devcouncil 0.1.0

package/src/devcouncil/execution/hook_policy.py

@@ -0,0 +1,144 @@
+import fnmatch
+import re
+from dataclasses import dataclass
+from pathlib import Path
+from pathlib import PurePosixPath
+from typing import Any, Optional
+
+from devcouncil.domain.task import Task
+
+
+@dataclass(frozen=True)
+class HookDecision:
+    action: str
+    reason: str
+    target: Optional[str] = None
+
+    @property
+    def allowed(self) -> bool:
+        return self.action in {"allow", "warn"}
+
+
+class HookPolicy:
+    """Policy-backed hook checks for Claude-style pre-tool-use events."""
+
+    def __init__(self, project_root: Path | None = None):
+        self.project_root = project_root.resolve() if project_root else None
+
+    secret_path_patterns = (
+        ".env",
+        ".env.*",
+        "**/.env",
+        "**/.env.*",
+        "**/credentials/**",
+        "**/secrets/**",
+        "**/*.pem",
+        "**/*.key",
+    )
+    protected_path_patterns = (
+        "package.json",
+        "pyproject.toml",
+        "uv.lock",
+        "Dockerfile",
+        "docker-compose.yml",
+        ".github/workflows/*.yml",
+        ".github/workflows/*.yaml",
+        "schema.prisma",
+        "wrangler.toml",
+        "index.html",
+    )
+    write_tools = {"write_file", "edit_file", "replace", "Write", "Edit", "MultiEdit"}
+    shell_tools = {"bash", "shell", "run_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 "")
+        arguments = call_data.get("arguments") or call_data.get("input") or call_data.get("tool_input") or {}
+        if not isinstance(arguments, dict):
+            arguments = {}
+
+        if tool_name in self.shell_tools:
+            command = self._extract_command(arguments)
+            return self.evaluate_command(command)
+
+        if tool_name in self.write_tools:
+            target = self._extract_path(arguments)
+            return self.evaluate_file_write(target, active_task)
+
+        return HookDecision("allow", "Tool is outside DevCouncil hook policy.")
+
+    def evaluate_command(self, command: str) -> HookDecision:
+        normalized = " ".join(command.split())
+        lowered = normalized.lower()
+        if not normalized:
+            return HookDecision("allow", "No command detected.")
+
+        if "--no-verify" in lowered or "--no-gpg-sign" in lowered:
+            return HookDecision("deny", "Verification bypass flags are not allowed.", normalized)
+
+        if re.search(r"\bgit\s+reset\s+--hard\s+(origin/)?(main|master)\b", lowered):
+            return HookDecision("deny", "Protected branch hard resets are not allowed.", normalized)
+
+        if re.search(r"\bgit\s+push\b.*(\s--force(?:-with-lease)?\b|\s-f\b)", lowered):
+            return HookDecision("deny", "Force pushes are not allowed.", normalized)
+
+        if re.search(r"\bgit\s+push\s+\S+\s+((head:)?(main|master)|(main|master):\S+)\b", lowered):
+            return HookDecision("warn", "Direct pushes to protected branches should go through verification gates.", normalized)
+
+        return HookDecision("allow", "Command is allowed.", normalized)
+
+    def evaluate_file_write(self, raw_path: Optional[str], active_task: Optional[Task]) -> HookDecision:
+        if not raw_path:
+            return HookDecision("allow", "No file path detected.")
+
+        path = self._normalize_path(raw_path)
+        if self._matches_any(path, self.secret_path_patterns):
+            return HookDecision("deny", "Secret and credential paths are never writable through hooks.", path)
+
+        if active_task is None:
+            return HookDecision("deny", "No running DevCouncil task authorizes this file write.", path)
+
+        if active_task and not self._is_planned_file(path, active_task):
+            return HookDecision("deny", f"Task {active_task.id} does not authorize changes to {path}.", path)
+
+        if self._matches_any(path, self.protected_path_patterns):
+            return HookDecision("warn", f"{path} is a protected high-impact file; verification gates must approve it.", path)
+
+        return HookDecision("allow", "File write is allowed.", path)
+
+    def _extract_command(self, arguments: dict[str, Any]) -> str:
+        value = arguments.get("command") or arguments.get("cmd") or arguments.get("script") or ""
+        return str(value)
+
+    def _extract_path(self, arguments: dict[str, Any]) -> Optional[str]:
+        value = (
+            arguments.get("path")
+            or arguments.get("file_path")
+            or arguments.get("filepath")
+            or arguments.get("filePath")
+            or arguments.get("target")
+        )
+        return str(value) if value else None
+
+    def _normalize_path(self, raw_path: str) -> str:
+        path = raw_path.strip().strip('"').replace("\\", "/")
+        if self.project_root:
+            try:
+                candidate = Path(path)
+                resolved = candidate.resolve() if candidate.is_absolute() else (self.project_root / path).resolve()
+                return resolved.relative_to(self.project_root).as_posix()
+            except (OSError, ValueError):
+                pass
+        if re.match(r"^[A-Za-z]:/", path):
+            parts = PurePosixPath(path).parts
+            path = "/".join(parts[1:])
+        return path[2:] if path.startswith("./") else path
+
+    def _is_planned_file(self, path: str, task: Task) -> bool:
+        for planned in task.planned_files:
+            planned_path = self._normalize_path(planned.path)
+            if path == planned_path or fnmatch.fnmatch(path, planned_path):
+                return True
+        return False
+
+    def _matches_any(self, path: str, patterns: tuple[str, ...]) -> bool:
+        return any(fnmatch.fnmatch(path, pattern) for pattern in patterns)

package/src/devcouncil/execution/patch.py

@@ -0,0 +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()

package/src/devcouncil/execution/paths.py

@@ -0,0 +1,14 @@
+from pathlib import Path
+
+from devcouncil.app.errors import ExecutionError
+
+
+def resolve_project_path(project_root: Path, path: str) -> Path:
+    """Resolve a repository-relative path and reject paths outside the project."""
+    root_resolved = project_root.resolve()
+    resolved = (root_resolved / path).resolve()
+    try:
+        resolved.relative_to(root_resolved)
+    except ValueError as exc:
+        raise ExecutionError(f"Path traversal blocked: {path} resolves outside project root.") from exc
+    return resolved

package/src/devcouncil/execution/permissions.py

@@ -0,0 +1,92 @@
+import fnmatch
+from pathlib import Path
+from typing import List, Literal, Optional
+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*"])
+
+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 is_file_change_allowed(
+        self,
+        path: str,
+        task: Task,
+        operation: Literal["create", "modify", "delete", "write"] = "write",
+    ) -> bool:
+        """Check if a file change is authorized by the task or policy."""
+        # 1. Check restricted paths (e.g. .git) and dynamic ignores
+        all_restricted = self.policy.restricted_paths + self.dynamic_ignores
+        for restricted in all_restricted:
+            if fnmatch.fnmatch(path, restricted) or path.startswith(restricted.strip("*")):
+                return False
+
+        # 2. Check if path is in task's planned files with a compatible operation.
+        planned = self._planned_file_for(path, task)
+        if not planned:
+            return False
+
+        if planned.allowed_change == "read_only":
+            return False
+        if operation == "write":
+            return planned.allowed_change in {"create", "modify"}
+        return planned.allowed_change == operation
+
+    def _planned_file_for(self, path: str, task: Task) -> Optional[PlannedFile]:
+        normalized = path.replace("\\", "/")
+        for planned in task.planned_files:
+            planned_path = planned.path.replace("\\", "/")
+            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 validate_action(
+        self,
+        action_type: str,
+        target: str,
+        task: Task,
+        operation: Literal["create", "modify", "delete", "write"] = "write",
+    ):
+        """Raise GatingError if an execution action violates permissions."""
+        if action_type == "file_write":
+            if not self.is_file_change_allowed(target, task, operation):
+                raise GatingError(
+                    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.")

package/src/devcouncil/execution/prompt_builder.py

@@ -0,0 +1,59 @@
+from pathlib import Path
+from typing import List
+
+from devcouncil.domain.requirement import Requirement
+from devcouncil.domain.task import Task
+from devcouncil.integrations.code_review_graph import CodeReviewGraphAdapter
+
+class PromptBuilder:
+    def __init__(self, project_root: Path = Path(".")):
+        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"
+
+        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:
+                prompt += f"- `{fc}`\n"
+
+        prompt += "\n## Expected tests\n"
+        for et in task.expected_tests:
+            prompt += f"- `{et}`\n"
+
+        prompt += "\n## Allowed commands\n"
+        for cmd in task.allowed_commands:
+            prompt += f"- `{cmd}`\n"
+
+        graph_context = CodeReviewGraphAdapter(self.project_root).prompt_section(
+            [planned.path for planned in task.planned_files]
+        )
+        if graph_context:
+            prompt += f"\n{graph_context}"
+
+        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

package/src/devcouncil/execution/task_runner.py

@@ -0,0 +1,166 @@
+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.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)
+
+    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)
+        for path, operation in changes.items():
+            self._validate_path_within_root(path)
+            self.permissions.validate_action("file_write", path, task, operation=operation)
+        applied = self.patch_engine.apply_patch(patch)
+        TraceLogger(self.project_root).log_event(
+            "tool_patch_applied",
+            {"paths": sorted(changes), "success": applied},
+            task_id=task.id,
+            summary=f"Patch {'applied' if applied else 'failed'} for {task.id}",
+        )
+        return applied
+
+    def _extract_patch_paths(self, patch: str) -> set[str]:
+        return set(self._extract_patch_changes(patch))
+
+    def _extract_patch_changes(self, patch: str) -> dict[str, Literal["create", "modify", "delete"]]:
+        """Extract repository-relative file paths touched by a unified git patch."""
+        changes: dict[str, Literal["create", "modify", "delete"]] = {}
+        old_path: Optional[str] = None
+        old_is_null = False
+        for line in patch.splitlines():
+            if line.startswith("diff --git "):
+                parts = line.split()
+                cleaned = self._normalize_patch_path(parts[3]) if len(parts) > 3 else None
+                if cleaned:
+                    changes.setdefault(cleaned, "modify")
+                old_path = self._normalize_patch_path(parts[2]) if len(parts) > 2 else None
+                old_is_null = False
+                continue
+
+            if line.startswith("--- "):
+                raw = line[4:].split("\t", 1)[0].strip()
+                old_is_null = raw == "/dev/null"
+                old_path = self._normalize_patch_path(raw)
+                continue
+
+            if line.startswith("+++ "):
+                raw = line[4:].split("\t", 1)[0].strip()
+                if raw == "/dev/null":
+                    if old_path:
+                        changes[old_path] = "delete"
+                    continue
+                new_path = self._normalize_patch_path(raw)
+                if new_path:
+                    changes[new_path] = "create" if old_is_null else "modify"
+
+        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]
+        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
+            )
+            stdout = result.stdout or ""
+            stderr = result.stderr or ""
+            stdout_path = self._save_command_log(task.id, command, "stdout", stdout)
+            stderr_path = self._save_command_log(task.id, command, "stderr", stderr)
+            stdout_summary = redact_string(stdout[-500:])
+            stderr_summary = redact_string(stderr[-500:])
+            TraceLogger(self.project_root).log_event(
+                "command_executed",
+                {"command": command, "exit_code": result.returncode},
+                task_id=task.id,
+                summary=f"{command} exited {result.returncode}",
+            )
+            return CommandResult(
+                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}")
+
+    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)
+        full_path = resolve_project_path(self.project_root, path)
+        operation = "modify" if full_path.exists() else "create"
+        self.permissions.validate_action("file_write", path, task, operation=operation)
+
+        logger.info(f"Writing authorized file: {path}")
+        try:
+            full_path.parent.mkdir(parents=True, exist_ok=True)
+            full_path.write_text(content, encoding="utf-8")
+            TraceLogger(self.project_root).log_event(
+                "file_written",
+                {"path": path},
+                task_id=task.id,
+                summary=f"Wrote {path}",
+            )
+        except Exception as e:
+            raise ExecutionError(f"Failed to write file {path}: {e}")

package/src/devcouncil/executors/__init__.py

@@ -0,0 +1 @@
+

package/src/devcouncil/executors/mini_swe.py

@@ -0,0 +1,73 @@
+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",
+        )