docrev 0.8.1 → 0.8.5

package/lib/{response.js → response.ts}

@@ -6,14 +6,33 @@
 import * as fs from 'fs';
 import * as path from 'path';
 
+interface Reply {
+  author: string;
+  text: string;
+}
+
+interface CommentWithReplies {
+  author: string;
+  text: string;
+  replies: Reply[];
+  context: string;
+  file: string;
+  line: number;
+}
+
+interface ResponseOptions {
+  title?: string;
+  authorName?: string;
+  includeContext?: boolean;
+  includeLocation?: boolean;
+}
+
 /**
  * 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 = [];
+export function parseCommentsWithReplies(text: string, file: string = ''): CommentWithReplies[] {
+  const comments: CommentWithReplies[] = [];
   const lines = text.split('\n');
 
   // Pattern for comments: {>>Author: text<<}
@@ -21,6 +40,7 @@ export function parseCommentsWithReplies(text, file = '') {
 
   for (let lineNum = 0; lineNum < lines.length; lineNum++) {
     const line = lines[lineNum];
+    if (!line) continue;
     const matches = [...line.matchAll(commentPattern)];
 
     if (matches.length === 0) continue;
@@ -31,13 +51,14 @@ export function parseCommentsWithReplies(text, file = '') {
 
     // First match is the original comment, rest are replies
     const [first, ...rest] = matches;
+    if (!first || !first[1] || !first[2]) continue;
 
     comments.push({
       author: first[1].trim(),
       text: first[2].trim(),
       replies: rest.map(m => ({
-        author: m[1].trim(),
-        text: m[2].trim(),
+        author: m[1]?.trim() || '',
+        text: m[2]?.trim() || '',
       })),
       context,
       file,
@@ -50,18 +71,16 @@ export function parseCommentsWithReplies(text, file = '') {
 
 /**
  * Group comments by reviewer
- * @param {Array} comments
- * @returns {Map<string, Array>}
  */
-export function groupByReviewer(comments) {
-  const grouped = new Map();
+export function groupByReviewer(comments: CommentWithReplies[]): Map<string, CommentWithReplies[]> {
+  const grouped = new Map<string, CommentWithReplies[]>();
 
   for (const comment of comments) {
     const reviewer = comment.author;
     if (!grouped.has(reviewer)) {
       grouped.set(reviewer, []);
     }
-    grouped.get(reviewer).push(comment);
+    grouped.get(reviewer)!.push(comment);
   }
 
   return grouped;
@@ -69,11 +88,8 @@ export function groupByReviewer(comments) {
 
 /**
  * Generate response letter in Markdown format
- * @param {Array} comments - All comments from all files
- * @param {object} options
- * @returns {string}
  */
-export function generateResponseLetter(comments, options = {}) {
+export function generateResponseLetter(comments: CommentWithReplies[], options: ResponseOptions = {}): string {
   const {
     title = 'Response to Reviewers',
     authorName = 'Author',
@@ -81,7 +97,7 @@ export function generateResponseLetter(comments, options = {}) {
     includeLocation = true,
   } = options;
 
-  const lines = [];
+  const lines: string[] = [];
   lines.push(`# ${title}`);
   lines.push('');
   lines.push(`We thank the reviewers for their constructive feedback. Below we address each comment.`);
@@ -105,12 +121,13 @@ export function generateResponseLetter(comments, options = {}) {
     if (reviewer.toLowerCase() === authorName.toLowerCase()) continue;
     if (reviewer.toLowerCase() === 'claude') continue;
 
-    const reviewerComments = grouped.get(reviewer);
+    const reviewerComments = grouped.get(reviewer)!;
     lines.push(`## ${reviewer}`);
     lines.push('');
 
     for (let i = 0; i < reviewerComments.length; i++) {
       const c = reviewerComments[i];
+      if (!c) continue;
 
       lines.push(`### Comment ${i + 1}`);
       if (includeLocation) {
@@ -164,11 +181,9 @@ export function generateResponseLetter(comments, options = {}) {
 
 /**
  * Collect comments from multiple files
- * @param {string[]} files - Array of file paths
- * @returns {Array}
  */
-export function collectComments(files) {
-  const allComments = [];
+export function collectComments(files: string[]): CommentWithReplies[] {
+  const allComments: CommentWithReplies[] = [];
 
   for (const file of files) {
     if (!fs.existsSync(file)) continue;

package/lib/{review.js → review.ts}

@@ -4,45 +4,65 @@
 
 import * as readline from 'readline';
 import chalk from 'chalk';
+import type { Annotation, Comment } from './types.js';
 import { getTrackChanges, getComments, applyDecision } from './annotations.js';
 
+interface ReviewResult {
+  text: string;
+  accepted: number;
+  rejected: number;
+  skipped: number;
+}
+
+interface CommentReviewOptions {
+  author?: string;
+  addReply?: (text: string, comment: Comment, author: string, replyText: string) => string;
+  setCommentStatus?: (text: string, comment: Comment, resolved: boolean) => string;
+}
+
+interface CommentReviewResult {
+  text: string;
+  resolved: number;
+  replied: number;
+  skipped: number;
+}
+
 /**
  * Format an annotation for display
- * @param {object} annotation
- * @param {number} index
- * @param {number} total
- * @returns {string}
  */
-function formatAnnotation(annotation, index, total) {
+function formatAnnotation(annotation: Annotation, index: number, total: number): string {
   const header = chalk.dim(`─── Change ${index + 1}/${total} (line ${annotation.line}) ───`);
 
-  let action;
-  let display;
+  let action: string;
+  let display: string;
 
   switch (annotation.type) {
     case 'insert':
       action = chalk.green(`+ Insert: "${annotation.content}"`);
       display =
-        chalk.dim(annotation.before) +
+        chalk.dim(annotation.before || '') +
         chalk.green.bold(`[${annotation.content}]`) +
-        chalk.dim(annotation.after);
+        chalk.dim(annotation.after || '');
       break;
     case 'delete':
       action = chalk.red(`- Delete: "${annotation.content}"`);
       display =
-        chalk.dim(annotation.before) +
+        chalk.dim(annotation.before || '') +
         chalk.red.strikethrough(`[${annotation.content}]`) +
-        chalk.dim(annotation.after);
+        chalk.dim(annotation.after || '');
       break;
     case 'substitute':
       action = chalk.yellow(`~ Change: "${annotation.content}" → "${annotation.replacement}"`);
       display =
-        chalk.dim(annotation.before) +
+        chalk.dim(annotation.before || '') +
         chalk.red.strikethrough(`[${annotation.content}]`) +
         chalk.dim(' → ') +
         chalk.green.bold(`[${annotation.replacement}]`) +
-        chalk.dim(annotation.after);
+        chalk.dim(annotation.after || '');
       break;
+    default:
+      action = chalk.gray(`? Unknown: "${annotation.content}"`);
+      display = chalk.dim(annotation.before || '') + chalk.gray(`[${annotation.content}]`) + chalk.dim(annotation.after || '');
   }
 
   return `\n${header}\n\n  ${action}\n\n  ${display}\n`;
@@ -50,11 +70,8 @@ function formatAnnotation(annotation, index, total) {
 
 /**
  * Prompt for a single keypress
- * @param {string} prompt
- * @param {string[]} validKeys
- * @returns {Promise<string>}
  */
-function promptKey(prompt, validKeys) {
+function promptKey(prompt: string, validKeys: string[]): Promise<string> {
   return new Promise((resolve) => {
     const rl = readline.createInterface({
       input: process.stdin,
@@ -69,7 +86,7 @@ function promptKey(prompt, validKeys) {
 
     process.stdout.write(prompt);
 
-    process.stdin.once('data', (key) => {
+    process.stdin.once('data', (key: Buffer) => {
       const char = key.toString().toLowerCase();
 
       if (process.stdin.isTTY) {
@@ -95,10 +112,8 @@ function 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) {
+export async function interactiveReview(text: string): Promise<ReviewResult> {
   const changes = getTrackChanges(text);
   const comments = getComments(text);
 
@@ -119,6 +134,7 @@ export async function interactiveReview(text) {
 
   for (let i = 0; i < changes.length; i++) {
     const change = changes[i];
+    if (!change) continue;
     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: ');
@@ -132,7 +148,8 @@ export async function interactiveReview(text) {
       case 'A':
         // Accept all remaining
         for (let j = i; j < changes.length; j++) {
-          currentText = applyDecision(currentText, changes[j], true);
+          const ch = changes[j];
+          if (ch) currentText = applyDecision(currentText, ch, true);
         }
         accepted += changes.length - i;
         console.log(chalk.green(`\nAccepted all ${changes.length - i} remaining changes.`));
@@ -142,7 +159,8 @@ export async function interactiveReview(text) {
       case 'L':
         // Reject all remaining
         for (let j = i; j < changes.length; j++) {
-          currentText = applyDecision(currentText, changes[j], false);
+          const ch = changes[j];
+          if (ch) currentText = applyDecision(currentText, ch, false);
         }
         rejected += changes.length - i;
         console.log(chalk.red(`\nRejected all ${changes.length - i} remaining changes.`));
@@ -179,9 +197,8 @@ export async function interactiveReview(text) {
 
 /**
  * List all comments
- * @param {string} text
  */
-export function listComments(text) {
+export function listComments(text: string): void {
   const comments = getComments(text);
 
   if (comments.length === 0) {
@@ -193,15 +210,16 @@ export function listComments(text) {
 
   for (let i = 0; i < comments.length; i++) {
     const c = comments[i];
+    if (!c) continue;
     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.dim(`  Context: ...${(c.before || '').slice(-25)}`) +
         chalk.yellow('*') +
-        chalk.dim(`${c.after.slice(0, 25)}...`)
+        chalk.dim(`${(c.after || '').slice(0, 25)}...`)
     );
     console.log();
   }
@@ -209,12 +227,8 @@ export function listComments(text) {
 
 /**
  * Format a comment for interactive display
- * @param {object} comment
- * @param {number} index
- * @param {number} total
- * @returns {string}
  */
-function formatComment(comment, index, total) {
+function formatComment(comment: Comment, index: number, total: number): string {
   const statusIcon = comment.resolved ? chalk.green('✓') : chalk.yellow('○');
   const author = comment.author || 'Anonymous';
   const header = chalk.dim(`─── Comment ${index + 1}/${total} (line ${comment.line}) ───`);
@@ -227,16 +241,10 @@ function formatComment(comment, index, total) {
 
 /**
  * Run interactive comment review session
- * @param {string} text
- * @param {object} options
- * @param {string} options.author - Author name for replies
- * @param {Function} options.addReply - Function to add reply to comment
- * @param {Function} options.setCommentStatus - Function to set comment status
- * @returns {Promise<{text: string, resolved: number, replied: number, skipped: number}>}
  */
-export async function interactiveCommentReview(text, options = {}) {
+export async function interactiveCommentReview(text: string, options: CommentReviewOptions = {}): Promise<CommentReviewResult> {
   const { author = 'Author', addReply, setCommentStatus } = options;
-  const comments = getComments(text, { pendingOnly: true });
+  const comments = getComments(text, { pendingOnly: true }) as Comment[];
 
   if (comments.length === 0) {
     console.log(chalk.green('No pending comments found.'));
@@ -252,6 +260,7 @@ export async function interactiveCommentReview(text, options = {}) {
 
   for (let i = 0; i < comments.length; i++) {
     const comment = comments[i];
+    if (!comment) continue;
     console.log(formatComment(comment, i, comments.length));
 
     const prompt = chalk.dim('[r]eply [m]ark resolved [s]kip | resolve [A]ll [q]uit: ');
@@ -265,8 +274,9 @@ export async function interactiveCommentReview(text, options = {}) {
       case 'A':
         // Resolve all remaining
         for (let j = i; j < comments.length; j++) {
-          if (setCommentStatus) {
-            currentText = setCommentStatus(currentText, comments[j], true);
+          const c = comments[j];
+          if (setCommentStatus && c) {
+            currentText = setCommentStatus(currentText, c, true);
           }
         }
         resolved += comments.length - i;
@@ -288,7 +298,7 @@ export async function interactiveCommentReview(text, options = {}) {
           input: process.stdin,
           output: process.stdout,
         });
-        const replyText = await new Promise((resolve) => {
+        const replyText = await new Promise<string>((resolve) => {
           rl.question(chalk.cyan('  Reply: '), resolve);
         });
         rl.close();

package/lib/{schema.js → schema.ts}

@@ -2,10 +2,59 @@
  * JSON Schema validation for rev.yaml configuration
  */
 
+/**
+ * Validation error
+ */
+interface ValidationError {
+  path: string;
+  message: string;
+  value?: unknown;
+}
+
+/**
+ * Validation warning
+ */
+interface ValidationWarning {
+  path: string;
+  message: string;
+}
+
+/**
+ * Validation result
+ */
+interface ValidationResult {
+  valid: boolean;
+  errors: ValidationError[];
+  warnings: ValidationWarning[];
+}
+
+/**
+ * JSON Schema type
+ */
+interface Schema {
+  $schema?: string;
+  title?: string;
+  description?: string;
+  type?: string;
+  properties?: Record<string, Schema>;
+  required?: string[];
+  items?: Schema;
+  oneOf?: Schema[];
+  enum?: string[];
+  pattern?: string;
+  format?: string;
+  minimum?: number;
+  maximum?: number;
+  minItems?: number;
+  maxItems?: number;
+  additionalProperties?: boolean;
+  default?: unknown;
+}
+
 /**
  * JSON Schema for rev.yaml
  */
-export const revYamlSchema = {
+export const revYamlSchema: Schema = {
   $schema: 'http://json-schema.org/draft-07/schema#',
   title: 'rev.yaml configuration',
   description: 'Configuration file for docrev document workflow',
@@ -134,13 +183,9 @@ export const revYamlSchema = {
 
 /**
  * Validate a value against a simple schema
- * @param {*} value - Value to validate
- * @param {object} schema - JSON Schema
- * @param {string} path - Current path for error messages
- * @returns {object[]} Array of validation errors
  */
-function validateValue(value, schema, path = '') {
-  const errors = [];
+function validateValue(value: unknown, schema: Schema, path = ''): ValidationError[] {
+  const errors: ValidationError[] = [];
 
   // Handle oneOf
   if (schema.oneOf) {
@@ -228,23 +273,24 @@ function validateValue(value, schema, path = '') {
     }
     if (schema.items) {
       value.forEach((item, index) => {
-        errors.push(...validateValue(item, schema.items, `${path}[${index}]`));
+        errors.push(...validateValue(item, schema.items!, `${path}[${index}]`));
       });
     }
   }
 
   // Object validation
   if (schema.type === 'object' && typeof value === 'object' && value !== null) {
+    const obj = value as Record<string, unknown>;
     if (schema.properties) {
       for (const [key, propSchema] of Object.entries(schema.properties)) {
-        if (value[key] !== undefined) {
-          errors.push(...validateValue(value[key], propSchema, path ? `${path}.${key}` : key));
+        if (obj[key] !== undefined) {
+          errors.push(...validateValue(obj[key], propSchema, path ? `${path}.${key}` : key));
         }
       }
     }
     if (schema.required) {
       for (const key of schema.required) {
-        if (value[key] === undefined) {
+        if (obj[key] === undefined) {
           errors.push({
             path: path ? `${path}.${key}` : key,
             message: `Required property "${key}" is missing`,
@@ -260,29 +306,28 @@ function validateValue(value, schema, path = '') {
 
 /**
  * Validate rev.yaml configuration
- * @param {object} config - Parsed configuration object
- * @returns {{ valid: boolean, errors: object[], warnings: object[] }}
  */
-export function validateConfig(config) {
+export function validateConfig(config: Record<string, unknown>): ValidationResult {
   const errors = validateValue(config, revYamlSchema);
-  const warnings = [];
+  const warnings: ValidationWarning[] = [];
 
   // Additional semantic validations
-  if (config.sections && config.sections.length === 0) {
+  if (config.sections && Array.isArray(config.sections) && config.sections.length === 0) {
     warnings.push({
       path: 'sections',
       message: 'No sections specified - build will auto-detect .md files',
     });
   }
 
-  if (config.bibliography && !config.bibliography.endsWith('.bib')) {
+  if (config.bibliography && typeof config.bibliography === 'string' && !config.bibliography.endsWith('.bib')) {
     warnings.push({
       path: 'bibliography',
       message: 'Bibliography file should have .bib extension',
     });
   }
 
-  if (config.pdf?.linestretch && (config.pdf.linestretch < 1 || config.pdf.linestretch > 3)) {
+  const pdf = config.pdf as { linestretch?: number } | undefined;
+  if (pdf?.linestretch && (pdf.linestretch < 1 || pdf.linestretch > 3)) {
     warnings.push({
       path: 'pdf.linestretch',
       message: 'Line stretch values outside 1-3 range may produce unexpected results',
@@ -290,7 +335,7 @@ export function validateConfig(config) {
   }
 
   // Check for common typos
-  const knownKeys = Object.keys(revYamlSchema.properties);
+  const knownKeys = Object.keys(revYamlSchema.properties || {});
   for (const key of Object.keys(config)) {
     if (key.startsWith('_')) continue; // Internal keys
     if (!knownKeys.includes(key)) {
@@ -316,12 +361,12 @@ export function validateConfig(config) {
 
 /**
  * Format validation results for display
- * @param {{ valid: boolean, errors: object[], warnings: object[] }} result
- * @param {object} chalk - Chalk instance for coloring
- * @returns {string}
  */
-export function formatValidationResult(result, chalk) {
-  const lines = [];
+export function formatValidationResult(
+  result: ValidationResult,
+  chalk: { red: (s: string) => string; yellow: (s: string) => string; green: (s: string) => string }
+): string {
+  const lines: string[] = [];
 
   if (result.errors.length > 0) {
     lines.push(chalk.red('Configuration errors:'));
@@ -348,7 +393,7 @@ export function formatValidationResult(result, chalk) {
 /**
  * Levenshtein distance for typo detection
  */
-function levenshtein(a, b) {
+function levenshtein(a: string, b: string): number {
   const matrix = Array(b.length + 1)
     .fill(null)
     .map(() => Array(a.length + 1).fill(null));