@evantahler/mcpx 0.18.3 → 0.18.6

package/src/search/index.ts

@@ -1,70 +1,66 @@
 import type { SearchIndex } from "../config/schemas.ts";
+import { DEFAULTS } from "../constants.ts";
 import { keywordSearch } from "./keyword.ts";
 import { semanticSearch } from "./semantic.ts";
-import { DEFAULTS } from "../constants.ts";
 
 export interface SearchResult {
-  server: string;
-  tool: string;
-  description: string;
-  score: number;
-  matchType: "keyword" | "semantic" | "both";
+	server: string;
+	tool: string;
+	description: string;
+	score: number;
+	matchType: "keyword" | "semantic" | "both";
 }
 
 export interface SearchOptions {
-  keywordOnly?: boolean;
-  semanticOnly?: boolean;
-  topK?: number;
+	keywordOnly?: boolean;
+	semanticOnly?: boolean;
+	topK?: number;
 }
 
 /** Search tools using keyword and/or semantic matching */
-export async function search(
-  query: string,
-  index: SearchIndex,
-  options: SearchOptions = {},
-): Promise<SearchResult[]> {
-  const topK = options.topK ?? DEFAULTS.SEARCH_TOP_K;
-  const results = new Map<string, SearchResult>();
+export async function search(query: string, index: SearchIndex, options: SearchOptions = {}): Promise<SearchResult[]> {
+	const topK = options.topK ?? DEFAULTS.SEARCH_TOP_K;
+	const results = new Map<string, SearchResult>();
 
-  const runKeyword = !options.semanticOnly;
-  const runSemantic = !options.keywordOnly;
+	const runKeyword = !options.semanticOnly;
+	const runSemantic = !options.keywordOnly;
 
-  // Keyword search
-  if (runKeyword) {
-    const matches = keywordSearch(query, index.tools);
-    for (const m of matches) {
-      const key = `${m.server}/${m.tool}`;
-      results.set(key, {
-        server: m.server,
-        tool: m.tool,
-        description: m.description,
-        score: m.score,
-        matchType: "keyword",
-      });
-    }
-  }
+	// Keyword search
+	if (runKeyword) {
+		const matches = keywordSearch(query, index.tools);
+		for (const m of matches) {
+			const key = `${m.server}/${m.tool}`;
+			results.set(key, {
+				server: m.server,
+				tool: m.tool,
+				description: m.description,
+				score: m.score,
+				matchType: "keyword",
+			});
+		}
+	}
 
-  // Semantic search
-  if (runSemantic && index.tools.some((t) => t.embedding.length > 0)) {
-    const matches = await semanticSearch(query, index.tools, topK);
-    for (const m of matches) {
-      const key = `${m.server}/${m.tool}`;
-      const existing = results.get(key);
-      if (existing) {
-        // Combine scores: keyword 0.4 + semantic 0.6
-        existing.score = existing.score * 0.4 + m.score * 0.6;
-        existing.matchType = "both";
-      } else {
-        results.set(key, {
-          server: m.server,
-          tool: m.tool,
-          description: m.description,
-          score: m.score,
-          matchType: "semantic",
-        });
-      }
-    }
-  }
+	// Semantic search
+	if (runSemantic && index.tools.some((t) => t.embedding.length > 0)) {
+		const matches = await semanticSearch(query, index.tools, topK);
+		for (const m of matches) {
+			const key = `${m.server}/${m.tool}`;
+			const existing = results.get(key);
+			if (existing) {
+				// Combine scores: keyword 0.4 + semantic 0.6
+				existing.score = existing.score * 0.4 + m.score * 0.6;
+				existing.matchType = "both";
+			} else {
+				results.set(key, {
+					server: m.server,
+					tool: m.tool,
+					description: m.description,
+					score: m.score,
+					matchType: "semantic",
+				});
+			}
+		}
+	}
 
-  return [...results.values()].sort((a, b) => b.score - a.score).slice(0, topK);
+	return [...results.values()].sort((a, b) => b.score - a.score).slice(0, topK);
 }

package/src/search/indexer.ts

@@ -1,92 +1,92 @@
 import type { ServerManager, ToolWithServer } from "../client/manager.ts";
-import type { SearchIndex, IndexedTool } from "../config/schemas.ts";
-import { generateEmbedding } from "./semantic.ts";
+import type { IndexedTool, SearchIndex } from "../config/schemas.ts";
 import { logger } from "../output/logger.ts";
+import { generateEmbedding } from "./semantic.ts";
 
 /** Extract keywords from a tool name by splitting on separators and camelCase */
 export function extractKeywords(name: string): string[] {
-  // Split on underscores, hyphens, dots
-  const parts = name.split(/[_\-.]+/);
+	// Split on underscores, hyphens, dots
+	const parts = name.split(/[_\-.]+/);
 
-  // Also split camelCase
-  const words: string[] = [];
-  for (const part of parts) {
-    words.push(...part.replace(/([a-z])([A-Z])/g, "$1 $2").split(/\s+/));
-  }
+	// Also split camelCase
+	const words: string[] = [];
+	for (const part of parts) {
+		words.push(...part.replace(/([a-z])([A-Z])/g, "$1 $2").split(/\s+/));
+	}
 
-  return words.map((w) => w.toLowerCase()).filter((w) => w.length > 1);
+	return words.map((w) => w.toLowerCase()).filter((w) => w.length > 1);
 }
 
 /** Generate scenario phrases from tool name and description */
 export function generateScenarios(name: string, description: string): string[] {
-  const scenarios: string[] = [];
+	const scenarios: string[] = [];
 
-  // Use description as-is if short enough
-  if (description && description.length < 200) {
-    scenarios.push(description);
-  }
+	// Use description as-is if short enough
+	if (description && description.length < 200) {
+		scenarios.push(description);
+	}
 
-  // Extract action + noun from tool name (e.g., "SendMessage" → "send a message")
-  const keywords = extractKeywords(name);
-  if (keywords.length >= 2) {
-    scenarios.push(keywords.join(" "));
-  }
+	// Extract action + noun from tool name (e.g., "SendMessage" → "send a message")
+	const keywords = extractKeywords(name);
+	if (keywords.length >= 2) {
+		scenarios.push(keywords.join(" "));
+	}
 
-  return scenarios;
+	return scenarios;
 }
 
 /** Build an IndexedTool from a tool with server info */
 async function indexTool(t: ToolWithServer): Promise<IndexedTool> {
-  const description = t.tool.description ?? "";
-  const keywords = extractKeywords(t.tool.name);
-  const scenarios = generateScenarios(t.tool.name, description);
-
-  // Build text for embedding: combine name, description, and scenarios
-  const embeddingText = [t.tool.name, description, ...scenarios].filter(Boolean).join(" ");
-  const embedding = await generateEmbedding(embeddingText);
-
-  return {
-    server: t.server,
-    tool: t.tool.name,
-    description,
-    input_schema: t.tool.inputSchema,
-    scenarios,
-    keywords,
-    embedding,
-  };
+	const description = t.tool.description ?? "";
+	const keywords = extractKeywords(t.tool.name);
+	const scenarios = generateScenarios(t.tool.name, description);
+
+	// Build text for embedding: combine name, description, and scenarios
+	const embeddingText = [t.tool.name, description, ...scenarios].filter(Boolean).join(" ");
+	const embedding = await generateEmbedding(embeddingText);
+
+	return {
+		server: t.server,
+		tool: t.tool.name,
+		description,
+		input_schema: t.tool.inputSchema,
+		scenarios,
+		keywords,
+		embedding,
+	};
 }
 
 export interface IndexProgress {
-  total: number;
-  current: number;
-  tool: string;
+	total: number;
+	current: number;
+	tool: string;
 }
 
 /** Build a search index from all configured servers */
 export async function buildSearchIndex(
-  manager: ServerManager,
-  onProgress?: (progress: IndexProgress) => void,
+	manager: ServerManager,
+	onProgress?: (progress: IndexProgress) => void,
 ): Promise<SearchIndex> {
-  const { tools, errors } = await manager.getAllTools();
-
-  if (errors.length > 0) {
-    for (const err of errors) {
-      logger.warn(`${err.server}: ${err.message}`);
-    }
-  }
-
-  const indexed: IndexedTool[] = [];
-
-  for (let i = 0; i < tools.length; i++) {
-    const t = tools[i]!;
-    onProgress?.({ total: tools.length, current: i + 1, tool: `${t.server}/${t.tool.name}` });
-    indexed.push(await indexTool(t));
-  }
-
-  return {
-    version: 1,
-    indexed_at: new Date().toISOString(),
-    embedding_model: "Xenova/all-MiniLM-L6-v2",
-    tools: indexed,
-  };
+	const { tools, errors } = await manager.getAllTools();
+
+	if (errors.length > 0) {
+		for (const err of errors) {
+			logger.warn(`${err.server}: ${err.message}`);
+		}
+	}
+
+	const indexed: IndexedTool[] = [];
+
+	for (let i = 0; i < tools.length; i++) {
+		const t = tools[i]!;
+		onProgress?.({ total: tools.length, current: i + 1, tool: `${t.server}/${t.tool.name}` });
+		indexed.push(await indexTool(t));
+	}
+
+	return {
+		version: 1,
+		indexed_at: new Date().toISOString(),
+		embedding_model: "Xenova/all-MiniLM-L6-v2",
+		tools: indexed,
+	};
 }

package/src/search/keyword.ts

@@ -3,81 +3,81 @@ import type { IndexedTool } from "../config/schemas.ts";
 import type { BaseMatch } from "./types.ts";
 
 export interface KeywordMatch extends BaseMatch {
-  matchedField: string;
+	matchedField: string;
 }
 
 interface FieldWeight {
-  field: string;
-  weight: number;
-  values: (t: IndexedTool) => string[];
+	field: string;
+	weight: number;
+	values: (t: IndexedTool) => string[];
 }
 
 const FIELDS: FieldWeight[] = [
-  { field: "name", weight: 1.0, values: (t) => [t.tool] },
-  { field: "keyword", weight: 0.8, values: (t) => t.keywords },
-  { field: "scenario", weight: 0.6, values: (t) => t.scenarios },
-  { field: "description", weight: 0.4, values: (t) => [t.description] },
+	{ field: "name", weight: 1.0, values: (t) => [t.tool] },
+	{ field: "keyword", weight: 0.8, values: (t) => t.keywords },
+	{ field: "scenario", weight: 0.6, values: (t) => t.scenarios },
+	{ field: "description", weight: 0.4, values: (t) => [t.description] },
 ];
 
 /** Check if query looks like a glob pattern */
 function isGlob(query: string): boolean {
-  return /[*?[\]{}]/.test(query);
+	return /[*?[\]{}]/.test(query);
 }
 
 /** Search indexed tools by keyword/glob matching */
 export function keywordSearch(query: string, tools: IndexedTool[]): KeywordMatch[] {
-  const queryLower = query.toLowerCase();
-  const tokens = queryLower.split(/\s+/).filter(Boolean);
+	const queryLower = query.toLowerCase();
+	const tokens = queryLower.split(/\s+/).filter(Boolean);
 
-  // If any token is a glob, use picomatch for name matching
-  const globTokens = tokens.filter(isGlob);
-  const textTokens = tokens.filter((t) => !isGlob(t));
-  const globMatcher = globTokens.length > 0 ? picomatch(globTokens, { nocase: true }) : null;
+	// If any token is a glob, use picomatch for name matching
+	const globTokens = tokens.filter(isGlob);
+	const textTokens = tokens.filter((t) => !isGlob(t));
+	const globMatcher = globTokens.length > 0 ? picomatch(globTokens, { nocase: true }) : null;
 
-  const results: KeywordMatch[] = [];
+	const results: KeywordMatch[] = [];
 
-  for (const tool of tools) {
-    let bestScore = 0;
-    let bestField = "";
+	for (const tool of tools) {
+		let bestScore = 0;
+		let bestField = "";
 
-    // Glob matching against tool name
-    if (globMatcher && globMatcher(tool.tool)) {
-      bestScore = 1.0;
-      bestField = "name";
-    }
+		// Glob matching against tool name
+		if (globMatcher?.(tool.tool)) {
+			bestScore = 1.0;
+			bestField = "name";
+		}
 
-    // Text token matching against all fields
-    if (textTokens.length > 0) {
-      for (const { field, weight, values } of FIELDS) {
-        const fieldValues = values(tool).map((v) => v.toLowerCase());
-        let matchCount = 0;
+		// Text token matching against all fields
+		if (textTokens.length > 0) {
+			for (const { field, weight, values } of FIELDS) {
+				const fieldValues = values(tool).map((v) => v.toLowerCase());
+				let matchCount = 0;
 
-        for (const token of textTokens) {
-          if (fieldValues.some((v) => v.includes(token))) {
-            matchCount++;
-          }
-        }
+				for (const token of textTokens) {
+					if (fieldValues.some((v) => v.includes(token))) {
+						matchCount++;
+					}
+				}
 
-        if (matchCount > 0) {
-          const score = (matchCount / textTokens.length) * weight;
-          if (score > bestScore) {
-            bestScore = score;
-            bestField = field;
-          }
-        }
-      }
-    }
+				if (matchCount > 0) {
+					const score = (matchCount / textTokens.length) * weight;
+					if (score > bestScore) {
+						bestScore = score;
+						bestField = field;
+					}
+				}
+			}
+		}
 
-    if (bestScore > 0) {
-      results.push({
-        server: tool.server,
-        tool: tool.tool,
-        description: tool.description,
-        score: bestScore,
-        matchedField: bestField,
-      });
-    }
-  }
+		if (bestScore > 0) {
+			results.push({
+				server: tool.server,
+				tool: tool.tool,
+				description: tool.description,
+				score: bestScore,
+				matchedField: bestField,
+			});
+		}
+	}
 
-  return results.sort((a, b) => b.score - a.score);
+	return results.sort((a, b) => b.score - a.score);
 }

package/src/search/semantic.ts

@@ -9,64 +9,64 @@ let pipelineInstance: ((text: string) => Promise<Float32Array>) | null = null;
 
 /** Get or create the embedding pipeline */
 async function getEmbedder(): Promise<(text: string) => Promise<Float32Array>> {
-  if (pipelineInstance) return pipelineInstance;
+	if (pipelineInstance) return pipelineInstance;
 
-  const { pipeline } = await import("@huggingface/transformers");
-  const extractor = await pipeline("feature-extraction", "Xenova/all-MiniLM-L6-v2", {
-    dtype: "fp32",
-  });
+	const { pipeline } = await import("@huggingface/transformers");
+	const extractor = await pipeline("feature-extraction", "Xenova/all-MiniLM-L6-v2", {
+		dtype: "fp32",
+	});
 
-  pipelineInstance = async (text: string): Promise<Float32Array> => {
-    const output = await extractor(text, { pooling: "mean", normalize: true });
-    // output.data is a Float32Array of the pooled embedding
-    return output.data as Float32Array;
-  };
+	pipelineInstance = async (text: string): Promise<Float32Array> => {
+		const output = await extractor(text, { pooling: "mean", normalize: true });
+		// output.data is a Float32Array of the pooled embedding
+		return output.data as Float32Array;
+	};
 
-  return pipelineInstance;
+	return pipelineInstance;
 }
 
 /** Generate an embedding vector for text */
 export async function generateEmbedding(text: string): Promise<number[]> {
-  const embed = await getEmbedder();
-  const vec = await embed(text);
-  return Array.from(vec);
+	const embed = await getEmbedder();
+	const vec = await embed(text);
+	return Array.from(vec);
 }
 
 /** Cosine similarity between two vectors */
 export function cosineSimilarity(a: number[], b: number[]): number {
-  if (a.length !== b.length || a.length === 0) return 0;
+	if (a.length !== b.length || a.length === 0) return 0;
 
-  let dot = 0;
-  let magA = 0;
-  let magB = 0;
-  for (let i = 0; i < a.length; i++) {
-    dot += a[i]! * b[i]!;
-    magA += a[i]! * a[i]!;
-    magB += b[i]! * b[i]!;
-  }
+	let dot = 0;
+	let magA = 0;
+	let magB = 0;
+	for (let i = 0; i < a.length; i++) {
+		dot += a[i]! * b[i]!;
+		magA += a[i]! * a[i]!;
+		magB += b[i]! * b[i]!;
+	}
 
-  const denom = Math.sqrt(magA) * Math.sqrt(magB);
-  return denom === 0 ? 0 : dot / denom;
+	const denom = Math.sqrt(magA) * Math.sqrt(magB);
+	return denom === 0 ? 0 : dot / denom;
 }
 
 /** Search indexed tools by semantic similarity */
 export async function semanticSearch(
-  query: string,
-  tools: IndexedTool[],
-  topK: number = DEFAULTS.SEARCH_TOP_K,
+	query: string,
+	tools: IndexedTool[],
+	topK: number = DEFAULTS.SEARCH_TOP_K,
 ): Promise<SemanticMatch[]> {
-  // Only search tools that have embeddings
-  const withEmbeddings = tools.filter((t) => t.embedding.length > 0);
-  if (withEmbeddings.length === 0) return [];
+	// Only search tools that have embeddings
+	const withEmbeddings = tools.filter((t) => t.embedding.length > 0);
+	if (withEmbeddings.length === 0) return [];
 
-  const queryEmbedding = await generateEmbedding(query);
+	const queryEmbedding = await generateEmbedding(query);
 
-  const scored = withEmbeddings.map((tool) => ({
-    server: tool.server,
-    tool: tool.tool,
-    description: tool.description,
-    score: cosineSimilarity(queryEmbedding, tool.embedding),
-  }));
+	const scored = withEmbeddings.map((tool) => ({
+		server: tool.server,
+		tool: tool.tool,
+		description: tool.description,
+		score: cosineSimilarity(queryEmbedding, tool.embedding),
+	}));
 
-  return scored.sort((a, b) => b.score - a.score).slice(0, topK);
+	return scored.sort((a, b) => b.score - a.score).slice(0, topK);
 }

package/src/search/staleness.ts

@@ -2,7 +2,7 @@ import type { SearchIndex, ServersFile } from "../config/schemas.ts";
 
 /** Return server names that appear in the index but not in the current config */
 export function getStaleServers(index: SearchIndex, servers: ServersFile): string[] {
-  const configured = new Set(Object.keys(servers.mcpServers));
-  const indexed = new Set(index.tools.map((t) => t.server));
-  return [...indexed].filter((s) => !configured.has(s));
+	const configured = new Set(Object.keys(servers.mcpServers));
+	const indexed = new Set(index.tools.map((t) => t.server));
+	return [...indexed].filter((s) => !configured.has(s));
 }

package/src/search/types.ts

@@ -1,7 +1,7 @@
 /** Base interface for tool search matches */
 export interface BaseMatch {
-  server: string;
-  tool: string;
-  description: string;
-  score: number;
+	server: string;
+	tool: string;
+	description: string;
+	score: number;
 }