edsger 0.44.0 → 0.45.1

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

@@ -1,321 +0,0 @@
-import assert from 'node:assert';
-import { describe, it } from 'node:test';
-import { buildHookPrompt, executeHook, parseHookResponse, } from '../hook-executor.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,
-    };
-}
-const defaultSkillFile = {
-    frontmatter: { model: 'sonnet', maxTurns: 10 },
-    body: 'You are a schema validator.',
-};
-function makeContext(overrides = {}) {
-    return {
-        featureId: 'feat-1',
-        phase: 'technical-design',
-        hookPoint: 'after',
-        ...overrides,
-    };
-}
-// ---- buildHookPrompt ----
-void describe('buildHookPrompt', () => {
-    void it('includes feature ID and phase name', () => {
-        const ctx = {
-            featureId: 'feat-123',
-            phase: 'technical-design',
-            hookPoint: 'after',
-        };
-        const prompt = buildHookPrompt(makeBinding(), ctx);
-        assert.ok(prompt.includes('feat-123'));
-        assert.ok(prompt.includes('technical-design'));
-    });
-    void it('includes plugin and skill names', () => {
-        const ctx = {
-            featureId: 'feat-1',
-            phase: 'code-review',
-            hookPoint: 'before',
-        };
-        const prompt = buildHookPrompt(makeBinding(), ctx);
-        assert.ok(prompt.includes('payload-cms'));
-        assert.ok(prompt.includes('validate-schema'));
-    });
-    void it('includes hook point', () => {
-        const ctx = {
-            featureId: 'feat-1',
-            phase: 'code-review',
-            hookPoint: 'before',
-        };
-        const prompt = buildHookPrompt(makeBinding(), ctx);
-        assert.ok(prompt.includes('before'));
-    });
-    void it('includes phase result for after hooks', () => {
-        const ctx = {
-            featureId: 'feat-1',
-            phase: 'technical-design',
-            hookPoint: 'after',
-            phaseResult: { status: 'success', iterations: 3 },
-        };
-        const prompt = buildHookPrompt(makeBinding(), ctx);
-        assert.ok(prompt.includes('Phase Result'));
-        assert.ok(prompt.includes('"iterations": 3'));
-    });
-    void it('does not include phase result for before hooks', () => {
-        const ctx = {
-            featureId: 'feat-1',
-            phase: 'technical-design',
-            hookPoint: 'before',
-        };
-        const prompt = buildHookPrompt(makeBinding(), ctx);
-        assert.ok(!prompt.includes('Phase Result'));
-    });
-    void it('includes error for on_error hooks', () => {
-        const ctx = {
-            featureId: 'feat-1',
-            phase: 'code-implementation',
-            hookPoint: 'on_error',
-            error: new Error('Out of memory'),
-        };
-        const prompt = buildHookPrompt(makeBinding(), ctx);
-        assert.ok(prompt.includes('Phase Error'));
-        assert.ok(prompt.includes('Out of memory'));
-    });
-    void it('includes binding config when present', () => {
-        const binding = makeBinding({
-            config: { severity: 'high', threshold: 0.8 },
-        });
-        const ctx = {
-            featureId: 'feat-1',
-            phase: 'technical-design',
-            hookPoint: 'after',
-        };
-        const prompt = buildHookPrompt(binding, ctx);
-        assert.ok(prompt.includes('Hook Configuration'));
-        assert.ok(prompt.includes('"severity": "high"'));
-    });
-    void it('omits config section when config is empty', () => {
-        const ctx = {
-            featureId: 'feat-1',
-            phase: 'technical-design',
-            hookPoint: 'after',
-        };
-        const prompt = buildHookPrompt(makeBinding(), ctx);
-        assert.ok(!prompt.includes('Hook Configuration'));
-    });
-});
-// ---- parseHookResponse ----
-void describe('parseHookResponse', () => {
-    void it('parses JSON in fenced code block', () => {
-        const text = 'Some text\n```json\n{"status":"success","message":"All good","data":{"count":5}}\n```\nMore text';
-        const result = parseHookResponse(text);
-        assert.strictEqual(result.status, 'success');
-        assert.strictEqual(result.message, 'All good');
-        assert.deepStrictEqual(result.data, { count: 5 });
-    });
-    void it('parses raw JSON text', () => {
-        const text = '{"status":"error","message":"Schema mismatch"}';
-        const result = parseHookResponse(text);
-        assert.strictEqual(result.status, 'error');
-        assert.strictEqual(result.message, 'Schema mismatch');
-    });
-    void it('treats non-JSON text as success', () => {
-        const text = 'Everything looks fine, no issues found.';
-        const result = parseHookResponse(text);
-        assert.strictEqual(result.status, 'success');
-        assert.ok(result.message.includes('Everything looks fine'));
-    });
-    void it('truncates long non-JSON text', () => {
-        const text = 'x'.repeat(1000);
-        const result = parseHookResponse(text);
-        assert.strictEqual(result.message.length, 500);
-    });
-    void it('handles empty text', () => {
-        const result = parseHookResponse('');
-        assert.strictEqual(result.status, 'success');
-        assert.ok(result.message.includes('no structured output'));
-    });
-    void it('handles malformed JSON in code block gracefully', () => {
-        const text = '```json\n{invalid json}\n```';
-        const result = parseHookResponse(text);
-        assert.strictEqual(result.status, 'success');
-    });
-    void it('defaults message when JSON has no message field', () => {
-        const text = '{"status":"success"}';
-        const result = parseHookResponse(text);
-        assert.strictEqual(result.message, 'Hook completed');
-    });
-});
-// ---- executeHook (with injected deps) ----
-void describe('executeHook', () => {
-    /** Create a mock queryFn that yields the given messages */
-    function mockQuery(messages
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    ) {
-        // Return a function that returns an async iterable
-        return () => ({
-            // eslint-disable-next-line @typescript-eslint/require-await
-            async *[Symbol.asyncIterator]() {
-                for (const msg of messages) {
-                    yield msg;
-                }
-            },
-        });
-    }
-    function makeDeps(overrides = {}) {
-        return {
-            loadSkillFile: () => Promise.resolve(defaultSkillFile),
-            queryFn: mockQuery([
-                {
-                    type: 'result',
-                    subtype: 'success',
-                    result: '```json\n{"status":"success","message":"Schema valid"}\n```',
-                },
-            ]),
-            ...overrides,
-        };
-    }
-    void it('returns skipped when skill file not found', async () => {
-        const deps = makeDeps({ loadSkillFile: () => Promise.resolve(null) });
-        const result = await executeHook(makeBinding(), makeContext(), false, deps);
-        assert.strictEqual(result.status, 'skipped');
-        assert.ok(result.message.includes('not found'));
-    });
-    void it('executes successfully with result message from query', async () => {
-        const deps = makeDeps();
-        const result = await executeHook(makeBinding(), makeContext(), false, deps);
-        assert.strictEqual(result.status, 'success');
-        assert.strictEqual(result.message, 'Schema valid');
-        assert.ok(result.duration_ms >= 0);
-        assert.strictEqual(result.hookId, 'hook-1');
-    });
-    void it('returns error status when skill returns error JSON', async () => {
-        const deps = makeDeps({
-            queryFn: mockQuery([
-                {
-                    type: 'result',
-                    subtype: 'success',
-                    result: '{"status":"error","message":"3 issues found"}',
-                },
-            ]),
-        });
-        const result = await executeHook(makeBinding(), makeContext(), false, deps);
-        assert.strictEqual(result.status, 'error');
-        assert.strictEqual(result.message, '3 issues found');
-    });
-    void it('collects text from assistant messages', async () => {
-        const deps = makeDeps({
-            queryFn: mockQuery([
-                {
-                    type: 'assistant',
-                    message: {
-                        content: [{ type: 'text', text: '```json\n{"status":"success",' }],
-                    },
-                },
-                {
-                    type: 'assistant',
-                    message: {
-                        content: [
-                            { type: 'text', text: '"message":"from streaming"}\n```' },
-                        ],
-                    },
-                },
-                { type: 'result', subtype: 'success', result: '' },
-            ]),
-        });
-        const result = await executeHook(makeBinding(), makeContext(), false, deps);
-        assert.strictEqual(result.status, 'success');
-        assert.strictEqual(result.message, 'from streaming');
-    });
-    void it('prefers result message over streamed text', async () => {
-        const deps = makeDeps({
-            queryFn: mockQuery([
-                {
-                    type: 'assistant',
-                    message: { content: [{ type: 'text', text: 'streamed partial' }] },
-                },
-                {
-                    type: 'result',
-                    subtype: 'success',
-                    result: '{"status":"success","message":"final result"}',
-                },
-            ]),
-        });
-        const result = await executeHook(makeBinding(), makeContext(), false, deps);
-        assert.strictEqual(result.message, 'final result');
-    });
-    void it('returns error when query throws', async () => {
-        const deps = makeDeps({
-            queryFn: (() => {
-                throw new Error('Network timeout');
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            }),
-        });
-        const result = await executeHook(makeBinding(), makeContext(), false, deps);
-        assert.strictEqual(result.status, 'error');
-        assert.ok(result.message.includes('Network timeout'));
-    });
-    void it('passes correct model and maxTurns from frontmatter', async () => {
-        let capturedOptions = {};
-        const deps = makeDeps({
-            loadSkillFile: () => Promise.resolve({
-                frontmatter: { model: 'haiku', maxTurns: 5 },
-                body: 'Test prompt',
-            }),
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            queryFn: ((opts) => {
-                capturedOptions = opts.options;
-                return {
-                    // eslint-disable-next-line @typescript-eslint/require-await
-                    async *[Symbol.asyncIterator]() {
-                        yield {
-                            type: 'result',
-                            subtype: 'success',
-                            result: '{"status":"success","message":"ok"}',
-                        };
-                    },
-                };
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            }),
-        });
-        await executeHook(makeBinding(), makeContext(), false, deps);
-        assert.strictEqual(capturedOptions.model, 'haiku');
-        assert.strictEqual(capturedOptions.maxTurns, 5);
-    });
-    void it('uses DEFAULT_MODEL when frontmatter has no model', async () => {
-        let capturedOptions = {};
-        const deps = makeDeps({
-            loadSkillFile: () => Promise.resolve({
-                frontmatter: {},
-                body: 'Test prompt',
-            }),
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            queryFn: ((opts) => {
-                capturedOptions = opts.options;
-                return {
-                    // eslint-disable-next-line @typescript-eslint/require-await
-                    async *[Symbol.asyncIterator]() {
-                        yield {
-                            type: 'result',
-                            subtype: 'success',
-                            result: '{"status":"success","message":"ok"}',
-                        };
-                    },
-                };
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            }),
-        });
-        await executeHook(makeBinding(), makeContext(), false, deps);
-        // DEFAULT_MODEL is 'opus'
-        assert.strictEqual(capturedOptions.model, 'opus');
-    });
-});

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

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

package/dist/services/phase-hooks/__tests__/hook-runner.test.js

@@ -1,261 +0,0 @@
-import assert from 'node:assert';
-import { describe, it } from 'node:test';
-import { runHooksForPhase } from '../hook-runner.js';
-// ---- Helpers ----
-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,
-    };
-}
-function makeResult(binding, overrides = {}) {
-    return {
-        hookId: binding.id,
-        binding,
-        status: 'success',
-        message: 'OK',
-        duration_ms: 100,
-        ...overrides,
-    };
-}
-function makeContext(overrides = {}) {
-    return {
-        featureId: 'feat-1',
-        phase: 'technical-design',
-        hookPoint: 'after',
-        ...overrides,
-    };
-}
-function makeDeps(overrides = {}) {
-    return {
-        executeHook: (binding) => Promise.resolve(makeResult(binding)),
-        getCachedBindings: () => null,
-        getBindingsForPhase: () => [],
-        logHookEvent: () => Promise.resolve(),
-        ...overrides,
-    };
-}
-// ---- Tests ----
-void describe('runHooksForPhase', () => {
-    void it('returns empty results when no cached bindings', async () => {
-        const deps = makeDeps({ getCachedBindings: () => null });
-        const result = await runHooksForPhase(makeContext(), deps);
-        assert.deepStrictEqual(result, { results: [], blocked: false });
-    });
-    void it('returns empty results when cache has empty bindings', async () => {
-        const deps = makeDeps({
-            getCachedBindings: () => ({
-                productId: 'prod-1',
-                bindings: [],
-                fetchedAt: Date.now(),
-            }),
-        });
-        const result = await runHooksForPhase(makeContext(), deps);
-        assert.deepStrictEqual(result, { results: [], blocked: false });
-    });
-    void it('returns empty results when no bindings match the phase', async () => {
-        const cached = {
-            productId: 'prod-1',
-            bindings: [makeBinding({ phase: 'code-review' })],
-            fetchedAt: Date.now(),
-        };
-        const deps = makeDeps({
-            getCachedBindings: () => cached,
-            getBindingsForPhase: () => [], // no match
-        });
-        const result = await runHooksForPhase(makeContext(), deps);
-        assert.deepStrictEqual(result, { results: [], blocked: false });
-    });
-    void it('executes matching hooks and returns results', async () => {
-        const binding = makeBinding();
-        const cached = {
-            productId: 'prod-1',
-            bindings: [binding],
-            fetchedAt: Date.now(),
-        };
-        const executeCalls = [];
-        const deps = makeDeps({
-            getCachedBindings: () => cached,
-            getBindingsForPhase: () => [binding],
-            executeHook: (b) => {
-                executeCalls.push(b);
-                return Promise.resolve(makeResult(b));
-            },
-        });
-        const result = await runHooksForPhase(makeContext(), deps);
-        assert.strictEqual(result.results.length, 1);
-        assert.strictEqual(result.blocked, false);
-        assert.strictEqual(executeCalls.length, 1);
-        assert.strictEqual(executeCalls[0].id, 'hook-1');
-    });
-    void it('executes hooks in order (sequential)', async () => {
-        const b1 = makeBinding({ id: 'first', sort_order: 0 });
-        const b2 = makeBinding({ id: 'second', sort_order: 1 });
-        const cached = {
-            productId: 'prod-1',
-            bindings: [b1, b2],
-            fetchedAt: Date.now(),
-        };
-        const order = [];
-        const deps = makeDeps({
-            getCachedBindings: () => cached,
-            getBindingsForPhase: () => [b1, b2],
-            executeHook: (b) => {
-                order.push(b.id);
-                return Promise.resolve(makeResult(b));
-            },
-        });
-        await runHooksForPhase(makeContext(), deps);
-        assert.deepStrictEqual(order, ['first', 'second']);
-    });
-    void it('blocks on error with on_failure=block', async () => {
-        const b1 = makeBinding({ id: 'blocker', on_failure: 'block' });
-        const b2 = makeBinding({
-            id: 'after-blocker',
-            on_failure: 'block',
-            sort_order: 1,
-        });
-        const cached = {
-            productId: 'prod-1',
-            bindings: [b1, b2],
-            fetchedAt: Date.now(),
-        };
-        const executedIds = [];
-        const deps = makeDeps({
-            getCachedBindings: () => cached,
-            getBindingsForPhase: () => [b1, b2],
-            executeHook: (b) => {
-                executedIds.push(b.id);
-                if (b.id === 'blocker') {
-                    return Promise.resolve(makeResult(b, {
-                        status: 'error',
-                        message: 'Validation failed',
-                    }));
-                }
-                return Promise.resolve(makeResult(b));
-            },
-        });
-        const result = await runHooksForPhase(makeContext(), deps);
-        assert.strictEqual(result.blocked, true);
-        assert.strictEqual(result.results.length, 1); // only the blocker ran
-        assert.strictEqual(result.results[0].status, 'error');
-        assert.deepStrictEqual(executedIds, ['blocker']); // second hook never ran
-    });
-    void it('continues on error with on_failure=warn', async () => {
-        const b1 = makeBinding({ id: 'warner', on_failure: 'warn' });
-        const b2 = makeBinding({
-            id: 'after-warner',
-            on_failure: 'block',
-            sort_order: 1,
-        });
-        const cached = {
-            productId: 'prod-1',
-            bindings: [b1, b2],
-            fetchedAt: Date.now(),
-        };
-        const deps = makeDeps({
-            getCachedBindings: () => cached,
-            getBindingsForPhase: () => [b1, b2],
-            executeHook: (b) => {
-                if (b.id === 'warner') {
-                    return Promise.resolve(makeResult(b, {
-                        status: 'error',
-                        message: 'Non-critical issue',
-                    }));
-                }
-                return Promise.resolve(makeResult(b));
-            },
-        });
-        const result = await runHooksForPhase(makeContext(), deps);
-        assert.strictEqual(result.blocked, false);
-        assert.strictEqual(result.results.length, 2); // both ran
-        assert.strictEqual(result.results[0].status, 'error');
-        assert.strictEqual(result.results[1].status, 'success');
-    });
-    void it('continues silently on error with on_failure=skip', async () => {
-        const b1 = makeBinding({ id: 'skipper', on_failure: 'skip' });
-        const b2 = makeBinding({ id: 'after-skipper', sort_order: 1 });
-        const cached = {
-            productId: 'prod-1',
-            bindings: [b1, b2],
-            fetchedAt: Date.now(),
-        };
-        const deps = makeDeps({
-            getCachedBindings: () => cached,
-            getBindingsForPhase: () => [b1, b2],
-            executeHook: (b) => {
-                if (b.id === 'skipper') {
-                    return Promise.resolve(makeResult(b, { status: 'error', message: 'Ignored' }));
-                }
-                return Promise.resolve(makeResult(b));
-            },
-        });
-        const result = await runHooksForPhase(makeContext(), deps);
-        assert.strictEqual(result.blocked, false);
-        assert.strictEqual(result.results.length, 2);
-    });
-    void it('logs events for each hook execution', async () => {
-        const binding = makeBinding();
-        const cached = {
-            productId: 'prod-1',
-            bindings: [binding],
-            fetchedAt: Date.now(),
-        };
-        const logCalls = [];
-        const deps = makeDeps({
-            getCachedBindings: () => cached,
-            getBindingsForPhase: () => [binding],
-            logHookEvent: ({ result: r }) => {
-                logCalls.push(r.hookId);
-                return Promise.resolve();
-            },
-        });
-        await runHooksForPhase(makeContext(), deps);
-        assert.deepStrictEqual(logCalls, ['hook-1']);
-    });
-    void it('does not block when logHookEvent throws', async () => {
-        const binding = makeBinding();
-        const cached = {
-            productId: 'prod-1',
-            bindings: [binding],
-            fetchedAt: Date.now(),
-        };
-        const deps = makeDeps({
-            getCachedBindings: () => cached,
-            getBindingsForPhase: () => [binding],
-            logHookEvent: () => {
-                return Promise.reject(new Error('Logging failed'));
-            },
-        });
-        const result = await runHooksForPhase(makeContext(), deps);
-        // Should still succeed — logging failure is swallowed
-        assert.strictEqual(result.blocked, false);
-        assert.strictEqual(result.results.length, 1);
-    });
-    void it('handles skipped hooks (file not found) without blocking', async () => {
-        const binding = makeBinding({ on_failure: 'block' });
-        const cached = {
-            productId: 'prod-1',
-            bindings: [binding],
-            fetchedAt: Date.now(),
-        };
-        const deps = makeDeps({
-            getCachedBindings: () => cached,
-            getBindingsForPhase: () => [binding],
-            executeHook: (b) => Promise.resolve(makeResult(b, { status: 'skipped', message: 'Not found' })),
-        });
-        const result = await runHooksForPhase(makeContext(), deps);
-        // 'skipped' is not an error, so on_failure policy should not apply
-        assert.strictEqual(result.blocked, false);
-        assert.strictEqual(result.results[0].status, 'skipped');
-    });
-});

package/dist/services/phase-hooks/__tests__/plugin-loader.test.d.ts

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