devcouncil 0.2.0 → 0.2.1

package/src/devcouncil/verification/sandbox.py

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

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