edsger 0.76.0 → 0.78.0

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

@@ -1,131 +0,0 @@
-import { resolveSkill, substituteVariables, } from '../../services/skill-resolver.js';
-import { OUTPUT_CONTRACTS } from '../output-contracts.js';
-/**
- * Create the system prompt for branch creation and code splitting
- */
-export async function createPRExecutionSystemPrompt(issueId, devBranchName, projectDir) {
-    const skill = await resolveSkill('phase/pr-execution', {
-        projectDir,
-    });
-    if (!skill) {
-        throw new Error('Failed to load skill: phase/pr-execution');
-    }
-    let { prompt } = skill;
-    prompt = substituteVariables(prompt, {
-        ISSUE_ID: issueId,
-        DEV_BRANCH: devBranchName,
-    });
-    return `${prompt}\n\n${OUTPUT_CONTRACTS['pr-execution']}`;
-}
-/**
- * Create the system prompt for incremental sync (re-runs)
- */
-export async function createIncrementalSyncSystemPrompt(issueId, devBranchName, projectDir) {
-    const skill = await resolveSkill('phase/incremental-sync', {
-        projectDir,
-    });
-    if (!skill) {
-        throw new Error('Failed to load skill: phase/incremental-sync');
-    }
-    let { prompt } = skill;
-    prompt = substituteVariables(prompt, {
-        ISSUE_ID: issueId,
-        DEV_BRANCH: devBranchName,
-    });
-    return `${prompt}\n\n${OUTPUT_CONTRACTS['incremental-sync']}`;
-}
-/**
- * Resolve the base branch for a PR based on its dependency chain.
- * Falls back to the repo's default branch (main, master, …) when the PR has
- * no upstream dependency.
- */
-function resolveBaseBranch(pr, allPRs, defaultBranch) {
-    if (!pr.base_pr_id) {
-        return defaultBranch;
-    }
-    const basePR = allPRs.find((p) => p.id === pr.base_pr_id);
-    return basePR?.branch_name || defaultBranch;
-}
-/**
- * Create the user prompt for first-time branch creation
- */
-export function createPRExecutionPrompt(issueId, devBranchName, pullRequests, defaultBranch) {
-    const prList = pullRequests
-        .map((pr) => {
-        const files = pr.files
-            ? pr.files.map((f) => `    - ${f.path} (${f.change_type})`).join('\n')
-            : '    (no files specified)';
-        const baseBranch = resolveBaseBranch(pr, pullRequests, defaultBranch);
-        return `### PR ${pr.sequence}: ${pr.name}
-- Branch: \`${pr.branch_name}\`
-- Base: \`${baseBranch}\`
-- Description: ${pr.description}
-- Files:
-${files}`;
-    })
-        .join('\n\n');
-    return `# Create PR Branches (Stacked)
-
-Create the following PR branches as a stacked chain, applying the relevant changes from \`${devBranchName}\`:
-
-${prList}
-
-## Instructions
-
-For each PR above (in sequence order):
-1. Switch to the **base branch** specified in "Base" above (either \`${defaultBranch}\` or a previous PR's branch)
-2. Create the branch: \`git checkout -b <branch_name>\`
-3. Apply only the listed files from \`${devBranchName}\`
-4. Commit with a descriptive message
-5. Verify with \`git diff --stat <base>...<branch_name>\`
-
-After all branches are created, switch back to \`${defaultBranch}\` and provide the execution result JSON.`;
-}
-export function createIncrementalSyncPrompt(opts) {
-    const { issueId: _issueId, devBranchName, pullRequests, lastSyncedCommit, diffStat, changedFiles, defaultBranch, } = opts;
-    const prList = pullRequests
-        .map((pr) => {
-        const files = pr.files
-            ? pr.files.map((f) => `    - ${f.path} (${f.change_type})`).join('\n')
-            : '    (no files specified)';
-        const baseBranch = resolveBaseBranch(pr, pullRequests, defaultBranch);
-        return `### PR ${pr.sequence}: ${pr.name}
-- Branch: \`${pr.branch_name}\`
-- Base: \`${baseBranch}\`
-- Files:
-${files}`;
-    })
-        .join('\n\n');
-    return `# Sync PR Branches with Latest Changes (Stacked)
-
-New changes have been made on \`${devBranchName}\` since the last sync at commit \`${lastSyncedCommit}\`.
-
-## New Changes Since Last Sync
-
-### Diff Stat
-\`\`\`
-${diffStat || 'No changes detected'}
-\`\`\`
-
-### Changed Files (${changedFiles.length} files)
-${changedFiles.map((f) => `- ${f.path} (${f.change_type})`).join('\n') || 'No files changed'}
-
-## Existing PR Branches (Stacked)
-
-${prList}
-
-## Instructions
-
-These branches are stacked — each PR branch is based on its dependency. Update them **in sequence order** (base PRs first):
-
-For each PR branch that has files affected by the new changes:
-1. Switch to the PR branch
-2. If this PR has a base PR that was just updated, first merge the base branch into this branch: \`git merge <base-branch> --no-edit\`
-3. Apply the relevant new changes from \`${devBranchName}\` (checkout the updated files)
-4. Commit with a sync message
-5. Verify the branch state
-
-If a PR branch has no files affected by the new changes but its base PR was updated, still merge the base branch to keep the stack consistent.
-
-After all branches are updated, switch back to \`main\` and provide the execution result JSON.`;
-}

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

@@ -1,28 +0,0 @@
-/**
- * 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

@@ -1,153 +0,0 @@
-/**
- * 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 — assigned to the most appropriate phase(s) so issues are caught as early as possible.
-
-## Available Phases (earliest → latest)
-
-| Phase | When it runs | Good for |
-|-------|-------------|----------|
-| \`issue_analysis\` | Requirements gathering | Requirement gaps, scope issues, edge cases |
-| \`user_stories_analysis\` | User story refinement | Acceptance criteria gaps, missing scenarios |
-| \`test_cases_analysis\` | Test planning | Missing test coverage, untested edge cases |
-| \`technical_design\` | Architecture & design | Design flaws, API contract issues, data modelling |
-| \`branch_planning\` | Work breakdown | Dependency issues, ordering problems |
-| \`code_implementation\` | Writing code | Coding patterns, error handling, security, performance |
-| \`code_testing\` | Unit/integration tests | Test quality, assertion coverage, mocking issues |
-| \`code_refine\` | Code polish | Readability, naming, documentation |
-| \`code_review\` | Final review | Cross-cutting concerns not caught earlier |
-
-## Workflow
-
-1. **Read** the addressed review comments provided below.
-2. **Query existing checklists** using \`list_checklists\` (without a phase filter) to see what already exists across all phases.
-3. **Identify patterns** — group related comments into categories (e.g., error handling, naming, security, performance, testing).
-4. **Decide the best phase(s)** for each pattern — prefer earlier phases where the issue could have been prevented. A checklist item can belong to multiple phases if appropriate.
-5. **Update or create checklist items**:
-   - If an existing checklist covers the category and phase, add new items to it (skip if a similar item already exists).
-   - If no suitable checklist exists, create a new one with the appropriate phases.
-6. **Summarise** what you added or updated, and explain why you chose each phase.
-
-## Phase Selection Guidelines
-
-- **Shift left**: If an issue could have been prevented in an earlier phase, assign it there. For example, a missing null check found in code review should become a \`code_implementation\` checklist item.
-- **Security & error handling** → typically \`code_implementation\`
-- **Missing test cases or edge cases** → \`test_cases_analysis\` or \`code_testing\`
-- **Design or architecture issues** → \`technical_design\`
-- **Missing requirements or acceptance criteria** → \`issue_analysis\` or \`user_stories_analysis\`
-- **Code style, readability, naming** → \`code_refine\`
-- **Only use \`code_review\`** for cross-cutting concerns that genuinely can't be checked earlier.
-
-## Rules
-
-- Only create items for **genuine quality patterns** — things that should be checked repeatedly.
-- Skip one-off nits, purely stylistic preferences, or context-specific fixes that won't generalise.
-- Role: \`developer\`
-- 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 checklists across all phases and create or update items in the most appropriate phase(s) to prevent these issues from recurring. Prefer earlier phases where the issue could have been caught sooner.');
-    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.');
-                    // eslint-disable-next-line max-depth
-                    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/github-reply.d.ts

@@ -1,16 +0,0 @@
-/**
- * GitHub API operations for PR resolve: reply to threads, resolve threads.
- * Reuses GraphQL patterns from code-refine-verification.
- */
-import { type Octokit } from '@octokit/rest';
-export declare function buildResolveMarker(action: 'changed' | 'skipped'): string;
-export declare function hasResolveMarker(body: string | undefined | null): boolean;
-/**
- * Reply to a review thread on GitHub using GraphQL. Appends a marker so the
- * next run can detect that we've already responded to this thread.
- */
-export declare function replyToReviewThread(octokit: Octokit, threadId: string, body: string, action: 'changed' | 'skipped', 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

@@ -1,75 +0,0 @@
-/**
- * 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';
-/**
- * Marker appended to every reply we post so subsequent runs can recognise
- * their own prior comments and avoid posting duplicates.
- */
-const RESOLVE_MARKER_PREFIX = '<!-- edsger:pr-resolve';
-export function buildResolveMarker(action) {
-    return `${RESOLVE_MARKER_PREFIX}:${action} -->`;
-}
-export function hasResolveMarker(body) {
-    if (!body) {
-        return false;
-    }
-    return body.includes(RESOLVE_MARKER_PREFIX);
-}
-/**
- * Reply to a review thread on GitHub using GraphQL. Appends a marker so the
- * next run can detect that we've already responded to this thread.
- */
-export async function replyToReviewThread(octokit, threadId, body, action, verbose) {
-    try {
-        const mutation = `
-      mutation($threadId: ID!, $body: String!) {
-        addPullRequestReviewThreadReply(input: {
-          pullRequestReviewThreadId: $threadId
-          body: $body
-        }) {
-          comment {
-            id
-          }
-        }
-      }
-    `;
-        const bodyWithMarker = `${body}\n\n${buildResolveMarker(action)}`;
-        await octokit.graphql(mutation, { threadId, body: bodyWithMarker });
-        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

@@ -1,33 +0,0 @@
-/**
- * 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;
-    /** Set for repo-scoped PRs — routes the status write through Supabase. */
-    repositoryId?: string;
-    pullRequestUrl: string;
-    githubToken: string;
-    owner: string;
-    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';
-    message: string;
-    threadsAddressed?: number;
-    threadsSkipped?: number;
-    threadsErrored?: number;
-    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.
- */
-export declare function resolveStandalonePR(options: StandalonePRResolveOptions): Promise<PRResolveResult>;