edsger 0.41.3 → 0.42.0

package/dist/services/lifecycle-agent/types.d.ts

@@ -0,0 +1,190 @@
+/**
+ * Lifecycle Agent Types
+ *
+ * Type definitions for the AI-powered lifecycle agent that manages
+ * product feature lifecycle decisions: when to advance to the next phase,
+ * when to re-run the current phase, and when to escalate to a human.
+ *
+ * The lifecycle agent evaluates phase outputs against quality criteria
+ * and makes transition decisions, reducing reliance on manual human
+ * intervention while preserving the ability to escalate when needed.
+ */
+import type { FeatureStatus } from '../../types/index.js';
+import type { ExecutionMode } from '../../types/pipeline.js';
+/**
+ * Decision the lifecycle agent can make after evaluating a phase
+ *
+ * - advance: Phase output meets quality criteria, proceed to next phase
+ * - rerun: Phase output needs improvement, re-run with generated feedback
+ * - escalate: Agent is uncertain or output requires human judgment
+ */
+export type LifecycleDecision = 'advance' | 'rerun' | 'escalate';
+/**
+ * Result of evaluating a single quality criterion
+ */
+export interface CriterionEvaluation {
+    /** Criterion identifier matching a CriterionDefinition.id */
+    readonly criterionId: string;
+    /** Score from 0-100 for this criterion */
+    readonly score: number;
+    /** Whether the criterion meets its minimum threshold */
+    readonly passed: boolean;
+    /** Explanation of the evaluation result */
+    readonly reasoning: string;
+    /** Specific issues found, if any */
+    readonly issues?: readonly string[];
+}
+/**
+ * Complete evaluation result for a phase execution
+ * This is the primary output of the lifecycle agent's evaluation step
+ */
+export interface PhaseEvaluationResult {
+    /** The phase that was evaluated */
+    readonly phase: string;
+    /** Feature being evaluated */
+    readonly featureId: string;
+    /** Overall quality score (weighted average of criteria scores, 0-100) */
+    readonly qualityScore: number;
+    /** Decision: advance, rerun, or escalate */
+    readonly decision: LifecycleDecision;
+    /** Agent's confidence in its decision (0-100) */
+    readonly confidence: number;
+    /** Individual criterion evaluations */
+    readonly criteria: readonly CriterionEvaluation[];
+    /** Summary reasoning for the decision */
+    readonly reasoning: string;
+    /** If decision is 'rerun', suggested feedbacks to inject */
+    readonly suggestedFeedbacks?: readonly SuggestedFeedback[];
+    /** How many times this phase has been re-run in the current cycle */
+    readonly rerunCount: number;
+    /** Timestamp of the evaluation */
+    readonly evaluatedAt: string;
+}
+/**
+ * Feedback suggested by the lifecycle agent when deciding to re-run a phase
+ * These mirror the existing Feedback structure so they can be injected
+ * into the feedback system seamlessly
+ */
+export interface SuggestedFeedback {
+    /** Type of feedback, matching existing FeedbackType */
+    readonly feedbackType: 'requirement' | 'constraint' | 'preference' | 'context' | 'quality_criteria' | 'issue' | 'suggestion';
+    /** Short title describing the feedback */
+    readonly title: string;
+    /** Detailed content of the feedback */
+    readonly content: string;
+    /** Priority from 1-10 (higher = more important) */
+    readonly priority: number;
+    /** Which phase this feedback targets */
+    readonly phase: string;
+}
+/**
+ * Definition of a quality criterion for phase evaluation
+ * Each phase has its own set of criteria that the agent uses to evaluate outputs
+ */
+export interface CriterionDefinition {
+    /** Unique identifier for this criterion */
+    readonly id: string;
+    /** Human-readable name */
+    readonly name: string;
+    /** Description of what this criterion measures */
+    readonly description: string;
+    /** Relative importance weight (0-1, all weights for a phase should sum to ~1) */
+    readonly weight: number;
+    /** Minimum score (0-100) needed to pass this criterion */
+    readonly minimumScore: number;
+    /** Prompt instructions for how the AI should evaluate this criterion */
+    readonly evaluationGuidance: string;
+}
+/**
+ * Quality criteria configuration for a specific phase
+ * Defines the thresholds and criteria used to evaluate that phase's outputs
+ */
+export interface PhaseQualityCriteria {
+    /** Phase name (underscore format, e.g., 'user_stories_analysis') */
+    readonly phase: string;
+    /** Minimum overall quality score needed to auto-advance (0-100) */
+    readonly advanceThreshold: number;
+    /** Overall score below which the agent should escalate to human (0-100) */
+    readonly escalateThreshold: number;
+    /** Maximum number of automatic re-runs before escalating */
+    readonly maxAutoRetries: number;
+    /** Individual quality criteria for this phase */
+    readonly criteria: readonly CriterionDefinition[];
+}
+/**
+ * A transition rule that maps phase evaluation outcomes to actions
+ */
+export interface TransitionRule {
+    /** Phase this rule applies to (underscore format) */
+    readonly fromPhase: string;
+    /** Target phase if advancing */
+    readonly toPhase: string;
+    /** Execution mode to use when advancing to the target phase */
+    readonly executionMode: ExecutionMode;
+    /** Feature status to set when advancing */
+    readonly targetStatus: FeatureStatus;
+}
+/**
+ * Configuration for the lifecycle agent
+ * Controls behavior and thresholds for automated lifecycle management
+ */
+export interface LifecycleAgentConfig {
+    /** Whether the lifecycle agent is enabled for this product */
+    readonly enabled: boolean;
+    /** Allow agent to auto-advance phases without human approval */
+    readonly autoAdvanceEnabled: boolean;
+    /** Allow agent to auto-rerun phases with generated feedback */
+    readonly autoRerunEnabled: boolean;
+    /** Global maximum auto-retries (overrides per-phase if lower) */
+    readonly maxAutoRetries: number;
+    /** When confidence is below this threshold, always escalate (0-100) */
+    readonly confidenceThreshold: number;
+    /** Per-phase quality criteria overrides (falls back to defaults if not set) */
+    readonly phaseOverrides?: Partial<Record<string, Partial<PhaseQualityCriteria>>>;
+}
+/**
+ * Runtime state for the lifecycle agent managing a specific feature
+ * Tracks re-run counts and evaluation history
+ */
+export interface LifecycleAgentState {
+    /** Feature being managed */
+    readonly featureId: string;
+    /** Number of re-runs per phase in current cycle */
+    readonly rerunCounts: Readonly<Record<string, number>>;
+    /** History of evaluation results */
+    readonly evaluationHistory: readonly PhaseEvaluationResult[];
+}
+/**
+ * Input to the lifecycle agent's evaluate function
+ * Contains all context needed to evaluate a phase's output
+ */
+export interface PhaseEvaluationInput {
+    /** Feature ID */
+    readonly featureId: string;
+    /** Phase that was just executed */
+    readonly phase: string;
+    /** Current feature status */
+    readonly currentStatus: FeatureStatus;
+    /** The phase execution result data (varies by phase) */
+    readonly phaseOutput: unknown;
+    /** Quality criteria to evaluate against */
+    readonly qualityCriteria: PhaseQualityCriteria;
+    /** Current re-run count for this phase */
+    readonly rerunCount: number;
+    /** Agent configuration */
+    readonly config: LifecycleAgentConfig;
+}
+/**
+ * Output from the lifecycle agent's decide function
+ * Contains the decision and all information needed to execute it
+ */
+export interface LifecycleDecisionResult {
+    /** The evaluation that led to this decision */
+    readonly evaluation: PhaseEvaluationResult;
+    /** The transition to execute if advancing */
+    readonly transition?: TransitionRule;
+    /** Execution mode to use (for both advance and rerun scenarios) */
+    readonly executionMode?: ExecutionMode;
+    /** Feature status to set */
+    readonly targetStatus?: FeatureStatus;
+}

package/dist/services/lifecycle-agent/types.js

@@ -0,0 +1,12 @@
+/**
+ * Lifecycle Agent Types
+ *
+ * Type definitions for the AI-powered lifecycle agent that manages
+ * product feature lifecycle decisions: when to advance to the next phase,
+ * when to re-run the current phase, and when to escalate to a human.
+ *
+ * The lifecycle agent evaluates phase outputs against quality criteria
+ * and makes transition decisions, reducing reliance on manual human
+ * intervention while preserving the ability to escalate when needed.
+ */
+export {};

package/package.json

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

package/.env.local

@@ -1,12 +0,0 @@
-OPENAI_API_KEY=
-TRIGGER_SECRET_KEY=
-RECALL_AI_API_KEY=
-RECALL_WEBHOOK_SECRET=
-NEXT_PUBLIC_APP_URL=
-RESEND_API_KEY=
-EMAIL_FROM=
-GITHUB_APP_ID=
-GITHUB_APP_PRIVATE_KEY=
-GITHUB_APP_SLUG=
-DEEPGRAM_API_KEY=
-DEEPGRAM_PROJECT_ID=

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