edsger 0.13.0 → 0.13.1

package/dist/utils/git-branch-manager.d.ts

@@ -22,6 +22,10 @@ export declare function resetUncommittedChanges(verbose?: boolean): void;
  * Check if a Git branch exists locally
  */
 export declare function branchExists(branch: string): boolean;
+/**
+ * Check if a remote branch exists
+ */
+export declare function remoteBranchExists(branch: string): boolean;
 /**
  * Switch to a specific Git branch, creating it if it doesn't exist
  */

package/dist/utils/git-branch-manager.js

@@ -76,6 +76,23 @@ export function branchExists(branch) {
         return false;
     }
 }
+/**
+ * Check if a remote branch exists
+ */
+export function remoteBranchExists(branch) {
+    try {
+        // Fetch remote refs first to ensure we have latest info
+        execSync('git fetch origin --prune', { encoding: 'utf-8', stdio: 'pipe' });
+        execSync(`git rev-parse --verify origin/${branch}`, {
+            encoding: 'utf-8',
+            stdio: 'pipe',
+        });
+        return true;
+    }
+    catch (error) {
+        return false;
+    }
+}
 /**
  * Switch to a specific Git branch, creating it if it doesn't exist
  */
@@ -179,6 +196,50 @@ export function switchToFeatureBranchAndRebase(featureBranch, baseBranch = 'main
     if (getCurrentBranch() !== featureBranch) {
         switchToBranch(featureBranch, verbose);
     }
+    // Sync with remote feature branch if it exists
+    // This handles the case where the branch was pushed from another machine
+    try {
+        // Check for uncommitted changes and reset if found before any git operations
+        if (hasUncommittedChanges()) {
+            if (verbose) {
+                logInfo(`⚠️  Found uncommitted changes. Resetting to clean state before sync...`);
+            }
+            resetUncommittedChanges(verbose);
+        }
+        // Fetch to get latest remote state
+        execSync('git fetch origin', { encoding: 'utf-8', stdio: 'pipe' });
+        // Check if remote feature branch exists
+        try {
+            execSync(`git rev-parse --verify origin/${featureBranch}`, {
+                encoding: 'utf-8',
+                stdio: 'pipe',
+            });
+            // Remote branch exists, sync with it
+            if (verbose) {
+                logInfo(`📥 Syncing with remote feature branch origin/${featureBranch}...`);
+            }
+            // Reset local branch to match remote branch
+            // This ensures we have all commits from the remote (e.g., from another machine)
+            execSync(`git reset --hard origin/${featureBranch}`, {
+                encoding: 'utf-8',
+                stdio: 'pipe',
+            });
+            if (verbose) {
+                logInfo(`✅ Synced local branch with origin/${featureBranch}`);
+            }
+        }
+        catch (e) {
+            // Remote branch doesn't exist, that's fine - we'll push later
+            if (verbose) {
+                logInfo(`   Remote branch origin/${featureBranch} doesn't exist yet, will create on push`);
+            }
+        }
+    }
+    catch (error) {
+        if (verbose) {
+            logInfo(`⚠️  Could not sync with remote feature branch, continuing with local branch`);
+        }
+    }
     // Rebase feature branch with latest main
     if (verbose) {
         logInfo(`📥 Rebasing ${featureBranch} with origin/${baseBranch}...`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "edsger",
-  "version": "0.13.0",
+  "version": "0.13.1",
   "type": "module",
   "bin": {
     "edsger": "dist/index.js"

package/.claude/settings.local.json

@@ -1,28 +0,0 @@
-{
-  "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

@@ -1,5 +0,0 @@
-/**
- * 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

@@ -1,338 +0,0 @@
-/**
- * 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

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