docrev 0.2.1 → 0.5.0

package/bin/rev.js

@@ -1048,6 +1048,148 @@ program
     }
   });
 
+// ============================================================================
+// MERGE command - Combine feedback from multiple reviewers
+// ============================================================================
+
+program
+  .command('merge')
+  .description('Merge feedback from multiple Word documents')
+  .argument('<original>', 'Original markdown file')
+  .argument('<docx...>', 'Word documents from reviewers')
+  .option('-o, --output <file>', 'Output file (default: original-merged.md)')
+  .option('--names <names>', 'Reviewer names (comma-separated, in order of docx files)')
+  .option('--auto', 'Auto-resolve conflicts by taking first change')
+  .option('--dry-run', 'Show conflicts without writing')
+  .action(async (original, docxFiles, options) => {
+    const { mergeReviewerDocs, formatConflict, applyChangesAsAnnotations, resolveConflict } = await import('../lib/merge.js');
+
+    if (!fs.existsSync(original)) {
+      console.error(fmt.status('error', `Original file not found: ${original}`));
+      process.exit(1);
+    }
+
+    // Validate all docx files exist
+    for (const docx of docxFiles) {
+      if (!fs.existsSync(docx)) {
+        console.error(fmt.status('error', `Reviewer file not found: ${docx}`));
+        process.exit(1);
+      }
+    }
+
+    // Parse reviewer names
+    const names = options.names
+      ? options.names.split(',').map(n => n.trim())
+      : docxFiles.map((f, i) => `Reviewer ${i + 1}`);
+
+    if (names.length < docxFiles.length) {
+      // Pad with default names
+      for (let i = names.length; i < docxFiles.length; i++) {
+        names.push(`Reviewer ${i + 1}`);
+      }
+    }
+
+    const reviewerDocs = docxFiles.map((p, i) => ({
+      path: p,
+      name: names[i],
+    }));
+
+    console.log(fmt.header('Multi-Reviewer Merge'));
+    console.log();
+    console.log(chalk.dim(`  Original: ${original}`));
+    console.log(chalk.dim(`  Reviewers: ${names.join(', ')}`));
+    console.log();
+
+    const spin = fmt.spinner('Analyzing changes...').start();
+
+    try {
+      const { merged, conflicts, stats, originalText } = await mergeReviewerDocs(original, reviewerDocs, {
+        autoResolve: options.auto,
+      });
+
+      spin.stop();
+
+      // Show stats
+      console.log(fmt.table(['Metric', 'Count'], [
+        ['Total changes', stats.totalChanges.toString()],
+        ['Non-conflicting', stats.nonConflicting.toString()],
+        ['Conflicts', stats.conflicts.toString()],
+        ['Comments', stats.comments.toString()],
+      ]));
+      console.log();
+
+      // Handle conflicts
+      if (conflicts.length > 0) {
+        console.log(chalk.yellow(`Found ${conflicts.length} conflict(s):\n`));
+
+        let resolvedMerged = merged;
+
+        for (let i = 0; i < conflicts.length; i++) {
+          const conflict = conflicts[i];
+          console.log(chalk.bold(`Conflict ${i + 1}/${conflicts.length}:`));
+          console.log(formatConflict(conflict, originalText));
+          console.log();
+
+          if (options.auto) {
+            // Auto-resolve: take first reviewer's change
+            console.log(chalk.dim(`  Auto-resolved: using ${conflict.changes[0].reviewer}'s change`));
+            resolvedMerged = resolveConflict(resolvedMerged, conflict, 0, originalText);
+          } else if (!options.dryRun) {
+            // Interactive resolution
+            const rl = await import('readline');
+            const readline = rl.createInterface({
+              input: process.stdin,
+              output: process.stdout,
+            });
+
+            const answer = await new Promise((resolve) =>
+              readline.question(chalk.cyan(`  Choose (1-${conflict.changes.length}, s=skip): `), resolve)
+            );
+            readline.close();
+
+            if (answer.toLowerCase() !== 's' && !isNaN(parseInt(answer))) {
+              const choice = parseInt(answer) - 1;
+              if (choice >= 0 && choice < conflict.changes.length) {
+                resolvedMerged = resolveConflict(resolvedMerged, conflict, choice, originalText);
+                console.log(chalk.green(`  Applied: ${conflict.changes[choice].reviewer}'s change`));
+              }
+            } else {
+              console.log(chalk.dim('  Skipped'));
+            }
+            console.log();
+          }
+        }
+
+        if (!options.dryRun) {
+          const outPath = options.output || original.replace(/\.md$/, '-merged.md');
+          fs.writeFileSync(outPath, resolvedMerged, 'utf-8');
+          console.log(fmt.status('success', `Merged output written to ${outPath}`));
+        }
+      } else {
+        // No conflicts
+        if (!options.dryRun) {
+          const outPath = options.output || original.replace(/\.md$/, '-merged.md');
+          fs.writeFileSync(outPath, merged, 'utf-8');
+          console.log(fmt.status('success', `Merged output written to ${outPath}`));
+        } else {
+          console.log(fmt.status('info', 'Dry run - no output written'));
+        }
+      }
+
+      if (!options.dryRun && stats.nonConflicting > 0) {
+        console.log();
+        console.log(chalk.dim('Next steps:'));
+        console.log(chalk.dim('  1. rev review <merged.md>  - Review all changes'));
+        console.log(chalk.dim('  2. rev comments <merged.md> - Address comments'));
+      }
+    } catch (err) {
+      spin.stop();
+      console.error(fmt.status('error', err.message));
+      if (process.env.DEBUG) console.error(err.stack);
+      process.exit(1);
+    }
+  });
+
 // ============================================================================
 // REFS command - Show figure/table reference status
 // ============================================================================
@@ -1381,6 +1523,7 @@ program
   .option('-d, --dir <directory>', 'Project directory', '.')
   .option('--no-crossref', 'Skip pandoc-crossref filter')
   .option('--toc', 'Include table of contents')
+  .option('--show-changes', 'Export DOCX with visible track changes (audit mode)')
   .action(async (formats, options) => {
     const dir = path.resolve(options.dir);
 
@@ -1414,6 +1557,7 @@ program
     console.log(chalk.dim(`  Formats: ${targetFormats.join(', ')}`));
     console.log(chalk.dim(`  Crossref: ${hasPandocCrossref() && options.crossref !== false ? 'enabled' : 'disabled'}`));
     if (tocEnabled) console.log(chalk.dim(`  TOC: enabled`));
+    if (options.showChanges) console.log(chalk.dim(`  Track changes: visible`));
     console.log('');
 
     // Override config with CLI options
@@ -1422,6 +1566,57 @@ program
       config.docx.toc = true;
     }
 
+    // Handle --show-changes mode (audit export)
+    if (options.showChanges) {
+      if (!targetFormats.includes('docx') && !targetFormats.includes('all')) {
+        console.error(fmt.status('error', '--show-changes only applies to DOCX output'));
+        process.exit(1);
+      }
+
+      const { combineSections } = await import('../lib/build.js');
+      const { buildWithTrackChanges } = await import('../lib/trackchanges.js');
+
+      const spin = fmt.spinner('Building with track changes...').start();
+
+      try {
+        // Combine sections first
+        const paperPath = combineSections(dir, config);
+        spin.stop();
+        console.log(chalk.cyan('Combined sections → paper.md'));
+        console.log(chalk.dim(`  ${paperPath}\n`));
+
+        // Build DOCX with track changes
+        const baseName = config.title
+          ? config.title.toLowerCase().replace(/[^a-z0-9]+/g, '-').slice(0, 50)
+          : 'paper';
+        const outputPath = path.join(dir, `${baseName}-changes.docx`);
+
+        const spinTc = fmt.spinner('Applying track changes...').start();
+        const result = await buildWithTrackChanges(paperPath, outputPath, {
+          author: getUserName() || 'Author',
+        });
+        spinTc.stop();
+
+        if (result.success) {
+          console.log(chalk.cyan('Output (with track changes):'));
+          console.log(`  DOCX: ${path.basename(outputPath)}`);
+          if (result.stats) {
+            console.log(chalk.dim(`    ${result.stats.insertions} insertions, ${result.stats.deletions} deletions, ${result.stats.substitutions} substitutions`));
+          }
+          console.log(chalk.green('\nBuild complete!'));
+        } else {
+          console.error(fmt.status('error', result.message));
+          process.exit(1);
+        }
+      } catch (err) {
+        spin.stop();
+        console.error(fmt.status('error', err.message));
+        if (process.env.DEBUG) console.error(err.stack);
+        process.exit(1);
+      }
+      return;
+    }
+
     const spin = fmt.spinner('Building...').start();
 
     try {
@@ -1726,6 +1921,103 @@ program
     console.log(fmt.status('success', `Created ${outputPath}`));
   });
 
+// ============================================================================
+// VALIDATE command - Check manuscript against journal requirements
+// ============================================================================
+
+program
+  .command('validate')
+  .description('Validate manuscript against journal requirements')
+  .argument('[files...]', 'Markdown files to validate (default: all section files)')
+  .option('-j, --journal <name>', 'Journal profile (e.g., nature, plos-one, science)')
+  .option('--list', 'List available journal profiles')
+  .action(async (files, options) => {
+    const { listJournals, validateProject, getJournalProfile } = await import('../lib/journals.js');
+
+    if (options.list) {
+      console.log(fmt.header('Available Journal Profiles'));
+      console.log();
+      const journals = listJournals();
+      for (const j of journals) {
+        console.log(`  ${chalk.bold(j.id)} - ${j.name}`);
+        console.log(chalk.dim(`    ${j.url}`));
+      }
+      console.log();
+      console.log(chalk.dim('Usage: rev validate --journal <name>'));
+      return;
+    }
+
+    if (!options.journal) {
+      console.error(fmt.status('error', 'Please specify a journal with --journal <name>'));
+      console.error(chalk.dim('Use --list to see available profiles'));
+      process.exit(1);
+    }
+
+    const profile = getJournalProfile(options.journal);
+    if (!profile) {
+      console.error(fmt.status('error', `Unknown journal: ${options.journal}`));
+      console.error(chalk.dim('Use --list to see available profiles'));
+      process.exit(1);
+    }
+
+    // Find files to validate
+    let mdFiles = files;
+    if (!mdFiles || mdFiles.length === 0) {
+      mdFiles = fs.readdirSync('.').filter(f =>
+        f.endsWith('.md') && !['README.md', 'CLAUDE.md', 'paper.md'].includes(f)
+      );
+    }
+
+    if (mdFiles.length === 0) {
+      console.error(fmt.status('error', 'No markdown files found'));
+      process.exit(1);
+    }
+
+    console.log(fmt.header(`Validating for ${profile.name}`));
+    console.log(chalk.dim(`  ${profile.url}`));
+    console.log();
+
+    const result = validateProject(mdFiles, options.journal);
+
+    // Show stats
+    console.log(chalk.cyan('Manuscript Stats:'));
+    console.log(fmt.table(['Metric', 'Value'], [
+      ['Word count', result.stats.wordCount.toString()],
+      ['Abstract', `${result.stats.abstractWords} words`],
+      ['Title', `${result.stats.titleChars} chars`],
+      ['Figures', result.stats.figures.toString()],
+      ['Tables', result.stats.tables.toString()],
+      ['References', result.stats.references.toString()],
+    ]));
+    console.log();
+
+    // Show errors
+    if (result.errors.length > 0) {
+      console.log(chalk.red('Errors:'));
+      for (const err of result.errors) {
+        console.log(chalk.red(`  ✗ ${err}`));
+      }
+      console.log();
+    }
+
+    // Show warnings
+    if (result.warnings.length > 0) {
+      console.log(chalk.yellow('Warnings:'));
+      for (const warn of result.warnings) {
+        console.log(chalk.yellow(`  ⚠ ${warn}`));
+      }
+      console.log();
+    }
+
+    // Summary
+    if (result.valid) {
+      console.log(fmt.status('success', `Manuscript meets ${profile.name} requirements`));
+    } else {
+      console.log(fmt.status('error', `Manuscript has ${result.errors.length} error(s)`));
+      process.exit(1);
+    }
+  });
+
 // ============================================================================
 // ANONYMIZE command - Prepare document for blind review
 // ============================================================================
@@ -2497,6 +2789,188 @@ program
     }
   });
 
+// ============================================================================
+// DIFF command - Compare sections against git history
+// ============================================================================
+
+program
+  .command('diff')
+  .description('Compare sections against git history')
+  .argument('[ref]', 'Git reference to compare against (default: main/master)')
+  .option('-f, --files <files>', 'Specific files to compare (comma-separated)')
+  .option('--stat', 'Show only statistics, not full diff')
+  .action(async (ref, options) => {
+    const {
+      isGitRepo,
+      getDefaultBranch,
+      getCurrentBranch,
+      getChangedFiles,
+      getWordCountDiff,
+      compareFileVersions,
+    } = await import('../lib/git.js');
+
+    if (!isGitRepo()) {
+      console.error(fmt.status('error', 'Not a git repository'));
+      process.exit(1);
+    }
+
+    const compareRef = ref || getDefaultBranch();
+    const currentBranch = getCurrentBranch();
+
+    console.log(fmt.header('Git Diff'));
+    console.log(chalk.dim(`  Comparing: ${compareRef} → ${currentBranch || 'HEAD'}`));
+    console.log();
+
+    // Get files to compare
+    let filesToCompare;
+    if (options.files) {
+      filesToCompare = options.files.split(',').map(f => f.trim());
+    } else {
+      // Default to markdown section files
+      filesToCompare = fs.readdirSync('.').filter(f =>
+        f.endsWith('.md') && !['README.md', 'CLAUDE.md'].includes(f)
+      );
+    }
+
+    if (filesToCompare.length === 0) {
+      console.log(fmt.status('info', 'No markdown files found'));
+      return;
+    }
+
+    // Get changed files from git
+    const changedFiles = getChangedFiles(compareRef);
+    const changedSet = new Set(changedFiles.map(f => f.file));
+
+    // Get word count differences
+    const { total, byFile } = getWordCountDiff(filesToCompare, compareRef);
+
+    // Show results
+    const rows = [];
+    for (const file of filesToCompare) {
+      const stats = byFile[file];
+      if (stats && (stats.added > 0 || stats.removed > 0)) {
+        const status = changedSet.has(file)
+          ? changedFiles.find(f => f.file === file)?.status || 'modified'
+          : 'unchanged';
+        rows.push([
+          file,
+          status,
+          chalk.green(`+${stats.added}`),
+          chalk.red(`-${stats.removed}`),
+        ]);
+      }
+    }
+
+    if (rows.length === 0) {
+      console.log(fmt.status('success', 'No changes detected'));
+      return;
+    }
+
+    console.log(fmt.table(['File', 'Status', 'Added', 'Removed'], rows));
+    console.log();
+    console.log(chalk.dim(`Total: ${chalk.green(`+${total.added}`)} words, ${chalk.red(`-${total.removed}`)} words`));
+
+    // Show detailed diff if not --stat
+    if (!options.stat && rows.length > 0) {
+      console.log();
+      console.log(chalk.cyan('Changed sections:'));
+      for (const file of filesToCompare) {
+        const stats = byFile[file];
+        if (stats && (stats.added > 0 || stats.removed > 0)) {
+          const { changes } = compareFileVersions(file, compareRef);
+          console.log(chalk.bold(`\n  ${file}:`));
+
+          // Show first few significant changes
+          let shown = 0;
+          for (const change of changes) {
+            if (shown >= 3) {
+              console.log(chalk.dim('    ...'));
+              break;
+            }
+            const preview = change.text.slice(0, 60).replace(/\n/g, ' ');
+            if (change.type === 'add') {
+              console.log(chalk.green(`    + "${preview}..."`));
+            } else {
+              console.log(chalk.red(`    - "${preview}..."`));
+            }
+            shown++;
+          }
+        }
+      }
+    }
+  });
+
+// ============================================================================
+// HISTORY command - Show revision history
+// ============================================================================
+
+program
+  .command('history')
+  .description('Show revision history for section files')
+  .argument('[file]', 'Specific file (default: all sections)')
+  .option('-n, --limit <count>', 'Number of commits to show', '10')
+  .action(async (file, options) => {
+    const {
+      isGitRepo,
+      getFileHistory,
+      getRecentCommits,
+      hasUncommittedChanges,
+    } = await import('../lib/git.js');
+
+    if (!isGitRepo()) {
+      console.error(fmt.status('error', 'Not a git repository'));
+      process.exit(1);
+    }
+
+    const limit = parseInt(options.limit) || 10;
+
+    console.log(fmt.header('Revision History'));
+    console.log();
+
+    if (file) {
+      // Show history for specific file
+      if (!fs.existsSync(file)) {
+        console.error(fmt.status('error', `File not found: ${file}`));
+        process.exit(1);
+      }
+
+      const history = getFileHistory(file, limit);
+
+      if (history.length === 0) {
+        console.log(fmt.status('info', 'No history found (file may not be committed)'));
+        return;
+      }
+
+      console.log(chalk.cyan(`History for ${file}:`));
+      console.log();
+
+      for (const commit of history) {
+        const date = new Date(commit.date).toLocaleDateString();
+        console.log(`  ${chalk.yellow(commit.hash)} ${chalk.dim(date)}`);
+        console.log(`    ${commit.message}`);
+      }
+    } else {
+      // Show recent commits affecting any file
+      const commits = getRecentCommits(limit);
+
+      if (commits.length === 0) {
+        console.log(fmt.status('info', 'No commits found'));
+        return;
+      }
+
+      if (hasUncommittedChanges()) {
+        console.log(chalk.yellow('  * Uncommitted changes'));
+        console.log();
+      }
+
+      for (const commit of commits) {
+        const date = new Date(commit.date).toLocaleDateString();
+        console.log(`  ${chalk.yellow(commit.hash)} ${chalk.dim(date)} ${chalk.blue(commit.author)}`);
+        console.log(`    ${commit.message}`);
+      }
+    }
+  });
+
 // ============================================================================
 // HELP command - Comprehensive help
 // ============================================================================
@@ -2859,4 +3333,1656 @@ ${chalk.bold('rev help')} [topic]
 `);
 }
 
+// ============================================================================
+// COMPLETIONS command - Shell completions
+// ============================================================================
+
+program
+  .command('completions')
+  .description('Output shell completions')
+  .argument('<shell>', 'Shell type: bash, zsh')
+  .action((shell) => {
+    const completionsDir = path.join(import.meta.dirname, '..', 'completions');
+
+    if (shell === 'bash') {
+      const bashFile = path.join(completionsDir, 'rev.bash');
+      if (fs.existsSync(bashFile)) {
+        console.log(fs.readFileSync(bashFile, 'utf-8'));
+      } else {
+        console.error(chalk.red('Bash completions not found'));
+        process.exit(1);
+      }
+    } else if (shell === 'zsh') {
+      const zshFile = path.join(completionsDir, 'rev.zsh');
+      if (fs.existsSync(zshFile)) {
+        console.log(fs.readFileSync(zshFile, 'utf-8'));
+      } else {
+        console.error(chalk.red('Zsh completions not found'));
+        process.exit(1);
+      }
+    } else {
+      console.error(chalk.red(`Unknown shell: ${shell}`));
+      console.log(chalk.dim('Supported shells: bash, zsh'));
+      process.exit(1);
+    }
+  });
+
+// ============================================================================
+// WORD-COUNT command - Per-section word counts
+// ============================================================================
+
+program
+  .command('word-count')
+  .alias('wc')
+  .description('Show word counts per section')
+  .option('-l, --limit <number>', 'Warn if total exceeds limit', parseInt)
+  .option('-j, --journal <name>', 'Use journal word limit')
+  .action(async (options) => {
+    let config = {};
+    try {
+      config = loadBuildConfig() || {};
+    } catch {
+      // Not in a rev project, that's ok
+    }
+    const sections = config.sections || [];
+
+    if (sections.length === 0) {
+      // Try to find .md files
+      const mdFiles = fs.readdirSync('.').filter(f =>
+        f.endsWith('.md') && !['README.md', 'CLAUDE.md', 'paper.md'].includes(f)
+      );
+      if (mdFiles.length === 0) {
+        console.error(chalk.red('No section files found. Run from a rev project directory.'));
+        process.exit(1);
+      }
+      sections.push(...mdFiles);
+    }
+
+    const countWords = (text) => {
+      return text
+        .replace(/^---[\s\S]*?---/m, '')
+        .replace(/!\[.*?\]\(.*?\)/g, '')
+        .replace(/\[([^\]]+)\]\([^)]+\)/g, '$1')
+        .replace(/#+\s*/g, '')
+        .replace(/\*\*|__|[*_`]/g, '')
+        .replace(/```[\s\S]*?```/g, '')
+        .replace(/\{[^}]+\}/g, '')
+        .replace(/@\w+:\w+/g, '')
+        .replace(/@\w+/g, '')
+        .replace(/\|[^|]+\|/g, ' ')
+        .replace(/\n+/g, ' ')
+        .trim()
+        .split(/\s+/)
+        .filter(w => w.length > 0).length;
+    };
+
+    let total = 0;
+    const rows = [];
+
+    for (const section of sections) {
+      if (!fs.existsSync(section)) continue;
+      const text = fs.readFileSync(section, 'utf-8');
+      const words = countWords(text);
+      total += words;
+      rows.push([section, words.toLocaleString()]);
+    }
+
+    rows.push(['', '']);
+    rows.push([chalk.bold('Total'), chalk.bold(total.toLocaleString())]);
+
+    console.log(fmt.header('Word Count'));
+    console.log(fmt.table(['Section', 'Words'], rows));
+
+    // Check limit
+    let limit = options.limit;
+    if (options.journal) {
+      const { getJournalProfile } = await import('../lib/journals.js');
+      const profile = getJournalProfile(options.journal);
+      if (profile?.requirements?.wordLimit?.main) {
+        limit = profile.requirements.wordLimit.main;
+        console.log(chalk.dim(`\nUsing ${profile.name} word limit: ${limit.toLocaleString()}`));
+      }
+    }
+
+    if (limit && total > limit) {
+      console.log(chalk.red(`\n⚠ Over limit by ${(total - limit).toLocaleString()} words`));
+    } else if (limit) {
+      console.log(chalk.green(`\n✓ Within limit (${(limit - total).toLocaleString()} words remaining)`));
+    }
+  });
+
+// ============================================================================
+// STATS command - Project dashboard
+// ============================================================================
+
+program
+  .command('stats')
+  .description('Show project statistics dashboard')
+  .action(async () => {
+    let config = {};
+    try {
+      config = loadBuildConfig() || {};
+    } catch {
+      // Not in a rev project, that's ok
+    }
+    let sections = config.sections || [];
+
+    if (sections.length === 0) {
+      sections = fs.readdirSync('.').filter(f =>
+        f.endsWith('.md') && !['README.md', 'CLAUDE.md', 'paper.md'].includes(f)
+      );
+    }
+
+    const countWords = (text) => {
+      return text
+        .replace(/^---[\s\S]*?---/m, '')
+        .replace(/!\[.*?\]\(.*?\)/g, '')
+        .replace(/\[([^\]]+)\]\([^)]+\)/g, '$1')
+        .replace(/[#*_`]/g, '')
+        .replace(/\{[^}]+\}/g, '')
+        .replace(/@\w+/g, '')
+        .replace(/\n+/g, ' ')
+        .trim()
+        .split(/\s+/)
+        .filter(w => w.length > 0).length;
+    };
+
+    let totalWords = 0;
+    let totalFigures = 0;
+    let totalTables = 0;
+    let totalComments = 0;
+    let pendingComments = 0;
+    const citations = new Set();
+
+    for (const section of sections) {
+      if (!fs.existsSync(section)) continue;
+      const text = fs.readFileSync(section, 'utf-8');
+
+      totalWords += countWords(text);
+      totalFigures += (text.match(/!\[.*?\]\(.*?\)/g) || []).length;
+      totalTables += (text.match(/^\|[^|]+\|/gm) || []).length / 5; // Approximate
+
+      const comments = getComments(text);
+      totalComments += comments.length;
+      pendingComments += comments.filter(c => !c.resolved).length;
+
+      const cites = text.match(/@(\w+)(?![:\w])/g) || [];
+      cites.forEach(c => citations.add(c.slice(1)));
+    }
+
+    console.log(fmt.header('Project Statistics'));
+    console.log();
+
+    const stats = [
+      ['Sections', sections.length],
+      ['Words', totalWords.toLocaleString()],
+      ['Figures', Math.round(totalFigures)],
+      ['Tables', Math.round(totalTables)],
+      ['Citations', citations.size],
+      ['Comments', `${totalComments} (${pendingComments} pending)`],
+    ];
+
+    for (const [label, value] of stats) {
+      console.log(`  ${chalk.dim(label.padEnd(12))} ${chalk.bold(value)}`);
+    }
+
+    // Bibliography stats
+    const bibPath = config.bibliography || 'references.bib';
+    if (fs.existsSync(bibPath)) {
+      const bibContent = fs.readFileSync(bibPath, 'utf-8');
+      const bibEntries = (bibContent.match(/@\w+\s*\{/g) || []).length;
+      console.log(`  ${chalk.dim('Bib entries'.padEnd(12))} ${chalk.bold(bibEntries)}`);
+    }
+
+    console.log();
+  });
+
+// ============================================================================
+// SEARCH command - Search across section files
+// ============================================================================
+
+program
+  .command('search')
+  .description('Search across all section files')
+  .argument('<query>', 'Search query (supports regex)')
+  .option('-i, --ignore-case', 'Case-insensitive search')
+  .option('-c, --context <lines>', 'Show context lines', parseInt, 1)
+  .action((query, options) => {
+    let config = {};
+    try {
+      config = loadBuildConfig() || {};
+    } catch {
+      // Not in a rev project, that's ok
+    }
+    let sections = config.sections || [];
+
+    if (sections.length === 0) {
+      sections = fs.readdirSync('.').filter(f =>
+        f.endsWith('.md') && !['README.md', 'CLAUDE.md'].includes(f)
+      );
+    }
+
+    const flags = options.ignoreCase ? 'gi' : 'g';
+    let pattern;
+    try {
+      pattern = new RegExp(query, flags);
+    } catch {
+      pattern = new RegExp(query.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), flags);
+    }
+
+    let totalMatches = 0;
+
+    for (const section of sections) {
+      if (!fs.existsSync(section)) continue;
+      const text = fs.readFileSync(section, 'utf-8');
+      const lines = text.split('\n');
+
+      const matches = [];
+      for (let i = 0; i < lines.length; i++) {
+        if (pattern.test(lines[i])) {
+          matches.push({ line: i + 1, text: lines[i] });
+          pattern.lastIndex = 0;
+        }
+      }
+
+      if (matches.length > 0) {
+        console.log(chalk.cyan.bold(`\n${section}`));
+        for (const match of matches) {
+          const highlighted = match.text.replace(pattern, (m) => chalk.yellow.bold(m));
+          console.log(`  ${chalk.dim(match.line + ':')} ${highlighted}`);
+        }
+        totalMatches += matches.length;
+      }
+    }
+
+    if (totalMatches === 0) {
+      console.log(chalk.yellow(`No matches found for "${query}"`));
+    } else {
+      console.log(chalk.dim(`\n${totalMatches} match${totalMatches === 1 ? '' : 'es'} found`));
+    }
+  });
+
+// ============================================================================
+// BACKUP command - Timestamped project backup
+// ============================================================================
+
+program
+  .command('backup')
+  .description('Create timestamped project backup')
+  .option('-n, --name <name>', 'Custom backup name')
+  .option('-o, --output <dir>', 'Output directory', '.')
+  .action(async (options) => {
+    const { default: AdmZip } = await import('adm-zip');
+    const zip = new AdmZip();
+
+    const date = new Date().toISOString().slice(0, 10);
+    const name = options.name || `backup-${date}`;
+    const outputPath = path.join(options.output, `${name}.zip`);
+
+    // Files to include
+    const includePatterns = [
+      '*.md', '*.yaml', '*.yml', '*.bib', '*.csl',
+      'figures/*', 'images/*', 'assets/*'
+    ];
+
+    // Files to exclude
+    const excludePatterns = [
+      'node_modules', '.git', '*.docx', '*.pdf', '*.zip',
+      'paper.md' // Generated file
+    ];
+
+    const shouldInclude = (file) => {
+      for (const pattern of excludePatterns) {
+        if (file.includes(pattern.replace('*', ''))) return false;
+      }
+      return true;
+    };
+
+    const addDir = (dir, zipPath = '') => {
+      const entries = fs.readdirSync(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        const entryZipPath = path.join(zipPath, entry.name);
+
+        if (!shouldInclude(entry.name)) continue;
+
+        if (entry.isDirectory()) {
+          addDir(fullPath, entryZipPath);
+        } else {
+          zip.addLocalFile(fullPath, zipPath || undefined);
+        }
+      }
+    };
+
+    // Add current directory
+    const entries = fs.readdirSync('.', { withFileTypes: true });
+    for (const entry of entries) {
+      if (!shouldInclude(entry.name)) continue;
+
+      if (entry.isDirectory()) {
+        addDir(entry.name, entry.name);
+      } else if (entry.isFile()) {
+        zip.addLocalFile(entry.name);
+      }
+    }
+
+    zip.writeZip(outputPath);
+    console.log(fmt.status('success', `Backup created: ${outputPath}`));
+  });
+
+// ============================================================================
+// EXPORT command - Export project as distributable zip
+// ============================================================================
+
+program
+  .command('export')
+  .description('Export project as distributable zip')
+  .option('-o, --output <file>', 'Output filename')
+  .option('--include-output', 'Include built PDF/DOCX files')
+  .action(async (options) => {
+    const { default: AdmZip } = await import('adm-zip');
+    let config = {};
+    try {
+      config = loadBuildConfig() || {};
+    } catch {
+      // Not in a rev project, that's ok
+    }
+
+    // Build first if including output
+    if (options.includeOutput) {
+      console.log(chalk.dim('Building documents...'));
+      await build(['pdf', 'docx']);
+    }
+
+    const zip = new AdmZip();
+    const projectName = config.title?.replace(/[^a-zA-Z0-9]/g, '-').toLowerCase() || 'project';
+    const outputPath = options.output || `${projectName}-export.zip`;
+
+    const exclude = ['node_modules', '.git', '.DS_Store', '*.zip'];
+
+    const shouldInclude = (name) => {
+      if (!options.includeOutput && (name.endsWith('.pdf') || name.endsWith('.docx'))) {
+        return false;
+      }
+      for (const pattern of exclude) {
+        if (name === pattern || name.includes(pattern.replace('*', ''))) return false;
+      }
+      return true;
+    };
+
+    const addDir = (dir, zipPath = '') => {
+      const entries = fs.readdirSync(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        const entryZipPath = path.join(zipPath, entry.name);
+
+        if (!shouldInclude(entry.name)) continue;
+
+        if (entry.isDirectory()) {
+          addDir(fullPath, entryZipPath);
+        } else {
+          zip.addLocalFile(fullPath, zipPath || undefined);
+        }
+      }
+    };
+
+    const entries = fs.readdirSync('.', { withFileTypes: true });
+    for (const entry of entries) {
+      if (!shouldInclude(entry.name)) continue;
+
+      if (entry.isDirectory()) {
+        addDir(entry.name, entry.name);
+      } else if (entry.isFile()) {
+        zip.addLocalFile(entry.name);
+      }
+    }
+
+    zip.writeZip(outputPath);
+    console.log(fmt.status('success', `Exported: ${outputPath}`));
+  });
+
+// ============================================================================
+// PREVIEW command - Build and open document
+// ============================================================================
+
+program
+  .command('preview')
+  .description('Build and open document in default app')
+  .argument('[format]', 'Format to preview: pdf, docx', 'pdf')
+  .action(async (format) => {
+    const { exec } = require('child_process');
+    let config = {};
+    try {
+      config = loadBuildConfig() || {};
+    } catch (err) {
+      console.error(chalk.red('Not in a rev project directory (no rev.yaml found)'));
+      process.exit(1);
+    }
+
+    console.log(chalk.dim(`Building ${format}...`));
+    const results = await build([format]);
+
+    const result = results.find(r => r.format === format);
+    if (!result?.success) {
+      console.error(chalk.red(`Build failed: ${result?.error || 'Unknown error'}`));
+      process.exit(1);
+    }
+
+    const outputFile = result.output;
+    if (!fs.existsSync(outputFile)) {
+      console.error(chalk.red(`Output file not found: ${outputFile}`));
+      process.exit(1);
+    }
+
+    // Open with system default
+    const openCmd = process.platform === 'darwin' ? 'open' :
+                    process.platform === 'win32' ? 'start' : 'xdg-open';
+
+    exec(`${openCmd} "${outputFile}"`, (err) => {
+      if (err) {
+        console.error(chalk.red(`Could not open file: ${err.message}`));
+      } else {
+        console.log(fmt.status('success', `Opened ${outputFile}`));
+      }
+    });
+  });
+
+// ============================================================================
+// WATCH command - Auto-rebuild on changes
+// ============================================================================
+
+program
+  .command('watch')
+  .description('Watch files and auto-rebuild on changes')
+  .argument('[format]', 'Format to build: pdf, docx, all', 'pdf')
+  .option('--no-open', 'Do not open after first build')
+  .action(async (format, options) => {
+    const { exec } = require('child_process');
+    let config = {};
+    try {
+      config = loadBuildConfig() || {};
+    } catch (err) {
+      console.error(chalk.red('Not in a rev project directory (no rev.yaml found)'));
+      process.exit(1);
+    }
+    let sections = config.sections || [];
+
+    if (sections.length === 0) {
+      sections = fs.readdirSync('.').filter(f =>
+        f.endsWith('.md') && !['README.md', 'CLAUDE.md', 'paper.md'].includes(f)
+      );
+    }
+
+    const filesToWatch = [
+      ...sections,
+      'rev.yaml',
+      config.bibliography || 'references.bib'
+    ].filter(f => fs.existsSync(f));
+
+    console.log(fmt.header('Watch Mode'));
+    console.log(chalk.dim(`Watching: ${filesToWatch.join(', ')}`));
+    console.log(chalk.dim('Press Ctrl+C to stop\n'));
+
+    let building = false;
+    let pendingBuild = false;
+
+    const doBuild = async () => {
+      if (building) {
+        pendingBuild = true;
+        return;
+      }
+
+      building = true;
+      console.log(chalk.dim(`\n[${new Date().toLocaleTimeString()}] Rebuilding...`));
+
+      try {
+        const formats = format === 'all' ? ['pdf', 'docx'] : [format];
+        const results = await build(formats);
+
+        for (const r of results) {
+          if (r.success) {
+            console.log(chalk.green(`  ✓ ${r.format}: ${r.output}`));
+          } else {
+            console.log(chalk.red(`  ✗ ${r.format}: ${r.error}`));
+          }
+        }
+      } catch (err) {
+        console.error(chalk.red(`  Build error: ${err.message}`));
+      }
+
+      building = false;
+      if (pendingBuild) {
+        pendingBuild = false;
+        doBuild();
+      }
+    };
+
+    // Initial build
+    await doBuild();
+
+    // Open after first build
+    if (options.open) {
+      const outputFile = format === 'docx' ?
+        (config.title?.replace(/[^a-zA-Z0-9]/g, '-').toLowerCase() || 'paper') + '.docx' :
+        (config.title?.replace(/[^a-zA-Z0-9]/g, '-').toLowerCase() || 'paper') + '.pdf';
+
+      if (fs.existsSync(outputFile)) {
+        const openCmd = process.platform === 'darwin' ? 'open' :
+                        process.platform === 'win32' ? 'start' : 'xdg-open';
+        exec(`${openCmd} "${outputFile}"`);
+      }
+    }
+
+    // Watch files
+    for (const file of filesToWatch) {
+      fs.watch(file, { persistent: true }, (eventType) => {
+        if (eventType === 'change') {
+          doBuild();
+        }
+      });
+    }
+  });
+
+// ============================================================================
+// LINT command - Check for common issues
+// ============================================================================
+
+program
+  .command('lint')
+  .description('Check for common issues in the project')
+  .option('--fix', 'Auto-fix issues where possible')
+  .action(async (options) => {
+    let config = {};
+    try {
+      config = loadBuildConfig() || {};
+    } catch {
+      // Not in a rev project, that's ok
+    }
+    let sections = config.sections || [];
+
+    if (sections.length === 0) {
+      sections = fs.readdirSync('.').filter(f =>
+        f.endsWith('.md') && !['README.md', 'CLAUDE.md', 'paper.md'].includes(f)
+      );
+    }
+
+    const issues = [];
+    const warnings = [];
+
+    // Collect all content
+    let allText = '';
+    for (const section of sections) {
+      if (fs.existsSync(section)) {
+        allText += fs.readFileSync(section, 'utf-8') + '\n';
+      }
+    }
+
+    // Check 1: Broken cross-references
+    const figAnchors = new Set();
+    const tblAnchors = new Set();
+    const eqAnchors = new Set();
+
+    const anchorPattern = /\{#(fig|tbl|eq):([^}]+)\}/g;
+    let match;
+    while ((match = anchorPattern.exec(allText)) !== null) {
+      if (match[1] === 'fig') figAnchors.add(match[2]);
+      else if (match[1] === 'tbl') tblAnchors.add(match[2]);
+      else if (match[1] === 'eq') eqAnchors.add(match[2]);
+    }
+
+    const refPattern = /@(fig|tbl|eq):([a-zA-Z0-9_-]+)/g;
+    while ((match = refPattern.exec(allText)) !== null) {
+      const type = match[1];
+      const label = match[2];
+      const anchors = type === 'fig' ? figAnchors : type === 'tbl' ? tblAnchors : eqAnchors;
+
+      if (!anchors.has(label)) {
+        issues.push({
+          type: 'error',
+          message: `Broken reference: @${type}:${label}`,
+          fix: null
+        });
+      }
+    }
+
+    // Check 2: Orphaned figures (defined but not referenced)
+    for (const label of figAnchors) {
+      if (!allText.includes(`@fig:${label}`)) {
+        warnings.push({
+          type: 'warning',
+          message: `Unreferenced figure: {#fig:${label}}`,
+        });
+      }
+    }
+
+    // Check 3: Missing citations
+    const bibPath = config.bibliography || 'references.bib';
+    if (fs.existsSync(bibPath)) {
+      const bibContent = fs.readFileSync(bibPath, 'utf-8');
+      const bibKeys = new Set();
+      const bibPattern = /@\w+\s*\{\s*([^,]+)/g;
+      while ((match = bibPattern.exec(bibContent)) !== null) {
+        bibKeys.add(match[1].trim());
+      }
+
+      const citePattern = /@([a-zA-Z][a-zA-Z0-9_-]*)(?![:\w])/g;
+      while ((match = citePattern.exec(allText)) !== null) {
+        const key = match[1];
+        if (!bibKeys.has(key) && !['fig', 'tbl', 'eq'].includes(key)) {
+          issues.push({
+            type: 'error',
+            message: `Missing citation: @${key}`,
+          });
+        }
+      }
+    }
+
+    // Check 4: Unresolved comments
+    const comments = getComments(allText);
+    const pending = comments.filter(c => !c.resolved);
+    if (pending.length > 0) {
+      warnings.push({
+        type: 'warning',
+        message: `${pending.length} unresolved comment${pending.length === 1 ? '' : 's'}`,
+      });
+    }
+
+    // Check 5: Empty sections
+    for (const section of sections) {
+      if (fs.existsSync(section)) {
+        const content = fs.readFileSync(section, 'utf-8').trim();
+        if (content.length < 50) {
+          warnings.push({
+            type: 'warning',
+            message: `Section appears empty: ${section}`,
+          });
+        }
+      }
+    }
+
+    // Output results
+    console.log(fmt.header('Lint Results'));
+    console.log();
+
+    if (issues.length === 0 && warnings.length === 0) {
+      console.log(chalk.green('✓ No issues found'));
+      return;
+    }
+
+    for (const issue of issues) {
+      console.log(chalk.red(`  ✗ ${issue.message}`));
+    }
+
+    for (const warning of warnings) {
+      console.log(chalk.yellow(`  ⚠ ${warning.message}`));
+    }
+
+    console.log();
+    console.log(chalk.dim(`${issues.length} error${issues.length === 1 ? '' : 's'}, ${warnings.length} warning${warnings.length === 1 ? '' : 's'}`));
+
+    if (issues.length > 0) {
+      process.exit(1);
+    }
+  });
+
+// ============================================================================
+// GRAMMAR command - Check grammar and style
+// ============================================================================
+
+program
+  .command('grammar')
+  .description('Check grammar and style issues')
+  .argument('[files...]', 'Markdown files to check')
+  .option('--learn <word>', 'Add word to custom dictionary')
+  .option('--forget <word>', 'Remove word from custom dictionary')
+  .option('--list', 'List custom dictionary words')
+  .option('--rules', 'List available grammar rules')
+  .option('--no-scientific', 'Disable scientific writing rules')
+  .option('-s, --severity <level>', 'Minimum severity: error, warning, info', 'info')
+  .action(async (files, options) => {
+    const {
+      checkGrammar,
+      getGrammarSummary,
+      loadDictionary,
+      addToDictionary,
+      removeFromDictionary,
+      listRules,
+    } = await import('../lib/grammar.js');
+
+    // Handle dictionary management
+    if (options.learn) {
+      const added = addToDictionary(options.learn);
+      if (added) {
+        console.log(fmt.status('success', `Added "${options.learn}" to dictionary`));
+      } else {
+        console.log(chalk.dim(`"${options.learn}" already in dictionary`));
+      }
+      return;
+    }
+
+    if (options.forget) {
+      const removed = removeFromDictionary(options.forget);
+      if (removed) {
+        console.log(fmt.status('success', `Removed "${options.forget}" from dictionary`));
+      } else {
+        console.log(chalk.yellow(`"${options.forget}" not in dictionary`));
+      }
+      return;
+    }
+
+    if (options.list) {
+      const words = loadDictionary();
+      console.log(fmt.header('Custom Dictionary'));
+      console.log();
+      if (words.size === 0) {
+        console.log(chalk.dim('  No custom words defined'));
+        console.log(chalk.dim('  Use --learn <word> to add words'));
+      } else {
+        const sorted = [...words].sort();
+        for (const word of sorted) {
+          console.log(`  ${word}`);
+        }
+        console.log();
+        console.log(chalk.dim(`${words.size} word(s)`));
+      }
+      return;
+    }
+
+    if (options.rules) {
+      const rules = listRules(options.scientific);
+      console.log(fmt.header('Grammar Rules'));
+      console.log();
+      for (const rule of rules) {
+        const icon = rule.severity === 'error' ? chalk.red('●') :
+                     rule.severity === 'warning' ? chalk.yellow('●') :
+                     chalk.blue('●');
+        console.log(`  ${icon} ${chalk.bold(rule.id)}`);
+        console.log(chalk.dim(`     ${rule.message}`));
+      }
+      return;
+    }
+
+    // Get files to check
+    let mdFiles = files;
+    if (!mdFiles || mdFiles.length === 0) {
+      let config = {};
+      try {
+        config = loadBuildConfig() || {};
+      } catch {
+        // Not in a rev project
+      }
+      mdFiles = config.sections || [];
+
+      if (mdFiles.length === 0) {
+        mdFiles = fs.readdirSync('.').filter(f =>
+          f.endsWith('.md') && !['README.md', 'CLAUDE.md', 'paper.md'].includes(f)
+        );
+      }
+    }
+
+    if (mdFiles.length === 0) {
+      console.error(chalk.red('No markdown files found'));
+      process.exit(1);
+    }
+
+    console.log(fmt.header('Grammar Check'));
+    console.log();
+
+    const severityLevels = { error: 3, warning: 2, info: 1 };
+    const minSeverity = severityLevels[options.severity] || 1;
+
+    let allIssues = [];
+
+    for (const file of mdFiles) {
+      if (!fs.existsSync(file)) continue;
+
+      const text = fs.readFileSync(file, 'utf-8');
+      const issues = checkGrammar(text, { scientific: options.scientific });
+
+      // Filter by severity
+      const filtered = issues.filter(i => severityLevels[i.severity] >= minSeverity);
+
+      if (filtered.length > 0) {
+        console.log(chalk.cyan.bold(file));
+
+        for (const issue of filtered) {
+          const icon = issue.severity === 'error' ? chalk.red('●') :
+                       issue.severity === 'warning' ? chalk.yellow('●') :
+                       chalk.blue('●');
+
+          console.log(`  ${chalk.dim(`L${issue.line}:`)} ${icon} ${issue.message}`);
+          console.log(chalk.dim(`      "${issue.match}" in: ${issue.context.slice(0, 60)}...`));
+        }
+        console.log();
+        allIssues.push(...filtered.map(i => ({ ...i, file })));
+      }
+    }
+
+    const summary = getGrammarSummary(allIssues);
+
+    if (summary.total === 0) {
+      console.log(chalk.green('✓ No issues found'));
+    } else {
+      console.log(chalk.dim(`Found ${summary.total} issue(s): ${summary.errors} errors, ${summary.warnings} warnings, ${summary.info} info`));
+      console.log();
+      console.log(chalk.dim('Tip: Use --learn <word> to add words to dictionary'));
+    }
+  });
+
+// ============================================================================
+// ANNOTATE command - Add comments to Word document
+// ============================================================================
+
+program
+  .command('annotate')
+  .description('Add comment to Word document')
+  .argument('<docx>', 'Word document')
+  .option('-m, --message <text>', 'Comment text')
+  .option('-s, --search <text>', 'Text to attach comment to')
+  .option('-a, --author <name>', 'Comment author')
+  .action(async (docxPath, options) => {
+    if (!fs.existsSync(docxPath)) {
+      console.error(chalk.red(`File not found: ${docxPath}`));
+      process.exit(1);
+    }
+
+    if (!options.message) {
+      console.error(chalk.red('Comment message required (-m)'));
+      process.exit(1);
+    }
+
+    const { default: AdmZip } = await import('adm-zip');
+    const zip = new AdmZip(docxPath);
+
+    // Read document.xml
+    const docEntry = zip.getEntry('word/document.xml');
+    if (!docEntry) {
+      console.error(chalk.red('Invalid Word document'));
+      process.exit(1);
+    }
+
+    let docXml = zip.readAsText(docEntry);
+
+    // Read or create comments.xml
+    let commentsEntry = zip.getEntry('word/comments.xml');
+    let commentsXml;
+    let nextCommentId = 1;
+
+    if (commentsEntry) {
+      commentsXml = zip.readAsText(commentsEntry);
+      // Find highest existing comment ID
+      const idMatches = commentsXml.match(/w:id="(\d+)"/g) || [];
+      for (const m of idMatches) {
+        const id = parseInt(m.match(/\d+/)[0]);
+        if (id >= nextCommentId) nextCommentId = id + 1;
+      }
+    } else {
+      commentsXml = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<w:comments xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main">
+</w:comments>`;
+    }
+
+    const author = options.author || getUserName() || 'Claude';
+    const date = new Date().toISOString();
+    const commentId = nextCommentId;
+
+    // Add comment to comments.xml
+    const newComment = `<w:comment w:id="${commentId}" w:author="${author}" w:date="${date}">
+  <w:p><w:r><w:t>${options.message}</w:t></w:r></w:p>
+</w:comment>`;
+
+    commentsXml = commentsXml.replace('</w:comments>', `${newComment}\n</w:comments>`);
+
+    // Find text and add comment markers
+    if (options.search) {
+      const searchText = options.search;
+      const textPattern = new RegExp(`(<w:t[^>]*>)([^<]*${searchText.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}[^<]*)(<\/w:t>)`, 'i');
+
+      if (textPattern.test(docXml)) {
+        docXml = docXml.replace(textPattern, (match, start, text, end) => {
+          return `<w:commentRangeStart w:id="${commentId}"/>${start}${text}${end}<w:commentRangeEnd w:id="${commentId}"/><w:r><w:commentReference w:id="${commentId}"/></w:r>`;
+        });
+      } else {
+        console.log(chalk.yellow(`Text "${searchText}" not found in document. Comment added without anchor.`));
+      }
+    }
+
+    // Update zip
+    zip.updateFile('word/document.xml', Buffer.from(docXml));
+
+    if (commentsEntry) {
+      zip.updateFile('word/comments.xml', Buffer.from(commentsXml));
+    } else {
+      zip.addFile('word/comments.xml', Buffer.from(commentsXml));
+
+      // Update [Content_Types].xml to include comments
+      const ctEntry = zip.getEntry('[Content_Types].xml');
+      if (ctEntry) {
+        let ctXml = zip.readAsText(ctEntry);
+        if (!ctXml.includes('comments.xml')) {
+          ctXml = ctXml.replace('</Types>',
+            '<Override PartName="/word/comments.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.comments+xml"/>\n</Types>');
+          zip.updateFile('[Content_Types].xml', Buffer.from(ctXml));
+        }
+      }
+
+      // Update document.xml.rels
+      const relsEntry = zip.getEntry('word/_rels/document.xml.rels');
+      if (relsEntry) {
+        let relsXml = zip.readAsText(relsEntry);
+        if (!relsXml.includes('comments.xml')) {
+          const newRelId = `rId${Date.now()}`;
+          relsXml = relsXml.replace('</Relationships>',
+            `<Relationship Id="${newRelId}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/comments" Target="comments.xml"/>\n</Relationships>`);
+          zip.updateFile('word/_rels/document.xml.rels', Buffer.from(relsXml));
+        }
+      }
+    }
+
+    // Write back
+    zip.writeZip(docxPath);
+    console.log(fmt.status('success', `Added comment to ${docxPath}`));
+  });
+
+// ============================================================================
+// APPLY command - Apply MD annotations as Word track changes
+// ============================================================================
+
+program
+  .command('apply')
+  .description('Apply markdown annotations to Word document as track changes')
+  .argument('<md>', 'Markdown file with annotations')
+  .argument('<docx>', 'Output Word document')
+  .option('-a, --author <name>', 'Author name for track changes')
+  .action(async (mdPath, docxPath, options) => {
+    if (!fs.existsSync(mdPath)) {
+      console.error(chalk.red(`File not found: ${mdPath}`));
+      process.exit(1);
+    }
+
+    const mdContent = fs.readFileSync(mdPath, 'utf-8');
+    const annotations = parseAnnotations(mdContent);
+
+    if (annotations.length === 0) {
+      console.log(chalk.yellow('No annotations found in markdown file'));
+      // Still build the document
+    }
+
+    const author = options.author || getUserName() || 'Author';
+
+    // Build document with track changes
+    const { buildWithTrackChanges } = await import('../lib/trackchanges.js');
+
+    try {
+      const result = await buildWithTrackChanges(mdPath, docxPath, { author });
+
+      if (result.success) {
+        console.log(fmt.status('success', result.message));
+        console.log(chalk.dim(`  ${annotations.length} annotations applied as track changes`));
+      } else {
+        console.error(chalk.red(result.message));
+        process.exit(1);
+      }
+    } catch (err) {
+      console.error(chalk.red(`Error: ${err.message}`));
+      process.exit(1);
+    }
+  });
+
+// ============================================================================
+// COMMENT command - Interactive comment addition to DOCX
+// ============================================================================
+
+program
+  .command('comment')
+  .description('Add comments to Word document interactively')
+  .argument('<docx>', 'Word document')
+  .option('-a, --author <name>', 'Comment author')
+  .action(async (docxPath, options) => {
+    if (!fs.existsSync(docxPath)) {
+      console.error(chalk.red(`File not found: ${docxPath}`));
+      process.exit(1);
+    }
+
+    const { default: AdmZip } = await import('adm-zip');
+    const rl = (await import('readline')).createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+
+    const ask = (prompt) => new Promise((resolve) => rl.question(prompt, resolve));
+
+    const author = options.author || getUserName() || 'Reviewer';
+
+    console.log(fmt.header('Interactive Comment Mode'));
+    console.log(chalk.dim(`  Document: ${docxPath}`));
+    console.log(chalk.dim(`  Author: ${author}`));
+    console.log(chalk.dim('  Type your comment, then the text to attach it to.'));
+    console.log(chalk.dim('  Enter empty comment to quit.\n'));
+
+    let commentsAdded = 0;
+
+    while (true) {
+      const message = await ask(chalk.cyan('Comment: '));
+
+      if (!message.trim()) {
+        break;
+      }
+
+      const searchText = await ask(chalk.cyan('Attach to text: '));
+
+      // Load document fresh each time
+      const zip = new AdmZip(docxPath);
+      const docEntry = zip.getEntry('word/document.xml');
+
+      if (!docEntry) {
+        console.error(chalk.red('Invalid Word document'));
+        rl.close();
+        process.exit(1);
+      }
+
+      let docXml = zip.readAsText(docEntry);
+
+      // Read or create comments.xml
+      let commentsEntry = zip.getEntry('word/comments.xml');
+      let commentsXml;
+      let nextCommentId = 1;
+
+      if (commentsEntry) {
+        commentsXml = zip.readAsText(commentsEntry);
+        const idMatches = commentsXml.match(/w:id="(\d+)"/g) || [];
+        for (const m of idMatches) {
+          const id = parseInt(m.match(/\d+/)[0]);
+          if (id >= nextCommentId) nextCommentId = id + 1;
+        }
+      } else {
+        commentsXml = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<w:comments xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main">
+</w:comments>`;
+      }
+
+      const date = new Date().toISOString();
+      const commentId = nextCommentId;
+
+      // Add comment to comments.xml
+      const newComment = `<w:comment w:id="${commentId}" w:author="${author}" w:date="${date}">
+  <w:p><w:r><w:t>${message}</w:t></w:r></w:p>
+</w:comment>`;
+
+      commentsXml = commentsXml.replace('</w:comments>', `${newComment}\n</w:comments>`);
+
+      // Find text and add comment markers
+      if (searchText.trim()) {
+        const escapedSearch = searchText.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        const textPattern = new RegExp(`(<w:t[^>]*>)([^<]*${escapedSearch}[^<]*)(<\/w:t>)`, 'i');
+
+        if (textPattern.test(docXml)) {
+          docXml = docXml.replace(textPattern, (match, start, text, end) => {
+            return `<w:commentRangeStart w:id="${commentId}"/>${start}${text}${end}<w:commentRangeEnd w:id="${commentId}"/><w:r><w:commentReference w:id="${commentId}"/></w:r>`;
+          });
+          console.log(chalk.green(`  ✓ Comment added at "${searchText}"`));
+        } else {
+          console.log(chalk.yellow(`  Text not found. Comment added without anchor.`));
+        }
+      } else {
+        console.log(chalk.dim(`  Comment added without anchor.`));
+      }
+
+      // Update zip
+      zip.updateFile('word/document.xml', Buffer.from(docXml));
+
+      if (commentsEntry) {
+        zip.updateFile('word/comments.xml', Buffer.from(commentsXml));
+      } else {
+        zip.addFile('word/comments.xml', Buffer.from(commentsXml));
+
+        // Update [Content_Types].xml
+        const ctEntry = zip.getEntry('[Content_Types].xml');
+        if (ctEntry) {
+          let ctXml = zip.readAsText(ctEntry);
+          if (!ctXml.includes('comments.xml')) {
+            ctXml = ctXml.replace('</Types>',
+              '<Override PartName="/word/comments.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.comments+xml"/>\n</Types>');
+            zip.updateFile('[Content_Types].xml', Buffer.from(ctXml));
+          }
+        }
+
+        // Update document.xml.rels
+        const relsEntry = zip.getEntry('word/_rels/document.xml.rels');
+        if (relsEntry) {
+          let relsXml = zip.readAsText(relsEntry);
+          if (!relsXml.includes('comments.xml')) {
+            const newRelId = `rId${Date.now()}`;
+            relsXml = relsXml.replace('</Relationships>',
+              `<Relationship Id="${newRelId}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/comments" Target="comments.xml"/>\n</Relationships>`);
+            zip.updateFile('word/_rels/document.xml.rels', Buffer.from(relsXml));
+          }
+        }
+      }
+
+      zip.writeZip(docxPath);
+      commentsAdded++;
+      console.log();
+    }
+
+    rl.close();
+    console.log();
+
+    if (commentsAdded > 0) {
+      console.log(fmt.status('success', `Added ${commentsAdded} comment(s) to ${docxPath}`));
+    } else {
+      console.log(chalk.dim('No comments added.'));
+    }
+  });
+
+// ============================================================================
+// CLEAN command - Remove generated files
+// ============================================================================
+
+program
+  .command('clean')
+  .description('Remove generated files (paper.md, PDFs, DOCXs)')
+  .option('-n, --dry-run', 'Show what would be deleted without deleting')
+  .option('--all', 'Also remove backup and export zips')
+  .action((options) => {
+    let config = {};
+    try {
+      config = loadBuildConfig() || {};
+    } catch {
+      // Not in a rev project, that's ok
+    }
+
+    const projectName = config.title?.toLowerCase().replace(/\s+/g, '-') || 'paper';
+
+    // Files to clean
+    const patterns = [
+      'paper.md',
+      '*.pdf',
+      `${projectName}.docx`,
+      `${projectName}.pdf`,
+      `${projectName}.tex`,
+      '.paper-*.md', // Temp build files
+    ];
+
+    if (options.all) {
+      patterns.push('*.zip', 'backup-*.zip', '*-export.zip');
+    }
+
+    const toDelete = [];
+
+    for (const pattern of patterns) {
+      if (pattern.includes('*')) {
+        // Glob pattern
+        const regex = new RegExp('^' + pattern.replace(/\./g, '\\.').replace(/\*/g, '.*') + '$');
+        const files = fs.readdirSync('.').filter(f => regex.test(f));
+        toDelete.push(...files);
+      } else if (fs.existsSync(pattern)) {
+        toDelete.push(pattern);
+      }
+    }
+
+    if (toDelete.length === 0) {
+      console.log(chalk.dim('No generated files to clean.'));
+      return;
+    }
+
+    console.log(fmt.header('Clean'));
+    console.log();
+
+    for (const file of toDelete) {
+      if (options.dryRun) {
+        console.log(chalk.dim(`  Would delete: ${file}`));
+      } else {
+        fs.unlinkSync(file);
+        console.log(chalk.red(`  Deleted: ${file}`));
+      }
+    }
+
+    console.log();
+    if (options.dryRun) {
+      console.log(chalk.dim(`Would delete ${toDelete.length} file(s). Run without --dry-run to delete.`));
+    } else {
+      console.log(fmt.status('success', `Cleaned ${toDelete.length} file(s)`));
+    }
+  });
+
+// ============================================================================
+// CHECK command - Pre-submission check (lint + grammar + citations)
+// ============================================================================
+
+program
+  .command('check')
+  .description('Run all checks before submission (lint + grammar + citations)')
+  .option('--fix', 'Auto-fix issues where possible')
+  .option('-s, --severity <level>', 'Minimum grammar severity', 'warning')
+  .action(async (options) => {
+    console.log(fmt.header('Pre-Submission Check'));
+    console.log();
+
+    let hasErrors = false;
+    let totalIssues = 0;
+
+    // 1. Run lint
+    console.log(chalk.cyan.bold('1. Linting...'));
+    let config = {};
+    try {
+      config = loadBuildConfig() || {};
+    } catch {
+      // Not in a rev project
+    }
+
+    let sections = config.sections || [];
+    if (sections.length === 0) {
+      sections = fs.readdirSync('.').filter(f =>
+        f.endsWith('.md') && !['README.md', 'CLAUDE.md', 'paper.md'].includes(f)
+      );
+    }
+
+    const lintIssues = [];
+    const lintWarnings = [];
+
+    for (const file of sections) {
+      if (!fs.existsSync(file)) continue;
+      const content = fs.readFileSync(file, 'utf-8');
+
+      // Check for broken cross-references
+      const refs = content.match(/@(fig|tbl|eq|sec):\w+/g) || [];
+      const anchors = content.match(/\{#(fig|tbl|eq|sec):[^}]+\}/g) || [];
+      const anchorLabels = anchors.map(a => a.match(/#([^}]+)/)[1]);
+
+      for (const ref of refs) {
+        const label = ref.slice(1);
+        if (!anchorLabels.includes(label)) {
+          lintIssues.push({ file, message: `Broken reference: ${ref}` });
+        }
+      }
+
+      // Check for unresolved comments
+      const unresolvedComments = (content.match(/\{>>[^<]*<<\}/g) || [])
+        .filter(c => !c.includes('[RESOLVED]'));
+      if (unresolvedComments.length > 0) {
+        lintWarnings.push({ file, message: `${unresolvedComments.length} unresolved comment(s)` });
+      }
+    }
+
+    if (lintIssues.length > 0) {
+      for (const issue of lintIssues) {
+        console.log(chalk.red(`   ✗ ${issue.file}: ${issue.message}`));
+      }
+      hasErrors = true;
+      totalIssues += lintIssues.length;
+    }
+    for (const warning of lintWarnings) {
+      console.log(chalk.yellow(`   ⚠ ${warning.file}: ${warning.message}`));
+      totalIssues++;
+    }
+    if (lintIssues.length === 0 && lintWarnings.length === 0) {
+      console.log(chalk.green('   ✓ No lint issues'));
+    }
+    console.log();
+
+    // 2. Run grammar check
+    console.log(chalk.cyan.bold('2. Grammar check...'));
+    const {
+      checkGrammar,
+      getGrammarSummary,
+    } = await import('../lib/grammar.js');
+
+    const severityLevels = { error: 3, warning: 2, info: 1 };
+    const minSeverity = severityLevels[options.severity] || 2;
+    let grammarIssues = [];
+
+    for (const file of sections) {
+      if (!fs.existsSync(file)) continue;
+      const text = fs.readFileSync(file, 'utf-8');
+      const issues = checkGrammar(text, { scientific: true });
+      const filtered = issues.filter(i => severityLevels[i.severity] >= minSeverity);
+      grammarIssues.push(...filtered.map(i => ({ ...i, file })));
+    }
+
+    const grammarSummary = getGrammarSummary(grammarIssues);
+    if (grammarSummary.errors > 0) {
+      hasErrors = true;
+    }
+    totalIssues += grammarSummary.total;
+
+    if (grammarSummary.total > 0) {
+      console.log(chalk.yellow(`   ⚠ ${grammarSummary.total} grammar issue(s): ${grammarSummary.errors} errors, ${grammarSummary.warnings} warnings`));
+    } else {
+      console.log(chalk.green('   ✓ No grammar issues'));
+    }
+    console.log();
+
+    // 3. Run citation check
+    console.log(chalk.cyan.bold('3. Citation check...'));
+    const bibFile = config.bibliography || 'references.bib';
+    if (fs.existsSync(bibFile)) {
+      const { validateCitations } = await import('../lib/citations.js');
+      const allContent = sections
+        .filter(f => fs.existsSync(f))
+        .map(f => fs.readFileSync(f, 'utf-8'))
+        .join('\n');
+      const bibContent = fs.readFileSync(bibFile, 'utf-8');
+
+      const result = validateCitations(allContent, bibContent);
+
+      if (result.missing.length > 0) {
+        console.log(chalk.red(`   ✗ ${result.missing.length} missing citation(s): ${result.missing.slice(0, 3).join(', ')}${result.missing.length > 3 ? '...' : ''}`));
+        hasErrors = true;
+        totalIssues += result.missing.length;
+      }
+      if (result.unused.length > 0) {
+        console.log(chalk.yellow(`   ⚠ ${result.unused.length} unused citation(s)`));
+        totalIssues += result.unused.length;
+      }
+      if (result.missing.length === 0 && result.unused.length === 0) {
+        console.log(chalk.green('   ✓ All citations valid'));
+      }
+    } else {
+      console.log(chalk.dim('   - No bibliography file found'));
+    }
+    console.log();
+
+    // Summary
+    console.log(chalk.bold('Summary'));
+    if (hasErrors) {
+      console.log(chalk.red(`   ${totalIssues} issue(s) found. Please fix before submission.`));
+      process.exit(1);
+    } else if (totalIssues > 0) {
+      console.log(chalk.yellow(`   ${totalIssues} warning(s). Review before submission.`));
+    } else {
+      console.log(chalk.green('   ✓ All checks passed! Ready for submission.'));
+    }
+  });
+
+// ============================================================================
+// OPEN command - Open project folder or file
+// ============================================================================
+
+program
+  .command('open')
+  .description('Open project folder or file in default app')
+  .argument('[file]', 'File to open (default: project folder)')
+  .action(async (file) => {
+    const { exec } = await import('child_process');
+    const target = file || '.';
+
+    if (!fs.existsSync(target)) {
+      console.error(chalk.red(`File not found: ${target}`));
+      process.exit(1);
+    }
+
+    // Platform-specific open command
+    const platform = process.platform;
+    let command;
+
+    if (platform === 'darwin') {
+      command = `open "${target}"`;
+    } else if (platform === 'win32') {
+      command = `start "" "${target}"`;
+    } else {
+      command = `xdg-open "${target}"`;
+    }
+
+    exec(command, (err) => {
+      if (err) {
+        console.error(chalk.red(`Failed to open: ${err.message}`));
+        process.exit(1);
+      }
+      console.log(fmt.status('success', `Opened ${target}`));
+    });
+  });
+
+// ============================================================================
+// INSTALL-CLI-SKILL command - Install Claude Code skill
+// ============================================================================
+
+program
+  .command('install-cli-skill')
+  .description('Install docrev skill for Claude Code')
+  .action(() => {
+    const homedir = process.env.HOME || process.env.USERPROFILE;
+    const skillDir = path.join(homedir, '.claude', 'skills', 'docrev');
+    const sourceDir = path.join(import.meta.dirname, '..', 'skill');
+
+    // Check if source skill files exist
+    const skillFile = path.join(sourceDir, 'SKILL.md');
+    if (!fs.existsSync(skillFile)) {
+      console.error(chalk.red('Skill files not found in package'));
+      process.exit(1);
+    }
+
+    // Create skill directory
+    fs.mkdirSync(skillDir, { recursive: true });
+
+    // Copy skill files
+    const files = ['SKILL.md', 'REFERENCE.md'];
+    for (const file of files) {
+      const src = path.join(sourceDir, file);
+      const dest = path.join(skillDir, file);
+      if (fs.existsSync(src)) {
+        fs.copyFileSync(src, dest);
+      }
+    }
+
+    console.log(fmt.status('success', 'Installed docrev skill for Claude Code'));
+    console.log(chalk.dim(`  Location: ${skillDir}`));
+    console.log(chalk.dim('  Restart Claude Code to activate'));
+  });
+
+program
+  .command('uninstall-cli-skill')
+  .description('Remove docrev skill from Claude Code')
+  .action(() => {
+    const homedir = process.env.HOME || process.env.USERPROFILE;
+    const skillDir = path.join(homedir, '.claude', 'skills', 'docrev');
+
+    if (fs.existsSync(skillDir)) {
+      fs.rmSync(skillDir, { recursive: true });
+      console.log(fmt.status('success', 'Removed docrev skill from Claude Code'));
+    } else {
+      console.log(chalk.yellow('Skill not installed'));
+    }
+  });
+
+// ============================================================================
+// SPELLING command - Spellcheck with global dictionary
+// ============================================================================
+
+program
+  .command('spelling')
+  .description('Check spelling in markdown files')
+  .argument('[files...]', 'Files to check (default: section files)')
+  .option('--learn <word>', 'Add word to global dictionary')
+  .option('--learn-project <word>', 'Add word to project dictionary')
+  .option('--forget <word>', 'Remove word from global dictionary')
+  .option('--forget-project <word>', 'Remove word from project dictionary')
+  .option('--list', 'List global dictionary words')
+  .option('--list-project', 'List project dictionary words')
+  .option('--list-all', 'List all custom words (global + project)')
+  .option('--british', 'Use British English dictionary')
+  .option('--add-names', 'Add detected names to global dictionary')
+  .action(async (files, options) => {
+    const spelling = await import('../lib/spelling.js');
+
+    // Handle dictionary management
+    if (options.learn) {
+      const added = spelling.addWord(options.learn, true);
+      if (added) {
+        console.log(fmt.status('success', `Added "${options.learn}" to global dictionary`));
+      } else {
+        console.log(chalk.yellow(`"${options.learn}" already in dictionary`));
+      }
+      return;
+    }
+
+    if (options.learnProject) {
+      const added = spelling.addWord(options.learnProject, false);
+      if (added) {
+        console.log(fmt.status('success', `Added "${options.learnProject}" to project dictionary`));
+      } else {
+        console.log(chalk.yellow(`"${options.learnProject}" already in dictionary`));
+      }
+      return;
+    }
+
+    if (options.forget) {
+      const removed = spelling.removeWord(options.forget, true);
+      if (removed) {
+        console.log(fmt.status('success', `Removed "${options.forget}" from global dictionary`));
+      } else {
+        console.log(chalk.yellow(`"${options.forget}" not in dictionary`));
+      }
+      return;
+    }
+
+    if (options.forgetProject) {
+      const removed = spelling.removeWord(options.forgetProject, false);
+      if (removed) {
+        console.log(fmt.status('success', `Removed "${options.forgetProject}" from project dictionary`));
+      } else {
+        console.log(chalk.yellow(`"${options.forgetProject}" not in dictionary`));
+      }
+      return;
+    }
+
+    if (options.list) {
+      const words = spelling.listWords(true);
+      console.log(fmt.header('Global Dictionary'));
+      if (words.length === 0) {
+        console.log(chalk.dim('  No custom words'));
+        console.log(chalk.dim('  Use --learn <word> to add words'));
+      } else {
+        for (const word of words) {
+          console.log(`  ${word}`);
+        }
+        console.log(chalk.dim(`\n${words.length} word(s)`));
+      }
+      return;
+    }
+
+    if (options.listProject) {
+      const words = spelling.listWords(false);
+      console.log(fmt.header('Project Dictionary'));
+      if (words.length === 0) {
+        console.log(chalk.dim('  No custom words'));
+        console.log(chalk.dim('  Use --learn-project <word> to add words'));
+      } else {
+        for (const word of words) {
+          console.log(`  ${word}`);
+        }
+        console.log(chalk.dim(`\n${words.length} word(s)`));
+      }
+      return;
+    }
+
+    if (options.listAll) {
+      const globalWords = spelling.listWords(true);
+      const projectWords = spelling.listWords(false);
+
+      console.log(fmt.header('Global Dictionary'));
+      if (globalWords.length === 0) {
+        console.log(chalk.dim('  No custom words'));
+      } else {
+        for (const word of globalWords) {
+          console.log(`  ${word}`);
+        }
+      }
+
+      console.log(fmt.header('Project Dictionary'));
+      if (projectWords.length === 0) {
+        console.log(chalk.dim('  No custom words'));
+      } else {
+        for (const word of projectWords) {
+          console.log(`  ${word}`);
+        }
+      }
+
+      console.log(chalk.dim(`\nTotal: ${globalWords.length + projectWords.length} word(s)`));
+      return;
+    }
+
+    // Check spelling in files
+    let filesToCheck = files;
+
+    if (filesToCheck.length === 0) {
+      // Default to section files if in a project
+      if (fs.existsSync('rev.yaml')) {
+        const { getSectionFiles } = await import('../lib/sections.js');
+        filesToCheck = getSectionFiles('.');
+      } else {
+        // Check all .md files in current directory
+        filesToCheck = fs.readdirSync('.')
+          .filter(f => f.endsWith('.md') && !f.startsWith('.'));
+      }
+    }
+
+    if (filesToCheck.length === 0) {
+      console.log(chalk.yellow('No markdown files found'));
+      return;
+    }
+
+    const lang = options.british ? 'en-gb' : 'en';
+    console.log(fmt.header(`Spelling Check (${options.british ? 'British' : 'US'} English)`));
+    let totalMisspelled = 0;
+    const allNames = new Set();
+
+    for (const file of filesToCheck) {
+      if (!fs.existsSync(file)) {
+        console.log(chalk.yellow(`File not found: ${file}`));
+        continue;
+      }
+
+      const result = await spelling.checkFile(file, { projectDir: '.', lang });
+      const { misspelled, possibleNames } = result;
+
+      // Collect names
+      for (const n of possibleNames) {
+        allNames.add(n.word);
+      }
+
+      if (misspelled.length > 0) {
+        console.log(chalk.cyan(`\n${file}:`));
+        for (const issue of misspelled) {
+          const suggestions = issue.suggestions.length > 0
+            ? chalk.dim(` → ${issue.suggestions.join(', ')}`)
+            : '';
+          console.log(`  ${chalk.yellow(issue.word)} ${chalk.dim(`(line ${issue.line})`)}${suggestions}`);
+        }
+        totalMisspelled += misspelled.length;
+      }
+    }
+
+    // Show possible names separately
+    if (allNames.size > 0) {
+      const nameList = [...allNames].sort();
+
+      if (options.addNames) {
+        // Add all names to dictionary
+        console.log(fmt.header('Adding Names to Dictionary'));
+        for (const name of nameList) {
+          spelling.addWord(name, true);
+          console.log(chalk.green(`  ✓ ${name}`));
+        }
+        console.log(chalk.dim(`\nAdded ${nameList.length} name(s) to global dictionary`));
+      } else {
+        console.log(fmt.header('Possible Names'));
+        console.log(chalk.dim(`  ${nameList.join(', ')}`));
+        console.log(chalk.dim(`\n  Run with --add-names to add all to dictionary`));
+      }
+    }
+
+    if (totalMisspelled === 0 && allNames.size === 0) {
+      console.log(fmt.status('success', 'No spelling errors found'));
+    } else {
+      if (totalMisspelled > 0) {
+        console.log(chalk.yellow(`\n${totalMisspelled} spelling error(s)`));
+      }
+      if (allNames.size > 0) {
+        console.log(chalk.blue(`${allNames.size} possible name(s)`));
+      }
+      console.log(chalk.dim('Use --learn <word> to add words to dictionary'));
+    }
+  });
+
 program.parse();