@berthojoris/mcp-mysql-server 1.16.3 → 1.17.0

package/dist/index.d.ts

@@ -28,6 +28,13 @@ export declare class MySQLMCP {
     private intelligentQueryTools;
     private smartDiscoveryTools;
     private documentationGeneratorTools;
+    private schemaDesignTools;
+    private securityAuditTools;
+    private indexRecommendationTools;
+    private testDataTools;
+    private schemaPatternTools;
+    private queryVisualizationTools;
+    private forecastingTools;
     private security;
     private featureConfig;
     constructor(permissionsConfig?: string, categoriesConfig?: string, presetName?: string);
@@ -1400,5 +1407,164 @@ export declare class MySQLMCP {
         };
         error?: string;
     }>;
+    designSchemaFromRequirements(params: {
+        requirements_text: string;
+        entities?: Array<{
+            name: string;
+            fields?: string[];
+        }>;
+        naming_convention?: "snake_case" | "camelCase";
+        include_audit_columns?: boolean;
+        id_type?: "BIGINT" | "UUID";
+        engine?: string;
+        charset?: string;
+        collation?: string;
+    }): Promise<{
+        status: string;
+        data?: {
+            input: {
+                requirements_text: string;
+                inferred_entities_count: number;
+            };
+            tables: Array<{
+                table_name: string;
+                columns: Array<{
+                    name: string;
+                    type: string;
+                    nullable: boolean;
+                    primary_key?: boolean;
+                    unique?: boolean;
+                    references?: {
+                        table: string;
+                        column: string;
+                    };
+                }>;
+                indexes: Array<{
+                    name: string;
+                    columns: string[];
+                    unique?: boolean;
+                }>;
+            }>;
+            relationships: Array<{
+                from_table: string;
+                from_column: string;
+                to_table: string;
+                to_column: string;
+                type: "one_to_many" | "many_to_one";
+            }>;
+            ddl_statements: string[];
+            notes: string[];
+        };
+        error?: string;
+    }>;
+    auditDatabaseSecurity(params?: {
+        database?: string;
+        include_user_account_checks?: boolean;
+        include_privilege_checks?: boolean;
+    }): Promise<{
+        status: string;
+        data?: {
+            database: string;
+            findings: Array<{
+                severity: "critical" | "medium" | "info" | "low" | "high";
+                title: string;
+                evidence?: string;
+                recommendation: string;
+            }>;
+            summary: {
+                critical: number;
+                high: number;
+                medium: number;
+                low: number;
+                info: number;
+            };
+            notes: string[];
+        };
+        error?: string;
+    }>;
+    recommendIndexes(params?: {
+        database?: string;
+        max_query_patterns?: number;
+        max_recommendations?: number;
+        min_execution_count?: number;
+        min_avg_time_ms?: number;
+        include_unused_index_warnings?: boolean;
+    }): Promise<{
+        status: string;
+        data?: {
+            database: string;
+            analyzed_query_patterns: number;
+            recommendations: Array<{
+                table_name: string;
+                columns: string[];
+                proposed_index_name: string;
+                create_index_sql: string;
+                reason: string;
+                supporting_query_patterns: Array<{
+                    query_pattern: string;
+                    execution_count: number;
+                    avg_execution_time_ms: number;
+                }>;
+            }>;
+            unused_index_warnings?: Array<{
+                table_schema: string;
+                table_name: string;
+                index_name: string;
+                note: string;
+            }>;
+            notes: string[];
+        };
+        error?: string;
+    }>;
+    generateTestData(params: {
+        table_name: string;
+        row_count: number;
+        batch_size?: number;
+        include_nulls?: boolean;
+        database?: string;
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+    }>;
+    analyzeSchemaPatterns(params?: {
+        scope?: "database" | "table";
+        table_name?: string;
+        database?: string;
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+    }>;
+    visualizeQuery(params: {
+        query: string;
+        include_explain_json?: boolean;
+        format?: "mermaid" | "json" | "both";
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+    }>;
+    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;
+    }>;
+    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;
+    }>;
 }
 export default MySQLMCP;

package/dist/index.js

@@ -29,6 +29,13 @@ const macroTools_1 = require("./tools/macroTools");
 const intelligentQueryTools_1 = require("./tools/intelligentQueryTools");
 const smartDiscoveryTools_1 = require("./tools/smartDiscoveryTools");
 const documentationGeneratorTools_1 = require("./tools/documentationGeneratorTools");
+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");
@@ -66,6 +73,13 @@ class MySQLMCP {
         this.intelligentQueryTools = new intelligentQueryTools_1.IntelligentQueryTools(this.security);
         this.smartDiscoveryTools = new smartDiscoveryTools_1.SmartDiscoveryTools(this.security);
         this.documentationGeneratorTools = new documentationGeneratorTools_1.DocumentationGeneratorTools(this.security);
+        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) {
@@ -1128,6 +1142,60 @@ class MySQLMCP {
             return { status: "error", error: check.error };
         return await this.documentationGeneratorTools.generateBusinessGlossaryReport(params);
     }
+    // ==========================================
+    // PHASE 2: AI Enhancement Tools (Schema + Security + Indexing)
+    // ==========================================
+    async designSchemaFromRequirements(params) {
+        const check = this.checkToolEnabled("designSchemaFromRequirements");
+        if (!check.enabled)
+            return { status: "error", error: check.error };
+        return await this.schemaDesignTools.designSchemaFromRequirements(params);
+    }
+    async auditDatabaseSecurity(params) {
+        const check = this.checkToolEnabled("auditDatabaseSecurity");
+        if (!check.enabled)
+            return { status: "error", error: check.error };
+        return await this.securityAuditTools.auditDatabaseSecurity(params);
+    }
+    async recommendIndexes(params) {
+        const check = this.checkToolEnabled("recommendIndexes");
+        if (!check.enabled)
+            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

@@ -2883,6 +2883,250 @@ const TOOLS = [
             required: ["query"],
         },
     },
+    // ==========================================
+    // PHASE 2: AI Enhancement Tools (Schema + Security + Indexing)
+    // ==========================================
+    {
+        name: "design_schema_from_requirements",
+        description: "Designs a database schema from natural language requirements. Returns a proposed schema spec and CREATE TABLE / CREATE INDEX statements (does not execute DDL).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                requirements_text: {
+                    type: "string",
+                    description: "Business requirements in natural language, optionally including entity/field hints.",
+                },
+                entities: {
+                    type: "array",
+                    description: "Optional explicit entity hints to improve accuracy (each entity may include fields).",
+                    items: {
+                        type: "object",
+                        properties: {
+                            name: { type: "string" },
+                            fields: { type: "array", items: { type: "string" } },
+                        },
+                        required: ["name"],
+                    },
+                },
+                naming_convention: {
+                    type: "string",
+                    enum: ["snake_case", "camelCase"],
+                    description: "Naming convention for generated identifiers (default: snake_case).",
+                },
+                include_audit_columns: {
+                    type: "boolean",
+                    description: "Whether to include created_at/updated_at columns (default: true).",
+                },
+                id_type: {
+                    type: "string",
+                    enum: ["BIGINT", "UUID"],
+                    description: "Primary key type for id columns (default: BIGINT).",
+                },
+                engine: {
+                    type: "string",
+                    description: "Storage engine for CREATE TABLE (default: InnoDB).",
+                },
+                charset: {
+                    type: "string",
+                    description: "Default charset (default: utf8mb4).",
+                },
+                collation: {
+                    type: "string",
+                    description: "Default collation (default: utf8mb4_unicode_ci).",
+                },
+            },
+            required: ["requirements_text"],
+        },
+    },
+    {
+        name: "audit_database_security",
+        description: "Audits MySQL security configuration and (optionally) accounts/privileges using read-only inspection queries. Returns prioritized findings and recommendations.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                database: {
+                    type: "string",
+                    description: "Optional: specific database name",
+                },
+                include_user_account_checks: {
+                    type: "boolean",
+                    description: "Include account checks (requires mysql.user privileges, default: true).",
+                },
+                include_privilege_checks: {
+                    type: "boolean",
+                    description: "Include privilege summary checks via INFORMATION_SCHEMA (default: true).",
+                },
+            },
+        },
+    },
+    {
+        name: "recommend_indexes",
+        description: "Analyzes real query patterns from performance_schema digests and suggests concrete CREATE INDEX statements. Uses heuristics to avoid duplicate/redundant indexes.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                database: {
+                    type: "string",
+                    description: "Optional: specific database name",
+                },
+                max_query_patterns: {
+                    type: "number",
+                    description: "Max query patterns to analyze from digests (default: 25, max: 200).",
+                },
+                max_recommendations: {
+                    type: "number",
+                    description: "Max index recommendations to return (default: 25, max: 200).",
+                },
+                min_execution_count: {
+                    type: "number",
+                    description: "Minimum executions for a digest to be considered (default: 5).",
+                },
+                min_avg_time_ms: {
+                    type: "number",
+                    description: "Minimum average execution time (ms) for a digest to be considered (default: 5).",
+                },
+                include_unused_index_warnings: {
+                    type: "boolean",
+                    description: "Include unused index warnings (default: false).",
+                },
+            },
+        },
+    },
+    // ==========================================
+    // 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",
@@ -3070,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: {},
@@ -3531,6 +3775,36 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
             case "generate_business_glossary":
                 result = await mysqlMCP.generateBusinessGlossary((args || {}));
                 break;
+            // ==========================================
+            // PHASE 2: AI Enhancement Tools (Schema + Security + Indexing)
+            // ==========================================
+            case "design_schema_from_requirements":
+                result = await mysqlMCP.designSchemaFromRequirements((args || {}));
+                break;
+            case "audit_database_security":
+                result = await mysqlMCP.auditDatabaseSecurity((args || {}));
+                break;
+            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;
+    }>;
+}