db-mcp 3.0.2 → 5.0.0

package/dist/{sqlite-native-IF75BB3O.js → sqlite-native-5GQ3WKCZ.js}

@@ -1,8 +1,7 @@
-import { RowRecordSchema, WhereConditionSchema, sanitizeIdentifier, buildWhereClause, resolveAliases, autoEnableWal, detectAndSetJsonbSupport, SchemaManager, applyCommonPragmas, isDDL, getResourceDefinitions, getPromptDefinitions, validateIdentifier, normalizeSqliteParams, translateSqliteError, getCoreTools, getJsonOperationTools, getJsonHelperTools, getTextTools, getStatsTools, getVirtualTools, getVectorTools, getGeoTools, getAdminTools, getIntrospectionTools, getMigrationTools, getCodeModeTools, validateTableExists, FtsHeadlineSchema } from './chunk-NV34JSQM.js';
-import { DatabaseAdapter } from './chunk-W5WQVNVX.js';
-import { ErrorResponseFields, write, readOnly, VERSION, admin, writeFs, getToolGroupIcon, idempotent } from './chunk-E5IESRTK.js';
-import { logger, formatHandlerError, ValidationError, ConfigurationError, ERROR_CODES, ConnectionError, DbMcpError, ResourceNotFoundError, ExtensionNotAvailableError } from './chunk-L552U3QS.js';
-import Database from 'better-sqlite3';
+import { RowRecordSchema, WhereConditionSchema, autoEnableWal, detectAndSetJsonbSupport, SchemaManager, applyCommonPragmas, isDDL, getResourceDefinitions, getPromptDefinitions, resolveAliases, normalizeSqliteParams, translateSqliteError, getCoreTools, getJsonOperationTools, getJsonHelperTools, getTextTools, getStatsTools, getVirtualTools, getVectorTools, getGeoTools, getAdminTools, getIntrospectionTools, getMigrationTools, getCodeModeTools, validateTableExists, sanitizeFtsQuery, FtsHeadlineSchema } from './chunk-UE7GVOBV.js';
+import { DatabaseAdapter } from './chunk-27C5EE6U.js';
+import { ErrorResponseFields, write, readOnly, VERSION, sanitizeIdentifier, buildWhereClause, admin, validateIdentifier, writeFs, getToolGroupIcon, idempotent } from './chunk-2TYICG7B.js';
+import { logger, formatHandlerError, ValidationError, ConfigurationError, ERROR_CODES, ConnectionError, DbMcpError, ErrorCategory, ResourceNotFoundError, ExtensionNotAvailableError } from './chunk-XLIYO3YA.js';
 import { z } from 'zod';
 import { createRequire } from 'module';
 import { fileURLToPath } from 'url';
@@ -22,7 +21,9 @@ var FtsResultSchema = z.object({
 var FtsSearchOutputSchema = z.object({
   success: z.boolean(),
   rowCount: z.number().optional(),
-  results: z.array(FtsResultSchema).optional()
+  results: z.array(FtsResultSchema).optional(),
+  nextCursor: z.string().optional(),
+  facets: z.record(z.string(), z.number()).optional()
 }).extend(ErrorResponseFields.shape);
 var FtsRebuildOutputSchema = z.object({
   success: z.boolean(),
@@ -65,7 +66,11 @@ var FtsSearchSchema = z.object({
     return val;
   }, z.number().optional().default(100)),
   highlight: z.boolean().optional().default(false).describe("Include highlighted snippets"),
-  includeRowData: z.boolean().optional().default(true).describe("Include full row data in results")
+  includeRowData: z.boolean().optional().default(true).describe("Include full row data in results"),
+  cursor: z.string().optional().describe("Opaque cursor for pagination"),
+  includeFacets: z.boolean().optional().default(false).describe(
+    "Return match counts per column (distribution by matched column)"
+  )
 });
 var FtsRebuildSchema = z.object({
   table: z.string().describe("FTS table name to rebuild")
@@ -224,20 +229,46 @@ function createFtsSearchTool(adapter) {
         }
         sanitizeIdentifier(input.table);
         await validateTableExists(adapter, input.table);
+        let offset = 0;
+        if (input.cursor) {
+          try {
+            const cursorData = JSON.parse(
+              Buffer.from(input.cursor, "base64").toString("utf8")
+            );
+            if (typeof cursorData["offset"] === "number")
+              offset = cursorData["offset"];
+          } catch {
+          }
+        }
         let selectClause = input.includeRowData ? "*" : "rowid";
         if (input.highlight) {
           selectClause += `, highlight("${input.table}", 0, '<b>', '</b>') as snippet`;
         }
         if (input.query === "*" || input.query.trim() === "") {
-          const sql2 = `SELECT ${selectClause}, NULL as rank FROM "${input.table}" ORDER BY rowid LIMIT ${input.limit}`;
+          const sql2 = `SELECT ${selectClause}, NULL as rank FROM "${input.table}" ORDER BY rowid LIMIT ${input.limit} OFFSET ${offset}`;
           const result2 = await adapter.executeReadQuery(sql2, queryParams);
+          let nextCursor2;
+          if (result2.rows?.length === input.limit) {
+            nextCursor2 = Buffer.from(
+              JSON.stringify({ offset: offset + input.limit })
+            ).toString("base64");
+          }
           return {
             success: true,
             rowCount: result2.rows?.length ?? 0,
-            results: result2.rows
+            results: result2.rows,
+            nextCursor: nextCursor2
           };
         }
-        const queryEscaped = input.query.replace(/'/g, "''");
+        const sanitizedQuery = sanitizeFtsQuery(input.query);
+        if (!sanitizedQuery) {
+          return {
+            success: true,
+            rowCount: 0,
+            results: []
+          };
+        }
+        const queryEscaped = sanitizedQuery.replace(/'/g, "''");
         let matchExpr = `"${input.table}" MATCH '${queryEscaped}'`;
         if (input.columns && input.columns.length > 0) {
           for (const col of input.columns) {
@@ -246,12 +277,58 @@ function createFtsSearchTool(adapter) {
           const colFilter = input.columns.map((c) => `${c}:${queryEscaped}`).join(" OR ");
           matchExpr = `"${input.table}" MATCH '${colFilter}'`;
         }
-        const sql = `SELECT ${selectClause}, rank FROM "${input.table}" WHERE ${matchExpr} ORDER BY rank LIMIT ${input.limit}`;
+        let columnsToFacet = [];
+        if (input.includeFacets) {
+          const colResult = await adapter.executeReadQuery(
+            `PRAGMA table_info("${input.table}")`,
+            []
+          );
+          const allCols = (colResult.rows ?? []).map((r, i) => ({
+            name: String(r["name"]),
+            index: i
+          }));
+          if (input.columns && input.columns.length > 0) {
+            columnsToFacet = allCols.filter(
+              (c) => input.columns?.includes(c.name)
+            );
+          } else {
+            columnsToFacet = allCols.filter(
+              (c) => c.name !== input.table && c.name !== "rank"
+            );
+          }
+          for (const col of columnsToFacet) {
+            selectClause += `, highlight("${input.table}", ${col.index}, '', '') as _facet_${col.index}`;
+          }
+        }
+        const sql = `SELECT ${selectClause}, rank FROM "${input.table}" WHERE ${matchExpr} ORDER BY rank LIMIT ${input.limit} OFFSET ${offset}`;
         const result = await adapter.executeReadQuery(sql, queryParams);
+        let nextCursor;
+        if (result.rows?.length === input.limit) {
+          nextCursor = Buffer.from(
+            JSON.stringify({ offset: offset + input.limit })
+          ).toString("base64");
+        }
+        const facets = {};
+        if (input.includeFacets && result.rows) {
+          for (const col of columnsToFacet) {
+            facets[col.name] = 0;
+          }
+          for (const row of result.rows) {
+            for (const col of columnsToFacet) {
+              const val = row[`_facet_${col.index}`];
+              if (typeof val === "string" && val.includes("")) {
+                facets[col.name] = (facets[col.name] ?? 0) + 1;
+              }
+              Reflect.deleteProperty(row, `_facet_${col.index}`);
+            }
+          }
+        }
         return {
           success: true,
           rowCount: result.rows?.length ?? 0,
-          results: result.rows
+          results: result.rows,
+          nextCursor,
+          ...input.includeFacets ? { facets } : {}
         };
       } catch (error) {
         if (isFts5UnavailableError(error)) {
@@ -315,7 +392,15 @@ function createFtsMatchInfoTool(adapter) {
         }
         sanitizeIdentifier(input.table);
         await validateTableExists(adapter, input.table);
-        const queryEscaped = input.query.replace(/'/g, "''");
+        const sanitizedQuery = sanitizeFtsQuery(input.query);
+        if (!sanitizedQuery) {
+          return {
+            success: true,
+            rowCount: 0,
+            results: []
+          };
+        }
+        const queryEscaped = sanitizedQuery.replace(/'/g, "''");
         let rankExpr;
         if (input.format === "bm25") {
           rankExpr = `bm25("${input.table}")`;
@@ -357,8 +442,17 @@ function createFtsHeadlineTool(adapter) {
         }
         sanitizeIdentifier(input.table);
         await validateTableExists(adapter, input.table);
-        const queryEscaped = input.query.replace(/'/g, "''");
+        const sanitizedQuery = sanitizeFtsQuery(input.query);
+        if (!sanitizedQuery && input.query !== "*" && input.query.trim() !== "") {
+          return {
+            success: true,
+            rowCount: 0,
+            results: []
+          };
+        }
+        const queryEscaped = sanitizedQuery.replace(/'/g, "''");
         let columnIndex = 0;
+        let snippetColumnIndex = -1;
         if (input.column) {
           const colResult = await adapter.executeReadQuery(
             `PRAGMA table_info("${input.table}")`,
@@ -370,12 +464,13 @@ function createFtsHeadlineTool(adapter) {
           );
           if (found >= 0) {
             columnIndex = found;
+            snippetColumnIndex = found;
           }
         }
         const startSel = input.startSel.replace(/'/g, "''");
         const stopSel = input.stopSel.replace(/'/g, "''");
         const highlightExpr = `highlight("${input.table}", ${String(columnIndex)}, '${startSel}', '${stopSel}')`;
-        const snippetExpr = `snippet("${input.table}", ${String(columnIndex)}, '${startSel}', '${stopSel}', '...', ${String(input.snippetWords)})`;
+        const snippetExpr = `snippet("${input.table}", ${String(snippetColumnIndex)}, '${startSel}', '${stopSel}', '...', ${String(input.snippetWords)})`;
         if (input.query === "*" || input.query.trim() === "") {
           const sql2 = `SELECT *, NULL as headline, NULL as snippet, NULL as rank FROM "${input.table}" ORDER BY rowid LIMIT ${String(input.limit)}`;
           const result2 = await adapter.executeReadQuery(sql2, queryParams);
@@ -515,7 +610,8 @@ var SpatialiteLoadOutputSchema = z.object({
   message: z.string().optional(),
   alreadyLoaded: z.boolean().optional(),
   extensionPath: z.string().optional(),
-  searchedPaths: z.array(z.string()).optional()
+  searchedPaths: z.array(z.string()).optional(),
+  version: z.string().optional()
 }).extend(ErrorResponseFields.shape);
 var SpatialiteCreateTableOutputSchema = z.object({
   success: z.boolean(),
@@ -562,14 +658,14 @@ var BeginTransactionSchema = z.object({
   mode: z.enum(["deferred", "immediate", "exclusive"]).optional().default("deferred").describe(
     "Transaction mode: deferred waits for first write, immediate acquires lock immediately, exclusive blocks all access"
   )
-});
+}).strict();
 var SavepointSchema = z.object({
   name: z.string().describe("Savepoint name")
-});
+}).strict();
 var ExecuteInTransactionSchema = z.object({
   statements: z.array(z.string()).describe("Array of SQL statements to execute in order"),
   rollbackOnError: z.boolean().optional().default(true).describe("If true, rollback all changes when any statement fails")
-});
+}).strict();
 function getTransactionTools(adapter) {
   return [
     createBeginTransactionTool(adapter),
@@ -612,7 +708,7 @@ function createTransactionStatusTool(adapter) {
     name: "sqlite_transaction_status",
     description: "Check whether a transaction is currently active. Returns status and a boolean flag. Read-only \u2014 does not alter transaction state.",
     group: "transactions",
-    inputSchema: z.object({}),
+    inputSchema: z.object({}).strict(),
     outputSchema: TransactionStatusOutputSchema,
     annotations: readOnly("Transaction Status"),
     requiredScopes: ["read"],
@@ -637,7 +733,7 @@ function createCommitTransactionTool(adapter) {
     name: "sqlite_transaction_commit",
     description: "Commit the current transaction, making all changes permanent.",
     group: "transactions",
-    inputSchema: z.object({}),
+    inputSchema: z.object({}).strict(),
     outputSchema: TransactionCommitOutputSchema,
     annotations: write("Commit Transaction"),
     requiredScopes: ["write"],
@@ -660,7 +756,7 @@ function createRollbackTransactionTool(adapter) {
     description: "Rollback the current transaction, discarding all changes.",
     group: "transactions",
     outputSchema: TransactionRollbackOutputSchema,
-    inputSchema: z.object({}),
+    inputSchema: z.object({}).strict(),
     annotations: write("Rollback Transaction"),
     requiredScopes: ["write"],
     handler: (_params, _context) => {
@@ -858,6 +954,14 @@ function createExecuteInTransactionTool(adapter) {
         if (transactionStarted) {
           adapter.commitTransaction();
         }
+        if (results.length > 50) {
+          const omitted = results.length - 50;
+          results.splice(50);
+          results.push({
+            statement: "TRUNCATED",
+            error: `Results array truncated. Omitted ${omitted} results to conserve payload size.`
+          });
+        }
         return {
           success,
           error: success ? void 0 : "Transaction completed with errors",
@@ -888,17 +992,28 @@ function createExecuteInTransactionTool(adapter) {
         } else if (!transactionStarted && !originallyInTransaction) {
           rollbackMessage = `Transaction failed to start: ${message}`;
         }
+        const totalExecuted = results.length;
+        if (results.length > 50) {
+          const omitted = results.length - 50;
+          results.splice(50);
+          results.push({
+            statement: "TRUNCATED",
+            error: `Results array truncated. Omitted ${omitted} results to conserve payload size.`
+          });
+        }
         return {
           ...formatted,
           error: formatted.error ?? rollbackMessage,
           message: rollbackMessage,
-          statementsExecuted: results.length,
+          statementsExecuted: totalExecuted,
           results
         };
       }
     }
   };
 }
+
+// src/adapters/sqlite-native/tools/window/helpers.ts
 var coerceNumber = (val) => {
   if (typeof val === "string") {
     if (val.trim() === "") return void 0;
@@ -909,93 +1024,6 @@ var coerceNumber = (val) => {
 };
 var coerceEnumValues2 = (allowed) => (val) => typeof val === "string" && allowed.includes(val) ? val : void 0;
 var VALID_DIRECTIONS = ["lag", "lead"];
-var RowNumberSchema = z.object({
-  table: z.string().describe("Table name"),
-  orderBy: z.string().describe("Column(s) to order by"),
-  partitionBy: z.string().optional().describe("Column(s) to partition by"),
-  selectColumns: z.array(z.string()).optional().describe("Columns to include in result"),
-  conditions: z.array(WhereConditionSchema).optional().describe("Optional WHERE clause conditions"),
-  limit: z.preprocess(
-    coerceNumber,
-    z.number().optional().default(20).describe("Maximum rows to return")
-  )
-});
-var RankSchema = z.object({
-  table: z.string().describe("Table name"),
-  orderBy: z.string().describe("Column(s) to order by (determines rank)"),
-  partitionBy: z.string().optional().describe("Column(s) to partition by"),
-  selectColumns: z.array(z.string()).optional().describe("Columns to include in result"),
-  rankType: z.preprocess(
-    coerceEnumValues2(["rank", "dense_rank", "percent_rank"]),
-    z.enum(["rank", "dense_rank", "percent_rank"]).optional().default("rank").describe("Rank function type")
-  ),
-  conditions: z.array(WhereConditionSchema).optional().describe("Optional WHERE clause conditions"),
-  limit: z.preprocess(
-    coerceNumber,
-    z.number().optional().default(20).describe("Maximum rows to return")
-  )
-});
-var LagLeadSchema = z.object({
-  table: z.string().describe("Table name"),
-  column: z.string().describe("Column to get lag/lead value from"),
-  orderBy: z.string().describe("Column(s) to order by"),
-  direction: z.string().describe("LAG (previous) or LEAD (next) row"),
-  offset: z.preprocess(
-    coerceNumber,
-    z.number().optional().default(1).describe("Number of rows to look back/ahead")
-  ),
-  defaultValue: z.string().optional().describe("Default value if no row exists"),
-  partitionBy: z.string().optional().describe("Column(s) to partition by"),
-  selectColumns: z.array(z.string()).optional().describe("Columns to include in result"),
-  conditions: z.array(WhereConditionSchema).optional().describe("Optional WHERE clause conditions"),
-  limit: z.preprocess(
-    coerceNumber,
-    z.number().optional().default(20).describe("Maximum rows to return")
-  )
-});
-var RunningTotalSchema = z.object({
-  table: z.string().describe("Table name"),
-  column: z.string().describe("Column to sum"),
-  orderBy: z.string().describe("Column(s) to order by"),
-  partitionBy: z.string().optional().describe("Reset running total for each partition"),
-  selectColumns: z.array(z.string()).optional().describe("Columns to include in result"),
-  conditions: z.array(WhereConditionSchema).optional().describe("Optional WHERE clause conditions"),
-  limit: z.preprocess(
-    coerceNumber,
-    z.number().optional().default(20).describe("Maximum rows to return")
-  )
-});
-var MovingAverageSchema = z.object({
-  table: z.string().describe("Table name"),
-  column: z.string().describe("Column to average"),
-  orderBy: z.string().describe("Column(s) to order by"),
-  windowSize: z.preprocess(
-    coerceNumber,
-    z.number().describe("Number of rows in the moving window")
-  ),
-  partitionBy: z.string().optional().describe("Column(s) to partition by"),
-  selectColumns: z.array(z.string()).optional().describe("Columns to include in result"),
-  conditions: z.array(WhereConditionSchema).optional().describe("Optional WHERE clause conditions"),
-  limit: z.preprocess(
-    coerceNumber,
-    z.number().optional().default(20).describe("Maximum rows to return")
-  )
-});
-var NtileSchema = z.object({
-  table: z.string().describe("Table name"),
-  orderBy: z.string().describe("Column(s) to order by"),
-  buckets: z.preprocess(
-    coerceNumber,
-    z.number().describe("Number of buckets (e.g., 4 for quartiles)")
-  ),
-  partitionBy: z.string().optional().describe("Column(s) to partition by"),
-  selectColumns: z.array(z.string()).optional().describe("Columns to include in result"),
-  conditions: z.array(WhereConditionSchema).optional().describe("Optional WHERE clause conditions"),
-  limit: z.preprocess(
-    coerceNumber,
-    z.number().optional().default(20).describe("Maximum rows to return")
-  )
-});
 async function validateTableExists2(adapter, table) {
   validateIdentifier(table);
   const result = await adapter.executeReadQuery(
@@ -1041,7 +1069,7 @@ async function validateOrderByColumns(adapter, table, orderBy) {
       throw new DbMcpError(
         `Invalid ORDER BY expression: '${colName}' contains disallowed characters. Only column names with optional ASC/DESC are permitted.`,
         "NATIVE_WINDOW_INVALID_ORDERBY",
-        "validation" /* VALIDATION */
+        ErrorCategory.VALIDATION
       );
     }
     if (/^(ASC|DESC)$/i.test(colName)) continue;
@@ -1157,19 +1185,100 @@ function validateDefaultValue(value) {
   throw new DbMcpError(
     `Invalid default value: '${value}'. Only numeric literals, single-quoted strings, or NULL are permitted.`,
     "NATIVE_WINDOW_INVALID_DEFAULT",
-    "validation" /* VALIDATION */
+    ErrorCategory.VALIDATION
   );
 }
-function getWindowTools(adapter) {
-  return [
-    createRowNumberTool(adapter),
-    createRankTool(adapter),
-    createLagLeadTool(adapter),
-    createRunningTotalTool(adapter),
-    createMovingAverageTool(adapter),
-    createNtileTool(adapter)
-  ];
-}
+
+// src/adapters/sqlite-native/tools/window/schemas.ts
+var RowNumberSchema = z.object({
+  table: z.string().describe("Table name"),
+  orderBy: z.string().describe("Column(s) to order by"),
+  partitionBy: z.string().optional().describe("Column(s) to partition by"),
+  selectColumns: z.array(z.string()).optional().describe("Columns to include in result"),
+  conditions: z.array(WhereConditionSchema).optional().describe("Optional WHERE clause conditions"),
+  limit: z.preprocess(
+    coerceNumber,
+    z.number().optional().default(20).describe("Maximum rows to return")
+  )
+});
+var RankSchema = z.object({
+  table: z.string().describe("Table name"),
+  orderBy: z.string().describe("Column(s) to order by (determines rank)"),
+  partitionBy: z.string().optional().describe("Column(s) to partition by"),
+  selectColumns: z.array(z.string()).optional().describe("Columns to include in result"),
+  rankType: z.preprocess(
+    coerceEnumValues2(["rank", "dense_rank", "percent_rank"]),
+    z.enum(["rank", "dense_rank", "percent_rank"]).optional().default("rank").describe("Rank function type")
+  ),
+  conditions: z.array(WhereConditionSchema).optional().describe("Optional WHERE clause conditions"),
+  limit: z.preprocess(
+    coerceNumber,
+    z.number().optional().default(20).describe("Maximum rows to return")
+  )
+});
+var LagLeadSchema = z.object({
+  table: z.string().describe("Table name"),
+  column: z.string().describe("Column to get lag/lead value from"),
+  orderBy: z.string().describe("Column(s) to order by"),
+  direction: z.string().describe("LAG (previous) or LEAD (next) row"),
+  offset: z.preprocess(
+    coerceNumber,
+    z.number().optional().default(1).describe("Number of rows to look back/ahead")
+  ),
+  defaultValue: z.string().optional().describe("Default value if no row exists"),
+  partitionBy: z.string().optional().describe("Column(s) to partition by"),
+  selectColumns: z.array(z.string()).optional().describe("Columns to include in result"),
+  conditions: z.array(WhereConditionSchema).optional().describe("Optional WHERE clause conditions"),
+  limit: z.preprocess(
+    coerceNumber,
+    z.number().optional().default(20).describe("Maximum rows to return")
+  )
+});
+var RunningTotalSchema = z.object({
+  table: z.string().describe("Table name"),
+  column: z.string().describe("Column to sum"),
+  orderBy: z.string().describe("Column(s) to order by"),
+  partitionBy: z.string().optional().describe("Reset running total for each partition"),
+  selectColumns: z.array(z.string()).optional().describe("Columns to include in result"),
+  conditions: z.array(WhereConditionSchema).optional().describe("Optional WHERE clause conditions"),
+  limit: z.preprocess(
+    coerceNumber,
+    z.number().optional().default(20).describe("Maximum rows to return")
+  )
+});
+var MovingAverageSchema = z.object({
+  table: z.string().describe("Table name"),
+  column: z.string().describe("Column to average"),
+  orderBy: z.string().describe("Column(s) to order by"),
+  windowSize: z.preprocess(
+    coerceNumber,
+    z.number().describe("Number of rows in the moving window")
+  ),
+  partitionBy: z.string().optional().describe("Column(s) to partition by"),
+  selectColumns: z.array(z.string()).optional().describe("Columns to include in result"),
+  conditions: z.array(WhereConditionSchema).optional().describe("Optional WHERE clause conditions"),
+  limit: z.preprocess(
+    coerceNumber,
+    z.number().optional().default(20).describe("Maximum rows to return")
+  )
+});
+var NtileSchema = z.object({
+  table: z.string().describe("Table name"),
+  orderBy: z.string().describe("Column(s) to order by"),
+  buckets: z.preprocess(
+    coerceNumber,
+    z.number().describe("Number of buckets (e.g., 4 for quartiles)")
+  ),
+  partitionBy: z.string().optional().describe("Column(s) to partition by"),
+  selectColumns: z.array(z.string()).optional().describe("Columns to include in result"),
+  conditions: z.array(WhereConditionSchema).optional().describe("Optional WHERE clause conditions"),
+  limit: z.preprocess(
+    coerceNumber,
+    z.number().optional().default(20).describe("Maximum rows to return")
+  )
+});
+
+// src/adapters/sqlite-native/tools/window/row-number.ts
 function createRowNumberTool(adapter) {
   return {
     name: "sqlite_window_row_number",
@@ -1221,6 +1330,8 @@ function createRowNumberTool(adapter) {
     }
   };
 }
+
+// src/adapters/sqlite-native/tools/window/rank.ts
 function createRankTool(adapter) {
   return {
     name: "sqlite_window_rank",
@@ -1274,6 +1385,8 @@ function createRankTool(adapter) {
     }
   };
 }
+
+// src/adapters/sqlite-native/tools/window/lag-lead.ts
 function createLagLeadTool(adapter) {
   return {
     name: "sqlite_window_lag_lead",
@@ -1349,6 +1462,8 @@ function createLagLeadTool(adapter) {
     }
   };
 }
+
+// src/adapters/sqlite-native/tools/window/running-total.ts
 function createRunningTotalTool(adapter) {
   return {
     name: "sqlite_window_running_total",
@@ -1405,6 +1520,8 @@ function createRunningTotalTool(adapter) {
     }
   };
 }
+
+// src/adapters/sqlite-native/tools/window/moving-average.ts
 function createMovingAverageTool(adapter) {
   return {
     name: "sqlite_window_moving_avg",
@@ -1463,6 +1580,8 @@ function createMovingAverageTool(adapter) {
     }
   };
 }
+
+// src/adapters/sqlite-native/tools/window/ntile.ts
 function createNtileTool(adapter) {
   return {
     name: "sqlite_window_ntile",
@@ -1515,6 +1634,18 @@ function createNtileTool(adapter) {
     }
   };
 }
+
+// src/adapters/sqlite-native/tools/window/index.ts
+function getWindowTools(adapter) {
+  return [
+    createRowNumberTool(adapter),
+    createRankTool(adapter),
+    createLagLeadTool(adapter),
+    createRunningTotalTool(adapter),
+    createMovingAverageTool(adapter),
+    createNtileTool(adapter)
+  ];
+}
 var coerceNumber2 = (val) => {
   if (typeof val === "string") {
     if (val.trim() === "") return void 0;
@@ -1755,34 +1886,44 @@ function createLoadSpatialiteTool(adapter) {
     outputSchema: SpatialiteLoadOutputSchema,
     requiredScopes: ["admin"],
     annotations: admin("SpatiaLite Load"),
-    handler: (_params, _context) => {
+    handler: async (_params, _context) => {
       try {
         const input = LoadSpatialiteSchema.parse(_params);
         if (!input.forceReload && isSpatialiteLoaded(adapter)) {
-          return Promise.resolve({
+          const versionResult = await adapter.executeReadQuery(
+            "SELECT spatialite_version() as v"
+          );
+          const version = versionResult.rows?.[0]?.["v"];
+          return {
             success: true,
             message: "SpatiaLite already loaded",
-            alreadyLoaded: true
-          });
+            alreadyLoaded: true,
+            version
+          };
         }
         const result = tryLoadSpatialite(adapter);
         if (result.success) {
-          return Promise.resolve({
+          const versionResult = await adapter.executeReadQuery(
+            "SELECT spatialite_version() as v"
+          );
+          const version = versionResult.rows?.[0]?.["v"];
+          return {
             success: true,
             message: "SpatiaLite loaded successfully",
-            extensionPath: result.path
-          });
+            extensionPath: result.path,
+            version
+          };
         }
-        return Promise.resolve({
+        return {
           success: false,
           error: result.error,
           code: "SPATIALITE_LOAD_FAILED",
           category: "internal",
           recoverable: false,
           searchedPaths: SPATIALITE_PATHS
-        });
+        };
       } catch (error) {
-        return Promise.resolve(formatHandlerError(error));
+        return formatHandlerError(error);
       }
     }
   };
@@ -2636,16 +2777,18 @@ function savepoint(db, name) {
 }
 function releaseSavepoint(db, name) {
   if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(name)) {
-    throw new Error(
-      "Invalid savepoint name. Must start with a letter/underscore and contain only alphanumeric chars."
+    throw new ValidationError(
+      "Invalid savepoint name. Must start with a letter/underscore and contain only alphanumeric chars.",
+      "INVALID_SAVEPOINT_NAME"
     );
   }
   db.exec(`RELEASE SAVEPOINT "${name}"`);
 }
 function rollbackToSavepoint(db, name) {
   if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(name)) {
-    throw new Error(
-      "Invalid savepoint name. Must start with a letter/underscore and contain only alphanumeric chars."
+    throw new ValidationError(
+      "Invalid savepoint name. Must start with a letter/underscore and contain only alphanumeric chars.",
+      "INVALID_SAVEPOINT_NAME"
     );
   }
   db.exec(`ROLLBACK TO SAVEPOINT "${name}"`);
@@ -2724,7 +2867,7 @@ var NativeSqliteAdapter = class extends DatabaseAdapter {
   /**
    * Connect to a SQLite database using better-sqlite3
    */
-  connect(config) {
+  async connect(config) {
     if (config.type !== "sqlite") {
       throw new ConfigurationError(
         `Invalid database type: expected 'sqlite', got '${config.type}'`,
@@ -2735,13 +2878,33 @@ var NativeSqliteAdapter = class extends DatabaseAdapter {
     this.config = sqliteConfig;
     try {
       const filePath = sqliteConfig.filePath ?? sqliteConfig.connectionString ?? ":memory:";
-      this.db = new Database(filePath, {
-        readonly: false,
-        fileMustExist: false
-      });
-      log.info(`Connected to SQLite database (native): ${filePath}`, {
-        code: "SQLITE_CONNECT"
-      });
+      if (sqliteConfig.options?.encryptionKey) {
+        const DatabaseDriver = (await import('better-sqlite3-multiple-ciphers')).default;
+        this.db = new DatabaseDriver(filePath, {
+          readonly: false,
+          fileMustExist: false
+        });
+        const escapedKey = sqliteConfig.options.encryptionKey.replace(
+          /"/g,
+          '""'
+        );
+        this.db.pragma(`key = "${escapedKey}"`);
+        log.info(
+          `Connected to SQLite database (native encrypted): ${filePath}`,
+          {
+            code: "SQLITE_CONNECT_ENCRYPTED"
+          }
+        );
+      } else {
+        const DatabaseDriver = (await import('better-sqlite3')).default;
+        this.db = new DatabaseDriver(filePath, {
+          readonly: false,
+          fileMustExist: false
+        });
+        log.info(`Connected to SQLite database (native): ${filePath}`, {
+          code: "SQLITE_CONNECT"
+        });
+      }
       this.applyOptions(sqliteConfig.options);
       const db = this.db;
       autoEnableWal(
@@ -2780,7 +2943,6 @@ var NativeSqliteAdapter = class extends DatabaseAdapter {
         }
       );
     }
-    return Promise.resolve();
   }
   /**
    * Apply SQLite PRAGMA options and load extensions
@@ -2870,6 +3032,7 @@ var NativeSqliteAdapter = class extends DatabaseAdapter {
     const result = nativeExecuteWrite(this.ensureDb(), sql, params, log);
     if (isDDL(sql)) {
       this.clearSchemaCache();
+      this.emit("schemaChanged");
     }
     return result;
   }
@@ -2896,6 +3059,7 @@ var NativeSqliteAdapter = class extends DatabaseAdapter {
     this.ensureConnected();
     this.ensureDb().exec(sql);
     this.clearSchemaCache();
+    this.emit("schemaChanged");
     return Promise.resolve();
   }
   /**
@@ -2943,7 +3107,7 @@ var NativeSqliteAdapter = class extends DatabaseAdapter {
       throw new DbMcpError(
         "Invalid table name",
         "SQLITE_INVALID_TABLE",
-        "validation" /* VALIDATION */
+        ErrorCategory.VALIDATION
       );
     }
     const result = await this.executeReadQuery(
@@ -2953,7 +3117,7 @@ var NativeSqliteAdapter = class extends DatabaseAdapter {
       throw new DbMcpError(
         `Table '${tableName}' does not exist`,
         "SQLITE_TABLE_NOT_FOUND",
-        "resource" /* RESOURCE */
+        ErrorCategory.RESOURCE
       );
     }
     return {