opencodekit 0.9.2 → 0.10.0

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

@@ -1,140 +1,190 @@
 /**
  * OpenCode Enforcer Plugin
- * Warns when session goes idle with incomplete TODOs - prevents abandoned work
+ * ENFORCES continuation when session idles with incomplete TODOs
  *
- * Inspired by oh-my-opencode's todo-continuation-enforcer
+ * Upgrade from notification-only to actual enforcement:
+ * Uses client.session.promptAsync() to inject continuation prompt
  */
 
 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;
-  }
-}
+import { notify } from "./lib/notify";
 
-function escapeShell(str: string): string {
-  return str.replace(/"/g, '\\"').replace(/\$/g, "\\$").replace(/`/g, "\\`");
+interface TodoItem {
+	id: string;
+	content: string;
+	status: "pending" | "in_progress" | "completed" | "cancelled";
+	priority: "high" | "medium" | "low";
 }
 
-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, () => {});
-}
+// Cooldown to prevent rapid-fire enforcement (5 minutes)
+const ENFORCEMENT_COOLDOWN_MS = 5 * 60 * 1000;
 
-interface TodoItem {
-  status: string;
-  content?: string;
+// Track last enforcement time per session
+const lastEnforcement = new Map<string, number>();
+
+// Track todos per session
+const sessionTodos = new Map<string, TodoItem[]>();
+
+/**
+ * Build continuation prompt based on incomplete TODOs
+ */
+function buildContinuationPrompt(incomplete: TodoItem[]): string {
+	const highPriority = incomplete.filter((t) => t.priority === "high");
+	const inProgress = incomplete.filter((t) => t.status === "in_progress");
+
+	let prompt = "You stopped with incomplete work. Continue immediately.\n\n";
+
+	if (inProgress.length > 0) {
+		prompt += "**In Progress (finish these first):**\n";
+		inProgress.forEach((t) => {
+			prompt += `- ${t.content}\n`;
+		});
+		prompt += "\n";
+	}
+
+	if (highPriority.length > 0) {
+		const remaining = highPriority.filter((t) => t.status !== "in_progress");
+		if (remaining.length > 0) {
+			prompt += "**High Priority:**\n";
+			remaining.forEach((t) => {
+				prompt += `- ${t.content}\n`;
+			});
+			prompt += "\n";
+		}
+	}
+
+	const others = incomplete.filter(
+		(t) => t.priority !== "high" && t.status !== "in_progress",
+	);
+	if (others.length > 0) {
+		prompt += "**Remaining:**\n";
+		others.slice(0, 5).forEach((t) => {
+			prompt += `- ${t.content}\n`;
+		});
+		if (others.length > 5) {
+			prompt += `- ... and ${others.length - 5} more\n`;
+		}
+	}
+
+	prompt += "\nPick up where you left off. Do not ask for confirmation.";
+
+	return prompt;
 }
 
-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);
-        }
-      }
-    },
-  };
+export const EnforcerPlugin: Plugin = async ({ client, $ }) => {
+	return {
+		event: async ({ event }) => {
+			const props = event.properties as Record<string, unknown>;
+
+			// Track TODO updates
+			if (event.type === "todo.updated") {
+				const sessionId = props?.sessionID as string | undefined;
+				const todos = props?.todos as TodoItem[] | undefined;
+
+				if (sessionId && todos) {
+					sessionTodos.set(sessionId, todos);
+				}
+			}
+
+			// Enforce on session idle
+			if (event.type === "session.idle") {
+				const sessionId = props?.sessionID as string | undefined;
+				if (!sessionId) return;
+
+				const todos = sessionTodos.get(sessionId) || [];
+				const incomplete = todos.filter(
+					(t) => t.status === "pending" || t.status === "in_progress",
+				);
+
+				// No incomplete TODOs - nothing to enforce
+				if (incomplete.length === 0) return;
+
+				// Check cooldown to prevent spam
+				const now = Date.now();
+				const lastTime = lastEnforcement.get(sessionId) || 0;
+				if (now - lastTime < ENFORCEMENT_COOLDOWN_MS) {
+					return; // Still in cooldown
+				}
+
+				// Count high priority and in-progress
+				const highPriority = incomplete.filter((t) => t.priority === "high");
+				const inProgress = incomplete.filter((t) => t.status === "in_progress");
+
+				// Only enforce for high-priority or in-progress items
+				// Low priority pending items don't warrant forced continuation
+				if (highPriority.length === 0 && inProgress.length === 0) {
+					// Just notify for low-priority items
+					await notify(
+						$,
+						"Session Idle",
+						`📋 ${incomplete.length} TODO${incomplete.length > 1 ? "s" : ""} remaining`,
+					);
+					return;
+				}
+
+				// Update cooldown
+				lastEnforcement.set(sessionId, now);
+
+				// Build and send continuation prompt
+				const continuationPrompt = buildContinuationPrompt(incomplete);
+
+				try {
+					await client.session.promptAsync({
+						path: { id: sessionId },
+						body: {
+							parts: [
+								{
+									type: "text",
+									text: continuationPrompt,
+								},
+							],
+						},
+					});
+
+					client.app
+						.log({
+							body: {
+								service: "enforcer",
+								level: "info",
+								message: `Enforced continuation: ${inProgress.length} in-progress, ${highPriority.length} high-priority TODOs`,
+							},
+						})
+						.catch(() => {});
+
+					await notify(
+						$,
+						"Enforcer",
+						`Continuing ${inProgress.length + highPriority.length} incomplete TODOs`,
+					);
+				} catch (error) {
+					// Fallback to notification if prompt fails
+					client.app
+						.log({
+							body: {
+								service: "enforcer",
+								level: "warn",
+								message: `Enforcement failed: ${(error as Error).message}`,
+							},
+						})
+						.catch(() => {});
+
+					const message =
+						highPriority.length > 0
+							? `🔴 ${highPriority.length} high-priority TODO${highPriority.length > 1 ? "s" : ""} incomplete`
+							: `🟡 ${inProgress.length} TODO${inProgress.length > 1 ? "s" : ""} still in progress`;
+
+					await notify($, "Session Idle", message);
+				}
+			}
+
+			// Cleanup on session delete
+			if (event.type === "session.deleted") {
+				const sessionId = props?.sessionID as string | undefined;
+				if (sessionId) {
+					sessionTodos.delete(sessionId);
+					lastEnforcement.delete(sessionId);
+				}
+			}
+		},
+	};
 };

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

@@ -0,0 +1,150 @@
+/**
+ * OpenCode AGENTS.md Hierarchy Injector Plugin
+ *
+ * Walks up from read file's directory to project root, collecting ALL AGENTS.md
+ * files and injecting them into context. Solves the limitation where OpenCode's
+ * findUp only finds the first match.
+ *
+ * Injection order: root → specific (T-shaped context loading)
+ */
+
+import { existsSync, readFileSync } from "fs";
+import { dirname, join, resolve } from "path";
+import type { Plugin } from "@opencode-ai/plugin";
+
+// Cache injected directories per session to avoid duplicates
+const sessionInjectedDirs = new Map<string, Set<string>>();
+
+/**
+ * Walk up from a directory to root, collecting all AGENTS.md files
+ */
+function collectAgentsMdFiles(
+	startDir: string,
+	projectRoot: string,
+): { path: string; content: string }[] {
+	const files: { path: string; content: string }[] = [];
+	let currentDir = resolve(startDir);
+	const root = resolve(projectRoot);
+
+	// Walk up until we hit project root or filesystem root
+	while (currentDir.startsWith(root) || currentDir === root) {
+		const agentsMdPath = join(currentDir, "AGENTS.md");
+
+		if (existsSync(agentsMdPath)) {
+			try {
+				const content = readFileSync(agentsMdPath, "utf-8");
+				files.push({ path: agentsMdPath, content });
+			} catch {
+				// Skip unreadable files
+			}
+		}
+
+		// Move up one directory
+		const parentDir = dirname(currentDir);
+		if (parentDir === currentDir) break; // Hit filesystem root
+		currentDir = parentDir;
+	}
+
+	// Reverse so root comes first (T-shaped: general → specific)
+	return files.reverse();
+}
+
+/**
+ * Check if a file path is a code file (not AGENTS.md itself)
+ */
+function isCodeFile(filePath: string): boolean {
+	const lowerPath = filePath.toLowerCase();
+
+	// Skip AGENTS.md files themselves
+	if (lowerPath.endsWith("agents.md")) return false;
+
+	// Skip common non-code files
+	if (lowerPath.includes("node_modules/")) return false;
+	if (lowerPath.includes("/.git/")) return false;
+
+	return true;
+}
+
+/**
+ * Format injected AGENTS.md content
+ */
+function formatInjection(
+	files: { path: string; content: string }[],
+	projectRoot: string,
+): string {
+	if (files.length === 0) return "";
+
+	const sections = files.map((f) => {
+		const relativePath = f.path.replace(projectRoot, "").replace(/^\//, "");
+		return `<!-- AGENTS.md from: ${relativePath} -->\n${f.content}`;
+	});
+
+	return (
+		"\n\n---\n## Injected AGENTS.md Hierarchy\n\n" +
+		sections.join("\n\n---\n\n") +
+		"\n---\n\n"
+	);
+}
+
+export const InjectorPlugin: Plugin = async ({ directory, worktree }) => {
+	// Use worktree if available (git worktree), otherwise use directory
+	const projectRoot = worktree || directory;
+
+	return {
+		"tool.execute.after": async (input, output) => {
+			// Only process read tool
+			if (input.tool !== "read") return;
+
+			// Get the file path from metadata
+			const filePath = output.metadata?.filePath as string | undefined;
+			if (!filePath) return;
+
+			// Skip non-code files
+			if (!isCodeFile(filePath)) return;
+
+			// Get or create session cache
+			let injectedDirs = sessionInjectedDirs.get(input.sessionID);
+			if (!injectedDirs) {
+				injectedDirs = new Set();
+				sessionInjectedDirs.set(input.sessionID, injectedDirs);
+			}
+
+			// Get the directory of the read file
+			const fileDir = dirname(resolve(filePath));
+
+			// Check if we've already injected for this directory chain
+			if (injectedDirs.has(fileDir)) return;
+
+			// Collect AGENTS.md files
+			const agentsFiles = collectAgentsMdFiles(fileDir, projectRoot);
+
+			// Skip if no AGENTS.md files found
+			if (agentsFiles.length === 0) return;
+
+			// Mark this directory as injected
+			injectedDirs.add(fileDir);
+
+			// Also mark parent directories to avoid redundant injections
+			let dir = fileDir;
+			while (dir.startsWith(projectRoot) && dir !== projectRoot) {
+				injectedDirs.add(dir);
+				dir = dirname(dir);
+			}
+
+			// Inject at the beginning of output
+			const injection = formatInjection(agentsFiles, projectRoot);
+			output.output = injection + output.output;
+		},
+
+		event: async ({ event }) => {
+			// Clean up cache when session is deleted
+			if (event.type === "session.deleted") {
+				const props = event.properties as Record<string, unknown>;
+				const sessionId = props?.sessionID as string | undefined;
+				if (sessionId) {
+					sessionInjectedDirs.delete(sessionId);
+				}
+			}
+		},
+	};
+};

package/dist/template/.opencode/plugin/lib/notify.ts

@@ -0,0 +1,86 @@
+/**
+ * Shared notification utilities for OpenCode plugins
+ * Uses Bun's shell API ($) as recommended by official docs
+ */
+
+// Cache WSL detection result
+let _isWSL: boolean | null = null;
+
+/**
+ * Check if running in WSL (cached)
+ */
+export function isWSL(): boolean {
+	if (_isWSL !== null) return _isWSL;
+	try {
+		const fs = require("fs");
+		const release = fs.readFileSync("/proc/version", "utf8").toLowerCase();
+		_isWSL = release.includes("microsoft") || release.includes("wsl");
+	} catch {
+		_isWSL = false;
+	}
+	return _isWSL ?? false;
+}
+
+/**
+ * Send native notification using Bun shell API
+ * @param $ - Bun shell from plugin context
+ * @param title - Notification title
+ * @param message - Notification body
+ */
+export async function notify(
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	$: any,
+	title: string,
+	message: string,
+): Promise<void> {
+	const platform = process.platform;
+	const safeTitle = title || "OpenCode";
+	const safeMessage = message || "";
+
+	try {
+		if (platform === "darwin") {
+			await $`osascript -e ${'display notification "' + safeMessage + '" with title "' + safeTitle + '"'}`;
+		} else if (platform === "linux") {
+			if (isWSL()) {
+				// WSL: try notify-send, fail silently
+				await $`notify-send ${safeTitle} ${safeMessage}`.catch(() => {});
+			} else {
+				await $`notify-send ${safeTitle} ${safeMessage}`;
+			}
+		} else if (platform === "win32") {
+			// Windows: PowerShell toast (fire and forget)
+			await $`powershell -Command "Add-Type -AssemblyName System.Windows.Forms; [System.Windows.Forms.MessageBox]::Show('${safeMessage}', '${safeTitle}')"`.catch(
+				() => {},
+			);
+		}
+	} catch {
+		// Notifications are best-effort, never throw
+	}
+}
+
+/**
+ * Threshold configuration for context monitoring
+ */
+export const THRESHOLDS = {
+	MODERATE: 70,
+	URGENT: 85,
+	CRITICAL: 95,
+} as const;
+
+/**
+ * Token statistics from session events
+ */
+export interface TokenStats {
+	used: number;
+	limit: number;
+	percentage?: number;
+}
+
+/**
+ * Calculate context percentage from token stats
+ */
+export function getContextPercentage(stats: TokenStats): number {
+	if (stats.percentage) return stats.percentage;
+	if (stats.limit > 0) return Math.round((stats.used / stats.limit) * 100);
+	return 0;
+}