Update app.py

app.py

@@ -1,283 +1,108 @@
 import os
-import subprocess
-import random
 from huggingface_hub import InferenceClient
 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,
-    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
-now = datetime.now()
-date_time_str = now.strftime("%Y-%m-%d %H:%M:%S")
-
-client = InferenceClient(
-    "mistralai/Mixtral-8x7B-Instruct-v0.1"
-)
-
-############################################
-
-
-VERBOSE = True
-MAX_HISTORY = 100
-#MODEL = "gpt-3.5-turbo"  # "gpt-4"
-
-
-def format_prompt(message, history):
-  prompt = "<s>"
-  for user_prompt, bot_response in history:
-    prompt += f"[INST] {user_prompt} [/INST]"
-    prompt += f" {bot_response}</s> "
-  prompt += f"[INST] {message} [/INST]"
-  return prompt
-
-
-
-def run_gpt(
-    prompt_template,
-    stop_tokens,
-    max_tokens,
-    purpose,
-    **prompt_kwargs,
-):
-    seed = random.randint(1,1111111111111111)
-    print (seed)
-    generate_kwargs = dict(
-        temperature=1.0,
-        max_new_tokens=2096,
-        top_p=0.99,
-        repetition_penalty=1.0,
-        do_sample=True,
-        seed=seed,
-    )
-
-    
-    content = PREFIX.format(
-        date_time_str=date_time_str,
-        purpose=purpose,
-        safe_search=safe_search,
-    ) + prompt_template.format(**prompt_kwargs)
-    if VERBOSE:
-        print(LOG_PROMPT.format(content))
-    
-    
-    #formatted_prompt = format_prompt(f"{system_prompt}, {prompt}", history)
-    #formatted_prompt = format_prompt(f'{content}', history)
-
-    stream = client.text_generation(content, **generate_kwargs, stream=True, details=True, return_full_text=False)
-    resp = ""
-    for response in stream:
-        resp += response.token.text
-
-    if VERBOSE:
-        print(LOG_RESPONSE.format(resp))
-    return resp
-
-
-def compress_history(purpose, task, history, directory):
-    resp = run_gpt(
-        COMPRESS_HISTORY_PROMPT,
-        stop_tokens=["observation:", "task:", "action:", "thought:"],
-        max_tokens=512,
-        purpose=purpose,
-        task=task,
-        history=history,
-    )
-    history = "observation: {}\n".format(resp)
-    return history
-    
-def call_search(purpose, task, history, directory, action_input):
-    print("CALLING SEARCH")
-    try:
-        
-        if "http" in action_input:
-            if "<" in action_input:
-                action_input = action_input.strip("<")
-            if ">" in action_input:
-                action_input = action_input.strip(">")
-            
-            response = i_s(action_input)
-            #response = google(search_return)
-            print(response)
-            history += "observation: search result is: {}\n".format(response)
-        else:
-            history += "observation: I need to provide a valid URL to 'action: SEARCH action_input=https://URL'\n"
-    except Exception as e:
-        history += "observation: {}'\n".format(e)
-    return "MAIN", None, history, task
-
-def call_main(purpose, task, history, directory, action_input):
-    resp = run_gpt(
-        ACTION_PROMPT,
-        stop_tokens=["observation:", "task:", "action:","thought:"],
-        max_tokens=2096,
-        purpose=purpose,
-        task=task,
-        history=history,
-    )
-    lines = resp.strip().strip("\n").split("\n")
-    for line in lines:
-        if line == "":
-            continue
-        if line.startswith("thought: "):
-            history += "{}\n".format(line)
-        elif line.startswith("action: "):
-            
-            action_name, action_input = parse_action(line)
-            print (f'ACTION_NAME :: {action_name}')
-            print (f'ACTION_INPUT :: {action_input}')
-            
-            history += "{}\n".format(line)
-            if "COMPLETE" in action_name or "COMPLETE" in action_input:
-                task = "END"
-                return action_name, action_input, history, task
-            else:
-                return action_name, action_input, history, task
-        else:
-            history += "{}\n".format(line)
-            #history += "observation: the following command did not produce any useful output: '{}', I need to check the commands syntax, or use a different command\n".format(line)
-            
-            #return action_name, action_input, history, task
-            #assert False, "unknown action: {}".format(line)
-    return "MAIN", None, history, task
-
-
-def call_set_task(purpose, task, history, directory, action_input):
-    task = run_gpt(
-        TASK_PROMPT,
-        stop_tokens=[],
-        max_tokens=64,
-        purpose=purpose,
-        task=task,
-        history=history,
-    ).strip("\n")
-    history += "observation: task has been updated to: {}\n".format(task)
-    return "MAIN", None, history, task
-
-def end_fn(purpose, task, history, directory, action_input):
-    task = "END"
-    return "COMPLETE", "COMPLETE", history, task
-
-NAME_TO_FUNC = {
-    "MAIN": call_main,
-    "UPDATE-TASK": call_set_task,
-    "SEARCH": call_search,
-    "COMPLETE": end_fn,
-
+import random
+from transformers import pipeline, AutoModelForCausalLM, AutoTokenizer
+import subprocess
+import threading
+import time
+import json
+import streamlit as st
+
+# 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")
+
+# 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)
+
+# Define the agents
+agents = {
+    "WEB_DEV": {
+        "description": "Expert in web development technologies and frameworks.",
+        "skills": ["HTML", "CSS", "JavaScript", "React", "Vue.js", "Flask", "Django", "Node.js", "Express.js"],
+        "system_prompt": "You are a web development expert. Your goal is to assist the user in building and deploying web applications. Provide code snippets, explanations, and guidance on best practices.",
+    },
+    "AI_SYSTEM_PROMPT": {
+        "description": "Expert in designing and implementing AI systems.",
+        "skills": ["Machine Learning", "Deep Learning", "Natural Language Processing", "Computer Vision", "Reinforcement Learning"],
+        "system_prompt": "You are an AI system expert. Your goal is to assist the user in designing and implementing AI systems. Provide code snippets, explanations, and guidance on best practices.",
+    },
+    "PYTHON_CODE_DEV": {
+        "description": "Expert in Python programming and development.",
+        "skills": ["Python", "Data Structures", "Algorithms", "Object-Oriented Programming", "Functional Programming"],
+        "system_prompt": "You are a Python code development expert. Your goal is to assist the user in writing and debugging Python code. Provide code snippets, explanations, and guidance on best practices.",
+    },
+    "CODE_REVIEW_ASSISTANT": {
+        "description": "Expert in code review and quality assurance.",
+        "skills": ["Code Style", "Best Practices", "Security", "Performance", "Maintainability"],
+        "system_prompt": "You are a code review assistant. Your goal is to assist the user in reviewing code for quality and efficiency. Provide feedback on code style, best practices, security, performance, and maintainability.",
+    },
+    "CONTENT_WRITER_EDITOR": {
+        "description": "Expert in content writing and editing.",
+        "skills": ["Grammar", "Style", "Clarity", "Conciseness", "SEO"],
+        "system_prompt": "You are a content writer and editor. Your goal is to assist the user in creating high-quality content. Provide suggestions on grammar, style, clarity, conciseness, and SEO.",
+    },
+    "QUESTION_GENERATOR": {
+        "description": "Expert in generating questions for learning and assessment.",
+        "skills": ["Question Types", "Cognitive Levels", "Assessment Design"],
+        "system_prompt": "You are a question generator. Your goal is to assist the user in generating questions for learning and assessment. Provide questions that are relevant to the topic and aligned with the cognitive levels.",
+    },
+    "HUGGINGFACE_FILE_DEV": {
+        "description": "Expert in developing Hugging Face files for machine learning models.",
+        "skills": ["Transformers", "Datasets", "Model Training", "Model Deployment"],
+        "system_prompt": "You are a Hugging Face file development expert. Your goal is to assist the user in creating and deploying Hugging Face files for machine learning models. Provide code snippets, explanations, and guidance on best practices.",
+    },
 }
 
-def run_action(purpose, task, history, directory, action_name, action_input):
-    print(f'action_name::{action_name}')
-    try:
-        if "RESPONSE" in action_name or "COMPLETE" in action_name:
-            action_name="COMPLETE"
-            task="END"
-            return action_name, "COMPLETE", history, task
-    
-        # compress the history when it is long
-        if len(history.split("\n")) > MAX_HISTORY:
-            if VERBOSE:
-                print("COMPRESSING HISTORY")
-            history = compress_history(purpose, task, history, directory)
-        if not action_name in NAME_TO_FUNC:
-            action_name="MAIN"
-        if action_name == "" or action_name == None:
-            action_name="MAIN"
-        assert action_name in NAME_TO_FUNC
-    
-        print("RUN: ", action_name, action_input)
-        return NAME_TO_FUNC[action_name](purpose, task, history, directory, action_input)
-    except Exception as e:
-        history += "observation: the previous command did not produce any useful output, I need to check the commands syntax, or use a different command\n"
-
-        return "MAIN", None, history, task
-
-def run(purpose,history):
-    
-    #print(purpose)
-    #print(hist)
-    task=None
-    directory="./"
-    if history:
-        history=str(history).strip("[]")
-    if not history:
-        history = ""
-    
-    action_name = "UPDATE-TASK" if task is None else "MAIN"
-    action_input = None
-    while True:
-        print("")
-        print("")
-        print("---")
-        print("purpose:", purpose)
-        print("task:", task)
-        print("---")
-        print(history)
-        print("---")
-
-        action_name, action_input, history, task = run_action(
-            purpose,
-            task,
-            history,
-            directory,
-            action_name,
-            action_input,
-        )
-        yield (history)
-        #yield ("",[(purpose,history)])
-        if task == "END":
-            return (history)
-            #return ("", [(purpose,history)])
-
-
-
-################################################
-
-def format_prompt(message, history):
-  prompt = "<s>"
-  for user_prompt, bot_response in history:
-    prompt += f"[INST] {user_prompt} [/INST]"
-    prompt += f" {bot_response}</s> "
-  prompt += f"[INST] {message} [/INST]"
-  return prompt
-agents =[
-    "WEB_DEV",
-    "AI_SYSTEM_PROMPT",
-    "PYTHON_CODE_DEV"
-]
-def generate(
-        prompt, history, agent_name=agents[0], sys_prompt="", temperature=0.9, max_new_tokens=256, top_p=0.95, repetition_penalty=1.0,
-):
-    seed = random.randint(1,1111111111111111)
-
-    agent=prompts.WEB_DEV
-    if agent_name == "WEB_DEV":
-        agent = prompts.WEB_DEV
-    if agent_name == "AI_SYSTEM_PROMPT":
-        agent = prompts.AI_SYSTEM_PROMPT
-    if agent_name == "PYTHON_CODE_DEV":
-        agent = prompts.PYTHON_CODE_DEV        
-    system_prompt=agent
-    temperature = float(temperature)
-    if temperature < 1e-2:
-        temperature = 1e-2
-    top_p = float(top_p)
+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):
+    prompt = "<s>"
+    for user_prompt, bot_response in history:
+        prompt += f"[INST] {user_prompt} [/INST]"
+        prompt += f" {bot_response}</s> "
+    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)
+    agent = agents[agent_name]
+    system_prompt = agent["system_prompt"]
 
     generate_kwargs = dict(
-        temperature=temperature,
+        temperature=float(temperature),
         max_new_tokens=max_new_tokens,
         top_p=top_p,
         repetition_penalty=repetition_penalty,
@@ -285,119 +110,122 @@ def generate(
         seed=seed,
     )
 
-    formatted_prompt = format_prompt(f"{system_prompt}, {prompt}", history)
-    stream = client.text_generation(formatted_prompt, **generate_kwargs, stream=True, details=True, return_full_text=False)
-    output = ""
-
-    for response in stream:
-        output += response.token.text
-        yield output
-    return output
-
-
-additional_inputs=[
-    gr.Dropdown(
-        label="Agents",
-        choices=[s for s in agents],
-        value=agents[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=1048*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",
-    ),
+    formatted_prompt = format_prompt(prompt, history, system_prompt)
+    input_ids = tokenizer.encode(formatted_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
+    else:
+        return "Agent is not active. Please activate the agent."
 
+def terminal_interface(command, project_name):
+    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):
+    project_path = os.path.join(os.getcwd(), project_name)
+    if not os.path.exists(project_path):
+        os.makedirs(project_path)
+    file_path = os.path.join(project_path, file_name)
+    with open(file_path, 'w') as file:
+        file.write(code)
+    if project_name not in st.session_state.workspace_projects:
+        st.session_state.workspace_projects[project_name] = {'files': []}
+    st.session_state.workspace_projects[project_name]['files'].append(file_name)
+    return f"Added {file_name} to {project_name}"
+
+# Streamlit UI
+st.title("DevToolKit: AI-Powered Development Environment")
+
+# Project Management
+st.header("Project Management")
+project_name = st.text_input("Enter project name:")
+if st.button("Create Project"):
+    if project_name not in st.session_state.workspace_projects:
+        st.session_state.workspace_projects[project_name] = {'files': []}
+        st.success(f"Created project: {project_name}")
+    else:
+        st.warning(f"Project {project_name} already exists")
+
+# 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'):")
+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
+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
+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
+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()
+            st.success(f"{agent_name} activated.")
+        if st.button(f"Deactivate {agent_name}"):
+            agent.deactivate()
+            st.success(f"{agent_name} deactivated.")
+
+# 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
+
+# Display current state for debugging
+st.sidebar.subheader("Current State")
+st.sidebar.json(st.session_state.current_state)
+
+# 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"),
 ]
 
-examples=[
-    ["Create a simple web application using Flask", agents[0], None, None, None, None, ],
-    ["Generate a Python script to perform a linear regression analysis", agents[2], None, None, None, None, ],
-    ["Create a Dockerfile for a Node.js application", agents[1], None, None, None, None, ],
-    ["Write a shell script to automate the deployment of a web application to a server", agents[3], None, None, None, None, ],
-    ["Generate a SQL query to retrieve the top 10 most popular products by sales", agents[4], None, None, None, None, ],
-    ["Write a Python script to generate a random password with a given length and complexity", agents[2], None, None, None, None, ],
-    ["Create a simple game in Unity using C#", agents[0], None, None, None, None, ],
-    ["Generate a Java program to implement a binary search algorithm", agents[2], None, None, None, None, ],
-    ["Write a shell script to monitor the CPU usage of a server", agents[1], None, None, None, None, ],
-    ["Create a simple web application using React and Node.js", agents[0], None, None, None, None, ],
-    ["Generate a Python script to perform a sentiment analysis on a given text", agents[2], None, None, None, None, ],
-    ["Write a shell script to automate the backup of a MySQL database", agents[1], None, None, None, None, ],
-    ["Create a simple game in Unreal Engine using C++", agents[3], None, None, None, None, ],
-    ["Generate a Java program to implement a bubble sort algorithm", agents[2], None, None, None, None, ],
-    ["Write a shell script to monitor the memory usage of a server", agents[1], None, None, None, None, ],
-    ["Create a simple web application using Angular and Node.js", agents[0], None, None, None, None, ],
-    ["Generate a Python script to perform a text classification on a given dataset", agents[2], None, None, None, None, ],
-    ["Write a shell script to automate the installation of a software package on a server", agents[1], None, None, None, None, ],
-    ["Create a simple game in Godot using GDScript", agents[3], None, None, None, None, ],
-    ["Generate a Java program to implement a merge sort algorithm", agents[2], None, None, None, None, ],
-    ["Write a shell script to automate the cleanup of temporary files on a server", agents[1], None, None, None, None, ],
+examples = [
+    ["Create a simple web application using Flask", "WEB_DEV"],
+    ["Generate a Python script to perform a linear regression analysis", "PYTHON_CODE_DEV"],
+    ["Create a Dockerfile for a Node.js application", "AI_SYSTEM_PROMPT"],
+    # Add more examples as needed
 ]
 
-'''
-gr.ChatInterface(
-fn=run,
-chatbot=gr.Chatbot(show_label=False, show_share_button=False, show_copy_button=True, likeable=True, layout="panel"),
-title="Mixtral 46.7B\nMicro-Agent\nInternet Search <br> development test",
-examples=examples,
-concurrency_limit=20,
-with gr.Blocks() as ifacea:
-    gr.HTML("""TEST""")
-ifacea.launch()
-).launch()
-with gr.Blocks() as iface:
-    #chatbot=gr.Chatbot(show_label=False, show_share_button=False, show_copy_button=True, likeable=True, layout="panel"),
-    chatbot=gr.Chatbot()
-    msg = gr.Textbox()
-    with gr.Row():
-        submit_b = gr.Button()
-        clear = gr.ClearButton([msg, chatbot])
-    submit_b.click(run, [msg,chatbot],[msg,chatbot])
-    msg.submit(run, [msg, chatbot], [msg, chatbot])
-iface.launch()
-'''
 gr.ChatInterface(
-    fn=run,
+    fn=chat_interface,
     chatbot=gr.Chatbot(show_label=False, show_share_button=False, show_copy_button=True, likeable=True, layout="panel"),
-    title="Mixtral 46.7B\nMicro-Agent\nInternet Search <br> development test",
+    additional_inputs=additional_inputs,
+    title="DevToolKit AI Assistant",
     examples=examples,
     concurrency_limit=20,
-).launch(show_api=False)
+).launch(show_api=True)