@aiwerk/mcp-bridge 1.6.2 → 1.7.0

package/dist/bin/mcp-bridge.js

@@ -2,6 +2,7 @@
 import { readFileSync, existsSync } from "fs";
 import { join, dirname, resolve } from "path";
 import { fileURLToPath } from "url";
+import { platform } from "os";
 import { execFileSync } from "child_process";
 import { loadConfig, initConfigDir } from "../src/config.js";
 import { StandaloneServer } from "../src/standalone-server.js";
@@ -212,19 +213,30 @@ function cmdSearch(query, logger) {
         return;
     }
     process.stdout.write(`\nSearch results for "${query}":\n\n`);
-    for (const [i, [name, info]] of matches.entries()) {
+    matches.forEach(([name, info], i) => {
         process.stdout.write(`  ${i + 1}  ${name.padEnd(16)}${info.description || ""}\n`);
-    }
+    });
     process.stdout.write("\n");
 }
 function cmdInstall(serverName, logger) {
-    const scriptPath = join(PACKAGE_ROOT, "scripts", "install-server.sh");
-    if (!existsSync(scriptPath)) {
-        logger.error("Install script not found");
-        process.exit(1);
-    }
+    const scriptDir = join(PACKAGE_ROOT, "scripts");
     try {
-        execFileSync("bash", [scriptPath, serverName], { stdio: "inherit" });
+        if (platform() === "win32") {
+            const psScript = join(scriptDir, "install-server.ps1");
+            if (!existsSync(psScript)) {
+                logger.error("Install script not found (install-server.ps1)");
+                process.exit(1);
+            }
+            execFileSync("powershell", ["-ExecutionPolicy", "Bypass", "-File", psScript, serverName], { stdio: "inherit" });
+        }
+        else {
+            const scriptPath = join(scriptDir, "install-server.sh");
+            if (!existsSync(scriptPath)) {
+                logger.error("Install script not found (install-server.sh)");
+                process.exit(1);
+            }
+            execFileSync("bash", [scriptPath, serverName], { stdio: "inherit" });
+        }
     }
     catch (err) {
         process.exit(1);

package/dist/src/embeddings.d.ts

@@ -5,8 +5,13 @@ export interface EmbeddingProvider {
 }
 export declare class GeminiEmbedding implements EmbeddingProvider {
     private readonly apiKey;
+    private readonly model;
+    private readonly baseUrl;
+    private static readonly BATCH_LIMIT;
     constructor(apiKey: string);
     embed(texts: string[]): Promise<number[][]>;
+    private batchEmbed;
+    private singleEmbed;
     dimensions(): number;
 }
 export declare class OpenAIEmbedding implements EmbeddingProvider {
@@ -25,7 +30,14 @@ export declare class OllamaEmbedding implements EmbeddingProvider {
 }
 export declare class KeywordEmbedding implements EmbeddingProvider {
     private vocabulary;
-    private vocabSize;
+    private frozen;
+    /**
+     * Add texts to the vocabulary (call during indexing phase).
+     * After freeze(), new words are silently ignored.
+     */
+    buildVocabulary(texts: string[]): void;
+    /** Freeze vocabulary — no new words added after this. */
+    freeze(): void;
     embed(texts: string[]): Promise<number[][]>;
     dimensions(): number;
     private tokenize;

package/dist/src/embeddings.js

@@ -1,26 +1,60 @@
 export class GeminiEmbedding {
     apiKey;
+    model = "gemini-embedding-001";
+    baseUrl = "https://generativelanguage.googleapis.com/v1beta";
+    static BATCH_LIMIT = 100;
     constructor(apiKey) {
         this.apiKey = apiKey;
     }
     async embed(texts) {
         const results = [];
-        for (const text of texts) {
-            const response = await fetch(`https://generativelanguage.googleapis.com/v1beta/models/gemini-embedding-001:embedContent?key=${this.apiKey}`, {
-                method: "POST",
-                headers: { "Content-Type": "application/json" },
-                body: JSON.stringify({
-                    content: { parts: [{ text }] }
-                })
-            });
-            if (!response.ok) {
-                throw new Error(`Gemini API error: ${response.status} ${response.statusText}`);
+        // Process in chunks of BATCH_LIMIT
+        for (let i = 0; i < texts.length; i += GeminiEmbedding.BATCH_LIMIT) {
+            const chunk = texts.slice(i, i + GeminiEmbedding.BATCH_LIMIT);
+            try {
+                const chunkResults = await this.batchEmbed(chunk);
+                results.push(...chunkResults);
+            }
+            catch {
+                // Fallback: sequential embedding if batch fails
+                for (const text of chunk) {
+                    results.push(await this.singleEmbed(text));
+                }
             }
-            const data = await response.json();
-            results.push(data.embedding.values);
         }
         return results;
     }
+    async batchEmbed(texts) {
+        const response = await fetch(`${this.baseUrl}/models/${this.model}:batchEmbedContents?key=${this.apiKey}`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                requests: texts.map(text => ({
+                    model: `models/${this.model}`,
+                    content: { parts: [{ text }] },
+                })),
+            }),
+        });
+        if (!response.ok) {
+            throw new Error(`Gemini API error: ${response.status} ${response.statusText}`);
+        }
+        const data = await response.json();
+        return data.embeddings.map((e) => e.values);
+    }
+    async singleEmbed(text) {
+        const response = await fetch(`${this.baseUrl}/models/${this.model}:embedContent?key=${this.apiKey}`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                content: { parts: [{ text }] }
+            })
+        });
+        if (!response.ok) {
+            throw new Error(`Gemini API error: ${response.status} ${response.statusText}`);
+        }
+        const data = await response.json();
+        return data.embedding.values;
+    }
     dimensions() {
         return 768;
     }
@@ -78,57 +112,55 @@ export class OllamaEmbedding {
 }
 export class KeywordEmbedding {
     vocabulary = new Map();
-    vocabSize = 0;
-    async embed(texts) {
-        // Build vocabulary from all texts
-        this.vocabulary.clear();
-        this.vocabSize = 0;
-        const tokenizedTexts = texts.map((text) => this.tokenize(text));
-        for (const tokens of tokenizedTexts) {
-            for (const token of tokens) {
-                if (!this.vocabulary.has(token)) {
-                    this.vocabulary.set(token, this.vocabSize++);
+    frozen = false;
+    /**
+     * Add texts to the vocabulary (call during indexing phase).
+     * After freeze(), new words are silently ignored.
+     */
+    buildVocabulary(texts) {
+        if (this.frozen)
+            return;
+        for (const text of texts) {
+            for (const word of this.tokenize(text)) {
+                if (!this.vocabulary.has(word)) {
+                    this.vocabulary.set(word, this.vocabulary.size);
                 }
             }
         }
-        if (this.vocabSize === 0) {
+    }
+    /** Freeze vocabulary — no new words added after this. */
+    freeze() {
+        this.frozen = true;
+    }
+    async embed(texts) {
+        // If not frozen yet, add these texts to vocabulary first
+        if (!this.frozen) {
+            this.buildVocabulary(texts);
+        }
+        const vocabSize = this.vocabulary.size;
+        if (vocabSize === 0) {
             return texts.map(() => [0]);
         }
-        // Create TF vectors
-        const vectors = [];
-        for (const tokens of tokenizedTexts) {
-            const vector = new Array(this.vocabSize).fill(0);
-            for (const token of tokens) {
-                const idx = this.vocabulary.get(token);
-                vector[idx] += 1;
+        // Create TF vectors using the FIXED vocabulary
+        return texts.map((text) => {
+            const vector = new Array(vocabSize).fill(0);
+            const words = this.tokenize(text);
+            for (const word of words) {
+                const idx = this.vocabulary.get(word);
+                if (idx !== undefined) {
+                    vector[idx] += 1;
+                }
             }
             // Normalize by document length
-            const len = tokens.length || 1;
+            const len = words.length || 1;
             for (let i = 0; i < vector.length; i++) {
                 vector[i] /= len;
             }
-            vectors.push(vector);
-        }
-        // Apply IDF weighting
-        const docCount = texts.length;
-        const idf = new Array(this.vocabSize).fill(0);
-        for (let i = 0; i < this.vocabSize; i++) {
-            let df = 0;
-            for (const vec of vectors) {
-                if (vec[i] > 0)
-                    df++;
-            }
-            idf[i] = Math.log((docCount + 1) / (df + 1)) + 1;
-        }
-        for (const vec of vectors) {
-            for (let i = 0; i < vec.length; i++) {
-                vec[i] *= idf[i];
-            }
-        }
-        return vectors;
+            return vector;
+        });
     }
     dimensions() {
-        return this.vocabSize || 1;
+        return this.vocabulary.size || 1;
     }
     tokenize(text) {
         return text

package/dist/src/intent-router.js

@@ -1,3 +1,4 @@
+import { KeywordEmbedding } from "./embeddings.js";
 import { VectorStore } from "./vector-store.js";
 const DEFAULT_MIN_SCORE = 0.3;
 const DEFAULT_TOP_K = 4;
@@ -40,6 +41,10 @@ export class IntentRouter {
                 description: entries[i].text
             });
         }
+        // Freeze keyword vocabulary so query vectors use the same dimensions
+        if (this.embeddingProvider instanceof KeywordEmbedding) {
+            this.embeddingProvider.freeze();
+        }
         this.indexed = true;
         this.logger.debug(`[mcp-bridge] Intent router indexed ${entries.length} tools`);
     }

package/dist/src/smart-filter.d.ts

@@ -47,46 +47,10 @@ export interface UserTurn {
     content: string;
     timestamp: number;
 }
-/**
- * Smart Filter implementation - Phase 1
- */
-export declare class SmartFilter {
-    private config;
-    private logger;
-    constructor(config: SmartFilterConfig, logger: OpenClawLogger);
-    /**
-     * Main filter entry point
-     */
-    filter(servers: Record<string, PluginServerConfig>, allTools: Map<string, McpTool[]>, userTurns: UserTurn[]): Promise<FilterResult>;
-    private performFilter;
-    /**
-     * Extract meaningful intent from last 1-3 user turns
-     */
-    static synthesizeQuery(userTurns: UserTurn[]): string;
-    private static extractMeaningfulContent;
-    private prepareFilterableServers;
-    private normalizeKeywords;
-    /**
-     * Score servers using weighted overlap scoring
-     */
-    private scoreServers;
-    static tokenize(text: string): string[];
-    private calculateServerScore;
-    private getSemanticScore;
-    private countOverlap;
-    /**
-     * Select servers using dynamic topServers with confidence-based expansion
-     */
-    private selectServers;
-    /**
-     * Filter tools within selected servers
-     */
-    private filterTools;
-    private calculateToolScore;
-    private calculateConfidenceScore;
-    private createUnfilteredResult;
-    private logTelemetry;
-}
+/** Tokenize text into lowercase words, stripping punctuation. */
+export declare function tokenize(text: string): string[];
+/** Extract meaningful intent from last 1-3 user turns. */
+export declare function synthesizeQuery(userTurns: UserTurn[]): string;
 export declare const DEFAULTS: Required<SmartFilterConfig>;
 /** Normalize keywords: lowercase, trim, dedup, strip empties, cap at MAX_KEYWORDS. */
 export declare function validateKeywords(raw: string[]): string[];

package/dist/src/smart-filter.js

@@ -2,390 +2,58 @@
  * Smart Filter v2 - Phase 1: Keyword-based filtering
  * Zero external dependencies, graceful degradation
  */
-/**
- * Smart Filter implementation - Phase 1
- */
-export class SmartFilter {
-    config;
-    logger;
-    constructor(config, logger) {
-        // Apply defaults
-        this.config = {
-            enabled: config.enabled ?? true,
-            embedding: config.embedding ?? "auto",
-            topServers: config.topServers ?? 5,
-            hardCap: config.hardCap ?? 8,
-            topTools: config.topTools ?? 10,
-            serverThreshold: config.serverThreshold ?? 0.01, // Very low threshold for maximum recall
-            toolThreshold: config.toolThreshold ?? 0.05, // Much lower threshold for better recall  
-            fallback: config.fallback ?? "keyword",
-            alwaysInclude: config.alwaysInclude ?? [],
-            timeoutMs: config.timeoutMs ?? 500,
-            telemetry: config.telemetry ?? false,
-        };
-        this.logger = logger;
-    }
-    /**
-     * Main filter entry point
-     */
-    async filter(servers, allTools, userTurns) {
-        if (!this.config.enabled) {
-            return this.createUnfilteredResult(servers, allTools, "disabled");
-        }
-        const startTime = Date.now();
-        let timeoutOccurred = false;
-        try {
-            // Set up timeout
-            let timeoutId;
-            const timeoutPromise = new Promise((resolve) => {
-                timeoutId = setTimeout(() => {
-                    timeoutOccurred = true;
-                    this.logger.warn(`[smart-filter] Filter timeout after ${this.config.timeoutMs}ms, falling back to show all`);
-                    resolve(this.createUnfilteredResult(servers, allTools, "keyword"));
-                }, this.config.timeoutMs);
-            });
-            const filterPromise = this.performFilter(servers, allTools, userTurns);
-            let result;
-            try {
-                result = await Promise.race([filterPromise, timeoutPromise]);
-            }
-            finally {
-                clearTimeout(timeoutId);
-            }
-            result.metadata.timeoutOccurred = timeoutOccurred;
-            const duration = Date.now() - startTime;
-            if (this.config.telemetry) {
-                this.logTelemetry(result, duration);
-            }
-            return result;
-        }
-        catch (error) {
-            this.logger.warn(`[smart-filter] Filter failed: ${error instanceof Error ? error.message : String(error)}, falling back to show all`);
-            const result = this.createUnfilteredResult(servers, allTools, "keyword");
-            result.metadata.timeoutOccurred = timeoutOccurred;
-            return result;
-        }
-    }
-    async performFilter(servers, allTools, userTurns) {
-        // Step 1: Query synthesis
-        const query = SmartFilter.synthesizeQuery(userTurns);
-        if (!query) {
-            this.logger.debug("[smart-filter] No meaningful query found, showing all servers");
-            return this.createUnfilteredResult(servers, allTools, "keyword", "");
-        }
-        // Step 2: Prepare filterable servers
-        const filterableServers = this.prepareFilterableServers(servers, allTools);
-        // Step 3: Level 1 - Server filtering
-        const serverScores = this.scoreServers(query, filterableServers);
-        const selectedServers = this.selectServers(serverScores, filterableServers);
-        // Step 4: Level 2 - Tool filtering
-        const toolResults = this.filterTools(query, selectedServers);
-        return {
-            servers: selectedServers.map(s => s.server),
-            tools: toolResults,
-            metadata: {
-                queryUsed: query,
-                totalServersBeforeFilter: Object.keys(servers).length,
-                totalToolsBeforeFilter: Array.from(allTools.values()).flat().length,
-                filterMode: "keyword",
-                timeoutOccurred: false,
-                confidenceScore: this.calculateConfidenceScore(serverScores),
-            },
-        };
-    }
-    /**
-     * Extract meaningful intent from last 1-3 user turns
-     */
-    static synthesizeQuery(userTurns) {
-        if (!userTurns || userTurns.length === 0) {
-            return "";
-        }
-        // Take last 1-3 turns, newest first
-        const recentTurns = userTurns
-            .slice(-3)
-            .reverse()
-            .map(turn => turn.content.trim());
-        for (const content of recentTurns) {
-            const cleanedQuery = SmartFilter.extractMeaningfulContent(content);
-            if (cleanedQuery.length >= 3) {
-                return cleanedQuery;
-            }
-        }
-        // If all recent turns are too short, try combining them
-        const combined = recentTurns
-            .map(content => SmartFilter.extractMeaningfulContent(content))
-            .filter(content => content.length > 0)
-            .join(" ")
-            .trim();
-        return combined.length >= 3 ? combined : "";
-    }
-    static extractMeaningfulContent(content) {
-        // Remove metadata patterns
-        const cleaned = content
-            .replace(/\[.*?\]/g, "") // [timestamps], [commands]
-            .replace(/^\s*[>]*\s*/gm, "") // quote markers
-            .replace(/^\s*[-*•]\s*/gm, "") // list markers
-            .trim();
-        // Filter out noise words/confirmations
-        const noisePatterns = [
-            /^(yes|no|ok|okay|sure|thanks?|thank you)\.?$/i,
-            /^(do it|go ahead|proceed)\.?$/i,
-            /^(yes,?\s+(do it|go ahead|proceed))\.?$/i,
-            /^\?+$/,
-            /^\.+$/,
-            /^!+$/,
-        ];
-        if (noisePatterns.some(pattern => pattern.test(cleaned))) {
-            return "";
-        }
-        // Remove trailing "please" and other politeness words
-        const withoutPoliteness = cleaned
-            .replace(/\s+please\.?$/i, "")
-            .replace(/\s+thanks?\.?$/i, "")
-            .trim();
-        return withoutPoliteness;
-    }
-    prepareFilterableServers(servers, allTools) {
-        return Object.entries(servers).map(([name, config]) => ({
-            name,
-            description: config.description || "",
-            keywords: this.normalizeKeywords(config.keywords || []),
-            tools: allTools.get(name) || [],
-        }));
-    }
-    normalizeKeywords(keywords) {
-        return keywords
-            .slice(0, 30) // Max 30 keywords
-            .map(kw => kw.toLowerCase().trim())
-            .filter(kw => kw.length > 0)
-            .filter((kw, index, arr) => arr.indexOf(kw) === index); // Deduplicate
-    }
-    /**
-     * Score servers using weighted overlap scoring
-     */
-    scoreServers(query, servers) {
-        const queryWords = SmartFilter.tokenize(query.toLowerCase());
-        return servers.map(server => ({
-            server,
-            score: this.calculateServerScore(queryWords, server),
-        }));
-    }
-    static tokenize(text) {
-        return text
-            .toLowerCase()
-            .replace(/[^\w\s]/g, " ")
-            .split(/\s+/)
-            .filter(word => word.length > 0);
-    }
-    calculateServerScore(queryWords, server) {
-        if (queryWords.length === 0)
-            return 0;
-        const descriptionWords = SmartFilter.tokenize(server.description);
-        const keywordWords = server.keywords;
-        const allServerWords = [...descriptionWords, ...keywordWords];
-        // Calculate overlaps
-        const descMatches = this.countOverlap(queryWords, descriptionWords);
-        // Count keyword matches that are NOT already counted in description
-        const keywordOnlyWords = keywordWords.filter(kw => !descriptionWords.includes(kw));
-        const keywordOnlyMatches = this.countOverlap(queryWords, keywordOnlyWords);
-        // Add basic synonym matching for common terms
-        let semanticMatches = 0;
-        for (const queryWord of queryWords) {
-            semanticMatches += this.getSemanticScore(queryWord, allServerWords);
-        }
-        // Also check for partial/substring matches for better recall
-        let partialMatches = 0;
-        for (const queryWord of queryWords) {
-            for (const serverWord of allServerWords) {
-                if (queryWord.length > 3 && serverWord.includes(queryWord)) {
-                    partialMatches += 0.3; // Partial match gets partial credit
-                }
-            }
-        }
-        // Weighted scoring: description 1.0x, keywords 0.7x, semantic 0.5x, partial matches 0.3x
-        const score = (descMatches * 1.0 + keywordOnlyMatches * 0.7 + semanticMatches * 0.5 + partialMatches) / queryWords.length;
-        return score;
-    }
-    getSemanticScore(queryWord, serverWords) {
-        // Comprehensive synonym/semantic matching
-        const synonymMap = {
-            // Finance/payment terms
-            money: ["payment", "transfer", "currency", "invoice", "billing", "charge", "account", "balance"],
-            payment: ["money", "transfer", "invoice", "billing", "charge", "process"],
-            send: ["transfer", "payment", "international"],
-            transfer: ["send", "payment", "money", "international"],
-            invoice: ["bill", "charge", "payment", "billing", "customer"],
-            account: ["balance", "money", "payment"],
-            balance: ["account", "money"],
-            international: ["transfer", "money", "payment"],
-            // Task/productivity terms  
-            task: ["todo", "reminder", "project", "management", "productivity"],
-            todo: ["task", "reminder", "management"],
-            create: ["add", "new", "task", "issue"],
-            project: ["task", "management", "board", "productivity"],
-            manage: ["task", "project", "productivity"],
-            schedule: ["meeting", "calendar", "appointment"],
-            meeting: ["schedule", "calendar"],
-            // Development terms
-            code: ["repo", "repository", "commit", "branch", "github"],
-            issue: ["bug", "ticket", "github", "repository"],
-            bug: ["issue", "github"],
-            repository: ["repo", "code", "github"],
-            commit: ["code", "repository", "github"],
-            // Location/maps terms
-            location: ["map", "address", "directions", "geocode", "places"],
-            directions: ["map", "route", "location"],
-            address: ["location", "geocode"],
-            geocode: ["address", "location"],
-            restaurant: ["location", "places", "map"],
-            nearby: ["location", "map"],
-            // Storage/document terms
-            upload: ["store", "save", "file", "document"],
-            document: ["file", "note", "upload", "storage"],
-            store: ["save", "upload", "note"],
-            notes: ["document", "store"],
-            // Infrastructure terms
-            deploy: ["infrastructure", "cloud", "server"],
-            cloud: ["infrastructure", "deploy"],
-            server: ["infrastructure", "monitoring"],
-            infrastructure: ["cloud", "server", "deploy"],
-            monitoring: ["server", "infrastructure"],
-            // Collaboration terms
-            whiteboard: ["collaboration", "brainstorming"],
-            brainstorming: ["whiteboard", "collaboration"],
-            collaboration: ["whiteboard", "design"],
-            // Search terms
-            search: ["find", "information", "papers"],
-            find: ["search", "information"],
-            information: ["search", "find"],
-            // Web scraping terms
-            analyze: ["data", "extract", "website"],
-            extract: ["data", "scraping", "website"],
-            website: ["scraping", "analyze", "extract"],
-            data: ["extract", "analyze", "scraping"],
-            traffic: ["website", "analyze"],
-        };
-        const synonyms = synonymMap[queryWord.toLowerCase()] || [];
-        let matches = 0;
-        for (const synonym of synonyms) {
-            if (serverWords.includes(synonym)) {
-                matches += 1;
-            }
-        }
-        return matches;
-    }
-    countOverlap(words1, words2) {
-        const set2 = new Set(words2);
-        return words1.filter(word => set2.has(word)).length;
-    }
-    /**
-     * Select servers using dynamic topServers with confidence-based expansion
-     */
-    selectServers(serverScores, allServers) {
-        // Include always-included servers first
-        const alwaysIncluded = allServers
-            .filter(s => this.config.alwaysInclude.includes(s.name))
-            .map(server => ({ server, score: 1.0 }));
-        // Sort all servers by score
-        const allScoredServers = serverScores
-            .filter(({ server }) => !this.config.alwaysInclude.includes(server.name))
-            .sort((a, b) => b.score - a.score);
-        // Primary filter: servers that meet threshold
-        const thresholdServers = allScoredServers.filter(({ score }) => score >= this.config.serverThreshold);
-        // Fallback: if too few servers pass threshold, include more based on ranking
-        let scoredServers = thresholdServers;
-        if (thresholdServers.length < 2) {
-            // Take at least top 3 servers regardless of threshold for better recall
-            scoredServers = allScoredServers.slice(0, Math.max(3, this.config.topServers));
-            this.logger.debug(`[smart-filter] Only ${thresholdServers.length} servers met threshold, expanding to top ${scoredServers.length}`);
-        }
-        // Dynamic topServers based on confidence
-        let numServers = this.config.topServers;
-        if (scoredServers.length >= 2) {
-            const topScore = scoredServers[0].score;
-            const cutoffScore = scoredServers[Math.min(this.config.topServers - 1, scoredServers.length - 1)].score;
-            const gap = topScore - cutoffScore;
-            // If gap is small (uncertain), expand toward hard cap
-            if (gap < 0.1 && scoredServers.length > numServers) {
-                numServers = Math.min(this.config.hardCap, scoredServers.length);
-                this.logger.debug(`[smart-filter] Low confidence (gap: ${gap.toFixed(3)}), expanding to ${numServers} servers`);
-            }
-        }
-        const selectedScored = scoredServers.slice(0, numServers);
-        return [...alwaysIncluded, ...selectedScored];
-    }
-    /**
-     * Filter tools within selected servers
-     */
-    filterTools(query, selectedServers) {
-        const queryWords = SmartFilter.tokenize(query);
-        const allTools = [];
-        for (const { server } of selectedServers) {
-            for (const tool of server.tools) {
-                const score = this.calculateToolScore(queryWords, tool);
-                if (score >= this.config.toolThreshold) {
-                    allTools.push({ serverId: server.name, tool, score });
-                }
-            }
-        }
-        // Sort by score and take top N
-        return allTools
-            .sort((a, b) => b.score - a.score)
-            .slice(0, this.config.topTools)
-            .map(({ serverId, tool }) => ({ serverId, tool }));
-    }
-    calculateToolScore(queryWords, tool) {
-        if (queryWords.length === 0)
-            return 0;
-        const nameWords = SmartFilter.tokenize(tool.name);
-        const descWords = SmartFilter.tokenize(tool.description || "");
-        const nameMatches = this.countOverlap(queryWords, nameWords);
-        const descMatches = this.countOverlap(queryWords, descWords) - this.countOverlap(queryWords, nameWords);
-        // Weighted: description 1.0x, name 0.5x (name is less descriptive usually)
-        const score = (descMatches * 1.0 + nameMatches * 0.5) / queryWords.length;
-        return score;
-    }
-    calculateConfidenceScore(serverScores) {
-        if (serverScores.length < 2)
-            return 1.0;
-        const scores = serverScores.map(s => s.score).sort((a, b) => b - a);
-        const topScore = scores[0];
-        const secondScore = scores[1];
-        // Confidence based on gap between top scores
-        if (topScore === 0)
-            return 0;
-        return Math.min(1.0, (topScore - secondScore) / topScore);
-    }
-    createUnfilteredResult(servers, allTools, filterMode, queryUsed = "") {
-        const filterableServers = this.prepareFilterableServers(servers, allTools);
-        const tools = Array.from(allTools.entries()).flatMap(([serverId, tools]) => tools.map(tool => ({ serverId, tool })));
-        return {
-            servers: filterableServers,
-            tools,
-            metadata: {
-                queryUsed,
-                totalServersBeforeFilter: Object.keys(servers).length,
-                totalToolsBeforeFilter: tools.length,
-                filterMode,
-                timeoutOccurred: false,
-            },
-        };
-    }
-    logTelemetry(result, durationMs) {
-        const telemetry = {
-            timestamp: new Date().toISOString(),
-            query: result.metadata.queryUsed,
-            serversReturned: result.servers.length,
-            toolsReturned: result.tools.length,
-            totalServersBefore: result.metadata.totalServersBeforeFilter,
-            totalToolsBefore: result.metadata.totalToolsBeforeFilter,
-            filterMode: result.metadata.filterMode,
-            durationMs,
-            confidenceScore: result.metadata.confidenceScore,
-            timeoutOccurred: result.metadata.timeoutOccurred,
-        };
-        this.logger.debug("[smart-filter] Telemetry:", JSON.stringify(telemetry));
-    }
+// ── Shared helpers (used by both standalone functions and legacy class) ───────
+/** Tokenize text into lowercase words, stripping punctuation. */
+export function tokenize(text) {
+    return text
+        .toLowerCase()
+        .replace(/[^\w\s]/g, " ")
+        .split(/\s+/)
+        .filter(word => word.length > 0);
+}
+function extractMeaningfulContent(content) {
+    const cleaned = content
+        .replace(/\[.*?\]/g, "")
+        .replace(/^\s*[>]*\s*/gm, "")
+        .replace(/^\s*[-*•]\s*/gm, "")
+        .trim();
+    const noisePatterns = [
+        /^(yes|no|ok|okay|sure|thanks?|thank you)\.?$/i,
+        /^(do it|go ahead|proceed)\.?$/i,
+        /^(yes,?\s+(do it|go ahead|proceed))\.?$/i,
+        /^\?+$/,
+        /^\.+$/,
+        /^!+$/,
+    ];
+    if (noisePatterns.some(pattern => pattern.test(cleaned))) {
+        return "";
+    }
+    return cleaned
+        .replace(/\s+please\.?$/i, "")
+        .replace(/\s+thanks?\.?$/i, "")
+        .trim();
+}
+/** Extract meaningful intent from last 1-3 user turns. */
+export function synthesizeQuery(userTurns) {
+    if (!userTurns || userTurns.length === 0) {
+        return "";
+    }
+    const recentTurns = userTurns
+        .slice(-3)
+        .reverse()
+        .map(turn => turn.content.trim());
+    for (const content of recentTurns) {
+        const cleanedQuery = extractMeaningfulContent(content);
+        if (cleanedQuery.length >= 3) {
+            return cleanedQuery;
+        }
+    }
+    const combined = recentTurns
+        .map(content => extractMeaningfulContent(content))
+        .filter(content => content.length > 0)
+        .join(" ")
+        .trim();
+    return combined.length >= 3 ? combined : "";
 }
 // ── Standalone utility exports (for testing and external use) ────────────────
 const MAX_KEYWORDS = 30;
@@ -424,10 +92,10 @@ export function validateKeywords(raw) {
 export function scoreServer(queryTokens, serverName, description, keywords) {
     if (queryTokens.length === 0)
         return 0;
-    const descTokens = new Set(SmartFilter.tokenize(description));
-    for (const t of SmartFilter.tokenize(serverName))
+    const descTokens = new Set(tokenize(description));
+    for (const t of tokenize(serverName))
         descTokens.add(t);
-    const kwTokens = new Set(validateKeywords(keywords).flatMap(kw => SmartFilter.tokenize(kw)));
+    const kwTokens = new Set(validateKeywords(keywords).flatMap(kw => tokenize(kw)));
     let descMatches = 0;
     let kwOnlyMatches = 0;
     for (const qt of queryTokens) {
@@ -503,14 +171,14 @@ export function filterServers(servers, userTurns, config, logger) {
         const merged = { ...DEFAULTS, ...config };
         const startTime = Date.now();
         const userTurnObjects = userTurns.map(content => ({ content, timestamp: Date.now() }));
-        const query = SmartFilter.synthesizeQuery(userTurnObjects) || null;
+        const query = synthesizeQuery(userTurnObjects) || null;
         if (!query)
             return showAll("no-query");
         if (Date.now() - startTime > merged.timeoutMs) {
             logger?.warn("[smart-filter] Timeout during query synthesis");
             return showAll("timeout", query);
         }
-        const queryTokens = SmartFilter.tokenize(query);
+        const queryTokens = tokenize(query);
         if (queryTokens.length === 0)
             return showAll("no-query");
         const scores = scoreAllServers(queryTokens, servers);

package/dist/src/update-checker.d.ts

@@ -4,6 +4,7 @@ export interface UpdateInfo {
     latestVersion: string;
     updateAvailable: boolean;
     updateCommand: string;
+    updateCommandParts: string[];
 }
 /**
  * Check npm registry for a newer version. Non-blocking, best-effort.

package/dist/src/update-checker.js

@@ -11,7 +11,8 @@ export async function checkForUpdate(logger) {
     if (cachedUpdateInfo)
         return cachedUpdateInfo;
     const current = PACKAGE_VERSION;
-    const updateCmd = `npm update -g ${PACKAGE_NAME}`;
+    const updateCmdParts = ["npm", "update", "-g", PACKAGE_NAME];
+    const updateCmd = updateCmdParts.join(" ");
     try {
         const latest = await npmViewVersion(logger);
         const updateAvailable = latest !== current && isNewer(latest, current);
@@ -20,6 +21,7 @@ export async function checkForUpdate(logger) {
             latestVersion: latest,
             updateAvailable,
             updateCommand: updateCmd,
+            updateCommandParts: updateCmdParts,
         };
         if (updateAvailable) {
             logger.info(`[mcp-bridge] Update available: ${current} → ${latest}`);
@@ -35,6 +37,7 @@ export async function checkForUpdate(logger) {
             latestVersion: current,
             updateAvailable: false,
             updateCommand: updateCmd,
+            updateCommandParts: updateCmdParts,
         };
     }
     return cachedUpdateInfo;
@@ -66,8 +69,8 @@ export async function runUpdate(logger) {
     }
     logger.info(`[mcp-bridge] Running update: ${info.updateCommand}`);
     try {
-        const parts = info.updateCommand.split(/\s+/);
-        const output = await execFileAsync(parts[0], parts.slice(1), 60_000);
+        const [cmd, ...args] = info.updateCommandParts;
+        const output = await execFileAsync(cmd, args, 60_000);
         // Invalidate cache so next check re-fetches
         cachedUpdateInfo = null;
         noticeDelivered = false;
@@ -87,9 +90,7 @@ export async function runUpdate(logger) {
 // --- helpers ---
 function npmViewVersion(_logger) {
     return new Promise((resolve, reject) => {
-        const timeout = setTimeout(() => reject(new Error("npm view timed out")), 10_000);
-        execFile("npm", ["view", PACKAGE_NAME, "version"], { encoding: "utf-8" }, (err, stdout) => {
-            clearTimeout(timeout);
+        execFile("npm", ["view", PACKAGE_NAME, "version"], { encoding: "utf-8", timeout: 10_000 }, (err, stdout) => {
             if (err)
                 return reject(err);
             const ver = (stdout ?? "").trim();
@@ -109,9 +110,7 @@ function npmViewVersionSync(_logger) {
 }
 function execFileAsync(file, args, timeoutMs) {
     return new Promise((resolve, reject) => {
-        const timeout = setTimeout(() => reject(new Error(`Command timed out after ${timeoutMs}ms`)), timeoutMs);
         execFile(file, args, { encoding: "utf-8", timeout: timeoutMs }, (err, stdout, stderr) => {
-            clearTimeout(timeout);
             if (err)
                 return reject(new Error(`${err.message}\n${stderr ?? ""}`));
             resolve(stdout ?? "");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiwerk/mcp-bridge",
-  "version": "1.6.2",
+  "version": "1.7.0",
   "description": "Standalone MCP server that multiplexes multiple MCP servers into one interface",
   "type": "module",
   "main": "./dist/src/index.js",

package/scripts/install-server.sh

@@ -135,12 +135,14 @@ if [[ "$REMOVE" == "true" ]]; then
 
     # Check if server exists in config
     HAS_SERVER=$(python3 -c "
-import json
-with open('$MCP_BRIDGE_JSON') as f:
+import json, sys
+server_name = sys.argv[1]
+config_path = sys.argv[2]
+with open(config_path) as f:
     cfg = json.load(f)
 servers = cfg.get('servers',{})
-print('yes' if '$SERVER_NAME' in servers else 'no')
-" 2>/dev/null)
+print('yes' if server_name in servers else 'no')
+" "$SERVER_NAME" "$MCP_BRIDGE_JSON" 2>/dev/null)
 
     if [[ "$HAS_SERVER" != "yes" ]]; then
         echo "ℹ️  Server '$SERVER_NAME' not found in config. Nothing to remove."
@@ -154,17 +156,19 @@ print('yes' if '$SERVER_NAME' in servers else 'no')
 
     # Remove server entry from config (keep servers/<name>/ directory)
     python3 -c "
-import json
-with open('$MCP_BRIDGE_JSON') as f:
+import json, sys
+server_name = sys.argv[1]
+config_path = sys.argv[2]
+with open(config_path) as f:
     cfg = json.load(f)
 servers = cfg.get('servers', {})
-del servers['$SERVER_NAME']
-with open('$MCP_BRIDGE_JSON', 'w') as f:
+del servers[server_name]
+with open(config_path, 'w') as f:
     json.dump(cfg, f, indent=2)
     f.write('\n')
-print('✅ Removed $SERVER_NAME from config')
-print('ℹ️  Server recipe kept in servers/$SERVER_NAME/ (reinstall anytime)')
-" 2>/dev/null
+print(f'✅ Removed {server_name} from config')
+print(f'ℹ️  Server recipe kept in servers/{server_name}/ (reinstall anytime)')
+" "$SERVER_NAME" "$MCP_BRIDGE_JSON" 2>/dev/null
 
     # Remove env var from .env if exists
     if [[ -f "$ENV_VARS_FILE" ]] && [[ -s "$ENV_VARS_FILE" ]] && [[ -f "$ENV_FILE" ]]; then