opencodekit 0.14.6 → 0.15.0

package/dist/template/.opencode/tool/background.ts

@@ -1,509 +0,0 @@
-/**
- * @experimental Background Task Tool
- *
- * LIMITATION: Creates SEPARATE sessions, NOT child sessions of the parent.
- * This means background tasks don't inherit context from the build agent's session.
- *
- * USE CASES:
- * - True fire-and-forget async execution
- * - When you need to continue working before results are ready
- *
- * FOR MOST CASES: Use the Task tool instead. Multiple Task calls in one message
- * run in parallel AND create proper child sessions.
- *
- * Example with Task (recommended):
- *   Task({ subagent_type: "scout", prompt: "..." })  // ┐
- *   Task({ subagent_type: "explore", prompt: "..." }) // ┘ Parallel, proper sessions
- *
- * Example with Background (fire-and-forget):
- *   background_start({ agent: "scout", prompt: "..." }) // → taskId
- *   // ... continue other work ...
- *   background_output({ taskId }) // collect later
- */
-
-import { type ChildProcess, execSync, spawn } from "node:child_process";
-import fs from "node:fs/promises";
-import path from "node:path";
-import { tool } from "@opencode-ai/plugin";
-
-const TASKS_FILE = ".opencode/.background-tasks.json";
-const OUTPUT_DIR = ".opencode/.background-output";
-
-interface BackgroundTask {
-	taskId: string;
-	pid: number;
-	outputFile: string;
-	agent: string;
-	prompt: string;
-	started: number;
-	status: "running" | "completed" | "cancelled" | "failed";
-	// Beads integration
-	beadId?: string;
-	autoCloseBead?: boolean;
-}
-
-interface TasksStore {
-	tasks: Record<string, BackgroundTask>;
-}
-
-async function loadTasks(): Promise<TasksStore> {
-	try {
-		const content = await fs.readFile(TASKS_FILE, "utf-8");
-		return JSON.parse(content);
-	} catch {
-		return { tasks: {} };
-	}
-}
-
-async function saveTasks(store: TasksStore): Promise<void> {
-	await fs.mkdir(path.dirname(TASKS_FILE), { recursive: true });
-	await fs.writeFile(TASKS_FILE, JSON.stringify(store, null, 2));
-}
-
-async function ensureOutputDir(): Promise<void> {
-	await fs.mkdir(OUTPUT_DIR, { recursive: true });
-}
-
-/**
- * Find the bd binary path dynamically
- */
-function findBdPath(): string {
-	try {
-		const result = execSync("which bd || command -v bd", {
-			encoding: "utf-8",
-			timeout: 5000,
-			shell: "/bin/sh",
-		}).trim();
-		if (result) return result;
-	} catch {
-		const commonPaths = [
-			`${process.env.HOME}/.local/bin/bd`,
-			`${process.env.HOME}/.bun/bin/bd`,
-			"/usr/local/bin/bd",
-			"/opt/homebrew/bin/bd",
-		];
-		for (const p of commonPaths) {
-			try {
-				execSync(`test -x "${p}"`, { timeout: 1000 });
-				return p;
-			} catch {
-				// Try next path
-			}
-		}
-	}
-	return "bd";
-}
-
-let bdPath: string | null = null;
-function getBdPath(): string {
-	if (!bdPath) {
-		bdPath = findBdPath();
-	}
-	return bdPath;
-}
-
-/**
- * Helper to run beads CLI commands
- */
-async function runBeadsCommand(
-	args: string[],
-): Promise<{ success: boolean; output: string }> {
-	try {
-		const quotedArgs = args.map((arg) =>
-			arg.includes(" ") ? `"${arg}"` : arg,
-		);
-		const output = execSync(`${getBdPath()} ${quotedArgs.join(" ")}`, {
-			encoding: "utf-8",
-			timeout: 30000,
-			shell: "/bin/sh",
-			env: { ...process.env },
-		});
-		return { success: true, output };
-	} catch (e) {
-		const error = e as { stderr?: string; message?: string };
-		return {
-			success: false,
-			output: error.stderr || error.message || String(e),
-		};
-	}
-}
-
-/**
- * Check if a process is still running by PID
- */
-function isProcessRunning(pid: number): boolean {
-	try {
-		process.kill(pid, 0); // Signal 0 = check if process exists
-		return true;
-	} catch {
-		return false;
-	}
-}
-
-// Allowed agents for background delegation
-const ALLOWED_AGENTS = [
-	"explore",
-	"scout",
-	"review",
-	"planner",
-	"vision",
-	"looker",
-	"rush",
-] as const;
-type AllowedAgent = (typeof ALLOWED_AGENTS)[number];
-
-// Agents safe for autoCloseBead (pure research, no side effects)
-const SAFE_AUTOCLOSE_AGENTS: readonly string[] = [
-	"explore",
-	"scout",
-	"looker",
-] as const;
-
-/**
- * Start a background subagent task using `opencode run`.
- * Spawns a separate process that runs independently.
- */
-export const start = tool({
-	description:
-		"Start a background subagent task. Returns a task_id to collect results later. Use for parallel research/exploration or executing beads subtasks. NOTE: Cannot delegate to 'build' agent (build is the orchestrator).",
-	args: {
-		agent: tool.schema
-			.string()
-			.describe(
-				"Agent type: explore, scout, review, planner, vision, looker, rush (NOT build)",
-			),
-		prompt: tool.schema.string().describe("Task prompt for the agent"),
-		title: tool.schema
-			.string()
-			.optional()
-			.describe("Optional task title for identification"),
-		beadId: tool.schema
-			.string()
-			.optional()
-			.describe("Bead ID to associate with this task (e.g., bd-abc123)"),
-		autoCloseBead: tool.schema
-			.boolean()
-			.optional()
-			.describe(
-				"Auto-close bead on completion. Only allowed for safe agents (explore, scout, looker).",
-			),
-	},
-	execute: async (args) => {
-		// Validate agent type
-		if (args.agent === "build") {
-			return JSON.stringify({
-				error:
-					"Cannot delegate to 'build' agent. Build is the orchestrator. Use subagents instead.",
-			});
-		}
-
-		if (!ALLOWED_AGENTS.includes(args.agent as AllowedAgent)) {
-			return JSON.stringify({
-				error: `Invalid agent type: ${args.agent}. Allowed: ${ALLOWED_AGENTS.join(", ")}`,
-			});
-		}
-
-		// Validate autoCloseBead
-		if (args.autoCloseBead && !SAFE_AUTOCLOSE_AGENTS.includes(args.agent)) {
-			return JSON.stringify({
-				error: `autoCloseBead not allowed for '${args.agent}' agent. Only safe for: ${SAFE_AUTOCLOSE_AGENTS.join(", ")}`,
-			});
-		}
-
-		await ensureOutputDir();
-
-		const taskId = `bg_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
-		const title = args.title || `bg-${args.agent}-${taskId}`;
-		const outputFile = path.join(OUTPUT_DIR, `${taskId}.txt`);
-
-		try {
-			// Create output file to capture stdout
-			const outFd = await fs.open(outputFile, "w");
-
-			// Spawn opencode run with the agent and prompt
-			// Using --format default for readable output (json is too verbose for collection)
-			const proc = spawn(
-				"opencode",
-				[
-					"run",
-					"--agent",
-					args.agent,
-					"--title",
-					title,
-					"--format",
-					"default",
-					args.prompt,
-				],
-				{
-					detached: true, // Run independently of parent
-					stdio: ["ignore", outFd.fd, outFd.fd], // Redirect stdout/stderr to file
-					cwd: process.cwd(),
-					env: { ...process.env },
-				},
-			);
-
-			// Don't wait for completion - let it run in background
-			proc.unref();
-
-			// Close our handle to the output file (process keeps its own)
-			await outFd.close();
-
-			if (!proc.pid) {
-				return JSON.stringify({ error: "Failed to spawn opencode process" });
-			}
-
-			// Persist task info
-			const store = await loadTasks();
-			store.tasks[taskId] = {
-				taskId,
-				pid: proc.pid,
-				outputFile,
-				agent: args.agent,
-				prompt: args.prompt,
-				started: Date.now(),
-				status: "running",
-				beadId: args.beadId,
-				autoCloseBead: args.autoCloseBead,
-			};
-			await saveTasks(store);
-
-			// If beadId provided, mark it as in_progress
-			if (args.beadId) {
-				await runBeadsCommand([
-					"update",
-					args.beadId,
-					"--status",
-					"in_progress",
-				]);
-			}
-
-			return JSON.stringify({
-				taskId,
-				pid: proc.pid,
-				agent: args.agent,
-				beadId: args.beadId,
-				status: "started",
-				message: `Background task started. Use background_output(taskId="${taskId}") to get results.`,
-			});
-		} catch (e) {
-			const error = e instanceof Error ? e.message : String(e);
-			return JSON.stringify({
-				error: `Failed to start background task: ${error}`,
-			});
-		}
-	},
-});
-
-/**
- * Get output from a background task.
- * Reads the output file and checks if the process has completed.
- */
-export const output = tool({
-	description:
-		"Get output from a background task. Returns the agent's response or 'still running' if not complete.",
-	args: {
-		taskId: tool.schema.string().describe("Task ID from background_start"),
-	},
-	execute: async (args) => {
-		const store = await loadTasks();
-		const task = store.tasks[args.taskId];
-
-		if (!task) {
-			return JSON.stringify({
-				error: `Task not found: ${args.taskId}`,
-				availableTasks: Object.keys(store.tasks),
-			});
-		}
-
-		try {
-			// Check if process is still running
-			const running = isProcessRunning(task.pid);
-
-			// Read output file
-			let output = "";
-			try {
-				output = await fs.readFile(task.outputFile, "utf-8");
-			} catch {
-				output = "(no output yet)";
-			}
-
-			// If still running and no substantial output
-			if (running && output.length < 100) {
-				return JSON.stringify({
-					taskId: args.taskId,
-					agent: task.agent,
-					status: "running",
-					message: "Task still running - no complete response yet",
-					partialOutput: output.slice(0, 500),
-				});
-			}
-
-			// Process completed or has substantial output
-			if (!running) {
-				// Update status
-				task.status = output.length > 0 ? "completed" : "failed";
-				await saveTasks(store);
-			}
-
-			// Build result object
-			const result: Record<string, unknown> = {
-				taskId: args.taskId,
-				agent: task.agent,
-				status: running ? "running" : task.status,
-				output: output || "(empty response)",
-			};
-
-			// Handle bead closing (only if completed)
-			if (task.beadId && !running && task.status === "completed") {
-				result.beadId = task.beadId;
-
-				if (task.autoCloseBead && SAFE_AUTOCLOSE_AGENTS.includes(task.agent)) {
-					const closeResult = await runBeadsCommand([
-						"close",
-						task.beadId,
-						"--reason",
-						`Auto-closed: ${task.agent} task completed (${task.taskId})`,
-					]);
-					result.beadClosed = closeResult.success;
-					if (!closeResult.success) {
-						result.beadCloseError = closeResult.output;
-					}
-				} else {
-					result.beadAction = `VERIFY output, then run: bd close ${task.beadId} --reason "..."`;
-				}
-			}
-
-			return JSON.stringify(result);
-		} catch (e) {
-			const error = e instanceof Error ? e.message : String(e);
-			return JSON.stringify({
-				taskId: args.taskId,
-				error: `Failed to get output: ${error}`,
-			});
-		}
-	},
-});
-
-/**
- * Cancel background tasks by killing the process.
- */
-export const cancel = tool({
-	description:
-		"Cancel background tasks. Use all=true to cancel all, or specify taskId.",
-	args: {
-		all: tool.schema
-			.boolean()
-			.optional()
-			.describe("Cancel all background tasks"),
-		taskId: tool.schema
-			.string()
-			.optional()
-			.describe("Specific task ID to cancel"),
-	},
-	execute: async (args) => {
-		const store = await loadTasks();
-		const cancelled: string[] = [];
-		const errors: string[] = [];
-
-		const tasksToCancel = args.all
-			? Object.values(store.tasks).filter((t) => t.status === "running")
-			: args.taskId && store.tasks[args.taskId]
-				? [store.tasks[args.taskId]]
-				: [];
-
-		if (!tasksToCancel.length) {
-			return JSON.stringify({
-				message: args.all
-					? "No running tasks to cancel"
-					: `Task not found: ${args.taskId}`,
-				activeTasks: Object.values(store.tasks)
-					.filter((t) => t.status === "running")
-					.map((t) => t.taskId),
-			});
-		}
-
-		for (const task of tasksToCancel) {
-			try {
-				// Kill the process and its children (negative PID kills process group)
-				try {
-					process.kill(-task.pid, "SIGTERM");
-				} catch {
-					// Try without process group
-					process.kill(task.pid, "SIGTERM");
-				}
-				task.status = "cancelled";
-				cancelled.push(task.taskId);
-			} catch (e) {
-				const error = e instanceof Error ? e.message : String(e);
-				// Process might already be dead
-				if (error.includes("ESRCH")) {
-					task.status = "cancelled";
-					cancelled.push(task.taskId);
-				} else {
-					errors.push(`${task.taskId}: ${error}`);
-				}
-			}
-		}
-
-		await saveTasks(store);
-
-		return JSON.stringify({
-			cancelled,
-			errors: errors.length ? errors : undefined,
-			remaining: Object.values(store.tasks)
-				.filter((t) => t.status === "running")
-				.map((t) => t.taskId),
-		});
-	},
-});
-
-/**
- * List all background tasks with their status.
- */
-export const list = tool({
-	description: "List all background tasks with their status.",
-	args: {
-		status: tool.schema
-			.enum(["running", "completed", "cancelled", "failed", "all"])
-			.optional()
-			.default("all")
-			.describe("Filter by status"),
-	},
-	execute: async (args) => {
-		const store = await loadTasks();
-		const tasks = Object.values(store.tasks);
-
-		// Update status of running tasks
-		for (const task of tasks) {
-			if (task.status === "running" && !isProcessRunning(task.pid)) {
-				// Process finished, check if it has output
-				try {
-					const output = await fs.readFile(task.outputFile, "utf-8");
-					task.status = output.length > 0 ? "completed" : "failed";
-				} catch {
-					task.status = "failed";
-				}
-			}
-		}
-		await saveTasks(store);
-
-		const filtered =
-			args.status === "all"
-				? tasks
-				: tasks.filter((t) => t.status === args.status);
-
-		return JSON.stringify({
-			total: filtered.length,
-			tasks: filtered.map((t) => ({
-				taskId: t.taskId,
-				agent: t.agent,
-				status: t.status,
-				pid: t.pid,
-				started: new Date(t.started).toISOString(),
-				running: t.status === "running" ? isProcessRunning(t.pid) : false,
-				prompt: t.prompt.slice(0, 100) + (t.prompt.length > 100 ? "..." : ""),
-				beadId: t.beadId,
-			})),
-		});
-	},
-});

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

@@ -1,110 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import { tool } from "@opencode-ai/plugin";
-
-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) {
-			const err = e as NodeJS.ErrnoException;
-			if (err.code === "ENOENT") {
-				return JSON.stringify({ msgs: [], count: 0 });
-			}
-			return JSON.stringify({ error: (e as Error).message });
-		}
-	},
-});

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

@@ -1,62 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import { tool } from "@opencode-ai/plugin";
-
-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 });
-	},
-});