@ansonlai/docx-redline-js 0.1.0

package/engine/table-mode.js

@@ -0,0 +1,172 @@
+/**
+ * Table-specific reconciliation and transformation flows.
+ */
+
+import { NS_W, getNextRevisionId, getRevisionTimestamp } from '../core/types.js';
+import {
+    getElementsByTag,
+    getElementsByTagNS,
+    getFirstElementByTag,
+    getFirstElementByTagNS,
+    getXmlParseError
+} from '../core/xml-query.js';
+import { createParser } from '../adapters/xml-adapter.js';
+import { log, error } from '../adapters/logger.js';
+import { diffTablesWithVirtualGrid, serializeVirtualGridToOoxml, generateTableOoxml } from '../services/table-reconciliation.js';
+import { parseTable } from '../pipeline/pipeline.js';
+import { ingestTableToVirtualGrid } from '../pipeline/ingestion.js';
+
+function noChanges(serializer, xmlDoc) {
+    return { oxml: serializer.serializeToString(xmlDoc), hasChanges: false };
+}
+
+/**
+ * Applies structural reconciliation to tables using Virtual Grid.
+ *
+ * @param {Document} xmlDoc - XML document
+ * @param {string} modifiedText - Markdown/target table text
+ * @param {XMLSerializer} serializer - Serializer instance
+ * @param {DOMParser} parser - Parser instance
+ * @param {string} author - Author name
+ * @param {boolean} [generateRedlines=true] - Track change toggle
+ * @returns {{ oxml: string, hasChanges: boolean }}
+ */
+export function applyTableReconciliation(xmlDoc, modifiedText, serializer, parser, author, generateRedlines = true) {
+    const tableNodes = getElementsByTag(xmlDoc, 'w:tbl');
+    const newTableData = parseTable(modifiedText);
+    const hasNewContent = newTableData.rows.length > 0 || newTableData.headers.length > 0;
+
+    if (tableNodes.length === 0 || !hasNewContent) {
+        return noChanges(serializer, xmlDoc);
+    }
+
+    const targetTable = tableNodes[0];
+    const oldGrid = ingestTableToVirtualGrid(targetTable);
+    const operations = diffTablesWithVirtualGrid(oldGrid, newTableData);
+
+    if (operations.length === 0) {
+        return noChanges(serializer, xmlDoc);
+    }
+
+    const options = { generateRedlines, author };
+    const reconciledOxml = serializeVirtualGridToOoxml(oldGrid, operations, options);
+    const wrappedOxml = `<root xmlns:w="${NS_W}">${reconciledOxml}</root>`;
+    const reconcileParser = parser || createParser();
+    const reconciledDoc = reconcileParser.parseFromString(wrappedOxml, 'application/xml');
+
+    const parseError = getXmlParseError(reconciledDoc);
+    if (parseError) {
+        error('[OxmlEngine] Failed to parse reconciled table OOXML:', parseError.textContent);
+        return noChanges(serializer, xmlDoc);
+    }
+
+    const newTableNode = getFirstElementByTag(reconciledDoc, 'w:tbl');
+    if (!newTableNode) {
+        error('[OxmlEngine] No table found in reconciled OOXML');
+        return noChanges(serializer, xmlDoc);
+    }
+
+    const importedTable = xmlDoc.importNode(newTableNode, true);
+    targetTable.parentNode.replaceChild(importedTable, targetTable);
+
+    return { oxml: serializer.serializeToString(xmlDoc), hasChanges: true };
+}
+
+/**
+ * Transforms paragraph content into a new table from Markdown text.
+ *
+ * @param {Document} xmlDoc - XML document
+ * @param {string} modifiedText - Markdown table text
+ * @param {XMLSerializer} serializer - Serializer instance
+ * @param {DOMParser} parser - Parser instance
+ * @param {string} author - Author name
+ * @param {boolean} generateRedlines - Track change toggle
+ * @returns {{ oxml: string, hasChanges: boolean }}
+ */
+export function applyTextToTableTransformation(xmlDoc, modifiedText, serializer, parser, author, generateRedlines) {
+    const tableData = parseTable(modifiedText);
+    if (!tableData || (tableData.rows.length === 0 && tableData.headers.length === 0)) {
+        log('[OxmlEngine] Failed to parse table data from Markdown');
+        return noChanges(serializer, xmlDoc);
+    }
+
+    const tableOoxml = generateTableOoxml(tableData, { generateRedlines, author });
+    const activeParser = parser || createParser();
+    const tableDoc = activeParser.parseFromString(`<root xmlns:w="${NS_W}">${tableOoxml}</root>`, 'application/xml');
+
+    const tableParseError = getXmlParseError(tableDoc);
+    if (tableParseError) {
+        error('[OxmlEngine] Failed to parse generated table OOXML:', tableParseError.textContent);
+        return noChanges(serializer, xmlDoc);
+    }
+
+    let newTableElement = getFirstElementByTagNS(tableDoc, NS_W, 'tbl');
+    if (!newTableElement) {
+        newTableElement = getFirstElementByTagNS(tableDoc, NS_W, 'ins');
+    }
+    if (!newTableElement) {
+        error('[OxmlEngine] No table element found in generated OOXML');
+        return noChanges(serializer, xmlDoc);
+    }
+
+    let workingDoc = xmlDoc;
+    let paragraphs = getElementsByTagNS(workingDoc, NS_W, 'p');
+    if (paragraphs.length === 0) {
+        log('[OxmlEngine] No paragraphs found to replace');
+        return noChanges(serializer, workingDoc);
+    }
+
+    let firstParagraph = paragraphs[0];
+    let parent = firstParagraph.parentNode;
+
+    if (parent && parent.nodeType === 9) {
+        const wrappedDoc = activeParser.parseFromString(
+            `<w:document xmlns:w="${NS_W}"><w:body/></w:document>`,
+            'application/xml'
+        );
+        const wrappedBody = getFirstElementByTagNS(wrappedDoc, NS_W, 'body');
+        paragraphs.forEach(p => wrappedBody.appendChild(wrappedDoc.importNode(p, true)));
+
+        workingDoc = wrappedDoc;
+        paragraphs = getElementsByTagNS(workingDoc, NS_W, 'p');
+        firstParagraph = paragraphs[0];
+        parent = firstParagraph.parentNode;
+    }
+
+    const importedTable = workingDoc.importNode(newTableElement, true);
+
+    if (generateRedlines) {
+        const date = getRevisionTimestamp();
+        paragraphs.forEach(p => {
+            const runs = getElementsByTagNS(p, NS_W, 'r');
+            runs.forEach(run => {
+                const textNodes = getElementsByTagNS(run, NS_W, 't');
+                textNodes.forEach(t => {
+                    const text = t.textContent || '';
+                    if (text.trim()) {
+                        const delText = workingDoc.createElementNS(NS_W, 'w:delText');
+                        delText.textContent = text;
+                        t.parentNode.replaceChild(delText, t);
+                    }
+                });
+
+                const del = workingDoc.createElementNS(NS_W, 'w:del');
+                del.setAttribute('w:id', String(getNextRevisionId()));
+                del.setAttribute('w:author', author);
+                del.setAttribute('w:date', date);
+                run.parentNode.insertBefore(del, run);
+                del.appendChild(run);
+            });
+        });
+    } else {
+        paragraphs.slice(1).forEach(p => p.parentNode.removeChild(p));
+    }
+
+    parent.insertBefore(importedTable, firstParagraph);
+    if (!generateRedlines) {
+        parent.removeChild(firstParagraph);
+    }
+
+    log('[OxmlEngine] Text-to-table transformation complete');
+    return { oxml: serializer.serializeToString(workingDoc), hasChanges: true };
+}

package/index.js

@@ -0,0 +1,308 @@
+/**
+ * Standalone reconciliation entrypoint (no Word JS API dependencies).
+ */
+
+// Adapters
+export { configureXmlProvider } from './adapters/xml-adapter.js';
+export { configureLogger } from './adapters/logger.js';
+export { setDefaultAuthor, getDefaultAuthor, setPlatform, getPlatform } from './adapters/config.js';
+
+// Engine
+import {
+    applyRedlineToOxml as applyRedlineToOxmlEngine,
+    sanitizeAiResponse,
+    parseOoxml,
+    serializeOoxml
+} from './engine/oxml-engine.js';
+import { parseTable as parseMarkdownTable } from './pipeline/pipeline.js';
+import { wrapInDocumentFragment as wrapInDocumentFragmentShared } from './pipeline/serialization.js';
+import {
+    buildSingleLineListStructuralFallbackPlan,
+    executeSingleLineListStructuralFallback,
+    resolveSingleLineListFallbackNumberingAction,
+    recordSingleLineListFallbackExplicitSequence,
+    clearSingleLineListFallbackExplicitSequence,
+    enforceListBindingOnParagraphNodes,
+    stripSingleLineListMarkerPrefix
+} from './orchestration/list-structural-fallback.js';
+
+/**
+ * Standalone-safe redline wrapper.
+ *
+ * In non-Word runtimes, the engine can return `{ useNativeApi: true, hasChanges: true }`
+ * without an OOXML payload for some format-only operations. Standalone callers cannot
+ * complete that native fallback path, so normalize to a no-op with warnings.
+ */
+export async function applyRedlineToOxml(oxml, originalText, modifiedText, options = {}) {
+    const result = await applyRedlineToOxmlEngine(oxml, originalText, modifiedText, options);
+    if (result?.useNativeApi && typeof result?.oxml !== 'string') {
+        const existingWarnings = Array.isArray(result?.warnings) ? result.warnings : [];
+        return {
+            ...result,
+            oxml,
+            hasChanges: false,
+            warnings: [
+                ...existingWarnings,
+                'Standalone mode cannot execute native Word API fallback for this operation.'
+            ]
+        };
+    }
+    return result;
+}
+
+/**
+ * Reconciles a Markdown table against an OOXML scope.
+ *
+ * This centralizes table-specific validation + reconciliation so Word add-in
+ * and browser modules can share the same entrypoint.
+ *
+ * @param {string} oxml - OOXML scope to reconcile (paragraph/range/table package)
+ * @param {string} originalText - Original visible text in that scope
+ * @param {string} markdownTable - Markdown table text
+ * @param {Object} [options={}] - Reconciliation options forwarded to applyRedlineToOxml
+ * @returns {Promise<{ oxml: string, hasChanges: boolean, warnings?: string[], isMarkdownTable: boolean, tableData?: Object }>}
+ */
+export async function reconcileMarkdownTableOoxml(oxml, originalText, markdownTable, options = {}) {
+    const sourceOoxml = typeof oxml === 'string' ? oxml : '';
+    const tableText = typeof markdownTable === 'string' ? markdownTable : String(markdownTable || '');
+    let tableData;
+
+    try {
+        tableData = parseMarkdownTable(tableText);
+    } catch {
+        tableData = { headers: [], rows: [] };
+    }
+
+    const hasTableData = (tableData?.headers?.length || 0) > 0 || (tableData?.rows?.length || 0) > 0;
+    if (!hasTableData) {
+        return {
+            oxml: sourceOoxml,
+            hasChanges: false,
+            isMarkdownTable: false,
+            warnings: ['Could not parse Markdown table from input.']
+        };
+    }
+
+    const result = await applyRedlineToOxml(
+        sourceOoxml,
+        originalText || '',
+        tableText,
+        options
+    );
+
+    return {
+        ...result,
+        isMarkdownTable: true,
+        tableData
+    };
+}
+
+export { resolveParagraphRangeByRefs } from './core/paragraph-targeting.js';
+export { inferTableReplacementParagraphBlock, isLikelyStructuredTableSourceParagraph } from './core/table-targeting.js';
+
+/**
+ * Applies redline reconciliation, then forces single-line structural list
+ * conversion when the redline is a no-op on marker-prefixed list text.
+ *
+ * This is useful for inputs like `1. HEADER` where text diff is unchanged but
+ * OOXML should convert plain text markers into real Word list structure.
+ *
+ * @param {string} oxml - Original OOXML
+ * @param {string} originalText - Original visible text
+ * @param {string} modifiedText - Proposed modified text
+ * @param {Object} [options={}] - Reconciliation options
+ * @param {boolean} [options.listFallbackAllowExistingList=true] - Allow fallback even when paragraph is already list-bound
+ * @returns {Promise<{ oxml: string, hasChanges: boolean } & Record<string, any>>}
+ */
+export async function applyRedlineToOxmlWithListFallback(oxml, originalText, modifiedText, options = {}) {
+    const allowExistingListForFallback = options.listFallbackAllowExistingList !== false;
+    const plan = buildSingleLineListStructuralFallbackPlan({
+        oxml,
+        originalText,
+        modifiedText,
+        allowExistingList: allowExistingListForFallback
+    });
+    const preferListFallback = options.preferListStructuralFallback !== false;
+    let preflightFallbackWarnings = [];
+
+    if (plan && preferListFallback) {
+        const fallbackResult = await executeSingleLineListStructuralFallback(plan, {
+            author: options.author,
+            generateRedlines: options.generateRedlines,
+            pipeline: options.listFallbackPipeline
+        });
+        if (fallbackResult?.hasChanges && fallbackResult?.oxml) {
+            const wrappedOxml = wrapInDocumentFragmentShared(fallbackResult.oxml, {
+                includeNumbering: fallbackResult.includeNumbering ?? true,
+                numberingXml: fallbackResult.numberingXml
+            });
+            const fallbackWarnings = Array.isArray(fallbackResult?.warnings) ? fallbackResult.warnings : [];
+            return {
+                oxml: wrappedOxml,
+                hasChanges: true,
+                warnings: fallbackWarnings,
+                listStructuralFallbackApplied: true,
+                listStructuralFallbackKey: fallbackResult.listStructuralFallbackKey || null,
+                listStructuralFallbackNumberingXml: fallbackResult.numberingXml || null
+            };
+        }
+        preflightFallbackWarnings = Array.isArray(fallbackResult?.warnings) ? fallbackResult.warnings : [];
+    }
+
+    const baseResult = await applyRedlineToOxml(oxml, originalText, modifiedText, options);
+
+    if (!plan) {
+        return {
+            ...baseResult,
+            warnings: [
+                ...(Array.isArray(baseResult?.warnings) ? baseResult.warnings : []),
+                ...preflightFallbackWarnings
+            ],
+            listStructuralFallbackApplied: false
+        };
+    }
+
+    if (preferListFallback) {
+        return {
+            ...baseResult,
+            warnings: [
+                ...(Array.isArray(baseResult?.warnings) ? baseResult.warnings : []),
+                ...preflightFallbackWarnings
+            ],
+            listStructuralFallbackApplied: false
+        };
+    }
+
+    if (baseResult?.hasChanges) {
+        return {
+            ...baseResult,
+            listStructuralFallbackApplied: false
+        };
+    }
+
+    const fallbackResult = await executeSingleLineListStructuralFallback(plan, {
+        author: options.author,
+        generateRedlines: options.generateRedlines,
+        pipeline: options.listFallbackPipeline
+    });
+    if (!fallbackResult?.hasChanges || !fallbackResult?.oxml) {
+        const existingWarnings = Array.isArray(baseResult?.warnings) ? baseResult.warnings : [];
+        const fallbackWarnings = Array.isArray(fallbackResult?.warnings) ? fallbackResult.warnings : [];
+        return {
+            ...baseResult,
+            warnings: [...existingWarnings, ...fallbackWarnings],
+            listStructuralFallbackApplied: false
+        };
+    }
+
+    const wrappedOxml = wrapInDocumentFragmentShared(fallbackResult.oxml, {
+        includeNumbering: fallbackResult.includeNumbering ?? true,
+        numberingXml: fallbackResult.numberingXml
+    });
+    const existingWarnings = Array.isArray(baseResult?.warnings) ? baseResult.warnings : [];
+    const fallbackWarnings = Array.isArray(fallbackResult?.warnings) ? fallbackResult.warnings : [];
+
+    return {
+        ...baseResult,
+        oxml: wrappedOxml,
+        hasChanges: true,
+        warnings: [...existingWarnings, ...preflightFallbackWarnings, ...fallbackWarnings],
+        listStructuralFallbackApplied: true,
+        listStructuralFallbackKey: fallbackResult.listStructuralFallbackKey || null,
+        listStructuralFallbackNumberingXml: fallbackResult.numberingXml || null
+    };
+}
+
+export { sanitizeAiResponse, parseOoxml, serializeOoxml };
+
+export {
+    createDynamicNumberingIdState,
+    reserveNextNumberingId,
+    reserveNextNumberingIdPair,
+    overwriteParagraphNumIds,
+    extractFirstParagraphNumId,
+    buildExplicitDecimalMultilevelNumberingXml,
+    remapNumberingPayloadForDocument,
+    mergeNumberingXmlBySchemaOrder
+} from './services/numbering-helpers.js';
+
+// Pipeline components
+export { ReconciliationPipeline } from './pipeline/pipeline.js';
+export { ingestOoxml } from './pipeline/ingestion.js';
+export { ingestWordOoxmlToPlainText, ingestWordOoxmlToMarkdown } from './pipeline/ingestion-export.js';
+export { preprocessMarkdown } from './pipeline/markdown-processor.js';
+export { serializeToOoxml, wrapInDocumentFragment } from './pipeline/serialization.js';
+
+// Comment engine
+export {
+    injectCommentsIntoOoxml,
+    injectCommentsIntoPackage,
+    buildCommentElement,
+    buildCommentsPartXml
+} from './services/comment-engine.js';
+
+// Formatting removal utilities
+export {
+    removeFormattingFromRPr,
+    applyFormattingRemovalToOoxml,
+    applyHighlightToOoxml
+} from './engine/formatting-removal.js';
+
+// Table/list tools
+export { generateTableOoxml } from './services/table-reconciliation.js';
+export { NumberingService } from './services/numbering-service.js';
+export {
+    parseXmlStrictStandalone,
+    getBodyElementFromDocument,
+    insertBodyElementBeforeSectPr,
+    normalizeBodySectionOrderStandalone,
+    sanitizeNestedParagraphsInTables,
+    getPackagePartName,
+    extractReplacementNodesFromOoxml,
+    ensureNumberingArtifactsInZip,
+    ensureCommentsArtifactsInZip,
+    validateDocxPackage
+} from './services/standalone-docx-plumbing.js';
+export { buildReconciliationPlan, RoutePlanKind, normalizeContentEscapesForRouting } from './orchestration/route-plan.js';
+export { parseMarkdownListContent, hasListItems } from './orchestration/list-parsing.js';
+export { buildListMarkdown, inferNumberingStyleFromMarker, normalizeListItemsWithLevels } from './orchestration/list-markdown.js';
+export {
+    buildSingleLineListStructuralFallbackPlan,
+    executeSingleLineListStructuralFallback,
+    resolveSingleLineListFallbackNumberingAction,
+    recordSingleLineListFallbackExplicitSequence,
+    clearSingleLineListFallbackExplicitSequence,
+    enforceListBindingOnParagraphNodes,
+    stripSingleLineListMarkerPrefix
+} from './orchestration/list-structural-fallback.js';
+
+// Core types/constants
+export { DiffOp, RunKind, ContainerKind, ContentType, NS_W, escapeXml } from './core/types.js';
+export { extractParagraphIdFromOoxml } from './core/ooxml-identifiers.js';
+export {
+    WORD_MAIN_NS,
+    getParagraphText,
+    getDocumentParagraphNodes,
+    normalizeWhitespaceForTargeting,
+    isMarkdownTableText,
+    parseParagraphReference,
+    stripLeadingParagraphMarker,
+    splitLeadingParagraphMarker,
+    findContainingWordElement,
+    findParagraphByReference,
+    findParagraphByStrictText,
+    findParagraphByBestTextMatch,
+    resolveTargetParagraph,
+    buildTargetReferenceSnapshot,
+    resolveTargetParagraphWithSnapshot
+} from './core/paragraph-targeting.js';
+export { synthesizeTableMarkdownFromMultilineCellEdit } from './core/table-targeting.js';
+export {
+    getParagraphListInfo,
+    collectContiguousListParagraphBlock,
+    synthesizeExpandedListScopeEdit,
+    planListInsertionOnlyEdit,
+    stripRedundantLeadingListMarkers
+} from './core/list-targeting.js';
+
+

package/orchestration/list-markdown.js

@@ -0,0 +1,141 @@
+/**
+ * Shared list markdown construction/parsing helpers for command adapters.
+ */
+
+/**
+ * Infers numbering style from a list marker.
+ *
+ * @param {string} marker - Marker text
+ * @returns {'decimal'|'lowerAlpha'|'upperAlpha'|'lowerRoman'|'upperRoman'}
+ */
+export function inferNumberingStyleFromMarker(marker) {
+    const m = (marker || '').trim();
+    if (!m) return 'decimal';
+    if (/^\d+(?:\.\d+)*\.?$/.test(m) || /^\(\d+\)$/.test(m)) return 'decimal';
+    if (/^[ivxlcdm]+\.$/.test(m)) return 'lowerRoman';
+    if (/^[IVXLCDM]{2,}\.$/.test(m)) return 'upperRoman';
+    if (/^[a-z]\.$/.test(m)) return 'lowerAlpha';
+    if (/^[A-Z]\.$/.test(m)) return 'upperAlpha';
+    return 'decimal';
+}
+
+/**
+ * Builds list markdown from normalized item+level input.
+ *
+ * @param {Array<{ text: string, level: number }>} itemsWithLevels - Items with indentation levels
+ * @param {'bullet'|'numbered'} listType - List kind
+ * @param {'decimal'|'lowerAlpha'|'upperAlpha'|'lowerRoman'|'upperRoman'} numberingStyle - Number style for numbered lists
+ * @returns {string}
+ */
+export function buildListMarkdown(itemsWithLevels, listType, numberingStyle) {
+    const levelCounters = new Map();
+    const lines = [];
+
+    for (const item of itemsWithLevels) {
+        const level = Math.max(0, Number(item?.level) || 0);
+        for (const key of Array.from(levelCounters.keys())) {
+            if (key > level) {
+                levelCounters.delete(key);
+            }
+        }
+
+        const nextCounter = (levelCounters.get(level) || 0) + 1;
+        levelCounters.set(level, nextCounter);
+
+        const marker = buildListMarker(nextCounter, listType, numberingStyle);
+        const indent = ' '.repeat(level * 4);
+        lines.push(`${indent}${marker} ${item.text || ''}`.trimEnd());
+    }
+
+    return lines.join('\n');
+}
+
+/**
+ * Normalizes list item text/indentation into markdown-ready model.
+ *
+ * @param {Array<string>} rawItems - Raw tool items
+ * @param {Object} [options={}] - Normalize options
+ * @param {number} [options.indentSpaces=4] - Spaces per indent level
+ * @returns {Array<{ text: string, level: number, removedMarker: string|null }>}
+ */
+export function normalizeListItemsWithLevels(rawItems, options = {}) {
+    const indentSpaces = Math.max(1, Number(options.indentSpaces) || 4);
+    const markersRegex = /^((?:\d+(?:\.\d+)*\.?|\((?:\d+|[a-zA-Z]|[ivxlcIVXLC]+)\)|[a-zA-Z]\.|\d+\.|[ivxlcIVXLC]+\.|[-*•])\s*)/;
+
+    return (rawItems || []).map((rawItem) => {
+        const item = String(rawItem ?? '');
+        const indentMatch = item.match(/^(\s*)/);
+        const indentSize = indentMatch ? indentMatch[1].length : 0;
+        const level = Math.floor(indentSize / indentSpaces);
+
+        let stripped = item.trim();
+        let removedMarker = null;
+        const markerMatch = stripped.match(markersRegex);
+        if (markerMatch) {
+            removedMarker = markerMatch[1].trim() || null;
+            stripped = stripped.replace(markersRegex, '');
+        }
+
+        return {
+            text: stripped.trim(),
+            level,
+            removedMarker
+        };
+    });
+}
+
+function buildListMarker(counter, listType, numberingStyle) {
+    if (listType === 'bullet') return '-';
+
+    switch (numberingStyle) {
+        case 'lowerAlpha':
+            return `${toAlphaSequence(counter, false)}.`;
+        case 'upperAlpha':
+            return `${toAlphaSequence(counter, true)}.`;
+        case 'lowerRoman':
+            return `${toRoman(counter, false)}.`;
+        case 'upperRoman':
+            return `${toRoman(counter, true)}.`;
+        case 'decimal':
+        default:
+            return `${counter}.`;
+    }
+}
+
+function toAlphaSequence(value, upper = false) {
+    let n = Math.max(1, Number(value) || 1);
+    let out = '';
+    while (n > 0) {
+        n -= 1;
+        out = String.fromCharCode(97 + (n % 26)) + out;
+        n = Math.floor(n / 26);
+    }
+    return upper ? out.toUpperCase() : out;
+}
+
+function toRoman(value, upper = false) {
+    let n = Math.max(1, Number(value) || 1);
+    const romanPairs = [
+        [1000, 'M'],
+        [900, 'CM'],
+        [500, 'D'],
+        [400, 'CD'],
+        [100, 'C'],
+        [90, 'XC'],
+        [50, 'L'],
+        [40, 'XL'],
+        [10, 'X'],
+        [9, 'IX'],
+        [5, 'V'],
+        [4, 'IV'],
+        [1, 'I']
+    ];
+    let out = '';
+    for (const [num, sym] of romanPairs) {
+        while (n >= num) {
+            out += sym;
+            n -= num;
+        }
+    }
+    return upper ? out : out.toLowerCase();
+}

package/orchestration/list-parsing.js

@@ -0,0 +1,73 @@
+/**
+ * Shared markdown list parsing for command adapters.
+ *
+ * Keeps command-layer list parsing aligned with reconciliation marker logic.
+ */
+
+import { matchListMarker, stripListMarker } from '../pipeline/list-markers.js';
+
+/**
+ * Parses markdown list-like content into structured items.
+ *
+ * Output shape is compatible with command-layer expectations from `parseMarkdownList`.
+ *
+ * @param {string} content - Raw markdown/text content
+ * @returns {{ type: 'numbered'|'bullet'|'text', items: Array<{ type: 'numbered'|'bullet'|'text', level: number, text: string, marker?: string }> }|null}
+ */
+export function parseMarkdownListContent(content) {
+    if (!content) return null;
+
+    const normalized = String(content).trim();
+    if (!normalized) return null;
+
+    const lines = normalized.split('\n');
+    const items = [];
+
+    for (const line of lines) {
+        if (!line.trim()) continue;
+
+        const markerMatch = matchListMarker(line, { allowZeroSpaceAfterMarker: false });
+        if (markerMatch) {
+            const indent = markerMatch[1] || '';
+            const marker = markerMatch[2].trim();
+            const text = stripListMarker(line, { allowZeroSpaceAfterMarker: false }).trim();
+            const level = Math.floor(indent.length / 2);
+            const isBullet = /^[-*+\u2022]$/.test(marker);
+
+            items.push({
+                type: isBullet ? 'bullet' : 'numbered',
+                level,
+                text,
+                marker
+            });
+            continue;
+        }
+
+        items.push({
+            type: 'text',
+            level: 0,
+            text: line.trim()
+        });
+    }
+
+    if (items.length === 0) return null;
+
+    const hasNumbered = items.some(item => item.type === 'numbered');
+    const hasBullet = items.some(item => item.type === 'bullet');
+
+    return {
+        type: hasNumbered ? 'numbered' : (hasBullet ? 'bullet' : 'text'),
+        items
+    };
+}
+
+/**
+ * Checks whether parsed list data includes at least one real list item.
+ *
+ * @param {{ items?: Array<{ type?: string }> }|null} parsedListData - Parsed list data
+ * @returns {boolean}
+ */
+export function hasListItems(parsedListData) {
+    if (!parsedListData || !Array.isArray(parsedListData.items)) return false;
+    return parsedListData.items.some(item => item?.type === 'numbered' || item?.type === 'bullet');
+}