gsd-pi 2.28.0-dev.e19bf89 → 2.29.0-dev.2ccf3fb

package/src/resources/extensions/gsd/workflow-templates.ts

@@ -0,0 +1,241 @@
+/**
+ * GSD Workflow Templates — Registry & Resolution
+ *
+ * Loads the workflow template registry and resolves templates by name,
+ * alias, or trigger-keyword matching against user input.
+ */
+
+import { readFileSync, existsSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __extensionDir = dirname(fileURLToPath(import.meta.url));
+const registryPath = join(__extensionDir, "workflow-templates", "registry.json");
+
+// ─── Types ───────────────────────────────────────────────────────────────────
+
+export interface TemplateEntry {
+  name: string;
+  description: string;
+  file: string;
+  phases: string[];
+  triggers: string[];
+  artifact_dir: string | null;
+  estimated_complexity: string;
+  requires_project: boolean;
+}
+
+export interface TemplateRegistry {
+  version: number;
+  templates: Record<string, TemplateEntry>;
+}
+
+export interface TemplateMatch {
+  id: string;
+  template: TemplateEntry;
+  confidence: "exact" | "high" | "medium" | "low";
+  matchedTrigger?: string;
+}
+
+// ─── Registry Cache ──────────────────────────────────────────────────────────
+
+let cachedRegistry: TemplateRegistry | null = null;
+
+/**
+ * Load and cache the workflow template registry.
+ */
+export function loadRegistry(): TemplateRegistry {
+  if (cachedRegistry) return cachedRegistry;
+
+  const content = readFileSync(registryPath, "utf-8");
+  cachedRegistry = JSON.parse(content) as TemplateRegistry;
+  return cachedRegistry;
+}
+
+/**
+ * Resolve a template by exact name or alias.
+ * Returns null if no match found.
+ */
+export function resolveByName(nameOrAlias: string): TemplateMatch | null {
+  const registry = loadRegistry();
+  const normalized = nameOrAlias.toLowerCase().trim();
+
+  // Exact key match
+  if (registry.templates[normalized]) {
+    return {
+      id: normalized,
+      template: registry.templates[normalized],
+      confidence: "exact",
+    };
+  }
+
+  // Match by template name (case-insensitive)
+  for (const [id, entry] of Object.entries(registry.templates)) {
+    if (entry.name.toLowerCase() === normalized) {
+      return { id, template: entry, confidence: "exact" };
+    }
+  }
+
+  // Fuzzy: prefix match on id
+  for (const [id, entry] of Object.entries(registry.templates)) {
+    if (id.startsWith(normalized) || normalized.startsWith(id)) {
+      return { id, template: entry, confidence: "high" };
+    }
+  }
+
+  // Common aliases
+  const aliases: Record<string, string> = {
+    "bug": "bugfix",
+    "fix": "bugfix",
+    "feature": "small-feature",
+    "feat": "small-feature",
+    "research": "spike",
+    "investigate": "spike",
+    "hot": "hotfix",
+    "urgent": "hotfix",
+    "security": "security-audit",
+    "audit": "security-audit",
+    "upgrade": "dep-upgrade",
+    "deps": "dep-upgrade",
+    "update-deps": "dep-upgrade",
+    "migration": "refactor",
+    "project": "full-project",
+    "full": "full-project",
+  };
+
+  const aliasMatch = aliases[normalized];
+  if (aliasMatch && registry.templates[aliasMatch]) {
+    return {
+      id: aliasMatch,
+      template: registry.templates[aliasMatch],
+      confidence: "high",
+    };
+  }
+
+  return null;
+}
+
+/**
+ * Auto-detect the best template based on user description text.
+ * Returns ranked matches sorted by confidence.
+ */
+export function autoDetect(description: string): TemplateMatch[] {
+  const registry = loadRegistry();
+  const lower = description.toLowerCase();
+  const words = lower.split(/\s+/);
+  const matches: TemplateMatch[] = [];
+
+  for (const [id, entry] of Object.entries(registry.templates)) {
+    let bestScore = 0;
+    let bestTrigger = "";
+
+    for (const trigger of entry.triggers) {
+      const triggerLower = trigger.toLowerCase();
+
+      // Exact phrase match in description
+      if (lower.includes(triggerLower)) {
+        const score = triggerLower.split(/\s+/).length * 2; // multi-word triggers score higher
+        if (score > bestScore) {
+          bestScore = score;
+          bestTrigger = trigger;
+        }
+        continue;
+      }
+
+      // Single-word trigger match against description words
+      if (!triggerLower.includes(" ") && words.includes(triggerLower)) {
+        if (1 > bestScore) {
+          bestScore = 1;
+          bestTrigger = trigger;
+        }
+      }
+    }
+
+    if (bestScore > 0) {
+      const confidence = bestScore >= 4 ? "high" : bestScore >= 2 ? "medium" : "low";
+      matches.push({
+        id,
+        template: entry,
+        confidence,
+        matchedTrigger: bestTrigger,
+      });
+    }
+  }
+
+  // Sort by confidence (high > medium > low), then alphabetically
+  const order = { exact: 0, high: 1, medium: 2, low: 3 };
+  matches.sort((a, b) => order[a.confidence] - order[b.confidence] || a.id.localeCompare(b.id));
+
+  return matches;
+}
+
+/**
+ * List all templates as formatted text for display.
+ */
+export function listTemplates(): string {
+  const registry = loadRegistry();
+  const lines: string[] = ["Workflow Templates\n"];
+
+  for (const [id, entry] of Object.entries(registry.templates)) {
+    const phases = entry.phases.join(" → ");
+    const complexity = entry.estimated_complexity;
+    lines.push(`  ${id.padEnd(16)} ${entry.name}`);
+    lines.push(`  ${"".padEnd(16)} ${entry.description}`);
+    lines.push(`  ${"".padEnd(16)} Phases: ${phases}  |  Complexity: ${complexity}`);
+    lines.push("");
+  }
+
+  lines.push("Usage: /gsd start <template> [description]");
+  lines.push("       /gsd templates info <name>");
+
+  return lines.join("\n");
+}
+
+/**
+ * Get detailed info about a specific template.
+ */
+export function getTemplateInfo(name: string): string | null {
+  const match = resolveByName(name);
+  if (!match) return null;
+
+  const { id, template: t } = match;
+  const lines = [
+    `Template: ${t.name} (${id})`,
+    "",
+    `Description: ${t.description}`,
+    `Complexity:  ${t.estimated_complexity}`,
+    `Requires .gsd/: ${t.requires_project ? "yes" : "no"}`,
+    "",
+    "Phases:",
+    ...t.phases.map((p, i) => `  ${i + 1}. ${p}`),
+    "",
+    "Triggers:",
+    `  ${t.triggers.join(", ")}`,
+  ];
+
+  if (t.artifact_dir) {
+    lines.push("", `Artifacts: ${t.artifact_dir}`);
+  }
+
+  const templateFilePath = join(__extensionDir, "workflow-templates", t.file);
+  if (existsSync(templateFilePath)) {
+    lines.push("", "Template file: loaded");
+  } else {
+    lines.push("", "Template file: not yet created");
+  }
+
+  return lines.join("\n");
+}
+
+/**
+ * Load the raw content of a workflow template .md file.
+ */
+export function loadWorkflowTemplate(templateId: string): string | null {
+  const match = resolveByName(templateId);
+  if (!match) return null;
+
+  const filePath = join(__extensionDir, "workflow-templates", match.template.file);
+  if (!existsSync(filePath)) return null;
+
+  return readFileSync(filePath, "utf-8");
+}

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;
+	});
+}