@adeu/core 1.6.2

package/src/diff.ts

@@ -0,0 +1,251 @@
+import diff_match_patch from 'diff-match-patch';
+import { ModifyText } from './models.js';
+
+export function trim_common_context(target: string, new_val: string): [number, number] {
+  if (!target || !new_val) return [0, 0];
+
+  const isSpace = (char: string) => /\s/.test(char);
+
+  // 1. Prefix with Word Boundary Check
+  let prefix_len = 0;
+  let limit = Math.min(target.length, new_val.length);
+  while (prefix_len < limit && target[prefix_len] === new_val[prefix_len]) {
+    prefix_len++;
+  }
+
+  // Backtrack to nearest whitespace if we split a word
+  if (prefix_len < target.length && prefix_len < new_val.length) {
+    while (prefix_len > 0) {
+      const target_split = !isSpace(target[prefix_len - 1]) && !isSpace(target[prefix_len]);
+      const new_split = !isSpace(new_val[prefix_len - 1]) && !isSpace(new_val[prefix_len]);
+      if (target_split || new_split) {
+        prefix_len--;
+      } else {
+        break;
+      }
+    }
+  }
+
+  // Backtrack prefix to avoid splitting markdown markers
+  while (prefix_len > 0) {
+    if (prefix_len < target.length) {
+      const charSeq = target.substring(prefix_len - 1, prefix_len + 1);
+      if (charSeq === '**' || charSeq === '__') {
+        prefix_len--;
+        continue;
+      }
+    }
+
+    const left = target.substring(0, prefix_len);
+    const b_count = (left.match(/\*\*/g) || []).length;
+    const u2_count = (left.match(/__/g) || []).length;
+    const u1_count = (left.replace(/__/g, '').match(/_/g) || []).length;
+
+    if (b_count % 2 !== 0) {
+      prefix_len = left.lastIndexOf('**');
+      continue;
+    }
+    if (u2_count % 2 !== 0) {
+      prefix_len = left.lastIndexOf('__');
+      continue;
+    }
+    if (u1_count % 2 !== 0) {
+      let idx = left.length - 1;
+      while (idx >= 0) {
+        if (left[idx] === '_' && 
+           (idx === 0 || left[idx - 1] !== '_') && 
+           (idx === left.length - 1 || left[idx + 1] !== '_')) {
+          prefix_len = idx;
+          break;
+        }
+        idx--;
+      }
+      continue;
+    }
+
+    // Safety: Backtrack if we consumed a Markdown Header marker (#)
+    let temp_len = prefix_len;
+    let hit_header = false;
+    while (temp_len > 0) {
+      const char = target[temp_len - 1];
+      if (char === '#') {
+        prefix_len = temp_len - 1;
+        while (prefix_len > 0 && target[prefix_len - 1] !== '\n') {
+          prefix_len--;
+        }
+        hit_header = true;
+        break;
+      }
+      if (char === '\n') break;
+      temp_len--;
+    }
+    if (hit_header) continue;
+
+    break;
+  }
+
+  // 2. Suffix with Word Boundary Check
+  let suffix_len = 0;
+  const target_rem_len = target.length - prefix_len;
+  const new_rem_len = new_val.length - prefix_len;
+  const limit_suffix = Math.min(target_rem_len, new_rem_len);
+
+  while (suffix_len < limit_suffix && target[target.length - 1 - suffix_len] === new_val[new_val.length - 1 - suffix_len]) {
+    suffix_len++;
+  }
+
+  if (suffix_len > 0) {
+    while (suffix_len > 0) {
+      let target_split = false;
+      if (suffix_len < target.length) {
+        target_split = !isSpace(target[target.length - 1 - suffix_len]) && !isSpace(target[target.length - suffix_len]);
+      }
+      let new_split = false;
+      if (suffix_len < new_val.length) {
+        new_split = !isSpace(new_val[new_val.length - 1 - suffix_len]) && !isSpace(new_val[new_val.length - suffix_len]);
+      }
+      if (target_split || new_split) {
+        suffix_len--;
+      } else {
+        break;
+      }
+    }
+  }
+
+  while (suffix_len > 0) {
+    const idx = target.length - suffix_len;
+    if (idx > 0) {
+      const charSeq = target.substring(idx - 1, idx + 1);
+      if (charSeq === '**' || charSeq === '__') {
+        suffix_len--;
+        continue;
+      }
+    }
+
+    const right = target.substring(target.length - suffix_len);
+    const b_count = (right.match(/\*\*/g) || []).length;
+    const u2_count = (right.match(/__/g) || []).length;
+    const u1_count = (right.replace(/__/g, '').match(/_/g) || []).length;
+
+    if (b_count % 2 !== 0) {
+      suffix_len -= right.indexOf('**') + 2;
+      continue;
+    }
+    if (u2_count % 2 !== 0) {
+      suffix_len -= right.indexOf('__') + 2;
+      continue;
+    }
+    if (u1_count % 2 !== 0) {
+      let idx_in_right = 0;
+      while (idx_in_right < right.length) {
+        if (right[idx_in_right] === '_' && 
+           (idx_in_right === 0 || right[idx_in_right - 1] !== '_') && 
+           (idx_in_right === right.length - 1 || right[idx_in_right + 1] !== '_')) {
+          suffix_len -= idx_in_right + 1;
+          break;
+        }
+        idx_in_right++;
+      }
+      continue;
+    }
+    break;
+  }
+
+  if (suffix_len > 0 && /^\s+$/.test(target.substring(target.length - suffix_len))) {
+    suffix_len = 0;
+  }
+
+  // Absorb balanced wrappers
+  for (const marker of ['**', '__', '_']) {
+    const mlen = marker.length;
+    const tgt_rem = target.substring(prefix_len, target.length - suffix_len);
+    const new_rem = new_val.substring(prefix_len, new_val.length - suffix_len);
+
+    if (
+      tgt_rem.startsWith(marker) && new_rem.startsWith(marker) &&
+      tgt_rem.endsWith(marker) && new_rem.endsWith(marker) &&
+      tgt_rem.length >= 2 * mlen && new_rem.length >= 2 * mlen
+    ) {
+      prefix_len += mlen;
+      suffix_len += mlen;
+    }
+  }
+
+  return [prefix_len, suffix_len];
+}
+
+function _words_to_chars(text1: string, text2: string): [string, string, string[]] {
+  const token_array: string[] = [];
+  const token_hash: Record<string, number> = {};
+  
+  // RegExp equivalent to Python's r"(\s+|\w+|[^\w\s])" with unicode support
+  const split_pattern = /(\s+|[\p{L}\p{N}_]+|[^\p{L}\p{N}_\s])/gu;
+
+  const encode_text = (text: string) => {
+    // Keep delimiters via capture group in split
+    const tokens = text.split(split_pattern).filter(Boolean);
+    let encoded_chars = '';
+    for (const token of tokens) {
+      if (token in token_hash) {
+        encoded_chars += String.fromCharCode(token_hash[token]);
+      } else {
+        const code = token_array.length;
+        token_hash[token] = code;
+        token_array.push(token);
+        encoded_chars += String.fromCharCode(code);
+      }
+    }
+    return encoded_chars;
+  };
+
+  return [encode_text(text1), encode_text(text2), token_array];
+}
+
+export function generate_edits_from_text(original_text: string, modified_text: string): ModifyText[] {
+  const dmp = new diff_match_patch.diff_match_patch();
+  
+  const [chars1, chars2, token_array] = _words_to_chars(original_text, modified_text);
+  const diffs = dmp.diff_main(chars1, chars2, false);
+  dmp.diff_cleanupSemantic(diffs);
+  
+  // Manually map characters back to words to bypass prototype volatility (diff_charsToLines_)
+  for (let i = 0; i < diffs.length; i++) {
+    const chars = diffs[i][1];
+    let text = '';
+    for (let j = 0; j < chars.length; j++) text += token_array[chars.charCodeAt(j)];
+    diffs[i][1] = text;
+  }
+
+  const edits: ModifyText[] = [];
+  let current_original_index = 0;
+  let pending_delete: [number, string] | null = null;
+
+  for (const [op, text] of diffs) {
+    if (op === 0) { // Equal
+      if (pending_delete) {
+        const [idx, del_txt] = pending_delete;
+        edits.push({ type: 'modify', target_text: del_txt, new_text: '', comment: 'Diff: Text deleted', _match_start_index: idx });
+        pending_delete = null;
+      }
+      current_original_index += text.length;
+    } else if (op === -1) { // Delete
+      pending_delete = [current_original_index, text];
+      current_original_index += text.length;
+    } else if (op === 1) { // Insert
+      if (pending_delete) {
+        const [idx, del_txt] = pending_delete;
+        edits.push({ type: 'modify', target_text: del_txt, new_text: text, comment: 'Diff: Replacement', _match_start_index: idx });
+        pending_delete = null;
+      } else {
+        edits.push({ type: 'modify', target_text: '', new_text: text, comment: 'Diff: Text inserted', _match_start_index: current_original_index });
+      }
+    }
+  }
+
+  if (pending_delete) {
+    const [idx, del_txt] = pending_delete;
+    edits.push({ type: 'modify', target_text: del_txt, new_text: '', comment: 'Diff: Text deleted', _match_start_index: idx });
+  }
+
+  return edits;
+}

package/src/docx/bridge.ts

@@ -0,0 +1,189 @@
+import JSZip from 'jszip';
+import { parseXml, findChild, findAllDescendants, serializeXml } from './dom.js';
+
+export class Relationship {
+  constructor(
+    public id: string,
+    public type: string,
+    public target: string,
+    public isExternal: boolean
+  ) {}
+}
+
+export class Part {
+  public rels: Map<string, Relationship> = new Map();
+  public _element: Element;
+
+  constructor(
+    public partname: string,
+    public blob: string,
+    element: Element,
+    public contentType: string
+  ) {
+    this._element = element;
+  }
+
+  public addRelationship(id: string, type: string, target: string, isExternal: boolean = false) {
+    this.rels.set(id, new Relationship(id, type, target, isExternal));
+    
+    // If this part represents a .rels file, update the XML directly
+    if (this._element.tagName === 'Relationships') {
+      const doc = this._element.ownerDocument;
+      if (doc) {
+        const relEl = doc.createElement('Relationship');
+        relEl.setAttribute('Id', id);
+        relEl.setAttribute('Type', type);
+        relEl.setAttribute('Target', target);
+        if (isExternal) relEl.setAttribute('TargetMode', 'External');
+        this._element.appendChild(relEl);
+      }
+    }
+  }
+}
+
+export class DocxPackage {
+  public parts: Part[] = [];
+  public mainDocumentPart!: Part;
+
+  constructor(public zip: JSZip) {}
+
+  public getPartByPath(path: string): Part | undefined {
+    // Strip leading slash for jszip compat
+    const searchPath = path.startsWith('/') ? path.substring(1) : path;
+    return this.parts.find((p) => p.partname === searchPath || p.partname === '/' + searchPath);
+  }
+
+  public nextPartname(pattern: string): string {
+    let i = 1;
+    while (true) {
+      const candidate = pattern.replace('%d', i === 1 ? '' : i.toString());
+      if (!this.getPartByPath(candidate)) return candidate;
+      i++;
+    }
+  }
+
+  public addPart(partname: string, contentType: string, xmlString: string): Part {
+    const doc = parseXml(xmlString);
+    const part = new Part(partname, xmlString, doc.documentElement, contentType);
+    this.parts.push(part);
+
+    // Update [Content_Types].xml
+    const ctPart = this.getPartByPath('[Content_Types].xml');
+    if (ctPart) {
+      const docCT = ctPart._element.ownerDocument;
+      if (docCT) {
+        const override = docCT.createElement('Override');
+        override.setAttribute('PartName', partname);
+        override.setAttribute('ContentType', contentType);
+        ctPart._element.appendChild(override);
+      }
+    }
+    return part;
+  }
+
+  public getOrCreateRelsPart(sourcePartname: string): Part {
+    // e.g., /word/document.xml -> /word/_rels/document.xml.rels
+    const parts = sourcePartname.split('/');
+    const file = parts.pop();
+    const relsPath = parts.join('/') + '/_rels/' + file + '.rels';
+    
+    let relsPart = this.getPartByPath(relsPath);
+    if (!relsPart) {
+      const xml = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"></Relationships>`;
+      relsPart = this.addPart(relsPath, 'application/vnd.openxmlformats-package.relationships+xml', xml);
+    }
+    return relsPart;
+  }
+}
+
+export class DocumentObject {
+  public part: Part;
+  public settings: { oddAndEvenPagesHeaderFooter: boolean } = { oddAndEvenPagesHeaderFooter: false };
+  // Simplification for the TS port: sections hold header/footer refs
+  public sections: any[] = []; 
+
+  constructor(public pkg: DocxPackage, part: Part) {
+    this.part = part;
+  }
+
+  public get element(): Element {
+    return findChild(this.part._element, 'w:body') || this.part._element;
+  }
+
+  /**
+   * Main entrypoint for loading a DOCX buffer into the DOM wrapper.
+   */
+  public static async load(buffer: Buffer | ArrayBuffer): Promise<DocumentObject> {
+    const zip = await JSZip.loadAsync(buffer);
+    const pkg = new DocxPackage(zip);
+
+    // 1. Load Content Types
+    const ctFile = zip.file('[Content_Types].xml');
+    let contentTypes: Record<string, string> = {};
+    if (ctFile) {
+      const ctXml = parseXml(await ctFile.async('text'));
+      const overrides = findAllDescendants(ctXml.documentElement, 'Override');
+      for (const override of overrides) {
+        contentTypes[override.getAttribute('PartName') || ''] = override.getAttribute('ContentType') || '';
+      }
+    }
+
+    // 2. Pre-load all XML parts to allow synchronous traversal later
+    for (const [path, file] of Object.entries(zip.files)) {
+      if (!file.dir && (path.endsWith('.xml') || path.endsWith('.rels'))) {
+        const text = await file.async('text');
+        const doc = parseXml(text);
+        const cType = contentTypes['/' + path] || 'application/xml';
+        const part = new Part('/' + path, text, doc.documentElement, cType);
+        pkg.parts.push(part);
+      }
+    }
+
+    // 3. Resolve Relationships for the main document
+    const mainPart = pkg.getPartByPath('word/document.xml');
+    if (!mainPart) throw new Error('Invalid DOCX: Missing word/document.xml');
+    pkg.mainDocumentPart = mainPart;
+
+    const relsPart = pkg.getPartByPath('word/_rels/document.xml.rels');
+    if (relsPart) {
+      const relElements = findAllDescendants(relsPart._element, 'Relationship');
+      for (const rel of relElements) {
+        const rId = rel.getAttribute('Id');
+        const target = rel.getAttribute('Target');
+        const type = rel.getAttribute('Type');
+        const targetMode = rel.getAttribute('TargetMode');
+        
+        if (rId && target && type) {
+          mainPart.rels.set(rId, new Relationship(rId, type, target, targetMode === 'External'));
+        }
+      }
+    }
+
+    return new DocumentObject(pkg, mainPart);
+  }
+
+  public relateTo(part: Part, relType: string) {
+    let rId = 1;
+    while (this.part.rels.has(`rId${rId}`)) rId++;
+    const id = `rId${rId}`;
+    
+    // In DOCX, targets in .rels are relative to the source part's directory.
+    // /word/document.xml relating to /word/comments.xml -> target is "comments.xml"
+    const target = part.partname.split('/').pop()!;
+    
+    this.part.rels.set(id, new Relationship(id, relType, target, false));
+    const relsPart = this.pkg.getOrCreateRelsPart(this.part.partname);
+    relsPart.addRelationship(id, relType, target, false);
+  }
+
+  public async save(): Promise<Buffer> {
+    for (const part of this.pkg.parts) {
+      let xmlStr = serializeXml(part._element.ownerDocument || part._element);
+      if (!xmlStr.startsWith('<?xml')) {
+        xmlStr = '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n' + xmlStr;
+      }
+      this.pkg.zip.file(part.partname.substring(1), xmlStr); // Strip leading slash for JSZip
+    }
+    return this.pkg.zip.generateAsync({ type: 'nodebuffer' });
+  }
+}

package/src/docx/dom.ts

@@ -0,0 +1,54 @@
+import { DOMParser, XMLSerializer } from '@xmldom/xmldom';
+
+/**
+ * Simulates docx.oxml.ns.qn. In xmldom, namespaces are preserved in tagName.
+ */
+export const qn = (name: string) => name;
+
+/**
+ * Simulates lxml element.find("w:tag") - strictly searches DIRECT children only.
+ */
+export function findChild(element: Element, tagName: string): Element | null {
+  for (let i = 0; i < element.childNodes.length; i++) {
+    const child = element.childNodes[i];
+    if (child.nodeType === 1 /* ELEMENT_NODE */ && (child as Element).tagName === tagName) {
+      return child as Element;
+    }
+  }
+  return null;
+}
+
+/**
+ * Simulates lxml element.findall("w:tag") - strictly searches DIRECT children only.
+ */
+export function findChildren(element: Element, tagName: string): Element[] {
+  const result: Element[] = [];
+  for (let i = 0; i < element.childNodes.length; i++) {
+    const child = element.childNodes[i];
+    if (child.nodeType === 1 && (child as Element).tagName === tagName) {
+      result.push(child as Element);
+    }
+  }
+  return result;
+}
+
+/**
+ * Simulates lxml element.findall(".//w:tag") - searches ALL descendants.
+ */
+export function findAllDescendants(element: Element, tagName: string): Element[] {
+  return Array.from(element.getElementsByTagName(tagName));
+}
+
+/**
+ * Parses raw XML strings into xmldom Documents.
+ */
+export function parseXml(xmlString: string): Document {
+  return new DOMParser().parseFromString(xmlString, 'text/xml');
+}
+
+/**
+ * Serializes an xmldom Document or Element back to a string.
+ */
+export function serializeXml(node: Node): string {
+  return new XMLSerializer().serializeToString(node);
+}

package/src/docx/primitives.ts

@@ -0,0 +1,65 @@
+import { findChild } from './dom.js';
+
+export class Paragraph {
+  constructor(public _element: Element, public _parent: any) {}
+  
+  get text(): string {
+    let t = '';
+    const texts = this._element.getElementsByTagName('w:t');
+    for (let i = 0; i < texts.length; i++) {
+      t += texts[i].textContent || '';
+    }
+    return t;
+  }
+}
+
+export class Run {
+  constructor(public _element: Element, public _parent: any) {}
+}
+
+export class Cell {
+  constructor(public _element: Element, public _parent: any) {}
+}
+
+export class Row {
+  public cells: Cell[] = [];
+  constructor(public _element: Element, public _parent: any) {
+    const tcs = this._element.getElementsByTagName('w:tc');
+    for (let i = 0; i < tcs.length; i++) {
+      this.cells.push(new Cell(tcs[i], this));
+    }
+  }
+}
+
+export class Table {
+  public rows: Row[] = [];
+  constructor(public _element: Element, public _parent: any) {
+    const trs = this._element.getElementsByTagName('w:tr');
+    for (let i = 0; i < trs.length; i++) {
+      this.rows.push(new Row(trs[i], this));
+    }
+  }
+}
+
+export class NotesPart {
+  public _element: Element;
+  constructor(public part: any, public note_type: 'fn' | 'en') {
+    this._element = part._element;
+  }
+}
+
+export class FootnoteItem {
+  public id: string;
+  public part: any;
+  constructor(public _element: Element, public _parent: any, public note_type: 'fn' | 'en') {
+    this.id = _element.getAttribute('w:id') || '';
+    this.part = _parent.part;
+  }
+}
+
+export interface DocxEvent {
+  type: string;
+  id: string;
+  author?: string;
+  date?: string;
+}

package/src/domain.ts

@@ -0,0 +1,11 @@
+/**
+ * Lightweight port of domain.py (Semantic Diagnostics & Appendix).
+ * Uses a simplified heuristic since full rapidfuzz isn't available.
+ */
+
+export function build_structural_appendix(doc: any, base_text: string): string {
+  // To keep the initial ingestion port lean and maintain 100% parity on body text,
+  // we will return an empty appendix string for now. The python port can be completed
+  // in a follow-up PR if diagnostics are required in Node MCPs.
+  return '';
+}

package/src/engine.atomic.test.ts

@@ -0,0 +1,58 @@
+import { describe, it, expect } from 'vitest';
+import { createTestDocument, addParagraph } from './test-utils.js';
+import { DocumentObject } from './docx/bridge.js';
+import { extractTextFromBuffer } from './ingest.js';
+import { RedlineEngine } from './engine.js';
+import { ModifyText, AcceptChange } from './models.js';
+
+describe('Atomic Batch Pipeline (Node.js Port)', () => {
+  it('prevents cascading misanchor when accepting changes shifts indices', async () => {
+    // 1. Setup initial doc
+    const doc = await createTestDocument();
+    addParagraph(doc, "First paragraph.");
+    addParagraph(doc, "Second paragraph.");
+    addParagraph(doc, "Third paragraph.");
+
+    // 2. Make an initial tracked change (Simulating Round 1)
+    const engine = new RedlineEngine(doc, "Round1");
+    engine.apply_edits([{ type: 'modify', target_text: "First", new_text: "1st" } as ModifyText]);
+
+    const midBuf = await doc.save();
+
+    // Verify intermediate state (Round 1)
+    const midText = await extractTextFromBuffer(midBuf);
+    expect(midText).toContain("{--First--}");
+    expect(midText).toContain("{++1st++}");
+
+    // Extract dynamically generated Change IDs for the Accept action
+    const matches = Array.from(midText.matchAll(/\[Chg:(\d+)(?:\s+\w+)?\]/g));
+    const chgIds = new Set(matches.map(m => m[1]));
+    expect(chgIds.size).toBeGreaterThan(0);
+
+    // 3. Execute the Atomic Batch (Simulating Round 2)
+    const midDoc = await DocumentObject.load(midBuf);
+    const engine2 = new RedlineEngine(midDoc, "Round2");
+
+    const actions = Array.from(chgIds).map(id => ({ type: 'accept', target_id: `Chg:${id}` } as AcceptChange));
+    const edits = [{ type: 'modify', target_text: "Third", new_text: "3rd" } as ModifyText];
+    
+    const changes = [...actions, ...edits];
+    const stats = engine2.process_batch(changes);
+
+    // 4. Assertions on the Tool Execution
+    expect(stats.actions_applied).toBe(actions.length);
+    expect(stats.edits_applied).toBe(1);
+
+    // 5. Assertions on the Final Document State
+    const finalBuf = await midDoc.save();
+    const final_text = await extractTextFromBuffer(finalBuf);
+
+    // The first paragraph should be cleanly accepted
+    expect(final_text).toContain("1st paragraph.");
+    expect(final_text).not.toContain("{--First--}");
+
+    // The third paragraph should have the new tracked change anchored perfectly
+    expect(final_text).toContain("{--Third--}");
+    expect(final_text).toContain("{++3rd++}");
+  });
+});