micode 0.6.0 → 0.7.1

package/src/hooks/session-recovery.ts

@@ -0,0 +1,258 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+
+// Error patterns we can recover from
+const RECOVERABLE_ERRORS = {
+  TOOL_RESULT_MISSING: "tool_result block(s) missing",
+  THINKING_BLOCK_ORDER: "thinking blocks must be at the start",
+  THINKING_DISABLED: "thinking is not enabled",
+  EMPTY_CONTENT: "content cannot be empty",
+  INVALID_TOOL_RESULT: "tool_result must follow tool_use",
+} as const;
+
+type RecoverableErrorType = keyof typeof RECOVERABLE_ERRORS;
+
+interface RecoveryState {
+  processingErrors: Set<string>;
+  recoveryAttempts: Map<string, number>;
+}
+
+const MAX_RECOVERY_ATTEMPTS = 3;
+
+function extractErrorInfo(error: unknown): { message: string; messageIndex?: number } | null {
+  if (!error) return null;
+
+  let errorStr: string;
+  if (typeof error === "string") {
+    errorStr = error;
+  } else if (error instanceof Error) {
+    errorStr = error.message;
+  } else {
+    errorStr = JSON.stringify(error);
+  }
+
+  const errorLower = errorStr.toLowerCase();
+
+  // Extract message index if present (e.g., "messages.5" or "message 5")
+  const indexMatch = errorStr.match(/messages?[.\s](\d+)/i);
+  const messageIndex = indexMatch ? parseInt(indexMatch[1], 10) : undefined;
+
+  return { message: errorLower, messageIndex };
+}
+
+function identifyErrorType(errorMessage: string): RecoverableErrorType | null {
+  for (const [type, pattern] of Object.entries(RECOVERABLE_ERRORS)) {
+    if (errorMessage.includes(pattern.toLowerCase())) {
+      return type as RecoverableErrorType;
+    }
+  }
+  return null;
+}
+
+export function createSessionRecoveryHook(ctx: PluginInput) {
+  const state: RecoveryState = {
+    processingErrors: new Set(),
+    recoveryAttempts: new Map(),
+  };
+
+  async function getSessionMessages(sessionID: string): Promise<unknown[]> {
+    try {
+      const resp = await ctx.client.session.messages({
+        path: { id: sessionID },
+        query: { directory: ctx.directory },
+      });
+      return (resp as { data?: unknown[] }).data || [];
+    } catch {
+      return [];
+    }
+  }
+
+  async function abortSession(sessionID: string): Promise<void> {
+    try {
+      await ctx.client.session.abort({
+        path: { id: sessionID },
+        query: { directory: ctx.directory },
+      });
+    } catch {
+      // Ignore abort errors
+    }
+  }
+
+  async function resumeSession(
+    sessionID: string,
+    providerID?: string,
+    modelID?: string,
+    agent?: string,
+  ): Promise<void> {
+    try {
+      // Find last user message to resume from
+      const messages = await getSessionMessages(sessionID);
+      const lastUserMsg = [...messages].reverse().find((m) => {
+        const msg = m as Record<string, unknown>;
+        const info = msg.info as Record<string, unknown> | undefined;
+        return info?.role === "user";
+      });
+
+      if (!lastUserMsg) return;
+
+      const parts = (lastUserMsg as Record<string, unknown>).parts as Array<{
+        type: string;
+        text?: string;
+      }>;
+      const text = parts?.find((p) => p.type === "text")?.text;
+
+      if (!text) return;
+
+      // Resume with continue prompt
+      await ctx.client.session.prompt({
+        path: { id: sessionID },
+        body: {
+          parts: [{ type: "text", text: "Continue from where you left off." }],
+          ...(providerID && modelID ? { providerID, modelID } : {}),
+          ...(agent ? { agent } : {}),
+        },
+        query: { directory: ctx.directory },
+      });
+    } catch {
+      // Resume failed - user will need to manually continue
+    }
+  }
+
+  async function attemptRecovery(
+    sessionID: string,
+    errorType: RecoverableErrorType,
+    providerID?: string,
+    modelID?: string,
+    agent?: string,
+  ): Promise<boolean> {
+    const recoveryKey = `${sessionID}:${errorType}`;
+
+    // Check recovery attempts
+    const attempts = state.recoveryAttempts.get(recoveryKey) || 0;
+    if (attempts >= MAX_RECOVERY_ATTEMPTS) {
+      await ctx.client.tui
+        .showToast({
+          body: {
+            title: "Recovery Failed",
+            message: `Max attempts reached for ${errorType}. Manual intervention needed.`,
+            variant: "error",
+            duration: 5000,
+          },
+        })
+        .catch(() => {});
+      return false;
+    }
+
+    state.recoveryAttempts.set(recoveryKey, attempts + 1);
+
+    await ctx.client.tui
+      .showToast({
+        body: {
+          title: "Session Recovery",
+          message: `Recovering from ${errorType.toLowerCase().replace(/_/g, " ")}...`,
+          variant: "warning",
+          duration: 3000,
+        },
+      })
+      .catch(() => {});
+
+    // Abort current session to stop the error state
+    await abortSession(sessionID);
+
+    // Wait a moment for abort to complete
+    await new Promise((resolve) => setTimeout(resolve, 500));
+
+    // Attempt resume
+    await resumeSession(sessionID, providerID, modelID, agent);
+
+    await ctx.client.tui
+      .showToast({
+        body: {
+          title: "Recovery Complete",
+          message: "Session resumed. Continuing...",
+          variant: "success",
+          duration: 3000,
+        },
+      })
+      .catch(() => {});
+
+    return true;
+  }
+
+  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) {
+          // Clean up all recovery attempts for this session
+          for (const key of state.recoveryAttempts.keys()) {
+            if (key.startsWith(sessionInfo.id)) {
+              state.recoveryAttempts.delete(key);
+            }
+          }
+          for (const key of state.processingErrors) {
+            if (key.startsWith(sessionInfo.id)) {
+              state.processingErrors.delete(key);
+            }
+          }
+        }
+        return;
+      }
+
+      // Handle session errors
+      if (event.type === "session.error") {
+        const sessionID = props?.sessionID as string | undefined;
+        const error = props?.error;
+
+        if (!sessionID || !error) return;
+
+        const errorInfo = extractErrorInfo(error);
+        if (!errorInfo) return;
+
+        const errorType = identifyErrorType(errorInfo.message);
+        if (!errorType) return;
+
+        // Prevent duplicate processing
+        const errorKey = `${sessionID}:${errorType}:${Date.now()}`;
+        if (state.processingErrors.has(errorKey)) return;
+        state.processingErrors.add(errorKey);
+
+        // Clear old error keys after 10 seconds
+        setTimeout(() => state.processingErrors.delete(errorKey), 10000);
+
+        // Attempt recovery
+        await attemptRecovery(sessionID, errorType);
+      }
+
+      // Handle message errors
+      if (event.type === "message.updated") {
+        const info = props?.info as Record<string, unknown> | undefined;
+        const sessionID = info?.sessionID as string | undefined;
+        const error = info?.error;
+
+        if (!sessionID || !error) return;
+
+        const errorInfo = extractErrorInfo(error);
+        if (!errorInfo) return;
+
+        const errorType = identifyErrorType(errorInfo.message);
+        if (!errorType) return;
+
+        // Prevent duplicate processing
+        const errorKey = `${sessionID}:${errorType}:${Date.now()}`;
+        if (state.processingErrors.has(errorKey)) return;
+        state.processingErrors.add(errorKey);
+
+        setTimeout(() => state.processingErrors.delete(errorKey), 10000);
+
+        const providerID = info.providerID as string | undefined;
+        const modelID = info.modelID as string | undefined;
+        const agent = info.agent as string | undefined;
+
+        await attemptRecovery(sessionID, errorType, providerID, modelID, agent);
+      }
+    },
+  };
+}

package/src/hooks/token-aware-truncation.ts

@@ -0,0 +1,189 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+
+// Tools that benefit from truncation
+const TRUNCATABLE_TOOLS = ["grep", "Grep", "glob", "Glob", "ast_grep_search"];
+
+// Token estimation (conservative: 4 chars = 1 token)
+const CHARS_PER_TOKEN = 4;
+const DEFAULT_CONTEXT_LIMIT = 200_000;
+const DEFAULT_MAX_OUTPUT_TOKENS = 50_000;
+const SAFETY_MARGIN = 0.5; // Keep 50% headroom
+const PRESERVE_HEADER_LINES = 3;
+
+function estimateTokens(text: string): number {
+  return Math.ceil(text.length / CHARS_PER_TOKEN);
+}
+
+function truncateToTokenLimit(
+  output: string,
+  maxTokens: number,
+  preserveLines: number = PRESERVE_HEADER_LINES,
+): string {
+  const currentTokens = estimateTokens(output);
+
+  if (currentTokens <= maxTokens) {
+    return output;
+  }
+
+  const lines = output.split("\n");
+
+  // Preserve header lines
+  const headerLines = lines.slice(0, preserveLines);
+  const remainingLines = lines.slice(preserveLines);
+
+  // Calculate available tokens for content
+  const headerTokens = estimateTokens(headerLines.join("\n"));
+  const truncationMsgTokens = 50; // Reserve for truncation message
+  const availableTokens = maxTokens - headerTokens - truncationMsgTokens;
+
+  if (availableTokens <= 0) {
+    return `${headerLines.join("\n")}\n\n[Output truncated - context window limit reached]`;
+  }
+
+  // Accumulate lines until we hit the limit
+  const resultLines: string[] = [];
+  let usedTokens = 0;
+  let truncatedCount = 0;
+
+  for (const line of remainingLines) {
+    const lineTokens = estimateTokens(line);
+    if (usedTokens + lineTokens > availableTokens) {
+      truncatedCount = remainingLines.length - resultLines.length;
+      break;
+    }
+    resultLines.push(line);
+    usedTokens += lineTokens;
+  }
+
+  if (truncatedCount === 0) {
+    return output;
+  }
+
+  return [
+    ...headerLines,
+    ...resultLines,
+    "",
+    `[${truncatedCount} more lines truncated due to context window limit]`,
+  ].join("\n");
+}
+
+interface TruncationState {
+  sessionTokenUsage: Map<string, { used: number; limit: number }>;
+}
+
+export function createTokenAwareTruncationHook(ctx: PluginInput) {
+  const state: TruncationState = {
+    sessionTokenUsage: new Map(),
+  };
+
+  async function updateTokenUsage(sessionID: string): Promise<{ used: number; limit: number }> {
+    try {
+      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 { used: 0, limit: DEFAULT_CONTEXT_LIMIT };
+      }
+
+      // Find last assistant message with usage 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 { used: 0, limit: DEFAULT_CONTEXT_LIMIT };
+      }
+
+      const info = lastAssistant.info as Record<string, unknown> | undefined;
+      const usage = info?.usage as Record<string, unknown> | undefined;
+
+      const inputTokens = (usage?.inputTokens as number) || 0;
+      const cacheRead = (usage?.cacheReadInputTokens as number) || 0;
+      const used = inputTokens + cacheRead;
+
+      // Get model limit (simplified - use default for now)
+      const limit = DEFAULT_CONTEXT_LIMIT;
+
+      const result = { used, limit };
+      state.sessionTokenUsage.set(sessionID, result);
+      return result;
+    } catch {
+      return state.sessionTokenUsage.get(sessionID) || { used: 0, limit: DEFAULT_CONTEXT_LIMIT };
+    }
+  }
+
+  function calculateMaxOutputTokens(used: number, limit: number): number {
+    const remaining = limit - used;
+    const available = Math.floor(remaining * SAFETY_MARGIN);
+
+    if (available <= 0) {
+      return 0;
+    }
+
+    return Math.min(available, DEFAULT_MAX_OUTPUT_TOKENS);
+  }
+
+  return {
+    // Update token usage when assistant messages are received
+    event: async ({ event }: { event: { type: string; properties?: unknown } }) => {
+      const props = event.properties as Record<string, unknown> | undefined;
+
+      if (event.type === "session.deleted") {
+        const sessionInfo = props?.info as { id?: string } | undefined;
+        if (sessionInfo?.id) {
+          state.sessionTokenUsage.delete(sessionInfo.id);
+        }
+        return;
+      }
+
+      // Update usage on message updates
+      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") {
+          await updateTokenUsage(sessionID);
+        }
+      }
+    },
+
+    // Truncate tool output
+    "tool.execute.after": async (input: { name: string; sessionID: string }, output: { output?: string }) => {
+      // Only truncate specific tools
+      if (!TRUNCATABLE_TOOLS.includes(input.name)) {
+        return;
+      }
+
+      if (!output.output || typeof output.output !== "string") {
+        return;
+      }
+
+      try {
+        // Get current token usage
+        const { used, limit } = await updateTokenUsage(input.sessionID);
+        const maxTokens = calculateMaxOutputTokens(used, limit);
+
+        if (maxTokens <= 0) {
+          output.output = "[Output suppressed - context window exhausted. Consider compacting.]";
+          return;
+        }
+
+        // Truncate if needed
+        const currentTokens = estimateTokens(output.output);
+        if (currentTokens > maxTokens) {
+          output.output = truncateToTokenLimit(output.output, maxTokens);
+        }
+      } catch {
+        // On error, apply static truncation as fallback
+        const currentTokens = estimateTokens(output.output);
+        if (currentTokens > DEFAULT_MAX_OUTPUT_TOKENS) {
+          output.output = truncateToTokenLimit(output.output, DEFAULT_MAX_OUTPUT_TOKENS);
+        }
+      }
+    },
+  };
+}

package/src/index.ts

@@ -0,0 +1,258 @@
+import type { Plugin } from "@opencode-ai/plugin";
+import type { McpLocalConfig } from "@opencode-ai/sdk";
+
+// Agents
+import { agents, PRIMARY_AGENT_NAME } from "./agents";
+
+// Tools
+import { ast_grep_search, ast_grep_replace, checkAstGrepAvailable } from "./tools/ast-grep";
+import { btca_ask, checkBtcaAvailable } from "./tools/btca";
+import { look_at } from "./tools/look-at";
+import { artifact_search } from "./tools/artifact-search";
+
+// Hooks
+import { createAutoCompactHook } from "./hooks/auto-compact";
+import { createContextInjectorHook } from "./hooks/context-injector";
+import { createSessionRecoveryHook } from "./hooks/session-recovery";
+import { createTokenAwareTruncationHook } from "./hooks/token-aware-truncation";
+import { createContextWindowMonitorHook } from "./hooks/context-window-monitor";
+import { createCommentCheckerHook } from "./hooks/comment-checker";
+import { createAutoClearLedgerHook } from "./hooks/auto-clear-ledger";
+import { createLedgerLoaderHook } from "./hooks/ledger-loader";
+import { createArtifactAutoIndexHook } from "./hooks/artifact-auto-index";
+import { createFileOpsTrackerHook } from "./hooks/file-ops-tracker";
+
+// Background Task System
+import { BackgroundTaskManager, createBackgroundTaskTools } from "./tools/background-task";
+
+// PTY System
+import { PTYManager, createPtyTools } from "./tools/pty";
+
+// Config loader
+import { loadMicodeConfig, mergeAgentConfigs } from "./config-loader";
+
+// Think mode: detect keywords and enable extended thinking
+const THINK_KEYWORDS = [
+  /\bthink\s*(hard|deeply|carefully|through)\b/i,
+  /\bthink\b.*\b(about|on|through)\b/i,
+  /\b(deeply|carefully)\s*think\b/i,
+  /\blet('s|s)?\s*think\b/i,
+];
+
+function detectThinkKeyword(text: string): boolean {
+  return THINK_KEYWORDS.some((pattern) => pattern.test(text));
+}
+
+// MCP server configurations
+const MCP_SERVERS: Record<string, McpLocalConfig> = {
+  context7: {
+    type: "local",
+    command: ["npx", "-y", "@upstash/context7-mcp@latest"],
+  },
+};
+
+// Environment-gated research MCP servers
+if (process.env.PERPLEXITY_API_KEY) {
+  MCP_SERVERS.perplexity = {
+    type: "local",
+    command: ["npx", "-y", "@anthropic/mcp-perplexity"],
+  };
+}
+
+if (process.env.FIRECRAWL_API_KEY) {
+  MCP_SERVERS.firecrawl = {
+    type: "local",
+    command: ["npx", "-y", "firecrawl-mcp"],
+  };
+}
+
+const OpenCodeConfigPlugin: Plugin = async (ctx) => {
+  // Validate external tool dependencies at startup
+  const astGrepStatus = await checkAstGrepAvailable();
+  if (!astGrepStatus.available) {
+    console.warn(`[micode] ${astGrepStatus.message}`);
+  }
+
+  const btcaStatus = await checkBtcaAvailable();
+  if (!btcaStatus.available) {
+    console.warn(`[micode] ${btcaStatus.message}`);
+  }
+
+  // Load user config for model overrides
+  const userConfig = await loadMicodeConfig();
+  if (userConfig?.agents) {
+    console.log(`[micode] Loaded model overrides for: ${Object.keys(userConfig.agents).join(", ")}`);
+  }
+
+  // Think mode state per session
+  const thinkModeState = new Map<string, boolean>();
+
+  // Hooks
+  const autoCompactHook = createAutoCompactHook(ctx);
+  const contextInjectorHook = createContextInjectorHook(ctx);
+  const autoClearLedgerHook = createAutoClearLedgerHook(ctx);
+  const ledgerLoaderHook = createLedgerLoaderHook(ctx);
+  const sessionRecoveryHook = createSessionRecoveryHook(ctx);
+  const tokenAwareTruncationHook = createTokenAwareTruncationHook(ctx);
+  const contextWindowMonitorHook = createContextWindowMonitorHook(ctx);
+  const commentCheckerHook = createCommentCheckerHook(ctx);
+  const artifactAutoIndexHook = createArtifactAutoIndexHook(ctx);
+  const fileOpsTrackerHook = createFileOpsTrackerHook(ctx);
+
+  // Background Task System
+  const backgroundTaskManager = new BackgroundTaskManager(ctx);
+  const backgroundTaskTools = createBackgroundTaskTools(backgroundTaskManager);
+
+  // PTY System
+  const ptyManager = new PTYManager();
+  const ptyTools = createPtyTools(ptyManager);
+
+  return {
+    // Tools
+    tool: {
+      ast_grep_search,
+      ast_grep_replace,
+      btca_ask,
+      look_at,
+      artifact_search,
+      ...backgroundTaskTools,
+      ...ptyTools,
+    },
+
+    config: async (config) => {
+      // Allow all permissions globally - no prompts
+      config.permission = {
+        ...config.permission,
+        edit: "allow",
+        bash: "allow",
+        webfetch: "allow",
+        doom_loop: "allow",
+        external_directory: "allow",
+      };
+
+      // Merge user config overrides into plugin agents
+      const mergedAgents = mergeAgentConfigs(agents, userConfig);
+
+      // Add our agents - our agents override OpenCode defaults, demote built-in build/plan to subagent
+      config.agent = {
+        ...config.agent, // OpenCode defaults first
+        build: { ...config.agent?.build, mode: "subagent" },
+        plan: { ...config.agent?.plan, mode: "subagent" },
+        triage: { ...config.agent?.triage, mode: "subagent" },
+        docs: { ...config.agent?.docs, mode: "subagent" },
+        // Our agents override - spread these LAST so they take precedence
+        ...Object.fromEntries(Object.entries(mergedAgents).filter(([k]) => k !== PRIMARY_AGENT_NAME)),
+        [PRIMARY_AGENT_NAME]: mergedAgents[PRIMARY_AGENT_NAME],
+      };
+
+      // Add MCP servers (plugin servers override defaults)
+      config.mcp = {
+        ...config.mcp,
+        ...MCP_SERVERS,
+      };
+
+      // Add commands
+      config.command = {
+        ...config.command,
+        init: {
+          description: "Initialize project with ARCHITECTURE.md and CODE_STYLE.md",
+          agent: "project-initializer",
+          template: `Initialize this project. $ARGUMENTS`,
+        },
+        ledger: {
+          description: "Create or update continuity ledger for session state",
+          agent: "ledger-creator",
+          template: `Update the continuity ledger. $ARGUMENTS`,
+        },
+        search: {
+          description: "Search past handoffs, plans, and ledgers",
+          agent: "artifact-searcher",
+          template: `Search for: $ARGUMENTS`,
+        },
+      };
+    },
+
+    "chat.message": async (input, output) => {
+      // Extract text from user message
+      const text = output.parts
+        .filter((p) => p.type === "text" && "text" in p)
+        .map((p) => (p as { text: string }).text)
+        .join(" ");
+
+      // Track if think mode was requested
+      thinkModeState.set(input.sessionID, detectThinkKeyword(text));
+    },
+
+    "chat.params": async (input, output) => {
+      // Inject ledger context first (highest priority)
+      await ledgerLoaderHook["chat.params"](input, output);
+
+      // Inject project context files
+      await contextInjectorHook["chat.params"](input, output);
+
+      // Inject context window status
+      await contextWindowMonitorHook["chat.params"](input, output);
+
+      // If think mode was requested, increase thinking budget
+      if (thinkModeState.get(input.sessionID)) {
+        output.options = {
+          ...output.options,
+          thinking: {
+            type: "enabled",
+            budget_tokens: 32000,
+          },
+        };
+      }
+    },
+
+    // Tool output processing
+    "tool.execute.after": async (
+      input: { tool: string; sessionID: string; callID: string; args?: Record<string, unknown> },
+      output: { output?: string },
+    ) => {
+      // Token-aware truncation
+      await tokenAwareTruncationHook["tool.execute.after"]({ name: input.tool, sessionID: input.sessionID }, output);
+
+      // Comment checker for Edit tool
+      await commentCheckerHook["tool.execute.after"]({ tool: input.tool, args: input.args }, output);
+
+      // Directory-aware context injection for Read/Edit
+      await contextInjectorHook["tool.execute.after"]({ tool: input.tool, args: input.args }, output);
+
+      // Auto-index artifacts when written to thoughts/ directories
+      await artifactAutoIndexHook["tool.execute.after"]({ tool: input.tool, args: input.args }, output);
+
+      // Track file operations for ledger
+      await fileOpsTrackerHook["tool.execute.after"](
+        { tool: input.tool, sessionID: input.sessionID, args: input.args },
+        output,
+      );
+    },
+
+    event: async ({ event }) => {
+      // Session cleanup (think mode + PTY)
+      if (event.type === "session.deleted") {
+        const props = event.properties as { info?: { id?: string } } | undefined;
+        if (props?.info?.id) {
+          thinkModeState.delete(props.info.id);
+          ptyManager.cleanupBySession(props.info.id);
+        }
+      }
+
+      // Run all event hooks
+      await autoCompactHook.event({ event });
+      await autoClearLedgerHook.event({ event });
+      await sessionRecoveryHook.event({ event });
+      await tokenAwareTruncationHook.event({ event });
+      await contextWindowMonitorHook.event({ event });
+
+      // Background task manager event handling
+      backgroundTaskManager.handleEvent(event);
+
+      // File ops tracker cleanup
+      await fileOpsTrackerHook.event({ event });
+    },
+  };
+};
+
+export default OpenCodeConfigPlugin;