core-runtime 0.1.1__py3-none-any.whl

cli/logic/refusal_inspect_logic.py

@@ -0,0 +1,208 @@
+# src/cli/logic/refusal_inspect_logic.py
+"""
+Logic for inspecting constitutional refusals.
+
+Provides rich terminal output for:
+- Recent refusals with filtering
+- Refusal statistics and trends
+- Constitutional compliance analysis
+
+Used by: `core-admin inspect refusals` command
+"""
+
+from __future__ import annotations
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
+from body.infrastructure.repositories.refusal_repository import RefusalRepository
+from shared.infrastructure.intent.operational_config import load_operational_config
+
+
+console = Console()
+
+_CFG = load_operational_config().misc
+
+
+# ID: 4b4da583-c2ba-43ad-a249-720128871385
+async def show_recent_refusals(
+    limit: int = _CFG.refusal_inspect_default_limit,
+    refusal_type: str | None = None,
+    component: str | None = None,
+    details: bool = False,
+) -> None:
+    """
+    Show recent refusals with optional filtering.
+
+    Args:
+        limit: Maximum records to show
+        refusal_type: Filter by type (boundary, confidence, etc.)
+        component: Filter by component
+        details: Show full details
+    """
+    repo = RefusalRepository()
+    refusals = await repo.get_recent(
+        limit=limit, refusal_type=refusal_type, component_id=component
+    )
+    if not refusals:
+        console.print("[yellow]No refusals found matching criteria[/yellow]")
+        return
+    table = Table(title=f"Recent Refusals ({len(refusals)})")
+    table.add_column("Type", style="cyan")
+    table.add_column("Component", style="green")
+    table.add_column("Phase", style="blue")
+    table.add_column("Confidence", justify="right")
+    table.add_column("Time", style="dim")
+    for refusal in refusals:
+        confidence_str = f"{refusal.confidence:.0%}" if refusal.confidence else "N/A"
+        table.add_row(
+            refusal.refusal_type,
+            refusal.component_id,
+            refusal.phase,
+            confidence_str,
+            refusal.created_at.strftime("%Y-%m-%d %H:%M:%S"),
+        )
+    console.print(table)
+    if details and refusals:
+        console.print("\n[bold]Most Recent Refusal Details:[/bold]")
+        _show_refusal_details(refusals[0])
+
+
+def _show_refusal_details(refusal) -> None:
+    """Show detailed information about a single refusal."""
+    details = []
+    details.append(f"[bold cyan]Type:[/bold cyan] {refusal.refusal_type}")
+    details.append(f"[bold cyan]Component:[/bold cyan] {refusal.component_id}")
+    details.append(f"[bold cyan]Phase:[/bold cyan] {refusal.phase}")
+    details.append("")
+    details.append("[bold yellow]Reason:[/bold yellow]")
+    details.append(f"  {refusal.reason}")
+    details.append("")
+    details.append("[bold green]Suggested Action:[/bold green]")
+    details.append(f"  {refusal.suggested_action}")
+    details.append("")
+    if refusal.original_request:
+        details.append("[bold]Original Request:[/bold]")
+        request = refusal.original_request
+        if len(request) > 200:
+            request = request[:200] + "..."
+        details.append(f"  {request}")
+        details.append("")
+    if refusal.context_data:
+        details.append("[bold]Context:[/bold]")
+        for key, value in refusal.context_data.items():
+            details.append(f"  {key}: {value}")
+        details.append("")
+    details.append(f"[dim]Confidence: {refusal.confidence:.2f}[/dim]")
+    details.append(f"[dim]Time: {refusal.created_at}[/dim]")
+    if refusal.session_id:
+        details.append(f"[dim]Session: {refusal.session_id}[/dim]")
+    panel = Panel(
+        "\n".join(details), title=f"Refusal {str(refusal.id)[:8]}", border_style="cyan"
+    )
+    console.print(panel)
+
+
+# ID: 6ed8fe95-3088-46bb-87ce-343001399035
+async def show_refusal_statistics(days: int = 7) -> None:
+    """
+    Show refusal statistics and trends.
+
+    Args:
+        days: Number of days to analyze
+    """
+    repo = RefusalRepository()
+    stats = await repo.get_statistics(days=days)
+    if stats["total_refusals"] == 0:
+        console.print(f"[yellow]No refusals recorded in the last {days} days[/yellow]")
+        return
+    console.print(f"\n[bold]Refusal Statistics (Last {days} Days)[/bold]")
+    console.print(f"Total Refusals: {stats['total_refusals']}")
+    console.print(f"Average Confidence: {stats['avg_confidence']}\n")
+    if stats["by_type"]:
+        type_table = Table(title="Refusals by Type")
+        type_table.add_column("Type", style="cyan")
+        type_table.add_column("Count", justify="right")
+        type_table.add_column("Percentage", justify="right")
+        total = stats["total_refusals"]
+        for refusal_type, count in sorted(
+            stats["by_type"].items(), key=lambda x: x[1], reverse=True
+        ):
+            percentage = count / total * 100
+            type_table.add_row(refusal_type, str(count), f"{percentage:.1f}%")
+        console.print(type_table)
+    if stats["by_component"]:
+        console.print()
+        comp_table = Table(title="Refusals by Component")
+        comp_table.add_column("Component", style="green")
+        comp_table.add_column("Count", justify="right")
+        comp_table.add_column("Percentage", justify="right")
+        total = stats["total_refusals"]
+        for component, count in sorted(
+            stats["by_component"].items(), key=lambda x: x[1], reverse=True
+        ):
+            percentage = count / total * 100
+            comp_table.add_row(component, str(count), f"{percentage:.1f}%")
+        console.print(comp_table)
+    if stats["by_phase"]:
+        console.print()
+        phase_table = Table(title="Refusals by Phase")
+        phase_table.add_column("Phase", style="blue")
+        phase_table.add_column("Count", justify="right")
+        phase_table.add_column("Percentage", justify="right")
+        total = stats["total_refusals"]
+        for phase, count in sorted(
+            stats["by_phase"].items(), key=lambda x: x[1], reverse=True
+        ):
+            percentage = count / total * 100
+            phase_table.add_row(phase, str(count), f"{percentage:.1f}%")
+        console.print(phase_table)
+
+
+# ID: 89e49163-1450-4c3f-85b4-8cdf47b53c37
+async def show_refusals_by_type(
+    refusal_type: str, limit: int = _CFG.refusal_inspect_by_type_limit
+) -> None:
+    """
+    Show refusals of a specific type.
+
+    Args:
+        refusal_type: Type to filter (boundary, confidence, etc.)
+        limit: Maximum records to show
+    """
+    repo = RefusalRepository()
+    refusals = await repo.get_by_type(refusal_type, limit=limit)
+    if not refusals:
+        console.print(f"[yellow]No refusals found of type: {refusal_type}[/yellow]")
+        return
+    console.print(
+        f"\n[bold]{refusal_type.capitalize()} Refusals ({len(refusals)})[/bold]\n"
+    )
+    for i, refusal in enumerate(refusals, 1):
+        console.print(f"[cyan]{i}. {refusal.component_id}[/cyan]")
+        console.print(f"   Phase: {refusal.phase}")
+        console.print(f"   Reason: {refusal.reason[:100]}...")
+        console.print(f"   Time: {refusal.created_at.strftime('%Y-%m-%d %H:%M:%S')}")
+        console.print()
+
+
+# ID: c7576fa4-ec2e-46ba-89e4-feeab36ee0dc
+async def show_refusals_by_session(session_id: str) -> None:
+    """
+    Show all refusals for a specific decision trace session.
+
+    Args:
+        session_id: Decision trace session ID
+    """
+    repo = RefusalRepository()
+    refusals = await repo.get_by_session(session_id)
+    if not refusals:
+        console.print(f"[yellow]No refusals found for session: {session_id}[/yellow]")
+        return
+    console.print(
+        f"\n[bold]Refusals in Session {session_id} ({len(refusals)})[/bold]\n"
+    )
+    for refusal in refusals:
+        _show_refusal_details(refusal)
+        console.print()

cli/logic/report.py

@@ -0,0 +1,47 @@
+# src/cli/logic/report.py
+"""
+Provides functionality for the report module.
+"""
+
+from __future__ import annotations
+
+import typer
+from sqlalchemy import text
+
+from shared.infrastructure.database.session_manager import get_session
+
+
+# ID: 27a79c8d-285f-4e79-8de9-a4a5cba424d4
+async def report() -> None:
+    """Summary by source (count, pass rate, avg score)."""
+
+    stmt = text(
+        """
+        select
+          source,
+          count(*) as total,
+          sum(case when verdict = 'PASS' then 1 else 0 end) as passed_count,
+          round(avg(score)::numeric, 3) as avg_score
+        from core.audit_runs
+        where verdict <> 'pending'
+        group by source
+        order by source
+        """
+    )
+
+    async with get_session() as session:
+        result = await session.execute(stmt)
+        rows = result.all()
+
+    if not rows:
+        typer.echo("— no data —")
+        return
+
+    typer.echo("source   total  passed  pass_rate  avg_score")
+    for r in rows:
+        pass_rate = (r.passed_count / r.total) * 100.0 if r.total else 0.0
+        avg = f"{float(r.avg_score):>8.3f}" if r.avg_score is not None else "    —   "
+        typer.echo(
+            f"{r.source:<7} {r.total:>5}  {r.passed_count:>6}   "
+            f"{pass_rate:>6.1f}%     {avg}"
+        )

cli/logic/status.py

@@ -0,0 +1,47 @@
+# src/cli/logic/status.py
+"""
+Diagnostic logic for 'core-admin inspect status'.
+
+Shows DB connectivity and migration status.
+"""
+
+from __future__ import annotations
+
+from shared.infrastructure.repositories.db.status_service import StatusReport
+from shared.infrastructure.repositories.db.status_service import status as db_status
+
+
+async def _status_impl() -> None:
+    """
+    Render a human-readable DB status report to the console.
+
+    This is an internal helper used by CLI wrappers (e.g. `inspect status`,
+    `init status`). It delegates the actual health/ledger logic to the
+    DB status service in `services.repositories.db.status_service`.
+    """
+    # Use the status-report helper so tests can patch it and governance
+    # can reason about a single place where DB status is obtained.
+    report: StatusReport = await _get_status_report()
+
+    # FUTURE: This function should not render UI in a Body module.
+    # CLI wrappers should handle rendering. For now, we keep it as a no-op.
+    pass
+
+
+async def _get_status_report() -> StatusReport:
+    """
+    Internal helper used by the admin CLI and tests.
+
+    Returns the current database status report without rendering it. The
+    CLI command is responsible for turning this into human-readable output.
+    """
+    return await db_status()
+
+
+# NOTE:
+# We intentionally expose `get_status_report` only as an alias to the
+# private `_get_status_report` function. This keeps tests and callers
+# able to import and await `get_status_report`, but the symbol graph
+# only sees the underlying `_get_status_report` function as a single
+# (private) implementation detail, avoiding orphaned public logic.
+get_status_report = _get_status_report

cli/logic/symbol_drift.py

@@ -0,0 +1,77 @@
+# src/cli/logic/symbol_drift.py
+
+"""
+Implements the `inspect symbol-drift` command, a diagnostic tool to detect
+discrepancies between symbols on the filesystem and those in the database.
+"""
+
+from __future__ import annotations
+
+import asyncio
+
+from sqlalchemy import text
+
+from body.introspection.sync_service import SymbolScanner
+from shared.infrastructure.bootstrap_registry import bootstrap_registry
+from shared.infrastructure.database.session_manager import get_session
+from shared.logger import getLogger
+
+
+logger = getLogger(__name__)
+
+
+async def _run_drift_analysis():
+    """
+    The core logic that scans source, queries the DB, and compares the results.
+    """
+    logger.info("Running Symbol Drift Analysis...")
+    logger.info("Scanning 'src/' directory for all public symbols...")
+    scanner = SymbolScanner(repo_root=bootstrap_registry.get_repo_path())
+    code_symbols = await asyncio.to_thread(scanner.scan)
+    code_symbol_paths = {s["symbol_path"] for s in code_symbols}
+    logger.info("Found %s symbols in source code.", len(code_symbol_paths))
+    logger.info("Querying database for all registered symbols...")
+    db_symbol_paths = set()
+    try:
+        async with get_session() as session:
+            result = await session.execute(text("SELECT symbol_path FROM core.symbols"))
+            db_symbol_paths = {row[0] for row in result}
+        logger.info("Found %s symbols in the database.", len(db_symbol_paths))
+    except Exception as e:
+        logger.error("Database query failed: %s", e)
+        logger.info("Please ensure your database is running and accessible.")
+        return
+    ghost_symbols_in_db = sorted(list(db_symbol_paths - code_symbol_paths))
+    new_symbols_in_code = sorted(list(code_symbol_paths - db_symbol_paths))
+    logger.info("--- Analysis Complete ---")
+    if not ghost_symbols_in_db and (not new_symbols_in_code):
+        logger.info(
+            "No drift detected. The database is perfectly synchronized with the source code."
+        )
+        return
+    if ghost_symbols_in_db:
+        logger.warning("Found %s Ghost Symbols in Database", len(ghost_symbols_in_db))
+        logger.warning(
+            "These symbols exist in the DB but NOT in the source code. They should be pruned."
+        )
+        for symbol in ghost_symbols_in_db:
+            logger.warning("  - %s", symbol)
+        logger.info(
+            "Diagnosis: The `sync-knowledge` command is failing to delete obsolete symbols from the database."
+        )
+    if new_symbols_in_code:
+        logger.info("Found %s New Symbols in Source Code", len(new_symbols_in_code))
+        logger.info(
+            "These symbols exist in the code but NOT in the DB. They need to be synchronized."
+        )
+        for symbol in new_symbols_in_code:
+            logger.info("  - %s", symbol)
+    logger.info(
+        "Next Step: This report confirms a bug in the sync logic. Please proceed with fixing the `run_sync_with_db` function."
+    )
+
+
+# ID: 2ff57ea1-2b62-4c75-9586-10219c51ea13
+async def inspect_symbol_drift():
+    """Typer wrapper for the async drift analysis logic."""
+    await _run_drift_analysis()

cli/logic/sync.py

@@ -0,0 +1,48 @@
+# src/cli/logic/sync.py
+"""
+Headless logic for synchronizing the codebase state with the database.
+Complies with body_contracts.json (no UI imports).
+"""
+
+from __future__ import annotations
+
+from body.introspection.sync_service import run_sync_with_db
+from shared.infrastructure.database.session_manager import get_session
+from shared.logger import getLogger
+
+
+logger = getLogger(__name__)
+
+
+# ID: 26a3ed07-80bb-4a78-a05d-862cae7968e3
+async def sync_knowledge_base(write: bool = False) -> dict:
+    """
+    Scans the codebase and syncs all symbols and their IDs to the database.
+
+    Returns:
+        dict: Sync statistics.
+    """
+    logger.info("🚀 Synchronizing codebase state with database...")
+
+    if not write:
+        logger.info("DRY-RUN: Knowledge sync requires write=True to persist changes.")
+        return {
+            "status": "dry_run",
+            "scanned": 0,
+            "inserted": 0,
+            "updated": 0,
+            "deleted": 0,
+        }
+
+    async with get_session() as session:
+        # run_sync_with_db returns an ActionResult; we extract the data for the caller
+        result = await run_sync_with_db(session)
+        stats = result.data
+
+    logger.info("--- Knowledge Sync Summary ---")
+    logger.info("   Scanned from code:  %s symbols", stats.get("scanned", 0))
+    logger.info("   New symbols added:  %s", stats.get("inserted", 0))
+    logger.info("   Existing symbols updated: %s", stats.get("updated", 0))
+    logger.info("   Obsolete symbols removed: %s", stats.get("deleted", 0))
+
+    return stats

cli/logic/sync_domains.py

@@ -0,0 +1,72 @@
+# src/cli/logic/sync_domains.py
+"""
+CLI command to synchronize the canonical list of domains to the database.
+"""
+
+from __future__ import annotations
+
+import typer
+import yaml
+from sqlalchemy import text
+
+from shared.context import CoreContext
+from shared.infrastructure.database.session_manager import get_session
+from shared.logger import getLogger
+
+
+logger = getLogger(__name__)
+
+
+async def _sync_domains(repo_root):
+    """
+    Reads the canonical domains.yaml file and upserts them into the core.domains table.
+    """
+    domains_path = repo_root / "var" / "mind" / "knowledge" / "domains.yaml"
+    if not domains_path.exists():
+        logger.error("Constitutional domains file not found at %s", domains_path)
+        raise typer.Exit(code=1)
+
+    content = yaml.safe_load(domains_path.read_text("utf-8"))
+    domains_to_sync = content.get("domains", [])
+
+    if not domains_to_sync:
+        logger.warning("No domains found in domains.yaml. Nothing to sync.")
+        return
+
+    upserted_count = 0
+    async with get_session() as session:
+        async with session.begin():  # Start a transaction
+            for domain_data in domains_to_sync:
+                name = domain_data.get("name")
+                description = domain_data.get("description", "")
+                if not name:
+                    continue
+
+                stmt = text(
+                    """
+                    INSERT INTO core.domains (key, title, description, status)
+                    VALUES (:key, :title, :desc, 'active')
+                    ON CONFLICT (key) DO UPDATE SET
+                        title = EXCLUDED.title,
+                        description = EXCLUDED.description;
+                """
+                )
+
+                await session.execute(
+                    stmt,
+                    {
+                        "key": name,
+                        "title": name.replace("_", " ").title(),
+                        "desc": description,
+                    },
+                )
+                upserted_count += 1
+
+    logger.info("Successfully synced %s domains to the database.", upserted_count)
+
+
+# ID: 5bee5341-7f72-430e-b310-f174af37de20
+async def sync_domains(ctx: typer.Context):
+    """Synchronizes the canonical list of domains from .intent/knowledge/domains.yaml to the database."""
+    core_context: CoreContext = ctx.obj
+    await _sync_domains(core_context.git_service.repo_path)

cli/logic/sync_manifest.py

@@ -0,0 +1,31 @@
+# src/cli/logic/sync_manifest.py
+"""
+LEGACY / DEPRECATED — DO NOT USE.
+
+This module previously synchronized a legacy project manifest under `.intent/`.
+That behavior is constitutionally invalid:
+
+- `.intent/` is READ-ONLY for BODY.
+"""
+
+from __future__ import annotations
+
+import typer
+
+from shared.logger import getLogger
+
+
+logger = getLogger(__name__)
+
+
+# ID: fd8e5164-0a37-45e7-8701-7a1935d99d88
+async def sync_manifest() -> None:
+    """
+    Disabled operation: BODY may not write to `.intent/`.
+    """
+    logger.error(
+        "sync-manifest is deprecated and disabled: "
+        "BODY may not write to `.intent/`. "
+        "Migrate any consumers to SSOT (Postgres)."
+    )
+    raise typer.Exit(code=1)

cli/logic/tools.py

@@ -0,0 +1,133 @@
+# src/cli/logic/tools.py
+"""
+Registers a 'tools' command group for powerful, operator-focused maintenance tasks.
+This is the new, governed home for logic from standalone scripts.
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+import typer
+
+from body.maintenance.maintenance_service import rewire_imports
+
+# Import the moved script module
+from body.maintenance.scripts import context_export
+from shared.cli.command_meta import (
+    CommandBehavior,
+    CommandLayer,
+    command_meta,
+)  # Add this import
+from shared.logger import getLogger
+
+
+logger = getLogger(__name__)
+
+tools_app = typer.Typer(
+    help="Governed, operator-focused maintenance and refactoring tools."
+)
+
+
+@tools_app.command(
+    "rewire-imports",
+    help="Run after major refactoring to fix all Python import statements across 'src/'.",
+)
+@command_meta(
+    canonical_name="imports.rewire",
+    behavior=CommandBehavior.MUTATE,
+    layer=CommandLayer.BODY,
+    summary="Automatically fixes Python import statements across the codebase after major refactoring.",
+    dangerous=True,
+)
+# ID: 85a8bd02-dba4-4aab-9329-c36cc60a121a
+def rewire_imports_cli(
+    write: bool = typer.Option(
+        False, "--write", help="Apply the changes to the files."
+    ),
+):
+    """
+    CLI wrapper for the import rewiring service.
+    """
+    dry_run = not write
+    logger.info("Starting architectural import re-wiring script...")
+    if dry_run:
+        logger.info("DRY RUN MODE: No files will be changed.")
+    else:
+        logger.info("WRITE MODE: Files will be modified.")
+
+    # REFACTORED: Removed direct settings import
+    from body.infrastructure.bootstrap import create_core_context
+    from body.services.service_registry import service_registry
+    from shared.infrastructure.storage.file_handler import FileHandler
+
+    context = create_core_context(service_registry)
+    file_handler = FileHandler(str(context.git_service.repo_path))
+    total_changes = rewire_imports(context, file_handler, dry_run=dry_run)
+
+    logger.info("--- Re-wiring Complete ---")
+    if dry_run:
+        logger.info(
+            "DRY RUN: Found %s potential import changes to make.", total_changes
+        )
+        logger.info("Run with '--write' to apply them.")
+    else:
+        logger.info("APPLIED: Made %s import changes.", total_changes)
+
+    logger.info("--- NEXT STEPS ---")
+    logger.info(
+        "1. VERIFY: Run 'make format' and then 'make check' to ensure compliance."
+    )
+
+
+@tools_app.command("export-context")
+@command_meta(
+    canonical_name="context.export",
+    behavior=CommandBehavior.TRANSFORM,
+    layer=CommandLayer.BODY,
+    summary="Exports a complete operational snapshot including Mind, Body, State, and Vector data.",
+    dangerous=True,
+)
+# ID: a09e7c1d-791a-4132-bd51-146e468b8d89
+def export_context_cmd(
+    output_dir: Path = typer.Option(
+        Path("./scripts/exports"),
+        "--output-dir",
+        help="Directory to write export bundle into",
+    ),
+    db_url: str = typer.Option(None, "--db-url", help="Database URL override"),
+    qdrant_url: str = typer.Option(None, "--qdrant-url", help="Qdrant URL override"),
+    qdrant_collection: str = typer.Option(
+        None, "--qdrant-collection", help="Qdrant collection override"
+    ),
+):
+    """
+    Export a complete operational snapshot (Mind/Body/State/Vectors).
+    Wraps body.maintenance.scripts.context_export.
+    """
+    # Prepare arguments to look like sys.argv for the existing script logic
+    # This avoids rewriting the complex argparse logic inside the script for now.
+    args = ["context_export", "--output-dir", str(output_dir)]
+
+    if db_url:
+        args.extend(["--db-url", db_url])
+    if qdrant_url:
+        args.extend(["--qdrant-url", qdrant_url])
+    if qdrant_collection:
+        args.extend(["--qdrant-collection", qdrant_collection])
+
+    # Patch sys.argv temporarily to invoke the script's main
+    original_argv = sys.argv
+    try:
+        sys.argv = args
+        context_export.main()
+    except SystemExit as e:
+        # The script calls sys.exit(), we catch it to prevent CLI crash
+        if e.code != 0:
+            raise typer.Exit(e.code)
+    except Exception as e:
+        logger.error("Export failed: %s", e)
+        raise typer.Exit(1)
+    finally:
+        sys.argv = original_argv