@ansonlai/docx-redline-js 0.2.1 → 0.4.0

package/engine/oxml-engine.js

@@ -12,7 +12,7 @@ import {
     getElementsByTagNSOrTag,
     getXmlParseError
 } from '../core/xml-query.js';
-import { createParser, createSerializer, parseXml, serializeXml } from '../adapters/xml-adapter.js';
+import { createSerializer, parseOoxmlSafe, serializeXml } from '../adapters/xml-adapter.js';
 import { log, error } from '../adapters/logger.js';
 import { extractFormattingFromOoxml } from './format-extraction.js';
 import {
@@ -26,8 +26,13 @@ import { applyReconstructionMode } from './reconstruction-mode.js';
 import { applyTableReconciliation, applyTextToTableTransformation } from './table-mode.js';
 import { getDefaultAuthor } from '../adapters/config.js';
 import { containsTrackedChanges, withOoxmlSourceType } from '../core/word-xml.js';
-import { NS_W, seedRevisionIdsFromDocument } from '../core/types.js';
+import {
+    NS_W,
+    RevisionIdAllocator,
+    seedRevisionIdsFromDocument
+} from '../core/types.js';
 import { acceptTrackedChangesInOoxml } from '../services/revision-comment-management.js';
+import { isDiffTokenLimitError } from '../pipeline/diff-engine.js';
 
 /**
  * Applies redline track changes to OOXML by modifying the DOM in-place.
@@ -38,73 +43,107 @@ import { acceptTrackedChangesInOoxml } from '../services/revision-comment-manage
  * @param {Object} [options={}] - Options
  * @param {string} [options.author='AI'] - Author for track changes
  * @param {string|null} [options.targetParagraphId=null] - Preferred paragraph identity for table wrappers
- * @param {'reject-input'|'accept-all-first'} [options.existingRevisions='reject-input'] - Policy for source OOXML with tracked changes
+ * @param {'reject-input'|'accept-all-first'|'accept-all-first-keep-normalized'} [options.existingRevisions='reject-input'] - Policy for source OOXML with tracked changes
+ * @param {boolean} [options.removeFormatting=false] - Remove existing core formatting when text is otherwise unchanged
+ * @param {boolean} [options.sanitizeInput=false] - Strip a standalone leading assistant preface line
  * @returns {Promise<{ oxml: string, hasChanges: boolean, sourceType?: 'package'|'document'|'fragment', status?: 'ok'|'no-op'|'error', error?: { code: string, message: string } }>}
  */
 export async function applyRedlineToOxml(oxml, originalText, modifiedText, options = {}) {
+    const inputOoxml = oxml;
+    let workingOoxml = oxml;
+    originalText = typeof originalText === 'string' ? originalText : String(originalText ?? '');
+    modifiedText = typeof modifiedText === 'string' ? modifiedText : String(modifiedText ?? '');
     const generateRedlines = options.generateRedlines ?? true;
     const author = options.author || getDefaultAuthor();
-    const parser = createParser();
-    const serializer = createSerializer();
+    const serializer = createSerializer();
+    let parseWarnings = [];
+    const operationWarnings = [];
+    let normalizedExistingRevisions = false;
+    const keepNormalizedNoOp = options.existingRevisions === 'accept-all-first-keep-normalized';
     const finalize = result => {
         const withStatus = { ...result };
+        if (normalizedExistingRevisions && withStatus.hasChanges === false && withStatus.status !== 'error') {
+            if (keepNormalizedNoOp) {
+                withStatus.oxml = workingOoxml;
+                withStatus.hasChanges = true;
+                withStatus.warnings = [
+                    ...(Array.isArray(withStatus.warnings) ? withStatus.warnings : []),
+                    'Existing revisions were accepted before redlining.'
+                ];
+            } else {
+                withStatus.oxml = inputOoxml;
+            }
+        }
+        const warnings = [...parseWarnings, ...operationWarnings, ...(Array.isArray(withStatus.warnings) ? withStatus.warnings : [])];
+        if (warnings.length > 0) {
+            withStatus.warnings = [...new Set(warnings)];
+        }
         if (!withStatus.status) {
             withStatus.status = withStatus.hasChanges ? 'ok' : 'no-op';
         }
         return withOoxmlSourceType(withStatus);
     };
-    const noChanges = () => finalize({ oxml, hasChanges: false });
+    const finalizeUnchanged = () => {
+        if (normalizedExistingRevisions && keepNormalizedNoOp) {
+            return finalize({
+                oxml: workingOoxml,
+                hasChanges: true,
+                warnings: ['Existing revisions were accepted before redlining.']
+            });
+        }
+        return finalize({ oxml: inputOoxml, hasChanges: false });
+    };
 
-    let xmlDoc;
-    try {
-        xmlDoc = parser.parseFromString(oxml, 'text/xml');
-    } catch (e) {
-        error('[OxmlEngine] Failed to parse OXML:', e);
-        return finalize({
-            oxml,
-            hasChanges: false,
-            status: 'error',
-            error: { code: 'PARSE_ERROR', message: 'Could not parse OOXML input.' }
-        });
-    }
+    const parsed = parseOoxmlSafe(inputOoxml, 'text/xml');
+    parseWarnings = parsed.warnings;
+    let xmlDoc = parsed.doc;
 
-    const parseError = getXmlParseError(xmlDoc);
-    if (parseError) {
-        error('[OxmlEngine] XML parse error:', parseError.textContent);
+    const parseError = xmlDoc ? getXmlParseError(xmlDoc) : null;
+    if (parsed.error || parseError) {
+        const message = parsed.error?.message || parseError?.textContent || 'Could not parse OOXML input.';
+        error('[OxmlEngine] XML parse error:', message);
         return finalize({
-            oxml,
+            oxml: inputOoxml,
             hasChanges: false,
             status: 'error',
-            error: { code: 'PARSE_ERROR', message: parseError.textContent || 'Could not parse OOXML input.' }
+            error: { code: 'PARSE_ERROR', message }
         });
     }
-    seedRevisionIdsFromDocument(xmlDoc);
+    const revisionIdAllocator = options?._revisionIdAllocator instanceof RevisionIdAllocator
+        ? options._revisionIdAllocator
+        : new RevisionIdAllocator();
+    seedRevisionIdsFromDocument(xmlDoc, revisionIdAllocator);
 
     if (containsTrackedChanges(xmlDoc)) {
         const existingRevisionsPolicy = options.existingRevisions || 'reject-input';
-        if (existingRevisionsPolicy === 'accept-all-first') {
+        if (existingRevisionsPolicy === 'accept-all-first' || existingRevisionsPolicy === 'accept-all-first-keep-normalized') {
             log('[OxmlEngine] Existing revisions detected; accepting all input revisions before redlining');
-            const accepted = acceptTrackedChangesInOoxml(oxml, { allAuthors: true });
-            oxml = accepted.oxml;
-            xmlDoc = parser.parseFromString(oxml, 'text/xml');
-            const acceptedParseError = getXmlParseError(xmlDoc);
-            if (acceptedParseError) {
-                error('[OxmlEngine] XML parse error after accepting existing revisions:', acceptedParseError.textContent);
+            const accepted = acceptTrackedChangesInOoxml(inputOoxml, { allAuthors: true });
+            if (accepted.status === 'error') return finalize(accepted);
+            workingOoxml = accepted.oxml;
+            normalizedExistingRevisions = true;
+            const acceptedParsed = parseOoxmlSafe(workingOoxml, 'text/xml');
+            parseWarnings.push(...acceptedParsed.warnings);
+            xmlDoc = acceptedParsed.doc;
+            const acceptedParseError = xmlDoc ? getXmlParseError(xmlDoc) : null;
+            if (acceptedParsed.error || acceptedParseError) {
+                const message = acceptedParsed.error?.message || acceptedParseError?.textContent || 'Could not parse OOXML after accepting existing revisions.';
+                error('[OxmlEngine] XML parse error after accepting existing revisions:', message);
                 return finalize({
-                    oxml,
+                    oxml: inputOoxml,
                     hasChanges: false,
                     status: 'error',
                     error: {
                         code: 'PARSE_ERROR',
-                        message: 'Could not parse OOXML after accepting existing revisions.'
+                        message
                     }
                 });
             }
-            seedRevisionIdsFromDocument(xmlDoc);
+            seedRevisionIdsFromDocument(xmlDoc, revisionIdAllocator);
         } else {
             log('[OxmlEngine] Existing revisions detected; rejecting input per existingRevisions policy');
             return finalize({
-                oxml,
+                oxml: inputOoxml,
                 hasChanges: false,
                 status: 'error',
                 error: {
@@ -119,13 +158,20 @@ export async function applyRedlineToOxml(oxml, originalText, modifiedText, optio
     if (initialTableCellContext.hasTableWrapper && initialTableCellContext.targetParagraph && !options._isolatedTableCell) {
         log('[OxmlEngine] Isolating table-cell paragraph before diff');
         const isolatedOxml = serializeParagraphOnly(xmlDoc, initialTableCellContext.targetParagraph, serializer);
-        return applyRedlineToOxml(isolatedOxml, originalText, modifiedText, {
-            ...options,
-            _isolatedTableCell: true
-        });
-    }
-
-    const sanitizedText = sanitizeAiResponse(modifiedText);
+        const isolatedResult = await applyRedlineToOxml(isolatedOxml, originalText, modifiedText, {
+            ...options,
+            _isolatedTableCell: true
+        });
+        if (!isolatedResult.hasChanges && isolatedResult.status === 'no-op') {
+            return finalizeUnchanged();
+        }
+        return isolatedResult;
+    }
+
+    const sanitizedText = options.sanitizeInput === true ? sanitizeAiResponse(modifiedText) : modifiedText;
+    if (sanitizedText !== modifiedText) {
+        operationWarnings.push('Input was sanitized; pass sanitizeInput: false to disable.');
+    }
     const { cleanText: cleanModifiedText, formatHints } = preprocessMarkdown(sanitizedText);
 
     const hasTextChanges = cleanModifiedText.trim() !== originalText.trim();
@@ -134,18 +180,30 @@ export async function applyRedlineToOxml(oxml, originalText, modifiedText, optio
     const { existingFormatHints, textSpans, paragraphs } = extractFormattingFromOoxml(xmlDoc);
     const hasExistingFormatting = existingFormatHints.length > 0;
     const visibleText = textSpans.map(span => textSpanVisibleText(span)).join('');
+    const targetFound = originalText.includes('\n') || originalText.includes('\r')
+        ? originalText
+            .split(/\r?\n/)
+            .map(normalizeTargetText)
+            .filter(Boolean)
+            .every(line => paragraphs.some(paragraph => {
+                const paragraphText = textSpans
+                    .filter(span => span.paragraph === paragraph)
+                    .map(textSpanVisibleText)
+                    .join('');
+                return normalizeTargetText(paragraphText).includes(line);
+            }))
+        : visibleText.includes(originalText.trim())
+            || visibleText.replace(/[\t\n\u2011]/g, '').includes(originalText.trim().replace(/[\t\n\u2011]/g, ''))
+            || normalizeTargetText(visibleText).includes(normalizeTargetText(originalText));
     if (
         hasTextChanges
         && typeof originalText === 'string'
         && originalText.trim()
-        && !originalText.includes('\n')
-        && !visibleText.includes(originalText.trim())
-        && !visibleText.replace(/[\t\n\u2011]/g, '').includes(originalText.trim().replace(/[\t\n\u2011]/g, ''))
-        && !normalizeTargetText(visibleText).includes(normalizeTargetText(originalText))
+        && !targetFound
     ) {
         log('[OxmlEngine] Target text not found in OOXML');
         return finalize({
-            oxml,
+            oxml: inputOoxml,
             hasChanges: false,
             status: 'error',
             error: {
@@ -189,12 +247,20 @@ export async function applyRedlineToOxml(oxml, originalText, modifiedText, optio
 
     log(`[OxmlEngine] Text changes: ${hasTextChanges}, New format hints: ${formatHints.length}, Existing format hints: ${existingFormatHints.length}`);
 
-    const needsFormatRemoval = !hasTextChanges && !hasFormatHints && hasExistingFormatting;
+    const needsFormatRemoval = options.removeFormatting === true
+        && !hasTextChanges
+        && !hasFormatHints
+        && hasExistingFormatting;
 
-    if (!hasTextChanges && !hasFormatHints && !hasExistingFormatting) {
-        log('[OxmlEngine] No text changes, no format hints, and no existing formatting detected');
-        return noChanges();
-    }
+    if (!hasTextChanges && !hasFormatHints && !hasExistingFormatting) {
+        log('[OxmlEngine] No text changes, no format hints, and no existing formatting detected');
+        return finalizeUnchanged();
+    }
+
+    if (!hasTextChanges && !hasFormatHints && hasExistingFormatting && !needsFormatRemoval) {
+        log('[OxmlEngine] No text or explicit formatting changes; preserving existing formatting');
+        return finalizeUnchanged();
+    }
 
     if (needsFormatRemoval) {
         log('[OxmlEngine] Format REMOVAL detected: applying surgical replacement in OOXML');
@@ -266,15 +332,16 @@ export async function applyRedlineToOxml(oxml, originalText, modifiedText, optio
     const isTargetList = isListTargetLoose(cleanModifiedText);
     const tableCellContext = initialTableCellContext;
 
-    log(`[OxmlEngine] Mode: ${hasTables ? 'SURGICAL' : 'RECONSTRUCTION'}, formatHints: ${formatHints.length}, isMarkdownTable: ${isMarkdownTable}, isTargetList: ${isTargetList}, isTableCellParagraph: ${tableCellContext.isTableCellParagraph}`);
-
-    if (isMarkdownTable && !hasTables) {
+    log(`[OxmlEngine] Mode: ${hasTables ? 'SURGICAL' : 'RECONSTRUCTION'}, formatHints: ${formatHints.length}, isMarkdownTable: ${isMarkdownTable}, isTargetList: ${isTargetList}, isTableCellParagraph: ${tableCellContext.isTableCellParagraph}`);
+
+    try {
+    if (isMarkdownTable && !hasTables) {
         log('[OxmlEngine] Text-to-table transformation: generating new table from Markdown');
-        return finalize(applyTextToTableTransformation(xmlDoc, cleanModifiedText, serializer, parser, author, generateRedlines));
+        return finalize(applyTextToTableTransformation(xmlDoc, cleanModifiedText, serializer, null, author, generateRedlines));
     }
 
     if (hasTables && isMarkdownTable) {
-        return finalize(applyTableReconciliation(xmlDoc, cleanModifiedText, serializer, parser, author, generateRedlines));
+        return finalize(applyTableReconciliation(xmlDoc, cleanModifiedText, serializer, null, author, generateRedlines));
     }
     if (hasTables) {
         const surgicalTarget = tableCellContext.hasTableWrapper && tableCellContext.targetParagraph
@@ -289,10 +356,10 @@ export async function applyRedlineToOxml(oxml, originalText, modifiedText, optio
             originalText,
             cleanModifiedText,
             serializer,
-            author,
-            formatHints,
-            generateRedlines,
-            surgicalTarget
+            author,
+            formatHints,
+            generateRedlines,
+            surgicalTarget
         );
 
         if (tableCellContext.hasTableWrapper && result.hasChanges && tableCellContext.targetParagraph) {
@@ -303,22 +370,50 @@ export async function applyRedlineToOxml(oxml, originalText, modifiedText, optio
     }
     if (isTargetList) {
         log('[OxmlEngine] 🎯 Using reconciliation pipeline for list generation');
-        const pipeline = new ReconciliationPipeline({ author, generateRedlines });
-        const result = await pipeline.execute(oxml, modifiedText, { xmlDoc });
-
-        if (result.isValid && result.ooxml && result.ooxml !== oxml) {
-            log(`[OxmlEngine] Wrapping list OOXML with numbering definitions, includeNumbering=${result.includeNumbering}`);
-            const wrapped = wrapInDocumentFragment(result.ooxml, {
-                includeNumbering: result.includeNumbering ?? true,
-                numberingXml: result.numberingXml
-            });
+        const pipeline = new ReconciliationPipeline({
+            author,
+            generateRedlines,
+            revisionIdAllocator
+        });
+        const result = await pipeline.execute(workingOoxml, sanitizedText, { xmlDoc });
+
+        if (result.error?.code === 'DIFF_TOKEN_LIMIT') {
+            return finalize({ oxml: inputOoxml, hasChanges: false, status: 'error', error: result.error });
+        }
+
+        if (result.isValid && result.ooxml && result.ooxml !== workingOoxml) {
+            const includeNumbering = result.includeNumbering === true;
+            log(`[OxmlEngine] Wrapping list OOXML with numbering definitions, includeNumbering=${includeNumbering}`);
+            const wrapped = wrapInDocumentFragment(result.ooxml, {
+                includeNumbering,
+                numberingXml: result.numberingXml
+            });
             log(`[OxmlEngine] ✅ Wrapped OOXML length: ${wrapped.length}`);
             return finalize({ oxml: wrapped, hasChanges: true });
         }
-        return noChanges();
+        return finalizeUnchanged();
     }
 
-    return finalize(applyReconstructionMode(xmlDoc, originalText, cleanModifiedText, serializer, author, formatHints, generateRedlines));
+    return finalize(applyReconstructionMode(
+        xmlDoc,
+        originalText,
+        cleanModifiedText,
+        serializer,
+        author,
+        formatHints,
+        generateRedlines
+    ));
+    } catch (caught) {
+        if (isDiffTokenLimitError(caught)) {
+            return finalize({
+                oxml: inputOoxml,
+                hasChanges: false,
+                status: 'error',
+                error: { code: caught.code, message: caught.message }
+            });
+        }
+        throw caught;
+    }
 }
 
 function normalizeTargetText(text) {
@@ -340,14 +435,12 @@ function textSpanVisibleText(span) {
  * @param {string} text - AI response text
  * @returns {string}
  */
-export function sanitizeAiResponse(text) {
-    let cleaned = text;
-    cleaned = cleaned.replace(/^(Here is the redline:|Here is the text:|Sure, I can help:|Here's the updated text:)\s*/i, '');
-    cleaned = cleaned.replace(/\$\\text\{/g, '').replace(/\}\$/g, '');
-    cleaned = cleaned.replace(/\$([^0-9\n]+?)\$/g, '$1');
-    cleaned = cleaned.replace(/\\r\\n/g, '\n').replace(/\\n/g, '\n');
-    return cleaned;
-}
+export function sanitizeAiResponse(text) {
+    return String(text ?? '').replace(
+        /^(?:Here is the redline:|Here is the text:|Sure, I can help:|Here's the updated text:)[ \t]*\r?\n/i,
+        ''
+    );
+}
 
 /**
  * Parses OOXML into a DOM document.
@@ -355,9 +448,9 @@ export function sanitizeAiResponse(text) {
  * @param {string} ooxmlString - OOXML text
  * @returns {Document}
  */
-export function parseOoxml(ooxmlString) {
-    return parseXml(ooxmlString, 'application/xml');
-}
+export function parseOoxml(ooxmlString) {
+    return parseOoxmlSafe(ooxmlString, 'application/xml').doc;
+}
 
 /**
  * Serializes a DOM document to OOXML text.