db-mcp 1.1.1 → 2.0.0

package/dist/{sqlite-native-5O7FZJGB.js → sqlite-native-JXMCFQBA.js}

@@ -1,41 +1,50 @@
-import { TransactionBeginOutputSchema, TransactionCommitOutputSchema, TransactionRollbackOutputSchema, TransactionSavepointOutputSchema, TransactionReleaseOutputSchema, TransactionRollbackToOutputSchema, TransactionExecuteOutputSchema, WindowRowNumberOutputSchema, validateWhereClause, WindowRankOutputSchema, WindowLagLeadOutputSchema, WindowRunningTotalOutputSchema, resolveAliases, WindowMovingAvgOutputSchema, WindowNtileOutputSchema, autoEnableWal, detectAndSetJsonbSupport, SchemaManager, applyCommonPragmas, isDDL, getResourceDefinitions, getPromptDefinitions, SpatialiteLoadOutputSchema, SpatialiteCreateTableOutputSchema, SpatialiteQueryOutputSchema, SpatialiteAnalyzeOutputSchema, SpatialiteIndexOutputSchema, SpatialiteTransformOutputSchema, SpatialiteImportOutputSchema, normalizeSqliteParams, getCoreTools, getJsonOperationTools, getJsonHelperTools, getTextTools, getStatsTools, getVirtualTools, getVectorTools, getGeoTools, getAdminTools, getIntrospectionTools, getMigrationTools, getCodeModeTools, FtsCreateOutputSchema, sanitizeIdentifier, FtsSearchOutputSchema, validateTableExists, FtsRebuildOutputSchema } from './chunk-TVIZ3XJH.js';
-import { DatabaseAdapter } from './chunk-Z2GFQU3G.js';
-import { write, readOnly, VERSION, admin, getToolGroupIcon, idempotent } from './chunk-FW7UCRLN.js';
-import { formatHandlerError, ValidationError, ConfigurationError, ConnectionError, ResourceNotFoundError, QueryError } from './chunk-4IA3DB5C.js';
-import { logger, ERROR_CODES, DbMcpError } from './chunk-AOUL5SHS.js';
+import { ErrorResponseFields, RowRecordSchema, validateWhereClause, resolveAliases, autoEnableWal, detectAndSetJsonbSupport, SchemaManager, applyCommonPragmas, isDDL, getResourceDefinitions, getPromptDefinitions, normalizeSqliteParams, translateSqliteError, getCoreTools, getJsonOperationTools, getJsonHelperTools, getTextTools, getStatsTools, getVirtualTools, getVectorTools, getGeoTools, getAdminTools, getIntrospectionTools, getMigrationTools, getCodeModeTools, sanitizeIdentifier, validateTableExists, FtsHeadlineSchema } from './chunk-5Y42NPBP.js';
+import { DatabaseAdapter } from './chunk-Z7C2TM4L.js';
+import { write, readOnly, VERSION, admin, getToolGroupIcon, idempotent } from './chunk-VIDSICEL.js';
+import './chunk-OKOVZ5QE.js';
+import { formatHandlerError, ValidationError, ConfigurationError, ConnectionError, ResourceNotFoundError, ExtensionNotAvailableError } from './chunk-X3MUUOWM.js';
+import { logger, ERROR_CODES, DbMcpError } from './chunk-645ZEFLA.js';
 import Database from 'better-sqlite3';
 import { z } from 'zod';
 import path from 'path';
 import fs from 'fs';
 import { fileURLToPath } from 'url';
 
-function buildFts5UnavailableError(tableName) {
-  return {
-    success: false,
-    message: "FTS5 module unavailable",
-    tableName: tableName ?? "",
-    error: "FTS5 module unavailable",
-    hint: "FTS5 requires native SQLite backend (--sqlite-native). WASM mode (sql.js) does not include this module."
-  };
-}
-function isFts5UnavailableError(error) {
-  return error instanceof Error && error.message.toLowerCase().includes("no such module: fts5");
-}
-function isFts5Available(adapter) {
-  return adapter.isNativeBackend();
-}
-function buildFts5SearchUnavailableError() {
-  return {
-    success: false,
-    rowCount: 0,
-    results: [],
-    error: "FTS5 module unavailable",
-    hint: "FTS5 requires native SQLite backend (--sqlite-native). WASM mode (sql.js) does not include this module."
-  };
-}
+var FtsCreateOutputSchema = z.object({
+  success: z.boolean(),
+  message: z.string().optional(),
+  tableName: z.string().optional(),
+  triggersCreated: z.array(z.string()).optional()
+}).extend(ErrorResponseFields.shape);
+var FtsResultSchema = z.object({
+  rank: z.number().nullable().optional(),
+  bm25: z.number().nullable().optional()
+}).loose();
+var FtsSearchOutputSchema = z.object({
+  success: z.boolean(),
+  rowCount: z.number().optional(),
+  results: z.array(FtsResultSchema).optional()
+}).extend(ErrorResponseFields.shape);
+var FtsRebuildOutputSchema = z.object({
+  success: z.boolean(),
+  message: z.string().optional(),
+  tableName: z.string().optional()
+}).extend(ErrorResponseFields.shape);
+var FtsHeadlineOutputSchema = z.object({
+  success: z.boolean(),
+  rowCount: z.number().optional(),
+  results: z.array(
+    z.object({
+      headline: z.string().optional(),
+      snippet: z.string().optional(),
+      rank: z.number().nullable().optional()
+    }).loose()
+  ).optional()
+}).extend(ErrorResponseFields.shape);
 var coerceEnumValues = (allowed) => (val) => typeof val === "string" && allowed.includes(val) ? val : void 0;
 var FtsCreateSchema = z.object({
-  tableName: z.string().describe("Name of the FTS table to create"),
+  tableName: z.string().optional().describe("Name of the FTS table to create"),
+  ftsTable: z.string().optional().describe("Name of the FTS table to create (alias)"),
   sourceTable: z.string().describe("Source table to index"),
   columns: z.array(z.string()).describe("Columns to include in the index"),
   contentTable: z.string().optional().describe("Content table for external content FTS"),
@@ -43,9 +52,7 @@ var FtsCreateSchema = z.object({
     coerceEnumValues(["unicode61", "ascii", "porter"]),
     z.enum(["unicode61", "ascii", "porter"]).optional().default("unicode61")
   ),
-  createTriggers: z.boolean().optional().default(true).describe(
-    "Create INSERT/UPDATE/DELETE triggers for auto-sync (only for external content tables)"
-  )
+  createTriggers: z.boolean().optional().default(true).describe("Create triggers")
 });
 var FtsSearchSchema = z.object({
   table: z.string().describe("FTS table name"),
@@ -68,12 +75,39 @@ var FtsMatchInfoSchema = z.object({
     z.enum(["bm25", "rank"]).optional().default("bm25")
   )
 });
+
+// src/adapters/sqlite/tools/fts.ts
+function buildFts5UnavailableError(tableName) {
+  return {
+    success: false,
+    message: "FTS5 module unavailable",
+    tableName: tableName ?? "",
+    error: "FTS5 module unavailable",
+    hint: "FTS5 requires native SQLite backend (--sqlite-native). WASM mode (sql.js) does not include this module."
+  };
+}
+function isFts5UnavailableError(error) {
+  return error instanceof Error && error.message.toLowerCase().includes("no such module: fts5");
+}
+function isFts5Available(adapter) {
+  return adapter.isNativeBackend();
+}
+function buildFts5SearchUnavailableError() {
+  return {
+    success: false,
+    rowCount: 0,
+    results: [],
+    error: "FTS5 module unavailable",
+    hint: "FTS5 requires native SQLite backend (--sqlite-native). WASM mode (sql.js) does not include this module."
+  };
+}
 function getFtsTools(adapter) {
   return [
     createFtsCreateTool(adapter),
     createFtsSearchTool(adapter),
     createFtsRebuildTool(adapter),
-    createFtsMatchInfoTool(adapter)
+    createFtsMatchInfoTool(adapter),
+    createFtsHeadlineTool(adapter)
   ];
 }
 function createFtsCreateTool(adapter) {
@@ -88,7 +122,13 @@ function createFtsCreateTool(adapter) {
     handler: async (params, _context) => {
       try {
         const input = FtsCreateSchema.parse(params);
-        sanitizeIdentifier(input.tableName);
+        const targetTableName = input.tableName || input.ftsTable;
+        if (!targetTableName) {
+          throw new ValidationError(
+            "Must provide either tableName or ftsTable"
+          );
+        }
+        sanitizeIdentifier(targetTableName);
         sanitizeIdentifier(input.sourceTable);
         for (const col of input.columns) {
           sanitizeIdentifier(col);
@@ -98,31 +138,31 @@ function createFtsCreateTool(adapter) {
         const effectiveContentTable = input.contentTable ?? input.sourceTable;
         sanitizeIdentifier(effectiveContentTable);
         options += `, content="${effectiveContentTable}"`;
-        const sql = `CREATE VIRTUAL TABLE IF NOT EXISTS "${input.tableName}" USING fts5(${columnList}, ${options})`;
+        const sql = `CREATE VIRTUAL TABLE IF NOT EXISTS "${targetTableName}" USING fts5(${columnList}, ${options})`;
         await adapter.executeQuery(sql);
         let triggersCreated = [];
         if (input.createTriggers) {
           triggersCreated = await createSyncTriggers(
             adapter,
-            input.tableName,
+            targetTableName,
             effectiveContentTable,
             input.columns
           );
         }
         await adapter.executeQuery(
-          `INSERT INTO "${input.tableName}"("${input.tableName}") VALUES('rebuild')`
+          `INSERT INTO "${targetTableName}"("${targetTableName}") VALUES('rebuild')`
         );
-        const message = triggersCreated.length ? `FTS5 table '${input.tableName}' created with ${triggersCreated.length} sync triggers` : `FTS5 table '${input.tableName}' created`;
+        const message = triggersCreated.length ? `FTS5 table '${targetTableName}' created with ${triggersCreated.length} sync triggers` : `FTS5 table '${targetTableName}' created`;
         return {
           success: true,
           message,
-          tableName: input.tableName,
+          tableName: targetTableName,
           triggersCreated: triggersCreated.length ? triggersCreated : void 0
         };
       } catch (error) {
         if (isFts5UnavailableError(error)) {
           return buildFts5UnavailableError(
-            params?.tableName
+            params?.tableName || params?.ftsTable
           );
         }
         return formatHandlerError(error);
@@ -292,6 +332,223 @@ function createFtsMatchInfoTool(adapter) {
     }
   };
 }
+function createFtsHeadlineTool(adapter) {
+  return {
+    name: "sqlite_fts_headline",
+    description: "Generate highlighted snippets from FTS5 full-text search results. Returns headline (highlight) and snippet (context window) for each match.",
+    group: "text",
+    inputSchema: FtsHeadlineSchema,
+    outputSchema: FtsHeadlineOutputSchema,
+    requiredScopes: ["read"],
+    annotations: readOnly("FTS Headline"),
+    handler: async (params, _context) => {
+      try {
+        const input = FtsHeadlineSchema.parse(params);
+        if (!isFts5Available(adapter)) {
+          return buildFts5SearchUnavailableError();
+        }
+        sanitizeIdentifier(input.table);
+        await validateTableExists(adapter, input.table);
+        const queryEscaped = input.query.replace(/'/g, "''");
+        let columnIndex = 0;
+        if (input.column) {
+          const colResult = await adapter.executeReadQuery(
+            `PRAGMA table_info("${input.table}")`
+          );
+          const colRows = colResult.rows ?? [];
+          const found = colRows.findIndex(
+            (r) => String(r["name"]) === input.column
+          );
+          if (found >= 0) {
+            columnIndex = 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)})`;
+        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);
+          return {
+            success: true,
+            rowCount: result2.rows?.length ?? 0,
+            results: result2.rows
+          };
+        }
+        const sql = `SELECT ${highlightExpr} as headline, ${snippetExpr} as snippet, rank FROM "${input.table}" WHERE "${input.table}" MATCH '${queryEscaped}' ORDER BY rank LIMIT ${String(input.limit)}`;
+        const result = await adapter.executeReadQuery(sql);
+        return {
+          success: true,
+          rowCount: result.rows?.length ?? 0,
+          results: result.rows
+        };
+      } catch (error) {
+        if (isFts5UnavailableError(error)) {
+          return buildFts5SearchUnavailableError();
+        }
+        return formatHandlerError(error);
+      }
+    }
+  };
+}
+var TransactionBeginOutputSchema = z.object({
+  success: z.boolean(),
+  message: z.string().optional(),
+  mode: z.string().optional()
+}).extend(ErrorResponseFields.shape);
+var TransactionCommitOutputSchema = z.object({
+  success: z.boolean(),
+  message: z.string().optional()
+}).extend(ErrorResponseFields.shape);
+var TransactionRollbackOutputSchema = z.object({
+  success: z.boolean(),
+  message: z.string().optional()
+}).extend(ErrorResponseFields.shape);
+var TransactionSavepointOutputSchema = z.object({
+  success: z.boolean(),
+  message: z.string().optional(),
+  name: z.string().optional(),
+  savepoint: z.string().optional()
+}).extend(ErrorResponseFields.shape);
+var TransactionReleaseOutputSchema = z.object({
+  success: z.boolean(),
+  message: z.string().optional(),
+  name: z.string().optional(),
+  savepoint: z.string().optional()
+}).extend(ErrorResponseFields.shape);
+var TransactionRollbackToOutputSchema = z.object({
+  success: z.boolean(),
+  message: z.string().optional(),
+  name: z.string().optional(),
+  savepoint: z.string().optional()
+}).extend(ErrorResponseFields.shape);
+var TransactionExecuteOutputSchema = z.object({
+  success: z.boolean(),
+  message: z.string().optional(),
+  statementsExecuted: z.number().optional(),
+  results: z.array(z.unknown()).optional()
+}).extend(ErrorResponseFields.shape);
+var TransactionStatusOutputSchema = z.object({
+  success: z.boolean(),
+  status: z.enum(["active", "none"]).optional().describe(
+    'Transaction state: "active" (transaction in progress) or "none" (no active transaction)'
+  ),
+  active: z.boolean().optional().describe("Whether a transaction is currently in progress"),
+  message: z.string().optional()
+}).extend(ErrorResponseFields.shape);
+var RowNumberResultSchema = z.object({
+  row_number: z.number()
+}).loose();
+var WindowRowNumberOutputSchema = z.object({
+  success: z.boolean(),
+  rowCount: z.number().optional(),
+  rows: z.array(RowNumberResultSchema).optional(),
+  hint: z.string().optional()
+}).extend(ErrorResponseFields.shape);
+var RankResultSchema = z.object({
+  rank: z.number().optional(),
+  dense_rank: z.number().optional(),
+  percent_rank: z.number().optional()
+}).loose();
+var WindowRankOutputSchema = z.object({
+  success: z.boolean(),
+  rankType: z.string().optional(),
+  rowCount: z.number().optional(),
+  rows: z.array(RankResultSchema).optional(),
+  hint: z.string().optional()
+}).extend(ErrorResponseFields.shape);
+var LagLeadResultSchema = z.object({
+  lag_value: z.unknown().optional(),
+  lead_value: z.unknown().optional()
+}).loose();
+var WindowLagLeadOutputSchema = z.object({
+  success: z.boolean(),
+  direction: z.string().optional(),
+  offset: z.number().optional(),
+  rowCount: z.number().optional(),
+  rows: z.array(LagLeadResultSchema).optional(),
+  hint: z.string().optional()
+}).extend(ErrorResponseFields.shape);
+var RunningTotalResultSchema = z.object({
+  running_total: z.number()
+}).loose();
+var WindowRunningTotalOutputSchema = z.object({
+  success: z.boolean(),
+  valueColumn: z.string().optional(),
+  rowCount: z.number().optional(),
+  rows: z.array(RunningTotalResultSchema).optional(),
+  hint: z.string().optional()
+}).extend(ErrorResponseFields.shape);
+var MovingAvgResultSchema = z.object({
+  moving_avg: z.number()
+}).loose();
+var WindowMovingAvgOutputSchema = z.object({
+  success: z.boolean(),
+  valueColumn: z.string().optional(),
+  windowSize: z.number().optional(),
+  rowCount: z.number().optional(),
+  rows: z.array(MovingAvgResultSchema).optional(),
+  hint: z.string().optional()
+}).extend(ErrorResponseFields.shape);
+var NtileResultSchema = z.object({
+  ntile: z.number()
+}).loose();
+var WindowNtileOutputSchema = z.object({
+  success: z.boolean(),
+  buckets: z.number().optional(),
+  rowCount: z.number().optional(),
+  rows: z.array(NtileResultSchema).optional(),
+  hint: z.string().optional()
+}).extend(ErrorResponseFields.shape);
+var SpatialiteLoadOutputSchema = z.object({
+  success: z.boolean(),
+  message: z.string().optional(),
+  alreadyLoaded: z.boolean().optional(),
+  extensionPath: z.string().optional(),
+  searchedPaths: z.array(z.string()).optional()
+}).extend(ErrorResponseFields.shape);
+var SpatialiteCreateTableOutputSchema = z.object({
+  success: z.boolean(),
+  message: z.string().optional(),
+  tableName: z.string().optional(),
+  alreadyExists: z.boolean().optional(),
+  geometryColumn: z.string().optional(),
+  geometryType: z.string().optional(),
+  srid: z.number().optional()
+}).extend(ErrorResponseFields.shape);
+var SpatialiteQueryOutputSchema = z.object({
+  success: z.boolean(),
+  rowCount: z.number().optional(),
+  rows: z.array(RowRecordSchema).optional()
+}).extend(ErrorResponseFields.shape);
+var SpatialiteIndexOutputSchema = z.object({
+  success: z.boolean(),
+  message: z.string().optional(),
+  action: z.string().optional(),
+  alreadyExists: z.boolean().optional(),
+  alreadyDropped: z.boolean().optional(),
+  indexed: z.boolean().optional(),
+  valid: z.boolean().nullable().optional()
+}).extend(ErrorResponseFields.shape);
+var SpatialiteAnalyzeOutputSchema = z.object({
+  success: z.boolean(),
+  analysisType: z.string().optional(),
+  rowCount: z.number().optional(),
+  results: z.array(RowRecordSchema).optional()
+}).extend(ErrorResponseFields.shape);
+var SpatialiteTransformOutputSchema = z.object({
+  success: z.boolean(),
+  operation: z.string().optional(),
+  result: z.string().optional()
+}).extend(ErrorResponseFields.shape);
+var SpatialiteImportOutputSchema = z.object({
+  success: z.boolean(),
+  message: z.string().optional(),
+  rowsAffected: z.number().optional()
+}).extend(ErrorResponseFields.shape);
+
+// src/adapters/sqlite-native/tools/transactions.ts
 var VALID_MODES = ["deferred", "immediate", "exclusive"];
 var BeginTransactionSchema = z.object({
   mode: z.preprocess(
@@ -315,6 +572,7 @@ var ExecuteInTransactionSchema = z.object({
 function getTransactionTools(adapter) {
   return [
     createBeginTransactionTool(adapter),
+    createTransactionStatusTool(adapter),
     createCommitTransactionTool(adapter),
     createRollbackTransactionTool(adapter),
     createSavepointTool(adapter),
@@ -327,7 +585,7 @@ function createBeginTransactionTool(adapter) {
   return {
     name: "sqlite_transaction_begin",
     description: "Begin a new transaction. Use immediate or exclusive mode for write-heavy operations.",
-    group: "admin",
+    group: "transactions",
     inputSchema: BeginTransactionSchema,
     outputSchema: TransactionBeginOutputSchema,
     annotations: write("Begin Transaction"),
@@ -348,11 +606,36 @@ function createBeginTransactionTool(adapter) {
     }
   };
 }
+function createTransactionStatusTool(adapter) {
+  return {
+    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({}),
+    outputSchema: TransactionStatusOutputSchema,
+    annotations: readOnly("Transaction Status"),
+    requiredScopes: ["read"],
+    handler: (_params, _context) => {
+      try {
+        const db = adapter.getDatabase();
+        const active = db.inTransaction;
+        return Promise.resolve({
+          success: true,
+          status: active ? "active" : "none",
+          active,
+          message: active ? "A transaction is currently active." : "No transaction is active."
+        });
+      } catch (error) {
+        return Promise.resolve(formatHandlerError(error));
+      }
+    }
+  };
+}
 function createCommitTransactionTool(adapter) {
   return {
     name: "sqlite_transaction_commit",
     description: "Commit the current transaction, making all changes permanent.",
-    group: "admin",
+    group: "transactions",
     inputSchema: z.object({}),
     outputSchema: TransactionCommitOutputSchema,
     annotations: write("Commit Transaction"),
@@ -374,7 +657,7 @@ function createRollbackTransactionTool(adapter) {
   return {
     name: "sqlite_transaction_rollback",
     description: "Rollback the current transaction, discarding all changes.",
-    group: "admin",
+    group: "transactions",
     outputSchema: TransactionRollbackOutputSchema,
     inputSchema: z.object({}),
     annotations: write("Rollback Transaction"),
@@ -396,7 +679,7 @@ function createSavepointTool(adapter) {
   return {
     name: "sqlite_transaction_savepoint",
     description: "Create a savepoint within the current transaction for partial rollback.",
-    group: "admin",
+    group: "transactions",
     outputSchema: TransactionSavepointOutputSchema,
     inputSchema: SavepointSchema,
     annotations: write("Create Savepoint"),
@@ -429,7 +712,7 @@ function createReleaseSavepointTool(adapter) {
   return {
     name: "sqlite_transaction_release",
     description: "Release a savepoint, keeping the changes made since it was created.",
-    group: "admin",
+    group: "transactions",
     inputSchema: SavepointSchema,
     outputSchema: TransactionReleaseOutputSchema,
     annotations: write("Release Savepoint"),
@@ -462,7 +745,7 @@ function createRollbackToSavepointTool(adapter) {
   return {
     name: "sqlite_transaction_rollback_to",
     description: "Rollback to a savepoint, discarding changes made after it was created.",
-    group: "admin",
+    group: "transactions",
     inputSchema: SavepointSchema,
     outputSchema: TransactionRollbackToOutputSchema,
     annotations: write("Rollback to Savepoint"),
@@ -495,7 +778,7 @@ function createExecuteInTransactionTool(adapter) {
   return {
     name: "sqlite_transaction_execute",
     description: "Execute multiple SQL statements in a single transaction. Automatically commits on success or rolls back on error.",
-    group: "admin",
+    group: "transactions",
     outputSchema: TransactionExecuteOutputSchema,
     inputSchema: ExecuteInTransactionSchema,
     annotations: write("Execute in Transaction"),
@@ -504,18 +787,28 @@ function createExecuteInTransactionTool(adapter) {
       let input;
       try {
         input = ExecuteInTransactionSchema.parse(params);
+        if (input.statements.length === 0) {
+          throw new ValidationError("Must provide at least one SQL statement");
+        }
       } catch (error) {
+        const errObj = formatHandlerError(error);
         return {
-          ...formatHandlerError(error),
-          message: "",
+          ...errObj,
+          message: errObj.error || "Transaction execution failed",
           statementsExecuted: 0,
           results: []
         };
       }
       const results = [];
       let success = true;
+      let transactionStarted = false;
+      const db = adapter.getDatabase();
+      const originallyInTransaction = db.inTransaction;
       try {
-        adapter.beginTransaction();
+        if (!originallyInTransaction) {
+          adapter.beginTransaction();
+          transactionStarted = true;
+        }
         for (const statement of input.statements) {
           try {
             const isSelect = statement.trim().toUpperCase().startsWith("SELECT");
@@ -549,25 +842,38 @@ function createExecuteInTransactionTool(adapter) {
             success = false;
           }
         }
-        adapter.commitTransaction();
+        if (transactionStarted) {
+          adapter.commitTransaction();
+        }
         return {
           success,
+          error: success ? void 0 : "Transaction completed with errors",
           message: success ? "Transaction completed successfully" : "Transaction completed with errors",
           statementsExecuted: input.statements.length,
           results
         };
       } catch (error) {
         let rollbackFailure;
-        try {
-          adapter.rollbackTransaction();
-        } catch (rbError) {
-          rollbackFailure = rbError instanceof Error ? rbError.message : String(rbError);
+        if (transactionStarted) {
+          try {
+            adapter.rollbackTransaction();
+          } catch (rbError) {
+            rollbackFailure = rbError instanceof Error ? rbError.message : String(rbError);
+          }
+        } else if (originallyInTransaction && input.rollbackOnError) {
+          try {
+            adapter.rollbackTransaction();
+          } catch (rbError) {
+            rollbackFailure = rbError instanceof Error ? rbError.message : String(rbError);
+          }
         }
         const message = error instanceof Error ? error.message : String(error);
         const formatted = formatHandlerError(error);
         let rollbackMessage = `Transaction rolled back: ${message}`;
         if (rollbackFailure) {
           rollbackMessage += ` (rollback error: ${rollbackFailure})`;
+        } else if (!transactionStarted && !originallyInTransaction) {
+          rollbackMessage = `Transaction failed to start: ${message}`;
         }
         return {
           ...formatted,
@@ -580,7 +886,13 @@ function createExecuteInTransactionTool(adapter) {
     }
   };
 }
-var coerceNumber = (val) => typeof val === "string" ? isNaN(Number(val)) ? void 0 : Number(val) : val;
+var coerceNumber = (val) => {
+  if (typeof val === "string") {
+    const num = Number(val);
+    return isNaN(num) ? void 0 : num;
+  }
+  return val;
+};
 var coerceEnumValues2 = (allowed) => (val) => typeof val === "string" && allowed.includes(val) ? val : void 0;
 var VALID_DIRECTIONS = ["lag", "lead"];
 var RowNumberSchema = z.object({
@@ -591,7 +903,7 @@ var RowNumberSchema = z.object({
   whereClause: z.string().optional().describe("Optional WHERE clause"),
   limit: z.preprocess(
     coerceNumber,
-    z.number().optional().default(100).describe("Maximum rows to return")
+    z.number().optional().default(20).describe("Maximum rows to return")
   )
 });
 var RankSchema = z.object({
@@ -606,7 +918,7 @@ var RankSchema = z.object({
   whereClause: z.string().optional().describe("Optional WHERE clause"),
   limit: z.preprocess(
     coerceNumber,
-    z.number().optional().default(100).describe("Maximum rows to return")
+    z.number().optional().default(20).describe("Maximum rows to return")
   )
 });
 var LagLeadSchema = z.object({
@@ -624,7 +936,7 @@ var LagLeadSchema = z.object({
   whereClause: z.string().optional().describe("Optional WHERE clause"),
   limit: z.preprocess(
     coerceNumber,
-    z.number().optional().default(100).describe("Maximum rows to return")
+    z.number().optional().default(20).describe("Maximum rows to return")
   )
 });
 var RunningTotalSchema = z.object({
@@ -636,7 +948,7 @@ var RunningTotalSchema = z.object({
   whereClause: z.string().optional().describe("Optional WHERE clause"),
   limit: z.preprocess(
     coerceNumber,
-    z.number().optional().default(100).describe("Maximum rows to return")
+    z.number().optional().default(20).describe("Maximum rows to return")
   )
 });
 var MovingAverageSchema = z.object({
@@ -652,7 +964,7 @@ var MovingAverageSchema = z.object({
   whereClause: z.string().optional().describe("Optional WHERE clause"),
   limit: z.preprocess(
     coerceNumber,
-    z.number().optional().default(100).describe("Maximum rows to return")
+    z.number().optional().default(20).describe("Maximum rows to return")
   )
 });
 var NtileSchema = z.object({
@@ -667,7 +979,7 @@ var NtileSchema = z.object({
   whereClause: z.string().optional().describe("Optional WHERE clause"),
   limit: z.preprocess(
     coerceNumber,
-    z.number().optional().default(100).describe("Maximum rows to return")
+    z.number().optional().default(20).describe("Maximum rows to return")
   )
 });
 async function validateTableExists2(adapter, table) {
@@ -728,11 +1040,68 @@ async function validateOrderByColumns(adapter, table, orderBy) {
     await validateColumnInTable(adapter, table, colName);
   }
 }
-function formatColumns(selectColumns) {
-  if (selectColumns === void 0 || selectColumns.length === 0) {
-    return "*";
+async function resolveSelectColumns(adapter, table, selectColumns, rankCol) {
+  if (selectColumns && selectColumns.length > 0) {
+    return {
+      columnList: selectColumns.map((c) => `"${c}"`).join(", ")
+    };
+  }
+  const tableInfo = await adapter.executeReadQuery(
+    `PRAGMA table_info("${table}")`
+  );
+  const TEXT_TYPES = /* @__PURE__ */ new Set([
+    "text",
+    "blob",
+    "clob",
+    "varchar",
+    "nvarchar",
+    "char"
+  ]);
+  const LONG_CONTENT_PATTERNS = [
+    "description",
+    "body",
+    "bio",
+    "content",
+    "notes",
+    "summary",
+    "comment",
+    "details",
+    "html",
+    "markdown",
+    "text",
+    "message",
+    "payload",
+    "raw",
+    "data",
+    "log",
+    "blob"
+  ];
+  const excluded = [];
+  const included = [];
+  for (const c of tableInfo.rows ?? []) {
+    const colName = c["name"];
+    const colType = (c["type"] ?? "").toLowerCase();
+    const nameLower = colName.toLowerCase();
+    const isText = [...TEXT_TYPES].some(
+      (t) => colType === t || colType.startsWith(t)
+    );
+    const isRankCol = rankCol ? nameLower === rankCol.toLowerCase() : false;
+    const isLongContent = LONG_CONTENT_PATTERNS.some(
+      (p) => nameLower === p || nameLower.endsWith(`_${p}`) || nameLower.startsWith(`${p}_`)
+    );
+    if (isText && !isRankCol && isLongContent) {
+      excluded.push(colName);
+    } else {
+      included.push(colName);
+    }
+  }
+  if (excluded.length > 0 && included.length > 0) {
+    return {
+      columnList: included.map((c) => `"${c}"`).join(", "),
+      hint: `Excluded ${excluded.length} long-content column(s) (${excluded.join(", ")}) to reduce payload. Use selectColumns to override.`
+    };
   }
-  return selectColumns.map((c) => `"${c}"`).join(", ");
+  return { columnList: "*" };
 }
 function getWindowTools(adapter) {
   return [
@@ -758,7 +1127,11 @@ function createRowNumberTool(adapter) {
         const input = RowNumberSchema.parse(params);
         await validateTableExists2(adapter, input.table);
         await validateOrderByColumns(adapter, input.table, input.orderBy);
-        const columns = formatColumns(input.selectColumns);
+        const { columnList: columns, hint } = await resolveSelectColumns(
+          adapter,
+          input.table,
+          input.selectColumns
+        );
         const partition = input.partitionBy ? `PARTITION BY ${input.partitionBy}` : "";
         let sql = `
                 SELECT ${columns},
@@ -771,11 +1144,13 @@ function createRowNumberTool(adapter) {
         }
         sql += ` LIMIT ${input.limit}`;
         const result = await adapter.executeReadQuery(sql);
-        return {
+        const response = {
           success: true,
           rowCount: result.rows?.length ?? 0,
           rows: result.rows
         };
+        if (hint) response["hint"] = hint;
+        return response;
       } catch (error) {
         return formatHandlerError(error);
       }
@@ -796,7 +1171,11 @@ function createRankTool(adapter) {
         const input = RankSchema.parse(params);
         await validateTableExists2(adapter, input.table);
         await validateOrderByColumns(adapter, input.table, input.orderBy);
-        const columns = formatColumns(input.selectColumns);
+        const { columnList: columns, hint } = await resolveSelectColumns(
+          adapter,
+          input.table,
+          input.selectColumns
+        );
         const partition = input.partitionBy ? `PARTITION BY ${input.partitionBy}` : "";
         const rankFunc = input.rankType.toUpperCase();
         let sql = `
@@ -810,12 +1189,14 @@ function createRankTool(adapter) {
         }
         sql += ` LIMIT ${input.limit}`;
         const result = await adapter.executeReadQuery(sql);
-        return {
+        const response = {
           success: true,
           rankType: input.rankType,
           rowCount: result.rows?.length ?? 0,
           rows: result.rows
         };
+        if (hint) response["hint"] = hint;
+        return response;
       } catch (error) {
         return formatHandlerError(error);
       }
@@ -849,7 +1230,12 @@ function createLagLeadTool(adapter) {
         await validateTableExists2(adapter, input.table);
         await validateColumnInTable(adapter, input.table, input.column);
         await validateOrderByColumns(adapter, input.table, input.orderBy);
-        const columns = formatColumns(input.selectColumns);
+        const { columnList: columns, hint } = await resolveSelectColumns(
+          adapter,
+          input.table,
+          input.selectColumns,
+          input.column
+        );
         const partition = input.partitionBy ? `PARTITION BY ${input.partitionBy}` : "";
         const func = normalizedDirection.toUpperCase();
         const defaultVal = input.defaultValue !== void 0 ? `, ${input.defaultValue}` : "";
@@ -864,13 +1250,15 @@ function createLagLeadTool(adapter) {
         }
         sql += ` LIMIT ${input.limit}`;
         const result = await adapter.executeReadQuery(sql);
-        return {
+        const response = {
           success: true,
           direction: normalizedDirection,
           offset: input.offset,
           rowCount: result.rows?.length ?? 0,
           rows: result.rows
         };
+        if (hint) response["hint"] = hint;
+        return response;
       } catch (error) {
         return formatHandlerError(error);
       }
@@ -894,7 +1282,12 @@ function createRunningTotalTool(adapter) {
         await validateTableExists2(adapter, input.table);
         await validateColumnInTable(adapter, input.table, input.column);
         await validateOrderByColumns(adapter, input.table, input.orderBy);
-        const columns = formatColumns(input.selectColumns);
+        const { columnList: columns, hint } = await resolveSelectColumns(
+          adapter,
+          input.table,
+          input.selectColumns,
+          input.column
+        );
         const partition = input.partitionBy ? `PARTITION BY ${input.partitionBy}` : "";
         let sql = `
                 SELECT ${columns},
@@ -907,12 +1300,14 @@ function createRunningTotalTool(adapter) {
         }
         sql += ` LIMIT ${input.limit}`;
         const result = await adapter.executeReadQuery(sql);
-        return {
+        const response = {
           success: true,
           valueColumn: input.column,
           rowCount: result.rows?.length ?? 0,
           rows: result.rows
         };
+        if (hint) response["hint"] = hint;
+        return response;
       } catch (error) {
         return formatHandlerError(error);
       }
@@ -945,7 +1340,12 @@ function createMovingAverageTool(adapter) {
         await validateTableExists2(adapter, input.table);
         await validateColumnInTable(adapter, input.table, input.column);
         await validateOrderByColumns(adapter, input.table, input.orderBy);
-        const columns = formatColumns(input.selectColumns);
+        const { columnList: columns, hint } = await resolveSelectColumns(
+          adapter,
+          input.table,
+          input.selectColumns,
+          input.column
+        );
         const partition = input.partitionBy ? `PARTITION BY ${input.partitionBy}` : "";
         const preceding = input.windowSize - 1;
         let sql = `
@@ -959,13 +1359,15 @@ function createMovingAverageTool(adapter) {
         }
         sql += ` LIMIT ${input.limit}`;
         const result = await adapter.executeReadQuery(sql);
-        return {
+        const response = {
           success: true,
           valueColumn: input.column,
           windowSize: input.windowSize,
           rowCount: result.rows?.length ?? 0,
           rows: result.rows
         };
+        if (hint) response["hint"] = hint;
+        return response;
       } catch (error) {
         return formatHandlerError(error);
       }
@@ -995,7 +1397,11 @@ function createNtileTool(adapter) {
         }
         await validateTableExists2(adapter, input.table);
         await validateOrderByColumns(adapter, input.table, input.orderBy);
-        const columns = formatColumns(input.selectColumns);
+        const { columnList: columns, hint } = await resolveSelectColumns(
+          adapter,
+          input.table,
+          input.selectColumns
+        );
         const partition = input.partitionBy ? `PARTITION BY ${input.partitionBy}` : "";
         let sql = `
                 SELECT ${columns},
@@ -1008,12 +1414,14 @@ function createNtileTool(adapter) {
         }
         sql += ` LIMIT ${input.limit}`;
         const result = await adapter.executeReadQuery(sql);
-        return {
+        const response = {
           success: true,
           buckets: input.buckets,
           rowCount: result.rows?.length ?? 0,
           rows: result.rows
         };
+        if (hint) response["hint"] = hint;
+        return response;
       } catch (error) {
         return formatHandlerError(error);
       }
@@ -1211,11 +1619,9 @@ function ensureSpatialite(adapter) {
   if (!isSpatialiteLoaded(adapter)) {
     const result = tryLoadSpatialite(adapter);
     if (!result.success) {
-      throw new DbMcpError(
-        result.error ?? "Failed to load SpatiaLite",
-        "SPATIALITE_LOAD_FAILED",
-        "connection" /* CONNECTION */
-      );
+      throw new ExtensionNotAvailableError("SpatiaLite", {
+        suggestion: "Install mod_spatialite and set SPATIALITE_PATH environment variable."
+      });
     }
   }
 }
@@ -1422,9 +1828,10 @@ function createSpatialIndexTool(adapter) {
         }
         const indexExists = async () => {
           const idxCheck = await adapter.executeReadQuery(
-            `SELECT name FROM sqlite_master WHERE type='table' AND name='idx_${input.tableName}_${input.geometryColumn}'`
+            `SELECT spatial_index_enabled FROM geometry_columns WHERE f_table_name = '${input.tableName}' AND f_geometry_column = '${input.geometryColumn}'`
           );
-          return (idxCheck.rows?.length ?? 0) > 0;
+          const val = idxCheck.rows?.[0]?.["spatial_index_enabled"];
+          return val === 1 || val === "1";
         };
         switch (input.action) {
           case "create": {
@@ -1436,9 +1843,18 @@ function createSpatialIndexTool(adapter) {
                 action: "create"
               };
             }
-            await adapter.executeReadQuery(
-              `SELECT CreateSpatialIndex('${input.tableName}', '${input.geometryColumn}')`
+            const createRes = await adapter.executeReadQuery(
+              `SELECT CreateSpatialIndex('${input.tableName}', '${input.geometryColumn}') as res`
             );
+            if (createRes.rows?.[0]?.["res"] === 0) {
+              return {
+                success: false,
+                error: `Failed to create spatial index on ${input.tableName}.${input.geometryColumn}`,
+                code: "SPATIAL_INDEX_CREATE_FAILED",
+                category: "internal",
+                recoverable: false
+              };
+            }
             return {
               success: true,
               message: `Spatial index created on ${input.tableName}.${input.geometryColumn}`,
@@ -1454,9 +1870,18 @@ function createSpatialIndexTool(adapter) {
                 action: "drop"
               };
             }
-            await adapter.executeReadQuery(
-              `SELECT DisableSpatialIndex('${input.tableName}', '${input.geometryColumn}')`
+            const dropRes = await adapter.executeReadQuery(
+              `SELECT DisableSpatialIndex('${input.tableName}', '${input.geometryColumn}') as res`
             );
+            if (dropRes.rows?.[0]?.["res"] === 0) {
+              return {
+                success: false,
+                error: `Failed to drop spatial index on ${input.tableName}.${input.geometryColumn}`,
+                code: "SPATIAL_INDEX_DROP_FAILED",
+                category: "internal",
+                recoverable: false
+              };
+            }
             return {
               success: true,
               message: `Spatial index dropped from ${input.tableName}.${input.geometryColumn}`,
@@ -1786,6 +2211,19 @@ function createSpatialImportTool(adapter) {
         if (input.format === "geojson") {
           try {
             JSON.parse(input.data);
+            const geojsonCheck = await adapter.executeReadQuery(
+              `SELECT GeomFromGeoJSON('${input.data}') as geom`
+            );
+            const parsedGeom2 = geojsonCheck.rows?.[0]?.["geom"];
+            if (parsedGeom2 === null || parsedGeom2 === void 0) {
+              return {
+                success: false,
+                error: `Invalid GeoJSON geometry: could not be parsed by SpatiaLite (must be a valid Geometry object)`,
+                code: "VALIDATION_ERROR",
+                category: "validation",
+                recoverable: false
+              };
+            }
             const columns2 = ["geom"];
             const values2 = [
               `SetSRID(GeomFromGeoJSON('${input.data}'), ${input.srid})`
@@ -2043,18 +2481,7 @@ function nativeExecuteRead(db, sql, params, log2) {
       executionTimeMs: Date.now() - start
     });
   } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    log2.error(`Query failed: ${message}`, {
-      code: ERROR_CODES.DB.QUERY_FAILED.full
-    });
-    throw new QueryError(
-      `Query execution failed: ${message}`,
-      "DB_QUERY_FAILED",
-      {
-        sql,
-        cause: error instanceof Error ? error : void 0
-      }
-    );
+    translateSqliteError(error, sql, "Query execution", log2);
   }
 }
 function nativeExecuteWrite(db, sql, params, log2) {
@@ -2062,21 +2489,27 @@ function nativeExecuteWrite(db, sql, params, log2) {
   try {
     const stmt = db.prepare(sql);
     const normalizedParams = normalizeSqliteParams(params);
+    if (stmt.reader) {
+      const rows = normalizedParams ? stmt.all(...normalizedParams) : stmt.all();
+      return Promise.resolve({
+        rows,
+        rowsAffected: rows.length,
+        // .all() does not return changes, but we know it's rows.length for RETURNING
+        executionTimeMs: Date.now() - start
+      });
+    }
     const info = normalizedParams ? stmt.run(...normalizedParams) : stmt.run();
-    return Promise.resolve({
+    const result = {
       rows: [],
       rowsAffected: info.changes,
       executionTimeMs: Date.now() - start
-    });
+    };
+    if (info.lastInsertRowid !== void 0) {
+      result.lastInsertId = Number(info.lastInsertRowid);
+    }
+    return Promise.resolve(result);
   } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    log2.error(`Write query failed: ${message}`, {
-      code: ERROR_CODES.DB.QUERY_FAILED.full
-    });
-    throw new QueryError(`Write query failed: ${message}`, "DB_WRITE_FAILED", {
-      sql,
-      cause: error instanceof Error ? error : void 0
-    });
+    translateSqliteError(error, sql, "Write query", log2);
   }
 }
 
@@ -2099,7 +2532,8 @@ var NativeSqliteAdapter = class extends DatabaseAdapter {
    */
   getConfiguredPath() {
     const config = this.config;
-    return config?.filePath ?? config?.connectionString ?? ":memory:";
+    const path2 = config?.filePath ?? config?.connectionString ?? ":memory:";
+    return path2;
   }
   db = null;
   schemaManager = null;
@@ -2137,6 +2571,17 @@ var NativeSqliteAdapter = class extends DatabaseAdapter {
         const versionResult = db.prepare("SELECT sqlite_version()").get();
         return versionResult?.["sqlite_version()"] ?? "0.0.0";
       }, log);
+      if (sqliteConfig.initializationSql && Array.isArray(sqliteConfig.initializationSql)) {
+        for (const sql of sqliteConfig.initializationSql) {
+          db.exec(sql);
+        }
+        log.info(
+          `Executed ${sqliteConfig.initializationSql.length} initialization SQL statements`,
+          {
+            code: "SQLITE_INIT_SQL"
+          }
+        );
+      }
       this.schemaManager = new SchemaManager(this);
       this.connected = true;
     } catch (error) {
@@ -2328,6 +2773,23 @@ var NativeSqliteAdapter = class extends DatabaseAdapter {
   listSchemas() {
     return Promise.resolve(["main"]);
   }
+  /**
+   * Get indexes, optionally for a specific table (cached via SchemaManager)
+   */
+  async getIndexes(table) {
+    this.ensureConnected();
+    if (this.schemaManager) {
+      if (table) {
+        return this.schemaManager.getTableIndexes(table);
+      }
+      return this.schemaManager.getAllIndexes();
+    }
+    const all = await this.getAllIndexes();
+    if (table) {
+      return all.filter((i) => i.tableName === table);
+    }
+    return all;
+  }
   /**
    * Get all indexes in the database (cached via SchemaManager)
    * Required by sqlite_indexes resource