Update app.py

app.py

@@ -1,31 +1,29 @@
+🧠
+gemini-1.5-flash-latest
+import streamlit as st
+from streamlit_ace import st_ace
+from streamlit_jupyter import st_jupyter
+from transformers import pipeline, AutoTokenizer, AutoModelForSeq2SeqLM
 import os
 import subprocess
-import logging
-import streamlit as st
-from transformers import pipeline, AutoModelForCausalLM, AutoTokenizer, AutoModel, RagRetriever, AutoModelForSeq2SeqLM
+import black
+from pylint import lint
+from io import StringIO
+import sys
 import torch
-from datetime import datetime
 from huggingface_hub import hf_hub_url, cached_download, HfApi
-from dotenv import load_dotenv
+import re
+from typing import List, Dict
+
+# Access Hugging Face API key from secrets
+hf_token = st.secrets["hf_token"]
+if not hf_token:
+    st.error("Hugging Face API key not found. Please make sure it is set in the secrets.")
 
-# Constants
 HUGGING_FACE_REPO_URL = "https://huggingface.co/spaces/acecalisto3/DevToolKit"
 PROJECT_ROOT = "projects"
 AGENT_DIRECTORY = "agents"
-AVAILABLE_CODE_GENERATIVE_MODELS = [
-    "bigcode/starcoder",  # Popular and powerful
-    "Salesforce/codegen-350M-mono",  # Smaller, good for quick tasks
-    "microsoft/CodeGPT-small",  # Smaller, good for quick tasks
-    "google/flan-t5-xl",  # Powerful, good for complex tasks
-    "facebook/bart-large-cnn",  # Good for text-to-code tasks
-]
-
-# Load environment variables
-load_dotenv()
-HF_TOKEN = os.getenv("HUGGING_FACE_API_KEY")
-
-# Initialize logger
-logging.basicConfig(level=logging.INFO)
+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
 if 'chat_history' not in st.session_state:
@@ -36,296 +34,374 @@ 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_state' not in st.session_state:
-    st.session_state.current_state = {
-        'toolbox': {},
-        'workspace_chat': {}
-    }
-
-# Load pre-trained RAG retriever
-rag_retriever = RagRetriever.from_pretrained("facebook/rag-token-base")  # Use a Hugging Face RAG model
-
-# Load pre-trained chat model
-chat_model = AutoModelForSeq2SeqLM.from_pretrained("microsoft/DialoGPT-medium")  # Use a Hugging Face chat model
 
-# Load tokenizer
-tokenizer = AutoTokenizer.from_pretrained("microsoft/DialoGPT-medium")
+# AI Guide Toggle
+ai_guide_level = st.sidebar.radio("AI Guide Level", ["Full Assistance", "Partial Assistance", "No Assistance"])
 
-# Define a class for the AI Agent
 class AIAgent:
-    def __init__(self, name, description, skills):
+    def __init__(self, name: str, description: str, skills: List[str]):
         self.name = name
         self.description = description
         self.skills = skills
+        self._hf_api = HfApi()  # Initialize HfApi here
+
+    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:
+        # 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, 
+            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)
 
-# Define a function to process user input
-def process_input(user_input):
-    # Input pipeline: Tokenize and preprocess user input
-    input_ids = tokenizer(user_input, return_tensors="pt").input_ids
-    attention_mask = tokenizer(user_input, return_tensors="pt").attention_mask
-
-    # RAG model: Generate response
-    output = rag_retriever(input_ids, attention_mask=attention_mask)
-    response = output.generator_outputs[0].sequences[0]
-
-    # Chat model: Refine response
-    chat_input = tokenizer(response, return_tensors="pt")
-    chat_input["input_ids"] = chat_input["input_ids"].unsqueeze(0)
-    chat_input["attention_mask"] = chat_input["attention_mask"].unsqueeze(0)
-    output = chat_model(**chat_input)
-    refined_response = output.sequences[0]
-
-    # Output pipeline: Return final response
-    return refined_response
-
-# Define a function to create a new project
-def create_project(project_name):
+def workspace_interface(project_name: str) -> str:
     project_path = os.path.join(PROJECT_ROOT, project_name)
-    if os.path.exists(project_path):
-        return f"Project '{project_name}' already exists."
-    else:
+    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."
 
-# Define a function to add code to a project
-def add_code_to_project(project_name, code, file_name):
+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)
-    try:
-        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}'."
-    except Exception as e:
-        logging.error(f"Error adding code: {file_name}: {e}")
-        return f"Error adding code: {file_name}"
-
-# Define a function to run code
-def run_code(command, project_name=None):
-    if project_name:
-        project_path = os.path.join(PROJECT_ROOT, project_name)
-        result = subprocess.run(command, shell=True, capture_output=True, text=True, cwd=project_path)
-    else:
-        result = subprocess.run(command, shell=True, capture_output=True, text=True)
-    return result.stdout
-
-# Define a function to display chat history
-def display_chat_history(history):
-    chat_history = ""
-    for user_input, response in history:
-        chat_history += f"User: {user_input}\nAgent: {response}\n\n"
-    return chat_history
-
-# Define a function to display workspace projects
-def display_workspace_projects(projects):
-    workspace_projects = ""
-    for project, details in projects.items():
-        workspace_projects += f"Project: {project}\nFiles:\n"
-        for file in details['files']:
-            workspace_projects += f"  - {file}\n"
-    return workspace_projects
-
-# Define a function to download models
-def download_models():
-    for model in AVAILABLE_CODE_GENERATIVE_MODELS:
-        try:
-            cached_model = cached_download(model)
-            logging.info(f"Downloaded model '{model}' successfully.")
-        except Exception as e:
-            logging.error(f"Error downloading model '{model}': {e}")
-
-# Define a function to deploy a space to Hugging Face Hub
-def deploy_space_to_hf(project_name, hf_token):
-    repository_name = f"my-awesome-space_{datetime.now().timestamp()}"
-    files = get_built_space_files()
-    commit_response = deploy_to_git(project_name, repository_name, files)
-    if commit_response:
-        publish_space(repository_name, hf_token)
-        return f"Space '{repository_name}' deployed successfully."
-    else:
-        return "Failed to commit changes to Space."
-
-# Define a function to get built space files
-def get_built_space_files():
-    projects = st.session_state.workspace_projects
-    files = []
-    for project in projects.values():
-        for file in project['files']:
-            file_path = os.path.join(PROJECT_ROOT, project['project_name'], file)
-            with open(file_path, "rb") as file:
-                files.append(file.read())
-    return files
-
-# Define a function to deploy to Git
-def deploy_to_git(project_name, repository_name, files):
-    project_path = os.path.join(PROJECT_ROOT, project_name)
-    git_repo_url = hf_hub_url(repository_name)
-    git = subprocess.Popen(["git", "init"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, cwd=project_path)
-    git.communicate()
-
-    git = subprocess.Popen(["git", "add", "-A"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, cwd=project_path)
-    git.communicate()
-
-    for file in files:
-        filename = "temp.txt"
-        with open("temp.txt", "wb") as temp_file:
-            temp_file.write(file)
-            git = subprocess.Popen(["git", "add", filename], stdout=subprocess.PIPE, stderr=subprocess.PIPE, cwd=project_path)
-            git.communicate()
-            os.remove("temp.txt")
-
-    git = subprocess.Popen(["git", "commit", "-m", "Initial commit"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, cwd=project_path)
-    git.communicate()
-
-    return git.returncode == 0
-
-# Define a function to publish a space
-def publish_space(repository_name, hf_token):
-    api = HfApi(token=hf_token)
-    api.create_model(repository_name, files=[], push_to_hub=True)
-
-# Define a function to handle autonomous build
-def handle_autonomous_build():
-    if not st.session_state.workspace_projects or not st.session_state.available_agents:
-        st.error("No projects or agents available to build.")
-        return
-
-    project_name = list(st.session_state.workspace_projects.keys())[0]
-    selected_agent = st.session_state.available_agents[0]
-    code_idea = st.session_state.current_state["workspace_chat"]["user_input"]
-    code_generative_model = next((model for model in AVAILABLE_CODE_GENERATIVE_MODELS if model in st.session_state.current_state["toolbox"]["selected_models"]), None)
+    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:
+    # Logic to generate the Streamlit app content based on project_name
+    # ... (This is where you'll need to implement the actual code generation)
+    return "import streamlit as st\nst.title('My Streamlit App')\nst.write('Hello, world!')"
+
+# Function to display the AI Guide chat
+def display_ai_guide_chat(chat_history: List[tuple[str, str]]):
+    st.markdown("<div class='chat-history'>", unsafe_allow_html=True)
+    for user_message, agent_message in chat_history:
+        st.markdown(f"<div class='chat-message user'>{user_message}</div>", unsafe_allow_html=True)
+        st.markdown(f"<div class='chat-message agent'>{agent_message}</div>", unsafe_allow_html=True)
+    st.markdown("</div>", unsafe_allow_html=True)
+
+# Load the CodeGPT tokenizer explicitly
+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)
+
+def analyze_code(code: str) -> List[str]:
+    hints = []
+    
+    # Example pointer: Suggest using list comprehensions
+    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.")
+    
+    # Example pointer: Recommend using f-strings for string formatting
+    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.")
+    
+    # Example pointer: Avoid using global variables
+    if re.search(r'\bglobal\b', code):
+        hints.append("Avoid using global variables. Consider passing parameters or using classes.")
+    
+    # Example pointer: Recommend using `with` statement for file operations
+    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:
+    # Generate code completion based on the current code input
+    # Use max_new_tokens instead of max_length
+    completions = code_generator(prompt, max_new_tokens=50, num_return_sequences=1) 
+    return completions[0]['generated_text']
+
+def lint_code(code: str) -> List[str]:
+    # Capture pylint output
+    pylint_output = StringIO()
+    sys.stdout = pylint_output
+    
+    # Run pylint on the provided code
+    pylint.lint.Run(['--from-stdin'], do_exit=False, argv=[], stdin=StringIO(code))
+    
+    # Reset stdout and fetch lint results
+    sys.stdout = sys.__stdout__
+    lint_results = pylint_output.getvalue().splitlines()
+    return lint_results
 
-    if not code_generative_model:
-        st.error("No code-generative model selected.")
-        return
-
-    logging.info(f"Building project '{project_name}' with agent '{selected_agent}' and model '{code_generative_model}'.")
-
-    try:
-        # TODO: Add code to run the build process here
-        # This could include generating code, running it, and updating the workspace projects
-        # The build process should also update the UI with the build summary and next steps
-        summary, next_step = build_project(project_name, selected_agent, code_idea, code_generative_model)
-        st.write(f"Build summary: {summary}")
-        st.write(f"Next step: {next_step}")
-
-        if next_step == "Deploy to Hugging Face Hub":
-            deploy_response = deploy_space_to_hf(project_name, HF_TOKEN)
-            st.write(deploy_response)
-    except Exception as e:
-        logging.error(f"Error during build process: {e}")
-        st.error("Error during build process.")
-
-# Define a function to build a project
-def build_project(project_name, agent, code_idea, code_generative_model):
-    # TODO: Add code to build the project here
-    # This could include generating code, running it, and updating the workspace projects
-    # The build process should also return a summary and next step
-    summary = "Project built successfully."
-    next_step = ""
-    return summary, next_step
-
-# Define the main function
-def main():
-    # Initialize the app
-    st.title("AI Agent Creator")
-
-    # Sidebar navigation
+if __name__ == "__main__":
     st.sidebar.title("Navigation")
-    app_mode = st.sidebar.selectbox("Choose the app mode", ["AI Agent Creator", "Tool Box", "Workspace Chat App"])
-
-    if app_mode == "AI Agent Creator":
-        # AI Agent Creator
-        st.header("Create an AI Agent from Text")
-
-        st.subheader("From Text")
-        agent_name = st.text_input("Enter agent name:")
-        text_input = st.text_area("Enter skills (one per line):")
-        if st.button("Create Agent"):
-            skills = text_input.split('\n')
-            try:
-                agent = AIAgent(agent_name, "AI agent created from text input", skills)
-                st.session_state.available_agents.append(agent_name)
-                st.success(f"Agent '{agent_name}' created and saved successfully.")
-            except Exception as e:
-                st.error(f"Error creating agent: {e}")
-
-    elif app_mode == "Tool Box":
-        # Tool Box
-        st.header("AI-Powered Tools")
-
-        # Chat Interface
-        st.subheader("Chat with CodeCraft")
-        chat_input = st.text_area("Enter your message:")
-        if st.button("Send"):
-            response = process_input(chat_input)
-            st.session_state.chat_history.append((chat_input, response))
-            st.write(f"CodeCraft: {response}")
+    app_mode = st.sidebar.selectbox("Choose the app mode", ["Home", "Terminal", "Explorer", "Code Editor", "Build & Deploy"])
 
-        # Terminal Interface
-        st.subheader("Terminal")
+    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")
-
-        # Project Management
-        st.subheader("Project Management")
-        project_name_input = st.text_input("Enter Project Name:")
-        if st.button("Create Project"):
-            status = create_project(project_name_input)
-            st.write(status)
-
-        code_to_add = st.text_area("Enter Code to Add to Workspace:", height=150)
-        file_name_input = st.text_input("Enter File Name (e.g., 'app.py'):")
-        if st.button("Add Code"):
-            status = add_code_to_project(project_name_input, code_to_add, file_name_input)
-            st.write(status)
-
-        # Display Chat History
-        st.subheader("Chat History")
-        chat_history = display_chat_history(st.session_state.chat_history)
-        st.text_area("Chat History", value=chat_history, height=200)
-
-        # Display Workspace Projects
-        st.subheader("Workspace Projects")
-        workspace_projects = display_workspace_projects(st.session_state.workspace_projects)
-        st.text_area("Workspace Projects", value=workspace_projects, height=200)
-
-        # Download and deploy models
-        if st.button("Download and Deploy Models"):
-            download_models()
-            st.info("Models downloaded and deployed.")
-
-    elif app_mode == "Workspace Chat App":
-        # Workspace Chat App
-        st.header("Workspace Chat App")
-
-        # Chat Interface with AI Agents
-        st.subheader("Chat with AI Agents")
-        selected_agent = st.selectbox("Select an AI agent", st.session_state.available_agents)
-        agent_chat_input = st.text_area("Enter your message for the agent:")
-        if st.button("Send to Agent"):
-            response = process_input(agent_chat_input)
-            st.session_state.chat_history.append((agent_chat_input, response))
-            st.write(f"{selected_agent}: {response}")
-
-        # Code Generation
-        st.subheader("Code Generation")
-        code_idea = st.text_input("Enter your code idea:")
-        selected_model = st.selectbox("Select a code-generative model", AVAILABLE_CODE_GENERATIVE_MODELS)
-        if st.button("Generate Code"):
-            generated_code = run_code(code_idea)
-            st.code(generated_code, language="python")
-
-        # Autonomous build process
-        if st.button("Automate Build Process"):
-            handle_autonomous_build()
-
-if __name__ == "__main__":
-    main()
+        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)