edsger 0.46.0 → 0.48.0

package/dist/services/coaching/__tests__/coaching-loop.test.js

@@ -0,0 +1,59 @@
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+import { isStagnant } from '../coaching-loop.js';
+function makeRating(score) {
+    return {
+        score,
+        summary: `Score: ${score}`,
+        criteria_scores: {},
+        strengths: [],
+        weaknesses: [],
+    };
+}
+void describe('isStagnant', () => {
+    void it('returns false when fewer than 3 ratings', () => {
+        assert.strictEqual(isStagnant([]), false);
+        assert.strictEqual(isStagnant([makeRating(50)]), false);
+        assert.strictEqual(isStagnant([makeRating(50), makeRating(52)]), false);
+    });
+    void it('returns true when 3 ratings with < 3 point improvement', () => {
+        const ratings = [makeRating(80), makeRating(81), makeRating(82)];
+        assert.strictEqual(isStagnant(ratings), true);
+    });
+    void it('returns true when 3 ratings with zero improvement', () => {
+        const ratings = [makeRating(85), makeRating(85), makeRating(85)];
+        assert.strictEqual(isStagnant(ratings), true);
+    });
+    void it('returns false when improvement >= 3 points', () => {
+        // 73 - 70 = 3, and MIN_IMPROVEMENT = 3, so 3 < 3 is false → not stagnant
+        const ratings = [makeRating(70), makeRating(72), makeRating(73)];
+        assert.strictEqual(isStagnant(ratings), false);
+    });
+    void it('returns false when improvement exactly equals threshold', () => {
+        const ratings = [makeRating(70), makeRating(72), makeRating(73)];
+        // improvement = 73 - 70 = 3, MIN_IMPROVEMENT = 3
+        // 3 < 3 is false → not stagnant
+        assert.strictEqual(isStagnant(ratings), false);
+    });
+    void it('returns false when improvement exceeds threshold', () => {
+        const ratings = [makeRating(60), makeRating(65), makeRating(70)];
+        assert.strictEqual(isStagnant(ratings), false);
+    });
+    void it('only looks at last STAGNATION_WINDOW ratings', () => {
+        // Early ratings had big jumps, but last 3 are flat
+        const ratings = [
+            makeRating(30),
+            makeRating(50),
+            makeRating(70),
+            makeRating(71),
+            makeRating(72),
+        ];
+        // Last 3: 70, 71, 72 → improvement = 2 < 3 → stagnant
+        assert.strictEqual(isStagnant(ratings), true);
+    });
+    void it('handles decreasing scores as stagnant', () => {
+        const ratings = [makeRating(80), makeRating(78), makeRating(79)];
+        // improvement = 79 - 80 = -1 < 3 → stagnant
+        assert.strictEqual(isStagnant(ratings), true);
+    });
+});

package/dist/services/coaching/__tests__/self-rating.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/services/coaching/__tests__/self-rating.test.js

@@ -0,0 +1,188 @@
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+import { buildSelfRatingPrompt, getCriteriaForPhase, parseSelfRating, } from '../self-rating.js';
+void describe('getCriteriaForPhase', () => {
+    void it('returns analysis criteria for feature_analysis', () => {
+        const criteria = getCriteriaForPhase('feature_analysis');
+        assert.ok(criteria.includes('coverage'));
+        assert.ok(criteria.includes('clarity'));
+        assert.ok(criteria.includes('completeness'));
+    });
+    void it('returns analysis criteria for user_stories_analysis', () => {
+        const criteria = getCriteriaForPhase('user_stories_analysis');
+        assert.ok(criteria.includes('coverage'));
+    });
+    void it('returns analysis criteria for test_cases_analysis', () => {
+        const criteria = getCriteriaForPhase('test_cases_analysis');
+        assert.ok(criteria.includes('clarity'));
+    });
+    void it('returns design criteria for technical_design', () => {
+        const criteria = getCriteriaForPhase('technical_design');
+        assert.ok(criteria.includes('feasibility'));
+        assert.ok(criteria.includes('scalability'));
+        assert.ok(criteria.includes('maintainability'));
+    });
+    void it('returns design criteria for branch_planning', () => {
+        const criteria = getCriteriaForPhase('branch_planning');
+        assert.ok(criteria.includes('feasibility'));
+    });
+    void it('returns code criteria for code_implementation', () => {
+        const criteria = getCriteriaForPhase('code_implementation');
+        assert.ok(criteria.includes('readability'));
+        assert.ok(criteria.includes('testability'));
+        assert.ok(criteria.includes('performance'));
+        assert.ok(criteria.includes('security'));
+    });
+    void it('returns code criteria for code_refine', () => {
+        const criteria = getCriteriaForPhase('code_refine');
+        assert.ok(criteria.includes('readability'));
+    });
+    void it('returns common criteria for autonomous', () => {
+        const criteria = getCriteriaForPhase('autonomous');
+        assert.ok(criteria.includes('completeness'));
+        assert.ok(criteria.includes('accuracy'));
+        assert.ok(criteria.includes('quality'));
+        assert.ok(criteria.includes('consistency'));
+    });
+    void it('all criteria sets include common criteria', () => {
+        const phases = [
+            'feature_analysis',
+            'technical_design',
+            'code_implementation',
+            'autonomous',
+        ];
+        for (const phase of phases) {
+            const criteria = getCriteriaForPhase(phase);
+            assert.ok(criteria.includes('completeness'), `${phase} missing completeness`);
+            assert.ok(criteria.includes('accuracy'), `${phase} missing accuracy`);
+            assert.ok(criteria.includes('quality'), `${phase} missing quality`);
+            assert.ok(criteria.includes('consistency'), `${phase} missing consistency`);
+        }
+    });
+});
+void describe('buildSelfRatingPrompt', () => {
+    void it('includes phase-specific criteria', () => {
+        const prompt = buildSelfRatingPrompt('technical_design');
+        assert.ok(prompt.includes('"feasibility"'));
+        assert.ok(prompt.includes('"scalability"'));
+        assert.ok(prompt.includes('"maintainability"'));
+    });
+    void it('includes JSON structure template', () => {
+        const prompt = buildSelfRatingPrompt('code_implementation');
+        assert.ok(prompt.includes('"self_rating"'));
+        assert.ok(prompt.includes('"score"'));
+        assert.ok(prompt.includes('"criteria_scores"'));
+        assert.ok(prompt.includes('"strengths"'));
+        assert.ok(prompt.includes('"weaknesses"'));
+    });
+    void it('asks for 0-100 scores', () => {
+        const prompt = buildSelfRatingPrompt('feature_analysis');
+        assert.ok(prompt.includes('0-100'));
+    });
+});
+void describe('parseSelfRating', () => {
+    void it('parses valid JSON in markdown code block', () => {
+        const response = `Here is my self-rating:
+
+\`\`\`json
+{
+  "self_rating": {
+    "score": 85,
+    "summary": "Good coverage but some gaps",
+    "criteria_scores": {
+      "completeness": { "score": 90, "reason": "Covered all cases" },
+      "accuracy": { "score": 80, "reason": "Minor issues" }
+    },
+    "strengths": ["Good structure", "Clear naming"],
+    "weaknesses": ["Missing edge cases"]
+  }
+}
+\`\`\``;
+        const rating = parseSelfRating(response, 'technical_design');
+        assert.ok(rating);
+        assert.strictEqual(rating.score, 85);
+        assert.strictEqual(rating.summary, 'Good coverage but some gaps');
+        assert.strictEqual(rating.criteria_scores.completeness.score, 90);
+        assert.strictEqual(rating.criteria_scores.accuracy.score, 80);
+        assert.deepStrictEqual(rating.strengths, ['Good structure', 'Clear naming']);
+        assert.deepStrictEqual(rating.weaknesses, ['Missing edge cases']);
+    });
+    void it('parses raw JSON without code block', () => {
+        const response = JSON.stringify({
+            self_rating: {
+                score: 72,
+                summary: 'Needs work',
+                criteria_scores: {},
+                strengths: [],
+                weaknesses: ['Poor coverage'],
+            },
+        });
+        const rating = parseSelfRating(response, 'feature_analysis');
+        assert.ok(rating);
+        assert.strictEqual(rating.score, 72);
+        assert.strictEqual(rating.summary, 'Needs work');
+    });
+    void it('rounds score to integer', () => {
+        const response = JSON.stringify({
+            self_rating: {
+                score: 85.7,
+                summary: 'test',
+                criteria_scores: {},
+                strengths: [],
+                weaknesses: [],
+            },
+        });
+        const rating = parseSelfRating(response, 'technical_design');
+        assert.ok(rating);
+        assert.strictEqual(rating.score, 86);
+    });
+    void it('returns null for invalid score above 100', () => {
+        const response = JSON.stringify({
+            self_rating: {
+                score: 150,
+                summary: 'test',
+                criteria_scores: {},
+                strengths: [],
+                weaknesses: [],
+            },
+        });
+        const rating = parseSelfRating(response, 'technical_design');
+        assert.strictEqual(rating, null);
+    });
+    void it('returns null for negative score', () => {
+        const response = JSON.stringify({
+            self_rating: {
+                score: -5,
+                summary: 'test',
+                criteria_scores: {},
+                strengths: [],
+                weaknesses: [],
+            },
+        });
+        const rating = parseSelfRating(response, 'technical_design');
+        assert.strictEqual(rating, null);
+    });
+    void it('returns null for non-JSON response', () => {
+        const rating = parseSelfRating('This is not JSON at all', 'technical_design');
+        assert.strictEqual(rating, null);
+    });
+    void it('returns null for empty response', () => {
+        const rating = parseSelfRating('', 'technical_design');
+        assert.strictEqual(rating, null);
+    });
+    void it('handles missing optional fields gracefully', () => {
+        const response = JSON.stringify({
+            self_rating: {
+                score: 60,
+                criteria_scores: { completeness: { score: 60, reason: 'ok' } },
+            },
+        });
+        const rating = parseSelfRating(response, 'technical_design');
+        assert.ok(rating);
+        assert.strictEqual(rating.score, 60);
+        assert.strictEqual(rating.summary, '');
+        assert.deepStrictEqual(rating.strengths, []);
+        assert.deepStrictEqual(rating.weaknesses, []);
+        assert.strictEqual(rating.criteria_scores.completeness.score, 60);
+    });
+});

package/dist/services/lifecycle-agent/__tests__/phase-criteria.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Unit tests for phase quality criteria definitions
+ */
+export {};

package/dist/services/lifecycle-agent/__tests__/phase-criteria.test.js

@@ -0,0 +1,133 @@
+/**
+ * Unit tests for phase quality criteria definitions
+ */
+import { describe, it } from 'node:test';
+import assert from 'node:assert';
+import { DEFAULT_PHASE_CRITERIA, USER_STORIES_ANALYSIS_CRITERIA, TEST_CASES_ANALYSIS_CRITERIA, TECHNICAL_DESIGN_CRITERIA, BRANCH_PLANNING_CRITERIA, CODE_IMPLEMENTATION_CRITERIA, FUNCTIONAL_TESTING_CRITERIA, CODE_REVIEW_CRITERIA, getPhaseQualityCriteria, } from '../phase-criteria.js';
+describe('Phase Quality Criteria', () => {
+    describe('DEFAULT_PHASE_CRITERIA', () => {
+        it('should cover all evaluable phases', () => {
+            const expectedPhases = [
+                'user_stories_analysis',
+                'test_cases_analysis',
+                'technical_design',
+                'branch_planning',
+                'code_implementation',
+                'functional_testing',
+                'code_review',
+            ];
+            for (const phase of expectedPhases) {
+                assert.ok(phase in DEFAULT_PHASE_CRITERIA, `Should have criteria for phase: ${phase}`);
+            }
+        });
+        it('should have consistent phase names in criteria objects', () => {
+            for (const [key, criteria] of Object.entries(DEFAULT_PHASE_CRITERIA)) {
+                assert.strictEqual(criteria.phase, key, `Criteria for ${key} should have matching phase name`);
+            }
+        });
+    });
+    describe('Criteria Structural Validity', () => {
+        const allCriteria = [
+            USER_STORIES_ANALYSIS_CRITERIA,
+            TEST_CASES_ANALYSIS_CRITERIA,
+            TECHNICAL_DESIGN_CRITERIA,
+            BRANCH_PLANNING_CRITERIA,
+            CODE_IMPLEMENTATION_CRITERIA,
+            FUNCTIONAL_TESTING_CRITERIA,
+            CODE_REVIEW_CRITERIA,
+        ];
+        for (const phaseCriteria of allCriteria) {
+            describe(phaseCriteria.phase, () => {
+                it('should have advanceThreshold > escalateThreshold', () => {
+                    assert.ok(phaseCriteria.advanceThreshold > phaseCriteria.escalateThreshold, `advanceThreshold (${phaseCriteria.advanceThreshold}) should be > escalateThreshold (${phaseCriteria.escalateThreshold})`);
+                });
+                it('should have thresholds in valid range (0-100)', () => {
+                    assert.ok(phaseCriteria.advanceThreshold >= 0);
+                    assert.ok(phaseCriteria.advanceThreshold <= 100);
+                    assert.ok(phaseCriteria.escalateThreshold >= 0);
+                    assert.ok(phaseCriteria.escalateThreshold <= 100);
+                });
+                it('should have maxAutoRetries >= 1', () => {
+                    assert.ok(phaseCriteria.maxAutoRetries >= 1, `maxAutoRetries should be >= 1, got ${phaseCriteria.maxAutoRetries}`);
+                });
+                it('should have at least one criterion', () => {
+                    assert.ok(phaseCriteria.criteria.length > 0, 'Should have at least one criterion');
+                });
+                it('should have criteria weights that approximately sum to 1', () => {
+                    const totalWeight = phaseCriteria.criteria.reduce((sum, c) => sum + c.weight, 0);
+                    assert.ok(Math.abs(totalWeight - 1.0) < 0.01, `Weights should sum to ~1.0, got ${totalWeight}`);
+                });
+                it('should have unique criterion IDs', () => {
+                    const ids = phaseCriteria.criteria.map((c) => c.id);
+                    const uniqueIds = new Set(ids);
+                    assert.strictEqual(ids.length, uniqueIds.size, 'Criterion IDs should be unique');
+                });
+                it('should have valid criterion weights (0 < weight <= 1)', () => {
+                    for (const criterion of phaseCriteria.criteria) {
+                        assert.ok(criterion.weight > 0 && criterion.weight <= 1, `Weight for ${criterion.id} should be between 0 and 1, got ${criterion.weight}`);
+                    }
+                });
+                it('should have valid minimum scores (0-100)', () => {
+                    for (const criterion of phaseCriteria.criteria) {
+                        assert.ok(criterion.minimumScore >= 0 && criterion.minimumScore <= 100, `minimumScore for ${criterion.id} should be 0-100, got ${criterion.minimumScore}`);
+                    }
+                });
+                it('should have non-empty evaluation guidance', () => {
+                    for (const criterion of phaseCriteria.criteria) {
+                        assert.ok(criterion.evaluationGuidance.length > 0, `Criterion ${criterion.id} should have evaluation guidance`);
+                    }
+                });
+            });
+        }
+    });
+    describe('getPhaseQualityCriteria', () => {
+        it('should return default criteria for known phases', () => {
+            const criteria = getPhaseQualityCriteria('user_stories_analysis');
+            assert.ok(criteria);
+            assert.strictEqual(criteria.phase, 'user_stories_analysis');
+            assert.strictEqual(criteria.advanceThreshold, USER_STORIES_ANALYSIS_CRITERIA.advanceThreshold);
+        });
+        it('should return null for unknown phases', () => {
+            const criteria = getPhaseQualityCriteria('nonexistent_phase');
+            assert.strictEqual(criteria, null);
+        });
+        it('should apply overrides when provided', () => {
+            const criteria = getPhaseQualityCriteria('user_stories_analysis', {
+                user_stories_analysis: {
+                    advanceThreshold: 90,
+                    maxAutoRetries: 5,
+                },
+            });
+            assert.ok(criteria);
+            assert.strictEqual(criteria.advanceThreshold, 90);
+            assert.strictEqual(criteria.maxAutoRetries, 5);
+            // Non-overridden values should remain from defaults
+            assert.strictEqual(criteria.escalateThreshold, USER_STORIES_ANALYSIS_CRITERIA.escalateThreshold);
+        });
+        it('should return defaults when override map does not include the phase', () => {
+            const criteria = getPhaseQualityCriteria('technical_design', {
+                user_stories_analysis: { advanceThreshold: 90 },
+            });
+            assert.ok(criteria);
+            assert.strictEqual(criteria.advanceThreshold, TECHNICAL_DESIGN_CRITERIA.advanceThreshold);
+        });
+        it('should override criteria array when provided', () => {
+            const customCriteria = [
+                {
+                    id: 'custom_1',
+                    name: 'Custom',
+                    description: 'A custom criterion',
+                    weight: 1.0,
+                    minimumScore: 50,
+                    evaluationGuidance: 'Custom guidance',
+                },
+            ];
+            const criteria = getPhaseQualityCriteria('technical_design', {
+                technical_design: { criteria: customCriteria },
+            });
+            assert.ok(criteria);
+            assert.strictEqual(criteria.criteria.length, 1);
+            assert.strictEqual(criteria.criteria[0].id, 'custom_1');
+        });
+    });
+});

package/dist/services/lifecycle-agent/__tests__/transition-rules.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Unit tests for lifecycle agent transition rules and decision logic
+ */
+export {};