agent-lifecycle-kit 1.50.1__py3-none-any.whl

agent_lifecycle/cli/followup.py

@@ -0,0 +1,89 @@
+"""CLI wiring for follow-up register commands."""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+from typing import Any
+
+from agent_lifecycle.contracts import LifecycleError, read_json_object
+from agent_lifecycle.followup import (
+    add_followup_item,
+    build_followup_summary,
+    close_followup_item,
+    load_followup_register,
+    validate_followup_register,
+    write_followup_register,
+)
+
+
+def add_followup_parser(subparsers: argparse._SubParsersAction[argparse.ArgumentParser]) -> None:
+    followup = subparsers.add_parser("followup", help="follow-up register commands")
+    followup_sub = followup.add_subparsers(dest="followup_command", required=True)
+    check = followup_sub.add_parser("check")
+    check.add_argument("--register", required=True)
+    check.add_argument("--state")
+    check.add_argument("--root", default=".")
+    check.add_argument("--fail-on-finalization-blockers", action="store_true")
+    add = followup_sub.add_parser("add")
+    add.add_argument("--register", required=True)
+    add.add_argument("--item", required=True)
+    add.add_argument("--out")
+    close = followup_sub.add_parser("close")
+    close.add_argument("--register", required=True)
+    close.add_argument("--item-id", required=True)
+    close.add_argument("--evidence-id", action="append", default=[])
+    close.add_argument("--artifact", action="append", default=[])
+    close.add_argument("--verifier", required=True)
+    close.add_argument("--reason", required=True)
+    close.add_argument("--root", default=".")
+    close.add_argument("--out")
+    sweep = followup_sub.add_parser("sweep")
+    sweep.add_argument("--register", required=True)
+    sweep.add_argument("--state")
+    sweep.add_argument("--profile")
+    sweep.add_argument("--target-window")
+
+
+def dispatch_followup(args: argparse.Namespace) -> dict[str, Any]:
+    register_path = Path(args.register)
+    register = load_followup_register(register_path)
+    if args.followup_command == "check":
+        state = read_json_object(Path(args.state), label="workflow state") if args.state else None
+        validation = validate_followup_register(register, state=state, root=Path(args.root))
+        if args.fail_on_finalization_blockers and validation["finalizationBlockers"]:
+            raise LifecycleError(
+                "follow-up-finalization-blocked",
+                "open follow-up items contradict current finalization",
+                {"items": validation["finalizationBlockers"]},
+            )
+        return validation
+    if args.followup_command == "add":
+        updated = add_followup_item(register, read_json_object(Path(args.item), label="follow-up item"))
+        out = Path(args.out) if args.out else register_path
+        write_followup_register(out, updated)
+        return validate_followup_register(updated)
+    if args.followup_command == "close":
+        updated = close_followup_item(
+            register,
+            item_id=args.item_id,
+            evidence_ids=args.evidence_id,
+            artifact_paths=args.artifact,
+            verifier=args.verifier,
+            reason=args.reason,
+            root=Path(args.root),
+        )
+        out = Path(args.out) if args.out else register_path
+        write_followup_register(out, updated)
+        validation = validate_followup_register(updated, root=Path(args.root))
+        return {
+            "schemaVersion": "agent-follow-up-close-result.v1",
+            "status": "PASS",
+            "itemId": args.item_id,
+            "registerDigest": validation["registerDigest"],
+        }
+    if args.followup_command == "sweep":
+        state = read_json_object(Path(args.state), label="workflow state") if args.state else None
+        profile = read_json_object(Path(args.profile), label="context profile") if args.profile else None
+        return build_followup_summary(register, state=state, profile=profile, window=args.target_window)
+    raise LifecycleError("command-not-implemented", "followup command is not implemented")

agent_lifecycle/cli/main.py

@@ -0,0 +1,41 @@
+"""Thin root CLI entrypoint for Agent Lifecycle Kit."""
+
+from __future__ import annotations
+
+import sys
+
+from agent_lifecycle.cli.dispatch import dispatch
+from agent_lifecycle.cli.parsers import build_parser
+from agent_lifecycle.contracts import LifecycleError, canonical_bytes
+from agent_lifecycle.neutrality.cli import main as neutrality_main
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = build_parser()
+    args, remainder = parser.parse_known_args(argv)
+    if args.command == "neutrality":
+        return neutrality_main(remainder)
+    try:
+        payload = dispatch(args, remainder)
+    except LifecycleError as exc:
+        _write(exc.to_json())
+        return 2
+    if payload is None:
+        return 0
+    if isinstance(payload, str):
+        _write_text(payload)
+        return 0
+    _write(payload)
+    return 0
+
+
+def _write(payload: dict[str, object]) -> None:
+    sys.stdout.write(canonical_bytes(payload).decode("utf-8") + "\n")
+
+
+def _write_text(payload: str) -> None:
+    sys.stdout.write(payload.rstrip("\n") + "\n")
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

agent_lifecycle/cli/metrics_parser.py

@@ -0,0 +1,49 @@
+"""Argparse construction for lifecycle metrics commands."""
+
+from __future__ import annotations
+
+import argparse
+
+MODES = ("light", "standard", "strict", "release")
+
+
+def add_metrics_parser(subparsers: argparse._SubParsersAction[argparse.ArgumentParser]) -> None:
+    metrics = subparsers.add_parser("metrics", help="resource and lifecycle metrics commands")
+    metrics_sub = metrics.add_subparsers(dest="metrics_command", required=True)
+    cost_check = metrics_sub.add_parser("cost-check")
+    cost_check.add_argument("--receipt", required=True)
+    cost_report = metrics_sub.add_parser("cost-report")
+    cost_report.add_argument("--artifact", action="append", default=[])
+    cost_report.add_argument("--mode", choices=MODES, default="standard")
+    cost_report.add_argument("--project-root", default=".")
+    cost_report.add_argument("--out", required=True)
+    cost_report.add_argument("--summary-out")
+    usage_export = metrics_sub.add_parser("usage-export")
+    usage_export.add_argument("--artifact", action="append", default=[])
+    usage_export.add_argument("--project-root", default=".")
+    usage_export.add_argument("--format", choices=("json", "table"), default="json")
+    usage_export.add_argument("--out", required=True)
+    outcome_index = metrics_sub.add_parser("outcome-index")
+    outcome_index.add_argument("--artifact", action="append", default=[])
+    outcome_index.add_argument("--out")
+    quality_signals = metrics_sub.add_parser("quality-signals")
+    quality_signals.add_argument("--index", required=True)
+    quality_signals.add_argument("--out")
+    recommend = metrics_sub.add_parser("recommend")
+    recommend.add_argument("--report", action="append", default=[])
+    recommend.add_argument("--baseline-profile", default="profiles/lifecycle-baselines.v1.json")
+    recommend.add_argument("--task-shape", default="feature")
+    recommend.add_argument("--current-mode", choices=MODES)
+    recommend.add_argument("--sdd-tier")
+    recommend.add_argument("--risk", action="append", default=[])
+    recommend.add_argument("--out")
+    recommend.add_argument("--summary-out")
+    learn_recommend = metrics_sub.add_parser("learn-recommend")
+    learn_recommend.add_argument("--signals", required=True)
+    learn_recommend.add_argument("--baseline-profile", default="profiles/lifecycle-baselines.v1.json")
+    learn_recommend.add_argument("--task-shape", default="feature")
+    learn_recommend.add_argument("--current-mode", choices=MODES)
+    learn_recommend.add_argument("--sdd-tier")
+    learn_recommend.add_argument("--risk", action="append", default=[])
+    learn_recommend.add_argument("--out")
+    learn_recommend.add_argument("--summary-out")