docrev 0.10.0 → 0.10.1

package/lib/spelling.ts

@@ -1,334 +1,334 @@
-/**
- * Spelling checker module with global and project dictionaries
- *
- * Uses nspell (Hunspell-compatible) for English spellchecking.
- * Custom words stored in:
- * - ~/.rev-dictionary (global)
- * - .rev-dictionary (project-local)
- */
-
-import * as fs from 'fs';
-import * as path from 'path';
-// @ts-ignore - nspell has no types
-import nspell from 'nspell';
-// @ts-ignore - dictionary-en has no types
-import dictionaryEn from 'dictionary-en';
-// @ts-ignore - dictionary-en-gb has no types
-import dictionaryEnGb from 'dictionary-en-gb';
-import { scientificWords } from './scientific-words.js';
-import type { SpellingIssue, SpellingResult } from './types.js';
-
-const DICT_NAME = '.rev-dictionary';
-
-// Cache for the spellchecker instances (one per language)
-const spellcheckerCache: Record<string, any> = {
-  en: null,
-  'en-gb': null,
-};
-
-interface WordLocation {
-  word: string;
-  line: number;
-  column: number;
-}
-
-interface CheckSpellingOptions {
-  projectDir?: string;
-  lang?: 'en' | 'en-gb';
-}
-
-interface CheckFileOptions {
-  projectDir?: string;
-  lang?: 'en' | 'en-gb';
-}
-
-/**
- * Get the global dictionary path
- */
-export function getGlobalDictPath(): string {
-  const home = process.env.HOME || process.env.USERPROFILE;
-  return path.join(home!, DICT_NAME);
-}
-
-/**
- * Get the project dictionary path
- */
-export function getProjectDictPath(directory: string = '.'): string {
-  return path.join(directory, DICT_NAME);
-}
-
-/**
- * Load custom words from a dictionary file
- */
-export function loadDictionaryFile(dictPath: string): Set<string> {
-  const words = new Set<string>();
-
-  if (fs.existsSync(dictPath)) {
-    const content = fs.readFileSync(dictPath, 'utf-8');
-    for (const line of content.split('\n')) {
-      const word = line.trim();
-      if (word && !word.startsWith('#')) {
-        words.add(word.toLowerCase());
-      }
-    }
-  }
-
-  return words;
-}
-
-/**
- * Save words to a dictionary file
- */
-export function saveDictionaryFile(words: Set<string>, dictPath: string): void {
-  const header = `# Custom dictionary for docrev
-# One word per line, lines starting with # are comments
-`;
-  const content = header + [...words].sort().join('\n') + '\n';
-
-  // Ensure directory exists
-  const dir = path.dirname(dictPath);
-  if (!fs.existsSync(dir)) {
-    fs.mkdirSync(dir, { recursive: true });
-  }
-
-  fs.writeFileSync(dictPath, content, 'utf-8');
-}
-
-/**
- * Load all custom words (global + project)
- */
-export function loadAllCustomWords(projectDir: string = '.'): Set<string> {
-  const globalWords = loadDictionaryFile(getGlobalDictPath());
-  const projectWords = loadDictionaryFile(getProjectDictPath(projectDir));
-
-  return new Set([...globalWords, ...projectWords]);
-}
-
-/**
- * Add word to dictionary
- */
-export function addWord(word: string, global: boolean = true, projectDir: string = '.'): boolean {
-  const dictPath = global ? getGlobalDictPath() : getProjectDictPath(projectDir);
-  const words = loadDictionaryFile(dictPath);
-  const normalizedWord = word.trim().toLowerCase();
-
-  if (words.has(normalizedWord)) {
-    return false;
-  }
-
-  words.add(normalizedWord);
-  saveDictionaryFile(words, dictPath);
-
-  // Clear cache so new word is picked up
-  clearCache();
-
-  return true;
-}
-
-/**
- * Remove word from dictionary
- */
-export function removeWord(word: string, global: boolean = true, projectDir: string = '.'): boolean {
-  const dictPath = global ? getGlobalDictPath() : getProjectDictPath(projectDir);
-  const words = loadDictionaryFile(dictPath);
-  const normalizedWord = word.trim().toLowerCase();
-
-  if (!words.has(normalizedWord)) {
-    return false;
-  }
-
-  words.delete(normalizedWord);
-  saveDictionaryFile(words, dictPath);
-
-  // Clear cache
-  clearCache();
-
-  return true;
-}
-
-/**
- * List words in dictionary
- */
-export function listWords(global: boolean = true, projectDir: string = '.'): string[] {
-  const dictPath = global ? getGlobalDictPath() : getProjectDictPath(projectDir);
-  const words = loadDictionaryFile(dictPath);
-  return [...words].sort();
-}
-
-/**
- * Initialize the spellchecker with custom words
- */
-export async function getSpellchecker(projectDir: string = '.', lang: 'en' | 'en-gb' = 'en'): Promise<any> {
-  if (spellcheckerCache[lang]) {
-    return spellcheckerCache[lang];
-  }
-
-  // Select dictionary based on language
-  const dictionary = lang === 'en-gb' ? dictionaryEnGb : dictionaryEn;
-  const spell = nspell(dictionary);
-
-  // Add scientific/academic words
-  for (const word of scientificWords) {
-    spell.add(word);
-  }
-
-  // Add custom words
-  const customWords = loadAllCustomWords(projectDir);
-  for (const word of customWords) {
-    spell.add(word);
-  }
-
-  spellcheckerCache[lang] = spell;
-  return spell;
-}
-
-/**
- * Clear spellchecker cache (call after modifying dictionaries)
- */
-export function clearCache(): void {
-  spellcheckerCache.en = null;
-  spellcheckerCache['en-gb'] = null;
-}
-
-/**
- * Extract words from text, filtering out non-words
- */
-export function extractWords(text: string): WordLocation[] {
-  const words: WordLocation[] = [];
-  const lines = text.split('\n');
-  let inCodeBlock = false;
-  let inFrontmatter = false;
-
-  for (let lineNum = 0; lineNum < lines.length; lineNum++) {
-    const line = lines[lineNum];
-    if (!line) continue;
-    const trimmed = line.trim();
-
-    // Track YAML frontmatter (only at start of file)
-    if (lineNum === 0 && trimmed === '---') {
-      inFrontmatter = true;
-      continue;
-    }
-    if (inFrontmatter) {
-      if (trimmed === '---') {
-        inFrontmatter = false;
-      }
-      continue;
-    }
-
-    // Track code blocks
-    if (trimmed.startsWith('```')) {
-      inCodeBlock = !inCodeBlock;
-      continue;
-    }
-    if (inCodeBlock) {
-      continue;
-    }
-
-    // Skip URLs and paths
-    if (trimmed.startsWith('http') || trimmed.startsWith('/')) {
-      continue;
-    }
-
-    // Remove markdown syntax, URLs, code spans, LaTeX, etc.
-    let cleanLine = line
-      .replace(/`[^`]+`/g, '')           // inline code
-      .replace(/\[([^\]]+)\]\([^)]+\)/g, '$1')  // links (keep text)
-      .replace(/!\[[^\]]*\]\([^)]+\)/g, '')     // images
-      .replace(/@(fig|tbl|eq):\w+/g, '')        // cross-refs
-      .replace(/\{[^}]+\}/g, '')                // CriticMarkup/templates
-      .replace(/https?:\/\/\S+/g, '')           // URLs
-      .replace(/\$[^$]+\$/g, '')                // inline LaTeX math
-      .replace(/\\\w+/g, '')                    // LaTeX commands like \frac
-      .replace(/[#*_~`>|]/g, ' ');              // markdown chars
-
-    // Extract words (letters and apostrophes only)
-    const wordPattern = /[a-zA-Z][a-zA-Z']*[a-zA-Z]|[a-zA-Z]/g;
-    let match;
-
-    while ((match = wordPattern.exec(cleanLine)) !== null) {
-      const word = match[0];
-
-      // Skip:
-      // - Very short words (1-2 chars)
-      // - All caps (acronyms like NASA)
-      // - File extensions (.md, .tex, .png)
-      // - CamelCase (likely code or citations like vanKleunen)
-      // - Words starting with capital in middle of sentence (proper nouns/names)
-      if (word.length < 3 ||
-          /^[A-Z]+$/.test(word) ||
-          /^\w{2,4}$/.test(word) && /^(md|tex|png|jpg|pdf|csv|js|py|html|css|yaml|json|docx|bib)$/i.test(word) ||
-          /[a-z][A-Z]/.test(word)) {
-        continue;
-      }
-
-      words.push({
-        word,
-        line: lineNum + 1,
-        column: match.index + 1,
-      });
-    }
-  }
-
-  return words;
-}
-
-/**
- * Check if a word looks like a proper noun (name)
- */
-function looksLikeName(word: string): boolean {
-  // Capitalized, not all caps, reasonable length for a name
-  return /^[A-Z][a-z]{2,}$/.test(word);
-}
-
-/**
- * Check spelling in text
- */
-export async function checkSpelling(text: string, options: CheckSpellingOptions = {}): Promise<SpellingResult> {
-  const { projectDir = '.', lang = 'en' } = options;
-  const spell = await getSpellchecker(projectDir, lang);
-  const words = extractWords(text);
-  const misspelled: SpellingIssue[] = [];
-  const possibleNames: SpellingIssue[] = [];
-  const seen = new Set<string>();
-  const seenNames = new Set<string>();
-
-  for (const { word, line, column } of words) {
-    // Skip if already reported this word
-    const key = word.toLowerCase();
-    if (seen.has(key) || seenNames.has(key)) {
-      continue;
-    }
-
-    if (!spell.correct(word)) {
-      // Check if it looks like a proper noun/name
-      if (looksLikeName(word)) {
-        seenNames.add(key);
-        possibleNames.push({ word, line, column });
-      } else {
-        seen.add(key);
-        misspelled.push({
-          word,
-          line,
-          column,
-          suggestions: spell.suggest(word).slice(0, 5),
-        });
-      }
-    }
-  }
-
-  return { misspelled, possibleNames };
-}
-
-/**
- * Check spelling in a file
- */
-export async function checkFile(filePath: string, options: CheckFileOptions = {}): Promise<SpellingResult> {
-  const text = fs.readFileSync(filePath, 'utf-8');
-  const result = await checkSpelling(text, options);
-
-  return {
-    misspelled: result.misspelled.map(issue => ({ ...issue, file: filePath })),
-    possibleNames: result.possibleNames.map(issue => ({ ...issue, file: filePath })),
-  };
-}
+/**
+ * Spelling checker module with global and project dictionaries
+ *
+ * Uses nspell (Hunspell-compatible) for English spellchecking.
+ * Custom words stored in:
+ * - ~/.rev-dictionary (global)
+ * - .rev-dictionary (project-local)
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+// @ts-ignore - nspell has no types
+import nspell from 'nspell';
+// @ts-ignore - dictionary-en has no types
+import dictionaryEn from 'dictionary-en';
+// @ts-ignore - dictionary-en-gb has no types
+import dictionaryEnGb from 'dictionary-en-gb';
+import { scientificWords } from './scientific-words.js';
+import type { SpellingIssue, SpellingResult } from './types.js';
+
+const DICT_NAME = '.rev-dictionary';
+
+// Cache for the spellchecker instances (one per language)
+const spellcheckerCache: Record<string, any> = {
+  en: null,
+  'en-gb': null,
+};
+
+interface WordLocation {
+  word: string;
+  line: number;
+  column: number;
+}
+
+interface CheckSpellingOptions {
+  projectDir?: string;
+  lang?: 'en' | 'en-gb';
+}
+
+interface CheckFileOptions {
+  projectDir?: string;
+  lang?: 'en' | 'en-gb';
+}
+
+/**
+ * Get the global dictionary path
+ */
+export function getGlobalDictPath(): string {
+  const home = process.env.HOME || process.env.USERPROFILE;
+  return path.join(home!, DICT_NAME);
+}
+
+/**
+ * Get the project dictionary path
+ */
+export function getProjectDictPath(directory: string = '.'): string {
+  return path.join(directory, DICT_NAME);
+}
+
+/**
+ * Load custom words from a dictionary file
+ */
+export function loadDictionaryFile(dictPath: string): Set<string> {
+  const words = new Set<string>();
+
+  if (fs.existsSync(dictPath)) {
+    const content = fs.readFileSync(dictPath, 'utf-8');
+    for (const line of content.split('\n')) {
+      const word = line.trim();
+      if (word && !word.startsWith('#')) {
+        words.add(word.toLowerCase());
+      }
+    }
+  }
+
+  return words;
+}
+
+/**
+ * Save words to a dictionary file
+ */
+export function saveDictionaryFile(words: Set<string>, dictPath: string): void {
+  const header = `# Custom dictionary for docrev
+# One word per line, lines starting with # are comments
+`;
+  const content = header + [...words].sort().join('\n') + '\n';
+
+  // Ensure directory exists
+  const dir = path.dirname(dictPath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+
+  fs.writeFileSync(dictPath, content, 'utf-8');
+}
+
+/**
+ * Load all custom words (global + project)
+ */
+export function loadAllCustomWords(projectDir: string = '.'): Set<string> {
+  const globalWords = loadDictionaryFile(getGlobalDictPath());
+  const projectWords = loadDictionaryFile(getProjectDictPath(projectDir));
+
+  return new Set([...globalWords, ...projectWords]);
+}
+
+/**
+ * Add word to dictionary
+ */
+export function addWord(word: string, global: boolean = true, projectDir: string = '.'): boolean {
+  const dictPath = global ? getGlobalDictPath() : getProjectDictPath(projectDir);
+  const words = loadDictionaryFile(dictPath);
+  const normalizedWord = word.trim().toLowerCase();
+
+  if (words.has(normalizedWord)) {
+    return false;
+  }
+
+  words.add(normalizedWord);
+  saveDictionaryFile(words, dictPath);
+
+  // Clear cache so new word is picked up
+  clearCache();
+
+  return true;
+}
+
+/**
+ * Remove word from dictionary
+ */
+export function removeWord(word: string, global: boolean = true, projectDir: string = '.'): boolean {
+  const dictPath = global ? getGlobalDictPath() : getProjectDictPath(projectDir);
+  const words = loadDictionaryFile(dictPath);
+  const normalizedWord = word.trim().toLowerCase();
+
+  if (!words.has(normalizedWord)) {
+    return false;
+  }
+
+  words.delete(normalizedWord);
+  saveDictionaryFile(words, dictPath);
+
+  // Clear cache
+  clearCache();
+
+  return true;
+}
+
+/**
+ * List words in dictionary
+ */
+export function listWords(global: boolean = true, projectDir: string = '.'): string[] {
+  const dictPath = global ? getGlobalDictPath() : getProjectDictPath(projectDir);
+  const words = loadDictionaryFile(dictPath);
+  return [...words].sort();
+}
+
+/**
+ * Initialize the spellchecker with custom words
+ */
+export async function getSpellchecker(projectDir: string = '.', lang: 'en' | 'en-gb' = 'en'): Promise<any> {
+  if (spellcheckerCache[lang]) {
+    return spellcheckerCache[lang];
+  }
+
+  // Select dictionary based on language
+  const dictionary = lang === 'en-gb' ? dictionaryEnGb : dictionaryEn;
+  const spell = nspell(dictionary);
+
+  // Add scientific/academic words
+  for (const word of scientificWords) {
+    spell.add(word);
+  }
+
+  // Add custom words
+  const customWords = loadAllCustomWords(projectDir);
+  for (const word of customWords) {
+    spell.add(word);
+  }
+
+  spellcheckerCache[lang] = spell;
+  return spell;
+}
+
+/**
+ * Clear spellchecker cache (call after modifying dictionaries)
+ */
+export function clearCache(): void {
+  spellcheckerCache.en = null;
+  spellcheckerCache['en-gb'] = null;
+}
+
+/**
+ * Extract words from text, filtering out non-words
+ */
+export function extractWords(text: string): WordLocation[] {
+  const words: WordLocation[] = [];
+  const lines = text.split('\n');
+  let inCodeBlock = false;
+  let inFrontmatter = false;
+
+  for (let lineNum = 0; lineNum < lines.length; lineNum++) {
+    const line = lines[lineNum];
+    if (!line) continue;
+    const trimmed = line.trim();
+
+    // Track YAML frontmatter (only at start of file)
+    if (lineNum === 0 && trimmed === '---') {
+      inFrontmatter = true;
+      continue;
+    }
+    if (inFrontmatter) {
+      if (trimmed === '---') {
+        inFrontmatter = false;
+      }
+      continue;
+    }
+
+    // Track code blocks
+    if (trimmed.startsWith('```')) {
+      inCodeBlock = !inCodeBlock;
+      continue;
+    }
+    if (inCodeBlock) {
+      continue;
+    }
+
+    // Skip URLs and paths
+    if (trimmed.startsWith('http') || trimmed.startsWith('/')) {
+      continue;
+    }
+
+    // Remove markdown syntax, URLs, code spans, LaTeX, etc.
+    let cleanLine = line
+      .replace(/`[^`]+`/g, '')           // inline code
+      .replace(/\[([^\]]+)\]\([^)]+\)/g, '$1')  // links (keep text)
+      .replace(/!\[[^\]]*\]\([^)]+\)/g, '')     // images
+      .replace(/@(fig|tbl|eq):\w+/g, '')        // cross-refs
+      .replace(/\{[^}]+\}/g, '')                // CriticMarkup/templates
+      .replace(/https?:\/\/\S+/g, '')           // URLs
+      .replace(/\$[^$]+\$/g, '')                // inline LaTeX math
+      .replace(/\\\w+/g, '')                    // LaTeX commands like \frac
+      .replace(/[#*_~`>|]/g, ' ');              // markdown chars
+
+    // Extract words (letters and apostrophes only)
+    const wordPattern = /[a-zA-Z][a-zA-Z']*[a-zA-Z]|[a-zA-Z]/g;
+    let match;
+
+    while ((match = wordPattern.exec(cleanLine)) !== null) {
+      const word = match[0];
+
+      // Skip:
+      // - Very short words (1-2 chars)
+      // - All caps (acronyms like NASA)
+      // - File extensions (.md, .tex, .png)
+      // - CamelCase (likely code or citations like vanKleunen)
+      // - Words starting with capital in middle of sentence (proper nouns/names)
+      if (word.length < 3 ||
+          /^[A-Z]+$/.test(word) ||
+          /^\w{2,4}$/.test(word) && /^(md|tex|png|jpg|pdf|csv|js|py|html|css|yaml|json|docx|bib)$/i.test(word) ||
+          /[a-z][A-Z]/.test(word)) {
+        continue;
+      }
+
+      words.push({
+        word,
+        line: lineNum + 1,
+        column: match.index + 1,
+      });
+    }
+  }
+
+  return words;
+}
+
+/**
+ * Check if a word looks like a proper noun (name)
+ */
+function looksLikeName(word: string): boolean {
+  // Capitalized, not all caps, reasonable length for a name
+  return /^[A-Z][a-z]{2,}$/.test(word);
+}
+
+/**
+ * Check spelling in text
+ */
+export async function checkSpelling(text: string, options: CheckSpellingOptions = {}): Promise<SpellingResult> {
+  const { projectDir = '.', lang = 'en' } = options;
+  const spell = await getSpellchecker(projectDir, lang);
+  const words = extractWords(text);
+  const misspelled: SpellingIssue[] = [];
+  const possibleNames: SpellingIssue[] = [];
+  const seen = new Set<string>();
+  const seenNames = new Set<string>();
+
+  for (const { word, line, column } of words) {
+    // Skip if already reported this word
+    const key = word.toLowerCase();
+    if (seen.has(key) || seenNames.has(key)) {
+      continue;
+    }
+
+    if (!spell.correct(word)) {
+      // Check if it looks like a proper noun/name
+      if (looksLikeName(word)) {
+        seenNames.add(key);
+        possibleNames.push({ word, line, column });
+      } else {
+        seen.add(key);
+        misspelled.push({
+          word,
+          line,
+          column,
+          suggestions: spell.suggest(word).slice(0, 5),
+        });
+      }
+    }
+  }
+
+  return { misspelled, possibleNames };
+}
+
+/**
+ * Check spelling in a file
+ */
+export async function checkFile(filePath: string, options: CheckFileOptions = {}): Promise<SpellingResult> {
+  const text = fs.readFileSync(filePath, 'utf-8');
+  const result = await checkSpelling(text, options);
+
+  return {
+    misspelled: result.misspelled.map(issue => ({ ...issue, file: filePath })),
+    possibleNames: result.possibleNames.map(issue => ({ ...issue, file: filePath })),
+  };
+}