edsger 0.40.0 → 0.41.0

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

@@ -0,0 +1,25 @@
+/**
+ * Standalone PR Review
+ * Reviews a GitHub PR and posts review comments, without feature lifecycle dependency.
+ */
+export interface StandalonePRReviewOptions {
+    productId: string;
+    pullRequestUrl: string;
+    githubToken: string;
+    owner: string;
+    repo: string;
+    prId?: string;
+    verbose?: boolean;
+}
+export interface StandalonePRReviewResult {
+    status: 'success' | 'error';
+    message: string;
+    reviewId?: number;
+    reviewUrl?: string;
+    commentsCount?: number;
+    summary?: string;
+}
+/**
+ * Review a standalone PR and post comments to GitHub.
+ */
+export declare function reviewStandalonePR(options: StandalonePRReviewOptions): Promise<StandalonePRReviewResult>;

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

@@ -0,0 +1,213 @@
+/**
+ * Standalone PR Review
+ * Reviews a GitHub PR and posts review comments, without feature lifecycle dependency.
+ */
+import { query } from '@anthropic-ai/claude-agent-sdk';
+import { Octokit } from '@octokit/rest';
+import { callMcpEndpoint } from '../../api/mcp-client.js';
+import { DEFAULT_MODEL } from '../../constants.js';
+import { logError, logInfo } from '../../utils/logger.js';
+import { buildLineToPositionMap, findClosestPosition, } from '../code-review/diff-utils.js';
+import { createPromptGenerator, extractTextFromContent, tryExtractResult, } from '../pr-shared/agent-utils.js';
+import { fetchStandalonePRContext, formatStandalonePRContextForPrompt, } from '../pr-shared/context.js';
+import { createStandaloneReviewSystemPrompt, createStandaloneReviewUserPrompt, } from './prompts.js';
+/**
+ * Review a standalone PR and post comments to GitHub.
+ */
+export async function reviewStandalonePR(options
+// eslint-disable-next-line complexity
+) {
+    const { pullRequestUrl, githubToken, verbose, prId } = options;
+    logInfo(`Starting standalone PR review: ${pullRequestUrl}`);
+    try {
+        // Fetch PR context
+        const context = await fetchStandalonePRContext(pullRequestUrl, githubToken, verbose);
+        if (context.files.length === 0) {
+            logInfo('No files to review in the PR.');
+            return {
+                status: 'success',
+                message: 'No files to review',
+                summary: 'No changed files found in the PR',
+            };
+        }
+        logInfo(`Found ${context.files.length} files to review across ${context.commits.length} commits`);
+        // Build prompts
+        const systemPrompt = createStandaloneReviewSystemPrompt();
+        const contextInfo = formatStandalonePRContextForPrompt(context);
+        const reviewPrompt = createStandaloneReviewUserPrompt(contextInfo);
+        let lastAssistantResponse = '';
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        let structuredReviewResult = null;
+        logInfo('Starting Claude analysis for code review...');
+        for await (const message of query({
+            prompt: createPromptGenerator(reviewPrompt),
+            options: {
+                systemPrompt: {
+                    type: 'preset',
+                    preset: 'claude_code',
+                    append: systemPrompt,
+                },
+                model: DEFAULT_MODEL,
+                maxTurns: 50,
+                permissionMode: 'bypassPermissions',
+            },
+        })) {
+            if (message.type === 'assistant') {
+                lastAssistantResponse += extractTextFromContent(message.message?.content ?? [], verbose);
+                continue;
+            }
+            if (message.type !== 'result') {
+                continue;
+            }
+            if (message.subtype === 'success') {
+                logInfo('Code review analysis completed, parsing results...');
+                const responseText = message.result || lastAssistantResponse;
+                structuredReviewResult = tryExtractResult(responseText, 'review_result') || {
+                    summary: 'Code review completed',
+                    comments: [],
+                    overall_assessment: 'COMMENT',
+                };
+            }
+            else {
+                logError(`Code review incomplete: ${message.subtype}`);
+                if (lastAssistantResponse) {
+                    structuredReviewResult = tryExtractResult(lastAssistantResponse, 'review_result');
+                }
+            }
+        }
+        if (!structuredReviewResult) {
+            return {
+                status: 'error',
+                message: 'Code review analysis failed or incomplete',
+            };
+        }
+        // Post review to GitHub
+        const { summary, comments, overall_assessment } = structuredReviewResult;
+        const octokit = new Octokit({ auth: githubToken });
+        if (!comments || comments.length === 0) {
+            logInfo('No issues found. PR looks good!');
+            const review = await octokit.pulls.createReview({
+                owner: context.owner,
+                repo: context.repo,
+                pull_number: context.pullRequestNumber,
+                event: 'COMMENT',
+                body: summary ||
+                    overall_assessment ||
+                    'Code review completed. No issues found.',
+            });
+            if (prId) {
+                await updatePRStatus(prId, 'in_review');
+            }
+            return {
+                status: 'success',
+                message: 'Code review completed - no issues found',
+                reviewId: review.data.id,
+                reviewUrl: review.data.html_url,
+                commentsCount: 0,
+                summary: summary || 'No issues found',
+            };
+        }
+        logInfo(`Creating GitHub review with ${comments.length} comments...`);
+        // Build line-to-position maps for all files
+        const fileLineToPosition = new Map();
+        for (const file of context.files) {
+            if (file.patch) {
+                fileLineToPosition.set(file.filename, buildLineToPositionMap(file.patch));
+            }
+        }
+        const commitId = context.prData.head.sha;
+        // Map comments to diff positions
+        const reviewComments = [];
+        for (const comment of comments) {
+            const filePath = comment.file || comment.path;
+            const requestedLine = comment.line;
+            const lineToPosition = fileLineToPosition.get(filePath);
+            if (!lineToPosition) {
+                if (verbose) {
+                    logInfo(`Skipping comment for ${filePath}:${requestedLine} - file has no diff`);
+                }
+                continue;
+            }
+            const positionResult = findClosestPosition(requestedLine, lineToPosition);
+            if (positionResult === null) {
+                if (verbose) {
+                    logInfo(`Skipping comment for ${filePath}:${requestedLine} - line not in diff range`);
+                }
+                continue;
+            }
+            let commentBody = comment.comment || comment.body;
+            if (positionResult.actualLine !== requestedLine) {
+                commentBody = `**Note**: Comment originally for line ${requestedLine}, adjusted to line ${positionResult.actualLine} (nearest line in diff).\n\n${commentBody}`;
+            }
+            reviewComments.push({
+                path: filePath,
+                position: positionResult.position,
+                body: commentBody,
+            });
+        }
+        if (reviewComments.length === 0) {
+            logInfo('All comments were filtered out (invalid line numbers)');
+            const review = await octokit.pulls.createReview({
+                owner: context.owner,
+                repo: context.repo,
+                pull_number: context.pullRequestNumber,
+                event: 'COMMENT',
+                body: `${summary || 'Code review completed.'}\n\n**Note**: Some review comments could not be posted because they referenced lines not present in the diff.`,
+            });
+            if (prId) {
+                await updatePRStatus(prId, 'in_review');
+            }
+            return {
+                status: 'success',
+                message: 'Code review completed - comments filtered',
+                reviewId: review.data.id,
+                reviewUrl: review.data.html_url,
+                commentsCount: 0,
+                summary: summary || 'Code review completed (comments filtered)',
+            };
+        }
+        logInfo(`Posting ${reviewComments.length} validated comments (${comments.length - reviewComments.length} filtered out)`);
+        const review = await octokit.pulls.createReview({
+            owner: context.owner,
+            repo: context.repo,
+            pull_number: context.pullRequestNumber,
+            commit_id: commitId,
+            event: 'COMMENT',
+            body: summary ||
+                overall_assessment ||
+                'Please address the following review comments.',
+            comments: reviewComments,
+        });
+        logInfo(`GitHub review created: ${review.data.html_url}`);
+        if (prId) {
+            await updatePRStatus(prId, 'in_review');
+        }
+        return {
+            status: 'success',
+            message: 'Code review completed and posted to GitHub',
+            reviewId: review.data.id,
+            reviewUrl: review.data.html_url,
+            commentsCount: reviewComments.length,
+            summary: summary || 'Code review completed',
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logError(`PR review failed: ${errorMessage}`);
+        return {
+            status: 'error',
+            message: `PR review failed: ${errorMessage}`,
+        };
+    }
+}
+async function updatePRStatus(prId, status) {
+    try {
+        await callMcpEndpoint('pull_requests/update', {
+            pull_request_id: prId,
+            status,
+        });
+    }
+    catch {
+        // Non-critical, don't fail the review
+    }
+}

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

@@ -0,0 +1,5 @@
+/**
+ * Prompts for standalone PR review (no feature/design context).
+ */
+export declare function createStandaloneReviewSystemPrompt(): string;
+export declare function createStandaloneReviewUserPrompt(contextInfo: string): string;

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

@@ -0,0 +1,87 @@
+/**
+ * Prompts for standalone PR review (no feature/design context).
+ */
+export function createStandaloneReviewSystemPrompt() {
+    return `You are an expert code reviewer specializing in thorough, constructive code reviews. Your goal is to analyze pull request code and identify issues, potential bugs, code quality concerns, and areas for improvement.
+
+**Review Focus Areas**:
+1. **Code Quality**: Clean code principles, readability, maintainability
+2. **Best Practices**: Language-specific conventions, design patterns
+3. **Potential Bugs**: Logic errors, edge cases, error handling
+4. **Security**: Security vulnerabilities, input validation
+5. **Performance**: Performance issues, optimization opportunities
+6. **Architecture**: Design decisions, coupling, cohesion
+
+**Important Guidelines**:
+- Be thorough but focus on significant issues
+- Provide constructive, actionable feedback
+- Suggest specific improvements
+- Be respectful and professional
+- Focus on issues that truly matter, not nitpicks
+- If code looks good overall, provide positive feedback
+
+**CRITICAL - Result Format**:
+You MUST end your response with a JSON object containing the review results in this EXACT format:
+
+\`\`\`json
+{
+  "review_result": {
+    "summary": "Overall review summary and assessment",
+    "overall_assessment": "APPROVE | REQUEST_CHANGES | COMMENT",
+    "comments": [
+      {
+        "file": "path/to/file.ts",
+        "line": 42,
+        "comment": "Detailed comment about the issue and suggested fix"
+      }
+    ],
+    "issues_found": {
+      "critical": 0,
+      "major": 0,
+      "minor": 0
+    }
+  }
+}
+\`\`\`
+
+**Comment Guidelines**:
+- Each comment should reference a specific file and line number
+- Be specific about what the issue is
+- Provide a suggested fix or improvement
+
+**Assessment Options**:
+- **APPROVE**: Code looks good, no significant issues
+- **REQUEST_CHANGES**: Issues found that should be addressed
+- **COMMENT**: Minor suggestions or questions, not blocking`;
+}
+export function createStandaloneReviewUserPrompt(contextInfo) {
+    return `Review the following pull request code:
+
+${contextInfo}
+
+## Code Review Instructions
+
+Follow this systematic approach:
+
+1. **Analyze Each File**: For each changed file:
+   - Review the code changes in the diff
+   - Look for code quality issues
+   - Check for potential bugs or logic errors
+   - Verify error handling
+   - Consider security implications
+   - Evaluate performance considerations
+
+2. **Identify Issues**: Categorize by severity:
+   - **Critical**: Security vulnerabilities, data loss risks, major bugs
+   - **Major**: Logic errors, incorrect implementations, missing error handling
+   - **Minor**: Code quality improvements, style issues, optimization suggestions
+
+3. **Provide Actionable Feedback**: For each issue:
+   - Reference the specific file and line number
+   - Explain what the issue is
+   - Suggest how to fix it
+
+4. **Generate Review Result**: Create a structured JSON response with summary, assessment, and comments.
+
+Begin by analyzing the changed files and identifying any issues or improvements.`;
+}

package/dist/phases/pr-shared/__tests__/agent-utils.test.d.ts

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

package/dist/phases/pr-shared/__tests__/agent-utils.test.js

@@ -0,0 +1,91 @@
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+import { extractTextFromContent, tryExtractResult, tryParseJsonFromResponse, userMessage, } from '../agent-utils.js';
+describe('userMessage', () => {
+    it('creates a user message object', () => {
+        const msg = userMessage('hello');
+        assert.deepStrictEqual(msg, {
+            type: 'user',
+            message: { role: 'user', content: 'hello' },
+        });
+    });
+});
+describe('extractTextFromContent', () => {
+    it('extracts text items from content array', () => {
+        const content = [
+            { type: 'text', text: 'hello' },
+            { type: 'tool_use', id: '123', name: 'read', input: {} },
+            { type: 'text', text: 'world' },
+        ];
+        const result = extractTextFromContent(content);
+        assert.strictEqual(result, 'hello\nworld\n');
+    });
+    it('returns empty string for no text items', () => {
+        const content = [{ type: 'tool_use', id: '123', name: 'read', input: {} }];
+        const result = extractTextFromContent(content);
+        assert.strictEqual(result, '');
+    });
+    it('returns empty string for empty array', () => {
+        assert.strictEqual(extractTextFromContent([]), '');
+    });
+});
+describe('tryParseJsonFromResponse', () => {
+    it('parses JSON from code block', () => {
+        const text = 'Here is the result:\n```json\n{"key": "value"}\n```\nDone.';
+        const result = tryParseJsonFromResponse(text);
+        assert.deepStrictEqual(result, { key: 'value' });
+    });
+    it('parses raw JSON', () => {
+        const text = '{"key": "value"}';
+        const result = tryParseJsonFromResponse(text);
+        assert.deepStrictEqual(result, { key: 'value' });
+    });
+    it('returns null for invalid JSON', () => {
+        const result = tryParseJsonFromResponse('not json at all');
+        assert.strictEqual(result, null);
+    });
+    it('returns null for empty string', () => {
+        const result = tryParseJsonFromResponse('');
+        assert.strictEqual(result, null);
+    });
+    it('parses JSON block with surrounding text', () => {
+        const text = `I analyzed the code and here are my findings:
+
+\`\`\`json
+{
+  "review_result": {
+    "summary": "looks good",
+    "comments": []
+  }
+}
+\`\`\`
+
+That's my review.`;
+        const result = tryParseJsonFromResponse(text);
+        assert.ok(result);
+        assert.ok(result.review_result);
+    });
+});
+describe('tryExtractResult', () => {
+    it('extracts keyed result from JSON code block', () => {
+        const text = '```json\n{"review_result": {"summary": "good"}}\n```';
+        const result = tryExtractResult(text, 'review_result');
+        assert.deepStrictEqual(result, { summary: 'good' });
+    });
+    it('returns whole object if key not found but JSON valid', () => {
+        const text = '{"summary": "good", "comments": []}';
+        const result = tryExtractResult(text, 'review_result');
+        assert.deepStrictEqual(result, { summary: 'good', comments: [] });
+    });
+    it('returns null for unparseable text', () => {
+        const result = tryExtractResult('no json here', 'review_result');
+        assert.strictEqual(result, null);
+    });
+    it('extracts resolve_result key', () => {
+        const text = '```json\n{"resolve_result": {"comments": [{"comment_id": "comment_1", "action": "changed", "reply": "fixed"}]}}\n```';
+        const result = tryExtractResult(text, 'resolve_result');
+        assert.ok(result);
+        assert.ok(Array.isArray(result.comments));
+        assert.strictEqual(result.comments.length, 1);
+    });
+});

package/dist/phases/pr-shared/__tests__/context.test.d.ts

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

package/dist/phases/pr-shared/__tests__/context.test.js

@@ -0,0 +1,94 @@
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+import { formatStandalonePRContextForPrompt, parsePullRequestUrl, } from '../context.js';
+describe('parsePullRequestUrl (re-exported)', () => {
+    it('parses a standard GitHub PR URL', () => {
+        const result = parsePullRequestUrl('https://github.com/owner/repo/pull/123');
+        assert.deepStrictEqual(result, {
+            owner: 'owner',
+            repo: 'repo',
+            prNumber: 123,
+        });
+    });
+    it('parses URL with trailing path segments', () => {
+        const result = parsePullRequestUrl('https://github.com/my-org/my-repo/pull/456/files');
+        assert.deepStrictEqual(result, {
+            owner: 'my-org',
+            repo: 'my-repo',
+            prNumber: 456,
+        });
+    });
+    it('returns null for non-PR URL', () => {
+        assert.strictEqual(parsePullRequestUrl('https://github.com/owner/repo/issues/1'), null);
+    });
+    it('returns null for non-GitHub URL', () => {
+        assert.strictEqual(parsePullRequestUrl('https://example.com/pull/1'), null);
+    });
+});
+describe('formatStandalonePRContextForPrompt', () => {
+    const context = {
+        pullRequestUrl: 'https://github.com/owner/repo/pull/42',
+        pullRequestNumber: 42,
+        owner: 'owner',
+        repo: 'repo',
+        prData: {
+            number: 42,
+            title: 'Fix bug in auth',
+            body: 'This fixes the login issue',
+            state: 'open',
+            head: { ref: 'fix/auth', sha: 'abc123' },
+            base: { ref: 'main', sha: 'def456' },
+            user: { login: 'testuser' },
+        },
+        files: [
+            {
+                filename: 'src/auth.ts',
+                status: 'modified',
+                additions: 5,
+                deletions: 2,
+                changes: 7,
+                patch: '@@ -1,3 +1,6 @@\n line1\n+added\n line3',
+                blob_url: '',
+            },
+        ],
+        commits: [
+            {
+                sha: 'abc1234567890',
+                commit: {
+                    message: 'fix: auth bug',
+                    author: { name: 'Test', date: '2026-01-01' },
+                },
+            },
+        ],
+    };
+    it('includes PR URL and number', () => {
+        const output = formatStandalonePRContextForPrompt(context);
+        assert.ok(output.includes('#42'));
+        assert.ok(output.includes('github.com/owner/repo/pull/42'));
+    });
+    it('includes PR title and author', () => {
+        const output = formatStandalonePRContextForPrompt(context);
+        assert.ok(output.includes('Fix bug in auth'));
+        assert.ok(output.includes('@testuser'));
+    });
+    it('includes branch info', () => {
+        const output = formatStandalonePRContextForPrompt(context);
+        assert.ok(output.includes('fix/auth'));
+        assert.ok(output.includes('main'));
+    });
+    it('includes file diff', () => {
+        const output = formatStandalonePRContextForPrompt(context);
+        assert.ok(output.includes('src/auth.ts'));
+        assert.ok(output.includes('+added'));
+        assert.ok(output.includes('+5 -2'));
+    });
+    it('includes commit info', () => {
+        const output = formatStandalonePRContextForPrompt(context);
+        assert.ok(output.includes('abc1234'));
+        assert.ok(output.includes('fix: auth bug'));
+    });
+    it('includes PR body/description', () => {
+        const output = formatStandalonePRContextForPrompt(context);
+        assert.ok(output.includes('This fixes the login issue'));
+    });
+});

package/dist/phases/pr-shared/agent-utils.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Shared utilities for Agent SDK phases.
+ * Eliminates duplication of prompt generators, text extractors, and JSON parsers.
+ */
+/**
+ * Create a user message object for the Agent SDK prompt generator.
+ */
+export declare function userMessage(content: string): {
+    type: string;
+    message: {
+        role: string;
+        content: string;
+    };
+};
+/**
+ * Create an async generator that yields a single user prompt for Agent SDK query().
+ */
+export declare function createPromptGenerator(prompt: string): AsyncGenerator<{
+    type: string;
+    message: {
+        role: string;
+        content: string;
+    };
+}>;
+/**
+ * Extract text content from assistant message content array.
+ */
+export declare function extractTextFromContent(content: any[], verbose?: boolean): string;
+/**
+ * Try to parse a JSON result from agent response text.
+ * Looks for ```json code blocks first, then falls back to raw JSON parsing.
+ * Returns the parsed object or null on failure.
+ */
+export declare function tryParseJsonFromResponse(responseText: string): unknown | null;
+/**
+ * Extract a specific keyed result from agent response.
+ * e.g., tryExtractResult(text, 'review_result') extracts the review_result key.
+ */
+export declare function tryExtractResult(responseText: string, key: string): unknown | null;

package/dist/phases/pr-shared/agent-utils.js

@@ -0,0 +1,69 @@
+/**
+ * Shared utilities for Agent SDK phases.
+ * Eliminates duplication of prompt generators, text extractors, and JSON parsers.
+ */
+import { logDebug } from '../../utils/logger.js';
+/**
+ * Create a user message object for the Agent SDK prompt generator.
+ */
+export function userMessage(content) {
+    return {
+        type: 'user',
+        message: { role: 'user', content },
+    };
+}
+/**
+ * Create an async generator that yields a single user prompt for Agent SDK query().
+ */
+export async function* createPromptGenerator(prompt) {
+    yield userMessage(prompt);
+    await new Promise((res) => {
+        setTimeout(res, 10000);
+    });
+}
+/**
+ * Extract text content from assistant message content array.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function extractTextFromContent(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+content, verbose) {
+    let text = '';
+    for (const item of content) {
+        if (item.type === 'text') {
+            text += `${item.text}\n`;
+            logDebug(item.text, verbose);
+        }
+    }
+    return text;
+}
+/**
+ * Try to parse a JSON result from agent response text.
+ * Looks for ```json code blocks first, then falls back to raw JSON parsing.
+ * Returns the parsed object or null on failure.
+ */
+export function tryParseJsonFromResponse(responseText) {
+    try {
+        const jsonBlockMatch = responseText.match(/```json\s*\n([\s\S]*?)\n\s*```/);
+        return jsonBlockMatch
+            ? JSON.parse(jsonBlockMatch[1])
+            : JSON.parse(responseText);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Extract a specific keyed result from agent response.
+ * e.g., tryExtractResult(text, 'review_result') extracts the review_result key.
+ */
+export function tryExtractResult(responseText, key) {
+    const parsed = tryParseJsonFromResponse(responseText);
+    if (parsed &&
+        typeof parsed === 'object' &&
+        key in parsed) {
+        return parsed[key];
+    }
+    // If top-level has the expected shape, return the whole thing
+    return parsed;
+}

package/dist/phases/pr-shared/context.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Shared context builder for standalone PR operations.
+ * Reuses GitHub API utilities from code-review/context.ts without feature dependencies.
+ */
+import { type PRCommit, type PRData, type PRFile } from '../code-review/context.js';
+export { parsePullRequestUrl } from '../code-review/context.js';
+export type { PRCommit, PRData, PRFile } from '../code-review/context.js';
+export interface StandalonePRContext {
+    pullRequestUrl: string;
+    pullRequestNumber: number;
+    owner: string;
+    repo: string;
+    prData: PRData;
+    files: PRFile[];
+    commits: PRCommit[];
+}
+/**
+ * Fetch PR context for standalone review/resolve (no feature dependency).
+ */
+export declare function fetchStandalonePRContext(pullRequestUrl: string, githubToken: string, verbose?: boolean): Promise<StandalonePRContext>;
+/**
+ * Format standalone PR context for prompts (no feature/design context).
+ */
+export declare function formatStandalonePRContextForPrompt(context: StandalonePRContext): string;