edsger 0.41.3 → 0.42.1

package/.claude/settings.local.json

@@ -1,28 +1,8 @@
 {
   "permissions": {
     "allow": [
-      "Read(//Users/steven/development/edsger/**)",
-      "Bash(npm run build)",
-      "Bash(node:*)",
-      "Bash(git add:*)",
-      "Bash(git commit:*)",
-      "Bash(ls:*)",
-      "Bash(cat:*)",
-      "Bash(npm run typecheck:*)",
-      "Bash(git diff:*)",
-      "WebSearch",
-      "WebFetch(domain:supabase.com)",
-      "Bash(npm install:*)",
-      "Bash(grep:*)",
-      "Bash(npx supabase gen types typescript --help:*)",
-      "Bash(git -C /Users/steven/development/edsger status)",
-      "Bash(git -C /Users/steven/development/edsger diff)",
-      "Bash(git -C /Users/steven/development/edsger log --oneline -5)",
-      "Bash(git -C /Users/steven/development/edsger add supabase/migrations/20251231000000_drop_unused_views.sql)",
-      "Bash(git -C /Users/steven/development/edsger commit -m \"$\\(cat <<''EOF''\nchore: drop unused database views\n\nRemove test_report_summary and user_stories_with_context views that are defined but never used in the application.\n\n🤖 Generated with [Claude Code]\\(https://claude.com/claude-code\\)\n\nCo-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>\nEOF\n\\)\")",
-      "Bash(git -C /Users/steven/development/edsger commit -m \"$\\(cat <<''EOF''\nchore: drop unused database views\n\nRemove test_report_summary and user_stories_with_context views\nthat are defined but never used in the application.\n\n🤖 Generated with [Claude Code]\\(https://claude.com/claude-code\\)\n\nCo-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>\nEOF\n\\)\")"
-    ],
-    "deny": [],
-    "ask": []
+      "Bash(npx tsc:*)",
+      "Bash(npm run:*)"
+    ]
   }
 }

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

@@ -6,5 +6,6 @@ export interface PRResolveCliOptions {
     prUrl: string;
     prId?: string;
     verbose?: boolean;
+    learn?: boolean;
 }
 export declare function runPRResolve(productId: string, options: PRResolveCliOptions): Promise<void>;

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

@@ -26,6 +26,7 @@ export async function runPRResolve(productId, options) {
         repo: githubConfig.repo,
         prId,
         verbose,
+        learn: options.learn,
     });
     if (result.status === 'success') {
         logSuccess(`PR resolve completed: ${result.message}`);

package/dist/index.js

@@ -299,6 +299,7 @@ program
     .description('AI-resolve change requests on a GitHub PR')
     .requiredOption('--pr-url <url>', 'GitHub PR URL')
     .option('--pr-id <id>', 'Pull request record ID in database')
+    .option('--no-learn', 'Skip checklist learning after resolve')
     .option('-v, --verbose', 'Verbose output')
     .action(async (productId, opts) => {
     try {

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

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

package/dist/phases/pr-resolve/__tests__/checklist-learner.test.js

@@ -0,0 +1,157 @@
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+import { buildLearnerPrompt } from '../checklist-learner.js';
+// ── helpers ──────────────────────────────────────────────────
+function makeThread(id, overrides) {
+    return {
+        id,
+        isResolved: false,
+        isOutdated: false,
+        comments: {
+            totalCount: 1,
+            nodes: [
+                {
+                    id: `${id}-c1`,
+                    author: { login: overrides?.author || 'reviewer' },
+                    body: overrides?.body || 'Please fix this',
+                    path: overrides?.path || 'src/index.ts',
+                    line: overrides && 'line' in overrides ? (overrides.line ?? null) : 10,
+                    url: `https://github.com/o/r/pull/1#${id}`,
+                },
+            ],
+        },
+    };
+}
+function makeMap(entries) {
+    return new Map(entries);
+}
+// ── buildLearnerPrompt ──────────────────────────────────────
+describe('buildLearnerPrompt', () => {
+    it('includes addressed comment count in header', () => {
+        const comments = [
+            { comment_id: 'comment_1', action: 'changed', reply: 'Fixed' },
+            { comment_id: 'comment_2', action: 'changed', reply: 'Done' },
+        ];
+        const threads = [makeThread('t1'), makeThread('t2')];
+        const map = makeMap([
+            ['comment_1', 't1'],
+            ['comment_2', 't2'],
+        ]);
+        const prompt = buildLearnerPrompt(comments, threads, map);
+        assert.ok(prompt.includes('2 review comment(s)'));
+    });
+    it('includes reviewer, file path, line, and comment body', () => {
+        const comments = [
+            { comment_id: 'comment_1', action: 'changed', reply: 'Added null check' },
+        ];
+        const threads = [
+            makeThread('t1', {
+                path: 'src/auth.ts',
+                line: 42,
+                body: 'Missing null check here',
+                author: 'alice',
+            }),
+        ];
+        const map = makeMap([['comment_1', 't1']]);
+        const prompt = buildLearnerPrompt(comments, threads, map);
+        assert.ok(prompt.includes('src/auth.ts'));
+        assert.ok(prompt.includes('42'));
+        assert.ok(prompt.includes('@alice'));
+        assert.ok(prompt.includes('Missing null check here'));
+        assert.ok(prompt.includes('Added null check'));
+    });
+    it('includes resolution text for each comment', () => {
+        const comments = [
+            {
+                comment_id: 'comment_1',
+                action: 'changed',
+                reply: 'Refactored to use try/catch',
+            },
+        ];
+        const threads = [makeThread('t1')];
+        const map = makeMap([['comment_1', 't1']]);
+        const prompt = buildLearnerPrompt(comments, threads, map);
+        assert.ok(prompt.includes('**Resolution**: Refactored to use try/catch'));
+    });
+    it('includes summary when provided', () => {
+        const comments = [
+            { comment_id: 'comment_1', action: 'changed', reply: 'Fixed' },
+        ];
+        const threads = [makeThread('t1')];
+        const map = makeMap([['comment_1', 't1']]);
+        const prompt = buildLearnerPrompt(comments, threads, map, 'Improved error handling across 3 files');
+        assert.ok(prompt.includes('## Overall Summary'));
+        assert.ok(prompt.includes('Improved error handling across 3 files'));
+    });
+    it('omits summary section when not provided', () => {
+        const comments = [
+            { comment_id: 'comment_1', action: 'changed', reply: 'Fixed' },
+        ];
+        const threads = [makeThread('t1')];
+        const map = makeMap([['comment_1', 't1']]);
+        const prompt = buildLearnerPrompt(comments, threads, map);
+        assert.ok(!prompt.includes('## Overall Summary'));
+    });
+    it('handles comment with no matching thread gracefully', () => {
+        const comments = [
+            { comment_id: 'comment_1', action: 'changed', reply: 'Fixed' },
+        ];
+        // Empty threads — no match for comment_1
+        const map = makeMap([['comment_1', 'nonexistent']]);
+        const prompt = buildLearnerPrompt(comments, [], map);
+        // Should still include the comment section with resolution
+        assert.ok(prompt.includes('## comment_1'));
+        assert.ok(prompt.includes('**Resolution**: Fixed'));
+        // Should NOT include reviewer info since thread was not found
+        assert.ok(!prompt.includes('**Reviewer**'));
+    });
+    it('handles comment_id not in map gracefully', () => {
+        const comments = [
+            { comment_id: 'comment_99', action: 'changed', reply: 'Fixed' },
+        ];
+        const prompt = buildLearnerPrompt(comments, [], new Map());
+        assert.ok(prompt.includes('## comment_99'));
+        assert.ok(prompt.includes('**Resolution**: Fixed'));
+    });
+    it('omits line when null', () => {
+        const comments = [
+            { comment_id: 'comment_1', action: 'changed', reply: 'Fixed' },
+        ];
+        const threads = [makeThread('t1', { line: null })];
+        const map = makeMap([['comment_1', 't1']]);
+        const prompt = buildLearnerPrompt(comments, threads, map);
+        assert.ok(prompt.includes('**File**: src/index.ts'));
+        assert.ok(!prompt.includes('**Line**'));
+    });
+    it('uses threadById map correctly for multiple comments', () => {
+        const comments = [
+            { comment_id: 'comment_1', action: 'changed', reply: 'Fix A' },
+            { comment_id: 'comment_3', action: 'changed', reply: 'Fix C' },
+        ];
+        const threads = [
+            makeThread('t1', { body: 'Issue A', path: 'a.ts' }),
+            makeThread('t2', { body: 'Issue B', path: 'b.ts' }),
+            makeThread('t3', { body: 'Issue C', path: 'c.ts' }),
+        ];
+        const map = makeMap([
+            ['comment_1', 't1'],
+            ['comment_2', 't2'],
+            ['comment_3', 't3'],
+        ]);
+        const prompt = buildLearnerPrompt(comments, threads, map);
+        assert.ok(prompt.includes('Issue A'));
+        assert.ok(prompt.includes('a.ts'));
+        assert.ok(prompt.includes('Issue C'));
+        assert.ok(prompt.includes('c.ts'));
+        // comment_2 was not in addressedComments, should not appear
+        assert.ok(!prompt.includes('Issue B'));
+    });
+    it('includes instructions section', () => {
+        const comments = [
+            { comment_id: 'comment_1', action: 'changed', reply: 'Fixed' },
+        ];
+        const prompt = buildLearnerPrompt(comments, [makeThread('t1')], makeMap([['comment_1', 't1']]));
+        assert.ok(prompt.includes('## Instructions'));
+        assert.ok(prompt.includes('code_review checklists'));
+    });
+});

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

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

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

@@ -0,0 +1,43 @@
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+import { isResolveResult } from '../types.js';
+describe('isResolveResult', () => {
+    it('returns true for valid ResolveResult', () => {
+        assert.ok(isResolveResult({
+            comments: [
+                { comment_id: 'comment_1', action: 'changed', reply: 'Fixed' },
+            ],
+        }));
+    });
+    it('returns true when optional fields are present', () => {
+        assert.ok(isResolveResult({
+            comments: [],
+            files_modified: ['a.ts'],
+            summary: 'Done',
+        }));
+    });
+    it('returns true for empty comments array', () => {
+        assert.ok(isResolveResult({ comments: [] }));
+    });
+    it('returns false for null', () => {
+        assert.ok(!isResolveResult(null));
+    });
+    it('returns false for undefined', () => {
+        assert.ok(!isResolveResult(undefined));
+    });
+    it('returns false for string', () => {
+        assert.ok(!isResolveResult('not an object'));
+    });
+    it('returns false for number', () => {
+        assert.ok(!isResolveResult(42));
+    });
+    it('returns false when comments is missing', () => {
+        assert.ok(!isResolveResult({ files_modified: ['a.ts'] }));
+    });
+    it('returns false when comments is not an array', () => {
+        assert.ok(!isResolveResult({ comments: 'not-array' }));
+    });
+    it('returns false for empty object', () => {
+        assert.ok(!isResolveResult({}));
+    });
+});

package/dist/phases/pr-resolve/checklist-learner.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Checklist Learner — runs after PR resolve to analyse addressed review
+ * comments and create / update code-review checklists so the same issues
+ * don't recur.
+ *
+ * Uses the Claude Agent SDK with the existing checklist MCP tools.
+ * Strictly non-blocking: failures only log a warning.
+ */
+import { type ReviewThread } from '../code-refine-verification/types.js';
+import { type ResolveComment, type ResolveResult } from './types.js';
+export interface ChecklistLearnerInput {
+    productId: string;
+    unresolvedThreads: ReviewThread[];
+    resolveResult: ResolveResult;
+    /** Maps comment_id (e.g. "comment_1") → GraphQL thread ID */
+    commentIdToThreadId: Map<string, string>;
+    verbose?: boolean;
+}
+/**
+ * Build a user prompt from the addressed review comments.
+ * @param addressedComments - pre-filtered list of comments with action === 'changed'
+ */
+export declare function buildLearnerPrompt(addressedComments: ResolveComment[], unresolvedThreads: ReviewThread[], commentIdToThreadId: Map<string, string>, summary?: string): string;
+/**
+ * Analyse addressed review comments and update code-review checklists.
+ * Non-blocking — catches all errors and logs a warning.
+ */
+export declare function learnFromReviewFeedback(input: ChecklistLearnerInput): Promise<void>;

package/dist/phases/pr-resolve/checklist-learner.js

@@ -0,0 +1,128 @@
+/**
+ * Checklist Learner — runs after PR resolve to analyse addressed review
+ * comments and create / update code-review checklists so the same issues
+ * don't recur.
+ *
+ * Uses the Claude Agent SDK with the existing checklist MCP tools.
+ * Strictly non-blocking: failures only log a warning.
+ */
+import { query } from '@anthropic-ai/claude-agent-sdk';
+import { createChecklistsMcpServer } from '../../commands/checklists/tools.js';
+import { logInfo, logWarning } from '../../utils/logger.js';
+const LEARNER_SYSTEM_PROMPT = `You are a software quality engineer. Your task is to analyse review comments that were addressed during a PR resolve and distil them into actionable checklist items for the code_review phase.
+
+## Workflow
+
+1. **Read** the addressed review comments provided below.
+2. **Query existing checklists** using \`list_checklists\` with phase "code_review" to see what already exists.
+3. **Identify patterns** — group related comments into categories (e.g., error handling, naming, security, performance, testing).
+4. **Update or create checklist items**:
+   - If an existing checklist covers the category, add new items to it (skip if a similar item already exists).
+   - If no suitable checklist exists, create a new one.
+5. **Summarise** what you added or updated.
+
+## Rules
+
+- Only create items for **genuine quality patterns** — things that should be checked in every code review.
+- Skip one-off nits, purely stylistic preferences, or context-specific fixes that won't generalise.
+- Role: \`developer\`
+- Phases: \`["code_review"]\`
+- Item type: \`boolean\` (yes/no checkable)
+- Keep item titles concise (< 80 chars). Use the description for details.
+- Do NOT duplicate items that already exist in the checklists.
+- If all comments are too specific to generalise, it's fine to add nothing — just say so.
+`;
+/**
+ * Build a user prompt from the addressed review comments.
+ * @param addressedComments - pre-filtered list of comments with action === 'changed'
+ */
+export function buildLearnerPrompt(addressedComments, unresolvedThreads, commentIdToThreadId, summary) {
+    // Build a reverse lookup: threadId → thread for O(1) access
+    const threadById = new Map();
+    for (const thread of unresolvedThreads) {
+        threadById.set(thread.id, thread);
+    }
+    const sections = [
+        '# Addressed PR Review Comments',
+        '',
+        `${addressedComments.length} review comment(s) were accepted and fixed during PR resolution.`,
+        `Analyse these to identify patterns that should become checklist items for future code reviews.`,
+        '',
+    ];
+    for (const comment of addressedComments) {
+        const threadId = commentIdToThreadId.get(comment.comment_id);
+        const thread = threadId ? threadById.get(threadId) : undefined;
+        const firstNode = thread?.comments.nodes[0];
+        sections.push(`## ${comment.comment_id}`);
+        if (firstNode) {
+            sections.push(`**File**: ${firstNode.path}`);
+            if (firstNode.line) {
+                sections.push(`**Line**: ${firstNode.line}`);
+            }
+            sections.push(`**Reviewer**: @${firstNode.author.login}`);
+            sections.push(`**Review comment**:`);
+            sections.push(firstNode.body);
+        }
+        sections.push(`**Resolution**: ${comment.reply}`);
+        sections.push('');
+    }
+    if (summary) {
+        sections.push('## Overall Summary');
+        sections.push(summary);
+        sections.push('');
+    }
+    sections.push('## Instructions');
+    sections.push('Based on the patterns above, query existing code_review checklists and create or update items to prevent these issues from recurring.');
+    return sections.join('\n');
+}
+/**
+ * Analyse addressed review comments and update code-review checklists.
+ * Non-blocking — catches all errors and logs a warning.
+ */
+export async function learnFromReviewFeedback(input) {
+    try {
+        const { resolveResult, unresolvedThreads, commentIdToThreadId, verbose, productId, } = input;
+        // Filter once — only learn from accepted changes
+        const addressedComments = resolveResult.comments.filter((c) => c.action === 'changed');
+        if (addressedComments.length === 0) {
+            if (verbose) {
+                logInfo('No addressed comments to learn from, skipping checklist sync.');
+            }
+            return;
+        }
+        logInfo(`Learning from ${addressedComments.length} addressed review comment(s) to update checklists...`);
+        const userPrompt = buildLearnerPrompt(addressedComments, unresolvedThreads, commentIdToThreadId, resolveResult.summary);
+        const mcpServer = createChecklistsMcpServer(productId);
+        for await (const message of query({
+            prompt: userPrompt,
+            options: {
+                systemPrompt: {
+                    type: 'preset',
+                    preset: 'claude_code',
+                    append: LEARNER_SYSTEM_PROMPT,
+                },
+                model: 'sonnet',
+                maxTurns: 15,
+                permissionMode: 'bypassPermissions',
+                mcpServers: {
+                    'edsger-checklists': mcpServer,
+                },
+            },
+        })) {
+            if (message.type === 'result') {
+                if (message.subtype === 'success') {
+                    logInfo('Checklist learning completed.');
+                    if (verbose && message.result) {
+                        logInfo(message.result);
+                    }
+                }
+                else if (verbose) {
+                    logWarning(`Checklist learning incomplete: ${message.subtype}`);
+                }
+            }
+        }
+    }
+    catch (error) {
+        logWarning(`Checklist learning failed (non-blocking): ${error instanceof Error ? error.message : String(error)}`);
+    }
+}

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

@@ -11,6 +11,8 @@ export interface StandalonePRResolveOptions {
     repo: string;
     prId?: string;
     verbose?: boolean;
+    /** Set to false to skip checklist learning after resolve (default: true) */
+    learn?: boolean;
 }
 export interface PRResolveResult {
     status: 'success' | 'error';
@@ -21,6 +23,8 @@ export interface PRResolveResult {
     filesModified?: string[];
     summary?: string;
 }
+export type { ResolveComment, ResolveResult } from './types.js';
+export { isResolveResult } from './types.js';
 /**
  * Resolve PR change requests: evaluate each comment, fix or explain.
  */

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

@@ -13,9 +13,12 @@ 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 { learnFromReviewFeedback } from './checklist-learner.js';
 import { replyToReviewThread, resolveReviewThread } from './github-reply.js';
 import { createResolveSystemPrompt, createResolveUserPrompt, } from './prompts.js';
+import { isResolveResult } from './types.js';
 import { hasNewCommits, hasUncommittedChanges, prepareWorkspace, pushChanges, } from './workspace.js';
+export { isResolveResult } from './types.js';
 /**
  * Resolve PR change requests: evaluate each comment, fix or explain.
  */
@@ -50,14 +53,30 @@ export async function resolveStandalonePR(options) {
             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);
+        // Determine clone source: fork PRs need to clone from the fork repo.
+        // head.repo is null when the fork has been deleted — treat as fork with deleted source.
+        const isFork = !prData.head.repo ||
+            prData.head.repo.full_name !== prData.base.repo.full_name;
+        const forkDeleted = !prData.head.repo;
+        const cloneOwner = isFork && !forkDeleted ? prData.head.repo.owner.login : owner;
+        const cloneRepo = isFork && !forkDeleted ? prData.head.repo.name : repo;
+        if (isFork && verbose) {
+            logInfo(forkDeleted
+                ? `Fork PR detected but fork repo has been deleted, will use PR ref from ${owner}/${repo}`
+                : `Fork PR detected: cloning from ${cloneOwner}/${cloneRepo} instead of ${owner}/${repo}`);
+        }
+        // Clone repo and checkout PR branch.
+        // For fork PRs, pass fallback info so prepareWorkspace can fetch the PR ref
+        // from upstream if the fork branch is unavailable.
+        // For deleted forks, clone upstream directly and always use PR ref fallback.
+        const repoPath = prepareWorkspace(cloneOwner, cloneRepo, headRef, prInfo.prNumber, githubToken, verbose, isFork
+            ? { upstreamOwner: owner, upstreamRepo: repo }
+            : undefined);
         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({
@@ -84,8 +103,11 @@ export async function resolveStandalonePR(options) {
                 if (message.subtype === 'success') {
                     logInfo('Agent completed, parsing results...');
                     const responseText = message.result || lastAssistantResponse;
-                    resolveResult = tryExtractResult(responseText, 'resolve_result');
-                    if (!resolveResult) {
+                    const parsed = tryExtractResult(responseText, 'resolve_result');
+                    if (isResolveResult(parsed)) {
+                        resolveResult = parsed;
+                    }
+                    else {
                         logError('Failed to parse resolve result JSON');
                     }
                 }
@@ -93,7 +115,10 @@ export async function resolveStandalonePR(options) {
                     logError(`Agent incomplete: ${message.subtype}`);
                     // Try to salvage partial results from last response
                     if (lastAssistantResponse) {
-                        resolveResult = tryExtractResult(lastAssistantResponse, 'resolve_result');
+                        const salvaged = tryExtractResult(lastAssistantResponse, 'resolve_result');
+                        if (isResolveResult(salvaged)) {
+                            resolveResult = salvaged;
+                        }
                     }
                 }
             }
@@ -113,7 +138,7 @@ export async function resolveStandalonePR(options) {
             let threadsSkipped = 0;
             let threadsErrored = 0;
             if (resolveResult?.comments) {
-                const comments = resolveResult.comments;
+                const { comments } = resolveResult;
                 for (const comment of comments) {
                     // Map comment_id back to real GraphQL thread ID
                     const threadId = commentIdToThreadId.get(comment.comment_id);
@@ -166,6 +191,16 @@ export async function resolveStandalonePR(options) {
                 }
             }
             logSuccess(`PR resolve completed: ${threadsAddressed} addressed, ${threadsSkipped} skipped, ${threadsErrored} errors`);
+            // Learn from addressed comments to update code-review checklists
+            if (options.learn !== false && threadsAddressed > 0 && resolveResult) {
+                await learnFromReviewFeedback({
+                    productId: options.productId,
+                    unresolvedThreads,
+                    resolveResult,
+                    commentIdToThreadId,
+                    verbose,
+                });
+            }
             if (prId) {
                 try {
                     await callMcpEndpoint('pull_requests/update', {

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

@@ -0,0 +1,18 @@
+/**
+ * Shared type definitions for PR resolve phase.
+ */
+export interface ResolveComment {
+    comment_id: string;
+    action: 'changed' | 'skipped';
+    reply: string;
+}
+export interface ResolveResult {
+    comments: ResolveComment[];
+    files_modified?: string[];
+    summary?: string;
+}
+/**
+ * Runtime type guard — validates that an unknown value from tryExtractResult
+ * has the shape of a ResolveResult.
+ */
+export declare function isResolveResult(value: unknown): value is ResolveResult;

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

@@ -0,0 +1,14 @@
+/**
+ * Shared type definitions for PR resolve phase.
+ */
+/**
+ * Runtime type guard — validates that an unknown value from tryExtractResult
+ * has the shape of a ResolveResult.
+ */
+export function isResolveResult(value) {
+    if (!value || typeof value !== 'object') {
+        return false;
+    }
+    const obj = value;
+    return Array.isArray(obj.comments);
+}

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

@@ -10,11 +10,17 @@ export declare function buildCredentialArgs(token: string): string[];
  * Get the workspace path for a PR resolve operation.
  */
 export declare function getResolveWorkspacePath(prNumber: number): string;
+export interface ForkFallbackInfo {
+    upstreamOwner: string;
+    upstreamRepo: string;
+}
 /**
  * Clone or reuse a repo for PR resolve.
+ * For fork PRs, clones from the fork repo. If the fork branch is unavailable,
+ * falls back to fetching the PR ref from the upstream repo.
  * Returns the workspace path.
  */
-export declare function prepareWorkspace(owner: string, repo: string, headRef: string, prNumber: number, token: string, verbose?: boolean): string;
+export declare function prepareWorkspace(owner: string, repo: string, headRef: string, prNumber: number, token: string, verbose?: boolean, forkFallback?: ForkFallbackInfo): string;
 /**
  * Push changes from workspace back to remote.
  */

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

@@ -27,9 +27,11 @@ export function getResolveWorkspacePath(prNumber) {
 }
 /**
  * Clone or reuse a repo for PR resolve.
+ * For fork PRs, clones from the fork repo. If the fork branch is unavailable,
+ * falls back to fetching the PR ref from the upstream repo.
  * Returns the workspace path.
  */
-export function prepareWorkspace(owner, repo, headRef, prNumber, token, verbose) {
+export function prepareWorkspace(owner, repo, headRef, prNumber, token, verbose, forkFallback) {
     const repoPath = getResolveWorkspacePath(prNumber);
     const repoUrl = `https://github.com/${owner}/${repo}.git`;
     const gitCredentialArgs = buildCredentialArgs(token);
@@ -66,16 +68,41 @@ export function prepareWorkspace(owner, repo, headRef, prNumber, token, verbose)
     }
     else {
         logInfo(`Cloning ${owner}/${repo} (branch: ${headRef})...`);
-        execFileSync('git', [
-            ...gitCredentialArgs,
-            'clone',
-            '--branch',
-            headRef,
-            '--single-branch',
-            repoUrl,
-            repoPath,
-        ], { stdio: 'pipe' });
-        logSuccess(`Cloned to ${repoPath}`);
+        try {
+            execFileSync('git', [
+                ...gitCredentialArgs,
+                'clone',
+                '--branch',
+                headRef,
+                '--single-branch',
+                repoUrl,
+                repoPath,
+            ], { stdio: 'pipe' });
+            logSuccess(`Cloned to ${repoPath}`);
+        }
+        catch (error) {
+            // If clone fails and this is a fork PR, fall back to upstream PR ref
+            if (forkFallback) {
+                logInfo(`Fork branch not available, falling back to PR ref from ${forkFallback.upstreamOwner}/${forkFallback.upstreamRepo}`);
+                const upstreamUrl = `https://github.com/${forkFallback.upstreamOwner}/${forkFallback.upstreamRepo}.git`;
+                execFileSync('git', [...gitCredentialArgs, 'clone', upstreamUrl, repoPath], { stdio: 'pipe' });
+                // Fetch the PR ref and check it out
+                execFileSync('git', [
+                    ...gitCredentialArgs,
+                    'fetch',
+                    'origin',
+                    `pull/${prNumber}/head:${headRef}`,
+                ], { cwd: repoPath, stdio: 'pipe' });
+                execSync(`git checkout ${headRef}`, {
+                    cwd: repoPath,
+                    stdio: 'pipe',
+                });
+                logSuccess(`Cloned via PR ref to ${repoPath}`);
+            }
+            else {
+                throw error;
+            }
+        }
     }
     // Configure git user for commits
     try {