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

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]")

invar/shell/commands/template_sync.py

@@ -70,8 +70,12 @@ def sync_templates(path: Path, config: SyncConfig) -> Result[SyncReport, str]:
     manifest = manifest_result.unwrap()
     report = SyncReport()
 
-    # Build variables for template rendering
-    variables = {**manifest.get("variables", {}), "syntax": config.syntax}
+    # Build variables for template rendering (LX-05: include language)
+    variables = {
+        **manifest.get("variables", {}),
+        "syntax": config.syntax,
+        "language": config.language,
+    }
 
     # Load project additions if enabled
     project_additions = _load_project_additions(path) if config.inject_project_additions else ""
@@ -83,7 +87,12 @@ def sync_templates(path: Path, config: SyncConfig) -> Result[SyncReport, str]:
     for dest_rel, src_rel in fully_managed:
         if should_skip_file(dest_rel, config.skip_patterns):
             continue
-        result = _sync_fully_managed(path, templates_dir, dest_rel, src_rel, config, report)
+        # Get template type from manifest (LX-05: support jinja for fully_managed)
+        template_config = manifest.get("templates", {}).get(dest_rel, {})
+        template_type = template_config.get("type", "copy")
+        result = _sync_fully_managed(
+            path, templates_dir, dest_rel, src_rel, template_type, variables, config, report
+        )
         if isinstance(result, Failure):
             report.errors.append(result.failure())
 
@@ -124,29 +133,44 @@ def _load_project_additions(path: Path) -> str:
     return ""
 
 
-# @shell_complexity: File I/O with multiple existence/content checks
+# @shell_complexity: File I/O with multiple existence/content checks and Jinja rendering
 def _sync_fully_managed(
     path: Path,
     templates_dir: Path,
     dest_rel: str,
     src_rel: str,
+    template_type: str,
+    variables: dict,
     config: SyncConfig,
     report: SyncReport,
 ) -> Result[str, str]:
-    """Sync a fully managed file (direct overwrite)."""
+    """Sync a fully managed file (direct overwrite).
+
+    LX-05: Now supports Jinja templates for composition.
+    """
     dest_file = path / dest_rel
     src_file = templates_dir / src_rel
 
     if not src_file.exists():
         return Failure(f"Template not found: {src_rel}")
 
-    try:
-        new_content = src_file.read_text()
-    except OSError as e:
-        return Failure(f"Failed to read template {src_rel}: {e}")
+    # LX-05: Render Jinja templates, copy plain files
+    if template_type == "jinja":
+        render_result = render_template_file(src_file, variables)
+        if isinstance(render_result, Failure):
+            return render_result
+        new_content = render_result.unwrap()
+    else:
+        try:
+            new_content = src_file.read_text()
+        except OSError as e:
+            return Failure(f"Failed to read template {src_rel}: {e}")
+
+    # Track if file exists BEFORE write (for correct created/updated reporting)
+    file_existed = dest_file.exists()
 
     # Check if update needed
-    if dest_file.exists() and not config.force:
+    if file_existed and not config.force:
         try:
             if dest_file.read_text() == new_content:
                 report.skipped.append(dest_rel)
@@ -162,7 +186,11 @@ def _sync_fully_managed(
         except OSError as e:
             return Failure(f"Failed to write {dest_rel}: {e}")
 
-    report.updated.append(dest_rel) if dest_file.exists() else report.created.append(dest_rel)
+    # Report based on pre-write existence
+    if file_existed:
+        report.updated.append(dest_rel)
+    else:
+        report.created.append(dest_rel)
     return Success("synced")
 
 
@@ -341,6 +369,14 @@ def _merge_region_content(
 
     else:
         # Missing: no Invar markers - preserve entire content as user content
+        # Handle empty content - just return fresh template
+        if not existing_content.strip():
+            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
+
         preserved = format_preserved_content(existing_content, date.today().isoformat())
         parsed = parse_invar_regions(new_content)
         if user_region in parsed.regions:
@@ -371,7 +407,8 @@ def _sync_create_only(
         report.skipped.append(dest_rel)
         return Success("skipped")
 
-    if not src_file.exists():
+    # LX-05: Skip existence check for copy_dir_lang (has {language} placeholder)
+    if template_type != "copy_dir_lang" and not src_file.exists():
         return Failure(f"Template not found: {src_rel}")
 
     try:
@@ -386,9 +423,24 @@ def _sync_create_only(
             dest_file.write_text(result.unwrap())
         elif template_type == "copy_dir":
             if src_file.is_dir():
-                shutil.copytree(src_file, dest_file)
+                # Ignore Python bytecode and cache directories
+                ignore = shutil.ignore_patterns("__pycache__", "*.pyc", "*.pyo")
+                shutil.copytree(src_file, dest_file, ignore=ignore)
             else:
                 return Failure(f"Expected directory: {src_rel}")
+        elif template_type == "copy_dir_lang":
+            # LX-05 hotfix: Language-aware directory copy
+            lang = variables.get("language", "python")
+            lang_src_rel = src_rel.replace("{language}", lang)
+            lang_src_file = templates_dir / lang_src_rel
+            if not lang_src_file.exists():
+                return Failure(f"Language-specific template not found: {lang_src_rel}")
+            if lang_src_file.is_dir():
+                # Ignore Python bytecode and cache directories
+                ignore = shutil.ignore_patterns("__pycache__", "*.pyc", "*.pyo")
+                shutil.copytree(lang_src_file, dest_file, ignore=ignore)
+            else:
+                return Failure(f"Expected directory: {lang_src_rel}")
 
         report.created.append(dest_rel)
         return Success("created")

invar/shell/commands/uninstall.py

@@ -16,6 +16,7 @@ import typer
 from rich.console import Console
 
 from invar.shell.claude_hooks import is_invar_hook
+from invar.shell.skill_manager import CORE_SKILLS, has_user_extensions
 
 console = Console()
 
@@ -199,13 +200,19 @@ def remove_hooks_from_settings(path: Path) -> tuple[bool, str]:
 
 
 # @shell_complexity: Multi-file type detection requires comprehensive branching
-def collect_removal_targets(path: Path) -> dict:
-    """Collect files and directories to remove/modify."""
+def collect_removal_targets(path: Path, remove_extensions: bool = False) -> dict:
+    """Collect files and directories to remove/modify.
+
+    Args:
+        path: Project root path
+        remove_extensions: If True, also remove extension skills
+    """
     targets = {
         "delete_dirs": [],
         "delete_files": [],
         "modify_files": [],
         "skip": [],
+        "extensions_preserved": [],  # Extension skills that will be kept
     }
 
     # Directories to delete entirely
@@ -222,21 +229,45 @@ def collect_removal_targets(path: Path) -> dict:
         if file_path.exists():
             targets["delete_files"].append((file_name, description))
 
-    # Skills with _invar marker
+    # Skills - distinguish core vs extension
     skills_dir = path / ".claude" / "skills"
     if skills_dir.exists():
         for skill_dir in skills_dir.iterdir():
             if skill_dir.is_dir():
+                skill_name = skill_dir.name
                 skill_file = skill_dir / "SKILL.md"
-                if skill_file.exists():
-                    if has_invar_marker(skill_file):
+
+                if not skill_file.exists():
+                    continue
+
+                # Core skills are always removed
+                if skill_name in CORE_SKILLS:
+                    targets["delete_dirs"].append(
+                        (f".claude/skills/{skill_name}/", "core skill")
+                    )
+                elif has_invar_marker(skill_file):
+                    # Extension skill with Invar marker
+                    if remove_extensions:
+                        has_custom = has_user_extensions(skill_dir)
+                        desc = "extension skill"
+                        if has_custom:
+                            desc += " (has custom content)"
                         targets["delete_dirs"].append(
-                            (f".claude/skills/{skill_dir.name}/", "skill, has _invar marker")
+                            (f".claude/skills/{skill_name}/", desc)
                         )
                     else:
-                        targets["skip"].append(
-                            (f".claude/skills/{skill_dir.name}/", "no _invar marker")
+                        # Preserve extension skill
+                        has_custom = has_user_extensions(skill_dir)
+                        desc = "extension skill"
+                        if has_custom:
+                            desc += ", has custom content"
+                        targets["extensions_preserved"].append(
+                            (f".claude/skills/{skill_name}/", desc)
                         )
+                else:
+                    targets["skip"].append(
+                        (f".claude/skills/{skill_name}/", "no _invar marker")
+                    )
 
     # Commands with _invar marker
     commands_dir = path / ".claude" / "commands"
@@ -260,6 +291,23 @@ def collect_removal_targets(path: Path) -> dict:
                     (f".claude/hooks/{hook_file.name}", "hook, has invar marker")
                 )
 
+    # Pi hooks (LX-04)
+    pi_hooks_dir = path / ".pi" / "hooks"
+    if pi_hooks_dir.exists():
+        invar_ts = pi_hooks_dir / "invar.ts"
+        if invar_ts.exists():
+            targets["delete_files"].append((".pi/hooks/invar.ts", "Pi hook"))
+        # Check if .pi/hooks is empty after removal
+        if not any(f for f in pi_hooks_dir.iterdir() if f.name != "invar.ts"):
+            targets["delete_dirs"].append((".pi/hooks/", "empty after removal"))
+        # Check if .pi is empty
+        pi_dir = path / ".pi"
+        hooks_only = all(
+            child.name == "hooks" for child in pi_dir.iterdir() if child.is_dir()
+        )
+        if hooks_only:
+            targets["delete_dirs"].append((".pi/", "only had hooks"))
+
     # CLAUDE.md - delete if empty user region, otherwise modify
     claude_md = path / "CLAUDE.md"
     if claude_md.exists():
@@ -341,6 +389,14 @@ def show_preview(targets: dict) -> None:
         for item, desc in targets["modify_files"]:
             console.print(f"  {item:40} ({desc})")
 
+    if targets.get("extensions_preserved"):
+        console.print("\n[cyan]Will PRESERVE (extension skills):[/cyan]")
+        for item, desc in targets["extensions_preserved"]:
+            console.print(f"  {item:40} ({desc})")
+        console.print(
+            "\n[dim]Use --remove-extensions to also remove extension skills[/dim]"
+        )
+
     if targets["skip"]:
         console.print("\n[dim]Will SKIP:[/dim]")
         for item, desc in targets["skip"]:
@@ -429,16 +485,25 @@ def uninstall(
         "-f",
         help="Skip confirmation prompt",
     ),
+    remove_extensions: bool = typer.Option(
+        False,
+        "--remove-extensions",
+        help="Also remove extension skills (security, acceptance, etc.)",
+    ),
 ) -> None:
     """Remove Invar from a project.
 
     Safely removes Invar-generated files and configurations while
     preserving user content. Uses marker-based detection.
 
+    By default, extension skills are preserved. Use --remove-extensions
+    to also remove them.
+
     Examples:
-        invar uninstall --dry-run    # Preview changes
-        invar uninstall              # Remove with confirmation
-        invar uninstall --force      # Remove without confirmation
+        invar uninstall --dry-run           # Preview changes
+        invar uninstall                     # Remove with confirmation
+        invar uninstall --force             # Remove without confirmation
+        invar uninstall --remove-extensions # Also remove extension skills
     """
     # Check if this is an Invar project
     invar_toml = path / "invar.toml"
@@ -451,7 +516,7 @@ def uninstall(
         raise typer.Exit(1)
 
     # Collect targets
-    targets = collect_removal_targets(path)
+    targets = collect_removal_targets(path, remove_extensions=remove_extensions)
 
     # Check if there's anything to do
     if not any([targets["delete_dirs"], targets["delete_files"], targets["modify_files"]]):

invar/shell/commands/update.py

@@ -19,9 +19,7 @@ console = Console()
 
 def update(
     path: Path = typer.Argument(Path(), help="Project root directory"),
-    check: bool = typer.Option(False, "--check", help="Preview changes"),
-    force: bool = typer.Option(False, "--force", "-f", help="Update even if current"),
-    yes: bool = typer.Option(False, "--yes", "-y", help="Accept defaults without prompting"),
+    preview: bool = typer.Option(False, "--preview", "--check", help="Preview changes (dry run)"),
 ) -> None:
     """
     Alias for 'invar init' (DX-55).
@@ -29,20 +27,14 @@ def update(
     Maintained for backwards compatibility.
     Both commands are now idempotent and do the same thing.
 
-    Use 'invar init --check' to preview changes.
-    Use 'invar init --force' to refresh even if current.
+    Use 'invar init --preview' to preview changes.
     """
     console.print("[dim]Note: 'update' is now an alias for 'init'[/dim]")
-    # Pass all init parameters with explicit defaults to avoid typer.Option object issues
+    # Call init with matching parameters (DX-70 signature)
     return init_command(
         path=path,
         claude=False,
-        mcp_method=None,
-        dirs=None,
-        hooks=True,
-        skills=True,
-        yes=yes,
-        check=check,
-        force=force,
-        reset=False,
+        pi=False,
+        language=None,
+        preview=preview,
     )

invar/shell/contract_coverage.py

@@ -266,6 +266,7 @@ def detect_batch_creation(
         return Success(None)
 
 
+# @shell_orchestration: Report formatting for CLI output display
 # @shell_complexity: Report formatting with multiple conditional sections
 def format_contract_coverage_report(report: ContractCoverageReport) -> str:
     """Format coverage report for human-readable output."""

invar/shell/fs.py

@@ -19,6 +19,16 @@ if TYPE_CHECKING:
     from pathlib import Path
 
 
+# @shell_orchestration: Helper for file discovery, co-located with I/O functions
+def _is_excluded(relative_str: str, exclude_patterns: list[str]) -> bool:
+    """Check if a relative path should be excluded."""
+    for pattern in exclude_patterns:
+        # Match whole path component, not prefix
+        if relative_str == pattern or relative_str.startswith(pattern + "/") or f"/{pattern}/" in f"/{relative_str}":
+            return True
+    return False
+
+
 # @shell_complexity: Recursive file discovery with gitignore and exclusions
 def discover_python_files(
     project_root: Path,
@@ -39,18 +49,51 @@ def discover_python_files(
         exclude_patterns = exclude_result.unwrap() if isinstance(exclude_result, Success) else []
 
     for py_file in project_root.rglob("*.py"):
-        # Check exclusions
-        relative = py_file.relative_to(project_root)
-        relative_str = str(relative)
+        # Check exclusions using shared helper
+        relative_str = str(py_file.relative_to(project_root))
+        if not _is_excluded(relative_str, exclude_patterns):
+            yield py_file
 
-        excluded = False
-        for pattern in exclude_patterns:
-            if relative_str.startswith(pattern) or f"/{pattern}/" in f"/{relative_str}":
-                excluded = True
-                break
 
-        if not excluded:
-            yield py_file
+# @shell_complexity: Recursive TypeScript file discovery with exclusions
+def discover_typescript_files(
+    project_root: Path,
+    exclude_patterns: list[str] | None = None,
+) -> Iterator[Path]:
+    """
+    Discover all TypeScript files in a project (LX-06).
+
+    Args:
+        project_root: Root directory to search
+        exclude_patterns: Patterns to exclude (uses config defaults if None)
+
+    Yields:
+        Path objects for each TypeScript file found
+    """
+    if exclude_patterns is None:
+        exclude_result = get_exclude_paths(project_root)
+        exclude_patterns = exclude_result.unwrap() if isinstance(exclude_result, Success) else []
+
+    # Always exclude node_modules and common build directories
+    default_ts_excludes = ["node_modules", "dist", "build", ".next", "out"]
+    all_excludes = list(set(list(exclude_patterns) + default_ts_excludes))
+
+    for ext in ("*.ts", "*.tsx"):
+        for ts_file in project_root.rglob(ext):
+            # Check exclusions
+            relative = ts_file.relative_to(project_root)
+            relative_str = str(relative)
+
+            excluded = False
+            for pattern in all_excludes:
+                # Match whole path component, not prefix
+                # e.g., "dist" should exclude "dist/file.ts" but NOT "dist_backup/file.ts"
+                if relative_str == pattern or relative_str.startswith(pattern + "/") or f"/{pattern}/" in f"/{relative_str}":
+                    excluded = True
+                    break
+
+            if not excluded:
+                yield ts_file
 
 
 # @shell_complexity: File reading with AST parsing and error handling
@@ -105,11 +148,21 @@ def scan_project(
     Yields:
         Result containing FileInfo or error message for each file
     """
+    # Get exclusion patterns once
+    exclude_result = get_exclude_paths(project_root)
+    exclude_patterns = exclude_result.unwrap() if isinstance(exclude_result, Success) else []
+
     if only_files is not None:
-        # Phase 8.1: --changed mode - only scan specified files
+        # Phase 8.1: --changed mode - only scan specified files (with exclusions)
         for py_file in only_files:
             if py_file.exists() and py_file.suffix == ".py":
-                yield read_and_parse_file(py_file, project_root)
+                # Apply exclusions even in --changed mode
+                try:
+                    relative_str = str(py_file.relative_to(project_root))
+                except ValueError:
+                    relative_str = str(py_file)
+                if not _is_excluded(relative_str, exclude_patterns):
+                    yield read_and_parse_file(py_file, project_root)
     else:
-        for py_file in discover_python_files(project_root):
+        for py_file in discover_python_files(project_root, exclude_patterns):
             yield read_and_parse_file(py_file, project_root)