core-runtime 0.1.1__py3-none-any.whl

cli/commands/refactor_support/display.py

@@ -0,0 +1,170 @@
+# src/cli/commands/refactor_support/display.py
+
+"""Display formatting for refactoring analysis output.
+
+Pure presentation layer. No CORE-internal imports; Rich rendering only.
+All output routes through `console.print` per the CLAUDE.md Rich rule
+(Rich objects/markup must not pass through `logger.info`).
+"""
+
+from __future__ import annotations
+
+import logging
+
+from rich.console import Console
+from rich.table import Table
+
+
+logger = logging.getLogger(__name__)
+console = Console()
+
+
+# ID: faf1e919-5ae7-4a63-8e3b-89847123dd51
+class RefactorDisplay:
+    """Handles Rich-based display formatting for refactoring analysis."""
+
+    def __init__(self):
+        self.console = console
+
+    @staticmethod
+    # ID: 903e0fd9-1162-4d90-951c-9cc4ed2497f5
+    def show_file_analysis(file_path: str, details: dict, target_value: float) -> None:
+        """Display detailed analysis for a single file."""
+        console.print(f"[bold cyan]🔍 Analyzing Modularity: {file_path}[/bold cyan]\n")
+        score = details["total_score"]
+        breakdown = details["breakdown"]
+        status, color = RefactorDisplay._get_status(score, target_value)
+        console.print(
+            f"[{color}]Status: {status} "
+            f"(Score: {score:.1f} / Target: <{target_value})[/{color}]\n"
+        )
+        RefactorDisplay._show_breakdown_table(breakdown, score)
+        RefactorDisplay._show_responsibilities(details)
+        RefactorDisplay._show_cohesion_warning(details)
+        RefactorDisplay._show_coupling_warning(details)
+
+    @staticmethod
+    # ID: 1f9a5dcb-9ae6-45a6-bce0-e3a98c74ba97
+    def show_recommendations(recommendations: list[str]) -> None:
+        """Display recommendations."""
+        console.print("\n[bold green]💡 Recommended Improvements:[/bold green]")
+        for rec in recommendations:
+            console.print(f"  - {rec}")
+
+    @staticmethod
+    # ID: f9985b46-2553-46df-9e10-fb86eceb56ea
+    def show_clean_file() -> None:
+        """Display message for exceptionally clean files."""
+        console.print("[bold green]✅ This file is exceptionally clean.[/bold green]")
+
+    @staticmethod
+    # ID: 9f129067-663c-4ec0-944a-59c3aac772a3
+    def show_candidates_table(
+        candidates: list[dict], target_value: float, limit: int
+    ) -> None:
+        """Display table of refactoring candidates."""
+        table = Table(title=f"Refactoring Candidates (Top {limit})")
+        table.add_column("File Path", style="cyan")
+        table.add_column("Score", justify="right")
+        table.add_column("Resp.", justify="right")
+        table.add_column("Lines", justify="right")
+        for c in candidates[:limit]:
+            color = "red" if c["score"] > target_value else "yellow"
+            table.add_row(
+                str(c["file"]),
+                f"[{color}]{c['score']:.1f}[/{color}]",
+                str(c["resp"]),
+                str(c["loc"]),
+            )
+        console.print(table)
+
+    @staticmethod
+    # ID: bedaeaa7-18e6-4ad9-b47e-ac1faa3e70f5
+    def show_no_candidates() -> None:
+        """Display message when no candidates exceed threshold."""
+        console.print(
+            "[bold green]✅ No files found exceeding the modularity threshold.[/bold green]"
+        )
+
+    @staticmethod
+    # ID: fb2cc8dc-a8e7-4310-8a91-fd89a6b203ea
+    def show_stats(
+        total_files: int,
+        avg_score: float,
+        target_value: float,
+        high_risk: int,
+        warning: int,
+        healthy: int,
+    ) -> None:
+        """Display codebase statistics."""
+        console.print("[bold cyan]📊 System Modularity Statistics[/bold cyan]\n")
+        console.print(f"Total Files Analyzed : [bold]{total_files}[/bold]")
+        console.print(f"Constitutional Target: <{target_value}")
+        console.print(f"Average System Score : [bold]{avg_score:.1f}/100[/bold]\n")
+        warning_level = target_value * 0.8
+        console.print("[bold]Health Distribution (80% Gaussian Gauge):[/bold]")
+        console.print(f"  🔴 High Risk (>{target_value})     : {high_risk} files")
+        console.print(
+            f"  🟡 Warning ({warning_level:.0f}-{target_value:.0f})  : {warning} files"
+        )
+        console.print(f"  🟢 Healthy (<{warning_level:.0f})     : {healthy} files")
+
+    @staticmethod
+    def _get_status(score: float, target_value: float) -> tuple[str, str]:
+        """Determine status and color based on score."""
+        if score > target_value:
+            return ("NON-COMPLIANT", "red")
+        elif score > target_value * 0.8:
+            return ("WARNING: BORDERLINE", "yellow")
+        else:
+            return ("COMPLIANT", "green")
+
+    @staticmethod
+    def _show_breakdown_table(breakdown: dict, total_score: float) -> None:
+        """Show modularity breakdown table."""
+        table = Table(title="Modularity Breakdown", box=None)
+        table.add_column("Dimension", style="cyan")
+        table.add_column("Impact", justify="right")
+        table.add_column("Max Weight", justify="right")
+        table.add_row("Responsibilities", f"{breakdown['responsibilities']:.1f}", "35")
+        table.add_row("Semantic Cohesion", f"{breakdown['cohesion']:.1f}", "25")
+        table.add_row("Dependency Coupling", f"{breakdown['coupling']:.1f}", "25")
+        table.add_row("Code Volume", f"{breakdown['size']:.1f}", "15")
+        table.add_row(
+            "[bold]TOTAL DEBT[/bold]", f"[bold]{total_score:.1f}[/bold]", "100"
+        )
+        console.print(table)
+
+    @staticmethod
+    def _show_responsibilities(details: dict) -> None:
+        """Show detected responsibilities."""
+        responsibilities = details.get("responsibilities")
+        if responsibilities:
+            console.print(
+                f"\n[bold]Detected Responsibilities ({len(responsibilities)}):[/bold]"
+            )
+            for resp in responsibilities:
+                console.print(f"  • {resp.replace('_', ' ').title()}")
+
+    @staticmethod
+    def _show_cohesion_warning(details: dict) -> None:
+        """Show cohesion warning if applicable."""
+        cohesion = details.get("cohesion", 1.0)
+        if cohesion < 0.7:
+            console.print(
+                f"\n[bold yellow]⚠️ Low Semantic Cohesion:[/bold yellow] {cohesion:.2f}"
+            )
+            console.print("  Functions in this file may not belong together logically.")
+
+    @staticmethod
+    def _show_coupling_warning(details: dict) -> None:
+        """Show coupling warning if applicable."""
+        concern_count = details.get("concern_count", 0)
+        if concern_count > 3:
+            console.print(
+                f"\n[bold yellow]⚠️ High Coupling:[/bold yellow] touches "
+                f"{concern_count} areas."
+            )
+            concerns = details.get("concerns") or []
+            if concerns:
+                console.print(f"  Areas: {', '.join(concerns)}")

cli/commands/refactor_support/recommendations.py

@@ -0,0 +1,55 @@
+# src/cli/commands/refactor_support/recommendations.py
+
+"""Generates smart recommendations based on analysis results.
+
+Pure presentation/text helper. Thresholds are baked in as CLI defaults
+rather than reaching into `shared.infrastructure.intent.operational_config`;
+the recommendation surface is governor-tuned only when copy changes, not
+on operational drift.
+"""
+
+from __future__ import annotations
+
+
+_RESPONSIBILITIES_THRESHOLD = 20.0
+_COHESION_THRESHOLD = 15.0
+_COUPLING_THRESHOLD = 15.0
+_LOC_THRESHOLD = 400
+
+
+# ID: 36f3d7ff-4832-419e-863a-7c169e8e5fe1
+class RecommendationEngine:
+    """Generates actionable recommendations from modularity analysis."""
+
+    @staticmethod
+    # ID: 90c40477-7955-446f-adb9-c330eadbe2d2
+    def generate(details: dict) -> list[str]:
+        """Generate recommendations based on breakdown scores."""
+        recommendations: list[str] = []
+        breakdown = details.get("breakdown", {})
+
+        if breakdown.get("responsibilities", 0) > _RESPONSIBILITIES_THRESHOLD:
+            recommendations.append(
+                "[bold]Split Module:[/bold] This file is doing too many things. "
+                "Extract logic into new files."
+            )
+
+        if breakdown.get("cohesion", 0) > _COHESION_THRESHOLD:
+            recommendations.append(
+                "[bold]Refine Logic:[/bold] Group related functions more tightly "
+                "to improve focus."
+            )
+
+        if breakdown.get("coupling", 0) > _COUPLING_THRESHOLD:
+            recommendations.append(
+                "[bold]Decouple:[/bold] Reduce external imports; use shared "
+                "services instead of direct calls."
+            )
+
+        if details.get("lines_of_code", 0) > _LOC_THRESHOLD:
+            recommendations.append(
+                "[bold]Reduce Volume:[/bold] File is physically too long. "
+                "Move helpers to shared/utils."
+            )
+
+        return recommendations

cli/commands/run.py

@@ -0,0 +1,60 @@
+# src/cli/commands/run.py
+"""
+Commands for executing specific complex system processes.
+
+`vectorize` is a thin client over POST /v1/sync/code-vectors (ADR-058 D2).
+The constitutional worker pipeline (`RepoCrawlerWorker` +
+`RepoEmbedderWorker`) runs server-side; this 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
+
+
+logger = logging.getLogger(__name__)
+run_app = typer.Typer(
+    help="Commands for executing complex processes and autonomous cycles.",
+    no_args_is_help=True,
+)
+
+
+@run_app.command("vectorize")
+@core_command(dangerous=True, requires_context=False)
+# ID: f8e9d0a1-b2c3-4d5e-6f7a-8b9c0d1e2f3a
+async def vectorize_command(
+    ctx: typer.Context,
+    write: bool = typer.Option(False, "--write", help="Commit vectors to Qdrant."),
+    force: bool = typer.Option(
+        False, help="Force re-vectorization of all capabilities."
+    ),
+):
+    """Vectorize codebase artifacts via the constitutional worker pipeline."""
+    _ = ctx
+    _ = force  # API doesn't currently expose a force flag; #361 follow-up.
+    typer.secho(
+        "🚀 Starting vectorization via constitutional worker pipeline...",
+        fg=typer.colors.CYAN,
+    )
+    client = CoreApiClient()
+    initial = await client.sync_code_vectors(write=write)
+    run_id = initial.get("run_id")
+    if not run_id:
+        typer.secho(
+            f"❌ sync_code_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"❌ Vectorization failed: {final.get('error') or final}",
+            fg=typer.colors.RED,
+        )
+        raise typer.Exit(1)
+    typer.secho("✅ Vectorization completed", fg=typer.colors.GREEN)

cli/commands/search.py

@@ -0,0 +1,103 @@
+# src/cli/commands/search.py
+
+"""Search command group — capabilities and commands, both via API.
+
+Per ADR-057 D5 (revised 2026-05-18) and #363 (closed 2026-05-19):
+- `search capabilities` is served by GET /v1/search/capabilities.
+- `search commands` is served by GET /v1/search/commands.
+"""
+
+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
+
+
+logger = logging.getLogger(__name__)
+console = Console()
+search_app = typer.Typer(
+    help="Discover capabilities and commands.", no_args_is_help=True
+)
+
+
+@search_app.command("capabilities")
+@core_command(dangerous=False, requires_context=False)
+# ID: 4df5c462-ba14-4849-b707-ef1fce79b9b4
+async def search_capabilities_cmd(
+    ctx: typer.Context,
+    query: str = typer.Argument(..., help="The semantic query to search for."),
+    limit: int = typer.Option(5, "--limit", "-n", help="Max results to return."),
+) -> None:
+    """Performs a semantic search for capabilities via /v1/search/capabilities."""
+    _ = ctx
+    console.print(
+        f"🧠 Searching for capabilities related to: '[cyan]{query}[/cyan]'..."
+    )
+    client = CoreApiClient()
+    payload = await client.inspect_search_capabilities(q=query, limit=limit)
+    if not payload.get("available", False):
+        error = payload.get("error", "unknown error")
+        console.print(f"[yellow]Search unavailable: {error}[/yellow]")
+        return
+    results = payload.get("results") or []
+    if not results:
+        console.print("[yellow]No relevant capabilities found.[/yellow]")
+        return
+    table = Table(title="Top Matching Capabilities")
+    table.add_column("Score", style="magenta", justify="right")
+    table.add_column("Capability Key", style="cyan")
+    table.add_column("Description", style="green")
+    for hit in results:
+        hit_payload = hit.get("payload", {}) or {}
+        key = hit_payload.get("key", "none")
+        description = (
+            hit_payload.get("description") or "No description provided."
+        ).strip()
+        score = f"{hit.get('score', 0):.4f}"
+        table.add_row(score, key, description)
+    console.print(table)
+
+
+@search_app.command("commands")
+@core_command(dangerous=False, requires_context=False)
+# ID: 49b5f4fd-7f51-4a19-aa56-7373d83d381d
+async def search_commands_cmd(
+    ctx: typer.Context,
+    term: str = typer.Argument(
+        ..., help="Term to search in command names/descriptions."
+    ),
+    limit: int = typer.Option(25, "--limit", "-l", help="Max results."),
+) -> None:
+    """Fuzzy search across CLI commands via /v1/search/commands."""
+    _ = ctx
+    console.print(f"🔍 Searching CLI commands for: '[cyan]{term}[/cyan]'...")
+    client = CoreApiClient()
+    payload = await client.inspect_search_commands(q=term, limit=limit)
+    if not payload.get("available", False):
+        error = payload.get("error", "unknown error")
+        console.print(f"[yellow]Search unavailable: {error}[/yellow]")
+        return
+    results = payload.get("results") or []
+    if not results:
+        console.print("[yellow]No matching commands found.[/yellow]")
+        return
+    table = Table(title=f"Matching Commands ({len(results)})")
+    table.add_column("Command", style="cyan")
+    table.add_column("Module", style="magenta")
+    table.add_column("Description", style="green")
+    for hit in results:
+        description = (hit.get("description") or "").strip() or "—"
+        if len(description) > 100:
+            description = description[:99] + "…"
+        table.add_row(
+            hit.get("command", "—"),
+            hit.get("module", "—"),
+            description,
+        )
+    console.print(table)

cli/commands/status.py

@@ -0,0 +1,86 @@
+# src/cli/commands/status.py
+"""Status command group.
+
+Golden Path:
+- status drift {guard|symbol|vector|all}
+
+All drift scopes route to /v1/status/drift (ADR-057 D3) plus the local
+`cli.commands.guard.guard_drift_cmd` for the manifest-vs-code guard
+check. No imports from `mind.*` — that was a layer inversion on the old
+status path.
+"""
+
+from __future__ import annotations
+
+import logging
+
+import typer
+from rich.console import Console
+
+from api.cli import CoreApiClient
+from cli.utils import core_command
+
+
+logger = logging.getLogger(__name__)
+console = Console()
+status_app = typer.Typer(
+    help="Single-glance system state and readiness.", no_args_is_help=True
+)
+
+
+def _warn_not_wired(detail: str) -> None:
+    typer.secho(f"STATUS: not fully wired yet ({detail})", fg=typer.colors.YELLOW)
+
+
+@status_app.command("drift")
+@core_command(dangerous=False, requires_context=False)
+# ID: 17ba54ad-6d9e-4392-9512-7b62053575ea
+async def drift_cmd(
+    ctx: typer.Context,
+    scope: str = typer.Argument("all", help="Drift scope: guard|symbol|vector|all"),
+) -> None:
+    """Consolidated drift entry point."""
+    _ = ctx
+    scope_norm = (scope or "all").strip().lower()
+    if scope_norm not in {"guard", "symbol", "vector", "all"}:
+        typer.secho(
+            f"Invalid scope '{scope}'. Use: guard|symbol|vector|all",
+            fg=typer.colors.RED,
+        )
+        raise typer.Exit(code=2)
+
+    client = CoreApiClient()
+
+    # ID: 76621d1c-d1a8-4b47-8210-3c969bc138f1
+    async def run_guard() -> None:
+        console.print("[bold]Drift: guard[/bold]")
+        try:
+            from cli.commands.guard import run_guard_drift
+        except Exception as exc:
+            logger.debug("status drift: cannot import run_guard_drift: %s", exc)
+            _warn_not_wired("guard drift handler not available")
+            return
+        await run_guard_drift()
+
+    # ID: 54d8b8dd-0ea6-4199-bcc3-0b68fb356c79
+    async def run_symbol_or_vector(api_scope: str) -> None:
+        console.print(f"[bold]Drift: {api_scope}[/bold]")
+        payload = await client.status_drift(scope=api_scope)
+        console.print(payload)
+
+    if scope_norm == "guard":
+        await run_guard()
+        return
+    if scope_norm == "symbol":
+        await run_symbol_or_vector("symbols")
+        return
+    if scope_norm == "vector":
+        await run_symbol_or_vector("vectors")
+        return
+
+    # scope == "all"
+    await run_guard()
+    console.print()
+    await run_symbol_or_vector("symbols")
+    console.print()
+    await run_symbol_or_vector("vectors")

cli/commands/submit.py

@@ -0,0 +1,23 @@
+# src/cli/commands/submit.py
+
+"""DEPRECATED: Use 'core-admin proposals integrate' instead."""
+
+from __future__ import annotations
+
+import typer
+
+from cli.utils import deprecated_command
+
+
+submit_app = typer.Typer(
+    help="[DEPRECATED] Use 'proposals' resource.", no_args_is_help=True
+)
+
+
+@submit_app.command("changes")
+# ID: ce382b1a-af48-4e9b-bcd9-ce8938b58d51
+def integrate_command(ctx: typer.Context, message: str = typer.Option(..., "-m")):
+    """DEPRECATED shim for proposals integrate."""
+    deprecated_command("submit changes", "proposals integrate")
+    # Forward to the new command logic if needed, or simply exit.
+    raise typer.Exit(1)

cli/interactive.py

@@ -0,0 +1,177 @@
+# src/cli/interactive.py
+from __future__ import annotations
+
+import sys
+
+from rich.console import Console
+from rich.panel import Panel
+
+from shared.utils.subprocess_utils import run_poetry_command
+
+
+console = Console()
+
+
+def _show_menu(title: str, options: dict[str, str], actions: dict):
+    while True:
+        console.clear()
+        console.print(Panel(f"[bold cyan]{title}[/bold cyan]"))
+        for key, text in options.items():
+            console.print(f"  [{key}] {text}")
+        console.print("\n  [b] Back | [q] Quit")
+        choice = console.input("\nEnter choice: ").lower()
+        if choice == "b":
+            return
+        if choice == "q":
+            sys.exit(0)
+        action = actions.get(choice)
+        if action:
+            try:
+                action()
+            except Exception as e:
+                console.print(f"[red]Error: {e}[/red]")
+            console.input("\nPress Enter to return...")
+
+
+# ID: 827a231b-79dd-42ba-8ae4-2e3857a2f4b2
+def show_development_menu():
+    _show_menu(
+        title="AI Development & Quality",
+        options={
+            "1": "Dev Sync (Fix & Sync Everything)",
+            "2": "Chat with CORE (Intent Translation)",
+            "3": "Run Project Tests",
+            "4": "Interactive Test Generation",
+        },
+        actions={
+            "1": lambda: run_poetry_command(
+                "Syncing...", ["core-admin", "dev", "sync", "--write"]
+            ),
+            "2": lambda: run_poetry_command(
+                "Thinking...", ["core-admin", "dev", "chat", console.input("Goal: ")]
+            ),
+            "3": lambda: run_poetry_command(
+                "Testing...", ["core-admin", "code", "test"]
+            ),
+            "4": lambda: run_poetry_command(
+                "Starting...", ["core-admin", "dev", "test", console.input("File: ")]
+            ),
+        },
+    )
+
+
+# ID: c36a1e25-f2e0-4bf6-b860-1ecdfc6089eb
+def show_governance_menu():
+    _show_menu(
+        title="Constitutional Governance",
+        options={
+            "1": "Validate Constitution (.intent)",
+            "2": "Check Rule Coverage",
+            "3": "List A3 Proposals",
+            "4": "Query the Mind (Semantic Search)",
+        },
+        actions={
+            "1": lambda: run_poetry_command(
+                "Validating...", ["core-admin", "constitution", "validate"]
+            ),
+            "2": lambda: run_poetry_command(
+                "Checking...", ["core-admin", "constitution", "status"]
+            ),
+            "3": lambda: run_poetry_command(
+                "Listing...", ["core-admin", "proposals", "list"]
+            ),
+            "4": lambda: run_poetry_command(
+                "Searching...",
+                ["core-admin", "constitution", "query", console.input("Question: ")],
+            ),
+        },
+    )
+
+
+# ID: 6b97f86f-c37f-4df8-a754-4c1e84c4b575
+def show_system_menu():
+    """Displays the System Health & CI submenu."""
+    _show_menu(
+        title="System Health & CI",
+        options={
+            "1": "Run Full Check (lint, test, audit)",
+            "2": "Run Only Tests",
+            "3": "Format All Code",
+        },
+        actions={
+            "1": lambda: run_poetry_command(
+                "Running system check...", ["core-admin", "check", "system"]
+            ),
+            "2": lambda: run_poetry_command(
+                "Running tests...", ["core-admin", "check", "tests"]
+            ),
+            "3": lambda: run_poetry_command(
+                "Formatting code...", ["core-admin", "fix", "code-style"]
+            ),
+        },
+    )
+
+
+# ID: 74f08345-03bd-4112-a13f-1353113e2c44
+def show_project_lifecycle_menu():
+    """Displays the Project Lifecycle submenu."""
+    _show_menu(
+        title="Project Lifecycle",
+        options={
+            "1": "Create New Governed Application",
+            "2": "Onboard Existing Repository (BYOR)",
+        },
+        actions={
+            "1": lambda: run_poetry_command(
+                "Creating new application...",
+                [
+                    "core-admin",
+                    "manage",
+                    "project",
+                    "new",
+                    console.input("Enter the name for the new application: "),
+                    "--write",
+                ],
+            ),
+            "2": lambda: run_poetry_command(
+                "Onboarding repository...",
+                [
+                    "core-admin",
+                    "manage",
+                    "project",
+                    "onboard",
+                    console.input("Enter the path to the existing repository: "),
+                    "--write",
+                ],
+            ),
+        },
+    )
+
+
+# ID: 30f97ec8-8803-4ef3-91cf-4fb31943e28c
+def launch_interactive_menu():
+    """The main entry point for the interactive TUI menu."""
+    while True:
+        console.clear()
+        console.print(
+            Panel(
+                "[bold green]🏛️ Welcome to the CORE Interactive Shell[/bold green]",
+                subtitle="Select a command group",
+            )
+        )
+        console.print("[bold cyan]1.[/bold cyan] AI Development & Self-Healing")
+        console.print("[bold cyan]2.[/bold cyan] Constitutional Governance")
+        console.print("[bold cyan]3.[/bold cyan] System Health & CI")
+        console.print("[bold cyan]4.[/bold cyan] Project Lifecycle")
+        console.print("\n[bold red]q.[/bold red] Quit")
+        choice = console.input("\nEnter your choice: ")
+        if choice == "1":
+            show_development_menu()
+        elif choice == "2":
+            show_governance_menu()
+        elif choice == "3":
+            show_system_menu()
+        elif choice == "4":
+            show_project_lifecycle_menu()
+        elif choice.lower() == "q":
+            break

cli/logic/__init__.py

@@ -0,0 +1,7 @@
+# src/cli/logic/__init__.py
+"""
+This file marks the 'commands' directory as a Python package,
+allowing command modules to be imported from here.
+"""
+
+from __future__ import annotations