@adeu/core 1.17.1 → 1.18.0

package/src/ingest.ts

@@ -184,13 +184,28 @@ export function extract_table(
 
       if (!first_cell) cell_cursor += 3;
 
-      const cell_content = _extract_blocks(
+      let cell_content = _extract_blocks(
         cell,
         comments_map,
         cleanView,
         cell_cursor,
         paragraph_offsets,
       );
+      // Emit a stable, document-native anchor for this cell so empty/short
+      // value cells are addressable by the engine. Reuses the {#...} bookmark
+      // projection (already protected by validate_edit_strings and resolvable
+      // via the mapper). We key on the cell's first paragraph w14:paraId, which
+      // Word assigns and keeps stable across reads.
+      if (!cleanView) {
+        const firstP = cell._element.getElementsByTagName("w:p")[0] as
+          | Element
+          | undefined;
+        const paraId = firstP ? firstP.getAttribute("w14:paraId") : null;
+        if (paraId) {
+          const anchor = `{#cell:${paraId}}`;
+          cell_content = cell_content + anchor;
+        }
+      }
       cell_texts.push(cell_content);
       cell_cursor += cell_content.length;
       first_cell = false;

package/src/mapper.ts

@@ -260,7 +260,29 @@ export class DocumentMapper {
           current += 3;
         }
 
+        const cell_start = current;
         current = this._map_blocks(cell, current);
+
+        // Parity with ingest.extract_table: emit a {#cell:<paraId>} anchor and
+        // bind a zero-width span to the cell's first paragraph so the engine
+        // can resolve "write into this cell" even when the cell is empty
+        // (pPr-only paragraph with no run).
+        if (!this.clean_view && !this.original_view) {
+          const firstP = cell._element.getElementsByTagName("w:p")[0] as
+            | Element
+            | undefined;
+          const paraId = firstP ? firstP.getAttribute("w14:paraId") : null;
+          if (paraId && firstP) {
+            // Zero-width span bound to the empty cell paragraph: gives
+            // get_insertion_anchor a paragraph to land on. Placed at the anchor
+            // token offset so resolution targets THIS cell, not a neighbour.
+            const cellPara = new Paragraph(firstP, cell);
+            this._add_virtual_text("", current, cellPara);
+            const anchor = `{#cell:${paraId}}`;
+            this._add_virtual_text(anchor, current, cellPara);
+            current += anchor.length;
+          }
+        }
         cells_processed += 1;
       }
 
@@ -738,7 +760,7 @@ export class DocumentMapper {
     target_text = this._replace_smart_quotes(target_text);
 
     const parts: string[] = [];
-    const token_pattern = /(\[_+\])|(\s+)|(['"])|([.,;:\/])/g;
+    const token_pattern = /(\[_+\])|(\s+)|(['"])|([.,;:\/\-\[\](){}+=$?*!|#^<>\\%&@~`_])/g;
 
     let last_idx = 0;
     let match;

package/src/markup.ts

@@ -138,7 +138,7 @@ export function _make_fuzzy_regex(target_text: string): string {
   target_text = _replace_smart_quotes(target_text);
 
   const parts: string[] = [];
-  const token_pattern = /(_+)|(\s+)|(['"])|([.,;:\/])/g;
+  const token_pattern = /(_+)|(\s+)|(['"])|([.,;:\/\-\[\](){}+=$?*!|#^<>\\%&@~`])/g;
 
   // Note: JS does not support atomic groups (?>...).
   // However, because we only match markdown characters * and _,

package/src/reject_and_nested_redline.test.ts

@@ -0,0 +1,137 @@
+/**
+ * Canonical track-change semantics for editing inside another author's pending
+ * insertion, plus reject_all_revisions round-trips. Mirrors the Python suite
+ * python/tests/test_reject_and_nested_redline.py (Python is canonical).
+ *
+ * When an author edits/deletes text inside another author's still-pending
+ * <w:ins>, the deletion is NESTED inside that <w:ins> and the replacement is a
+ * SIBLING after it (splitting the insertion if the edit is mid-insertion);
+ * <w:ins> is never nested in <w:ins>. This preserves authorship and makes
+ * reject-all revert the contingent text to nothing rather than promoting an
+ * unaccepted proposal to committed body text.
+ */
+import { describe, it, expect } from "vitest";
+import { createTestDocument, addParagraph } from "./test-utils.js";
+import { RedlineEngine } from "./engine.js";
+import { extractTextFromBuffer } from "./ingest.js";
+
+function foreignInsDoc(doc: any) {
+  const xmlDoc = doc.element.ownerDocument!;
+  const p = addParagraph(doc, "The party shall provide ");
+  const ins = xmlDoc.createElement("w:ins");
+  ins.setAttribute("w:id", "201");
+  ins.setAttribute("w:author", "Supplier's Counsel");
+  const r = xmlDoc.createElement("w:r");
+  const t = xmlDoc.createElement("w:t");
+  t.textContent = "written notice";
+  r.appendChild(t);
+  ins.appendChild(r);
+  p.appendChild(ins);
+  const r2 = xmlDoc.createElement("w:r");
+  const t2 = xmlDoc.createElement("w:t");
+  t2.textContent = " within 30 days.";
+  r2.appendChild(t2);
+  p.appendChild(r2);
+  return p;
+}
+
+async function cleanText(doc: any): Promise<string> {
+  return await extractTextFromBuffer(await doc.save());
+}
+
+describe("Canonical nesting + reject round-trips", () => {
+  it("modify inside a foreign insertion nests del and emits a sibling ins (no ins-in-ins)", async () => {
+    const doc = await createTestDocument();
+    const p = foreignInsDoc(doc);
+    const engine = new RedlineEngine(doc, "Reviewer AI");
+    const res = engine.process_batch(
+      [{ type: "modify", target_text: "written notice", new_text: "email notification" }] as any,
+      false,
+    );
+    expect(res.edits_applied).toBe(1);
+    expect(res.edits_skipped).toBe(0);
+
+    // del nested inside Supplier's <w:ins>; no <w:ins> nested in <w:ins>.
+    const insNodes = Array.from(p.getElementsByTagName("w:ins"));
+    const supplierIns = insNodes.find(
+      (i) => i.getAttribute("w:author") === "Supplier's Counsel",
+    )!;
+    expect(supplierIns).toBeTruthy();
+    expect(supplierIns.getElementsByTagName("w:del").length).toBeGreaterThan(0);
+    for (const i of insNodes) {
+      expect(i.getElementsByTagName("w:ins").length).toBe(0);
+    }
+    // Reviewer's replacement insertion exists as a separate node.
+    expect(
+      insNodes.some(
+        (i) =>
+          i.getAttribute("w:author") === "Reviewer AI" &&
+          (i.textContent || "").includes("email notification"),
+      ),
+    ).toBe(true);
+  });
+
+  it("accept-all and reject-all round-trip correctly for a foreign-ins modify", async () => {
+    const accDoc = await createTestDocument();
+    foreignInsDoc(accDoc);
+    const ae = new RedlineEngine(accDoc, "Reviewer AI");
+    ae.process_batch(
+      [{ type: "modify", target_text: "written notice", new_text: "email notification" }] as any,
+      false,
+    );
+    ae.accept_all_revisions();
+    expect(await cleanText(accDoc)).toContain(
+      "The party shall provide email notification within 30 days.",
+    );
+
+    const rejDoc = await createTestDocument();
+    foreignInsDoc(rejDoc);
+    const re = new RedlineEngine(rejDoc, "Reviewer AI");
+    re.process_batch(
+      [{ type: "modify", target_text: "written notice", new_text: "email notification" }] as any,
+      false,
+    );
+    re.reject_all_revisions();
+    const rejected = await cleanText(rejDoc);
+    // Reject reverts to the true baseline: the pending insertion vanishes.
+    expect(rejected).not.toContain("written notice");
+    expect(rejected).not.toContain("email notification");
+    expect(rejected).toContain("The party shall provide  within 30 days.");
+  });
+
+  it("insertion inside a foreign ins splits (no ins-in-ins) and round-trips", async () => {
+    const doc = await createTestDocument();
+    const p = foreignInsDoc(doc);
+    const e = new RedlineEngine(doc, "Reviewer AI");
+    // A modify that trims to a pure INSERTION inside the foreign <w:ins>.
+    const res = e.process_batch(
+      [{ type: "modify", target_text: "written notice", new_text: "written notice please" }] as any,
+      false,
+    );
+    expect(res.edits_applied).toBe(1);
+    for (const i of Array.from(p.getElementsByTagName("w:ins"))) {
+      expect(i.getElementsByTagName("w:ins").length).toBe(0);
+    }
+
+    const ad = await createTestDocument();
+    foreignInsDoc(ad);
+    const ae = new RedlineEngine(ad, "Reviewer AI");
+    ae.process_batch(
+      [{ type: "modify", target_text: "written notice", new_text: "written notice please" }] as any,
+      false,
+    );
+    ae.accept_all_revisions();
+    expect(await cleanText(ad)).toContain(
+      "The party shall provide written notice please within 30 days.",
+    );
+  });
+
+  it("reject-all restores the original for an own-author edit", async () => {
+    const doc = await createTestDocument();
+    addParagraph(doc, "The cat sat.");
+    const e = new RedlineEngine(doc, "Z");
+    e.process_batch([{ type: "modify", target_text: "cat", new_text: "dog" }] as any, false);
+    e.reject_all_revisions();
+    expect(await cleanText(doc)).toContain("The cat sat.");
+  });
+});

package/src/repro.feedback.test.ts

@@ -0,0 +1,160 @@
+// FILE: node/packages/core/src/repro.feedback.test.ts
+//
+// Regression repros for the field observations against the Node engine.
+//
+// STYLE: these assert the DESIRED (correct) behaviour, so a test is RED while
+// the bug is present and turns GREEN once the engine is fixed. (This is the
+// "isolate the bug before fixing" pattern from AI_CONTEXT.md > Testing.)
+//
+//   Issue 1 — accept + modify the same span in one batch  -> currently RED (bug)
+//   Issue 2 — comment-only run-shredding                  -> NOT a bug; see note
+//
+// (Issue 3 lives in node/packages/mcp-server/src/repro.feedback.test.ts.)
+
+import { describe, it, expect } from "vitest";
+import { RedlineEngine } from "./engine.js";
+import { createTestDocument, addParagraph } from "./test-utils.js";
+
+/** Append a paragraph that already contains a tracked insertion by `author`. */
+function addParagraphWithForeignInsertion(
+  doc: any,
+  prefix: string,
+  insertedText: string,
+  insId: string,
+  author: string,
+): Element {
+  const x = doc.element.ownerDocument!;
+  const p = x.createElement("w:p");
+  const r0 = x.createElement("w:r");
+  const t0 = x.createElement("w:t");
+  t0.textContent = prefix;
+  t0.setAttribute("xml:space", "preserve");
+  r0.appendChild(t0);
+  p.appendChild(r0);
+
+  const ins = x.createElement("w:ins");
+  ins.setAttribute("w:id", insId);
+  ins.setAttribute("w:author", author);
+  ins.setAttribute("w:date", "2024-01-01T00:00:00Z");
+  const r = x.createElement("w:r");
+  const t = x.createElement("w:t");
+  t.textContent = insertedText;
+  r.appendChild(t);
+  ins.appendChild(r);
+  p.appendChild(ins);
+
+  doc.element.appendChild(p);
+  return p;
+}
+
+function countTag(el: any, tag: string): number {
+  let n = 0;
+  const walk = (node: any) => {
+    if (node.tagName === tag) n++;
+    let c = node.firstChild;
+    while (c) {
+      if (c.nodeType === 1) walk(c);
+      c = c.nextSibling;
+    }
+  };
+  walk(el);
+  return n;
+}
+
+describe("Field feedback repro — Node engine", () => {
+  // ───────────────────────────────────────────────────────────────────────
+  // ISSUE 1 — RED until fixed.
+  //
+  // Accepting a foreign author's insertion and then editing that now-accepted
+  // text, in a SINGLE batch, MUST succeed: by the time the modify runs the span
+  // has been accepted and is no longer foreign. Node rejects it because the
+  // unified up-front validation pass (engine.ts `_process_batch_internal`, the
+  // `validate_edits(edits)` call BEFORE `apply_review_actions`) validates the
+  // modify against the PRE-accept document. This test fails today and will pass
+  // once validation runs after the accepts are applied.
+  // ───────────────────────────────────────────────────────────────────────
+  it("Issue 1: accept + modify of the SAME foreign insertion in one batch should succeed", async () => {
+    const doc = await createTestDocument();
+    addParagraphWithForeignInsertion(
+      doc,
+      "The term is ",
+      "24 months",
+      "5",
+      "Supplier's Counsel",
+    );
+
+    const engine = new RedlineEngine(doc, "Acme's Counsel");
+    const batch = [
+      { type: "accept", target_id: "Chg:5" },
+      { type: "modify", target_text: "24 months", new_text: "36 months" },
+    ] as any[];
+
+    // DESIRED behaviour — RED on current Node (throws "active insertion from
+    // another author"), GREEN after the fix.
+    const stats = engine.process_batch(batch, false);
+    expect(stats.actions_applied).toBe(1);
+    expect(stats.edits_applied).toBe(1);
+    expect(stats.edits_skipped).toBe(0);
+  });
+
+  it("Issue 1 (control, GREEN): the same accept + modify succeeds across two batches", async () => {
+    // Proves the rejection above is purely a single-round-trip batching
+    // artifact — the content and intent are valid.
+    const doc = await createTestDocument();
+    addParagraphWithForeignInsertion(
+      doc,
+      "The term is ",
+      "24 months",
+      "5",
+      "Supplier's Counsel",
+    );
+
+    const engine = new RedlineEngine(doc, "Acme's Counsel");
+    const r1 = engine.process_batch([{ type: "accept", target_id: "Chg:5" }], false);
+    expect(r1.actions_applied).toBe(1);
+    const r2 = engine.process_batch(
+      [{ type: "modify", target_text: "24 months", new_text: "36 months" }],
+      false,
+    );
+    expect(r2.edits_applied).toBe(1);
+  });
+
+  // ───────────────────────────────────────────────────────────────────────
+  // ISSUE 2 — NOT a bug in the current engine, so there is nothing to fail on.
+  // The described mechanism (one match whose physical runs are shredded →
+  // comment id duplicated per run segment) does not occur: COMMENT_ONLY anchors
+  // a single range across the first→last run regardless of fragmentation. These
+  // assertions are GREEN BY DESIGN and exist as evidence for the "not
+  // replicable" conclusion. (The real gap — no dedicated comment-only change
+  // type, so comments must ride a self-replacing ModifyText — is a feature
+  // request, not a failing-test-able defect.)
+  // ───────────────────────────────────────────────────────────────────────
+  it("Issue 2 (GREEN, evidence): self-replacement comment over 9 fragmented runs emits ONE comment", async () => {
+    const doc = await createTestDocument();
+    const x = doc.element.ownerDocument!;
+    const p = x.createElement("w:p");
+    const words = [
+      "The ", "Purchase ", "Price ", "is ", "[   ] ",
+      "dollars ", "per ", "unit ", "total.",
+    ];
+    words.forEach((w, i) => {
+      if (i % 2 === 0) p.appendChild(x.createElement("w:proofErr"));
+      const r = x.createElement("w:r");
+      const t = x.createElement("w:t");
+      t.textContent = w;
+      t.setAttribute("xml:space", "preserve");
+      r.appendChild(t);
+      p.appendChild(r);
+    });
+    doc.element.appendChild(p);
+
+    const engine = new RedlineEngine(doc, "Reviewer");
+    const sentence = words.join("").trim();
+    engine.process_batch(
+      [{ type: "modify", target_text: sentence, new_text: sentence, comment: "Missing value" }],
+      false,
+    );
+
+    expect(countTag(doc.element, "w:commentReference")).toBe(1);
+  });
+});

package/src/repro.report.test.ts

@@ -0,0 +1,132 @@
+import { describe, it, expect } from "vitest";
+import { createTestDocument, addParagraph, addTable, setCellText } from "./test-utils.js";
+import { RedlineEngine } from "./engine.js";
+import { DocumentObject } from "./docx/bridge.js";
+
+describe("Webinar Report Bug Reproductions", () => {
+  it("Bug 1: Diff Engine Fragility (Token-Splitting Punctuation)", async () => {
+    const doc = await createTestDocument();
+    const xmlDoc = doc.element.ownerDocument!;
+    const p = xmlDoc.createElement("w:p");
+
+    // Replicate MS Word fragmented runs for token-splitting punctuation: [Company Name]
+    // with style/formatting run fragmentation where only some runs are bold.
+    // This generates: **[**Company Name**]**
+    // The target "[Company Name]" will fail to be matched because brackets are not treated
+    // as fuzzy boundaries, so the fuzzy regex expects "[Company" directly without the intermediate "**".
+    const r1 = xmlDoc.createElement("w:r");
+    const rPr1 = xmlDoc.createElement("w:rPr");
+    rPr1.appendChild(xmlDoc.createElement("w:b"));
+    r1.appendChild(rPr1);
+    const t1 = xmlDoc.createElement("w:t");
+    t1.textContent = "[";
+    r1.appendChild(t1);
+    p.appendChild(r1);
+
+    const r2 = xmlDoc.createElement("w:r");
+    // Run 2 is NOT bold
+    const t2 = xmlDoc.createElement("w:t");
+    t2.textContent = "Company Name";
+    r2.appendChild(t2);
+    p.appendChild(r2);
+
+    const r3 = xmlDoc.createElement("w:r");
+    const rPr3 = xmlDoc.createElement("w:rPr");
+    rPr3.appendChild(xmlDoc.createElement("w:b"));
+    r3.appendChild(rPr3);
+    const t3 = xmlDoc.createElement("w:t");
+    t3.textContent = "]";
+    r3.appendChild(t3);
+    p.appendChild(r3);
+
+    doc.element.appendChild(p);
+
+    const engine = new RedlineEngine(doc);
+
+    // Under correct engine behavior, targeting "[Company Name]" should succeed.
+    // However, on the unpatched codebase, it throws a BatchValidationError (Target text not found).
+    const res = engine.process_batch([
+      {
+        type: "modify",
+        target_text: "[Company Name]",
+        new_text: "Google LLC",
+      } as any,
+    ]);
+
+    expect(res.edits_applied).toBe(1);
+    expect(res.edits_skipped).toBe(0);
+  });
+
+  it("Bug 2: editing across a foreign author's insertion boundary is refused (provenance-safe)", async () => {
+    const doc = await createTestDocument();
+    const xmlDoc = doc.element.ownerDocument!;
+
+    const p = addParagraph(doc, "The party shall provide ");
+    const ins = xmlDoc.createElement("w:ins");
+    ins.setAttribute("w:id", "123");
+    ins.setAttribute("w:author", "Supplier's Counsel");
+    const r = xmlDoc.createElement("w:r");
+    const t = xmlDoc.createElement("w:t");
+    t.textContent = "written notice";
+    r.appendChild(t);
+    ins.appendChild(r);
+    p.appendChild(ins);
+
+    const suffixRun = xmlDoc.createElement("w:r");
+    const suffixText = xmlDoc.createElement("w:t");
+    suffixText.textContent = " within 30 days.";
+    suffixRun.appendChild(suffixText);
+    p.appendChild(suffixRun);
+
+    const engine = new RedlineEngine(doc, "Reviewer");
+
+    // The target STRADDLES Supplier's Counsel's pending <w:ins> boundary
+    // (foreign-inserted "written notice" + plain " within 30 days."). Canonical
+    // behavior is to REFUSE rather than silently lift the foreign insertion into
+    // committed text (which would launder another author's pending proposal and
+    // erase their provenance). The agent must accept that change first, or scope
+    // the edit within / outside the insertion. (Matches the Python engine.)
+    const edit = {
+      type: "modify",
+      target_text: "written notice within 30 days.",
+      new_text: "notice within 15 business days.",
+    };
+    expect(() => engine.process_batch([edit as any], false)).toThrow(
+      /active insertion from another author/,
+    );
+  });
+
+  it("Bug 3: Table Layout Ambiguity and Markdown Loss of Fidelity", async () => {
+    const doc = await createTestDocument();
+    
+    // Create a table with 2 rows, 4 columns
+    const tbl = addTable(doc, 2, 4);
+    
+    // Set cell text to match identical structure: Date | | | 
+    setCellText(tbl, 0, 0, "Date");
+    setCellText(tbl, 0, 1, "");
+    setCellText(tbl, 0, 2, "");
+    setCellText(tbl, 0, 3, "");
+    
+    setCellText(tbl, 1, 0, "Date");
+    setCellText(tbl, 1, 1, "");
+    setCellText(tbl, 1, 2, "");
+    setCellText(tbl, 1, 3, "");
+
+    const buf = await doc.save();
+    const midDoc = await DocumentObject.load(buf);
+    const engine = new RedlineEngine(midDoc);
+
+    // Target one of the empty rows to apply a date.
+    const edit = {
+      type: "modify",
+      target_text: "Date |  |  | ",
+      new_text: "Date | June 29, 2026 |  | ",
+    };
+
+    // Ideally, the system should allow distinct targeting of cells (e.g. preserving grid coordinates).
+    // But due to the coordinate-flattening design flaw, it throws "Ambiguous match".
+    const res = engine.process_batch([edit as any]);
+    expect(res.edits_applied).toBe(1);
+  });
+});