devvy 0.1.0__py3-none-any.whl

cli/__init__.py

@@ -0,0 +1 @@
+"""CLI package."""

cli/__main__.py

@@ -0,0 +1,9 @@
+"""Allow ``python -m cli`` to invoke the devvy CLI.
+
+This is the fallback entry-point used by ``devvy run --background`` when
+the installed ``devvy`` script cannot be found on PATH.
+"""
+
+from cli.main import app
+
+app()

cli/ado_client.py

@@ -0,0 +1,212 @@
+"""Azure DevOps REST API helpers for the CLI orchestrator.
+
+All functions are module-level and stateless — they receive credentials
+explicitly so they can be used independently of the Orchestrator class and
+tested in isolation.
+
+Auth: ADO uses HTTP Basic with an empty username and a PAT as the password,
+Base64-encoded as ``:<pat>``.
+"""
+
+from __future__ import annotations
+
+import base64
+from urllib.parse import urlparse
+
+import httpx
+
+
+_ADO_API_VERSION = "7.1"
+
+
+def ado_headers(pat: str) -> dict[str, str]:
+    token = base64.b64encode(f":{pat}".encode()).decode()
+    return {"Authorization": f"Basic {token}", "Content-Type": "application/json"}
+
+
+def extract_repo_name(repo_url: str) -> str:
+    return urlparse(repo_url).path.rstrip("/").split("/")[-1]
+
+
+def api_base(org_url: str, project: str, repo_name: str) -> str:
+    return f"{org_url.rstrip('/')}/{project}/_apis/git/repositories/{repo_name}"
+
+
+async def get_existing_pr(
+    repo_url: str,
+    branch: str,
+    ado_org_url: str,
+    ado_project: str,
+    ado_pat: str,
+) -> tuple[int, str] | None:
+    """Look up an open PR for *branch* in ADO.
+
+    Returns (pr_number, pr_url) if one is found, otherwise None.
+    """
+    repo_name = extract_repo_name(repo_url)
+    url = (
+        f"{api_base(ado_org_url, ado_project, repo_name)}/pullrequests"
+        f"?sourceRefName=refs/heads/{branch}&status=active&api-version={_ADO_API_VERSION}"
+    )
+    async with httpx.AsyncClient(timeout=30) as client:
+        resp = await client.get(url, headers=ado_headers(ado_pat))
+        resp.raise_for_status()
+        data = resp.json()
+    prs = data.get("value", [])
+    if not prs:
+        return None
+    pr = prs[0]
+    pr_number = pr["pullRequestId"]
+    pr_url = f"{ado_org_url.rstrip('/')}/{ado_project}/_git/{repo_name}/pullrequest/{pr_number}"
+    return pr_number, pr_url
+
+
+async def create_pr(
+    repo_url: str,
+    branch: str,
+    title: str,
+    description: str,
+    ado_org_url: str,
+    ado_project: str,
+    ado_pat: str,
+    target_branch: str = "main",
+) -> tuple[int, str]:
+    """Create a PR and return (pr_number, pr_url).
+
+    If ADO returns 400/409 (e.g. a PR already exists for this branch), looks
+    up and returns the existing PR instead of raising.
+    """
+    repo_name = extract_repo_name(repo_url)
+    url = f"{api_base(ado_org_url, ado_project, repo_name)}/pullrequests?api-version={_ADO_API_VERSION}"
+    payload = {
+        "title": title,
+        "description": description,
+        "sourceRefName": f"refs/heads/{branch}",
+        "targetRefName": f"refs/heads/{target_branch}",
+    }
+    async with httpx.AsyncClient(timeout=30) as client:
+        resp = await client.post(url, json=payload, headers=ado_headers(ado_pat))
+        if resp.status_code in (400, 409):
+            # PR likely already exists for this branch — look it up.
+            existing = await get_existing_pr(
+                repo_url, branch, ado_org_url, ado_project, ado_pat
+            )
+            if existing:
+                return existing
+            # No existing PR found — surface the original error.
+            resp.raise_for_status()
+        else:
+            resp.raise_for_status()
+        data = resp.json()
+    pr_number = data["pullRequestId"]
+    pr_url = f"{ado_org_url.rstrip('/')}/{ado_project}/_git/{repo_name}/pullrequest/{pr_number}"
+    return pr_number, pr_url
+
+
+async def get_pr_status(
+    repo_url: str,
+    pr_number: int,
+    ado_org_url: str,
+    ado_project: str,
+    ado_pat: str,
+) -> str:
+    repo_name = extract_repo_name(repo_url)
+    url = (
+        f"{api_base(ado_org_url, ado_project, repo_name)}"
+        f"/pullrequests/{pr_number}?api-version={_ADO_API_VERSION}"
+    )
+    async with httpx.AsyncClient(timeout=30) as client:
+        resp = await client.get(url, headers=ado_headers(ado_pat))
+        resp.raise_for_status()
+        return resp.json().get("status", "unknown")
+
+
+async def get_pr_comments(
+    repo_url: str,
+    pr_number: int,
+    ado_org_url: str,
+    ado_project: str,
+    ado_pat: str,
+) -> list[dict]:
+    """Return one dict per non-deleted, non-system thread.
+
+    Each dict has the shape::
+
+        {
+            "thread_id": "64",
+            "file_path": "src/app/foo.py",  # or None for general comments
+            "comments": [
+                {"comment_id": 1, "author": "Alice", "body": "..."},
+                {"comment_id": 2, "author": "devvy", "body": "..."},
+            ],
+        }
+
+    Comments within each thread are ordered by ``id`` ascending so callers
+    can treat the last entry as the most recent.
+    """
+    repo_name = extract_repo_name(repo_url)
+    url = (
+        f"{api_base(ado_org_url, ado_project, repo_name)}"
+        f"/pullrequests/{pr_number}/threads?api-version={_ADO_API_VERSION}"
+    )
+    async with httpx.AsyncClient(timeout=30) as client:
+        resp = await client.get(url, headers=ado_headers(ado_pat))
+        resp.raise_for_status()
+        data = resp.json()
+
+    threads: list[dict] = []
+    for thread in data.get("value", []):
+        if thread.get("isDeleted"):
+            continue
+        thread_id = str(thread.get("id", ""))
+        file_path = (thread.get("threadContext") or {}).get("filePath")
+        comments = []
+        for comment in sorted(thread.get("comments", []), key=lambda c: c.get("id", 0)):
+            if comment.get("isDeleted") or comment.get("commentType") == "system":
+                continue
+            comments.append(
+                {
+                    "comment_id": comment.get("id", 0),
+                    "author": comment.get("author", {}).get("displayName", "unknown"),
+                    "body": comment.get("content", ""),
+                }
+            )
+        if not comments:
+            continue
+        threads.append(
+            {
+                "thread_id": thread_id,
+                "file_path": file_path,
+                "comments": comments,
+            }
+        )
+    return threads
+
+
+async def post_thread_reply(
+    repo_url: str,
+    pr_number: int,
+    thread_id: str,
+    message: str,
+    ado_org_url: str,
+    ado_project: str,
+    ado_pat: str,
+) -> int:
+    """Post a reply comment to an existing PR thread.
+
+    parentCommentId=1 attaches the reply to the first (root) comment in the
+    thread, which is what ADO expects for a standard reply.
+
+    Returns the ``id`` of the newly created comment so callers can advance
+    the high-water mark for that thread.
+    """
+    repo_name = extract_repo_name(repo_url)
+    url = (
+        f"{api_base(ado_org_url, ado_project, repo_name)}"
+        f"/pullrequests/{pr_number}/threads/{thread_id}/comments?api-version={_ADO_API_VERSION}"
+    )
+    payload = {"content": message, "parentCommentId": 1}
+    async with httpx.AsyncClient(timeout=30) as client:
+        resp = await client.post(url, json=payload, headers=ado_headers(ado_pat))
+        resp.raise_for_status()
+        return int(resp.json().get("id", 0))

cli/commands/__init__.py

@@ -0,0 +1 @@
+"""CLI commands package."""

cli/commands/init.py

@@ -0,0 +1,107 @@
+"""coding-agent init — configure the local CLI client."""
+
+from __future__ import annotations
+
+import tomllib
+
+import typer
+
+from cli.config import CONFIG_PATH, DEFAULT_MODEL
+from cli.ui import console, pick_model
+
+# Ordered list of models shown in the picker (provider/model format).
+# Kept in sync with `opencode models` output for the github-copilot provider.
+_MODELS = [
+    "github-copilot/claude-sonnet-4.6",
+    "github-copilot/claude-sonnet-4.5",
+    "github-copilot/claude-opus-4.6",
+    "github-copilot/claude-opus-4.5",
+    "github-copilot/claude-haiku-4.5",
+    "github-copilot/gpt-5",
+    "github-copilot/gpt-5.1",
+    "github-copilot/gpt-5.2",
+    "github-copilot/gpt-4.1",
+    "github-copilot/gpt-4o",
+    "github-copilot/gpt-5-mini",
+    "github-copilot/gpt-5.1-codex",
+    "github-copilot/gpt-5.1-codex-mini",
+    "github-copilot/gemini-2.5-pro",
+    "github-copilot/gemini-3-flash-preview",
+    "github-copilot/gemini-3-pro-preview",
+]
+
+
+app = typer.Typer(help="Initialise the coding-agent CLI configuration.")
+
+
+@app.callback(invoke_without_command=True)
+def init(ctx: typer.Context) -> None:
+    """
+    Interactively configure the coding-agent CLI.
+
+    Writes all credentials and settings to ~/.coding-agent.toml.
+    """
+    console.print("\n[bold]Initialising coding-agent configuration…[/bold]\n")
+
+    # Load existing config so we can show current values as defaults
+    existing: dict = {}
+    if CONFIG_PATH.exists():
+        try:
+            with CONFIG_PATH.open("rb") as f:
+                existing = tomllib.load(f).get("coding_agent", {})
+        except Exception:
+            pass
+
+    current_model = existing.get("opencode_model", DEFAULT_MODEL)
+    default_model = current_model if current_model in _MODELS else DEFAULT_MODEL
+
+    opencode_model = pick_model(_MODELS, default_model)
+    console.print(
+        f"\n  [bold green]✓[/bold green]  Selected: [bold]{opencode_model}[/bold]\n"
+    )
+
+    ado_org_url = typer.prompt(
+        "Azure DevOps org URL (e.g. https://dev.azure.com/myorg)",
+        default=existing.get("ado_org_url", ""),
+    )
+    ado_project = typer.prompt(
+        "Azure DevOps project name",
+        default=existing.get("ado_project", ""),
+    )
+    ado_pat = typer.prompt(
+        "Azure DevOps personal access token",
+        hide_input=True,
+    )
+    repo_url = typer.prompt(
+        "Repository URL (e.g. https://dev.azure.com/myorg/myproject/_git/myrepo)",
+        default=existing.get("repo_url", ""),
+    )
+    env_file = typer.prompt(
+        "Path to repo .env file to inject into the workspace (leave blank to skip)",
+        default=existing.get("env_file", ""),
+    )
+
+    config = {
+        "opencode_model": opencode_model,
+        "ado_org_url": ado_org_url,
+        "ado_project": ado_project,
+        "ado_pat": ado_pat,
+        "repo_url": repo_url,
+        "env_file": env_file,
+    }
+
+    # Write as TOML manually (tomllib is read-only; avoid extra dep on tomli-w)
+    lines = ["[coding_agent]\n"]
+    for key, value in config.items():
+        escaped = value.replace("\\", "\\\\").replace('"', '\\"')
+        lines.append(f'{key} = "{escaped}"\n')
+
+    CONFIG_PATH.write_text("".join(lines))
+
+    # Lock down permissions — config contains secrets
+    CONFIG_PATH.chmod(0o600)
+
+    console.print(
+        f"\n[bold green]✓[/bold green]  Configuration written to [bold]{CONFIG_PATH}[/bold]"
+    )
+    console.print("[dim]  Permissions set to 600 (owner read/write only).[/dim]")

cli/commands/logs.py

@@ -0,0 +1,36 @@
+"""coding-agent logs <id> — print orchestrator logs for a ticket from local DB."""
+
+from __future__ import annotations
+
+import asyncio
+
+import typer
+from sqlalchemy import select
+
+import cli.models  # noqa: F401 — ensure tables are registered on Base.metadata
+from cli.db import SessionManager, init_db
+from cli.models import GraphContext, Ticket
+from cli.ui import err_console, render_logs
+
+
+def logs(ticket_id: str = typer.Argument(..., help="Ticket ID")) -> None:
+    """Print the agent logs for a ticket."""
+    asyncio.run(_logs_async(ticket_id))
+
+
+async def _logs_async(ticket_id: str) -> None:
+    await init_db()
+
+    async with SessionManager.session() as session:
+        ticket = await session.get(Ticket, ticket_id)
+        if ticket is None:
+            err_console.print(f"[red]Ticket {ticket_id!r} not found.[/red]")
+            raise typer.Exit(1)
+
+        result = await session.execute(
+            select(GraphContext).where(GraphContext.ticket_id == ticket_id)
+        )
+        ctx = result.scalar_one_or_none()
+
+    log_text = (ctx.logs if ctx else "").strip()
+    render_logs(log_text)

cli/commands/ps.py

@@ -0,0 +1,72 @@
+"""devvy ps — list all in-progress (and recently crashed) tickets."""
+
+from __future__ import annotations
+
+import asyncio
+
+from rich.table import Table
+from sqlalchemy import select
+
+import cli.models  # noqa: F401 — ensure tables are registered on Base.metadata
+from cli.db import SessionManager, init_db
+from cli.fsm import TicketState
+from cli.models import GraphContext, Ticket
+from cli.ui import _pid_alive, console, state_text
+
+
+def ps() -> None:
+    """List all tickets that are not yet in a terminal state."""
+    asyncio.run(_ps_async())
+
+
+async def _ps_async() -> None:
+    await init_db()
+
+    terminal_values = {s.value for s in TicketState if s.is_terminal}
+
+    async with SessionManager.session() as session:
+        result = await session.execute(
+            select(Ticket, GraphContext)
+            .join(GraphContext, GraphContext.ticket_id == Ticket.id)
+            .where(Ticket.state.notin_(terminal_values))
+            .order_by(Ticket.created_at)
+        )
+        rows = result.all()
+
+    if not rows:
+        console.print("[dim]No active tickets.[/dim]")
+        return
+
+    table = Table(show_header=True, header_style="bold dim", box=None, padding=(0, 2))
+    table.add_column("ID", style="dim", no_wrap=True)
+    table.add_column("TITLE")
+    table.add_column("STATE")
+    table.add_column("PROCESS")
+    table.add_column("BRANCH", style="dim")
+
+    for ticket, ctx in rows:
+        pid = ctx.worker_pid
+
+        if pid is not None:
+            if _pid_alive(pid):
+                process_label = (
+                    f"[bold green]Running[/bold green]  [dim](pid {pid})[/dim]"
+                )
+            else:
+                process_label = f"[bold red]Crashed[/bold red]   [dim](pid {pid})[/dim]"
+        else:
+            process_label = "[dim yellow]Idle / resumable[/dim yellow]"
+
+        table.add_row(
+            ticket.id[:8],
+            ticket.title,
+            state_text(ticket.state),
+            process_label,
+            ticket.branch_name or "—",
+        )
+
+    console.print(table)
+    console.print(
+        f"\n[dim]{len(rows)} active ticket{'s' if len(rows) != 1 else ''}. "
+        "Use [bold]devvy logs <id>[/bold] or [bold]devvy status <id>[/bold] for details.[/dim]"
+    )

cli/commands/resume.py

@@ -0,0 +1,105 @@
+"""devvy resume <ticket-id> — re-attach to an existing ticket and continue running."""
+
+from __future__ import annotations
+
+import asyncio
+
+import typer
+from sqlalchemy import select
+
+import cli.models  # noqa: F401 — ensure tables are registered on Base.metadata
+from cli.config import Config, ConfigNotFoundError, load_config
+from cli.db import SessionManager, init_db
+from cli.fsm import TicketState
+from cli.models import GraphContext, Ticket
+from cli.orchestrator import Orchestrator
+from cli import local_runner
+from cli.ui import ProgressTracker, console, err_console, print_resume_banner
+
+
+def resume(
+    ticket_id: str = typer.Argument(..., help="Ticket ID to resume"),
+) -> None:
+    """Resume a previously started ticket from its last persisted state."""
+    try:
+        config = load_config()
+    except ConfigNotFoundError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1)
+    asyncio.run(_resume_async(ticket_id, config))
+
+
+async def _resume_async(ticket_id: str, config: Config) -> None:
+    await init_db()
+
+    async with SessionManager.session() as session:
+        ticket = await session.get(Ticket, ticket_id)
+        if ticket is None:
+            err_console.print(f"[red]Ticket {ticket_id!r} not found.[/red]")
+            raise typer.Exit(1)
+
+        result = await session.execute(
+            select(GraphContext).where(GraphContext.ticket_id == ticket_id)
+        )
+        ctx = result.scalar_one_or_none()
+        if ctx is None:
+            err_console.print(f"[red]No context found for ticket {ticket_id!r}.[/red]")
+            raise typer.Exit(1)
+
+        state = TicketState(ctx.current_state)
+        if state.is_terminal:
+            err_console.print(
+                f"[yellow]Ticket {ticket_id[:8]} is already in terminal state "
+                f"{state.value} — nothing to resume.[/yellow]"
+            )
+            raise typer.Exit(1)
+
+    print_resume_banner(
+        ticket_id=ticket_id,
+        title=ticket.title,
+        state=ctx.current_state,
+        branch=ticket.branch_name,
+        pr_number=ctx.pr_number,
+    )
+
+    # Re-attach to the running container or spawn a fresh one over the
+    # existing workspace.  If the workspace is gone, recover_container()
+    # raises a RuntimeError with a clear message.
+    try:
+        new_container_id, fresh = await local_runner.recover_container(
+            ticket_id=ticket_id,
+            container_id=ctx.container_id,
+            repo_url=ticket.repo_url,
+            ado_pat=config.ado_pat,
+        )
+    except RuntimeError as exc:
+        err_console.print(f"[red]Cannot resume: {exc}[/red]")
+        raise typer.Exit(1)
+
+    if fresh:
+        console.print(
+            f"  [dim]Spawned fresh container [bold]{new_container_id[:12]}[/bold] "
+            f"(old container was gone).[/dim]"
+        )
+        ctx.container_id = new_container_id
+        # Stale session ID is useless without the old container's opencode state.
+        ctx.opencode_session_id = None
+        async with SessionManager.session() as session:
+            session.add(ctx)
+            session.add(ticket)
+    else:
+        console.print(
+            f"  [dim]Re-attached to existing container [bold]{new_container_id[:12]}[/bold].[/dim]"
+        )
+
+    console.print(
+        f"  [dim]Running from state: [bold]{ctx.current_state}[/bold][/dim]\n"
+    )
+
+    tracker = ProgressTracker()
+    orchestrator = Orchestrator(ticket, ctx, config)
+    await orchestrator.run(status_callback=tracker.on_state_change)
+    tracker.finish(ticket)
+
+    if ticket.state != TicketState.MERGED.value:
+        raise typer.Exit(1)

cli/commands/run.py

@@ -0,0 +1,135 @@
+"""coding-agent run — submit a coding task and run it locally."""
+
+from __future__ import annotations
+
+import asyncio
+import shutil
+import subprocess
+import sys
+import uuid
+from datetime import UTC, datetime
+
+import typer
+
+from cli.config import Config, ConfigNotFoundError, load_config
+from cli.db import SessionManager, init_db
+from cli.fsm import TicketState
+from cli.models import GraphContext, Ticket
+from cli.orchestrator import Orchestrator
+from cli.ui import ProgressTracker, console, print_run_banner
+
+
+def run(
+    title: str = typer.Option(None, "--title", "-t", help="Ticket title"),
+    description: str = typer.Option(
+        None, "--description", "-D", help="Ticket description"
+    ),
+    background: bool = typer.Option(
+        False,
+        "--background",
+        "-d",
+        is_flag=True,
+        help="Detach and run in the background; returns the ticket ID immediately.",
+    ),
+) -> None:
+    """Run a coding task locally — no server required."""
+    try:
+        config = load_config()
+    except ConfigNotFoundError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1)
+
+    if not title:
+        title = typer.prompt("Ticket title")
+    if not description:
+        description = typer.prompt("Ticket description")
+
+    if background:
+        _run_in_background(title, description)
+        return
+
+    asyncio.run(_run_async(title, description, config))
+
+
+def _run_in_background(title: str, description: str) -> None:
+    """Fork a detached child process that runs the orchestrator and return immediately.
+
+    Re-executes the same ``devvy run`` command *without* ``--background`` so the
+    child goes through the normal foreground code path.  ``start_new_session=True``
+    detaches the child from the controlling terminal on Linux and macOS, meaning it
+    keeps running after the parent (and its terminal) exit.
+    """
+    cmd = [
+        sys.executable,
+        "-m",
+        "cli",  # invokes src/cli/__main__.py
+        "run",
+        "--title",
+        title,
+        "--description",
+        description,
+    ]
+
+    # Prefer the installed entry-point script when available — it's more robust
+    # than relying on -m cli.main_runner being importable.
+    devvy_exe = shutil.which("devvy")
+    if devvy_exe:
+        cmd = [devvy_exe, "run", "--title", title, "--description", description]
+
+    proc = subprocess.Popen(
+        cmd,
+        stdin=subprocess.DEVNULL,
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
+        start_new_session=True,  # detach from controlling terminal
+        close_fds=True,
+    )
+
+    console.print(
+        f"[bold green]Started background ticket[/bold green] (pid [dim]{proc.pid}[/dim])\n"
+        f"  [dim]title:[/dim]  {title}\n\n"
+        f"  Check progress:\n"
+        f"    [bold]devvy ps[/bold]\n"
+        f"    [bold]devvy status <ticket-id>[/bold]\n"
+        f"    [bold]devvy logs <ticket-id>[/bold]"
+    )
+
+
+async def _run_async(title: str, description: str, config: Config) -> None:
+    await init_db()
+
+    now = datetime.now(UTC)
+    ticket_id = str(uuid.uuid4())
+
+    ticket = Ticket(
+        id=ticket_id,
+        title=title,
+        description=description,
+        repo_url=config.repo_url,
+        state=TicketState.RECEIVED.value,
+        created_at=now,
+        updated_at=now,
+    )
+    context = GraphContext(
+        id=str(uuid.uuid4()),
+        ticket_id=ticket_id,
+        current_state=TicketState.RECEIVED.value,
+        retry_count=0,
+        logs="",
+        updated_at=now,
+    )
+
+    async with SessionManager.session() as session:
+        session.add(ticket)
+        session.add(context)
+
+    print_run_banner(ticket_id, title, config.repo_url)
+    console.print("[dim]Starting agent…[/dim]\n")
+
+    tracker = ProgressTracker()
+    orchestrator = Orchestrator(ticket, context, config)
+    await orchestrator.run(status_callback=tracker.on_state_change)
+    tracker.finish(ticket)
+
+    if ticket.state != TicketState.MERGED.value:
+        raise typer.Exit(1)