docrev 0.10.2 → 0.11.1

package/lib/commands/sync.ts

@@ -305,6 +305,7 @@ export function register(program: Command): void {
         // reports placements rather than the raw extracted count.
         const routedCommentIds = new Set<string>();
         let totalCommentsPlaced = 0;
+        let totalCommentsLowConfidence = 0;
         let totalCommentsDeduped = 0;
         let totalCommentsUnmatched = 0;
 
@@ -375,19 +376,23 @@ export function register(program: Command): void {
 
             if (sectionComments.length > 0) {
               for (const c of sectionComments) routedCommentIds.add(c.id);
-              const cstats = { placed: 0, deduped: 0, unmatched: 0 };
+              const cstats = { placed: 0, lowConfidence: 0, deduped: 0, unmatched: 0 };
               annotated = insertCommentsIntoMarkdown(annotated, sectionComments, anchors, {
                 quiet: !process.env.DEBUG,
                 sectionBoundary: boundary,
                 outStats: cstats,
               });
-              stats.comments = (stats.comments || 0) + cstats.placed;
-              totalCommentsPlaced += cstats.placed;
+              // Both confident and approximate placements are written to the
+              // file; count both as placed, but track the approximate ones so
+              // the summary can flag them for review.
+              stats.comments = (stats.comments || 0) + cstats.placed + cstats.lowConfidence;
+              totalCommentsPlaced += cstats.placed + cstats.lowConfidence;
+              totalCommentsLowConfidence += cstats.lowConfidence;
               totalCommentsDeduped += cstats.deduped;
               totalCommentsUnmatched += cstats.unmatched;
 
               if (process.env.DEBUG) {
-                console.log(`[DEBUG] ${section.file}: placed ${cstats.placed}, deduped ${cstats.deduped}, unmatched ${cstats.unmatched} of ${sectionComments.length}`);
+                console.log(`[DEBUG] ${section.file}: placed ${cstats.placed}, approx ${cstats.lowConfidence}, deduped ${cstats.deduped}, unmatched ${cstats.unmatched} of ${sectionComments.length}`);
               }
             }
           }
@@ -485,6 +490,9 @@ export function register(program: Command): void {
           if (totalCommentsPlaced > 0) {
             summaryLines.push(`${chalk.bold(totalCommentsPlaced)} of ${comments.length} comments placed`);
           }
+          if (totalCommentsLowConfidence > 0) {
+            summaryLines.push(`${chalk.yellow(totalCommentsLowConfidence)} placed approximately (review with verify-anchors)`);
+          }
           if (totalCommentsDeduped > 0) {
             summaryLines.push(`${chalk.cyan(totalCommentsDeduped)} already present (skipped)`);
           }
@@ -587,12 +595,12 @@ async function syncCommentsOnly(
   }
 
   const firstBoundaryStart = boundaries[0].start;
-  const results: Array<{ file: string; placed: number; deduped: number; unmatched: number; skipped: boolean }> = [];
+  const results: Array<{ file: string; placed: number; lowConfidence: number; deduped: number; unmatched: number; skipped: boolean }> = [];
 
   for (const boundary of activeBoundaries) {
     const sectionPath = path.join(options.dir, boundary.file);
     if (!fs.existsSync(sectionPath)) {
-      results.push({ file: boundary.file, placed: 0, deduped: 0, unmatched: 0, skipped: true });
+      results.push({ file: boundary.file, placed: 0, lowConfidence: 0, deduped: 0, unmatched: 0, skipped: true });
       continue;
     }
 
@@ -607,13 +615,13 @@ async function syncCommentsOnly(
     });
 
     if (sectionComments.length === 0) {
-      results.push({ file: boundary.file, placed: 0, deduped: 0, unmatched: 0, skipped: false });
+      results.push({ file: boundary.file, placed: 0, lowConfidence: 0, deduped: 0, unmatched: 0, skipped: false });
       continue;
     }
 
     const original = fs.readFileSync(sectionPath, 'utf-8');
 
-    const stats = { placed: 0, deduped: 0, unmatched: 0 };
+    const stats = { placed: 0, lowConfidence: 0, deduped: 0, unmatched: 0 };
     const annotated = insertCommentsIntoMarkdown(original, sectionComments, anchors, {
       quiet: !process.env.DEBUG,
       sectionBoundary: { start: boundary.start, end: boundary.end },
@@ -621,7 +629,7 @@ async function syncCommentsOnly(
       outStats: stats,
     });
 
-    if (!options.dryRun && stats.placed > 0) {
+    if (!options.dryRun && (stats.placed > 0 || stats.lowConfidence > 0)) {
       fs.writeFileSync(sectionPath, annotated, 'utf-8');
     }
     results.push({ file: boundary.file, ...stats, skipped: false });
@@ -634,6 +642,7 @@ async function syncCommentsOnly(
     return [
       chalk.bold(r.file),
       chalk.green(`${r.placed}`),
+      r.lowConfidence > 0 ? chalk.yellow(`${r.lowConfidence}`) : chalk.dim('-'),
       r.deduped > 0 ? chalk.cyan(`${r.deduped}`) : chalk.dim('-'),
       r.unmatched > 0 ? chalk.yellow(`${r.unmatched}`) : chalk.dim('-'),
       chalk.dim('comments only'),
@@ -641,13 +650,14 @@ async function syncCommentsOnly(
   });
 
   console.log(fmt.table(
-    ['File', 'Placed', 'Already', 'Unmatched', 'Mode'],
+    ['File', 'Placed', 'Approx', 'Already', 'Unmatched', 'Mode'],
     tableRows,
-    { align: ['left', 'right', 'right', 'right', 'left'] },
+    { align: ['left', 'right', 'right', 'right', 'right', 'left'] },
   ));
   console.log();
 
   const totalPlaced = results.reduce((s, r) => s + r.placed, 0);
+  const totalLowConfidence = results.reduce((s, r) => s + r.lowConfidence, 0);
   const totalDeduped = results.reduce((s, r) => s + r.deduped, 0);
   const totalUnmatched = results.reduce((s, r) => s + r.unmatched, 0);
 
@@ -656,6 +666,9 @@ async function syncCommentsOnly(
   if (totalPlaced > 0) {
     lines.push(`${chalk.bold(totalPlaced)} placed at anchors`);
   }
+  if (totalLowConfidence > 0) {
+    lines.push(`${chalk.yellow(totalLowConfidence)} placed approximately (review with verify-anchors)`);
+  }
   if (totalDeduped > 0) {
     lines.push(`${chalk.cyan(totalDeduped)} already present (skipped to avoid duplication)`);
   }
@@ -664,12 +677,12 @@ async function syncCommentsOnly(
   }
   if (options.dryRun) {
     lines.push(chalk.yellow('Dry run — no files written'));
-  } else if (totalPlaced > 0) {
+  } else if (totalPlaced > 0 || totalLowConfidence > 0) {
     lines.push(chalk.dim('Existing prose unchanged.'));
   }
   console.log(fmt.box(lines.join('\n'), { title: 'Summary', padding: 0 }));
 
-  if (totalUnmatched > 0) {
+  if (totalUnmatched > 0 || totalLowConfidence > 0) {
     console.log();
     console.log(chalk.dim('Tip: run "rev verify-anchors" to see which comments drifted.'));
   }

package/lib/comment-realign.ts

@@ -1,56 +1,19 @@
 /**
- * Realign comments from a reference DOCX to markdown
- * Uses paragraph-level matching with exact positions
+ * Realign comments from a reference DOCX onto markdown.
+ *
+ * This is the same job as `rev sync`: read the comments and their anchors from
+ * a docx, then place them into the current markdown. It therefore reuses the
+ * one extraction + placement engine rather than carrying a second docx parser
+ * and a proportional position-mapper.
  */
 
 import * as fs from 'fs';
-import AdmZip from 'adm-zip';
-import { parseStringPromise } from 'xml2js';
-
-interface CommentData {
-  author: string;
-  text: string;
-}
-
-interface CommentWithPosition {
-  id: string;
-  position: number;
-  author: string;
-  text: string;
-}
-
-interface Paragraph {
-  text: string;
-  comments: CommentWithPosition[];
-}
-
-interface MdParagraph {
-  text: string;
-  start: number;
-  end: number;
-}
-
-interface ParagraphMatch {
-  index: number;
-  score: number;
-  paragraph: MdParagraph;
-}
-
-interface WordContext {
-  before: string[];
-  after: string[];
-}
-
-interface CommentInsertion {
-  position: number;
-  text: string;
-  commentText: string;
-  hasReplies: boolean;
-  debug: string;
-}
+import { extractWordComments, extractCommentAnchors } from './word-extraction.js';
+import { insertCommentsIntoMarkdown } from './import.js';
 
 interface RealignOptions {
   dryRun?: boolean;
+  /** When set, realign only comments by these authors; otherwise all. */
   author?: string;
   replyAuthor?: string;
 }
@@ -59,8 +22,7 @@ interface RealignResult {
   success: boolean;
   dryRun?: boolean;
   insertions: number;
-  matched?: number;
-  unmatched?: number;
+  error?: string;
 }
 
 interface RealignMarkdownOptions {
@@ -75,443 +37,63 @@ interface RealignMarkdownResult {
   error?: string;
 }
 
-/**
- * Extract paragraphs with their full text and comment positions from DOCX
- */
-export async function extractParagraphsWithComments(docxPath: string): Promise<Paragraph[]> {
-  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: Record<string, CommentData> = {};
-
-  for (const c of nodes) {
-    const id = c.$?.['w:id'] ?? '';
-    const author = c.$?.['w:author'] ?? 'Unknown';
-    let text = '';
-    const extractT = (n: any): void => {
-      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: Paragraph[] = [];
-  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: CommentWithPosition[] = [];
-
-    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: string, mdParagraphs: MdParagraph[]): ParagraphMatch | null {
-  // Normalize for comparison
-  const normalize = (s: string): string => s.toLowerCase().replace(/\s+/g, ' ').trim();
-  const refNorm = normalize(refText);
-
-  if (refNorm.length < 20) return null;
-
-  let bestMatch: ParagraphMatch | null = 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;
+/** Existing CriticMarkup comments, removed before the reference set is placed. */
+function stripExistingComments(markdown: string): string {
+  return markdown.replace(/\s*\{>>[\s\S]+?<<\}/g, '');
 }
 
 /**
- * Extract paragraphs from markdown (split by blank lines)
+ * Realign the reference docx's comments onto an in-memory markdown string.
+ * Existing comments are cleared first so re-running is idempotent.
  */
-function parseMdParagraphs(markdown: string): MdParagraph[] {
-  const paragraphs: MdParagraph[] = [];
-  const parts = markdown.split(/\n\n+/);
-
-  let pos = 0;
-  for (const part of parts) {
-    const trimmed = part.trim();
-    if (trimmed) {
-      const partStart = markdown.indexOf(part, pos);
-      if (partStart !== -1) {
-        paragraphs.push({
-          text: trimmed,
-          start: partStart,
-          end: partStart + part.length,
-        });
-        pos = partStart + part.length;
-      }
-    }
-  }
-
-  return paragraphs;
-}
-
-/**
- * Normalize text for matching (remove citations, extra whitespace)
- */
-function normalizeForMatching(text: string): string {
-  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: string, pos: number): WordContext {
-  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: string, refPos: number, mdText: string): number {
-  // 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)];
+export async function realignMarkdown(
+  docxPath: string,
+  markdown: string,
+  options: RealignMarkdownOptions = {},
+): Promise<RealignMarkdownResult> {
+  try {
+    let comments = await extractWordComments(docxPath);
+    const { anchors } = await extractCommentAnchors(docxPath);
 
-    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);
+    if (options.author) {
+      const keep = new Set([options.author, options.replyAuthor].filter(Boolean) as string[]);
+      comments = comments.filter((c) => keep.has(c.author));
     }
-  }
 
-  // Fallback: proportional position
-  const ratio = refPos / Math.max(refText.length, 1);
-  return Math.round(ratio * mdText.length);
-}
+    const stripped = stripExistingComments(markdown);
+    const stats = { placed: 0, lowConfidence: 0, deduped: 0, unmatched: 0 };
+    const result = insertCommentsIntoMarkdown(stripped, comments, anchors, {
+      quiet: true,
+      wrapAnchor: false,
+      outStats: stats,
+    });
 
-/**
- * Extract reply comments that follow a parent comment
- * Returns map of parent comment text -> array of reply texts
- */
-function extractReplies(markdown: string, parentAuthor: string, replyAuthor: string): Map<string, string[]> {
-  const replies = new Map<string, string[]>();
-  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: string[] = [];
-      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 { success: true, markdown: result, insertions: stats.placed + stats.lowConfidence };
+  } catch (err: any) {
+    return { success: false, markdown, insertions: 0, error: err.message };
   }
-
-  return replies;
 }
 
 /**
- * Realign comments from reference DOCX to markdown
+ * Realign the reference docx's comments onto a markdown file in place.
  */
 export async function realignComments(
   docxPath: string,
   markdownPath: string,
-  options: RealignOptions = {}
+  options: RealignOptions = {},
 ): Promise<RealignResult> {
-  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');
+  const { dryRun = false, author, replyAuthor } = options;
 
-  // 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*\{>>[\s\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: CommentInsertion[] = [];
-  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 ?? 0) + 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)}"`,
-      });
-    }
+  const original = fs.readFileSync(markdownPath, 'utf-8');
+  const realigned = await realignMarkdown(docxPath, original, { author, replyAuthor });
+  if (!realigned.success) {
+    return { success: false, insertions: 0, error: realigned.error };
   }
 
-  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 };
+    return { success: true, dryRun: true, insertions: realigned.insertions };
   }
 
-  // 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)
- */
-export async function realignMarkdown(
-  docxPath: string,
-  markdown: string,
-  options: RealignMarkdownOptions = {}
-): Promise<RealignMarkdownResult> {
-  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*\{>>[\s\S]+?<<\}/g, '');
-
-    // Parse markdown paragraphs
-    const mdParagraphs = parseMdParagraphs(result);
-
-    // Track insertions
-    const insertions: Array<{ position: number; text: string }> = [];
-
-    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 ?? 0) + 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: any) {
-    return { success: false, markdown, insertions: 0, error: err.message };
-  }
+  fs.writeFileSync(markdownPath, realigned.markdown);
+  return { success: true, insertions: realigned.insertions };
 }