claude-code-templates 1.10.0 → 1.11.0

package/src/file-operations.js

@@ -1,29 +1,117 @@
 const fs = require('fs-extra');
 const path = require('path');
 const chalk = require('chalk');
+const inquirer = require('inquirer');
 const { getHooksForLanguage, filterHooksBySelection, getMCPsForLanguage, filterMCPsBySelection } = require('./hook-scanner');
 
-async function copyTemplateFiles(templateConfig, targetDir) {
-  const templateDir = path.join(__dirname, '../templates');
+async function checkExistingFiles(targetDir, templateConfig) {
+  const existingFiles = [];
   
-  // Check if CLAUDE.md already exists
+  // Check for existing CLAUDE.md
   const claudeFile = path.join(targetDir, 'CLAUDE.md');
   if (await fs.pathExists(claudeFile)) {
-    // Create backup
-    const backupFile = path.join(targetDir, 'CLAUDE.md.backup');
-    await fs.copy(claudeFile, backupFile);
-    console.log(chalk.yellow(`📋 Existing CLAUDE.md backed up to CLAUDE.md.backup`));
+    existingFiles.push('CLAUDE.md');
   }
   
-  // Check if .claude directory already exists
+  // Check for existing .claude directory
   const claudeDir = path.join(targetDir, '.claude');
   if (await fs.pathExists(claudeDir)) {
-    // Create backup
-    const backupDir = path.join(targetDir, '.claude.backup');
-    await fs.copy(claudeDir, backupDir);
-    console.log(chalk.yellow(`📁 Existing .claude directory backed up to .claude.backup`));
+    existingFiles.push('.claude/');
+  }
+  
+  // Check for existing .mcp.json
+  const mcpFile = path.join(targetDir, '.mcp.json');
+  if (await fs.pathExists(mcpFile)) {
+    existingFiles.push('.mcp.json');
+  }
+  
+  return existingFiles;
+}
+
+async function promptUserForOverwrite(existingFiles, targetDir) {
+  if (existingFiles.length === 0) {
+    return 'proceed'; // No existing files, safe to proceed
+  }
+  
+  console.log(chalk.yellow('\n⚠️  Existing Claude Code configuration detected!'));
+  console.log(chalk.yellow('The following files/directories already exist:'));
+  existingFiles.forEach(file => {
+    console.log(chalk.yellow(`   • ${file}`));
+  });
+  
+  const choices = [
+    {
+      name: '🔄 Backup and overwrite - Create backups and install new configuration',
+      value: 'backup',
+      short: 'Backup and overwrite'
+    },
+    {
+      name: '🔀 Merge configurations - Combine existing with new templates', 
+      value: 'merge',
+      short: 'Merge'
+    },
+    {
+      name: '❌ Cancel setup - Keep existing configuration unchanged',
+      value: 'cancel',
+      short: 'Cancel'
+    }
+  ];
+  
+  const answer = await inquirer.prompt([{
+    type: 'list',
+    name: 'action',
+    message: 'How would you like to proceed?',
+    choices,
+    default: 'backup'
+  }]);
+  
+  return answer.action;
+}
+
+async function createBackups(existingFiles, targetDir) {
+  const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+  
+  for (const file of existingFiles) {
+    const sourcePath = path.join(targetDir, file);
+    const backupPath = path.join(targetDir, `${file.replace('/', '')}.backup-${timestamp}`);
+    
+    try {
+      await fs.copy(sourcePath, backupPath);
+      console.log(chalk.green(`📋 Backed up ${file} → ${path.basename(backupPath)}`));
+    } catch (error) {
+      console.error(chalk.red(`✗ Failed to backup ${file}:`), error.message);
+      throw error;
+    }
+  }
+}
+
+async function copyTemplateFiles(templateConfig, targetDir, options = {}) {
+  const templateDir = path.join(__dirname, '../templates');
+  
+  // Check for existing files and get user preference
+  const existingFiles = await checkExistingFiles(targetDir, templateConfig);
+  let userAction = 'proceed';
+  
+  if (!options.yes && !options.dryRun) {
+    userAction = await promptUserForOverwrite(existingFiles, targetDir);
+    
+    if (userAction === 'cancel') {
+      console.log(chalk.blue('✓ Setup cancelled. Your existing configuration remains unchanged.'));
+      return false; // Indicate cancellation
+    }
+  } else if (existingFiles.length > 0) {
+    // In --yes mode, default to backup behavior
+    userAction = 'backup';
+  }
+  
+  // Create backups if requested
+  if (userAction === 'backup' && existingFiles.length > 0) {
+    await createBackups(existingFiles, targetDir);
   }
   
+  // Determine overwrite behavior based on user choice
+  const shouldOverwrite = userAction !== 'merge';
+  
   // Copy base files and framework-specific files
   for (const file of templateConfig.files) {
     const sourcePath = path.join(templateDir, file.source);
@@ -40,14 +128,21 @@ async function copyTemplateFiles(templateConfig, targetDir) {
         for (const frameworkFile of frameworkFiles) {
           const srcFile = path.join(sourcePath, frameworkFile);
           const destFile = path.join(destPath, frameworkFile);
-          await fs.copy(srcFile, destFile, { overwrite: true });
+          
+          // In merge mode, skip if file already exists
+          if (userAction === 'merge' && await fs.pathExists(destFile)) {
+            console.log(chalk.blue(`⏭️  Skipped ${frameworkFile} (already exists)`));
+            continue;
+          }
+          
+          await fs.copy(srcFile, destFile, { overwrite: shouldOverwrite });
         }
         
         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,
+          overwrite: shouldOverwrite,
           filter: (src) => {
             // Skip the commands directory itself - we'll handle it separately
             return !src.endsWith('.claude/commands');
@@ -69,24 +164,47 @@ async function copyTemplateFiles(templateConfig, targetDir) {
             if (!excludeCommands.includes(baseCommand)) {
               const srcFile = path.join(baseCommandsPath, baseCommand);
               const destFile = path.join(destCommandsPath, baseCommand);
-              await fs.copy(srcFile, destFile, { overwrite: true });
+              
+              // In merge mode, skip if file already exists
+              if (userAction === 'merge' && await fs.pathExists(destFile)) {
+                console.log(chalk.blue(`⏭️  Skipped ${baseCommand} (already exists)`));
+                continue;
+              }
+              
+              await fs.copy(srcFile, destFile, { overwrite: shouldOverwrite });
             }
           }
         }
         
         console.log(chalk.green(`✓ Copied base configuration and commands ${file.source} → ${file.destination}`));
       } else if (file.source.includes('settings.json') && templateConfig.selectedHooks) {
-        // Handle settings.json with hook filtering
-        await processSettingsFile(sourcePath, destPath, templateConfig);
-        console.log(chalk.green(`✓ Copied ${file.source} → ${file.destination} (with selected hooks)`));
+        // In merge mode, merge settings instead of overwriting
+        if (userAction === 'merge') {
+          await mergeSettingsFile(sourcePath, 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)`));
+        }
       } else if (file.source.includes('.mcp.json') && templateConfig.selectedMCPs) {
-        // Handle .mcp.json with MCP filtering
-        await processMCPFile(sourcePath, destPath, templateConfig);
-        console.log(chalk.green(`✓ Copied ${file.source} → ${file.destination} (with selected MCPs)`));
+        // In merge mode, merge MCP config instead of overwriting
+        if (userAction === 'merge') {
+          await mergeMCPFile(sourcePath, 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)`));
+        }
       } else {
-        // Copy regular files (CLAUDE.md, settings.json, etc.)
+        // Copy 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: true,
+          overwrite: shouldOverwrite,
           filter: (src) => {
             // Skip commands directory during regular copy - we handle them above
             return !src.includes('.claude/commands');
@@ -100,6 +218,8 @@ async function copyTemplateFiles(templateConfig, targetDir) {
     }
   }
   
+  return true; // Indicate successful completion
+  
   // Copy selected commands individually
   if (templateConfig.selectedCommands && templateConfig.selectedCommands.length > 0) {
     const commandsDir = path.join(targetDir, '.claude', 'commands');

package/src/hook-scanner.js

@@ -123,6 +123,10 @@ function getHookDescription(hook, matcher, type) {
     return 'Block print() statements in Python files';
   }
   
+  if (command.includes('puts\\|p ') && command.includes('rb$')) {
+    return 'Block puts/p statements in Ruby files';
+  }
+  
   if (command.includes('fmt.Print') && command.includes('go$')) {
     return 'Block fmt.Print statements in Go files';
   }
@@ -131,7 +135,7 @@ function getHookDescription(hook, matcher, type) {
     return 'Block println! macros in Rust files';
   }
   
-  if (command.includes('npm audit') || command.includes('pip-audit') || command.includes('cargo audit')) {
+  if (command.includes('npm audit') || command.includes('pip-audit') || command.includes('bundle audit') || command.includes('cargo audit')) {
     return 'Security audit for dependencies';
   }
   
@@ -143,6 +147,18 @@ function getHookDescription(hook, matcher, type) {
     return 'Auto-format Python files with Black';
   }
   
+  if (command.includes('rubocop -A') && command.includes('rb$')) {
+    return 'Auto-format Ruby files with RuboCop';
+  }
+  
+  if (command.includes('rubocop') && command.includes('rb$') && !command.includes('-A')) {
+    return 'Run Ruby linting with RuboCop';
+  }
+  
+  if (command.includes('brakeman')) {
+    return 'Run Ruby security scan with Brakeman';
+  }
+  
   if (command.includes('isort') && command.includes('py$')) {
     return 'Auto-sort Python imports with isort';
   }
@@ -195,6 +211,10 @@ function getHookDescription(hook, matcher, type) {
     return 'Auto-run Python tests for modified files';
   }
   
+  if (command.includes('rspec')) {
+    return 'Auto-run Ruby tests with RSpec';
+  }
+  
   if (command.includes('go test')) {
     return 'Auto-run Go tests for modified files';
   }

package/src/index.js

@@ -28,6 +28,11 @@ async function showMainMenu() {
         value: 'analytics',
         short: 'Analytics Dashboard'
       },
+      {
+        name: '💬 Chats Dashboard - View and analyze your Claude conversations',
+        value: 'chats',
+        short: 'Chats Dashboard'
+      },
       {
         name: '🔍 Health Check - Verify your Claude Code setup and configuration',
         value: 'health',
@@ -48,6 +53,12 @@ async function showMainMenu() {
     return;
   }
   
+  if (initialChoice.action === 'chats') {
+    console.log(chalk.blue('💬 Launching Claude Code Chats Dashboard...'));
+    await runAnalytics({ openTo: 'agents' });
+    return;
+  }
+  
   if (initialChoice.action === 'health') {
     console.log(chalk.blue('🔍 Running Health Check...'));
     const healthResult = await runHealthCheck();
@@ -93,6 +104,12 @@ async function createClaudeConfig(options = {}) {
     return;
   }
   
+  // Handle chats/agents dashboard
+  if (options.chats || options.agents) {
+    await runAnalytics({ ...options, openTo: 'agents' });
+    return;
+  }
+  
   // Handle health check
   let shouldRunSetup = false;
   if (options.healthCheck || options.health || options.check || options.verify) {
@@ -187,7 +204,11 @@ async function createClaudeConfig(options = {}) {
   // Copy template files
   const copySpinner = ora('Copying template files...').start();
   try {
-    await copyTemplateFiles(templateConfig, targetDir);
+    const result = await copyTemplateFiles(templateConfig, targetDir, options);
+    if (result === false) {
+      copySpinner.info('Setup cancelled by user');
+      return; // Exit early if user cancelled
+    }
     copySpinner.succeed('Template files copied successfully');
   } catch (error) {
     copySpinner.fail('Failed to copy template files');
@@ -200,6 +221,8 @@ async function createClaudeConfig(options = {}) {
   console.log(chalk.white('  1. Review the generated CLAUDE.md file'));
   console.log(chalk.white('  2. Customize the configuration for your project'));
   console.log(chalk.white('  3. Start using Claude Code with: claude'));
+  console.log('');
+  console.log(chalk.blue('🌐 View all available templates at: https://davila7.github.io/claude-code-templates/'));
   
   if (config.language !== 'common') {
     console.log(chalk.yellow(`💡 Language-specific features for ${config.language} have been configured`));

package/src/templates.js

@@ -8,6 +8,7 @@ const TEMPLATES_CONFIG = {
     files: [
       { source: 'common/CLAUDE.md', destination: 'CLAUDE.md' },
       { source: 'common/.claude', destination: '.claude' },
+      { source: 'common/.claude/settings.json', destination: '.claude/settings.json' },
       { source: 'common/.mcp.json', destination: '.mcp.json' }
     ]
   },
@@ -17,6 +18,7 @@ const TEMPLATES_CONFIG = {
     files: [
       { source: 'javascript-typescript/CLAUDE.md', destination: 'CLAUDE.md' },
       { source: 'javascript-typescript/.claude', destination: '.claude' },
+      { source: 'javascript-typescript/.claude/settings.json', destination: '.claude/settings.json' },
       { source: 'javascript-typescript/.mcp.json', destination: '.mcp.json' }
     ],
     frameworks: {
@@ -52,6 +54,7 @@ const TEMPLATES_CONFIG = {
     files: [
       { source: 'python/CLAUDE.md', destination: 'CLAUDE.md' },
       { source: 'python/.claude', destination: '.claude' },
+      { source: 'python/.claude/settings.json', destination: '.claude/settings.json' },
       { source: 'python/.mcp.json', destination: '.mcp.json' }
     ],
     frameworks: {
@@ -76,6 +79,31 @@ const TEMPLATES_CONFIG = {
       }
     }
   },
+  'ruby': {
+    name: 'Ruby',
+    description: 'Optimized for Ruby development with modern tools',
+    files: [
+      { source: 'ruby/CLAUDE.md', destination: 'CLAUDE.md' },
+      { source: 'ruby/.claude', destination: '.claude' },
+      { source: 'ruby/.claude/settings.json', destination: '.claude/settings.json' },
+      { source: 'ruby/.mcp.json', destination: '.mcp.json' }
+    ],
+    frameworks: {
+      'rails': {
+        name: 'Ruby on Rails 8',
+        additionalFiles: [
+          { source: 'ruby/examples/rails-app/.claude/commands', destination: '.claude/commands' },
+          { source: 'ruby/examples/rails-app/CLAUDE.md', destination: 'CLAUDE.md' }
+        ]
+      },
+      'sinatra': {
+        name: 'Sinatra',
+        additionalFiles: [
+          { source: 'ruby/examples/sinatra-app/.claude/commands', destination: '.claude/commands' }
+        ]
+      }
+    }
+  },
   'rust': {
     name: 'Rust',
     description: 'Optimized for Rust development',

package/src/test-console-bridge.js

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+
+const ConsoleBridge = require('./console-bridge');
+const chalk = require('chalk');
+
+/**
+ * Test script for the Console Bridge
+ */
+async function testConsoleBridge() {
+  console.log(chalk.blue('🧪 Testing Console Bridge Integration'));
+  console.log(chalk.gray('This will monitor running Claude Code processes and enable web-based interaction'));
+  console.log('');
+  
+  // Create console bridge instance
+  const bridge = new ConsoleBridge({
+    port: 3334,
+    debug: true
+  });
+  
+  try {
+    // Initialize the bridge
+    const success = await bridge.initialize();
+    
+    if (!success) {
+      console.error(chalk.red('❌ Failed to initialize Console Bridge'));
+      process.exit(1);
+    }
+    
+    console.log('');
+    console.log(chalk.green('✅ Console Bridge is running!'));
+    console.log(chalk.cyan('📡 WebSocket server: ws://localhost:3334'));
+    console.log(chalk.cyan('🌐 Web interface should connect to this WebSocket'));
+    console.log('');
+    console.log(chalk.yellow('💡 Instructions:'));
+    console.log('  1. Open your analytics dashboard (npm run analytics:start)');
+    console.log('  2. Navigate to the Agents page');
+    console.log('  3. The console interaction panel should appear when Claude Code prompts are detected');
+    console.log('  4. Run Claude Code in another terminal to test interaction');
+    console.log('');
+    console.log(chalk.gray('Press Ctrl+C to stop the bridge'));
+    
+    // Handle graceful shutdown
+    process.on('SIGINT', async () => {
+      console.log('');
+      console.log(chalk.yellow('🛑 Shutting down Console Bridge...'));
+      await bridge.shutdown();
+      process.exit(0);
+    });
+    
+    process.on('SIGTERM', async () => {
+      await bridge.shutdown();
+      process.exit(0);
+    });
+    
+    // Keep the process running
+    setInterval(() => {
+      // Heartbeat to keep process alive
+    }, 1000);
+    
+  } catch (error) {
+    console.error(chalk.red('❌ Error running Console Bridge:'), error);
+    process.exit(1);
+  }
+}
+
+// Run the test
+testConsoleBridge();

package/src/utils.js

@@ -60,6 +60,50 @@ async function detectProject(targetDir) {
     }
   }
   
+  // Check for Ruby files
+  const rubyFiles = await findFilesByExtension(targetDir, ['.rb']);
+  const gemfilePath = path.join(targetDir, 'Gemfile');
+  const gemfileLockPath = path.join(targetDir, 'Gemfile.lock');
+  
+  if (rubyFiles.length > 0 || await fs.pathExists(gemfilePath)) {
+    detectedLanguages.push('ruby');
+    
+    // Check for Ruby frameworks
+    if (await fs.pathExists(gemfilePath)) {
+      try {
+        const gemfile = await fs.readFile(gemfilePath, 'utf-8');
+        if (gemfile.includes('rails')) {
+          detectedFrameworks.push('rails');
+        }
+        if (gemfile.includes('sinatra')) {
+          detectedFrameworks.push('sinatra');
+        }
+      } catch (error) {
+        console.warn('Could not parse Gemfile');
+      }
+    }
+    
+    // Check for Rails application structure
+    const railsAppPath = path.join(targetDir, 'config', 'application.rb');
+    const railsRoutesPath = path.join(targetDir, 'config', 'routes.rb');
+    if (await fs.pathExists(railsAppPath) || await fs.pathExists(railsRoutesPath)) {
+      detectedFrameworks.push('rails');
+    }
+    
+    // Check for Rakefile (common in Rails and Ruby projects)
+    const rakefilePath = path.join(targetDir, 'Rakefile');
+    if (await fs.pathExists(rakefilePath)) {
+      try {
+        const rakefile = await fs.readFile(rakefilePath, 'utf-8');
+        if (rakefile.includes('Rails.application.load_tasks')) {
+          detectedFrameworks.push('rails');
+        }
+      } catch (error) {
+        // Ignore parsing errors
+      }
+    }
+  }
+  
   // Check for Rust files
   const rustFiles = await findFilesByExtension(targetDir, ['.rs']);
   const cargoPath = path.join(targetDir, 'Cargo.toml');
@@ -145,6 +189,7 @@ async function getProjectSummary(targetDir) {
     hasGit: await fs.pathExists(path.join(targetDir, '.git')),
     hasNodeModules: await fs.pathExists(path.join(targetDir, 'node_modules')),
     hasVenv: await fs.pathExists(path.join(targetDir, 'venv')) || await fs.pathExists(path.join(targetDir, '.venv')),
+    hasBundle: await fs.pathExists(path.join(targetDir, 'vendor', 'bundle')),
     configFiles: []
   };
   
@@ -152,6 +197,7 @@ async function getProjectSummary(targetDir) {
   const configFiles = [
     'package.json', 'tsconfig.json', 'webpack.config.js', 'vite.config.js',
     'requirements.txt', 'setup.py', 'pyproject.toml', 'Pipfile',
+    'Gemfile', 'Gemfile.lock', 'Rakefile', 'config.ru',
     'Cargo.toml', 'go.mod', '.gitignore', 'README.md'
   ];