docrev 0.9.4 → 0.9.6

package/lib/commands/text-ops.ts

@@ -0,0 +1,449 @@
+/**
+ * Text operation commands: spelling, batch
+ *
+ * Commands for spelling checks and batch operations on markdown files.
+ */
+
+import type { Command } from 'commander';
+import {
+  chalk,
+  fs,
+  path,
+  fmt,
+  findFiles,
+  loadBuildConfig,
+  countAnnotations,
+  getComments,
+  stripAnnotations,
+  setCommentStatus,
+} from './context.js';
+
+// Use the actual BuildConfig from build.ts which allows string|Author[]
+type BuildConfig = ReturnType<typeof loadBuildConfig>;
+
+// Options interfaces
+interface SpellingOptions {
+  learn?: string;
+  learnProject?: string;
+  forget?: string;
+  forgetProject?: string;
+  list?: boolean;
+  listProject?: boolean;
+  listAll?: boolean;
+  british?: boolean;
+  addNames?: boolean;
+}
+
+interface BatchOptions {
+  parallel?: boolean;
+  dryRun?: boolean;
+  all?: boolean;
+}
+
+// Spelling issue interface
+interface SpellingIssue {
+  word: string;
+  line: number;
+  suggestions: string[];
+}
+
+// Spelling result interface
+interface SpellingResult {
+  misspelled: SpellingIssue[];
+  possibleNames: SpellingIssue[];
+}
+
+// Batch result interface
+interface BatchResult {
+  file: string;
+  status: string;
+  annotations?: number;
+  comments?: number;
+  pending?: number;
+  total?: number;
+  resolved?: number;
+  stripped?: boolean;
+  error?: string;
+}
+
+/**
+ * Register text-ops commands with the program
+ */
+export function register(program: Command): void {
+  // ==========================================================================
+  // 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: string[] | undefined, options: SpellingOptions) => {
+      const spelling = await import('../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) {
+        if (fs.existsSync('rev.yaml')) {
+          try {
+            const config = loadBuildConfig('.');
+            filesToCheck = config?.sections || [];
+          } catch {
+            // Ignore errors
+          }
+          if (filesToCheck.length === 0) {
+            filesToCheck = fs.readdirSync('.')
+              .filter(f => f.endsWith('.md') && !f.startsWith('.'));
+          }
+        } else {
+          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<string>();
+
+      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 }) as SpellingResult;
+        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) {
+          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'));
+      }
+    });
+
+  // ==========================================================================
+  // BATCH command - Run operations on multiple documents
+  // ==========================================================================
+
+  program
+    .command('batch')
+    .description('Run operations on multiple documents')
+    .argument('<command>', 'Command to run (status, strip, resolve)')
+    .argument('[pattern]', 'File pattern (default: *.md)')
+    .option('--parallel', 'Run operations in parallel')
+    .option('--dry-run', 'Preview files without running')
+    .option('-a, --all', 'Include all .md files (not just sections)')
+    .action(async (command: string, pattern: string | undefined, options: BatchOptions) => {
+      const validCommands = ['status', 'strip', 'resolve', 'comments'];
+
+      if (!validCommands.includes(command)) {
+        console.error(fmt.status('error', `Unknown batch command: ${command}`));
+        console.error(chalk.dim(`Available: ${validCommands.join(', ')}`));
+        process.exit(1);
+      }
+
+      // Find files
+      let files: string[] = [];
+      if (pattern) {
+        if (pattern.includes('*')) {
+          files = fs.readdirSync('.').filter(f =>
+            f.endsWith('.md') && !['README.md', 'CLAUDE.md', 'paper.md'].includes(f)
+          );
+        } else {
+          files = [pattern];
+        }
+      } else {
+        files = fs.readdirSync('.').filter(f =>
+          f.endsWith('.md') &&
+          (options.all || !['README.md', 'CLAUDE.md', 'paper.md'].includes(f))
+        );
+      }
+
+      if (files.length === 0) {
+        console.error(fmt.status('error', 'No files found'));
+        process.exit(1);
+      }
+
+      console.log(fmt.header(`Batch ${command} on ${files.length} file(s)`));
+      console.log();
+
+      if (options.dryRun) {
+        console.log(chalk.dim('Dry run - files that would be processed:'));
+        for (const file of files) {
+          console.log(chalk.dim(`  ${file}`));
+        }
+        return;
+      }
+
+      // Process files
+      const results: BatchResult[] = [];
+      const progressBar = fmt.progressBar(files.length, 'Processing');
+      progressBar.update(0);
+
+      for (let i = 0; i < files.length; i++) {
+        const file = files[i];
+        progressBar.update(i + 1);
+
+        if (!fs.existsSync(file)) {
+          results.push({ file, status: 'not found' });
+          continue;
+        }
+
+        try {
+          const text = fs.readFileSync(file, 'utf-8');
+          let result: BatchResult = { file, status: 'ok' };
+
+          switch (command) {
+            case 'status': {
+              const counts = countAnnotations(text);
+              const comments = getComments(text);
+              result.annotations = counts.total;
+              result.comments = comments.length;
+              result.pending = comments.filter(c => !c.resolved).length;
+              break;
+            }
+
+            case 'comments': {
+              const comments = getComments(text);
+              result.total = comments.length;
+              result.pending = comments.filter(c => !c.resolved).length;
+              result.resolved = comments.filter(c => c.resolved).length;
+              break;
+            }
+
+            case 'resolve': {
+              const comments = getComments(text);
+              const pending = comments.filter(c => !c.resolved);
+              if (pending.length > 0) {
+                let newText = text;
+                for (const c of pending) {
+                  newText = setCommentStatus(newText, c, true);
+                }
+                fs.writeFileSync(file, newText, 'utf-8');
+                result.resolved = pending.length;
+              } else {
+                result.resolved = 0;
+              }
+              break;
+            }
+
+            case 'strip': {
+              const clean = stripAnnotations(text, { keepComments: false });
+              const hasChanges = clean !== text;
+              if (hasChanges) {
+                fs.writeFileSync(file, clean, 'utf-8');
+                result.stripped = true;
+              } else {
+                result.stripped = false;
+              }
+              break;
+            }
+          }
+
+          results.push(result);
+        } catch (err) {
+          results.push({ file, status: 'error', error: (err as Error).message });
+        }
+      }
+
+      progressBar.done();
+      console.log();
+
+      // Show results
+      console.log(fmt.header('Results'));
+      console.log();
+
+      for (const r of results) {
+        const statusIcon = r.status === 'ok'
+          ? chalk.green('✓')
+          : r.status === 'error'
+            ? chalk.red('✗')
+            : chalk.yellow('?');
+
+        let details = '';
+        switch (command) {
+          case 'status':
+            details = chalk.dim(`${r.annotations || 0} annotations, ${r.pending || 0} pending comments`);
+            break;
+          case 'comments':
+            details = chalk.dim(`${r.total || 0} total, ${r.pending || 0} pending`);
+            break;
+          case 'resolve':
+            details = r.resolved && r.resolved > 0
+              ? chalk.green(`${r.resolved} resolved`)
+              : chalk.dim('no pending');
+            break;
+          case 'strip':
+            details = r.stripped
+              ? chalk.green('cleaned')
+              : chalk.dim('no changes');
+            break;
+        }
+
+        console.log(`  ${statusIcon} ${r.file} ${details}`);
+        if (r.error) {
+          console.log(chalk.red(`    ${r.error}`));
+        }
+      }
+
+      // Summary
+      console.log();
+      const successful = results.filter(r => r.status === 'ok').length;
+      const failed = results.filter(r => r.status === 'error').length;
+      console.log(chalk.dim(`${successful} succeeded, ${failed} failed`));
+    });
+}