invar-tools 1.7.1__py3-none-any.whl → 1.10.0__py3-none-any.whl

invar/shell/claude_hooks.py

@@ -15,6 +15,8 @@ from typing import TYPE_CHECKING
 from jinja2 import Environment, FileSystemLoader
 from returns.result import Failure, Result, Success
 
+from invar.core.language import detect_language_from_markers
+
 if TYPE_CHECKING:
     from rich.console import Console
 
@@ -32,6 +34,9 @@ DISABLED_MARKER = ".invar_disabled"
 # Marker for identifying Invar hooks in settings
 INVAR_HOOK_MARKER = ".claude/hooks/"
 
+# Regex pattern for extracting protocol version from hook files
+PROTOCOL_VERSION_PATTERN = r"Protocol: v([\d.]+)"
+
 
 # @shell_orchestration: Tightly coupled to Claude Code settings.local.json format
 def is_invar_hook(hook_entry: dict) -> bool:
@@ -102,11 +107,16 @@ def generate_hook_content(
         syntax = detect_syntax(project_path)
         guard_cmd = "invar_guard" if syntax == "mcp" else "invar guard"
 
+        # Detect project language from marker files
+        markers = frozenset(f.name for f in project_path.iterdir() if f.is_file())
+        language = detect_language_from_markers(markers)
+
         # Build context for template
         context = {
             "protocol_version": PROTOCOL_VERSION,
             "generated_date": datetime.now().strftime("%Y-%m-%d"),
             "guard_cmd": guard_cmd,
+            "language": language,
         }
 
         # For UserPromptSubmit, add the full INVAR.md content
@@ -138,9 +148,11 @@ def _register_hooks_in_settings(project_path: Path) -> Result[bool, str]:
 
     def build_invar_hook(hook_type: str) -> dict:
         """Build Invar hook entry for a hook type."""
+        # Use $CLAUDE_PROJECT_DIR for portable paths that work regardless of cwd
+        # Claude Code provides this env var to all hooks (see code.claude.com/docs/hooks)
         hook_cmd = {
             "type": "command",
-            "command": f".claude/hooks/{hook_type}.sh",
+            "command": f'"$CLAUDE_PROJECT_DIR"/.claude/hooks/{hook_type}.sh',
         }
         if hook_type in ("PreToolUse", "PostToolUse"):
             # These need a matcher - use "*" to match all tools
@@ -239,20 +251,24 @@ def install_claude_hooks(
                 # Create merged wrapper
                 merged = f'''#!/bin/bash
 # Merged hook: User + Invar (DX-57)
-# User hooks run first (higher priority)
-
-HOOK_DIR="$(dirname "$0")"
+# Ensure correct working directory regardless of where Claude Code invokes from
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+PROJECT_ROOT="$(cd "$SCRIPT_DIR/../.." && pwd)"
+if ! cd "$PROJECT_ROOT" 2>/dev/null; then
+  echo "[invar] Warning: Could not cd to $PROJECT_ROOT" >&2
+  exit 0  # Don't block Claude Code
+fi
 
-# Run user hook first
-if [[ -f "$HOOK_DIR/{hook_type}.sh.user_backup" ]]; then
-  source "$HOOK_DIR/{hook_type}.sh.user_backup" "$@"
+# Run user hook first (higher priority)
+if [[ -f "$SCRIPT_DIR/{hook_type}.sh.user_backup" ]]; then
+  source "$SCRIPT_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" "$@"
+if [[ -f "$SCRIPT_DIR/invar.{hook_type}.sh" ]]; then
+  source "$SCRIPT_DIR/invar.{hook_type}.sh" "$@"
 fi
 '''
                 wrapper_hook.write_text(merged)
@@ -262,7 +278,14 @@ fi
             # No user hook, create simple wrapper
             wrapper = f'''#!/bin/bash
 # Invar hook wrapper (DX-57)
-source "$(dirname "$0")/invar.{hook_type}.sh" "$@"
+# Ensure correct working directory regardless of where Claude Code invokes from
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+PROJECT_ROOT="$(cd "$SCRIPT_DIR/../.." && pwd)"
+if ! cd "$PROJECT_ROOT" 2>/dev/null; then
+  echo "[invar] Warning: Could not cd to $PROJECT_ROOT" >&2
+  exit 0  # Don't block Claude Code
+fi
+source "$SCRIPT_DIR/invar.{hook_type}.sh" "$@"
 '''
             wrapper_hook.write_text(wrapper)
             wrapper_hook.chmod(0o755)
@@ -311,7 +334,7 @@ def sync_claude_hooks(
     try:
         existing_content = check_hook.read_text()
         # Extract version from header comment
-        version_match = re.search(r"Protocol: v([\d.]+)", existing_content)
+        version_match = re.search(PROTOCOL_VERSION_PATTERN, existing_content)
         old_version = version_match.group(1) if version_match else "unknown"
 
         if old_version != PROTOCOL_VERSION:
@@ -456,7 +479,7 @@ def hooks_status(
             # Try to get version
             try:
                 content = invar_hook.read_text()
-                match = re.search(r"Protocol: v([\d.]+)", content)
+                match = re.search(PROTOCOL_VERSION_PATTERN, content)
                 if match:
                     status[f"{hook_type}_version"] = match.group(1)
             except OSError:

invar/shell/commands/guard.py

@@ -158,6 +158,8 @@ def guard(
     Use --suggest to get functional pattern suggestions (NewType, Validation, etc.).
     Use --contracts-only (-c) to check contract coverage without running tests (DX-63).
     """
+    # LX-06: Language detection and dispatch
+    from invar.shell.commands.init import detect_language
     from invar.shell.guard_helpers import (
         collect_files_to_check,
         handle_changed_mode,
@@ -168,7 +170,38 @@ def guard(
     )
     from invar.shell.testing import VerificationLevel
 
-    # DX-65: Handle single file mode
+    project_language = detect_language(path if path.is_dir() else find_project_root(path))
+
+    # Dispatch to language-specific guard if not Python
+    if project_language == "typescript":
+        from invar.shell.prove.guard_ts import run_typescript_guard
+
+        ts_result = run_typescript_guard(path if path.is_dir() else find_project_root(path))
+        match ts_result:
+            case Success(result):
+                if json_output or agent:
+                    import json as json_mod
+
+                    from invar.shell.prove.guard_ts import format_typescript_guard_v2
+
+                    output = format_typescript_guard_v2(result)
+                    console.print(json_mod.dumps(output, indent=2))
+                else:
+                    console.print(f"[bold]TypeScript Guard[/bold] ({project_language})")
+                    if result.status == "passed":
+                        console.print("[green]✓ PASSED[/green]")
+                    elif result.status == "skipped":
+                        console.print("[yellow]⚠ SKIPPED[/yellow] (no TypeScript tools available)")
+                    else:
+                        console.print(f"[red]✗ FAILED[/red] ({result.error_count} errors)")
+                        for v in result.violations[:10]:  # Show first 10
+                            console.print(f"  {v.file}:{v.line}: [{v.severity}] {v.message}")
+                raise typer.Exit(0 if result.status == "passed" else 1)
+            case Failure(err):
+                console.print(f"[red]Error:[/red] {err}")
+                raise typer.Exit(1)
+
+    # DX-65: Handle single file mode (Python only from here)
     single_file_mode = path.is_file()
     single_file: Path | None = None
     if single_file_mode:
@@ -519,6 +552,7 @@ def rules(
 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.skill import app as skill_app  # LX-07
 from invar.shell.commands.sync_self import sync_self  # DX-49
 from invar.shell.commands.test import test, verify
 from invar.shell.commands.uninstall import uninstall  # DX-69
@@ -531,6 +565,7 @@ 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
+app.add_typer(skill_app, name="skill")  # LX-07: Extension skills management
 
 # DX-56: Create dev subcommand group for developer commands
 dev_app = typer.Typer(

invar/shell/commands/init.py

@@ -15,13 +15,14 @@ from returns.result import Failure, Success
 from rich.console import Console
 from rich.panel import Panel
 
-from invar.core.sync_helpers import SyncConfig
+from invar.core.sync_helpers import VALID_LANGUAGES, SyncConfig
 from invar.shell.claude_hooks import install_claude_hooks
 from invar.shell.commands.template_sync import sync_templates
 from invar.shell.mcp_config import (
     generate_mcp_json,
     get_recommended_method,
 )
+from invar.shell.pi_hooks import install_pi_hooks
 from invar.shell.templates import (
     add_config,
     create_directories,
@@ -55,15 +56,72 @@ FILE_CATEGORIES: dict[str, list[tuple[str, str]]] = {
     "generic": [
         ("AGENT.md", "Universal agent instructions"),
     ],
+    "pi": [
+        ("CLAUDE.md", "Agent instructions (Pi compatible)"),
+        (".claude/skills/", "Workflow automation (Pi compatible)"),
+        (".pi/hooks/", "Pi-specific hooks"),
+    ],
 }
 
 AGENT_CONFIGS: dict[str, dict[str, str]] = {
     "claude": {"name": "Claude Code", "category": "claude"},
+    "pi": {"name": "Pi Coding Agent", "category": "pi"},
     "generic": {"name": "Other (AGENT.md)", "category": "generic"},
-    # Future: "cursor", "windsurf", etc.
 }
 
 
+# =============================================================================
+# Language Detection (LX-05)
+# =============================================================================
+
+from invar.core.language import (
+    FUTURE_LANGUAGES,
+    detect_language_from_markers,
+)
+
+# Marker files to check for language detection
+LANGUAGE_MARKERS: frozenset[str] = frozenset({
+    "pyproject.toml", "setup.py",  # Python
+    "tsconfig.json", "package.json",  # TypeScript
+    "Cargo.toml",  # Rust (future)
+    "go.mod",  # Go (future)
+})
+
+
+def detect_language(path: Path) -> str:
+    """Detect project language from marker files (Shell wrapper).
+
+    This is the Shell wrapper that handles I/O. The actual detection
+    logic is in core.language.detect_language_from_markers.
+
+    Examples:
+        >>> from pathlib import Path
+        >>> import tempfile
+        >>> with tempfile.TemporaryDirectory() as d:
+        ...     p = Path(d)
+        ...     (p / "pyproject.toml").touch()
+        ...     detect_language(p)
+        'python'
+
+        >>> with tempfile.TemporaryDirectory() as d:
+        ...     p = Path(d)
+        ...     (p / "tsconfig.json").touch()
+        ...     detect_language(p)
+        'typescript'
+
+        >>> with tempfile.TemporaryDirectory() as d:
+        ...     p = Path(d)
+        ...     detect_language(p)  # Empty dir defaults to python
+        'python'
+    """
+    # Collect present markers (I/O operation)
+    present_markers = frozenset(
+        marker for marker in LANGUAGE_MARKERS if (path / marker).exists()
+    )
+    # Delegate to pure core function
+    return detect_language_from_markers(present_markers)
+
+
 # =============================================================================
 # Interactive Prompts (DX-70)
 # =============================================================================
@@ -103,6 +161,7 @@ def _prompt_agent_selection() -> list[str]:
 
     choices = [
         questionary.Choice("Claude Code (recommended)", value="claude"),
+        questionary.Choice("Pi Coding Agent", value="pi"),
         questionary.Choice("Other (AGENT.md)", value="generic"),
     ]
 
@@ -156,6 +215,8 @@ def _prompt_file_selection(agents: list[str]) -> dict[str, bool]:
         category_name = category.capitalize()
         if category == "claude":
             category_name = "Claude Code"
+        elif category == "pi":
+            category_name = "Pi Coding Agent"
         choices.append(questionary.Separator(f"── {category_name} ──"))
         for file, desc in files:
             choices.append(
@@ -241,6 +302,17 @@ def init(
         "--claude",
         help="Auto-select Claude Code, skip all prompts",
     ),
+    pi: bool = typer.Option(
+        False,
+        "--pi",
+        help="Auto-select Pi Coding Agent, skip all prompts",
+    ),
+    language: str | None = typer.Option(
+        None,
+        "--language",
+        "-l",
+        help="Target language (auto-detected if not specified): python, typescript",
+    ),
     preview: bool = typer.Option(
         False,
         "--preview",
@@ -252,6 +324,11 @@ def init(
 
     DX-70: Simplified init with interactive selection and safe merge.
 
+    \b
+    Quick setup options:
+    - --claude  Auto-select Claude Code (MCP + hooks + skills)
+    - --pi      Auto-select Pi (shares CLAUDE.md + skills, adds Pi hooks)
+
     \b
     This command is safe - it always MERGES with existing files:
     - File doesn't exist → Create
@@ -264,31 +341,65 @@ def init(
     """
     from invar import __version__
 
+    # Mutual exclusivity check
+    if claude and pi:
+        console.print("[red]Error:[/red] Cannot use --claude and --pi together.")
+        raise typer.Exit(1)
+
     # Resolve path
     if path == Path():
         path = Path.cwd()
     path = path.resolve()
 
+    # LX-05: Language detection and validation
+    if language is None:
+        detected = detect_language(path)
+        # Fall back to python for unsupported detected languages
+        if detected in FUTURE_LANGUAGES:
+            console.print(
+                f"[yellow]Note:[/yellow] {detected} project detected. "
+                f"Using python templates (most similar). "
+                f"Native {detected} support coming soon."
+            )
+            language = "python"
+        else:
+            language = detected
+    else:
+        # Validate explicitly provided language
+        if language not in VALID_LANGUAGES:
+            valid = ", ".join(sorted(VALID_LANGUAGES))
+            console.print(f"[red]Error:[/red] Invalid language '{language}'. Must be one of: {valid}")
+            raise typer.Exit(1)
+
     # Header
     if claude:
         console.print(f"\n[bold]Invar v{__version__} - Quick Setup (Claude Code)[/bold]")
+    elif pi:
+        console.print(f"\n[bold]Invar v{__version__} - Quick Setup (Pi)[/bold]")
     else:
         console.print(f"\n[bold]Invar v{__version__} - Project Setup[/bold]")
     console.print("=" * 45)
-    console.print("[dim]Existing files will be MERGED (your content preserved).[/dim]")
+    console.print(f"[dim]Language: {language} | Existing files will be MERGED.[/dim]")
 
     # Determine agents and files
     if claude:
-        # Quick mode: use defaults
+        # Quick mode: Claude Code defaults
         agents = ["claude"]
         selected_files: dict[str, bool] = {}
         for category in ["optional", "claude"]:
             for file, _ in FILE_CATEGORIES.get(category, []):
                 selected_files[file] = True
+    elif pi:
+        # Quick mode: Pi defaults
+        agents = ["pi"]
+        selected_files = {}
+        for category in ["optional", "pi"]:
+            for file, _ in FILE_CATEGORIES.get(category, []):
+                selected_files[file] = True
     else:
         # Interactive mode
         if not _is_interactive():
-            console.print("[yellow]Non-interactive terminal detected. Use --claude for quick setup.[/yellow]")
+            console.print("[yellow]Non-interactive terminal detected. Use --claude or --pi for quick setup.[/yellow]")
             raise typer.Exit(1)
 
         agents = _prompt_agent_selection()
@@ -338,9 +449,10 @@ def init(
     if not selected_files.get(".pre-commit-config.yaml", True):
         skip_patterns.append(".pre-commit-config.yaml")
 
-    # Run template sync
+    # Run template sync (LX-05: pass language for template rendering)
     sync_config = SyncConfig(
         syntax="cli",
+        language=language,
         inject_project_additions=(path / ".invar" / "project-additions.md").exists(),
         force=False,
         check=False,
@@ -379,6 +491,10 @@ def init(
     if "claude" in agents and selected_files.get(".claude/hooks/", True):
         install_claude_hooks(path, console)
 
+    # Install Pi hooks if selected
+    if "pi" in agents and selected_files.get(".pi/hooks/", True):
+        install_pi_hooks(path, console)
+
     # Create MCP setup guide
     mcp_setup = invar_dir / "mcp-setup.md"
     if not mcp_setup.exists():
@@ -397,7 +513,7 @@ def init(
     # Completion message
     console.print(f"\n[bold green]✓ Initialized Invar v{__version__}[/bold green]")
 
-    # Show tip for Claude users
+    # Show agent-specific tips
     if "claude" in agents:
         console.print()
         console.print(
@@ -408,3 +524,13 @@ def init(
                 border_style="dim",
             )
         )
+    elif "pi" in agents:
+        console.print()
+        console.print(
+            Panel(
+                "[dim]Pi reads CLAUDE.md and .claude/skills/ directly.\n"
+                "Run [bold]pi[/bold] to start — USBV workflow is auto-enabled.[/dim]",
+                title="📌 Tip",
+                border_style="dim",
+            )
+        )

invar/shell/commands/perception.py

@@ -36,44 +36,20 @@ def run_map(path: Path, top_n: int, json_output: bool) -> Result[None, str]:
     Run the map command.
 
     Scans project and generates perception map with reference counts.
+    LX-06: Supports TypeScript projects (basic symbol listing).
     """
     if not path.exists():
         return Failure(f"Path does not exist: {path}")
 
-    # Collect all files and their sources
-    file_infos: list[FileInfo] = []
-    sources: dict[str, str] = {}
+    # LX-06: Detect language and dispatch
+    from invar.shell.commands.init import detect_language
 
-    for py_file in discover_python_files(path):
-        try:
-            content = py_file.read_text(encoding="utf-8")
-            rel_path = str(py_file.relative_to(path))
-            # Skip empty files (e.g., __init__.py)
-            if not content.strip():
-                continue
-            file_info = parse_source(content, rel_path)
-            if file_info:
-                file_infos.append(file_info)
-                sources[rel_path] = content
-        except (OSError, UnicodeDecodeError) as e:
-            console.print(f"[yellow]Warning:[/yellow] {py_file}: {e}")
-            continue
-
-    if not file_infos:
-        return Failure("No Python files found")
-
-    # Build perception map
-    perception_map = build_perception_map(file_infos, sources, str(path.absolute()))
-
-    # Output
-    if json_output:
-        output = format_map_json(perception_map, top_n)
-        console.print(json.dumps(output, indent=2))
-    else:
-        output = format_map_text(perception_map, top_n)
-        console.print(output)
+    project_language = detect_language(path)
+    if project_language == "typescript":
+        return _run_map_typescript(path, top_n, json_output)
 
-    return Success(None)
+    # Python path (original logic)
+    return _run_map_python(path, top_n, json_output)
 
 
 # @shell_complexity: Signature extraction with symbol filtering
@@ -83,6 +59,7 @@ def run_sig(target: str, json_output: bool) -> Result[None, str]:
 
     Extracts signatures from a file or specific symbol.
     Target format: "path/to/file.py" or "path/to/file.py::symbol_name"
+    LX-06: Supports TypeScript files (.ts, .tsx).
     """
     # Parse target
     if "::" in target:
@@ -95,12 +72,26 @@ def run_sig(target: str, json_output: bool) -> Result[None, str]:
     if not file_path.exists():
         return Failure(f"File not found: {file_path}")
 
-    # Read and parse
+    # Read file content
     try:
         content = file_path.read_text(encoding="utf-8")
     except (OSError, UnicodeDecodeError) as e:
         return Failure(f"Failed to read {file_path}: {e}")
 
+    # LX-06: Detect file type and dispatch to appropriate parser
+    suffix = file_path.suffix.lower()
+    if suffix in (".ts", ".tsx"):
+        return _run_sig_typescript(content, file_path, symbol_name, json_output)
+
+    # Python path (original logic)
+    return _run_sig_python(content, file_path, symbol_name, json_output)
+
+
+# @shell_complexity: Python sig orchestration with error handling and output modes
+def _run_sig_python(
+    content: str, file_path: Path, symbol_name: str | None, json_output: bool
+) -> Result[None, str]:
+    """Run sig for Python files."""
     # Handle empty files
     if not content.strip():
         file_info = FileInfo(path=str(file_path), lines=0, symbols=[], imports=[], source="")
@@ -125,3 +116,136 @@ def run_sig(target: str, json_output: bool) -> Result[None, str]:
         console.print(output)
 
     return Success(None)
+
+
+# @shell_complexity: TypeScript sig orchestration with error handling and output modes
+def _run_sig_typescript(
+    content: str, file_path: Path, symbol_name: str | None, json_output: bool
+) -> Result[None, str]:
+    """Run sig for TypeScript files (LX-06)."""
+    from invar.core.ts_sig_parser import (
+        extract_ts_signatures,
+        format_ts_signatures_json,
+        format_ts_signatures_text,
+    )
+
+    # Handle empty files consistently with Python path
+    symbols = [] if not content.strip() else extract_ts_signatures(content)
+
+    # Filter by symbol name if specified
+    if symbol_name:
+        symbols = [s for s in symbols if s.name == symbol_name]
+        if not symbols:
+            return Failure(f"Symbol '{symbol_name}' not found in {file_path}")
+
+    # Output
+    if json_output:
+        output = format_ts_signatures_json(symbols, str(file_path))
+        console.print(json.dumps(output, indent=2))
+    else:
+        output = format_ts_signatures_text(symbols, str(file_path))
+        console.print(output)
+
+    return Success(None)
+
+
+# @shell_complexity: Python map with perception map building
+def _run_map_python(path: Path, top_n: int, json_output: bool) -> Result[None, str]:
+    """Run map for Python projects (original logic)."""
+    # Collect all files and their sources
+    file_infos: list[FileInfo] = []
+    sources: dict[str, str] = {}
+
+    for py_file in discover_python_files(path):
+        try:
+            content = py_file.read_text(encoding="utf-8")
+            rel_path = str(py_file.relative_to(path))
+            # Skip empty files (e.g., __init__.py)
+            if not content.strip():
+                continue
+            file_info = parse_source(content, rel_path)
+            if file_info:
+                file_infos.append(file_info)
+                sources[rel_path] = content
+        except (OSError, UnicodeDecodeError) as e:
+            console.print(f"[yellow]Warning:[/yellow] {py_file}: {e}")
+            continue
+
+    if not file_infos:
+        return Failure("No Python files found")
+
+    # Build perception map
+    perception_map = build_perception_map(file_infos, sources, str(path.absolute()))
+
+    # Output
+    if json_output:
+        output = format_map_json(perception_map, top_n)
+        console.print(json.dumps(output, indent=2))
+    else:
+        output = format_map_text(perception_map, top_n)
+        console.print(output)
+
+    return Success(None)
+
+
+# @shell_complexity: TypeScript map with file discovery and symbol extraction
+def _run_map_typescript(path: Path, top_n: int, json_output: bool) -> Result[None, str]:
+    """Run map for TypeScript projects (LX-06).
+
+    MVP: Lists symbols without reference counting (Phase 2 can add references).
+    """
+    from invar.core.ts_sig_parser import TSSymbol, extract_ts_signatures
+    from invar.shell.fs import discover_typescript_files
+
+    all_symbols: list[tuple[str, TSSymbol]] = []
+
+    for ts_file in discover_typescript_files(path):
+        try:
+            content = ts_file.read_text(encoding="utf-8")
+            rel_path = str(ts_file.relative_to(path))
+            if not content.strip():
+                continue
+            symbols = extract_ts_signatures(content)
+            for sym in symbols:
+                all_symbols.append((rel_path, sym))
+        except (OSError, UnicodeDecodeError) as e:
+            console.print(f"[yellow]Warning:[/yellow] {ts_file}: {e}")
+            continue
+
+    if not all_symbols:
+        return Failure("No TypeScript symbols found (files may be empty or contain no exportable symbols)")
+
+    # Sort by kind priority (function/class first), then by name
+    kind_order = {"function": 0, "class": 1, "interface": 2, "type": 3, "const": 4, "method": 5}
+    all_symbols.sort(key=lambda x: (kind_order.get(x[1].kind, 99), x[1].name))
+
+    # Limit to top_n
+    display_symbols = all_symbols[:top_n] if top_n > 0 else all_symbols
+
+    # Output
+    if json_output:
+        output = {
+            "language": "typescript",
+            "total_symbols": len(all_symbols),
+            "symbols": [
+                {
+                    "name": sym.name,
+                    "kind": sym.kind,
+                    "file": file_path,
+                    "line": sym.line,
+                    "signature": sym.signature,
+                }
+                for file_path, sym in display_symbols
+            ],
+        }
+        console.print(json.dumps(output, indent=2))
+    else:
+        console.print("[bold]TypeScript Symbol Map[/bold]")
+        console.print(f"Total symbols: {len(all_symbols)}\n")
+        for file_path, sym in display_symbols:
+            console.print(f"[{sym.kind}] {sym.name}")
+            console.print(f"  {file_path}:{sym.line}")
+            console.print(f"  {sym.signature}")
+            console.print()
+
+    return Success(None)