devsync 0.5.5__py3-none-any.whl

aiconfigkit/cli/template_update.py

@@ -0,0 +1,225 @@
+"""Template update command."""
+
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+
+import typer
+from rich.console import Console
+from rich.progress import Progress, SpinnerColumn, TextColumn
+
+from aiconfigkit.core.checksum import sha256_string
+from aiconfigkit.core.conflict_resolution import (
+    apply_resolution,
+    detect_conflict,
+    prompt_conflict_resolution_template,
+)
+from aiconfigkit.core.models import ConflictResolution, ConflictType
+from aiconfigkit.storage.template_library import TemplateLibraryManager
+from aiconfigkit.storage.template_tracker import TemplateInstallationTracker
+from aiconfigkit.utils.git_helpers import TemplateNetworkError, update_template_repo
+from aiconfigkit.utils.project import find_project_root
+
+console = Console()
+
+
+def update_command(
+    repo_name: Optional[str] = typer.Argument(None, help="Repository name to update (omit for --all)"),
+    all_repos: bool = typer.Option(
+        False,
+        "--all",
+        "-a",
+        help="Update all installed template repositories",
+    ),
+    scope: str = typer.Option(
+        "project",
+        "--scope",
+        "-s",
+        help="Which installations to update (project, global, both)",
+    ),
+    force: bool = typer.Option(
+        False,
+        "--force",
+        "-f",
+        help="Overwrite local changes without prompting",
+    ),
+    dry_run: bool = typer.Option(
+        False,
+        "--dry-run",
+        "-n",
+        help="Show what would be updated without making changes",
+    ),
+) -> None:
+    """
+    Update installed templates to latest version.
+
+    Example:
+        inskit template update acme-templates
+        inskit template update --all
+        inskit template update acme-templates --dry-run
+        inskit template update --all --force
+    """
+    try:
+        # Validate arguments
+        if not repo_name and not all_repos:
+            console.print("[red]Error: Must specify repo-name or --all[/red]")
+            console.print("Usage: inskit template update <repo-name> or inskit template update --all")
+            raise typer.Exit(2)
+
+        if scope not in ["project", "global", "both"]:
+            console.print(f"[red]Error: Invalid scope '{scope}'. Must be 'project', 'global', or 'both'[/red]")
+            raise typer.Exit(1)
+
+        # Determine which trackers to use
+        trackers: list[tuple[str, TemplateInstallationTracker]] = []
+        if scope in ["project", "both"]:
+            try:
+                project_root = find_project_root()
+                if project_root:
+                    trackers.append(("project", TemplateInstallationTracker.for_project(project_root)))
+            except Exception:
+                if scope == "project":
+                    console.print("[red]Error: Not in a project directory[/red]")
+                    raise typer.Exit(1)
+
+        if scope in ["global", "both"]:
+            trackers.append(("global", TemplateInstallationTracker.for_global()))
+
+        # Collect repositories to update
+        repos_to_update: set[str] = set()
+        for scope_name, tracker in trackers:
+            records = tracker.load_installation_records()
+            if all_repos:
+                repos_to_update.update(r.namespace for r in records)
+            elif repo_name:
+                matching = [r for r in records if r.source_repo == repo_name or r.namespace == repo_name]
+                if matching:
+                    repos_to_update.add(matching[0].namespace)
+
+        if not repos_to_update:
+            if repo_name:
+                console.print(f"[yellow]Repository '{repo_name}' not found in {scope} installations[/yellow]")
+            else:
+                console.print(f"[yellow]No repositories found in {scope} installations[/yellow]")
+            raise typer.Exit(0)
+
+        # Update each repository
+        library_manager = TemplateLibraryManager()
+        total_updated = 0
+
+        for namespace in sorted(repos_to_update):
+            console.print(f"\n[bold]Checking {namespace} for updates...[/bold]")
+
+            # Get repository path
+            try:
+                repo_path, old_manifest = library_manager.get_template_repository(namespace)
+            except FileNotFoundError:
+                console.print("[yellow]⚠️  Repository not found in library, skipping[/yellow]")
+                continue
+
+            # Check for updates
+            try:
+                with Progress(
+                    SpinnerColumn(), TextColumn("[progress.description]{task.description}"), console=console
+                ) as progress:
+                    task = progress.add_task("Fetching updates...", total=None)
+                    has_updates = update_template_repo(repo_path)
+                    progress.update(task, completed=True)
+
+                if not has_updates:
+                    console.print("[green]✓ Already up-to-date[/green]")
+                    continue
+
+            except TemplateNetworkError as e:
+                console.print(f"[red]❌ Failed to check for updates: {e}[/red]")
+                continue
+
+            # Load new manifest
+            from aiconfigkit.core.template_manifest import load_manifest
+
+            new_manifest = load_manifest(repo_path / "templatekit.yaml")
+
+            console.print(f"[green]Found updates[/green] (v{old_manifest.version} → v{new_manifest.version})\n")
+
+            if dry_run:
+                console.print("[dim]Dry run - no changes will be made[/dim]")
+                # Show what would be updated
+                for template in new_manifest.templates:
+                    console.print(f"  Would update: {namespace}.{template.name}")
+                continue
+
+            # Update templates
+            updated_count = 0
+            skipped_count = 0
+
+            for scope_name, tracker in trackers:
+                records = tracker.get_installations_by_namespace(namespace)
+
+                for record in records:
+                    # Find matching template in new manifest
+                    matching_template = next(
+                        (t for t in new_manifest.templates if t.name == record.template_name), None
+                    )
+                    if not matching_template:
+                        console.print(
+                            f"[yellow]⚠️  Template {record.template_name} no longer in repository, skipping[/yellow]"
+                        )
+                        continue
+
+                    # Read new template content
+                    template_file = matching_template.files[0]
+                    source_file = repo_path / template_file.path
+                    new_content = source_file.read_text(encoding="utf-8")
+
+                    # Check for conflicts
+                    installed_path = Path(record.installed_path)
+                    conflict_type = detect_conflict(installed_path, new_content, record)
+
+                    if conflict_type != ConflictType.NONE and not force:
+                        # Prompt for resolution
+                        resolution = prompt_conflict_resolution_template(
+                            f"{namespace}.{record.template_name}", conflict_type
+                        )
+
+                        if resolution == ConflictResolution.SKIP:
+                            console.print(f"Skipping [cyan]{namespace}.{record.template_name}[/cyan]")
+                            skipped_count += 1
+                            continue
+
+                        # Apply resolution
+                        apply_resolution(installed_path, new_content, resolution)
+                    else:
+                        # Safe to update or force mode
+                        console.print(f"Updating [cyan]{namespace}.{record.template_name}[/cyan]...", end=" ")
+                        installed_path.write_text(new_content, encoding="utf-8")
+
+                    # Update installation record
+                    record.source_version = new_manifest.version
+                    record.checksum = sha256_string(new_content)
+                    record.installed_at = datetime.now()
+                    tracker.update_installation(record.id, record)
+
+                    console.print("[green]✓[/green]")
+                    updated_count += 1
+
+            if updated_count > 0:
+                console.print(f"\n[green]✓ Updated {updated_count} template(s)[/green]")
+                total_updated += updated_count
+            if skipped_count > 0:
+                console.print(f"[yellow]Skipped {skipped_count} template(s) due to conflicts[/yellow]")
+
+        if dry_run:
+            console.print("\n[dim]Dry run complete - no changes were made[/dim]")
+        elif total_updated > 0:
+            console.print(f"\n[green]✓ Total updated: {total_updated} template(s)[/green]")
+        else:
+            console.print("\n[yellow]No templates were updated[/yellow]")
+
+    except typer.Exit:
+        raise
+    except KeyboardInterrupt:
+        console.print("\n[yellow]Cancelled by user[/yellow]")
+        raise typer.Exit(130)
+    except Exception as e:
+        console.print(f"\n[red]Error: {e}[/red]")
+        raise typer.Exit(1)

aiconfigkit/cli/template_validate.py

@@ -0,0 +1,234 @@
+"""Template validation command."""
+
+from pathlib import Path
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from aiconfigkit.core.checksum import calculate_file_checksum
+from aiconfigkit.storage.template_library import TemplateLibraryManager
+from aiconfigkit.storage.template_tracker import TemplateInstallationTracker
+from aiconfigkit.utils.project import find_project_root
+
+console = Console()
+
+
+class ValidationIssue:
+    """Represents a validation issue found during template validation."""
+
+    def __init__(self, severity: str, template: str, issue_type: str, description: str, remediation: str = ""):
+        """
+        Initialize validation issue.
+
+        Args:
+            severity: Issue severity (error, warning, info)
+            template: Template identifier
+            issue_type: Type of issue
+            description: Issue description
+            remediation: Suggested remediation
+        """
+        self.severity = severity
+        self.template = template
+        self.issue_type = issue_type
+        self.description = description
+        self.remediation = remediation
+
+
+def validate_command(
+    scope: str = typer.Option(
+        "all",
+        "--scope",
+        "-s",
+        help="Which installations to validate (project, global, all)",
+    ),
+    fix: bool = typer.Option(
+        False,
+        "--fix",
+        help="Attempt to fix issues automatically",
+    ),
+    verbose: bool = typer.Option(
+        False,
+        "--verbose",
+        "-v",
+        help="Show detailed information",
+    ),
+) -> None:
+    """
+    Validate installed templates for issues.
+
+    Checks for:
+    - Tracking inconsistencies (installed but files missing)
+    - Missing files referenced in manifest
+    - Outdated versions (local vs remote)
+    - Broken template dependencies
+    - Local modifications (checksum mismatch)
+
+    Example:
+        inskit template validate
+        inskit template validate --scope project
+        inskit template validate --fix
+    """
+    try:
+        # Validate scope
+        if scope not in ["project", "global", "all"]:
+            console.print(f"[red]Error: Invalid scope '{scope}'. Must be 'project', 'global', or 'all'[/red]")
+            raise typer.Exit(1)
+
+        issues: list[ValidationIssue] = []
+
+        # Validate project templates
+        if scope in ["project", "all"]:
+            try:
+                project_root = find_project_root()
+                if project_root:
+                    console.print(f"\n[bold]Validating project templates[/bold] ({project_root})...")
+                    project_issues = _validate_installations(
+                        TemplateInstallationTracker.for_project(project_root), "project", verbose
+                    )
+                    issues.extend(project_issues)
+                elif scope == "project":
+                    console.print("[yellow]⚠️  Not in a project directory[/yellow]")
+                    raise typer.Exit(1)
+            except Exception as e:
+                if scope == "project":
+                    console.print(f"[red]Error: {e}[/red]")
+                    raise typer.Exit(1)
+
+        # Validate global templates
+        if scope in ["global", "all"]:
+            console.print("\n[bold]Validating global templates...[/bold]")
+            global_issues = _validate_installations(TemplateInstallationTracker.for_global(), "global", verbose)
+            issues.extend(global_issues)
+
+        # Display results
+        _display_validation_results(issues, fix, verbose)
+
+    except typer.Exit:
+        raise
+    except KeyboardInterrupt:
+        console.print("\n[yellow]Validation cancelled by user[/yellow]")
+        raise typer.Exit(130)
+    except Exception as e:
+        console.print(f"\n[red]Error: {e}[/red]")
+        raise typer.Exit(1)
+
+
+def _validate_installations(tracker: TemplateInstallationTracker, scope: str, verbose: bool) -> list[ValidationIssue]:
+    """Validate all installations tracked by a tracker."""
+    issues: list[ValidationIssue] = []
+    records = tracker.load_installation_records()
+
+    if not records:
+        console.print(f"  [dim]No {scope} templates installed[/dim]")
+        return issues
+
+    console.print(f"  Found {len(records)} template(s)")
+
+    for record in records:
+        template_id = f"{record.namespace}.{record.template_name}"
+
+        # Check 1: File exists
+        installed_path = Path(record.installed_path)
+        if not installed_path.exists():
+            issues.append(
+                ValidationIssue(
+                    severity="error",
+                    template=template_id,
+                    issue_type="missing_file",
+                    description=f"Installed file not found: {installed_path}",
+                    remediation=(
+                        f"Reinstall template with: "
+                        f"inskit template install {record.source_repo} --template {record.template_name}"
+                    ),
+                )
+            )
+            continue
+
+        # Check 2: Local modifications (checksum mismatch)
+        try:
+            current_checksum = calculate_file_checksum(str(installed_path))
+            if current_checksum != record.checksum:
+                issues.append(
+                    ValidationIssue(
+                        severity="warning",
+                        template=template_id,
+                        issue_type="modified",
+                        description="Template has been modified locally",
+                        remediation=f"Update to restore original: inskit template update {record.namespace}",
+                    )
+                )
+        except Exception as e:
+            if verbose:
+                console.print(f"  [dim]Could not verify checksum for {template_id}: {e}[/dim]")
+
+        # Check 3: Outdated version
+        try:
+            library_manager = TemplateLibraryManager()
+            local_version = library_manager.get_repository_version(record.namespace)
+            if local_version and record.source_version and local_version != record.source_version:
+                issues.append(
+                    ValidationIssue(
+                        severity="info",
+                        template=template_id,
+                        issue_type="outdated",
+                        description=f"Newer version available ({record.source_version} -> {local_version})",
+                        remediation=f"Update with: inskit template update {record.namespace}",
+                    )
+                )
+        except Exception as e:
+            if verbose:
+                console.print(f"  [dim]Could not check version for {template_id}: {e}[/dim]")
+
+    return issues
+
+
+def _display_validation_results(issues: list[ValidationIssue], fix: bool, verbose: bool) -> None:
+    """Display validation results in a formatted table."""
+    if not issues:
+        console.print("\n[green]✓ All templates are valid![/green]")
+        return
+
+    # Group by severity
+    errors = [i for i in issues if i.severity == "error"]
+    warnings = [i for i in issues if i.severity == "warning"]
+    info = [i for i in issues if i.severity == "info"]
+
+    console.print("\n[bold]Validation Summary:[/bold]")
+    if errors:
+        console.print(f"  [red]✗ {len(errors)} error(s)[/red]")
+    if warnings:
+        console.print(f"  [yellow]⚠ {len(warnings)} warning(s)[/yellow]")
+    if info:
+        console.print(f"  [blue]ℹ {len(info)} info[/blue]")
+
+    # Display issues table
+    if verbose or errors:
+        table = Table(title="\nValidation Issues")
+        table.add_column("Severity", style="bold")
+        table.add_column("Template")
+        table.add_column("Issue Type")
+        table.add_column("Description")
+        table.add_column("Remediation")
+
+        for issue in errors + warnings + info:
+            severity_color = {"error": "red", "warning": "yellow", "info": "blue"}[issue.severity]
+            severity_symbol = {"error": "✗", "warning": "⚠", "info": "ℹ"}[issue.severity]
+
+            table.add_row(
+                f"[{severity_color}]{severity_symbol} {issue.severity.upper()}[/{severity_color}]",
+                issue.template,
+                issue.issue_type,
+                issue.description,
+                issue.remediation,
+            )
+
+        console.print(table)
+
+    if fix:
+        console.print("\n[yellow]⚠️  Auto-fix is not yet implemented[/yellow]")
+        console.print("Please use the suggested remediation commands above")
+
+    # Exit with error code if there are errors
+    if errors:
+        raise typer.Exit(1)

aiconfigkit/cli/tools.py

@@ -0,0 +1,47 @@
+"""Tools command to show detected AI coding tools."""
+
+from rich.console import Console
+from rich.table import Table
+
+from aiconfigkit.ai_tools.detector import get_detector
+
+console = Console()
+
+
+def show_tools() -> int:
+    """
+    Show detected AI coding tools.
+
+    Returns:
+        Exit code (0 for success)
+    """
+    detector = get_detector()
+
+    # Create table
+    table = Table(title="AI Coding Tools", show_header=True, header_style="bold cyan")
+    table.add_column("Tool", style="cyan", no_wrap=True)
+    table.add_column("Status", style="green")
+
+    # Get all tools and their status
+    for tool_type, tool in detector.tools.items():
+        is_installed = tool.is_installed()
+        status = "[green]✓ Installed[/green]" if is_installed else "[red]✗ Not found[/red]"
+
+        table.add_row(tool.tool_name, status)
+
+    # Display table
+    console.print()
+    console.print(table)
+    console.print()
+
+    # Summary
+    installed = detector.detect_installed_tools()
+    if installed:
+        tool_names = ", ".join([t.tool_name for t in installed])
+        console.print(f"[green]Found {len(installed)} installed tool(s):[/green] {tool_names}")
+    else:
+        console.print("[yellow]No AI coding tools detected[/yellow]")
+        console.print("\nSupported tools: Cursor, GitHub Copilot, Winsurf, Claude Code")
+
+    console.print()
+    return 0

aiconfigkit/cli/uninstall.py

@@ -0,0 +1,125 @@
+"""Uninstall command implementation."""
+
+from pathlib import Path
+from typing import Optional
+
+import typer
+from rich.console import Console
+
+from aiconfigkit.ai_tools.detector import get_detector
+from aiconfigkit.core.models import AIToolType, InstallationScope
+from aiconfigkit.storage.tracker import InstallationTracker
+from aiconfigkit.utils.project import find_project_root
+from aiconfigkit.utils.ui import print_error, print_success, print_warning
+
+console = Console()
+
+
+def uninstall_instruction(
+    name: str,
+    tool: Optional[str] = None,
+    force: bool = False,
+) -> int:
+    """
+    Uninstall an instruction.
+
+    Uninstalls from project level only.
+
+    Args:
+        name: Instruction name to uninstall
+        tool: Specific AI tool to uninstall from (or None for all)
+        force: Skip confirmation prompt
+
+    Returns:
+        Exit code (0 for success, 1 for error)
+    """
+    tracker = InstallationTracker()
+
+    # Detect project root
+    project_root = find_project_root()
+
+    # Get installed instructions matching the name (project scope only)
+    all_records = tracker.get_installed_instructions(project_root=project_root)
+    matching_records = [r for r in all_records if r.instruction_name == name and r.scope == InstallationScope.PROJECT]
+
+    # Filter by tool if specified
+    if tool:
+        try:
+            ai_tool_type = AIToolType(tool.lower())
+            matching_records = [r for r in matching_records if r.ai_tool == ai_tool_type]
+        except ValueError:
+            print_error(f"Invalid AI tool: {tool}. Valid options: cursor, copilot, windsurf, claude", console)
+            return 1
+
+    # Check if instruction is installed
+    if not matching_records:
+        if tool:
+            print_error(f"Instruction '{name}' is not installed for {tool}", console)
+        else:
+            print_error(f"Instruction '{name}' is not installed", console)
+        return 1
+
+    # Show what will be uninstalled
+    console.print("\n[yellow]The following will be uninstalled:[/yellow]")
+    for record in matching_records:
+        console.print(f"  • {record.instruction_name} ({record.ai_tool.value}, {record.scope.value})")
+
+    # Confirm unless --force
+    if not force:
+        console.print()
+        confirm = typer.confirm("Continue with uninstall?", default=False)
+        if not confirm:
+            console.print("[yellow]Uninstall cancelled[/yellow]")
+            return 0
+
+    # Get AI tool detector
+    detector = get_detector()
+
+    # Uninstall each record
+    removed_count = 0
+    error_count = 0
+
+    for record in matching_records:
+        ai_tool = detector.get_tool_by_type(record.ai_tool)
+        if not ai_tool:
+            print_warning(f"Unknown AI tool: {record.ai_tool}", console)
+            error_count += 1
+            continue
+
+        try:
+            # Remove file
+            file_path = Path(record.installed_path)
+            if file_path.exists():
+                file_path.unlink()
+            else:
+                print_warning(f"File not found: {file_path}", console)
+
+            # Determine scope filter for removal
+            scope_filter = record.scope.value
+
+            # Determine project root for removal (only for project-scoped installations)
+            removal_project_root = project_root if record.scope == InstallationScope.PROJECT else None
+
+            # Remove from tracker
+            tracker.remove_installation(
+                record.instruction_name, record.ai_tool, project_root=removal_project_root, scope_filter=scope_filter
+            )
+
+            print_success(
+                f"Uninstalled {record.instruction_name} from {ai_tool.tool_name} ({record.scope.value})", console
+            )
+            removed_count += 1
+
+        except Exception as e:
+            print_error(f"Failed to uninstall {record.instruction_name}: {e}", console)
+            error_count += 1
+
+    # Summary
+    console.print()
+    if removed_count > 0:
+        console.print(f"[green]Successfully uninstalled {removed_count} instruction(s)[/green]")
+    if error_count > 0:
+        console.print(f"[red]Failed to uninstall {error_count} instruction(s)[/red]")
+        return 1
+
+    return 0