codex-autorunner 1.0.0__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,13 +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,
@@ -16,8 +20,83 @@ 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):
@@ -152,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]:
@@ -218,7 +297,7 @@ def build_opencode_supervisor(
     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.
 
@@ -262,9 +341,11 @@ 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,
@@ -276,6 +357,7 @@ def build_opencode_supervisor(
         base_env=base_env,
         subagent_models=subagent_models,
     )
+    return cast(Any, supervisor)
 
 
 def _command_available(

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/definition.py

@@ -6,7 +6,12 @@ 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 AgentPool, TicketRunConfig, TicketRunner
+from ...tickets import (
+    DEFAULT_MAX_TOTAL_TURNS,
+    AgentPool,
+    TicketRunConfig,
+    TicketRunner,
+)
 
 
 def build_ticket_flow_definition(*, agent_pool: AgentPool) -> FlowDefinition:
@@ -33,7 +38,9 @@ def build_ticket_flow_definition(*, agent_pool: AgentPool) -> FlowDefinition:
         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 25)
+        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(

codex_autorunner/integrations/agents/__init__.py

@@ -1,27 +1,17 @@
-from .agent_backend import AgentBackend, AgentEvent, AgentEventType
+from .codex_adapter import CodexAdapterOrchestrator
 from .codex_backend import CodexAppServerBackend
+from .opencode_adapter import OpenCodeAdapterOrchestrator
 from .opencode_backend import OpenCodeBackend
-from .run_event import (
-    ApprovalRequested,
-    Completed,
-    Failed,
-    OutputDelta,
-    RunEvent,
-    Started,
-    ToolCall,
+from .wiring import (
+    build_agent_backend_factory,
+    build_app_server_supervisor_factory,
 )
 
 __all__ = [
-    "AgentBackend",
-    "AgentEvent",
-    "AgentEventType",
+    "CodexAdapterOrchestrator",
     "CodexAppServerBackend",
+    "OpenCodeAdapterOrchestrator",
     "OpenCodeBackend",
-    "RunEvent",
-    "Started",
-    "OutputDelta",
-    "ToolCall",
-    "ApprovalRequested",
-    "Completed",
-    "Failed",
+    "build_agent_backend_factory",
+    "build_app_server_supervisor_factory",
 ]