opencodekit 0.16.4 → 0.16.6

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

@@ -1,697 +0,0 @@
-import { tool } from "@opencode-ai/plugin";
-
-interface Phase {
-	name: string;
-	role: "explore" | "general" | "review" | "plan";
-	agent_count: number;
-	dependencies: string[];
-}
-
-interface TaskNode {
-	id: string;
-	content: string;
-	phase: string;
-	worker: string;
-	status: "pending" | "in_progress" | "completed";
-	priority: "high" | "medium" | "low";
-	blockedBy: string[];
-	blocks: string[];
-	assignedFiles: string[];
-}
-
-interface DependencyGraph {
-	nodes: TaskNode[];
-	edges: Array<{ from: string; to: string; type: "blocks" | "blocked_by" }>;
-	critical_path: string[];
-	parallelizable_groups: string[][];
-}
-
-interface TaskClassification {
-	type: "search" | "batch" | "writing" | "sequential" | "mixed";
-	coupling: "high" | "medium" | "low";
-	recommended_agents: number;
-	phases: Phase[];
-	reasoning: string;
-	confidence: "high" | "medium" | "low";
-}
-
-interface SerialCollapseCheck {
-	is_serial_collapse: boolean;
-	warning_signs: string[];
-	severity: "high" | "medium" | "none";
-	recommendation: string;
-}
-
-interface OrchestrationPlan {
-	task: string;
-	file_count: number;
-	classification: TaskClassification;
-	serial_collapse_check: SerialCollapseCheck;
-	allocation: {
-		initial_agents: number;
-		max_agents: number;
-		strategy: string;
-	};
-	dependency_graph: DependencyGraph;
-	recommendation: string;
-}
-
-export default tool({
-	description: `Swarm planning and orchestration with Kimi K2.5 PARL patterns.
-
-Combines task classification, anti-serial-collapse detection, and dynamic agent allocation.
-
-Operations:
-- analyze: Full task analysis with classification and recommendations
-- classify: Quick task classification only
-- check: Check for serial collapse in current plan
-- allocate: Get dynamic agent allocation strategy
-
-Usage (pass the user's actual request):
-  swarm-plan({ operation: "analyze", task: "<user's request>", files: "<detected files>" })
-  swarm-plan({ operation: "check", task: "<user's request>", files: "<file count>", recommended_agents: <current> })
-
-Worker skills (load these in worker prompt):
-  skill({ name: "verification-before-completion" })  // Required: verify before claiming done
-  skill({ name: "test-driven-development" })         // Recommended: test first, implement, verify
-  skill({ name: "tool-priority" })                   // Recommended: LSP before edits
-
-Worker progress reporting (simplified flow - Task tool returns results directly):
-  swarm-monitor({ operation: "progress_update", team_name: "<team>", worker_id: "<id>", phase: "<phase>", progress: 0-100, status: "working|completed|error", file: "<current-file>" })`,
-
-	args: {
-		operation: tool.schema
-			.enum(["analyze", "classify", "check", "allocate"])
-			.describe("Planning operation to perform"),
-		task: tool.schema.string().describe("Task description"),
-		files: tool.schema
-			.string()
-			.optional()
-			.describe("Comma-separated file paths or file count"),
-		recommended_agents: tool.schema
-			.number()
-			.optional()
-			.describe("Current agent recommendation (for check operation)"),
-		current_phases: tool.schema
-			.string()
-			.optional()
-			.describe("Current phases JSON (for check operation)"),
-		context: tool.schema
-			.string()
-			.optional()
-			.describe("Additional context about the task"),
-	},
-
-	execute: async (args) => {
-		switch (args.operation) {
-			case "analyze":
-				return await analyzeOperation(args.task, args.files);
-			case "classify":
-				return await classifyOperation(args.task, args.files);
-			case "check":
-				return await checkOperation(
-					args.task,
-					args.files,
-					args.recommended_agents,
-					args.current_phases,
-				);
-			case "allocate":
-				return await allocateOperation(args.task, args.files);
-			default:
-				return `Error: Unknown operation: ${args.operation}`;
-		}
-	},
-});
-
-async function analyzeOperation(task: string, files?: string): Promise<string> {
-	const fileList = files?.split(",").filter(Boolean) || [];
-	const fileCount = Number.parseInt(files || "0") || fileList.length;
-
-	// Get classification
-	const classification = classifyTask(task, fileList);
-
-	// Check for serial collapse
-	const collapseCheck = detectSerialCollapse(
-		task,
-		fileCount,
-		classification.recommended_agents,
-	);
-
-	// Get allocation strategy
-	const allocation = calculateAllocation(fileCount);
-
-	// Build dependency graph
-	const dependencyGraph = buildDependencyGraph(
-		classification.phases,
-		fileList,
-		task,
-	);
-
-	// Build recommendation
-	let recommendation: string;
-	if (collapseCheck.is_serial_collapse) {
-		recommendation = `Use swarm mode with ${Math.min(fileCount, 5)} agents (serial collapse detected)`;
-	} else if (classification.recommended_agents > 1) {
-		recommendation = `Use swarm mode with ${classification.recommended_agents} agents`;
-	} else {
-		recommendation = "Single agent sufficient";
-	}
-
-	const plan: OrchestrationPlan = {
-		task,
-		file_count: fileCount,
-		classification,
-		serial_collapse_check: collapseCheck,
-		allocation,
-		dependency_graph: dependencyGraph,
-		recommendation,
-	};
-
-	return JSON.stringify(plan, null, 2);
-}
-
-async function classifyOperation(
-	task: string,
-	files?: string,
-): Promise<string> {
-	const fileList = files?.split(",").filter(Boolean) || [];
-	const classification = classifyTask(task, fileList);
-	return JSON.stringify(classification, null, 2);
-}
-
-async function checkOperation(
-	task: string,
-	files?: string,
-	recommendedAgents?: number,
-	currentPhases?: string,
-): Promise<string> {
-	const fileCount =
-		Number.parseInt(files || "0") || files?.split(",").length || 0;
-	const agents = recommendedAgents || 1;
-
-	const collapseCheck = detectSerialCollapse(task, fileCount, agents);
-
-	// Additional phase check
-	let phaseCheck: { issue: string; suggestion: string } | null = null;
-	if (currentPhases) {
-		try {
-			const phases = JSON.parse(currentPhases);
-			const allSingleAgent = phases.every((p: any) => p.agent_count === 1);
-			const noParallelPhases =
-				phases.filter((p: any) => p.agent_count > 1).length === 0;
-
-			if (allSingleAgent && noParallelPhases && fileCount > 3) {
-				phaseCheck = {
-					issue: "All phases use single agent despite multiple files",
-					suggestion: "Add parallel exploration phase",
-				};
-			}
-		} catch {
-			// Invalid phases JSON
-		}
-	}
-
-	return JSON.stringify(
-		{
-			task,
-			file_count: fileCount,
-			recommended_agents: agents,
-			serial_collapse_detected: collapseCheck.is_serial_collapse,
-			warning_signs: collapseCheck.warning_signs,
-			severity: collapseCheck.severity,
-			phase_check: phaseCheck,
-			action_required: collapseCheck.is_serial_collapse || phaseCheck !== null,
-			suggested_agents: collapseCheck.is_serial_collapse
-				? Math.min(fileCount, 5)
-				: agents,
-		},
-		null,
-		2,
-	);
-}
-
-async function allocateOperation(
-	task: string,
-	files?: string,
-): Promise<string> {
-	const fileCount =
-		Number.parseInt(files || "0") || files?.split(",").length || 0;
-	const allocation = calculateAllocation(fileCount);
-
-	return JSON.stringify(
-		{
-			task,
-			file_count: fileCount,
-			allocation,
-			scaling_rules: [
-				"Scale up if: Bottleneck detected (1 agent at 100%, others idle)",
-				"Scale up if: New files discovered during execution",
-				"Scale down if: Error rate exceeds 20%",
-				"Scale down if: File conflicts detected between workers",
-			],
-			recommendation: `Start with ${allocation.initial_agents} agents, scale up to ${allocation.max_agents} if needed`,
-		},
-		null,
-		2,
-	);
-}
-
-function classifyTask(task: string, files: string[]): TaskClassification {
-	// Search indicators
-	const searchPatterns =
-		/research|find|search|explore|investigate|compare|analyze.*codebase|look.*for|discover/i;
-
-	// Writing indicators
-	const writingPatterns =
-		/write|create|document|generate|draft|author|compose/i;
-
-	// Batch indicators
-	const batchPatterns =
-		/refactor|update|migrate|convert.*all|batch|multiple.*files|every.*file|all.*components/i;
-	const hasManyFiles = files.length > 3;
-
-	// Sequential indicators
-	const sequentialPatterns =
-		/debug|fix.*issue|optimize|complex.*refactor|architecture|design.*pattern|troubleshoot/i;
-
-	// Analyze coupling
-	const coupling = analyzeCoupling(files);
-
-	// Classification logic
-	if (searchPatterns.test(task)) {
-		return {
-			type: "search",
-			coupling: "low",
-			recommended_agents: Math.min(Math.max(files.length, 3), 5),
-			phases: [
-				{
-					name: "explore",
-					role: "explore",
-					agent_count: Math.min(files.length || 3, 3),
-					dependencies: [],
-				},
-				{
-					name: "synthesize",
-					role: "plan",
-					agent_count: 1,
-					dependencies: ["explore"],
-				},
-			],
-			reasoning:
-				"Search tasks benefit from parallel exploration across multiple sources/domains",
-			confidence: "high",
-		};
-	}
-
-	if ((batchPatterns.test(task) || hasManyFiles) && files.length > 0) {
-		return {
-			type: "batch",
-			coupling: coupling,
-			recommended_agents: Math.min(files.length, 8),
-			phases: [
-				{ name: "explore", role: "explore", agent_count: 2, dependencies: [] },
-				{
-					name: "generate",
-					role: "general",
-					agent_count: Math.min(files.length, 6),
-					dependencies: ["explore"],
-				},
-				{
-					name: "reflect",
-					role: "review",
-					agent_count: 2,
-					dependencies: ["generate"],
-				},
-				{
-					name: "synthesize",
-					role: "plan",
-					agent_count: 1,
-					dependencies: ["reflect"],
-				},
-			],
-			reasoning: `Batch processing of ${files.length} files with ${coupling} coupling - parallel execution recommended`,
-			confidence: coupling === "low" ? "high" : "medium",
-		};
-	}
-
-	if (writingPatterns.test(task) && files.length > 0) {
-		return {
-			type: "writing",
-			coupling: coupling,
-			recommended_agents: Math.min(Math.ceil(files.length / 2), 4),
-			phases: [
-				{
-					name: "explore",
-					role: "explore",
-					agent_count: 1,
-					dependencies: [],
-				},
-				{
-					name: "generate",
-					role: "general",
-					agent_count: Math.min(files.length, 3),
-					dependencies: ["explore"],
-				},
-				{
-					name: "reflect",
-					role: "review",
-					agent_count: 1,
-					dependencies: ["generate"],
-				},
-			],
-			reasoning:
-				"Writing tasks parallelize by section when coupling is low-medium",
-			confidence: coupling === "low" ? "high" : "medium",
-		};
-	}
-
-	if (
-		sequentialPatterns.test(task) ||
-		coupling === "high" ||
-		files.length <= 2
-	) {
-		return {
-			type: "sequential",
-			coupling: "high",
-			recommended_agents: 1,
-			phases: [
-				{
-					name: "analyze",
-					role: "explore",
-					agent_count: 1,
-					dependencies: [],
-				},
-				{
-					name: "implement",
-					role: "general",
-					agent_count: 1,
-					dependencies: ["analyze"],
-				},
-				{
-					name: "verify",
-					role: "review",
-					agent_count: 1,
-					dependencies: ["implement"],
-				},
-			],
-			reasoning:
-				"High coupling or complex debugging requires sequential execution for coherence",
-			confidence: "high",
-		};
-	}
-
-	// Default: mixed approach
-	return {
-		type: "mixed",
-		coupling: coupling,
-		recommended_agents: Math.min(files.length || 2, 4),
-		phases: [
-			{ name: "explore", role: "explore", agent_count: 2, dependencies: [] },
-			{
-				name: "implement",
-				role: "general",
-				agent_count: 2,
-				dependencies: ["explore"],
-			},
-		],
-		reasoning:
-			"Unclear task type - using conservative mixed approach with verification",
-		confidence: "low",
-	};
-}
-
-function analyzeCoupling(files: string[]): "high" | "medium" | "low" {
-	if (files.length <= 1) return "high";
-	if (files.length <= 3) return "medium";
-
-	// Check for shared directories (potential coupling)
-	const dirs = files.map((f) => {
-		const parts = f.split("/");
-		return parts.slice(0, -1).join("/");
-	});
-	const uniqueDirs = new Set(dirs);
-
-	if (uniqueDirs.size === 1) return "high"; // All in same directory
-	if (uniqueDirs.size <= files.length / 2) return "medium";
-	return "low";
-}
-
-function detectSerialCollapse(
-	task: string,
-	fileCount: number,
-	recommendedAgents: number,
-): SerialCollapseCheck {
-	const warningSigns: string[] = [];
-
-	// Sign 1: Many files but choosing 1 agent
-	if (fileCount >= 5 && recommendedAgents === 1) {
-		warningSigns.push(`${fileCount} files but single agent selected`);
-	}
-
-	// Sign 2: Search task with single agent
-	if (/research|search|explore/i.test(task) && recommendedAgents === 1) {
-		warningSigns.push("Search task with single agent");
-	}
-
-	// Sign 3: Batch operation with single agent
-	if (
-		/refactor.*all|update.*all|migrate.*all/i.test(task) &&
-		recommendedAgents === 1
-	) {
-		warningSigns.push("Batch operation with single agent");
-	}
-
-	// Sign 4: Explicit parallel keywords but 1 agent
-	if (
-		/parallel|concurrent|multiple.*at.*once/i.test(task) &&
-		recommendedAgents === 1
-	) {
-		warningSigns.push("Parallel keywords but single agent");
-	}
-
-	const isSerialCollapse =
-		warningSigns.length >= 2 || (warningSigns.length === 1 && fileCount > 8);
-
-	return {
-		is_serial_collapse: isSerialCollapse,
-		warning_signs: warningSigns,
-		severity:
-			warningSigns.length >= 2
-				? "high"
-				: warningSigns.length === 1
-					? "medium"
-					: "none",
-		recommendation: isSerialCollapse
-			? `Increase to ${Math.min(fileCount, 5)} agents for parallel execution`
-			: "Current allocation appropriate",
-	};
-}
-
-function calculateAllocation(fileCount: number) {
-	// Conservative start: 50% of what we might need, at least 1, at most 3
-	const initialAgents = Math.max(1, Math.min(Math.ceil(fileCount * 0.5), 3));
-
-	// Max based on reasonable limits
-	const maxAgents = Math.min(fileCount, 10);
-
-	return {
-		initial_agents: initialAgents,
-		max_agents: maxAgents,
-		strategy: "Conservative start, scale based on bottlenecks",
-	};
-}
-
-/**
- * Build a dependency graph from phases and files
- * This enables proper DAG-based task scheduling
- */
-function buildDependencyGraph(
-	phases: Phase[],
-	files: string[],
-	task: string,
-): DependencyGraph {
-	const nodes: TaskNode[] = [];
-	const edges: Array<{
-		from: string;
-		to: string;
-		type: "blocks" | "blocked_by";
-	}> = [];
-
-	// Distribute files across workers in each phase
-	let taskIdCounter = 1;
-
-	for (const phase of phases) {
-		const phaseFiles =
-			phase.name === "explore" || phase.name === "synthesize"
-				? files
-				: distributeFiles(files, phase.agent_count);
-
-		for (let i = 0; i < phase.agent_count; i++) {
-			const workerId = `${phase.name}-worker-${i + 1}`;
-			const taskId = `task-${taskIdCounter++}`;
-
-			// Determine assigned files based on phase type
-			let assignedFiles: string[];
-			if (phase.name === "explore" || phase.name === "synthesize") {
-				// These phases get all files
-				assignedFiles = files;
-			} else {
-				// Other phases get distributed files
-				const distributed = phaseFiles as string[][];
-				assignedFiles = distributed[i] || [];
-			}
-
-			const node: TaskNode = {
-				id: taskId,
-				content: `${phase.name}: ${task.slice(0, 50)}${task.length > 50 ? "..." : ""}`,
-				phase: phase.name,
-				worker: workerId,
-				status: "pending",
-				priority: phase.name === "explore" ? "high" : "medium",
-				blockedBy: [],
-				blocks: [],
-				assignedFiles,
-			};
-
-			// Add dependencies based on phase dependencies
-			if (phase.dependencies.length > 0) {
-				for (const dep of phase.dependencies) {
-					// Find all tasks in the dependency phase
-					const depTasks = nodes.filter((n) => n.phase === dep);
-					for (const depTask of depTasks) {
-						node.blockedBy.push(depTask.id);
-						depTask.blocks.push(taskId);
-						edges.push({ from: depTask.id, to: taskId, type: "blocks" });
-					}
-				}
-			}
-
-			nodes.push(node);
-		}
-	}
-
-	// Calculate critical path (longest chain of dependencies)
-	const criticalPath = calculateCriticalPath(nodes);
-
-	// Find parallelizable groups (tasks that can run simultaneously)
-	const parallelizableGroups = findParallelizableGroups(nodes);
-
-	return {
-		nodes,
-		edges,
-		critical_path: criticalPath,
-		parallelizable_groups: parallelizableGroups,
-	};
-}
-
-/**
- * Distribute files across workers
- */
-function distributeFiles(files: string[], workerCount: number): string[][] {
-	if (files.length === 0 || workerCount === 0) return [];
-
-	const result: string[][] = Array.from({ length: workerCount }, () => []);
-
-	files.forEach((file, index) => {
-		result[index % workerCount].push(file);
-	});
-
-	return result;
-}
-
-/**
- * Calculate the critical path (longest dependency chain)
- */
-function calculateCriticalPath(nodes: TaskNode[]): string[] {
-	const visited = new Set<string>();
-	const pathLengths = new Map<string, number>();
-	const pathParents = new Map<string, string | null>();
-
-	// Find root nodes (no blockedBy)
-	const roots = nodes.filter((n) => n.blockedBy.length === 0);
-
-	// BFS to calculate distances
-	const queue = [...roots];
-	for (const root of roots) {
-		pathLengths.set(root.id, 1);
-		pathParents.set(root.id, null);
-	}
-
-	while (queue.length > 0) {
-		const current = queue.shift()!;
-		if (visited.has(current.id)) continue;
-		visited.add(current.id);
-
-		const currentLength = pathLengths.get(current.id) || 1;
-
-		for (const blockedId of current.blocks) {
-			const blocked = nodes.find((n) => n.id === blockedId);
-			if (!blocked) continue;
-
-			const newLength = currentLength + 1;
-			const existingLength = pathLengths.get(blockedId) || 0;
-
-			if (newLength > existingLength) {
-				pathLengths.set(blockedId, newLength);
-				pathParents.set(blockedId, current.id);
-			}
-
-			queue.push(blocked);
-		}
-	}
-
-	// Find the node with longest path
-	let maxLength = 0;
-	let maxNode: string | null = null;
-	for (const [nodeId, length] of pathLengths) {
-		if (length > maxLength) {
-			maxLength = length;
-			maxNode = nodeId;
-		}
-	}
-
-	// Reconstruct path
-	const criticalPath: string[] = [];
-	let current = maxNode;
-	while (current) {
-		criticalPath.unshift(current);
-		current = pathParents.get(current) || null;
-	}
-
-	return criticalPath;
-}
-
-/**
- * Find groups of tasks that can run in parallel
- */
-function findParallelizableGroups(nodes: TaskNode[]): string[][] {
-	const groups: string[][] = [];
-	const assigned = new Set<string>();
-
-	// Group by "generation" - tasks whose all dependencies are satisfied
-	while (assigned.size < nodes.length) {
-		const group: string[] = [];
-
-		for (const node of nodes) {
-			if (assigned.has(node.id)) continue;
-
-			// Check if all blockedBy are already assigned
-			const allDependenciesMet = node.blockedBy.every((dep) =>
-				assigned.has(dep),
-			);
-
-			if (allDependenciesMet) {
-				group.push(node.id);
-			}
-		}
-
-		if (group.length === 0) break; // Prevent infinite loop on cycles
-
-		for (const id of group) {
-			assigned.add(id);
-		}
-		groups.push(group);
-	}
-
-	return groups;
-}