docrev 0.2.0

package/lib/response.js

@@ -0,0 +1,182 @@
+/**
+ * Response letter generator
+ * Extract comments and replies from markdown files for journal resubmission
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+
+/**
+ * Parse a comment with potential replies
+ * Format: {>>Author: comment<<} {>>Reply Author: reply<<}
+ * @param {string} text
+ * @returns {Array<{author: string, text: string, replies: Array, context: string, file: string, line: number}>}
+ */
+export function parseCommentsWithReplies(text, file = '') {
+  const comments = [];
+  const lines = text.split('\n');
+
+  // Pattern for comments: {>>Author: text<<}
+  const commentPattern = /\{>>([^:]+):\s*([^<]+)<<\}/g;
+
+  for (let lineNum = 0; lineNum < lines.length; lineNum++) {
+    const line = lines[lineNum];
+    const matches = [...line.matchAll(commentPattern)];
+
+    if (matches.length === 0) continue;
+
+    // Get context (surrounding text without comments)
+    const contextLine = line.replace(/\{>>[^<]+<<\}/g, '').trim();
+    const context = contextLine.slice(0, 100) + (contextLine.length > 100 ? '...' : '');
+
+    // First match is the original comment, rest are replies
+    const [first, ...rest] = matches;
+
+    comments.push({
+      author: first[1].trim(),
+      text: first[2].trim(),
+      replies: rest.map(m => ({
+        author: m[1].trim(),
+        text: m[2].trim(),
+      })),
+      context,
+      file,
+      line: lineNum + 1,
+    });
+  }
+
+  return comments;
+}
+
+/**
+ * Group comments by reviewer
+ * @param {Array} comments
+ * @returns {Map<string, Array>}
+ */
+export function groupByReviewer(comments) {
+  const grouped = new Map();
+
+  for (const comment of comments) {
+    const reviewer = comment.author;
+    if (!grouped.has(reviewer)) {
+      grouped.set(reviewer, []);
+    }
+    grouped.get(reviewer).push(comment);
+  }
+
+  return grouped;
+}
+
+/**
+ * Generate response letter in Markdown format
+ * @param {Array} comments - All comments from all files
+ * @param {object} options
+ * @returns {string}
+ */
+export function generateResponseLetter(comments, options = {}) {
+  const {
+    title = 'Response to Reviewers',
+    authorName = 'Author',
+    includeContext = true,
+    includeLocation = true,
+  } = options;
+
+  const lines = [];
+  lines.push(`# ${title}`);
+  lines.push('');
+  lines.push(`We thank the reviewers for their constructive feedback. Below we address each comment.`);
+  lines.push('');
+
+  // Group by reviewer
+  const grouped = groupByReviewer(comments);
+
+  // Sort reviewers (put known reviewer names first, then others)
+  const reviewers = [...grouped.keys()].sort((a, b) => {
+    // "Reviewer" names first, then alphabetical
+    const aIsReviewer = a.toLowerCase().includes('reviewer');
+    const bIsReviewer = b.toLowerCase().includes('reviewer');
+    if (aIsReviewer && !bIsReviewer) return -1;
+    if (!aIsReviewer && bIsReviewer) return 1;
+    return a.localeCompare(b);
+  });
+
+  for (const reviewer of reviewers) {
+    // Skip if this is the author's own comments (replies)
+    if (reviewer.toLowerCase() === authorName.toLowerCase()) continue;
+    if (reviewer.toLowerCase() === 'claude') continue;
+
+    const reviewerComments = grouped.get(reviewer);
+    lines.push(`## ${reviewer}`);
+    lines.push('');
+
+    for (let i = 0; i < reviewerComments.length; i++) {
+      const c = reviewerComments[i];
+
+      lines.push(`### Comment ${i + 1}`);
+      if (includeLocation) {
+        lines.push(`*${c.file}:${c.line}*`);
+      }
+      lines.push('');
+
+      // Original comment
+      lines.push(`> **${c.author}:** ${c.text}`);
+      lines.push('');
+
+      // Context if available
+      if (includeContext && c.context) {
+        lines.push(`*Context:* "${c.context}"`);
+        lines.push('');
+      }
+
+      // Replies
+      if (c.replies.length > 0) {
+        lines.push('**Response:**');
+        lines.push('');
+        for (const reply of c.replies) {
+          lines.push(`${reply.text}`);
+        }
+      } else {
+        lines.push('**Response:**');
+        lines.push('');
+        lines.push('*[TODO: Add response]*');
+      }
+      lines.push('');
+      lines.push('---');
+      lines.push('');
+    }
+  }
+
+  // Summary stats
+  const totalComments = comments.filter(c =>
+    !c.author.toLowerCase().includes('claude') &&
+    c.author.toLowerCase() !== authorName.toLowerCase()
+  ).length;
+  const answered = comments.filter(c => c.replies.length > 0).length;
+
+  lines.push('## Summary');
+  lines.push('');
+  lines.push(`- Total comments: ${totalComments}`);
+  lines.push(`- Addressed: ${answered}`);
+  lines.push(`- Pending: ${totalComments - answered}`);
+
+  return lines.join('\n');
+}
+
+/**
+ * Collect comments from multiple files
+ * @param {string[]} files - Array of file paths
+ * @returns {Array}
+ */
+export function collectComments(files) {
+  const allComments = [];
+
+  for (const file of files) {
+    if (!fs.existsSync(file)) continue;
+
+    const text = fs.readFileSync(file, 'utf-8');
+    const comments = parseCommentsWithReplies(text, path.basename(file));
+    allComments.push(...comments);
+  }
+
+  return allComments;
+}

package/lib/review.js

@@ -0,0 +1,208 @@
+/**
+ * Interactive review TUI for track changes
+ */
+
+import * as readline from 'readline';
+import chalk from 'chalk';
+import { getTrackChanges, getComments, applyDecision } from './annotations.js';
+
+/**
+ * Format an annotation for display
+ * @param {object} annotation
+ * @param {number} index
+ * @param {number} total
+ * @returns {string}
+ */
+function formatAnnotation(annotation, index, total) {
+  const header = chalk.dim(`─── Change ${index + 1}/${total} (line ${annotation.line}) ───`);
+
+  let action;
+  let display;
+
+  switch (annotation.type) {
+    case 'insert':
+      action = chalk.green(`+ Insert: "${annotation.content}"`);
+      display =
+        chalk.dim(annotation.before) +
+        chalk.green.bold(`[${annotation.content}]`) +
+        chalk.dim(annotation.after);
+      break;
+    case 'delete':
+      action = chalk.red(`- Delete: "${annotation.content}"`);
+      display =
+        chalk.dim(annotation.before) +
+        chalk.red.strikethrough(`[${annotation.content}]`) +
+        chalk.dim(annotation.after);
+      break;
+    case 'substitute':
+      action = chalk.yellow(`~ Change: "${annotation.content}" → "${annotation.replacement}"`);
+      display =
+        chalk.dim(annotation.before) +
+        chalk.red.strikethrough(`[${annotation.content}]`) +
+        chalk.dim(' → ') +
+        chalk.green.bold(`[${annotation.replacement}]`) +
+        chalk.dim(annotation.after);
+      break;
+  }
+
+  return `\n${header}\n\n  ${action}\n\n  ${display}\n`;
+}
+
+/**
+ * Prompt for a single keypress
+ * @param {string} prompt
+ * @param {string[]} validKeys
+ * @returns {Promise<string>}
+ */
+function promptKey(prompt, validKeys) {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+
+    // Enable raw mode for single keypress
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode(true);
+    }
+    process.stdin.resume();
+
+    process.stdout.write(prompt);
+
+    process.stdin.once('data', (key) => {
+      const char = key.toString().toLowerCase();
+
+      if (process.stdin.isTTY) {
+        process.stdin.setRawMode(false);
+      }
+      rl.close();
+
+      if (char === '\u0003') {
+        // Ctrl+C
+        process.exit(0);
+      }
+
+      if (validKeys.includes(char)) {
+        console.log(char);
+        resolve(char);
+      } else {
+        console.log();
+        resolve(promptKey(prompt, validKeys));
+      }
+    });
+  });
+}
+
+/**
+ * Run interactive review session
+ * @param {string} text
+ * @returns {Promise<{text: string, accepted: number, rejected: number, skipped: number}>}
+ */
+export async function interactiveReview(text) {
+  const changes = getTrackChanges(text);
+  const comments = getComments(text);
+
+  if (changes.length === 0) {
+    console.log(chalk.green('No track changes found.'));
+    if (comments.length > 0) {
+      console.log(chalk.yellow(`${comments.length} comment(s) remain in the document.`));
+    }
+    return { text, accepted: 0, rejected: 0, skipped: 0 };
+  }
+
+  console.log(chalk.cyan(`\nFound ${changes.length} track change(s)\n`));
+
+  let accepted = 0;
+  let rejected = 0;
+  let skipped = 0;
+  let currentText = text;
+
+  for (let i = 0; i < changes.length; i++) {
+    const change = changes[i];
+    console.log(formatAnnotation(change, i, changes.length));
+
+    const prompt = chalk.dim('[a]ccept [r]eject [s]kip | accept [A]ll reject a[L]l [q]uit: ');
+    const choice = await promptKey(prompt, ['a', 'r', 's', 'A', 'L', 'q']);
+
+    switch (choice) {
+      case 'q':
+        console.log(chalk.yellow('\nAborted. No changes saved.'));
+        return { text, accepted: 0, rejected: 0, skipped: changes.length };
+
+      case 'A':
+        // Accept all remaining
+        for (let j = i; j < changes.length; j++) {
+          currentText = applyDecision(currentText, changes[j], true);
+        }
+        accepted += changes.length - i;
+        console.log(chalk.green(`\nAccepted all ${changes.length - i} remaining changes.`));
+        i = changes.length; // Exit loop
+        break;
+
+      case 'L':
+        // Reject all remaining
+        for (let j = i; j < changes.length; j++) {
+          currentText = applyDecision(currentText, changes[j], false);
+        }
+        rejected += changes.length - i;
+        console.log(chalk.red(`\nRejected all ${changes.length - i} remaining changes.`));
+        i = changes.length; // Exit loop
+        break;
+
+      case 'a':
+        currentText = applyDecision(currentText, change, true);
+        accepted++;
+        break;
+
+      case 'r':
+        currentText = applyDecision(currentText, change, false);
+        rejected++;
+        break;
+
+      case 's':
+        skipped++;
+        break;
+    }
+  }
+
+  console.log(chalk.cyan('\n─── Summary ───'));
+  console.log(chalk.green(`Accepted: ${accepted}`));
+  console.log(chalk.red(`Rejected: ${rejected}`));
+  console.log(chalk.yellow(`Skipped: ${skipped}`));
+
+  if (comments.length > 0) {
+    console.log(chalk.blue(`\n${comments.length} comment(s) preserved.`));
+  }
+
+  return { text: currentText, accepted, rejected, skipped };
+}
+
+/**
+ * List all comments
+ * @param {string} text
+ */
+export function listComments(text) {
+  const comments = getComments(text);
+
+  if (comments.length === 0) {
+    console.log(chalk.green('No comments found.'));
+    return;
+  }
+
+  console.log(chalk.cyan(`\nFound ${comments.length} comment(s):\n`));
+
+  for (let i = 0; i < comments.length; i++) {
+    const c = comments[i];
+    const author = c.author || 'Anonymous';
+    const header = chalk.blue(`[${i + 1}] ${author}`) + chalk.dim(` (line ${c.line})`);
+
+    console.log(header);
+    console.log(`  ${c.content}`);
+    console.log(
+      chalk.dim(`  Context: ...${c.before.slice(-25)}`) +
+        chalk.yellow('*') +
+        chalk.dim(`${c.after.slice(0, 25)}...`)
+    );
+    console.log();
+  }
+}