opencodekit 0.16.4 → 0.16.6

package/dist/template/.opencode/tool/swarm-delegate.ts

@@ -1,180 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import { tool } from "@opencode-ai/plugin";
-
-function isSafePathSegment(value: string): boolean {
-	if (!value) return false;
-	if (value.includes("..")) return false;
-	if (value.includes("/")) return false;
-	if (value.includes("\\")) return false;
-	return true;
-}
-
-function sanitizeFilename(value: string): string {
-	const trimmed = value.trim();
-	if (!trimmed) return "delegation.md";
-	if (!isSafePathSegment(trimmed)) return "delegation.md";
-	return trimmed;
-}
-
-function splitList(input?: string): string[] {
-	if (!input) return [];
-	const parts = input
-		.split(/\r?\n|,/g)
-		.map((s) => s.trim())
-		.filter(Boolean);
-	return [...new Set(parts)];
-}
-
-function formatBullets(items: string[]): string {
-	if (items.length === 0) return "- (none)";
-	return items.map((i) => `- ${i}`).join("\n");
-}
-
-async function fileExists(filePath: string): Promise<boolean> {
-	try {
-		await fs.access(filePath);
-		return true;
-	} catch {
-		return false;
-	}
-}
-
-export default tool({
-	description: `Generate a delegation packet for Task tool workers.
-
-Purpose:
-- Creates a consistent delegation envelope for parallel Task execution
-- Optionally appends it to .beads/artifacts/<id>/delegation.md
-
-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: "<task-title>",
-  expected_outcome: "<specific outcome>",
-  required_tools: "read, grep, lsp, edit, bash",
-  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: npm run typecheck, lint: npm run lint",
-  context: "Files: <files>, Purpose: <reason>",
-  write: true
-})`,
-	args: {
-		bead_id: tool.schema
-			.string()
-			.describe("Beads issue id (e.g., opencodekit-template-abc)"),
-		title: tool.schema
-			.string()
-			.optional()
-			.describe("Optional title (defaults to Beads id only)"),
-		expected_outcome: tool.schema
-			.string()
-			.describe("Measurable end state for this task"),
-		required_tools: tool.schema
-			.string()
-			.optional()
-			.describe("Comma/newline-separated list of tools"),
-		must_do: tool.schema
-			.string()
-			.optional()
-			.describe("Comma/newline-separated MUST DO list"),
-		must_not_do: tool.schema
-			.string()
-			.optional()
-			.describe("Comma/newline-separated MUST NOT DO list"),
-		acceptance_checks: tool.schema
-			.string()
-			.optional()
-			.describe(
-				"Comma/newline-separated checks (prefer 'typecheck: <command>', 'lint: <command>', 'test: <command>')",
-			),
-		context: tool.schema
-			.string()
-			.optional()
-			.describe("Extra context pointers (files/links/notes)"),
-		write: tool.schema
-			.boolean()
-			.optional()
-			.describe("When true, append packet to task artifact file"),
-		output_file: tool.schema
-			.string()
-			.optional()
-			.describe(
-				"Artifact filename under .beads/artifacts/<id>/ (default: delegation.md)",
-			),
-	},
-	execute: async (args: {
-		bead_id: string;
-		title?: string;
-		expected_outcome: string;
-		required_tools?: string;
-		must_do?: string;
-		must_not_do?: string;
-		acceptance_checks?: string;
-		context?: string;
-		write?: boolean;
-		output_file?: string;
-	}) => {
-		const beadId = args.bead_id.trim();
-		if (!beadId) return "Error: bead_id is required.";
-		if (!isSafePathSegment(beadId)) {
-			return "Error: bead_id must be a single path segment (no slashes or '..').";
-		}
-
-		const title = args.title?.trim();
-		const taskLine = title ? `${beadId} - ${title}` : beadId;
-
-		const requiredTools = splitList(args.required_tools);
-		const mustDo = splitList(args.must_do);
-		const mustNotDo = splitList(args.must_not_do);
-		const acceptanceChecks = splitList(args.acceptance_checks);
-		const context = args.context?.trim();
-
-		const now = new Date();
-		const stamp = now.toISOString();
-
-		const packet = [
-			"# Delegation Packet",
-			"",
-			`- TASK: ${taskLine}`,
-			`- EXPECTED OUTCOME: ${args.expected_outcome.trim()}`,
-			"- REQUIRED TOOLS:",
-			formatBullets(requiredTools),
-			"- MUST DO:",
-			formatBullets(mustDo),
-			"- MUST NOT DO:",
-			formatBullets(mustNotDo),
-			"- ACCEPTANCE CHECKS:",
-			formatBullets(acceptanceChecks),
-			"- CONTEXT:",
-			context ? context : "(none)",
-		].join("\n");
-
-		if (!args.write) {
-			return `${packet}\n`;
-		}
-
-		const artifactDir = path.join(process.cwd(), ".beads", "artifacts", beadId);
-		const outName = sanitizeFilename(args.output_file || "delegation.md");
-		const outPath = path.join(artifactDir, outName);
-
-		const specPath = path.join(artifactDir, "spec.md");
-		const hasSpec = await fileExists(specPath);
-
-		await fs.mkdir(artifactDir, { recursive: true });
-
-		const header = `\n\n---\nGenerated: ${stamp}\n---\n\n`;
-		await fs.appendFile(outPath, `${header}${packet}\n`, "utf-8");
-
-		const specNote = hasSpec
-			? ""
-			: `\nWarning: spec.md not found at ${specPath}`;
-
-		return `✓ Delegation packet appended to ${outPath}${specNote}\n\n${packet}\n`;
-	},
-});

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

@@ -1,388 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import { tool } from "@opencode-ai/plugin";
-
-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;
-}
-
-export default tool({
-	description: `Swarm progress tracking for parallel task visualization.
-
-Operations:
-- 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
-- clear: Clear team data
-
-Note: For worker communication, use the Task tool which handles results directly.
-
-Usage:
-  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>" })
-  swarm-monitor({ operation: "status", team_name: "<team-name>" })`,
-
-	args: {
-		operation: tool.schema
-			.enum([
-				"progress_update",
-				"progress_render",
-				"status",
-				"clear",
-				"render_block",
-			])
-			.describe("Monitoring operation to perform"),
-		team_name: tool.schema.string().describe("Team/swarm identifier"),
-		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)"),
-		message: tool.schema
-			.string()
-			.optional()
-			.describe("Status message (for progress_update)"),
-		file: tool.schema
-			.string()
-			.optional()
-			.describe("Current file being worked on"),
-	},
-
-	execute: async (args, ctx) => {
-		const worktree = ctx.worktree || process.cwd();
-
-		switch (args.operation) {
-			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}`;
-		}
-	},
-});
-
-// 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);
-
-	if (workers.length === 0) {
-		return `## 🐝 Swarm: ${teamName}\n\n_No active workers._`;
-	}
-
-	// 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("");
-
-	// 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("");
-		}
-	}
-
-	return lines.join("\n");
-}
-
-// Combined status
-async function getFullStatus(
-	teamName: string,
-	worktree: string,
-): Promise<string> {
-	const progressData = await getProgress(teamName, worktree);
-	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,
-			},
-			workers,
-		},
-		null,
-		2,
-	);
-}
-
-// Clear operations
-async function clearTeam(teamName: string, worktree: string): Promise<string> {
-	const progressPath = path.join(worktree, PROGRESS_FILE);
-
-	let clearedProgress = 0;
-
-	// 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: {
-				progress_entries: clearedProgress,
-			},
-		},
-		null,
-		2,
-	);
-}