opencode-morphllm 0.0.6 → 0.0.7

package/dist/shared/config.test.js

@@ -1,204 +1,201 @@
-import {
-  describe,
-  it,
-  expect,
-  beforeEach,
-  vi,
-  beforeAll,
-  afterAll,
-} from 'bun:test';
-import { existsSync, writeFileSync, rmSync, mkdirSync } from 'node:fs';
+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';
-// Mock the opencode-config-dir module before importing config
-const mockConfigDir = join(tmpdir(), 'mock-opencode-config-test');
+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');
-vi.mock('./opencode-config-dir', () => ({
-  getOpenCodeConfigDir: vi.fn(() => mockConfigDir),
-}));
-import {
-  getMorphPluginConfigPath,
-  loadMorphPluginConfig,
-  loadMorphPluginConfigWithProjectOverride,
-} from './config';
+// Save original environment
+let originalEnv;
+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);
+    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('loadMorphPluginConfig', () => {
-    it('should return null when no config files exist', () => {
-      const result = loadMorphPluginConfig();
-      expect(result).toBeNull();
+    describe('getMorphPluginConfigPath', () => {
+        it('should return path to morph.json in config directory', () => {
+            const path = getMorphPluginConfigPath();
+            expect(path).toContain('morph.json');
+            expect(path).toContain(mockConfigDir);
+        });
     });
-    it('should load config from .jsonc file', () => {
-      const content = `{
+    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');
+            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',
+            });
+        });
     });
-    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 = `
+    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');
+            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.d.ts

@@ -1,9 +1,19 @@
-interface OpenCodeConfigDirOptions {
-  binary: 'opencode' | 'opencode-desktop';
-  version?: string | null;
-  checkExisting?: boolean;
+export type OpenCodeBinaryType = 'opencode' | 'opencode-desktop';
+export interface OpenCodeConfigDirOptions {
+    binary: OpenCodeBinaryType;
+    version?: string | null;
+    checkExisting?: boolean;
 }
-export declare function getOpenCodeConfigDir(
-  options: OpenCodeConfigDirOptions
-): string;
-export {};
+export interface OpenCodeConfigPaths {
+    configDir: string;
+    configJson: string;
+    configJsonc: string;
+    packageJson: string;
+    omoConfig: string;
+}
+export declare const TAURI_APP_IDENTIFIER = "ai.opencode.desktop";
+export declare const TAURI_APP_IDENTIFIER_DEV = "ai.opencode.desktop.dev";
+export declare function isDevBuild(version: string | null | undefined): boolean;
+export declare function getOpenCodeConfigDir(options: OpenCodeConfigDirOptions): string;
+export declare function getOpenCodeConfigPaths(options: OpenCodeConfigDirOptions): OpenCodeConfigPaths;
+export declare function detectExistingConfigDir(binary: OpenCodeBinaryType, version?: string | null): string | null;

package/dist/shared/opencode-config-dir.js

@@ -1,56 +1,102 @@
 import { existsSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join, resolve } from 'node:path';
+export const TAURI_APP_IDENTIFIER = 'ai.opencode.desktop';
+export const TAURI_APP_IDENTIFIER_DEV = 'ai.opencode.desktop.dev';
+export function isDevBuild(version) {
+    if (!version)
+        return false;
+    return version.includes('-dev') || version.includes('.dev');
+}
 function getTauriConfigDir(identifier) {
-  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);
-    }
-  }
+    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() {
-  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');
+    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) {
-  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();
+    const { binary, version, checkExisting = true } = options;
+    if (binary === 'opencode') {
+        return getCliConfigDir();
+    }
+    const identifier = isDevBuild(version)
+        ? TAURI_APP_IDENTIFIER_DEV
+        : TAURI_APP_IDENTIFIER;
+    const tauriDir = getTauriConfigDir(identifier);
+    if (checkExisting) {
+        const legacyDir = getCliConfigDir();
+        const legacyConfig = join(legacyDir, 'opencode.json');
+        const legacyConfigC = join(legacyDir, 'opencode.jsonc');
+        if (existsSync(legacyConfig) || existsSync(legacyConfigC)) {
+            return legacyDir;
+        }
+    }
+    return tauriDir;
+}
+export function getOpenCodeConfigPaths(options) {
+    const configDir = getOpenCodeConfigDir(options);
+    return {
+        configDir,
+        configJson: join(configDir, 'opencode.json'),
+        configJsonc: join(configDir, 'opencode.jsonc'),
+        packageJson: join(configDir, 'package.json'),
+        omoConfig: join(configDir, 'oh-my-opencode.json'),
+    };
+}
+export function detectExistingConfigDir(binary, version) {
+    const locations = [];
+    const envConfigDir = process.env.OPENCODE_CONFIG_DIR?.trim();
+    if (envConfigDir) {
+        locations.push(resolve(envConfigDir));
+    }
+    if (binary === 'opencode-desktop') {
+        const identifier = isDevBuild(version)
+            ? TAURI_APP_IDENTIFIER_DEV
+            : TAURI_APP_IDENTIFIER;
+        locations.push(getTauriConfigDir(identifier));
+        if (isDevBuild(version)) {
+            locations.push(getTauriConfigDir(TAURI_APP_IDENTIFIER));
+        }
+    }
+    locations.push(getCliConfigDir());
+    for (const dir of locations) {
+        const configJson = join(dir, 'opencode.json');
+        const configJsonc = join(dir, 'opencode.jsonc');
+        if (existsSync(configJson) || existsSync(configJsonc)) {
+            return dir;
+        }
+    }
+    return null;
 }

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

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