edsger 0.51.0 → 0.53.0

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 {};

package/dist/config/__tests__/feature-status.test.js

@@ -1,111 +0,0 @@
-/**
- * Unit tests for feature status configuration
- */
-import assert from 'node:assert';
-import { describe, it } from 'node:test';
-import { PHASE_STATUS_MAP, STATUS_PROGRESSION_ORDER, } from '../feature-status.js';
-void describe('Feature Status Configuration', () => {
-    void describe('STATUS_PROGRESSION_ORDER', () => {
-        void it('should start with backlog and end with archived', () => {
-            assert.strictEqual(STATUS_PROGRESSION_ORDER[0], 'backlog', 'First status should be backlog');
-            assert.strictEqual(STATUS_PROGRESSION_ORDER[STATUS_PROGRESSION_ORDER.length - 1], 'archived', 'Last status should be archived');
-        });
-        void it('should be readonly', () => {
-            // This test ensures the configuration is properly typed as readonly
-            // TypeScript will catch attempts to modify the array at compile time
-            assert.ok(Array.isArray(STATUS_PROGRESSION_ORDER));
-            assert.ok(STATUS_PROGRESSION_ORDER.length > 0);
-        });
-        void it('should maintain logical workflow order', () => {
-            const criticalOrder = [
-                'backlog',
-                'ready_for_ai',
-                'feature_analysis',
-                'technical_design',
-                'code_implementation',
-                'shipped',
-            ];
-            let lastIndex = -1;
-            for (const status of criticalOrder) {
-                const currentIndex = STATUS_PROGRESSION_ORDER.indexOf(status);
-                assert.ok(currentIndex > lastIndex, `${status} should come after the previous critical status`);
-                lastIndex = currentIndex;
-            }
-        });
-    });
-    void describe('PHASE_STATUS_MAP', () => {
-        void it('should map all expected phases', () => {
-            const expectedPhases = [
-                'feature-analysis',
-                'feature-analysis-verification',
-                'technical-design',
-                'technical-design-verification',
-                'code-implementation',
-                'code-implementation-verification',
-                'code-refine',
-                'code-refine-verification',
-                'bug-fixing',
-                'code-review',
-                'pull-request',
-                'functional-testing',
-                'testing-in-progress',
-                'testing-passed',
-                'testing-failed',
-            ];
-            for (const phase of expectedPhases) {
-                assert.ok(phase in PHASE_STATUS_MAP, `Should have mapping for phase: ${phase}`);
-            }
-        });
-        void it('should map phases to valid statuses', () => {
-            for (const [phase, status] of Object.entries(PHASE_STATUS_MAP)) {
-                assert.ok(STATUS_PROGRESSION_ORDER.includes(status), `Phase ${phase} maps to valid status ${status}`);
-            }
-        });
-        void it('should use kebab-case for multi-word phase names and snake_case for multi-word status names', () => {
-            for (const [phase, status] of Object.entries(PHASE_STATUS_MAP)) {
-                // Phase names should not contain underscores
-                assert.ok(!phase.includes('_'), `Phase name ${phase} should not contain underscores`);
-                // Status names should not contain hyphens
-                assert.ok(!status.includes('-'), `Status name ${status} should not contain hyphens`);
-                // Multi-word phase names should use hyphens
-                if (phase.split('-').length > 1) {
-                    assert.ok(phase.includes('-'), `Multi-word phase name ${phase} should use kebab-case`);
-                }
-                // Multi-word status names should use underscores
-                if (status.split('_').length > 1) {
-                    assert.ok(status.includes('_'), `Multi-word status name ${status} should use snake_case`);
-                }
-            }
-        });
-        void it('should maintain consistency with phase naming conventions', () => {
-            // Test some specific mappings to ensure they follow expected patterns
-            assert.strictEqual(PHASE_STATUS_MAP['feature-analysis'], 'feature_analysis', 'feature-analysis should map to feature_analysis');
-            assert.strictEqual(PHASE_STATUS_MAP['technical-design-verification'], 'technical_design_verification', 'technical-design-verification should map to technical_design_verification');
-            assert.strictEqual(PHASE_STATUS_MAP['code-implementation'], 'code_implementation', 'code-implementation should map to code_implementation');
-        });
-        void it('should be readonly', () => {
-            // Ensure the mapping is properly configured as readonly
-            assert.ok(typeof PHASE_STATUS_MAP === 'object');
-            assert.ok(Object.keys(PHASE_STATUS_MAP).length > 0);
-        });
-    });
-    void describe('Integration Tests', () => {
-        void it('should have all mapped statuses in progression order', () => {
-            const mappedStatuses = Object.values(PHASE_STATUS_MAP);
-            for (const status of mappedStatuses) {
-                assert.ok(STATUS_PROGRESSION_ORDER.includes(status), `Mapped status ${status} should be in progression order`);
-            }
-        });
-        void it('should not have gaps in critical workflow phases', () => {
-            const workflowPhases = [
-                'feature-analysis',
-                'technical-design',
-                'code-implementation',
-                'functional-testing',
-            ];
-            for (const phase of workflowPhases) {
-                assert.ok(phase in PHASE_STATUS_MAP, `Critical workflow phase ${phase} should be mapped`);
-            }
-        });
-    });
-});

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

@@ -1,56 +0,0 @@
-/**
- * Feature status configuration
- * Defines the progression order and mappings for feature statuses
- */
-import type { FeatureStatus } from '../types/index.js';
-/**
- * Status progression order - higher index means more advanced status
- * This defines the allowed forward progression through the feature workflow
- *
- * Business Logic Rules:
- * - Features can only move forward or stay at the same status level
- * - No regression to earlier stages is allowed (e.g., cannot go back to 'backlog' from 'code_implementation')
- * - Status updates preserve development momentum and prevent accidental rollbacks
- *
- * Special Cases:
- * - testing_failed → testing_in_progress: Allowed for retry attempts after fixing issues
- * - Same status → same status: Allowed for retries, reprocessing, or status confirmation
- * - code_refine_verification → code_refine: Handled by specific retry logic, not this progression
- *
- * Note: The order reflects the typical development workflow from initial planning
- * through to final shipping. All status values must match the database constraint
- * in migration 20251019000000_update_feature_status_constraint.sql
- */
-export declare const STATUS_PROGRESSION_ORDER: readonly FeatureStatus[];
-/**
- * Phase to status mapping
- * Maps pipeline phase names to their corresponding feature statuses
- *
- * This mapping ensures that each pipeline phase updates the feature to the appropriate
- * status. Phase names use kebab-case (e.g., 'feature-analysis') while status values
- * use snake_case (e.g., 'feature_analysis') to match database schema.
- *
- * All status values must match the database constraint in migration 20251019000000_update_feature_status_constraint.sql
- *
- * If a phase is not found in this mapping, updateFeatureStatusForPhase will return null
- * and skip the status update to prevent unintended regression to 'backlog'.
- */
-export declare const PHASE_STATUS_MAP: Record<string, FeatureStatus>;
-/**
- * Human-selectable statuses
- * These are the statuses that a human user can manually set.
- *
- * Excluded statuses (system-managed):
- * - *_verification statuses: Automatically entered after completing the corresponding phase
- * - testing_in_progress: Automatically set when functional testing begins
- * - testing_passed: Automatically set when all tests pass
- * - testing_failed: Automatically set when tests fail
- *
- * These excluded statuses should not be shown in UI dropdowns for manual status changes
- * because they represent intermediate states that are managed by the workflow system.
- */
-export declare const HUMAN_SELECTABLE_STATUSES: readonly FeatureStatus[];
-/**
- * Check if a status can be manually selected by a human user
- */
-export declare function isHumanSelectableStatus(status: FeatureStatus): boolean;

package/dist/config/feature-status.js

@@ -1,130 +0,0 @@
-/**
- * Feature status configuration
- * Defines the progression order and mappings for feature statuses
- */
-/**
- * Status progression order - higher index means more advanced status
- * This defines the allowed forward progression through the feature workflow
- *
- * Business Logic Rules:
- * - Features can only move forward or stay at the same status level
- * - No regression to earlier stages is allowed (e.g., cannot go back to 'backlog' from 'code_implementation')
- * - Status updates preserve development momentum and prevent accidental rollbacks
- *
- * Special Cases:
- * - testing_failed → testing_in_progress: Allowed for retry attempts after fixing issues
- * - Same status → same status: Allowed for retries, reprocessing, or status confirmation
- * - code_refine_verification → code_refine: Handled by specific retry logic, not this progression
- *
- * Note: The order reflects the typical development workflow from initial planning
- * through to final shipping. All status values must match the database constraint
- * in migration 20251019000000_update_feature_status_constraint.sql
- */
-export const STATUS_PROGRESSION_ORDER = [
-    'backlog',
-    'ready_for_ai',
-    'assigned_to_ai',
-    'feature_analysis',
-    'feature_analysis_verification',
-    'user_stories_analysis',
-    'user_stories_analysis_verification',
-    'test_cases_analysis',
-    'test_cases_analysis_verification',
-    'technical_design',
-    'technical_design_verification',
-    'branch_planning',
-    'branch_planning_verification',
-    'code_implementation',
-    'code_implementation_verification',
-    'pr_splitting',
-    'pr_splitting_verification',
-    'pr_execution',
-    'code_refine',
-    'code_refine_verification',
-    'bug_fixing',
-    'code_review',
-    'functional_testing',
-    'testing_in_progress',
-    'testing_passed',
-    'testing_failed',
-    'ready_for_review',
-    'shipped',
-    'archived',
-];
-/**
- * Phase to status mapping
- * Maps pipeline phase names to their corresponding feature statuses
- *
- * This mapping ensures that each pipeline phase updates the feature to the appropriate
- * status. Phase names use kebab-case (e.g., 'feature-analysis') while status values
- * use snake_case (e.g., 'feature_analysis') to match database schema.
- *
- * All status values must match the database constraint in migration 20251019000000_update_feature_status_constraint.sql
- *
- * If a phase is not found in this mapping, updateFeatureStatusForPhase will return null
- * and skip the status update to prevent unintended regression to 'backlog'.
- */
-export const PHASE_STATUS_MAP = {
-    'feature-analysis': 'feature_analysis',
-    'feature-analysis-verification': 'feature_analysis_verification',
-    'user-stories-analysis': 'user_stories_analysis',
-    'user-stories-analysis-verification': 'user_stories_analysis_verification',
-    'test-cases-analysis': 'test_cases_analysis',
-    'test-cases-analysis-verification': 'test_cases_analysis_verification',
-    'technical-design': 'technical_design',
-    'technical-design-verification': 'technical_design_verification',
-    'branch-planning': 'branch_planning',
-    'branch-planning-verification': 'branch_planning_verification',
-    'code-implementation': 'code_implementation',
-    'code-implementation-verification': 'code_implementation_verification',
-    'pr-splitting': 'pr_splitting',
-    'pr-splitting-verification': 'pr_splitting_verification',
-    'pr-execution': 'pr_execution',
-    'code-refine': 'code_refine',
-    'code-refine-verification': 'code_refine_verification',
-    'bug-fixing': 'bug_fixing',
-    'code-review': 'code_review',
-    'functional-testing': 'functional_testing',
-    'testing-in-progress': 'testing_in_progress',
-    'testing-passed': 'testing_passed',
-    'testing-failed': 'testing_failed',
-    'ready-for-review': 'ready_for_review',
-};
-/**
- * Human-selectable statuses
- * These are the statuses that a human user can manually set.
- *
- * Excluded statuses (system-managed):
- * - *_verification statuses: Automatically entered after completing the corresponding phase
- * - testing_in_progress: Automatically set when functional testing begins
- * - testing_passed: Automatically set when all tests pass
- * - testing_failed: Automatically set when tests fail
- *
- * These excluded statuses should not be shown in UI dropdowns for manual status changes
- * because they represent intermediate states that are managed by the workflow system.
- */
-export const HUMAN_SELECTABLE_STATUSES = [
-    'backlog',
-    'ready_for_ai',
-    'feature_analysis',
-    'user_stories_analysis',
-    'test_cases_analysis',
-    'technical_design',
-    'branch_planning',
-    'code_implementation',
-    'pr_splitting',
-    'pr_execution',
-    'code_refine',
-    'bug_fixing',
-    'code_review',
-    'functional_testing',
-    'ready_for_review',
-    'shipped',
-    'archived',
-];
-/**
- * Check if a status can be manually selected by a human user
- */
-export function isHumanSelectableStatus(status) {
-    return HUMAN_SELECTABLE_STATUSES.includes(status);
-}

package/dist/errors/__tests__/index.test.d.ts

@@ -1,4 +0,0 @@
-/**
- * Unit tests for Edsger error classification system
- */
-export {};