core-runtime 0.1.1__py3-none-any.whl

cli/commands/fix/db_tools.py

@@ -0,0 +1,90 @@
+# src/cli/commands/fix/db_tools.py
+"""
+Database and vector-related commands for the 'fix' CLI group.
+
+Thin clients over POST /v1/sync/knowledge-graph and POST /v1/sync/vectors
+(ADR-058 D2). Both endpoints dispatch async; the CLI polls the
+sync_runs resource until terminal.
+"""
+
+from __future__ import annotations
+
+import logging
+
+import typer
+
+from api.cli import CoreApiClient
+from cli.utils import core_command
+
+from . import fix_app
+
+
+logger = logging.getLogger(__name__)
+
+
+@fix_app.command(
+    "knowledge-graph",
+    help="Synchronize code symbols to the PostgreSQL knowledge graph.",
+)
+@core_command(dangerous=True, confirmation=False, requires_context=False)
+# ID: 40bd8310-f78e-43bd-bc79-21b3519bc802
+async def sync_knowledge_graph_command(ctx: typer.Context) -> None:
+    """Thin client over POST /v1/sync/knowledge-graph."""
+    _ = ctx
+    typer.secho("Syncing knowledge graph to database...", fg=typer.colors.CYAN)
+    client = CoreApiClient()
+    initial = await client.sync_knowledge_graph(write=True)
+    run_id = initial.get("run_id")
+    if not run_id:
+        typer.secho(
+            f"❌ sync_knowledge_graph failed to dispatch: {initial}",
+            fg=typer.colors.RED,
+        )
+        raise typer.Exit(1)
+    final = await client.poll_sync_run(run_id)
+    if final.get("status") != "completed":
+        typer.secho(
+            f"❌ Knowledge graph sync failed: {final.get('error') or final}",
+            fg=typer.colors.RED,
+        )
+        raise typer.Exit(1)
+    typer.secho("✅ Knowledge graph sync completed", fg=typer.colors.GREEN)
+
+
+@fix_app.command(
+    "vector-sync", help="Atomically synchronize vectors between PostgreSQL and Qdrant."
+)
+@core_command(dangerous=True, confirmation=True, requires_context=False)
+# ID: 945cd068-91ec-4e32-acd0-2e1be5148732
+async def fix_vector_sync_command(
+    ctx: typer.Context,
+    write: bool = typer.Option(
+        False,
+        "--write",
+        help="Apply fixes to both PostgreSQL and Qdrant (otherwise dry-run).",
+    ),
+) -> None:
+    """Atomic bidirectional vector synchronization via POST /v1/sync/vectors."""
+    _ = ctx
+    typer.secho("Synchronizing vector database...", fg=typer.colors.CYAN)
+    client = CoreApiClient()
+    initial = await client.sync_vectors(write=write)
+    run_id = initial.get("run_id")
+    if not run_id:
+        typer.secho(
+            f"❌ sync_vectors failed to dispatch: {initial}", fg=typer.colors.RED
+        )
+        raise typer.Exit(1)
+    final = await client.poll_sync_run(run_id)
+    if final.get("status") != "completed":
+        typer.secho(
+            f"❌ Vector synchronization failed: {final.get('error') or final}",
+            fg=typer.colors.RED,
+        )
+        raise typer.Exit(1)
+    if write:
+        typer.secho("✅ Vector synchronization completed", fg=typer.colors.GREEN)
+    else:
+        typer.secho(
+            "✅ Vector synchronization dry-run completed", fg=typer.colors.GREEN
+        )

cli/commands/fix/fix_ir.py

@@ -0,0 +1,79 @@
+# src/cli/commands/fix/fix_ir.py
+"""
+IR (Incident Response) self-healing commands.
+
+Thin client over POST /v1/fix/ir (ADR-055 D6 Batch C2). The endpoint
+always writes; the CLI preserves --write/dry-run UX client-side by
+short-circuiting before the call when --write is not set.
+"""
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+
+import typer
+from rich.console import Console
+
+from api.cli import CoreApiClient
+from cli.utils import core_command
+
+from . import fix_app
+
+
+logger = logging.getLogger(__name__)
+console = Console()
+
+_IR_DIR = Path(".intent") / "mind" / "ir"
+_DRY_RUN_PATHS = {
+    "triage": _IR_DIR / "triage_log.yaml",
+    "log": _IR_DIR / "incident_log.yaml",
+}
+
+
+async def _scaffold(kind: str, label: str, write: bool) -> None:
+    rel_path = str(_DRY_RUN_PATHS[kind]).replace("\\", "/")
+    if not write:
+        console.print(
+            f"[yellow]Dry run:[/yellow] would ensure {rel_path} exists with a "
+            f"minimal {label.lower()} structure. Use --write to apply."
+        )
+        return
+    client = CoreApiClient()
+    result = await client.fix_ir(kind)
+    written_path = result.get("path", rel_path)
+    console.print(f"[green]✅ Created {label} at {written_path}[/green]")
+
+
+@fix_app.command("ir-triage", help="Initialize or update the incident triage log.")
+@core_command(dangerous=True, confirmation=False)
+# ID: c50add43-9412-44ad-b261-6f64aed07b21
+async def fix_ir_triage(
+    ctx: typer.Context,
+    write: bool = typer.Option(
+        False,
+        "--write",
+        help="Apply changes to the IR triage log (creates file if missing).",
+    ),
+) -> None:
+    """
+    Bootstrap the IR triage log under .intent/mind/ir/.
+    """
+    await _scaffold("triage", "IR triage log", write)
+
+
+@fix_app.command("ir-log", help="Initialize or update the incident response log.")
+@core_command(dangerous=True, confirmation=False)
+# ID: e2f34a52-0839-4146-bafd-7ce6b559a510
+async def fix_ir_log(
+    ctx: typer.Context,
+    write: bool = typer.Option(
+        False,
+        "--write",
+        help="Apply changes to the IR incident log (creates file if missing).",
+    ),
+) -> None:
+    """
+    Bootstrap the main incident response log under .intent/mind/ir/.
+    """
+    await _scaffold("log", "IR incident log", write)

cli/commands/fix/handler_discovery.py

@@ -0,0 +1,54 @@
+# src/cli/commands/fix/handler_discovery.py
+"""
+Action discovery command — thin client over GET /v1/actions.
+
+Renders the full atomic-action registry server-side; the CLI just shapes
+the table.
+"""
+
+from __future__ import annotations
+
+import logging
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from api.cli import CoreApiClient
+from cli.utils import core_command
+
+from . import fix_app
+
+
+logger = logging.getLogger(__name__)
+console = Console()
+
+
+@fix_app.command("discover-actions")
+@core_command(dangerous=False, requires_context=False)
+# ID: a5ba0fda-a697-490f-8a81-f16056b380c4
+async def discover_actions_command(ctx: typer.Context) -> None:
+    """
+    List all registered Atomic Actions from the canonical registry.
+    """
+    _ = ctx
+    console.print(
+        "[bold cyan]🔍 Discovering Registered Atomic Actions...[/bold cyan]\n"
+    )
+    client = CoreApiClient()
+    payload = await client.list_actions()
+    actions = payload.get("actions", [])
+    table = Table(show_header=True, header_style="bold green")
+    table.add_column("Action ID", style="cyan")
+    table.add_column("Category", style="blue")
+    table.add_column("Impact", style="magenta")
+    table.add_column("Description")
+    for action in sorted(actions, key=lambda a: a.get("action_id", "")):
+        table.add_row(
+            action.get("action_id", ""),
+            action.get("category", ""),
+            action.get("impact_level", ""),
+            action.get("description", ""),
+        )
+    console.print(table)
+    console.print(f"\n[green]✅ Total Actions Registered: {len(actions)}[/green]")

cli/commands/fix/imports.py

@@ -0,0 +1,55 @@
+# src/cli/commands/fix/imports.py
+"""
+Import organization command for the 'fix' CLI group — thin client over
+POST /v1/fix/run/fix.imports.
+"""
+
+from __future__ import annotations
+
+import logging
+
+import typer
+from rich.console import Console
+
+from api.cli import CoreApiClient
+from cli.utils import core_command
+
+from . import fix_app
+
+
+logger = logging.getLogger(__name__)
+console = Console()
+
+
+@fix_app.command(
+    "imports",
+    help="Sort and group imports according to PEP 8 (stdlib → third-party → local).",
+)
+@core_command(dangerous=False)
+# ID: da8cd296-1100-48b8-b87a-1edeafa5db15
+async def fix_imports_command(
+    ctx: typer.Context,
+    write: bool = typer.Option(
+        False, "--write/--dry-run", help="Apply import sorting (default: dry-run)"
+    ),
+) -> None:
+    """
+    Sort and group Python imports according to constitutional style policy.
+
+    Dispatches fix.imports via POST /v1/fix/run/{fix_id}. The server runs
+    ruff with the I rules; the CLI polls and reports.
+    """
+    _ = ctx
+    console.print("[bold cyan]Sorting imports...[/bold cyan]")
+    console.print(f"Mode: {'WRITE' if write else 'DRY RUN'}")
+    client = CoreApiClient()
+    initial = await client.run_fix("fix.imports", write=write)
+    run_id = initial.get("run_id")
+    if not run_id:
+        console.print(f"[red]fix.imports failed to dispatch: {initial}[/red]")
+        raise typer.Exit(1)
+    final = await client._poll_run(run_id)
+    if final.get("status") != "completed":
+        console.print(f"[red]fix.imports failed: {final.get('error') or final}[/red]")
+        raise typer.Exit(1)
+    console.print("[green]✅ Import sorting completed[/green]")

cli/commands/fix/list_commands.py

@@ -0,0 +1,54 @@
+# src/cli/commands/fix/list_commands.py
+"""
+Listing and discovery commands for the 'fix' CLI group.
+
+Provides:
+- core-admin fix list — thin client over GET /v1/fix/commands.
+
+Renders the registered fix-* atomic actions returned by the server
+(action_id, category, impact, description) rather than the local CLI
+COMMAND_CONFIG used pre-migration. The two views are not identical;
+this is the intentional behavior per ADR-055 D6 Batch C4 ("CLI is a
+typed HTTP client").
+"""
+
+from __future__ import annotations
+
+import logging
+
+from rich.console import Console
+from rich.table import Table
+
+from api.cli import CoreApiClient
+
+from . import fix_app
+
+
+logger = logging.getLogger(__name__)
+console = Console()
+
+
+@fix_app.command("list", help="List all available fix commands with their categories.")
+# ID: cf22c003-eec0-4c68-8bac-f7876a276538
+async def list_commands() -> None:
+    """
+    Render a Rich table of all registered fix-category atomic actions.
+
+    Columns: Action ID, Category, Impact, Description.
+    """
+    client = CoreApiClient()
+    payload = await client.list_fix_commands()
+    commands = payload.get("commands", [])
+    table = Table(title="Available fix actions")
+    table.add_column("Action ID", style="cyan", no_wrap=True)
+    table.add_column("Category", style="magenta")
+    table.add_column("Impact", justify="center")
+    table.add_column("Description", style="dim")
+    for cmd in sorted(commands, key=lambda c: c.get("action_id", "")):
+        table.add_row(
+            cmd.get("action_id", ""),
+            cmd.get("category", ""),
+            cmd.get("impact_level", ""),
+            cmd.get("description", ""),
+        )
+    console.print(table)

cli/commands/fix/metadata.py

@@ -0,0 +1,160 @@
+# src/cli/commands/fix/metadata.py
+"""
+Metadata-related self-healing commands for the 'fix' CLI group.
+
+Provides:
+- fix ids (Assign stable UUIDs)
+- fix purge-legacy-tags
+- fix policy-ids
+- fix tags (Capability tagging)
+- fix duplicate-ids
+- fix placeholders
+- fix dead-code
+
+Thin clients over POST /v1/fix/run/{fix_id}. All execution moves
+server-side; this module only dispatches, polls, and renders.
+"""
+
+from __future__ import annotations
+
+import logging
+
+import typer
+from rich.console import Console
+
+from api.cli import CoreApiClient
+from cli.utils import core_command
+
+from . import fix_app
+
+
+logger = logging.getLogger(__name__)
+console = Console()
+
+
+__all__ = [
+    "fix_dead_code_cmd",
+    "fix_duplicate_ids_command",
+    "fix_placeholders_command",
+    "fix_tags_command",
+    "purge_legacy_tags_command",
+]
+
+
+async def _dispatch_and_poll(
+    fix_id: str, *, write: bool, params: dict | None = None
+) -> dict:
+    """Dispatch an atomic fix and poll to terminal status.
+
+    Returns the final fix_runs payload. Raises typer.Exit(1) on
+    dispatch failure or non-completed terminal status.
+    """
+    client = CoreApiClient()
+    initial = await client.run_fix(fix_id, write=write, params=params)
+    run_id = initial.get("run_id")
+    if not run_id:
+        console.print(f"[red]{fix_id} failed to dispatch: {initial}[/red]")
+        raise typer.Exit(1)
+    final = await client._poll_run(run_id)
+    if final.get("status") != "completed":
+        console.print(f"[red]{fix_id} failed: {final.get('error') or final}[/red]")
+        raise typer.Exit(1)
+    return final
+
+
+@fix_app.command(
+    "purge-legacy-tags",
+    help="Removes obsolete tag formats (e.g. old 'Tag:' or 'Metadata:' lines).",
+)
+@core_command(dangerous=True, confirmation=True)
+# ID: ab1c0d74-ec6c-45b4-a909-2a43eb9b8d41
+async def purge_legacy_tags_command(
+    ctx: typer.Context,
+    write: bool = typer.Option(
+        False, "--write", help="Apply changes (remove the lines)."
+    ),
+) -> None:
+    """Remove obsolete tag formats from Python files."""
+    _ = ctx
+    final = await _dispatch_and_poll("fix.purge_legacy_tags", write=write)
+    data = (final.get("result") or {}).get("data", {})
+    removed = data.get("removed", 0)
+    mode = "removed" if write else "would be removed (dry-run)"
+    console.print(f"[bold green]Obsolete tags {mode}: {removed}[/bold green]")
+
+
+@fix_app.command(
+    "tags", help="Tags untagged capabilities by calling the capability-tagging service."
+)
+@core_command(dangerous=True, confirmation=True)
+# ID: 7d415daf-34de-4971-be89-991cd9490591
+async def fix_tags_command(
+    ctx: typer.Context,
+    write: bool = typer.Option(False, "--write", help="Write capability tags to DB."),
+) -> None:
+    """
+    Automatically tag untagged capabilities using the AI naming agent.
+    """
+    _ = ctx
+    await _dispatch_and_poll("fix.capability_tagging", write=write)
+    console.print("[green]✓ fix.capability_tagging completed.[/green]")
+
+
+@fix_app.command(
+    "duplicate-ids",
+    help="Resolves duplicate IDs by regenerating fresh UUIDs for conflicts.",
+)
+@core_command(dangerous=True, confirmation=True)
+# ID: 96717df8-d28f-4124-bc1e-71bf3921b358
+async def fix_duplicate_ids_command(
+    ctx: typer.Context,
+    write: bool = typer.Option(
+        False, "--write", help="Apply the changes to resolve duplicate IDs."
+    ),
+) -> None:
+    """Detect and resolve duplicate IDs in Python files."""
+    _ = ctx
+    console.print("[cyan]Resolving duplicate IDs...[/cyan]")
+    await _dispatch_and_poll("fix.duplicate_ids", write=write)
+    console.print("[green]✓ fix.duplicate_ids completed.[/green]")
+
+
+@fix_app.command(
+    "placeholders",
+    help="Automated replacement of forbidden placeholders (FUTURE, pending, none).",
+)
+@core_command(dangerous=True, confirmation=True)
+# ID: e8c8f803-1cad-4150-9e66-e50859d8bd35
+async def fix_placeholders_command(
+    ctx: typer.Context,
+    write: bool = typer.Option(
+        False, "--write", help="Apply fixes to resolve forbidden placeholders."
+    ),
+) -> None:
+    """
+    Detects and resolves forbidden placeholder strings (pending, FUTURE, etc.)
+    via the registered fix.placeholders atomic action.
+    """
+    _ = ctx
+    console.print("[cyan]Purging forbidden placeholders...[/cyan]")
+    await _dispatch_and_poll("fix.placeholders", write=write)
+    console.print("[green]✓ fix.placeholders completed.[/green]")
+
+
+@fix_app.command(
+    "dead-code", help="Mechanically remove unused variables/functions found by Vulture."
+)
+@core_command(dangerous=True)
+# ID: d2a428ee-63c2-4212-8c73-5bbebf514ff0
+async def fix_dead_code_cmd(
+    ctx: typer.Context,
+    write: bool = typer.Option(False, "--write", help="Apply the deletions."),
+) -> None:
+    """CLI wrapper for the Vulture Healer (registered as fix.vulture_heal)."""
+    _ = ctx
+    console.print("[bold cyan]Snipping dead code scars...[/bold cyan]")
+    await _dispatch_and_poll("fix.vulture_heal", write=write)
+    if not write:
+        console.print(
+            "\n[yellow]💡 Dry run complete. Use --write to apply the 'Scissors'.[/yellow]"
+        )

cli/commands/fix/modularity.py

@@ -0,0 +1,88 @@
+# src/cli/commands/fix/modularity.py
+"""
+Automated Modularity Healing — thin client over POST /v1/fix/modularity.
+
+The endpoint is async (202 + run_id); CLI polls via CoreApiClient._poll_run
+and renders the per-file remediation summary that
+ModularityRemediationService writes into fix_runs.result.
+"""
+
+from __future__ import annotations
+
+import logging
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from api.cli import CoreApiClient
+from cli.utils import core_command
+
+from . import fix_app
+
+
+logger = logging.getLogger(__name__)
+console = Console()
+
+
+@fix_app.command("modularity", help="Autonomously modularize architectural offenders.")
+@core_command(dangerous=True, confirmation=True)
+# ID: ea078c28-eb5f-46ec-b39c-e55cf33714ed
+async def fix_modularity_cmd(
+    ctx: typer.Context,
+    min_score: float = typer.Option(
+        None,
+        "--score",
+        help="Minimum score to trigger healing (defaults to Constitution)",
+    ),
+    limit: int = typer.Option(
+        1, "--limit", "-n", help="Max files to heal in one batch"
+    ),
+    write: bool = typer.Option(False, "--write", help="Apply changes autonomously"),
+) -> None:
+    """
+    Finds high-complexity files and uses the A3 loop to modularize them.
+    """
+    params: dict[str, object] = {"limit": limit}
+    if min_score is not None:
+        params["min_score"] = min_score
+
+    console.print("[bold cyan]CORE is defragmenting architecture...[/bold cyan]")
+    client = CoreApiClient()
+    initial = await client.fix_modularity(write=write, params=params)
+    run_id = initial.get("run_id")
+    if not run_id:
+        console.print(f"[red]fix.modularity failed to dispatch: {initial}[/red]")
+        raise typer.Exit(1)
+    final = await client._poll_run(run_id)
+    if final.get("status") != "completed":
+        console.print(
+            f"[red]fix.modularity failed: {final.get('error') or final}[/red]"
+        )
+        raise typer.Exit(1)
+
+    result_payload = final.get("result") or {}
+    files = result_payload.get("files", [])
+    if not files:
+        console.print("[green]✅ No files exceed the modularity threshold.[/green]")
+        return
+
+    table = Table(title="Modularity Healing Results")
+    table.add_column("File", style="cyan")
+    table.add_column("Status", justify="center")
+    table.add_column("Initial", justify="right")
+    table.add_column("Final", justify="right")
+    table.add_column("Delta", style="green", justify="right")
+    for res in files:
+        status = "✅" if res.get("success") else "❌"
+        start_score = res.get("start_score", 0.0)
+        final_score = res.get("final_score", 0.0)
+        delta = res.get("improvement", 0.0)
+        table.add_row(
+            res.get("file", ""),
+            status,
+            f"{start_score:.1f}",
+            f"{final_score:.1f}",
+            f"-{delta:.1f}" if delta > 0 else "0.0",
+        )
+    console.print(table)

cli/commands/fix/settings_access.py

@@ -0,0 +1,65 @@
+# src/cli/commands/fix/settings_access.py
+"""Refactor settings.* imports to DI — thin client over POST /v1/fix/run/fix.settings_access."""
+
+from __future__ import annotations
+
+import logging
+
+import typer
+from rich.console import Console
+
+from api.cli import CoreApiClient
+from cli.utils import core_command
+
+from . import fix_app
+
+
+logger = logging.getLogger(__name__)
+console = Console()
+
+
+@fix_app.command("settings-di")
+@core_command(dangerous=True, confirmation=True)
+# ID: 4bb27cb3-4f2f-4462-8c80-7e57828c2ed1
+async def fix_settings_di_cmd(
+    ctx: typer.Context,
+    write: bool = typer.Option(False, "--write", help="Apply changes"),
+    layers: str = typer.Option("mind,will", "--layers", help="Comma-separated layers"),
+) -> None:
+    """Refactor settings imports to dependency injection via CoreContext."""
+    _ = ctx
+    layer_list = [layer.strip() for layer in layers.split(",")]
+    client = CoreApiClient()
+    initial = await client.run_fix(
+        "fix.settings_access", write=write, params={"layers": layer_list}
+    )
+    run_id = initial.get("run_id")
+    if not run_id:
+        console.print(f"[red]fix.settings_access failed to dispatch: {initial}[/red]")
+        raise typer.Exit(1)
+    final = await client._poll_run(run_id)
+    if final.get("status") != "completed":
+        console.print(
+            f"[red]fix.settings_access failed: {final.get('error') or final}[/red]"
+        )
+        raise typer.Exit(1)
+
+    result_data = (final.get("result") or {}).get("data", {})
+    results = result_data.get("results", {})
+    total_refactored = 0
+    total_failed = 0
+    for layer_name, stats in results.items():
+        console.print(f"\n[cyan]{layer_name.upper()}[/cyan]:")
+        console.print(f"  Files analyzed: {stats.get('analyzed', 0)}")
+        console.print(f"  Files refactored: {stats.get('refactored', 0)}")
+        total_refactored += stats.get("refactored", 0)
+        failed = stats.get("failed", 0)
+        total_failed += failed
+        if failed:
+            console.print(f"  [red]Failed: {failed}[/red]")
+    console.print("\n[bold]Summary:[/bold]")
+    console.print(f"  Total refactored: {total_refactored}")
+    if total_failed:
+        console.print(f"  [red]Total failed: {total_failed}[/red]")
+    else:
+        console.print("  [green]✅ All files processed successfully[/green]")