edsger 0.45.0 → 0.45.1

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

@@ -1,74 +0,0 @@
-import assert from 'node:assert';
-import { describe, it } from 'node:test';
-import { buildImprovementPrompt, } from '../coaching-agent.js';
-void describe('buildImprovementPrompt', () => {
-    const decision = {
-        shouldContinue: true,
-        reasoning: 'Completeness is weak, needs more coverage',
-        focusAreas: ['completeness', 'accuracy'],
-        suggestions: [
-            'Add error handling section',
-            'Include database migration plan',
-        ],
-    };
-    const rating = {
-        score: 72,
-        summary: 'Decent but incomplete',
-        criteria_scores: {
-            completeness: { score: 60, reason: 'Missing sections' },
-            accuracy: { score: 75, reason: 'Minor issues' },
-            quality: { score: 82, reason: 'Good structure' },
-        },
-        strengths: ['Clean structure'],
-        weaknesses: ['Missing error handling', 'No migration plan'],
-    };
-    void it('includes current score and target', () => {
-        const prompt = buildImprovementPrompt(decision, rating);
-        assert.ok(prompt.includes('72/100'));
-        assert.ok(prompt.includes('100/100'));
-    });
-    void it('includes coaching reasoning', () => {
-        const prompt = buildImprovementPrompt(decision, rating);
-        assert.ok(prompt.includes('Completeness is weak, needs more coverage'));
-    });
-    void it('includes focus areas with scores', () => {
-        const prompt = buildImprovementPrompt(decision, rating);
-        assert.ok(prompt.includes('completeness'));
-        assert.ok(prompt.includes('60/100'));
-        assert.ok(prompt.includes('accuracy'));
-        assert.ok(prompt.includes('75/100'));
-    });
-    void it('includes specific suggestions', () => {
-        const prompt = buildImprovementPrompt(decision, rating);
-        assert.ok(prompt.includes('Add error handling section'));
-        assert.ok(prompt.includes('Include database migration plan'));
-    });
-    void it('includes weaknesses to address', () => {
-        const prompt = buildImprovementPrompt(decision, rating);
-        assert.ok(prompt.includes('Missing error handling'));
-        assert.ok(prompt.includes('No migration plan'));
-    });
-    void it('handles empty focus areas gracefully', () => {
-        const emptyDecision = {
-            shouldContinue: true,
-            reasoning: 'General improvement needed',
-            focusAreas: [],
-            suggestions: ['Improve overall'],
-        };
-        const prompt = buildImprovementPrompt(emptyDecision, rating);
-        assert.ok(prompt.includes('General improvement needed'));
-        assert.ok(prompt.includes('Improve overall'));
-    });
-    void it('handles focus areas not present in criteria_scores', () => {
-        const decisionWithUnknown = {
-            shouldContinue: true,
-            reasoning: 'test',
-            focusAreas: ['nonexistent_criterion'],
-            suggestions: ['test'],
-        };
-        const prompt = buildImprovementPrompt(decisionWithUnknown, rating);
-        // Should not crash, should show '?' for missing score
-        assert.ok(prompt.includes('nonexistent_criterion'));
-        assert.ok(prompt.includes('?/100'));
-    });
-});

package/dist/services/coaching/__tests__/coaching-loop.test.d.ts

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

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

@@ -1,59 +0,0 @@
-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

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

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

@@ -1,188 +0,0 @@
-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/phase-hooks/__tests__/bindings-fetcher.test.d.ts

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

package/dist/services/phase-hooks/__tests__/bindings-fetcher.test.js

@@ -1,122 +0,0 @@
-import assert from 'node:assert';
-import { afterEach, describe, it } from 'node:test';
-import { cacheBindings, clearBindingsCache, getBindingsForPhase, getCachedBindings, } from '../bindings-fetcher.js';
-function makeBinding(overrides = {}) {
-    return {
-        id: 'hook-1',
-        product_id: 'prod-1',
-        phase: 'technical-design',
-        hook_point: 'after',
-        plugin_name: 'payload-cms',
-        skill_name: 'validate-schema',
-        on_failure: 'block',
-        config: {},
-        sort_order: 0,
-        enabled: true,
-        ...overrides,
-    };
-}
-// ---- getBindingsForPhase ----
-void describe('getBindingsForPhase', () => {
-    void it('filters by exact phase match', () => {
-        const bindings = [
-            makeBinding({ phase: 'technical-design', hook_point: 'after' }),
-            makeBinding({
-                id: '2',
-                phase: 'code-implementation',
-                hook_point: 'after',
-            }),
-        ];
-        const result = getBindingsForPhase(bindings, 'technical-design', 'after');
-        assert.strictEqual(result.length, 1);
-        assert.strictEqual(result[0].phase, 'technical-design');
-    });
-    void it('matches wildcard phase "*"', () => {
-        const bindings = [
-            makeBinding({ phase: '*', hook_point: 'after', skill_name: 'notify' }),
-        ];
-        const result = getBindingsForPhase(bindings, 'code-review', 'after');
-        assert.strictEqual(result.length, 1);
-        assert.strictEqual(result[0].skill_name, 'notify');
-    });
-    void it('combines exact match and wildcard', () => {
-        const bindings = [
-            makeBinding({
-                id: '1',
-                phase: 'technical-design',
-                hook_point: 'after',
-                sort_order: 1,
-            }),
-            makeBinding({ id: '2', phase: '*', hook_point: 'after', sort_order: 0 }),
-        ];
-        const result = getBindingsForPhase(bindings, 'technical-design', 'after');
-        assert.strictEqual(result.length, 2);
-        // Wildcard (sort_order 0) comes first
-        assert.strictEqual(result[0].id, '2');
-        assert.strictEqual(result[1].id, '1');
-    });
-    void it('filters by hook_point', () => {
-        const bindings = [
-            makeBinding({ hook_point: 'before' }),
-            makeBinding({ id: '2', hook_point: 'after' }),
-        ];
-        const result = getBindingsForPhase(bindings, 'technical-design', 'before');
-        assert.strictEqual(result.length, 1);
-        assert.strictEqual(result[0].hook_point, 'before');
-    });
-    void it('excludes disabled bindings', () => {
-        const bindings = [makeBinding({ enabled: false })];
-        const result = getBindingsForPhase(bindings, 'technical-design', 'after');
-        assert.strictEqual(result.length, 0);
-    });
-    void it('sorts by sort_order ascending', () => {
-        const bindings = [
-            makeBinding({ id: 'c', sort_order: 10 }),
-            makeBinding({ id: 'a', sort_order: 1 }),
-            makeBinding({ id: 'b', sort_order: 5 }),
-        ];
-        const result = getBindingsForPhase(bindings, 'technical-design', 'after');
-        assert.deepStrictEqual(result.map((b) => b.id), ['a', 'b', 'c']);
-    });
-    void it('returns empty array when no bindings match', () => {
-        const bindings = [
-            makeBinding({ phase: 'code-review', hook_point: 'before' }),
-        ];
-        const result = getBindingsForPhase(bindings, 'technical-design', 'after');
-        assert.strictEqual(result.length, 0);
-    });
-    void it('handles on_error hook point', () => {
-        const bindings = [makeBinding({ hook_point: 'on_error' })];
-        const result = getBindingsForPhase(bindings, 'technical-design', 'on_error');
-        assert.strictEqual(result.length, 1);
-    });
-});
-// ---- Cache management ----
-void describe('bindings cache', () => {
-    afterEach(() => {
-        clearBindingsCache('test-feature-1');
-        clearBindingsCache('test-feature-2');
-    });
-    void it('returns null for uncached feature', () => {
-        assert.strictEqual(getCachedBindings('nonexistent'), null);
-    });
-    void it('round-trips cache/get/clear', () => {
-        const bindings = [makeBinding()];
-        cacheBindings('test-feature-1', 'prod-1', bindings);
-        const cached = getCachedBindings('test-feature-1');
-        assert.ok(cached);
-        assert.strictEqual(cached.productId, 'prod-1');
-        assert.strictEqual(cached.bindings.length, 1);
-        assert.ok(cached.fetchedAt > 0);
-        clearBindingsCache('test-feature-1');
-        assert.strictEqual(getCachedBindings('test-feature-1'), null);
-    });
-    void it('isolates cache by featureId', () => {
-        cacheBindings('test-feature-1', 'prod-1', [makeBinding({ id: 'a' })]);
-        cacheBindings('test-feature-2', 'prod-2', [makeBinding({ id: 'b' })]);
-        const cached1 = getCachedBindings('test-feature-1');
-        const cached2 = getCachedBindings('test-feature-2');
-        assert.strictEqual(cached1?.bindings[0].id, 'a');
-        assert.strictEqual(cached2?.bindings[0].id, 'b');
-    });
-});

package/dist/services/phase-hooks/__tests__/hook-executor.test.d.ts

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