invar-tools 1.3.0__py3-none-any.whl → 1.3.2__py3-none-any.whl

invar/shell/claude_hooks.py

@@ -0,0 +1,387 @@
+"""
+Claude Code hooks management for Invar.
+
+DX-57: Implements hook installation, update, and management.
+Shell module: handles file I/O for hooks.
+"""
+
+from __future__ import annotations
+
+import re
+from datetime import datetime
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from jinja2 import Environment, FileSystemLoader
+from returns.result import Failure, Result, Success
+
+if TYPE_CHECKING:
+    from rich.console import Console
+
+# Protocol version for hook version tracking
+PROTOCOL_VERSION = "5.0"
+
+# Hook types supported
+HOOK_TYPES = ["PreToolUse", "PostToolUse", "UserPromptSubmit", "Stop"]
+
+# Path constants
+HOOKS_SUBDIR = ".claude/hooks"
+DISABLED_MARKER = ".invar_disabled"
+
+
+def get_templates_path() -> Path:
+    """Get the path to hook templates."""
+    return Path(__file__).parent.parent / "templates" / "hooks"
+
+
+def get_invar_md_content(project_path: Path) -> str:
+    """Read INVAR.md content for embedding in UserPromptSubmit hook."""
+    invar_md = project_path / "INVAR.md"
+    if invar_md.exists():
+        return invar_md.read_text()
+    # Fallback to template if INVAR.md not yet created
+    template_path = Path(__file__).parent.parent / "templates" / "protocol" / "INVAR.md"
+    if template_path.exists():
+        return template_path.read_text()
+    return "# INVAR.md not found"
+
+
+def detect_syntax(project_path: Path) -> str:
+    """Detect syntax mode from .mcp.json presence."""
+    mcp_json = project_path / ".mcp.json"
+    if mcp_json.exists():
+        try:
+            content = mcp_json.read_text()
+            if '"invar"' in content:
+                return "mcp"
+        except OSError:
+            pass
+    return "cli"
+
+
+# @shell_complexity: Template rendering with syntax detection
+def generate_hook_content(
+    hook_type: str,
+    project_path: Path,
+) -> Result[str, str]:
+    """Generate hook content from template."""
+    templates_path = get_templates_path()
+    template_file = f"{hook_type}.sh.jinja"
+
+    if not (templates_path / template_file).exists():
+        return Failure(f"Template not found: {template_file}")
+
+    try:
+        env = Environment(
+            loader=FileSystemLoader(str(templates_path)),
+            keep_trailing_newline=True,
+        )
+        template = env.get_template(template_file)
+
+        # Determine guard command based on syntax
+        syntax = detect_syntax(project_path)
+        guard_cmd = "invar_guard" if syntax == "mcp" else "invar guard"
+
+        # Build context for template
+        context = {
+            "protocol_version": PROTOCOL_VERSION,
+            "generated_date": datetime.now().strftime("%Y-%m-%d"),
+            "guard_cmd": guard_cmd,
+        }
+
+        # For UserPromptSubmit, add the full INVAR.md content
+        if hook_type == "UserPromptSubmit":
+            context["invar_protocol"] = get_invar_md_content(project_path)
+
+        content = template.render(**context)
+        return Success(content)
+    except Exception as e:
+        return Failure(f"Failed to generate {hook_type} hook: {e}")
+
+
+# @shell_complexity: Hook installation with user hook merging
+def install_claude_hooks(
+    project_path: Path,
+    console: Console,
+) -> Result[list[str], str]:
+    """
+    Install Claude Code hooks for Invar.
+
+    Creates:
+    - .claude/hooks/invar.{HookType}.sh - Invar hook scripts
+    - .claude/hooks/{HookType}.sh - Wrapper that sources Invar hook
+
+    Preserves existing user hooks by creating wrapper that runs both.
+    """
+    hooks_dir = project_path / HOOKS_SUBDIR
+    hooks_dir.mkdir(parents=True, exist_ok=True)
+
+    installed: list[str] = []
+    failed: list[str] = []
+
+    console.print("\n[bold]Installing Claude Code hooks (DX-57)...[/bold]")
+    console.print("  Hooks will:")
+    console.print("    ✓ Block pytest/crosshair → redirect to invar_guard")
+    console.print("    ✓ Remind to verify after code changes")
+    console.print("    ✓ Refresh protocol in long conversations (~1,800 tokens)")
+    console.print("")
+
+    for hook_type in HOOK_TYPES:
+        result = generate_hook_content(hook_type, project_path)
+        if isinstance(result, Failure):
+            console.print(f"  [red]Failed:[/red] {result.failure()}")
+            failed.append(hook_type)
+            continue
+
+        content = result.unwrap()
+        invar_hook = hooks_dir / f"invar.{hook_type}.sh"
+        wrapper_hook = hooks_dir / f"{hook_type}.sh"
+
+        # Write Invar hook
+        invar_hook.write_text(content)
+        invar_hook.chmod(0o755)
+
+        # Handle wrapper hook
+        if wrapper_hook.exists():
+            existing_content = wrapper_hook.read_text()
+            if f"invar.{hook_type}.sh" in existing_content:
+                # Already has Invar reference, just update invar hook
+                console.print(f"  [cyan]Updated[/cyan] invar.{hook_type}.sh")
+            else:
+                # User hook exists, create backup and merge
+                backup = hooks_dir / f"{hook_type}.sh.user_backup"
+                if not backup.exists():
+                    backup.write_text(existing_content)
+                    console.print(f"  [dim]Backed up user {hook_type}.sh[/dim]")
+
+                # Create merged wrapper
+                merged = f'''#!/bin/bash
+# Merged hook: User + Invar (DX-57)
+# User hooks run first (higher priority)
+
+HOOK_DIR="$(dirname "$0")"
+
+# Run user hook first
+if [[ -f "$HOOK_DIR/{hook_type}.sh.user_backup" ]]; then
+  source "$HOOK_DIR/{hook_type}.sh.user_backup" "$@"
+  USER_EXIT=$?
+  [[ $USER_EXIT -ne 0 ]] && exit $USER_EXIT
+fi
+
+# Run Invar hook
+if [[ -f "$HOOK_DIR/invar.{hook_type}.sh" ]]; then
+  source "$HOOK_DIR/invar.{hook_type}.sh" "$@"
+fi
+'''
+                wrapper_hook.write_text(merged)
+                wrapper_hook.chmod(0o755)
+                console.print(f"  [green]Merged[/green] {hook_type}.sh (user hook preserved)")
+        else:
+            # No user hook, create simple wrapper
+            wrapper = f'''#!/bin/bash
+# Invar hook wrapper (DX-57)
+source "$(dirname "$0")/invar.{hook_type}.sh" "$@"
+'''
+            wrapper_hook.write_text(wrapper)
+            wrapper_hook.chmod(0o755)
+            console.print(f"  [green]Created[/green] {hook_type}.sh")
+
+        installed.append(hook_type)
+
+    if installed:
+        console.print("\n  [bold green]✓ Claude Code hooks installed[/bold green]")
+        console.print("  [dim]Auto-escape: pytest --pdb, pytest --cov, vendor/[/dim]")
+        console.print("  [dim]Manual escape: INVAR_ALLOW_PYTEST=1[/dim]")
+
+    if failed:
+        return Failure(f"Failed to install hooks: {', '.join(failed)}")
+
+    return Success(installed)
+
+
+# @shell_complexity: Hook sync with version detection
+def sync_claude_hooks(
+    project_path: Path,
+    console: Console,
+) -> Result[list[str], str]:
+    """
+    Update Claude Code hooks with current INVAR.md content.
+
+    Called during `invar init` to ensure hooks stay in sync with protocol.
+    Only updates if Invar hooks are already installed.
+    """
+    hooks_dir = project_path / HOOKS_SUBDIR
+
+    # Check if Invar hooks are installed
+    check_hook = hooks_dir / "invar.UserPromptSubmit.sh"
+    if not check_hook.exists():
+        return Success([])  # No hooks installed, nothing to sync
+
+    # Check version in existing hook
+    try:
+        existing_content = check_hook.read_text()
+        # Extract version from header comment
+        version_match = re.search(r"Protocol: v([\d.]+)", existing_content)
+        old_version = version_match.group(1) if version_match else "unknown"
+
+        if old_version != PROTOCOL_VERSION:
+            console.print(f"[cyan]Updating Claude hooks: v{old_version} → v{PROTOCOL_VERSION}[/cyan]")
+        else:
+            # Still update to refresh INVAR.md content
+            console.print("[dim]Refreshing Claude hooks...[/dim]")
+    except OSError:
+        pass
+
+    updated: list[str] = []
+    failed: list[str] = []
+
+    for hook_type in HOOK_TYPES:
+        result = generate_hook_content(hook_type, project_path)
+        if isinstance(result, Failure):
+            console.print(f"  [yellow]Warning:[/yellow] Failed to generate {hook_type}: {result.failure()}")
+            failed.append(hook_type)
+            continue
+
+        content = result.unwrap()
+        invar_hook = hooks_dir / f"invar.{hook_type}.sh"
+
+        if invar_hook.exists():
+            invar_hook.write_text(content)
+            invar_hook.chmod(0o755)
+            updated.append(hook_type)
+
+    if updated:
+        console.print(f"[green]✓[/green] Claude hooks synced ({len(updated)} files)")
+    if failed:
+        console.print(f"[yellow]⚠[/yellow] {len(failed)} hook(s) failed to sync")
+
+    return Success(updated)
+
+
+# @shell_complexity: Hook removal with backup restoration
+def remove_claude_hooks(
+    project_path: Path,
+    console: Console,
+) -> Result[None, str]:
+    """
+    Remove Invar Claude Code hooks.
+
+    Restores user hooks from backup if available.
+    """
+    hooks_dir = project_path / HOOKS_SUBDIR
+
+    if not hooks_dir.exists():
+        console.print("[yellow]No hooks directory found[/yellow]")
+        return Success(None)
+
+    console.print("[bold]Removing Invar Claude Code hooks...[/bold]")
+
+    for hook_type in HOOK_TYPES:
+        invar_hook = hooks_dir / f"invar.{hook_type}.sh"
+        wrapper_hook = hooks_dir / f"{hook_type}.sh"
+        backup_hook = hooks_dir / f"{hook_type}.sh.user_backup"
+
+        # Remove Invar hook
+        if invar_hook.exists():
+            invar_hook.unlink()
+            console.print(f"  [red]Removed[/red] invar.{hook_type}.sh")
+
+        # Restore user backup if exists
+        if backup_hook.exists():
+            if wrapper_hook.exists():
+                wrapper_hook.unlink()
+            backup_hook.rename(wrapper_hook)
+            console.print(f"  [green]Restored[/green] {hook_type}.sh (from backup)")
+        elif wrapper_hook.exists():
+            # Check if it's just an Invar wrapper
+            content = wrapper_hook.read_text()
+            if f"invar.{hook_type}.sh" in content and "user_backup" not in content:
+                wrapper_hook.unlink()
+                console.print(f"  [red]Removed[/red] {hook_type}.sh (Invar wrapper)")
+
+    console.print("[bold green]✓ Invar hooks removed[/bold green]")
+    return Success(None)
+
+
+def disable_claude_hooks(
+    project_path: Path,
+    console: Console,
+) -> Result[None, str]:
+    """Temporarily disable Invar hooks."""
+    hooks_dir = project_path / HOOKS_SUBDIR
+
+    if not hooks_dir.exists():
+        return Failure("No hooks directory found")
+
+    disabled_marker = hooks_dir / DISABLED_MARKER
+    disabled_marker.touch()
+
+    console.print("[yellow]✓ Invar hooks disabled[/yellow]")
+    console.print(f"[dim]Remove {HOOKS_SUBDIR}/{DISABLED_MARKER} to re-enable[/dim]")
+    return Success(None)
+
+
+def enable_claude_hooks(
+    project_path: Path,
+    console: Console,
+) -> Result[None, str]:
+    """Re-enable Invar hooks."""
+    hooks_dir = project_path / HOOKS_SUBDIR
+    disabled_marker = hooks_dir / DISABLED_MARKER
+
+    if disabled_marker.exists():
+        disabled_marker.unlink()
+        console.print("[green]✓ Invar hooks enabled[/green]")
+    else:
+        console.print("[dim]Invar hooks were not disabled[/dim]")
+
+    return Success(None)
+
+
+# @shell_complexity: Status display with version extraction
+def hooks_status(
+    project_path: Path,
+    console: Console,
+) -> Result[dict[str, str], str]:
+    """Check status of Claude Code hooks."""
+    hooks_dir = project_path / HOOKS_SUBDIR
+
+    status: dict[str, str] = {}
+
+    if not hooks_dir.exists():
+        console.print("[yellow]No hooks directory[/yellow]")
+        return Success({"status": "not_installed"})
+
+    disabled = (hooks_dir / DISABLED_MARKER).exists()
+    if disabled:
+        console.print("[yellow]⏸ Invar hooks disabled[/yellow]")
+        status["status"] = "disabled"
+    else:
+        status["status"] = "enabled"
+
+    for hook_type in HOOK_TYPES:
+        invar_hook = hooks_dir / f"invar.{hook_type}.sh"
+        if invar_hook.exists():
+            status[hook_type] = "installed"
+            # Try to get version
+            try:
+                content = invar_hook.read_text()
+                match = re.search(r"Protocol: v([\d.]+)", content)
+                if match:
+                    status[f"{hook_type}_version"] = match.group(1)
+            except OSError:
+                pass
+        else:
+            status[hook_type] = "not_installed"
+
+    # Display status
+    installed_count = sum(1 for h in HOOK_TYPES if status.get(h) == "installed")
+    if installed_count == len(HOOK_TYPES):
+        version = status.get("UserPromptSubmit_version", "?")
+        console.print(f"[green]✓ All hooks installed (v{version})[/green]")
+    elif installed_count > 0:
+        console.print(f"[yellow]⚠ Partial installation ({installed_count}/{len(HOOK_TYPES)})[/yellow]")
+    else:
+        console.print("[dim]No Invar hooks installed[/dim]")
+
+    return Success(status)

invar/shell/commands/guard.py

@@ -437,6 +437,7 @@ def rules(
 
 
 # DX-48b: Import commands from shell/commands/
+from invar.shell.commands.hooks import app as hooks_app  # DX-57
 from invar.shell.commands.init import init
 from invar.shell.commands.mutate import mutate  # DX-28
 from invar.shell.commands.sync_self import sync_self  # DX-49
@@ -448,6 +449,7 @@ app.command()(update)
 app.command()(test)
 app.command()(verify)
 app.command()(mutate)  # DX-28: Mutation testing
+app.add_typer(hooks_app, name="hooks")  # DX-57: Claude Code hooks management
 
 # DX-56: Create dev subcommand group for developer commands
 dev_app = typer.Typer(

invar/shell/commands/hooks.py

@@ -0,0 +1,74 @@
+"""
+Hooks management command for Invar.
+
+DX-57: Claude Code hooks installation, removal, and management.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import typer
+from returns.result import Failure, Result
+from rich.console import Console
+
+from invar.shell.claude_hooks import (
+    disable_claude_hooks,
+    enable_claude_hooks,
+    hooks_status,
+    install_claude_hooks,
+    remove_claude_hooks,
+    sync_claude_hooks,
+)
+
+console = Console()
+
+
+def _handle_result(result: Result[object, str]) -> None:
+    """Print error message if result is Failure."""
+    if isinstance(result, Failure):
+        console.print(f"[red]Error:[/red] {result.failure()}")
+
+app = typer.Typer(help="Manage Claude Code hooks")
+
+
+# @invar:allow entry_point_too_thick: Typer command with options and docstring
+@app.callback(invoke_without_command=True)
+def hooks(
+    ctx: typer.Context,
+    path: Path = typer.Argument(Path(), help="Project root directory"),
+    remove: bool = typer.Option(False, "--remove", help="Remove Invar hooks"),
+    disable: bool = typer.Option(False, "--disable", help="Temporarily disable hooks"),
+    enable: bool = typer.Option(False, "--enable", help="Re-enable disabled hooks"),
+    install: bool = typer.Option(False, "--install", help="Install hooks"),
+    sync: bool = typer.Option(False, "--sync", help="Sync hooks with current INVAR.md"),
+) -> None:
+    """
+    Manage Claude Code hooks for Invar.
+
+    Without flags, shows current hooks status.
+
+    \b
+    Examples:
+        invar hooks                  # Show status
+        invar hooks --install        # Install hooks
+        invar hooks --remove         # Permanently remove hooks
+        invar hooks --disable        # Temporarily disable
+        invar hooks --enable         # Re-enable
+        invar hooks --sync           # Update with current INVAR.md
+    """
+    path = path.resolve()
+
+    if remove:
+        _handle_result(remove_claude_hooks(path, console))
+    elif disable:
+        _handle_result(disable_claude_hooks(path, console))
+    elif enable:
+        _handle_result(enable_claude_hooks(path, console))
+    elif install:
+        _handle_result(install_claude_hooks(path, console))
+    elif sync:
+        _handle_result(sync_claude_hooks(path, console))
+    else:
+        # Default: show status
+        _handle_result(hooks_status(path, console))

invar/shell/commands/init.py

@@ -5,6 +5,7 @@ Shell module: handles project initialization.
 DX-21B: Added --claude flag for Claude Code integration.
 DX-55: Unified idempotent init command with smart merge.
 DX-56: Uses unified template sync engine for file generation.
+DX-57: Added Claude Code hooks installation.
 """
 
 from __future__ import annotations
@@ -19,6 +20,10 @@ from rich.console import Console
 
 from invar.core.sync_helpers import SyncConfig
 from invar.core.template_parser import ClaudeMdState
+from invar.shell.claude_hooks import (
+    install_claude_hooks,
+    sync_claude_hooks,
+)
 from invar.shell.commands.merge import (
     ProjectState,
     detect_project_state,
@@ -201,6 +206,10 @@ def init(
     hooks: bool = typer.Option(
         True, "--hooks/--no-hooks", help="Install pre-commit hooks (default: ON)"
     ),
+    claude_hooks: bool = typer.Option(
+        None, "--claude-hooks/--no-claude-hooks",
+        help="Install Claude Code hooks (default: ON when --claude, DX-57)"
+    ),
     skills: bool = typer.Option(
         True, "--skills/--no-skills", help="Create .claude/skills/ (default: ON, use --no-skills for Cursor)"
     ),
@@ -241,6 +250,7 @@ def init(
     Use --mcp-method to specify MCP execution method (uvx, command, python).
     Use --dirs to always create directories, --no-dirs to skip.
     Use --no-hooks to skip pre-commit hooks installation.
+    Use --no-claude-hooks to skip Claude Code hooks (DX-57).
     Use --no-skills to skip .claude/skills/ creation (for Cursor users).
     Use --yes to accept defaults without prompting.
     """
@@ -406,6 +416,24 @@ def init(
     if hooks:
         install_hooks(path, console)
 
+    # DX-57: Handle Claude Code hooks
+    # Determine if we should install/update Claude hooks
+    should_install_claude_hooks = (
+        claude_hooks is True  # Explicitly requested
+        or (claude_hooks is None and claude)  # Default ON when --claude
+    )
+    should_skip_claude_hooks = claude_hooks is False
+
+    if should_install_claude_hooks and not should_skip_claude_hooks:
+        # Install Claude hooks
+        install_claude_hooks(path, console)
+    elif not should_skip_claude_hooks:
+        # Check if hooks already installed and need sync
+        claude_hooks_dir = path / ".claude" / "hooks"
+        if (claude_hooks_dir / "invar.UserPromptSubmit.sh").exists():
+            # Sync existing hooks (idempotent update)
+            sync_claude_hooks(path, console)
+
     if not config_added and not (path / "INVAR.md").exists():
         console.print("[yellow]Invar already configured.[/yellow]")
 
@@ -446,11 +474,13 @@ def _show_check_preview(state: ProjectState, path: Path, version: str) -> None:
             console.print("  - CLAUDE.md")
             console.print("  - .invar/context.md")
             console.print("  - .claude/skills/")
+            console.print("  - .claude/hooks/ (DX-57, with --claude)")
             console.print("  - .pre-commit-config.yaml")
         case "update":
             console.print("Would update:")
             console.print(f"  - CLAUDE.md (managed section v{state.version} → v{version})")
             console.print("  - .claude/skills/* (refresh)")
+            console.print("  - .claude/hooks/* (refresh, if installed)")
         case "recover":
             console.print("[yellow]Would recover:[/yellow]")
             console.print("  - CLAUDE.md (restore regions, preserve content)")

invar/shell/commands/template_sync.py

@@ -22,7 +22,6 @@ from invar.core.sync_helpers import (
     should_skip_file,
 )
 from invar.core.template_parser import (
-    detect_claude_md_state,
     format_preserved_content,
     parse_invar_regions,
     reconstruct_file,
@@ -282,20 +281,54 @@ def _merge_region_content(
     config: SyncConfig,
 ) -> str:
     """Merge existing content with new template based on DX-55 state."""
-    state = detect_claude_md_state(existing_content)
     updates: dict[str, str] = {}
 
-    if state.state == "intact":
-        # Just update managed region, preserve user
+    # Reset mode: discard all user content, use fresh template
+    if config.reset:
+        # Only inject project additions for CLAUDE.md if available
+        if dest_rel == "CLAUDE.md" and project_additions:
+            parsed = parse_invar_regions(new_content)
+            if "project" in parsed.regions:
+                return reconstruct_file(parsed, {"project": project_additions})
+        return new_content
+
+    # Generic region detection: check if primary region markers exist
+    # This works for any region scheme (managed/user, skill/extensions, etc.)
+    primary_open = f"<!--invar:{primary_region}"
+    primary_close = f"<!--/invar:{primary_region}-->"
+    user_open = f"<!--invar:{user_region}-->"
+    user_close = f"<!--/invar:{user_region}-->"
+
+    has_primary_open = primary_open in existing_content
+    has_primary_close = primary_close in existing_content
+    has_user_open = user_open in existing_content
+    has_user_close = user_close in existing_content
+
+    primary_complete = has_primary_open and has_primary_close
+    user_complete = has_user_open and has_user_close
+
+    # Determine state based on generic region presence
+    if primary_complete and user_complete:
+        # Intact: update primary region, preserve user region
         existing_parsed = parse_invar_regions(existing_content)
         updates[primary_region] = new_parsed.regions[primary_region].content
+
+        # DX-58: Also update critical region if present (always overwrite from template)
+        if "critical" in new_parsed.regions and "critical" in existing_parsed.regions:
+            updates["critical"] = new_parsed.regions["critical"].content
+
         if dest_rel == "CLAUDE.md" and project_additions and "project" in existing_parsed.regions:
             updates["project"] = project_additions
         return reconstruct_file(existing_parsed, updates)
 
-    elif state.state == "partial":
-        # Corruption: salvage user content
-        user_content = state.user_content or strip_invar_markers(existing_content)
+    elif has_primary_open or has_user_open:
+        # Partial: some markers present but incomplete - salvage user content
+        existing_parsed = parse_invar_regions(existing_content)
+        user_content = ""
+        if user_region in existing_parsed.regions:
+            user_content = existing_parsed.regions[user_region].content
+        if not user_content:
+            user_content = strip_invar_markers(existing_content)
         if user_content:
             user_content = format_preserved_content(user_content, date.today().isoformat())
         parsed = parse_invar_regions(new_content)
@@ -306,8 +339,8 @@ def _merge_region_content(
             return reconstruct_file(parsed, updates)
         return new_content
 
-    elif state.state == "missing":
-        # No Invar markers - preserve entire content as user content
+    else:
+        # Missing: no Invar markers - preserve entire content as user content
         preserved = format_preserved_content(existing_content, date.today().isoformat())
         parsed = parse_invar_regions(new_content)
         if user_region in parsed.regions:
@@ -317,8 +350,6 @@ def _merge_region_content(
             return reconstruct_file(parsed, updates)
         return new_content
 
-    return new_content
-
 
 # @shell_complexity: File creation with multiple template types
 def _sync_create_only(

invar/shell/commands/test.py

@@ -68,7 +68,7 @@ def test(
         console.print(f"[red]Error:[/red] {result.failure()}")
         raise typer.Exit(1)
 
-    report = result.unwrap()
+    report, _coverage_data = result.unwrap()
     output = format_property_test_report(report, use_json)
     console.print(output)
 

invar/shell/templates.py

@@ -434,7 +434,7 @@ Find your Python path: `python -c "import sys; print(sys.executable)"`
 
 ```bash
 # Recommended: use uvx (no installation needed)
-uvx invar-tools guard
+uvx --from invar-tools invar guard
 
 # Or install globally
 pip install invar-tools
@@ -449,7 +449,7 @@ Run the MCP server directly:
 
 ```bash
 # Using uvx
-uvx invar-tools mcp
+uvx --from invar-tools invar mcp
 
 # Or if installed
 invar mcp