devvy 0.1.0__py3-none-any.whl

cli/local_runner/repo_detection.py

@@ -0,0 +1,182 @@
+"""Repo container detection — inspects the cloned workspace to determine
+how to build and run the repo's own container for validation.
+
+This module is pure filesystem inspection — no Docker calls, fully testable
+in isolation.
+"""
+
+from __future__ import annotations
+
+import json as _json
+from pathlib import Path
+from typing import Literal
+
+
+# Services whose names suggest infrastructure rather than the app itself.
+# We skip these when auto-detecting the app service from docker-compose.
+_INFRA_SERVICE_NAMES = frozenset(
+    {
+        "db",
+        "database",
+        "redis",
+        "postgres",
+        "postgresql",
+        "mysql",
+        "mongo",
+        "mongodb",
+        "mssql",
+        "sqlserver",
+        "cache",
+        "rabbitmq",
+        "kafka",
+        "worker",
+        "nginx",
+        "proxy",
+        "elasticsearch",
+        "elastic",
+    }
+)
+
+from dataclasses import dataclass
+
+
+@dataclass
+class RepoContainerConfig:
+    """How to build and run the repo's own container for validation."""
+
+    kind: Literal["compose", "dockerfile"]
+    # compose only
+    compose_file: str | None  # absolute host path
+    service: str | None  # docker-compose service name
+    # dockerfile only
+    dockerfile: str | None  # path relative to workspace root
+    context: str | None  # absolute host path used as build context
+    # shared
+    image_tag: str  # e.g. "devvy-repo-<ticket_id[:8]>"
+
+    def to_json(self) -> str:
+        from dataclasses import asdict
+
+        return _json.dumps(asdict(self))
+
+    @staticmethod
+    def from_json(raw: str) -> "RepoContainerConfig":
+        return RepoContainerConfig(**_json.loads(raw))
+
+
+def detect_repo_container(ws: Path, ticket_id: str) -> RepoContainerConfig:
+    """
+    Inspect the cloned workspace and return a RepoContainerConfig describing
+    how to build and run the repo's own container for validation.
+
+    Detection order:
+      1. docker-compose.yml / docker-compose.yaml — pick the first non-infra
+         service that has a ``build:`` key.
+      2. .devcontainer/devcontainer.json — VS Code devcontainer spec.
+      3. Dockerfile at the repo root.
+
+    Raises RuntimeError if none of the above are found, with a helpful message.
+    """
+    image_tag = f"devvy-repo-{ticket_id[:8]}"
+
+    # 1. docker-compose
+    for compose_name in ("docker-compose.yml", "docker-compose.yaml"):
+        compose_path = ws / compose_name
+        if compose_path.is_file():
+            service = _pick_compose_service(compose_path)
+            if service:
+                return RepoContainerConfig(
+                    kind="compose",
+                    compose_file=str(compose_path),
+                    service=service,
+                    dockerfile=None,
+                    context=None,
+                    image_tag=image_tag,
+                )
+
+    # 2. .devcontainer/devcontainer.json
+    devcontainer = ws / ".devcontainer" / "devcontainer.json"
+    if devcontainer.is_file():
+        try:
+            cfg = _json.loads(devcontainer.read_text())
+            build_cfg = cfg.get("build", {})
+            dockerfile = build_cfg.get("dockerfile") or cfg.get("dockerFile")
+            if dockerfile:
+                context = str(ws / build_cfg.get("context", "."))
+                return RepoContainerConfig(
+                    kind="dockerfile",
+                    compose_file=None,
+                    service=None,
+                    dockerfile=dockerfile,
+                    context=context,
+                    image_tag=image_tag,
+                )
+        except Exception:
+            pass
+
+    # 3. Root Dockerfile (case-insensitive — some repos use lowercase 'dockerfile')
+    for dockerfile_name in ("Dockerfile", "dockerfile"):
+        if (ws / dockerfile_name).is_file():
+            return RepoContainerConfig(
+                kind="dockerfile",
+                compose_file=None,
+                service=None,
+                dockerfile=dockerfile_name,
+                context=str(ws),
+                image_tag=image_tag,
+            )
+
+    raise RuntimeError(
+        "devvy could not find a container config in this repo.\n"
+        "Add one of the following so devvy knows how to run validation:\n"
+        "  • docker-compose.yml  (with a build: service)\n"
+        "  • .devcontainer/devcontainer.json\n"
+        "  • Dockerfile  (at the repo root)"
+    )
+
+
+def _pick_compose_service(compose_path: Path) -> str | None:
+    """
+    Parse a docker-compose file and return the name of the best candidate
+    app service (has a ``build:`` key, not an infra service by name).
+
+    Preferred names (``app``, ``api``, ``service``) are chosen first if present.
+    Otherwise the first non-infra service with a ``build:`` key wins.
+
+    Returns None if no suitable service is found.
+    """
+    # Well-known app service names: checked before falling back to positional order.
+    _PREFERRED_SERVICE_NAMES = ("app", "api", "service")
+
+    try:
+        # Avoid adding a pyyaml hard-dependency: use a minimal regex-free
+        # approach — just try importing yaml and fall back to None on failure.
+        import yaml  # type: ignore[import-untyped]
+
+        data = yaml.safe_load(compose_path.read_text())
+    except Exception:
+        return None
+
+    services: dict = (data or {}).get("services", {})
+
+    # Collect all buildable, non-infra services preserving declaration order.
+    candidates: list[str] = []
+    for name, svc in services.items():
+        if not isinstance(svc, dict):
+            continue
+        if "build" not in svc:
+            continue
+        if name.lower() in _INFRA_SERVICE_NAMES:
+            continue
+        candidates.append(name)
+
+    if not candidates:
+        return None
+
+    # Prefer well-known app service names over positional order.
+    for preferred in _PREFERRED_SERVICE_NAMES:
+        for name in candidates:
+            if name.lower() == preferred:
+                return name
+
+    return candidates[0]

cli/local_runner/validation.py

@@ -0,0 +1,203 @@
+"""Validation pipeline — builds the repo's own container image, runs the
+three standard validation scripts (format, code-checks, run-tests), then
+tears the container down.
+
+Validation is intentionally separate from workspace lifecycle so it can be
+called multiple times (self-fix retry loop) without re-cloning.
+"""
+
+from __future__ import annotations
+
+import asyncio
+from dataclasses import dataclass
+from pathlib import Path
+
+from cli.local_runner.docker_primitives import CONTAINER_WORKSPACE, _run
+from cli.local_runner.repo_detection import RepoContainerConfig
+
+
+# Conventional locations for validation scripts, relative to /workspace.
+_FORMAT_SCRIPT = "src/scripts/format.sh"
+_CODE_CHECKS_SCRIPT = "src/scripts/code-checks.sh"
+_RUN_TESTS_SCRIPT = "src/scripts/run-tests.sh"
+
+
+@dataclass
+class ValidationResult:
+    passed: bool
+    output: str
+
+
+async def _file_exists_in_container(container_id: str, path: str) -> bool:
+    """Return True if *path* exists (as a file) inside the container."""
+    try:
+        await _run(["docker", "exec", container_id, "test", "-f", path], check=True)
+        return True
+    except RuntimeError:
+        return False
+
+
+async def _exec_script(
+    container_id: str,
+    script_path: str,
+    env: dict[str, str] | None = None,
+    workdir: str | None = None,
+) -> tuple[bool, str]:
+    """
+    Run a shell script inside the container.
+
+    Returns (passed, output). Never raises on non-zero exit — failures are
+    captured in the returned output string.
+    """
+    cmd = ["docker", "exec"]
+    if workdir:
+        cmd += ["--workdir", workdir]
+    if env:
+        for k, v in env.items():
+            cmd += ["-e", f"{k}={v}"]
+    cmd += [container_id, "bash", script_path]
+    try:
+        out = await _run(cmd, check=True)
+        return True, out
+    except RuntimeError as exc:
+        return False, str(exc)
+
+
+async def run_validation(repo_cfg: RepoContainerConfig) -> ValidationResult:
+    """
+    Build the repo's own container image, spin up a temporary instance with the
+    workspace bind-mounted, run the repo's validation scripts in order, then
+    tear the container down.
+
+    Script execution order (each looked up at /workspace/src/scripts/):
+      1. format.sh       — auto-format  (non-fatal: applies changes, always runs)
+      2. code-checks.sh  — lint + types (fatal on non-zero exit)
+      3. run-tests.sh    — test suite   (fatal on non-zero exit)
+
+    Raises RuntimeError if no validation scripts are found at all.
+    Returns a ValidationResult — never raises on script failure itself.
+    """
+    ws = (
+        Path(repo_cfg.context or "")
+        if repo_cfg.kind == "dockerfile"
+        else Path(repo_cfg.compose_file or "").parent
+    )
+    container_name = f"devvy-validate-{repo_cfg.image_tag.split('-')[-1]}"
+    combined: list[str] = []
+    all_passed = True
+
+    # ------------------------------------------------------------------
+    # 1. Build the repo's image
+    # ------------------------------------------------------------------
+    if repo_cfg.kind == "compose":
+        if not repo_cfg.compose_file or not repo_cfg.service:
+            raise RuntimeError("RepoContainerConfig missing compose_file or service")
+        compose_file: str = repo_cfg.compose_file
+        service: str = repo_cfg.service
+        await _run(["docker", "compose", "-f", compose_file, "build", service])
+        # Docker Compose names built images as <project>-<service>:latest where
+        # project is the lowercase directory name of the compose file's parent.
+        # `docker compose images -q` only lists images for *running* containers
+        # so it returns nothing here — derive the name directly instead.
+        project = Path(compose_file).parent.name.lower()
+        image_name = f"{project}-{service}:latest"
+    else:
+        if not repo_cfg.dockerfile or not repo_cfg.context:
+            raise RuntimeError("RepoContainerConfig missing dockerfile or context")
+        dockerfile: str = repo_cfg.dockerfile
+        context: str = repo_cfg.context
+        await _run(
+            ["docker", "build", "-f", dockerfile, "-t", repo_cfg.image_tag, context]
+        )
+        image_name = repo_cfg.image_tag
+
+    # ------------------------------------------------------------------
+    # 2. Spin up a temporary validation container
+    # ------------------------------------------------------------------
+    # Remove any stale container with the same name first
+    await _run(["docker", "rm", "--force", container_name], check=False)
+
+    validate_container_id = (
+        await _run(
+            [
+                "docker",
+                "run",
+                "--detach",
+                "--name",
+                container_name,
+                "-v",
+                f"{ws}:{CONTAINER_WORKSPACE}",
+                image_name,
+                "sleep",
+                "infinity",
+            ]
+        )
+    ).strip()
+
+    try:
+        # ------------------------------------------------------------------
+        # 3. Discover which scripts exist
+        # ------------------------------------------------------------------
+        format_path = f"{CONTAINER_WORKSPACE}/{_FORMAT_SCRIPT}"
+        checks_path = f"{CONTAINER_WORKSPACE}/{_CODE_CHECKS_SCRIPT}"
+        tests_path = f"{CONTAINER_WORKSPACE}/{_RUN_TESTS_SCRIPT}"
+
+        format_exists, checks_exists, tests_exists = await asyncio.gather(
+            _file_exists_in_container(validate_container_id, format_path),
+            _file_exists_in_container(validate_container_id, checks_path),
+            _file_exists_in_container(validate_container_id, tests_path),
+        )
+
+        if not (format_exists or checks_exists or tests_exists):
+            raise RuntimeError(
+                "No validation scripts found in this repo.\n"
+                f"Expected at least one of:\n"
+                f"  • {_FORMAT_SCRIPT}\n"
+                f"  • {_CODE_CHECKS_SCRIPT}\n"
+                f"  • {_RUN_TESTS_SCRIPT}"
+            )
+
+        # ------------------------------------------------------------------
+        # 4a. format.sh — non-fatal, always run first if present
+        #     Changes it writes land in /workspace (shared bind-mount) so
+        #     the devvy-worker container and subsequent git commits pick them up.
+        # ------------------------------------------------------------------
+        if format_exists:
+            _, out = await _exec_script(validate_container_id, format_path)
+            combined.append(f"--- format.sh ---\n{out}")
+            # Non-fatal: log the result but don't fail validation
+
+        # ------------------------------------------------------------------
+        # 4b. code-checks.sh — fatal
+        # ------------------------------------------------------------------
+        if checks_exists:
+            passed, out = await _exec_script(validate_container_id, checks_path)
+            combined.append(f"--- code-checks.sh ---\n{out}")
+            if not passed:
+                all_passed = False
+
+        # ------------------------------------------------------------------
+        # 4c. run-tests.sh — fatal
+        # ------------------------------------------------------------------
+        if tests_exists:
+            passed, out = await _exec_script(validate_container_id, tests_path)
+            combined.append(f"--- run-tests.sh ---\n{out}")
+            if not passed:
+                all_passed = False
+
+    finally:
+        # ------------------------------------------------------------------
+        # 5. Always tear down the validation container and its image.
+        #    The repo image is a ~1-2 GB throwaway rebuilt every validation
+        #    run (including retries), so we remove it immediately to avoid
+        #    filling disk.  Dangling build-cache layers are pruned too.
+        # ------------------------------------------------------------------
+        await _run(["docker", "stop", validate_container_id], check=False)
+        await _run(["docker", "rm", "--force", validate_container_id], check=False)
+        await _run(["docker", "rmi", "--force", image_name], check=False)
+        await _run(
+            ["docker", "builder", "prune", "--filter", "dangling=true", "--force"],
+            check=False,
+        )
+
+    return ValidationResult(passed=all_passed, output="\n".join(combined))

cli/local_runner/workspace.py

@@ -0,0 +1,295 @@
+"""Workspace lifecycle and agent operations.
+
+Covers the full lifecycle of a devvy workspace:
+  - prepare_workspace  — clone, start container, detect repo config
+  - recover_container  — re-attach or re-spawn for a resume
+  - run_opencode       — invoke opencode inside the worker container
+  - run_git            — git passthrough into the container
+  - commit_if_changed  — stage + commit if there are changes
+  - push_branch        — push agent branch to origin
+  - read_pr_template   — find ADO PR template in the workspace
+  - cleanup_workspace  — stop container, delete workspace dir
+"""
+
+from __future__ import annotations
+
+import json as _json
+import shutil
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+
+from cli.local_runner.credentials import _write_git_credentials
+from cli.local_runner.docker_primitives import (
+    CONTAINER_WORKSPACE,
+    WORKSPACE_BASE,
+    _check_tool,
+    _check_worker_image,
+    _run,
+    _start_worker_container,
+)
+from cli.local_runner.repo_detection import RepoContainerConfig, detect_repo_container
+
+
+@dataclass
+class WorkspaceSetup:
+    """Return value of ``prepare_workspace``, grouping all workspace artefacts."""
+
+    branch_name: str
+    workspace: Path
+    container_id: str
+    default_branch: str
+    repo_cfg: RepoContainerConfig
+
+
+def workspace_path(ticket_id: str) -> Path:
+    return WORKSPACE_BASE / ticket_id
+
+
+async def prepare_workspace(
+    ticket_id: str,
+    repo_url: str,
+    ado_pat: str,
+    env_file: str | None = None,
+) -> WorkspaceSetup:
+    """
+    Clone the repo on the host, start an ephemeral worker container, and
+    detect the repo's own container config for validation.
+
+    If ``env_file`` is set and points to a readable file, it is copied into the
+    cloned workspace as ``.env`` before the container image is built.  This is
+    needed for repos whose docker-compose references a ``.env`` that is gitignored.
+
+    Returns a WorkspaceSetup with branch_name, workspace path, container_id,
+    default_branch, and repo_cfg.
+    """
+    _check_tool("docker")
+    _check_tool("git")
+    await _check_worker_image()
+
+    ws = workspace_path(ticket_id)
+    ws.parent.mkdir(parents=True, exist_ok=True)
+
+    if ws.exists():
+        shutil.rmtree(ws)
+
+    # Write a temporary git credentials file outside the workspace so the PAT
+    # is never embedded in .git/config (where the validation container could read it).
+    creds_path = _write_git_credentials(ticket_id, repo_url, ado_pat)
+    try:
+        await _run(
+            [
+                "git",
+                "-c",
+                f"credential.helper=store --file {creds_path}",
+                "clone",
+                repo_url,
+                str(ws),
+            ]
+        )
+    finally:
+        creds_path.unlink(missing_ok=True)
+
+    # Copy the .env file into the workspace if one was configured.
+    # docker-compose files typically reference .env for port/password vars, but
+    # .env is gitignored so it won't be present in the clone.
+    if env_file:
+        src_env = Path(env_file).expanduser()
+        if src_env.is_file():
+            shutil.copy2(src_env, ws / ".env")
+        else:
+            # Non-fatal — warn but continue; the build may still succeed if
+            # all referenced vars have defaults or are not strictly required.
+            print(
+                f"Warning: env_file '{env_file}' not found — skipping .env copy into workspace",
+                file=sys.stderr,
+            )
+
+    # Detect the default branch from the cloned repo (e.g. "main" or "master")
+    try:
+        raw = await _run(["git", "symbolic-ref", "refs/remotes/origin/HEAD"], cwd=ws)
+        # Output is e.g. "refs/remotes/origin/main\n"
+        default_branch = raw.strip().split("/")[-1] or "main"
+    except RuntimeError:
+        default_branch = "main"
+
+    # Detect the repo's own container config for validation
+    repo_cfg = detect_repo_container(ws, ticket_id)
+
+    # Spawn the worker container with the workspace and opencode auth mounted,
+    # and install git credentials inside it.
+    container_id = await _start_worker_container(ticket_id, ws, repo_url, ado_pat)
+
+    # Create and check out the agent branch inside the container
+    branch_name = f"agent/{ticket_id[:8]}"
+    await run_git(container_id, ["checkout", "-b", branch_name])
+
+    return WorkspaceSetup(
+        branch_name=branch_name,
+        workspace=ws,
+        container_id=container_id,
+        default_branch=default_branch,
+        repo_cfg=repo_cfg,
+    )
+
+
+async def run_opencode(
+    container_id: str,
+    prompt: str,
+    model: str,
+    session_id: str | None = None,
+) -> tuple[str, str]:
+    """
+    Run `opencode run --format json --model <model> [--session <id> --continue] <prompt>`
+    inside the worker container.
+
+    Returns (text_output, session_id).
+    """
+    cmd = [
+        "docker",
+        "exec",
+        container_id,
+        "opencode",
+        "run",
+        "--format",
+        "json",
+        "--model",
+        model,
+    ]
+    if session_id:
+        cmd += ["--session", session_id, "--continue"]
+    cmd.append(prompt)
+
+    raw = await _run(cmd, check=False)
+
+    extracted_session_id: str = session_id or ""
+    text_parts: list[str] = []
+
+    for line in raw.splitlines():
+        line = line.strip()
+        if not line:
+            continue
+        try:
+            event = _json.loads(line)
+        except _json.JSONDecodeError:
+            continue
+
+        if not extracted_session_id:
+            extracted_session_id = event.get("sessionID", "")
+
+        if event.get("type") == "text":
+            part = event.get("part", {})
+            text_parts.append(part.get("text", ""))
+
+    return "".join(text_parts), extracted_session_id
+
+
+async def run_git(container_id: str, args: list[str]) -> str:
+    """Run a git command inside the worker container at /workspace."""
+    return await _run(
+        ["docker", "exec", container_id, "git", "-C", CONTAINER_WORKSPACE] + args
+    )
+
+
+async def commit_if_changed(container_id: str, message: str) -> bool:
+    """
+    Stage all changes and commit if there is anything to commit.
+
+    Returns True if a commit was made, False if the working tree was clean.
+    """
+    await run_git(container_id, ["add", "-A"])
+    status = await run_git(container_id, ["status", "--porcelain"])
+    if not status.strip():
+        return False
+    await run_git(container_id, ["commit", "-m", message])
+    return True
+
+
+async def push_branch(container_id: str, branch: str) -> None:
+    """Push the agent branch to origin from inside the container."""
+    await run_git(container_id, ["push", "--set-upstream", "origin", branch])
+
+
+def read_pr_template(ticket_id: str) -> str | None:
+    """
+    Look for a PR template in the cloned workspace on the host.
+
+    Checks ADO-standard locations in order:
+      1. .azuredevops/pull_request_template.md
+      2. docs/pull_request_template.md
+      3. pull_request_template.md
+
+    Returns the template text, or None if no template is found.
+    """
+    ws = workspace_path(ticket_id)
+    candidate_paths = [
+        ws / ".azuredevops" / "pull_request_template.md",
+        ws / "docs" / "pull_request_template.md",
+        ws / "pull_request_template.md",
+    ]
+    for path in candidate_paths:
+        if path.is_file():
+            return path.read_text(encoding="utf-8")
+    return None
+
+
+async def recover_container(
+    ticket_id: str,
+    container_id: str | None,
+    repo_url: str,
+    ado_pat: str,
+) -> tuple[str, bool]:
+    """Re-attach to a running container or spawn a fresh one for an existing workspace.
+
+    Three cases:
+    1. *container_id* is set and the container is still running → return it unchanged.
+    2. The workspace dir exists on disk → ``docker run`` a new container with the
+       same bind-mount.  The agent branch is already checked out; no re-clone or
+       re-checkout needed.  Git credentials are restored inside the fresh container.
+    3. Neither → raise RuntimeError (workspace lost, must start a fresh ticket).
+
+    Returns ``(container_id, fresh)`` where *fresh* is True only when a new
+    container was spawned (so the caller knows to clear ``opencode_session_id``).
+    """
+    _check_tool("docker")
+    await _check_worker_image()
+
+    # Case 1: existing container still alive?
+    if container_id:
+        try:
+            out = await _run(
+                ["docker", "inspect", "--format", "{{.State.Running}}", container_id],
+                check=True,
+            )
+            if out.strip() == "true":
+                return container_id, False
+        except RuntimeError:
+            pass  # container gone — fall through to case 2
+
+    # Case 2: workspace on disk — spin up a fresh container
+    ws = workspace_path(ticket_id)
+    if not ws.exists():
+        raise RuntimeError(
+            f"Workspace for ticket {ticket_id[:8]} no longer exists on disk. "
+            "The ticket cannot be resumed — start a fresh run instead."
+        )
+
+    # Remove any dead container with the same name so docker run doesn't conflict.
+    await _run(
+        ["docker", "rm", "--force", f"devvy-worker-{ticket_id[:8]}"], check=False
+    )
+
+    new_container_id = await _start_worker_container(ticket_id, ws, repo_url, ado_pat)
+    return new_container_id, True
+
+
+async def cleanup_workspace(ticket_id: str, container_id: str | None) -> None:
+    """Stop and remove the worker container, then delete the workspace directory."""
+    if container_id:
+        # Stop gracefully, then force-remove
+        await _run(["docker", "stop", container_id], check=False)
+        await _run(["docker", "rm", "--force", container_id], check=False)
+
+    ws = workspace_path(ticket_id)
+    if ws.exists():
+        shutil.rmtree(ws, ignore_errors=True)

cli/main.py

@@ -0,0 +1,22 @@
+"""coding-agent CLI — entry point."""
+
+import typer
+
+from cli.commands import init, logs, ps, resume, run, status
+
+app = typer.Typer(
+    name="devvy",
+    help="Autonomous coding agent CLI",
+    no_args_is_help=True,
+)
+
+app.add_typer(init.app, name="init")
+app.command("run")(run.run)
+app.command("resume")(resume.resume)
+app.command("status")(status.status)
+app.command("logs")(logs.logs)
+app.command("ps")(ps.ps)
+
+
+if __name__ == "__main__":
+    app()