batch-exec-cli 1.2.0

package/.batchexecignore

@@ -0,0 +1,9 @@
+# Directories to ignore
+node_modules
+dist
+build
+.git
+.idea
+.vscode
+*.tmp
+temp-*

package/CHANGELOG.md

@@ -0,0 +1,11 @@
+# Changelog
+
+All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
+
+## 1.2.0 (2026-03-01)
+
+
+### Features
+
+* add colors highlight 240bf16
+* add progress display by using --no-progress 320a372

package/README.md

@@ -0,0 +1,143 @@
+# batch-exec
+
+高效批量命令执行工具，能够遍历目录内所有直接子目录并执行命令。
+
+## 功能特性
+
+- 🚀 高效遍历目标目录的所有直接子目录
+- 📁 支持绝对路径和相对路径
+- 🚫 可配置忽略目录（支持 `.gitignore` 风格的模式匹配）
+- 📊 提供执行摘要和失败目录列表
+- 🔧 跨平台支持（Windows、macOS、Linux）
+- 💬 详细的 verbose 输出模式
+- 🎨 彩色高亮输出，便于识别目录路径和命令
+- ⏳ 实时进度条显示，带旋转动画和执行时间
+- ✨ 精美的输出格式和摘要展示
+
+## 安装
+
+```bash
+npm install -g batch-exec
+```
+
+或者克隆项目后本地安装：
+
+```bash
+git clone <repository-url>
+cd batch-exec
+npm install
+npm link
+```
+
+## 使用方法
+
+### 基本用法
+
+```bash
+batch-exec <目录> <命令> [参数...]
+```
+
+### 示例
+
+在 `./my-projects` 目录下的所有子目录中执行 `git pull`：
+
+```bash
+batch-exec ./my-projects git pull
+```
+
+在 `./my-projects` 目录下的所有子目录中更新 lodash 依赖：
+
+```bash
+batch-exec ./my-projects npm update lodash -S
+```
+
+列出所有子目录的内容：
+
+```bash
+batch-exec ./repos ls -la
+```
+
+### 选项
+
+| 选项                | 别名 | 描述                                           |
+| ------------------- | ---- | ---------------------------------------------- |
+| `-s, --skip <文件>` |      | 指定忽略文件路径（默认：`./.batchexecignore`） |
+| `-v, --verbose`     |      | 显示详细输出                                   |
+| `--no-progress`     |      | 禁用进度条显示                                 |
+| `-h, --help`        |      | 显示帮助信息                                   |
+
+### 使用自定义忽略文件
+
+```bash
+batch-exec --skip ./custom-ignore.txt ./repos git status
+```
+
+### 禁用进度条
+
+```bash
+batch-exec --no-progress ./my-projects npm install
+```
+
+### 显示详细输出
+
+```bash
+batch-exec -v ./my-projects git status
+```
+
+## 输出示例
+
+### 普通模式（带进度条）
+
+```
+⠋ [████████████████████████████░░] 85% (17/20) [5s]
+```
+
+### 摘要展示
+
+```
+═══════════════════════════════════════════════════════════════
+📊 Execution Summary
+═══════════════════════════════════════════════════════════════
+  Total directories: 20
+  Successful:        18
+  Failed:            2
+
+❌ Failed directories:
+  • project1: Error: Command failed
+  • project3: Error: Permission denied
+═══════════════════════════════════════════════════════════════
+```
+
+## .batchexecignore 文件格式
+
+与 `.gitignore` 文件格式完全相同：
+
+```
+node_modules
+dist
+build
+.git
+.idea
+.vscode
+*.tmp
+temp-*
+```
+
+## API 使用
+
+你也可以作为库使用：
+
+```javascript
+import { batchExecute } from 'batch-exec';
+
+const results = await batchExecute('./my-projects', 'git', ['pull'], {
+  verbose: false,
+  showProgress: true
+});
+
+console.log(results);
+```
+
+## 许可证
+
+MIT

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "batch-exec-cli",
+  "version": "1.2.0",
+  "description": "Efficiently iterate through directories and execute commands with progress display",
+  "type": "module",
+  "main": "src/index.js",
+  "bin": {
+    "batch-exec": "src/cli.js"
+  },
+  "scripts": {
+    "test": "echo 'Tests require Node.js >= 18.0.0 with --test support'",
+    "lint": "eslint src/ test/"
+  },
+  "keywords": [
+    "batch",
+    "execute",
+    "command",
+    "directory",
+    "zx",
+    "progress",
+    "cli"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/chandq/batch-exec.git"
+  },
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "minimist": "^1.2.8",
+    "zx": "^8.8.5"
+  },
+  "devDependencies": {
+    "eslint": "^8.57.0"
+  },
+  "engines": {
+    "node": ">=12.17.0"
+  }
+}

package/src/cli.js

@@ -0,0 +1,124 @@
+#!/usr/bin/env node
+
+import path from 'path';
+import minimist from 'minimist';
+import { $ } from 'zx';
+import { batchExecute, parseIgnoreFile } from './index.js';
+import { cyan, yellow, green, red, gray, bold, dim, magenta, blue } from './utils/colors.js';
+
+$.verbose = false;
+
+async function main() {
+  const argv = minimist(process.argv.slice(2), {
+    boolean: ['v', 'verbose', 'h', 'help', 'no-progress'],
+    string: ['s', 'skip'],
+    alias: {
+      s: 'skip',
+      v: 'verbose',
+      h: 'help'
+    }
+  });
+
+  if (argv.help) {
+    printHelp();
+    process.exit(0);
+  }
+
+  const [targetDir, command, ...args] = argv._;
+
+  if (!targetDir || !command) {
+    console.error(red('Error: Missing required arguments'));
+    printHelp();
+    process.exit(1);
+  }
+
+  let ignoreFilePath = argv.skip;
+
+  if (!ignoreFilePath) {
+    const defaultIgnorePath = path.join(process.cwd(), '.batchexecignore');
+    ignoreFilePath = defaultIgnorePath;
+  }
+
+  const skipPaths = await parseIgnoreFile(ignoreFilePath);
+
+  if (argv.verbose) {
+    console.log(bold('\n🚀 Batch Executor\n'));
+    console.log(`Target directory: ${cyan(targetDir)}`);
+    console.log(`Command: ${yellow(command)} ${args.join(' ')}`);
+    if (skipPaths.length > 0) {
+      console.log(`Skipping directories: ${gray(skipPaths.join(', '))}`);
+    }
+    console.log(gray('----------------------------------------\n'));
+  }
+
+  try {
+    const results = await batchExecute(targetDir, command, args, {
+      skipPaths,
+      verbose: argv.verbose,
+      showProgress: argv.progress !== false
+    });
+
+    printSummary(results);
+  } catch (error) {
+    console.error(red(`\nError: ${error.message}\n`));
+    process.exit(1);
+  }
+}
+
+function printHelp() {
+  console.log(`
+${bold('Batch Executor')} ${dim('v1.1.0')}
+
+${cyan('Usage:')} batch-exec [options] <directory> <command> [args...]
+
+Efficiently iterate through all direct subdirectories of a directory and execute a command.
+
+${blue('Arguments:')}
+  ${cyan('<directory>')}    Target directory (absolute or relative path)
+  ${yellow('<command>')}      Command to execute in each subdirectory
+  [args...]      Optional arguments for the command
+
+${magenta('Options:')}
+  -s, --skip <file>  Ignore file path (default: ./.batchexecignore)
+  -v, --verbose      Show verbose output
+      --no-progress  Disable progress bar
+  -h, --help         Show this help message
+
+${green('Examples:')}
+  ${green('batch-exec')} ./my-projects git pull
+  ${green('batch-exec')} ./my-projects npm update lodash -S
+  ${green('batch-exec')} --skip ./custom-ignore.txt ./repos ls -la
+`);
+}
+
+function printSummary(results) {
+  const successCount = results.filter(r => r.success).length;
+  const failureCount = results.filter(r => !r.success).length;
+
+  console.log(bold('\n═══════════════════════════════════════════════════════════════'));
+  console.log(bold('📊 Execution Summary'));
+  console.log('═══════════════════════════════════════════════════════════════');
+  console.log(`  Total directories: ${bold(results.length.toString())}`);
+  console.log(`  Successful:        ${green(bold(successCount.toString()))}`);
+  console.log(`  Failed:            ${failureCount > 0 ? red(bold(failureCount.toString())) : '0'}`);
+
+  if (failureCount > 0) {
+    console.log('\n' + red(bold('❌ Failed directories:')));
+    results
+      .filter(r => !r.success)
+      .forEach(r => {
+        console.log(`  ${cyan('•')} ${cyan(r.directory)}: ${red(r.error)}`);
+      });
+  }
+
+  if (successCount > 0 && failureCount === 0) {
+    console.log('\n' + green(bold('✅ All operations completed successfully!')));
+  }
+
+  console.log('═══════════════════════════════════════════════════════════════\n');
+}
+
+main().catch(error => {
+  console.error(red('Fatal error:'), error);
+  process.exit(1);
+});

package/src/directoryLister.js

@@ -0,0 +1,31 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { shouldSkipDirectory } from './ignoreParser.js';
+
+export async function listDirectSubdirectories(targetDir, skipPatterns = []) {
+  const absoluteTargetDir = path.resolve(targetDir);
+
+  try {
+    const entries = await fs.readdir(absoluteTargetDir, { withFileTypes: true });
+
+    const subdirs = [];
+
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        if (!shouldSkipDirectory(entry.name, skipPatterns)) {
+          subdirs.push(entry.name);
+        }
+      }
+    }
+
+    return subdirs.sort();
+  } catch (error) {
+    if (error.code === 'ENOENT') {
+      throw new Error(`Directory not found: ${absoluteTargetDir}`);
+    }
+    if (error.code === 'ENOTDIR') {
+      throw new Error(`Not a directory: ${absoluteTargetDir}`);
+    }
+    throw error;
+  }
+}

package/src/ignoreParser.js

@@ -0,0 +1,52 @@
+import fs from 'fs/promises';
+import path from 'path';
+
+export async function parseIgnoreFile(ignoreFilePath) {
+  if (!ignoreFilePath) {
+    return [];
+  }
+
+  try {
+    const content = await fs.readFile(ignoreFilePath, 'utf-8');
+    const lines = content.split('\n');
+
+    return lines
+      .map(line => line.trim())
+      .filter(line => line && !line.startsWith('#'));
+  } catch (error) {
+    if (error.code === 'ENOENT') {
+      return [];
+    }
+    throw error;
+  }
+}
+
+export function shouldSkipDirectory(dirName, skipPatterns) {
+  if (!skipPatterns || skipPatterns.length === 0) {
+    return false;
+  }
+
+  return skipPatterns.some(pattern => {
+    if (pattern === dirName) {
+      return true;
+    }
+
+    if (pattern.endsWith('/')) {
+      const patternWithoutSlash = pattern.slice(0, -1);
+      if (patternWithoutSlash === dirName) {
+        return true;
+      }
+    }
+
+    if (pattern.includes('*')) {
+      const regexPattern = pattern
+        .replace(/\./g, '\\.')
+        .replace(/\*/g, '.*')
+        .replace(/\?/g, '.');
+      const regex = new RegExp(`^${regexPattern}$`);
+      return regex.test(dirName);
+    }
+
+    return false;
+  });
+}

package/src/index.js

@@ -0,0 +1,89 @@
+import path from 'path';
+import { $, cd } from 'zx';
+import { parseIgnoreFile } from './ignoreParser.js';
+import { listDirectSubdirectories } from './directoryLister.js';
+import { cyan, red, ProgressBar, clearLine } from './utils/colors.js';
+
+export { parseIgnoreFile };
+export { listDirectSubdirectories };
+
+export async function batchExecute(targetDir, command, args, options = {}) {
+  const { skipPaths = [], verbose = false, showProgress = true } = options;
+
+  const absoluteTargetDir = path.resolve(targetDir);
+
+  const subdirs = await listDirectSubdirectories(absoluteTargetDir, skipPaths);
+
+  const results = [];
+  let progressBar = null;
+
+  if (showProgress && subdirs.length > 0) {
+    progressBar = new ProgressBar(subdirs.length);
+    progressBar.start();
+  }
+
+  for (let i = 0; i < subdirs.length; i++) {
+    const subdir = subdirs[i];
+    const subdirPath = path.join(absoluteTargetDir, subdir);
+
+    try {
+      if (verbose) {
+        console.log(`=== Executing in: ${cyan(subdirPath)} ===`);
+      }
+
+      let result;
+
+      cd(subdirPath);
+
+      if (verbose) {
+        result = await $`${command} ${args}`;
+      } else {
+        result = await $`${command} ${args}`.quiet();
+      }
+
+      results.push({
+        directory: subdir,
+        success: true,
+        stdout: result.stdout,
+        stderr: result.stderr
+      });
+
+      if (verbose) {
+        console.log(result.stdout);
+        if (result.stderr) {
+          console.error(result.stderr);
+        }
+      }
+    } catch (error) {
+      results.push({
+        directory: subdir,
+        success: false,
+        error: error.message,
+        stdout: error.stdout || '',
+        stderr: error.stderr || ''
+      });
+
+      if (verbose) {
+        console.error(red(`Error in ${cyan(subdir)}: ${error.message}`));
+        if (error.stdout) {
+          console.log(error.stdout);
+        }
+        if (error.stderr) {
+          console.error(error.stderr);
+        }
+      }
+    }
+
+    if (progressBar) {
+      progressBar.update(i + 1);
+    }
+  }
+
+  if (progressBar) {
+    progressBar.stop();
+  } else if (!verbose) {
+    clearLine();
+  }
+
+  return results;
+}

package/src/utils/colors.js

@@ -0,0 +1,209 @@
+const colors = {
+  reset: '\x1b[0m',
+  bright: '\x1b[1m',
+  dim: '\x1b[2m',
+  underscore: '\x1b[4m',
+  blink: '\x1b[5m',
+  reverse: '\x1b[7m',
+  hidden: '\x1b[8m',
+
+  fg: {
+    black: '\x1b[30m',
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    blue: '\x1b[34m',
+    magenta: '\x1b[35m',
+    cyan: '\x1b[36m',
+    white: '\x1b[37m',
+    gray: '\x1b[90m'
+  },
+
+  bg: {
+    black: '\x1b[40m',
+    red: '\x1b[41m',
+    green: '\x1b[42m',
+    yellow: '\x1b[43m',
+    blue: '\x1b[44m',
+    magenta: '\x1b[45m',
+    cyan: '\x1b[46m',
+    white: '\x1b[47m'
+  }
+};
+
+function wrap(color, text) {
+  return `${color}${text}${colors.reset}`;
+}
+
+export function cyan(text) {
+  return wrap(colors.fg.cyan, text);
+}
+
+export function yellow(text) {
+  return wrap(colors.fg.yellow, text);
+}
+
+export function green(text) {
+  return wrap(colors.fg.green, text);
+}
+
+export function red(text) {
+  return wrap(colors.fg.red, text);
+}
+
+export function gray(text) {
+  return wrap(colors.fg.gray, text);
+}
+
+export function blue(text) {
+  return wrap(colors.fg.blue, text);
+}
+
+export function magenta(text) {
+  return wrap(colors.fg.magenta, text);
+}
+
+export function white(text) {
+  return wrap(colors.fg.white, text);
+}
+
+export function bold(text) {
+  return wrap(colors.bright, text);
+}
+
+export function dim(text) {
+  return wrap(colors.dim, text);
+}
+
+export function underline(text) {
+  return wrap(colors.underscore, text);
+}
+
+export function bgGreen(text) {
+  return wrap(colors.bg.green, text);
+}
+
+export function bgRed(text) {
+  return wrap(colors.bg.red, text);
+}
+
+export function bgYellow(text) {
+  return wrap(colors.bg.yellow, text);
+}
+
+export function bgCyan(text) {
+  return wrap(colors.bg.cyan, text);
+}
+
+const spinnerFrames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+
+export class ProgressBar {
+  constructor(total, options = {}) {
+    this.total = total;
+    this.current = 0;
+    this.startTime = Date.now();
+    this.lastUpdate = 0;
+    this.spinnerIndex = 0;
+    this.spinnerInterval = null;
+    this.options = {
+      width: 40,
+      showSpinner: true,
+      showPercentage: true,
+      showCount: true,
+      showElapsed: true,
+      ...options
+    };
+  }
+
+  start() {
+    if (this.options.showSpinner) {
+      this.spinnerInterval = setInterval(() => {
+        this.spinnerIndex = (this.spinnerIndex + 1) % spinnerFrames.length;
+        this.render(false);
+      }, 100);
+    }
+    this.render(true);
+  }
+
+  update(current) {
+    this.current = current;
+    this.render(true);
+  }
+
+  increment() {
+    this.current++;
+    this.render(true);
+  }
+
+  stop() {
+    if (this.spinnerInterval) {
+      clearInterval(this.spinnerInterval);
+      this.spinnerInterval = null;
+    }
+    this.render(true);
+    console.log();
+  }
+
+  render(clear = false) {
+    const now = Date.now();
+    if (!clear && now - this.lastUpdate < 50) return;
+    this.lastUpdate = now;
+
+    const percentage = this.total > 0 ? Math.floor((this.current / this.total) * 100) : 0;
+    const filledWidth = this.total > 0 ? Math.floor((this.current / this.total) * this.options.width) : 0;
+    const emptyWidth = this.options.width - filledWidth;
+    
+    const bar = '█'.repeat(filledWidth) + '░'.repeat(emptyWidth);
+    const spinner = this.spinnerInterval ? spinnerFrames[this.spinnerIndex] : '✓';
+    
+    let output = '';
+    
+    if (this.options.showSpinner) {
+      output += `${cyan(spinner)} `;
+    }
+    
+    output += `[${green(bar)}]`;
+    
+    if (this.options.showPercentage) {
+      output += ` ${bold(`${percentage}%`)}`;
+    }
+    
+    if (this.options.showCount) {
+      output += ` ${dim(`(${this.current}/${this.total})`)}`;
+    }
+    
+    if (this.options.showElapsed) {
+      const elapsed = Math.floor((now - this.startTime) / 1000);
+      output += ` ${gray(`[${elapsed}s]`)}`;
+    }
+
+    if (clear) {
+      process.stdout.write('\r' + ' '.repeat(process.stdout.columns || 80));
+    }
+    process.stdout.write('\r' + output);
+  }
+}
+
+export function clearLine() {
+  process.stdout.write('\r' + ' '.repeat(process.stdout.columns || 80) + '\r');
+}
+
+export function moveCursorUp(count = 1) {
+  process.stdout.write(`\x1b[${count}A`);
+}
+
+export function moveCursorDown(count = 1) {
+  process.stdout.write(`\x1b[${count}B`);
+}
+
+export function eraseToEnd() {
+  process.stdout.write('\x1b[K');
+}
+
+export function saveCursor() {
+  process.stdout.write('\x1b[s');
+}
+
+export function restoreCursor() {
+  process.stdout.write('\x1b[u');
+}

package/test/cli.test.js

@@ -0,0 +1,70 @@
+import { describe, it, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert';
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+import { $ } from 'zx';
+
+describe('CLI Integration', () => {
+  let tempDir;
+  let testProjectsDir;
+
+  beforeEach(async () => {
+    tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'batch-exec-cli-test-'));
+    testProjectsDir = path.join(tempDir, 'test-projects');
+
+    await fs.mkdir(testProjectsDir);
+    await fs.mkdir(path.join(testProjectsDir, 'project1'));
+    await fs.mkdir(path.join(testProjectsDir, 'project2'));
+    await fs.mkdir(path.join(testProjectsDir, 'node_modules'));
+
+    await fs.writeFile(path.join(tempDir, '.batchexecignore'), 'node_modules');
+  });
+
+  afterEach(async () => {
+    await fs.rm(tempDir, { recursive: true, force: true });
+  });
+
+  it('should show help message with --help', async () => {
+    const result = await $`node ${path.join(process.cwd(), 'src/cli.js')} --help`;
+    assert(result.stdout.includes('Usage:'));
+    assert(result.stdout.includes('batch-exec'));
+  });
+
+  it('should execute command in subdirectories', async () => {
+    const result = await $`node ${path.join(process.cwd(), 'src/cli.js')} ${testProjectsDir} echo test`;
+    assert(result.stdout.includes('Summary:'));
+    assert(result.stdout.includes('Total directories: 2'));
+  });
+
+  it('should respect .batchexecignore file', async () => {
+    const result = await $`node ${path.join(process.cwd(), 'src/cli.js')} ${testProjectsDir} pwd`;
+    assert(result.stdout.includes('Total directories: 2'));
+    assert(!result.stdout.includes('node_modules'));
+  });
+
+  it('should work with custom ignore file using --skip', async () => {
+    const customIgnore = path.join(tempDir, 'custom-ignore');
+    await fs.writeFile(customIgnore, 'project1\nnode_modules');
+
+    const result = await $`node ${path.join(
+      process.cwd(),
+      'src/cli.js'
+    )} --skip ${customIgnore} ${testProjectsDir} pwd`;
+    assert(result.stdout.includes('Total directories: 1'));
+    assert(!result.stdout.includes('project1'));
+  });
+
+  it('should show verbose output with --verbose', async () => {
+    const result = await $`node ${path.join(process.cwd(), 'src/cli.js')} --verbose ${testProjectsDir} echo hello`;
+    assert(result.stdout.includes('Target directory:'));
+    assert(result.stdout.includes('Command:'));
+  });
+
+  it('should fail with error message when missing arguments', async () => {
+    await assert.rejects($`node ${path.join(process.cwd(), 'src/cli.js')}`, error => {
+      assert(error.stderr.includes('Missing required arguments'));
+      return true;
+    });
+  });
+});

package/test/directoryLister.test.js

@@ -0,0 +1,68 @@
+import { describe, it, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert';
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+import { listDirectSubdirectories } from '../src/directoryLister.js';
+
+describe('directoryLister', () => {
+  let tempDir;
+
+  beforeEach(async () => {
+    tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'batch-exec-test-'));
+    
+    await fs.mkdir(path.join(tempDir, 'dir1'));
+    await fs.mkdir(path.join(tempDir, 'dir2'));
+    await fs.mkdir(path.join(tempDir, 'node_modules'));
+    await fs.mkdir(path.join(tempDir, '.git'));
+    
+    await fs.writeFile(path.join(tempDir, 'file1.txt'), 'content');
+    await fs.writeFile(path.join(tempDir, 'file2.js'), 'content');
+  });
+
+  afterEach(async () => {
+    await fs.rm(tempDir, { recursive: true, force: true });
+  });
+
+  describe('listDirectSubdirectories', () => {
+    it('should list only direct subdirectories', async () => {
+      const subdirs = await listDirectSubdirectories(tempDir);
+      assert.deepStrictEqual(subdirs.sort(), ['.git', 'dir1', 'dir2', 'node_modules'].sort());
+    });
+
+    it('should skip directories matching patterns', async () => {
+      const subdirs = await listDirectSubdirectories(tempDir, ['node_modules', '.git']);
+      assert.deepStrictEqual(subdirs, ['dir1', 'dir2']);
+    });
+
+    it('should skip directories with wildcard patterns', async () => {
+      const subdirs = await listDirectSubdirectories(tempDir, ['dir*']);
+      assert.deepStrictEqual(subdirs.sort(), ['.git', 'node_modules'].sort());
+    });
+
+    it('should return sorted directory names', async () => {
+      const subdirs = await listDirectSubdirectories(tempDir);
+      assert.deepStrictEqual(subdirs, subdirs.slice().sort());
+    });
+
+    it('should throw error for non-existent directory', async () => {
+      await assert.rejects(
+        listDirectSubdirectories(path.join(tempDir, 'non-existent')),
+        { message: /Directory not found/ }
+      );
+    });
+
+    it('should throw error for file path', async () => {
+      await assert.rejects(
+        listDirectSubdirectories(path.join(tempDir, 'file1.txt')),
+        { message: /Not a directory/ }
+      );
+    });
+
+    it('should work with relative paths', async () => {
+      const relativePath = path.relative(process.cwd(), tempDir);
+      const subdirs = await listDirectSubdirectories(relativePath);
+      assert.deepStrictEqual(subdirs.sort(), ['.git', 'dir1', 'dir2', 'node_modules'].sort());
+    });
+  });
+});

package/test/ignoreParser.test.js

@@ -0,0 +1,93 @@
+import { describe, it, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert';
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+import { parseIgnoreFile, shouldSkipDirectory } from '../src/ignoreParser.js';
+
+describe('ignoreParser', () => {
+  let tempDir;
+
+  beforeEach(async () => {
+    tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'batch-exec-test-'));
+  });
+
+  afterEach(async () => {
+    await fs.rm(tempDir, { recursive: true, force: true });
+  });
+
+  describe('parseIgnoreFile', () => {
+    it('should parse ignore file correctly', async () => {
+      const ignoreFilePath = path.join(tempDir, '.testignore');
+      await fs.writeFile(ignoreFilePath, `
+# This is a comment
+node_modules
+dist/
+*.tmp
+test-*
+
+# Another comment
+build
+      `.trim());
+
+      const patterns = await parseIgnoreFile(ignoreFilePath);
+      assert.deepStrictEqual(patterns, [
+        'node_modules',
+        'dist/',
+        '*.tmp',
+        'test-*',
+        'build'
+      ]);
+    });
+
+    it('should return empty array for non-existent file', async () => {
+      const patterns = await parseIgnoreFile(path.join(tempDir, 'non-existent'));
+      assert.deepStrictEqual(patterns, []);
+    });
+
+    it('should return empty array for null or undefined', async () => {
+      const patterns1 = await parseIgnoreFile(null);
+      const patterns2 = await parseIgnoreFile(undefined);
+      assert.deepStrictEqual(patterns1, []);
+      assert.deepStrictEqual(patterns2, []);
+    });
+  });
+
+  describe('shouldSkipDirectory', () => {
+    it('should return false when no patterns provided', () => {
+      assert.strictEqual(shouldSkipDirectory('dir1', []), false);
+      assert.strictEqual(shouldSkipDirectory('dir1', null), false);
+      assert.strictEqual(shouldSkipDirectory('dir1', undefined), false);
+    });
+
+    it('should match exact directory names', () => {
+      assert.strictEqual(shouldSkipDirectory('node_modules', ['node_modules']), true);
+      assert.strictEqual(shouldSkipDirectory('dist', ['node_modules']), false);
+    });
+
+    it('should match directory names with trailing slash', () => {
+      assert.strictEqual(shouldSkipDirectory('dist', ['dist/']), true);
+      assert.strictEqual(shouldSkipDirectory('node_modules', ['dist/']), false);
+    });
+
+    it('should match wildcard patterns', () => {
+      assert.strictEqual(shouldSkipDirectory('test-123', ['test-*']), true);
+      assert.strictEqual(shouldSkipDirectory('test-abc', ['test-*']), true);
+      assert.strictEqual(shouldSkipDirectory('other', ['test-*']), false);
+    });
+
+    it('should match extension wildcards', () => {
+      assert.strictEqual(shouldSkipDirectory('file.tmp', ['*.tmp']), true);
+      assert.strictEqual(shouldSkipDirectory('test.tmp', ['*.tmp']), true);
+      assert.strictEqual(shouldSkipDirectory('test.txt', ['*.tmp']), false);
+    });
+
+    it('should match any of the patterns', () => {
+      const patterns = ['node_modules', 'dist/', '*.tmp'];
+      assert.strictEqual(shouldSkipDirectory('node_modules', patterns), true);
+      assert.strictEqual(shouldSkipDirectory('dist', patterns), true);
+      assert.strictEqual(shouldSkipDirectory('test.tmp', patterns), true);
+      assert.strictEqual(shouldSkipDirectory('src', patterns), false);
+    });
+  });
+});

package/test/index.test.js

@@ -0,0 +1,70 @@
+import { describe, it, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert';
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+import { batchExecute } from '../src/index.js';
+
+describe('batchExecute', () => {
+  let tempDir;
+
+  beforeEach(async () => {
+    tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'batch-exec-test-'));
+    
+    await fs.mkdir(path.join(tempDir, 'dir1'));
+    await fs.mkdir(path.join(tempDir, 'dir2'));
+    await fs.mkdir(path.join(tempDir, 'skip-me'));
+  });
+
+  afterEach(async () => {
+    await fs.rm(tempDir, { recursive: true, force: true });
+  });
+
+  it('should execute command in all subdirectories', async () => {
+    const results = await batchExecute(tempDir, 'pwd', []);
+    
+    assert.strictEqual(results.length, 3);
+    
+    results.forEach(result => {
+      assert.strictEqual(result.success, true);
+    });
+  });
+
+  it('should skip specified directories', async () => {
+    const results = await batchExecute(tempDir, 'pwd', [], {
+      skipPaths: ['skip-me']
+    });
+    
+    assert.strictEqual(results.length, 2);
+    
+    const dirs = results.map(r => r.directory);
+    assert.deepStrictEqual(dirs.sort(), ['dir1', 'dir2'].sort());
+  });
+
+  it('should capture command output', async () => {
+    const results = await batchExecute(tempDir, 'echo', ['hello']);
+    
+    results.forEach(result => {
+      assert.strictEqual(result.success, true);
+      assert(result.stdout.includes('hello'));
+    });
+  });
+
+  it('should handle command failures gracefully', async () => {
+    const results = await batchExecute(tempDir, 'this-command-does-not-exist', []);
+    
+    results.forEach(result => {
+      assert.strictEqual(result.success, false);
+      assert(result.error);
+    });
+  });
+
+  it('should work with multiple arguments', async () => {
+    const results = await batchExecute(tempDir, 'echo', ['hello', 'world']);
+    
+    results.forEach(result => {
+      assert.strictEqual(result.success, true);
+      assert(result.stdout.includes('hello world'));
+    });
+  });
+});