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

codex_autorunner/cli.py

@@ -5,6 +5,7 @@ import logging
 import os
 import shlex
 import subprocess
+import uuid
 from pathlib import Path
 from typing import NoReturn, Optional
 
@@ -18,16 +19,17 @@ from .core.config import (
     CONFIG_FILENAME,
     ConfigError,
     HubConfig,
+    RepoConfig,
     _normalize_base_path,
+    derive_repo_config,
     find_nearest_hub_config_path,
     load_hub_config,
 )
-from .core.engine import Engine, LockError, clear_stale_lock, doctor
+from .core.engine import DoctorReport, Engine, LockError, clear_stale_lock, doctor
 from .core.git_utils import GitError, run_git
 from .core.hub import HubSupervisor
 from .core.logging_utils import log_event, setup_rotating_logger
 from .core.optional_dependencies import require_optional_dependencies
-from .core.snapshot import SnapshotError
 from .core.state import RunnerState, load_state, now_iso, save_state, state_lock
 from .core.usage import (
     UsageError,
@@ -37,18 +39,17 @@ from .core.usage import (
     summarize_repo_usage,
 )
 from .core.utils import RepoNotFoundError, default_editor, find_repo_root
-from .integrations.app_server.env import build_app_server_env
-from .integrations.app_server.supervisor import WorkspaceAppServerSupervisor
 from .integrations.telegram.adapter import TelegramAPIError, TelegramBotClient
+from .integrations.telegram.doctor import telegram_doctor_checks
 from .integrations.telegram.service import (
     TelegramBotConfig,
     TelegramBotConfigError,
     TelegramBotLockError,
     TelegramBotService,
 )
+from .integrations.telegram.state import TelegramStateStore
 from .manifest import load_manifest
 from .server import create_hub_app
-from .spec_ingest import SpecIngestError, SpecIngestService, clear_work_docs
 from .voice import VoiceConfig
 
 logger = logging.getLogger("codex_autorunner.cli")
@@ -755,7 +756,7 @@ def log(
 
 @app.command()
 def edit(
-    target: str = typer.Argument(..., help="todo|progress|opinions|spec"),
+    target: str = typer.Argument(..., help="active_context|decisions|spec"),
     repo: Optional[Path] = typer.Option(None, "--repo", help="Repo path"),
     hub: Optional[Path] = typer.Option(None, "--hub", help="Hub root path"),
 ):
@@ -763,8 +764,8 @@ def edit(
     engine = _require_repo_config(repo, hub)
     config = engine.config
     key = target.lower()
-    if key not in ("todo", "progress", "opinions", "spec"):
-        _raise_exit("Invalid target; choose todo, progress, opinions, or spec")
+    if key not in ("active_context", "decisions", "spec"):
+        _raise_exit("Invalid target; choose active_context, decisions, or spec")
     path = config.doc_path(key)
     editor = os.environ.get("VISUAL") or os.environ.get("EDITOR") or default_editor()
     editor_parts = shlex.split(editor)
@@ -774,84 +775,6 @@ def edit(
     subprocess.run([*editor_parts, str(path)])
 
 
-@app.command("ingest-spec")
-def ingest_spec_cmd(
-    repo: Optional[Path] = typer.Option(None, "--repo", help="Repo path"),
-    hub: Optional[Path] = typer.Option(None, "--hub", help="Hub root path"),
-    spec: Optional[Path] = typer.Option(
-        None, "--spec", help="Path to SPEC (defaults to configured docs.spec)"
-    ),
-    force: bool = typer.Option(
-        False, "--force", help="Overwrite TODO/PROGRESS/OPINIONS"
-    ),
-):
-    """Generate TODO/PROGRESS/OPINIONS from SPEC using Codex."""
-    try:
-        engine = _require_repo_config(repo, hub)
-        config = engine.config
-        if not config.app_server.command:
-            raise SpecIngestError("app_server.command must be configured")
-
-        async def _run_ingest() -> dict:
-            logger = logging.getLogger("codex_autorunner.cli.app_server")
-
-            def _env_builder(
-                workspace_root: Path, _workspace_id: str, state_dir: Path
-            ) -> dict[str, str]:
-                state_dir.mkdir(parents=True, exist_ok=True)
-                return build_app_server_env(
-                    config.app_server.command,
-                    workspace_root,
-                    state_dir,
-                    logger=logger,
-                    event_prefix="cli",
-                )
-
-            supervisor = WorkspaceAppServerSupervisor(
-                config.app_server.command,
-                state_root=config.app_server.state_root,
-                env_builder=_env_builder,
-                logger=logger,
-                max_handles=config.app_server.max_handles,
-                idle_ttl_seconds=config.app_server.idle_ttl_seconds,
-                request_timeout=config.app_server.request_timeout,
-            )
-            service = SpecIngestService(engine, app_server_supervisor=supervisor)
-            try:
-                await service.execute(force=force, spec_path=spec, message=None)
-                return service.apply_patch()
-            finally:
-                await supervisor.close_all()
-
-        docs = asyncio.run(_run_ingest())
-    except (ConfigError, SpecIngestError) as exc:
-        _raise_exit(str(exc), cause=exc)
-
-    typer.echo("Ingested SPEC into TODO/PROGRESS/OPINIONS.")
-    for key, content in docs.items():
-        lines = len(content.splitlines())
-        typer.echo(f"- {key.upper()}: {lines} lines")
-
-
-@app.command("clear-docs")
-def clear_docs_cmd(
-    repo: Optional[Path] = typer.Option(None, "--repo", help="Repo path"),
-    hub: Optional[Path] = typer.Option(None, "--hub", help="Hub root path"),
-    yes: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation"),
-):
-    """Clear TODO/PROGRESS/OPINIONS to empty templates."""
-    if not yes:
-        confirm = input("Clear TODO/PROGRESS/OPINIONS? Type CLEAR to confirm: ").strip()
-        if confirm.upper() != "CLEAR":
-            _raise_exit("Aborted.")
-    engine = _require_repo_config(repo, hub)
-    try:
-        clear_work_docs(engine)
-    except ConfigError as exc:
-        _raise_exit(str(exc), cause=exc)
-    typer.echo("Cleared TODO/PROGRESS/OPINIONS.")
-
-
 @app.command("doctor")
 def doctor_cmd(
     repo: Optional[Path] = typer.Option(None, "--repo", help="Repo or hub path"),
@@ -859,7 +782,19 @@ def doctor_cmd(
 ):
     """Validate repo or hub setup."""
     try:
-        report = doctor(repo or Path.cwd())
+        start_path = repo or Path.cwd()
+        report = doctor(start_path)
+
+        hub_config = load_hub_config(start_path)
+        repo_config: Optional[RepoConfig] = None
+        try:
+            repo_root = find_repo_root(start_path)
+            repo_config = derive_repo_config(hub_config, repo_root)
+        except RepoNotFoundError:
+            repo_config = None
+
+        telegram_checks = telegram_doctor_checks(repo_config or hub_config)
+        report = DoctorReport(checks=report.checks + telegram_checks)
     except ConfigError as exc:
         _raise_exit(str(exc), cause=exc)
     if json_output:
@@ -877,56 +812,6 @@ def doctor_cmd(
     typer.echo("Doctor check passed")
 
 
-@app.command()
-def snapshot(
-    repo: Optional[Path] = typer.Option(None, "--repo", help="Repo path"),
-    hub: Optional[Path] = typer.Option(None, "--hub", help="Hub root path"),
-):
-    """Generate or update `.codex-autorunner/SNAPSHOT.md`."""
-    try:
-        engine = _require_repo_config(repo, hub)
-        config = engine.config
-        if not config.app_server.command:
-            raise SnapshotError("app_server.command must be configured")
-
-        async def _run_snapshot() -> None:
-            logger = logging.getLogger("codex_autorunner.cli.app_server")
-
-            def _env_builder(
-                workspace_root: Path, _workspace_id: str, state_dir: Path
-            ) -> dict[str, str]:
-                state_dir.mkdir(parents=True, exist_ok=True)
-                return build_app_server_env(
-                    config.app_server.command,
-                    workspace_root,
-                    state_dir,
-                    logger=logger,
-                    event_prefix="cli",
-                )
-
-            supervisor = WorkspaceAppServerSupervisor(
-                config.app_server.command,
-                state_root=config.app_server.state_root,
-                env_builder=_env_builder,
-                logger=logger,
-                max_handles=config.app_server.max_handles,
-                idle_ttl_seconds=config.app_server.idle_ttl_seconds,
-                request_timeout=config.app_server.request_timeout,
-            )
-            from .core.snapshot import SnapshotService
-
-            service = SnapshotService(engine, app_server_supervisor=supervisor)
-            try:
-                await service.generate_snapshot()
-            finally:
-                await supervisor.close_all()
-
-        asyncio.run(_run_snapshot())
-    except (ConfigError, SnapshotError) as exc:
-        _raise_exit(str(exc), cause=exc)
-    typer.echo("Snapshot written to .codex-autorunner/SNAPSHOT.md")
-
-
 @app.command()
 def serve(
     path: Optional[Path] = typer.Option(None, "--path", "--hub", help="Hub root path"),
@@ -1106,6 +991,8 @@ def telegram_start(
             housekeeping_config=config.housekeeping,
             update_repo_url=update_repo_url,
             update_repo_ref=update_repo_ref,
+            update_skip_checks=config.update_skip_checks,
+            app_server_auto_restart=config.app_server.auto_restart,
         )
         await service.run_polling()
 
@@ -1151,8 +1038,139 @@ def telegram_health(
         asyncio.run(_run())
     except TelegramAPIError as exc:
         _raise_exit(f"Telegram health check failed: {exc}", cause=exc)
-    except Exception as exc:
-        _raise_exit(f"Telegram health check failed: {exc}", cause=exc)
+
+
+@telegram_app.command("state-check")
+def telegram_state_check(
+    path: Optional[Path] = typer.Option(None, "--path", help="Repo or hub root path"),
+):
+    """Open the Telegram state DB and ensure schema migrations apply."""
+    try:
+        config = load_hub_config(path or Path.cwd())
+    except ConfigError as exc:
+        _raise_exit(str(exc), cause=exc)
+    telegram_cfg = TelegramBotConfig.from_raw(
+        config.raw.get("telegram_bot") if isinstance(config.raw, dict) else None,
+        root=config.root,
+        agent_binaries=getattr(config, "agents", None)
+        and {name: agent.binary for name, agent in config.agents.items()},
+    )
+    if not telegram_cfg.enabled:
+        _raise_exit("telegram_bot is disabled; set telegram_bot.enabled: true")
+
+    try:
+        store = TelegramStateStore(
+            telegram_cfg.state_file,
+            default_approval_mode=telegram_cfg.defaults.approval_mode,
+        )
+        # This will open the DB and apply schema/migrations.
+        store._connection_sync()  # type: ignore[attr-defined]
+    except Exception as exc:  # pragma: no cover - defensive runtime check
+        _raise_exit(f"Telegram state check failed: {exc}", cause=exc)
+
+
+@app.command()
+def flow(
+    action: str = typer.Argument(..., help="worker"),
+    repo: Optional[Path] = typer.Option(None, "--repo", help="Repo path"),
+    hub: Optional[Path] = typer.Option(None, "--hub", help="Hub root path"),
+    run_id: Optional[str] = typer.Option(
+        None, "--run-id", help="Flow run ID (for worker)"
+    ),
+):
+    """Flow runtime commands."""
+    engine = _require_repo_config(repo, hub)
+
+    if action == "worker":
+        if not run_id:
+            _raise_exit("--run-id is required for worker command")
+        try:
+            run_id = str(uuid.UUID(str(run_id)))
+        except ValueError:
+            _raise_exit("Invalid run_id format; must be a UUID")
+
+        from .core.flows import FlowController, FlowStore
+        from .core.flows.models import FlowRunStatus
+        from .flows.ticket_flow import build_ticket_flow_definition
+        from .tickets import AgentPool
+
+        db_path = engine.repo_root / ".codex-autorunner" / "flows.db"
+        artifacts_root = engine.repo_root / ".codex-autorunner" / "flows"
+
+        typer.echo(f"Starting flow worker for run {run_id}")
+
+        async def _run_worker():
+            typer.echo(f"Flow worker started for {run_id}")
+            typer.echo(f"DB path: {db_path}")
+            typer.echo(f"Artifacts root: {artifacts_root}")
+
+            store = FlowStore(db_path)
+            store.initialize()
+
+            record = store.get_flow_run(run_id)
+            if not record:
+                typer.echo(f"Flow run {run_id} not found", err=True)
+                store.close()
+                raise typer.Exit(code=1)
+            store.close()
+
+            agent_pool: AgentPool | None = None
+
+            def _build_definition(flow_type: str):
+                nonlocal agent_pool
+                if flow_type == "pr_flow":
+                    _raise_exit(
+                        "PR flow is no longer supported. Use ticket_flow instead."
+                    )
+                if flow_type == "ticket_flow":
+                    agent_pool = AgentPool(engine.config)
+                    return build_ticket_flow_definition(agent_pool=agent_pool)
+                _raise_exit(f"Unknown flow type for run {run_id}: {flow_type}")
+                return None
+
+            definition = _build_definition(record.flow_type)
+            definition.validate()
+
+            controller = FlowController(
+                definition=definition,
+                db_path=db_path,
+                artifacts_root=artifacts_root,
+            )
+            controller.initialize()
+
+            record = controller.get_status(run_id)
+            if not record:
+                typer.echo(f"Flow run {run_id} not found", err=True)
+                raise typer.Exit(code=1)
+
+            if record.status.is_terminal() and record.status not in {
+                FlowRunStatus.STOPPED,
+                FlowRunStatus.FAILED,
+            }:
+                typer.echo(
+                    f"Flow run {run_id} already completed (status={record.status})"
+                )
+                return
+
+            action = (
+                "Resuming" if record.status != FlowRunStatus.PENDING else "Starting"
+            )
+            typer.echo(f"{action} flow run {run_id} from step: {record.current_step}")
+            try:
+                final_record = await controller.run_flow(run_id)
+                typer.echo(
+                    f"Flow run {run_id} finished with status {final_record.status}"
+                )
+            finally:
+                if agent_pool is not None:
+                    try:
+                        await agent_pool.close()
+                    except Exception:
+                        typer.echo("Failed to close agent pool cleanly", err=True)
+
+        asyncio.run(_run_worker())
+    else:
+        _raise_exit(f"Unknown action: {action}")
 
 
 if __name__ == "__main__":

codex_autorunner/core/about_car.py

@@ -17,6 +17,26 @@ ABOUT_CAR_REL_PATH = Path(".codex-autorunner") / ABOUT_CAR_BASENAME
 # If this marker is present, codex-autorunner may safely refresh the file content.
 ABOUT_CAR_GENERATED_MARKER = "<!-- CAR:AUTOGENERATED -->"
 
+CAR_CONTEXT_KEYWORDS = (
+    "car",
+    "codex",
+    "spec",
+    "autorunner",
+    "workspace",
+    "ticket",
+    "tickets",
+    "context",
+    "decision",
+    "decisions",
+    "handoff",
+    "dispatch",
+    "inbox",
+)
+
+CAR_CONTEXT_HINT = (
+    "Context: read .codex-autorunner/ABOUT_CAR.md for repo-specific rules."
+)
+
 
 def _display_path(repo_root: Path, path: Path) -> str:
     try:
@@ -28,11 +48,9 @@ def _display_path(repo_root: Path, path: Path) -> str:
 def build_about_car_markdown(
     *,
     repo_root: Path,
-    todo_path: Path,
-    progress_path: Path,
-    opinions_path: Path,
+    active_context_path: Path,
+    decisions_path: Path,
     spec_path: Path,
-    summary_path: Path,
     hub_config_path: Optional[Path] = None,
     repo_override_path: Optional[Path] = None,
 ) -> str:
@@ -44,11 +62,9 @@ def build_about_car_markdown(
     repo_override_path = repo_override_path or (repo_root / REPO_OVERRIDE_FILENAME)
     root_config_path = repo_root / ROOT_CONFIG_FILENAME
     root_override_path = repo_root / ROOT_OVERRIDE_FILENAME
-    todo_disp = _display_path(repo_root, todo_path)
-    progress_disp = _display_path(repo_root, progress_path)
-    opinions_disp = _display_path(repo_root, opinions_path)
+    active_context_disp = _display_path(repo_root, active_context_path)
+    decisions_disp = _display_path(repo_root, decisions_path)
     spec_disp = _display_path(repo_root, spec_path)
-    summary_disp = _display_path(repo_root, summary_path)
     hub_config_disp = _display_path(repo_root, hub_config_path)
     repo_override_disp = _display_path(repo_root, repo_override_path)
     root_config_disp = _display_path(repo_root, root_config_path)
@@ -58,25 +74,25 @@ def build_about_car_markdown(
         f"{ABOUT_CAR_GENERATED_MARKER}\n"
         "# ABOUT_CAR — Codex Autorunner (CAR)\n\n"
         "You are running inside **Codex Autorunner (CAR)**.\n\n"
-        "CAR uses a small set of markdown **work docs** as the control surface for long-horizon work. "
-        "These docs live under the repo-local, gitignored `.codex-autorunner/` directory.\n\n"
-        "## Work docs (canonical)\n"
-        "- **TODO** — ordered checklist of high-level tasks: "
-        f"`{todo_disp}`\n"
-        "- **PROGRESS** — running notes / validation / context: "
-        f"`{progress_disp}`\n"
-        "- **OPINIONS** — constraints + style guidelines: "
-        f"`{opinions_disp}`\n"
-        "- **SPEC** — source-of-truth requirements and scope: "
-        f"`{spec_disp}`\n"
-        "- **SUMMARY** — user-facing report + external/user action items: "
-        f"`{summary_disp}`\n\n"
+        "CAR uses a ticket-first workflow.\n\n"
+        "## Required for operation\n"
+        "- Tickets live under `.codex-autorunner/tickets/`.\n\n"
+        "## Optional workspace docs\n"
+        "- **Active context**: "
+        f"`{active_context_disp}`\n"
+        "- **Decisions**: "
+        f"`{decisions_disp}`\n"
+        "- **Spec**: "
+        f"`{spec_disp}`\n\n"
         "## Critical rules\n"
-        f'- When the user says **"add this to the TODOs"**, edit `{todo_disp}`.\n'
-        "- Do **not** create new copies of TODO/PROGRESS/OPINIONS/SPEC/SUMMARY elsewhere in the repo.\n"
+        "- Do **not** create new copies of workspace docs elsewhere in the repo.\n"
         "- Treat `.codex-autorunner/` as intentional project structure even though it is hidden/gitignored.\n\n"
+        "## Agent Flow\n"
+        "- **Dispatch**: An update or message from the agent.\n"
+        "- **Handoff**: Passing control from agent to user (or vice versa).\n"
+        "- **Inbox**: Where the agent receives files/messages.\n\n"
         "## How CAR works (short)\n"
-        "- `car run/once` repeatedly runs Codex non-interactively, feeding it the work docs (and the prior run tail).\n"
+        "- The web UI provides ticket editing + unified file chat.\n"
         "- `car serve` starts the hub web UI. The **Terminal** tab launches the configured `codex` binary in a PTY.\n"
         f"- Hub config lives at `{hub_config_disp}` (generated).\n"
         f"- Repo overrides (optional) live at `{repo_override_disp}`.\n"
@@ -101,11 +117,9 @@ def ensure_about_car_file_for_repo(
 
     content = build_about_car_markdown(
         repo_root=repo_root,
-        todo_path=doc_paths["todo"],
-        progress_path=doc_paths["progress"],
-        opinions_path=doc_paths["opinions"],
+        active_context_path=doc_paths["active_context"],
+        decisions_path=doc_paths["decisions"],
         spec_path=doc_paths["spec"],
-        summary_path=doc_paths["summary"],
     )
     if content and not content.endswith("\n"):
         content += "\n"
@@ -129,10 +143,8 @@ def ensure_about_car_file(config: Config, *, force: bool = False) -> Path:
     """Config-aware wrapper that uses configured doc paths."""
     repo_root = config.root
     docs = {
-        "todo": config.doc_path("todo"),
-        "progress": config.doc_path("progress"),
-        "opinions": config.doc_path("opinions"),
+        "active_context": config.doc_path("active_context"),
+        "decisions": config.doc_path("decisions"),
         "spec": config.doc_path("spec"),
-        "summary": config.doc_path("summary"),
     }
     return ensure_about_car_file_for_repo(repo_root, doc_paths=docs, force=force)

codex_autorunner/core/adapter_utils.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+from typing import Any, Callable
+
+
+def handle_agent_output(
+    log_app_server_output: Callable[[int, list[str]], None],
+    write_run_artifact: Callable[[int, str, str], Any],
+    merge_run_index_entry: Callable[[int, dict[str, Any]], None],
+    run_id: int,
+    output: str | list[str],
+) -> None:
+    if isinstance(output, str):
+        messages = [output]
+    else:
+        messages = output
+    log_app_server_output(run_id, messages)
+    output_text = "\n\n".join(messages).strip() if messages else ""
+    if output_text:
+        output_path = write_run_artifact(run_id, "output.txt", output_text)
+        merge_run_index_entry(run_id, {"artifacts": {"output_path": str(output_path)}})

codex_autorunner/core/app_server_logging.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 from typing import Any, cast
 
+from .redaction import redact_text
 from .text_delta_coalescer import TextDeltaCoalescer
 
 
@@ -69,7 +70,8 @@ def _extract_error_message(params: Any) -> str:
 
 
 class AppServerEventFormatter:
-    def __init__(self) -> None:
+    def __init__(self, redact_enabled: bool = True) -> None:
+        self._redact_enabled = redact_enabled
         self._thinking_items: set[str] = set()
         self._reasoning_coalescers: dict[str, TextDeltaCoalescer] = {}
 
@@ -187,7 +189,8 @@ class AppServerEventFormatter:
                 or params.get("value")
             )
             if isinstance(diff, str) and diff:
-                lines.extend(diff.splitlines())
+                diff_text = redact_text(diff) if self._redact_enabled else diff
+                lines.extend(diff_text.splitlines())
             return lines
 
         if method == "error":
@@ -199,7 +202,8 @@ class AppServerEventFormatter:
         if "outputdelta" in method.lower():
             delta = params.get("delta") or params.get("text") or params.get("output")
             if isinstance(delta, str) and delta:
-                lines.extend(delta.splitlines())
+                delta_text = redact_text(delta) if self._redact_enabled else delta
+                lines.extend(delta_text.splitlines())
             return lines
 
         return lines