@sochdb/sochdb 0.4.2 → 0.4.4

package/dist/esm/mcp/index.js

@@ -0,0 +1,28 @@
+"use strict";
+/**
+ * MCP (Model Context Protocol) Module
+ *
+ * Provides MCP server and client implementations for LLM agent integration.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.McpClient = exports.McpServer = void 0;
+__exportStar(require("./types"), exports);
+var server_1 = require("./server");
+Object.defineProperty(exports, "McpServer", { enumerable: true, get: function () { return server_1.McpServer; } });
+var client_1 = require("./client");
+Object.defineProperty(exports, "McpClient", { enumerable: true, get: function () { return client_1.McpClient; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbWNwL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQTs7OztHQUlHOzs7Ozs7Ozs7Ozs7Ozs7OztBQUVILDBDQUF3QjtBQUN4QixtQ0FBcUM7QUFBNUIsbUdBQUEsU0FBUyxPQUFBO0FBQ2xCLG1DQUFxQztBQUE1QixtR0FBQSxTQUFTLE9BQUEiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIE1DUCAoTW9kZWwgQ29udGV4dCBQcm90b2NvbCkgTW9kdWxlXG4gKiBcbiAqIFByb3ZpZGVzIE1DUCBzZXJ2ZXIgYW5kIGNsaWVudCBpbXBsZW1lbnRhdGlvbnMgZm9yIExMTSBhZ2VudCBpbnRlZ3JhdGlvbi5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL3R5cGVzJztcbmV4cG9ydCB7IE1jcFNlcnZlciB9IGZyb20gJy4vc2VydmVyJztcbmV4cG9ydCB7IE1jcENsaWVudCB9IGZyb20gJy4vY2xpZW50JztcbiJdfQ==

package/dist/esm/mcp/server.js

@@ -0,0 +1,244 @@
+"use strict";
+/**
+ * MCP Server Implementation
+ *
+ * SochDB MCP Server for exposing database operations to LLM agents.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.McpServer = void 0;
+/**
+ * MCP Server for SochDB
+ *
+ * Exposes database operations as MCP tools for LLM agents.
+ *
+ * @example
+ * ```typescript
+ * import { EmbeddedDatabase, McpServer } from '@sochdb/sochdb';
+ *
+ * const db = EmbeddedDatabase.open('./mydb');
+ * const server = new McpServer(db, {
+ *   name: 'sochdb-mcp',
+ *   version: '1.0.0',
+ *   capabilities: { tools: true, resources: true }
+ * });
+ *
+ * // List available tools
+ * const tools = server.listTools();
+ *
+ * // Execute a tool call
+ * const result = await server.callTool({
+ *   id: 'call_1',
+ *   name: 'db_get',
+ *   arguments: { key: 'user:123' }
+ * });
+ * ```
+ */
+class McpServer {
+    db;
+    config;
+    tools = new Map();
+    prompts = new Map();
+    customToolHandlers = new Map();
+    constructor(db, config) {
+        this.db = db;
+        this.config = config;
+        this.registerBuiltinTools();
+    }
+    /**
+     * Register built-in database tools
+     */
+    registerBuiltinTools() {
+        // Key-Value operations
+        this.registerTool({
+            name: 'db_get',
+            description: 'Get a value from the database by key',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    key: { type: 'string', description: 'The key to retrieve' },
+                },
+                required: ['key'],
+            },
+        }, async (args) => {
+            const value = await this.db.get(Buffer.from(args.key));
+            return value ? value.toString() : null;
+        });
+        this.registerTool({
+            name: 'db_put',
+            description: 'Store a value in the database',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    key: { type: 'string', description: 'The key to store' },
+                    value: { type: 'string', description: 'The value to store' },
+                },
+                required: ['key', 'value'],
+            },
+        }, async (args) => {
+            await this.db.put(Buffer.from(args.key), Buffer.from(args.value));
+            return { success: true };
+        });
+        this.registerTool({
+            name: 'db_delete',
+            description: 'Delete a key from the database',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    key: { type: 'string', description: 'The key to delete' },
+                },
+                required: ['key'],
+            },
+        }, async (args) => {
+            await this.db.delete(Buffer.from(args.key));
+            return { success: true };
+        });
+        this.registerTool({
+            name: 'db_scan',
+            description: 'Scan keys with a prefix',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    prefix: { type: 'string', description: 'The prefix to scan' },
+                    limit: { type: 'number', description: 'Maximum results', default: 100 },
+                },
+                required: ['prefix'],
+            },
+        }, async (args) => {
+            const results = [];
+            const limit = args.limit || 100;
+            let count = 0;
+            for await (const [keyBuffer, valueBuffer] of this.db.scanPrefix(Buffer.from(args.prefix))) {
+                if (count >= limit)
+                    break;
+                results.push({
+                    key: keyBuffer.toString(),
+                    value: valueBuffer.toString(),
+                });
+                count++;
+            }
+            return results;
+        });
+        this.registerTool({
+            name: 'db_stats',
+            description: 'Get database statistics',
+            inputSchema: {
+                type: 'object',
+                properties: {},
+            },
+        }, async () => {
+            const stats = await this.db.stats();
+            return {
+                memtableSizeBytes: stats.memtableSizeBytes.toString(),
+                walSizeBytes: stats.walSizeBytes.toString(),
+                activeTransactions: stats.activeTransactions,
+            };
+        });
+    }
+    /**
+     * Register a custom tool
+     */
+    registerTool(tool, handler) {
+        this.tools.set(tool.name, tool);
+        this.customToolHandlers.set(tool.name, handler);
+    }
+    /**
+     * Unregister a tool
+     */
+    unregisterTool(name) {
+        this.customToolHandlers.delete(name);
+        return this.tools.delete(name);
+    }
+    /**
+     * List all available tools
+     */
+    listTools() {
+        return Array.from(this.tools.values());
+    }
+    /**
+     * Call a tool
+     */
+    async callTool(call) {
+        const handler = this.customToolHandlers.get(call.name);
+        if (!handler) {
+            return {
+                id: call.id,
+                content: null,
+                isError: true,
+                errorMessage: `Tool not found: ${call.name}`,
+            };
+        }
+        try {
+            const content = await handler(call.arguments);
+            return {
+                id: call.id,
+                content,
+                isError: false,
+            };
+        }
+        catch (error) {
+            return {
+                id: call.id,
+                content: null,
+                isError: true,
+                errorMessage: error.message || 'Unknown error',
+            };
+        }
+    }
+    /**
+     * Register a prompt template
+     */
+    registerPrompt(prompt) {
+        this.prompts.set(prompt.name, prompt);
+    }
+    /**
+     * List all available prompts
+     */
+    listPrompts() {
+        return Array.from(this.prompts.values());
+    }
+    /**
+     * Get prompt messages
+     */
+    getPrompt(name, args) {
+        const prompt = this.prompts.get(name);
+        if (!prompt) {
+            return null;
+        }
+        // For now, return empty messages - actual implementation would render the prompt
+        return [];
+    }
+    /**
+     * List available resources
+     */
+    async listResources() {
+        // Return database stats as a resource
+        return [{
+                uri: 'sochdb://stats',
+                name: 'Database Statistics',
+                description: 'Current database statistics',
+                mimeType: 'application/json',
+            }];
+    }
+    /**
+     * Read a resource
+     */
+    async readResource(uri) {
+        if (uri === 'sochdb://stats') {
+            const stats = await this.db.stats();
+            return {
+                uri,
+                mimeType: 'application/json',
+                text: JSON.stringify(stats, (_, v) => typeof v === 'bigint' ? v.toString() : v),
+            };
+        }
+        return null;
+    }
+    /**
+     * Get server info
+     */
+    getServerInfo() {
+        return { ...this.config };
+    }
+}
+exports.McpServer = McpServer;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"server.js","sourceRoot":"","sources":["../../../src/mcp/server.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * MCP Server Implementation\n * \n * SochDB MCP Server for exposing database operations to LLM agents.\n */\n\nimport { EmbeddedDatabase } from '../embedded';\nimport {\n  McpTool,\n  McpToolCall,\n  McpToolResult,\n  McpResource,\n  McpResourceContent,\n  McpPrompt,\n  McpPromptMessage,\n  McpServerConfig,\n  McpServerCapabilities,\n  McpError,\n  MCP_ERROR_CODES,\n} from './types';\n\n/**\n * MCP Server for SochDB\n * \n * Exposes database operations as MCP tools for LLM agents.\n * \n * @example\n * ```typescript\n * import { EmbeddedDatabase, McpServer } from '@sochdb/sochdb';\n * \n * const db = EmbeddedDatabase.open('./mydb');\n * const server = new McpServer(db, {\n *   name: 'sochdb-mcp',\n *   version: '1.0.0',\n *   capabilities: { tools: true, resources: true }\n * });\n * \n * // List available tools\n * const tools = server.listTools();\n * \n * // Execute a tool call\n * const result = await server.callTool({\n *   id: 'call_1',\n *   name: 'db_get',\n *   arguments: { key: 'user:123' }\n * });\n * ```\n */\nexport class McpServer {\n  private db: EmbeddedDatabase;\n  private config: McpServerConfig;\n  private tools: Map<string, McpTool> = new Map();\n  private prompts: Map<string, McpPrompt> = new Map();\n  private customToolHandlers: Map<string, (args: Record<string, any>) => Promise<any>> = new Map();\n\n  constructor(db: EmbeddedDatabase, config: McpServerConfig) {\n    this.db = db;\n    this.config = config;\n    this.registerBuiltinTools();\n  }\n\n  /**\n   * Register built-in database tools\n   */\n  private registerBuiltinTools(): void {\n    // Key-Value operations\n    this.registerTool({\n      name: 'db_get',\n      description: 'Get a value from the database by key',\n      inputSchema: {\n        type: 'object',\n        properties: {\n          key: { type: 'string', description: 'The key to retrieve' },\n        },\n        required: ['key'],\n      },\n    }, async (args) => {\n      const value = await this.db.get(Buffer.from(args.key));\n      return value ? value.toString() : null;\n    });\n\n    this.registerTool({\n      name: 'db_put',\n      description: 'Store a value in the database',\n      inputSchema: {\n        type: 'object',\n        properties: {\n          key: { type: 'string', description: 'The key to store' },\n          value: { type: 'string', description: 'The value to store' },\n        },\n        required: ['key', 'value'],\n      },\n    }, async (args) => {\n      await this.db.put(Buffer.from(args.key), Buffer.from(args.value));\n      return { success: true };\n    });\n\n    this.registerTool({\n      name: 'db_delete',\n      description: 'Delete a key from the database',\n      inputSchema: {\n        type: 'object',\n        properties: {\n          key: { type: 'string', description: 'The key to delete' },\n        },\n        required: ['key'],\n      },\n    }, async (args) => {\n      await this.db.delete(Buffer.from(args.key));\n      return { success: true };\n    });\n\n    this.registerTool({\n      name: 'db_scan',\n      description: 'Scan keys with a prefix',\n      inputSchema: {\n        type: 'object',\n        properties: {\n          prefix: { type: 'string', description: 'The prefix to scan' },\n          limit: { type: 'number', description: 'Maximum results', default: 100 },\n        },\n        required: ['prefix'],\n      },\n    }, async (args) => {\n      const results: Array<{ key: string; value: string }> = [];\n      const limit = args.limit || 100;\n      let count = 0;\n\n      for await (const [keyBuffer, valueBuffer] of this.db.scanPrefix(Buffer.from(args.prefix))) {\n        if (count >= limit) break;\n        results.push({\n          key: keyBuffer.toString(),\n          value: valueBuffer.toString(),\n        });\n        count++;\n      }\n\n      return results;\n    });\n\n    this.registerTool({\n      name: 'db_stats',\n      description: 'Get database statistics',\n      inputSchema: {\n        type: 'object',\n        properties: {},\n      },\n    }, async () => {\n      const stats = await this.db.stats();\n      return {\n        memtableSizeBytes: stats.memtableSizeBytes.toString(),\n        walSizeBytes: stats.walSizeBytes.toString(),\n        activeTransactions: stats.activeTransactions,\n      };\n    });\n  }\n\n  /**\n   * Register a custom tool\n   */\n  registerTool(\n    tool: McpTool,\n    handler: (args: Record<string, any>) => Promise<any>\n  ): void {\n    this.tools.set(tool.name, tool);\n    this.customToolHandlers.set(tool.name, handler);\n  }\n\n  /**\n   * Unregister a tool\n   */\n  unregisterTool(name: string): boolean {\n    this.customToolHandlers.delete(name);\n    return this.tools.delete(name);\n  }\n\n  /**\n   * List all available tools\n   */\n  listTools(): McpTool[] {\n    return Array.from(this.tools.values());\n  }\n\n  /**\n   * Call a tool\n   */\n  async callTool(call: McpToolCall): Promise<McpToolResult> {\n    const handler = this.customToolHandlers.get(call.name);\n    \n    if (!handler) {\n      return {\n        id: call.id,\n        content: null,\n        isError: true,\n        errorMessage: `Tool not found: ${call.name}`,\n      };\n    }\n\n    try {\n      const content = await handler(call.arguments);\n      return {\n        id: call.id,\n        content,\n        isError: false,\n      };\n    } catch (error: any) {\n      return {\n        id: call.id,\n        content: null,\n        isError: true,\n        errorMessage: error.message || 'Unknown error',\n      };\n    }\n  }\n\n  /**\n   * Register a prompt template\n   */\n  registerPrompt(prompt: McpPrompt): void {\n    this.prompts.set(prompt.name, prompt);\n  }\n\n  /**\n   * List all available prompts\n   */\n  listPrompts(): McpPrompt[] {\n    return Array.from(this.prompts.values());\n  }\n\n  /**\n   * Get prompt messages\n   */\n  getPrompt(name: string, args?: Record<string, any>): McpPromptMessage[] | null {\n    const prompt = this.prompts.get(name);\n    if (!prompt) {\n      return null;\n    }\n\n    // For now, return empty messages - actual implementation would render the prompt\n    return [];\n  }\n\n  /**\n   * List available resources\n   */\n  async listResources(): Promise<McpResource[]> {\n    // Return database stats as a resource\n    return [{\n      uri: 'sochdb://stats',\n      name: 'Database Statistics',\n      description: 'Current database statistics',\n      mimeType: 'application/json',\n    }];\n  }\n\n  /**\n   * Read a resource\n   */\n  async readResource(uri: string): Promise<McpResourceContent | null> {\n    if (uri === 'sochdb://stats') {\n      const stats = await this.db.stats();\n      return {\n        uri,\n        mimeType: 'application/json',\n        text: JSON.stringify(stats, (_, v) => \n          typeof v === 'bigint' ? v.toString() : v\n        ),\n      };\n    }\n    return null;\n  }\n\n  /**\n   * Get server info\n   */\n  getServerInfo(): McpServerConfig {\n    return { ...this.config };\n  }\n}\n"]}

package/dist/esm/mcp/types.js

@@ -0,0 +1,34 @@
+"use strict";
+/**
+ * MCP (Model Context Protocol) Types
+ *
+ * Type definitions for Model Context Protocol integration with LLM agents.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MCP_ERROR_CODES = exports.McpError = void 0;
+/**
+ * MCP Error
+ */
+class McpError extends Error {
+    code;
+    data;
+    constructor(message, code, data) {
+        super(message);
+        this.name = 'McpError';
+        this.code = code;
+        this.data = data;
+    }
+}
+exports.McpError = McpError;
+// Error codes
+exports.MCP_ERROR_CODES = {
+    PARSE_ERROR: -32700,
+    INVALID_REQUEST: -32600,
+    METHOD_NOT_FOUND: -32601,
+    INVALID_PARAMS: -32602,
+    INTERNAL_ERROR: -32603,
+    TOOL_NOT_FOUND: -32001,
+    RESOURCE_NOT_FOUND: -32002,
+    PROMPT_NOT_FOUND: -32003,
+};
+//# sourceMappingURL=data:application/json;base64,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