opencode-morphllm 0.0.7 → 0.0.9

package/dist/morph/router.test.js

@@ -1,239 +0,0 @@
-import { describe, it, expect, vi } from 'bun:test';
-vi.mock('@morphllm/morphsdk', () => ({
-    MorphClient: vi.fn().mockImplementation(() => ({
-        routers: {
-            raw: {
-                classify: vi.fn(),
-            },
-        },
-    })),
-}));
-vi.mock('../shared/config', () => ({
-    API_KEY: 'sk-test-api-key-123',
-    MORPH_MODEL_EASY: 'easy/easy',
-    MORPH_MODEL_MEDIUM: 'medium/medium',
-    MORPH_MODEL_HARD: 'hard/hard',
-    MORPH_MODEL_DEFAULT: 'default/default',
-    MORPH_ROUTER_PROMPT_CACHING_AWARE: false,
-    MORPH_ROUTER_ENABLED: true,
-}));
-import { createModelRouterHook, extractPromptText } from './router';
-describe('router.ts', () => {
-    describe('extractPromptText', () => {
-        it('should extract text from parts', () => {
-            const parts = [
-                { type: 'text', text: 'Hello' },
-                { type: 'text', text: 'World' },
-            ];
-            expect(extractPromptText(parts)).toBe('Hello World');
-        });
-        it('should handle empty parts', () => {
-            const parts = [];
-            expect(extractPromptText(parts)).toBe('');
-        });
-        it('should filter out non-text parts', () => {
-            const parts = [
-                { type: 'text', text: 'Hello' },
-                { type: 'other', text: 'Ignore' },
-                { type: 'text', text: 'World' },
-            ];
-            expect(extractPromptText(parts)).toBe('Hello World');
-        });
-        it('should handle parts with no text', () => {
-            const parts = [
-                { type: 'text', text: 'Hello' },
-                { type: 'text' },
-                { type: 'text', text: 'World' },
-            ];
-            expect(extractPromptText(parts)).toBe('Hello  World');
-        });
-        it('should handle all non-text parts', () => {
-            const parts = [
-                { type: 'image', data: 'base64...' },
-                { type: 'tool_use', name: 'bash' },
-            ];
-            expect(extractPromptText(parts)).toBe('');
-        });
-    });
-    describe('createModelRouterHook', () => {
-        it('should return a chat.message hook', () => {
-            const hook = createModelRouterHook();
-            expect('chat.message' in hook).toBe(true);
-            expect(typeof hook['chat.message']).toBe('function');
-        });
-        it('should call the classifier with the correct input', async () => {
-            const hook = createModelRouterHook();
-            const classify = vi.fn().mockResolvedValue({ difficulty: 'easy' });
-            const input = {
-                sessionID: '123',
-                classify,
-            };
-            const output = {
-                message: {},
-                parts: [{ type: 'text', text: 'test prompt' }],
-            };
-            await hook['chat.message'](input, output);
-            expect(classify).toHaveBeenCalledWith({ input: 'test prompt' });
-        });
-        it('should assign the correct model based on difficulty', async () => {
-            const hook = createModelRouterHook();
-            const classify = vi.fn().mockResolvedValue({ difficulty: 'hard' });
-            const input = {
-                sessionID: '123',
-                classify,
-            };
-            const output = {
-                message: {},
-                parts: [{ type: 'text', text: 'test prompt' }],
-            };
-            await hook['chat.message'](input, output);
-            expect(input).toHaveProperty('model');
-            expect(input.model.providerID).toBe('hard');
-            expect(input.model.modelID).toBe('hard');
-        });
-        it('should use the default model if no difficulty is returned', async () => {
-            const hook = createModelRouterHook();
-            const classify = vi.fn().mockResolvedValue({});
-            const input = {
-                sessionID: '123',
-                classify,
-            };
-            const output = {
-                message: {},
-                parts: [{ type: 'text', text: 'test prompt' }],
-            };
-            await hook['chat.message'](input, output);
-            expect(input).toHaveProperty('model');
-            expect(input.model.providerID).toBe('default');
-            expect(input.model.modelID).toBe('default');
-        });
-        it('should use default model when router returns nothing', async () => {
-            const hook = createModelRouterHook();
-            const classify = vi.fn().mockResolvedValue({});
-            const input = {
-                sessionID: '123',
-                classify,
-            };
-            const output = {
-                message: {},
-                parts: [{ type: 'text', text: 'test prompt' }],
-            };
-            await hook['chat.message'](input, output);
-            expect(input).toHaveProperty('model');
-            expect(input.model.providerID).toBe('default');
-            expect(input.model.modelID).toBe('default');
-        });
-        it('should handle classifier throwing an error gracefully', async () => {
-            const hook = createModelRouterHook();
-            const classify = vi.fn().mockRejectedValue(new Error('API Error'));
-            const input = {
-                sessionID: '123',
-                classify,
-            };
-            const output = {
-                message: {},
-                parts: [{ type: 'text', text: 'test prompt' }],
-            };
-            await expect(hook['chat.message'](input, output)).rejects.toThrow('API Error');
-        });
-        it('should handle classifier returning null', async () => {
-            const hook = createModelRouterHook();
-            const classify = vi.fn().mockResolvedValue(null);
-            const input = {
-                sessionID: '123',
-                classify,
-            };
-            const output = {
-                message: {},
-                parts: [{ type: 'text', text: 'test prompt' }],
-            };
-            await hook['chat.message'](input, output);
-            expect(input.model.providerID).toBe('default');
-            expect(input.model.modelID).toBe('default');
-        });
-        it('should handle classifier returning undefined difficulty', async () => {
-            const hook = createModelRouterHook();
-            const classify = vi.fn().mockResolvedValue({ difficulty: undefined });
-            const input = {
-                sessionID: '123',
-                classify,
-            };
-            const output = {
-                message: {},
-                parts: [{ type: 'text', text: 'test prompt' }],
-            };
-            await hook['chat.message'](input, output);
-            expect(input.model.providerID).toBe('default');
-            expect(input.model.modelID).toBe('default');
-        });
-        it('should default to default model for invalid difficulty values', async () => {
-            const hook = createModelRouterHook();
-            const classify = vi.fn().mockResolvedValue({ difficulty: 'ultra-hard' });
-            const input = {
-                sessionID: '123',
-                classify,
-            };
-            const output = {
-                message: {},
-                parts: [{ type: 'text', text: 'test prompt' }],
-            };
-            await hook['chat.message'](input, output);
-            expect(input.model.providerID).toBe('default');
-            expect(input.model.modelID).toBe('default');
-        });
-        it('should default to default model for empty string difficulty', async () => {
-            const hook = createModelRouterHook();
-            const classify = vi.fn().mockResolvedValue({ difficulty: '' });
-            const input = {
-                sessionID: '123',
-                classify,
-            };
-            const output = {
-                message: {},
-                parts: [{ type: 'text', text: 'test prompt' }],
-            };
-            await hook['chat.message'](input, output);
-            expect(input.model.providerID).toBe('default');
-            expect(input.model.modelID).toBe('default');
-        });
-        it('should handle case-insensitive difficulty matching', async () => {
-            const hook = createModelRouterHook();
-            const classify = vi.fn().mockResolvedValue({ difficulty: 'HARD' });
-            const input = {
-                sessionID: '123',
-                classify,
-            };
-            const output = {
-                message: {},
-                parts: [{ type: 'text', text: 'test prompt' }],
-            };
-            await hook['chat.message'](input, output);
-            expect(input.model.providerID).toBe('hard');
-            expect(input.model.modelID).toBe('hard');
-        });
-        it('should route all messages when MORPH_ROUTER_PROMPT_CACHING_AWARE is disabled', async () => {
-            const hook = createModelRouterHook();
-            const classify = vi
-                .fn()
-                .mockResolvedValueOnce({ difficulty: 'hard' })
-                .mockResolvedValueOnce({ difficulty: 'easy' });
-            const sessionID = 'session-456';
-            const input1 = { sessionID, classify };
-            const output1 = {
-                message: {},
-                parts: [{ type: 'text', text: 'first message' }],
-            };
-            await hook['chat.message'](input1, output1);
-            expect(classify).toHaveBeenCalledTimes(1);
-            expect(input1.model.providerID).toBe('hard');
-            const input2 = { sessionID, classify };
-            const output2 = {
-                message: {},
-                parts: [{ type: 'text', text: 'second message' }],
-            };
-            await hook['chat.message'](input2, output2);
-            expect(classify).toHaveBeenCalledTimes(2);
-            expect(input2.model.providerID).toBe('easy');
-        });
-    });
-});

package/dist/shared/config.test.d.ts

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

package/dist/shared/config.test.js

@@ -1,201 +0,0 @@
-import { describe, it, expect, beforeEach, beforeAll, afterAll, } from 'bun:test';
-import { existsSync, writeFileSync, rmSync, mkdirSync, } from 'node:fs';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-import { env } from 'node:process';
-// Use a real temporary directory for testing - no mocking needed
-const mockConfigDir = join(tmpdir(), 'mock-morph-config-test');
-const mockMorphJson = join(mockConfigDir, 'morph.json');
-const mockMorphJsonc = join(mockConfigDir, 'morph.jsonc');
-// Save original environment
-let originalEnv;
-import { getMorphPluginConfigPath, loadMorphPluginConfig, loadMorphPluginConfigWithProjectOverride, } from './config';
-describe('config.ts', () => {
-    beforeAll(() => {
-        // Save original environment and set custom config dir
-        originalEnv = {
-            OPENCODE_CONFIG_DIR: env.OPENCODE_CONFIG_DIR,
-        };
-        env.OPENCODE_CONFIG_DIR = mockConfigDir;
-        // Create mock config directory
-        if (!existsSync(mockConfigDir)) {
-            mkdirSync(mockConfigDir, { recursive: true });
-        }
-    });
-    afterAll(() => {
-        // Restore original environment
-        if (originalEnv.OPENCODE_CONFIG_DIR !== undefined) {
-            env.OPENCODE_CONFIG_DIR = originalEnv.OPENCODE_CONFIG_DIR;
-        }
-        else {
-            delete env.OPENCODE_CONFIG_DIR;
-        }
-        // Cleanup
-        try {
-            if (existsSync(mockMorphJson))
-                rmSync(mockMorphJson);
-            if (existsSync(mockMorphJsonc))
-                rmSync(mockMorphJsonc);
-            if (existsSync(mockConfigDir))
-                rmSync(mockConfigDir, { recursive: true });
-        }
-        catch {
-            // Ignore cleanup errors
-        }
-    });
-    beforeEach(() => {
-        // Clean up any existing config files before each test
-        try {
-            if (existsSync(mockMorphJson))
-                rmSync(mockMorphJson);
-            if (existsSync(mockMorphJsonc))
-                rmSync(mockMorphJsonc);
-        }
-        catch {
-            // Ignore cleanup errors
-        }
-    });
-    describe('getMorphPluginConfigPath', () => {
-        it('should return path to morph.json in config directory', () => {
-            const path = getMorphPluginConfigPath();
-            expect(path).toContain('morph.json');
-            expect(path).toContain(mockConfigDir);
-        });
-    });
-    describe('loadMorphPluginConfig', () => {
-        it('should return null when no config files exist', () => {
-            const result = loadMorphPluginConfig();
-            expect(result).toBeNull();
-        });
-        it('should load config from .jsonc file', () => {
-            const content = `{
-        "MORPH_API_KEY": "test-key-123",
-        "MORPH_ROUTER_ENABLED": false
-      }`;
-            writeFileSync(mockMorphJsonc, content);
-            const result = loadMorphPluginConfig();
-            expect(result).not.toBeNull();
-            expect(result?.MORPH_API_KEY).toBe('test-key-123');
-            expect(result?.MORPH_ROUTER_ENABLED).toBe(false);
-        });
-        it('should load config from .json file', () => {
-            const content = JSON.stringify({
-                MORPH_API_KEY: 'json-key-456',
-                MORPH_MODEL_EASY: 'provider/model-easy',
-            });
-            writeFileSync(mockMorphJson, content);
-            const result = loadMorphPluginConfig();
-            expect(result).not.toBeNull();
-            expect(result?.MORPH_API_KEY).toBe('json-key-456');
-            expect(result?.MORPH_MODEL_EASY).toBe('provider/model-easy');
-        });
-        it('should prefer .jsonc over .json when both exist', () => {
-            const jsoncContent = '{"MORPH_API_KEY": "from-jsonc"}';
-            const jsonContent = '{"MORPH_API_KEY": "from-json"}';
-            writeFileSync(mockMorphJsonc, jsoncContent);
-            writeFileSync(mockMorphJson, jsonContent);
-            const result = loadMorphPluginConfig();
-            expect(result?.MORPH_API_KEY).toBe('from-jsonc');
-        });
-        it('should return null for invalid .jsonc content', () => {
-            writeFileSync(mockMorphJsonc, 'invalid json content');
-            const result = loadMorphPluginConfig();
-            expect(result).toBeNull();
-        });
-        it('should return null for invalid .json content', () => {
-            writeFileSync(mockMorphJson, 'invalid json content');
-            const result = loadMorphPluginConfig();
-            expect(result).toBeNull();
-        });
-        it('should handle all MORPH config fields', () => {
-            const content = JSON.stringify({
-                MORPH_API_KEY: 'api-key',
-                MORPH_ROUTER_ENABLED: true,
-                MORPH_MODEL_EASY: 'easy/provider/model',
-                MORPH_MODEL_MEDIUM: 'medium/provider/model',
-                MORPH_MODEL_HARD: 'hard/provider/model',
-                MORPH_MODEL_DEFAULT: 'default/provider/model',
-            });
-            writeFileSync(mockMorphJson, content);
-            const result = loadMorphPluginConfig();
-            expect(result).toEqual({
-                MORPH_API_KEY: 'api-key',
-                MORPH_ROUTER_ENABLED: true,
-                MORPH_MODEL_EASY: 'easy/provider/model',
-                MORPH_MODEL_MEDIUM: 'medium/provider/model',
-                MORPH_MODEL_HARD: 'hard/provider/model',
-                MORPH_MODEL_DEFAULT: 'default/provider/model',
-            });
-        });
-        it('should handle nested MORPH_ROUTER_CONFIGS', () => {
-            const content = JSON.stringify({
-                MORPH_API_KEY: 'api-key',
-                MORPH_ROUTER_CONFIGS: {
-                    MORPH_ROUTER_ENABLED: true,
-                    MORPH_MODEL_EASY: 'easy/provider/model',
-                    MORPH_MODEL_MEDIUM: 'medium/provider/model',
-                    MORPH_MODEL_HARD: 'hard/provider/model',
-                    MORPH_MODEL_DEFAULT: 'default/provider/model',
-                },
-            });
-            writeFileSync(mockMorphJson, content);
-            const result = loadMorphPluginConfig();
-            expect(result?.MORPH_API_KEY).toBe('api-key');
-            expect(result?.MORPH_ROUTER_CONFIGS).toEqual({
-                MORPH_ROUTER_ENABLED: true,
-                MORPH_MODEL_EASY: 'easy/provider/model',
-                MORPH_MODEL_MEDIUM: 'medium/provider/model',
-                MORPH_MODEL_HARD: 'hard/provider/model',
-                MORPH_MODEL_DEFAULT: 'default/provider/model',
-            });
-        });
-    });
-    describe('loadMorphPluginConfigWithProjectOverride', () => {
-        it('should return empty object when no config exists', () => {
-            const result = loadMorphPluginConfigWithProjectOverride('/non-existent-path');
-            expect(result).toEqual({});
-        });
-        it('should merge user config with project config', () => {
-            // Create user config
-            writeFileSync(mockMorphJson, JSON.stringify({
-                MORPH_API_KEY: 'user-api-key',
-                MORPH_MODEL_EASY: 'user-easy-model',
-            }));
-            // Create project config directory
-            const projectDir = join(tmpdir(), 'test-project');
-            const projectConfigDir = join(projectDir, '.opencode');
-            const projectConfigPath = join(projectConfigDir, 'morph.json');
-            mkdirSync(projectConfigDir, { recursive: true });
-            writeFileSync(projectConfigPath, JSON.stringify({
-                MORPH_API_KEY: 'project-api-key',
-                MORPH_MODEL_HARD: 'project-hard-model',
-            }));
-            const result = loadMorphPluginConfigWithProjectOverride(projectDir);
-            // Project config should override user config
-            expect(result.MORPH_API_KEY).toBe('project-api-key');
-            expect(result.MORPH_MODEL_EASY).toBe('user-easy-model');
-            expect(result.MORPH_MODEL_HARD).toBe('project-hard-model');
-        });
-        it('should handle project .jsonc config', () => {
-            // Create user config
-            writeFileSync(mockMorphJson, JSON.stringify({
-                MORPH_API_KEY: 'user-key',
-            }));
-            // Create project config with .jsonc
-            const projectDir = join(tmpdir(), 'test-project2');
-            const projectConfigDir = join(projectDir, '.opencode');
-            const projectConfigPath = join(projectConfigDir, 'morph.jsonc');
-            mkdirSync(projectConfigDir, { recursive: true });
-            const jsoncContent = `
-        // Project config with comments
-        {
-          "MORPH_MODEL_MEDIUM": "project-medium-model"
-        }
-      `;
-            writeFileSync(projectConfigPath, jsoncContent);
-            const result = loadMorphPluginConfigWithProjectOverride(projectDir);
-            expect(result.MORPH_API_KEY).toBe('user-key');
-            expect(result.MORPH_MODEL_MEDIUM).toBe('project-medium-model');
-        });
-    });
-});

package/dist/shared/opencode-config-dir.test.d.ts

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