micode 0.8.6 → 0.9.0

package/src/config-loader.ts

@@ -13,45 +13,80 @@ export interface ProviderInfo {
 }
 
 /**
- * Load available models from opencode.json config file (synchronous)
- * Returns a Set of "provider/model" strings
+ * OpenCode config structure for reading default model and available models
  */
-export function loadAvailableModels(configDir?: string): Set<string> {
-  const availableModels = new Set<string>();
+interface OpencodeConfig {
+  model?: string;
+  provider?: Record<string, { models?: Record<string, unknown> }>;
+}
+
+/**
+ * Load opencode.json config file (synchronous)
+ * Returns the parsed config or null if unavailable
+ */
+function loadOpencodeConfig(configDir?: string): OpencodeConfig | null {
   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> }> };
+    return JSON.parse(content) as OpencodeConfig;
+  } catch {
+    return null;
+  }
+}
 
-    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}`);
-          }
+/**
+ * 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 config = loadOpencodeConfig(configDir);
+
+  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;
 }
 
+/**
+ * Load the default model from opencode.json config file (synchronous)
+ * Returns the model string in "provider/model" format or null if not set
+ */
+export function loadDefaultModel(configDir?: string): string | null {
+  const config = loadOpencodeConfig(configDir);
+  return config?.model ?? null;
+}
+
 // Safe properties that users can override
 const SAFE_AGENT_PROPERTIES = ["model", "temperature", "maxTokens"] as const;
 
+// Built-in OpenCode models that don't require validation (always available)
+const BUILTIN_MODELS = new Set(["opencode/big-pickle"]);
+
 export interface AgentOverride {
   model?: string;
   temperature?: number;
   maxTokens?: number;
 }
 
+export interface MicodeFeatures {
+  mindmodelInjection?: boolean;
+}
+
 export interface MicodeConfig {
   agents?: Record<string, AgentOverride>;
+  features?: MicodeFeatures;
+  compactionThreshold?: number;
+  fragments?: Record<string, string[]>;
 }
 
 /**
@@ -67,7 +102,9 @@ export async function loadMicodeConfig(configDir?: string): Promise<MicodeConfig
     const content = await readFile(configPath, "utf-8");
     const parsed = JSON.parse(content) as Record<string, unknown>;
 
-    // Sanitize the config - only allow safe properties
+    const result: MicodeConfig = {};
+
+    // Sanitize agents - only allow safe properties
     if (parsed.agents && typeof parsed.agents === "object") {
       const sanitizedAgents: Record<string, AgentOverride> = {};
 
@@ -86,67 +123,143 @@ export async function loadMicodeConfig(configDir?: string): Promise<MicodeConfig
         }
       }
 
-      return { agents: sanitizedAgents };
+      result.agents = sanitizedAgents;
+    }
+
+    // Parse features
+    if (parsed.features && typeof parsed.features === "object") {
+      const features = parsed.features as Record<string, unknown>;
+      result.features = {
+        mindmodelInjection: features.mindmodelInjection === true,
+      };
+    }
+
+    // Parse compactionThreshold (must be number between 0 and 1)
+    if (typeof parsed.compactionThreshold === "number") {
+      const threshold = parsed.compactionThreshold;
+      if (threshold >= 0 && threshold <= 1) {
+        result.compactionThreshold = threshold;
+      }
+    }
+
+    // Parse fragments
+    if (parsed.fragments && typeof parsed.fragments === "object") {
+      const fragments = parsed.fragments as Record<string, unknown>;
+      const sanitizedFragments: Record<string, string[]> = {};
+
+      for (const [agentName, fragmentList] of Object.entries(fragments)) {
+        if (Array.isArray(fragmentList)) {
+          const validFragments = fragmentList.filter((f): f is string => typeof f === "string" && f.trim().length > 0);
+          if (validFragments.length > 0) {
+            sanitizedFragments[agentName] = validFragments;
+          }
+        }
+      }
+
+      result.fragments = sanitizedFragments;
     }
 
-    return parsed as MicodeConfig;
+    return result;
   } catch {
     return null;
   }
 }
 
+/**
+ * Load model context limits from opencode.json
+ * Returns a Map of "provider/model" -> context limit (tokens)
+ */
+export function loadModelContextLimits(configDir?: string): Map<string, number> {
+  const limits = new Map<string, number>();
+  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, { limit?: { context?: number } }> }>;
+    };
+
+    if (config.provider) {
+      for (const [providerId, providerConfig] of Object.entries(config.provider)) {
+        if (providerConfig.models) {
+          for (const [modelId, modelConfig] of Object.entries(providerConfig.models)) {
+            const contextLimit = modelConfig?.limit?.context;
+            if (typeof contextLimit === "number" && contextLimit > 0) {
+              limits.set(`${providerId}/${modelId}`, contextLimit);
+            }
+          }
+        }
+      }
+    }
+  } catch {
+    // Config doesn't exist or can't be parsed - return empty map
+  }
+
+  return limits;
+}
+
 /**
  * Merge user config overrides into plugin agent configs
  * Model overrides are validated against available models from opencode.json
  * Invalid models are logged and skipped (agent uses opencode default)
+ *
+ * Model resolution priority:
+ * 1. Per-agent override in micode.json (highest)
+ * 2. Default model from opencode.json "model" field
+ * 3. Plugin default (hardcoded in agent definitions)
  */
 export function mergeAgentConfigs(
   pluginAgents: Record<string, AgentConfig>,
   userConfig: MicodeConfig | null,
   availableModels?: Set<string>,
+  defaultModel?: string | null,
 ): Record<string, AgentConfig> {
-  if (!userConfig?.agents) {
-    return pluginAgents;
-  }
-
   const models = availableModels ?? loadAvailableModels();
   const shouldValidateModels = models.size > 0;
+  const opencodeDefaultModel = defaultModel ?? loadDefaultModel();
+
+  // Helper to validate a model string
+  const isValidModel = (model: string): boolean => {
+    if (BUILTIN_MODELS.has(model)) return true;
+    if (!shouldValidateModels) return true;
+    return models.has(model);
+  };
 
   const merged: Record<string, AgentConfig> = {};
 
   for (const [name, agentConfig] of Object.entries(pluginAgents)) {
-    const userOverride = userConfig.agents[name];
+    const userOverride = userConfig?.agents?.[name];
 
+    // Start with the base agent config
+    let finalConfig: AgentConfig = { ...agentConfig };
+
+    // Apply opencode default model if available and valid (overrides plugin default)
+    if (opencodeDefaultModel && isValidModel(opencodeDefaultModel)) {
+      finalConfig = { ...finalConfig, model: opencodeDefaultModel };
+    }
+
+    // Apply user overrides from micode.json (highest priority)
     if (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,
-          };
+        if (isValidModel(userOverride.model)) {
+          // Model is valid - apply all overrides including model
+          finalConfig = { ...finalConfig, ...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,
-          };
+          finalConfig = { ...finalConfig, ...safeOverrides };
         }
       } else {
-        // No model specified - apply all overrides
-        merged[name] = {
-          ...agentConfig,
-          ...userOverride,
-        };
+        // No model in override - apply other overrides (keep resolved model)
+        finalConfig = { ...finalConfig, ...userOverride };
       }
-    } else {
-      merged[name] = agentConfig;
     }
+
+    merged[name] = finalConfig;
   }
 
   return merged;
@@ -192,6 +305,12 @@ export function validateAgentModels(userConfig: MicodeConfig, providers: Provide
       continue;
     }
 
+    // Skip validation for built-in models
+    if (BUILTIN_MODELS.has(trimmedModel)) {
+      validatedAgents[agentName] = override;
+      continue;
+    }
+
     // Parse "provider/model" format
     const [providerID, ...rest] = trimmedModel.split("/");
     const modelID = rest.join("/");

package/src/hooks/auto-compact.ts

@@ -7,6 +7,13 @@ import { config } from "../utils/config";
 import { extractErrorMessage } from "../utils/errors";
 import { getContextLimit } from "../utils/model-limits";
 
+export interface AutoCompactConfig {
+  /** Compaction threshold (0-1), defaults to config.compaction.threshold */
+  compactionThreshold?: number;
+  /** Model context limits loaded from opencode.json */
+  modelContextLimits?: Map<string, number>;
+}
+
 interface PendingCompaction {
   resolve: () => void;
   reject: (error: Error) => void;
@@ -19,7 +26,10 @@ interface AutoCompactState {
   pendingCompactions: Map<string, PendingCompaction>;
 }
 
-export function createAutoCompactHook(ctx: PluginInput) {
+export function createAutoCompactHook(ctx: PluginInput, hookConfig?: AutoCompactConfig) {
+  const threshold = hookConfig?.compactionThreshold ?? config.compaction.threshold;
+  const modelLimits = hookConfig?.modelContextLimits;
+
   const state: AutoCompactState = {
     inProgress: new Set(),
     lastCompactTime: new Map(),
@@ -113,7 +123,7 @@ ${summaryText}
 
     try {
       const usedPercent = Math.round(usageRatio * 100);
-      const thresholdPercent = Math.round(config.compaction.threshold * 100);
+      const thresholdPercent = Math.round(threshold * 100);
 
       await ctx.client.tui
         .showToast({
@@ -149,12 +159,31 @@ ${summaryText}
         .showToast({
           body: {
             title: "Compaction Complete",
-            message: "Session summarized and ledger updated.",
+            message: "Session summarized. Continuing...",
             variant: "success",
             duration: config.timeouts.toastSuccessMs,
           },
         })
         .catch(() => {});
+
+      // Auto-continue after compaction - prompt the agent to resume work
+      await ctx.client.session
+        .prompt({
+          path: { id: sessionID },
+          body: {
+            parts: [
+              {
+                type: "text",
+                text: "Context was compacted. Continue from where you left off - check the 'In Progress' and 'Next Steps' sections in the summary above.",
+              },
+            ],
+            model: { providerID, modelID },
+          },
+          query: { directory: ctx.directory },
+        })
+        .catch(() => {
+          // If auto-continue fails, user can manually prompt
+        });
     } catch (e) {
       const errorMsg = extractErrorMessage(e);
       await ctx.client.tui
@@ -222,11 +251,11 @@ ${summaryText}
 
         const modelID = (info?.modelID as string) || "";
         const providerID = (info?.providerID as string) || "";
-        const contextLimit = getContextLimit(modelID);
+        const contextLimit = getContextLimit(modelID, providerID, modelLimits);
         const usageRatio = totalUsed / contextLimit;
 
         // Trigger compaction if over threshold
-        if (usageRatio >= config.compaction.threshold) {
+        if (usageRatio >= threshold) {
           triggerCompaction(sessionID, providerID, modelID, usageRatio);
         }
       }

package/src/hooks/constraint-reviewer.ts

@@ -0,0 +1,177 @@
+// src/hooks/constraint-reviewer.ts
+import type { PluginInput } from "@opencode-ai/plugin";
+
+import {
+  formatViolationsForRetry,
+  formatViolationsForUser,
+  type LoadedMindmodel,
+  loadMindmodel,
+  parseReviewResponse,
+  type ReviewResult,
+} from "../mindmodel";
+import { config } from "../utils/config";
+import { log } from "../utils/logger";
+
+type ReviewFn = (prompt: string) => Promise<string>;
+
+interface ReviewState {
+  /** Retry count per file path */
+  retryCountByFile: Map<string, number>;
+  /** Override active for remainder of turn */
+  overrideActive: boolean;
+}
+
+export function createConstraintReviewerHook(ctx: PluginInput, reviewFn: ReviewFn) {
+  let cachedMindmodel: LoadedMindmodel | null | undefined;
+  const sessionState = new Map<string, ReviewState>();
+
+  async function getMindmodel(): Promise<LoadedMindmodel | null> {
+    if (cachedMindmodel === undefined) {
+      cachedMindmodel = await loadMindmodel(ctx.directory);
+    }
+    return cachedMindmodel;
+  }
+
+  function getSessionState(sessionID: string): ReviewState {
+    if (!sessionState.has(sessionID)) {
+      sessionState.set(sessionID, {
+        retryCountByFile: new Map(),
+        overrideActive: false,
+      });
+    }
+    return sessionState.get(sessionID)!;
+  }
+
+  function cleanupSession(sessionID: string): void {
+    sessionState.delete(sessionID);
+  }
+
+  return {
+    "tool.execute.after": async (
+      input: { tool: string; sessionID: string; args?: Record<string, unknown> },
+      output: { output?: string },
+    ) => {
+      // Only review Write and Edit operations
+      if (!["Write", "Edit"].includes(input.tool)) return;
+      if (!config.mindmodel.reviewEnabled) return;
+
+      const mindmodel = await getMindmodel();
+      if (!mindmodel) return;
+
+      const state = getSessionState(input.sessionID);
+
+      // Skip if override is active
+      if (state.overrideActive) {
+        state.overrideActive = false;
+        return;
+      }
+
+      const filePath = input.args?.file_path as string | undefined;
+      if (!filePath) return;
+
+      try {
+        // Build review prompt
+        const reviewPrompt = buildReviewPrompt(output.output || "", filePath, mindmodel);
+
+        // Call reviewer
+        const reviewResponse = await reviewFn(reviewPrompt);
+        const result = parseReviewResponse(reviewResponse);
+
+        if (result.status === "PASS") {
+          // Reset retry count for this file on success
+          state.retryCountByFile.delete(filePath);
+          return;
+        }
+
+        // Handle violations - track retry count per file
+        const currentRetryCount = state.retryCountByFile.get(filePath) || 0;
+
+        if (currentRetryCount < config.mindmodel.reviewMaxRetries) {
+          // Trigger retry by modifying output
+          state.retryCountByFile.set(filePath, currentRetryCount + 1);
+          const violationsText = formatViolationsForRetry(result.violations);
+          output.output = `${output.output}\n\n<constraint-violations>\n${violationsText}\n</constraint-violations>`;
+        } else {
+          // Max retries reached - block
+          state.retryCountByFile.delete(filePath);
+          const userMessage = formatViolationsForUser(result.violations);
+          throw new ConstraintViolationError(userMessage, result);
+        }
+      } catch (error) {
+        if (error instanceof ConstraintViolationError) {
+          throw error;
+        }
+        // Log but don't block on review failures
+        log.warn("mindmodel", `Review failed: ${error instanceof Error ? error.message : "unknown"}`);
+      }
+    },
+
+    "chat.message": async (input: { sessionID: string }, output: { parts: Array<{ type: string; text?: string }> }) => {
+      // Check for override command
+      const text = output.parts
+        .filter((p) => p.type === "text" && p.text)
+        .map((p) => p.text)
+        .join(" ");
+
+      const overrideMatch = text.match(/^override:\s*(.+)$/im);
+      if (overrideMatch) {
+        const state = getSessionState(input.sessionID);
+        state.overrideActive = true;
+
+        // Log the override
+        const reason = overrideMatch[1].trim();
+        await logOverride(ctx.directory, reason);
+
+        log.info("mindmodel", `Override activated: ${reason}`);
+      }
+    },
+
+    /** Cleanup session state on session deletion to prevent memory leaks */
+    cleanupSession,
+  };
+}
+
+function buildReviewPrompt(code: string, filePath: string, mindmodel: LoadedMindmodel): string {
+  // For now, include all constraints - selective loading can be added later
+  const constraintSummary = mindmodel.manifest.categories.map((c) => `- ${c.path}: ${c.description}`).join("\n");
+
+  return `Review this generated code against project constraints.
+
+File: ${filePath}
+
+Code:
+\`\`\`
+${code}
+\`\`\`
+
+Available constraints:
+${constraintSummary}
+
+Return JSON with status "PASS" or "BLOCKED" and any violations found.`;
+}
+
+async function logOverride(projectDir: string, reason: string): Promise<void> {
+  const { appendFile, mkdir } = await import("node:fs/promises");
+  const { join } = await import("node:path");
+
+  const logPath = join(projectDir, ".mindmodel", config.mindmodel.overrideLogFile);
+  const timestamp = new Date().toISOString();
+  const entry = `${timestamp} | override | reason: "${reason}"\n`;
+
+  try {
+    await mkdir(join(projectDir, ".mindmodel"), { recursive: true });
+    await appendFile(logPath, entry);
+  } catch {
+    // Ignore logging failures
+  }
+}
+
+export class ConstraintViolationError extends Error {
+  constructor(
+    message: string,
+    public readonly result: ReviewResult,
+  ) {
+    super(message);
+    this.name = "ConstraintViolationError";
+  }
+}

package/src/hooks/context-injector.ts

@@ -1,6 +1,8 @@
-import type { PluginInput } from "@opencode-ai/plugin";
 import { readFile } from "node:fs/promises";
-import { join, dirname, resolve } from "node:path";
+import { dirname, join, resolve } from "node:path";
+
+import type { PluginInput } from "@opencode-ai/plugin";
+
 import { config } from "../utils/config";
 
 // Tools that trigger directory-aware context injection

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

@@ -1,13 +1,20 @@
 import type { PluginInput } from "@opencode-ai/plugin";
+
 import { config } from "../utils/config";
 import { getContextLimit } from "../utils/model-limits";
 
+export interface ContextWindowMonitorConfig {
+  /** Model context limits loaded from opencode.json */
+  modelContextLimits?: Map<string, number>;
+}
+
 interface MonitorState {
   lastWarningTime: Map<string, number>;
   lastUsageRatio: Map<string, number>;
 }
 
-export function createContextWindowMonitorHook(ctx: PluginInput) {
+export function createContextWindowMonitorHook(ctx: PluginInput, hookConfig?: ContextWindowMonitorConfig) {
+  const modelLimits = hookConfig?.modelContextLimits;
   const state: MonitorState = {
     lastWarningTime: new Map(),
     lastUsageRatio: new Map(),
@@ -69,7 +76,8 @@ export function createContextWindowMonitorHook(ctx: PluginInput) {
         const totalUsed = inputTokens + cacheRead;
 
         const modelID = (info.modelID as string) || "";
-        const contextLimit = getContextLimit(modelID);
+        const providerID = (info.providerID as string) || "";
+        const contextLimit = getContextLimit(modelID, providerID, modelLimits);
         const usageRatio = totalUsed / contextLimit;
 
         state.lastUsageRatio.set(sessionID, usageRatio);