edsger 0.19.15 → 0.19.16

package/dist/services/branches.d.ts

@@ -12,7 +12,7 @@ export interface Branch {
     base_branch_id: string | null;
     pull_request_url: string | null;
     pull_request_number: number | null;
-    status: 'pending' | 'in_progress' | 'ready_for_review' | 'reviewed' | 'refined' | 'merged' | 'closed';
+    status: 'pending' | 'in_progress' | 'ready_for_review' | 'reviewed' | 'refined' | 'merged' | 'completed' | 'closed';
     created_at: string;
     updated_at: string;
 }
@@ -56,20 +56,24 @@ export declare function hasMultipleBranches(options: PipelinePhaseOptions): Prom
  */
 export declare function getNextPendingBranch(options: PipelinePhaseOptions): Promise<Branch | null>;
 /**
- * Check if all branches are completed
+ * Check if all branches are completed (feat merged to main)
  */
 export declare function allBranchesCompleted(options: PipelinePhaseOptions): Promise<boolean>;
 /**
  * Get the base branch information for a branch.
  * Returns:
  * - If base_branch_id is null: use main (first branch in chain)
+ * - If base_branch_id is set and that branch is completed: use main
+ *   (completed means feat merged to main)
  * - If base_branch_id is set and that branch is merged: use base branch's feat branch
  *   (merged means dev merged to feat, not to main)
  * - If base_branch_id is set and that branch is not merged: use base branch's dev branch
  *
- * When base branch is merged (squash merge), we need to use `git rebase --onto` to
+ * When base branch is merged/completed (squash merge), we need to use `git rebase --onto` to
  * correctly rebase only the new commits. This function returns both the new base
- * (feat branch) and the original base (dev branch) for this purpose.
+ * and the original base for this purpose:
+ * - completed: baseBranch=main, originalBaseBranch=feat/xxx
+ * - merged: baseBranch=feat/xxx, originalBaseBranch=dev/xxx
  */
 export declare function getBaseBranchInfo(branch: Branch, allBranches: Branch[], mainBranch?: string): Promise<{
     baseBranch: string;

package/dist/services/branches.js

@@ -97,6 +97,8 @@ export function formatBranchesForContext(branches) {
     }
     const getStatusEmoji = (status) => {
         switch (status) {
+            case 'completed':
+                return '🏁';
             case 'merged':
                 return '✅';
             case 'refined':
@@ -148,25 +150,29 @@ export async function getNextPendingBranch(options) {
     return branches.find((b) => b.status === 'pending') || null;
 }
 /**
- * Check if all branches are completed
+ * Check if all branches are completed (feat merged to main)
  */
 export async function allBranchesCompleted(options) {
     const branches = await getBranches(options);
     if (branches.length === 0)
         return true;
-    return branches.every((b) => b.status === 'merged' || b.status === 'closed');
+    return branches.every((b) => b.status === 'completed' || b.status === 'merged' || b.status === 'closed');
 }
 /**
  * Get the base branch information for a branch.
  * Returns:
  * - If base_branch_id is null: use main (first branch in chain)
+ * - If base_branch_id is set and that branch is completed: use main
+ *   (completed means feat merged to main)
  * - If base_branch_id is set and that branch is merged: use base branch's feat branch
  *   (merged means dev merged to feat, not to main)
  * - If base_branch_id is set and that branch is not merged: use base branch's dev branch
  *
- * When base branch is merged (squash merge), we need to use `git rebase --onto` to
+ * When base branch is merged/completed (squash merge), we need to use `git rebase --onto` to
  * correctly rebase only the new commits. This function returns both the new base
- * (feat branch) and the original base (dev branch) for this purpose.
+ * and the original base for this purpose:
+ * - completed: baseBranch=main, originalBaseBranch=feat/xxx
+ * - merged: baseBranch=feat/xxx, originalBaseBranch=dev/xxx
  */
 export async function getBaseBranchInfo(branch, allBranches, mainBranch = 'main') {
     // No base branch - start from main (first branch in chain)
@@ -187,6 +193,25 @@ export async function getBaseBranchInfo(branch, allBranches, mainBranch = 'main'
             baseBranchMerged: true,
         };
     }
+    // Check if base branch is completed (feat merged to main)
+    if (baseBranch.status === 'completed') {
+        // Base branch's feat is merged to main - rebase directly from main
+        // Use feat branch as originalBaseBranch for --onto
+        if (!baseBranch.branch_name) {
+            return {
+                baseBranch: mainBranch,
+                needsRebase: false,
+                baseBranchMerged: true,
+            };
+        }
+        const featBranchName = baseBranch.branch_name.replace(/^dev\//, 'feat/');
+        return {
+            baseBranch: mainBranch,
+            originalBaseBranch: featBranchName, // Use feat branch for --onto
+            needsRebase: true,
+            baseBranchMerged: true,
+        };
+    }
     // Check if base branch is merged (dev merged to feat)
     if (baseBranch.status === 'merged') {
         // Base branch's dev is merged to feat - rebase from base branch's feat branch

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "edsger",
-  "version": "0.19.15",
+  "version": "0.19.16",
   "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 {};