lite-kits 0.1.0__py3-none-any.whl → 0.3.1__py3-none-any.whl

lite_kits/core/__init__.py

@@ -0,0 +1,19 @@
+"""Core modules for lite-kits."""
+
+from .banner import diagonal_reveal_banner, show_loading_spinner, show_static_banner
+from .conflict_checker import ConflictChecker
+from .detector import Detector
+from .installer import Installer
+from .manifest import KitManifest
+from .validator import Validator
+
+__all__ = [
+    "diagonal_reveal_banner",
+    "show_loading_spinner",
+    "show_static_banner",
+    "ConflictChecker",
+    "Detector",
+    "Installer",
+    "KitManifest",
+    "Validator",
+]

lite_kits/core/banner.py

@@ -0,0 +1,160 @@
+from rich.console import Console
+from rich.text import Text
+from rich.live import Live
+import time
+import sys
+
+console = Console()
+
+BANNER = """
+██╗     ██╗████████╗███████╗      ██╗  ██╗██╗████████╗███████╗
+██║     ██║╚══██╔══╝██╔════╝      ██║ ██╔╝██║╚══██╔══╝██╔════╝
+██║     ██║   ██║   █████╗  █████╗█████╔╝ ██║   ██║   ███████╗
+██║     ██║   ██║   ██╔══╝  ╚════╝██╔═██╗ ██║   ██║   ╚════██║
+███████╗██║   ██║   ███████╗      ██║  ██╗██║   ██║   ███████║
+╚══════╝╚═╝   ╚═╝   ╚══════╝      ╚═╝  ╚═╝╚═╝   ╚═╝   ╚══════╝
+"""
+
+TAGLINE = "Lightweight enhancement kits for spec-driven development."
+
+RAINBOW_STOPS = [
+    (255,   0,   0),   # Red
+    (255, 127,   0),   # Orange
+    (255, 255,   0),   # Yellow
+    (0,   255,   0),   # Green
+    (0,     0, 255),   # Blue
+    (75,    0, 130),   # Indigo
+    (148,   0, 211),   # Violet
+    (255, 105, 180),   # Pink
+]
+
+def interpolate_multi_color(stops, steps):
+    gradient = []
+    n_segments = len(stops) - 1
+    steps_per_segment = steps // n_segments
+    for i in range(n_segments):
+        start = stops[i]
+        end = stops[i+1]
+        for j in range(steps_per_segment):
+            t = j / steps_per_segment
+            r = int(start[0] + (end[0] - start[0]) * t)
+            g = int(start[1] + (end[1] - start[1]) * t)
+            b = int(start[2] + (end[2] - start[2]) * t)
+            gradient.append(f"#{r:02X}{g:02X}{b:02X}")
+    gradient.append(f"#{stops[-1][0]:02X}{stops[-1][1]:02X}{stops[-1][2]:02X}")
+    return gradient
+
+def get_diagonal_steps(text=BANNER):
+    lines = text.strip().split('\n')
+    height = len(lines)
+    width = max(len(line) for line in lines)
+    return height + width - 2
+
+def apply_diagonal_gradient(text=BANNER, offset=0, steps_override=None):
+    lines = text.strip().split('\n')
+    height = len(lines)
+    width = max(len(line) for line in lines)
+    steps = steps_override if steps_override else height + width - 2
+    gradient = interpolate_multi_color(RAINBOW_STOPS, steps + 1)
+    result = Text()
+    for line_idx, line in enumerate(lines):
+        for char_idx, char in enumerate(line):
+            diag_idx = line_idx + char_idx + offset
+            color_idx = min(diag_idx, len(gradient) - 1)
+            color = gradient[color_idx]
+            result.append(char, style=f"bold {color}")
+        result.append('\n')
+    return result
+
+def typewriter_effect(text=TAGLINE, delay=0.02, cursor_blink_rate=0.4, blink_cycles=2):
+    """Display retro terminal typewriter animation with dim text via ANSI codes."""
+    DIM = '\033[2m'
+    RESET = '\033[0m'
+    for i in range(len(text) + 1):
+        sys.stdout.write('\r' + DIM + text[:i] + RESET)
+        sys.stdout.flush()
+        time.sleep(delay)
+    for _ in range(blink_cycles):
+        sys.stdout.write('\r' + DIM + text + '█' + RESET)
+        sys.stdout.flush()
+        time.sleep(cursor_blink_rate)
+        sys.stdout.write('\r' + DIM + text + ' ' + RESET)
+        sys.stdout.flush()
+        time.sleep(cursor_blink_rate)
+    sys.stdout.write('\n')
+
+
+def diagonal_reveal_banner(text=BANNER, steps_override=None, fps=56):
+    """Reveal the banner diagonally from top-left to bottom-right, with gradient following the reveal."""
+    console.print()
+    lines = text.strip().split('\n')
+    height = len(lines)
+    width = max(len(line) for line in lines)
+    steps = steps_override if steps_override else height + width - 2
+    gradient = interpolate_multi_color(RAINBOW_STOPS, steps + 1)
+
+    # Prepare a matrix of characters and their diagonal indices
+    char_matrix = []
+    diag_indices = []
+    for line_idx, line in enumerate(lines):
+        row = []
+        diag_row = []
+        for char_idx, char in enumerate(line):
+            row.append(char)
+            diag_row.append(line_idx + char_idx)
+        char_matrix.append(row)
+        diag_indices.append(diag_row)
+
+    # Reveal animation
+    try:
+        with Live(console=console, refresh_per_second=fps, transient=True) as live:
+            for reveal_diag in range(steps + 1):
+                result = Text()
+                for line_idx, row in enumerate(char_matrix):
+                    for char_idx, char in enumerate(row):
+                        diag_idx = diag_indices[line_idx][char_idx]
+                        if diag_idx <= reveal_diag:
+                            color = gradient[min(diag_idx, len(gradient)-1)]
+                            result.append(char, style=f"bold {color}")
+                        else:
+                            result.append(" ")
+                    result.append('\n')
+                live.update(result)
+                time.sleep(1.0 / fps)
+    except KeyboardInterrupt:
+        pass
+
+    # Show final static gradient
+    result = Text()
+    for line_idx, row in enumerate(char_matrix):
+        for char_idx, char in enumerate(row):
+            diag_idx = diag_indices[line_idx][char_idx]
+            color = gradient[min(diag_idx, len(gradient)-1)]
+            result.append(char, style=f"bold {color}")
+        result.append('\n')
+    console.print(result)
+    typewriter_effect()
+
+def show_static_banner():
+    console.print()
+    steps = get_diagonal_steps()
+    gradient_text = apply_diagonal_gradient(offset=0, steps_override=steps)
+    console.print(gradient_text)
+    console.print(f"{TAGLINE}", style="dim")
+
+def show_loading_spinner(message="Loading kits..."):
+    with console.status(f"[bold bright_cyan]{message}", spinner="dots"):
+        time.sleep(1.5)
+    console.print("[green][OK] Done![/green]")
+
+if __name__ == "__main__":
+    console.clear()
+    console.print("[bold yellow]\nDemo 1: Loading Spinner[/bold yellow]\n")
+    show_loading_spinner()
+    time.sleep(1)
+    console.print("[bold yellow]Demo 2: Diagonal Reveal Animation[/bold yellow]\n")
+    diagonal_reveal_banner()
+    time.sleep(1)
+    console.print("[bold yellow]Demo 3: Status Banner[/bold yellow]\n")
+    show_static_banner()
+    console.print()

lite_kits/core/conflict_checker.py

@@ -0,0 +1,115 @@
+"""
+File conflict detection for installer.
+
+Checks for existing files that would be overwritten.
+"""
+
+from pathlib import Path
+from typing import Dict, List
+
+from .manifest import KitManifest
+
+
+class ConflictChecker:
+    """Detects file conflicts before installation."""
+
+    def __init__(self, target_dir: Path, kits_dir: Path, manifest: KitManifest):
+        """
+        Initialize conflict checker.
+
+        Args:
+            target_dir: Target project directory
+            kits_dir: Kits source directory
+            manifest: Loaded kit manifest
+        """
+        self.target_dir = target_dir
+        self.kits_dir = kits_dir
+        self.manifest = manifest
+
+    def check_conflicts(
+        self,
+        kits: List[str],
+        agents: List[str],
+        shells: List[str]
+    ) -> Dict:
+        """
+        Check for file conflicts.
+
+        Args:
+            kits: List of kit names to check
+            agents: List of agent names
+            shells: List of shell names
+
+        Returns:
+            Dict with conflict details
+        """
+        result = {
+            'conflicts': [],
+            'overwrites': [],
+            'safe': [],
+            'has_conflicts': False
+        }
+
+        for kit_name in kits:
+            # Check agent files
+            for agent in agents:
+                self._check_file_group(kit_name, agent, result)
+
+            # Check shell files
+            for shell in shells:
+                self._check_file_group(kit_name, shell, result)
+
+            # Check agent-agnostic files
+            all_files = self.manifest.get_kit_files(kit_name, agent=None)
+            for file_info in all_files:
+                # Skip agent/shell-specific
+                if file_info.get('type') in ['command', 'prompt', 'script']:
+                    continue
+
+                self._check_file(file_info, result)
+
+        result['has_conflicts'] = len(result['conflicts']) > 0
+        return result
+
+    def _check_file_group(self, kit_name: str, agent_or_shell: str, result: Dict):
+        """Check a group of files for an agent/shell."""
+        files = self.manifest.get_kit_files(kit_name, agent=agent_or_shell)
+
+        for file_info in files:
+            if file_info.get('status') == 'planned':
+                continue
+
+            self._check_file(file_info, result)
+
+    def _check_file(self, file_info: Dict, result: Dict):
+        """Check a single file for conflicts."""
+        target_path = self.target_dir / file_info['path']
+
+        if not target_path.exists():
+            if file_info['path'] not in result['safe']:
+                result['safe'].append(file_info['path'])
+            return
+
+        # File exists, check if content differs
+        source_path = self.kits_dir / file_info['source']
+
+        if not source_path.exists():
+            return
+
+        try:
+            source_content = source_path.read_text(encoding='utf-8')
+            target_content = target_path.read_text(encoding='utf-8')
+
+            if source_content != target_content:
+                if file_info['path'] not in result['conflicts']:
+                    result['conflicts'].append(file_info['path'])
+                    result['overwrites'].append({
+                        'path': file_info['path'],
+                        'source': file_info['source'],
+                        'size_current': target_path.stat().st_size,
+                        'size_new': source_path.stat().st_size,
+                    })
+        except Exception:
+            # If can't read/compare, treat as conflict
+            if file_info['path'] not in result['conflicts']:
+                result['conflicts'].append(file_info['path'])

lite_kits/core/detector.py

@@ -0,0 +1,140 @@
+"""
+Agent and shell detection for lite-kits installer.
+
+Detects which AI agents and shell environments are present in a project.
+"""
+
+from pathlib import Path
+from typing import List, Optional
+
+from .manifest import KitManifest
+
+
+class Detector:
+    """Detects agents and shells in target project."""
+
+    def __init__(self, target_dir: Path, manifest: KitManifest):
+        """
+        Initialize detector.
+
+        Args:
+            target_dir: Target project directory
+            manifest: Loaded kit manifest
+        """
+        self.target_dir = target_dir
+        self.manifest = manifest
+
+    def detect_agents(self, preferred: Optional[str] = None) -> List[str]:
+        """
+        Auto-detect which AI agents are present.
+
+        Args:
+            preferred: Explicit agent preference (overrides auto-detection)
+
+        Returns:
+            List of agent names sorted by priority
+        """
+        # If explicit preference, validate and return
+        if preferred:
+            config = self.manifest.get_agent_config(preferred)
+            if not config:
+                raise ValueError(f"Unknown agent: {preferred}")
+            if not config.get('supported', False):
+                raise ValueError(f"Agent not supported: {preferred}")
+            return [preferred]
+
+        # Auto-detect from manifest
+        detected = []
+        agents = self.manifest.manifest.get('agents', {})
+
+        for agent_name, config in agents.items():
+            if not config.get('supported', False):
+                continue
+
+            marker_dir = self.target_dir / config['marker_dir']
+            # Check if marker dir exists OR its parent exists (for nested dirs like .github/prompts)
+            # This allows detection even if subdirectory doesn't exist yet (will be created on install)
+            parent_dir = marker_dir.parent
+            if marker_dir.exists() or (parent_dir != self.target_dir and parent_dir.exists()):
+                detected.append({
+                    'name': agent_name,
+                    'priority': config.get('priority', 999)
+                })
+
+        # Sort by priority (lower = higher)
+        detected.sort(key=lambda x: x['priority'])
+        return [agent['name'] for agent in detected]
+
+    def detect_shells(self, preferred: Optional[str] = None) -> List[str]:
+        """
+        Determine which shells to install for.
+
+        Args:
+            preferred: Explicit shell preference (overrides auto-detection)
+
+        Returns:
+            List of shell names
+        """
+        # If explicit preference, validate and return
+        if preferred:
+            config = self.manifest.manifest.get('shells', {}).get(preferred)
+            if not config:
+                raise ValueError(f"Unknown shell: {preferred}")
+            if not config.get('supported', False):
+                raise ValueError(f"Shell not supported: {preferred}")
+            return [preferred]
+
+        # Check if shell detection is enabled
+        options = self.manifest.manifest.get('options', {})
+        if not options.get('auto_detect_shells', True):
+            return []
+
+        # Get all supported shells
+        shells_config = self.manifest.manifest.get('shells', {})
+        detected = []
+
+        for shell_name, config in shells_config.items():
+            if not config.get('supported', False):
+                continue
+
+            detected.append({
+                'name': shell_name,
+                'priority': config.get('priority', 999)
+            })
+
+        # Sort by priority
+        detected.sort(key=lambda x: x['priority'])
+
+        # Return all or just primary based on options
+        if options.get('prefer_all_shells', False):
+            return [shell['name'] for shell in detected]
+
+        return [detected[0]['name']] if detected else []
+
+    def is_spec_kit_project(self) -> bool:
+        """
+        Check if target is a spec-kit project.
+
+        Returns:
+            True if spec-kit markers found
+        """
+        spec_config = self.manifest.manifest.get('spec_kit', {})
+        markers = spec_config.get('markers', [])
+        require_any = spec_config.get('require_any', True)
+
+        found = []
+        for marker in markers:
+            path = self.target_dir / marker['path']
+
+            if marker.get('type') == 'directory':
+                if path.is_dir():
+                    found.append(marker['path'])
+            else:
+                if path.exists():
+                    found.append(marker['path'])
+
+        # Check requirement
+        if require_any:
+            return len(found) > 0
+
+        return len(found) == len(markers)