core-cli 1.0.0__py3-none-any.whl

core_cli/resources/project/scout.py

@@ -0,0 +1,288 @@
+# src/core_cli/resources/project/scout.py
+
+"""BYOR Scout Phase B — per-rule ratification CLI over HTTP (ADR-146 D2 / ADR-119).
+
+Calls POST /v1/project/scout to get LLM-induced + catalog-matched candidates,
+then walks the operator through per-rule Accept/Downgrade/Skip ratification
+(ADR-119 D5 — no --accept-all). Confirmed rules are written to:
+  <path>/.intent/rules/scout_inducted.json
+  <path>/.intent/enforcement/mappings/scout.yaml
+
+File writes use direct stdlib (same as byor.py) — this is intentional; the
+.intent/ tree lives in the consumer project, not in CORE, so FileHandler and
+ActionExecutor (which gate CORE's own .intent/) do not apply.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+import typer
+import yaml
+from rich.console import Console
+from rich.rule import Rule
+
+from api.cli import CoreApiClient
+from cli.utils import core_command
+
+from . import app
+
+
+console = Console()
+
+_ENFORCEMENT_LEVELS = ("blocking", "reporting", "advisory")
+_RULES_OUTPUT = "rules/scout_inducted.json"
+_MAPPINGS_OUTPUT = "enforcement/mappings/scout.yaml"
+
+
+@app.command("scout")
+@core_command(dangerous=True, requires_context=False, requires_brain_services=False)
+# ID: 55eee96e-6306-4452-a334-29c71135196e
+async def scout_project(
+    ctx: typer.Context,
+    path: Path = typer.Argument(
+        ..., help="Path to the target repository.", exists=True
+    ),
+    write: bool = typer.Option(
+        False, "--write", help="Write inducted rules to .intent/ after ratification."
+    ),
+    reset: bool = typer.Option(
+        False,
+        "--reset",
+        help="Clear existing scout_inducted.json and re-run induction.",
+    ),
+) -> None:
+    """Induce and ratify governance rules for a repository — Phase B (BYOR Scout).
+
+    Calls the CORE API to extract signals and propose candidate rules
+    (LLM-assisted; falls back to a universal menu when LLM is unavailable).
+    Walks you through per-rule ratification. Only confirmed rules are written
+    (ADR-119 D5 — no --accept-all). Requires Phase A first:
+    run `project onboard <target> --write` before this command.
+    """
+    console.print(Rule("[bold cyan]Scout — Phase B: Rule Induction[/bold cyan]"))
+    console.print(f"[bold cyan]Target:[/bold cyan] {path}")
+
+    client = CoreApiClient()
+    try:
+        result = await client.project.scout(str(path), reset=reset)
+    except Exception as exc:
+        import httpx
+
+        if isinstance(exc, httpx.HTTPStatusError):
+            detail = exc.response.json().get("detail", str(exc))
+            console.print(f"[red]Scout failed: {detail}[/red]")
+        else:
+            console.print(f"[red]Scout failed: {exc}[/red]")
+        raise typer.Exit(1) from exc
+
+    candidates: list[dict[str, Any]] = result.get("candidates", [])
+    candidate_count = result.get("candidate_count", len(candidates))
+    matched = result.get("matched", 0)
+
+    console.print(
+        f"\n[cyan]Suggest[/cyan] — {candidate_count} candidate(s) received "
+        f"({matched} catalog-matched, {candidate_count - matched} declared-only)\n"
+    )
+
+    if not candidates:
+        console.print(
+            "[yellow]No candidate rules returned. Nothing to ratify.[/yellow]"
+        )
+        return
+
+    # ── Confirm (ADR-119 D5 — mandatory per-rule ratification) ───────────────
+    confirmed = _run_confirm_loop(candidates)
+
+    if not confirmed:
+        console.print("\n[yellow]No rules confirmed. Nothing written.[/yellow]")
+        return
+
+    # ── Write ─────────────────────────────────────────────────────────────────
+    target_intent = Path(path).resolve() / ".intent"
+    rules_json = _build_rules_document(confirmed)
+    mappings_yaml = _build_mappings_document(confirmed)
+
+    for output_rel, content in (
+        (_RULES_OUTPUT, rules_json),
+        (_MAPPINGS_OUTPUT, mappings_yaml),
+    ):
+        dest = target_intent / output_rel
+        if write:
+            dest.parent.mkdir(parents=True, exist_ok=True)
+            dest.write_text(content, encoding="utf-8")
+            console.print(f"[green]  ✅ Written: .intent/{output_rel}[/green]")
+        else:
+            console.print(f"[dim]  [DRY RUN] would write: .intent/{output_rel}[/dim]")
+
+    enforced = sum(1 for c in confirmed if c.get("enforcement_matched"))
+    declared_only = len(confirmed) - enforced
+
+    if not write:
+        console.print(
+            f"\n[yellow]Dry run — {len(confirmed)} rule(s) would be written "
+            f"({enforced} enforced, {declared_only} declared-only). "
+            "Pass --write to apply.[/yellow]"
+        )
+    else:
+        console.print(
+            f"\n[green]✅ {len(confirmed)} rule(s) written to {target_intent} "
+            f"({enforced} enforced, {declared_only} declared-only)[/green]"
+        )
+        console.print(
+            "Next: run `core-admin code audit --offline` against this repo to enforce them."
+        )
+
+
+# ── Confirm loop (ADR-119 D5) ─────────────────────────────────────────────────
+
+
+def _run_confirm_loop(candidates: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    from rich.prompt import Prompt
+
+    confirmed: list[dict[str, Any]] = []
+    total = len(candidates)
+
+    for idx, candidate in enumerate(candidates, start=1):
+        console.print(Rule(f"Rule {idx} / {total}"))
+        _display_candidate(candidate)
+
+        try:
+            choice = Prompt.ask(
+                "[bold]Action[/bold]",
+                choices=["a", "r", "c"],
+                default="a",
+                show_choices=True,
+                show_default=True,
+            ).lower()
+        except (EOFError, KeyboardInterrupt):
+            console.print(
+                "\n[yellow]Confirmation interrupted — no further rules reviewed.[/yellow]"
+            )
+            break
+
+        if choice == "r":
+            console.print("[dim]  ↳ Rejected.[/dim]")
+            continue
+
+        if choice == "c":
+            try:
+                new_level = Prompt.ask(
+                    "  New enforcement level",
+                    choices=list(_ENFORCEMENT_LEVELS),
+                    default=candidate.get("enforcement", "reporting"),
+                ).lower()
+            except (EOFError, KeyboardInterrupt):
+                console.print(
+                    "\n[yellow]Level change interrupted — rule rejected.[/yellow]"
+                )
+                continue
+            candidate = {**candidate, "enforcement": new_level}
+
+        console.print(f"[green]  ↳ Accepted ({candidate['enforcement']}).[/green]")
+        confirmed.append(candidate)
+
+    return confirmed
+
+
+def _display_candidate(candidate: dict[str, Any]) -> None:
+    rule_id = candidate.get("rule_id", "<unknown>")
+    statement = candidate.get("statement", "")
+    enforcement = candidate.get("enforcement", "reporting")
+    rationale = candidate.get("rationale", "")
+    evidence = candidate.get("evidence_sample", "")
+    ramp = candidate.get("ramp_note", "")
+    matched = candidate.get("enforcement_matched", False)
+
+    color = {"blocking": "red", "reporting": "yellow", "advisory": "dim"}.get(
+        enforcement, "white"
+    )
+
+    console.print("  [bold underline]OBSERVATION[/bold underline]")
+    console.print(f"  [bold]ID:[/bold]          {rule_id}")
+    console.print(f"  [bold]Statement:[/bold]   {statement}")
+    console.print(f"  [bold]Enforcement:[/bold] [{color}]{enforcement}[/{color}]")
+    console.print(f"  [bold]Rationale:[/bold]   {rationale}")
+    if evidence:
+        console.print(f"  [bold]Evidence:[/bold]    {evidence}")
+    if ramp:
+        console.print(f"  [bold]Ramp note:[/bold]   [yellow]{ramp}[/yellow]")
+
+    console.print()
+    console.print("  [bold underline]ENFORCEMENT[/bold underline]")
+    if matched:
+        engine = candidate.get("engine", "")
+        params = candidate.get("params", {})
+        scope = candidate.get("scope", {})
+        applies = scope.get("applies_to", [])
+        excludes = scope.get("excludes", [])
+        console.print(
+            f"  [bold]Engine:[/bold]      {engine} {json.dumps(params, separators=(',', ':'))}"
+        )
+        console.print(f"  [bold]Scope:[/bold]       applies_to {applies}")
+        if excludes:
+            console.print(f"               excludes   {excludes}")
+    else:
+        console.print(
+            "  [yellow]⚠  No catalog match — rule will be declared but not enforced.[/yellow]"
+        )
+
+    console.print()
+    console.print("  [dim]a = accept · r = reject · c = change enforcement level[/dim]")
+
+
+# ── Output builders ────────────────────────────────────────────────────────────
+
+
+def _build_rules_document(confirmed: list[dict[str, Any]]) -> str:
+    rules = []
+    for c in confirmed:
+        rule: dict[str, Any] = {
+            "id": c["rule_id"],
+            "statement": c["statement"],
+            "authority": "policy",
+            "phase": "runtime",
+            "enforcement": c["enforcement"],
+            "rationale": c.get("rationale", ""),
+        }
+        if not c.get("enforcement_matched"):
+            rule["enforcement_note"] = (
+                "declared-only: no enforcement catalog entry exists for this rule."
+            )
+        rules.append(rule)
+    doc = {
+        "$schema": "META/rule_document.schema.json",
+        "kind": "rule_document",
+        "metadata": {
+            "id": "rules.scout_inducted",
+            "title": "Scout-Inducted Rules",
+            "version": "1.0.0",
+            "authority": "policy",
+            "phase": "runtime",
+            "status": "active",
+        },
+        "rules": rules,
+    }
+    return json.dumps(doc, indent=2)
+
+
+def _build_mappings_document(confirmed: list[dict[str, Any]]) -> str:
+    mappings: dict[str, Any] = {}
+    for c in confirmed:
+        if not c.get("enforcement_matched"):
+            continue
+        scope = c.get("scope", {})
+        entry: dict[str, Any] = {
+            "engine": c.get("engine", "ast_gate"),
+            "params": c.get("params", {}),
+            "scope": {
+                "applies_to": scope.get("applies_to", ["**/*.py"]),
+            },
+        }
+        excludes = scope.get("excludes", [])
+        if excludes:
+            entry["scope"]["excludes"] = excludes
+        mappings[c["rule_id"]] = entry
+    return yaml.dump({"mappings": mappings}, default_flow_style=False, sort_keys=False)

core_cli/resources/proposals/__init__.py

@@ -0,0 +1,27 @@
+# src/cli/resources/proposals/__init__.py
+"""A3 Autonomous Proposal management."""
+
+from __future__ import annotations
+
+import typer
+
+from . import create, manage
+from . import list as list_mod
+
+
+app = typer.Typer(
+    name="proposals",
+    help="Operations for the A3 Autonomous Proposal system (propose, approve, execute).",
+    no_args_is_help=True,
+)
+
+
+# Register actions
+app.command("list")(list_mod.list_proposals)
+app.command("create")(create.create_proposal)
+app.command("show")(manage.show_proposal)
+app.command("approve")(manage.approve_proposal)
+app.command("reject")(manage.reject_proposal)
+app.command("execute")(manage.execute_proposal)
+
+__all__ = ["app"]

core_cli/resources/proposals/create.py

@@ -0,0 +1,99 @@
+# src/core_cli/resources/proposals/create.py
+
+from __future__ import annotations
+
+import httpx
+import typer
+from rich.console import Console
+
+from api.cli import CoreApiClient
+from cli.utils import core_command
+
+
+console = Console()
+
+
+def _parse_action_options(action_strs: list[str]) -> list[dict]:
+    """Parse CLI action strings (action_id:key=val) into plain dicts.
+
+    Returns dicts with keys {action_id, parameters, order} matching the
+    POST /v1/proposals action body schema. Preserves input order.
+    """
+    proposal_actions: list[dict] = []
+    for i, action_str in enumerate(action_strs):
+        if ":" in action_str:
+            action_id, params_str = action_str.split(":", 1)
+            parameters: dict[str, str] = {}
+            for param in params_str.split(","):
+                if "=" in param:
+                    key, value = param.split("=", 1)
+                    parameters[key.strip()] = value.strip()
+        else:
+            action_id = action_str
+            parameters = {}
+        proposal_actions.append(
+            {"action_id": action_id, "parameters": parameters, "order": i}
+        )
+    return proposal_actions
+
+
+@core_command(dangerous=True, requires_context=False)
+# ID: e3cc0065-b821-49dd-b90e-df86633d01c6
+async def create_proposal(
+    goal: str = typer.Argument(..., help="Strategic goal of the proposal."),
+    actions: list[str] = typer.Option(
+        [], "--action", "-a", help="Format: action_id:param=value"
+    ),
+    files: list[str] = typer.Option(
+        [], "--file", "-f", help="Specific files affected."
+    ),
+    write: bool = typer.Option(
+        False, "--write", help="Persist the proposal. Dry-run by default."
+    ),
+) -> None:
+    """Create a new autonomous proposal for system modification.
+
+    Validates the plan and performs an initial risk assessment.
+    """
+    console.print(f"[bold cyan]📝 Crafting Proposal:[/bold cyan] {goal}")
+    proposal_actions = _parse_action_options(actions)
+    if not proposal_actions:
+        console.print(
+            "[yellow]⚠️ Warning: No actions specified. "
+            "Proposal created as placeholder.[/yellow]"
+        )
+
+    client = CoreApiClient()
+    try:
+        response = await client.create_proposal(
+            goal=goal,
+            actions=proposal_actions,
+            files=files,
+            write=write,
+        )
+    except httpx.HTTPStatusError as exc:
+        try:
+            detail = exc.response.json().get("detail", exc.response.text)
+        except ValueError:
+            detail = exc.response.text
+        console.print(f"[red]Proposal creation failed: {detail}[/red]")
+        raise typer.Exit(1) from exc
+
+    proposal = response["proposal"]
+    risk_level = proposal["risk"]["overall_risk"] if proposal.get("risk") else "unknown"
+    console.print(f"Risk Tier: [bold]{risk_level.upper()}[/bold]")
+
+    if not write:
+        console.print(
+            "[yellow]⚠️  DRY RUN MODE — No changes made. "
+            "Use --write to persist.[/yellow]"
+        )
+        console.print(f"[dim]Proposal goal: {proposal['goal']}[/dim]")
+        return
+
+    console.print(
+        f"[green]✅ Proposal created: [bold]{proposal['proposal_id']}[/bold][/green]"
+    )
+    console.print(
+        f"[dim]Run 'core proposals approve {proposal['proposal_id']}' to authorize.[/dim]"
+    )

core_cli/resources/proposals/integrate.py

@@ -0,0 +1,57 @@
+# src/cli/resources/proposals/integrate.py
+"""
+Proposals Integration Action.
+Orchestrates the final integration of staged code changes into the system.
+"""
+
+from __future__ import annotations
+
+import httpx
+import typer
+from rich.console import Console
+
+from api.cli import CoreApiClient
+from cli.utils import core_command
+
+from . import app
+
+
+console = Console()
+
+
+@app.command("integrate")
+@core_command(dangerous=True, requires_context=False)
+# ID: f779e122-cafa-44a9-80cc-b4b1a31cc363
+async def integrate_cmd(
+    commit_message: str = typer.Option(
+        ..., "-m", "--message", help="The git commit message for this integration."
+    ),
+    write: bool = typer.Option(
+        False, "--write", help="Commit and integrate staged changes (default: dry-run)."
+    ),
+) -> None:
+    """Finalize and integrate staged changes into the repository."""
+    console.print("[bold cyan]🚀 Initiating integration sequence...[/bold cyan]")
+    if not write:
+        console.print(
+            "[yellow]DRY-RUN:[/yellow] Pass [bold]--write[/bold] to integrate staged changes."
+        )
+        return
+    client = CoreApiClient()
+    try:
+        await client.integrate(commit_message=commit_message)
+    except httpx.HTTPStatusError as exc:
+        try:
+            detail = exc.response.json().get("detail", {})
+        except ValueError:
+            detail = {}
+        exit_code = (
+            (detail or {}).get("exit_code", 1) if isinstance(detail, dict) else 1
+        )
+        error = (detail or {}).get("error") if isinstance(detail, dict) else str(detail)
+        console.print(f"[red]Integration failed: {error or exc.response.text}[/red]")
+        raise typer.Exit(exit_code) from exc
+
+    console.print(
+        "[bold green]✅ Changes successfully integrated and committed.[/bold green]"
+    )

core_cli/resources/proposals/list.py

@@ -0,0 +1,115 @@
+# src/core_cli/resources/proposals/list.py
+
+from __future__ import annotations
+
+import logging
+from datetime import datetime
+
+import httpx
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from api.cli import CoreApiClient
+from cli.utils import core_command
+
+
+logger = logging.getLogger(__name__)
+
+console = Console()
+
+_DEFAULT_LIMIT = 20
+
+_STATUS_COLORS: dict[str, str] = {
+    "draft": "white",
+    "pending": "yellow",
+    "approved": "green",
+    "executing": "blue",
+    "completed": "green",
+    "failed": "red",
+    "rejected": "red",
+}
+_RISK_COLORS: dict[str, str] = {"safe": "green", "moderate": "yellow", "high": "red"}
+
+
+def _render_list_table(proposals: list[dict], title: str) -> Table:
+    table = Table(title=title)
+    table.add_column("ID", style="cyan", no_wrap=True)
+    table.add_column("Goal", style="white")
+    table.add_column("Status", style="bold")
+    table.add_column("Actions", justify="center")
+    table.add_column("Risk", justify="center")
+    table.add_column("Created", style="dim")
+    for p in proposals:
+        status = p["status"]
+        s_color = _STATUS_COLORS.get(status, "white")
+        risk_level = p["risk"]["overall_risk"] if p.get("risk") else "unknown"
+        r_color = _RISK_COLORS.get(risk_level, "white")
+        created = datetime.fromisoformat(p["created_at"]).strftime("%Y-%m-%d %H:%M")
+        goal = p.get("goal") or ""
+        table.add_row(
+            p["proposal_id"][:8] + "...",
+            goal[:50] + ("..." if len(goal) > 50 else ""),
+            f"[{s_color}]{status}[/{s_color}]",
+            str(len(p.get("actions", []))),
+            f"[{r_color}]{risk_level}[/{r_color}]",
+            created,
+        )
+    return table
+
+
+@core_command(dangerous=False, requires_context=False)
+# ID: 0485ff02-01f2-4f9d-b22d-9fde692b8bf7
+async def list_proposals(
+    status: str = typer.Option(
+        None, "--status", "-s", help="Filter by status (pending, approved, etc.)"
+    ),
+    limit: int = typer.Option(_DEFAULT_LIMIT, "--limit", "-n", help="Max results."),
+    full_ids: bool = typer.Option(
+        False,
+        "--full-ids",
+        "-f",
+        help="Show complete proposal IDs instead of truncating.",
+    ),
+) -> None:
+    """List recent autonomous proposals and their risk assessments."""
+    client = CoreApiClient()
+    try:
+        response = await client.list_proposals(status=status or None, limit=limit)
+    except httpx.HTTPStatusError as exc:
+        if exc.response.status_code == 400:
+            console.print(f"[red]Invalid status: {status}[/red]")
+            return
+        raise
+
+    proposals = response["proposals"]
+    title = f"Proposals ({status})" if status else "Recent Proposals"
+
+    if not proposals:
+        console.print("[yellow]No proposals found.[/yellow]")
+    elif full_ids:
+        table = Table(title=title)
+        table.add_column("ID", style="cyan", no_wrap=True)
+        table.add_column("Goal", style="white")
+        table.add_column("Status", style="bold")
+        table.add_column("Actions", justify="center")
+        table.add_column("Risk", justify="center")
+        table.add_column("Created", style="dim")
+        for p in proposals:
+            s = p["status"]
+            s_color = _STATUS_COLORS.get(s, "white")
+            risk_level = p["risk"]["overall_risk"] if p.get("risk") else "unknown"
+            r_color = _RISK_COLORS.get(risk_level, "white")
+            created = datetime.fromisoformat(p["created_at"]).strftime("%Y-%m-%d %H:%M")
+            goal = p.get("goal") or ""
+            table.add_row(
+                p["proposal_id"],
+                goal[:50] + ("..." if len(goal) > 50 else ""),
+                f"[{s_color}]{s}[/{s_color}]",
+                str(len(p.get("actions", []))),
+                f"[{r_color}]{risk_level}[/{r_color}]",
+                created,
+            )
+        console.print(table)
+    else:
+        console.print(_render_list_table(proposals, title))