opencode-morphllm 0.0.5 → 0.0.7

package/src/{router.ts → morph/router.ts}

@@ -6,7 +6,9 @@ import {
   MORPH_MODEL_MEDIUM,
   MORPH_MODEL_HARD,
   MORPH_MODEL_DEFAULT,
-} from './config';
+  MORPH_ROUTER_PROMPT_CACHING_AWARE,
+  MORPH_ROUTER_ENABLED,
+} from '../shared/config';
 import type { Part, UserMessage } from '@opencode-ai/sdk';
 import type {
   RouterInput,
@@ -14,7 +16,17 @@ import type {
   ComplexityLevel,
 } from '@morphllm/morphsdk';
 
-const morph = new MorphClient({ apiKey: API_KEY });
+// Lazy initialization to allow mocking in tests
+let morph: MorphClient | null = null;
+
+const sessionsWithModelSelected = new Set<string>();
+
+function getMorphClient(): MorphClient {
+  if (!morph) {
+    morph = new MorphClient({ apiKey: API_KEY });
+  }
+  return morph;
+}
 
 function parseModel(s?: string): { providerID: string; modelID: string } {
   if (!s) return { providerID: '', modelID: '' };
@@ -54,11 +66,21 @@ export function createModelRouterHook() {
     ): Promise<void> => {
       input.model = input.model ?? { providerID: '', modelID: '' };
 
+      if (!MORPH_ROUTER_ENABLED) {
+        return;
+      }
+
+      if (MORPH_ROUTER_PROMPT_CACHING_AWARE) {
+        if (sessionsWithModelSelected.has(input.sessionID)) {
+          return;
+        }
+      }
+
       const promptText = extractPromptText(output.parts);
 
       const classifier =
         input.classify ??
-        ((args: RouterInput) => morph.routers.raw.classify(args));
+        ((args: RouterInput) => getMorphClient().routers.raw.classify(args));
 
       const classification: RawRouterResult = await classifier({
         input: promptText,
@@ -71,6 +93,10 @@ export function createModelRouterHook() {
 
       input.model.providerID = finalProviderID;
       input.model.modelID = finalModelID;
+
+      if (MORPH_ROUTER_ENABLED && MORPH_ROUTER_PROMPT_CACHING_AWARE) {
+        sessionsWithModelSelected.add(input.sessionID);
+      }
     },
   };
 }

package/src/shared/config.test.ts

@@ -0,0 +1,257 @@
+import {
+  describe,
+  it,
+  expect,
+  beforeEach,
+  afterEach,
+  beforeAll,
+  afterAll,
+} from 'bun:test';
+import {
+  existsSync,
+  writeFileSync,
+  readFileSync,
+  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: Record<string, string | undefined>;
+
+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/src/{config.ts → shared/config.ts}

@@ -1,6 +1,6 @@
 import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
-import { getOpenCodeConfigDir } from './shared/opencode-config-dir';
+import { getOpenCodeConfigDir } from './opencode-config-dir';
 
 const MORPH_PLUGIN_NAME = 'morph';
 
@@ -9,9 +9,21 @@ export function getMorphPluginConfigPath(): string {
   return join(configDir, `${MORPH_PLUGIN_NAME}.json`);
 }
 
+interface MorphRouterConfigs {
+  MORPH_ROUTER_ENABLED?: boolean;
+  MORPH_ROUTER_PROMPT_CACHING_AWARE?: boolean;
+  MORPH_MODEL_EASY?: string;
+  MORPH_MODEL_MEDIUM?: string;
+  MORPH_MODEL_HARD?: string;
+  MORPH_MODEL_DEFAULT?: string;
+}
+
 interface MorphConfig {
   MORPH_API_KEY?: string;
+  MORPH_ROUTER_CONFIGS?: MorphRouterConfigs;
+  // Legacy fields for backward compatibility
   MORPH_ROUTER_ENABLED?: boolean;
+  MORPH_ROUTER_PROMPT_CACHING_AWARE?: boolean;
   MORPH_MODEL_EASY?: string;
   MORPH_MODEL_MEDIUM?: string;
   MORPH_MODEL_HARD?: string;
@@ -85,10 +97,22 @@ export function loadMorphPluginConfigWithProjectOverride(
 
 const config = loadMorphPluginConfigWithProjectOverride();
 
+const routerConfigs = config.MORPH_ROUTER_CONFIGS || {};
+
 export const API_KEY = config.MORPH_API_KEY || '';
-export const MORPH_MODEL_EASY = config.MORPH_MODEL_EASY || '';
-export const MORPH_MODEL_MEDIUM = config.MORPH_MODEL_MEDIUM || '';
-export const MORPH_MODEL_HARD = config.MORPH_MODEL_HARD || '';
+export const MORPH_MODEL_EASY =
+  routerConfigs.MORPH_MODEL_EASY || config.MORPH_MODEL_EASY || '';
+export const MORPH_MODEL_MEDIUM =
+  routerConfigs.MORPH_MODEL_MEDIUM || config.MORPH_MODEL_MEDIUM || '';
+export const MORPH_MODEL_HARD =
+  routerConfigs.MORPH_MODEL_HARD || config.MORPH_MODEL_HARD || '';
 export const MORPH_MODEL_DEFAULT =
-  config.MORPH_MODEL_DEFAULT || MORPH_MODEL_MEDIUM;
-export const MORPH_ROUTER_ENABLED = config.MORPH_ROUTER_ENABLED ?? true;
+  routerConfigs.MORPH_MODEL_DEFAULT ||
+  config.MORPH_MODEL_DEFAULT ||
+  MORPH_MODEL_MEDIUM;
+export const MORPH_ROUTER_ENABLED =
+  routerConfigs.MORPH_ROUTER_ENABLED ?? config.MORPH_ROUTER_ENABLED ?? true;
+export const MORPH_ROUTER_PROMPT_CACHING_AWARE =
+  routerConfigs.MORPH_ROUTER_PROMPT_CACHING_AWARE ??
+  config.MORPH_ROUTER_PROMPT_CACHING_AWARE ??
+  false;