edsger 0.26.0 → 0.26.2

package/dist/api/features/__tests__/status-updater.integration.test.js

@@ -0,0 +1,497 @@
+/**
+ * Integration tests for status updater functionality
+ * Tests the complete flow including MCP calls and error handling
+ */
+import { describe, it, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert';
+import { updateFeatureStatus, updateFeatureStatusForPhase, getStatusForPhase, } from '../status-updater.js';
+// Mock modules
+let mockCallMcpEndpoint;
+let mockGetFeature;
+let originalCallMcpEndpoint;
+let originalGetFeature;
+// Test data
+const mockFeatureInfo = {
+    id: 'test-feature-id',
+    name: 'Test Feature',
+    description: 'Test feature description',
+    status: 'backlog',
+    product_id: 'test-product-id',
+    execution_mode: 'auto',
+    created_at: '2025-11-13T00:00:00Z',
+    updated_at: '2025-11-13T00:00:00Z',
+};
+// Setup mocks before tests
+const setupMocks = () => {
+    // Mock successful MCP call
+    mockCallMcpEndpoint = async (method, params) => {
+        if (method === 'features/update') {
+            return { success: true };
+        }
+        throw new Error(`Unexpected method: ${method}`);
+    };
+    // Mock successful getFeature call
+    mockGetFeature = async (featureId, verbose) => {
+        return { ...mockFeatureInfo, id: featureId };
+    };
+};
+// Restore original functions
+const restoreMocks = () => {
+    if (originalCallMcpEndpoint) {
+        // Note: In a real test environment, we would need proper module mocking
+        // This is a simplified version for demonstration
+    }
+};
+describe('Status Updater Integration Tests', () => {
+    beforeEach(() => {
+        setupMocks();
+    });
+    afterEach(() => {
+        restoreMocks();
+    });
+    describe('updateFeatureStatus', () => {
+        it('should successfully update feature status when progression is valid', async () => {
+            // Set current status to backlog
+            mockGetFeature = async (featureId) => ({
+                ...mockFeatureInfo,
+                id: featureId,
+                status: 'backlog',
+            });
+            let mcpCalled = false;
+            let updateParams = null;
+            mockCallMcpEndpoint = async (method, params) => {
+                if (method === 'features/update') {
+                    mcpCalled = true;
+                    updateParams = params;
+                    return { success: true };
+                }
+                throw new Error(`Unexpected method: ${method}`);
+            };
+            const result = await updateFeatureStatus({
+                featureId: 'test-feature-id',
+                status: 'ready_for_dev',
+                verbose: true,
+            });
+            assert.strictEqual(result, true, 'Should return true for successful update');
+            assert.strictEqual(mcpCalled, true, 'Should call MCP endpoint');
+            assert.deepStrictEqual(updateParams, {
+                feature_id: 'test-feature-id',
+                status: 'ready_for_dev',
+            }, 'Should pass correct parameters to MCP');
+        });
+        it('should prevent status regression', async () => {
+            // Set current status to ready_for_dev
+            mockGetFeature = async (featureId) => ({
+                ...mockFeatureInfo,
+                id: featureId,
+                status: 'ready_for_dev',
+            });
+            let mcpCalled = false;
+            mockCallMcpEndpoint = async () => {
+                mcpCalled = true;
+                return { success: true };
+            };
+            const result = await updateFeatureStatus({
+                featureId: 'test-feature-id',
+                status: 'backlog', // This is a regression
+                verbose: true,
+            });
+            assert.strictEqual(result, false, 'Should return false for regression attempt');
+            assert.strictEqual(mcpCalled, false, 'Should not call MCP endpoint for regression');
+        });
+        it('should allow staying at the same status', async () => {
+            // Set current status to feature_analysis
+            mockGetFeature = async (featureId) => ({
+                ...mockFeatureInfo,
+                id: featureId,
+                status: 'feature_analysis',
+            });
+            let mcpCalled = false;
+            mockCallMcpEndpoint = async () => {
+                mcpCalled = true;
+                return { success: true };
+            };
+            const result = await updateFeatureStatus({
+                featureId: 'test-feature-id',
+                status: 'feature_analysis', // Same status
+                verbose: true,
+            });
+            assert.strictEqual(result, true, 'Should return true when status is already at target');
+            assert.strictEqual(mcpCalled, false, 'Should not call MCP when status is unchanged');
+        });
+        it('should handle getFeature errors gracefully', async () => {
+            // Mock getFeature to fail
+            mockGetFeature = async () => {
+                throw new Error('Feature not found');
+            };
+            let mcpCalled = false;
+            mockCallMcpEndpoint = async () => {
+                mcpCalled = true;
+                return { success: true };
+            };
+            const result = await updateFeatureStatus({
+                featureId: 'invalid-feature-id',
+                status: 'ready_for_dev',
+                verbose: true,
+            });
+            assert.strictEqual(result, false, 'Should return false when current status cannot be retrieved');
+            assert.strictEqual(mcpCalled, false, 'Should not call MCP when getFeature fails');
+        });
+        it('should handle MCP endpoint errors gracefully', async () => {
+            // Set current status to backlog
+            mockGetFeature = async (featureId) => ({
+                ...mockFeatureInfo,
+                id: featureId,
+                status: 'backlog',
+            });
+            // Mock MCP call to fail
+            mockCallMcpEndpoint = async () => {
+                throw new Error('MCP server error');
+            };
+            const result = await updateFeatureStatus({
+                featureId: 'test-feature-id',
+                status: 'ready_for_dev',
+                verbose: true,
+            });
+            assert.strictEqual(result, false, 'Should return false when MCP call fails');
+        });
+        it('should handle complex status progressions correctly', async () => {
+            // Test progression from middle of workflow to end
+            mockGetFeature = async (featureId) => ({
+                ...mockFeatureInfo,
+                id: featureId,
+                status: 'code_implementation',
+            });
+            let mcpCalled = false;
+            let updateParams = null;
+            mockCallMcpEndpoint = async (method, params) => {
+                mcpCalled = true;
+                updateParams = params;
+                return { success: true };
+            };
+            const result = await updateFeatureStatus({
+                featureId: 'test-feature-id',
+                status: 'shipped',
+                verbose: false, // Test non-verbose mode
+            });
+            assert.strictEqual(result, true, 'Should allow forward progression');
+            assert.strictEqual(mcpCalled, true, 'Should call MCP endpoint');
+            assert.strictEqual(updateParams.status, 'shipped', 'Should pass correct target status');
+        });
+        it('should handle testing workflow edge cases', async () => {
+            // Test progression from testing_failed back to testing_in_progress (retry)
+            mockGetFeature = async (featureId) => ({
+                ...mockFeatureInfo,
+                id: featureId,
+                status: 'testing_failed',
+            });
+            let updateParams = null;
+            mockCallMcpEndpoint = async (method, params) => {
+                updateParams = params;
+                return { success: true };
+            };
+            const result = await updateFeatureStatus({
+                featureId: 'test-feature-id',
+                status: 'testing_in_progress',
+                verbose: true,
+            });
+            // This should be prevented because testing_in_progress comes before testing_failed
+            // in the progression order
+            assert.strictEqual(result, false, 'Should prevent regression from testing_failed to testing_in_progress');
+        });
+    });
+    describe('updateFeatureStatusForPhase', () => {
+        it('should successfully update status for known phases', async () => {
+            mockGetFeature = async (featureId) => ({
+                ...mockFeatureInfo,
+                id: featureId,
+                status: 'backlog',
+            });
+            let mcpCalled = false;
+            let updateParams = null;
+            mockCallMcpEndpoint = async (method, params) => {
+                mcpCalled = true;
+                updateParams = params;
+                return { success: true };
+            };
+            const result = await updateFeatureStatusForPhase('test-feature-id', 'feature-analysis', true);
+            assert.strictEqual(result, true, 'Should return true for known phase');
+            assert.strictEqual(mcpCalled, true, 'Should call MCP endpoint');
+            assert.strictEqual(updateParams.status, 'feature_analysis', 'Should map phase to correct status');
+        });
+        it('should reject unknown phases', async () => {
+            let mcpCalled = false;
+            mockCallMcpEndpoint = async () => {
+                mcpCalled = true;
+                return { success: true };
+            };
+            const result = await updateFeatureStatusForPhase('test-feature-id', 'unknown-phase', true);
+            assert.strictEqual(result, false, 'Should return false for unknown phase');
+            assert.strictEqual(mcpCalled, false, 'Should not call MCP for unknown phase');
+        });
+        it('should handle all mapped phases correctly', async () => {
+            const phaseStatusPairs = [
+                ['feature-analysis', 'feature_analysis'],
+                ['feature-analysis-verification', 'feature_analysis_verification'],
+                ['technical-design', 'technical_design'],
+                ['technical-design-verification', 'technical_design_verification'],
+                ['code-implementation', 'code_implementation'],
+                ['code-implementation-verification', 'code_implementation_verification'],
+                ['code-refine', 'code_refine'],
+                ['code-refine-verification', 'code_refine_verification'],
+                ['bug-fixing', 'bug_fixing'],
+                ['code-review', 'code_review'],
+                ['pull-request', 'pull_request'],
+                ['functional-testing', 'functional_testing'],
+                ['deployment', 'deployment'],
+                ['testing-in-progress', 'testing_in_progress'],
+                ['testing-passed', 'testing_passed'],
+                ['testing-failed', 'testing_failed'],
+            ];
+            for (const [phase, expectedStatus] of phaseStatusPairs) {
+                mockGetFeature = async (featureId) => ({
+                    ...mockFeatureInfo,
+                    id: featureId,
+                    status: 'backlog', // Start from backlog each time
+                });
+                let capturedStatus = null;
+                mockCallMcpEndpoint = async (method, params) => {
+                    if (method === 'features/update') {
+                        capturedStatus = params.status;
+                        return { success: true };
+                    }
+                    return {};
+                };
+                const result = await updateFeatureStatusForPhase('test-feature-id', phase, false);
+                assert.strictEqual(result, true, `Phase ${phase} should be processed successfully`);
+                assert.strictEqual(capturedStatus, expectedStatus, `Phase ${phase} should map to status ${expectedStatus}`);
+            }
+        });
+        it('should propagate errors from updateFeatureStatus', async () => {
+            mockGetFeature = async () => {
+                throw new Error('Database connection failed');
+            };
+            const result = await updateFeatureStatusForPhase('test-feature-id', 'feature-analysis', true);
+            assert.strictEqual(result, false, 'Should return false when underlying update fails');
+        });
+        it('should respect regression prevention in phase updates', async () => {
+            // Set current status to shipped
+            mockGetFeature = async (featureId) => ({
+                ...mockFeatureInfo,
+                id: featureId,
+                status: 'shipped',
+            });
+            let mcpCalled = false;
+            mockCallMcpEndpoint = async () => {
+                mcpCalled = true;
+                return { success: true };
+            };
+            // Try to update to a phase that would regress the status
+            const result = await updateFeatureStatusForPhase('test-feature-id', 'feature-analysis', // This would be regression from shipped
+            true);
+            assert.strictEqual(result, false, 'Should prevent regression even when phase is valid');
+            assert.strictEqual(mcpCalled, false, 'Should not call MCP for regression attempt');
+        });
+    });
+    describe('getStatusForPhase', () => {
+        it('should return correct status for all known phases', () => {
+            const testCases = [
+                ['feature-analysis', 'feature_analysis'],
+                ['technical-design', 'technical_design'],
+                ['code-implementation', 'code_implementation'],
+                ['functional-testing', 'functional_testing'],
+                ['deployment', 'deployment'],
+                ['testing-passed', 'testing_passed'],
+            ];
+            for (const [phase, expectedStatus] of testCases) {
+                const result = getStatusForPhase(phase);
+                assert.strictEqual(result, expectedStatus, `Phase ${phase} should map to ${expectedStatus}`);
+            }
+        });
+        it('should return null for unknown phases', () => {
+            const unknownPhases = [
+                'unknown-phase',
+                'invalid-phase',
+                'some-random-string',
+                '',
+                'feature_analysis', // Wrong format (underscore instead of hyphen)
+                'technical_design', // Wrong format
+            ];
+            for (const phase of unknownPhases) {
+                const result = getStatusForPhase(phase);
+                assert.strictEqual(result, null, `Unknown phase ${phase} should return null`);
+            }
+        });
+        it('should handle edge cases', () => {
+            // Test case sensitivity
+            assert.strictEqual(getStatusForPhase('Feature-Analysis'), null, 'Should be case sensitive');
+            // Test whitespace
+            assert.strictEqual(getStatusForPhase(' feature-analysis '), null, 'Should not handle whitespace');
+            // Test empty string
+            assert.strictEqual(getStatusForPhase(''), null, 'Should return null for empty string');
+        });
+        it('should maintain consistency with phase naming conventions', () => {
+            // All returned statuses should use snake_case
+            const phases = [
+                'feature-analysis',
+                'technical-design',
+                'code-implementation',
+                'functional-testing',
+            ];
+            for (const phase of phases) {
+                const status = getStatusForPhase(phase);
+                if (status) {
+                    assert.ok(!status.includes('-'), `Status ${status} should not contain hyphens`);
+                    if (status.includes('_')) {
+                        assert.ok(status.split('_').length > 1, `Multi-word status ${status} should use snake_case`);
+                    }
+                }
+            }
+        });
+    });
+    describe('Async Behavior and Breaking Changes', () => {
+        it('should handle updateFeatureStatusForPhase as async function', async () => {
+            mockGetFeature = async (featureId) => ({
+                ...mockFeatureInfo,
+                id: featureId,
+                status: 'backlog',
+            });
+            mockCallMcpEndpoint = async () => ({ success: true });
+            // Verify the function returns a Promise
+            const resultPromise = updateFeatureStatusForPhase('test-feature-id', 'feature-analysis');
+            assert.ok(resultPromise instanceof Promise, 'updateFeatureStatusForPhase should return a Promise');
+            const result = await resultPromise;
+            assert.strictEqual(typeof result, 'boolean', 'Promise should resolve to boolean');
+        });
+        it('should handle concurrent status updates correctly', async () => {
+            let mcpCallCount = 0;
+            const mcpCalls = [];
+            mockGetFeature = async (featureId) => ({
+                ...mockFeatureInfo,
+                id: featureId,
+                status: 'backlog',
+            });
+            mockCallMcpEndpoint = async (method, params) => {
+                mcpCallCount++;
+                mcpCalls.push({ method, params });
+                // Simulate some delay
+                await new Promise(resolve => setTimeout(resolve, 10));
+                return { success: true };
+            };
+            // Start multiple updates concurrently
+            const promises = [
+                updateFeatureStatusForPhase('feature-1', 'feature-analysis'),
+                updateFeatureStatusForPhase('feature-2', 'technical-design'),
+                updateFeatureStatusForPhase('feature-3', 'code-implementation'),
+            ];
+            const results = await Promise.all(promises);
+            assert.strictEqual(results.length, 3, 'Should handle all concurrent updates');
+            assert.ok(results.every(r => r === true), 'All updates should succeed');
+            assert.strictEqual(mcpCallCount, 3, 'Should make correct number of MCP calls');
+        });
+        it('should maintain proper error isolation in concurrent updates', async () => {
+            let callCount = 0;
+            mockGetFeature = async (featureId) => {
+                callCount++;
+                if (featureId === 'failing-feature') {
+                    throw new Error('Feature not found');
+                }
+                return {
+                    ...mockFeatureInfo,
+                    id: featureId,
+                    status: 'backlog',
+                };
+            };
+            mockCallMcpEndpoint = async () => ({ success: true });
+            // Mix successful and failing updates
+            const promises = [
+                updateFeatureStatusForPhase('feature-1', 'feature-analysis'),
+                updateFeatureStatusForPhase('failing-feature', 'technical-design'),
+                updateFeatureStatusForPhase('feature-3', 'code-implementation'),
+            ];
+            const results = await Promise.all(promises);
+            assert.strictEqual(results[0], true, 'First update should succeed');
+            assert.strictEqual(results[1], false, 'Second update should fail');
+            assert.strictEqual(results[2], true, 'Third update should succeed');
+        });
+    });
+    describe('Error Handling and Edge Cases', () => {
+        it('should handle malformed feature data gracefully', async () => {
+            // Mock getFeature to return malformed data
+            mockGetFeature = async () => ({
+                id: 'test-feature',
+                // Missing required fields
+                status: null,
+            });
+            mockCallMcpEndpoint = async () => ({ success: true });
+            const result = await updateFeatureStatus({
+                featureId: 'test-feature-id',
+                status: 'ready_for_dev',
+                verbose: true,
+            });
+            assert.strictEqual(result, false, 'Should handle malformed feature data gracefully');
+        });
+        it('should handle network timeouts and retries', async () => {
+            let attemptCount = 0;
+            mockGetFeature = async (featureId) => ({
+                ...mockFeatureInfo,
+                id: featureId,
+                status: 'backlog',
+            });
+            mockCallMcpEndpoint = async () => {
+                attemptCount++;
+                if (attemptCount < 2) {
+                    throw new Error('Network timeout');
+                }
+                return { success: true };
+            };
+            const result = await updateFeatureStatus({
+                featureId: 'test-feature-id',
+                status: 'ready_for_dev',
+            });
+            // Since we don't implement retry logic, this should fail
+            assert.strictEqual(result, false, 'Should handle network errors');
+            assert.strictEqual(attemptCount, 1, 'Should only attempt once');
+        });
+        it('should handle very long feature IDs and status names', async () => {
+            const longFeatureId = 'a'.repeat(1000);
+            const validStatus = 'feature_analysis';
+            mockGetFeature = async (featureId) => ({
+                ...mockFeatureInfo,
+                id: featureId,
+                status: 'backlog',
+            });
+            let receivedParams = null;
+            mockCallMcpEndpoint = async (method, params) => {
+                receivedParams = params;
+                return { success: true };
+            };
+            const result = await updateFeatureStatus({
+                featureId: longFeatureId,
+                status: validStatus,
+            });
+            assert.strictEqual(result, true, 'Should handle long feature IDs');
+            assert.strictEqual(receivedParams?.feature_id, longFeatureId, 'Should pass through long feature ID correctly');
+        });
+        it('should handle status transitions at workflow boundaries', async () => {
+            // Test transition from last testing status to deployment
+            mockGetFeature = async (featureId) => ({
+                ...mockFeatureInfo,
+                id: featureId,
+                status: 'testing_passed',
+            });
+            let updateParams = null;
+            mockCallMcpEndpoint = async (method, params) => {
+                updateParams = params;
+                return { success: true };
+            };
+            const result = await updateFeatureStatus({
+                featureId: 'test-feature-id',
+                status: 'deployment',
+                verbose: true,
+            });
+            assert.strictEqual(result, true, 'Should allow progression from testing to deployment');
+            assert.strictEqual(updateParams.status, 'deployment', 'Should update to deployment status');
+        });
+    });
+});

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

@@ -7,6 +7,7 @@ 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 { executeFeaturePRs } from '../../../phases/pr-execution/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';
@@ -100,6 +101,10 @@ export const phaseConfigs = [
         name: 'pr-splitting',
         execute: splitFeatureIntoPRs,
     },
+    {
+        name: 'pr-execution',
+        execute: executeFeaturePRs,
+    },
     {
         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>, 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, };
+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>, runPRExecutionPhase: (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, runPRExecutionPhase, 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, runPRSplittingPhase, runFunctionalTestingPhase, runCodeTestingPhase, runCodeRefinePhase, runCodeRefineVerificationPhase, runCodeReviewPhase, runAutonomousPhase,] = phaseConfigs.map(createPhaseRunner);
+const [runFeatureAnalysisPhase, runUserStoriesAnalysisPhase, runTestCasesAnalysisPhase, runTechnicalDesignPhase, runBranchPlanningPhase, runCodeImplementationPhase, runPRSplittingPhase, runPRExecutionPhase, runFunctionalTestingPhase, runCodeTestingPhase, runCodeRefinePhase, runCodeRefineVerificationPhase, runCodeReviewPhase, runAutonomousPhase,] = phaseConfigs.map(createPhaseRunner);
 // Export individual phase runners for granular control
-export { runFeatureAnalysisPhase, runUserStoriesAnalysisPhase, runTestCasesAnalysisPhase, runTechnicalDesignPhase, runBranchPlanningPhase, runCodeImplementationPhase, runPRSplittingPhase, runFunctionalTestingPhase, runCodeTestingPhase, runCodeRefinePhase, runCodeRefineVerificationPhase, runCodeReviewPhase, runAutonomousPhase, };
+export { runFeatureAnalysisPhase, runUserStoriesAnalysisPhase, runTestCasesAnalysisPhase, runTechnicalDesignPhase, runBranchPlanningPhase, runCodeImplementationPhase, runPRSplittingPhase, runPRExecutionPhase, runFunctionalTestingPhase, runCodeTestingPhase, runCodeRefinePhase, runCodeRefineVerificationPhase, runCodeReviewPhase, runAutonomousPhase, };

package/dist/commands/workflow/feature-coordinator.js

@@ -13,7 +13,7 @@ import { getFeature } from '../../api/features/get-feature.js';
 import { markWorkflowPhaseCompleted } from '../../api/features/update-feature.js';
 import { logError, logInfo, logWarning } from '../../utils/logger.js';
 import { logPhaseResult } from '../../utils/pipeline-logger.js';
-import { runFeatureAnalysisPhase, runUserStoriesAnalysisPhase, runTestCasesAnalysisPhase, runTechnicalDesignPhase, runBranchPlanningPhase, runCodeImplementationPhase, runFunctionalTestingPhase, runCodeRefinePhase, runCodeReviewPhase, runAutonomousPhase, } from './executors/phase-executor.js';
+import { runFeatureAnalysisPhase, runUserStoriesAnalysisPhase, runTestCasesAnalysisPhase, runTechnicalDesignPhase, runBranchPlanningPhase, runCodeImplementationPhase, runPRSplittingPhase, runPRExecutionPhase, runFunctionalTestingPhase, runCodeRefinePhase, runCodeReviewPhase, runAutonomousPhase, } from './executors/phase-executor.js';
 /**
  * Map workflow phase names (underscore format) to phase runner functions
  * Note: code_refine includes built-in verification loop (similar to technical_design)
@@ -25,6 +25,8 @@ const PHASE_RUNNERS = {
     technical_design: runTechnicalDesignPhase,
     branch_planning: runBranchPlanningPhase,
     code_implementation: runCodeImplementationPhase,
+    pr_splitting: runPRSplittingPhase,
+    pr_execution: runPRExecutionPhase,
     functional_testing: runFunctionalTestingPhase,
     code_review: runCodeReviewPhase,
     code_refine: runCodeRefinePhase,

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, runPRSplittingPhase, runFunctionalTestingPhase, runCodeTestingPhase, runCodeReviewPhase, } from './executors/phase-executor.js';
+import { runFeatureAnalysisPhase, runUserStoriesAnalysisPhase, runTestCasesAnalysisPhase, runTechnicalDesignPhase, runCodeImplementationPhase, runPRSplittingPhase, runPRExecutionPhase, 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';
@@ -83,6 +83,11 @@ export const runPipelineByMode = async (options, config, executionMode) => {
             return await runOnlyPRSplitting(options, config);
         case 'from_pr_splitting':
             return await runFromPRSplitting(options, config);
+        // PR Execution
+        case 'only_pr_execution':
+            return await runOnlyPRExecution(options, config);
+        case 'from_pr_execution':
+            return await runFromPRExecution(options, config);
         // Functional Testing
         case 'only_functional_testing':
             return await runOnlyFunctionalTesting(options, config);
@@ -328,18 +333,76 @@ const runOnlyPRSplitting = async (options, config) => {
 };
 /**
  * Run from PR splitting to end
- * Flow: pr-splitting → functional-testing → ... → code-review → code-refine
+ * Flow: pr-splitting → (human review) → pr-execution → testing → ...
  */
 const runFromPRSplitting = async (options, config) => {
     const { featureId, verbose } = options;
     logPipelineStart(featureId, verbose);
     const results = [];
-    // 1. PR Splitting
+    // 1. PR Splitting (planning only)
     const prSplittingResult = await runPRSplittingPhase(options, config);
     results.push(await logAndMarkPhaseCompleted(prSplittingResult, verbose));
     if (!shouldContinuePipeline(results)) {
         return finalizePipelineExecution(options, results, verbose);
     }
+    // 2. PR Execution (create branches, push, create GitHub PRs)
+    const prExecutionResult = await runPRExecutionPhase(options, config);
+    results.push(await logAndMarkPhaseCompleted(prExecutionResult, verbose));
+    if (!shouldContinuePipeline(results)) {
+        return finalizePipelineExecution(options, results, verbose);
+    }
+    // 3. 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 PR execution phase
+ */
+const runOnlyPRExecution = async (options, config) => {
+    const { featureId, verbose } = options;
+    logPipelineStart(featureId, verbose);
+    const results = [];
+    const prExecutionResult = await runPRExecutionPhase(options, config);
+    results.push(await logAndMarkPhaseCompleted(prExecutionResult, verbose));
+    return finalizePipelineExecution(options, results, verbose);
+};
+/**
+ * Run from PR execution to end
+ * Flow: pr-execution → testing → code-review → code-refine
+ */
+const runFromPRExecution = async (options, config) => {
+    const { featureId, verbose } = options;
+    logPipelineStart(featureId, verbose);
+    const results = [];
+    // 1. PR Execution
+    const prExecutionResult = await runPRExecutionPhase(options, config);
+    results.push(await logAndMarkPhaseCompleted(prExecutionResult, verbose));
+    if (!shouldContinuePipeline(results)) {
+        return finalizePipelineExecution(options, results, verbose);
+    }
     // 2. Functional Testing with retry loop for bug fixes
     const testingResult = await handleTestFailuresWithRetry({
         options,