edsger 0.41.0 → 0.41.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/pipeline-runner.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Pipeline runner for executing development workflow phases
+ * Complete pipeline flow:
+ *   feature-analysis → technical-design → code-implementation →
+ *   functional-testing → pull-request → code-review → code-refine → code-refine-verification
+ * Uses functional programming principles
+ */
+import { EdsgerConfig } from '../../types/index.js';
+import { PipelinePhaseOptions, PipelineResult, ExecutionMode } from '../../types/pipeline.js';
+/**
+ * Run pipeline based on execution mode
+ */
+export declare const runPipelineByMode: (options: PipelinePhaseOptions, config: EdsgerConfig, executionMode: ExecutionMode) => Promise<readonly PipelineResult[]>;
+/**
+ * Run complete pipeline for a feature using functional composition (legacy)
+ */
+export declare const runCompletePipeline: (options: PipelinePhaseOptions, config: EdsgerConfig) => () => Promise<readonly PipelineResult[]>;