docrev 0.3.0 → 0.5.1

package/lib/trackchanges.js

@@ -1,37 +1,19 @@
 /**
- * Track Changes export utilities
- * Convert CriticMarkup annotations to Word track changes format
+ * Track changes module - Apply markdown annotations as Word track changes
+ *
+ * Converts CriticMarkup annotations to Word OOXML track changes format.
  */
 
 import * as fs from 'fs';
 import * as path from 'path';
+import { execSync } from 'child_process';
 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
+function escapeXml(str) {
+  return str
     .replace(/&/g, '&')
     .replace(/</g, '&lt;')
     .replace(/>/g, '&gt;')
@@ -40,71 +22,87 @@ function escapeXml(text) {
 }
 
 /**
- * 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
+ * Prepare text with CriticMarkup annotations for track changes
+ * Replaces annotations with markers that can be processed in DOCX
  *
- * @param {string} text - Markdown with CriticMarkup
- * @returns {{text: string, annotations: Array}}
+ * @param {string} text - Text with CriticMarkup annotations
+ * @param {object} options - Options
+ * @param {string} options.author - Default author for track changes
+ * @returns {{text: string, markers: Array}} Processed text and marker info
  */
-export function prepareForTrackChanges(text) {
-  const annotations = parseAnnotations(text);
+export function prepareForTrackChanges(text, options = {}) {
+  const { author = 'Reviewer' } = options;
   const markers = [];
-
-  // Sort by position descending to replace from end
-  const sorted = [...annotations].sort((a, b) => b.position - a.position);
+  let markerId = 0;
 
   let result = text;
 
-  for (const ann of sorted) {
-    const marker = `{{TC_${markers.length}}}`;
+  // Process insertions: {++text++}
+  result = result.replace(/\{\+\+(.+?)\+\+\}/gs, (match, content) => {
+    const id = markerId++;
+    markers.push({
+      id,
+      type: 'insert',
+      content,
+      author,
+    });
+    return `{{TC_${id}}}`;
+  });
 
+  // Process deletions: {--text--}
+  result = result.replace(/\{--(.+?)--\}/gs, (match, content) => {
+    const id = markerId++;
     markers.push({
-      id: markers.length,
-      type: ann.type,
-      content: ann.content,
-      replacement: ann.replacement,
-      author: ann.author || 'Reviewer',
+      id,
+      type: 'delete',
+      content,
+      author,
     });
+    return `{{TC_${id}}}`;
+  });
 
-    // Replace annotation with marker
-    result = result.slice(0, ann.position) + marker + result.slice(ann.position + ann.match.length);
-  }
+  // Process substitutions: {~~old~>new~~}
+  result = result.replace(/\{~~(.+?)~>(.+?)~~\}/gs, (match, old, replacement) => {
+    const id = markerId++;
+    markers.push({
+      id,
+      type: 'substitute',
+      content: old,
+      replacement,
+      author,
+    });
+    return `{{TC_${id}}}`;
+  });
+
+  // Process comments: {>>Author: comment<<}
+  result = result.replace(/\{>>(.+?)<<\}/gs, (match, content) => {
+    const id = markerId++;
+    // Extract author if present (format: "Author: comment")
+    const colonIdx = content.indexOf(':');
+    let commentAuthor = author;
+    let commentText = content;
+    if (colonIdx > 0 && colonIdx < 30) {
+      commentAuthor = content.slice(0, colonIdx).trim();
+      commentText = content.slice(colonIdx + 1).trim();
+    }
+    markers.push({
+      id,
+      type: 'comment',
+      content: commentText,
+      author: commentAuthor,
+    });
+    return `{{TC_${id}}}`;
+  });
 
   return { text: result, markers };
 }
 
 /**
- * Post-process a DOCX file to convert markers to track changes
+ * Apply track changes markers to a Word document
  *
- * @param {string} docxPath - Path to DOCX file
+ * @param {string} docxPath - Path to input DOCX file
  * @param {Array} markers - Markers from prepareForTrackChanges
- * @param {string} outputPath - Output path
+ * @param {string} outputPath - Path for output DOCX file
  * @returns {Promise<{success: boolean, message: string}>}
  */
 export async function applyTrackChangesToDocx(docxPath, markers, outputPath) {
@@ -112,162 +110,120 @@ export async function applyTrackChangesToDocx(docxPath, markers, outputPath) {
     return { success: false, message: `File not found: ${docxPath}` };
   }
 
+  let zip;
   try {
-    const zip = new AdmZip(docxPath);
-    const documentEntry = zip.getEntry('word/document.xml');
+    zip = new AdmZip(docxPath);
+  } catch (err) {
+    return { success: false, message: `Invalid DOCX file: ${err.message}` };
+  }
 
-    if (!documentEntry) {
-      return { success: false, message: 'Invalid DOCX: no document.xml' };
-    }
+  // Read document.xml
+  const docEntry = zip.getEntry('word/document.xml');
+  if (!docEntry) {
+    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'));
-      }
-    }
+  let documentXml = zip.readAsText(docEntry);
 
-    // 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);
-        }
-      }
-    }
+  // Generate ISO date for track changes
+  const now = new Date().toISOString();
 
-    // Clean up empty runs created by replacements
-    documentXml = documentXml.replace(/<w:r><w:t><\/w:t><\/w:r>/g, '');
+  // Replace markers with track change XML
+  for (const marker of markers) {
+    const placeholder = `{{TC_${marker.id}}}`;
+    let replacement = '';
+
+    const escapedContent = escapeXml(marker.content);
+    const escapedAuthor = escapeXml(marker.author);
+
+    if (marker.type === 'insert') {
+      replacement = `<w:ins w:id="${marker.id}" w:author="${escapedAuthor}" w:date="${now}"><w:r><w:t>${escapedContent}</w:t></w:r></w:ins>`;
+    } else if (marker.type === 'delete') {
+      replacement = `<w:del w:id="${marker.id}" w:author="${escapedAuthor}" w:date="${now}"><w:r><w:delText>${escapedContent}</w:delText></w:r></w:del>`;
+    } else if (marker.type === 'substitute') {
+      const escapedReplacement = escapeXml(marker.replacement);
+      replacement = `<w:del w:id="${marker.id}" w:author="${escapedAuthor}" w:date="${now}"><w:r><w:delText>${escapedContent}</w:delText></w:r></w:del><w:ins w:id="${marker.id + 1000}" w:author="${escapedAuthor}" w:date="${now}"><w:r><w:t>${escapedReplacement}</w:t></w:r></w:ins>`;
+    }
 
-    zip.updateFile('word/document.xml', Buffer.from(documentXml, 'utf-8'));
-    zip.writeZip(outputPath);
+    documentXml = documentXml.replace(placeholder, replacement);
+  }
 
-    return { success: true, message: `Created ${outputPath} with track changes` };
-  } catch (err) {
-    return { success: false, message: err.message };
+  // Update document.xml
+  zip.updateFile('word/document.xml', Buffer.from(documentXml));
+
+  // Enable track revisions in settings.xml
+  const settingsEntry = zip.getEntry('word/settings.xml');
+  if (settingsEntry) {
+    let settingsXml = zip.readAsText(settingsEntry);
+    if (!settingsXml.includes('w:trackRevisions')) {
+      settingsXml = settingsXml.replace(
+        '</w:settings>',
+        '<w:trackRevisions/></w:settings>'
+      );
+      zip.updateFile('word/settings.xml', Buffer.from(settingsXml));
+    }
   }
+
+  // Write output
+  zip.writeZip(outputPath);
+
+  return { success: true, message: `Created ${outputPath} with track changes` };
 }
 
 /**
- * Build DOCX with track changes visible
- * This is the main entry point for the audit export feature
+ * Build a Word document with track changes from annotated markdown
  *
- * @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}>}
+ * @param {string} mdPath - Path to markdown file with CriticMarkup
+ * @param {string} docxPath - Output path for Word document
+ * @param {object} options - Options
+ * @param {string} options.author - Author name for track changes
+ * @returns {Promise<{success: boolean, message: string}>}
  */
-export async function buildWithTrackChanges(markdownPath, outputPath, options = {}) {
-  const { author = 'Reviewer' } = options;
+export async function buildWithTrackChanges(mdPath, docxPath, options = {}) {
+  const { author = 'Author' } = options;
 
-  if (!fs.existsSync(markdownPath)) {
-    return { success: false, message: `File not found: ${markdownPath}`, stats: null };
+  if (!fs.existsSync(mdPath)) {
+    return { success: false, message: `File not found: ${mdPath}` };
   }
 
-  const text = fs.readFileSync(markdownPath, 'utf-8');
-  const { text: preparedText, markers } = prepareForTrackChanges(text);
+  const content = fs.readFileSync(mdPath, 'utf-8');
 
-  // Assign author to markers that don't have one
-  for (const marker of markers) {
-    if (!marker.author || marker.author === 'Reviewer') {
-      marker.author = author;
+  // Prepare for track changes
+  const { text: prepared, markers } = prepareForTrackChanges(content, { author });
+
+  // If no annotations, just build normally
+  if (markers.length === 0) {
+    try {
+      execSync(`pandoc "${mdPath}" -o "${docxPath}"`, { encoding: 'utf-8' });
+      return { success: true, message: `Created ${docxPath}` };
+    } catch (err) {
+      return { success: false, message: err.message };
     }
   }
 
-  // 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');
+  // Write prepared content to temp file
+  const tempDir = path.dirname(mdPath);
+  const tempMd = path.join(tempDir, `.temp-${Date.now()}.md`);
+  const tempDocx = path.join(tempDir, `.temp-${Date.now()}.docx`);
 
   try {
-    execSync(`pandoc "${tempMd}" -o "${tempDocx}"`, { stdio: 'pipe' });
-  } catch (err) {
-    fs.unlinkSync(tempMd);
-    return { success: false, message: `Pandoc failed: ${err.message}`, stats: null };
-  }
+    fs.writeFileSync(tempMd, prepared, 'utf-8');
 
-  // Apply track changes
-  const result = await applyTrackChangesToDocx(tempDocx, markers, outputPath);
+    // Build with pandoc
+    execSync(`pandoc "${tempMd}" -o "${tempDocx}"`, { encoding: 'utf-8' });
 
-  // Cleanup
-  try {
+    // Apply track changes
+    const result = await applyTrackChangesToDocx(tempDocx, markers, docxPath);
+
+    // Clean up temp files
     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 };
+    return result;
+  } catch (err) {
+    // Clean up on error
+    if (fs.existsSync(tempMd)) fs.unlinkSync(tempMd);
+    if (fs.existsSync(tempDocx)) fs.unlinkSync(tempDocx);
+    return { success: false, message: err.message };
+  }
 }

package/lib/variables.js

@@ -0,0 +1,173 @@
+/**
+ * Template variable substitution for rev
+ *
+ * Supported variables:
+ *   {{date}}       - Current date (YYYY-MM-DD)
+ *   {{date:format}} - Custom date format (e.g., {{date:MMMM D, YYYY}})
+ *   {{version}}    - Version from rev.yaml
+ *   {{word_count}} - Total word count
+ *   {{author}}     - First author name
+ *   {{authors}}    - All authors (comma-separated)
+ *   {{title}}      - Document title
+ *   {{year}}       - Current year
+ */
+
+import * as fs from 'fs';
+
+/**
+ * Format date with simple pattern
+ * @param {Date} date
+ * @param {string} format - Pattern (YYYY, MM, DD, MMMM, MMM, D)
+ * @returns {string}
+ */
+function formatDate(date, format = 'YYYY-MM-DD') {
+  const months = [
+    'January', 'February', 'March', 'April', 'May', 'June',
+    'July', 'August', 'September', 'October', 'November', 'December'
+  ];
+  const monthsShort = [
+    'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun',
+    'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'
+  ];
+
+  const year = date.getFullYear();
+  const month = date.getMonth();
+  const day = date.getDate();
+
+  // Use placeholders to avoid replacement conflicts (e.g., D in December)
+  return format
+    .replace('YYYY', '\x00YEAR\x00')
+    .replace('MMMM', '\x00MONTHFULL\x00')
+    .replace('MMM', '\x00MONTHSHORT\x00')
+    .replace('MM', '\x00MONTHNUM\x00')
+    .replace('DD', '\x00DAYPAD\x00')
+    .replace(/\bD\b/, '\x00DAY\x00')
+    .replace('\x00YEAR\x00', year.toString())
+    .replace('\x00MONTHFULL\x00', months[month])
+    .replace('\x00MONTHSHORT\x00', monthsShort[month])
+    .replace('\x00MONTHNUM\x00', (month + 1).toString().padStart(2, '0'))
+    .replace('\x00DAYPAD\x00', day.toString().padStart(2, '0'))
+    .replace('\x00DAY\x00', day.toString());
+}
+
+/**
+ * Count words in text (excluding markdown syntax)
+ * @param {string} text
+ * @returns {number}
+ */
+function countWords(text) {
+  return text
+    .replace(/^---[\s\S]*?---/m, '') // Remove frontmatter
+    .replace(/!\[.*?\]\(.*?\)/g, '') // Remove images
+    .replace(/\[([^\]]+)\]\([^)]+\)/g, '$1') // Keep link text
+    .replace(/#+\s*/g, '') // Remove headers
+    .replace(/\*\*|__|[*_`]/g, '') // Remove formatting
+    .replace(/```[\s\S]*?```/g, '') // Remove code blocks
+    .replace(/\{[^}]+\}/g, '') // Remove annotations
+    .replace(/@\w+:\w+/g, '') // Remove refs
+    .replace(/@\w+/g, '') // Remove citations
+    .replace(/\|[^|]+\|/g, ' ') // Remove tables
+    .replace(/\n+/g, ' ')
+    .trim()
+    .split(/\s+/)
+    .filter(w => w.length > 0).length;
+}
+
+/**
+ * Get first author name from authors array
+ * @param {Array|string} authors
+ * @returns {string}
+ */
+function getFirstAuthor(authors) {
+  if (!authors || authors.length === 0) return '';
+
+  const first = Array.isArray(authors) ? authors[0] : authors;
+
+  if (typeof first === 'string') return first;
+  if (first.name) return first.name;
+
+  return '';
+}
+
+/**
+ * Get all author names
+ * @param {Array|string} authors
+ * @returns {string}
+ */
+function getAllAuthors(authors) {
+  if (!authors) return '';
+  if (typeof authors === 'string') return authors;
+
+  return authors
+    .map(a => typeof a === 'string' ? a : a.name)
+    .filter(Boolean)
+    .join(', ');
+}
+
+/**
+ * Process template variables in text
+ * @param {string} text - Text with {{variable}} placeholders
+ * @param {object} config - rev.yaml config
+ * @param {object} options - Additional options
+ * @param {string[]} options.sections - Section file contents for word count
+ * @returns {string} Text with variables replaced
+ */
+export function processVariables(text, config = {}, options = {}) {
+  const now = new Date();
+  let result = text;
+
+  // Calculate word count from sections if provided
+  let wordCount = 0;
+  if (options.sectionContents) {
+    for (const content of options.sectionContents) {
+      wordCount += countWords(content);
+    }
+  }
+
+  // {{date}} - Current date
+  result = result.replace(/\{\{date\}\}/g, formatDate(now));
+
+  // {{date:format}} - Custom date format
+  result = result.replace(/\{\{date:([^}]+)\}\}/g, (match, format) => {
+    return formatDate(now, format);
+  });
+
+  // {{year}} - Current year
+  result = result.replace(/\{\{year\}\}/g, now.getFullYear().toString());
+
+  // {{version}} - From config
+  result = result.replace(/\{\{version\}\}/g, config.version || '');
+
+  // {{title}} - Document title
+  result = result.replace(/\{\{title\}\}/g, config.title || '');
+
+  // {{author}} - First author
+  result = result.replace(/\{\{author\}\}/g, getFirstAuthor(config.authors));
+
+  // {{authors}} - All authors
+  result = result.replace(/\{\{authors\}\}/g, getAllAuthors(config.authors));
+
+  // {{word_count}} - Total word count
+  result = result.replace(/\{\{word_count\}\}/g, wordCount.toLocaleString());
+
+  return result;
+}
+
+/**
+ * Check if text contains any template variables
+ * @param {string} text
+ * @returns {boolean}
+ */
+export function hasVariables(text) {
+  return /\{\{[^}]+\}\}/.test(text);
+}
+
+/**
+ * List all variables found in text
+ * @param {string} text
+ * @returns {string[]}
+ */
+export function findVariables(text) {
+  const matches = text.match(/\{\{([^}]+)\}\}/g) || [];
+  return [...new Set(matches.map(m => m.slice(2, -2)))];
+}