@neverinfamous/mysql-mcp 2.1.0

package/src/adapters/mysql/resources/indexes.ts

@@ -0,0 +1,98 @@
+/**
+ * MySQL Resource - Indexes
+ * 
+ * Index usage statistics and recommendations.
+ */
+import type { MySQLAdapter } from '../MySQLAdapter.js';
+import type { ResourceDefinition, RequestContext } from '../../../types/index.js';
+
+export function createIndexesResource(adapter: MySQLAdapter): ResourceDefinition {
+    return {
+        uri: 'mysql://indexes',
+        name: 'Index Statistics',
+        title: 'MySQL Index Statistics',
+        description: 'Index usage statistics, unused indexes, and duplicate detection',
+        mimeType: 'application/json',
+        annotations: {
+            audience: ['user', 'assistant'],
+            priority: 0.7
+        },
+        handler: async (_uri: string, _context: RequestContext) => {
+            // Get current database
+            const dbResult = await adapter.executeQuery('SELECT DATABASE() as db');
+            const database = (dbResult.rows?.[0]?.['db'] as string) ?? '';
+
+            if (!database) {
+                return { error: 'No database selected' };
+            }
+
+            // Get index statistics
+            const indexResult = await adapter.executeQuery(`
+                SELECT 
+                    TABLE_NAME as table_name,
+                    INDEX_NAME as index_name,
+                    NON_UNIQUE as non_unique,
+                    SEQ_IN_INDEX as seq_in_index,
+                    COLUMN_NAME as column_name,
+                    CARDINALITY as cardinality,
+                    INDEX_TYPE as index_type
+                FROM information_schema.STATISTICS
+                WHERE TABLE_SCHEMA = ?
+                ORDER BY TABLE_NAME, INDEX_NAME, SEQ_IN_INDEX
+            `, [database]);
+
+            // Try to get index usage from performance_schema if available
+            let unusedIndexes: unknown[] = [];
+            try {
+                const unusedResult = await adapter.executeQuery(`
+                    SELECT 
+                        object_schema as schema_name,
+                        object_name as table_name,
+                        index_name
+                    FROM performance_schema.table_io_waits_summary_by_index_usage
+                    WHERE object_schema = ?
+                      AND index_name IS NOT NULL
+                      AND index_name != 'PRIMARY'
+                      AND count_star = 0
+                `, [database]);
+                unusedIndexes = unusedResult.rows ?? [];
+            } catch {
+                // Performance schema may not be available
+            }
+
+            // Get duplicate/redundant indexes
+            let duplicateIndexes: unknown[] = [];
+            try {
+                const dupResult = await adapter.executeQuery(`
+                    SELECT 
+                        a.TABLE_NAME as table_name,
+                        a.INDEX_NAME as redundant_index,
+                        a.COLUMN_NAME as column_name,
+                        b.INDEX_NAME as dominant_index
+                    FROM information_schema.STATISTICS a
+                    JOIN information_schema.STATISTICS b 
+                        ON a.TABLE_SCHEMA = b.TABLE_SCHEMA 
+                        AND a.TABLE_NAME = b.TABLE_NAME
+                        AND a.COLUMN_NAME = b.COLUMN_NAME
+                        AND a.SEQ_IN_INDEX = b.SEQ_IN_INDEX
+                        AND a.INDEX_NAME != b.INDEX_NAME
+                    WHERE a.TABLE_SCHEMA = ?
+                      AND a.SEQ_IN_INDEX = 1
+                      AND (a.INDEX_NAME != 'PRIMARY' AND b.INDEX_NAME != 'PRIMARY')
+                    GROUP BY a.TABLE_NAME, a.INDEX_NAME, a.COLUMN_NAME, b.INDEX_NAME
+                `, [database]);
+                duplicateIndexes = dupResult.rows ?? [];
+            } catch {
+                // May fail on older MySQL versions
+            }
+
+            return {
+                database,
+                total_indexes: (indexResult.rows ?? []).length,
+                indexes: indexResult.rows ?? [],
+                unused_indexes: unusedIndexes,
+                potential_duplicates: duplicateIndexes
+            };
+        }
+    };
+}

package/src/adapters/mysql/resources/innodb.ts

@@ -0,0 +1,110 @@
+/**
+ * MySQL Resource - InnoDB
+ * 
+ * InnoDB buffer pool and engine status metrics.
+ */
+import type { MySQLAdapter } from '../MySQLAdapter.js';
+import type { ResourceDefinition, RequestContext } from '../../../types/index.js';
+
+export function createInnodbResource(adapter: MySQLAdapter): ResourceDefinition {
+    return {
+        uri: 'mysql://innodb',
+        name: 'InnoDB Status',
+        title: 'MySQL InnoDB Status',
+        description: 'InnoDB buffer pool statistics and engine status',
+        mimeType: 'application/json',
+        annotations: {
+            audience: ['user', 'assistant'],
+            priority: 0.7
+        },
+        handler: async (_uri: string, _context: RequestContext) => {
+            // Get buffer pool status
+            const bufferPoolResult = await adapter.executeQuery(`
+                SHOW GLOBAL STATUS WHERE Variable_name LIKE 'Innodb_buffer_pool%'
+            `);
+
+            const bufferPool: Record<string, number> = {};
+            for (const row of bufferPoolResult.rows ?? []) {
+                bufferPool[row['Variable_name'] as string] = parseInt(row['Value'] as string, 10);
+            }
+
+            // Get buffer pool size configuration
+            const configResult = await adapter.executeQuery(`
+                SHOW GLOBAL VARIABLES WHERE Variable_name IN (
+                    'innodb_buffer_pool_size', 'innodb_buffer_pool_instances',
+                    'innodb_log_file_size', 'innodb_log_files_in_group',
+                    'innodb_flush_log_at_trx_commit', 'innodb_file_per_table'
+                )
+            `);
+
+            const config: Record<string, string> = {};
+            for (const row of configResult.rows ?? []) {
+                config[row['Variable_name'] as string] = row['Value'] as string;
+            }
+
+            // Get row operations
+            const opsResult = await adapter.executeQuery(`
+                SHOW GLOBAL STATUS WHERE Variable_name IN (
+                    'Innodb_rows_read', 'Innodb_rows_inserted', 
+                    'Innodb_rows_updated', 'Innodb_rows_deleted',
+                    'Innodb_data_reads', 'Innodb_data_writes',
+                    'Innodb_os_log_written', 'Innodb_log_writes'
+                )
+            `);
+
+            const operations: Record<string, number> = {};
+            for (const row of opsResult.rows ?? []) {
+                operations[row['Variable_name'] as string] = parseInt(row['Value'] as string, 10);
+            }
+
+            // Calculate buffer pool efficiency
+            const readRequests = bufferPool['Innodb_buffer_pool_read_requests'] ?? 0;
+            const reads = bufferPool['Innodb_buffer_pool_reads'] ?? 0;
+            const hitRatio = readRequests > 0
+                ? Math.round(((readRequests - reads) / readRequests) * 100 * 100) / 100
+                : 100;
+
+            const pagesTotal = bufferPool['Innodb_buffer_pool_pages_total'] ?? 0;
+            const pagesFree = bufferPool['Innodb_buffer_pool_pages_free'] ?? 0;
+            const pagesData = bufferPool['Innodb_buffer_pool_pages_data'] ?? 0;
+            const pagesDirty = bufferPool['Innodb_buffer_pool_pages_dirty'] ?? 0;
+
+            return {
+                buffer_pool: {
+                    size_bytes: parseInt(config['innodb_buffer_pool_size'] ?? '0', 10),
+                    instances: parseInt(config['innodb_buffer_pool_instances'] ?? '1', 10),
+                    hit_ratio_percent: hitRatio,
+                    pages: {
+                        total: pagesTotal,
+                        free: pagesFree,
+                        data: pagesData,
+                        dirty: pagesDirty,
+                        dirty_percent: pagesTotal > 0 ? Math.round((pagesDirty / pagesTotal) * 100) : 0
+                    },
+                    read_requests: readRequests,
+                    reads: reads,
+                    write_requests: bufferPool['Innodb_buffer_pool_write_requests'] ?? 0
+                },
+                configuration: {
+                    buffer_pool_size: config['innodb_buffer_pool_size'],
+                    log_file_size: config['innodb_log_file_size'],
+                    log_files_in_group: config['innodb_log_files_in_group'],
+                    flush_log_at_trx_commit: config['innodb_flush_log_at_trx_commit'],
+                    file_per_table: config['innodb_file_per_table']
+                },
+                row_operations: {
+                    reads: operations['Innodb_rows_read'] ?? 0,
+                    inserts: operations['Innodb_rows_inserted'] ?? 0,
+                    updates: operations['Innodb_rows_updated'] ?? 0,
+                    deletes: operations['Innodb_rows_deleted'] ?? 0
+                },
+                io: {
+                    data_reads: operations['Innodb_data_reads'] ?? 0,
+                    data_writes: operations['Innodb_data_writes'] ?? 0,
+                    log_writes: operations['Innodb_log_writes'] ?? 0,
+                    os_log_written: operations['Innodb_os_log_written'] ?? 0
+                }
+            };
+        }
+    };
+}

package/src/adapters/mysql/resources/locks.ts

@@ -0,0 +1,64 @@
+/**
+ * MySQL Resource - Locks
+ */
+import type { MySQLAdapter } from '../MySQLAdapter.js';
+import type { ResourceDefinition, RequestContext } from '../../../types/index.js';
+
+export function createLocksResource(adapter: MySQLAdapter): ResourceDefinition {
+    return {
+        uri: 'mysql://locks',
+        name: 'Lock Contention',
+        title: 'MySQL Lock Contention',
+        description: 'Current InnoDB lock waits and blocking transactions',
+        mimeType: 'application/json',
+        annotations: {
+            audience: ['user', 'assistant'],
+            priority: 0.8
+        },
+        handler: async (_uri: string, _context: RequestContext) => {
+            try {
+                // Get current lock waits from performance_schema
+                const lockWaitsResult = await adapter.executeQuery(`
+                    SELECT 
+                        r.trx_id AS waiting_trx_id,
+                        r.trx_mysql_thread_id AS waiting_thread,
+                        r.trx_query AS waiting_query,
+                        b.trx_id AS blocking_trx_id,
+                        b.trx_mysql_thread_id AS blocking_thread,
+                        b.trx_query AS blocking_query,
+                        TIMESTAMPDIFF(SECOND, r.trx_wait_started, NOW()) AS wait_seconds
+                    FROM performance_schema.data_lock_waits w
+                    JOIN information_schema.innodb_trx r ON r.trx_id = w.REQUESTING_ENGINE_TRANSACTION_ID
+                    JOIN information_schema.innodb_trx b ON b.trx_id = w.BLOCKING_ENGINE_TRANSACTION_ID
+                    LIMIT 20
+                `);
+
+                // Get global lock status
+                const lockStatusResult = await adapter.executeQuery(`
+                    SHOW STATUS LIKE 'Innodb_row_lock%'
+                `);
+
+                const lockStats: Record<string, unknown> = {};
+                for (const row of (lockStatusResult.rows ?? [])) {
+                    const varName = row['Variable_name'];
+                    if (typeof varName === 'string') {
+                        lockStats[varName] = row['Value'];
+                    }
+                }
+
+                return {
+                    currentLockWaits: lockWaitsResult.rows?.length ?? 0,
+                    lockWaits: lockWaitsResult.rows ?? [],
+                    lockStatistics: lockStats
+                };
+            } catch {
+                return {
+                    currentLockWaits: 0,
+                    lockWaits: [],
+                    lockStatistics: {},
+                    error: 'Unable to retrieve lock information'
+                };
+            }
+        }
+    };
+}

package/src/adapters/mysql/resources/performance.ts

@@ -0,0 +1,100 @@
+/**
+ * MySQL Resource - Performance
+ * 
+ * Query performance metrics and slow query information.
+ */
+import type { MySQLAdapter } from '../MySQLAdapter.js';
+import type { ResourceDefinition, RequestContext } from '../../../types/index.js';
+
+export function createPerformanceResource(adapter: MySQLAdapter): ResourceDefinition {
+    return {
+        uri: 'mysql://performance',
+        name: 'Performance Metrics',
+        title: 'MySQL Performance Metrics',
+        description: 'Query performance statistics and slow query analysis',
+        mimeType: 'application/json',
+        annotations: {
+            audience: ['user', 'assistant'],
+            priority: 0.8
+        },
+        handler: async (_uri: string, _context: RequestContext) => {
+            // Get performance-related status variables
+            const statusResult = await adapter.executeQuery(`
+                SHOW GLOBAL STATUS WHERE Variable_name IN (
+                    'Queries', 'Questions', 'Slow_queries',
+                    'Select_full_join', 'Select_range_check', 'Select_scan',
+                    'Sort_merge_passes', 'Sort_range', 'Sort_rows', 'Sort_scan',
+                    'Created_tmp_disk_tables', 'Created_tmp_tables',
+                    'Handler_read_first', 'Handler_read_key', 'Handler_read_rnd',
+                    'Handler_read_rnd_next', 'Handler_write'
+                )
+            `);
+
+            const status: Record<string, number> = {};
+            for (const row of statusResult.rows ?? []) {
+                status[row['Variable_name'] as string] = parseInt(row['Value'] as string, 10);
+            }
+
+            // Get performance schema if available (MySQL 5.6+)
+            let topQueries: unknown[] = [];
+            try {
+                const perfResult = await adapter.executeQuery(`
+                    SELECT 
+                        DIGEST_TEXT as query_pattern,
+                        COUNT_STAR as execution_count,
+                        ROUND(SUM_TIMER_WAIT / 1000000000, 2) as total_time_ms,
+                        ROUND(AVG_TIMER_WAIT / 1000000000, 2) as avg_time_ms,
+                        ROUND(MAX_TIMER_WAIT / 1000000000, 2) as max_time_ms,
+                        SUM_ROWS_EXAMINED as rows_examined,
+                        SUM_ROWS_SENT as rows_sent
+                    FROM performance_schema.events_statements_summary_by_digest
+                    WHERE DIGEST_TEXT IS NOT NULL
+                    ORDER BY SUM_TIMER_WAIT DESC
+                    LIMIT 10
+                `);
+                topQueries = perfResult.rows ?? [];
+            } catch {
+                // Performance schema may not be available
+            }
+
+            // Calculate derived metrics
+            const tmpTablesCreated = status['Created_tmp_tables'] ?? 0;
+            const tmpDiskRatio = tmpTablesCreated > 0
+                ? Math.round(((status['Created_tmp_disk_tables'] ?? 0) / tmpTablesCreated) * 100)
+                : 0;
+
+            const fullTableScans = status['Handler_read_rnd_next'] ?? 0;
+            const indexReads = status['Handler_read_key'] ?? 0;
+            const scanVsIndexRatio = (fullTableScans + indexReads) > 0
+                ? Math.round((fullTableScans / (fullTableScans + indexReads)) * 100)
+                : 0;
+
+            return {
+                summary: {
+                    total_queries: status['Queries'] ?? 0,
+                    slow_queries: status['Slow_queries'] ?? 0,
+                    tmp_tables_to_disk_percent: tmpDiskRatio,
+                    full_scan_percent: scanVsIndexRatio
+                },
+                sorts: {
+                    merge_passes: status['Sort_merge_passes'] ?? 0,
+                    range: status['Sort_range'] ?? 0,
+                    rows: status['Sort_rows'] ?? 0,
+                    scan: status['Sort_scan'] ?? 0
+                },
+                joins: {
+                    full_join: status['Select_full_join'] ?? 0,
+                    range_check: status['Select_range_check'] ?? 0,
+                    scan: status['Select_scan'] ?? 0
+                },
+                handler: {
+                    read_key: status['Handler_read_key'] ?? 0,
+                    read_rnd: status['Handler_read_rnd'] ?? 0,
+                    read_rnd_next: status['Handler_read_rnd_next'] ?? 0,
+                    write: status['Handler_write'] ?? 0
+                },
+                top_queries: topQueries
+            };
+        }
+    };
+}

package/src/adapters/mysql/resources/pool.ts

@@ -0,0 +1,26 @@
+/**
+ * MySQL Resource - Pool
+ */
+import type { MySQLAdapter } from '../MySQLAdapter.js';
+import type { ResourceDefinition, RequestContext } from '../../../types/index.js';
+
+export function createPoolResource(adapter: MySQLAdapter): ResourceDefinition {
+    return {
+        uri: 'mysql://pool',
+        name: 'Connection Pool',
+        title: 'MySQL Connection Pool',
+        description: 'Connection pool statistics',
+        mimeType: 'application/json',
+        annotations: {
+            audience: ['user', 'assistant'],
+            priority: 0.7
+        },
+        handler: (_uri: string, _context: RequestContext) => {
+            const pool = adapter.getPool();
+            if (!pool) {
+                return Promise.resolve({ error: 'Pool not available' });
+            }
+            return Promise.resolve({ poolStats: pool.getStats() });
+        }
+    };
+}

package/src/adapters/mysql/resources/processlist.ts

@@ -0,0 +1,23 @@
+/**
+ * MySQL Resource - Processlist
+ */
+import type { MySQLAdapter } from '../MySQLAdapter.js';
+import type { ResourceDefinition, RequestContext } from '../../../types/index.js';
+
+export function createProcesslistResource(adapter: MySQLAdapter): ResourceDefinition {
+    return {
+        uri: 'mysql://processlist',
+        name: 'Active Processes',
+        title: 'MySQL Active Processes',
+        description: 'Currently running queries and connections',
+        mimeType: 'application/json',
+        annotations: {
+            audience: ['user', 'assistant'],
+            priority: 0.8
+        },
+        handler: async (_uri: string, _context: RequestContext) => {
+            const result = await adapter.executeQuery('SHOW FULL PROCESSLIST');
+            return { processes: result.rows };
+        }
+    };
+}

package/src/adapters/mysql/resources/replication.ts

@@ -0,0 +1,120 @@
+/**
+ * MySQL Resource - Replication
+ * 
+ * Replication status, lag monitoring, and GTID information.
+ */
+import type { MySQLAdapter } from '../MySQLAdapter.js';
+import type { ResourceDefinition, RequestContext } from '../../../types/index.js';
+
+export function createReplicationResource(adapter: MySQLAdapter): ResourceDefinition {
+    return {
+        uri: 'mysql://replication',
+        name: 'Replication Status',
+        title: 'MySQL Replication Status',
+        description: 'Replication status, lag monitoring, and GTID information',
+        mimeType: 'application/json',
+        annotations: {
+            audience: ['user', 'assistant'],
+            priority: 0.6
+        },
+        handler: async (_uri: string, _context: RequestContext) => {
+            // Check if this is a replica
+            let replicaStatus: Record<string, unknown> | null = null;
+            try {
+                // Try MySQL 8.0.22+ syntax first
+                const replicaResult = await adapter.executeQuery('SHOW REPLICA STATUS');
+                if (replicaResult.rows && replicaResult.rows.length > 0) {
+                    replicaStatus = replicaResult.rows[0] ?? null;
+                }
+            } catch {
+                try {
+                    // Fall back to older syntax
+                    const slaveResult = await adapter.executeQuery('SHOW SLAVE STATUS');
+                    if (slaveResult.rows && slaveResult.rows.length > 0) {
+                        replicaStatus = slaveResult.rows[0] ?? null;
+                    }
+                } catch {
+                    // Not a replica or no permissions
+                }
+            }
+
+            // Check if this is a source/master
+            let sourceStatus: Record<string, unknown> | null = null;
+            try {
+                const binlogResult = await adapter.executeQuery('SHOW BINARY LOG STATUS');
+                if (binlogResult.rows && binlogResult.rows.length > 0) {
+                    sourceStatus = binlogResult.rows[0] ?? null;
+                }
+            } catch {
+                try {
+                    // Fall back to older syntax
+                    const masterResult = await adapter.executeQuery('SHOW MASTER STATUS');
+                    if (masterResult.rows && masterResult.rows.length > 0) {
+                        sourceStatus = masterResult.rows[0] ?? null;
+                    }
+                } catch {
+                    // Binary logging may be disabled
+                }
+            }
+
+            // Get GTID info if available
+            const gtidInfo: Record<string, string> = {};
+            try {
+                const gtidResult = await adapter.executeQuery(`
+                    SHOW GLOBAL VARIABLES WHERE Variable_name IN (
+                        'gtid_mode', 'gtid_executed', 'gtid_purged', 'enforce_gtid_consistency'
+                    )
+                `);
+                for (const row of gtidResult.rows ?? []) {
+                    gtidInfo[row['Variable_name'] as string] = row['Value'] as string;
+                }
+            } catch {
+                // GTID may not be available
+            }
+
+            // Get connected replicas if this is a source
+            let replicas: unknown[] = [];
+            try {
+                const replicasResult = await adapter.executeQuery('SHOW REPLICAS');
+                replicas = replicasResult.rows ?? [];
+            } catch {
+                try {
+                    const replicasResult = await adapter.executeQuery('SHOW SLAVE HOSTS');
+                    replicas = replicasResult.rows ?? [];
+                } catch {
+                    // May not have permission or no replicas connected
+                }
+            }
+
+            // Determine role
+            let role = 'standalone';
+            if (replicaStatus) {
+                role = sourceStatus ? 'replica-source' : 'replica';
+            } else if (sourceStatus) {
+                role = 'source';
+            }
+
+            return {
+                role,
+                source: sourceStatus ? {
+                    file: sourceStatus['File'],
+                    position: sourceStatus['Position'],
+                    binlog_do_db: sourceStatus['Binlog_Do_DB'],
+                    binlog_ignore_db: sourceStatus['Binlog_Ignore_DB']
+                } : null,
+                replica: replicaStatus ? {
+                    source_host: replicaStatus['Source_Host'] ?? replicaStatus['Master_Host'],
+                    source_port: replicaStatus['Source_Port'] ?? replicaStatus['Master_Port'],
+                    io_running: replicaStatus['Replica_IO_Running'] ?? replicaStatus['Slave_IO_Running'],
+                    sql_running: replicaStatus['Replica_SQL_Running'] ?? replicaStatus['Slave_SQL_Running'],
+                    seconds_behind: replicaStatus['Seconds_Behind_Source'] ?? replicaStatus['Seconds_Behind_Master'],
+                    last_error: replicaStatus['Last_Error'],
+                    relay_log_file: replicaStatus['Relay_Log_File'],
+                    relay_log_pos: replicaStatus['Relay_Log_Pos']
+                } : null,
+                gtid: gtidInfo,
+                connected_replicas: replicas
+            };
+        }
+    };
+}

package/src/adapters/mysql/resources/schema.ts

@@ -0,0 +1,23 @@
+/**
+ * MySQL Resource - Schema
+ */
+import type { MySQLAdapter } from '../MySQLAdapter.js';
+import type { ResourceDefinition, RequestContext } from '../../../types/index.js';
+
+export function createSchemaResource(adapter: MySQLAdapter): ResourceDefinition {
+    return {
+        uri: 'mysql://schema',
+        name: 'Database Schema',
+        title: 'MySQL Database Schema',
+        description: 'Full database schema including tables, views, and indexes',
+        mimeType: 'application/json',
+        annotations: {
+            audience: ['user', 'assistant'],
+            priority: 0.8
+        },
+        handler: async (_uri: string, _context: RequestContext) => {
+            const schema = await adapter.getSchema();
+            return schema;
+        }
+    };
+}

package/src/adapters/mysql/resources/spatial.ts

@@ -0,0 +1,54 @@
+/**
+ * MySQL Resource - Spatial
+ */
+import type { MySQLAdapter } from '../MySQLAdapter.js';
+import type { ResourceDefinition, RequestContext } from '../../../types/index.js';
+
+export function createSpatialResource(adapter: MySQLAdapter): ResourceDefinition {
+    return {
+        uri: 'mysql://spatial',
+        name: 'Spatial Columns',
+        title: 'MySQL Spatial/GIS Columns',
+        description: 'Spatial columns and indexes in the database',
+        mimeType: 'application/json',
+        annotations: {
+            audience: ['user', 'assistant'],
+            priority: 0.5
+        },
+        handler: async (_uri: string, _context: RequestContext) => {
+            // Get spatial columns
+            const columnsResult = await adapter.executeQuery(`
+                SELECT 
+                    TABLE_SCHEMA as schema_name,
+                    TABLE_NAME as table_name,
+                    COLUMN_NAME as column_name,
+                    DATA_TYPE as data_type,
+                    SRS_ID as srid
+                FROM information_schema.COLUMNS
+                WHERE DATA_TYPE IN ('geometry', 'point', 'linestring', 'polygon', 
+                                   'multipoint', 'multilinestring', 'multipolygon', 'geometrycollection')
+                  AND TABLE_SCHEMA = DATABASE()
+                ORDER BY TABLE_NAME, COLUMN_NAME
+            `);
+
+            // Get spatial indexes
+            const indexesResult = await adapter.executeQuery(`
+                SELECT 
+                    TABLE_NAME as table_name,
+                    INDEX_NAME as index_name,
+                    COLUMN_NAME as column_name
+                FROM information_schema.STATISTICS
+                WHERE INDEX_TYPE = 'SPATIAL'
+                  AND TABLE_SCHEMA = DATABASE()
+                ORDER BY TABLE_NAME, INDEX_NAME
+            `);
+
+            return {
+                spatialColumnCount: columnsResult.rows?.length ?? 0,
+                spatialColumns: columnsResult.rows ?? [],
+                spatialIndexCount: indexesResult.rows?.length ?? 0,
+                spatialIndexes: indexesResult.rows ?? []
+            };
+        }
+    };
+}

package/src/adapters/mysql/resources/status.ts

@@ -0,0 +1,27 @@
+/**
+ * MySQL Resource - Status
+ */
+import type { MySQLAdapter } from '../MySQLAdapter.js';
+import type { ResourceDefinition, RequestContext } from '../../../types/index.js';
+
+export function createStatusResource(adapter: MySQLAdapter): ResourceDefinition {
+    return {
+        uri: 'mysql://status',
+        name: 'Server Status',
+        title: 'MySQL Server Status',
+        description: 'MySQL server status metrics',
+        mimeType: 'application/json',
+        annotations: {
+            audience: ['user', 'assistant'],
+            priority: 0.7
+        },
+        handler: async (_uri: string, _context: RequestContext) => {
+            const result = await adapter.executeQuery('SHOW GLOBAL STATUS');
+            const status: Record<string, string> = {};
+            for (const row of result.rows ?? []) {
+                status[row['Variable_name'] as string] = row['Value'] as string;
+            }
+            return { status };
+        }
+    };
+}