@neverinfamous/mysql-mcp 2.1.0

package/src/adapters/mysql/tools/spatial/operations.ts

@@ -0,0 +1,217 @@
+/**
+ * MySQL Spatial/GIS Tools - Spatial Operations
+ * 
+ * Tools for spatial transformations and operations.
+ * 4 tools: intersection, buffer, transform, geojson.
+ */
+
+import { z } from 'zod';
+import type { MySQLAdapter } from '../../MySQLAdapter.js';
+import type { ToolDefinition, RequestContext } from '../../../../types/index.js';
+
+// =============================================================================
+// Zod Schemas
+// =============================================================================
+
+const IntersectionSchema = z.object({
+    geometry1: z.string().describe('First WKT geometry'),
+    geometry2: z.string().describe('Second WKT geometry'),
+    srid: z.number().default(4326).describe('SRID')
+});
+
+const BufferSchema = z.object({
+    geometry: z.string().describe('WKT geometry'),
+    distance: z.number().describe('Buffer distance in meters'),
+    srid: z.number().default(4326).describe('SRID')
+});
+
+const TransformSchema = z.object({
+    geometry: z.string().describe('WKT geometry'),
+    fromSrid: z.number().describe('Source SRID'),
+    toSrid: z.number().describe('Target SRID')
+});
+
+const GeoJSONSchema = z.object({
+    geometry: z.string().optional().describe('WKT geometry to convert to GeoJSON'),
+    geoJson: z.string().optional().describe('GeoJSON to convert to WKT'),
+    srid: z.number().default(4326).describe('SRID for conversion')
+}).refine(
+    data => (data.geometry !== undefined) !== (data.geoJson !== undefined),
+    'Either geometry or geoJson must be provided, but not both'
+);
+
+/**
+ * Calculate intersection of two geometries
+ */
+export function createSpatialIntersectionTool(adapter: MySQLAdapter): ToolDefinition {
+    return {
+        name: 'mysql_spatial_intersection',
+        title: 'MySQL Spatial Intersection',
+        description: 'Calculate the intersection of two geometries.',
+        group: 'spatial',
+        inputSchema: IntersectionSchema,
+        requiredScopes: ['read'],
+        annotations: {
+            readOnlyHint: true,
+            idempotentHint: true
+        },
+        handler: async (params: unknown, _context: RequestContext) => {
+            const { geometry1, geometry2, srid } = IntersectionSchema.parse(params);
+
+            const result = await adapter.executeQuery(
+                `SELECT 
+                    ST_Intersects(ST_GeomFromText(?), ST_GeomFromText(?)) as intersects,
+                    ST_AsText(ST_Intersection(
+                        ST_SRID(ST_GeomFromText(?), ${String(srid)}),
+                        ST_SRID(ST_GeomFromText(?), ${String(srid)})
+                    )) as intersection_wkt,
+                    ST_AsGeoJSON(ST_Intersection(
+                        ST_SRID(ST_GeomFromText(?), ${String(srid)}),
+                        ST_SRID(ST_GeomFromText(?), ${String(srid)})
+                    )) as intersection_geojson`,
+                [geometry1, geometry2, geometry1, geometry2, geometry1, geometry2]
+            );
+
+            const row = result.rows?.[0];
+            const intersectionGeoJsonStr = row?.['intersection_geojson'];
+            return {
+                intersects: Boolean(row?.['intersects']),
+                intersectionWkt: row?.['intersection_wkt'],
+                intersectionGeoJson: typeof intersectionGeoJsonStr === 'string'
+                    ? JSON.parse(intersectionGeoJsonStr) as Record<string, unknown>
+                    : null
+            };
+        }
+    };
+}
+
+/**
+ * Create a buffer around a geometry
+ */
+export function createSpatialBufferTool(adapter: MySQLAdapter): ToolDefinition {
+    return {
+        name: 'mysql_spatial_buffer',
+        title: 'MySQL Spatial Buffer',
+        description: 'Create a buffer (expanded area) around a geometry.',
+        group: 'spatial',
+        inputSchema: BufferSchema,
+        requiredScopes: ['read'],
+        annotations: {
+            readOnlyHint: true,
+            idempotentHint: true
+        },
+        handler: async (params: unknown, _context: RequestContext) => {
+            const { geometry, distance, srid } = BufferSchema.parse(params);
+
+            const result = await adapter.executeQuery(
+                `SELECT 
+                    ST_AsText(ST_Buffer(ST_SRID(ST_GeomFromText(?), ${String(srid)}), ?)) as buffer_wkt,
+                    ST_AsGeoJSON(ST_Buffer(ST_SRID(ST_GeomFromText(?), ${String(srid)}), ?)) as buffer_geojson`,
+                [geometry, distance, geometry, distance]
+            );
+
+            const row = result.rows?.[0];
+            const bufferGeoJsonStr = row?.['buffer_geojson'];
+            return {
+                bufferWkt: row?.['buffer_wkt'],
+                bufferGeoJson: typeof bufferGeoJsonStr === 'string'
+                    ? JSON.parse(bufferGeoJsonStr) as Record<string, unknown>
+                    : null,
+                bufferDistance: distance,
+                srid
+            };
+        }
+    };
+}
+
+/**
+ * Transform geometry between SRIDs
+ */
+export function createSpatialTransformTool(adapter: MySQLAdapter): ToolDefinition {
+    return {
+        name: 'mysql_spatial_transform',
+        title: 'MySQL Spatial Transform',
+        description: 'Transform a geometry from one spatial reference system to another.',
+        group: 'spatial',
+        inputSchema: TransformSchema,
+        requiredScopes: ['read'],
+        annotations: {
+            readOnlyHint: true,
+            idempotentHint: true
+        },
+        handler: async (params: unknown, _context: RequestContext) => {
+            const { geometry, fromSrid, toSrid } = TransformSchema.parse(params);
+
+            const result = await adapter.executeQuery(
+                `SELECT 
+                    ST_AsText(ST_Transform(ST_SRID(ST_GeomFromText(?), ${String(fromSrid)}), ${String(toSrid)})) as transformed_wkt,
+                    ST_AsGeoJSON(ST_Transform(ST_SRID(ST_GeomFromText(?), ${String(fromSrid)}), ${String(toSrid)})) as transformed_geojson`,
+                [geometry, geometry]
+            );
+
+            const row = result.rows?.[0];
+            const transformedGeoJsonStr = row?.['transformed_geojson'];
+            return {
+                originalWkt: geometry,
+                transformedWkt: row?.['transformed_wkt'],
+                transformedGeoJson: typeof transformedGeoJsonStr === 'string'
+                    ? JSON.parse(transformedGeoJsonStr) as Record<string, unknown>
+                    : null,
+                fromSrid,
+                toSrid
+            };
+        }
+    };
+}
+
+/**
+ * Convert between WKT and GeoJSON
+ */
+export function createSpatialGeoJSONTool(adapter: MySQLAdapter): ToolDefinition {
+    return {
+        name: 'mysql_spatial_geojson',
+        title: 'MySQL GeoJSON Conversion',
+        description: 'Convert geometry between WKT and GeoJSON formats.',
+        group: 'spatial',
+        inputSchema: GeoJSONSchema,
+        requiredScopes: ['read'],
+        annotations: {
+            readOnlyHint: true,
+            idempotentHint: true
+        },
+        handler: async (params: unknown, _context: RequestContext) => {
+            const { geometry, geoJson, srid } = GeoJSONSchema.parse(params);
+
+            if (geometry) {
+                // Convert WKT to GeoJSON
+                const result = await adapter.executeQuery(
+                    `SELECT ST_AsGeoJSON(ST_SRID(ST_GeomFromText(?), ${String(srid)})) as geoJson`,
+                    [geometry]
+                );
+
+                const row = result.rows?.[0];
+                const geoJsonStr = row?.['geoJson'];
+                return {
+                    wkt: geometry,
+                    geoJson: typeof geoJsonStr === 'string' ? JSON.parse(geoJsonStr) as Record<string, unknown> : null,
+                    conversion: 'WKT to GeoJSON'
+                };
+            } else if (geoJson) {
+                // Convert GeoJSON to WKT
+                const result = await adapter.executeQuery(
+                    `SELECT ST_AsText(ST_GeomFromGeoJSON(?)) as wkt`,
+                    [geoJson]
+                );
+
+                const row = result.rows?.[0];
+                return {
+                    wkt: row?.['wkt'],
+                    geoJson: JSON.parse(geoJson) as Record<string, unknown>,
+                    conversion: 'GeoJSON to WKT'
+                };
+            }
+
+            throw new Error('Either geometry or geoJson must be provided');
+        }
+    };
+}

package/src/adapters/mysql/tools/spatial/queries.ts

@@ -0,0 +1,235 @@
+/**
+ * MySQL Spatial/GIS Tools - Spatial Queries
+ * 
+ * Tools for querying spatial relationships and distances.
+ * 4 tools: distance, distance_sphere, contains, within.
+ */
+
+import { z } from 'zod';
+import type { MySQLAdapter } from '../../MySQLAdapter.js';
+import type { ToolDefinition, RequestContext } from '../../../../types/index.js';
+
+// =============================================================================
+// Zod Schemas
+// =============================================================================
+
+const DistanceSchema = z.object({
+    table: z.string().describe('Table name'),
+    spatialColumn: z.string().describe('Spatial column name'),
+    point: z.object({
+        longitude: z.number(),
+        latitude: z.number()
+    }).describe('Reference point'),
+    maxDistance: z.number().optional().describe('Maximum distance in meters'),
+    limit: z.number().default(20).describe('Maximum results'),
+    srid: z.number().default(4326).describe('SRID')
+});
+
+const ContainsSchema = z.object({
+    table: z.string().describe('Table name'),
+    spatialColumn: z.string().describe('Spatial column name'),
+    polygon: z.string().describe('WKT polygon to test containment'),
+    limit: z.number().default(100).describe('Maximum results'),
+    srid: z.number().default(4326).describe('SRID of the input geometry (default: 4326 for GPS coordinates)')
+});
+
+const WithinSchema = z.object({
+    table: z.string().describe('Table name'),
+    spatialColumn: z.string().describe('Spatial column name'),
+    geometry: z.string().describe('WKT geometry to test within'),
+    limit: z.number().default(100).describe('Maximum results'),
+    srid: z.number().default(4326).describe('SRID of the input geometry (default: 4326 for GPS coordinates)')
+});
+
+/**
+ * Calculate distance between geometries
+ */
+export function createSpatialDistanceTool(adapter: MySQLAdapter): ToolDefinition {
+    return {
+        name: 'mysql_spatial_distance',
+        title: 'MySQL Spatial Distance',
+        description: 'Find rows within a certain distance from a point (Cartesian distance).',
+        group: 'spatial',
+        inputSchema: DistanceSchema,
+        requiredScopes: ['read'],
+        annotations: {
+            readOnlyHint: true,
+            idempotentHint: true
+        },
+        handler: async (params: unknown, _context: RequestContext) => {
+            const { table, spatialColumn, point, maxDistance, limit, srid } = DistanceSchema.parse(params);
+
+            // Validate identifiers
+            if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(table)) {
+                throw new Error('Invalid table name');
+            }
+            if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(spatialColumn)) {
+                throw new Error('Invalid column name');
+            }
+
+            // Use 'axis-order=long-lat' to accept natural longitude-latitude order
+            const pointWkt = `POINT(${String(point.longitude)} ${String(point.latitude)})`;
+
+            let query = `
+                SELECT *,
+                       ST_Distance(\`${spatialColumn}\`, ST_GeomFromText(?, ${String(srid)}, 'axis-order=long-lat')) as distance
+                FROM \`${table}\`
+            `;
+
+            const queryParams: unknown[] = [pointWkt];
+
+            if (maxDistance !== undefined) {
+                query += ` WHERE ST_Distance(\`${spatialColumn}\`, ST_GeomFromText(?, ${String(srid)}, 'axis-order=long-lat')) <= ?`;
+                queryParams.push(pointWkt, maxDistance);
+            }
+
+            query += ` ORDER BY distance LIMIT ${String(limit)}`;
+
+            const result = await adapter.executeQuery(query, queryParams);
+            return {
+                results: result.rows ?? [],
+                count: result.rows?.length ?? 0,
+                referencePoint: point
+            };
+        }
+    };
+}
+
+/**
+ * Calculate spherical distance
+ */
+export function createSpatialDistanceSphereTool(adapter: MySQLAdapter): ToolDefinition {
+    return {
+        name: 'mysql_spatial_distance_sphere',
+        title: 'MySQL Spherical Distance',
+        description: 'Calculate distance on a sphere (for geographic coordinates). Returns distance in meters.',
+        group: 'spatial',
+        inputSchema: DistanceSchema,
+        requiredScopes: ['read'],
+        annotations: {
+            readOnlyHint: true,
+            idempotentHint: true
+        },
+        handler: async (params: unknown, _context: RequestContext) => {
+            const { table, spatialColumn, point, maxDistance, limit, srid } = DistanceSchema.parse(params);
+
+            // Validate identifiers
+            if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(table)) {
+                throw new Error('Invalid table name');
+            }
+            if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(spatialColumn)) {
+                throw new Error('Invalid column name');
+            }
+
+            // Use 'axis-order=long-lat' to accept natural longitude-latitude order
+            const pointWkt = `POINT(${String(point.longitude)} ${String(point.latitude)})`;
+
+            let query = `
+                SELECT *,
+                       ST_Distance_Sphere(\`${spatialColumn}\`, ST_GeomFromText(?, ${String(srid)}, 'axis-order=long-lat')) as distance_meters
+                FROM \`${table}\`
+            `;
+
+            const queryParams: unknown[] = [pointWkt];
+
+            if (maxDistance !== undefined) {
+                query += ` WHERE ST_Distance_Sphere(\`${spatialColumn}\`, ST_GeomFromText(?, ${String(srid)}, 'axis-order=long-lat')) <= ?`;
+                queryParams.push(pointWkt, maxDistance);
+            }
+
+            query += ` ORDER BY distance_meters LIMIT ${String(limit)}`;
+
+            const result = await adapter.executeQuery(query, queryParams);
+            return {
+                results: result.rows ?? [],
+                count: result.rows?.length ?? 0,
+                referencePoint: point,
+                unit: 'meters'
+            };
+        }
+    };
+}
+
+/**
+ * Find geometries contained within a polygon
+ */
+export function createSpatialContainsTool(adapter: MySQLAdapter): ToolDefinition {
+    return {
+        name: 'mysql_spatial_contains',
+        title: 'MySQL Spatial Contains',
+        description: 'Find rows where the geometry is contained within a specified polygon.',
+        group: 'spatial',
+        inputSchema: ContainsSchema,
+        requiredScopes: ['read'],
+        annotations: {
+            readOnlyHint: true,
+            idempotentHint: true
+        },
+        handler: async (params: unknown, _context: RequestContext) => {
+            const { table, spatialColumn, polygon, limit, srid } = ContainsSchema.parse(params);
+
+            // Validate identifiers
+            if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(table)) {
+                throw new Error('Invalid table name');
+            }
+            if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(spatialColumn)) {
+                throw new Error('Invalid column name');
+            }
+
+            const query = `
+                SELECT *
+                FROM \`${table}\`
+                WHERE ST_Contains(ST_GeomFromText(?, ${String(srid)}), \`${spatialColumn}\`)
+                LIMIT ${String(limit)}
+            `;
+
+            const result = await adapter.executeQuery(query, [polygon]);
+            return {
+                results: result.rows ?? [],
+                count: result.rows?.length ?? 0
+            };
+        }
+    };
+}
+
+/**
+ * Find geometries within another geometry
+ */
+export function createSpatialWithinTool(adapter: MySQLAdapter): ToolDefinition {
+    return {
+        name: 'mysql_spatial_within',
+        title: 'MySQL Spatial Within',
+        description: 'Find rows where the geometry is within a specified geometry.',
+        group: 'spatial',
+        inputSchema: WithinSchema,
+        requiredScopes: ['read'],
+        annotations: {
+            readOnlyHint: true,
+            idempotentHint: true
+        },
+        handler: async (params: unknown, _context: RequestContext) => {
+            const { table, spatialColumn, geometry, limit, srid } = WithinSchema.parse(params);
+
+            // Validate identifiers
+            if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(table)) {
+                throw new Error('Invalid table name');
+            }
+            if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(spatialColumn)) {
+                throw new Error('Invalid column name');
+            }
+
+            const query = `
+                SELECT *
+                FROM \`${table}\`
+                WHERE ST_Within(\`${spatialColumn}\`, ST_GeomFromText(?, ${String(srid)}))
+                LIMIT ${String(limit)}
+            `;
+
+            const result = await adapter.executeQuery(query, [geometry]);
+            return {
+                results: result.rows ?? [],
+                count: result.rows?.length ?? 0
+            };
+        }
+    };
+}

package/src/adapters/mysql/tools/spatial/setup.ts

@@ -0,0 +1,104 @@
+/**
+ * MySQL Spatial/GIS Tools - Setup and Schema Management
+ * 
+ * Tools for creating and managing spatial columns and indexes.
+ * 2 tools: column creation and index creation.
+ */
+
+import { z } from 'zod';
+import type { MySQLAdapter } from '../../MySQLAdapter.js';
+import type { ToolDefinition, RequestContext } from '../../../../types/index.js';
+
+// =============================================================================
+// Zod Schemas
+// =============================================================================
+
+const SpatialColumnSchema = z.object({
+    table: z.string().describe('Table name'),
+    column: z.string().describe('Column name'),
+    type: z.enum(['POINT', 'LINESTRING', 'POLYGON', 'GEOMETRY', 'MULTIPOINT', 'MULTILINESTRING', 'MULTIPOLYGON', 'GEOMETRYCOLLECTION']).default('GEOMETRY').describe('Geometry type'),
+    srid: z.number().default(4326).describe('Spatial Reference System ID (4326 = WGS84)'),
+    nullable: z.boolean().default(true).describe('Allow NULL values')
+});
+
+const SpatialIndexSchema = z.object({
+    table: z.string().describe('Table name'),
+    column: z.string().describe('Spatial column name'),
+    indexName: z.string().optional().describe('Index name (auto-generated if not provided)')
+});
+
+/**
+ * Add a spatial column to a table
+ */
+export function createSpatialCreateColumnTool(adapter: MySQLAdapter): ToolDefinition {
+    return {
+        name: 'mysql_spatial_create_column',
+        title: 'MySQL Create Spatial Column',
+        description: 'Add a geometry/spatial column to an existing table.',
+        group: 'spatial',
+        inputSchema: SpatialColumnSchema,
+        requiredScopes: ['write'],
+        annotations: {
+            readOnlyHint: false
+        },
+        handler: async (params: unknown, _context: RequestContext) => {
+            const { table, column, type, srid, nullable } = SpatialColumnSchema.parse(params);
+
+            // Validate identifiers
+            if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(table)) {
+                throw new Error('Invalid table name');
+            }
+            if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(column)) {
+                throw new Error('Invalid column name');
+            }
+
+            const nullClause = nullable ? '' : ' NOT NULL';
+            const sridClause = srid ? ` SRID ${String(srid)}` : '';
+
+            await adapter.executeQuery(
+                `ALTER TABLE \`${table}\` ADD COLUMN \`${column}\` ${type}${sridClause}${nullClause}`
+            );
+
+            return { success: true, table, column, type, srid };
+        }
+    };
+}
+
+/**
+ * Create a spatial index
+ */
+export function createSpatialCreateIndexTool(adapter: MySQLAdapter): ToolDefinition {
+    return {
+        name: 'mysql_spatial_create_index',
+        title: 'MySQL Create Spatial Index',
+        description: 'Create a SPATIAL index on a geometry column for faster queries.',
+        group: 'spatial',
+        inputSchema: SpatialIndexSchema,
+        requiredScopes: ['write'],
+        annotations: {
+            readOnlyHint: false
+        },
+        handler: async (params: unknown, _context: RequestContext) => {
+            const { table, column, indexName } = SpatialIndexSchema.parse(params);
+
+            // Validate identifiers
+            if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(table)) {
+                throw new Error('Invalid table name');
+            }
+            if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(column)) {
+                throw new Error('Invalid column name');
+            }
+
+            const idxName = indexName ?? `idx_spatial_${table}_${column}`;
+            if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(idxName)) {
+                throw new Error('Invalid index name');
+            }
+
+            await adapter.executeQuery(
+                `CREATE SPATIAL INDEX \`${idxName}\` ON \`${table}\` (\`${column}\`)`
+            );
+
+            return { success: true, indexName: idxName, table, column };
+        }
+    };
+}

package/src/adapters/mysql/tools/stats/__tests__/comparative.test.ts

@@ -0,0 +1,139 @@
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { createCorrelationTool, createRegressionTool, createHistogramTool } from '../comparative.js';
+import { MySQLAdapter } from '../../../MySQLAdapter.js';
+
+describe('Comparative Stats Tools', () => {
+    let mockAdapter: any;
+    let correlationTool: any;
+    let regressionTool: any;
+    let histogramTool: any;
+
+    beforeEach(() => {
+        mockAdapter = {
+            executeQuery: vi.fn()
+        };
+        correlationTool = createCorrelationTool(mockAdapter as MySQLAdapter);
+        regressionTool = createRegressionTool(mockAdapter as MySQLAdapter);
+        histogramTool = createHistogramTool(mockAdapter as MySQLAdapter);
+    });
+
+    describe('mysql_stats_correlation', () => {
+        it('should interpret strong correlation', async () => {
+            mockAdapter.executeQuery.mockResolvedValue({
+                rows: [{
+                    correlation: 0.95,
+                    sample_size: 100,
+                    mean_x: 10,
+                    mean_y: 20,
+                    std_x: 2,
+                    std_y: 3
+                }]
+            });
+
+            const result: any = await correlationTool.handler({
+                table: 'data',
+                column1: 'x',
+                column2: 'y'
+            }, {} as any);
+
+            expect(result.correlation).toBe(0.95);
+            expect(result.interpretation).toBe('Very strong');
+        });
+
+        it('should interpret weak correlation', async () => {
+            mockAdapter.executeQuery.mockResolvedValue({
+                rows: [{ correlation: 0.2, sample_size: 100 }]
+            });
+
+            const result: any = await correlationTool.handler({
+                table: 'data',
+                column1: 'x',
+                column2: 'y'
+            }, {} as any);
+
+            expect(result.interpretation).toBe('Very weak / No correlation');
+        });
+
+        it('should validate inputs', async () => {
+            await expect(correlationTool.handler({
+                table: 'bad;table',
+                column1: 'x',
+                column2: 'y'
+            }, {} as any)).rejects.toThrow('Invalid table name');
+        });
+    });
+
+    describe('mysql_stats_regression', () => {
+        it('should handle insufficient data', async () => {
+            mockAdapter.executeQuery.mockResolvedValue({
+                rows: [{ n: 1 }]
+            });
+
+            const result: any = await regressionTool.handler({
+                table: 'data',
+                xColumn: 'x',
+                yColumn: 'y'
+            }, {} as any);
+
+            expect(result.error).toContain('Insufficient data');
+        });
+
+        it('should calculate regression and interpretation', async () => {
+            // Need n, sum_x, sum_y, sum_xy, sum_x2, sum_y2 to calculate slope/intercept/r2
+            mockAdapter.executeQuery.mockResolvedValue({
+                rows: [{
+                    n: 3,
+                    sum_x: 6,
+                    sum_y: 6,
+                    sum_xy: 14,
+                    sum_x2: 14,
+                    sum_y2: 14,
+                    avg_x: 2,
+                    avg_y: 2
+                }]
+            });
+
+            const result: any = await regressionTool.handler({
+                table: 'data',
+                xColumn: 'x',
+                yColumn: 'y'
+            }, {} as any);
+
+            expect(result.slope).toBeCloseTo(1);
+            expect(result.intercept).toBeCloseTo(0);
+            expect(result.rSquared).toBeCloseTo(1);
+            expect(result.interpretation).toBe('Good fit');
+        });
+    });
+
+    describe('mysql_stats_histogram', () => {
+        it('should handle update', async () => {
+            // First call (UPDATE) returns whatever, second call (SELECT) returns info
+            mockAdapter.executeQuery
+                .mockResolvedValueOnce({}) // analyze table
+                .mockResolvedValueOnce({ rows: [{ histogramType: 'SINGLETON' }] }); // select info
+
+            const result: any = await histogramTool.handler({
+                table: 'users',
+                column: 'age',
+                update: true
+            }, {} as any);
+
+            expect(mockAdapter.executeQuery).toHaveBeenCalledWith(expect.stringContaining('ANALYZE TABLE'));
+            expect(result.exists).toBe(true);
+        });
+
+        it('should handle non-existent histogram', async () => {
+            mockAdapter.executeQuery.mockResolvedValue({ rows: [] });
+
+            const result: any = await histogramTool.handler({
+                table: 'users',
+                column: 'age'
+            }, {} as any);
+
+            expect(result.exists).toBe(false);
+            expect(result.message).toContain('No histogram exists');
+        });
+    });
+});