Update app.py

app.py

@@ -1,26 +1,29 @@
 import os
-from huggingface_hub import InferenceClient
-import gradio as gr
-import random
-from transformers import pipeline, AutoModelForCausalLM, AutoTokenizer
-import subprocess
-import threading
-import time
 import json
+import time
+from typing import Dict, List, Tuple
+
+import gradio as gr
 import streamlit as st
+from huggingface_hub import InferenceClient
+from transformers import AutoModelForCausalLM, AutoTokenizer
+from rich import print as rprint
+from rich.panel import Panel
+from rich.progress import track
+from rich.table import Table
 
-# Initialize the session state
-if 'current_state' not in st.session_state:
-    st.session_state.current_state = None
-# Initialize the InferenceClient for Mixtral-8x7B-Instruct-v0.1
-client = InferenceClient("mistralai/Mixtral-8x7B-Instruct-v0.1")
+# --- Constants ---
+MODEL_NAME = "bigscience/bloom-1b7"  # Choose a suitable model
+MAX_NEW_TOKENS = 1024
+TEMPERATURE = 0.7
+TOP_P = 0.95
+REPETITION_PENALTY = 1.2
 
-# Load the model and tokenizer from a different repository
-model_name = "bigscience/bloom-1b7"
-model = AutoModelForCausalLM.from_pretrained(model_name)
-tokenizer = AutoTokenizer.from_pretrained(model_name)
+# --- Model & Tokenizer ---
+model = AutoModelForCausalLM.from_pretrained(MODEL_NAME)
+tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
 
-# Define the agents
+# --- Agents ---
 agents = {
     "WEB_DEV": {
         "description": "Expert in web development technologies and frameworks.",
@@ -59,36 +62,19 @@ agents = {
     },
 }
 
-class AIAgent:
-    def __init__(self, name, description, skills, system_prompt):
-        self.name = name
-        self.description = description
-        self.skills = skills
-        self.system_prompt = system_prompt
-        self.active = False
-
-    def activate(self):
-        self.active = True
-
-    def deactivate(self):
-        self.active = False
-
-    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):
-        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 format_prompt(message, history, agent_prompt):
+# --- Session State ---
+if "workspace_projects" not in st.session_state:
+    st.session_state.workspace_projects = {}
+if "chat_history" not in st.session_state:
+    st.session_state.chat_history = []
+if "active_agent" not in st.session_state:
+    st.session_state.active_agent = None
+if "selected_agents" not in st.session_state:
+    st.session_state.selected_agents = []
+
+# --- Functions ---
+def format_prompt(message: str, history: List[Tuple[str, str]], agent_prompt: str) -> str:
+    """Formats the prompt for the language model."""
     prompt = "<s>"
     for user_prompt, bot_response in history:
         prompt += f"[INST] {user_prompt} [/INST]"
@@ -96,41 +82,44 @@ def format_prompt(message, history, agent_prompt):
     prompt += f"[INST] {agent_prompt}, {message} [/INST]"
     return prompt
 
-def generate(prompt, history, agent_name, temperature=0.9, max_new_tokens=256, top_p=0.95, repetition_penalty=1.0):
-    seed = random.randint(1, 1111111111111111)
+def generate_response(prompt: str, agent_name: str) -> str:
+    """Generates a response from the language model."""
     agent = agents[agent_name]
     system_prompt = agent["system_prompt"]
-
     generate_kwargs = dict(
-        temperature=float(temperature),
-        max_new_tokens=max_new_tokens,
-        top_p=top_p,
-        repetition_penalty=repetition_penalty,
+        temperature=TEMPERATURE,
+        max_new_tokens=MAX_NEW_TOKENS,
+        top_p=TOP_P,
+        repetition_penalty=REPETITION_PENALTY,
         do_sample=True,
-        seed=seed,
     )
-
-    formatted_prompt = format_prompt(prompt, history, system_prompt)
-    input_ids = tokenizer.encode(formatted_prompt, return_tensors="pt")
+    input_ids = tokenizer.encode(prompt, return_tensors="pt")
     output = model.generate(input_ids, **generate_kwargs)
     response = tokenizer.decode(output[0], skip_special_tokens=True)
     return response
 
-def chat_interface(chat_input, agent_name):
-    if agents[agent_name].active:
-        response = generate(chat_input, st.session_state.chat_history, agent_name)
-        return response
+def chat_interface(chat_input: str, agent_names: List[str]) -> str:
+    """Handles chat interactions with the selected agents."""
+    if agent_names:
+        responses = []
+        for agent_name in agent_names:
+            prompt = format_prompt(chat_input, st.session_state.chat_history, agents[agent_name]["system_prompt"])
+            response = generate_response(prompt, agent_name)
+            responses.append(f"{agent_name}: {response}")
+        return "\n".join(responses)
     else:
-        return "Agent is not active. Please activate the agent."
+        return "Please select at least one agent."
 
-def terminal_interface(command, project_name):
+def terminal_interface(command: str, project_name: str) -> str:
+    """Executes a command within the specified project directory."""
     try:
         result = subprocess.run(command, shell=True, capture_output=True, text=True, cwd=project_name)
         return result.stdout if result.returncode == 0 else result.stderr
     except Exception as e:
         return str(e)
 
-def add_code_to_workspace(project_name, code, file_name):
+def add_code_to_workspace(project_name: str, code: str, file_name: str) -> str:
+    """Adds code to a workspace project."""
     project_path = os.path.join(os.getcwd(), project_name)
     if not os.path.exists(project_path):
         os.makedirs(project_path)
@@ -142,10 +131,49 @@ def add_code_to_workspace(project_name, code, file_name):
     st.session_state.workspace_projects[project_name]['files'].append(file_name)
     return f"Added {file_name} to {project_name}"
 
-# Streamlit UI
+def display_workspace_projects():
+    """Displays a table of workspace projects."""
+    table = Table(title="Workspace Projects")
+    table.add_column("Project Name", style="cyan", no_wrap=True)
+    table.add_column("Files", style="magenta")
+    for project_name, details in st.session_state.workspace_projects.items():
+        table.add_row(project_name, ", ".join(details['files']))
+    rprint(Panel(table, title="[bold blue]Workspace Projects[/bold blue]"))
+
+def display_chat_history():
+    """Displays the chat history in a formatted way."""
+    table = Table(title="Chat History")
+    table.add_column("User", style="cyan", no_wrap=True)
+    table.add_column("Agent", style="magenta")
+    for user_prompt, bot_response in st.session_state.chat_history:
+        table.add_row(user_prompt, bot_response)
+    rprint(Panel(table, title="[bold blue]Chat History[/bold blue]"))
+
+def display_agent_info(agent_name: str):
+    """Displays information about the selected agent."""
+    agent = agents[agent_name]
+    table = Table(title=f"{agent_name} - Agent Information")
+    table.add_column("Description", style="cyan", no_wrap=True)
+    table.add_column("Skills", style="magenta")
+    table.add_row(agent["description"], ", ".join(agent["skills"]))
+    rprint(Panel(table, title=f"[bold blue]{agent_name} - Agent Information[/bold blue]"))
+
+def run_autonomous_build(agent_names: List[str], project_name: str):
+    """Runs the autonomous build process."""
+    for agent_name in agent_names:
+        agent = agents[agent_name]
+        chat_history = st.session_state.chat_history
+        workspace_projects = st.session_state.workspace_projects
+        summary, next_step = agent.autonomous_build(chat_history, workspace_projects)
+        rprint(Panel(summary, title="[bold blue]Current State[/bold blue]"))
+        rprint(Panel(next_step, title="[bold blue]Next Step[/bold blue]"))
+        # Implement logic for autonomous build based on the current state
+        # ...
+
+# --- Streamlit UI ---
 st.title("DevToolKit: AI-Powered Development Environment")
 
-# Project Management
+# --- Project Management ---
 st.header("Project Management")
 project_name = st.text_input("Enter project name:")
 if st.button("Create Project"):
@@ -155,7 +183,7 @@ if st.button("Create Project"):
     else:
         st.warning(f"Project {project_name} already exists")
 
-# Code Addition
+# --- Code Addition ---
 st.subheader("Add Code to Workspace")
 code_to_add = st.text_area("Enter code to add to workspace:")
 file_name = st.text_input("Enter file name (e.g. 'app.py'):")
@@ -163,55 +191,58 @@ if st.button("Add Code"):
     add_code_status = add_code_to_workspace(project_name, code_to_add, file_name)
     st.success(add_code_status)
 
-# Terminal Interface
+# --- Terminal Interface ---
 st.subheader("Terminal (Workspace Context)")
 terminal_input = st.text_input("Enter a command within the workspace:")
 if st.button("Run Command"):
     terminal_output = terminal_interface(terminal_input, project_name)
     st.code(terminal_output, language="bash")
 
-# Chat Interface
+# --- Chat Interface ---
 st.subheader("Chat with AI Agents")
-selected_agent = st.selectbox("Select an AI agent", list(agents.keys()))
-agent_chat_input = st.text_area("Enter your message for the agent:")
-if st.button("Send to Agent"):
-    agent_chat_response = chat_interface(agent_chat_input, selected_agent)
-    st.session_state.chat_history.append((agent_chat_input, agent_chat_response))
-    st.write(f"{selected_agent}: {agent_chat_response}")
-
-# Agent Control
+selected_agents = st.multiselect("Select AI agents", list(agents.keys()), key="agent_select")
+st.session_state.selected_agents = selected_agents
+agent_chat_input = st.text_area("Enter your message for the agents:", key="agent_input")
+if st.button("Send to Agents", key="agent_send"):
+    agent_chat_response = chat_interface(agent_chat_input, selected_agents)
+    st.write(agent_chat_response)
+
+# --- Agent Control ---
 st.subheader("Agent Control")
 for agent_name in agents:
     agent = agents[agent_name]
     with st.expander(f"{agent_name} ({agent['description']})"):
-        if st.button(f"Activate {agent_name}"):
-            agent.activate()
+        if st.button(f"Activate {agent_name}", key=f"activate_{agent_name}"):
+            st.session_state.active_agent = agent_name
             st.success(f"{agent_name} activated.")
-        if st.button(f"Deactivate {agent_name}"):
-            agent.deactivate()
+        if st.button(f"Deactivate {agent_name}", key=f"deactivate_{agent_name}"):
+            st.session_state.active_agent = None
             st.success(f"{agent_name} deactivated.")
 
-# Automate Build Process
+# --- Automate Build Process ---
 st.subheader("Automate Build Process")
 if st.button("Automate"):
-    # Select the appropriate agent based on the current context
-    # ...
-    # Implement the autonomous build process
-    # ...
-    pass
+    if st.session_state.selected_agents:
+        run_autonomous_build(st.session_state.selected_agents, project_name)
+    else:
+        st.warning("Please select at least one agent.")
 
-# Display current state for debugging
+# --- Display Information ---
 st.sidebar.subheader("Current State")
 st.sidebar.json(st.session_state.current_state)
+if st.session_state.active_agent:
+    display_agent_info(st.session_state.active_agent)
+display_workspace_projects()
+display_chat_history()
 
-# Gradio Interface
+# --- Gradio Interface ---
 additional_inputs = [
     gr.Dropdown(label="Agents", choices=[s for s in agents.keys()], value=list(agents.keys())[0], interactive=True),
     gr.Textbox(label="System Prompt", max_lines=1, interactive=True),
-    gr.Slider(label="Temperature", value=0.9, minimum=0.0, maximum=1.0, step=0.05, interactive=True, info="Higher values produce more diverse outputs"),
-    gr.Slider(label="Max new tokens", value=1048*10, minimum=0, maximum=1000*10, step=64, interactive=True, info="The maximum numbers of new tokens"),
-    gr.Slider(label="Top-p (nucleus sampling)", value=0.90, minimum=0.0, maximum=1, step=0.05, interactive=True, info="Higher values sample more low-probability tokens"),
-    gr.Slider(label="Repetition penalty", value=1.2, minimum=1.0, maximum=2.0, step=0.05, interactive=True, info="Penalize repeated tokens"),
+    gr.Slider(label="Temperature", value=TEMPERATURE, minimum=0.0, maximum=1.0, step=0.05, interactive=True, info="Higher values produce more diverse outputs"),
+    gr.Slider(label="Max new tokens", value=MAX_NEW_TOKENS, minimum=0, maximum=1000*10, step=64, interactive=True, info="The maximum numbers of new tokens"),
+    gr.Slider(label="Top-p (nucleus sampling)", value=TOP_P, minimum=0.0, maximum=1, step=0.05, interactive=True, info="Higher values sample more low-probability tokens"),
+    gr.Slider(label="Repetition penalty", value=REPETITION_PENALTY, minimum=1.0, maximum=2.0, step=0.05, interactive=True, info="Penalize repeated tokens"),
 ]
 
 examples = [