invar-tools 1.8.0__py3-none-any.whl → 1.11.0__py3-none-any.whl

invar/shell/commands/init.py

@@ -15,7 +15,7 @@ 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 (
@@ -70,6 +70,58 @@ AGENT_CONFIGS: dict[str, dict[str, str]] = {
 }
 
 
+# =============================================================================
+# 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)
 # =============================================================================
@@ -208,8 +260,12 @@ def _show_execution_output(
 
 
 # @shell_complexity: MCP config merge with existing file handling
-def _configure_mcp(path: Path) -> bool:
-    """Configure MCP server with recommended method."""
+def _configure_mcp(path: Path) -> tuple[bool, str]:
+    """Configure MCP server with recommended method.
+
+    Returns:
+        (success, message): (True, "created") | (True, "merged") | (False, "already_configured") | (False, error_message)
+    """
     import json
 
     config = get_recommended_method()
@@ -219,19 +275,24 @@ def _configure_mcp(path: Path) -> bool:
     if mcp_json_path.exists():
         try:
             existing = json.loads(mcp_json_path.read_text())
-            if "mcpServers" in existing and "invar" in existing.get("mcpServers", {}):
-                return False  # Already configured
+            if existing.get("mcpServers", {}).get("invar"):
+                return (False, "already_configured")
             # Add invar to existing config
             if "mcpServers" not in existing:
                 existing["mcpServers"] = {}
             existing["mcpServers"]["invar"] = mcp_content["mcpServers"]["invar"]
             mcp_json_path.write_text(json.dumps(existing, indent=2))
-            return True
-        except (json.JSONDecodeError, OSError):
-            return False
+            return (True, "merged")
+        except json.JSONDecodeError as e:
+            return (False, f"Invalid JSON in .mcp.json: {e}")
+        except OSError as e:
+            return (False, f"Failed to read/write .mcp.json: {e}")
     else:
-        mcp_json_path.write_text(json.dumps(mcp_content, indent=2))
-        return True
+        try:
+            mcp_json_path.write_text(json.dumps(mcp_content, indent=2))
+            return (True, "created")
+        except OSError as e:
+            return (False, f"Failed to create .mcp.json: {e}")
 
 
 # =============================================================================
@@ -255,6 +316,17 @@ def init(
         "--pi",
         help="Auto-select Pi Coding Agent, skip all prompts",
     ),
+    mcp_only: bool = typer.Option(
+        False,
+        "--mcp-only",
+        help="Install MCP tools only (no framework files, just .mcp.json)",
+    ),
+    language: str | None = typer.Option(
+        None,
+        "--language",
+        "-l",
+        help="Target language (auto-detected if not specified): python, typescript",
+    ),
     preview: bool = typer.Option(
         False,
         "--preview",
@@ -268,8 +340,9 @@ def init(
 
     \b
     Quick setup options:
-    - --claude  Auto-select Claude Code (MCP + hooks + skills)
-    - --pi      Auto-select Pi (shares CLAUDE.md + skills, adds Pi hooks)
+    - --claude     Auto-select Claude Code (MCP + hooks + skills)
+    - --pi         Auto-select Pi (shares CLAUDE.md + skills, adds Pi hooks)
+    - --mcp-only   Install MCP tools only (minimal, no framework files)
 
     \b
     This command is safe - it always MERGES with existing files:
@@ -288,11 +361,69 @@ def init(
         console.print("[red]Error:[/red] Cannot use --claude and --pi together.")
         raise typer.Exit(1)
 
+    if mcp_only and (claude or pi):
+        console.print("[red]Error:[/red] --mcp-only cannot be combined with --claude or --pi.")
+        raise typer.Exit(1)
+
+    if mcp_only and language is not None:
+        console.print("[red]Error:[/red] --language is not needed with --mcp-only (MCP tools work for all languages).")
+        raise typer.Exit(1)
+
     # Resolve path
     if path == Path():
         path = Path.cwd()
     path = path.resolve()
 
+    # MCP-only mode: minimal setup, just create .mcp.json
+    if mcp_only:
+        console.print(f"\n[bold]Invar v{__version__} - MCP Tools Only[/bold]")
+        console.print("=" * 45)
+        console.print("[dim]Installing MCP server configuration only.[/dim]\n")
+
+        # Preview mode
+        if preview:
+            console.print("[bold]Preview - Would create:[/bold]")
+            console.print("  [green]✓[/green] .mcp.json")
+            console.print("\n[dim]Run without --preview to apply.[/dim]")
+            return
+
+        console.print("[bold]Creating .mcp.json...[/bold]")
+        success, message = _configure_mcp(path)
+        if success:
+            if message == "created":
+                console.print("[green]✓[/green] Created .mcp.json")
+            elif message == "merged":
+                console.print("[green]✓[/green] Merged into existing .mcp.json")
+            console.print("\n[bold]Setup complete![/bold]")
+            console.print("MCP tools available: invar_doc_*, invar_sig, invar_map, invar_guard")
+        elif message == "already_configured":
+            console.print("[yellow]○[/yellow] .mcp.json already configured")
+        else:
+            console.print(f"[red]Error:[/red] {message}")
+            raise typer.Exit(1)
+
+        return  # Early exit, skip all framework setup
+
+    # 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]")
@@ -301,7 +432,7 @@ def init(
     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:
@@ -371,9 +502,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,
@@ -397,8 +529,14 @@ def init(
 
     # Configure MCP if Claude selected
     if "claude" in agents and selected_files.get(".mcp.json", True):
-        if _configure_mcp(path):
-            created.append(".mcp.json")
+        success, message = _configure_mcp(path)
+        if success:
+            if message == "created":
+                created.append(".mcp.json")
+            elif message == "merged":
+                merged.append(".mcp.json")
+        elif message != "already_configured":
+            console.print(f"[yellow]Warning:[/yellow] MCP configuration failed: {message}")
 
     # Create directories if selected
     if selected_files.get("src/core/", True):

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)

invar/shell/commands/skill.py

@@ -0,0 +1,187 @@
+"""
+Skill management command for Invar.
+
+LX-07: Extension Skills - CLI interface for skill management.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import typer
+from returns.result import Failure, Result
+from rich.console import Console
+from rich.table import Table
+
+from invar.shell.skill_manager import (
+    add_skill,
+    list_skills,
+    remove_skill,
+    update_skill,
+)
+
+PROJECT_SKILLS_DIR = ".claude/skills"
+
+console = Console()
+
+app = typer.Typer(help="Manage extension skills")
+
+
+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()}")
+        raise typer.Exit(1)
+
+
+# @invar:allow entry_point_too_thick: Typer callback with docstring examples
+@app.callback(invoke_without_command=True)
+def skill_callback(ctx: typer.Context) -> None:
+    """
+    Manage Invar extension skills.
+
+    Extension skills add specialized capabilities like acceptance testing
+    and security auditing to your project.
+
+    \b
+    Examples:
+        invar skill              # List all skills
+        invar skill add security # Install security skill
+        invar skill remove security
+        invar skill update security
+    """
+    # If no subcommand, show list
+    if ctx.invoked_subcommand is None:
+        list_cmd(Path())
+
+
+# @invar:allow entry_point_too_thick: Rich table formatting for CLI output
+@app.command("list")
+def list_cmd(
+    path: Path = typer.Argument(Path(), help="Project root directory"),
+) -> None:
+    """List available extension skills."""
+    path = path.resolve()
+
+    result = list_skills(path, console)
+    if isinstance(result, Failure):
+        _handle_result(result)
+        return
+
+    skills = result.unwrap()
+
+    # Create rich table
+    table = Table(title="Extension Skills", show_header=True)
+    table.add_column("Name", style="cyan")
+    table.add_column("Tier", style="dim")
+    table.add_column("Status", style="green")
+    table.add_column("Description")
+
+    # Status styling
+    status_styles = {
+        "installed": "[green]installed[/green]",
+        "available": "[blue]available[/blue]",
+        "pending_discussion": "[yellow]pending[/yellow]",
+    }
+
+    for skill in skills:
+        status_display = status_styles.get(skill.status, skill.status)
+        isolation = " [dim](isolated)[/dim]" if skill.isolation else ""
+
+        table.add_row(
+            f"/{skill.name}",
+            skill.tier,
+            status_display,
+            f"{skill.description}{isolation}",
+        )
+
+    console.print(table)
+    console.print()
+    console.print("[dim]Use 'invar skill add <name>' to install a skill[/dim]")
+
+
+# @invar:allow entry_point_too_thick: CLI output with usage hints
+@app.command("add")
+def add_cmd(
+    name: str = typer.Argument(..., help="Skill name to add"),
+    path: Path = typer.Option(Path(), "--path", "-p", help="Project root"),
+) -> None:
+    """Add or update an extension skill (idempotent)."""
+    path = path.resolve()
+
+    # DX-71: add_skill now prints its own status (Adding/Updating)
+    result = add_skill(name, path, console)
+
+    if isinstance(result, Failure):
+        _handle_result(result)
+        return
+
+    console.print(f"[green]{result.unwrap()}[/green]")
+    console.print()
+    console.print(f"[dim]Use '/{name}' in Claude Code to invoke the skill[/dim]")
+
+
+# @invar:allow entry_point_too_thick: CLI with confirmation dialog
+@app.command("remove")
+def remove_cmd(
+    name: str = typer.Argument(..., help="Skill name to remove"),
+    path: Path = typer.Option(Path(), "--path", "-p", help="Project root"),
+    force: bool = typer.Option(False, "--force", "-f", help="Force removal"),
+) -> None:
+    """Remove an extension skill from the project."""
+    from invar.shell.skill_manager import has_user_extensions
+
+    path = path.resolve()
+    skill_dir = path / PROJECT_SKILLS_DIR / name
+
+    # DX-71 review: Check existence before any user interaction
+    if not skill_dir.exists():
+        console.print(f"[red]Error:[/red] Skill not installed: {name}")
+        raise typer.Exit(1)
+
+    # DX-71: Check extensions FIRST to avoid confusing confirmation→failure flow
+    if not force:
+        # If skill has user extensions, require --force (no confirmation dialog)
+        if has_user_extensions(skill_dir):
+            console.print(
+                f"[yellow]Warning:[/yellow] Skill '{name}' has custom extensions "
+                "content that will be lost."
+            )
+            console.print(
+                "[dim]Use --force to confirm removal, or backup extensions first.[/dim]"
+            )
+            raise typer.Exit(1)
+
+        # No extensions - show simple confirmation dialog
+        confirm = typer.confirm(f"Remove skill '{name}'?")
+        if not confirm:
+            console.print("[yellow]Cancelled[/yellow]")
+            raise typer.Exit(0)
+
+    console.print(f"[bold]Removing skill:[/bold] {name}")
+    # force=True here because we've already done CLI-level checks
+    result = remove_skill(name, path, console, force=True)
+
+    if isinstance(result, Failure):
+        _handle_result(result)
+        return
+
+    console.print(f"[green]{result.unwrap()}[/green]")
+
+
+@app.command("update")
+def update_cmd(
+    name: str = typer.Argument(..., help="Skill name to update"),
+    path: Path = typer.Option(Path(), "--path", "-p", help="Project root"),
+) -> None:
+    """Update an extension skill (deprecated, use 'add' instead)."""
+    path = path.resolve()
+
+    # DX-71: update_skill now shows deprecation notice and delegates to add_skill
+    result = update_skill(name, path, console)
+
+    if isinstance(result, Failure):
+        _handle_result(result)
+        return
+
+    console.print(f"[green]{result.unwrap()}[/green]")