@hyqf98/easy_db_mcp_server 1.0.0 → 2.0.0

package/dist/database/sqlite.js

@@ -1,4 +1,6 @@
 import Database from 'better-sqlite3';
+import fs from 'fs';
+import { expandTilde, formatFileSize, ensureDirectoryExists, getDefaultFilePath } from '../utils/file.js';
 export class SQLiteAdapter {
     db;
     config;
@@ -66,4 +68,225 @@ export class SQLiteAdapter {
             this.db = undefined;
         }
     }
+    async executeTransaction(queries) {
+        if (!this.db)
+            throw new Error('Not connected');
+        const results = [];
+        let totalAffectedRows = 0;
+        this.db.exec('BEGIN TRANSACTION');
+        try {
+            for (const query of queries) {
+                const trimmed = query.trim().toUpperCase();
+                if (trimmed.startsWith('SELECT')) {
+                    const rows = this.db.prepare(query).all();
+                    results.push({ rows, rowCount: rows.length });
+                }
+                else {
+                    const result = this.db.prepare(query).run();
+                    totalAffectedRows += result.changes;
+                    results.push({ affectedRows: result.changes });
+                }
+            }
+            this.db.exec('COMMIT');
+            return {
+                success: true,
+                affectedRows: totalAffectedRows,
+                results,
+            };
+        }
+        catch (error) {
+            this.db.exec('ROLLBACK');
+            throw error;
+        }
+    }
+    async batchInsert(table, data) {
+        if (!this.db)
+            throw new Error('Not connected');
+        if (data.length === 0) {
+            return { insertedRows: 0, duplicateRows: 0 };
+        }
+        const columns = Object.keys(data[0]);
+        const columnList = columns.join(', ');
+        const placeholders = columns.map(() => '?').join(', ');
+        const query = `INSERT INTO ${table} (${columnList}) VALUES (${placeholders})`;
+        const stmt = this.db.prepare(query);
+        let insertedRows = 0;
+        let duplicateRows = 0;
+        this.db.exec('BEGIN TRANSACTION');
+        try {
+            for (const row of data) {
+                try {
+                    const values = columns.map((col) => row[col]);
+                    stmt.run(values);
+                    insertedRows++;
+                }
+                catch (error) {
+                    if (error.code === 'SQLITE_CONSTRAINT') {
+                        duplicateRows++;
+                    }
+                    else {
+                        throw error;
+                    }
+                }
+            }
+            this.db.exec('COMMIT');
+            return { insertedRows, duplicateRows };
+        }
+        catch (error) {
+            this.db.exec('ROLLBACK');
+            throw error;
+        }
+    }
+    async batchUpdate(table, updates) {
+        if (!this.db)
+            throw new Error('Not connected');
+        const setClause = Object.entries(updates.set)
+            .map(([key, value]) => `${key} = ${this.escapeValue(value)}`)
+            .join(', ');
+        const query = `UPDATE ${table} SET ${setClause} WHERE ${updates.where}`;
+        const result = this.db.prepare(query).run();
+        return { affectedRows: result.changes };
+    }
+    escapeValue(value) {
+        if (value === null)
+            return 'NULL';
+        if (typeof value === 'number')
+            return String(value);
+        if (typeof value === 'boolean')
+            return value ? '1' : '0';
+        return `'${String(value).replace(/'/g, "''")}'`;
+    }
+    async exportData(table, format, filePath, options) {
+        if (!this.db)
+            throw new Error('Not connected');
+        let query = `SELECT * FROM ${table}`;
+        if (options?.where) {
+            query += ` WHERE ${options.where}`;
+        }
+        if (options?.limit) {
+            query += ` LIMIT ${options.limit}`;
+        }
+        const data = this.db.prepare(query).all();
+        const targetPath = filePath
+            ? expandTilde(filePath)
+            : getDefaultFilePath(table, format);
+        ensureDirectoryExists(targetPath);
+        let content;
+        if (format === 'json') {
+            content = JSON.stringify(data, null, 2);
+        }
+        else {
+            if (data.length === 0) {
+                content = '';
+            }
+            else {
+                const headers = Object.keys(data[0]);
+                const csvRows = [
+                    headers.join(','),
+                    ...data.map((row) => headers.map((h) => {
+                        const val = row[h];
+                        if (val === null)
+                            return '';
+                        if (typeof val === 'string')
+                            return '"' + val.replace(/"/g, '""') + '"';
+                        return String(val);
+                    }).join(',')),
+                ];
+                content = csvRows.join('\n');
+            }
+        }
+        fs.writeFileSync(targetPath, content, 'utf-8');
+        const stats = fs.statSync(targetPath);
+        return {
+            success: true,
+            filePath: targetPath,
+            rowCount: data.length,
+            fileSize: formatFileSize(stats.size),
+        };
+    }
+    async createTable(table, columns) {
+        if (!this.db)
+            throw new Error('Not connected');
+        const columnDefs = columns.map((col) => {
+            let def = `${col.name} ${col.type}`;
+            if (col.nullable === false)
+                def += ' NOT NULL';
+            if (col.primaryKey)
+                def += ' PRIMARY KEY';
+            if (col.defaultValue !== undefined) {
+                def += ` DEFAULT ${this.escapeValue(col.defaultValue)}`;
+            }
+            return def;
+        });
+        const query = `CREATE TABLE ${table} (${columnDefs.join(', ')})`;
+        this.db.exec(query);
+        return { success: true, tableName: table };
+    }
+    async dropTable(table, ifExists = false) {
+        if (!this.db)
+            throw new Error('Not connected');
+        const query = ifExists
+            ? `DROP TABLE IF EXISTS ${table}`
+            : `DROP TABLE ${table}`;
+        this.db.exec(query);
+        return { success: true, tableName: table };
+    }
+    async getTableStats(table) {
+        if (!this.db)
+            throw new Error('Not connected');
+        // Get row count
+        const countResult = this.db.prepare(`SELECT COUNT(*) as count FROM ${table}`).get();
+        const rowCount = countResult.count;
+        // Get column count
+        const colResult = this.db.prepare(`PRAGMA table_info(${table})`).all();
+        const columns = colResult.length;
+        // Get indexes
+        const indexResult = this.db.prepare(`PRAGMA index_list(${table})`).all();
+        const indexes = indexResult.map((row) => row.name);
+        // Get table size (SQLite doesn't have a direct way, estimate from page count)
+        const pragmaResult = this.db.prepare(`PRAGMA page_count`).get();
+        const pageSizeResult = this.db.prepare(`PRAGMA page_size`).get();
+        const sizeBytes = pragmaResult.page_count * pageSizeResult.page_size;
+        const size = formatFileSize(sizeBytes);
+        return {
+            tableName: table,
+            rowCount,
+            columns,
+            indexes,
+            size,
+        };
+    }
+    async previewData(table, page = 1, pageSize = 50, orderBy) {
+        if (!this.db)
+            throw new Error('Not connected');
+        // Get total row count
+        const countResult = this.db.prepare(`SELECT COUNT(*) as count FROM ${table}`).get();
+        const totalRows = countResult.count;
+        const totalPages = Math.ceil(totalRows / pageSize);
+        const offset = (page - 1) * pageSize;
+        // Build query
+        let query = `SELECT * FROM ${table}`;
+        if (orderBy) {
+            query += ` ORDER BY ${orderBy}`;
+        }
+        query += ` LIMIT ${pageSize} OFFSET ${offset}`;
+        const rows = this.db.prepare(query).all();
+        return {
+            rows,
+            currentPage: page,
+            totalPages,
+            totalRows,
+        };
+    }
+    async sampleData(table, count = 10) {
+        if (!this.db)
+            throw new Error('Not connected');
+        const rows = this.db
+            .prepare(`SELECT * FROM ${table} ORDER BY RANDOM() LIMIT ${count}`)
+            .all();
+        return {
+            rows,
+            sampleCount: rows.length,
+        };
+    }
 }

package/dist/index.js

@@ -1,13 +1,13 @@
 #!/usr/bin/env node
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { z } from 'zod';
 import { loadConfig } from './config.js';
 import { createAdapter } from './database/factory.js';
-// Create server instance
-const server = new Server({
+// Create server instance with new API
+const server = new McpServer({
     name: 'hyqf98@easy_db_mcp_server',
-    version: '1.0.0',
+    version: '2.0.0',
 }, {
     capabilities: {
         tools: {},
@@ -15,191 +15,260 @@ const server = new Server({
 });
 // Load configuration and create adapter
 let adapter;
+let cachedConfig;
 try {
-    const config = loadConfig();
-    adapter = createAdapter(config);
+    cachedConfig = loadConfig();
+    adapter = createAdapter(cachedConfig);
     await adapter.connect();
-    console.error(`Connected to ${config.type} database`);
+    console.error(`Connected to ${cachedConfig.type} database`);
 }
 catch (error) {
     console.error('Failed to connect to database:', error);
     process.exit(1);
 }
-// List available tools
-server.setRequestHandler(ListToolsRequestSchema, async () => {
+// Helper function to validate database parameter
+const getDatabase = (paramDb) => {
+    if (paramDb) {
+        return paramDb;
+    }
+    if (cachedConfig.database) {
+        return cachedConfig.database;
+    }
+    throw new Error('Database name is required. Either set EASYDB_DATABASE environment variable or pass the database parameter in the tool call.');
+};
+// Register existing tools with new API
+server.registerTool('list_tables', {
+    title: 'List Tables',
+    description: 'List all tables in the database. If EASYDB_DATABASE is not set, the database parameter must be provided.',
+    inputSchema: {
+        database: z.string().optional().describe('Database name (optional if EASYDB_DATABASE is set, otherwise required)'),
+    },
+}, async ({ database }) => {
+    const dbName = getDatabase(database);
+    const tables = await adapter.listTables(dbName);
+    return {
+        content: [{ type: 'text', text: JSON.stringify(tables, null, 2) }],
+    };
+});
+server.registerTool('describe_table', {
+    title: 'Describe Table',
+    description: 'Get the structure of a table including columns, types, and constraints. If EASYDB_DATABASE is not set, the database parameter must be provided.',
+    inputSchema: {
+        table: z.string().describe('Table name'),
+        database: z.string().optional().describe('Database name (optional if EASYDB_DATABASE is set, otherwise required)'),
+    },
+}, async ({ table, database }) => {
+    const dbName = getDatabase(database);
+    const columns = await adapter.describeTable(table, dbName);
+    return {
+        content: [{ type: 'text', text: JSON.stringify(columns, null, 2) }],
+    };
+});
+server.registerTool('execute_query', {
+    title: 'Execute Query',
+    description: 'Execute a SELECT query (read-only). If EASYDB_DATABASE is not set, the database parameter must be provided.',
+    inputSchema: {
+        sql: z.string().describe('SQL SELECT query to execute'),
+        database: z.string().optional().describe('Database name (optional if EASYDB_DATABASE is set, otherwise required)'),
+    },
+}, async ({ sql, database }) => {
+    const dbName = getDatabase(database);
+    const result = await adapter.executeQuery(sql, dbName);
+    return {
+        content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+    };
+});
+server.registerTool('execute_sql', {
+    title: 'Execute SQL',
+    description: 'Execute any SQL statement (requires EASYDB_ALLOW_WRITE=true). If EASYDB_DATABASE is not set, the database parameter must be provided.',
+    inputSchema: {
+        sql: z.string().describe('SQL statement to execute (INSERT, UPDATE, DELETE, DDL, etc.)'),
+        database: z.string().optional().describe('Database name (optional if EASYDB_DATABASE is set, otherwise required)'),
+    },
+}, async ({ sql, database }) => {
+    if (!cachedConfig.allowWrite) {
+        throw new Error('SQL execution requires EASYDB_ALLOW_WRITE=true for safety. Please enable this environment variable if you want to allow write operations.');
+    }
+    // Improved DDL detection using regex to handle various formats
+    const trimmed = sql.trim().toUpperCase();
+    const ddlPattern = /^(CREATE|DROP|ALTER|TRUNCATE|RENAME)\s+(TABLE|INDEX|DATABASE|SCHEMA|VIEW|PROCEDURE|FUNCTION|TRIGGER)/;
+    const isDDL = ddlPattern.test(trimmed);
+    if (isDDL && !cachedConfig.allowDDL) {
+        throw new Error('DDL statements require EASYDB_ALLOW_DDL=true for safety. Please enable this environment variable if you want to allow DDL operations.');
+    }
+    const dbName = getDatabase(database);
+    const result = await adapter.executeSQL(sql, dbName);
+    return {
+        content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+    };
+});
+server.registerTool('execute_transaction', {
+    title: 'Execute Transaction',
+    description: 'Execute multiple SQL statements as a transaction. All queries will succeed or all will be rolled back.',
+    inputSchema: {
+        sql: z.array(z.string()).max(100).describe('Array of SQL statements to execute in transaction (max 100)'),
+        database: z.string().optional().describe('Database name (optional if EASYDB_DATABASE is set)'),
+    },
+}, async ({ sql, database }) => {
+    if (!cachedConfig.allowWrite) {
+        throw new Error('Transaction execution requires EASYDB_ALLOW_WRITE=true');
+    }
+    const dbName = getDatabase(database);
+    const result = await adapter.executeTransaction(sql, dbName);
+    return {
+        content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+    };
+});
+server.registerTool('batch_insert', {
+    title: 'Batch Insert',
+    description: 'Insert multiple rows into a table efficiently',
+    inputSchema: {
+        table: z.string().describe('Table name'),
+        data: z.array(z.record(z.string(), z.any())).describe('Array of row data objects'),
+        database: z.string().optional().describe('Database name (optional if EASYDB_DATABASE is set)'),
+    },
+}, async ({ table, data, database }) => {
+    if (!cachedConfig.allowWrite) {
+        throw new Error('Batch insert requires EASYDB_ALLOW_WRITE=true');
+    }
+    const dbName = getDatabase(database);
+    const result = await adapter.batchInsert(table, data, dbName);
     return {
-        tools: [
-            {
-                name: 'list_tables',
-                description: 'List all tables in the database. If EASYDB_DATABASE is not set, the database parameter must be provided.',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        database: {
-                            type: 'string',
-                            description: 'Database name (optional if EASYDB_DATABASE is set, otherwise required)',
-                        },
-                    },
-                },
-            },
-            {
-                name: 'describe_table',
-                description: 'Get the structure of a table including columns, types, and constraints. If EASYDB_DATABASE is not set, the database parameter must be provided.',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        table: {
-                            type: 'string',
-                            description: 'Table name',
-                        },
-                        database: {
-                            type: 'string',
-                            description: 'Database name (optional if EASYDB_DATABASE is set, otherwise required)',
-                        },
-                    },
-                    required: ['table'],
-                },
-            },
-            {
-                name: 'execute_query',
-                description: 'Execute a SELECT query (read-only). If EASYDB_DATABASE is not set, the database parameter must be provided.',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        sql: {
-                            type: 'string',
-                            description: 'SQL SELECT query to execute',
-                        },
-                        database: {
-                            type: 'string',
-                            description: 'Database name (optional if EASYDB_DATABASE is set, otherwise required)',
-                        },
-                    },
-                    required: ['sql'],
-                },
-            },
-            {
-                name: 'execute_sql',
-                description: 'Execute any SQL statement (requires EASYDB_ALLOW_WRITE=true). If EASYDB_DATABASE is not set, the database parameter must be provided.',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        sql: {
-                            type: 'string',
-                            description: 'SQL statement to execute (INSERT, UPDATE, DELETE, DDL, etc.)',
-                        },
-                        database: {
-                            type: 'string',
-                            description: 'Database name (optional if EASYDB_DATABASE is set, otherwise required)',
-                        },
-                    },
-                    required: ['sql'],
-                },
-            },
-        ],
+        content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
     };
 });
-// Handle tool calls
-server.setRequestHandler(CallToolRequestSchema, async (request) => {
-    const { name, arguments: args } = request.params;
-    const config = loadConfig();
-    // Helper function to validate database parameter
-    const getDatabase = (paramDb) => {
-        if (paramDb) {
-            return paramDb;
-        }
-        if (config.database) {
-            return config.database;
-        }
-        throw new Error('Database name is required. Either set EASYDB_DATABASE environment variable or pass the database parameter in the tool call.');
+server.registerTool('batch_update', {
+    title: 'Batch Update',
+    description: 'Update multiple rows in a table based on conditions',
+    inputSchema: {
+        table: z.string().describe('Table name'),
+        updates: z.object({
+            set: z.record(z.string(), z.any()).describe('Column values to set'),
+            where: z.string().describe('WHERE clause condition'),
+        }),
+        database: z.string().optional().describe('Database name (optional if EASYDB_DATABASE is set)'),
+    },
+}, async ({ table, updates, database }) => {
+    if (!cachedConfig.allowWrite) {
+        throw new Error('Batch update requires EASYDB_ALLOW_WRITE=true');
+    }
+    const dbName = getDatabase(database);
+    const result = await adapter.batchUpdate(table, updates, dbName);
+    return {
+        content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+    };
+});
+server.registerTool('export_data', {
+    title: 'Export Data',
+    description: 'Export table data to JSON or CSV file. Default saves to ~/table_name.json',
+    inputSchema: {
+        table: z.string().describe('Table name to export'),
+        format: z.enum(['json', 'csv']).describe('Export format'),
+        filePath: z.string().optional().describe('Optional file path (default: ~/table_name.format)'),
+        limit: z.number().optional().describe('Optional row limit'),
+        where: z.string().optional().describe('Optional WHERE clause'),
+        database: z.string().optional().describe('Database name (optional if EASYDB_DATABASE is set)'),
+    },
+}, async ({ table, format, filePath, limit, where, database }) => {
+    const dbName = getDatabase(database);
+    const result = await adapter.exportData(table, format, filePath, { limit, where }, dbName);
+    return {
+        content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
     };
-    try {
-        switch (name) {
-            case 'list_tables': {
-                const database = getDatabase(args?.database);
-                const tables = await adapter.listTables(database);
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify(tables, null, 2),
-                        },
-                    ],
-                };
-            }
-            case 'describe_table': {
-                const database = getDatabase(args?.database);
-                const columns = await adapter.describeTable(args?.table, database);
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify(columns, null, 2),
-                        },
-                    ],
-                };
-            }
-            case 'execute_query': {
-                const database = getDatabase(args?.database);
-                const result = await adapter.executeQuery(args?.sql, database);
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify(result, null, 2),
-                        },
-                    ],
-                };
-            }
-            case 'execute_sql': {
-                if (!config.allowWrite) {
-                    throw new Error('SQL execution requires EASYDB_ALLOW_WRITE=true for safety. Please enable this environment variable if you want to allow write operations.');
-                }
-                const sql = args?.sql;
-                const trimmed = sql.trim().toUpperCase();
-                // Check for DDL statements
-                const isDDL = trimmed.startsWith('CREATE ') ||
-                    trimmed.startsWith('DROP ') ||
-                    trimmed.startsWith('ALTER ') ||
-                    trimmed.startsWith('TRUNCATE ');
-                if (isDDL && !config.allowDDL) {
-                    throw new Error('DDL statements require EASYDB_ALLOW_DDL=true for safety. Please enable this environment variable if you want to allow DDL operations.');
-                }
-                const database = getDatabase(args?.database);
-                const result = await adapter.executeSQL(sql, database);
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify(result, null, 2),
-                        },
-                    ],
-                };
-            }
-            default:
-                throw new Error(`Unknown tool: ${name}`);
-        }
+});
+server.registerTool('create_table', {
+    title: 'Create Table',
+    description: 'Create a new table with specified columns',
+    inputSchema: {
+        table: z.string().describe('Table name'),
+        columns: z.array(z.object({
+            name: z.string().describe('Column name'),
+            type: z.string().describe('Column data type'),
+            nullable: z.boolean().optional().describe('Whether column allows NULL'),
+            primaryKey: z.boolean().optional().describe('Whether column is primary key'),
+            defaultValue: z.any().optional().describe('Default value'),
+        })).describe('Column definitions'),
+        database: z.string().optional().describe('Database name (optional if EASYDB_DATABASE is set)'),
+    },
+}, async ({ table, columns, database }) => {
+    if (!cachedConfig.allowDDL) {
+        throw new Error('Create table requires EASYDB_ALLOW_DDL=true');
     }
-    catch (error) {
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify({
-                        success: false,
-                        error: error instanceof Error ? error.message : String(error),
-                    }, null, 2),
-                },
-            ],
-            isError: true,
-        };
+    const dbName = getDatabase(database);
+    const result = await adapter.createTable(table, columns, dbName);
+    return {
+        content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+    };
+});
+server.registerTool('drop_table', {
+    title: 'Drop Table',
+    description: 'Delete a table from the database',
+    inputSchema: {
+        table: z.string().describe('Table name to drop'),
+        ifExists: z.boolean().optional().describe('Use IF EXISTS to avoid error if table does not exist'),
+        database: z.string().optional().describe('Database name (optional if EASYDB_DATABASE is set)'),
+    },
+}, async ({ table, ifExists, database }) => {
+    if (!cachedConfig.allowDDL) {
+        throw new Error('Drop table requires EASYDB_ALLOW_DDL=true');
     }
+    const dbName = getDatabase(database);
+    const result = await adapter.dropTable(table, ifExists, dbName);
+    return {
+        content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+    };
+});
+server.registerTool('get_table_stats', {
+    title: 'Get Table Statistics',
+    description: 'Get detailed statistics about a table including row count, columns, indexes, and size',
+    inputSchema: {
+        table: z.string().describe('Table name'),
+        database: z.string().optional().describe('Database name (optional if EASYDB_DATABASE is set)'),
+    },
+}, async ({ table, database }) => {
+    const dbName = getDatabase(database);
+    const result = await adapter.getTableStats(table, dbName);
+    return {
+        content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+    };
+});
+server.registerTool('preview_data', {
+    title: 'Preview Data',
+    description: 'Preview table data with pagination',
+    inputSchema: {
+        table: z.string().describe('Table name'),
+        page: z.number().optional().describe('Page number (default: 1)'),
+        pageSize: z.number().optional().describe('Rows per page (default: 50)'),
+        orderBy: z.string().optional().describe('Order by column name'),
+        database: z.string().optional().describe('Database name (optional if EASYDB_DATABASE is set)'),
+    },
+}, async ({ table, page = 1, pageSize = 50, orderBy, database }) => {
+    const dbName = getDatabase(database);
+    const result = await adapter.previewData(table, page, pageSize, orderBy, dbName);
+    return {
+        content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+    };
+});
+server.registerTool('sample_data', {
+    title: 'Sample Data',
+    description: 'Get a random sample of rows from a table',
+    inputSchema: {
+        table: z.string().describe('Table name'),
+        count: z.number().optional().describe('Number of rows to sample (default: 10)'),
+        database: z.string().optional().describe('Database name (optional if EASYDB_DATABASE is set)'),
+    },
+}, async ({ table, count = 10, database }) => {
+    const dbName = getDatabase(database);
+    const result = await adapter.sampleData(table, count, dbName);
+    return {
+        content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+    };
 });
 // Start server
 async function main() {
     const transport = new StdioServerTransport();
     await server.connect(transport);
-    console.error('EasyDB MCP Server running');
+    console.error('EasyDB MCP Server v2.0.0 running');
 }
 main().catch((error) => {
     console.error('Server error:', error);

package/dist/utils/file.d.ts

@@ -0,0 +1,4 @@
+export declare function expandTilde(filePath: string): string;
+export declare function formatFileSize(bytes: number): string;
+export declare function ensureDirectoryExists(filePath: string): void;
+export declare function getDefaultFilePath(baseName: string, extension: string): string;