Update app.py

app.py

@@ -21,10 +21,13 @@ if not hf_token:
     st.error("Hugging Face API key not found. Please make sure it is set in the secrets.")
 
 HUGGING_FACE_REPO_URL = "https://huggingface.co/spaces/acecalisto3/0shotTest"
-PROJECT_ROOT = "projects"
-AGENT_DIRECTORY = "agents"
+PROJECT_ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), 'user_projects'))
 AVAILABLE_CODE_GENERATIVE_MODELS = ["bigcode/starcoder", "Salesforce/codegen-350M-mono", "microsoft/CodeGPT-small"]
 
+# Create PROJECT_ROOT if it doesn't exist
+if not os.path.exists(PROJECT_ROOT):
+    os.makedirs(PROJECT_ROOT)
+
 # Global state management
 if 'chat_history' not in st.session_state:
     st.session_state.chat_history = []
@@ -32,8 +35,8 @@ if 'terminal_history' not in st.session_state:
     st.session_state.terminal_history = []
 if 'workspace_projects' not in st.session_state:
     st.session_state.workspace_projects = {}
-if 'available_agents' not in st.session_state:
-    st.session_state.available_agents = []
+if 'current_project' not in st.session_state:
+    st.session_state.current_project = None
 
 # AI Guide Toggle
 ai_guide_level = st.sidebar.radio("AI Guide Level", ["Full Assistance", "Partial Assistance", "No Assistance"])
@@ -42,27 +45,15 @@ ai_guide_level = st.sidebar.radio("AI Guide Level", ["Full Assistance", "Partial
 code_generator_tokenizer = AutoTokenizer.from_pretrained("microsoft/CodeGPT-small-py", clean_up_tokenization_spaces=True)
 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):
+    def __init__(self, name: str, description: str, skills: List[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)
+        # For now, we'll use a simple response. In a real implementation, you'd use a more sophisticated model.
+        return f"Agent {self.name} responding to: {prompt}"
 
     def create_agent_prompt(self) -> str:
         skills_str = '\n'.join([f"* {skill}" for skill in self.skills])
@@ -73,230 +64,90 @@ I am confident that I can leverage my expertise to assist you in developing and
 """
         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 create_project(self, 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_file_to_project(self, project_name: str, file_name: str, content: 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(content)
+        st.session_state.workspace_projects[project_name]['files'].append(file_name)
+        return f"File '{file_name}' added to project '{project_name}'."
+
+    def modify_file_in_project(self, project_name: str, file_name: str, content: str) -> str:
+        project_path = os.path.join(PROJECT_ROOT, project_name)
+        file_path = os.path.join(project_path, file_name)
+        if not os.path.exists(file_path):
+            return f"File '{file_name}' does not exist in project '{project_name}'."
+        
+        with open(file_path, "w") as file:
+            file.write(content)
+        return f"File '{file_name}' in project '{project_name}' has been modified."
 
-def format_code(code: str) -> str:
-    formatted_code = black.format_str(code, mode=black.FileMode())
-    return formatted_code
+# Initialize some example agents
+example_agents = [
+    AIAgent("WebDev Wizard", "Full-stack web development expert", ["HTML", "CSS", "JavaScript", "React", "Node.js"]),
+    AIAgent("Data Scientist", "Machine learning and data analysis specialist", ["Python", "Pandas", "Scikit-learn", "TensorFlow"]),
+    AIAgent("DevOps Guru", "Infrastructure and deployment expert", ["Docker", "Kubernetes", "AWS", "CI/CD"])
+]
 
 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())
+    st.title("AI-Guided Workspace")
+
+    # Sidebar for project selection and creation
+    st.sidebar.header("Project Management")
+    project_name = st.sidebar.text_input("Enter project name:")
+    if st.sidebar.button("Create Project"):
+        result = example_agents[0].create_project(project_name)
+        st.sidebar.write(result)
+    
+    projects = list(st.session_state.workspace_projects.keys())
+    selected_project = st.sidebar.selectbox("Select a project", projects, index=0 if projects else None)
+    if selected_project:
+        st.session_state.current_project = selected_project
 
-    # Workspace Tab
-    st.subheader("Workspace")
-    workspace_tabs = st.tabs(["Chat", "Tool Box", "Projects"])
+    # Main area
+    if st.session_state.current_project:
+        st.header(f"Current Project: {st.session_state.current_project}")
 
-    with workspace_tabs[0]:
-        # Chat Tab
-        st.subheader("Chat with your Agent")
+        # Chat with AI Agent
+        st.subheader("Chat with AI 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
+        if st.button("Send"):
+            agent_response = example_agents[0].generate_agent_response(user_input)
+            st.session_state.chat_history.append((user_input, agent_response))
 
         # 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((
-                    "I'm building a Streamlit app to display data from a CSV file.",
-                    "That's a great project! Let me know if you need any help with specific parts of the implementation."
-                ))
-            
-            st.markdown(display_chat_history(guide_chat_history))
+        for user, agent in st.session_state.chat_history:
+            st.text(f"You: {user}")
+            st.text(f"Agent: {agent}")
 
-    with workspace_tabs[1]:
-        # Tool Box Tab
-        st.subheader("Tool Box")
-        
         # Code Editor
         st.subheader("Code Editor")
+        file_name = st.text_input("File name:")
         code = st_ace(language="python", theme="monokai", key="code_editor")
-        
-        # Code Analysis
-        if st.button("Analyze Code"):
-            hints = analyze_code(code)
-            for hint in hints:
-                st.info(hint)
-        
-        # Code Completion
-        if st.button("Get 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")
+        if st.button("Save File"):
+            result = example_agents[0].add_file_to_project(st.session_state.current_project, file_name, code)
+            st.write(result)
 
-    with workspace_tabs[2]:
-        # Projects Tab
-        st.subheader("Projects")
-        st.markdown(display_workspace_projects(st.session_state.workspace_projects))
+        # Display project files
+        st.subheader("Project Files")
+        if st.session_state.current_project in st.session_state.workspace_projects:
+            for file in st.session_state.workspace_projects[st.session_state.current_project]['files']:
+                st.text(file)
 
-        # 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)
-
-        # 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)
+    else:
+        st.write("Please create or select a project to get started.")
 
 if __name__ == "__main__":
     main()