edsger 0.51.0 → 0.53.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/commands/workflow/feature-coordinator.js

@@ -1,161 +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 { getFeature } from '../../api/features/get-feature.js';
-import { markWorkflowPhaseCompleted } from '../../api/features/update-feature.js';
-import { cacheBindings, clearBindingsCache, fetchHookBindings, } from '../../services/phase-hooks/index.js';
-import { logError, logInfo, logWarning } from '../../utils/logger.js';
-import { logPhaseResult } from '../../utils/pipeline-logger.js';
-import { runAutonomousPhase, runBranchPlanningPhase, runCodeImplementationPhase, runCodeRefinePhase, runCodeReviewPhase, runFeatureAnalysisPhase, runFunctionalTestingPhase, runPRExecutionPhase, runPRSplittingPhase, runTechnicalDesignPhase, runTestCasesAnalysisPhase, runUserStoriesAnalysisPhase, } 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)
- */
-const PHASE_RUNNERS = {
-    feature_analysis: runFeatureAnalysisPhase,
-    user_stories_analysis: runUserStoriesAnalysisPhase,
-    test_cases_analysis: runTestCasesAnalysisPhase,
-    technical_design: runTechnicalDesignPhase,
-    branch_planning: runBranchPlanningPhase,
-    code_implementation: runCodeImplementationPhase,
-    pr_splitting: runPRSplittingPhase,
-    pr_execution: runPRExecutionPhase,
-    functional_testing: runFunctionalTestingPhase,
-    code_review: runCodeReviewPhase,
-    code_refine: runCodeRefinePhase,
-    autonomous: runAutonomousPhase,
-};
-/**
- * Get all pending phases from workflow in order
- */
-function getPendingPhases(workflow) {
-    if (!workflow || workflow.length === 0) {
-        return [];
-    }
-    return workflow.filter((phase) => phase.status === 'pending');
-}
-/**
- * Execute a single phase and handle results
- * Returns the result and marks workflow phase as completed if successful
- */
-async function executePhase(phaseName, options, config) {
-    const { featureId, verbose } = options;
-    // Normalize phase name: kebab-case → snake_case (e.g., code-implementation → code_implementation)
-    const normalizedName = phaseName.replace(/-/g, '_');
-    const phaseRunner = PHASE_RUNNERS[normalizedName];
-    if (!phaseRunner) {
-        logWarning(`Unknown workflow phase: ${phaseName}, skipping`);
-        return {
-            featureId,
-            phase: phaseName,
-            status: 'error',
-            message: `Unknown workflow phase: ${phaseName}`,
-        };
-    }
-    if (verbose) {
-        logInfo(`\n🎯 Executing phase: ${normalizedName}`);
-    }
-    // Execute the phase
-    const result = await phaseRunner(options, config);
-    // Log the result
-    logPhaseResult(result, verbose);
-    // Mark workflow phase as completed if successful
-    if (result.status === 'success') {
-        await markWorkflowPhaseCompleted(featureId, normalizedName, verbose);
-    }
-    return result;
-}
-/**
- * Run workflow for a feature based on its workflow field
- * Executes all pending phases in order, stopping on failure or blocked
- */
-export async function runFeatureWorkflow(options, config) {
-    const { featureId, verbose } = options;
-    try {
-        // 1. Get feature details to check workflow
-        if (verbose) {
-            logInfo(`🔍 Fetching feature configuration for: ${featureId}`);
-        }
-        const feature = await getFeature(featureId, verbose);
-        // Fetch and cache hook bindings for this feature's product
-        try {
-            const bindings = await fetchHookBindings(feature.product_id, verbose);
-            cacheBindings(featureId, feature.product_id, bindings);
-            if (verbose && bindings.length > 0) {
-                logInfo(`🪝 Loaded ${bindings.length} phase hook binding(s) for product ${feature.product_id}`);
-            }
-        }
-        catch (hookError) {
-            // Hook binding fetch failures should not block workflow execution
-            logWarning(`Failed to fetch phase hook bindings: ${hookError instanceof Error ? hookError.message : String(hookError)}`);
-        }
-        // Debug log workflow data
-        if (verbose) {
-            logInfo(`🔍 Feature data from API:`);
-            logInfo(`  - workflow: ${JSON.stringify(feature.workflow, null, 2)}`);
-        }
-        // 2. Get all pending phases from workflow
-        const pendingPhases = getPendingPhases(feature.workflow);
-        if (pendingPhases.length === 0) {
-            if (verbose) {
-                logInfo('No pending phases in workflow, nothing to execute');
-            }
-            return [
-                {
-                    featureId,
-                    phase: 'workflow-initialization',
-                    status: 'success',
-                    message: 'No pending phases in workflow, nothing to execute',
-                },
-            ];
-        }
-        if (verbose) {
-            logInfo(`📋 Found ${pendingPhases.length} pending phases to execute:`);
-            pendingPhases.forEach((p, i) => logInfo(`   ${i + 1}. ${p.phase}`));
-        }
-        // 3. Execute each pending phase in order
-        const results = [];
-        for (const workflowPhase of pendingPhases) {
-            const result = await executePhase(workflowPhase.phase, options, config);
-            results.push(result);
-            // Stop execution if phase failed or was blocked
-            if (result.status === 'error' || result.status === 'blocked') {
-                if (verbose) {
-                    logInfo(`\n⛔ Stopping workflow execution: ${workflowPhase.phase} ${result.status}`);
-                }
-                break;
-            }
-            // Note: PR creation is now handled within the code-implementation phase itself,
-            // so we no longer need to create it here after code_implementation succeeds.
-        }
-        // Clean up hook bindings cache
-        clearBindingsCache(featureId);
-        if (verbose) {
-            const successCount = results.filter((r) => r.status === 'success').length;
-            logInfo(`\n✅ Workflow execution completed: ${successCount}/${results.length} phases succeeded`);
-        }
-        return results;
-    }
-    catch (error) {
-        clearBindingsCache(featureId);
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        logError(`Failed to run feature workflow: ${errorMessage}`);
-        // Return error result
-        return [
-            {
-                featureId,
-                phase: 'workflow-initialization',
-                status: 'error',
-                message: `Workflow initialization failed: ${errorMessage}`,
-            },
-        ];
-    }
-}

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

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