@fitchmultz/pi-mcp-adapter 6.0.0 → 7.0.0

package/scripts/prepare.mjs

@@ -1,103 +0,0 @@
-#!/usr/bin/env node
-/**
- * Purpose: Build generated dist output for GitHub/source installs even when Pi invokes npm install --omit=dev.
- * Responsibilities: Detect missing source-build dependencies via the local node_modules tree, install dev
- * dependencies with lifecycle scripts disabled, run the canonical build, then prune the dev tree so installs
- * keep a runtime-only footprint.
- * Scope: Package install lifecycle only; runtime behavior remains owned by scripts/build.mjs.
- * Usage: package.json prepare script.
- */
-
-import { execFile as execFileCallback } from "node:child_process";
-import { existsSync } from "node:fs";
-import { join } from "node:path";
-import process from "node:process";
-import { promisify } from "node:util";
-
-const execFile = promisify(execFileCallback);
-
-// Checked as literal node_modules paths: require.resolve() is unusable here because
-// several @earendil-works packages expose import-only "exports" maps and throw
-// ERR_PACKAGE_PATH_NOT_EXPORTED even when installed.
-const REQUIRED_SOURCE_BUILD_MODULES = [
-	"esbuild",
-	"typescript",
-	"typebox",
-	"@earendil-works/pi-ai",
-	"@earendil-works/pi-coding-agent",
-	"@earendil-works/pi-tui",
-];
-
-function hasBuildDependencies() {
-	return REQUIRED_SOURCE_BUILD_MODULES.every((moduleName) =>
-		existsSync(join(process.cwd(), "node_modules", ...moduleName.split("/"), "package.json")),
-	);
-}
-
-async function runNpm(args) {
-	const npmExecPath = process.env.npm_execpath;
-	if (!npmExecPath) {
-		throw new Error(
-			`npm_execpath is not set; run "npm ${args.join(" ")}" manually in ${process.cwd()} and retry.`,
-		);
-	}
-	// No shell: process.execPath runs npm's cli.js directly, which is safe for paths
-	// containing spaces on every platform (shell:true concatenates args unescaped).
-	await execFile(process.execPath, [npmExecPath, ...args], {
-		cwd: process.cwd(),
-		maxBuffer: 20 * 1024 * 1024,
-	});
-}
-
-async function runBuild() {
-	const { stderr, stdout } = await execFile(process.execPath, [join(process.cwd(), "scripts", "build.mjs")], {
-		cwd: process.cwd(),
-		maxBuffer: 20 * 1024 * 1024,
-	});
-	// Forward build output on success too: install-time diagnostics such as the
-	// concurrent-swap race-loss warning are otherwise swallowed.
-	if (stdout) process.stdout.write(stdout);
-	if (stderr) process.stderr.write(stderr);
-}
-
-async function pruneDevDependencies() {
-	await runNpm(["prune", "--omit=dev", "--ignore-scripts"]);
-}
-
-async function pruneQuietly() {
-	try {
-		await pruneDevDependencies();
-	} catch (error) {
-		console.warn(`npm prune failed after a failed build: ${error?.message ?? error}`);
-	}
-}
-
-function reportError(error) {
-	if (error?.stdout) process.stdout.write(error.stdout);
-	if (error?.stderr) process.stderr.write(error.stderr);
-	console.error(error instanceof Error ? error.message : String(error));
-}
-
-async function main() {
-	if (hasBuildDependencies()) {
-		await runBuild();
-		return;
-	}
-	await runNpm(["install", "--include=dev", "--ignore-scripts"]);
-	try {
-		await runBuild();
-	} catch (buildError) {
-		// Report the build first; cleanup can warn afterward but never mask it.
-		reportError(buildError);
-		await pruneQuietly();
-		process.exitCode = 1;
-		return;
-	}
-	// A prune failure after a successful build still fails the install.
-	await pruneDevDependencies();
-}
-
-main().catch((error) => {
-	reportError(error);
-	process.exitCode = 1;
-});

package/search-ranking.ts

@@ -1,132 +0,0 @@
-import MiniSearch, { type SearchOptions } from "minisearch";
-import type { McpExtensionState } from "./state.ts";
-import type { ToolMetadata } from "./types.ts";
-import { getServerPrefix, isServerDisabled, isToolAllowed, resolveToolPrefix } from "./types.ts";
-
-export const MAX_PAGE_SIZE = 100;
-export const MAX_TOOL_NAME_LENGTH = 512;
-
-export interface RankedToolMatch {
-  server: string;
-  tool: ToolMetadata;
-  score: number;
-}
-
-export function normalizeSearchText(value: string): string {
-  return value
-    .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
-    .replace(/[_./:-]+/g, " ")
-    .toLowerCase();
-}
-
-function schemaSearchText(schema: unknown): string {
-  if (!schema || typeof schema !== "object") return "";
-  if (Array.isArray(schema)) return schema.map(schemaSearchText).join(" ");
-  return Object.entries(schema).flatMap(([key, value]) => {
-    if ((key === "description" || key === "title" || key === "const") && typeof value === "string") return value;
-    if (key === "enum" && Array.isArray(value)) return value.filter(item => typeof item === "string");
-    if (key === "properties" && value && typeof value === "object") return [Object.keys(value).join(" "), schemaSearchText(value)];
-    return schemaSearchText(value);
-  }).join(" ");
-}
-
-interface SearchDocument {
-  id: number;
-  server: string;
-  tool: ToolMetadata;
-  name: string;
-  originalName: string;
-  description: string;
-  schema: string;
-}
-
-const indexes = new WeakMap<McpExtensionState, {
-  metadata: Map<string, ToolMetadata[]>;
-  index: MiniSearch<SearchDocument>;
-}>();
-
-function getIndex(state: McpExtensionState): MiniSearch<SearchDocument> {
-  const cached = indexes.get(state);
-  // Catalog publishers replace each server's metadata array on discovery/reconnect.
-  if (cached && cached.metadata.size === state.toolMetadata.size
-    && [...state.toolMetadata].every(([server, metadata]) => cached.metadata.get(server) === metadata)) {
-    return cached.index;
-  }
-
-  const index = new MiniSearch<SearchDocument>({
-    fields: ["name", "originalName", "description", "schema"],
-    storeFields: ["server", "tool"],
-    searchOptions: { fields: ["name", "description", "schema"], boost: { name: 2, description: 1, schema: 1 }, prefix: true },
-  });
-  let id = 0;
-  for (const [server, tools] of state.toolMetadata) {
-    for (const tool of tools) {
-      if (tool.resourceUri !== undefined) continue;
-      index.add({
-        id: id++, server, tool,
-        name: normalizeSearchText(tool.name),
-        originalName: normalizeSearchText(tool.originalName),
-        description: normalizeSearchText([tool.title, tool.description].filter(Boolean).join(" ")),
-        schema: normalizeSearchText(schemaSearchText(tool.inputSchema)),
-      });
-    }
-  }
-  indexes.set(state, { metadata: new Map(state.toolMetadata), index });
-  return index;
-}
-
-function searchCatalog(state: McpExtensionState, query: string, server?: string, options?: SearchOptions): RankedToolMatch[] {
-  return getIndex(state).search(normalizeSearchText(query), {
-    ...options,
-    filter: result => {
-      if (server && result.server !== server) return false;
-      const definition = state.config.mcpServers[result.server];
-      if (!definition || isServerDisabled(definition)) return false;
-      const prefix = resolveToolPrefix(definition, state.config.settings?.toolPrefix);
-      return isToolAllowed(result.tool.originalName, result.server, prefix, definition.includeTools, definition.excludeTools);
-    },
-  }).map(({ server, tool, score }) => ({ server, tool, score }))
-    .sort((a, b) => b.score - a.score || a.tool.name.localeCompare(b.tool.name));
-}
-
-export function rankToolMatches(state: McpExtensionState, query: string, server?: string): RankedToolMatch[] {
-  return searchCatalog(state, query, server);
-}
-
-export function paginate<T>(items: T[], offset: number, limit: number): { items: T[]; total: number; hasMore: boolean; nextOffset: number | null } {
-  const safeOffset = Number.isFinite(offset) ? Math.max(0, Math.trunc(offset)) : 0;
-  const safeLimit = Number.isFinite(limit) ? Math.min(MAX_PAGE_SIZE, Math.max(1, Math.trunc(limit))) : 1;
-  const total = items.length;
-  const page = items.slice(safeOffset, safeOffset + safeLimit);
-  const nextOffset = safeOffset + page.length;
-  return {
-    items: page,
-    total,
-    hasMore: nextOffset < total,
-    nextOffset: nextOffset < total ? nextOffset : null,
-  };
-}
-
-export function rankSuggestions(state: McpExtensionState, name: string, limit: number, server?: string): string[] {
-  if (name.length > MAX_TOOL_NAME_LENGTH) return [];
-
-  const globalPrefix = state.config.settings?.toolPrefix ?? "server";
-  const inferred = server ? undefined : Object.entries(state.config.mcpServers)
-    .filter(([, definition]) => !isServerDisabled(definition))
-    .map(([candidateServer, definition]) => ({
-      server: candidateServer,
-      prefix: getServerPrefix(candidateServer, resolveToolPrefix(definition, globalPrefix)),
-    }))
-    .filter((candidate): candidate is { server: string; prefix: string } =>
-      Boolean(candidate.prefix) && name.startsWith(`${candidate.prefix}_`))
-    .sort((a, b) => b.prefix.length - a.prefix.length)[0];
-  const matchedServer = server ?? inferred?.server;
-  const definition = matchedServer ? state.config.mcpServers[matchedServer] : undefined;
-  if (matchedServer && (!definition || isServerDisabled(definition))) return [];
-  const prefix = inferred?.prefix ?? (matchedServer ? getServerPrefix(matchedServer, resolveToolPrefix(definition, globalPrefix)) : "");
-  const query = prefix && name.startsWith(`${prefix}_`) ? name.slice(prefix.length + 1) : name;
-  const suggestions = searchCatalog(state, query, matchedServer, {
-    fields: [matchedServer ? "originalName" : "name"], combineWith: "AND", fuzzy: 2,
-  }).slice(0, limit).map(match => match.tool.name);
-  return suggestions.length > 0 || !server ? suggestions : rankSuggestions(state, name, limit);
-}