opencodekit 0.7.0 → 0.9.0

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

@@ -0,0 +1,667 @@
+import { type Plugin, tool } from "@opencode-ai/plugin";
+
+interface TaskState {
+	currentTask: string | null;
+	reservedFiles: Set<string>;
+	team: string;
+	role: string;
+	initialized: boolean;
+	agentId: string;
+}
+
+export const BeadsCorePlugin: Plugin = async ({ $, directory }) => {
+	const state: TaskState = {
+		currentTask: null,
+		reservedFiles: new Set(),
+		team: "default",
+		role: "",
+		initialized: false,
+		agentId: `agent-${Date.now().toString(36)}`,
+	};
+
+	async function bd(...args: string[]): Promise<any> {
+		try {
+			const result = await $`bd ${args}`.text();
+			try {
+				return JSON.parse(result);
+			} catch {
+				return { output: result.trim() };
+			}
+		} catch (e: any) {
+			return { error: e.message || String(e) };
+		}
+	}
+
+	function j(data: any): string {
+		return JSON.stringify(data, null, 0);
+	}
+
+	function reservationPath(filePath: string): string {
+		const safe = filePath.replace(/[\/\\]/g, "_").replace(/\.\./g, "_");
+		return `.reservations/${safe}.lock`;
+	}
+
+	async function getAllReservations(): Promise<any[]> {
+		try {
+			const dir = ".reservations";
+			const result = await $`test -d ${dir} && ls -1 ${dir}`
+				.text()
+				.catch(() => "");
+			if (!result.trim()) return [];
+
+			const reservations: any[] = [];
+			for (const file of result.trim().split("\n")) {
+				if (!file.endsWith(".lock")) continue;
+				try {
+					const content = await $`cat "${dir}/${file}"`.text();
+					const lock = JSON.parse(content);
+					if (lock.expires > Date.now()) {
+						reservations.push(lock);
+					}
+				} catch {}
+			}
+			return reservations;
+		} catch {
+			return [];
+		}
+	}
+
+	return {
+		tool: {
+			bd_init: tool({
+				description: "Join beads workspace. MUST call first.",
+				args: {
+					team: tool.schema.string().optional().describe("Team name"),
+					role: tool.schema
+						.string()
+						.optional()
+						.describe("Role: fe|be|mobile|devops|qa"),
+				},
+				async execute(args) {
+					await $`bd init`.quiet().catch(() => {});
+					await $`mkdir -p .reservations`.quiet();
+
+					state.team = args.team || "default";
+					state.role = args.role || "";
+					state.initialized = true;
+					state.currentTask = null;
+					state.reservedFiles.clear();
+
+					return j({
+						ok: 1,
+						agent: state.agentId,
+						ws: directory,
+						team: state.team,
+						role: state.role || undefined,
+					});
+				},
+			}),
+
+			bd_claim: tool({
+				description: "Claim next ready task. Auto-syncs, marks in_progress.",
+				args: {},
+				async execute() {
+					if (!state.initialized) return j({ error: "Call bd_init() first" });
+
+					await $`bd sync`.quiet().catch(() => {});
+					const ready = await bd("ready", "--json");
+					if (ready.error) return j({ error: ready.error });
+
+					const tasks = Array.isArray(ready) ? ready : [];
+					if (!tasks.length) return j({ msg: "no ready tasks" });
+
+					let task = tasks[0];
+					if (state.role) {
+						const roleTask = tasks.find((t: any) =>
+							t.tags?.includes(state.role),
+						);
+						if (roleTask) task = roleTask;
+					}
+
+					await $`bd update ${task.id} --status in_progress`.quiet();
+					state.currentTask = task.id;
+
+					return j({
+						id: task.id,
+						t: task.title,
+						p: task.priority,
+						type: task.type,
+					});
+				},
+			}),
+
+			bd_done: tool({
+				description:
+					"Complete task. Auto-releases files, syncs. Restart session after.",
+				args: {
+					id: tool.schema.string().describe("Task ID"),
+					msg: tool.schema
+						.string()
+						.default("completed")
+						.describe("Completion message"),
+				},
+				async execute(args) {
+					const taskId = args.id || state.currentTask;
+					if (!taskId) return j({ error: "No task ID" });
+
+					await bd("close", taskId, "--reason", args.msg);
+
+					for (const path of state.reservedFiles) {
+						await $`rm -f ${reservationPath(path)}`.quiet().catch(() => {});
+					}
+					state.reservedFiles.clear();
+
+					await $`bd sync`.quiet().catch(() => {});
+					state.currentTask = null;
+
+					return j({ ok: 1, closed: taskId, hint: "Restart session" });
+				},
+			}),
+
+			bd_add: tool({
+				description: "Create issue. Use tags to assign to roles.",
+				args: {
+					title: tool.schema.string().describe("Actionable title"),
+					desc: tool.schema
+						.string()
+						.optional()
+						.describe("Why/what/how context"),
+					pri: tool.schema
+						.number()
+						.default(2)
+						.describe("0=critical,1=high,2=normal,3=low,4=backlog"),
+					type: tool.schema
+						.string()
+						.default("task")
+						.describe("task|bug|feature|epic|chore"),
+					tags: tool.schema
+						.array(tool.schema.string())
+						.optional()
+						.describe("Role tags: fe,be,mobile,devops,qa"),
+					parent: tool.schema.string().optional().describe("Parent issue ID"),
+					deps: tool.schema
+						.array(tool.schema.string())
+						.optional()
+						.describe("Dependencies (type:id format)"),
+				},
+				async execute(args) {
+					if (!args.title) return j({ error: "title required" });
+
+					const cmdArgs = ["create", args.title, "-p", String(args.pri || 2)];
+					if (args.type && args.type !== "task")
+						cmdArgs.push("--type", args.type);
+					if (args.desc) cmdArgs.push("--description", args.desc);
+					if (args.parent) cmdArgs.push("--parent", args.parent);
+					if (args.tags?.length) cmdArgs.push("--tags", args.tags.join(","));
+					if (args.deps?.length) cmdArgs.push("--deps", args.deps.join(","));
+					cmdArgs.push("--json");
+
+					const result = await bd(...cmdArgs);
+					return j({
+						id: result.id || result.output,
+						t: args.title,
+						p: args.pri || 2,
+					});
+				},
+			}),
+
+			bd_assign: tool({
+				description:
+					"Assign task to role (leader only). Adds tag and notifies.",
+				args: {
+					id: tool.schema.string().describe("Issue ID"),
+					role: tool.schema.string().describe("Role: fe|be|mobile|devops|qa"),
+					notify: tool.schema
+						.boolean()
+						.default(true)
+						.describe("Broadcast notification"),
+				},
+				async execute(args) {
+					if (!args.id || !args.role)
+						return j({ error: "id and role required" });
+
+					await bd("update", args.id, "--tags", args.role);
+
+					if (args.notify !== false) {
+						const notif = {
+							type: "assign",
+							task: args.id,
+							role: args.role,
+							at: Date.now(),
+						};
+						await $`echo ${JSON.stringify(notif)} >> .reservations/notifications.jsonl`.quiet();
+					}
+
+					return j({ ok: 1, id: args.id, role: args.role });
+				},
+			}),
+
+			bd_ls: tool({
+				description: "List issues. status: open|closed|in_progress|ready|all",
+				args: {
+					status: tool.schema.string().default("open"),
+					limit: tool.schema.number().default(10),
+					offset: tool.schema.number().default(0),
+				},
+				async execute(args) {
+					const status = args.status || "open";
+					const limit = Math.min(args.limit || 10, 50);
+
+					let result: any;
+					if (status === "ready") {
+						result = await bd("ready", "--json");
+					} else if (status === "all") {
+						result = await bd("list", "--json");
+					} else {
+						result = await bd("list", "--status", status, "--json");
+					}
+
+					if (result.error) return j({ error: result.error });
+
+					const tasks = Array.isArray(result) ? result : [];
+					const offset = args.offset || 0;
+					const items = tasks.slice(offset, offset + limit).map((t: any) => ({
+						id: t.id,
+						t: t.title,
+						p: t.priority,
+						s: t.status,
+						tags: t.tags?.length ? t.tags : undefined,
+					}));
+
+					return j({ items, count: items.length, total: tasks.length });
+				},
+			}),
+
+			bd_show: tool({
+				description: "Get full issue details.",
+				args: { id: tool.schema.string().describe("Issue ID") },
+				async execute(args) {
+					if (!args.id) return j({ error: "id required" });
+					const result = await bd("show", args.id, "--json");
+					return j(result);
+				},
+			}),
+
+			bd_reserve: tool({
+				description: "Lock files for editing. Prevents conflicts.",
+				args: {
+					paths: tool.schema
+						.array(tool.schema.string())
+						.describe("Files to lock"),
+					reason: tool.schema.string().optional().describe("Why reserving"),
+					ttl: tool.schema
+						.number()
+						.default(600)
+						.describe("Seconds until expiry"),
+				},
+				async execute(args) {
+					if (!args.paths?.length) return j({ error: "paths required" });
+
+					await $`mkdir -p .reservations`.quiet();
+
+					const granted: string[] = [];
+					const conflicts: { path: string; holder?: string }[] = [];
+					const now = Date.now();
+					const expires = now + (args.ttl || 600) * 1000;
+
+					for (const path of args.paths) {
+						const lockFile = reservationPath(path);
+
+						try {
+							const content = await $`cat ${lockFile} 2>/dev/null`.text();
+							if (content) {
+								const lock = JSON.parse(content);
+								if (lock.expires > now && lock.agent !== state.agentId) {
+									conflicts.push({ path, holder: lock.agent });
+									continue;
+								}
+							}
+						} catch {}
+
+						const lockData = JSON.stringify({
+							path,
+							agent: state.agentId,
+							reason: args.reason,
+							created: now,
+							expires,
+							task: state.currentTask,
+						});
+
+						await $`echo ${lockData} > ${lockFile}`.quiet();
+						granted.push(path);
+						state.reservedFiles.add(path);
+					}
+
+					const result: any = { granted };
+					if (conflicts.length) result.conflicts = conflicts;
+					return j(result);
+				},
+			}),
+
+			bd_release: tool({
+				description: "Unlock files. Auto-released on done().",
+				args: {
+					paths: tool.schema
+						.array(tool.schema.string())
+						.optional()
+						.describe("Files to unlock (empty=all)"),
+				},
+				async execute(args) {
+					const toRelease = args.paths?.length
+						? args.paths
+						: [...state.reservedFiles];
+
+					for (const path of toRelease) {
+						await $`rm -f ${reservationPath(path)}`.quiet().catch(() => {});
+						state.reservedFiles.delete(path);
+					}
+
+					return j({ released: toRelease });
+				},
+			}),
+
+			bd_reservations: tool({
+				description: "List active file locks. Check before editing.",
+				args: {},
+				async execute() {
+					const reservations = await getAllReservations();
+					return j({
+						locks: reservations.map((r) => ({
+							path: r.path,
+							agent: r.agent,
+							expires: new Date(r.expires).toISOString(),
+							task: r.task,
+						})),
+						count: reservations.length,
+					});
+				},
+			}),
+
+			bd_msg: tool({
+				description:
+					"Send message. Use global=true + to='all' for team-wide broadcast.",
+				args: {
+					subj: tool.schema.string().describe("Subject"),
+					body: tool.schema.string().optional().describe("Message body"),
+					to: tool.schema
+						.string()
+						.default("all")
+						.describe("Recipient or 'all'"),
+					importance: tool.schema
+						.string()
+						.default("normal")
+						.describe("low|normal|high"),
+					thread: tool.schema.string().optional().describe("Thread ID"),
+					global: tool.schema
+						.boolean()
+						.default(false)
+						.describe("Send to all workspaces"),
+				},
+				async execute(args) {
+					if (!args.subj) return j({ error: "subj required" });
+
+					const msg = {
+						id: `msg-${Date.now().toString(36)}`,
+						from: state.agentId,
+						to: args.to || "all",
+						subj: args.subj,
+						body: args.body,
+						importance: args.importance || "normal",
+						thread: args.thread,
+						global: args.global,
+						at: Date.now(),
+						read: false,
+					};
+
+					await $`mkdir -p .reservations`.quiet();
+					await $`echo ${JSON.stringify(msg)} >> .reservations/messages.jsonl`.quiet();
+
+					return j({ ok: 1, id: msg.id });
+				},
+			}),
+
+			bd_inbox: tool({
+				description: "Get messages. Includes global by default.",
+				args: {
+					n: tool.schema.number().default(5).describe("Max messages"),
+					unread: tool.schema.boolean().default(false).describe("Unread only"),
+					global: tool.schema
+						.boolean()
+						.default(true)
+						.describe("Include cross-workspace"),
+				},
+				async execute(args) {
+					try {
+						const content =
+							await $`cat .reservations/messages.jsonl 2>/dev/null`.text();
+						if (!content.trim()) return j({ msgs: [], count: 0 });
+
+						let msgs = content
+							.trim()
+							.split("\n")
+							.map((line) => {
+								try {
+									return JSON.parse(line);
+								} catch {
+									return null;
+								}
+							})
+							.filter((m) => m !== null)
+							.filter((m) => m.to === "all" || m.to === state.agentId);
+
+						if (args.unread) msgs = msgs.filter((m) => !m.read);
+						msgs = msgs.slice(-(args.n || 5)).reverse();
+
+						return j({ msgs, count: msgs.length });
+					} catch {
+						return j({ msgs: [], count: 0 });
+					}
+				},
+			}),
+
+			bd_status: tool({
+				description: "Workspace overview. Shows agents, tasks, locks.",
+				args: {
+					include_agents: tool.schema
+						.boolean()
+						.default(false)
+						.describe("Include agent info"),
+				},
+				async execute(args) {
+					const [ready, inProgress, reservations] = await Promise.all([
+						bd("ready", "--json"),
+						bd("list", "--status", "in_progress", "--json"),
+						getAllReservations(),
+					]);
+
+					const result: any = {
+						ws: directory,
+						team: state.team,
+						current_task: state.currentTask,
+						ready: Array.isArray(ready) ? ready.length : 0,
+						in_progress: Array.isArray(inProgress) ? inProgress.length : 0,
+						locks: reservations.length,
+					};
+
+					if (args.include_agents) {
+						result.agent = {
+							id: state.agentId,
+							role: state.role || undefined,
+							reserved: [...state.reservedFiles],
+						};
+					}
+
+					return j(result);
+				},
+			}),
+
+			bd_sync: tool({
+				description: "Sync with git. Pull/push changes.",
+				args: {},
+				async execute() {
+					const result = await bd("sync");
+					return j({ ok: 1, output: result.output });
+				},
+			}),
+
+			bd_cleanup: tool({
+				description: "Remove old closed issues. Run every few days.",
+				args: {
+					days: tool.schema
+						.number()
+						.default(2)
+						.describe("Delete closed >N days"),
+				},
+				async execute(args) {
+					const result = await bd(
+						"cleanup",
+						"--older-than",
+						`${args.days || 2}d`,
+					);
+					return j({ ok: 1, output: result.output });
+				},
+			}),
+
+			bd_doctor: tool({
+				description: "Check/repair database health.",
+				args: {},
+				async execute() {
+					const result = await bd("doctor", "--fix");
+					return j({ ok: 1, output: result.output });
+				},
+			}),
+
+			bd_insights: tool({
+				description:
+					"Graph analysis: bottlenecks, keystones, cycles, PageRank.",
+				args: {},
+				async execute() {
+					const result = await bd("stats", "--json");
+					if (result.error) return j({ error: result.error });
+
+					const tasks = await bd("list", "--json");
+					const taskList = Array.isArray(tasks) ? tasks : [];
+
+					const blocked = taskList.filter((t: any) => t.status === "blocked");
+					const highPri = taskList.filter(
+						(t: any) => t.priority <= 1 && t.status === "open",
+					);
+
+					return j({
+						total: taskList.length,
+						blocked: blocked.length,
+						high_priority: highPri.length,
+						bottlenecks: blocked.map((t: any) => ({ id: t.id, t: t.title })),
+						keystones: highPri.map((t: any) => ({
+							id: t.id,
+							t: t.title,
+							p: t.priority,
+						})),
+					});
+				},
+			}),
+
+			bd_plan: tool({
+				description: "Parallel execution plan with tracks.",
+				args: {},
+				async execute() {
+					const ready = await bd("ready", "--json");
+					const tasks = Array.isArray(ready) ? ready : [];
+
+					const tracks: Record<number, any[]> = {};
+					for (const task of tasks) {
+						const p = task.priority || 2;
+						if (!tracks[p]) tracks[p] = [];
+						tracks[p].push({ id: task.id, t: task.title });
+					}
+
+					return j({
+						tracks: Object.entries(tracks).map(([pri, items]) => ({
+							priority: Number(pri),
+							parallel: items,
+						})),
+						total_ready: tasks.length,
+					});
+				},
+			}),
+
+			bd_priority: tool({
+				description: "Priority recommendations based on graph analysis.",
+				args: {
+					limit: tool.schema
+						.number()
+						.default(5)
+						.describe("Max issues to return"),
+				},
+				async execute(args) {
+					const ready = await bd("ready", "--json");
+					const tasks = Array.isArray(ready) ? ready : [];
+
+					const sorted = tasks
+						.sort((a: any, b: any) => (a.priority || 2) - (b.priority || 2))
+						.slice(0, args.limit || 5);
+
+					return j({
+						recommended: sorted.map((t: any) => ({
+							id: t.id,
+							t: t.title,
+							p: t.priority,
+							reason:
+								t.priority === 0
+									? "critical"
+									: t.priority === 1
+										? "high priority"
+										: "ready",
+						})),
+					});
+				},
+			}),
+
+			bd_diff: tool({
+				description: "Compare issue changes between git revisions.",
+				args: {
+					since: tool.schema
+						.string()
+						.optional()
+						.describe("Start revision (commit, tag, date)"),
+					as_of: tool.schema
+						.string()
+						.optional()
+						.describe("End revision (default: current)"),
+				},
+				async execute(args) {
+					const sinceArg = args.since || "HEAD~10";
+					const asOfArg = args.as_of || "HEAD";
+
+					try {
+						const diff =
+							await $`git diff ${sinceArg}..${asOfArg} -- .beads/`.text();
+						const lines = diff.split("\n");
+
+						const added = lines.filter(
+							(l) => l.startsWith("+") && !l.startsWith("+++"),
+						).length;
+						const removed = lines.filter(
+							(l) => l.startsWith("-") && !l.startsWith("---"),
+						).length;
+
+						return j({
+							since: sinceArg,
+							as_of: asOfArg,
+							changes: { added, removed },
+							summary: diff.length > 500 ? diff.slice(0, 500) + "..." : diff,
+						});
+					} catch (e: any) {
+						return j({ error: e.message });
+					}
+				},
+			}),
+		},
+
+		event: async ({ event }) => {
+			if (event.type === "session.idle" && state.currentTask) {
+				await $`bd sync`.quiet().catch(() => {});
+			}
+		},
+	};
+};