devcouncil 0.1.0 → 0.2.0

package/src/devcouncil/verification/sandbox.py

@@ -0,0 +1,178 @@
+"""Verification sandbox abstraction."""
+
+from __future__ import annotations
+
+import hashlib
+import platform
+import subprocess
+import sys
+from pathlib import Path
+from typing import Literal
+
+from pydantic import BaseModel
+
+from devcouncil.app.config import DevCouncilConfig, load_config
+from devcouncil.domain.task import Task
+from devcouncil.storage.db import get_db
+from devcouncil.storage.native import VerificationRunRepository
+from devcouncil.verification.verifier import Verifier
+
+
+class SandboxResult(BaseModel):
+    sandbox: str
+    status: Literal["passed", "failed", "unsupported"]
+    environment: dict[str, str]
+    commands: list[dict]
+
+
+class VerificationSandbox:
+    def run(self, task: Task, commands: list[str], requirements: list) -> SandboxResult:
+        raise NotImplementedError
+
+
+def _save_run(
+    project_root: Path,
+    task: Task,
+    sandbox: str,
+    environment: dict[str, str],
+    commands: list[dict],
+    status: Literal["passed", "failed", "unsupported"],
+) -> None:
+    db = get_db(project_root)
+    if not db:
+        return
+    with db.get_session() as session:
+        VerificationRunRepository(session).save(
+            task.id,
+            sandbox,
+            environment,
+            commands,
+            status,
+        )
+
+
+class LocalSandbox(VerificationSandbox):
+    def __init__(self, project_root: Path):
+        self.project_root = project_root
+
+    def run(self, task: Task, commands: list[str], requirements: list) -> SandboxResult:
+        import asyncio
+
+        gaps, _ = asyncio.run(Verifier(self.project_root).verify_task(task, requirements))
+        status: Literal["passed", "failed", "unsupported"] = (
+            "failed" if any(g.blocking for g in gaps) else "passed"
+        )
+        env = _environment_metadata(self.project_root)
+        command_results = [{"command": cmd, "status": status} for cmd in commands]
+        _save_run(self.project_root, task, "local", env, command_results, status)
+        return SandboxResult(sandbox="local", status=status, environment=env, commands=command_results)
+
+
+class DockerSandbox(VerificationSandbox):
+    def __init__(self, project_root: Path, config: DevCouncilConfig):
+        self.project_root = project_root
+        self.config = config
+
+    def run(self, task: Task, commands: list[str], requirements: list) -> SandboxResult:
+        if not shutil_which("docker"):
+            result = SandboxResult(
+                sandbox="docker",
+                status="unsupported",
+                environment={},
+                commands=[{"reason": "docker not available"}],
+            )
+            _save_run(self.project_root, task, "docker", result.environment, result.commands, result.status)
+            return result
+        image = self.config.verification.sandbox.docker_image
+        setup = self.config.verification.sandbox.docker_setup_commands
+        results: list[dict] = []
+        for setup_cmd in setup:
+            proc = subprocess.run(
+                ["docker", "run", "--rm", "-v", f"{self.project_root}:/work", "-w", "/work", image, "sh", "-c", setup_cmd],
+                capture_output=True,
+                text=True,
+            )
+            results.append({"command": setup_cmd, "exit_code": proc.returncode})
+            if proc.returncode != 0:
+                result = SandboxResult(sandbox="docker", status="failed", environment={"image": image}, commands=results)
+                _save_run(self.project_root, task, "docker", result.environment, result.commands, result.status)
+                return result
+        for cmd in commands:
+            proc = subprocess.run(
+                ["docker", "run", "--rm", "-v", f"{self.project_root}:/work", "-w", "/work", image, "sh", "-c", cmd],
+                capture_output=True,
+                text=True,
+            )
+            results.append({"command": cmd, "exit_code": proc.returncode})
+            if proc.returncode != 0:
+                result = SandboxResult(sandbox="docker", status="failed", environment={"image": image}, commands=results)
+                _save_run(self.project_root, task, "docker", result.environment, result.commands, result.status)
+                return result
+        result = SandboxResult(sandbox="docker", status="passed", environment={"image": image}, commands=results)
+        _save_run(self.project_root, task, "docker", result.environment, result.commands, result.status)
+        return result
+
+
+class NixSandbox(VerificationSandbox):
+    def __init__(self, project_root: Path, config: DevCouncilConfig):
+        self.project_root = project_root
+        self.config = config
+
+    def run(self, task: Task, commands: list[str], requirements: list) -> SandboxResult:
+        if not (self.project_root / "flake.nix").exists() or not shutil_which("nix"):
+            result = SandboxResult(
+                sandbox="nix",
+                status="unsupported",
+                environment={},
+                commands=[{"reason": "nix or flake.nix unavailable"}],
+            )
+            _save_run(self.project_root, task, "nix", result.environment, result.commands, result.status)
+            return result
+        attr = self.config.verification.sandbox.nix_flake_attr or "devShells.default"
+        results: list[dict] = []
+        for cmd in commands:
+            proc = subprocess.run(
+                ["nix", "develop", f".#{attr}", "-c", "sh", "-c", cmd],
+                cwd=self.project_root,
+                capture_output=True,
+                text=True,
+            )
+            results.append({"command": cmd, "exit_code": proc.returncode})
+            if proc.returncode != 0:
+                result = SandboxResult(sandbox="nix", status="failed", environment={"attr": attr}, commands=results)
+                _save_run(self.project_root, task, "nix", result.environment, result.commands, result.status)
+                return result
+        result = SandboxResult(sandbox="nix", status="passed", environment={"attr": attr}, commands=results)
+        _save_run(self.project_root, task, "nix", result.environment, result.commands, result.status)
+        return result
+
+
+def shutil_which(name: str) -> str | None:
+    import shutil
+
+    return shutil.which(name)
+
+
+def _environment_metadata(project_root: Path) -> dict[str, str]:
+    env = {
+        "python": sys.version.split()[0],
+        "platform": platform.platform(),
+    }
+    try:
+        uv = subprocess.check_output(["uv", "--version"], text=True).strip()
+        env["uv"] = uv
+    except (FileNotFoundError, subprocess.CalledProcessError, OSError):
+        pass
+    lock = project_root / "uv.lock"
+    if lock.exists():
+        env["uv_lock_hash"] = hashlib.sha256(lock.read_bytes()).hexdigest()[:16]
+    return env
+
+
+def get_sandbox(name: str, project_root: Path) -> VerificationSandbox:
+    config = load_config(project_root)
+    if name == "docker":
+        return DockerSandbox(project_root, config)
+    if name == "nix":
+        return NixSandbox(project_root, config)
+    return LocalSandbox(project_root)

package/src/devcouncil/verification/test_resolver.py

@@ -0,0 +1,91 @@
+"""Evidence suggestion from changed files."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Literal
+
+from pydantic import BaseModel
+
+from devcouncil.domain.task import Task
+
+
+class EvidenceSuggestion(BaseModel):
+    command: str
+    confidence: Literal["high", "medium", "low"]
+    reason: str
+    paths: list[str] = []
+
+
+class TestResolver:
+    __test__ = False
+
+    def __init__(self, project_root: Path):
+        self.project_root = project_root.resolve()
+
+    def suggest_for_task(
+        self,
+        task: Task,
+        changed_files: list[str] | None = None,
+    ) -> list[EvidenceSuggestion]:
+        files = changed_files or [pf.path for pf in task.planned_files]
+        suggestions: list[EvidenceSuggestion] = []
+        seen: set[str] = set()
+
+        for path in files:
+            normalized = path.replace("\\", "/")
+            for candidate in self._candidates_for_path(normalized):
+                if candidate in seen:
+                    continue
+                seen.add(candidate)
+                confidence, reason = self._confidence_for(normalized, candidate)
+                suggestions.append(
+                    EvidenceSuggestion(
+                        command=candidate,
+                        confidence=confidence,
+                        reason=reason,
+                        paths=[normalized],
+                    )
+                )
+        return suggestions
+
+    def _candidates_for_path(self, path: str) -> list[str]:
+        candidates: list[str] = []
+        if path.startswith("src/") and path.endswith(".py"):
+            module = path.removeprefix("src/").removesuffix(".py")
+            parts = module.split("/")
+            if len(parts) >= 2:
+                nested = self.project_root / "tests" / parts[0] / f"test_{parts[-1]}.py"
+                if nested.exists():
+                    candidates.append(f"pytest {nested.relative_to(self.project_root).as_posix()}")
+            flat = self.project_root / "tests" / f"test_{parts[-1]}.py"
+            if flat.exists():
+                candidates.append(f"pytest {flat.relative_to(self.project_root).as_posix()}")
+            if "cli/commands/" in path:
+                unit = self.project_root / "tests/unit/test_cli_commands.py"
+                if unit.exists():
+                    candidates.append(f"pytest {unit.relative_to(self.project_root).as_posix()}")
+            if path.endswith("policy_engine.py"):
+                unit = self.project_root / "tests/unit/test_task_policy_engine.py"
+                if unit.exists():
+                    candidates.append(f"pytest {unit.relative_to(self.project_root).as_posix()}")
+        if path == "src/auth.py":
+            auth_test = self.project_root / "tests/test_auth.py"
+            if auth_test.exists():
+                candidates.append("pytest tests/test_auth.py")
+        if not candidates:
+            candidates.append("pytest tests/unit")
+        return candidates
+
+    def _confidence_for(self, path: str, command: str) -> tuple[Literal["high", "medium", "low"], str]:
+        if "test_auth.py" in command and path.endswith("auth.py"):
+            return "high", "Direct auth module mapping"
+        if path.endswith("policy_engine.py") and "test_task_policy_engine.py" in command:
+            return "high", "Policy engine unit test exists"
+        if "cli/commands" in path and "test_cli_commands.py" in command:
+            return "high", "CLI command module maps to cli command tests"
+        if command.startswith("pytest tests/") and command != "pytest tests/unit":
+            return "high", "Nested module test path exists"
+        if "test_" in command:
+            return "medium", "Related test file match"
+        return "low", "Package-level fallback"