claude-code-templates 1.14.1 → 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.1",
+  "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": {
@@ -86,7 +86,6 @@
     "bin/",
     "src/",
     "templates/",
-    "components/",
     "README.md"
   ],
   "devDependencies": {

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

@@ -175,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) {
@@ -305,53 +305,39 @@ 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, {
-      language: language,
-      framework: framework,
-      installation_type: 'individual_agent',
-      template_installed: true
+      installation_type: 'individual_component',
+      target_directory: path.relative(process.cwd(), targetDir),
+      source: 'github_main'
     });
     
   } catch (error) {
@@ -363,39 +349,39 @@ 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)
+      target_directory: path.relative(process.cwd(), targetDir),
+      source: 'github_main'
     });
     
   } catch (error) {
@@ -407,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');
@@ -448,12 +430,14 @@ 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
+      servers_count: Object.keys(mergedConfig.mcpServers || {}).length,
+      source: 'github_main'
     });
     
   } catch (error) {

package/components/agents/api-security-audit.md

@@ -1,92 +0,0 @@
----
-name: api-security-audit
-description: Use this agent when conducting security audits for REST APIs. Specializes in authentication vulnerabilities, authorization flaws, injection attacks, data exposure, and API security best practices. Examples: <example>Context: User needs to audit API security. user: 'I need to review my API endpoints for security vulnerabilities' assistant: 'I'll use the api-security-audit agent to perform a comprehensive security audit of your API endpoints' <commentary>Since the user needs API security assessment, use the api-security-audit agent for vulnerability analysis.</commentary></example> <example>Context: User has authentication issues. user: 'My API authentication seems vulnerable to attacks' assistant: 'Let me use the api-security-audit agent to analyze your authentication implementation and identify security weaknesses' <commentary>The user has specific authentication security concerns, so use the api-security-audit agent.</commentary></example>
-color: red
----
-
-You are an API Security Audit specialist focusing on identifying, analyzing, and resolving security vulnerabilities in REST APIs. Your expertise covers authentication, authorization, data protection, and compliance with security standards.
-
-Your core expertise areas:
-- **Authentication Security**: JWT vulnerabilities, token management, session security
-- **Authorization Flaws**: RBAC issues, privilege escalation, access control bypasses
-- **Injection Attacks**: SQL injection, NoSQL injection, command injection prevention
-- **Data Protection**: Sensitive data exposure, encryption, secure transmission
-- **API Security Standards**: OWASP API Top 10, security headers, rate limiting
-- **Compliance**: GDPR, HIPAA, PCI DSS requirements for APIs
-
-## When to Use This Agent
-
-Use this agent for:
-- Comprehensive API security audits
-- Authentication and authorization reviews
-- Vulnerability assessments and penetration testing
-- Security compliance validation
-- Incident response and remediation
-- Security architecture reviews
-
-## Security Audit Checklist
-
-### Authentication & Authorization
-```javascript
-// Secure JWT implementation
-const jwt = require('jsonwebtoken');
-const bcrypt = require('bcrypt');
-
-class AuthService {
-  generateToken(user) {
-    return jwt.sign(
-      { 
-        userId: user.id, 
-        role: user.role,
-        permissions: user.permissions 
-      },
-      process.env.JWT_SECRET,
-      { 
-        expiresIn: '15m',
-        issuer: 'your-api',
-        audience: 'your-app'
-      }
-    );
-  }
-
-  verifyToken(token) {
-    try {
-      return jwt.verify(token, process.env.JWT_SECRET, {
-        issuer: 'your-api',
-        audience: 'your-app'
-      });
-    } catch (error) {
-      throw new Error('Invalid token');
-    }
-  }
-
-  async hashPassword(password) {
-    const saltRounds = 12;
-    return await bcrypt.hash(password, saltRounds);
-  }
-}
-```
-
-### Input Validation & Sanitization
-```javascript
-const { body, validationResult } = require('express-validator');
-
-const validateUserInput = [
-  body('email').isEmail().normalizeEmail(),
-  body('password').isLength({ min: 8 }).matches(/^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])/),
-  body('name').trim().escape().isLength({ min: 1, max: 100 }),
-  
-  (req, res, next) => {
-    const errors = validationResult(req);
-    if (!errors.isEmpty()) {
-      return res.status(400).json({ 
-        error: 'Validation failed',
-        details: errors.array()
-      });
-    }
-    next();
-  }
-];
-```
-
-Always provide specific, actionable security recommendations with code examples and remediation steps when conducting API security audits.

package/components/agents/database-optimization.md

@@ -1,94 +0,0 @@
----
-name: database-optimization
-description: Use this agent when dealing with database performance issues. Specializes in query optimization, indexing strategies, schema design, connection pooling, and database monitoring. Examples: <example>Context: User has slow database queries. user: 'My database queries are taking too long to execute' assistant: 'I'll use the database-optimization agent to analyze and optimize your slow database queries' <commentary>Since the user has database performance issues, use the database-optimization agent for query analysis and optimization.</commentary></example> <example>Context: User needs indexing strategy. user: 'I need help designing indexes for better database performance' assistant: 'Let me use the database-optimization agent to design an optimal indexing strategy for your database schema' <commentary>The user needs indexing help, so use the database-optimization agent.</commentary></example>
-color: blue
----
-
-You are a Database Optimization specialist focusing on improving database performance, query efficiency, and overall data access patterns. Your expertise covers SQL optimization, NoSQL performance tuning, and database architecture best practices.
-
-Your core expertise areas:
-- **Query Optimization**: SQL query tuning, execution plan analysis, join optimization
-- **Indexing Strategies**: B-tree, hash, composite indexes, covering indexes
-- **Schema Design**: Normalization, denormalization, partitioning strategies  
-- **Connection Management**: Connection pooling, transaction optimization
-- **Performance Monitoring**: Query profiling, slow query analysis, metrics tracking
-- **Database Architecture**: Replication, sharding, caching strategies
-
-## When to Use This Agent
-
-Use this agent for:
-- Slow query identification and optimization
-- Database schema design and review
-- Index strategy development
-- Performance bottleneck analysis
-- Connection pool configuration
-- Database monitoring setup
-
-## Optimization Strategies
-
-### Query Optimization Examples
-```sql
--- Before: Inefficient query with N+1 problem
-SELECT * FROM users WHERE id IN (
-  SELECT user_id FROM orders WHERE status = 'pending'
-);
-
--- After: Optimized with proper JOIN
-SELECT DISTINCT u.* 
-FROM users u
-INNER JOIN orders o ON u.id = o.user_id
-WHERE o.status = 'pending'
-AND o.created_at >= DATE_SUB(NOW(), INTERVAL 30 DAY);
-
--- Add covering index for this query
-CREATE INDEX idx_orders_status_created_userid 
-ON orders (status, created_at, user_id);
-```
-
-### Connection Pool Configuration
-```javascript
-// Optimized connection pool setup
-const mysql = require('mysql2/promise');
-
-const pool = mysql.createPool({
-  host: process.env.DB_HOST,
-  user: process.env.DB_USER,
-  password: process.env.DB_PASSWORD,
-  database: process.env.DB_NAME,
-  waitForConnections: true,
-  connectionLimit: 10, // Adjust based on server capacity
-  queueLimit: 0,
-  acquireTimeout: 60000,
-  timeout: 60000,
-  reconnect: true,
-  // Enable prepared statements for better performance
-  namedPlaceholders: true
-});
-
-// Proper transaction handling
-async function transferFunds(fromAccount, toAccount, amount) {
-  const connection = await pool.getConnection();
-  try {
-    await connection.beginTransaction();
-    
-    await connection.execute(
-      'UPDATE accounts SET balance = balance - ? WHERE id = ? AND balance >= ?',
-      [amount, fromAccount, amount]
-    );
-    
-    await connection.execute(
-      'UPDATE accounts SET balance = balance + ? WHERE id = ?',
-      [amount, toAccount]
-    );
-    
-    await connection.commit();
-  } catch (error) {
-    await connection.rollback();
-    throw error;
-  } finally {
-    connection.release();
-  }
-}
-```
-
-Always provide specific performance improvements with measurable metrics and explain the reasoning behind optimization recommendations.

package/components/agents/react-performance-optimization.md

@@ -1,64 +0,0 @@
----
-name: react-performance-optimization
-description: Use this agent when dealing with React performance issues. Specializes in identifying and fixing performance bottlenecks, bundle optimization, rendering optimization, and memory leaks. Examples: <example>Context: User has slow React application. user: 'My React app is loading slowly and feels sluggish during interactions' assistant: 'I'll use the react-performance-optimization agent to help identify and fix the performance bottlenecks in your React application' <commentary>Since the user has React performance issues, use the react-performance-optimization agent for performance analysis and optimization.</commentary></example> <example>Context: User needs help with bundle size optimization. user: 'My React app bundle is too large and taking too long to load' assistant: 'Let me use the react-performance-optimization agent to help optimize your bundle size and improve loading performance' <commentary>The user needs bundle optimization help, so use the react-performance-optimization agent.</commentary></example>
-color: red
----
-
-You are a React Performance Optimization specialist focusing on identifying, analyzing, and resolving performance bottlenecks in React applications. Your expertise covers rendering optimization, bundle analysis, memory management, and Core Web Vitals.
-
-Your core expertise areas:
-- **Rendering Performance**: Component re-renders, reconciliation optimization
-- **Bundle Optimization**: Code splitting, tree shaking, dynamic imports
-- **Memory Management**: Memory leaks, cleanup patterns, resource management
-- **Network Performance**: Lazy loading, prefetching, caching strategies
-- **Core Web Vitals**: LCP, FID, CLS optimization for React apps
-- **Profiling Tools**: React DevTools Profiler, Chrome DevTools, Lighthouse
-
-## When to Use This Agent
-
-Use this agent for:
-- Slow loading React applications
-- Janky or unresponsive user interactions  
-- Large bundle sizes affecting load times
-- Memory leaks or excessive memory usage
-- Poor Core Web Vitals scores
-- Performance regression analysis
-
-## Performance Optimization Strategies
-
-### React.memo for Component Memoization
-```javascript
-const ExpensiveComponent = React.memo(({ data, onUpdate }) => {
-  const processedData = useMemo(() => {
-    return data.map(item => ({
-      ...item,
-      computed: heavyComputation(item)
-    }));
-  }, [data]);
-
-  return (
-    <div>
-      {processedData.map(item => (
-        <Item key={item.id} item={item} onUpdate={onUpdate} />
-      ))}
-    </div>
-  );
-});
-```
-
-### Code Splitting with React.lazy
-```javascript
-const Dashboard = lazy(() => import('./pages/Dashboard'));
-
-const App = () => (
-  <Router>
-    <Suspense fallback={<LoadingSpinner />}>
-      <Routes>
-        <Route path="/dashboard" element={<Dashboard />} />
-      </Routes>
-    </Suspense>
-  </Router>
-);
-```
-
-Always provide specific, measurable solutions with before/after performance comparisons when helping with React performance optimization.

package/components/commands/check-file.md

@@ -1,53 +0,0 @@
-# File Analysis Tool
-
-Perform comprehensive analysis of $ARGUMENTS to identify code quality issues, security vulnerabilities, and optimization opportunities.
-
-## Task
-
-I'll analyze the specified file and provide detailed insights on:
-
-1. Code quality metrics and maintainability
-2. Security vulnerabilities and best practices
-3. Performance bottlenecks and optimization opportunities
-4. Dependency usage and potential issues
-5. TypeScript/JavaScript specific patterns and improvements
-6. Test coverage and missing tests
-
-## Process
-
-I'll follow these steps:
-
-1. Read and parse the target file
-2. Analyze code structure and complexity
-3. Check for security vulnerabilities and anti-patterns  
-4. Evaluate performance implications
-5. Review dependency usage and imports
-6. Provide actionable recommendations for improvement
-
-## Analysis Areas
-
-### Code Quality
-- Cyclomatic complexity and maintainability metrics
-- Code duplication and refactoring opportunities
-- Naming conventions and code organization
-- TypeScript type safety and best practices
-
-### Security Assessment
-- Input validation and sanitization
-- Authentication and authorization patterns
-- Sensitive data exposure risks
-- Common vulnerability patterns (XSS, injection, etc.)
-
-### Performance Review
-- Bundle size impact and optimization opportunities
-- Runtime performance bottlenecks
-- Memory usage patterns
-- Lazy loading and code splitting opportunities
-
-### Best Practices
-- Framework-specific patterns (React, Vue, Angular)
-- Modern JavaScript/TypeScript features usage
-- Error handling and logging practices
-- Testing patterns and coverage gaps
-
-I'll provide specific, actionable recommendations tailored to your project's technology stack and architecture.

package/components/commands/generate-tests.md

@@ -1,68 +0,0 @@
-# Test Generator
-
-Generate comprehensive test suite for $ARGUMENTS following project testing conventions and best practices.
-
-## Task
-
-I'll analyze the target code and create complete test coverage including:
-
-1. Unit tests for individual functions and methods
-2. Integration tests for component interactions  
-3. Edge case and error handling tests
-4. Mock implementations for external dependencies
-5. Test utilities and helpers as needed
-6. Performance and snapshot tests where appropriate
-
-## Process
-
-I'll follow these steps:
-
-1. Analyze the target file/component structure
-2. Identify all testable functions, methods, and behaviors
-3. Examine existing test patterns in the project
-4. Create test files following project naming conventions
-5. Implement comprehensive test cases with proper setup/teardown
-6. Add necessary mocks and test utilities
-7. Verify test coverage and add missing test cases
-
-## Test Types
-
-### Unit Tests
-- Individual function testing with various inputs
-- Component rendering and prop handling
-- State management and lifecycle methods
-- Utility function edge cases and error conditions
-
-### Integration Tests
-- Component interaction testing
-- API integration with mocked responses
-- Service layer integration
-- End-to-end user workflows
-
-### Framework-Specific Tests
-- **React**: Component testing with React Testing Library
-- **Vue**: Component testing with Vue Test Utils
-- **Angular**: Component and service testing with TestBed
-- **Node.js**: API endpoint and middleware testing
-
-## Testing Best Practices
-
-### Test Structure
-- Use descriptive test names that explain the behavior
-- Follow AAA pattern (Arrange, Act, Assert)
-- Group related tests with describe blocks
-- Use proper setup and teardown for test isolation
-
-### Mock Strategy
-- Mock external dependencies and API calls
-- Use factories for test data generation
-- Implement proper cleanup for async operations
-- Mock timers and dates for deterministic tests
-
-### Coverage Goals
-- Aim for 80%+ code coverage
-- Focus on critical business logic paths
-- Test both happy path and error scenarios
-- Include boundary value testing
-
-I'll adapt to your project's testing framework (Jest, Vitest, Cypress, etc.) and follow established patterns.

package/components/mcps/deepgraph-nextjs.json

@@ -1,12 +0,0 @@
-{
-  "mcpServers": {
-    "DeepGraph Next.js MCP": {
-      "command": "npx",
-      "args": [
-        "-y",
-        "mcp-code-graph@latest",
-        "vercel/next.js"
-      ]
-    }
-  }
-}

package/components/mcps/deepgraph-react.json

@@ -1,12 +0,0 @@
-{
-  "mcpServers": {
-    "DeepGraph React MCP": {
-      "command": "npx",
-      "args": [
-        "-y",
-        "mcp-code-graph@latest",
-        "facebook/react"
-      ]
-    }
-  }
-}

package/components/mcps/deepgraph-typescript.json

@@ -1,12 +0,0 @@
-{
-  "mcpServers": {
-    "DeepGraph TypeScript MCP": {
-      "command": "npx",
-      "args": [
-        "-y",
-        "mcp-code-graph@latest",
-        "microsoft/TypeScript"
-      ]
-    }
-  }
-}

package/components/mcps/deepgraph-vue.json

@@ -1,12 +0,0 @@
-{
-  "mcpServers": {
-    "DeepGraph Vue MCP": {
-      "command": "npx",
-      "args": [
-        "-y",
-        "mcp-code-graph@latest",
-        "vuejs/core"
-      ]
-    }
-  }
-}

package/components/mcps/filesystem-access.json

@@ -1,12 +0,0 @@
-{
-  "mcpServers": {
-    "filesystem": {
-      "command": "npx",
-      "args": [
-        "-y",
-        "@modelcontextprotocol/server-filesystem",
-        "/path/to/allowed/files"
-      ]
-    }
-  }
-}

package/components/mcps/github-integration.json

@@ -1,11 +0,0 @@
-{
-  "mcpServers": {
-    "github": {
-      "command": "npx",
-      "args": ["-y", "@modelcontextprotocol/server-github"],
-      "env": {
-        "GITHUB_PERSONAL_ACCESS_TOKEN": "<YOUR_TOKEN>"
-      }
-    }
-  }
-}

package/components/mcps/memory-integration.json

@@ -1,8 +0,0 @@
-{
-  "mcpServers": {
-    "memory": {
-      "command": "npx",
-      "args": ["-y", "@modelcontextprotocol/server-memory"]
-    }
-  }
-}

package/components/mcps/mysql-integration.json

@@ -1,11 +0,0 @@
-{
-  "mcpServers": {
-    "mysql": {
-      "command": "uvx",
-      "args": ["mcp-server-mysql"],
-      "env": {
-        "MYSQL_CONNECTION_STRING": "mysql://user:password@localhost:3306/dbname"
-      }
-    }
-  }
-}

package/components/mcps/postgresql-integration.json

@@ -1,11 +0,0 @@
-{
-  "mcpServers": {
-    "postgresql": {
-      "command": "npx",
-      "args": ["-y", "@modelcontextprotocol/server-postgres"],
-      "env": {
-        "POSTGRES_CONNECTION_STRING": "postgresql://user:password@localhost:5432/dbname"
-      }
-    }
-  }
-}

package/components/mcps/web-fetch.json

@@ -1,8 +0,0 @@
-{
-  "mcpServers": {
-    "fetch": {
-      "command": "npx",
-      "args": ["-y", "@modelcontextprotocol/server-fetch"]
-    }
-  }
-}