core-cli 1.0.0__py3-none-any.whl

core_cli/__init__.py

@@ -0,0 +1,3 @@
+"""core-cli — consumer governance CLI for CORE."""
+
+from __future__ import annotations

core_cli/main.py

@@ -0,0 +1,33 @@
+"""core-cli entry point — consumer governance CLI."""
+
+from __future__ import annotations
+
+import typer
+
+from core_cli.resources.code import app as code_app
+from core_cli.resources.lane import app as lane_app
+from core_cli.resources.project import app as project_app
+from core_cli.resources.proposals import app as proposals_app
+from core_cli.resources.secrets import app as secrets_app
+from core_cli.resources.symbols import app as symbols_app
+from core_cli.resources.vectors import app as vectors_app
+
+
+# ID: 92ffef66-e5d7-48ae-929e-a82f136a9719
+app = typer.Typer(
+    name="core",
+    help="CORE consumer governance CLI — govern your project against CORE constitutional rules.",
+    no_args_is_help=True,
+)
+
+app.add_typer(lane_app, name="lane")
+app.add_typer(proposals_app, name="proposals")
+app.add_typer(secrets_app, name="secrets")
+app.add_typer(code_app, name="code")
+app.add_typer(symbols_app, name="symbols")
+app.add_typer(vectors_app, name="vectors")
+app.add_typer(project_app, name="project")
+
+
+if __name__ == "__main__":
+    app()

core_cli/resources/__init__.py

@@ -0,0 +1,3 @@
+"""Consumer resource command packages."""
+
+from __future__ import annotations

core_cli/resources/code/__init__.py

@@ -0,0 +1,22 @@
+"""Consumer codebase commands — quality, style, and verification over HTTP."""
+
+from __future__ import annotations
+
+from . import (  # noqa: F401
+    actions,
+    audit_duplicates,
+    bridges,
+    check_imports,
+    check_ui,
+    docstrings,
+    fix_atomic,
+    format,
+    integrity,
+    lint,
+    logging,
+    test,
+)
+from .hub import app
+
+
+__all__ = ["app"]

core_cli/resources/code/actions.py

@@ -0,0 +1,54 @@
+# src/cli/resources/code/actions.py
+import logging
+
+from rich.console import Console
+from rich.table import Table
+
+from api.cli import CoreApiClient
+from cli.utils import core_command
+from shared.cli.command_meta import (
+    CommandBehavior,
+    CommandExposure,
+    CommandLayer,
+    command_meta,
+)
+
+from .hub import app
+
+
+logger = logging.getLogger(__name__)
+console = Console()
+
+
+@app.command("actions")
+@command_meta(
+    canonical_name="code.actions",
+    behavior=CommandBehavior.READ,
+    layer=CommandLayer.BODY,
+    exposure=CommandExposure.GOVERNOR_ONLY,
+    summary="List all registered Atomic Actions showing their IDs, categories, impact levels, and descriptions.",
+    dangerous=False,
+)
+@core_command(dangerous=False, requires_context=False)
+# ID: 4f8e13a3-f017-4d0f-a6ef-340f81d05341
+async def list_actions_cmd() -> None:
+    """
+    List all registered Atomic Actions (Body Capabilities).
+    Shows IDs, categories, and impact levels for autonomous building blocks.
+    """
+    client = CoreApiClient()
+    payload = await client.list_actions()
+    actions = payload.get("actions", [])
+    table = Table(title="Registered Atomic Actions", 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)

core_cli/resources/code/audit_duplicates.py

@@ -0,0 +1,37 @@
+# src/core_cli/resources/code/audit_duplicates.py
+from __future__ import annotations
+
+import typer
+from rich.console import Console
+
+from api.cli import CoreApiClient
+from cli.utils import core_command
+
+from .hub import app
+
+
+console = Console()
+
+
+@app.command("audit-duplicates")
+@core_command(dangerous=False, requires_context=False)
+# ID: 2ad098e5-aa8a-4e12-89e4-be20d2e12e03
+async def audit_duplicates_cmd(
+    threshold: float = typer.Option(0.96, help="Similarity threshold (0.0-1.0)."),
+) -> None:
+    """
+    Perform a semantic scan to find duplicate logic across the codebase.
+    Helps enforce the 'dry_by_design' constitutional principle.
+    """
+    client = CoreApiClient()
+    result = await client.inspect.analysis_duplicates(threshold=threshold)
+    if result.get("ok"):
+        console.print(
+            f"[green]✓ Duplicates scan complete (threshold={threshold}).[/green]"
+        )
+        note = result.get("note", "")
+        if note:
+            console.print(f"[dim]{note}[/dim]")
+    else:
+        console.print(f"[red]✗ Duplicates scan failed: {result.get('error')}[/red]")
+        raise typer.Exit(1)

core_cli/resources/code/bridges.py

@@ -0,0 +1,90 @@
+# src/core_cli/resources/code/bridges.py
+"""CLI command: list declared architecture bridge points (issue #617)."""
+
+from __future__ import annotations
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from api.cli import CoreApiClient
+from cli.utils import core_command
+
+from .hub import app
+
+
+console = Console()
+
+
+@app.command("bridges")
+@core_command(dangerous=False, requires_context=False)
+# ID: 5b2e91f3-a4c8-4d7e-b6f0-8c1a9d2e3f04
+async def list_bridges_cmd(
+    consuming: str | None = typer.Option(
+        None,
+        "--consuming",
+        "-c",
+        help="Filter by consuming type (e.g. AuditFinding, Proposal).",
+    ),
+) -> None:
+    """
+    List declared architecture bridge points.
+
+    Each bridge is a constitutionally-declared data-flow crossing where
+    information moves between CORE layers. Use --consuming to find bridges
+    that consume a specific data type.
+
+    Example:
+      core code bridges --consuming AuditFinding
+    """
+    client = CoreApiClient()
+    result = await client.inspect.analysis_bridges(consuming=consuming)
+
+    if not result.get("available"):
+        console.print(f"[red]✗ Bridges unavailable: {result.get('error')}[/red]")
+        raise typer.Exit(1)
+
+    bridges = result.get("bridges", [])
+    if not bridges:
+        if consuming:
+            console.print(
+                f"[yellow]No bridges found consuming type '{consuming}'.[/yellow]"
+            )
+        else:
+            console.print("[yellow]No bridge declarations found.[/yellow]")
+        return
+
+    title = (
+        f"Architecture Bridges (consuming '{consuming}')"
+        if consuming
+        else "Architecture Bridges"
+    )
+    table = Table(title=title, header_style="bold cyan", show_lines=True)
+    table.add_column("ID", style="cyan", no_wrap=True)
+    table.add_column("Bridge Class", style="bold")
+    table.add_column("Layer", style="blue")
+    table.add_column("Source", style="dim")
+    table.add_column("Sink Target", style="green")
+    table.add_column("Attribution", style="magenta")
+    table.add_column("ADRs", style="dim")
+
+    for bridge in bridges:
+        source = bridge.get("source_layer") or (
+            bridge.get("source_context", "")[:40]
+        )
+        attr_mechanism = bridge.get("attribution_mechanism", "")
+        attr_field = bridge.get("attribution_field")
+        attribution = (
+            f"{attr_mechanism} → {attr_field}" if attr_field else attr_mechanism
+        )
+        table.add_row(
+            bridge.get("id", ""),
+            bridge.get("bridge_class", ""),
+            bridge.get("bridge_layer", ""),
+            source,
+            bridge.get("sink_target", ""),
+            attribution,
+            ", ".join(bridge.get("authority_adrs", [])),
+        )
+
+    console.print(table)

core_cli/resources/code/check_imports.py

@@ -0,0 +1,75 @@
+# src/cli/resources/code/check_imports.py
+"""
+Import integrity check command.
+
+Routes through POST /v1/quality/imports for constitutional compliance.
+"""
+
+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 .hub import app
+
+
+logger = logging.getLogger(__name__)
+console = Console()
+
+
+@app.command("check-imports")
+@core_command(dangerous=False, requires_context=False)
+# ID: 53db749b-a5cf-44e4-8e7f-47e6499aec0b
+async def check_imports_cmd(ctx: typer.Context) -> None:
+    """
+    Verify all import statements resolve to existing modules.
+
+    Checks for:
+    - F821: References to undefined names (moved/deleted modules)
+    - F401: Stale imports left after refactoring
+
+    Enforces:
+    - code.imports.must_resolve
+    - code.imports.no_stale_namespace
+    """
+    console.rule("[bold cyan]Import Integrity Check[/bold cyan]")
+    console.print("[dim]Scanning src/ for unresolvable imports (F821, F401)...[/dim]\n")
+    client = CoreApiClient()
+    result = await client.quality_imports()
+    if result.get("status") == "ok":
+        console.print("[bold green]✅ All imports resolve cleanly.[/bold green]")
+        return
+    violations = result.get("violations", [])
+    violation_count = len(violations)
+    console.print(
+        f"[bold red]❌ {violation_count} unresolvable import(s) found.[/bold red]\n"
+    )
+    if violations:
+        table = Table(
+            title="Import Violations", show_header=True, header_style="bold red"
+        )
+        table.add_column("File", style="cyan", overflow="fold")
+        table.add_column("Line", style="yellow", justify="right", width=6)
+        table.add_column("Rule", style="magenta", width=6)
+        table.add_column("Message", style="white", overflow="fold")
+        for v in violations:
+            table.add_row(
+                v.get("file", ""),
+                str(v.get("line", "")),
+                v.get("rule", ""),
+                v.get("message", ""),
+            )
+        console.print(table)
+    console.print(
+        "\n[dim]Fix: Update stale import paths or remove unused imports.[/dim]"
+    )
+    console.print(
+        "[dim]Rule: code.imports.must_resolve (.intent/rules/code/imports.json)[/dim]"
+    )
+    raise typer.Exit(code=1)

core_cli/resources/code/check_ui.py

@@ -0,0 +1,61 @@
+# src/core_cli/resources/code/check_ui.py
+"""
+Code UI Compliance Action.
+Ensures Body-layer modules are HEADLESS (no print, rich, or direct os.environ).
+"""
+
+from __future__ import annotations
+
+import typer
+from rich.console import Console
+
+from api.cli import CoreApiClient
+from cli.utils import core_command
+
+from .hub import app
+
+
+console = Console()
+
+
+@app.command("check-ui")
+@core_command(dangerous=True, requires_context=False)
+# ID: 662d6bed-c6fc-4120-ae34-d9063f703994
+async def check_ui_cmd(
+    write: bool = typer.Option(
+        False, "--write", help="Use LLM to autonomously fix UI contract violations."
+    ),
+) -> None:
+    """
+    Check and repair Body-layer UI contract violations.
+
+    Validates that logic in features/ and services/ does not use:
+    - print() or input()
+    - rich.console or formatting
+    - os.environ (must use shared.config.settings)
+
+    If --write is used, CORE invokes an AI specialist to refactor the
+    violating modules into a headless state.
+    """
+    client = CoreApiClient()
+    if not write:
+        console.print("[bold cyan]🔍 Checking Body UI Contracts...[/bold cyan]")
+        result = await client.quality_body_ui()
+        if result.get("status") == "ok":
+            console.print("[green]✓ Body UI contracts clean.[/green]")
+            return
+        violations = result.get("violations", [])
+        console.print(f"\n[red]❌ Found {len(violations)} contract violations.[/red]")
+        console.print("[yellow]💡 Run with '--write' to auto-fix via LLM.[/yellow]")
+        raise typer.Exit(1)
+    console.print("[bold cyan]🔧 Refactoring UI leaks out of Body layer...[/bold cyan]")
+    initial = await client.run_fix("fix.body_ui", write=True)
+    run_id = initial.get("run_id")
+    if not run_id:
+        console.print(f"[red]fix.body_ui 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.body_ui failed: {final.get('error') or final}[/red]")
+        raise typer.Exit(1)
+    console.print("[green]✓ fix.body_ui completed.[/green]")

core_cli/resources/code/docstrings.py

@@ -0,0 +1,44 @@
+# src/core_cli/resources/code/docstrings.py
+from __future__ import annotations
+
+import typer
+from rich.console import Console
+
+from api.cli import CoreApiClient
+from cli.utils import core_command
+
+from .hub import app
+
+
+console = Console()
+
+
+@app.command("docstrings")
+@core_command(dangerous=True, requires_context=False)
+# ID: 9f0d0239-d29d-4dff-8c32-3fdecaa809e9
+async def fix_docstrings_command(
+    write: bool = typer.Option(False, "--write", help="Apply changes."),
+    limit: int = typer.Option(3, "--limit", help="Symbols to process."),
+    file: str | None = typer.Option(
+        None, "--file", help="Target a single file (repo-relative)."
+    ),
+) -> None:
+    """Autonomously generate and inject missing docstrings using AI."""
+    client = CoreApiClient()
+    initial = await client.run_fix(
+        "fix.docstrings",
+        target_files=[file] if file else None,
+        write=write,
+        params={"limit": limit},
+    )
+    run_id = initial.get("run_id")
+    if not run_id:
+        console.print(f"[red]fix.docstrings 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.docstrings failed: {final.get('error') or final}[/red]"
+        )
+        raise typer.Exit(1)
+    console.print("[green]✓ fix.docstrings completed.[/green]")

core_cli/resources/code/fix_atomic.py

@@ -0,0 +1,57 @@
+# src/cli/resources/code/fix_atomic.py
+import logging
+
+import typer
+from rich.console import Console
+
+from api.cli import CoreApiClient
+from cli.utils import core_command
+from shared.cli.command_meta import (
+    CommandBehavior,
+    CommandExposure,
+    CommandLayer,
+    command_meta,
+)
+
+from .hub import app
+
+
+logger = logging.getLogger(__name__)
+console = Console()
+
+
+@app.command("fix-atomic")
+@command_meta(
+    canonical_name="code.fix-atomic",
+    behavior=CommandBehavior.MUTATE,
+    layer=CommandLayer.BODY,
+    exposure=CommandExposure.GOVERNOR_ONLY,
+    summary="Heal violations in the Atomic Action pattern.",
+    dangerous=True,
+)
+@core_command(dangerous=True, requires_context=False)
+# ID: 1a0797b9-e800-4783-9305-158b5f9247af
+async def fix_atomic_cmd(
+    ctx: typer.Context,
+    write: bool = typer.Option(
+        False, "--write", help="Apply fixes to atomic action patterns."
+    ),
+) -> None:
+    """
+    Heal violations in the Atomic Action pattern.
+    Ensures @atomic_action decorators and ActionResult returns are present.
+    """
+    client = CoreApiClient()
+    initial = await client.run_fix("fix.atomic_actions", write=write)
+    run_id = initial.get("run_id")
+    if not run_id:
+        console.print(f"[red]fix.atomic_actions failed to dispatch: {initial}[/red]")
+        raise typer.Exit(1)
+    final = await client._poll_run(run_id)
+    if final.get("status") == "completed":
+        console.print("[green]✓ fix.atomic_actions completed.[/green]")
+        return
+    console.print(
+        f"[red]fix.atomic_actions failed: {final.get('error') or final}[/red]"
+    )
+    raise typer.Exit(1)

core_cli/resources/code/format.py

@@ -0,0 +1,62 @@
+# src/core_cli/resources/code/format.py
+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 .hub import app
+
+
+logger = logging.getLogger(__name__)
+console = Console()
+
+
+async def _run_and_poll(fix_id: str, *, write: bool) -> None:
+    client = CoreApiClient()
+    initial = await client.run_fix(fix_id, write=write)
+    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)
+
+
+@app.command("format")
+@core_command(dangerous=True, requires_context=False)
+# ID: 3dfcec28-34fd-44d4-9aec-bcbf29eb6d76
+async def format_command(
+    write: bool = typer.Option(
+        False, "--write", help="Apply formatting changes to disk."
+    ),
+) -> None:
+    """
+    Format code using Black and Ruff.
+
+    Defaults to dry-run mode. Use --write to apply changes.
+    """
+    mode = "Applying" if write else "Checking"
+    console.print(f"[bold cyan]✨ {mode} code formatting (Black + Ruff)...[/bold cyan]")
+    await _run_and_poll("fix.format", write=write)
+    if not write:
+        console.print("[yellow]💡 Run with --write to apply these changes.[/yellow]")
+
+
+@app.command("format-imports")
+@core_command(dangerous=True, requires_context=False)
+# ID: 582d69b9-6f50-411a-a950-37e66ce2e07b
+async def format_imports_cmd(
+    write: bool = typer.Option(False, "--write", help="Apply import sorting to disk."),
+) -> None:
+    """
+    Sort and group Python imports according to PEP 8 / Constitutional standards.
+    Uses Ruff's import sorter (I) rules.
+    """
+    await _run_and_poll("fix.imports", write=write)

core_cli/resources/code/hub.py

@@ -0,0 +1,10 @@
+# src/cli/resources/code/hub.py
+import typer
+
+
+# This is the "Stable Hub" that everyone can import without circular risk
+app = typer.Typer(
+    name="code",
+    help="Codebase quality, style, and verification operations.",
+    no_args_is_help=True,
+)

core_cli/resources/code/integrity.py

@@ -0,0 +1,75 @@
+# src/cli/resources/code/integrity.py
+"""
+Integrity CLI Commands - Phase 2 Hardening.
+Allows the operator to baseline and verify the codebase state.
+
+Thin clients over POST /v1/integrity/{baseline,verify}. All execution
+moves server-side; this module only dispatches and renders.
+"""
+
+from __future__ import annotations
+
+import typer
+from rich.console import Console
+
+from api.cli import CoreApiClient
+from cli.utils import core_command
+
+from .hub import app
+
+
+console = Console()
+
+
+@app.command("baseline")
+@core_command(dangerous=False)
+# ID: d76fd565-17ef-4f35-9138-9530efc28324
+async def code_baseline_cmd(
+    ctx: typer.Context,
+    label: str = typer.Option(
+        "default", "--label", "-l", help="Label for this baseline."
+    ),
+) -> None:
+    """
+    Create a secure checksum baseline of the current 'src/' directory.
+    Run this before starting autonomous tasks.
+    """
+    _ = ctx
+    client = CoreApiClient()
+    console.print(f"[bold cyan]Creating integrity baseline: {label}...[/bold cyan]")
+    result = await client.baseline(label=label)
+    path = result.get("path")
+    files_hashed = result.get("files_hashed", 0)
+    console.print(
+        f"[bold green]Baseline stored at: {path} ({files_hashed} files)[/bold green]"
+    )
+
+
+@app.command("verify")
+@core_command(dangerous=False)
+# ID: 56975e9b-9040-4c0e-bdc4-76b7c68c5abd
+async def code_verify_cmd(
+    ctx: typer.Context,
+    label: str = typer.Option(
+        "default", "--label", "-l", help="Baseline label to verify against."
+    ),
+) -> None:
+    """
+    Verify the current codebase against a previously created baseline.
+    Detects any unauthorized MODIFICATIONS, DELETIONS, or NEW files.
+    """
+    _ = ctx
+    client = CoreApiClient()
+    console.print(
+        f"[bold cyan]Verifying code integrity against baseline: {label}...[/bold cyan]"
+    )
+    result = await client.verify(label=label)
+    if result.get("ok"):
+        console.print(
+            "[bold green]Integrity verified: no unauthorized changes detected.[/bold green]"
+        )
+    else:
+        console.print("[bold red]Integrity violation found.[/bold red]")
+        for error in result.get("errors", []):
+            console.print(f"  [yellow]-[/yellow] {error}")
+        raise typer.Exit(code=1)

core_cli/resources/code/lint.py

@@ -0,0 +1,37 @@
+# src/cli/resources/code/lint.py
+import typer
+from rich.console import Console
+
+from api.cli import CoreApiClient
+from cli.utils import core_command
+
+from .hub import app
+
+
+console = Console()
+
+
+@app.command("lint")
+@core_command(dangerous=False, requires_context=False)
+# ID: 044f8edf-3262-4e8b-b394-fd76bdd74136
+async def lint_command() -> None:
+    """Check code quality using Black and Ruff (Read-Only)."""
+    console.print("[bold cyan]🔎 Linting codebase...[/bold cyan]")
+    client = CoreApiClient()
+    result = await client.lint()
+
+    if result.get("error"):
+        console.print(f"[red]Lint failed: {result['error']}[/red]")
+        raise typer.Exit(1)
+
+    for tool_name, tool_result in result.get("tools", {}).items():
+        rc = tool_result["returncode"]
+        marker = "[green]✓[/green]" if rc == 0 else "[red]✗[/red]"
+        console.print(f"{marker} {tool_name} (returncode={rc})")
+        if tool_result.get("stdout"):
+            console.print(tool_result["stdout"], highlight=False, end="")
+        if tool_result.get("stderr"):
+            console.print(tool_result["stderr"], highlight=False, end="")
+
+    if not result.get("ok"):
+        raise typer.Exit(1)