@berthojoris/mcp-mysql-server 1.10.5 → 1.12.0

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,10 @@ export declare class MySQLMCP {
     private migrationTools;
     private schemaVersioningTools;
     private performanceTools;
+    private analysisTools;
     private security;
     private featureConfig;
-    constructor(permissionsConfig?: string, categoriesConfig?: string);
+    constructor(permissionsConfig?: string, categoriesConfig?: string, presetName?: string);
     private checkToolEnabled;
     listDatabases(): Promise<{
         status: string;
@@ -45,6 +46,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 +109,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 +130,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;
@@ -541,8 +582,22 @@ export declare class MySQLMCP {
     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 +606,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,7 @@ 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 securityLayer_1 = __importDefault(require("./security/securityLayer"));
 const connection_1 = __importDefault(require("./db/connection"));
 const featureConfig_1 = require("./config/featureConfig");
@@ -31,8 +32,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 +54,7 @@ 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);
     }
     // Helper method to check if tool is enabled
     checkToolEnabled(toolName) {
@@ -86,6 +88,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 +163,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");
@@ -496,11 +527,16 @@ class MySQLMCP {
     }
     // 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 +548,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
      */

package/dist/mcp-server.js

@@ -10,6 +10,7 @@ const index_js_2 = require("./index.js");
 // Layer 2 (Categories): MCP_CATEGORIES (optional, for fine-grained control)
 const permissions = process.env.MCP_PERMISSIONS || process.env.MCP_CONFIG || "";
 const categories = process.env.MCP_CATEGORIES || "";
+const preset = process.env.MCP_PRESET || process.env.MCP_PERMISSION_PRESET || "";
 // Declare the MySQL MCP instance (will be initialized in main())
 let mysqlMCP;
 // Define all available tools with their schemas
@@ -35,6 +36,79 @@ const TOOLS = [
             },
         },
     },
+    {
+        name: "get_database_summary",
+        description: "Get a high-level summary of the database (tables, columns, row counts) optimized for AI context.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                database: {
+                    type: "string",
+                    description: "Optional: specific database name",
+                },
+            },
+        },
+    },
+    {
+        name: "get_schema_erd",
+        description: "Get a Mermaid.js ER diagram string representing the database schema and relationships.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                database: {
+                    type: "string",
+                    description: "Optional: specific database name",
+                },
+            },
+        },
+    },
+    {
+        name: "get_schema_rag_context",
+        description: "Return a compact schema-aware context pack (tables, PK/FK, columns, row estimates) optimized for RAG prompts.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                database: {
+                    type: "string",
+                    description: "Optional: specific database name",
+                },
+                max_tables: {
+                    type: "number",
+                    description: "Optional: maximum number of tables to include (default 50, max 200)",
+                },
+                max_columns: {
+                    type: "number",
+                    description: "Optional: maximum number of columns per table (default 12, max 200)",
+                },
+                include_relationships: {
+                    type: "boolean",
+                    description: "Whether to include FK relationships section (default: true)",
+                },
+            },
+        },
+    },
+    {
+        name: "get_column_statistics",
+        description: "Get detailed statistics for a specific column (min, max, avg, distinct counts, nulls).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                table_name: {
+                    type: "string",
+                    description: "Name of the table",
+                },
+                column_name: {
+                    type: "string",
+                    description: "Name of the column",
+                },
+                database: {
+                    type: "string",
+                    description: "Optional: specific database name",
+                },
+            },
+            required: ["table_name", "column_name"],
+        },
+    },
     {
         name: "read_table_schema",
         description: "Reads the schema of a specified table, including columns, types, keys, and indexes.",
@@ -375,6 +449,10 @@ const TOOLS = [
                     type: "boolean",
                     description: "Whether to use query result caching (default: true)",
                 },
+                dry_run: {
+                    type: "boolean",
+                    description: "If true, returns query plan and estimated cost without executing (Safe Mode)",
+                },
             },
             required: ["query"],
         },
@@ -2687,7 +2765,7 @@ const TOOLS = [
 // Create the MCP server
 const server = new index_js_1.Server({
     name: "mysql-mcp-server",
-    version: "1.4.4",
+    version: "1.12.0",
 }, {
     capabilities: {
         tools: {},
@@ -2721,6 +2799,18 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
             case "list_tables":
                 result = await mysqlMCP.listTables((args || {}));
                 break;
+            case "get_database_summary":
+                result = await mysqlMCP.getDatabaseSummary((args || {}));
+                break;
+            case "get_schema_erd":
+                result = await mysqlMCP.getSchemaERD((args || {}));
+                break;
+            case "get_schema_rag_context":
+                result = await mysqlMCP.getSchemaRagContext((args || {}));
+                break;
+            case "get_column_statistics":
+                result = await mysqlMCP.getColumnStatistics((args || {}));
+                break;
             case "read_table_schema":
                 result = await mysqlMCP.readTableSchema((args || {}));
                 break;
@@ -3173,20 +3263,20 @@ async function main() {
     await server.connect(transport);
     // Initialize the MySQL MCP instance AFTER transport is connected
     // This ensures the database connection pool is created when the server is ready
-    mysqlMCP = new index_js_2.MySQLMCP(permissions, categories);
+    mysqlMCP = new index_js_2.MySQLMCP(permissions, categories, preset);
     // Log the effective filtering configuration to stderr
-    if (permissions && categories) {
-        console.error(`Active permissions (Layer 1): ${permissions}`);
-        console.error(`Active categories (Layer 2): ${categories}`);
-        console.error("Filtering mode: Dual-layer");
+    const accessProfile = mysqlMCP.getAccessProfile();
+    if (accessProfile.preset) {
+        console.error(`Preset: ${accessProfile.preset.name} (${accessProfile.preset.description})`);
     }
-    else if (permissions) {
-        console.error(`Active permissions: ${permissions}`);
-        console.error("Filtering mode: Single-layer");
+    else if (preset) {
+        console.error(`Preset requested but not recognized: ${preset}`);
     }
-    else {
-        console.error("Active permissions: all (default)");
+    console.error(`Permissions (resolved): ${accessProfile.permissions}`);
+    if (accessProfile.categories) {
+        console.error(`Categories (resolved): ${accessProfile.categories}`);
     }
+    console.error(`Filtering mode: ${accessProfile.filteringMode}`);
     // Log to stderr (not stdout, which is used for MCP protocol)
     console.error("MySQL MCP Server running on stdio");
 }

package/dist/tools/analysisTools.d.ts

@@ -0,0 +1,35 @@
+import { SecurityLayer } from "../security/securityLayer";
+export declare class AnalysisTools {
+    private db;
+    private security;
+    constructor(security: SecurityLayer);
+    /**
+     * Validate database access - ensures only the connected database can be accessed
+     */
+    private validateDatabaseAccess;
+    /**
+     * Get statistics for a specific column
+     */
+    getColumnStatistics(params: {
+        table_name: string;
+        column_name: string;
+        database?: string;
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+    }>;
+    /**
+     * Build a compact, schema-aware context pack for RAG (tables, PK/FK, columns, row estimates)
+     */
+    getSchemaRagContext(params?: {
+        database?: string;
+        max_tables?: number;
+        max_columns?: number;
+        include_relationships?: boolean;
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+    }>;
+}