claude-code-templates 1.15.0 → 1.16.1

package/package.json

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

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

@@ -321,35 +321,22 @@ async function installIndividualAgent(agentName, targetDir, options) {
     
     const agentContent = await response.text();
     
-    // For agents, they are typically part of templates, so we need to determine
-    // the appropriate language/framework and install the complete template
-    const language = extractLanguageFromAgent(agentContent, agentName);
-    const framework = extractFrameworkFromAgent(agentContent, agentName);
+    // Create .claude/agents directory if it doesn't exist
+    const agentsDir = path.join(targetDir, '.claude', 'agents');
+    await fs.ensureDir(agentsDir);
     
-    console.log(chalk.yellow(`📝 Agent "${agentName}" is part of ${language}/${framework} template`));
-    console.log(chalk.blue('🚀 Installing complete template with this agent...'));
-    
-    // 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'
     });