docrev 0.6.0 → 0.6.2

package/bin/rev.js

@@ -1525,6 +1525,7 @@ program
   .option('--toc', 'Include table of contents')
   .option('--show-changes', 'Export DOCX with visible track changes (audit mode)')
   .option('--dual', 'Output both clean DOCX and DOCX with Word comments (paper.docx + paper_comments.docx)')
+  .option('--reference <docx>', 'Reference DOCX for comment position alignment (use with --dual)')
   .action(async (formats, options) => {
     const dir = path.resolve(options.dir);
 
@@ -1568,6 +1569,11 @@ program
       config.docx.toc = true;
     }
 
+    // For --dual mode, the clean DOCX should have no comments
+    if (options.dual) {
+      config.docx.keepComments = false;
+    }
+
     // Handle --show-changes mode (audit export)
     if (options.showChanges) {
       if (!targetFormats.includes('docx') && !targetFormats.includes('all')) {
@@ -1645,28 +1651,84 @@ program
         process.exit(1);
       }
 
-      // Handle --dual mode: create a second DOCX with proper Word comments
+      // Handle --dual mode: create a second DOCX with proper Word comments using marker-based approach
       if (options.dual) {
         const docxResult = results.find(r => r.format === 'docx' && r.success);
         if (docxResult) {
-          const { injectComments } = await import('../lib/wordcomments.js');
-
-          // Read the combined paper.md (with comments still in it)
-          const markdown = fs.readFileSync(paperPath, 'utf-8');
-
-          // Generate comments DOCX path
-          const commentsDocxPath = docxResult.outputPath.replace(/\.docx$/, '_comments.docx');
+          const { prepareMarkdownWithMarkers, injectCommentsAtMarkers } = await import('../lib/wordcomments.js');
+          const { runPandoc, loadConfig } = await import('../lib/build.js');
+
+          // Read the combined paper.md (with comments)
+          let markdown = fs.readFileSync(paperPath, 'utf-8');
+
+          // If reference DOCX specified, realign comments from it
+          if (options.reference) {
+            const refPath = path.resolve(dir, options.reference);
+            if (fs.existsSync(refPath)) {
+              const spinRealign = fmt.spinner('Realigning comments from reference...').start();
+              const { realignComments } = await import('../lib/comment-realign.js');
+              // Realign in-memory (don't write to file)
+              const { realignMarkdown } = await import('../lib/comment-realign.js');
+              const realigned = await realignMarkdown(refPath, markdown);
+              if (realigned.success) {
+                markdown = realigned.markdown;
+                spinRealign.stop();
+                console.log(chalk.dim(`  Realigned ${realigned.insertions} comments from reference`));
+              } else {
+                spinRealign.stop();
+                console.log(chalk.yellow(`  Warning: Could not realign comments: ${realigned.error}`));
+              }
+            } else {
+              console.log(chalk.yellow(`  Warning: Reference not found: ${options.reference}`));
+            }
+          }
 
-          const spinComments = fmt.spinner('Injecting Word comments...').start();
-          const commentResult = await injectComments(docxResult.outputPath, markdown, commentsDocxPath);
-          spinComments.stop();
+          // Step 1: Replace comments with markers
+          const spinMarkers = fmt.spinner('Preparing markers...').start();
+          const { markedMarkdown, comments } = prepareMarkdownWithMarkers(markdown);
+          spinMarkers.stop();
 
-          if (commentResult.success) {
-            console.log(chalk.cyan('\nDual output:'));
-            console.log(`  Clean:    ${path.basename(docxResult.outputPath)}`);
-            console.log(`  Comments: ${path.basename(commentsDocxPath)} (${commentResult.commentCount} comments)`);
+          if (comments.length === 0) {
+            console.log(chalk.yellow('\nNo comments found - skipping comments DOCX'));
           } else {
-            console.error(chalk.yellow(`\nWarning: Could not create comments DOCX: ${commentResult.error}`));
+            // Step 2: Write marked markdown to temp file
+            const markedPath = path.join(dir, '.paper-marked.md');
+            fs.writeFileSync(markedPath, markedMarkdown, 'utf-8');
+
+            // Step 3: Build DOCX from marked markdown using pandoc
+            const spinBuild = fmt.spinner('Building marked DOCX...').start();
+            const markedDocxPath = path.join(dir, '.paper-marked.docx');
+            const pandocResult = await runPandoc(markedPath, 'docx', config, { ...options, outputPath: markedDocxPath });
+            spinBuild.stop();
+
+            if (!pandocResult.success) {
+              console.error(chalk.yellow(`\nWarning: Could not build marked DOCX: ${pandocResult.error}`));
+            } else {
+              // Step 4: Replace markers with comment ranges
+              const commentsDocxPath = docxResult.outputPath.replace(/\.docx$/, '_comments.docx');
+              const spinInject = fmt.spinner('Injecting comments at markers...').start();
+              const commentResult = await injectCommentsAtMarkers(markedDocxPath, comments, commentsDocxPath);
+              spinInject.stop();
+
+              // Clean up temp files (keep for debugging if DEBUG env is set)
+              if (!process.env.DEBUG) {
+                try {
+                  fs.unlinkSync(markedPath);
+                  fs.unlinkSync(markedDocxPath);
+                } catch { /* ignore */ }
+              }
+
+              if (commentResult.success) {
+                console.log(chalk.cyan('\nDual output:'));
+                console.log(`  Clean:    ${path.basename(docxResult.outputPath)}`);
+                console.log(`  Comments: ${path.basename(commentsDocxPath)} (${commentResult.commentCount} comments)`);
+                if (commentResult.skippedComments > 0) {
+                  console.log(chalk.yellow(`  Warning: ${commentResult.skippedComments} comments could not be anchored (markers not found)`));
+                }
+              } else {
+                console.error(chalk.yellow(`\nWarning: Could not create comments DOCX: ${commentResult.error}`));
+              }
+            }
           }
         } else {
           console.error(chalk.yellow('\n--dual requires docx format to be built'));

package/lib/build.js

@@ -399,7 +399,8 @@ export async function runPandoc(inputPath, format, config, options = {}) {
     : 'paper';
 
   const ext = format === 'tex' ? '.tex' : format === 'pdf' ? '.pdf' : '.docx';
-  const outputPath = path.join(directory, `${baseName}${ext}`);
+  // Allow custom output path via options
+  const outputPath = options.outputPath || path.join(directory, `${baseName}${ext}`);
 
   // Ensure crossref.yaml exists
   ensureCrossrefConfig(directory, config);

package/lib/comment-realign.js

@@ -0,0 +1,453 @@
+/**
+ * Realign comments from a reference DOCX to markdown
+ * Uses paragraph-level matching with exact positions
+ */
+
+import * as fs from 'fs';
+import AdmZip from 'adm-zip';
+import { parseStringPromise } from 'xml2js';
+
+/**
+ * Extract paragraphs with their full text and comment positions from DOCX
+ */
+export async function extractParagraphsWithComments(docxPath) {
+  const zip = new AdmZip(docxPath);
+  const doc = zip.readAsText('word/document.xml');
+  const commentsXml = zip.readAsText('word/comments.xml');
+
+  // Parse comments to get authors and texts
+  const parsed = await parseStringPromise(commentsXml, { explicitArray: false });
+  const commentNodes = parsed['w:comments']?.['w:comment'];
+  if (!commentNodes) return [];
+
+  const nodes = Array.isArray(commentNodes) ? commentNodes : [commentNodes];
+  const commentData = {};
+
+  for (const c of nodes) {
+    const id = c.$['w:id'];
+    const author = c.$['w:author'] || 'Unknown';
+    let text = '';
+    const extractT = (n) => {
+      if (!n) return;
+      if (n['w:t']) {
+        const t = n['w:t'];
+        text += typeof t === 'string' ? t : (t._ || t);
+      }
+      if (n['w:r']) {
+        (Array.isArray(n['w:r']) ? n['w:r'] : [n['w:r']]).forEach(extractT);
+      }
+      if (n['w:p']) {
+        (Array.isArray(n['w:p']) ? n['w:p'] : [n['w:p']]).forEach(extractT);
+      }
+    };
+    extractT(c);
+    commentData[id] = { author, text: text.trim() };
+  }
+
+  // Extract paragraphs with comments
+  const paragraphs = [];
+  const paraPattern = /<w:p\b[^>]*>([\s\S]*?)<\/w:p>/g;
+  let match;
+
+  while ((match = paraPattern.exec(doc)) !== null) {
+    const paraContent = match[1];
+    const hasComments = /commentRangeStart/.test(paraContent);
+
+    // Build paragraph text and track comment positions
+    let text = '';
+    const comments = [];
+
+    const tokenPattern = /<w:t[^>]*>([^<]*)<\/w:t>|<w:commentRangeStart[^>]*w:id="(\d+)"[^>]*\/?>/g;
+    let tokenMatch;
+
+    while ((tokenMatch = tokenPattern.exec(paraContent)) !== null) {
+      if (tokenMatch[1] !== undefined) {
+        text += tokenMatch[1];
+      } else if (tokenMatch[2] !== undefined) {
+        const cid = tokenMatch[2];
+        const data = commentData[cid];
+        if (data) {
+          comments.push({
+            id: cid,
+            position: text.length,
+            author: data.author,
+            text: data.text,
+          });
+        }
+      }
+    }
+
+    if (text.trim() || hasComments) {
+      paragraphs.push({ text: text.trim(), comments });
+    }
+  }
+
+  return paragraphs;
+}
+
+/**
+ * Find best matching paragraph in markdown for a reference paragraph
+ */
+function findMatchingParagraph(refText, mdParagraphs) {
+  // Normalize for comparison
+  const normalize = (s) => s.toLowerCase().replace(/\s+/g, ' ').trim();
+  const refNorm = normalize(refText);
+
+  if (refNorm.length < 20) return null;
+
+  let bestMatch = null;
+  let bestScore = 0;
+
+  for (let i = 0; i < mdParagraphs.length; i++) {
+    const mdNorm = normalize(mdParagraphs[i].text);
+
+    // Calculate word overlap
+    const refWords = new Set(refNorm.split(' ').filter((w) => w.length > 3));
+    const mdWords = mdNorm.split(' ').filter((w) => w.length > 3);
+    const overlap = mdWords.filter((w) => refWords.has(w)).length;
+    const score = overlap / Math.max(refWords.size, 1);
+
+    // Also check for substring containment (for section headers)
+    const containsStart = mdNorm.includes(refNorm.slice(0, 50));
+
+    if (score > bestScore || (containsStart && score > 0.3)) {
+      bestScore = Math.max(score, containsStart ? 0.8 : score);
+      bestMatch = { index: i, score: bestScore, paragraph: mdParagraphs[i] };
+    }
+  }
+
+  return bestScore > 0.4 ? bestMatch : null;
+}
+
+/**
+ * Extract paragraphs from markdown (split by blank lines)
+ */
+function parseMdParagraphs(markdown) {
+  const paragraphs = [];
+  const parts = markdown.split(/\n\n+/);
+
+  let pos = 0;
+  for (const part of parts) {
+    const trimmed = part.trim();
+    if (trimmed) {
+      paragraphs.push({
+        text: trimmed,
+        start: markdown.indexOf(part, pos),
+        end: markdown.indexOf(part, pos) + part.length,
+      });
+      pos = markdown.indexOf(part, pos) + part.length;
+    }
+  }
+
+  return paragraphs;
+}
+
+/**
+ * Strip existing comments from a specific author
+ */
+function stripAuthorComments(text, author) {
+  const pattern = new RegExp(`\\s*\\{>>${author}:[^<]*<<\\}`, 'g');
+  return text.replace(pattern, '');
+}
+
+/**
+ * Normalize text for matching (remove citations, extra whitespace)
+ */
+function normalizeForMatching(text) {
+  return text
+    // Remove Word citation placeholders
+    .replace(/\(\s*\$+\s*\)/g, '')
+    .replace(/\$+/g, '')
+    // Remove markdown citations
+    .replace(/\[@[^\]]+\]/g, '')
+    .replace(/@[A-Z][a-z]+\d{4}/g, '')
+    // Remove rendered citations like "(Author et al. 2021)"
+    .replace(/\([A-Z][a-z]+(?:\s+et\s+al\.?)?\s+\d{4}[a-z]?(?:[;,]\s*[A-Z][a-z]+(?:\s+et\s+al\.?)?\s+\d{4}[a-z]?)*\)/g, '')
+    // Remove figure references like "Fig. 1" or "(Fig. 1)"
+    .replace(/\(?Fig\.?\s*\d+[a-z]?\)?/gi, '')
+    // Normalize whitespace
+    .replace(/\s+/g, ' ')
+    .trim()
+    .toLowerCase();
+}
+
+/**
+ * Find the word at or near a position in text
+ */
+function getWordAtPosition(text, pos) {
+  const before = text.slice(Math.max(0, pos - 30), pos);
+  const after = text.slice(pos, pos + 30);
+
+  // Get the last complete word before position
+  const beforeWords = before.split(/\s+/).filter(w => w.length > 2);
+  const afterWords = after.split(/\s+/).filter(w => w.length > 2);
+
+  return {
+    before: beforeWords.slice(-3),
+    after: afterWords.slice(0, 3)
+  };
+}
+
+/**
+ * Find position in markdown paragraph matching reference position
+ * Uses the anchor word (word immediately before the comment) for precise matching
+ */
+function findMdPosition(refText, refPos, mdText) {
+  // Get the word(s) immediately before the comment position in reference
+  const refWords = getWordAtPosition(refText, refPos);
+  const normalizedMd = normalizeForMatching(mdText);
+
+  // The "anchor word" is the last word before the comment
+  const anchorWords = refWords.before;
+
+  if (anchorWords.length === 0) {
+    const ratio = refPos / Math.max(refText.length, 1);
+    return Math.round(ratio * mdText.length);
+  }
+
+  // Try to find the anchor word(s) in markdown
+  // Start with the most specific (all words), fall back to fewer
+  for (let numWords = anchorWords.length; numWords >= 1; numWords--) {
+    const searchWords = anchorWords.slice(-numWords);
+    const pattern = searchWords.map(w =>
+      w.toLowerCase().replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+    ).join('\\s+');
+
+    const regex = new RegExp(pattern, 'g');
+    const matches = [...normalizedMd.matchAll(regex)];
+
+    if (matches.length === 1) {
+      // Unique match - use this position
+      const matchEnd = matches[0].index + matches[0][0].length;
+      // Map back to original markdown position
+      const ratio = matchEnd / Math.max(normalizedMd.length, 1);
+      return Math.round(ratio * mdText.length);
+    } else if (matches.length > 1) {
+      // Multiple matches - use context after to disambiguate
+      const afterWords = refWords.after;
+      if (afterWords.length > 0) {
+        const afterPattern = afterWords[0].toLowerCase().replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        for (const match of matches) {
+          const matchEnd = match.index + match[0].length;
+          const afterContext = normalizedMd.slice(matchEnd, matchEnd + 50);
+          if (afterContext.includes(afterPattern)) {
+            const ratio = matchEnd / Math.max(normalizedMd.length, 1);
+            return Math.round(ratio * mdText.length);
+          }
+        }
+      }
+      // Fall back to first match
+      const matchEnd = matches[0].index + matches[0][0].length;
+      const ratio = matchEnd / Math.max(normalizedMd.length, 1);
+      return Math.round(ratio * mdText.length);
+    }
+  }
+
+  // Fallback: proportional position
+  const ratio = refPos / Math.max(refText.length, 1);
+  return Math.round(ratio * mdText.length);
+}
+
+/**
+ * Extract reply comments that follow a parent comment
+ * Returns map of parent comment text -> array of reply texts
+ */
+function extractReplies(markdown, parentAuthor, replyAuthor) {
+  const replies = new Map();
+  const pattern = new RegExp(
+    `\\{>>${parentAuthor}:\\s*([^<]+)<<\\}((?:\\s*\\{>>${replyAuthor}:[^<]+<<\\})*)`,
+    'g'
+  );
+
+  let match;
+  while ((match = pattern.exec(markdown)) !== null) {
+    const parentText = match[1].trim();
+    const replyBlock = match[2];
+
+    if (replyBlock) {
+      const replyPattern = new RegExp(`\\{>>${replyAuthor}:\\s*([^<]+)<<\\}`, 'g');
+      const replyTexts = [];
+      let replyMatch;
+      while ((replyMatch = replyPattern.exec(replyBlock)) !== null) {
+        replyTexts.push(replyMatch[1].trim());
+      }
+      if (replyTexts.length > 0) {
+        replies.set(parentText.slice(0, 50), replyTexts); // Use first 50 chars as key
+      }
+    }
+  }
+
+  return replies;
+}
+
+/**
+ * Realign comments from reference DOCX to markdown
+ * @param {string} docxPath - Reference DOCX with correctly positioned comments
+ * @param {string} markdownPath - Markdown to realign
+ * @param {object} options - {dryRun: boolean, author: string, replyAuthor: string}
+ */
+export async function realignComments(docxPath, markdownPath, options = {}) {
+  const { dryRun = false, author = 'Guy Colling', replyAuthor = 'Gilles Colling' } = options;
+
+  // Read original markdown to extract replies before stripping
+  const originalMarkdown = fs.readFileSync(markdownPath, 'utf-8');
+
+  // Extract reply relationships
+  const replies = extractReplies(originalMarkdown, author, replyAuthor);
+  console.log(`Found ${replies.size} ${author} comments with ${replyAuthor} replies`);
+
+  // Extract reference paragraphs with comments
+  const refParagraphs = await extractParagraphsWithComments(docxPath);
+  const refWithComments = refParagraphs.filter(
+    (p) => p.comments.length > 0 && p.comments.some((c) => c.author === author)
+  );
+
+  console.log(`Found ${refWithComments.length} paragraphs with ${author} comments in reference`);
+
+  // Strip ALL comments (both authors) from markdown to start fresh
+  let markdown = originalMarkdown;
+  markdown = markdown.replace(/\s*\{>>[^<]+<<\}/g, '');
+  console.log(`Stripped all comments from markdown`);
+
+  // Parse markdown paragraphs
+  const mdParagraphs = parseMdParagraphs(markdown);
+
+  // Track insertions (position, text) - will insert from end to start
+  const insertions = [];
+  let matched = 0;
+  let unmatched = 0;
+
+  for (const refPara of refWithComments) {
+    const match = findMatchingParagraph(refPara.text, mdParagraphs);
+
+    if (!match) {
+      console.log(`  No match for: "${refPara.text.slice(0, 60)}..."`);
+      unmatched++;
+      continue;
+    }
+
+    matched++;
+    const mdPara = match.paragraph;
+
+    // Get author's comments in this paragraph
+    const authorComments = refPara.comments.filter((c) => c.author === author);
+
+    for (const comment of authorComments) {
+      // Find corresponding position in markdown paragraph
+      const mdPos = findMdPosition(refPara.text, comment.position, mdPara.text);
+      const absolutePos = mdPara.start + mdPos;
+
+      // Build comment mark with any replies
+      let commentMark = ` {>>${comment.author}: ${comment.text}<<}`;
+
+      // Check for replies
+      const replyKey = comment.text.trim().slice(0, 50);
+      const replyTexts = replies.get(replyKey);
+      if (replyTexts) {
+        for (const replyText of replyTexts) {
+          commentMark += ` {>>${replyAuthor}: ${replyText}<<}`;
+        }
+      }
+
+      insertions.push({
+        position: absolutePos,
+        text: commentMark,
+        commentText: comment.text.slice(0, 30),
+        hasReplies: !!replyTexts,
+        debug: `"${mdPara.text.slice(Math.max(0, mdPos - 20), mdPos)}|HERE|${mdPara.text.slice(mdPos, mdPos + 20)}"`,
+      });
+    }
+  }
+
+  console.log(`Matched ${matched} paragraphs, ${unmatched} unmatched`);
+  console.log(`Inserting ${insertions.length} comments (${insertions.filter((i) => i.hasReplies).length} with replies)`);
+
+  if (dryRun) {
+    console.log('\nDry run - would insert:');
+    for (const ins of insertions.slice(0, 10)) {
+      console.log(`  At ${ins.position}: ${ins.debug}`);
+      console.log(`    Comment: "${ins.commentText}..."${ins.hasReplies ? ' (+ replies)' : ''}`);
+    }
+    return { success: true, dryRun: true, insertions: insertions.length };
+  }
+
+  // Sort by position descending and insert
+  insertions.sort((a, b) => b.position - a.position);
+
+  for (const ins of insertions) {
+    markdown = markdown.slice(0, ins.position) + ins.text + markdown.slice(ins.position);
+  }
+
+  // Write result
+  fs.writeFileSync(markdownPath, markdown);
+
+  return { success: true, insertions: insertions.length, matched, unmatched };
+}
+
+/**
+ * Realign comments in markdown string (in-memory, doesn't write to file)
+ * @param {string} docxPath - Reference DOCX with correctly positioned comments
+ * @param {string} markdown - Markdown content to realign
+ * @param {object} options - {author: string, replyAuthor: string}
+ * @returns {Promise<{success: boolean, markdown: string, insertions: number}>}
+ */
+export async function realignMarkdown(docxPath, markdown, options = {}) {
+  const { author = 'Guy Colling', replyAuthor = 'Gilles Colling' } = options;
+
+  try {
+    // Extract reply relationships from original markdown
+    const replies = extractReplies(markdown, author, replyAuthor);
+
+    // Extract reference paragraphs with comments
+    const refParagraphs = await extractParagraphsWithComments(docxPath);
+    const refWithComments = refParagraphs.filter(
+      (p) => p.comments.length > 0 && p.comments.some((c) => c.author === author)
+    );
+
+    // Strip ALL comments from markdown
+    let result = markdown.replace(/\s*\{>>[^<]+<<\}/g, '');
+
+    // Parse markdown paragraphs
+    const mdParagraphs = parseMdParagraphs(result);
+
+    // Track insertions
+    const insertions = [];
+
+    for (const refPara of refWithComments) {
+      const match = findMatchingParagraph(refPara.text, mdParagraphs);
+      if (!match) continue;
+
+      const mdPara = match.paragraph;
+      const authorComments = refPara.comments.filter((c) => c.author === author);
+
+      for (const comment of authorComments) {
+        const mdPos = findMdPosition(refPara.text, comment.position, mdPara.text);
+        const absolutePos = mdPara.start + mdPos;
+
+        let commentMark = ` {>>${comment.author}: ${comment.text}<<}`;
+
+        // Check for replies
+        const replyKey = comment.text.trim().slice(0, 50);
+        const replyTexts = replies.get(replyKey);
+        if (replyTexts) {
+          for (const replyText of replyTexts) {
+            commentMark += ` {>>${replyAuthor}: ${replyText}<<}`;
+          }
+        }
+
+        insertions.push({ position: absolutePos, text: commentMark });
+      }
+    }
+
+    // Sort by position descending and insert
+    insertions.sort((a, b) => b.position - a.position);
+
+    for (const ins of insertions) {
+      result = result.slice(0, ins.position) + ins.text + result.slice(ins.position);
+    }
+
+    return { success: true, markdown: result, insertions: insertions.length };
+  } catch (err) {
+    return { success: false, markdown, insertions: 0, error: err.message };
+  }
+}