opencodekit 0.16.4 → 0.16.6

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

@@ -1,657 +0,0 @@
-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 br list (beads_rust)
-		const statusFilter = filter === "all" ? "" : `--status ${filter}`;
-		const { stdout } = await execAsync(`br list ${statusFilter} --json`, {
-			cwd: worktree,
-		});
-
-		let beadTasks: BeadTask[];
-		try {
-			beadTasks = JSON.parse(stdout);
-		} catch {
-			// br 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(
-					`br 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}`;
-}