@neverinfamous/postgres-mcp 1.0.1

package/dist/adapters/postgresql/tools/pgcrypto.js

@@ -0,0 +1,239 @@
+/**
+ * PostgreSQL pgcrypto Extension Tools
+ * 9 tools total.
+ */
+import { z } from "zod";
+import { readOnly, write } from "../../../utils/annotations.js";
+import { getToolIcons } from "../../../utils/icons.js";
+import { PgcryptoHashSchema, PgcryptoHmacSchema, PgcryptoEncryptSchema, PgcryptoEncryptSchemaBase, PgcryptoDecryptSchema, PgcryptoDecryptSchemaBase, PgcryptoRandomBytesSchema, PgcryptoGenSaltSchema, PgcryptoCryptSchema, } from "../schemas/index.js";
+export function getPgcryptoTools(adapter) {
+    return [
+        createPgcryptoExtensionTool(adapter),
+        createPgcryptoHashTool(adapter),
+        createPgcryptoHmacTool(adapter),
+        createPgcryptoEncryptTool(adapter),
+        createPgcryptoDecryptTool(adapter),
+        createPgcryptoGenRandomUuidTool(adapter),
+        createPgcryptoGenRandomBytesTool(adapter),
+        createPgcryptoGenSaltTool(adapter),
+        createPgcryptoCryptTool(adapter),
+    ];
+}
+function createPgcryptoExtensionTool(adapter) {
+    return {
+        name: "pg_pgcrypto_create_extension",
+        description: "Enable the pgcrypto extension for cryptographic functions.",
+        group: "pgcrypto",
+        inputSchema: z.object({}),
+        annotations: write("Create Pgcrypto Extension"),
+        icons: getToolIcons("pgcrypto", write("Create Pgcrypto Extension")),
+        handler: async (_params, _context) => {
+            await adapter.executeQuery("CREATE EXTENSION IF NOT EXISTS pgcrypto");
+            return { success: true, message: "pgcrypto extension enabled" };
+        },
+    };
+}
+function createPgcryptoHashTool(adapter) {
+    return {
+        name: "pg_pgcrypto_hash",
+        description: "Hash data using various algorithms (SHA-256, SHA-512, MD5, etc.).",
+        group: "pgcrypto",
+        inputSchema: PgcryptoHashSchema,
+        annotations: readOnly("Hash Data"),
+        icons: getToolIcons("pgcrypto", readOnly("Hash Data")),
+        handler: async (params, _context) => {
+            const { data, algorithm, encoding } = PgcryptoHashSchema.parse(params);
+            const enc = encoding ?? "hex";
+            const encodeFunc = enc === "base64"
+                ? "encode(digest($1, $2), 'base64')"
+                : "encode(digest($1, $2), 'hex')";
+            const result = await adapter.executeQuery(`SELECT ${encodeFunc} as hash`, [data, algorithm]);
+            return {
+                success: true,
+                algorithm,
+                encoding: enc,
+                hash: result.rows?.[0]?.["hash"],
+                inputLength: data.length,
+            };
+        },
+    };
+}
+function createPgcryptoHmacTool(adapter) {
+    return {
+        name: "pg_pgcrypto_hmac",
+        description: "Compute HMAC for data with a secret key.",
+        group: "pgcrypto",
+        inputSchema: PgcryptoHmacSchema,
+        annotations: readOnly("HMAC"),
+        icons: getToolIcons("pgcrypto", readOnly("HMAC")),
+        handler: async (params, _context) => {
+            const { data, key, algorithm, encoding } = PgcryptoHmacSchema.parse(params);
+            const enc = encoding ?? "hex";
+            const encodeFunc = enc === "base64"
+                ? "encode(hmac($1, $2, $3), 'base64')"
+                : "encode(hmac($1, $2, $3), 'hex')";
+            const result = await adapter.executeQuery(`SELECT ${encodeFunc} as hmac`, [data, key, algorithm]);
+            return {
+                success: true,
+                algorithm,
+                encoding: enc,
+                hmac: result.rows?.[0]?.["hmac"],
+            };
+        },
+    };
+}
+function createPgcryptoEncryptTool(adapter) {
+    return {
+        name: "pg_pgcrypto_encrypt",
+        description: "Encrypt data using PGP symmetric encryption.",
+        group: "pgcrypto",
+        // Use base schema for MCP so properties are properly exposed
+        inputSchema: PgcryptoEncryptSchemaBase,
+        annotations: readOnly("Encrypt Data"),
+        icons: getToolIcons("pgcrypto", readOnly("Encrypt Data")),
+        handler: async (params, _context) => {
+            // Use transformed schema with alias resolution for validation
+            const { data, password, options } = PgcryptoEncryptSchema.parse(params);
+            const sql = options !== undefined
+                ? `SELECT encode(pgp_sym_encrypt($1, $2, $3), 'base64') as encrypted`
+                : `SELECT encode(pgp_sym_encrypt($1, $2), 'base64') as encrypted`;
+            const queryParams = options !== undefined ? [data, password, options] : [data, password];
+            const result = await adapter.executeQuery(sql, queryParams);
+            return {
+                success: true,
+                encrypted: result.rows?.[0]?.["encrypted"],
+                encoding: "base64",
+            };
+        },
+    };
+}
+function createPgcryptoDecryptTool(adapter) {
+    return {
+        name: "pg_pgcrypto_decrypt",
+        description: "Decrypt data that was encrypted with pg_pgcrypto_encrypt.",
+        group: "pgcrypto",
+        // Use base schema for MCP so properties are properly exposed
+        inputSchema: PgcryptoDecryptSchemaBase,
+        annotations: readOnly("Decrypt Data"),
+        icons: getToolIcons("pgcrypto", readOnly("Decrypt Data")),
+        handler: async (params, _context) => {
+            // Use transformed schema with alias resolution for validation
+            const { encryptedData, password } = PgcryptoDecryptSchema.parse(params);
+            const result = await adapter.executeQuery(`SELECT pgp_sym_decrypt(decode($1, 'base64'), $2) as decrypted`, [encryptedData, password]);
+            const decrypted = result.rows?.[0]?.["decrypted"];
+            // Throw error for decryption failure (wrong password or corrupted data)
+            if (decrypted === undefined || decrypted === null) {
+                throw new Error("Decryption failed - wrong password or corrupted data");
+            }
+            return { success: true, decrypted: decrypted, verified: true };
+        },
+    };
+}
+function createPgcryptoGenRandomUuidTool(adapter) {
+    // Schema with proper validation
+    const GenUuidSchema = z
+        .object({
+        count: z
+            .number()
+            .min(1)
+            .max(100)
+            .optional()
+            .describe("Number of UUIDs to generate (default: 1, max: 100)"),
+    })
+        .default({});
+    return {
+        name: "pg_pgcrypto_gen_random_uuid",
+        description: "Generate a cryptographically secure UUID v4.",
+        group: "pgcrypto",
+        inputSchema: GenUuidSchema,
+        annotations: readOnly("Generate UUID"),
+        icons: getToolIcons("pgcrypto", readOnly("Generate UUID")),
+        handler: async (params, _context) => {
+            // Parse via Zod to enforce count validation (max 100)
+            const parsed = GenUuidSchema.parse(params);
+            const generateCount = parsed.count ?? 1;
+            const result = await adapter.executeQuery(`SELECT gen_random_uuid()::text as uuid FROM generate_series(1, $1)`, [generateCount]);
+            const uuids = (result.rows ?? []).map((r) => r["uuid"]);
+            // Add convenience 'uuid' property for single UUID requests
+            const response = {
+                success: true,
+                uuids,
+                count: uuids.length,
+            };
+            if (uuids.length === 1) {
+                response["uuid"] = uuids[0];
+            }
+            return response;
+        },
+    };
+}
+function createPgcryptoGenRandomBytesTool(adapter) {
+    return {
+        name: "pg_pgcrypto_gen_random_bytes",
+        description: "Generate cryptographically secure random bytes.",
+        group: "pgcrypto",
+        inputSchema: PgcryptoRandomBytesSchema,
+        annotations: readOnly("Generate Random Bytes"),
+        icons: getToolIcons("pgcrypto", readOnly("Generate Random Bytes")),
+        handler: async (params, _context) => {
+            const { length, encoding } = PgcryptoRandomBytesSchema.parse(params);
+            const enc = encoding ?? "hex";
+            const encodeFormat = enc === "base64" ? "base64" : "hex";
+            const result = await adapter.executeQuery(`SELECT encode(gen_random_bytes($1), $2) as random_bytes`, [length, encodeFormat]);
+            return {
+                success: true,
+                randomBytes: result.rows?.[0]?.["random_bytes"],
+                length,
+                encoding: enc,
+            };
+        },
+    };
+}
+function createPgcryptoGenSaltTool(adapter) {
+    return {
+        name: "pg_pgcrypto_gen_salt",
+        description: "Generate a salt for use with crypt() password hashing.",
+        group: "pgcrypto",
+        inputSchema: PgcryptoGenSaltSchema,
+        annotations: readOnly("Generate Salt"),
+        icons: getToolIcons("pgcrypto", readOnly("Generate Salt")),
+        handler: async (params, _context) => {
+            const { type, iterations } = PgcryptoGenSaltSchema.parse(params);
+            const result = iterations !== undefined && (type === "bf" || type === "xdes")
+                ? await adapter.executeQuery(`SELECT gen_salt($1, $2) as salt`, [
+                    type,
+                    iterations,
+                ])
+                : await adapter.executeQuery(`SELECT gen_salt($1) as salt`, [type]);
+            return {
+                success: true,
+                salt: result.rows?.[0]?.["salt"],
+                type,
+            };
+        },
+    };
+}
+function createPgcryptoCryptTool(adapter) {
+    return {
+        name: "pg_pgcrypto_crypt",
+        description: "Hash a password using crypt() with a salt from gen_salt().",
+        group: "pgcrypto",
+        inputSchema: PgcryptoCryptSchema,
+        annotations: readOnly("Crypt Password"),
+        icons: getToolIcons("pgcrypto", readOnly("Crypt Password")),
+        handler: async (params, _context) => {
+            const { password, salt } = PgcryptoCryptSchema.parse(params);
+            const result = await adapter.executeQuery(`SELECT crypt($1, $2) as hash`, [password, salt]);
+            const hash = result.rows?.[0]?.["hash"];
+            const algorithm = salt.startsWith("$2a$") || salt.startsWith("$2b$")
+                ? "bcrypt"
+                : salt.startsWith("$1$")
+                    ? "md5"
+                    : salt.startsWith("_")
+                        ? "xdes"
+                        : "des";
+            return { success: true, hash, algorithm };
+        },
+    };
+}
+//# sourceMappingURL=pgcrypto.js.map

package/dist/adapters/postgresql/tools/pgcrypto.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pgcrypto.js","sourceRoot":"","sources":["../../../../src/adapters/postgresql/tools/pgcrypto.ts"],"names":[],"mappings":"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"}

package/dist/adapters/postgresql/tools/postgis/advanced.d.ts

@@ -0,0 +1,21 @@
+/**
+ * PostgreSQL PostGIS Extension Tools - Advanced Operations
+ *
+ * Advanced spatial tools: geocode, geo_transform, geo_index_optimize, geo_cluster.
+ */
+import type { PostgresAdapter } from "../../PostgresAdapter.js";
+import type { ToolDefinition } from "../../../../types/index.js";
+export declare function createGeocodeTool(adapter: PostgresAdapter): ToolDefinition;
+/**
+ * Transform geometry between coordinate systems
+ */
+export declare function createGeoTransformTool(adapter: PostgresAdapter): ToolDefinition;
+/**
+ * Analyze and optimize spatial indexes
+ */
+export declare function createGeoIndexOptimizeTool(adapter: PostgresAdapter): ToolDefinition;
+/**
+ * Spatial clustering using ST_ClusterDBSCAN or ST_ClusterKMeans
+ */
+export declare function createGeoClusterTool(adapter: PostgresAdapter): ToolDefinition;
+//# sourceMappingURL=advanced.d.ts.map

package/dist/adapters/postgresql/tools/postgis/advanced.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"advanced.d.ts","sourceRoot":"","sources":["../../../../../src/adapters/postgresql/tools/postgis/advanced.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAChE,OAAO,KAAK,EACV,cAAc,EAEf,MAAM,4BAA4B,CAAC;AAapC,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,eAAe,GAAG,cAAc,CAoC1E;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,eAAe,GACvB,cAAc,CA4EhB;AAED;;GAEG;AACH,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,eAAe,GACvB,cAAc,CAwIhB;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,eAAe,GAAG,cAAc,CAgM7E"}

package/dist/adapters/postgresql/tools/postgis/advanced.js

@@ -0,0 +1,383 @@
+/**
+ * PostgreSQL PostGIS Extension Tools - Advanced Operations
+ *
+ * Advanced spatial tools: geocode, geo_transform, geo_index_optimize, geo_cluster.
+ */
+import { z } from "zod";
+import { readOnly } from "../../../../utils/annotations.js";
+import { getToolIcons } from "../../../../utils/icons.js";
+import { GeocodeSchemaBase, GeocodeSchema, GeoTransformSchemaBase, GeoTransformSchema, GeoClusterSchemaBase, GeoClusterSchema, } from "../../schemas/index.js";
+export function createGeocodeTool(adapter) {
+    return {
+        name: "pg_geocode",
+        description: "Create a point geometry from latitude/longitude coordinates. The SRID parameter sets output metadata only; input coordinates are always WGS84 lat/lng.",
+        group: "postgis",
+        inputSchema: GeocodeSchemaBase, // Base schema for MCP visibility
+        annotations: readOnly("Geocode"),
+        icons: getToolIcons("postgis", readOnly("Geocode")),
+        handler: async (params, _context) => {
+            const parsed = GeocodeSchema.parse(params ?? {});
+            const srid = parsed.srid ?? 4326;
+            const sql = `SELECT 
+                        ST_AsGeoJSON(ST_SetSRID(ST_MakePoint($1, $2), $3)) as geojson,
+                        ST_AsText(ST_SetSRID(ST_MakePoint($1, $2), $3)) as wkt`;
+            const result = await adapter.executeQuery(sql, [
+                parsed.lng,
+                parsed.lat,
+                srid,
+            ]);
+            // Add note about SRID for non-4326 cases
+            const row = result.rows?.[0];
+            if (row === undefined) {
+                return {};
+            }
+            const response = { ...row };
+            if (srid !== 4326) {
+                response["note"] =
+                    `Coordinates are WGS84 lat/lng with SRID ${String(srid)} metadata. Use pg_geo_transform to convert to target CRS.`;
+            }
+            return response;
+        },
+    };
+}
+/**
+ * Transform geometry between coordinate systems
+ */
+export function createGeoTransformTool(adapter) {
+    return {
+        name: "pg_geo_transform",
+        description: "Transform geometry from one spatial reference system (SRID) to another.",
+        group: "postgis",
+        inputSchema: GeoTransformSchemaBase, // Base schema for MCP visibility
+        annotations: readOnly("Transform Geometry"),
+        icons: getToolIcons("postgis", readOnly("Transform Geometry")),
+        handler: async (params, _context) => {
+            const parsed = GeoTransformSchema.parse(params ?? {});
+            const schemaName = parsed.schema ?? "public";
+            const qualifiedTable = schemaName !== "public"
+                ? `"${schemaName}"."${parsed.table}"`
+                : `"${parsed.table}"`;
+            const columnName = `"${parsed.column}"`;
+            const whereClause = parsed.where !== undefined ? `WHERE ${parsed.where}` : "";
+            // Default limit of 50 to prevent large payloads, use limit: 0 for all
+            const effectiveLimit = parsed.limit ?? 50;
+            const limitClause = effectiveLimit > 0 ? `LIMIT ${String(effectiveLimit)}` : "";
+            // Get non-geometry columns to avoid returning raw WKB
+            const colQuery = `
+        SELECT column_name FROM information_schema.columns 
+        WHERE table_schema = $1 AND table_name = $2 
+        AND udt_name NOT IN ('geometry', 'geography')
+        ORDER BY ordinal_position
+      `;
+            const colResult = await adapter.executeQuery(colQuery, [
+                schemaName,
+                parsed.table,
+            ]);
+            const nonGeomCols = (colResult.rows ?? [])
+                .map((row) => `"${String(row["column_name"])}"`)
+                .join(", ");
+            // Select non-geometry columns + transformed geometry representations
+            const selectCols = nonGeomCols.length > 0
+                ? `${nonGeomCols}, ST_AsGeoJSON(ST_Transform(ST_SetSRID(${columnName}, ${String(parsed.fromSrid)}), ${String(parsed.toSrid)})) as transformed_geojson, ST_AsText(ST_Transform(ST_SetSRID(${columnName}, ${String(parsed.fromSrid)}), ${String(parsed.toSrid)})) as transformed_wkt, ${String(parsed.toSrid)} as output_srid`
+                : `ST_AsGeoJSON(ST_Transform(ST_SetSRID(${columnName}, ${String(parsed.fromSrid)}), ${String(parsed.toSrid)})) as transformed_geojson, ST_AsText(ST_Transform(ST_SetSRID(${columnName}, ${String(parsed.fromSrid)}), ${String(parsed.toSrid)})) as transformed_wkt, ${String(parsed.toSrid)} as output_srid`;
+            const sql = `SELECT ${selectCols} FROM ${qualifiedTable} ${whereClause} ${limitClause}`;
+            const result = await adapter.executeQuery(sql);
+            // Build response with truncation indicators if default limit was applied
+            const response = {
+                results: result.rows,
+                count: result.rows?.length ?? 0,
+                fromSrid: parsed.fromSrid,
+                toSrid: parsed.toSrid,
+            };
+            // When using default limit, check if more rows exist
+            if (parsed.limit === undefined && effectiveLimit > 0) {
+                const countSql = `SELECT COUNT(*) as cnt FROM ${qualifiedTable} ${whereClause}`;
+                const countResult = await adapter.executeQuery(countSql);
+                const totalCount = Number(countResult.rows?.[0]?.["cnt"] ?? 0);
+                if (totalCount > effectiveLimit) {
+                    response["truncated"] = true;
+                    response["totalCount"] = totalCount;
+                    response["limit"] = effectiveLimit;
+                }
+            }
+            return response;
+        },
+    };
+}
+/**
+ * Analyze and optimize spatial indexes
+ */
+export function createGeoIndexOptimizeTool(adapter) {
+    return {
+        name: "pg_geo_index_optimize",
+        description: "Analyze spatial indexes and provide optimization recommendations.",
+        group: "postgis",
+        inputSchema: z.object({
+            table: z
+                .string()
+                .optional()
+                .describe("Specific table to analyze (or all spatial tables)"),
+            schema: z.string().optional().describe("Schema name"),
+        }),
+        annotations: readOnly("Geo Index Optimize"),
+        icons: getToolIcons("postgis", readOnly("Geo Index Optimize")),
+        handler: async (params, _context) => {
+            const parsed = params;
+            const schemaName = parsed.schema ?? "public";
+            const indexQuery = `
+                SELECT 
+                    c.relname as table_name,
+                    i.relname as index_name,
+                    a.attname as column_name,
+                    pg_size_pretty(pg_relation_size(i.oid)) as index_size,
+                    pg_relation_size(i.oid) as index_size_bytes,
+                    idx_scan as index_scans,
+                    idx_tup_read as tuples_read,
+                    idx_tup_fetch as tuples_fetched
+                FROM pg_index x
+                JOIN pg_class c ON c.oid = x.indrelid
+                JOIN pg_class i ON i.oid = x.indexrelid
+                JOIN pg_attribute a ON a.attrelid = c.oid AND a.attnum = ANY(x.indkey)
+                JOIN pg_namespace n ON n.oid = c.relnamespace
+                JOIN pg_type t ON t.oid = a.atttypid
+                LEFT JOIN pg_stat_user_indexes s ON s.indexrelid = i.oid
+                WHERE n.nspname = $1
+                AND (pg_get_indexdef(i.oid) LIKE '%gist%' OR pg_get_indexdef(i.oid) LIKE '%spgist%')
+                AND t.typname IN ('geometry', 'geography')
+                ${parsed.table !== undefined ? `AND c.relname = '${parsed.table}'` : ""}
+                ORDER BY index_size_bytes DESC
+            `;
+            const [indexes, tableStats] = await Promise.all([
+                adapter.executeQuery(indexQuery, [schemaName]),
+                adapter.executeQuery(`
+                    SELECT 
+                        c.relname as table_name,
+                        n_live_tup as row_count,
+                        pg_size_pretty(pg_table_size(c.oid)) as table_size
+                    FROM pg_stat_user_tables t
+                    JOIN pg_class c ON c.relname = t.relname
+                    JOIN pg_namespace n ON n.oid = c.relnamespace
+                    WHERE n.nspname = $1
+                    ${parsed.table !== undefined ? `AND c.relname = '${parsed.table}'` : ""}
+                    AND EXISTS (
+                        SELECT 1 FROM information_schema.columns ic
+                        WHERE ic.table_schema = n.nspname 
+                        AND ic.table_name = c.relname 
+                        AND ic.udt_name IN ('geometry', 'geography')
+                    )
+                `, [schemaName]),
+            ]);
+            const recommendations = [];
+            for (const idx of indexes.rows ?? []) {
+                const scans = Number(idx["index_scans"] ?? 0);
+                const sizeBytes = Number(idx["index_size_bytes"] ?? 0);
+                if (scans === 0 && sizeBytes > 1024 * 1024) {
+                    recommendations.push(`Index "${String(idx["index_name"])}" on ${String(idx["table_name"])} is unused but takes ${String(idx["index_size"])}. Consider dropping it.`);
+                }
+                if (scans > 0 && sizeBytes > 100 * 1024 * 1024) {
+                    recommendations.push(`Large spatial index "${String(idx["index_name"])}" (${String(idx["index_size"])}). Consider partitioning the table for better performance.`);
+                }
+            }
+            for (const table of tableStats.rows ?? []) {
+                const rowCount = Number(table["row_count"] ?? 0);
+                const hasIndex = (indexes.rows ?? []).some((idx) => idx["table_name"] === table["table_name"]);
+                if (rowCount > 10000 && !hasIndex) {
+                    recommendations.push(`Table "${String(table["table_name"])}" has ${String(rowCount)} rows but no spatial index. Consider adding a GiST index.`);
+                }
+            }
+            // Warn if table filter specified but no results found
+            if (parsed.table !== undefined &&
+                (indexes.rows?.length ?? 0) === 0 &&
+                (tableStats.rows?.length ?? 0) === 0) {
+                return {
+                    warning: `Table "${parsed.table}" not found in schema "${schemaName}" or has no spatial columns/indexes.`,
+                    table: parsed.table,
+                    schema: schemaName,
+                    spatialIndexes: [],
+                    tableStats: [],
+                    recommendations: [
+                        `Verify table "${parsed.table}" exists and has geometry/geography columns.`,
+                    ],
+                };
+            }
+            return {
+                spatialIndexes: indexes.rows,
+                tableStats: tableStats.rows,
+                recommendations: recommendations.length > 0
+                    ? recommendations
+                    : (indexes.rows?.length ?? 0) === 0
+                        ? [
+                            "No spatial indexes found in this schema. Consider adding GiST indexes for spatial columns.",
+                        ]
+                        : ["All spatial indexes appear optimized"],
+                tips: [
+                    "Use GiST indexes for general spatial queries",
+                    "Consider SP-GiST for point-only data",
+                    "CLUSTER table by spatial index for range queries",
+                    "Use BRIN indexes for very large, sorted spatial data",
+                ],
+            };
+        },
+    };
+}
+/**
+ * Spatial clustering using ST_ClusterDBSCAN or ST_ClusterKMeans
+ */
+export function createGeoClusterTool(adapter) {
+    return {
+        name: "pg_geo_cluster",
+        description: "Perform spatial clustering using DBSCAN or K-Means. DBSCAN defaults: eps=100m, minPoints=3. K-Means default: numClusters=5 (provide explicit value for best results).",
+        group: "postgis",
+        inputSchema: GeoClusterSchemaBase, // Base schema for MCP visibility
+        annotations: readOnly("Geo Cluster"),
+        icons: getToolIcons("postgis", readOnly("Geo Cluster")),
+        handler: async (params, _context) => {
+            const parsed = GeoClusterSchema.parse(params ?? {});
+            const method = parsed.method ?? "dbscan";
+            const schemaName = parsed.schema ?? "public";
+            const qualifiedTable = schemaName !== "public"
+                ? `"${schemaName}"."${parsed.table}"`
+                : `"${parsed.table}"`;
+            const whereClause = parsed.where !== undefined ? `WHERE ${parsed.where}` : "";
+            const limitClause = parsed.limit !== undefined && parsed.limit > 0
+                ? `LIMIT ${String(parsed.limit)}`
+                : "";
+            // Track warning if K > N
+            let warning;
+            // For K-Means, validate and adjust numClusters
+            let effectiveNumClusters = parsed.numClusters ?? 5;
+            let rowCount = 0;
+            if (method === "kmeans") {
+                // Validate numClusters > 0
+                if (effectiveNumClusters <= 0) {
+                    return {
+                        error: `numClusters must be greater than 0 (received: ${String(effectiveNumClusters)}).`,
+                        method,
+                        table: parsed.table,
+                        numClusters: effectiveNumClusters,
+                        suggestion: "Provide a positive integer for numClusters (e.g., numClusters: 3)",
+                    };
+                }
+                const countResult = await adapter.executeQuery(`SELECT COUNT(*) as cnt FROM ${qualifiedTable} ${whereClause}`);
+                rowCount = Number(countResult.rows?.[0]?.["cnt"] ?? 0);
+                if (rowCount === 0) {
+                    return {
+                        error: `No rows found in table ${parsed.table}${whereClause !== "" ? " matching filter" : ""}. K-Means requires at least 1 row.`,
+                        method,
+                        table: parsed.table,
+                        rowCount: 0,
+                    };
+                }
+                // Clamp K to row count and warn if exceeded
+                if (effectiveNumClusters > rowCount) {
+                    warning = `Requested ${String(parsed.numClusters)} clusters but only ${String(rowCount)} rows available. Using ${String(rowCount)} clusters instead.`;
+                    effectiveNumClusters = rowCount;
+                }
+            }
+            let clusterFunction;
+            if (method === "kmeans") {
+                clusterFunction = `ST_ClusterKMeans("${parsed.column}", ${String(effectiveNumClusters)}) OVER ()`;
+            }
+            else {
+                const eps = parsed.eps ?? 100;
+                const minPoints = parsed.minPoints ?? 3;
+                clusterFunction = `ST_ClusterDBSCAN("${parsed.column}", ${String(eps)}, ${String(minPoints)}) OVER ()`;
+            }
+            const sql = `
+                WITH clustered AS (
+                    SELECT 
+                        *,
+                        ${clusterFunction} as cluster_id
+                    FROM ${qualifiedTable}
+                    ${whereClause}
+                )
+                SELECT 
+                    cluster_id,
+                    COUNT(*) as point_count,
+                    ST_AsGeoJSON(ST_Centroid(ST_Collect("${parsed.column}"))) as centroid,
+                    ST_AsGeoJSON(ST_ConvexHull(ST_Collect("${parsed.column}"))) as hull
+                FROM clustered
+                WHERE cluster_id IS NOT NULL
+                GROUP BY cluster_id
+                ORDER BY point_count DESC
+                ${limitClause}
+            `;
+            const [clustersResult, summaryResult] = await Promise.all([
+                adapter.executeQuery(sql),
+                adapter.executeQuery(`
+                    WITH clustered AS (
+                        SELECT ${clusterFunction} as cluster_id
+                        FROM ${qualifiedTable}
+                        ${whereClause}
+                    )
+                    SELECT 
+                        COUNT(DISTINCT cluster_id) as num_clusters,
+                        COUNT(*) FILTER (WHERE cluster_id IS NULL) as noise_points,
+                        COUNT(*) as total_points
+                    FROM clustered
+                `),
+            ]);
+            // Normalize cluster point_count to numbers
+            const normalizedClusters = (clustersResult.rows ?? []).map((row) => ({
+                ...row,
+                point_count: Number(row["point_count"]),
+            }));
+            // Normalize summary values to numbers for consistency
+            const rawSummary = summaryResult.rows?.[0] ?? {};
+            const normalizedSummary = {
+                num_clusters: Number(rawSummary["num_clusters"] ?? 0),
+                noise_points: Number(rawSummary["noise_points"] ?? 0),
+                total_points: Number(rawSummary["total_points"] ?? 0),
+            };
+            // Build response
+            const response = {
+                method,
+                parameters: method === "kmeans"
+                    ? { numClusters: effectiveNumClusters }
+                    : { eps: parsed.eps ?? 100, minPoints: parsed.minPoints ?? 3 },
+                summary: normalizedSummary,
+                clusters: normalizedClusters,
+            };
+            // Add warning if K was clamped
+            if (warning !== undefined) {
+                response["warning"] = warning;
+                response["requestedClusters"] = parsed.numClusters;
+                response["actualClusters"] = effectiveNumClusters;
+            }
+            // Add contextual hints based on method and results
+            const numClusters = normalizedSummary.num_clusters;
+            const noisePoints = normalizedSummary.noise_points;
+            const totalPoints = normalizedSummary.total_points;
+            if (method === "dbscan") {
+                const eps = parsed.eps ?? 100;
+                const minPoints = parsed.minPoints ?? 3;
+                // Provide hints about DBSCAN parameter trade-offs
+                const hints = [];
+                if (numClusters === 1 && totalPoints > 1) {
+                    hints.push(`All ${String(totalPoints)} points formed a single cluster. Consider decreasing eps (currently ${String(eps)}m) to create more distinct clusters.`);
+                }
+                if (noisePoints > 0 && noisePoints > totalPoints * 0.5) {
+                    hints.push(`${String(noisePoints)} of ${String(totalPoints)} points (${String(Math.round((noisePoints / totalPoints) * 100))}%) are noise. Consider increasing eps or decreasing minPoints (currently ${String(minPoints)}).`);
+                }
+                if (numClusters === 0 && totalPoints > 0) {
+                    hints.push(`No clusters formed - all points are noise. Try increasing eps (currently ${String(eps)}m) or decreasing minPoints (currently ${String(minPoints)}).`);
+                }
+                response["notes"] =
+                    "Noise points (cluster_id = NULL) are points not belonging to any cluster";
+                if (hints.length > 0) {
+                    response["hints"] = hints;
+                }
+                response["parameterGuide"] = {
+                    eps: `Distance threshold in meters. Larger values group more distant points together.`,
+                    minPoints: `Minimum points required to form a cluster. Higher values create fewer, denser clusters.`,
+                };
+            }
+            else {
+                response["notes"] =
+                    "K-Means will always assign all points to a cluster";
+            }
+            return response;
+        },
+    };
+}
+//# sourceMappingURL=advanced.js.map