addeed chat

.gitignore

@@ -0,0 +1,5 @@
+.env
+.env.local
+.env.development
+/__pycache__/
+

app.py

@@ -1,6 +1,7 @@
 import gradio as gr
 import json
 import os
+from smol import ChatAgent
 
 GLOBAL_STATE_FILE = "global_state.json"
 if os.path.exists(GLOBAL_STATE_FILE):
@@ -9,25 +10,36 @@ if os.path.exists(GLOBAL_STATE_FILE):
 else:
     global_game_state = {}  # initialize an empty state
 
-# TODO: Function to handle chat updates. 
-def process_chat(message, local_state):
-    # Initialize local state if None
-    local_state = local_state or {}
-    # Update local state with the latest message
-    local_state["last_message"] = message
+def process_chat(message, chat_history):
+    if chat_history is None:
+        chat_history = []
+
+    chat_history.append(("User", message))
+    
+    response = ChatAgent(message)
+
+    chat_history.append(("AI", response))
+    
+    return "", chat_history
+
+def chat_function(user_prompt, history):
+    # Initialize history if empty
+    if history is None:
+        history = []
+    # Append the user's message as a dictionary
+    history.append({"role": "user", "content": user_prompt})
     
-    # Check for a command to update the global game state
-    if message.strip().lower() == "update global":
-        # Update the global state
-        global global_game_state
-        global_game_state = local_state.copy()
-        # Optionally persist the global state to a file
-        with open(GLOBAL_STATE_FILE, "w") as f:
-            json.dump(global_game_state, f)
-        response = "Global game updated!"
-    else:
-        response = f"Local game updated with: {message}"
-    return "", local_state, response
+    # Process the prompt using your ChatAgent to get the AI response
+    ai_response = ChatAgent(user_prompt)
+    print(f"AI RESPONSE: {ai_response}")
+    print("HISTORY: ", history)
+    
+    # Append the AI's response as a dictionary
+    history.append({"role": "assistant", "content": ai_response})
+    
+    # Clear the input and return the updated history
+    return "", history
+
 
 with gr.Blocks() as demo:
     gr.Markdown("## Live Game & Chat Interface")
@@ -45,17 +57,25 @@ with gr.Blocks() as demo:
         # Right Column: Chat interface (smaller column)
         with gr.Column(scale=1):
             gr.Markdown("### Chat")
-            chat_output = gr.Textbox(label="Chat Output", interactive=False)
-            chat_input = gr.Textbox(
-                placeholder="Type your message here...",
-                label="Your Message"
-            )
-            local_state = gr.State({})
+            chatbot = gr.Chatbot(type="messages",label="Conversation")
+            # Textbox to receive user prompt
+            txt_input = gr.Textbox(placeholder="Type your prompt here...", label="Your Message")
+            # State to hold the conversation history
+            state = gr.State([])
+            
+            # When the user submits a message, update the chat
+            txt_input.submit(chat_function, inputs=[txt_input, state], outputs=[txt_input, chatbot])
+            # chat_output = gr.Chatbot(label="Chat Output", type="messages", interactive=False)
+            # chat_input = gr.Textbox(
+            #     placeholder="Type your message here...",
+            #     label="Your Message"
+            # )
+            # chat_history = gr.State([])
 
-            chat_input.submit(
-                process_chat,
-                inputs=[chat_input, local_state],
-                outputs=[chat_input, local_state, chat_output],
-            )
+            # chat_input.submit(
+            #     process_chat,
+            #     inputs=[chat_input, chat_history],
+            #     outputs=[chat_input, chat_output],
+            # )
 
 demo.launch()

smol.py

@@ -0,0 +1,74 @@
+import os
+import shutil
+
+from smolagents import CodeAgent, DuckDuckGoSearchTool, Tool, HfApiModel
+from dotenv import load_dotenv, dotenv_values 
+from tool import FindFilesTool, GitPushTool, FileReplaceTool, ProcessFlowIdentifierTool, GetImageDimensionsTool, FileModifyTool
+
+load_dotenv() 
+
+HF_TOKEN = os.getenv("HF_TOKEN")
+
+image_generation_tool = Tool.from_space(
+    "black-forest-labs/FLUX.1-schnell",
+    name="image_generator",
+    description="Generate an image from a prompt"
+)
+
+model = HfApiModel("Qwen/Qwen2.5-Coder-32B-Instruct", token=HF_TOKEN)
+"""
+Todo:
+- prompt cleaning
+- ensure github upload pathways
+==============
+step 1: receive prompt
+(deferred for now) step 2: analyze prompt for specific task (asset change, script change, etc) 
+step 3: crawl files to search for specific file that matches task and save file location
+step 4: run appropriate tool to accomplish task
+step 5: upload changes to github
+"""
+
+find_files_tool = FindFilesTool()
+file_replace_tool = FileReplaceTool()
+process_identifier_tool= ProcessFlowIdentifierTool()
+get_image_dimensions_tool= GetImageDimensionsTool()
+file_modify_tool = FileModifyTool()
+
+def ChatAgent(userPrompt):
+    #Identify purpose of prompt
+    promptCleanerAgent = CodeAgent(tools=[], model=model)
+    instructions = promptCleanerAgent.run(f"""
+        determine the purpose of the following string "{userPrompt}" if it is one of the following: [asset_change, script_update, conversation].
+        asset_change: The user wants to change an asset in the game.
+        script_update: The user wants to update the game script.
+        conversation: The user wants to have a conversation with the AI by asking general questions or greetings.
+    """)
+    
+    appDescription = """
+        This is a 2d platformer game where the player controls a ball that bounces off platforms falling down. This app
+        uses typescript and sandpack. The folder components/sandpack-examples.tsx file contains the game logic and scripts.
+    """
+    if(instructions == "conversation"):
+        contextPrompt = f"""
+            User prompt '{userPrompt}'
+            1) Reply to the user as a friendly ai agent.
+            2) Do not use any tools to modify files.
+            3) End process after replying to the user.
+        """
+    else:
+        contextPrompt = f'using process_identifier_tool look for the appropriate instructions for "{instructions}" and apply it to the user prompt after this'
+
+    agent = CodeAgent(tools=[find_files_tool, process_identifier_tool, image_generation_tool, file_modify_tool, get_image_dimensions_tool, file_replace_tool], model=model)
+    if instructions == "conversation":
+        response = agent.run(f"{contextPrompt}")
+    else:
+        response = agent.run(f"{appDescription} {contextPrompt} {userPrompt} ")
+    # agent = CodeAgent(tools=[DuckDuckGoSearchTool()], model=HfApiModel())
+    # Step 1: Prompt reception
+    print(f"Response made: {response}")
+    return response
+    # # Run the agent to generate an image based on a prompt
+    # # Check if the image path exists
+    # update_git_tool = GitPushTool()
+    # agent = CodeAgent(tools=[update_git_tool], model=model)
+    # agent.run("commit to new branch and push to repo", additional_args={'branch_name': 'image-replace-tool-5'})

tool.py

@@ -0,0 +1,248 @@
+from smolagents import CodeAgent, DuckDuckGoSearchTool, Tool, HfApiModel
+import os
+from dotenv import load_dotenv
+class FileReaderTool(Tool):
+    name = "file_reader_tool"
+    description = """
+    This tool will be used by the LLM Agent to read files to help analyze files for its task.
+    """
+    inputs = {
+        "file_location": {
+            "type": "string",
+            "description": "The location of the file that will be read/analyzed"
+        }
+    }
+    output_type = "string"
+
+    def forward(self,file_location ) -> str:
+        with open(file_location, "r") as file:
+            return file.read()
+        
+class FileWriteTool(Tool):
+    name = "file_write_tool"
+    description = """
+    This tool will be used by the LLM Agent to overwrite files if needed for task.
+    """
+    inputs = {
+        "file_location": {
+            "type": "string",
+            "description": "The location of the file that will be read/analyzed"
+        },
+        "new_code": {
+            "type": "string",
+            "description": "This is the code that will overwrite the contents of a file. If file does not exist, it is the new content."
+        }
+    }
+    output_type = "string"
+
+    def forward(self,file_location, new_code) -> str:
+        with open(file_location, "w") as file:
+            return file.write(new_code)
+
+class FileModifyTool(Tool):
+    name = "file_modify_tool"
+    description = """
+    This tool will be used by the LLM Agent to modify files if needed for task.
+    """
+    inputs = {
+        "file_location": {
+            "type": "string",
+            "description": "The location of the file that will be read/analyzed"
+        },
+        "prompt": {
+            "type": "string",
+            "description": "This is the prompt that the LLM will use to decide how to modify the code."
+        }
+    }
+    output_type = "string"
+
+    def forward(self,file_location, prompt) -> str:
+        load_dotenv() 
+
+        HF_TOKEN = os.getenv("HF_TOKEN")
+
+        file_reader_tool = FileReaderTool()
+        file_write_tool = FileWriteTool()
+
+        model = HfApiModel("Qwen/Qwen2.5-Coder-32B-Instruct", token=HF_TOKEN)
+        coderAgent = CodeAgent(tools=[], model=model)
+
+        file_content = file_reader_tool.forward(file_location)
+
+        if not file_content:
+            return "Error: File could not be read."
+
+        modified_code = coderAgent.run(f'Based on the prompt "{prompt}" \n Modify the following code:\n{file_content}\n')
+        if "ERROR" in modified_code:
+            return "Modification failed, please refine your request."
+        write_result = file_write_tool.forward(file_location, modified_code)
+        return
+        
+
+
+class FileReplaceTool(Tool):
+    name = "file_replace_tool"
+    description ="""
+    This tool will be used to replace the file in a given location with the provided new file location. This is not used to update files.
+    """
+    inputs = {
+        "target_file_location": {
+            "type": "string",
+            "description": "the location of the file that will be replaced"
+        },
+        "new_file_location": {
+            "type": "string",
+            "description": "the location of the new file to replace target file location"
+        }
+    }
+    output_type = "string"
+    def forward(self, target_file_location, new_file_location) -> str:
+        import os
+        import shutil
+
+        if os.path.exists(new_file_location):
+            # Define the destination path for the saved image
+        #     # Create the './generatedImages' directory if it doesn't exist
+        #     # Copy the image from the temporary location to the desired directory
+            shutil.copy(new_file_location, target_file_location)
+
+            return print(f"Image saved to {target_file_location}")
+        else:
+            return print("Failed to generate an image or the file does not exist.")
+        
+class GetImageDimensionsTool(Tool):
+    name = "get_image_dimensions_tool"
+    description= """
+    This tool is used to get the width and height of a webp file.
+    """
+    inputs = {
+        "file_location": {
+            "type": "string",
+            "description": "The location in which the webp file can be located"
+        }
+    }
+    output_type = "object"
+    def forward(self, file_location) -> dict:
+        from PIL import Image
+
+        with Image.open(file_location) as img:
+            width, height = img.size
+
+        return {"width": width, "height": height}
+
+class ProcessFlowIdentifierTool(Tool):
+    name = "process_flow_identifier_tool"
+    description = """
+    This tool will be used to give a set of instructions depending on the purpose of the prompt. This is to aid the LLM in its decision making process.
+    """
+    inputs = {
+        "prompt_objective": {
+            "type": "string",
+            "description": "This is the objective of the user's original prompt to help identify the steps needed for the llm to take."
+        }
+    }
+    output_type = "string"
+    def forward(self, prompt_objective) -> str:
+        match prompt_objective:
+            case "asset_change":
+                instructions = """
+                    1) use the find files tool to get a list of files containing tsx, and find the sandpack-examples.tsx file and copy its path. 
+                    2) Use the file_modify_tool to analyze and update the file.
+                    3) End process after sucessfully modifying the file
+                """
+                return instructions
+            case "script_change":
+                instructions = """
+                    1) use the find files tool to get a list of files containing tsx, and find the sandpack-examples.tsx file and copy its path. 
+                    2) Use the file_modify_tool to analyze and update the file.
+                    3) End process after sucessfully modifying the file
+                """
+                return instructions
+            case "conversation":
+                """
+                    1) Reply to the user with the last message they sent as a friendly ai agent.
+                    2) Do not use any tools to modify files.
+                    3) End process after replying to the user.
+                """
+            case _:
+                instructions = """
+                inform user that the instructions where unclear
+                """
+                return instructions
+        
+
+class GitPushTool(Tool):
+    name = "git_push_tool"
+    description = """
+    This tool will be triggered to create a new branch and push new changes to the repository.
+    """
+    inputs = {
+        "branch_name": {
+            "type": "string",
+            "description": "the target branch that will be pushed, new or existing."
+        }
+    }
+    output_type = "string"
+
+    def forward(self, branch_name) -> str:
+        import os
+        import subprocess
+        try:
+            gitUsername = os.getenv("GIT_USERNAME")
+            gitEmail = os.getenv("GIT_EMAIL")
+            # new_branch = "add-generated-image-2"
+            # Step 1: Ensure we are in a Git repository
+            subprocess.run(["git", "status"], check=True)
+
+            # Step 2: Create and switch to a new branch
+            subprocess.run(["git", "checkout", "-b", branch_name], check=True)
+            print(f"Checked out to new branch: {branch_name}")
+
+            # Step 3: Add the changes
+            subprocess.run(["git", "add", "*"], check=True)
+            print("Changes added to staging.")
+            # Step 4: Add credentials
+            subprocess.run(["git", "config", "--global", "user.email", gitEmail], check=True)
+            print("Updated git email.")
+            subprocess.run(["git", "config", "--global", "user.name", gitUsername], check=True)
+            print("Updated git user name.")
+
+            # Step 5: Commit the changes
+            commit_message = "Add generated image to repository"
+            subprocess.run(["git", "commit", "-m", commit_message], check=True)
+            print("Changes committed.")
+
+            #Step 6: Push the branch to the remote repository
+            subprocess.run(["git", "push", "--set-upstream", "origin", branch_name], check=True)
+            return print(f"Branch '{branch_name}' pushed to remote repository.")
+        except subprocess.CalledProcessError as e:
+            return print(f"An error occurred while performing Git operations: {e}")
+
+class FindFilesTool(Tool):
+    name = "find_files"
+    description = "Find files with a given extension in a directory and its subdirectories"
+    inputs = {"extension":{"type":"string","description":"the place from which you start your ride"}}
+  
+    output_type = "string"
+
+    def forward(self, extension: str) -> str:
+        """
+        Recursively search for files with a given extension in a directory and its subdirectories.
+
+        Args:
+            extension: The file extension to look for (e.g., '.txt')
+        """
+        import os
+
+        root_dir = "./"
+        found_files = []
+
+        # Walk through the directory tree
+        for dirpath, dirnames, filenames in os.walk(root_dir):
+            for filename in filenames:
+                if filename.endswith(extension):
+                    filepath = os.path.join(dirpath, filename)
+                    absolute_path = os.path.abspath(filepath)
+                    found_files.append(absolute_path)
+
+        return found_files