core-runtime 0.1.1__py3-none-any.whl

cli/commands/develop.py

@@ -0,0 +1,127 @@
+# src/cli/commands/develop.py
+"""Unified interface for AI-native development.
+
+Thin client over POST /v1/refactor/autonomous (ADR-057 D2). The A3 loop
+runs server-side; this CLI dispatches the goal, polls the run resource,
+and renders the outcome.
+"""
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+
+import typer
+from rich.console import Console
+from rich.panel import Panel
+
+from api.cli import CoreApiClient
+from cli.utils import core_command
+
+
+logger = logging.getLogger(__name__)
+console = Console()
+develop_app = typer.Typer(
+    help="AI-native development with constitutional governance", no_args_is_help=True
+)
+
+
+@develop_app.command("refactor")
+@core_command(dangerous=True, requires_context=False)
+# ID: 44c3e345-cc9a-4a81-a207-0ea84b69ff37
+async def refactor_command(
+    ctx: typer.Context,
+    goal: str | None = typer.Argument(
+        None,
+        help="File path or high-level refactoring goal (e.g. 'src/utils.py' or 'Improve modularity of UserService').",
+    ),
+    from_file: Path | None = typer.Option(
+        None, "--from-file", "-f", help="Read the goal from a file."
+    ),
+    write: bool = typer.Option(
+        False, "--write", help="Actually apply changes to the codebase."
+    ),
+):
+    """Initiates an autonomous refactoring cycle via /v1/refactor/autonomous.
+
+    The command intelligently formats goals for INTERPRET phase:
+    - If goal looks like a file path: "refactor {path} for better modularity"
+    - If goal is natural language: passes as-is
+    """
+    _ = ctx
+    if not goal and (not from_file):
+        console.print(
+            "[red]❌ You must provide a goal either as an argument or with --from-file.[/red]"
+        )
+        raise typer.Exit(code=1)
+
+    raw_goal = (
+        from_file.read_text(encoding="utf-8").strip() if from_file else goal.strip()
+    )
+    goal_content = _format_refactor_goal(raw_goal)
+    if goal_content != raw_goal:
+        console.print(f"🔍 Formatted goal for INTERPRET phase: {goal_content}")
+
+    console.print(f"🚀 Starting autonomous refactor for: {goal_content}")
+    client = CoreApiClient()
+    initial = await client.refactor_autonomous(goal=goal_content, write=write)
+    run_id = initial.get("run_id")
+    if not run_id:
+        console.print(
+            f"[red]❌ refactor_autonomous failed to dispatch: {initial}[/red]"
+        )
+        raise typer.Exit(code=1)
+
+    console.print(f"[dim]Dispatched run {run_id} — polling…[/dim]")
+    final = await client.poll_refactor_run(run_id)
+
+    result = final.get("result") or {}
+    message = result.get("message") or final.get("error") or "(no message)"
+    if final.get("status") == "completed" and result.get("success"):
+        console.print(f"\n[bold green]✅ Success:[/bold green] {message}")
+        proposals = result.get("proposal_ids") or []
+        if proposals:
+            console.print(
+                f"[cyan]Generated {len(proposals)} proposal(s):[/cyan] "
+                + ", ".join(proposals[:5])
+                + (f" (+{len(proposals) - 5} more)" if len(proposals) > 5 else "")
+            )
+    else:
+        console.print(f"[red]Goal execution failed: {message}[/red]")
+        raise typer.Exit(code=1)
+
+
+def _format_refactor_goal(raw_goal: str) -> str:
+    """Format raw goal into INTERPRET-friendly refactoring goal."""
+    refactor_keywords = [
+        "refactor",
+        "modularity",
+        "split",
+        "extract",
+        "improve",
+        "clarity",
+    ]
+    if any(keyword in raw_goal.lower() for keyword in refactor_keywords):
+        return raw_goal
+    if "/" in raw_goal or raw_goal.endswith(".py"):
+        return f"refactor {raw_goal} for better modularity"
+    return raw_goal
+
+
+@develop_app.command("info")
+# ID: 7964aa47-e138-4519-bdf3-e788b388e426
+def info():
+    """Show information about the autonomous development system."""
+    body = (
+        "[bold cyan]CORE Autonomous Development[/bold cyan]\n\n"
+        "This command group uses the A3 (Planning-Specification-Execution) loop\n"
+        "to perform complex code modifications autonomously via the API.\n\n"
+        'Usage: [yellow]core-admin develop refactor "your goal"[/yellow]\n\n'
+        "[bold]Smart Goal Formatting:[/bold]\n"
+        "• File paths are auto-formatted with refactoring context\n"
+        "• Natural language goals pass through unchanged\n\n"
+        "Examples:\n"
+        "  core-admin develop refactor src/utils.py --write\n"
+        '  core-admin develop refactor "Improve clarity of AuthService" --write'
+    )
+    console.print(Panel.fit(body, border_style="cyan"))

cli/commands/diagnostics.py

@@ -0,0 +1,32 @@
+# src/cli/commands/diagnostics.py
+
+"""
+Diagnostic Command Group (Cleaned).
+
+CONSTITUTIONAL PROMOTION (v2.6):
+- Evacuated find-clusters and command-tree (Redundant aliases).
+- Promoted debug-meta to admin.meta (ConstitutionalPathAnalyzer).
+- Promoted unassigned-symbols to symbols.audit.
+
+This file now only houses legacy Verb-First check shims.
+"""
+
+from __future__ import annotations
+
+import typer
+
+from cli.logic.diagnostics_policy import policy_coverage
+from cli.logic.diagnostics_registry import (
+    check_legacy_tags,
+    cli_registry,
+    manifest_hygiene,
+)
+
+
+app = typer.Typer(help="System integrity checks and constitutional auditing.")
+
+# Register existing commands (These are still being promoted to Resource Neurons)
+app.command("policy-coverage", help="Audits constitution coverage.")(policy_coverage)
+app.command("manifest-hygiene", help="Checks capability manifests.")(manifest_hygiene)
+app.command("cli-registry", help="Validates CLI registry schema.")(cli_registry)
+app.command("legacy-tags", help="Scans for obsolete tags.")(check_legacy_tags)

cli/commands/fix/__init__.py

@@ -0,0 +1,84 @@
+# src/cli/commands/fix/__init__.py
+"""
+Registers the 'fix' command group and its associated self-healing capabilities.
+
+This module acts as a pure registration hub for the CLI.
+Logic and UI helpers have been moved to prevent circular imports
+between the CLI and the Atomic Body layers.
+
+LEGACY ELIMINATION:
+- Removed 'line-lengths' per Roadmap.
+- Removed internal UI helpers to break circular dependencies.
+"""
+
+from __future__ import annotations
+
+import typer
+from rich.console import Console
+
+from shared.context import CoreContext
+from shared.logger import getLogger
+
+
+logger = getLogger(__name__)
+console = Console()
+
+# Configuration mapping for CLI metadata
+COMMAND_CONFIG = {
+    "code-style": {"category": "formatting", "dangerous": False},
+    "headers": {"category": "compliance", "dangerous": True},
+    "clarity": {"category": "refactoring", "dangerous": True},
+    "complexity": {"category": "refactoring", "dangerous": True},
+    "ids": {"category": "metadata", "dangerous": True},
+    "purge-legacy-tags": {"category": "cleanup", "dangerous": True},
+    "policy-ids": {"category": "metadata", "dangerous": True},
+    "tags": {"category": "metadata", "dangerous": True},
+    "knowledge-graph": {"category": "database", "dangerous": False},
+    "duplicate-ids": {"category": "metadata", "dangerous": True},
+    "vector-sync": {"category": "database", "dangerous": True},
+    "atomic-actions": {"category": "compliance", "dangerous": True},
+    "body-ui": {"category": "governance", "dangerous": True},
+    "imports": {"category": "formatting", "dangerous": False},
+}
+
+fix_app = typer.Typer(
+    help="Self-healing tools that write changes to the codebase.",
+    no_args_is_help=True,
+    rich_markup_mode="rich",
+)
+
+
+@fix_app.callback()
+# ID: 4165545f-18b7-4890-b89f-605ae2772b16
+def fix_callback(
+    ctx: typer.Context,
+    verbose: bool = typer.Option(
+        False, "--verbose", "-v", help="Enable verbose output"
+    ),
+    debug: bool = typer.Option(False, "--debug", help="Enable debug output"),
+):
+    """Self-healing tools organized by category."""
+    core_context: CoreContext = ctx.obj
+    if debug:
+        core_context.debug = True
+    if verbose:
+        core_context.verbose = True
+
+
+# LATE IMPORTS: These register themselves on fix_app when imported.
+# This must remain at the bottom to ensure fix_app is defined first.
+import cli.commands.fix.all_commands
+import cli.commands.fix.atomic_actions
+import cli.commands.fix.audit
+import cli.commands.fix.body_ui
+
+# import cli.commands.fix.clarity
+import cli.commands.fix.code_style
+import cli.commands.fix.db_tools
+import cli.commands.fix.fix_ir
+import cli.commands.fix.handler_discovery
+import cli.commands.fix.imports
+import cli.commands.fix.list_commands
+import cli.commands.fix.metadata
+import cli.commands.fix.modularity
+import cli.commands.fix.settings_access

cli/commands/fix/all_commands.py

@@ -0,0 +1,94 @@
+# src/cli/commands/fix/all_commands.py
+"""
+Batch execution command for the 'fix' CLI group.
+
+`core-admin fix all` runs a curated sequence of registered atomic
+actions via POST /v1/fix/run/{fix_id} and POST /v1/fix/ir. The
+sequence preserves the original prerequisite ordering.
+
+Three pre-migration steps (purge-legacy-tags, policy-ids, knowledge-graph)
+have no registered atomic action and were dropped from the sequence —
+they remain available as standalone CLI subcommands. Filed as
+governance debt; future Stage B reopens may restore the bundle.
+"""
+
+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 COMMAND_CONFIG, fix_app
+
+
+logger = logging.getLogger(__name__)
+console = Console()
+
+
+_PLAN: list[tuple[str, str, str | None]] = [
+    # (step name, fix_id for /fix/run, or ir_kind for /fix/ir)
+    ("code-style", "fix.format", None),
+    ("ids", "fix.ids", None),
+    ("knowledge-sync", "sync.db", None),
+    ("vector-sync", "sync.vectors_code", None),
+    ("docstrings", "fix.docstrings", None),
+    ("tags", "fix.capability_tagging", None),
+    ("ir-triage", "", "triage"),
+    ("ir-log", "", "log"),
+]
+
+
+@fix_app.command("all", help="Run a curated sequence of self-healing fixes.")
+@core_command(dangerous=True, confirmation=True)
+# ID: af5b3d93-3b58-45f9-bce6-33a5886d2a3c
+async def run_all_fixes(
+    ctx: typer.Context,
+    skip_dangerous: bool = typer.Option(
+        True, help="Skip potentially dangerous operations that modify code logic."
+    ),
+    write: bool = typer.Option(
+        False, "--write", help="Apply changes. Default is dry-run."
+    ),
+) -> None:
+    """
+    Run a curated set of fix subcommands in a sequence that respects dependencies.
+    """
+    _ = ctx
+    client = CoreApiClient()
+    mode_str = "write" if write else "dry-run"
+
+    for name, fix_id, ir_kind in _PLAN:
+        cfg = COMMAND_CONFIG.get(name, {})
+        is_dangerous = cfg.get("dangerous", False)
+        if skip_dangerous and is_dangerous and write:
+            console.print(f"[yellow]Skipping dangerous command 'fix {name}'.[/yellow]")
+            continue
+        console.print(f"[bold cyan]▶ Running 'fix {name}' ({mode_str})[/bold cyan]")
+
+        if ir_kind is not None:
+            try:
+                result = await client.fix_ir(ir_kind)
+                console.print(f"   -> IR scaffold: {result.get('path', '(unknown)')}")
+            except Exception as exc:
+                console.print(f"   [red]✗ fix {name} failed: {exc}[/red]")
+            continue
+
+        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]")
+            continue
+        final = await client._poll_run(run_id)
+        status = final.get("status")
+        if status != "completed":
+            console.print(
+                f"   [red]✗ {fix_id} failed: {final.get('error') or final}[/red]"
+            )
+            continue
+        console.print(f"   [green]✓ {fix_id} completed.[/green]")
+
+    console.print("[green]✅ 'fix all' sequence completed[/green]")

cli/commands/fix/atomic_actions.py

@@ -0,0 +1,48 @@
+# src/cli/commands/fix/atomic_actions.py
+"""
+Fix atomic actions pattern violations — thin client over
+POST /v1/fix/run/fix.atomic_actions.
+"""
+
+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("atomic-actions", help="Fix atomic actions pattern violations.")
+@core_command(dangerous=True, confirmation=False)
+# ID: d729c8ff-0b0c-4873-85b6-0b8151a4265c
+async def fix_atomic_actions_cmd(
+    ctx: typer.Context,
+    write: bool = typer.Option(False, "--write", help="Apply fixes."),
+) -> None:
+    """
+    Dispatches fix.atomic_actions via POST /v1/fix/run/{fix_id}.
+    """
+    _ = ctx
+    console.print("[cyan]Healing atomic actions...[/cyan]")
+    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(
+            f"[red]fix.atomic_actions failed: {final.get('error') or final}[/red]"
+        )
+        raise typer.Exit(1)
+    console.print("[green]✓ fix.atomic_actions completed.[/green]")

cli/commands/fix/audit.py

@@ -0,0 +1,146 @@
+# src/cli/commands/fix/audit.py
+"""Audit remediation command for the 'fix' CLI group.
+
+Thin client over POST /v1/audit/remediations (ADR-057 D4). The CLI
+dispatches an audit_run_id + mode + write flag and polls the
+audit_remediation_runs lifecycle. All remediation logic runs server-side.
+"""
+
+from __future__ import annotations
+
+import logging
+
+import typer
+from rich.table import Table
+
+from api.cli import CoreApiClient
+from cli.utils import core_command
+
+from . import console, fix_app
+
+
+logger = logging.getLogger(__name__)
+
+
+# The CLI accepts both the long-form RemediationMode value names
+# (safe_only / medium_risk / all_deterministic) and the wire-format names
+# the API expects (safe / medium / all). Long-form names are translated.
+_MODE_TO_WIRE = {
+    "safe": "safe",
+    "medium": "medium",
+    "all": "all",
+    "safe_only": "safe",
+    "medium_risk": "medium",
+    "all_deterministic": "all",
+}
+
+
+@fix_app.command("audit")
+@core_command(dangerous=True, confirmation=True, requires_context=False)
+# ID: 02131c6f-4f7e-4141-a7c6-7f72b7392e9f
+async def fix_audit_command(
+    ctx: typer.Context,
+    audit_run_id: str = typer.Option(
+        ...,
+        "--audit-run-id",
+        help="UUID of the audit_runs row whose findings should be remediated.",
+    ),
+    write: bool = typer.Option(
+        False, "--write", help="Actually apply fixes (default: dry-run)"
+    ),
+    mode: str = typer.Option(
+        "safe",
+        "--mode",
+        help="Risk tolerance: safe | medium | all (long-form: safe_only / medium_risk / all_deterministic).",
+    ),
+) -> None:
+    """Autonomous remediation of audit findings via /v1/audit/remediations.
+
+    Examples:
+        # Dry-run — see what would be fixed
+        core-admin fix audit --audit-run-id <uuid>
+
+        # Apply safe fixes
+        core-admin fix audit --audit-run-id <uuid> --write
+
+        # Apply medium-risk fixes
+        core-admin fix audit --audit-run-id <uuid> --write --mode medium
+    """
+    _ = ctx
+    wire_mode = _MODE_TO_WIRE.get(mode)
+    if wire_mode is None:
+        console.print(
+            f"[red]Invalid mode: {mode}[/red]\n"
+            "Valid modes: safe, medium, all "
+            "(long-form aliases: safe_only, medium_risk, all_deterministic)"
+        )
+        raise typer.Exit(1)
+
+    console.print("\n[bold cyan]🔧 CORE Audit Remediation[/bold cyan]")
+    console.print(f"Audit run: {audit_run_id}")
+    console.print(f"Mode: {wire_mode}")
+    console.print(
+        f"Write: {'YES - Will modify files' if write else 'NO - Dry run only'}"
+    )
+    console.print()
+
+    client = CoreApiClient()
+    initial = await client.audit_remediate(
+        audit_run_id=audit_run_id, mode=wire_mode, write=write
+    )
+    run_id = initial.get("run_id")
+    if not run_id:
+        console.print(f"[red]❌ audit_remediate failed to dispatch: {initial}[/red]")
+        raise typer.Exit(code=1)
+
+    console.print(f"[dim]Dispatched run {run_id} — polling…[/dim]")
+    final = await client.poll_audit_remediation_run(run_id)
+    if final.get("status") != "completed":
+        console.print(
+            f"[red]❌ Remediation failed: {final.get('error') or final}[/red]"
+        )
+        raise typer.Exit(code=1)
+
+    _display_results(final.get("result") or {}, write=write)
+
+
+def _display_results(result: dict, *, write: bool) -> None:
+    """Display remediation results in a Rich table."""
+    console.print("\n[bold]📊 Remediation Summary[/bold]\n")
+    summary_table = Table(show_header=False, box=None)
+    summary_table.add_column("Metric", style="cyan")
+    summary_table.add_column("Value", style="white")
+    summary_table.add_row("Total findings", str(result.get("total_findings", 0)))
+    summary_table.add_row("Fixes attempted", str(result.get("fixes_attempted", 0)))
+    summary_table.add_row(
+        "Fixes succeeded",
+        f"[green]{result.get('fixes_succeeded', 0)}[/green]",
+    )
+    if write:
+        summary_table.add_row("", "")
+        summary_table.add_row("Findings before", str(result.get("findings_before", 0)))
+        summary_table.add_row("Findings after", str(result.get("findings_after", 0)))
+        delta = int(result.get("improvement_delta", 0))
+        delta_color = "green" if delta > 0 else "red"
+        summary_table.add_row(
+            "Improvement",
+            f"[{delta_color}]{delta} fewer violations[/{delta_color}]",
+        )
+    console.print(summary_table)
+
+    if write:
+        if result.get("validation_passed"):
+            console.print("[green]✅ Validation PASSED - Quality improved[/green]")
+        else:
+            console.print("[red]❌ Validation FAILED - No improvement[/red]")
+
+    output_path = result.get("remediation_output_path")
+    if output_path:
+        console.print(f"\n[bold]📝 Evidence:[/bold] {output_path}")
+
+    if not write and result.get("fixes_attempted", 0) > 0:
+        console.print(
+            "\n[bold yellow]💡 Tip:[/bold yellow] Run with [cyan]--write[/cyan] "
+            "to apply these fixes"
+        )
+    console.print()

cli/commands/fix/body_ui.py

@@ -0,0 +1,93 @@
+# src/cli/commands/fix/body_ui.py
+"""
+CLI command: `core-admin fix body-ui`
+
+Thin client over POST /v1/quality/body-ui (read) + POST /v1/fix/run/fix.body_ui
+(write). Dry-run returns the violation list inline; --write dispatches the
+LLM fixer asynchronously and polls.
+"""
+
+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("body-ui", help="Fix Body-layer UI contract violations.")
+@core_command(dangerous=True, confirmation=True)
+# ID: e080af6d-2e0e-4b5d-967b-61c5b7223aaa
+async def fix_body_ui_command(
+    ctx: typer.Context,
+    write: bool = typer.Option(
+        False,
+        "--write/--dry-run",
+        help="Dry-run by default; use --write to apply changes.",
+    ),
+    count: int = typer.Option(
+        None,
+        "--count",
+        "-n",
+        help="Limit the number of files to process (for safety/testing).",
+    ),
+) -> None:
+    """
+    Fix Body-layer UI/env violations (Rich, print/input, os.environ) using the LLM.
+
+    Dry-run path uses POST /v1/quality/body-ui (sync check) and reports the
+    violation count. --write path dispatches POST /v1/fix/run/fix.body_ui
+    (async LLM fixer), polls, and reports the summary.
+    """
+    _ = ctx
+    console.print("\n[bold cyan]🔧 Body UI Contracts Fixer[/bold cyan]\n")
+    client = CoreApiClient()
+
+    if not write:
+        console.print(
+            "[yellow]Running in DRY-RUN mode. Use --write to apply changes.[/yellow]\n"
+        )
+        check = await client.quality_body_ui()
+        if check.get("status") == "ok":
+            console.print("[green]✓ Body contracts compliant.[/green]")
+            return
+        violations = check.get("violations", [])
+        unique_files = len({v.get("file") for v in violations if v.get("file")})
+        console.print("[bold]Summary:[/bold]")
+        console.print(f"  Files with violations : {unique_files}")
+        console.print(f"  Total violations      : {len(violations)}")
+        console.print("  Mode                  : DRY-RUN")
+        console.print("\n[yellow]Use --write to apply these changes.[/yellow]")
+        return
+
+    if count:
+        console.print(f"[dim]Limiting processing to first {count} file(s).[/dim]\n")
+    params: dict[str, object] = {}
+    if count is not None:
+        params["limit"] = count
+    initial = await client.run_fix("fix.body_ui", write=True, params=params)
+    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)
+
+    result_data = (final.get("result") or {}).get("data", {})
+    console.print("[bold]Summary:[/bold]")
+    console.print(f"  Files found     : {result_data.get('files_found', 0)}")
+    console.print(f"  Files processed : {result_data.get('files_processed', 0)}")
+    console.print(f"  Files modified  : {result_data.get('files_modified', 0)}")
+    console.print("  Mode            : WRITE")
+    console.print("\n[green]✓ Body UI contracts successfully applied.[/green]")

cli/commands/fix/code_style.py

@@ -0,0 +1,52 @@
+# src/cli/commands/fix/code_style.py
+"""
+Code style and formatting commands for the 'fix' CLI group.
+
+Provides:
+- fix headers — thin client over POST /v1/fix/run/fix.headers
+"""
+
+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(
+    "headers", help="Ensures all files have constitutionally compliant headers."
+)
+@core_command(dangerous=True, confirmation=True)
+# ID: 0077efbb-9090-42bb-a602-2ff3b7853875
+async def fix_headers_cmd(
+    ctx: typer.Context,
+    write: bool = typer.Option(
+        False, "--write", help="Apply fixes to files with violations."
+    ),
+) -> None:
+    """
+    Dispatches fix.headers via POST /v1/fix/run/{fix_id}.
+    """
+    _ = ctx
+    console.print("[cyan]Checking file headers...[/cyan]")
+    client = CoreApiClient()
+    initial = await client.run_fix("fix.headers", write=write)
+    run_id = initial.get("run_id")
+    if not run_id:
+        console.print(f"[red]fix.headers 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.headers failed: {final.get('error') or final}[/red]")
+        raise typer.Exit(1)
+    console.print("[green]✓ fix.headers completed.[/green]")