codex-autorunner 0.1.2__py3-none-any.whl → 1.1.0__py3-none-any.whl

codex_autorunner/core/flows/ux_helpers.py

@@ -0,0 +1,257 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Callable, Optional, Protocol
+
+from ...tickets.files import list_ticket_paths
+from .models import FlowEventType, FlowRunRecord
+from .store import FlowStore
+from .worker_process import (
+    check_worker_health,
+    clear_worker_metadata,
+    spawn_flow_worker,
+)
+
+
+@dataclass(frozen=True)
+class BootstrapCheckResult:
+    status: str
+    github_available: Optional[bool] = None
+    repo_slug: Optional[str] = None
+
+
+@dataclass(frozen=True)
+class IssueSeedResult:
+    content: str
+    issue_number: int
+    repo_slug: str
+
+
+class GitHubServiceProtocol(Protocol):
+    def gh_available(self) -> bool: ...
+
+    def gh_authenticated(self) -> bool: ...
+
+    def repo_info(self) -> Any: ...
+
+    def validate_issue_same_repo(self, issue_ref: str) -> int: ...
+
+    def issue_view(self, number: int) -> dict: ...
+
+
+def issue_md_path(repo_root: Path) -> Path:
+    return repo_root.resolve() / ".codex-autorunner" / "ISSUE.md"
+
+
+def issue_md_has_content(repo_root: Path) -> bool:
+    issue_path = issue_md_path(repo_root)
+    if not issue_path.exists():
+        return False
+    try:
+        return bool(issue_path.read_text(encoding="utf-8").strip())
+    except OSError:
+        return False
+
+
+def _ticket_dir(repo_root: Path) -> Path:
+    return repo_root.resolve() / ".codex-autorunner" / "tickets"
+
+
+def bootstrap_check(
+    repo_root: Path,
+    github_service_factory: Optional[Callable[[Path], GitHubServiceProtocol]] = None,
+) -> BootstrapCheckResult:
+    if list_ticket_paths(_ticket_dir(repo_root)):
+        return BootstrapCheckResult(status="ready")
+
+    if issue_md_has_content(repo_root):
+        return BootstrapCheckResult(status="ready")
+
+    gh_available = False
+    repo_slug: Optional[str] = None
+    if github_service_factory is not None:
+        try:
+            gh = github_service_factory(repo_root)
+            gh_available = gh.gh_available() and gh.gh_authenticated()
+            if gh_available:
+                repo_info = gh.repo_info()
+                repo_slug = getattr(repo_info, "name_with_owner", None)
+        except Exception:
+            gh_available = False
+            repo_slug = None
+
+    return BootstrapCheckResult(
+        status="needs_issue", github_available=gh_available, repo_slug=repo_slug
+    )
+
+
+def format_issue_as_markdown(issue: dict, repo_slug: Optional[str] = None) -> str:
+    number = issue.get("number")
+    title = issue.get("title") or ""
+    url = issue.get("url") or ""
+    state = issue.get("state") or ""
+    author = issue.get("author") or {}
+    author_name = (
+        author.get("login") if isinstance(author, dict) else str(author or "unknown")
+    )
+    labels = issue.get("labels")
+    label_names: list[str] = []
+    if isinstance(labels, list):
+        for label in labels:
+            if isinstance(label, dict):
+                name = label.get("name")
+            else:
+                name = label
+            if name:
+                label_names.append(str(name))
+    comments = issue.get("comments")
+    comment_count = None
+    if isinstance(comments, dict):
+        total = comments.get("totalCount")
+        if isinstance(total, int):
+            comment_count = total
+
+    body = issue.get("body") or "(no description)"
+    lines = [
+        f"# Issue #{number}: {title}".strip(),
+        "",
+        f"**Repo:** {repo_slug or 'unknown'}",
+        f"**URL:** {url}",
+        f"**State:** {state}",
+        f"**Author:** {author_name}",
+    ]
+    if label_names:
+        lines.append(f"**Labels:** {', '.join(label_names)}")
+    if comment_count is not None:
+        lines.append(f"**Comments:** {comment_count}")
+    lines.extend(["", "## Description", "", str(body).strip(), ""])
+    return "\n".join(lines)
+
+
+def seed_issue_from_github(
+    repo_root: Path,
+    issue_ref: str,
+    github_service_factory: Optional[Callable[[Path], GitHubServiceProtocol]] = None,
+) -> IssueSeedResult:
+    if github_service_factory is None:
+        raise RuntimeError("GitHub service unavailable.")
+    gh = github_service_factory(repo_root)
+    if not (gh.gh_available() and gh.gh_authenticated()):
+        raise RuntimeError("GitHub CLI is not available or not authenticated.")
+    number = gh.validate_issue_same_repo(issue_ref)
+    issue = gh.issue_view(number=number)
+    repo_info = gh.repo_info()
+    content = format_issue_as_markdown(issue, repo_info.name_with_owner)
+    return IssueSeedResult(
+        content=content, issue_number=number, repo_slug=repo_info.name_with_owner
+    )
+
+
+def seed_issue_from_text(plan_text: str) -> str:
+    return f"# Issue\n\n{plan_text.strip()}\n"
+
+
+def _derive_effective_current_ticket(
+    record: FlowRunRecord, store: Optional[FlowStore]
+) -> Optional[str]:
+    if store is None:
+        return None
+    try:
+        if (
+            getattr(record, "flow_type", None) != "ticket_flow"
+            or not record.status.is_active()
+        ):
+            return None
+        last_started = store.get_last_event_seq_by_types(
+            record.id, [FlowEventType.STEP_STARTED]
+        )
+        last_finished = store.get_last_event_seq_by_types(
+            record.id, [FlowEventType.STEP_COMPLETED, FlowEventType.STEP_FAILED]
+        )
+        in_progress = bool(
+            last_started is not None
+            and (last_finished is None or last_started > last_finished)
+        )
+        if not in_progress:
+            return None
+        return store.get_latest_step_progress_current_ticket(
+            record.id, after_seq=last_finished
+        )
+    except Exception:
+        return None
+
+
+def build_flow_status_snapshot(
+    repo_root: Path, record: FlowRunRecord, store: Optional[FlowStore]
+) -> dict:
+    last_event_seq = None
+    last_event_at = None
+    if store:
+        try:
+            last_event_seq, last_event_at = store.get_last_event_meta(record.id)
+        except Exception:
+            last_event_seq, last_event_at = None, None
+    health = check_worker_health(repo_root, record.id)
+
+    state = record.state or {}
+    current_ticket = None
+    if isinstance(state, dict):
+        ticket_engine = state.get("ticket_engine")
+        if isinstance(ticket_engine, dict):
+            current_ticket = ticket_engine.get("current_ticket")
+            if not (isinstance(current_ticket, str) and current_ticket.strip()):
+                current_ticket = None
+    effective_ticket = current_ticket
+    if not effective_ticket:
+        effective_ticket = _derive_effective_current_ticket(record, store)
+
+    updated_state: Optional[dict] = None
+    if effective_ticket and not current_ticket and isinstance(state, dict):
+        ticket_engine = state.get("ticket_engine")
+        ticket_engine = dict(ticket_engine) if isinstance(ticket_engine, dict) else {}
+        ticket_engine["current_ticket"] = effective_ticket
+        updated_state = dict(state)
+        updated_state["ticket_engine"] = ticket_engine
+
+    return {
+        "last_event_seq": last_event_seq,
+        "last_event_at": last_event_at,
+        "worker_health": health,
+        "effective_current_ticket": effective_ticket,
+        "state": updated_state,
+    }
+
+
+def ensure_worker(repo_root: Path, run_id: str) -> dict:
+    health = check_worker_health(repo_root, run_id)
+    if health.status in {"dead", "mismatch", "invalid"}:
+        try:
+            clear_worker_metadata(health.artifact_path.parent)
+        except Exception:
+            pass
+    if health.is_alive:
+        return {"status": "reused", "health": health}
+
+    proc, stdout_handle, stderr_handle = spawn_flow_worker(repo_root, run_id)
+    return {
+        "status": "spawned",
+        "health": health,
+        "proc": proc,
+        "stdout": stdout_handle,
+        "stderr": stderr_handle,
+    }
+
+
+__all__ = [
+    "BootstrapCheckResult",
+    "IssueSeedResult",
+    "bootstrap_check",
+    "build_flow_status_snapshot",
+    "ensure_worker",
+    "format_issue_as_markdown",
+    "issue_md_has_content",
+    "issue_md_path",
+    "seed_issue_from_github",
+    "seed_issue_from_text",
+]

codex_autorunner/core/flows/worker_process.py

@@ -0,0 +1,242 @@
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import sys
+import uuid
+from dataclasses import dataclass
+from pathlib import Path
+from typing import IO, Literal, Optional, Tuple
+
+_WORKER_METADATA_FILENAME = "worker.json"
+
+
+@dataclass
+class FlowWorkerHealth:
+    status: Literal["absent", "alive", "dead", "invalid", "mismatch"]
+    pid: Optional[int]
+    cmdline: list[str]
+    artifact_path: Path
+    message: Optional[str] = None
+
+    @property
+    def is_alive(self) -> bool:
+        return self.status == "alive"
+
+
+def _normalized_run_id(run_id: str) -> str:
+    return str(uuid.UUID(str(run_id)))
+
+
+def _worker_artifacts_dir(
+    repo_root: Path, run_id: str, artifacts_root: Optional[Path] = None
+) -> Path:
+    repo_root = repo_root.resolve()
+    base_artifacts = (
+        artifacts_root
+        if artifacts_root is not None
+        else repo_root / ".codex-autorunner" / "flows"
+    )
+    artifacts_dir = base_artifacts / _normalized_run_id(run_id)
+    artifacts_dir.mkdir(parents=True, exist_ok=True)
+    return artifacts_dir
+
+
+def _worker_metadata_path(artifacts_dir: Path) -> Path:
+    return artifacts_dir / _WORKER_METADATA_FILENAME
+
+
+def _build_worker_cmd(entrypoint: str, run_id: str) -> list[str]:
+    normalized_run_id = _normalized_run_id(run_id)
+    return [
+        sys.executable,
+        "-m",
+        entrypoint,
+        "flow",
+        "worker",
+        "--run-id",
+        normalized_run_id,
+    ]
+
+
+def _pid_is_running(pid: int) -> bool:
+    try:
+        os.kill(pid, 0)
+    except ProcessLookupError:
+        return False
+    except PermissionError:
+        # Process exists but we may not own it.
+        return True
+    except OSError:
+        return False
+    return True
+
+
+def _read_process_cmdline(pid: int) -> list[str] | None:
+    proc_path = Path(f"/proc/{pid}/cmdline")
+    if proc_path.exists():
+        try:
+            raw = proc_path.read_bytes()
+            return [part for part in raw.decode().split("\0") if part]
+        except Exception:
+            pass
+
+    try:
+        out = subprocess.check_output(
+            ["ps", "-p", str(pid), "-o", "command="],
+            stderr=subprocess.DEVNULL,
+        )
+        cmd = out.decode().strip()
+        if cmd:
+            return cmd.split()
+    except Exception:
+        return None
+    return None
+
+
+def _cmdline_matches(expected: list[str], actual: list[str]) -> bool:
+    if not expected or not actual:
+        return False
+    if len(actual) >= len(expected) and actual[-len(expected) :] == expected:
+        return True
+    expected_str = " ".join(expected)
+    actual_str = " ".join(actual)
+    return expected_str in actual_str
+
+
+def _write_worker_metadata(path: Path, pid: int, cmd: list[str]) -> None:
+    data = {
+        "pid": pid,
+        "cmd": cmd,
+        "cwd": os.getcwd(),
+    }
+    path.write_text(json.dumps(data, indent=2), encoding="utf-8")
+    # Also emit a plain PID file for quick inspection.
+    pid_path = path.with_suffix(".pid")
+    pid_path.write_text(str(pid), encoding="utf-8")
+
+
+def clear_worker_metadata(artifacts_dir: Path) -> None:
+    for name in (
+        _WORKER_METADATA_FILENAME,
+        f"{Path(_WORKER_METADATA_FILENAME).stem}.pid",
+    ):
+        try:
+            (artifacts_dir / name).unlink()
+        except FileNotFoundError:
+            pass
+        except Exception:
+            pass
+
+
+def check_worker_health(
+    repo_root: Path,
+    run_id: str,
+    *,
+    artifacts_root: Optional[Path] = None,
+    entrypoint: str = "codex_autorunner",
+) -> FlowWorkerHealth:
+    artifacts_dir = _worker_artifacts_dir(repo_root, run_id, artifacts_root)
+    metadata_path = _worker_metadata_path(artifacts_dir)
+
+    if not metadata_path.exists():
+        return FlowWorkerHealth(
+            status="absent",
+            pid=None,
+            cmdline=[],
+            artifact_path=metadata_path,
+            message="worker metadata missing",
+        )
+
+    try:
+        data = json.loads(metadata_path.read_text(encoding="utf-8"))
+        pid = int(data.get("pid")) if data.get("pid") is not None else None
+        cmd = data.get("cmd") or []
+    except Exception:
+        return FlowWorkerHealth(
+            status="invalid",
+            pid=None,
+            cmdline=[],
+            artifact_path=metadata_path,
+            message="worker metadata unreadable",
+        )
+
+    if not pid or pid <= 0:
+        return FlowWorkerHealth(
+            status="invalid",
+            pid=pid,
+            cmdline=cmd if isinstance(cmd, list) else [],
+            artifact_path=metadata_path,
+            message="missing or invalid PID",
+        )
+
+    if not _pid_is_running(pid):
+        return FlowWorkerHealth(
+            status="dead",
+            pid=pid,
+            cmdline=cmd if isinstance(cmd, list) else [],
+            artifact_path=metadata_path,
+            message="worker PID not running",
+        )
+
+    expected_cmd = _build_worker_cmd(entrypoint, run_id)
+    actual_cmd = _read_process_cmdline(pid)
+    if actual_cmd is None:
+        # Can't inspect cmdline; trust the PID check.
+        return FlowWorkerHealth(
+            status="alive",
+            pid=pid,
+            cmdline=cmd if isinstance(cmd, list) else [],
+            artifact_path=metadata_path,
+            message="worker running (cmdline unknown)",
+        )
+
+    if not _cmdline_matches(expected_cmd, actual_cmd):
+        return FlowWorkerHealth(
+            status="mismatch",
+            pid=pid,
+            cmdline=actual_cmd,
+            artifact_path=metadata_path,
+            message="worker PID command does not match expected",
+        )
+
+    return FlowWorkerHealth(
+        status="alive",
+        pid=pid,
+        cmdline=actual_cmd,
+        artifact_path=metadata_path,
+        message="worker running",
+    )
+
+
+def spawn_flow_worker(
+    repo_root: Path,
+    run_id: str,
+    *,
+    artifacts_root: Optional[Path] = None,
+    entrypoint: str = "codex_autorunner",
+) -> Tuple[subprocess.Popen, IO[bytes], IO[bytes]]:
+    """Spawn a detached flow worker with consistent artifacts/log layout."""
+
+    normalized_run_id = _normalized_run_id(run_id)
+    repo_root = repo_root.resolve()
+    artifacts_dir = _worker_artifacts_dir(repo_root, normalized_run_id, artifacts_root)
+
+    stdout_path = artifacts_dir / "worker.out.log"
+    stderr_path = artifacts_dir / "worker.err.log"
+
+    stdout_handle = stdout_path.open("ab")
+    stderr_handle = stderr_path.open("ab")
+
+    cmd = _build_worker_cmd(entrypoint, normalized_run_id)
+
+    proc = subprocess.Popen(
+        cmd,
+        cwd=repo_root,
+        stdout=stdout_handle,
+        stderr=stderr_handle,
+    )
+
+    _write_worker_metadata(_worker_metadata_path(artifacts_dir), proc.pid, cmd)
+    return proc, stdout_handle, stderr_handle

codex_autorunner/core/git_utils.py

@@ -232,3 +232,65 @@ def git_default_branch(repo_root: Path) -> Optional[str]:
     if raw.startswith("origin/"):
         return raw.split("/", 1)[1]
     return raw
+
+
+def git_diff_stats(
+    repo_root: Path, from_ref: Optional[str] = None, *, include_staged: bool = True
+) -> Optional[dict]:
+    """
+    Get diff statistics (insertions/deletions) for changes.
+
+    Args:
+        repo_root: Repository root path
+        from_ref: Compare against this ref (e.g., a commit SHA). If None, compares
+                  working tree against HEAD.
+        include_staged: When from_ref is None, include staged changes in the diff.
+
+    Returns:
+        Dict with insertions, deletions, files_changed, or None on error.
+        Example: {"insertions": 47, "deletions": 12, "files_changed": 5}
+    """
+    try:
+        if from_ref:
+            # Compare from_ref to working tree (includes all changes: committed + staged + unstaged)
+            proc = run_git(["diff", "--numstat", from_ref], repo_root)
+        elif include_staged:
+            # Working tree + staged vs HEAD
+            proc = run_git(["diff", "--numstat", "HEAD"], repo_root)
+        else:
+            # Only unstaged changes
+            proc = run_git(["diff", "--numstat"], repo_root)
+    except GitError:
+        return None
+    if proc.returncode != 0:
+        return None
+
+    insertions = 0
+    deletions = 0
+    files_changed = 0
+
+    for line in (proc.stdout or "").strip().splitlines():
+        if not line:
+            continue
+        parts = line.split("\t")
+        if len(parts) < 2:
+            continue
+        # Binary files show "-" for both counts
+        add_str, del_str = parts[0], parts[1]
+        if add_str != "-":
+            try:
+                insertions += int(add_str)
+            except ValueError:
+                pass
+        if del_str != "-":
+            try:
+                deletions += int(del_str)
+            except ValueError:
+                pass
+        files_changed += 1
+
+    return {
+        "insertions": insertions,
+        "deletions": deletions,
+        "files_changed": files_changed,
+    }