opencodekit 0.2.7 → 0.3.0

package/dist/template/.opencode/package.json

@@ -11,7 +11,7 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "@opencode-ai/plugin": "1.0.162"
+    "@opencode-ai/plugin": "1.0.164"
   },
   "devDependencies": {
     "@types/better-sqlite3": "^7.6.13",

package/dist/template/.opencode/plugin/compactor.ts

@@ -0,0 +1,183 @@
+/**
+ * OpenCode Compactor Plugin
+ * Warns at token thresholds before hitting limits - graceful context management
+ *
+ * Inspired by oh-my-opencode's context-window-monitor and anthropic-auto-compact
+ */
+
+import type { Plugin } from "@opencode-ai/plugin";
+import { exec } from "child_process";
+import { readFileSync } from "fs";
+
+// Notification helpers
+function isWSL(): boolean {
+  try {
+    const release = readFileSync("/proc/version", "utf8").toLowerCase();
+    return release.includes("microsoft") || release.includes("wsl");
+  } catch {
+    return false;
+  }
+}
+
+function escapeShell(str: string): string {
+  return str.replace(/"/g, '\\"').replace(/\$/g, "\\$").replace(/`/g, "\\`");
+}
+
+function notify(title: string, message: string): void {
+  const platform = process.platform;
+  const safeTitle = title ? String(title) : "Notification";
+  const safeMessage = message ? String(message) : "";
+  const escapedTitle = escapeShell(safeTitle);
+  const escapedMessage = escapeShell(safeMessage);
+
+  let command: string;
+
+  if (platform === "darwin") {
+    command = `osascript -e 'display notification "${escapedMessage}" with title "${escapedTitle}"'`;
+  } else if (platform === "linux") {
+    command = `notify-send "${escapedTitle}" "${escapedMessage}"`;
+    if (isWSL()) {
+      command = `(${command}) 2>&1 || echo "WSL notification failed"`;
+    }
+  } else if (platform === "win32") {
+    command = `powershell -Command "Add-Type -AssemblyName System.Windows.Forms; [System.Windows.Forms.MessageBox]::Show('${escapedMessage}', '${escapedTitle}')"`;
+  } else {
+    return;
+  }
+
+  exec(command, () => {});
+}
+
+interface TokenStats {
+  used: number;
+  limit: number;
+  percentage?: number;
+}
+
+const THRESHOLDS = {
+  MODERATE: 70,
+  URGENT: 85,
+  CRITICAL: 95,
+} as const;
+
+type LogLevel = "debug" | "info" | "warn" | "error";
+
+export const CompactorPlugin: Plugin = async ({ client }) => {
+  const warnedSessions = new Map<string, number>();
+
+  client.app
+    .log({
+      body: {
+        service: "compactor-plugin",
+        level: "info",
+        message:
+          "📊 Compactor Plugin loaded - context window monitoring active",
+      },
+    })
+    .catch(() => {});
+
+  function getWarningLevel(
+    percentage: number,
+  ): { level: LogLevel; emoji: string; action: string } | null {
+    if (percentage >= THRESHOLDS.CRITICAL) {
+      return {
+        level: "error",
+        emoji: "🚨",
+        action:
+          "CRITICAL: Prune immediately or start new session. Context nearly exhausted.",
+      };
+    }
+    if (percentage >= THRESHOLDS.URGENT) {
+      return {
+        level: "warn",
+        emoji: "⚠️",
+        action:
+          "Consider pruning completed tool outputs or summarizing findings.",
+      };
+    }
+    if (percentage >= THRESHOLDS.MODERATE) {
+      return {
+        level: "info",
+        emoji: "📈",
+        action:
+          "Context at 70%. Still plenty of room - no rush, but consider consolidating.",
+      };
+    }
+    return null;
+  }
+
+  return {
+    event: async ({ event }) => {
+      const props = event.properties as Record<string, unknown>;
+
+      if (event.type === "session.updated") {
+        const info = props?.info as Record<string, unknown> | undefined;
+        const tokenStats = (info?.tokens || props?.tokens) as
+          | TokenStats
+          | undefined;
+        const sessionId = (info?.id || props?.sessionID) as string | undefined;
+
+        if (!sessionId || !tokenStats?.used || !tokenStats?.limit) return;
+
+        const pct =
+          tokenStats.percentage ||
+          Math.round((tokenStats.used / tokenStats.limit) * 100);
+        const lastWarned = warnedSessions.get(sessionId) || 0;
+
+        const warning = getWarningLevel(pct);
+        if (!warning) return;
+
+        let currentThreshold = 0;
+        if (pct >= THRESHOLDS.CRITICAL) currentThreshold = THRESHOLDS.CRITICAL;
+        else if (pct >= THRESHOLDS.URGENT) currentThreshold = THRESHOLDS.URGENT;
+        else if (pct >= THRESHOLDS.MODERATE)
+          currentThreshold = THRESHOLDS.MODERATE;
+
+        if (lastWarned >= currentThreshold) return;
+
+        warnedSessions.set(sessionId, currentThreshold);
+
+        const message = `${warning.emoji} Context: ${pct}% (${tokenStats.used.toLocaleString()}/${tokenStats.limit.toLocaleString()} tokens). ${warning.action}`;
+
+        client.app
+          .log({
+            body: {
+              service: "compactor-plugin",
+              level: warning.level,
+              message,
+            },
+          })
+          .catch(() => {});
+
+        if (pct >= THRESHOLDS.URGENT) {
+          notify(`Context ${pct}%`, warning.action);
+        }
+      }
+
+      if (event.type === "session.compacted") {
+        const sessionId = props?.sessionID as string | undefined;
+
+        if (sessionId) {
+          client.app
+            .log({
+              body: {
+                service: "compactor-plugin",
+                level: "info",
+                message: "♻️ Session compacted - context freed",
+              },
+            })
+            .catch(() => {});
+
+          warnedSessions.set(sessionId, 0);
+        }
+      }
+
+      if (event.type === "session.deleted") {
+        const sessionId = props?.sessionID as string | undefined;
+        if (sessionId) {
+          warnedSessions.delete(sessionId);
+        }
+      }
+    },
+  };
+};

package/dist/template/.opencode/plugin/enforcer.ts

@@ -0,0 +1,140 @@
+/**
+ * OpenCode Enforcer Plugin
+ * Warns when session goes idle with incomplete TODOs - prevents abandoned work
+ *
+ * Inspired by oh-my-opencode's todo-continuation-enforcer
+ */
+
+import type { Plugin } from "@opencode-ai/plugin";
+import { exec } from "child_process";
+import { readFileSync } from "fs";
+
+// Notification helpers
+function isWSL(): boolean {
+  try {
+    const release = readFileSync("/proc/version", "utf8").toLowerCase();
+    return release.includes("microsoft") || release.includes("wsl");
+  } catch {
+    return false;
+  }
+}
+
+function escapeShell(str: string): string {
+  return str.replace(/"/g, '\\"').replace(/\$/g, "\\$").replace(/`/g, "\\`");
+}
+
+function notify(title: string, message: string): void {
+  const platform = process.platform;
+  const safeTitle = title ? String(title) : "Notification";
+  const safeMessage = message ? String(message) : "";
+  const escapedTitle = escapeShell(safeTitle);
+  const escapedMessage = escapeShell(safeMessage);
+
+  let command: string;
+
+  if (platform === "darwin") {
+    command = `osascript -e 'display notification "${escapedMessage}" with title "${escapedTitle}"'`;
+  } else if (platform === "linux") {
+    command = `notify-send "${escapedTitle}" "${escapedMessage}"`;
+    if (isWSL()) {
+      command = `(${command}) 2>&1 || echo "WSL notification failed"`;
+    }
+  } else if (platform === "win32") {
+    command = `powershell -Command "Add-Type -AssemblyName System.Windows.Forms; [System.Windows.Forms.MessageBox]::Show('${escapedMessage}', '${escapedTitle}')"`;
+  } else {
+    return;
+  }
+
+  exec(command, () => {});
+}
+
+interface TodoItem {
+  status: string;
+  content?: string;
+}
+
+export const EnforcerPlugin: Plugin = async ({ client }) => {
+  const sessionTodos = new Map<string, { pending: number; total: number }>();
+
+  client.app
+    .log({
+      body: {
+        service: "enforcer-plugin",
+        level: "info",
+        message:
+          "🛡️ Enforcer Plugin loaded - TODO completion enforcement active",
+      },
+    })
+    .catch(() => {});
+
+  return {
+    event: async ({ event }) => {
+      const props = event.properties as Record<string, unknown>;
+
+      if (event.type === "todo.updated") {
+        const sessionId = props?.sessionID as string | undefined;
+        const todos = props?.todos as TodoItem[] | undefined;
+
+        if (sessionId && todos) {
+          const pending = todos.filter(
+            (t) => t.status === "pending" || t.status === "in_progress",
+          ).length;
+          const total = todos.length;
+          sessionTodos.set(sessionId, { pending, total });
+
+          if (pending > 0) {
+            client.app
+              .log({
+                body: {
+                  service: "enforcer-plugin",
+                  level: "debug",
+                  message: `📋 Session ${sessionId.slice(0, 8)}: ${pending}/${total} TODOs remaining`,
+                },
+              })
+              .catch(() => {});
+          }
+        }
+      }
+
+      if (event.type === "session.idle") {
+        const sessionId = props?.sessionID as string | undefined;
+        if (!sessionId) return;
+
+        const todoState = sessionTodos.get(sessionId);
+
+        if (todoState && todoState.pending > 0) {
+          const message = `${todoState.pending} incomplete TODO(s) remaining`;
+
+          client.app
+            .log({
+              body: {
+                service: "enforcer-plugin",
+                level: "warn",
+                message: `⚠️ Session idle with ${message}. Consider completing before stopping.`,
+              },
+            })
+            .catch(() => {});
+
+          notify("Incomplete TODOs", message);
+        } else if (todoState && todoState.total > 0) {
+          client.app
+            .log({
+              body: {
+                service: "enforcer-plugin",
+                level: "info",
+                message: `✅ All ${todoState.total} TODOs completed`,
+              },
+            })
+            .catch(() => {});
+        }
+      }
+
+      if (event.type === "session.deleted") {
+        const sessionId = props?.sessionID as string | undefined;
+        if (sessionId) {
+          sessionTodos.delete(sessionId);
+        }
+      }
+    },
+  };
+};

package/dist/template/.opencode/plugin/notification.ts

@@ -1,12 +1,59 @@
 /**
  * OpenCode Notification Plugin
  * Sends native notifications when sessions complete
+ *
+ * Cross-platform support:
+ * - macOS: Built-in (osascript)
+ * - Linux: notify-send (install: sudo apt install libnotify-bin)
+ * - WSL: notify-send + dunst (requires setup)
  */
 
 import type { Plugin } from "@opencode-ai/plugin";
+import { exec } from "child_process";
+import { readFileSync } from "fs";
+
+// Notification helpers
+function isWSL(): boolean {
+  try {
+    const release = readFileSync("/proc/version", "utf8").toLowerCase();
+    return release.includes("microsoft") || release.includes("wsl");
+  } catch {
+    return false;
+  }
+}
+
+function escapeShell(str: string): string {
+  return str.replace(/"/g, '\\"').replace(/\$/g, "\\$").replace(/`/g, "\\`");
+}
+
+function notify(title: string, message: string): void {
+  const platform = process.platform;
+  const safeTitle = title ? String(title) : "Notification";
+  const safeMessage = message ? String(message) : "";
+  const escapedTitle = escapeShell(safeTitle);
+  const escapedMessage = escapeShell(safeMessage);
+
+  let command: string;
+
+  if (platform === "darwin") {
+    command = `osascript -e 'display notification "${escapedMessage}" with title "${escapedTitle}"'`;
+  } else if (platform === "linux") {
+    command = `notify-send "${escapedTitle}" "${escapedMessage}"`;
+    if (isWSL()) {
+      command = `(${command}) 2>&1 || echo "WSL notification failed. Ensure dunst is running: dunst >/dev/null 2>&1 &"`;
+    }
+  } else if (platform === "win32") {
+    command = `powershell -Command "Add-Type -AssemblyName System.Windows.Forms; [System.Windows.Forms.MessageBox]::Show('${escapedMessage}', '${escapedTitle}')"`;
+  } else {
+    return;
+  }
+
+  exec(command, () => {});
+}
+
+export const NotificationPlugin: Plugin = async ({ client }) => {
+  const notifiedSessions = new Set<string>();
 
-export const NotificationPlugin: Plugin = async ({ client, $ }) => {
-  // Log plugin initialization
   client.app
     .log({
       body: {
@@ -19,16 +66,18 @@ export const NotificationPlugin: Plugin = async ({ client, $ }) => {
 
   return {
     event: async ({ event }) => {
-      // Send notification on session completion
       if (event.type === "session.idle") {
         const sessionId = event.properties?.sessionID;
 
-        // Get session summary with simple retry
+        if (!sessionId || notifiedSessions.has(sessionId)) {
+          return;
+        }
+        notifiedSessions.add(sessionId);
+
         setTimeout(async () => {
           try {
             let summary = "Session completed";
 
-            // Try to fetch session summary
             const messagesResponse = await client.session.messages({
               path: { id: sessionId },
             });
@@ -38,7 +87,6 @@ export const NotificationPlugin: Plugin = async ({ client, $ }) => {
                 .filter((m) => m.info.role === "user")
                 .pop();
 
-              // Type guard for summary object
               const messageSummary = lastUserMessage?.info?.summary;
               if (
                 messageSummary &&
@@ -53,13 +101,7 @@ export const NotificationPlugin: Plugin = async ({ client, $ }) => {
               }
             }
 
-            // Send notification
-            if (process.platform === "darwin") {
-              const script = `display notification "${summary.replace(/"/g, '\\"')}" with title "OpenCode"`;
-              await $`osascript -e ${script}`;
-            } else {
-              await $`notify-send "OpenCode" ${summary}`;
-            }
+            notify("OpenCode", summary);
 
             client.app
               .log({

package/dist/template/.opencode/plugin/truncator.ts

@@ -0,0 +1,190 @@
+/**
+ * OpenCode Truncator Plugin
+ * Dynamic output truncation utilities - smarter than fixed limits
+ *
+ * Inspired by oh-my-opencode's grep-output-truncator and tool-output-truncator
+ *
+ * NOTE: OpenCode doesn't currently expose tool.execute.before/after events for
+ * output modification. This plugin provides utility functions that can be used
+ * by other plugins or integrated when the API supports it.
+ */
+
+import type { Plugin } from "@opencode-ai/plugin";
+
+// Configuration
+const CONFIG = {
+	// Base limits (chars) - adjusted dynamically based on context usage
+	BASE_LIMITS: {
+		grep: 15000,
+		glob: 10000,
+		read: 30000,
+		bash: 20000,
+		default: 25000,
+	} as Record<string, number>,
+	// Context percentage thresholds for scaling
+	SCALE_FACTORS: [
+		{ threshold: 95, factor: 0.3 },
+		{ threshold: 85, factor: 0.5 },
+		{ threshold: 70, factor: 0.7 },
+		{ threshold: 50, factor: 1.0 },
+	],
+	// Minimum output to preserve (chars)
+	MIN_OUTPUT: 2000,
+};
+
+/**
+ * Get scale factor based on context usage percentage
+ */
+function getScaleFactor(contextPct: number): number {
+	for (const { threshold, factor } of CONFIG.SCALE_FACTORS) {
+		if (contextPct >= threshold) {
+			return factor;
+		}
+	}
+	return 1.0;
+}
+
+/**
+ * Get dynamic limit for a tool based on context usage
+ */
+export function getLimit(tool: string, contextPct: number): number {
+	const baseLimit = CONFIG.BASE_LIMITS[tool] || CONFIG.BASE_LIMITS.default;
+	const scaleFactor = getScaleFactor(contextPct);
+	return Math.max(CONFIG.MIN_OUTPUT, Math.floor(baseLimit * scaleFactor));
+}
+
+/**
+ * Ensure output is a string - handles objects, arrays, null, undefined
+ */
+function ensureString(output: unknown): string {
+	if (typeof output === "string") {
+		return output;
+	}
+	if (output === null || output === undefined) {
+		return "";
+	}
+	if (typeof output === "object") {
+		try {
+			return JSON.stringify(output, null, 2);
+		} catch {
+			return String(output);
+		}
+	}
+	return String(output);
+}
+
+/**
+ * Smart truncation with context preservation
+ */
+export function smartTruncate(
+	output: unknown,
+	limit: number,
+	tool: string,
+): string {
+	// Ensure we're working with a string
+	const str = ensureString(output);
+
+	// Return as-is if within limit or empty
+	if (!str || str.length <= limit) return str;
+
+	const truncatedChars = str.length - limit;
+	const truncationMsg = `\n\n[... truncated ${truncatedChars} chars to save context ...]`;
+
+	// Smart truncation strategies based on tool type
+	if (tool === "grep" || tool === "glob") {
+		// For search results: keep first and last results
+		const lines = str.split("\n");
+		const targetLines = Math.floor(limit / 80); // Assume ~80 chars per line
+
+		if (lines.length > targetLines && targetLines > 0) {
+			const keepStart = Math.max(1, Math.floor(targetLines * 0.7));
+			const keepEnd = Math.max(1, targetLines - keepStart);
+			return [
+				...lines.slice(0, keepStart),
+				`\n... [${lines.length - keepStart - keepEnd} lines truncated] ...\n`,
+				...lines.slice(-keepEnd),
+			].join("\n");
+		}
+	}
+
+	if (tool === "read") {
+		// For file reads: keep beginning and end
+		const keepStart = Math.floor(limit * 0.7);
+		const keepEnd = limit - keepStart;
+		if (keepStart > 0 && keepEnd > 0) {
+			return str.slice(0, keepStart) + truncationMsg + str.slice(-keepEnd);
+		}
+	}
+
+	if (tool === "bash") {
+		// For bash: prefer keeping the end (usually most relevant)
+		const keepStart = Math.floor(limit * 0.3);
+		const keepEnd = limit - keepStart;
+		if (keepStart > 0 && keepEnd > 0) {
+			return str.slice(0, keepStart) + truncationMsg + str.slice(-keepEnd);
+		}
+	}
+
+	// Default: balanced truncation
+	const keepStart = Math.floor(limit * 0.6);
+	const keepEnd = limit - keepStart;
+	if (keepStart > 0 && keepEnd > 0) {
+		return str.slice(0, keepStart) + truncationMsg + str.slice(-keepEnd);
+	}
+
+	// Fallback: just take first `limit` chars
+	return str.slice(0, limit) + truncationMsg;
+}
+
+export const TruncatorPlugin: Plugin = async ({ client }) => {
+	// Track current context usage for external access
+	let currentContextPct = 0;
+
+	client.app
+		.log({
+			body: {
+				service: "truncator-plugin",
+				level: "info",
+				message:
+					"✂️ Truncator Plugin loaded - dynamic truncation utilities available",
+			},
+		})
+		.catch(() => {});
+
+	return {
+		event: async ({ event }) => {
+			const props = event.properties as Record<string, unknown>;
+
+			// Track context usage from session updates
+			if (event.type === "session.updated") {
+				const info = props?.info as Record<string, unknown> | undefined;
+				const tokenStats = (info?.tokens || props?.tokens) as
+					| { percentage?: number }
+					| undefined;
+
+				if (tokenStats?.percentage) {
+					const prevPct = currentContextPct;
+					currentContextPct = tokenStats.percentage;
+
+					// Log when crossing thresholds
+					const thresholds = [50, 70, 85, 95];
+					for (const t of thresholds) {
+						if (prevPct < t && currentContextPct >= t) {
+							const limit = getLimit("default", currentContextPct);
+							client.app
+								.log({
+									body: {
+										service: "truncator-plugin",
+										level: "debug",
+										message: `✂️ Context at ${currentContextPct}% - dynamic limit now ${limit} chars`,
+									},
+								})
+								.catch(() => {});
+							break;
+						}
+					}
+				}
+			}
+		},
+	};
+};