@nemus-cli/nemus 0.2.1

package/src/commands/migrate.ts

@@ -0,0 +1,277 @@
+import { Command } from 'commander';
+import * as path from 'path';
+import * as fs from 'fs/promises';
+import { execSync } from 'child_process';
+import { WORKSPACES_DIR, getUserConfig } from '../utils/config';
+import { listWorkspaces, loadMetadata, saveMetadata } from '../utils/workspace-meta';
+import { generateClaudeContext, buildPerRepoContextSection } from '../utils/claude-integration';
+import { logInfo, logSuccess, logError, logWarning } from '../utils/logger';
+import { colorize } from '../utils/colors';
+import { WorkspaceMetadata, RepositoryMetadata } from '../types';
+import { getContextFileNames } from '../utils/agent-config';
+
+export function registerMigrateCommand(parent: Command) {
+  parent
+    .command('migrate')
+    .description('Migrate all workspaces to latest format (regenerate context files, update metadata)')
+    .option('--dry-run', 'Show what would be changed without making changes')
+    .action(async (opts) => {
+      await handleMigrate(opts);
+    });
+}
+
+async function handleMigrate(opts: { dryRun?: boolean }) {
+  const dryRun = opts.dryRun ?? false;
+
+  if (dryRun) {
+    logInfo('Dry run mode - no changes will be made\n');
+  }
+
+  const workspaces = await listWorkspaces(false);
+  if (workspaces.length === 0) {
+    logInfo('No workspaces found. Nothing to migrate.');
+    return;
+  }
+
+  logInfo(`Found ${colorize(String(workspaces.length), 'cyan')} workspaces to migrate\n`);
+
+  let migrated = 0;
+  let skipped = 0;
+  let errors = 0;
+
+  for (const ws of workspaces) {
+    const wsPath = ws.path;
+    const metadata = await loadMetadata(wsPath);
+
+    if (!metadata) {
+      // No metadata file - reconstruct it by scanning git subdirectories
+      logWarning(`${ws.name}: no metadata found - reconstructing from git repos`);
+      const reconstructed = await reconstructMetadata(ws.name, wsPath);
+      if (!reconstructed) {
+        logError(`  ${ws.name}: could not reconstruct metadata (no git repos found), skipping`);
+        skipped++;
+        continue;
+      }
+      if (!dryRun) {
+        await saveMetadata(wsPath, reconstructed);
+        logSuccess(`  ${colorize(ws.name, 'cyan')}: metadata created (${reconstructed.repositories.length} repos detected)`);
+      } else {
+        logInfo(`  ${colorize(ws.name, 'cyan')}: would create metadata (${reconstructed.repositories.length} repos detected)`);
+      }
+      // Regenerate context files using the reconstructed metadata.
+      const meta = reconstructed;
+      if (!dryRun) {
+        const repos = meta.repositories
+          .filter(r => r.status === 'success')
+          .map(r => ({ name: r.name, description: '', url: r.cloneUrl, owner: { login: r.owner }, sshUrl: r.cloneUrl }));
+        try {
+          await generateClaudeContext(wsPath, ws.name, repos as any, meta);
+        } catch { /* context gen is best-effort */ }
+      }
+      migrated++;
+      continue;
+    }
+
+    try {
+      const dirNames = metadata.repositories
+        .filter(r => r.status === 'success')
+        .map(r => r.directoryName);
+
+      const contextFiles = getContextFileNames();
+
+      // Read all existing context files first — before any writes.
+      // If any file is missing we must fall back to full regeneration;
+      // we determine this BEFORE touching anything so we never mix
+      // surgical patches with a subsequent full overwrite.
+      const existingContents = new Map<string, string>();
+      let needsFullRegen = false;
+      for (const fileName of contextFiles) {
+        try {
+          existingContents.set(fileName, await fs.readFile(path.join(wsPath, fileName), 'utf-8'));
+        } catch {
+          needsFullRegen = true;
+          break;
+        }
+      }
+
+      // Build the per-repo section (needs disk access; do once for both paths).
+      const perRepoSection = await buildPerRepoContextSection(wsPath, dirNames);
+      const repoCount = perRepoSection ? (perRepoSection.match(/^###/gm) || []).length : 0;
+
+      if (dryRun) {
+        if (needsFullRegen) {
+          logInfo(`  ${colorize(ws.name, 'cyan')}: would regenerate context files from scratch (context file missing)`);
+        } else if (repoCount > 0) {
+          logInfo(`  ${colorize(ws.name, 'cyan')}: would embed per-repo context from ${repoCount} location(s) into ${contextFiles.join(', ')}`);
+        } else {
+          logInfo(`  ${colorize(ws.name, 'cyan')}: would update ${contextFiles.join(', ')} (no per-repo context files found — any existing section removed)`);
+        }
+        migrated++;
+        continue;
+      }
+
+      // Ensure lastModified is set
+      if (!metadata.lastModified) {
+        metadata.lastModified = new Date().toISOString();
+        await saveMetadata(wsPath, metadata);
+      }
+
+      if (needsFullRegen) {
+        // One or more context files are missing — regenerate all from scratch.
+        const repos = metadata.repositories
+          .filter(r => r.status === 'success')
+          .map(r => ({
+            name: r.name, description: '', url: r.cloneUrl,
+            owner: { login: r.owner }, sshUrl: r.cloneUrl,
+          }));
+        await generateClaudeContext(wsPath, ws.name, repos as any, metadata);
+      } else {
+        // All context files exist — patch only the per-repo section in each.
+        for (const [fileName, existing] of existingContents) {
+          const updated = upsertPerRepoSection(existing, perRepoSection);
+          if (updated !== existing) {
+            await fs.writeFile(path.join(wsPath, fileName), updated, 'utf-8');
+          }
+        }
+      }
+
+      const detail = needsFullRegen
+        ? ' (regenerated from scratch)'
+        : repoCount > 0
+          ? ` (embedded per-repo context from ${repoCount} location(s))`
+          : ' (no per-repo context files found)';
+      logSuccess(`  ${colorize(ws.name, 'cyan')}: migrated${detail}`);
+      migrated++;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      logError(`  ${ws.name}: ${msg}`);
+      errors++;
+    }
+  }
+
+  console.log('');
+  logInfo(dryRun ? 'Dry run complete:' : 'Migration complete:');
+  console.log(`  ${colorize(String(migrated), 'green')} ${dryRun ? 'would migrate' : 'migrated'}`);
+  if (skipped > 0) console.log(`  ${colorize(String(skipped), 'yellow')} skipped`);
+  if (errors > 0) console.log(`  ${colorize(String(errors), 'red')} errors`);
+}
+
+/**
+ * Reconstruct a WorkspaceMetadata object for a workspace that has no metadata
+ * file by scanning subdirectories for git repositories and reading their
+ * remote origin URLs.
+ *
+ * Returns null if no git repos are found in the workspace directory.
+ */
+async function reconstructMetadata(
+  workspaceName: string,
+  workspacePath: string,
+): Promise<WorkspaceMetadata | null> {
+  let entries: string[];
+  try {
+    entries = await fs.readdir(workspacePath);
+  } catch {
+    return null;
+  }
+
+  const repositories: RepositoryMetadata[] = [];
+
+  for (const entry of entries) {
+    const repoPath = path.join(workspacePath, entry);
+    try {
+      const stat = await fs.stat(repoPath);
+      if (!stat.isDirectory()) continue;
+
+      // Check it's a git repo
+      await fs.access(path.join(repoPath, '.git'));
+
+      // Get the remote origin URL
+      let cloneUrl = '';
+      let owner = getUserConfig().githubOrg || 'your-org';
+      try {
+        cloneUrl = execSync('git remote get-url origin', {
+          cwd: repoPath, stdio: 'pipe', encoding: 'utf-8',
+        }).trim();
+        // Extract owner from SSH URL: git@github.com:owner/repo.git
+        const sshMatch = cloneUrl.match(/github\.com[:/]([^/]+)\//);
+        if (sshMatch) owner = sshMatch[1];
+      } catch { /* no remote - leave blank */ }
+
+      // Derive the canonical repo name from the remote URL, falling back
+      // to the directory name.
+      let repoName = entry;
+      try {
+        const urlMatch = cloneUrl.match(/\/([^/]+?)\.git$/) ||
+                         cloneUrl.match(/\/([^/]+)$/);
+        if (urlMatch) repoName = urlMatch[1];
+      } catch { /* use directory name */ }
+
+      repositories.push({
+        name: repoName,
+        directoryName: entry,
+        owner,
+        clonedAt: new Date().toISOString(),
+        cloneUrl,
+        status: 'success',
+      });
+    } catch { /* not accessible or not a git repo - skip */ }
+  }
+
+  if (repositories.length === 0) return null;
+
+  return {
+    workspaceName,
+    createdAt: new Date().toISOString(),
+    lastModified: new Date().toISOString(),
+    repositories,
+  };
+}
+
+/**
+ * Insert or replace the '## Per-Repository Context' section in an existing
+ * workspace context file, leaving everything else (user notes, etc.) intact.
+ *
+ * Insertion order (preferred first — we want the section as early as
+ * possible so the LLM weights it heavily):
+ *   1. Before '## Common Workflows'   — the new canonical position
+ *   2. Before '## Workspace Management' (older layouts)
+ *   3. Before '## AI Agent Rules'      (older layouts)
+ *   4. Before '## Tips for Working'    (older layouts)
+ *   5. Before '## Notes'               (legacy fallback)
+ *   6. Before '## Saved Context'       (legacy fallback)
+ *   7. Appended at the end             (last resort)
+ *
+ * If `newSection` is null the existing section (if any) is removed so that
+ * a workspace that previously had per-repo context but no longer does gets
+ * cleaned up.
+ */
+function upsertPerRepoSection(content: string, newSection: string | null): string {
+  // Match the section *including* its leading blank line(s) so removal
+  // leaves a clean join with no leftover blank lines. No 'm' flag so '$'
+  // only matches the true end-of-string.
+  const sectionRegex = /\n{1,2}## Per-Repository Context\b[\s\S]*?(?=\n## |\n#{1,2} |$)/;
+  // Only trimEnd() the very end of the file — never touch the body.
+  const base = content.replace(sectionRegex, '').trimEnd();
+
+  if (!newSection) return base + '\n'; // section removed, nothing to add back
+
+  const block = `\n\n${newSection.trim()}\n`;
+
+  // Try anchors in order of preference — earliest first so per-repo rules
+  // are read by the LLM before generic boilerplate.
+  const anchors = [
+    '\n## Common Workflows',
+    '\n## Workspace Management',
+    '\n## AI Agent Rules',
+    '\n## Tips for Working',
+    '\n## Notes',
+    '\n## Saved Context',
+  ];
+  for (const anchor of anchors) {
+    if (base.includes(anchor)) {
+      return base.replace(anchor, `${block}${anchor}`);
+    }
+  }
+  // Append (last resort)
+  return base + block;
+}

package/src/commands/remove-repo.ts

@@ -0,0 +1,194 @@
+import { Command } from 'commander';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { WORKSPACES_DIR } from '../utils/config';
+import { loadMetadata, saveMetadata } from '../utils/workspace-meta';
+import { generateClaudeContext } from '../utils/claude-integration';
+import { logInfo, logSuccess, logError, logStep } from '../utils/logger';
+import { colorize } from '../utils/colors';
+import inquirer from 'inquirer';
+import autocompletePrompt from 'inquirer-autocomplete-prompt';
+import * as fuzzy from 'fuzzy';
+import { getGlobalOpts, resolveWorkspace, parseList } from '../utils/command-helpers';
+
+inquirer.registerPrompt('autocomplete', autocompletePrompt);
+
+export function registerRemoveRepoCommand(parent: Command) {
+  parent
+    .command('remove-repo')
+    .alias('rr')
+    .description('Remove a repo from a workspace')
+    .option('-w, --workspace <name>', 'Workspace name')
+    .option('-r, --repos <repos>', 'Comma-separated repository directory names')
+    .action(async (opts, cmd) => {
+      const globalOpts = getGlobalOpts(cmd);
+      await handleRemoveRepo({ ...opts, ...globalOpts });
+    });
+}
+
+async function handleRemoveRepo(opts: {
+  workspace?: string;
+  repos?: string;
+  yes: boolean;
+  forceRefresh: boolean;
+}) {
+  console.log('\n' + '='.repeat(60));
+  console.log(colorize('Remove Repository Instances', 'bright'));
+  console.log('='.repeat(60) + '\n');
+
+  try {
+    logStep(1, 4, 'Select workspace...');
+    const workspaceName = await resolveWorkspace(opts.workspace);
+    const workspacePath = path.join(WORKSPACES_DIR, workspaceName);
+    logInfo(`Selected workspace: ${colorize(workspaceName, 'cyan')}`);
+
+    logStep(2, 4, 'Loading repository instances...');
+    const metadata = await loadMetadata(workspacePath);
+    const successRepos = metadata?.repositories.filter(r => r.status === 'success') ?? [];
+
+    const entries = await fs.readdir(workspacePath, { withFileTypes: true });
+    const diskDirs = entries
+      .filter(e => e.isDirectory() && !e.name.startsWith('.'))
+      .map(e => e.name);
+
+    const metaDirNames = new Set(successRepos.map(r => r.directoryName));
+    const repoEntries: Array<{ displayName: string; dirName: string }> = [];
+
+    for (const repo of successRepos) {
+      repoEntries.push({
+        displayName: repo.directoryName !== repo.name
+          ? `${repo.directoryName} (${repo.name})`
+          : repo.directoryName,
+        dirName: repo.directoryName,
+      });
+    }
+
+    for (const dir of diskDirs) {
+      if (!metaDirNames.has(dir)) {
+        repoEntries.push({ displayName: `${dir} (untracked)`, dirName: dir });
+      }
+    }
+
+    if (repoEntries.length === 0) {
+      logInfo('No repositories found in this workspace.');
+      if (opts.yes) {
+        await fs.rm(workspacePath, { recursive: true, force: true });
+        logSuccess(`Workspace "${workspaceName}" deleted.`);
+      } else {
+        const { deleteWorkspace } = await inquirer.prompt([{
+          type: 'confirm', name: 'deleteWorkspace',
+          message: `Delete the entire workspace folder "${workspaceName}"?`, default: false,
+        }]);
+        if (deleteWorkspace) {
+          await fs.rm(workspacePath, { recursive: true, force: true });
+          logSuccess(`Workspace "${workspaceName}" deleted.`);
+        } else {
+          logInfo('No action taken.');
+        }
+      }
+      process.exit(0);
+    }
+
+    logStep(3, 4, 'Select instances to remove...');
+
+    let selectedDirs: string[];
+
+    if (opts.repos) {
+      selectedDirs = parseList(opts.repos);
+      const unknownDirs = selectedDirs.filter(d => !repoEntries.some(e => e.dirName === d));
+      if (unknownDirs.length > 0) {
+        logError(`Directories not found in workspace: ${unknownDirs.join(', ')}`);
+        process.exit(1);
+      }
+    } else {
+      console.log('\n' + colorize('Repository Selection', 'bright'));
+      console.log('Type to search repositories. Use arrow keys to navigate, Enter to select.');
+      console.log('Type "done" when finished selecting.\n');
+
+      selectedDirs = [];
+
+      while (true) {
+        const available = repoEntries.filter(e => !selectedDirs.includes(e.dirName));
+        if (available.length === 0) {
+          console.log(colorize('All repositories selected.', 'yellow'));
+          break;
+        }
+
+        try {
+          const { repoDir } = await inquirer.prompt([{
+            type: 'autocomplete', name: 'repoDir',
+            message: `Search and select repository (${colorize(String(selectedDirs.length), 'cyan')} selected):`,
+            source: async (_answersSoFar: any, input: string | undefined) => {
+              const searchInput = input || '';
+              const doneOption = { name: colorize('done - Finish selection', 'green'), value: 'done' };
+              if (!searchInput || searchInput.toLowerCase().startsWith('done')) {
+                return [doneOption, ...available.map(e => ({ name: e.displayName, value: e.dirName }))];
+              }
+              const results = fuzzy.filter(searchInput, available, { extract: (e) => e.displayName });
+              return [doneOption, ...results.map(result => ({ name: result.original.displayName, value: result.original.dirName }))];
+            },
+            pageSize: 16,
+          } as any]);
+
+          if (repoDir === 'done') {
+            if (selectedDirs.length === 0) { console.log(colorize('\nYou must select at least one repository\n', 'yellow')); continue; }
+            break;
+          }
+
+          selectedDirs.push(repoDir);
+          const entry = repoEntries.find(e => e.dirName === repoDir);
+          console.log(colorize(`Added: ${entry?.displayName || repoDir}`, 'green'));
+        } catch { console.log('\n'); process.exit(0); }
+      }
+    }
+
+    console.log(`\n${colorize(`Selected ${selectedDirs.length} repository instance${selectedDirs.length === 1 ? '' : 's'}:`, 'cyan')}`);
+    selectedDirs.forEach(dir => console.log(`  - ${dir}`));
+    console.log('');
+
+    if (!opts.yes) {
+      const { confirm } = await inquirer.prompt([{
+        type: 'confirm', name: 'confirm',
+        message: `Remove ${selectedDirs.length} instance(s)? This will delete the directories.`, default: false,
+      }]);
+      if (!confirm) { logInfo('Removal cancelled'); process.exit(0); }
+    }
+
+    logStep(4, 4, 'Removing instances...');
+
+    for (const dirName of selectedDirs) {
+      const dirPath = path.join(workspacePath, dirName);
+      try {
+        await fs.rm(dirPath, { recursive: true, force: true });
+        logSuccess(`Removed: ${dirName}`);
+      } catch (error) {
+        logError(`Failed to remove ${dirName}: ${error instanceof Error ? error.message : 'Unknown error'}`);
+      }
+    }
+
+    const removedSet = new Set(selectedDirs);
+    if (metadata) {
+      metadata.repositories = metadata.repositories.filter(r => !removedSet.has(r.directoryName));
+      await saveMetadata(workspacePath, metadata);
+
+      const remainingRepos = metadata.repositories
+        .filter(r => r.status === 'success')
+        .map(r => ({
+          name: r.name, url: '', sshUrl: r.cloneUrl,
+          owner: { login: r.owner }, description: '', isPrivate: true,
+        }));
+
+      if (remainingRepos.length > 0) {
+        await generateClaudeContext(workspacePath, workspaceName, remainingRepos, metadata);
+      }
+
+      console.log(`\nWorkspace now has ${colorize(String(metadata.repositories.length), 'cyan')} repositories\n`);
+    }
+    logSuccess('Repository instances removed successfully!');
+
+  } catch (error) {
+    logError('Failed to remove repository instances');
+    if (error instanceof Error) { logError(error.message); }
+    process.exit(1);
+  }
+}

package/src/commands/report-bug.ts

@@ -0,0 +1,88 @@
+import { Command } from 'commander';
+import * as fs from 'fs';
+import * as path from 'path';
+import { logInfo, logSuccess, logError, logWarning } from '../utils/logger';
+import { colorize } from '../utils/colors';
+import {
+  reportBug,
+  readLastError,
+  type CapturedError,
+  BUG_REPORT_REPO,
+} from '../utils/bug-report';
+
+function getVersion(): string {
+  try {
+    const pkg = JSON.parse(
+      fs.readFileSync(path.join(__dirname, '..', '..', 'package.json'), 'utf-8'),
+    );
+    return pkg.version ?? 'unknown';
+  } catch {
+    return 'unknown';
+  }
+}
+
+export function registerReportBugCommand(parent: Command) {
+  parent
+    .command('report-bug')
+    .description('File the last error (or a custom message) as a GitHub issue')
+    .option('-m, --message <message>', 'Report a custom message instead of the last captured error')
+    .option('-f, --force', 'Report even if the error looks environmental (network/auth)')
+    .action(async (opts: { message?: string; force?: boolean }) => {
+      await handleReportBug(opts);
+    });
+}
+
+async function handleReportBug(opts: { message?: string; force?: boolean }): Promise<void> {
+  let captured: CapturedError | null;
+
+  if (opts.message) {
+    captured = {
+      command: 'w report-bug (manual)',
+      message: opts.message,
+      timestamp: new Date().toISOString(),
+      version: getVersion(),
+    };
+  } else {
+    captured = readLastError();
+    if (!captured) {
+      logError('No recent error to report.');
+      logInfo('Run a command that fails first, or use: w report-bug -m "describe the bug"');
+      process.exit(1);
+      return;
+    }
+    // Show which error we're about to report (with its age). Some failures
+    // — notably `nemus -- <prompt>` — exit without updating last-error.json, so
+    // the most recent capture could be an older crash. Surfacing the
+    // timestamp lets the user catch a stale report before filing.
+    const ageMs = Date.now() - new Date(captured.timestamp).getTime();
+    const ageMin = Math.floor(ageMs / 60000);
+    const when = Number.isFinite(ageMin)
+      ? (ageMin < 1 ? 'just now' : `${ageMin} min ago`)
+      : 'unknown time';
+    logInfo(`Last captured error (${when}): ${colorize(captured.command, 'cyan')}`);
+    logInfo(`  ${captured.message.split('\n')[0].slice(0, 100)}`);
+    if (ageMin >= 10) {
+      logWarning(`This error is ${ageMin} min old — make sure it's the one you mean to report.`);
+      logInfo('Tip: pass -m "..." to report a specific message instead.');
+    }
+  }
+
+  logInfo(`Reporting to ${colorize(BUG_REPORT_REPO, 'cyan')}...`);
+  const result = reportBug(captured, getVersion(), { force: opts.force });
+
+  switch (result.status) {
+    case 'created':
+      logSuccess(`Bug issue created: ${colorize(result.url!, 'cyan')}`);
+      break;
+    case 'duplicate':
+      logInfo(`This error was already reported: ${colorize(result.url!, 'cyan')}`);
+      logInfo('Subscribe there for updates — no duplicate filed.');
+      break;
+    case 'skipped':
+      logWarning(result.reason || 'Skipped.');
+      break;
+    case 'failed':
+      logError(result.reason || 'Failed to file the bug report.');
+      process.exit(1);
+  }
+}

package/src/commands/run.ts

@@ -0,0 +1,125 @@
+import { Command } from 'commander';
+import * as path from 'path';
+import { WORKSPACES_DIR } from '../utils/config';
+import { loadMetadata } from '../utils/workspace-meta';
+import { logError } from '../utils/logger';
+import { colorize } from '../utils/colors';
+import { resolveWorkspace } from '../utils/command-helpers';
+import { runInRepo, RunResult } from '../utils/run-operations';
+
+const CONCURRENCY_LIMIT = 3;
+
+export function registerRunCommand(parent: Command) {
+  parent
+    .command('run')
+    .alias('r')
+    .description('Run command across all repos')
+    .argument('[workspace]', 'Workspace name')
+    .argument('[command...]', 'Command to run (use quotes for flags: "git status -s")')
+    .allowUnknownOption()
+    .allowExcessArguments()
+    .action(async (workspace, commandParts) => {
+      // Commander parses positional args correctly even with allowUnknownOption.
+      // workspace = first positional, commandParts = rest as array.
+      // Unknown options (like -s in "git status -s") end up in commandParts too.
+      if (!workspace && (!commandParts || commandParts.length === 0)) {
+        // No args at all
+        await handleRun(undefined, []);
+      } else if (!commandParts || commandParts.length === 0) {
+        // Single arg: treat as command, prompt for workspace
+        await handleRun(undefined, [workspace]);
+      } else {
+        // First arg is workspace, rest is command
+        await handleRun(workspace, commandParts);
+      }
+    });
+}
+
+async function handleRun(workspaceArg?: string, commandParts?: string[]) {
+  try {
+    let workspaceName: string;
+    let command: string;
+
+    if (!commandParts || commandParts.length === 0) {
+      if (!workspaceArg) {
+        logError('Usage: w run [workspace-name] "<command>"');
+        process.exit(1);
+      }
+      // Only one arg: treat as command, prompt for workspace
+      command = workspaceArg;
+      workspaceName = await resolveWorkspace();
+    } else if (!workspaceArg) {
+      // commandParts provided but no workspace — treat first part as command
+      command = commandParts.join(' ');
+      workspaceName = await resolveWorkspace();
+    } else {
+      // Both workspace and command provided
+      workspaceName = workspaceArg;
+      command = commandParts.join(' ');
+    }
+
+    const workspacePath = path.join(WORKSPACES_DIR, workspaceName);
+    const metadata = await loadMetadata(workspacePath);
+
+    if (!metadata) {
+      logError(`Workspace metadata not found for: ${workspaceName}`);
+      process.exit(1);
+    }
+
+    const repos = metadata.repositories.filter(r => r.status === 'success');
+
+    console.log('\n' + colorize('Run Command Across Workspace', 'bright'));
+    console.log(`Workspace: ${colorize(workspaceName, 'cyan')}`);
+    console.log(`Command:   ${colorize(command, 'yellow')}`);
+    console.log(`Repos:     ${repos.length}\n`);
+
+    const results: RunResult[] = [];
+
+    for (let i = 0; i < repos.length; i += CONCURRENCY_LIMIT) {
+      const chunk = repos.slice(i, i + CONCURRENCY_LIMIT);
+      const chunkResults = await Promise.all(
+        chunk.map(repo => {
+          const repoPath = path.join(workspacePath, repo.directoryName);
+          const displayName = repo.directoryName !== repo.name
+            ? `${repo.directoryName} (${repo.name})`
+            : repo.name;
+          return runInRepo(repoPath, displayName, command);
+        })
+      );
+      results.push(...chunkResults);
+    }
+
+    console.log(colorize('═'.repeat(60), 'gray'));
+    for (const result of results) {
+      const icon = result.status === 'success'
+        ? colorize('✓', 'green')
+        : colorize('✗', 'red');
+
+      console.log(`\n${icon} ${colorize(result.repo, 'cyan')}`);
+
+      if (result.stdout) {
+        console.log(result.stdout);
+      }
+      if (result.stderr) {
+        console.log(colorize(result.stderr, 'yellow'));
+      }
+    }
+
+    const successful = results.filter(r => r.status === 'success').length;
+    const failed = results.filter(r => r.status === 'failed').length;
+
+    console.log('\n' + colorize('═'.repeat(60), 'gray'));
+    console.log(`${colorize('✓', 'green')} ${successful} successful, ${colorize('✗', 'red')} ${failed} failed`);
+    console.log('');
+
+    if (failed > 0) {
+      process.exit(1);
+    }
+  } catch (error) {
+    logError('Failed to run command');
+    if (error instanceof Error) {
+      logError(error.message);
+    }
+    process.exit(1);
+  }
+}