opencodekit 0.14.0 → 0.14.2

package/dist/template/.opencode/plugin/skill-mcp.ts

@@ -1,7 +1,7 @@
 import { type ChildProcess, spawn } from "node:child_process";
 import { existsSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
-import { join } from "node:path";
+import { dirname, join } from "node:path";
 import type { Plugin } from "@opencode-ai/plugin";
 import { tool } from "@opencode-ai/plugin/tool";
 
@@ -9,6 +9,7 @@ interface McpServerConfig {
 	command: string;
 	args?: string[];
 	env?: Record<string, string>;
+	includeTools?: string[]; // Ampcode-style tool filtering with glob patterns
 }
 
 interface McpClient {
@@ -24,6 +25,7 @@ interface McpClient {
 		resources?: any[];
 		prompts?: any[];
 	};
+	filteredTools?: any[]; // Tools after includeTools filtering
 }
 
 interface SkillMcpState {
@@ -31,6 +33,37 @@ interface SkillMcpState {
 	loadedSkills: Map<string, Record<string, McpServerConfig>>; // skillName -> mcp configs
 }
 
+/**
+ * Match a tool name against a glob pattern
+ * Supports: exact match, * (any chars), ? (single char)
+ */
+function matchGlobPattern(pattern: string, toolName: string): boolean {
+	// Exact match
+	if (pattern === toolName) return true;
+
+	// Convert glob to regex
+	const regexPattern = pattern
+		.replace(/[.+^${}()|[\]\\]/g, "\\$&") // Escape special regex chars
+		.replace(/\*/g, ".*") // * -> .*
+		.replace(/\?/g, "."); // ? -> .
+
+	const regex = new RegExp(`^${regexPattern}$`);
+	return regex.test(toolName);
+}
+
+/**
+ * Filter tools based on includeTools patterns
+ */
+function filterTools(allTools: any[], includePatterns?: string[]): any[] {
+	if (!includePatterns || includePatterns.length === 0) {
+		return allTools; // No filtering, return all
+	}
+
+	return allTools.filter((tool) =>
+		includePatterns.some((pattern) => matchGlobPattern(pattern, tool.name)),
+	);
+}
+
 function parseYamlFrontmatter(content: string): {
 	frontmatter: any;
 	body: string;
@@ -43,11 +76,10 @@ function parseYamlFrontmatter(content: string): {
 
 	// Simple YAML parser for our use case
 	const frontmatter: any = {};
-	let currentKey = "";
-	let currentIndent = 0;
 	let mcpConfig: any = null;
 	let serverName = "";
 	let serverConfig: any = {};
+	let currentArrayKey = "";
 
 	for (const line of yamlStr.split("\n")) {
 		const trimmed = line.trim();
@@ -67,40 +99,80 @@ function parseYamlFrontmatter(content: string): {
 				} else {
 					frontmatter[key] = value || undefined;
 				}
-				currentKey = key;
-				currentIndent = indent;
+				currentArrayKey = "";
 			} else if (mcpConfig !== null && indent === 2) {
 				// Server name under mcp
 				serverName = key;
 				serverConfig = {};
 				mcpConfig[serverName] = serverConfig;
+				currentArrayKey = "";
 			} else if (serverConfig && indent === 4) {
 				// Server config property
 				if (key === "command") {
 					serverConfig.command = value;
-				} else if (key === "args") {
+					currentArrayKey = "";
+				} else if (key === "args" || key === "includeTools") {
 					// Parse inline array or set up for multi-line
 					if (value.startsWith("[")) {
 						try {
-							serverConfig.args = JSON.parse(value);
+							serverConfig[key] = JSON.parse(value);
 						} catch {
-							serverConfig.args = [];
+							serverConfig[key] = [];
 						}
+						currentArrayKey = "";
 					} else {
-						serverConfig.args = [];
+						serverConfig[key] = [];
+						currentArrayKey = key;
 					}
+				} else {
+					currentArrayKey = "";
 				}
 			}
-		} else if (trimmed.startsWith("- ") && serverConfig?.args) {
-			// Array item for args
+		} else if (
+			trimmed.startsWith("- ") &&
+			serverConfig &&
+			currentArrayKey &&
+			serverConfig[currentArrayKey]
+		) {
+			// Array item for args or includeTools
 			const item = trimmed.slice(2).replace(/^["']|["']$/g, "");
-			serverConfig.args.push(item);
+			serverConfig[currentArrayKey].push(item);
 		}
 	}
 
 	return { frontmatter, body };
 }
 
+/**
+ * Load MCP config from either mcp.json or YAML frontmatter
+ * Priority: mcp.json > YAML frontmatter (Ampcode pattern)
+ */
+function loadMcpConfig(
+	skillDir: string,
+	skillPath: string,
+): Record<string, McpServerConfig> | null {
+	// Try mcp.json first (Ampcode pattern)
+	const mcpJsonPath = join(skillDir, "mcp.json");
+	if (existsSync(mcpJsonPath)) {
+		try {
+			const mcpJson = JSON.parse(readFileSync(mcpJsonPath, "utf-8"));
+			return mcpJson;
+		} catch {
+			// Fall through to YAML
+		}
+	}
+
+	// Fall back to YAML frontmatter
+	const content = readFileSync(skillPath, "utf-8");
+	const { frontmatter } = parseYamlFrontmatter(content);
+
+	if (frontmatter.mcp && Object.keys(frontmatter.mcp).length > 0) {
+		return frontmatter.mcp;
+	}
+
+	return null;
+}
+
 function findSkillPath(skillName: string, projectDir: string): string | null {
 	const locations = [
 		join(projectDir, ".opencode", "skill", skillName, "SKILL.md"),
@@ -216,7 +288,7 @@ export const SkillMcpPlugin: Plugin = async ({ directory }) => {
 			console.error(`MCP server error [${key}]:`, err.message);
 		});
 
-		proc.on("exit", (code) => {
+		proc.on("exit", () => {
 			state.clients.delete(key);
 		});
 
@@ -227,7 +299,7 @@ export const SkillMcpPlugin: Plugin = async ({ directory }) => {
 			await sendRequest(client, "initialize", {
 				protocolVersion: "2024-11-05",
 				capabilities: {},
-				clientInfo: { name: "opencode-skill-mcp", version: "1.0.0" },
+				clientInfo: { name: "opencode-skill-mcp", version: "1.1.0" },
 			});
 
 			// Send initialized notification
@@ -241,9 +313,14 @@ export const SkillMcpPlugin: Plugin = async ({ directory }) => {
 			// Discover capabilities
 			try {
 				const toolsResult = await sendRequest(client, "tools/list", {});
-				client.capabilities = { tools: toolsResult.tools || [] };
+				const allTools = toolsResult.tools || [];
+				client.capabilities = { tools: allTools };
+
+				// Apply includeTools filtering (Ampcode pattern)
+				client.filteredTools = filterTools(allTools, config.includeTools);
 			} catch {
 				client.capabilities = { tools: [] };
+				client.filteredTools = [];
 			}
 		} catch (e: any) {
 			proc.kill();
@@ -255,7 +332,7 @@ export const SkillMcpPlugin: Plugin = async ({ directory }) => {
 	}
 
 	function disconnectAll() {
-		for (const [key, client] of state.clients) {
+		for (const [, client] of state.clients) {
 			client.process.kill();
 		}
 		state.clients.clear();
@@ -266,10 +343,11 @@ export const SkillMcpPlugin: Plugin = async ({ directory }) => {
 			skill_mcp: tool({
 				description: `Invoke MCP tools from skill-embedded MCP servers.
 
-When a skill declares MCP servers in its YAML frontmatter, use this tool to:
+When a skill declares MCP servers (via mcp.json or YAML frontmatter), use this tool to:
 - List available tools: skill_mcp(skill_name="playwright", list_tools=true)
 - Call a tool: skill_mcp(skill_name="playwright", tool_name="browser_navigate", arguments='{"url": "..."}')
 
+Skills can use "includeTools" to filter which MCP tools are exposed (reduces token usage).
 The skill must be loaded first via the skill() tool to register its MCP config.`,
 				args: {
 					skill_name: tool.schema
@@ -305,34 +383,34 @@ The skill must be loaded first via the skill() tool to register its MCP config.`
 						return JSON.stringify({ error: "skill_name required" });
 					}
 
-					// Find skill and parse its MCP config
+					// Find skill path
 					const skillPath = findSkillPath(skill_name, directory);
 					if (!skillPath) {
 						return JSON.stringify({ error: `Skill '${skill_name}' not found` });
 					}
 
-					const content = readFileSync(skillPath, "utf-8");
-					const { frontmatter } = parseYamlFrontmatter(content);
+					// Load MCP config from mcp.json or YAML frontmatter
+					const skillDir = dirname(skillPath);
+					const mcpConfig = loadMcpConfig(skillDir, skillPath);
 
-					if (!frontmatter.mcp || Object.keys(frontmatter.mcp).length === 0) {
+					if (!mcpConfig) {
 						return JSON.stringify({
-							error: `Skill '${skill_name}' has no MCP config`,
+							error: `Skill '${skill_name}' has no MCP config (check mcp.json or YAML frontmatter)`,
 						});
 					}
 
 					// Determine which MCP server to use
-					const mcpServers = frontmatter.mcp as Record<string, McpServerConfig>;
-					const serverNames = Object.keys(mcpServers);
+					const serverNames = Object.keys(mcpConfig);
 					const targetServer = mcp_name || serverNames[0];
 
-					if (!mcpServers[targetServer]) {
+					if (!mcpConfig[targetServer]) {
 						return JSON.stringify({
 							error: `MCP server '${targetServer}' not found in skill`,
 							available: serverNames,
 						});
 					}
 
-					const serverConfig = mcpServers[targetServer];
+					const serverConfig = mcpConfig[targetServer];
 
 					// Connect to MCP server
 					let client: McpClient;
@@ -346,17 +424,29 @@ The skill must be loaded first via the skill() tool to register its MCP config.`
 						return JSON.stringify({ error: `Failed to connect: ${e.message}` });
 					}
 
-					// List tools
+					// List tools (filtered by includeTools if configured)
 					if (list_tools) {
+						const totalTools = client.capabilities?.tools?.length || 0;
+						const filteredTools = client.filteredTools || [];
+						const isFiltered =
+							serverConfig.includeTools && serverConfig.includeTools.length > 0;
+
 						return JSON.stringify(
 							{
 								mcp: targetServer,
-								tools:
-									client.capabilities?.tools?.map((t: any) => ({
-										name: t.name,
-										description: t.description,
-										schema: t.inputSchema,
-									})) || [],
+								tools: filteredTools.map((t: any) => ({
+									name: t.name,
+									description: t.description,
+									schema: t.inputSchema,
+								})),
+								...(isFiltered && {
+									filtering: {
+										patterns: serverConfig.includeTools,
+										showing: filteredTools.length,
+										total: totalTools,
+										tokenSavings: `~${Math.round((1 - filteredTools.length / totalTools) * 100)}%`,
+									},
+								}),
 							},
 							null,
 							2,
@@ -365,11 +455,28 @@ The skill must be loaded first via the skill() tool to register its MCP config.`
 
 					// Call tool
 					if (tool_name) {
+						// Validate tool is in filtered list (if filtering is enabled)
+						if (
+							serverConfig.includeTools &&
+							serverConfig.includeTools.length > 0
+						) {
+							const isAllowed = client.filteredTools?.some(
+								(t: any) => t.name === tool_name,
+							);
+							if (!isAllowed) {
+								return JSON.stringify({
+									error: `Tool '${tool_name}' is not in includeTools filter`,
+									allowed: client.filteredTools?.map((t: any) => t.name) || [],
+									hint: "Add this tool to includeTools in mcp.json or YAML frontmatter",
+								});
+							}
+						}
+
 						let toolArgs = {};
 						if (argsJson) {
 							try {
 								toolArgs = JSON.parse(argsJson);
-							} catch (e) {
+							} catch {
 								return JSON.stringify({ error: "Invalid JSON in arguments" });
 							}
 						}
@@ -391,7 +498,7 @@ The skill must be loaded first via the skill() tool to register its MCP config.`
 						error: "Specify either list_tools=true or tool_name to call",
 						mcp: targetServer,
 						available_tools:
-							client.capabilities?.tools?.map((t: any) => t.name) || [],
+							client.filteredTools?.map((t: any) => t.name) || [],
 					});
 				},
 			}),
@@ -403,11 +510,23 @@ The skill must be loaded first via the skill() tool to register its MCP config.`
 					const servers: any[] = [];
 					for (const [key, client] of state.clients) {
 						const [skillName, serverName] = key.split(":");
+						const totalTools = client.capabilities?.tools?.length || 0;
+						const filteredTools = client.filteredTools?.length || 0;
+						const isFiltered =
+							client.config.includeTools &&
+							client.config.includeTools.length > 0;
+
 						servers.push({
 							skill: skillName,
 							server: serverName,
 							connected: !client.process.killed,
-							tools: client.capabilities?.tools?.length || 0,
+							tools: filteredTools,
+							...(isFiltered && {
+								filtering: {
+									total: totalTools,
+									filtered: filteredTools,
+								},
+							}),
 						});
 					}
 					return JSON.stringify({

package/dist/template/.opencode/skill/chrome-devtools/SKILL.md

@@ -1,88 +1,66 @@
 ---
 name: chrome-devtools
 description: Chrome DevTools for debugging, performance analysis, and browser automation. Use when debugging web apps, analyzing performance, inspecting network requests, or automating browser interactions.
-mcp:
-  chrome-devtools:
-    command: npx
-    args: ["-y", "chrome-devtools-mcp@latest", "--stdio"]
 ---
 
 # Chrome DevTools (MCP)
 
-Control and inspect a live Chrome browser via Chrome DevTools Protocol. Debug, analyze performance, inspect network, and automate browser interactions.
+Control and inspect a live Chrome browser via Chrome DevTools Protocol.
 
-## Quick Start
-
-```
-skill_mcp(skill_name="chrome-devtools", tool_name="take_snapshot")
-skill_mcp(skill_name="chrome-devtools", tool_name="navigate_page", arguments='{"type": "url", "url": "https://example.com"}')
-```
-
-## Tools
-
-### Input
+## Available Tools
 
-| Tool            | Description          | Parameters                   |
-| --------------- | -------------------- | ---------------------------- |
-| `click`         | Click element        | `uid`                        |
-| `fill`          | Type text            | `uid`, `value`               |
-| `fill_form`     | Fill multiple fields | `elements` array             |
-| `hover`         | Hover element        | `uid`                        |
-| `press_key`     | Press key            | `key` (e.g., "Enter")        |
-| `drag`          | Drag element         | `from_uid`, `to_uid`         |
-| `upload_file`   | Upload file          | `uid`, `filePath`            |
-| `handle_dialog` | Handle dialog        | `action`: "accept"/"dismiss" |
+- `take_snapshot` - Get accessibility tree snapshot with element UIDs
+- `take_screenshot` - Capture screenshot of page or element
+- `navigate_page` - Navigate to URL, back, forward, or reload
+- `new_page` - Open a new browser tab
+- `list_pages` - List all open pages/tabs
+- `click` - Click element by UID
+- `fill` - Type text into element
+- `hover` - Hover over element
+- `press_key` - Press keyboard key (Enter, Tab, etc.)
+- `evaluate_script` - Run JavaScript in page context
+- `wait_for` - Wait for text to appear
 
-### Navigation
+## Workflow
 
-| Tool            | Description   | Parameters                                     |
-| --------------- | ------------- | ---------------------------------------------- |
-| `navigate_page` | Navigate      | `type`: "url"/"back"/"forward"/"reload", `url` |
-| `new_page`      | Open new page | `url`                                          |
-| `list_pages`    | List pages    | -                                              |
-| `select_page`   | Switch page   | `pageIdx`                                      |
-| `close_page`    | Close page    | `pageIdx`                                      |
-| `wait_for`      | Wait for text | `text`, `timeout`                              |
+1. **Snapshot** the page using `take_snapshot` to get element UIDs
+2. **Navigate** to target URL using `navigate_page`
+3. **Interact** using `click`, `fill`, `hover` with UIDs from snapshot
+4. **Screenshot** to capture results using `take_screenshot`
 
-### Debugging
-
-| Tool                    | Description        | Parameters                  |
-| ----------------------- | ------------------ | --------------------------- |
-| `take_snapshot`         | A11y tree snapshot | `verbose`                   |
-| `take_screenshot`       | Screenshot         | `uid`, `fullPage`, `format` |
-| `evaluate_script`       | Run JS             | `function`, `args`          |
-| `list_console_messages` | Console logs       | `types` filter              |
-| `get_console_message`   | Get message        | `msgid`                     |
-
-### Network
+## Quick Start
 
-| Tool                    | Description     | Parameters                  |
-| ----------------------- | --------------- | --------------------------- |
-| `list_network_requests` | List requests   | `resourceTypes`, `pageSize` |
-| `get_network_request`   | Request details | `reqid`                     |
+```
+# Get page structure with element UIDs
+skill_mcp(skill_name="chrome-devtools", tool_name="take_snapshot")
 
-### Performance
+# Navigate to URL
+skill_mcp(skill_name="chrome-devtools", tool_name="navigate_page", arguments='{"type": "url", "url": "https://example.com"}')
 
-| Tool                          | Description | Parameters                    |
-| ----------------------------- | ----------- | ----------------------------- |
-| `performance_start_trace`     | Start trace | `reload`, `autoStop`          |
-| `performance_stop_trace`      | Stop trace  | -                             |
-| `performance_analyze_insight` | Analyze     | `insightSetId`, `insightName` |
+# Click element (use UID from snapshot)
+skill_mcp(skill_name="chrome-devtools", tool_name="click", arguments='{"uid": "e123"}')
 
-### Emulation
+# Fill input field
+skill_mcp(skill_name="chrome-devtools", tool_name="fill", arguments='{"uid": "e456", "value": "hello"}')
 
-| Tool          | Description        | Parameters                               |
-| ------------- | ------------------ | ---------------------------------------- |
-| `emulate`     | Emulate conditions | `networkConditions`, `cpuThrottlingRate` |
-| `resize_page` | Resize viewport    | `width`, `height`                        |
+# Take screenshot
+skill_mcp(skill_name="chrome-devtools", tool_name="take_screenshot")
+```
 
 ## Tips
 
-- **Always `take_snapshot` first** to get element `uid`s
-- **Element uids change** after navigation - take fresh snapshot
-- **Network conditions**: "Slow 3G", "Fast 3G", "Offline"
+- **Always `take_snapshot` first** to get element UIDs
+- **Element UIDs change** after navigation - take fresh snapshot
+- **Use `wait_for`** after actions that trigger page changes
+- **Use `evaluate_script`** for custom JS when tools don't cover your need
 
 ## vs Playwright
 
-- **chrome-devtools**: Performance profiling, network inspection, console - Chrome only
-- **playwright**: Cross-browser testing - Chrome, Firefox, WebKit
+| Feature             | chrome-devtools      | playwright         |
+| ------------------- | -------------------- | ------------------ |
+| Browser support     | Chrome only          | Chrome, FF, WebKit |
+| Performance tracing | ✅ (full MCP has it) | ❌                 |
+| Network inspection  | ✅ (full MCP has it) | ❌                 |
+| Cross-browser       | ❌                   | ✅                 |
+
+> **Note**: This skill loads 11 essential tools. For full 26+ tools (performance, network, console), modify `mcp.json` to remove `includeTools` filter.

package/dist/template/.opencode/skill/chrome-devtools/mcp.json

@@ -0,0 +1,19 @@
+{
+	"chrome-devtools": {
+		"command": "npx",
+		"args": ["-y", "chrome-devtools-mcp@latest", "--stdio"],
+		"includeTools": [
+			"take_snapshot",
+			"take_screenshot",
+			"navigate_page",
+			"new_page",
+			"list_pages",
+			"click",
+			"fill",
+			"hover",
+			"press_key",
+			"evaluate_script",
+			"wait_for"
+		]
+	}
+}

package/dist/template/.opencode/skill/executing-plans/SKILL.md

@@ -19,8 +19,38 @@ Load plan, review critically, execute tasks in batches, report for review betwee
 
 1. Read plan file
 2. Review critically - identify any questions or concerns about the plan
-3. If concerns: Raise them with your human partner before starting
-4. If no concerns: Create TodoWrite and proceed
+3. If concerns: Use question tool to raise them:
+
+```typescript
+question({
+  questions: [
+    {
+      header: "Concerns",
+      question: "Plan review complete. Any concerns before proceeding?",
+      options: [
+        {
+          label: "No concerns (Recommended)",
+          description: "Plan looks good, execute batches",
+        },
+        {
+          label: "Has concerns",
+          description: "Need clarification before starting",
+        },
+      ],
+    },
+  ],
+});
+```
+
+4. Read plan and identify:
+   - What is the goal?
+   - What are the deliverables?
+   - What are the risks?
+   - Does the approach make sense?
+   - Are there missing pieces?
+
+If no concerns: Create TodoWrite and proceed
+If concerns: Wait for human to decide and resubmit
 
 ### Step 2: Execute Batch