lite-kits 0.1.1__py3-none-any.whl → 0.3.2__py3-none-any.whl

lite_kits/core/__init__.py

@@ -1,13 +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

@@ -145,7 +145,7 @@ def show_static_banner():
 def show_loading_spinner(message="Loading kits..."):
     with console.status(f"[bold bright_cyan]{message}", spinner="dots"):
         time.sleep(1.5)
-    console.print("[green]✓ Done![/green]")
+    console.print("[green][OK] Done![/green]")
 
 if __name__ == "__main__":
     console.clear()

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,177 @@
+"""
+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[List[str]] = None) -> List[str]:
+        """
+        Auto-detect which AI agents are present.
+
+        Args:
+            preferred: List of explicit agent preferences (overrides auto-detection)
+
+        Returns:
+            List of agent names sorted by priority
+        """
+        # If explicit preferences, validate and return
+        if preferred:
+            validated = []
+            for agent_name in preferred:
+                config = self.manifest.get_agent_config(agent_name)
+                if not config:
+                    # Build helpful error message with valid options
+                    agents = self.manifest.manifest.get('agents', {})
+                    valid_agents = [
+                        name for name, cfg in agents.items()
+                        if cfg.get('supported', False)
+                    ]
+                    valid_list = ', '.join(valid_agents)
+                    raise ValueError(
+                        f"Unknown agent: '{agent_name}'\n"
+                        f"Valid options: {valid_list}"
+                    )
+                if not config.get('supported', False):
+                    raise ValueError(f"Agent not supported: {agent_name}")
+                validated.append(agent_name)
+            return validated
+
+        # 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[List[str]] = None) -> List[str]:
+        """
+        Determine which shells to install for.
+
+        Args:
+            preferred: List of explicit shell preferences (overrides auto-detection)
+
+        Returns:
+            List of shell names
+        """
+        # Shell aliases for common shorthands
+        shell_aliases = {
+            'ps': 'powershell',
+            'pwsh': 'powershell',
+            'sh': 'bash',
+        }
+
+        # If explicit preferences, validate and return
+        if preferred:
+            validated = []
+            for shell_name in preferred:
+                # Normalize shell name using aliases
+                normalized = shell_aliases.get(shell_name.lower(), shell_name.lower())
+
+                config = self.manifest.manifest.get('shells', {}).get(normalized)
+                if not config:
+                    # Build helpful error message with valid options
+                    shells_config = self.manifest.manifest.get('shells', {})
+                    valid_shells = [
+                        name for name, cfg in shells_config.items()
+                        if cfg.get('supported', False)
+                    ]
+                    valid_list = ', '.join(valid_shells)
+                    raise ValueError(
+                        f"Unknown shell: '{shell_name}'\n"
+                        f"Valid options: {valid_list}\n"
+                        f"Aliases: ps/pwsh->powershell, sh->bash"
+                    )
+                if not config.get('supported', False):
+                    raise ValueError(f"Shell not supported: {normalized}")
+                validated.append(normalized)
+            return validated
+
+        # 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)