Update app.py

app.py

@@ -1,249 +1,172 @@
+import streamlit as st
 import os
 import subprocess
-import random
-import json
-from datetime import datetime
-
-from huggingface_hub import (
-    InferenceClient,
-    cached_download,
-    hf_hub_url
-)
-import gradio as gr
-
-from safe_search import safe_search
-from i_search import google
-from i_search import i_search as i_s 
-
-from agent import (
-    ACTION_PROMPT,
-    ADD_PROMPT,
-    COMPRESS_HISTORY_PROMPT,
-    
-    LOG_PROMPT,
-    LOG_RESPONSE,
-    MODIFY_PROMPT,
-    PRE_PREFIX,
-    SEARCH_QUERY,
-    READ_PROMPT,
-    TASK_PROMPT,
-    UNDERSTAND_TEST_RESULTS_PROMPT,
-) 
-
-from utils import (
-    parse_action, 
-    parse_file_content, 
-    read_python_module_structure
-) 
-from datetime import datetime 
-import json
-
-#--- Global Variables for App State ---
-app_state = {"components": []} 
-
-terminal_history = ""
-#--- Component Library ---
-components_registry = { "Button": { "properties": {"label": "Click Me", "onclick": ""}, "description": "A clickable button", "code_snippet": 'gr.Button(value="{label}", variant="primary")', }, "Text Input": { "properties": {"value": "", "placeholder": "Enter text"}, "description": "A field for entering text", "code_snippet": 'gr.Textbox(label="{placeholder}")', }, "Image": { "properties": {"src": "#", "alt": "Image"}, "description": "Displays an image", "code_snippet": 'gr.Image(label="{alt}")', }, "Dropdown": { "properties": {"choices": ["Option 1", "Option 2"], "value": ""}, "description": "A dropdown menu for selecting options", "code_snippet": 'gr.Dropdown(choices={choices}, label="Dropdown")', }, }, # Add more components here... }
-
-#--- NLP Model (Example using Hugging Face) ---
-nlp_model_name = "google/flan-t5-small"
-
-# Check if the model exists in the cache
-try: cached_download(hf_hub_url(nlp_model_name, revision="main")) nlp_model = InferenceClient(nlp_model_name) except: nlp_model = None
-
-#--- Function to get NLP model response ---
-def get_nlp_response(input_text): if nlp_model: response = nlp_model.text_generation(input_text) return response.generated_text else: return "NLP model not available."
-
-# --- Component Class ---
-class Component: def init(self, type, properties=None, id=None): self.id = id or random.randint(1000, 9999) self.type = type self.properties = properties or components_registry[type]["properties"].copy()
-
-def to_dict(self):
-    return {
-        "id": self.id,
-        "type": self.type,
-        "properties": self.properties,
-    }
-
-def render(self):
-    # Properly format choices for Dropdown
-    if self.type == "Dropdown":
-        self.properties["choices"] = (
-            str(self.properties["choices"])
-            .replace("[", "")
-            .replace("]", "")
-            .replace("'", "")
-        )
-    return components_registry[self.type]["code_snippet"].format(
-        **self.properties
+from transformers import pipeline, AutoModelForCausalLM, AutoTokenizer
+import black
+from pylint import lint
+from io import StringIO
+import sys
+
+PROJECT_ROOT = "projects"
+AGENT_DIRECTORY = "agents"
+
+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 = []
+
+class AIAgent:
+    def __init__(self, name, description, skills):
+        self.name = name
+        self.description = description
+        self.skills = skills
+
+    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):
+        """
+        Autonomous build logic that continues based on the state of chat history and workspace projects.
+        """
+        # Example logic: Generate a summary of chat history and workspace state
+        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()])
+
+        # Example: Generate the next logical step in the project
+        next_step = "Based on the current state, the next logical step is to implement the main application logic."
+
+        return summary, next_step
+
+def save_agent_to_file(agent):
+    """Saves the agent's prompt to a file."""
+    if not os.path.exists(AGENT_DIRECTORY):
+        os.makedirs(AGENT_DIRECTORY)
+    file_path = os.path.join(AGENT_DIRECTORY, f"{agent.name}.txt")
+    with open(file_path, "w") as file:
+        file.write(agent.create_agent_prompt())
+    st.session_state.available_agents.append(agent.name)
+
+def load_agent_prompt(agent_name):
+    """Loads an agent prompt from a file."""
+    file_path = os.path.join(AGENT_DIRECTORY, f"{agent_name}.txt")
+    if os.path.exists(file_path):
+        with open(file_path, "r") as file:
+            agent_prompt = file.read()
+        return agent_prompt
+    else:
+        return None
+
+def create_agent_from_text(name, text):
+    skills = text.split('\n')
+    agent = AIAgent(name, "AI agent created from text input.", skills)
+    save_agent_to_file(agent)
+    return agent.create_agent_prompt()
+
+def chat_interface_with_agent(input_text, agent_name):
+    agent_prompt = load_agent_prompt(agent_name)
+    if agent_prompt is None:
+        return f"Agent {agent_name} not found."
+
+    model_name = "gpt2"
+    try:
+        model = AutoModelForCausalLM.from_pretrained(model_name)
+        tokenizer = AutoTokenizer.from_pretrained(model_name)
+        generator = pipeline("text-generation", model=model, tokenizer=tokenizer)
+    except EnvironmentError as e:
+        return f"Error loading model: {e}"
+
+    # Combine the agent prompt with user input
+    combined_input = f"{agent_prompt}\n\nUser: {input_text}\nAgent:"
+
+    # Truncate input text to avoid exceeding the model's maximum length
+    max_input_length = 900
+    input_ids = tokenizer.encode(combined_input, return_tensors="pt")
+    if input_ids.shape[1] > max_input_length:
+        input_ids = input_ids[:, :max_input_length]
+
+    # Generate chatbot response
+    outputs = model.generate(
+        input_ids, max_new_tokens=50, num_return_sequences=1, do_sample=True
     )
-# --- Function to update the app canvas (for preview) ---
-def update_app_canvas(): components_html = "".join( [ f"<div>Component ID: {component['id']}, Type: {component['type']}, Properties: {component['properties']}</div>" for component in app_state["components"] ] ) return components_html
-
-# --- Function to handle component addition ---
-def add_component(component_type): if component_type in components_registry: new_component = Component(component_type) app_state["components"].append(new_component.to_dict()) return ( update_app_canvas(), f"System: Added component: {component_type}\n", ) else: return None, f"Error: Invalid component type: {component_type}\n"
-
-# --- Function to handle terminal input ---
-def run_terminal_command(command, history): global terminal_history output = "" try: # Basic command parsing (expand with NLP) if command.startswith("add "): component_type = command.split("add ", 1)[1].strip() _, output = add_component(component_type) elif command.startswith("set "): _, output = set_component_property(command) elif command.startswith("search "): search_query = command.split("search ", 1)[1].strip() output = i_s(search_query) elif command.startswith("deploy "): app_name = command.split("deploy ", 1)[1].strip() output = deploy_to_huggingface(app_name) else: # Attempt to execute command as Python code try: result = subprocess.check_output( command, shell=True, stderr=subprocess.STDOUT, text=True ) output = result except Exception as e: output = f"Error executing Python code: {str(e)}" except Exception as e: output = f"Error: {str(e)}" finally: terminal_history += f"User: {command}\n" terminal_history += f"{output}\n" return terminal_history
-
-def set_component_property(command): try: # Improved 'set' command parsing set_parts = command.split(" ", 2)[1:] if len(set_parts) != 2: raise ValueError("Invalid 'set' command format.")
-
-component_id = int(set_parts[0])  # Use component ID
-    property_name, property_value = set_parts[1].split("=", 1)
-
-    # Find component by ID
-    component_found = False
-    for component in app_state["components"]:
-        if component["id"] == component_id:
-            if property_name in component["properties"]:
-                component["properties"][
-                    property_name.strip()
-                ] = property_value.strip()
-                component_found = True
-                return (
-                    update_app_canvas(),
-                    f"System: Property '{property_name}' set to '{property_value}' for component {component_id}\n",
-                )
-            else:
-                return (
-                    None,
-                    f"Error: Property '{property_name}' not found in component {component_id}\n",
-                )
-    if not component_found:
-        return (
-            None,
-            f"Error: Component with ID {component_id} not found.\n",
-        )
-
-except Exception as e:
-    return None, f"Error: Invalid 'set' command format or error setting property: {str(e)}\n"
-#--- Function to handle chat interaction ---
-def run_chat(message, history): global terminal_history if message.startswith("!"): command = message[1:] terminal_history = run_terminal_command(command, history) return history, terminal_history else: # ... (Your regular chat response generation) return history, terminal_history
-
-# --- Code Generation ---
-def generate_python_code(app_name): code = f""" import gradio as gr
-
-Define your Gradio components here
-with gr.Blocks() as {app_name}: """ for component in app_state["components"]: code += " " + Component(**component).render() + "\n"
-
-code += f"""
-{app_name}.launch() """ return code
-
-# --- Save/Load App State ---
-def save_app_state(filename="app_state.json"): with open(filename, "w") as f: json.dump(app_state, f)
-
-# --- Hugging Face Deployment --- def deploy_to_huggingface(app_name): # Generate Python code code = generate_python_code(app_name)
-def load_app_state(filename="app_state.json"): global app_state try: with open(filename, "r") as f: app_state = json.load(f) except FileNotFoundError: print("App state file not found. Starting with a blank slate.")
-
-# Create requirements.txt
-with open("requirements.txt", "w") as f:
-    f.write("gradio==3.32.0\n")
-
-# Create the app.py file
-with open("app.py", "w") as f:
-    f.write(code)
-
-# Execute the deployment command
-try:
-    subprocess.run(
-        [
-            "huggingface-cli",
-            "repo",
-            "create",
-            "--type",
-            "space",
-            "--space_sdk",
-            "gradio",
-            app_name,
-        ],
-        check=True,
-    )
-    subprocess.run(
-        ["git", "init"], cwd=f"./{app_name}", check=True
-    )
-    subprocess.run(
-        ["git", "add", "."], cwd=f"./{app_name}", check=True
-    )
-    subprocess.run(
-        ['git', 'commit', '-m', '"Initial commit"'], cwd=f"./{user_name}/{app_name}", check=True
-    )
-    subprocess.run(
-        ["git", "push", "https://huggingface.co/spaces/" + app_name, "main"], cwd=f"./{app_name}", check=True
-    )
-    return (
-        f"Successfully deployed to Hugging Face Spaces: https://huggingface.co/spaces/{app_name}"
-    )
-except Exception as e:
-    return f"Error deploying to Hugging Face Spaces: {e}"
---- Gradio Interface ---
-with gr.Blocks() as iface: with gr.Row(): # --- Chat Interface --- chat_history = gr.Chatbot(label="Chat with Agent") chat_input = gr.Textbox(label="Your Message") chat_button = gr.Button("Send")
-
-chat_button.click(
-        run_chat,
-        inputs=[chat_input, chat_history],
-        outputs=[chat_history, terminal_output],
-    )
-
-with gr.Row():
-    # --- App Builder Section ---
-    app_canvas = gr.HTML(
-        "<div>App Canvas Preview:</div>", label="App Canvas"
-    )
-    with gr.Column():
-        component_list = gr.Dropdown(
-            choices=list(components_registry.keys()), label="Components"
-        )
-        add_button = gr.Button("Add Component")
-
-        add_button.click(
-            add_component,
-            inputs=component_list,
-            outputs=[app_canvas, terminal_output],
-        )
-
-with gr.Row():
-    # --- Terminal ---
-    terminal_output = gr.Textbox(
-        lines=8, label="Terminal", value=terminal_history
-    )
-    terminal_input = gr.Textbox(label="Enter Command")
-    terminal_button = gr.Button("Run")
-
-    terminal_button.click(
-        run_terminal_command,
-        inputs=[terminal_input, terminal_output],
-        outputs=terminal_output,
-    )
-
-with gr.Row():
-    # --- Code Generation ---
-    code_output = gr.Code(
-        generate_python_code("app_name"),
-        language="python",
-        label="Generated Code",
-    )
-    app_name_input = gr.Textbox(label="App Name")
-    generate_code_button = gr.Button("Generate Code")
-    generate_code_button.click(
-        generate_python_code,
-        inputs=[app_name_input],
-        outputs=code_output,
-    )
-
-with gr.Row():
-    # --- Save/Load Buttons ---
-    save_button = gr.Button("Save App State")
-    load_button = gr.Button("Load App State")
-
-    save_button.click(save_app_state)
-    load_button.click(load_app_state)
-
-with gr.Row():
-    # --- Deploy Button ---
-    deploy_button = gr.Button("Deploy to Hugging Face")
-    deploy_output = gr.Textbox(label="Deployment Output")
-    deploy_button.click(
-        deploy_to_huggingface,
-        inputs=[app_name_input],
-        outputs=[deploy_output],
-    )
-iface.launch()
+    response = tokenizer.decode(outputs[0], skip_special_tokens=True)
+    return response
+
+def terminal_interface(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
+
+def code_editor_interface(code):
+    formatted_code = black.format_str(code, mode=black.FileMode())
+    pylint_output = lint.Run([formatted_code], do_exit=False)
+    pylint_output_str = StringIO()
+    pylint_output.linter.reporter.write_messages(pylint_output_str)
+    return formatted_code, pylint_output_str.getvalue()
+
+def summarize_text(text):
+    summarizer = pipeline("summarization")
+    summary = summarizer(text, max_length=130, min_length=30, do_sample=False)
+    return summary[0]['summary_text']
+
+def sentiment_analysis(text):
+    analyzer = pipeline("sentiment-analysis")
+    result = analyzer(text)
+    return result[0]['label']
+
+def translate_code(code, source_language, target_language):
+    # Placeholder for translation logic
+    return f"Translated {source_language} code to {target_language}."
+
+def generate_code(idea):
+    # Placeholder for code generation logic
+    return f"Generated code based on the idea: {idea}."
+
+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."
+
+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 chat_interface(input_text):
+    # Placeholder for chat interface logic
+    return f"Chatbot response: {input_text}"
+
+st.title("AI Agent Creator")
+
+sidebar = st.sidebar
+sidebar.title("Navigation")
+app_mode = sidebar.selectbox("Choose the app mode", ["AI Agent Creator", "Tool Box", "Workspace Chat App"])
+
+if app_mode == "AI Agent Creator":
+    st.header("Create an AI Agent from Text")
+
+    subheader = st.subheader
+    agent_name = subheader("Enter agent name:")
+    text_input = subheader("Enter skills (one per line):")
+
+    if st.button("Create Agent"):
+        agent_prompt = create_agent_from_text(agent_name, text_input)