micode 0.8.3 → 0.8.5

package/src/config-loader.test.ts

@@ -0,0 +1,226 @@
+// src/config-loader.test.ts
+import { describe, expect, test } from "bun:test";
+
+import { type MicodeConfig, type ProviderInfo, validateAgentModels } from "./config-loader";
+
+// Helper to create a minimal ProviderInfo for testing
+function createProvider(id: string, modelIds: string[]): ProviderInfo {
+  const models: Record<string, unknown> = {};
+  for (const modelId of modelIds) {
+    models[modelId] = { id: modelId };
+  }
+  return { id, models };
+}
+
+describe("validateAgentModels", () => {
+  test("returns config unchanged when all models are valid", () => {
+    const userConfig: MicodeConfig = {
+      agents: {
+        commander: { model: "openai/gpt-4" },
+        brainstormer: { model: "anthropic/claude-3" },
+      },
+    };
+
+    const providers: ProviderInfo[] = [
+      createProvider("openai", ["gpt-4", "gpt-3.5"]),
+      createProvider("anthropic", ["claude-3", "claude-2"]),
+    ];
+
+    const result = validateAgentModels(userConfig, providers);
+
+    expect(result.agents?.commander?.model).toBe("openai/gpt-4");
+    expect(result.agents?.brainstormer?.model).toBe("anthropic/claude-3");
+  });
+
+  test("removes model override when provider does not exist", () => {
+    const userConfig: MicodeConfig = {
+      agents: {
+        commander: { model: "nonexistent/gpt-4" },
+      },
+    };
+
+    const providers: ProviderInfo[] = [createProvider("openai", ["gpt-4"])];
+
+    const result = validateAgentModels(userConfig, providers);
+
+    // Model should be removed, falling back to default
+    expect(result.agents?.commander?.model).toBeUndefined();
+  });
+
+  test("removes model override when model does not exist in provider", () => {
+    const userConfig: MicodeConfig = {
+      agents: {
+        commander: { model: "openai/nonexistent-model" },
+      },
+    };
+
+    const providers: ProviderInfo[] = [createProvider("openai", ["gpt-4", "gpt-3.5"])];
+
+    const result = validateAgentModels(userConfig, providers);
+
+    // Model should be removed, falling back to default
+    expect(result.agents?.commander?.model).toBeUndefined();
+  });
+
+  test("preserves other properties when model is invalid", () => {
+    const userConfig: MicodeConfig = {
+      agents: {
+        commander: {
+          model: "nonexistent/model",
+          temperature: 0.7,
+          maxTokens: 4000,
+        },
+      },
+    };
+
+    const providers: ProviderInfo[] = [createProvider("openai", ["gpt-4"])];
+
+    const result = validateAgentModels(userConfig, providers);
+
+    // Model removed but other properties preserved
+    expect(result.agents?.commander?.model).toBeUndefined();
+    expect(result.agents?.commander?.temperature).toBe(0.7);
+    expect(result.agents?.commander?.maxTokens).toBe(4000);
+  });
+
+  test("handles config with no agents", () => {
+    const userConfig: MicodeConfig = {};
+
+    const providers: ProviderInfo[] = [createProvider("openai", ["gpt-4"])];
+
+    const result = validateAgentModels(userConfig, providers);
+
+    expect(result).toEqual({});
+  });
+
+  test("handles agent override with no model specified", () => {
+    const userConfig: MicodeConfig = {
+      agents: {
+        commander: { temperature: 0.5 },
+      },
+    };
+
+    const providers: ProviderInfo[] = [createProvider("openai", ["gpt-4"])];
+
+    const result = validateAgentModels(userConfig, providers);
+
+    // No model to validate, config unchanged
+    expect(result.agents?.commander?.temperature).toBe(0.5);
+    expect(result.agents?.commander?.model).toBeUndefined();
+  });
+
+  test("handles empty providers list", () => {
+    const userConfig: MicodeConfig = {
+      agents: {
+        commander: { model: "openai/gpt-4" },
+      },
+    };
+
+    const providers: ProviderInfo[] = [];
+
+    const result = validateAgentModels(userConfig, providers);
+
+    // No providers available, config should remain unchanged
+    expect(result).toEqual(userConfig);
+  });
+
+  test("handles providers with no models", () => {
+    const userConfig: MicodeConfig = {
+      agents: {
+        commander: { model: "openai/gpt-4" },
+      },
+    };
+
+    const providers: ProviderInfo[] = [{ id: "openai", models: {} }];
+
+    const result = validateAgentModels(userConfig, providers);
+
+    // No provider models available, config should remain unchanged
+    expect(result).toEqual(userConfig);
+  });
+
+  test("validates multiple agents with mixed valid/invalid models", () => {
+    const userConfig: MicodeConfig = {
+      agents: {
+        commander: { model: "openai/gpt-4" }, // valid
+        brainstormer: { model: "fake/model" }, // invalid provider
+        planner: { model: "openai/fake-model" }, // invalid model
+        reviewer: { model: "anthropic/claude-3" }, // valid
+      },
+    };
+
+    const providers: ProviderInfo[] = [
+      createProvider("openai", ["gpt-4", "gpt-3.5"]),
+      createProvider("anthropic", ["claude-3"]),
+    ];
+
+    const result = validateAgentModels(userConfig, providers);
+
+    expect(result.agents?.commander?.model).toBe("openai/gpt-4");
+    expect(result.agents?.brainstormer?.model).toBeUndefined();
+    expect(result.agents?.planner?.model).toBeUndefined();
+    expect(result.agents?.reviewer?.model).toBe("anthropic/claude-3");
+  });
+
+  test("removes empty string model", () => {
+    const userConfig: MicodeConfig = {
+      agents: {
+        commander: { model: "", temperature: 0.5 },
+      },
+    };
+
+    const providers: ProviderInfo[] = [createProvider("openai", ["gpt-4"])];
+
+    const result = validateAgentModels(userConfig, providers);
+
+    // Empty string model should be removed as invalid
+    expect(result.agents?.commander?.model).toBeUndefined();
+    expect(result.agents?.commander?.temperature).toBe(0.5);
+  });
+
+  test("removes model string without slash (malformed)", () => {
+    const userConfig: MicodeConfig = {
+      agents: {
+        commander: { model: "gpt-4-no-provider" },
+      },
+    };
+
+    const providers: ProviderInfo[] = [createProvider("openai", ["gpt-4"])];
+
+    const result = validateAgentModels(userConfig, providers);
+
+    // Malformed model (no slash) should be removed
+    expect(result.agents?.commander?.model).toBeUndefined();
+  });
+
+  test("handles model with multiple slashes in model ID", () => {
+    const userConfig: MicodeConfig = {
+      agents: {
+        commander: { model: "openai/gpt-4/turbo" },
+      },
+    };
+
+    // Model ID is "gpt-4/turbo" (contains slash)
+    const providers: ProviderInfo[] = [createProvider("openai", ["gpt-4/turbo"])];
+
+    const result = validateAgentModels(userConfig, providers);
+
+    // Should be valid - "gpt-4/turbo" is the full model ID
+    expect(result.agents?.commander?.model).toBe("openai/gpt-4/turbo");
+  });
+
+  test("returns consistent shape when all agents have invalid models", () => {
+    const userConfig: MicodeConfig = {
+      agents: {
+        commander: { model: "invalid/model" },
+      },
+    };
+
+    const providers: ProviderInfo[] = [createProvider("openai", ["gpt-4"])];
+
+    const result = validateAgentModels(userConfig, providers);
+
+    // Should return { agents: {} } for consistency, not {}
+    expect(result).toEqual({ agents: {} });
+  });
+});

package/src/config-loader.ts

@@ -1,9 +1,46 @@
 // src/config-loader.ts
+import { readFileSync } from "node:fs";
 import { readFile } from "node:fs/promises";
-import { join } from "node:path";
 import { homedir } from "node:os";
+import { join } from "node:path";
+
 import type { AgentConfig } from "@opencode-ai/sdk";
 
+// Minimal type for provider validation - only what we need
+export interface ProviderInfo {
+  id: string;
+  models: Record<string, unknown>;
+}
+
+/**
+ * Load available models from opencode.json config file (synchronous)
+ * Returns a Set of "provider/model" strings
+ */
+export function loadAvailableModels(configDir?: string): Set<string> {
+  const availableModels = new Set<string>();
+  const baseDir = configDir ?? join(homedir(), ".config", "opencode");
+
+  try {
+    const configPath = join(baseDir, "opencode.json");
+    const content = readFileSync(configPath, "utf-8");
+    const config = JSON.parse(content) as { provider?: Record<string, { models?: Record<string, unknown> }> };
+
+    if (config.provider) {
+      for (const [providerId, providerConfig] of Object.entries(config.provider)) {
+        if (providerConfig.models) {
+          for (const modelId of Object.keys(providerConfig.models)) {
+            availableModels.add(`${providerId}/${modelId}`);
+          }
+        }
+      }
+    }
+  } catch {
+    // Config doesn't exist or can't be parsed - return empty set
+  }
+
+  return availableModels;
+}
+
 // Safe properties that users can override
 const SAFE_AGENT_PROPERTIES = ["model", "temperature", "maxTokens"] as const;
 
@@ -60,26 +97,53 @@ export async function loadMicodeConfig(configDir?: string): Promise<MicodeConfig
 
 /**
  * Merge user config overrides into plugin agent configs
- * User overrides take precedence for safe properties only
+ * Model overrides are validated against available models from opencode.json
+ * Invalid models are logged and skipped (agent uses opencode default)
  */
 export function mergeAgentConfigs(
   pluginAgents: Record<string, AgentConfig>,
   userConfig: MicodeConfig | null,
+  availableModels?: Set<string>,
 ): Record<string, AgentConfig> {
   if (!userConfig?.agents) {
     return pluginAgents;
   }
 
+  const models = availableModels ?? loadAvailableModels();
+  const shouldValidateModels = models.size > 0;
+
   const merged: Record<string, AgentConfig> = {};
 
   for (const [name, agentConfig] of Object.entries(pluginAgents)) {
     const userOverride = userConfig.agents[name];
 
     if (userOverride) {
-      merged[name] = {
-        ...agentConfig,
-        ...userOverride,
-      };
+      // Validate model if specified
+      if (userOverride.model) {
+        if (!shouldValidateModels || models.has(userOverride.model)) {
+          // Model is valid (or validation unavailable) - apply all overrides
+          merged[name] = {
+            ...agentConfig,
+            ...userOverride,
+          };
+        } else {
+          // Model is invalid - log warning and apply other overrides only
+          console.warn(
+            `[micode] Model "${userOverride.model}" for agent "${name}" is not available. Using opencode default.`,
+          );
+          const { model: _ignored, ...safeOverrides } = userOverride;
+          merged[name] = {
+            ...agentConfig,
+            ...safeOverrides,
+          };
+        }
+      } else {
+        // No model specified - apply all overrides
+        merged[name] = {
+          ...agentConfig,
+          ...userOverride,
+        };
+      }
     } else {
       merged[name] = agentConfig;
     }
@@ -87,3 +151,65 @@ export function mergeAgentConfigs(
 
   return merged;
 }
+
+/**
+ * Validate that configured models exist in available providers
+ * Removes invalid model overrides and logs warnings
+ */
+export function validateAgentModels(userConfig: MicodeConfig, providers: ProviderInfo[]): MicodeConfig {
+  if (!userConfig.agents) {
+    return userConfig;
+  }
+
+  const hasAnyModels = providers.some((provider) => Object.keys(provider.models).length > 0);
+  if (!hasAnyModels) {
+    return userConfig;
+  }
+
+  // Build lookup map for providers and their models
+  const providerMap = new Map<string, Set<string>>();
+  for (const provider of providers) {
+    providerMap.set(provider.id, new Set(Object.keys(provider.models)));
+  }
+
+  const validatedAgents: Record<string, AgentOverride> = {};
+
+  for (const [agentName, override] of Object.entries(userConfig.agents)) {
+    // No model specified - keep other properties as-is
+    if (override.model === undefined) {
+      validatedAgents[agentName] = override;
+      continue;
+    }
+
+    // Empty or whitespace-only model - treat as invalid
+    const trimmedModel = override.model.trim();
+    if (!trimmedModel) {
+      const { model: _removed, ...otherProps } = override;
+      console.warn(`[micode] Empty model for agent "${agentName}". Using default model.`);
+      if (Object.keys(otherProps).length > 0) {
+        validatedAgents[agentName] = otherProps;
+      }
+      continue;
+    }
+
+    // Parse "provider/model" format
+    const [providerID, ...rest] = trimmedModel.split("/");
+    const modelID = rest.join("/");
+
+    const providerModels = providerMap.get(providerID);
+    const isValid = providerModels?.has(modelID) ?? false;
+
+    if (isValid) {
+      validatedAgents[agentName] = override;
+    } else {
+      // Remove invalid model but keep other properties
+      const { model: _removed, ...otherProps } = override;
+      console.warn(`[micode] Model "${override.model}" not found for agent "${agentName}". Using default model.`);
+      if (Object.keys(otherProps).length > 0) {
+        validatedAgents[agentName] = otherProps;
+      }
+    }
+  }
+
+  return { agents: validatedAgents };
+}

package/src/hooks/artifact-auto-index.ts

@@ -4,6 +4,7 @@
 import type { PluginInput } from "@opencode-ai/plugin";
 import { readFileSync } from "node:fs";
 import { getArtifactIndex } from "../tools/artifact-index";
+import { log } from "../utils/logger";
 
 const LEDGER_PATH_PATTERN = /thoughts\/ledgers\/CONTINUITY_(.+)\.md$/;
 const PLAN_PATH_PATTERN = /thoughts\/shared\/plans\/(.+)\.md$/;
@@ -102,7 +103,7 @@ export function createArtifactAutoIndexHook(_ctx: PluginInput) {
         }
       } catch (e) {
         // Silent failure - don't interrupt user flow
-        console.error(`[artifact-auto-index] Error indexing ${filePath}:`, e);
+        log.error("artifact-auto-index", `Error indexing ${filePath}`, e);
       }
     },
   };

package/src/hooks/auto-compact.ts

@@ -1,15 +1,11 @@
-import type { PluginInput } from "@opencode-ai/plugin";
-import { getContextLimit } from "../utils/model-limits";
 import { mkdir, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 
-// Compact when this percentage of context is used
-const COMPACT_THRESHOLD = 0.5;
-
-const LEDGER_DIR = "thoughts/ledgers";
+import type { PluginInput } from "@opencode-ai/plugin";
 
-// Timeout for waiting for compaction to complete (2 minutes)
-const COMPACTION_TIMEOUT_MS = 120_000;
+import { config } from "../utils/config";
+import { extractErrorMessage } from "../utils/errors";
+import { getContextLimit } from "../utils/model-limits";
 
 interface PendingCompaction {
   resolve: () => void;
@@ -23,9 +19,6 @@ interface AutoCompactState {
   pendingCompactions: Map<string, PendingCompaction>;
 }
 
-// Cooldown between compaction attempts (prevent rapid re-triggering)
-const COMPACT_COOLDOWN_MS = 30_000; // 30 seconds
-
 export function createAutoCompactHook(ctx: PluginInput) {
   const state: AutoCompactState = {
     inProgress: new Set(),
@@ -65,13 +58,13 @@ export function createAutoCompactHook(ctx: PluginInput) {
       if (!summaryText.trim()) return;
 
       // Create ledger directory if needed
-      const ledgerDir = join(ctx.directory, LEDGER_DIR);
+      const ledgerDir = join(ctx.directory, config.paths.ledgerDir);
       await mkdir(ledgerDir, { recursive: true });
 
       // Write ledger file - summary is already structured (Factory.ai/pi-mono format)
       const timestamp = new Date().toISOString();
       const sessionName = sessionID.slice(0, 8); // Use first 8 chars of session ID
-      const ledgerPath = join(ledgerDir, `CONTINUITY_${sessionName}.md`);
+      const ledgerPath = join(ledgerDir, `${config.paths.ledgerPrefix}${sessionName}.md`);
 
       // Add metadata header, then the structured summary as-is
       const ledgerContent = `---
@@ -94,7 +87,7 @@ ${summaryText}
       const timeoutId = setTimeout(() => {
         state.pendingCompactions.delete(sessionID);
         reject(new Error("Compaction timed out"));
-      }, COMPACTION_TIMEOUT_MS);
+      }, config.compaction.timeoutMs);
 
       state.pendingCompactions.set(sessionID, { resolve, reject, timeoutId });
     });
@@ -112,7 +105,7 @@ ${summaryText}
 
     // Check cooldown
     const lastCompact = state.lastCompactTime.get(sessionID) || 0;
-    if (Date.now() - lastCompact < COMPACT_COOLDOWN_MS) {
+    if (Date.now() - lastCompact < config.compaction.cooldownMs) {
       return;
     }
 
@@ -120,7 +113,7 @@ ${summaryText}
 
     try {
       const usedPercent = Math.round(usageRatio * 100);
-      const thresholdPercent = Math.round(COMPACT_THRESHOLD * 100);
+      const thresholdPercent = Math.round(config.compaction.threshold * 100);
 
       await ctx.client.tui
         .showToast({
@@ -128,7 +121,7 @@ ${summaryText}
             title: "Auto Compacting",
             message: `Context at ${usedPercent}% (threshold: ${thresholdPercent}%). Summarizing...`,
             variant: "warning",
-            duration: 3000,
+            duration: config.timeouts.toastWarningMs,
           },
         })
         .catch(() => {});
@@ -158,19 +151,19 @@ ${summaryText}
             title: "Compaction Complete",
             message: "Session summarized and ledger updated.",
             variant: "success",
-            duration: 3000,
+            duration: config.timeouts.toastSuccessMs,
           },
         })
         .catch(() => {});
     } catch (e) {
-      const errorMsg = e instanceof Error ? e.message : String(e);
+      const errorMsg = extractErrorMessage(e);
       await ctx.client.tui
         .showToast({
           body: {
             title: "Compaction Failed",
             message: errorMsg.slice(0, 100),
             variant: "error",
-            duration: 5000,
+            duration: config.timeouts.toastErrorMs,
           },
         })
         .catch(() => {});
@@ -233,7 +226,7 @@ ${summaryText}
         const usageRatio = totalUsed / contextLimit;
 
         // Trigger compaction if over threshold
-        if (usageRatio >= COMPACT_THRESHOLD) {
+        if (usageRatio >= config.compaction.threshold) {
           triggerCompaction(sessionID, providerID, modelID, usageRatio);
         }
       }

package/src/hooks/context-injector.ts

@@ -1,12 +1,7 @@
 import type { PluginInput } from "@opencode-ai/plugin";
 import { readFile } from "node:fs/promises";
 import { join, dirname, resolve } from "node:path";
-
-// Files to inject at project root level (AGENTS.md and CLAUDE.md handled by OpenCode natively)
-const ROOT_CONTEXT_FILES = ["ARCHITECTURE.md", "CODE_STYLE.md", "README.md"] as const;
-
-// Files to collect when walking up directories (AGENTS.md handled by OpenCode natively)
-const DIRECTORY_CONTEXT_FILES = ["README.md"] as const;
+import { config } from "../utils/config";
 
 // Tools that trigger directory-aware context injection
 const FILE_ACCESS_TOOLS = ["Read", "read", "Edit", "edit"];
@@ -18,8 +13,6 @@ interface ContextCache {
   lastRootCheck: number;
 }
 
-const CACHE_TTL = 30_000; // 30 seconds
-
 export function createContextInjectorHook(ctx: PluginInput) {
   const cache: ContextCache = {
     rootContent: new Map(),
@@ -30,14 +23,14 @@ export function createContextInjectorHook(ctx: PluginInput) {
   async function loadRootContextFiles(): Promise<Map<string, string>> {
     const now = Date.now();
 
-    if (now - cache.lastRootCheck < CACHE_TTL && cache.rootContent.size > 0) {
+    if (now - cache.lastRootCheck < config.limits.contextCacheTtlMs && cache.rootContent.size > 0) {
       return cache.rootContent;
     }
 
     cache.rootContent.clear();
     cache.lastRootCheck = now;
 
-    for (const filename of ROOT_CONTEXT_FILES) {
+    for (const filename of config.paths.rootContextFiles) {
       try {
         const filepath = join(ctx.directory, filename);
         const content = await readFile(filepath, "utf-8");
@@ -67,7 +60,7 @@ export function createContextInjectorHook(ctx: PluginInput) {
 
     // Walk up from file directory to project root
     while (currentDir.startsWith(projectRoot) || currentDir === projectRoot) {
-      for (const filename of DIRECTORY_CONTEXT_FILES) {
+      for (const filename of config.paths.dirContextFiles) {
         const contextPath = join(currentDir, filename);
         const relPath = currentDir.replace(projectRoot, "").replace(/^\//, "") || ".";
         const key = `${relPath}/${filename}`;
@@ -98,7 +91,7 @@ export function createContextInjectorHook(ctx: PluginInput) {
     cache.directoryContent.set(cacheKey, collected);
 
     // Limit cache size
-    if (cache.directoryContent.size > 100) {
+    if (cache.directoryContent.size > config.limits.contextCacheMaxSize) {
       const firstKey = cache.directoryContent.keys().next().value;
       if (firstKey) cache.directoryContent.delete(firstKey);
     }
@@ -143,7 +136,7 @@ export function createContextInjectorHook(ctx: PluginInput) {
     ) => {
       if (!FILE_ACCESS_TOOLS.includes(input.tool)) return;
 
-      const filePath = input.args?.file_path as string | undefined;
+      const filePath = input.args?.filePath as string | undefined;
       if (!filePath) return;
 
       try {

package/src/hooks/context-window-monitor.ts

@@ -1,17 +1,12 @@
 import type { PluginInput } from "@opencode-ai/plugin";
+import { config } from "../utils/config";
 import { getContextLimit } from "../utils/model-limits";
 
-// Thresholds for context window warnings
-const WARNING_THRESHOLD = 0.7; // 70% - remind there's still room
-const CRITICAL_THRESHOLD = 0.85; // 85% - getting tight
-
 interface MonitorState {
   lastWarningTime: Map<string, number>;
   lastUsageRatio: Map<string, number>;
 }
 
-const WARNING_COOLDOWN_MS = 120_000; // 2 minutes between warnings
-
 export function createContextWindowMonitorHook(ctx: PluginInput) {
   const state: MonitorState = {
     lastWarningTime: new Map(),
@@ -21,11 +16,11 @@ export function createContextWindowMonitorHook(ctx: PluginInput) {
   function getEncouragementMessage(usageRatio: number): string {
     const remaining = Math.round((1 - usageRatio) * 100);
 
-    if (usageRatio < WARNING_THRESHOLD) {
+    if (usageRatio < config.contextWindow.warningThreshold) {
       return ""; // No message needed
     }
 
-    if (usageRatio < CRITICAL_THRESHOLD) {
+    if (usageRatio < config.contextWindow.criticalThreshold) {
       return `Context: ${remaining}% remaining. Plenty of room - don't rush.`;
     }
 
@@ -40,7 +35,7 @@ export function createContextWindowMonitorHook(ctx: PluginInput) {
     ) => {
       const usageRatio = state.lastUsageRatio.get(input.sessionID);
 
-      if (usageRatio && usageRatio >= WARNING_THRESHOLD) {
+      if (usageRatio && usageRatio >= config.contextWindow.warningThreshold) {
         const message = getEncouragementMessage(usageRatio);
         if (message && output.system) {
           output.system = `${output.system}\n\n<context-status>${message}</context-status>`;
@@ -80,13 +75,13 @@ export function createContextWindowMonitorHook(ctx: PluginInput) {
         state.lastUsageRatio.set(sessionID, usageRatio);
 
         // Show toast warning if threshold crossed
-        if (usageRatio >= WARNING_THRESHOLD) {
+        if (usageRatio >= config.contextWindow.warningThreshold) {
           const lastWarning = state.lastWarningTime.get(sessionID) || 0;
-          if (Date.now() - lastWarning > WARNING_COOLDOWN_MS) {
+          if (Date.now() - lastWarning > config.contextWindow.warningCooldownMs) {
             state.lastWarningTime.set(sessionID, Date.now());
 
             const remaining = Math.round((1 - usageRatio) * 100);
-            const variant = usageRatio >= CRITICAL_THRESHOLD ? "warning" : "info";
+            const variant = usageRatio >= config.contextWindow.criticalThreshold ? "warning" : "info";
 
             await ctx.client.tui
               .showToast({
@@ -94,7 +89,7 @@ export function createContextWindowMonitorHook(ctx: PluginInput) {
                   title: "Context Window",
                   message: `${remaining}% remaining (${Math.round(totalUsed / 1000)}K / ${Math.round(contextLimit / 1000)}K tokens)`,
                   variant,
-                  duration: 4000,
+                  duration: config.timeouts.toastWarningMs,
                 },
               })
               .catch(() => {});