opencode-morphllm 0.0.5 → 0.0.7

package/dist/shared/config.js

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

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

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

package/dist/shared/config.test.js

@@ -0,0 +1,201 @@
+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.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 {};