edsger 0.40.0 → 0.41.0

package/dist/phases/pr-resolve/index.js

@@ -0,0 +1,213 @@
+/**
+ * Standalone PR Resolve
+ * Evaluates unresolved review comments, fixes what's genuinely better,
+ * replies to every comment on GitHub explaining the decision.
+ */
+import { query } from '@anthropic-ai/claude-agent-sdk';
+import { Octokit } from '@octokit/rest';
+import { execSync } from 'child_process';
+import { rmSync } from 'fs';
+import { callMcpEndpoint } from '../../api/mcp-client.js';
+import { DEFAULT_MODEL } from '../../constants.js';
+import { logError, logInfo, logSuccess } from '../../utils/logger.js';
+import { fetchUnresolvedReviewThreads } from '../code-refine-verification/github.js';
+import { createPromptGenerator, extractTextFromContent, tryExtractResult, } from '../pr-shared/agent-utils.js';
+import { parsePullRequestUrl } from '../pr-shared/context.js';
+import { replyToReviewThread, resolveReviewThread } from './github-reply.js';
+import { createResolveSystemPrompt, createResolveUserPrompt, } from './prompts.js';
+import { hasNewCommits, hasUncommittedChanges, prepareWorkspace, pushChanges, } from './workspace.js';
+/**
+ * Resolve PR change requests: evaluate each comment, fix or explain.
+ */
+export async function resolveStandalonePR(options) {
+    const { pullRequestUrl, githubToken, owner, repo, verbose, prId } = options;
+    logInfo(`Starting PR resolve: ${pullRequestUrl}`);
+    try {
+        // Parse PR URL
+        const prInfo = parsePullRequestUrl(pullRequestUrl);
+        if (!prInfo) {
+            throw new Error(`Invalid PR URL: ${pullRequestUrl}`);
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        // Fetch unresolved review threads
+        logInfo('Fetching unresolved review threads...');
+        const unresolvedThreads = await fetchUnresolvedReviewThreads(octokit, owner, repo, prInfo.prNumber, verbose);
+        if (unresolvedThreads.length === 0) {
+            logSuccess('No unresolved review threads found.');
+            return {
+                status: 'success',
+                message: 'No unresolved review threads to resolve',
+                threadsAddressed: 0,
+                threadsSkipped: 0,
+            };
+        }
+        logInfo(`Found ${unresolvedThreads.length} unresolved threads to evaluate`);
+        // Get PR details for head branch
+        // Note: workspace will be preserved on failure for manual inspection
+        const { data: prData } = await octokit.pulls.get({
+            owner,
+            repo,
+            pull_number: prInfo.prNumber,
+        });
+        const headRef = prData.head.ref;
+        // Clone repo and checkout PR branch
+        const repoPath = prepareWorkspace(owner, repo, headRef, prInfo.prNumber, githubToken, verbose);
+        try {
+            // Run Claude Agent SDK to evaluate and fix comments
+            const systemPrompt = createResolveSystemPrompt();
+            const { prompt: resolvePrompt, commentIdToThreadId } = createResolveUserPrompt(unresolvedThreads);
+            let lastAssistantResponse = '';
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            let resolveResult = null;
+            logInfo('Starting Claude agent to evaluate and resolve comments...');
+            for await (const message of query({
+                prompt: createPromptGenerator(resolvePrompt),
+                options: {
+                    systemPrompt: {
+                        type: 'preset',
+                        preset: 'claude_code',
+                        append: systemPrompt,
+                    },
+                    model: DEFAULT_MODEL,
+                    maxTurns: 2000,
+                    permissionMode: 'bypassPermissions',
+                    cwd: repoPath,
+                },
+            })) {
+                if (message.type === 'assistant') {
+                    lastAssistantResponse += extractTextFromContent(message.message?.content ?? [], verbose);
+                    continue;
+                }
+                if (message.type !== 'result') {
+                    continue;
+                }
+                if (message.subtype === 'success') {
+                    logInfo('Agent completed, parsing results...');
+                    const responseText = message.result || lastAssistantResponse;
+                    resolveResult = tryExtractResult(responseText, 'resolve_result');
+                    if (!resolveResult) {
+                        logError('Failed to parse resolve result JSON');
+                    }
+                }
+                else {
+                    logError(`Agent incomplete: ${message.subtype}`);
+                    // Try to salvage partial results from last response
+                    if (lastAssistantResponse) {
+                        resolveResult = tryExtractResult(lastAssistantResponse, 'resolve_result');
+                    }
+                }
+            }
+            // Commit and push any changes the agent made
+            if (hasUncommittedChanges(repoPath)) {
+                logInfo('Committing changes...');
+                execSync('git add -A', { cwd: repoPath, stdio: 'pipe' });
+                execSync('git commit -m "Resolve PR review comments\n\nAutomated resolution by Edsger AI"', { cwd: repoPath, stdio: 'pipe' });
+            }
+            // Check if there are commits to push (agent may have made its own commits)
+            const newCommitsExist = hasNewCommits(repoPath, headRef);
+            if (newCommitsExist) {
+                pushChanges(repoPath, headRef, githubToken, verbose);
+            }
+            // Reply to each comment on GitHub
+            let threadsAddressed = 0;
+            let threadsSkipped = 0;
+            let threadsErrored = 0;
+            if (resolveResult?.comments) {
+                const comments = resolveResult.comments;
+                for (const comment of comments) {
+                    // Map comment_id back to real GraphQL thread ID
+                    const threadId = commentIdToThreadId.get(comment.comment_id);
+                    if (!threadId) {
+                        logError(`Unknown comment_id "${comment.comment_id}", skipping reply`);
+                        threadsErrored++;
+                        continue;
+                    }
+                    try {
+                        const replied = await replyToReviewThread(octokit, threadId, comment.reply, verbose);
+                        if (replied && comment.action === 'changed') {
+                            // Resolve the thread since the change was made
+                            await resolveReviewThread(octokit, threadId, verbose);
+                            threadsAddressed++;
+                        }
+                        else if (replied && comment.action === 'skipped') {
+                            // Don't resolve - leave open for human to review the explanation
+                            threadsSkipped++;
+                        }
+                        else {
+                            threadsErrored++;
+                        }
+                    }
+                    catch (error) {
+                        logError(`Failed to process ${comment.comment_id}: ${error}`);
+                        threadsErrored++;
+                    }
+                }
+            }
+            else {
+                // No structured result - check if agent made changes and reply generically
+                logInfo('No structured resolve result. Replying with generic status to each thread.');
+                const agentMadeChanges = newCommitsExist;
+                for (const thread of unresolvedThreads) {
+                    try {
+                        const genericReply = agentMadeChanges
+                            ? 'Changes were made to address review feedback. Please re-review.'
+                            : 'Reviewed this comment. No changes were made at this time.';
+                        const replied = await replyToReviewThread(octokit, thread.id, genericReply, verbose);
+                        if (replied) {
+                            threadsSkipped++;
+                        }
+                        else {
+                            threadsErrored++;
+                        }
+                    }
+                    catch {
+                        threadsErrored++;
+                    }
+                }
+            }
+            logSuccess(`PR resolve completed: ${threadsAddressed} addressed, ${threadsSkipped} skipped, ${threadsErrored} errors`);
+            if (prId) {
+                try {
+                    await callMcpEndpoint('pull_requests/update', {
+                        pull_request_id: prId,
+                        status: 'in_review',
+                    });
+                }
+                catch {
+                    // Non-critical
+                }
+            }
+            return {
+                status: 'success',
+                message: `Resolved ${threadsAddressed} threads, skipped ${threadsSkipped}, ${threadsErrored} errors`,
+                threadsAddressed,
+                threadsSkipped,
+                threadsErrored,
+                filesModified: resolveResult?.files_modified,
+                summary: resolveResult?.summary,
+            };
+        }
+        catch (innerError) {
+            // On failure, keep workspace for inspection
+            logError(`Error during resolve: ${innerError instanceof Error ? innerError.message : String(innerError)}`);
+            logInfo(`Workspace preserved for inspection: ${repoPath}`);
+            throw innerError;
+        }
+        // Only clean up on success
+        try {
+            rmSync(repoPath, { recursive: true, force: true });
+            logInfo(`Cleaned up workspace: ${repoPath}`);
+        }
+        catch {
+            // ignore cleanup errors
+        }
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logError(`PR resolve failed: ${errorMessage}`);
+        return {
+            status: 'error',
+            message: `PR resolve failed: ${errorMessage}`,
+        };
+    }
+}

package/dist/phases/pr-resolve/prompts.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Prompts for standalone PR resolve.
+ * The agent evaluates each review comment, fixes what's genuinely better, and explains what it won't change.
+ *
+ * Uses simple numeric IDs (comment_1, comment_2...) instead of opaque GraphQL thread IDs
+ * to make it easier for the agent to produce correct output. The caller maps back to real IDs.
+ */
+import { type ReviewThread } from '../code-refine-verification/types.js';
+export declare function createResolveSystemPrompt(): string;
+/**
+ * Build the user prompt with numbered comment IDs.
+ * Returns the prompt string and a mapping from comment_id to real thread ID.
+ */
+export declare function createResolveUserPrompt(unresolvedThreads: ReviewThread[]): {
+    prompt: string;
+    commentIdToThreadId: Map<string, string>;
+};

package/dist/phases/pr-resolve/prompts.js

@@ -0,0 +1,106 @@
+/**
+ * Prompts for standalone PR resolve.
+ * The agent evaluates each review comment, fixes what's genuinely better, and explains what it won't change.
+ *
+ * Uses simple numeric IDs (comment_1, comment_2...) instead of opaque GraphQL thread IDs
+ * to make it easier for the agent to produce correct output. The caller maps back to real IDs.
+ */
+export function createResolveSystemPrompt() {
+    return `You are an expert software engineer resolving code review feedback on a pull request.
+
+**Your Goal**: For each review comment, evaluate whether the suggested change genuinely improves the code. If it does, make the change. If you disagree, do NOT make the change.
+
+**Decision Criteria - Make the change when**:
+- The suggestion fixes a real bug or logic error
+- The suggestion improves correctness, security, or error handling
+- The suggestion makes the code clearer or more maintainable
+- The suggestion follows established best practices for the language/framework
+
+**Skip the change when**:
+- The suggestion is purely stylistic preference without clear benefit
+- The suggestion would increase complexity without proportional value
+- The suggestion conflicts with the codebase's established patterns
+- You disagree with the technical rationale
+
+**Process**:
+1. Read all the review comments carefully
+2. For each comment, examine the relevant code
+3. If you agree: make the change in the file
+4. If you disagree: skip it (do NOT modify the file for that comment)
+5. After processing all comments, output a JSON summary
+
+**CRITICAL - Result Format**:
+After making all changes, you MUST output a JSON result. Use the exact comment_id from each comment (comment_1, comment_2, etc.):
+
+\`\`\`json
+{
+  "resolve_result": {
+    "comments": [
+      {
+        "comment_id": "comment_1",
+        "action": "changed",
+        "reply": "Brief description of what was changed"
+      },
+      {
+        "comment_id": "comment_2",
+        "action": "skipped",
+        "reply": "Technical explanation of why not changing"
+      }
+    ],
+    "files_modified": ["list of modified file paths"],
+    "summary": "Overall summary of what was done"
+  }
+}
+\`\`\`
+
+**Reply Guidelines**:
+- For "changed": briefly describe what was changed (1-2 sentences)
+- For "skipped": provide a clear, respectful technical explanation of why the current code is better (2-3 sentences)
+- Be professional and constructive in all replies
+- You MUST include an entry for EVERY comment_id`;
+}
+/**
+ * Build the user prompt with numbered comment IDs.
+ * Returns the prompt string and a mapping from comment_id to real thread ID.
+ */
+export function createResolveUserPrompt(unresolvedThreads) {
+    const sections = [];
+    const commentIdToThreadId = new Map();
+    sections.push('# PR Review Comments to Resolve');
+    sections.push('');
+    sections.push(`There are ${unresolvedThreads.length} unresolved review comment(s) to evaluate.`);
+    sections.push('');
+    let commentIndex = 0;
+    for (const thread of unresolvedThreads) {
+        const firstComment = thread.comments.nodes[0];
+        if (!firstComment)
+            continue;
+        commentIndex++;
+        const commentId = `comment_${commentIndex}`;
+        commentIdToThreadId.set(commentId, thread.id);
+        sections.push(`## ${commentId}`);
+        sections.push(`**File**: ${firstComment.path}`);
+        if (firstComment.line) {
+            sections.push(`**Line**: ${firstComment.line}`);
+        }
+        sections.push(`**Author**: @${firstComment.author.login}`);
+        sections.push(`**Comment**:`);
+        sections.push(firstComment.body);
+        // Include follow-up comments in the thread
+        if (thread.comments.nodes.length > 1) {
+            sections.push('');
+            sections.push('**Follow-up comments**:');
+            for (const comment of thread.comments.nodes.slice(1)) {
+                sections.push(`- @${comment.author.login}: ${comment.body}`);
+            }
+        }
+        sections.push('');
+    }
+    sections.push('## Instructions');
+    sections.push('');
+    sections.push('For each comment above, read the referenced file and evaluate the suggestion.');
+    sections.push('Make changes only when they genuinely improve the code. Skip changes you disagree with.');
+    sections.push('After processing all comments, output the JSON resolve_result with your decisions and reply messages.');
+    sections.push(`Use the exact comment IDs: ${Array.from(commentIdToThreadId.keys()).join(', ')}`);
+    return { prompt: sections.join('\n'), commentIdToThreadId };
+}

package/dist/phases/pr-resolve/workspace.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Git workspace operations for PR resolve.
+ * Extracted for testability.
+ */
+/**
+ * Build git credential helper args for GitHub token auth.
+ */
+export declare function buildCredentialArgs(token: string): string[];
+/**
+ * Get the workspace path for a PR resolve operation.
+ */
+export declare function getResolveWorkspacePath(prNumber: number): string;
+/**
+ * Clone or reuse a repo for PR resolve.
+ * Returns the workspace path.
+ */
+export declare function prepareWorkspace(owner: string, repo: string, headRef: string, prNumber: number, token: string, verbose?: boolean): string;
+/**
+ * Push changes from workspace back to remote.
+ */
+export declare function pushChanges(repoPath: string, headRef: string, token: string, verbose?: boolean): boolean;
+/**
+ * Check if there are uncommitted changes in the workspace.
+ */
+export declare function hasUncommittedChanges(repoPath: string): boolean;
+/**
+ * Check if there are new commits ahead of remote.
+ */
+export declare function hasNewCommits(repoPath: string, headRef: string): boolean;

package/dist/phases/pr-resolve/workspace.js

@@ -0,0 +1,145 @@
+/**
+ * Git workspace operations for PR resolve.
+ * Extracted for testability.
+ */
+import { execFileSync, execSync } from 'child_process';
+import { existsSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+import { logError, logInfo, logSuccess } from '../../utils/logger.js';
+/**
+ * Build git credential helper args for GitHub token auth.
+ */
+export function buildCredentialArgs(token) {
+    const credentialHelper = `!f() { echo "username=x-access-token"; echo "password=${token}"; }; f`;
+    return [
+        '-c',
+        'credential.helper=',
+        '-c',
+        `credential.helper=${credentialHelper}`,
+    ];
+}
+/**
+ * Get the workspace path for a PR resolve operation.
+ */
+export function getResolveWorkspacePath(prNumber) {
+    return join(homedir(), 'edsger', `pr-resolve-${prNumber}`);
+}
+/**
+ * Clone or reuse a repo for PR resolve.
+ * Returns the workspace path.
+ */
+export function prepareWorkspace(owner, repo, headRef, prNumber, token, verbose) {
+    const repoPath = getResolveWorkspacePath(prNumber);
+    const repoUrl = `https://github.com/${owner}/${repo}.git`;
+    const gitCredentialArgs = buildCredentialArgs(token);
+    if (existsSync(join(repoPath, '.git'))) {
+        logInfo(`Reusing existing repo at ${repoPath}`);
+        try {
+            execSync(`git remote set-url origin "${repoUrl}"`, {
+                cwd: repoPath,
+                stdio: 'pipe',
+            });
+        }
+        catch {
+            // ignore
+        }
+        try {
+            execFileSync('git', [...gitCredentialArgs, 'fetch', 'origin'], {
+                cwd: repoPath,
+                stdio: 'pipe',
+            });
+        }
+        catch {
+            logError('Could not fetch latest changes');
+        }
+        try {
+            execSync(`git checkout ${headRef}`, { cwd: repoPath, stdio: 'pipe' });
+            execSync(`git reset --hard origin/${headRef}`, {
+                cwd: repoPath,
+                stdio: 'pipe',
+            });
+        }
+        catch {
+            logError(`Could not checkout branch ${headRef}`);
+        }
+    }
+    else {
+        logInfo(`Cloning ${owner}/${repo} (branch: ${headRef})...`);
+        execFileSync('git', [
+            ...gitCredentialArgs,
+            'clone',
+            '--branch',
+            headRef,
+            '--single-branch',
+            repoUrl,
+            repoPath,
+        ], { stdio: 'pipe' });
+        logSuccess(`Cloned to ${repoPath}`);
+    }
+    // Configure git user for commits
+    try {
+        execSync('git config user.email "edsger-bot@edsger.ai"', {
+            cwd: repoPath,
+            stdio: 'pipe',
+        });
+        execSync('git config user.name "Edsger Bot"', {
+            cwd: repoPath,
+            stdio: 'pipe',
+        });
+    }
+    catch {
+        if (verbose) {
+            logInfo('Note: Could not set git user config');
+        }
+    }
+    return repoPath;
+}
+/**
+ * Push changes from workspace back to remote.
+ */
+export function pushChanges(repoPath, headRef, token, verbose) {
+    const gitCredentialArgs = buildCredentialArgs(token);
+    try {
+        execFileSync('git', [...gitCredentialArgs, 'push', 'origin', headRef], {
+            cwd: repoPath,
+            stdio: 'pipe',
+        });
+        logSuccess('Pushed changes to remote');
+        return true;
+    }
+    catch (error) {
+        logError(`Failed to push: ${error instanceof Error ? error.message : String(error)}`);
+        return false;
+    }
+}
+/**
+ * Check if there are uncommitted changes in the workspace.
+ */
+export function hasUncommittedChanges(repoPath) {
+    try {
+        const result = execSync('git status --porcelain', {
+            cwd: repoPath,
+            encoding: 'utf-8',
+        });
+        return result.trim().length > 0;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Check if there are new commits ahead of remote.
+ */
+export function hasNewCommits(repoPath, headRef) {
+    try {
+        const result = execSync(`git log origin/${headRef}..HEAD --oneline`, {
+            cwd: repoPath,
+            encoding: 'utf-8',
+        });
+        return result.trim().length > 0;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/phases/pr-review/__tests__/prompts.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/phases/pr-review/__tests__/prompts.test.js

@@ -0,0 +1,49 @@
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+import { createStandaloneReviewSystemPrompt, createStandaloneReviewUserPrompt, } from '../prompts.js';
+describe('createStandaloneReviewSystemPrompt', () => {
+    it('includes review focus areas', () => {
+        const prompt = createStandaloneReviewSystemPrompt();
+        assert.ok(prompt.includes('Code Quality'));
+        assert.ok(prompt.includes('Security'));
+        assert.ok(prompt.includes('Performance'));
+    });
+    it('specifies JSON result format', () => {
+        const prompt = createStandaloneReviewSystemPrompt();
+        assert.ok(prompt.includes('review_result'));
+        assert.ok(prompt.includes('"file"'));
+        assert.ok(prompt.includes('"line"'));
+        assert.ok(prompt.includes('"comment"'));
+    });
+    it('includes assessment options', () => {
+        const prompt = createStandaloneReviewSystemPrompt();
+        assert.ok(prompt.includes('APPROVE'));
+        assert.ok(prompt.includes('REQUEST_CHANGES'));
+        assert.ok(prompt.includes('COMMENT'));
+    });
+    it('does not include feature/checklist instructions', () => {
+        const prompt = createStandaloneReviewSystemPrompt();
+        assert.ok(!prompt.includes('checklist'));
+        assert.ok(!prompt.includes('feature_id'));
+        assert.ok(!prompt.includes('user stories'));
+    });
+});
+describe('createStandaloneReviewUserPrompt', () => {
+    it('includes context info in the prompt', () => {
+        const contextInfo = '# Pull Request\n**Title**: Fix auth bug\n';
+        const prompt = createStandaloneReviewUserPrompt(contextInfo);
+        assert.ok(prompt.includes('Fix auth bug'));
+    });
+    it('includes review instructions', () => {
+        const prompt = createStandaloneReviewUserPrompt('some context');
+        assert.ok(prompt.includes('Analyze Each File'));
+        assert.ok(prompt.includes('Identify Issues'));
+        assert.ok(prompt.includes('Actionable Feedback'));
+    });
+    it('mentions severity categories', () => {
+        const prompt = createStandaloneReviewUserPrompt('context');
+        assert.ok(prompt.includes('Critical'));
+        assert.ok(prompt.includes('Major'));
+        assert.ok(prompt.includes('Minor'));
+    });
+});

package/dist/phases/pr-review/__tests__/review-comments.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/phases/pr-review/__tests__/review-comments.test.js

@@ -0,0 +1,108 @@
+/**
+ * Integration-level tests for the review comment mapping logic.
+ * Tests the flow: agent JSON result → diff position mapping → GitHub comment payload.
+ */
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+import { buildLineToPositionMap, findClosestPosition, } from '../../code-review/diff-utils.js';
+// Simulate the comment mapping logic from reviewStandalonePR
+function mapCommentsToReviewPayload(agentComments, files) {
+    // Build line-to-position maps
+    const fileLineToPosition = new Map();
+    for (const file of files) {
+        if (file.patch) {
+            fileLineToPosition.set(file.filename, buildLineToPositionMap(file.patch));
+        }
+    }
+    const result = [];
+    for (const comment of agentComments) {
+        const lineToPosition = fileLineToPosition.get(comment.file);
+        if (!lineToPosition)
+            continue;
+        const positionResult = findClosestPosition(comment.line, lineToPosition);
+        if (!positionResult)
+            continue;
+        let body = comment.comment;
+        if (positionResult.actualLine !== comment.line) {
+            body = `**Note**: Comment originally for line ${comment.line}, adjusted to line ${positionResult.actualLine} (nearest line in diff).\n\n${body}`;
+        }
+        result.push({
+            path: comment.file,
+            position: positionResult.position,
+            body,
+        });
+    }
+    return result;
+}
+describe('review comment mapping (integration)', () => {
+    const samplePatch = `@@ -1,5 +1,7 @@
+ import { useState } from 'react'
+
++const MAX_RETRIES = 3
++
+ export function App() {
+-  const [count, setCount] = useState(0)
++  const [count, setCount] = useState<number>(0)
+   return <div>{count}</div>`;
+    const files = [{ filename: 'src/App.tsx', patch: samplePatch }];
+    it('maps exact line comments to correct diff positions', () => {
+        const comments = [
+            {
+                file: 'src/App.tsx',
+                line: 3,
+                comment: 'Consider making this configurable',
+            },
+        ];
+        const result = mapCommentsToReviewPayload(comments, files);
+        assert.strictEqual(result.length, 1);
+        assert.strictEqual(result[0].path, 'src/App.tsx');
+        assert.ok(result[0].position > 0);
+        assert.ok(result[0].body.includes('Consider making this configurable'));
+        // No "Note" prefix since line was exact
+        assert.ok(!result[0].body.includes('**Note**'));
+    });
+    it('adjusts line numbers when exact line not in diff', () => {
+        // Line 2 is blank (in diff) but line 100 is way outside
+        const comments = [{ file: 'src/App.tsx', line: 8, comment: 'Fix this' }];
+        const result = mapCommentsToReviewPayload(comments, files);
+        // Line 8 should find closest in range
+        if (result.length > 0) {
+            assert.ok(result[0].body.includes('**Note**'));
+        }
+        // If no match within range, it's filtered out - also valid
+    });
+    it('filters out comments for files not in diff', () => {
+        const comments = [
+            {
+                file: 'src/other.ts',
+                line: 5,
+                comment: 'This file is not in the diff',
+            },
+        ];
+        const result = mapCommentsToReviewPayload(comments, files);
+        assert.strictEqual(result.length, 0);
+    });
+    it('handles multiple comments on same file', () => {
+        const comments = [
+            { file: 'src/App.tsx', line: 3, comment: 'Comment A' },
+            { file: 'src/App.tsx', line: 6, comment: 'Comment B' },
+        ];
+        const result = mapCommentsToReviewPayload(comments, files);
+        assert.strictEqual(result.length, 2);
+        assert.ok(result[0].body.includes('Comment A'));
+        assert.ok(result[1].body.includes('Comment B'));
+    });
+    it('handles files with no patch (binary files)', () => {
+        const binaryFiles = [
+            { filename: 'image.png' }, // no patch
+            { filename: 'src/App.tsx', patch: samplePatch },
+        ];
+        const comments = [
+            { file: 'image.png', line: 1, comment: 'Binary comment' },
+            { file: 'src/App.tsx', line: 3, comment: 'Code comment' },
+        ];
+        const result = mapCommentsToReviewPayload(comments, binaryFiles);
+        assert.strictEqual(result.length, 1);
+        assert.strictEqual(result[0].path, 'src/App.tsx');
+    });
+});