@diff-review-system/drs 4.0.0-rc.4 → 4.0.1

package/dist/runtime/client.test.js

@@ -1,772 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { RuntimeClient, createRuntimeClient, createRuntimeClientInstance } from './client.js';
-function createRuntime(sessionOverrides = {}) {
-    return {
-        server: {
-            url: 'pi://in-process',
-            close: vi.fn(),
-        },
-        client: {
-            session: {
-                create: vi.fn(async () => ({ data: { id: 'session-123' } })),
-                prompt: vi.fn(async () => { }),
-                messages: vi.fn(async () => ({ data: [] })),
-                delete: vi.fn(async () => { }),
-                ...sessionOverrides,
-            },
-        },
-    };
-}
-const mocks = vi.hoisted(() => ({
-    createPiInProcessServer: vi.fn(),
-    loadAgents: vi.fn(() => []),
-}));
-vi.mock('../pi/sdk.js', () => ({
-    createPiInProcessServer: mocks.createPiInProcessServer,
-}));
-vi.mock('./agent-loader.js', () => ({
-    loadAgents: mocks.loadAgents,
-}));
-describe('RuntimeClient', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-        vi.spyOn(console, 'log').mockImplementation(() => { });
-        vi.spyOn(console, 'warn').mockImplementation(() => { });
-        mocks.createPiInProcessServer.mockResolvedValue(createRuntime());
-        mocks.loadAgents.mockReturnValue([]);
-    });
-    describe('constructor', () => {
-        it('creates an instance with minimal config', () => {
-            const client = new RuntimeClient({
-                directory: '/test/dir',
-            });
-            expect(client).toBeInstanceOf(RuntimeClient);
-        });
-        it('supports optional model overrides and provider config', () => {
-            const client = new RuntimeClient({
-                modelOverrides: {
-                    'review/security': 'anthropic/claude-opus-4-5-20251101',
-                },
-                provider: {
-                    custom: {
-                        baseUrl: 'https://api.custom.example/v1',
-                        apiKey: 'CUSTOM_API_KEY',
-                        api: 'openai-completions',
-                        models: [
-                            {
-                                id: 'model',
-                                name: 'model',
-                            },
-                        ],
-                    },
-                },
-            });
-            expect(client).toBeInstanceOf(RuntimeClient);
-        });
-    });
-    describe('initialize', () => {
-        it('wires Pi runtime agent prompts and model overrides', async () => {
-            mocks.loadAgents.mockReturnValue([
-                {
-                    id: 'review/security',
-                    namespace: 'review',
-                    name: 'review/security',
-                    path: '/tmp/security.md',
-                    description: 'Security specialist',
-                    prompt: 'Security prompt',
-                    tools: { Read: true },
-                },
-                {
-                    id: 'review/quality',
-                    namespace: 'review',
-                    name: 'review/quality',
-                    path: '/tmp/quality.md',
-                    description: 'Quality specialist',
-                    prompt: 'Quality prompt',
-                },
-            ]);
-            const client = await createRuntimeClientInstance({
-                directory: process.cwd(),
-                config: {
-                    review: {
-                        agents: ['review/security', 'review/quality'],
-                    },
-                    agents: {
-                        default: {
-                            skills: [],
-                        },
-                    },
-                },
-                modelOverrides: {
-                    'review/security': 'anthropic/claude-security',
-                },
-            });
-            expect(mocks.createPiInProcessServer).toHaveBeenCalledWith(expect.objectContaining({
-                config: expect.objectContaining({
-                    agent: expect.objectContaining({
-                        'review/security': expect.objectContaining({
-                            prompt: 'Security prompt',
-                            model: 'anthropic/claude-security',
-                            tools: { Read: true },
-                        }),
-                        'review/quality': expect.objectContaining({
-                            prompt: 'Quality prompt',
-                        }),
-                    }),
-                }),
-            }));
-            await client.shutdown();
-        });
-        it('passes skill search paths and agent skill configuration to Pi runtime', async () => {
-            const projectRoot = process.cwd();
-            const config = {
-                agents: {
-                    default: {
-                        skills: ['baseline-review'],
-                    },
-                },
-                review: {
-                    agents: [
-                        {
-                            name: 'review/security',
-                            skills: ['security-audit'],
-                        },
-                    ],
-                },
-            };
-            mocks.loadAgents.mockReturnValueOnce([
-                {
-                    id: 'review/security',
-                    namespace: 'review',
-                    name: 'security',
-                    path: '/tmp/security.md',
-                    description: 'Security agent',
-                },
-            ]);
-            const client = await createRuntimeClientInstance({
-                directory: projectRoot,
-                config,
-            });
-            expect(mocks.createPiInProcessServer).toHaveBeenCalledWith(expect.objectContaining({
-                config: expect.objectContaining({
-                    skillSearchPaths: expect.any(Array),
-                    agentSkills: {
-                        'review/security': ['baseline-review', 'security-audit'],
-                    },
-                }),
-            }));
-            await client.shutdown();
-        });
-        it('includes unified reviewer in skill configuration when configured', async () => {
-            const config = {
-                agents: {
-                    default: {
-                        skills: ['cli-testing'],
-                    },
-                },
-                review: {
-                    agents: ['review/unified-reviewer'],
-                },
-            };
-            mocks.loadAgents.mockReturnValueOnce([
-                {
-                    id: 'review/unified-reviewer',
-                    namespace: 'review',
-                    name: 'unified-reviewer',
-                    path: '/tmp/unified-reviewer.md',
-                    description: 'Unified agent',
-                },
-            ]);
-            const client = await createRuntimeClientInstance({
-                directory: process.cwd(),
-                config,
-            });
-            expect(mocks.createPiInProcessServer).toHaveBeenCalledWith(expect.objectContaining({
-                config: expect.objectContaining({
-                    agentSkills: expect.objectContaining({
-                        'review/unified-reviewer': ['cli-testing'],
-                    }),
-                }),
-            }));
-            await client.shutdown();
-        });
-        it('applies generic default skills to non-review agents', async () => {
-            const config = {
-                agents: {
-                    default: {
-                        skills: ['generic-skill'],
-                    },
-                },
-                review: {
-                    agents: ['review/security'],
-                },
-            };
-            mocks.loadAgents.mockReturnValueOnce([
-                {
-                    id: 'review/security',
-                    namespace: 'review',
-                    name: 'security',
-                    path: '/tmp/security.md',
-                    description: 'Security agent',
-                },
-                {
-                    id: 'describe/pr-describer',
-                    namespace: 'describe',
-                    name: 'pr-describer',
-                    path: '/tmp/pr-describer.md',
-                    description: 'Description agent',
-                },
-            ]);
-            const client = await createRuntimeClientInstance({
-                directory: process.cwd(),
-                config,
-            });
-            expect(mocks.createPiInProcessServer).toHaveBeenCalledWith(expect.objectContaining({
-                config: expect.objectContaining({
-                    agentSkills: expect.objectContaining({
-                        'describe/pr-describer': ['generic-skill'],
-                    }),
-                }),
-            }));
-            await client.shutdown();
-        });
-        it('applies generic model defaults, namespaces, and overrides to all loaded agents', async () => {
-            const config = {
-                agents: {
-                    default: {
-                        model: 'provider/default-model',
-                        skills: [],
-                    },
-                    namespaces: {
-                        task: {
-                            model: 'provider/task-model',
-                        },
-                    },
-                    overrides: {
-                        'task/specialist': {
-                            model: 'provider/specialist-override',
-                        },
-                    },
-                },
-                review: {
-                    agents: [],
-                },
-            };
-            mocks.loadAgents.mockReturnValueOnce([
-                {
-                    id: 'task/docs-updater',
-                    namespace: 'task',
-                    name: 'docs-updater',
-                    path: '/tmp/docs-updater.md',
-                    description: 'Docs updater',
-                },
-                {
-                    id: 'task/specialist',
-                    namespace: 'task',
-                    name: 'specialist',
-                    path: '/tmp/specialist.md',
-                    description: 'Specialist',
-                    model: 'provider/frontmatter-model',
-                },
-                {
-                    id: 'ops/deploy',
-                    namespace: 'ops',
-                    name: 'deploy',
-                    path: '/tmp/deploy.md',
-                    description: 'Deploy helper',
-                },
-            ]);
-            const client = await createRuntimeClientInstance({
-                directory: process.cwd(),
-                config,
-            });
-            expect(mocks.createPiInProcessServer).toHaveBeenCalledWith(expect.objectContaining({
-                config: expect.objectContaining({
-                    agent: expect.objectContaining({
-                        'task/docs-updater': expect.objectContaining({
-                            model: 'provider/task-model',
-                        }),
-                        'task/specialist': expect.objectContaining({
-                            model: 'provider/specialist-override',
-                        }),
-                        'ops/deploy': expect.objectContaining({
-                            model: 'provider/default-model',
-                        }),
-                    }),
-                }),
-            }));
-            await client.shutdown();
-        });
-        it('passes per-agent tool overrides to Pi runtime config', async () => {
-            mocks.loadAgents.mockReturnValue([
-                {
-                    id: 'review/security',
-                    namespace: 'review',
-                    name: 'review/security',
-                    path: '/tmp/security.md',
-                    description: 'Security agent',
-                    prompt: 'Security prompt',
-                    tools: { Read: true, Bash: false, Edit: true },
-                },
-                {
-                    id: 'review/quality',
-                    namespace: 'review',
-                    name: 'review/quality',
-                    path: '/tmp/quality.md',
-                    description: 'Quality agent',
-                    prompt: 'Quality prompt',
-                    // No tools override — uses global defaults
-                },
-            ]);
-            const client = await createRuntimeClientInstance({
-                directory: process.cwd(),
-                config: {
-                    review: {
-                        agents: ['review/security', 'review/quality'],
-                    },
-                    agents: {
-                        default: { skills: [] },
-                    },
-                },
-            });
-            expect(mocks.createPiInProcessServer).toHaveBeenCalledWith(expect.objectContaining({
-                config: expect.objectContaining({
-                    agent: expect.objectContaining({
-                        'review/security': expect.objectContaining({
-                            tools: { Read: true, Bash: false, Edit: true },
-                        }),
-                        'review/quality': expect.not.objectContaining({
-                            tools: expect.anything(),
-                        }),
-                    }),
-                }),
-            }));
-            await client.shutdown();
-        });
-        it('passes provider and model headers through to Pi runtime config', async () => {
-            const client = await createRuntimeClientInstance({
-                directory: process.cwd(),
-                provider: {
-                    custom: {
-                        baseUrl: 'https://api.custom.example/v1',
-                        apiKey: 'CUSTOM_API_KEY',
-                        api: 'openai-completions',
-                        headers: {
-                            'X-Provider-Header': 'provider-value',
-                        },
-                        models: [
-                            {
-                                id: 'custom-model',
-                                headers: {
-                                    'X-Model-Header': 'model-value',
-                                },
-                            },
-                        ],
-                    },
-                },
-            });
-            expect(mocks.createPiInProcessServer).toHaveBeenCalledWith(expect.objectContaining({
-                config: expect.objectContaining({
-                    provider: expect.objectContaining({
-                        custom: expect.objectContaining({
-                            headers: {
-                                'X-Provider-Header': 'provider-value',
-                            },
-                            models: [
-                                expect.objectContaining({
-                                    id: 'custom-model',
-                                    headers: {
-                                        'X-Model-Header': 'model-value',
-                                    },
-                                }),
-                            ],
-                        }),
-                    }),
-                }),
-            }));
-            await client.shutdown();
-        });
-        it('passes configured provider retry settings to Pi runtime config', async () => {
-            const client = await createRuntimeClientInstance({
-                directory: process.cwd(),
-                providerRetry: {
-                    timeoutMs: 45000,
-                    maxRetries: 2,
-                    maxRetryDelayMs: 15000,
-                },
-            });
-            expect(mocks.createPiInProcessServer).toHaveBeenCalledWith(expect.objectContaining({
-                config: expect.objectContaining({
-                    retry: {
-                        provider: {
-                            timeoutMs: 45000,
-                            maxRetries: 2,
-                            maxRetryDelayMs: 15000,
-                        },
-                    },
-                }),
-            }));
-            await client.shutdown();
-        });
-    });
-    describe('createSession', () => {
-        it('throws error if not initialized', async () => {
-            const client = new RuntimeClient({});
-            await expect(client.createSession({
-                agent: 'review/security',
-                message: 'Review this code',
-            })).rejects.toThrow('Runtime client not initialized');
-        });
-        it('maps authentication errors to actionable messages', async () => {
-            mocks.createPiInProcessServer.mockResolvedValueOnce(createRuntime({
-                create: vi.fn(async () => {
-                    throw new Error('401 Unauthorized');
-                }),
-            }));
-            const client = await createRuntimeClientInstance({
-                directory: process.cwd(),
-            });
-            await expect(client.createSession({
-                agent: 'review/security',
-                message: 'Review this code',
-            })).rejects.toThrow('Authentication failed with the configured model provider');
-        });
-        it('maps model resolution errors to actionable messages', async () => {
-            mocks.createPiInProcessServer.mockResolvedValueOnce(createRuntime({
-                create: vi.fn(async () => {
-                    throw new Error('Failed to resolve model "anthropic/does-not-exist"');
-                }),
-            }));
-            const client = await createRuntimeClientInstance({
-                directory: process.cwd(),
-            });
-            await expect(client.createSession({
-                agent: 'review/security',
-                message: 'Review this code',
-            })).rejects.toThrow('Model configuration is invalid or unavailable');
-        });
-        it('includes local-runtime hint when connectivity errors occur', async () => {
-            mocks.createPiInProcessServer.mockResolvedValueOnce(createRuntime({
-                create: vi.fn(async () => {
-                    throw new Error('fetch failed');
-                }),
-            }));
-            const client = await createRuntimeClientInstance({
-                directory: process.cwd(),
-            });
-            await expect(client.createSession({
-                agent: 'review/security',
-                message: 'Review this code',
-            })).rejects.toThrow('Verify local Pi runtime setup and model provider connectivity');
-        });
-        it('fails fast when session creation hangs', async () => {
-            mocks.createPiInProcessServer.mockResolvedValueOnce(createRuntime({
-                create: vi.fn(() => new Promise(() => { })),
-            }));
-            const client = await createRuntimeClientInstance({
-                directory: process.cwd(),
-                operationTimeoutMs: 25,
-            });
-            await expect(client.createSession({
-                agent: 'review/security',
-                message: 'Review this code',
-            })).rejects.toThrow('Create session timed out');
-        });
-    });
-    describe('lifecycle and helper methods', () => {
-        it('streamMessages throws if not initialized', async () => {
-            const client = new RuntimeClient({});
-            const generator = client.streamMessages('session-123');
-            await expect(generator.next()).rejects.toThrow('Runtime client not initialized');
-        });
-        it('applies configured model pricing when runtime cost is missing or zero', async () => {
-            const runtimeMessages = [
-                {
-                    info: {
-                        id: 'msg-1',
-                        role: 'assistant',
-                        time: { completed: Date.now() },
-                        provider: 'opencode',
-                        model: 'glm-5-free',
-                        usage: {
-                            input: 1000,
-                            output: 100,
-                            cacheRead: 0,
-                            cacheWrite: 0,
-                            totalTokens: 1100,
-                        },
-                    },
-                    parts: [{ text: 'done' }],
-                },
-            ];
-            mocks.createPiInProcessServer.mockResolvedValueOnce(createRuntime({
-                messages: vi.fn(async () => ({ data: runtimeMessages })),
-            }));
-            const client = await createRuntimeClientInstance({
-                directory: process.cwd(),
-                config: {
-                    review: {
-                        agents: [],
-                    },
-                    agents: {
-                        default: {
-                            skills: [],
-                        },
-                    },
-                    pricing: {
-                        models: {
-                            'opencode/glm-5-free': {
-                                input: 2,
-                                output: 8,
-                            },
-                        },
-                    },
-                },
-            });
-            const collected = [];
-            for await (const message of client.streamMessages('session-123')) {
-                collected.push(message);
-            }
-            expect(collected).toHaveLength(1);
-            expect(collected[0].usage?.cost).toBeCloseTo(0.0028, 10);
-            await client.shutdown();
-        });
-        it('fails fast when message polling exceeds stream timeout', async () => {
-            const runtimeMessages = [
-                {
-                    info: {
-                        id: 'msg-1',
-                        role: 'assistant',
-                    },
-                    parts: [{ text: 'still running' }],
-                },
-            ];
-            mocks.createPiInProcessServer.mockResolvedValueOnce(createRuntime({
-                messages: vi.fn(async () => ({ data: runtimeMessages })),
-            }));
-            const client = await createRuntimeClientInstance({
-                directory: process.cwd(),
-                streamTimeoutMs: 30,
-                streamPollIntervalMs: 10,
-            });
-            const collect = async () => {
-                const collected = [];
-                for await (const message of client.streamMessages('session-123')) {
-                    collected.push(message);
-                }
-                return collected;
-            };
-            await expect(collect()).rejects.toThrow('Session session-123 timed out');
-            await client.shutdown();
-        });
-        it('prefers env timeout overrides over constructor values', async () => {
-            const previousOpTimeout = process.env.DRS_RUNTIME_OPERATION_TIMEOUT_MS;
-            const previousStreamTimeout = process.env.DRS_RUNTIME_STREAM_TIMEOUT_MS;
-            const previousPollInterval = process.env.DRS_RUNTIME_STREAM_POLL_INTERVAL_MS;
-            process.env.DRS_RUNTIME_OPERATION_TIMEOUT_MS = '10';
-            process.env.DRS_RUNTIME_STREAM_TIMEOUT_MS = '30';
-            process.env.DRS_RUNTIME_STREAM_POLL_INTERVAL_MS = '10';
-            try {
-                mocks.createPiInProcessServer.mockResolvedValueOnce(createRuntime({
-                    create: vi.fn(() => new Promise(() => { })),
-                }));
-                const client = await createRuntimeClientInstance({
-                    directory: process.cwd(),
-                    operationTimeoutMs: 1000,
-                    streamTimeoutMs: 1000,
-                    streamPollIntervalMs: 1000,
-                });
-                await expect(client.createSession({
-                    agent: 'review/security',
-                    message: 'Review this code',
-                })).rejects.toThrow('Create session timed out');
-                await client.shutdown();
-            }
-            finally {
-                if (previousOpTimeout === undefined) {
-                    delete process.env.DRS_RUNTIME_OPERATION_TIMEOUT_MS;
-                }
-                else {
-                    process.env.DRS_RUNTIME_OPERATION_TIMEOUT_MS = previousOpTimeout;
-                }
-                if (previousStreamTimeout === undefined) {
-                    delete process.env.DRS_RUNTIME_STREAM_TIMEOUT_MS;
-                }
-                else {
-                    process.env.DRS_RUNTIME_STREAM_TIMEOUT_MS = previousStreamTimeout;
-                }
-                if (previousPollInterval === undefined) {
-                    delete process.env.DRS_RUNTIME_STREAM_POLL_INTERVAL_MS;
-                }
-                else {
-                    process.env.DRS_RUNTIME_STREAM_POLL_INTERVAL_MS = previousPollInterval;
-                }
-            }
-        });
-        it('closeSession throws if not initialized', async () => {
-            const client = new RuntimeClient({});
-            await expect(client.closeSession('session-123')).rejects.toThrow('Runtime client not initialized');
-        });
-        it('getServerUrl throws when server is not initialized', () => {
-            const client = new RuntimeClient({});
-            expect(() => client.getServerUrl()).toThrow('Server not initialized');
-        });
-        it('shutdown does not throw when no runtime is active', async () => {
-            const client = new RuntimeClient({});
-            await expect(client.shutdown()).resolves.toBeUndefined();
-        });
-    });
-    describe('environment variable resolution', () => {
-        it('resolves provider apiKey env references before runtime init', async () => {
-            const originalEnv = process.env.TEST_API_KEY;
-            process.env.TEST_API_KEY = 'test-key-123';
-            try {
-                const client = await createRuntimeClientInstance({
-                    directory: process.cwd(),
-                    provider: {
-                        'test-provider': {
-                            baseUrl: 'https://api.test.com/v1',
-                            apiKey: '{env:TEST_API_KEY}',
-                            api: 'openai-completions',
-                            models: [
-                                {
-                                    id: 'test-model',
-                                },
-                            ],
-                        },
-                    },
-                });
-                expect(mocks.createPiInProcessServer).toHaveBeenCalledWith(expect.objectContaining({
-                    config: expect.objectContaining({
-                        provider: expect.objectContaining({
-                            'test-provider': expect.objectContaining({
-                                apiKey: 'test-key-123',
-                            }),
-                        }),
-                    }),
-                }));
-                await client.shutdown();
-            }
-            finally {
-                if (originalEnv === undefined) {
-                    delete process.env.TEST_API_KEY;
-                }
-                else {
-                    process.env.TEST_API_KEY = originalEnv;
-                }
-            }
-        });
-        it('resolves env references inside provider and model headers', async () => {
-            const originalProviderHeaderEnv = process.env.TEST_PROVIDER_HEADER;
-            const originalModelHeaderEnv = process.env.TEST_MODEL_HEADER;
-            process.env.TEST_PROVIDER_HEADER = 'provider-header-value';
-            process.env.TEST_MODEL_HEADER = 'model-header-value';
-            try {
-                const client = await createRuntimeClientInstance({
-                    directory: process.cwd(),
-                    provider: {
-                        'test-provider': {
-                            baseUrl: 'https://api.test.com/v1',
-                            apiKey: 'TEST_API_KEY',
-                            api: 'openai-completions',
-                            headers: {
-                                'X-Provider-Header': '{env:TEST_PROVIDER_HEADER}',
-                            },
-                            models: [
-                                {
-                                    id: 'test-model',
-                                    headers: {
-                                        'X-Model-Header': '{env:TEST_MODEL_HEADER}',
-                                    },
-                                },
-                            ],
-                        },
-                    },
-                });
-                expect(mocks.createPiInProcessServer).toHaveBeenCalledWith(expect.objectContaining({
-                    config: expect.objectContaining({
-                        provider: expect.objectContaining({
-                            'test-provider': expect.objectContaining({
-                                headers: {
-                                    'X-Provider-Header': 'provider-header-value',
-                                },
-                                models: [
-                                    expect.objectContaining({
-                                        id: 'test-model',
-                                        headers: {
-                                            'X-Model-Header': 'model-header-value',
-                                        },
-                                    }),
-                                ],
-                            }),
-                        }),
-                    }),
-                }));
-                await client.shutdown();
-            }
-            finally {
-                if (originalProviderHeaderEnv === undefined) {
-                    delete process.env.TEST_PROVIDER_HEADER;
-                }
-                else {
-                    process.env.TEST_PROVIDER_HEADER = originalProviderHeaderEnv;
-                }
-                if (originalModelHeaderEnv === undefined) {
-                    delete process.env.TEST_MODEL_HEADER;
-                }
-                else {
-                    process.env.TEST_MODEL_HEADER = originalModelHeaderEnv;
-                }
-            }
-        });
-        it('warns when referenced environment variables are missing', async () => {
-            const logSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
-            const originalEnv = process.env.NONEXISTENT_VAR;
-            delete process.env.NONEXISTENT_VAR;
-            try {
-                const client = await createRuntimeClientInstance({
-                    directory: process.cwd(),
-                    provider: {
-                        'test-provider': {
-                            baseUrl: 'https://api.test.com/v1',
-                            apiKey: '{env:NONEXISTENT_VAR}',
-                            api: 'openai-completions',
-                            models: [
-                                {
-                                    id: 'test-model',
-                                },
-                            ],
-                        },
-                    },
-                });
-                // Logger outputs warning via console.log (human format)
-                const allOutput = logSpy.mock.calls.map((c) => String(c[0])).join('\n');
-                expect(allOutput).toContain('NONEXISTENT_VAR is not set');
-                await client.shutdown();
-            }
-            finally {
-                logSpy.mockRestore();
-                if (originalEnv !== undefined) {
-                    process.env.NONEXISTENT_VAR = originalEnv;
-                }
-            }
-        });
-    });
-    describe('factory functions', () => {
-        it('createRuntimeClient returns an uninitialized client instance', () => {
-            const client = createRuntimeClient({
-                directory: process.cwd(),
-            });
-            expect(client).toBeInstanceOf(RuntimeClient);
-        });
-        it('createRuntimeClientInstance initializes in-process runtime', async () => {
-            const client = await createRuntimeClientInstance({
-                directory: process.cwd(),
-            });
-            expect(client).toBeInstanceOf(RuntimeClient);
-            expect(mocks.createPiInProcessServer).toHaveBeenCalled();
-            await client.shutdown();
-        });
-    });
-});
-//# sourceMappingURL=client.test.js.map