@berthojoris/mcp-mysql-server 1.14.1 → 1.16.0

package/dist/config/featureConfig.js

@@ -52,6 +52,7 @@ var DocCategory;
     DocCategory["DATA_MIGRATION"] = "data_migration";
     DocCategory["SCHEMA_MIGRATIONS"] = "schema_migrations";
     DocCategory["ANALYSIS"] = "analysis";
+    DocCategory["AI_ENHANCEMENT"] = "ai_enhancement";
 })(DocCategory || (exports.DocCategory = DocCategory = {}));
 const normalizePresetName = (value) => (value || "").toLowerCase().replace(/[\s_-]/g, "");
 const permissionPresets = {
@@ -84,6 +85,7 @@ const permissionPresets = {
             DocCategory.QUERY_OPTIMIZATION,
             DocCategory.CACHE_MANAGEMENT,
             DocCategory.SERVER_MANAGEMENT,
+            DocCategory.AI_ENHANCEMENT,
         ],
     },
     dbalite: {
@@ -115,6 +117,58 @@ const permissionPresets = {
             DocCategory.STORED_PROCEDURES,
         ],
     },
+    dev: {
+        name: "dev",
+        description: "Development profile with full access to all tools",
+        permissions: Object.values(ToolCategory),
+        categories: Object.values(DocCategory),
+        deniedTools: [], // Explicitly allow everything
+    },
+    stage: {
+        name: "stage",
+        description: "Staging profile with data modification but no destructive DDL",
+        permissions: [
+            ToolCategory.LIST,
+            ToolCategory.READ,
+            ToolCategory.CREATE,
+            ToolCategory.UPDATE,
+            ToolCategory.DELETE,
+            ToolCategory.UTILITY,
+            ToolCategory.TRANSACTION,
+        ],
+        categories: [
+            DocCategory.DATABASE_DISCOVERY,
+            DocCategory.CRUD_OPERATIONS,
+            DocCategory.BULK_OPERATIONS,
+            DocCategory.CUSTOM_QUERIES,
+            DocCategory.UTILITIES,
+            DocCategory.TRANSACTION_MANAGEMENT,
+            DocCategory.IMPORT_EXPORT,
+            DocCategory.DATA_MIGRATION,
+            DocCategory.PERFORMANCE_MONITORING,
+            DocCategory.ANALYSIS,
+        ],
+        deniedTools: ["drop_table", "truncate_table", "drop_database"],
+    },
+    prod: {
+        name: "prod",
+        description: "Production profile with strict read-only access and safety checks",
+        permissions: [ToolCategory.LIST, ToolCategory.READ, ToolCategory.UTILITY],
+        categories: [
+            DocCategory.DATABASE_DISCOVERY,
+            DocCategory.CRUD_OPERATIONS, // Read only via permissions
+            DocCategory.CUSTOM_QUERIES,
+            DocCategory.UTILITIES,
+            DocCategory.PERFORMANCE_MONITORING,
+            DocCategory.ANALYSIS,
+        ],
+        deniedTools: [
+            "create_table", "alter_table", "drop_table", "truncate_table",
+            "create_record", "update_record", "delete_record",
+            "bulk_insert", "bulk_update", "bulk_delete",
+            "execute_sql", "execute_ddl"
+        ],
+    },
 };
 /**
  * Map of tool names to their legacy categories
@@ -153,6 +207,8 @@ exports.toolCategoryMap = {
     getTableRelationships: ToolCategory.UTILITY,
     exportTableToCSV: ToolCategory.UTILITY,
     exportQueryToCSV: ToolCategory.UTILITY,
+    safe_export_table: ToolCategory.UTILITY,
+    read_changelog: ToolCategory.UTILITY,
     // Transaction tools
     beginTransaction: ToolCategory.TRANSACTION,
     commitTransaction: ToolCategory.TRANSACTION,
@@ -256,6 +312,15 @@ exports.toolCategoryMap = {
     getConnectionPoolStats: ToolCategory.UTILITY,
     getDatabaseHealthCheck: ToolCategory.UTILITY,
     resetPerformanceStats: ToolCategory.UTILITY,
+    // Phase 1: AI Enhancement Tools
+    buildQueryFromIntent: ToolCategory.READ,
+    suggestQueryImprovements: ToolCategory.UTILITY,
+    smartSearch: ToolCategory.LIST,
+    findSimilarColumns: ToolCategory.LIST,
+    discoverDataPatterns: ToolCategory.READ,
+    generateDocumentation: ToolCategory.UTILITY,
+    generateDataDictionary: ToolCategory.UTILITY,
+    generateBusinessGlossary: ToolCategory.UTILITY,
 };
 /**
  * Map of tool names to their documentation categories (New Enhanced System)
@@ -288,6 +353,7 @@ exports.toolDocCategoryMap = {
     describeConnection: DocCategory.UTILITIES,
     exportTableToCSV: DocCategory.UTILITIES,
     exportQueryToCSV: DocCategory.UTILITIES,
+    read_changelog: DocCategory.UTILITIES,
     // Transaction Management
     beginTransaction: DocCategory.TRANSACTION_MANAGEMENT,
     commitTransaction: DocCategory.TRANSACTION_MANAGEMENT,
@@ -408,6 +474,15 @@ exports.toolDocCategoryMap = {
     getSchemaERD: DocCategory.ANALYSIS,
     getColumnStatistics: DocCategory.ANALYSIS,
     getSchemaRagContext: DocCategory.ANALYSIS,
+    // Phase 1: AI Enhancement
+    buildQueryFromIntent: DocCategory.AI_ENHANCEMENT,
+    suggestQueryImprovements: DocCategory.AI_ENHANCEMENT,
+    smartSearch: DocCategory.AI_ENHANCEMENT,
+    findSimilarColumns: DocCategory.AI_ENHANCEMENT,
+    discoverDataPatterns: DocCategory.AI_ENHANCEMENT,
+    generateDocumentation: DocCategory.AI_ENHANCEMENT,
+    generateDataDictionary: DocCategory.AI_ENHANCEMENT,
+    generateBusinessGlossary: DocCategory.AI_ENHANCEMENT,
 };
 /**
  * Mapping between legacy categories and documentation categories
@@ -518,6 +593,9 @@ class FeatureConfig {
         const parsed = this.parseConfig(mergedPermissions, mergedCategories);
         this.enabledLegacyCategories = parsed.legacy;
         this.enabledDocCategories = parsed.doc;
+        // Initialize Allow/Deny Lists
+        this.allowedTools = new Set(this.activePreset?.allowedTools || []);
+        this.deniedTools = new Set(this.activePreset?.deniedTools || []);
     }
     /**
      * Normalize and merge preset + user-supplied configuration lists
@@ -576,6 +654,9 @@ class FeatureConfig {
                 docCats.forEach((dc) => docSet.add(dc));
             });
         }
+        // Re-initialize Allow/Deny Lists if preset changed
+        this.allowedTools = new Set(this.activePreset?.allowedTools || []);
+        this.deniedTools = new Set(this.activePreset?.deniedTools || []);
         return {
             legacy: legacySet,
             doc: docSet,
@@ -632,6 +713,15 @@ class FeatureConfig {
             console.warn(`Unknown tool: ${toolName}`);
             return false;
         }
+        // Layer 0: Check explicit Deny/Allow lists
+        // Deny takes precedence
+        if (this.deniedTools.has(toolName)) {
+            return false;
+        }
+        // Allow overrides other checks
+        if (this.allowedTools.has(toolName)) {
+            return true;
+        }
         // Layer 1: Check permission (legacy category)
         const hasPermission = legacyCategory
             ? this.enabledLegacyCategories.has(legacyCategory)
@@ -658,6 +748,9 @@ class FeatureConfig {
         if (!docCategory && !legacyCategory) {
             return `Unknown tool '${toolName}'. This tool is not recognized by the MCP server.`;
         }
+        if (this.deniedTools.has(toolName)) {
+            return `Permission denied: Tool '${toolName}' is explicitly denied by the current profile ('${this.presetName}').`;
+        }
         const isAllEnabled = !this.originalPermissionsString.trim() &&
             !this.originalCategoriesString.trim();
         if (isAllEnabled) {

package/dist/index.d.ts

@@ -25,6 +25,9 @@ export declare class MySQLMCP {
     private analysisTools;
     private aiTools;
     private macroTools;
+    private intelligentQueryTools;
+    private smartDiscoveryTools;
+    private documentationGeneratorTools;
     private security;
     private featureConfig;
     constructor(permissionsConfig?: string, categoriesConfig?: string, presetName?: string);
@@ -190,6 +193,14 @@ export declare class MySQLMCP {
         data?: any;
         error?: string;
     }>;
+    readChangelog(params?: {
+        version?: string;
+        limit?: number;
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+    }>;
     beginTransaction(params?: {
         transactionId?: string;
     }): Promise<import("./tools/transactionTools").TransactionResult | {
@@ -1167,5 +1178,227 @@ export declare class MySQLMCP {
         message?: string;
         error?: string;
     }>;
+    buildQueryFromIntent(params: {
+        natural_language: string;
+        context?: "analytics" | "reporting" | "data_entry" | "schema_exploration";
+        max_complexity?: "simple" | "medium" | "complex";
+        safety_level?: "strict" | "moderate" | "permissive";
+        database?: string;
+    }): Promise<{
+        status: string;
+        data?: {
+            generated_sql: string;
+            explanation: string;
+            tables_involved: string[];
+            columns_involved: string[];
+            estimated_complexity: string;
+            safety_notes: string[];
+            optimization_hints: string[];
+            alternatives?: string[];
+        };
+        error?: string;
+    }>;
+    suggestQueryImprovements(params: {
+        query: string;
+        optimization_goal?: "speed" | "memory" | "readability";
+        database?: string;
+    }): Promise<{
+        status: string;
+        data?: {
+            original_query: string;
+            suggestions: Array<{
+                type: string;
+                description: string;
+                improved_query?: string;
+            }>;
+            estimated_improvement: string;
+        };
+        error?: string;
+    }>;
+    smartSearch(params: {
+        search_term: string;
+        search_type?: "column" | "table" | "data_pattern" | "relationship" | "all";
+        similarity_threshold?: number;
+        include_sample_data?: boolean;
+        max_results?: number;
+        database?: string;
+    }): Promise<{
+        status: string;
+        data?: {
+            search_term: string;
+            search_type: string;
+            results: {
+                tables: Array<{
+                    name: string;
+                    relevance_score: number;
+                    match_reason: string;
+                    column_count: number;
+                    row_estimate: number;
+                    matching_columns?: string[];
+                }>;
+                columns: Array<{
+                    table_name: string;
+                    column_name: string;
+                    data_type: string;
+                    relevance_score: number;
+                    match_reason: string;
+                    sample_values?: any[];
+                }>;
+                data_patterns: Array<{
+                    table_name: string;
+                    column_name: string;
+                    pattern_type: string;
+                    description: string;
+                    sample_matches?: any[];
+                }>;
+                relationships: Array<{
+                    from_table: string;
+                    from_column: string;
+                    to_table: string;
+                    to_column: string;
+                    relationship_type: string;
+                    confidence: number;
+                }>;
+            };
+            total_matches: number;
+            search_time_ms: number;
+        };
+        error?: string;
+    }>;
+    findSimilarColumns(params: {
+        column_name?: string;
+        table_name?: string;
+        include_data_comparison?: boolean;
+        max_results?: number;
+        database?: string;
+    }): Promise<{
+        status: string;
+        data?: {
+            reference_column?: {
+                table: string;
+                column: string;
+                data_type: string;
+            };
+            similar_columns: Array<{
+                table_name: string;
+                column_name: string;
+                data_type: string;
+                similarity_score: number;
+                similarity_type: string;
+                data_overlap_percentage?: number;
+            }>;
+            potential_joins: Array<{
+                table1: string;
+                column1: string;
+                table2: string;
+                column2: string;
+                confidence: number;
+                reason: string;
+            }>;
+        };
+        error?: string;
+    }>;
+    discoverDataPatterns(params: {
+        table_name: string;
+        pattern_types?: Array<"unique" | "null" | "duplicate" | "format" | "range">;
+        max_columns?: number;
+        database?: string;
+    }): Promise<{
+        status: string;
+        data?: {
+            table_name: string;
+            patterns: Array<{
+                column_name: string;
+                pattern_type: string;
+                description: string;
+                metrics?: Record<string, any>;
+                recommendations?: string[];
+            }>;
+            summary: {
+                columns_analyzed: number;
+                patterns_found: number;
+                data_quality_score: number;
+            };
+        };
+        error?: string;
+    }>;
+    generateDocumentation(params: {
+        scope?: "database" | "table" | "column" | "relationship";
+        table_name?: string;
+        include_business_glossary?: boolean;
+        format?: "markdown" | "html" | "json";
+        include_examples?: boolean;
+        include_statistics?: boolean;
+        database?: string;
+    }): Promise<{
+        status: string;
+        data?: {
+            format: string;
+            scope: string;
+            content: string;
+            metadata: {
+                generated_at: string;
+                database: string;
+                tables_documented: number;
+                columns_documented: number;
+            };
+        };
+        error?: string;
+    }>;
+    generateDataDictionary(params: {
+        table_name: string;
+        include_sample_values?: boolean;
+        include_constraints?: boolean;
+        database?: string;
+    }): Promise<{
+        status: string;
+        data?: {
+            table_name: string;
+            description: string;
+            columns: Array<{
+                name: string;
+                data_type: string;
+                description: string;
+                constraints: string[];
+                is_nullable: boolean;
+                default_value: string | null;
+                sample_values?: any[];
+                business_term?: string;
+            }>;
+            primary_key: string[];
+            foreign_keys: Array<{
+                column: string;
+                references_table: string;
+                references_column: string;
+            }>;
+            indexes: Array<{
+                name: string;
+                columns: string[];
+                is_unique: boolean;
+            }>;
+        };
+        error?: string;
+    }>;
+    generateBusinessGlossary(params: {
+        include_descriptions?: boolean;
+        group_by?: "table" | "category" | "alphabetical";
+        database?: string;
+    }): Promise<{
+        status: string;
+        data?: {
+            glossary: Array<{
+                term: string;
+                technical_name: string;
+                source_table: string;
+                data_type: string;
+                description: string;
+                category: string;
+                related_terms?: string[];
+            }>;
+            categories: string[];
+            total_terms: number;
+        };
+        error?: string;
+    }>;
 }
 export default MySQLMCP;

package/dist/index.js

@@ -26,6 +26,9 @@ const performanceTools_1 = require("./tools/performanceTools");
 const analysisTools_1 = require("./tools/analysisTools");
 const aiTools_1 = require("./tools/aiTools");
 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 securityLayer_1 = __importDefault(require("./security/securityLayer"));
 const connection_1 = __importDefault(require("./db/connection"));
 const featureConfig_1 = require("./config/featureConfig");
@@ -60,6 +63,9 @@ class MySQLMCP {
         this.analysisTools = new analysisTools_1.AnalysisTools(this.security);
         this.aiTools = new aiTools_1.AiTools(this.security);
         this.macroTools = new macroTools_1.MacroTools(this.security);
+        this.intelligentQueryTools = new intelligentQueryTools_1.IntelligentQueryTools(this.security);
+        this.smartDiscoveryTools = new smartDiscoveryTools_1.SmartDiscoveryTools(this.security);
+        this.documentationGeneratorTools = new documentationGeneratorTools_1.DocumentationGeneratorTools(this.security);
     }
     // Helper method to check if tool is enabled
     checkToolEnabled(toolName) {
@@ -234,6 +240,13 @@ class MySQLMCP {
         }
         return await this.utilityTools.getTableRelationships(params);
     }
+    async readChangelog(params) {
+        const check = this.checkToolEnabled("read_changelog");
+        if (!check.enabled) {
+            return { status: "error", error: check.error };
+        }
+        return await this.utilityTools.readChangelog(params);
+    }
     // Transaction Tools
     async beginTransaction(params) {
         const check = this.checkToolEnabled("beginTransaction");
@@ -1061,6 +1074,60 @@ class MySQLMCP {
             return { status: "error", error: check.error };
         return await this.performanceTools.resetPerformanceStats();
     }
+    // ==========================================
+    // PHASE 1: AI Enhancement Tools
+    // ==========================================
+    // Intelligent Query Assistant
+    async buildQueryFromIntent(params) {
+        const check = this.checkToolEnabled("buildQueryFromIntent");
+        if (!check.enabled)
+            return { status: "error", error: check.error };
+        return await this.intelligentQueryTools.buildQueryFromIntent(params);
+    }
+    async suggestQueryImprovements(params) {
+        const check = this.checkToolEnabled("suggestQueryImprovements");
+        if (!check.enabled)
+            return { status: "error", error: check.error };
+        return await this.intelligentQueryTools.suggestQueryImprovements(params);
+    }
+    // Smart Data Discovery
+    async smartSearch(params) {
+        const check = this.checkToolEnabled("smartSearch");
+        if (!check.enabled)
+            return { status: "error", error: check.error };
+        return await this.smartDiscoveryTools.smartSearch(params);
+    }
+    async findSimilarColumns(params) {
+        const check = this.checkToolEnabled("findSimilarColumns");
+        if (!check.enabled)
+            return { status: "error", error: check.error };
+        return await this.smartDiscoveryTools.findSimilarColumns(params);
+    }
+    async discoverDataPatterns(params) {
+        const check = this.checkToolEnabled("discoverDataPatterns");
+        if (!check.enabled)
+            return { status: "error", error: check.error };
+        return await this.smartDiscoveryTools.discoverDataPatterns(params);
+    }
+    // Documentation Generator
+    async generateDocumentation(params) {
+        const check = this.checkToolEnabled("generateDocumentation");
+        if (!check.enabled)
+            return { status: "error", error: check.error };
+        return await this.documentationGeneratorTools.generateDocumentation(params);
+    }
+    async generateDataDictionary(params) {
+        const check = this.checkToolEnabled("generateDataDictionary");
+        if (!check.enabled)
+            return { status: "error", error: check.error };
+        return await this.documentationGeneratorTools.generateDataDictionary(params);
+    }
+    async generateBusinessGlossary(params) {
+        const check = this.checkToolEnabled("generateBusinessGlossary");
+        if (!check.enabled)
+            return { status: "error", error: check.error };
+        return await this.documentationGeneratorTools.generateBusinessGlossaryReport(params);
+    }
 }
 exports.MySQLMCP = MySQLMCP;
 exports.default = MySQLMCP;