opencodekit 0.15.15 → 0.15.18

package/dist/template/.opencode/{skill → skills}/tool-priority/SKILL.md

@@ -186,5 +186,5 @@ glob ["src/**/*.ts", "tests/**/*.ts"]
 | **context7_query-docs**         | Query official library documentation. Fast.             |
 | **websearch**                   | Docs not in Context7, recent releases, troubleshooting. |
 | **codesearch**                  | Real implementation patterns from GitHub.               |
-| **grep-search**                 | Cross-repo code patterns via grep.app.                  |
+| **grepsearch**                 | Cross-repo code patterns via grep.app.                  |
 | **webfetch**                    | Specific URL user provided.                             |

package/dist/template/.opencode/{tool/grep-search.ts → tools/grepsearch.ts}

@@ -27,9 +27,9 @@ IMPORTANT: Search for **literal code patterns**, not keywords:
 ❌ Bad: "react tutorial", "best practices", "how to use"
 
 Examples:
-  grep_search({ query: "getServerSession", language: "TypeScript" })
-  grep_search({ query: "CORS(", language: "Python", repo: "flask" })
-  grep_search({ query: "export async function POST", path: "route.ts" })
+  grepsearch({ query: "getServerSession", language: "TypeScript" })
+  grepsearch({ query: "CORS(", language: "Python", repo: "flask" })
+  grepsearch({ query: "export async function POST", path: "route.ts" })
 `,
 	args: {
 		query: tool.schema

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

@@ -47,16 +47,16 @@ Purpose:
 - Creates a consistent delegation envelope for a specific Beads task
 - Optionally appends it to .beads/artifacts/<id>/delegation.md
 
-Example:
+Example (use actual task from user request):
 swarm-delegate({
-  bead_id: "opencodekit-template-xyz",
-  title: "Add feature X",
-  expected_outcome: "Feature X works and tests pass",
-  required_tools: "read, grep, lsp, bash",
-  must_do: "LSP before edits, run project verification commands",
-  must_not_do: "no new deps, don't edit dist/",
+  bead_id: "<bead-id>",
+  title: "<phase> - <worker-id>",
+  expected_outcome: "<specific outcome for this worker's assigned files>",
+  required_tools: "read, grep, lsp, edit, bash",
+  must_do: "LSP before edits, run tests, report progress via swarm-monitor",
+  must_not_do: "no new deps, don't edit files outside assignment",
   acceptance_checks: "typecheck: <command>, lint: <command>, test: <command>",
-  context: "See .beads/artifacts/<id>/spec.md",
+  context: "Phase: <phase>, Role: <role>, Team: <team-name>, Assigned: <files>",
   write: true
 })`,
 	args: {

package/dist/template/.opencode/tools/swarm-monitor.ts

@@ -0,0 +1,544 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { tool } from "@opencode-ai/plugin";
+
+const SWARM_MAIL_FILE = ".beads/swarm-mail.jsonl";
+const PROGRESS_FILE = ".beads/swarm-progress.jsonl";
+
+interface ProgressEntry {
+	timestamp: string;
+	team_name: string;
+	worker_id: string;
+	phase: string;
+	progress: number;
+	status: "idle" | "working" | "completed" | "error" | "blocked";
+	message?: string;
+	file?: string;
+}
+
+interface MailEntry {
+	timestamp: string;
+	team_name: string;
+	from_worker?: string;
+	to_worker?: string;
+	message?: string;
+	status?: string;
+}
+
+export default tool({
+	description: `Swarm monitoring and coordination - combines mailbox and progress tracking.
+
+Operations:
+- mail_send: Send message to team mailbox
+- mail_read: Read messages from team mailbox
+- progress_update: Update worker progress
+- progress_render: Display ASCII progress UI
+- render_block: Display beautiful markdown block UI for TUI
+- status: Get full team status (mail + progress)
+- clear: Clear team data
+
+Usage (use the actual team name from swarm-plan):
+  swarm-monitor({ operation: "mail_send", team_name: "<team-name>", from_worker: "worker-1", message: "DONE: <actual work completed>" })
+  swarm-monitor({ operation: "progress_update", team_name: "<team-name>", worker_id: "worker-1", phase: "<phase>", progress: <0-100>, status: "working", file: "<current file>" })
+  swarm-monitor({ operation: "render_block", team_name: "<team-name>" })`,
+
+	args: {
+		operation: tool.schema
+			.enum([
+				"mail_send",
+				"mail_read",
+				"progress_update",
+				"progress_render",
+				"status",
+				"clear",
+				"render_block",
+			])
+			.describe("Monitoring operation to perform"),
+		team_name: tool.schema.string().describe("Team/swarm identifier"),
+		from_worker: tool.schema
+			.string()
+			.optional()
+			.describe("Sending worker (for mail_send)"),
+		to_worker: tool.schema
+			.string()
+			.optional()
+			.describe("Target worker (for mail_send)"),
+		message: tool.schema
+			.string()
+			.optional()
+			.describe("Message content (for mail_send)"),
+		worker_id: tool.schema
+			.string()
+			.optional()
+			.describe("Worker identifier (for progress operations)"),
+		phase: tool.schema
+			.string()
+			.optional()
+			.describe("Current phase name (for progress_update)"),
+		progress: tool.schema
+			.number()
+			.min(0)
+			.max(100)
+			.optional()
+			.describe("Progress percentage 0-100 (for progress_update)"),
+		status: tool.schema
+			.enum(["idle", "working", "completed", "error", "blocked"])
+			.optional()
+			.describe("Worker status (for progress_update)"),
+		file: tool.schema
+			.string()
+			.optional()
+			.describe("Current file being worked on"),
+		limit: tool.schema
+			.number()
+			.optional()
+			.describe("Limit entries (for mail_read)"),
+	},
+
+	execute: async (args, ctx) => {
+		const worktree = ctx.worktree || process.cwd();
+
+		switch (args.operation) {
+			case "mail_send":
+				return await sendMail(
+					args.team_name,
+					args.from_worker,
+					args.to_worker,
+					args.message || "",
+					worktree,
+				);
+			case "mail_read":
+				return await readMail(args.team_name, args.limit, worktree);
+			case "progress_update":
+				return await updateProgress(
+					{
+						timestamp: new Date().toISOString(),
+						team_name: args.team_name,
+						worker_id: args.worker_id || "unknown",
+						phase: args.phase || "unknown",
+						progress: args.progress || 0,
+						status: args.status || "idle",
+						message: args.message,
+						file: args.file,
+					},
+					worktree,
+				);
+			case "progress_render":
+				return await renderProgress(args.team_name, worktree);
+			case "status":
+				return await getFullStatus(args.team_name, worktree);
+			case "clear":
+				return await clearTeam(args.team_name, worktree);
+			case "render_block":
+				return await renderBlock(args.team_name, worktree);
+			default:
+				return `Error: Unknown operation: ${args.operation}`;
+		}
+	},
+});
+
+// Mail operations
+async function sendMail(
+	teamName: string,
+	fromWorker: string | undefined,
+	toWorker: string | undefined,
+	message: string,
+	worktree: string,
+): Promise<string> {
+	if (!teamName || !message) {
+		return "Error: team_name and message are required.";
+	}
+
+	const mailPath = path.join(worktree, SWARM_MAIL_FILE);
+	const entry = {
+		timestamp: new Date().toISOString(),
+		team_name: teamName,
+		from_worker: fromWorker || "system",
+		to_worker: toWorker || "all",
+		message,
+		status: "unread",
+	};
+
+	try {
+		await fs.mkdir(path.dirname(mailPath), { recursive: true });
+		await fs.appendFile(mailPath, `${JSON.stringify(entry)}\n`, "utf-8");
+		return JSON.stringify(
+			{
+				success: true,
+				team_name: teamName,
+				from_worker: fromWorker,
+				to_worker: toWorker,
+				message,
+				mail_file: SWARM_MAIL_FILE,
+			},
+			null,
+			2,
+		);
+	} catch (error: any) {
+		return `Error: Failed to write to ${SWARM_MAIL_FILE}: ${error}`;
+	}
+}
+
+async function readMail(
+	teamName: string,
+	limit: number | undefined,
+	worktree: string,
+): Promise<string> {
+	if (!teamName) {
+		return "Error: team_name is required.";
+	}
+
+	const mailPath = path.join(worktree, SWARM_MAIL_FILE);
+
+	try {
+		const content = await fs.readFile(mailPath, "utf-8");
+		const lines = content.trim().split("\n").filter(Boolean);
+		const entries = lines
+			.map((line) => {
+				try {
+					return JSON.parse(line) as MailEntry;
+				} catch {
+					return null;
+				}
+			})
+			.filter((e): e is MailEntry => e !== null);
+
+		const relevant = entries.filter((m) => m.team_name === teamName);
+
+		if (limit && limit > 0) {
+			return JSON.stringify(relevant.slice(-limit), null, 2);
+		}
+		return JSON.stringify(relevant, null, 2);
+	} catch {
+		return JSON.stringify([], null, 2);
+	}
+}
+
+// Progress operations
+async function updateProgress(
+	entry: ProgressEntry,
+	worktree: string,
+): Promise<string> {
+	const progressPath = path.join(worktree, PROGRESS_FILE);
+
+	try {
+		await fs.mkdir(path.dirname(progressPath), { recursive: true });
+		await fs.appendFile(progressPath, JSON.stringify(entry) + "\n", "utf-8");
+		return JSON.stringify({ success: true, record: entry }, null, 2);
+	} catch (error: any) {
+		return `Error: Failed to update progress: ${error}`;
+	}
+}
+
+async function getProgress(
+	teamName: string,
+	worktree: string,
+): Promise<{ workers: ProgressEntry[]; total_entries: number }> {
+	const progressPath = path.join(worktree, PROGRESS_FILE);
+
+	try {
+		const content = await fs.readFile(progressPath, "utf-8");
+		const lines = content.trim().split("\n").filter(Boolean);
+		const entries = lines.map((line) => JSON.parse(line) as ProgressEntry);
+		const teamEntries = entries.filter((e) => e.team_name === teamName);
+
+		// Get latest entry per worker
+		const workerProgress = new Map<string, ProgressEntry>();
+		for (const entry of teamEntries) {
+			workerProgress.set(entry.worker_id, entry);
+		}
+
+		return {
+			workers: Array.from(workerProgress.values()),
+			total_entries: teamEntries.length,
+		};
+	} catch {
+		return { workers: [], total_entries: 0 };
+	}
+}
+
+async function renderProgress(
+	teamName: string,
+	worktree: string,
+): Promise<string> {
+	const { workers } = await getProgress(teamName, worktree);
+
+	if (workers.length === 0) {
+		return `No progress data for team: ${teamName}`;
+	}
+
+	// Group by phase
+	const phases = new Map<string, ProgressEntry[]>();
+	for (const worker of workers) {
+		if (!phases.has(worker.phase)) {
+			phases.set(worker.phase, []);
+		}
+		phases.get(worker.phase)!.push(worker);
+	}
+
+	// Build terminal UI
+	const lines: string[] = [];
+	lines.push("┌─────────────────────────────────────────────────────────────┐");
+	lines.push(`│  Swarm: ${teamName.padEnd(53)}│`);
+	lines.push("├─────────────────────────────────────────────────────────────┤");
+
+	for (const [phaseName, phaseWorkers] of phases) {
+		const avgProgress = Math.round(
+			phaseWorkers.reduce((sum, w) => sum + w.progress, 0) /
+				phaseWorkers.length,
+		);
+		const bar = renderProgressBar(avgProgress, 20);
+		const statusIcon = getPhaseStatus(phaseWorkers);
+
+		lines.push(
+			`│                                                             │`,
+		);
+		lines.push(`│  ${statusIcon} Phase: ${phaseName.padEnd(52)}│`);
+		lines.push(
+			`│     Progress: [${bar}] ${avgProgress.toString().padStart(3)}%                    │`,
+		);
+		lines.push(
+			`│                                                             │`,
+		);
+
+		for (const worker of phaseWorkers) {
+			const workerBar = renderProgressBar(worker.progress, 10);
+			const icon = getStatusIcon(worker.status);
+			const fileInfo = worker.file ? ` (${path.basename(worker.file)})` : "";
+			lines.push(
+				`│       ${icon} ${worker.worker_id.padEnd(10)} [${workerBar}] ${worker.progress.toString().padStart(3)}%${fileInfo.padEnd(20)}│`,
+			);
+		}
+	}
+
+	lines.push("│                                                             │");
+	lines.push("└─────────────────────────────────────────────────────────────┘");
+
+	return lines.join("\n");
+}
+
+function renderProgressBar(progress: number, width: number): string {
+	const filled = Math.round((progress / 100) * width);
+	const empty = width - filled;
+	return "█".repeat(filled) + "░".repeat(empty);
+}
+
+function getStatusIcon(status: string): string {
+	switch (status) {
+		case "completed":
+			return "✓";
+		case "error":
+			return "✗";
+		case "blocked":
+			return "⊘";
+		case "working":
+			return "▶";
+		default:
+			return "○";
+	}
+}
+
+function getPhaseStatus(workers: ProgressEntry[]): string {
+	if (workers.every((w) => w.status === "completed")) return "✓";
+	if (workers.some((w) => w.status === "error")) return "✗";
+	if (workers.some((w) => w.status === "working")) return "▶";
+	return "○";
+}
+
+// Render beautiful markdown block for TUI
+async function renderBlock(
+	teamName: string,
+	worktree: string,
+): Promise<string> {
+	const { workers } = await getProgress(teamName, worktree);
+	const mailData = await readMail(teamName, 5, worktree);
+	const messages = JSON.parse(mailData);
+
+	if (workers.length === 0 && messages.length === 0) {
+		return `## 🐝 Swarm: ${teamName}\n\n_No active workers or messages._`;
+	}
+
+	// Group workers by phase
+	const phases = new Map<string, ProgressEntry[]>();
+	for (const worker of workers) {
+		if (!phases.has(worker.phase)) {
+			phases.set(worker.phase, []);
+		}
+		phases.get(worker.phase)!.push(worker);
+	}
+
+	// Build markdown block
+	const lines: string[] = [];
+	lines.push(`## 🐝 Swarm: \`${teamName}\``);
+	lines.push("");
+
+	// Summary stats
+	const completed = workers.filter((w) => w.status === "completed").length;
+	const working = workers.filter((w) => w.status === "working").length;
+	const errors = workers.filter((w) => w.status === "error").length;
+	const total = workers.length;
+
+	lines.push("### 📊 Summary");
+	lines.push("");
+	lines.push(`| Metric | Value |`);
+	lines.push(`|--------|-------|`);
+	lines.push(`| Total Workers | ${total} |`);
+	lines.push(`| ✅ Completed | ${completed} |`);
+	lines.push(`| ▶️ Working | ${working} |`);
+	if (errors > 0) lines.push(`| ❌ Errors | ${errors} |`);
+	lines.push(`| 💬 Messages | ${messages.length} |`);
+	lines.push("");
+
+	// Phase details
+	if (phases.size > 0) {
+		lines.push("### 🔄 Phases");
+		lines.push("");
+
+		for (const [phaseName, phaseWorkers] of phases) {
+			const avgProgress = Math.round(
+				phaseWorkers.reduce((sum, w) => sum + w.progress, 0) /
+					phaseWorkers.length,
+			);
+			const phaseCompleted = phaseWorkers.every(
+				(w) => w.status === "completed",
+			);
+			const phaseError = phaseWorkers.some((w) => w.status === "error");
+			const phaseIcon = phaseCompleted ? "✅" : phaseError ? "❌" : "🔄";
+
+			lines.push(`#### ${phaseIcon} ${phaseName}`);
+			lines.push("");
+			lines.push(`**Progress:** ${avgProgress}%`);
+			lines.push("");
+			lines.push(`| Worker | Status | Progress | File |`);
+			lines.push(`|--------|--------|----------|------|`);
+
+			for (const worker of phaseWorkers) {
+				const statusIcon =
+					worker.status === "completed"
+						? "✅"
+						: worker.status === "error"
+							? "❌"
+							: worker.status === "working"
+								? "▶️"
+								: "⏸️";
+				const file = worker.file ? path.basename(worker.file) : "-";
+				lines.push(
+					`| ${worker.worker_id} | ${statusIcon} ${worker.status} | ${worker.progress}% | ${file} |`,
+				);
+			}
+			lines.push("");
+		}
+	}
+
+	// Recent messages
+	if (messages.length > 0) {
+		lines.push("### 💬 Recent Messages");
+		lines.push("");
+
+		for (const msg of messages.slice(-3)) {
+			const time = new Date(msg.timestamp).toLocaleTimeString();
+			const from = msg.from_worker || "system";
+			lines.push(`**${from}** at ${time}:`);
+			lines.push(`> ${msg.message}`);
+			lines.push("");
+		}
+	}
+
+	return lines.join("\n");
+}
+
+// Combined status
+async function getFullStatus(
+	teamName: string,
+	worktree: string,
+): Promise<string> {
+	const [mailData, progressData] = await Promise.all([
+		readMail(teamName, 20, worktree),
+		getProgress(teamName, worktree),
+	]);
+
+	const messages = JSON.parse(mailData);
+	const { workers } = progressData;
+
+	// Calculate overall stats
+	const completedWorkers = workers.filter(
+		(w) => w.status === "completed",
+	).length;
+	const errorWorkers = workers.filter((w) => w.status === "error").length;
+	const workingWorkers = workers.filter((w) => w.status === "working").length;
+
+	return JSON.stringify(
+		{
+			team_name: teamName,
+			summary: {
+				total_workers: workers.length,
+				completed: completedWorkers,
+				working: workingWorkers,
+				errors: errorWorkers,
+				messages: messages.length,
+			},
+			workers,
+			messages: messages.slice(-5), // Last 5 messages
+		},
+		null,
+		2,
+	);
+}
+
+// Clear operations
+async function clearTeam(teamName: string, worktree: string): Promise<string> {
+	const mailPath = path.join(worktree, SWARM_MAIL_FILE);
+	const progressPath = path.join(worktree, PROGRESS_FILE);
+
+	let clearedMail = 0;
+	let clearedProgress = 0;
+
+	// Clear mail entries
+	try {
+		const content = await fs.readFile(mailPath, "utf-8");
+		const lines = content.trim().split("\n").filter(Boolean);
+		const entries = lines.map((line) => JSON.parse(line) as MailEntry);
+		const otherEntries = entries.filter((e) => e.team_name !== teamName);
+		clearedMail = entries.length - otherEntries.length;
+
+		await fs.writeFile(
+			mailPath,
+			otherEntries.map((e) => JSON.stringify(e)).join("\n") +
+				(otherEntries.length > 0 ? "\n" : ""),
+			"utf-8",
+		);
+	} catch {
+		// File doesn't exist
+	}
+
+	// Clear progress entries
+	try {
+		const content = await fs.readFile(progressPath, "utf-8");
+		const lines = content.trim().split("\n").filter(Boolean);
+		const entries = lines.map((line) => JSON.parse(line) as ProgressEntry);
+		const otherEntries = entries.filter((e) => e.team_name !== teamName);
+		clearedProgress = entries.length - otherEntries.length;
+
+		await fs.writeFile(
+			progressPath,
+			otherEntries.map((e) => JSON.stringify(e)).join("\n") +
+				(otherEntries.length > 0 ? "\n" : ""),
+			"utf-8",
+		);
+	} catch {
+		// File doesn't exist
+	}
+
+	return JSON.stringify(
+		{
+			success: true,
+			team_name: teamName,
+			cleared: {
+				mail_entries: clearedMail,
+				progress_entries: clearedProgress,
+			},
+		},
+		null,
+		2,
+	);
+}