edsger 0.26.0 → 0.26.2

package/dist/phases/feature-analysis-verification/verifier.js

@@ -0,0 +1,147 @@
+/**
+ * Checklist verification agent for feature analysis
+ * This agent independently reviews checklist compliance to ensure objectivity
+ */
+import { query } from '@anthropic-ai/claude-code';
+import { logInfo, logError } from '../../utils/logger.js';
+import { createChecklistVerificationPrompt, createChecklistVerificationSystemPrompt, } from './prompts.js';
+function userMessage(content) {
+    return {
+        type: 'user',
+        message: { role: 'user', content: content },
+    };
+}
+async function* prompt(verificationPrompt) {
+    yield userMessage(verificationPrompt);
+}
+/**
+ * Verify checklist compliance using an independent AI agent
+ * This agent acts as a "challenger" to validate the claims made by the analysis agent
+ */
+export async function verifyChecklistCompliance(options, config) {
+    const { checklistContext, analysisContext, createdUserStories, createdTestCases, verbose, } = options;
+    const totalChecklistItems = checklistContext.checklists.reduce((sum, checklist) => sum + checklist.items.length, 0);
+    if (verbose) {
+        logInfo('🔍 Starting checklist verification...');
+        logInfo(`   Verifying ${totalChecklistItems} checklist items`);
+    }
+    try {
+        const systemPrompt = createChecklistVerificationSystemPrompt(config);
+        const verificationPrompt = createChecklistVerificationPrompt({
+            checklistContext,
+            analysisContext,
+            createdUserStories,
+            createdTestCases,
+        });
+        let lastAssistantResponse = '';
+        let verificationResult = null;
+        if (verbose) {
+            logInfo('🤖 Starting verification agent query...');
+        }
+        // Use Claude Code SDK for verification
+        for await (const message of query({
+            prompt: prompt(verificationPrompt),
+            options: {
+                appendSystemPrompt: systemPrompt,
+                model: config.claude.model || 'sonnet',
+                maxTurns: 100,
+                permissionMode: 'bypassPermissions',
+            },
+        })) {
+            if (verbose) {
+                logInfo(`   Received message type: ${message.type}`);
+            }
+            // Capture assistant responses
+            if (message.type === 'assistant' && message.message?.content) {
+                for (const content of message.message.content) {
+                    if (content.type === 'text') {
+                        lastAssistantResponse += content.text + '\n';
+                        if (verbose) {
+                            console.log(`\n🔍 ${content.text}`);
+                        }
+                    }
+                }
+            }
+            if (message.type === 'result') {
+                if (message.subtype === 'success') {
+                    logInfo('\n✅ Verification completed, parsing results...');
+                    try {
+                        const responseText = message.result || lastAssistantResponse;
+                        // Try to extract JSON from markdown code block
+                        const jsonBlockMatch = responseText.match(/```json\s*\n([\s\S]*?)\n\s*```/);
+                        let jsonResult = null;
+                        if (jsonBlockMatch) {
+                            jsonResult = JSON.parse(jsonBlockMatch[1]);
+                        }
+                        else {
+                            jsonResult = JSON.parse(responseText);
+                        }
+                        if (jsonResult && jsonResult.verification) {
+                            verificationResult = jsonResult.verification;
+                        }
+                        else {
+                            throw new Error('Invalid verification JSON structure');
+                        }
+                    }
+                    catch (error) {
+                        logError(`Failed to parse verification result: ${error}`);
+                        // Return default "uncertain" result
+                        verificationResult = createUncertainVerificationResult(checklistContext, 'Failed to parse verification response');
+                    }
+                }
+                else {
+                    logError(`\n⚠️ Verification incomplete: ${message.subtype}`);
+                    verificationResult = createUncertainVerificationResult(checklistContext, `Verification incomplete: ${message.subtype}`);
+                }
+            }
+        }
+        if (!verificationResult) {
+            verificationResult = createUncertainVerificationResult(checklistContext, 'No verification result received');
+        }
+        if (verbose) {
+            logInfo('\n📊 Verification Summary:');
+            logInfo(`   Total items: ${verificationResult.total_items}`);
+            logInfo(`   ✅ Confirmed: ${verificationResult.confirmed_count}`);
+            logInfo(`   ❌ Rejected: ${verificationResult.rejected_count}`);
+            logInfo(`   ⚠️  Uncertain: ${verificationResult.uncertain_count}`);
+            logInfo(`   Summary: ${verificationResult.summary}`);
+            if (verificationResult.rejected_count > 0) {
+                logInfo('\n❌ Rejected items:');
+                verificationResult.item_verifications
+                    .filter((v) => v.verification_status === 'rejected')
+                    .forEach((v) => {
+                    logInfo(`   - ${v.checklist_item_id}`);
+                    logInfo(`     Reason: ${v.verification_reason}`);
+                });
+            }
+        }
+        return verificationResult;
+    }
+    catch (error) {
+        logError(`Checklist verification failed: ${error instanceof Error ? error.message : String(error)}`);
+        return createUncertainVerificationResult(checklistContext, `Verification error: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * Create a default "uncertain" verification result when verification fails
+ */
+function createUncertainVerificationResult(checklistContext, reason) {
+    // Get all checklist items
+    const allItems = checklistContext.checklists.flatMap((checklist) => checklist.items.map((item) => ({
+        checklist_item_id: item.id,
+    })));
+    return {
+        all_verified: false,
+        total_items: allItems.length,
+        confirmed_count: 0,
+        rejected_count: 0,
+        uncertain_count: allItems.length,
+        item_verifications: allItems.map((item) => ({
+            checklist_item_id: item.checklist_item_id,
+            is_satisfied: false,
+            verification_status: 'uncertain',
+            verification_reason: reason,
+        })),
+        summary: `Verification could not be completed: ${reason}`,
+    };
+}

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

@@ -0,0 +1,26 @@
+import type { FeatureInfo } from '../../types/features.js';
+import { type PullRequest } from '../../services/pull-requests.js';
+import { type RepoForkInfo } from '../../utils/github-repo-info.js';
+export interface GitHubConfigInfo {
+    configured: boolean;
+    token?: string;
+    owner?: string;
+    repo?: string;
+    message?: string;
+}
+export interface PRExecutionContext {
+    feature: FeatureInfo;
+    pullRequests: PullRequest[];
+    devBranchName: string;
+    devBranchHeadSha: string;
+    githubConfig: GitHubConfigInfo;
+    forkInfo: RepoForkInfo;
+    isIncrementalSync: boolean;
+    lastSyncedCommit: string | null;
+    diffStat: string;
+    changedFiles: string[];
+}
+/**
+ * Fetch context for PR execution phase
+ */
+export declare function fetchPRExecutionContext(featureId: string, verbose?: boolean): Promise<PRExecutionContext>;

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

@@ -0,0 +1,156 @@
+import { execSync } from 'child_process';
+import { logInfo, logError } from '../../utils/logger.js';
+import { getFeature } from '../../api/features/index.js';
+import { getPullRequests, } from '../../services/pull-requests.js';
+import { getGitHubConfig } from '../../api/github.js';
+import { getRepoForkInfo, } from '../../utils/github-repo-info.js';
+import { branchExists, remoteBranchExists, } from '../../utils/git-branch-manager.js';
+/**
+ * Get the dev branch name for a feature
+ */
+function getDevBranchName(featureId) {
+    return `dev/${featureId}`;
+}
+/**
+ * Get the HEAD SHA of a branch
+ */
+function getBranchHeadSha(branchName) {
+    return execSync(`git rev-parse ${branchName}`, { encoding: 'utf-8' }).trim();
+}
+/**
+ * Get diff stat between two refs
+ */
+function getDiffStat(baseRef, headRef) {
+    try {
+        return execSync(`git diff --stat ${baseRef}...${headRef}`, {
+            encoding: 'utf-8',
+        }).trim();
+    }
+    catch {
+        return '';
+    }
+}
+/**
+ * Get list of changed files between two refs
+ */
+function getChangedFiles(baseRef, headRef) {
+    try {
+        const output = execSync(`git diff --name-only ${baseRef}...${headRef}`, { encoding: 'utf-8' }).trim();
+        if (!output)
+            return [];
+        return output.split('\n').filter((f) => f.length > 0);
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Determine the common last_synced_commit from existing PRs
+ * Returns null if any PR hasn't been synced yet (first run)
+ */
+function getLastSyncedCommit(pullRequests) {
+    if (pullRequests.length === 0)
+        return null;
+    const syncedCommits = pullRequests
+        .map((pr) => pr.last_synced_commit)
+        .filter((c) => c !== null);
+    // If not all PRs have been synced, this is a first-time execution
+    if (syncedCommits.length !== pullRequests.length)
+        return null;
+    // All should be the same after a successful sync, use the first
+    return syncedCommits[0];
+}
+/**
+ * Fetch context for PR execution phase
+ */
+export async function fetchPRExecutionContext(featureId, verbose) {
+    try {
+        if (verbose) {
+            logInfo(`Fetching PR execution context for feature: ${featureId}`);
+        }
+        const devBranchName = getDevBranchName(featureId);
+        // Verify dev branch exists
+        const localExists = branchExists(devBranchName);
+        const remoteExists = !localExists && remoteBranchExists(devBranchName);
+        if (!localExists && !remoteExists) {
+            throw new Error(`Development branch '${devBranchName}' does not exist. ` +
+                `The feature must have code on the dev branch before PR execution.`);
+        }
+        // If branch only exists on remote, fetch it
+        if (!localExists && remoteExists) {
+            if (verbose) {
+                logInfo(`Fetching remote branch ${devBranchName}...`);
+            }
+            execSync(`git fetch origin ${devBranchName}`, {
+                encoding: 'utf-8',
+                stdio: 'pipe',
+            });
+        }
+        // Fetch data in parallel
+        const [feature, pullRequests] = await Promise.all([
+            getFeature(featureId, verbose),
+            getPullRequests({ featureId, verbose }),
+        ]);
+        if (pullRequests.length === 0) {
+            throw new Error('No PR plan found. Run the pr-splitting phase first to create a PR plan.');
+        }
+        // Fetch GitHub config
+        const githubConfig = await getGitHubConfig(featureId, verbose);
+        if (!githubConfig.configured) {
+            throw new Error(`GitHub is not configured. ${githubConfig.message || 'Please configure GitHub integration.'}`);
+        }
+        // Detect fork status
+        let forkInfo = { isFork: false };
+        if (githubConfig.token && githubConfig.owner && githubConfig.repo) {
+            try {
+                forkInfo = await getRepoForkInfo(githubConfig.token, githubConfig.owner, githubConfig.repo);
+                if (verbose) {
+                    logInfo(forkInfo.isFork
+                        ? `📌 Repository is a fork of ${forkInfo.upstream?.owner}/${forkInfo.upstream?.repo}`
+                        : `📌 Repository is not a fork`);
+                }
+            }
+            catch (error) {
+                if (verbose) {
+                    logError(`Failed to detect fork status: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }
+        }
+        // Determine sync mode
+        const devRef = localExists ? devBranchName : `origin/${devBranchName}`;
+        const devBranchHeadSha = getBranchHeadSha(devRef);
+        const lastSyncedCommit = getLastSyncedCommit(pullRequests);
+        const isIncrementalSync = lastSyncedCommit !== null;
+        // Get diff info: for incremental, diff from last sync; for first run, diff from main
+        const diffBase = isIncrementalSync ? lastSyncedCommit : 'main';
+        const diffStat = getDiffStat(diffBase, devRef);
+        const changedFiles = getChangedFiles(diffBase, devRef);
+        if (verbose) {
+            logInfo(`✅ PR execution context fetched:`);
+            logInfo(`   Feature: ${feature.name}`);
+            logInfo(`   Dev Branch: ${devBranchName} (HEAD: ${devBranchHeadSha})`);
+            logInfo(`   PR Records: ${pullRequests.length}`);
+            logInfo(`   Mode: ${isIncrementalSync ? '🔄 Incremental sync' : '✨ First execution'}`);
+            logInfo(`   Diff Base: ${diffBase}`);
+            logInfo(`   Changed Files: ${changedFiles.length}`);
+            logInfo(`   GitHub: ${githubConfig.configured ? 'Configured' : 'Not configured'}`);
+        }
+        return {
+            feature,
+            pullRequests,
+            devBranchName,
+            devBranchHeadSha,
+            githubConfig,
+            forkInfo,
+            isIncrementalSync,
+            lastSyncedCommit,
+            diffStat,
+            changedFiles,
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logError(`Failed to fetch PR execution context: ${errorMessage}`);
+        throw new Error(`Context fetch failed: ${errorMessage}`);
+    }
+}

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

@@ -0,0 +1,20 @@
+import { EdsgerConfig } from '../../types/index.js';
+export interface PRExecutionOptions {
+    featureId: string;
+    verbose?: boolean;
+}
+/**
+ * PR Execution Phase: Create git branches, push code, and create GitHub PRs
+ *
+ * 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.
+ */
+export declare const executeFeaturePRs: (options: PRExecutionOptions, config: EdsgerConfig) => Promise<{
+    status: "success" | "error";
+    message?: string;
+    summary?: string;
+    [key: string]: any;
+}>;

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

@@ -0,0 +1,287 @@
+import { query } from '@anthropic-ai/claude-agent-sdk';
+import { execSync } from 'child_process';
+import { DEFAULT_MODEL } from '../../constants.js';
+import { logInfo, logError } from '../../utils/logger.js';
+import { fetchPRExecutionContext } from './context.js';
+import { createPRExecutionSystemPrompt, createPRExecutionPrompt, createIncrementalSyncSystemPrompt, createIncrementalSyncPrompt, } from './prompts.js';
+import { buildExecutionSuccessResult, buildExecutionErrorResult, buildNoChangeResult, } from './outcome.js';
+import { logFeaturePhaseEvent } from '../../services/audit-logs.js';
+import { pushAndCreateGitHubPR, updatePRDatabaseRecord, } from './pr-executor.js';
+import { getCurrentBranch, returnToMainBranch, } from '../../utils/git-branch-manager.js';
+function userMessage(content) {
+    return {
+        type: 'user',
+        message: { role: 'user', content: content },
+    };
+}
+async function* prompt(executionPrompt) {
+    yield userMessage(executionPrompt);
+    await new Promise((res) => setTimeout(res, 10000));
+}
+/**
+ * PR Execution Phase: Create git branches, push code, and create GitHub PRs
+ *
+ * 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.
+ */
+export const executeFeaturePRs = async (options, config) => {
+    const { featureId, verbose } = options;
+    if (verbose) {
+        logInfo(`Starting PR execution for feature ID: ${featureId}`);
+    }
+    try {
+        // Log phase start
+        await logFeaturePhaseEvent({
+            featureId,
+            eventType: 'phase_started',
+            phase: 'pr_execution',
+            result: 'info',
+            metadata: {
+                timestamp: new Date().toISOString(),
+            },
+        }, verbose);
+        // Fetch context
+        const context = await fetchPRExecutionContext(featureId, 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(featureId, 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(featureId, 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 main before the agent starts
+        const currentBranch = getCurrentBranch();
+        if (currentBranch !== 'main') {
+            if (verbose) {
+                logInfo(`Switching from ${currentBranch} to main...`);
+            }
+            execSync('git checkout main', { encoding: 'utf-8', stdio: 'pipe' });
+        }
+        let systemPrompt;
+        let userPrompt;
+        if (context.isIncrementalSync && context.lastSyncedCommit) {
+            systemPrompt = createIncrementalSyncSystemPrompt(featureId, context.devBranchName);
+            userPrompt = createIncrementalSyncPrompt(featureId, context.devBranchName, context.pullRequests, context.lastSyncedCommit, context.diffStat, context.changedFiles);
+        }
+        else {
+            systemPrompt = createPRExecutionSystemPrompt(featureId, context.devBranchName);
+            userPrompt = createPRExecutionPrompt(featureId, context.devBranchName, context.pullRequests);
+        }
+        // Execute agent query
+        await executeAgentQuery(userPrompt, systemPrompt, config, verbose);
+        // ================================================
+        // Push & Create GitHub PRs (Programmatic)
+        // ================================================
+        if (verbose) {
+            logInfo('\n🚀 Pushing branches and creating GitHub PRs...');
+        }
+        // Ensure we're on main before pushing
+        try {
+            execSync('git checkout main', { encoding: 'utf-8', stdio: 'pipe' });
+        }
+        catch {
+            // Ignore if already on main
+        }
+        const executionConfig = {
+            githubToken: context.githubConfig.token,
+            owner: context.githubConfig.owner,
+            repo: context.githubConfig.repo,
+            forkInfo: context.forkInfo,
+            verbose,
+        };
+        const executionSummary = {
+            branchesCreated: 0,
+            branchesUpdated: 0,
+            prsCreated: 0,
+            prsUpdated: 0,
+            failedBranches: [],
+            prUrls: [],
+        };
+        for (const pr of context.pullRequests) {
+            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 {
+                execSync(`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.failedBranches.push(pr.branch_name);
+                continue;
+            }
+            if (context.isIncrementalSync) {
+                executionSummary.branchesUpdated++;
+            }
+            else {
+                executionSummary.branchesCreated++;
+            }
+            // Push and create/update GitHub PR
+            const prTitle = `feat: ${pr.name.toLowerCase()}`;
+            const prDescription = `## ${pr.name}\n\n${pr.description || ''}\n\n---\n**Branch**: \`${pr.branch_name}\`\n**Created by**: Automated PR Splitting`;
+            const result = await pushAndCreateGitHubPR(executionConfig, pr.branch_name, prTitle, prDescription);
+            if (result.success && result.prUrl && result.prNumber) {
+                if (pr.pull_request_url) {
+                    executionSummary.prsUpdated++;
+                }
+                else {
+                    executionSummary.prsCreated++;
+                }
+                executionSummary.prUrls.push(result.prUrl);
+                // Update database record with PR info and sync commit
+                try {
+                    await updatePRDatabaseRecord(pr.id, result.prUrl, result.prNumber, context.devBranchHeadSha, verbose);
+                }
+                catch (error) {
+                    if (verbose) {
+                        logError(`Failed to update PR record: ${error instanceof Error ? error.message : String(error)}`);
+                    }
+                }
+            }
+            else {
+                executionSummary.failedBranches.push(pr.branch_name);
+            }
+        }
+        // Return to main branch
+        try {
+            returnToMainBranch('main', verbose);
+        }
+        catch {
+            // Best effort
+        }
+        if (verbose) {
+            logInfo(`\n📊 PR execution complete:`);
+            if (context.isIncrementalSync) {
+                logInfo(`   Branches updated: ${executionSummary.branchesUpdated}`);
+                logInfo(`   PRs updated: ${executionSummary.prsUpdated}`);
+            }
+            else {
+                logInfo(`   Branches created: ${executionSummary.branchesCreated}`);
+                logInfo(`   PRs created: ${executionSummary.prsCreated}`);
+            }
+            logInfo(`   Failed: ${executionSummary.failedBranches.length}`);
+            executionSummary.prUrls.forEach((url) => {
+                logInfo(`   🔗 ${url}`);
+            });
+        }
+        // Log phase completion
+        await logFeaturePhaseEvent({
+            featureId,
+            eventType: 'phase_completed',
+            phase: 'pr_execution',
+            result: 'success',
+            metadata: {
+                branches_created: executionSummary.branchesCreated,
+                branches_updated: executionSummary.branchesUpdated,
+                prs_created: executionSummary.prsCreated,
+                prs_updated: executionSummary.prsUpdated,
+                failed_branches: executionSummary.failedBranches,
+                pr_urls: executionSummary.prUrls,
+                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}`
+            : `Created ${executionSummary.branchesCreated} PR branches and ${executionSummary.prsCreated} GitHub PRs`;
+        return buildExecutionSuccessResult(featureId, executionSummary, summary);
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logError(`PR execution failed: ${errorMessage}`);
+        // Try to return to main branch
+        try {
+            returnToMainBranch('main', false);
+        }
+        catch {
+            // Best effort
+        }
+        await logFeaturePhaseEvent({
+            featureId,
+            eventType: 'phase_failed',
+            phase: 'pr_execution',
+            result: 'error',
+            metadata: {
+                error: errorMessage,
+                timestamp: new Date().toISOString(),
+            },
+        }, verbose);
+        return buildExecutionErrorResult(featureId, errorMessage);
+    }
+};
+/**
+ * Execute an agent query for branch creation/update
+ */
+async function executeAgentQuery(userPrompt, systemPrompt, config, verbose) {
+    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') {
+                    if (verbose) {
+                        console.log(`\n🤖 ${content.text}`);
+                    }
+                }
+                else if (content.type === 'tool_use') {
+                    if (verbose) {
+                        console.log(`\n🔧 ${content.name}: ${content.input.description || 'Running...'}`);
+                    }
+                }
+            }
+        }
+        if (message.type === 'result') {
+            if (message.subtype === 'success') {
+                logInfo('\n✅ Branch operations completed.');
+            }
+            else {
+                logError(`\n⚠️ Branch operations incomplete: ${message.subtype}`);
+            }
+        }
+    }
+}

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

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