devsync 0.5.5__py3-none-any.whl

aiconfigkit/cli/template_install.py

@@ -0,0 +1,261 @@
+"""Template installation command."""
+
+import uuid
+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 rich.table import Table
+
+from aiconfigkit.ai_tools.detector import get_detector
+from aiconfigkit.core.checksum import sha256_string
+from aiconfigkit.core.models import AIToolType, InstallationScope, TemplateInstallationRecord
+from aiconfigkit.core.template_manifest import validate_dependencies, validate_manifest_size
+from aiconfigkit.storage.template_library import TemplateLibraryManager
+from aiconfigkit.storage.template_tracker import TemplateInstallationTracker
+from aiconfigkit.utils.git_helpers import TemplateAuthError, TemplateNetworkError
+from aiconfigkit.utils.namespace import derive_namespace, get_install_path
+from aiconfigkit.utils.project import find_project_root
+
+console = Console()
+
+
+def install_command(
+    repo_url: str = typer.Argument(..., help="Git repository URL (https:// or git@)"),
+    scope: str = typer.Option(
+        "project",
+        "--scope",
+        "-s",
+        help="Installation scope (project or global)",
+    ),
+    namespace_override: Optional[str] = typer.Option(
+        None,
+        "--as",
+        help="Override namespace (default: derived from repository name)",
+    ),
+    force: bool = typer.Option(
+        False,
+        "--force",
+        "-f",
+        help="Overwrite existing templates without prompting",
+    ),
+) -> None:
+    """
+    Install templates from a repository.
+
+    Example:
+        inskit template install https://github.com/acme/templates
+        inskit template install https://github.com/acme/templates --scope global
+        inskit template install https://github.com/acme/templates --as acme
+    """
+    try:
+        # Validate scope
+        if scope not in ["project", "global"]:
+            console.print(f"[red]Error: Invalid scope '{scope}'. Must be 'project' or 'global'[/red]")
+            raise typer.Exit(1)
+
+        installation_scope = InstallationScope.PROJECT if scope == "project" else InstallationScope.GLOBAL
+
+        # Derive namespace
+        try:
+            namespace = derive_namespace(repo_url, namespace_override)
+            if namespace_override:
+                console.print(f"Using custom namespace: [cyan]{namespace}[/cyan]")
+            else:
+                console.print(f"Deriving namespace from repository: [cyan]{namespace}[/cyan]")
+        except ValueError as e:
+            console.print(f"[red]Error: {e}[/red]")
+            raise typer.Exit(1)
+
+        # Clone repository
+        library_manager = TemplateLibraryManager()
+
+        console.print(f"\n[bold]Cloning repository from {repo_url}...[/bold]")
+
+        with Progress(
+            SpinnerColumn(), TextColumn("[progress.description]{task.description}"), console=console
+        ) as progress:
+            task = progress.add_task("Cloning repository...", total=None)
+
+            try:
+                repo_path, manifest = library_manager.clone_repository(repo_url, namespace_override)
+                progress.update(task, completed=True)
+
+            except TemplateAuthError as e:
+                progress.stop()
+                console.print(f"\n[red]❌ {e}[/red]")
+                raise typer.Exit(3)
+
+            except TemplateNetworkError as e:
+                progress.stop()
+                console.print(f"\n[red]❌ {e}[/red]")
+                raise typer.Exit(4)
+
+            except Exception as e:
+                progress.stop()
+                console.print(f"\n[red]❌ Failed to clone repository: {e}[/red]")
+                raise typer.Exit(1)
+
+        console.print("[green]✓ Repository cloned[/green]\n")
+
+        # Validate manifest
+        warnings = validate_manifest_size(repo_path / "templatekit.yaml", len(manifest.templates))
+        for warning in warnings:
+            console.print(warning)
+
+        dep_errors = validate_dependencies(manifest.templates)
+        if dep_errors:
+            console.print("[red]❌ Manifest validation errors:[/red]")
+            for error in dep_errors:
+                console.print(f"  - {error}")
+            raise typer.Exit(5)
+
+        # Detect IDEs
+        if installation_scope == InstallationScope.PROJECT:
+            try:
+                project_root = find_project_root()
+            except Exception:
+                console.print("[red]Error: Could not detect project root. Ensure you're in a project directory.[/red]")
+                raise typer.Exit(1)
+        else:
+            project_root = None
+
+        detector = get_detector()
+        detected_tool_instances = detector.detect_installed_tools() if project_root else []
+        detected_tools = [tool.tool_type for tool in detected_tool_instances]
+
+        if not detected_tools and installation_scope == InstallationScope.PROJECT:
+            console.print("[yellow]⚠️  No AI coding tools detected in project.[/yellow]")
+            console.print("Templates will be installed but may not be accessible until IDE is configured.")
+
+        if not detected_tools and installation_scope == InstallationScope.GLOBAL:
+            # For global, use a default set
+            detected_tools = [AIToolType.CURSOR, AIToolType.CLAUDE, AIToolType.WINSURF, AIToolType.COPILOT]
+
+        # Install templates
+        console.print(f"[bold]Installing {len(manifest.templates)} templates...[/bold]\n")
+
+        # Initialize tracker
+        if installation_scope == InstallationScope.PROJECT:
+            if project_root is None:
+                console.print("[red]Error: Project root not found[/red]")
+                raise typer.Exit(1)
+            tracker = TemplateInstallationTracker.for_project(project_root)
+        else:
+            tracker = TemplateInstallationTracker.for_global()
+
+        installed_count = 0
+        skipped_count = 0
+        failed_count = 0
+
+        for template in manifest.templates:
+            template_display_name = f"{namespace}.{template.name}"
+
+            try:
+                console.print(f"Installing [cyan]{template_display_name}[/cyan]...", end=" ")
+
+                # Get template file
+                template_file = template.files[0]  # Use first file for now
+                source_file = repo_path / template_file.path
+                content = source_file.read_text(encoding="utf-8")
+
+                # Calculate checksum
+                checksum = sha256_string(content)
+
+                # Install for each detected IDE
+                for ide_type in detected_tools:
+                    # Get IDE-specific paths
+                    if installation_scope == InstallationScope.PROJECT:
+                        tool = detector.get_tool_by_type(ide_type)
+                        if tool is None or project_root is None:
+                            continue
+
+                        ide_base_path = tool.get_project_instructions_directory(project_root)
+                        extension = tool.get_instruction_file_extension().lstrip(".")
+                    else:
+                        # Global installation
+                        global_base = Path.home() / ".instructionkit" / "global-templates" / ide_type.value
+                        global_base.mkdir(parents=True, exist_ok=True)
+                        ide_base_path = global_base
+                        extension = "md"  # Default
+
+                    # Get install path with namespace
+                    install_path = get_install_path(namespace, template.name, ide_base_path, extension)
+
+                    # Check for conflicts
+                    if install_path.exists() and not force:
+                        console.print("[yellow]⚠️  (already exists, skipping)[/yellow]")
+                        skipped_count += 1
+                        continue
+
+                    # Create parent directory
+                    install_path.parent.mkdir(parents=True, exist_ok=True)
+
+                    # Write template file
+                    install_path.write_text(content, encoding="utf-8")
+
+                    # Create installation record
+                    record = TemplateInstallationRecord(
+                        id=str(uuid.uuid4()),
+                        template_name=template.name,
+                        source_repo=manifest.name,
+                        source_version=manifest.version,
+                        namespace=namespace,
+                        installed_path=str(install_path),
+                        scope=installation_scope,
+                        installed_at=datetime.now(),
+                        checksum=checksum,
+                        ide_type=ide_type,
+                    )
+
+                    tracker.add_installation(record)
+
+                console.print("[green]✓[/green]")
+                installed_count += 1
+
+            except Exception as e:
+                console.print(f"[red]✗ {e}[/red]")
+                failed_count += 1
+
+        # Display summary
+        console.print()
+        table = Table(title="Installation Summary")
+        table.add_column("Status", style="cyan")
+        table.add_column("Count", style="magenta")
+        table.add_column("Templates", style="green")
+
+        if installed_count > 0:
+            template_names = ", ".join([t.name for t in manifest.templates[:3]])
+            if len(manifest.templates) > 3:
+                template_names += f", ... ({len(manifest.templates)} total)"
+            table.add_row("✓ Installed", str(installed_count), template_names)
+
+        if skipped_count > 0:
+            table.add_row("⊘ Skipped", str(skipped_count), "(already exists)")
+
+        if failed_count > 0:
+            table.add_row("✗ Failed", str(failed_count), "(see errors above)")
+
+        console.print(table)
+
+        # Show available commands
+        if installed_count > 0:
+            console.print("\n[bold]Commands available:[/bold]")
+            for template in manifest.templates[:5]:
+                console.print(f"  /{namespace}.{template.name}")
+            if len(manifest.templates) > 5:
+                console.print(f"  ... and {len(manifest.templates) - 5} more")
+
+        console.print("\n[green]✓ Installation complete[/green]")
+
+    except typer.Exit:
+        raise
+    except KeyboardInterrupt:
+        console.print("\n[yellow]Installation cancelled by user[/yellow]")
+        raise typer.Exit(130)
+    except Exception as e:
+        console.print(f"\n[red]Unexpected error: {e}[/red]")
+        raise typer.Exit(1)

aiconfigkit/cli/template_list.py

@@ -0,0 +1,172 @@
+"""Template list command."""
+
+from typing import Optional
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from aiconfigkit.storage.template_tracker import TemplateInstallationTracker
+from aiconfigkit.utils.project import find_project_root
+
+console = Console()
+
+
+def list_command(
+    scope: str = typer.Option(
+        "all",
+        "--scope",
+        "-s",
+        help="Which installations to list (project, global, all)",
+    ),
+    repo: Optional[str] = typer.Option(
+        None,
+        "--repo",
+        "-r",
+        help="Filter by repository name",
+    ),
+    format_type: str = typer.Option(
+        "table",
+        "--format",
+        "-f",
+        help="Output format (table, json, simple)",
+    ),
+    verbose: bool = typer.Option(
+        False,
+        "--verbose",
+        "-v",
+        help="Show detailed information",
+    ),
+) -> None:
+    """
+    List installed templates.
+
+    Example:
+        inskit template list
+        inskit template list --scope project
+        inskit template list --repo acme-templates
+        inskit template list --format json
+    """
+    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)
+
+        # Validate format
+        if format_type not in ["table", "json", "simple"]:
+            console.print(f"[red]Error: Invalid format '{format_type}'. Must be 'table', 'json', or 'simple'[/red]")
+            raise typer.Exit(1)
+
+        # Load installation records
+        project_records: list = []
+        global_records: list = []
+
+        if scope in ["project", "all"]:
+            try:
+                project_root = find_project_root()
+                if project_root:
+                    tracker = TemplateInstallationTracker.for_project(project_root)
+                    project_records = tracker.load_installation_records()
+            except Exception:
+                if scope == "project":
+                    console.print("[yellow]⚠️  Not in a project directory[/yellow]")
+                    raise typer.Exit(1)
+
+        if scope in ["global", "all"]:
+            tracker = TemplateInstallationTracker.for_global()
+            global_records = tracker.load_installation_records()
+
+        # Combine records
+        all_records = []
+        if project_records:
+            all_records.extend(project_records)
+        if global_records:
+            all_records.extend(global_records)
+
+        # Filter by repository if specified
+        if repo:
+            all_records = [r for r in all_records if r.source_repo == repo or r.namespace == repo]
+
+        # Check if empty
+        if not all_records:
+            if repo:
+                console.print(f"[yellow]No templates installed from repository '{repo}'[/yellow]")
+            else:
+                console.print("[yellow]No templates installed.[/yellow]")
+                console.print("\nTo install templates:")
+                console.print("  inskit template install <repo-url>")
+            raise typer.Exit(0)
+
+        # Output based on format
+        if format_type == "json":
+
+            output = {
+                "installations": [r.to_dict() for r in all_records],
+                "count": len(all_records),
+                "repositories": len(set(r.source_repo for r in all_records)),
+            }
+            console.print_json(data=output)
+
+        elif format_type == "simple":
+            for record in all_records:
+                console.print(f"{record.namespace}.{record.template_name}")
+
+        else:  # table format
+            # Group by repository
+            repos: dict = {}
+            for record in all_records:
+                repo_key = record.source_repo
+                if repo_key not in repos:
+                    repos[repo_key] = {
+                        "version": record.source_version,
+                        "namespace": record.namespace,
+                        "records": [],
+                    }
+                repos[repo_key]["records"].append(record)
+
+            # Display each repository
+            for repo_name, repo_data in repos.items():
+                console.print(f"\n[bold]Repository: {repo_name}[/bold] (v{repo_data['version']})")
+                console.print(f"[dim]Namespace: {repo_data['namespace']}[/dim]\n")
+
+                table = Table()
+                table.add_column("Template", style="cyan")
+                table.add_column("IDE", style="green")
+                table.add_column("Scope", style="yellow")
+                table.add_column("Installed", style="magenta")
+
+                if verbose:
+                    table.add_column("Path", style="dim")
+                    table.add_column("Checksum", style="dim")
+
+                for record in repo_data["records"]:
+                    installed_date = record.installed_at.strftime("%Y-%m-%d")
+                    row = [
+                        record.template_name,
+                        record.ide_type.value,
+                        record.scope.value,
+                        installed_date,
+                    ]
+
+                    if verbose:
+                        row.append(str(record.installed_path))
+                        row.append(record.checksum[:8] + "...")
+
+                    table.add_row(*row)
+
+                console.print(table)
+
+            # Summary
+            total_repos = len(repos)
+            total_templates = len(all_records)
+            console.print(f"\n[bold]Total:[/bold] {total_templates} templates from {total_repos} repository(ies)")
+
+    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_uninstall.py

@@ -0,0 +1,146 @@
+"""Template uninstall command."""
+
+from pathlib import Path
+from typing import Optional
+
+import typer
+from rich.console import Console
+from rich.prompt import Confirm
+
+from aiconfigkit.storage.template_library import TemplateLibraryManager
+from aiconfigkit.storage.template_tracker import TemplateInstallationTracker
+from aiconfigkit.utils.project import find_project_root
+
+console = Console()
+
+
+def uninstall_command(
+    repo_name: str = typer.Argument(..., help="Repository name or namespace to uninstall"),
+    scope: str = typer.Option(
+        "project",
+        "--scope",
+        "-s",
+        help="Which installation to remove (project or global)",
+    ),
+    template: Optional[str] = typer.Option(
+        None,
+        "--template",
+        "-t",
+        help="Uninstall specific template (not entire repository)",
+    ),
+    force: bool = typer.Option(
+        False,
+        "--force",
+        "-f",
+        help="Skip confirmation prompt",
+    ),
+    keep_files: bool = typer.Option(
+        False,
+        "--keep-files",
+        "-k",
+        help="Remove from tracking but keep files on disk",
+    ),
+) -> None:
+    """
+    Remove installed templates.
+
+    Example:
+        inskit template uninstall acme-templates
+        inskit template uninstall acme-templates --force
+        inskit template uninstall acme-templates --template test-command
+        inskit template uninstall acme-templates --keep-files
+    """
+    try:
+        # Validate scope
+        if scope not in ["project", "global"]:
+            console.print(f"[red]Error: Invalid scope '{scope}'. Must be 'project' or 'global'[/red]")
+            raise typer.Exit(1)
+
+        # Get tracker
+        if scope == "project":
+            try:
+                project_root = find_project_root()
+                if not project_root:
+                    console.print("[red]Error: Not in a project directory[/red]")
+                    raise typer.Exit(1)
+            except Exception:
+                console.print("[red]Error: Not in a project directory[/red]")
+                raise typer.Exit(1)
+            tracker = TemplateInstallationTracker.for_project(project_root)
+        else:
+            tracker = TemplateInstallationTracker.for_global()
+
+        # Load records
+        all_records = tracker.load_installation_records()
+
+        # Filter by repository name or namespace
+        repo_records = [r for r in all_records if r.source_repo == repo_name or r.namespace == repo_name]
+
+        if not repo_records:
+            console.print(f"[red]Error: Repository '{repo_name}' not found in {scope} installations[/red]")
+            console.print("\nInstalled repositories:")
+            repos = set(f"{r.source_repo} ({r.namespace})" for r in all_records)
+            for repo in sorted(repos):
+                console.print(f"  - {repo}")
+            raise typer.Exit(1)
+
+        # Filter by specific template if requested
+        if template:
+            repo_records = [r for r in repo_records if r.template_name == template]
+            if not repo_records:
+                console.print(f"[red]Error: Template '{template}' not found in repository '{repo_name}'[/red]")
+                raise typer.Exit(1)
+
+        # Show what will be removed
+        console.print("\n[bold]The following templates will be removed:[/bold]")
+        for record in repo_records:
+            console.print(f"  - {record.namespace}.{record.template_name} ({record.ide_type.value})")
+
+        # Confirm unless --force
+        if not force:
+            confirm_msg = f"Remove {len(repo_records)} template(s) from {repo_name}?"
+            if not Confirm.ask(confirm_msg, default=False):
+                console.print("[yellow]Uninstall cancelled[/yellow]")
+                raise typer.Exit(0)
+
+        # Remove templates
+        removed_count = 0
+        for record in repo_records:
+            console.print(f"Removing [cyan]{record.namespace}.{record.template_name}[/cyan]...", end=" ")
+
+            # Delete file if not keeping
+            if not keep_files:
+                try:
+                    file_path = Path(record.installed_path)
+                    if file_path.exists():
+                        file_path.unlink()
+                except Exception as e:
+                    console.print(f"[yellow]⚠️  (failed to delete file: {e})[/yellow]")
+                    continue
+
+            # Remove from tracking
+            tracker.remove_installation(record.id)
+            removed_count += 1
+            console.print("[green]✓[/green]")
+
+        # Clean up library if removing entire repository and no templates remain
+        if not template:
+            remaining = tracker.get_installations_by_namespace(repo_records[0].namespace)
+            if not remaining:
+                try:
+                    library_manager = TemplateLibraryManager()
+                    library_manager.remove_repository(repo_records[0].namespace)
+                    console.print(f"\n[dim]Removed repository from library: {repo_records[0].namespace}[/dim]")
+                except Exception:
+                    pass  # Library removal is optional
+
+        console.print(f"\n[green]✓ Uninstalled {removed_count} template(s)[/green]")
+
+    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)