loopx 0.4.8__py3-none-any.whl

loopx/cli_commands/status_registration.py

@@ -0,0 +1,239 @@
+from __future__ import annotations
+
+import argparse
+from collections.abc import Callable
+from pathlib import Path
+
+
+def default_public_scan_root() -> str:
+    return str(Path(__file__).resolve().parents[2])
+
+
+def register_status_commands(
+    subparsers: argparse._SubParsersAction,
+    add_subcommand_format: Callable[[argparse.ArgumentParser], None],
+) -> None:
+    check_parser = subparsers.add_parser(
+        "check",
+        help="Run a read-only contract and public/private boundary check.",
+    )
+    check_parser.add_argument(
+        "--scan-root",
+        default=".",
+        help="Public files to scan for obvious private material.",
+    )
+    check_parser.add_argument(
+        "--scan-path",
+        action="append",
+        default=[],
+        help=(
+            "Specific public file or directory to scan. Repeatable. "
+            "Overrides --scan-root when set."
+        ),
+    )
+    check_parser.add_argument("--limit", type=int, default=5)
+
+    status_parser = subparsers.add_parser(
+        "status",
+        help="Show a first-screen goal status and attention queue.",
+    )
+    add_subcommand_format(status_parser)
+    status_parser.add_argument(
+        "--scan-root",
+        default=default_public_scan_root(),
+        help=(
+            "Public files to scan for obvious private material. "
+            "Defaults to the LoopX install root."
+        ),
+    )
+    status_parser.add_argument(
+        "--scan-path",
+        action="append",
+        default=[],
+        help=(
+            "Specific public file or directory to scan. Repeatable. "
+            "Overrides --scan-root when set."
+        ),
+    )
+    status_parser.add_argument("--limit", type=int, default=5)
+    status_parser.add_argument(
+        "--goal-id",
+        help=(
+            "Optional goal id to focus the status projection. The default remains "
+            "the global dashboard/status view."
+        ),
+    )
+    status_parser.add_argument(
+        "--agent-id",
+        help=(
+            "Registered agent id for adding agent-lane next-action projection "
+            "to matching status queue items."
+        ),
+    )
+    status_parser.add_argument(
+        "--available-capability",
+        dest="available_capabilities",
+        action="append",
+        help=(
+            "Declare a capability available in the current execution envelope. "
+            "Repeat for multiple capabilities; capability-gated status fields "
+            "remain absent by default."
+        ),
+    )
+    status_parser.add_argument(
+        "--include-task-graph",
+        action="store_true",
+        help=(
+            "Include the optional task_graph_projection_v0 on status items. "
+            "Default status output keeps this graph on the cold path to stay "
+            "inside the dashboard hot-path budget."
+        ),
+    )
+    status_parser.add_argument(
+        "--use-projection-cache",
+        action="store_true",
+        help=(
+            "Read a fresh status_projection_cache_v0 snapshot before running "
+            "the full status collector. Misses and expired snapshots fall back "
+            "to the full collector."
+        ),
+    )
+    status_parser.add_argument(
+        "--write-projection-cache",
+        action="store_true",
+        help=(
+            "Write the collected status projection to the cache after a full "
+            "collection."
+        ),
+    )
+    status_parser.add_argument(
+        "--projection-cache-ttl-seconds",
+        type=int,
+        default=120,
+        help="Freshness window for --use-projection-cache. Defaults to 120 seconds.",
+    )
+
+    diagnose_parser = subparsers.add_parser(
+        "diagnose",
+        help=(
+            "Build a LoopX diagnostic evidence packet for the user's agent to "
+            "reason over."
+        ),
+    )
+    add_subcommand_format(diagnose_parser)
+    diagnose_parser.add_argument(
+        "--goal-id",
+        help="Goal id to diagnose. Defaults to the first attention item.",
+    )
+    diagnose_parser.add_argument(
+        "--agent-id",
+        help=(
+            "Registered agent id for identity-scoped quota/todo projection. "
+            "Use this for multi-agent goals and heartbeat-driven diagnosis."
+        ),
+    )
+    diagnose_parser.add_argument(
+        "--available-capability",
+        dest="available_capabilities",
+        action="append",
+        help=(
+            "Declare a capability available in the current agent environment. "
+            "Repeat for multiple capabilities so diagnose uses the same runtime "
+            "envelope as quota should-run."
+        ),
+    )
+    diagnose_parser.add_argument(
+        "--scan-root",
+        default=default_public_scan_root(),
+        help=(
+            "Public files to scan for obvious private material. "
+            "Defaults to the LoopX install root."
+        ),
+    )
+    diagnose_parser.add_argument(
+        "--scan-path",
+        action="append",
+        default=[],
+        help=(
+            "Specific public file or directory to scan. Repeatable. "
+            "Overrides --scan-root when set."
+        ),
+    )
+    diagnose_parser.add_argument("--limit", type=int, default=5)
+
+    review_packet_parser = subparsers.add_parser(
+        "review-packet",
+        help=(
+            "Generate a CLI-visible Review Packet from the current status contract, "
+            "including agent-scoped evidence-log read hints when available."
+        ),
+    )
+    review_packet_parser.add_argument(
+        "--goal-id",
+        required=True,
+        help="Goal id to package for review or handoff.",
+    )
+    review_packet_parser.add_argument(
+        "--action-kind",
+        choices=["reward", "controller", "codex", "evidence", "health"],
+        help=(
+            "Override inferred action kind. Defaults to the goal's current "
+            "attention item."
+        ),
+    )
+    review_packet_parser.add_argument(
+        "--review-url",
+        help="Optional dashboard review URL to include in the packet.",
+    )
+    review_packet_parser.add_argument(
+        "--scan-root",
+        default=default_public_scan_root(),
+        help=(
+            "Public files to scan for obvious private material. "
+            "Defaults to the LoopX install root."
+        ),
+    )
+    review_packet_parser.add_argument(
+        "--scan-path",
+        action="append",
+        default=[],
+        help=(
+            "Specific public file or directory to scan. Repeatable. "
+            "Overrides --scan-root when set."
+        ),
+    )
+    review_packet_parser.add_argument(
+        "--handoff-only",
+        action="store_true",
+        help=(
+            "Print only the target project-agent handoff in markdown output; "
+            "JSON output returns a minimized handoff payload."
+        ),
+    )
+    review_packet_parser.add_argument(
+        "--format",
+        dest="review_packet_format",
+        choices=["markdown", "json"],
+        help=(
+            "Output format for review-packet. This mirrors the global --format "
+            "flag and may appear after the subcommand."
+        ),
+    )
+    review_packet_parser.add_argument(
+        "--agent-id",
+        help=(
+            "Registered agent id for adding read-only agent-member status to "
+            "the review packet."
+        ),
+    )
+    review_packet_parser.add_argument(
+        "--available-capability",
+        dest="available_capabilities",
+        action="append",
+        help=(
+            "Declare a capability available in the current execution envelope. "
+            "Repeat for multiple capabilities; capability-gated review fields "
+            "remain absent by default."
+        ),
+    )
+    review_packet_parser.add_argument("--limit", type=int, default=5)

loopx/cli_commands/summary_all.py

@@ -0,0 +1,222 @@
+from __future__ import annotations
+
+import argparse
+from collections.abc import Callable
+from pathlib import Path
+
+from ..global_risks import (
+    build_global_risks,
+    build_global_risks_error,
+    render_global_risks_markdown,
+)
+from ..global_todos import (
+    build_global_todos,
+    build_global_todos_error,
+    render_global_todos_markdown,
+)
+from ..summary_all import (
+    build_global_gates,
+    build_global_gates_error,
+    build_summary_all,
+    render_global_gates_markdown,
+    render_summary_all_markdown,
+)
+
+
+PrintPayload = Callable[
+    [dict[str, object], str, Callable[[dict[str, object]], str]],
+    None,
+]
+FormatSelector = Callable[..., str]
+
+
+def default_public_scan_root() -> str:
+    return str(Path(__file__).resolve().parents[2])
+
+
+def _scan_roots(args: argparse.Namespace) -> list[Path]:
+    scan_roots = [Path(item).expanduser() for item in args.scan_path]
+    return scan_roots or [Path(args.scan_root).expanduser()]
+
+
+def _add_current_manager_flags(
+    parser: argparse.ArgumentParser,
+    *,
+    agent_help: str,
+    limit_help: str,
+) -> None:
+    parser.add_argument("--agent-id", help=agent_help)
+    parser.add_argument("--limit", type=int, default=8, help=limit_help)
+    parser.add_argument(
+        "--scan-root",
+        default=default_public_scan_root(),
+        help=(
+            "Public files to scan for obvious private material. "
+            "Defaults to the LoopX install root."
+        ),
+    )
+    parser.add_argument(
+        "--scan-path",
+        action="append",
+        default=[],
+        help=(
+            "Specific public file or directory to scan. Repeatable. "
+            "Overrides --scan-root when set."
+        ),
+    )
+
+
+def register_summary_all_command(
+    subparsers: argparse._SubParsersAction,
+    add_subcommand_format: Callable[[argparse.ArgumentParser], None],
+) -> None:
+    parser = subparsers.add_parser(
+        "global-summary",
+        help=(
+            "Read a public-safe /loopx-global-summary progress digest; "
+            "see `loopx slash-commands` for slash help."
+        ),
+    )
+    add_subcommand_format(parser)
+    _add_current_manager_flags(
+        parser,
+        agent_help="Registered agent id for agent-lane quota projection.",
+        limit_help="Maximum items per digest section.",
+    )
+    parser.add_argument(
+        "--time-range",
+        default="24h",
+        help="Recent progress window, e.g. 24h or 7d.",
+    )
+
+    gates_parser = subparsers.add_parser(
+        "global-gates",
+        help=(
+            "Read public-safe /loopx-global-gates user/controller decisions; "
+            "see `loopx slash-commands` for slash help."
+        ),
+    )
+    add_subcommand_format(gates_parser)
+    _add_current_manager_flags(
+        gates_parser,
+        agent_help="Registered agent id used to narrow gate projection.",
+        limit_help="Maximum returned gate count.",
+    )
+
+    todos_parser = subparsers.add_parser(
+        "global-todos",
+        help=(
+            "Read a public-safe current-state todo inbox across visible goals; "
+            "see `loopx slash-commands` for slash help."
+        ),
+    )
+    add_subcommand_format(todos_parser)
+    _add_current_manager_flags(
+        todos_parser,
+        agent_help="Registered agent id used to narrow todo projection.",
+        limit_help="Maximum returned todo count.",
+    )
+
+    risks_parser = subparsers.add_parser(
+        "global-risks",
+        help=(
+            "Read a public-safe current risk inbox across visible goals; "
+            "see `loopx slash-commands` for slash help."
+        ),
+    )
+    add_subcommand_format(risks_parser)
+    _add_current_manager_flags(
+        risks_parser,
+        agent_help="Registered agent id used to narrow risk projection.",
+        limit_help="Maximum returned risk count.",
+    )
+    risks_parser.add_argument(
+        "--time-range",
+        default="24h",
+        help=(
+            "Risk request window for protocol compatibility, e.g. 24h or 7d; "
+            "current risks remain visible."
+        ),
+    )
+
+
+def handle_summary_all_command(
+    args: argparse.Namespace,
+    *,
+    registry_path: Path,
+    runtime_root_arg: str | None,
+    output_format: FormatSelector,
+    print_payload: PrintPayload,
+) -> int | None:
+    if args.command not in {
+        "global-summary",
+        "global-gates",
+        "global-todos",
+        "global-risks",
+    }:
+        return None
+    if args.command == "global-risks":
+        try:
+            payload = build_global_risks(
+                registry_path=registry_path,
+                runtime_root_override=runtime_root_arg,
+                scan_roots=_scan_roots(args),
+                agent_id=args.agent_id,
+                time_range=args.time_range,
+                limit=max(1, args.limit),
+            )
+        except Exception as exc:
+            payload = build_global_risks_error(exc, time_range=args.time_range)
+        print_payload(payload, output_format(args), render_global_risks_markdown)
+        return 0 if payload.get("ok") else 1
+    if args.command == "global-gates":
+        try:
+            payload = build_global_gates(
+                registry_path=registry_path,
+                runtime_root_override=runtime_root_arg,
+                scan_roots=_scan_roots(args),
+                agent_id=args.agent_id,
+                limit=max(1, args.limit),
+            )
+        except Exception as exc:
+            payload = build_global_gates_error(exc)
+        print_payload(payload, output_format(args), render_global_gates_markdown)
+        return 0 if payload.get("ok") else 1
+    if args.command == "global-todos":
+        try:
+            payload = build_global_todos(
+                registry_path=registry_path,
+                runtime_root_override=runtime_root_arg,
+                scan_roots=_scan_roots(args),
+                agent_id=args.agent_id,
+                limit=max(1, args.limit),
+            )
+        except Exception as exc:
+            payload = build_global_todos_error(exc)
+        print_payload(payload, output_format(args), render_global_todos_markdown)
+        return 0 if payload.get("ok") else 1
+
+    try:
+        payload = build_summary_all(
+            registry_path=registry_path,
+            runtime_root_override=runtime_root_arg,
+            scan_roots=_scan_roots(args),
+            agent_id=args.agent_id,
+            time_range=args.time_range,
+            limit=max(1, args.limit),
+        )
+    except Exception as exc:
+        payload = {
+            "ok": False,
+            "schema_version": "global_manager_command_response_v0",
+            "request": {
+                "schema_version": "global_manager_command_request_v0",
+                "command": "/loopx-global-summary",
+                "legacy_aliases": ["/loop-global-summary"],
+                "privacy_mode": "public_safe_summary",
+                "dry_run": True,
+            },
+            "error": str(exc),
+        }
+    print_payload(payload, output_format(args), render_summary_all_markdown)
+    return 0 if payload.get("ok") else 1