devcouncil 0.2.0 → 0.2.1

package/src/devcouncil/executors/mini_swe.py

@@ -1,73 +0,0 @@
-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:
-        builder = PromptBuilder(self.project_root)
-        task_prompt = builder.build_task_prompt(task, requirements)
-        
-        # Write temporary instruction file for mini-SWE-agent
-        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 = [
-            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",
-        )

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

@@ -1,208 +0,0 @@
-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
-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)  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."})
-
-        # 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."
-                    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":
-                        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]")
-                    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,71 +0,0 @@
-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}...")
-        
-        # 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.
-        # Reference: https://github.com/All-Hands-AI/OpenHands
-        instruction_file = self.project_root / ".devcouncil" / f"{task.id}-openhands-task.md"
-        instruction_file.parent.mkdir(parents=True, exist_ok=True)
-        instruction_file.write_text(task_prompt, encoding="utf-8")
-        
-        cmd = [
-            "openhands", "run",
-            "--workspace-base", str(self.project_root),
-            "--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",
-        )

package/src/devcouncil/gating/__init__.py

@@ -1 +0,0 @@
-

package/src/devcouncil/gating/checks/clean_git.py

@@ -1,52 +0,0 @@
-import subprocess
-import logging
-from devcouncil.domain.gap import Gap
-
-logger = logging.getLogger(__name__)
-
-class CleanGitCheck:
-    """Ensures the working tree is clean before a task starts."""
-
-    def _is_runtime_state(self, line: str) -> bool:
-        path = line[3:].strip().replace("\\", "/")
-        # DevCouncil manages the root .gitignore itself (ensure_gitignore runs on
-        # init and before every task), so it must not block execution.
-        return path.startswith(".devcouncil/") or path == ".gitignore"
-    
-    def check(self, project_root, task_id: str) -> list[Gap]:
-        try:
-            status = subprocess.check_output(["git", "status", "--porcelain"], cwd=project_root).decode()
-            dirty_lines = [line for line in status.splitlines() if line.strip() and not self._is_runtime_state(line)]
-            if dirty_lines:
-                return [Gap(
-                    id=f"GAP-{task_id}-DIRTY-GIT",
-                    severity="high",
-                    gap_type="architecture_drift",
-                    task_id=task_id,
-                    description="Git working tree is dirty. Execution requires a clean state for checkpointing.",
-                    recommended_fix="Commit or stash your current changes before running the task.",
-                    blocking=True
-                )]
-        except FileNotFoundError:
-            logger.error("Git is not installed or not in PATH.")
-            return [Gap(
-                id=f"GAP-{task_id}-NO-GIT",
-                severity="high",
-                gap_type="architecture_drift",
-                task_id=task_id,
-                description="Git is not available. Cannot verify working tree cleanliness.",
-                recommended_fix="Install git and ensure it is in your PATH.",
-                blocking=True
-            )]
-        except subprocess.CalledProcessError as e:
-            logger.warning("Git status check failed: %s", e)
-            return [Gap(
-                id=f"GAP-{task_id}-GIT-ERROR",
-                severity="medium",
-                gap_type="architecture_drift",
-                task_id=task_id,
-                description=f"Git status check failed: {e}. Directory may not be a git repository.",
-                recommended_fix="Initialize a git repository with 'git init' before running tasks.",
-                blocking=True
-            )]
-        return []

package/src/devcouncil/gating/checks/planned_files_check.py

@@ -1,32 +0,0 @@
-from devcouncil.domain.task import Task
-from devcouncil.domain.gap import Gap
-
-class PlannedFilesCheck:
-    """Ensures a task has legitimate files planned for modification."""
-    
-    def check(self, task: Task) -> list[Gap]:
-        gaps = []
-        if not task.planned_files:
-            gaps.append(Gap(
-                id=f"GAP-{task.id}-NO-FILES",
-                severity="high",
-                gap_type="task_not_implemented",
-                task_id=task.id,
-                description=f"Task {task.id} has no planned files. Agents won't know where to write code.",
-                recommended_fix="Update the task to include at least one planned file path.",
-                blocking=True
-            ))
-        
-        has_modify = any(pf.allowed_change in ["create", "modify", "delete"] for pf in task.planned_files)
-        if task.planned_files and not has_modify:
-            gaps.append(Gap(
-                id=f"GAP-{task.id}-READ-ONLY",
-                severity="medium",
-                gap_type="task_not_implemented",
-                task_id=task.id,
-                description=f"Task {task.id} only has read-only files. No changes can be made.",
-                recommended_fix="Grant 'modify' or 'create' permissions to at least one file.",
-                blocking=True
-            ))
-            
-        return gaps

package/src/devcouncil/gating/checks/requirement_coverage.py

@@ -1,26 +0,0 @@
-from devcouncil.domain.requirement import Requirement
-from devcouncil.domain.task import Task
-from devcouncil.domain.gap import Gap
-from typing import List
-
-class RequirementCoverageCheck:
-    """Detects requirements that are not mapped to any tasks."""
-    
-    def check(self, requirements: List[Requirement], tasks: List[Task]) -> List[Gap]:
-        task_req_ids = set()
-        for t in tasks:
-            task_req_ids.update(t.requirement_ids)
-            
-        gaps = []
-        for req in requirements:
-            if req.id not in task_req_ids:
-                gaps.append(Gap(
-                    id=f"GAP-PLAN-{req.id}-UNMAPPED",
-                    severity="high",
-                    gap_type="requirement_not_planned",
-                    requirement_id=req.id,
-                    description=f"Requirement '{req.title}' is not covered by any task.",
-                    recommended_fix="Decompose this requirement into one or more implementation tasks.",
-                    blocking=True
-                ))
-        return gaps

package/src/devcouncil/gating/checks/secret_scan_check.py

@@ -1,53 +0,0 @@
-import re
-from typing import List
-from devcouncil.domain.gap import Gap
-from devcouncil.utils.redaction import SECRET_PATTERNS, redact_string
-
-# Captures the new-file starting line from a unified-diff hunk header (@@ -a,b +c,d @@).
-_HUNK_RE = re.compile(r"^@@ -\d+(?:,\d+)? \+(\d+)(?:,\d+)? @@")
-
-
-class SecretScanner:
-    """Scans code diffs for potential secrets (API keys, tokens, etc.)."""
-
-    def scan_diff(self, diff_content: str, task_id: str) -> List[Gap]:
-        gaps: List[Gap] = []
-        current_file = "unknown_file"
-        new_line_no = 0  # line number in the new file, tracked across hunks
-        counter = 0      # ensures unique gap ids
-
-        for line in diff_content.splitlines():
-            if line.startswith("+++ b/"):
-                current_file = line[6:]
-                continue
-            if line.startswith("+++") or line.startswith("---") or line.startswith("diff "):
-                continue
-            hunk = _HUNK_RE.match(line)
-            if hunk:
-                new_line_no = int(hunk.group(1))
-                continue
-            if line.startswith("-"):
-                continue  # removed line — does not advance the new-file counter
-            if line.startswith("+"):
-                for key_type, pattern in SECRET_PATTERNS.items():
-                    if pattern.search(line):
-                        counter += 1
-                        gaps.append(Gap(
-                            id=f"GAP-{task_id}-SECRET-{key_type.upper()}-{new_line_no}-{counter}",
-                            severity="critical",
-                            gap_type="security_risk",
-                            task_id=task_id,
-                            description=f"Potential {key_type} found in {current_file}:{new_line_no}.",
-                            evidence=[redact_string(line.strip())],
-                            recommended_fix="Remove the secret and use environment variables or a secret manager.",
-                            blocking=True,
-                            # Populate the routing fields so the security NextAction points
-                            # the agent straight at the file:line instead of forcing a re-grep.
-                            file=current_file,
-                            line=new_line_no,
-                        ))
-                new_line_no += 1
-                continue
-            # Context or blank line — advances the new-file counter.
-            new_line_no += 1
-        return gaps