edsger 0.76.0 → 0.78.0

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

@@ -1,401 +0,0 @@
-import { query } from '@anthropic-ai/claude-agent-sdk';
-import { execFileSync } from 'child_process';
-import { DEFAULT_MODEL } from '../../constants.js';
-import { logIssuePhaseEvent } from '../../services/audit-logs.js';
-import { getPullRequests, } from '../../services/pull-requests.js';
-import { getCurrentBranch, returnToMainBranch, } from '../../utils/git-branch-manager.js';
-import { resolveDefaultBranch } from '../../utils/github-repo-info.js';
-import { logDebug, logError, logInfo } from '../../utils/logger.js';
-import { fetchPRExecutionContext } from './context.js';
-import { assignNewFilesToPRs, removeDeletedFilesFromPRs, removeStaleFilesFromPRs, } from './file-assigner.js';
-import { buildExecutionErrorResult, buildExecutionSuccessResult, buildNoChangeResult, } from './outcome.js';
-import { pushBranchAndBuildUrl, updatePRDatabaseRecord, } from './pr-executor.js';
-import { createIncrementalSyncPrompt, createIncrementalSyncSystemPrompt, createPRExecutionPrompt, createPRExecutionSystemPrompt, } from './prompts.js';
-function userMessage(content) {
-    return {
-        type: 'user',
-        message: { role: 'user', content },
-    };
-}
-async function* prompt(executionPrompt) {
-    yield userMessage(executionPrompt);
-    await new Promise((res) => {
-        setTimeout(res, 10000);
-    });
-}
-/**
- * PR Execution Phase: Create git branches, push code, and generate compare URLs
- *
- * Prerequisites: pr-splitting phase must have been run and human-approved.
- * PR plan records must exist in the database.
- *
- * Supports incremental re-sync: if PR branches already exist and dev branch
- * has new changes, only the new changes are synced to existing branches.
- *
- * GitHub PRs are created manually by the user via compare URLs in the UI.
- */
-export const executeIssuePRs = async (options, config) => {
-    const { issueId, verbose } = options;
-    if (verbose) {
-        logInfo(`Starting PR execution for issue ID: ${issueId}`);
-    }
-    try {
-        // Log phase start
-        await logIssuePhaseEvent({
-            issueId,
-            eventType: 'phase_started',
-            phase: 'pr_execution',
-            result: 'info',
-            metadata: {
-                timestamp: new Date().toISOString(),
-            },
-        }, verbose);
-        // Fetch context
-        const context = await fetchPRExecutionContext(issueId, verbose);
-        // Check if already fully synced
-        if (context.isIncrementalSync &&
-            context.lastSyncedCommit === context.devBranchHeadSha) {
-            if (verbose) {
-                logInfo('All PR branches are already synced to latest commit.');
-            }
-            return buildNoChangeResult(issueId, context.pullRequests.length);
-        }
-        // Check if there are any changed files (for incremental sync)
-        if (context.isIncrementalSync && context.changedFiles.length === 0) {
-            if (verbose) {
-                logInfo('No new changes since last sync.');
-            }
-            return buildNoChangeResult(issueId, context.pullRequests.length);
-        }
-        // ======================================
-        // Reconcile file assignments
-        // ======================================
-        let activePullRequests = context.pullRequests;
-        // Reconcile file lists against the current diff.
-        if (context.changedFiles.length > 0) {
-            let needsRefetch = false;
-            if (context.isIncrementalSync) {
-                // Incremental: only remove explicitly deleted files
-                const deletedCount = await removeDeletedFilesFromPRs(context.changedFiles, activePullRequests, undefined, verbose);
-                if (deletedCount > 0) {
-                    needsRefetch = true;
-                }
-            }
-            else {
-                // Full re-execution (e.g. after rebase): remove any PR files that
-                // are no longer in the current diff against main
-                const staleCount = await removeStaleFilesFromPRs(context.changedFiles, activePullRequests, undefined, verbose);
-                if (staleCount > 0) {
-                    needsRefetch = true;
-                }
-            }
-            // Assign changed files not covered by any PR
-            if (needsRefetch) {
-                activePullRequests = await getPullRequests({ issueId, verbose });
-            }
-            const assignedCount = await assignNewFilesToPRs(context.changedFiles, activePullRequests, verbose);
-            if (assignedCount > 0) {
-                activePullRequests = await getPullRequests({ issueId, verbose });
-            }
-        }
-        // ======================================
-        // Filter to only the next eligible PR
-        // ======================================
-        // Only process the first pending PR whose predecessor is merged/closed.
-        // Already-executed PRs (branch_created, pr_opened, etc.) are included for sync.
-        activePullRequests = filterToEligiblePRs(activePullRequests, verbose);
-        if (activePullRequests.length === 0) {
-            if (verbose) {
-                logInfo('No eligible PRs to process — waiting for current PR to be merged or closed.');
-            }
-            return buildNoChangeResult(issueId, context.pullRequests.length);
-        }
-        // ======================================
-        // Agent: Create/Update branches
-        // ======================================
-        if (verbose) {
-            logInfo(context.isIncrementalSync
-                ? '\n🔄 Syncing PR branches with latest changes...'
-                : '\n🔧 Creating PR branches and moving code...');
-        }
-        // Ensure we're on the repo's default branch before the agent starts
-        const currentBranch = getCurrentBranch();
-        if (currentBranch !== context.defaultBranch) {
-            if (verbose) {
-                logInfo(`Switching from ${currentBranch} to ${context.defaultBranch}...`);
-            }
-            execFileSync('git', ['checkout', context.defaultBranch], {
-                encoding: 'utf-8',
-                stdio: 'pipe',
-            });
-        }
-        let systemPrompt;
-        let userPrompt;
-        if (context.isIncrementalSync && context.lastSyncedCommit) {
-            systemPrompt = await createIncrementalSyncSystemPrompt(issueId, context.devBranchName);
-            userPrompt = createIncrementalSyncPrompt({
-                issueId,
-                devBranchName: context.devBranchName,
-                pullRequests: activePullRequests,
-                lastSyncedCommit: context.lastSyncedCommit,
-                diffStat: context.diffStat,
-                changedFiles: context.changedFiles,
-                defaultBranch: context.defaultBranch,
-            });
-        }
-        else {
-            systemPrompt = await createPRExecutionSystemPrompt(issueId, context.devBranchName);
-            userPrompt = createPRExecutionPrompt(issueId, context.devBranchName, activePullRequests, context.defaultBranch);
-        }
-        // Execute agent query
-        const agentResult = await executeAgentQuery(userPrompt, systemPrompt, config, verbose);
-        // ================================================
-        // Push branches to remote (no GitHub API calls)
-        // ================================================
-        if (verbose) {
-            logInfo('\n🚀 Pushing branches to remote...');
-        }
-        // Ensure we're back on the default branch before pushing
-        try {
-            execFileSync('git', ['checkout', context.defaultBranch], {
-                encoding: 'utf-8',
-                stdio: 'pipe',
-            });
-        }
-        catch {
-            // Ignore if already on the default branch
-        }
-        if (!context.githubConfig.owner || !context.githubConfig.repo) {
-            throw new Error('GitHub owner and repo must be configured for PR execution');
-        }
-        const executionConfig = {
-            owner: context.githubConfig.owner,
-            repo: context.githubConfig.repo,
-            forkInfo: context.forkInfo,
-            verbose,
-            token: context.githubConfig.token,
-        };
-        const executionSummary = {
-            branchesCreated: 0,
-            branchesUpdated: 0,
-            skippedBranches: [],
-            failedBranches: [],
-        };
-        // Build PR id → branch name map for stacked PR base resolution
-        const prIdToBranch = new Map();
-        for (const pr of activePullRequests) {
-            if (pr.branch_name) {
-                prIdToBranch.set(pr.id, pr.branch_name);
-            }
-        }
-        for (const pr of activePullRequests) {
-            if (!pr.branch_name) {
-                if (verbose) {
-                    logError(`PR "${pr.name}" has no branch name, skipping`);
-                }
-                executionSummary.failedBranches.push(pr.name);
-                continue;
-            }
-            // Verify the branch exists locally
-            try {
-                execFileSync('git', ['rev-parse', '--verify', pr.branch_name], {
-                    encoding: 'utf-8',
-                    stdio: 'pipe',
-                });
-            }
-            catch {
-                if (verbose) {
-                    logError(`Branch ${pr.branch_name} does not exist locally, skipping`);
-                }
-                executionSummary.skippedBranches.push(pr.branch_name);
-                continue;
-            }
-            if (context.isIncrementalSync) {
-                executionSummary.branchesUpdated++;
-            }
-            else {
-                executionSummary.branchesCreated++;
-            }
-            // Resolve base branch for stacked PRs (default to repo's default branch)
-            const baseBranch = pr.base_pr_id
-                ? prIdToBranch.get(pr.base_pr_id) || context.defaultBranch
-                : context.defaultBranch;
-            // Push branch and build compare URL (using stacked base)
-            const result = pushBranchAndBuildUrl(executionConfig, pr.branch_name, baseBranch);
-            if (result.success) {
-                // Update database record with compare URL and sync commit
-                await updatePRDatabaseRecord(pr.id, result.compareUrl, context.devBranchHeadSha, verbose).catch((error) => {
-                    logError(`Failed to update PR record: ${error instanceof Error ? error.message : String(error)}`);
-                });
-            }
-            else {
-                executionSummary.failedBranches.push(pr.branch_name);
-            }
-        }
-        // Return to the repo's default branch
-        try {
-            returnToMainBranch(context.defaultBranch, verbose);
-        }
-        catch {
-            // Best effort
-        }
-        if (verbose) {
-            logInfo(`\n📊 PR execution complete:`);
-            if (context.isIncrementalSync) {
-                logInfo(`   Branches updated: ${executionSummary.branchesUpdated}`);
-            }
-            else {
-                logInfo(`   Branches pushed: ${executionSummary.branchesCreated}`);
-            }
-            if (executionSummary.skippedBranches.length > 0) {
-                logInfo(`   Skipped: ${executionSummary.skippedBranches.length} (no local changes)`);
-            }
-            if (executionSummary.failedBranches.length > 0) {
-                logInfo(`   Failed: ${executionSummary.failedBranches.length}`);
-            }
-            if (context.forkInfo.isFork && context.forkInfo.upstream) {
-                logInfo(`   Fork target: ${context.forkInfo.upstream.owner}/${context.forkInfo.upstream.repo}`);
-            }
-        }
-        // Log phase completion
-        await logIssuePhaseEvent({
-            issueId,
-            eventType: 'phase_completed',
-            phase: 'pr_execution',
-            result: 'success',
-            metadata: {
-                branches_created: executionSummary.branchesCreated,
-                branches_updated: executionSummary.branchesUpdated,
-                skipped_branches: executionSummary.skippedBranches,
-                failed_branches: executionSummary.failedBranches,
-                last_synced_commit: context.devBranchHeadSha,
-                incremental_sync: context.isIncrementalSync,
-                timestamp: new Date().toISOString(),
-            },
-        }, verbose);
-        const summary = context.isIncrementalSync
-            ? `Synced PR branches with latest changes from ${context.devBranchName}`
-            : `Pushed ${executionSummary.branchesCreated} PR branches to remote`;
-        const successResult = buildExecutionSuccessResult(issueId, executionSummary, summary);
-        return {
-            ...successResult,
-            execution_session_id: agentResult.execution_session_id,
-        };
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        logError(`PR execution failed: ${errorMessage}`);
-        // Try to return to the repo's default branch (best effort — context may
-        // have failed before defaultBranch was resolved, so look it up locally)
-        try {
-            returnToMainBranch(resolveDefaultBranch(), false);
-        }
-        catch {
-            // Best effort
-        }
-        await logIssuePhaseEvent({
-            issueId,
-            eventType: 'phase_failed',
-            phase: 'pr_execution',
-            result: 'error',
-            metadata: {
-                error: errorMessage,
-                timestamp: new Date().toISOString(),
-            },
-        }, verbose);
-        return buildExecutionErrorResult(issueId, errorMessage);
-    }
-};
-/**
- * Filter PRs to only include the next eligible pending PR.
- *
- * - Already-executed PRs (branch_created, pr_opened, in_review, approved) are
- *   kept for incremental sync.
- * - Merged/closed PRs are excluded (no branch work needed).
- * - Only the first pending PR is included, and only if the PR immediately
- *   before it (by sequence) is merged or closed (or it's the first PR).
- * - All other pending PRs are blocked until the current one completes.
- */
-function filterToEligiblePRs(pullRequests, verbose) {
-    const sorted = [...pullRequests].sort((a, b) => a.sequence - b.sequence);
-    const eligible = [];
-    let foundPendingToProcess = false;
-    let blockedCount = 0;
-    for (let i = 0; i < sorted.length; i++) {
-        const pr = sorted[i];
-        if (pr.status === 'merged' || pr.status === 'closed') {
-            // Done — no branch work needed
-            continue;
-        }
-        if (pr.status !== 'pending') {
-            // Already executed but not done — include for incremental sync
-            eligible.push(pr);
-            continue;
-        }
-        // PR is pending
-        if (foundPendingToProcess) {
-            blockedCount++;
-            continue;
-        }
-        // Check if the previous PR (by sequence) is merged or closed
-        const prevPR = i > 0 ? sorted[i - 1] : null;
-        if (!prevPR || prevPR.status === 'merged' || prevPR.status === 'closed') {
-            eligible.push(pr);
-        }
-        else {
-            blockedCount++;
-        }
-        foundPendingToProcess = true;
-    }
-    if (blockedCount > 0 && verbose) {
-        logInfo(`⏳ ${blockedCount} pending PR(s) waiting for previous PR to be merged or closed`);
-    }
-    return eligible;
-}
-/**
- * Execute an agent query for branch creation/update
- */
-async function executeAgentQuery(userPrompt, systemPrompt, config, verbose) {
-    let executionSessionId = '';
-    if (verbose) {
-        logInfo('🤖 Starting PR execution agent query...');
-    }
-    for await (const message of query({
-        prompt: prompt(userPrompt),
-        options: {
-            systemPrompt: {
-                type: 'preset',
-                preset: 'claude_code',
-                append: systemPrompt,
-            },
-            model: DEFAULT_MODEL,
-            maxTurns: 500,
-            permissionMode: 'bypassPermissions',
-        },
-    })) {
-        if (verbose) {
-            logInfo(`   Received message type: ${message.type}`);
-        }
-        if (message.type === 'assistant' && message.message?.content) {
-            for (const content of message.message.content) {
-                if (content.type === 'text') {
-                    logDebug(`🤖 ${content.text}`, verbose);
-                }
-                else if (content.type === 'tool_use') {
-                    const input = (content.input ?? {});
-                    logDebug(`🔧 ${content.name}: ${input.description ?? 'Running...'}`, verbose);
-                }
-            }
-        }
-        if (message.type === 'result') {
-            executionSessionId = message.session_id || executionSessionId;
-            if (message.subtype === 'success') {
-                logInfo('\n✅ Branch operations completed.');
-            }
-            else {
-                logError(`\n⚠️ Branch operations incomplete: ${message.subtype}`);
-            }
-        }
-    }
-    return { execution_session_id: executionSessionId || undefined };
-}

package/dist/phases/pr-execution/outcome.d.ts

@@ -1,24 +0,0 @@
-export interface PRExecutionSummary {
-    branchesCreated: number;
-    branchesUpdated: number;
-    skippedBranches: string[];
-    failedBranches: string[];
-}
-export interface PRExecutionPhaseResult {
-    issueId: string;
-    status: 'success' | 'error';
-    summary: string;
-    executionSummary?: PRExecutionSummary;
-}
-/**
- * Build a successful execution result
- */
-export declare function buildExecutionSuccessResult(issueId: string, executionSummary: PRExecutionSummary, summary: string): PRExecutionPhaseResult;
-/**
- * Build an error result
- */
-export declare function buildExecutionErrorResult(issueId: string, errorMessage: string): PRExecutionPhaseResult;
-/**
- * Build a no-change result
- */
-export declare function buildNoChangeResult(issueId: string, prCount: number): PRExecutionPhaseResult;

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

@@ -1,34 +0,0 @@
-/**
- * Build a successful execution result
- */
-export function buildExecutionSuccessResult(issueId, executionSummary, summary) {
-    const details = executionSummary.branchesUpdated > 0
-        ? `${executionSummary.branchesUpdated} branches updated`
-        : `${executionSummary.branchesCreated} branches pushed`;
-    return {
-        issueId,
-        status: 'success',
-        summary: `${summary} (${details})`,
-        executionSummary,
-    };
-}
-/**
- * Build an error result
- */
-export function buildExecutionErrorResult(issueId, errorMessage) {
-    return {
-        issueId,
-        status: 'error',
-        summary: `PR execution failed: ${errorMessage}`,
-    };
-}
-/**
- * Build a no-change result
- */
-export function buildNoChangeResult(issueId, prCount) {
-    return {
-        issueId,
-        status: 'success',
-        summary: `All ${prCount} PR branches are already synced to latest commit. No changes needed.`,
-    };
-}

package/dist/phases/pr-execution/pr-executor.d.ts

@@ -1,42 +0,0 @@
-/**
- * PR Executor for pushing branches to remote and generating compare URLs
- * Handles fork-aware URL construction for manual PR creation
- */
-import type { RepoForkInfo } from '../../utils/github-repo-info.js';
-export interface PRExecutionConfig {
-    owner: string;
-    repo: string;
-    forkInfo: RepoForkInfo;
-    verbose?: boolean;
-    token?: string;
-}
-export interface PRBranchResult {
-    branchName: string;
-    compareUrl: string;
-    headSha: string;
-    success: boolean;
-    error?: string;
-}
-/**
- * Push a branch to remote with force-with-lease fallback
- */
-export declare function pushBranch(branchName: string, verbose?: boolean, token?: string): void;
-/**
- * Get the HEAD SHA of a local branch
- */
-export declare function getLocalBranchSha(branchName: string): string;
-/**
- * Build a GitHub compare URL for manual PR creation
- * Fork: https://github.com/{upstream_owner}/{upstream_repo}/compare/{base}...{fork_owner}:{branch}?expand=1
- * Non-fork: https://github.com/{owner}/{repo}/compare/{base}...{branch}?expand=1
- */
-export declare function buildCompareUrl(forkInfo: RepoForkInfo, owner: string, repo: string, branchName: string, base?: string): string;
-/**
- * Push a branch and build the compare URL
- * For stacked PRs, baseBranch is the dependency PR's branch instead of 'main'
- */
-export declare function pushBranchAndBuildUrl(config: PRExecutionConfig, branchName: string, baseBranch?: string): PRBranchResult;
-/**
- * Update a PR record in the database after branch push
- */
-export declare function updatePRDatabaseRecord(prId: string, compareUrl: string, headSha: string, verbose?: boolean): Promise<void>;

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

@@ -1,78 +0,0 @@
-/**
- * PR Executor for pushing branches to remote and generating compare URLs
- * Handles fork-aware URL construction for manual PR creation
- */
-import { execFileSync } from 'child_process';
-import { updatePullRequest } from '../../services/pull-requests.js';
-import { gitPush } from '../../utils/git-push.js';
-import { logInfo } from '../../utils/logger.js';
-/**
- * Push a branch to remote with force-with-lease fallback
- */
-export function pushBranch(branchName, verbose, token) {
-    const result = gitPush({ branchName, token, verbose });
-    if (!result.success) {
-        throw new Error(`Failed to push branch ${branchName}: ${result.error}`);
-    }
-}
-/**
- * Get the HEAD SHA of a local branch
- */
-export function getLocalBranchSha(branchName) {
-    return execFileSync('git', ['rev-parse', branchName], {
-        encoding: 'utf-8',
-    }).trim();
-}
-/**
- * Build a GitHub compare URL for manual PR creation
- * Fork: https://github.com/{upstream_owner}/{upstream_repo}/compare/{base}...{fork_owner}:{branch}?expand=1
- * Non-fork: https://github.com/{owner}/{repo}/compare/{base}...{branch}?expand=1
- */
-export function buildCompareUrl(forkInfo, owner, repo, branchName, base = 'main') {
-    if (forkInfo.isFork && forkInfo.upstream) {
-        const { owner: upstreamOwner, repo: upstreamRepo } = forkInfo.upstream;
-        return `https://github.com/${upstreamOwner}/${upstreamRepo}/compare/${base}...${owner}:${branchName}?expand=1`;
-    }
-    return `https://github.com/${owner}/${repo}/compare/${base}...${branchName}?expand=1`;
-}
-/**
- * Push a branch and build the compare URL
- * For stacked PRs, baseBranch is the dependency PR's branch instead of 'main'
- */
-export function pushBranchAndBuildUrl(config, branchName, baseBranch = 'main') {
-    const { owner, repo, forkInfo, verbose, token } = config;
-    const headSha = getLocalBranchSha(branchName);
-    try {
-        pushBranch(branchName, verbose, token);
-        const compareUrl = buildCompareUrl(forkInfo, owner, repo, branchName, baseBranch);
-        if (verbose) {
-            logInfo(`🔗 Compare URL: ${compareUrl}`);
-        }
-        return {
-            branchName,
-            compareUrl,
-            headSha,
-            success: true,
-        };
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        return {
-            branchName,
-            headSha,
-            compareUrl: '',
-            success: false,
-            error: errorMessage,
-        };
-    }
-}
-/**
- * Update a PR record in the database after branch push
- */
-export async function updatePRDatabaseRecord(prId, compareUrl, headSha, verbose) {
-    await updatePullRequest(prId, {
-        compare_url: compareUrl,
-        status: 'branch_created',
-        last_synced_commit: headSha,
-    }, verbose);
-}

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

@@ -1,27 +0,0 @@
-import type { PullRequest } from '../../services/pull-requests.js';
-import type { ChangedFileInfo } from './context.js';
-/**
- * Create the system prompt for branch creation and code splitting
- */
-export declare function createPRExecutionSystemPrompt(issueId: string, devBranchName: string, projectDir?: string): Promise<string>;
-/**
- * Create the system prompt for incremental sync (re-runs)
- */
-export declare function createIncrementalSyncSystemPrompt(issueId: string, devBranchName: string, projectDir?: string): Promise<string>;
-/**
- * Create the user prompt for first-time branch creation
- */
-export declare function createPRExecutionPrompt(issueId: string, devBranchName: string, pullRequests: PullRequest[], defaultBranch: string): string;
-/**
- * Create the user prompt for incremental sync
- */
-export interface IncrementalSyncPromptOptions {
-    issueId: string;
-    devBranchName: string;
-    pullRequests: PullRequest[];
-    lastSyncedCommit: string;
-    diffStat: string;
-    changedFiles: ChangedFileInfo[];
-    defaultBranch: string;
-}
-export declare function createIncrementalSyncPrompt(opts: IncrementalSyncPromptOptions): string;