Update app.py

app.py

@@ -1,5 +1,6 @@
+import streamlit as st
 from streamlit_ace import st_ace
-from transformers import pipeline, AutoTokenizer, AutoModelForSeq2SeqLM
+from transformers import pipeline, AutoTokenizer, AutoModelForSeq2SeqLM, AutoModelForCausalLM
 import os
 import subprocess
 import black
@@ -10,12 +11,10 @@ import torch
 from huggingface_hub import hf_hub_url, cached_download, HfApi
 import re
 from typing import List, Dict
-import streamlit as st # This import is sufficient
 from streamlit_jupyter import StreamlitPatcher, tqdm
 
 StreamlitPatcher().jupyter()  # This patches Streamlit to work in Jupyter
 
-
 # Access Hugging Face API key from secrets
 hf_token = st.secrets["hf_token"]
 if not hf_token:
@@ -39,13 +38,28 @@ if 'available_agents' not in st.session_state:
 # AI Guide Toggle
 ai_guide_level = st.sidebar.radio("AI Guide Level", ["Full Assistance", "Partial Assistance", "No Assistance"])
 
+class TextGenerationTool:
+    def __init__(self, llm: str):
+        self.llm = llm
+        self.tokenizer = AutoTokenizer.from_pretrained(llm)
+        self.model = AutoModelForCausalLM.from_pretrained(llm)
+
+    def generate_text(self, prompt: str, max_length: int = 50) -> str:
+        inputs = self.tokenizer(prompt, return_tensors="pt")
+        outputs = self.model.generate(**inputs, max_length=max_length)
+        return self.tokenizer.decode(outputs[0], skip_special_tokens=True)
+
 class AIAgent:
-    def __init__(self, name: str, description: str, skills: List[str]):
+    def __init__(self, name: str, description: str, skills: List[str], llm: str):
         self.name = name
         self.description = description
         self.skills = skills
+        self.text_gen_tool = TextGenerationTool(llm)
         self._hf_api = HfApi()  # Initialize HfApi here
 
+    def generate_agent_response(self, prompt: str) -> str:
+        return self.text_gen_tool.generate_text(prompt)
+
     def create_agent_prompt(self) -> str:
         skills_str = '\n'.join([f"* {skill}" for skill in self.skills])
         agent_prompt = f"""
@@ -63,7 +77,6 @@ I am confident that I can leverage my expertise to assist you in developing and
         return summary, next_step
 
     def deploy_built_space_to_hf(self, project_name: str) -> str:
-        # Assuming you have a function that generates the space content
         space_content = generate_space_content(project_name)
         repository = self._hf_api.create_repo(
             repo_id=project_name, 
@@ -173,278 +186,173 @@ def lint_code(code: str) -> List[str]:
     sys.stdout = pylint_output
     
     # Run pylint on the provided code
-    pylint.lint.Run(['--from-stdin'], do_exit=False, argv=[], stdin=StringIO(code))
+    pylint.lint.Run(['--from-stdin'], do_exit=False, input=code)
     
-    # Reset stdout and fetch lint results
+    # Reset stdout
     sys.stdout = sys.__stdout__
-    lint_results = pylint_output.getvalue().splitlines()
-    return lint_results
-
-# Sidebar for chat interface
-st.sidebar.title("Chat Interface")
-user_input = st.sidebar.text_area("Type your idea, task, or request here:")
-
-# Placeholder function to simulate code generation
-def generate_code(user_input):
-    return f"# Generated code for: {user_input}\nprint('Hello, World!')"
-
-# Main layout
-col1, col2 = st.columns([1, 3])
-
-with col1:
-    st.title("Code Editor")
-    if user_input:
-        code = generate_code(user_input)
-    else:
-        code = ""
-    code = st_ace(value=code, language='python', theme='monokai', height=400)
-
-with col2:
-    st.title("Jupyter IPython Console")
-    st_jupyter()
-    st.title("Read-Only Terminal")
-    st.text_area("Terminal Output", height=200)
-
-# Placeholder for autonomous agent logic
-if user_input:
-    st.sidebar.write("Processing your request...")
-
-    # Example: Generate a simple "Hello, World!" Streamlit app
-    generated_code = code_generator(f"Create a Streamlit app that displays 'Hello, World!'", max_new_tokens=50, num_return_sequences=1)[0]['generated_text']
-    st.sidebar.write("Generated code:")
-    st.sidebar.code(generated_code, language="python")
-
-    # Update the code editor
-    code = generated_code
-    # ... (Additional logic for code analysis, project management, etc.)
-
-    # ... (Update the Jupyter console and terminal output as needed)
-
-    # ... (Interact with the AI guide chatbot)
+    
+    # Extract pylint messages
+    messages = pylint_output.getvalue().splitlines()
+    
+    return messages
+
+def format_code(code: str) -> str:
+    # Format code using Black
+    formatted_code = black.format_str(code, mode=black.FileMode())
+    return formatted_code
+
+def main():
+    st.title("Streamlit Workspace")
+
+    # Load agents from the agent directory
+    agent_files = [f for f in os.listdir(AGENT_DIRECTORY) if f.endswith(".py")]
+    for agent_file in agent_files:
+        agent_module = __import__(f"{AGENT_DIRECTORY}.{os.path.splitext(agent_file)[0]}")
+        agent_class = getattr(agent_module, os.path.splitext(agent_file)[0])
+        agent_instance = agent_class()
+        st.session_state.available_agents.append(agent_instance)
+
+    # Display the available agents
+    st.subheader("Available Agents")
+    for agent in st.session_state.available_agents:
+        st.write(f"**{agent.name}**: {agent.description}")
+
+    # Select an agent
+    selected_agent = st.selectbox("Select an Agent", [agent.name for agent in st.session_state.available_agents])
+    current_agent = next((agent for agent in st.session_state.available_agents if agent.name == selected_agent), None)
+
+    # Display the agent's prompt
+    if current_agent:
+        st.subheader(f"{current_agent.name} Prompt")
+        st.write(current_agent.create_agent_prompt())
+
+    # Workspace Tab
+    st.subheader("Workspace")
+    workspace_tabs = st.tabs(["Chat", "Tool Box", "Projects"])
+
+    with workspace_tabs[0]:
+        # Chat Tab
+        st.subheader("Chat with your Agent")
+        user_input = st.text_input("Enter your message:")
+
+        if user_input:
+            st.session_state.chat_history.append((user_input, current_agent.generate_agent_response(user_input)))
+            user_input = ""  # Clear the input field
+
+        # Display chat history
+        st.markdown(display_chat_history(st.session_state.chat_history))
+
+        # AI Guide
+        if ai_guide_level != "No Assistance":
+            st.subheader("AI Guide")
+            guide_chat_history = []
+            if ai_guide_level == "Full Assistance":
+                guide_chat_history.append((
+                    "I'm building a Streamlit app to display data from a CSV file.",
+                    "Great! Let's start by creating a new project in the workspace."
+                ))
+                guide_chat_history.append((
+                    "Create a new project called 'data_app'.",
+                    "Okay, I've created the project 'data_app'. What would you like to name the main file?"
+                ))
+                guide_chat_history.append((
+                    "Name it 'app.py'.",
+                    "Alright, I've added an empty 'app.py' file to the 'data_app' project. Now, let's add some code to read the CSV file."
+                ))
+                guide_chat_history.append((
+                    "Add the following code to 'app.py':\n```python\nimport pandas as pd\nimport streamlit as st\n\ndata = pd.read_csv('data.csv')\nst.write(data)\n```",
+                    "Excellent! Now you can run this code to see the data from your CSV file in the Streamlit app."
+                ))
+            elif ai_guide_level == "Partial Assistance":
+                guide_chat_history.append((
+                    "How can I read data from a CSV file in Streamlit?",
+                    "You can use the `pandas` library to read the CSV file and then use `streamlit.write()` to display it."
+                ))
+            display_ai_guide_chat(guide_chat_history)
+
+    with workspace_tabs[1]:
+        # Tool Box Tab
+        st.subheader("Tool Box")
+        tool_tabs = st.tabs(["Code Editor", "Terminal", "Code Analysis"])
+
+        with tool_tabs[0]:
+            # Code Editor Tab
+            st.subheader("Code Editor")
+            code_editor = st_ace(
+                placeholder="Write your code here...",
+                height=300,
+                theme="monokai",
+                key="code_editor",
+                language="python",
+                auto_update=True
+            )
+
+            st.button("Run Code", on_click=lambda: st.write(run_code(code_editor)))
+
+            # Code Completion
+            st.subheader("Code Completion")
+            completion_prompt = st.text_area("Enter code for completion:")
+            if completion_prompt:
+                completed_code = get_code_completion(completion_prompt)
+                st.write(f"**Completion:** {completed_code}")
+
+        with tool_tabs[1]:
+            # Terminal Tab
+            st.subheader("Terminal")
+            terminal_input = st.text_input("Enter a command:")
+
+            if terminal_input:
+                st.session_state.terminal_history.append(terminal_input)
+                st.write(run_code(terminal_input))
+                terminal_input = ""  # Clear the input field
+
+            # Display terminal history
+            st.markdown("\n".join(st.session_state.terminal_history))
+
+        with tool_tabs[2]:
+            # Code Analysis Tab
+            st.subheader("Code Analysis")
+            code_to_analyze = st.text_area("Enter code to analyze:")
+            if code_to_analyze:
+                # Analyze code
+                analysis_results = analyze_code(code_to_analyze)
+                if analysis_results:
+                    st.write("**Code Analysis Results:**")
+                    for hint in analysis_results:
+                        st.write(f"- {hint}")
+                else:
+                    st.write("No code analysis suggestions found.")
+
+                # Lint code
+                lint_results = lint_code(code_to_analyze)
+                if lint_results:
+                    st.write("**Linting Results:**")
+                    for message in lint_results:
+                        st.write(f"- {message}")
+                else:
+                    st.write("No linting issues found.")
+
+                # Format code
+                formatted_code = format_code(code_to_analyze)
+                st.write("**Formatted Code:**")
+                st.code(formatted_code, language="python")
+
+    with workspace_tabs[2]:
+        # Projects Tab
+        st.subheader("Projects")
+        project_name = st.text_input("Enter project name:")
+        if st.button("Create Project"):
+            st.write(workspace_interface(project_name))
+
+        # Display existing projects
+        st.markdown(display_workspace_projects(st.session_state.workspace_projects))
+
+        # Add code to a project
+        selected_project = st.selectbox("Select a project", list(st.session_state.workspace_projects.keys()))
+        code_to_add = st.text_area("Enter code to add:")
+        file_name = st.text_input("Enter file name:")
+        if st.button("Add Code"):
+            st.write(add_code_to_workspace(selected_project, code_to_add, file_name))
 
 if __name__ == "__main__":
-    st.sidebar.title("Navigation")
-    app_mode = st.sidebar.selectbox("Choose the app mode", ["Home", "Terminal", "Explorer", "Code Editor", "Build & Deploy"])
-
-    if app_mode == "Home":
-        st.title("Welcome to AI-Guided Development")
-        st.write("This application helps you build and deploy applications with the assistance of an AI Guide.")
-        st.write("Toggle the AI Guide from the sidebar to choose the level of assistance you need.")
-
-    elif app_mode == "Terminal":
-        st.header("Terminal")
-        terminal_input = st.text_input("Enter a command:")
-        if st.button("Run"):
-            output = run_code(terminal_input)
-            st.session_state.terminal_history.append((terminal_input, output))
-            st.code(output, language="bash")
-        if ai_guide_level != "No Assistance":
-            st.write("Run commands here to add packages to your project. For example: pip install <package-name>.")
-            if terminal_input and "install" in terminal_input:
-                package_name = terminal_input.split("install")[-1].strip()
-                st.write(f"Package {package_name} will be added to your project.")
-
-    elif app_mode == "Explorer":
-        st.header("Explorer")
-        uploaded_file = st.file_uploader("Upload a file", type=["py"])
-        if uploaded_file:
-            file_details = {"FileName": uploaded_file.name, "FileType": uploaded_file.type}
-            st.write(file_details)
-            save_path = os.path.join(PROJECT_ROOT, uploaded_file.name)
-            with open(save_path, "wb") as f:
-                f.write(uploaded_file.getbuffer())
-            st.success(f"File {uploaded_file.name} saved successfully!")
-
-        st.write("Drag and drop files into the 'app' folder.")
-        for project, details in st.session_state.workspace_projects.items():
-            st.write(f"Project: {project}")
-            for file in details['files']:
-                st.write(f"  - {file}")
-                if st.button(f"Move {file} to app folder"):
-                    # Logic to move file to 'app' folder
-                    pass
-        if ai_guide_level != "No Assistance":
-            st.write("You can upload files and move them into the 'app' folder for building your application.")
-
-    elif app_mode == "Code Editor":
-        st.header("Code Editor")
-        code_editor = st.text_area("Write your code:", height=300)
-        if st.button("Save Code"):
-            # Logic to save code
-            pass
-        if ai_guide_level != "No Assistance":
-            st.write("The function foo() requires the bar package. Add it to requirements.txt.")
-
-        # Analyze code and provide real-time hints
-        hints = analyze_code(code_editor)
-        if hints:
-            st.write("**Helpful Hints:**")
-            for hint in hints:
-                st.write(f"- {hint}")
-
-        if st.button("Get Code Suggestion"):
-            # Provide a predictive code completion
-            completion = get_code_completion(code_editor)
-            st.write("**Suggested Code Completion:**")
-            st.code(completion, language="python")
-
-        if st.button("Check Code"):
-            # Analyze the code for errors and warnings
-            lint_results = lint_code(code_editor)
-
-            if lint_results:
-                st.write("**Errors and Warnings:**")
-                for result in lint_results:
-                    st.write(result)
-            else:
-                st.write("No issues found! Your code is clean.")
-
-    elif app_mode == "Build & Deploy":
-        st.header("Build & Deploy")
-        project_name_input = st.text_input("Enter Project Name for Automation:")
-        if st.button("Automate"):
-            selected_agent = st.selectbox("Select an AI agent", st.session_state.available_agents)
-            selected_model = st.selectbox("Select a code-generative model", AVAILABLE_CODE_GENERATIVE_MODELS)
-            agent = AIAgent(selected_agent, "", [])  # Load the agent without skills for now
-            summary, next_step = agent.autonomous_build(st.session_state.chat_history, st.session_state.workspace_projects, project_name_input, selected_model, hf_token)
-            st.write("Autonomous Build Summary:")
-            st.write(summary)
-            st.write("Next Step:")
-            st.write(next_step)
-            if agent._hf_api and agent.has_valid_hf_token():
-                repository_name = agent.deploy_built_space_to_hf(project_name_input)
-                st.markdown("## Congratulations! Successfully deployed Space 🚀 ##")
-                st.markdown(f"[Check out your new Space here](hf.co/{repository_name})")
-
-    # AI Guide Chat
-    if ai_guide_level != "No Assistance":
-        display_ai_guide_chat(st.session_state.chat_history)
-        # Add a text input for user to interact with the AI Guide
-        user_input = st.text_input("Ask the AI Guide a question:", key="user_input")
-        if st.button("Send"):
-            if user_input:
-                # Process the user's input and get a response from the AI Guide
-                agent_response = process_input(user_input)
-                st.session_state.chat_history.append((user_input, agent_response))
-                # Clear the user input field
-                st.session_state.user_input = ""
-
-    # CSS for styling
-    st.markdown("""
-    <style>
-    /* Advanced and Accommodating CSS */
-    body {
-        font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
-        background-color: #f4f4f9;
-        color: #333;
-        margin: 0;
-        padding: 0;
-    }
-    h1, h2, h3, h4, h5, h6 {
-        color: #333;
-    }
-    .container {
-        width: 90%;
-        margin: 0 auto;
-        padding: 20px;
-    }
-    /* Navigation Sidebar */
-    .sidebar {
-        background-color: #2c3e50;
-        color: #ecf0f1;
-        padding: 20px;
-        height: 100vh;
-        position: fixed;
-        top: 0;
-        left: 0;
-        width: 250px;
-        overflow-y: auto;
-    }
-    .sidebar a {
-        color: #ecf0f1;
-        text-decoration: none;
-        display: block;
-        padding: 10px 0;
-    }
-    .sidebar a:hover {
-        background-color: #34495e;
-        border-radius: 5px;
-    }
-    /* Main Content */
-    .main-content {
-        margin-left: 270px;
-        padding: 20px;
-    }
-    /* Buttons */
-    button {
-        background-color: #3498db;
-        color: #fff;
-        border: none;
-        padding: 10px 20px;
-        border-radius: 5px;
-        cursor: pointer;
-        font-size: 16px;
-    }
-    button:hover {
-        background-color: #2980b9;
-    }
-    /* Text Areas and Inputs */
-    textarea, input[type="text"] {
-        width: 100%;
-        padding: 10px;
-        margin: 10px 0;
-        border: 1px solid #ddd;
-        border-radius: 5px;
-        box-sizing: border-box;
-    }
-    textarea:focus, input[type="text"]:focus {
-        border-color: #3498db;
-        outline: none;
-    }
-    /* Terminal Output */
-    .code-output {
-        background-color: #1e1e1e;
-        color: #dcdcdc;
-        padding: 20px;
-        border-radius: 5px;
-        font-family: 'Courier New', Courier, monospace;
-    }
-    /* Chat History */
-    .chat-history {
-        background-color: #ecf0f1;
-        padding: 20px;
-        border-radius: 5px;
-        max-height: 300px;
-        overflow-y: auto;
-    }
-    .chat-message {
-        margin-bottom: 10px;
-    }
-    .chat-message.user {
-        text-align: right;
-        color: #3498db;
-    }
-    .chat-message.agent {
-        text-align: left;
-        color: #e74c3c;
-    }
-    /* Project Management */
-    .project-list {
-        background-color: #ecf0f1;
-        padding: 20px;
-        border-radius: 5px;
-        max-height: 300px;
-        overflow-y: auto;
-    }
-    .project-item {
-        margin-bottom: 10px;
-    }
-    .project-item a {
-        color: #3498db;
-        text-decoration: none;
-    }
-    .project-item a:hover {
-        text-decoration: underline;
-    }
-    </style>
-    """, unsafe_allow_html=True)
+    main()