devsync 0.5.5__py3-none-any.whl

aiconfigkit/cli/download.py

@@ -0,0 +1,274 @@
+"""Download command for fetching instructions into the library."""
+
+import shutil
+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 calculate_file_checksum
+from aiconfigkit.core.git_operations import GitOperations, RepositoryOperationError
+from aiconfigkit.core.models import LibraryInstruction
+from aiconfigkit.core.repository import RepositoryParser
+from aiconfigkit.storage.library import LibraryManager
+from aiconfigkit.utils.ui import print_error, print_success
+
+console = Console()
+
+app = typer.Typer()
+
+
+def download_instructions(
+    repo: str,
+    force: bool = False,
+    alias: Optional[str] = None,
+    ref: Optional[str] = None,
+) -> int:
+    """
+    Download instructions from a repository into the local library.
+
+    Args:
+        repo: Repository URL or local path
+        force: If True, re-download even if already in library
+        alias: User-friendly alias for this source (auto-generated if not provided)
+        ref: Git reference (tag, branch, or commit) to download
+
+    Returns:
+        Exit code (0 = success)
+    """
+    library = LibraryManager()
+
+    # Display what we're downloading
+    if ref:
+        console.print(f"\n[bold]Downloading from:[/bold] {repo} [bold cyan]@{ref}[/bold cyan]\n")
+    else:
+        console.print(f"\n[bold]Downloading from:[/bold] {repo}\n")
+
+    # Determine if local or remote
+    is_local = GitOperations.is_local_path(repo)
+    temp_repo_path = None  # Track temp directory for cleanup
+    ref_type = None  # Track the reference type
+
+    try:
+        # Validate and detect ref type for remote repositories
+        if ref and not is_local:
+            try:
+                validated_ref, ref_type = GitOperations.detect_ref_type(repo, ref)
+                ref = validated_ref  # Use the validated reference
+            except RepositoryOperationError as e:
+                if e.error_type == "invalid_reference":
+                    print_error(f"Invalid reference '{ref}': not found in repository")
+                    return 1
+                elif e.error_type == "network_error":
+                    print_error("Network error: unable to access repository")
+                    return 1
+                else:
+                    print_error(f"Failed to validate reference: {e}")
+                    return 1
+
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            console=console,
+        ) as progress:
+            if is_local:
+                if ref:
+                    print_error("Version references (--ref) are not supported for local repositories")
+                    return 1
+                progress.add_task("Loading local repository...", total=None)
+                repo_path = Path(repo).resolve()
+            else:
+                if ref:
+                    task = progress.add_task(f"Cloning repository at {ref}...", total=None)
+                else:
+                    task = progress.add_task("Cloning repository...", total=None)
+
+                # Use new clone_at_ref for versioned cloning
+                import tempfile
+                from pathlib import Path as PathlibPath
+
+                temp_dir = PathlibPath(tempfile.mkdtemp(prefix="instructionkit-"))
+
+                try:
+                    GitOperations.clone_at_ref(repo, temp_dir, ref, ref_type)
+                    repo_path = temp_dir
+                    temp_repo_path = repo_path  # Save for cleanup
+                except RepositoryOperationError as e:
+                    if temp_dir.exists():
+                        shutil.rmtree(temp_dir, ignore_errors=True)
+                    print_error(f"Failed to clone repository: {e}")
+                    return 1
+
+                progress.update(task, completed=True)
+
+            # Parse repository
+            task = progress.add_task("Parsing repository metadata...", total=None)
+            parser = RepositoryParser(repo_path)
+            repository = parser.parse()
+            repository.url = repo
+            progress.update(task, completed=True)
+
+        # Generate versioned namespace if ref is specified
+        repo_name = repository.metadata.get("name", "Unknown")
+        if ref:
+            repo_namespace = library.get_versioned_namespace(repo, ref)
+        else:
+            repo_namespace = library.get_repo_namespace(repo, repo_name)
+
+        # Check if this specific version already exists
+        existing_repo = library.get_repository(repo_namespace)
+
+        if existing_repo and not force:
+            if ref:
+                print_error(
+                    f"Version '{ref}' of '{repo_name}' already exists in library.\n" f"Use --force to re-download."
+                )
+            else:
+                print_error(
+                    f"Source '{existing_repo.alias or repo_name}' already exists in library.\n"
+                    f"Use --force to re-download."
+                )
+            return 1
+
+        # Prepare library instructions
+        library_instructions = []
+        library_repo_dir = library.library_dir / repo_namespace
+        repo_dir = library_repo_dir / "instructions"
+        repo_dir.mkdir(parents=True, exist_ok=True)
+
+        console.print("\n[bold]Copying instructions to library...[/bold]\n")
+
+        for instruction in repository.instructions:
+            # Copy instruction file to library
+            source_file = repo_path / instruction.file_path
+            if not source_file.exists():
+                print_error(f"Warning: File not found: {instruction.file_path}")
+                continue
+
+            dest_file = repo_dir / f"{instruction.name}.md"
+            shutil.copy2(source_file, dest_file)
+
+            # Calculate checksum
+            checksum = calculate_file_checksum(str(dest_file))
+
+            # Create library instruction
+            lib_inst = LibraryInstruction(
+                id=f"{repo_namespace}/{instruction.name}",
+                name=instruction.name,
+                description=instruction.description,
+                repo_namespace=repo_namespace,
+                repo_url=repo,
+                repo_name=repo_name,
+                author=repository.metadata.get("author", "Unknown"),
+                version=repository.metadata.get("version", "1.0.0"),
+                file_path=str(dest_file),
+                tags=instruction.tags,
+                downloaded_at=datetime.now(),
+                checksum=checksum,
+            )
+            library_instructions.append(lib_inst)
+
+            console.print(f"  ✓ {instruction.name}")
+
+        # Preserve .git directory for Git sources to enable updates
+        if not is_local:
+            git_dir = repo_path / ".git"
+            if git_dir.exists():
+                dest_git_dir = library_repo_dir / ".git"
+                if dest_git_dir.exists():
+                    shutil.rmtree(dest_git_dir)
+                shutil.copytree(git_dir, dest_git_dir)
+
+        # Add to library
+        library_repo = library.add_repository(
+            repo_name=repo_name,
+            repo_description=repository.metadata.get("description", ""),
+            repo_url=repo,
+            repo_author=repository.metadata.get("author", "Unknown"),
+            repo_version=repository.metadata.get("version", "1.0.0"),
+            instructions=library_instructions,
+            alias=alias,
+            namespace=repo_namespace,
+        )
+
+        # Build success message
+        success_msg = f"\n✓ Downloaded {len(library_instructions)} instruction(s) from '{repo_name}'"
+        if ref and ref_type:
+            ref_type_badge = {"tag": "📌", "branch": "🌿", "commit": "📍"}.get(ref_type.value, "")
+            success_msg += f" {ref_type_badge} {ref}"
+        success_msg += f"\n  Alias: {library_repo.alias}\n" f"  Namespace: {repo_namespace}\n"
+        if ref:
+            ref_labels = {"tag": "Tag", "branch": "Branch", "commit": "Commit"}
+            ref_label = ref_labels.get(ref_type.value if ref_type else "", "Ref")
+            success_msg += f"  {ref_label}: {ref}\n"
+        success_msg += (
+            "  Use 'inskit list library' to see all downloaded instructions\n"
+            "  Use 'inskit install' to install into your AI tools"
+        )
+        print_success(success_msg)
+
+        return 0
+
+    except FileNotFoundError as e:
+        print_error(f"Repository metadata file not found: {e}")
+        return 1
+    except Exception as e:
+        print_error(f"Failed to download: {e}")
+        return 1
+    finally:
+        # Clean up temp directory if not local
+        if temp_repo_path and not is_local:
+            GitOperations.cleanup_repository(temp_repo_path, is_temp=True)
+
+
+@app.command(name="download")
+def download_command(
+    repo: str = typer.Option(
+        ...,
+        "--repo",
+        "-r",
+        help="Repository URL or local path to download from",
+    ),
+    ref: Optional[str] = typer.Option(
+        None,
+        "--ref",
+        help="Git reference (tag, branch, or commit) to download",
+    ),
+    force: bool = typer.Option(
+        False,
+        "--force",
+        "-f",
+        help="Re-download even if already in library",
+    ),
+) -> None:
+    """
+    Download instructions from a repository into your local library.
+
+    This downloads and caches instructions locally without installing them.
+    After downloading, use 'instructionkit install' to select and install
+    instructions into your AI coding tools.
+
+    Examples:
+        # Download from GitHub (default branch)
+        instructionkit download --repo https://github.com/company/instructions
+
+        # Download specific tag version
+        instructionkit download --repo https://github.com/company/instructions --ref v1.0.0
+
+        # Download from specific branch
+        instructionkit download --repo https://github.com/company/instructions --ref main
+
+        # Download from specific commit
+        instructionkit download --repo https://github.com/company/instructions --ref abc123def
+
+        # Download from local folder (no --ref support)
+        instructionkit download --repo ./my-instructions
+
+        # Force re-download
+        instructionkit download --repo https://github.com/company/instructions --force
+    """
+    exit_code = download_instructions(repo=repo, ref=ref, force=force)
+    raise typer.Exit(code=exit_code)

aiconfigkit/cli/install.py

@@ -0,0 +1,237 @@
+"""Install command implementation."""
+
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+
+from rich.console import Console
+from rich.progress import Progress, SpinnerColumn, TextColumn
+
+from aiconfigkit.ai_tools.base import AITool
+from aiconfigkit.ai_tools.detector import get_detector
+from aiconfigkit.core.checksum import ChecksumValidator
+from aiconfigkit.core.conflict_resolution import (
+    ConflictResolver,
+)
+from aiconfigkit.core.git_operations import GitOperations
+from aiconfigkit.core.models import (
+    ConflictResolution,
+    InstallationRecord,
+    InstallationScope,
+)
+from aiconfigkit.core.repository import RepositoryParser
+from aiconfigkit.storage.tracker import InstallationTracker
+from aiconfigkit.utils.project import find_project_root
+from aiconfigkit.utils.validation import is_valid_git_url, normalize_repo_url
+
+console = Console()
+
+
+def install_instruction(
+    name: str,
+    repo: str,
+    tool: Optional[str] = None,
+    conflict_strategy: str = "skip",
+    bundle: bool = False,
+) -> int:
+    """
+    Install an instruction from a Git repository.
+
+    All installations are at project level.
+
+    Args:
+        name: Instruction or bundle name to install
+        repo: Git repository URL
+        tool: AI tool to install to (cursor, copilot, etc.)
+        conflict_strategy: How to handle conflicts (skip, rename, overwrite)
+        bundle: Whether this is a bundle installation
+
+    Returns:
+        Exit code (0 for success, 1 for error)
+    """
+    # Validate repository URL
+    if not is_valid_git_url(repo):
+        console.print(f"[red]Error:[/red] Invalid Git repository URL: {repo}")
+        return 1
+
+    # Parse conflict strategy
+    try:
+        strategy = ConflictResolution(conflict_strategy.lower())
+    except ValueError:
+        console.print(
+            f"[red]Error:[/red] Invalid conflict strategy: {conflict_strategy}. "
+            f"Must be 'skip', 'rename', or 'overwrite'."
+        )
+        return 1
+
+    # Always use project scope
+    install_scope = InstallationScope.PROJECT
+
+    # Detect project root
+    project_root = find_project_root()
+    if project_root is None:
+        console.print(
+            "[red]Error:[/red] Could not detect project root. "
+            "Make sure you're running this command from within a project directory."
+        )
+        return 1
+    console.print(f"Detected project root: [cyan]{project_root}[/cyan]")
+
+    # Check Git is installed
+    if not GitOperations.is_git_installed():
+        console.print("[red]Error:[/red] Git is not installed. " "Please install Git and try again.")
+        return 1
+
+    # Determine AI tool
+    ai_tool = _get_ai_tool(tool)
+    if ai_tool is None:
+        console.print("[red]Error:[/red] Could not determine AI coding tool. " "Please specify with --tool flag.")
+        return 1
+
+    # Validate AI tool
+    validation_error = ai_tool.validate_installation()
+    if validation_error:
+        console.print(f"[red]Error:[/red] {validation_error}")
+        return 1
+
+    console.print(f"Installing to [cyan]{ai_tool.tool_name}[/cyan]...")
+
+    # Clone repository or use local path
+    git_ops = GitOperations()
+    is_local = git_ops.is_local_path(repo)
+
+    if is_local:
+        # Use local directory directly
+        try:
+            repo_path = git_ops.clone_repository(repo)
+            console.print(f"Using local directory: [cyan]{repo_path}[/cyan]")
+        except Exception as e:
+            console.print(f"[red]Error:[/red] Failed to access local directory: {e}")
+            return 1
+    else:
+        # Clone remote repository
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            console=console,
+        ) as progress:
+            progress.add_task(description="Cloning repository...", total=None)
+
+            try:
+                repo_path = git_ops.clone_repository(repo)
+            except Exception as e:
+                console.print(f"[red]Error:[/red] Failed to clone repository: {e}")
+                return 1
+
+    try:
+        # Parse repository
+        parser = RepositoryParser(repo_path)
+        repository = parser.parse()
+        repository.url = normalize_repo_url(repo)
+
+        # Get instructions to install
+        if bundle:
+            instructions = parser.get_instructions_for_bundle(name)
+            console.print(f"Installing bundle '[cyan]{name}[/cyan]' " f"with {len(instructions)} instruction(s)...")
+        else:
+            instruction = parser.get_instruction_by_name(name)
+            if not instruction:
+                console.print(f"[red]Error:[/red] Instruction '{name}' not found in repository")
+                return 1
+            instructions = [instruction]
+
+        # Install instructions
+        tracker = InstallationTracker()
+        resolver = ConflictResolver(default_strategy=strategy)
+        checksum_validator = ChecksumValidator()
+
+        installed_count = 0
+        skipped_count = 0
+
+        for instruction in instructions:
+            # Check if already exists
+            target_path = ai_tool.get_instruction_path(instruction.name, install_scope, project_root)
+
+            if target_path.exists():
+                # Handle conflict
+                if strategy == ConflictResolution.SKIP:
+                    console.print(f"  [yellow]Skipped:[/yellow] {instruction.name} (already exists)")
+                    skipped_count += 1
+                    continue
+                elif strategy == ConflictResolution.RENAME:
+                    conflict_info = resolver.resolve(instruction.name, target_path, strategy)
+                    if conflict_info.new_path is None:
+                        console.print(f"  [red]Error:[/red] Failed to rename {instruction.name}")
+                        continue
+                    target_path = Path(conflict_info.new_path)
+                    console.print(f"  [yellow]Renamed:[/yellow] {instruction.name} -> " f"{target_path.name}")
+                elif strategy == ConflictResolution.OVERWRITE:
+                    console.print(f"  [yellow]Overwriting:[/yellow] {instruction.name}")
+
+            # Validate checksum
+            try:
+                checksum_validator.validate(instruction.content, instruction.checksum)
+            except Exception as e:
+                console.print(f"  [red]Error:[/red] {instruction.name}: {e}")
+                continue
+
+            # Install instruction
+            try:
+                # Write file
+                target_path.parent.mkdir(parents=True, exist_ok=True)
+                target_path.write_text(instruction.content, encoding="utf-8")
+
+                # Track installation
+                record = InstallationRecord(
+                    instruction_name=instruction.name,
+                    ai_tool=ai_tool.tool_type,
+                    source_repo=repository.url,
+                    installed_path=str(target_path),
+                    installed_at=datetime.now(),
+                    checksum=instruction.checksum,
+                    bundle_name=name if bundle else None,
+                    scope=install_scope,
+                )
+                tracker.add_installation(record, project_root)
+
+                console.print(f"  [green]✓[/green] Installed: {instruction.name}")
+                installed_count += 1
+
+            except Exception as e:
+                console.print(f"  [red]Error:[/red] {instruction.name}: {e}")
+
+        # Summary
+        console.print()
+        console.print(f"[green]Successfully installed {installed_count} instruction(s)[/green]")
+        if skipped_count > 0:
+            console.print(f"[yellow]Skipped {skipped_count} existing instruction(s)[/yellow]")
+
+        return 0
+
+    finally:
+        # Clean up cloned repository (but not local directories)
+        GitOperations.cleanup_repository(repo_path, is_temp=not is_local)
+
+
+def _get_ai_tool(tool_name: Optional[str]) -> Optional[AITool]:
+    """
+    Get AI tool instance from name.
+
+    Args:
+        tool_name: Name of AI tool (or None to auto-detect)
+
+    Returns:
+        AITool instance or None if not found
+    """
+    detector = get_detector()
+
+    if tool_name:
+        # Use specified tool
+        tool = detector.get_tool_by_name(tool_name)
+        if tool and not tool.is_installed():
+            console.print(f"[yellow]Warning:[/yellow] {tool.tool_name} is not installed")
+            return None
+        return tool
+
+    # Auto-detect: find first installed tool
+    return detector.get_primary_tool()