codex-autorunner 0.1.0__py3-none-any.whl

codex_autorunner/routes/docs.py

@@ -0,0 +1,275 @@
+"""
+Document management routes: read/write docs and chat functionality.
+"""
+
+import asyncio
+from pathlib import Path
+from typing import Optional
+
+from fastapi import APIRouter, HTTPException, Request
+from fastapi.responses import StreamingResponse
+
+from ..core.doc_chat import (
+    DocChatBusyError,
+    DocChatError,
+    DocChatValidationError,
+    _normalize_kind,
+)
+from ..core.snapshot import (
+    SnapshotError,
+    generate_snapshot,
+    load_snapshot,
+    load_snapshot_state,
+)
+from ..core.usage import (
+    UsageError,
+    default_codex_home,
+    get_repo_usage_series_cached,
+    get_repo_usage_summary_cached,
+    parse_iso_datetime,
+)
+from ..core.utils import atomic_write
+from ..spec_ingest import (
+    SpecIngestError,
+    clear_work_docs,
+    generate_docs_from_spec,
+    write_ingested_docs,
+)
+from ..web.schemas import (
+    DocChatPayload,
+    DocContentRequest,
+    DocsResponse,
+    DocWriteResponse,
+    IngestSpecRequest,
+    RepoUsageResponse,
+    SnapshotCreateResponse,
+    SnapshotRequest,
+    SnapshotResponse,
+    UsageSeriesResponse,
+)
+
+
+def build_docs_routes() -> APIRouter:
+    """Build routes for document management and chat."""
+    router = APIRouter()
+
+    @router.get("/api/docs", response_model=DocsResponse)
+    def get_docs(request: Request):
+        engine = request.app.state.engine
+        return {
+            "todo": engine.docs.read_doc("todo"),
+            "progress": engine.docs.read_doc("progress"),
+            "opinions": engine.docs.read_doc("opinions"),
+            "spec": engine.docs.read_doc("spec"),
+            "summary": engine.docs.read_doc("summary"),
+        }
+
+    @router.put("/api/docs/{kind}", response_model=DocWriteResponse)
+    def put_doc(kind: str, payload: DocContentRequest, request: Request):
+        engine = request.app.state.engine
+        key = kind.lower()
+        if key not in ("todo", "progress", "opinions", "spec", "summary"):
+            raise HTTPException(status_code=400, detail="invalid doc kind")
+        content = payload.content
+        atomic_write(engine.config.doc_path(key), content)
+        return {"kind": key, "content": content}
+
+    @router.get("/api/snapshot", response_model=SnapshotResponse)
+    def get_snapshot(request: Request):
+        engine = request.app.state.engine
+        content = load_snapshot(engine)
+        state = load_snapshot_state(engine)
+        return {"exists": bool(content), "content": content or "", "state": state or {}}
+
+    @router.post("/api/snapshot", response_model=SnapshotCreateResponse)
+    async def post_snapshot(
+        request: Request, payload: Optional[SnapshotRequest] = None
+    ):
+        # Snapshot generation has a single default behavior now; we accept an
+        # optional JSON object for backwards compatibility, but ignore any fields.
+        engine = request.app.state.engine
+        try:
+            result = await asyncio.to_thread(
+                generate_snapshot,
+                engine,
+            )
+        except SnapshotError as exc:
+            raise HTTPException(status_code=400, detail=str(exc)) from exc
+        except Exception as exc:
+            raise HTTPException(status_code=500, detail=str(exc)) from exc
+
+        return {
+            "content": result.content,
+            "truncated": result.truncated,
+            "state": result.state,
+        }
+
+    @router.post("/api/docs/{kind}/chat")
+    async def chat_doc(
+        kind: str, request: Request, payload: Optional[DocChatPayload] = None
+    ):
+        doc_chat = request.app.state.doc_chat
+        try:
+            payload_dict = payload.model_dump(exclude_none=True) if payload else None
+            doc_req = doc_chat.parse_request(kind, payload_dict)
+        except DocChatValidationError as exc:
+            raise HTTPException(status_code=400, detail=str(exc)) from exc
+
+        repo_blocked = doc_chat.repo_blocked_reason()
+        if repo_blocked:
+            raise HTTPException(status_code=409, detail=repo_blocked)
+
+        if doc_chat.doc_busy(doc_req.kind):
+            raise HTTPException(
+                status_code=409,
+                detail=f"Doc chat already running for {doc_req.kind}",
+            )
+
+        if doc_req.stream:
+            return StreamingResponse(
+                doc_chat.stream(doc_req), media_type="text/event-stream"
+            )
+
+        try:
+            async with doc_chat.doc_lock(doc_req.kind):
+                result = await doc_chat.execute(doc_req)
+        except DocChatBusyError as exc:
+            raise HTTPException(status_code=409, detail=str(exc)) from exc
+
+        if result.get("status") != "ok":
+            detail = result.get("detail") or "Doc chat failed"
+            raise HTTPException(status_code=500, detail=detail)
+        return result
+
+    @router.post("/api/docs/{kind}/chat/apply")
+    async def apply_chat_patch(kind: str, request: Request):
+        doc_chat = request.app.state.doc_chat
+        key = _normalize_kind(kind)
+        repo_blocked = doc_chat.repo_blocked_reason()
+        if repo_blocked:
+            raise HTTPException(status_code=409, detail=repo_blocked)
+
+        try:
+            async with doc_chat.doc_lock(key):
+                content = doc_chat.apply_saved_patch(key)
+        except DocChatBusyError as exc:
+            raise HTTPException(status_code=409, detail=str(exc)) from exc
+        except DocChatError as exc:
+            raise HTTPException(status_code=500, detail=str(exc)) from exc
+        return {
+            "status": "ok",
+            "kind": key,
+            "content": content,
+            "agent_message": doc_chat.last_agent_message
+            or f"Updated {key.upper()} via doc chat.",
+        }
+
+    @router.post("/api/docs/{kind}/chat/discard")
+    async def discard_chat_patch(kind: str, request: Request):
+        doc_chat = request.app.state.doc_chat
+        key = _normalize_kind(kind)
+        try:
+            async with doc_chat.doc_lock(key):
+                content = doc_chat.discard_patch(key)
+        except DocChatError as exc:
+            raise HTTPException(status_code=500, detail=str(exc)) from exc
+        return {"status": "ok", "kind": key, "content": content}
+
+    @router.get("/api/docs/{kind}/chat/pending")
+    async def pending_chat_patch(kind: str, request: Request):
+        doc_chat = request.app.state.doc_chat
+        key = _normalize_kind(kind)
+        pending = doc_chat.pending_patch(key)
+        if not pending:
+            raise HTTPException(status_code=404, detail="No pending patch")
+        return pending
+
+    @router.post("/api/ingest-spec", response_model=DocsResponse)
+    def ingest_spec(request: Request, payload: Optional[IngestSpecRequest] = None):
+        engine = request.app.state.engine
+        force = False
+        spec_override: Optional[Path] = None
+        if payload:
+            force = payload.force
+            if payload.spec_path:
+                spec_override = Path(str(payload.spec_path))
+        try:
+            docs = generate_docs_from_spec(engine, spec_path=spec_override)
+            write_ingested_docs(engine, docs, force=force)
+        except SpecIngestError as exc:
+            raise HTTPException(status_code=400, detail=str(exc)) from exc
+        return docs
+
+    @router.post("/api/docs/clear", response_model=DocsResponse)
+    def clear_docs(request: Request):
+        engine = request.app.state.engine
+        try:
+            docs = clear_work_docs(engine)
+            docs["spec"] = engine.docs.read_doc("spec")
+            docs["summary"] = engine.docs.read_doc("summary")
+        except Exception as exc:
+            raise HTTPException(status_code=500, detail=str(exc)) from exc
+        return docs
+
+    @router.get("/api/usage", response_model=RepoUsageResponse)
+    def get_usage(
+        request: Request, since: Optional[str] = None, until: Optional[str] = None
+    ):
+        engine = request.app.state.engine
+        try:
+            since_dt = parse_iso_datetime(since)
+            until_dt = parse_iso_datetime(until)
+        except UsageError as exc:
+            raise HTTPException(status_code=400, detail=str(exc)) from exc
+        summary, status = get_repo_usage_summary_cached(
+            engine.repo_root,
+            default_codex_home(),
+            since=since_dt,
+            until=until_dt,
+        )
+        return {
+            "mode": "repo",
+            "repo": str(engine.repo_root),
+            "codex_home": str(default_codex_home()),
+            "since": since,
+            "until": until,
+            "status": status,
+            **summary.to_dict(),
+        }
+
+    @router.get("/api/usage/series", response_model=UsageSeriesResponse)
+    def get_usage_series(
+        request: Request,
+        since: Optional[str] = None,
+        until: Optional[str] = None,
+        bucket: str = "day",
+        segment: str = "none",
+    ):
+        engine = request.app.state.engine
+        try:
+            since_dt = parse_iso_datetime(since)
+            until_dt = parse_iso_datetime(until)
+        except UsageError as exc:
+            raise HTTPException(status_code=400, detail=str(exc)) from exc
+        try:
+            series, status = get_repo_usage_series_cached(
+                engine.repo_root,
+                default_codex_home(),
+                since=since_dt,
+                until=until_dt,
+                bucket=bucket,
+                segment=segment,
+            )
+        except UsageError as exc:
+            raise HTTPException(status_code=400, detail=str(exc)) from exc
+        return {
+            "mode": "repo",
+            "repo": str(engine.repo_root),
+            "codex_home": str(default_codex_home()),
+            "since": since,
+            "until": until,
+            "status": status,
+            **series,
+        }
+
+    return router

codex_autorunner/routes/github.py

@@ -0,0 +1,197 @@
+"""
+GitHub integration routes.
+"""
+
+import asyncio
+import time
+from typing import Any, Dict, Optional, Tuple
+
+from fastapi import APIRouter, HTTPException, Request
+
+from ..integrations.github.service import GitHubError, GitHubService
+from ..web.schemas import GithubContextRequest, GithubIssueRequest, GithubPrSyncRequest
+
+_GITHUB_CACHE: Dict[Tuple[str, str], Dict[str, Any]] = {}
+_GITHUB_CACHE_LOCK = asyncio.Lock()
+_GITHUB_STATUS_TTL_SECONDS = 20.0
+_GITHUB_PR_TTL_SECONDS = 60.0
+
+
+async def _get_cached_status_payload(
+    request: Request,
+    *,
+    kind: str,
+    ttl_seconds: float,
+) -> dict:
+    repo_root = request.app.state.engine.repo_root.resolve()
+    key = (str(repo_root), kind)
+    now = time.monotonic()
+    task: Optional[asyncio.Task] = None
+
+    async with _GITHUB_CACHE_LOCK:
+        entry = _GITHUB_CACHE.get(key) or {}
+        value = entry.get("value")
+        expires_at = float(entry.get("expires_at", 0) or 0)
+        task = entry.get("task")
+
+        if value is not None and expires_at > now:
+            return value
+        if task is None:
+            task = asyncio.create_task(
+                asyncio.to_thread(_github(request).status_payload)
+            )
+            _GITHUB_CACHE[key] = {
+                "value": value,
+                "expires_at": expires_at,
+                "task": task,
+            }
+
+    if task is None:
+        task = asyncio.create_task(asyncio.to_thread(_github(request).status_payload))
+        async with _GITHUB_CACHE_LOCK:
+            _GITHUB_CACHE[key] = {"task": task}
+
+    try:
+        value = await task
+    except Exception:
+        async with _GITHUB_CACHE_LOCK:
+            current = _GITHUB_CACHE.get(key) or {}
+            if current.get("task") is task:
+                _GITHUB_CACHE.pop(key, None)
+        raise
+
+    async with _GITHUB_CACHE_LOCK:
+        _GITHUB_CACHE[key] = {
+            "value": value,
+            "expires_at": now + ttl_seconds,
+        }
+    return value
+
+
+def _github(request) -> GitHubService:
+    """Get a GitHubService instance from the request."""
+    engine = request.app.state.engine
+    return GitHubService(engine.repo_root, raw_config=engine.config.raw)
+
+
+def build_github_routes() -> APIRouter:
+    """Build routes for GitHub integration."""
+    router = APIRouter()
+
+    @router.get("/api/github/status")
+    async def github_status(request: Request):
+        try:
+            return await _get_cached_status_payload(
+                request,
+                kind="status",
+                ttl_seconds=_GITHUB_STATUS_TTL_SECONDS,
+            )
+        except GitHubError as exc:
+            raise HTTPException(status_code=exc.status_code, detail=str(exc)) from exc
+        except Exception as exc:
+            raise HTTPException(status_code=500, detail=str(exc)) from exc
+
+    @router.get("/api/github/pr")
+    async def github_pr(request: Request):
+        try:
+            status = await _get_cached_status_payload(
+                request,
+                kind="pr",
+                ttl_seconds=_GITHUB_PR_TTL_SECONDS,
+            )
+            return {
+                "status": "ok",
+                "git": status.get("git"),
+                "pr": status.get("pr"),
+                "links": status.get("pr_links"),
+                "link": status.get("link") or {},
+            }
+        except GitHubError as exc:
+            raise HTTPException(status_code=exc.status_code, detail=str(exc)) from exc
+        except Exception as exc:
+            raise HTTPException(status_code=500, detail=str(exc)) from exc
+
+    @router.post("/api/github/link-issue")
+    async def github_link_issue(request: Request, payload: GithubIssueRequest):
+        issue = payload.issue
+        try:
+            state = await asyncio.to_thread(_github(request).link_issue, str(issue))
+            return {"status": "ok", "link": state}
+        except GitHubError as exc:
+            raise HTTPException(status_code=exc.status_code, detail=str(exc)) from exc
+        except Exception as exc:
+            raise HTTPException(status_code=500, detail=str(exc)) from exc
+
+    @router.post("/api/github/spec/from-issue")
+    async def github_spec_from_issue(request: Request, payload: GithubIssueRequest):
+        issue = payload.issue
+
+        doc_chat = request.app.state.doc_chat
+        repo_blocked = doc_chat.repo_blocked_reason()
+        if repo_blocked:
+            raise HTTPException(status_code=409, detail=repo_blocked)
+        if doc_chat.doc_busy("spec"):
+            raise HTTPException(
+                status_code=409, detail="Doc chat already running for spec"
+            )
+
+        svc = _github(request)
+        try:
+            prompt, link_state = await asyncio.to_thread(
+                svc.build_spec_prompt_from_issue, str(issue)
+            )
+            doc_req = doc_chat.parse_request(
+                "spec", {"message": prompt, "stream": False}
+            )
+            async with doc_chat.doc_lock("spec"):
+                result = await doc_chat.execute(doc_req)
+            if result.get("status") != "ok":
+                detail = result.get("detail") or "SPEC generation failed"
+                raise HTTPException(status_code=500, detail=detail)
+            result["github"] = {"issue": link_state.get("issue")}
+            return result
+        except GitHubError as exc:
+            raise HTTPException(status_code=exc.status_code, detail=str(exc)) from exc
+        except HTTPException:
+            raise
+        except Exception as exc:
+            raise HTTPException(status_code=500, detail=str(exc)) from exc
+
+    @router.post("/api/github/pr/sync")
+    async def github_pr_sync(request: Request, payload: GithubPrSyncRequest):
+        if payload.mode is not None:
+            raise HTTPException(
+                status_code=400,
+                detail="Repo mode does not support worktrees; create a hub worktree repo instead.",
+            )
+        draft = payload.draft
+        title = payload.title
+        body = payload.body
+        try:
+            return await asyncio.to_thread(
+                _github(request).sync_pr,
+                draft=draft,
+                title=str(title) if title else None,
+                body=str(body) if body else None,
+            )
+        except GitHubError as exc:
+            raise HTTPException(status_code=exc.status_code, detail=str(exc)) from exc
+        except Exception as exc:
+            raise HTTPException(status_code=500, detail=str(exc)) from exc
+
+    @router.post("/api/github/context")
+    async def github_context(request: Request, payload: GithubContextRequest):
+        url = payload.url
+        try:
+            result = await asyncio.to_thread(
+                _github(request).build_context_file_from_url, str(url)
+            )
+            if not result:
+                return {"status": "ok", "injected": False}
+            return {"status": "ok", "injected": True, **result}
+        except GitHubError as exc:
+            raise HTTPException(status_code=exc.status_code, detail=str(exc)) from exc
+        except Exception as exc:
+            raise HTTPException(status_code=500, detail=str(exc)) from exc
+
+    return router

codex_autorunner/routes/repos.py

@@ -0,0 +1,121 @@
+"""
+Repository run control routes: start, stop, resume, reset, kill.
+"""
+
+from typing import Optional
+
+from fastapi import APIRouter, HTTPException, Request
+
+from ..core.engine import LockError, clear_stale_lock
+from ..core.state import RunnerState, load_state, now_iso, save_state, state_lock
+from ..web.schemas import (
+    RunControlRequest,
+    RunControlResponse,
+    RunResetResponse,
+    RunStatusResponse,
+)
+
+
+def build_repos_routes() -> APIRouter:
+    """Build routes for run control."""
+    router = APIRouter()
+
+    @router.post("/api/run/start", response_model=RunControlResponse)
+    def start_run(request: Request, payload: Optional[RunControlRequest] = None):
+        manager = request.app.state.manager
+        logger = request.app.state.logger
+        once = payload.once if payload else False
+        try:
+            logger.info("run/start once=%s", once)
+        except Exception:
+            pass
+        try:
+            manager.start(once=once)
+        except LockError as exc:
+            raise HTTPException(status_code=409, detail=str(exc)) from exc
+        return {"running": manager.running, "once": once}
+
+    @router.post("/api/run/stop", response_model=RunStatusResponse)
+    def stop_run(request: Request):
+        manager = request.app.state.manager
+        logger = request.app.state.logger
+        try:
+            logger.info("run/stop requested")
+        except Exception:
+            pass
+        manager.stop()
+        return {"running": manager.running}
+
+    @router.post("/api/run/kill", response_model=RunStatusResponse)
+    def kill_run(request: Request):
+        engine = request.app.state.engine
+        manager = request.app.state.manager
+        logger = request.app.state.logger
+        try:
+            logger.info("run/kill requested")
+        except Exception:
+            pass
+        manager.kill()
+        with state_lock(engine.state_path):
+            state = load_state(engine.state_path)
+            new_state = RunnerState(
+                last_run_id=state.last_run_id,
+                status="error",
+                last_exit_code=137,
+                last_run_started_at=state.last_run_started_at,
+                last_run_finished_at=now_iso(),
+                runner_pid=None,
+                sessions=state.sessions,
+                repo_to_session=state.repo_to_session,
+            )
+            save_state(engine.state_path, new_state)
+        clear_stale_lock(engine.lock_path)
+        return {"running": manager.running}
+
+    @router.post("/api/run/resume", response_model=RunControlResponse)
+    def resume_run(request: Request, payload: Optional[RunControlRequest] = None):
+        manager = request.app.state.manager
+        logger = request.app.state.logger
+        once = payload.once if payload else False
+        try:
+            logger.info("run/resume once=%s", once)
+        except Exception:
+            pass
+        try:
+            manager.resume(once=once)
+        except LockError as exc:
+            raise HTTPException(status_code=409, detail=str(exc)) from exc
+        return {"running": manager.running, "once": once}
+
+    @router.post("/api/run/reset", response_model=RunResetResponse)
+    def reset_runner(request: Request):
+        engine = request.app.state.engine
+        manager = request.app.state.manager
+        logger = request.app.state.logger
+        if manager.running:
+            raise HTTPException(
+                status_code=409, detail="Cannot reset while runner is active"
+            )
+        try:
+            logger.info("run/reset requested")
+        except Exception:
+            pass
+        with state_lock(engine.state_path):
+            current_state = load_state(engine.state_path)
+            engine.lock_path.unlink(missing_ok=True)
+            initial_state = RunnerState(
+                last_run_id=None,
+                status="idle",
+                last_exit_code=None,
+                last_run_started_at=None,
+                last_run_finished_at=None,
+                runner_pid=None,
+                sessions=current_state.sessions,
+                repo_to_session=current_state.repo_to_session,
+            )
+            save_state(engine.state_path, initial_state)
+        if engine.log_path.exists():
+            engine.log_path.unlink()
+        return {"status": "ok", "message": "Runner reset complete"}
+
+    return router