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

codex_autorunner/core/time_utils.py

@@ -0,0 +1,11 @@
+from datetime import datetime, timezone
+
+
+def now_iso_utc_z() -> str:
+    return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+
+now_iso = now_iso_utc_z
+
+
+__all__ = ["now_iso_utc_z", "now_iso"]

codex_autorunner/core/types.py

@@ -0,0 +1,18 @@
+"""Core type definitions.
+
+This module provides type definitions that were previously in Engine.
+"""
+
+from typing import Any, Callable, Optional
+
+# Type aliases for factory functions
+BackendFactory = Callable[[str, Any, Optional[Callable[[dict[str, Any]], Any]]], Any]
+AppServerSupervisorFactory = Callable[
+    [str, Optional[Callable[[dict[str, Any]], Any]]], Any
+]
+
+
+__all__ = [
+    "BackendFactory",
+    "AppServerSupervisorFactory",
+]

codex_autorunner/core/update.py

@@ -11,6 +11,7 @@ from typing import Optional
 from urllib.parse import unquote, urlparse
 
 from .git_utils import GitError, run_git
+from .update_paths import resolve_update_paths
 
 
 class UpdateInProgressError(RuntimeError):
@@ -55,7 +56,7 @@ def _normalize_update_ref(raw: Optional[str]) -> str:
 
 
 def _update_status_path() -> Path:
-    return Path.home() / ".codex-autorunner" / "update_status.json"
+    return resolve_update_paths().status_path
 
 
 def _write_update_status(status: str, message: str, **extra) -> None:
@@ -134,7 +135,7 @@ def _read_update_status() -> Optional[dict[str, object]]:
 
 
 def _update_lock_path() -> Path:
-    return Path.home() / ".codex-autorunner" / "update.lock"
+    return resolve_update_paths().lock_path
 
 
 def _read_update_lock() -> Optional[dict[str, object]]:
@@ -281,9 +282,7 @@ def _system_update_check(
     update_cache_dir: Optional[Path] = None,
 ) -> dict:
     module_dir = module_dir or Path(__file__).resolve().parent
-    update_cache_dir = update_cache_dir or (
-        Path.home() / ".codex-autorunner" / "update_cache"
-    )
+    update_cache_dir = update_cache_dir or resolve_update_paths().cache_dir
     repo_ref = _normalize_update_ref(repo_ref)
 
     repo_root = _resolve_local_repo_root(

codex_autorunner/core/update_paths.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Optional
+
+from .state_roots import resolve_global_state_root
+
+
+@dataclass(frozen=True)
+class UpdatePaths:
+    status_path: Path
+    lock_path: Path
+    cache_dir: Path
+    compact_status_path: Path
+
+
+def resolve_update_paths(
+    *, config: Optional[Any] = None, repo_root: Optional[Path] = None
+) -> UpdatePaths:
+    """Resolve update status, lock, cache, and compact status paths."""
+    root = resolve_global_state_root(config=config, repo_root=repo_root)
+    return UpdatePaths(
+        status_path=root / "update_status.json",
+        lock_path=root / "update.lock",
+        cache_dir=root / "update_cache",
+        compact_status_path=root / "compact_status.json",
+    )

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):
@@ -68,12 +147,21 @@ def is_within(root: Path, target: Path) -> bool:
         return False
 
 
-def atomic_write(path: Path, content: str) -> None:
+def atomic_write(path: Path, content: str, durable: bool = False) -> None:
     path.parent.mkdir(parents=True, exist_ok=True)
     tmp_path = path.with_suffix(path.suffix + ".tmp")
     with tmp_path.open("w", encoding="utf-8") as f:
         f.write(content)
+        if durable:
+            f.flush()
+            os.fsync(f.fileno())
     tmp_path.replace(path)
+    if durable:
+        dir_fd = os.open(path.parent, os.O_RDONLY)
+        try:
+            os.fsync(dir_fd)
+        finally:
+            os.close(dir_fd)
 
 
 def read_json(path: Path) -> Optional[dict]:
@@ -96,7 +184,28 @@ def _default_path_prefixes() -> list[str]:
         str(home / ".opencode" / "bin"),  # OpenCode default install
         str(home / ".local" / "bin"),  # Common user-local installs
     ]
-    return [p for p in candidates if os.path.isdir(p)]
+    repo_candidates: list[str] = []
+    repo_root = get_repo_root_context()
+    if repo_root is None:
+        try:
+            repo_root = find_repo_root()
+        except RepoNotFoundError:
+            repo_root = None
+    if repo_root is not None:
+        bin_dir = "Scripts" if os.name == "nt" else "bin"
+        repo_candidates = [
+            str(repo_root / ".venv" / bin_dir),
+            str(repo_root / ".codex-autorunner" / "bin"),
+            str(repo_root / "bin"),
+        ]
+        car_shim = repo_root / "car"
+        if car_shim.exists():
+            repo_candidates.append(str(repo_root))
+    return [
+        p
+        for p in (repo_candidates + candidates)
+        if (os.path.isdir(p) or os.path.isfile(p))
+    ]
 
 
 def augmented_path(path: Optional[str] = None) -> str:
@@ -148,12 +257,8 @@ def resolve_executable(
     return resolved
 
 
-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]:
@@ -216,9 +321,10 @@ def build_opencode_supervisor(
     max_handles: Optional[int] = None,
     idle_ttl_seconds: Optional[float] = None,
     session_stall_timeout_seconds: Optional[float] = None,
+    max_text_chars: Optional[int] = 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,20 +368,24 @@ 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,
+        max_text_chars=max_text_chars,
         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/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",
+]