opencodekit 0.15.16 → 0.15.19

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

@@ -0,0 +1,466 @@
+import { tool } from "@opencode-ai/plugin";
+
+interface Phase {
+	name: string;
+	role: "explore" | "general" | "review" | "plan";
+	agent_count: number;
+	dependencies: 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;
+	};
+	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> })`,
+
+	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 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,
+		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",
+	};
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "opencodekit",
-	"version": "0.15.16",
+	"version": "0.15.19",
 	"description": "CLI tool for bootstrapping and managing OpenCodeKit projects",
 	"keywords": ["agents", "cli", "mcp", "opencode", "opencodekit", "template"],
 	"license": "MIT",