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

codex_autorunner/core/app_server_prompts.py

@@ -3,117 +3,31 @@ from __future__ import annotations
 from pathlib import Path
 from typing import Callable, Optional
 
-from .config import (
-    AppServerAutorunnerPromptConfig,
-    AppServerDocChatPromptConfig,
-    AppServerSpecIngestPromptConfig,
-    Config,
-)
+from .config import AppServerAutorunnerPromptConfig, Config
 
 TRUNCATION_MARKER = "...[truncated]"
 
 
-DOC_CHAT_APP_SERVER_TEMPLATE = """You are an autonomous coding assistant helping maintain the work docs for this repository.
-
-Instructions:
-- Use the base doc content below. Drafts (if present) are the authoritative base.
-- You may inspect the repo and update the work docs listed when needed.
-- If you update docs, edit the files directly. If no changes are needed, do not edit files.
-- Respond with a short summary of what you did or found.
-
-Work docs (paths):
-- TODO: {todo_path}
-- PROGRESS: {progress_path}
-- OPINIONS: {opinions_path}
-- SPEC: {spec_path}
-- SUMMARY: {summary_path}
-
-{user_viewing_block}
-
-User request:
-{message}
-
-{docs_context_block}
-{recent_summary_block}
-"""
-
-
-SPEC_INGEST_APP_SERVER_TEMPLATE = """You are preparing work docs (TODO/PROGRESS/OPINIONS) from the SPEC.
-
-SPEC path: {spec_path}
-TODO path: {todo_path}
-PROGRESS path: {progress_path}
-OPINIONS path: {opinions_path}
-
-Instructions:
-- Read the SPEC and existing docs from disk.
-- Edit the TODO, PROGRESS, and OPINIONS files directly to reflect the SPEC.
-- The TODO must be a Markdown checklist. Every task MUST be a checkbox line:
-  - Use `- [ ] <task>` for open items and `- [x] <task>` for completed items.
-  - Do NOT use plain bullets like `- task` or paragraphs for tasks.
-- Do NOT output a patch block. Just edit the files.
-- Output a short summary prefixed with "Agent: " explaining what you did.
-
-User request:
-{message}
-
-{spec_excerpt_block}
-"""
-
-
-SNAPSHOT_APP_SERVER_TEMPLATE = """You are generating a compact Markdown repo snapshot meant to be pasted into another LLM chat.
-
-Snapshot path: {snapshot_path}
-
-Instructions:
-- Analyze the provided context and the repository.
-- Write the snapshot content directly to the snapshot path.
-- Keep the file concise and high-signal.
-
-Required output format (keep headings exactly):
-# Repo Snapshot
-
-## What this repo is
-- 3–6 bullets.
-
-## Architecture overview
-- Components and responsibilities.
-- Data/control flow (high level).
-- How things actually work
-
-## Key files and modules
-- Bullet list of important paths with 1-line notes.
-
-## Extension points and sharp edges
-- Config/state/concurrency hazards, limits, sharp edges.
-
-Inputs:
-{seed_context}
-
-{changes_block}
-{previous_snapshot_block}
-"""
-
-
 AUTORUNNER_APP_SERVER_TEMPLATE = """You are an autonomous coding assistant operating on a git repository.
 
-Work docs (read from disk as needed):
-- TODO: {todo_path}
-- PROGRESS: {progress_path}
-- OPINIONS: {opinions_path}
-- SPEC: {spec_path}
-- SUMMARY: {summary_path}
+Workspace docs (optional; read from disk when useful):
+- Active context: {active_context_path}
+- Decisions: {decisions_path}
+- Spec: {spec_path}
+
+Tickets:
+- The authoritative work items are ticket files under `.codex-autorunner/tickets/`.
+- Pick the next not-done ticket, implement it, and update the ticket file (`done: true`) when complete.
 
 Instructions:
-- Work through TODO items from top to bottom.
-- Prefer fixing issues over documenting them.
-- Keep TODO/PROGRESS/OPINIONS/SPEC/SUMMARY in sync.
-- Make actual edits in the repo as needed.
+- This run is non-interactive. Do not ask the user questions. If unsure, make reasonable assumptions and proceed.
+- Prefer small, safe diffs and keep work focused on the current ticket.
+- You may create new tickets only when needed to break down the current work.
 
 User request:
 {message}
 
-{todo_excerpt_block}
+{workspace_spec_block}
 {prev_run_block}
 """
 
@@ -167,144 +81,6 @@ def _shrink_prompt(
     return prompt
 
 
-def build_doc_chat_prompt(
-    config: Config,
-    *,
-    message: str,
-    recent_summary: Optional[str],
-    docs: dict[str, dict[str, str]],
-    context_doc: Optional[str] = None,
-) -> str:
-    prompt_cfg: AppServerDocChatPromptConfig = config.app_server.prompts.doc_chat
-    doc_paths = {
-        "todo": _display_path(config.root, config.doc_path("todo")),
-        "progress": _display_path(config.root, config.doc_path("progress")),
-        "opinions": _display_path(config.root, config.doc_path("opinions")),
-        "spec": _display_path(config.root, config.doc_path("spec")),
-        "summary": _display_path(config.root, config.doc_path("summary")),
-    }
-    message_text = truncate_text(message, prompt_cfg.message_max_chars)
-    doc_blocks = []
-    for key, path in doc_paths.items():
-        payload = docs.get(key, {})
-        source = payload.get("source") or "disk"
-        content = truncate_text(
-            str(payload.get("content") or ""), prompt_cfg.target_excerpt_max_chars
-        )
-        if not content.strip():
-            content = "(empty)"
-        label = f"{key.upper()} [{path}] ({source.upper()})"
-        doc_blocks.append(f"{label}\n{content}")
-    docs_context = "\n\n".join(doc_blocks)
-    recent_text = truncate_text(
-        recent_summary or "", prompt_cfg.recent_summary_max_chars
-    )
-    user_viewing = ""
-    if context_doc:
-        user_viewing = f"The user is currently looking at {context_doc.upper()}."
-
-    sections = {
-        "message": message_text,
-        "docs_context": docs_context,
-        "recent_summary": recent_text,
-        "user_viewing": user_viewing,
-    }
-
-    def render() -> str:
-        return DOC_CHAT_APP_SERVER_TEMPLATE.format(
-            todo_path=doc_paths["todo"],
-            progress_path=doc_paths["progress"],
-            opinions_path=doc_paths["opinions"],
-            spec_path=doc_paths["spec"],
-            summary_path=doc_paths["summary"],
-            message=sections["message"],
-            user_viewing_block=_optional_block(
-                "USER_VIEWING", sections["user_viewing"]
-            ),
-            docs_context_block=_optional_block("DOC_BASES", sections["docs_context"]),
-            recent_summary_block=_optional_block(
-                "RECENT_RUN_SUMMARY", sections["recent_summary"]
-            ),
-        )
-
-    return _shrink_prompt(
-        max_chars=prompt_cfg.max_chars,
-        render=render,
-        sections=sections,
-        order=["recent_summary", "docs_context", "message"],
-    )
-
-
-def build_spec_ingest_prompt(
-    config: Config,
-    *,
-    message: str,
-    spec_path: Optional[Path] = None,
-) -> str:
-    prompt_cfg: AppServerSpecIngestPromptConfig = config.app_server.prompts.spec_ingest
-    doc_paths = {
-        "todo": _display_path(config.root, config.doc_path("todo")),
-        "progress": _display_path(config.root, config.doc_path("progress")),
-        "opinions": _display_path(config.root, config.doc_path("opinions")),
-    }
-    spec_target = spec_path or config.doc_path("spec")
-    spec_path_str = _display_path(config.root, spec_target)
-    message_text = truncate_text(message, prompt_cfg.message_max_chars)
-    spec_excerpt = truncate_text(
-        spec_target.read_text(encoding="utf-8"),
-        prompt_cfg.spec_excerpt_max_chars,
-    )
-
-    sections = {
-        "message": message_text,
-        "spec_excerpt": spec_excerpt,
-    }
-
-    def render() -> str:
-        return SPEC_INGEST_APP_SERVER_TEMPLATE.format(
-            spec_path=spec_path_str,
-            todo_path=doc_paths["todo"],
-            progress_path=doc_paths["progress"],
-            opinions_path=doc_paths["opinions"],
-            message=sections["message"],
-            spec_excerpt_block=_optional_block(
-                "SPEC_EXCERPT", sections["spec_excerpt"]
-            ),
-        )
-
-    return _shrink_prompt(
-        max_chars=prompt_cfg.max_chars,
-        render=render,
-        sections=sections,
-        order=["spec_excerpt", "message"],
-    )
-
-
-def build_app_server_snapshot_prompt(
-    config: Config,
-    *,
-    seed_context: str,
-    previous_snapshot: Optional[str] = None,
-    changes: Optional[str] = None,
-) -> str:
-    snapshot_path = config.doc_path("snapshot")
-    previous_block = ""
-    if previous_snapshot:
-        previous_block = (
-            f"<PREVIOUS_SNAPSHOT>\n{previous_snapshot.strip()}\n</PREVIOUS_SNAPSHOT>"
-        )
-    changes_block = ""
-    if changes:
-        changes_block = f"<CHANGES_SINCE_LAST_SNAPSHOT>\n{changes.strip()}\n</CHANGES_SINCE_LAST_SNAPSHOT>"
-
-    return SNAPSHOT_APP_SERVER_TEMPLATE.format(
-        snapshot_path=snapshot_path,
-        seed_context=seed_context,
-        changes_block=changes_block,
-        previous_snapshot_block=previous_block,
-    )
-
-
 def build_autorunner_prompt(
     config: Config,
     *,
@@ -313,35 +89,36 @@ def build_autorunner_prompt(
 ) -> str:
     prompt_cfg: AppServerAutorunnerPromptConfig = config.app_server.prompts.autorunner
     doc_paths = {
-        "todo": _display_path(config.root, config.doc_path("todo")),
-        "progress": _display_path(config.root, config.doc_path("progress")),
-        "opinions": _display_path(config.root, config.doc_path("opinions")),
+        "active_context": _display_path(config.root, config.doc_path("active_context")),
+        "decisions": _display_path(config.root, config.doc_path("decisions")),
         "spec": _display_path(config.root, config.doc_path("spec")),
-        "summary": _display_path(config.root, config.doc_path("summary")),
     }
+
     message_text = truncate_text(message, prompt_cfg.message_max_chars)
-    todo_excerpt = truncate_text(
-        config.doc_path("todo").read_text(encoding="utf-8"),
+    spec_excerpt = truncate_text(
+        (
+            config.doc_path("spec").read_text(encoding="utf-8")
+            if config.doc_path("spec").exists()
+            else ""
+        ),
         prompt_cfg.todo_excerpt_max_chars,
     )
     prev_run_text = truncate_text(prev_run_summary or "", prompt_cfg.prev_run_max_chars)
 
     sections = {
         "message": message_text,
-        "todo_excerpt": todo_excerpt,
+        "workspace_spec": spec_excerpt,
         "prev_run": prev_run_text,
     }
 
     def render() -> str:
         return AUTORUNNER_APP_SERVER_TEMPLATE.format(
-            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"],
             message=sections["message"],
-            todo_excerpt_block=_optional_block(
-                "TODO_EXCERPT", sections["todo_excerpt"]
+            workspace_spec_block=_optional_block(
+                "WORKSPACE_SPEC", sections["workspace_spec"]
             ),
             prev_run_block=_optional_block("PREV_RUN_SUMMARY", sections["prev_run"]),
         )
@@ -350,13 +127,11 @@ def build_autorunner_prompt(
         max_chars=prompt_cfg.max_chars,
         render=render,
         sections=sections,
-        order=["prev_run", "todo_excerpt", "message"],
+        order=["prev_run", "workspace_spec", "message"],
     )
 
 
 APP_SERVER_PROMPT_BUILDERS = {
-    "doc_chat": build_doc_chat_prompt,
-    "spec_ingest": build_spec_ingest_prompt,
     "autorunner": build_autorunner_prompt,
 }
 
@@ -364,13 +139,7 @@ APP_SERVER_PROMPT_BUILDERS = {
 __all__ = [
     "AUTORUNNER_APP_SERVER_TEMPLATE",
     "APP_SERVER_PROMPT_BUILDERS",
-    "DOC_CHAT_APP_SERVER_TEMPLATE",
-    "SPEC_INGEST_APP_SERVER_TEMPLATE",
-    "SNAPSHOT_APP_SERVER_TEMPLATE",
     "TRUNCATION_MARKER",
     "build_autorunner_prompt",
-    "build_doc_chat_prompt",
-    "build_spec_ingest_prompt",
-    "build_app_server_snapshot_prompt",
     "truncate_text",
 ]

codex_autorunner/core/app_server_threads.py

@@ -12,19 +12,15 @@ APP_SERVER_THREADS_FILENAME = ".codex-autorunner/app_server_threads.json"
 APP_SERVER_THREADS_VERSION = 1
 APP_SERVER_THREADS_CORRUPT_SUFFIX = ".corrupt"
 APP_SERVER_THREADS_NOTICE_SUFFIX = ".corrupt.json"
-DOC_CHAT_KINDS = ("todo", "progress", "opinions", "spec", "summary")
-DOC_CHAT_PREFIX = "doc_chat."
-DOC_CHAT_KEY = "doc_chat"
-DOC_CHAT_OPENCODE_KEY = "doc_chat.opencode"
-DOC_CHAT_OPENCODE_PREFIX = "doc_chat.opencode."
-DOC_CHAT_KEYS = {DOC_CHAT_KEY} | {f"{DOC_CHAT_PREFIX}{kind}" for kind in DOC_CHAT_KINDS}
-DOC_CHAT_KEYS = DOC_CHAT_KEYS | {
-    DOC_CHAT_OPENCODE_KEY,
-    *(f"{DOC_CHAT_OPENCODE_PREFIX}{kind}" for kind in DOC_CHAT_KINDS),
-}
-FEATURE_KEYS = DOC_CHAT_KEYS | {
-    "spec_ingest",
-    "spec_ingest.opencode",
+FILE_CHAT_KEY = "file_chat"
+FILE_CHAT_OPENCODE_KEY = "file_chat.opencode"
+FILE_CHAT_PREFIX = "file_chat."
+FILE_CHAT_OPENCODE_PREFIX = "file_chat.opencode."
+
+# Static keys that can be reset/managed via the UI.
+FEATURE_KEYS = {
+    FILE_CHAT_KEY,
+    FILE_CHAT_OPENCODE_KEY,
     "autorunner",
     "autorunner.opencode",
 }
@@ -43,6 +39,10 @@ def normalize_feature_key(raw: str) -> str:
     key = key.replace("/", ".").replace(":", ".")
     if key in FEATURE_KEYS:
         return key
+    # Allow per-target file chat threads (e.g. file_chat.ticket.1, file_chat.workspace.spec).
+    for prefix in (FILE_CHAT_PREFIX, FILE_CHAT_OPENCODE_PREFIX):
+        if key.startswith(prefix) and len(key) > len(prefix):
+            return key
     raise ValueError(f"invalid feature key: {raw}")
 
 
@@ -84,20 +84,9 @@ class AppServerThreadRegistry:
 
     def feature_map(self) -> dict[str, object]:
         threads = self.load()
-        doc_chat_thread = threads.get(DOC_CHAT_KEY)
-        doc_chat_opencode_thread = threads.get(DOC_CHAT_OPENCODE_KEY)
         payload: dict[str, object] = {
-            "doc_chat": {
-                kind: doc_chat_thread or threads.get(f"{DOC_CHAT_PREFIX}{kind}")
-                for kind in DOC_CHAT_KINDS
-            },
-            "doc_chat_opencode": {
-                kind: doc_chat_opencode_thread
-                or threads.get(f"{DOC_CHAT_OPENCODE_PREFIX}{kind}")
-                for kind in DOC_CHAT_KINDS
-            },
-            "spec_ingest": threads.get("spec_ingest"),
-            "spec_ingest_opencode": threads.get("spec_ingest.opencode"),
+            "file_chat": threads.get(FILE_CHAT_KEY),
+            "file_chat_opencode": threads.get(FILE_CHAT_OPENCODE_KEY),
             "autorunner": threads.get("autorunner"),
             "autorunner_opencode": threads.get("autorunner.opencode"),
         }

codex_autorunner/core/circuit_breaker.py

@@ -0,0 +1,183 @@
+from __future__ import annotations
+
+import asyncio
+import logging
+from contextlib import asynccontextmanager
+from dataclasses import dataclass
+from datetime import datetime, timedelta
+from enum import Enum
+from typing import AsyncIterator, Optional
+
+from .exceptions import CircuitOpenError
+
+logger = logging.getLogger(__name__)
+
+
+class CircuitState(str, Enum):
+    CLOSED = "closed"
+    OPEN = "open"
+    HALF_OPEN = "half_open"
+
+
+@dataclass
+class CircuitBreakerConfig:
+    """Configuration for circuit breaker behavior."""
+
+    failure_threshold: int = 5
+    """Number of failures before opening circuit."""
+
+    timeout_seconds: int = 60
+    """Seconds to wait before attempting recovery (half-open state)."""
+
+    half_open_attempts: int = 1
+    """Number of successful calls needed to close circuit from half-open state."""
+
+
+@dataclass
+class CircuitBreakerState:
+    """Internal state tracking for circuit breaker."""
+
+    failure_count: int = 0
+    state: CircuitState = CircuitState.CLOSED
+    last_failure_time: Optional[datetime] = None
+    success_count: int = 0
+
+
+class CircuitBreaker:
+    """
+    Circuit breaker pattern implementation for external service resilience.
+
+    Opens after N consecutive failures, closes after success or timeout.
+    Prevents cascading failures and provides fast-fail for degraded services.
+    """
+
+    def __init__(
+        self,
+        service_name: str,
+        *,
+        config: Optional[CircuitBreakerConfig] = None,
+        logger: Optional[logging.Logger] = None,
+    ) -> None:
+        self._service_name = service_name
+        self._config = config or CircuitBreakerConfig()
+        self._logger = logger or logging.getLogger(__name__)
+        self._state = CircuitBreakerState()
+        self._lock = asyncio.Lock()
+
+    @asynccontextmanager
+    async def call(self) -> AsyncIterator[None]:
+        """
+        Context manager that raises CircuitOpenError if circuit is open.
+
+        Tracks failures/successes to manage circuit state transitions.
+
+        Raises:
+            CircuitOpenError: If circuit is open.
+
+        Example:
+            async with circuit_breaker.call():
+                result = await external_service.request()
+        """
+        is_open = False
+        async with self._lock:
+            if self._should_open_circuit():
+                self._open_circuit()
+                is_open = True
+            elif self._should_half_open_circuit():
+                self._half_open_circuit()
+            elif self._state.state == CircuitState.OPEN:
+                is_open = True
+
+        if is_open:
+            raise CircuitOpenError(
+                self._service_name,
+                message=f"Circuit breaker OPEN for {self._service_name}. "
+                f"Last failure: {self._state.last_failure_time}",
+            )
+
+        try:
+            yield
+        except Exception as exc:
+            self._logger.debug(
+                "Exception caught by circuit breaker for %s: %s",
+                self._service_name,
+                exc,
+            )
+            await self._record_failure()
+            raise
+        else:
+            await self._record_success()
+
+    def _should_open_circuit(self) -> bool:
+        """Check if circuit should open based on failure count."""
+        return (
+            self._state.state == CircuitState.CLOSED
+            and self._state.failure_count >= self._config.failure_threshold
+        )
+
+    def _should_half_open_circuit(self) -> bool:
+        """Check if circuit should transition to half-open state."""
+        if self._state.state != CircuitState.OPEN:
+            return False
+        if self._state.last_failure_time is None:
+            return False
+        return datetime.utcnow() >= self._state.last_failure_time + timedelta(
+            seconds=self._config.timeout_seconds
+        )
+
+    def _open_circuit(self) -> None:
+        """Open circuit and log the transition."""
+        self._state.state = CircuitState.OPEN
+        self._state.last_failure_time = datetime.utcnow()
+        self._logger.warning(
+            "Circuit breaker OPEN for %s after %d failures",
+            self._service_name,
+            self._state.failure_count,
+        )
+
+    def _half_open_circuit(self) -> None:
+        """Transition to half-open state and allow one test call."""
+        self._state.state = CircuitState.HALF_OPEN
+        self._state.success_count = 0
+        self._logger.info(
+            "Circuit breaker HALF_OPEN for %s (testing recovery)",
+            self._service_name,
+        )
+
+    async def _record_failure(self) -> None:
+        """Record a failure and update state accordingly."""
+        async with self._lock:
+            self._state.failure_count += 1
+            self._state.last_failure_time = datetime.utcnow()
+
+            if self._state.state == CircuitState.HALF_OPEN:
+                self._state.state = CircuitState.OPEN
+                self._logger.warning(
+                    "Circuit breaker OPEN for %s (failure in half-open state)",
+                    self._service_name,
+                )
+            elif self._state.state == CircuitState.CLOSED:
+                self._logger.debug(
+                    "Circuit breaker recorded failure for %s (count: %d/%d)",
+                    self._service_name,
+                    self._state.failure_count,
+                    self._config.failure_threshold,
+                )
+
+    async def _record_success(self) -> None:
+        """Record a success and update state accordingly."""
+        async with self._lock:
+            if self._state.state == CircuitState.CLOSED:
+                self._state.failure_count = 0
+            elif self._state.state == CircuitState.HALF_OPEN:
+                self._state.success_count += 1
+                if self._state.success_count >= self._config.half_open_attempts:
+                    self._state.state = CircuitState.CLOSED
+                    self._state.failure_count = 0
+                    self._state.success_count = 0
+                    self._logger.info(
+                        "Circuit breaker CLOSED for %s (recovery successful)",
+                        self._service_name,
+                    )
+            else:
+                pass

codex_autorunner/core/codex_runner.py

@@ -1,3 +1,9 @@
+# DEPRECATED: This module implements a Codex CLI subprocess runner.
+# The primary execution path now uses the Codex app-server via OpenCode runtime.
+# This file is kept for potential future CLI-as-backend support but is currently
+# not referenced by the main engine. See src/codex_autorunner/core/engine.py for
+# the current execution path (_run_codex_app_server_async).
+
 import asyncio
 import subprocess
 from pathlib import Path