claude-code-templates 1.1.1 → 1.1.3

package/bin/create-claude-config.js

@@ -6,7 +6,7 @@ const boxen = require('boxen');
 const createClaudeConfig = require('../src/index');
 
 // ASCII Art for Claude Code Templates
-const banner = chalk.cyan(`
+const banner = chalk.hex('#D97706')(`
  ██████╗██╗      █████╗ ██╗   ██╗██████╗ ███████╗
 ██╔════╝██║     ██╔══██╗██║   ██║██╔══██╗██╔════╝
 ██║     ██║     ███████║██║   ██║██║  ██║█████╗  
@@ -27,9 +27,8 @@ const banner = chalk.cyan(`
    ██║   ██╔══╝  ██║╚██╔╝██║██╔═══╝ ██║     ██╔══██║   ██║   ██╔══╝  ╚════██║
    ██║   ███████╗██║ ╚═╝ ██║██║     ███████╗██║  ██║   ██║   ███████╗███████║
    ╚═╝   ╚══════╝╚═╝     ╚═╝╚═╝     ╚══════╝╚═╝  ╚═╝   ╚═╝   ╚══════╝╚══════╝
-`) + chalk.yellow(`
-                    🚀 Setup Claude Code for any project language 🚀
-`);
+`) +
+chalk.yellow('\n     🚀 Setup Claude Code for any project language 🚀');
 
 console.log(banner);
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-templates",
-  "version": "1.1.1",
+  "version": "1.1.3",
   "description": "CLI tool to setup Claude Code configurations for different programming languages",
   "main": "src/index.js",
   "bin": {
@@ -13,8 +13,8 @@
     "start": "node bin/create-claude-config.js",
     "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!\"",
+    "presync": "echo \"🔄 Starting template synchronization...\"",
+    "postsync": "echo \"✅ Synchronization completed. Ready to publish!\"",
     "prepublishOnly": "npm run sync"
   },
   "keywords": [

package/scripts/sync-templates.js

@@ -5,17 +5,17 @@ const path = require('path');
 const chalk = require('chalk');
 
 /**
- * Script para sincronizar las plantillas desde las carpetas root 
- * hacia cli-tool/templates/
+ * Script to synchronize templates from root folders 
+ * to cli-tool/templates/
  */
 
 async function syncTemplates() {
-  console.log(chalk.blue('🔄 Sincronizando plantillas...'));
+  console.log(chalk.blue('🔄 Synchronizing templates...'));
   
   const rootDir = path.join(__dirname, '..', '..');
   const templatesDir = path.join(__dirname, '..', 'templates');
   
-  // Lenguajes a sincronizar
+  // Languages to synchronize
   const languages = ['common', 'javascript-typescript', 'python', 'rust', 'go'];
   
   let totalCopied = 0;
@@ -26,26 +26,26 @@ async function syncTemplates() {
     const targetDir = path.join(templatesDir, language);
     
     if (!await fs.pathExists(sourceDir)) {
-      console.log(chalk.yellow(`⚠️  Carpeta source no existe: ${language}`));
+      console.log(chalk.yellow(`⚠️  Source folder does not exist: ${language}`));
       continue;
     }
     
-    console.log(chalk.cyan(`\n📂 Sincronizando ${language}...`));
+    console.log(chalk.cyan(`\n📂 Synchronizing ${language}...`));
     
-    // Limpiar directorio destino
+    // Clean destination directory
     if (await fs.pathExists(targetDir)) {
       await fs.remove(targetDir);
-      console.log(chalk.gray(`   🗑️  Directorio anterior eliminado`));
+      console.log(chalk.gray(`   🗑️  Previous directory removed`));
     }
     
-    // Copiar todo desde source
+    // Copy everything from source
     try {
       await fs.copy(sourceDir, targetDir, {
         filter: (src, dest) => {
-          // Filtrar archivos que no queremos copiar
+          // Filter files we don't want to copy
           const relativePath = path.relative(sourceDir, src);
           
-          // Excluir directorios y archivos específicos
+          // Exclude specific directories and files
           if (relativePath.includes('node_modules')) return false;
           if (relativePath.includes('.git')) return false;
           if (relativePath.includes('package-lock.json')) return false;
@@ -55,26 +55,26 @@ async function syncTemplates() {
         }
       });
       
-      // Contar archivos copiados
+      // Count copied files
       const stats = await getDirectoryStats(targetDir);
       totalCopied += stats.files;
       
-      console.log(chalk.green(`   ✅ ${stats.files} archivos copiados`));
+      console.log(chalk.green(`   ✅ ${stats.files} files copied`));
       
-      // Mostrar estructura copiada
+      // Show copied structure
       if (stats.files > 0) {
         await showDirectoryStructure(targetDir, '   ');
       }
       
     } catch (error) {
-      console.error(chalk.red(`   ❌ Error copiando ${language}:`), error.message);
+      console.error(chalk.red(`   ❌ Error copying ${language}:`), error.message);
     }
   }
   
-  console.log(chalk.green(`\n🎉 Sincronización completada!`));
-  console.log(chalk.white(`📊 Total de archivos sincronizados: ${totalCopied}`));
+  console.log(chalk.green(`\n🎉 Synchronization completed!`));
+  console.log(chalk.white(`📊 Total synchronized files: ${totalCopied}`));
   
-  // Verificar que no existan archivos hooks
+  // Verify that no hook files exist
   await cleanupOldReferences();
 }
 
@@ -118,7 +118,7 @@ async function showDirectoryStructure(dir, prefix = '') {
     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
+        // Show only one more level for .claude and commands
         const subItems = await fs.readdir(itemPath);
         const newPrefix = prefix + (isLast ? '    ' : '│   ');
         for (let j = 0; j < Math.min(subItems.length, 3); j++) {
@@ -127,7 +127,7 @@ async function showDirectoryStructure(dir, prefix = '') {
           console.log(chalk.gray(`${newPrefix}${subConnector}${subItem}`));
         }
         if (subItems.length > 3) {
-          console.log(chalk.gray(`${newPrefix}└── ... y ${subItems.length - 3} más`));
+          console.log(chalk.gray(`${newPrefix}└── ... and ${subItems.length - 3} more`));
         }
       }
     } else {
@@ -137,22 +137,22 @@ async function showDirectoryStructure(dir, prefix = '') {
 }
 
 async function cleanupOldReferences() {
-  console.log(chalk.yellow('\n🧹 Limpiando referencias obsoletas...'));
+  console.log(chalk.yellow('\n🧹 Cleaning up obsolete references...'));
   
   const templatesDir = path.join(__dirname, '..', 'templates');
   
-  // Buscar y eliminar directorios hooks
+  // Search and remove hooks directories
   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/`));
+      console.log(chalk.yellow(`   🗑️  Removed: ${language}/.claude/hooks/`));
     }
   }
   
-  // Verificar archivos vacíos en commands
+  // Check for empty files in commands
   for (const language of languages) {
     const commandsDir = path.join(templatesDir, language, '.claude', 'commands');
     if (await fs.pathExists(commandsDir)) {
@@ -160,10 +160,10 @@ async function cleanupOldReferences() {
       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
+        if (stat.size < 50) { // Very small files are probably empty
           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)`));
+            console.log(chalk.yellow(`   ⚠️  Possibly empty file: ${language}/.claude/commands/${file} (${stat.size} bytes)`));
           }
         }
       }
@@ -171,10 +171,10 @@ async function cleanupOldReferences() {
   }
 }
 
-// Función para ejecutar la sincronización
+// Function to execute synchronization
 if (require.main === module) {
   syncTemplates().catch(error => {
-    console.error(chalk.red('❌ Error durante la sincronización:'), error);
+    console.error(chalk.red('❌ Error during synchronization:'), error);
     process.exit(1);
   });
 }

package/src/command-scanner.js

@@ -87,8 +87,8 @@ function scanCommandsInDirectory(commandsDir, category) {
         
         commands.push({
           name: commandName,
-          displayName: metadata.title || commandName,
-          description: metadata.description || `${commandName} command`,
+          displayName: createShortDisplayName(commandName, metadata.title),
+          description: createShortDescription(metadata.description, commandName),
           category: category,
           filePath: filePath,
           checked: metadata.defaultChecked || false
@@ -145,6 +145,104 @@ function parseCommandMetadata(content, commandName) {
   return metadata;
 }
 
+/**
+ * Creates a short display name from command name for better console display
+ * @param {string} commandName - The command name
+ * @param {string} title - The full title from markdown
+ * @returns {string} Short display name
+ */
+function createShortDisplayName(commandName, title) {
+  // Define mapping for common command names to short display names
+  const shortNames = {
+    'api-endpoint': 'API Endpoint',
+    'debug': 'Debug',
+    'lint': 'Lint',
+    'test': 'Test',
+    'refactor': 'Refactor',
+    'typescript-migrate': 'TS Migration',
+    'npm-scripts': 'NPM Scripts',
+    'component': 'Component',
+    'hooks': 'Hooks',
+    'state-management': 'State Mgmt',
+    'middleware': 'Middleware',
+    'route': 'Route',
+    'database': 'Database',
+    'components': 'Components',
+    'services': 'Services',
+    'composables': 'Composables',
+    'django-model': 'Django Model',
+    'flask-route': 'Flask Route',
+    'git-workflow': 'Git Workflow',
+    'project-setup': 'Project Setup'
+  };
+  
+  // Return predefined short name if available
+  if (shortNames[commandName]) {
+    return shortNames[commandName];
+  }
+  
+  // If title is short enough, use it
+  if (title && title.length <= 15) {
+    return title;
+  }
+  
+  // Create short name from command name
+  return commandName
+    .split('-')
+    .map(word => word.charAt(0).toUpperCase() + word.slice(1))
+    .join(' ');
+}
+
+/**
+ * Creates a short description for better console display
+ * @param {string} description - The full description
+ * @param {string} commandName - The command name
+ * @returns {string} Short description
+ */
+function createShortDescription(description, commandName) {
+  // Define short descriptions for common commands
+  const shortDescriptions = {
+    'api-endpoint': 'Generate API endpoint',
+    'debug': 'Debug issues',
+    'lint': 'Fix linting issues',
+    'test': 'Run tests',
+    'refactor': 'Refactor code',
+    'typescript-migrate': 'Migrate to TypeScript',
+    'npm-scripts': 'Manage NPM scripts',
+    'component': 'Create component',
+    'hooks': 'React hooks helper',
+    'state-management': 'Manage state',
+    'middleware': 'Create middleware',
+    'route': 'Create route',
+    'database': 'Database operations',
+    'components': 'Create components',
+    'services': 'Create services',
+    'composables': 'Create composables',
+    'django-model': 'Create Django model',
+    'flask-route': 'Create Flask route',
+    'git-workflow': 'Git workflow helper',
+    'project-setup': 'Setup project'
+  };
+  
+  // Return predefined short description if available
+  if (shortDescriptions[commandName]) {
+    return shortDescriptions[commandName];
+  }
+  
+  // If description exists and is short enough, use it
+  if (description && description.length <= 40) {
+    return description;
+  }
+  
+  // Truncate long descriptions
+  if (description && description.length > 40) {
+    return description.substring(0, 37) + '...';
+  }
+  
+  // Fallback to command name
+  return `${commandName.replace('-', ' ')} command`;
+}
+
 /**
  * Get commands available for a specific language and framework combination
  * @param {string} language - The language template
@@ -171,5 +269,7 @@ module.exports = {
   getAvailableCommands,
   getCommandsForLanguageAndFramework,
   scanCommandsInDirectory,
-  parseCommandMetadata
+  parseCommandMetadata,
+  createShortDisplayName,
+  createShortDescription
 };

package/src/file-operations.js

@@ -23,25 +23,68 @@ async function copyTemplateFiles(templateConfig, targetDir) {
     console.log(chalk.yellow(`📁 Existing .claude directory backed up to .claude.backup`));
   }
   
-  // Copy base files (but skip .claude/commands for now)
+  // 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 {
-      // 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');
+      // Handle framework-specific command files specially
+      if (file.source.includes('.claude/commands') && file.source.includes('examples/')) {
+        // 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);
+          await fs.copy(srcFile, destFile, { overwrite: true });
+        }
+        
+        console.log(chalk.green(`✓ Copied 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: true,
+          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');
+        
+        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
+          
+          for (const baseCommand of baseCommands) {
+            if (!excludeCommands.includes(baseCommand)) {
+              const srcFile = path.join(baseCommandsPath, baseCommand);
+              const destFile = path.join(destCommandsPath, baseCommand);
+              await fs.copy(srcFile, destFile, { overwrite: true });
+            }
+          }
         }
-      });
-      console.log(chalk.green(`✓ Copied ${file.source} → ${file.destination}`));
+        
+        console.log(chalk.green(`✓ Copied base configuration and commands ${file.source} → ${file.destination}`));
+      } else {
+        // Copy regular files (CLAUDE.md, settings.json, etc.)
+        await fs.copy(sourcePath, destPath, { 
+          overwrite: true,
+          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}`));
+      }
     } catch (error) {
       console.error(chalk.red(`✗ Failed to copy ${file.source}:`), error.message);
       throw error;

package/src/index.js

@@ -5,7 +5,7 @@ const path = require('path');
 const ora = require('ora');
 const { detectProject } = require('./utils');
 const { getTemplateConfig } = require('./templates');
-const { createPrompts } = require('./prompts');
+const { createPrompts, interactivePrompts } = require('./prompts');
 const { copyTemplateFiles } = require('./file-operations');
 
 async function createClaudeConfig(options = {}) {
@@ -19,9 +19,6 @@ async function createClaudeConfig(options = {}) {
   const projectInfo = await detectProject(targetDir);
   spinner.succeed('Project detection complete');
   
-  // Create interactive prompts
-  const prompts = createPrompts(projectInfo, options);
-  
   let config;
   if (options.yes) {
     // Use defaults
@@ -31,8 +28,8 @@ async function createClaudeConfig(options = {}) {
       features: []
     };
   } else {
-    // Interactive prompts
-    config = await inquirer.prompt(prompts);
+    // Interactive prompts with back navigation
+    config = await interactivePrompts(projectInfo, options);
   }
   
   // Check if user confirmed the setup

package/src/prompts.js

@@ -1,7 +1,169 @@
 const chalk = require('chalk');
+const inquirer = require('inquirer');
 const { getAvailableLanguages, getFrameworksForLanguage } = require('./templates');
 const { getCommandsForLanguageAndFramework } = require('./command-scanner');
 
+async function interactivePrompts(projectInfo, options = {}) {
+  const state = {
+    currentStep: 0,
+    answers: {},
+    steps: []
+  };
+
+  // Build steps array based on options
+  if (!options.language) state.steps.push('language');
+  if (!options.framework) state.steps.push('framework');
+  state.steps.push('commands', 'confirm');
+
+  while (state.currentStep < state.steps.length) {
+    const stepName = state.steps[state.currentStep];
+    const result = await showStep(stepName, state.answers, projectInfo, options);
+    
+    if (result.action === 'back') {
+      if (state.currentStep > 0) {
+        state.currentStep--;
+        // Clear the answer for the step we're going back from
+        delete state.answers[stepName];
+      }
+    } else if (result.action === 'next') {
+      state.answers[stepName] = result.value;
+      state.currentStep++;
+    } else if (result.action === 'exit') {
+      return { confirm: false };
+    }
+  }
+
+  return state.answers;
+}
+
+async function showStep(stepName, currentAnswers, projectInfo, options) {
+  const stepConfig = getStepConfig(stepName, currentAnswers, projectInfo, options);
+  
+  if (!stepConfig) {
+    return { action: 'next', value: null };
+  }
+
+  // Add back option if not first step
+  const isFirstStep = stepName === 'language' || (options.language && stepName === 'framework') || 
+                      (options.language && options.framework && stepName === 'commands');
+  
+  if (!isFirstStep && stepConfig.type === 'list') {
+    stepConfig.choices = [
+      { value: '__back__', name: chalk.gray('← Back') },
+      new inquirer.Separator(),
+      ...stepConfig.choices
+    ];
+  }
+
+  const answer = await inquirer.prompt([stepConfig]);
+  const value = answer[stepName];
+
+  if (value === '__back__') {
+    return { action: 'back' };
+  }
+
+  return { action: 'next', value };
+}
+
+function getStepConfig(stepName, currentAnswers, projectInfo, options) {
+  switch (stepName) {
+    case 'language':
+      return {
+        type: 'list',
+        name: 'language',
+        message: 'Select your programming language:',
+        choices: getAvailableLanguages(),
+        default: projectInfo.detectedLanguage || 'common',
+        prefix: chalk.blue('🔤')
+      };
+
+    case 'framework':
+      const selectedLanguage = currentAnswers.language || options.language;
+      const frameworks = getFrameworksForLanguage(selectedLanguage);
+      
+      if (frameworks.length === 0) {
+        return null; // Skip this step
+      }
+      
+      return {
+        type: 'list',
+        name: 'framework',
+        message: 'Select your framework (optional):',
+        choices: [
+          { value: 'none', name: 'None / Generic' },
+          ...frameworks
+        ],
+        default: projectInfo.detectedFramework || 'none',
+        prefix: chalk.green('🎯')
+      };
+
+    case 'commands':
+      const commandLanguage = currentAnswers.language || options.language;
+      const commandFramework = currentAnswers.framework || options.framework;
+      
+      if (!commandLanguage || commandLanguage === 'common') {
+        return {
+          type: 'checkbox',
+          name: 'commands',
+          message: 'Select commands to include (use space to select):',
+          choices: [
+            {
+              value: 'basic-commands',
+              name: 'Basic development commands',
+              checked: true
+            }
+          ],
+          prefix: chalk.cyan('📋')
+        };
+      }
+      
+      const availableCommands = getCommandsForLanguageAndFramework(commandLanguage, commandFramework);
+      
+      return {
+        type: 'checkbox',
+        name: 'commands',
+        message: 'Select commands to include (use space to select, enter to continue):',
+        choices: availableCommands.map(cmd => ({
+          value: cmd.name,
+          name: `${cmd.displayName} - ${cmd.description}`,
+          checked: cmd.checked
+        })),
+        prefix: chalk.cyan('📋')
+      };
+
+    case 'confirm':
+      const confirmLanguage = currentAnswers.language || options.language || 'common';
+      const confirmFramework = currentAnswers.framework || options.framework || 'none';
+      const commandCount = currentAnswers.commands ? currentAnswers.commands.length : 0;
+      
+      let message = `Setup Claude Code for ${chalk.cyan(confirmLanguage)}`;
+      if (confirmFramework !== 'none') {
+        message += ` with ${chalk.green(confirmFramework)}`;
+      }
+      if (commandCount > 0) {
+        message += ` (${chalk.yellow(commandCount)} commands)`;
+      }
+      message += '?';
+      
+      return {
+        type: 'list',
+        name: 'confirm',
+        message,
+        choices: [
+          { value: '__back__', name: chalk.gray('← Back to modify settings') },
+          new inquirer.Separator(),
+          { value: true, name: chalk.green('✅ Yes, proceed with setup') },
+          { value: false, name: chalk.red('❌ No, cancel setup') }
+        ],
+        default: true,
+        prefix: chalk.red('🚀')
+      };
+
+    default:
+      return null;
+  }
+}
+
 function createPrompts(projectInfo, options = {}) {
   const prompts = [];
   
@@ -76,35 +238,6 @@ function createPrompts(projectInfo, options = {}) {
     }
   });
 
-  // Features selection
-  prompts.push({
-    type: 'checkbox',
-    name: 'features',
-    message: 'Select additional features:',
-    choices: [
-      {
-        value: 'git-hooks',
-        name: 'Git hooks integration',
-        checked: false
-      },
-      {
-        value: 'testing',
-        name: 'Enhanced testing commands',
-        checked: true
-      },
-      {
-        value: 'linting',
-        name: 'Code linting and formatting',
-        checked: true
-      },
-      {
-        value: 'debugging',
-        name: 'Debugging helpers',
-        checked: false
-      }
-    ],
-    prefix: chalk.yellow('⚙️')
-  });
   
   // Confirmation
   prompts.push({
@@ -152,5 +285,6 @@ function createProjectTypePrompt(detectedTypes) {
 
 module.exports = {
   createPrompts,
-  createProjectTypePrompt
+  createProjectTypePrompt,
+  interactivePrompts
 };