@prompd/cli 0.4.9 → 0.4.11

package/dist/lib/mcp.js

@@ -34,13 +34,113 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PrompdMCPServer = void 0;
+// Import MCP SDK dynamically since it's an ES module.
+// Use indirect import() to prevent TypeScript from converting to require() in CJS output.
+const dynamicImport = new Function('specifier', 'return import(specifier)');
 const fs = __importStar(require("fs-extra"));
 const path = __importStar(require("path"));
+const os = __importStar(require("os"));
 const glob = __importStar(require("glob"));
 const parser_1 = require("./parser");
 const executor_1 = require("./executor");
+const compiler_1 = require("./compiler");
+const config_1 = require("./config");
+const registry_1 = require("./registry");
 const workflow_1 = require("./workflow");
 const security_1 = require("./security");
+/**
+ * Definitions for built-in MCP tools that wrap CLI operations.
+ * These are always available regardless of what .prmd files are registered.
+ */
+const BUILTIN_TOOLS = [
+    {
+        name: 'prompd_compile',
+        description: 'Compile a .prmd file or package reference using the 6-stage compilation pipeline. Returns the rendered prompt with parameters substituted and templates processed.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                source: { type: 'string', description: 'Path to .prmd file or package reference (@namespace/package@version)' },
+                format: { type: 'string', description: 'Output format: markdown | provider-json:openai | provider-json:anthropic', default: 'markdown' },
+                parameters: { type: 'object', description: 'Key-value parameters to substitute in the prompt', additionalProperties: true },
+            },
+            required: ['source'],
+        },
+    },
+    {
+        name: 'prompd_run',
+        description: 'Execute a .prmd prompt file with an LLM provider and return the response. Requires a configured API key for the chosen provider.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                file: { type: 'string', description: 'Path to the .prmd file to execute' },
+                provider: { type: 'string', description: 'LLM provider: openai, anthropic, ollama' },
+                model: { type: 'string', description: 'Model name (e.g., gpt-4, claude-3-sonnet)' },
+                parameters: { type: 'object', description: 'Key-value parameters for the prompt', additionalProperties: true },
+            },
+            required: ['file'],
+        },
+    },
+    {
+        name: 'prompd_search',
+        description: 'Search the Prompd package registry for available packages matching a query.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: { type: 'string', description: 'Search query string' },
+                limit: { type: 'number', description: 'Maximum number of results (default: 20)' },
+                registry: { type: 'string', description: 'Specific registry name to search (optional)' },
+            },
+            required: ['query'],
+        },
+    },
+    {
+        name: 'prompd_show',
+        description: 'Show the structure, metadata, and parameters of a .prmd file. Useful for understanding what a prompt expects before calling it.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                file: { type: 'string', description: 'Path to the .prmd file to inspect' },
+            },
+            required: ['file'],
+        },
+    },
+    {
+        name: 'prompd_list',
+        description: 'List available .prmd files in a directory (defaults to current directory). Returns file names, descriptions, and parameters.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                directory: { type: 'string', description: 'Directory to search for .prmd files (default: current directory)' },
+                detailed: { type: 'boolean', description: 'Include full details for each file' },
+            },
+            required: [],
+        },
+    },
+    {
+        name: 'prompd_explain',
+        description: 'Get detailed information about a .prmd file, .pdpkg package, or registry package (@namespace/name). Shows metadata, parameters, sections, file info, and available versions.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                target: { type: 'string', description: '.prmd file path, .pdpkg package path, or registry package (@namespace/name)' },
+                detailed: { type: 'boolean', description: 'Show extended details' },
+                sections: { type: 'boolean', description: 'Show section content previews (for .prmd files)' },
+            },
+            required: ['target'],
+        },
+    },
+    {
+        name: 'prompd_validate',
+        description: 'Validate a .prmd file for syntax errors, structural issues, and best practice violations. Returns errors, warnings, and info messages.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                file: { type: 'string', description: 'Path to the .prmd file to validate' },
+            },
+            required: ['file'],
+        },
+    },
+];
 class PrompdMCPServer {
     constructor(config) {
         this.config = config;
@@ -56,7 +156,7 @@ class PrompdMCPServer {
     }
     async initializeMCP() {
         // Dynamic import of MCP SDK
-        const serverModule = await Promise.resolve().then(() => __importStar(require('@modelcontextprotocol/sdk/server/index.js')));
+        const serverModule = await dynamicImport('@modelcontextprotocol/sdk/server/index.js');
         // Initialize MCP server
         this.server = new serverModule.Server({
             name: this.config.name || 'prompd-mcp-server',
@@ -70,19 +170,29 @@ class PrompdMCPServer {
     }
     async setupHandlers() {
         // Dynamic import for schemas
-        const typesModule = await Promise.resolve().then(() => __importStar(require('@modelcontextprotocol/sdk/types.js')));
+        const typesModule = await dynamicImport('@modelcontextprotocol/sdk/types.js');
         // List available tools
         this.server.setRequestHandler(typesModule.ListToolsRequestSchema, async () => {
             const tools = [];
-            // Add prompt tools
-            for (const [name, prompd] of this.registeredTools.entries()) {
+            // Add built-in CLI tools first
+            for (const builtin of BUILTIN_TOOLS) {
+                tools.push({
+                    name: builtin.name,
+                    description: builtin.description,
+                    inputSchema: builtin.inputSchema,
+                });
+            }
+            // Add registered prompt tools
+            for (const [name, entry] of this.registeredTools.entries()) {
+                const desc = entry.prompd.metadata.description || `Execute ${name} prompt`;
+                const templateNote = this.config.execute ? '' : ' Returns a fully rendered prompt for the LLM to follow as instructions.';
                 tools.push({
                     name,
-                    description: prompd.metadata.description || `Execute ${name} prompt`,
-                    inputSchema: this.createInputSchema(prompd)
+                    description: desc + templateNote,
+                    inputSchema: this.createInputSchema(entry.prompd)
                 });
             }
-            // Add workflow tools
+            // Add registered workflow tools
             for (const [name, workflow] of this.registeredWorkflows.entries()) {
                 tools.push({
                     name,
@@ -102,7 +212,17 @@ class PrompdMCPServer {
                 throw new Error(`Security validation failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
             }
             const { name, arguments: args } = request.params;
-            // Sanitize and validate tool name
+            // Security: Check request size
+            const requestSize = JSON.stringify(args).length;
+            if (this.config.maxRequestSize && requestSize > this.config.maxRequestSize) {
+                throw new Error('Request too large');
+            }
+            // Check if this is a built-in tool
+            const builtinResult = await this.handleBuiltinTool(name, args || {});
+            if (builtinResult !== null) {
+                return builtinResult;
+            }
+            // Sanitize and validate tool name for registered tools
             let sanitizedName;
             try {
                 sanitizedName = security_1.SecurityManager.sanitizeToolName(name);
@@ -120,11 +240,6 @@ class PrompdMCPServer {
             if (this.config.allowedTools && !this.config.allowedTools.includes(sanitizedName)) {
                 throw new Error(`Tool '${sanitizedName}' not allowed`);
             }
-            // Security: Check request size
-            const requestSize = JSON.stringify(args).length;
-            if (this.config.maxRequestSize && requestSize > this.config.maxRequestSize) {
-                throw new Error('Request too large');
-            }
             try {
                 if (isWorkflow) {
                     // Execute workflow
@@ -154,11 +269,11 @@ class PrompdMCPServer {
                 }
                 else {
                     // Execute prompt
-                    const prompd = this.registeredTools.get(sanitizedName);
-                    this.validateParameters(prompd, args || {});
+                    const entry = this.registeredTools.get(sanitizedName);
+                    this.validateParameters(entry.prompd, args || {});
                     if (this.config.execute && this.executor) {
-                        // Execute with LLM and return response
-                        const result = await this.executeWithLLM(prompd, args || {});
+                        // Execute with LLM using original file path (compiler resolves includes/inheritance)
+                        const result = await this.executeWithLLM(entry.filePath, args || {});
                         return {
                             content: [
                                 {
@@ -169,13 +284,13 @@ class PrompdMCPServer {
                         };
                     }
                     else {
-                        // Return rendered prompt template
-                        const renderedPrompt = this.renderPrompt(prompd, args || {});
+                        // Compile with full pipeline (Nunjucks, includes, inheritance)
+                        const renderedPrompt = await this.compilePrompt(entry.filePath, args || {});
                         return {
                             content: [
                                 {
                                     type: 'text',
-                                    text: renderedPrompt
+                                    text: `[INSTRUCTIONS: Use the following rendered prompt as your guide to complete the user's request.]\n\n${renderedPrompt}`
                                 }
                             ]
                         };
@@ -187,6 +302,297 @@ class PrompdMCPServer {
             }
         });
     }
+    /**
+     * Handle built-in CLI tool calls. Returns null if the tool name doesn't match a built-in.
+     */
+    async handleBuiltinTool(name, args) {
+        switch (name) {
+            case 'prompd_compile':
+                return this.handleCompile(args);
+            case 'prompd_run':
+                return this.handleRun(args);
+            case 'prompd_search':
+                return this.handleSearch(args);
+            case 'prompd_show':
+                return this.handleShow(args);
+            case 'prompd_list':
+                return this.handleList(args);
+            case 'prompd_explain':
+                return this.handleExplain(args);
+            case 'prompd_validate':
+                return this.handleValidate(args);
+            default:
+                return null;
+        }
+    }
+    textResult(text) {
+        return { content: [{ type: 'text', text }] };
+    }
+    async handleCompile(args) {
+        const source = args.source;
+        if (!source)
+            throw new Error('source is required');
+        const compiler = new compiler_1.PrompdCompiler();
+        const result = await compiler.compile(source, {
+            outputFormat: args.format || 'markdown',
+            parameters: args.parameters || {},
+        });
+        return this.textResult(typeof result === 'string' ? result : JSON.stringify(result, null, 2));
+    }
+    async handleRun(args) {
+        const file = args.file;
+        if (!file)
+            throw new Error('file is required');
+        const configManager = config_1.ConfigManager.getInstance();
+        const config = await configManager.loadConfig();
+        const provider = args.provider || this.config.provider || configManager.getDefaultProvider(config);
+        const model = args.model || this.config.model || configManager.getDefaultModel(provider, config);
+        const executor = new executor_1.PrompdExecutor();
+        const response = await executor.execute(file, {
+            provider,
+            model,
+            apiKey: this.config.apiKey,
+            params: args.parameters || {},
+        });
+        const responseText = response.response || response.content || 'No response received';
+        const result = { response: responseText, provider, model };
+        if (response.usage)
+            result.usage = response.usage;
+        return this.textResult(JSON.stringify(result, null, 2));
+    }
+    async handleSearch(args) {
+        const query = args.query;
+        if (!query)
+            throw new Error('query is required');
+        const client = new registry_1.RegistryClient(args.registry);
+        const results = await client.search({
+            query,
+            limit: args.limit || 20,
+        });
+        if (results.packages.length === 0) {
+            return this.textResult(`No packages found for: ${query}`);
+        }
+        const lines = [`Found ${results.packages.length} package(s) for "${query}":\n`];
+        for (const pkg of results.packages) {
+            lines.push(`${pkg.name} v${pkg.version}`);
+            lines.push(`  ${pkg.description || 'No description'}`);
+            if (pkg.author)
+                lines.push(`  Author: ${pkg.author}`);
+            lines.push('');
+        }
+        return this.textResult(lines.join('\n'));
+    }
+    async handleShow(args) {
+        const file = args.file;
+        if (!file)
+            throw new Error('file is required');
+        const parser = new parser_1.PrompdParser();
+        const prompd = await parser.parseFile(file);
+        const metadata = prompd.metadata;
+        const lines = [];
+        lines.push(`=== ${metadata.name || 'Unnamed'} ===`);
+        if (metadata.version)
+            lines.push(`Version: ${metadata.version}`);
+        if (metadata.description)
+            lines.push(`\nDescription:\n  ${metadata.description}\n`);
+        const allParams = [...(metadata.parameters || []), ...(metadata.variables || [])];
+        if (allParams.length > 0) {
+            lines.push('Parameters:');
+            for (const param of allParams) {
+                const required = param.required ? ' (required)' : '';
+                lines.push(`  - ${param.name} (${param.type})${required}`);
+                if (param.description)
+                    lines.push(`    ${param.description}`);
+                if (param.default !== undefined)
+                    lines.push(`    Default: ${JSON.stringify(param.default)}`);
+                if (param.pattern)
+                    lines.push(`    Pattern: ${param.pattern}`);
+                if (param.enum)
+                    lines.push(`    Enum: ${param.enum.join(', ')}`);
+            }
+        }
+        const sectionKeys = Object.keys(prompd.sections);
+        if (sectionKeys.length > 0) {
+            lines.push('\nSections:');
+            for (const key of sectionKeys)
+                lines.push(`  - #${key}`);
+        }
+        return this.textResult(lines.join('\n'));
+    }
+    async handleList(args) {
+        const detailed = args.detailed;
+        // When no directory specified, search both global and local cache dirs
+        const explicitDir = args.directory;
+        const searchDirs = [];
+        if (explicitDir) {
+            searchDirs.push(path.resolve(explicitDir));
+        }
+        else {
+            const globalCache = path.join(os.homedir(), '.prompd', 'cache');
+            const localCache = path.join(process.cwd(), '.prompd', 'cache');
+            if (fs.existsSync(globalCache))
+                searchDirs.push(globalCache);
+            if (fs.existsSync(localCache) && localCache !== globalCache)
+                searchDirs.push(localCache);
+            // Also search cwd if it has .prmd files directly
+            searchDirs.push(process.cwd());
+        }
+        const files = [];
+        const seen = new Set();
+        for (const dir of searchDirs) {
+            const pattern = path.join(dir, '**/*.prmd').replace(/\\/g, '/');
+            for (const f of glob.sync(pattern)) {
+                const normalized = path.resolve(f);
+                if (!seen.has(normalized)) {
+                    seen.add(normalized);
+                    files.push(f);
+                }
+            }
+        }
+        if (files.length === 0) {
+            const searchedLabel = explicitDir ? path.resolve(explicitDir) : searchDirs.join(', ');
+            return this.textResult(`No .prmd files found in ${searchedLabel}`);
+        }
+        const parser = new parser_1.PrompdParser();
+        const searchedLabel = explicitDir ? path.resolve(explicitDir) : searchDirs.join(', ');
+        const lines = [`Found ${files.length} .prmd file(s) in ${searchedLabel}:\n`];
+        for (const file of files) {
+            try {
+                const prompd = await parser.parseFile(file);
+                const metadata = prompd.metadata;
+                const name = metadata.name || path.basename(file, '.prmd');
+                if (detailed) {
+                    lines.push(`${name}`);
+                    lines.push(`  File: ${file}`);
+                    if (metadata.description)
+                        lines.push(`  Description: ${metadata.description}`);
+                    if (metadata.version)
+                        lines.push(`  Version: ${metadata.version}`);
+                    if (metadata.parameters && metadata.parameters.length > 0) {
+                        lines.push(`  Parameters: ${metadata.parameters.map(p => p.name).join(', ')}`);
+                    }
+                    lines.push('');
+                }
+                else {
+                    const desc = metadata.description
+                        ? (metadata.description.length > 50 ? metadata.description.substring(0, 47) + '...' : metadata.description)
+                        : '';
+                    lines.push(`  ${name} - ${desc}`);
+                }
+            }
+            catch {
+                lines.push(`  ${path.basename(file, '.prmd')} - (parse error)`);
+            }
+        }
+        return this.textResult(lines.join('\n'));
+    }
+    async handleExplain(args) {
+        const target = args.target;
+        if (!target)
+            throw new Error('target is required');
+        const lines = [];
+        if (target.endsWith('.prmd')) {
+            // Explain .prmd file
+            if (!await fs.pathExists(target))
+                throw new Error(`File not found: ${target}`);
+            const parser = new parser_1.PrompdParser();
+            const prompd = await parser.parseFile(target);
+            const stats = await fs.stat(target);
+            lines.push(`File: ${path.basename(target)}`);
+            lines.push(`Path: ${path.resolve(target)}\n`);
+            lines.push('Metadata:');
+            lines.push(`  ID: ${prompd.metadata.id}`);
+            if (prompd.metadata.name)
+                lines.push(`  Name: ${prompd.metadata.name}`);
+            if (prompd.metadata.version)
+                lines.push(`  Version: ${prompd.metadata.version}`);
+            if (prompd.metadata.description)
+                lines.push(`  Description: ${prompd.metadata.description}`);
+            lines.push('');
+            const params = prompd.metadata.parameters || [];
+            if (params.length > 0) {
+                lines.push('Parameters:');
+                for (const param of params) {
+                    const required = param.required ? 'required' : 'optional';
+                    const defaultVal = param.default !== undefined ? ` (default: ${JSON.stringify(param.default)})` : '';
+                    lines.push(`  - ${param.name} (${param.type}) ${required}${defaultVal}`);
+                    if (param.description)
+                        lines.push(`    ${param.description}`);
+                }
+                lines.push('');
+            }
+            if (args.sections && Object.keys(prompd.sections).length > 0) {
+                lines.push('Sections:');
+                for (const section of Object.keys(prompd.sections))
+                    lines.push(`  - ${section}`);
+                lines.push('');
+            }
+            lines.push('File Info:');
+            lines.push(`  Size: ${stats.size} bytes`);
+            lines.push(`  Modified: ${stats.mtime.toISOString()}`);
+        }
+        else if (target.startsWith('@') && target.includes('/')) {
+            // Explain registry package
+            const client = new registry_1.RegistryClient();
+            const info = await client.getPackageInfo(target);
+            const versions = await client.getPackageVersions(target);
+            lines.push(`Package: ${target}\n`);
+            if (info.description)
+                lines.push(`${info.description}\n`);
+            lines.push('Package Info:');
+            lines.push(`  Name: ${info.name}`);
+            if (info.version)
+                lines.push(`  Latest Version: ${info.version}`);
+            if (info.author)
+                lines.push(`  Author: ${info.author}`);
+            lines.push('');
+            if (versions && versions.length > 0) {
+                const sorted = versions.sort((a, b) => b.localeCompare(a, undefined, { numeric: true, sensitivity: 'base' }));
+                const display = args.detailed ? sorted : sorted.slice(0, 10);
+                lines.push('Available Versions:');
+                display.forEach((v, i) => {
+                    lines.push(`  ${i === 0 ? '(latest) ' : ''}${v}`);
+                });
+                if (!args.detailed && sorted.length > 10) {
+                    lines.push(`  ... and ${sorted.length - 10} more`);
+                }
+            }
+        }
+        else {
+            throw new Error('Target must be a .prmd file or registry package (@namespace/name)');
+        }
+        return this.textResult(lines.join('\n'));
+    }
+    async handleValidate(args) {
+        const file = args.file;
+        if (!file)
+            throw new Error('file is required');
+        const parser = new parser_1.PrompdParser();
+        const issues = await parser.validateFile(file);
+        if (issues.length === 0) {
+            return this.textResult(`${file} is valid - no issues found.`);
+        }
+        const errors = issues.filter(i => i.level === 'error');
+        const warnings = issues.filter(i => i.level === 'warning');
+        const info = issues.filter(i => i.level === 'info');
+        const lines = [];
+        if (errors.length > 0) {
+            lines.push(`ERRORS (${errors.length}):`);
+            for (const issue of errors)
+                lines.push(`  - ${issue.message}`);
+        }
+        if (warnings.length > 0) {
+            lines.push(`WARNINGS (${warnings.length}):`);
+            for (const issue of warnings)
+                lines.push(`  - ${issue.message}`);
+        }
+        if (info.length > 0) {
+            lines.push(`INFO (${info.length}):`);
+            for (const issue of info)
+                lines.push(`  - ${issue.message}`);
+        }
+        return this.textResult(lines.join('\n'));
+    }
     createInputSchema(prompd) {
         const properties = {};
         const required = [];
@@ -295,64 +701,28 @@ class PrompdMCPServer {
             default: return true;
         }
     }
-    renderPrompt(prompd, args) {
-        let rendered = prompd.content;
-        // Apply defaults for missing parameters
-        const allParams = [
-            ...(prompd.metadata.parameters || []),
-            ...(prompd.metadata.variables || [])
-        ];
-        const finalArgs = { ...args };
-        for (const param of allParams) {
-            if (finalArgs[param.name] === undefined && param.default !== undefined) {
-                finalArgs[param.name] = param.default;
-            }
-        }
-        // Simple parameter substitution
-        for (const [key, value] of Object.entries(finalArgs)) {
-            const placeholder = `{${key}}`;
-            rendered = rendered.replace(new RegExp(placeholder, 'g'), String(value));
-        }
-        return rendered;
+    async compilePrompt(filePath, args) {
+        const compiler = new compiler_1.PrompdCompiler();
+        const result = await compiler.compile(filePath, {
+            outputFormat: 'markdown',
+            parameters: args,
+        });
+        return typeof result === 'string' ? result : JSON.stringify(result, null, 2);
     }
-    async executeWithLLM(prompd, args) {
+    async executeWithLLM(filePath, args) {
         if (!this.executor) {
             throw new Error('Executor not initialized');
         }
-        // Create secure temporary file for execution
-        const tempFile = security_1.SecurityManager.createSecureTempPath('prompd-exec', '.prmd');
-        const prompdContent = this.reconstructPrompdFile(prompd);
-        // Create secure execution context
-        const { tempDir, cleanup } = await security_1.SecurityManager.createSecureExecutionContext();
-        try {
-            // Ensure temp directory exists
-            await fs.ensureDir(path.dirname(tempFile));
-            // Write with restrictive permissions
-            await fs.writeFile(tempFile, prompdContent, { mode: 0o600 });
-            const executeOptions = {
-                provider: this.config.provider || 'openai',
-                model: this.config.model || 'gpt-4',
-                apiKey: this.config.apiKey,
-                params: security_1.SecurityManager.sanitizeParameters(args)
-            };
-            const result = await this.executor.execute(tempFile, executeOptions);
-            return result;
-        }
-        finally {
-            // Clean up temp files and directory
-            try {
-                await fs.remove(tempFile);
-                await cleanup();
-            }
-            catch (error) {
-                console.warn('Failed to cleanup temporary files:', error);
-            }
-        }
-    }
-    reconstructPrompdFile(prompd) {
-        const yaml = require('yaml');
-        const frontmatter = yaml.stringify(prompd.metadata);
-        return `---\n${frontmatter}---\n\n${prompd.content}`;
+        const executeOptions = {
+            provider: this.config.provider || 'openai',
+            model: this.config.model || 'gpt-4',
+            apiKey: this.config.apiKey,
+            params: security_1.SecurityManager.sanitizeParameters(args)
+        };
+        // Execute directly from the original file — the executor runs
+        // the full compiler pipeline internally, preserving relative paths
+        // for {% include %}, inherits:, context:, etc.
+        return await this.executor.execute(filePath, executeOptions);
     }
     async registerTool(name, prompdFile) {
         try {
@@ -362,7 +732,7 @@ class PrompdMCPServer {
             // Validate file size
             await security_1.SecurityManager.validateFileSize(validatedPath);
             const prompd = await this.parser.parseFile(validatedPath);
-            this.registeredTools.set(sanitizedName, prompd);
+            this.registeredTools.set(sanitizedName, { prompd, filePath: validatedPath });
         }
         catch (error) {
             throw new Error(`Failed to register tool '${name}': ${error instanceof Error ? error.message : 'Unknown error'}`);
@@ -376,7 +746,7 @@ class PrompdMCPServer {
             try {
                 const prompd = await this.parser.parseFile(file);
                 const toolName = prompd.metadata.name || path.basename(file, '.prmd');
-                this.registeredTools.set(toolName, prompd);
+                this.registeredTools.set(toolName, { prompd, filePath: file });
             }
             catch (error) {
                 console.warn(`Skipping invalid prompd file ${file}: ${error instanceof Error ? error.message : 'Unknown error'}`);
@@ -400,7 +770,7 @@ class PrompdMCPServer {
         // Initialize MCP components first
         await this.initializeMCP();
         // Dynamic import for transport
-        const stdioModule = await Promise.resolve().then(() => __importStar(require('@modelcontextprotocol/sdk/server/stdio.js')));
+        const stdioModule = await dynamicImport('@modelcontextprotocol/sdk/server/stdio.js');
         const transport = new stdioModule.StdioServerTransport();
         await this.server.connect(transport);
     }