app.py

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 datetime import datetime
import logging
import json

# --- Configuration ---
MODEL_NAME = "mistralai/Mixtral-8x7B-Instruct-v0.1"  # Model to use
MAX_HISTORY_TURNS = 5  # Number of history turns to keep
VERBOSE = True  # Enable verbose logging

# --- Logging Setup ---
logging.basicConfig(
    filename="app.log",  # Name of the log file
    level=logging.INFO,  # Set the logging level (INFO, DEBUG, etc.)
    format="%(asctime)s - %(levelname)s - %(message)s",
)

# --- Agent Definitions ---
agents = {
    "WEB_DEV": {
        "description": "Specialized in web development tasks.",
        "system_prompt": "You are a helpful AI assistant specializing in web development. You can generate code, answer questions, and provide guidance on web technologies.",
    },
    "AI_SYSTEM_PROMPT": {
        "description": "Focuses on generating system prompts for AI agents.",
        "system_prompt": "You are a helpful AI assistant that generates effective system prompts for AI agents. Your prompts should be clear, concise, and provide specific instructions.",
    },
    "PYTHON_CODE_DEV": {
        "description": "Expert in Python code development.",
        "system_prompt": "You are a helpful AI assistant specializing in Python code development. You can generate Python code, debug code, and answer questions about Python.",
    },
    "DATA_SCIENCE": {
        "description": "Expert in data science tasks.",
        "system_prompt": "You are a helpful AI assistant specializing in data science. You can analyze data, build models, and provide insights.",
    },
    "GAME_DEV": {
        "description": "Expert in game development tasks.",
        "system_prompt": "You are a helpful AI assistant specializing in game development. You can generate game logic, design levels, and provide guidance on game engines.",
    },
    # Add more agents as needed
}

# --- Function to format prompt with history ---
def format_prompt(message, history, agent_name, system_prompt):
    prompt = " "
    for user_prompt, bot_response in history[-MAX_HISTORY_TURNS:]:
        prompt += f"[INST] {user_prompt} [/  "
        prompt += f" {bot_response}"
    prompt += f"[INST] {message} [/  "

    # Add system prompt if provided
    if system_prompt:
        prompt = f"{system_prompt}\n\n{prompt}"

    return prompt

# --- Function to run the LLM with specified parameters ---
def run_llm(
    prompt,
    stop_sequences,
    max_tokens,
    temperature=0.7,
    top_p=0.8,
    repetition_penalty=1.5,
):
    seed = random.randint(1, 1111111111111111)
    logging.info(f"Seed: {seed}")  # Log the seed

    client = InferenceClient(MODEL_NAME)
    resp = client.text_generation(
        prompt,
        max_new_tokens=max_tokens,
        stop_sequences=stop_sequences,
        temperature=temperature,
        top_p=top_p,
        repetition_penalty=repetition_penalty,
    )
    if VERBOSE:
        logging.info(f"Prompt: {prompt}")
        logging.info(f"Response: {resp}")
    return resp

# --- Function to handle agent interactions ---
def agent_interaction(
    purpose,
    message,
    agent_name,
    system_prompt,
    history,
    temperature,
    max_new_tokens,
    top_p,
    repetition_penalty,
):
    # Format the prompt with history
    prompt = format_prompt(message, history, agent_name, system_prompt)

    # Run the LLM
    response = run_llm(
        prompt,
        stop_sequences=["observation:", "task:", "action:", "thought:"],
        max_tokens=max_new_tokens,
        temperature=temperature,
        top_p=top_p,
        repetition_penalty=repetition_penalty,
    )

    # Update history
    history.append((message, response))
    return history, history

# --- Function to parse actions from LLM response ---
def parse_action(line):
    """Parse the action line to get the action name and input."""
    parts = line.split(":", 1)
    if len(parts) == 2:
        action_name = parts[0].replace("action", "").strip()
        action_input = parts[1].strip()
    else:
        action_name = parts[0].replace("action", "").strip()
        action_input = ""
    return action_name, action_input

# --- Function to execute actions based on agent's response ---
def execute_action(purpose, task, history, action_name, action_input):
    logging.info(f"Executing Action: {action_name} - {action_input}")

    if action_name == "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)
                logging.info(f"Search Result: {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

    elif action_name == "COMPLETE":
        task = "END"
        return "COMPLETE", "COMPLETE", history, task

    elif action_name == "GENERATE_CODE":
        # Simulate OpenAI API response for code generation (using Hugging Face model)
        # ... (Implement code generation logic using a suitable Hugging Face model)
        # Example:
        # code = generate_code_from_huggingface_model(action_input)  # Replace with actual code generation function
        # history += f"observation: Here's the code: {code}\n"
        # return "MAIN", None, history, task
        pass  # Placeholder for code generation logic

    elif action_name == "RUN_CODE":
        # Simulate OpenAI API response for code execution (using Hugging Face model)
        # ... (Implement code execution logic using a suitable Hugging Face model)
        # Example:
        # output = execute_code_from_huggingface_model(action_input)  # Replace with actual code execution function
        # history += f"observation: Code output: {output}\n"
        # return "MAIN", None, history, task
        pass  # Placeholder for code execution logic

    else:
        # Default action: "MAIN"
        return "MAIN", action_input, history, task

# --- Function to handle the main loop of agent interaction ---
def run_agent(purpose, history):
    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:
        logging.info(f"---")
        logging.info(f"Purpose: {purpose}")
        logging.info(f"Task: {task}")
        logging.info(f"---")
        logging.info(f"History: {history}")
        logging.info(f"---")

        # Get the agent's next action
        prompt = f"""
        You are a helpful AI assistant. You are working on the task: {task}
        Your current history is:
        {history}
        What is your next thought?
        thought: 
        What is your next action?
        action: 
        """

        response = run_llm(
            prompt,
            stop_sequences=["observation:", "task:", "action:", "thought:"],
            max_tokens=32000,
        )

        # Parse the action
        lines = response.strip().strip("\n").split("\n")
        for line in lines:
            if line.startswith("thought: "):
                history += "{}\n".format(line)
                logging.info(f"Thought: {line}")
            elif line.startswith("action: "):
                action_name, action_input = parse_action(line)
                logging.info(f"Action: {action_name} - {action_input}")
                history += "{}\n".format(line)
                break

        # Execute the action
        action_name, action_input, history, task = execute_action(
            purpose, task, history, action_name, action_input
        )

        yield (history)
        if task == "END":
            return (history)

# --- Gradio Interface ---
def main():
    with gr.Blocks() as demo:
        gr.Markdown("## FragMixt - No-Code Development Powerhouse")
        gr.Markdown("### Your AI-Powered Development Companion")

        # Chat Interface
        chatbot = gr.Chatbot(show_label=False, show_share_button=False, show_copy_button=True, likeable=True, layout="panel")

        # Input Components
        message = gr.Textbox(label="Enter your message", placeholder="Ask me anything!")
        purpose = gr.Textbox(label="Purpose", placeholder="What is the purpose of this interaction?")
        agent_name = gr.Dropdown(label="Agents", choices=list(agents.keys()), value=list(agents.keys())[0], interactive=True)
        system_prompt = gr.Textbox(label="System Prompt", max_lines=1, interactive=True)
        temperature = 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")
        max_new_tokens = 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")
        top_p = 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")
        repetition_penalty = gr.Slider(label="Repetition penalty", value=1.2, minimum=1.0, maximum=2.0, step=0.05, interactive=True, info="Penalize repeated tokens")

        # Button to submit the message
        submit_button = gr.Button(value="Send")

        # Project Explorer Tab (Placeholder)
        with gr.Tab("Project Explorer"):
            project_path = gr.Textbox(label="Project Path", placeholder="/home/user/app/current_project")
            explore_button = gr.Button(value="Explore")
            project_output = gr.Textbox(label="File Tree", lines=20)

        # Chat App Logic Tab
        with gr.Tab("Chat App"):
            history = gr.State([])
            examples = [
                ["What is the purpose of this AI agent?", "I am designed to assist with no-code development tasks."],
                ["Can you help me generate a Python function to calculate the factorial of a number?", "Sure! Here is a Python function to calculate the factorial of a number:"],
            ]

        def chat(purpose, message, agent_name, system_prompt, temperature, max_new_tokens, top_p, repetition_penalty, history):
            # Get the system prompt for the selected agent
            system_prompt = agents.get(agent_name, {}).get("system_prompt", "")

            # Run the agent interaction
            history, history_output = agent_interaction(
                purpose,
                message,
                agent_name,
                system_prompt,
                history,
                temperature,
                max_new_tokens,
                top_p,
                repetition_penalty,
            )
            return history, history_output

        submit_button.click(
            chat,
            inputs=[
                purpose,
                message,
                agent_name,
                system_prompt,
                temperature,
                max_new_tokens,
                top_p,
                repetition_penalty,
                history,
            ],
            outputs=[chatbot, history],
        )

    demo.launch()

if __name__ == "__main__":
    main()