God Mode+ v3 fix: agents/debug_agent.py

agents/debug_agent.py

@@ -1,29 +1,18 @@
 """
-DebugAgent — Autonomous error detection, self-healing, retry loops
+DebugAgent — Code debugging via LLMRouter
 """
-import json
-import re
-from typing import Dict, List
 import structlog
+from typing import Dict
 from .base_agent import BaseAgent
 
 log = structlog.get_logger()
 
-DEBUG_SYSTEM = """You are an expert debugging engineer with deep knowledge of:
-- Python, TypeScript, JavaScript, Go, Rust errors
-- Runtime exceptions, import errors, type errors
-- API errors, network failures, auth issues
-- Build failures, dependency conflicts
-- Database errors, query optimization
-
-When given an error:
-1. Identify the root cause precisely
-2. Provide the EXACT fix (code patch or config change)
-3. Explain WHY it failed
-4. Suggest prevention strategies
-
-Always return actionable fixes, not just explanations.
-"""
+DEBUG_SYSTEM = """You are an expert debugger and code reviewer.
+When given code with errors, you:
+1. Identify the root cause
+2. Explain the issue clearly
+3. Provide a complete fixed version
+4. Suggest best practices to prevent similar issues"""
 
 
 class DebugAgent(BaseAgent):
@@ -31,123 +20,11 @@ class DebugAgent(BaseAgent):
         super().__init__("DebugAgent", ws_manager, ai_router)
 
     async def run(self, task: str, context: Dict = {}, **kwargs) -> str:
-        session_id = kwargs.get("session_id", "")
-        task_id = kwargs.get("task_id", "")
-        attempt = context.get("attempt", 1)
-
-        await self.emit(task_id, "agent_start", {
-            "agent": "DebugAgent",
-            "attempt": attempt,
-            "error": task[:100],
-        }, session_id)
-
-        messages = [
+        session_id = kwargs.get("session_id", context.get("session_id", ""))
+        task_id    = kwargs.get("task_id",    context.get("task_id", ""))
+        messages   = [
             {"role": "system", "content": DEBUG_SYSTEM},
-            {"role": "user", "content": (
-                f"Debug and fix this issue (attempt {attempt}):\n\n"
-                f"{task}\n\n"
-                f"Provide:\n"
-                f"1. Root cause analysis\n"
-                f"2. Exact fix (code/config)\n"
-                f"3. Prevention strategy"
-            )},
+            {"role": "user",   "content": f"Debug this:\n\n{task}"},
         ]
-
-        result = await self.llm(
-            messages,
-            task_id=task_id,
-            session_id=session_id,
-            temperature=0.1,
-            max_tokens=4096,
-        )
-
-        await self.emit(task_id, "debug_complete", {
-            "agent": "DebugAgent",
-            "has_fix": "```" in result or "fix" in result.lower(),
-            "attempt": attempt,
-        }, session_id)
-
-        return result
-
-    async def analyze_error(self, error_output: str, source_code: str = "", task_id: str = "", session_id: str = "") -> Dict:
-        """Deep error analysis with structured output."""
-        messages = [
-            {"role": "system", "content": DEBUG_SYSTEM},
-            {"role": "user", "content": (
-                f"Analyze this error and provide structured diagnosis:\n\n"
-                f"Error:\n{error_output[:2000]}\n\n"
-                f"{'Source Code:\\n```\\n' + source_code[:1000] + '\\n```' if source_code else ''}\n\n"
-                f"Respond with JSON:\n"
-                f'{{"error_type": "...", "root_cause": "...", "fix": "...", "prevention": "...", "severity": "low|medium|high|critical"}}'
-            )},
-        ]
-        raw = await self.llm(messages, task_id=task_id, session_id=session_id, temperature=0.1, max_tokens=1000)
-        try:
-            start = raw.find("{")
-            end = raw.rfind("}") + 1
-            return json.loads(raw[start:end])
-        except Exception:
-            return {"error_type": "unknown", "root_cause": error_output[:200], "fix": raw[:500], "severity": "medium"}
-
-    async def self_heal_loop(
-        self,
-        code: str,
-        error: str,
-        max_retries: int = 3,
-        task_id: str = "",
-        session_id: str = "",
-    ) -> str:
-        """Self-healing loop — generate fix, validate, retry."""
-        current_code = code
-        current_error = error
-
-        for attempt in range(1, max_retries + 1):
-            await self.emit(task_id, "self_heal_attempt", {
-                "attempt": attempt,
-                "max_retries": max_retries,
-                "error_snippet": current_error[:100],
-            }, session_id)
-
-            messages = [
-                {"role": "system", "content": DEBUG_SYSTEM},
-                {"role": "user", "content": (
-                    f"Fix attempt {attempt}/{max_retries}:\n\n"
-                    f"Error: {current_error}\n\n"
-                    f"Code:\n```\n{current_code[:3000]}\n```\n\n"
-                    f"Return ONLY the fixed code."
-                )},
-            ]
-
-            fixed = await self.llm(messages, task_id=task_id, session_id=session_id, temperature=0.1, max_tokens=8192)
-            fixed = self._strip_fences(fixed)
-
-            # Validate syntax for Python
-            validation = await self._validate_python(fixed)
-            if validation["valid"]:
-                await self.emit(task_id, "self_heal_success", {
-                    "attempt": attempt,
-                    "code_lines": len(fixed.split("\n")),
-                }, session_id)
-                return fixed
-            else:
-                current_code = fixed
-                current_error = validation["error"]
-                log.warning("Self-heal attempt failed", attempt=attempt, error=current_error[:100])
-
-        await self.emit(task_id, "self_heal_failed", {"attempts": max_retries}, session_id)
-        return current_code  # Return best attempt
-
-    async def _validate_python(self, code: str) -> Dict:
-        """Quick Python syntax validation."""
-        try:
-            compile(code, "<string>", "exec")
-            return {"valid": True, "error": ""}
-        except SyntaxError as e:
-            return {"valid": False, "error": f"SyntaxError: {e}"}
-        except Exception as e:
-            return {"valid": False, "error": str(e)}
-
-    def _strip_fences(self, text: str) -> str:
-        text = re.sub(r"^```[\w]*\n", "", text.strip())
-        text = re.sub(r"\n```$", "", text)
-        return text
+        await self.emit(task_id, "debug_started", {"task": task[:100]}, session_id)
+        return await self.ask_llm(messages=messages, task_id=task_id, session_id=session_id, temperature=0.2)