opencode-dux 1.0.0

package/src/config/loader.ts

@@ -0,0 +1,269 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { stripJsonComments } from '../cli/config-io';
+import { getConfigSearchDirs } from '../cli/paths';
+import { type PluginConfig, PluginConfigSchema } from './schema';
+
+const PROMPTS_DIR_NAME = 'opencode-dux';
+
+/**
+ * Load and validate plugin configuration from a specific file path.
+ * Supports both .json and .jsonc formats (JSON with comments).
+ * Returns null if the file doesn't exist, is invalid, or cannot be read.
+ * Logs warnings for validation errors and unexpected read errors.
+ *
+ * @param configPath - Absolute path to the config file
+ * @returns Validated config object, or null if loading failed
+ */
+function loadConfigFromPath(configPath: string): PluginConfig | null {
+  try {
+    const content = fs.readFileSync(configPath, 'utf-8');
+    // Use stripJsonComments to support JSONC format (comments and trailing commas)
+    const rawConfig = JSON.parse(stripJsonComments(content));
+    const result = PluginConfigSchema.safeParse(rawConfig);
+
+    if (!result.success) {
+      console.warn(`[opencode-dux] Invalid config at ${configPath}:`);
+      console.warn(result.error.format());
+      return null;
+    }
+
+    return result.data;
+  } catch (error) {
+    // File doesn't exist or isn't readable - this is expected and fine
+    if (
+      error instanceof Error &&
+      'code' in error &&
+      (error as NodeJS.ErrnoException).code !== 'ENOENT'
+    ) {
+      console.warn(
+        `[opencode-dux] Error reading config from ${configPath}:`,
+        error.message,
+      );
+    }
+    return null;
+  }
+}
+
+/**
+ * Find existing config file path, preferring .jsonc over .json.
+ * Checks for .jsonc first, then falls back to .json.
+ *
+ * @param basePath - Base path without extension (e.g., /path/to/opencode-dux)
+ * @returns Path to existing config file, or null if neither exists
+ */
+function findConfigPath(basePath: string): string | null {
+  const jsoncPath = `${basePath}.jsonc`;
+  const jsonPath = `${basePath}.json`;
+
+  // Prefer .jsonc over .json
+  if (fs.existsSync(jsoncPath)) {
+    return jsoncPath;
+  }
+  if (fs.existsSync(jsonPath)) {
+    return jsonPath;
+  }
+  return null;
+}
+
+function findConfigPathInDirs(
+  configDirs: string[],
+  baseName: string,
+): string | null {
+  for (const configDir of configDirs) {
+    const configPath = findConfigPath(path.join(configDir, baseName));
+    if (configPath) {
+      return configPath;
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Recursively merge two objects, with override values taking precedence.
+ * For nested objects, merges recursively. For arrays and primitives, override replaces base.
+ *
+ * @param base - Base object to merge into
+ * @param override - Override object whose values take precedence
+ * @returns Merged object, or undefined if both inputs are undefined
+ */
+export function deepMerge<T extends Record<string, unknown>>(
+  base?: T,
+  override?: T,
+): T | undefined {
+  if (!base) return override;
+  if (!override) return base;
+
+  const result = { ...base } as T;
+  for (const key of Object.keys(override) as (keyof T)[]) {
+    const baseVal = base[key];
+    const overrideVal = override[key];
+
+    if (
+      typeof baseVal === 'object' &&
+      baseVal !== null &&
+      typeof overrideVal === 'object' &&
+      overrideVal !== null &&
+      !Array.isArray(baseVal) &&
+      !Array.isArray(overrideVal)
+    ) {
+      result[key] = deepMerge(
+        baseVal as Record<string, unknown>,
+        overrideVal as Record<string, unknown>,
+      ) as T[keyof T];
+    } else {
+      result[key] = overrideVal;
+    }
+  }
+  return result;
+}
+
+/**
+ * Load plugin configuration from user and project config files, merging them appropriately.
+ *
+ * Configuration is loaded from two locations:
+ * 1. User config: $OPENCODE_CONFIG_DIR/opencode-dux.jsonc or .json,
+ *    or ~/.config/opencode/opencode-dux.jsonc or .json (or $XDG_CONFIG_HOME)
+ * 2. Project config: <directory>/.opencode/opencode-dux.jsonc or .json
+ *
+ * JSONC format is preferred over JSON (allows comments and trailing commas).
+ * Project config takes precedence over user config. Nested objects (agents) are
+ * deep-merged, while top-level arrays are replaced entirely by project config.
+ *
+ * @param directory - Project directory to search for .opencode config
+ * @returns Merged plugin configuration (empty object if no configs found)
+ */
+export function loadPluginConfig(directory: string): PluginConfig {
+  const userConfigPath = findConfigPathInDirs(
+    getConfigSearchDirs(),
+    'opencode-dux',
+  );
+
+  const projectConfigBasePath = path.join(
+    directory,
+    '.opencode',
+    'opencode-dux',
+  );
+
+  // Find existing config files (preferring .jsonc over .json)
+  const projectConfigPath = findConfigPath(projectConfigBasePath);
+
+  let config: PluginConfig = userConfigPath
+    ? (loadConfigFromPath(userConfigPath) ?? {})
+    : {};
+
+  const projectConfig = projectConfigPath
+    ? loadConfigFromPath(projectConfigPath)
+    : null;
+  if (projectConfig) {
+    config = {
+      ...config,
+      ...projectConfig,
+      agents: deepMerge(config.agents, projectConfig.agents),
+      sessionManager: deepMerge(
+        config.sessionManager,
+        projectConfig.sessionManager,
+      ),
+      contextPressure: deepMerge(
+        config.contextPressure,
+        projectConfig.contextPressure,
+      ),
+      fallback: deepMerge(config.fallback, projectConfig.fallback),
+    };
+  }
+
+  // Override preset from environment variable if set
+  const envPreset = process.env.OH_MY_OPENCODE_SLIM_PRESET;
+  if (envPreset) {
+    config.preset = envPreset;
+  }
+
+  // Resolve preset and merge with root agents
+  if (config.preset) {
+    const preset = config.presets?.[config.preset];
+    if (preset) {
+      // Merge preset agents with root agents (root overrides)
+      config.agents = deepMerge(preset, config.agents);
+    } else {
+      // Preset name specified but doesn't exist - warn user
+      const presetSource =
+        envPreset === config.preset ? 'environment variable' : 'config file';
+      const availablePresets = config.presets
+        ? Object.keys(config.presets).join(', ')
+        : 'none';
+      console.warn(
+        `[opencode-dux] Preset "${config.preset}" not found (from ${presetSource}). Available presets: ${availablePresets}`,
+      );
+    }
+  }
+
+  return config;
+}
+
+/**
+ * Load custom prompt for an agent from the prompts directory.
+ * Checks for {agent}.md (replaces default) and {agent}_append.md (appends to default).
+ * If preset is provided and safe for paths, it first checks {preset}/ subdirectory,
+ * then falls back to the root prompts directory.
+ *
+ * @param agentName - Name of the agent (e.g., "orchestrator", "explorer")
+ * @param preset - Optional preset name for preset-scoped prompt lookup
+ * @returns Object with prompt and/or appendPrompt if files exist
+ */
+export function loadAgentPrompt(
+  agentName: string,
+  preset?: string,
+): {
+  prompt?: string;
+  appendPrompt?: string;
+} {
+  const presetDirName =
+    preset && /^[a-zA-Z0-9_-]+$/.test(preset) ? preset : undefined;
+  const promptSearchDirs = getConfigSearchDirs().flatMap((configDir) => {
+    const promptsDir = path.join(configDir, PROMPTS_DIR_NAME);
+    return presetDirName
+      ? [path.join(promptsDir, presetDirName), promptsDir]
+      : [promptsDir];
+  });
+  const result: { prompt?: string; appendPrompt?: string } = {};
+
+  const readFirstPrompt = (
+    fileName: string,
+    errorPrefix: string,
+  ): string | undefined => {
+    for (const dir of promptSearchDirs) {
+      const promptPath = path.join(dir, fileName);
+      if (!fs.existsSync(promptPath)) {
+        continue;
+      }
+
+      try {
+        return fs.readFileSync(promptPath, 'utf-8');
+      } catch (error) {
+        console.warn(
+          `[opencode-dux] ${errorPrefix} ${promptPath}:`,
+          error instanceof Error ? error.message : String(error),
+        );
+      }
+    }
+
+    return undefined;
+  };
+
+  // Check for replacement prompt
+  result.prompt = readFirstPrompt(
+    `${agentName}.md`,
+    'Error reading prompt file',
+  );
+
+  // Check for append prompt
+  result.appendPrompt = readFirstPrompt(
+    `${agentName}_append.md`,
+    'Error reading append prompt file',
+  );
+
+  return result;
+}
+
+

package/src/config/model-resolution.test.ts

@@ -0,0 +1,176 @@
+import { describe, expect, test } from 'bun:test';
+import type { ModelEntry } from '../config/schema';
+
+/**
+ * Test the model array resolution logic that runs in the config hook.
+ * This logic determines which model to use from an effective model array.
+ *
+ * The resolver always picks the first model in the effective array,
+ * regardless of provider configuration. This is correct because:
+ * - Not all providers require entries in opencodeConfig.provider - some are
+ *   loaded automatically by opencode (e.g. github-copilot, openrouter).
+ * - We cannot distinguish "auto-loaded provider" from "provider not configured"
+ *   without calling the API, which isn't available at config-hook time.
+ * - Runtime failover (rate-limit handling) is handled separately by
+ *   ForegroundFallbackManager.
+ */
+
+describe('model array resolution', () => {
+  /**
+   * Simulates the resolution logic from src/index.ts.
+   * Always returns the first model in the array.
+   */
+  function resolveModelFromArray(
+    modelArray: Array<{ id: string; variant?: string }>,
+  ): { model: string; variant?: string } | null {
+    if (!modelArray || modelArray.length === 0) return null;
+
+    const chosen = modelArray[0];
+    return {
+      model: chosen.id,
+      variant: chosen.variant,
+    };
+  }
+
+  test('uses first model when no provider config exists', () => {
+    const modelArray: ModelEntry[] = [
+      { id: 'opencode/big-pickle', variant: 'high' },
+      { id: 'iflowcn/qwen3-235b-a22b-thinking-2507', variant: 'high' },
+    ];
+
+    const result = resolveModelFromArray(modelArray);
+
+    expect(result?.model).toBe('opencode/big-pickle');
+    expect(result?.variant).toBe('high');
+  });
+
+  test('uses first model even when other providers are configured', () => {
+    const modelArray: ModelEntry[] = [
+      { id: 'github-copilot/claude-opus-4.6', variant: 'high' },
+      { id: 'zai-coding-plan/glm-5' },
+    ];
+
+    const result = resolveModelFromArray(modelArray);
+
+    // Auto-loaded provider should not be skipped in favor of configured one
+    expect(result?.model).toBe('github-copilot/claude-opus-4.6');
+    expect(result?.variant).toBe('high');
+  });
+
+  test('returns null for empty model array', () => {
+    const modelArray: ModelEntry[] = [];
+
+    const result = resolveModelFromArray(modelArray);
+
+    expect(result).toBeNull();
+  });
+});
+
+/**
+ * Tests for the fallback.chains merging logic that runs in the config hook.
+ * Mirrors the effectiveArrays construction in src/index.ts.
+ */
+describe('fallback.chains merging for foreground agents', () => {
+  /**
+   * Simulates the effectiveArrays construction + resolution from src/index.ts.
+   * Returns the resolved model string or null.
+   */
+  function resolveWithChains(opts: {
+    modelArray?: Array<{ id: string; variant?: string }>;
+    currentModel?: string;
+    chainModels?: string[];
+    fallbackEnabled?: boolean;
+  }): string | null {
+    const {
+      modelArray,
+      currentModel,
+      chainModels,
+      fallbackEnabled = true,
+    } = opts;
+
+    // Build effectiveArrays (mirrors index.ts logic)
+    const effectiveArray: Array<{ id: string; variant?: string }> = modelArray
+      ? [...modelArray]
+      : [];
+
+    if (fallbackEnabled && chainModels && chainModels.length > 0) {
+      if (effectiveArray.length === 0 && currentModel) {
+        effectiveArray.push({ id: currentModel });
+      }
+      const seen = new Set(effectiveArray.map((m) => m.id));
+      for (const chainModel of chainModels) {
+        if (!seen.has(chainModel)) {
+          seen.add(chainModel);
+          effectiveArray.push({ id: chainModel });
+        }
+      }
+    }
+
+    if (effectiveArray.length === 0) return null;
+
+    // Resolution: always use first model in effective array
+    return effectiveArray[0].id;
+  }
+
+  test('primary model wins regardless of provider config', () => {
+    const result = resolveWithChains({
+      currentModel: 'anthropic/claude-opus-4-5',
+      chainModels: ['openai/gpt-4o'],
+    });
+    expect(result).toBe('anthropic/claude-opus-4-5');
+  });
+
+  test('chain is ignored when fallback disabled', () => {
+    const result = resolveWithChains({
+      currentModel: 'anthropic/claude-opus-4-5',
+      chainModels: ['openai/gpt-4o'],
+      fallbackEnabled: false,
+    });
+    // chain not applied; no effectiveArray entry → falls through to null (no _modelArray either)
+    expect(result).toBeNull();
+  });
+
+  test('_modelArray entries take precedence and chain appends after', () => {
+    const result = resolveWithChains({
+      modelArray: [
+        { id: 'anthropic/claude-opus-4-5' },
+        { id: 'anthropic/claude-sonnet-4-5' },
+      ],
+      chainModels: ['openai/gpt-4o'],
+    });
+    // First entry in _modelArray wins; chain only used for runtime failover
+    expect(result).toBe('anthropic/claude-opus-4-5');
+  });
+
+  test('duplicate model ids across array and chain are deduplicated', () => {
+    const result = resolveWithChains({
+      modelArray: [
+        { id: 'anthropic/claude-opus-4-5' },
+        { id: 'openai/gpt-4o' },
+      ],
+      chainModels: ['openai/gpt-4o', 'google/gemini-pro'],
+    });
+    expect(result).toBe('anthropic/claude-opus-4-5');
+  });
+
+  test('no currentModel and no _modelArray with chain still resolves', () => {
+    const result = resolveWithChains({
+      chainModels: ['openai/gpt-4o', 'anthropic/claude-sonnet-4-5'],
+    });
+    expect(result).toBe('openai/gpt-4o');
+  });
+
+  test('built-in provider not skipped when other providers are configured', () => {
+    // Regression test: github-copilot is auto-loaded by opencode and doesn't
+    // need an entry in opencodeConfig.provider. The resolver must not skip
+    // it in favor of a configured provider later in the chain.
+    const result = resolveWithChains({
+      currentModel: 'github-copilot/claude-opus-4.6',
+      chainModels: [
+        'github-copilot/gemini-3.1-pro-preview',
+        'zai-coding-plan/glm-5',
+      ],
+    });
+    expect(result).toBe('github-copilot/claude-opus-4.6');
+  });
+});

package/src/config/runtime-preset.test.ts

@@ -0,0 +1,61 @@
+import { describe, expect, test } from 'bun:test';
+import {
+  getActiveRuntimePreset,
+  getPreviousRuntimePreset,
+  rollbackRuntimePreset,
+  setActiveRuntimePreset,
+  setActiveRuntimePresetWithPrevious,
+} from './runtime-preset';
+
+describe('runtime-preset', () => {
+  // Cleanup after each test to avoid state leakage
+  test('getActiveRuntimePreset returns null initially', () => {
+    setActiveRuntimePreset(null);
+    expect(getActiveRuntimePreset()).toBeNull();
+    setActiveRuntimePreset(null);
+  });
+
+  test('setActiveRuntimePreset sets the active preset', () => {
+    setActiveRuntimePreset(null);
+    setActiveRuntimePreset('foo');
+    expect(getActiveRuntimePreset()).toBe('foo');
+    setActiveRuntimePreset(null);
+  });
+
+  test('setActiveRuntimePresetWithPrevious sets active and previous', () => {
+    setActiveRuntimePreset(null);
+    setActiveRuntimePreset('old');
+    setActiveRuntimePresetWithPrevious('new');
+    expect(getActiveRuntimePreset()).toBe('new');
+    expect(getPreviousRuntimePreset()).toBe('old');
+    setActiveRuntimePreset(null);
+  });
+
+  test('setActiveRuntimePresetWithPrevious with null sets previous to old', () => {
+    setActiveRuntimePreset(null);
+    setActiveRuntimePreset('old');
+    setActiveRuntimePresetWithPrevious(null);
+    expect(getActiveRuntimePreset()).toBeNull();
+    expect(getPreviousRuntimePreset()).toBe('old');
+    setActiveRuntimePreset(null);
+  });
+
+  test('rollbackRuntimePreset restores active and clears previous', () => {
+    setActiveRuntimePreset(null);
+    setActiveRuntimePreset('old');
+    setActiveRuntimePresetWithPrevious('new');
+    rollbackRuntimePreset('old');
+    expect(getActiveRuntimePreset()).toBe('old');
+    expect(getPreviousRuntimePreset()).toBeNull();
+    setActiveRuntimePreset(null);
+  });
+
+  test('rollbackRuntimePreset with null clears active and previous', () => {
+    setActiveRuntimePreset(null);
+    setActiveRuntimePresetWithPrevious('new');
+    rollbackRuntimePreset(null);
+    expect(getActiveRuntimePreset()).toBeNull();
+    expect(getPreviousRuntimePreset()).toBeNull();
+    setActiveRuntimePreset(null);
+  });
+});

package/src/config/runtime-preset.ts

@@ -0,0 +1,37 @@
+/**
+ * Module-level runtime preset state.
+ *
+ * Survives plugin re-inits triggered by client.config.update() →
+ * Instance.dispose(). The plugin function re-runs but this module-level
+ * variable persists within the same Node.js process.
+ */
+
+let activeRuntimePreset: string | null = null;
+
+export function setActiveRuntimePreset(name: string | null): void {
+  activeRuntimePreset = name;
+}
+
+export function getActiveRuntimePreset(): string | null {
+  return activeRuntimePreset;
+}
+
+/**
+ * Returns the name of the previously active runtime preset (before the
+ * current one), used to compute reset diffs when switching presets.
+ */
+let previousRuntimePreset: string | null = null;
+
+export function getPreviousRuntimePreset(): string | null {
+  return previousRuntimePreset;
+}
+
+export function setActiveRuntimePresetWithPrevious(name: string | null): void {
+  previousRuntimePreset = activeRuntimePreset;
+  activeRuntimePreset = name;
+}
+
+export function rollbackRuntimePreset(previous: string | null): void {
+  activeRuntimePreset = previous;
+  previousRuntimePreset = null;
+}