claude-code-templates 1.14.0 → 1.14.2

package/bin/create-claude-config.js

@@ -43,8 +43,9 @@ program
   .name('create-claude-config')
   .description('Setup Claude Code configurations for different programming languages')
   .version(require('../package.json').version)
-  .option('-l, --language <language>', 'specify programming language')
-  .option('-f, --framework <framework>', 'specify framework')
+  .option('-l, --language <language>', 'specify programming language (deprecated, use --template)')
+  .option('-f, --framework <framework>', 'specify framework (deprecated, use --template)')
+  .option('-t, --template <template>', 'specify template (e.g., common, javascript-typescript, python, ruby)')
   .option('-d, --directory <directory>', 'target directory (default: current directory)')
   .option('-y, --yes', 'skip prompts and use defaults')
   .option('--dry-run', 'show what would be copied without actually copying')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-templates",
-  "version": "1.14.0",
+  "version": "1.14.2",
   "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": {

package/src/file-operations.js

@@ -4,6 +4,152 @@ const chalk = require('chalk');
 const inquirer = require('inquirer');
 const { getHooksForLanguage, filterHooksBySelection, getMCPsForLanguage, filterMCPsBySelection } = require('./hook-scanner');
 
+// GitHub configuration for downloading templates
+const GITHUB_CONFIG = {
+  owner: 'davila7',
+  repo: 'claude-code-templates',
+  branch: 'main',
+  templatesPath: 'cli-tool/templates'
+};
+
+// Cache for downloaded files to avoid repeated downloads
+const downloadCache = new Map();
+
+async function downloadFileFromGitHub(filePath) {
+  // Check cache first
+  if (downloadCache.has(filePath)) {
+    return downloadCache.get(filePath);
+  }
+
+  const githubUrl = `https://raw.githubusercontent.com/${GITHUB_CONFIG.owner}/${GITHUB_CONFIG.repo}/${GITHUB_CONFIG.branch}/${GITHUB_CONFIG.templatesPath}/${filePath}`;
+  
+  try {
+    const response = await fetch(githubUrl);
+    if (!response.ok) {
+      throw new Error(`Failed to download ${filePath}: ${response.status} ${response.statusText}`);
+    }
+    
+    const content = await response.text();
+    downloadCache.set(filePath, content);
+    return content;
+  } catch (error) {
+    console.error(chalk.red(`❌ Error downloading ${filePath} from GitHub:`), error.message);
+    throw error;
+  }
+}
+
+async function downloadDirectoryFromGitHub(dirPath) {
+  // For directories, we need to get the list of files first
+  // GitHub API endpoint to get directory contents
+  const apiUrl = `https://api.github.com/repos/${GITHUB_CONFIG.owner}/${GITHUB_CONFIG.repo}/contents/${GITHUB_CONFIG.templatesPath}/${dirPath}?ref=${GITHUB_CONFIG.branch}`;
+  
+  try {
+    const response = await fetch(apiUrl);
+    if (!response.ok) {
+      throw new Error(`Failed to get directory listing for ${dirPath}: ${response.status} ${response.statusText}`);
+    }
+    
+    const items = await response.json();
+    const files = {};
+    
+    for (const item of items) {
+      if (item.type === 'file') {
+        const relativePath = path.relative(GITHUB_CONFIG.templatesPath, item.path);
+        const content = await downloadFileFromGitHub(relativePath);
+        files[item.name] = content;
+      }
+    }
+    
+    return files;
+  } catch (error) {
+    console.error(chalk.red(`❌ Error downloading directory ${dirPath} from GitHub:`), error.message);
+    throw error;
+  }
+}
+
+// Helper functions for processing downloaded content
+async function processSettingsFileFromContent(settingsContent, destPath, templateConfig) {
+  const settings = JSON.parse(settingsContent);
+  
+  // Filter hooks based on selection
+  if (templateConfig.selectedHooks && settings.hooks) {
+    settings.hooks = filterHooksBySelection(settings.hooks, templateConfig.selectedHooks);
+  }
+  
+  const destDir = path.dirname(destPath);
+  await fs.ensureDir(destDir);
+  await fs.writeJson(destPath, settings, { spaces: 2 });
+}
+
+async function mergeSettingsFileFromContent(settingsContent, destPath, templateConfig) {
+  const newSettings = JSON.parse(settingsContent);
+  let existingSettings = {};
+  
+  if (await fs.pathExists(destPath)) {
+    existingSettings = await fs.readJson(destPath);
+  }
+  
+  // Filter hooks based on selection
+  if (templateConfig.selectedHooks && newSettings.hooks) {
+    newSettings.hooks = filterHooksBySelection(newSettings.hooks, templateConfig.selectedHooks);
+  }
+  
+  // Merge settings
+  const mergedSettings = {
+    ...existingSettings,
+    ...newSettings,
+    hooks: {
+      ...existingSettings.hooks,
+      ...newSettings.hooks
+    }
+  };
+  
+  const destDir = path.dirname(destPath);
+  await fs.ensureDir(destDir);
+  await fs.writeJson(destPath, mergedSettings, { spaces: 2 });
+}
+
+async function processMCPFileFromContent(mcpContent, destPath, templateConfig) {
+  const mcpConfig = JSON.parse(mcpContent);
+  
+  // Filter MCPs based on selection
+  if (templateConfig.selectedMCPs && mcpConfig.mcpServers) {
+    mcpConfig.mcpServers = filterMCPsBySelection(mcpConfig.mcpServers, templateConfig.selectedMCPs);
+  }
+  
+  const destDir = path.dirname(destPath);
+  await fs.ensureDir(destDir);
+  await fs.writeJson(destPath, mcpConfig, { spaces: 2 });
+}
+
+async function mergeMCPFileFromContent(mcpContent, destPath, templateConfig) {
+  const newMcpConfig = JSON.parse(mcpContent);
+  let existingMcpConfig = {};
+  
+  if (await fs.pathExists(destPath)) {
+    existingMcpConfig = await fs.readJson(destPath);
+  }
+  
+  // Filter MCPs based on selection
+  if (templateConfig.selectedMCPs && newMcpConfig.mcpServers) {
+    newMcpConfig.mcpServers = filterMCPsBySelection(newMcpConfig.mcpServers, templateConfig.selectedMCPs);
+  }
+  
+  // Merge MCP configurations
+  const mergedMcpConfig = {
+    ...existingMcpConfig,
+    ...newMcpConfig,
+    mcpServers: {
+      ...existingMcpConfig.mcpServers,
+      ...newMcpConfig.mcpServers
+    }
+  };
+  
+  const destDir = path.dirname(destPath);
+  await fs.ensureDir(destDir);
+  await fs.writeJson(destPath, mergedMcpConfig, { spaces: 2 });
+}
+
 async function checkExistingFiles(targetDir, templateConfig) {
   const existingFiles = [];
   
@@ -86,7 +232,7 @@ async function createBackups(existingFiles, targetDir) {
 }
 
 async function copyTemplateFiles(templateConfig, targetDir, options = {}) {
-  const templateDir = path.join(__dirname, '../templates');
+  console.log(chalk.gray(`📥 Downloading templates from GitHub (${GITHUB_CONFIG.branch} branch)...`));
   
   // Check for existing files and get user preference
   const existingFiles = await checkExistingFiles(targetDir, templateConfig);
@@ -114,7 +260,6 @@ async function copyTemplateFiles(templateConfig, targetDir, options = {}) {
   
   // Copy base files and framework-specific files
   for (const file of templateConfig.files) {
-    const sourcePath = path.join(templateDir, file.source);
     const destPath = path.join(targetDir, file.destination);
     
     try {
@@ -123,94 +268,115 @@ async function copyTemplateFiles(templateConfig, targetDir, options = {}) {
         // This is a framework-specific commands directory - merge with existing commands
         await fs.ensureDir(destPath);
         
-        // Copy framework-specific commands to the commands directory
-        const frameworkFiles = await fs.readdir(sourcePath);
-        for (const frameworkFile of frameworkFiles) {
-          const srcFile = path.join(sourcePath, frameworkFile);
-          const destFile = path.join(destPath, frameworkFile);
+        // Download framework-specific commands from GitHub
+        const frameworkFiles = await downloadDirectoryFromGitHub(file.source);
+        for (const [frameworkFileName, content] of Object.entries(frameworkFiles)) {
+          const destFile = path.join(destPath, frameworkFileName);
           
           // In merge mode, skip if file already exists
           if (userAction === 'merge' && await fs.pathExists(destFile)) {
-            console.log(chalk.blue(`⏭️  Skipped ${frameworkFile} (already exists)`));
+            console.log(chalk.blue(`⏭️  Skipped ${frameworkFileName} (already exists)`));
             continue;
           }
           
-          await fs.copy(srcFile, destFile, { overwrite: shouldOverwrite });
+          await fs.writeFile(destFile, content, 'utf8');
         }
         
-        console.log(chalk.green(`✓ Copied framework commands ${file.source} → ${file.destination}`));
+        console.log(chalk.green(`✓ Downloaded framework commands ${file.source} → ${file.destination}`));
       } else if (file.source.includes('.claude') && !file.source.includes('examples/')) {
-        // This is base .claude directory - copy it but handle commands specially
-        await fs.copy(sourcePath, destPath, { 
-          overwrite: shouldOverwrite,
-          filter: (src) => {
-            // Skip the commands directory itself - we'll handle it separately
-            return !src.endsWith('.claude/commands');
-          }
-        });
-        
-        // Now handle base commands specifically
-        const baseCommandsPath = path.join(sourcePath, 'commands');
-        const destCommandsPath = path.join(destPath, 'commands');
+        // This is base .claude directory - download it but handle commands specially
+        await fs.ensureDir(destPath);
         
-        if (await fs.pathExists(baseCommandsPath)) {
-          await fs.ensureDir(destCommandsPath);
-          
-          // Copy base commands, but exclude framework-specific ones that were moved
-          const baseCommands = await fs.readdir(baseCommandsPath);
-          const excludeCommands = ['react-component.md', 'route.md', 'api-endpoint.md']; // Commands moved to framework dirs
+        // Download base .claude directory structure from GitHub
+        try {
+          const baseClaudeFiles = await downloadDirectoryFromGitHub(file.source);
           
-          for (const baseCommand of baseCommands) {
-            if (!excludeCommands.includes(baseCommand)) {
-              const srcFile = path.join(baseCommandsPath, baseCommand);
-              const destFile = path.join(destCommandsPath, baseCommand);
+          // Write non-command files first
+          for (const [fileName, content] of Object.entries(baseClaudeFiles)) {
+            if (fileName !== 'commands') { // Skip commands directory, handle separately
+              const destFile = path.join(destPath, fileName);
               
               // In merge mode, skip if file already exists
               if (userAction === 'merge' && await fs.pathExists(destFile)) {
-                console.log(chalk.blue(`⏭️  Skipped ${baseCommand} (already exists)`));
+                console.log(chalk.blue(`⏭️  Skipped ${fileName} (already exists)`));
                 continue;
               }
               
-              await fs.copy(srcFile, destFile, { overwrite: shouldOverwrite });
+              await fs.writeFile(destFile, content, 'utf8');
             }
           }
+          
+          // Now handle base commands specifically
+          const destCommandsPath = path.join(destPath, 'commands');
+          await fs.ensureDir(destCommandsPath);
+          
+          // Download base commands from GitHub
+          const baseCommandsDir = `${file.source}/commands`;
+          try {
+            const baseCommands = await downloadDirectoryFromGitHub(baseCommandsDir);
+            const excludeCommands = ['react-component.md', 'route.md', 'api-endpoint.md']; // Commands moved to framework dirs
+            
+            for (const [baseCommandName, commandContent] of Object.entries(baseCommands)) {
+              if (!excludeCommands.includes(baseCommandName)) {
+                const destFile = path.join(destCommandsPath, baseCommandName);
+                
+                // In merge mode, skip if file already exists
+                if (userAction === 'merge' && await fs.pathExists(destFile)) {
+                  console.log(chalk.blue(`⏭️  Skipped ${baseCommandName} (already exists)`));
+                  continue;
+                }
+                
+                await fs.writeFile(destFile, commandContent, 'utf8');
+              }
+            }
+          } catch (error) {
+            // Commands directory might not exist for some templates, that's ok
+            console.log(chalk.yellow(`⚠️  No commands directory found for ${baseCommandsDir}`));
+          }
+          
+        } catch (error) {
+          console.error(chalk.red(`❌ Error downloading .claude directory: ${error.message}`));
+          throw error;
         }
         
-        console.log(chalk.green(`✓ Copied base configuration and commands ${file.source} → ${file.destination}`));
+        console.log(chalk.green(`✓ Downloaded base configuration and commands ${file.source} → ${file.destination}`));
       } else if (file.source.includes('settings.json') && templateConfig.selectedHooks) {
+        // Download and process settings.json with hooks
+        const settingsContent = await downloadFileFromGitHub(file.source);
+        
         // In merge mode, merge settings instead of overwriting
         if (userAction === 'merge') {
-          await mergeSettingsFile(sourcePath, destPath, templateConfig);
+          await mergeSettingsFileFromContent(settingsContent, destPath, templateConfig);
           console.log(chalk.green(`✓ Merged ${file.source} → ${file.destination} (with selected hooks)`));
         } else {
-          await processSettingsFile(sourcePath, destPath, templateConfig);
-          console.log(chalk.green(`✓ Copied ${file.source} → ${file.destination} (with selected hooks)`));
+          await processSettingsFileFromContent(settingsContent, destPath, templateConfig);
+          console.log(chalk.green(`✓ Downloaded ${file.source} → ${file.destination} (with selected hooks)`));
         }
       } else if (file.source.includes('.mcp.json') && templateConfig.selectedMCPs) {
+        // Download and process MCP config with selected MCPs
+        const mcpContent = await downloadFileFromGitHub(file.source);
+        
         // In merge mode, merge MCP config instead of overwriting
         if (userAction === 'merge') {
-          await mergeMCPFile(sourcePath, destPath, templateConfig);
+          await mergeMCPFileFromContent(mcpContent, destPath, templateConfig);
           console.log(chalk.green(`✓ Merged ${file.source} → ${file.destination} (with selected MCPs)`));
         } else {
-          await processMCPFile(sourcePath, destPath, templateConfig);
-          console.log(chalk.green(`✓ Copied ${file.source} → ${file.destination} (with selected MCPs)`));
+          await processMCPFileFromContent(mcpContent, destPath, templateConfig);
+          console.log(chalk.green(`✓ Downloaded ${file.source} → ${file.destination} (with selected MCPs)`));
         }
       } else {
-        // Copy regular files (CLAUDE.md, etc.)
+        // Download regular files (CLAUDE.md, etc.)
         // In merge mode, skip if file already exists
         if (userAction === 'merge' && await fs.pathExists(destPath)) {
           console.log(chalk.blue(`⏭️  Skipped ${file.destination} (already exists)`));
           continue;
         }
         
-        await fs.copy(sourcePath, destPath, { 
-          overwrite: shouldOverwrite,
-          filter: (src) => {
-            // Skip commands directory during regular copy - we handle them above
-            return !src.includes('.claude/commands');
-          }
-        });
-        console.log(chalk.green(`✓ Copied ${file.source} → ${file.destination}`));
+        const fileContent = await downloadFileFromGitHub(file.source);
+        const destDir = path.dirname(destPath);
+        await fs.ensureDir(destDir);
+        await fs.writeFile(destPath, fileContent, 'utf8');
+        console.log(chalk.green(`✓ Downloaded ${file.source} → ${file.destination}`));
       }
     } catch (error) {
       console.error(chalk.red(`✗ Failed to copy ${file.source}:`), error.message);
@@ -218,38 +384,8 @@ async function copyTemplateFiles(templateConfig, targetDir, options = {}) {
     }
   }
   
+  console.log(chalk.cyan(`📦 All templates downloaded from: https://github.com/${GITHUB_CONFIG.owner}/${GITHUB_CONFIG.repo}/tree/${GITHUB_CONFIG.branch}/${GITHUB_CONFIG.templatesPath}`));
   return true; // Indicate successful completion
-  
-  // Copy selected commands individually
-  if (templateConfig.selectedCommands && templateConfig.selectedCommands.length > 0) {
-    const commandsDir = path.join(targetDir, '.claude', 'commands');
-    await fs.ensureDir(commandsDir);
-    
-    for (const command of templateConfig.selectedCommands) {
-      try {
-        const commandFileName = `${command.name}.md`;
-        const destPath = path.join(commandsDir, commandFileName);
-        
-        await fs.copy(command.filePath, destPath);
-        console.log(chalk.green(`✓ Added command: ${command.displayName}`));
-      } catch (error) {
-        console.error(chalk.red(`✗ Failed to copy command ${command.name}:`), error.message);
-        // Don't throw - continue with other commands
-      }
-    }
-    
-    console.log(chalk.cyan(`📋 Installed ${templateConfig.selectedCommands.length} commands`));
-  }
-  
-  // Report hook selection
-  if (templateConfig.selectedHooks && templateConfig.selectedHooks.length > 0) {
-    console.log(chalk.magenta(`🔧 Installed ${templateConfig.selectedHooks.length} automation hooks`));
-  }
-  
-  // Report MCP selection
-  if (templateConfig.selectedMCPs && templateConfig.selectedMCPs.length > 0) {
-    console.log(chalk.blue(`🔧 Installed ${templateConfig.selectedMCPs.length} MCP`));
-  }
 }
 
 async function runPostInstallationValidation(targetDir, templateConfig) {

package/src/index.js

@@ -14,6 +14,7 @@ const { runHookStats } = require('./hook-stats');
 const { runMCPStats } = require('./mcp-stats');
 const { runAnalytics } = require('./analytics');
 const { runHealthCheck } = require('./health-check');
+const { trackingService } = require('./tracking-service');
 
 async function showMainMenu() {
   console.log('');
@@ -49,12 +50,14 @@ async function showMainMenu() {
   
   if (initialChoice.action === 'analytics') {
     console.log(chalk.blue('📊 Launching Claude Code Analytics Dashboard...'));
+    trackingService.trackAnalyticsDashboard({ page: 'dashboard', source: 'interactive_menu' });
     await runAnalytics({});
     return;
   }
   
   if (initialChoice.action === 'chats') {
     console.log(chalk.blue('💬 Launching Claude Code Chats Dashboard...'));
+    trackingService.trackAnalyticsDashboard({ page: 'agents', source: 'interactive_menu' });
     await runAnalytics({ openTo: 'agents' });
     return;
   }
@@ -62,6 +65,13 @@ async function showMainMenu() {
   if (initialChoice.action === 'health') {
     console.log(chalk.blue('🔍 Running Health Check...'));
     const healthResult = await runHealthCheck();
+    
+    // Track health check usage
+    trackingService.trackHealthCheck({
+      setup_recommended: healthResult.runSetup,
+      issues_found: healthResult.issues || 0
+    });
+    
     if (healthResult.runSetup) {
       console.log(chalk.blue('⚙️  Starting Project Setup...'));
       // Continue with setup flow
@@ -116,12 +126,14 @@ async function createClaudeConfig(options = {}) {
   
   // Handle analytics dashboard
   if (options.analytics) {
+    trackingService.trackAnalyticsDashboard({ page: 'dashboard', source: 'command_line' });
     await runAnalytics(options);
     return;
   }
   
   // Handle chats/agents dashboard
   if (options.chats || options.agents) {
+    trackingService.trackAnalyticsDashboard({ page: 'agents', source: 'command_line' });
     await runAnalytics({ ...options, openTo: 'agents' });
     return;
   }
@@ -130,6 +142,14 @@ async function createClaudeConfig(options = {}) {
   let shouldRunSetup = false;
   if (options.healthCheck || options.health || options.check || options.verify) {
     const healthResult = await runHealthCheck();
+    
+    // Track health check usage
+    trackingService.trackHealthCheck({
+      setup_recommended: healthResult.runSetup,
+      issues_found: healthResult.issues || 0,
+      source: 'command_line'
+    });
+    
     if (healthResult.runSetup) {
       console.log(chalk.blue('⚙️  Starting Project Setup...'));
       shouldRunSetup = true;
@@ -155,8 +175,8 @@ async function createClaudeConfig(options = {}) {
   
   let config;
   if (options.yes) {
-    // Use defaults
-    const selectedLanguage = options.language || projectInfo.detectedLanguage || 'common';
+    // Use defaults - prioritize --template over --language for backward compatibility
+    const selectedLanguage = options.template || options.language || projectInfo.detectedLanguage || 'common';
     
     // Check if selected language is coming soon
     if (selectedLanguage && TEMPLATES_CONFIG[selectedLanguage] && TEMPLATES_CONFIG[selectedLanguage].comingSoon) {
@@ -244,8 +264,8 @@ async function createClaudeConfig(options = {}) {
   console.log(chalk.white('  2. Customize the configuration for your project'));
   console.log(chalk.white('  3. Start using Claude Code with: claude'));
   console.log('');
-  console.log(chalk.blue('🌐 View all available templates at: https://davila7.github.io/claude-code-templates/'));
-  console.log(chalk.blue('📖 Read the complete documentation at: https://davila7.github.io/claude-code-templates/docu/'));
+  console.log(chalk.blue('🌐 View all available templates at: https://aitmpl.com/'));
+  console.log(chalk.blue('📖 Read the complete documentation at: https://aitmpl.com/docu/'));
   
   if (config.language !== 'common') {
     console.log(chalk.yellow(`💡 Language-specific features for ${config.language} have been configured`));
@@ -262,6 +282,17 @@ async function createClaudeConfig(options = {}) {
   if (config.mcps && config.mcps.length > 0) {
     console.log(chalk.blue(`🔧 ${config.mcps.length} MCP servers have been configured`));
   }
+
+  // Track successful template installation
+  if (!options.agent && !options.command && !options.mcp) {
+    trackingService.trackTemplateInstallation(config.language, config.framework, {
+      installation_method: options.setupFromMenu ? 'interactive_menu' : 'command_line',
+      dry_run: options.dryRun || false,
+      hooks_count: config.hooks ? config.hooks.length : 0,
+      mcps_count: config.mcps ? config.mcps.length : 0,
+      project_detected: !!options.detectedProject
+    });
+  }
   
   // Run post-installation validation
   if (!options.dryRun) {
@@ -274,46 +305,40 @@ async function installIndividualAgent(agentName, targetDir, options) {
   console.log(chalk.blue(`🤖 Installing agent: ${agentName}`));
   
   try {
-    // Check if components directory exists
-    const componentsPath = path.join(__dirname, '..', 'components', 'agents');
-    const agentFile = path.join(componentsPath, `${agentName}.md`);
+    // Download agent directly from GitHub
+    const githubUrl = `https://raw.githubusercontent.com/davila7/claude-code-templates/main/cli-tool/components/agents/${agentName}.md`;
+    console.log(chalk.gray(`📥 Downloading from GitHub (main branch)...`));
     
-    if (!await fs.pathExists(agentFile)) {
-      console.log(chalk.red(`❌ Agent "${agentName}" not found`));
-      console.log(chalk.yellow('Available agents:'));
-      
-      // List available agents
-      if (await fs.pathExists(componentsPath)) {
-        const agents = await fs.readdir(componentsPath);
-        agents.filter(f => f.endsWith('.md')).forEach(agent => {
-          console.log(chalk.cyan(`  - ${agent.replace('.md', '')}`));
-        });
+    const response = await fetch(githubUrl);
+    if (!response.ok) {
+      if (response.status === 404) {
+        console.log(chalk.red(`❌ Agent "${agentName}" not found`));
+        console.log(chalk.yellow('Available agents: api-security-audit, database-optimization, react-performance-optimization'));
+        return;
       }
-      return;
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
     }
     
-    // For agents, they are typically part of templates, so we need to determine
-    // the appropriate language/framework and install the complete template
-    const agentContent = await fs.readFile(agentFile, 'utf8');
-    const language = extractLanguageFromAgent(agentContent, agentName);
-    const framework = extractFrameworkFromAgent(agentContent, agentName);
+    const agentContent = await response.text();
     
-    console.log(chalk.yellow(`📝 Agent "${agentName}" is part of ${language}/${framework} template`));
-    console.log(chalk.blue('🚀 Installing complete template with this agent...'));
+    // Create .claude/agents directory if it doesn't exist
+    const agentsDir = path.join(targetDir, '.claude', 'agents');
+    await fs.ensureDir(agentsDir);
     
-    // Install the template that contains this agent (avoid recursion)
-    const setupOptions = {
-      ...options,
-      language,
-      framework,
-      yes: true,
-      targetDirectory: targetDir,
-      agent: null // Remove agent to avoid recursion
-    };
-    delete setupOptions.agent;
-    await createClaudeConfig(setupOptions);
+    // Write the agent file
+    const targetFile = path.join(agentsDir, `${agentName}.md`);
+    await fs.writeFile(targetFile, agentContent, 'utf8');
     
     console.log(chalk.green(`✅ Agent "${agentName}" installed successfully!`));
+    console.log(chalk.cyan(`📁 Installed to: ${path.relative(targetDir, targetFile)}`));
+    console.log(chalk.cyan(`📦 Downloaded from: ${githubUrl}`));
+    
+    // Track successful agent installation
+    trackingService.trackDownload('agent', agentName, {
+      installation_type: 'individual_component',
+      target_directory: path.relative(process.cwd(), targetDir),
+      source: 'github_main'
+    });
     
   } catch (error) {
     console.log(chalk.red(`❌ Error installing agent: ${error.message}`));
@@ -324,34 +349,40 @@ async function installIndividualCommand(commandName, targetDir, options) {
   console.log(chalk.blue(`⚡ Installing command: ${commandName}`));
   
   try {
-    // Check if components directory exists
-    const componentsPath = path.join(__dirname, '..', 'components', 'commands');
-    const commandFile = path.join(componentsPath, `${commandName}.md`);
+    // Download command directly from GitHub
+    const githubUrl = `https://raw.githubusercontent.com/davila7/claude-code-templates/main/cli-tool/components/commands/${commandName}.md`;
+    console.log(chalk.gray(`📥 Downloading from GitHub (main branch)...`));
     
-    if (!await fs.pathExists(commandFile)) {
-      console.log(chalk.red(`❌ Command "${commandName}" not found`));
-      console.log(chalk.yellow('Available commands:'));
-      
-      // List available commands
-      if (await fs.pathExists(componentsPath)) {
-        const commands = await fs.readdir(componentsPath);
-        commands.filter(f => f.endsWith('.md')).forEach(command => {
-          console.log(chalk.cyan(`  - ${command.replace('.md', '')}`));
-        });
+    const response = await fetch(githubUrl);
+    if (!response.ok) {
+      if (response.status === 404) {
+        console.log(chalk.red(`❌ Command "${commandName}" not found`));
+        console.log(chalk.yellow('Available commands: check-file, generate-tests'));
+        return;
       }
-      return;
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
     }
     
+    const commandContent = await response.text();
+    
     // Create .claude/commands directory if it doesn't exist
     const commandsDir = path.join(targetDir, '.claude', 'commands');
     await fs.ensureDir(commandsDir);
     
-    // Copy the command file
+    // Write the command file
     const targetFile = path.join(commandsDir, `${commandName}.md`);
-    await fs.copy(commandFile, targetFile);
+    await fs.writeFile(targetFile, commandContent, 'utf8');
     
     console.log(chalk.green(`✅ Command "${commandName}" installed successfully!`));
     console.log(chalk.cyan(`📁 Installed to: ${path.relative(targetDir, targetFile)}`));
+    console.log(chalk.cyan(`📦 Downloaded from: ${githubUrl}`));
+    
+    // Track successful command installation
+    trackingService.trackDownload('command', commandName, {
+      installation_type: 'individual_command',
+      target_directory: path.relative(process.cwd(), targetDir),
+      source: 'github_main'
+    });
     
   } catch (error) {
     console.log(chalk.red(`❌ Error installing command: ${error.message}`));
@@ -362,26 +393,22 @@ async function installIndividualMCP(mcpName, targetDir, options) {
   console.log(chalk.blue(`🔌 Installing MCP: ${mcpName}`));
   
   try {
-    // Check if components directory exists
-    const componentsPath = path.join(__dirname, '..', 'components', 'mcps');
-    const mcpFile = path.join(componentsPath, `${mcpName}.json`);
+    // Download MCP directly from GitHub
+    const githubUrl = `https://raw.githubusercontent.com/davila7/claude-code-templates/main/cli-tool/components/mcps/${mcpName}.json`;
+    console.log(chalk.gray(`📥 Downloading from GitHub (main branch)...`));
     
-    if (!await fs.pathExists(mcpFile)) {
-      console.log(chalk.red(`❌ MCP "${mcpName}" not found`));
-      console.log(chalk.yellow('Available MCPs:'));
-      
-      // List available MCPs
-      if (await fs.pathExists(componentsPath)) {
-        const mcps = await fs.readdir(componentsPath);
-        mcps.filter(f => f.endsWith('.json')).forEach(mcp => {
-          console.log(chalk.cyan(`  - ${mcp.replace('.json', '')}`));
-        });
+    const response = await fetch(githubUrl);
+    if (!response.ok) {
+      if (response.status === 404) {
+        console.log(chalk.red(`❌ MCP "${mcpName}" not found`));
+        console.log(chalk.yellow('Available MCPs: web-fetch, filesystem-access, github-integration, memory-integration, mysql-integration, postgresql-integration, deepgraph-react, deepgraph-nextjs, deepgraph-typescript, deepgraph-vue'));
+        return;
       }
-      return;
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
     }
     
-    // Read the MCP configuration
-    const mcpConfig = await fs.readJson(mcpFile);
+    const mcpConfigText = await response.text();
+    const mcpConfig = JSON.parse(mcpConfigText);
     
     // Check if .mcp.json exists in target directory
     const targetMcpFile = path.join(targetDir, '.mcp.json');
@@ -403,6 +430,15 @@ async function installIndividualMCP(mcpName, targetDir, options) {
     
     console.log(chalk.green(`✅ MCP "${mcpName}" installed successfully!`));
     console.log(chalk.cyan(`📁 Configuration merged into: ${path.relative(targetDir, targetMcpFile)}`));
+    console.log(chalk.cyan(`📦 Downloaded from: ${githubUrl}`));
+    
+    // Track successful MCP installation
+    trackingService.trackDownload('mcp', mcpName, {
+      installation_type: 'individual_mcp',
+      merged_with_existing: existingConfig !== null,
+      servers_count: Object.keys(mergedConfig.mcpServers || {}).length,
+      source: 'github_main'
+    });
     
   } catch (error) {
     console.log(chalk.red(`❌ Error installing MCP: ${error.message}`));

package/src/tracking-service.js

@@ -0,0 +1,188 @@
+/**
+ * TrackingService - Download analytics using GitHub Issues as backend
+ * 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
+    }
+
+    /**
+     * Check if tracking should be enabled (respects user privacy)
+     */
+    shouldEnableTracking() {
+        // Allow users to opt-out
+        if (process.env.CCT_NO_TRACKING === 'true' || 
+            process.env.CCT_NO_ANALYTICS === 'true' ||
+            process.env.CI === 'true') {
+            return false;
+        }
+        
+        // Enable by default (anonymous usage data only)
+        return true;
+    }
+
+    /**
+     * Track a component download/installation
+     * @param {string} componentType - 'agent', 'command', or 'mcp'
+     * @param {string} componentName - Name of the component
+     * @param {object} metadata - Additional context (optional)
+     */
+    async trackDownload(componentType, componentName, metadata = {}) {
+        if (!this.trackingEnabled) {
+            return;
+        }
+
+        try {
+            // Create tracking payload
+            const trackingData = this.createTrackingPayload(componentType, componentName, metadata);
+            
+            // Fire-and-forget tracking (don't block user experience)
+            this.sendTrackingData(trackingData)
+                .catch(error => {
+                    // Silent failure - tracking should never impact functionality
+                    console.debug('📊 Tracking info (non-critical):', error.message);
+                });
+
+        } catch (error) {
+            // Silently handle any tracking errors
+            console.debug('📊 Analytics error (non-critical):', error.message);
+        }
+    }
+
+    /**
+     * Create standardized tracking payload
+     */
+    createTrackingPayload(componentType, componentName, metadata) {
+        const timestamp = new Date().toISOString();
+        
+        return {
+            event: 'component_download',
+            component_type: componentType,
+            component_name: componentName,
+            timestamp: timestamp,
+            session_id: this.generateSessionId(),
+            environment: {
+                node_version: process.version,
+                platform: process.platform,
+                arch: process.arch,
+                cli_version: this.getCliVersion()
+            },
+            metadata: metadata
+        };
+    }
+
+    /**
+     * Send tracking data to GitHub Issues (async, non-blocking)
+     */
+    async sendTrackingData(trackingData) {
+        const title = `📊 ${trackingData.component_type}:${trackingData.component_name} - ${trackingData.timestamp.split('T')[0]}`;
+        
+        const body = `\`\`\`json
+${JSON.stringify(trackingData, null, 2)}
+\`\`\`
+
+<!-- ANALYTICS_DATA -->
+Component: **${trackingData.component_name}** (${trackingData.component_type})  
+Platform: ${trackingData.environment.platform} ${trackingData.environment.arch}  
+Node: ${trackingData.environment.node_version}  
+CLI: ${trackingData.environment.cli_version}  
+Session: \`${trackingData.session_id}\`
+`;
+
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+
+        try {
+            const response = await fetch(`https://api.github.com/repos/${this.repoOwner}/${this.repoName}/issues`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'User-Agent': 'claude-code-templates-cli'
+                },
+                body: JSON.stringify({
+                    title: title,
+                    body: body,
+                    labels: ['📊 analytics', 'download-tracking', `type:${trackingData.component_type}`]
+                }),
+                signal: controller.signal
+            });
+
+            clearTimeout(timeoutId);
+
+            if (!response.ok) {
+                throw new Error(`GitHub API responded with ${response.status}`);
+            }
+
+            console.debug('📊 Download tracked successfully');
+            
+        } catch (error) {
+            clearTimeout(timeoutId);
+            throw error;
+        }
+    }
+
+    /**
+     * Generate a session ID for grouping related downloads
+     */
+    generateSessionId() {
+        return Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15);
+    }
+
+    /**
+     * Get CLI version from package.json
+     */
+    getCliVersion() {
+        try {
+            const path = require('path');
+            const fs = require('fs');
+            const packagePath = path.join(__dirname, '..', 'package.json');
+            const packageData = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
+            return packageData.version || 'unknown';
+        } catch (error) {
+            return 'unknown';
+        }
+    }
+
+    /**
+     * Track template installation (full project setup)
+     */
+    async trackTemplateInstallation(language, framework, metadata = {}) {
+        return this.trackDownload('template', `${language}/${framework}`, {
+            ...metadata,
+            installation_type: 'full_template'
+        });
+    }
+
+    /**
+     * Track health check usage
+     */
+    async trackHealthCheck(results = {}) {
+        return this.trackDownload('health-check', 'system-validation', {
+            installation_type: 'health_check',
+            results_summary: results
+        });
+    }
+
+    /**
+     * Track analytics dashboard usage
+     */
+    async trackAnalyticsDashboard(metadata = {}) {
+        return this.trackDownload('analytics', 'dashboard-launch', {
+            installation_type: 'analytics_dashboard',
+            ...metadata
+        });
+    }
+}
+
+// Export singleton instance
+const trackingService = new TrackingService();
+
+module.exports = {
+    TrackingService,
+    trackingService
+};