claude-code-templates 1.19.0 → 1.19.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-templates",
-  "version": "1.19.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;
   }
 }
 
@@ -712,13 +721,20 @@ async function installIndividualSetting(settingName, targetDir, options) {
       // 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]}")`);
+            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]}")`);
+          }
         }
       });
       
-      // Ask user about conflicts if any exist and not in silent mode
-      if (conflicts.length > 0 && !options.silent) {
+      // 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}`)));
         
@@ -734,10 +750,6 @@ async function installIndividualSetting(settingName, targetDir, options) {
           console.log(chalk.yellow(`⏹️  Installation of setting "${settingName}" 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 settings and warn
-        console.log(chalk.yellow(`⚠️  Skipping setting "${settingName}" in ${installLocation} due to conflicts (use individual installation to resolve)`));
-        continue; // Skip this location and continue with others
       }
       
       // Deep merge configurations
@@ -809,8 +821,11 @@ async function installIndividualSetting(settingName, targetDir, options) {
       }
     }
     
+    return successfulInstallations;
+    
   } catch (error) {
     console.log(chalk.red(`❌ Error installing setting: ${error.message}`));
+    return 0;
   }
 }
 
@@ -966,8 +981,8 @@ async function installIndividualHook(hookName, targetDir, options) {
       // 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) {
+      // 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}`)));
         
@@ -983,10 +998,6 @@ async function installIndividualHook(hookName, targetDir, options) {
           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}" in ${installLocation} due to conflicts (use individual installation to resolve)`));
-        continue; // Skip this location and continue with others
       }
       
       // Deep merge configurations with proper hook array structure
@@ -1066,8 +1077,11 @@ async function installIndividualHook(hookName, targetDir, options) {
       }
     }
     
+    return successfulInstallations;
+    
   } catch (error) {
     console.log(chalk.red(`❌ Error installing hook: ${error.message}`));
+    return 0;
   }
 }
 
@@ -1208,6 +1222,9 @@ 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;
@@ -1253,39 +1270,44 @@ async function installMultipleComponents(options, targetDir) {
     // 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 (using shared installation locations)
     for (const setting of components.settings) {
       console.log(chalk.gray(`   Installing setting: ${setting}`));
-      await installIndividualSetting(setting, targetDir, { 
+      const settingSuccess = await installIndividualSetting(setting, targetDir, { 
         ...options, 
         silent: true, 
         sharedInstallLocations: sharedInstallLocations 
       });
+      if (settingSuccess > 0) successfullyInstalled++;
     }
     
     // Install hooks (using shared installation locations)
     for (const hook of components.hooks) {
       console.log(chalk.gray(`   Installing hook: ${hook}`));
-      await installIndividualHook(hook, targetDir, { 
+      const hookSuccess = await installIndividualHook(hook, targetDir, { 
         ...options, 
         silent: true, 
         sharedInstallLocations: sharedInstallLocations 
       });
+      if (hookSuccess > 0) successfullyInstalled++;
     }
     
     // Handle YAML workflow if provided
@@ -1317,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) {
@@ -1325,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
      */