@berthojoris/mcp-mysql-server 1.10.5 → 1.13.0

package/dist/config/featureConfig.d.ts

@@ -39,7 +39,17 @@ export declare enum DocCategory {
     BACKUP_RESTORE = "backup_restore",
     IMPORT_EXPORT = "import_export",
     DATA_MIGRATION = "data_migration",
-    SCHEMA_MIGRATIONS = "schema_migrations"
+    SCHEMA_MIGRATIONS = "schema_migrations",
+    ANALYSIS = "analysis"
+}
+/**
+ * Permission preset bundles for faster, safer configuration
+ */
+export interface PermissionPreset {
+    name: string;
+    description: string;
+    permissions: ToolCategory[];
+    categories: DocCategory[];
 }
 /**
  * Map of tool names to their legacy categories
@@ -61,7 +71,17 @@ export declare class FeatureConfig {
     private originalPermissionsString;
     private originalCategoriesString;
     private useDualLayer;
-    constructor(permissionsStr?: string, categoriesStr?: string);
+    private activePreset?;
+    private presetName?;
+    constructor(permissionsStr?: string, categoriesStr?: string, presetName?: string);
+    /**
+     * Normalize and merge preset + user-supplied configuration lists
+     */
+    private mergeConfigStrings;
+    /**
+     * Resolve a preset name to its configuration
+     */
+    private resolvePreset;
     /**
      * Parse permissions and categories for dual-layer filtering
      * Layer 1 (permissions): Broad control using legacy categories
@@ -71,7 +91,7 @@ export declare class FeatureConfig {
     /**
      * Update configuration at runtime
      */
-    setConfig(permissionsStr: string, categoriesStr?: string): void;
+    setConfig(permissionsStr: string, categoriesStr?: string, presetName?: string): void;
     /**
      * Check if a specific tool is enabled
      * Dual-layer logic:
@@ -111,6 +131,24 @@ export declare class FeatureConfig {
      * Check if using dual-layer filtering mode
      */
     isUsingDualLayer(): boolean;
+    /**
+     * Get the active preset (if any)
+     */
+    getActivePreset(): PermissionPreset | undefined;
+    /**
+     * Snapshot of the resolved configuration for logging/telemetry
+     */
+    getConfigSnapshot(): {
+        preset?: {
+            name: string;
+            description: string;
+        };
+        permissions: string;
+        categories: string;
+        filteringMode: string;
+        enabledLegacy: ToolCategory[];
+        enabledDoc: DocCategory[];
+    };
     /**
      * Get filtering mode description
      */

package/dist/config/featureConfig.js

@@ -51,7 +51,71 @@ var DocCategory;
     DocCategory["IMPORT_EXPORT"] = "import_export";
     DocCategory["DATA_MIGRATION"] = "data_migration";
     DocCategory["SCHEMA_MIGRATIONS"] = "schema_migrations";
+    DocCategory["ANALYSIS"] = "analysis";
 })(DocCategory || (exports.DocCategory = DocCategory = {}));
+const normalizePresetName = (value) => (value || "").toLowerCase().replace(/[\s_-]/g, "");
+const permissionPresets = {
+    readonly: {
+        name: "readonly",
+        description: "Safe read-only profile with discovery, querying, exports, and diagnostics",
+        permissions: [ToolCategory.LIST, ToolCategory.READ, ToolCategory.UTILITY],
+        categories: [
+            DocCategory.DATABASE_DISCOVERY,
+            DocCategory.CRUD_OPERATIONS,
+            DocCategory.CUSTOM_QUERIES,
+            DocCategory.UTILITIES,
+            DocCategory.IMPORT_EXPORT,
+            DocCategory.PERFORMANCE_MONITORING,
+            DocCategory.ANALYSIS,
+        ],
+    },
+    analyst: {
+        name: "analyst",
+        description: "Exploratory analytics profile with query insights and safe exports",
+        permissions: [ToolCategory.LIST, ToolCategory.READ, ToolCategory.UTILITY],
+        categories: [
+            DocCategory.DATABASE_DISCOVERY,
+            DocCategory.CRUD_OPERATIONS,
+            DocCategory.CUSTOM_QUERIES,
+            DocCategory.UTILITIES,
+            DocCategory.IMPORT_EXPORT,
+            DocCategory.PERFORMANCE_MONITORING,
+            DocCategory.ANALYSIS,
+            DocCategory.QUERY_OPTIMIZATION,
+            DocCategory.CACHE_MANAGEMENT,
+            DocCategory.SERVER_MANAGEMENT,
+        ],
+    },
+    dbalite: {
+        name: "dba-lite",
+        description: "Admin-lite profile for schema care, migrations, and maintenance",
+        permissions: [
+            ToolCategory.LIST,
+            ToolCategory.READ,
+            ToolCategory.UTILITY,
+            ToolCategory.DDL,
+            ToolCategory.TRANSACTION,
+            ToolCategory.PROCEDURE,
+        ],
+        categories: [
+            DocCategory.DATABASE_DISCOVERY,
+            DocCategory.CUSTOM_QUERIES,
+            DocCategory.UTILITIES,
+            DocCategory.SERVER_MANAGEMENT,
+            DocCategory.SCHEMA_MANAGEMENT,
+            DocCategory.TABLE_MAINTENANCE,
+            DocCategory.INDEX_MANAGEMENT,
+            DocCategory.CONSTRAINT_MANAGEMENT,
+            DocCategory.BACKUP_RESTORE,
+            DocCategory.SCHEMA_MIGRATIONS,
+            DocCategory.PERFORMANCE_MONITORING,
+            DocCategory.VIEWS_MANAGEMENT,
+            DocCategory.TRIGGERS_MANAGEMENT,
+            DocCategory.FUNCTIONS_MANAGEMENT,
+            DocCategory.STORED_PROCEDURES,
+        ],
+    },
+};
 /**
  * Map of tool names to their legacy categories
  */
@@ -60,11 +124,17 @@ exports.toolCategoryMap = {
     listDatabases: ToolCategory.LIST,
     listTables: ToolCategory.LIST,
     readTableSchema: ToolCategory.LIST,
+    // Analysis tools (added here to group with database tools)
+    getDatabaseSummary: ToolCategory.LIST,
+    getSchemaERD: ToolCategory.LIST,
+    getSchemaRagContext: ToolCategory.LIST,
     // CRUD tools
     createRecord: ToolCategory.CREATE,
     readRecords: ToolCategory.READ,
     updateRecord: ToolCategory.UPDATE,
     deleteRecord: ToolCategory.DELETE,
+    // Analysis tools (added here to group with read tools)
+    getColumnStatistics: ToolCategory.READ,
     // Bulk operations
     bulkInsert: ToolCategory.CREATE,
     bulkUpdate: ToolCategory.UPDATE,
@@ -186,6 +256,8 @@ exports.toolCategoryMap = {
     validateMigrations: ToolCategory.LIST,
     resetFailedMigration: ToolCategory.DDL,
     generateMigrationFromDiff: ToolCategory.DDL,
+    // Analysis tools - MOVED here to avoid duplication
+    // Note: keys must be unique in the object literal
     // Performance monitoring tools
     getPerformanceMetrics: ToolCategory.UTILITY,
     getTopQueriesByTime: ToolCategory.UTILITY,
@@ -343,6 +415,11 @@ exports.toolDocCategoryMap = {
     validateMigrations: DocCategory.SCHEMA_MIGRATIONS,
     resetFailedMigration: DocCategory.SCHEMA_MIGRATIONS,
     generateMigrationFromDiff: DocCategory.SCHEMA_MIGRATIONS,
+    // Analysis
+    getDatabaseSummary: DocCategory.ANALYSIS,
+    getSchemaERD: DocCategory.ANALYSIS,
+    getColumnStatistics: DocCategory.ANALYSIS,
+    getSchemaRagContext: DocCategory.ANALYSIS,
 };
 /**
  * Mapping between legacy categories and documentation categories
@@ -360,8 +437,9 @@ const legacyToDocCategoryMap = {
         DocCategory.TABLE_MAINTENANCE,
         DocCategory.SERVER_MANAGEMENT,
         DocCategory.SCHEMA_MIGRATIONS,
+        DocCategory.ANALYSIS,
     ],
-    read: [DocCategory.CRUD_OPERATIONS, DocCategory.CUSTOM_QUERIES],
+    read: [DocCategory.CRUD_OPERATIONS, DocCategory.CUSTOM_QUERIES, DocCategory.ANALYSIS],
     create: [
         DocCategory.CRUD_OPERATIONS,
         DocCategory.BULK_OPERATIONS,
@@ -409,20 +487,66 @@ const legacyToDocCategoryMap = {
  * - Layer 2 (Categories): Documentation categories (fine-grained control, optional)
  */
 class FeatureConfig {
-    constructor(permissionsStr, categoriesStr) {
+    constructor(permissionsStr, categoriesStr, presetName) {
+        const presetInput = presetName ||
+            process.env.MCP_PERMISSION_PRESET ||
+            process.env.MCP_PRESET ||
+            "";
+        this.activePreset = this.resolvePreset(presetInput);
+        this.presetName = this.activePreset?.name;
+        const presetRequested = !!presetInput.trim();
         // Support both old single-parameter and new dual-parameter signatures
-        const permissions = permissionsStr ||
+        const permissionsInput = permissionsStr ||
             process.env.MCP_PERMISSIONS ||
             process.env.MCP_CONFIG ||
             "";
-        const categories = categoriesStr || process.env.MCP_CATEGORIES || "";
-        this.originalPermissionsString = permissions;
-        this.originalCategoriesString = categories;
-        this.useDualLayer = !!categories.trim();
-        const parsed = this.parseConfig(permissions, categories);
+        const categoriesInput = categoriesStr || process.env.MCP_CATEGORIES || "";
+        // Use preset values when available, otherwise fall back to user input
+        // If an unknown preset is requested without explicit permissions/categories,
+        // default to a safe read-only baseline rather than enabling everything.
+        const basePermissions = this.activePreset
+            ? this.activePreset.permissions.join(",")
+            : presetRequested && !permissionsInput
+                ? [ToolCategory.LIST, ToolCategory.READ, ToolCategory.UTILITY].join(",")
+                : "";
+        const baseCategories = this.activePreset
+            ? this.activePreset.categories.join(",")
+            : presetRequested && !categoriesInput
+                ? [
+                    DocCategory.DATABASE_DISCOVERY,
+                    DocCategory.CRUD_OPERATIONS,
+                    DocCategory.CUSTOM_QUERIES,
+                    DocCategory.UTILITIES,
+                ].join(",")
+                : "";
+        if (presetRequested && !this.activePreset) {
+            console.warn(`Preset '${presetInput}' not recognized. Falling back to safe read-only defaults.`);
+        }
+        const mergedPermissions = this.mergeConfigStrings(basePermissions, permissionsInput);
+        const mergedCategories = this.mergeConfigStrings(baseCategories, categoriesInput);
+        this.originalPermissionsString = mergedPermissions;
+        this.originalCategoriesString = mergedCategories;
+        this.useDualLayer = !!mergedCategories.trim();
+        const parsed = this.parseConfig(mergedPermissions, mergedCategories);
         this.enabledLegacyCategories = parsed.legacy;
         this.enabledDocCategories = parsed.doc;
     }
+    /**
+     * Normalize and merge preset + user-supplied configuration lists
+     */
+    mergeConfigStrings(base, override) {
+        const items = [...(base || "").split(","), ...(override || "").split(",")]
+            .map((c) => c.trim().toLowerCase())
+            .filter(Boolean);
+        return Array.from(new Set(items)).join(",");
+    }
+    /**
+     * Resolve a preset name to its configuration
+     */
+    resolvePreset(name) {
+        const normalized = normalizePresetName(name);
+        return normalized ? permissionPresets[normalized] : undefined;
+    }
     /**
      * Parse permissions and categories for dual-layer filtering
      * Layer 1 (permissions): Broad control using legacy categories
@@ -472,11 +596,37 @@ class FeatureConfig {
     /**
      * Update configuration at runtime
      */
-    setConfig(permissionsStr, categoriesStr) {
-        this.originalPermissionsString = permissionsStr;
-        this.originalCategoriesString = categoriesStr || "";
-        this.useDualLayer = !!(categoriesStr && categoriesStr.trim());
-        const parsed = this.parseConfig(permissionsStr, categoriesStr || "");
+    setConfig(permissionsStr, categoriesStr, presetName) {
+        const presetRequested = presetName !== undefined ? !!presetName.trim() : !!this.presetName;
+        this.activePreset =
+            presetName === ""
+                ? undefined
+                : this.resolvePreset(presetName || this.presetName);
+        this.presetName = this.activePreset?.name;
+        const basePermissions = this.activePreset
+            ? this.activePreset.permissions.join(",")
+            : presetRequested && !permissionsStr
+                ? [ToolCategory.LIST, ToolCategory.READ, ToolCategory.UTILITY].join(",")
+                : "";
+        const baseCategories = this.activePreset
+            ? this.activePreset.categories.join(",")
+            : presetRequested && !categoriesStr
+                ? [
+                    DocCategory.DATABASE_DISCOVERY,
+                    DocCategory.CRUD_OPERATIONS,
+                    DocCategory.CUSTOM_QUERIES,
+                    DocCategory.UTILITIES,
+                ].join(",")
+                : "";
+        if (presetRequested && !this.activePreset) {
+            console.warn(`Preset '${presetName}' not recognized. Falling back to safe read-only defaults.`);
+        }
+        const mergedPermissions = this.mergeConfigStrings(basePermissions, permissionsStr);
+        const mergedCategories = this.mergeConfigStrings(baseCategories, categoriesStr || "");
+        this.originalPermissionsString = mergedPermissions;
+        this.originalCategoriesString = mergedCategories;
+        this.useDualLayer = !!(mergedCategories && mergedCategories.trim());
+        const parsed = this.parseConfig(mergedPermissions, mergedCategories || "");
         this.enabledLegacyCategories = parsed.legacy;
         this.enabledDocCategories = parsed.doc;
     }
@@ -602,6 +752,31 @@ class FeatureConfig {
     isUsingDualLayer() {
         return this.useDualLayer;
     }
+    /**
+     * Get the active preset (if any)
+     */
+    getActivePreset() {
+        return this.activePreset;
+    }
+    /**
+     * Snapshot of the resolved configuration for logging/telemetry
+     */
+    getConfigSnapshot() {
+        return {
+            preset: this.activePreset
+                ? {
+                    name: this.activePreset.name,
+                    description: this.activePreset.description,
+                }
+                : undefined,
+            permissions: this.originalPermissionsString || "all",
+            categories: this.originalCategoriesString ||
+                (this.useDualLayer ? "" : "derived from permissions"),
+            filteringMode: this.getFilteringMode(),
+            enabledLegacy: this.getEnabledCategories(),
+            enabledDoc: this.getEnabledDocCategories(),
+        };
+    }
     /**
      * Get filtering mode description
      */

package/dist/index.d.ts

@@ -22,9 +22,11 @@ export declare class MySQLMCP {
     private migrationTools;
     private schemaVersioningTools;
     private performanceTools;
+    private analysisTools;
+    private aiTools;
     private security;
     private featureConfig;
-    constructor(permissionsConfig?: string, categoriesConfig?: string);
+    constructor(permissionsConfig?: string, categoriesConfig?: string, presetName?: string);
     private checkToolEnabled;
     listDatabases(): Promise<{
         status: string;
@@ -45,6 +47,20 @@ export declare class MySQLMCP {
         data?: import("./validation/schemas").ColumnInfo[];
         error?: string;
     }>;
+    getDatabaseSummary(params: {
+        database?: string;
+    }): Promise<{
+        status: string;
+        data?: string;
+        error?: string;
+    }>;
+    getSchemaERD(params: {
+        database?: string;
+    }): Promise<{
+        status: string;
+        data?: string;
+        error?: string;
+    }>;
     createRecord(params: {
         table_name: string;
         data: Record<string, any>;
@@ -94,11 +110,18 @@ export declare class MySQLMCP {
     runQuery(params: {
         query: string;
         params?: any[];
+        hints?: any;
+        useCache?: boolean;
+        dry_run?: boolean;
     }): Promise<{
         status: string;
         data?: any[];
         error?: string;
         optimizedQuery?: string;
+        dry_run?: boolean;
+        execution_plan?: any;
+        estimated_cost?: string;
+        message?: string;
     }>;
     executeSql(params: {
         query: string;
@@ -108,6 +131,25 @@ export declare class MySQLMCP {
         data?: any;
         error?: string;
     }>;
+    getColumnStatistics(params: {
+        table_name: string;
+        column_name: string;
+        database?: string;
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+    }>;
+    getSchemaRagContext(params: {
+        database?: string;
+        max_tables?: number;
+        max_columns?: number;
+        include_relationships?: boolean;
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+    }>;
     createTable(params: any): Promise<{
         status: string;
         data?: any;
@@ -538,11 +580,35 @@ export declare class MySQLMCP {
         data?: any;
         error?: string;
     }>;
+    repairQuery(params: {
+        query: string;
+        error_message?: string;
+    }): Promise<{
+        status: string;
+        analysis?: any;
+        fixed_query?: string;
+        suggestions?: string[];
+        error?: string;
+    }>;
     getFeatureStatus(): {
         status: string;
         data: {
+            config: {
+                preset?: {
+                    name: string;
+                    description: string;
+                };
+                permissions: string;
+                categories: string;
+                filteringMode: string;
+                enabledLegacy: import("./config/featureConfig").ToolCategory[];
+                enabledDoc: import("./config/featureConfig").DocCategory[];
+            };
+            preset: import("./config/featureConfig").PermissionPreset | undefined;
+            filteringMode: string;
             enabledCategories: import("./config/featureConfig").ToolCategory[];
             categoryStatus: Record<import("./config/featureConfig").ToolCategory, boolean>;
+            docCategoryStatus: Record<import("./config/featureConfig").DocCategory, boolean>;
         };
     };
     /**
@@ -551,6 +617,20 @@ export declare class MySQLMCP {
      * @returns boolean indicating if the tool is enabled
      */
     isToolEnabled(toolName: string): boolean;
+    /**
+     * Expose resolved access profile (preset + merged permissions/categories)
+     */
+    getAccessProfile(): {
+        preset?: {
+            name: string;
+            description: string;
+        };
+        permissions: string;
+        categories: string;
+        filteringMode: string;
+        enabledLegacy: import("./config/featureConfig").ToolCategory[];
+        enabledDoc: import("./config/featureConfig").DocCategory[];
+    };
     /**
      * Bulk insert multiple records into the specified table
      */

package/dist/index.js

@@ -23,6 +23,8 @@ const backupRestoreTools_1 = require("./tools/backupRestoreTools");
 const migrationTools_1 = require("./tools/migrationTools");
 const schemaVersioningTools_1 = require("./tools/schemaVersioningTools");
 const performanceTools_1 = require("./tools/performanceTools");
+const analysisTools_1 = require("./tools/analysisTools");
+const aiTools_1 = require("./tools/aiTools");
 const securityLayer_1 = __importDefault(require("./security/securityLayer"));
 const connection_1 = __importDefault(require("./db/connection"));
 const featureConfig_1 = require("./config/featureConfig");
@@ -31,8 +33,8 @@ const featureConfig_1 = require("./config/featureConfig");
  * A secure interface for AI models to interact with MySQL databases
  */
 class MySQLMCP {
-    constructor(permissionsConfig, categoriesConfig) {
-        this.featureConfig = new featureConfig_1.FeatureConfig(permissionsConfig, categoriesConfig);
+    constructor(permissionsConfig, categoriesConfig, presetName) {
+        this.featureConfig = new featureConfig_1.FeatureConfig(permissionsConfig, categoriesConfig, presetName);
         this.security = new securityLayer_1.default(this.featureConfig);
         this.dbTools = new databaseTools_1.DatabaseTools();
         this.crudTools = new crudTools_1.CrudTools(this.security);
@@ -53,6 +55,8 @@ class MySQLMCP {
         this.migrationTools = new migrationTools_1.MigrationTools(this.security);
         this.schemaVersioningTools = new schemaVersioningTools_1.SchemaVersioningTools(this.security);
         this.performanceTools = new performanceTools_1.PerformanceTools(this.security);
+        this.analysisTools = new analysisTools_1.AnalysisTools(this.security);
+        this.aiTools = new aiTools_1.AiTools(this.security);
     }
     // Helper method to check if tool is enabled
     checkToolEnabled(toolName) {
@@ -86,6 +90,20 @@ class MySQLMCP {
         }
         return await this.dbTools.readTableSchema(params);
     }
+    async getDatabaseSummary(params) {
+        const check = this.checkToolEnabled("getDatabaseSummary");
+        if (!check.enabled) {
+            return { status: "error", error: check.error };
+        }
+        return await this.dbTools.getDatabaseSummary(params);
+    }
+    async getSchemaERD(params) {
+        const check = this.checkToolEnabled("getSchemaERD");
+        if (!check.enabled) {
+            return { status: "error", error: check.error };
+        }
+        return await this.dbTools.getSchemaERD(params);
+    }
     // CRUD Tools
     async createRecord(params) {
         const check = this.checkToolEnabled("createRecord");
@@ -147,6 +165,21 @@ class MySQLMCP {
         }
         return await this.queryTools.executeSql(params);
     }
+    // Analysis Tools
+    async getColumnStatistics(params) {
+        const check = this.checkToolEnabled("getColumnStatistics");
+        if (!check.enabled) {
+            return { status: "error", error: check.error };
+        }
+        return await this.analysisTools.getColumnStatistics(params);
+    }
+    async getSchemaRagContext(params) {
+        const check = this.checkToolEnabled("getSchemaRagContext");
+        if (!check.enabled) {
+            return { status: "error", error: check.error };
+        }
+        return await this.analysisTools.getSchemaRagContext(params);
+    }
     // DDL Tools
     async createTable(params) {
         const check = this.checkToolEnabled("createTable");
@@ -494,13 +527,26 @@ class MySQLMCP {
         }
         return await this.schemaVersioningTools.generateMigrationFromDiff(params);
     }
+    // AI Productivity Tools
+    async repairQuery(params) {
+        const check = this.checkToolEnabled("repairQuery");
+        if (!check.enabled) {
+            return { status: "error", error: check.error };
+        }
+        return await this.aiTools.repairQuery(params);
+    }
     // Get feature configuration status
     getFeatureStatus() {
+        const snapshot = this.featureConfig.getConfigSnapshot();
         return {
             status: "success",
             data: {
+                config: snapshot,
+                preset: this.featureConfig.getActivePreset(),
+                filteringMode: this.featureConfig.getFilteringMode(),
                 enabledCategories: this.featureConfig.getEnabledCategories(),
                 categoryStatus: this.featureConfig.getCategoryStatus(),
+                docCategoryStatus: this.featureConfig.getDocCategoryStatus(),
             },
         };
     }
@@ -512,6 +558,12 @@ class MySQLMCP {
     isToolEnabled(toolName) {
         return this.featureConfig.isToolEnabled(toolName);
     }
+    /**
+     * Expose resolved access profile (preset + merged permissions/categories)
+     */
+    getAccessProfile() {
+        return this.featureConfig.getConfigSnapshot();
+    }
     /**
      * Bulk insert multiple records into the specified table
      */