opencode-agent-modes 0.2.0 → 0.3.1

package/README.md

@@ -41,7 +41,7 @@ Add the plugin to your `opencode.json`:
 ```
 
 The following command files are automatically copied to
-`~/.config/opencode/command/` when the plugin initializes:
+`~/.config/opencode/commands/` when the plugin initializes:
 
 - `mode-performance.md`
 - `mode-economy.md`
@@ -135,7 +135,7 @@ To add a custom preset (e.g., "premium"):
    }
    ```
 
-2. Create a command file at `~/.config/opencode/command/mode-premium.md`:
+2. Create a command file at `~/.config/opencode/commands/mode-premium.md`:
 
    ```md
    ---
@@ -150,6 +150,10 @@ To add a custom preset (e.g., "premium"):
 > [!INFO]
 > - Changes require an opencode restart to take effect
 > - Custom mode presets can be added by editing the configuration file
+> - Built-in command files (`mode-performance.md`, `mode-economy.md`, etc.)
+>   are overwritten on every plugin startup. Do not modify them directly.
+> - Custom command files (e.g., `mode-premium.md`) are not affected by
+>   this overwrite and will persist across restarts.
 
 ## Development
 

package/dist/config/guards.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Type guard utilities for configuration processing.
+ */
+/**
+ * Checks if a value is a plain object (not null, not array).
+ *
+ * This is used throughout the codebase to distinguish between
+ * hierarchical structures and leaf values when processing
+ * configurations.
+ *
+ * @param obj - Value to check
+ * @returns True if the value is a plain object
+ */
+export declare function isObject(obj: unknown): obj is Record<string, unknown>;

package/dist/config/index.d.ts

@@ -1,4 +1,5 @@
 export * from './types.ts';
+export * from './guards.ts';
 export * from './loader.ts';
 export * from './initializer.ts';
 export * from './command-installer.ts';

package/dist/config/types.d.ts

@@ -1,17 +1,38 @@
 /**
- * Agent preset configuration for a single agent
+ * Generic model configuration for any agent.
+ *
+ * This interface is intentionally flexible to support arbitrary
+ * properties beyond just `model` and `variant`.
  */
-export interface AgentPreset {
-    model: string;
+export interface ModelConfig {
+    model?: string;
+    variant?: string;
+    [key: string]: unknown;
 }
 /**
- * Mode preset containing configurations for both opencode and oh-my-opencode agents
+ * Hierarchical preset structure supporting arbitrary nesting.
+ *
+ * This type recursively represents the configuration structure for
+ * both opencode and oh-my-opencode, supporting any level of nesting
+ * (e.g., agents/categories, future sections).
+ *
+ * Note: This type alias has a circular reference by design to support
+ * recursive structures. The TypeScript compiler warning about this
+ * can be safely ignored.
+ */
+export type HierarchicalPreset = Record<string, ModelConfig | HierarchicalPreset>;
+/**
+ * Mode preset containing configurations for both opencode and oh-my-opencode agents.
+ *
+ * Both opencode and oh-my-opencode use the same HierarchicalPreset type,
+ * allowing them to have arbitrary nested structures that are handled
+ * uniformly by recursive merge functions.
  */
 export interface ModePreset {
     description: string;
     model?: string;
-    opencode: Record<string, AgentPreset>;
-    'oh-my-opencode': Record<string, AgentPreset>;
+    opencode: HierarchicalPreset;
+    'oh-my-opencode': HierarchicalPreset;
 }
 /**
  * Main configuration for the mode switcher plugin
@@ -23,6 +44,9 @@ export interface ModeSwitcherConfig {
 }
 /**
  * OpenCode agent configuration structure in opencode.json
+ *
+ * @deprecated This type is kept for backward compatibility but may not
+ * accurately represent the actual structure. Use ModelConfig directly.
  */
 export interface OpencodeAgentConfig {
     model?: string;
@@ -31,17 +55,21 @@ export interface OpencodeAgentConfig {
 }
 /**
  * OpenCode configuration file structure
+ *
+ * Supports arbitrary properties beyond the documented ones.
  */
 export interface OpencodeConfig {
     model?: string;
-    agent?: Record<string, OpencodeAgentConfig>;
+    agent?: HierarchicalPreset;
     [key: string]: unknown;
 }
 /**
  * Oh-my-opencode configuration file structure
+ *
+ * Supports arbitrary properties and nested structures like
+ * agents, categories, and any future sections.
  */
 export interface OhMyOpencodeConfig {
-    agents?: Record<string, AgentPreset>;
     [key: string]: unknown;
 }
 /**

package/dist/index.js

@@ -1,12 +1,16 @@
 // @bun
 var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
       get: all[name],
       enumerable: true,
       configurable: true,
-      set: (newValue) => all[name] = () => newValue
+      set: __exportSetter.bind(all, name)
     });
 };
 
@@ -12332,6 +12336,10 @@ function tool(input) {
 tool.schema = exports_external;
 // src/config/types.ts
 var DEFAULT_ECONOMY_MODEL = "opencode/glm-4.7-free";
+// src/config/guards.ts
+function isObject2(obj) {
+  return typeof obj === "object" && obj !== null && !Array.isArray(obj);
+}
 // src/config/loader.ts
 import { homedir } from "os";
 import { join } from "path";
@@ -13795,35 +13803,29 @@ async function pluginConfigExists() {
   return Bun.file(getPluginConfigPath()).exists();
 }
 // src/config/initializer.ts
-var OPENCODE_AGENTS = [
-  "build",
-  "plan",
-  "summary",
-  "compaction",
-  "title",
-  "explore",
-  "general"
-];
-async function buildPerformancePreset() {
-  const opencodeConfig = await loadOpencodeConfig();
-  const ohMyOpencodeConfig = await loadOhMyOpencodeConfig();
-  const opencodePreset = {};
-  const ohMyOpencodePreset = {};
-  if (opencodeConfig?.agent) {
-    for (const agentName of OPENCODE_AGENTS) {
-      const agentConfig = opencodeConfig.agent[agentName];
-      if (agentConfig?.model) {
-        opencodePreset[agentName] = { model: agentConfig.model };
-      }
-    }
-  }
-  if (ohMyOpencodeConfig?.agents) {
-    for (const [agentName, agentConfig] of Object.entries(ohMyOpencodeConfig.agents)) {
-      if (agentConfig?.model) {
-        ohMyOpencodePreset[agentName] = { model: agentConfig.model };
+function applyEconomyModel(config2, economyModel) {
+  const result = {};
+  for (const [key, value] of Object.entries(config2)) {
+    if (isObject2(value)) {
+      if ("model" in value) {
+        result[key] = {
+          ...value,
+          model: economyModel
+        };
+      } else {
+        result[key] = applyEconomyModel(value, economyModel);
       }
+    } else {
+      result[key] = value;
     }
   }
+  return result;
+}
+async function buildPerformancePreset() {
+  const opencodeConfig = await loadOpencodeConfig();
+  const ohMyOpencodeConfig = await loadOhMyOpencodeConfig();
+  const opencodePreset = opencodeConfig?.agent || {};
+  const ohMyOpencodePreset = ohMyOpencodeConfig || {};
   const globalModel = opencodeConfig?.model;
   return {
     description: "High-performance models for complex tasks",
@@ -13835,22 +13837,8 @@ async function buildPerformancePreset() {
 async function buildEconomyPreset() {
   const opencodeConfig = await loadOpencodeConfig();
   const ohMyOpencodeConfig = await loadOhMyOpencodeConfig();
-  const opencodePreset = {};
-  const ohMyOpencodePreset = {};
-  if (opencodeConfig?.agent) {
-    for (const agentName of Object.keys(opencodeConfig.agent)) {
-      opencodePreset[agentName] = { model: DEFAULT_ECONOMY_MODEL };
-    }
-  } else {
-    for (const agentName of OPENCODE_AGENTS) {
-      opencodePreset[agentName] = { model: DEFAULT_ECONOMY_MODEL };
-    }
-  }
-  if (ohMyOpencodeConfig?.agents) {
-    for (const agentName of Object.keys(ohMyOpencodeConfig.agents)) {
-      ohMyOpencodePreset[agentName] = { model: DEFAULT_ECONOMY_MODEL };
-    }
-  }
+  const opencodePreset = applyEconomyModel(opencodeConfig?.agent || {}, DEFAULT_ECONOMY_MODEL);
+  const ohMyOpencodePreset = applyEconomyModel(ohMyOpencodeConfig || {}, DEFAULT_ECONOMY_MODEL);
   return {
     description: "Cost-efficient free model for routine tasks",
     model: DEFAULT_ECONOMY_MODEL,
@@ -13884,7 +13872,7 @@ import { copyFileSync, existsSync, mkdirSync, readdirSync } from "fs";
 import { homedir as homedir2 } from "os";
 import { dirname, join as join2 } from "path";
 import { fileURLToPath } from "url";
-var COMMANDS_DEST = join2(homedir2(), ".config", "opencode", "command");
+var COMMANDS_DEST = join2(homedir2(), ".config", "opencode", "commands");
 function findCommandsDir() {
   const __dirname2 = dirname(fileURLToPath(import.meta.url));
   const candidates = [
@@ -13911,6 +13899,69 @@ function copyCommandFiles() {
   }
 }
 // src/modes/manager.ts
+function isLeafNode(value) {
+  return "model" in value && typeof value.model === "string";
+}
+function deepMergeModel(target, preset) {
+  for (const [key, value] of Object.entries(preset)) {
+    if (!isObject2(value))
+      continue;
+    const actualValue = target[key];
+    if (isLeafNode(value)) {
+      const valueRecord = value;
+      const existing = actualValue ?? {};
+      const merged = {
+        ...existing,
+        ...valueRecord
+      };
+      target[key] = merged;
+    } else {
+      const childTarget = actualValue ?? {};
+      target[key] = childTarget;
+      deepMergeModel(childTarget, value);
+    }
+  }
+}
+function hasDriftRecursive(actual, expected) {
+  for (const [key, expectedValue] of Object.entries(expected)) {
+    if (!isObject2(expectedValue))
+      continue;
+    const actualValue = actual[key];
+    if (isLeafNode(expectedValue)) {
+      const actualObj = actualValue;
+      if (!actualObj) {
+        return true;
+      }
+      for (const [propKey, expectedPropValue] of Object.entries(expectedValue)) {
+        if (actualObj[propKey] !== expectedPropValue) {
+          return true;
+        }
+      }
+    } else if (hasDriftRecursive(actualValue || {}, expectedValue)) {
+      return true;
+    }
+  }
+  return false;
+}
+function formatHierarchicalTree(preset, indent = "  ") {
+  const lines = [];
+  for (const [key, value] of Object.entries(preset)) {
+    if (!isObject2(value))
+      continue;
+    if (isLeafNode(value)) {
+      const variant = value.variant ? ` (${value.variant})` : "";
+      const otherProps = Object.keys(value).filter((k) => k !== "model" && k !== "variant").map((k) => `${k}: ${JSON.stringify(value[k])}`).join(", ");
+      const extra = otherProps ? ` [${otherProps}]` : "";
+      lines.push(`${indent}${key}: ${value.model}${variant}${extra}`);
+    } else {
+      lines.push(`${indent}${key}:`);
+      lines.push(formatHierarchicalTree(value, `${indent}  `));
+    }
+  }
+  return lines.join(`
+`);
+}
+
 class ModeManager {
   client;
   config = null;
@@ -13953,26 +14004,17 @@ class ModeManager {
   async hasConfigDrift(preset) {
     const opencodeConfig = await loadOpencodeConfig();
     const ohMyConfig = await loadOhMyOpencodeConfig();
-    if (preset.model && opencodeConfig) {
-      if (opencodeConfig.model !== preset.model) {
-        return true;
-      }
+    if (!opencodeConfig && !ohMyConfig) {
+      return false;
     }
-    if (opencodeConfig?.agent) {
-      for (const [agentName, agentPreset] of Object.entries(preset.opencode)) {
-        const actual = opencodeConfig.agent[agentName];
-        if (actual?.model !== agentPreset.model) {
-          return true;
-        }
-      }
+    if (preset.model && opencodeConfig?.model !== preset.model) {
+      return true;
     }
-    if (ohMyConfig?.agents) {
-      for (const [agentName, agentPreset] of Object.entries(preset["oh-my-opencode"])) {
-        const actual = ohMyConfig.agents[agentName];
-        if (actual?.model !== agentPreset.model) {
-          return true;
-        }
-      }
+    if (opencodeConfig?.agent && hasDriftRecursive(opencodeConfig.agent, preset.opencode)) {
+      return true;
+    }
+    if (ohMyConfig && hasDriftRecursive(ohMyConfig, preset["oh-my-opencode"])) {
+      return true;
     }
     return false;
   }
@@ -14003,20 +14045,18 @@ ${modes}`;
       return `Current mode: ${currentMode} (preset not found)`;
     }
     const globalModel = preset.model ? `Global model: ${preset.model}` : "Global model: (not set)";
-    const opencodeAgents = Object.entries(preset.opencode).map(([name, cfg]) => `  - ${name}: ${cfg.model}`).join(`
-`);
-    const ohMyOpencodeAgents = Object.entries(preset["oh-my-opencode"]).map(([name, cfg]) => `  - ${name}: ${cfg.model}`).join(`
-`);
+    const opencodeTree = formatHierarchicalTree(preset.opencode);
+    const ohMyOpencodeTree = formatHierarchicalTree(preset["oh-my-opencode"]);
     return [
       `Current mode: ${currentMode}`,
       `Description: ${preset.description}`,
       globalModel,
       "",
-      "OpenCode agents:",
-      opencodeAgents || "  (none configured)",
+      "OpenCode config:",
+      opencodeTree || "  (none configured)",
       "",
-      "Oh-my-opencode agents:",
-      ohMyOpencodeAgents || "  (none configured)"
+      "Oh-my-opencode config:",
+      ohMyOpencodeTree || "  (none configured)"
     ].join(`
 `);
   }
@@ -14036,16 +14076,14 @@ ${modes}`;
     this.config = config2;
     await savePluginConfig(config2);
     results.push("agent-mode-switcher.json: updated");
-    try {
-      await this.client.tui.showToast({
-        body: {
-          title: "Mode Switched",
-          message: `Switched to "${modeName}". Restart opencode to apply.`,
-          variant: "warning",
-          duration: 5000
-        }
-      });
-    } catch {}
+    this.client.tui.showToast({
+      body: {
+        title: "Mode Switched",
+        message: `Switched to "${modeName}". Restart opencode to apply.`,
+        variant: "warning",
+        duration: 5000
+      }
+    }).catch(() => {});
     return [
       `Switched to ${modeName} mode`,
       preset.description,
@@ -14067,12 +14105,7 @@ ${modes}`;
         opencodeConfig.model = globalModel;
       }
       opencodeConfig.agent = opencodeConfig.agent || {};
-      for (const [agentName, preset] of Object.entries(agentPresets)) {
-        opencodeConfig.agent[agentName] = {
-          ...opencodeConfig.agent[agentName],
-          model: preset.model
-        };
-      }
+      deepMergeModel(opencodeConfig.agent, agentPresets);
       await saveOpencodeConfig(opencodeConfig);
       return "updated";
     } catch (error45) {
@@ -14080,16 +14113,13 @@ ${modes}`;
       return `error: ${message}`;
     }
   }
-  async updateOhMyOpencodeConfig(agentPresets) {
+  async updateOhMyOpencodeConfig(preset) {
     try {
       const ohMyConfig = await loadOhMyOpencodeConfig();
       if (!ohMyConfig) {
         return "skipped (not found)";
       }
-      ohMyConfig.agents = ohMyConfig.agents || {};
-      for (const [agentName, preset] of Object.entries(agentPresets)) {
-        ohMyConfig.agents[agentName] = { model: preset.model };
-      }
+      deepMergeModel(ohMyConfig, preset);
       await saveOhMyOpencodeConfig(ohMyConfig);
       return "updated";
     } catch (error45) {

package/dist/modes/manager.d.ts

@@ -76,7 +76,7 @@ export declare class ModeManager {
      * Compares a mode preset against the actual opencode.json and
      * oh-my-opencode.json files to detect configuration drift.
      *
-     * Checks global model and per-agent model values. Returns true
+     * Checks global model and per-agent model values recursively. Returns true
      * if any expected value differs from the actual file content.
      *
      * @param preset - The mode preset to compare against
@@ -134,8 +134,8 @@ export declare class ModeManager {
      * Returns a formatted multi-line string showing:
      * - Current mode name and description
      * - Global model setting (if configured)
-     * - All OpenCode agents and their assigned models
-     * - All oh-my-opencode agents and their assigned models
+     * - Hierarchical tree of OpenCode configuration
+     * - Hierarchical tree of oh-my-opencode configuration
      *
      * @returns Promise resolving to formatted status string
      * @example
@@ -147,9 +147,10 @@ export declare class ModeManager {
      * // Description: High-performance models for complex tasks
      * // Global model: (not set)
      * //
-     * // OpenCode agents:
-     * //   - build: anthropic/claude-sonnet-4
-     * //   - plan: anthropic/claude-sonnet-4
+     * // OpenCode config:
+     * //   agent:
+     * //     build: anthropic/claude-sonnet-4
+     * //     plan: anthropic/claude-sonnet-4
      * // ...
      * ```
      */
@@ -191,22 +192,23 @@ export declare class ModeManager {
      *
      * This internal method modifies the OpenCode configuration file to apply
      * the new preset's settings. It preserves other configuration properties
-     * and only updates model-related fields.
+     * and only updates model-related fields using recursive merge.
      *
      * @param globalModel - Global model setting (optional). If provided, sets the top-level "model" field
-     * @param agentPresets - Agent-specific model settings. Keys are agent names, values contain model strings
+     * @param agentPresets - Hierarchical preset structure for agent configuration
      * @returns Promise resolving to result status: "updated", "skipped (not found)", or "error: ..."
      * @private
      */
     private updateOpencodeConfig;
     /**
-     * Updates oh-my-opencode.json agents section with preset values.
+     * Updates oh-my-opencode.json with preset values.
      *
      * This internal method modifies the oh-my-opencode configuration file
-     * to apply the new preset's agent settings. Unlike opencode.json, this
-     * only updates the agents section and doesn't set a global model.
+     * to apply the new preset's settings using recursive merge. The entire
+     * structure (agents, categories, etc.) is updated while preserving
+     * other properties.
      *
-     * @param agentPresets - Agent-specific model settings. Keys are agent names, values contain model strings
+     * @param preset - Hierarchical preset structure for oh-my-opencode configuration
      * @returns Promise resolving to result status: "updated", "skipped (not found)", or "error: ..."
      * @private
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-agent-modes",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "description": "OpenCode plugin to switch agent modes between performance and economy presets",
   "module": "src/index.ts",
   "main": "dist/index.js",