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

codex_autorunner/routes/__init__.py

@@ -1,16 +1,17 @@
 """
 Modular API routes for the codex-autorunner server.
 
-This package splits the monolithic api_routes.py into focused modules:
-- base: Index, state streaming, and general endpoints
+This package splits monolithic api_routes.py into focused modules:
+- base: Index, WebSocket terminal, and general endpoints
 - agents: Agent harness models and event streaming
 - app_server: App-server thread registry endpoints
-- docs: Document management (read/write) and chat
-- github: GitHub integration endpoints
+- workspace: Optional workspace docs (active_context/decisions/spec)
+- flows: Flow runtime management (start/stop/resume/status/events/artifacts)
+- messages: Inbox/message wrappers over ticket_flow dispatch + reply histories
 - repos: Run control (start/stop/resume/reset)
-- runs: Run telemetry and artifacts
 - sessions: Terminal session registry endpoints
 - settings: Session settings for autorunner overrides
+- file_chat: Unified file chat (tickets + workspace docs)
 - voice: Voice transcription and config
 - terminal_images: Terminal image uploads
 """
@@ -20,25 +21,29 @@ from pathlib import Path
 from fastapi import APIRouter
 
 from .agents import build_agents_routes
+from .analytics import build_analytics_routes
 from .app_server import build_app_server_routes
-from .base import build_base_routes
-from .docs import build_docs_routes
-from .github import build_github_routes
+from .base import build_base_routes, build_frontend_routes
+from .file_chat import build_file_chat_routes
+from .flows import build_flow_routes
+from .messages import build_messages_routes
 from .repos import build_repos_routes
-from .runs import build_runs_routes
+from .review import build_review_routes
 from .sessions import build_sessions_routes
 from .settings import build_settings_routes
 from .system import build_system_routes
 from .terminal_images import build_terminal_image_routes
+from .usage import build_usage_routes
 from .voice import build_voice_routes
+from .workspace import build_workspace_routes
 
 
 def build_repo_router(static_dir: Path) -> APIRouter:
     """
-    Build the complete API router by combining all route modules.
+    Build complete API router by combining all route modules.
 
     Args:
-        static_dir: Path to the static assets directory
+        static_dir: Path to static assets directory
 
     Returns:
         Combined APIRouter with all endpoints
@@ -47,17 +52,23 @@ def build_repo_router(static_dir: Path) -> APIRouter:
 
     # Include all route modules
     router.include_router(build_base_routes(static_dir))
+    router.include_router(build_analytics_routes())
     router.include_router(build_agents_routes())
     router.include_router(build_app_server_routes())
-    router.include_router(build_docs_routes())
-    router.include_router(build_github_routes())
+    router.include_router(build_workspace_routes())
+    router.include_router(build_flow_routes())
+    router.include_router(build_file_chat_routes())
+    router.include_router(build_messages_routes())
     router.include_router(build_repos_routes())
-    router.include_router(build_runs_routes())
+    router.include_router(build_review_routes())
     router.include_router(build_sessions_routes())
     router.include_router(build_settings_routes())
     router.include_router(build_system_routes())
     router.include_router(build_terminal_image_routes())
+    router.include_router(build_usage_routes())
     router.include_router(build_voice_routes())
+    # Include frontend routes last to avoid shadowing API routes
+    router.include_router(build_frontend_routes(static_dir))
 
     return router
 

codex_autorunner/routes/agents.py

@@ -21,16 +21,27 @@ def _available_agents(request: Request) -> tuple[list[dict[str, str]], str]:
     default_agent: Optional[str] = None
 
     if getattr(request.app.state, "app_server_supervisor", None) is not None:
-        agents.append({"id": "codex", "name": "Codex"})
+        agents.append({"id": "codex", "name": "Codex", "protocol_version": "2.0"})
         default_agent = "codex"
 
     if getattr(request.app.state, "opencode_supervisor", None) is not None:
-        agents.append({"id": "opencode", "name": "OpenCode"})
+        supervisor = getattr(request.app.state, "opencode_supervisor", None)
+        version = None
+        if supervisor and hasattr(supervisor, "_handles"):
+            handles = supervisor._handles
+            if handles:
+                first_handle = next(iter(handles.values()), None)
+                if first_handle:
+                    version = getattr(first_handle, "version", None)
+        agent_data = {"id": "opencode", "name": "OpenCode"}
+        if version:
+            agent_data["version"] = str(version)
+        agents.append(agent_data)
         if default_agent is None:
             default_agent = "opencode"
 
     if not agents:
-        agents = [{"id": "codex", "name": "Codex"}]
+        agents = [{"id": "codex", "name": "Codex", "protocol_version": "2.0"}]
         default_agent = "codex"
 
     return agents, default_agent or "codex"
@@ -51,76 +62,6 @@ def _serialize_model_catalog(catalog: ModelCatalog) -> dict[str, Any]:
     }
 
 
-def _coerce_opencode_providers(payload: Any) -> list[dict[str, Any]]:
-    if isinstance(payload, dict):
-        providers = payload.get("providers")
-        if isinstance(providers, list):
-            return [entry for entry in providers if isinstance(entry, dict)]
-    if isinstance(payload, list):
-        return [entry for entry in payload if isinstance(entry, dict)]
-    return []
-
-
-def _build_opencode_model_catalog(payload: Any) -> ModelCatalog:
-    from ..agents.types import ModelSpec
-
-    providers = _coerce_opencode_providers(payload)
-    models: list[ModelSpec] = []
-    default_model = ""
-    if isinstance(payload, dict):
-        raw_default = payload.get("default")
-        if isinstance(raw_default, dict):
-            for provider in providers:
-                provider_id = provider.get("id") or provider.get("providerID")
-                if (
-                    isinstance(provider_id, str)
-                    and provider_id
-                    and provider_id in raw_default
-                ):
-                    default_model_id = raw_default[provider_id]
-                    if isinstance(default_model_id, str) and default_model_id:
-                        default_model = f"{provider_id}/{default_model_id}"
-                        break
-    for provider in providers:
-        provider_id = provider.get("id") or provider.get("providerID")
-        if not isinstance(provider_id, str) or not provider_id:
-            continue
-        models_map = provider.get("models")
-        if not isinstance(models_map, dict):
-            continue
-        for model_id, model in models_map.items():
-            if not isinstance(model_id, str) or not isinstance(model, dict):
-                continue
-            model_name = model.get("name") or model.get("id") or model_id
-            display_name = (
-                model_name if isinstance(model_name, str) and model_name else model_id
-            )
-            capabilities = model.get("capabilities")
-            supports_reasoning = False
-            if isinstance(capabilities, dict):
-                supports_reasoning = bool(capabilities.get("reasoning"))
-            variants = model.get("variants")
-            reasoning_options: list[str] = []
-            if isinstance(variants, dict):
-                reasoning_options = [
-                    key for key in variants.keys() if isinstance(key, str)
-                ]
-                if reasoning_options:
-                    supports_reasoning = True
-            full_id = f"{provider_id}/{model_id}"
-            models.append(
-                ModelSpec(
-                    id=full_id,
-                    display_name=display_name,
-                    supports_reasoning=supports_reasoning,
-                    reasoning_options=reasoning_options,
-                )
-            )
-    if not default_model and models:
-        default_model = models[0].id
-    return ModelCatalog(default_model=default_model, models=models)
-
-
 def build_agents_routes() -> APIRouter:
     router = APIRouter()
 
@@ -138,8 +79,8 @@ def build_agents_routes() -> APIRouter:
             events = request.app.state.app_server_events
             if supervisor is None:
                 raise HTTPException(status_code=404, detail="Codex harness unavailable")
-            harness = CodexHarness(supervisor, events)
-            catalog = await harness.model_catalog(engine.repo_root)
+            codex_harness = CodexHarness(supervisor, events)
+            catalog = await codex_harness.model_catalog(engine.repo_root)
             return _serialize_model_catalog(catalog)
         if agent_id == "opencode":
             supervisor = getattr(request.app.state, "opencode_supervisor", None)
@@ -148,9 +89,8 @@ def build_agents_routes() -> APIRouter:
                     status_code=404, detail="OpenCode harness unavailable"
                 )
             try:
-                client = await supervisor.get_client(engine.repo_root)
-                payload = await client.providers(directory=str(engine.repo_root))
-                catalog = _build_opencode_model_catalog(payload)
+                opencode_harness = OpenCodeHarness(supervisor)
+                catalog = await opencode_harness.model_catalog(engine.repo_root)
                 return _serialize_model_catalog(catalog)
             except OpenCodeSupervisorError as exc:
                 raise HTTPException(status_code=502, detail=str(exc)) from exc

codex_autorunner/routes/analytics.py

@@ -0,0 +1,239 @@
+"""Analytics summary routes.
+
+This module aggregates run/ticket/message metadata for the analytics dashboard
+without relying on legacy autorunner endpoints. It intentionally reads from the
+filesystem-backed ticket_flow store and ticket files to keep the UI consistent
+with the rest of the app.
+"""
+
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+from fastapi import APIRouter
+
+from ..core.flows.models import FlowRunRecord, FlowRunStatus
+from ..core.flows.store import FlowStore
+from ..core.utils import find_repo_root
+from ..tickets.files import list_ticket_paths, read_ticket, ticket_is_done
+from ..tickets.outbox import resolve_outbox_paths
+from ..tickets.replies import resolve_reply_paths
+
+
+def _flows_db_path(repo_root: Path) -> Path:
+    return repo_root / ".codex-autorunner" / "flows.db"
+
+
+def _load_flow_store(repo_root: Path) -> Optional[FlowStore]:
+    db_path = _flows_db_path(repo_root)
+    if not db_path.exists():
+        return None
+    store = FlowStore(db_path)
+    try:
+        store.initialize()
+    except Exception:
+        return None
+    return store
+
+
+def _select_primary_run(records: list[FlowRunRecord]) -> Optional[FlowRunRecord]:
+    """Select the primary run for analytics display.
+
+    Only considers the newest run (records[0]). If it's active or paused, return it.
+    If the newest run is terminal (completed/stopped/failed), return None to show idle.
+    This matches the backend's _active_or_paused_run() logic and prevents showing
+    stale data from old paused runs when newer runs have completed.
+    """
+    if not records:
+        return None
+    newest = records[0]
+    if (
+        FlowRunStatus(newest.status).is_active()
+        or FlowRunStatus(newest.status).is_paused()
+    ):
+        return newest
+    return None
+
+
+def _parse_timestamp(value: Optional[str]) -> Optional[datetime]:
+    if not value:
+        return None
+    try:
+        if value.endswith("Z"):
+            return datetime.fromisoformat(value.replace("Z", "+00:00"))
+        return datetime.fromisoformat(value)
+    except ValueError:
+        return None
+
+
+def _duration_seconds(
+    started_at: Optional[str], finished_at: Optional[str], status: str
+) -> Optional[float]:
+    start_dt = _parse_timestamp(started_at)
+    if not start_dt:
+        return None
+    end_dt = _parse_timestamp(finished_at)
+    if not end_dt and status in {
+        FlowRunStatus.RUNNING.value,
+        FlowRunStatus.PAUSED.value,
+        FlowRunStatus.PENDING.value,
+    }:
+        end_dt = datetime.now(timezone.utc)
+    if not end_dt:
+        return None
+    return (end_dt - start_dt).total_seconds()
+
+
+def _ticket_counts(ticket_dir: Path) -> dict[str, int]:
+    total = 0
+    done = 0
+    for path in list_ticket_paths(ticket_dir):
+        total += 1
+        try:
+            if ticket_is_done(path):
+                done += 1
+        except Exception:
+            # Treat unreadable/invalid tickets as not-done but still count them.
+            continue
+    todo = max(total - done, 0)
+    return {"todo": todo, "done": done, "total": total}
+
+
+def _count_history_dirs(history_dir: Path) -> int:
+    if not history_dir.exists() or not history_dir.is_dir():
+        return 0
+    count = 0
+    try:
+        for child in history_dir.iterdir():
+            try:
+                if child.is_dir() and len(child.name) == 4 and child.name.isdigit():
+                    count += 1
+            except OSError:
+                continue
+    except OSError:
+        return count
+    return count
+
+
+def _build_summary(repo_root: Path) -> Dict[str, Any]:
+    ticket_dir = repo_root / ".codex-autorunner" / "tickets"
+    store = _load_flow_store(repo_root)
+    records: list[FlowRunRecord] = []
+    if store:
+        try:
+            records = store.list_flow_runs(flow_type="ticket_flow")
+        except Exception:
+            records = []
+        finally:
+            try:
+                store.close()
+            except Exception:
+                pass
+
+    run_record = _select_primary_run(records)
+
+    default_run = {
+        "id": None,
+        "short_id": None,
+        "status": "idle",
+        "started_at": None,
+        "finished_at": None,
+        "duration_seconds": None,
+        "current_step": None,
+        "created_at": None,
+    }
+
+    run_data: Dict[str, Any] = default_run
+    turns: Dict[str, Optional[int]] = {
+        "total": None,
+        "current_ticket": None,
+        "dispatches": 0,
+        "replies": 0,
+    }
+    current_ticket: Optional[str] = None
+    agent_id: Optional[str] = None
+
+    if run_record:
+        run_data = {
+            "id": run_record.id,
+            "short_id": run_record.id.split("-")[0] if run_record.id else None,
+            "status": run_record.status.value,
+            "started_at": run_record.started_at,
+            "finished_at": run_record.finished_at,
+            "duration_seconds": _duration_seconds(
+                run_record.started_at, run_record.finished_at, run_record.status.value
+            ),
+            "current_step": run_record.current_step,
+            "created_at": run_record.created_at,
+        }
+
+        state = run_record.state if isinstance(run_record.state, dict) else {}
+        ticket_state = state.get("ticket_engine") if isinstance(state, dict) else {}
+        if isinstance(ticket_state, dict):
+            turns["total"] = ticket_state.get("total_turns")  # type: ignore[index]
+            turns["current_ticket"] = ticket_state.get("ticket_turns")  # type: ignore[index]
+            current_ticket = ticket_state.get("current_ticket")  # type: ignore[assignment]
+            agent_id = ticket_state.get("last_agent_id")  # type: ignore[assignment]
+
+        workspace_value = run_record.input_data.get("workspace_root")
+        workspace_root = Path(workspace_value) if workspace_value else repo_root
+        runs_dir = Path(
+            run_record.input_data.get("runs_dir") or ".codex-autorunner/runs"
+        )
+        outbox_paths = resolve_outbox_paths(
+            workspace_root=workspace_root, runs_dir=runs_dir, run_id=run_record.id
+        )
+        reply_paths = resolve_reply_paths(
+            workspace_root=workspace_root, runs_dir=runs_dir, run_id=run_record.id
+        )
+        turns["dispatches"] = _count_history_dirs(outbox_paths.dispatch_history_dir)
+        turns["replies"] = _count_history_dirs(reply_paths.reply_history_dir)
+
+        # If current ticket is known, read its frontmatter to pick agent id when available.
+        if current_ticket:
+            current_path = (workspace_root / current_ticket).resolve()
+            try:
+                doc, _errors = read_ticket(current_path)
+                if doc and doc.frontmatter and getattr(doc.frontmatter, "agent", None):
+                    agent_id = doc.frontmatter.agent
+            except Exception:
+                pass
+
+    ticket_counts = _ticket_counts(ticket_dir)
+
+    return {
+        "run": run_data,
+        "tickets": {
+            "todo_count": ticket_counts["todo"],
+            "done_count": ticket_counts["done"],
+            "total_count": ticket_counts["total"],
+            "current_ticket": current_ticket,
+        },
+        "turns": {
+            "total": turns.get("total"),
+            "current_ticket": turns.get("current_ticket"),
+            "dispatches": turns.get("dispatches"),
+            "replies": turns.get("replies"),
+        },
+        "agent": {
+            "id": agent_id,
+            "model": None,
+        },
+    }
+
+
+def build_analytics_routes() -> APIRouter:
+    router = APIRouter(prefix="/api/analytics", tags=["analytics"])
+
+    @router.get("/summary")
+    def get_analytics_summary():
+        repo_root = find_repo_root()
+        data = _build_summary(repo_root)
+        return data
+
+    return router
+
+
+__all__ = ["build_analytics_routes"]