edsger 0.25.0 → 0.26.0

package/dist/commands/workflow/config/phase-configs.js

@@ -6,6 +6,7 @@ import { analyseUserStories } from '../../../phases/user-stories-analysis/index.
 import { analyseTestCases } from '../../../phases/test-cases-analysis/index.js';
 import { generateTechnicalDesign } from '../../../phases/technical-design/index.js';
 import { planFeatureBranches } from '../../../phases/branch-planning/index.js';
+import { splitFeatureIntoPRs } from '../../../phases/pr-splitting/index.js';
 import { implementFeatureCode } from '../../../phases/code-implementation/index.js';
 import { runFunctionalTesting } from '../../../phases/functional-testing/analyzer.js';
 import { writeCodeTests } from '../../../phases/code-testing/analyzer.js';
@@ -95,6 +96,10 @@ export const phaseConfigs = [
         name: 'code-implementation',
         execute: implementFeatureCode,
     },
+    {
+        name: 'pr-splitting',
+        execute: splitFeatureIntoPRs,
+    },
     {
         name: 'functional-testing',
         execute: runFunctionalTesting,

package/dist/commands/workflow/executors/phase-executor.d.ts

@@ -4,5 +4,5 @@
 import { EdsgerConfig } from '../../../types/index.js';
 import { PipelinePhaseOptions, PipelineResult, PhaseConfig } from '../../../types/pipeline.js';
 export declare const createPhaseRunner: (phaseConfig: PhaseConfig) => (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>;
-declare const runFeatureAnalysisPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runUserStoriesAnalysisPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runTestCasesAnalysisPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runTechnicalDesignPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runBranchPlanningPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runCodeImplementationPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runFunctionalTestingPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runCodeTestingPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runCodeRefinePhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runCodeRefineVerificationPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runCodeReviewPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runAutonomousPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>;
-export { runFeatureAnalysisPhase, runUserStoriesAnalysisPhase, runTestCasesAnalysisPhase, runTechnicalDesignPhase, runBranchPlanningPhase, runCodeImplementationPhase, runFunctionalTestingPhase, runCodeTestingPhase, runCodeRefinePhase, runCodeRefineVerificationPhase, runCodeReviewPhase, runAutonomousPhase, };
+declare const runFeatureAnalysisPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runUserStoriesAnalysisPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runTestCasesAnalysisPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runTechnicalDesignPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runBranchPlanningPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runCodeImplementationPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runPRSplittingPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runFunctionalTestingPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runCodeTestingPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runCodeRefinePhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runCodeRefineVerificationPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runCodeReviewPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runAutonomousPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>;
+export { runFeatureAnalysisPhase, runUserStoriesAnalysisPhase, runTestCasesAnalysisPhase, runTechnicalDesignPhase, runBranchPlanningPhase, runCodeImplementationPhase, runPRSplittingPhase, runFunctionalTestingPhase, runCodeTestingPhase, runCodeRefinePhase, runCodeRefineVerificationPhase, runCodeReviewPhase, runAutonomousPhase, };

package/dist/commands/workflow/executors/phase-executor.js

@@ -262,6 +262,6 @@ export const createPhaseRunner = (phaseConfig) => async (options, config) => {
     }
 };
 // Create phase runners using the configuration
-const [runFeatureAnalysisPhase, runUserStoriesAnalysisPhase, runTestCasesAnalysisPhase, runTechnicalDesignPhase, runBranchPlanningPhase, runCodeImplementationPhase, runFunctionalTestingPhase, runCodeTestingPhase, runCodeRefinePhase, runCodeRefineVerificationPhase, runCodeReviewPhase, runAutonomousPhase,] = phaseConfigs.map(createPhaseRunner);
+const [runFeatureAnalysisPhase, runUserStoriesAnalysisPhase, runTestCasesAnalysisPhase, runTechnicalDesignPhase, runBranchPlanningPhase, runCodeImplementationPhase, runPRSplittingPhase, runFunctionalTestingPhase, runCodeTestingPhase, runCodeRefinePhase, runCodeRefineVerificationPhase, runCodeReviewPhase, runAutonomousPhase,] = phaseConfigs.map(createPhaseRunner);
 // Export individual phase runners for granular control
-export { runFeatureAnalysisPhase, runUserStoriesAnalysisPhase, runTestCasesAnalysisPhase, runTechnicalDesignPhase, runBranchPlanningPhase, runCodeImplementationPhase, runFunctionalTestingPhase, runCodeTestingPhase, runCodeRefinePhase, runCodeRefineVerificationPhase, runCodeReviewPhase, runAutonomousPhase, };
+export { runFeatureAnalysisPhase, runUserStoriesAnalysisPhase, runTestCasesAnalysisPhase, runTechnicalDesignPhase, runBranchPlanningPhase, runCodeImplementationPhase, runPRSplittingPhase, runFunctionalTestingPhase, runCodeTestingPhase, runCodeRefinePhase, runCodeRefineVerificationPhase, runCodeReviewPhase, runAutonomousPhase, };

package/dist/commands/workflow/phase-orchestrator.js

@@ -14,7 +14,7 @@
  * Uses functional programming principles for composability
  */
 import { updateFeatureStatusForPhase, markWorkflowPhaseCompleted, } from '../../api/features/index.js';
-import { runFeatureAnalysisPhase, runUserStoriesAnalysisPhase, runTestCasesAnalysisPhase, runTechnicalDesignPhase, runCodeImplementationPhase, runFunctionalTestingPhase, runCodeTestingPhase, runCodeReviewPhase, } from './executors/phase-executor.js';
+import { runFeatureAnalysisPhase, runUserStoriesAnalysisPhase, runTestCasesAnalysisPhase, runTechnicalDesignPhase, runCodeImplementationPhase, runPRSplittingPhase, runFunctionalTestingPhase, runCodeTestingPhase, runCodeReviewPhase, } from './executors/phase-executor.js';
 import { logPipelineStart, logPhaseResult, logPipelineComplete, shouldContinuePipeline, } from '../../utils/pipeline-logger.js';
 import { handleTestFailuresWithRetry } from '../../phases/functional-testing/test-retry-handler.js';
 import { handleCodeRefineWithRetry } from '../../phases/code-refine/retry-handler.js';
@@ -78,6 +78,11 @@ export const runPipelineByMode = async (options, config, executionMode) => {
             return await runOnlyCodeImplementation(options, config);
         case 'from_code_implementation':
             return await runFromCodeImplementation(options, config);
+        // PR Splitting
+        case 'only_pr_splitting':
+            return await runOnlyPRSplitting(options, config);
+        case 'from_pr_splitting':
+            return await runFromPRSplitting(options, config);
         // Functional Testing
         case 'only_functional_testing':
             return await runOnlyFunctionalTesting(options, config);
@@ -310,6 +315,58 @@ const runOnlyCodeImplementation = async (options, config) => {
     }
     return finalizePipelineExecution(options, results, verbose);
 };
+/**
+ * Run only PR splitting phase
+ */
+const runOnlyPRSplitting = async (options, config) => {
+    const { featureId, verbose } = options;
+    logPipelineStart(featureId, verbose);
+    const results = [];
+    const prSplittingResult = await runPRSplittingPhase(options, config);
+    results.push(await logAndMarkPhaseCompleted(prSplittingResult, verbose));
+    return finalizePipelineExecution(options, results, verbose);
+};
+/**
+ * Run from PR splitting to end
+ * Flow: pr-splitting → functional-testing → ... → code-review → code-refine
+ */
+const runFromPRSplitting = async (options, config) => {
+    const { featureId, verbose } = options;
+    logPipelineStart(featureId, verbose);
+    const results = [];
+    // 1. PR Splitting
+    const prSplittingResult = await runPRSplittingPhase(options, config);
+    results.push(await logAndMarkPhaseCompleted(prSplittingResult, verbose));
+    if (!shouldContinuePipeline(results)) {
+        return finalizePipelineExecution(options, results, verbose);
+    }
+    // 2. Functional Testing with retry loop for bug fixes
+    const testingResult = await handleTestFailuresWithRetry({
+        options,
+        config,
+        results,
+        verbose,
+    });
+    const finalStatus = testingResult.status === 'success' ? 'testing_passed' : 'testing_failed';
+    await updateFeatureStatusForPhase(featureId, finalStatus === 'testing_passed' ? 'testing-passed' : 'testing-failed', verbose);
+    if (testingResult.status === 'success') {
+        const prCreated = await handlePullRequestCreation({
+            featureId,
+            results,
+            testingResult,
+            verbose,
+        });
+        if (prCreated) {
+            await continueWithCodeReviewAndRefine(options, config, results, verbose);
+        }
+        else {
+            if (verbose) {
+                logInfo('⚠️ Skipping code review and refine workflow: pull request creation failed');
+            }
+        }
+    }
+    return finalizePipelineExecution(options, results, verbose);
+};
 /**
  * Run only functional testing phase
  */

package/dist/config/feature-status.js

@@ -36,6 +36,8 @@ export const STATUS_PROGRESSION_ORDER = [
     'branch_planning_verification',
     'code_implementation',
     'code_implementation_verification',
+    'pr_splitting',
+    'pr_splitting_verification',
     'code_refine',
     'code_refine_verification',
     'bug_fixing',
@@ -73,6 +75,8 @@ export const PHASE_STATUS_MAP = {
     'branch-planning-verification': 'branch_planning_verification',
     'code-implementation': 'code_implementation',
     'code-implementation-verification': 'code_implementation_verification',
+    'pr-splitting': 'pr_splitting',
+    'pr-splitting-verification': 'pr_splitting_verification',
     'code-refine': 'code_refine',
     'code-refine-verification': 'code_refine_verification',
     'bug-fixing': 'bug_fixing',
@@ -105,6 +109,7 @@ export const HUMAN_SELECTABLE_STATUSES = [
     'technical_design',
     'branch_planning',
     'code_implementation',
+    'pr_splitting',
     'code_refine',
     'bug_fixing',
     'code_review',

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

@@ -0,0 +1,14 @@
+import type { FeatureInfo } from '../../types/features.js';
+import { type ProductInfo } from '../../api/products.js';
+import { type Branch } from '../../services/branches.js';
+import { type PullRequest } from '../../services/pull-requests.js';
+export interface PRSplittingContext {
+    feature: FeatureInfo;
+    product: ProductInfo;
+    existing_branches: Branch[];
+    existing_pull_requests: PullRequest[];
+}
+/**
+ * Fetch all context information needed for PR splitting via MCP endpoints
+ */
+export declare function fetchPRSplittingContext(featureId: string, verbose?: boolean): Promise<PRSplittingContext>;

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

@@ -0,0 +1,41 @@
+import { logInfo, logError } from '../../utils/logger.js';
+import { getFeature } from '../../api/features/index.js';
+import { getProduct } from '../../api/products.js';
+import { getBranches } from '../../services/branches.js';
+import { getPullRequests, } from '../../services/pull-requests.js';
+/**
+ * Fetch all context information needed for PR splitting via MCP endpoints
+ */
+export async function fetchPRSplittingContext(featureId, verbose) {
+    try {
+        if (verbose) {
+            logInfo(`Fetching PR splitting context for feature: ${featureId}`);
+        }
+        // Fetch all required data in parallel for better performance
+        const [feature, existing_branches, existing_pull_requests] = await Promise.all([
+            getFeature(featureId, verbose),
+            getBranches({ featureId, verbose }).catch(() => []),
+            getPullRequests({ featureId, verbose }).catch(() => []),
+        ]);
+        const product = await getProduct(feature.product_id, verbose);
+        if (verbose) {
+            logInfo(`✅ PR splitting context fetched successfully:`);
+            logInfo(`   Feature: ${feature.name}`);
+            logInfo(`   Product: ${product.name}`);
+            logInfo(`   Technical Design: ${feature.technical_design ? 'Yes' : 'No'}`);
+            logInfo(`   Existing Branches: ${existing_branches.length}`);
+            logInfo(`   Existing Pull Requests: ${existing_pull_requests.length}`);
+        }
+        return {
+            feature,
+            product,
+            existing_branches,
+            existing_pull_requests,
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logError(`Failed to fetch PR splitting context: ${errorMessage}`);
+        throw new Error(`Context fetch failed: ${errorMessage}`);
+    }
+}

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

@@ -0,0 +1,29 @@
+import { EdsgerConfig } from '../../types/index.js';
+export interface PRSplittingOptions {
+    featureId: string;
+    verbose?: boolean;
+    replaceExisting?: boolean;
+}
+export interface PlannedPullRequest {
+    sequence: number;
+    name: string;
+    description: string;
+    branch_name?: string;
+    depends_on_branch_name?: string | null;
+    files?: Array<{
+        path: string;
+        change_type: string;
+    }>;
+    scope?: string[];
+    acceptance_criteria?: string[];
+}
+export interface PRSplittingResult {
+    featureId: string;
+    pullRequests: PlannedPullRequest[];
+    status: 'success' | 'error';
+    summary: string;
+    rationale?: string;
+}
+export declare const splitFeatureIntoPRs: (options: PRSplittingOptions, config: EdsgerConfig) => Promise<PRSplittingResult>;
+export { fetchPRSplittingContext } from './context.js';
+export type { PRSplittingContext } from './context.js';

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

@@ -0,0 +1,361 @@
+import { query } from '@anthropic-ai/claude-agent-sdk';
+import { DEFAULT_MODEL } from '../../constants.js';
+import { logInfo, logError } from '../../utils/logger.js';
+import { fetchPRSplittingContext } from './context.js';
+import { createPRSplittingSystemPrompt, createPRSplittingPromptWithContext, createImprovementPrompt, formatContextForPrompt, formatExistingPRsForPrompt, } from './prompts.js';
+import { buildSuccessResult, buildErrorResult, buildNoChangeResult, validatePlannedPRs, sortPRsByDependency, } from './outcome.js';
+import { createPullRequests, clearPullRequests, } from '../../services/pull-requests.js';
+import { logFeaturePhaseEvent } from '../../services/audit-logs.js';
+import { getFeedbacksForPhase, formatFeedbacksForContext, } from '../../services/feedbacks.js';
+function userMessage(content) {
+    return {
+        type: 'user',
+        message: { role: 'user', content: content },
+    };
+}
+async function* prompt(analysisPrompt) {
+    yield userMessage(analysisPrompt);
+    await new Promise((res) => setTimeout(res, 10000));
+}
+export const splitFeatureIntoPRs = async (options, config) => {
+    const { featureId, verbose, replaceExisting } = options;
+    if (verbose) {
+        logInfo(`Starting PR splitting for feature ID: ${featureId}`);
+    }
+    try {
+        // Log phase start
+        await logFeaturePhaseEvent({
+            featureId,
+            eventType: 'phase_started',
+            phase: 'pr_splitting',
+            result: 'info',
+            metadata: {
+                replace_existing: replaceExisting || false,
+                timestamp: new Date().toISOString(),
+            },
+        }, verbose);
+        // Fetch context
+        const context = await fetchPRSplittingContext(featureId, verbose);
+        // Fetch feedbacks for pr-splitting phase
+        let feedbacksContext = null;
+        let hasFeedbacks = false;
+        try {
+            feedbacksContext = await getFeedbacksForPhase({ featureId, verbose }, 'pr-splitting');
+            hasFeedbacks = feedbacksContext.feedbacks.length > 0;
+            if (verbose) {
+                logInfo(`📋 Feedbacks fetched: ${feedbacksContext.feedbacks.length} feedbacks found`);
+            }
+        }
+        catch (error) {
+            if (verbose) {
+                logError(`Failed to fetch feedbacks: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        // Determine operation mode
+        const hasExistingPRs = context.existing_pull_requests.length > 0;
+        const isIncrementalUpdate = hasExistingPRs && hasFeedbacks && !replaceExisting;
+        if (verbose) {
+            logInfo('\n📋 PR Splitting Mode Decision:');
+            logInfo(`   - Has existing PRs: ${hasExistingPRs} (${context.existing_pull_requests.length} PRs)`);
+            logInfo(`   - Has feedbacks: ${hasFeedbacks} (${feedbacksContext?.feedbacks.length || 0} feedbacks)`);
+            logInfo(`   - Replace existing: ${replaceExisting || false}`);
+            logInfo(`   - Mode: ${isIncrementalUpdate ? '🔄 Incremental Update' : hasExistingPRs && !replaceExisting ? '✅ No Change Needed' : '✨ New Planning'}`);
+        }
+        // Check if there are existing PRs and no feedbacks - no change needed
+        if (hasExistingPRs && !hasFeedbacks && !replaceExisting) {
+            if (verbose) {
+                logInfo(`Feature already has ${context.existing_pull_requests.length} PRs planned and no feedbacks to address.`);
+                logInfo('Use replaceExisting: true to re-plan.');
+            }
+            return buildNoChangeResult(featureId, context.existing_pull_requests.length);
+        }
+        // Clear existing PRs if requested (full re-plan)
+        if (replaceExisting && hasExistingPRs) {
+            if (verbose) {
+                logInfo(`Clearing ${context.existing_pull_requests.length} existing PRs for full re-plan...`);
+            }
+            await clearPullRequests({ featureId, verbose }, true);
+        }
+        // Format context for prompt
+        const contextInfo = formatContextForPrompt(context.feature, context.product, context.existing_branches);
+        const existingPRsInfo = formatExistingPRsForPrompt(context.existing_pull_requests);
+        // Create prompts based on mode
+        const systemPrompt = createPRSplittingSystemPrompt(config, featureId);
+        let userPrompt;
+        if (isIncrementalUpdate && feedbacksContext) {
+            if (verbose) {
+                logInfo('\n🎯 Feedbacks that will be addressed:');
+                feedbacksContext.feedbacks.forEach((fb, idx) => {
+                    logInfo(`   ${idx + 1}. [${fb.feedback_type}] ${fb.title}`);
+                    logInfo(`      ${fb.content.substring(0, 100)}${fb.content.length > 100 ? '...' : ''}`);
+                });
+            }
+            const feedbacksInfo = await formatFeedbacksForContext(feedbacksContext);
+            const currentPlanInfo = existingPRsInfo || 'No existing PR plan documented.';
+            userPrompt = createImprovementPrompt(feedbacksInfo, currentPlanInfo);
+            userPrompt = `${userPrompt}\n\n## Feature Context\n\n${contextInfo}`;
+        }
+        else {
+            userPrompt = createPRSplittingPromptWithContext(featureId, contextInfo, existingPRsInfo);
+        }
+        if (verbose) {
+            logInfo('Starting Claude Code query for PR splitting...');
+        }
+        // Execute query
+        const result = await executePRSplittingQuery(userPrompt, systemPrompt, config, verbose);
+        if (!result ||
+            !result.pullRequests ||
+            result.pullRequests.length === 0) {
+            const errorMsg = 'No pull requests were generated';
+            logError(errorMsg);
+            return buildErrorResult(featureId, errorMsg);
+        }
+        // Validate PRs
+        const validation = validatePlannedPRs(result.pullRequests);
+        if (!validation.valid) {
+            const errorMsg = `Invalid PR plan: ${validation.errors.join(', ')}`;
+            logError(errorMsg);
+            return buildErrorResult(featureId, errorMsg);
+        }
+        // Sort PRs by dependency
+        const sortedPRs = sortPRsByDependency(result.pullRequests);
+        // For incremental update mode, clear existing PRs before creating new ones
+        if (isIncrementalUpdate && hasExistingPRs) {
+            if (verbose) {
+                logInfo(`🔄 Clearing ${context.existing_pull_requests.length} existing PRs for incremental update...`);
+            }
+            await clearPullRequests({ featureId, verbose: false }, true);
+        }
+        // Create PRs in database with proper dependencies
+        const prBranchNameToId = new Map();
+        const prInputs = [];
+        for (const pr of sortedPRs) {
+            let basePrId;
+            if (pr.depends_on_branch_name) {
+                basePrId = prBranchNameToId.get(pr.depends_on_branch_name);
+            }
+            prInputs.push({
+                sequence: pr.sequence,
+                name: pr.name,
+                description: pr.description,
+                branch_name: pr.branch_name,
+                base_pr_id: basePrId,
+                files: pr.files,
+            });
+        }
+        const created = await createPullRequests({ featureId, verbose: false }, prInputs);
+        // Build the branch name to ID mapping from created PRs
+        created.forEach((createdPR) => {
+            if (createdPR.branch_name) {
+                prBranchNameToId.set(createdPR.branch_name, createdPR.id);
+            }
+        });
+        if (verbose) {
+            const modeLabel = isIncrementalUpdate ? '🔄 Updated' : '✅ Created';
+            logInfo(`${modeLabel} ${sortedPRs.length} pull requests`);
+            sortedPRs.forEach((pr) => {
+                logInfo(`   ${pr.sequence}. ${pr.name}`);
+                if (pr.files) {
+                    logInfo(`      Files: ${pr.files.map((f) => f.path).join(', ')}`);
+                }
+            });
+        }
+        // Log phase completion
+        await logFeaturePhaseEvent({
+            featureId,
+            eventType: 'phase_completed',
+            phase: 'pr_splitting',
+            result: 'success',
+            metadata: {
+                prs_created: sortedPRs.length,
+                pr_names: sortedPRs.map((pr) => pr.name),
+                mode: isIncrementalUpdate ? 'incremental_update' : 'new_planning',
+                feedbacks_addressed: feedbacksContext?.feedbacks.length || 0,
+                timestamp: new Date().toISOString(),
+            },
+        }, verbose);
+        const summaryPrefix = isIncrementalUpdate
+            ? `Updated PR plan based on ${feedbacksContext?.feedbacks.length || 0} feedbacks.`
+            : '';
+        return buildSuccessResult(featureId, sortedPRs, result.summary ||
+            `${summaryPrefix} ${sortedPRs.length} pull requests for incremental review`.trim(), result.rationale);
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logError(`PR splitting failed: ${errorMessage}`);
+        // Log phase failure
+        await logFeaturePhaseEvent({
+            featureId,
+            eventType: 'phase_failed',
+            phase: 'pr_splitting',
+            result: 'error',
+            metadata: {
+                error: errorMessage,
+                timestamp: new Date().toISOString(),
+            },
+        }, verbose);
+        return buildErrorResult(featureId, errorMessage);
+    }
+};
+/**
+ * Execute the PR splitting query and parse the result
+ */
+async function executePRSplittingQuery(userPrompt, systemPrompt, config, verbose) {
+    let lastAssistantResponse = '';
+    let structuredResult = null;
+    if (verbose) {
+        logInfo('🤖 Starting PR splitting 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') {
+                    lastAssistantResponse += content.text + '\n';
+                    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📋 PR splitting completed, parsing results...');
+                try {
+                    const responseText = message.result || lastAssistantResponse;
+                    structuredResult = parseJsonResponse(responseText, verbose);
+                }
+                catch (error) {
+                    logError(`Failed to parse PR splitting result: ${error}`);
+                }
+            }
+            else {
+                logError(`\n⚠️ PR splitting incomplete: ${message.subtype}`);
+            }
+        }
+    }
+    if (!structuredResult) {
+        return null;
+    }
+    return {
+        pullRequests: structuredResult.pullRequests || [],
+        summary: structuredResult.summary,
+        rationale: structuredResult.rationale,
+    };
+}
+/**
+ * Parse JSON response from Claude
+ */
+function parseJsonResponse(responseText, verbose) {
+    // Try to extract JSON from markdown code block
+    const jsonBlockMatch = responseText.match(/```json\s*\n([\s\S]*?)\n\s*```/);
+    if (jsonBlockMatch) {
+        try {
+            const parsed = JSON.parse(jsonBlockMatch[1]);
+            if (parsed.pr_splitting_result) {
+                return {
+                    pullRequests: parsed.pr_splitting_result.pull_requests || [],
+                    summary: parsed.pr_splitting_result.summary,
+                    rationale: parsed.pr_splitting_result.rationale,
+                };
+            }
+            if (parsed.pull_requests) {
+                return {
+                    pullRequests: parsed.pull_requests,
+                    summary: parsed.summary,
+                    rationale: parsed.rationale,
+                };
+            }
+            return parsed;
+        }
+        catch (e) {
+            if (verbose) {
+                logError(`Failed to parse JSON from code block: ${e}`);
+            }
+        }
+    }
+    // Try to find JSON object containing "pr_splitting_result"
+    const resultMatch = responseText.match(/\{[\s\S]*"pr_splitting_result"[\s\S]*\}/);
+    if (resultMatch) {
+        try {
+            let braceCount = 0;
+            let startIndex = -1;
+            let endIndex = -1;
+            for (let i = 0; i < responseText.length; i++) {
+                if (responseText[i] === '{') {
+                    if (startIndex === -1)
+                        startIndex = i;
+                    braceCount++;
+                }
+                else if (responseText[i] === '}') {
+                    braceCount--;
+                    if (braceCount === 0 && startIndex !== -1) {
+                        endIndex = i;
+                        break;
+                    }
+                }
+            }
+            if (startIndex !== -1 && endIndex !== -1) {
+                const jsonStr = responseText.substring(startIndex, endIndex + 1);
+                const parsed = JSON.parse(jsonStr);
+                if (parsed.pr_splitting_result) {
+                    return {
+                        pullRequests: parsed.pr_splitting_result.pull_requests || [],
+                        summary: parsed.pr_splitting_result.summary,
+                        rationale: parsed.pr_splitting_result.rationale,
+                    };
+                }
+            }
+        }
+        catch (e) {
+            if (verbose) {
+                logError(`Failed to extract JSON from response: ${e}`);
+            }
+        }
+    }
+    // Try to parse the entire response as JSON
+    try {
+        const parsed = JSON.parse(responseText);
+        if (parsed.pr_splitting_result) {
+            return {
+                pullRequests: parsed.pr_splitting_result.pull_requests || [],
+                summary: parsed.pr_splitting_result.summary,
+                rationale: parsed.pr_splitting_result.rationale,
+            };
+        }
+        if (parsed.pull_requests) {
+            return {
+                pullRequests: parsed.pull_requests,
+                summary: parsed.summary,
+                rationale: parsed.rationale,
+            };
+        }
+    }
+    catch (e) {
+        if (verbose) {
+            logError(`Failed to parse response as JSON: ${e}`);
+        }
+    }
+    return null;
+}
+// Re-export types and functions for external use
+export { fetchPRSplittingContext } from './context.js';

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

@@ -0,0 +1,24 @@
+import { PRSplittingResult, PlannedPullRequest } from './index.js';
+/**
+ * Build a successful PR splitting result
+ */
+export declare function buildSuccessResult(featureId: string, pullRequests: PlannedPullRequest[], summary: string, rationale?: string): PRSplittingResult;
+/**
+ * Build an error result
+ */
+export declare function buildErrorResult(featureId: string, errorMessage: string): PRSplittingResult;
+/**
+ * Build a result when no changes are needed
+ */
+export declare function buildNoChangeResult(featureId: string, existingPRCount: number): PRSplittingResult;
+/**
+ * Validate planned pull requests
+ */
+export declare function validatePlannedPRs(prs: PlannedPullRequest[]): {
+    valid: boolean;
+    errors: string[];
+};
+/**
+ * Sort pull requests by dependency order (topological sort based on depends_on_branch_name)
+ */
+export declare function sortPRsByDependency(prs: PlannedPullRequest[]): PlannedPullRequest[];