edsger 0.40.1 → 0.41.0

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

@@ -0,0 +1,116 @@
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+import { createResolveSystemPrompt, createResolveUserPrompt, } from '../prompts.js';
+function makeThread(id, overrides) {
+    const nodes = [
+        {
+            id: `${id}-comment-1`,
+            author: { login: overrides?.author || 'reviewer' },
+            body: overrides?.body || 'Please fix this',
+            path: overrides?.path || 'src/index.ts',
+            line: overrides?.line ?? 10,
+            url: `https://github.com/owner/repo/pull/1#discussion_${id}`,
+        },
+    ];
+    if (overrides?.followUps) {
+        for (const fu of overrides.followUps) {
+            nodes.push({
+                id: `${id}-followup`,
+                author: { login: fu.author },
+                body: fu.body,
+                path: overrides?.path || 'src/index.ts',
+                line: overrides?.line ?? 10,
+                url: `https://github.com/owner/repo/pull/1#discussion_${id}_fu`,
+            });
+        }
+    }
+    return {
+        id,
+        isResolved: false,
+        isOutdated: false,
+        comments: {
+            totalCount: nodes.length,
+            nodes,
+        },
+    };
+}
+describe('createResolveSystemPrompt', () => {
+    it('includes decision criteria', () => {
+        const prompt = createResolveSystemPrompt();
+        assert.ok(prompt.includes('Make the change when'));
+        assert.ok(prompt.includes('Skip the change when'));
+    });
+    it('specifies comment_id format', () => {
+        const prompt = createResolveSystemPrompt();
+        assert.ok(prompt.includes('comment_id'));
+        assert.ok(prompt.includes('comment_1'));
+    });
+    it('includes result format', () => {
+        const prompt = createResolveSystemPrompt();
+        assert.ok(prompt.includes('resolve_result'));
+        assert.ok(prompt.includes('"action"'));
+        assert.ok(prompt.includes('"reply"'));
+    });
+});
+describe('createResolveUserPrompt', () => {
+    it('uses sequential comment IDs not thread IDs', () => {
+        const threads = [makeThread('PRRT_kwDOxx_1'), makeThread('PRRT_kwDOxx_2')];
+        const { prompt, commentIdToThreadId } = createResolveUserPrompt(threads);
+        // Should use comment_1, comment_2 in the prompt
+        assert.ok(prompt.includes('## comment_1'));
+        assert.ok(prompt.includes('## comment_2'));
+        // Should NOT include opaque GraphQL IDs
+        assert.ok(!prompt.includes('PRRT_kwDOxx_1'));
+        assert.ok(!prompt.includes('PRRT_kwDOxx_2'));
+        // Mapping should be correct
+        assert.strictEqual(commentIdToThreadId.get('comment_1'), 'PRRT_kwDOxx_1');
+        assert.strictEqual(commentIdToThreadId.get('comment_2'), 'PRRT_kwDOxx_2');
+        assert.strictEqual(commentIdToThreadId.size, 2);
+    });
+    it('includes file path and line number', () => {
+        const threads = [makeThread('t1', { path: 'src/auth.ts', line: 42 })];
+        const { prompt } = createResolveUserPrompt(threads);
+        assert.ok(prompt.includes('src/auth.ts'));
+        assert.ok(prompt.includes('42'));
+    });
+    it('includes comment body', () => {
+        const threads = [
+            makeThread('t1', { body: 'This should use a const instead of let' }),
+        ];
+        const { prompt } = createResolveUserPrompt(threads);
+        assert.ok(prompt.includes('This should use a const instead of let'));
+    });
+    it('includes follow-up comments', () => {
+        const threads = [
+            makeThread('t1', {
+                body: 'Main comment',
+                followUps: [{ author: 'dev', body: 'I disagree because...' }],
+            }),
+        ];
+        const { prompt } = createResolveUserPrompt(threads);
+        assert.ok(prompt.includes('Main comment'));
+        assert.ok(prompt.includes('I disagree because...'));
+        assert.ok(prompt.includes('@dev'));
+    });
+    it('includes instruction to use exact comment IDs', () => {
+        const threads = [makeThread('t1'), makeThread('t2'), makeThread('t3')];
+        const { prompt } = createResolveUserPrompt(threads);
+        assert.ok(prompt.includes('comment_1, comment_2, comment_3'));
+    });
+    it('handles threads with no comments gracefully', () => {
+        const emptyThread = {
+            id: 'empty',
+            isResolved: false,
+            isOutdated: false,
+            comments: { totalCount: 0, nodes: [] },
+        };
+        const { commentIdToThreadId } = createResolveUserPrompt([emptyThread]);
+        // Empty thread should be skipped (no comment nodes to index)
+        assert.strictEqual(commentIdToThreadId.size, 0);
+    });
+    it('returns correct count in header', () => {
+        const threads = [makeThread('t1'), makeThread('t2')];
+        const { prompt } = createResolveUserPrompt(threads);
+        assert.ok(prompt.includes('2 unresolved review comment(s)'));
+    });
+});

package/dist/phases/pr-resolve/__tests__/resolve-mapping.test.d.ts

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

package/dist/phases/pr-resolve/__tests__/resolve-mapping.test.js

@@ -0,0 +1,138 @@
+/**
+ * Integration-level tests for the resolve comment→thread mapping logic.
+ * Tests the flow: agent JSON result → comment_id to thread_id mapping → reply decisions.
+ */
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+import { createResolveUserPrompt } from '../prompts.js';
+// Simulate the mapping logic from resolveStandalonePR
+function processResolveResult(comments, commentIdToThreadId) {
+    const addressed = [];
+    const skipped = [];
+    const errors = [];
+    for (const comment of comments) {
+        const threadId = commentIdToThreadId.get(comment.comment_id);
+        if (!threadId) {
+            errors.push(`Unknown comment_id "${comment.comment_id}"`);
+            continue;
+        }
+        if (comment.action === 'changed') {
+            addressed.push({ threadId, reply: comment.reply });
+        }
+        else {
+            skipped.push({ threadId, reply: comment.reply });
+        }
+    }
+    return { addressed, skipped, errors };
+}
+function makeThread(id, body) {
+    return {
+        id,
+        isResolved: false,
+        isOutdated: false,
+        comments: {
+            totalCount: 1,
+            nodes: [
+                {
+                    id: `${id}-c1`,
+                    author: { login: 'reviewer' },
+                    body,
+                    path: 'src/index.ts',
+                    line: 10,
+                    url: '',
+                },
+            ],
+        },
+    };
+}
+describe('resolve comment→thread mapping (integration)', () => {
+    it('correctly maps comment_ids to thread IDs', () => {
+        const threads = [
+            makeThread('PRRT_aaa', 'Use const'),
+            makeThread('PRRT_bbb', 'Add error handling'),
+            makeThread('PRRT_ccc', 'Remove unused import'),
+        ];
+        const { commentIdToThreadId } = createResolveUserPrompt(threads);
+        const agentResult = [
+            {
+                comment_id: 'comment_1',
+                action: 'changed',
+                reply: 'Done, switched to const',
+            },
+            { comment_id: 'comment_2', action: 'changed', reply: 'Added try/catch' },
+            {
+                comment_id: 'comment_3',
+                action: 'skipped',
+                reply: 'Import is used in tests',
+            },
+        ];
+        const result = processResolveResult(agentResult, commentIdToThreadId);
+        assert.strictEqual(result.addressed.length, 2);
+        assert.strictEqual(result.skipped.length, 1);
+        assert.strictEqual(result.errors.length, 0);
+        // Verify thread ID mapping
+        assert.strictEqual(result.addressed[0].threadId, 'PRRT_aaa');
+        assert.strictEqual(result.addressed[1].threadId, 'PRRT_bbb');
+        assert.strictEqual(result.skipped[0].threadId, 'PRRT_ccc');
+    });
+    it('reports errors for unknown comment_ids', () => {
+        const threads = [makeThread('PRRT_aaa', 'Fix bug')];
+        const { commentIdToThreadId } = createResolveUserPrompt(threads);
+        const agentResult = [
+            { comment_id: 'comment_1', action: 'changed', reply: 'Fixed' },
+            { comment_id: 'comment_99', action: 'changed', reply: 'Unknown' },
+        ];
+        const result = processResolveResult(agentResult, commentIdToThreadId);
+        assert.strictEqual(result.addressed.length, 1);
+        assert.strictEqual(result.errors.length, 1);
+        assert.ok(result.errors[0].includes('comment_99'));
+    });
+    it('handles agent returning partial results', () => {
+        const threads = [
+            makeThread('PRRT_aaa', 'Fix A'),
+            makeThread('PRRT_bbb', 'Fix B'),
+            makeThread('PRRT_ccc', 'Fix C'),
+        ];
+        const { commentIdToThreadId } = createResolveUserPrompt(threads);
+        // Agent only addressed 2 of 3
+        const agentResult = [
+            { comment_id: 'comment_1', action: 'changed', reply: 'Done' },
+            { comment_id: 'comment_3', action: 'skipped', reply: 'No change needed' },
+        ];
+        const result = processResolveResult(agentResult, commentIdToThreadId);
+        assert.strictEqual(result.addressed.length, 1);
+        assert.strictEqual(result.skipped.length, 1);
+        assert.strictEqual(result.errors.length, 0);
+        // comment_2 was not mentioned - no error, just not processed
+    });
+    it('handles empty agent result', () => {
+        const threads = [makeThread('PRRT_aaa', 'Fix')];
+        const { commentIdToThreadId } = createResolveUserPrompt(threads);
+        const result = processResolveResult([], commentIdToThreadId);
+        assert.strictEqual(result.addressed.length, 0);
+        assert.strictEqual(result.skipped.length, 0);
+        assert.strictEqual(result.errors.length, 0);
+    });
+    it('preserves reply text in all cases', () => {
+        const threads = [
+            makeThread('PRRT_aaa', 'Fix this'),
+            makeThread('PRRT_bbb', 'Change that'),
+        ];
+        const { commentIdToThreadId } = createResolveUserPrompt(threads);
+        const agentResult = [
+            {
+                comment_id: 'comment_1',
+                action: 'changed',
+                reply: 'Switched to const as suggested. Good catch.',
+            },
+            {
+                comment_id: 'comment_2',
+                action: 'skipped',
+                reply: 'The current approach is better because it allows lazy initialization which is needed for the singleton pattern.',
+            },
+        ];
+        const result = processResolveResult(agentResult, commentIdToThreadId);
+        assert.ok(result.addressed[0].reply.includes('Good catch'));
+        assert.ok(result.skipped[0].reply.includes('singleton pattern'));
+    });
+});

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

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

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

@@ -0,0 +1,111 @@
+import assert from 'node:assert';
+import { execSync } from 'node:child_process';
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, beforeEach, describe, it } from 'node:test';
+import { buildCredentialArgs, hasNewCommits, hasUncommittedChanges, } from '../workspace.js';
+// Helper: create a temp git repo with an initial commit
+function createTempRepo() {
+    const dir = mkdtempSync(join(tmpdir(), 'edsger-test-'));
+    execSync('git init', { cwd: dir, stdio: 'pipe' });
+    execSync('git config user.email "test@test.com"', { cwd: dir, stdio: 'pipe' });
+    execSync('git config user.name "Test"', { cwd: dir, stdio: 'pipe' });
+    writeFileSync(join(dir, 'README.md'), '# Test');
+    execSync('git add .', { cwd: dir, stdio: 'pipe' });
+    execSync('git commit -m "init"', { cwd: dir, stdio: 'pipe' });
+    return dir;
+}
+describe('buildCredentialArgs', () => {
+    it('returns 4 args with credential helper config', () => {
+        const args = buildCredentialArgs('my-token');
+        assert.strictEqual(args.length, 4);
+        assert.strictEqual(args[0], '-c');
+        assert.strictEqual(args[1], 'credential.helper=');
+        assert.strictEqual(args[2], '-c');
+        assert.ok(args[3].includes('my-token'));
+        assert.ok(args[3].includes('x-access-token'));
+    });
+    it('escapes token in credential helper', () => {
+        const args = buildCredentialArgs('token-with-special-chars!@#');
+        assert.ok(args[3].includes('token-with-special-chars!@#'));
+    });
+});
+describe('hasUncommittedChanges', () => {
+    let repoPath;
+    beforeEach(() => {
+        repoPath = createTempRepo();
+    });
+    afterEach(() => {
+        rmSync(repoPath, { recursive: true, force: true });
+    });
+    it('returns false for clean repo', () => {
+        assert.strictEqual(hasUncommittedChanges(repoPath), false);
+    });
+    it('returns true after modifying a file', () => {
+        writeFileSync(join(repoPath, 'README.md'), '# Modified');
+        assert.strictEqual(hasUncommittedChanges(repoPath), true);
+    });
+    it('returns true for new untracked file', () => {
+        writeFileSync(join(repoPath, 'new-file.txt'), 'content');
+        assert.strictEqual(hasUncommittedChanges(repoPath), true);
+    });
+    it('returns false after staging and committing', () => {
+        writeFileSync(join(repoPath, 'new.txt'), 'x');
+        execSync('git add . && git commit -m "add"', {
+            cwd: repoPath,
+            stdio: 'pipe',
+        });
+        assert.strictEqual(hasUncommittedChanges(repoPath), false);
+    });
+    it('returns false for non-existent path', () => {
+        assert.strictEqual(hasUncommittedChanges('/tmp/nonexistent-repo-xyz'), false);
+    });
+});
+describe('hasNewCommits', () => {
+    let repoPath;
+    let bareRemote;
+    beforeEach(() => {
+        // Create a bare remote and clone it
+        bareRemote = mkdtempSync(join(tmpdir(), 'edsger-remote-'));
+        execSync('git init --bare', { cwd: bareRemote, stdio: 'pipe' });
+        repoPath = mkdtempSync(join(tmpdir(), 'edsger-clone-'));
+        rmSync(repoPath, { recursive: true });
+        execSync(`git clone "${bareRemote}" "${repoPath}"`, { stdio: 'pipe' });
+        execSync('git config user.email "test@test.com"', {
+            cwd: repoPath,
+            stdio: 'pipe',
+        });
+        execSync('git config user.name "Test"', { cwd: repoPath, stdio: 'pipe' });
+        // Create initial commit and push
+        writeFileSync(join(repoPath, 'README.md'), '# Test');
+        execSync('git add . && git commit -m "init"', {
+            cwd: repoPath,
+            stdio: 'pipe',
+        });
+        execSync('git push origin main', { cwd: repoPath, stdio: 'pipe' });
+    });
+    afterEach(() => {
+        rmSync(repoPath, { recursive: true, force: true });
+        rmSync(bareRemote, { recursive: true, force: true });
+    });
+    it('returns false when HEAD matches remote', () => {
+        assert.strictEqual(hasNewCommits(repoPath, 'main'), false);
+    });
+    it('returns true after a local commit not pushed', () => {
+        writeFileSync(join(repoPath, 'new.txt'), 'hello');
+        execSync('git add . && git commit -m "local"', {
+            cwd: repoPath,
+            stdio: 'pipe',
+        });
+        assert.strictEqual(hasNewCommits(repoPath, 'main'), true);
+    });
+    it('returns false after pushing local commit', () => {
+        writeFileSync(join(repoPath, 'new.txt'), 'hello');
+        execSync('git add . && git commit -m "local" && git push origin main', {
+            cwd: repoPath,
+            stdio: 'pipe',
+        });
+        assert.strictEqual(hasNewCommits(repoPath, 'main'), false);
+    });
+});

package/dist/phases/pr-resolve/github-reply.d.ts

@@ -0,0 +1,13 @@
+/**
+ * GitHub API operations for PR resolve: reply to threads, resolve threads.
+ * Reuses GraphQL patterns from code-refine-verification.
+ */
+import { type Octokit } from '@octokit/rest';
+/**
+ * Reply to a review thread on GitHub using GraphQL.
+ */
+export declare function replyToReviewThread(octokit: Octokit, threadId: string, body: string, verbose?: boolean): Promise<boolean>;
+/**
+ * Resolve a review thread on GitHub using GraphQL.
+ */
+export declare function resolveReviewThread(octokit: Octokit, threadId: string, verbose?: boolean): Promise<boolean>;

package/dist/phases/pr-resolve/github-reply.js

@@ -0,0 +1,59 @@
+/**
+ * GitHub API operations for PR resolve: reply to threads, resolve threads.
+ * Reuses GraphQL patterns from code-refine-verification.
+ */
+import { logError, logInfo } from '../../utils/logger.js';
+/**
+ * Reply to a review thread on GitHub using GraphQL.
+ */
+export async function replyToReviewThread(octokit, threadId, body, verbose) {
+    try {
+        const mutation = `
+      mutation($threadId: ID!, $body: String!) {
+        addPullRequestReviewThreadReply(input: {
+          pullRequestReviewThreadId: $threadId
+          body: $body
+        }) {
+          comment {
+            id
+          }
+        }
+      }
+    `;
+        await octokit.graphql(mutation, { threadId, body });
+        if (verbose) {
+            logInfo(`Replied to thread ${threadId}`);
+        }
+        return true;
+    }
+    catch (error) {
+        logError(`Failed to reply to thread ${threadId}: ${error}`);
+        return false;
+    }
+}
+/**
+ * Resolve a review thread on GitHub using GraphQL.
+ */
+export async function resolveReviewThread(octokit, threadId, verbose) {
+    try {
+        const mutation = `
+      mutation($threadId: ID!) {
+        resolveReviewThread(input: {threadId: $threadId}) {
+          thread {
+            id
+            isResolved
+          }
+        }
+      }
+    `;
+        await octokit.graphql(mutation, { threadId });
+        if (verbose) {
+            logInfo(`Resolved thread ${threadId}`);
+        }
+        return true;
+    }
+    catch (error) {
+        logError(`Failed to resolve thread ${threadId}: ${error}`);
+        return false;
+    }
+}

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

@@ -0,0 +1,27 @@
+/**
+ * Standalone PR Resolve
+ * Evaluates unresolved review comments, fixes what's genuinely better,
+ * replies to every comment on GitHub explaining the decision.
+ */
+export interface StandalonePRResolveOptions {
+    productId: string;
+    pullRequestUrl: string;
+    githubToken: string;
+    owner: string;
+    repo: string;
+    prId?: string;
+    verbose?: boolean;
+}
+export interface PRResolveResult {
+    status: 'success' | 'error';
+    message: string;
+    threadsAddressed?: number;
+    threadsSkipped?: number;
+    threadsErrored?: number;
+    filesModified?: string[];
+    summary?: string;
+}
+/**
+ * Resolve PR change requests: evaluate each comment, fix or explain.
+ */
+export declare function resolveStandalonePR(options: StandalonePRResolveOptions): Promise<PRResolveResult>;