Update app.py

app.py

@@ -1,356 +1,251 @@
-import streamlit as st
-from transformers import pipeline, AutoTokenizer, AutoModelForSequenceClassification
-import json
 import os
-import requests
-import torch
-from gensim import summarize, corpora, models, dictionary
-import re
-from pygments import highlight
-from pygments.lexers import PythonLexer
-from pygments.formatters import HtmlFormatter
-import sys
-import time
-from threading import Thread
+import streamlit as st
+from huggingface_hub import InferenceClient
+import gradio as gr
+import random
+from transformers import pipeline, AutoModelForCausalLM, AutoTokenizer
 import subprocess
-import collections.abc as collections
-
-client = InferenceClient(
-    "mistralai/Mixtral-8x7B-Instruct-v0.1"
-)
-
-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
-
-# --- Constants ---
-MODEL_URL = "https://huggingface.co/models"
-TASKS_FILE = "tasks.json"
-CODE_EXECUTION_ENV = {}
-PIPELINE_RUNNING = False
-
-# --- Model Initialization ---
-generator = pipeline('text-generation', model='EleutherAI/gpt-neo-2.7B')
-sentiment_model_name = "distilbert-base-uncased-finetuned-sst-2-english"
-sentiment_tokenizer = AutoTokenizer.from_pretrained(sentiment_model_name)
-sentiment_model = AutoModelForSequenceClassification.from_pretrained(sentiment_model_name)
-
-# --- Helper Functions ---
-
-def generate_code(prompt):
-    """Generates code based on the given prompt."""
-    generated = generator(prompt, max_length=200, do_sample=True, temperature=0.9)
-    return generated[0]['generated_text']
-
-def add_task(task_description):
-    """Adds a new task to the task list."""
-    try:
-        with open(TASKS_FILE, "r") as outfile:
-            tasks = json.load(outfile)
-    except FileNotFoundError:
-        tasks = []
-    tasks.append({"task": task_description["task"], "description": task_description["description"], "status": "Pending"})
-    with open(TASKS_FILE, "w") as outfile:
-        json.dump(tasks, outfile)
-
-def display_code(code):
-    """Displays the code in a formatted manner."""
-    formatter = HtmlFormatter(style='default')
-    lexer = PythonLexer()
-    html = highlight(code, lexer, formatter)
-    st.markdown(html, unsafe_allow_html=True)
-
-def summarize_text(text):
-    """Summarizes the given text."""
-    return summarize(text)
-
-def analyze_sentiment(text):
-    """Analyzes the sentiment of the given text."""
-    inputs = sentiment_tokenizer(text, return_tensors='pt')
-    outputs = sentiment_model(**inputs)
-    probs = torch.nn.functional.softmax(outputs.logits, dim=1)
-    return probs.tolist()[0][1]
-
-def run_tests(code):
-    """Runs tests on the given code."""
-    # Placeholder for testing logic
-    return "Tests passed."
-
-def load_model(model_name):
-    """Loads a pre-trained model."""
-    tokenizer = AutoTokenizer.from_pretrained(model_name)
-    model = AutoModelForSequenceClassification.from_pretrained(model_name)
-    return model, tokenizer
-
-def save_model(model, tokenizer, file_name):
-    """Saves the model and tokenizer."""
-    model.save_pretrained(file_name)
-    tokenizer.save_pretrained(file_name)
-
-def load_dataset(file_name):
-    """Loads a dataset from a file."""
-    data = []
-    with open(file_name, "r") as infile:
-        for line in infile:
-            data.append(line.strip())
-    return data
-
-def save_dataset(data, file_name):
-    """Saves a dataset to a file."""
-    with open(file_name, "w") as outfile:
-        for item in data:
-            outfile.write("%s\n" % item)
-
-def download_file(url, file_name):
-    """Downloads a file from a URL."""
-    response = requests.get(url)
-    if response.status_code == 200:
-        with open(file_name, "wb") as outfile:
-            outfile.write(response.content)
-
-def get_model_list():
-    """Gets a list of available models."""
-    response = requests.get(MODEL_URL)
-    models = []
-    for match in re.finditer("<a href='/models/(\w+/\w+)'", response.text):
-        models.append(match.group(1))
-    return models
-
-def predict_text(model, tokenizer, text):
-    """Predicts the text using the given model and tokenizer."""
-    inputs = tokenizer(text, return_tensors='pt')
-    outputs = model(**inputs)
-    probs = torch.nn.functional.softmax(outputs.logits, dim=1)
-    return probs.tolist()[0]
-
-def get_user_input():
-    """Gets user input."""
-    input_type = st.selectbox("Select an input type", ["Text", "File", "Model"])
-    if input_type == "Text":
-        prompt = st.text_input("Enter text:")
+
+# --- Agent Definitions ---
+class AIAgent:
+    def __init__(self, name, description, skills, model_name="mistralai/Mixtral-8x7B-Instruct-v0.1"):
+        self.name = name
+        self.description = description
+        self.skills = skills
+        self.model_name = model_name
+        self.client = InferenceClient(self.model_name)
+
+    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 generate_response(self, prompt, history, temperature=0.9, max_new_tokens=256, top_p=0.95, repetition_penalty=1.0):
+        formatted_prompt = self.format_prompt(prompt, history)
+        stream = self.client.text_generation(formatted_prompt, 
+                                            temperature=temperature,
+                                            max_new_tokens=max_new_tokens,
+                                            top_p=top_p,
+                                            repetition_penalty=repetition_penalty,
+                                            do_sample=True,
+                                            seed=random.randint(1, 1111111111111111),
+                                            stream=True, 
+                                            details=True, 
+                                            return_full_text=False)
+        output = ""
+        for response in stream:
+            output += response.token.text
+            yield output
+        return output
+
+    def format_prompt(self, 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
-    elif input_type == "File":
-        uploaded_file = st.file_uploader("Choose a file")
-        if uploaded_file:
-            return uploaded_file.read().decode("utf-8")
-        else:
-            return ""
-    elif input_type == "Model":
-        model_name = st.selectbox("Select a model", get_model_list())
-        model, tokenizer = load_model(model_name)
-        text = st.text_area("Enter text:")
-        return text
-
-def get_tasks():
-    """Loads tasks from tasks.json."""
-    try:
-        with open(TASKS_FILE, "r") as outfile:
-            tasks = json.load(outfile)
-        return tasks
-    except FileNotFoundError:
-        return []
-
-def complete_task(task_id):
-    """Completes a task."""
-    tasks = get_tasks()
-    if 0 <= task_id < len(tasks):
-        tasks[task_id]["status"] = "Completed"
-        with open(TASKS_FILE, "w") as outfile:
-            json.dump(tasks, outfile)
-        st.write(f"Task {task_id} completed.")
-    else:
-        st.write(f"Invalid task ID: {task_id}")
-
-def delete_task(task_id):
-    """Deletes a task."""
-    tasks = get_tasks()
-    if 0 <= task_id < len(tasks):
-        del tasks[task_id]
-        with open(TASKS_FILE, "w") as outfile:
-            json.dump(tasks, outfile)
-        st.write(f"Task {task_id} deleted.")
+
+    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
+
+# --- Agent Definitions ---
+agents = {
+    "WEB_DEV": AIAgent("WEB_DEV", "Web development expert", ["HTML", "CSS", "JavaScript", "Flask", "React"]),
+    "AI_SYSTEM_PROMPT": AIAgent("AI_SYSTEM_PROMPT", "AI system prompt expert", ["Prompt Engineering", "LLM Interaction", "Fine-tuning"]),
+    "PYTHON_CODE_DEV": AIAgent("PYTHON_CODE_DEV", "Python code development expert", ["Python", "Data Structures", "Algorithms", "Libraries"]),
+    "CODE_REVIEW_ASSISTANT": AIAgent("CODE_REVIEW_ASSISTANT", "Code review assistant", ["Code Quality", "Best Practices", "Security"]),
+    "CONTENT_WRITER_EDITOR": AIAgent("CONTENT_WRITER_EDITOR", "Content writer and editor", ["Writing", "Editing", "SEO"]),
+    "QUESTION_GENERATOR": AIAgent("QUESTION_GENERATOR", "Question generator", ["Question Generation", "Knowledge Testing"]),
+    "HUGGINGFACE_FILE_DEV": AIAgent("HUGGINGFACE_FILE_DEV", "Hugging Face file development expert", ["Hugging Face Hub", "Model Training", "Dataset Creation"]),
+}
+
+# --- 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.write(f"Invalid task ID: {task_id}")
-
-def run_pipeline():
-    """Runs the pipeline."""
-    global PIPELINE_RUNNING
-    PIPELINE_RUNNING = True
-    while PIPELINE_RUNNING:
-        tasks = get_tasks()
-        for i, task in enumerate(tasks):
-            if task["status"] == "Pending":
-                st.write(f"Processing task {i}: {task['task']}")
-                try:
-                    code = generate_code(task['description'])
-                    st.write(f"Generated code:\n{code}")
-                    # Execute code in a separate process
-                    process = subprocess.Popen(["python", "-c", code], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-                    output, error = process.communicate()
-                    st.write(f"Code output:\n{output.decode('utf-8')}")
-                    st.write(f"Code error:\n{error.decode('utf-8')}")
-                    # Run tests (replace with actual logic)
-                    test_result = run_tests(code)
-                    st.write(f"Test result: {test_result}")
-                    # Update task status
-                    tasks[i]["status"] = "Completed"
-                    with open(TASKS_FILE, "w") as outfile:
-                        json.dump(tasks, outfile)
-                except Exception as e:
-                    st.write(f"Error processing task {i}: {e}")
-                    tasks[i]["status"] = "Failed"
-                    with open(TASKS_FILE, "w") as outfile:
-                        json.dump(tasks, outfile)
-                time.sleep(1)  # Adjust delay as needed
-
-def stop_pipeline():
-    """Stops the pipeline."""
-    global PIPELINE_RUNNING
-    PIPELINE_RUNNING = False
-    st.write("Pipeline stopped.")
-
-def load_model(file_name):
-    """Loads a saved model."""
-    try:
-        with open(file_name, "rb") as f:
-            model = pickle.load(f)
-        with open(file_name.replace(".sav", "_tokenizer.pkl"), "rb") as f:
-            tokenizer = pickle.load(f)
-        return model, tokenizer
-    except FileNotFoundError:
-        st.write(f"Model not found: {file_name}")
-        return None, None
-
-def delete_model(file_name):
-    """Deletes a saved model."""
+        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 DevToolKit for Guidance")
+chat_input = st.text_area("Enter your message for guidance:")
+if st.button("Get Guidance"):
+    chat_response = chat_interface(chat_input)
+    st.session_state.chat_history.append((chat_input, chat_response))
+    st.write(f"DevToolKit: {chat_response}")
+
+# --- Display Chat History ---
+st.subheader("Chat History")
+for user_input, response in st.session_state.chat_history:
+    st.write(f"User: {user_input}")
+    st.write(f"DevToolKit: {response}")
+
+# --- Display Terminal History ---
+st.subheader("Terminal History")
+for command, output in st.session_state.terminal_history:
+    st.write(f"Command: {command}")
+    st.code(output, language="bash")
+
+# --- Display Projects and Files ---
+st.subheader("Workspace Projects")
+for project, details in st.session_state.workspace_projects.items():
+    st.write(f"Project: {project}")
+    for file in details['files']:
+        st.write(f"  - {file}")
+
+# --- Chat with AI Agents ---
+st.subheader("Chat with AI Agents")
+selected_agent_name = st.selectbox("Select an AI agent", list(agents.keys()))
+selected_agent = agents[selected_agent_name]
+agent_chat_input = st.text_area("Enter your message for the agent:")
+if st.button("Send to Agent"):
+    agent_chat_response = selected_agent.generate_response(agent_chat_input, st.session_state.chat_history)
+    st.session_state.chat_history.append((agent_chat_input, agent_chat_response))
+    st.write(f"{selected_agent.name}: {agent_chat_response}")
+
+# --- Automate Build Process ---
+st.subheader("Automate Build Process")
+if st.button("Automate"):
+    summary, next_step = selected_agent.autonomous_build(st.session_state.chat_history, st.session_state.workspace_projects)
+    st.write("Autonomous Build Summary:")
+    st.write(summary)
+    st.write("Next Step:")
+    st.write(next_step)
+
+# --- 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=list(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", "WEB_DEV", None, None, None, None, ],
+    ["Generate a Python script to perform a linear regression analysis", "PYTHON_CODE_DEV", None, None, None, None, ],
+    ["Create a Dockerfile for a Node.js application", "AI_SYSTEM_PROMPT", None, None, None, None, ],
+    # Add more examples as needed
+]
+
+gr.ChatInterface(
+    fn=generate,
+    chatbot=gr.Chatbot(show_label=False, show_share_button=False, show_copy_button=True, likeable=True, layout="panel"),
+    additional_inputs=additional_inputs,
+    title="DevToolKit AI Assistant",
+    examples=examples,
+    concurrency_limit=20,
+).launch(show_api=True)
+
+# --- Helper Functions (Moved to separate file) ---
+def generate(prompt, history, agent_name, sys_prompt="", temperature=0.9, max_new_tokens=256, top_p=0.95, repetition_penalty=1.0):
+    # ... (Implementation in utils.py)
+
+def chat_interface(chat_input):
+    # ... (Implementation in utils.py)
+
+def chat_interface_with_agent(chat_input, agent_name):
+    # ... (Implementation in utils.py)
+
+def terminal_interface(command, project_name):
+    # ... (Implementation in utils.py)
+
+def add_code_to_workspace(project_name, code, file_name):
+    # ... (Implementation in utils.py)
+2. requirements.txt (Dependencies)
+
+streamlit
+huggingface_hub
+gradio
+transformers
+subprocess
+3. utils.py (Helper Functions)
+
+import os
+import subprocess
+import streamlit as st
+
+def generate(prompt, history, agent_name, sys_prompt="", 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.create_agent_prompt() if sys_prompt is None else sys_prompt
+
+    generate_kwargs = dict(
+        temperature=float(temperature),
+        max_new_tokens=max_new_tokens,
+        top_p=top_p,
+        repetition_penalty=repetition_penalty,
+        do_sample=True,
+        seed=seed,
+    )
+
+    formatted_prompt = agent.format_prompt(f"{system_prompt}, {prompt}", history)
+    stream = agent.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
+
+def chat_interface(chat_input):
+    response = generate(chat_input, st.session_state.chat_history)
+    return response
+
+def chat_interface_with_agent(chat_input, agent_name):
+    agent_prompt = agents[agent_name].create_agent_prompt()
+    response = generate(chat_input, st.session_state.chat_history, agent_name=agent_name, sys_prompt=agent_prompt)
+    return response
+
+def terminal_interface(command, project_name):
     try:
-        os.remove(file_name)
-        os.remove(file_name.replace(".sav", "_tokenizer.pkl"))
-        st.write(f"Model deleted: {file_name}")
-    except FileNotFoundError:
-        st.write(f"Model not found: {file_name}")
-
-# --- Streamlit App ---
-
-def main():
-    """Main function."""
-    st.title("AI-Powered Code Interpreter")
-
-    # --- Code Generation and Analysis ---
-    st.subheader("Code Generation and Analysis")
-    text = get_user_input()
-
-    if text:
-        prompt = "Generate a python function that:\n\n" + text
-        code = generate_code(prompt)
-
-        summarized_text = ""
-        if len(text) > 100:
-            summarized_text = summarize_text(text)
-
-        sentiment = ""
-        if text:
-            sentiment = "Positive" if analyze_sentiment(text) > 0.5 else "Negative"
-
-        tests_passed = ""
-        if code:
-            tests_passed = run_tests(code)
-
-        st.subheader("Summary:")
-        st.write(summarized_text)
-
-        st.subheader("Sentiment:")
-        st.write(sentiment)
-
-        st.subheader("Code:")
-        display_code(code)
-
-        st.subheader("Tests:")
-        st.write(tests_passed)
-
-        if st.button("Save code"):
-            file_name = st.text_input("Enter file name:")
-            with open(file_name, "w") as outfile:
-                outfile.write(code)
-
-    # --- Dataset Management ---
-    st.subheader("Dataset Management")
-    if st.button("Load dataset"):
-        file_name = st.text_input("Enter file name:")
-        data = load_dataset(file_name)
-        st.write(data)
-
-    if st.button("Save dataset"):
-        data = st.text_area("Enter data:")
-        file_name = st.text_input("Enter file name:")
-        save_dataset(data, file_name)
-
-    # --- Model Management ---
-    st.subheader("Model Management")
-    if st.button("Download model"):
-        model_name = st.selectbox("Select a model", get_model_list())
-        url = f"{MODEL_URL}/models/{model_name}/download"
-        file_name = model_name.replace("/", "-") + ".tar.gz"
-        download_file(url, file_name)
-
-    if st.button("Load model"):
-        model_name = st.selectbox("Select a model", get_model_list())
-        model, tokenizer = load_model(model_name)
-
-    if st.button("Predict text"):
-        text = st.text_area("Enter text:")
-        probs = predict_text(model, tokenizer, text)
-        st.write(probs)
-
-    if st.button("Save model"):
-        file_name = st.text_input("Enter file name:")
-        save_model(model, tokenizer, file_name)
-
-    # --- Saved Model Management ---
-    st.subheader("Saved Model Management")
-    file_name = st.text_input("Enter file name:")
-    model, tokenizer = load_model(file_name)
-
-    if st.button("Delete model"):
-        delete_model(file_name)
-
-    # --- Task Management ---
-    st.subheader("Task Management")
-    if st.button("Add task"):
-        task = st.text_input("Enter task:")
-        description = st.text_area("Enter description:")
-        add_task({"task": task, "description": description})
-
-    if st.button("Show tasks"):
-        tasks = get_tasks()
-        st.write(tasks)
-
-    if st.button("Complete task"):
-        task_id = st.number_input("Enter task ID:")
-        complete_task(task_id)
-
-    if st.button("Delete task"):
-        task_id = st.number_input("Enter task ID:")
-        delete_task(task_id)
-
-    # --- Pipeline Management ---
-    st.subheader("Pipeline Management")
-    if st.button("Run pipeline") and not PIPELINE_RUNNING:
-        Thread(target=run_pipeline).start()
-    if st.button("Stop pipeline") and PIPELINE_RUNNING:
-        stop_pipeline()
-
-    # --- Console Management ---
-    st.subheader("Console Management")
-    if st.button("Clear console"):
-        st.write("")
-
-    if st.button("Quit"):
-        sys.exit()
-
-if __name__ == "__main__":
-    main() 
+        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}"