gsd-pi 2.8.3 → 2.10.0

package/src/resources/extensions/search-the-web/tool-search.ts

@@ -16,12 +16,12 @@ import { Text } from "@gsd/pi-tui";
 import { Type } from "@sinclair/typebox";
 import { StringEnum } from "@gsd/pi-ai";
 
-import { LRUTTLCache } from "./cache";
-import { fetchWithRetryTimed, fetchWithRetry, classifyError, type RateLimitInfo } from "./http";
-import { normalizeQuery, toDedupeKey, detectFreshness } from "./url-utils";
-import { formatSearchResults, type SearchResultFormatted, type FormatSearchOptions } from "./format";
-import { getTavilyApiKey, resolveSearchProvider } from "./provider";
-import { normalizeTavilyResult, mapFreshnessToTavily, type TavilySearchResponse } from "./tavily";
+import { LRUTTLCache } from "./cache.js";
+import { fetchWithRetryTimed, fetchWithRetry, classifyError, type RateLimitInfo } from "./http.js";
+import { normalizeQuery, toDedupeKey, detectFreshness } from "./url-utils.js";
+import { formatSearchResults, type SearchResultFormatted, type FormatSearchOptions } from "./format.js";
+import { getTavilyApiKey, resolveSearchProvider } from "./provider.js";
+import { normalizeTavilyResult, mapFreshnessToTavily, type TavilySearchResponse } from "./tavily.js";
 
 // =============================================================================
 // Types
@@ -291,7 +291,7 @@ export function registerSearchTool(pi: ExtensionAPI) {
 
     async execute(toolCallId, params, signal, onUpdate, ctx) {
       if (signal?.aborted) {
-        return { content: [{ type: "text", text: "Search cancelled." }] };
+        return { content: [{ type: "text", text: "Search cancelled." }], details: undefined as unknown };
       }
 
       // ------------------------------------------------------------------
@@ -365,7 +365,7 @@ export function registerSearchTool(pi: ExtensionAPI) {
         const truncation = truncateHead(output, { maxLines: DEFAULT_MAX_LINES, maxBytes: DEFAULT_MAX_BYTES });
         let content = truncation.content;
         if (truncation.truncated) {
-          const tempFile = await pi.writeTempFile(output, { prefix: "web-search-" });
+          const tempFile = await (pi as any).writeTempFile(output, { prefix: "web-search-" });
           content += `\n\n[Truncated: ${truncation.outputLines}/${truncation.totalLines} lines (${formatSize(truncation.outputBytes)}/${formatSize(truncation.totalBytes)}). Full results: ${tempFile}]`;
         }
 
@@ -387,7 +387,7 @@ export function registerSearchTool(pi: ExtensionAPI) {
         return { content: [{ type: "text", text: content }], details };
       }
 
-      onUpdate?.({ content: [{ type: "text", text: `Searching for "${params.query}"...` }] });
+      onUpdate?.({ content: [{ type: "text", text: `Searching for "${params.query}"...` }], details: undefined as unknown });
 
       try {
         // ------------------------------------------------------------------
@@ -484,7 +484,7 @@ export function registerSearchTool(pi: ExtensionAPI) {
         let content = truncation.content;
 
         if (truncation.truncated) {
-          const tempFile = await pi.writeTempFile(output, { prefix: "web-search-" });
+          const tempFile = await (pi as any).writeTempFile(output, { prefix: "web-search-" });
           content += `\n\n[Truncated: ${truncation.outputLines}/${truncation.totalLines} lines (${formatSize(truncation.outputBytes)}/${formatSize(truncation.totalBytes)}). Full results: ${tempFile}]`;
         }
 

package/src/resources/extensions/shared/interview-ui.ts

@@ -105,7 +105,7 @@ export interface WrapUpOptions {
 // ─── Constants ────────────────────────────────────────────────────────────────
 
 const OTHER_OPTION_LABEL = "None of the above";
-const OTHER_OPTION_DESCRIPTION = "Optionally, add details in notes below.";
+const OTHER_OPTION_DESCRIPTION = "Press TAB to add optional notes.";
 
 // ─── Wrap-up screen ───────────────────────────────────────────────────────────
 
@@ -593,7 +593,7 @@ export async function showInterviewRound(
 				hints.push("tab to add notes");
 				hints.push(isLast && allAnswered() ? "enter to review" : "enter to next");
 			} else {
-				if (st.committedIndex !== null || !isMultiQuestion) hints.push("tab to add notes");
+				hints.push("tab to add notes");
 				if (isMultiQuestion) hints.push("←/→ navigate");
 				hints.push(isLast && allAnswered() ? "enter to review" : "enter to next");
 			}

package/src/resources/extensions/universal-config/discovery.ts

@@ -0,0 +1,78 @@
+/**
+ * Universal Config Discovery — main discovery orchestrator
+ *
+ * Runs all tool scanners in parallel and aggregates results into a
+ * unified DiscoveryResult.
+ */
+
+import { homedir } from "node:os";
+import { TOOLS } from "./tools.js";
+import { SCANNERS } from "./scanners.js";
+import type { DiscoveryResult, DiscoveredItem, ToolDiscoveryResult } from "./types.js";
+
+/**
+ * Run universal config discovery across all supported AI coding tools.
+ *
+ * @param projectRoot - Absolute path to the project root (cwd)
+ * @param home - Home directory override (defaults to os.homedir())
+ * @returns Aggregated discovery result
+ */
+export async function discoverAllConfigs(
+  projectRoot: string,
+  home: string = homedir(),
+): Promise<DiscoveryResult> {
+  const start = Date.now();
+  const allWarnings: string[] = [];
+  const toolResults: ToolDiscoveryResult[] = [];
+
+  // Run all scanners in parallel
+  const results = await Promise.allSettled(
+    TOOLS.map(async (tool) => {
+      const scanner = SCANNERS[tool.id];
+      if (!scanner) return { tool, items: [] as DiscoveredItem[], warnings: [`No scanner for ${tool.id}`] };
+      try {
+        const { items, warnings } = await scanner(projectRoot, home, tool);
+        return { tool, items, warnings };
+      } catch (err) {
+        return {
+          tool,
+          items: [] as DiscoveredItem[],
+          warnings: [`Scanner error for ${tool.name}: ${err instanceof Error ? err.message : String(err)}`],
+        };
+      }
+    }),
+  );
+
+  for (const result of results) {
+    if (result.status === "fulfilled") {
+      toolResults.push(result.value);
+      allWarnings.push(...result.value.warnings);
+    } else {
+      allWarnings.push(`Scanner failed: ${result.reason}`);
+    }
+  }
+
+  const allItems = toolResults.flatMap((r) => r.items);
+
+  const mcpServers = allItems.filter((i) => i.type === "mcp-server").length;
+  const rules = allItems.filter((i) => i.type === "rule").length;
+  const contextFiles = allItems.filter((i) => i.type === "context-file").length;
+  const settings = allItems.filter((i) => i.type === "settings").length;
+  const toolsWithConfig = toolResults.filter((r) => r.items.length > 0).length;
+
+  return {
+    tools: toolResults,
+    allItems,
+    summary: {
+      mcpServers,
+      rules,
+      contextFiles,
+      settings,
+      totalItems: allItems.length,
+      toolsScanned: TOOLS.length,
+      toolsWithConfig,
+    },
+    warnings: allWarnings,
+    durationMs: Date.now() - start,
+  };
+}

package/src/resources/extensions/universal-config/format.ts

@@ -0,0 +1,160 @@
+/**
+ * Universal Config Discovery — output formatting
+ *
+ * Formats DiscoveryResult into human-readable and LLM-readable output.
+ */
+
+import type { DiscoveryResult, DiscoveredItem, ToolDiscoveryResult } from "./types.js";
+
+/**
+ * Format discovery result as a compact text report for the LLM tool response.
+ */
+export function formatDiscoveryForTool(result: DiscoveryResult): string {
+  const lines: string[] = [];
+  const { summary } = result;
+
+  lines.push(`Universal Config Discovery — ${summary.toolsWithConfig}/${summary.toolsScanned} tools with config (${result.durationMs}ms)`);
+  lines.push("");
+
+  if (summary.totalItems === 0) {
+    lines.push("No configuration found from any AI coding tool.");
+    lines.push("");
+    lines.push("Scanned for: Claude Code, Cursor, Windsurf, Gemini CLI, Codex, Cline, GitHub Copilot, VS Code");
+    return lines.join("\n");
+  }
+
+  lines.push(`Found: ${summary.mcpServers} MCP server(s), ${summary.rules} rule(s), ${summary.contextFiles} context file(s), ${summary.settings} settings file(s)`);
+  lines.push("");
+
+  for (const toolResult of result.tools) {
+    if (toolResult.items.length === 0) continue;
+    lines.push(`## ${toolResult.tool.name}`);
+
+    const byType = groupByType(toolResult.items);
+
+    if (byType["mcp-server"]?.length) {
+      lines.push(`  MCP Servers (${byType["mcp-server"].length}):`);
+      for (const item of byType["mcp-server"]) {
+        if (item.type !== "mcp-server") continue;
+        const transport = item.transport ?? (item.url ? "http" : item.command ? "stdio" : "unknown");
+        const detail = item.command
+          ? `${item.command}${item.args?.length ? ` ${item.args.join(" ")}` : ""}`
+          : item.url ?? "no endpoint";
+        lines.push(`    - ${item.name} [${transport}] ${detail} (${item.source.level})`);
+      }
+    }
+
+    if (byType.rule?.length) {
+      lines.push(`  Rules (${byType.rule.length}):`);
+      for (const item of byType.rule) {
+        if (item.type !== "rule") continue;
+        const meta: string[] = [];
+        if (item.alwaysApply) meta.push("always");
+        if (item.globs?.length) meta.push(`globs: ${item.globs.join(", ")}`);
+        const suffix = meta.length ? ` [${meta.join(", ")}]` : "";
+        const preview = item.content.slice(0, 80).replace(/\n/g, " ").trim();
+        lines.push(`    - ${item.name}${suffix}: ${preview}${item.content.length > 80 ? "..." : ""}`);
+      }
+    }
+
+    if (byType["context-file"]?.length) {
+      lines.push(`  Context Files (${byType["context-file"].length}):`);
+      for (const item of byType["context-file"]) {
+        if (item.type !== "context-file") continue;
+        const size = item.content.length;
+        lines.push(`    - ${item.name} (${size} chars, ${item.source.level}) ${item.source.path}`);
+      }
+    }
+
+    if (byType.settings?.length) {
+      lines.push(`  Settings (${byType.settings.length}):`);
+      for (const item of byType.settings) {
+        if (item.type !== "settings") continue;
+        const keys = Object.keys(item.data).slice(0, 5);
+        const suffix = Object.keys(item.data).length > 5 ? ` +${Object.keys(item.data).length - 5} more` : "";
+        lines.push(`    - ${item.source.path} (${item.source.level}): keys: ${keys.join(", ")}${suffix}`);
+      }
+    }
+
+    lines.push("");
+  }
+
+  if (result.warnings.length > 0) {
+    lines.push("Warnings:");
+    for (const w of result.warnings) {
+      lines.push(`  - ${w}`);
+    }
+    lines.push("");
+  }
+
+  return lines.join("\n");
+}
+
+/**
+ * Format discovery result as a structured summary for /configs command output.
+ */
+export function formatDiscoveryForCommand(result: DiscoveryResult): string[] {
+  const lines: string[] = [];
+  const { summary } = result;
+
+  lines.push(`--- Universal Config Discovery ---`);
+  lines.push(`${summary.toolsWithConfig} of ${summary.toolsScanned} tools have configuration`);
+  lines.push(`${summary.totalItems} total items discovered in ${result.durationMs}ms`);
+  lines.push("");
+
+  if (summary.totalItems === 0) {
+    lines.push("No configuration found.");
+    return lines;
+  }
+
+  lines.push(`  MCP Servers: ${summary.mcpServers}`);
+  lines.push(`  Rules:       ${summary.rules}`);
+  lines.push(`  Context:     ${summary.contextFiles}`);
+  lines.push(`  Settings:    ${summary.settings}`);
+  lines.push("");
+
+  for (const toolResult of result.tools) {
+    if (toolResult.items.length === 0) continue;
+
+    const counts = countByType(toolResult.items);
+    const parts: string[] = [];
+    if (counts["mcp-server"]) parts.push(`${counts["mcp-server"]} MCP`);
+    if (counts.rule) parts.push(`${counts.rule} rules`);
+    if (counts["context-file"]) parts.push(`${counts["context-file"]} context`);
+    if (counts.settings) parts.push(`${counts.settings} settings`);
+
+    lines.push(`  ${toolResult.tool.name}: ${parts.join(", ")}`);
+
+    // Show MCP server names
+    const servers = toolResult.items.filter((i) => i.type === "mcp-server");
+    for (const server of servers) {
+      if (server.type !== "mcp-server") continue;
+      lines.push(`    MCP: ${server.name} (${server.source.level})`);
+    }
+  }
+
+  if (result.warnings.length > 0) {
+    lines.push("");
+    lines.push(`${result.warnings.length} warning(s) — run discover_configs tool for details`);
+  }
+
+  return lines;
+}
+
+// ── Helpers ───────────────────────────────────────────────────────────────────
+
+function groupByType(items: DiscoveredItem[]): Record<string, DiscoveredItem[]> {
+  const groups: Record<string, DiscoveredItem[]> = {};
+  for (const item of items) {
+    (groups[item.type] ??= []).push(item);
+  }
+  return groups;
+}
+
+function countByType(items: DiscoveredItem[]): Record<string, number> {
+  const counts: Record<string, number> = {};
+  for (const item of items) {
+    counts[item.type] = (counts[item.type] ?? 0) + 1;
+  }
+  return counts;
+}

package/src/resources/extensions/universal-config/index.ts

@@ -0,0 +1,118 @@
+/**
+ * Universal Config Discovery Extension
+ *
+ * Auto-detects and displays configuration from 8 AI coding tools:
+ * Claude Code, Cursor, Windsurf, Gemini CLI, Codex, Cline,
+ * GitHub Copilot, and VS Code.
+ *
+ * Discovers: MCP servers, rules/instructions, context files, and settings.
+ *
+ * Read-only: never modifies other tools' config files.
+ *
+ * Provides:
+ *   - discover_configs tool (LLM-callable)
+ *   - /configs command (slash command)
+ */
+
+import type { ExtensionAPI, ExtensionCommandContext } from "@gsd/pi-coding-agent";
+import { Type } from "@sinclair/typebox";
+import { discoverAllConfigs } from "./discovery.js";
+import { formatDiscoveryForTool, formatDiscoveryForCommand } from "./format.js";
+import type { DiscoveryResult, ToolId } from "./types.js";
+
+// Cache discovery result within a session to avoid re-scanning
+let cachedResult: DiscoveryResult | null = null;
+
+export default function universalConfig(pi: ExtensionAPI) {
+  // ── Tool: discover_configs ──────────────────────────────────────────────
+
+  pi.registerTool({
+    name: "discover_configs",
+    label: "Discover Configs",
+    description:
+      "Scan for existing AI coding tool configurations in this project and the user's home directory. " +
+      "Discovers MCP servers, rules, context files, and settings from Claude Code, Cursor, Windsurf, " +
+      "Gemini CLI, Codex, Cline, GitHub Copilot, and VS Code. Read-only — never modifies config files.",
+    promptSnippet: "Discover existing AI tool configs (MCP servers, rules, context files) from 8 coding tools.",
+    promptGuidelines: [
+      "Use discover_configs when a user asks about their existing configuration, MCP servers, or when switching from another AI coding tool.",
+      "The tool scans both user-level (~/) and project-level (./) config directories.",
+      "Results include MCP servers that could be reused, rules/instructions that could be adapted, and context files from other tools.",
+    ],
+    parameters: Type.Object({
+      tool: Type.Optional(
+        Type.String({
+          description:
+            "Filter to a specific tool: claude, cursor, windsurf, gemini, codex, cline, github-copilot, vscode. Omit to scan all.",
+        }),
+      ),
+      refresh: Type.Optional(
+        Type.Boolean({
+          description: "Force re-scan even if cached results exist. Default: false.",
+        }),
+      ),
+    }),
+
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      if (params.refresh || !cachedResult) {
+        cachedResult = await discoverAllConfigs(ctx.cwd);
+      }
+
+      let result = cachedResult;
+
+      // Filter to specific tool if requested
+      if (params.tool) {
+        const toolId = params.tool as ToolId;
+        const filtered = result.tools.filter((t) => t.tool.id === toolId);
+        if (filtered.length === 0) {
+          return {
+            content: [{ type: "text", text: `No scanner found for tool "${params.tool}". Valid tools: claude, cursor, windsurf, gemini, codex, cline, github-copilot, vscode` }],
+            isError: true,
+            details: undefined as unknown,
+          };
+        }
+        // Rebuild result with filtered tools
+        const allItems = filtered.flatMap((t) => t.items);
+        result = {
+          ...result,
+          tools: filtered,
+          allItems,
+          summary: {
+            ...result.summary,
+            mcpServers: allItems.filter((i) => i.type === "mcp-server").length,
+            rules: allItems.filter((i) => i.type === "rule").length,
+            contextFiles: allItems.filter((i) => i.type === "context-file").length,
+            settings: allItems.filter((i) => i.type === "settings").length,
+            totalItems: allItems.length,
+            toolsWithConfig: filtered.filter((t) => t.items.length > 0).length,
+          },
+        };
+      }
+
+      const text = formatDiscoveryForTool(result);
+      return {
+        content: [{ type: "text", text }],
+        details: undefined as unknown,
+      };
+    },
+  });
+
+  // ── Command: /configs ───────────────────────────────────────────────────
+
+  pi.registerCommand("configs", {
+    description: "Show discovered AI tool configurations (MCP servers, rules, context files)",
+    async handler(_args: string, ctx: ExtensionCommandContext) {
+      // Always refresh on command invocation
+      cachedResult = await discoverAllConfigs(ctx.cwd);
+      const lines = formatDiscoveryForCommand(cachedResult);
+
+      ctx.ui.notify(lines.join("\n"), "info");
+    },
+  });
+
+  // ── Invalidate cache on session switch ──────────────────────────────────
+
+  pi.on("session_switch", () => {
+    cachedResult = null;
+  });
+}

package/src/resources/extensions/universal-config/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "pi-extension-universal-config",
+  "private": true,
+  "version": "1.0.0",
+  "type": "module",
+  "pi": {
+    "extensions": [
+      "./index.ts"
+    ]
+  }
+}