core-runtime 0.1.1__py3-none-any.whl

cli/resources/context/search.py

@@ -0,0 +1,114 @@
+# src/cli/resources/context/search.py
+"""
+Context search command - Direct pattern search.
+
+Fast path for simple code pattern searches without full context building.
+
+Usage:
+    core-admin context search isinstance
+    core-admin context search "async def" --path src/will
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+
+import typer
+from rich.console import Console
+from rich.table import Table
+from sqlalchemy import text
+
+from body.services.service_registry import service_registry
+from shared.infrastructure.database.session_manager import get_session
+from shared.infrastructure.intent.operational_config import load_operational_config
+
+from .hub import app
+
+
+logger = logging.getLogger(__name__)
+console = Console()
+
+_CFG = load_operational_config().misc
+
+
+async def _search_async(pattern: str, path: str | None, limit: int) -> None:
+    """Query core.symbols for qualname/ast_signature matches."""
+    service_registry.prime(get_session)
+    module_filter: str | None = None
+    if path:
+        module_filter = path.replace("src/", "").replace("/", ".").strip(".")
+    like_pattern = f"%{pattern}%"
+    sql = text(
+        "\n        SELECT qualname, module, kind, ast_signature, intent\n        FROM core.symbols\n        WHERE (\n            ast_signature ILIKE :pat\n            OR qualname     ILIKE :pat\n            OR intent       ILIKE :pat\n        )\n        AND (CAST(:module_filter AS TEXT) IS NULL OR module ILIKE :module_pat)\n        ORDER BY qualname\n        LIMIT :limit\n        "
+    )
+    async with get_session() as session:
+        result = await session.execute(
+            sql,
+            {
+                "pat": like_pattern,
+                "module_filter": module_filter,
+                "module_pat": f"{module_filter}%" if module_filter else None,
+                "limit": limit,
+            },
+        )
+        rows = result.fetchall()
+    if not rows:
+        console.print(f"[yellow]No matches found for:[/yellow] {pattern}")
+        return
+    table = Table(
+        title=f"Search results for '{pattern}' ({len(rows)} found)",
+        header_style="bold cyan",
+    )
+    table.add_column("Symbol", style="cyan")
+    table.add_column("Module", style="dim")
+    table.add_column("Kind", style="magenta")
+    table.add_column("Signature / Intent", style="green")
+    for row in rows:
+        summary = (row.intent or row.ast_signature or "—")[:80]
+        table.add_row(row.qualname, row.module, row.kind, summary)
+    console.print(table)
+    if len(rows) == limit:
+        console.print(
+            f"[dim]Showing first {limit} results. Use --limit to see more.[/dim]"
+        )
+
+
+@app.command("search")
+# ID: 6ced2f28-5c2b-410c-b8ec-07db0518b602
+def search(
+    pattern: str = typer.Argument(
+        ..., help="Code pattern to search (e.g., 'isinstance')"
+    ),
+    path: str = typer.Option(None, "--path", help="Limit search to specific path"),
+    limit: int = typer.Option(
+        _CFG.context_search_display_limit,
+        "--limit",
+        help="Maximum results to return",
+    ),
+) -> None:
+    """
+    Search for code patterns directly in the knowledge graph.
+
+    Faster than 'build' for simple pattern searches.
+    Queries the symbols table directly (qualname, signature, intent).
+
+    Examples:
+        core-admin context search isinstance
+        core-admin context search "async def" --path src/will
+        core-admin context search "try" --limit 10
+
+    For semantic/vector search, use 'core-admin context build' instead.
+    """
+    try:
+        loop = asyncio.get_running_loop()
+    except RuntimeError:
+        loop = None
+    if loop and loop.is_running():
+        return
+    try:
+        asyncio.run(_search_async(pattern, path, limit))
+    except Exception as e:
+        console.print(f"[red]❌ Error: {e}[/red]")
+        logger.exception("Search failed")
+        raise typer.Exit(code=1)

cli/resources/database/__init__.py

@@ -0,0 +1,13 @@
+# src/cli/resources/database/__init__.py
+"""Database resource hub."""
+
+from __future__ import annotations
+
+# 2. Register all database neurons
+from . import cleanup, export, migrate, status, sync, sync_env, sync_registry
+
+# 1. Import the stable app from the hub
+from .hub import app
+
+
+__all__ = ["app"]

cli/resources/database/cleanup.py

@@ -0,0 +1,107 @@
+# src/cli/resources/database/cleanup.py
+"""
+Database cleanup command.
+
+Removes orphaned records, expired sessions, and stale data.
+"""
+
+from __future__ import annotations
+
+import logging
+
+import typer
+from rich.console import Console
+
+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("cleanup")
+@core_command(dangerous=True, requires_context=False)
+# ID: 6cce903f-ff9e-41de-b4cb-e01b09bfa139
+async def cleanup_database(
+    ctx: typer.Context,
+    write: bool = typer.Option(
+        False, "--write", help="Apply cleanup (default: dry-run)"
+    ),
+    target: str = typer.Option(
+        "all", "--target", "-t", help="Cleanup target: all, memory, action_results"
+    ),
+    days: int = typer.Option(
+        30, "--days", "-d", help="Age threshold in days for stale data removal"
+    ),
+) -> None:
+    """
+    Remove orphaned and stale database records.
+
+    Cleanup targets:
+    - memory: Old agent episode and reflection entries
+    - action_results: Old records from core.action_results ledger
+    - all: Run all cleanup operations
+
+    Constitutional Compliance:
+    - Requires --write flag for safety
+    - Generates audit trail for deletions
+
+    Examples:
+        # Dry-run: show what would be deleted
+        core-admin database cleanup
+
+        # Clean up old memory entries
+        core-admin database cleanup --target memory --write
+
+        # Full cleanup with custom age threshold
+        core-admin database cleanup --target all --days 60 --write
+    """
+    from body.maintenance.memory_cleanup_service import MemoryCleanupService
+
+    console.print("[bold cyan]🧹 Database Cleanup[/bold cyan]")
+    console.print(f"Target: {target}")
+    console.print(f"Age threshold: {days} days")
+    console.print(f"Mode: {'WRITE' if write else 'DRY-RUN'}")
+    console.print()
+    try:
+        async with get_session() as session:
+            service = MemoryCleanupService(session=session)
+            if target in ("all", "memory"):
+                result = await service.cleanup_old_memories(
+                    days_to_keep_episodes=days,
+                    days_to_keep_reflections=days * 3,
+                    dry_run=not write,
+                )
+                if result.ok:
+                    stats = result.data
+                    console.print("[green]✅ Memory cleanup completed[/green]")
+                    console.print(f"  Episodes: {stats.get('episodes_deleted', 0)}")
+                    console.print(
+                        f"  Reflections: {stats.get('reflections_deleted', 0)}"
+                    )
+                else:
+                    console.print(
+                        f"[red]❌ Memory cleanup failed: {result.data.get('error')}[/red]"
+                    )
+            if target in ("all", "action_results"):
+                result = await service.cleanup_action_results(
+                    days_to_keep=days, dry_run=not write
+                )
+                if result.ok:
+                    stats = result.data
+                    console.print("[green]✅ Action results cleanup completed[/green]")
+                    console.print(f"  Records: {stats.get('records_processed', 0)}")
+                else:
+                    console.print(
+                        f"[red]❌ Action results cleanup failed: {result.data.get('error')}[/red]"
+                    )
+        if not write:
+            console.print()
+            console.print("[yellow]💡 Run with --write to apply cleanup[/yellow]")
+    except Exception as e:
+        logger.error("Database cleanup failed", exc_info=True)
+        console.print(f"[red]❌ Error: {e}[/red]")
+        raise typer.Exit(1)

cli/resources/database/export.py

@@ -0,0 +1,61 @@
+# src/cli/resources/database/export.py
+"""
+Database export command.
+
+Exports database contents to JSON or SQL format.
+"""
+
+from __future__ import annotations
+
+import logging
+
+import typer
+from rich.console import Console
+
+from cli.utils import core_command
+
+from .hub import app
+
+
+logger = logging.getLogger(__name__)
+console = Console()
+
+
+@app.command("export")
+@core_command(dangerous=False, requires_context=True)
+# ID: e7f86889-85aa-40c7-92f9-19f751f8162f
+async def export_database(
+    ctx: typer.Context,
+    output_dir: str = typer.Option(
+        "backups", "--output-dir", "-o", help="Output directory for export files"
+    ),
+) -> None:
+    """
+    Export database operational data to files.
+
+    Exports database tables to canonical YAML representations
+    in the specified output directory.
+
+    Constitutional Compliance:
+    - Writes to var/ directory (runtime artifacts)
+    - Uses FileHandler for traceable mutations
+
+    Examples:
+        # Export to default backups directory
+        core-admin database export
+
+        # Export to custom directory
+        core-admin database export --output-dir exports/2024
+    """
+    console.print("[bold cyan]📤 Database Export[/bold cyan]")
+    console.print(f"Output directory: {output_dir}")
+    console.print()
+    try:
+        from cli.logic.db import export_data
+
+        export_data(output_dir)
+        console.print(f"[green]✅ Export completed to {output_dir}[/green]")
+    except Exception as e:
+        logger.error("Database export failed", exc_info=True)
+        console.print(f"[red]❌ Error: {e}[/red]")
+        raise typer.Exit(1)

cli/resources/database/hub.py

@@ -0,0 +1,11 @@
+# src/cli/resources/database/hub.py
+
+import typer
+
+
+# Stable hub for database resource commands
+app = typer.Typer(
+    name="database",
+    help="PostgreSQL state and operational data management.",
+    no_args_is_help=True,
+)

cli/resources/database/migrate.py

@@ -0,0 +1,57 @@
+# src/cli/resources/database/migrate.py
+"""
+Database migration command — currently dormant.
+
+The repo operates under a schema-as-truth model: `infra/sql/db_schema_live.sql`
+is the canonical schema, regenerated via `pg_dump --schema-only`. One-off SQL
+changes are committed under `infra/scripts/migrations/` as historical record
+but are NOT replayed through this CLI. The ledger-based migration framework
+(MigrationService + core._migrations table) is preserved but unused; this
+command will be revived if it is reintroduced. See #438 for history.
+"""
+
+from __future__ import annotations
+
+import typer
+from rich.console import Console
+
+from cli.utils import core_command
+
+from .hub import app
+
+
+console = Console()
+
+
+@app.command("migrate")
+@core_command(dangerous=False, requires_context=False)
+# ID: d8b7978f-d801-4ba2-a669-f0fd48851b01
+async def migrate_database(
+    ctx: typer.Context,
+    apply: bool = typer.Option(
+        False, "--apply", help="(Currently inert — framework is dormant.)"
+    ),
+) -> None:
+    """Show the current migration-framework status.
+
+    Currently dormant: schema-as-truth via `infra/sql/db_schema_live.sql` is
+    the canonical model. This command will be revived if ledger-based
+    migrations are reintroduced.
+    """
+    _ = apply  # currently unused; kept for forward-compat
+    console.print()
+    console.print("[yellow]⏸  Migration framework is currently dormant.[/yellow]")
+    console.print()
+    console.print("Schema-as-truth model is in effect:")
+    console.print("  • Canonical schema:  [cyan]infra/sql/db_schema_live.sql[/cyan]")
+    console.print(
+        "  • Regenerate via:    [cyan]pg_dump --schema-only --schema=core[/cyan]"
+    )
+    console.print(
+        "  • One-off SQL files: [cyan]infra/scripts/migrations/[/cyan] (historical record)"
+    )
+    console.print()
+    console.print(
+        "This command will be revived if ledger-based migrations are reintroduced."
+    )
+    console.print("See #438 for the framework-orphan history.")

cli/resources/database/status.py

@@ -0,0 +1,101 @@
+# src/cli/resources/database/status.py
+"""
+Database status command.
+
+Shows health metrics, connection status, and diagnostics.
+"""
+
+from __future__ import annotations
+
+import logging
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from cli.utils import core_command
+
+from .hub import app
+
+
+logger = logging.getLogger(__name__)
+console = Console()
+
+
+@app.command("status")
+@core_command(dangerous=False, requires_context=False)
+# ID: 7c22539d-3f8e-4d18-8457-9d194062a94e
+async def database_status(
+    ctx: typer.Context,
+    detailed: bool = typer.Option(
+        False, "--detailed", "-d", help="Show detailed table statistics"
+    ),
+    format: str = typer.Option(
+        "table", "--format", "-f", help="Output format: table or json"
+    ),
+) -> None:
+    """
+    Show database health metrics and diagnostics.
+
+    Displays:
+    - Connection status
+    - Database version
+    - Migration status
+
+    Examples:
+        # Basic status
+        core-admin database status
+
+        # JSON output for scripting
+        core-admin database status --format json
+    """
+    console.print("[bold cyan]📊 Database Status[/bold cyan]")
+    console.print()
+    try:
+        from shared.infrastructure.repositories.db.status_service import (
+            status as db_status,
+        )
+
+        report = await db_status()
+        if format == "json":
+            import json
+
+            result = {
+                "connected": report.is_connected,
+                "version": report.db_version,
+                "applied_migrations": list(report.applied_migrations),
+                "pending_migrations": report.pending_migrations,
+            }
+            console.print(json.dumps(result, indent=2, default=str))
+            return
+        _display_status_table(report, detailed)
+    except Exception as e:
+        logger.error("Database status check failed", exc_info=True)
+        console.print(f"[red]❌ Error: {e}[/red]")
+        raise typer.Exit(1)
+
+
+def _display_status_table(report, detailed: bool) -> None:
+    """Display status information as rich tables."""
+    console.print("[bold]Connection[/bold]")
+    conn_table = Table(show_header=False)
+    conn_table.add_column("Metric", style="cyan")
+    conn_table.add_column("Value")
+    conn_table.add_row(
+        "Status", "🟢 Connected" if report.is_connected else "🔴 Disconnected"
+    )
+    conn_table.add_row("Version", report.db_version or "N/A")
+    console.print(conn_table)
+    console.print()
+    console.print("[bold]Migrations[/bold]")
+    mig_table = Table(show_header=False)
+    mig_table.add_column("Metric", style="cyan")
+    mig_table.add_column("Value")
+    mig_table.add_row("Applied", str(len(report.applied_migrations)))
+    mig_table.add_row("Pending", str(len(report.pending_migrations)))
+    console.print(mig_table)
+    if report.pending_migrations:
+        console.print()
+        console.print("[yellow]⚠️  Pending migrations:[/yellow]")
+        for mig in sorted(report.pending_migrations):
+            console.print(f"  • {mig}")

cli/resources/database/sync.py

@@ -0,0 +1,84 @@
+# src/cli/resources/database/sync.py
+"""
+Database synchronization command.
+
+Synchronizes PostgreSQL schema and seeds constitutional data.
+"""
+
+from __future__ import annotations
+
+import logging
+
+import typer
+from rich.console import Console
+
+from cli.utils import core_command
+from shared.cli.command_meta import CommandBehavior, CommandLayer, command_meta
+from shared.infrastructure.database.session_manager import get_session
+
+from .hub import app
+
+
+logger = logging.getLogger(__name__)
+console = Console()
+
+
+@app.command("sync")
+@command_meta(
+    canonical_name="database.sync",
+    behavior=CommandBehavior.MUTATE,
+    layer=CommandLayer.BODY,
+    summary="Synchronize database with codebase symbols.",
+    dangerous=True,
+)
+@core_command(dangerous=True, requires_context=True)
+# ID: acb50cd7-0423-4837-bcda-e9ab8bc16a46
+async def sync_database(
+    ctx: typer.Context,
+    write: bool = typer.Option(
+        False, "--write", help="Apply changes to database (default: dry-run)"
+    ),
+) -> None:
+    """
+    Synchronize database with codebase symbols.
+
+    Scans the codebase and syncs all symbols to the database knowledge graph.
+
+    Constitutional Compliance:
+    - Enforces 'knowledge.database_ssot'
+    - All changes logged to audit trail
+    - Atomic action with rollback capability
+
+    Examples:
+        # Dry-run (show what would change)
+        core-admin database sync
+
+        # Apply changes
+        core-admin database sync --write
+    """
+    console.print("[bold cyan]📊 Database Synchronization[/bold cyan]")
+    console.print(f"Mode: {'WRITE' if write else 'DRY-RUN'}")
+    console.print()
+    try:
+        from body.introspection.sync_service import run_sync_with_db
+
+        if not write:
+            console.print("[yellow]DRY-RUN: Use --write to persist changes[/yellow]")
+            return
+        async with get_session() as session:
+            result = await run_sync_with_db(session)
+            if result.ok:
+                stats = result.data
+                console.print("[green]✅ Synchronization completed[/green]")
+                console.print()
+                console.print(f"  Scanned: {stats.get('scanned', 0)} symbols")
+                console.print(f"  Inserted: {stats.get('inserted', 0)}")
+                console.print(f"  Updated: {stats.get('updated', 0)}")
+                console.print(f"  Deleted: {stats.get('deleted', 0)}")
+            else:
+                console.print(f"[red]❌ Sync failed: {result.error}[/red]")
+                raise typer.Exit(1)
+    except Exception as e:
+        logger.error("Database sync failed", exc_info=True)
+        console.print(f"[red]❌ Error: {e}[/red]")
+        raise typer.Exit(1)

cli/resources/database/sync_env.py

@@ -0,0 +1,76 @@
+# src/cli/resources/database/sync_env.py
+"""
+Environment settings sync command.
+
+Reads variables from .env and upserts them into core.runtime_settings.
+"""
+
+from __future__ import annotations
+
+import logging
+
+import typer
+from rich.console import Console
+
+from cli.utils import core_command
+from shared.cli.command_meta import CommandBehavior, CommandLayer, command_meta
+from shared.infrastructure.database.session_manager import get_session
+
+from .hub import app
+
+
+logger = logging.getLogger(__name__)
+console = Console()
+
+
+@app.command("sync-env")
+@command_meta(
+    canonical_name="database.sync_env",
+    behavior=CommandBehavior.MUTATE,
+    layer=CommandLayer.BODY,
+    summary="Sync .env variables into core.runtime_settings table.",
+    dangerous=True,
+)
+@core_command(dangerous=True, requires_context=True)
+# ID: 44ffa6cb-5c9e-4c12-b8ab-ab673dbdf0d4
+async def sync_env(
+    ctx: typer.Context,
+    write: bool = typer.Option(False, "--write", help="Apply sync (default: dry-run)"),
+) -> None:
+    """
+    Sync environment variables into the database runtime_settings table.
+
+    Reads variables declared in mind.config.runtime_requirements and upserts
+    their current values from .env into core.runtime_settings.
+
+    Constitutional Compliance:
+    - Requires --write flag for safety
+    - Secret keys are masked in dry-run output
+
+    Examples:
+        # Dry-run: show what would be synced
+        core-admin database sync-env
+
+        # Apply sync
+        core-admin database sync-env --write
+    """
+    from body.maintenance.dotenv_sync_service import run_dotenv_sync
+
+    console.print("[bold cyan]⚙️  Environment Settings Sync[/bold cyan]")
+    console.print(f"Mode: {'WRITE' if write else 'DRY-RUN'}")
+    console.print()
+    try:
+        core_context = ctx.obj
+        async with get_session() as session:
+            await run_dotenv_sync(
+                context=core_context, session=session, dry_run=not write
+            )
+        if not write:
+            console.print()
+            console.print("[yellow]💡 Run with --write to apply sync[/yellow]")
+        else:
+            console.print("[green]✅ Environment settings synced to database[/green]")
+    except Exception as e:
+        logger.error("Environment sync failed", exc_info=True)
+        console.print(f"[red]❌ Error: {e}[/red]")
+        raise typer.Exit(1)

cli/resources/database/sync_registry.py

@@ -0,0 +1,48 @@
+# src/cli/resources/database/sync_registry.py
+
+import typer
+
+from cli.utils import core_command
+from shared.cli.command_meta import (
+    CommandBehavior,
+    CommandLayer,
+    command_meta,
+)  # Add this import
+from shared.infrastructure.database.session_manager import get_session
+
+from .hub import app
+
+
+@app.command("sync-registry")
+@command_meta(
+    canonical_name="database.sync-registry",
+    behavior=CommandBehavior.MUTATE,
+    layer=CommandLayer.BODY,
+    summary="Synchronize the live CLI command structure to the database.",
+    dangerous=True,  # Explicitly mark as dangerous
+)
+@core_command(dangerous=True, requires_context=False)
+# ID: d71b92d9-d954-48dd-9059-68f0b3ed4442
+async def sync_registry_cmd(
+    # Add the mandatory write parameter
+    write: bool = typer.Option(
+        False, "--write", help="Actually persist the registry to the database."
+    ),
+):
+    """
+    Synchronize the live CLI command structure (metadata) to the database.
+    This makes the DB the Single Source of Truth for available system neurons.
+    """
+    if not write:
+        typer.echo(
+            "📋 DRY RUN: Would synchronize CLI Registry to database. Use --write to apply."
+        )
+        return
+
+    from body.maintenance.command_sync_service import _sync_commands_to_db
+    from cli.admin_cli import app as main_app
+
+    async with get_session() as session:
+        await _sync_commands_to_db(session, main_app)
+
+    typer.echo("✅ CLI Registry synchronized to database.")

cli/resources/dev/__init__.py

@@ -0,0 +1,14 @@
+# src/cli/resources/dev/__init__.py
+
+"""Developer workflow and interaction operations."""
+
+from __future__ import annotations
+
+# Register all sub-modules (neurons) — import order triggers @app.command decorators
+from . import refactor, stability, strategic_audit, sync, test
+
+# Import the centralized app from the hub
+from .hub import app
+
+
+__all__ = ["app"]