docrev 0.2.0 → 0.3.0

package/lib/merge.js

@@ -0,0 +1,365 @@
+/**
+ * Multi-reviewer merge utilities
+ * Combine feedback from multiple Word documents with conflict detection
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import { diffWords } from 'diff';
+import { extractTextFromWord, extractCommentsFromWord } from './import.js';
+
+/**
+ * Represents a change from a reviewer
+ * @typedef {Object} ReviewerChange
+ * @property {string} reviewer - Reviewer name/identifier
+ * @property {string} type - 'insert' | 'delete' | 'replace'
+ * @property {number} start - Start position in original text
+ * @property {number} end - End position in original text
+ * @property {string} oldText - Original text (for delete/replace)
+ * @property {string} newText - New text (for insert/replace)
+ */
+
+/**
+ * Represents a conflict between reviewers
+ * @typedef {Object} Conflict
+ * @property {number} start - Start position in original
+ * @property {number} end - End position in original
+ * @property {string} original - Original text
+ * @property {ReviewerChange[]} changes - Conflicting changes from different reviewers
+ */
+
+/**
+ * Extract changes from a Word document compared to original
+ * @param {string} originalText - Original markdown text
+ * @param {string} wordText - Text extracted from Word
+ * @param {string} reviewer - Reviewer identifier
+ * @returns {ReviewerChange[]}
+ */
+export function extractChanges(originalText, wordText, reviewer) {
+  const changes = [];
+  const diffs = diffWords(originalText, wordText);
+
+  let originalPos = 0;
+  let i = 0;
+
+  while (i < diffs.length) {
+    const part = diffs[i];
+
+    if (!part.added && !part.removed) {
+      // Unchanged
+      originalPos += part.value.length;
+      i++;
+    } else if (part.removed && diffs[i + 1]?.added) {
+      // Replacement: removed followed by added
+      changes.push({
+        reviewer,
+        type: 'replace',
+        start: originalPos,
+        end: originalPos + part.value.length,
+        oldText: part.value,
+        newText: diffs[i + 1].value,
+      });
+      originalPos += part.value.length;
+      i += 2;
+    } else if (part.removed) {
+      // Pure deletion
+      changes.push({
+        reviewer,
+        type: 'delete',
+        start: originalPos,
+        end: originalPos + part.value.length,
+        oldText: part.value,
+        newText: '',
+      });
+      originalPos += part.value.length;
+      i++;
+    } else if (part.added) {
+      // Pure insertion
+      changes.push({
+        reviewer,
+        type: 'insert',
+        start: originalPos,
+        end: originalPos,
+        oldText: '',
+        newText: part.value,
+      });
+      i++;
+    }
+  }
+
+  return changes;
+}
+
+/**
+ * Check if two changes overlap
+ * @param {ReviewerChange} a
+ * @param {ReviewerChange} b
+ * @returns {boolean}
+ */
+function changesOverlap(a, b) {
+  // Insertions at same point conflict
+  if (a.type === 'insert' && b.type === 'insert' && a.start === b.start) {
+    return a.newText !== b.newText; // Same insertion is not a conflict
+  }
+
+  // Check range overlap
+  const aStart = a.start;
+  const aEnd = a.type === 'insert' ? a.start : a.end;
+  const bStart = b.start;
+  const bEnd = b.type === 'insert' ? b.start : b.end;
+
+  // Ranges overlap if neither ends before the other starts
+  if (aEnd <= bStart || bEnd <= aStart) {
+    return false;
+  }
+
+  // They overlap - but is it a conflict?
+  // Same change from different reviewers is not a conflict
+  if (a.type === b.type && a.oldText === b.oldText && a.newText === b.newText) {
+    return false;
+  }
+
+  return true;
+}
+
+/**
+ * Detect conflicts between changes from multiple reviewers
+ * @param {ReviewerChange[][]} allChanges - Array of change arrays, one per reviewer
+ * @returns {{conflicts: Conflict[], nonConflicting: ReviewerChange[]}}
+ */
+export function detectConflicts(allChanges) {
+  // Flatten and sort all changes by position
+  const flat = allChanges.flat().sort((a, b) => a.start - b.start || a.end - b.end);
+
+  const conflicts = [];
+  const nonConflicting = [];
+  const usedIndices = new Set();
+
+  for (let i = 0; i < flat.length; i++) {
+    if (usedIndices.has(i)) continue;
+
+    const change = flat[i];
+    const conflictingChanges = [change];
+
+    // Find all changes that conflict with this one
+    for (let j = i + 1; j < flat.length; j++) {
+      if (usedIndices.has(j)) continue;
+
+      const other = flat[j];
+
+      // Stop if we're past the range
+      if (other.start > change.end && change.type !== 'insert') break;
+
+      if (changesOverlap(change, other)) {
+        conflictingChanges.push(other);
+        usedIndices.add(j);
+      }
+    }
+
+    if (conflictingChanges.length > 1) {
+      // Multiple reviewers changed the same region
+      const start = Math.min(...conflictingChanges.map(c => c.start));
+      const end = Math.max(...conflictingChanges.map(c => c.end));
+
+      conflicts.push({
+        start,
+        end,
+        original: conflictingChanges[0].oldText || '',
+        changes: conflictingChanges,
+      });
+      usedIndices.add(i);
+    } else {
+      // No conflict
+      nonConflicting.push(change);
+      usedIndices.add(i);
+    }
+  }
+
+  // Deduplicate identical non-conflicting changes
+  const seen = new Map();
+  const dedupedNonConflicting = [];
+
+  for (const change of nonConflicting) {
+    const key = `${change.start}:${change.end}:${change.type}:${change.newText}`;
+    if (!seen.has(key)) {
+      seen.set(key, true);
+      dedupedNonConflicting.push(change);
+    }
+  }
+
+  return { conflicts, nonConflicting: dedupedNonConflicting };
+}
+
+/**
+ * Apply non-conflicting changes to text
+ * @param {string} originalText
+ * @param {ReviewerChange[]} changes - Must be sorted by position
+ * @returns {string}
+ */
+export function applyChanges(originalText, changes) {
+  // Sort by position descending to apply from end to start
+  const sorted = [...changes].sort((a, b) => b.start - a.start);
+
+  let result = originalText;
+
+  for (const change of sorted) {
+    if (change.type === 'insert') {
+      result = result.slice(0, change.start) + change.newText + result.slice(change.start);
+    } else if (change.type === 'delete') {
+      result = result.slice(0, change.start) + result.slice(change.end);
+    } else if (change.type === 'replace') {
+      result = result.slice(0, change.start) + change.newText + result.slice(change.end);
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Apply changes as CriticMarkup annotations
+ * @param {string} originalText
+ * @param {ReviewerChange[]} changes
+ * @returns {string}
+ */
+export function applyChangesAsAnnotations(originalText, changes) {
+  const sorted = [...changes].sort((a, b) => b.start - a.start);
+
+  let result = originalText;
+
+  for (const change of sorted) {
+    const reviewer = change.reviewer;
+
+    if (change.type === 'insert') {
+      const annotation = `{++${change.newText}++}`;
+      result = result.slice(0, change.start) + annotation + result.slice(change.start);
+    } else if (change.type === 'delete') {
+      const annotation = `{--${change.oldText}--}`;
+      result = result.slice(0, change.start) + annotation + result.slice(change.end);
+    } else if (change.type === 'replace') {
+      const annotation = `{~~${change.oldText}~>${change.newText}~~}`;
+      result = result.slice(0, change.start) + annotation + result.slice(change.end);
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Format a conflict for display
+ * @param {Conflict} conflict
+ * @param {string} originalText
+ * @returns {string}
+ */
+export function formatConflict(conflict, originalText) {
+  const lines = [];
+  const context = 30;
+
+  // Show context
+  const beforeStart = Math.max(0, conflict.start - context);
+  const afterEnd = Math.min(originalText.length, conflict.end + context);
+
+  const before = originalText.slice(beforeStart, conflict.start);
+  const original = originalText.slice(conflict.start, conflict.end);
+  const after = originalText.slice(conflict.end, afterEnd);
+
+  lines.push(`Context: ...${before}[CONFLICT]${after}...`);
+  lines.push(`Original: "${original || '(insertion point)'}"`);
+  lines.push('');
+  lines.push('Options:');
+
+  conflict.changes.forEach((change, i) => {
+    const label = change.type === 'insert'
+      ? `Insert: "${change.newText}"`
+      : change.type === 'delete'
+        ? `Delete: "${change.oldText}"`
+        : `Replace "${change.oldText}" → "${change.newText}"`;
+    lines.push(`  ${i + 1}. [${change.reviewer}] ${label}`);
+  });
+
+  return lines.join('\n');
+}
+
+/**
+ * Merge multiple Word documents against an original
+ * @param {string} originalPath - Path to original markdown
+ * @param {Array<{path: string, name: string}>} reviewerDocs - Reviewer Word docs
+ * @param {Object} options
+ * @returns {Promise<{merged: string, conflicts: Conflict[], stats: Object}>}
+ */
+export async function mergeReviewerDocs(originalPath, reviewerDocs, options = {}) {
+  const { autoResolve = false } = options;
+
+  if (!fs.existsSync(originalPath)) {
+    throw new Error(`Original file not found: ${originalPath}`);
+  }
+
+  const originalText = fs.readFileSync(originalPath, 'utf-8');
+
+  // Extract changes from each reviewer
+  const allChanges = [];
+  const allComments = [];
+
+  for (const doc of reviewerDocs) {
+    if (!fs.existsSync(doc.path)) {
+      throw new Error(`Reviewer file not found: ${doc.path}`);
+    }
+
+    const wordText = await extractTextFromWord(doc.path);
+    const changes = extractChanges(originalText, wordText, doc.name);
+    allChanges.push(changes);
+
+    // Also extract comments
+    try {
+      const comments = await extractCommentsFromWord(doc.path);
+      allComments.push(...comments.map(c => ({ ...c, reviewer: doc.name })));
+    } catch {
+      // Comments extraction failed, continue without
+    }
+  }
+
+  // Detect conflicts
+  const { conflicts, nonConflicting } = detectConflicts(allChanges);
+
+  // Apply non-conflicting changes as annotations
+  let merged = applyChangesAsAnnotations(originalText, nonConflicting);
+
+  // Add comments
+  for (const comment of allComments) {
+    // Append comments at the end for now (position tracking is complex)
+    merged += `\n{>>${comment.reviewer}: ${comment.text}<<}`;
+  }
+
+  const stats = {
+    reviewers: reviewerDocs.length,
+    totalChanges: allChanges.flat().length,
+    nonConflicting: nonConflicting.length,
+    conflicts: conflicts.length,
+    comments: allComments.length,
+  };
+
+  return { merged, conflicts, stats, originalText };
+}
+
+/**
+ * Resolve a conflict by choosing one option
+ * @param {string} text - Current merged text
+ * @param {Conflict} conflict
+ * @param {number} choice - Index of chosen change (0-based)
+ * @param {string} originalText - Original text for position reference
+ * @returns {string}
+ */
+export function resolveConflict(text, conflict, choice, originalText) {
+  const chosen = conflict.changes[choice];
+
+  // Find the conflict region in the current text
+  // This is simplified - real implementation would track positions
+  const annotation = chosen.type === 'insert'
+    ? `{++${chosen.newText}++}`
+    : chosen.type === 'delete'
+      ? `{--${chosen.oldText}--}`
+      : `{~~${chosen.oldText}~>${chosen.newText}~~}`;
+
+  // For now, append resolved conflicts at marker position
+  // A more sophisticated approach would track exact positions
+  return text + `\n<!-- Resolved: ${annotation} -->`;
+}

package/lib/trackchanges.js

@@ -0,0 +1,273 @@
+/**
+ * Track Changes export utilities
+ * Convert CriticMarkup annotations to Word track changes format
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import AdmZip from 'adm-zip';
+import { parseAnnotations } from './annotations.js';
+
+/**
+ * Generate a unique revision ID
+ * @returns {number}
+ */
+let revisionId = 0;
+function getNextRevId() {
+  return revisionId++;
+}
+
+/**
+ * Format date for Word revision
+ * @returns {string}
+ */
+function getRevisionDate() {
+  return new Date().toISOString().replace('Z', '');
+}
+
+/**
+ * Escape XML special characters
+ * @param {string} text
+ * @returns {string}
+ */
+function escapeXml(text) {
+  return text
+    .replace(/&/g, '&')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&apos;');
+}
+
+/**
+ * Create Word insertion markup
+ * @param {string} text - Text to insert
+ * @param {string} author - Author name
+ * @returns {string}
+ */
+function createInsertionXml(text, author = 'Author') {
+  const id = getNextRevId();
+  const date = getRevisionDate();
+
+  return `<w:ins w:id="${id}" w:author="${escapeXml(author)}" w:date="${date}"><w:r><w:t>${escapeXml(text)}</w:t></w:r></w:ins>`;
+}
+
+/**
+ * Create Word deletion markup
+ * @param {string} text - Text to delete
+ * @param {string} author - Author name
+ * @returns {string}
+ */
+function createDeletionXml(text, author = 'Author') {
+  const id = getNextRevId();
+  const date = getRevisionDate();
+
+  return `<w:del w:id="${id}" w:author="${escapeXml(author)}" w:date="${date}"><w:r><w:delText>${escapeXml(text)}</w:delText></w:r></w:del>`;
+}
+
+/**
+ * Convert CriticMarkup to Word track changes in markdown
+ * This creates a special markdown format that can be processed after pandoc
+ *
+ * @param {string} text - Markdown with CriticMarkup
+ * @returns {{text: string, annotations: Array}}
+ */
+export function prepareForTrackChanges(text) {
+  const annotations = parseAnnotations(text);
+  const markers = [];
+
+  // Sort by position descending to replace from end
+  const sorted = [...annotations].sort((a, b) => b.position - a.position);
+
+  let result = text;
+
+  for (const ann of sorted) {
+    const marker = `{{TC_${markers.length}}}`;
+
+    markers.push({
+      id: markers.length,
+      type: ann.type,
+      content: ann.content,
+      replacement: ann.replacement,
+      author: ann.author || 'Reviewer',
+    });
+
+    // Replace annotation with marker
+    result = result.slice(0, ann.position) + marker + result.slice(ann.position + ann.match.length);
+  }
+
+  return { text: result, markers };
+}
+
+/**
+ * Post-process a DOCX file to convert markers to track changes
+ *
+ * @param {string} docxPath - Path to DOCX file
+ * @param {Array} markers - Markers from prepareForTrackChanges
+ * @param {string} outputPath - Output path
+ * @returns {Promise<{success: boolean, message: string}>}
+ */
+export async function applyTrackChangesToDocx(docxPath, markers, outputPath) {
+  if (!fs.existsSync(docxPath)) {
+    return { success: false, message: `File not found: ${docxPath}` };
+  }
+
+  try {
+    const zip = new AdmZip(docxPath);
+    const documentEntry = zip.getEntry('word/document.xml');
+
+    if (!documentEntry) {
+      return { success: false, message: 'Invalid DOCX: no document.xml' };
+    }
+
+    let documentXml = zip.readAsText(documentEntry);
+
+    // Enable track changes in settings
+    const settingsEntry = zip.getEntry('word/settings.xml');
+    if (settingsEntry) {
+      let settingsXml = zip.readAsText(settingsEntry);
+      // Add trackRevisions setting if not present
+      if (!settingsXml.includes('w:trackRevisions')) {
+        settingsXml = settingsXml.replace(
+          '</w:settings>',
+          '<w:trackRevisions/></w:settings>'
+        );
+        zip.updateFile('word/settings.xml', Buffer.from(settingsXml, 'utf-8'));
+      }
+    }
+
+    // Replace markers with track changes XML
+    for (const marker of markers) {
+      const markerText = `{{TC_${marker.id}}}`;
+
+      // Find the marker in document.xml (may be split across runs)
+      // First try simple replacement
+      if (documentXml.includes(markerText)) {
+        let replacement;
+
+        switch (marker.type) {
+          case 'insert':
+            replacement = createInsertionXml(marker.content, marker.author);
+            break;
+          case 'delete':
+            replacement = createDeletionXml(marker.content, marker.author);
+            break;
+          case 'substitute':
+            // Substitution = deletion + insertion
+            replacement =
+              createDeletionXml(marker.content, marker.author) +
+              createInsertionXml(marker.replacement, marker.author);
+            break;
+          case 'comment':
+            // Comments are handled differently - skip for track changes
+            replacement = '';
+            break;
+          default:
+            replacement = '';
+        }
+
+        documentXml = documentXml.replace(markerText, replacement);
+      } else {
+        // Marker might be split across <w:t> elements
+        // Try to find and reconstruct
+        const markerPattern = markerText.split('').join('(?:</w:t></w:r><w:r><w:t>)?');
+        const regex = new RegExp(markerPattern, 'g');
+
+        if (regex.test(documentXml)) {
+          let replacement;
+
+          switch (marker.type) {
+            case 'insert':
+              replacement = `</w:t></w:r>${createInsertionXml(marker.content, marker.author)}<w:r><w:t>`;
+              break;
+            case 'delete':
+              replacement = `</w:t></w:r>${createDeletionXml(marker.content, marker.author)}<w:r><w:t>`;
+              break;
+            case 'substitute':
+              replacement =
+                `</w:t></w:r>${createDeletionXml(marker.content, marker.author)}` +
+                `${createInsertionXml(marker.replacement, marker.author)}<w:r><w:t>`;
+              break;
+            default:
+              replacement = '';
+          }
+
+          documentXml = documentXml.replace(regex, replacement);
+        }
+      }
+    }
+
+    // Clean up empty runs created by replacements
+    documentXml = documentXml.replace(/<w:r><w:t><\/w:t><\/w:r>/g, '');
+
+    zip.updateFile('word/document.xml', Buffer.from(documentXml, 'utf-8'));
+    zip.writeZip(outputPath);
+
+    return { success: true, message: `Created ${outputPath} with track changes` };
+  } catch (err) {
+    return { success: false, message: err.message };
+  }
+}
+
+/**
+ * Build DOCX with track changes visible
+ * This is the main entry point for the audit export feature
+ *
+ * @param {string} markdownPath - Path to markdown with annotations
+ * @param {string} outputPath - Output DOCX path
+ * @param {Object} options
+ * @returns {Promise<{success: boolean, message: string, stats: Object}>}
+ */
+export async function buildWithTrackChanges(markdownPath, outputPath, options = {}) {
+  const { author = 'Reviewer' } = options;
+
+  if (!fs.existsSync(markdownPath)) {
+    return { success: false, message: `File not found: ${markdownPath}`, stats: null };
+  }
+
+  const text = fs.readFileSync(markdownPath, 'utf-8');
+  const { text: preparedText, markers } = prepareForTrackChanges(text);
+
+  // Assign author to markers that don't have one
+  for (const marker of markers) {
+    if (!marker.author || marker.author === 'Reviewer') {
+      marker.author = author;
+    }
+  }
+
+  // Write temporary markdown
+  const tempMd = outputPath.replace('.docx', '.tmp.md');
+  const tempDocx = outputPath.replace('.docx', '.tmp.docx');
+
+  fs.writeFileSync(tempMd, preparedText, 'utf-8');
+
+  // Run pandoc to create initial DOCX
+  const { execSync } = await import('child_process');
+
+  try {
+    execSync(`pandoc "${tempMd}" -o "${tempDocx}"`, { stdio: 'pipe' });
+  } catch (err) {
+    fs.unlinkSync(tempMd);
+    return { success: false, message: `Pandoc failed: ${err.message}`, stats: null };
+  }
+
+  // Apply track changes
+  const result = await applyTrackChangesToDocx(tempDocx, markers, outputPath);
+
+  // Cleanup
+  try {
+    fs.unlinkSync(tempMd);
+    fs.unlinkSync(tempDocx);
+  } catch {
+    // Ignore cleanup errors
+  }
+
+  const stats = {
+    insertions: markers.filter(m => m.type === 'insert').length,
+    deletions: markers.filter(m => m.type === 'delete').length,
+    substitutions: markers.filter(m => m.type === 'substitute').length,
+    total: markers.length,
+  };
+
+  return { ...result, stats };
+}