opencode-morphllm 0.0.4 → 0.0.6

package/src/shared/config.test.ts

@@ -0,0 +1,245 @@
+import {
+  describe,
+  it,
+  expect,
+  beforeEach,
+  afterEach,
+  vi,
+  beforeAll,
+  afterAll,
+} from 'bun:test';
+import {
+  existsSync,
+  writeFileSync,
+  readFileSync,
+  rmSync,
+  mkdirSync,
+} from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+// Mock the opencode-config-dir module before importing config
+const mockConfigDir = join(tmpdir(), 'mock-opencode-config-test');
+const mockMorphJson = join(mockConfigDir, 'morph.json');
+const mockMorphJsonc = join(mockConfigDir, 'morph.jsonc');
+
+vi.mock('./opencode-config-dir', () => ({
+  getOpenCodeConfigDir: vi.fn(() => mockConfigDir),
+}));
+
+import {
+  getMorphPluginConfigPath,
+  loadMorphPluginConfig,
+  loadMorphPluginConfigWithProjectOverride,
+} from './config';
+
+describe('config.ts', () => {
+  beforeAll(() => {
+    // Create mock config directory
+    if (!existsSync(mockConfigDir)) {
+      mkdirSync(mockConfigDir, { recursive: true });
+    }
+  });
+
+  afterAll(() => {
+    // 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

@@ -0,0 +1,118 @@
+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_ONLY_FIRST_MESSAGE?: 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_ONLY_FIRST_MESSAGE?: 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_ONLY_FIRST_MESSAGE =
+  routerConfigs.MORPH_ROUTER_ONLY_FIRST_MESSAGE ??
+  config.MORPH_ROUTER_ONLY_FIRST_MESSAGE ??
+  false;

package/src/shared/opencode-config-dir.ts

@@ -0,0 +1,77 @@
+import { existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join, resolve } from 'node:path';
+
+interface OpenCodeConfigDirOptions {
+  binary: 'opencode' | 'opencode-desktop';
+  version?: string | null;
+  checkExisting?: boolean;
+}
+
+function getTauriConfigDir(identifier: string): string {
+  const platform = process.platform;
+
+  switch (platform) {
+    case 'darwin':
+      return join(homedir(), 'Library', 'Application Support', identifier);
+
+    case 'win32': {
+      const appData =
+        process.env.APPDATA || join(homedir(), 'AppData', 'Roaming');
+      return join(appData, identifier);
+    }
+
+    case 'linux':
+    default: {
+      const xdgConfig =
+        process.env.XDG_CONFIG_HOME || join(homedir(), '.config');
+      return join(xdgConfig, identifier);
+    }
+  }
+}
+
+function getCliConfigDir(): string {
+  const envConfigDir = process.env.OPENCODE_CONFIG_DIR?.trim();
+  if (envConfigDir) {
+    return resolve(envConfigDir);
+  }
+
+  if (process.platform === 'win32') {
+    const crossPlatformDir = join(homedir(), '.config', 'opencode');
+    const crossPlatformConfig = join(crossPlatformDir, 'opencode.json');
+
+    if (existsSync(crossPlatformConfig)) {
+      return crossPlatformDir;
+    }
+
+    const appData =
+      process.env.APPDATA || join(homedir(), 'AppData', 'Roaming');
+    const appdataDir = join(appData, 'opencode');
+    const appdataConfig = join(appdataDir, 'opencode.json');
+
+    if (existsSync(appdataConfig)) {
+      return appdataDir;
+    }
+
+    return crossPlatformDir;
+  }
+
+  const xdgConfig = process.env.XDG_CONFIG_HOME || join(homedir(), '.config');
+  return join(xdgConfig, 'opencode');
+}
+
+export function getOpenCodeConfigDir(
+  options: OpenCodeConfigDirOptions
+): string {
+  if (options.binary === 'opencode-desktop') {
+    const version = options.version;
+    const isDev =
+      !!version && (version.includes('-dev') || version.includes('.dev'));
+    const identifier = isDev
+      ? 'ai.opencode.desktop.dev'
+      : 'ai.opencode.desktop';
+    return getTauriConfigDir(identifier);
+  }
+
+  return getCliConfigDir();
+}

package/dist/const.d.ts

@@ -1,6 +0,0 @@
-export declare const API_KEY: string;
-export declare const MORPH_MODEL_EASY: string;
-export declare const MORPH_MODEL_MEDIUM: string;
-export declare const MORPH_MODEL_HARD: string;
-export declare const MORPH_MODEL_DEFAULT: string;
-export declare const MORPH_ROUTER_ENABLED: boolean;

package/dist/const.js

@@ -1,20 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-const configPath = path.join(
-  process.env.HOME || process.env.USERPROFILE || '',
-  '.config/opencode/morph.json'
-);
-let config = {};
-try {
-  if (fs.existsSync(configPath)) {
-    config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
-  }
-} catch (e) {
-  console.warn('[Morph Plugin] Failed to load config file:', configPath);
-}
-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_DEFAULT = config.MORPH_MODEL_DEFAULT || '';
-export const MORPH_ROUTER_ENABLED = config.MORPH_ROUTER_ENABLED ?? true;

package/src/const.ts

@@ -1,32 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-interface MorphConfig {
-  MORPH_API_KEY?: string;
-  MORPH_ROUTER_ENABLED?: boolean;
-  MORPH_MODEL_EASY?: string;
-  MORPH_MODEL_MEDIUM?: string;
-  MORPH_MODEL_HARD?: string;
-  MORPH_MODEL_DEFAULT?: string;
-}
-
-const configPath = path.join(
-  process.env.HOME || process.env.USERPROFILE || '',
-  '.config/opencode/morph.json'
-);
-
-let config: MorphConfig = {};
-
-try {
-  if (fs.existsSync(configPath)) {
-    config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
-  }
-} catch (e) {
-  console.warn('[Morph Plugin] Failed to load config file:', configPath);
-}
-
-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_DEFAULT = config.MORPH_MODEL_DEFAULT || '';
-export const MORPH_ROUTER_ENABLED = config.MORPH_ROUTER_ENABLED ?? true;