edsger 0.45.0 → 0.45.1

package/dist/api/features/__tests__/feature-utils.test.js

@@ -1,370 +0,0 @@
-/**
- * Unit tests for feature utility functions
- */
-import assert from 'node:assert';
-import { describe, it } from 'node:test';
-import { filterFeaturesByStatus, sortFeaturesByUpdatedAt, } from '../feature-utils.js';
-void describe('Feature Utils', () => {
-    void describe('sortFeaturesByUpdatedAt', () => {
-        void it('should sort features by updated_at in ascending order (oldest first)', () => {
-            const features = [
-                {
-                    id: '1',
-                    name: 'Feature 1',
-                    status: 'ready_for_ai',
-                    product_id: 'test-product',
-                    updated_at: '2024-01-15T10:00:00Z',
-                },
-                {
-                    id: '2',
-                    name: 'Feature 2',
-                    status: 'ready_for_ai',
-                    product_id: 'test-product',
-                    updated_at: '2024-01-10T10:00:00Z',
-                },
-                {
-                    id: '3',
-                    name: 'Feature 3',
-                    status: 'ready_for_ai',
-                    product_id: 'test-product',
-                    updated_at: '2024-01-20T10:00:00Z',
-                },
-            ];
-            const sorted = sortFeaturesByUpdatedAt(features);
-            // Should be sorted oldest first: Feature 2, Feature 1, Feature 3
-            assert.strictEqual(sorted[0].id, '2', 'First should be Feature 2 (oldest)');
-            assert.strictEqual(sorted[1].id, '1', 'Second should be Feature 1');
-            assert.strictEqual(sorted[2].id, '3', 'Third should be Feature 3 (newest)');
-        });
-        void it('should handle features with missing updated_at dates', () => {
-            const features = [
-                {
-                    id: '1',
-                    name: 'Feature 1',
-                    status: 'ready_for_ai',
-                    product_id: 'test-product',
-                    updated_at: '2024-01-15T10:00:00Z',
-                },
-                {
-                    id: '2',
-                    name: 'Feature 2',
-                    status: 'ready_for_ai',
-                    product_id: 'test-product',
-                    // Missing updated_at
-                },
-                {
-                    id: '3',
-                    name: 'Feature 3',
-                    status: 'ready_for_ai',
-                    product_id: 'test-product',
-                    updated_at: '2024-01-10T10:00:00Z',
-                },
-            ];
-            const sorted = sortFeaturesByUpdatedAt(features);
-            // Feature without updated_at should be treated as epoch (1970-01-01)
-            // and sorted first
-            assert.strictEqual(sorted[0].id, '2', 'Feature without date should come first');
-            assert.strictEqual(sorted[1].id, '3', 'Feature 3 should be second (older date)');
-            assert.strictEqual(sorted[2].id, '1', 'Feature 1 should be third (newer date)');
-        });
-        void it('should handle empty array', () => {
-            const features = [];
-            const sorted = sortFeaturesByUpdatedAt(features);
-            assert.strictEqual(sorted.length, 0, 'Empty array should remain empty');
-        });
-        void it('should handle single feature', () => {
-            const features = [
-                {
-                    id: '1',
-                    name: 'Feature 1',
-                    status: 'ready_for_ai',
-                    product_id: 'test-product',
-                    updated_at: '2024-01-15T10:00:00Z',
-                },
-            ];
-            const sorted = sortFeaturesByUpdatedAt(features);
-            assert.strictEqual(sorted.length, 1, 'Should return single feature');
-            assert.strictEqual(sorted[0].id, '1', 'Should be the same feature');
-        });
-        void it('should create a new array and not mutate the original', () => {
-            const features = [
-                {
-                    id: '1',
-                    name: 'Feature 1',
-                    status: 'ready_for_ai',
-                    product_id: 'test-product',
-                    updated_at: '2024-01-15T10:00:00Z',
-                },
-                {
-                    id: '2',
-                    name: 'Feature 2',
-                    status: 'ready_for_ai',
-                    product_id: 'test-product',
-                    updated_at: '2024-01-10T10:00:00Z',
-                },
-            ];
-            const originalOrder = features.map((f) => f.id);
-            const sorted = sortFeaturesByUpdatedAt(features);
-            const originalAfterSort = features.map((f) => f.id);
-            // Original array should be unchanged
-            assert.deepStrictEqual(originalAfterSort, originalOrder, 'Original array should not be mutated');
-            // Sorted array should be different
-            assert.notDeepStrictEqual(sorted.map((f) => f.id), originalOrder, 'Sorted array should have different order');
-        });
-        void it('should handle features with same updated_at timestamps consistently', () => {
-            const sameTimestamp = '2024-01-15T10:00:00Z';
-            const features = [
-                {
-                    id: '1',
-                    name: 'Feature 1',
-                    status: 'ready_for_ai',
-                    product_id: 'test-product',
-                    updated_at: sameTimestamp,
-                },
-                {
-                    id: '2',
-                    name: 'Feature 2',
-                    status: 'ready_for_ai',
-                    product_id: 'test-product',
-                    updated_at: sameTimestamp,
-                },
-                {
-                    id: '3',
-                    name: 'Feature 3',
-                    status: 'ready_for_ai',
-                    product_id: 'test-product',
-                    updated_at: sameTimestamp,
-                },
-            ];
-            const sorted = sortFeaturesByUpdatedAt(features);
-            assert.strictEqual(sorted.length, 3, 'Should return all features');
-            // Order should be stable (same as original for equal timestamps)
-            // Note: JavaScript sort is stable in modern engines
-        });
-        void it('should handle various date formats correctly', () => {
-            const features = [
-                {
-                    id: '1',
-                    name: 'Feature 1',
-                    status: 'ready_for_ai',
-                    product_id: 'test-product',
-                    updated_at: '2024-01-15', // Date only
-                },
-                {
-                    id: '2',
-                    name: 'Feature 2',
-                    status: 'ready_for_ai',
-                    product_id: 'test-product',
-                    updated_at: '2024-01-10T10:00:00.000Z', // Full ISO format
-                },
-                {
-                    id: '3',
-                    name: 'Feature 3',
-                    status: 'ready_for_ai',
-                    product_id: 'test-product',
-                    updated_at: '2024-01-20T15:30:00Z', // ISO with time
-                },
-            ];
-            const sorted = sortFeaturesByUpdatedAt(features);
-            // Should handle different date formats and sort correctly
-            assert.strictEqual(sorted[0].id, '2', 'Feature 2 should be first (oldest)');
-            assert.strictEqual(sorted[1].id, '1', 'Feature 1 should be second');
-            assert.strictEqual(sorted[2].id, '3', 'Feature 3 should be third (newest)');
-        });
-    });
-    void describe('filterFeaturesByStatus', () => {
-        void it('should filter features by exact status match', () => {
-            const features = [
-                {
-                    id: '1',
-                    name: 'Feature 1',
-                    status: 'ready_for_ai',
-                    product_id: 'test-product',
-                },
-                {
-                    id: '2',
-                    name: 'Feature 2',
-                    status: 'feature_analysis',
-                    product_id: 'test-product',
-                },
-                {
-                    id: '3',
-                    name: 'Feature 3',
-                    status: 'ready_for_ai',
-                    product_id: 'test-product',
-                },
-            ];
-            const filtered = filterFeaturesByStatus(features, 'ready_for_ai');
-            assert.strictEqual(filtered.length, 2, 'Should return 2 ready_for_ai features');
-            assert.strictEqual(filtered[0].id, '1', 'Should include Feature 1');
-            assert.strictEqual(filtered[1].id, '3', 'Should include Feature 3');
-        });
-        void it('should return empty array when no features match status', () => {
-            const features = [
-                {
-                    id: '1',
-                    name: 'Feature 1',
-                    status: 'feature_analysis',
-                    product_id: 'test-product',
-                },
-                {
-                    id: '2',
-                    name: 'Feature 2',
-                    status: 'code_implementation',
-                    product_id: 'test-product',
-                },
-            ];
-            const filtered = filterFeaturesByStatus(features, 'ready_for_ai');
-            assert.strictEqual(filtered.length, 0, 'Should return empty array');
-        });
-        void it('should handle empty input array', () => {
-            const features = [];
-            const filtered = filterFeaturesByStatus(features, 'ready_for_ai');
-            assert.strictEqual(filtered.length, 0, 'Should return empty array');
-        });
-    });
-    void describe('Integration Tests - Workflow Processing Order', () => {
-        void it('should process features in oldest-first order for workflow execution', () => {
-            // This test simulates the expected behavior for workflow processing
-            const simulatedWorkflowFeatures = [
-                {
-                    id: 'urgent-feature',
-                    name: 'Urgent Feature',
-                    status: 'ready_for_ai',
-                    product_id: 'test-product',
-                    updated_at: '2024-01-01T08:00:00Z', // Very old - should be processed first
-                },
-                {
-                    id: 'recent-feature',
-                    name: 'Recent Feature',
-                    status: 'ready_for_ai',
-                    product_id: 'test-product',
-                    updated_at: '2024-01-20T10:00:00Z', // Recent - should be processed last
-                },
-                {
-                    id: 'medium-feature',
-                    name: 'Medium Feature',
-                    status: 'ready_for_ai',
-                    product_id: 'test-product',
-                    updated_at: '2024-01-10T12:00:00Z', // Medium age - should be processed second
-                },
-            ];
-            const processingOrder = sortFeaturesByUpdatedAt(simulatedWorkflowFeatures);
-            // Verify processing order matches expected workflow behavior
-            assert.strictEqual(processingOrder[0].id, 'urgent-feature', 'Oldest feature should be processed first in workflow');
-            assert.strictEqual(processingOrder[1].id, 'medium-feature', 'Medium-age feature should be processed second in workflow');
-            assert.strictEqual(processingOrder[2].id, 'recent-feature', 'Newest feature should be processed last in workflow');
-            // Verify timestamps are in correct ascending order
-            const timestamps = processingOrder.map((f) => new Date(f.updated_at || 0).getTime());
-            for (let i = 1; i < timestamps.length; i++) {
-                assert.ok(timestamps[i] >= timestamps[i - 1], `Feature ${i} should have timestamp >= feature ${i - 1}`);
-            }
-        });
-        void it('should maintain consistent ordering across multiple calls', () => {
-            const features = [
-                {
-                    id: '1',
-                    name: 'Feature 1',
-                    status: 'ready_for_ai',
-                    product_id: 'test-product',
-                    updated_at: '2024-01-15T10:00:00Z',
-                },
-                {
-                    id: '2',
-                    name: 'Feature 2',
-                    status: 'ready_for_ai',
-                    product_id: 'test-product',
-                    updated_at: '2024-01-10T10:00:00Z',
-                },
-                {
-                    id: '3',
-                    name: 'Feature 3',
-                    status: 'ready_for_ai',
-                    product_id: 'test-product',
-                    updated_at: '2024-01-20T10:00:00Z',
-                },
-            ];
-            // Sort multiple times to ensure consistency
-            const sorted1 = sortFeaturesByUpdatedAt(features);
-            const sorted2 = sortFeaturesByUpdatedAt(features);
-            const sorted3 = sortFeaturesByUpdatedAt(features);
-            // All should produce the same order
-            assert.deepStrictEqual(sorted1.map((f) => f.id), sorted2.map((f) => f.id), 'First and second sort should produce same order');
-            assert.deepStrictEqual(sorted2.map((f) => f.id), sorted3.map((f) => f.id), 'Second and third sort should produce same order');
-        });
-        void it('should verify oldest-first ordering is critical for fair workflow processing', () => {
-            // Test that demonstrates why oldest-first ordering is important
-            const featuresWithVariousAges = [
-                {
-                    id: 'very-old-bug',
-                    name: 'Critical Bug Fix',
-                    status: 'ready_for_ai',
-                    product_id: 'test-product',
-                    updated_at: '2024-01-01T00:00:00Z', // Very old, should be highest priority
-                },
-                {
-                    id: 'new-enhancement',
-                    name: 'Nice to Have Feature',
-                    status: 'ready_for_ai',
-                    product_id: 'test-product',
-                    updated_at: '2024-01-25T00:00:00Z', // Recent, should be lowest priority
-                },
-                {
-                    id: 'medium-priority',
-                    name: 'Important Feature',
-                    status: 'ready_for_ai',
-                    product_id: 'test-product',
-                    updated_at: '2024-01-15T00:00:00Z', // Medium age, should be middle priority
-                },
-            ];
-            const orderedFeatures = sortFeaturesByUpdatedAt(featuresWithVariousAges);
-            // The oldest feature (potentially a bug that's been waiting) should be processed first
-            assert.strictEqual(orderedFeatures[0].id, 'very-old-bug');
-            assert.strictEqual(orderedFeatures[1].id, 'medium-priority');
-            assert.strictEqual(orderedFeatures[2].id, 'new-enhancement');
-            // Verify the business logic: older items get processed before newer ones
-            // This ensures fairness and prevents newer features from always jumping ahead
-            const ages = orderedFeatures.map((f) => new Date(f.updated_at ?? '').getTime());
-            assert.ok(ages[0] <= ages[1] && ages[1] <= ages[2], 'Features should be processed in age order (oldest first)');
-        });
-    });
-    void describe('getReadyForAIFeatures integration behavior', () => {
-        void it('should use sortFeaturesByUpdatedAt to ensure oldest-first processing', () => {
-            // This test verifies the integration between getReadyForAIFeatures and sortFeaturesByUpdatedAt
-            // We can test this indirectly by testing the sorting function that getReadyForAIFeatures uses
-            const mockApiResponse = [
-                {
-                    id: 'feat-1',
-                    name: 'Feature Added Last Week',
-                    status: 'ready_for_ai',
-                    product_id: 'product-123',
-                    updated_at: '2024-01-18T10:00:00Z',
-                },
-                {
-                    id: 'feat-2',
-                    name: 'Feature Added Yesterday',
-                    status: 'ready_for_ai',
-                    product_id: 'product-123',
-                    updated_at: '2024-01-24T15:30:00Z',
-                },
-                {
-                    id: 'feat-3',
-                    name: 'Feature Added Last Month',
-                    status: 'ready_for_ai',
-                    product_id: 'product-123',
-                    updated_at: '2024-01-05T08:00:00Z',
-                },
-            ];
-            // This simulates what getReadyForAIFeatures does internally
-            const sortedForWorkflow = sortFeaturesByUpdatedAt(mockApiResponse);
-            // Verify oldest-first ordering that getReadyForAIFeatures should provide
-            assert.strictEqual(sortedForWorkflow[0].id, 'feat-3', 'Oldest feature should be first');
-            assert.strictEqual(sortedForWorkflow[1].id, 'feat-1', 'Second oldest should be second');
-            assert.strictEqual(sortedForWorkflow[2].id, 'feat-2', 'Newest feature should be last');
-            // Verify the function returns the features in the correct order for workflow processing
-            const expectedOrder = ['feat-3', 'feat-1', 'feat-2'];
-            const actualOrder = sortedForWorkflow.map((f) => f.id);
-            assert.deepStrictEqual(actualOrder, expectedOrder, 'Features should be ordered for fair workflow processing');
-        });
-    });
-});

package/dist/api/features/__tests__/status-updater.test.d.ts

@@ -1,4 +0,0 @@
-/**
- * Unit tests for status progression logic
- */
-export {};

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

@@ -1,88 +0,0 @@
-/**
- * Unit tests for status progression logic
- */
-import assert from 'node:assert';
-import { describe, it } from 'node:test';
-import { STATUS_PROGRESSION_ORDER } from '../../../config/feature-status.js';
-import { isForwardProgression } from '../status-updater.js';
-void describe('Status Progression Logic', () => {
-    void describe('isForwardProgression', () => {
-        void it('should allow forward progression', () => {
-            assert.strictEqual(isForwardProgression('backlog', 'ready_for_ai'), true, 'Should allow progression from backlog to ready_for_ai');
-            assert.strictEqual(isForwardProgression('feature_analysis', 'technical_design'), true, 'Should allow progression from feature_analysis to technical_design');
-            assert.strictEqual(isForwardProgression('code_implementation', 'shipped'), true, 'Should allow progression from code_implementation to shipped');
-        });
-        void it('should allow staying at same status', () => {
-            assert.strictEqual(isForwardProgression('backlog', 'backlog'), true, 'Should allow staying at backlog status');
-            assert.strictEqual(isForwardProgression('feature_analysis', 'feature_analysis'), true, 'Should allow staying at feature_analysis status');
-            assert.strictEqual(isForwardProgression('shipped', 'shipped'), true, 'Should allow staying at shipped status');
-        });
-        void it('should prevent backward progression', () => {
-            assert.strictEqual(isForwardProgression('ready_for_ai', 'backlog'), false, 'Should prevent regression from ready_for_ai to backlog');
-            assert.strictEqual(isForwardProgression('technical_design', 'feature_analysis'), false, 'Should prevent regression from technical_design to feature_analysis');
-            assert.strictEqual(isForwardProgression('shipped', 'code_implementation'), false, 'Should prevent regression from shipped to code_implementation');
-        });
-        void it('should handle edge cases correctly', () => {
-            // First status to last status
-            assert.strictEqual(isForwardProgression('backlog', 'shipped'), true, 'Should allow progression from first to last status');
-            // Last status to first status
-            assert.strictEqual(isForwardProgression('shipped', 'backlog'), false, 'Should prevent regression from last to first status');
-        });
-        void it('should handle testing workflow correctly', () => {
-            // Allow progression through testing states
-            assert.strictEqual(isForwardProgression('functional_testing', 'testing_in_progress'), true, 'Should allow progression to testing_in_progress');
-            assert.strictEqual(isForwardProgression('testing_in_progress', 'testing_passed'), true, 'Should allow progression to testing_passed');
-            // Allow retry after failed testing
-            assert.strictEqual(isForwardProgression('testing_in_progress', 'testing_failed'), true, 'Should allow marking tests as failed');
-            // Prevent going back to testing_in_progress from passed
-            assert.strictEqual(isForwardProgression('testing_passed', 'testing_in_progress'), false, 'Should prevent going back from testing_passed to testing_in_progress');
-        });
-    });
-    void describe('STATUS_PROGRESSION_ORDER', () => {
-        void it('should contain all expected statuses', () => {
-            const expectedStatuses = [
-                'backlog',
-                'ready_for_ai',
-                'feature_analysis',
-                'feature_analysis_verification',
-                'technical_design',
-                'technical_design_verification',
-                'branch_planning',
-                'branch_planning_verification',
-                'code_implementation',
-                'code_implementation_verification',
-                'code_refine',
-                'code_refine_verification',
-                'bug_fixing',
-                'code_review',
-                'functional_testing',
-                'testing_in_progress',
-                'testing_passed',
-                'testing_failed',
-                'ready_for_review',
-                'shipped',
-            ];
-            assert.strictEqual(STATUS_PROGRESSION_ORDER.length, expectedStatuses.length, 'Should contain the correct number of statuses');
-            for (const status of expectedStatuses) {
-                assert.ok(STATUS_PROGRESSION_ORDER.includes(status), `Should include status: ${status}`);
-            }
-        });
-        void it('should have correct ordering for key workflow phases', () => {
-            const backlogIndex = STATUS_PROGRESSION_ORDER.indexOf('backlog');
-            const readyForDevIndex = STATUS_PROGRESSION_ORDER.indexOf('ready_for_ai');
-            const featureAnalysisIndex = STATUS_PROGRESSION_ORDER.indexOf('feature_analysis');
-            const technicalDesignIndex = STATUS_PROGRESSION_ORDER.indexOf('technical_design');
-            const codeImplementationIndex = STATUS_PROGRESSION_ORDER.indexOf('code_implementation');
-            const shippedIndex = STATUS_PROGRESSION_ORDER.indexOf('shipped');
-            assert.ok(backlogIndex < readyForDevIndex, 'backlog should come before ready_for_ai');
-            assert.ok(readyForDevIndex < featureAnalysisIndex, 'ready_for_ai should come before feature_analysis');
-            assert.ok(featureAnalysisIndex < technicalDesignIndex, 'feature_analysis should come before technical_design');
-            assert.ok(technicalDesignIndex < codeImplementationIndex, 'technical_design should come before code_implementation');
-            assert.ok(codeImplementationIndex < shippedIndex, 'code_implementation should come before shipped');
-        });
-        void it('should not have duplicate statuses', () => {
-            const uniqueStatuses = new Set(STATUS_PROGRESSION_ORDER);
-            assert.strictEqual(uniqueStatuses.size, STATUS_PROGRESSION_ORDER.length, 'Should not contain duplicate statuses');
-        });
-    });
-});

package/dist/commands/build/__tests__/build.test.d.ts

@@ -1,5 +0,0 @@
-/**
- * Unit tests for the build command's pure/utility functions.
- * Tests project discovery, scheme parsing, plist generation, and API key management.
- */
-export {};