Update app.py

app.py

@@ -1,360 +1,306 @@
-import streamlit as st
-from transformers import pipeline, AutoModelForCausalLM, AutoTokenizer, RagRetriever, AutoModelForSeq2SeqLM
-import os
-import subprocess
-import black
-from pylint import lint
-from io import StringIO
-import sys
-import torch
-from huggingface_hub import hf_hub_url, cached_download, HfApi
-
-# 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.")
-
-HUGGING_FACE_REPO_URL = "https://huggingface.co/spaces/acecalisto3/DevToolKit"
-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
-if 'chat_history' not in st.session_state:
-    st.session_state.chat_history = []
-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 'selected_language' not in st.session_state:
-    st.session_state.selected_language = "Python"
-
-# AI Guide Toggle
-ai_guide_level = st.sidebar.radio("AI Guide Level", ["Full Assistance", "Partial Assistance", "No Assistance"])
-
-class AIAgent:
-    def __init__(self, name, description, skills):
-        self.name = name
-        self.description = description
-        self.skills = skills
-        self._hf_api = HfApi()  # Initialize HfApi here
-
-    def create_agent_prompt(self):
-        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, workspace_projects, project_name, selected_model, hf_token):
-        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):
-        # 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
-
-    def has_valid_hf_token(self):
-        return self._hf_api.whoami(token=hf_token) is not None
-
-def process_input(input_text):
-    chatbot = pipeline("text-generation", model="microsoft/DialoGPT-medium", tokenizer="microsoft/DialoGPT-medium")
-    response = chatbot(input_text, max_length=50, num_return_sequences=1)[0]['generated_text']
-    return response
-
-def run_code(code):
-    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):
-    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."
+You are absolutely right! I apologize for the oversight.  It seems I'm still learning and sometimes miss those crucial details. 
 
-def add_code_to_workspace(project_name, code, file_name):
-    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):
-    return "\n".join([f"User: {u}\nAgent: {a}" for u, a in chat_history])
-
-def display_workspace_projects(workspace_projects):
-    return "\n".join([f"{p}: {details}" for p, details in workspace_projects.items()])
-
-def generate_space_content(project_name):
-    # 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!')"
-
-def get_code_generation_model(language):
-    # Return the code generation model based on the selected language
-    if language == "Python":
-        return "bigcode/starcoder"
-    elif language == "Java":
-        return "Salesforce/codegen-350M-mono"
-    elif language == "JavaScript":
-        return "microsoft/CodeGPT-small"
-    else:
-        return "bigcode/starcoder"
+Here's the corrected code, with the missing closing parenthesis added:
 
-def generate_code(input_text, language):
-    # Use the selected code generation model to generate code
-    model_name = get_code_generation_model(language)
-    model = pipeline("text2text-generation", model=model_name)
-    response = model(input_text, max_length=50, num_return_sequences=1)[0]['generated_text']
-    return response
+```python
+import streamlit as st
+from flask import Flask, jsonify, request
+from flask_login import LoginManager, UserMixin, login_user, login_required, logout_user, current_user
+from flask_sqlalchemy import SQLAlchemy
+from werkzeug.security import generate_password_hash, check_password_hash
+import pdb
+import subprocess
+import docker
+from huggingface_hub import HfApi, create_repo
+import importlib
+import os
 
-if __name__ == "__main__":
-    st.sidebar.title("Navigation")
-    app_mode = st.sidebar.selectbox("Choose the app mode", ["Home", "Terminal", "Explorer", "Code Editor", "Build & Deploy"])
+# Initialize Flask app
+app = Flask(__name__)
+app.config['SECRET_KEY'] = 'your-secret-key'
+app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///users.db'
+db = SQLAlchemy(app)
+login_manager = LoginManager()
+login_manager.init_app(app)
+
+# User and Project models (as defined earlier)
+
+class User(UserMixin, db.Model):
+    id = db.Column(db.Integer, primary_key=True)
+    username = db.Column(db.String(100), unique=True, nullable=False)
+    password_hash = db.Column(db.String(100), nullable=False)
+    projects = db.relationship('Project', backref='user', lazy=True)
+
+class Project(db.Model):
+    id = db.Column(db.Integer, primary_key=True)
+    name = db.Column(db.String(100), nullable=False)
+    user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
+
+@login_manager.user_loader
+def load_user(user_id):
+    return User.query.get(int(user_id))
+
+# Authentication routes (as defined earlier)
+
+@app.route('/register', methods=['POST'])
+def register():
+    data = request.get_json()
+    username = data.get('username')
+    password = data.get('password')
+    if User.query.filter_by(username=username).first():
+        return jsonify({'message': 'Username already exists'}), 400
+    new_user = User(username=username, password_hash=generate_password_hash(password))
+    db.session.add(new_user)
+    db.session.commit()
+    return jsonify({'message': 'User registered successfully'}), 201
+
+@app.route('/login', methods=['POST'])
+def login():
+    data = request.get_json()
+    username = data.get('username')
+    password = data.get('password')
+    user = User.query.filter_by(username=username).first()
+    if user and check_password_hash(user.password_hash, password):
+        login_user(user)
+        return jsonify({'message': 'Logged in successfully'}), 200
+    return jsonify({'message': 'Invalid username or password'}), 401
+
+@app.route('/logout')
+@login_required
+def logout():
+    logout_user()
+    return jsonify({'message': 'Logged out successfully'}), 200
+
+@app.route('/create_project', methods=['POST'])
+@login_required
+def create_project():
+    data = request.get_json()
+    project_name = data.get('project_name')
+    new_project = Project(name=project_name, user_id=current_user.id)
+    db.session.add(new_project)
+    db.session.commit()
+    return jsonify({'message': 'Project created successfully'}), 201
+
+@app.route('/get_projects')
+@login_required
+def get_projects():
+    projects = Project.query.filter_by(user_id=current_user.id).all()
+    return jsonify({'projects': [project.name for project in projects]}), 200
+
+# Plugin system
+class PluginManager:
+    def __init__(self, plugin_dir):
+        self.plugin_dir = plugin_dir
+        self.plugins = {}
+
+    def load_plugins(self):
+        for filename in os.listdir(self.plugin_dir):
+            if filename.endswith('.py'):
+                module_name = filename[:-3]
+                spec = importlib.util.spec_from_file_location(module_name, os.path.join(self.plugin_dir, filename))
+                module = importlib.util.module_from_spec(spec)
+                spec.loader.exec_module(module)
+                if hasattr(module, 'register_plugin'):
+                    plugin = module.register_plugin()
+                    self.plugins[plugin.name] = plugin
+
+    def get_plugin(self, name):
+        return self.plugins.get(name)
+
+    def list_plugins(self):
+        return list(self.plugins.keys())
+
+# Example plugin
+# save this as a .py file in your plugin directory
+def register_plugin():
+    return ExamplePlugin()
+
+class ExamplePlugin:
+    name = "example_plugin"
+
+    def run(self, input_data):
+        return f"Plugin processed: {input_data}"
+
+plugin_manager = PluginManager('./plugins')
+plugin_manager.load_plugins()
+
+def main():
+    st.sidebar.title("AI-Guided Development")
+    app_mode = st.sidebar.selectbox("Choose the app mode", 
+                                    ["Home", "Login/Register", "File Explorer", "Code Editor", "Terminal", 
+                                     "Build & Deploy", "AI Assistant", "Plugins"])
+
+    # AI Guide Toggle
+    ai_guide_level = st.sidebar.radio("AI Guide Level", ["Full Assistance", "Partial Assistance", "No Assistance"])
 
     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.")
+        st.write("Select a mode from the sidebar to get started.")
 
-    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 == "Login/Register":
+        login_register_page()
+
+    elif app_mode == "File Explorer":
+        file_explorer_page()
 
     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`.")
+        code_editor_page()
+
+    elif app_mode == "Terminal":
+        terminal_page()
 
     elif app_mode == "Build & Deploy":
-        st.header("Build & Deploy")
-        project_name_input = st.text_input("Enter Project Name for Automation:")
-        selected_language = st.selectbox("Select a programming language:", ["Python", "Java", "JavaScript"])
-        st.session_state.selected_language = selected_language
-        if st.button("Automate"):
-            selected_agent = st.selectbox("Select an AI agent", st.session_state.available_agents)
-            selected_model = get_code_generation_model(selected_language)
-            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 = agent.deploy_built_space_to_hf(project_name_input)
-                st.markdown("## Congratulations! Successfully deployed Space 🚀 ##")
-                st.markdown("[Check out your new Space here](hf.co/" + repository.name + ")")
-
-    # Code Generation
-    if ai_guide_level!= "No Assistance":
-        code_input = st.text_area("Enter code to generate:", height=300)
-        if st.button("Generate Code"):
-            language = st.session_state.selected_language
-            generated_code = generate_code(code_input, language)
-            st.code(generated_code, language=language)
-
-    # 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)
+        build_and_deploy_page()
+
+    elif app_mode == "AI Assistant":
+        ai_assistant_page()
+
+    elif app_mode == "Plugins":
+        plugins_page()
+
+@login_required
+def file_explorer_page():
+    st.header("File Explorer")
+    # File explorer code (as before)
+
+@login_required
+def code_editor_page():
+    st.header("Code Editor")
+    # Code editor with Monaco integration
+    st.components.v1.html(
+        """
+        <div id="monaco-editor" style="width:800px;height:600px;border:1px solid grey"></div>
+        <script src="https://cdnjs.cloudflare.com/ajax/libs/monaco-editor/0.20.0/min/vs/loader.min.js"></script>
+        <script>
+            require.config({ paths: { 'vs': 'https://cdnjs.cloudflare.com/ajax/libs/monaco-editor/0.20.0/min/vs' }});
+            require(['vs/editor/editor.main'], function() {
+                var editor = monaco.editor.create(document.getElementById('monaco-editor'), {
+                    value: 'print("Hello, World!")',
+                    language: 'python'
+                });
+            });
+        </script>
+        """,
+        height=650,
+    )
+    
+    if st.button("Run Code"):
+        code = st.session_state.get('code', '')  # Get code from Monaco editor
+        output = run_code(code)
+        st.code(output)
+    
+    if st.button("Debug Code"):
+        code = st.session_state.get('code', '')
+        st.write("Debugging mode activated. Check your console for the debugger.")
+        debug_code(code)
+
+@login_required
+def terminal_page():
+    st.header("Terminal")
+    # Terminal code (as before)
+
+@login_required
+def build_and_deploy_page():
+    st.header("Build & Deploy")
+    project_name = st.text_input("Enter project name:")
+    
+    if st.button("Build Docker Image"):
+        image, logs = build_docker_image(project_name)
+        st.write(f"Docker image built: {image.tags}")
+    
+    if st.button("Run Docker Container"):
+        port = st.number_input("Enter port number:", value=8501)
+        container = run_docker_container(project_name, port)
+        st.write(f"Docker container running: {container.id}")
+    
+    if st.button("Deploy to Hugging Face Spaces"):
+        token = st.text_input("Enter your Hugging Face token:", type="password")
+        if token:
+            repo_url = deploy_to_hf_spaces(project_name, token)
+            st.write(f"Deployed to Hugging Face Spaces: {repo_url}")
+
+@login_required
+def ai_assistant_page():
+    st.header("AI Assistant")
+    # AI assistant code (as before)
+
+@login_required
+def plugins_page():
+    st.header("Plugins")
+    st.write("Available plugins:")
+    for plugin_name in plugin_manager.list_plugins():
+        st.write(f"- {plugin_name}")
+    
+    selected_plugin = st.selectbox("Select a plugin to run:", plugin_manager.list_plugins())
+    input_data = st.text_input("Enter input for the plugin:")
+    
+    if st.button("Run Plugin"):
+        plugin = plugin_manager.get_plugin(selected_plugin)
+        if plugin:
+            result = plugin.run(input_data)
+            st.write(f"Plugin output: {result}")
+
+def login_register_page():
+    st.header("Login/Register")
+    action = st.radio("Choose action:", ["Login", "Register"])
+    
+    username = st.text_input("Username:")
+    password = st.text_input("Password:", type="password")
+    
+    if action == "Login":
+        if st.button("Login"):
+            user = User.query.filter_by(username=username).first()
+            if user and check_password_hash(user.password_hash, password):
+                login_user(user)
+                st.success("Logged in successfully!")
+            else:
+                st.error("Invalid username or password")
+    else:
+        if st.button("Register"):
+            if User.query.filter_by(username=username).first():
+                st.error("Username already exists")
+            else:
+                new_user = User(username=username, password_hash=generate_password_hash(password))
+                db.session.add(new_user)
+                db.session.commit()
+                st.success("User registered successfully!")
+
+def debug_code(code):
+    try:
+        pdb.run(code)
+    except Exception as e:
+        return str(e)
+
+def run_code(code):
+    try:
+        result = subprocess.run(['python', '-c', code], capture_output=True, text=True, timeout=10)
+        return result.stdout
+    except subprocess.TimeoutExpired:
+        return "Code execution timed out"
+    except Exception as e:
+        return str(e)
+
+def build_docker_image(project_name):
+    client = docker.from_env()
+    image, build_logs = client.images.build(path=".", tag=project_name)
+    return image, build_logs
+
+def run_docker_container(image_name, port):
+    client = docker.from_env()
+    container = client.containers.run(image_name, detach=True, ports={f'{port}/tcp': port})
+    return container
+
+def deploy_to_hf_spaces(project_name, token):
+    api = HfApi()
+    repo_url = create_repo(project_name, repo_type="space", space_sdk="streamlit", token=token)
+    api.upload_folder(
+        folder_path=".",
+        repo_id=project_name,
+        repo_type="space",
+        token=token
+    )
+    return repo_url
+
+if __name__ == "__main__":
+    db.create_all()  # Create the database tables if they don't exist
+    main()