@andezdev/tokenlite-mysql-mcp 2.0.0 → 3.1.0

package/AGENTS.md

@@ -23,7 +23,7 @@
 
 5. **Fixing Optimizer Blocks (Full Table Scans).**
    - **Rule**: If the `execute_safe_query` tool throws an `OptimizerError: Full table scan detected`, it means your query is scanning too many rows without an index.
-   - **Action**: You MUST rewrite the query to include a `WHERE` clause that uses an indexed column (e.g., a primary key or foreign key).
+   - **Action**: Use `explain_query` to see the full EXPLAIN output, then rewrite the query to include a `WHERE` clause that uses an indexed column (e.g., a primary key or foreign key).
 
 ---
 
@@ -49,3 +49,15 @@
 **Use for:** Forcing the server to rescan the database and update its internal graph.
 **Arguments:** None.
 **Use when:** You receive an error that a table or column doesn't exist, implying the schema changed.
+
+### `explain_query`
+**Use for:** Analyzing the execution plan of a SELECT query before running it.
+**Arguments:** `sql` (string) - The SELECT query to analyze.
+**Returns:** The MySQL EXPLAIN output as CSV showing join types, index usage, and estimated row counts.
+**Use when:** Your query was blocked by the optimizer (`OptimizerError`) or you want to verify it uses indexes before executing.
+
+### `ping`
+**Use for:** Checking if the database connection is alive and healthy.
+**Arguments:** None.
+**Returns:** JSON with `status` (`"ok"` or `"error"`), `server_version`, and `pool` stats (`active`, `idle`, `queue` connection counts).
+**Use when:** You suspect a connection issue or want to verify the server is operational before running queries.

package/README.md

@@ -1,6 +1,6 @@
 # TokenLite MySQL MCP
 
-[![npm version](https://badge.fury.io/js/@andezdev%2Ftokenlite-mysql-mcp.svg)](https://badge.fury.io/js/@andezdev%2Ftokenlite-mysql-mcp)
+[![npm version](https://badge.fury.io/js/@andezdev%2Ftokenlite-mysql-mcp.svg?icon=si%3Anpm)](https://badge.fury.io/js/@andezdev%2Ftokenlite-mysql-mcp)
 
 A robust and secure MySQL database server implemented under Anthropic's **Model Context Protocol (MCP)**. 
 Designed specifically to solve the shortcomings of current generic MCP servers through **Graceful Degradation, Active Performance Protection, and Aggressive Token Optimization**.
@@ -104,6 +104,11 @@ To use within Cursor IDE:
 | `MYSQL_QUERY_TIMEOUT` | Max execution time for a query (in ms). Aborts heavy queries to protect against DoS. | `15000` | No |
 | `MYSQL_CONNECTION_LIMIT` | Max concurrent pool connections. | `10` | No |
 | `MYSQL_CONNECT_TIMEOUT` | Max time to wait for a socket to establish (in ms). | `10000` | No |
+| `MYSQL_RETRY_ATTEMPTS` | Max retries on transient connection errors (`ECONNREFUSED`, `PROTOCOL_CONNECTION_LOST`, etc.). | `3` | No |
+| `MYSQL_RETRY_DELAY_MS` | Base delay (ms) for exponential backoff between retries (1s, 2s, 4s...). | `1000` | No |
+| `MYSQL_QUEUE_LIMIT` | Max queued requests when all pool connections are busy. Prevents unbounded growth if MySQL is down. | `50` | No |
+| `MCP_DDL_CACHE_TTL` | Time-to-live (in seconds) for cached DDL statements. Reduces latency on repeated `search_schema` calls. Invalidated by `refresh_schema`. | `60` | No |
+| `MCP_LOG_LEVEL` | Minimum severity for MCP log notifications: `debug`, `info`, `notice`, `warning`, `error`, `critical`, `alert`, `emergency`. | `info` | No |
 | `ALLOW_INSERT_OPERATION` | Enable `INSERT` and `REPLACE` queries. | `false` | No |
 | `ALLOW_UPDATE_OPERATION` | Enable `UPDATE` queries. | `false` | No |
 | `ALLOW_DELETE_OPERATION` | Enable `DELETE` and `TRUNCATE` queries. | `false` | No |
@@ -142,29 +147,58 @@ Stop the LLM from hallucinating complex metrics by providing vetted templates.
 
 ## 📈 Benchmarks & Token Savings
 
-TokenLite includes an automated, precise benchmark suite using official `cl100k_base` tokenization (matching models like Claude 3.5 Sonnet and GPT-4) to measure efficiency improvements.
+TokenLite includes an automated benchmark suite using `o200k_base` tokenization (GPT-4o/GPT-5 standard) to measure efficiency improvements. Token counts are approximate — Claude 4.x uses a proprietary tokenizer; actual counts may vary slightly.
 
 To run the benchmark in your own environment:
 ```bash
 npm run benchmark
 ```
 
+### Baseline: Standard MCP Pattern
+The benchmark compares against the standard pattern used by generic MySQL MCP servers: full schema exposed as `information_schema.columns` in pretty-printed JSON, and query results returned as `JSON.stringify(rows, null, 2)` with execution time metadata.
+
 ### 1. Schema Discovery (Input Tokens)
-Traditional MCP servers dump the entire schema to the LLM. For large databases, this consumes thousands of input tokens on every turn. TokenLite's relational graph serves a localized **Auto-Join Context** (target table + direct parent tables + direct child tables).
+Standard MCP servers dump the entire schema to the LLM. For large databases, this consumes thousands of input tokens on every turn. TokenLite's relational graph serves a localized **Auto-Join Context** (target table + direct parent tables + direct child tables).
+
+| Scenario | Standard MCP Pattern | TokenLite | 📉 Savings |
+| :--- | :--- | :--- | :--- |
+| **Mock (50 tables, Enterprise CRM)** | 15,566 tokens | 883 tokens | **94.3%** |
+| **Live (7 tables, Test DB)** | 1,892 tokens | 257 tokens | **86.4%** |
 
-*   **Generic MCP Schema Dump:** 611 tokens
-*   **TokenLite Relational Graph:** 252 tokens
-*   **📉 Schema Input Savings:** **58.7%** (up to **90%** on larger enterprise schemas)
+Savings scale with the number of tables: the more tables in the database, the higher the savings because the standard pattern dumps all of them while TokenLite only fetches the target + 1-hop relationships.
 
 ### 2. Query Result Payloads (Output Tokens)
 TokenLite converts raw database rows to a dense, structured CSV layout. This avoids JSON syntax overhead (brackets, braces, repeated keys) and compresses the output payload returned to the LLM.
 
-| Rows Returned | Generic MCP JSON (Tokens) | TokenLite CSV (Tokens) | 📉 Output Savings (%) |
+**Mock data** (varied: NULLs, long descriptions, mixed lengths):
+
+| Rows Returned | Standard MCP Pattern (Tokens) | TokenLite CSV (Tokens) | 📉 Output Savings (%) |
+| :--- | :--- | :--- | :--- |
+| **10 rows** | 1,167 | 592 | **49.3%** |
+| **50 rows** | 5,805 | 2,875 | **50.5%** |
+| **100 rows** | 11,607 | 5,734 | **50.6%** |
+| **500 rows** | 57,998 | 28,578 | **50.7%** |
+
+**Live data** (real MySQL test database with NULLs, ENUMs, variable-length text):
+
+| Rows Returned | Standard MCP Pattern (Tokens) | TokenLite CSV (Tokens) | 📉 Output Savings (%) |
 | :--- | :--- | :--- | :--- |
-| **10 rows** | 1,153 | 590 | **48.8%** |
-| **50 rows** | 5,764 | 2,861 | **50.3%** |
-| **100 rows** | 11,527 | 5,699 | **50.5%** |
-| **500 rows** | 57,635 | 28,407 | **50.7%** |
+| **10 rows** | 1,007 | 575 | **42.9%** |
+| **50 rows** | 5,029 | 2,845 | **43.4%** |
+| **100 rows** | 10,071 | 5,699 | **43.4%** |
+| **500 rows** | 50,327 | 28,441 | **43.5%** |
+
+---
+
+## 📊 Logging & Observability
+
+TokenLite uses MCP-native logging via `notifications/message` instead of raw stderr output. Clients that support MCP logging (e.g., MCP Inspector) will receive structured log messages with severity levels, logger names, and JSON data.
+
+**Severity levels** (from least to most severe): `debug`, `info`, `notice`, `warning`, `error`, `critical`, `alert`, `emergency`.
+
+The server emits logs at `info` level and above by default. Control the minimum level via `MCP_LOG_LEVEL` or dynamically at runtime through the MCP `logging/setLevel` request.
+
+Before the MCP session is established (e.g., during pool initialization), logs fall back to stderr.
 
 ---
 
@@ -192,7 +226,7 @@ Instead, wrap the process using standard open-source MCP proxies like [mcp-proxy
 
 **Error: `OptimizerError: Full table scan detected...`**
 The LLM attempted to execute a query that requires scanning thousands of rows without using an index. 
-*Solution*: The LLM will automatically see this error and try to rewrite the query with an indexed `WHERE` clause. If you truly need to scan the whole table, increase `MCP_SAFE_QUERY_MAX_ROWS` in your config.
+*Solution*: Use `explain_query` to see the full EXPLAIN output and understand why the query was blocked. Rewrite the query with an indexed `WHERE` clause. If you truly need to scan the whole table, increase `MCP_SAFE_QUERY_MAX_ROWS` in your config.
 
 **Error: `calling "initialize": invalid character...`**
 This means the MCP JSON-RPC protocol crashed. Ensure you are passing the correct DB credentials and that the database is running and accessible from the machine where the MCP server runs.

package/dist/db/index.js

@@ -1,8 +1,29 @@
 import mysql from 'mysql2/promise';
 import dotenv from 'dotenv';
 import { injectLimitAst, analyzeQueryPlan } from './optimizer.js';
+import { log } from '../utils/logger.js';
 // Supress dotenv logs so they don't corrupt the MCP JSON-RPC stdout stream
 dotenv.config({ quiet: true });
+const MAX_RETRY_ATTEMPTS = parseInt(process.env.MYSQL_RETRY_ATTEMPTS || '3', 10);
+const RETRY_BASE_DELAY_MS = parseInt(process.env.MYSQL_RETRY_DELAY_MS || '1000', 10);
+const QUEUE_LIMIT = parseInt(process.env.MYSQL_QUEUE_LIMIT || '50', 10);
+const RETRYABLE_ERRORS = new Set([
+    'ECONNREFUSED',
+    'PROTOCOL_CONNECTION_LOST',
+    'ECONNRESET',
+    'ETIMEDOUT',
+    'ER_CON_COUNT_ERROR',
+]);
+export function isRetryableError(error) {
+    if (RETRYABLE_ERRORS.has(error.code))
+        return true;
+    if (error.message?.includes('Connection lost'))
+        return true;
+    return false;
+}
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
 export const pool = mysql.createPool({
     host: process.env.DB_HOST || 'localhost',
     port: parseInt(process.env.DB_PORT || '3306', 10),
@@ -11,9 +32,12 @@ export const pool = mysql.createPool({
     database: process.env.DB_NAME || 'test',
     waitForConnections: true,
     connectionLimit: parseInt(process.env.MYSQL_CONNECTION_LIMIT || '10', 10),
-    queueLimit: 0,
+    queueLimit: QUEUE_LIMIT,
     connectTimeout: parseInt(process.env.MYSQL_CONNECT_TIMEOUT || '10000', 10)
 });
+pool.pool.on('enqueue', () => {
+    log("warning", `All connections busy, request queued (limit: ${QUEUE_LIMIT}).`, "pool");
+});
 // Session-Level Defense in Depth
 const allowInsert = process.env.ALLOW_INSERT_OPERATION === 'true';
 const allowUpdate = process.env.ALLOW_UPDATE_OPERATION === 'true';
@@ -25,7 +49,7 @@ if (isStrictReadOnlyMode) {
         // At runtime this is a callback connection, despite what TS types say
         connection.query('SET SESSION TRANSACTION READ ONLY', (err) => {
             if (err) {
-                console.error('[tokenlite-mysql-mcp] Warning: Failed to set connection to READ ONLY:', err.message);
+                log("warning", `Failed to set connection to READ ONLY: ${err.message}`, "pool");
             }
         });
     });
@@ -66,15 +90,36 @@ export async function executeSafeQuery(sql) {
     if (astType === 'select') {
         await analyzeQueryPlan(astOptimizedSql, pool);
     }
-    const [rows] = await pool.query({
+    const rows = await queryWithRetry({
         sql: astOptimizedSql,
         timeout: parseInt(process.env.MYSQL_QUERY_TIMEOUT || '15000', 10)
     });
     return rows;
 }
+async function queryWithRetry(opts) {
+    let lastError;
+    for (let attempt = 0; attempt <= MAX_RETRY_ATTEMPTS; attempt++) {
+        try {
+            const [rows] = await pool.query(opts);
+            return rows;
+        }
+        catch (error) {
+            lastError = error;
+            if (!isRetryableError(error)) {
+                throw error;
+            }
+            if (attempt < MAX_RETRY_ATTEMPTS) {
+                const delay = RETRY_BASE_DELAY_MS * Math.pow(2, attempt);
+                log("warning", `Connection error (${error.code}), retrying in ${delay}ms (attempt ${attempt + 1}/${MAX_RETRY_ATTEMPTS})...`, "pool");
+                await sleep(delay);
+            }
+        }
+    }
+    throw lastError;
+}
 export async function pingDb() {
     try {
-        await pool.query('SELECT 1');
+        await queryWithRetry({ sql: 'SELECT 1' });
         return true;
     }
     catch (e) {
@@ -87,9 +132,9 @@ export async function pingDb() {
 export async function closePool() {
     try {
         await pool.end();
-        console.error('[tokenlite-mysql-mcp] Database connection pool closed gracefully.');
+        log("info", "Database connection pool closed gracefully.", "pool");
     }
     catch (error) {
-        console.error('[tokenlite-mysql-mcp] Error closing database connection pool:', error.message);
+        log("error", `Error closing database connection pool: ${error.message}`, "pool");
     }
 }

package/dist/db/metadata.js

@@ -1,6 +1,7 @@
 import fs from 'fs';
 import Fuse from 'fuse.js';
 import dotenv from 'dotenv';
+import { log } from '../utils/logger.js';
 dotenv.config({ quiet: true });
 let metadataCache = {};
 let templatesCache = [];
@@ -11,10 +12,10 @@ export function initMetadata() {
         try {
             const raw = fs.readFileSync(metadataPath, 'utf8');
             metadataCache = JSON.parse(raw);
-            console.error(`[tokenlite-mysql-mcp] Loaded metadata dictionary from ${metadataPath}`);
+            log("info", `Loaded metadata dictionary from ${metadataPath}`, "metadata");
         }
         catch (err) {
-            console.error(`[tokenlite-mysql-mcp] Error loading metadata.json:`, err);
+            log("error", `Error loading metadata.json: ${err}`, "metadata");
         }
     }
     const templatesPath = process.env.MCP_TEMPLATES_PATH;
@@ -27,10 +28,10 @@ export function initMetadata() {
                 threshold: 0.5,
                 ignoreLocation: true
             });
-            console.error(`[tokenlite-mysql-mcp] Loaded ${templatesCache.length} SQL templates from ${templatesPath}`);
+            log("info", `Loaded ${templatesCache.length} SQL templates from ${templatesPath}`, "metadata");
         }
         catch (err) {
-            console.error(`[tokenlite-mysql-mcp] Error loading templates.json:`, err);
+            log("error", `Error loading templates.json: ${err}`, "metadata");
         }
     }
 }

package/dist/db/schema.js

@@ -1,15 +1,27 @@
 import { pool, getDbName } from './index.js';
+import { log } from '../utils/logger.js';
 export let schemaGraph = new Map();
-/**
- * Retrieves the raw DDL (CREATE TABLE) statement for a given table.
- */
+const DDL_CACHE_TTL_MS = parseInt(process.env.MCP_DDL_CACHE_TTL || '60', 10) * 1000;
+const ddlCache = new Map();
+export function invalidateDdlCache() {
+    ddlCache.clear();
+}
+const SAFE_TABLE_NAME = /^[a-zA-Z0-9_]+$/;
 export async function getTableDDL(tableName) {
+    if (!SAFE_TABLE_NAME.test(tableName)) {
+        return null;
+    }
+    const cached = ddlCache.get(tableName);
+    if (cached && Date.now() < cached.expiresAt) {
+        return cached.ddl;
+    }
     try {
         const [rows] = await pool.query(`SHOW CREATE TABLE \`${tableName}\``);
-        if (rows && rows.length > 0) {
-            return rows[0]['Create Table'] || rows[0]['Create View'];
-        }
-        return null;
+        const ddl = (rows && rows.length > 0)
+            ? (rows[0]['Create Table'] || rows[0]['Create View'])
+            : null;
+        ddlCache.set(tableName, { ddl, expiresAt: Date.now() + DDL_CACHE_TTL_MS });
+        return ddl;
     }
     catch (e) {
         return null;
@@ -94,6 +106,7 @@ export async function buildSchemaGraph() {
             }
         }
     }
+    invalidateDdlCache();
     schemaGraph = newGraph;
-    console.error(`[tokenlite-mysql-mcp] Schema Graph built successfully. Indexed ${schemaGraph.size} tables.`);
+    log("info", `Schema Graph built successfully. Indexed ${schemaGraph.size} tables.`, "schema");
 }

package/dist/index.js

@@ -4,20 +4,33 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { registerExecuteQueryTool } from "./tools/executeQuery.js";
 import { registerSearchSchemaTool } from "./tools/searchSchema.js";
 import { registerRefreshSchemaTool } from "./tools/refreshSchema.js";
+import { registerPingTool } from "./tools/ping.js";
+import { registerExplainQueryTool } from "./tools/explainQuery.js";
 import { registerTemplatesPrompt } from "./prompts/templates.js";
 import { registerTableResources } from "./resources/tables.js";
 import { buildSchemaGraph } from "./db/schema.js";
 import { initMetadata } from "./db/metadata.js";
 import { closePool } from "./db/index.js";
+import { initLogger, log } from "./utils/logger.js";
 import dotenv from "dotenv";
 dotenv.config({ quiet: true });
 async function main() {
     const server = new McpServer({
         name: "tokenlite-mysql-mcp",
         version: "1.0.0",
+    }, {
+        capabilities: {
+            logging: {},
+        },
     });
+    initLogger(server);
     // Build Semantic Graph on startup
-    await buildSchemaGraph();
+    try {
+        await buildSchemaGraph();
+    }
+    catch (e) {
+        log("warning", `Failed to build schema graph on startup: ${e instanceof Error ? e.message : String(e)}. The server will start in degraded mode.`);
+    }
     // Load Metadata and Templates
     initMetadata();
     // Generate or use provided tool prefix (dev_, prod_ ...)
@@ -30,6 +43,8 @@ async function main() {
     registerSearchSchemaTool(server, prefix);
     registerExecuteQueryTool(server, prefix);
     registerRefreshSchemaTool(server, prefix);
+    registerPingTool(server, prefix);
+    registerExplainQueryTool(server, prefix);
     registerTemplatesPrompt(server, prefix);
     registerTableResources(server);
     const transport = new StdioServerTransport();

package/dist/tools/executeQuery.js

@@ -44,6 +44,9 @@ export function registerExecuteQueryTool(server, prefix = "") {
     // If any write operation is enabled, this tool is no longer read-only
     const isReadOnly = !(allowInsert || allowUpdate || allowDelete || allowDdl);
     server.tool(`${prefix}execute_safe_query`, "Executes a safe SELECT query on the database. Large results are automatically truncated. CRITICAL: NEVER use this tool (e.g., SHOW TABLES or querying information_schema) to understand the database structure. You MUST ALWAYS use the 'search_schema' tool first to understand the relationships and tables before writing any JOIN queries.", {
-        sql: z.string().describe("SQL SELECT statement to execute."),
-    }, { readOnlyHint: isReadOnly }, handleExecuteQuery);
+        sql: z.string().max(10000).describe("SQL SELECT statement to execute."),
+    }, {
+        readOnlyHint: isReadOnly,
+        destructiveHint: allowDelete || allowDdl,
+    }, handleExecuteQuery);
 }

package/dist/tools/explainQuery.js

@@ -0,0 +1,26 @@
+import { z } from "zod";
+import { pool } from "../db/index.js";
+import { jsonToCsv } from "../utils/csvFormatter.js";
+export async function handleExplainQuery({ sql }) {
+    try {
+        const [rows] = await pool.query(`EXPLAIN ${sql}`);
+        const csv = jsonToCsv(rows);
+        return {
+            content: [{ type: "text", text: csv }],
+        };
+    }
+    catch (error) {
+        return {
+            content: [{ type: "text", text: `EXPLAIN Error: ${error.message}` }],
+            isError: true,
+        };
+    }
+}
+export function registerExplainQueryTool(server, prefix = "") {
+    server.tool(`${prefix}explain_query`, "Returns the MySQL EXPLAIN output for a SELECT query. Use this to understand index usage, join types, and row estimates before rewriting a blocked or slow query.", {
+        sql: z.string().max(10000).describe("The SELECT query to analyze."),
+    }, {
+        readOnlyHint: true,
+        idempotentHint: true,
+    }, handleExplainQuery);
+}

package/dist/tools/ping.js

@@ -0,0 +1,37 @@
+import { pool } from "../db/index.js";
+export async function handlePing() {
+    const rawPool = pool.pool;
+    const poolInfo = {
+        active: rawPool._allConnections?.length ?? 0,
+        idle: rawPool._freeConnections?.length ?? 0,
+        queue: rawPool._connectionQueue?.length ?? 0,
+    };
+    try {
+        const [rows] = await pool.query("SELECT VERSION() AS version");
+        const response = {
+            status: "ok",
+            server_version: rows[0]?.version,
+            pool: poolInfo,
+        };
+        return {
+            content: [{ type: "text", text: JSON.stringify(response, null, 2) }],
+        };
+    }
+    catch (error) {
+        const response = {
+            status: "error",
+            pool: poolInfo,
+            error: error.message,
+        };
+        return {
+            content: [{ type: "text", text: JSON.stringify(response, null, 2) }],
+            isError: true,
+        };
+    }
+}
+export function registerPingTool(server, prefix = "") {
+    server.tool(`${prefix}ping`, "Health check: verifies the database connection is alive and returns pool stats and server version.", {}, {
+        readOnlyHint: true,
+        openWorldHint: false,
+    }, handlePing);
+}

package/dist/tools/refreshSchema.js

@@ -1,6 +1,6 @@
 import { buildSchemaGraph } from "../db/schema.js";
 export function registerRefreshSchemaTool(server, prefix = "") {
-    server.tool(`${prefix}refresh_schema`, "Forces the MCP server to rebuild the internal Schema Graph. Use this if you suspect a DBA recently added a table, column, or foreign key and the search_schema or execute queries are failing.", {}, { idempotentHint: true }, async () => {
+    server.tool(`${prefix}refresh_schema`, "Forces the MCP server to rebuild the internal Schema Graph. Use this if you suspect a DBA recently added a table, column, or foreign key and the search_schema or execute queries are failing.", {}, { readOnlyHint: true, idempotentHint: true }, async () => {
         try {
             await buildSchemaGraph();
             return {

package/dist/tools/searchSchema.js

@@ -75,6 +75,6 @@ export async function handleSearchSchema({ query }) {
 }
 export function registerSearchSchemaTool(server, prefix = "") {
     server.tool(`${prefix}search_schema`, "CRITICAL TOOL FOR SCHEMA EXPLORATION: Use this tool FIRST to understand the database structure. Searches for a table and returns its exact SQL DDL, along with the DDL of its direct parent and child tables (Auto-Join Context). Do NOT use execute_safe_query for schema exploration.", {
-        query: z.string().describe("The name of the table or entity to search for (e.g. 'users', 'invoices')."),
-    }, { readOnlyHint: true }, handleSearchSchema);
+        query: z.string().max(200).describe("The name of the table or entity to search for (e.g. 'users', 'invoices')."),
+    }, { readOnlyHint: true, openWorldHint: false }, handleSearchSchema);
 }

package/dist/utils/logger.js

@@ -0,0 +1,39 @@
+import { SetLevelRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+const SEVERITY_ORDER = [
+    "debug", "info", "notice", "warning", "error", "critical", "alert", "emergency"
+];
+let mcpServer = null;
+let minLevel = process.env.MCP_LOG_LEVEL || "info";
+function severityIndex(level) {
+    return SEVERITY_ORDER.indexOf(level);
+}
+export function initLogger(server) {
+    mcpServer = server;
+    server.server.setRequestHandler(SetLevelRequestSchema, async (request) => {
+        const requested = request.params?.level;
+        if (requested && SEVERITY_ORDER.includes(requested)) {
+            minLevel = requested;
+        }
+        return {};
+    });
+}
+export function getMinLevel() {
+    return minLevel;
+}
+export async function log(level, data, logger) {
+    if (severityIndex(level) < severityIndex(minLevel)) {
+        return;
+    }
+    if (mcpServer) {
+        try {
+            await mcpServer.sendLoggingMessage({ level, data, logger });
+            return;
+        }
+        catch {
+            // MCP session not ready yet, fall through to stderr
+        }
+    }
+    const prefix = logger ? `[${logger}]` : "[tokenlite-mysql-mcp]";
+    const msg = typeof data === "string" ? data : JSON.stringify(data);
+    console.error(`${prefix} [${level}] ${msg}`);
+}

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "@andezdev/tokenlite-mysql-mcp",
-  "version": "2.0.0",
+  "version": "3.1.0",
+  "mcpName": "io.github.andezdev/tokenlite-mysql-mcp",
   "description": "A secure, efficient, and intelligent MySQL server for the Model Context Protocol",
   "main": "dist/index.js",
   "type": "module",
@@ -39,8 +40,10 @@
   "homepage": "https://github.com/andezdev/tokenlite-mysql-mcp#readme",
   "scripts": {
     "build": "tsc",
+    "prepublishOnly": "npm run build",
     "start": "node dist/index.js",
     "test": "vitest run",
+    "test:coverage": "vitest run --coverage",
     "test:watch": "vitest",
     "inspect-graph": "tsx scripts/inspect-graph.ts",
     "benchmark": "tsx scripts/benchmark.ts",
@@ -59,6 +62,7 @@
     "@commitlint/config-conventional": "^21.0.2",
     "@types/node": "^22.10.1",
     "@types/node-sql-parser": "^1.0.0",
+    "@vitest/coverage-v8": "^4.1.8",
     "husky": "^9.1.7",
     "js-tiktoken": "^1.0.21",
     "ts-node": "^10.9.2",

package/dist/tools/getTemplates.js

@@ -1,24 +0,0 @@
-import { z } from "zod";
-import { searchTemplates } from "../db/metadata.js";
-export function handleGetTemplates({ query }) {
-    const results = searchTemplates(query || "");
-    if (results.length === 0) {
-        return {
-            content: [{ type: "text", text: "No SQL templates found matching your query." }]
-        };
-    }
-    let output = "--- PRE-APPROVED SQL TEMPLATES ---\n\n";
-    for (const t of results) {
-        output += `### ${t.name}\n`;
-        output += `Description: ${t.description}\n`;
-        output += `SQL:\n\`\`\`sql\n${t.sql}\n\`\`\`\n\n`;
-    }
-    return {
-        content: [{ type: "text", text: output }]
-    };
-}
-export function registerGetTemplatesTool(server) {
-    server.tool("get_query_templates", "NEVER write SQL for business metrics (like LTV, Revenue, Performance) manually. YOU MUST ALWAYS use this tool first to retrieve the official company SQL template. Pass a keyword to search, or leave empty to list all templates.", {
-        query: z.string().optional().describe("Keyword to search for in templates (e.g., 'revenue', 'ltv')."),
-    }, handleGetTemplates);
-}