codexloop 0.1.0__py3-none-any.whl

codexloop/cli/asyncio.py

@@ -0,0 +1,80 @@
+"""Single ``anyio.run()`` bridge: signals, drain, and exit-code translation."""
+
+from __future__ import annotations
+
+import asyncio
+import signal
+from collections.abc import Callable, Coroutine
+from functools import wraps
+from typing import Any
+
+import anyio
+import typer
+
+from codexloop.application.dto import RunResult
+from codexloop.bootstrap import DrainControl, current_drain, register_drain
+from codexloop.domain.errors import ConfigurationError
+
+
+def sysexit_for(result: RunResult) -> int:
+    if result.reason == "stop":
+        return 130
+    if result.success:
+        return 0
+    return 1
+
+
+def _request_drain() -> None:
+    drain = current_drain()
+    if drain is not None:
+        drain.request_stop()
+
+
+def _signal_handler(_signum: int, _frame: object | None) -> None:
+    _request_drain()
+
+
+def _install_drain_signals() -> None:
+    try:
+        loop = asyncio.get_running_loop()
+    except RuntimeError:
+        signal.signal(signal.SIGINT, _signal_handler)
+        signal.signal(signal.SIGTERM, _signal_handler)
+        return
+    for sig in (signal.SIGINT, signal.SIGTERM):
+        try:
+            loop.add_signal_handler(sig, _request_drain)
+        except (NotImplementedError, RuntimeError):
+            signal.signal(sig, _signal_handler)
+
+
+def _raise_for_result(result: object) -> None:
+    if not isinstance(result, RunResult):
+        return
+    code = sysexit_for(result)
+    if code != 0:
+        raise typer.Exit(code)
+
+
+def async_command[**P, T](func: Callable[P, Coroutine[Any, Any, T]]) -> Callable[P, T]:
+    """Run an async Typer command via ``anyio.run()`` with SIGINT/SIGTERM drain."""
+
+    @wraps(func)
+    def wrapper(*args: P.args, **kwargs: P.kwargs) -> T:
+        async def _runner() -> T:
+            register_drain(DrainControl())
+            _install_drain_signals()
+            return await func(*args, **kwargs)
+
+        try:
+            result = anyio.run(_runner)
+        except ConfigurationError as exc:
+            typer.echo(str(exc), err=True)
+            raise typer.Exit(2) from exc
+        except KeyboardInterrupt:
+            _request_drain()
+            raise typer.Exit(130) from None
+        _raise_for_result(result)
+        return result
+
+    return wrapper

codexloop/cli/commands/__init__.py

@@ -0,0 +1 @@
+"""CLI command implementations. Must not import ``infrastructure``."""

codexloop/cli/commands/approval_cmd.py

@@ -0,0 +1,24 @@
+"""``codexloop approval`` — enqueue SetApproval."""
+
+from __future__ import annotations
+
+import typer
+
+from codexloop.bootstrap import enqueue_run_control
+from codexloop.domain.approval import ApprovalPolicy
+from codexloop.domain.control import SetApproval
+from codexloop.domain.errors import ConfigurationError
+
+
+def approval_cmd(
+    policy: str = typer.Argument(..., help="Approval policy."),
+    run_id: str | None = typer.Option(None, "--run-id", help="Target run id."),
+) -> None:
+    """Queue an approval-policy change for the next control boundary."""
+    try:
+        value = ApprovalPolicy(policy)
+        path = enqueue_run_control(SetApproval(policy=value), run_id=run_id)
+    except (ConfigurationError, ValueError) as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(2) from exc
+    typer.echo(f"queued → {path}")

codexloop/cli/commands/capacity.py

@@ -0,0 +1,33 @@
+"""``codexloop capacity`` — print plan windows or say they are unavailable."""
+
+from __future__ import annotations
+
+import typer
+
+from codexloop.bootstrap import read_capacity_windows
+
+
+def capacity() -> None:
+    """Show ChatGPT plan windows when known; say so honestly when not."""
+    windows = read_capacity_windows()
+    if windows is None:
+        typer.echo("plan windows unavailable")
+        return
+    typer.echo(f"plan_type: {windows.plan_type or 'unknown'}")
+    typer.echo(f"limit_reached: {windows.limit_reached or 'none'}")
+    if windows.primary is None:
+        typer.echo("primary: unavailable")
+    else:
+        p = windows.primary
+        typer.echo(
+            f"primary: used={p.used_percent}% window={p.window_minutes}m "
+            f"resets_at={p.resets_at.isoformat() if p.resets_at else 'unknown'}"
+        )
+    if windows.secondary is None:
+        typer.echo("secondary: unavailable")
+    else:
+        s = windows.secondary
+        typer.echo(
+            f"secondary: used={s.used_percent}% window={s.window_minutes}m "
+            f"resets_at={s.resets_at.isoformat() if s.resets_at else 'unknown'}"
+        )

codexloop/cli/commands/cwd_cmd.py

@@ -0,0 +1,22 @@
+"""``codexloop cwd`` — enqueue SetCwd."""
+
+from __future__ import annotations
+
+import typer
+
+from codexloop.bootstrap import enqueue_run_control
+from codexloop.domain.control import SetCwd
+from codexloop.domain.errors import ConfigurationError
+
+
+def cwd_cmd(
+    path: str = typer.Argument(..., help="Working directory path."),
+    run_id: str | None = typer.Option(None, "--run-id", help="Target run id."),
+) -> None:
+    """Queue a cwd change for the next control boundary."""
+    try:
+        written = enqueue_run_control(SetCwd(cwd=path), run_id=run_id)
+    except ConfigurationError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(2) from exc
+    typer.echo(f"queued → {written}")

codexloop/cli/commands/doctor.py

@@ -0,0 +1,27 @@
+"""``codexloop doctor`` — pre-flight environment checks."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import typer
+
+from codexloop.bootstrap import run_doctor_checks
+
+
+def doctor(
+    cwd: Path | None = typer.Option(None, "--cwd", help="Working directory to check."),
+) -> None:
+    """Report auth mode, probe strategies, and other pre-flight gates."""
+    report = run_doctor_checks(cwd=cwd)
+    typer.echo(f"auth_mode: {report.auth_mode}")
+    strategies = ", ".join(
+        f"{name}={'live' if live else 'unavailable'}"
+        for name, live in report.probe_strategies.items()
+    )
+    typer.echo(f"probe_strategies: {strategies}")
+    for check in report.checks:
+        mark = "ok" if check.passed else "FAIL"
+        typer.echo(f"[{mark}] {check.name}: {check.detail}")
+    if not report.all_passed:
+        raise typer.Exit(1)

codexloop/cli/commands/effort_cmd.py

@@ -0,0 +1,24 @@
+"""``codexloop effort`` — enqueue SetEffort."""
+
+from __future__ import annotations
+
+import typer
+
+from codexloop.bootstrap import enqueue_run_control
+from codexloop.domain.control import SetEffort
+from codexloop.domain.errors import ConfigurationError
+from codexloop.domain.model_profile import Effort
+
+
+def effort_cmd(
+    effort: str = typer.Argument(..., help="Effort level."),
+    run_id: str | None = typer.Option(None, "--run-id", help="Target run id."),
+) -> None:
+    """Queue an effort change for the next control boundary."""
+    try:
+        value = Effort(effort)
+        path = enqueue_run_control(SetEffort(effort=value), run_id=run_id)
+    except (ConfigurationError, ValueError) as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(2) from exc
+    typer.echo(f"queued → {path}")

codexloop/cli/commands/logs.py

@@ -0,0 +1,15 @@
+"""``codexloop logs [run-id]``."""
+
+from __future__ import annotations
+
+import typer
+
+from codexloop.bootstrap import read_run_events
+from codexloop.cli.render import render_logs
+
+
+def logs(
+    run_id: str | None = typer.Argument(None, help="Run id. Defaults to the latest run."),
+) -> None:
+    """Print events.jsonl for a run."""
+    typer.echo(render_logs(read_run_events(run_id)))

codexloop/cli/commands/model_cmd.py

@@ -0,0 +1,22 @@
+"""``codexloop model`` — enqueue SetModel."""
+
+from __future__ import annotations
+
+import typer
+
+from codexloop.bootstrap import enqueue_run_control
+from codexloop.domain.control import SetModel
+from codexloop.domain.errors import ConfigurationError
+
+
+def model_cmd(
+    model: str = typer.Argument(..., help="Model name."),
+    run_id: str | None = typer.Option(None, "--run-id", help="Target run id."),
+) -> None:
+    """Queue a model change for the next control boundary."""
+    try:
+        path = enqueue_run_control(SetModel(model=model), run_id=run_id)
+    except ConfigurationError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(2) from exc
+    typer.echo(f"queued → {path}")

codexloop/cli/commands/prompt.py

@@ -0,0 +1,32 @@
+"""``codexloop prompt`` — queue an operator prompt into the run inbox."""
+
+from __future__ import annotations
+
+import typer
+
+from codexloop.bootstrap import enqueue_run_control
+from codexloop.domain.control import Prompt, PromptTiming
+from codexloop.domain.errors import ConfigurationError
+
+
+def prompt(
+    text: str = typer.Argument(..., help="Prompt text to queue."),
+    now: bool = typer.Option(False, "--now", help="Apply at the next control poll."),
+    next_turn: bool = typer.Option(
+        False,
+        "--next-turn",
+        help="Apply before the next turn.",
+    ),
+    run_id: str | None = typer.Option(None, "--run-id", help="Target run id."),
+) -> None:
+    """Queue an operator prompt. Requires exactly one of --now / --next-turn."""
+    if now == next_turn:
+        typer.echo("Specify exactly one of --now or --next-turn.", err=True)
+        raise typer.Exit(2)
+    timing = PromptTiming.NOW if now else PromptTiming.NEXT_TURN
+    try:
+        path = enqueue_run_control(Prompt(text=text, timing=timing), run_id=run_id)
+    except ConfigurationError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(2) from exc
+    typer.echo(f"queued → {path}")

codexloop/cli/commands/reset.py

@@ -0,0 +1,25 @@
+"""``codexloop reset`` — create a labeled savepoint of the current tree."""
+
+from __future__ import annotations
+
+import typer
+
+from codexloop.bootstrap import create_savepoint
+from codexloop.domain.errors import ConfigurationError
+
+
+def reset(
+    run_id: str | None = typer.Option(None, "--run-id", help="Target run id."),
+    label: str = typer.Option("reset", "--label", help="Savepoint label."),
+) -> None:
+    """Record a savepoint (commit if dirty, else ref-tag only)."""
+    try:
+        point = create_savepoint(label=label, run_id=run_id, summary="operator reset")
+    except ConfigurationError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(2) from exc
+    if point is None:
+        typer.echo("not a git repository — no savepoint created")
+        raise typer.Exit(1)
+    kind = "commit" if point.committed else "ref-only"
+    typer.echo(f"savepoint {point.n} ({kind}) {point.sha[:12]}")

codexloop/cli/commands/resume.py

@@ -0,0 +1,38 @@
+"""``codexloop resume [<thread-id> | --last]``."""
+
+from __future__ import annotations
+
+import typer
+
+from codexloop.application.usecases.resume_thread import resume_thread
+from codexloop.application.usecases.run_plan import run_plan
+from codexloop.bootstrap import build_runner
+from codexloop.cli.asyncio import async_command
+from codexloop.cli.render import render_result
+from codexloop.domain.session import MostRecent
+
+
+@async_command
+async def resume(
+    thread_id: str | None = typer.Argument(None, help="Thread id to resume."),
+    last: bool = typer.Option(False, "--last", help="Resume the most recent thread."),
+    transport: str = typer.Option(
+        "exec",
+        "--transport",
+        help="Agent transport: exec or app-server.",
+    ),
+) -> object:
+    """Resume by explicit thread id (default) or the most recent catalog entry."""
+    if thread_id is None and not last:
+        typer.echo("Specify a thread id or --last.", err=True)
+        raise typer.Exit(2)
+    if thread_id is not None and last:
+        typer.echo("Specify a thread id or --last, not both.", err=True)
+        raise typer.Exit(2)
+    ctx = build_runner(transport=transport)
+    if thread_id is not None:
+        result = await resume_thread(ctx, thread_id)
+    else:
+        result = await run_plan(ctx, MostRecent(), "")
+    typer.echo(render_result(result))
+    return result

codexloop/cli/commands/run.py

@@ -0,0 +1,50 @@
+"""``codexloop run <plan.md>``."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import typer
+
+from codexloop.application.usecases.run_plan import run_plan
+from codexloop.bootstrap import build_runner, events_path_for_run, run_stream_ui_for_events
+from codexloop.cli.asyncio import async_command
+from codexloop.cli.render import render_result
+from codexloop.domain.session import PlanFile
+
+
+@async_command
+async def run(
+    plan: Path = typer.Argument(
+        ...,
+        exists=True,
+        readable=True,
+        help="Markdown work plan.",
+    ),
+    transport: str = typer.Option(
+        "exec",
+        "--transport",
+        help="Agent transport: exec or app-server.",
+    ),
+    model: str | None = typer.Option(None, "--model", help="Model name."),
+    max_turns: int | None = typer.Option(None, "--max-turns", help="Turn budget."),
+    max_wait: str | None = typer.Option(None, "--max-wait", help="Max wait duration."),
+    stream_ui: bool = typer.Option(
+        False,
+        "--stream-ui",
+        help="Open a Textual live view of the run event log after completion.",
+    ),
+) -> object:
+    """Drive a new autonomous run from a markdown work plan."""
+    flags: dict[str, object] = {
+        "model": model,
+        "max_turns": max_turns,
+        "max_wait": max_wait,
+    }
+    ctx = build_runner(transport=transport, flags=flags)
+    text = plan.read_text(encoding="utf-8")
+    result = await run_plan(ctx, PlanFile(str(plan)), text)
+    typer.echo(render_result(result))
+    if stream_ui:
+        run_stream_ui_for_events(events_path_for_run())
+    return result

codexloop/cli/commands/runs.py

@@ -0,0 +1,13 @@
+"""``codexloop runs``."""
+
+from __future__ import annotations
+
+import typer
+
+from codexloop.bootstrap import list_run_records
+from codexloop.cli.render import render_runs
+
+
+def runs() -> None:
+    """List run directories under .codexloop/runs/."""
+    typer.echo(render_runs(list_run_records()))

codexloop/cli/commands/sandbox_cmd.py

@@ -0,0 +1,24 @@
+"""``codexloop sandbox`` — enqueue SetSandbox."""
+
+from __future__ import annotations
+
+import typer
+
+from codexloop.bootstrap import enqueue_run_control
+from codexloop.domain.approval import SandboxMode
+from codexloop.domain.control import SetSandbox
+from codexloop.domain.errors import ConfigurationError
+
+
+def sandbox_cmd(
+    sandbox: str = typer.Argument(..., help="Sandbox mode."),
+    run_id: str | None = typer.Option(None, "--run-id", help="Target run id."),
+) -> None:
+    """Queue a sandbox-mode change for the next control boundary."""
+    try:
+        value = SandboxMode(sandbox)
+        path = enqueue_run_control(SetSandbox(sandbox=value), run_id=run_id)
+    except (ConfigurationError, ValueError) as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(2) from exc
+    typer.echo(f"queued → {path}")

codexloop/cli/commands/savepoints.py

@@ -0,0 +1,25 @@
+"""``codexloop savepoints`` — list git save points for a run."""
+
+from __future__ import annotations
+
+import typer
+
+from codexloop.bootstrap import list_savepoints
+from codexloop.domain.errors import ConfigurationError
+
+
+def savepoints(
+    run_id: str | None = typer.Option(None, "--run-id", help="Target run id."),
+) -> None:
+    """List numbered git save points."""
+    try:
+        points = list_savepoints(run_id=run_id)
+    except ConfigurationError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(2) from exc
+    if not points:
+        typer.echo("no savepoints")
+        return
+    for point in points:
+        committed = "commit" if point.committed else "ref-only"
+        typer.echo(f"{point.n}\t{point.sha[:12]}\t{committed}\t{point.label}\t{point.ref}")

codexloop/cli/commands/snapshot.py

@@ -0,0 +1,26 @@
+"""``codexloop snapshot`` — copy the workspace excluding ``.codexloop/``."""
+
+from __future__ import annotations
+
+import typer
+
+from codexloop.bootstrap import restore_run_snapshot, take_snapshot
+from codexloop.domain.errors import ConfigurationError
+
+
+def snapshot(
+    name: str | None = typer.Argument(None, help="Snapshot name (default: timestamp)."),
+    run_id: str | None = typer.Option(None, "--run-id", help="Target run id."),
+    restore: str | None = typer.Option(None, "--restore", help="Restore a named snapshot."),
+) -> None:
+    """Create or restore a filesystem snapshot for the active run."""
+    try:
+        if restore is not None:
+            restore_run_snapshot(restore, run_id=run_id)
+            typer.echo(f"restored snapshot {restore}")
+            return
+        path = take_snapshot(run_id=run_id, name=name)
+    except (ConfigurationError, FileNotFoundError) as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(2) from exc
+    typer.echo(f"snapshot → {path}")

codexloop/cli/commands/status.py

@@ -0,0 +1,15 @@
+"""``codexloop status [run-id]``."""
+
+from __future__ import annotations
+
+import typer
+
+from codexloop.bootstrap import read_run_record
+from codexloop.cli.render import render_status
+
+
+def status(
+    run_id: str | None = typer.Argument(None, help="Run id. Defaults to the latest run."),
+) -> None:
+    """Show persisted state for a run."""
+    typer.echo(render_status(read_run_record(run_id)))

codexloop/cli/commands/stop.py

@@ -0,0 +1,21 @@
+"""``codexloop stop`` — enqueue a Stop control command."""
+
+from __future__ import annotations
+
+import typer
+
+from codexloop.bootstrap import enqueue_run_control
+from codexloop.domain.control import Stop
+from codexloop.domain.errors import ConfigurationError
+
+
+def stop(
+    run_id: str | None = typer.Option(None, "--run-id", help="Target run id."),
+) -> None:
+    """Request a graceful stop at the next control boundary."""
+    try:
+        path = enqueue_run_control(Stop(), run_id=run_id)
+    except ConfigurationError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(2) from exc
+    typer.echo(f"queued stop → {path}")

codexloop/cli/commands/threads.py

@@ -0,0 +1,15 @@
+"""``codexloop threads`` — this product's run registry, not vendor sessions."""
+
+from __future__ import annotations
+
+import typer
+
+from codexloop.application.usecases.list_threads import list_threads
+from codexloop.bootstrap import build_runner
+from codexloop.cli.render import render_threads
+
+
+def threads() -> None:
+    """List this product's run registry (not vendor Codex sessions)."""
+    ctx = build_runner(ensure_run=False)
+    typer.echo(render_threads(list_threads(ctx)))

codexloop/cli/commands/unwind.py

@@ -0,0 +1,24 @@
+"""``codexloop unwind`` — reset the worktree to a save point."""
+
+from __future__ import annotations
+
+import typer
+
+from codexloop.bootstrap import unwind_savepoint
+from codexloop.domain.errors import ConfigurationError
+
+
+def unwind(
+    to: str = typer.Argument(..., help="Save point number, sha prefix, or label."),
+    run_id: str | None = typer.Option(None, "--run-id", help="Target run id."),
+    backup: bool = typer.Option(True, "--backup/--no-backup", help="Keep a backup ref."),
+) -> None:
+    """Hard-reset to a save point. Refuses while a run is live."""
+    try:
+        result = unwind_savepoint(to, run_id=run_id, backup=backup)
+    except (ConfigurationError, ValueError) as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(2) from exc
+    typer.echo(f"restored {result.restored_sha} (savepoint {result.to.n})")
+    if result.backup_ref:
+        typer.echo(f"backup {result.backup_ref}")

codexloop/cli/commands/watch.py

@@ -0,0 +1,66 @@
+"""``codexloop watch`` — print current run state (one-shot or continuous)."""
+
+from __future__ import annotations
+
+import json
+import time
+
+import typer
+
+from codexloop.bootstrap import (
+    events_path_for_run,
+    read_run_state,
+    run_is_live,
+    run_stream_ui_for_events,
+)
+
+
+def watch(
+    run_id: str | None = typer.Argument(None, help="Run id. Defaults to the latest run."),
+    replay: bool = typer.Option(
+        False,
+        "--replay",
+        help="Open the Textual stream UI against the run event log.",
+    ),
+    follow: bool = typer.Option(
+        False,
+        "--follow",
+        "-f",
+        help="Keep printing state whenever it changes until the run exits.",
+    ),
+    interval: float = typer.Option(
+        1.0,
+        "--interval",
+        min=0.1,
+        help="Poll interval in seconds when --follow is set.",
+    ),
+) -> None:
+    """Show a snapshot of persisted run state."""
+    if replay:
+        run_stream_ui_for_events(events_path_for_run(run_id))
+        return
+    if follow:
+        _follow(run_id, interval=interval)
+        return
+    state = read_run_state(run_id)
+    if not state:
+        typer.echo("no run state")
+        raise typer.Exit(1)
+    typer.echo(json.dumps(state, indent=2, default=str))
+
+
+def _follow(run_id: str | None, *, interval: float) -> None:
+    last: dict[str, object] | None = None
+    saw_state = False
+    while True:
+        state = read_run_state(run_id)
+        if state and state != last:
+            typer.echo(json.dumps(state, indent=2, default=str))
+            last = state
+            saw_state = True
+        if saw_state and not run_is_live(run_id):
+            return
+        if not saw_state and not state:
+            typer.echo("no run state")
+            raise typer.Exit(1)
+        time.sleep(interval)