opencode-morphllm 0.0.7 → 0.0.9

package/src/morph/router.ts

@@ -1,111 +0,0 @@
-import { MorphClient } from '@morphllm/morphsdk';
-
-import {
-  API_KEY,
-  MORPH_MODEL_EASY,
-  MORPH_MODEL_MEDIUM,
-  MORPH_MODEL_HARD,
-  MORPH_MODEL_DEFAULT,
-  MORPH_ROUTER_PROMPT_CACHING_AWARE,
-  MORPH_ROUTER_ENABLED,
-} from '../shared/config';
-import type { Part, UserMessage } from '@opencode-ai/sdk';
-import type {
-  RouterInput,
-  RawRouterResult,
-  ComplexityLevel,
-} from '@morphllm/morphsdk';
-
-// 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: '' };
-  const [providerID = '', modelID = ''] = s.split('/');
-  return { providerID, modelID };
-}
-
-function pickModelForDifficulty(difficulty?: ComplexityLevel | string): {
-  providerID: string;
-  modelID: string;
-} {
-  const key = String(difficulty).toLowerCase();
-  switch (key) {
-    case 'easy':
-      return parseModel(MORPH_MODEL_EASY);
-    case 'medium':
-      return parseModel(MORPH_MODEL_MEDIUM);
-    case 'hard':
-      return parseModel(MORPH_MODEL_HARD);
-    default:
-      return parseModel(MORPH_MODEL_DEFAULT);
-  }
-}
-
-export function createModelRouterHook() {
-  return {
-    'chat.message': async (
-      input: {
-        sessionID: string;
-        agent?: string;
-        model?: { providerID: string; modelID: string };
-        messageID?: string;
-        variant?: string;
-        classify?: (args: RouterInput) => Promise<RawRouterResult>;
-      },
-      output: { message: UserMessage; parts: Part[] }
-    ): 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) => getMorphClient().routers.raw.classify(args));
-
-      const classification: RawRouterResult = await classifier({
-        input: promptText,
-      } as RouterInput);
-
-      const chosen = pickModelForDifficulty(classification?.difficulty);
-
-      const finalProviderID = chosen.providerID || input.model.providerID;
-      const finalModelID = chosen.modelID || input.model.modelID;
-
-      input.model.providerID = finalProviderID;
-      input.model.modelID = finalModelID;
-
-      if (MORPH_ROUTER_ENABLED && MORPH_ROUTER_PROMPT_CACHING_AWARE) {
-        sessionsWithModelSelected.add(input.sessionID);
-      }
-    },
-  };
-}
-
-export function extractPromptText(
-  parts: Array<{ type: string; text?: string }>
-): string {
-  return parts
-    .filter((p) => p.type === 'text')
-    .map((p) => p.text || '')
-    .join(' ');
-}

package/src/shared/config.test.ts

@@ -1,257 +0,0 @@
-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/shared/config.ts

@@ -1,118 +0,0 @@
-import { existsSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { getOpenCodeConfigDir } from './opencode-config-dir';
-
-const MORPH_PLUGIN_NAME = 'morph';
-
-export function getMorphPluginConfigPath(): string {
-  const configDir = getOpenCodeConfigDir({ binary: 'opencode' });
-  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;
-  MORPH_MODEL_DEFAULT?: string;
-}
-
-function parseJsonc<T>(content: string): T | null {
-  try {
-    // A simple JSONC parser that removes comments
-    const cleanedContent = content.replace(/\/\*[\s\S]*?\*\/|\/\/.*/g, '');
-    return JSON.parse(cleanedContent) as T;
-  } catch {
-    return null;
-  }
-}
-
-export function loadMorphPluginConfig(): MorphConfig | null {
-  const jsoncPath = getMorphPluginConfigPath().replace('.json', '.jsonc');
-  const jsonPath = getMorphPluginConfigPath();
-
-  if (existsSync(jsoncPath)) {
-    try {
-      const content = readFileSync(jsoncPath, 'utf-8');
-      return parseJsonc<MorphConfig>(content);
-    } catch {
-      return null;
-    }
-  }
-
-  if (existsSync(jsonPath)) {
-    try {
-      const content = readFileSync(jsonPath, 'utf-8');
-      return JSON.parse(content) as MorphConfig;
-    } catch {
-      return null;
-    }
-  }
-
-  return null;
-}
-
-export function loadMorphPluginConfigWithProjectOverride(
-  projectDir: string = process.cwd()
-): MorphConfig {
-  const userConfig = loadMorphPluginConfig() ?? {};
-
-  const projectBasePath = join(projectDir, '.opencode', MORPH_PLUGIN_NAME);
-  const projectJsoncPath = `${projectBasePath}.jsonc`;
-  const projectJsonPath = `${projectBasePath}.json`;
-
-  let projectConfig: MorphConfig = {};
-
-  if (existsSync(projectJsoncPath)) {
-    try {
-      const content = readFileSync(projectJsoncPath, 'utf-8');
-      projectConfig = parseJsonc<MorphConfig>(content) ?? {};
-    } catch {
-      // Ignore parse errors
-    }
-  } else if (existsSync(projectJsonPath)) {
-    try {
-      const content = readFileSync(projectJsonPath, 'utf-8');
-      projectConfig = JSON.parse(content) as MorphConfig;
-    } catch {
-      // Ignore parse errors
-    }
-  }
-
-  return { ...userConfig, ...projectConfig };
-}
-
-const config = loadMorphPluginConfigWithProjectOverride();
-
-const routerConfigs = config.MORPH_ROUTER_CONFIGS || {};
-
-export const API_KEY = config.MORPH_API_KEY || '';
-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 =
-  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;