app.py

import os
import streamlit as st
from huggingface_hub import InferenceClient
import gradio as gr
import random
from transformers import pipeline, AutoModelForCausalLM, AutoTokenizer
import subprocess

# --- 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

    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.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:
        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}"