docrev 0.10.1 → 0.11.0

package/lib/rate-limiter.ts

@@ -1,94 +1,127 @@
-/**
- * Rate Limiter - Prevents API abuse with exponential backoff
- */
-
-export interface RateLimiterOptions {
-  minDelay?: number;
-  maxDelay?: number;
-  maxRetries?: number;
-  backoffFactor?: number;
-}
-
-export class RateLimiter {
-  private minDelay: number;
-  private maxDelay: number;
-  private maxRetries: number;
-  private backoffFactor: number;
-  private lastRequestTime: number;
-  private currentDelay: number;
-  private consecutiveErrors: number;
-
-  constructor(options: RateLimiterOptions = {}) {
-    this.minDelay = options.minDelay || 100;      // Min delay between requests (ms)
-    this.maxDelay = options.maxDelay || 30000;    // Max delay after backoff (ms)
-    this.maxRetries = options.maxRetries || 3;    // Max retry attempts
-    this.backoffFactor = options.backoffFactor || 2;
-    this.lastRequestTime = 0;
-    this.currentDelay = this.minDelay;
-    this.consecutiveErrors = 0;
-  }
-
-  async wait(): Promise<void> {
-    const now = Date.now();
-    const elapsed = now - this.lastRequestTime;
-    if (elapsed < this.currentDelay) {
-      await new Promise(r => setTimeout(r, this.currentDelay - elapsed));
-    }
-    this.lastRequestTime = Date.now();
-  }
-
-  onSuccess(): void {
-    // Gradually reduce delay on success
-    this.consecutiveErrors = 0;
-    this.currentDelay = Math.max(this.minDelay, this.currentDelay / this.backoffFactor);
-  }
-
-  onError(statusCode: number): boolean {
-    this.consecutiveErrors++;
-    // Exponential backoff
-    if (statusCode === 429 || statusCode >= 500) {
-      this.currentDelay = Math.min(this.maxDelay, this.currentDelay * this.backoffFactor);
-    }
-    return this.consecutiveErrors <= this.maxRetries;
-  }
-
-  async fetchWithRetry(url: string, options: RequestInit = {}): Promise<Response> {
-    let lastError: Error | undefined;
-
-    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
-      await this.wait();
-
-      try {
-        const response = await fetch(url, options);
-
-        if (response.status === 429) {
-          // Rate limited - back off
-          const retryAfter = response.headers.get('Retry-After');
-          const delay = retryAfter ? parseInt(retryAfter, 10) * 1000 : this.currentDelay * 2;
-          this.currentDelay = Math.min(this.maxDelay, delay);
-          if (!this.onError(429)) break;
-          continue;
-        }
-
-        if (response.status >= 500 && attempt < this.maxRetries) {
-          // Server error - retry with backoff
-          if (!this.onError(response.status)) break;
-          continue;
-        }
-
-        this.onSuccess();
-        return response;
-      } catch (err) {
-        lastError = err as Error;
-        if (!this.onError(0)) break;
-      }
-    }
-
-    throw lastError || new Error('Max retries exceeded');
-  }
-}
-
-// Shared rate limiters for different APIs
-export const crossrefLimiter = new RateLimiter({ minDelay: 100, maxDelay: 10000 });
-export const dataciteLimiter = new RateLimiter({ minDelay: 100, maxDelay: 10000 });
-export const doiOrgLimiter = new RateLimiter({ minDelay: 200, maxDelay: 15000 });
+/**
+ * Rate Limiter - Prevents API abuse with exponential backoff
+ */
+
+export interface RateLimiterOptions {
+  minDelay?: number;
+  maxDelay?: number;
+  maxRetries?: number;
+  backoffFactor?: number;
+  /** Per-request timeout in ms; a stalled connection aborts instead of hanging. */
+  requestTimeout?: number;
+}
+
+/**
+ * Parse an HTTP `Retry-After` header, which may be a delay in seconds or an
+ * HTTP-date. Returns the delay in milliseconds, or null when unparseable.
+ */
+export function parseRetryAfter(value: string | null, now: number = Date.now()): number | null {
+  if (!value) return null;
+  const seconds = Number(value);
+  if (Number.isFinite(seconds)) return Math.max(0, seconds * 1000);
+  const date = Date.parse(value);
+  if (!Number.isNaN(date)) return Math.max(0, date - now);
+  return null;
+}
+
+export class RateLimiter {
+  private minDelay: number;
+  private maxDelay: number;
+  private maxRetries: number;
+  private backoffFactor: number;
+  private requestTimeout: number;
+  private lastRequestTime: number;
+  private currentDelay: number;
+  private consecutiveErrors: number;
+
+  constructor(options: RateLimiterOptions = {}) {
+    this.minDelay = options.minDelay || 100;      // Min delay between requests (ms)
+    this.maxDelay = options.maxDelay || 30000;    // Max delay after backoff (ms)
+    this.maxRetries = options.maxRetries || 3;    // Max retry attempts
+    this.backoffFactor = options.backoffFactor || 2;
+    this.requestTimeout = options.requestTimeout || 15000; // Abort a stalled request
+    this.lastRequestTime = 0;
+    this.currentDelay = this.minDelay;
+    this.consecutiveErrors = 0;
+  }
+
+  async wait(): Promise<void> {
+    const now = Date.now();
+    const elapsed = now - this.lastRequestTime;
+    if (elapsed < this.currentDelay) {
+      await new Promise(r => setTimeout(r, this.currentDelay - elapsed));
+    }
+    this.lastRequestTime = Date.now();
+  }
+
+  onSuccess(): void {
+    // Gradually reduce delay on success
+    this.consecutiveErrors = 0;
+    this.currentDelay = Math.max(this.minDelay, this.currentDelay / this.backoffFactor);
+  }
+
+  onError(statusCode: number): boolean {
+    this.consecutiveErrors++;
+    // Exponential backoff
+    if (statusCode === 429 || statusCode >= 500) {
+      this.currentDelay = Math.min(this.maxDelay, this.currentDelay * this.backoffFactor);
+    }
+    return this.consecutiveErrors <= this.maxRetries;
+  }
+
+  async fetchWithRetry(url: string, options: RequestInit = {}): Promise<Response> {
+    let lastError: Error | undefined;
+    const callerSignal = options.signal ?? undefined;
+
+    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+      await this.wait();
+
+      // Bound each attempt so a half-open connection cannot hang the run
+      // forever; merge the caller's signal so an external cancel still works.
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(new Error('Request timed out')), this.requestTimeout);
+      const onCallerAbort = () => controller.abort((callerSignal as AbortSignal).reason);
+      if (callerSignal) {
+        if (callerSignal.aborted) controller.abort(callerSignal.reason);
+        else callerSignal.addEventListener('abort', onCallerAbort, { once: true });
+      }
+
+      try {
+        const response = await fetch(url, { ...options, signal: controller.signal });
+
+        if (response.status === 429) {
+          // Rate limited - back off. Retry-After may be seconds or an HTTP-date.
+          const delay = parseRetryAfter(response.headers.get('Retry-After')) ?? this.currentDelay * 2;
+          this.currentDelay = Math.min(this.maxDelay, delay);
+          if (!this.onError(429)) break;
+          continue;
+        }
+
+        if (response.status >= 500 && attempt < this.maxRetries) {
+          // Server error - retry with backoff
+          if (!this.onError(response.status)) break;
+          continue;
+        }
+
+        this.onSuccess();
+        return response;
+      } catch (err) {
+        // A caller-initiated abort is intentional cancellation, not a failure
+        // to retry around.
+        if (callerSignal?.aborted) throw err;
+        lastError = err as Error;
+        if (!this.onError(0)) break;
+      } finally {
+        clearTimeout(timer);
+        if (callerSignal) callerSignal.removeEventListener('abort', onCallerAbort);
+      }
+    }
+
+    throw lastError || new Error('Max retries exceeded');
+  }
+}
+
+// Shared rate limiters for different APIs
+export const crossrefLimiter = new RateLimiter({ minDelay: 100, maxDelay: 10000 });
+export const dataciteLimiter = new RateLimiter({ minDelay: 100, maxDelay: 10000 });
+export const doiOrgLimiter = new RateLimiter({ minDelay: 200, maxDelay: 15000 });

package/lib/response.ts

@@ -1,197 +1,197 @@
-/**
- * Response letter generator
- * Extract comments and replies from markdown files for journal resubmission
- */
-
-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<<}
- */
-export function parseCommentsWithReplies(text: string, file: string = ''): CommentWithReplies[] {
-  const comments: CommentWithReplies[] = [];
-  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];
-    if (!line) continue;
-    const matches = [...line.matchAll(commentPattern)];
-
-    if (matches.length === 0) continue;
-
-    // Get context (surrounding text without comments)
-    const contextLine = line.replace(/\{>>[\s\S]+?<<\}/g, '').trim();
-    const context = contextLine.slice(0, 100) + (contextLine.length > 100 ? '...' : '');
-
-    // 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() || '',
-      })),
-      context,
-      file,
-      line: lineNum + 1,
-    });
-  }
-
-  return comments;
-}
-
-/**
- * Group comments by reviewer
- */
-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);
-  }
-
-  return grouped;
-}
-
-/**
- * Generate response letter in Markdown format
- */
-export function generateResponseLetter(comments: CommentWithReplies[], options: ResponseOptions = {}): string {
-  const {
-    title = 'Response to Reviewers',
-    authorName = 'Author',
-    includeContext = true,
-    includeLocation = true,
-  } = options;
-
-  const lines: string[] = [];
-  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];
-      if (!c) continue;
-
-      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
- */
-export function collectComments(files: string[]): CommentWithReplies[] {
-  const allComments: CommentWithReplies[] = [];
-
-  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;
-}
+/**
+ * Response letter generator
+ * Extract comments and replies from markdown files for journal resubmission
+ */
+
+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<<}
+ */
+export function parseCommentsWithReplies(text: string, file: string = ''): CommentWithReplies[] {
+  const comments: CommentWithReplies[] = [];
+  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];
+    if (!line) continue;
+    const matches = [...line.matchAll(commentPattern)];
+
+    if (matches.length === 0) continue;
+
+    // Get context (surrounding text without comments)
+    const contextLine = line.replace(/\{>>[\s\S]+?<<\}/g, '').trim();
+    const context = contextLine.slice(0, 100) + (contextLine.length > 100 ? '...' : '');
+
+    // 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() || '',
+      })),
+      context,
+      file,
+      line: lineNum + 1,
+    });
+  }
+
+  return comments;
+}
+
+/**
+ * Group comments by reviewer
+ */
+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);
+  }
+
+  return grouped;
+}
+
+/**
+ * Generate response letter in Markdown format
+ */
+export function generateResponseLetter(comments: CommentWithReplies[], options: ResponseOptions = {}): string {
+  const {
+    title = 'Response to Reviewers',
+    authorName = 'Author',
+    includeContext = true,
+    includeLocation = true,
+  } = options;
+
+  const lines: string[] = [];
+  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];
+      if (!c) continue;
+
+      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
+ */
+export function collectComments(files: string[]): CommentWithReplies[] {
+  const allComments: CommentWithReplies[] = [];
+
+  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;
+}