prism-mcp-server 20.0.7 → 20.0.8

package/dist/agent/mcpBridge.js

@@ -1,234 +0,0 @@
-/**
- * MCP Bridge — Connect external MCP servers to the Prism Agent Terminal
- * ======================================================================
- *
- * Allows `prism prompt` to discover and connect to MCP servers configured
- * in standard config files (.cursor/mcp.json, .vscode/mcp.json) or via
- * manual `prism prompt --mcp <command>`.
- *
- * Connected MCP server tools are automatically injected into Gemini's
- * function declarations so the AI can call them during conversation.
- *
- * Config format (standard MCP convention):
- * ```json
- * {
- *   "mcpServers": {
- *     "my-server": {
- *       "command": "node",
- *       "args": ["path/to/server.js"],
- *       "env": { "API_KEY": "..." }
- *     }
- *   }
- * }
- * ```
- */
-import * as fs from "fs";
-import * as path from "path";
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
-import { SchemaType } from "@google/generative-ai";
-// ---------------------------------------------------------------------------
-// MCP Bridge
-// ---------------------------------------------------------------------------
-export class McpBridge {
-    connections = new Map();
-    /**
-     * Connect to an MCP server via stdio.
-     */
-    async connect(serverName, config) {
-        // Don't double-connect
-        if (this.connections.has(serverName)) {
-            const existing = this.connections.get(serverName);
-            return existing.tools;
-        }
-        const client = new Client({ name: "prism-agent", version: "12.0.0" }, { capabilities: {} });
-        const transport = new StdioClientTransport({
-            command: config.command,
-            args: config.args || [],
-            env: { ...process.env, ...(config.env || {}) },
-        });
-        await client.connect(transport);
-        // Discover tools
-        const toolsResult = await client.listTools();
-        const tools = toolsResult.tools.map((t) => ({
-            name: t.name,
-            description: t.description || "",
-            inputSchema: t.inputSchema,
-        }));
-        this.connections.set(serverName, { name: serverName, client, transport, tools });
-        return tools;
-    }
-    /**
-     * Call a tool on a connected MCP server.
-     */
-    async callTool(toolName, args) {
-        // Find which server owns this tool
-        for (const conn of this.connections.values()) {
-            const tool = conn.tools.find((t) => t.name === toolName);
-            if (!tool)
-                continue;
-            const result = await conn.client.callTool({
-                name: toolName,
-                arguments: args,
-            });
-            if (result.isError) {
-                const errText = result.content
-                    .filter((c) => c.type === "text")
-                    .map((c) => c.text)
-                    .join("\n");
-                return `Error: ${errText || "Tool returned an error"}`;
-            }
-            // Extract text content
-            const texts = result.content
-                .filter((c) => c.type === "text")
-                .map((c) => c.text || "");
-            return texts.join("\n") || "(no output)";
-        }
-        return `Error: No MCP server has tool "${toolName}"`;
-    }
-    /**
-     * Get all tools from all connected servers as Gemini FunctionDeclarations.
-     * Prefixes tool names with server name to avoid collisions.
-     */
-    getGeminiFunctionDeclarations() {
-        const declarations = [];
-        for (const conn of this.connections.values()) {
-            for (const tool of conn.tools) {
-                // Convert JSON Schema to Gemini's FunctionDeclaration format
-                declarations.push({
-                    name: tool.name,
-                    description: `[MCP:${conn.name}] ${tool.description}`,
-                    parameters: convertJsonSchemaToGemini(tool.inputSchema),
-                });
-            }
-        }
-        return declarations;
-    }
-    /**
-     * Check if a tool name belongs to an MCP server.
-     */
-    hasToolName(toolName) {
-        for (const conn of this.connections.values()) {
-            if (conn.tools.some((t) => t.name === toolName))
-                return true;
-        }
-        return false;
-    }
-    /**
-     * List all connected servers and their tools.
-     */
-    listServers() {
-        return Array.from(this.connections.values()).map((c) => ({
-            name: c.name,
-            toolCount: c.tools.length,
-            tools: c.tools.map((t) => t.name),
-        }));
-    }
-    /**
-     * Disconnect all servers gracefully.
-     */
-    async disconnectAll() {
-        for (const conn of this.connections.values()) {
-            try {
-                await conn.client.close();
-            }
-            catch {
-                // Ignore cleanup errors
-            }
-        }
-        this.connections.clear();
-    }
-}
-// ---------------------------------------------------------------------------
-// Config Discovery
-// ---------------------------------------------------------------------------
-/**
- * Search for MCP server configurations in standard locations.
- * Returns merged config from all discovered files.
- */
-export function discoverMcpConfigs(cwd = process.cwd()) {
-    const configs = {};
-    // Search paths in order of priority (later overrides earlier)
-    const searchPaths = [
-        // Global configs
-        path.join(process.env.HOME || "~", ".cursor", "mcp.json"),
-        path.join(process.env.HOME || "~", ".vscode", "mcp.json"),
-        // Project-level configs (higher priority)
-        path.join(cwd, ".cursor", "mcp.json"),
-        path.join(cwd, ".vscode", "mcp.json"),
-        path.join(cwd, "mcp.json"),
-    ];
-    for (const configPath of searchPaths) {
-        try {
-            if (!fs.existsSync(configPath))
-                continue;
-            const raw = fs.readFileSync(configPath, "utf-8");
-            const parsed = JSON.parse(raw);
-            // Support both { mcpServers: {...} } and { servers: {...} } formats
-            const servers = parsed.mcpServers || parsed.servers || {};
-            for (const [name, config] of Object.entries(servers)) {
-                const c = config;
-                if (c.command) {
-                    configs[name] = c;
-                }
-            }
-        }
-        catch {
-            // Skip invalid config files
-        }
-    }
-    return configs;
-}
-// ---------------------------------------------------------------------------
-// Schema Conversion
-// ---------------------------------------------------------------------------
-/**
- * Convert a JSON Schema object to Gemini's FunctionDeclaration parameters format.
- * Gemini uses its own SchemaType enum instead of standard JSON Schema type strings.
- */
-function convertJsonSchemaToGemini(schema) {
-    if (!schema || typeof schema !== "object") {
-        return { type: SchemaType.OBJECT, properties: {} };
-    }
-    const properties = {};
-    const schemaProps = (schema.properties || {});
-    for (const [key, prop] of Object.entries(schemaProps)) {
-        properties[key] = convertPropertyToGemini(prop);
-    }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- dynamic JSON Schema conversion
-    return {
-        type: SchemaType.OBJECT,
-        properties,
-        required: schema.required || [],
-    };
-}
-function convertPropertyToGemini(prop) {
-    const typeMap = {
-        string: SchemaType.STRING,
-        number: SchemaType.NUMBER,
-        integer: SchemaType.INTEGER,
-        boolean: SchemaType.BOOLEAN,
-        array: SchemaType.ARRAY,
-        object: SchemaType.OBJECT,
-    };
-    const result = {
-        type: typeMap[prop.type] || SchemaType.STRING,
-    };
-    if (prop.description)
-        result.description = prop.description;
-    if (prop.enum)
-        result.enum = prop.enum;
-    // Handle array items
-    if (prop.type === "array" && prop.items) {
-        result.items = convertPropertyToGemini(prop.items);
-    }
-    // Handle nested objects
-    if (prop.type === "object" && prop.properties) {
-        const nestedProps = {};
-        for (const [k, v] of Object.entries(prop.properties)) {
-            nestedProps[k] = convertPropertyToGemini(v);
-        }
-        result.properties = nestedProps;
-    }
-    return result;
-}