gsd-pi 2.29.0-dev.49d972f → 2.29.0-dev.4c155ee

package/src/resources/extensions/mcp-client/index.ts

@@ -0,0 +1,459 @@
+/**
+ * MCP Client Extension — Native MCP server integration for pi
+ *
+ * Provides on-demand access to MCP servers configured in project files
+ * (.mcp.json, .gsd/mcp.json) using the @modelcontextprotocol/sdk Client
+ * directly — no external CLI dependency required.
+ *
+ * Three tools:
+ *   mcp_servers   — List available MCP servers from config files
+ *   mcp_discover  — Get tool signatures for a specific server (lazy connect)
+ *   mcp_call      — Call a tool on an MCP server (lazy connect)
+ */
+
+import type { ExtensionAPI } from "@gsd/pi-coding-agent";
+import {
+	truncateHead,
+	DEFAULT_MAX_BYTES,
+	DEFAULT_MAX_LINES,
+	formatSize,
+} from "@gsd/pi-coding-agent";
+import { Text } from "@gsd/pi-tui";
+import { Type } from "@sinclair/typebox";
+import { Client } from "@modelcontextprotocol/sdk/client";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { readFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+
+// ─── Types ────────────────────────────────────────────────────────────────────
+
+interface McpServerConfig {
+	name: string;
+	transport: "stdio" | "http" | "unknown";
+	command?: string;
+	args?: string[];
+	env?: Record<string, string>;
+	url?: string;
+	cwd?: string;
+}
+
+interface McpToolSchema {
+	name: string;
+	description: string;
+	inputSchema?: Record<string, unknown>;
+}
+
+interface ManagedConnection {
+	client: Client;
+	transport: StdioClientTransport | StreamableHTTPClientTransport;
+}
+
+// ─── Connection Manager ───────────────────────────────────────────────────────
+
+const connections = new Map<string, ManagedConnection>();
+let configCache: McpServerConfig[] | null = null;
+const toolCache = new Map<string, McpToolSchema[]>();
+
+function readConfigs(): McpServerConfig[] {
+	if (configCache) return configCache;
+
+	const servers: McpServerConfig[] = [];
+	const seen = new Set<string>();
+	const configPaths = [
+		join(process.cwd(), ".mcp.json"),
+		join(process.cwd(), ".gsd", "mcp.json"),
+	];
+
+	for (const configPath of configPaths) {
+		try {
+			if (!existsSync(configPath)) continue;
+			const raw = readFileSync(configPath, "utf-8");
+			const data = JSON.parse(raw) as Record<string, unknown>;
+			const mcpServers = (data.mcpServers ?? data.servers) as
+				| Record<string, Record<string, unknown>>
+				| undefined;
+			if (!mcpServers || typeof mcpServers !== "object") continue;
+
+			for (const [name, config] of Object.entries(mcpServers)) {
+				if (seen.has(name)) continue;
+				seen.add(name);
+
+				const hasCommand = typeof config.command === "string";
+				const hasUrl = typeof config.url === "string";
+				const transport: McpServerConfig["transport"] = hasCommand
+					? "stdio"
+					: hasUrl
+						? "http"
+						: "unknown";
+
+				servers.push({
+					name,
+					transport,
+					...(hasCommand && {
+						command: config.command as string,
+						args: Array.isArray(config.args) ? (config.args as string[]) : undefined,
+						env: config.env && typeof config.env === "object"
+							? (config.env as Record<string, string>)
+							: undefined,
+						cwd: typeof config.cwd === "string" ? config.cwd : undefined,
+					}),
+					...(hasUrl && { url: config.url as string }),
+				});
+			}
+		} catch {
+			// Non-fatal — config file may not exist or be malformed
+		}
+	}
+
+	configCache = servers;
+	return servers;
+}
+
+function getServerConfig(name: string): McpServerConfig | undefined {
+	return readConfigs().find((s) => s.name === name);
+}
+
+async function getOrConnect(name: string, signal?: AbortSignal): Promise<Client> {
+	const existing = connections.get(name);
+	if (existing) return existing.client;
+
+	const config = getServerConfig(name);
+	if (!config) throw new Error(`Unknown MCP server: "${name}". Use mcp_servers to list available servers.`);
+
+	const client = new Client({ name: "gsd", version: "1.0.0" });
+	let transport: StdioClientTransport | StreamableHTTPClientTransport;
+
+	if (config.transport === "stdio" && config.command) {
+		transport = new StdioClientTransport({
+			command: config.command,
+			args: config.args,
+			env: config.env ? { ...process.env, ...config.env } as Record<string, string> : undefined,
+			cwd: config.cwd,
+			stderr: "pipe",
+		});
+	} else if (config.transport === "http" && config.url) {
+		transport = new StreamableHTTPClientTransport(new URL(config.url));
+	} else {
+		throw new Error(`Server "${name}" has unsupported transport: ${config.transport}`);
+	}
+
+	await client.connect(transport, { signal, timeout: 30000 });
+	connections.set(name, { client, transport });
+	return client;
+}
+
+async function closeAll(): Promise<void> {
+	const closing = Array.from(connections.entries()).map(async ([name, conn]) => {
+		try {
+			await conn.client.close();
+		} catch {
+			// Best-effort cleanup
+		}
+		connections.delete(name);
+	});
+	await Promise.allSettled(closing);
+	toolCache.clear();
+}
+
+// ─── Formatters ───────────────────────────────────────────────────────────────
+
+function formatServerList(servers: McpServerConfig[]): string {
+	if (servers.length === 0) return "No MCP servers configured. Add servers to .mcp.json or .gsd/mcp.json.";
+
+	const lines: string[] = [`${servers.length} MCP servers configured:\n`];
+
+	for (const s of servers) {
+		const connected = connections.has(s.name) ? "✓" : "○";
+		const cached = toolCache.get(s.name);
+		const toolCount = cached ? ` — ${cached.length} tools` : "";
+		lines.push(`${connected} ${s.name} (${s.transport})${toolCount}`);
+	}
+
+	lines.push("\nUse mcp_discover to see full tool schemas for a specific server.");
+	lines.push("Use mcp_call to invoke a tool: mcp_call(server, tool, args).");
+	return lines.join("\n");
+}
+
+function formatToolList(serverName: string, tools: McpToolSchema[]): string {
+	const lines: string[] = [`${serverName} — ${tools.length} tools:\n`];
+
+	for (const tool of tools) {
+		lines.push(`## ${tool.name}`);
+		if (tool.description) lines.push(tool.description);
+		if (tool.inputSchema) {
+			lines.push("```json");
+			lines.push(JSON.stringify(tool.inputSchema, null, 2));
+			lines.push("```");
+		}
+		lines.push("");
+	}
+
+	lines.push(`Call with: mcp_call(server="${serverName}", tool="<tool_name>", args={...})`);
+	return lines.join("\n");
+}
+
+// ─── Extension ────────────────────────────────────────────────────────────────
+
+export default function (pi: ExtensionAPI) {
+	// ── mcp_servers ──────────────────────────────────────────────────────────
+
+	pi.registerTool({
+		name: "mcp_servers",
+		label: "MCP Servers",
+		description:
+			"List all available MCP servers configured in project files (.mcp.json, .gsd/mcp.json). " +
+			"Shows server names, transport type, and connection status. Use mcp_discover to get full tool schemas for a server.",
+		promptSnippet:
+			"List available MCP servers from project configuration",
+		promptGuidelines: [
+			"Call mcp_servers to see what MCP servers are available before trying to use one.",
+			"MCP servers provide external integrations (Twitter, Linear, Railway, etc.) via the Model Context Protocol.",
+			"After listing, use mcp_discover(server) to get tool schemas, then mcp_call(server, tool, args) to invoke.",
+		],
+		parameters: Type.Object({
+			refresh: Type.Optional(
+				Type.Boolean({ description: "Force refresh the server list (default: use cache)" }),
+			),
+		}),
+
+		async execute(_id, params) {
+			if (params.refresh) configCache = null;
+
+			const servers = readConfigs();
+			return {
+				content: [{ type: "text", text: formatServerList(servers) }],
+				details: {
+					serverCount: servers.length,
+					cached: !params.refresh && configCache !== null,
+				},
+			};
+		},
+
+		renderCall(args, theme) {
+			let text = theme.fg("toolTitle", theme.bold("mcp_servers"));
+			if (args.refresh) text += theme.fg("warning", " (refresh)");
+			return new Text(text, 0, 0);
+		},
+
+		renderResult(result, { isPartial }, theme) {
+			if (isPartial) return new Text(theme.fg("warning", "Reading MCP config..."), 0, 0);
+			const d = result.details as { serverCount: number } | undefined;
+			return new Text(
+				theme.fg("success", `${d?.serverCount ?? 0} servers configured`),
+				0,
+				0,
+			);
+		},
+	});
+
+	// ── mcp_discover ─────────────────────────────────────────────────────────
+
+	pi.registerTool({
+		name: "mcp_discover",
+		label: "MCP Discover",
+		description:
+			"Get detailed tool signatures and JSON schemas for a specific MCP server. " +
+			"Connects to the server on first call (lazy connection). " +
+			"Use this to understand what tools a server provides and what arguments they accept " +
+			"before calling them with mcp_call.",
+		promptSnippet:
+			"Get tool schemas for a specific MCP server before calling its tools",
+		promptGuidelines: [
+			"Call mcp_discover with a server name to see the full tool signatures before calling mcp_call.",
+			"The schemas show required and optional parameters with types and descriptions.",
+		],
+		parameters: Type.Object({
+			server: Type.String({
+				description:
+					"MCP server name (from mcp_servers output), e.g. 'railway', 'twitter-mcp', 'linear'",
+			}),
+		}),
+
+		async execute(_id, params, signal) {
+			try {
+				// Return cached tools if available
+				const cached = toolCache.get(params.server);
+				if (cached) {
+					const text = formatToolList(params.server, cached);
+					const truncation = truncateHead(text, { maxLines: DEFAULT_MAX_LINES, maxBytes: DEFAULT_MAX_BYTES });
+					let finalText = truncation.content;
+					if (truncation.truncated) {
+						finalText += `\n\n[Truncated: ${truncation.outputLines}/${truncation.totalLines} lines (${formatSize(truncation.outputBytes)} of ${formatSize(truncation.totalBytes)})]`;
+					}
+					return {
+						content: [{ type: "text", text: finalText }],
+						details: { server: params.server, toolCount: cached.length, cached: true },
+					};
+				}
+
+				const client = await getOrConnect(params.server, signal);
+				const result = await client.listTools(undefined, { signal, timeout: 30000 });
+				const tools: McpToolSchema[] = (result.tools ?? []).map((t) => ({
+					name: t.name,
+					description: t.description ?? "",
+					inputSchema: t.inputSchema as Record<string, unknown> | undefined,
+				}));
+				toolCache.set(params.server, tools);
+
+				const text = formatToolList(params.server, tools);
+				const truncation = truncateHead(text, { maxLines: DEFAULT_MAX_LINES, maxBytes: DEFAULT_MAX_BYTES });
+				let finalText = truncation.content;
+				if (truncation.truncated) {
+					finalText += `\n\n[Truncated: ${truncation.outputLines}/${truncation.totalLines} lines (${formatSize(truncation.outputBytes)} of ${formatSize(truncation.totalBytes)})]`;
+				}
+
+				return {
+					content: [{ type: "text", text: finalText }],
+					details: { server: params.server, toolCount: tools.length, cached: false },
+				};
+			} catch (err: unknown) {
+				const msg = err instanceof Error ? err.message : String(err);
+				throw new Error(`Failed to discover tools for "${params.server}": ${msg}`);
+			}
+		},
+
+		renderCall(args, theme) {
+			let text = theme.fg("toolTitle", theme.bold("mcp_discover "));
+			text += theme.fg("accent", args.server);
+			return new Text(text, 0, 0);
+		},
+
+		renderResult(result, { isPartial }, theme) {
+			if (isPartial)
+				return new Text(theme.fg("warning", "Discovering tools..."), 0, 0);
+			const d = result.details as { server: string; toolCount: number } | undefined;
+			return new Text(
+				theme.fg("success", `${d?.toolCount ?? 0} tools`) +
+					theme.fg("dim", ` · ${d?.server}`),
+				0,
+				0,
+			);
+		},
+	});
+
+	// ── mcp_call ─────────────────────────────────────────────────────────────
+
+	pi.registerTool({
+		name: "mcp_call",
+		label: "MCP Call",
+		description:
+			"Call a tool on an MCP server. Provide the server name, tool name, and arguments. " +
+			"Connects to the server on first call (lazy connection). " +
+			"Use mcp_discover first to see available tools and their required arguments.",
+		promptSnippet: "Call a tool on an MCP server",
+		promptGuidelines: [
+			"Always use mcp_discover first to understand the tool's parameters before calling mcp_call.",
+			"Arguments are passed as a JSON object matching the tool's input schema.",
+		],
+		parameters: Type.Object({
+			server: Type.String({
+				description: "MCP server name, e.g. 'railway', 'twitter-mcp'",
+			}),
+			tool: Type.String({
+				description: "Tool name on that server, e.g. 'railway_list_projects'",
+			}),
+			args: Type.Optional(
+				Type.Record(Type.String(), Type.Unknown(), {
+					description:
+						"Tool arguments as key-value pairs matching the tool's input schema",
+				}),
+			),
+		}),
+
+		async execute(_id, params, signal) {
+			try {
+				const client = await getOrConnect(params.server, signal);
+				const result = await client.callTool(
+					{ name: params.tool, arguments: params.args ?? {} },
+					undefined,
+					{ signal, timeout: 60000 },
+				);
+
+				// Serialize result content to text
+				const contentItems = result.content as Array<{ type: string; text?: string }>;
+				const raw = contentItems
+					.map((c) => (c.type === "text" ? c.text ?? "" : JSON.stringify(c)))
+					.join("\n");
+
+				const truncation = truncateHead(raw, { maxLines: DEFAULT_MAX_LINES, maxBytes: DEFAULT_MAX_BYTES });
+				let finalText = truncation.content;
+				if (truncation.truncated) {
+					finalText += `\n\n[Output truncated: ${truncation.outputLines}/${truncation.totalLines} lines (${formatSize(truncation.outputBytes)} of ${formatSize(truncation.totalBytes)})]`;
+				}
+
+				return {
+					content: [{ type: "text", text: finalText }],
+					details: {
+						server: params.server,
+						tool: params.tool,
+						charCount: finalText.length,
+						truncated: truncation.truncated,
+					},
+				};
+			} catch (err: unknown) {
+				const msg = err instanceof Error ? err.message : String(err);
+				throw new Error(`MCP call failed: ${params.server}.${params.tool}\n${msg}`);
+			}
+		},
+
+		renderCall(args, theme) {
+			let text = theme.fg("toolTitle", theme.bold("mcp_call "));
+			text += theme.fg("accent", `${args.server}.${args.tool}`);
+			if (args.args && Object.keys(args.args).length > 0) {
+				const preview = Object.entries(args.args)
+					.slice(0, 3)
+					.map(([k, v]) => {
+						const val = typeof v === "string" ? v : JSON.stringify(v);
+						return `${k}:${val.length > 30 ? val.slice(0, 30) + "…" : val}`;
+					})
+					.join(" ");
+				text += " " + theme.fg("muted", preview);
+			}
+			return new Text(text, 0, 0);
+		},
+
+		renderResult(result, { isPartial, expanded }, theme) {
+			if (isPartial) return new Text(theme.fg("warning", "Calling MCP tool..."), 0, 0);
+
+			const d = result.details as {
+				server: string;
+				tool: string;
+				charCount: number;
+				truncated: boolean;
+			} | undefined;
+
+			let text = theme.fg("success", `✓ ${d?.server}.${d?.tool}`);
+			text += theme.fg("dim", ` · ${(d?.charCount ?? 0).toLocaleString()} chars`);
+			if (d?.truncated) text += theme.fg("warning", " · truncated");
+
+			if (expanded) {
+				const content = result.content[0];
+				if (content?.type === "text") {
+					const preview = content.text.split("\n").slice(0, 15).join("\n");
+					text += "\n\n" + theme.fg("dim", preview);
+				}
+			}
+
+			return new Text(text, 0, 0);
+		},
+	});
+
+	// ── Lifecycle ─────────────────────────────────────────────────────────────
+
+	pi.on("session_start", async (_event, ctx) => {
+		const servers = readConfigs();
+		if (servers.length > 0) {
+			ctx.ui.notify(`MCP client ready — ${servers.length} server(s) configured`, "info");
+		}
+	});
+
+	pi.on("session_shutdown", async () => {
+		await closeAll();
+	});
+
+	pi.on("session_switch", async () => {
+		await closeAll();
+		configCache = null;
+	});
+}

package/src/resources/skills/create-gsd-extension/SKILL.md

@@ -0,0 +1,87 @@
+---
+name: create-gsd-extension
+description: Create, debug, and iterate on GSD extensions (TypeScript modules that add tools, commands, event hooks, custom UI, and providers to GSD). Use when asked to build an extension, add a tool the LLM can call, register a slash command, hook into GSD events, create custom TUI components, or modify GSD behavior. Triggers on "create extension", "build extension", "add a tool", "register command", "hook into gsd", "custom tool", "gsd plugin", "gsd extension".
+---
+
+<essential_principles>
+
+**Extensions are TypeScript modules** that hook into GSD's runtime (built on pi). They export a default function receiving `ExtensionAPI` and use it to subscribe to events, register tools/commands/shortcuts, and interact with the session.
+
+**GSD extension paths:**
+- Global extensions: `~/.gsd/agent/extensions/*.ts` or `~/.gsd/agent/extensions/*/index.ts`
+- Project-local extensions: `.gsd/extensions/*.ts` or `.gsd/extensions/*/index.ts`
+
+**The three primitives:**
+1. **Events** — Listen and react (`pi.on("event", handler)`). Can block tool calls, modify messages, inject context.
+2. **Tools** — Give the LLM new abilities (`pi.registerTool()`). LLM calls them autonomously.
+3. **Commands** — Give users slash commands (`pi.registerCommand()`). Users type `/mycommand`.
+
+**Non-negotiable rules:**
+- Use `StringEnum` from `@mariozechner/pi-ai` for string enum params (NOT `Type.Union`/`Type.Literal` — breaks Google's API)
+- Truncate tool output to 50KB / 2000 lines max (use `truncateHead`/`truncateTail` from `@mariozechner/pi-coding-agent`)
+- Store stateful tool state in `details` for branching support
+- Check `signal?.aborted` in long-running tool executions
+- Use `pi.exec()` not `child_process` for shell commands
+- Check `ctx.hasUI` before dialog methods (non-interactive modes exist)
+- Session control methods (`waitForIdle`, `newSession`, `fork`, `navigateTree`, `reload`) are ONLY available in command handlers — they deadlock in event handlers
+- Lines from `render()` must not exceed `width` — use `truncateToWidth()`
+- Use theme from callback params, never import directly
+- Strip leading `@` from path params in custom tools (some models add it)
+
+**Available imports:**
+
+| Package | Purpose |
+|---------|---------|
+| `@mariozechner/pi-coding-agent` | `ExtensionAPI`, `ExtensionContext`, `Theme`, event types, tool utilities, `DynamicBorder`, `BorderedLoader`, `CustomEditor`, `highlightCode` |
+| `@sinclair/typebox` | `Type.Object`, `Type.String`, `Type.Number`, `Type.Optional`, `Type.Boolean`, `Type.Array` |
+| `@mariozechner/pi-ai` | `StringEnum` (required for string enums), `Type` re-export |
+| `@mariozechner/pi-tui` | `Text`, `Box`, `Container`, `Spacer`, `Markdown`, `SelectList`, `Input`, `matchesKey`, `Key`, `truncateToWidth`, `visibleWidth` |
+| Node.js built-ins | `node:fs`, `node:path`, `node:child_process`, etc. |
+
+</essential_principles>
+
+<routing>
+Based on user intent, route to the appropriate workflow:
+
+**Building a new extension:**
+- "Create an extension", "build a tool", "I want to add a command" → `workflows/create-extension.md`
+
+**Adding capabilities to an existing extension:**
+- "Add a tool to my extension", "add event hook", "add custom rendering" → `workflows/add-capability.md`
+
+**Debugging an extension:**
+- "My extension doesn't work", "tool not showing up", "event not firing" → `workflows/debug-extension.md`
+
+**If user intent is clear from context, skip the question and go directly to the workflow.**
+</routing>
+
+<reference_index>
+All domain knowledge in `references/`:
+
+**Core architecture:** extension-lifecycle.md, events-reference.md
+**API surface:** extensionapi-reference.md, extensioncontext-reference.md
+**Capabilities:** custom-tools.md, custom-commands.md, custom-ui.md, custom-rendering.md
+**Patterns:** state-management.md, system-prompt-modification.md, compaction-session-control.md
+**Infrastructure:** model-provider-management.md, remote-execution-overrides.md, packaging-distribution.md, mode-behavior.md
+**Gotchas:** key-rules-gotchas.md
+</reference_index>
+
+<workflows_index>
+| Workflow | Purpose |
+|----------|---------|
+| create-extension.md | Build a new extension from scratch |
+| add-capability.md | Add tools, commands, hooks, UI to an existing extension |
+| debug-extension.md | Diagnose and fix extension issues |
+</workflows_index>
+
+<success_criteria>
+Extension is complete when:
+- TypeScript compiles without errors (jiti handles this at runtime)
+- Extension loads on GSD startup or `/reload` without errors
+- Tools appear in the LLM's system prompt and are callable
+- Commands respond to `/command` input
+- Event hooks fire at the expected lifecycle points
+- Custom UI renders correctly within terminal width
+- State persists correctly across session restarts (if stateful)
+- Output is truncated to safe limits (if tools produce variable output)
+</success_criteria>

package/src/resources/skills/create-gsd-extension/references/compaction-session-control.md

@@ -0,0 +1,77 @@
+<overview>
+Custom compaction hooks, triggering compaction, and session control methods available only in command handlers.
+</overview>
+
+<custom_compaction>
+Override default compaction behavior:
+
+```typescript
+pi.on("session_before_compact", async (event, ctx) => {
+  const { preparation, branchEntries, customInstructions, signal } = event;
+
+  // Option 1: Cancel
+  return { cancel: true };
+
+  // Option 2: Custom summary
+  return {
+    compaction: {
+      summary: "Custom summary of conversation so far...",
+      firstKeptEntryId: preparation.firstKeptEntryId,
+      tokensBefore: preparation.tokensBefore,
+    }
+  };
+});
+```
+</custom_compaction>
+
+<trigger_compaction>
+Trigger compaction programmatically from any handler:
+
+```typescript
+ctx.compact({
+  customInstructions: "Focus on the authentication changes",
+  onComplete: (result) => ctx.ui.notify("Compacted!", "info"),
+  onError: (error) => ctx.ui.notify(`Failed: ${error.message}`, "error"),
+});
+```
+</trigger_compaction>
+
+<session_control>
+**Only available in command handlers** (deadlocks in event handlers):
+
+```typescript
+pi.registerCommand("handoff", {
+  handler: async (args, ctx) => {
+    await ctx.waitForIdle();
+
+    // Create new session with initial context
+    const result = await ctx.newSession({
+      parentSession: ctx.sessionManager.getSessionFile(),
+      setup: async (sm) => {
+        sm.appendMessage({
+          role: "user",
+          content: [{ type: "text", text: `Context: ${args}` }],
+          timestamp: Date.now(),
+        });
+      },
+    });
+
+    if (result.cancelled) { /* extension cancelled via session_before_switch */ }
+  },
+});
+```
+
+| Method | Purpose |
+|--------|---------|
+| `ctx.waitForIdle()` | Wait for agent to finish streaming |
+| `ctx.newSession(options?)` | Create a new session |
+| `ctx.fork(entryId)` | Fork from a specific entry |
+| `ctx.navigateTree(targetId, options?)` | Navigate session tree (with optional summary) |
+| `ctx.reload()` | Hot-reload everything (treat as terminal — code after runs pre-reload version) |
+
+`navigateTree` options:
+- `summarize: boolean` — generate summary of abandoned branch
+- `customInstructions: string` — instructions for summarizer
+- `replaceInstructions: boolean` — replace default prompt entirely
+- `label: string` — label to attach to branch summary
+</session_control>