claude-code-templates 1.4.3 → 1.5.1

package/src/hook-stats.js

@@ -0,0 +1,258 @@
+const fs = require('fs-extra');
+const path = require('path');
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+const { spawn } = require('child_process');
+
+function estimateTokens(text) {
+  if (!text || typeof text !== 'string') return 0;
+  
+  // Clean the text and estimate tokens
+  const cleanText = text.replace(/\s+/g, ' ').trim();
+  const baseTokens = Math.ceil(cleanText.length / 4);
+  
+  // Add extra tokens for code blocks and complex structures
+  const codeBlocks = (text.match(/```[\s\S]*?```/g) || []).length;
+  const inlineCode = (text.match(/`[^`]+`/g) || []).length;
+  const jsonBlocks = (text.match(/\{[\s\S]*?\}/g) || []).length;
+  
+  const adjustedTokens = baseTokens + (codeBlocks * 5) + (inlineCode * 2) + (jsonBlocks * 3);
+  return Math.max(adjustedTokens, 1);
+}
+
+async function analyzeHooks(targetDir = process.cwd()) {
+  const settingsPath = path.join(targetDir, '.claude', 'settings.json');
+  
+  console.log(chalk.blue('🔍 Analyzing automation hooks...'));
+  console.log(chalk.gray(`Scanning: ${settingsPath}`));
+
+  if (!await fs.pathExists(settingsPath)) {
+    console.log(chalk.yellow('⚠️  No .claude/settings.json file found.'));
+    return null;
+  }
+
+  try {
+    const settingsContent = await fs.readFile(settingsPath, 'utf8');
+    const settings = JSON.parse(settingsContent);
+    
+    if (!settings.hooks || Object.keys(settings.hooks).length === 0) {
+      console.log(chalk.yellow('⚠️  No automation hooks found in settings.json.'));
+      return null;
+    }
+
+    const hookAnalysis = {
+      totalHooks: 0,
+      byType: {},
+      hooks: []
+    };
+
+    // Analyze each hook type
+    for (const [hookType, hooks] of Object.entries(settings.hooks)) {
+      if (!Array.isArray(hooks)) continue;
+      
+      hookAnalysis.byType[hookType] = {
+        count: hooks.length,
+        hooks: []
+      };
+
+      for (const hook of hooks) {
+        const hookData = {
+          type: hookType,
+          name: hook.name || 'Unnamed Hook',
+          description: hook.description || '',
+          scriptContent: hook.script || hook.command || '',
+          enabled: hook.enabled !== false, // Default to true if not specified
+          conditions: hook.conditions || [],
+          size: JSON.stringify(hook).length,
+          lines: (hook.script || hook.command || '').split('\n').length,
+          words: (hook.script || hook.command || '').split(/\s+/).filter(word => word.length > 0).length,
+          tokens: estimateTokens(JSON.stringify(hook))
+        };
+
+        hookAnalysis.byType[hookType].hooks.push(hookData);
+        hookAnalysis.hooks.push(hookData);
+        hookAnalysis.totalHooks++;
+      }
+    }
+
+    // Get file stats
+    const stats = await fs.stat(settingsPath);
+    hookAnalysis.fileSize = stats.size;
+    hookAnalysis.lastModified = stats.mtime;
+
+    return hookAnalysis;
+
+  } catch (error) {
+    console.error(chalk.red('❌ Error reading settings.json:'), error.message);
+    return null;
+  }
+}
+
+function displayHookStats(analysis) {
+  if (!analysis || analysis.totalHooks === 0) {
+    console.log(chalk.yellow('\n📊 Hook Analysis Results'));
+    console.log(chalk.gray('No automation hooks found to analyze.'));
+    return;
+  }
+
+  console.log(chalk.blue('\n📊 Hook Analysis Results'));
+  console.log(chalk.gray(`File: .claude/settings.json (${analysis.fileSize} bytes)`));
+  console.log(chalk.gray(`Last Modified: ${analysis.lastModified.toLocaleDateString()}`));
+  console.log(chalk.gray(`Total Hooks: ${analysis.totalHooks}`));
+
+  // Calculate column widths
+  const maxNameLength = Math.max(
+    ...analysis.hooks.map(hook => hook.name.length),
+    'Hook Name'.length
+  );
+  const nameWidth = Math.min(maxNameLength, 30);
+
+  // Header
+  const header = chalk.bold.blue(
+    'Hook Name'.padEnd(nameWidth) + ' │ ' +
+    'Type'.padEnd(12) + ' │ ' +
+    'Status'.padEnd(8) + ' │ ' +
+    'Description'
+  );
+
+  const separator = '─'.repeat(nameWidth) + '─┼─' +
+    '─'.repeat(12) + '─┼─' +
+    '─'.repeat(8) + '─┼─' +
+    '─'.repeat(40);
+
+  console.log('\n' + header);
+  console.log(chalk.gray(separator));
+
+  // Hook rows
+  analysis.hooks.forEach(hook => {
+    const truncatedName = hook.name.length > nameWidth ? 
+      hook.name.substring(0, nameWidth - 3) + '...' : 
+      hook.name;
+    
+    const statusColor = hook.enabled ? chalk.green : chalk.yellow;
+    const status = hook.enabled ? 'Enabled' : 'Disabled';
+    
+    const truncatedDesc = hook.description.length > 40 ? 
+      hook.description.substring(0, 37) + '...' : 
+      hook.description;
+
+    const row = 
+      truncatedName.padEnd(nameWidth) + ' │ ' +
+      hook.type.padEnd(12) + ' │ ' +
+      statusColor(status.padEnd(8)) + ' │ ' +
+      chalk.gray(truncatedDesc);
+
+    console.log(row);
+  });
+
+  // Summary by type
+  console.log(chalk.blue('\n📈 Hook Summary by Type:'));
+  for (const [type, data] of Object.entries(analysis.byType)) {
+    const enabledCount = data.hooks.filter(h => h.enabled).length;
+    const disabledCount = data.hooks.filter(h => !h.enabled).length;
+    
+    console.log(chalk.gray(`  ${type}: ${data.count} hooks`) + 
+      chalk.green(` (${enabledCount} enabled`) + 
+      (disabledCount > 0 ? chalk.yellow(`, ${disabledCount} disabled)`) : chalk.green(')')));
+  }
+
+  console.log(chalk.blue('\n🔧 Hook Types Found:'));
+  Object.keys(analysis.byType).forEach(type => {
+    console.log(chalk.gray(`  • ${type}`));
+  });
+}
+
+async function runHookStats(options) {
+  const targetDir = options.directory || process.cwd();
+  
+  console.log(chalk.blue('🔧 Claude Code Hook Analysis'));
+  console.log(chalk.gray(`Target directory: ${targetDir}`));
+
+  const analysis = await analyzeHooks(targetDir);
+  
+  if (!analysis) {
+    console.log(chalk.yellow('\n💡 No automation hooks found.'));
+    console.log(chalk.gray('Would you like to set up Claude Code Templates to add automation hooks?'));
+    
+    const { setupHooks } = await inquirer.prompt([{
+      type: 'confirm',
+      name: 'setupHooks',
+      message: 'Set up automation hooks with Claude Code Templates?',
+      default: true
+    }]);
+
+    if (setupHooks) {
+      console.log(chalk.blue('\n🚀 Starting Claude Code Templates setup...'));
+      
+      // Import and run the main setup
+      const createClaudeConfig = require('./index');
+      await createClaudeConfig({ ...options, directory: targetDir });
+    }
+    return;
+  }
+
+  displayHookStats(analysis);
+
+  // Ask if user wants Claude Code to review and optimize hooks
+  console.log(chalk.blue('\n🤖 Optimization Opportunity'));
+  console.log(chalk.gray('Claude Code can analyze your automation hooks and suggest optimizations.'));
+  
+  const { optimizeHooks } = await inquirer.prompt([{
+    type: 'confirm',
+    name: 'optimizeHooks',
+    message: 'Would you like Claude Code to review and optimize your automation hooks?',
+    default: true
+  }]);
+
+  if (optimizeHooks) {
+    console.log(chalk.blue('\n🔍 Launching Claude Code for hook optimization...'));
+    
+    // Prepare the optimization prompt
+    const hookSummary = `I have ${analysis.totalHooks} automation hooks configured in my .claude/settings.json file:
+
+${Object.entries(analysis.byType).map(([type, data]) => 
+  `${type}: ${data.count} hooks (${data.hooks.filter(h => h.enabled).length} enabled, ${data.hooks.filter(h => !h.enabled).length} disabled)`
+).join('\n')}
+
+Hook details:
+${analysis.hooks.map(hook => 
+  `- ${hook.name} (${hook.type}): ${hook.enabled ? 'Enabled' : 'Disabled'} - ${hook.tokens} tokens - ${hook.description || 'No description'}`
+).join('\n')}
+
+Please review my automation hook configuration and suggest optimizations for:
+1. Hook efficiency and performance
+2. Missing hooks that could improve my workflow
+3. Hooks that might be redundant or conflicting
+4. Best practices for hook organization
+5. Security considerations for the hooks
+6. Hook conditions and triggers optimization
+
+Consider my project structure and suggest hooks that would be most beneficial for my development workflow.`;
+
+    const claudeCommand = `claude "${hookSummary}"`;
+    
+    try {
+      const child = spawn('sh', ['-c', claudeCommand], {
+        stdio: 'inherit',
+        cwd: targetDir
+      });
+
+      child.on('error', (error) => {
+        console.error(chalk.red('❌ Error launching Claude Code:'), error.message);
+        console.log(chalk.yellow('💡 Make sure Claude Code is installed: npm install -g @anthropic-ai/claude-code'));
+      });
+
+    } catch (error) {
+      console.error(chalk.red('❌ Error launching Claude Code:'), error.message);
+      console.log(chalk.yellow('💡 Make sure Claude Code is installed and accessible.'));
+    }
+  } else {
+    console.log(chalk.gray('\n✅ Hook analysis complete. You can run this command again anytime to re-analyze your hooks.'));
+  }
+}
+
+module.exports = {
+  runHookStats,
+  analyzeHooks,
+  displayHookStats
+};

package/src/index.js

@@ -9,16 +9,37 @@ const { createPrompts, interactivePrompts } = require('./prompts');
 const { copyTemplateFiles, runPostInstallationValidation } = require('./file-operations');
 const { getHooksForLanguage, getMCPsForLanguage } = require('./hook-scanner');
 const { runCommandStats } = require('./command-stats');
+const { runHookStats } = require('./hook-stats');
+const { runMCPStats } = require('./mcp-stats');
+const { runAnalytics } = require('./analytics');
 
 async function createClaudeConfig(options = {}) {
   const targetDir = options.directory || process.cwd();
   
-  // Handle command stats analysis
-  if (options.commandStats) {
+  // Handle command stats analysis (both singular and plural)
+  if (options.commandStats || options.commandsStats) {
     await runCommandStats(options);
     return;
   }
   
+  // Handle hook stats analysis (both singular and plural)
+  if (options.hookStats || options.hooksStats) {
+    await runHookStats(options);
+    return;
+  }
+  
+  // Handle MCP stats analysis (both singular and plural)
+  if (options.mcpStats || options.mcpsStats) {
+    await runMCPStats(options);
+    return;
+  }
+  
+  // Handle analytics dashboard
+  if (options.analytics) {
+    await runAnalytics(options);
+    return;
+  }
+  
   console.log(chalk.blue('🚀 Setting up Claude Code configuration...'));
   console.log(chalk.gray(`Target directory: ${targetDir}`));
   

package/src/mcp-stats.js

@@ -0,0 +1,321 @@
+const fs = require('fs-extra');
+const path = require('path');
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+const { spawn } = require('child_process');
+
+async function analyzeMCPServers(targetDir = process.cwd()) {
+  const mcpConfigPath = path.join(targetDir, '.mcp.json');
+  
+  console.log(chalk.blue('🔍 Analyzing MCP server configurations...'));
+  console.log(chalk.gray(`Scanning: ${mcpConfigPath}`));
+
+  if (!await fs.pathExists(mcpConfigPath)) {
+    console.log(chalk.yellow('⚠️  No .mcp.json file found.'));
+    return null;
+  }
+
+  try {
+    const mcpContent = await fs.readFile(mcpConfigPath, 'utf8');
+    const mcpConfig = JSON.parse(mcpContent);
+    
+    if (!mcpConfig.mcpServers || Object.keys(mcpConfig.mcpServers).length === 0) {
+      console.log(chalk.yellow('⚠️  No MCP servers found in .mcp.json.'));
+      return null;
+    }
+
+    const mcpAnalysis = {
+      totalServers: 0,
+      servers: [],
+      byCategory: {}
+    };
+
+    // Analyze each MCP server
+    for (const [serverKey, serverConfig] of Object.entries(mcpConfig.mcpServers)) {
+      const serverData = {
+        key: serverKey,
+        name: serverConfig.name || serverKey,
+        description: serverConfig.description || 'No description provided',
+        command: serverConfig.command || 'Unknown',
+        args: serverConfig.args || [],
+        env: serverConfig.env || {},
+        enabled: serverConfig.disabled !== true, // Default to enabled unless explicitly disabled
+        category: categorizeServer(serverConfig),
+        configSize: JSON.stringify(serverConfig).length,
+        complexity: calculateComplexity(serverConfig)
+      };
+
+      mcpAnalysis.servers.push(serverData);
+      mcpAnalysis.totalServers++;
+
+      // Group by category
+      if (!mcpAnalysis.byCategory[serverData.category]) {
+        mcpAnalysis.byCategory[serverData.category] = [];
+      }
+      mcpAnalysis.byCategory[serverData.category].push(serverData);
+    }
+
+    // Get file stats
+    const stats = await fs.stat(mcpConfigPath);
+    mcpAnalysis.fileSize = stats.size;
+    mcpAnalysis.lastModified = stats.mtime;
+
+    return mcpAnalysis;
+
+  } catch (error) {
+    console.error(chalk.red('❌ Error reading .mcp.json:'), error.message);
+    return null;
+  }
+}
+
+function categorizeServer(serverConfig) {
+  const name = (serverConfig.name || '').toLowerCase();
+  const command = (serverConfig.command || '').toLowerCase();
+  const description = (serverConfig.description || '').toLowerCase();
+  
+  // IDE and Development Tools
+  if (name.includes('ide') || name.includes('vscode') || name.includes('jupyter') || 
+      command.includes('jupyter') || description.includes('ide')) {
+    return 'IDE & Development';
+  }
+  
+  // Database Tools
+  if (name.includes('postgres') || name.includes('mysql') || name.includes('sqlite') || 
+      name.includes('database') || description.includes('database')) {
+    return 'Database';
+  }
+  
+  // Web and API Tools
+  if (name.includes('web') || name.includes('search') || name.includes('api') || 
+      name.includes('http') || description.includes('web') || description.includes('search')) {
+    return 'Web & API';
+  }
+  
+  // File System Tools
+  if (name.includes('file') || name.includes('filesystem') || 
+      description.includes('file') || description.includes('filesystem')) {
+    return 'Filesystem';
+  }
+  
+  // Development Tools
+  if (name.includes('git') || name.includes('docker') || name.includes('github') ||
+      description.includes('git') || description.includes('docker')) {
+    return 'DevOps';
+  }
+  
+  // AI and ML Tools
+  if (name.includes('ai') || name.includes('ml') || name.includes('model') ||
+      description.includes('ai') || description.includes('machine learning')) {
+    return 'AI & ML';
+  }
+  
+  return 'Other';
+}
+
+function calculateComplexity(serverConfig) {
+  let complexity = 1; // Base complexity
+  
+  // Add complexity for configuration options
+  if (serverConfig.args && serverConfig.args.length > 0) complexity += 1;
+  if (serverConfig.env && Object.keys(serverConfig.env).length > 0) complexity += 1;
+  if (serverConfig.settings && Object.keys(serverConfig.settings).length > 0) complexity += 1;
+  
+  // Add complexity for environment variables
+  const envCount = Object.keys(serverConfig.env || {}).length;
+  if (envCount > 3) complexity += 1;
+  if (envCount > 6) complexity += 1;
+  
+  return Math.min(complexity, 5); // Cap at 5
+}
+
+function displayMCPStats(analysis) {
+  if (!analysis || analysis.totalServers === 0) {
+    console.log(chalk.yellow('\n📊 MCP Server Analysis Results'));
+    console.log(chalk.gray('No MCP servers found to analyze.'));
+    return;
+  }
+
+  console.log(chalk.blue('\n📊 MCP Server Analysis Results'));
+  console.log(chalk.gray(`File: .mcp.json (${analysis.fileSize} bytes)`));
+  console.log(chalk.gray(`Last Modified: ${analysis.lastModified.toLocaleDateString()}`));
+  console.log(chalk.gray(`Total MCP Servers: ${analysis.totalServers}`));
+
+  // Calculate column widths
+  const maxNameLength = Math.max(
+    ...analysis.servers.map(server => server.name.length),
+    'Server Name'.length
+  );
+  const nameWidth = Math.min(maxNameLength, 25);
+
+  // Header
+  const header = chalk.bold.blue(
+    'Server Name'.padEnd(nameWidth) + ' │ ' +
+    'Category'.padEnd(15) + ' │ ' +
+    'Status'.padEnd(8) + ' │ ' +
+    'Command'.padEnd(12) + ' │ ' +
+    'Complexity'.padEnd(10) + ' │ ' +
+    'Description'
+  );
+
+  const separator = '─'.repeat(nameWidth) + '─┼─' +
+    '─'.repeat(15) + '─┼─' +
+    '─'.repeat(8) + '─┼─' +
+    '─'.repeat(12) + '─┼─' +
+    '─'.repeat(10) + '─┼─' +
+    '─'.repeat(30);
+
+  console.log('\n' + header);
+  console.log(chalk.gray(separator));
+
+  // Server rows
+  analysis.servers.forEach(server => {
+    const truncatedName = server.name.length > nameWidth ? 
+      server.name.substring(0, nameWidth - 3) + '...' : 
+      server.name;
+    
+    const statusColor = server.enabled ? chalk.green : chalk.yellow;
+    const status = server.enabled ? 'Enabled' : 'Disabled';
+    
+    const truncatedCommand = server.command.length > 12 ? 
+      server.command.substring(0, 9) + '...' : 
+      server.command;
+    
+    const complexityStars = '★'.repeat(server.complexity) + '☆'.repeat(5 - server.complexity);
+    
+    const truncatedDesc = server.description.length > 30 ? 
+      server.description.substring(0, 27) + '...' : 
+      server.description;
+
+    const row = 
+      truncatedName.padEnd(nameWidth) + ' │ ' +
+      server.category.padEnd(15) + ' │ ' +
+      statusColor(status.padEnd(8)) + ' │ ' +
+      chalk.cyan(truncatedCommand.padEnd(12)) + ' │ ' +
+      chalk.yellow(complexityStars.padEnd(10)) + ' │ ' +
+      chalk.gray(truncatedDesc);
+
+    console.log(row);
+  });
+
+  // Summary by category
+  console.log(chalk.blue('\n📈 MCP Server Summary by Category:'));
+  for (const [category, servers] of Object.entries(analysis.byCategory)) {
+    const enabledCount = servers.filter(s => s.enabled).length;
+    const disabledCount = servers.filter(s => !s.enabled).length;
+    
+    console.log(chalk.gray(`  ${category}: ${servers.length} servers`) + 
+      chalk.green(` (${enabledCount} enabled`) + 
+      (disabledCount > 0 ? chalk.yellow(`, ${disabledCount} disabled)`) : chalk.green(')')));
+  }
+
+  // Complexity analysis
+  console.log(chalk.blue('\n🔧 Complexity Distribution:'));
+  const complexityCount = {};
+  analysis.servers.forEach(server => {
+    complexityCount[server.complexity] = (complexityCount[server.complexity] || 0) + 1;
+  });
+  
+  for (let i = 1; i <= 5; i++) {
+    const count = complexityCount[i] || 0;
+    if (count > 0) {
+      const stars = '★'.repeat(i) + '☆'.repeat(5 - i);
+      console.log(chalk.gray(`  ${chalk.yellow(stars)} (${i}/5): ${count} servers`));
+    }
+  }
+}
+
+async function runMCPStats(options) {
+  const targetDir = options.directory || process.cwd();
+  
+  console.log(chalk.blue('🔌 Claude Code MCP Server Analysis'));
+  console.log(chalk.gray(`Target directory: ${targetDir}`));
+
+  const analysis = await analyzeMCPServers(targetDir);
+  
+  if (!analysis) {
+    console.log(chalk.yellow('\n💡 No MCP servers found.'));
+    console.log(chalk.gray('Would you like to set up Claude Code Templates to add MCP servers?'));
+    
+    const { setupMCP } = await inquirer.prompt([{
+      type: 'confirm',
+      name: 'setupMCP',
+      message: 'Set up MCP servers with Claude Code Templates?',
+      default: true
+    }]);
+
+    if (setupMCP) {
+      console.log(chalk.blue('\n🚀 Starting Claude Code Templates setup...'));
+      
+      // Import and run the main setup
+      const createClaudeConfig = require('./index');
+      await createClaudeConfig({ ...options, directory: targetDir });
+    }
+    return;
+  }
+
+  displayMCPStats(analysis);
+
+  // Ask if user wants Claude Code to review and optimize MCP configuration
+  console.log(chalk.blue('\n🤖 Optimization Opportunity'));
+  console.log(chalk.gray('Claude Code can analyze your MCP server configuration and suggest optimizations.'));
+  
+  const { optimizeMCP } = await inquirer.prompt([{
+    type: 'confirm',
+    name: 'optimizeMCP',
+    message: 'Would you like Claude Code to review and optimize your MCP server configuration?',
+    default: true
+  }]);
+
+  if (optimizeMCP) {
+    console.log(chalk.blue('\n🔍 Launching Claude Code for MCP optimization...'));
+    
+    // Prepare the optimization prompt
+    const mcpSummary = `I have ${analysis.totalServers} MCP servers configured in my .mcp.json file:
+
+${Object.entries(analysis.byCategory).map(([category, servers]) => 
+  `${category}: ${servers.length} servers (${servers.filter(s => s.enabled).length} enabled, ${servers.filter(s => !s.enabled).length} disabled)`
+).join('\n')}
+
+MCP Server details:
+${analysis.servers.map(server => 
+  `- ${server.name} (${server.category}): ${server.enabled ? 'Enabled' : 'Disabled'} - Command: ${server.command} - Complexity: ${server.complexity}/5 - ${server.description}`
+).join('\n')}
+
+Please review my MCP server configuration and suggest optimizations for:
+1. Server selection and relevance to my development workflow
+2. Missing MCP servers that could improve my productivity
+3. Server configuration optimization (command, args, environment variables)
+4. Performance considerations and resource usage
+5. Security best practices for MCP server configurations
+6. Redundant or conflicting servers
+7. Integration opportunities between different MCP servers
+
+Consider my project structure and development needs to suggest the most beneficial MCP server setup.`;
+
+    const claudeCommand = `claude "${mcpSummary}"`;
+    
+    try {
+      const child = spawn('sh', ['-c', claudeCommand], {
+        stdio: 'inherit',
+        cwd: targetDir
+      });
+
+      child.on('error', (error) => {
+        console.error(chalk.red('❌ Error launching Claude Code:'), error.message);
+        console.log(chalk.yellow('💡 Make sure Claude Code is installed: npm install -g @anthropic-ai/claude-code'));
+      });
+
+    } catch (error) {
+      console.error(chalk.red('❌ Error launching Claude Code:'), error.message);
+      console.log(chalk.yellow('💡 Make sure Claude Code is installed and accessible.'));
+    }
+  } else {
+    console.log(chalk.gray('\n✅ MCP analysis complete. You can run this command again anytime to re-analyze your MCP configuration.'));
+  }
+}
+
+module.exports = {
+  runMCPStats,
+  analyzeMCPServers,
+  displayMCPStats
+};