claude-code-templates 1.18.0 → 1.19.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-templates",
-  "version": "1.18.0",
+  "version": "1.19.1",
   "description": "CLI tool to setup Claude Code configurations with framework-specific commands, automation hooks and MCP Servers for your projects",
   "main": "src/index.js",
   "bin": {
@@ -90,6 +90,6 @@
   ],
   "devDependencies": {
     "jest": "^30.0.4",
-    "jest-watch-typeahead": "^2.2.2"
+    "jest-watch-typeahead": "^3.0.1"
   }
 }

package/src/index.js

@@ -401,8 +401,11 @@ async function installIndividualAgent(agentName, targetDir, options) {
       source: 'github_main'
     });
     
+    return true;
+    
   } catch (error) {
     console.log(chalk.red(`❌ Error installing agent: ${error.message}`));
+    return false;
   }
 }
 
@@ -464,8 +467,11 @@ async function installIndividualCommand(commandName, targetDir, options) {
       source: 'github_main'
     });
     
+    return true;
+    
   } catch (error) {
     console.log(chalk.red(`❌ Error installing command: ${error.message}`));
+    return false;
   }
 }
 
@@ -547,8 +553,11 @@ async function installIndividualMCP(mcpName, targetDir, options) {
       source: 'github_main'
     });
     
+    return true;
+    
   } catch (error) {
     console.log(chalk.red(`❌ Error installing MCP: ${error.message}`));
+    return false;
   }
 }
 
@@ -586,14 +595,14 @@ async function installIndividualSetting(settingName, targetDir, options) {
       delete settingConfig.description;
     }
     
-    // Ask user where to install the setting (unless in silent mode)
-    let settingsFile = 'settings.json'; // default
-    if (!options.silent) {
+    // Use shared locations if provided (batch mode), otherwise ask user
+    let installLocations = options.sharedInstallLocations || ['local']; // default to local settings
+    if (!options.silent && !options.sharedInstallLocations) {
       const inquirer = require('inquirer');
-      const { installLocation } = await inquirer.prompt([{
-        type: 'list',
-        name: 'installLocation',
-        message: 'Where would you like to install this setting?',
+      const { selectedLocations } = await inquirer.prompt([{
+        type: 'checkbox',
+        name: 'selectedLocations',
+        message: 'Where would you like to install this setting? (Select one or more)',
         choices: [
           {
             name: '🏠 User settings (~/.claude/settings.json) - Applies to all projects',
@@ -605,19 +614,36 @@ async function installIndividualSetting(settingName, targetDir, options) {
           },
           {
             name: '⚙️  Local settings (.claude/settings.local.json) - Personal, not committed',
-            value: 'local'
+            value: 'local',
+            checked: true // Default selection
           },
           {
             name: '🏢 Enterprise managed settings - System-wide policy (requires admin)',
             value: 'enterprise'
           }
         ],
-        default: 'local'
+        validate: function(answer) {
+          if (answer.length < 1) {
+            return 'You must choose at least one installation location.';
+          }
+          return true;
+        }
       }]);
-
+      
+      installLocations = selectedLocations;
+    }
+    
+    // Install the setting in each selected location
+    let successfulInstallations = 0;
+    for (const installLocation of installLocations) {
+      console.log(chalk.blue(`\n📍 Installing "${settingName}" in ${installLocation} settings...`));
+      
+      let currentTargetDir = targetDir;
+      let settingsFile = 'settings.local.json'; // default
+      
       if (installLocation === 'user') {
         const os = require('os');
-        targetDir = os.homedir();
+        currentTargetDir = os.homedir();
         settingsFile = 'settings.json';
       } else if (installLocation === 'project') {
         settingsFile = 'settings.json';
@@ -629,156 +655,177 @@ async function installIndividualSetting(settingName, targetDir, options) {
         
         if (platform === 'darwin') {
           // macOS
-          targetDir = '/Library/Application Support/ClaudeCode';
+          currentTargetDir = '/Library/Application Support/ClaudeCode';
           settingsFile = 'managed-settings.json';
         } else if (platform === 'linux' || (process.platform === 'win32' && process.env.WSL_DISTRO_NAME)) {
           // Linux and WSL
-          targetDir = '/etc/claude-code';
+          currentTargetDir = '/etc/claude-code';
           settingsFile = 'managed-settings.json';
         } else if (platform === 'win32') {
           // Windows
-          targetDir = 'C:\\ProgramData\\ClaudeCode';
+          currentTargetDir = 'C:\\ProgramData\\ClaudeCode';
           settingsFile = 'managed-settings.json';
         } else {
           console.log(chalk.yellow('⚠️  Platform not supported for enterprise settings. Using user settings instead.'));
           const os = require('os');
-          targetDir = os.homedir();
+          currentTargetDir = os.homedir();
           settingsFile = 'settings.json';
         }
         
         console.log(chalk.yellow(`⚠️  Enterprise settings require administrator privileges.`));
-        console.log(chalk.gray(`📍 Target path: ${path.join(targetDir, settingsFile)}`));
+        console.log(chalk.gray(`📍 Target path: ${path.join(currentTargetDir, settingsFile)}`));
       }
-    }
-    
-    // Determine target directory and file based on selection
-    const claudeDir = path.join(targetDir, '.claude');
-    const targetSettingsFile = path.join(claudeDir, settingsFile);
-    let existingConfig = {};
-    
-    // For enterprise settings, create directory structure directly (not under .claude)
-    if (settingsFile === 'managed-settings.json') {
-      // Ensure enterprise directory exists (requires admin privileges)
-      try {
-        await fs.ensureDir(targetDir);
-      } catch (error) {
-        console.log(chalk.red(`❌ Failed to create enterprise directory: ${error.message}`));
-        console.log(chalk.yellow('💡 Try running with administrator privileges or choose a different installation location.'));
-        return;
-      }
-    } else {
-      // Ensure .claude directory exists for regular settings
-      await fs.ensureDir(claudeDir);
-    }
-    
-    // Read existing configuration
-    const actualTargetFile = settingsFile === 'managed-settings.json' 
-      ? path.join(targetDir, settingsFile)
-      : targetSettingsFile;
       
-    if (await fs.pathExists(actualTargetFile)) {
-      existingConfig = await fs.readJson(actualTargetFile);
-      console.log(chalk.yellow(`📝 Existing ${settingsFile} found, merging configurations...`));
-    }
-    
-    // Check for conflicts before merging
-    const conflicts = [];
-    
-    // Check for conflicting environment variables
-    if (existingConfig.env && settingConfig.env) {
-      Object.keys(settingConfig.env).forEach(key => {
-        if (existingConfig.env[key] && existingConfig.env[key] !== settingConfig.env[key]) {
-          conflicts.push(`Environment variable "${key}" (current: "${existingConfig.env[key]}", new: "${settingConfig.env[key]}")`);
+      // Determine target directory and file based on selection
+      const claudeDir = path.join(currentTargetDir, '.claude');
+      const targetSettingsFile = path.join(claudeDir, settingsFile);
+      let existingConfig = {};
+      
+      // For enterprise settings, create directory structure directly (not under .claude)
+      if (settingsFile === 'managed-settings.json') {
+        // Ensure enterprise directory exists (requires admin privileges)
+        try {
+          await fs.ensureDir(currentTargetDir);
+        } catch (error) {
+          console.log(chalk.red(`❌ Failed to create enterprise directory: ${error.message}`));
+          console.log(chalk.yellow('💡 Try running with administrator privileges or choose a different installation location.'));
+          continue; // Skip this location and continue with others
         }
-      });
-    }
-    
-    // Check for conflicting top-level settings
-    Object.keys(settingConfig).forEach(key => {
-      if (key !== 'permissions' && key !== 'env' && key !== 'hooks' && 
-          existingConfig[key] !== undefined && existingConfig[key] !== settingConfig[key]) {
-        conflicts.push(`Setting "${key}" (current: "${existingConfig[key]}", new: "${settingConfig[key]}")`);
+      } else {
+        // Ensure .claude directory exists for regular settings
+        await fs.ensureDir(claudeDir);
       }
-    });
-    
-    // Ask user about conflicts if any exist and not in silent mode
-    if (conflicts.length > 0 && !options.silent) {
-      console.log(chalk.yellow(`\n⚠️  Conflicts detected while installing setting "${settingName}":`));
-      conflicts.forEach(conflict => console.log(chalk.gray(`   • ${conflict}`)));
       
-      const inquirer = require('inquirer');
-      const { shouldOverwrite } = await inquirer.prompt([{
-        type: 'confirm',
-        name: 'shouldOverwrite',
-        message: 'Do you want to overwrite the existing configuration?',
-        default: false
-      }]);
+      // Read existing configuration
+      const actualTargetFile = settingsFile === 'managed-settings.json' 
+        ? path.join(currentTargetDir, settingsFile)
+        : targetSettingsFile;
+        
+      if (await fs.pathExists(actualTargetFile)) {
+        existingConfig = await fs.readJson(actualTargetFile);
+        console.log(chalk.yellow(`📝 Existing ${settingsFile} found, merging configurations...`));
+      }
       
-      if (!shouldOverwrite) {
-        console.log(chalk.yellow(`⏹️  Installation of setting "${settingName}" cancelled by user.`));
-        return;
+      // Check for conflicts before merging
+      const conflicts = [];
+      
+      // Check for conflicting environment variables
+      if (existingConfig.env && settingConfig.env) {
+        Object.keys(settingConfig.env).forEach(key => {
+          if (existingConfig.env[key] && existingConfig.env[key] !== settingConfig.env[key]) {
+            conflicts.push(`Environment variable "${key}" (current: "${existingConfig.env[key]}", new: "${settingConfig.env[key]}")`);
+          }
+        });
       }
-    } else if (conflicts.length > 0 && options.silent) {
-      // In silent mode (batch installation), skip conflicting settings and warn
-      console.log(chalk.yellow(`⚠️  Skipping setting "${settingName}" due to conflicts (use individual installation to resolve)`));
-      return;
-    }
-    
-    // Deep merge configurations
-    const mergedConfig = {
-      ...existingConfig,
-      ...settingConfig
-    };
-    
-    // Deep merge specific sections (only if no conflicts or user approved overwrite)
-    if (existingConfig.permissions && settingConfig.permissions) {
-      mergedConfig.permissions = {
-        ...existingConfig.permissions,
-        ...settingConfig.permissions
-      };
       
-      // Merge arrays for allow, deny, ask (no conflicts here, just merge)
-      ['allow', 'deny', 'ask'].forEach(key => {
-        if (existingConfig.permissions[key] && settingConfig.permissions[key]) {
-          mergedConfig.permissions[key] = [
-            ...new Set([...existingConfig.permissions[key], ...settingConfig.permissions[key]])
-          ];
+      // Check for conflicting top-level settings
+      Object.keys(settingConfig).forEach(key => {
+        if (key !== 'permissions' && key !== 'env' && key !== 'hooks' && 
+            existingConfig[key] !== undefined && JSON.stringify(existingConfig[key]) !== JSON.stringify(settingConfig[key])) {
+          
+          // For objects, just indicate the setting name without showing the complex values
+          if (typeof existingConfig[key] === 'object' && existingConfig[key] !== null &&
+              typeof settingConfig[key] === 'object' && settingConfig[key] !== null) {
+            conflicts.push(`Setting "${key}" (will be overwritten with new configuration)`);
+          } else {
+            conflicts.push(`Setting "${key}" (current: "${existingConfig[key]}", new: "${settingConfig[key]}")`);
+          }
         }
       });
-    }
-    
-    if (existingConfig.env && settingConfig.env) {
-      mergedConfig.env = {
-        ...existingConfig.env,
-        ...settingConfig.env
-      };
-    }
-    
-    if (existingConfig.hooks && settingConfig.hooks) {
-      mergedConfig.hooks = {
-        ...existingConfig.hooks,
-        ...settingConfig.hooks
+      
+      // Ask user about conflicts if any exist
+      if (conflicts.length > 0) {
+        console.log(chalk.yellow(`\n⚠️  Conflicts detected while installing setting "${settingName}" in ${installLocation}:`));
+        conflicts.forEach(conflict => console.log(chalk.gray(`   • ${conflict}`)));
+        
+        const inquirer = require('inquirer');
+        const { shouldOverwrite } = await inquirer.prompt([{
+          type: 'confirm',
+          name: 'shouldOverwrite',
+          message: `Do you want to overwrite the existing configuration in ${installLocation}?`,
+          default: false
+        }]);
+        
+        if (!shouldOverwrite) {
+          console.log(chalk.yellow(`⏹️  Installation of setting "${settingName}" in ${installLocation} cancelled by user.`));
+          continue; // Skip this location and continue with others
+        }
+      }
+      
+      // Deep merge configurations
+      const mergedConfig = {
+        ...existingConfig,
+        ...settingConfig
       };
+      
+      // Deep merge specific sections (only if no conflicts or user approved overwrite)
+      if (existingConfig.permissions && settingConfig.permissions) {
+        mergedConfig.permissions = {
+          ...existingConfig.permissions,
+          ...settingConfig.permissions
+        };
+        
+        // Merge arrays for allow, deny, ask (no conflicts here, just merge)
+        ['allow', 'deny', 'ask'].forEach(key => {
+          if (existingConfig.permissions[key] && settingConfig.permissions[key]) {
+            mergedConfig.permissions[key] = [
+              ...new Set([...existingConfig.permissions[key], ...settingConfig.permissions[key]])
+            ];
+          }
+        });
+      }
+      
+      if (existingConfig.env && settingConfig.env) {
+        mergedConfig.env = {
+          ...existingConfig.env,
+          ...settingConfig.env
+        };
+      }
+      
+      if (existingConfig.hooks && settingConfig.hooks) {
+        mergedConfig.hooks = {
+          ...existingConfig.hooks,
+          ...settingConfig.hooks
+        };
+      }
+      
+      // Write the merged configuration
+      await fs.writeJson(actualTargetFile, mergedConfig, { spaces: 2 });
+      
+      if (!options.silent) {
+        console.log(chalk.green(`✅ Setting "${settingName}" installed successfully in ${installLocation}!`));
+        console.log(chalk.cyan(`📁 Configuration merged into: ${actualTargetFile}`));
+        console.log(chalk.cyan(`📦 Downloaded from: ${githubUrl}`));
+      }
+      
+      // Track successful setting installation for this location
+      trackingService.trackDownload('setting', settingName, {
+        installation_type: 'individual_setting',
+        installation_location: installLocation,
+        merged_with_existing: Object.keys(existingConfig).length > 0,
+        source: 'github_main'
+      });
+      
+      // Increment successful installations counter
+      successfulInstallations++;
     }
     
-    // Write the merged configuration
-    await fs.writeJson(actualTargetFile, mergedConfig, { spaces: 2 });
-    
+    // Summary after all installations
     if (!options.silent) {
-      console.log(chalk.green(`✅ Setting "${settingName}" installed successfully!`));
-      console.log(chalk.cyan(`📁 Configuration merged into: ${actualTargetFile}`));
-      console.log(chalk.cyan(`📦 Downloaded from: ${githubUrl}`));
+      if (successfulInstallations === installLocations.length) {
+        console.log(chalk.green(`\n🎉 Setting "${settingName}" successfully installed in ${successfulInstallations} location(s)!`));
+      } else {
+        console.log(chalk.yellow(`\n⚠️  Setting "${settingName}" installed in ${successfulInstallations} of ${installLocations.length} location(s).`));
+        const failedCount = installLocations.length - successfulInstallations;
+        console.log(chalk.red(`❌ ${failedCount} installation(s) failed due to permission or other errors.`));
+      }
     }
     
-    // Track successful setting installation
-    trackingService.trackDownload('setting', settingName, {
-      installation_type: 'individual_setting',
-      merged_with_existing: Object.keys(existingConfig).length > 0,
-      source: 'github_main'
-    });
+    return successfulInstallations;
     
   } catch (error) {
     console.log(chalk.red(`❌ Error installing setting: ${error.message}`));
+    return 0;
   }
 }
 
@@ -816,14 +863,14 @@ async function installIndividualHook(hookName, targetDir, options) {
       delete hookConfig.description;
     }
     
-    // Ask user where to install the hook (unless in silent mode)
-    let settingsFile = 'settings.json'; // default
-    if (!options.silent) {
+    // Use shared locations if provided (batch mode), otherwise ask user
+    let installLocations = options.sharedInstallLocations || ['local']; // default to local settings
+    if (!options.silent && !options.sharedInstallLocations) {
       const inquirer = require('inquirer');
-      const { installLocation } = await inquirer.prompt([{
-        type: 'list',
-        name: 'installLocation',
-        message: 'Where would you like to install this hook?',
+      const { selectedLocations } = await inquirer.prompt([{
+        type: 'checkbox',
+        name: 'selectedLocations',
+        message: 'Where would you like to install this hook? (Select one or more)',
         choices: [
           {
             name: '🏠 User settings (~/.claude/settings.json) - Applies to all projects',
@@ -835,19 +882,36 @@ async function installIndividualHook(hookName, targetDir, options) {
           },
           {
             name: '⚙️  Local settings (.claude/settings.local.json) - Personal, not committed',
-            value: 'local'
+            value: 'local',
+            checked: true // Default selection
           },
           {
             name: '🏢 Enterprise managed settings - System-wide policy (requires admin)',
             value: 'enterprise'
           }
         ],
-        default: 'local'
+        validate: function(answer) {
+          if (answer.length < 1) {
+            return 'You must choose at least one installation location.';
+          }
+          return true;
+        }
       }]);
+      
+      installLocations = selectedLocations;
+    }
+    
+    // Install the hook in each selected location
+    let successfulInstallations = 0;
+    for (const installLocation of installLocations) {
+      console.log(chalk.blue(`\n📍 Installing "${hookName}" in ${installLocation} settings...`));
+      
+      let currentTargetDir = targetDir;
+      let settingsFile = 'settings.local.json'; // default
 
       if (installLocation === 'user') {
         const os = require('os');
-        targetDir = os.homedir();
+        currentTargetDir = os.homedir();
         settingsFile = 'settings.json';
       } else if (installLocation === 'project') {
         settingsFile = 'settings.json';
@@ -859,151 +923,165 @@ async function installIndividualHook(hookName, targetDir, options) {
         
         if (platform === 'darwin') {
           // macOS
-          targetDir = '/Library/Application Support/ClaudeCode';
+          currentTargetDir = '/Library/Application Support/ClaudeCode';
           settingsFile = 'managed-settings.json';
         } else if (platform === 'linux' || (process.platform === 'win32' && process.env.WSL_DISTRO_NAME)) {
           // Linux and WSL
-          targetDir = '/etc/claude-code';
+          currentTargetDir = '/etc/claude-code';
           settingsFile = 'managed-settings.json';
         } else if (platform === 'win32') {
           // Windows
-          targetDir = 'C:\\ProgramData\\ClaudeCode';
+          currentTargetDir = 'C:\\ProgramData\\ClaudeCode';
           settingsFile = 'managed-settings.json';
         } else {
           console.log(chalk.yellow('⚠️  Platform not supported for enterprise settings. Using user settings instead.'));
           const os = require('os');
-          targetDir = os.homedir();
+          currentTargetDir = os.homedir();
           settingsFile = 'settings.json';
         }
         
         console.log(chalk.yellow(`⚠️  Enterprise settings require administrator privileges.`));
-        console.log(chalk.gray(`📍 Target path: ${path.join(targetDir, settingsFile)}`));
+        console.log(chalk.gray(`📍 Target path: ${path.join(currentTargetDir, settingsFile)}`));
       }
-    }
-    
-    // Determine target directory and file based on selection
-    const claudeDir = path.join(targetDir, '.claude');
-    const targetSettingsFile = path.join(claudeDir, settingsFile);
-    let existingConfig = {};
-    
-    // For enterprise settings, create directory structure directly (not under .claude)
-    if (settingsFile === 'managed-settings.json') {
-      // Ensure enterprise directory exists (requires admin privileges)
-      try {
-        await fs.ensureDir(targetDir);
-      } catch (error) {
-        console.log(chalk.red(`❌ Failed to create enterprise directory: ${error.message}`));
-        console.log(chalk.yellow('💡 Try running with administrator privileges or choose a different installation location.'));
-        return;
+      
+      // Determine target directory and file based on selection
+      const claudeDir = path.join(currentTargetDir, '.claude');
+      const targetSettingsFile = path.join(claudeDir, settingsFile);
+      let existingConfig = {};
+      
+      // For enterprise settings, create directory structure directly (not under .claude)
+      if (settingsFile === 'managed-settings.json') {
+        // Ensure enterprise directory exists (requires admin privileges)
+        try {
+          await fs.ensureDir(currentTargetDir);
+        } catch (error) {
+          console.log(chalk.red(`❌ Failed to create enterprise directory: ${error.message}`));
+          console.log(chalk.yellow('💡 Try running with administrator privileges or choose a different installation location.'));
+          continue; // Skip this location and continue with others
+        }
+      } else {
+        // Ensure .claude directory exists for regular settings
+        await fs.ensureDir(claudeDir);
       }
-    } else {
-      // Ensure .claude directory exists for regular settings
-      await fs.ensureDir(claudeDir);
-    }
-    
-    // Read existing configuration
-    const actualTargetFile = settingsFile === 'managed-settings.json' 
-      ? path.join(targetDir, settingsFile)
-      : targetSettingsFile;
       
-    if (await fs.pathExists(actualTargetFile)) {
-      existingConfig = await fs.readJson(actualTargetFile);
-      console.log(chalk.yellow(`📝 Existing ${settingsFile} found, merging hook configurations...`));
-    }
-    
-    // Check for conflicts before merging (simplified for new array format)
-    const conflicts = [];
-    
-    // For the new array format, we'll allow appending rather than conflict detection
-    // This is because Claude Code's array format naturally supports multiple hooks
-    // Conflicts are less likely and generally hooks can coexist
-    
-    // Ask user about conflicts if any exist and not in silent mode
-    if (conflicts.length > 0 && !options.silent) {
-      console.log(chalk.yellow(`\n⚠️  Conflicts detected while installing hook "${hookName}":`));
-      conflicts.forEach(conflict => console.log(chalk.gray(`   • ${conflict}`)));
+      // Read existing configuration
+      const actualTargetFile = settingsFile === 'managed-settings.json' 
+        ? path.join(currentTargetDir, settingsFile)
+        : targetSettingsFile;
+        
+      if (await fs.pathExists(actualTargetFile)) {
+        existingConfig = await fs.readJson(actualTargetFile);
+        console.log(chalk.yellow(`📝 Existing ${settingsFile} found, merging hook configurations...`));
+      }
       
-      const inquirer = require('inquirer');
-      const { shouldOverwrite } = await inquirer.prompt([{
-        type: 'confirm',
-        name: 'shouldOverwrite',
-        message: 'Do you want to overwrite the existing hook configuration?',
-        default: false
-      }]);
+      // Check for conflicts before merging (simplified for new array format)
+      const conflicts = [];
       
-      if (!shouldOverwrite) {
-        console.log(chalk.yellow(`⏹️  Installation of hook "${hookName}" cancelled by user.`));
-        return;
+      // For the new array format, we'll allow appending rather than conflict detection
+      // This is because Claude Code's array format naturally supports multiple hooks
+      // Conflicts are less likely and generally hooks can coexist
+      
+      // Ask user about conflicts if any exist
+      if (conflicts.length > 0) {
+        console.log(chalk.yellow(`\n⚠️  Conflicts detected while installing hook "${hookName}" in ${installLocation}:`));
+        conflicts.forEach(conflict => console.log(chalk.gray(`   • ${conflict}`)));
+        
+        const inquirer = require('inquirer');
+        const { shouldOverwrite } = await inquirer.prompt([{
+          type: 'confirm',
+          name: 'shouldOverwrite',
+          message: `Do you want to overwrite the existing hook configuration in ${installLocation}?`,
+          default: false
+        }]);
+        
+        if (!shouldOverwrite) {
+          console.log(chalk.yellow(`⏹️  Installation of hook "${hookName}" in ${installLocation} cancelled by user.`));
+          continue; // Skip this location and continue with others
+        }
       }
-    } else if (conflicts.length > 0 && options.silent) {
-      // In silent mode (batch installation), skip conflicting hooks and warn
-      console.log(chalk.yellow(`⚠️  Skipping hook "${hookName}" due to conflicts (use individual installation to resolve)`));
-      return;
-    }
-    
-    // Deep merge configurations with proper hook array structure
-    const mergedConfig = {
-      ...existingConfig
-    };
-    
-    // Initialize hooks structure if it doesn't exist
-    if (!mergedConfig.hooks) {
-      mergedConfig.hooks = {};
-    }
-    
-    // Merge hook configurations properly (Claude Code expects arrays)
-    if (hookConfig.hooks) {
-      Object.keys(hookConfig.hooks).forEach(hookType => {
-        if (!mergedConfig.hooks[hookType]) {
-          // If hook type doesn't exist, just copy the array
-          mergedConfig.hooks[hookType] = hookConfig.hooks[hookType];
-        } else {
-          // If hook type exists, append to the array (Claude Code format)
-          if (Array.isArray(hookConfig.hooks[hookType])) {
-            // New format: array of hook objects
-            if (!Array.isArray(mergedConfig.hooks[hookType])) {
-              // Convert old format to new format
-              mergedConfig.hooks[hookType] = [];
-            }
-            // Append new hooks to existing array
-            mergedConfig.hooks[hookType] = mergedConfig.hooks[hookType].concat(hookConfig.hooks[hookType]);
+      
+      // Deep merge configurations with proper hook array structure
+      const mergedConfig = {
+        ...existingConfig
+      };
+      
+      // Initialize hooks structure if it doesn't exist
+      if (!mergedConfig.hooks) {
+        mergedConfig.hooks = {};
+      }
+      
+      // Merge hook configurations properly (Claude Code expects arrays)
+      if (hookConfig.hooks) {
+        Object.keys(hookConfig.hooks).forEach(hookType => {
+          if (!mergedConfig.hooks[hookType]) {
+            // If hook type doesn't exist, just copy the array
+            mergedConfig.hooks[hookType] = hookConfig.hooks[hookType];
           } else {
-            // Old format compatibility: convert to new format
-            console.log(chalk.yellow(`⚠️  Converting old hook format to new Claude Code format for ${hookType}`));
-            if (!Array.isArray(mergedConfig.hooks[hookType])) {
-              mergedConfig.hooks[hookType] = [];
+            // If hook type exists, append to the array (Claude Code format)
+            if (Array.isArray(hookConfig.hooks[hookType])) {
+              // New format: array of hook objects
+              if (!Array.isArray(mergedConfig.hooks[hookType])) {
+                // Convert old format to new format
+                mergedConfig.hooks[hookType] = [];
+              }
+              // Append new hooks to existing array
+              mergedConfig.hooks[hookType] = mergedConfig.hooks[hookType].concat(hookConfig.hooks[hookType]);
+            } else {
+              // Old format compatibility: convert to new format
+              console.log(chalk.yellow(`⚠️  Converting old hook format to new Claude Code format for ${hookType}`));
+              if (!Array.isArray(mergedConfig.hooks[hookType])) {
+                mergedConfig.hooks[hookType] = [];
+              }
+              // Add old format hook as a single matcher
+              mergedConfig.hooks[hookType].push({
+                matcher: "*",
+                hooks: [{
+                  type: "command",
+                  command: hookConfig.hooks[hookType]
+                }]
+              });
             }
-            // Add old format hook as a single matcher
-            mergedConfig.hooks[hookType].push({
-              matcher: "*",
-              hooks: [{
-                type: "command",
-                command: hookConfig.hooks[hookType]
-              }]
-            });
           }
-        }
+        });
+      }
+      
+      // Write the merged configuration
+      await fs.writeJson(actualTargetFile, mergedConfig, { spaces: 2 });
+      
+      if (!options.silent) {
+        console.log(chalk.green(`✅ Hook "${hookName}" installed successfully in ${installLocation}!`));
+        console.log(chalk.cyan(`📁 Configuration merged into: ${actualTargetFile}`));
+        console.log(chalk.cyan(`📦 Downloaded from: ${githubUrl}`));
+      }
+      
+      // Track successful hook installation for this location
+      trackingService.trackDownload('hook', hookName, {
+        installation_type: 'individual_hook',
+        installation_location: installLocation,
+        merged_with_existing: Object.keys(existingConfig).length > 0,
+        source: 'github_main'
       });
+      
+      // Increment successful installations counter
+      successfulInstallations++;
     }
     
-    // Write the merged configuration
-    await fs.writeJson(actualTargetFile, mergedConfig, { spaces: 2 });
-    
+    // Summary after all installations
     if (!options.silent) {
-      console.log(chalk.green(`✅ Hook "${hookName}" installed successfully!`));
-      console.log(chalk.cyan(`📁 Configuration merged into: ${actualTargetFile}`));
-      console.log(chalk.cyan(`📦 Downloaded from: ${githubUrl}`));
+      if (successfulInstallations === installLocations.length) {
+        console.log(chalk.green(`\n🎉 Hook "${hookName}" successfully installed in ${successfulInstallations} location(s)!`));
+      } else {
+        console.log(chalk.yellow(`\n⚠️  Hook "${hookName}" installed in ${successfulInstallations} of ${installLocations.length} location(s).`));
+        const failedCount = installLocations.length - successfulInstallations;
+        console.log(chalk.red(`❌ ${failedCount} installation(s) failed due to permission or other errors.`));
+      }
     }
     
-    // Track successful hook installation
-    trackingService.trackDownload('hook', hookName, {
-      installation_type: 'individual_hook',
-      merged_with_existing: Object.keys(existingConfig).length > 0,
-      source: 'github_main'
-    });
+    return successfulInstallations;
     
   } catch (error) {
     console.log(chalk.red(`❌ Error installing hook: ${error.message}`));
+    return 0;
   }
 }
 
@@ -1144,34 +1222,92 @@ async function installMultipleComponents(options, targetDir) {
     console.log(chalk.gray(`   Settings: ${components.settings.length}`));
     console.log(chalk.gray(`   Hooks: ${components.hooks.length}`));
     
+    // Counter for successfully installed components
+    let successfullyInstalled = 0;
+    
+    // Ask for installation locations once for configuration components (if any exist and not in silent mode)
+    let sharedInstallLocations = ['local']; // default
+    const hasSettingsOrHooks = components.settings.length > 0 || components.hooks.length > 0;
+    
+    if (hasSettingsOrHooks && !options.yes) {
+      console.log(chalk.blue('\n📍 Choose installation locations for configuration components:'));
+      const inquirer = require('inquirer');
+      const { selectedLocations } = await inquirer.prompt([{
+        type: 'checkbox',
+        name: 'selectedLocations',
+        message: 'Where would you like to install the configuration components? (Select one or more)',
+        choices: [
+          {
+            name: '🏠 User settings (~/.claude/settings.json) - Applies to all projects',
+            value: 'user'
+          },
+          {
+            name: '📁 Project settings (.claude/settings.json) - Shared with team',
+            value: 'project'
+          },
+          {
+            name: '⚙️  Local settings (.claude/settings.local.json) - Personal, not committed',
+            value: 'local',
+            checked: true // Default selection
+          },
+          {
+            name: '🏢 Enterprise managed settings - System-wide policy (requires admin)',
+            value: 'enterprise'
+          }
+        ],
+        validate: function(answer) {
+          if (answer.length < 1) {
+            return 'You must choose at least one installation location.';
+          }
+          return true;
+        }
+      }]);
+      
+      sharedInstallLocations = selectedLocations;
+      console.log(chalk.cyan(`📋 Will install configuration components in: ${sharedInstallLocations.join(', ')}`));
+    }
+    
     // Install agents
     for (const agent of components.agents) {
       console.log(chalk.gray(`   Installing agent: ${agent}`));
-      await installIndividualAgent(agent, targetDir, { ...options, silent: true });
+      const agentSuccess = await installIndividualAgent(agent, targetDir, { ...options, silent: true });
+      if (agentSuccess) successfullyInstalled++;
     }
     
     // Install commands
     for (const command of components.commands) {
       console.log(chalk.gray(`   Installing command: ${command}`));
-      await installIndividualCommand(command, targetDir, { ...options, silent: true });
+      const commandSuccess = await installIndividualCommand(command, targetDir, { ...options, silent: true });
+      if (commandSuccess) successfullyInstalled++;
     }
     
     // Install MCPs
     for (const mcp of components.mcps) {
       console.log(chalk.gray(`   Installing MCP: ${mcp}`));
-      await installIndividualMCP(mcp, targetDir, { ...options, silent: true });
+      const mcpSuccess = await installIndividualMCP(mcp, targetDir, { ...options, silent: true });
+      if (mcpSuccess) successfullyInstalled++;
     }
     
-    // Install settings
+    // Install settings (using shared installation locations)
     for (const setting of components.settings) {
       console.log(chalk.gray(`   Installing setting: ${setting}`));
-      await installIndividualSetting(setting, targetDir, { ...options, silent: true });
+      const settingSuccess = await installIndividualSetting(setting, targetDir, { 
+        ...options, 
+        silent: true, 
+        sharedInstallLocations: sharedInstallLocations 
+      });
+      if (settingSuccess > 0) successfullyInstalled++;
     }
     
-    // Install hooks
+    // Install hooks (using shared installation locations)
     for (const hook of components.hooks) {
       console.log(chalk.gray(`   Installing hook: ${hook}`));
-      await installIndividualHook(hook, targetDir, { ...options, silent: true });
+      const hookSuccess = await installIndividualHook(hook, targetDir, { 
+        ...options, 
+        silent: true, 
+        sharedInstallLocations: sharedInstallLocations 
+      });
+      if (hookSuccess > 0) successfullyInstalled++;
     }
     
     // Handle YAML workflow if provided
@@ -1203,7 +1339,15 @@ async function installMultipleComponents(options, targetDir) {
       }
     }
     
-    console.log(chalk.green(`\n✅ Successfully installed ${totalComponents} components!`));
+    if (successfullyInstalled === totalComponents) {
+      console.log(chalk.green(`\n✅ Successfully installed ${successfullyInstalled} components!`));
+    } else if (successfullyInstalled > 0) {
+      console.log(chalk.yellow(`\n⚠️  Successfully installed ${successfullyInstalled} of ${totalComponents} components.`));
+      console.log(chalk.red(`❌ ${totalComponents - successfullyInstalled} component(s) failed to install.`));
+    } else {
+      console.log(chalk.red(`\n❌ No components were installed successfully.`));
+      return; // Exit early if nothing was installed
+    }
     console.log(chalk.cyan(`📁 Components installed to: .claude/`));
     
     if (options.yaml) {
@@ -1211,17 +1355,7 @@ async function installMultipleComponents(options, targetDir) {
       console.log(chalk.cyan(`🚀 Use the workflow file with Claude Code to execute the complete setup`));
     }
     
-    // Track installation
-    trackingService.trackDownload('multi-component', 'batch', {
-      installation_type: 'multi-component',
-      agents_count: components.agents.length,
-      commands_count: components.commands.length,
-      mcps_count: components.mcps.length,
-      settings_count: components.settings.length,
-      hooks_count: components.hooks.length,
-      has_yaml: !!options.yaml,
-      target_directory: path.relative(process.cwd(), targetDir)
-    });
+    // Note: Individual components are already tracked separately in their installation functions
     
     // Handle prompt execution if provided
     if (options.prompt) {

package/src/tracking-service.js

@@ -1,12 +1,10 @@
 /**
- * TrackingService - Download analytics using GitHub Issues as backend
+ * TrackingService - Anonymous download analytics using Supabase database
  * Records component installations for analytics without impacting user experience
  */
 
 class TrackingService {
     constructor() {
-        this.repoOwner = 'davila7';
-        this.repoName = 'claude-code-templates';
         this.trackingEnabled = this.shouldEnableTracking();
         this.timeout = 5000; // 5s timeout for tracking requests
     }
@@ -83,35 +81,20 @@ class TrackingService {
     }
 
     /**
-     * Send tracking data via public telemetry endpoint (like Google Analytics)
+     * Send tracking data to database endpoint
      */
     async sendTrackingData(trackingData) {
         const controller = new AbortController();
         const timeoutId = setTimeout(() => controller.abort(), this.timeout);
 
         try {
-            // Build query parameters for GET request (like image tracking)
-            const params = new URLSearchParams({
-                type: trackingData.component_type,
-                name: trackingData.component_name,
-                platform: trackingData.environment.platform || 'unknown',
-                cli: trackingData.environment.cli_version || 'unknown',
-                session: trackingData.session_id.substring(0, 8) // Only first 8 chars for privacy
-            });
-
-            // Use GitHub Pages tracking endpoint via custom domain (no auth needed)
-            await fetch(`https://aitmpl.com/api/track.html?${params}`, {
-                method: 'GET',
-                mode: 'no-cors', // Prevents CORS errors
-                signal: controller.signal
-            });
+            // Send to Vercel database endpoint
+            await this.sendToDatabase(trackingData, controller.signal);
 
             clearTimeout(timeoutId);
 
-            // No need to check response with no-cors mode
-            // Only show success message when debugging
             if (process.env.CCT_DEBUG === 'true') {
-                console.debug('📊 Download tracked successfully via telemetry');
+                console.debug('📊 Download tracked successfully');
             }
             
         } catch (error) {
@@ -123,6 +106,63 @@ class TrackingService {
         }
     }
 
+    /**
+     * Send tracking data to Vercel database
+     */
+    async sendToDatabase(trackingData, signal) {
+        try {
+            // Extract component path from metadata
+            const componentPath = trackingData.metadata?.target_directory || 
+                                trackingData.metadata?.path || 
+                                trackingData.component_name;
+
+            // Extract category from metadata or component name
+            const category = trackingData.metadata?.category || 
+                           (trackingData.component_name.includes('/') ? 
+                            trackingData.component_name.split('/')[0] : 'general');
+
+            const payload = {
+                type: trackingData.component_type,
+                name: trackingData.component_name,
+                path: componentPath,
+                category: category,
+                cliVersion: trackingData.environment?.cli_version || 'unknown'
+            };
+
+            const response = await fetch('https://www.aitmpl.com/api/track-download-supabase', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'User-Agent': `claude-code-templates/${trackingData.environment?.cli_version || 'unknown'}`
+                },
+                body: JSON.stringify(payload),
+                signal: signal
+            });
+
+            if (process.env.CCT_DEBUG === 'true') {
+                console.debug('📊 Payload sent:', JSON.stringify(payload, null, 2));
+                if (response.ok) {
+                    console.debug('📊 Successfully saved to database');
+                } else {
+                    console.debug(`📊 Database save failed with status: ${response.status}`);
+                    try {
+                        const errorText = await response.text();
+                        console.debug('📊 Error response:', errorText);
+                    } catch (e) {
+                        console.debug('📊 Could not read error response');
+                    }
+                }
+            }
+
+        } catch (error) {
+            if (process.env.CCT_DEBUG === 'true') {
+                console.debug('📊 Database tracking failed:', error.message);
+            }
+            // Don't throw - tracking should be non-blocking
+        }
+    }
+
+
     /**
      * Generate a session ID for grouping related downloads
      */