Update app.py

app.py

@@ -1,6 +1,7 @@
 import streamlit as st
 from streamlit_ace import st_ace
-from transformers import pipeline, AutoTokenizer
+from transformers import pipeline, AutoTokenizer, AutoModelForCausalLM
+from huggingface_hub import HfApi
 import os
 import subprocess
 import black
@@ -10,21 +11,6 @@ import sys
 import re
 from typing import List, Dict
 from streamlit_jupyter import StreamlitPatcher, tqdm
-from .agents import (
-    TextGenerationTool,
-    AIAgent,
-    process_input,
-    run_code,
-    workspace_interface,
-    add_code_to_workspace,
-    display_chat_history,
-    display_workspace_projects,
-    generate_space_content,
-    analyze_code,
-    get_code_completion,
-    lint_code,
-    format_code
-)
 
 # This line should be at the top of your script
 StreamlitPatcher().jupyter()  # This patches Streamlit to work in Jupyter
@@ -39,7 +25,7 @@ PROJECT_ROOT = "projects"
 AGENT_DIRECTORY = "agents"
 AVAILABLE_CODE_GENERATIVE_MODELS = ["bigcode/starcoder", "Salesforce/codegen-350M-mono", "microsoft/CodeGPT-small"]
 
-# Global state to manage communication between Tool Box and Workspace Chat App
+# Global state management
 if 'chat_history' not in st.session_state:
     st.session_state.chat_history = []
 if 'terminal_history' not in st.session_state:
@@ -52,11 +38,147 @@ 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"])
 
-# Load the CodeGPT tokenizer explicitly
+# Load the CodeGPT tokenizer and model
 code_generator_tokenizer = AutoTokenizer.from_pretrained("microsoft/CodeGPT-small-py", clean_up_tokenization_spaces=True)
-# Load the CodeGPT model for code completion
 code_generator = pipeline("text-generation", model="microsoft/CodeGPT-small-py", tokenizer=code_generator_tokenizer)
 
+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], llm: str):
+        self.name = name
+        self.description = description
+        self.skills = skills
+        self.text_gen_tool = TextGenerationTool(llm)
+        self._hf_api = HfApi()
+
+    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"""
+As an elite expert developer, my name is {self.name}. I possess a comprehensive understanding of the following areas:
+{skills_str}
+I am confident that I can leverage my expertise to assist you in developing and deploying cutting-edge web applications. Please feel free to ask any questions or present any challenges you may encounter.
+"""
+        return agent_prompt
+
+    def autonomous_build(self, chat_history: List[tuple[str, str]], workspace_projects: Dict[str, Dict], 
+                        project_name: str, selected_model: str, hf_token: str) -> tuple[str, str]:
+        summary = "Chat History:\n" + "\n".join([f"User: {u}\nAgent: {a}" for u, a in chat_history])
+        summary += "\n\nWorkspace Projects:\n" + "\n".join([f"{p}: {details}" for p, details in workspace_projects.items()])
+        next_step = "Based on the current state, the next logical step is to implement the main application logic."
+        return summary, next_step
+
+    def deploy_built_space_to_hf(self, project_name: str) -> str:
+        space_content = generate_space_content(project_name)
+        repository = self._hf_api.create_repo(
+            repo_id=project_name, 
+            private=True,
+            token=hf_token,
+            exist_ok=True,
+            space_sdk="streamlit"
+        )
+        self._hf_api.upload_file(
+            path_or_fileobj=space_content,
+            path_in_repo="app.py",
+            repo_id=project_name,
+            repo_type="space",
+            token=hf_token
+        )
+        return repository.name
+
+    def has_valid_hf_token(self) -> bool:
+        return self._hf_api.whoami(token=hf_token) is not None
+
+def process_input(input_text: str) -> str:
+    chatbot = pipeline("text-generation", model="microsoft/DialoGPT-medium", tokenizer="microsoft/DialoGPT-medium", clean_up_tokenization_spaces=True)
+    response = chatbot(input_text, max_length=50, num_return_sequences=1)[0]['generated_text']
+    return response
+
+def run_code(code: str) -> str:
+    try:
+        result = subprocess.run(code, shell=True, capture_output=True, text=True)
+        return result.stdout
+    except Exception as e:
+        return str(e)
+
+def workspace_interface(project_name: str) -> str:
+    project_path = os.path.join(PROJECT_ROOT, project_name)
+    if not os.path.exists(project_path):
+        os.makedirs(project_path)
+        st.session_state.workspace_projects[project_name] = {'files': []}
+        return f"Project '{project_name}' created successfully."
+    else:
+        return f"Project '{project_name}' already exists."
+
+def add_code_to_workspace(project_name: str, code: str, file_name: str) -> str:
+    project_path = os.path.join(PROJECT_ROOT, project_name)
+    if not os.path.exists(project_path):
+        return f"Project '{project_name}' does not exist."
+    
+    file_path = os.path.join(project_path, file_name)
+    with open(file_path, "w") as file:
+        file.write(code)
+    st.session_state.workspace_projects[project_name]['files'].append(file_name)
+    return f"Code added to '{file_name}' in project '{project_name}'."
+
+def display_chat_history(chat_history: List[tuple[str, str]]) -> str:
+    return "\n".join([f"User: {u}\nAgent: {a}" for u, a in chat_history])
+
+def display_workspace_projects(workspace_projects: Dict[str, Dict]) -> str:
+    return "\n".join([f"{p}: {details}" for p, details in workspace_projects.items()])
+
+def generate_space_content(project_name: str) -> str:
+    return "import streamlit as st\nst.title('My Streamlit App')\nst.write('Hello, world!')"
+
+def analyze_code(code: str) -> List[str]:
+    hints = []
+    
+    if re.search(r'for .* in .*:\n\s+.*\.append\(', code):
+        hints.append("Consider using a list comprehension instead of a loop for appending to a list.")
+    
+    if re.search(r'\".*\%s\"|\'.*\%s\'', code) or re.search(r'\".*\%d\"|\'.*\%d\'', code):
+        hints.append("Consider using f-strings for cleaner and more efficient string formatting.")
+    
+    if re.search(r'\bglobal\b', code):
+        hints.append("Avoid using global variables. Consider passing parameters or using classes.")
+    
+    if re.search(r'open\(.+\)', code) and not re.search(r'with open\(.+\)', code):
+        hints.append("Consider using the `with` statement when opening files to ensure proper resource management.")
+    
+    return hints
+
+def get_code_completion(prompt: str) -> str:
+    completions = code_generator(prompt, max_new_tokens=50, num_return_sequences=1) 
+    return completions[0]['generated_text']
+
+def lint_code(code: str) -> List[str]:
+    pylint_output = StringIO()
+    sys.stdout = pylint_output
+    
+    lint.Run(['--from-stdin'], do_exit=False, input=code)
+    
+    sys.stdout = sys.__stdout__
+    
+    messages = pylint_output.getvalue().splitlines()
+    
+    return messages
+
+def format_code(code: str) -> str:
+    formatted_code = black.format_str(code, mode=black.FileMode())
+    return formatted_code
+
 def main():
     st.title("Streamlit Workspace")
 
@@ -122,51 +244,59 @@ def main():
             elif ai_guide_level == "Partial 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."
+                    "That's a great project! Let me know if you need any help with specific parts of the implementation."
                 ))
-
-            display_ai_guide_chat(guide_chat_history)
+            
+            st.markdown(display_chat_history(guide_chat_history))
 
     with workspace_tabs[1]:
         # Tool Box Tab
         st.subheader("Tool Box")
-        code_input = st_ace(language='python', theme='monokai', key='code_input')
-        if st.button("Run Code"):
-            output = run_code(code_input)
-            st.text_area("Output", output, height=200)
-
+        
+        # Code Editor
+        st.subheader("Code Editor")
+        code = st_ace(language="python", theme="monokai", key="code_editor")
+        
+        # Code Analysis
         if st.button("Analyze Code"):
-            hints = analyze_code(code_input)
-            st.text_area("Hints", "\n".join(hints), height=200)
-
-        if st.button("Format Code"):
-            formatted_code = format_code(code_input)
-            st_ace(value=formatted_code, language='python', theme='monokai', key='formatted_code')
-
-        if st.button("Lint Code"):
-            lint_messages = lint_code(code_input)
-            st.text_area("Lint Messages", "\n".join(lint_messages), height=200)
-
+            hints = analyze_code(code)
+            for hint in hints:
+                st.info(hint)
+        
+        # Code Completion
         if st.button("Get Code Completion"):
-            completion = get_code_completion(code_input)
-            st_ace(value=completion, language='python', theme='monokai', key='code_completion')
+            completion = get_code_completion(code)
+            st.code(completion, language="python")
+        
+        # Code Linting
+        if st.button("Lint Code"):
+            lint_messages = lint_code(code)
+            for message in lint_messages:
+                st.warning(message)
+        
+        # Code Formatting
+        if st.button("Format Code"):
+            formatted_code = format_code(code)
+            st.code(formatted_code, language="python")
 
     with workspace_tabs[2]:
         # Projects Tab
         st.subheader("Projects")
-        project_name = st.text_input("Project Name")
-        if st.button("Create Project"):
-            message = workspace_interface(project_name)
-            st.write(message)
+        st.markdown(display_workspace_projects(st.session_state.workspace_projects))
 
-        file_name = st.text_input("File Name")
-        code_content = st_ace(language='python', theme='monokai', key='code_content')
-        if st.button("Add Code to Project"):
-            message = add_code_to_workspace(project_name, code_content, file_name)
-            st.write(message)
+        # Create new project
+        new_project = st.text_input("Enter new project name:")
+        if st.button("Create Project"):
+            result = workspace_interface(new_project)
+            st.success(result)
 
-        st.subheader("Workspace Projects")
-        st.markdown(display_workspace_projects(st.session_state.workspace_projects))
+        # Add code to project
+        project_name = st.selectbox("Select project", list(st.session_state.workspace_projects.keys()))
+        file_name = st.text_input("Enter file name:")
+        code_to_add = st.text_area("Enter code:")
+        if st.button("Add Code"):
+            result = add_code_to_workspace(project_name, code_to_add, file_name)
+            st.success(result)
 
 if __name__ == "__main__":
     main()