claude-code-workflow 6.1.4 → 6.2.2

package/ccw/src/commands/{stop.js → stop.ts}

@@ -4,12 +4,17 @@ import { promisify } from 'util';
 
 const execAsync = promisify(exec);
 
+interface StopOptions {
+  port?: number;
+  force?: boolean;
+}
+
 /**
  * Find process using a specific port (Windows)
  * @param {number} port - Port number
  * @returns {Promise<string|null>} PID or null
  */
-async function findProcessOnPort(port) {
+async function findProcessOnPort(port: number): Promise<string | null> {
   try {
     const { stdout } = await execAsync(`netstat -ano | findstr :${port} | findstr LISTENING`);
     const lines = stdout.trim().split('\n');
@@ -28,7 +33,7 @@ async function findProcessOnPort(port) {
  * @param {string} pid - Process ID
  * @returns {Promise<boolean>} Success status
  */
-async function killProcess(pid) {
+async function killProcess(pid: string): Promise<boolean> {
   try {
     await execAsync(`taskkill /PID ${pid} /F`);
     return true;
@@ -41,7 +46,7 @@ async function killProcess(pid) {
  * Stop command handler - stops the running CCW dashboard server
  * @param {Object} options - Command options
  */
-export async function stopCommand(options) {
+export async function stopCommand(options: StopOptions): Promise<void> {
   const port = options.port || 3456;
   const force = options.force || false;
 
@@ -67,7 +72,7 @@ export async function stopCommand(options) {
       await new Promise(resolve => setTimeout(resolve, 500));
 
       console.log(chalk.green.bold('\n  Server stopped successfully!\n'));
-      return;
+      process.exit(0);
     }
 
     // No CCW server responding, check if port is in use
@@ -75,7 +80,7 @@ export async function stopCommand(options) {
 
     if (!pid) {
       console.log(chalk.yellow(`  No server running on port ${port}\n`));
-      return;
+      process.exit(0);
     }
 
     // Port is in use by another process
@@ -87,15 +92,20 @@ export async function stopCommand(options) {
 
       if (killed) {
         console.log(chalk.green.bold('\n  Process killed successfully!\n'));
+        process.exit(0);
       } else {
         console.log(chalk.red('\n  Failed to kill process. Try running as administrator.\n'));
+        process.exit(1);
       }
     } else {
       console.log(chalk.gray(`\n  This is not a CCW server. Use --force to kill it:`));
       console.log(chalk.white(`  ccw stop --force\n`));
+      process.exit(0);
     }
 
   } catch (err) {
-    console.error(chalk.red(`\n  Error: ${err.message}\n`));
+    const error = err as Error;
+    console.error(chalk.red(`\n  Error: ${error.message}\n`));
+    process.exit(1);
   }
 }

package/ccw/src/commands/tool.ts

@@ -0,0 +1,201 @@
+/**
+ * Tool Command - Execute and manage CCW tools
+ */
+
+import chalk from 'chalk';
+import { listTools, executeTool, getTool, getAllToolSchemas } from '../tools/index.js';
+
+interface ToolOptions {
+  name?: string;
+}
+
+interface ExecOptions {
+  path?: string;
+  old?: string;
+  new?: string;
+  action?: string;
+  query?: string;
+  limit?: string;
+  file?: string;
+  files?: string;
+  languages?: string;
+  mode?: string;
+  operation?: string;
+  line?: string;
+  text?: string;
+  dryRun?: boolean;
+  replaceAll?: boolean;
+}
+
+/**
+ * List all available tools
+ */
+async function listAction(): Promise<void> {
+  const tools = listTools();
+
+  if (tools.length === 0) {
+    console.log(chalk.yellow('No tools registered'));
+    return;
+  }
+
+  console.log(chalk.bold.cyan('\nAvailable Tools:\n'));
+
+  for (const tool of tools) {
+    console.log(chalk.bold.white(`  ${tool.name}`));
+    console.log(chalk.gray(`    ${tool.description}`));
+
+    if (tool.parameters?.properties) {
+      const props = tool.parameters.properties;
+      const required = tool.parameters.required || [];
+
+      console.log(chalk.gray('    Parameters:'));
+      for (const [name, schema] of Object.entries(props)) {
+        const req = required.includes(name) ? chalk.red('*') : '';
+        const defaultVal = (schema as any).default !== undefined ? chalk.gray(` (default: ${(schema as any).default})`) : '';
+        console.log(chalk.gray(`      - ${name}${req}: ${(schema as any).description}${defaultVal}`));
+      }
+    }
+    console.log();
+  }
+}
+
+/**
+ * Show tool schema in MCP-compatible JSON format
+ */
+async function schemaAction(options: ToolOptions): Promise<void> {
+  const { name } = options;
+
+  if (name) {
+    const tool = getTool(name);
+    if (!tool) {
+      console.error(chalk.red(`Tool not found: ${name}`));
+      process.exit(1);
+    }
+
+    const schema = {
+      name: tool.name,
+      description: tool.description,
+      inputSchema: {
+        type: 'object',
+        properties: tool.parameters?.properties || {},
+        required: tool.parameters?.required || []
+      }
+    };
+    console.log(JSON.stringify(schema, null, 2));
+  } else {
+    const schemas = getAllToolSchemas();
+    console.log(JSON.stringify({ tools: schemas }, null, 2));
+  }
+}
+
+/**
+ * Execute a tool with given parameters
+ * @param {string} toolName - Tool name
+ * @param {string|undefined} jsonParams - JSON string of parameters
+ * @param {Object} options - CLI options
+ */
+async function execAction(toolName: string | undefined, jsonParams: string | undefined, options: ExecOptions): Promise<void> {
+  if (!toolName) {
+    console.error(chalk.red('Tool name is required'));
+    console.error(chalk.gray('Usage: ccw tool exec <tool_name> \'{"param": "value"}\''));
+    console.error(chalk.gray('       ccw tool exec edit_file --path file.txt --old "old" --new "new"'));
+    console.error(chalk.gray('       ccw tool exec codex_lens --action search --query "pattern"'));
+    process.exit(1);
+  }
+
+  const tool = getTool(toolName);
+  if (!tool) {
+    console.error(chalk.red(`Tool not found: ${toolName}`));
+    console.error(chalk.gray('Use "ccw tool list" to see available tools'));
+    process.exit(1);
+  }
+
+  // Build params from CLI options or JSON
+  let params: any = {};
+
+  // Check if JSON params provided
+  if (jsonParams && jsonParams.trim().startsWith('{')) {
+    try {
+      params = JSON.parse(jsonParams);
+    } catch (e) {
+      const error = e as Error;
+      console.error(chalk.red('Invalid JSON parameters'));
+      console.error(chalk.gray(`Parse error: ${error.message}`));
+      process.exit(1);
+    }
+  } else if (toolName === 'edit_file') {
+    // Parameter mode for edit_file
+    if (!options.path || !options.old || !options.new) {
+      console.error(chalk.red('edit_file requires --path, --old, and --new parameters'));
+      console.error(chalk.gray('Usage: ccw tool exec edit_file --path file.txt --old "old text" --new "new text"'));
+      process.exit(1);
+    }
+    params.path = options.path;
+    params.oldText = options.old;
+    params.newText = options.new;
+  } else if (toolName === 'codex_lens') {
+    // Parameter mode for codex_lens
+    if (!options.action) {
+      console.error(chalk.red('codex_lens requires --action parameter'));
+      console.error(chalk.gray('Usage: ccw tool exec codex_lens --action search --query "pattern" --path .'));
+      console.error(chalk.gray('Actions: init, search, search_files, symbol, status, update, bootstrap, check'));
+      process.exit(1);
+    }
+    params.action = options.action;
+    if (options.path) params.path = options.path;
+    if (options.query) params.query = options.query;
+    if (options.limit) params.limit = parseInt(options.limit, 10);
+    if (options.file) params.file = options.file;
+    if (options.files) params.files = options.files.split(',').map(f => f.trim());
+    if (options.languages) params.languages = options.languages.split(',').map(l => l.trim());
+  } else if (jsonParams) {
+    // Non-JSON string provided but not for supported tools
+    console.error(chalk.red('Parameters must be valid JSON'));
+    console.error(chalk.gray(`Usage: ccw tool exec ${toolName} '{"param": "value"}'`));
+    process.exit(1);
+  }
+  // If no params provided, use empty object (tool may have defaults)
+
+  // Execute tool
+  const result = await executeTool(toolName, params);
+
+  // Always output JSON
+  console.log(JSON.stringify(result, null, 2));
+}
+
+/**
+ * Tool command entry point
+ * @param {string} subcommand - Subcommand (list, schema, exec)
+ * @param {string[]} args - Arguments array [toolName, jsonParams, ...]
+ * @param {Object} options - CLI options
+ */
+export async function toolCommand(subcommand: string, args: string | string[], options: ExecOptions): Promise<void> {
+  // args is now an array due to [args...] in cli.js
+  const argsArray = Array.isArray(args) ? args : (args ? [args] : []);
+
+  // Handle subcommands
+  switch (subcommand) {
+    case 'list':
+      await listAction();
+      break;
+    case 'schema':
+      await schemaAction({ name: argsArray[0] });
+      break;
+    case 'exec':
+      await execAction(argsArray[0], argsArray[1], options);
+      break;
+    default:
+      console.log(chalk.bold.cyan('\nCCW Tool System\n'));
+      console.log('Subcommands:');
+      console.log(chalk.gray('  list              List all available tools'));
+      console.log(chalk.gray('  schema [name]     Show tool schema (JSON)'));
+      console.log(chalk.gray('  exec <name>       Execute a tool'));
+      console.log();
+      console.log('Usage:');
+      console.log(chalk.gray('  ccw tool list'));
+      console.log(chalk.gray('  ccw tool schema edit_file'));
+      console.log(chalk.gray('  ccw tool exec <tool_name> \'{"param": "value"}\''));
+      console.log(chalk.gray('  ccw tool exec edit_file --path file.txt --old "old text" --new "new text"'));
+      console.log(chalk.gray('  ccw tool exec codex_lens --action search --query "def main" --path .'));
+  }
+}

package/ccw/src/commands/{uninstall.js → uninstall.ts}

@@ -1,15 +1,26 @@
 import { existsSync, unlinkSync, rmdirSync, readdirSync, statSync } from 'fs';
 import { join, dirname, basename } from 'path';
+import { homedir } from 'os';
 import inquirer from 'inquirer';
 import chalk from 'chalk';
 import { showBanner, createSpinner, success, info, warning, error, summaryBox, divider } from '../utils/ui.js';
 import { getAllManifests, deleteManifest } from '../core/manifest.js';
 
+// Global subdirectories that should be protected when Global installation exists
+const GLOBAL_SUBDIRS = ['workflows', 'scripts', 'templates'];
+
+interface UninstallOptions {}
+
+interface FileEntry {
+  path: string;
+  error: string;
+}
+
 /**
  * Uninstall command handler
  * @param {Object} options - Command options
  */
-export async function uninstallCommand(options) {
+export async function uninstallCommand(options: UninstallOptions): Promise<void> {
   showBanner();
   console.log(chalk.cyan.bold('  Uninstall Claude Code Workflow\n'));
 
@@ -38,7 +49,7 @@ export async function uninstallCommand(options) {
   divider();
 
   // Select installation to uninstall
-  let selectedManifest;
+  let selectedManifest: any;
 
   if (manifests.length === 1) {
     const { confirm } = await inquirer.prompt([{
@@ -92,12 +103,28 @@ export async function uninstallCommand(options) {
 
   console.log('');
 
+  // Check if this is a Path mode uninstallation and if Global installation exists
+  const isPathMode = selectedManifest.installation_mode === 'Path';
+  const globalClaudeDir = join(homedir(), '.claude');
+  let hasGlobalInstallation = false;
+  let skippedFiles = 0;
+
+  if (isPathMode) {
+    // Check if any Global installation manifest exists
+    const globalManifest = manifests.find(m => m.installation_mode === 'Global');
+    if (globalManifest) {
+      hasGlobalInstallation = true;
+      info('Global installation detected - global files will be preserved');
+      console.log('');
+    }
+  }
+
   // Perform uninstallation
   const spinner = createSpinner('Removing files...').start();
 
   let removedFiles = 0;
   let removedDirs = 0;
-  let failedFiles = [];
+  let failedFiles: FileEntry[] = [];
 
   try {
     // Remove files first (in reverse order to handle nested files)
@@ -105,6 +132,25 @@ export async function uninstallCommand(options) {
 
     for (const fileEntry of files) {
       const filePath = fileEntry.path;
+
+      // For Path mode uninstallation, skip global files if Global installation exists
+      if (isPathMode && hasGlobalInstallation) {
+        const normalizedPath = filePath.toLowerCase().replace(/\\/g, '/');
+        const normalizedGlobalDir = globalClaudeDir.toLowerCase().replace(/\\/g, '/');
+
+        // Check if file is under global .claude directory
+        if (normalizedPath.startsWith(normalizedGlobalDir)) {
+          // Check if it's in one of the global subdirectories
+          const relativePath = normalizedPath.substring(normalizedGlobalDir.length + 1);
+          const topDir = relativePath.split('/')[0];
+
+          if (GLOBAL_SUBDIRS.includes(topDir)) {
+            skippedFiles++;
+            continue;
+          }
+        }
+      }
+
       spinner.text = `Removing: ${basename(filePath)}`;
 
       try {
@@ -113,7 +159,8 @@ export async function uninstallCommand(options) {
           removedFiles++;
         }
       } catch (err) {
-        failedFiles.push({ path: filePath, error: err.message });
+        const error = err as Error;
+        failedFiles.push({ path: filePath, error: error.message });
       }
     }
 
@@ -121,7 +168,7 @@ export async function uninstallCommand(options) {
     const directories = [...(selectedManifest.directories || [])].reverse();
 
     // Sort by path length (deepest first)
-    directories.sort((a, b) => b.path.length - a.path.length);
+    directories.sort((a: any, b: any) => b.path.length - a.path.length);
 
     for (const dirEntry of directories) {
       const dirPath = dirEntry.path;
@@ -158,7 +205,8 @@ export async function uninstallCommand(options) {
 
   } catch (err) {
     spinner.fail('Uninstall failed');
-    error(err.message);
+    const errMsg = err as Error;
+    error(errMsg.message);
     return;
   }
 
@@ -168,41 +216,43 @@ export async function uninstallCommand(options) {
   // Show summary
   console.log('');
 
+  const summaryLines: string[] = [];
+
   if (failedFiles.length > 0) {
-    summaryBox({
-      title: ' Uninstall Summary ',
-      lines: [
-        chalk.yellow.bold('⚠ Partially Completed'),
-        '',
-        chalk.white(`Files removed: ${chalk.green(removedFiles)}`),
-        chalk.white(`Directories removed: ${chalk.green(removedDirs)}`),
-        chalk.white(`Failed: ${chalk.red(failedFiles.length)}`),
-        '',
-        chalk.gray('Some files could not be removed.'),
-        chalk.gray('They may be in use or require elevated permissions.'),
-      ],
-      borderColor: 'yellow'
-    });
+    summaryLines.push(chalk.yellow.bold('⚠ Partially Completed'));
+  } else {
+    summaryLines.push(chalk.green.bold('✓ Successfully Uninstalled'));
+  }
 
-    if (process.env.DEBUG) {
-      console.log('');
-      console.log(chalk.gray('Failed files:'));
-      failedFiles.forEach(f => {
-        console.log(chalk.red(`  ${f.path}: ${f.error}`));
-      });
-    }
+  summaryLines.push('');
+  summaryLines.push(chalk.white(`Files removed: ${chalk.green(removedFiles.toString())}`));
+  summaryLines.push(chalk.white(`Directories removed: ${chalk.green(removedDirs.toString())}`));
+
+  if (skippedFiles > 0) {
+    summaryLines.push(chalk.white(`Global files preserved: ${chalk.cyan(skippedFiles.toString())}`));
+  }
+
+  if (failedFiles.length > 0) {
+    summaryLines.push(chalk.white(`Failed: ${chalk.red(failedFiles.length.toString())}`));
+    summaryLines.push('');
+    summaryLines.push(chalk.gray('Some files could not be removed.'));
+    summaryLines.push(chalk.gray('They may be in use or require elevated permissions.'));
   } else {
-    summaryBox({
-      title: ' Uninstall Summary ',
-      lines: [
-        chalk.green.bold('✓ Successfully Uninstalled'),
-        '',
-        chalk.white(`Files removed: ${chalk.green(removedFiles)}`),
-        chalk.white(`Directories removed: ${chalk.green(removedDirs)}`),
-        '',
-        chalk.gray('Manifest removed'),
-      ],
-      borderColor: 'green'
+    summaryLines.push('');
+    summaryLines.push(chalk.gray('Manifest removed'));
+  }
+
+  summaryBox({
+    title: ' Uninstall Summary ',
+    lines: summaryLines,
+    borderColor: failedFiles.length > 0 ? 'yellow' : 'green'
+  });
+
+  if (process.env.DEBUG && failedFiles.length > 0) {
+    console.log('');
+    console.log(chalk.gray('Failed files:'));
+    failedFiles.forEach(f => {
+      console.log(chalk.red(`  ${f.path}: ${f.error}`));
     });
   }
 
@@ -213,7 +263,7 @@ export async function uninstallCommand(options) {
  * Recursively remove empty directories
  * @param {string} dirPath - Directory path
  */
-async function removeEmptyDirs(dirPath) {
+async function removeEmptyDirs(dirPath: string): Promise<void> {
   if (!existsSync(dirPath)) return;
 
   const stat = statSync(dirPath);
@@ -235,4 +285,3 @@ async function removeEmptyDirs(dirPath) {
     rmdirSync(dirPath);
   }
 }
-

package/ccw/src/commands/{upgrade.js → upgrade.ts}

@@ -1,5 +1,6 @@
 import { existsSync, readdirSync, statSync, copyFileSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
 import { join, dirname, basename } from 'path';
+import { homedir } from 'os';
 import { fileURLToPath } from 'url';
 import inquirer from 'inquirer';
 import chalk from 'chalk';
@@ -12,13 +13,30 @@ const __dirname = dirname(__filename);
 // Source directories to install
 const SOURCE_DIRS = ['.claude', '.codex', '.gemini', '.qwen'];
 
+// Subdirectories that should always be installed to global (~/.claude/)
+const GLOBAL_SUBDIRS = ['workflows', 'scripts', 'templates'];
+
+interface UpgradeOptions {
+  all?: boolean;
+}
+
+interface UpgradeResult {
+  files: number;
+  directories: number;
+}
+
+interface CopyResult {
+  files: number;
+  directories: number;
+}
+
 // Get package root directory (ccw/src/commands -> ccw)
-function getPackageRoot() {
+function getPackageRoot(): string {
   return join(__dirname, '..', '..');
 }
 
 // Get source installation directory (parent of ccw)
-function getSourceDir() {
+function getSourceDir(): string {
   return join(getPackageRoot(), '..');
 }
 
@@ -26,8 +44,15 @@ function getSourceDir() {
  * Get package version
  * @returns {string} - Version string
  */
-function getVersion() {
+function getVersion(): string {
   try {
+    // First try root package.json (parent of ccw)
+    const rootPkgPath = join(getSourceDir(), 'package.json');
+    if (existsSync(rootPkgPath)) {
+      const pkg = JSON.parse(readFileSync(rootPkgPath, 'utf8'));
+      if (pkg.version) return pkg.version;
+    }
+    // Fallback to ccw package.json
     const pkgPath = join(getPackageRoot(), 'package.json');
     const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
     return pkg.version || '1.0.0';
@@ -40,7 +65,7 @@ function getVersion() {
  * Upgrade command handler
  * @param {Object} options - Command options
  */
-export async function upgradeCommand(options) {
+export async function upgradeCommand(options: UpgradeOptions): Promise<void> {
   showBanner();
   console.log(chalk.cyan.bold('  Upgrade Claude Code Workflow\n'));
 
@@ -58,7 +83,7 @@ export async function upgradeCommand(options) {
   // Display current installations
   console.log(chalk.white.bold('  Current installations:\n'));
 
-  const upgradeTargets = [];
+  const upgradeTargets: any[] = [];
 
   for (let i = 0; i < manifests.length; i++) {
     const m = manifests[i];
@@ -105,7 +130,7 @@ export async function upgradeCommand(options) {
   }
 
   // Select which installations to upgrade
-  let selectedManifests = [];
+  let selectedManifests: any[] = [];
 
   if (options.all) {
     selectedManifests = upgradeTargets.map(t => t.manifest);
@@ -143,12 +168,12 @@ export async function upgradeCommand(options) {
       return;
     }
 
-    selectedManifests = selections.map(i => upgradeTargets[i].manifest);
+    selectedManifests = selections.map((i: number) => upgradeTargets[i].manifest);
   }
 
   // Perform upgrades
   console.log('');
-  const results = [];
+  const results: any[] = [];
   const sourceDir = getSourceDir();
 
   for (const manifest of selectedManifests) {
@@ -159,9 +184,10 @@ export async function upgradeCommand(options) {
       upgradeSpinner.succeed(`Upgraded ${manifest.installation_mode}: ${result.files} files`);
       results.push({ manifest, success: true, ...result });
     } catch (err) {
+      const errMsg = err as Error;
       upgradeSpinner.fail(`Failed to upgrade ${manifest.installation_mode}`);
-      error(err.message);
-      results.push({ manifest, success: false, error: err.message });
+      error(errMsg.message);
+      results.push({ manifest, success: false, error: errMsg.message });
     }
   }
 
@@ -208,8 +234,9 @@ export async function upgradeCommand(options) {
  * @param {string} version - Version string
  * @returns {Promise<Object>} - Upgrade result
  */
-async function performUpgrade(manifest, sourceDir, version) {
+async function performUpgrade(manifest: any, sourceDir: string, version: string): Promise<UpgradeResult> {
   const installPath = manifest.installation_path;
+  const mode = manifest.installation_mode;
 
   // Get available source directories
   const availableDirs = SOURCE_DIRS.filter(dir => existsSync(join(sourceDir, dir)));
@@ -219,30 +246,37 @@ async function performUpgrade(manifest, sourceDir, version) {
   }
 
   // Create new manifest
-  const newManifest = createManifest(manifest.installation_mode, installPath);
+  const newManifest = createManifest(mode, installPath);
 
   let totalFiles = 0;
   let totalDirs = 0;
 
+  // For Path mode, upgrade workflows to global first
+  if (mode === 'Path') {
+    const globalPath = homedir();
+    for (const subdir of GLOBAL_SUBDIRS) {
+      const srcWorkflows = join(sourceDir, '.claude', subdir);
+      if (existsSync(srcWorkflows)) {
+        const destWorkflows = join(globalPath, '.claude', subdir);
+        const { files, directories } = await copyDirectory(srcWorkflows, destWorkflows, newManifest);
+        totalFiles += files;
+        totalDirs += directories;
+      }
+    }
+  }
+
   // Copy each directory
   for (const dir of availableDirs) {
     const srcPath = join(sourceDir, dir);
     const destPath = join(installPath, dir);
 
-    const { files, directories } = await copyDirectory(srcPath, destPath, newManifest);
+    // For Path mode on .claude, exclude global subdirs (they're already installed to global)
+    const excludeDirs = (mode === 'Path' && dir === '.claude') ? GLOBAL_SUBDIRS : [];
+    const { files, directories } = await copyDirectory(srcPath, destPath, newManifest, excludeDirs);
     totalFiles += files;
     totalDirs += directories;
   }
 
-  // Copy CLAUDE.md to .claude directory
-  const claudeMdSrc = join(sourceDir, 'CLAUDE.md');
-  const claudeMdDest = join(installPath, '.claude', 'CLAUDE.md');
-  if (existsSync(claudeMdSrc) && existsSync(dirname(claudeMdDest))) {
-    copyFileSync(claudeMdSrc, claudeMdDest);
-    addFileEntry(newManifest, claudeMdDest);
-    totalFiles++;
-  }
-
   // Update version.json
   const versionPath = join(installPath, '.claude', 'version.json');
   if (existsSync(dirname(versionPath))) {
@@ -272,9 +306,15 @@ async function performUpgrade(manifest, sourceDir, version) {
  * @param {string} src - Source directory
  * @param {string} dest - Destination directory
  * @param {Object} manifest - Manifest to track files
+ * @param {string[]} excludeDirs - Directory names to exclude (optional)
  * @returns {Object} - Count of files and directories
  */
-async function copyDirectory(src, dest, manifest) {
+async function copyDirectory(
+  src: string,
+  dest: string,
+  manifest: any,
+  excludeDirs: string[] = []
+): Promise<CopyResult> {
   let files = 0;
   let directories = 0;
 
@@ -288,6 +328,11 @@ async function copyDirectory(src, dest, manifest) {
   const entries = readdirSync(src);
 
   for (const entry of entries) {
+    // Skip excluded directories
+    if (excludeDirs.includes(entry)) {
+      continue;
+    }
+
     const srcPath = join(src, entry);
     const destPath = join(dest, entry);
     const stat = statSync(srcPath);