Updated python code to be able to update vercel code

smol.py

@@ -3,7 +3,7 @@ import shutil
 
 from smolagents import CodeAgent, DuckDuckGoSearchTool, Tool, HfApiModel
 from dotenv import load_dotenv, dotenv_values 
-from tool import GetGameFileNamesTool, FindFilesTool, GitPushTool, FileReplaceTool, ProcessFlowIdentifierTool, GetImageDimensionsTool, FileModifyTool
+from tool import GetGameFileNamesTool, ReadFilesTool, UpdateGameFileTool, GitPushTool, ProcessFlowIdentifierTool, GetImageDimensionsTool
 
 load_dotenv() 
 
@@ -29,19 +29,21 @@ step 5: upload changes to github
 """
 
 get_game_file_names_tool = GetGameFileNamesTool()
-find_files_tool = FindFilesTool()
-file_replace_tool = FileReplaceTool()
+read_files_tool = ReadFilesTool()
 process_identifier_tool= ProcessFlowIdentifierTool()
 get_image_dimensions_tool= GetImageDimensionsTool()
-file_modify_tool = FileModifyTool()
+update_game_file_tool = UpdateGameFileTool()
+# file_replace_tool = FileReplaceTool()
+# 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.
+        determine the purpose of the following string "{userPrompt}" if it is one of the following: [asset_change, read_file, script_update, conversation].
+        asset_change: The user wants to change an asset from the game.
+        read_file: The user wants to read a file from 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.
     """)
@@ -63,7 +65,7 @@ def ChatAgent(userPrompt):
     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=[get_game_file_names_tool, find_files_tool, process_identifier_tool, image_generation_tool, file_modify_tool, get_image_dimensions_tool, file_replace_tool], model=model)
+    agent = CodeAgent(tools=[get_game_file_names_tool, read_files_tool, update_game_file_tool, process_identifier_tool, image_generation_tool, get_image_dimensions_tool], model=model)
 
     if instructions == "conversation":
         response = agent.run(f"{contextPrompt}")

tool.py

@@ -8,36 +8,20 @@ load_dotenv()
 HF_TOKEN = os.getenv("HF_TOKEN")
 NOODLE_PUBLIC_API_URL = os.getenv("NOODLE_PUBLIC_API_URL")
 
-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.
+    This tool will be used by the LLM Agent to create files if needed for task. Always put the files in the /ai-code directory from the root of this project.
     """
     inputs = {
         "file_location": {
             "type": "string",
-            "description": "The location of the file that will be read/analyzed"
+            "description": "The location of the file that will be written to. Please put this in the /ai-code directory."
         },
         "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."
+            "description": "This is the content of the file."
         }
     }
     output_type = "string"
@@ -46,73 +30,6 @@ class FileWriteTool(Tool):
         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:
-        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= """
@@ -149,16 +66,25 @@ class ProcessFlowIdentifierTool(Tool):
         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
+                    1) use the get_game_file_names_tool to get the list of accessible game files. If user specifies what file, do this still to check if they can access it.
+                    2) Use the read_file_tool to read the file contents of the file from step 1. Remember to save the path of the file, this will be used to update the file.
+                    3) Based on the prompt, make changes to the code from step 2 and pass it to the update_game_file_tool along with the path saved from step1.
+                    4) End process after sucessfully modifying the file
+                """
+                return instructions
+            case "read_file":
+                instructions = """
+                    1) use the get_game_file_names_tool to get the list of accessible game files. If user specifies what file, do this still to check if they can access it.
+                    2) Use the read_file_tool to read the file contents of the file from step 1.
+                    3) End process after reading 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
+                    1) use the get_game_file_names_tool to get the list of accessible game files. If user specifies what file, do this still to check if they can access it.
+                    2) Use the read_file_tool to read the file contents of the file from step 1. Remember to save the path of the file, this will be used to update the file.
+                    3) Based on the prompt, make changes to the code from step 2 and use the update_game_file_tool.
+                    4) End process after sucessfully modifying the file
                 """
                 return instructions
             case "conversation":
@@ -221,6 +147,7 @@ class GitPushTool(Tool):
         except subprocess.CalledProcessError as e:
             return print(f"An error occurred while performing Git operations: {e}")
 
+# READ
 class GetGameFileNamesTool(Tool):
     name="get_game_file_names_tool"
     description="""
@@ -238,33 +165,56 @@ class GetGameFileNamesTool(Tool):
         else:
             print("Failed to get file content")
         return response.json()['content']
-        
 
-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"}}
-  
+# UPDATE
+class UpdateGameFileTool(Tool):
+    name = "update_game_file_tool"
+    description = """
+        Update the game file via an api by sending the updated code for the nextjs game app to handle.
+    """
+    inputs = {
+        "file_path": {
+            "type": "string",
+            "description": "The path from the game directory to update."
+        },
+        "new_content": {
+            "type": "string",
+            "description": "The updated code."
+        }
+    }
     output_type = "string"
 
-    def forward(self, extension: str) -> str:
+    def forward(self, file_path: str, new_content: 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')
+        Make an api call to update the file from a secure api route.
         """
-        import os
+        update_file_contents = NOODLE_PUBLIC_API_URL + "/api/files/"
+        headers = {
+            "Content-Type": "application/octet-stream"
+        }
+        binary_data = new_content.encode("utf-8")
 
-        root_dir = "./"
-        found_files = []
+        response = requests.put(update_file_contents, params={"path": file_path}, headers=headers, data=binary_data)
+        if response.status_code == 200:
+            return 
+        else:
+            return "Failed to update file contents"
 
-        # 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)
+class ReadFilesTool(Tool):
+    name = "read_file_tool"
+    description = "Read the file contents of the given game file path."
+    inputs = {"file_path":{"type":"string","description":"the path to the directory to search in"},}
+  
+    output_type = "string"
 
-        return found_files
+    def forward(self, file_path: str) -> str:
+        """
+        Make an api call to browse the file from the game through an api call. The file path must be passed to view the file.
+        """
+        read_file_contents = NOODLE_PUBLIC_API_URL + "/api/files/"
+        response = requests.get(f"{read_file_contents}", params={"path": file_path})
+        if response.status_code == 200:
+            return response.json()['content']
+        else:
+            return "Failed to read file contents"
+        return