edsger 0.13.4 → 0.15.0

package/.claude/settings.local.json

@@ -0,0 +1,28 @@
+{
+  "permissions": {
+    "allow": [
+      "Read(//Users/steven/development/edsger/**)",
+      "Bash(npm run build)",
+      "Bash(node:*)",
+      "Bash(git add:*)",
+      "Bash(git commit:*)",
+      "Bash(ls:*)",
+      "Bash(cat:*)",
+      "Bash(npm run typecheck:*)",
+      "Bash(git diff:*)",
+      "WebSearch",
+      "WebFetch(domain:supabase.com)",
+      "Bash(npm install:*)",
+      "Bash(grep:*)",
+      "Bash(npx supabase gen types typescript --help:*)",
+      "Bash(git -C /Users/steven/development/edsger status)",
+      "Bash(git -C /Users/steven/development/edsger diff)",
+      "Bash(git -C /Users/steven/development/edsger log --oneline -5)",
+      "Bash(git -C /Users/steven/development/edsger add supabase/migrations/20251231000000_drop_unused_views.sql)",
+      "Bash(git -C /Users/steven/development/edsger commit -m \"$\\(cat <<''EOF''\nchore: drop unused database views\n\nRemove test_report_summary and user_stories_with_context views that are defined but never used in the application.\n\n🤖 Generated with [Claude Code]\\(https://claude.com/claude-code\\)\n\nCo-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>\nEOF\n\\)\")",
+      "Bash(git -C /Users/steven/development/edsger commit -m \"$\\(cat <<''EOF''\nchore: drop unused database views\n\nRemove test_report_summary and user_stories_with_context views\nthat are defined but never used in the application.\n\n🤖 Generated with [Claude Code]\\(https://claude.com/claude-code\\)\n\nCo-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>\nEOF\n\\)\")"
+    ],
+    "deny": [],
+    "ask": []
+  }
+}

package/dist/api/features/__tests__/regression-prevention.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Specialized tests for status regression prevention
+ * Focuses on the core business requirement: preventing backward status movement
+ */
+export {};

package/dist/api/features/__tests__/regression-prevention.test.js

@@ -0,0 +1,338 @@
+/**
+ * Specialized tests for status regression prevention
+ * Focuses on the core business requirement: preventing backward status movement
+ */
+import { describe, it } from 'node:test';
+import assert from 'node:assert';
+import { isForwardProgression } from '../status-updater.js';
+import { STATUS_PROGRESSION_ORDER } from '../../../config/feature-status.js';
+describe('Regression Prevention Tests', () => {
+    describe('Core Business Logic: Prevent Backlog Regression', () => {
+        it('should prevent any status from regressing to backlog', () => {
+            const allStatuses = STATUS_PROGRESSION_ORDER.slice(1); // All except backlog itself
+            for (const status of allStatuses) {
+                const result = isForwardProgression(status, 'backlog');
+                assert.strictEqual(result, false, `Status ${status} should NOT be allowed to regress to backlog`);
+            }
+        });
+        it('should allow progression from backlog to any other status', () => {
+            const targetStatuses = STATUS_PROGRESSION_ORDER.slice(1); // All except backlog
+            for (const targetStatus of targetStatuses) {
+                const result = isForwardProgression('backlog', targetStatus);
+                assert.strictEqual(result, true, `Should allow progression from backlog to ${targetStatus}`);
+            }
+        });
+        it('should prevent regression from any status to ready_for_dev', () => {
+            // Only backlog should be allowed to progress to ready_for_dev
+            const higherStatuses = STATUS_PROGRESSION_ORDER.slice(2); // All except backlog and ready_for_dev
+            for (const status of higherStatuses) {
+                const result = isForwardProgression(status, 'ready_for_dev');
+                assert.strictEqual(result, false, `Status ${status} should NOT regress to ready_for_dev`);
+            }
+        });
+        it('should prevent all forms of backward progression in critical workflow', () => {
+            // Test critical workflow progression points
+            const criticalProgression = [
+                'backlog',
+                'ready_for_dev',
+                'feature_analysis',
+                'technical_design',
+                'code_implementation',
+                'functional_testing',
+                'deployment',
+                'shipped',
+            ];
+            // Test every possible backward combination
+            for (let i = 0; i < criticalProgression.length; i++) {
+                for (let j = 0; j < i; j++) {
+                    const currentStatus = criticalProgression[i];
+                    const targetStatus = criticalProgression[j];
+                    const result = isForwardProgression(currentStatus, targetStatus);
+                    assert.strictEqual(result, false, `Should prevent regression from ${currentStatus} to ${targetStatus}`);
+                }
+            }
+        });
+    });
+    describe('CLI Phase Protection', () => {
+        it('should identify scenarios where CLI phases could cause regression', () => {
+            // Simulate CLI phases that could potentially cause issues
+            const problematicScenarios = [
+                {
+                    currentStatus: 'code_implementation',
+                    phase: 'feature-analysis',
+                    expectedTargetStatus: 'feature_analysis',
+                    description: 'CLI re-running feature analysis after code implementation',
+                },
+                {
+                    currentStatus: 'deployment',
+                    phase: 'technical-design',
+                    expectedTargetStatus: 'technical_design',
+                    description: 'CLI running technical design after deployment',
+                },
+                {
+                    currentStatus: 'shipped',
+                    phase: 'code-implementation',
+                    expectedTargetStatus: 'code_implementation',
+                    description: 'CLI attempting code implementation on shipped feature',
+                },
+                {
+                    currentStatus: 'testing_passed',
+                    phase: 'feature-analysis',
+                    expectedTargetStatus: 'feature_analysis',
+                    description: 'CLI re-analyzing feature after tests passed',
+                },
+            ];
+            for (const scenario of problematicScenarios) {
+                const result = isForwardProgression(scenario.currentStatus, scenario.expectedTargetStatus);
+                assert.strictEqual(result, false, `Regression prevention should block: ${scenario.description}`);
+            }
+        });
+        it('should allow valid CLI phase progressions', () => {
+            const validScenarios = [
+                {
+                    currentStatus: 'backlog',
+                    phase: 'feature-analysis',
+                    expectedTargetStatus: 'feature_analysis',
+                    description: 'CLI starting feature analysis from backlog',
+                },
+                {
+                    currentStatus: 'feature_analysis',
+                    phase: 'technical-design',
+                    expectedTargetStatus: 'technical_design',
+                    description: 'CLI progressing to technical design',
+                },
+                {
+                    currentStatus: 'technical_design',
+                    phase: 'code-implementation',
+                    expectedTargetStatus: 'code_implementation',
+                    description: 'CLI progressing to code implementation',
+                },
+                {
+                    currentStatus: 'functional_testing',
+                    phase: 'deployment',
+                    expectedTargetStatus: 'deployment',
+                    description: 'CLI progressing to deployment after testing',
+                },
+            ];
+            for (const scenario of validScenarios) {
+                const result = isForwardProgression(scenario.currentStatus, scenario.expectedTargetStatus);
+                assert.strictEqual(result, true, `Valid progression should be allowed: ${scenario.description}`);
+            }
+        });
+    });
+    describe('Edge Cases and Boundary Conditions', () => {
+        it('should handle same-status transitions correctly', () => {
+            // Allow staying at the same status (for retries, re-runs, etc.)
+            for (const status of STATUS_PROGRESSION_ORDER) {
+                const result = isForwardProgression(status, status);
+                assert.strictEqual(result, true, `Should allow staying at status ${status}`);
+            }
+        });
+        it('should handle first and last status edge cases', () => {
+            const firstStatus = STATUS_PROGRESSION_ORDER[0]; // 'backlog'
+            const lastStatus = STATUS_PROGRESSION_ORDER[STATUS_PROGRESSION_ORDER.length - 1]; // 'shipped'
+            // From first to last should be allowed
+            const forwardResult = isForwardProgression(firstStatus, lastStatus);
+            assert.strictEqual(forwardResult, true, 'Should allow progression from first to last status');
+            // From last to first should be prevented
+            const backwardResult = isForwardProgression(lastStatus, firstStatus);
+            assert.strictEqual(backwardResult, false, 'Should prevent regression from last to first status');
+        });
+        it('should validate progression order is strictly enforced', () => {
+            // Test every adjacent pair in the progression
+            for (let i = 0; i < STATUS_PROGRESSION_ORDER.length - 1; i++) {
+                const currentStatus = STATUS_PROGRESSION_ORDER[i];
+                const nextStatus = STATUS_PROGRESSION_ORDER[i + 1];
+                // Forward should be allowed
+                const forwardResult = isForwardProgression(currentStatus, nextStatus);
+                assert.strictEqual(forwardResult, true, `Should allow progression from ${currentStatus} to ${nextStatus}`);
+                // Backward should be prevented
+                const backwardResult = isForwardProgression(nextStatus, currentStatus);
+                assert.strictEqual(backwardResult, false, `Should prevent regression from ${nextStatus} to ${currentStatus}`);
+            }
+        });
+        it('should handle testing workflow regression scenarios', () => {
+            // Testing has special rules - test specific edge cases
+            const testingScenarios = [
+                {
+                    from: 'testing_passed',
+                    to: 'testing_in_progress',
+                    shouldAllow: false,
+                    description: 'Should prevent going back from passed to in-progress',
+                },
+                {
+                    from: 'testing_passed',
+                    to: 'testing_failed',
+                    shouldAllow: true,
+                    description: 'Should allow going from passed to failed (possible if retested)',
+                },
+                {
+                    from: 'testing_failed',
+                    to: 'testing_passed',
+                    shouldAllow: false,
+                    description: 'Should prevent going from failed to passed (need to restart testing)',
+                },
+                {
+                    from: 'testing_in_progress',
+                    to: 'testing_failed',
+                    shouldAllow: true,
+                    description: 'Should allow marking in-progress tests as failed',
+                },
+                {
+                    from: 'testing_in_progress',
+                    to: 'testing_passed',
+                    shouldAllow: true,
+                    description: 'Should allow marking in-progress tests as passed',
+                },
+            ];
+            for (const scenario of testingScenarios) {
+                const result = isForwardProgression(scenario.from, scenario.to);
+                assert.strictEqual(result, scenario.shouldAllow, scenario.description);
+            }
+        });
+        it('should prevent skipping multiple phases backwards', () => {
+            // Test skipping multiple phases in regression
+            const skipBackwardTests = [
+                {
+                    from: 'shipped',
+                    to: 'feature_analysis',
+                    skipCount: 'many phases',
+                },
+                {
+                    from: 'code_implementation',
+                    to: 'backlog',
+                    skipCount: 'many phases',
+                },
+                {
+                    from: 'deployment',
+                    to: 'ready_for_dev',
+                    skipCount: 'many phases',
+                },
+            ];
+            for (const test of skipBackwardTests) {
+                const result = isForwardProgression(test.from, test.to);
+                assert.strictEqual(result, false, `Should prevent skipping ${test.skipCount} backwards from ${test.from} to ${test.to}`);
+            }
+        });
+        it('should allow skipping multiple phases forward', () => {
+            // Test skipping phases in forward direction (should be allowed)
+            const skipForwardTests = [
+                {
+                    from: 'backlog',
+                    to: 'code_implementation',
+                    description: 'Skip from backlog to code implementation',
+                },
+                {
+                    from: 'feature_analysis',
+                    to: 'deployment',
+                    description: 'Skip from analysis to deployment',
+                },
+                {
+                    from: 'technical_design',
+                    to: 'shipped',
+                    description: 'Skip from design to shipped',
+                },
+            ];
+            for (const test of skipForwardTests) {
+                const result = isForwardProgression(test.from, test.to);
+                assert.strictEqual(result, true, `Should allow forward skip: ${test.description}`);
+            }
+        });
+    });
+    describe('Real-world Workflow Scenarios', () => {
+        it('should handle hotfix scenario correctly', () => {
+            // Hotfix: shipped feature needs bug fixing
+            // Should allow progression to bug_fixing from shipped
+            const result = isForwardProgression('shipped', 'bug_fixing');
+            // Since bug_fixing comes before shipped in progression, this should be false
+            assert.strictEqual(result, false, 'Should prevent regression from shipped to bug_fixing (hotfixes need new feature entries)');
+        });
+        it('should handle feature refinement scenarios', () => {
+            // Feature refinement: going from code_implementation to code_refine
+            const result1 = isForwardProgression('code_implementation', 'code_refine');
+            assert.strictEqual(result1, true, 'Should allow progression from implementation to refinement');
+            // But not the other way around
+            const result2 = isForwardProgression('code_refine', 'code_implementation');
+            assert.strictEqual(result2, false, 'Should prevent regression from refinement to implementation');
+        });
+        it('should handle review cycle scenarios', () => {
+            // Review cycles: code_review -> pull_request -> code_review (if rejected)
+            const reviewToPrep = isForwardProgression('code_review', 'pull_request');
+            assert.strictEqual(reviewToPrep, true, 'Should allow progression from review to pull request');
+            // But not back from pull_request to code_review
+            const prepToReview = isForwardProgression('pull_request', 'code_review');
+            assert.strictEqual(prepToReview, false, 'Should prevent regression from pull request to code review');
+        });
+        it('should handle deployment rollback scenarios', () => {
+            // Deployment rollback: deployment -> functional_testing (to re-test)
+            const deployToTest = isForwardProgression('deployment', 'functional_testing');
+            assert.strictEqual(deployToTest, false, 'Should prevent regression from deployment to testing (rollbacks need new process)');
+        });
+        it('should validate complete workflow progression path', () => {
+            // Simulate a complete feature lifecycle
+            const completeWorkflow = [
+                'backlog',
+                'ready_for_dev',
+                'feature_analysis',
+                'feature_analysis_verification',
+                'technical_design',
+                'technical_design_verification',
+                'code_implementation',
+                'code_refine',
+                'code_review',
+                'pull_request',
+                'functional_testing',
+                'testing_in_progress',
+                'testing_passed',
+                'deployment',
+                'shipped',
+            ];
+            // Test each step in the workflow
+            for (let i = 0; i < completeWorkflow.length - 1; i++) {
+                const currentStatus = completeWorkflow[i];
+                const nextStatus = completeWorkflow[i + 1];
+                const result = isForwardProgression(currentStatus, nextStatus);
+                assert.strictEqual(result, true, `Workflow step ${i + 1}: Should allow progression from ${currentStatus} to ${nextStatus}`);
+            }
+            // Test that you can't go backwards at any point in the workflow
+            for (let i = 1; i < completeWorkflow.length; i++) {
+                const currentStatus = completeWorkflow[i];
+                const previousStatus = completeWorkflow[i - 1];
+                const result = isForwardProgression(currentStatus, previousStatus);
+                assert.strictEqual(result, false, `Workflow regression check ${i}: Should prevent regression from ${currentStatus} to ${previousStatus}`);
+            }
+        });
+    });
+    describe('Status Progression Order Validation', () => {
+        it('should ensure progression order matches business workflow', () => {
+            // Verify that the progression order makes business sense
+            const criticalStatusPositions = {
+                backlog: STATUS_PROGRESSION_ORDER.indexOf('backlog'),
+                ready_for_dev: STATUS_PROGRESSION_ORDER.indexOf('ready_for_dev'),
+                feature_analysis: STATUS_PROGRESSION_ORDER.indexOf('feature_analysis'),
+                technical_design: STATUS_PROGRESSION_ORDER.indexOf('technical_design'),
+                code_implementation: STATUS_PROGRESSION_ORDER.indexOf('code_implementation'),
+                functional_testing: STATUS_PROGRESSION_ORDER.indexOf('functional_testing'),
+                deployment: STATUS_PROGRESSION_ORDER.indexOf('deployment'),
+                shipped: STATUS_PROGRESSION_ORDER.indexOf('shipped'),
+            };
+            // Verify logical ordering
+            assert.ok(criticalStatusPositions.backlog < criticalStatusPositions.ready_for_dev, 'Backlog should come before ready_for_dev');
+            assert.ok(criticalStatusPositions.ready_for_dev < criticalStatusPositions.feature_analysis, 'Ready for dev should come before feature analysis');
+            assert.ok(criticalStatusPositions.feature_analysis < criticalStatusPositions.technical_design, 'Feature analysis should come before technical design');
+            assert.ok(criticalStatusPositions.technical_design < criticalStatusPositions.code_implementation, 'Technical design should come before code implementation');
+            assert.ok(criticalStatusPositions.code_implementation < criticalStatusPositions.functional_testing, 'Code implementation should come before functional testing');
+            assert.ok(criticalStatusPositions.functional_testing < criticalStatusPositions.deployment, 'Functional testing should come before deployment');
+            assert.ok(criticalStatusPositions.deployment < criticalStatusPositions.shipped, 'Deployment should come before shipped');
+        });
+        it('should prevent CLI from causing any backward movement', () => {
+            // This test specifically addresses the original issue:
+            // "After running CLI, in some phases, it update feature status to 'Backlog'"
+            // No matter what the current status is, CLI should NEVER be able to set it to backlog
+            for (const currentStatus of STATUS_PROGRESSION_ORDER.slice(1)) {
+                const result = isForwardProgression(currentStatus, 'backlog');
+                assert.strictEqual(result, false, `CLI should NEVER be able to regress ${currentStatus} to backlog`);
+            }
+        });
+    });
+});

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

@@ -0,0 +1,5 @@
+/**
+ * Integration tests for status updater functionality
+ * Tests the complete flow including MCP calls and error handling
+ */
+export {};