devcouncil 0.1.0 → 0.1.1

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,43 +1,43 @@
-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 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 devcouncil.execution.task_runner import TaskRunner
 from devcouncil.execution.context_builder import ContextBuilder
 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:
+
+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:
 - read_file(path: str)
 - list_files()
 - apply_patch(patch: str)
@@ -45,48 +45,48 @@ You have access to the following tools:
 
 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."})
+
+        # 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:
                     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":
@@ -97,11 +97,11 @@ Rules:
                         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]")
+                    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 @@
-
+

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

@@ -1,45 +1,50 @@
-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 check(self, project_root, task_id: str) -> list[Gap]:
-        try:
-            status = subprocess.check_output(["git", "status", "--porcelain"], cwd=project_root).decode()
-            if status.strip():
-                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 []
+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("\\", "/")
+        return path.startswith(".devcouncil/")
+    
+    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 +1,32 @@
-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
+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