core-runtime 0.1.1__py3-none-any.whl

cli/resources/coherence/supersede.py

@@ -0,0 +1,124 @@
+# src/cli/resources/coherence/supersede.py
+"""
+`core-admin coherence supersede` — retire one CCC run by supersession from a
+canonical run. Bulk-dismisses every unreviewed candidate in the old run
+with a mandatory note, closes the old run, then recomputes the canonical
+run's denormalized ``unreviewed_count``.
+
+Governing ADR: .specs/decisions/ADR-067-constitutional-coherence-checker.md (D6).
+"""
+
+from __future__ import annotations
+
+import logging
+
+import typer
+from rich.console import Console
+
+from body.services.coherence_service import CoherenceService
+from cli.utils import core_command
+from shared.infrastructure.database.session_manager import get_session
+
+from .hub import app
+
+
+logger = logging.getLogger(__name__)
+console = Console()
+
+
+@app.command("supersede")
+@core_command(dangerous=True, requires_context=False)
+# ID: 1679b214-2bda-45f1-a28a-2e5080efeb02
+async def supersede_command(
+    old_run_id: str = typer.Argument(
+        ...,
+        help="Run id to retire (must be currently open).",
+    ),
+    by: str = typer.Option(
+        ...,
+        "--by",
+        help="Canonical run id that supersedes the old run.",
+    ),
+    note: str = typer.Option(
+        ...,
+        "--note",
+        help=(
+            "Mandatory rationale recorded on every dismissed candidate's "
+            "triage_note. The supersession is auditable through ordinary "
+            "triage history."
+        ),
+    ),
+    yes: bool = typer.Option(
+        False,
+        "--yes",
+        "-y",
+        help="Skip the interactive confirmation prompt.",
+    ),
+) -> None:
+    """Retire one CCC run by supersession from another."""
+    if not note.strip():
+        console.print("[red]X --note must not be empty.[/red]")
+        raise typer.Exit(code=1)
+
+    async with get_session() as session:
+        service = CoherenceService(session)
+
+        old_run = await service.get_run(old_run_id)
+        canonical_run = await service.get_run(by)
+
+        if old_run is None:
+            console.print(f"[red]X old_run_id not found: {old_run_id}[/red]")
+            raise typer.Exit(code=1)
+        if canonical_run is None:
+            console.print(f"[red]X --by canonical_run_id not found: {by}[/red]")
+            raise typer.Exit(code=1)
+        if old_run["run_status"] != "open":
+            console.print(
+                f"[red]X old_run_id {old_run_id} is not open "
+                f"(status: {old_run['run_status']}).[/red]"
+            )
+            raise typer.Exit(code=1)
+
+        dismiss_preview = int(old_run.get("unreviewed_count") or 0)
+        age_warning = canonical_run["run_at"] <= old_run["run_at"]
+
+        console.print(
+            f"[bold]Supersede preview:[/bold] {dismiss_preview} unreviewed "
+            f"candidate(s) in run [cyan]{old_run_id[:8]}[/cyan] will be "
+            f"dismissed and the run closed. Canonical "
+            f"[cyan]{by[:8]}[/cyan]'s denormalized count will be repaired."
+        )
+        if age_warning:
+            console.print(
+                f"[yellow]! Canonical run_at ({canonical_run['run_at']}) is "
+                f"not newer than old run_at ({old_run['run_at']}). "
+                f"Proceeding because --note records the rationale.[/yellow]"
+            )
+
+        if not yes:
+            confirmed = typer.confirm("Apply?", default=False)
+            if not confirmed:
+                console.print("[yellow]Aborted by governor.[/yellow]")
+                raise typer.Exit(code=1)
+
+        try:
+            result = await service.supersede_run(
+                old_run_id=old_run_id,
+                canonical_run_id=by,
+                note=note,
+            )
+        except ValueError as exc:
+            console.print(f"[red]X supersede failed: {exc}[/red]")
+            raise typer.Exit(code=1) from exc
+        except Exception as exc:
+            logger.exception("supersede failed")
+            console.print(f"[red]X supersede failed: {exc}[/red]")
+            raise typer.Exit(code=1) from exc
+
+    console.print(
+        f"[green]Supersede complete:[/green] "
+        f"{result['dismissed_count']} candidate(s) dismissed; "
+        f"run [cyan]{old_run_id[:8]}[/cyan] closed; canonical "
+        f"[cyan]{by[:8]}[/cyan] count "
+        f"{result['canonical_old_count']} -> {result['canonical_new_count']}."
+    )

cli/resources/coherence/triage.py

@@ -0,0 +1,81 @@
+# src/cli/resources/coherence/triage.py
+"""
+`core-admin coherence triage` — record a triage decision on one CCC candidate.
+
+Governing ADR: .specs/decisions/ADR-067-constitutional-coherence-checker.md (D2).
+"""
+
+from __future__ import annotations
+
+import logging
+
+import typer
+from rich.console import Console
+
+from body.services.coherence_service import CoherenceService
+from cli.utils import core_command
+from shared.infrastructure.database.session_manager import get_session
+
+from .hub import app
+
+
+logger = logging.getLogger(__name__)
+console = Console()
+
+
+_ALLOWED_DECISIONS = ("confirmed", "dismissed", "deferred")
+
+
+@app.command("triage")
+@core_command(dangerous=True, requires_context=False)
+# ID: a8fe052f-0103-4b62-a2cb-eaadc5a368d8
+async def triage_command(
+    candidate_id: str = typer.Argument(..., help="Candidate id to triage."),
+    decision: str = typer.Argument(
+        ...,
+        help=f"Triage decision: one of {', '.join(_ALLOWED_DECISIONS)}.",
+    ),
+    note: str = typer.Option(
+        None,
+        "--note",
+        help="Governor rationale. Required when DECISION is 'dismissed'.",
+    ),
+) -> None:
+    """Record a triage decision on one candidate."""
+    decision_normalized = decision.strip().lower()
+    if decision_normalized not in _ALLOWED_DECISIONS:
+        console.print(
+            f"[red]❌ Invalid decision '{decision}'. "
+            f"Must be one of: {', '.join(_ALLOWED_DECISIONS)}.[/red]"
+        )
+        raise typer.Exit(code=1)
+
+    if decision_normalized == "dismissed" and not note:
+        console.print("[red]❌ --note is required when DECISION is 'dismissed'.[/red]")
+        raise typer.Exit(code=1)
+
+    async with get_session() as session:
+        service = CoherenceService(session)
+        try:
+            result = await service.triage_candidate(
+                candidate_id=candidate_id,
+                decision=decision_normalized,
+                note=note,
+            )
+        except Exception as exc:
+            logger.exception("Triage failed")
+            console.print(f"[red]❌ Triage failed: {exc}[/red]")
+            raise typer.Exit(code=1) from exc
+
+    if result["run_id"] is None:
+        console.print(f"[red]❌ Candidate not found: {candidate_id}[/red]")
+        raise typer.Exit(code=1)
+
+    console.print(
+        f"[green]✅ Candidate {candidate_id} marked {decision_normalized}.[/green]"
+    )
+    if result["run_closed"]:
+        console.print(
+            f"[bold green]Run {result['run_id']} closed — "
+            f"all candidates triaged.[/bold green]"
+        )

cli/resources/constitution/__init__.py

@@ -0,0 +1,19 @@
+# src/cli/resources/constitution/__init__.py
+"""Constitutional governance and policy operations."""
+
+from __future__ import annotations
+
+import typer
+
+
+app = typer.Typer(
+    name="constitution",
+    help="Operations for the system mind: policies, schemas, and rule coverage.",
+    no_args_is_help=True,
+)
+
+# Standard Verbs
+from . import audit, query, status, validate
+
+
+__all__ = ["app"]

cli/resources/constitution/audit.py

@@ -0,0 +1,49 @@
+# src/cli/resources/constitution/audit.py
+import typer
+from rich.console import Console
+
+from cli.utils import core_command
+from mind.governance.filtered_audit import run_filtered_audit
+
+from . import app
+
+
+console = Console()
+
+
+@app.command("audit")
+@core_command(dangerous=False, requires_context=True)
+# ID: d12aedfe-884a-4223-9f4c-9cb2c10dfa41
+async def audit_policies(
+    ctx: typer.Context,
+    policy: list[str] = typer.Option(
+        [], "--policy", "-p", help="Policy IDs to execute."
+    ),
+    rule: list[str] = typer.Option(
+        [], "--rule", "-r", help="Specific rule IDs to execute."
+    ),
+) -> None:
+    """
+    Execute targeted constitutional audits for specific policies or rules.
+
+    Example: core-admin constitution audit --policy standard_code_linkage
+    """
+    if not policy and (not rule):
+        console.print(
+            "[red]Error: Must specify at least one --policy or --rule filter.[/red]"
+        )
+        raise typer.Exit(1)
+    auditor_context = ctx.obj.auditor_context
+    console.print(
+        f"[bold cyan]🔍 Executing targeted audit for {len(policy or rule)} items...[/bold cyan]"
+    )
+    findings, _executed_ids, stats = await run_filtered_audit(
+        auditor_context, policy_ids=policy or None, rule_ids=rule or None
+    )
+    console.print(
+        f"\n[bold]Audit Complete:[/bold] {stats['executed_rules']} rules checked."
+    )
+    if not findings:
+        console.print("[green]✅ No violations found.[/green]")
+    else:
+        console.print(f"[red]❌ Found {len(findings)} violations.[/red]")

cli/resources/constitution/query.py

@@ -0,0 +1,45 @@
+# src/cli/resources/constitution/query.py
+import typer
+from rich.console import Console
+
+from cli.utils import core_command
+from will.tools.policy_vectorizer import PolicyVectorizer
+
+from . import app
+
+
+console = Console()
+
+
+@app.command("query")
+@core_command(dangerous=False, requires_context=True)
+# ID: 3e2bdb30-c7c8-42eb-9c50-ceac1c9c73d1
+async def query_constitution(
+    ctx: typer.Context,
+    text: str = typer.Argument(
+        ..., help="Natural language question about the constitution."
+    ),
+) -> None:
+    """
+    Perform a semantic search for policies and rules using natural language.
+
+    Example: core-admin constitution query "what are the rules for database access?"
+    """
+    core_context = ctx.obj
+    vectorizer = PolicyVectorizer(
+        repo_root=core_context.git_service.repo_path,
+        cognitive_service=core_context.cognitive_service,
+        qdrant_service=core_context.qdrant_service,
+    )
+    console.print(f"[bold cyan]🧠 Searching Mind for:[/bold cyan] '{text}'...")
+    results = await vectorizer.search_policies(query=text, limit=3)
+    if not results:
+        console.print("[yellow]No relevant rules found.[/yellow]")
+        return
+    for i, hit in enumerate(results, 1):
+        payload = hit.get("payload", {})
+        rule_id = payload.get("rule_id", "Unknown Rule")
+        console.print(
+            f"\n[bold green]{i}. {rule_id}[/bold green] (score: {hit['score']})"
+        )
+        console.print(f"   [dim]{payload.get('content', '')[:200]}...[/dim]")

cli/resources/constitution/status.py

@@ -0,0 +1,34 @@
+# src/cli/resources/constitution/status.py
+import typer
+from rich.console import Console
+
+from cli.logic import governance_logic
+from cli.utils import core_command
+
+from . import app
+
+
+console = Console()
+
+
+@app.command("status")
+@core_command(dangerous=False, requires_context=True)
+# ID: d4c140ee-0765-402c-9a60-7b84909bad43
+def status_coverage(ctx: typer.Context) -> None:
+    """
+    Show enforcement coverage status for the entire constitution.
+
+    Identifies 'Enforced' vs 'Declared' rules to detect governance gaps.
+    """
+    core_context = ctx.obj
+    repo_root = core_context.git_service.repo_path
+    console.print(
+        "[bold cyan]📊 Mapping Constitutional Enforcement Coverage...[/bold cyan]"
+    )
+    coverage_data = governance_logic.get_coverage_data(
+        repo_root, core_context.file_handler
+    )
+    summary = coverage_data.get("summary", {})
+    console.print(f"\nTotal Rules: {summary.get('rules_total')}")
+    console.print(f"Enforced   : [green]{summary.get('rules_enforced')}[/green]")
+    console.print(f"Coverage   : [bold]{summary.get('execution_rate')}%[/bold]")

cli/resources/constitution/validate.py

@@ -0,0 +1,36 @@
+# src/cli/resources/constitution/validate.py
+import typer
+from rich.console import Console
+
+from cli.utils import core_command
+from mind.governance.meta_validator import MetaValidator
+
+from . import app
+
+
+console = Console()
+
+
+@app.command("validate")
+@core_command(dangerous=False, requires_context=False)
+# ID: b75321ea-88dd-4ed1-93d8-b6730590777a
+def validate_constitution(ctx: typer.Context) -> None:
+    """
+    Validate all .intent artifacts against their JSON schemas.
+
+    Ensures that the Mind is structurally sound and follows the META-SCHEMA.
+    """
+    console.print("[bold cyan]🛡️  Validating Constitutional Artifacts...[/bold cyan]\n")
+    validator = MetaValidator()
+    report = validator.validate_all_documents()
+    if report.valid:
+        console.print(
+            f"[green]✅ Success! {report.documents_valid} documents validated.[/green]"
+        )
+    else:
+        console.print(
+            f"[bold red]❌ Validation Failed: {len(report.errors)} errors found.[/bold red]"
+        )
+        for err in report.errors:
+            console.print(f"   - [yellow]{err.document}[/yellow]: {err.message}")
+        raise typer.Exit(1)

cli/resources/context/__init__.py

@@ -0,0 +1,21 @@
+# src/cli/resources/context/__init__.py
+"""
+Context Resource - Context building and exploration.
+
+Commands:
+- build   : Agent simulation — exact context CoderAgent sees (uses build_for_task)
+- explain : Semantic exploration — "what code relates to this concept?"
+- search  : Direct pattern search (fast path, queries DB directly)
+- cache   : Manage context cache
+"""
+
+from __future__ import annotations
+
+# 2. Register all neurons (import triggers @app.command decorators)
+from . import build, cache, explain, search
+
+# 1. Import stable hub first
+from .hub import app
+
+
+__all__ = ["app"]