micode 0.7.0 → 0.7.1

package/src/config-loader.ts

@@ -0,0 +1,89 @@
+// src/config-loader.ts
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import type { AgentConfig } from "@opencode-ai/sdk";
+
+// Safe properties that users can override
+const SAFE_AGENT_PROPERTIES = ["model", "temperature", "maxTokens"] as const;
+
+export interface AgentOverride {
+  model?: string;
+  temperature?: number;
+  maxTokens?: number;
+}
+
+export interface MicodeConfig {
+  agents?: Record<string, AgentOverride>;
+}
+
+/**
+ * Load micode.json from ~/.config/opencode/micode.json
+ * Returns null if file doesn't exist or is invalid JSON
+ * @param configDir - Optional override for config directory (for testing)
+ */
+export async function loadMicodeConfig(configDir?: string): Promise<MicodeConfig | null> {
+  const baseDir = configDir ?? join(homedir(), ".config", "opencode");
+  const configPath = join(baseDir, "micode.json");
+
+  try {
+    const content = await readFile(configPath, "utf-8");
+    const parsed = JSON.parse(content) as Record<string, unknown>;
+
+    // Sanitize the config - only allow safe properties
+    if (parsed.agents && typeof parsed.agents === "object") {
+      const sanitizedAgents: Record<string, AgentOverride> = {};
+
+      for (const [agentName, agentConfig] of Object.entries(parsed.agents)) {
+        if (agentConfig && typeof agentConfig === "object") {
+          const sanitized: AgentOverride = {};
+          const config = agentConfig as Record<string, unknown>;
+
+          for (const prop of SAFE_AGENT_PROPERTIES) {
+            if (prop in config) {
+              (sanitized as Record<string, unknown>)[prop] = config[prop];
+            }
+          }
+
+          sanitizedAgents[agentName] = sanitized;
+        }
+      }
+
+      return { agents: sanitizedAgents };
+    }
+
+    return parsed as MicodeConfig;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Merge user config overrides into plugin agent configs
+ * User overrides take precedence for safe properties only
+ */
+export function mergeAgentConfigs(
+  pluginAgents: Record<string, AgentConfig>,
+  userConfig: MicodeConfig | null,
+): Record<string, AgentConfig> {
+  if (!userConfig?.agents) {
+    return pluginAgents;
+  }
+
+  const merged: Record<string, AgentConfig> = {};
+
+  for (const [name, agentConfig] of Object.entries(pluginAgents)) {
+    const userOverride = userConfig.agents[name];
+
+    if (userOverride) {
+      merged[name] = {
+        ...agentConfig,
+        ...userOverride,
+      };
+    } else {
+      merged[name] = agentConfig;
+    }
+  }
+
+  return merged;
+}

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

@@ -0,0 +1,111 @@
+// src/hooks/artifact-auto-index.ts
+// Auto-indexes artifacts when written to thoughts/ directories
+
+import type { PluginInput } from "@opencode-ai/plugin";
+import { readFileSync } from "node:fs";
+import { getArtifactIndex } from "../tools/artifact-index";
+
+const LEDGER_PATH_PATTERN = /thoughts\/ledgers\/CONTINUITY_(.+)\.md$/;
+const PLAN_PATH_PATTERN = /thoughts\/shared\/plans\/(.+)\.md$/;
+
+export function parseLedger(content: string, filePath: string, sessionName: string) {
+  const goalMatch = content.match(/## Goal\n([^\n]+)/);
+  const stateMatch = content.match(/### In Progress\n- \[ \] ([^\n]+)/);
+  const decisionsMatch = content.match(/## Key Decisions\n([\s\S]*?)(?=\n## |$)/);
+
+  // Parse file operations from new ledger format
+  const fileOpsSection = content.match(/## File Operations\n([\s\S]*?)(?=\n## |$)/);
+  let filesRead = "";
+  let filesModified = "";
+
+  if (fileOpsSection) {
+    const readMatch = fileOpsSection[1].match(/### Read\n([\s\S]*?)(?=\n### |$)/);
+    const modifiedMatch = fileOpsSection[1].match(/### Modified\n([\s\S]*?)(?=\n### |$)/);
+
+    if (readMatch) {
+      // Extract paths from markdown list items like "- `path`"
+      const paths = readMatch[1].match(/`([^`]+)`/g);
+      filesRead = paths ? paths.map((p) => p.replace(/`/g, "")).join(",") : "";
+    }
+
+    if (modifiedMatch) {
+      const paths = modifiedMatch[1].match(/`([^`]+)`/g);
+      filesModified = paths ? paths.map((p) => p.replace(/`/g, "")).join(",") : "";
+    }
+  }
+
+  return {
+    id: `ledger-${sessionName}`,
+    sessionName,
+    filePath,
+    goal: goalMatch?.[1] || "",
+    stateNow: stateMatch?.[1] || "",
+    keyDecisions: decisionsMatch?.[1]?.trim() || "",
+    filesRead,
+    filesModified,
+  };
+}
+
+function parsePlan(content: string, filePath: string, fileName: string) {
+  // Extract title (first heading)
+  const titleMatch = content.match(/^# (.+)$/m);
+  const title = titleMatch?.[1] || fileName;
+
+  // Extract overview
+  const overviewMatch = content.match(/## Overview\n\n([\s\S]*?)(?=\n## |$)/);
+  const overview = overviewMatch?.[1]?.trim() || "";
+
+  // Extract approach
+  const approachMatch = content.match(/## Approach\n\n([\s\S]*?)(?=\n## |$)/);
+  const approach = approachMatch?.[1]?.trim() || "";
+
+  return {
+    id: `plan-${fileName}`,
+    title,
+    filePath,
+    overview,
+    approach,
+  };
+}
+
+export function createArtifactAutoIndexHook(_ctx: PluginInput) {
+  return {
+    "tool.execute.after": async (
+      input: { tool: string; args?: Record<string, unknown> },
+      _output: { output?: string },
+    ) => {
+      // Only process Write tool
+      if (input.tool !== "write") return;
+
+      const filePath = input.args?.filePath as string | undefined;
+      if (!filePath) return;
+
+      try {
+        // Check if it's a ledger
+        const ledgerMatch = filePath.match(LEDGER_PATH_PATTERN);
+        if (ledgerMatch) {
+          const content = readFileSync(filePath, "utf-8");
+          const index = await getArtifactIndex();
+          const record = parseLedger(content, filePath, ledgerMatch[1]);
+          await index.indexLedger(record);
+          console.log(`[artifact-auto-index] Indexed ledger: ${filePath}`);
+          return;
+        }
+
+        // Check if it's a plan
+        const planMatch = filePath.match(PLAN_PATH_PATTERN);
+        if (planMatch) {
+          const content = readFileSync(filePath, "utf-8");
+          const index = await getArtifactIndex();
+          const record = parsePlan(content, filePath, planMatch[1]);
+          await index.indexPlan(record);
+          console.log(`[artifact-auto-index] Indexed plan: ${filePath}`);
+          return;
+        }
+      } catch (e) {
+        // Silent failure - don't interrupt user flow
+        console.error(`[artifact-auto-index] Error indexing ${filePath}:`, e);
+      }
+    },
+  };
+}

package/src/hooks/auto-clear-ledger.ts

@@ -0,0 +1,230 @@
+// src/hooks/auto-clear-ledger.ts
+import type { PluginInput } from "@opencode-ai/plugin";
+import { findCurrentLedger, formatLedgerInjection } from "./ledger-loader";
+import { getFileOps, clearFileOps, formatFileOpsForPrompt } from "./file-ops-tracker";
+import { getContextLimit } from "../utils/model-limits";
+
+export const DEFAULT_THRESHOLD = 0.6; // 60% of context window
+const MIN_TOKENS_FOR_CLEAR = 50_000;
+export const CLEAR_COOLDOWN_MS = 60_000;
+
+interface ClearState {
+  lastClearTime: Map<string, number>;
+  clearInProgress: Set<string>;
+}
+
+export function createAutoClearLedgerHook(ctx: PluginInput) {
+  const state: ClearState = {
+    lastClearTime: new Map(),
+    clearInProgress: new Set(),
+  };
+
+  async function checkAndClear(sessionID: string, _providerID?: string, modelID?: string): Promise<void> {
+    // Skip if clear in progress
+    if (state.clearInProgress.has(sessionID)) return;
+
+    // Respect cooldown
+    const lastTime = state.lastClearTime.get(sessionID) || 0;
+    if (Date.now() - lastTime < CLEAR_COOLDOWN_MS) return;
+
+    try {
+      // Get session messages to calculate token usage
+      const resp = await ctx.client.session.messages({
+        path: { id: sessionID },
+        query: { directory: ctx.directory },
+      });
+
+      const messages = (resp as { data?: unknown[] }).data;
+      if (!Array.isArray(messages) || messages.length === 0) return;
+
+      // Find last assistant message with token info
+      const lastAssistant = [...messages].reverse().find((m) => {
+        const msg = m as Record<string, unknown>;
+        const info = msg.info as Record<string, unknown> | undefined;
+        return info?.role === "assistant";
+      }) as Record<string, unknown> | undefined;
+
+      if (!lastAssistant) return;
+
+      const info = lastAssistant.info as Record<string, unknown> | undefined;
+      const usage = info?.usage as Record<string, unknown> | undefined;
+
+      // Calculate token usage
+      const inputTokens = (usage?.inputTokens as number) || 0;
+      const cacheRead = (usage?.cacheReadInputTokens as number) || 0;
+      const totalUsed = inputTokens + cacheRead;
+
+      if (totalUsed < MIN_TOKENS_FOR_CLEAR) return;
+
+      // Get model context limit
+      const model = modelID || (info?.modelID as string) || "";
+      const contextLimit = getContextLimit(model);
+      const usageRatio = totalUsed / contextLimit;
+
+      if (usageRatio < DEFAULT_THRESHOLD) return;
+
+      // Start clear process
+      state.clearInProgress.add(sessionID);
+      state.lastClearTime.set(sessionID, Date.now());
+
+      await ctx.client.tui
+        .showToast({
+          body: {
+            title: "Context Window",
+            message: `${Math.round(usageRatio * 100)}% used - saving ledger and clearing...`,
+            variant: "warning",
+            duration: 3000,
+          },
+        })
+        .catch(() => {});
+
+      // Step 1: Get file operations and existing ledger (don't clear yet)
+      const fileOps = getFileOps(sessionID);
+      const existingLedger = await findCurrentLedger(ctx.directory);
+
+      // Step 2: Spawn ledger-creator agent to update ledger
+      const ledgerSessionResp = await ctx.client.session.create({
+        body: {},
+        query: { directory: ctx.directory },
+      });
+      const ledgerSessionID = (ledgerSessionResp as { data?: { id?: string } }).data?.id;
+
+      if (ledgerSessionID) {
+        // Build prompt with previous ledger and file ops
+        let promptText = "";
+
+        if (existingLedger) {
+          promptText += `<previous-ledger>\n${existingLedger.content}\n</previous-ledger>\n\n`;
+        }
+
+        promptText += formatFileOpsForPrompt(fileOps);
+        promptText += "\n\n<instruction>\n";
+        promptText += existingLedger
+          ? "Update the ledger with the current session state. Merge the file operations above with any existing ones in the previous ledger."
+          : "Create a new continuity ledger for this session.";
+        promptText += "\n</instruction>";
+
+        await ctx.client.session.prompt({
+          path: { id: ledgerSessionID },
+          body: {
+            parts: [{ type: "text", text: promptText }],
+            agent: "ledger-creator",
+          },
+          query: { directory: ctx.directory },
+        });
+
+        // Wait for ledger completion (poll for idle)
+        let attempts = 0;
+        let ledgerCompleted = false;
+        while (attempts < 30) {
+          await new Promise((resolve) => setTimeout(resolve, 2000));
+          const statusResp = await ctx.client.session.get({
+            path: { id: ledgerSessionID },
+            query: { directory: ctx.directory },
+          });
+          if ((statusResp as { data?: { status?: string } }).data?.status === "idle") {
+            ledgerCompleted = true;
+            break;
+          }
+          attempts++;
+        }
+
+        // Only clear file ops after ledger-creator successfully completed
+        if (ledgerCompleted) {
+          clearFileOps(sessionID);
+        }
+      }
+
+      // Step 3: Get first message ID for revert
+      const firstMessage = messages[0] as Record<string, unknown> | undefined;
+      const firstMessageID = (firstMessage?.info as Record<string, unknown> | undefined)?.id as string | undefined;
+
+      if (!firstMessageID) {
+        throw new Error("Could not find first message ID for revert");
+      }
+
+      // Step 4: Revert session to first message
+      await ctx.client.session.revert({
+        path: { id: sessionID },
+        body: { messageID: firstMessageID },
+        query: { directory: ctx.directory },
+      });
+
+      // Step 5: Inject ledger context
+      const ledger = await findCurrentLedger(ctx.directory);
+      if (ledger) {
+        const injection = formatLedgerInjection(ledger);
+        await ctx.client.session.prompt({
+          path: { id: sessionID },
+          body: {
+            parts: [{ type: "text", text: injection }],
+            noReply: true,
+          },
+          query: { directory: ctx.directory },
+        });
+      }
+
+      await ctx.client.tui
+        .showToast({
+          body: {
+            title: "Context Cleared",
+            message: "Ledger saved. Session ready to continue.",
+            variant: "success",
+            duration: 5000,
+          },
+        })
+        .catch(() => {});
+    } catch (e) {
+      // Log error but don't interrupt user flow
+      console.error("[auto-clear-ledger] Error:", e);
+      await ctx.client.tui
+        .showToast({
+          body: {
+            title: "Clear Failed",
+            message: "Could not complete context clear. Continuing normally.",
+            variant: "error",
+            duration: 5000,
+          },
+        })
+        .catch(() => {});
+    } finally {
+      state.clearInProgress.delete(sessionID);
+    }
+  }
+
+  return {
+    event: async ({ event }: { event: { type: string; properties?: unknown } }) => {
+      const props = event.properties as Record<string, unknown> | undefined;
+
+      // Cleanup on session delete
+      if (event.type === "session.deleted") {
+        const sessionInfo = props?.info as { id?: string } | undefined;
+        if (sessionInfo?.id) {
+          state.lastClearTime.delete(sessionInfo.id);
+          state.clearInProgress.delete(sessionInfo.id);
+        }
+        return;
+      }
+
+      // Check on message update (assistant finished)
+      if (event.type === "message.updated") {
+        const info = props?.info as Record<string, unknown> | undefined;
+        const sessionID = info?.sessionID as string | undefined;
+
+        if (sessionID && info?.role === "assistant") {
+          const providerID = info.providerID as string | undefined;
+          const modelID = info.modelID as string | undefined;
+          await checkAndClear(sessionID, providerID, modelID);
+        }
+      }
+
+      // Check when session goes idle
+      if (event.type === "session.idle") {
+        const sessionID = props?.sessionID as string | undefined;
+        if (sessionID) {
+          await checkAndClear(sessionID);
+        }
+      }
+    },
+  };
+}

package/src/hooks/auto-compact.ts

@@ -0,0 +1,241 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+
+interface TokenLimitError {
+  currentTokens?: number;
+  maxTokens?: number;
+  providerID?: string;
+  modelID?: string;
+}
+
+// Parse Anthropic token limit errors
+function parseTokenLimitError(error: unknown): TokenLimitError | null {
+  if (!error) return null;
+
+  const errorStr = typeof error === "string" ? error : JSON.stringify(error);
+
+  // Check for Anthropic-specific token limit messages
+  const patterns = [
+    /prompt is too long.*?(\d+)\s*tokens.*?maximum.*?(\d+)/i,
+    /context.*?(\d+).*?exceeds.*?(\d+)/i,
+    /token limit.*?(\d+).*?max.*?(\d+)/i,
+  ];
+
+  for (const pattern of patterns) {
+    const match = errorStr.match(pattern);
+    if (match) {
+      return {
+        currentTokens: parseInt(match[1], 10),
+        maxTokens: parseInt(match[2], 10),
+      };
+    }
+  }
+
+  // Check for generic rate limit / context errors
+  if (
+    errorStr.includes("context_length_exceeded") ||
+    errorStr.includes("token") ||
+    errorStr.includes("prompt is too long")
+  ) {
+    return {};
+  }
+
+  return null;
+}
+
+interface AutoCompactState {
+  pendingCompact: Set<string>;
+  errorData: Map<string, TokenLimitError>;
+  retryCount: Map<string, number>;
+  inProgress: Set<string>;
+}
+
+export function createAutoCompactHook(ctx: PluginInput) {
+  const state: AutoCompactState = {
+    pendingCompact: new Set(),
+    errorData: new Map(),
+    retryCount: new Map(),
+    inProgress: new Set(),
+  };
+
+  const MAX_RETRIES = 3;
+
+  async function attemptRecovery(sessionID: string, providerID?: string, modelID?: string): Promise<void> {
+    if (state.inProgress.has(sessionID)) return;
+    state.inProgress.add(sessionID);
+
+    const retries = state.retryCount.get(sessionID) || 0;
+
+    if (retries >= MAX_RETRIES) {
+      await ctx.client.tui
+        .showToast({
+          body: {
+            title: "Auto Compact Failed",
+            message: "Max retries reached. Please start a new session or manually compact.",
+            variant: "error",
+            duration: 5000,
+          },
+        })
+        .catch(() => {});
+      state.inProgress.delete(sessionID);
+      state.pendingCompact.delete(sessionID);
+      return;
+    }
+
+    try {
+      await ctx.client.tui
+        .showToast({
+          body: {
+            title: "Context Limit Hit",
+            message: `Attempting to summarize session (attempt ${retries + 1}/${MAX_RETRIES})...`,
+            variant: "warning",
+            duration: 3000,
+          },
+        })
+        .catch(() => {});
+
+      // Try to summarize the session
+      if (providerID && modelID) {
+        await ctx.client.session.summarize({
+          path: { id: sessionID },
+          body: { providerID, modelID },
+          query: { directory: ctx.directory },
+        });
+
+        await ctx.client.tui
+          .showToast({
+            body: {
+              title: "Session Compacted",
+              message: "Context has been summarized. Continuing...",
+              variant: "success",
+              duration: 3000,
+            },
+          })
+          .catch(() => {});
+
+        // Clear state on success
+        state.pendingCompact.delete(sessionID);
+        state.errorData.delete(sessionID);
+        state.retryCount.delete(sessionID);
+
+        // Send continue prompt
+        setTimeout(async () => {
+          try {
+            await ctx.client.session.prompt({
+              path: { id: sessionID },
+              body: { parts: [{ type: "text", text: "Continue" }] },
+              query: { directory: ctx.directory },
+            });
+          } catch {}
+        }, 500);
+      } else {
+        await ctx.client.tui
+          .showToast({
+            body: {
+              title: "Cannot Auto-Compact",
+              message: "Missing model info. Please compact manually with /compact.",
+              variant: "error",
+              duration: 5000,
+            },
+          })
+          .catch(() => {});
+      }
+    } catch (_e) {
+      state.retryCount.set(sessionID, retries + 1);
+
+      // Exponential backoff
+      const delay = Math.min(1000 * 2 ** retries, 10000);
+      setTimeout(() => {
+        state.inProgress.delete(sessionID);
+        attemptRecovery(sessionID, providerID, modelID);
+      }, delay);
+      return;
+    }
+
+    state.inProgress.delete(sessionID);
+  }
+
+  return {
+    event: async ({ event }: { event: { type: string; properties?: unknown } }) => {
+      const props = event.properties as Record<string, unknown> | undefined;
+
+      // Clean up on session delete
+      if (event.type === "session.deleted") {
+        const sessionInfo = props?.info as { id?: string } | undefined;
+        if (sessionInfo?.id) {
+          state.pendingCompact.delete(sessionInfo.id);
+          state.errorData.delete(sessionInfo.id);
+          state.retryCount.delete(sessionInfo.id);
+          state.inProgress.delete(sessionInfo.id);
+        }
+        return;
+      }
+
+      // Detect token limit errors
+      if (event.type === "session.error") {
+        const sessionID = props?.sessionID as string | undefined;
+        const error = props?.error;
+
+        if (!sessionID) return;
+
+        const parsed = parseTokenLimitError(error);
+        if (parsed) {
+          state.pendingCompact.add(sessionID);
+          state.errorData.set(sessionID, parsed);
+
+          // Get last assistant message for provider/model info
+          const lastAssistant = await getLastAssistantInfo(sessionID);
+          const providerID = parsed.providerID || lastAssistant?.providerID;
+          const modelID = parsed.modelID || lastAssistant?.modelID;
+
+          attemptRecovery(sessionID, providerID, modelID);
+        }
+      }
+
+      // Also check message.updated for errors
+      if (event.type === "message.updated") {
+        const info = props?.info as Record<string, unknown> | undefined;
+        const sessionID = info?.sessionID as string | undefined;
+
+        if (sessionID && info?.role === "assistant" && info.error) {
+          const parsed = parseTokenLimitError(info.error);
+          if (parsed) {
+            parsed.providerID = info.providerID as string | undefined;
+            parsed.modelID = info.modelID as string | undefined;
+
+            state.pendingCompact.add(sessionID);
+            state.errorData.set(sessionID, parsed);
+
+            attemptRecovery(sessionID, parsed.providerID, parsed.modelID);
+          }
+        }
+      }
+    },
+  };
+
+  async function getLastAssistantInfo(sessionID: string): Promise<{ providerID?: string; modelID?: string } | null> {
+    try {
+      const resp = await ctx.client.session.messages({
+        path: { id: sessionID },
+        query: { directory: ctx.directory },
+      });
+
+      const data = (resp as { data?: unknown[] }).data;
+      if (!Array.isArray(data)) return null;
+
+      const lastAssistant = [...data].reverse().find((m) => {
+        const msg = m as Record<string, unknown>;
+        const info = msg.info as Record<string, unknown> | undefined;
+        return info?.role === "assistant";
+      });
+
+      if (!lastAssistant) return null;
+      const info = (lastAssistant as { info?: Record<string, unknown> }).info;
+      return {
+        providerID: info?.providerID as string | undefined,
+        modelID: info?.modelID as string | undefined,
+      };
+    } catch {
+      return null;
+    }
+  }
+}