@nemus-cli/nemus 0.2.1

package/src/commands/diff.ts

@@ -0,0 +1,106 @@
+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 { getRepoDiff, RepoDiff } from '../utils/diff-operations';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+
+const execAsync = promisify(exec);
+
+export function registerDiffCommand(parent: Command) {
+  parent
+    .command('diff')
+    .alias('di')
+    .description('Show diff summary across all repos')
+    .argument('[workspace]', 'Workspace name')
+    .option('--full', 'Show full diff output')
+    .action(async (workspace, opts) => {
+      await handleDiff(workspace, opts);
+    });
+}
+
+async function handleDiff(workspaceArg?: string, opts: { full?: boolean } = {}) {
+  try {
+    const selectedWorkspace = await resolveWorkspace(workspaceArg);
+    const workspacePath = path.join(WORKSPACES_DIR, selectedWorkspace);
+    const metadata = await loadMetadata(workspacePath);
+
+    if (!metadata) {
+      logError(`Workspace metadata not found for: ${selectedWorkspace}`);
+      process.exit(1);
+    }
+
+    const repos = metadata.repositories.filter(r => r.status === 'success');
+
+    console.log('\n' + colorize('Workspace Diff Summary', 'bright'));
+    console.log(colorize('═'.repeat(40), 'gray') + '\n');
+
+    const diffs: RepoDiff[] = [];
+    let totalStaged = 0;
+    let totalUnstaged = 0;
+    let reposWithChanges = 0;
+
+    for (const repo of repos) {
+      const repoPath = path.join(workspacePath, repo.directoryName);
+      const displayName = repo.directoryName !== repo.name
+        ? `${repo.directoryName} (${repo.name})`
+        : repo.name;
+
+      const diff = await getRepoDiff(repoPath, displayName);
+      diffs.push(diff);
+
+      if (diff.error) {
+        console.log(colorize(diff.repo, 'cyan'));
+        console.log(`  ${colorize('⚠', 'yellow')} ${diff.error}\n`);
+        continue;
+      }
+
+      const hasChanges = diff.staged.files > 0 || diff.unstaged.files > 0;
+
+      if (hasChanges) {
+        reposWithChanges++;
+        totalStaged += diff.staged.files;
+        totalUnstaged += diff.unstaged.files;
+
+        console.log(colorize(diff.repo, 'cyan'));
+        if (diff.staged.files > 0) {
+          console.log(`  Staged:   ${diff.staged.files} file(s), ${colorize(`+${diff.staged.insertions}`, 'green')}, ${colorize(`-${diff.staged.deletions}`, 'red')}`);
+        }
+        if (diff.unstaged.files > 0) {
+          console.log(`  Unstaged: ${diff.unstaged.files} file(s), ${colorize(`+${diff.unstaged.insertions}`, 'green')}, ${colorize(`-${diff.unstaged.deletions}`, 'red')}`);
+        }
+        console.log('');
+
+        if (opts.full) {
+          try {
+            const { stdout: fullDiff } = await execAsync('git diff', { cwd: path.join(workspacePath, repo.directoryName) });
+            if (fullDiff.trim()) {
+              console.log(colorize('--- Full diff ---', 'gray'));
+              console.log(fullDiff);
+              console.log('');
+            }
+          } catch {
+            // Ignore errors getting full diff
+          }
+        }
+      } else {
+        console.log(colorize(diff.repo, 'cyan'));
+        console.log(`  ${colorize('✓', 'green')} Clean\n`);
+      }
+    }
+
+    console.log(colorize('═'.repeat(40), 'gray'));
+    console.log(`Total: ${colorize(String(totalStaged), 'green')} staged, ${colorize(String(totalUnstaged), 'yellow')} unstaged across ${reposWithChanges} repo(s)`);
+    console.log('');
+  } catch (error) {
+    logError('Failed to get workspace diff');
+    if (error instanceof Error) {
+      logError(error.message);
+    }
+    process.exit(1);
+  }
+}

package/src/commands/doctor.ts

@@ -0,0 +1,110 @@
+import { Command } from 'commander';
+import * as path from 'path';
+import { WORKSPACES_DIR } from '../utils/config';
+import { loadMetadata } from '../utils/workspace-meta';
+import { runAllHealthChecks, calculateHealthScore } from '../utils/health-checks';
+import { logError, logInfo, logStep, logSuccess, logWarning } from '../utils/logger';
+import { colorize } from '../utils/colors';
+import { HealthCheckResult } from '../types';
+import { resolveWorkspace } from '../utils/command-helpers';
+
+const displayHealthCheck = (result: HealthCheckResult) => {
+  let statusIcon = '';
+  let statusColor: 'green' | 'yellow' | 'red' = 'green';
+
+  switch (result.status) {
+    case 'healthy':
+      statusIcon = '✓';
+      statusColor = 'green';
+      break;
+    case 'warning':
+      statusIcon = '⚠';
+      statusColor = 'yellow';
+      break;
+    case 'error':
+      statusIcon = '✗';
+      statusColor = 'red';
+      break;
+  }
+
+  console.log(`\n${colorize(statusIcon, statusColor)} ${colorize(result.category, 'bright')}`);
+  console.log(`  ${result.message}`);
+  if (result.details) {
+    console.log(`  ${colorize('Details:', 'gray')} ${result.details}`);
+  }
+  if (result.actionable) {
+    console.log(`  ${colorize('→', 'cyan')} ${result.actionable}`);
+  }
+};
+
+const displayHealthScore = (score: number) => {
+  let scoreColor: 'green' | 'yellow' | 'red' = 'green';
+  let rating = 'Excellent';
+
+  if (score >= 80) { scoreColor = 'green'; rating = 'Excellent'; }
+  else if (score >= 60) { scoreColor = 'yellow'; rating = 'Good'; }
+  else if (score >= 40) { scoreColor = 'yellow'; rating = 'Fair'; }
+  else { scoreColor = 'red'; rating = 'Poor'; }
+
+  console.log('\n' + colorize('═'.repeat(60), 'gray'));
+  console.log(
+    `${colorize('Overall Health Score:', 'bright')} ${colorize(String(score), scoreColor)}/100 (${colorize(rating, scoreColor)})`
+  );
+  console.log(colorize('═'.repeat(60), 'gray') + '\n');
+};
+
+export function registerDoctorCommand(parent: Command) {
+  parent
+    .command('doctor')
+    .alias('doc')
+    .description('Run comprehensive health checks')
+    .argument('[workspace]', 'Workspace name')
+    .action(async (workspace) => {
+      await handleDoctor(workspace);
+    });
+}
+
+async function handleDoctor(workspaceArg?: string) {
+  try {
+    const selectedWorkspace = await resolveWorkspace(workspaceArg);
+    const workspacePath = path.join(WORKSPACES_DIR, selectedWorkspace);
+    const metadata = await loadMetadata(workspacePath);
+
+    if (!metadata) {
+      logError(`Workspace metadata not found for: ${selectedWorkspace}`);
+      process.exit(1);
+    }
+
+    logStep(`Running health checks for workspace: ${colorize(selectedWorkspace, 'cyan')}`);
+    logInfo('This may take a moment...');
+
+    const results = await runAllHealthChecks(workspacePath, metadata);
+    const score = calculateHealthScore(results);
+
+    console.log('\n' + colorize('Health Check Results', 'bright'));
+    console.log(colorize('═'.repeat(60), 'gray'));
+
+    for (const result of results) {
+      displayHealthCheck(result);
+    }
+
+    displayHealthScore(score);
+
+    const hasErrors = results.some(r => r.status === 'error');
+    const hasWarnings = results.some(r => r.status === 'warning');
+
+    if (hasErrors) {
+      logError('Critical issues detected. Please address error items above.');
+    } else if (hasWarnings) {
+      logWarning('Some warnings detected. Review and address when possible.');
+    } else {
+      logSuccess('All health checks passed! Your workspace is in good shape.');
+    }
+  } catch (error) {
+    logError('Failed to run health checks');
+    if (error instanceof Error) {
+      logError(error.message);
+    }
+    process.exit(1);
+  }
+}

package/src/commands/generate-docs.ts

@@ -0,0 +1,45 @@
+import { Command } from 'commander';
+import * as path from 'path';
+import { WORKSPACES_DIR } from '../utils/config';
+import { loadMetadata } from '../utils/workspace-meta';
+import { writeDocs } from '../utils/doc-generator';
+import { logError, logStep, logSuccess } from '../utils/logger';
+import { colorize } from '../utils/colors';
+import { resolveWorkspace } from '../utils/command-helpers';
+
+export function registerGenerateDocsCommand(parent: Command) {
+  parent
+    .command('generate-docs')
+    .alias('gd')
+    .description('Generate workspace documentation')
+    .argument('[workspace]', 'Workspace name')
+    .action(async (workspace) => {
+      await handleGenerateDocs(workspace);
+    });
+}
+
+async function handleGenerateDocs(workspaceArg?: string) {
+  try {
+    const workspaceName = await resolveWorkspace(workspaceArg);
+    const workspacePath = path.join(WORKSPACES_DIR, workspaceName);
+    const metadata = await loadMetadata(workspacePath);
+
+    if (!metadata) {
+      logError(`Workspace not found: ${workspaceName}`);
+      process.exit(1);
+    }
+
+    logStep(`Generating documentation for ${colorize(workspaceName, 'cyan')}...`);
+
+    await writeDocs(workspacePath, metadata);
+
+    logSuccess('Documentation generated:');
+    console.log(`  • WORKSPACE-README.md`);
+    console.log(`  • DEPENDENCY-GRAPH.md`);
+    console.log(`  • REPOSITORY-INDEX.md`);
+  } catch (error) {
+    logError('Failed to generate documentation');
+    if (error instanceof Error) { logError(error.message); }
+    process.exit(1);
+  }
+}

package/src/commands/ghq-status.ts

@@ -0,0 +1,70 @@
+import { Command } from 'commander';
+import { getGhqStatus, displayGhqInfo, ghqList } from '../utils/ghq-integration';
+import { logSuccess, logWarning, logError } from '../utils/logger';
+import { colorize } from '../utils/colors';
+import inquirer from 'inquirer';
+
+export function registerGhqStatusCommand(parent: Command) {
+  parent
+    .command('ghq-status')
+    .description('Check ghq integration status')
+    .action(async () => {
+      await handleGhqStatus();
+    });
+}
+
+async function handleGhqStatus() {
+  console.log('\n' + '='.repeat(60));
+  console.log(colorize('ghq Integration Status', 'bright'));
+  console.log('='.repeat(60) + '\n');
+
+  try {
+    const status = await getGhqStatus();
+
+    if (status.installed) {
+      logSuccess('ghq is installed and active');
+      console.log('');
+      console.log(colorize('Configuration:', 'cyan'));
+      console.log(`  Root directory: ${colorize(status.root || 'unknown', 'gray')}`);
+      console.log(`  Managed repositories: ${colorize(String(status.repoCount || 0), 'yellow')}`);
+      console.log('');
+
+      if (status.repoCount && status.repoCount > 0) {
+        const { showRepos } = await inquirer.prompt([{
+          type: 'confirm', name: 'showRepos',
+          message: `View all ${status.repoCount} managed repositories?`, default: false,
+        }]);
+
+        if (showRepos) {
+          const repos = await ghqList();
+          console.log('');
+          console.log(colorize('Managed Repositories:', 'cyan'));
+          repos.forEach((repo, index) => { console.log(`  ${index + 1}. ${repo}`); });
+          console.log('');
+        }
+      }
+    } else {
+      logWarning('ghq is not installed');
+      console.log('');
+      console.log('The workspace manager will use direct git clones.');
+
+      const { showInfo } = await inquirer.prompt([{
+        type: 'confirm', name: 'showInfo',
+        message: 'Show ghq installation information?', default: true,
+      }]);
+
+      if (showInfo) { displayGhqInfo(); }
+    }
+
+    console.log(colorize('Workspace Manager Behavior:', 'cyan'));
+    console.log('  • Auto-detects ghq installation');
+    console.log('  • Uses ghq when available');
+    console.log('  • Falls back to git clone if needed');
+    console.log('  • Always maintains workspace isolation');
+    console.log('');
+  } catch (error) {
+    logError('Failed to check ghq status');
+    if (error instanceof Error) { logError(error.message); }
+    process.exit(1);
+  }
+}

package/src/commands/go.ts

@@ -0,0 +1,125 @@
+import { Command } from 'commander';
+import * as path from 'path';
+import { WORKSPACES_DIR } from '../utils/config';
+import * as fs from 'fs/promises';
+import * as os from 'os';
+import { listWorkspaces } from '../utils/workspace-meta';
+import { getWorkspaceSessions } from '../utils/claude-sessions';
+import { logError } from '../utils/logger';
+import { colorize } from '../utils/colors';
+import inquirer from 'inquirer';
+import autocompletePrompt from 'inquirer-autocomplete-prompt';
+import * as fuzzy from 'fuzzy';
+
+inquirer.registerPrompt('autocomplete', autocompletePrompt);
+
+const TEMP_FILE = path.join(os.homedir(), '.workspace-last-go');
+const RESUME_FLAG_FILE = path.join(os.homedir(), '.workspace-resume-session');
+
+export function registerGoCommand(parent: Command) {
+  parent
+    .command('go')
+    .description('Quick navigate to workspace')
+    .argument('[workspace]', 'Workspace name')
+    .action(async (workspace) => {
+      await handleGo(workspace);
+    });
+}
+
+async function handleGo(workspaceArg?: string) {
+  try {
+    let selectedWorkspace: string;
+
+    if (workspaceArg) {
+      selectedWorkspace = workspaceArg;
+    } else {
+      const [workspaces, sessions] = await Promise.all([
+        listWorkspaces(),
+        getWorkspaceSessions(),
+      ]);
+
+      if (workspaces.length === 0) {
+        logError('No workspaces found');
+        process.exit(1);
+        return;
+      }
+
+      // Build session map, keeping most-recent session per workspace
+      // (sessions are sorted most-recent-first, so first entry wins)
+      const sessionMap = new Map<string, typeof sessions[0]>();
+      for (const session of sessions) {
+        if (!sessionMap.has(session.workspaceName)) {
+          sessionMap.set(session.workspaceName, session);
+        }
+      }
+
+      const items = workspaces.map(ws => ({
+        name: ws.name,
+        repoCount: ws.metadata?.repositories?.length ?? 0,
+        lastActiveLabel: sessionMap.get(ws.name)?.lastActiveLabel ?? null,
+        lastActiveAt: sessionMap.get(ws.name)?.lastActiveAt.getTime() ?? 0,
+        hasSession: sessionMap.has(ws.name),
+      }));
+
+      items.sort((a, b) => {
+        if (a.hasSession && b.hasSession) return b.lastActiveAt - a.lastActiveAt;
+        if (a.hasSession) return -1;
+        if (b.hasSession) return 1;
+        return 0;
+      });
+
+      const { workspaceName } = await inquirer.prompt([
+        {
+          type: 'autocomplete',
+          name: 'workspaceName',
+          message: 'Select workspace to navigate to:',
+          source: async (_answersSoFar: any, input: string | undefined) => {
+            const searchInput = input || '';
+            const source = items.map(item => ({
+              name: `${item.name}  ${item.lastActiveLabel ? colorize(item.lastActiveLabel, 'dim') : colorize('no session', 'dim')}  ${colorize(`${item.repoCount} repos`, 'dim')}`,
+              value: item.name,
+            }));
+            if (!searchInput) return source;
+            const results = fuzzy.filter(searchInput, items, { extract: (item) => item.name });
+            return results.map(result => ({
+              name: `${result.original.name}  ${result.original.lastActiveLabel ? colorize(result.original.lastActiveLabel, 'dim') : colorize('no session', 'dim')}  ${colorize(`${result.original.repoCount} repos`, 'dim')}`,
+              value: result.original.name,
+            }));
+          },
+          pageSize: 15,
+        } as any,
+      ]);
+
+      selectedWorkspace = workspaceName;
+    }
+
+    const workspacePath = path.join(WORKSPACES_DIR, selectedWorkspace);
+
+    try {
+      await fs.access(workspacePath);
+    } catch {
+      logError(`Workspace not found: ${selectedWorkspace}`);
+      process.exit(1);
+    }
+
+    await fs.writeFile(TEMP_FILE, workspacePath, 'utf-8');
+
+    const sessions = await getWorkspaceSessions();
+    const session = sessions.find(s => s.workspaceName === selectedWorkspace);
+    if (session) {
+      // Write JSON with session ID and agent type for correct resume
+      await fs.writeFile(RESUME_FLAG_FILE, JSON.stringify({
+        sessionId: session.sessionId,
+        agentType: session.agentType,
+      }), 'utf-8');
+    }
+
+    console.log(workspacePath);
+  } catch (error) {
+    logError('Failed to navigate to workspace');
+    if (error instanceof Error) {
+      logError(error.message);
+    }
+    process.exit(1);
+  }
+}

package/src/commands/history.ts

@@ -0,0 +1,136 @@
+import { Command } from 'commander';
+import { readHistory, getOperationStats, filterHistory, clearHistory } from '../utils/history';
+import { logError, logInfo, logStep, logSuccess } from '../utils/logger';
+import { colorize } from '../utils/colors';
+import inquirer from 'inquirer';
+import { getGlobalOpts } from '../utils/command-helpers';
+
+const displayHistoryTable = (records: Array<{ timestamp: string; command: string; workspace?: string; duration: number; success: boolean; error?: string }>) => {
+  if (records.length === 0) {
+    logInfo('No operation history found');
+    return;
+  }
+
+  console.log('\n' + colorize('═'.repeat(120), 'gray'));
+  console.log(
+    colorize('Time', 'bright').padEnd(25) +
+    colorize('Command', 'bright').padEnd(25) +
+    colorize('Workspace', 'bright').padEnd(25) +
+    colorize('Duration', 'bright').padEnd(15) +
+    colorize('Status', 'bright')
+  );
+  console.log(colorize('─'.repeat(120), 'gray'));
+
+  for (const record of records) {
+    const time = new Date(record.timestamp).toLocaleString().padEnd(15);
+    const command = record.command.padEnd(15);
+    const workspace = (record.workspace || '-').padEnd(15);
+    const duration = `${(record.duration / 1000).toFixed(1)}s`.padEnd(10);
+    const status = record.success
+      ? colorize('✓ Success', 'green')
+      : colorize('✗ Failed', 'red') + (record.error ? ` (${record.error})` : '');
+
+    console.log(`${time} ${command} ${workspace} ${duration} ${status}`);
+  }
+
+  console.log(colorize('═'.repeat(120), 'gray') + '\n');
+};
+
+const displayStats = (stats: { totalOperations: number; successRate: number; avgDuration: number; commandCounts: Record<string, number> }) => {
+  console.log(colorize('Operation Statistics', 'bright'));
+  console.log(colorize('─'.repeat(60), 'gray'));
+  console.log(`Total Operations: ${colorize(String(stats.totalOperations), 'cyan')}`);
+  console.log(`Success Rate: ${colorize(`${stats.successRate.toFixed(1)}%`, 'green')}`);
+  console.log(`Average Duration: ${colorize(`${(stats.avgDuration / 1000).toFixed(1)}s`, 'yellow')}`);
+
+  console.log(`\n${colorize('Command Usage', 'bright')}`);
+  const sortedCommands = Object.entries(stats.commandCounts).sort((a, b) => b[1] - a[1]);
+
+  for (const [command, count] of sortedCommands) {
+    console.log(`  ${command.padEnd(20)} ${colorize(String(count), 'cyan')} times`);
+  }
+  console.log('');
+};
+
+export function registerHistoryCommand(parent: Command) {
+  const history = parent
+    .command('history')
+    .alias('h')
+    .description('View operation history');
+
+  history
+    .command('show', { isDefault: true })
+    .description('Show recent operations')
+    .argument('[limit]', 'Number of records to show', '20')
+    .option('--command <cmd>', 'Filter by command')
+    .option('--workspace <name>', 'Filter by workspace')
+    .action(async (limit, opts) => {
+      await handleHistoryShow(parseInt(limit) || 20, opts);
+    });
+
+  history
+    .command('stats')
+    .description('Show detailed statistics')
+    .action(async () => {
+      logStep('Calculating statistics...');
+      const stats = await getOperationStats();
+      displayStats(stats);
+    });
+
+  history
+    .command('clear')
+    .description('Clear all history')
+    .action(async (opts, cmd) => {
+      const globalOpts = getGlobalOpts(cmd);
+      if (globalOpts.yes) {
+        await clearHistory();
+        logSuccess('Operation history cleared');
+        return;
+      }
+
+      const { confirm } = await inquirer.prompt([
+        {
+          type: 'confirm',
+          name: 'confirm',
+          message: 'Are you sure you want to clear operation history?',
+          default: false,
+        },
+      ]);
+
+      if (confirm) {
+        await clearHistory();
+        logSuccess('Operation history cleared');
+      } else {
+        logInfo('Operation cancelled');
+      }
+    });
+}
+
+async function handleHistoryShow(limit: number, opts: { command?: string; workspace?: string }) {
+  try {
+    logStep(`Fetching operation history (last ${limit} records)...`);
+
+    let records;
+    if (opts.command || opts.workspace) {
+      records = await filterHistory(opts.command, opts.workspace);
+      records = records.slice(0, limit);
+    } else {
+      records = await readHistory(limit);
+    }
+
+    displayHistoryTable(records);
+
+    const stats = await getOperationStats();
+    console.log(colorize('Quick Stats:', 'bright'));
+    console.log(`  Total Operations: ${stats.totalOperations}`);
+    console.log(`  Success Rate: ${stats.successRate.toFixed(1)}%`);
+    console.log(`  Average Duration: ${(stats.avgDuration / 1000).toFixed(1)}s`);
+    console.log('');
+  } catch (error) {
+    logError('Failed to retrieve history');
+    if (error instanceof Error) {
+      logError(error.message);
+    }
+    process.exit(1);
+  }
+}