Update backend/agent.py

backend/agent.py

@@ -1,83 +1,44 @@
-import asyncio, subprocess, json, os, re
+import asyncio, subprocess, re, json
 from pathlib import Path
-from typing import List, Dict, Any
+from typing import List, Dict
 from model_router import route_chat
-import uuid
-
-# ---------- Tool definitions ----------
-def read_file(filepath: str, project_path: Path) -> str:
-    full_path = project_path / filepath
-    if full_path.exists():
-        return full_path.read_text()
-    return f"Error: File not found: {filepath}"
-
-def write_file(filepath: str, content: str, project_path: Path) -> str:
-    full_path = project_path / filepath
-    full_path.parent.mkdir(parents=True, exist_ok=True)
-    full_path.write_text(content)
-    return f"File written: {filepath}"
-
-def run_command(command: str, cwd: str) -> str:
-    try:
-        result = subprocess.run(command, shell=True, cwd=cwd, capture_output=True, text=True, timeout=30)
-        return result.stdout + result.stderr
-    except subprocess.TimeoutExpired:
-        return "Command timed out."
-
-def list_dir(path: str, project_path: Path) -> List[str]:
-    full_path = project_path / path if path else project_path
-    try:
-        return os.listdir(full_path)
-    except:
-        return []
-
-# ---------- Agent class ----------
+
 class CodingAgent:
     def __init__(self, project_path: str, model: str = "groq-llama-3.3-70b-versatile"):
         self.project_path = Path(project_path)
         self.model = model
         self.status = "idle"
         self.logs = []
-        self.pending_changes = []   # list of {action, filepath, content/search/replace}
-        self.max_steps = 10
+        self.pending_changes = []
 
-    async def run_task(self, task: str):
-        """Main agent loop with tool calls."""
+    async def run_task(self, task: str) -> dict:
+        """New agent loop – returns {logs, pending_changes}."""
         self.status = "running"
         self.logs = []
         self.pending_changes = []
 
-        system = f"""You are an AI coding agent. Your goal is to complete the user's task step by step.
-You are working in the project folder: {self.project_path}.
-You have access to these tools (use exactly these function names):
-- read_file(filepath) – returns file contents
-- write_file(filepath, content) – creates or overwrites a file
-- edit_file(filepath, search, replace) – replaces the first occurrence of 'search' with 'replace' in the file
-- run_command(command) – executes a shell command, returns output
-- list_dir(path) – lists files in a directory (path can be empty for root)
-- task_complete() – call this when the task is fully finished
-
-For each step, you must output a JSON object with two keys:
-- "thought": a short description of what you are doing
-- "tool": the name of the tool to call
-- "arguments": the arguments for the tool (as a dictionary)
+        system = f"""You are an AI coding agent. Complete the user's task step by step.
+You work in the project folder: {self.project_path}.
+Available tools (respond with a JSON object containing "thought", "tool", and "arguments"):
+- read_file(filepath)
+- write_file(filepath, content)
+- edit_file(filepath, search, replace)
+- run_command(command)
+- list_dir(path)
+- task_complete()
 
-Example:
-{{"thought": "I need to see the current code", "tool": "read_file", "arguments": {{"filepath": "main.py"}}}}
-
-DO NOT output anything except the JSON object. If you need to talk, use the "thought" field."""
+Example: {{"thought": "I need to see the code", "tool": "read_file", "arguments": {{"filepath": "main.py"}}}}
+Only output the JSON object."""
 
         messages = [
             {"role": "system", "content": system},
             {"role": "user", "content": task}
         ]
 
-        for step in range(self.max_steps):
-            # Get agent's next action
+        for step in range(8):
             response = await self._generate(messages)
             self.logs.append(f"Step {step+1}: {response[:150]}...")
 
-            # Parse the JSON action
             action = self._parse_action(response)
             if not action:
                 messages.append({"role": "user", "content": "Invalid JSON. Please output only the JSON action."})
@@ -87,12 +48,10 @@ DO NOT output anything except the JSON object. If you need to talk, use the "tho
             tool = action.get("tool", "")
             args = action.get("arguments", {})
 
-            # Execute tool
             result = ""
             if tool == "read_file":
-                result = read_file(args.get("filepath", ""), self.project_path)
+                result = self._read_file(args.get("filepath", ""))
             elif tool == "write_file":
-                # Queue the change instead of writing immediately
                 filepath = args.get("filepath", "")
                 content = args.get("content", "")
                 self.pending_changes.append({"action": "create", "filepath": filepath, "content": content})
@@ -101,8 +60,7 @@ DO NOT output anything except the JSON object. If you need to talk, use the "tho
                 filepath = args.get("filepath", "")
                 search = args.get("search", "")
                 replace = args.get("replace", "")
-                # Read current file, apply change, write back (temporary, will be approved later)
-                current = read_file(filepath, self.project_path)
+                current = self._read_file(filepath)
                 if search in current:
                     modified = current.replace(search, replace)
                     self.pending_changes.append({"action": "edit", "filepath": filepath, "original": current, "modified": modified})
@@ -110,49 +68,59 @@ DO NOT output anything except the JSON object. If you need to talk, use the "tho
                 else:
                     result = f"Search string not found in {filepath}"
             elif tool == "run_command":
-                result = run_command(args.get("command", ""), str(self.project_path))
+                result = self._run_command(args.get("command", ""))
             elif tool == "list_dir":
-                result = "\n".join(list_dir(args.get("path", ""), self.project_path))
+                result = "\n".join(self._list_dir(args.get("path", "")))
             elif tool == "task_complete":
                 self.logs.append("Agent marked task complete.")
                 break
             else:
                 result = f"Unknown tool: {tool}"
 
-            # Feed result back to model
             messages.append({"role": "assistant", "content": response})
             messages.append({"role": "user", "content": f"Tool result: {result}"})
 
         self.status = "awaiting_approval"
-        # Return a summary and the pending changes
-        return {
-            "logs": self.logs,
-            "pending_changes": self.pending_changes
-        }
+        return {"logs": self.logs, "pending_changes": self.pending_changes}
 
     async def approve_and_apply(self):
-        """Apply all pending changes."""
         self.status = "applying"
         for change in self.pending_changes:
             try:
                 if change["action"] == "create":
-                    write_file(change["filepath"], change["content"], self.project_path)
+                    (self.project_path / change["filepath"]).parent.mkdir(parents=True, exist_ok=True)
+                    (self.project_path / change["filepath"]).write_text(change["content"])
                     self.logs.append(f"Created {change['filepath']}")
                 elif change["action"] == "edit":
-                    write_file(change["filepath"], change["modified"], self.project_path)
+                    (self.project_path / change["filepath"]).write_text(change["modified"])
                     self.logs.append(f"Edited {change['filepath']}")
             except Exception as e:
                 self.logs.append(f"Error: {e}")
         self.pending_changes = []
         self.status = "completed"
 
-    def _parse_action(self, text: str) -> Dict | None:
+    def _read_file(self, filepath: str) -> str:
+        p = self.project_path / filepath
+        return p.read_text() if p.exists() else "File not found."
+
+    def _run_command(self, cmd: str) -> str:
+        try:
+            r = subprocess.run(cmd, shell=True, cwd=self.project_path, capture_output=True, text=True, timeout=30)
+            return r.stdout + r.stderr
+        except Exception as e:
+            return str(e)
+
+    def _list_dir(self, path: str) -> list:
+        p = self.project_path / path if path else self.project_path
+        try:
+            return [f.name for f in p.iterdir()]
+        except:
+            return []
+
+    def _parse_action(self, text: str) -> dict | None:
         text = text.strip()
-        # Remove any markdown fences
-        if text.startswith("```"):
-            text = text[3:]
-        if text.endswith("```"):
-            text = text[:-3]
+        if text.startswith("```"): text = text[3:]
+        if text.endswith("```"): text = text[:-3]
         try:
             return json.loads(text)
         except: