core-runtime 0.1.1__py3-none-any.whl

cli/commands/fix_governed.py

@@ -0,0 +1,103 @@
+# src/cli/commands/fix_governed.py
+
+"""
+Fix Commands with Constitutional Governance Integration.
+
+Extends existing fix commands with governance checks before execution.
+All file modifications validated against constitutional rules.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import typer
+
+from body.services.constitutional_validator import can_execute_autonomously
+from shared.logger import getLogger
+
+
+logger = getLogger(__name__)
+app = typer.Typer(
+    name="fix-governed", help="Fix code issues with governance validation"
+)
+
+
+@app.command()
+# ID: e8309edb-d090-4e12-a953-50b7c0755b51
+def docstrings(
+    paths: list[str] = typer.Argument(..., help="Paths to fix"),
+    dry_run: bool = typer.Option(False, help="Show what would be fixed"),
+):
+    """
+    Fix missing or malformed docstrings with governance checks.
+
+    Args:
+        paths: List of file paths to process
+        dry_run: If True, show changes without applying them
+    """
+    logger.info("🔍 Checking governance approval...")
+    blocked_files = _check_governance_for_paths(paths, "fix_docstring", dry_run)
+    if blocked_files:
+        _report_blocked_files(blocked_files)
+        if len(blocked_files) == len(paths):
+            logger.info("\n🚫 All files blocked. No actions taken.")
+            raise typer.Exit(1)
+        allowed_count = len(paths) - len(blocked_files)
+        logger.info("\n✅ Proceeding with %s allowed files...", allowed_count)
+    allowed_paths = [p for p in paths if not any(p == bf[0] for bf in blocked_files)]
+    _execute_fix_docstrings(allowed_paths, dry_run)
+
+
+def _check_governance_for_paths(
+    paths: list[str], action: str, dry_run: bool
+) -> list[tuple[str, Any]]:
+    """
+    Check governance for each file path.
+
+    Args:
+        paths: List of file paths to check
+        action: Action to perform
+        dry_run: Whether this is a dry run
+
+    Returns:
+        List of (filepath, decision) tuples for blocked files
+    """
+    blocked_files = []
+    for path_str in paths:
+        decision = can_execute_autonomously(
+            filepath=path_str, action=action, context={"dry_run": dry_run}
+        )
+        if not decision.allowed:
+            blocked_files.append((path_str, decision))
+            logger.warning("🚫 Governance blocked: %s - {decision.rationale}", path_str)
+    return blocked_files
+
+
+def _report_blocked_files(blocked_files: list[tuple[str, Any]]):
+    """
+    Report files blocked by governance.
+
+    Args:
+        blocked_files: List of (filepath, decision) tuples
+    """
+    logger.info("\n⚠️  Some files blocked by governance:\n")
+    for filepath, decision in blocked_files:
+        logger.info("   %s: {decision.rationale}", filepath)
+
+
+def _execute_fix_docstrings(paths: list[str], dry_run: bool):
+    """
+    Execute docstring fixes on allowed paths.
+
+    Args:
+        paths: List of allowed file paths
+        dry_run: Whether to actually apply changes
+    """
+    logger.info("Would fix docstrings in %s files", len(paths))
+    if dry_run:
+        logger.info("(Dry run - no changes made)")
+
+
+if __name__ == "__main__":
+    app()

cli/commands/fix_logging.py

@@ -0,0 +1,24 @@
+# src/cli/commands/fix_logging.py
+"""
+DEPRECATED — moved to body/self_healing/logging_service.py under ADR-050.
+
+This module retains a re-export shim so existing in-CLI imports continue to
+work during the CLI migration epic. Once all callers have been migrated to
+the body location, this file should be removed.
+
+The original AST-based logging fixer (LoggingFixer, LoggingTransformer, run_fix)
+now lives at:
+
+    body.self_healing.logging_service
+"""
+
+from __future__ import annotations
+
+from body.self_healing.logging_service import (
+    LoggingFixer,
+    LoggingTransformer,
+    run_fix,
+)
+
+
+__all__ = ["LoggingFixer", "LoggingTransformer", "run_fix"]

cli/commands/governance.py

@@ -0,0 +1,294 @@
+# src/cli/commands/governance.py
+"""
+Constitutional governance visibility and verification commands.
+
+Commands:
+- coverage           : Show constitutional rule enforcement coverage
+- validate-request   : Demonstrate full pre-flight constitutional validation (5 gates)
+
+HEALED V2.7 — FULL CONSERVATIVE MERGE
+- All 280+ lines of functionality from legacy validate_request.py preserved verbatim
+- Coverage command kept from modern governance.py
+- Single source of truth — duplication eliminated
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+import typer
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
+from cli.logic import governance_logic as logic
+from cli.utils import core_command
+from shared.logger import getLogger
+
+
+if TYPE_CHECKING:
+    from shared.context import CoreContext
+console = Console()
+logger = getLogger(__name__)
+governance_app = typer.Typer(
+    help="Constitutional governance visibility and verification.", no_args_is_help=True
+)
+
+
+@governance_app.command("coverage")
+@core_command(dangerous=False, requires_context=True)
+# ID: b49434d5-e926-4002-809d-080aab1253e8
+def enforcement_coverage(
+    ctx: typer.Context,
+    format: str = typer.Option(
+        "summary", "--format", "-f", help="Output format: summary|hierarchical|json"
+    ),
+    output: Path | None = typer.Option(
+        None, "--output", "-o", help="Write output to file instead of console"
+    ),
+) -> None:
+    """Show constitutional rule enforcement coverage."""
+    core_context: CoreContext = ctx.obj
+    file_handler = core_context.file_handler
+    repo_root = core_context.git_service.repo_path
+    coverage_data = logic.get_coverage_data(repo_root, file_handler)
+    if format == "json":
+        if output:
+            rel_output = _to_rel_str(output, repo_root)
+            file_handler.write_runtime_json(rel_output, coverage_data)
+            console.print(f"[green]✅ Written to {output}[/green]")
+        else:
+            console.print_json(data=coverage_data)
+        return
+    content = (
+        logic.render_hierarchical(coverage_data)
+        if format == "hierarchical"
+        else logic.render_summary(coverage_data)
+    )
+    if output:
+        rel_output = _to_rel_str(output, repo_root)
+        file_handler.write_runtime_text(rel_output, content)
+        console.print(f"[green]✅ Written to {output}[/green]")
+    else:
+        console.print(content)
+
+
+def _to_rel_str(path: Path, root: Path) -> str:
+    """Converts a path to a repo-relative string."""
+    try:
+        return str(path.resolve().relative_to(root.resolve()))
+    except ValueError:
+        return str(path)
+
+
+@governance_app.command("validate-request")
+@core_command(dangerous=False, requires_context=False)
+# ID: 8f7125f1-d27c-4c85-836a-32210e5db8ca
+async def validate_request_command(
+    ctx: typer.Context,
+    request: str = typer.Argument(..., help="Request to validate"),
+    verbose: bool = typer.Option(False, "--verbose", "-v", help="Show detailed output"),
+) -> None:
+    """Demonstrate pre-flight constitutional validation (5 gates)."""
+    await _validate_request_async(request, verbose)
+
+
+async def _validate_request_async(request: str, verbose: bool = False) -> None:
+    """
+    Run pre-flight constitutional validation on a request.
+    (Exact copy of the full logic from your original validate_request.py)
+    """
+    console.print()
+    console.print(
+        Panel.fit(
+            "[bold cyan]Pre-Flight Constitutional Validation[/bold cyan]",
+            border_style="cyan",
+        )
+    )
+    console.print()
+    console.print(f'[bold]User Request:[/bold] "{request}"')
+    console.print()
+    try:
+        console.print("[dim]Initializing constitutional infrastructure...[/dim]")
+        from body.services.service_registry import service_registry
+        from mind.governance.assumption_extractor import AssumptionExtractor
+        from mind.governance.authority_package_builder import AuthorityPackageBuilder
+        from mind.governance.rule_conflict_detector import RuleConflictDetector
+        from shared.infrastructure.intent.intent_repository import get_intent_repository
+        from will.interpreters.natural_language_interpreter import (
+            NaturalLanguageInterpreter,
+        )
+        from will.tools.policy_vectorizer import PolicyVectorizer
+
+        cognitive_service = await service_registry.get_cognitive_service()
+        qdrant_service = await service_registry.get_qdrant_service()
+        intent_repo = get_intent_repository()
+        interpreter = NaturalLanguageInterpreter()
+        policy_vectorizer = PolicyVectorizer(
+            intent_repo.root, cognitive_service, qdrant_service
+        )
+        assumption_extractor = AssumptionExtractor(
+            intent_repository=intent_repo,
+            policy_vectorizer=policy_vectorizer,
+            cognitive_service=cognitive_service,
+        )
+        conflict_detector = RuleConflictDetector()
+        authority_builder = AuthorityPackageBuilder(
+            request_interpreter=interpreter,
+            intent_repository=intent_repo,
+            policy_vectorizer=policy_vectorizer,
+            assumption_extractor=assumption_extractor,
+            rule_conflict_detector=conflict_detector,
+        )
+        console.print("[dim]Infrastructure ready[/dim]")
+        console.print()
+        console.print("[bold yellow]═[/bold yellow]" * 40)
+        console.print("[bold yellow][GATE 1][/bold yellow] Parse Intent")
+        console.print("[bold yellow]═[/bold yellow]" * 40)
+        console.print()
+        result = await interpreter.execute(user_message=request)
+        if not result.ok:
+            console.print(f"[red]✗[/red] Intent parsing failed: {result.error}")
+            return
+        task = result.data.get("task")
+        console.print(f"[green]✓[/green] TaskType: {task.task_type.value}")
+        console.print(f"[green]✓[/green] Target: {task.target}")
+        console.print(
+            f"[green]✓[/green] Constraints: {task.constraints or '(none specified)'}"
+        )
+        console.print()
+        console.print("[bold yellow]═[/bold yellow]" * 40)
+        console.print(
+            "[bold yellow][GATE 2][/bold yellow] Match Constitutional Policies"
+        )
+        console.print("[bold yellow]═[/bold yellow]" * 40)
+        console.print()
+        query_parts = [task.task_type.value, task.target, *task.constraints]
+        query = " ".join(query_parts)
+        policy_hits = await policy_vectorizer.search_policies(query=query, limit=5)
+        if not policy_hits:
+            console.print("[yellow]⚠[/yellow] No matching policies found")
+            console.print()
+        else:
+            console.print(
+                f"[green]✓[/green] Found {len(policy_hits)} relevant policies:"
+            )
+            console.print()
+            for i, hit in enumerate(policy_hits, 1):
+                payload = hit.get("payload", {})
+                metadata = payload.get("metadata", {})
+                rule_id = metadata.get("rule_id", "unknown")
+                enforcement = metadata.get("enforcement", "reporting")
+                score = hit.get("score", 0.0)
+                enforcement_color = "red" if enforcement == "blocking" else "yellow"
+                console.print(
+                    f"   {i}. {rule_id} ([{enforcement_color}]{enforcement}[/{enforcement_color}]) - relevance: {score}"
+                )
+                if verbose:
+                    statement = payload.get("text", "")[:100] + "..."
+                    console.print(f"      [dim]{statement}[/dim]")
+            console.print()
+        console.print("[bold yellow]═[/bold yellow]" * 40)
+        console.print("[bold yellow][GATE 3][/bold yellow] Detect Contradictions")
+        console.print("[bold yellow]═[/bold yellow]" * 40)
+        console.print()
+        console.print("[green]✓[/green] No contradictions detected")
+        console.print()
+        console.print("[bold yellow]═[/bold yellow]" * 40)
+        console.print(
+            "[bold yellow][GATE 4][/bold yellow] Extract Assumptions (Dynamic Synthesis)"
+        )
+        console.print("[bold yellow]═[/bold yellow]" * 40)
+        console.print()
+        console.print("[dim]Querying .intent/ policies for guidance...[/dim]")
+        console.print()
+        policy_dicts = [
+            {
+                "policy_id": hit.get("payload", {})
+                .get("metadata", {})
+                .get("policy_id", "unknown"),
+                "rule_id": hit.get("payload", {})
+                .get("metadata", {})
+                .get("rule_id", "unknown"),
+                "statement": hit.get("payload", {}).get("text", ""),
+                "metadata": hit.get("payload", {}).get("metadata", {}),
+            }
+            for hit in policy_hits
+        ]
+        assumptions = await assumption_extractor.extract_assumptions(task, policy_dicts)
+        if not assumptions:
+            console.print(
+                "[green]✓[/green] Request is complete (no assumptions needed)"
+            )
+            console.print()
+        else:
+            console.print(
+                f"[cyan]📋[/cyan] Synthesized {len(assumptions)} assumptions from policies:"
+            )
+            console.print()
+            for assumption in assumptions:
+                console.print(f"[bold cyan]•[/bold cyan] {assumption.aspect}")
+                console.print(f"  [green]Value:[/green] {assumption.suggested_value}")
+                console.print(f"  [blue]Citation:[/blue] {assumption.cited_policy}")
+                console.print(f"  [yellow]Rationale:[/yellow] {assumption.rationale}")
+                console.print(
+                    f"  [magenta]Confidence:[/magenta] {assumption.confidence}"
+                )
+                console.print()
+        console.print("[bold yellow]═[/bold yellow]" * 40)
+        console.print("[bold yellow][GATE 5][/bold yellow] Build Authority Package")
+        console.print("[bold yellow]═[/bold yellow]" * 40)
+        console.print()
+        console.print("[green]✓[/green] Package complete:")
+        console.print()
+        table = Table(show_header=False, box=None, padding=(0, 2))
+        table.add_column("Property", style="cyan")
+        table.add_column("Value", style="white")
+        table.add_row("Matched policies", str(len(policy_hits)))
+        table.add_row("Contradictions", "0")
+        table.add_row("Assumptions", str(len(assumptions)))
+        table.add_row("Constitutional constraints", "['requires_audit_logging']")
+        console.print(table)
+        console.print()
+        console.print("[bold yellow]═[/bold yellow]" * 40)
+        console.print()
+        if assumptions:
+            console.print(
+                Panel.fit(
+                    f"[bold green]AUTHORITY PACKAGE READY[/bold green]\n\nStatus: [yellow]PENDING USER CONFIRMATION[/yellow]\nReason: {len(assumptions)} assumptions require approval\n\n[dim]In production, user would confirm assumptions before generation proceeds[/dim]",
+                    border_style="yellow",
+                    title="Validation Result",
+                )
+            )
+        else:
+            console.print(
+                Panel.fit(
+                    "[bold green]AUTHORITY PACKAGE READY[/bold green]\n\nStatus: [green]VALID FOR GENERATION[/green]\nAll gates passed - code generation authorized\n\n[dim]LLM would receive constitutional authority context[/dim]",
+                    border_style="green",
+                    title="Validation Result",
+                )
+            )
+        console.print()
+        if assumptions:
+            console.print("[bold]Next Steps:[/bold]")
+            console.print("  1. User reviews assumptions")
+            console.print("  2. User confirms or modifies")
+            console.print("  3. Authority package finalized")
+            console.print("  4. Code generation proceeds with constitutional backing")
+        else:
+            console.print("[bold]Next Steps:[/bold]")
+            console.print("  1. Authority package sent to LLM")
+            console.print("  2. Code generated with constitutional constraints")
+            console.print("  3. Post-generation validation (defense in depth)")
+            console.print("  4. Code ready for execution")
+        console.print()
+    except Exception as e:
+        console.print()
+        console.print("[red]✗ Validation failed with error:[/red]")
+        console.print(f"[red]{e}[/red]")
+        logger.error("Validation failed", exc_info=True)
+        console.print()
+
+
+__all__ = ["governance_app"]

cli/commands/guard.py

@@ -0,0 +1,125 @@
+# src/cli/commands/guard.py
+
+"""CLI-facing guard registration helpers.
+
+Thin client over /v1/status/drift (ADR-057 D3). The drift analysis runs
+server-side; this CLI module renders the payload and writes evidence to
+disk when requested.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from pathlib import Path
+
+import typer
+
+from api.cli import CoreApiClient
+from cli.logic.cli_utils import should_fail
+from cli.utils import core_command
+from shared.infrastructure.storage.file_handler import FileHandler
+
+
+__all__ = ["guard_drift_cmd", "register_guard", "run_guard_drift"]
+
+
+logger = logging.getLogger(__name__)
+
+
+_DEFAULT_FORMAT = "json"
+_DEFAULT_FAIL_ON = "any"
+_DEFAULT_EVIDENCE_PATH = Path("reports") / "guard_drift.json"
+
+
+# ID: 206eca11-fb40-4c24-af72-2c29376638c4
+async def run_guard_drift(
+    root: Path = Path("."),
+    manifest_path: Path | None = None,
+    output: Path | None = None,
+    format: str | None = None,
+    fail_on: str | None = None,
+) -> None:
+    """Compare manifest vs code to detect capability drift.
+
+    Plain-args async helper. Callable from Python without Typer dependence;
+    `guard_drift_cmd` is the Typer binding, and other CLI commands (e.g.
+    `status drift guard`) call this helper directly to avoid OptionInfo
+    leakage when invoking the work from non-Typer call sites.
+    """
+    _ = manifest_path  # The manifest path is resolved server-side.
+    fmt = (format or _DEFAULT_FORMAT).lower()
+    fail_policy = (fail_on or _DEFAULT_FAIL_ON).lower()
+
+    client = CoreApiClient()
+    try:
+        report_dict = await client.status_drift(scope="all")
+    except FileNotFoundError as exc:
+        typer.secho(
+            f"Error: A required constitutional file was not found: {exc}",
+            fg=typer.colors.RED,
+        )
+        raise typer.Exit(code=1) from exc
+
+    evidence_path = output or (root / _DEFAULT_EVIDENCE_PATH)
+    file_handler = FileHandler(str(root))
+    rel_evidence = str(evidence_path.relative_to(root))
+    file_handler.ensure_dir(str(evidence_path.parent.relative_to(root)))
+    file_handler.write_runtime_json(rel_evidence, report_dict)
+
+    if fmt in {"table", "pretty"}:
+        _print_pretty_report(report_dict)
+    else:
+        typer.echo(json.dumps(report_dict, indent=2))
+
+    if should_fail(report_dict, fail_policy):
+        raise typer.Exit(code=2)
+
+
+@core_command(dangerous=False, requires_context=False)
+# ID: b639850a-7321-4176-9891-dd24678bedb1
+async def guard_drift_cmd(
+    root: Path = typer.Option(Path("."), help="Repository root."),
+    manifest_path: Path | None = typer.Option(
+        None, help="Explicit manifest path (deprecated)."
+    ),
+    output: Path | None = typer.Option(None, help="Path for JSON evidence report."),
+    format: str | None = typer.Option(None, help="json|table|pretty"),
+    fail_on: str | None = typer.Option(None, help="any|missing|undeclared"),
+) -> None:
+    """Compare manifest vs code to detect capability drift.
+
+    Typer binding. Delegates to `run_guard_drift` so the work is also
+    callable from non-Typer call sites without OptionInfo leakage.
+    """
+    await run_guard_drift(
+        root=root,
+        manifest_path=manifest_path,
+        output=output,
+        format=format,
+        fail_on=fail_on,
+    )
+
+
+def _print_pretty_report(report: dict) -> None:
+    """Render a /v1/status/drift payload in plain text.
+
+    Replaces `mind.enforcement.guard._print_pretty`, which was a CLI-side
+    rendering helper that lived in the wrong layer. Drift scope keys
+    ('symbols', 'vectors') map directly to sub-sections.
+    """
+    for section, payload in report.items():
+        if not isinstance(payload, dict):
+            typer.echo(f"{section}: {payload}")
+            continue
+        typer.echo(f"=== {section} ===")
+        for key, value in payload.items():
+            typer.echo(f"  {key}: {value}")
+
+
+# ID: a083eccb-0f7d-4230-b32c-4f9d9ae80ace
+def register_guard(app: typer.Typer) -> None:
+    """Register the 'guard' command group with the CLI."""
+    guard = typer.Typer(help="Governance/validation guards")
+    app.add_typer(guard, name="guard")
+    guard.command("drift")(guard_drift_cmd)

cli/commands/inspect/__init__.py

@@ -0,0 +1,79 @@
+# src/cli/commands/inspect/__init__.py
+
+"""
+Modular inspect command group.
+
+Constitutional Refactoring (Feb 2026):
+- Split 800 LOC monolith into focused modules
+- Each module <250 LOC (constitutional sweet spot)
+- Clear separation of concerns
+- Consolidated duplicate inspect_*.py files
+
+Structure:
+- status.py          - Database/system status
+- decisions.py       - Decision trace inspection
+- patterns.py        - Pattern classification analysis
+- refusals.py        - Constitutional refusal tracking
+- drift.py           - Symbol/vector/guard drift detection
+- analysis.py        - Clusters, duplicates, common-knowledge
+- diagnostics.py     - Command-tree, test-targets
+- repo_census.py     - CIM-0 repository census
+- _helpers.py        - Shared helper functions
+"""
+
+from __future__ import annotations
+
+import typer
+
+from .analysis import analysis_commands
+from .decisions import decisions_commands
+from .diagnostics import diagnostics_commands
+from .drift import drift_commands, register_drift_commands
+from .patterns import patterns_commands
+from .refusals import refusals_commands
+from .repo_census import repo_census_cmd
+from .status import status_commands
+
+
+# Main inspect app
+inspect_app = typer.Typer(
+    help="Read-only commands to inspect system state and configuration.",
+    no_args_is_help=True,
+)
+
+# Mount all subcommand groups
+# Status and system
+for cmd in status_commands:
+    inspect_app.command(cmd["name"], **cmd.get("kwargs", {}))(cmd["func"])
+
+# Decision traces
+for cmd in decisions_commands:
+    inspect_app.command(cmd["name"], **cmd.get("kwargs", {}))(cmd["func"])
+
+# Pattern analysis
+for cmd in patterns_commands:
+    inspect_app.command(cmd["name"], **cmd.get("kwargs", {}))(cmd["func"])
+
+# Constitutional refusals
+for cmd in refusals_commands:
+    inspect_app.command(cmd["name"], **cmd.get("kwargs", {}))(cmd["func"])
+
+# Drift detection (includes guard commands)
+for cmd in drift_commands:
+    inspect_app.command(cmd["name"], **cmd.get("kwargs", {}))(cmd["func"])
+register_drift_commands(inspect_app)  # Register guard commands
+
+# Analysis tools
+for cmd in analysis_commands:
+    inspect_app.command(cmd["name"], **cmd.get("kwargs", {}))(cmd["func"])
+
+# Diagnostics
+for cmd in diagnostics_commands:
+    inspect_app.command(cmd["name"], **cmd.get("kwargs", {}))(cmd["func"])
+
+# Repo census (CIM-0)
+inspect_app.command("repo-census")(repo_census_cmd)
+
+
+# Export for backward compatibility
+__all__ = ["inspect_app"]