opencodekit 0.9.1 → 0.10.0

package/dist/template/.opencode/skill/v0/SKILL.md

@@ -0,0 +1,154 @@
+---
+name: v0
+description: AI-powered UI generation via v0 MCP. Create chats, generate React components, get design assistance. Use when building UI components, dashboards, or need AI design help.
+mcp:
+  v0:
+    command: npx
+    args:
+      [
+        "mcp-remote",
+        "https://mcp.v0.dev",
+        "--header",
+        "Authorization: Bearer ${V0_API_KEY}",
+      ]
+    env:
+      V0_API_KEY: "${V0_API_KEY}"
+---
+
+# v0 AI Code Generation (MCP)
+
+Access v0's AI-powered code generation via MCP. When this skill is loaded, the `v0` MCP server auto-starts and exposes tools for creating and managing v0 chats.
+
+## Prerequisites
+
+Set your v0 API key as an environment variable:
+
+```bash
+export V0_API_KEY="your-v0-api-key"
+```
+
+To get your v0 API key:
+
+1. Go to [v0 account settings](https://v0.app/chat/settings/keys)
+2. Create a new API key
+3. Copy and set as environment variable
+
+## Quick Start
+
+After loading this skill, list available tools:
+
+```
+skill_mcp(skill_name="v0", list_tools=true)
+```
+
+Then invoke tools:
+
+```
+skill_mcp(skill_name="v0", tool_name="create_chat", arguments='{"prompt": "Create a React dashboard component with a sidebar"}')
+```
+
+## Available Tools
+
+### create_chat
+
+Create a new v0 chat with a prompt.
+
+| Parameter | Type   | Required | Description                        |
+| --------- | ------ | -------- | ---------------------------------- |
+| `prompt`  | string | Yes      | The prompt for v0 to generate code |
+
+**Example:**
+
+```
+skill_mcp(skill_name="v0", tool_name="create_chat", arguments='{"prompt": "Build a responsive navbar with dark mode toggle"}')
+```
+
+### get_chat
+
+Get details about an existing chat.
+
+| Parameter | Type   | Required | Description    |
+| --------- | ------ | -------- | -------------- |
+| `chatId`  | string | Yes      | The v0 chat ID |
+
+**Example:**
+
+```
+skill_mcp(skill_name="v0", tool_name="get_chat", arguments='{"chatId": "abc123"}')
+```
+
+### find_chats
+
+Search through your v0 chats.
+
+| Parameter | Type   | Required | Description  |
+| --------- | ------ | -------- | ------------ |
+| `query`   | string | No       | Search query |
+
+**Example:**
+
+```
+skill_mcp(skill_name="v0", tool_name="find_chats", arguments='{"query": "React components"}')
+```
+
+### send_message
+
+Continue a conversation in an existing chat.
+
+| Parameter | Type   | Required | Description     |
+| --------- | ------ | -------- | --------------- |
+| `chatId`  | string | Yes      | The v0 chat ID  |
+| `message` | string | Yes      | Message to send |
+
+**Example:**
+
+```
+skill_mcp(skill_name="v0", tool_name="send_message", arguments='{"chatId": "abc123", "message": "Add dark mode support"}')
+```
+
+## Workflow
+
+### 1. Generate a New Component
+
+```
+# Create a new chat with your requirements
+skill_mcp(skill_name="v0", tool_name="create_chat", arguments='{"prompt": "Create a modern pricing table with 3 tiers using Tailwind CSS"}')
+
+# The response includes a chat ID and generated code
+```
+
+### 2. Iterate on Design
+
+```
+# Send follow-up messages to refine
+skill_mcp(skill_name="v0", tool_name="send_message", arguments='{"chatId": "chat-id-here", "message": "Make the recommended tier more prominent with a gradient border"}')
+```
+
+### 3. Search Previous Work
+
+```
+# Find relevant previous chats
+skill_mcp(skill_name="v0", tool_name="find_chats", arguments='{"query": "dashboard"}')
+```
+
+## Use Cases
+
+- **Component Generation**: Create React/Next.js components from descriptions
+- **UI Prototyping**: Rapidly prototype UI ideas
+- **Design Iteration**: Refine designs through conversation
+- **Code Assistance**: Get help with Tailwind CSS, responsive design, etc.
+
+## Tips
+
+- **Be specific** in prompts - include framework (React, Next.js), styling (Tailwind, CSS), and functionality details
+- **Iterate** using `send_message` rather than creating new chats for refinements
+- **Search first** with `find_chats` to reuse previous work
+- **Include context** about your existing design system or component patterns
+
+## Troubleshooting
+
+**"Invalid API key"**: Ensure `V0_API_KEY` environment variable is set correctly.
+
+**"Rate limit exceeded"**: v0 has usage limits. Wait a few minutes or check your plan.
+
+**"Chat not found"**: Verify the chat ID is correct. Use `find_chats` to list available chats.

package/dist/template/.opencode/tool/lsp.ts

@@ -14,7 +14,13 @@ import { lspManager } from "../lib/lsp/client";
 import { resolveServer } from "../lib/lsp/config";
 import type {
 	CodeAction,
+	Diagnostic,
+	DocumentSymbol,
+	HoverResult,
+	Location,
+	LocationLink,
 	PrepareRenameResult,
+	SymbolInfo,
 	WorkspaceEdit,
 } from "../lib/lsp/types";
 import {
@@ -328,5 +334,453 @@ Note: File was modified directly. Re-read before editing.`;
 	},
 });
 
+/**
+ * Get hover information (type/documentation) at a position
+ */
+export const lsp_hover = tool({
+	description: `Get type information and documentation for a symbol at a specific position.
+
+Returns type signatures, JSDoc/docstrings, and other hover information the language server provides.
+Useful for understanding what a variable/function is without reading its definition.`,
+
+	args: {
+		filePath: tool.schema.string().describe("Path to the file"),
+		line: tool.schema.number().describe("Line number (1-based)"),
+		character: tool.schema.number().describe("Character position (0-based)"),
+	},
+
+	async execute(args) {
+		const cwd = process.cwd();
+		const absPath = resolve(cwd, args.filePath);
+		const server = resolveServer(absPath);
+
+		if (!server) {
+			return `Error: No LSP server available for file type: ${absPath}`;
+		}
+
+		try {
+			const client = await lspManager.getClient(cwd, server);
+			const result = (await client.hover(
+				absPath,
+				args.line,
+				args.character,
+			)) as HoverResult | null;
+			lspManager.releaseClient(cwd, server.id);
+
+			if (!result) {
+				return "No hover information available at this position.";
+			}
+
+			return formatHoverResult(result);
+		} catch (error) {
+			return `Error: ${error instanceof Error ? error.message : String(error)}`;
+		}
+	},
+});
+
+/**
+ * Go to definition of a symbol
+ */
+export const lsp_goto_definition = tool({
+	description: `Find the definition location of a symbol at a specific position.
+
+Returns the file path and position where the symbol is defined.
+Works for functions, variables, classes, types, imports, etc.`,
+
+	args: {
+		filePath: tool.schema.string().describe("Path to the file"),
+		line: tool.schema.number().describe("Line number (1-based)"),
+		character: tool.schema.number().describe("Character position (0-based)"),
+	},
+
+	async execute(args) {
+		const cwd = process.cwd();
+		const absPath = resolve(cwd, args.filePath);
+		const server = resolveServer(absPath);
+
+		if (!server) {
+			return `Error: No LSP server available for file type: ${absPath}`;
+		}
+
+		try {
+			const client = await lspManager.getClient(cwd, server);
+			const result = (await client.definition(
+				absPath,
+				args.line,
+				args.character,
+			)) as Location | Location[] | LocationLink[] | null;
+			lspManager.releaseClient(cwd, server.id);
+
+			if (!result) {
+				return "No definition found at this position.";
+			}
+
+			return formatLocations(result);
+		} catch (error) {
+			return `Error: ${error instanceof Error ? error.message : String(error)}`;
+		}
+	},
+});
+
+/**
+ * Find all references to a symbol
+ */
+export const lsp_find_references = tool({
+	description: `Find all references to a symbol across the workspace.
+
+Returns all locations where the symbol is used, including the definition.
+Useful for understanding usage before refactoring.`,
+
+	args: {
+		filePath: tool.schema.string().describe("Path to the file"),
+		line: tool.schema.number().describe("Line number (1-based)"),
+		character: tool.schema.number().describe("Character position (0-based)"),
+		includeDeclaration: tool.schema
+			.boolean()
+			.optional()
+			.describe("Include the declaration itself (default: true)"),
+	},
+
+	async execute(args) {
+		const cwd = process.cwd();
+		const absPath = resolve(cwd, args.filePath);
+		const server = resolveServer(absPath);
+
+		if (!server) {
+			return `Error: No LSP server available for file type: ${absPath}`;
+		}
+
+		try {
+			const client = await lspManager.getClient(cwd, server);
+			const result = (await client.references(
+				absPath,
+				args.line,
+				args.character,
+				args.includeDeclaration ?? true,
+			)) as Location[] | null;
+			lspManager.releaseClient(cwd, server.id);
+
+			if (!result || result.length === 0) {
+				return "No references found.";
+			}
+
+			const locations = result.slice(0, 50); // Limit results
+			const formatted = locations.map((loc) => formatLocation(loc)).join("\n");
+			const suffix =
+				result.length > 50 ? `\n\n... and ${result.length - 50} more` : "";
+
+			return `Found ${result.length} reference(s):\n\n${formatted}${suffix}`;
+		} catch (error) {
+			return `Error: ${error instanceof Error ? error.message : String(error)}`;
+		}
+	},
+});
+
+/**
+ * Get document symbols (outline) for a file
+ */
+export const lsp_document_symbols = tool({
+	description: `Get the symbol outline of a file (classes, functions, variables, etc.).
+
+Returns a hierarchical structure of all symbols in the file.
+Useful for understanding file structure quickly.`,
+
+	args: {
+		filePath: tool.schema.string().describe("Path to the file"),
+	},
+
+	async execute(args) {
+		const cwd = process.cwd();
+		const absPath = resolve(cwd, args.filePath);
+		const server = resolveServer(absPath);
+
+		if (!server) {
+			return `Error: No LSP server available for file type: ${absPath}`;
+		}
+
+		try {
+			const client = await lspManager.getClient(cwd, server);
+			const result = (await client.documentSymbols(absPath)) as
+				| DocumentSymbol[]
+				| SymbolInfo[]
+				| null;
+			lspManager.releaseClient(cwd, server.id);
+
+			if (!result || result.length === 0) {
+				return "No symbols found in this file.";
+			}
+
+			return formatDocumentSymbols(result);
+		} catch (error) {
+			return `Error: ${error instanceof Error ? error.message : String(error)}`;
+		}
+	},
+});
+
+/**
+ * Search for symbols across the workspace
+ */
+export const lsp_workspace_symbols = tool({
+	description: `Search for symbols by name across the entire workspace.
+
+Performs fuzzy matching on symbol names (functions, classes, variables, etc.).
+Useful for finding where something is defined without knowing the exact file.`,
+
+	args: {
+		query: tool.schema
+			.string()
+			.describe("Symbol name to search for (fuzzy match)"),
+		filePath: tool.schema
+			.string()
+			.optional()
+			.describe("Any file in the project (used to determine language server)"),
+	},
+
+	async execute(args) {
+		const cwd = process.cwd();
+		const absPath = args.filePath
+			? resolve(cwd, args.filePath)
+			: resolve(cwd, ".");
+		const server = resolveServer(absPath);
+
+		if (!server) {
+			return `Error: No LSP server available. Provide a filePath to help identify the language.`;
+		}
+
+		try {
+			const client = await lspManager.getClient(cwd, server);
+			const result = (await client.workspaceSymbols(args.query)) as
+				| SymbolInfo[]
+				| null;
+			lspManager.releaseClient(cwd, server.id);
+
+			if (!result || result.length === 0) {
+				return `No symbols found matching "${args.query}".`;
+			}
+
+			const symbols = result.slice(0, 30); // Limit results
+			const formatted = symbols
+				.map(
+					(sym) =>
+						`${getSymbolKindName(sym.kind)} ${sym.name}${sym.containerName ? ` (in ${sym.containerName})` : ""}\n  ${formatUri(sym.location.uri)}:${sym.location.range.start.line + 1}`,
+				)
+				.join("\n\n");
+			const suffix =
+				result.length > 30 ? `\n\n... and ${result.length - 30} more` : "";
+
+			return `Found ${result.length} symbol(s):\n\n${formatted}${suffix}`;
+		} catch (error) {
+			return `Error: ${error instanceof Error ? error.message : String(error)}`;
+		}
+	},
+});
+
+/**
+ * Get diagnostics (errors, warnings) for a file
+ */
+export const lsp_diagnostics = tool({
+	description: `Get diagnostics (errors, warnings, hints) for a file from the language server.
+
+Returns type errors, lint warnings, and other issues detected by the language server.
+Useful for checking if code has problems before running tests.`,
+
+	args: {
+		filePath: tool.schema.string().describe("Path to the file"),
+		severity: tool.schema
+			.string()
+			.optional()
+			.describe(
+				"Filter by severity: 'error', 'warning', 'info', 'hint', or 'all' (default: all)",
+			),
+	},
+
+	async execute(args) {
+		const cwd = process.cwd();
+		const absPath = resolve(cwd, args.filePath);
+		const server = resolveServer(absPath);
+
+		if (!server) {
+			return `Error: No LSP server available for file type: ${absPath}`;
+		}
+
+		try {
+			const client = await lspManager.getClient(cwd, server);
+			const result = await client.diagnostics(absPath);
+			lspManager.releaseClient(cwd, server.id);
+
+			let diagnostics = result.items || [];
+
+			// Filter by severity if specified
+			if (args.severity && args.severity !== "all") {
+				const severityMap: Record<string, number> = {
+					error: 1,
+					warning: 2,
+					info: 3,
+					hint: 4,
+				};
+				const targetSeverity = severityMap[args.severity.toLowerCase()];
+				if (targetSeverity) {
+					diagnostics = diagnostics.filter(
+						(d) => d.severity === targetSeverity,
+					);
+				}
+			}
+
+			if (diagnostics.length === 0) {
+				return args.severity && args.severity !== "all"
+					? `No ${args.severity} diagnostics found.`
+					: "No diagnostics found. File appears clean.";
+			}
+
+			return formatDiagnostics(diagnostics, args.filePath);
+		} catch (error) {
+			return `Error: ${error instanceof Error ? error.message : String(error)}`;
+		}
+	},
+});
+
+// ============ Helper Functions ============
+
+function formatHoverResult(hover: HoverResult): string {
+	const contents = hover.contents;
+
+	if (typeof contents === "string") {
+		return contents;
+	}
+
+	if (Array.isArray(contents)) {
+		return contents
+			.map((c) => (typeof c === "string" ? c : c.value))
+			.join("\n\n");
+	}
+
+	if (typeof contents === "object" && "value" in contents) {
+		return contents.value;
+	}
+
+	return JSON.stringify(contents);
+}
+
+function formatUri(uri: string): string {
+	return uri.replace("file://", "").replace(process.cwd() + "/", "");
+}
+
+function formatLocation(loc: Location | LocationLink): string {
+	if ("targetUri" in loc) {
+		return `${formatUri(loc.targetUri)}:${loc.targetRange.start.line + 1}:${loc.targetRange.start.character}`;
+	}
+	return `${formatUri(loc.uri)}:${loc.range.start.line + 1}:${loc.range.start.character}`;
+}
+
+function formatLocations(
+	result: Location | Location[] | LocationLink[],
+): string {
+	const locations = Array.isArray(result) ? result : [result];
+
+	if (locations.length === 0) {
+		return "No locations found.";
+	}
+
+	if (locations.length === 1) {
+		return `Definition: ${formatLocation(locations[0] as Location | LocationLink)}`;
+	}
+
+	return `Found ${locations.length} location(s):\n${locations.map((l) => `  ${formatLocation(l as Location | LocationLink)}`).join("\n")}`;
+}
+
+function formatDocumentSymbols(
+	symbols: DocumentSymbol[] | SymbolInfo[],
+	indent = 0,
+): string {
+	const prefix = "  ".repeat(indent);
+	const lines: string[] = [];
+
+	for (const sym of symbols) {
+		const kindName = getSymbolKindName(sym.kind);
+		const line =
+			"range" in sym
+				? sym.range.start.line + 1
+				: "location" in sym
+					? sym.location.range.start.line + 1
+					: "?";
+
+		lines.push(`${prefix}${kindName} ${sym.name} (line ${line})`);
+
+		if ("children" in sym && sym.children) {
+			lines.push(formatDocumentSymbols(sym.children, indent + 1));
+		}
+	}
+
+	return lines.join("\n");
+}
+
+function formatDiagnostics(
+	diagnostics: Diagnostic[],
+	filePath: string,
+): string {
+	const severityNames = ["", "Error", "Warning", "Info", "Hint"];
+
+	const sorted = [...diagnostics].sort((a, b) => {
+		const sevA = a.severity ?? 4;
+		const sevB = b.severity ?? 4;
+		if (sevA !== sevB) return sevA - sevB;
+		return a.range.start.line - b.range.start.line;
+	});
+
+	const lines = sorted.map((d) => {
+		const sev = severityNames[d.severity ?? 4] || "Unknown";
+		const line = d.range.start.line + 1;
+		const col = d.range.start.character + 1;
+		const source = d.source ? `[${d.source}]` : "";
+		const code = d.code ? ` (${d.code})` : "";
+		return `${sev}: ${filePath}:${line}:${col}${code} ${source}\n  ${d.message}`;
+	});
+
+	const errorCount = diagnostics.filter((d) => d.severity === 1).length;
+	const warnCount = diagnostics.filter((d) => d.severity === 2).length;
+
+	let summary = `Found ${diagnostics.length} diagnostic(s)`;
+	if (errorCount > 0 || warnCount > 0) {
+		const parts: string[] = [];
+		if (errorCount > 0) parts.push(`${errorCount} error(s)`);
+		if (warnCount > 0) parts.push(`${warnCount} warning(s)`);
+		summary += `: ${parts.join(", ")}`;
+	}
+
+	return `${summary}\n\n${lines.join("\n\n")}`;
+}
+
+function getSymbolKindName(kind: number): string {
+	const kinds: Record<number, string> = {
+		1: "File",
+		2: "Module",
+		3: "Namespace",
+		4: "Package",
+		5: "Class",
+		6: "Method",
+		7: "Property",
+		8: "Field",
+		9: "Constructor",
+		10: "Enum",
+		11: "Interface",
+		12: "Function",
+		13: "Variable",
+		14: "Constant",
+		15: "String",
+		16: "Number",
+		17: "Boolean",
+		18: "Array",
+		19: "Object",
+		20: "Key",
+		21: "Null",
+		22: "EnumMember",
+		23: "Struct",
+		24: "Event",
+		25: "Operator",
+		26: "TypeParameter",
+	};
+	return kinds[kind] || `Kind(${kind})`;
+}
+
 // Default export for single-tool registration (uses rename as primary)
 export default lsp_rename;