devcouncil 0.1.0 → 0.1.1

package/src/devcouncil/execution/executor.py

@@ -1,15 +1,15 @@
-from abc import ABC, abstractmethod
-from typing import List
-from pydantic import BaseModel
-from devcouncil.domain.task import Task
-from devcouncil.domain.requirement import Requirement
-
-class ExecutionResult(BaseModel):
-    success: bool
-    message: str
-
-class Executor(ABC):
-    @abstractmethod
-    def run_task(self, task: Task, requirements: List[Requirement]) -> ExecutionResult:
-        """Execute the task and return the result."""
-        pass
+from abc import ABC, abstractmethod
+from typing import List
+from pydantic import BaseModel
+from devcouncil.domain.task import Task
+from devcouncil.domain.requirement import Requirement
+
+class ExecutionResult(BaseModel):
+    success: bool
+    message: str
+
+class Executor(ABC):
+    @abstractmethod
+    def run_task(self, task: Task, requirements: List[Requirement]) -> ExecutionResult:
+        """Execute the task and return the result."""
+        pass

package/src/devcouncil/execution/hook_policy.py

@@ -20,7 +20,7 @@ class HookDecision:
 
 
 class HookPolicy:
-    """Policy-backed hook checks for Claude-style pre-tool-use events."""
+    """Policy-backed hook checks for coding CLI tool-use events."""
 
     def __init__(self, project_root: Path | None = None):
         self.project_root = project_root.resolve() if project_root else None
@@ -47,8 +47,28 @@ class HookPolicy:
         "wrangler.toml",
         "index.html",
     )
-    write_tools = {"write_file", "edit_file", "replace", "Write", "Edit", "MultiEdit"}
-    shell_tools = {"bash", "shell", "run_command", "Bash"}
+    write_tools = {
+        "apply_patch",
+        "edit",
+        "edit_file",
+        "replace",
+        "write",
+        "write_file",
+        "Edit",
+        "MultiEdit",
+        "Write",
+    }
+    shell_tools = {
+        "bash",
+        "exec",
+        "exec_command",
+        "local_shell",
+        "run_command",
+        "run_shell_command",
+        "shell",
+        "shell_command",
+        "Bash",
+    }
 
     def evaluate(self, call_data: dict[str, Any], active_task: Optional[Task]) -> HookDecision:
         tool_name = str(call_data.get("name") or call_data.get("tool_name") or call_data.get("tool") or "")
@@ -116,6 +136,7 @@ class HookPolicy:
             or arguments.get("filepath")
             or arguments.get("filePath")
             or arguments.get("target")
+            or arguments.get("target_file")
         )
         return str(value) if value else None
 

package/src/devcouncil/execution/patch.py

@@ -1,28 +1,28 @@
-import subprocess
-from pathlib import Path
-from devcouncil.app.errors import ExecutionError
-
-class PatchEngine:
-    """Handles applying unified diff patches to the codebase."""
-    
-    def __init__(self, project_root: Path):
-        self.project_root = project_root
-
-    def apply_patch(self, patch_content: str) -> bool:
-        """Applies a git-style patch to the repository."""
-        patch_file = self.project_root / ".devcouncil" / "temp.patch"
-        patch_file.parent.mkdir(parents=True, exist_ok=True)
-        patch_file.write_text(patch_content, encoding="utf-8")
-        
-        try:
-            # Using git apply for robust patch application
-            subprocess.check_call(
-                ["git", "apply", "--ignore-whitespace", str(patch_file)],
-                cwd=self.project_root
-            )
-            return True
-        except subprocess.CalledProcessError as e:
-            raise ExecutionError(f"Failed to apply patch: {e}")
-        finally:
-            if patch_file.exists():
-                patch_file.unlink()
+import subprocess
+from pathlib import Path
+from devcouncil.app.errors import ExecutionError
+
+class PatchEngine:
+    """Handles applying unified diff patches to the codebase."""
+    
+    def __init__(self, project_root: Path):
+        self.project_root = project_root
+
+    def apply_patch(self, patch_content: str) -> bool:
+        """Applies a git-style patch to the repository."""
+        patch_file = self.project_root / ".devcouncil" / "temp.patch"
+        patch_file.parent.mkdir(parents=True, exist_ok=True)
+        patch_file.write_text(patch_content, encoding="utf-8")
+        
+        try:
+            # Using git apply for robust patch application
+            subprocess.check_call(
+                ["git", "apply", "--ignore-whitespace", str(patch_file)],
+                cwd=self.project_root
+            )
+            return True
+        except subprocess.CalledProcessError as e:
+            raise ExecutionError(f"Failed to apply patch: {e}")
+        finally:
+            if patch_file.exists():
+                patch_file.unlink()

package/src/devcouncil/execution/permissions.py

@@ -1,34 +1,34 @@
-import fnmatch
-from pathlib import Path
+import fnmatch
+from pathlib import Path
 from typing import List, Literal, Optional
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field
 from devcouncil.domain.task import PlannedFile, Task
-from devcouncil.app.errors import GatingError
-
-class PermissionPolicy(BaseModel):
-    """Defines the security boundaries for task execution."""
-    allow_file_create: bool = False
-    allow_file_delete: bool = False
-    allowed_shell_commands: List[str] = Field(default_factory=list)
-    restricted_paths: List[str] = Field(default_factory=lambda: [".git/*", ".devcouncil/*", ".env*"])
-
+from devcouncil.app.errors import GatingError
+
+class PermissionPolicy(BaseModel):
+    """Defines the security boundaries for task execution."""
+    allow_file_create: bool = False
+    allow_file_delete: bool = False
+    allowed_shell_commands: List[str] = Field(default_factory=list)
+    restricted_paths: List[str] = Field(default_factory=lambda: [".git/*", ".devcouncil/*", ".env*"])
+
 class PermissionManager:
-    def __init__(self, policy: PermissionPolicy, project_root: Path = Path(".")):
-        self.policy = policy
-        self.project_root = project_root
-        self.dynamic_ignores = self._load_devcouncilignore()
-
-    def _load_devcouncilignore(self) -> List[str]:
-        """Load additional restricted paths from .devcouncilignore."""
-        ignore_file = self.project_root / ".devcouncilignore"
-        if ignore_file.exists():
-            try:
-                lines = ignore_file.read_text().splitlines()
-                return [line.strip() for line in lines if line.strip() and not line.startswith("#")]
-            except Exception:
-                pass
-        return []
-
+    def __init__(self, policy: PermissionPolicy, project_root: Path = Path(".")):
+        self.policy = policy
+        self.project_root = project_root
+        self.dynamic_ignores = self._load_devcouncilignore()
+
+    def _load_devcouncilignore(self) -> List[str]:
+        """Load additional restricted paths from .devcouncilignore."""
+        ignore_file = self.project_root / ".devcouncilignore"
+        if ignore_file.exists():
+            try:
+                lines = ignore_file.read_text().splitlines()
+                return [line.strip() for line in lines if line.strip() and not line.startswith("#")]
+            except Exception:
+                pass
+        return []
+
     def is_file_change_allowed(
         self,
         path: str,
@@ -60,19 +60,19 @@ class PermissionManager:
             if normalized == planned_path or fnmatch.fnmatch(normalized, planned_path):
                 return planned
         return None
-
-    def is_command_allowed(self, command: str, task: Task) -> bool:
-        """Check if a shell command is authorized by the task or global allowlist."""
-        # 1. Check task-specific allowlist
-        if any(fnmatch.fnmatch(command, allowed) for allowed in task.allowed_commands):
-            return True
-            
-        # 2. Check global policy allowlist
-        if any(fnmatch.fnmatch(command, allowed) for allowed in self.policy.allowed_shell_commands):
-            return True
-            
-        return False
-
+
+    def is_command_allowed(self, command: str, task: Task) -> bool:
+        """Check if a shell command is authorized by the task or global allowlist."""
+        # 1. Check task-specific allowlist
+        if any(fnmatch.fnmatch(command, allowed) for allowed in task.allowed_commands):
+            return True
+            
+        # 2. Check global policy allowlist
+        if any(fnmatch.fnmatch(command, allowed) for allowed in self.policy.allowed_shell_commands):
+            return True
+            
+        return False
+
     def validate_action(
         self,
         action_type: str,
@@ -87,6 +87,6 @@ class PermissionManager:
                     f"Unauthorized file {operation}: {target}. "
                     "File and operation must match task planned_files."
                 )
-        elif action_type == "shell":
-            if not self.is_command_allowed(target, task):
-                raise GatingError(f"Unauthorized shell command: {target}. Command must be in task's allowed_commands.")
+        elif action_type == "shell":
+            if not self.is_command_allowed(target, task):
+                raise GatingError(f"Unauthorized shell command: {target}. Command must be in task's allowed_commands.")

package/src/devcouncil/execution/prompt_builder.py

@@ -10,25 +10,25 @@ class PromptBuilder:
         self.project_root = project_root
 
     def build_task_prompt(self, task: Task, requirements: List[Requirement]) -> str:
-        req_map = {r.id: r for r in requirements}
-        task_reqs = [req_map[rid] for rid in task.requirement_ids if rid in req_map]
-        
-        prompt = f"""# Implement {task.id}: {task.title}
-
-## Goal
-{task.description}
-
-## Requirements
-"""
-        for req in task_reqs:
-            prompt += f"- {req.id}: {req.title}\n"
-            for ac in req.acceptance_criteria:
-                prompt += f"  - [ ] {ac.description} ({ac.verification_method})\n"
-
+        req_map = {r.id: r for r in requirements}
+        task_reqs = [req_map[rid] for rid in task.requirement_ids if rid in req_map]
+        
+        prompt = f"""# Implement {task.id}: {task.title}
+
+## Goal
+{task.description}
+
+## Requirements
+"""
+        for req in task_reqs:
+            prompt += f"- {req.id}: {req.title}\n"
+            for ac in req.acceptance_criteria:
+                prompt += f"  - [ ] {ac.description} ({ac.verification_method})\n"
+
         prompt += "\n## Allowed files\n"
         for pf in task.planned_files:
             prompt += f"- `{pf.path}` ({pf.allowed_change}): {pf.reason}\n"
-
+
         if task.forbidden_changes:
             prompt += "\n## Forbidden changes\n"
             for fc in task.forbidden_changes:
@@ -50,10 +50,10 @@ class PromptBuilder:
 
         prompt += """
 ## Instructions
-1. Implement the goal described above.
-2. Ensure all acceptance criteria are met.
-3. Only modify the allowed files.
-4. Run the allowed commands to verify your work.
-5. Provide evidence of passing tests.
-"""
-        return prompt
+1. Implement the goal described above.
+2. Ensure all acceptance criteria are met.
+3. Only modify the allowed files.
+4. Run the allowed commands to verify your work.
+5. Provide evidence of passing tests.
+"""
+        return prompt

package/src/devcouncil/execution/task_runner.py

@@ -1,34 +1,34 @@
-import hashlib
-import subprocess
-import logging
-import re
-import shlex
-from pathlib import Path
+import hashlib
+import subprocess
+import logging
+import re
+import shlex
+from pathlib import Path
 from typing import Literal, Optional
-from devcouncil.domain.task import Task
-from devcouncil.execution.permissions import PermissionManager
-from devcouncil.domain.evidence import CommandResult
+from devcouncil.domain.task import Task
+from devcouncil.execution.permissions import PermissionManager
+from devcouncil.domain.evidence import CommandResult
 from devcouncil.app.errors import ExecutionError
 
 from devcouncil.execution.patch import PatchEngine
 from devcouncil.execution.paths import resolve_project_path
 from devcouncil.telemetry.traces import TraceLogger
 from devcouncil.utils.redaction import redact_string
-
-logger = logging.getLogger(__name__)
-
-class TaskRunner:
-    """Safely executes task actions while enforcing permission boundaries."""
-    
-    def __init__(self, project_root: Path, permission_manager: PermissionManager):
-        self.project_root = project_root
-        self.permissions = permission_manager
-        self.patch_engine = PatchEngine(project_root)
-
+
+logger = logging.getLogger(__name__)
+
+class TaskRunner:
+    """Safely executes task actions while enforcing permission boundaries."""
+    
+    def __init__(self, project_root: Path, permission_manager: PermissionManager):
+        self.project_root = project_root
+        self.permissions = permission_manager
+        self.patch_engine = PatchEngine(project_root)
+
     def _validate_path_within_root(self, path: str) -> None:
         """Ensure a path resolves to a location within the project root."""
         resolve_project_path(self.project_root, path)
-
+
     def apply_patch(self, patch: str, task: Task) -> bool:
         """Apply a patch if permissions allow (all affected files must be in planned_files)."""
         changes = self._extract_patch_changes(patch)
@@ -81,48 +81,48 @@ class TaskRunner:
         if not changes:
             raise ExecutionError("Patch does not declare any affected files.")
         return changes
-
-    def _normalize_patch_path(self, raw_path: str) -> Optional[str]:
-        raw_path = raw_path.strip().strip('"')
-        if raw_path == "/dev/null":
-            return None
-        raw_path = re.sub(r"^[ab]/", "", raw_path)
-        return raw_path.replace("\\", "/")
-
-    def _save_command_log(self, task_id: str, command: str, stream: str, content: str) -> str:
-        """Save command output to a log file and return the path."""
-        log_dir = self.project_root / ".devcouncil" / "logs"
-        log_dir.mkdir(parents=True, exist_ok=True)
-        cmd_hash = hashlib.sha256(command.encode()).hexdigest()[:8]
+
+    def _normalize_patch_path(self, raw_path: str) -> Optional[str]:
+        raw_path = raw_path.strip().strip('"')
+        if raw_path == "/dev/null":
+            return None
+        raw_path = re.sub(r"^[ab]/", "", raw_path)
+        return raw_path.replace("\\", "/")
+
+    def _save_command_log(self, task_id: str, command: str, stream: str, content: str) -> str:
+        """Save command output to a log file and return the path."""
+        log_dir = self.project_root / ".devcouncil" / "logs"
+        log_dir.mkdir(parents=True, exist_ok=True)
+        cmd_hash = hashlib.sha256(command.encode()).hexdigest()[:8]
         filename = f"{task_id}-{cmd_hash}-{stream}.log"
         log_path = log_dir / filename
         log_path.write_text(redact_string(content), encoding="utf-8")
         return str(log_path)
-
-    def run_command(self, command: str, task: Task) -> CommandResult:
-        """Execute a shell command if allowed by permissions."""
-        self.permissions.validate_action("shell", command, task)
-        
-        logger.info(f"Executing authorized command: {command}")
-        
-        try:
-            from devcouncil.app.config import load_config
-            config = load_config(self.project_root)
-            timeout = config.execution.command_timeout
-        except Exception:
-            timeout = 300
-
-        try:
-            result = subprocess.run(
-                shlex.split(command, posix=False),
-                shell=False,
-                capture_output=True,
-                text=True,
-                encoding="utf-8",
-                errors="replace",
-                cwd=self.project_root,
-                timeout=timeout
-            )
+
+    def run_command(self, command: str, task: Task) -> CommandResult:
+        """Execute a shell command if allowed by permissions."""
+        self.permissions.validate_action("shell", command, task)
+        
+        logger.info(f"Executing authorized command: {command}")
+        
+        try:
+            from devcouncil.app.config import load_config
+            config = load_config(self.project_root)
+            timeout = config.execution.command_timeout
+        except Exception:
+            timeout = 300
+
+        try:
+            result = subprocess.run(
+                shlex.split(command, posix=False),
+                shell=False,
+                capture_output=True,
+                text=True,
+                encoding="utf-8",
+                errors="replace",
+                cwd=self.project_root,
+                timeout=timeout
+            )
             stdout = result.stdout or ""
             stderr = result.stderr or ""
             stdout_path = self._save_command_log(task.id, command, "stdout", stdout)
@@ -136,15 +136,15 @@ class TaskRunner:
                 summary=f"{command} exited {result.returncode}",
             )
             return CommandResult(
-                command=command,
+                command=command,
                 exit_code=result.returncode,
                 stdout_path=stdout_path,
                 stderr_path=stderr_path,
                 summary=f"Exit code {result.returncode}. stdout: {stdout_summary}. stderr: {stderr_summary}"
             )
-        except Exception as e:
-            raise ExecutionError(f"Command execution failed: {e}")
-
+        except Exception as e:
+            raise ExecutionError(f"Command execution failed: {e}")
+
     def write_file(self, path: str, content: str, task: Task):
         """Write content to a file if allowed by permissions."""
         self._validate_path_within_root(path)

package/src/devcouncil/executors/__init__.py

@@ -1 +1 @@
-
+

package/src/devcouncil/executors/coding_cli.py

@@ -0,0 +1,112 @@
+import shutil
+import subprocess
+import os
+from pathlib import Path
+
+from rich.console import Console
+
+from devcouncil.domain.requirement import Requirement
+from devcouncil.domain.task import Task
+from devcouncil.execution.executor import Executor, ExecutionResult
+from devcouncil.execution.prompt_builder import PromptBuilder
+
+console = Console()
+
+
+class CodingCliExecutor(Executor):
+    """Execute a DevCouncil task by handing it off to an external coding CLI."""
+
+    _ALIASES = {
+        "codex-cli": "codex",
+        "gemini-cli": "gemini",
+        "claude-cli": "claude",
+        "claude-code": "claude",
+    }
+
+    def __init__(self, project_root: Path, client: str, timeout_seconds: int = 1800):
+        self.client = self._normalize_client(client)
+        self.project_root = project_root
+        self.timeout_seconds = timeout_seconds
+
+    def _normalize_client(self, client: str) -> str:
+        normalized = (client or "").strip().lower().replace("_", "-")
+        return self._ALIASES.get(normalized, normalized)
+
+    def _command(self) -> list[str]:
+        if self.client == "codex":
+            return ["codex", "exec", "-"]
+        if self.client == "gemini":
+            return ["gemini"]
+        if self.client == "claude":
+            return ["claude", "-p"]
+        raise ValueError(f"Unsupported coding CLI client: {self.client}")
+
+    def run_task(self, task: Task, requirements: list[Requirement]) -> ExecutionResult:
+        try:
+            command = self._command()
+        except ValueError as exc:
+            return ExecutionResult(success=False, message=str(exc))
+
+        executable = command[0]
+        if not shutil.which(executable):
+            return ExecutionResult(
+                success=False,
+                message=f"{self.client} CLI is not installed or not on PATH.",
+            )
+
+        prompt = PromptBuilder(self.project_root).build_task_prompt(task, requirements)
+        instruction_file = self.project_root / ".devcouncil" / f"{task.id}-{self.client}-task.md"
+        instruction_file.parent.mkdir(parents=True, exist_ok=True)
+        instruction_file.write_text(prompt, encoding="utf-8")
+
+        env = {**dict(os.environ), "DEVCOUNCIL_PROJECT_ROOT": str(self.project_root)}
+        log_prefix = f"{task.id}-{self.client}"
+
+        console.print(f"Starting [bold]{self.client.upper()}[/bold] for task [bold]{task.id}[/bold]...")
+        console.print(f"Task prompt: [dim]{instruction_file}[/dim]")
+        console.print(f"Command: [dim]{' '.join(command)}[/dim]")
+
+        try:
+            result = subprocess.run(
+                command,
+                input=prompt,
+                capture_output=True,
+                text=True,
+                encoding="utf-8",
+                errors="replace",
+                cwd=self.project_root,
+                env=env,
+                timeout=self.timeout_seconds,
+            )
+            self._write_log(log_prefix, result)
+            if result.returncode != 0:
+                stderr_preview = (result.stderr or result.stdout or "").strip().splitlines()[:5]
+                detail = stderr_preview[0] if stderr_preview else "No diagnostics were produced."
+                return ExecutionResult(
+                    success=False,
+                    message=f"{self.client} exited with code {result.returncode}: {detail}",
+                )
+            return ExecutionResult(success=True, message=f"{self.client} execution finished.")
+        except subprocess.TimeoutExpired as exc:
+            _ = exc
+            return ExecutionResult(
+                success=False,
+                message=f"{self.client} execution timed out after {self.timeout_seconds}s.",
+            )
+        except Exception as exc:
+            return ExecutionResult(success=False, message=str(exc))
+
+    def _write_log(self, task_client: 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_client}.log"
+        log_path.write_text(
+            "\n".join([
+                f"command_returncode={result.returncode}",
+                "=== stdout ===",
+                result.stdout or "",
+                "=== stderr ===",
+                result.stderr or "",
+            ]),
+            encoding="utf-8",
+        )