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

codex_autorunner/core/usage.py

@@ -522,8 +522,35 @@ def summarize_hub_usage(
                 return repo_id
         return None
 
+    base_repo_ids = sorted(
+        {repo_id for repo_id, _ in repo_map}, key=lambda rid: (-len(rid), rid)
+    )
+
+    def _heuristic_match_base(cwd: Optional[Path]) -> Optional[str]:
+        if not cwd:
+            return None
+        for repo_id in base_repo_ids:
+            prefix = f"{repo_id}--"
+            if cwd.name.startswith(prefix):
+                logger.debug(
+                    "Heuristic matched cwd %s to base %s via name", cwd, repo_id
+                )
+                return repo_id
+            for part in cwd.parts:
+                if part.startswith(prefix):
+                    logger.debug(
+                        "Heuristic matched cwd %s to base %s via path part %s",
+                        cwd,
+                        repo_id,
+                        part,
+                    )
+                    return repo_id
+        return None
+
     for event in iter_token_events(codex_home, since=since, until=until):
         repo_id = _match_repo(event.cwd)
+        if repo_id is None:
+            repo_id = _heuristic_match_base(event.cwd)
         if repo_id is None:
             unmatched.totals.add(event.delta)
             unmatched.events += 1
@@ -540,6 +567,8 @@ def summarize_hub_usage(
         [path for _, path in repo_map], since=since, until=until
     ):
         repo_id = _match_repo(event.cwd)
+        if repo_id is None:
+            repo_id = _heuristic_match_base(event.cwd)
         if repo_id is None:
             continue
         summary = per_repo[repo_id]
@@ -1323,6 +1352,31 @@ class UsageSeriesCache:
                     return repo_id
             return None
 
+        base_repo_ids = sorted(
+            {repo_id for repo_id, _ in repo_map}, key=lambda rid: (-len(rid), rid)
+        )
+
+        def _heuristic_match_base(cwd: Optional[Path]) -> Optional[str]:
+            if not cwd:
+                return None
+            for repo_id in base_repo_ids:
+                prefix = f"{repo_id}--"
+                if cwd.name.startswith(prefix):
+                    logger.debug(
+                        "Heuristic matched cwd %s to base %s via name", cwd, repo_id
+                    )
+                    return repo_id
+                for part in cwd.parts:
+                    if part.startswith(prefix):
+                        logger.debug(
+                            "Heuristic matched cwd %s to base %s via path part %s",
+                            cwd,
+                            repo_id,
+                            part,
+                        )
+                        return repo_id
+            return None
+
         rollups = cast(Dict[str, Any], payload.get("summary", {}).get("by_cwd", {}))
         per_repo: Dict[str, _SummaryAccumulator] = {
             repo_id: _SummaryAccumulator() for repo_id, _ in repo_map
@@ -1336,6 +1390,8 @@ class UsageSeriesCache:
                 logger.debug("Failed to create Path from cwd %r: %s", cwd, exc)
                 cwd_path = None
             repo_id = _match_repo(cwd_path)
+            if repo_id is None:
+                repo_id = _heuristic_match_base(cwd_path)
             if repo_id is None:
                 unmatched.add_entry(entry)
             else:
@@ -1513,7 +1569,8 @@ class UsageSeriesCache:
         }
 
 
-_USAGE_SERIES_CACHES: Dict[str, UsageSeriesCache] = {}
+_USAGE_SERIES_CACHES: Dict[Tuple[str, str], UsageSeriesCache] = {}
+_REPO_USAGE_CACHE_MIGRATED: set[str] = set()
 
 
 def _build_series_entries(
@@ -1781,9 +1838,80 @@ def _build_hub_opencode_series(
     }
 
 
-def get_usage_series_cache(codex_home: Path) -> UsageSeriesCache:
-    cache_path = _default_usage_series_cache_path(codex_home)
-    key = str(cache_path)
+def _resolve_usage_cache_paths(
+    *,
+    config: Optional[Any] = None,
+    repo_root: Optional[Path] = None,
+    codex_home: Optional[Path] = None,
+) -> Tuple[Path, Path, str, Path]:
+    codex_root = (codex_home or default_codex_home()).expanduser()
+    cache_scope = "global"
+    cache_path = _default_usage_series_cache_path(codex_root)
+    global_cache_root = codex_root
+    usage_cfg: Optional[Any] = None
+    if config is not None:
+        usage_cfg = getattr(config, "usage", None)
+        if usage_cfg is None:
+            raw = getattr(config, "raw", None)
+            if isinstance(raw, dict):
+                usage_cfg = raw.get("usage")
+    if usage_cfg:
+        cache_scope = str(getattr(usage_cfg, "cache_scope", "global") or "global")
+        cache_scope = cache_scope.lower().strip() or "global"
+        global_root = getattr(usage_cfg, "global_cache_root", None)
+        repo_cache_path = getattr(usage_cfg, "repo_cache_path", None)
+        if global_root:
+            global_cache_root = Path(global_root)
+        if cache_scope == "repo":
+            if repo_cache_path:
+                cache_path = Path(repo_cache_path)
+            elif repo_root:
+                cache_path = (
+                    repo_root
+                    / ".codex-autorunner"
+                    / "usage"
+                    / "usage_series_cache.json"
+                )
+        else:
+            if global_root:
+                cache_path = _default_usage_series_cache_path(global_cache_root)
+            else:
+                cache_path = _default_usage_series_cache_path(codex_root)
+    return codex_root, cache_path, cache_scope, Path(global_cache_root)
+
+
+def _maybe_migrate_usage_cache(cache_path: Path, global_cache_path: Path) -> None:
+    cache_key = str(cache_path)
+    if cache_key in _REPO_USAGE_CACHE_MIGRATED:
+        return
+    _REPO_USAGE_CACHE_MIGRATED.add(cache_key)
+    if cache_path.exists() or not global_cache_path.exists():
+        return
+    try:
+        payload = global_cache_path.read_text(encoding="utf-8")
+        cache_path.parent.mkdir(parents=True, exist_ok=True)
+        tmp_path = cache_path.with_suffix(".tmp")
+        tmp_path.write_text(payload, encoding="utf-8")
+        tmp_path.replace(cache_path)
+        logger.warning(
+            "Imported global usage cache into repo cache at %s from %s",
+            cache_path,
+            global_cache_path,
+        )
+    except OSError as exc:
+        logger.warning(
+            "Failed to import global usage cache from %s to %s: %s",
+            global_cache_path,
+            cache_path,
+            exc,
+        )
+
+
+def get_usage_series_cache(
+    codex_home: Path, *, cache_path: Optional[Path] = None
+) -> UsageSeriesCache:
+    cache_path = cache_path or _default_usage_series_cache_path(codex_home)
+    key = (str(cache_path), str(codex_home))
     cache = _USAGE_SERIES_CACHES.get(key)
     if cache is None:
         cache = UsageSeriesCache(codex_home, cache_path)
@@ -1795,13 +1923,19 @@ def get_repo_usage_series_cached(
     repo_root: Path,
     codex_home: Optional[Path] = None,
     *,
+    config: Optional[Any] = None,
     since: Optional[datetime] = None,
     until: Optional[datetime] = None,
     bucket: str = "day",
     segment: str = "none",
 ) -> Tuple[Dict[str, object], str]:
-    codex_root = (codex_home or default_codex_home()).expanduser()
-    cache = get_usage_series_cache(codex_root)
+    codex_root, cache_path, cache_scope, global_cache_root = _resolve_usage_cache_paths(
+        config=config, repo_root=repo_root, codex_home=codex_home
+    )
+    if cache_scope == "repo":
+        global_cache_path = _default_usage_series_cache_path(global_cache_root)
+        _maybe_migrate_usage_cache(cache_path, global_cache_path)
+    cache = get_usage_series_cache(codex_root, cache_path=cache_path)
     if segment == "agent":
         codex_series, status = cache.get_repo_series(
             repo_root, since=since, until=until, bucket=bucket, segment="none"
@@ -1829,11 +1963,17 @@ def get_repo_usage_summary_cached(
     repo_root: Path,
     codex_home: Optional[Path] = None,
     *,
+    config: Optional[Any] = None,
     since: Optional[datetime] = None,
     until: Optional[datetime] = None,
 ) -> Tuple[UsageSummary, str]:
-    codex_root = (codex_home or default_codex_home()).expanduser()
-    cache = get_usage_series_cache(codex_root)
+    codex_root, cache_path, cache_scope, global_cache_root = _resolve_usage_cache_paths(
+        config=config, repo_root=repo_root, codex_home=codex_home
+    )
+    if cache_scope == "repo":
+        global_cache_path = _default_usage_series_cache_path(global_cache_root)
+        _maybe_migrate_usage_cache(cache_path, global_cache_path)
+    cache = get_usage_series_cache(codex_root, cache_path=cache_path)
     summary, status = cache.get_repo_summary(repo_root, since=since, until=until)
     opencode_summary = summarize_opencode_repo_usage(
         repo_root, since=since, until=until
@@ -1852,13 +1992,19 @@ def get_hub_usage_series_cached(
     repo_map: List[Tuple[str, Path]],
     codex_home: Optional[Path] = None,
     *,
+    config: Optional[Any] = None,
     since: Optional[datetime] = None,
     until: Optional[datetime] = None,
     bucket: str = "day",
     segment: str = "none",
 ) -> Tuple[Dict[str, object], str]:
-    codex_root = (codex_home or default_codex_home()).expanduser()
-    cache = get_usage_series_cache(codex_root)
+    codex_root, cache_path, cache_scope, global_cache_root = _resolve_usage_cache_paths(
+        config=config, repo_root=None, codex_home=codex_home
+    )
+    if cache_scope == "repo":
+        global_cache_path = _default_usage_series_cache_path(global_cache_root)
+        _maybe_migrate_usage_cache(cache_path, global_cache_path)
+    cache = get_usage_series_cache(codex_root, cache_path=cache_path)
     if segment == "agent":
         codex_series, status = cache.get_hub_series(
             repo_map, since=since, until=until, bucket=bucket, segment="none"
@@ -1886,11 +2032,17 @@ def get_hub_usage_summary_cached(
     repo_map: List[Tuple[str, Path]],
     codex_home: Optional[Path] = None,
     *,
+    config: Optional[Any] = None,
     since: Optional[datetime] = None,
     until: Optional[datetime] = None,
 ) -> Tuple[Dict[str, UsageSummary], UsageSummary, str]:
-    codex_root = (codex_home or default_codex_home()).expanduser()
-    cache = get_usage_series_cache(codex_root)
+    codex_root, cache_path, cache_scope, global_cache_root = _resolve_usage_cache_paths(
+        config=config, repo_root=None, codex_home=codex_home
+    )
+    if cache_scope == "repo":
+        global_cache_path = _default_usage_series_cache_path(global_cache_root)
+        _maybe_migrate_usage_cache(cache_path, global_cache_path)
+    cache = get_usage_series_cache(codex_root, cache_path=cache_path)
     per_repo, unmatched, status = cache.get_hub_summary(
         repo_map, since=since, until=until
     )

codex_autorunner/core/utils.py

@@ -1,12 +1,17 @@
+import contextvars
+import importlib
 import json
 import logging
 import os
 import shlex
 import shutil
+import subprocess
+from functools import lru_cache
 from pathlib import Path
 from typing import (
-    TYPE_CHECKING,
+    Any,
     Dict,
+    Iterable,
     Mapping,
     MutableMapping,
     Optional,
@@ -15,16 +20,115 @@ from typing import (
     cast,
 )
 
-if TYPE_CHECKING:
-    from ..agents.opencode.supervisor import OpenCodeSupervisor
+SUBCOMMAND_HINTS = ("exec", "resume")
+
+
+def extract_flag_value(args: Iterable[str], flag: str) -> Optional[str]:
+    if not args:
+        return None
+    for arg in args:
+        if not isinstance(arg, str):
+            continue
+        if arg.startswith(f"{flag}="):
+            return arg.split("=", 1)[1] or None
+    args_list = [str(a) for a in args]
+    for idx, arg in enumerate(args_list):
+        if arg == flag and idx + 1 < len(args_list):
+            return args_list[idx + 1]
+    return None
+
+
+def inject_flag(
+    args: Iterable[str],
+    flag: str,
+    value: Optional[str],
+    *,
+    subcommands: Iterable[str] = SUBCOMMAND_HINTS,
+) -> list[str]:
+    if not value:
+        return [str(a) for a in args]
+    args_list = [str(a) for a in args]
+    if extract_flag_value(args_list, flag):
+        return args_list
+    insert_at = None
+    for cmd in subcommands:
+        try:
+            insert_at = args_list.index(cmd)
+            break
+        except ValueError:
+            continue
+    if insert_at is None:
+        if args_list and not args_list[0].startswith("-"):
+            return [args_list[0], flag, value] + args_list[1:]
+        return [flag, value] + args_list
+    return args_list[:insert_at] + [flag, value] + args_list[insert_at:]
+
+
+def apply_codex_options(
+    args: Iterable[str],
+    *,
+    model: Optional[str] = None,
+    reasoning: Optional[str] = None,
+    supports_reasoning: Optional[bool] = None,
+) -> list[str]:
+    with_model = inject_flag(args, "--model", model)
+    if reasoning and supports_reasoning is False:
+        return with_model
+    return inject_flag(with_model, "--reasoning", reasoning)
+
+
+def _read_help_text(binary: str) -> str:
+    try:
+        result = subprocess.run(
+            [binary, "--help"],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+    except FileNotFoundError:
+        return ""
+    return "\n".join(filter(None, [result.stdout, result.stderr]))
+
+
+@lru_cache(maxsize=8)
+def supports_flag(binary: str, flag: str) -> bool:
+    return flag in _read_help_text(binary)
+
+
+def supports_reasoning(binary: str) -> bool:
+    return supports_flag(binary, "--reasoning")
 
 
 class RepoNotFoundError(Exception):
     pass
 
 
-def find_repo_root(start: Path) -> Path:
-    current = start.resolve()
+_repo_root_ctx: contextvars.ContextVar[Optional[Path]] = contextvars.ContextVar(
+    "codex_autorunner_repo_root", default=None
+)
+
+
+def set_repo_root_context(
+    repo_root: Optional[Path],
+) -> contextvars.Token[Optional[Path]]:
+    """Set the current repo root for the active context."""
+    return _repo_root_ctx.set(repo_root.resolve() if repo_root else None)
+
+
+def reset_repo_root_context(token: contextvars.Token[Optional[Path]]) -> None:
+    _repo_root_ctx.reset(token)
+
+
+def get_repo_root_context() -> Optional[Path]:
+    return _repo_root_ctx.get()
+
+
+def find_repo_root(start: Optional[Path] = None) -> Path:
+    ctx_root = get_repo_root_context()
+    if ctx_root is not None and (ctx_root / ".git").exists():
+        return ctx_root
+
+    current = (start or Path.cwd()).resolve()
     for parent in [current] + list(current.parents):
         if (parent / ".git").exists():
             return parent
@@ -127,8 +231,8 @@ def ensure_executable(binary: str) -> bool:
     return resolve_executable(binary) is not None
 
 
-def default_editor() -> str:
-    return os.environ.get("EDITOR") or "vi"
+def default_editor(*, fallback: str = "vi") -> str:
+    return os.environ.get("EDITOR") or fallback
 
 
 def resolve_opencode_binary(raw_command: Optional[str] = None) -> Optional[str]:
@@ -190,9 +294,10 @@ def build_opencode_supervisor(
     request_timeout: Optional[float] = None,
     max_handles: Optional[int] = None,
     idle_ttl_seconds: Optional[float] = None,
+    session_stall_timeout_seconds: Optional[float] = None,
     base_env: Optional[MutableMapping[str, str]] = None,
     subagent_models: Optional[Mapping[str, str]] = None,
-) -> Optional["OpenCodeSupervisor"]:
+) -> Optional[Any]:
     """
     Unified factory for building OpenCodeSupervisor instances.
 
@@ -236,19 +341,23 @@ def build_opencode_supervisor(
     if password and not username:
         username = "opencode"
 
-    from ..agents.opencode.supervisor import OpenCodeSupervisor
-
-    return OpenCodeSupervisor(
+    supervisor_module = importlib.import_module(
+        "codex_autorunner.agents.opencode.supervisor"
+    )
+    supervisor_cls = supervisor_module.OpenCodeSupervisor
+    supervisor = supervisor_cls(
         command,
         logger=logger,
         request_timeout=request_timeout,
         max_handles=max_handles,
         idle_ttl_seconds=idle_ttl_seconds,
+        session_stall_timeout_seconds=session_stall_timeout_seconds,
         username=username if password else None,
         password=password if password else None,
         base_env=base_env,
         subagent_models=subagent_models,
     )
+    return cast(Any, supervisor)
 
 
 def _command_available(

codex_autorunner/discovery.py

@@ -57,7 +57,7 @@ def discover_and_init(hub_config: HubConfig) -> Tuple[Manifest, List[DiscoveryRe
 
     def _record_repo(repo_entry: ManifestRepo, *, added: bool) -> None:
         repo_path = (hub_config.root / repo_entry.path).resolve()
-        initialized = (repo_path / ".codex-autorunner" / "state.sqlite3").exists()
+        initialized = (repo_path / ".codex-autorunner" / "tickets").exists()
         init_error: Optional[str] = None
         if hub_config.auto_init_missing and repo_path.exists() and not initialized:
             try:
@@ -176,9 +176,7 @@ def discover_and_init(hub_config: HubConfig) -> Tuple[Manifest, List[DiscoveryRe
                 absolute_path=repo_path,
                 added_to_manifest=False,
                 exists_on_disk=repo_path.exists(),
-                initialized=(
-                    repo_path / ".codex-autorunner" / "state.sqlite3"
-                ).exists(),
+                initialized=(repo_path / ".codex-autorunner" / "tickets").exists(),
                 init_error=None,
             )
         )

codex_autorunner/flows/review/__init__.py

@@ -0,0 +1,17 @@
+from .service import (
+    REVIEW_PROMPT,
+    REVIEW_PROMPT_SPEC_PROGRESS,
+    ReviewBusyError,
+    ReviewConflictError,
+    ReviewError,
+    ReviewService,
+)
+
+__all__ = [
+    "REVIEW_PROMPT",
+    "REVIEW_PROMPT_SPEC_PROGRESS",
+    "ReviewBusyError",
+    "ReviewConflictError",
+    "ReviewError",
+    "ReviewService",
+]

codex_autorunner/{core/review.py → flows/review/service.py}

@@ -10,15 +10,20 @@ import zipfile
 from pathlib import Path
 from typing import Any, Optional
 
-from ..agents.opencode.run_prompt import OpenCodeRunConfig, run_opencode_prompt
-from ..agents.opencode.supervisor import OpenCodeSupervisor
-from ..agents.registry import has_capability, validate_agent_id
-from ..integrations.app_server.supervisor import WorkspaceAppServerSupervisor
-from .config import RepoConfig
-from .engine import Engine
-from .locks import FileLock, FileLockBusy, FileLockError, process_alive, read_lock_info
-from .state import now_iso
-from .utils import atomic_write, read_json
+from ...agents.opencode.run_prompt import OpenCodeRunConfig, run_opencode_prompt
+from ...agents.opencode.supervisor import OpenCodeSupervisor
+from ...agents.registry import has_capability, validate_agent_id
+from ...core.config import RepoConfig
+from ...core.engine import Engine
+from ...core.locks import (
+    FileLock,
+    FileLockBusy,
+    FileLockError,
+    process_alive,
+    read_lock_info,
+)
+from ...core.state import now_iso
+from ...core.utils import atomic_write, read_json
 
 REVIEW_STATE_VERSION = 1
 REVIEW_TIMEOUT_SECONDS = 3600
@@ -391,7 +396,7 @@ class ReviewService:
         engine: Engine,
         *,
         opencode_supervisor: Optional[OpenCodeSupervisor] = None,
-        app_server_supervisor: Optional[WorkspaceAppServerSupervisor] = None,
+        app_server_supervisor: Optional[Any] = None,
         logger: Optional[logging.Logger] = None,
     ) -> None:
         self.engine = engine

codex_autorunner/flows/ticket_flow/__init__.py

@@ -0,0 +1,3 @@
+from .definition import build_ticket_flow_definition
+
+__all__ = ["build_ticket_flow_definition"]

codex_autorunner/flows/ticket_flow/definition.py

@@ -0,0 +1,98 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+from ...core.flows.definition import EmitEventFn, FlowDefinition, StepOutcome
+from ...core.flows.models import FlowEventType, FlowRunRecord
+from ...core.utils import find_repo_root
+from ...tickets import (
+    DEFAULT_MAX_TOTAL_TURNS,
+    AgentPool,
+    TicketRunConfig,
+    TicketRunner,
+)
+
+
+def build_ticket_flow_definition(*, agent_pool: AgentPool) -> FlowDefinition:
+    """Build the single-step ticket runner flow.
+
+    The flow is intentionally simple: each step executes at most one agent turn
+    against the current ticket, and re-schedules itself until paused or complete.
+    """
+
+    async def _ticket_turn_step(
+        record: FlowRunRecord,
+        input_data: Dict[str, Any],
+        emit_event: Optional[EmitEventFn],
+    ) -> StepOutcome:
+        # Namespace all state under `ticket_engine` to avoid collisions with other flows.
+        engine_state = (
+            record.state.get("ticket_engine")
+            if isinstance(record.state, dict)
+            else None
+        )
+        engine_state = dict(engine_state) if isinstance(engine_state, dict) else {}
+
+        repo_root = find_repo_root()
+        workspace_root = Path(input_data.get("workspace_root") or repo_root)
+        ticket_dir = Path(input_data.get("ticket_dir") or ".codex-autorunner/tickets")
+        runs_dir = Path(input_data.get("runs_dir") or ".codex-autorunner/runs")
+        max_total_turns = int(
+            input_data.get("max_total_turns") or DEFAULT_MAX_TOTAL_TURNS
+        )
+        max_lint_retries = int(input_data.get("max_lint_retries") or 3)
+        max_commit_retries = int(input_data.get("max_commit_retries") or 2)
+        auto_commit = bool(
+            input_data.get("auto_commit") if "auto_commit" in input_data else True
+        )
+
+        runner = TicketRunner(
+            workspace_root=workspace_root,
+            run_id=str(record.id),
+            config=TicketRunConfig(
+                ticket_dir=ticket_dir,
+                runs_dir=runs_dir,
+                max_total_turns=max_total_turns,
+                max_lint_retries=max_lint_retries,
+                max_commit_retries=max_commit_retries,
+                auto_commit=auto_commit,
+            ),
+            agent_pool=agent_pool,
+        )
+
+        if emit_event is not None:
+            emit_event(FlowEventType.STEP_PROGRESS, {"message": "Running ticket turn"})
+        result = await runner.step(engine_state, emit_event=emit_event)
+        out_state = dict(record.state or {})
+        out_state["ticket_engine"] = result.state
+
+        if result.status == "completed":
+            return StepOutcome.complete(output=out_state)
+        if result.status == "paused":
+            return StepOutcome.pause(output=out_state)
+        if result.status == "failed":
+            return StepOutcome.fail(
+                error=result.reason or "Ticket engine failed", output=out_state
+            )
+        return StepOutcome.continue_to(next_steps={"ticket_turn"}, output=out_state)
+
+    return FlowDefinition(
+        flow_type="ticket_flow",
+        name="Ticket Flow",
+        description="Ticket-based agent workflow runner",
+        initial_step="ticket_turn",
+        input_schema={
+            "type": "object",
+            "properties": {
+                "workspace_root": {"type": "string"},
+                "ticket_dir": {"type": "string"},
+                "runs_dir": {"type": "string"},
+                "max_total_turns": {"type": "integer"},
+                "max_lint_retries": {"type": "integer"},
+                "max_commit_retries": {"type": "integer"},
+                "auto_commit": {"type": "boolean"},
+            },
+        },
+        steps={"ticket_turn": _ticket_turn_step},
+    )

codex_autorunner/integrations/agents/__init__.py

@@ -0,0 +1,17 @@
+from .codex_adapter import CodexAdapterOrchestrator
+from .codex_backend import CodexAppServerBackend
+from .opencode_adapter import OpenCodeAdapterOrchestrator
+from .opencode_backend import OpenCodeBackend
+from .wiring import (
+    build_agent_backend_factory,
+    build_app_server_supervisor_factory,
+)
+
+__all__ = [
+    "CodexAdapterOrchestrator",
+    "CodexAppServerBackend",
+    "OpenCodeAdapterOrchestrator",
+    "OpenCodeBackend",
+    "build_agent_backend_factory",
+    "build_app_server_supervisor_factory",
+]