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

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"]

codex_autorunner/routes/base.py

@@ -1,5 +1,5 @@
 """
-Base routes: Index, state streaming, WebSocket terminal, and logs.
+Base routes: Index, WebSocket terminal.
 """
 
 import asyncio
@@ -14,142 +14,94 @@ from fastapi import APIRouter, HTTPException, Request, WebSocket, WebSocketDisco
 from fastapi.responses import (
     HTMLResponse,
     JSONResponse,
-    PlainTextResponse,
-    StreamingResponse,
 )
 
-from ..codex_cli import extract_flag_value
+from ..core.config import HubConfig
 from ..core.logging_utils import safe_log
-from ..core.state import SessionRecord, load_state, now_iso, persist_session_registry
+from ..core.state import SessionRecord, now_iso, persist_session_registry
 from ..web.pty_session import REPLAY_END, ActiveSession, PTYSession
-from ..web.schemas import StateResponse, VersionResponse
+from ..web.schemas import VersionResponse
 from ..web.static_assets import index_response_headers, render_index_html
 from ..web.static_refresh import refresh_static_assets
 from .shared import (
-    SSE_HEADERS,
     build_codex_terminal_cmd,
     build_opencode_terminal_cmd,
-    log_stream,
-    resolve_lock_payload,
-    resolve_runner_status,
-    state_stream,
 )
 
 ALT_SCREEN_ENTER = b"\x1b[?1049h"
 
 
+def _serve_index(request: Request, static_dir: Path):
+    active_static = getattr(request.app.state, "static_dir", static_dir)
+    index_path = active_static / "index.html"
+    if not index_path.exists():
+        if refresh_static_assets(request.app):
+            active_static = request.app.state.static_dir
+            index_path = active_static / "index.html"
+    if not index_path.exists():
+        raise HTTPException(
+            status_code=500, detail="Static UI assets missing; reinstall package"
+        )
+    html = render_index_html(active_static, request.app.state.asset_version)
+    return HTMLResponse(html, headers=index_response_headers())
+
+
 def build_base_routes(static_dir: Path) -> APIRouter:
     """Build routes for index, state, logs, and terminal WebSocket."""
     router = APIRouter()
 
     @router.get("/", include_in_schema=False)
     def index(request: Request):
-        active_static = getattr(request.app.state, "static_dir", static_dir)
-        index_path = active_static / "index.html"
-        if not index_path.exists():
-            if refresh_static_assets(request.app):
-                active_static = request.app.state.static_dir
-                index_path = active_static / "index.html"
-        if not index_path.exists():
-            raise HTTPException(
-                status_code=500, detail="Static UI assets missing; reinstall package"
-            )
-        html = render_index_html(active_static, request.app.state.asset_version)
-        return HTMLResponse(html, headers=index_response_headers())
-
-    @router.get("/api/state", response_model=StateResponse)
-    def get_state(request: Request):
-        engine = request.app.state.engine
-        config = request.app.state.config
-        state = load_state(engine.state_path)
-        outstanding, done = engine.docs.todos()
-        status, runner_pid, running = resolve_runner_status(engine, state)
-        lock_payload = resolve_lock_payload(engine)
-        codex_model = config.codex_model or extract_flag_value(
-            config.codex_args, "--model"
-        )
-        return {
-            "last_run_id": state.last_run_id,
-            "status": status,
-            "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,
-            "outstanding_count": len(outstanding),
-            "done_count": len(done),
-            "running": running,
-            "runner_pid": runner_pid,
-            **lock_payload,
-            "terminal_idle_timeout_seconds": config.terminal_idle_timeout_seconds,
-            "codex_model": codex_model or "auto",
-        }
+        return _serve_index(request, static_dir)
 
     @router.get("/api/version", response_model=VersionResponse)
     def get_version(request: Request):
         return {"asset_version": request.app.state.asset_version}
 
-    @router.get("/api/state/stream")
-    async def stream_state_endpoint(request: Request):
-        engine = request.app.state.engine
-        manager = request.app.state.manager
-        shutdown_event = getattr(request.app.state, "shutdown_event", None)
-        return StreamingResponse(
-            state_stream(
-                engine,
-                manager,
-                logger=request.app.state.logger,
-                shutdown_event=shutdown_event,
-                max_seconds=60.0,
-            ),
-            media_type="text/event-stream",
-            headers=SSE_HEADERS,
-        )
+    @router.get("/api/repo/health")
+    def repo_health(request: Request):
+        config = getattr(request.app.state, "config", None)
+        if isinstance(config, HubConfig):
+            raise HTTPException(
+                status_code=404, detail="Repo health not available in hub mode"
+            )
+
+        engine = getattr(request.app.state, "engine", None)
+        repo_root = getattr(engine, "repo_root", None)
+        if repo_root is None:
+            return JSONResponse(
+                {"status": "error", "detail": "Repo context unavailable"},
+                status_code=503,
+            )
 
-    @router.get("/api/logs")
-    def get_logs(
-        request: Request,
-        run_id: Optional[int] = None,
-        tail: Optional[int] = None,
-        raw: bool = False,
-    ):
-        engine = request.app.state.engine
-
-        def _build_response(
-            text: str, *, run_id: Optional[int] = None, tail: Optional[int] = None
-        ):
-            if raw:
-                return PlainTextResponse(text or "")
-            payload = {"log": text or ""}
-            if run_id is not None:
-                payload["run_id"] = run_id
-            if tail is not None:
-                payload["tail"] = tail
-            return JSONResponse(payload)
-
-        if run_id is not None:
-            block = engine.read_run_block(run_id)
-            if not block:
-                raise HTTPException(status_code=404, detail="run not found")
-            return _build_response(block, run_id=run_id)
-        if tail is not None:
-            return _build_response(engine.tail_log(tail), tail=tail)
-        state = load_state(engine.state_path)
-        if state.last_run_id is None:
-            return _build_response("")
-        block = engine.read_run_block(state.last_run_id) or ""
-        return _build_response(block, run_id=state.last_run_id)
-
-    @router.get("/api/logs/stream")
-    async def stream_logs_endpoint(request: Request):
-        engine = request.app.state.engine
-        shutdown_event = getattr(request.app.state, "shutdown_event", None)
-        return StreamingResponse(
-            log_stream(
-                engine.log_path, shutdown_event=shutdown_event, max_seconds=60.0
-            ),
-            media_type="text/event-stream",
-            headers=SSE_HEADERS,
+        flows_db = repo_root / ".codex-autorunner" / "flows.db"
+
+        docs_dir = repo_root / ".codex-autorunner"
+        docs_status = "ok" if docs_dir.exists() else "missing"
+
+        tickets_dir = repo_root / ".codex-autorunner" / "tickets"
+        tickets_status = "ok" if tickets_dir.exists() else "missing"
+
+        flows_status = "ok" if tickets_dir.exists() else "missing"
+        flows_detail = None
+
+        overall_status = (
+            "ok" if docs_status == "ok" and tickets_status == "ok" else "degraded"
         )
 
+        return {
+            "status": overall_status,
+            "mode": "repo",
+            "repo_root": str(repo_root),
+            "flows": {
+                "status": flows_status,
+                "path": str(flows_db),
+                "detail": flows_detail,
+            },
+            "docs": {"status": docs_status, "path": str(docs_dir)},
+            "tickets": {"status": tickets_status, "path": str(tickets_dir)},
+        }
+
     @router.websocket("/api/terminal")
     async def terminal(ws: WebSocket):
         selected_protocol = None
@@ -623,3 +575,23 @@ def build_base_routes(static_dir: Path) -> APIRouter:
                 active_websockets.discard(ws)
 
     return router
+
+
+def build_frontend_routes(static_dir: Path) -> APIRouter:
+    """Build catch-all routes for frontend tabs."""
+    router = APIRouter()
+
+    @router.get("/{tab}", include_in_schema=False)
+    def tab_route(tab: str, request: Request):
+        if tab in {
+            "workspace",
+            "tickets",
+            "messages",
+            "analytics",
+            "terminal",
+            "settings",
+        }:
+            return _serve_index(request, static_dir)
+        raise HTTPException(status_code=404, detail="Not Found")
+
+    return router