opencodekit 0.12.4 → 0.12.5

package/dist/template/.opencode/plugin/skill-mcp.ts

@@ -2,7 +2,8 @@ import { type ChildProcess, spawn } from "child_process";
 import { existsSync, readFileSync } from "fs";
 import { homedir } from "os";
 import { join } from "path";
-import { type Plugin, tool } from "@opencode-ai/plugin";
+import type { Plugin } from "@opencode-ai/plugin";
+import { tool } from "@opencode-ai/plugin/tool";
 
 interface McpServerConfig {
 	command: string;

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

@@ -1,80 +1,58 @@
 /**
  * OpenCode Truncator Plugin
- * Monitors tool output sizes and warns about large outputs
+ * Warns when tools return large outputs under context pressure
  *
- * NOTE: tool.execute.after hook is observation-only (returns void).
- * Actual truncation would require OpenCode core changes.
- * This plugin logs warnings when outputs are large under context pressure.
+ * Note: This doesn't actually truncate - OpenCode handles that via compaction.prune.
+ * This only adds WARNINGS that OpenCode doesn't provide.
  */
 
 import type { Plugin } from "@opencode-ai/plugin";
-import {
-	THRESHOLDS,
-	type TokenStats,
-	getContextPercentage,
-} from "./lib/notify";
-
-// Warning thresholds for output size (chars)
-const OUTPUT_WARN = {
-	MODERATE: 20000, // Warn if output > 20k at 70%+ context
-	URGENT: 10000, // Warn if output > 10k at 85%+ context
-	CRITICAL: 5000, // Warn if output > 5k at 95%+ context
-} as const;
-
-function getOutputThreshold(percentage: number): number | null {
-	if (percentage >= THRESHOLDS.CRITICAL) return OUTPUT_WARN.CRITICAL;
-	if (percentage >= THRESHOLDS.URGENT) return OUTPUT_WARN.URGENT;
-	if (percentage >= THRESHOLDS.MODERATE) return OUTPUT_WARN.MODERATE;
-	return null; // No warning under 70%
-}
 
 export const TruncatorPlugin: Plugin = async ({ client }) => {
-	// Track context percentage per session
 	const sessionContext = new Map<string, number>();
 
 	return {
 		event: async ({ event }) => {
 			const props = event.properties as Record<string, unknown>;
 
-			// Update context tracking from session updates
 			if (event.type === "session.updated") {
 				const info = props?.info as Record<string, unknown> | undefined;
 				const tokenStats = (info?.tokens || props?.tokens) as
-					| TokenStats
+					| { used: number; limit: number }
 					| undefined;
 				const sessionId = (info?.id || props?.sessionID) as string | undefined;
 
 				if (sessionId && tokenStats?.used && tokenStats?.limit) {
-					sessionContext.set(sessionId, getContextPercentage(tokenStats));
+					sessionContext.set(
+						sessionId,
+						Math.round((tokenStats.used / tokenStats.limit) * 100),
+					);
 				}
 			}
 
 			if (event.type === "session.deleted") {
 				const sessionId = props?.sessionID as string | undefined;
-				if (sessionId) sessionContext.delete(sessionId);
+				if (sessionId) {
+					sessionContext.delete(sessionId);
+				}
 			}
 		},
 
 		"tool.execute.after": async (input, output) => {
-			const toolName = input.tool;
-			const sessionId = input.sessionID;
+			const pct = sessionContext.get(input.sessionID) || 0;
+			if (pct < 70) return; // Only warn under pressure
 
-			// Get current context pressure
-			const percentage = sessionContext.get(sessionId) || 0;
-			const threshold = getOutputThreshold(percentage);
-
-			// Only check when under pressure
-			if (!threshold) return;
-
-			// Check output size
+			// Thresholds get tighter as context fills up
+			const threshold = pct >= 95 ? 5000 : pct >= 85 ? 10000 : 20000;
 			const outputStr = output.output || "";
+
 			if (outputStr.length > threshold) {
-				client.app
+				await client.app
 					.log({
 						body: {
 							service: "truncator",
-							level: percentage >= THRESHOLDS.CRITICAL ? "warn" : "info",
-							message: `Large output from ${toolName}: ${outputStr.length} chars (threshold: ${threshold}, context: ${percentage}%)`,
+							level: pct >= 95 ? "warn" : "info",
+							message: `Large output from ${input.tool}: ${outputStr.length} chars (threshold: ${threshold}, context: ${pct}%)`,
 						},
 					})
 					.catch(() => {});

package/dist/template/.opencode/plugin/tsconfig.json

@@ -1,15 +1,16 @@
 {
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "ESNext",
-    "moduleResolution": "bundler",
-    "allowSyntheticDefaultImports": true,
-    "esModuleInterop": true,
-    "strict": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "types": ["node"]
-  },
-  "include": ["**/*.ts"],
-  "exclude": ["node_modules"]
+	"compilerOptions": {
+		"target": "ES2022",
+		"module": "NodeNext",
+		"moduleResolution": "nodenext",
+		"allowSyntheticDefaultImports": true,
+		"esModuleInterop": true,
+		"strict": true,
+		"noImplicitAny": false,
+		"skipLibCheck": true,
+		"forceConsistentCasingInFileNames": true,
+		"types": ["node"]
+	},
+	"include": ["**/*.ts"],
+	"exclude": ["node_modules"]
 }

package/dist/template/.opencode/tool/bd-inbox.ts

@@ -0,0 +1,109 @@
+import path from "path";
+import { tool } from "@opencode-ai/plugin";
+import fs from "fs/promises";
+
+const RESERVATIONS_DIR = ".reservations";
+const MESSAGES_FILE = "messages.jsonl";
+
+interface Message {
+	id: string;
+	from: string;
+	to: string;
+	subj: string;
+	body?: string;
+	importance: string;
+	at: number;
+	read: boolean;
+}
+
+export default tool({
+	description:
+		"Read messages from other agents. Returns most recent messages addressed to you or broadcast to 'all'.",
+	args: {
+		n: tool.schema
+			.number()
+			.optional()
+			.default(5)
+			.describe("Max messages to return"),
+		unread: tool.schema
+			.boolean()
+			.optional()
+			.default(false)
+			.describe("Only show unread messages"),
+		ack: tool.schema
+			.array(tool.schema.string())
+			.optional()
+			.describe("Message IDs to mark as read"),
+	},
+	execute: async (args, context) => {
+		const cwd = process.cwd();
+		const agentId = context?.agent || `agent-${process.pid}`;
+		const messagesPath = path.join(cwd, RESERVATIONS_DIR, MESSAGES_FILE);
+
+		try {
+			const content = await fs.readFile(messagesPath, "utf-8");
+			if (!content.trim()) {
+				return JSON.stringify({ msgs: [], count: 0 });
+			}
+
+			const idsToAck = new Set(args.ack || []);
+			let messages: Message[] = [];
+			const lines = content.trim().split("\n");
+
+			for (const line of lines) {
+				if (!line.trim()) continue;
+				try {
+					const msg = JSON.parse(line) as Message;
+					// Filter to messages for this agent or broadcast
+					if (msg.to === "all" || msg.to === agentId) {
+						// Mark as read if in ack list
+						if (idsToAck.has(msg.id)) {
+							msg.read = true;
+						}
+						messages.push(msg);
+					}
+				} catch {
+					// Skip invalid lines
+				}
+			}
+
+			// If acking, rewrite the file
+			if (idsToAck.size > 0) {
+				const allMsgs: Message[] = [];
+				for (const line of lines) {
+					if (!line.trim()) continue;
+					try {
+						const msg = JSON.parse(line) as Message;
+						if (idsToAck.has(msg.id)) {
+							msg.read = true;
+						}
+						allMsgs.push(msg);
+					} catch {
+						// Skip
+					}
+				}
+				await fs.writeFile(
+					messagesPath,
+					allMsgs.map((m) => JSON.stringify(m)).join("\n") + "\n",
+					"utf-8",
+				);
+			}
+
+			// Filter unread if requested
+			if (args.unread) {
+				messages = messages.filter((m) => !m.read);
+			}
+
+			// Return most recent N
+			const limit = args.n || 5;
+			messages = messages.slice(-limit).reverse();
+
+			return JSON.stringify({ msgs: messages, count: messages.length });
+		} catch (e: any) {
+			if (e.code === "ENOENT") {
+				return JSON.stringify({ msgs: [], count: 0 });
+			}
+			return JSON.stringify({ error: e.message });
+		}
+	},
+});

package/dist/template/.opencode/tool/bd-msg.ts

@@ -0,0 +1,62 @@
+import path from "path";
+import { tool } from "@opencode-ai/plugin";
+import fs from "fs/promises";
+
+const RESERVATIONS_DIR = ".reservations";
+const MESSAGES_FILE = "messages.jsonl";
+
+interface Message {
+	id: string;
+	from: string;
+	to: string;
+	subj: string;
+	body?: string;
+	importance: string;
+	at: number;
+	read: boolean;
+}
+
+export default tool({
+	description:
+		"Send message to other agents or broadcast to all. Messages stored in .reservations/messages.jsonl.",
+	args: {
+		subj: tool.schema.string().describe("Message subject"),
+		body: tool.schema.string().optional().describe("Message body"),
+		to: tool.schema
+			.string()
+			.optional()
+			.default("all")
+			.describe("Recipient agent ID or 'all' for broadcast"),
+		importance: tool.schema
+			.string()
+			.optional()
+			.default("normal")
+			.describe("Priority: low | normal | high"),
+	},
+	execute: async (args, context) => {
+		if (!args.subj) {
+			return JSON.stringify({ error: "subj required" });
+		}
+
+		const cwd = process.cwd();
+		const agentId = context?.agent || `agent-${process.pid}`;
+		const messagesPath = path.join(cwd, RESERVATIONS_DIR, MESSAGES_FILE);
+
+		// Ensure dir exists
+		await fs.mkdir(path.join(cwd, RESERVATIONS_DIR), { recursive: true });
+
+		const msg: Message = {
+			id: `msg-${Date.now().toString(36)}`,
+			from: agentId,
+			to: args.to || "all",
+			subj: args.subj,
+			body: args.body,
+			importance: args.importance || "normal",
+			at: Date.now(),
+			read: false,
+		};
+
+		await fs.appendFile(messagesPath, JSON.stringify(msg) + "\n", "utf-8");
+		return JSON.stringify({ ok: 1, id: msg.id });
+	},
+});

package/dist/template/.opencode/tool/bd-release.ts

@@ -0,0 +1,71 @@
+import path from "path";
+import { tool } from "@opencode-ai/plugin";
+import fs from "fs/promises";
+
+const RESERVATIONS_DIR = ".reservations";
+
+function lockDir(filePath: string): string {
+	const safe = filePath.replace(/[/\\]/g, "_").replace(/\.\./g, "_");
+	return path.join(RESERVATIONS_DIR, `${safe}.lock`);
+}
+
+export default tool({
+	description:
+		"Release file locks. If no paths specified, lists all active locks.",
+	args: {
+		paths: tool.schema
+			.array(tool.schema.string())
+			.optional()
+			.describe("File paths to unlock (empty = list locks)"),
+	},
+	execute: async (args) => {
+		const cwd = process.cwd();
+		const reservationsPath = path.join(cwd, RESERVATIONS_DIR);
+
+		// If no paths, list locks
+		if (!args.paths?.length) {
+			try {
+				const entries = await fs.readdir(reservationsPath);
+				const locks = [];
+				const now = Date.now();
+
+				for (const entry of entries) {
+					if (entry.endsWith(".lock")) {
+						const metaPath = path.join(reservationsPath, entry, "meta.json");
+						try {
+							const content = await fs.readFile(metaPath, "utf-8");
+							const lock = JSON.parse(content);
+							if (lock.expires > now) {
+								locks.push({
+									path: lock.path,
+									agent: lock.agent,
+									expires: new Date(lock.expires).toISOString(),
+								});
+							}
+						} catch {
+							// Skip invalid locks
+						}
+					}
+				}
+
+				return JSON.stringify({ locks, count: locks.length });
+			} catch {
+				return JSON.stringify({ locks: [], count: 0 });
+			}
+		}
+
+		// Release specified paths
+		const released: string[] = [];
+		for (const filePath of args.paths) {
+			const lockPath = path.join(cwd, lockDir(filePath));
+			try {
+				await fs.rm(lockPath, { recursive: true });
+				released.push(filePath);
+			} catch {
+				// Already released or never locked
+			}
+		}
+
+		return JSON.stringify({ released });
+	},
+});

package/dist/template/.opencode/tool/bd-reserve.ts

@@ -0,0 +1,120 @@
+import path from "path";
+import { tool } from "@opencode-ai/plugin";
+import fs from "fs/promises";
+
+const RESERVATIONS_DIR = ".reservations";
+
+interface LockData {
+	path: string;
+	agent: string;
+	reason?: string;
+	created: number;
+	expires: number;
+}
+
+function lockDir(filePath: string): string {
+	const safe = filePath.replace(/[/\\]/g, "_").replace(/\.\./g, "_");
+	return path.join(RESERVATIONS_DIR, `${safe}.lock`);
+}
+
+export default tool({
+	description:
+		"Lock files for editing to prevent conflicts between agents. Uses atomic mkdir-based locking.",
+	args: {
+		paths: tool.schema
+			.array(tool.schema.string())
+			.describe("File paths to lock"),
+		reason: tool.schema
+			.string()
+			.optional()
+			.describe("Why reserving these files"),
+		ttl: tool.schema
+			.number()
+			.optional()
+			.default(600)
+			.describe("Lock TTL in seconds (default 600 = 10 min)"),
+	},
+	execute: async (args, context) => {
+		if (!args.paths?.length) {
+			return JSON.stringify({ error: "paths required" });
+		}
+
+		const cwd = process.cwd();
+		const agentId = context?.agent || `agent-${process.pid}`;
+		const ttlSeconds = args.ttl || 600;
+		const now = Date.now();
+		const expires = now + ttlSeconds * 1000;
+
+		// Ensure reservations dir exists
+		await fs.mkdir(path.join(cwd, RESERVATIONS_DIR), { recursive: true });
+
+		const granted: string[] = [];
+		const conflicts: { path: string; holder?: string }[] = [];
+
+		for (const filePath of args.paths) {
+			const lockPath = path.join(cwd, lockDir(filePath));
+			const metaPath = path.join(lockPath, "meta.json");
+
+			try {
+				// Atomic: mkdir fails if dir exists
+				await fs.mkdir(lockPath, { recursive: false });
+
+				// Lock acquired - write metadata
+				const lockData: LockData = {
+					path: filePath,
+					agent: agentId,
+					reason: args.reason,
+					created: now,
+					expires,
+				};
+				await fs.writeFile(metaPath, JSON.stringify(lockData), "utf-8");
+				granted.push(filePath);
+			} catch (e: any) {
+				if (e.code === "EEXIST") {
+					// Lock exists - check if expired or ours
+					try {
+						const content = await fs.readFile(metaPath, "utf-8");
+						const lock: LockData = JSON.parse(content);
+
+						if (lock.expires < now) {
+							// Expired - remove and retry
+							await fs.rm(lockPath, { recursive: true });
+							// Retry acquisition
+							try {
+								await fs.mkdir(lockPath, { recursive: false });
+								const lockData: LockData = {
+									path: filePath,
+									agent: agentId,
+									reason: args.reason,
+									created: now,
+									expires,
+								};
+								await fs.writeFile(metaPath, JSON.stringify(lockData), "utf-8");
+								granted.push(filePath);
+							} catch {
+								conflicts.push({ path: filePath });
+							}
+						} else if (lock.agent === agentId) {
+							// We already hold it - refresh
+							lock.expires = expires;
+							await fs.writeFile(metaPath, JSON.stringify(lock), "utf-8");
+							granted.push(filePath);
+						} else {
+							conflicts.push({ path: filePath, holder: lock.agent });
+						}
+					} catch {
+						// Corrupted lock - remove and retry
+						await fs.rm(lockPath, { recursive: true, force: true });
+						conflicts.push({ path: filePath });
+					}
+				} else {
+					conflicts.push({ path: filePath });
+				}
+			}
+		}
+
+		const response: Record<string, unknown> = { granted };
+		if (conflicts.length) response.conflicts = conflicts;
+		return JSON.stringify(response);
+	},
+});

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "opencodekit",
-	"version": "0.12.4",
+	"version": "0.12.5",
 	"description": "CLI tool for bootstrapping and managing OpenCodeKit projects",
 	"type": "module",
 	"repository": {
@@ -34,7 +34,7 @@
 	},
 	"dependencies": {
 		"@clack/prompts": "^0.7.0",
-		"@opencode-ai/plugin": "^1.0.141",
+		"@opencode-ai/plugin": "^1.1.2",
 		"beads-village": "^1.3.3",
 		"cac": "^6.7.14",
 		"cli-table3": "^0.6.5",