codex-autorunner 1.0.0__py3-none-any.whl → 1.2.0__py3-none-any.whl

codex_autorunner/core/flows/ux_helpers.py

@@ -0,0 +1,272 @@
+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, ticket_is_done
+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 ticket_progress(repo_root: Path) -> dict[str, int]:
+    ticket_dir = _ticket_dir(repo_root)
+    ticket_paths = list_ticket_paths(ticket_dir)
+    total = len(ticket_paths)
+    done = 0
+    if total:
+        for path in ticket_paths:
+            if ticket_is_done(path):
+                done += 1
+    return {"done": done, "total": total}
+
+
+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,
+        "ticket_progress": ticket_progress(repo_root),
+        "state": updated_state,
+    }
+
+
+def ensure_worker(repo_root: Path, run_id: str, is_terminal: bool = False) -> dict:
+    health = check_worker_health(repo_root, run_id)
+    # Only clear metadata for dead/mismatch/invalid workers if not terminal
+    if not is_terminal and 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",
+    "ticket_progress",
+    "seed_issue_from_github",
+    "seed_issue_from_text",
+]

codex_autorunner/core/flows/worker_process.py

@@ -152,7 +152,8 @@ def check_worker_health(
     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 []
+        raw_cmd = data.get("cmd") or []
+        cmd = [str(part) for part in raw_cmd] if isinstance(raw_cmd, list) else []
     except Exception:
         return FlowWorkerHealth(
             status="invalid",
@@ -166,7 +167,7 @@ def check_worker_health(
         return FlowWorkerHealth(
             status="invalid",
             pid=pid,
-            cmdline=cmd if isinstance(cmd, list) else [],
+            cmdline=cmd,
             artifact_path=metadata_path,
             message="missing or invalid PID",
         )
@@ -175,19 +176,19 @@ def check_worker_health(
         return FlowWorkerHealth(
             status="dead",
             pid=pid,
-            cmdline=cmd if isinstance(cmd, list) else [],
+            cmdline=cmd,
             artifact_path=metadata_path,
             message="worker PID not running",
         )
 
-    expected_cmd = _build_worker_cmd(entrypoint, run_id)
+    expected_cmd = cmd or _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 [],
+            cmdline=cmd,
             artifact_path=metadata_path,
             message="worker running (cmdline unknown)",
         )
@@ -198,7 +199,7 @@ def check_worker_health(
             pid=pid,
             cmdline=actual_cmd,
             artifact_path=metadata_path,
-            message="worker PID command does not match expected",
+            message="worker PID command does not match stored metadata",
         )
 
     return FlowWorkerHealth(
@@ -210,6 +211,31 @@ def check_worker_health(
     )
 
 
+def register_worker_metadata(
+    repo_root: Path,
+    run_id: str,
+    *,
+    artifacts_root: Optional[Path] = None,
+    pid: Optional[int] = None,
+    cmd: Optional[list[str]] = None,
+    entrypoint: str = "codex_autorunner",
+) -> Path:
+    normalized_run_id = _normalized_run_id(run_id)
+    artifacts_dir = _worker_artifacts_dir(repo_root, normalized_run_id, artifacts_root)
+
+    resolved_pid = pid or os.getpid()
+    resolved_cmd = cmd or _read_process_cmdline(resolved_pid)
+    if not resolved_cmd:
+        resolved_cmd = _build_worker_cmd(entrypoint, normalized_run_id)
+
+    _write_worker_metadata(
+        _worker_metadata_path(artifacts_dir),
+        resolved_pid,
+        resolved_cmd,
+    )
+    return artifacts_dir
+
+
 def spawn_flow_worker(
     repo_root: Path,
     run_id: str,

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,
+    }