micode 0.7.0 → 0.7.1

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

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