micode 0.6.0 → 0.7.1

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;
+    }
+  }
+}

package/src/hooks/comment-checker.ts

@@ -0,0 +1,120 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+
+// Patterns that indicate excessive/unnecessary comments
+const EXCESSIVE_COMMENT_PATTERNS = [
+  // Obvious comments that explain what code does (not why)
+  /\/\/\s*(increment|decrement|add|subtract|set|get|return|call|create|initialize|init)\s+/i,
+  /\/\/\s*(the|this|a|an)\s+(following|above|below|next|previous)/i,
+  // Section dividers
+  /\/\/\s*[-=]{3,}/,
+  /\/\/\s*#{3,}/,
+  // Empty or whitespace-only comments
+  /\/\/\s*$/,
+  // "End of" comments
+  /\/\/\s*end\s+(of|function|class|method|if|loop|for|while)/i,
+];
+
+// Patterns that are valid and should be ignored
+const VALID_COMMENT_PATTERNS = [
+  // TODO/FIXME/NOTE comments
+  /\/\/\s*(TODO|FIXME|NOTE|HACK|XXX|BUG|WARN):/i,
+  // JSDoc/TSDoc
+  /^\s*\*|\/\*\*/,
+  // Directive comments (eslint, prettier, ts, etc.)
+  /\/\/\s*@|\/\/\s*eslint|\/\/\s*prettier|\/\/\s*ts-|\/\/\s*type:/i,
+  // License headers
+  /\/\/\s*(copyright|license|spdx)/i,
+  // BDD-style comments (describe, it, given, when, then)
+  /\/\/\s*(given|when|then|and|but|describe|it|should|expect)/i,
+  // URL references
+  /\/\/\s*https?:\/\//i,
+  // Regex explanations (often necessary)
+  /\/\/\s*regex|\/\/\s*pattern/i,
+];
+
+interface CommentIssue {
+  line: number;
+  comment: string;
+  reason: string;
+}
+
+function analyzeComments(content: string): CommentIssue[] {
+  const issues: CommentIssue[] = [];
+  const lines = content.split("\n");
+
+  let consecutiveComments = 0;
+  let lastCommentLine = -2;
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const trimmed = line.trim();
+
+    // Check for comment lines
+    if (trimmed.startsWith("//") || trimmed.startsWith("/*") || trimmed.startsWith("*")) {
+      // Skip valid patterns
+      if (VALID_COMMENT_PATTERNS.some((p) => p.test(trimmed))) {
+        continue;
+      }
+
+      // Check for excessive patterns
+      for (const pattern of EXCESSIVE_COMMENT_PATTERNS) {
+        if (pattern.test(trimmed)) {
+          issues.push({
+            line: i + 1,
+            comment: trimmed.slice(0, 60) + (trimmed.length > 60 ? "..." : ""),
+            reason: "Explains what, not why",
+          });
+          break;
+        }
+      }
+
+      // Track consecutive comments (might indicate over-documentation)
+      if (i === lastCommentLine + 1) {
+        consecutiveComments++;
+        if (consecutiveComments > 5) {
+          issues.push({
+            line: i + 1,
+            comment: trimmed.slice(0, 60),
+            reason: "Excessive consecutive comments",
+          });
+        }
+      } else {
+        consecutiveComments = 1;
+      }
+      lastCommentLine = i;
+    }
+  }
+
+  return issues;
+}
+
+export function createCommentCheckerHook(_ctx: PluginInput) {
+  return {
+    // Check after file edits
+    "tool.execute.after": async (
+      input: { tool: string; args?: Record<string, unknown> },
+      output: { output?: string },
+    ) => {
+      // Only check Edit tool
+      if (input.tool !== "Edit" && input.tool !== "edit") return;
+
+      const newString = input.args?.new_string as string | undefined;
+      if (!newString) return;
+
+      const issues = analyzeComments(newString);
+
+      if (issues.length > 0) {
+        const warning = `\n\n⚠️ **Comment Check**: Found ${issues.length} potentially unnecessary comment(s):\n${issues
+          .slice(0, 3)
+          .map((i) => `- Line ${i.line}: "${i.comment}" (${i.reason})`)
+          .join(
+            "\n",
+          )}${issues.length > 3 ? `\n...and ${issues.length - 3} more` : ""}\n\nComments should explain WHY, not WHAT. Consider removing obvious comments.`;
+
+        if (output.output) {
+          output.output += warning;
+        }
+      }
+    },
+  };
+}