loopx 0.4.8__py3-none-any.whl

loopx/cli_commands/starter_scheduler.py

@@ -0,0 +1,207 @@
+from __future__ import annotations
+
+import argparse
+import json
+from collections.abc import Callable
+from pathlib import Path
+
+from ..codex_cli_probe import (
+    DEFAULT_CODEX_BIN,
+    DEFAULT_EXECUTOR_TIMEOUT_SECONDS,
+    DEFAULT_TIMEOUT_SECONDS,
+    load_codex_cli_visible_session_proof_fixture,
+    render_codex_cli_local_scheduler_executor_markdown,
+    render_codex_cli_local_scheduler_tick_markdown,
+    run_codex_cli_session_probe,
+)
+from ..codex_cli_scheduler import (
+    build_codex_cli_local_scheduler_executor,
+    build_codex_cli_local_scheduler_tick,
+)
+from .starter_runtime_idle import (
+    _add_runtime_idle_observation_arguments,
+    _load_codex_cli_runtime_idle_payload,
+)
+
+
+PrintPayload = Callable[
+    [dict[str, object], str, Callable[[dict[str, object]], str]],
+    None,
+]
+
+
+def _add_scheduler_common_arguments(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument("--project", default=".", help="Project directory to start from.")
+    parser.add_argument("--goal-id", help="Goal id. Defaults to <project-name>-goal.")
+    parser.add_argument(
+        "--agent-id",
+        help="Registered LoopX agent id to include in quota/claim instructions.",
+    )
+    parser.add_argument(
+        "--cli-bin",
+        default="loopx",
+        help="LoopX CLI binary name embedded in generated commands.",
+    )
+    parser.add_argument(
+        "--codex-bin",
+        default=DEFAULT_CODEX_BIN,
+        help="Codex CLI executable to probe for visible-session capabilities.",
+    )
+    parser.add_argument(
+        "--timeout-seconds",
+        type=float,
+        default=DEFAULT_TIMEOUT_SECONDS,
+        help="Per-command timeout for help-only Codex CLI probes.",
+    )
+    parser.add_argument(
+        "--fixture",
+        help="Public-safe JSON fixture with command_outputs, used instead of invoking Codex CLI.",
+    )
+    parser.add_argument(
+        "--quota-fixture",
+        help="Optional public-safe quota should-run JSON fixture with scheduler_hint.",
+    )
+    parser.add_argument(
+        "--proof-fixture",
+        help="Optional public-safe visible-session proof fixture. Without it, same-session automation remains blocked.",
+    )
+    _add_runtime_idle_observation_arguments(parser)
+    parser.add_argument(
+        "--allow-headless-fallback",
+        action="store_true",
+        help="Deprecated and ignored; headless codex exec is disabled for this default /goal path.",
+    )
+
+
+def register_starter_scheduler_commands(subparsers: argparse._SubParsersAction) -> None:
+    codex_cli_local_scheduler_tick_parser = subparsers.add_parser(
+        "codex-cli-local-scheduler-tick",
+        help="Build a no-execution local scheduler tick around codex-cli-visible-driver-run.",
+    )
+    _add_scheduler_common_arguments(codex_cli_local_scheduler_tick_parser)
+
+    codex_cli_local_scheduler_exec_parser = subparsers.add_parser(
+        "codex-cli-local-scheduler-exec",
+        help="Explicit opt-in executor wrapper for codex-cli-local-scheduler-tick results.",
+    )
+    _add_scheduler_common_arguments(codex_cli_local_scheduler_exec_parser)
+    codex_cli_local_scheduler_exec_parser.add_argument(
+        "--executor-timeout-seconds",
+        type=float,
+        default=DEFAULT_EXECUTOR_TIMEOUT_SECONDS,
+        help="Timeout for the explicitly executed scheduler result command.",
+    )
+    codex_cli_local_scheduler_exec_parser.add_argument(
+        "--guard-checked",
+        action="store_true",
+        help="Confirm a fresh quota/user-gate guard was checked before executing a candidate or blocker writeback.",
+    )
+    codex_cli_local_scheduler_exec_parser.add_argument(
+        "--execute-candidate",
+        action="store_true",
+        help="Execute the scheduler candidate command after guard and prefix checks.",
+    )
+    codex_cli_local_scheduler_exec_parser.add_argument(
+        "--execute-blocker-writeback",
+        action="store_true",
+        help="Execute the precise LoopX blocker writeback command after a fresh guard check.",
+    )
+    codex_cli_local_scheduler_exec_parser.add_argument(
+        "--candidate-command-prefix",
+        action="append",
+        default=[],
+        help="Allowed command prefix for --execute-candidate. Repeatable; required before candidate execution.",
+    )
+
+
+def handle_codex_cli_local_scheduler_tick_command(
+    args: argparse.Namespace,
+    print_payload: PrintPayload,
+) -> int:
+    probe_payload = run_codex_cli_session_probe(
+        codex_bin=args.codex_bin,
+        timeout_seconds=args.timeout_seconds,
+        fixture=Path(args.fixture).expanduser() if args.fixture else None,
+    )
+    proof_payload = (
+        load_codex_cli_visible_session_proof_fixture(Path(args.proof_fixture).expanduser())
+        if args.proof_fixture
+        else None
+    )
+    idle_payload = _load_codex_cli_runtime_idle_payload(args)
+    quota_payload = (
+        json.loads(Path(args.quota_fixture).expanduser().read_text(encoding="utf-8"))
+        if args.quota_fixture
+        else None
+    )
+    payload = build_codex_cli_local_scheduler_tick(
+        project=Path(args.project),
+        goal_id=args.goal_id,
+        agent_id=args.agent_id,
+        cli_bin=args.cli_bin,
+        codex_bin=args.codex_bin,
+        probe_payload=probe_payload,
+        quota_payload=quota_payload,
+        proof_payload=proof_payload,
+        idle_payload=idle_payload,
+        allow_headless_fallback=bool(args.allow_headless_fallback),
+    )
+    print_payload(payload, args.format, render_codex_cli_local_scheduler_tick_markdown)
+    return 0 if payload.get("ok") else 1
+
+
+def handle_codex_cli_local_scheduler_exec_command(
+    args: argparse.Namespace,
+    print_payload: PrintPayload,
+) -> int:
+    probe_payload = run_codex_cli_session_probe(
+        codex_bin=args.codex_bin,
+        timeout_seconds=args.timeout_seconds,
+        fixture=Path(args.fixture).expanduser() if args.fixture else None,
+    )
+    proof_payload = (
+        load_codex_cli_visible_session_proof_fixture(Path(args.proof_fixture).expanduser())
+        if args.proof_fixture
+        else None
+    )
+    idle_payload = _load_codex_cli_runtime_idle_payload(args)
+    quota_payload = (
+        json.loads(Path(args.quota_fixture).expanduser().read_text(encoding="utf-8"))
+        if args.quota_fixture
+        else None
+    )
+    payload = build_codex_cli_local_scheduler_executor(
+        project=Path(args.project),
+        goal_id=args.goal_id,
+        agent_id=args.agent_id,
+        cli_bin=args.cli_bin,
+        codex_bin=args.codex_bin,
+        probe_payload=probe_payload,
+        quota_payload=quota_payload,
+        proof_payload=proof_payload,
+        idle_payload=idle_payload,
+        allow_headless_fallback=bool(args.allow_headless_fallback),
+        execute_candidate=bool(args.execute_candidate),
+        execute_blocker_writeback=bool(args.execute_blocker_writeback),
+        guard_checked=bool(args.guard_checked),
+        candidate_command_prefixes=list(args.candidate_command_prefix or []),
+        executor_timeout_seconds=args.executor_timeout_seconds,
+    )
+    print_payload(payload, args.format, render_codex_cli_local_scheduler_executor_markdown)
+    return 0 if payload.get("ok") else 1
+
+
+_SCHEDULER_HANDLERS: dict[str, Callable[[argparse.Namespace, PrintPayload], int]] = {
+    "codex-cli-local-scheduler-tick": handle_codex_cli_local_scheduler_tick_command,
+    "codex-cli-local-scheduler-exec": handle_codex_cli_local_scheduler_exec_command,
+}
+
+
+def handle_starter_scheduler_command(
+    args: argparse.Namespace,
+    print_payload: PrintPayload,
+) -> int | None:
+    handler = _SCHEDULER_HANDLERS.get(str(getattr(args, "command", "")))
+    if handler is None:
+        return None
+    return handler(args, print_payload)

loopx/cli_commands/starter_session_runtime.py

@@ -0,0 +1,152 @@
+from __future__ import annotations
+
+import argparse
+from collections.abc import Callable
+from pathlib import Path
+
+from ..codex_cli_probe import (
+    DEFAULT_CODEX_BIN,
+    DEFAULT_TIMEOUT_SECONDS,
+    build_codex_cli_runtime_idle_detector,
+    build_codex_cli_visible_session_proof,
+    load_codex_cli_visible_session_proof_fixture,
+    render_codex_cli_runtime_idle_detector_markdown,
+    render_codex_cli_session_probe_markdown,
+    render_codex_cli_visible_session_proof_markdown,
+    run_codex_cli_session_probe,
+)
+from .starter_runtime_idle import (
+    _add_runtime_idle_observation_arguments,
+    _load_codex_cli_runtime_idle_payload,
+)
+
+
+PrintPayload = Callable[
+    [dict[str, object], str, Callable[[dict[str, object]], str]],
+    None,
+]
+
+
+def register_starter_session_runtime_commands(subparsers: argparse._SubParsersAction) -> None:
+    codex_cli_probe_parser = subparsers.add_parser(
+        "codex-cli-session-probe",
+        help="Probe Codex CLI help surfaces for same-session LoopX automation support.",
+    )
+    codex_cli_probe_parser.add_argument(
+        "--codex-bin",
+        default=DEFAULT_CODEX_BIN,
+        help="Codex CLI executable to probe with help-only commands.",
+    )
+    codex_cli_probe_parser.add_argument(
+        "--timeout-seconds",
+        type=float,
+        default=DEFAULT_TIMEOUT_SECONDS,
+        help="Per-command timeout for help-only Codex CLI probes.",
+    )
+    codex_cli_probe_parser.add_argument(
+        "--fixture",
+        help="Public-safe JSON fixture with command_outputs, used instead of invoking Codex CLI.",
+    )
+
+    codex_cli_visible_session_proof_parser = subparsers.add_parser(
+        "codex-cli-visible-session-proof",
+        help="Validate a public-safe proof fixture before treating Codex CLI resume or remote-control as same-session automation.",
+    )
+    codex_cli_visible_session_proof_parser.add_argument("--project", default=".", help="Project directory to start from.")
+    codex_cli_visible_session_proof_parser.add_argument("--goal-id", help="Goal id. Defaults to <project-name>-goal.")
+    codex_cli_visible_session_proof_parser.add_argument(
+        "--agent-id",
+        help="Registered LoopX agent id to include in the proof packet.",
+    )
+    codex_cli_visible_session_proof_parser.add_argument(
+        "--cli-bin",
+        default="loopx",
+        help="LoopX CLI binary name embedded in proof metadata.",
+    )
+    codex_cli_visible_session_proof_parser.add_argument(
+        "--proof-fixture",
+        help="Public-safe JSON proof fixture. When omitted, prints the required fixture shape.",
+    )
+
+    codex_cli_runtime_idle_parser = subparsers.add_parser(
+        "codex-cli-runtime-idle-detector",
+        help="Validate public-safe runtime idle evidence before a later visible Codex CLI turn.",
+    )
+    codex_cli_runtime_idle_parser.add_argument("--project", default=".", help="Project directory to start from.")
+    codex_cli_runtime_idle_parser.add_argument("--goal-id", help="Goal id. Defaults to <project-name>-goal.")
+    codex_cli_runtime_idle_parser.add_argument(
+        "--agent-id",
+        help="Registered LoopX agent id to include in the idle packet.",
+    )
+    codex_cli_runtime_idle_parser.add_argument(
+        "--cli-bin",
+        default="loopx",
+        help="LoopX CLI binary name embedded in idle detector metadata.",
+    )
+    _add_runtime_idle_observation_arguments(codex_cli_runtime_idle_parser)
+
+
+def handle_codex_cli_session_probe_command(
+    args: argparse.Namespace,
+    print_payload: PrintPayload,
+) -> int:
+    payload = run_codex_cli_session_probe(
+        codex_bin=args.codex_bin,
+        timeout_seconds=args.timeout_seconds,
+        fixture=Path(args.fixture).expanduser() if args.fixture else None,
+    )
+    print_payload(payload, args.format, render_codex_cli_session_probe_markdown)
+    return 0 if payload.get("ok") else 1
+
+
+def handle_codex_cli_visible_session_proof_command(
+    args: argparse.Namespace,
+    print_payload: PrintPayload,
+) -> int:
+    proof_payload = (
+        load_codex_cli_visible_session_proof_fixture(Path(args.proof_fixture).expanduser())
+        if args.proof_fixture
+        else None
+    )
+    payload = build_codex_cli_visible_session_proof(
+        project=Path(args.project),
+        goal_id=args.goal_id,
+        agent_id=args.agent_id,
+        cli_bin=args.cli_bin,
+        proof_payload=proof_payload,
+    )
+    print_payload(payload, args.format, render_codex_cli_visible_session_proof_markdown)
+    return 0 if payload.get("ok") else 1
+
+
+def handle_codex_cli_runtime_idle_detector_command(
+    args: argparse.Namespace,
+    print_payload: PrintPayload,
+) -> int:
+    idle_payload = _load_codex_cli_runtime_idle_payload(args)
+    payload = build_codex_cli_runtime_idle_detector(
+        project=Path(args.project),
+        goal_id=args.goal_id,
+        agent_id=args.agent_id,
+        cli_bin=args.cli_bin,
+        idle_payload=idle_payload,
+    )
+    print_payload(payload, args.format, render_codex_cli_runtime_idle_detector_markdown)
+    return 0 if payload.get("ok") else 1
+
+
+_SESSION_RUNTIME_HANDLERS: dict[str, Callable[[argparse.Namespace, PrintPayload], int]] = {
+    "codex-cli-session-probe": handle_codex_cli_session_probe_command,
+    "codex-cli-visible-session-proof": handle_codex_cli_visible_session_proof_command,
+    "codex-cli-runtime-idle-detector": handle_codex_cli_runtime_idle_detector_command,
+}
+
+
+def handle_starter_session_runtime_command(
+    args: argparse.Namespace,
+    print_payload: PrintPayload,
+) -> int | None:
+    handler = _SESSION_RUNTIME_HANDLERS.get(str(getattr(args, "command", "")))
+    if handler is None:
+        return None
+    return handler(args, print_payload)

loopx/cli_commands/starter_visible_common.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+import argparse
+
+from ..codex_cli_probe import DEFAULT_CODEX_BIN, DEFAULT_TIMEOUT_SECONDS
+
+
+def _add_project_arguments(
+    parser: argparse.ArgumentParser,
+    *,
+    agent_help: str = "Registered LoopX agent id to include in quota/claim instructions.",
+) -> None:
+    parser.add_argument("--project", default=".", help="Project directory to start from.")
+    parser.add_argument("--goal-id", help="Goal id. Defaults to <project-name>-goal.")
+    parser.add_argument("--agent-id", help=agent_help)
+    parser.add_argument(
+        "--cli-bin",
+        default="loopx",
+        help="LoopX CLI binary name embedded in generated commands.",
+    )
+
+
+def _add_codex_probe_arguments(
+    parser: argparse.ArgumentParser,
+    *,
+    codex_help: str = "Codex CLI executable to probe and reference in fallback commands.",
+) -> None:
+    parser.add_argument(
+        "--codex-bin",
+        default=DEFAULT_CODEX_BIN,
+        help=codex_help,
+    )
+    parser.add_argument(
+        "--timeout-seconds",
+        type=float,
+        default=DEFAULT_TIMEOUT_SECONDS,
+        help="Per-command timeout for help-only Codex CLI probes.",
+    )
+    parser.add_argument(
+        "--fixture",
+        help="Public-safe JSON fixture with command_outputs, used instead of invoking Codex CLI.",
+    )
+
+
+def _add_optional_proof_fixture(parser: argparse.ArgumentParser, *, help_text: str) -> None:
+    parser.add_argument("--proof-fixture", help=help_text)
+
+
+def _add_headless_fallback_argument(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument(
+        "--allow-headless-fallback",
+        action="store_true",
+        help="Deprecated and ignored; headless codex exec is disabled for this default /goal path.",
+    )

loopx/cli_commands/starter_visible_driver.py

@@ -0,0 +1,161 @@
+from __future__ import annotations
+
+import argparse
+from collections.abc import Callable
+from pathlib import Path
+
+from ..codex_cli_probe import (
+    build_codex_cli_local_driver_plan,
+    build_codex_cli_visible_driver_plan,
+    build_codex_cli_visible_driver_run_packet,
+    load_codex_cli_visible_session_proof_fixture,
+    render_codex_cli_local_driver_plan_markdown,
+    render_codex_cli_visible_driver_plan_markdown,
+    render_codex_cli_visible_driver_run_packet_markdown,
+    run_codex_cli_session_probe,
+)
+from .starter_visible_common import (
+    _add_codex_probe_arguments,
+    _add_headless_fallback_argument,
+    _add_optional_proof_fixture,
+    _add_project_arguments,
+)
+from .starter_visible_pilot import (
+    handle_starter_visible_pilot_command,
+    register_starter_visible_pilot_commands,
+)
+
+
+PrintPayload = Callable[
+    [dict[str, object], str, Callable[[dict[str, object]], str]],
+    None,
+]
+
+
+def register_starter_visible_driver_commands(subparsers: argparse._SubParsersAction) -> None:
+    register_starter_visible_pilot_commands(subparsers)
+
+    codex_cli_visible_driver_parser = subparsers.add_parser(
+        "codex-cli-visible-driver-plan",
+        help="Plan a public-safe visible Codex CLI driver path from session-probe evidence.",
+    )
+    _add_project_arguments(codex_cli_visible_driver_parser)
+    _add_codex_probe_arguments(codex_cli_visible_driver_parser)
+
+    codex_cli_local_driver_parser = subparsers.add_parser(
+        "codex-cli-local-driver-plan",
+        help=(
+            "Compose a dry-run-first local Codex CLI driver plan from quota, "
+            "TUI bootstrap, visible-driver, and exec fallback commands."
+        ),
+    )
+    _add_project_arguments(codex_cli_local_driver_parser)
+    _add_codex_probe_arguments(codex_cli_local_driver_parser)
+
+    codex_cli_visible_driver_run_parser = subparsers.add_parser(
+        "codex-cli-visible-driver-run",
+        help="Build a no-execution visible Codex CLI driver run packet from quota-safe driver planning inputs.",
+    )
+    _add_project_arguments(codex_cli_visible_driver_run_parser)
+    _add_codex_probe_arguments(
+        codex_cli_visible_driver_run_parser,
+        codex_help="Codex CLI executable to probe for visible-session capabilities.",
+    )
+    _add_optional_proof_fixture(
+        codex_cli_visible_driver_run_parser,
+        help_text=(
+            "Optional public-safe visible-session proof fixture. "
+            "Without it, same-session automation remains blocked."
+        ),
+    )
+    _add_headless_fallback_argument(codex_cli_visible_driver_run_parser)
+
+
+def handle_codex_cli_visible_driver_plan_command(
+    args: argparse.Namespace,
+    print_payload: PrintPayload,
+) -> int:
+    probe_payload = run_codex_cli_session_probe(
+        codex_bin=args.codex_bin,
+        timeout_seconds=args.timeout_seconds,
+        fixture=Path(args.fixture).expanduser() if args.fixture else None,
+    )
+    payload = build_codex_cli_visible_driver_plan(
+        project=Path(args.project),
+        goal_id=args.goal_id,
+        agent_id=args.agent_id,
+        cli_bin=args.cli_bin,
+        codex_bin=args.codex_bin,
+        probe_payload=probe_payload,
+    )
+    print_payload(payload, args.format, render_codex_cli_visible_driver_plan_markdown)
+    return 0 if payload.get("ok") else 1
+
+
+def handle_codex_cli_local_driver_plan_command(
+    args: argparse.Namespace,
+    print_payload: PrintPayload,
+) -> int:
+    probe_payload = run_codex_cli_session_probe(
+        codex_bin=args.codex_bin,
+        timeout_seconds=args.timeout_seconds,
+        fixture=Path(args.fixture).expanduser() if args.fixture else None,
+    )
+    payload = build_codex_cli_local_driver_plan(
+        project=Path(args.project),
+        goal_id=args.goal_id,
+        agent_id=args.agent_id,
+        cli_bin=args.cli_bin,
+        codex_bin=args.codex_bin,
+        probe_payload=probe_payload,
+    )
+    print_payload(payload, args.format, render_codex_cli_local_driver_plan_markdown)
+    return 0 if payload.get("ok") else 1
+
+
+def handle_codex_cli_visible_driver_run_command(
+    args: argparse.Namespace,
+    print_payload: PrintPayload,
+) -> int:
+    probe_payload = run_codex_cli_session_probe(
+        codex_bin=args.codex_bin,
+        timeout_seconds=args.timeout_seconds,
+        fixture=Path(args.fixture).expanduser() if args.fixture else None,
+    )
+    proof_payload = (
+        load_codex_cli_visible_session_proof_fixture(Path(args.proof_fixture).expanduser())
+        if args.proof_fixture
+        else None
+    )
+    payload = build_codex_cli_visible_driver_run_packet(
+        project=Path(args.project),
+        goal_id=args.goal_id,
+        agent_id=args.agent_id,
+        cli_bin=args.cli_bin,
+        codex_bin=args.codex_bin,
+        probe_payload=probe_payload,
+        proof_payload=proof_payload,
+        allow_headless_fallback=bool(args.allow_headless_fallback),
+    )
+    print_payload(payload, args.format, render_codex_cli_visible_driver_run_packet_markdown)
+    return 0 if payload.get("ok") else 1
+
+
+_VISIBLE_DRIVER_HANDLERS: dict[str, Callable[[argparse.Namespace, PrintPayload], int]] = {
+    "codex-cli-visible-driver-plan": handle_codex_cli_visible_driver_plan_command,
+    "codex-cli-local-driver-plan": handle_codex_cli_local_driver_plan_command,
+    "codex-cli-visible-driver-run": handle_codex_cli_visible_driver_run_command,
+}
+
+
+def handle_starter_visible_driver_command(
+    args: argparse.Namespace,
+    print_payload: PrintPayload,
+) -> int | None:
+    pilot_result = handle_starter_visible_pilot_command(args, print_payload)
+    if pilot_result is not None:
+        return pilot_result
+    handler = _VISIBLE_DRIVER_HANDLERS.get(str(getattr(args, "command", "")))
+    if handler is None:
+        return None
+    return handler(args, print_payload)