claude-code-templates 1.0.2 → 1.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-templates",
-  "version": "1.0.2",
+  "version": "1.1.1",
   "description": "CLI tool to setup Claude Code configurations for different programming languages",
   "main": "src/index.js",
   "bin": {
@@ -11,7 +11,11 @@
   },
   "scripts": {
     "start": "node bin/create-claude-config.js",
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "sync": "node scripts/sync-templates.js",
+    "presync": "echo \"🔄 Iniciando sincronización de plantillas...\"",
+    "postsync": "echo \"✅ Sincronización completada. Listo para publicar!\"",
+    "prepublishOnly": "npm run sync"
   },
   "keywords": [
     "claude",
@@ -46,6 +50,7 @@
   "files": [
     "bin/",
     "src/",
+    "scripts/",
     "templates/",
     "README.md"
   ]

package/scripts/sync-templates.js

@@ -0,0 +1,182 @@
+#!/usr/bin/env node
+
+const fs = require('fs-extra');
+const path = require('path');
+const chalk = require('chalk');
+
+/**
+ * Script para sincronizar las plantillas desde las carpetas root 
+ * hacia cli-tool/templates/
+ */
+
+async function syncTemplates() {
+  console.log(chalk.blue('🔄 Sincronizando plantillas...'));
+  
+  const rootDir = path.join(__dirname, '..', '..');
+  const templatesDir = path.join(__dirname, '..', 'templates');
+  
+  // Lenguajes a sincronizar
+  const languages = ['common', 'javascript-typescript', 'python', 'rust', 'go'];
+  
+  let totalCopied = 0;
+  let totalSkipped = 0;
+  
+  for (const language of languages) {
+    const sourceDir = path.join(rootDir, language);
+    const targetDir = path.join(templatesDir, language);
+    
+    if (!await fs.pathExists(sourceDir)) {
+      console.log(chalk.yellow(`⚠️  Carpeta source no existe: ${language}`));
+      continue;
+    }
+    
+    console.log(chalk.cyan(`\n📂 Sincronizando ${language}...`));
+    
+    // Limpiar directorio destino
+    if (await fs.pathExists(targetDir)) {
+      await fs.remove(targetDir);
+      console.log(chalk.gray(`   🗑️  Directorio anterior eliminado`));
+    }
+    
+    // Copiar todo desde source
+    try {
+      await fs.copy(sourceDir, targetDir, {
+        filter: (src, dest) => {
+          // Filtrar archivos que no queremos copiar
+          const relativePath = path.relative(sourceDir, src);
+          
+          // Excluir directorios y archivos específicos
+          if (relativePath.includes('node_modules')) return false;
+          if (relativePath.includes('.git')) return false;
+          if (relativePath.includes('package-lock.json')) return false;
+          if (relativePath.endsWith('.log')) return false;
+          
+          return true;
+        }
+      });
+      
+      // Contar archivos copiados
+      const stats = await getDirectoryStats(targetDir);
+      totalCopied += stats.files;
+      
+      console.log(chalk.green(`   ✅ ${stats.files} archivos copiados`));
+      
+      // Mostrar estructura copiada
+      if (stats.files > 0) {
+        await showDirectoryStructure(targetDir, '   ');
+      }
+      
+    } catch (error) {
+      console.error(chalk.red(`   ❌ Error copiando ${language}:`), error.message);
+    }
+  }
+  
+  console.log(chalk.green(`\n🎉 Sincronización completada!`));
+  console.log(chalk.white(`📊 Total de archivos sincronizados: ${totalCopied}`));
+  
+  // Verificar que no existan archivos hooks
+  await cleanupOldReferences();
+}
+
+async function getDirectoryStats(dir) {
+  let files = 0;
+  let dirs = 0;
+  
+  if (!await fs.pathExists(dir)) {
+    return { files: 0, dirs: 0 };
+  }
+  
+  const items = await fs.readdir(dir);
+  
+  for (const item of items) {
+    const itemPath = path.join(dir, item);
+    const stat = await fs.stat(itemPath);
+    
+    if (stat.isDirectory()) {
+      dirs++;
+      const subStats = await getDirectoryStats(itemPath);
+      files += subStats.files;
+      dirs += subStats.dirs;
+    } else {
+      files++;
+    }
+  }
+  
+  return { files, dirs };
+}
+
+async function showDirectoryStructure(dir, prefix = '') {
+  const items = await fs.readdir(dir);
+  
+  for (let i = 0; i < items.length; i++) {
+    const item = items[i];
+    const itemPath = path.join(dir, item);
+    const stat = await fs.stat(itemPath);
+    const isLast = i === items.length - 1;
+    const connector = isLast ? '└── ' : '├── ';
+    
+    if (stat.isDirectory()) {
+      console.log(chalk.blue(`${prefix}${connector}${item}/`));
+      if (item === '.claude' || item === 'commands') {
+        // Mostrar solo un nivel más para .claude y commands
+        const subItems = await fs.readdir(itemPath);
+        const newPrefix = prefix + (isLast ? '    ' : '│   ');
+        for (let j = 0; j < Math.min(subItems.length, 3); j++) {
+          const subItem = subItems[j];
+          const subConnector = j === Math.min(subItems.length, 3) - 1 ? '└── ' : '├── ';
+          console.log(chalk.gray(`${newPrefix}${subConnector}${subItem}`));
+        }
+        if (subItems.length > 3) {
+          console.log(chalk.gray(`${newPrefix}└── ... y ${subItems.length - 3} más`));
+        }
+      }
+    } else {
+      console.log(chalk.gray(`${prefix}${connector}${item}`));
+    }
+  }
+}
+
+async function cleanupOldReferences() {
+  console.log(chalk.yellow('\n🧹 Limpiando referencias obsoletas...'));
+  
+  const templatesDir = path.join(__dirname, '..', 'templates');
+  
+  // Buscar y eliminar directorios hooks
+  const languages = ['javascript-typescript', 'python', 'common'];
+  
+  for (const language of languages) {
+    const hooksDir = path.join(templatesDir, language, '.claude', 'hooks');
+    if (await fs.pathExists(hooksDir)) {
+      await fs.remove(hooksDir);
+      console.log(chalk.yellow(`   🗑️  Eliminado: ${language}/.claude/hooks/`));
+    }
+  }
+  
+  // Verificar archivos vacíos en commands
+  for (const language of languages) {
+    const commandsDir = path.join(templatesDir, language, '.claude', 'commands');
+    if (await fs.pathExists(commandsDir)) {
+      const files = await fs.readdir(commandsDir);
+      for (const file of files) {
+        const filePath = path.join(commandsDir, file);
+        const stat = await fs.stat(filePath);
+        if (stat.size < 50) { // Archivos muy pequeños probablemente estén vacíos
+          const content = await fs.readFile(filePath, 'utf8');
+          if (content.trim().length < 10) {
+            console.log(chalk.yellow(`   ⚠️  Archivo posiblemente vacío: ${language}/.claude/commands/${file} (${stat.size} bytes)`));
+          }
+        }
+      }
+    }
+  }
+}
+
+// Función para ejecutar la sincronización
+if (require.main === module) {
+  syncTemplates().catch(error => {
+    console.error(chalk.red('❌ Error durante la sincronización:'), error);
+    process.exit(1);
+  });
+}
+
+module.exports = { syncTemplates };

package/src/command-scanner.js

@@ -0,0 +1,175 @@
+const fs = require('fs-extra');
+const path = require('path');
+
+/**
+ * Scans and returns available commands for a given language
+ * @param {string} language - The language template to scan
+ * @returns {Array} Array of available commands with metadata
+ */
+function getAvailableCommands(language) {
+  const templatesDir = path.join(__dirname, '..', 'templates');
+  const languageDir = path.join(templatesDir, language);
+  
+  // Check if language directory exists
+  if (!fs.existsSync(languageDir)) {
+    return [];
+  }
+  
+  const commands = [];
+  
+  // Scan main .claude/commands directory
+  const mainCommandsDir = path.join(languageDir, '.claude', 'commands');
+  if (fs.existsSync(mainCommandsDir)) {
+    const mainCommands = scanCommandsInDirectory(mainCommandsDir, 'core');
+    commands.push(...mainCommands);
+  }
+  
+  // Scan framework-specific commands in examples
+  const examplesDir = path.join(languageDir, 'examples');
+  if (fs.existsSync(examplesDir)) {
+    const frameworkDirs = fs.readdirSync(examplesDir).filter(dir => {
+      return fs.statSync(path.join(examplesDir, dir)).isDirectory();
+    });
+    
+    frameworkDirs.forEach(framework => {
+      const frameworkCommandsDir = path.join(examplesDir, framework, '.claude', 'commands');
+      if (fs.existsSync(frameworkCommandsDir)) {
+        const frameworkCommands = scanCommandsInDirectory(frameworkCommandsDir, framework);
+        commands.push(...frameworkCommands);
+      }
+    });
+  }
+  
+  // Remove duplicates based on command name
+  const uniqueCommands = commands.reduce((acc, command) => {
+    const existing = acc.find(c => c.name === command.name);
+    if (!existing) {
+      acc.push(command);
+    } else {
+      // If duplicate, prefer core commands over framework-specific ones
+      if (command.category === 'core' && existing.category !== 'core') {
+        const index = acc.findIndex(c => c.name === command.name);
+        acc[index] = command;
+      }
+    }
+    return acc;
+  }, []);
+  
+  return uniqueCommands.sort((a, b) => {
+    // Sort by category first (core first), then by name
+    if (a.category !== b.category) {
+      return a.category === 'core' ? -1 : 1;
+    }
+    return a.name.localeCompare(b.name);
+  });
+}
+
+/**
+ * Scans a directory for command files and returns command metadata
+ * @param {string} commandsDir - Directory to scan
+ * @param {string} category - Category of commands (core, react-app, node-api, etc.)
+ * @returns {Array} Array of command objects
+ */
+function scanCommandsInDirectory(commandsDir, category) {
+  const commands = [];
+  
+  try {
+    const files = fs.readdirSync(commandsDir);
+    
+    files.forEach(file => {
+      if (path.extname(file) === '.md') {
+        const commandName = path.basename(file, '.md');
+        const filePath = path.join(commandsDir, file);
+        
+        // Read the command file to extract metadata
+        const content = fs.readFileSync(filePath, 'utf8');
+        const metadata = parseCommandMetadata(content, commandName);
+        
+        commands.push({
+          name: commandName,
+          displayName: metadata.title || commandName,
+          description: metadata.description || `${commandName} command`,
+          category: category,
+          filePath: filePath,
+          checked: metadata.defaultChecked || false
+        });
+      }
+    });
+  } catch (error) {
+    console.warn(`Warning: Could not scan commands in ${commandsDir}:`, error.message);
+  }
+  
+  return commands;
+}
+
+/**
+ * Parses command metadata from markdown file content
+ * @param {string} content - The markdown content
+ * @param {string} commandName - The command name
+ * @returns {Object} Parsed metadata
+ */
+function parseCommandMetadata(content, commandName) {
+  const metadata = {
+    title: null,
+    description: null,
+    defaultChecked: false
+  };
+  
+  const lines = content.split('\n');
+  
+  // Extract title from first heading
+  for (let i = 0; i < Math.min(lines.length, 10); i++) {
+    const line = lines[i].trim();
+    if (line.startsWith('# ')) {
+      metadata.title = line.substring(2).trim();
+      break;
+    }
+  }
+  
+  // Extract description from purpose section or first paragraph
+  const purposeMatch = content.match(/## Purpose\s*\n\s*(.+?)(?=\n\n|\n##|$)/s);
+  if (purposeMatch) {
+    metadata.description = purposeMatch[1].trim().replace(/\n/g, ' ');
+  } else {
+    // Try to find first paragraph after title
+    const paragraphMatch = content.match(/^#[^\n]*\n\s*\n(.+?)(?=\n\n|\n##|$)/s);
+    if (paragraphMatch) {
+      metadata.description = paragraphMatch[1].trim().replace(/\n/g, ' ');
+    }
+  }
+  
+  // Determine default checked state (core commands usually checked by default)
+  const coreCommands = ['test', 'lint', 'debug', 'refactor'];
+  metadata.defaultChecked = coreCommands.includes(commandName);
+  
+  return metadata;
+}
+
+/**
+ * Get commands available for a specific language and framework combination
+ * @param {string} language - The language template
+ * @param {string} framework - The framework (optional)
+ * @returns {Array} Array of available commands
+ */
+function getCommandsForLanguageAndFramework(language, framework = null) {
+  const allCommands = getAvailableCommands(language);
+  
+  if (!framework || framework === 'none') {
+    // Return only core commands
+    return allCommands.filter(cmd => cmd.category === 'core');
+  }
+  
+  // Return core commands + framework-specific commands
+  return allCommands.filter(cmd => 
+    cmd.category === 'core' || 
+    cmd.category === framework ||
+    cmd.category === `${framework}-app`
+  );
+}
+
+module.exports = {
+  getAvailableCommands,
+  getCommandsForLanguageAndFramework,
+  scanCommandsInDirectory,
+  parseCommandMetadata
+};

package/src/file-operations.js

@@ -23,19 +23,51 @@ async function copyTemplateFiles(templateConfig, targetDir) {
     console.log(chalk.yellow(`📁 Existing .claude directory backed up to .claude.backup`));
   }
   
-  // Copy files
+  // Copy base files (but skip .claude/commands for now)
   for (const file of templateConfig.files) {
     const sourcePath = path.join(templateDir, file.source);
     const destPath = path.join(targetDir, file.destination);
     
     try {
-      await fs.copy(sourcePath, destPath, { overwrite: true });
+      // Skip .claude/commands directories - we'll handle them separately
+      if (file.source.includes('.claude/commands')) {
+        continue;
+      }
+      
+      await fs.copy(sourcePath, destPath, { 
+        overwrite: true,
+        filter: (src) => {
+          // Skip commands directory during base copy
+          return !src.includes('.claude/commands');
+        }
+      });
       console.log(chalk.green(`✓ Copied ${file.source} → ${file.destination}`));
     } catch (error) {
       console.error(chalk.red(`✗ Failed to copy ${file.source}:`), error.message);
       throw error;
     }
   }
+  
+  // 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`));
+  }
 }
 
 async function ensureDirectoryExists(dirPath) {

package/src/prompts.js

@@ -1,5 +1,6 @@
 const chalk = require('chalk');
 const { getAvailableLanguages, getFrameworksForLanguage } = require('./templates');
+const { getCommandsForLanguageAndFramework } = require('./command-scanner');
 
 function createPrompts(projectInfo, options = {}) {
   const prompts = [];
@@ -41,6 +42,40 @@ function createPrompts(projectInfo, options = {}) {
     });
   }
   
+  // Command selection
+  prompts.push({
+    type: 'checkbox',
+    name: 'commands',
+    message: 'Select commands to include (use space to select):',
+    choices: (answers) => {
+      const selectedLanguage = answers.language || options.language;
+      const selectedFramework = answers.framework || options.framework;
+      
+      if (!selectedLanguage || selectedLanguage === 'common') {
+        return [
+          {
+            value: 'basic-commands',
+            name: 'Basic development commands',
+            checked: true
+          }
+        ];
+      }
+      
+      const availableCommands = getCommandsForLanguageAndFramework(selectedLanguage, selectedFramework);
+      
+      return availableCommands.map(cmd => ({
+        value: cmd.name,
+        name: `${cmd.displayName} - ${cmd.description}`,
+        checked: cmd.checked
+      }));
+    },
+    prefix: chalk.cyan('📋'),
+    when: (answers) => {
+      const selectedLanguage = answers.language || options.language;
+      return selectedLanguage && selectedLanguage !== 'common';
+    }
+  });
+
   // Features selection
   prompts.push({
     type: 'checkbox',
@@ -78,7 +113,18 @@ function createPrompts(projectInfo, options = {}) {
     message: (answers) => {
       const language = answers.language || options.language || 'common';
       const framework = answers.framework || options.framework || 'none';
-      return `Setup Claude Code for ${chalk.cyan(language)}${framework !== 'none' ? ` with ${chalk.green(framework)}` : ''}?`;
+      const commandCount = answers.commands ? answers.commands.length : 0;
+      
+      let message = `Setup Claude Code for ${chalk.cyan(language)}`;
+      if (framework !== 'none') {
+        message += ` with ${chalk.green(framework)}`;
+      }
+      if (commandCount > 0) {
+        message += ` (${chalk.yellow(commandCount)} commands)`;
+      }
+      message += '?';
+      
+      return message;
     },
     default: true,
     prefix: chalk.red('🚀')

package/src/templates.js

@@ -1,4 +1,5 @@
 const path = require('path');
+const { getCommandsForLanguageAndFramework } = require('./command-scanner');
 
 const TEMPLATES_CONFIG = {
   'common': {
@@ -101,7 +102,7 @@ function getFrameworksForLanguage(language) {
 }
 
 function getTemplateConfig(selections) {
-  const { language, framework } = selections;
+  const { language, framework, commands = [] } = selections;
   const baseConfig = TEMPLATES_CONFIG[language];
   
   if (!baseConfig) {
@@ -118,10 +119,18 @@ function getTemplateConfig(selections) {
     }
   }
   
+  // Handle command selection
+  let selectedCommands = [];
+  if (commands && commands.length > 0) {
+    const availableCommands = getCommandsForLanguageAndFramework(language, framework);
+    selectedCommands = availableCommands.filter(cmd => commands.includes(cmd.name));
+  }
+  
   return {
     language,
     framework,
     files,
+    selectedCommands,
     config: baseConfig
   };
 }