micode 0.6.0 → 0.7.1

package/src/hooks/context-injector.ts

@@ -0,0 +1,163 @@
+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
+const ROOT_CONTEXT_FILES = ["ARCHITECTURE.md", "CODE_STYLE.md", "AGENTS.md", "CLAUDE.md", "README.md"] as const;
+
+// Files to collect when walking up directories
+const DIRECTORY_CONTEXT_FILES = ["AGENTS.md", "README.md"] as const;
+
+// Tools that trigger directory-aware context injection
+const FILE_ACCESS_TOOLS = ["Read", "read", "Edit", "edit"];
+
+// Cache for file contents
+interface ContextCache {
+  rootContent: Map<string, string>;
+  directoryContent: Map<string, Map<string, string>>; // path -> filename -> content
+  lastRootCheck: number;
+}
+
+const CACHE_TTL = 30_000; // 30 seconds
+
+export function createContextInjectorHook(ctx: PluginInput) {
+  const cache: ContextCache = {
+    rootContent: new Map(),
+    directoryContent: new Map(),
+    lastRootCheck: 0,
+  };
+
+  async function loadRootContextFiles(): Promise<Map<string, string>> {
+    const now = Date.now();
+
+    if (now - cache.lastRootCheck < CACHE_TTL && cache.rootContent.size > 0) {
+      return cache.rootContent;
+    }
+
+    cache.rootContent.clear();
+    cache.lastRootCheck = now;
+
+    for (const filename of ROOT_CONTEXT_FILES) {
+      try {
+        const filepath = join(ctx.directory, filename);
+        const content = await readFile(filepath, "utf-8");
+        if (content.trim()) {
+          cache.rootContent.set(filename, content);
+        }
+      } catch {
+        // File doesn't exist - skip
+      }
+    }
+
+    return cache.rootContent;
+  }
+
+  async function walkUpForContextFiles(filePath: string): Promise<Map<string, string>> {
+    const absPath = resolve(filePath);
+    const projectRoot = resolve(ctx.directory);
+
+    // Check cache
+    const cacheKey = dirname(absPath);
+    if (cache.directoryContent.has(cacheKey)) {
+      return cache.directoryContent.get(cacheKey)!;
+    }
+
+    const collected = new Map<string, string>();
+    let currentDir = dirname(absPath);
+
+    // Walk up from file directory to project root
+    while (currentDir.startsWith(projectRoot) || currentDir === projectRoot) {
+      for (const filename of DIRECTORY_CONTEXT_FILES) {
+        const contextPath = join(currentDir, filename);
+        const relPath = currentDir.replace(projectRoot, "").replace(/^\//, "") || ".";
+        const key = `${relPath}/${filename}`;
+
+        // Skip if already have this file from a closer directory
+        if (!collected.has(key)) {
+          try {
+            const content = await readFile(contextPath, "utf-8");
+            if (content.trim()) {
+              collected.set(key, content);
+            }
+          } catch {
+            // File doesn't exist - skip
+          }
+        }
+      }
+
+      // Stop at project root
+      if (currentDir === projectRoot) break;
+
+      // Move up
+      const parent = dirname(currentDir);
+      if (parent === currentDir) break; // Reached filesystem root
+      currentDir = parent;
+    }
+
+    // Cache for this directory
+    cache.directoryContent.set(cacheKey, collected);
+
+    // Limit cache size
+    if (cache.directoryContent.size > 100) {
+      const firstKey = cache.directoryContent.keys().next().value;
+      if (firstKey) cache.directoryContent.delete(firstKey);
+    }
+
+    return collected;
+  }
+
+  function formatContextBlock(files: Map<string, string>, label: string): string {
+    if (files.size === 0) return "";
+
+    const blocks: string[] = [];
+
+    for (const [filename, content] of files) {
+      blocks.push(`<context file="${filename}">\n${content}\n</context>`);
+    }
+
+    return `\n<${label}>\n${blocks.join("\n\n")}\n</${label}>\n`;
+  }
+
+  return {
+    // Inject project root context into every chat
+    "chat.params": async (
+      _input: { sessionID: string },
+      output: { options?: Record<string, unknown>; system?: string },
+    ) => {
+      const files = await loadRootContextFiles();
+      if (files.size === 0) return;
+
+      const contextBlock = formatContextBlock(files, "project-context");
+
+      if (output.system) {
+        output.system = output.system + contextBlock;
+      } else {
+        output.system = contextBlock;
+      }
+    },
+
+    // Inject directory-specific context when reading/editing files
+    "tool.execute.after": async (
+      input: { tool: string; args?: Record<string, unknown> },
+      output: { output?: string },
+    ) => {
+      if (!FILE_ACCESS_TOOLS.includes(input.tool)) return;
+
+      const filePath = input.args?.file_path as string | undefined;
+      if (!filePath) return;
+
+      try {
+        const directoryFiles = await walkUpForContextFiles(filePath);
+        if (directoryFiles.size === 0) return;
+
+        const contextBlock = formatContextBlock(directoryFiles, "directory-context");
+
+        if (output.output) {
+          output.output = output.output + contextBlock;
+        }
+      } catch {
+        // Ignore errors in context injection
+      }
+    },
+  };
+}

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

@@ -0,0 +1,106 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+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(),
+    lastUsageRatio: new Map(),
+  };
+
+  function getEncouragementMessage(usageRatio: number): string {
+    const remaining = Math.round((1 - usageRatio) * 100);
+
+    if (usageRatio < WARNING_THRESHOLD) {
+      return ""; // No message needed
+    }
+
+    if (usageRatio < CRITICAL_THRESHOLD) {
+      return `Context: ${remaining}% remaining. Plenty of room - don't rush.`;
+    }
+
+    return `Context: ${remaining}% remaining. Consider wrapping up or compacting soon.`;
+  }
+
+  return {
+    // Inject context awareness into chat params
+    "chat.params": async (
+      input: { sessionID: string },
+      output: { system?: string; options?: Record<string, unknown> },
+    ) => {
+      const usageRatio = state.lastUsageRatio.get(input.sessionID);
+
+      if (usageRatio && usageRatio >= WARNING_THRESHOLD) {
+        const message = getEncouragementMessage(usageRatio);
+        if (message && output.system) {
+          output.system = `${output.system}\n\n<context-status>${message}</context-status>`;
+        }
+      }
+    },
+
+    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.lastWarningTime.delete(sessionInfo.id);
+          state.lastUsageRatio.delete(sessionInfo.id);
+        }
+        return;
+      }
+
+      // Track 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") return;
+
+        const usage = info.usage as Record<string, unknown> | undefined;
+        const inputTokens = (usage?.inputTokens as number) || 0;
+        const cacheRead = (usage?.cacheReadInputTokens as number) || 0;
+        const totalUsed = inputTokens + cacheRead;
+
+        const modelID = (info.modelID as string) || "";
+        const contextLimit = getContextLimit(modelID);
+        const usageRatio = totalUsed / contextLimit;
+
+        state.lastUsageRatio.set(sessionID, usageRatio);
+
+        // Show toast warning if threshold crossed
+        if (usageRatio >= WARNING_THRESHOLD) {
+          const lastWarning = state.lastWarningTime.get(sessionID) || 0;
+          if (Date.now() - lastWarning > WARNING_COOLDOWN_MS) {
+            state.lastWarningTime.set(sessionID, Date.now());
+
+            const remaining = Math.round((1 - usageRatio) * 100);
+            const variant = usageRatio >= CRITICAL_THRESHOLD ? "warning" : "info";
+
+            await ctx.client.tui
+              .showToast({
+                body: {
+                  title: "Context Window",
+                  message: `${remaining}% remaining (${Math.round(totalUsed / 1000)}K / ${Math.round(contextLimit / 1000)}K tokens)`,
+                  variant,
+                  duration: 4000,
+                },
+              })
+              .catch(() => {});
+          }
+        }
+      }
+    },
+  };
+}

package/src/hooks/file-ops-tracker.ts

@@ -0,0 +1,96 @@
+// src/hooks/file-ops-tracker.ts
+import type { PluginInput } from "@opencode-ai/plugin";
+
+interface FileOps {
+  read: Set<string>;
+  modified: Set<string>;
+}
+
+// Per-session file operation tracking
+const sessionFileOps = new Map<string, FileOps>();
+
+function getOrCreateOps(sessionID: string): FileOps {
+  let ops = sessionFileOps.get(sessionID);
+  if (!ops) {
+    ops = { read: new Set(), modified: new Set() };
+    sessionFileOps.set(sessionID, ops);
+  }
+  return ops;
+}
+
+export function trackFileOp(sessionID: string, operation: "read" | "write" | "edit", filePath: string): void {
+  const ops = getOrCreateOps(sessionID);
+  if (operation === "read") {
+    ops.read.add(filePath);
+  } else {
+    // write and edit both modify files
+    ops.modified.add(filePath);
+  }
+}
+
+export function getFileOps(sessionID: string): FileOps {
+  const ops = sessionFileOps.get(sessionID);
+  if (!ops) {
+    return { read: new Set(), modified: new Set() };
+  }
+  return ops;
+}
+
+export function clearFileOps(sessionID: string): void {
+  sessionFileOps.delete(sessionID);
+}
+
+export function getAndClearFileOps(sessionID: string): FileOps {
+  const ops = getFileOps(sessionID);
+  // Return copies of the sets before clearing
+  const result = {
+    read: new Set(ops.read),
+    modified: new Set(ops.modified),
+  };
+  clearFileOps(sessionID);
+  return result;
+}
+
+export function formatFileOpsForPrompt(ops: FileOps): string {
+  const readPaths = Array.from(ops.read).sort();
+  const modifiedPaths = Array.from(ops.modified).sort();
+
+  let result = "<file-operations>\n";
+  result += `Read: ${readPaths.length > 0 ? readPaths.join(", ") : "(none)"}\n`;
+  result += `Modified: ${modifiedPaths.length > 0 ? modifiedPaths.join(", ") : "(none)"}\n`;
+  result += "</file-operations>";
+
+  return result;
+}
+
+export function createFileOpsTrackerHook(_ctx: PluginInput) {
+  return {
+    "tool.execute.after": async (
+      input: { tool: string; sessionID: string; args?: Record<string, unknown> },
+      _output: { output?: string },
+    ) => {
+      const toolName = input.tool.toLowerCase();
+
+      // Only track read, write, edit tools
+      if (!["read", "write", "edit"].includes(toolName)) {
+        return;
+      }
+
+      // Extract file path from args
+      const filePath = input.args?.filePath as string | undefined;
+      if (!filePath) return;
+
+      trackFileOp(input.sessionID, toolName as "read" | "write" | "edit", filePath);
+    },
+
+    event: async ({ event }: { event: { type: string; properties?: unknown } }) => {
+      // Clean up on session delete
+      if (event.type === "session.deleted") {
+        const props = event.properties as { info?: { id?: string } } | undefined;
+        if (props?.info?.id) {
+          clearFileOps(props.info.id);
+        }
+      }
+    },
+  };
+}

package/src/hooks/ledger-loader.ts

@@ -0,0 +1,78 @@
+// src/hooks/ledger-loader.ts
+import type { PluginInput } from "@opencode-ai/plugin";
+import { readFile, readdir } from "node:fs/promises";
+import { join } from "node:path";
+
+const LEDGER_DIR = "thoughts/ledgers";
+const LEDGER_PREFIX = "CONTINUITY_";
+
+export interface LedgerInfo {
+  sessionName: string;
+  filePath: string;
+  content: string;
+}
+
+export async function findCurrentLedger(directory: string): Promise<LedgerInfo | null> {
+  const ledgerDir = join(directory, LEDGER_DIR);
+
+  try {
+    const files = await readdir(ledgerDir);
+    const ledgerFiles = files.filter((f) => f.startsWith(LEDGER_PREFIX) && f.endsWith(".md"));
+
+    if (ledgerFiles.length === 0) return null;
+
+    // Get most recently modified ledger
+    let latestFile = ledgerFiles[0];
+    let latestMtime = 0;
+
+    for (const file of ledgerFiles) {
+      const filePath = join(ledgerDir, file);
+      try {
+        const stat = await Bun.file(filePath).stat();
+        if (stat && stat.mtime.getTime() > latestMtime) {
+          latestMtime = stat.mtime.getTime();
+          latestFile = file;
+        }
+      } catch {
+        // Skip files we can't stat
+      }
+    }
+
+    const filePath = join(ledgerDir, latestFile);
+    const content = await readFile(filePath, "utf-8");
+    const sessionName = latestFile.replace(LEDGER_PREFIX, "").replace(".md", "");
+
+    return { sessionName, filePath, content };
+  } catch {
+    return null;
+  }
+}
+
+export function formatLedgerInjection(ledger: LedgerInfo): string {
+  return `<continuity-ledger session="${ledger.sessionName}">
+${ledger.content}
+</continuity-ledger>
+
+You are resuming work from a previous context clear. The ledger above contains your session state.
+Review it and continue from where you left off. The "Now" item is your current focus.`;
+}
+
+export function createLedgerLoaderHook(ctx: PluginInput) {
+  return {
+    "chat.params": async (
+      _input: { sessionID: string },
+      output: { options?: Record<string, unknown>; system?: string },
+    ) => {
+      const ledger = await findCurrentLedger(ctx.directory);
+      if (!ledger) return;
+
+      const injection = formatLedgerInjection(ledger);
+
+      if (output.system) {
+        output.system = `${injection}\n\n${output.system}`;
+      } else {
+        output.system = injection;
+      }
+    },
+  };
+}

package/src/hooks/preemptive-compaction.ts

@@ -0,0 +1,183 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+
+// Model context limits (tokens)
+const MODEL_CONTEXT_LIMITS: Record<string, number> = {
+  // Anthropic
+  "claude-opus": 200_000,
+  "claude-sonnet": 200_000,
+  "claude-haiku": 200_000,
+  "claude-3": 200_000,
+  "claude-4": 200_000,
+  // OpenAI
+  "gpt-4o": 128_000,
+  "gpt-4-turbo": 128_000,
+  "gpt-4": 128_000,
+  "gpt-5": 200_000,
+  o1: 200_000,
+  o3: 200_000,
+  // Google
+  gemini: 1_000_000,
+};
+
+const DEFAULT_CONTEXT_LIMIT = 200_000;
+const DEFAULT_THRESHOLD = 0.6; // 60% of context window
+const MIN_TOKENS_FOR_COMPACTION = 50_000;
+const COMPACTION_COOLDOWN_MS = 60_000; // 60 seconds
+
+function getContextLimit(modelID: string): number {
+  const modelLower = modelID.toLowerCase();
+  for (const [pattern, limit] of Object.entries(MODEL_CONTEXT_LIMITS)) {
+    if (modelLower.includes(pattern)) {
+      return limit;
+    }
+  }
+  return DEFAULT_CONTEXT_LIMIT;
+}
+
+interface CompactionState {
+  lastCompactionTime: Map<string, number>;
+  compactionInProgress: Set<string>;
+}
+
+export function createPreemptiveCompactionHook(ctx: PluginInput) {
+  const state: CompactionState = {
+    lastCompactionTime: new Map(),
+    compactionInProgress: new Set(),
+  };
+
+  async function checkAndCompact(sessionID: string, providerID?: string, modelID?: string): Promise<void> {
+    // Skip if compaction in progress
+    if (state.compactionInProgress.has(sessionID)) return;
+
+    // Respect cooldown
+    const lastTime = state.lastCompactionTime.get(sessionID) || 0;
+    if (Date.now() - lastTime < COMPACTION_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_COMPACTION) 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;
+
+      // Skip if last message was already a summary
+      const lastUserMsg = [...messages].reverse().find((m) => {
+        const msg = m as Record<string, unknown>;
+        const msgInfo = msg.info as Record<string, unknown> | undefined;
+        return msgInfo?.role === "user";
+      }) as Record<string, unknown> | undefined;
+
+      if (lastUserMsg) {
+        const parts = lastUserMsg.parts as Array<{ type: string; text?: string }> | undefined;
+        const text = parts?.find((p) => p.type === "text")?.text || "";
+        if (text.includes("summarized") || text.includes("compacted")) return;
+      }
+
+      // Trigger compaction
+      state.compactionInProgress.add(sessionID);
+      state.lastCompactionTime.set(sessionID, Date.now());
+
+      await ctx.client.tui
+        .showToast({
+          body: {
+            title: "Context Window",
+            message: `${Math.round(usageRatio * 100)}% used - auto-compacting...`,
+            variant: "warning",
+            duration: 3000,
+          },
+        })
+        .catch(() => {});
+
+      const provider = providerID || (info?.providerID as string);
+      const modelToUse = modelID || (info?.modelID as string);
+
+      if (provider && modelToUse) {
+        await ctx.client.session.summarize({
+          path: { id: sessionID },
+          body: { providerID: provider, modelID: modelToUse },
+          query: { directory: ctx.directory },
+        });
+
+        await ctx.client.tui
+          .showToast({
+            body: {
+              title: "Compacted",
+              message: "Session summarized successfully",
+              variant: "success",
+              duration: 3000,
+            },
+          })
+          .catch(() => {});
+      }
+    } catch (_e) {
+      // Silent failure - don't interrupt user flow
+    } finally {
+      state.compactionInProgress.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.lastCompactionTime.delete(sessionInfo.id);
+          state.compactionInProgress.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 checkAndCompact(sessionID, providerID, modelID);
+        }
+      }
+
+      // Check when session goes idle
+      if (event.type === "session.idle") {
+        const sessionID = props?.sessionID as string | undefined;
+        if (sessionID) {
+          await checkAndCompact(sessionID);
+        }
+      }
+    },
+  };
+}