edsger 0.50.0 → 0.52.0

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

@@ -1,384 +0,0 @@
-/**
- * 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/core/feature-filter.d.ts

@@ -1,16 +0,0 @@
-/**
- * Feature filtering utilities for workflow processor
- * Pure functions for filtering and selecting features for processing
- */
-import type { FeatureInfo } from '../../../types/features.js';
-import type { FeatureProcessingState } from './state-manager.js';
-export declare const shouldProcessFeature: (maxRetries: number) => (feature: FeatureInfo, states: Map<string, FeatureProcessingState>) => boolean;
-export declare const findNextFeature: (features: readonly FeatureInfo[], states: Map<string, FeatureProcessingState>, maxRetries: number) => FeatureInfo | undefined;
-export declare const isFeatureProcessing: (featureId: string, states: Map<string, FeatureProcessingState>) => boolean;
-export declare const isFeatureCompleted: (featureId: string, states: Map<string, FeatureProcessingState>) => boolean;
-export declare const isFeatureFailed: (featureId: string, states: Map<string, FeatureProcessingState>) => boolean;
-export declare const hasReachedMaxRetries: (featureId: string, states: Map<string, FeatureProcessingState>, maxRetries: number) => boolean;
-export declare const filterProcessingFeatures: (features: readonly FeatureInfo[], states: Map<string, FeatureProcessingState>) => FeatureInfo[];
-export declare const filterCompletedFeatures: (features: readonly FeatureInfo[], states: Map<string, FeatureProcessingState>) => FeatureInfo[];
-export declare const filterFailedFeatures: (features: readonly FeatureInfo[], states: Map<string, FeatureProcessingState>) => FeatureInfo[];
-export declare const filterAvailableFeatures: (features: readonly FeatureInfo[], states: Map<string, FeatureProcessingState>, maxRetries: number) => FeatureInfo[];

package/dist/commands/workflow/core/feature-filter.js

@@ -1,47 +0,0 @@
-/**
- * Feature filtering utilities for workflow processor
- * Pure functions for filtering and selecting features for processing
- */
-// Feature filtering functions (pure)
-export const shouldProcessFeature = (maxRetries) => (feature, states) => {
-    const state = states.get(feature.id);
-    // If never processed, should process
-    if (!state) {
-        return true;
-    }
-    // If feature was updated after last processing attempt, should reprocess
-    // This handles cases where user manually changes status back to ready_for_ai
-    if (feature.updated_at) {
-        const featureUpdatedTime = new Date(feature.updated_at).getTime();
-        const lastAttemptTime = state.lastAttempt.getTime();
-        if (featureUpdatedTime > lastAttemptTime) {
-            // Feature has been updated since last processing, reprocess it
-            return true;
-        }
-    }
-    // If failed and haven't exceeded retry limit, should retry
-    return state.status === 'failed' && state.retryCount < maxRetries;
-};
-export const findNextFeature = (features, states, maxRetries) => features.find((feature) => shouldProcessFeature(maxRetries)(feature, states));
-// Feature status checking functions (pure)
-export const isFeatureProcessing = (featureId, states) => {
-    const state = states.get(featureId);
-    return state?.status === 'processing';
-};
-export const isFeatureCompleted = (featureId, states) => {
-    const state = states.get(featureId);
-    return state?.status === 'completed';
-};
-export const isFeatureFailed = (featureId, states) => {
-    const state = states.get(featureId);
-    return state?.status === 'failed';
-};
-export const hasReachedMaxRetries = (featureId, states, maxRetries) => {
-    const state = states.get(featureId);
-    return state ? state.retryCount >= maxRetries : false;
-};
-// Feature collection filtering functions (pure)
-export const filterProcessingFeatures = (features, states) => features.filter((feature) => isFeatureProcessing(feature.id, states));
-export const filterCompletedFeatures = (features, states) => features.filter((feature) => isFeatureCompleted(feature.id, states));
-export const filterFailedFeatures = (features, states) => features.filter((feature) => isFeatureFailed(feature.id, states));
-export const filterAvailableFeatures = (features, states, maxRetries) => features.filter((feature) => shouldProcessFeature(maxRetries)(feature, states));

package/dist/commands/workflow/feature-coordinator.d.ts

@@ -1,18 +0,0 @@
-/**
- * Feature Coordinator - High-level workflow orchestration
- *
- * Responsibilities:
- * - Fetch feature configuration from API
- * - Execute phases based on workflow field (pending phases in order)
- * - Coordinate feature-level workflow initialization
- * - Handle phase execution results and stop on failure/blocked
- *
- * This is the entry point for feature workflow execution
- */
-import { type EdsgerConfig } from '../../types/index.js';
-import { type PipelinePhaseOptions, type PipelineResult } from '../../types/pipeline.js';
-/**
- * Run workflow for a feature based on its workflow field
- * Executes all pending phases in order, stopping on failure or blocked
- */
-export declare function runFeatureWorkflow(options: PipelinePhaseOptions, config: EdsgerConfig): Promise<readonly PipelineResult[]>;

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

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