devcouncil 0.1.0 → 0.2.0

package/src/devcouncil/executors/mini_swe.py

@@ -1,19 +1,19 @@
 import subprocess
 import sys
-from pathlib import Path
-from rich.console import Console
-from devcouncil.domain.task import Task
-from devcouncil.domain.requirement import Requirement
-from devcouncil.execution.executor import Executor, ExecutionResult
-from devcouncil.execution.prompt_builder import PromptBuilder
-
-console = Console()
-
-class MiniSWEExecutor(Executor):
-    def __init__(self, project_root: Path):
-        self.project_root = project_root
-
-    def run_task(self, task: Task, requirements: list[Requirement]) -> ExecutionResult:
+from pathlib import Path
+from rich.console import Console
+from devcouncil.domain.task import Task
+from devcouncil.domain.requirement import Requirement
+from devcouncil.execution.executor import Executor, ExecutionResult
+from devcouncil.execution.prompt_builder import PromptBuilder
+
+console = Console()
+
+class MiniSWEExecutor(Executor):
+    def __init__(self, project_root: Path):
+        self.project_root = project_root
+
+    def run_task(self, task: Task, requirements: list[Requirement]) -> ExecutionResult:
         builder = PromptBuilder(self.project_root)
         task_prompt = builder.build_task_prompt(task, requirements)
         
@@ -21,53 +21,53 @@ class MiniSWEExecutor(Executor):
         instruction_file = self.project_root / ".devcouncil" / f"{task.id}-mini-swe-task.md"
         instruction_file.parent.mkdir(parents=True, exist_ok=True)
         instruction_file.write_text(task_prompt, encoding="utf-8")
-        
-        console.print(f"Starting [bold]mini-SWE-agent[/bold] for task {task.id}...")
-        
-        # In a real implementation, we'd invoke the agent CLI
-        # For now, we simulate the command call
-        cmd = [
+        
+        console.print(f"Starting [bold]mini-SWE-agent[/bold] for task {task.id}...")
+        
+        # In a real implementation, we'd invoke the agent CLI
+        # For now, we simulate the command call
+        cmd = [
             sys.executable, "-m", "mini_swe_agent.main",
-            "--instruction-file", str(instruction_file),
-            "--repo-path", str(self.project_root)
-        ]
-        
-        console.print(f"Command: [dim]{' '.join(cmd)}[/dim]")
-        
-        # Since I might not have mini_swe_agent installed here, 
-        # I'll just explain what it would do.
-        console.print("[yellow]Note: mini_swe_agent must be installed in the environment.[/yellow]")
-        
-        try:
-            result = subprocess.run(
-                cmd,
-                capture_output=True,
-                text=True,
-                encoding="utf-8",
-                errors="replace",
-                cwd=self.project_root,
-                timeout=1800,
-            )
-            self._write_log(task.id, result)
-            if result.returncode != 0:
-                console.print(f"[red]mini-SWE-agent exited with {result.returncode}.[/red]")
-                return ExecutionResult(success=False, message='Execution failed')
-            return ExecutionResult(success=True, message='Execution successful')
-        except Exception as e:
-            console.print(f"[red]Error running mini-SWE-agent: {e}[/red]")
-            return ExecutionResult(success=False, message='Execution failed')
-
-    def _write_log(self, task_id: str, result: subprocess.CompletedProcess[str]) -> None:
-        log_dir = self.project_root / ".devcouncil" / "logs"
-        log_dir.mkdir(parents=True, exist_ok=True)
-        log_path = log_dir / f"{task_id}-mini-swe.log"
-        log_path.write_text(
-            "\n".join([
-                f"command_returncode={result.returncode}",
-                "=== stdout ===",
-                result.stdout or "",
-                "=== stderr ===",
-                result.stderr or "",
-            ]),
-            encoding="utf-8",
-        )
+            "--instruction-file", str(instruction_file),
+            "--repo-path", str(self.project_root)
+        ]
+        
+        console.print(f"Command: [dim]{' '.join(cmd)}[/dim]")
+        
+        # Since I might not have mini_swe_agent installed here, 
+        # I'll just explain what it would do.
+        console.print("[yellow]Note: mini_swe_agent must be installed in the environment.[/yellow]")
+        
+        try:
+            result = subprocess.run(
+                cmd,
+                capture_output=True,
+                text=True,
+                encoding="utf-8",
+                errors="replace",
+                cwd=self.project_root,
+                timeout=1800,
+            )
+            self._write_log(task.id, result)
+            if result.returncode != 0:
+                console.print(f"[red]mini-SWE-agent exited with {result.returncode}.[/red]")
+                return ExecutionResult(success=False, message='Execution failed')
+            return ExecutionResult(success=True, message='Execution successful')
+        except Exception as e:
+            console.print(f"[red]Error running mini-SWE-agent: {e}[/red]")
+            return ExecutionResult(success=False, message='Execution failed')
+
+    def _write_log(self, task_id: str, result: subprocess.CompletedProcess[str]) -> None:
+        log_dir = self.project_root / ".devcouncil" / "logs"
+        log_dir.mkdir(parents=True, exist_ok=True)
+        log_path = log_dir / f"{task_id}-mini-swe.log"
+        log_path.write_text(
+            "\n".join([
+                f"command_returncode={result.returncode}",
+                "=== stdout ===",
+                result.stdout or "",
+                "=== stderr ===",
+                result.stderr or "",
+            ]),
+            encoding="utf-8",
+        )

package/src/devcouncil/executors/native/agent.py

@@ -1,107 +1,208 @@
-from typing import List, Dict, Any
-from rich.console import Console
-from pydantic import BaseModel
-from devcouncil.domain.task import Task
-from devcouncil.domain.requirement import Requirement
-from devcouncil.execution.executor import Executor, ExecutionResult
-from devcouncil.llm.router import ModelRouter
+from typing import List, Dict, Any
+import asyncio
+from rich.console import Console
+from pydantic import BaseModel
+from devcouncil.domain.task import Task
+from devcouncil.domain.requirement import Requirement
+from devcouncil.execution.executor import Executor, ExecutionResult
+from devcouncil.llm.router import ModelRouter, StructuredOutputError
 from devcouncil.execution.task_runner import TaskRunner
 from devcouncil.execution.context_builder import ContextBuilder
+from devcouncil.execution.prompt_builder import PromptBuilder
 from devcouncil.execution.paths import resolve_project_path
-
-console = Console()
-
-class ToolCall(BaseModel):
-    tool: str
-    args: Dict[str, Any]
-
-class AgentAction(BaseModel):
-    thought: str
-    tool_calls: List[ToolCall] = []
-    finish: bool = False
-
-class NativeAgent(Executor):
-    def __init__(self, router: ModelRouter, task_runner: TaskRunner):
-        self.router = router
-        self.task_runner = task_runner
-        self.context_builder = ContextBuilder(task_runner.project_root)
-
-    async def run_task(self, task: Task, requirements: List[Requirement]) -> ExecutionResult:
-        console.print(f"Starting [bold]Native Executor[/bold] for task {task.id}...")
-        
-        # 1. Gather rich context
-        context_json = self.context_builder.build_task_context(task, requirements)
-        
-        system_prompt = f"""
-You are the DevCouncil Native Agent. Your goal is to implement the provided task.
-Current Project Context:
-{context_json}
-
-You have access to the following tools:
+from devcouncil.app.errors import ExecutionError
+
+console = Console()
+
+# Resilience bounds for the preview native loop.
+MAX_AGENT_STEPS = 10
+MAX_STRUCTURED_FAILURES = 2          # model can't produce a valid action -> give up cleanly
+MAX_CONSECUTIVE_PATCH_FAILURES = 3   # stop spinning on a patch the model can't fix
+
+class ToolCall(BaseModel):
+    tool: str
+    args: Dict[str, Any]
+
+class AgentAction(BaseModel):
+    thought: str
+    tool_calls: List[ToolCall] = []
+    finish: bool = False
+
+class NativeAgent(Executor):
+    def __init__(self, router: ModelRouter, task_runner: TaskRunner):
+        self.router = router
+        self.task_runner = task_runner
+        # ContextBuilder is retained only for the cheap list_files file listing; the
+        # implementation context itself uses the budgeted PromptBuilder so the native
+        # executor gets the same repo-map orientation, symbol outlines, dependents and
+        # context-window budgeting as the CLI executors (rather than a flat JSON dump).
+        self.context_builder = ContextBuilder(task_runner.project_root)
+        self.prompt_builder = PromptBuilder(task_runner.project_root)
+
+    def run_task(self, task: Task, requirements: List[Requirement]) -> ExecutionResult:
+        """Run the preview native executor behind the normal synchronous executor contract."""
+        return asyncio.run(self._run_task_async(task, requirements))
+
+    async def _run_task_async(self, task: Task, requirements: List[Requirement]) -> ExecutionResult:
+        console.print(f"Starting [bold]Native Executor[/bold] for task {task.id}...")
+        console.print("[yellow]Native executor is preview quality; DevCouncil verification remains the completion gate.[/yellow]")
+        
+        # 1. Gather rich context (budgeted; includes repo-map orientation + symbol outlines)
+        context_block = self.prompt_builder.build_task_prompt(task, requirements)
+        from devcouncil.planning.correction_manifest import load_latest_correction_manifest
+
+        correction = load_latest_correction_manifest(self.task_runner.project_root, task.id)
+        correction_block = ""
+        if correction is not None:
+            correction_block = f"\nCorrection Manifest:\n{correction.model_dump_json(indent=2)}\n"
+
+        system_prompt = f"""
+You are the DevCouncil Native Agent. Your goal is to implement the provided task.
+Current Project Context:
+{context_block}
+{correction_block}
+
+You have access to the following tools:
 - read_file(path: str)
 - list_files()
-- apply_patch(patch: str)
+- apply_patch(patch: str)  OR  apply_patch(path: str, content: str) as a fallback when a valid unified diff cannot be produced
 - run_command(command: str)
 
 Rules:
 1. You can only write to files or apply patches to files listed in the task's 'planned_files'.
-2. You can only run commands listed in the task's 'allowed_commands'.
-3. Use 'thought' to explain your reasoning.
-4. Set 'finish' to true when you believe the task is complete and verified.
-"""
-        messages = [{"role": "system", "content": system_prompt}]
-        
-        # Initial task prompt
-        messages.append({"role": "user", "content": f"Begin implementing task {task.id} based on the context provided."})
-
-        # Basic tool loop (Max 10 steps for safety in MVP)
-        for step in range(10):
-            action = await self.router.complete_structured(
-                role="native_agent", 
-                messages=messages,
-                schema=AgentAction
-            )
-            
-            console.print(f"\n[bold]Step {step+1}:[/bold] {action.thought}")
-            
-            if action.finish:
-                console.print("[green]Native agent signaled completion.[/green]")
-                return ExecutionResult(success=True, message="Agent signaled completion")
-
-            for tool_call in action.tool_calls:
-                result_summary = ""
-                try:
+2. You can only run commands listed in the task's 'allowed_commands'.
+3. Use 'thought' to explain your reasoning.
+4. Set 'finish' to true when you believe the task is complete and verified.
+"""
+        messages = [{"role": "system", "content": system_prompt}]
+        
+        # Initial task prompt
+        messages.append({"role": "user", "content": f"Begin implementing task {task.id} based on the context provided."})
+
+        # Bounded tool loop. Counters let us fail a single task cleanly instead of
+        # crashing the whole run (structured-output faults) or spinning on an
+        # unfixable patch.
+        structured_failures = 0
+        consecutive_patch_failures = 0
+        for step in range(MAX_AGENT_STEPS):
+            try:
+                action = await self.router.complete_structured(
+                    role="native_agent",
+                    messages=messages,
+                    schema=AgentAction,
+                )
+            except StructuredOutputError as exc:
+                # The model could not produce a valid action even after healing/retry.
+                # native_agent has no fallback by design, so handle it here rather than
+                # letting it propagate and abort the entire `dev go` run.
+                structured_failures += 1
+                console.print(f"[red]Native agent could not parse a valid action: {exc}[/red]")
+                if structured_failures >= MAX_STRUCTURED_FAILURES:
+                    return ExecutionResult(
+                        success=False,
+                        message=f"Native agent gave up after {structured_failures} unparseable responses.",
+                    )
+                messages.append({
+                    "role": "user",
+                    "content": (
+                        "[System] Your previous response was not valid JSON for the "
+                        "AgentAction schema. Reply with a single valid JSON object only "
+                        "(fields: thought, tool_calls, finish) — no prose, no fences."
+                    ),
+                })
+                continue
+            structured_failures = 0
+
+            console.print(f"\n[bold]Step {step+1}:[/bold] {action.thought}")
+
+            # Record the agent's own turn so subsequent steps see what it already did.
+            # Without this the model only sees tool RESULTS, not its prior actions, and
+            # tends to repeat itself and never converge within the step budget.
+            messages.append({"role": "assistant", "content": action.model_dump_json()})
+
+            if action.finish:
+                console.print("[green]Native agent signaled completion.[/green]")
+                return ExecutionResult(success=True, message="Agent signaled completion; pending DevCouncil verification")
+
+            if not action.tool_calls:
+                # No action and not finished — nudge instead of silently burning a step.
+                messages.append({"role": "user", "content": (
+                    "[System] You produced no tool_calls and did not finish. Call a tool "
+                    "(read_file/list_files/apply_patch/run_command) to make progress, or set "
+                    "finish=true if the task is complete."
+                )})
+                continue
+
+            for tool_call in action.tool_calls:
+                result_summary = ""
+                try:
                     if tool_call.tool == "read_file":
                         path = tool_call.args["path"]
                         resolved = resolve_project_path(self.task_runner.project_root, path)
                         # Security: block reading sensitive files
                         sensitive_patterns = {".env", ".pem", ".key", "credentials", "secrets"}
-                        path_lower = path.lower()
-                        if any(s in path_lower for s in sensitive_patterns):
-                            raise PermissionError(f"Reading sensitive file blocked: {path}")
-                        content = resolved.read_text(encoding="utf-8")
-                        if len(content) > 8000:
-                            content = content[:8000] + "\n[truncated]"
-                        result_summary = f"File content of {path}:\n{content}"
-                    elif tool_call.tool == "list_files":
-                        # We use the internal helper but return limited list
-                        files = self.context_builder.get_structure_summary()
-                        result_summary = f"Found {len(files)} files in repository."
+                        path_lower = path.lower()
+                        if any(s in path_lower for s in sensitive_patterns):
+                            raise PermissionError(f"Reading sensitive file blocked: {path}")
+                        content = resolved.read_text(encoding="utf-8")
+                        if len(content) > 8000:
+                            content = content[:8000] + "\n[truncated]"
+                        result_summary = f"File content of {path}:\n{content}"
+                    elif tool_call.tool == "list_files":
+                        # We use the internal helper but return limited list
+                        files = self.context_builder.get_structure_summary()
+                        result_summary = f"Found {len(files)} files in repository."
                     elif tool_call.tool == "write_file":
                         raise PermissionError("write_file is disabled for the native executor; use apply_patch.")
                     elif tool_call.tool == "apply_patch":
-                        self.task_runner.apply_patch(tool_call.args["patch"], task)
-                        result_summary = "Successfully applied patch."
+                        if "path" in tool_call.args and "content" in tool_call.args:
+                            # Fallback for when the model can't produce a valid unified
+                            # diff. Routes through write_file, which enforces the same
+                            # planned-files permission check — no widening of scope.
+                            self.task_runner.write_file(
+                                tool_call.args["path"], tool_call.args["content"], task
+                            )
+                            consecutive_patch_failures = 0
+                            result_summary = f"Wrote {tool_call.args['path']} via path+content fallback."
+                        else:
+                            patch = tool_call.args.get("patch", "")
+                            if not patch or not patch.strip():
+                                raise ExecutionError(
+                                    "Empty patch. Provide a unified git diff beginning with "
+                                    "'diff --git a/<path> b/<path>', then '--- a/<path>' (or "
+                                    "'--- /dev/null' for a new file), '+++ b/<path>', and '@@' hunks."
+                                )
+                            self.task_runner.apply_patch(patch, task)
+                            consecutive_patch_failures = 0
+                            result_summary = "Successfully applied patch."
                     elif tool_call.tool == "run_command":
                         cmd_result = self.task_runner.run_command(tool_call.args["command"], task)
                         result_summary = f"Command finished with exit code {cmd_result.exit_code}."
                     else:
                         raise ValueError(f"Unknown tool: {tool_call.tool}")
-                    
-                    messages.append({"role": "user", "content": f"[Tool Result] '{tool_call.tool}': {result_summary}"})
-                except Exception as e:
-                    console.print(f"[red]Error executing tool {tool_call.tool}: {e}[/red]")
-                    messages.append({"role": "user", "content": f"[Tool Error] '{tool_call.tool}' failed: {e}"})
-
-        console.print("[red]Native agent reached maximum step limit.[/red]")
-        return ExecutionResult(success=False, message="Reached maximum step limit")
+                    
+                    messages.append({"role": "user", "content": f"[Tool Result] '{tool_call.tool}': {result_summary}"})
+                except Exception as e:
+                    console.print(f"[red]Error executing tool {tool_call.tool}: {e}[/red]")
+                    if tool_call.tool == "apply_patch":
+                        consecutive_patch_failures += 1
+                        if consecutive_patch_failures >= MAX_CONSECUTIVE_PATCH_FAILURES:
+                            return ExecutionResult(
+                                success=False,
+                                message=(
+                                    f"Native agent failed to apply a patch "
+                                    f"{consecutive_patch_failures} times in a row."
+                                ),
+                            )
+                        messages.append({"role": "user", "content": (
+                            f"[Tool Error] 'apply_patch' failed: {e}\n"
+                            "Re-read the target file, match the existing context lines EXACTLY, "
+                            "and do NOT resubmit the same patch. If you cannot produce a valid "
+                            "unified diff, call apply_patch with 'path' and 'content' instead to "
+                            "write the whole file."
+                        )})
+                    else:
+                        messages.append({"role": "user", "content": f"[Tool Error] '{tool_call.tool}' failed: {e}"})
+
+        console.print("[red]Native agent reached maximum step limit.[/red]")
+        return ExecutionResult(success=False, message="Reached maximum step limit")

package/src/devcouncil/executors/openhands.py

@@ -1,23 +1,23 @@
-import subprocess
-from pathlib import Path
-from rich.console import Console
-from devcouncil.domain.task import Task
-from devcouncil.domain.requirement import Requirement
-from devcouncil.execution.executor import Executor, ExecutionResult
-from devcouncil.execution.prompt_builder import PromptBuilder
-
-console = Console()
-
-class OpenHandsExecutor(Executor):
-    def __init__(self, project_root: Path):
-        self.project_root = project_root
-
-    def run_task(self, task: Task, requirements: list[Requirement]) -> ExecutionResult:
+import subprocess
+from pathlib import Path
+from rich.console import Console
+from devcouncil.domain.task import Task
+from devcouncil.domain.requirement import Requirement
+from devcouncil.execution.executor import Executor, ExecutionResult
+from devcouncil.execution.prompt_builder import PromptBuilder
+
+console = Console()
+
+class OpenHandsExecutor(Executor):
+    def __init__(self, project_root: Path):
+        self.project_root = project_root
+
+    def run_task(self, task: Task, requirements: list[Requirement]) -> ExecutionResult:
         builder = PromptBuilder(self.project_root)
-        task_prompt = builder.build_task_prompt(task, requirements)
-        
-        console.print(f"Starting [bold]OpenHands[/bold] for task {task.id}...")
-        
+        task_prompt = builder.build_task_prompt(task, requirements)
+        
+        console.print(f"Starting [bold]OpenHands[/bold] for task {task.id}...")
+        
         # OpenHands often expects a workspace mount and an instruction.
         # Keep the full prompt out of argv so Windows command-line limits and
         # terminal logs do not become part of the execution boundary.
@@ -32,40 +32,40 @@ class OpenHandsExecutor(Executor):
             "--task-file", str(instruction_file),
             "--headless"
         ]
-        
-        console.print(f"Command: [dim]{' '.join(cmd)}[/dim]")
-        console.print("[yellow]Note: OpenHands must be installed and configured in the environment.[/yellow]")
-        
-        try:
-            result = subprocess.run(
-                cmd,
-                capture_output=True,
-                text=True,
-                encoding="utf-8",
-                errors="replace",
-                cwd=self.project_root,
-                timeout=1800,
-            )
-            self._write_log(task.id, result)
-            if result.returncode != 0:
-                console.print(f"[red]OpenHands exited with {result.returncode}.[/red]")
-                return ExecutionResult(success=False, message=f"Exited with code {result.returncode}")
-            return ExecutionResult(success=True, message="Completed successfully")
-        except Exception as e:
-            console.print(f"[red]Error running OpenHands: {e}[/red]")
-            return ExecutionResult(success=False, message=str(e))
-
-    def _write_log(self, task_id: str, result: subprocess.CompletedProcess[str]) -> None:
-        log_dir = self.project_root / ".devcouncil" / "logs"
-        log_dir.mkdir(parents=True, exist_ok=True)
-        log_path = log_dir / f"{task_id}-openhands.log"
-        log_path.write_text(
-            "\n".join([
-                f"command_returncode={result.returncode}",
-                "=== stdout ===",
-                result.stdout or "",
-                "=== stderr ===",
-                result.stderr or "",
-            ]),
-            encoding="utf-8",
-        )
+        
+        console.print(f"Command: [dim]{' '.join(cmd)}[/dim]")
+        console.print("[yellow]Note: OpenHands must be installed and configured in the environment.[/yellow]")
+        
+        try:
+            result = subprocess.run(
+                cmd,
+                capture_output=True,
+                text=True,
+                encoding="utf-8",
+                errors="replace",
+                cwd=self.project_root,
+                timeout=1800,
+            )
+            self._write_log(task.id, result)
+            if result.returncode != 0:
+                console.print(f"[red]OpenHands exited with {result.returncode}.[/red]")
+                return ExecutionResult(success=False, message=f"Exited with code {result.returncode}")
+            return ExecutionResult(success=True, message="Completed successfully")
+        except Exception as e:
+            console.print(f"[red]Error running OpenHands: {e}[/red]")
+            return ExecutionResult(success=False, message=str(e))
+
+    def _write_log(self, task_id: str, result: subprocess.CompletedProcess[str]) -> None:
+        log_dir = self.project_root / ".devcouncil" / "logs"
+        log_dir.mkdir(parents=True, exist_ok=True)
+        log_path = log_dir / f"{task_id}-openhands.log"
+        log_path.write_text(
+            "\n".join([
+                f"command_returncode={result.returncode}",
+                "=== stdout ===",
+                result.stdout or "",
+                "=== stderr ===",
+                result.stderr or "",
+            ]),
+            encoding="utf-8",
+        )

package/src/devcouncil/gating/__init__.py

@@ -1 +1 @@
-
+