claude-code-templates 1.2.1 → 1.3.1

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "claude-code-templates",
-  "version": "1.2.1",
-  "description": "CLI tool to setup Claude Code configurations with selective automation hooks for different programming languages",
+  "version": "1.3.1",
+  "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

@@ -267,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);
@@ -336,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;

package/src/templates.js

@@ -7,7 +7,8 @@ const TEMPLATES_CONFIG = {
     description: 'Universal configuration for any project',
     files: [
       { source: 'common/CLAUDE.md', destination: 'CLAUDE.md' },
-      { source: 'common/.claude', destination: '.claude' }
+      { source: 'common/.claude', destination: '.claude' },
+      { source: 'common/.mcp.json', destination: '.mcp.json' }
     ]
   },
   'javascript-typescript': {
@@ -50,23 +51,45 @@ const TEMPLATES_CONFIG = {
     description: 'Optimized for Python development',
     files: [
       { source: 'python/CLAUDE.md', destination: 'CLAUDE.md' },
-      { source: 'python/.claude', destination: '.claude' }
-    ]
+      { source: 'python/.claude', destination: '.claude' },
+      { source: 'python/.mcp.json', destination: '.mcp.json' }
+    ],
+    frameworks: {
+      'django': {
+        name: 'Django',
+        additionalFiles: [
+          { source: 'python/examples/django-app/.claude/commands', destination: '.claude/commands' },
+          { source: 'python/examples/django-app/CLAUDE.md', destination: 'CLAUDE.md' }
+        ]
+      },
+      'flask': {
+        name: 'Flask',
+        additionalFiles: [
+          { source: 'python/examples/flask-app/.claude/commands', destination: '.claude/commands' }
+        ]
+      },
+      'fastapi': {
+        name: 'FastAPI',
+        additionalFiles: [
+          { source: 'python/examples/fastapi-app/.claude/commands', destination: '.claude/commands' }
+        ]
+      }
+    }
   },
   'rust': {
     name: 'Rust',
     description: 'Optimized for Rust development',
+    comingSoon: true,
     files: [
-      { source: 'rust/CLAUDE.md', destination: 'CLAUDE.md' },
-      { source: 'rust/.claude', destination: '.claude' }
+      { source: 'rust/.mcp.json', destination: '.mcp.json' }
     ]
   },
   'go': {
     name: 'Go',
-    description: 'Optimized for Go development',
+    description: 'Optimized for Go development', 
+    comingSoon: true,
     files: [
-      { source: 'go/CLAUDE.md', destination: 'CLAUDE.md' },
-      { source: 'go/.claude', destination: '.claude' }
+      { source: 'go/.mcp.json', destination: '.mcp.json' }
     ]
   }
 };

package/scripts/sync-templates.js

@@ -1,182 +0,0 @@
-#!/usr/bin/env node
-
-const fs = require('fs-extra');
-const path = require('path');
-const chalk = require('chalk');
-
-/**
- * Script to synchronize templates from root folders 
- * to cli-tool/templates/
- */
-
-async function syncTemplates() {
-  console.log(chalk.blue('🔄 Synchronizing templates...'));
-  
-  const rootDir = path.join(__dirname, '..', '..');
-  const templatesDir = path.join(__dirname, '..', 'templates');
-  
-  // Languages to synchronize
-  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(`⚠️  Source folder does not exist: ${language}`));
-      continue;
-    }
-    
-    console.log(chalk.cyan(`\n📂 Synchronizing ${language}...`));
-    
-    // Clean destination directory
-    if (await fs.pathExists(targetDir)) {
-      await fs.remove(targetDir);
-      console.log(chalk.gray(`   🗑️  Previous directory removed`));
-    }
-    
-    // Copy everything from source
-    try {
-      await fs.copy(sourceDir, targetDir, {
-        filter: (src, dest) => {
-          // Filter files we don't want to copy
-          const relativePath = path.relative(sourceDir, src);
-          
-          // 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;
-          if (relativePath.endsWith('.log')) return false;
-          
-          return true;
-        }
-      });
-      
-      // Count copied files
-      const stats = await getDirectoryStats(targetDir);
-      totalCopied += stats.files;
-      
-      console.log(chalk.green(`   ✅ ${stats.files} files copied`));
-      
-      // Show copied structure
-      if (stats.files > 0) {
-        await showDirectoryStructure(targetDir, '   ');
-      }
-      
-    } catch (error) {
-      console.error(chalk.red(`   ❌ Error copying ${language}:`), error.message);
-    }
-  }
-  
-  console.log(chalk.green(`\n🎉 Synchronization completed!`));
-  console.log(chalk.white(`📊 Total synchronized files: ${totalCopied}`));
-  
-  // Verify that no hook files exist
-  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') {
-        // 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++) {
-          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}└── ... and ${subItems.length - 3} more`));
-        }
-      }
-    } else {
-      console.log(chalk.gray(`${prefix}${connector}${item}`));
-    }
-  }
-}
-
-async function cleanupOldReferences() {
-  console.log(chalk.yellow('\n🧹 Cleaning up obsolete references...'));
-  
-  const templatesDir = path.join(__dirname, '..', 'templates');
-  
-  // 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(`   🗑️  Removed: ${language}/.claude/hooks/`));
-    }
-  }
-  
-  // Check for empty files in 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) { // Very small files are probably empty
-          const content = await fs.readFile(filePath, 'utf8');
-          if (content.trim().length < 10) {
-            console.log(chalk.yellow(`   ⚠️  Possibly empty file: ${language}/.claude/commands/${file} (${stat.size} bytes)`));
-          }
-        }
-      }
-    }
-  }
-}
-
-// Function to execute synchronization
-if (require.main === module) {
-  syncTemplates().catch(error => {
-    console.error(chalk.red('❌ Error during synchronization:'), error);
-    process.exit(1);
-  });
-}
-
-module.exports = { syncTemplates };