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

codex_autorunner/bootstrap.py

@@ -10,45 +10,22 @@ from .core.config import (
     ConfigError,
     resolve_hub_config_data,
 )
+from .core.state import RunnerState, save_state
 from .core.utils import atomic_write
 from .manifest import load_manifest
 
 GITIGNORE_CONTENT = "*"
+GENERATED_CONFIG_HEADER = "# GENERATED by CAR - DO NOT EDIT\n"
 
 
 def sample_todo() -> str:
     return """# TODO\n\n- [ ] Replace this item with your first task\n- [ ] Add another task\n- [x] Example completed item\n"""
 
 
-def sample_opinions() -> str:
-    return """# Opinions\n\n- Prefer small, well-tested changes.\n- Keep docs in sync with code.\n- Avoid unnecessary dependencies.\n"""
-
-
 def sample_spec() -> str:
     return """# Spec\n\n## Context\n- Add project background and goals here.\n\n## Requirements\n- Requirement 1\n- Requirement 2\n\n## Non-goals\n- Out of scope items\n"""
 
 
-def sample_summary() -> str:
-    return """# Summary
-
-This doc is the **user-facing report and handoff** for work done by CAR agents.
-
-Use it for:
-- Anything that requires **user action** or an **external party** (not agents).
-- Unresolved decisions or blockers that agents can’t finish autonomously.
-- A final condensed report once TODO is complete.
-
-## External/user actions
-- (none)
-
-## Open questions / blockers
-- (none)
-
-## Final report
-- (pending)
-"""
-
-
 def _seed_doc(path: Path, force: bool, content: str) -> None:
     if path.exists() and not force:
         return
@@ -81,6 +58,7 @@ def write_hub_config(hub_root: Path, force: bool = False) -> Path:
         return config_path
     config_path.parent.mkdir(parents=True, exist_ok=True)
     with config_path.open("w", encoding="utf-8") as f:
+        f.write(GENERATED_CONFIG_HEADER)
         yaml.safe_dump(
             resolve_hub_config_data(hub_root),
             f,
@@ -107,32 +85,33 @@ def seed_repo_files(
     if not gitignore_path.exists() or force:
         gitignore_path.write_text(GITIGNORE_CONTENT, encoding="utf-8")
 
-    state_path = ca_dir / "state.json"
+    state_path = ca_dir / "state.sqlite3"
     if not state_path.exists() or force:
-        atomic_write(
-            state_path,
-            '{\n  "last_run_id": null,\n  "status": "idle",\n  "last_exit_code": null,\n  "last_run_started_at": null,\n  "last_run_finished_at": null,\n  "runner_pid": null\n}\n',
-        )
+        save_state(state_path, RunnerState(None, "idle", None, None, None))
 
     log_path = ca_dir / "codex-autorunner.log"
     if not log_path.exists() or force:
         log_path.write_text("", encoding="utf-8")
 
-    _seed_doc(ca_dir / "TODO.md", force, sample_todo())
-    _seed_doc(ca_dir / "PROGRESS.md", force, "# Progress\n\n")
-    _seed_doc(ca_dir / "OPINIONS.md", force, sample_opinions())
-    _seed_doc(ca_dir / "SPEC.md", force, sample_spec())
-    _seed_doc(ca_dir / "SUMMARY.md", force, sample_summary())
+    tickets_dir = ca_dir / "tickets"
+    if not tickets_dir.exists() or force:
+        tickets_dir.mkdir(parents=True, exist_ok=True)
+
+    workspace_dir = ca_dir / "workspace"
+    if not workspace_dir.exists() or force:
+        workspace_dir.mkdir(parents=True, exist_ok=True)
+
+    _seed_doc(workspace_dir / "active_context.md", force, sample_todo())
+    _seed_doc(workspace_dir / "decisions.md", force, "# Decisions\n\n")
+    _seed_doc(workspace_dir / "spec.md", force, sample_spec())
 
     # Seed an always-available briefing doc for interactive Codex sessions.
     ensure_about_car_file_for_repo(
         repo_root,
         doc_paths={
-            "todo": ca_dir / "TODO.md",
-            "progress": ca_dir / "PROGRESS.md",
-            "opinions": ca_dir / "OPINIONS.md",
-            "spec": ca_dir / "SPEC.md",
-            "summary": ca_dir / "SUMMARY.md",
+            "active_context": workspace_dir / "active_context.md",
+            "decisions": workspace_dir / "decisions.md",
+            "spec": workspace_dir / "spec.md",
         },
         force=force,
     )

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,20 +39,21 @@ 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")
+
 app = typer.Typer(add_completion=False)
 hub_app = typer.Typer(add_completion=False)
 telegram_app = typer.Typer(add_completion=False)
@@ -115,14 +118,16 @@ def _resolve_repo_api_path(repo_root: Path, hub: Optional[Path], path: str) -> s
                 manifest_value = hub_cfg.get("manifest")
                 if isinstance(manifest_value, str) and manifest_value.strip():
                     manifest_rel = manifest_value.strip()
-    except Exception:
+    except (OSError, yaml.YAMLError, KeyError, ValueError) as exc:
+        logger.debug("Failed to read hub config for manifest: %s", exc)
         manifest_rel = None
     manifest_path = hub_root / (manifest_rel or ".codex-autorunner/manifest.yml")
     if not manifest_path.exists():
         return path
     try:
         manifest = load_manifest(manifest_path, hub_root)
-    except Exception:
+    except (OSError, ValueError, KeyError) as exc:
+        logger.debug("Failed to load manifest: %s", exc)
         return path
     repo_root = repo_root.resolve()
     for entry in manifest.repos:
@@ -287,6 +292,7 @@ def init(
 def status(
     repo: Optional[Path] = typer.Option(None, "--repo", help="Repo path"),
     hub: Optional[Path] = typer.Option(None, "--hub", help="Hub root path"),
+    output_json: bool = typer.Option(False, "--json", help="Emit JSON output"),
 ):
     """Show autorunner status."""
     engine = _require_repo_config(repo, hub)
@@ -301,6 +307,51 @@ def status(
     opencode_record = (
         state.sessions.get(opencode_session_id) if opencode_session_id else None
     )
+
+    if output_json:
+        hub_config_path = _resolve_hub_config_path_for_cli(engine.repo_root, hub)
+        payload = {
+            "repo": str(engine.repo_root),
+            "hub": (
+                str(hub_config_path.parent.parent.resolve())
+                if hub_config_path
+                else None
+            ),
+            "status": state.status,
+            "last_run_id": state.last_run_id,
+            "last_exit_code": state.last_exit_code,
+            "last_run_started_at": state.last_run_started_at,
+            "last_run_finished_at": state.last_run_finished_at,
+            "runner_pid": state.runner_pid,
+            "session_id": session_id,
+            "session_record": (
+                {
+                    "repo_path": session_record.repo_path,
+                    "created_at": session_record.created_at,
+                    "last_seen_at": session_record.last_seen_at,
+                    "status": session_record.status,
+                    "agent": session_record.agent,
+                }
+                if session_record
+                else None
+            ),
+            "opencode_session_id": opencode_session_id,
+            "opencode_record": (
+                {
+                    "repo_path": opencode_record.repo_path,
+                    "created_at": opencode_record.created_at,
+                    "last_seen_at": opencode_record.last_seen_at,
+                    "status": opencode_record.status,
+                    "agent": opencode_record.agent,
+                }
+                if opencode_record
+                else None
+            ),
+            "outstanding_todos": len(outstanding),
+        }
+        typer.echo(json.dumps(payload, indent=2))
+        return
+
     typer.echo(f"Repo: {engine.repo_root}")
     typer.echo(f"Status: {state.status}")
     typer.echo(f"Last run id: {state.last_run_id}")
@@ -341,7 +392,15 @@ def sessions(
     source = "server"
     try:
         payload = _request_json("GET", url, token_env=config.server_auth_token_env)
-    except Exception:
+    except (
+        httpx.HTTPError,
+        httpx.ConnectError,
+        httpx.TimeoutException,
+        OSError,
+    ) as exc:
+        logger.debug(
+            "Failed to fetch sessions from server, falling back to state: %s", exc
+        )
         state = load_state(engine.state_path)
         payload = {
             "sessions": [
@@ -407,8 +466,15 @@ def stop_session(
         stopped_id = response.get("session_id", payload.get("session_id", ""))
         typer.echo(f"Stopped session {stopped_id}")
         return
-    except Exception:
-        pass
+    except (
+        httpx.HTTPError,
+        httpx.ConnectError,
+        httpx.TimeoutException,
+        OSError,
+    ) as exc:
+        logger.debug(
+            "Failed to stop session via server, falling back to state: %s", exc
+        )
 
     with state_lock(engine.state_path):
         state = load_state(engine.state_path)
@@ -467,7 +533,7 @@ def usage(
     except RepoNotFoundError:
         repo_root = None
 
-    if repo_root and (repo_root / ".codex-autorunner" / "state.json").exists():
+    if repo_root and (repo_root / ".codex-autorunner" / "state.sqlite3").exists():
         engine = _require_repo_config(repo, hub)
     else:
         try:
@@ -568,8 +634,8 @@ def run(
         if engine:
             try:
                 engine.release_lock()
-            except Exception:
-                pass
+            except OSError as exc:
+                logger.debug("Failed to release lock in run command: %s", exc)
 
 
 @app.command()
@@ -591,8 +657,8 @@ def once(
         if engine:
             try:
                 engine.release_lock()
-            except Exception:
-                pass
+            except OSError as exc:
+                logger.debug("Failed to release lock in once command: %s", exc)
 
 
 @app.command()
@@ -650,8 +716,8 @@ def resume(
         if engine:
             try:
                 engine.release_lock()
-            except Exception:
-                pass
+            except OSError as exc:
+                logger.debug("Failed to release lock in resume command: %s", exc)
 
 
 @app.command()
@@ -690,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"),
 ):
@@ -698,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)
@@ -709,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"),
@@ -794,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:
@@ -812,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"),
@@ -1041,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()
 
@@ -1086,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__":