opencodekit 0.15.20 → 0.15.21

package/dist/template/.opencode/tool/beads-sync.ts

@@ -0,0 +1,657 @@
+import { exec } from "node:child_process";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { promisify } from "node:util";
+import { tool } from "@opencode-ai/plugin";
+
+const execAsync = promisify(exec);
+
+// OpenCode's native todo storage location
+const OPENCODE_TODO_DIR = path.join(
+	process.env.HOME || "",
+	".local",
+	"share",
+	"opencode",
+	"storage",
+	"todo",
+);
+
+// Shared task lists for cross-session coordination
+const SHARED_TASKS_DIR = path.join(
+	process.env.HOME || "",
+	".local",
+	"share",
+	"opencode",
+	"storage",
+	"shared-tasks",
+);
+
+interface BeadTask {
+	id: string;
+	title: string;
+	status: "open" | "in_progress" | "closed";
+	priority: number;
+	labels: string[];
+	blockedBy: string[];
+	blocks: string[];
+}
+
+interface TodoItem {
+	id: string;
+	content: string;
+	status: "pending" | "in_progress" | "completed" | "cancelled";
+	priority: "high" | "medium" | "low";
+	blockedBy?: string[];
+	blocks?: string[];
+	beadId?: string;
+	phase?: string;
+}
+
+interface SharedTaskList {
+	id: string;
+	name: string;
+	created: string;
+	updated: string;
+	tasks: TodoItem[];
+}
+
+export default tool({
+	description: `Bridge between Beads git-backed tasks and OpenCode's native todo system.
+
+Operations:
+- push: Sync Beads tasks to OpenCode todos (makes them visible to subagents via todoread)
+- pull: Update Beads from completed OpenCode todos
+- create_shared: Create a shared task list for cross-session swarm coordination
+- get_shared: Get a shared task list by ID
+- update_shared: Update tasks in a shared list
+- list_shared: List all shared task lists for this project
+
+Usage:
+  beads-sync({ operation: "push" })  // Push current Beads to OpenCode todos
+  beads-sync({ operation: "create_shared", name: "api-refactor-swarm", tasks: [...] })
+  beads-sync({ operation: "get_shared", list_id: "abc123" })`,
+
+	args: {
+		operation: tool.schema
+			.enum([
+				"push",
+				"pull",
+				"create_shared",
+				"get_shared",
+				"update_shared",
+				"list_shared",
+			])
+			.describe("Sync operation to perform"),
+		session_id: tool.schema
+			.string()
+			.optional()
+			.describe("Target session ID (defaults to current)"),
+		list_id: tool.schema
+			.string()
+			.optional()
+			.describe("Shared task list ID (for get_shared/update_shared)"),
+		name: tool.schema
+			.string()
+			.optional()
+			.describe("Name for new shared task list"),
+		tasks: tool.schema
+			.string()
+			.optional()
+			.describe("JSON array of tasks (for create_shared/update_shared)"),
+		filter: tool.schema
+			.string()
+			.optional()
+			.describe("Filter by status: open, in_progress, all (default: open)"),
+	},
+
+	execute: async (args, ctx) => {
+		const worktree = ctx.worktree || process.cwd();
+
+		switch (args.operation) {
+			case "push":
+				return await pushBeadsToTodos(
+					worktree,
+					args.session_id,
+					args.filter || "open",
+				);
+			case "pull":
+				return await pullTodosToBeads(worktree, args.session_id);
+			case "create_shared":
+				return await createSharedList(args.name, args.tasks, worktree);
+			case "get_shared":
+				return await getSharedList(args.list_id);
+			case "update_shared":
+				return await updateSharedList(args.list_id, args.tasks);
+			case "list_shared":
+				return await listSharedLists(worktree);
+			default:
+				return `Error: Unknown operation: ${args.operation}`;
+		}
+	},
+});
+
+/**
+ * Push Beads tasks to OpenCode's native todo storage
+ * This makes Beads visible to subagents via todoread
+ */
+async function pushBeadsToTodos(
+	worktree: string,
+	sessionId?: string,
+	filter = "open",
+): Promise<string> {
+	try {
+		// Get beads tasks using bd list
+		const statusFilter = filter === "all" ? "" : `--status=${filter}`;
+		const { stdout } = await execAsync(`bd list ${statusFilter} --json`, {
+			cwd: worktree,
+		});
+
+		let beadTasks: BeadTask[];
+		try {
+			beadTasks = JSON.parse(stdout);
+		} catch {
+			// bd list might not support --json, parse text output
+			beadTasks = parseBeadListOutput(stdout);
+		}
+
+		if (beadTasks.length === 0) {
+			return JSON.stringify(
+				{
+					success: true,
+					message: "No Beads tasks to sync",
+					synced: 0,
+				},
+				null,
+				2,
+			);
+		}
+
+		// Convert to OpenCode todo format
+		const todos: TodoItem[] = beadTasks.map((bead) => ({
+			id: bead.id,
+			content: `[Bead] ${bead.title}`,
+			status: mapBeadStatus(bead.status),
+			priority: mapBeadPriority(bead.priority),
+			blockedBy: bead.blockedBy || [],
+			blocks: bead.blocks || [],
+			beadId: bead.id,
+		}));
+
+		// Write to OpenCode todo storage
+		const targetSessionId = sessionId || (await getCurrentSessionId(worktree));
+		const todoPath = path.join(OPENCODE_TODO_DIR, `${targetSessionId}.json`);
+
+		await fs.mkdir(OPENCODE_TODO_DIR, { recursive: true });
+		await fs.writeFile(todoPath, JSON.stringify(todos, null, 2), "utf-8");
+
+		return JSON.stringify(
+			{
+				success: true,
+				message: `Synced ${todos.length} Beads tasks to OpenCode todos`,
+				synced: todos.length,
+				session_id: targetSessionId,
+				todo_path: todoPath,
+				tasks: todos.map((t) => ({
+					id: t.id,
+					content: t.content,
+					status: t.status,
+					blockedBy: t.blockedBy,
+				})),
+			},
+			null,
+			2,
+		);
+	} catch (error: any) {
+		return JSON.stringify(
+			{
+				success: false,
+				error: `Failed to push Beads to todos: ${error.message}`,
+			},
+			null,
+			2,
+		);
+	}
+}
+
+/**
+ * Pull completed todos back to Beads
+ */
+async function pullTodosToBeads(
+	worktree: string,
+	sessionId?: string,
+): Promise<string> {
+	try {
+		const targetSessionId = sessionId || (await getCurrentSessionId(worktree));
+		const todoPath = path.join(OPENCODE_TODO_DIR, `${targetSessionId}.json`);
+
+		let todos: TodoItem[];
+		try {
+			const content = await fs.readFile(todoPath, "utf-8");
+			todos = JSON.parse(content);
+		} catch {
+			return JSON.stringify(
+				{
+					success: true,
+					message: "No todos to pull",
+					updated: 0,
+				},
+				null,
+				2,
+			);
+		}
+
+		// Find completed todos that came from Beads
+		const completedBeadTodos = todos.filter(
+			(t) => t.beadId && t.status === "completed",
+		);
+
+		if (completedBeadTodos.length === 0) {
+			return JSON.stringify(
+				{
+					success: true,
+					message: "No completed Bead todos to update",
+					updated: 0,
+				},
+				null,
+				2,
+			);
+		}
+
+		// Update Beads status
+		const updated: string[] = [];
+		for (const todo of completedBeadTodos) {
+			try {
+				await execAsync(
+					`bd close ${todo.beadId} --reason "Completed via todo"`,
+					{ cwd: worktree },
+				);
+				updated.push(todo.beadId!);
+			} catch {
+				// Bead might already be closed
+			}
+		}
+
+		return JSON.stringify(
+			{
+				success: true,
+				message: `Updated ${updated.length} Beads from completed todos`,
+				updated: updated.length,
+				bead_ids: updated,
+			},
+			null,
+			2,
+		);
+	} catch (error: any) {
+		return JSON.stringify(
+			{
+				success: false,
+				error: `Failed to pull todos to Beads: ${error.message}`,
+			},
+			null,
+			2,
+		);
+	}
+}
+
+/**
+ * Create a shared task list for cross-session swarm coordination
+ */
+async function createSharedList(
+	name?: string,
+	tasksJson?: string,
+	worktree?: string,
+): Promise<string> {
+	if (!name) {
+		return JSON.stringify({ success: false, error: "name is required" });
+	}
+
+	try {
+		const listId = generateListId();
+		let tasks: TodoItem[] = [];
+
+		if (tasksJson) {
+			try {
+				tasks = JSON.parse(tasksJson);
+			} catch {
+				return JSON.stringify({
+					success: false,
+					error: "Invalid tasks JSON",
+				});
+			}
+		}
+
+		const sharedList: SharedTaskList = {
+			id: listId,
+			name,
+			created: new Date().toISOString(),
+			updated: new Date().toISOString(),
+			tasks,
+		};
+
+		// Get project ID from worktree
+		const projectDir = worktree || process.cwd();
+		const projectId = path.basename(projectDir);
+		const listPath = path.join(SHARED_TASKS_DIR, projectId, `${listId}.json`);
+
+		await fs.mkdir(path.dirname(listPath), { recursive: true });
+		await fs.writeFile(listPath, JSON.stringify(sharedList, null, 2), "utf-8");
+
+		return JSON.stringify(
+			{
+				success: true,
+				message: `Created shared task list: ${name}`,
+				list_id: listId,
+				path: listPath,
+				task_count: tasks.length,
+				usage: `Share with workers: SHARED_TASK_LIST_ID=${listId}`,
+			},
+			null,
+			2,
+		);
+	} catch (error: any) {
+		return JSON.stringify(
+			{
+				success: false,
+				error: `Failed to create shared list: ${error.message}`,
+			},
+			null,
+			2,
+		);
+	}
+}
+
+/**
+ * Get a shared task list by ID
+ */
+async function getSharedList(listId?: string): Promise<string> {
+	if (!listId) {
+		return JSON.stringify({ success: false, error: "list_id is required" });
+	}
+
+	try {
+		// Search in all project directories
+		const projectDirs = await fs.readdir(SHARED_TASKS_DIR).catch(() => []);
+
+		for (const projectId of projectDirs) {
+			const listPath = path.join(SHARED_TASKS_DIR, projectId, `${listId}.json`);
+			try {
+				const content = await fs.readFile(listPath, "utf-8");
+				const list: SharedTaskList = JSON.parse(content);
+
+				// Calculate stats
+				const completed = list.tasks.filter(
+					(t) => t.status === "completed",
+				).length;
+				const pending = list.tasks.filter((t) => t.status === "pending").length;
+				const inProgress = list.tasks.filter(
+					(t) => t.status === "in_progress",
+				).length;
+
+				return JSON.stringify(
+					{
+						success: true,
+						list,
+						stats: {
+							total: list.tasks.length,
+							completed,
+							pending,
+							in_progress: inProgress,
+							progress_percent: Math.round(
+								(completed / list.tasks.length) * 100,
+							),
+						},
+					},
+					null,
+					2,
+				);
+			} catch {
+				continue;
+			}
+		}
+
+		return JSON.stringify({
+			success: false,
+			error: `Shared list not found: ${listId}`,
+		});
+	} catch (error: any) {
+		return JSON.stringify(
+			{
+				success: false,
+				error: `Failed to get shared list: ${error.message}`,
+			},
+			null,
+			2,
+		);
+	}
+}
+
+/**
+ * Update tasks in a shared list
+ */
+async function updateSharedList(
+	listId?: string,
+	tasksJson?: string,
+): Promise<string> {
+	if (!listId) {
+		return JSON.stringify({ success: false, error: "list_id is required" });
+	}
+
+	try {
+		// Find the list
+		const projectDirs = await fs.readdir(SHARED_TASKS_DIR).catch(() => []);
+		let listPath: string | null = null;
+		let existingList: SharedTaskList | null = null;
+
+		for (const projectId of projectDirs) {
+			const candidatePath = path.join(
+				SHARED_TASKS_DIR,
+				projectId,
+				`${listId}.json`,
+			);
+			try {
+				const content = await fs.readFile(candidatePath, "utf-8");
+				existingList = JSON.parse(content);
+				listPath = candidatePath;
+				break;
+			} catch {
+				continue;
+			}
+		}
+
+		if (!listPath || !existingList) {
+			return JSON.stringify({
+				success: false,
+				error: `Shared list not found: ${listId}`,
+			});
+		}
+
+		// Parse and merge updates
+		if (tasksJson) {
+			try {
+				const updates: Partial<TodoItem>[] = JSON.parse(tasksJson);
+
+				for (const update of updates) {
+					if (!update.id) continue;
+
+					const existingTask = existingList.tasks.find(
+						(t) => t.id === update.id,
+					);
+					if (existingTask) {
+						Object.assign(existingTask, update);
+					} else {
+						existingList.tasks.push(update as TodoItem);
+					}
+				}
+			} catch {
+				return JSON.stringify({
+					success: false,
+					error: "Invalid tasks JSON",
+				});
+			}
+		}
+
+		existingList.updated = new Date().toISOString();
+		await fs.writeFile(
+			listPath,
+			JSON.stringify(existingList, null, 2),
+			"utf-8",
+		);
+
+		return JSON.stringify(
+			{
+				success: true,
+				message: `Updated shared list: ${existingList.name}`,
+				list_id: listId,
+				task_count: existingList.tasks.length,
+			},
+			null,
+			2,
+		);
+	} catch (error: any) {
+		return JSON.stringify(
+			{
+				success: false,
+				error: `Failed to update shared list: ${error.message}`,
+			},
+			null,
+			2,
+		);
+	}
+}
+
+/**
+ * List all shared task lists for this project
+ */
+async function listSharedLists(worktree?: string): Promise<string> {
+	try {
+		const projectDir = worktree || process.cwd();
+		const projectId = path.basename(projectDir);
+		const projectListDir = path.join(SHARED_TASKS_DIR, projectId);
+
+		let files: string[];
+		try {
+			files = await fs.readdir(projectListDir);
+		} catch {
+			return JSON.stringify(
+				{
+					success: true,
+					lists: [],
+					message: "No shared task lists found for this project",
+				},
+				null,
+				2,
+			);
+		}
+
+		const lists: Array<{
+			id: string;
+			name: string;
+			task_count: number;
+			completed: number;
+			updated: string;
+		}> = [];
+
+		for (const file of files) {
+			if (!file.endsWith(".json")) continue;
+
+			try {
+				const content = await fs.readFile(
+					path.join(projectListDir, file),
+					"utf-8",
+				);
+				const list: SharedTaskList = JSON.parse(content);
+				lists.push({
+					id: list.id,
+					name: list.name,
+					task_count: list.tasks.length,
+					completed: list.tasks.filter((t) => t.status === "completed").length,
+					updated: list.updated,
+				});
+			} catch {
+				continue;
+			}
+		}
+
+		return JSON.stringify(
+			{
+				success: true,
+				lists,
+				count: lists.length,
+			},
+			null,
+			2,
+		);
+	} catch (error: any) {
+		return JSON.stringify(
+			{
+				success: false,
+				error: `Failed to list shared lists: ${error.message}`,
+			},
+			null,
+			2,
+		);
+	}
+}
+
+// Helper functions
+
+function parseBeadListOutput(output: string): BeadTask[] {
+	const lines = output.trim().split("\n").filter(Boolean);
+	const tasks: BeadTask[] = [];
+
+	for (const line of lines) {
+		// Parse lines like: #123 [open] (P2) Task title
+		const match = line.match(/^#?(\S+)\s+\[(\w+)\]\s+(?:\(P(\d)\))?\s*(.+)$/);
+		if (match) {
+			tasks.push({
+				id: match[1],
+				status: match[2] as BeadTask["status"],
+				priority: match[3] ? Number.parseInt(match[3]) : 2,
+				title: match[4],
+				labels: [],
+				blockedBy: [],
+				blocks: [],
+			});
+		}
+	}
+
+	return tasks;
+}
+
+function mapBeadStatus(
+	status: string,
+): "pending" | "in_progress" | "completed" | "cancelled" {
+	switch (status) {
+		case "open":
+			return "pending";
+		case "in_progress":
+			return "in_progress";
+		case "closed":
+			return "completed";
+		default:
+			return "pending";
+	}
+}
+
+function mapBeadPriority(priority: number): "high" | "medium" | "low" {
+	if (priority <= 1) return "high";
+	if (priority <= 2) return "medium";
+	return "low";
+}
+
+async function getCurrentSessionId(worktree: string): Promise<string> {
+	// Try to get from environment or generate based on project
+	const envSessionId = process.env.OPENCODE_SESSION_ID;
+	if (envSessionId) return envSessionId;
+
+	// Generate a session-like ID based on project path
+	const projectName = path.basename(worktree);
+	const timestamp = Date.now().toString(36);
+	return `ses_${timestamp}_${projectName.slice(0, 10)}`;
+}
+
+function generateListId(): string {
+	const timestamp = Date.now().toString(36);
+	const random = Math.random().toString(36).slice(2, 8);
+	return `shl_${timestamp}${random}`;
+}

package/dist/template/.opencode/{tools → tool}/swarm-delegate.ts

@@ -41,22 +41,27 @@ async function fileExists(filePath: string): Promise<boolean> {
 }
 
 export default tool({
-	description: `Generate a Swarm delegation packet (Beads-as-board).
+	description: `Generate a delegation packet for Task tool workers.
 
 Purpose:
-- Creates a consistent delegation envelope for a specific Beads task
+- Creates a consistent delegation envelope for parallel Task execution
 - Optionally appends it to .beads/artifacts/<id>/delegation.md
 
-Example (use actual task from user request):
+Recommended skills for workers:
+- verification-before-completion: Must verify before claiming done
+- test-driven-development: Write tests first, watch fail, implement, verify pass
+- tool-priority: Use LSP before edits, grep for patterns, read before edit
+
+Example:
 swarm-delegate({
   bead_id: "<bead-id>",
-  title: "<phase> - <worker-id>",
-  expected_outcome: "<specific outcome for this worker's assigned files>",
+  title: "<task-title>",
+  expected_outcome: "<specific outcome>",
   required_tools: "read, grep, lsp, edit, bash",
-  must_do: "LSP before edits, run tests, report progress via swarm-monitor",
+  must_do: "LSP before edits, run tests, verify before claiming done",
   must_not_do: "no new deps, don't edit files outside assignment",
-  acceptance_checks: "typecheck: <command>, lint: <command>, test: <command>",
-  context: "Phase: <phase>, Role: <role>, Team: <team-name>, Assigned: <files>",
+  acceptance_checks: "typecheck: npm run typecheck, lint: npm run lint",
+  context: "Files: <files>, Purpose: <reason>",
   write: true
 })`,
 	args: {