refactor: simplify Component architecture and move shared logic to base class

* Component Base Class:
  * Add constructor parameter for component subdirectory
  * Move file discovery utilities to base class to avoid repetition in subclasses
  * Same for validate_prerequisites, get_files_to_install, get_settings_modifications methods
  * Split install method into _install and _post_install for better separation of concerns
  * Add error handling wrapper around _install method

* All Component Subclasses:
  * Remove duplicate code now handled by base class
  * Use shared file discovery and installation logic
  * Simplify metadata updates using base class methods
  * Leverage base class file handling and validation

* Hooks Component:
  * Fix the logic for handling both placeholder and actual hooks scenarios

* MCP Component:
  * Fix npm package names and installation commands

setup/base/component.py

@@ -6,12 +6,16 @@ from abc import ABC, abstractmethod
 from typing import List, Dict, Tuple, Optional, Any
 from pathlib import Path
 import json
+from ..managers.file_manager import FileManager
+from ..managers.settings_manager import SettingsManager
+from ..utils.logger import get_logger
+from ..utils.security import SecurityValidator
 
 
 class Component(ABC):
     """Base class for all installable components"""
     
-    def __init__(self, install_dir: Optional[Path] = None):
+    def __init__(self, install_dir: Optional[Path] = None, component_subdir: Path = Path('')):
         """
         Initialize component with installation directory
         
@@ -20,10 +24,11 @@ class Component(ABC):
         """
         from .. import DEFAULT_INSTALL_DIR
         self.install_dir = install_dir or DEFAULT_INSTALL_DIR
-        self._metadata = None
-        self._dependencies = None
-        self._files_to_install = None
-        self._settings_modifications = None
+        self.settings_manager = SettingsManager(self.install_dir)
+        self.logger = get_logger()
+        self.component_files = self._discover_component_files()
+        self.file_manager = FileManager()
+        self.install_component_subdir = self.install_dir / component_subdir
     
     @abstractmethod
     def get_metadata(self) -> Dict[str, str]:
@@ -39,17 +44,58 @@ class Component(ABC):
         """
         pass
     
-    @abstractmethod
-    def validate_prerequisites(self) -> Tuple[bool, List[str]]:
+    def validate_prerequisites(self, installSubPath: Optional[Path] = None) -> Tuple[bool, List[str]]:
         """
         Check prerequisites for this component
         
         Returns:
             Tuple of (success: bool, error_messages: List[str])
         """
-        pass
+        errors = []
+
+        # Check if we have read access to source files
+        source_dir = self._get_source_dir()
+        if not source_dir or (source_dir and not source_dir.exists()):
+            errors.append(f"Source directory not found: {source_dir}")
+            return False, errors
+
+        # Check if all required framework files exist
+        missing_files = []
+        for filename in self.component_files:
+            source_file = source_dir / filename
+            if not source_file.exists():
+                missing_files.append(filename)
+
+        if missing_files:
+            errors.append(f"Missing component files: {missing_files}")
+
+        # Check write permissions to install directory
+        has_perms, missing = SecurityValidator.check_permissions(
+            self.install_dir, {'write'}
+        )
+        if not has_perms:
+            errors.append(f"No write permissions to {self.install_dir}: {missing}")
+
+        # Validate installation target
+        is_safe, validation_errors = SecurityValidator.validate_installation_target(self.install_component_subdir)
+        if not is_safe:
+            errors.extend(validation_errors)
+
+        # Get files to install
+        files_to_install = self.get_files_to_install()
+
+        # Validate all files for security
+        is_safe, security_errors = SecurityValidator.validate_component_files(
+            files_to_install, source_dir, self.install_component_subdir
+        )
+        if not is_safe:
+            errors.extend(security_errors)
+
+        if not self.file_manager.ensure_directory(self.install_component_subdir):
+            errors.append(f"Could not create install directory: {self.install_component_subdir}")
+
+        return len(errors) == 0, errors
     
-    @abstractmethod
     def get_files_to_install(self) -> List[Tuple[Path, Path]]:
         """
         Return list of files to install
@@ -57,20 +103,37 @@ class Component(ABC):
         Returns:
             List of tuples (source_path, target_path)
         """
-        pass
+        source_dir = self._get_source_dir()
+        files = []
+
+        if source_dir:
+            for filename in self.component_files:
+                source = source_dir / filename
+                target = self.install_component_subdir / filename
+                files.append((source, target))
+
+        return files
     
-    @abstractmethod
     def get_settings_modifications(self) -> Dict[str, Any]:
         """
         Return settings.json modifications to apply
-        
+        (now only Claude Code compatible settings)
+
         Returns:
             Dict of settings to merge into settings.json
         """
-        pass
+        # Return empty dict as we don't modify Claude Code settings
+        return {}
     
-    @abstractmethod
     def install(self, config: Dict[str, Any]) -> bool:
+        try:
+            return self._install(config)
+        except Exception as e:
+            self.logger.exception(f"Unexpected error during {repr(self)} installation: {e}")
+            return False
+
+    @abstractmethod
+    def _install(self, config: Dict[str, Any]) -> bool:
         """
         Perform component-specific installation logic
         
@@ -80,8 +143,41 @@ class Component(ABC):
         Returns:
             True if successful, False otherwise
         """
-        pass
+        # Validate installation
+        success, errors = self.validate_prerequisites()
+        if not success:
+            for error in errors:
+                self.logger.error(error)
+            return False
+
+        # Get files to install
+        files_to_install = self.get_files_to_install()
+
+        # Copy framework files
+        success_count = 0
+        for source, target in files_to_install:
+            self.logger.debug(f"Copying {source.name} to {target}")
+
+            if self.file_manager.copy_file(source, target):
+                success_count += 1
+                self.logger.debug(f"Successfully copied {source.name}")
+            else:
+                self.logger.error(f"Failed to copy {source.name}")
+
+        if success_count != len(files_to_install):
+            self.logger.error(f"Only {success_count}/{len(files_to_install)} files copied successfully")
+            return False
+
+        self.logger.success(f"{repr(self)} component installed successfully ({success_count} files)")
+
+        return self._post_install()
+
     
+    @abstractmethod
+    def _post_install(self) -> bool:
+        pass
+
+
     @abstractmethod
     def uninstall(self) -> bool:
         """
@@ -101,6 +197,11 @@ class Component(ABC):
             List of component names this component depends on
         """
         pass
+
+    @abstractmethod
+    def _get_source_dir(self) -> Optional[Path]:
+        """Get source directory for component files"""
+        pass
     
     def update(self, config: Dict[str, Any]) -> bool:
         """
@@ -124,8 +225,10 @@ class Component(ABC):
         Returns:
             Version string if installed, None otherwise
         """
+        print("GETTING INSTALLED VERSION")
         settings_file = self.install_dir / "settings.json"
         if settings_file.exists():
+            print("SETTINGS.JSON EXISTS")
             try:
                 with open(settings_file, 'r') as f:
                     settings = json.load(f)
@@ -133,6 +236,7 @@ class Component(ABC):
                 return settings.get('components', {}).get(component_name, {}).get('version')
             except Exception:
                 pass
+        print("SETTINGS.JSON DOESNT EXIST RETURNING NONE")
         return None
     
     def is_installed(self) -> bool:
@@ -179,6 +283,73 @@ class Component(ABC):
                 elif source.is_dir():
                     total_size += sum(f.stat().st_size for f in source.rglob('*') if f.is_file())
         return total_size
+
+    def _discover_component_files(self) -> List[str]:
+        """
+        Dynamically discover framework .md files in the Core directory
+
+        Returns:
+            List of framework filenames (e.g., ['CLAUDE.md', 'COMMANDS.md', ...])
+        """
+        source_dir = self._get_source_dir()
+
+        if not source_dir:
+            return []
+
+        return self._discover_files_in_directory(
+            source_dir,
+            extension='.md',
+            exclude_patterns=['README.md', 'CHANGELOG.md', 'LICENSE.md']
+        )
+
+    def _discover_files_in_directory(self, directory: Path, extension: str = '.md',
+                                   exclude_patterns: Optional[List[str]] = None) -> List[str]:
+        """
+        Shared utility for discovering files in a directory
+
+        Args:
+            directory: Directory to scan
+            extension: File extension to look for (default: '.md')
+            exclude_patterns: List of filename patterns to exclude
+
+        Returns:
+            List of filenames found in the directory
+        """
+        if exclude_patterns is None:
+            exclude_patterns = []
+
+        try:
+            if not directory.exists():
+                self.logger.warning(f"Source directory not found: {directory}")
+                return []
+
+            if not directory.is_dir():
+                self.logger.warning(f"Source path is not a directory: {directory}")
+                return []
+
+            # Discover files with the specified extension
+            files = []
+            for file_path in directory.iterdir():
+                if (file_path.is_file() and
+                    file_path.suffix.lower() == extension.lower() and
+                    file_path.name not in exclude_patterns):
+                    files.append(file_path.name)
+
+            # Sort for consistent ordering
+            files.sort()
+
+            self.logger.debug(f"Discovered {len(files)} {extension} files in {directory}")
+            if files:
+                self.logger.debug(f"Files found: {files}")
+
+            return files
+
+        except PermissionError:
+            self.logger.error(f"Permission denied accessing directory: {directory}")
+            return []
+        except Exception as e:
+            self.logger.error(f"Error discovering files in {directory}: {e}")
+            return []
     
     def __str__(self) -> str:
         """String representation of component"""
@@ -187,4 +358,4 @@ class Component(ABC):
     
     def __repr__(self) -> str:
         """Developer representation of component"""
-        return f"<{self.__class__.__name__}({self.get_metadata()['name']})>"
+        return f"<{self.__class__.__name__}({self.get_metadata()['name']})>"