claude-code-templates 1.2.0 → 1.3.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "claude-code-templates",
-  "version": "1.2.0",
-  "description": "CLI tool to setup Claude Code configurations with selective automation hooks for different programming languages",
+  "version": "1.3.0",
+  "description": "CLI tool to setup Claude Code configurations with framework-specific commands and automation hooks for JavaScript/TypeScript and Python projects",
   "main": "src/index.js",
   "bin": {
     "create-claude-config": "bin/create-claude-config.js",
@@ -20,10 +20,7 @@
     "dev:link": "npm link",
     "dev:unlink": "npm unlink -g claude-code-templates",
     "pretest": "npm run dev:link",
-    "sync": "node scripts/sync-templates.js",
-    "presync": "echo \"🔄 Starting template synchronization...\"",
-    "postsync": "echo \"✅ Synchronization completed. Ready to publish!\"",
-    "prepublishOnly": "npm run sync && npm run test"
+    "prepublishOnly": "npm run test"
   },
   "keywords": [
     "claude",
@@ -37,7 +34,14 @@
     "automation",
     "javascript",
     "typescript",
+    "react",
+    "vue",
+    "angular",
+    "nodejs",
     "python",
+    "django",
+    "flask",
+    "fastapi",
     "rust",
     "go"
   ],
@@ -65,8 +69,6 @@
   "files": [
     "bin/",
     "src/",
-    "scripts/",
-    "templates/",
     "README.md"
   ]
 }

package/src/command-scanner.js

@@ -7,7 +7,7 @@ const path = require('path');
  * @returns {Array} Array of available commands with metadata
  */
 function getAvailableCommands(language) {
-  const templatesDir = path.join(__dirname, '..', 'templates');
+  const templatesDir = path.join(__dirname, '../../');
   const languageDir = path.join(templatesDir, language);
   
   // Check if language directory exists

package/src/file-operations.js

@@ -1,10 +1,10 @@
 const fs = require('fs-extra');
 const path = require('path');
 const chalk = require('chalk');
-const { getHooksForLanguage, filterHooksBySelection } = require('./hook-scanner');
+const { getHooksForLanguage, filterHooksBySelection, getMCPsForLanguage, filterMCPsBySelection } = require('./hook-scanner');
 
 async function copyTemplateFiles(templateConfig, targetDir) {
-  const templateDir = path.join(__dirname, '../templates');
+  const templateDir = path.join(__dirname, '../../');
   
   // Check if CLAUDE.md already exists
   const claudeFile = path.join(targetDir, 'CLAUDE.md');
@@ -79,6 +79,10 @@ async function copyTemplateFiles(templateConfig, targetDir) {
         // Handle settings.json with hook filtering
         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)`));
       } else {
         // Copy regular files (CLAUDE.md, settings.json, etc.)
         await fs.copy(sourcePath, destPath, { 
@@ -121,6 +125,11 @@ async function copyTemplateFiles(templateConfig, targetDir) {
   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 processSettingsFile(sourcePath, destPath, templateConfig) {
@@ -155,6 +164,37 @@ async function processSettingsFile(sourcePath, destPath, templateConfig) {
   }
 }
 
+async function processMCPFile(sourcePath, destPath, templateConfig) {
+  try {
+    // Read the original MCP file
+    const originalMCPData = JSON.parse(await fs.readFile(sourcePath, 'utf8'));
+    
+    // If MCPs are selected, filter them
+    if (templateConfig.selectedMCPs && templateConfig.selectedMCPs.length > 0) {
+      const availableMCPs = getMCPsForLanguage(templateConfig.language);
+      const filteredMCPData = filterMCPsBySelection(
+        originalMCPData,
+        templateConfig.selectedMCPs,
+        availableMCPs
+      );
+      
+      // Write the filtered MCP data
+      await fs.ensureDir(path.dirname(destPath));
+      await fs.writeFile(destPath, JSON.stringify(filteredMCPData, null, 2));
+    } else {
+      // No MCPs selected, create empty MCP file
+      const emptyMCPData = { mcpServers: {} };
+      
+      await fs.ensureDir(path.dirname(destPath));
+      await fs.writeFile(destPath, JSON.stringify(emptyMCPData, null, 2));
+    }
+  } catch (error) {
+    console.error(chalk.red(`Failed to process MCP file: ${error.message}`));
+    // Fallback to copying original file
+    await fs.copy(sourcePath, destPath);
+  }
+}
+
 async function ensureDirectoryExists(dirPath) {
   try {
     await fs.ensureDir(dirPath);
@@ -180,5 +220,6 @@ module.exports = {
   copyTemplateFiles,
   ensureDirectoryExists,
   checkWritePermissions,
-  processSettingsFile
+  processSettingsFile,
+  processMCPFile
 };

package/src/hook-scanner.js

@@ -110,56 +110,129 @@ function getHooksFromSettings(settingsPath) {
 function getHookDescription(hook, matcher, type) {
   const command = hook.command || '';
   
-  // Pre-defined descriptions for common hooks
-  const descriptions = {
-    // PreToolUse hooks
-    'jq -r': 'Log Bash commands to ~/.claude/bash-command-log.txt',
-    'console\\.log': 'Block files containing console.log statements',
-    'print(': 'Block Python files containing print statements',
-    'fmt.Print': 'Block Go files containing fmt.Print statements',
-    'println!': 'Block Rust files containing println! statements',
-    'npm audit': 'Check for vulnerable dependencies when modifying package.json',
-    'pip-audit': 'Check for vulnerable Python dependencies',
-    'cargo audit': 'Check for vulnerable Rust dependencies',
-    'go list': 'Check Go dependencies',
-    
-    // PostToolUse hooks
-    'prettier --write': 'Auto-format JavaScript/TypeScript files with Prettier',
-    'black': 'Auto-format Python files with Black',
-    'isort': 'Sort Python imports with isort',
-    'gofmt': 'Auto-format Go files with gofmt',
-    'goimports': 'Auto-format Go imports with goimports',
-    'rustfmt': 'Auto-format Rust files with rustfmt',
-    'tsc --noEmit': 'Run TypeScript type checking after edits',
-    'flake8': 'Run Python code quality checks with flake8',
-    'mypy': 'Run Python type checking with mypy',
-    'go vet': 'Run Go code analysis with go vet',
-    'cargo check': 'Run Rust code checking with cargo check',
-    'cargo clippy': 'Run Rust linting with clippy',
-    'import \\* from': 'Warn about wildcard imports (bad for tree-shaking)',
-    'npx jest': 'Run JavaScript/TypeScript tests automatically',
-    'pytest': 'Run Python tests automatically',
-    'go test': 'Run Go tests automatically',
-    'cargo test': 'Run Rust tests automatically',
-    
-    // Stop hooks
-    'eslint': 'Run ESLint on changed files before stopping',
-    'flake8.*git diff': 'Run Python linting on changed files',
-    'bandit': 'Run Python security analysis',
-    'go vet.*git diff': 'Run Go analysis on changed files',
-    'staticcheck': 'Run Go static analysis',
-    'cargo clippy.*git diff': 'Run Rust linting on changed files',
-    'bundlesize': 'Analyze bundle size impact of changes',
-    
-    // Notification hooks
-    'notifications.log': 'Log Claude Code notifications'
-  };
-
-  // Try to match command with known descriptions
-  for (const [pattern, description] of Object.entries(descriptions)) {
-    if (command.includes(pattern)) {
-      return description;
-    }
+  // Extract key patterns for more specific descriptions
+  if (command.includes('jq -r') && command.includes('bash-command-log')) {
+    return 'Log all Bash commands for debugging';
+  }
+  
+  if (command.includes('console\\.log')) {
+    return 'Block console.log statements in JS/TS files';
+  }
+  
+  if (command.includes('print(') && command.includes('py$')) {
+    return 'Block print() statements in Python files';
+  }
+  
+  if (command.includes('fmt.Print') && command.includes('go$')) {
+    return 'Block fmt.Print statements in Go files';
+  }
+  
+  if (command.includes('println!') && command.includes('rs$')) {
+    return 'Block println! macros in Rust files';
+  }
+  
+  if (command.includes('npm audit') || command.includes('pip-audit') || command.includes('cargo audit')) {
+    return 'Security audit for dependencies';
+  }
+  
+  if (command.includes('prettier --write')) {
+    return 'Auto-format JS/TS files with Prettier';
+  }
+  
+  if (command.includes('black') && command.includes('py$')) {
+    return 'Auto-format Python files with Black';
+  }
+  
+  if (command.includes('isort') && command.includes('py$')) {
+    return 'Auto-sort Python imports with isort';
+  }
+  
+  if (command.includes('gofmt') && command.includes('go$')) {
+    return 'Auto-format Go files with gofmt';
+  }
+  
+  if (command.includes('goimports')) {
+    return 'Auto-format Go imports with goimports';
+  }
+  
+  if (command.includes('rustfmt') && command.includes('rs$')) {
+    return 'Auto-format Rust files with rustfmt';
+  }
+  
+  if (command.includes('tsc --noEmit')) {
+    return 'Run TypeScript type checking';
+  }
+  
+  if (command.includes('flake8') && !command.includes('git diff')) {
+    return 'Run Python linting with flake8';
+  }
+  
+  if (command.includes('mypy')) {
+    return 'Run Python type checking with mypy';
+  }
+  
+  if (command.includes('go vet') && !command.includes('git diff')) {
+    return 'Run Go static analysis with go vet';
+  }
+  
+  if (command.includes('cargo check')) {
+    return 'Run Rust compilation checks';
+  }
+  
+  if (command.includes('cargo clippy') && !command.includes('git diff')) {
+    return 'Run Rust linting with clippy';
+  }
+  
+  if (command.includes('import \\* from')) {
+    return 'Warn about wildcard imports';
+  }
+  
+  if (command.includes('jest') || command.includes('vitest')) {
+    return 'Auto-run tests for modified files';
+  }
+  
+  if (command.includes('pytest')) {
+    return 'Auto-run Python tests for modified files';
+  }
+  
+  if (command.includes('go test')) {
+    return 'Auto-run Go tests for modified files';
+  }
+  
+  if (command.includes('cargo test')) {
+    return 'Auto-run Rust tests for modified files';
+  }
+  
+  if (command.includes('eslint') && command.includes('git diff')) {
+    return 'Run ESLint on changed files';
+  }
+  
+  if (command.includes('flake8') && command.includes('git diff')) {
+    return 'Run Python linting on changed files';
+  }
+  
+  if (command.includes('bandit')) {
+    return 'Run Python security analysis';
+  }
+  
+  if (command.includes('go vet') && command.includes('git diff')) {
+    return 'Run Go analysis on changed files';
+  }
+  
+  if (command.includes('staticcheck')) {
+    return 'Run Go static analysis on changed files';
+  }
+  
+  if (command.includes('cargo clippy') && command.includes('git diff')) {
+    return 'Run Rust linting on changed files';
+  }
+  
+  if (command.includes('bundlesize') || command.includes('webpack-bundle-analyzer')) {
+    return 'Analyze bundle size impact';
+  }
+  
+  if (command.includes('notifications.log')) {
+    return 'Log Claude Code notifications';
   }
 
   // Generate description based on command analysis
@@ -194,7 +267,7 @@ function getHookDescription(hook, matcher, type) {
  * @returns {Array} Array of available hooks for the language
  */
 function getHooksForLanguage(language) {
-  const templateDir = path.join(__dirname, '..', 'templates', language);
+  const templateDir = path.join(__dirname, '../../', language);
   const settingsPath = path.join(templateDir, '.claude', 'settings.json');
   
   return getHooksFromSettings(settingsPath);
@@ -263,9 +336,113 @@ function filterHooksBySelection(originalSettings, selectedHookIds, availableHook
   return filteredSettings;
 }
 
+/**
+ * Extracts and describes MCPs from a .mcp.json file
+ * @param {string} mcpPath - Path to the .mcp.json file
+ * @returns {Array} Array of MCP descriptions
+ */
+function getMCPsFromFile(mcpPath) {
+  if (!fs.existsSync(mcpPath)) {
+    return [];
+  }
+
+  try {
+    const mcpData = JSON.parse(fs.readFileSync(mcpPath, 'utf8'));
+    const mcps = [];
+
+    if (mcpData.mcpServers) {
+      Object.keys(mcpData.mcpServers).forEach((serverId) => {
+        const server = mcpData.mcpServers[serverId];
+        mcps.push({
+          id: serverId,
+          name: server.name || serverId,
+          description: server.description || 'No description available',
+          command: server.command,
+          args: server.args || [],
+          env: server.env || {},
+          originalServer: server,
+          checked: getDefaultMCPSelection(serverId) // Default selection logic
+        });
+      });
+    }
+
+    return mcps;
+  } catch (error) {
+    console.error(`Error parsing MCP file ${mcpPath}:`, error.message);
+    return [];
+  }
+}
+
+/**
+ * Determines default selection for MCP servers
+ * @param {string} serverId - The MCP server ID
+ * @returns {boolean} Whether the MCP should be selected by default
+ */
+function getDefaultMCPSelection(serverId) {
+  // Default to checked for commonly useful MCPs
+  const defaultSelected = [
+    'filesystem',
+    'memory-bank',
+    'sequential-thinking',
+    'typescript-sdk',
+    'python-sdk',
+    'rust-sdk',
+    'go-sdk'
+  ];
+  
+  return defaultSelected.includes(serverId);
+}
+
+/**
+ * Gets MCPs for a specific language
+ * @param {string} language - The programming language
+ * @returns {Array} Array of available MCPs for the language
+ */
+function getMCPsForLanguage(language) {
+  const templateDir = path.join(__dirname, '../../', language);
+  const mcpPath = path.join(templateDir, '.mcp.json');
+  
+  return getMCPsFromFile(mcpPath);
+}
+
+/**
+ * Filters MCPs based on user selection
+ * @param {Object} originalMCPData - Original MCP data object
+ * @param {Array} selectedMCPIds - Array of selected MCP IDs
+ * @param {Array} availableMCPs - Array of available MCPs
+ * @returns {Object} Filtered MCP data object
+ */
+function filterMCPsBySelection(originalMCPData, selectedMCPIds, availableMCPs) {
+  if (!originalMCPData.mcpServers) {
+    return originalMCPData;
+  }
+
+  const filteredMCPData = {
+    mcpServers: {}
+  };
+
+  // Create a map of selected MCPs for quick lookup
+  const selectedMCPs = new Map();
+  availableMCPs.forEach(mcp => {
+    if (selectedMCPIds.includes(mcp.id)) {
+      selectedMCPs.set(mcp.id, mcp);
+    }
+  });
+
+  // Add selected MCPs to filtered data
+  selectedMCPs.forEach((mcp, mcpId) => {
+    filteredMCPData.mcpServers[mcpId] = mcp.originalServer;
+  });
+
+  return filteredMCPData;
+}
+
 module.exports = {
   getHooksFromSettings,
   getHooksForLanguage,
   filterHooksBySelection,
-  getHookDescription
+  getHookDescription,
+  getMCPsFromFile,
+  getMCPsForLanguage,
+  filterMCPsBySelection
 };

package/src/index.js

@@ -4,10 +4,10 @@ const fs = require('fs-extra');
 const path = require('path');
 const ora = require('ora');
 const { detectProject } = require('./utils');
-const { getTemplateConfig } = require('./templates');
+const { getTemplateConfig, TEMPLATES_CONFIG } = require('./templates');
 const { createPrompts, interactivePrompts } = require('./prompts');
 const { copyTemplateFiles } = require('./file-operations');
-const { getHooksForLanguage } = require('./hook-scanner');
+const { getHooksForLanguage, getMCPsForLanguage } = require('./hook-scanner');
 
 async function createClaudeConfig(options = {}) {
   const targetDir = options.directory || process.cwd();
@@ -24,14 +24,24 @@ async function createClaudeConfig(options = {}) {
   if (options.yes) {
     // Use defaults
     const selectedLanguage = options.language || projectInfo.detectedLanguage || 'common';
+    
+    // Check if selected language is coming soon
+    if (selectedLanguage && TEMPLATES_CONFIG[selectedLanguage] && TEMPLATES_CONFIG[selectedLanguage].comingSoon) {
+      console.log(chalk.red(`❌ ${selectedLanguage} is not available yet. Coming soon!`));
+      console.log(chalk.yellow('Available languages: common, javascript-typescript, python'));
+      return;
+    }
     const availableHooks = getHooksForLanguage(selectedLanguage);
     const defaultHooks = availableHooks.filter(hook => hook.checked).map(hook => hook.id);
+    const availableMCPs = getMCPsForLanguage(selectedLanguage);
+    const defaultMCPs = availableMCPs.filter(mcp => mcp.checked).map(mcp => mcp.id);
     
     config = {
       language: selectedLanguage,
       framework: options.framework || projectInfo.detectedFramework || 'none',
       features: [],
-      hooks: defaultHooks
+      hooks: defaultHooks,
+      mcps: defaultMCPs
     };
   } else {
     // Interactive prompts with back navigation
@@ -53,6 +63,12 @@ async function createClaudeConfig(options = {}) {
     templateConfig.language = config.language; // Ensure language is available for hook filtering
   }
   
+  // Add selected MCPs to template config
+  if (config.mcps) {
+    templateConfig.selectedMCPs = config.mcps;
+    templateConfig.language = config.language; // Ensure language is available for MCP filtering
+  }
+  
   if (options.dryRun) {
     console.log(chalk.yellow('🔍 Dry run - showing what would be copied:'));
     templateConfig.files.forEach(file => {
@@ -89,6 +105,10 @@ async function createClaudeConfig(options = {}) {
   if (config.hooks && config.hooks.length > 0) {
     console.log(chalk.magenta(`🔧 ${config.hooks.length} automation hooks have been configured`));
   }
+  
+  if (config.mcps && config.mcps.length > 0) {
+    console.log(chalk.blue(`🔧 ${config.mcps.length} MCP servers have been configured`));
+  }
 }
 
 module.exports = createClaudeConfig;

package/src/prompts.js

@@ -13,7 +13,7 @@ class CustomCheckboxPrompt extends inquirer.prompt.prompts.checkbox {
 inquirer.registerPrompt('checkbox', CustomCheckboxPrompt);
 const { getAvailableLanguages, getFrameworksForLanguage } = require('./templates');
 const { getCommandsForLanguageAndFramework } = require('./command-scanner');
-const { getHooksForLanguage } = require('./hook-scanner');
+const { getHooksForLanguage, getMCPsForLanguage } = require('./hook-scanner');
 
 async function interactivePrompts(projectInfo, options = {}) {
   const state = {
@@ -25,7 +25,7 @@ async function interactivePrompts(projectInfo, options = {}) {
   // Build steps array based on options
   if (!options.language) state.steps.push('language');
   if (!options.framework) state.steps.push('framework');
-  state.steps.push('commands', 'hooks', 'confirm');
+  state.steps.push('commands', 'hooks', 'mcps', 'confirm');
 
   while (state.currentStep < state.steps.length) {
     const stepName = state.steps[state.currentStep];
@@ -170,11 +170,38 @@ function getStepConfig(stepName, currentAnswers, projectInfo, options) {
         pageSize: 15
       };
 
+    case 'mcps':
+      const mcpLanguage = currentAnswers.language || options.language;
+      
+      if (!mcpLanguage) {
+        return null; // Skip if no language selected
+      }
+      
+      const availableMCPs = getMCPsForLanguage(mcpLanguage);
+      
+      if (availableMCPs.length === 0) {
+        return null; // Skip if no MCPs available
+      }
+      
+      return {
+        type: 'checkbox',
+        name: 'mcps',
+        message: 'Select MCP servers to include (use space to select):',
+        choices: availableMCPs.map(mcp => ({
+          value: mcp.id,
+          name: `${mcp.name} - ${mcp.description}`,
+          checked: mcp.checked
+        })),
+        prefix: chalk.blue('🔧'),
+        pageSize: 15
+      };
+
     case 'confirm':
       const confirmLanguage = currentAnswers.language || options.language || 'common';
       const confirmFramework = currentAnswers.framework || options.framework || 'none';
       const commandCount = currentAnswers.commands ? currentAnswers.commands.length : 0;
       const hookCount = currentAnswers.hooks ? currentAnswers.hooks.length : 0;
+      const mcpCount = currentAnswers.mcps ? currentAnswers.mcps.length : 0;
       
       let message = `Setup Claude Code for ${chalk.cyan(confirmLanguage)}`;
       if (confirmFramework !== 'none') {
@@ -186,6 +213,9 @@ function getStepConfig(stepName, currentAnswers, projectInfo, options) {
       if (hookCount > 0) {
         message += ` (${chalk.magenta(hookCount)} hooks)`;
       }
+      if (mcpCount > 0) {
+        message += ` (${chalk.blue(mcpCount)} MCP)`;
+      }
       message += '?';
       
       return {
@@ -312,6 +342,38 @@ function createPrompts(projectInfo, options = {}) {
       return availableHooks.length > 0;
     }
   });
+
+  // MCP selection
+  prompts.push({
+    type: 'checkbox',
+    name: 'mcps',
+    message: 'Select MCP servers to include (use space to select):',
+    choices: (answers) => {
+      const selectedLanguage = answers.language || options.language;
+      
+      if (!selectedLanguage) {
+        return [];
+      }
+      
+      const availableMCPs = getMCPsForLanguage(selectedLanguage);
+      
+      return availableMCPs.map(mcp => ({
+        value: mcp.id,
+        name: `${mcp.name} - ${mcp.description}`,
+        checked: mcp.checked
+      }));
+    },
+    prefix: chalk.blue('🔧'),
+    pageSize: 15,
+    when: (answers) => {
+      const selectedLanguage = answers.language || options.language;
+      if (!selectedLanguage) {
+        return false;
+      }
+      const availableMCPs = getMCPsForLanguage(selectedLanguage);
+      return availableMCPs.length > 0;
+    }
+  });
   
   // Confirmation
   prompts.push({
@@ -322,6 +384,7 @@ function createPrompts(projectInfo, options = {}) {
       const framework = answers.framework || options.framework || 'none';
       const commandCount = answers.commands ? answers.commands.length : 0;
       const hookCount = answers.hooks ? answers.hooks.length : 0;
+      const mcpCount = answers.mcps ? answers.mcps.length : 0;
       
       let message = `Setup Claude Code for ${chalk.cyan(language)}`;
       if (framework !== 'none') {
@@ -333,6 +396,9 @@ function createPrompts(projectInfo, options = {}) {
       if (hookCount > 0) {
         message += ` (${chalk.magenta(hookCount)} hooks)`;
       }
+      if (mcpCount > 0) {
+        message += ` (${chalk.blue(mcpCount)} MCP)`;
+      }
       message += '?';
       
       return message;