docrev 0.9.5 → 0.9.7

package/lib/commands/verify-anchors.ts

@@ -0,0 +1,261 @@
+/**
+ * VERIFY-ANCHORS command: report drift between Word comment anchors
+ * and the current markdown.
+ *
+ * Useful when prose has been revised between sending the docx out for
+ * review and receiving it back. Each comment is classified by how well
+ * its anchor still matches the current section prose:
+ *
+ *   clean        – exact or whitespace-normalized hit
+ *   drift        – anchor only matches via stripped/partial fallbacks
+ *   context-only – anchor text is gone, only surrounding context survives
+ *   ambiguous    – multiple matches, can't pick one without context
+ *   unmatched    – nothing maps; user must place the comment manually
+ */
+
+import {
+  chalk,
+  fs,
+  path,
+  fmt,
+  loadConfig,
+  jsonMode,
+  jsonOutput,
+} from './context.js';
+import type { Command } from 'commander';
+import { findAnchorInText, classifyStrategy, type AnchorMatchQuality } from '../anchor-match.js';
+import type { CommentAnchorData } from '../word-extraction.js';
+import { computeSectionBoundaries } from './section-boundaries.js';
+
+interface VerifyOptions {
+  config: string;
+  dir: string;
+  json?: boolean;
+}
+
+interface CommentReport {
+  id: string;
+  author: string;
+  text: string;
+  section: string | null;
+  quality: AnchorMatchQuality | 'ambiguous';
+  strategy: string;
+  anchor: string;
+  occurrences: number;
+}
+
+export function register(program: Command): void {
+  program
+    .command('verify-anchors')
+    .description('Report drift between Word comment anchors and current markdown')
+    .argument('<file>', 'Word document with reviewer comments (.docx)')
+    .option('-c, --config <file>', 'Sections config file', 'sections.yaml')
+    .option('-d, --dir <directory>', 'Directory with section files', '.')
+    .option('--json', 'Output JSON report (for scripting)')
+    .action(async (docxPath: string, options: VerifyOptions) => {
+      if (!fs.existsSync(docxPath)) {
+        console.error(fmt.status('error', `File not found: ${docxPath}`));
+        process.exit(1);
+      }
+
+      const configPath = path.resolve(options.dir, options.config);
+      if (!fs.existsSync(configPath)) {
+        console.error(fmt.status('error', `Config not found: ${configPath}`));
+        console.error(chalk.dim('  Run "rev init" first to generate sections.yaml'));
+        process.exit(1);
+      }
+
+      const config = loadConfig(configPath);
+      const { extractWordComments, extractCommentAnchors, extractHeadings } = await import('../import.js');
+
+      let comments;
+      let anchors;
+      let headings;
+      try {
+        comments = await extractWordComments(docxPath);
+        const result = await extractCommentAnchors(docxPath);
+        anchors = result.anchors;
+        headings = await extractHeadings(docxPath);
+      } catch (err) {
+        const error = err as Error;
+        console.error(fmt.status('error', `Failed to read ${path.basename(docxPath)}: ${error.message}`));
+        if (process.env.DEBUG) console.error(error.stack);
+        process.exit(1);
+      }
+
+      if (comments.length === 0) {
+        console.log(fmt.status('info', 'No comments found in document.'));
+        return;
+      }
+
+      const boundaries = computeSectionBoundaries(config.sections, headings);
+
+      // Cache section markdown contents on first read
+      const sectionCache = new Map<string, string>();
+      function loadSection(file: string): string | null {
+        if (sectionCache.has(file)) return sectionCache.get(file)!;
+        const sectionPath = path.join(options.dir, file);
+        if (!fs.existsSync(sectionPath)) return null;
+        const content = fs.readFileSync(sectionPath, 'utf-8');
+        sectionCache.set(file, content);
+        return content;
+      }
+
+      const firstBoundaryStart = boundaries.length > 0 ? boundaries[0].start : 0;
+      const reports: CommentReport[] = [];
+
+      for (const c of comments) {
+        const anchor: CommentAnchorData | undefined = anchors.get(c.id);
+        const anchorText = anchor?.anchor || '';
+        if (!anchor) {
+          reports.push({
+            id: c.id,
+            author: c.author,
+            text: c.text,
+            section: null,
+            quality: 'unmatched',
+            strategy: 'no-anchor',
+            anchor: '',
+            occurrences: 0,
+          });
+          continue;
+        }
+
+        // Determine which section file this comment lives in
+        let sectionFile: string | null = null;
+        for (const b of boundaries) {
+          if (anchor.docPosition >= b.start && anchor.docPosition < b.end) {
+            sectionFile = b.file;
+            break;
+          }
+        }
+        if (!sectionFile && boundaries.length > 0 && anchor.docPosition < firstBoundaryStart) {
+          sectionFile = boundaries[0].file;
+        }
+
+        if (!sectionFile) {
+          reports.push({
+            id: c.id,
+            author: c.author,
+            text: c.text,
+            section: null,
+            quality: 'unmatched',
+            strategy: 'no-section',
+            anchor: anchorText,
+            occurrences: 0,
+          });
+          continue;
+        }
+
+        const md = loadSection(sectionFile);
+        if (md === null) {
+          reports.push({
+            id: c.id,
+            author: c.author,
+            text: c.text,
+            section: sectionFile,
+            quality: 'unmatched',
+            strategy: 'missing-file',
+            anchor: anchorText,
+            occurrences: 0,
+          });
+          continue;
+        }
+
+        const search = findAnchorInText(anchor.anchor, md, anchor.before, anchor.after);
+        let quality: AnchorMatchQuality | 'ambiguous' = classifyStrategy(search.strategy, search.occurrences.length);
+        if (quality === 'clean' && search.occurrences.length > 1) {
+          quality = 'ambiguous';
+        }
+
+        reports.push({
+          id: c.id,
+          author: c.author,
+          text: c.text,
+          section: sectionFile,
+          quality,
+          strategy: search.strategy,
+          anchor: anchorText,
+          occurrences: search.occurrences.length,
+        });
+      }
+
+      if (options.json || jsonMode) {
+        jsonOutput({
+          file: docxPath,
+          totalComments: comments.length,
+          summary: tally(reports),
+          comments: reports,
+        });
+        return;
+      }
+
+      printReport(docxPath, reports);
+    });
+}
+
+function tally(reports: CommentReport[]): Record<string, number> {
+  const out: Record<string, number> = { clean: 0, drift: 0, 'context-only': 0, ambiguous: 0, unmatched: 0 };
+  for (const r of reports) out[r.quality] = (out[r.quality] || 0) + 1;
+  return out;
+}
+
+function printReport(docxPath: string, reports: CommentReport[]): void {
+  console.log(fmt.header(`Anchor Verification: ${path.basename(docxPath)}`));
+  console.log();
+
+  const totals = tally(reports);
+  const summaryLines: string[] = [];
+  summaryLines.push(`${chalk.green(totals.clean)} clean (anchor still matches)`);
+  if (totals.drift) summaryLines.push(`${chalk.cyan(totals.drift)} drifted (matched via fallback strategies)`);
+  if (totals['context-only']) summaryLines.push(`${chalk.yellow(totals['context-only'])} context-only (anchor text gone, neighbors survive)`);
+  if (totals.ambiguous) summaryLines.push(`${chalk.magenta(totals.ambiguous)} ambiguous (multiple candidate positions)`);
+  if (totals.unmatched) summaryLines.push(`${chalk.red(totals.unmatched)} unmatched (manual placement needed)`);
+  console.log(fmt.box(summaryLines.join('\n'), { title: 'Summary', padding: 0 }));
+  console.log();
+
+  // Per-comment table for everything that isn't a clean direct hit
+  const problems = reports.filter(r => r.quality !== 'clean');
+  if (problems.length === 0) {
+    console.log(fmt.status('success', 'All comment anchors match the current markdown.'));
+    return;
+  }
+
+  const rows = problems.map(r => [
+    chalk.dim(`#${r.id}`),
+    qualityColor(r.quality),
+    r.section ? chalk.bold(r.section) : chalk.dim('—'),
+    chalk.dim(r.strategy),
+    truncate(r.anchor, 35),
+    truncate(r.text, 35),
+  ]);
+
+  console.log(fmt.table(
+    ['ID', 'Quality', 'Section', 'Strategy', 'Anchor (Word)', 'Comment'],
+    rows,
+    { align: ['right', 'left', 'left', 'left', 'left', 'left'] },
+  ));
+
+  if (totals.unmatched > 0 || totals.ambiguous > 0) {
+    console.log();
+    console.log(chalk.dim('Comments flagged "unmatched" or "ambiguous" need manual placement.'));
+    console.log(chalk.dim('Run "rev sync --no-overwrite" to import the matched ones without touching prose.'));
+  }
+}
+
+function qualityColor(q: string): string {
+  switch (q) {
+    case 'clean': return chalk.green('clean');
+    case 'drift': return chalk.cyan('drift');
+    case 'context-only': return chalk.yellow('context');
+    case 'ambiguous': return chalk.magenta('ambiguous');
+    case 'unmatched': return chalk.red('unmatched');
+    default: return q;
+  }
+}
+
+function truncate(s: string, max: number): string {
+  if (!s) return chalk.dim('—');
+  const flat = s.replace(/\s+/g, ' ').trim();
+  return flat.length > max ? flat.slice(0, max - 1) + '…' : flat;
+}

package/lib/commands/word-tools.ts

@@ -0,0 +1,340 @@
+/**
+ * Word document tool commands: annotate, apply, comment
+ *
+ * Commands for working with Word documents directly (comments, track changes).
+ */
+
+import type { Command } from 'commander';
+import {
+  chalk,
+  fs,
+  path,
+  fmt,
+  getUserName,
+  parseAnnotations,
+} from './context.js';
+
+// Options interfaces
+interface AnnotateOptions {
+  message?: string;
+  search?: string;
+  author?: string;
+}
+
+interface ApplyOptions {
+  author?: string;
+}
+
+interface CommentOptions {
+  author?: string;
+}
+
+/**
+ * Register word-tools commands with the program
+ */
+export function register(program: Command): void {
+  // ==========================================================================
+  // ANNOTATE command - Add comments to Word document
+  // ==========================================================================
+
+  program
+    .command('annotate')
+    .description('Add comment to Word document')
+    .argument('<docx>', 'Word document')
+    .option('-m, --message <text>', 'Comment text')
+    .option('-s, --search <text>', 'Text to attach comment to')
+    .option('-a, --author <name>', 'Comment author')
+    .action(async (docxPath: string, options: AnnotateOptions) => {
+      if (!fs.existsSync(docxPath)) {
+        console.error(chalk.red(`File not found: ${docxPath}`));
+        process.exit(1);
+      }
+
+      if (!options.message) {
+        console.error(chalk.red('Comment message required (-m)'));
+        process.exit(1);
+      }
+
+      const { default: AdmZip } = await import('adm-zip');
+      const zip = new AdmZip(docxPath);
+
+      // Read document.xml
+      const docEntry = zip.getEntry('word/document.xml');
+      if (!docEntry) {
+        console.error(chalk.red('Invalid Word document'));
+        process.exit(1);
+      }
+
+      let docXml = zip.readAsText(docEntry);
+
+      // Read or create comments.xml
+      let commentsEntry = zip.getEntry('word/comments.xml');
+      let commentsXml: string;
+      let nextCommentId = 1;
+
+      if (commentsEntry) {
+        commentsXml = zip.readAsText(commentsEntry);
+        const idMatches = commentsXml.match(/w:id="(\d+)"/g) || [];
+        for (const m of idMatches) {
+          const id = parseInt(m.match(/\d+/)![0]);
+          if (id >= nextCommentId) nextCommentId = id + 1;
+        }
+      } else {
+        commentsXml = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<w:comments xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main">
+</w:comments>`;
+      }
+
+      const author = options.author || getUserName() || 'Claude';
+      const date = new Date().toISOString();
+      const commentId = nextCommentId;
+
+      // Add comment to comments.xml
+      const newComment = `<w:comment w:id="${commentId}" w:author="${author}" w:date="${date}">
+  <w:p><w:r><w:t>${options.message}</w:t></w:r></w:p>
+</w:comment>`;
+
+      commentsXml = commentsXml.replace('</w:comments>', `${newComment}\n</w:comments>`);
+
+      // Find text and add comment markers
+      if (options.search) {
+        const searchText = options.search;
+        const textPattern = new RegExp(`(<w:t[^>]*>)([^<]*${searchText.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}[^<]*)(<\/w:t>)`, 'i');
+
+        if (textPattern.test(docXml)) {
+          docXml = docXml.replace(textPattern, (_match, start, text, end) => {
+            return `<w:commentRangeStart w:id="${commentId}"/>${start}${text}${end}<w:commentRangeEnd w:id="${commentId}"/><w:r><w:commentReference w:id="${commentId}"/></w:r>`;
+          });
+        } else {
+          console.log(chalk.yellow(`Text "${searchText}" not found in document. Comment added without anchor.`));
+        }
+      }
+
+      // Update zip
+      zip.updateFile('word/document.xml', Buffer.from(docXml));
+
+      if (commentsEntry) {
+        zip.updateFile('word/comments.xml', Buffer.from(commentsXml));
+      } else {
+        zip.addFile('word/comments.xml', Buffer.from(commentsXml));
+
+        // Update [Content_Types].xml
+        const ctEntry = zip.getEntry('[Content_Types].xml');
+        if (ctEntry) {
+          let ctXml = zip.readAsText(ctEntry);
+          if (!ctXml.includes('comments.xml')) {
+            ctXml = ctXml.replace('</Types>',
+              '<Override PartName="/word/comments.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.comments+xml"/>\n</Types>');
+            zip.updateFile('[Content_Types].xml', Buffer.from(ctXml));
+          }
+        }
+
+        // Update document.xml.rels
+        const relsEntry = zip.getEntry('word/_rels/document.xml.rels');
+        if (relsEntry) {
+          let relsXml = zip.readAsText(relsEntry);
+          if (!relsXml.includes('comments.xml')) {
+            const newRelId = `rId${Date.now()}`;
+            relsXml = relsXml.replace('</Relationships>',
+              `<Relationship Id="${newRelId}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/comments" Target="comments.xml"/>\n</Relationships>`);
+            zip.updateFile('word/_rels/document.xml.rels', Buffer.from(relsXml));
+          }
+        }
+      }
+
+      // Write back
+      zip.writeZip(docxPath);
+      console.log(fmt.status('success', `Added comment to ${docxPath}`));
+    });
+
+  // ==========================================================================
+  // APPLY command - Apply MD annotations as Word track changes
+  // ==========================================================================
+
+  program
+    .command('apply')
+    .description('Apply markdown annotations to Word document as track changes')
+    .argument('<md>', 'Markdown file with annotations')
+    .argument('<docx>', 'Output Word document')
+    .option('-a, --author <name>', 'Author name for track changes')
+    .action(async (mdPath: string, docxPath: string, options: ApplyOptions) => {
+      if (!fs.existsSync(mdPath)) {
+        console.error(chalk.red(`File not found: ${mdPath}`));
+        process.exit(1);
+      }
+
+      const mdContent = fs.readFileSync(mdPath, 'utf-8');
+      const annotations = parseAnnotations(mdContent);
+
+      if (annotations.length === 0) {
+        console.log(chalk.yellow('No annotations found in markdown file'));
+      }
+
+      const author = options.author || getUserName() || 'Author';
+
+      // Build document with track changes
+      const { buildWithTrackChanges } = await import('../trackchanges.js');
+
+      try {
+        const result = await buildWithTrackChanges(mdPath, docxPath, { author });
+
+        if (result.success) {
+          console.log(fmt.status('success', result.message));
+          console.log(chalk.dim(`  ${annotations.length} annotations applied as track changes`));
+        } else {
+          console.error(chalk.red(result.message));
+          process.exit(1);
+        }
+      } catch (err) {
+        console.error(chalk.red(`Error: ${(err as Error).message}`));
+        process.exit(1);
+      }
+    });
+
+  // ==========================================================================
+  // COMMENT command - Interactive comment addition to DOCX
+  // ==========================================================================
+
+  program
+    .command('comment')
+    .description('Add comments to Word document interactively')
+    .argument('<docx>', 'Word document')
+    .option('-a, --author <name>', 'Comment author')
+    .action(async (docxPath: string, options: CommentOptions) => {
+      if (!fs.existsSync(docxPath)) {
+        console.error(chalk.red(`File not found: ${docxPath}`));
+        process.exit(1);
+      }
+
+      const { default: AdmZip } = await import('adm-zip');
+      const readline = await import('readline');
+      const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+      });
+
+      const ask = (prompt: string): Promise<string> => new Promise((resolve) => rl.question(prompt, resolve));
+
+      const author = options.author || getUserName() || 'Reviewer';
+
+      console.log(fmt.header('Interactive Comment Mode'));
+      console.log(chalk.dim(`  Document: ${docxPath}`));
+      console.log(chalk.dim(`  Author: ${author}`));
+      console.log(chalk.dim('  Type your comment, then the text to attach it to.'));
+      console.log(chalk.dim('  Enter empty comment to quit.\n'));
+
+      let commentsAdded = 0;
+
+      while (true) {
+        const message = await ask(chalk.cyan('Comment: '));
+
+        if (!message.trim()) {
+          break;
+        }
+
+        const searchText = await ask(chalk.cyan('Attach to text: '));
+
+        // Load document fresh each time
+        const zip = new AdmZip(docxPath);
+        const docEntry = zip.getEntry('word/document.xml');
+
+        if (!docEntry) {
+          console.error(chalk.red('Invalid Word document'));
+          rl.close();
+          process.exit(1);
+        }
+
+        let docXml = zip.readAsText(docEntry);
+
+        // Read or create comments.xml
+        let commentsEntry = zip.getEntry('word/comments.xml');
+        let commentsXml: string;
+        let nextCommentId = 1;
+
+        if (commentsEntry) {
+          commentsXml = zip.readAsText(commentsEntry);
+          const idMatches = commentsXml.match(/w:id="(\d+)"/g) || [];
+          for (const m of idMatches) {
+            const id = parseInt(m.match(/\d+/)![0]);
+            if (id >= nextCommentId) nextCommentId = id + 1;
+          }
+        } else {
+          commentsXml = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<w:comments xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main">
+</w:comments>`;
+        }
+
+        const date = new Date().toISOString();
+        const commentId = nextCommentId;
+
+        // Add comment to comments.xml
+        const newComment = `<w:comment w:id="${commentId}" w:author="${author}" w:date="${date}">
+  <w:p><w:r><w:t>${message}</w:t></w:r></w:p>
+</w:comment>`;
+
+        commentsXml = commentsXml.replace('</w:comments>', `${newComment}\n</w:comments>`);
+
+        // Find text and add comment markers
+        if (searchText.trim()) {
+          const escapedSearch = searchText.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+          const textPattern = new RegExp(`(<w:t[^>]*>)([^<]*${escapedSearch}[^<]*)(<\/w:t>)`, 'i');
+
+          if (textPattern.test(docXml)) {
+            docXml = docXml.replace(textPattern, (_match, start, text, end) => {
+              return `<w:commentRangeStart w:id="${commentId}"/>${start}${text}${end}<w:commentRangeEnd w:id="${commentId}"/><w:r><w:commentReference w:id="${commentId}"/></w:r>`;
+            });
+            console.log(chalk.green(`  ✓ Comment added at "${searchText}"`));
+          } else {
+            console.log(chalk.yellow(`  Text not found. Comment added without anchor.`));
+          }
+        } else {
+          console.log(chalk.dim(`  Comment added without anchor.`));
+        }
+
+        // Update zip
+        zip.updateFile('word/document.xml', Buffer.from(docXml));
+
+        if (commentsEntry) {
+          zip.updateFile('word/comments.xml', Buffer.from(commentsXml));
+        } else {
+          zip.addFile('word/comments.xml', Buffer.from(commentsXml));
+
+          // Update [Content_Types].xml
+          const ctEntry = zip.getEntry('[Content_Types].xml');
+          if (ctEntry) {
+            let ctXml = zip.readAsText(ctEntry);
+            if (!ctXml.includes('comments.xml')) {
+              ctXml = ctXml.replace('</Types>',
+                '<Override PartName="/word/comments.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.comments+xml"/>\n</Types>');
+              zip.updateFile('[Content_Types].xml', Buffer.from(ctXml));
+            }
+          }
+
+          // Update document.xml.rels
+          const relsEntry = zip.getEntry('word/_rels/document.xml.rels');
+          if (relsEntry) {
+            let relsXml = zip.readAsText(relsEntry);
+            if (!relsXml.includes('comments.xml')) {
+              const newRelId = `rId${Date.now()}`;
+              relsXml = relsXml.replace('</Relationships>',
+                `<Relationship Id="${newRelId}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/comments" Target="comments.xml"/>\n</Relationships>`);
+              zip.updateFile('word/_rels/document.xml.rels', Buffer.from(relsXml));
+            }
+          }
+        }
+
+        zip.writeZip(docxPath);
+        commentsAdded++;
+        console.log();
+      }
+
+      rl.close();
+      console.log();
+
+      if (commentsAdded > 0) {
+        console.log(fmt.status('success', `Added ${commentsAdded} comment(s) to ${docxPath}`));
+      } else {
+        console.log(chalk.dim('No comments added.'));
+      }
+    });
+}