docrev 0.2.0 → 0.2.1

package/CLAUDE.md

@@ -1,6 +1,6 @@
-# Claude Instructions for rev
+# Claude Instructions for docrev
 
-This is `rev`, a CLI tool for academic paper workflows with Word ↔ Markdown round-trips.
+This is `docrev` (command: `rev`), a CLI tool for academic paper workflows with Word ↔ Markdown round-trips.
 
 ## Key Commands for Claude
 

package/README.md

@@ -41,9 +41,12 @@ rev install    # Check for missing dependencies
 - **Import from Word** - Diff Word docs against your Markdown, generating CriticMarkup annotations
 - **Section-aware import** - Import directly to modular section files (intro.md, methods.md, etc.)
 - **Interactive review** - Accept/reject track changes with a TUI
-- **Comment management** - List and filter reviewer comments
+- **Comment management** - List, filter, resolve, and reply to reviewer comments
+- **Response letter generation** - Auto-generate point-by-point response from comments
 - **DOI validation** - Check and find DOIs via Crossref/DataCite APIs
-- **Cross-reference conversion** - Auto-convert hardcoded "Figure 1" to dynamic `@fig:label` syntax
+- **Cross-reference conversion** - Auto-convert "Figures 1-3" to `@fig:label` syntax (handles complex patterns)
+- **Equation extraction** - Extract LaTeX equations from Word documents (OMML → LaTeX)
+- **Citation validation** - Check citations against bibliography
 
 ## Quick Start
 
@@ -114,6 +117,7 @@ rev build docx
 | Command | Description |
 |---------|-------------|
 | `rev build [formats...]` | Build PDF/DOCX/TEX from sections |
+| `rev build --toc` | Build with table of contents |
 | `rev new <name>` | Create new project from template |
 | `rev new --list` | List available templates |
 | `rev install` | Check/install dependencies (pandoc-crossref) |
@@ -134,6 +138,8 @@ rev build docx
 | `rev review <file>` | Interactive accept/reject TUI for track changes |
 | `rev status <file>` | Show annotation counts |
 | `rev comments <file>` | List all comments with context |
+| `rev comments <file> --export comments.csv` | Export comments to CSV |
+| `rev resolve <file> -n 1` | Mark comment #1 as resolved |
 | `rev strip <file>` | Output clean Markdown (annotations applied) |
 
 ### Cross-References
@@ -160,6 +166,17 @@ rev build docx
 | `rev doi fetch <doi>` | Fetch BibTeX entry from DOI |
 | `rev doi add <doi>` | Fetch and add DOI entry to bibliography |
 
+### Validation & Analysis
+
+| Command | Description |
+|---------|-------------|
+| `rev citations [file.bib]` | Validate citations against bibliography |
+| `rev figures [file]` | List figures/tables with reference counts |
+| `rev equations list` | List all equations in section files |
+| `rev equations from-word <docx>` | Extract equations from Word to LaTeX |
+| `rev response [files]` | Generate response letter from comments |
+| `rev anonymize <file>` | Prepare document for blind review |
+
 ### Configuration
 
 | Command | Description |
@@ -215,10 +232,12 @@ pdf:
   fontsize: 12pt
   geometry: margin=1in
   linestretch: 1.5
+  toc: false                 # Table of contents
 
 docx:
   reference: template.docx   # Optional reference doc
   keepComments: true
+  toc: false                 # Table of contents
 ```
 
 ## Annotation Syntax (CriticMarkup)
@@ -266,6 +285,9 @@ When importing from Word, hardcoded refs are auto-converted:
 - `Figure 1` → `@fig:heatmap`
 - `Fig. 2a` → `@fig:model`
 - `Figs. 1-3` → `@fig:heatmap; @fig:model; @fig:hierarchy`
+- `Figures 1, 2, and 3` → `@fig:one; @fig:two; @fig:three`
+- `Fig. 1a-c` → `@fig:one` (expands letter suffixes)
+- `Figs. 1a-3b` → all panels from 1a to 3b
 
 ## Build Outputs
 

package/bin/rev.js

@@ -48,7 +48,7 @@ import * as fmt from '../lib/format.js';
 import { inlineDiffPreview } from '../lib/format.js';
 import { parseCommentsWithReplies, collectComments, generateResponseLetter, groupByReviewer } from '../lib/response.js';
 import { validateCitations, getCitationStats } from '../lib/citations.js';
-import { extractEquations, getEquationStats, createEquationsDoc } from '../lib/equations.js';
+import { extractEquations, getEquationStats, createEquationsDoc, extractEquationsFromWord, getWordEquationStats } from '../lib/equations.js';
 import { parseBibEntries, checkBibDois, fetchBibtex, addToBib, isValidDoiFormat, lookupDoi, lookupMissingDois } from '../lib/doi.js';
 
 program
@@ -185,6 +185,7 @@ program
   .argument('<file>', 'Markdown file')
   .option('-p, --pending', 'Show only pending (unresolved) comments')
   .option('-r, --resolved', 'Show only resolved comments')
+  .option('-e, --export <csvFile>', 'Export comments to CSV file')
   .action((file, options) => {
     if (!fs.existsSync(file)) {
       console.error(chalk.red(`Error: File not found: ${file}`));
@@ -197,6 +198,34 @@ program
       resolvedOnly: options.resolved,
     });
 
+    // CSV export mode
+    if (options.export) {
+      const csvEscape = (str) => {
+        if (!str) return '';
+        str = String(str);
+        if (str.includes(',') || str.includes('"') || str.includes('\n')) {
+          return '"' + str.replace(/"/g, '""') + '"';
+        }
+        return str;
+      };
+
+      const header = ['number', 'author', 'comment', 'context', 'status', 'file', 'line'];
+      const rows = comments.map((c, i) => [
+        i + 1,
+        csvEscape(c.author || ''),
+        csvEscape(c.content),
+        csvEscape(c.before ? c.before.trim() : ''),
+        c.resolved ? 'resolved' : 'pending',
+        path.basename(file),
+        c.line,
+      ].join(','));
+
+      const csv = [header.join(','), ...rows].join('\n');
+      fs.writeFileSync(options.export, csv, 'utf-8');
+      console.log(fmt.status('success', `Exported ${comments.length} comments to ${options.export}`));
+      return;
+    }
+
     if (comments.length === 0) {
       if (options.pending) {
         console.log(fmt.status('success', 'No pending comments'));
@@ -1351,6 +1380,7 @@ program
   .argument('[formats...]', 'Output formats: pdf, docx, tex, all', ['pdf', 'docx'])
   .option('-d, --dir <directory>', 'Project directory', '.')
   .option('--no-crossref', 'Skip pandoc-crossref filter')
+  .option('--toc', 'Include table of contents')
   .action(async (formats, options) => {
     const dir = path.resolve(options.dir);
 
@@ -1380,15 +1410,24 @@ program
 
     // Show what we're building
     const targetFormats = formats.length > 0 ? formats : ['pdf', 'docx'];
+    const tocEnabled = options.toc || config.pdf?.toc || config.docx?.toc;
     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`));
     console.log('');
 
+    // Override config with CLI options
+    if (options.toc) {
+      config.pdf.toc = true;
+      config.docx.toc = true;
+    }
+
     const spin = fmt.spinner('Building...').start();
 
     try {
       const { results, paperPath } = await build(dir, targetFormats, {
         crossref: options.crossref,
+        config, // Pass modified config
       });
 
       spin.stop();
@@ -1687,6 +1726,123 @@ program
     console.log(fmt.status('success', `Created ${outputPath}`));
   });
 
+// ============================================================================
+// ANONYMIZE command - Prepare document for blind review
+// ============================================================================
+
+program
+  .command('anonymize')
+  .description('Prepare document for blind review')
+  .argument('<input>', 'Input markdown file or directory')
+  .option('-o, --output <file>', 'Output file (default: input-anonymous.md)')
+  .option('--authors <names>', 'Author names to redact (comma-separated)')
+  .option('--dry-run', 'Show what would be changed without writing')
+  .action((input, options) => {
+    const isDir = fs.existsSync(input) && fs.statSync(input).isDirectory();
+    const files = isDir
+      ? fs.readdirSync(input)
+          .filter(f => f.endsWith('.md') && !['README.md', 'CLAUDE.md'].includes(f))
+          .map(f => path.join(input, f))
+      : [input];
+
+    if (files.length === 0) {
+      console.error(fmt.status('error', 'No markdown files found'));
+      process.exit(1);
+    }
+
+    // Get author names to redact
+    let authorNames = [];
+    if (options.authors) {
+      authorNames = options.authors.split(',').map(n => n.trim());
+    } else {
+      // Try to load from rev.yaml
+      const configPath = isDir ? path.join(input, 'rev.yaml') : 'rev.yaml';
+      if (fs.existsSync(configPath)) {
+        try {
+          const config = yaml.load(fs.readFileSync(configPath, 'utf-8'));
+          if (config.authors) {
+            authorNames = config.authors.map(a => typeof a === 'string' ? a : a.name).filter(Boolean);
+          }
+        } catch { /* ignore */ }
+      }
+    }
+
+    console.log(fmt.header('Anonymizing Document'));
+    console.log();
+
+    let totalChanges = 0;
+
+    for (const file of files) {
+      if (!fs.existsSync(file)) {
+        console.error(chalk.yellow(`  Skipping: ${file} (not found)`));
+        continue;
+      }
+
+      let text = fs.readFileSync(file, 'utf-8');
+      let changes = 0;
+
+      // Remove YAML frontmatter author block
+      text = text.replace(/^---\n([\s\S]*?)\n---/, (match, fm) => {
+        let modified = fm;
+        // Remove author/authors field
+        modified = modified.replace(/^author:.*(?:\n(?:  |\t).*)*$/m, '');
+        modified = modified.replace(/^authors:.*(?:\n(?:  |\t|-\s+).*)*$/m, '');
+        // Remove affiliation/email
+        modified = modified.replace(/^affiliation:.*$/m, '');
+        modified = modified.replace(/^email:.*$/m, '');
+        if (modified !== fm) changes++;
+        return '---\n' + modified.replace(/\n{3,}/g, '\n\n').trim() + '\n---';
+      });
+
+      // Remove acknowledgments section
+      const ackPatterns = [
+        /^#+\s*Acknowledgments?[\s\S]*?(?=^#|\Z)/gmi,
+        /^#+\s*Funding[\s\S]*?(?=^#|\Z)/gmi,
+      ];
+      for (const pattern of ackPatterns) {
+        const before = text;
+        text = text.replace(pattern, '');
+        if (text !== before) changes++;
+      }
+
+      // Redact author names
+      for (const name of authorNames) {
+        const namePattern = new RegExp(`\\b${name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`, 'gi');
+        const before = text;
+        text = text.replace(namePattern, '[AUTHOR]');
+        if (text !== before) changes++;
+      }
+
+      // Replace self-citations: @AuthorLastName2024 -> @AUTHOR2024
+      for (const name of authorNames) {
+        const lastName = name.split(/\s+/).pop();
+        if (lastName && lastName.length > 2) {
+          const citePat = new RegExp(`@${lastName}(\\d{4})`, 'gi');
+          const before = text;
+          text = text.replace(citePat, '@AUTHOR$1');
+          if (text !== before) changes++;
+        }
+      }
+
+      totalChanges += changes;
+
+      if (options.dryRun) {
+        console.log(chalk.dim(`  ${path.basename(file)}: ${changes} change(s)`));
+      } else {
+        const outPath = options.output || file.replace(/\.md$/, '-anonymous.md');
+        fs.writeFileSync(outPath, text, 'utf-8');
+        console.log(fmt.status('success', `${path.basename(file)} → ${path.basename(outPath)} (${changes} changes)`));
+      }
+    }
+
+    console.log();
+    if (options.dryRun) {
+      console.log(chalk.dim(`  Total: ${totalChanges} change(s) would be made`));
+    } else {
+      console.log(fmt.status('success', `Anonymized ${files.length} file(s)`));
+    }
+  });
+
 // ============================================================================
 // CITATIONS command - Validate citations against .bib file
 // ============================================================================
@@ -1862,11 +2018,72 @@ program
   .command('equations')
   .alias('eq')
   .description('Extract equations or convert to Word')
-  .argument('<action>', 'Action: list, extract, convert')
-  .argument('[input]', 'Input file (for extract/convert)')
+  .argument('<action>', 'Action: list, extract, convert, from-word')
+  .argument('[input]', 'Input file (.md for extract/convert, .docx for from-word)')
   .option('-o, --output <file>', 'Output file')
   .action(async (action, input, options) => {
-    if (action === 'list') {
+    if (action === 'from-word') {
+      // Extract equations from Word document
+      if (!input) {
+        console.error(fmt.status('error', 'Word document required'));
+        process.exit(1);
+      }
+
+      if (!input.endsWith('.docx')) {
+        console.error(fmt.status('error', 'Input must be a .docx file'));
+        process.exit(1);
+      }
+
+      const spin = fmt.spinner(`Extracting equations from ${path.basename(input)}...`).start();
+
+      const result = await extractEquationsFromWord(input);
+
+      if (!result.success) {
+        spin.error(result.error);
+        process.exit(1);
+      }
+
+      spin.stop();
+      console.log(fmt.header('Equations from Word'));
+      console.log();
+
+      if (result.equations.length === 0) {
+        console.log(chalk.dim('No equations found in document.'));
+        return;
+      }
+
+      const display = result.equations.filter(e => e.type === 'display');
+      const inline = result.equations.filter(e => e.type === 'inline');
+
+      console.log(chalk.dim(`Found ${result.equations.length} equations (${display.length} display, ${inline.length} inline)`));
+      console.log();
+
+      // Show equations
+      for (let i = 0; i < result.equations.length; i++) {
+        const eq = result.equations[i];
+        const typeLabel = eq.type === 'display' ? chalk.cyan('[display]') : chalk.yellow('[inline]');
+
+        if (eq.latex) {
+          console.log(`${chalk.bold(i + 1)}. ${typeLabel}`);
+          console.log(chalk.dim('   LaTeX:'), eq.latex.length > 80 ? eq.latex.substring(0, 77) + '...' : eq.latex);
+        } else {
+          console.log(`${chalk.bold(i + 1)}. ${typeLabel} ${chalk.red('[conversion failed]')}`);
+        }
+      }
+
+      // Optionally save to file
+      if (options.output) {
+        const latex = result.equations
+          .filter(e => e.latex)
+          .map((e, i) => `%% Equation ${i + 1} (${e.type})\n${e.type === 'display' ? '$$' : '$'}${e.latex}${e.type === 'display' ? '$$' : '$'}`)
+          .join('\n\n');
+
+        fs.writeFileSync(options.output, latex, 'utf-8');
+        console.log();
+        console.log(fmt.status('success', `Saved ${result.equations.filter(e => e.latex).length} equations to ${options.output}`));
+      }
+
+    } else if (action === 'list') {
       // List equations in all section files
       const mdFiles = fs.readdirSync('.').filter(f =>
         f.endsWith('.md') && !['README.md', 'CLAUDE.md'].includes(f)
@@ -1935,7 +2152,7 @@ program
       }
     } else {
       console.error(fmt.status('error', `Unknown action: ${action}`));
-      console.log(chalk.dim('Actions: list, extract, convert'));
+      console.log(chalk.dim('Actions: list, extract, convert, from-word'));
       process.exit(1);
     }
   });

package/lib/build.js

@@ -39,10 +39,12 @@ export const DEFAULT_CONFIG = {
     geometry: 'margin=1in',
     linestretch: 1.5,
     numbersections: false,
+    toc: false,
   },
   docx: {
     reference: null,
     keepComments: true,
+    toc: false,
   },
   tex: {
     standalone: true,
@@ -317,10 +319,16 @@ export function buildPandocArgs(format, config, outputPath) {
     if (config.pdf.numbersections) {
       args.push('--number-sections');
     }
+    if (config.pdf.toc) {
+      args.push('--toc');
+    }
   } else if (format === 'docx') {
     if (config.docx.reference) {
       args.push('--reference-doc', config.docx.reference);
     }
+    if (config.docx.toc) {
+      args.push('--toc');
+    }
   }
 
   return args;
@@ -434,8 +442,8 @@ export async function build(directory, formats = ['pdf', 'docx'], options = {})
     throw new Error('pandoc not found. Run `rev install` to install dependencies.');
   }
 
-  // Load config
-  const config = loadConfig(directory);
+  // Load config (use passed config if provided, otherwise load from file)
+  const config = options.config || loadConfig(directory);
 
   // Combine sections → paper.md
   const paperPath = combineSections(directory, config, options);

package/lib/crossref.js

@@ -12,20 +12,26 @@ import * as path from 'path';
 
 /**
  * Patterns for detecting hardcoded references
- * Matches: Figure 1, Fig. 1a, fig 1b-c, Figs. 1-3, Table S1, etc.
- * Includes optional letter suffixes for sub-panels (a, b, c, etc.)
+ * Matches complex patterns including:
+ * - Simple: "Figure 1", "Fig. 2a", "Table S1"
+ * - Ranges: "Figures 1-3", "Fig. 1a-c", "Figs. 1a-3b"
+ * - Lists: "Figures 1, 2, and 3", "Fig. 1a, b, c", "Tables 1 & 2"
+ * - Mixed: "Figs. 1, 3-5, and 7"
+ *
+ * Uses a simpler base pattern and parses the full match for lists
  */
 const DETECTION_PATTERNS = {
-  // Figures: Fig, Fig., fig, figure, Figure, FIGURE, Figs, Figures (plural)
-  // With optional letter suffix: 1a, 1b, 2a-c, etc.
-  figure: /\b(Figures?|Figs?\.?)\s*(\d+|S\d+)([a-z])?(?:\s*[-–—&,]\s*(\d+|S\d+)?([a-z])?)?\b/gi,
+  // Captures the full reference including lists with "and"
+  // Group 1: type prefix (Figure, Fig., etc.)
+  // Group 2: reference list (parsed by parseReferenceList())
+  // Matches: "1", "1a", "1-3", "1a-c", "1, 2, 3", "1 and 2", "1, 2 and 3", "1, 2, and 3"
+  // Separator: comma/dash/ampersand, optionally followed by "and"
+  // Standalone letters must be followed by separator, punctuation, or word boundary
+  figure: /\b(Figures?|Figs?\.?)\s+((?:\d+|S\d+)[a-z]?(?:(?:\s*[-–—,&]\s*(?:and\s+)?|\s+and\s+)(?:(?:\d+|S\d+)[a-z]?|[a-z]\b))*)/gi,
 
-  // Tables: Tab, Tab., tab, table, Table, TABLE, Tabs, Tables (plural)
-  // With optional letter suffix for sub-tables
-  table: /\b(Tables?|Tabs?\.?)\s*(\d+|S\d+)([a-z])?(?:\s*[-–—&,]\s*(\d+|S\d+)?([a-z])?)?\b/gi,
+  table: /\b(Tables?|Tabs?\.?)\s+((?:\d+|S\d+)[a-z]?(?:(?:\s*[-–—,&]\s*(?:and\s+)?|\s+and\s+)(?:(?:\d+|S\d+)[a-z]?|[a-z]\b))*)/gi,
 
-  // Equations: Eq, Eq., eq, equation, Equation
-  equation: /\b(Equations?|Eqs?\.?)\s*(\d+)([a-z])?(?:\s*[-–—&,]\s*(\d+)?([a-z])?)?\b/gi,
+  equation: /\b(Equations?|Eqs?\.?)\s+((?:\d+)[a-z]?(?:(?:\s*[-–—,&]\s*(?:and\s+)?|\s+and\s+)(?:(?:\d+)[a-z]?|[a-z]\b))*)/gi,
 };
 
 /**
@@ -68,6 +74,120 @@ export function parseRefNumber(numStr, suffix = null) {
   return { isSupp, num, suffix: extractedSuffix ? extractedSuffix.toLowerCase() : null };
 }
 
+/**
+ * Parse a reference list string like "1, 2, and 3" or "1a-c" or "1a-3b"
+ * Returns an array of {num, isSupp, suffix} objects
+ *
+ * @param {string} listStr - e.g., "1, 2, and 3", "1a-c", "1a-3b", "1a, b, c"
+ * @returns {Array<{num: number, isSupp: boolean, suffix: string|null}>}
+ */
+export function parseReferenceList(listStr) {
+  const results = [];
+  if (!listStr) return results;
+
+  // Normalize: replace "and" with comma, normalize dashes
+  let normalized = listStr
+    .replace(/\s+and\s+/gi, ', ')
+    .replace(/[–—]/g, '-')   // en-dash, em-dash → hyphen
+    .replace(/&/g, ', ');    // & → comma
+
+  // Split by comma (but not by dash, which indicates ranges)
+  const parts = normalized.split(/\s*,\s*/).filter(p => p.trim());
+
+  let lastFullRef = null; // Track the last full reference for implicit prefixes
+
+  for (const part of parts) {
+    const trimmed = part.trim();
+    if (!trimmed) continue;
+
+    // Check if this is a range (contains -)
+    if (trimmed.includes('-')) {
+      const [start, end] = trimmed.split('-').map(s => s.trim());
+
+      // Check if end is just a letter (e.g., "1a-c" where end is "c")
+      const endIsLetterOnly = /^[a-z]$/i.test(end);
+
+      const startRef = parseRefNumber(start);
+      // For letter-only end, don't parse as number
+      const endRef = endIsLetterOnly
+        ? { num: startRef.num, isSupp: startRef.isSupp, suffix: end.toLowerCase() }
+        : parseRefNumber(end);
+
+      // Handle different range types:
+      // 1. Suffix-only range on same number: "1a-c" → 1a, 1b, 1c
+      // 2. Number range: "1-3" → 1, 2, 3
+      // 3. Cross-number suffix range: "1a-3b" → 1a...1z, 2a...2z, 3a, 3b (limited)
+
+      if (startRef.suffix && endRef.suffix && startRef.num !== endRef.num) {
+        // Cross-number suffix range: "1a-3b"
+        // For academic papers, limit intermediate figures to same suffix range
+        // e.g., "1a-3b" typically means 1a, 1b, 2a, 2b, 3a, 3b
+        const maxSuffix = Math.max(
+          startRef.suffix.charCodeAt(0),
+          endRef.suffix.charCodeAt(0)
+        );
+
+        for (let n = startRef.num; n <= endRef.num; n++) {
+          const suffixStart = (n === startRef.num) ? startRef.suffix.charCodeAt(0) : 'a'.charCodeAt(0);
+          const suffixEnd = (n === endRef.num) ? endRef.suffix.charCodeAt(0) : maxSuffix;
+
+          for (let s = suffixStart; s <= suffixEnd; s++) {
+            results.push({
+              num: n,
+              isSupp: startRef.isSupp,
+              suffix: String.fromCharCode(s)
+            });
+          }
+        }
+        lastFullRef = { num: endRef.num, isSupp: startRef.isSupp };
+      } else if (startRef.suffix || endRef.suffix) {
+        // Suffix range on same number: "1a-c"
+        const num = startRef.num || (lastFullRef ? lastFullRef.num : 1);
+        const isSupp = startRef.isSupp || (lastFullRef ? lastFullRef.isSupp : false);
+        const startCode = (startRef.suffix || 'a').charCodeAt(0);
+        const endCode = (endRef.suffix || 'a').charCodeAt(0);
+
+        for (let code = startCode; code <= endCode; code++) {
+          results.push({
+            num,
+            isSupp,
+            suffix: String.fromCharCode(code)
+          });
+        }
+        lastFullRef = { num, isSupp };
+      } else {
+        // Pure number range: "1-3"
+        for (let n = startRef.num; n <= endRef.num; n++) {
+          results.push({
+            num: n,
+            isSupp: startRef.isSupp,
+            suffix: null
+          });
+        }
+        lastFullRef = { num: endRef.num, isSupp: startRef.isSupp };
+      }
+    } else {
+      // Single reference or implicit suffix
+      // Check if it's just a letter (implicit prefix from previous number)
+      if (/^[a-z]$/i.test(trimmed) && lastFullRef) {
+        // Implicit prefix: "b" after "1a" means "1b"
+        results.push({
+          num: lastFullRef.num,
+          isSupp: lastFullRef.isSupp,
+          suffix: trimmed.toLowerCase()
+        });
+      } else {
+        // Full reference: "1", "1a", "S1", "S1a"
+        const ref = parseRefNumber(trimmed);
+        results.push(ref);
+        lastFullRef = { num: ref.num, isSupp: ref.isSupp };
+      }
+    }
+  }
+
+  return results;
+}
+
 /**
  * Build a registry of figure/table labels from .md files
  * Scans for {#fig:label} and {#tbl:label} anchors
@@ -232,46 +352,15 @@ export function detectHardcodedRefs(text) {
     let match;
 
     while ((match = pattern.exec(text)) !== null) {
-      const numbers = [];
-
       // Pattern groups:
-      // [1] = type (Figure, Fig., etc.)
-      // [2] = first number (1, S1)
-      // [3] = first suffix (a, b) - optional
-      // [4] = second number for range (2, S2) - optional
-      // [5] = second suffix (b, c) - optional
-
-      // Parse first number with optional suffix
-      const first = parseRefNumber(match[2], match[3]);
-      numbers.push(first);
-
-      // Parse second number/suffix if present (range like 1a-c or 1-3)
-      if (match[4] || match[5]) {
-        const second = parseRefNumber(match[4] || match[2], match[5]);
-
-        // Handle suffix-only ranges (e.g., "1a-c" means 1a, 1b, 1c)
-        if (!match[4] && match[5] && first.suffix) {
-          // Expand letter range: a-c → a, b, c
-          const startCode = first.suffix.charCodeAt(0);
-          const endCode = match[5].charCodeAt(0);
-          for (let code = startCode + 1; code <= endCode; code++) {
-            numbers.push({
-              num: first.num,
-              isSupp: first.isSupp,
-              suffix: String.fromCharCode(code)
-            });
-          }
-        } else if (match[4]) {
-          // Expand number range
-          if (first.isSupp === second.isSupp && !first.suffix && !second.suffix) {
-            for (let n = first.num + 1; n <= second.num; n++) {
-              numbers.push({ num: n, isSupp: first.isSupp, suffix: null });
-            }
-          } else {
-            numbers.push(second);
-          }
-        }
-      }
+      // [1] = type prefix (Figure, Fig., etc.)
+      // [2] = reference list string (e.g., "1, 2, and 3" or "1a-3b")
+
+      const listStr = match[2];
+      const numbers = parseReferenceList(listStr);
+
+      // Skip if no valid numbers were parsed
+      if (numbers.length === 0) continue;
 
       refs.push({
         type: normalizeType(type),

package/lib/equations.js

@@ -1,14 +1,36 @@
 /**
  * Equation extraction and conversion utilities
  * Handle LaTeX math in Markdown ↔ Word workflows
+ *
+ * Supports:
+ * - Extract LaTeX equations from Markdown
+ * - Extract equations from Word documents (OMML → LaTeX via Pandoc)
+ * - Convert Markdown with equations to Word (LaTeX → MathML)
  */
 
 import * as fs from 'fs';
 import * as path from 'path';
 import { exec } from 'child_process';
 import { promisify } from 'util';
+import AdmZip from 'adm-zip';
+import { parseString } from 'xml2js';
 
 const execAsync = promisify(exec);
+const parseXml = promisify(parseString);
+
+// Dynamic import for mathml-to-latex (ESM)
+let MathMLToLaTeX = null;
+async function getMathMLConverter() {
+  if (!MathMLToLaTeX) {
+    try {
+      const module = await import('mathml-to-latex');
+      MathMLToLaTeX = module.MathMLToLaTeX;
+    } catch {
+      return null;
+    }
+  }
+  return MathMLToLaTeX;
+}
 
 /**
  * Extract all equations from markdown text
@@ -256,3 +278,216 @@ export function getEquationStats(files) {
     byFile,
   };
 }
+
+/**
+ * Extract equations from a Word document using Pandoc
+ * Converts OMML (Office Math Markup) to LaTeX
+ *
+ * @param {string} docxPath - Path to Word document
+ * @returns {Promise<{success: boolean, equations: Array<{type: string, latex: string, position: number}>, error?: string}>}
+ */
+export async function extractEquationsFromWord(docxPath) {
+  if (!fs.existsSync(docxPath)) {
+    return { success: false, equations: [], error: `File not found: ${docxPath}` };
+  }
+
+  // Method 1: Use Pandoc to convert docx to markdown with LaTeX math
+  try {
+    const { stdout } = await execAsync(
+      `pandoc "${docxPath}" -t markdown --wrap=none`,
+      { maxBuffer: 50 * 1024 * 1024 }
+    );
+
+    // Extract equations from the markdown output
+    const equations = extractEquations(stdout, path.basename(docxPath));
+
+    return {
+      success: true,
+      equations: equations.map((eq, i) => ({
+        type: eq.type,
+        latex: eq.content,
+        position: i,
+        line: eq.line,
+      })),
+    };
+  } catch (err) {
+    // Pandoc failed, try fallback method
+    return extractEquationsFromWordDirect(docxPath);
+  }
+}
+
+/**
+ * Direct OMML extraction from Word document (fallback if Pandoc fails)
+ * Parses document.xml for <m:oMath> elements and attempts conversion
+ *
+ * @param {string} docxPath
+ * @returns {Promise<{success: boolean, equations: Array, error?: string}>}
+ */
+async function extractEquationsFromWordDirect(docxPath) {
+  try {
+    const zip = new AdmZip(docxPath);
+    const documentEntry = zip.getEntry('word/document.xml');
+
+    if (!documentEntry) {
+      return { success: false, equations: [], error: 'Invalid docx: no document.xml' };
+    }
+
+    const documentXml = zip.readAsText(documentEntry);
+
+    // Find all OMML equations (<m:oMath> or <m:oMathPara>)
+    const ommlPattern = /<m:oMath[^>]*>[\s\S]*?<\/m:oMath>/gi;
+    const matches = documentXml.match(ommlPattern) || [];
+
+    if (matches.length === 0) {
+      return { success: true, equations: [], message: 'No equations found' };
+    }
+
+    // Try to convert OMML to LaTeX via MathML intermediate
+    const Converter = await getMathMLConverter();
+    const equations = [];
+
+    for (let i = 0; i < matches.length; i++) {
+      const omml = matches[i];
+
+      // Attempt OMML → MathML → LaTeX conversion
+      // Note: This is a simplified approach; full OMML→MathML requires XSLT
+      try {
+        const latex = await ommlToLatex(omml, Converter);
+        if (latex) {
+          equations.push({
+            type: isDisplayMath(omml) ? 'display' : 'inline',
+            latex,
+            position: i,
+            raw: omml.substring(0, 100) + '...',
+          });
+        }
+      } catch {
+        // Keep raw OMML reference if conversion fails
+        equations.push({
+          type: 'unknown',
+          latex: null,
+          position: i,
+          raw: omml.substring(0, 100) + '...',
+          error: 'Conversion failed',
+        });
+      }
+    }
+
+    return { success: true, equations };
+  } catch (err) {
+    return { success: false, equations: [], error: err.message };
+  }
+}
+
+/**
+ * Check if OMML represents display math (equation on its own line)
+ */
+function isDisplayMath(omml) {
+  return omml.includes('<m:oMathPara') || omml.includes('m:jc');
+}
+
+/**
+ * Convert OMML to LaTeX (simplified approach)
+ * For complex equations, Pandoc method is more reliable
+ *
+ * @param {string} omml - OMML XML string
+ * @param {Function} Converter - MathMLToLaTeX converter
+ * @returns {Promise<string|null>}
+ */
+async function ommlToLatex(omml, Converter) {
+  if (!Converter) return null;
+
+  // Extract key elements from OMML and build approximate MathML
+  // This is a simplified conversion - not all OMML features are supported
+  try {
+    // Build basic MathML from OMML structure
+    const mathml = ommlToMathML(omml);
+    if (!mathml) return null;
+
+    // Convert MathML to LaTeX
+    const latex = Converter.convert(mathml);
+    return latex;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Convert OMML to MathML (simplified)
+ * Maps common OMML elements to MathML equivalents
+ */
+function ommlToMathML(omml) {
+  // Remove namespace prefixes for easier parsing
+  let xml = omml
+    .replace(/<m:/g, '<')
+    .replace(/<\/m:/g, '</')
+    .replace(/<w:/g, '<w_')
+    .replace(/<\/w:/g, '</w_');
+
+  // Map OMML elements to MathML
+  const mappings = [
+    [/<oMath[^>]*>/gi, '<math xmlns="http://www.w3.org/1998/Math/MathML">'],
+    [/<\/oMath>/gi, '</math>'],
+    [/<r>/gi, '<mi>'],
+    [/<\/r>/gi, '</mi>'],
+    [/<t>/gi, ''],
+    [/<\/t>/gi, ''],
+    [/<f>/gi, '<mfrac>'],
+    [/<\/f>/gi, '</mfrac>'],
+    [/<num>/gi, '<mrow>'],
+    [/<\/num>/gi, '</mrow>'],
+    [/<den>/gi, '<mrow>'],
+    [/<\/den>/gi, '</mrow>'],
+    [/<sup>/gi, '<msup><mrow>'],
+    [/<\/sup>/gi, '</mrow></msup>'],
+    [/<sub>/gi, '<msub><mrow>'],
+    [/<\/sub>/gi, '</mrow></msub>'],
+    [/<rad>/gi, '<msqrt>'],
+    [/<\/rad>/gi, '</msqrt>'],
+    [/<e>/gi, '<mrow>'],
+    [/<\/e>/gi, '</mrow>'],
+    // Remove elements we don't map
+    [/<rPr>[\s\S]*?<\/rPr>/gi, ''],
+    [/<ctrlPr>[\s\S]*?<\/ctrlPr>/gi, ''],
+    [/<w_[^>]*>[\s\S]*?<\/w_[^>]*>/gi, ''],
+    [/<[^>]*\/>/gi, ''], // Self-closing tags
+  ];
+
+  for (const [pattern, replacement] of mappings) {
+    xml = xml.replace(pattern, replacement);
+  }
+
+  // Clean up any remaining unrecognized tags
+  xml = xml.replace(/<[a-zA-Z][^>]*>/g, '').replace(/<\/[a-zA-Z]+>/g, '');
+
+  // Wrap in math if not already
+  if (!xml.includes('<math')) {
+    xml = `<math xmlns="http://www.w3.org/1998/Math/MathML">${xml}</math>`;
+  }
+
+  return xml;
+}
+
+/**
+ * Get equation summary from Word document
+ * @param {string} docxPath
+ * @returns {Promise<{count: number, display: number, inline: number, converted: number}>}
+ */
+export async function getWordEquationStats(docxPath) {
+  const result = await extractEquationsFromWord(docxPath);
+
+  if (!result.success) {
+    return { count: 0, display: 0, inline: 0, converted: 0, error: result.error };
+  }
+
+  const display = result.equations.filter(e => e.type === 'display').length;
+  const inline = result.equations.filter(e => e.type === 'inline').length;
+  const converted = result.equations.filter(e => e.latex).length;
+
+  return {
+    count: result.equations.length,
+    display,
+    inline,
+    converted,
+  };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "docrev",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Academic paper revision workflow: Word ↔ Markdown round-trips, DOI validation, reviewer comments",
   "type": "module",
   "bin": {
@@ -12,12 +12,12 @@
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/gcol33/rev.git"
+    "url": "git+https://github.com/gcol33/docrev.git"
   },
   "bugs": {
-    "url": "https://github.com/gcol33/rev/issues"
+    "url": "https://github.com/gcol33/docrev/issues"
   },
-  "homepage": "https://github.com/gcol33/rev#readme",
+  "homepage": "https://github.com/gcol33/docrev#readme",
   "keywords": [
     "markdown",
     "word",
@@ -38,6 +38,7 @@
     "diff": "^8.0.2",
     "js-yaml": "^4.1.1",
     "mammoth": "^1.6.0",
+    "mathml-to-latex": "^1.5.0",
     "xml2js": "^0.6.2"
   }
 }