@phystack/prdl 4.4.29

package/index.js

@@ -0,0 +1,959 @@
+#!/usr/bin/env node
+
+import { Octokit } from '@octokit/rest';
+import fs from 'fs';
+import path from 'path';
+import { execSync } from 'child_process';
+import { fileURLToPath } from 'url';
+
+// Get current directory in ESM
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Configuration
+const OUTPUT_FILE = 'pr-comments.json';
+const MAX_CONCURRENT_REQUESTS = 5; // Max number of concurrent API requests
+const BACKUP_INTERVAL = 60000; // Save backup every minute (60 seconds)
+
+// Track processed data globally for backup
+let globalComments = [];
+let isShuttingDown = false;
+
+// Function to save the current comments to a backup file
+function saveBackup(comments, outputPath, isFinal = false) {
+  try {
+    const backupPath = isFinal ? outputPath : `${outputPath}.backup`;
+    fs.writeFileSync(backupPath, JSON.stringify(comments, null, 2));
+    if (!isFinal) {
+      console.log(`Backup saved to ${backupPath} with ${comments.length} comments`);
+    }
+  } catch (error) {
+    console.error(`Error saving backup: ${error.message}`);
+  }
+}
+
+// Setup signal handlers for graceful shutdown
+function setupSignalHandlers(outputPath) {
+  const signalHandler = (signal) => {
+    if (isShuttingDown) return;
+
+    isShuttingDown = true;
+    console.log(`\nReceived ${signal}. Saving partial results before exiting...`);
+
+    // Save backup with whatever we have so far
+    const backupPath = `${outputPath}.partial`;
+    saveBackup(globalComments, backupPath, true);
+    console.log(`Saved ${globalComments.length} comments to ${backupPath}`);
+    console.log('You can resume later by using these partial results.');
+
+    process.exit(0);
+  };
+
+  // Handle termination signals
+  process.on('SIGINT', () => signalHandler('SIGINT'));
+  process.on('SIGTERM', () => signalHandler('SIGTERM'));
+  process.on('SIGHUP', () => signalHandler('SIGHUP'));
+}
+
+// Display usage information
+function showUsage() {
+  console.log('PR Comments Downloader');
+  console.log('---------------------');
+  console.log('A tool to download all PR comments from a GitHub repository');
+  console.log('\nUsage:');
+  console.log('  node pr-comments-downloader.js [repository_url] [pr_limit]');
+  console.log('\nExamples:');
+  console.log('  node pr-comments-downloader.js https://github.com/owner/repo 50');
+  console.log('  node pr-comments-downloader.js git@github.com:owner/repo.git');
+  console.log('  node pr-comments-downloader.js');
+  console.log('\nParameters:');
+  console.log('  repository_url: GitHub repository URL (optional if running in a git repository)');
+  console.log('  pr_limit: Maximum number of PRs to process, sorted by creation date (newest first)');
+  console.log('           If not specified, all PRs will be processed');
+  console.log('\nRequirements:');
+  console.log('  - GITHUB_TOKEN environment variable must be set with a valid GitHub personal access token');
+  process.exit(0);
+}
+
+// Simple queue implementation
+class RequestQueue {
+  constructor(maxConcurrent = 5) {
+    this.queue = [];
+    this.active = 0;
+    this.maxConcurrent = maxConcurrent;
+    this.completed = 0;
+    this.total = 0;
+    this.failed = 0;
+  }
+
+  add(promiseFn, description = '', timeoutMs = 30000) {
+    return new Promise((resolve, reject) => {
+      this.queue.push({
+        fn: promiseFn,
+        resolve,
+        reject,
+        description,
+        timeoutMs
+      });
+      this.total++;
+      this.process();
+    });
+  }
+
+  async process() {
+    if (this.active >= this.maxConcurrent || this.queue.length === 0) {
+      return;
+    }
+
+    const item = this.queue.shift();
+    this.active++;
+
+    // Set a timeout to prevent requests from hanging indefinitely
+    const timeoutPromise = new Promise((_, reject) => {
+      setTimeout(() => {
+        reject(new Error(`Request timed out after ${item.timeoutMs}ms: ${item.description}`));
+      }, item.timeoutMs);
+    });
+
+    try {
+      // Race between the actual request and a timeout
+      const result = await Promise.race([item.fn(), timeoutPromise]);
+      this.completed++;
+      if (this.completed % 10 === 0 || this.completed === this.total) {
+        console.log(`Progress: ${this.completed}/${this.total} requests completed (${Math.round(this.completed/this.total*100)}%), ${this.failed} failed`);
+      }
+      item.resolve(result);
+    } catch (error) {
+      this.failed++;
+      console.warn(`Request failed: ${item.description} - ${error.message}`);
+      // Resolve with null rather than rejecting to avoid Promise.all failing
+      item.resolve(null);
+    } finally {
+      this.active--;
+      this.process();
+    }
+
+    // Process more items if possible
+    this.process();
+  }
+}
+
+// Check if help was requested
+if (process.argv.includes('--help') || process.argv.includes('-h')) {
+  showUsage();
+}
+
+async function main() {
+  // Track errors for reporting
+  const errorStats = {
+    notFoundFiles: new Set(),
+    failedPRs: new Set(),
+    totalErrors: 0
+  };
+
+  // Set up output path
+  const outputPath = path.join(process.cwd(), OUTPUT_FILE);
+
+  // Set up signal handlers for graceful shutdown
+  setupSignalHandlers(outputPath);
+
+  try {
+    // Get GitHub token from environment variable
+    const token = process.env.GITHUB_TOKEN;
+    if (!token) {
+      console.error('Error: GITHUB_TOKEN environment variable not set');
+      console.error('Please set it with: export GITHUB_TOKEN=your_github_token');
+      process.exit(1);
+    }
+
+    // Initialize Octokit with rate limit handling
+    const octokit = new Octokit({
+      auth: token,
+      throttle: {
+        onRateLimit: (retryAfter, options) => {
+          console.warn(`Rate limit hit for request ${options.method} ${options.url}, retrying after ${retryAfter} seconds`);
+          return true; // Always retry
+        },
+        onSecondaryRateLimit: (retryAfter, options) => {
+          console.warn(`Secondary rate limit hit for request ${options.method} ${options.url}, retrying after ${retryAfter} seconds`);
+          return true; // Always retry
+        },
+      }
+    });
+
+    // Get repository info from command line argument or git config
+    console.log('Detecting repository information...');
+    let remoteUrl;
+    let prLimit = null;
+
+    // Parse command line arguments
+    if (process.argv.length > 2) {
+      // First argument is the repository URL if it looks like one
+      if (process.argv[2].includes('github.com') || process.argv[2].includes(':')) {
+        remoteUrl = process.argv[2];
+        console.log(`Using provided repository URL: ${remoteUrl}`);
+
+        // Check if there's a PR limit as well
+        if (process.argv.length > 3) {
+          const limitArg = parseInt(process.argv[3], 10);
+          if (!isNaN(limitArg) && limitArg > 0) {
+            prLimit = limitArg;
+          }
+        }
+      } else {
+        // First argument might be the PR limit
+        const limitArg = parseInt(process.argv[2], 10);
+        if (!isNaN(limitArg) && limitArg > 0) {
+          prLimit = limitArg;
+        }
+      }
+    }
+
+    // If PR limit is set, show it
+    if (prLimit !== null) {
+      console.log(`Processing the ${prLimit} most recent PRs`);
+    } else {
+      console.log('Processing all PRs');
+    }
+
+    // If no remote URL from args, fallback to git config
+    if (!remoteUrl) {
+      try {
+        remoteUrl = execSync('git config --get remote.origin.url').toString().trim();
+        console.log(`Using git config repository URL: ${remoteUrl}`);
+      } catch (error) {
+        console.error('Error: Could not determine repository from git config');
+        console.error('Please provide a GitHub repository URL as argument:');
+        console.error('  node pr-comments-downloader.js https://github.com/owner/repo');
+        process.exit(1);
+      }
+    }
+
+    // Parse owner and repo from the remote URL
+    let owner, repo;
+
+    if (remoteUrl.includes('github.com')) {
+      const match = remoteUrl.match(/github\.com[:/]([^/]+)\/([^/\.]+)(?:\.git)?$/);
+      if (match) {
+        owner = match[1];
+        repo = match[2];
+      }
+    }
+
+    if (!owner || !repo) {
+      console.error('Error: Could not determine repository owner and name');
+      console.error('Repository URL:', remoteUrl);
+      console.error('Please provide a valid GitHub repository URL in the format:');
+      console.error('  https://github.com/owner/repo');
+      console.error('  git@github.com:owner/repo.git');
+      process.exit(1);
+    }
+
+    console.log(`Repository: ${owner}/${repo}`);
+
+    // Get all pull requests
+    console.log('Fetching pull requests...');
+    const allPRs = await getPullRequests(octokit, owner, repo);
+    console.log(`Found ${allPRs.length} pull requests`);
+
+    // Sort PRs by creation date (newest first)
+    allPRs.sort((a, b) => new Date(b.created_at) - new Date(a.created_at));
+
+    // Limit PRs if specified
+    const prsToProcess = prLimit ? allPRs.slice(0, prLimit) : allPRs;
+    console.log(`Processing ${prsToProcess.length} pull requests`);
+
+    // Setup a timer to save backups periodically
+    const backupIntervalId = setInterval(() => {
+      if (globalComments.length > 0) {
+        saveBackup(globalComments, outputPath);
+      }
+    }, BACKUP_INTERVAL);
+
+    // Get comments for each pull request using parallelization
+    console.log('Fetching comments for each pull request (in parallel)...');
+    const commentData = await getAllCommentsParallel(octokit, owner, repo, prsToProcess, errorStats);
+
+    // Store globally for backup in case of interruption
+    globalComments = commentData;
+
+    // Stop the backup interval
+    clearInterval(backupIntervalId);
+
+    // Save to file
+    saveBackup(commentData, outputPath, true);
+    console.log(`Successfully saved ${commentData.length} PR comments to ${outputPath}`);
+
+    // Print error statistics if any
+    if (errorStats.totalErrors > 0) {
+      console.log('\nSummary of errors encountered:');
+      console.log(`- Total errors: ${errorStats.totalErrors}`);
+      console.log(`- Files not found: ${errorStats.notFoundFiles.size}`);
+
+      if (errorStats.notFoundFiles.size > 0) {
+        console.log('\nList of files that could not be found:');
+        Array.from(errorStats.notFoundFiles).slice(0, 10).forEach(file => {
+          console.log(`- ${file}`);
+        });
+
+        if (errorStats.notFoundFiles.size > 10) {
+          console.log(`...and ${errorStats.notFoundFiles.size - 10} more`);
+        }
+      }
+
+      if (errorStats.failedPRs.size > 0) {
+        console.log('\nPRs with errors:');
+        Array.from(errorStats.failedPRs).slice(0, 10).forEach(pr => {
+          console.log(`- PR #${pr}`);
+        });
+
+        if (errorStats.failedPRs.size > 10) {
+          console.log(`...and ${errorStats.failedPRs.size - 10} more`);
+        }
+      }
+    }
+  } catch (error) {
+    console.error('Error:', error.message);
+    process.exit(1);
+  }
+}
+
+async function getPullRequests(octokit, owner, repo) {
+  const allPRs = [];
+  let page = 1;
+  let hasNextPage = true;
+
+  while (hasNextPage) {
+    const response = await octokit.pulls.list({
+      owner,
+      repo,
+      state: 'all',
+      per_page: 100,
+      page,
+    });
+
+    if (response.data.length === 0) {
+      hasNextPage = false;
+    } else {
+      allPRs.push(...response.data);
+      page++;
+    }
+  }
+
+  return allPRs;
+}
+
+async function getAllCommentsParallel(octokit, owner, repo, pullRequests, errorStats) {
+  const requestQueue = new RequestQueue(MAX_CONCURRENT_REQUESTS);
+  const allComments = [];
+  let processedCount = 0;
+  const totalPRs = pullRequests.length;
+
+  // Process PRs in smaller batches to avoid memory issues
+  const batchSize = 10; // Process 10 PRs at a time
+  let startIndex = 0;
+
+  while (startIndex < pullRequests.length) {
+    const endIndex = Math.min(startIndex + batchSize, pullRequests.length);
+    const currentBatch = pullRequests.slice(startIndex, endIndex);
+    console.log(`Processing PR batch ${startIndex+1}-${endIndex} of ${pullRequests.length}`);
+
+    // Create an array of promises for processing each PR in the current batch
+    const prPromises = currentBatch.map((pr, index) => {
+      return requestQueue.add(
+        async () => {
+          console.log(`Processing PR #${pr.number} (${startIndex + index + 1}/${totalPRs})`);
+          try {
+            const comments = await processOnePR(octokit, owner, repo, pr, errorStats, requestQueue);
+            processedCount++;
+            console.log(`Completed PR #${pr.number} (${processedCount}/${totalPRs})`);
+            return comments;
+          } catch (error) {
+            console.error(`Error processing PR #${pr.number}: ${error.message}`);
+            errorStats.totalErrors++;
+            errorStats.failedPRs.add(pr.number);
+            processedCount++;
+            console.log(`Failed PR #${pr.number} (${processedCount}/${totalPRs})`);
+            return [];
+          }
+        },
+        `PR #${pr.number}`,
+        60000 // 60 second timeout for each PR
+      );
+    });
+
+    // Wait for all PRs in this batch to complete
+    console.log(`Waiting for ${prPromises.length} PRs in batch to complete processing...`);
+    const batchResults = await Promise.all(prPromises);
+
+    // Process results from this batch
+    let batchComments = [];
+    batchResults.filter(arr => arr !== null).forEach(comments => {
+      if (Array.isArray(comments)) {
+        batchComments.push(...comments);
+      }
+    });
+
+    // Add the batch comments to all comments
+    allComments.push(...batchComments);
+
+    // Update global comments for backup
+    globalComments = [...allComments];
+
+    console.log(`Batch ${startIndex+1}-${endIndex} completed with ${batchComments.length} comments. Total: ${allComments.length}`);
+
+    // Move to next batch
+    startIndex += batchSize;
+  }
+
+  return allComments;
+}
+
+async function processOnePR(octokit, owner, repo, pr, errorStats, requestQueue) {
+  const prComments = [];
+  const commentThreads = new Map(); // Map to organize comments into threads
+
+  try {
+    // Queue all requests for this PR in parallel with shorter timeouts
+    const requestResults = await Promise.allSettled([
+      getReviewComments(octokit, owner, repo, pr.number).catch(e => {
+        console.warn(`Failed to get review comments for PR #${pr.number}: ${e.message}`);
+        return [];
+      }),
+      getIssueComments(octokit, owner, repo, pr.number).catch(e => {
+        console.warn(`Failed to get issue comments for PR #${pr.number}: ${e.message}`);
+        return [];
+      }),
+      getReviews(octokit, owner, repo, pr.number).catch(e => {
+        console.warn(`Failed to get reviews for PR #${pr.number}: ${e.message}`);
+        return [];
+      })
+    ]);
+
+    // Extract results, defaulting to empty arrays for rejected promises
+    const [reviewCommentsResult, issueCommentsResult, reviewsResult] = requestResults;
+    const reviewComments = reviewCommentsResult.status === 'fulfilled' ? reviewCommentsResult.value : [];
+    const issueComments = issueCommentsResult.status === 'fulfilled' ? issueCommentsResult.value : [];
+    const reviews = reviewsResult.status === 'fulfilled' ? reviewsResult.value : [];
+
+    // Add statistics if any request failed
+    if (requestResults.some(r => r.status === 'rejected')) {
+      errorStats.failedPRs.add(pr.number);
+      errorStats.totalErrors++;
+    }
+
+    // Log some stats about the comments found
+    console.log(`PR #${pr.number}: Found ${reviewComments.length} review comments, ${issueComments.length} issue comments, ${reviews.length} reviews`);
+
+    // First, organize the review comments into threads
+    reviewComments.forEach(comment => {
+      // Store comment by ID for easy access later
+      if (comment.in_reply_to_id) {
+        // This is a reply to another comment
+        if (!commentThreads.has(comment.in_reply_to_id)) {
+          commentThreads.set(comment.in_reply_to_id, {
+            parent: null,
+            replies: []
+          });
+        }
+        commentThreads.get(comment.in_reply_to_id).replies.push(comment);
+      } else {
+        // This is a top-level comment
+        if (!commentThreads.has(comment.id)) {
+          commentThreads.set(comment.id, {
+            parent: comment,
+            replies: []
+          });
+        } else {
+          commentThreads.get(comment.id).parent = comment;
+        }
+      }
+    });
+
+    // Process review comments with code context in parallel
+    if (reviewComments.length > 0) {
+      // First, process the parent comments (top-level comments)
+      const parentCommentPromises = Array.from(commentThreads.values())
+        .filter(thread => thread.parent !== null)
+        .map(thread => {
+          const comment = thread.parent;
+          return requestQueue.add(
+            async () => {
+              try {
+                let codeContext = null;
+                if (comment.path && (comment.line || comment.position || comment.original_position)) {
+                  codeContext = await getCodeContext(octokit, owner, repo, pr.number, comment, errorStats);
+                }
+
+                // Get reply discussion
+                const replies = thread.replies.map(reply => ({
+                  id: reply.id,
+                  author: reply.user?.login || 'unknown',
+                  body: reply.body || '',
+                  created_at: reply.created_at,
+                  html_url: reply.html_url
+                }));
+
+                return {
+                  type: 'review_comment',
+                  pr_number: pr.number,
+                  pr_title: pr.title,
+                  pr_created_at: pr.created_at,
+                  author: comment.user?.login || 'unknown',
+                  body: comment.body || '',
+                  created_at: comment.created_at,
+                  path: comment.path,
+                  commit_id: comment.commit_id,
+                  line: comment.line,
+                  original_line: comment.original_line,
+                  position: comment.position,
+                  original_position: comment.original_position,
+                  diff_hunk: comment.diff_hunk,
+                  html_url: comment.html_url,
+                  code_context: codeContext,
+                  discussion: {
+                    replies: replies,
+                    count: replies.length
+                  }
+                };
+              } catch (error) {
+                console.warn(`Couldn't fetch code context for comment in PR #${pr.number}: ${error.message}`);
+                errorStats.totalErrors++;
+                errorStats.failedPRs.add(pr.number);
+                if (comment.path) {
+                  errorStats.notFoundFiles.add(comment.path);
+                }
+
+                // Still return the comment, just without code context
+                const replies = thread.replies.map(reply => ({
+                  id: reply.id,
+                  author: reply.user?.login || 'unknown',
+                  body: reply.body || '',
+                  created_at: reply.created_at,
+                  html_url: reply.html_url
+                }));
+
+                return {
+                  type: 'review_comment',
+                  pr_number: pr.number,
+                  pr_title: pr.title,
+                  pr_created_at: pr.created_at,
+                  author: comment.user?.login || 'unknown',
+                  body: comment.body || '',
+                  created_at: comment.created_at,
+                  path: comment.path,
+                  commit_id: comment.commit_id,
+                  line: comment.line,
+                  original_line: comment.original_line,
+                  position: comment.position,
+                  original_position: comment.original_position,
+                  diff_hunk: comment.diff_hunk,
+                  html_url: comment.html_url,
+                  code_context: null,
+                  discussion: {
+                    replies: replies,
+                    count: replies.length
+                  }
+                };
+              }
+            },
+            `CodeContext PR #${pr.number} comment ${comment.id}`,
+            45000 // 45 second timeout for each code context
+          );
+        });
+
+      // Process all parent review comments in parallel with a timeout
+      const reviewCommentsResults = await Promise.allSettled(parentCommentPromises);
+
+      // Filter fulfilled promises and add to comments
+      reviewCommentsResults
+        .filter(result => result.status === 'fulfilled' && result.value !== null)
+        .forEach(result => prComments.push(result.value));
+    }
+
+    // Group issue comments into conversations by time proximity
+    // This is heuristic-based since GitHub doesn't explicitly mark issue comment threads
+    if (issueComments.length > 0) {
+      // Sort comments by time
+      const sortedIssueComments = [...issueComments].sort((a, b) =>
+        new Date(a.created_at) - new Date(b.created_at)
+      );
+
+      // Group comments into conversations (30-minute window for replies)
+      const issueConversations = [];
+      let currentConversation = [];
+
+      for (const comment of sortedIssueComments) {
+        if (currentConversation.length === 0) {
+          currentConversation.push(comment);
+        } else {
+          const lastComment = currentConversation[currentConversation.length - 1];
+          const timeDiff = new Date(comment.created_at) - new Date(lastComment.created_at);
+          const THIRTY_MINUTES_MS = 30 * 60 * 1000;
+
+          if (timeDiff < THIRTY_MINUTES_MS) {
+            // Consider it part of the same conversation
+            currentConversation.push(comment);
+          } else {
+            // Start a new conversation
+            issueConversations.push([...currentConversation]);
+            currentConversation = [comment];
+          }
+        }
+      }
+
+      // Add the last conversation if not empty
+      if (currentConversation.length > 0) {
+        issueConversations.push(currentConversation);
+      }
+
+      // Process each conversation
+      issueConversations.forEach(conversation => {
+        const firstComment = conversation[0];
+        const replies = conversation.slice(1);
+
+        prComments.push({
+          type: 'issue_comment',
+          pr_number: pr.number,
+          pr_title: pr.title,
+          pr_created_at: pr.created_at,
+          author: firstComment.user?.login || 'unknown',
+          body: firstComment.body || '',
+          created_at: firstComment.created_at,
+          html_url: firstComment.html_url,
+          discussion: {
+            replies: replies.map(reply => ({
+              id: reply.id,
+              author: reply.user?.login || 'unknown',
+              body: reply.body || '',
+              created_at: reply.created_at,
+              html_url: reply.html_url
+            })),
+            count: replies.length
+          }
+        });
+      });
+    }
+
+    // Process reviews with their comments
+    const reviewsWithComments = new Map();
+
+    reviews.forEach(review => {
+      if (!reviewsWithComments.has(review.id)) {
+        reviewsWithComments.set(review.id, {
+          review: review,
+          comments: []
+        });
+      }
+    });
+
+    // Associate review comments with their parent reviews
+    reviewComments.forEach(comment => {
+      if (comment.pull_request_review_id && reviewsWithComments.has(comment.pull_request_review_id)) {
+        reviewsWithComments.get(comment.pull_request_review_id).comments.push(comment);
+      }
+    });
+
+    // Process each review with its associated comments
+    for (const [reviewId, reviewData] of reviewsWithComments.entries()) {
+      const review = reviewData.review;
+      const comments = reviewData.comments;
+
+      if (review.body?.trim() || comments.length > 0) {
+        prComments.push({
+          type: 'review',
+          pr_number: pr.number,
+          pr_title: pr.title,
+          pr_created_at: pr.created_at,
+          review_id: review.id,
+          author: review.user?.login || 'unknown',
+          body: review.body || '',
+          state: review.state,
+          created_at: review.submitted_at,
+          html_url: review.html_url,
+          comments: comments.map(comment => ({
+            id: comment.id,
+            path: comment.path,
+            position: comment.position,
+            body: comment.body,
+            diff_hunk: comment.diff_hunk
+          })),
+          comments_count: comments.length
+        });
+      }
+    }
+  } catch (error) {
+    console.error(`Error processing PR #${pr.number}: ${error.message}`);
+    errorStats.totalErrors++;
+    errorStats.failedPRs.add(pr.number);
+  }
+
+  return prComments;
+}
+
+async function getCodeContext(octokit, owner, repo, pullNumber, comment, errorStats) {
+  // Get both the original code (when commented) and final code (after merged)
+  let originalFileContent;
+  let mergedFileContent;
+  const result = {
+    commit_id: comment.commit_id,
+    original: null,
+    merged: null
+  };
+
+  // 1. Get original file content at the comment's commit
+  try {
+    // First check if this file exists at the commit
+    try {
+      const response = await octokit.repos.getContent({
+        owner,
+        repo,
+        path: comment.path,
+        ref: comment.commit_id // This is the commit the comment was made on
+      });
+
+      // Decode content from base64
+      if (response.data.encoding === 'base64') {
+        originalFileContent = Buffer.from(response.data.content, 'base64').toString();
+
+        // Process original file content
+        const lines = originalFileContent.split('\n');
+        const lineNum = comment.line || comment.position || 1;
+        const startLine = Math.max(1, lineNum - 5);
+        const endLine = Math.min(lines.length, lineNum + 5);
+
+        // Extract the lines for context
+        const contextLines = {};
+        for (let i = startLine; i <= endLine; i++) {
+          contextLines[i] = lines[i - 1]; // -1 because array is 0-indexed
+        }
+
+        result.original = {
+          startLine,
+          endLine,
+          lines: contextLines,
+          highlightedLine: lineNum
+        };
+      }
+    } catch (getFileError) {
+      // File might not exist at that commit, or the file was renamed/moved
+      // Record the error for reporting
+      if (getFileError.status === 404) {
+        if (comment.path) {
+          errorStats.notFoundFiles.add(comment.path);
+        }
+        errorStats.totalErrors++;
+      }
+
+      // Try to get the diff context from the comment itself
+      if (comment.diff_hunk) {
+        result.original = {
+          source: "diff_hunk",
+          diff_hunk: comment.diff_hunk
+        };
+      } else {
+        throw new Error(`File not found at commit ${comment.commit_id}`);
+      }
+    }
+  } catch (error) {
+    // Don't log 404 errors as they're expected in many cases
+    if (!error.message.includes('404')) {
+      console.warn(`Couldn't get original file content for ${comment.path} at commit ${comment.commit_id}: ${error.message}`);
+    }
+
+    errorStats.totalErrors++;
+
+    result.original = {
+      error: "Couldn't retrieve original file state",
+      reason: error.message,
+      // Include diff hunk if available
+      diff_hunk: comment.diff_hunk || null
+    };
+  }
+
+  // 2. Try to get the merged state (final version after PR was merged)
+  try {
+    // First get PR info to know the merge commit
+    const prInfo = await octokit.pulls.get({
+      owner,
+      repo,
+      pull_number: pullNumber
+    });
+
+    // Only proceed if PR was merged
+    if (prInfo.data.merged) {
+      const mergeCommit = prInfo.data.merge_commit_sha;
+
+      try {
+        const response = await octokit.repos.getContent({
+          owner,
+          repo,
+          path: comment.path,
+          ref: mergeCommit // The merge commit
+        });
+
+        // Decode content from base64
+        if (response.data.encoding === 'base64') {
+          mergedFileContent = Buffer.from(response.data.content, 'base64').toString();
+
+          // Process merged file content
+          const lines = mergedFileContent.split('\n');
+          // Try to find the same area of code - this is approximate as line numbers may shift
+          // We'll use the same line number as a starting point
+          const lineNum = comment.line || comment.position || 1;
+          const startLine = Math.max(1, lineNum - 5);
+          const endLine = Math.min(lines.length, lineNum + 5);
+
+          // Extract the lines for context
+          const contextLines = {};
+          for (let i = startLine; i <= endLine; i++) {
+            if (i <= lines.length) {
+              contextLines[i] = lines[i - 1]; // -1 because array is 0-indexed
+            }
+          }
+
+          result.merged = {
+            merge_commit_sha: mergeCommit,
+            startLine,
+            endLine,
+            lines: contextLines,
+            highlightedLine: lineNum
+          };
+        }
+      } catch (contentError) {
+        // Don't log 404 errors as they're expected in many cases
+        if (!contentError.message.includes('404')) {
+          console.warn(`Couldn't get merged file content for ${comment.path} at commit ${mergeCommit}: ${contentError.message}`);
+        }
+
+        if (contentError.status === 404) {
+          if (comment.path) {
+            errorStats.notFoundFiles.add(comment.path);
+          }
+          errorStats.totalErrors++;
+        }
+
+        // The file might have been deleted or moved in the final version
+        result.merged = {
+          error: "Couldn't retrieve merged file state",
+          reason: contentError.message,
+          merge_commit_sha: mergeCommit
+        };
+      }
+    } else if (prInfo.data.state === 'closed' && !prInfo.data.merged) {
+      // PR was closed without merging
+      result.merged = {
+        state: "PR was closed without merging"
+      };
+    } else {
+      // PR is still open
+      result.merged = {
+        state: "PR is still open"
+      };
+    }
+  } catch (prError) {
+    // Don't log 404 errors as they're expected in many cases
+    if (!prError.message.includes('404')) {
+      console.warn(`Couldn't retrieve PR merge information for PR #${pullNumber}: ${prError.message}`);
+    }
+
+    errorStats.totalErrors++;
+
+    result.merged = {
+      error: "Couldn't retrieve PR merge information",
+      reason: prError.message
+    };
+  }
+
+  return result;
+}
+
+async function getReviewComments(octokit, owner, repo, pullNumber) {
+  const comments = [];
+  let page = 1;
+  let hasNextPage = true;
+
+  while (hasNextPage) {
+    const response = await octokit.pulls.listReviewComments({
+      owner,
+      repo,
+      pull_number: pullNumber,
+      per_page: 100,
+      page,
+    });
+
+    if (response.data.length === 0) {
+      hasNextPage = false;
+    } else {
+      // Enrich each comment with additional information
+      for (const comment of response.data) {
+        // Store the original position and other diff-related data
+        // This helps in accurately locating the code when the comment was made
+        comments.push({
+          ...comment,
+          // Ensure these fields are preserved (they sometimes get transformed)
+          original_position: comment.original_position,
+          original_line: comment.original_line,
+          position: comment.position,
+          line: comment.line,
+          diff_hunk: comment.diff_hunk
+        });
+      }
+      page++;
+    }
+  }
+
+  return comments;
+}
+
+async function getIssueComments(octokit, owner, repo, issueNumber) {
+  const comments = [];
+  let page = 1;
+  let hasNextPage = true;
+
+  while (hasNextPage) {
+    const response = await octokit.issues.listComments({
+      owner,
+      repo,
+      issue_number: issueNumber,
+      per_page: 100,
+      page,
+    });
+
+    if (response.data.length === 0) {
+      hasNextPage = false;
+    } else {
+      comments.push(...response.data);
+      page++;
+    }
+  }
+
+  return comments;
+}
+
+async function getReviews(octokit, owner, repo, pullNumber) {
+  const reviews = [];
+  let page = 1;
+  let hasNextPage = true;
+
+  while (hasNextPage) {
+    const response = await octokit.pulls.listReviews({
+      owner,
+      repo,
+      pull_number: pullNumber,
+      per_page: 100,
+      page,
+    });
+
+    if (response.data.length === 0) {
+      hasNextPage = false;
+    } else {
+      reviews.push(...response.data);
+      page++;
+    }
+  }
+
+  return reviews;
+}
+
+main();

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@phystack/prdl",
+  "version": "4.4.29",
+  "main": "index.js",
+  "type": "module",
+  "bin": {
+    "prdl": "./index.js"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "build": "true"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "author": "",
+  "license": "ISC",
+  "description": "",
+  "dependencies": {
+    "@octokit/rest": "^21.1.1"
+  },
+  "gitHead": "7dba834ca1f446f669992ff14352862d2fbcfe22"
+}