core-runtime 0.1.1__py3-none-any.whl

cli/resources/code/check_ui.py

@@ -0,0 +1,62 @@
+# src/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(
+    ctx: typer.Context,
+    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]")

cli/resources/code/clarity.py

@@ -0,0 +1,51 @@
+# src/cli/resources/code/clarity.py
+
+"""
+Code Clarity Resource Action.
+Refactors Python code for improved readability using the V2.3 Adaptive Loop.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+import typer
+
+from cli.utils import core_command
+
+from .hub import app
+
+
+if TYPE_CHECKING:
+    from shared.context import CoreContext
+
+
+@app.command("clarity")
+@core_command(dangerous=True, requires_context=True, confirmation=True)
+# ID: fc72b260-ebc2-4ffc-9194-5e3e192f2a1f
+async def clarity_cmd(
+    ctx: typer.Context,
+    file_path: Path = typer.Argument(
+        ...,
+        help="Path to the Python file to refactor.",
+        exists=True,
+        dir_okay=False,
+        resolve_path=True,
+    ),
+    write: bool = typer.Option(
+        False, "--write", help="Actually apply the refactoring to the file."
+    ),
+) -> None:
+    """
+    Refactor a file for clarity using the V2.3 Adaptive Loop.
+
+    This command uses a Cognitive Workflow (Analyze -> Strategize -> Refactor -> Evaluate).
+    It will only apply changes if the Evaluator proves the code is more readable.
+    """
+    from will.self_healing.clarity_service import remediate_clarity
+
+    core_context: CoreContext = ctx.obj
+
+    # Execute the V2 Cognitive Workflow (Will Layer)
+    await remediate_clarity(context=core_context, file_path=file_path, write=write)

cli/resources/code/complexity.py

@@ -0,0 +1,55 @@
+# src/cli/resources/code/complexity.py
+
+"""
+Code Complexity Resource Action.
+Refactors complex code for better separation of concerns using V2.3 Adaptive Loop.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+import typer
+
+from cli.utils import core_command
+
+from .hub import app
+
+
+if TYPE_CHECKING:
+    from shared.context import CoreContext
+
+
+@app.command("complexity")
+@core_command(dangerous=True, requires_context=True, confirmation=True)
+# ID: 8608b515-e269-4f14-aefe-a8d0904fbcc2
+async def complexity_cmd(
+    ctx: typer.Context,
+    file_path: Path = typer.Argument(
+        ...,
+        help="Path to the file to refactor for complexity.",
+        exists=True,
+        dir_okay=False,
+        resolve_path=True,
+    ),
+    write: bool = typer.Option(
+        False, "--write", help="Actually apply the refactoring to the file."
+    ),
+) -> None:
+    """
+    Identify and refactor complexity outliers using the V2.3 Adaptive Orchestrator.
+
+    Targets high cyclomatic complexity and 'God Methods' to improve modularity.
+    """
+    # CONSTITUTIONAL FIX: V2.3 Roadmap-Compliant complexity remediation logic
+    from will.self_healing.complexity_service import remediate_complexity
+
+    core_context: CoreContext = ctx.obj
+
+    # This uses the high-resilience loop similar to 'code clarity'
+    await remediate_complexity(
+        context=core_context,
+        file_path=file_path,
+        write=write,
+    )

cli/resources/code/docstrings.py

@@ -0,0 +1,51 @@
+# src/cli/resources/code/docstrings.py
+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, CommandLayer, command_meta
+
+from .hub import app
+
+
+console = Console()
+
+
+@app.command("docstrings")
+@command_meta(
+    canonical_name="code.docstrings",
+    behavior=CommandBehavior.MUTATE,
+    layer=CommandLayer.WILL,
+    summary="Heal missing docstrings using constitutional reasoning.",
+    dangerous=True,
+)
+@core_command(dangerous=True, requires_context=False)
+# ID: 9f0d0239-d29d-4dff-8c32-3fdecaa809e9
+async def fix_docstrings_command(
+    ctx: typer.Context,
+    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]")

cli/resources/code/fix_atomic.py

@@ -0,0 +1,51 @@
+# 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, 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,
+    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)

cli/resources/code/format.py

@@ -0,0 +1,62 @@
+# src/cli/resources/code/format.py
+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(
+    ctx: typer.Context,
+    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(
+    ctx: typer.Context,
+    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)

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,
+)

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)

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)

cli/resources/code/logging.py

@@ -0,0 +1,49 @@
+# src/cli/resources/code/logging.py
+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, CommandLayer, command_meta
+
+from .hub import app
+
+
+console = Console()
+
+
+@app.command("logging")
+@command_meta(
+    canonical_name="code.logging",
+    behavior=CommandBehavior.MUTATE,
+    layer=CommandLayer.BODY,
+    summary="Standardize logging across the codebase.",
+    dangerous=True,
+)
+@core_command(dangerous=True, requires_context=False)
+# ID: 5076493c-79a8-4f92-8c15-ddfd695d4275
+async def fix_logging_command(
+    ctx: typer.Context,
+    write: bool = typer.Option(
+        False, "--write", help="Convert print() to logger calls."
+    ),
+) -> None:
+    """
+    Standardize logging across the codebase.
+
+    Replaces print() statements and malformed f-strings in loggers with
+    constitutional standard logging (LOG-001/LOG-003).
+    """
+    mode = "Applying" if write else "Analyzing"
+    console.print(f"[bold cyan]🪵  {mode} Logging Standards...[/bold cyan]")
+    client = CoreApiClient()
+    initial = await client.run_fix("fix.logging", write=write)
+    run_id = initial.get("run_id")
+    if not run_id:
+        console.print(f"[red]fix.logging 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.logging failed: {final.get('error') or final}[/red]")
+        raise typer.Exit(1)
+    console.print("[green]✓ fix.logging completed.[/green]")

cli/resources/code/refactor.py

@@ -0,0 +1,32 @@
+# src/cli/resources/code/refactor.py
+
+import typer
+
+from cli.utils import core_command
+from shared.context import CoreContext
+
+from .hub import app
+
+
+@app.command("refactor-settings")
+@core_command(dangerous=True, requires_context=True, confirmation=True)
+# ID: 47d02d56-dc5f-4a28-82e5-ec82d067caa0
+async def refactor_settings_cmd(
+    ctx: typer.Context,
+    write: bool = typer.Option(False, "--write", help="Apply DI refactoring."),
+    layers: str = typer.Option("mind,will", help="Comma-separated layers to process."),
+):
+    """
+    Automated refactoring of settings imports to Dependency Injection.
+    Moves layers toward using CoreContext instead of global settings.
+    """
+    from body.maintenance.refactor_settings_access import refactor_settings_access
+
+    core_context: CoreContext = ctx.obj
+    layer_list = [layer.strip() for layer in layers.split(",")]
+
+    await refactor_settings_access(
+        repo_path=core_context.git_service.repo_path,
+        layers=layer_list,
+        dry_run=not write,
+    )

cli/resources/code/test.py

@@ -0,0 +1,30 @@
+# src/cli/resources/code/test.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("test")
+@core_command(dangerous=False, requires_context=False)
+# ID: b89ff2a7-0bf3-47cf-90ba-66a3801630c3
+async def test_command(ctx: typer.Context) -> None:
+    """Run the project test suite via pytest."""
+    console.print("[bold cyan]🧪 Running test suite...[/bold cyan]")
+    client = CoreApiClient()
+    initial = await client.quality_tests()
+    run_id = initial.get("run_id")
+    if not run_id:
+        console.print(f"[red]quality.tests 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]quality.tests failed: {final.get('error') or final}[/red]")
+        raise typer.Exit(1)
+    console.print("[green]✓ tests completed.[/green]")

cli/resources/coherence/__init__.py

@@ -0,0 +1,13 @@
+# src/cli/resources/coherence/__init__.py
+"""Constitutional Coherence Checker resource group (ADR-067 + ADR-073)."""
+
+from __future__ import annotations
+
+from . import check, repair_counts, report, supersede, triage
+from .hub import app
+from .seed import seed_app
+
+
+app.add_typer(seed_app, name="seed")
+
+__all__ = ["app"]