@berthojoris/mcp-mysql-server 1.16.4 → 1.17.0

package/dist/index.js

@@ -32,6 +32,10 @@ const documentationGeneratorTools_1 = require("./tools/documentationGeneratorToo
 const schemaDesignTools_1 = require("./tools/schemaDesignTools");
 const securityAuditTools_1 = require("./tools/securityAuditTools");
 const indexRecommendationTools_1 = require("./tools/indexRecommendationTools");
+const testDataTools_1 = require("./tools/testDataTools");
+const schemaPatternTools_1 = require("./tools/schemaPatternTools");
+const queryVisualizationTools_1 = require("./tools/queryVisualizationTools");
+const forecastingTools_1 = require("./tools/forecastingTools");
 const securityLayer_1 = __importDefault(require("./security/securityLayer"));
 const connection_1 = __importDefault(require("./db/connection"));
 const featureConfig_1 = require("./config/featureConfig");
@@ -72,6 +76,10 @@ class MySQLMCP {
         this.schemaDesignTools = new schemaDesignTools_1.SchemaDesignTools(this.security);
         this.securityAuditTools = new securityAuditTools_1.SecurityAuditTools();
         this.indexRecommendationTools = new indexRecommendationTools_1.IndexRecommendationTools(this.security);
+        this.testDataTools = new testDataTools_1.TestDataTools(this.security);
+        this.schemaPatternTools = new schemaPatternTools_1.SchemaPatternTools(this.security);
+        this.queryVisualizationTools = new queryVisualizationTools_1.QueryVisualizationTools(this.security);
+        this.forecastingTools = new forecastingTools_1.ForecastingTools(this.security);
     }
     // Helper method to check if tool is enabled
     checkToolEnabled(toolName) {
@@ -1155,6 +1163,39 @@ class MySQLMCP {
             return { status: "error", error: check.error };
         return await this.indexRecommendationTools.recommendIndexes(params);
     }
+    // ==========================================
+    // PHASE 3: AI Enhancement Tools (Data Gen + Patterns + Visualization + Forecasting)
+    // ==========================================
+    async generateTestData(params) {
+        const check = this.checkToolEnabled("generateTestData");
+        if (!check.enabled)
+            return { status: "error", error: check.error };
+        return await this.testDataTools.generateTestData(params);
+    }
+    async analyzeSchemaPatterns(params) {
+        const check = this.checkToolEnabled("analyzeSchemaPatterns");
+        if (!check.enabled)
+            return { status: "error", error: check.error };
+        return await this.schemaPatternTools.analyzeSchemaPatterns(params);
+    }
+    async visualizeQuery(params) {
+        const check = this.checkToolEnabled("visualizeQuery");
+        if (!check.enabled)
+            return { status: "error", error: check.error };
+        return await this.queryVisualizationTools.visualizeQuery(params);
+    }
+    async predictQueryPerformance(params) {
+        const check = this.checkToolEnabled("predictQueryPerformance");
+        if (!check.enabled)
+            return { status: "error", error: check.error };
+        return await this.forecastingTools.predictQueryPerformance(params);
+    }
+    async forecastDatabaseGrowth(params) {
+        const check = this.checkToolEnabled("forecastDatabaseGrowth");
+        if (!check.enabled)
+            return { status: "error", error: check.error };
+        return await this.forecastingTools.forecastDatabaseGrowth(params);
+    }
 }
 exports.MySQLMCP = MySQLMCP;
 exports.default = MySQLMCP;

package/dist/mcp-server.js

@@ -2992,6 +2992,141 @@ const TOOLS = [
             },
         },
     },
+    // ==========================================
+    // PHASE 3: AI Enhancement Tools (Data Gen + Patterns + Visualization + Forecasting)
+    // ==========================================
+    {
+        name: "generate_test_data",
+        description: "Generates synthetic test data as SQL INSERT statements for a given table (does not execute). Attempts FK-aware value selection for referential integrity.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                table_name: {
+                    type: "string",
+                    description: "Target table to generate INSERT statements for",
+                },
+                row_count: {
+                    type: "number",
+                    description: "Number of rows to generate (max 5000)",
+                },
+                batch_size: {
+                    type: "number",
+                    description: "Rows per INSERT statement (default 100, max 1000)",
+                },
+                include_nulls: {
+                    type: "boolean",
+                    description: "Whether generated values may include NULLs when columns are nullable (default true)",
+                },
+                database: {
+                    type: "string",
+                    description: "Optional: specific database name",
+                },
+            },
+            required: ["table_name", "row_count"],
+        },
+    },
+    {
+        name: "analyze_schema_patterns",
+        description: "Analyzes the schema for common patterns and anti-patterns (missing PKs, wide tables, unindexed FKs, EAV-like tables, etc.) and returns recommendations.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                scope: {
+                    type: "string",
+                    enum: ["database", "table"],
+                    description: "Analysis scope (default: database unless table_name provided)",
+                },
+                table_name: {
+                    type: "string",
+                    description: "Optional: specific table to analyze (implies table scope)",
+                },
+                database: {
+                    type: "string",
+                    description: "Optional: specific database name",
+                },
+            },
+        },
+    },
+    {
+        name: "visualize_query",
+        description: "Creates a visual representation of a read-only SQL query as a Mermaid flowchart, based on EXPLAIN FORMAT=JSON and lightweight SQL parsing.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                query: {
+                    type: "string",
+                    description: "Read-only SQL query to visualize",
+                },
+                include_explain_json: {
+                    type: "boolean",
+                    description: "Include full EXPLAIN JSON in the response (default true)",
+                },
+                format: {
+                    type: "string",
+                    enum: ["mermaid", "json", "both"],
+                    description: "Output format (default: both)",
+                },
+            },
+            required: ["query"],
+        },
+    },
+    {
+        name: "predict_query_performance",
+        description: "Predicts how EXPLAIN-estimated scan volume/cost could change under table growth assumptions (heuristic).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                query: {
+                    type: "string",
+                    description: "Read-only SQL query to analyze",
+                },
+                row_growth_multiplier: {
+                    type: "number",
+                    description: "Default multiplicative growth factor to apply to table row estimates (default 2)",
+                },
+                per_table_row_growth: {
+                    type: "object",
+                    description: "Optional per-table growth overrides: { tableName: factor }",
+                    additionalProperties: { type: "number" },
+                },
+                include_explain_json: {
+                    type: "boolean",
+                    description: "Include full EXPLAIN JSON in the response (default false)",
+                },
+            },
+            required: ["query"],
+        },
+    },
+    {
+        name: "forecast_database_growth",
+        description: "Forecasts database/table growth based on current INFORMATION_SCHEMA sizes and user-supplied growth rate assumptions.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                horizon_days: {
+                    type: "number",
+                    description: "Forecast horizon in days (default 30, max 3650)",
+                },
+                growth_rate_percent_per_day: {
+                    type: "number",
+                    description: "Base daily growth rate percent applied to all tables unless overridden (e.g., 0.5)",
+                },
+                growth_rate_percent_per_month: {
+                    type: "number",
+                    description: "Base monthly growth rate percent (converted to daily compound rate)",
+                },
+                per_table_growth_rate_percent_per_day: {
+                    type: "object",
+                    description: "Optional per-table daily growth rate percent overrides: { tableName: percentPerDay }",
+                    additionalProperties: { type: "number" },
+                },
+                database: {
+                    type: "string",
+                    description: "Optional: specific database name",
+                },
+            },
+        },
+    },
     // Smart Data Discovery
     {
         name: "smart_search",
@@ -3179,7 +3314,7 @@ const TOOLS = [
 // Create the MCP server
 const server = new index_js_1.Server({
     name: "mysql-mcp-server",
-    version: "1.12.0",
+    version: "1.17.0",
 }, {
     capabilities: {
         tools: {},
@@ -3652,6 +3787,24 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
             case "recommend_indexes":
                 result = await mysqlMCP.recommendIndexes((args || {}));
                 break;
+            // ==========================================
+            // PHASE 3: AI Enhancement Tools (Data Gen + Patterns + Visualization + Forecasting)
+            // ==========================================
+            case "generate_test_data":
+                result = await mysqlMCP.generateTestData((args || {}));
+                break;
+            case "analyze_schema_patterns":
+                result = await mysqlMCP.analyzeSchemaPatterns((args || {}));
+                break;
+            case "visualize_query":
+                result = await mysqlMCP.visualizeQuery((args || {}));
+                break;
+            case "predict_query_performance":
+                result = await mysqlMCP.predictQueryPerformance((args || {}));
+                break;
+            case "forecast_database_growth":
+                result = await mysqlMCP.forecastDatabaseGrowth((args || {}));
+                break;
             default:
                 throw new Error(`Unknown tool: ${name}`);
         }

package/dist/tools/forecastingTools.d.ts

@@ -0,0 +1,36 @@
+import { SecurityLayer } from "../security/securityLayer";
+export declare class ForecastingTools {
+    private db;
+    private security;
+    constructor(security: SecurityLayer);
+    private validateDatabaseAccess;
+    private extractExplainNodes;
+    /**
+     * Predict how query cost/scan volume might change under table growth assumptions.
+     * This is heuristic-based and uses EXPLAIN FORMAT=JSON estimates.
+     */
+    predictQueryPerformance(params: {
+        query: string;
+        row_growth_multiplier?: number;
+        per_table_row_growth?: Record<string, number>;
+        include_explain_json?: boolean;
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+    }>;
+    /**
+     * Forecast database/table growth based on current sizes and user-supplied growth rate assumptions.
+     */
+    forecastDatabaseGrowth(params?: {
+        horizon_days?: number;
+        growth_rate_percent_per_day?: number;
+        growth_rate_percent_per_month?: number;
+        per_table_growth_rate_percent_per_day?: Record<string, number>;
+        database?: string;
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+    }>;
+}

package/dist/tools/forecastingTools.js

@@ -0,0 +1,256 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ForecastingTools = void 0;
+const connection_1 = __importDefault(require("../db/connection"));
+const config_1 = require("../config/config");
+class ForecastingTools {
+    constructor(security) {
+        this.db = connection_1.default.getInstance();
+        this.security = security;
+    }
+    validateDatabaseAccess(requestedDatabase) {
+        const connectedDatabase = config_1.dbConfig.database;
+        if (!connectedDatabase) {
+            return {
+                valid: false,
+                database: "",
+                error: "No database configured. Please specify a database in your connection settings.",
+            };
+        }
+        if (requestedDatabase && requestedDatabase !== connectedDatabase) {
+            return {
+                valid: false,
+                database: "",
+                error: `Access denied: You are connected to '${connectedDatabase}' but requested '${requestedDatabase}'. Cross-database access is not permitted.`,
+            };
+        }
+        return { valid: true, database: connectedDatabase };
+    }
+    extractExplainNodes(explainJson) {
+        const nodes = [];
+        const visit = (obj) => {
+            if (!obj || typeof obj !== "object")
+                return;
+            if (obj.table && typeof obj.table === "object") {
+                const t = obj.table;
+                nodes.push({
+                    table_name: t.table_name,
+                    access_type: t.access_type,
+                    key: t.key,
+                    rows_examined_per_scan: t.rows_examined_per_scan,
+                    rows_produced_per_join: t.rows_produced_per_join,
+                    filtered: t.filtered,
+                });
+            }
+            for (const v of Object.values(obj)) {
+                if (Array.isArray(v))
+                    v.forEach(visit);
+                else if (v && typeof v === "object")
+                    visit(v);
+            }
+        };
+        visit(explainJson);
+        return nodes;
+    }
+    /**
+     * Predict how query cost/scan volume might change under table growth assumptions.
+     * This is heuristic-based and uses EXPLAIN FORMAT=JSON estimates.
+     */
+    async predictQueryPerformance(params) {
+        try {
+            const query = params.query;
+            if (!query || typeof query !== "string") {
+                return { status: "error", error: "query is required" };
+            }
+            if (!this.security.isReadOnlyQuery(query)) {
+                return {
+                    status: "error",
+                    error: "Only read-only queries (SELECT/SHOW/DESCRIBE/EXPLAIN) are supported for prediction.",
+                };
+            }
+            const growth = params.row_growth_multiplier ?? 2;
+            if (!Number.isFinite(growth) || growth <= 0) {
+                return { status: "error", error: "row_growth_multiplier must be > 0" };
+            }
+            const explainRows = await this.db.query(`EXPLAIN FORMAT=JSON ${query}`);
+            let explainJson = null;
+            let queryCost = null;
+            if (explainRows[0] && explainRows[0].EXPLAIN) {
+                try {
+                    explainJson = JSON.parse(explainRows[0].EXPLAIN);
+                    const qc = explainJson?.query_block?.cost_info?.query_cost;
+                    queryCost = qc !== undefined ? parseFloat(String(qc)) : null;
+                }
+                catch {
+                    explainJson = explainRows;
+                }
+            }
+            const nodes = explainJson ? this.extractExplainNodes(explainJson) : [];
+            const perTable = params.per_table_row_growth || {};
+            const tablePredictions = nodes
+                .filter((n) => !!n.table_name)
+                .map((n) => {
+                const t = n.table_name;
+                const factor = typeof perTable[t] === "number" && perTable[t] > 0
+                    ? perTable[t]
+                    : growth;
+                const baseRows = n.rows_examined_per_scan ?? n.rows_produced_per_join ?? null;
+                const predictedRows = typeof baseRows === "number" ? Math.round(baseRows * factor) : null;
+                return {
+                    table_name: t,
+                    access_type: n.access_type,
+                    key: n.key,
+                    base_rows_estimate: baseRows,
+                    growth_factor: factor,
+                    predicted_rows_estimate: predictedRows,
+                };
+            });
+            const avgFactor = tablePredictions.length > 0
+                ? tablePredictions.reduce((acc, t) => acc + t.growth_factor, 0) /
+                    tablePredictions.length
+                : growth;
+            const predictedCost = typeof queryCost === "number" && Number.isFinite(queryCost)
+                ? parseFloat((queryCost * avgFactor).toFixed(4))
+                : null;
+            const worstScan = tablePredictions.reduce((max, t) => Math.max(max, t.predicted_rows_estimate || 0), 0);
+            let risk = "low";
+            if (worstScan > 1000000)
+                risk = "high";
+            else if (worstScan > 100000)
+                risk = "medium";
+            const recommendations = [];
+            for (const t of tablePredictions) {
+                if ((t.access_type || "").toUpperCase() === "ALL") {
+                    recommendations.push(`Table '${t.table_name}' is using a full scan (access_type=ALL). Consider adding an index aligned with WHERE/JOIN predicates.`);
+                }
+                if (!t.key && (t.predicted_rows_estimate || 0) > 100000) {
+                    recommendations.push(`Table '${t.table_name}' has no chosen index in EXPLAIN and predicted scan is large; review indexing and query predicates.`);
+                }
+            }
+            const data = {
+                current_estimate: {
+                    query_cost: queryCost,
+                },
+                growth_assumptions: {
+                    row_growth_multiplier: growth,
+                    per_table_row_growth: perTable,
+                    cost_scaling_model: "cost ~ linear in average growth factor (heuristic)",
+                },
+                predicted_estimate: {
+                    query_cost: predictedCost,
+                },
+                table_estimates: tablePredictions,
+                risk,
+                recommendations,
+                notes: [
+                    "This is an estimate based on MySQL EXPLAIN and simple scaling assumptions.",
+                    "Validate with production-like data volumes and real timings.",
+                ],
+            };
+            if (params.include_explain_json ?? false) {
+                data.explain_json = explainJson;
+            }
+            return { status: "success", data };
+        }
+        catch (error) {
+            return { status: "error", error: error.message };
+        }
+    }
+    /**
+     * Forecast database/table growth based on current sizes and user-supplied growth rate assumptions.
+     */
+    async forecastDatabaseGrowth(params = {}) {
+        try {
+            const dbValidation = this.validateDatabaseAccess(params?.database);
+            if (!dbValidation.valid) {
+                return { status: "error", error: dbValidation.error };
+            }
+            const database = dbValidation.database;
+            const horizonDays = Math.min(Math.max(params.horizon_days ?? 30, 1), 3650);
+            let baseDailyRate = null;
+            if (typeof params.growth_rate_percent_per_day === "number") {
+                baseDailyRate = params.growth_rate_percent_per_day / 100;
+            }
+            else if (typeof params.growth_rate_percent_per_month === "number") {
+                const monthly = params.growth_rate_percent_per_month / 100;
+                // Convert to approx daily compound rate assuming 30-day month
+                baseDailyRate = Math.pow(1 + monthly, 1 / 30) - 1;
+            }
+            const perTableRates = params.per_table_growth_rate_percent_per_day || {};
+            if (baseDailyRate === null && Object.keys(perTableRates).length === 0) {
+                return {
+                    status: "error",
+                    error: "Provide growth_rate_percent_per_day or growth_rate_percent_per_month, or per_table_growth_rate_percent_per_day.",
+                };
+            }
+            const rows = await this.db.query(`
+          SELECT TABLE_NAME, TABLE_ROWS, DATA_LENGTH, INDEX_LENGTH
+          FROM INFORMATION_SCHEMA.TABLES
+          WHERE TABLE_SCHEMA = ? AND TABLE_TYPE = 'BASE TABLE'
+          ORDER BY TABLE_NAME
+        `, [database]);
+            const tableForecasts = rows.map((r) => {
+                const table = r.TABLE_NAME;
+                const currentRows = typeof r.TABLE_ROWS === "number"
+                    ? r.TABLE_ROWS
+                    : parseInt(String(r.TABLE_ROWS || "0"), 10) || 0;
+                const dataBytes = typeof r.DATA_LENGTH === "number"
+                    ? r.DATA_LENGTH
+                    : parseInt(String(r.DATA_LENGTH || "0"), 10) || 0;
+                const indexBytes = typeof r.INDEX_LENGTH === "number"
+                    ? r.INDEX_LENGTH
+                    : parseInt(String(r.INDEX_LENGTH || "0"), 10) || 0;
+                const totalBytes = dataBytes + indexBytes;
+                const dailyRate = typeof perTableRates[table] === "number"
+                    ? perTableRates[table] / 100
+                    : baseDailyRate || 0;
+                const growthFactor = Math.pow(1 + dailyRate, horizonDays);
+                const forecastRows = Math.round(currentRows * growthFactor);
+                const forecastTotalBytes = Math.round(totalBytes * growthFactor);
+                return {
+                    table_name: table,
+                    current: {
+                        row_estimate: currentRows,
+                        total_size_bytes: totalBytes,
+                        data_size_bytes: dataBytes,
+                        index_size_bytes: indexBytes,
+                    },
+                    assumptions: {
+                        daily_growth_rate_percent: dailyRate * 100,
+                        horizon_days: horizonDays,
+                    },
+                    forecast: {
+                        row_estimate: forecastRows,
+                        total_size_bytes: forecastTotalBytes,
+                    },
+                };
+            });
+            const totals = {
+                current_total_bytes: tableForecasts.reduce((acc, t) => acc + t.current.total_size_bytes, 0),
+                forecast_total_bytes: tableForecasts.reduce((acc, t) => acc + t.forecast.total_size_bytes, 0),
+            };
+            return {
+                status: "success",
+                data: {
+                    database,
+                    horizon_days: horizonDays,
+                    base_growth_rate_percent_per_day: baseDailyRate === null ? null : baseDailyRate * 100,
+                    per_table_growth_rate_percent_per_day: perTableRates,
+                    totals,
+                    tables: tableForecasts,
+                    notes: [
+                        "Forecast uses simple exponential growth from current INFORMATION_SCHEMA sizes.",
+                        "Row counts and sizes are estimates and may be stale depending on storage engine/statistics.",
+                    ],
+                },
+            };
+        }
+        catch (error) {
+            return { status: "error", error: error.message };
+        }
+    }
+}
+exports.ForecastingTools = ForecastingTools;

package/dist/tools/queryVisualizationTools.d.ts

@@ -0,0 +1,22 @@
+import { SecurityLayer } from "../security/securityLayer";
+export declare class QueryVisualizationTools {
+    private db;
+    private security;
+    constructor(security: SecurityLayer);
+    private extractExplainNodes;
+    private sqlJoinEdges;
+    private buildMermaid;
+    /**
+     * Create a lightweight visual representation of a SQL query.
+     * Returns Mermaid flowchart + EXPLAIN FORMAT=JSON summary.
+     */
+    visualizeQuery(params: {
+        query: string;
+        include_explain_json?: boolean;
+        format?: "mermaid" | "json" | "both";
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+    }>;
+}