edsger 0.45.0 → 0.46.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/config/__tests__/config.test.d.ts

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

package/dist/config/__tests__/config.test.js

@@ -1,286 +0,0 @@
-/**
- * Unit tests for the config module (loadConfig and validateConfig)
- */
-import assert from 'node:assert';
-import { mkdtempSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { describe, it } from 'node:test';
-import { loadConfig, validateConfig } from '../../config.js';
-/**
- * Helper to create a valid default-shaped config for validateConfig tests.
- * Individual tests override specific fields to trigger validation errors.
- */
-function makeValidConfig(overrides = {}) {
-    return {
-        patterns: ['**/*.ts'],
-        exclude: ['**/node_modules/**'],
-        severity: 'error',
-        maxFiles: 50,
-        claude: { timeout: 120000 },
-        workflow: {
-            maxConcurrency: 3,
-            pollInterval: 30000,
-            maxRetries: 3,
-            retryCooldown: 300000,
-            workerTimeout: 1800000,
-            maxVerificationIterations: 10,
-        },
-        ...overrides,
-    };
-}
-void describe('Config Module', () => {
-    // ── loadConfig ──────────────────────────────────────────────────────
-    void describe('loadConfig', () => {
-        void it('should return defaults when no config file exists', () => {
-            // Use a fresh temp directory that has no config files
-            const tempDir = mkdtempSync(join(tmpdir(), 'edsger-test-'));
-            const originalCwd = process.cwd();
-            try {
-                process.chdir(tempDir);
-                const config = loadConfig();
-                assert.ok(Array.isArray(config.patterns), 'patterns should be an array');
-                assert.ok(config.patterns.length > 0, 'patterns should not be empty');
-                assert.ok(Array.isArray(config.exclude), 'exclude should be an array');
-                assert.ok(config.exclude.length > 0, 'exclude should not be empty');
-                assert.strictEqual(config.severity, 'error');
-                assert.strictEqual(config.maxFiles, 50);
-                assert.strictEqual(config.claude.timeout, 120000);
-            }
-            finally {
-                process.chdir(originalCwd);
-            }
-        });
-        void it('should include all default patterns for common languages', () => {
-            const tempDir = mkdtempSync(join(tmpdir(), 'edsger-test-'));
-            const originalCwd = process.cwd();
-            try {
-                process.chdir(tempDir);
-                const config = loadConfig();
-                const expectedPatterns = [
-                    '**/*.js',
-                    '**/*.ts',
-                    '**/*.tsx',
-                    '**/*.py',
-                    '**/*.go',
-                    '**/*.rs',
-                    '**/*.java',
-                ];
-                for (const pattern of expectedPatterns) {
-                    assert.ok(config.patterns.includes(pattern), `Default patterns should include ${pattern}`);
-                }
-            }
-            finally {
-                process.chdir(originalCwd);
-            }
-        });
-        void it('should include sensible default excludes', () => {
-            const tempDir = mkdtempSync(join(tmpdir(), 'edsger-test-'));
-            const originalCwd = process.cwd();
-            try {
-                process.chdir(tempDir);
-                const config = loadConfig();
-                assert.ok(config.exclude.includes('**/node_modules/**'), 'Should exclude node_modules');
-                assert.ok(config.exclude.includes('**/dist/**'), 'Should exclude dist');
-                assert.ok(config.exclude.includes('**/__tests__/**'), 'Should exclude __tests__');
-            }
-            finally {
-                process.chdir(originalCwd);
-            }
-        });
-        void it('should return correct default workflow values', () => {
-            const tempDir = mkdtempSync(join(tmpdir(), 'edsger-test-'));
-            const originalCwd = process.cwd();
-            try {
-                process.chdir(tempDir);
-                const config = loadConfig();
-                assert.strictEqual(config.workflow.maxConcurrency, 3);
-                assert.strictEqual(config.workflow.pollInterval, 30000);
-                assert.strictEqual(config.workflow.maxRetries, 3);
-                assert.strictEqual(config.workflow.retryCooldown, 300000);
-                assert.strictEqual(config.workflow.workerTimeout, 1800000);
-                assert.strictEqual(config.workflow.maxVerificationIterations, 10);
-            }
-            finally {
-                process.chdir(originalCwd);
-            }
-        });
-        void it('should return a claude object with default timeout', () => {
-            const tempDir = mkdtempSync(join(tmpdir(), 'edsger-test-'));
-            const originalCwd = process.cwd();
-            try {
-                process.chdir(tempDir);
-                const config = loadConfig();
-                assert.ok(typeof config.claude === 'object' && config.claude !== null, 'claude should be an object');
-                assert.strictEqual(config.claude.timeout, 120000);
-            }
-            finally {
-                process.chdir(originalCwd);
-            }
-        });
-    });
-    // ── validateConfig: valid configs ───────────────────────────────────
-    void describe('validateConfig - valid configs', () => {
-        void it('should return empty errors for a valid config', () => {
-            const config = makeValidConfig();
-            const errors = validateConfig(config);
-            assert.deepStrictEqual(errors, []);
-        });
-        void it('should accept severity "warning"', () => {
-            const config = makeValidConfig({ severity: 'warning' });
-            const errors = validateConfig(config);
-            assert.deepStrictEqual(errors, []);
-        });
-        void it('should accept config without claude.timeout (undefined)', () => {
-            const config = makeValidConfig({ claude: {} });
-            const errors = validateConfig(config);
-            assert.deepStrictEqual(errors, []);
-        });
-        void it('should accept maxFiles of 1', () => {
-            const config = makeValidConfig({ maxFiles: 1 });
-            const errors = validateConfig(config);
-            assert.deepStrictEqual(errors, []);
-        });
-        void it('should accept a large maxFiles value', () => {
-            const config = makeValidConfig({ maxFiles: 10000 });
-            const errors = validateConfig(config);
-            assert.deepStrictEqual(errors, []);
-        });
-    });
-    // ── validateConfig: patterns ────────────────────────────────────────
-    void describe('validateConfig - patterns validation', () => {
-        void it('should return error for empty patterns array', () => {
-            const config = makeValidConfig({ patterns: [] });
-            const errors = validateConfig(config);
-            assert.ok(errors.length > 0, 'Should have at least one error');
-            assert.ok(errors.some((e) => e.includes('patterns')), 'Error should mention patterns');
-        });
-        void it('should return error for non-array patterns', () => {
-            const config = makeValidConfig({
-                patterns: 'not-an-array',
-            });
-            const errors = validateConfig(config);
-            assert.ok(errors.length > 0, 'Should have at least one error');
-            assert.ok(errors.some((e) => e.includes('patterns')), 'Error should mention patterns');
-        });
-    });
-    // ── validateConfig: exclude ─────────────────────────────────────────
-    void describe('validateConfig - exclude validation', () => {
-        void it('should return error for non-array exclude', () => {
-            const config = makeValidConfig({
-                exclude: 'not-an-array',
-            });
-            const errors = validateConfig(config);
-            assert.ok(errors.length > 0, 'Should have at least one error');
-            assert.ok(errors.some((e) => e.includes('exclude')), 'Error should mention exclude');
-        });
-        void it('should accept empty exclude array', () => {
-            const config = makeValidConfig({ exclude: [] });
-            const errors = validateConfig(config);
-            assert.deepStrictEqual(errors, []);
-        });
-    });
-    // ── validateConfig: severity ────────────────────────────────────────
-    void describe('validateConfig - severity validation', () => {
-        void it('should return error for invalid severity', () => {
-            const config = makeValidConfig({
-                severity: 'info',
-            });
-            const errors = validateConfig(config);
-            assert.ok(errors.length > 0, 'Should have at least one error');
-            assert.ok(errors.some((e) => e.includes('severity')), 'Error should mention severity');
-        });
-    });
-    // ── validateConfig: maxFiles ────────────────────────────────────────
-    void describe('validateConfig - maxFiles validation', () => {
-        void it('should return error for zero maxFiles', () => {
-            const config = makeValidConfig({ maxFiles: 0 });
-            const errors = validateConfig(config);
-            assert.ok(errors.length > 0, 'Should have at least one error');
-            assert.ok(errors.some((e) => e.includes('maxFiles')), 'Error should mention maxFiles');
-        });
-        void it('should return error for negative maxFiles', () => {
-            const config = makeValidConfig({ maxFiles: -5 });
-            const errors = validateConfig(config);
-            assert.ok(errors.length > 0, 'Should have at least one error');
-            assert.ok(errors.some((e) => e.includes('maxFiles')), 'Error should mention maxFiles');
-        });
-        void it('should return error for non-number maxFiles', () => {
-            const config = makeValidConfig({
-                maxFiles: 'fifty',
-            });
-            const errors = validateConfig(config);
-            assert.ok(errors.length > 0, 'Should have at least one error');
-            assert.ok(errors.some((e) => e.includes('maxFiles')), 'Error should mention maxFiles');
-        });
-    });
-    // ── validateConfig: claude.timeout ──────────────────────────────────
-    void describe('validateConfig - claude.timeout validation', () => {
-        void it('should return error for negative timeout', () => {
-            const config = makeValidConfig({ claude: { timeout: -1000 } });
-            const errors = validateConfig(config);
-            assert.ok(errors.length > 0, 'Should have at least one error');
-            assert.ok(errors.some((e) => e.includes('timeout')), 'Error should mention timeout');
-        });
-        void it('should return error for zero timeout', () => {
-            // timeout of 0 is falsy, so the validation guard skips it
-            // This documents the current behavior
-            const config = makeValidConfig({ claude: { timeout: 0 } });
-            const errors = validateConfig(config);
-            // 0 is falsy, so the `config.claude.timeout &&` guard means
-            // zero timeout does NOT trigger the validation error
-            assert.deepStrictEqual(errors, []);
-        });
-        void it('should return error for non-number timeout', () => {
-            const config = makeValidConfig({
-                claude: { timeout: 'slow' },
-            });
-            const errors = validateConfig(config);
-            assert.ok(errors.length > 0, 'Should have at least one error');
-            assert.ok(errors.some((e) => e.includes('timeout')), 'Error should mention timeout');
-        });
-    });
-    // ── validateConfig: multiple errors ─────────────────────────────────
-    void describe('validateConfig - multiple errors', () => {
-        void it('should collect all validation errors at once', () => {
-            const config = {
-                patterns: [],
-                exclude: 'not-array',
-                severity: 'info',
-                maxFiles: -1,
-                claude: { timeout: -500 },
-                workflow: {
-                    maxConcurrency: 3,
-                    pollInterval: 30000,
-                    maxRetries: 3,
-                    retryCooldown: 300000,
-                    workerTimeout: 1800000,
-                    maxVerificationIterations: 10,
-                },
-            };
-            const errors = validateConfig(config);
-            assert.strictEqual(errors.length, 5, 'Should report all five errors');
-            assert.ok(errors.some((e) => e.includes('patterns')));
-            assert.ok(errors.some((e) => e.includes('exclude')));
-            assert.ok(errors.some((e) => e.includes('severity')));
-            assert.ok(errors.some((e) => e.includes('maxFiles')));
-            assert.ok(errors.some((e) => e.includes('timeout')));
-        });
-    });
-    // ── Default config passes validation ────────────────────────────────
-    void describe('loadConfig + validateConfig integration', () => {
-        void it('should produce a config from loadConfig that passes validation', () => {
-            const tempDir = mkdtempSync(join(tmpdir(), 'edsger-test-'));
-            const originalCwd = process.cwd();
-            try {
-                process.chdir(tempDir);
-                const config = loadConfig();
-                const errors = validateConfig(config);
-                assert.deepStrictEqual(errors, [], 'Default config from loadConfig should pass validation');
-            }
-            finally {
-                process.chdir(originalCwd);
-            }
-        });
-    });
-});

package/dist/config/__tests__/feature-status.test.d.ts

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