Update app.py

app.py

@@ -7,6 +7,15 @@ from io import StringIO
 import os
 import json
 from streamlit_ace import st_ace
+from agent import (
+    AppType,
+    createLlamaPrompt,
+    createSpace,
+    isPythonOrGradioAppPrompt,
+    isReactAppPrompt,
+    isStreamlitAppPrompt,
+    generateFiles,
+)
 
 # Set Hugging Face repository URL and project root path
 HUGGING_FACE_REPO_URL = "https://huggingface.co/spaces/acecalisto3/Mistri"
@@ -28,6 +37,16 @@ if 'current_state' not in st.session_state:
         'workspace_chat': {}
     }
 
+# Load Hugging Face models for code generation, translation, and conversation
+try:
+    code_generator = pipeline("text-generation", model="Salesforce/codegen-350M-mono")
+    translator = pipeline("translation_xx_to_yy", model="Helsinki-NLP/opus-mt-en-fr")  # Replace with appropriate language pair
+    conversational_model = AutoModelForCausalLM.from_pretrained("microsoft/DialoGPT-medium")
+    conversational_tokenizer = AutoTokenizer.from_pretrained("microsoft/DialoGPT-medium")
+    conversational_generator = pipeline("text-generation", model=conversational_model, tokenizer=conversational_tokenizer)
+except EnvironmentError as e:
+    st.error(f"Error loading Hugging Face models: {e}")
+
 # Define AIAgent class
 class AIAgent:
     def __init__(self, name, description, skills):
@@ -47,6 +66,13 @@ I am confident that I can leverage my expertise to assist you in developing and
     def autonomous_build(self, chat_history, workspace_projects):
         """
         Autonomous build logic based on chat history and workspace projects.
+        This function analyzes the chat history and workspace projects to determine the next steps in the development process.
+        It uses sentiment analysis to gauge the user's satisfaction and summarization to extract key information.
+        Args:
+            chat_history (list): A list of tuples containing user input and agent responses.
+            workspace_projects (dict): A dictionary of projects and their associated files.
+        Returns:
+            tuple: A tuple containing a summary of the current state and the suggested next step.
         """
         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}: {', '.join(ws_projects.keys())}" for p, ws_projects in workspace_projects.items()])
@@ -97,34 +123,48 @@ def create_agent_from_text(name, text):
 
 # Chat interface using a selected agent
 def chat_interface_with_agent(input_text, agent_name):
+    """
+    Provides a chat interface using a selected AI agent.
+    Loads the agent's prompt and uses a conversational model to generate responses.
+    Args:
+        input_text (str): The user's input text.
+        agent_name (str): The name of the selected AI agent.
+    Returns:
+        str: The AI agent's response.
+    """
     agent_prompt = load_agent_prompt(agent_name)
     if agent_prompt is None:
         return f"Agent {agent_name} not found."
 
-    # Load GPT-2 model
-    model_name = "gpt2"
-    try:
-        model = AutoModelForCausalLM.from_pretrained(model_name)
-        tokenizer = AutoTokenizer.from_pretrained(model_name)
-        generator = pipeline("text-generation", model=model, tokenizer=tokenizer)
-    except EnvironmentError as e:
-        return f"Error loading model: {e}"
-
     # Combine agent prompt with user input
     combined_input = f"{agent_prompt}\n\nUser: {input_text}\nAgent:"
 
-    # Truncate input text for model length limit
-    max_input_length = 900
-    input_ids = tokenizer.encode(combined_input, return_tensors="pt")
-    if input_ids.shape[1] > max_input_length:
-        input_ids = input_ids[:, :max_input_length]
-
     # Generate chatbot response
-    chatbot_response = generator(input_ids, max_length=150, min_length=30, do_sample=True)[0]['generated_text']
+    chatbot_response = conversational_generator(combined_input, max_length=150, min_length=30, do_sample=True)[0]['generated_text']
     return chatbot_response
 
+# Chat interface (default)
+def chat_interface(input_text):
+    """
+    Provides a general chat interface using a conversational model.
+    Args:
+        input_text (str): The user's input text.
+    Returns:
+        str: The chatbot's response.
+    """
+    # Generate response
+    response = conversational_generator(input_text, max_length=150, min_length=30, do_sample=True)[0]['generated_text']
+    return response
+
 # Workspace interface for creating projects
 def workspace_interface(project_name):
+    """
+    Creates a new project workspace.
+    Args:
+        project_name (str): The name of the project.
+    Returns:
+        str: A message indicating the status of the project creation.
+    """
     project_path = os.path.join(PROJECT_ROOT, project_name)
     if not os.path.exists(PROJECT_ROOT):
         os.makedirs(PROJECT_ROOT)
@@ -138,6 +178,15 @@ def workspace_interface(project_name):
 
 # Function to add code to the workspace
 def add_code_to_workspace(project_name, code, file_name):
+    """
+    Adds code to a specified file in a project workspace.
+    Args:
+        project_name (str): The name of the project.
+        code (str): The code to be added.
+        file_name (str): The name of the file.
+    Returns:
+        str: A message indicating the status of the code addition.
+    """
     project_path = os.path.join(PROJECT_ROOT, project_name)
     if os.path.exists(project_path):
         file_path = os.path.join(project_path, file_name)
@@ -152,6 +201,14 @@ def add_code_to_workspace(project_name, code, file_name):
 
 # Terminal interface with optional project context
 def terminal_interface(command, project_name=None):
+    """
+    Executes a terminal command with optional project context.
+    Args:
+        command (str): The terminal command to execute.
+        project_name (str, optional): The name of the project to execute the command in. Defaults to None.
+    Returns:
+        str: The output of the terminal command.
+    """
     if project_name:
         project_path = os.path.join(PROJECT_ROOT, project_name)
         if not os.path.exists(project_path):
@@ -165,9 +222,16 @@ def terminal_interface(command, project_name=None):
     else:
         st.session_state.current_state['toolbox']['terminal_output'] = result.stderr
         return result.stderr
-        
+
 # Code editor interface for formatting and linting
 def code_editor_interface(code):
+    """
+    Provides a code editor interface with formatting and linting capabilities.
+    Args:
+        code (str): The code to be edited.
+    Returns:
+        tuple: A tuple containing the formatted code and any linting messages.
+    """
     try:
         formatted_code = black.format_str(code, mode=black.FileMode())
     except black.NothingChanged:
@@ -185,6 +249,13 @@ def code_editor_interface(code):
 
 # Function to summarize text using a summarization pipeline
 def summarize_text(text):
+    """
+    Summarizes a given text using a Hugging Face summarization pipeline.
+    Args:
+        text (str): The text to be summarized.
+    Returns:
+        str: The summarized text.
+    """
     summarizer = pipeline("summarization")
     summary = summarizer(text, max_length=50, min_length=25, do_sample=False)
     st.session_state.current_state['toolbox']['summary'] = summary[0]['summary_text']
@@ -192,13 +263,29 @@ def summarize_text(text):
 
 # Function to perform sentiment analysis using a sentiment analysis pipeline
 def sentiment_analysis(text):
+    """
+    Performs sentiment analysis on a given text using a Hugging Face sentiment analysis pipeline.
+    Args:
+        text (str): The text to be analyzed.
+    Returns:
+        dict: The sentiment analysis result.
+    """
     analyzer = pipeline("sentiment-analysis")
     sentiment = analyzer(text)
     st.session_state.current_state['toolbox']['sentiment'] = sentiment[0]
     return sentiment[0]
 
-# Function to translate code using the OpenAI API
+# Function to translate code using the Hugging Face API
 def translate_code(code, input_language, output_language):
+    """
+    Translates code from one programming language to another using a Hugging Face translation pipeline.
+    Args:
+        code (str): The code to be translated.
+        input_language (str): The source programming language.
+        output_language (str): The target programming language.
+    Returns:
+        str: The translated code.
+    """
     # Define a dictionary to map programming languages to their corresponding file extensions
     language_extensions = {
         "Python": ".py",
@@ -218,31 +305,25 @@ def translate_code(code, input_language, output_language):
     input_extension = language_extensions[input_language]
     output_extension = language_extensions[output_language]
 
-    # Translate the code using the OpenAI API
-    prompt = f"Translate this code from {input_language} to {output_language}:\n\n{code}"
-    response = openai.ChatCompletion.create(
-        model="gpt-4",
-        messages=[
-            {"role": "system", "content": "You are an expert software developer."},
-            {"role": "user", "content": prompt}
-        ]
-    )
-    translated_code = response.choices[0].message['content'].strip()
+    # Translate the code using the Hugging Face API
+    translated_code = translator(code, max_length=1024)[0]['translation_text']
 
     # Return the translated code
     st.session_state.current_state['toolbox']['translated_code'] = translated_code
     return translated_code
 
-# Function to generate code based on a code idea using the OpenAI API
+# Function to generate code based on a code idea using the Hugging Face API
 def generate_code(code_idea):
-    response = openai.ChatCompletion.create(
-        model="gpt-4",
-        messages=[
-            {"role": "system", "content": "You are an expert software developer."},
-            {"role": "user", "content": f"Generate a Python code snippet for the following idea:\n\n{code_idea}"}
-        ]
-    )
-    generated_code = response.choices[0].message['content'].strip()
+    """
+    Generates code based on a given code idea using a Hugging Face code generation pipeline.
+    Args:
+        code_idea (str): The code idea or description.
+    Returns:
+        str: The generated code.
+    """
+    # Generate code using the Hugging Face API
+    generated_code = code_generator(f"```python\n{code_idea}\n```", max_length=512)[0]['generated_text']
+
     st.session_state.current_state['toolbox']['generated_code'] = generated_code
     return generated_code
 
@@ -355,7 +436,7 @@ elif app_mode == "Tool Box":
     }
     for command_name, command in preset_commands.items():
         st.write(f"{command_name}: `{command}`")
-        
+
 # Workspace Chat App
 elif app_mode == "Workspace Chat App":
     st.header("Workspace Chat App")