@deepagents/text2sql 3.0.1 → 4.0.0

package/dist/index.js

@@ -1,5 +1,7 @@
 // packages/text2sql/src/lib/adapter-name.ts
 var ADAPTER_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
+var DATABASE_NAME_FRAGMENT = "database";
+var RESERVED_ADAPTER_NAMES = /* @__PURE__ */ new Set([DATABASE_NAME_FRAGMENT]);
 function isValidAdapterName(name) {
   return name != null && ADAPTER_NAME_PATTERN.test(name);
 }
@@ -10,6 +12,9 @@ function validateAdapterNames(names) {
         `Invalid adapter name "${name}": must match ${ADAPTER_NAME_PATTERN}`
       );
     }
+    if (RESERVED_ADAPTER_NAMES.has(name)) {
+      throw new Error(`Adapter name "${name}" is reserved`);
+    }
   }
 }
 
@@ -1365,6 +1370,51 @@ var FileIndexCache = class {
   }
 };
 
+// packages/text2sql/src/lib/index-lock.ts
+import { createHash as createHash2 } from "node:crypto";
+import { mkdir as mkdir2 } from "node:fs/promises";
+import { tmpdir as tmpdir2 } from "node:os";
+import * as path2 from "node:path";
+import { lock as acquireLock } from "proper-lockfile";
+var DEFAULT_STALE_MS = 3e4;
+var DEFAULT_RETRIES = {
+  retries: 10,
+  factor: 2,
+  minTimeout: 100,
+  maxTimeout: 2e3
+};
+var FileIndexLock = class {
+  #dir;
+  #namespace;
+  #stale;
+  #retries;
+  constructor(options = {}) {
+    this.#dir = options.dir ?? tmpdir2();
+    this.#namespace = options.namespace;
+    this.#stale = options.stale ?? DEFAULT_STALE_MS;
+    this.#retries = options.retries ?? DEFAULT_RETRIES;
+  }
+  async run(key, fn) {
+    await mkdir2(this.#dir, { recursive: true });
+    const release = await acquireLock(this.#lockPathFor(key), {
+      realpath: false,
+      stale: this.#stale,
+      retries: this.#retries
+    });
+    try {
+      return await fn();
+    } finally {
+      await release().catch(() => {
+      });
+    }
+  }
+  #lockPathFor(key) {
+    const watermark = this.#namespace ? `${this.#namespace}-${key}` : key;
+    const hash2 = createHash2("md5").update(watermark).digest("hex");
+    return path2.join(this.#dir, `text2sql-lock-${hash2}`);
+  }
+};
+
 // packages/text2sql/src/lib/adapter-index.ts
 var TEXT2SQL_INDEX_PROGRESS_CHUNK = "data-text2sql-index-progress";
 var noopProgressHandler = () => {
@@ -1378,6 +1428,9 @@ function timestampProgressHandler(onProgress) {
     });
   };
 }
+function databaseNameFragment(name) {
+  return { name: DATABASE_NAME_FRAGMENT, data: name };
+}
 var AdapterIndexer = class {
   #adapters;
   #cache;
@@ -1404,7 +1457,7 @@ var AdapterIndexer = class {
     const settled = await Promise.allSettled(
       entries.map(async ([name, adapter]) => {
         const schema = await this.#indexAdapter(name, adapter, progress);
-        return fragment2(name, ...schema);
+        return fragment2(name, databaseNameFragment(name), ...schema);
       })
     );
     const failed = settled.find((result) => result.status === "rejected");
@@ -1491,7 +1544,7 @@ var AdapterIndexer = class {
         });
         return cached;
       }
-      const fragments = this.#lock ? await this.#lock.run(key, populate) : await populate();
+      const fragments = await this.#lock.run(key, populate);
       if (servedFromCache) emitCacheHit();
       progress({
         type: "adapter:end",
@@ -1543,16 +1596,16 @@ function errorMessage(error) {
 }
 
 // packages/text2sql/src/lib/checkpoint.ts
-import { createHash as createHash2 } from "node:crypto";
+import { createHash as createHash3 } from "node:crypto";
 import { existsSync as existsSync2, readFileSync, renameSync, writeFileSync } from "node:fs";
 import pLimit from "p-limit";
 var Checkpoint = class _Checkpoint {
   points;
   path;
   configHash;
-  constructor(path6, configHash, points) {
+  constructor(path7, configHash, points) {
     this.points = points;
-    this.path = path6;
+    this.path = path7;
     this.configHash = configHash;
   }
   /**
@@ -1560,14 +1613,14 @@ var Checkpoint = class _Checkpoint {
    * Handles corrupted files and config changes gracefully.
    */
   static async load(options) {
-    const { path: path6, configHash } = options;
-    if (existsSync2(path6)) {
+    const { path: path7, configHash } = options;
+    if (existsSync2(path7)) {
       try {
-        const content = readFileSync(path6, "utf-8");
+        const content = readFileSync(path7, "utf-8");
         const file = JSON.parse(content);
         if (configHash && file.configHash && file.configHash !== configHash) {
           console.log("\u26A0 Config changed, starting fresh");
-          return new _Checkpoint(path6, configHash, {});
+          return new _Checkpoint(path7, configHash, {});
         }
         const points = file.points ?? {};
         const totalEntries = Object.values(points).reduce(
@@ -1575,14 +1628,14 @@ var Checkpoint = class _Checkpoint {
           0
         );
         console.log(`\u2713 Resuming from checkpoint (${totalEntries} entries)`);
-        return new _Checkpoint(path6, configHash, points);
+        return new _Checkpoint(path7, configHash, points);
       } catch {
         console.log("\u26A0 Checkpoint corrupted, starting fresh");
-        return new _Checkpoint(path6, configHash, {});
+        return new _Checkpoint(path7, configHash, {});
       }
     }
     console.log("Starting new checkpoint");
-    return new _Checkpoint(path6, configHash, {});
+    return new _Checkpoint(path7, configHash, {});
   }
   /**
    * Run a single computation with checkpointing.
@@ -1664,7 +1717,7 @@ var Checkpoint = class _Checkpoint {
   }
 };
 function hash(value) {
-  return createHash2("md5").update(JSON.stringify(value)).digest("hex");
+  return createHash3("md5").update(JSON.stringify(value)).digest("hex");
 }
 var Point = class {
   #cache;
@@ -1708,11 +1761,11 @@ var Point = class {
   }
 };
 function hashConfig(config) {
-  return createHash2("md5").update(JSON.stringify(config)).digest("hex");
+  return createHash3("md5").update(JSON.stringify(config)).digest("hex");
 }
 
 // packages/text2sql/src/lib/fs/sqlite/sqlite-fs.ts
-import * as path2 from "node:path";
+import * as path3 from "node:path";
 import { DatabaseSync } from "node:sqlite";
 
 // packages/text2sql/src/lib/fs/sqlite/ddl.sqlite-fs.sql
@@ -1760,7 +1813,7 @@ var SqliteFs = class {
     const segments = p.split("/").filter(Boolean);
     let currentPath = "/";
     for (let i = 0; i < segments.length - 1; i++) {
-      currentPath = path2.posix.join(currentPath, segments[i]);
+      currentPath = path3.posix.join(currentPath, segments[i]);
       const exists = this.#stmt("SELECT 1 FROM fs_entries WHERE path = ?").get(
         currentPath
       );
@@ -1781,7 +1834,7 @@ var SqliteFs = class {
     return stmt;
   }
   #normalizeRoot(root) {
-    return path2.posix.resolve("/", root.trim());
+    return path3.posix.resolve("/", root.trim());
   }
   #prefixPath(p) {
     if (!this.#root) {
@@ -1790,7 +1843,7 @@ var SqliteFs = class {
     if (p === "/") {
       return this.#root;
     }
-    return path2.posix.join(this.#root, p);
+    return path3.posix.join(this.#root, p);
   }
   #unprefixPath(p) {
     if (!this.#root) {
@@ -1816,10 +1869,10 @@ var SqliteFs = class {
     }
   }
   #normalizePath(p) {
-    return path2.posix.resolve("/", p);
+    return path3.posix.resolve("/", p);
   }
   #dirname(p) {
-    const dir = path2.posix.dirname(p);
+    const dir = path3.posix.dirname(p);
     return dir === "" ? "/" : dir;
   }
   #ensureParentExists(filePath) {
@@ -1882,7 +1935,7 @@ var SqliteFs = class {
     }
     seen.add(p);
     const target = this.#normalizePath(
-      path2.posix.resolve(this.#dirname(p), entry.symlinkTarget)
+      path3.posix.resolve(this.#dirname(p), entry.symlinkTarget)
     );
     return this.#resolveSymlink(target, seen);
   }
@@ -2034,11 +2087,11 @@ var SqliteFs = class {
     this.#useTransaction(() => {
       if (options?.recursive) {
         const rootPath = this.#root || "/";
-        const relativePath = path2.posix.relative(rootPath, prefixed);
+        const relativePath = path3.posix.relative(rootPath, prefixed);
         const segments = relativePath.split("/").filter(Boolean);
         let currentPath = rootPath;
         for (const segment of segments) {
-          currentPath = path2.posix.join(currentPath, segment);
+          currentPath = path3.posix.join(currentPath, segment);
           const exists = this.#stmt(
             "SELECT type FROM fs_entries WHERE path = ?"
           ).get(currentPath);
@@ -2089,7 +2142,7 @@ var SqliteFs = class {
          AND path != ?
          AND path NOT LIKE ? || '%/%'`
     ).all(prefix, resolved, prefix);
-    return rows.map((row) => path2.posix.basename(row.path));
+    return rows.map((row) => path3.posix.basename(row.path));
   }
   async readdirWithFileTypes(dirPath) {
     const normalized = this.#normalizePath(dirPath);
@@ -2112,7 +2165,7 @@ var SqliteFs = class {
          AND path NOT LIKE ? || '%/%'`
     ).all(prefix, resolved, prefix);
     return rows.map((row) => ({
-      name: path2.posix.basename(row.path),
+      name: path3.posix.basename(row.path),
       isFile: row.type === "file",
       isDirectory: row.type === "directory",
       isSymbolicLink: row.type === "symlink"
@@ -2167,8 +2220,8 @@ var SqliteFs = class {
           `SELECT * FROM fs_entries WHERE path = ? OR path LIKE ? || '/%'`
         ).all(srcPrefixed, srcPrefixed);
         for (const entry of allEntries) {
-          const relativePath = path2.posix.relative(srcPrefixed, entry.path);
-          const newPath = path2.posix.join(destPrefixed, relativePath);
+          const relativePath = path3.posix.relative(srcPrefixed, entry.path);
+          const newPath = path3.posix.join(destPrefixed, relativePath);
           this.#stmt(
             `INSERT OR REPLACE INTO fs_entries (path, type, mode, size, mtime, symlinkTarget)
              VALUES (?, ?, ?, ?, ?, ?)`
@@ -2235,8 +2288,8 @@ var SqliteFs = class {
           `SELECT * FROM fs_entries WHERE path = ? OR path LIKE ? || '/%' ORDER BY path DESC`
         ).all(srcPrefixed, srcPrefixed);
         for (const entry of [...allEntries].reverse()) {
-          const relativePath = path2.posix.relative(srcPrefixed, entry.path);
-          const newPath = path2.posix.join(destPrefixed, relativePath);
+          const relativePath = path3.posix.relative(srcPrefixed, entry.path);
+          const newPath = path3.posix.join(destPrefixed, relativePath);
           this.#stmt(
             `INSERT INTO fs_entries (path, type, mode, size, mtime, symlinkTarget)
              VALUES (?, ?, ?, ?, ?, ?)`
@@ -2289,7 +2342,7 @@ var SqliteFs = class {
     });
   }
   resolvePath(base, relativePath) {
-    return path2.posix.resolve(base, relativePath);
+    return path3.posix.resolve(base, relativePath);
   }
   getAllPaths() {
     const rows = this.#stmt(
@@ -2401,7 +2454,7 @@ var SqliteFs = class {
 
 // packages/text2sql/src/lib/fs/mssql/mssql-fs.ts
 import { createRequire } from "node:module";
-import * as path3 from "node:path";
+import * as path4 from "node:path";
 
 // packages/text2sql/src/lib/fs/mssql/ddl.mssql-fs.ts
 function mssqlFsDDL(schema) {
@@ -2527,7 +2580,7 @@ var MssqlFs = class _MssqlFs {
     const segments = p.split("/").filter(Boolean);
     let currentPath = "/";
     for (let i = 0; i < segments.length - 1; i++) {
-      currentPath = path3.posix.join(currentPath, segments[i]);
+      currentPath = path4.posix.join(currentPath, segments[i]);
       const exists = await this.#rawQuery(
         `SELECT CASE WHEN EXISTS(SELECT 1 FROM ${this.#t("fs_entries")} WHERE path = @p0) THEN 1 ELSE 0 END as [exists]`,
         [currentPath]
@@ -2579,7 +2632,7 @@ var MssqlFs = class _MssqlFs {
     }
   }
   #normalizeRoot(root) {
-    return path3.posix.resolve("/", root.trim());
+    return path4.posix.resolve("/", root.trim());
   }
   #prefixPath(p) {
     if (!this.#root) {
@@ -2588,7 +2641,7 @@ var MssqlFs = class _MssqlFs {
     if (p === "/") {
       return this.#root;
     }
-    return path3.posix.join(this.#root, p);
+    return path4.posix.join(this.#root, p);
   }
   #unprefixPath(p) {
     if (!this.#root) {
@@ -2603,10 +2656,10 @@ var MssqlFs = class _MssqlFs {
     return p;
   }
   #normalizePath(p) {
-    return path3.posix.resolve("/", p);
+    return path4.posix.resolve("/", p);
   }
   #dirname(p) {
-    const dir = path3.posix.dirname(p);
+    const dir = path4.posix.dirname(p);
     return dir === "" ? "/" : dir;
   }
   async #ensureParentExists(filePath, transaction) {
@@ -2695,7 +2748,7 @@ var MssqlFs = class _MssqlFs {
     }
     seen.add(p);
     const target = this.#normalizePath(
-      path3.posix.resolve(this.#dirname(p), entry.symlinkTarget)
+      path4.posix.resolve(this.#dirname(p), entry.symlinkTarget)
     );
     return this.#resolveSymlink(target, seen);
   }
@@ -2878,11 +2931,11 @@ var MssqlFs = class _MssqlFs {
     await this.#useTransaction(async (transaction) => {
       if (options?.recursive) {
         const rootPath = this.#root || "/";
-        const relativePath = path3.posix.relative(rootPath, prefixed);
+        const relativePath = path4.posix.relative(rootPath, prefixed);
         const segments = relativePath.split("/").filter(Boolean);
         let currentPath = rootPath;
         for (const segment of segments) {
-          currentPath = path3.posix.join(currentPath, segment);
+          currentPath = path4.posix.join(currentPath, segment);
           const checkReq = transaction.request();
           checkReq.input("p0", currentPath);
           const result = await checkReq.query(
@@ -2946,7 +2999,7 @@ var MssqlFs = class _MssqlFs {
          AND path NOT LIKE @p0 + '%/%'`,
       [prefix, resolved]
     );
-    return rows.map((row) => path3.posix.basename(row.path));
+    return rows.map((row) => path4.posix.basename(row.path));
   }
   async readdirWithFileTypes(dirPath) {
     const normalized = this.#normalizePath(dirPath);
@@ -2972,7 +3025,7 @@ var MssqlFs = class _MssqlFs {
       [prefix, resolved]
     );
     return rows.map((row) => ({
-      name: path3.posix.basename(row.path),
+      name: path4.posix.basename(row.path),
       isFile: row.type === "file",
       isDirectory: row.type === "directory",
       isSymbolicLink: row.type === "symlink"
@@ -3041,8 +3094,8 @@ var MssqlFs = class _MssqlFs {
           `SELECT * FROM ${this.#t("fs_entries")} WHERE path = @p0 OR path LIKE @p0 + '/%'`
         );
         for (const entry of allEntriesResult.recordset) {
-          const relativePath = path3.posix.relative(srcPrefixed, entry.path);
-          const newPath = path3.posix.join(destPrefixed, relativePath);
+          const relativePath = path4.posix.relative(srcPrefixed, entry.path);
+          const newPath = path4.posix.join(destPrefixed, relativePath);
           const insertReq = transaction.request();
           insertReq.input("p0", newPath);
           insertReq.input("p1", entry.type);
@@ -3151,8 +3204,8 @@ var MssqlFs = class _MssqlFs {
           `DELETE FROM ${this.#t("fs_entries")} WHERE path = @dp0 OR path LIKE @dp0 + '/%'`
         );
         for (const entry of [...allEntriesResult.recordset].reverse()) {
-          const relativePath = path3.posix.relative(srcPrefixed, entry.path);
-          const newPath = path3.posix.join(destPrefixed, relativePath);
+          const relativePath = path4.posix.relative(srcPrefixed, entry.path);
+          const newPath = path4.posix.join(destPrefixed, relativePath);
           const insertReq = transaction.request();
           insertReq.input("p0", newPath);
           insertReq.input("p1", entry.type);
@@ -3245,7 +3298,7 @@ var MssqlFs = class _MssqlFs {
     });
   }
   resolvePath(base, relativePath) {
-    return path3.posix.resolve(base, relativePath);
+    return path4.posix.resolve(base, relativePath);
   }
   getAllPaths() {
     throw new Error(
@@ -3386,7 +3439,7 @@ var MssqlFs = class _MssqlFs {
 
 // packages/text2sql/src/lib/fs/postgres/postgres-fs.ts
 import { createRequire as createRequire2 } from "node:module";
-import * as path4 from "node:path";
+import * as path5 from "node:path";
 
 // packages/text2sql/src/lib/fs/postgres/ddl.postgres-fs.ts
 function postgresFsDDL(schema) {
@@ -3491,7 +3544,7 @@ var PostgresFs = class _PostgresFs {
     const segments = p.split("/").filter(Boolean);
     let currentPath = "/";
     for (let i = 0; i < segments.length - 1; i++) {
-      currentPath = path4.posix.join(currentPath, segments[i]);
+      currentPath = path5.posix.join(currentPath, segments[i]);
       const exists = await this.#rawQuery(
         `SELECT EXISTS(SELECT 1 FROM ${this.#t("fs_entries")} WHERE path = $1) AS exists`,
         [currentPath]
@@ -3536,7 +3589,7 @@ var PostgresFs = class _PostgresFs {
     }
   }
   #normalizeRoot(root) {
-    return path4.posix.resolve("/", root.trim());
+    return path5.posix.resolve("/", root.trim());
   }
   #prefixPath(p) {
     if (!this.#root) {
@@ -3545,7 +3598,7 @@ var PostgresFs = class _PostgresFs {
     if (p === "/") {
       return this.#root;
     }
-    return path4.posix.join(this.#root, p);
+    return path5.posix.join(this.#root, p);
   }
   #unprefixPath(p) {
     if (!this.#root) {
@@ -3560,10 +3613,10 @@ var PostgresFs = class _PostgresFs {
     return p;
   }
   #normalizePath(p) {
-    return path4.posix.resolve("/", p);
+    return path5.posix.resolve("/", p);
   }
   #dirname(p) {
-    const dir = path4.posix.dirname(p);
+    const dir = path5.posix.dirname(p);
     return dir === "" ? "/" : dir;
   }
   async #ensureParentExists(filePath, client) {
@@ -3643,7 +3696,7 @@ var PostgresFs = class _PostgresFs {
     }
     seen.add(p);
     const target = this.#normalizePath(
-      path4.posix.resolve(this.#dirname(p), entry.symlink_target)
+      path5.posix.resolve(this.#dirname(p), entry.symlink_target)
     );
     return this.#resolveSymlink(target, seen);
   }
@@ -3809,11 +3862,11 @@ var PostgresFs = class _PostgresFs {
     await this.#useTransaction(async (client) => {
       if (options?.recursive) {
         const rootPath = this.#root || "/";
-        const relativePath = path4.posix.relative(rootPath, prefixed);
+        const relativePath = path5.posix.relative(rootPath, prefixed);
         const segments = relativePath.split("/").filter(Boolean);
         let currentPath = rootPath;
         for (const segment of segments) {
-          currentPath = path4.posix.join(currentPath, segment);
+          currentPath = path5.posix.join(currentPath, segment);
           const result = await client.query(
             `SELECT type FROM ${this.#t("fs_entries")} WHERE path = $1`,
             [currentPath]
@@ -3871,7 +3924,7 @@ var PostgresFs = class _PostgresFs {
          AND path NOT LIKE $1 || '%/%'`,
       [prefix, resolved]
     );
-    return rows.map((row) => path4.posix.basename(row.path));
+    return rows.map((row) => path5.posix.basename(row.path));
   }
   async readdirWithFileTypes(dirPath) {
     const normalized = this.#normalizePath(dirPath);
@@ -3897,7 +3950,7 @@ var PostgresFs = class _PostgresFs {
       [prefix, resolved]
     );
     return rows.map((row) => ({
-      name: path4.posix.basename(row.path),
+      name: path5.posix.basename(row.path),
       isFile: row.type === "file",
       isDirectory: row.type === "directory",
       isSymbolicLink: row.type === "symlink"
@@ -3962,8 +4015,8 @@ var PostgresFs = class _PostgresFs {
           [srcPrefixed]
         );
         for (const entry of allEntriesResult.rows) {
-          const relativePath = path4.posix.relative(srcPrefixed, entry.path);
-          const newPath = path4.posix.join(destPrefixed, relativePath);
+          const relativePath = path5.posix.relative(srcPrefixed, entry.path);
+          const newPath = path5.posix.join(destPrefixed, relativePath);
           await client.query(
             `INSERT INTO ${this.#t("fs_entries")} (path, type, mode, size, mtime, symlink_target)
              VALUES ($1, $2, $3, $4, $5, $6)
@@ -4052,8 +4105,8 @@ var PostgresFs = class _PostgresFs {
           [destPrefixed]
         );
         for (const entry of [...allEntriesResult.rows].reverse()) {
-          const relativePath = path4.posix.relative(srcPrefixed, entry.path);
-          const newPath = path4.posix.join(destPrefixed, relativePath);
+          const relativePath = path5.posix.relative(srcPrefixed, entry.path);
+          const newPath = path5.posix.join(destPrefixed, relativePath);
           await client.query(
             `INSERT INTO ${this.#t("fs_entries")} (path, type, mode, size, mtime, symlink_target)
              VALUES ($1, $2, $3, $4, $5, $6)
@@ -4126,7 +4179,7 @@ var PostgresFs = class _PostgresFs {
     });
   }
   resolvePath(base, relativePath) {
-    return path4.posix.resolve(base, relativePath);
+    return path5.posix.resolve(base, relativePath);
   }
   getAllPaths() {
     throw new Error(
@@ -4262,29 +4315,29 @@ var ScopedFs = class {
     this.#base = options.base;
     this.#prefix = options.prefix.replace(/\/$/, "");
   }
-  #scope(path6) {
-    return `${this.#prefix}${path6}`;
+  #scope(path7) {
+    return `${this.#prefix}${path7}`;
   }
-  #unscope(path6) {
-    if (path6 === this.#prefix) {
+  #unscope(path7) {
+    if (path7 === this.#prefix) {
       return "/";
     }
-    if (path6.startsWith(this.#prefix + "/")) {
-      return path6.slice(this.#prefix.length) || "/";
+    if (path7.startsWith(this.#prefix + "/")) {
+      return path7.slice(this.#prefix.length) || "/";
     }
-    return path6;
+    return path7;
   }
-  async writeFile(path6, content, options) {
-    await this.#base.writeFile(this.#scope(path6), content, options);
+  async writeFile(path7, content, options) {
+    await this.#base.writeFile(this.#scope(path7), content, options);
   }
-  async appendFile(path6, content, options) {
-    await this.#base.appendFile(this.#scope(path6), content, options);
+  async appendFile(path7, content, options) {
+    await this.#base.appendFile(this.#scope(path7), content, options);
   }
-  async mkdir(path6, options) {
-    return this.#base.mkdir(this.#scope(path6), options);
+  async mkdir(path7, options) {
+    return this.#base.mkdir(this.#scope(path7), options);
   }
-  async rm(path6, options) {
-    await this.#base.rm(this.#scope(path6), options);
+  async rm(path7, options) {
+    await this.#base.rm(this.#scope(path7), options);
   }
   async cp(src, dest, options) {
     await this.#base.cp(this.#scope(src), this.#scope(dest), options);
@@ -4292,8 +4345,8 @@ var ScopedFs = class {
   async mv(src, dest) {
     await this.#base.mv(this.#scope(src), this.#scope(dest));
   }
-  async chmod(path6, mode) {
-    return this.#base.chmod(this.#scope(path6), mode);
+  async chmod(path7, mode) {
+    return this.#base.chmod(this.#scope(path7), mode);
   }
   async symlink(target, linkPath) {
     await this.#base.symlink(target, this.#scope(linkPath));
@@ -4301,35 +4354,35 @@ var ScopedFs = class {
   async link(existingPath, newPath) {
     await this.#base.link(this.#scope(existingPath), this.#scope(newPath));
   }
-  readFile(path6, options) {
-    return this.#base.readFile(this.#scope(path6), options);
+  readFile(path7, options) {
+    return this.#base.readFile(this.#scope(path7), options);
   }
-  readFileBuffer(path6) {
-    return this.#base.readFileBuffer(this.#scope(path6));
+  readFileBuffer(path7) {
+    return this.#base.readFileBuffer(this.#scope(path7));
   }
-  stat(path6) {
-    return this.#base.stat(this.#scope(path6));
+  stat(path7) {
+    return this.#base.stat(this.#scope(path7));
   }
-  lstat(path6) {
-    return this.#base.lstat(this.#scope(path6));
+  lstat(path7) {
+    return this.#base.lstat(this.#scope(path7));
   }
-  readdir(path6) {
-    return this.#base.readdir(this.#scope(path6));
+  readdir(path7) {
+    return this.#base.readdir(this.#scope(path7));
   }
-  readdirWithFileTypes(path6) {
-    return this.#base.readdirWithFileTypes(this.#scope(path6));
+  readdirWithFileTypes(path7) {
+    return this.#base.readdirWithFileTypes(this.#scope(path7));
   }
-  exists(path6) {
-    return this.#base.exists(this.#scope(path6));
+  exists(path7) {
+    return this.#base.exists(this.#scope(path7));
   }
-  readlink(path6) {
-    return this.#base.readlink(this.#scope(path6));
+  readlink(path7) {
+    return this.#base.readlink(this.#scope(path7));
   }
-  realpath(path6) {
-    return this.#base.realpath(this.#scope(path6)).then((p) => this.#unscope(p));
+  realpath(path7) {
+    return this.#base.realpath(this.#scope(path7)).then((p) => this.#unscope(p));
   }
-  utimes(path6, atime, mtime) {
-    return this.#base.utimes(this.#scope(path6), atime, mtime);
+  utimes(path7, atime, mtime) {
+    return this.#base.utimes(this.#scope(path7), atime, mtime);
   }
   resolvePath(base, relativePath) {
     return this.#base.resolvePath(base, relativePath);
@@ -4578,7 +4631,7 @@ Action: Ask user: "Top by what metric\u2014total revenue, number of orders, or m
       workflow2({
         task: "Query execution",
         steps: [
-          "Pick the target database from the schema fragments (each parent fragment is named after a configured database).",
+          `Pick the target database by the <database> value shown at the top of each schema fragment \u2014 that is the exact connection name to pass as <db>. It is NOT the SQL-level database/schema name (e.g. SQLite's default "main").`,
           'Execute SQL through bash tool: sql run <db> "SELECT ..."',
           "Read the output: file path, column names, and row count.",
           "Use column names to construct jq filters: cat <path> | jq '.[] | {col1, col2}'",
@@ -4588,7 +4641,7 @@ Action: Ask user: "Top by what metric\u2014total revenue, number of orders, or m
       guardrail2({
         rule: "Do not attempt SQL access through non-bash tools.",
         reason: "SQL access is only available through the bash tool.",
-        action: 'Use `sql run <db> "SELECT ..."` and `sql validate <db> "SELECT ..."` through bash, where `<db>` is the configured database name.'
+        action: 'Use `sql run <db> "SELECT ..."` and `sql validate <db> "SELECT ..."` through bash, where `<db>` is the exact configured connection name (not the SQL-level database/schema name).'
       }),
       explain({
         concept: "sql command output format",
@@ -4754,8 +4807,8 @@ import { BashTransformPipeline } from "just-bash";
 
 // packages/text2sql/src/lib/agents/sql-transform-plugins.ts
 import { parse as parse2, serialize } from "just-bash";
-import { createHash as createHash3 } from "node:crypto";
-import * as path5 from "node:path";
+import { createHash as createHash4 } from "node:crypto";
+import * as path6 from "node:path";
 import { BashException, asStaticWordText as asStaticWordText2 } from "@deepagents/context";
 function isScriptNode(value) {
   if (typeof value !== "object" || value === null) {
@@ -5267,7 +5320,7 @@ function isBlockedSimpleCommand(command, context, mode, options) {
   if (!commandName) {
     return false;
   }
-  const normalizedName = path5.posix.basename(commandName).toLowerCase();
+  const normalizedName = path6.posix.basename(commandName).toLowerCase();
   if (BLOCKED_DB_CLIENT_COMMANDS.has(normalizedName)) {
     return true;
   }
@@ -5456,7 +5509,7 @@ function rewriteSqlCommand(cmd, ast) {
   const dbName = asStaticWordText2(cmd.args[1]);
   const sqlArgs = cmd.args.slice(2);
   const unquotedSql = extractSqlText(sqlArgs);
-  const hash2 = createHash3("sha256").update(serialize(ast)).digest("hex").slice(0, 12);
+  const hash2 = createHash4("sha256").update(serialize(ast)).digest("hex").slice(0, 12);
   const sqlPath = `/tmp/sql-inline-${subcommand}-${hash2}.sql`;
   const heredocTag = `SQL_${hash2.toUpperCase()}`;
   const groupScript = [
@@ -5681,6 +5734,15 @@ var Text2Sql = class {
   }
 };
 
+// packages/text2sql/src/lib/resolve-adapter.ts
+function resolveAdapter(text2Sql, db) {
+  if (text2Sql.hasAdapter(db)) return db;
+  const names = text2Sql.adapterNames();
+  if (names.length === 1) return names[0];
+  const available = names.join(", ") || "(none configured)";
+  throw new Error(`unknown database "${db}". Available: ${available}`);
+}
+
 // packages/text2sql/src/lib/sql-command.ts
 var SQL_VALIDATE_REMINDER2 = 'Always run `sql validate <db> "..."` before `sql run <db> "..."` to catch syntax errors early.';
 var SqlCommandError = class extends BashException2 {
@@ -5778,7 +5840,7 @@ async function runHandler(subcommand, fn) {
     return await fn();
   } catch (error) {
     if (error instanceof BashException2) return error.format();
-    if (Text2SqlValidationError.isInstance(error) || Text2SqlUnknownAdapterError.isInstance(error)) {
+    if (Text2SqlValidationError.isInstance(error)) {
       return new SqlCommandError(subcommand, error.message).format();
     }
     const message = error instanceof Error ? error.message : String(error);
@@ -5787,24 +5849,19 @@ async function runHandler(subcommand, fn) {
 }
 function takeDbAndSql(subcommand, positional, text2Sql) {
   const [db, ...rest] = positional;
-  const available = text2Sql.adapterNames().join(", ");
   if (!db) {
+    const available = text2Sql.adapterNames().join(", ");
     throw new SqlCommandError(
       subcommand,
       `missing database name. Usage: sql ${subcommand} <db> "SELECT ...". Available: ${available}`
     );
   }
-  if (!text2Sql.hasAdapter(db)) {
-    throw new SqlCommandError(
-      subcommand,
-      `unknown database "${db}". Available: ${available}`
-    );
-  }
+  const name = resolveAdapter(text2Sql, db);
   const sql = rest.join(" ").trim();
   if (!sql) {
     throw new SqlCommandError(subcommand, "no query provided");
   }
-  return { name: db, sql };
+  return { name, sql };
 }
 function repairDbNameAndQuotedArg(rawArgs) {
   const trimmed = rawArgs.trim();
@@ -5823,6 +5880,7 @@ export {
   Checkpoint,
   FileCache,
   FileIndexCache,
+  FileIndexLock,
   JsonCache,
   MssqlFs,
   Point,