edsger 0.45.1 → 0.47.0

package/dist/commands/workflow/core/__tests__/state-manager.test.js

@@ -0,0 +1,384 @@
+/**
+ * Unit tests for workflow state management utilities
+ */
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+import { calculateStats, createCompletedState, createFailedState, createInitialState, createProcessingState, updateFeatureState, } from '../state-manager.js';
+void describe('State Manager', () => {
+    void describe('createInitialState', () => {
+        void it('should return an empty Map', () => {
+            const state = createInitialState();
+            assert.ok(state instanceof Map, 'Should return a Map instance');
+            assert.strictEqual(state.size, 0, 'Map should be empty');
+        });
+        void it('should return a new Map on each call', () => {
+            const state1 = createInitialState();
+            const state2 = createInitialState();
+            assert.notStrictEqual(state1, state2, 'Each call should return a distinct Map');
+        });
+    });
+    void describe('createProcessingState', () => {
+        void it('should create a new processing state with retryCount 1 when no current state', () => {
+            const state = createProcessingState('feat-1');
+            assert.strictEqual(state.featureId, 'feat-1');
+            assert.strictEqual(state.retryCount, 1);
+            assert.strictEqual(state.status, 'processing');
+            assert.ok(state.lastAttempt instanceof Date, 'lastAttempt should be a Date');
+        });
+        void it('should increment retryCount when current state is provided', () => {
+            const currentState = {
+                featureId: 'feat-1',
+                retryCount: 2,
+                lastAttempt: new Date('2024-01-01'),
+                status: 'failed',
+            };
+            const state = createProcessingState('feat-1', currentState);
+            assert.strictEqual(state.retryCount, 3, 'Should increment retryCount by 1');
+            assert.strictEqual(state.status, 'processing');
+        });
+        void it('should set a recent lastAttempt date', () => {
+            const before = new Date();
+            const state = createProcessingState('feat-1');
+            const after = new Date();
+            assert.ok(state.lastAttempt.getTime() >= before.getTime(), 'lastAttempt should be at or after the call');
+            assert.ok(state.lastAttempt.getTime() <= after.getTime(), 'lastAttempt should be at or before now');
+        });
+        void it('should increment from retryCount 1 to 2', () => {
+            const currentState = {
+                featureId: 'feat-1',
+                retryCount: 1,
+                lastAttempt: new Date('2024-01-01'),
+                status: 'completed',
+            };
+            const state = createProcessingState('feat-1', currentState);
+            assert.strictEqual(state.retryCount, 2);
+        });
+    });
+    void describe('createCompletedState', () => {
+        void it('should create a completed state with retryCount 1 when no current state', () => {
+            const state = createCompletedState('feat-2');
+            assert.strictEqual(state.featureId, 'feat-2');
+            assert.strictEqual(state.retryCount, 1);
+            assert.strictEqual(state.status, 'completed');
+            assert.ok(state.lastAttempt instanceof Date);
+        });
+        void it('should preserve retryCount from current state', () => {
+            const currentState = {
+                featureId: 'feat-2',
+                retryCount: 5,
+                lastAttempt: new Date('2024-01-01'),
+                status: 'processing',
+            };
+            const state = createCompletedState('feat-2', currentState);
+            assert.strictEqual(state.retryCount, 5, 'Should preserve the existing retryCount');
+            assert.strictEqual(state.status, 'completed');
+        });
+        void it('should not increment retryCount (unlike createProcessingState)', () => {
+            const currentState = {
+                featureId: 'feat-2',
+                retryCount: 3,
+                lastAttempt: new Date('2024-01-01'),
+                status: 'processing',
+            };
+            const state = createCompletedState('feat-2', currentState);
+            assert.strictEqual(state.retryCount, 3, 'retryCount should stay the same, not increment');
+        });
+        void it('should update lastAttempt to current time', () => {
+            const oldDate = new Date('2024-01-01');
+            const currentState = {
+                featureId: 'feat-2',
+                retryCount: 1,
+                lastAttempt: oldDate,
+                status: 'processing',
+            };
+            const state = createCompletedState('feat-2', currentState);
+            assert.ok(state.lastAttempt.getTime() > oldDate.getTime(), 'lastAttempt should be newer than the old date');
+        });
+    });
+    void describe('createFailedState', () => {
+        void it('should create a failed state with retryCount 1 when no current state', () => {
+            const state = createFailedState('feat-3');
+            assert.strictEqual(state.featureId, 'feat-3');
+            assert.strictEqual(state.retryCount, 1);
+            assert.strictEqual(state.status, 'failed');
+            assert.ok(state.lastAttempt instanceof Date);
+        });
+        void it('should preserve retryCount from current state', () => {
+            const currentState = {
+                featureId: 'feat-3',
+                retryCount: 4,
+                lastAttempt: new Date('2024-01-01'),
+                status: 'processing',
+            };
+            const state = createFailedState('feat-3', currentState);
+            assert.strictEqual(state.retryCount, 4, 'Should preserve the existing retryCount');
+            assert.strictEqual(state.status, 'failed');
+        });
+        void it('should not increment retryCount (unlike createProcessingState)', () => {
+            const currentState = {
+                featureId: 'feat-3',
+                retryCount: 2,
+                lastAttempt: new Date('2024-01-01'),
+                status: 'processing',
+            };
+            const state = createFailedState('feat-3', currentState);
+            assert.strictEqual(state.retryCount, 2);
+        });
+    });
+    void describe('updateFeatureState', () => {
+        void it('should return a new Map (immutability)', () => {
+            const original = new Map();
+            const updated = updateFeatureState(original, 'feat-1', () => createProcessingState('feat-1'));
+            assert.notStrictEqual(updated, original, 'Should return a different Map instance');
+        });
+        void it('should not mutate the original Map', () => {
+            const original = new Map();
+            updateFeatureState(original, 'feat-1', () => createProcessingState('feat-1'));
+            assert.strictEqual(original.size, 0, 'Original Map should remain empty');
+        });
+        void it('should add a new feature to the Map', () => {
+            const states = new Map();
+            const updated = updateFeatureState(states, 'feat-1', () => createProcessingState('feat-1'));
+            assert.strictEqual(updated.size, 1, 'Map should have one entry');
+            assert.strictEqual(updated.get('feat-1')?.status, 'processing');
+        });
+        void it('should update an existing feature in the Map', () => {
+            const initial = new Map([
+                [
+                    'feat-1',
+                    {
+                        featureId: 'feat-1',
+                        retryCount: 1,
+                        lastAttempt: new Date('2024-01-01'),
+                        status: 'processing',
+                    },
+                ],
+            ]);
+            const updated = updateFeatureState(initial, 'feat-1', (current) => createCompletedState('feat-1', current));
+            assert.strictEqual(updated.get('feat-1')?.status, 'completed');
+            assert.strictEqual(updated.get('feat-1')?.retryCount, 1, 'retryCount should be preserved');
+        });
+        void it('should pass current state to the update function', () => {
+            const existingState = {
+                featureId: 'feat-1',
+                retryCount: 3,
+                lastAttempt: new Date('2024-01-01'),
+                status: 'processing',
+            };
+            const states = new Map([
+                ['feat-1', existingState],
+            ]);
+            let receivedState;
+            updateFeatureState(states, 'feat-1', (current) => {
+                receivedState = current;
+                return createCompletedState('feat-1', current);
+            });
+            assert.deepStrictEqual(receivedState, existingState, 'Update function should receive the current state');
+        });
+        void it('should pass undefined for non-existent feature', () => {
+            const states = new Map();
+            let receivedState = {
+                featureId: 'sentinel',
+                retryCount: 999,
+                lastAttempt: new Date(),
+                status: 'completed',
+            };
+            updateFeatureState(states, 'feat-new', (current) => {
+                receivedState = current;
+                return createProcessingState('feat-new', current);
+            });
+            assert.strictEqual(receivedState, undefined, 'Update function should receive undefined for non-existent feature');
+        });
+        void it('should preserve other features in the Map', () => {
+            const states = new Map([
+                [
+                    'feat-1',
+                    {
+                        featureId: 'feat-1',
+                        retryCount: 1,
+                        lastAttempt: new Date('2024-01-01'),
+                        status: 'completed',
+                    },
+                ],
+                [
+                    'feat-2',
+                    {
+                        featureId: 'feat-2',
+                        retryCount: 2,
+                        lastAttempt: new Date('2024-01-02'),
+                        status: 'processing',
+                    },
+                ],
+            ]);
+            const updated = updateFeatureState(states, 'feat-2', (current) => createFailedState('feat-2', current));
+            assert.strictEqual(updated.size, 2, 'Map should still have two entries');
+            assert.strictEqual(updated.get('feat-1')?.status, 'completed', 'feat-1 should remain unchanged');
+            assert.strictEqual(updated.get('feat-2')?.status, 'failed', 'feat-2 should be updated');
+        });
+    });
+    void describe('calculateStats', () => {
+        void it('should return zeros for an empty Map', () => {
+            const states = new Map();
+            const stats = calculateStats(states, false);
+            assert.deepStrictEqual(stats, {
+                totalProcessed: 0,
+                completed: 0,
+                failed: 0,
+                processing: 0,
+                isRunning: false,
+            });
+        });
+        void it('should count all completed features', () => {
+            const states = new Map([
+                [
+                    'feat-1',
+                    {
+                        featureId: 'feat-1',
+                        retryCount: 1,
+                        lastAttempt: new Date(),
+                        status: 'completed',
+                    },
+                ],
+                [
+                    'feat-2',
+                    {
+                        featureId: 'feat-2',
+                        retryCount: 1,
+                        lastAttempt: new Date(),
+                        status: 'completed',
+                    },
+                ],
+            ]);
+            const stats = calculateStats(states, true);
+            assert.strictEqual(stats.totalProcessed, 2);
+            assert.strictEqual(stats.completed, 2);
+            assert.strictEqual(stats.failed, 0);
+            assert.strictEqual(stats.processing, 0);
+            assert.strictEqual(stats.isRunning, true);
+        });
+        void it('should count mixed states correctly', () => {
+            const states = new Map([
+                [
+                    'feat-1',
+                    {
+                        featureId: 'feat-1',
+                        retryCount: 1,
+                        lastAttempt: new Date(),
+                        status: 'completed',
+                    },
+                ],
+                [
+                    'feat-2',
+                    {
+                        featureId: 'feat-2',
+                        retryCount: 2,
+                        lastAttempt: new Date(),
+                        status: 'failed',
+                    },
+                ],
+                [
+                    'feat-3',
+                    {
+                        featureId: 'feat-3',
+                        retryCount: 1,
+                        lastAttempt: new Date(),
+                        status: 'processing',
+                    },
+                ],
+                [
+                    'feat-4',
+                    {
+                        featureId: 'feat-4',
+                        retryCount: 1,
+                        lastAttempt: new Date(),
+                        status: 'completed',
+                    },
+                ],
+            ]);
+            const stats = calculateStats(states, true);
+            assert.strictEqual(stats.totalProcessed, 4);
+            assert.strictEqual(stats.completed, 2);
+            assert.strictEqual(stats.failed, 1);
+            assert.strictEqual(stats.processing, 1);
+            assert.strictEqual(stats.isRunning, true);
+        });
+        void it('should reflect isRunning as false when stopped', () => {
+            const states = new Map([
+                [
+                    'feat-1',
+                    {
+                        featureId: 'feat-1',
+                        retryCount: 1,
+                        lastAttempt: new Date(),
+                        status: 'completed',
+                    },
+                ],
+            ]);
+            const stats = calculateStats(states, false);
+            assert.strictEqual(stats.isRunning, false);
+        });
+        void it('should count all failed features', () => {
+            const states = new Map([
+                [
+                    'feat-1',
+                    {
+                        featureId: 'feat-1',
+                        retryCount: 3,
+                        lastAttempt: new Date(),
+                        status: 'failed',
+                    },
+                ],
+                [
+                    'feat-2',
+                    {
+                        featureId: 'feat-2',
+                        retryCount: 1,
+                        lastAttempt: new Date(),
+                        status: 'failed',
+                    },
+                ],
+            ]);
+            const stats = calculateStats(states, false);
+            assert.strictEqual(stats.totalProcessed, 2);
+            assert.strictEqual(stats.completed, 0);
+            assert.strictEqual(stats.failed, 2);
+            assert.strictEqual(stats.processing, 0);
+        });
+        void it('should count all processing features', () => {
+            const states = new Map([
+                [
+                    'feat-1',
+                    {
+                        featureId: 'feat-1',
+                        retryCount: 1,
+                        lastAttempt: new Date(),
+                        status: 'processing',
+                    },
+                ],
+                [
+                    'feat-2',
+                    {
+                        featureId: 'feat-2',
+                        retryCount: 1,
+                        lastAttempt: new Date(),
+                        status: 'processing',
+                    },
+                ],
+                [
+                    'feat-3',
+                    {
+                        featureId: 'feat-3',
+                        retryCount: 1,
+                        lastAttempt: new Date(),
+                        status: 'processing',
+                    },
+                ],
+            ]);
+            const stats = calculateStats(states, true);
+            assert.strictEqual(stats.totalProcessed, 3);
+            assert.strictEqual(stats.completed, 0);
+            assert.strictEqual(stats.failed, 0);
+            assert.strictEqual(stats.processing, 3);
+        });
+    });
+});

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

@@ -130,7 +130,9 @@ async function validateAndLogChecklists(options, name, checklistContext, feature
     }
 }
 // Higher-order function for phase execution
-export const createPhaseRunner = (phaseConfig) => async (options, config) => {
+export const createPhaseRunner = (phaseConfig) => 
+// eslint-disable-next-line complexity
+async (options, config) => {
     const { featureId, verbose } = options;
     const { name, execute } = phaseConfig;
     // Track phase duration for logging

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

@@ -36,9 +36,8 @@ const logAndMarkPhaseCompleted = async (result, verbose) => {
  * Orchestrate phase execution based on execution mode
  * Routes to appropriate phase sequence based on mode (only_*, from_*, full_pipeline)
  */
-export const runPipelineByMode = async (options, config, executionMode
 // eslint-disable-next-line complexity
-) => {
+export const runPipelineByMode = async (options, config, executionMode) => {
     const { featureId, verbose } = options;
     if (verbose) {
         logInfo(`🚀 Starting pipeline with mode: ${executionMode} for feature: ${featureId}`);

package/dist/config/__tests__/config.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Unit tests for the config module (loadConfig and validateConfig)
+ */
+export {};