docrev 0.9.6 → 0.9.11

package/lib/wordcomments.ts

@@ -72,8 +72,35 @@ function generateParaId(commentIdx: number, paraNum: number): string {
  * - comments: array with author, text, isReply, parentIdx
  */
 export function prepareMarkdownWithMarkers(markdown: string): PrepareResult {
-  // Match all comments with optional anchor
-  const commentPattern = /\{>>(.+?)<<\}(?:\s*\[([^\]]+)\]\{\.mark\})?/g;
+  // Match the comment block first; extend manually to capture an optional
+  // trailing `[anchor]{.mark}` span. A regex `[^\]]+` for the anchor would
+  // bail on the inner `]` of nested syntax (e.g. `[[0..9]]{.mark}` or
+  // `[*phrase*]{.mark}` after pandoc-rewriting), so we walk the brackets
+  // ourselves and verify a `{.mark}` suffix.
+  const commentPattern = /\{>>([\s\S]+?)<<\}/g;
+
+  function tryParseTrailingAnchor(
+    text: string,
+    fromIdx: number,
+  ): { anchor: string; endIdx: number } | null {
+    let i = fromIdx;
+    while (i < text.length && /\s/.test(text[i] ?? '')) i++;
+    if (text[i] !== '[') return null;
+    let depth = 1;
+    let j = i + 1;
+    while (j < text.length) {
+      const ch = text[j];
+      if (ch === '[') depth++;
+      else if (ch === ']') {
+        depth--;
+        if (depth === 0) break;
+      }
+      j++;
+    }
+    if (depth !== 0) return null;
+    if (text.slice(j + 1, j + 8) !== '{.mark}') return null;
+    return { anchor: text.slice(i + 1, j), endIdx: j + 8 };
+  }
 
   const rawMatches: ParsedComment[] = [];
   let match: RegExpExecArray | null;
@@ -87,14 +114,25 @@ export function prepareMarkdownWithMarkers(markdown: string): PrepareResult {
       text = content.slice(colonIdx + 1).trim();
     }
 
+    const commentEnd = match.index + match[0].length;
+    const trailing = tryParseTrailingAnchor(markdown, commentEnd);
+
     rawMatches.push({
       author,
       text,
-      anchor: match[2] || null,
+      anchor: trailing ? trailing.anchor : null,
       start: match.index,
-      end: match.index + match[0].length,
-      fullMatch: match[0]
+      end: trailing ? trailing.endIdx : commentEnd,
+      fullMatch: markdown.slice(match.index, trailing ? trailing.endIdx : commentEnd),
     });
+
+    // Advance regex lastIndex past the consumed anchor so the next iteration
+    // doesn't re-scan inside it (e.g. `[*emphasis*]{.mark}` would otherwise
+    // tempt the matcher to look for another `{>>...<<}` in the body of the
+    // anchor span).
+    if (trailing) {
+      commentPattern.lastIndex = trailing.endIdx;
+    }
   }
 
   if (rawMatches.length === 0) {
@@ -179,10 +217,11 @@ export function prepareMarkdownWithMarkers(markdown: string): PrepareResult {
 
     if (c.isReply) {
       // Reply: remove from document entirely (will be in comments.xml only)
-      // Also consume leading whitespace to avoid double spaces
+      // Also consume one preceding whitespace char to avoid double spaces.
+      // We deliberately consume at most one — walking arbitrarily backwards
+      // would shift positions that lower-index comments still depend on.
       let removeStart = c.start;
-      const charBefore = markedMarkdown[removeStart - 1];
-      while (removeStart > 0 && charBefore && /\s/.test(charBefore)) {
+      if (removeStart > 0 && /\s/.test(markedMarkdown[removeStart - 1] ?? '')) {
         removeStart--;
       }
 
@@ -205,10 +244,10 @@ export function prepareMarkdownWithMarkers(markdown: string): PrepareResult {
     } else {
       // Parent comment
       if (c.anchorFromReply) {
-        // Anchor markers are placed by the reply, just remove this comment
+        // Anchor markers are placed by the reply, just remove this comment.
+        // Consume one preceding whitespace char only (see reply branch above).
         let removeStart = c.start;
-        const charBefore = markedMarkdown[removeStart - 1];
-        while (removeStart > 0 && charBefore && /\s/.test(charBefore)) {
+        if (removeStart > 0 && /\s/.test(markedMarkdown[removeStart - 1] ?? '')) {
           removeStart--;
         }
         markedMarkdown = markedMarkdown.slice(0, removeStart) + markedMarkdown.slice(c.end);
@@ -421,93 +460,152 @@ export async function injectCommentsAtMarkers(
       const endMarker = `${MARKER_END_PREFIX}${idx}${MARKER_SUFFIX}`;
 
       const startPos = documentXml.indexOf(startMarker);
-      const endPos = documentXml.indexOf(endMarker);
+      const endPos = documentXml.indexOf(endMarker, startPos + startMarker.length);
 
       if (startPos === -1 || endPos === -1) continue;
 
-      // Find the <w:r> containing the markers
-      const rStartBefore = documentXml.lastIndexOf('<w:r>', startPos);
-      const rStartOpen = documentXml.lastIndexOf('<w:r ', startPos);
-      const rStart = Math.max(rStartBefore, rStartOpen);
-      const rEndPos = documentXml.indexOf('</w:r>', endPos);
-
-      if (rStart === -1 || rEndPos === -1) continue;
-
-      const rEnd = rEndPos + '</w:r>'.length;
-      const runContent = documentXml.slice(rStart, rEnd);
-
-      // Extract styling
-      const rPrMatch = runContent.match(/<w:rPr>[\s\S]*?<\/w:rPr>/);
-      const rPr = rPrMatch ? rPrMatch[0] : '';
-
-      // Extract text
-      const textMatch = runContent.match(/<w:t[^>]*>([\s\S]*?)<\/w:t>/);
-      if (!textMatch) continue;
-
-      const fullText = textMatch[1] ?? '';
-      const tElementMatch = textMatch[0].match(/<w:t[^>]*>/);
-      if (!tElementMatch) continue;
-      const tElement = tElementMatch[0];
-
-      const startInText = fullText.indexOf(startMarker);
-      const endInText = fullText.indexOf(endMarker);
-      if (startInText === -1 || endInText === -1) continue;
+      // Find the runs containing each marker. Pandoc may split a single
+      // markdown anchor across multiple <w:r> blocks when it applies styling
+      // mid-anchor (smart-quote substitution, *italic*, `code`, **bold**).
+      // The same-run path (current happy path) collapses into the multi-run
+      // path when start and end runs coincide.
+      const startRunOpen = Math.max(
+        documentXml.lastIndexOf('<w:r>', startPos),
+        documentXml.lastIndexOf('<w:r ', startPos),
+      );
+      const startRunCloseIdx = documentXml.indexOf('</w:r>', startPos);
+      const endRunOpen = Math.max(
+        documentXml.lastIndexOf('<w:r>', endPos),
+        documentXml.lastIndexOf('<w:r ', endPos),
+      );
+      const endRunCloseIdx = documentXml.indexOf('</w:r>', endPos);
+
+      if (
+        startRunOpen === -1 || startRunCloseIdx === -1 ||
+        endRunOpen === -1 || endRunCloseIdx === -1
+      ) continue;
+
+      const startRunClose = startRunCloseIdx + '</w:r>'.length;
+      const endRunClose = endRunCloseIdx + '</w:r>'.length;
+
+      const startRunFull = documentXml.slice(startRunOpen, startRunClose);
+      const endRunFull = documentXml.slice(endRunOpen, endRunClose);
+
+      // Extract <w:rPr> and <w:t> element shape from each run. Both pieces
+      // are needed verbatim so a textBefore split keeps its original styling
+      // and so the post-anchor textAfter render keeps the end run's styling.
+      function dissectRun(runXml: string, marker: string): {
+        rPr: string;
+        tElement: string;
+        textBefore: string;
+        textAfter: string;
+      } | null {
+        const rPrMatch = runXml.match(/<w:rPr>[\s\S]*?<\/w:rPr>/);
+        const tMatch = runXml.match(/<w:t[^>]*>([\s\S]*?)<\/w:t>/);
+        if (!tMatch) return null;
+        const tOpenMatch = tMatch[0].match(/<w:t[^>]*>/);
+        if (!tOpenMatch) return null;
+        const tContent = tMatch[1] ?? '';
+        const markerInT = tContent.indexOf(marker);
+        if (markerInT === -1) return null;
+        return {
+          rPr: rPrMatch ? rPrMatch[0] : '',
+          tElement: tOpenMatch[0],
+          textBefore: tContent.slice(0, markerInT),
+          textAfter: tContent.slice(markerInT + marker.length),
+        };
+      }
 
-      let textBefore = fullText.slice(0, startInText);
-      let anchorText = fullText.slice(startInText + startMarker.length, endInText);
-      let textAfter = fullText.slice(endInText + endMarker.length);
+      let replacement = '';
+      const replies = commentsWithIds.filter(c => c.isReply && c.parentIdx === comment?.commentIdx);
 
-      // When anchor is empty, use the first word from textAfter as fallback
-      if (!anchorText && textAfter) {
-        const wordMatch = textAfter.match(/^\s*(\S+)/);
-        if (wordMatch) {
-          anchorText = wordMatch[1] ?? '';
-          textAfter = textAfter.slice(wordMatch[0].length);
+      const emitRangeStarts = () => {
+        replacement += `<w:commentRangeStart w:id="${comment.id}"/>`;
+        for (const reply of replies) {
+          replacement += `<w:commentRangeStart w:id="${reply.id}"/>`;
         }
-      }
+      };
+
+      const emitRangeEnds = () => {
+        replacement += `<w:commentRangeEnd w:id="${comment.id}"/>`;
+        replacement += `<w:r><w:commentReference w:id="${comment.id}"/></w:r>`;
+        for (const reply of replies) {
+          replacement += `<w:commentRangeEnd w:id="${reply.id}"/>`;
+          replacement += `<w:r><w:commentReference w:id="${reply.id}"/></w:r>`;
+          injectedIds.add(reply.id);
+        }
+      };
+
+      if (startRunOpen === endRunOpen) {
+        // Same-run path: both markers live inside one <w:t>. Original logic.
+        const startInfo = dissectRun(startRunFull, startMarker);
+        if (!startInfo) continue;
+        const fullText = startInfo.textBefore + startMarker + startInfo.textAfter;
+        const endInTextRel = startInfo.textAfter.indexOf(endMarker);
+        if (endInTextRel === -1) continue;
+        const anchorTextSame = startInfo.textAfter.slice(0, endInTextRel);
+        let textAfter = startInfo.textAfter.slice(endInTextRel + endMarker.length);
+        let anchorText = anchorTextSame;
+        let textBefore = startInfo.textBefore;
+
+        // Empty anchor: borrow the next word so the comment has something
+        // to anchor on. Then normalize the trailing double space.
+        if (!anchorText && textAfter) {
+          const wordMatch = textAfter.match(/^\s*(\S+)/);
+          if (wordMatch) {
+            anchorText = wordMatch[1] ?? '';
+            textAfter = textAfter.slice(wordMatch[0].length);
+          }
+        }
+        if (!anchorText && textBefore.endsWith(' ') && textAfter.startsWith(' ')) {
+          textAfter = textAfter.slice(1);
+        }
+        // Suppress unused warning for pre-empty-anchor fullText var
+        void fullText;
 
-      // When anchor is still empty, normalize double spaces to single space
-      if (!anchorText && textBefore.endsWith(' ') && textAfter.startsWith(' ')) {
-        textAfter = textAfter.slice(1); // Remove leading space from textAfter
+        if (textBefore) {
+          replacement += `<w:r>${startInfo.rPr}${startInfo.tElement}${textBefore}</w:t></w:r>`;
+        }
+        emitRangeStarts();
+        if (anchorText) {
+          replacement += `<w:r>${startInfo.rPr}${startInfo.tElement}${anchorText}</w:t></w:r>`;
+        }
+        emitRangeEnds();
+        if (textAfter) {
+          replacement += `<w:r>${startInfo.rPr}${startInfo.tElement}${textAfter}</w:t></w:r>`;
+        }
+        documentXml = documentXml.slice(0, startRunOpen) + replacement + documentXml.slice(startRunClose);
+        injectedIds.add(comment.id);
+        continue;
       }
 
-      // Build replacement
-      let replacement = '';
+      // Multi-run path: markers sit in different <w:r> blocks because pandoc
+      // applied mid-anchor styling. Split the start run at the start marker,
+      // keep all middle runs verbatim (they carry the styled anchor portions),
+      // split the end run at the end marker.
+      const startInfo = dissectRun(startRunFull, startMarker);
+      const endInfo = dissectRun(endRunFull, endMarker);
+      if (!startInfo || !endInfo) continue;
 
-      if (textBefore) {
-        replacement += `<w:r>${rPr}${tElement}${textBefore}</w:t></w:r>`;
-      }
-
-      // Find replies to this comment
-      const replies = commentsWithIds.filter(c => c.isReply && c.parentIdx === comment?.commentIdx);
+      const middle = documentXml.slice(startRunClose, endRunOpen);
 
-      // Start ranges for parent AND all replies (nested)
-      replacement += `<w:commentRangeStart w:id="${comment.id}"/>`;
-      for (const reply of replies) {
-        replacement += `<w:commentRangeStart w:id="${reply.id}"/>`;
+      if (startInfo.textBefore) {
+        replacement += `<w:r>${startInfo.rPr}${startInfo.tElement}${startInfo.textBefore}</w:t></w:r>`;
       }
-
-      // Anchor text
-      if (anchorText) {
-        replacement += `<w:r>${rPr}${tElement}${anchorText}</w:t></w:r>`;
+      emitRangeStarts();
+      if (startInfo.textAfter) {
+        replacement += `<w:r>${startInfo.rPr}${startInfo.tElement}${startInfo.textAfter}</w:t></w:r>`;
       }
-
-      // End parent range and reference (NO rStyle wrapper - required for threading)
-      replacement += `<w:commentRangeEnd w:id="${comment.id}"/>`;
-      replacement += `<w:r><w:commentReference w:id="${comment.id}"/></w:r>`;
-
-      // End reply ranges and references (same position as parent, NO rStyle wrapper)
-      for (const reply of replies) {
-        replacement += `<w:commentRangeEnd w:id="${reply.id}"/>`;
-        replacement += `<w:r><w:commentReference w:id="${reply.id}"/></w:r>`;
-        injectedIds.add(reply.id);
+      replacement += middle;
+      if (endInfo.textBefore) {
+        replacement += `<w:r>${endInfo.rPr}${endInfo.tElement}${endInfo.textBefore}</w:t></w:r>`;
       }
-
-      if (textAfter) {
-        replacement += `<w:r>${rPr}${tElement}${textAfter}</w:t></w:r>`;
+      emitRangeEnds();
+      if (endInfo.textAfter) {
+        replacement += `<w:r>${endInfo.rPr}${endInfo.tElement}${endInfo.textAfter}</w:t></w:r>`;
       }
 
-      documentXml = documentXml.slice(0, rStart) + replacement + documentXml.slice(rEnd);
+      documentXml = documentXml.slice(0, startRunOpen) + replacement + documentXml.slice(endRunClose);
       injectedIds.add(comment.id);
     }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "docrev",
-  "version": "0.9.6",
+  "version": "0.9.11",
   "description": "Academic paper revision workflow: Word ↔ Markdown round-trips, DOI validation, reviewer comments",
   "type": "module",
   "types": "dist/lib/types.d.ts",

package/skill/REFERENCE.md

@@ -21,11 +21,38 @@ rev import manuscript.docx --output ./project
 ### rev sync
 Sync feedback from a reviewed Word document into existing markdown sections.
 ```bash
-rev sync reviewed.docx       # Updates markdown with track changes/comments
-rev sync                     # Auto-detect most recent .docx
+rev sync reviewed.docx          # Updates markdown with track changes/comments
+rev sync                        # Auto-detect most recent .docx
 rev sync reviewed.docx methods  # Sync only methods section
+rev sync reviewed.docx --comments-only  # Insert comments only; never modify prose
 ```
 
+`--comments-only` skips the Word→Markdown diff entirely. Use it when the
+markdown has been revised between sending the docx out for review and
+receiving it back: applying track changes from a stale draft would clobber
+newer edits, but comments still need to land. Comments are placed at
+fuzzy-matched anchors against the current prose. Pair with
+`rev verify-anchors` to see which ones won't fit before you run sync.
+
+### rev verify-anchors
+Report drift between Word comment anchors and the current markdown.
+```bash
+rev verify-anchors reviewed.docx       # Print per-comment match quality
+rev verify-anchors reviewed.docx --json  # Machine-readable report
+```
+
+Each comment is classified by how well its anchor still matches the current
+section prose:
+
+- `clean` – exact or whitespace-normalized hit
+- `drift` – anchor only matches via stripped-CriticMarkup or partial-prefix fallbacks
+- `context-only` – anchor text is gone, only surrounding context survives
+- `ambiguous` – multiple candidate positions; needs context to disambiguate
+- `unmatched` – nothing maps; user must place the comment manually
+
+Useful before `rev sync --comments-only` to plan which comments will land
+automatically and which need manual placement.
+
 ### rev build
 Build output documents from markdown sections.
 ```bash

package/skill/SKILL.md

@@ -44,10 +44,18 @@ Send to reviewers. They add comments and track changes in Word.
 ### 3. Import feedback
 
 ```bash
-rev sync reviewed.docx       # Updates markdown with annotations
-rev sync                     # Auto-detect most recent .docx
+rev sync reviewed.docx              # Updates markdown with annotations
+rev sync                            # Auto-detect most recent .docx
+rev sync reviewed.docx --comments-only  # Insert comments only; never modify prose
+rev verify-anchors reviewed.docx    # Report which anchors still match current prose
 ```
 
+Use `--comments-only` when the markdown has been revised between sending the
+docx out and receiving it back. Without the flag, track changes from a stale
+draft would clobber newer edits. With it, only comments are imported, placed
+at fuzzy-matched anchors against the current prose. Run `rev verify-anchors`
+first to see which comments will land cleanly and which need manual placement.
+
 ### 4. View and address comments
 
 ```bash
@@ -111,6 +119,8 @@ rev response                 # Generate point-by-point response letter
 | Create LaTeX project | `rev new my-project --template latex` |
 | Import Word doc | `rev import manuscript.docx` |
 | Sync Word feedback | `rev sync reviewed.docx` |
+| Sync comments only (prose unchanged) | `rev sync reviewed.docx --comments-only` |
+| Verify anchors against current prose | `rev verify-anchors reviewed.docx` |
 | Sync PDF comments | `rev sync annotated.pdf` |
 | Extract PDF comments | `rev pdf-comments annotated.pdf` |
 | Extract with highlighted text | `rev pdf-comments file.pdf --with-text` |

package/dist/package.json

@@ -1,137 +0,0 @@
-{
-  "name": "docrev",
-  "version": "0.9.4",
-  "description": "Academic paper revision workflow: Word ↔ Markdown round-trips, DOI validation, reviewer comments",
-  "type": "module",
-  "types": "dist/lib/types.d.ts",
-  "exports": {
-    ".": {
-      "types": "./dist/lib/annotations.d.ts",
-      "import": "./dist/lib/annotations.js"
-    },
-    "./annotations": {
-      "types": "./dist/lib/annotations.d.ts",
-      "import": "./dist/lib/annotations.js"
-    },
-    "./build": {
-      "types": "./dist/lib/build.d.ts",
-      "import": "./dist/lib/build.js"
-    },
-    "./citations": {
-      "types": "./dist/lib/citations.d.ts",
-      "import": "./dist/lib/citations.js"
-    },
-    "./crossref": {
-      "types": "./dist/lib/crossref.d.ts",
-      "import": "./dist/lib/crossref.js"
-    },
-    "./doi": {
-      "types": "./dist/lib/doi.d.ts",
-      "import": "./dist/lib/doi.js"
-    },
-    "./equations": {
-      "types": "./dist/lib/equations.d.ts",
-      "import": "./dist/lib/equations.js"
-    },
-    "./git": {
-      "types": "./dist/lib/git.d.ts",
-      "import": "./dist/lib/git.js"
-    },
-    "./journals": {
-      "types": "./dist/lib/journals.d.ts",
-      "import": "./dist/lib/journals.js"
-    },
-    "./merge": {
-      "types": "./dist/lib/merge.d.ts",
-      "import": "./dist/lib/merge.js"
-    },
-    "./sections": {
-      "types": "./dist/lib/sections.d.ts",
-      "import": "./dist/lib/sections.js"
-    },
-    "./word": {
-      "types": "./dist/lib/word.d.ts",
-      "import": "./dist/lib/word.js"
-    },
-    "./variables": {
-      "types": "./dist/lib/variables.d.ts",
-      "import": "./dist/lib/variables.js"
-    },
-    "./grammar": {
-      "types": "./dist/lib/grammar.d.ts",
-      "import": "./dist/lib/grammar.js"
-    },
-    "./trackchanges": {
-      "types": "./dist/lib/trackchanges.d.ts",
-      "import": "./dist/lib/trackchanges.js"
-    },
-    "./spelling": {
-      "types": "./dist/lib/spelling.d.ts",
-      "import": "./dist/lib/spelling.js"
-    },
-    "./wordcomments": {
-      "types": "./dist/lib/wordcomments.d.ts",
-      "import": "./dist/lib/wordcomments.js"
-    }
-  },
-  "engines": {
-    "node": ">=18.0.0"
-  },
-  "bin": {
-    "rev": "bin/rev.js"
-  },
-  "scripts": {
-    "build": "tsc && node scripts/postbuild.js",
-    "build:watch": "tsc --watch",
-    "dev": "tsx bin/rev.ts",
-    "test": "tsx --test test/*.test.js",
-    "test:ts": "tsx --test test/*.test.ts",
-    "test:watch": "node --test --watch test/*.test.js",
-    "test:coverage": "c8 --reporter=text --reporter=lcov node --test test/*.test.js",
-    "typecheck": "tsc --noEmit",
-    "prepublishOnly": "npm run build"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/gcol33/docrev.git"
-  },
-  "bugs": {
-    "url": "https://github.com/gcol33/docrev/issues"
-  },
-  "homepage": "https://github.com/gcol33/docrev#readme",
-  "keywords": [
-    "markdown",
-    "word",
-    "docx",
-    "track-changes",
-    "comments",
-    "academic",
-    "writing",
-    "pandoc",
-    "criticmarkup"
-  ],
-  "author": "Gilles Colling",
-  "license": "MIT",
-  "dependencies": {
-    "adm-zip": "^0.5.16",
-    "chalk": "^5.3.0",
-    "commander": "^12.0.0",
-    "dictionary-en": "^4.0.0",
-    "dictionary-en-gb": "^3.0.0",
-    "diff": "^8.0.2",
-    "mathml-to-latex": "^1.5.0",
-    "nspell": "^2.1.5",
-    "pdf-lib": "^1.17.1",
-    "pdfjs-dist": "^5.4.530",
-    "tsx": "^4.21.0",
-    "xml2js": "^0.6.2",
-    "yaml": "^2.8.2"
-  },
-  "devDependencies": {
-    "@types/adm-zip": "^0.5.7",
-    "@types/node": "^25.2.0",
-    "@types/xml2js": "^0.4.14",
-    "c8": "^10.1.2",
-    "typescript": "^5.9.3"
-  }
-}