@deepagents/text2sql 7.1.0 → 7.1.2

package/dist/index.js

@@ -486,15 +486,15 @@ SQL: ${sql.trim()}`,
    */
   rowsFrom(result, paths) {
     if (Array.isArray(result)) return result;
-    for (const path7 of paths) {
-      const rows = path7.split(".").reduce(
+    for (const path6 of paths) {
+      const rows = path6.split(".").reduce(
         (value, key) => typeof value === "object" && value !== null ? Reflect.get(value, key) : void 0,
         result
       );
       if (Array.isArray(rows)) return rows;
     }
     throw new Error(
-      `${this.constructor.name} execute() must return an array of rows or an object holding one at ${paths.map((path7) => `result.${path7}`).join(", ")}.`
+      `${this.constructor.name} execute() must return an array of rows or an object holding one at ${paths.map((path6) => `result.${path6}`).join(", ")}.`
     );
   }
   /**
@@ -1203,51 +1203,6 @@ function isFragmentList(value) {
   return Array.isArray(value) && value.every((item) => isFragment(item) && isFragmentData(item));
 }
 
-// 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 = () => {
@@ -1267,7 +1222,6 @@ function databaseNameFragment(name) {
 var AdapterIndexer = class {
   #adapters;
   #cache;
-  #lock;
   constructor(options) {
     const adapterNames = Object.keys(options.adapters);
     if (adapterNames.length === 0) {
@@ -1276,7 +1230,6 @@ var AdapterIndexer = class {
     validateAdapterNames(adapterNames);
     this.#adapters = options.adapters;
     this.#cache = options.cache;
-    this.#lock = options.lock;
   }
   async index(options = {}) {
     const progress = timestampProgressHandler(options.onProgress);
@@ -1334,41 +1287,15 @@ var AdapterIndexer = class {
       message: `Indexing adapter "${name}"...`
     });
     const cache = this.#cache;
-    const key = name;
-    const emitCacheHit = () => progress({
-      type: "adapter:cache-hit",
-      adapter: name,
-      message: `Using cached index for adapter "${name}".`,
-      cached: true
-    });
-    const emitCacheMiss = () => progress({
-      type: "adapter:cache-miss",
-      adapter: name,
-      message: `No cached index for adapter "${name}".`,
-      cached: false
-    });
-    const introspect = async () => {
-      const ctx = createGroundingContext({
-        onProgress: (event) => progress(adapterProgressEvent(name, event))
-      });
-      const fragments = await adapter.introspect(ctx);
-      await cache?.write(key, fragments);
-      return fragments;
-    };
-    let servedFromCache = false;
-    const populate = async () => {
-      const recheck = await cache?.read(key);
-      if (recheck) {
-        servedFromCache = true;
-        return recheck;
-      }
-      if (cache) emitCacheMiss();
-      return introspect();
-    };
     try {
-      const cached = await cache?.read(key);
+      const cached = await cache?.read(name);
       if (cached) {
-        emitCacheHit();
+        progress({
+          type: "adapter:cache-hit",
+          adapter: name,
+          message: `Using cached index for adapter "${name}".`,
+          cached: true
+        });
         progress({
           type: "adapter:end",
           adapter: name,
@@ -1377,13 +1304,24 @@ var AdapterIndexer = class {
         });
         return cached;
       }
-      const fragments = await this.#lock.run(key, populate);
-      if (servedFromCache) emitCacheHit();
+      if (cache) {
+        progress({
+          type: "adapter:cache-miss",
+          adapter: name,
+          message: `No cached index for adapter "${name}".`,
+          cached: false
+        });
+      }
+      const ctx = createGroundingContext({
+        onProgress: (event) => progress(adapterProgressEvent(name, event))
+      });
+      const fragments = await adapter.introspect(ctx);
+      await cache?.write(name, fragments);
       progress({
         type: "adapter:end",
         adapter: name,
         message: `Finished indexing adapter "${name}".`,
-        cached: servedFromCache
+        cached: false
       });
       return fragments;
     } catch (error) {
@@ -1429,7 +1367,7 @@ function errorMessage(error) {
 }
 
 // packages/text2sql/src/lib/checkpoint.ts
-import { createHash as createHash3 } from "node:crypto";
+import { createHash as createHash2 } from "node:crypto";
 import { existsSync as existsSync2, readFileSync, renameSync, writeFileSync } from "node:fs";
 import pLimit from "p-limit";
 import z4 from "zod";
@@ -1450,9 +1388,9 @@ var Checkpoint = class _Checkpoint {
   points;
   path;
   configHash;
-  constructor(path7, configHash, points) {
+  constructor(path6, configHash, points) {
     this.points = points;
-    this.path = path7;
+    this.path = path6;
     this.configHash = configHash;
   }
   /**
@@ -1460,14 +1398,14 @@ var Checkpoint = class _Checkpoint {
    * Handles corrupted files and config changes gracefully.
    */
   static async load(options) {
-    const { path: path7, configHash } = options;
-    if (existsSync2(path7)) {
+    const { path: path6, configHash } = options;
+    if (existsSync2(path6)) {
       try {
-        const content = readFileSync(path7, "utf-8");
+        const content = readFileSync(path6, "utf-8");
         const file = checkpointFile.parse(JSON.parse(content));
         if (configHash && file.configHash && file.configHash !== configHash) {
           console.log("\u26A0 Config changed, starting fresh");
-          return new _Checkpoint(path7, configHash, {});
+          return new _Checkpoint(path6, configHash, {});
         }
         const points = file.points;
         const totalEntries = Object.values(points).reduce(
@@ -1475,14 +1413,14 @@ var Checkpoint = class _Checkpoint {
           0
         );
         console.log(`\u2713 Resuming from checkpoint (${totalEntries} entries)`);
-        return new _Checkpoint(path7, configHash, points);
+        return new _Checkpoint(path6, configHash, points);
       } catch {
         console.log("\u26A0 Checkpoint corrupted, starting fresh");
-        return new _Checkpoint(path7, configHash, {});
+        return new _Checkpoint(path6, configHash, {});
       }
     }
     console.log("Starting new checkpoint");
-    return new _Checkpoint(path7, configHash, {});
+    return new _Checkpoint(path6, configHash, {});
   }
   /**
    * Run a single computation with checkpointing.
@@ -1558,7 +1496,7 @@ var Checkpoint = class _Checkpoint {
   }
 };
 function hash(value) {
-  return createHash3("md5").update(JSON.stringify(value)).digest("hex");
+  return createHash2("md5").update(JSON.stringify(value)).digest("hex");
 }
 var Point = class {
   #stored;
@@ -1603,11 +1541,11 @@ var Point = class {
   }
 };
 function hashConfig(config) {
-  return createHash3("md5").update(JSON.stringify(config)).digest("hex");
+  return createHash2("md5").update(JSON.stringify(config)).digest("hex");
 }
 
 // packages/text2sql/src/lib/fs/sqlite/sqlite-fs.ts
-import * as path3 from "node:path";
+import * as path2 from "node:path";
 import { DatabaseSync } from "node:sqlite";
 import z6 from "zod";
 
@@ -1684,7 +1622,7 @@ var SqliteFs = class {
     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 = path2.posix.join(currentPath, segments[i]);
       const exists = this.#stmt("SELECT 1 FROM fs_entries WHERE path = ?").get(
         currentPath
       );
@@ -1705,7 +1643,7 @@ var SqliteFs = class {
     return stmt;
   }
   #normalizeRoot(root) {
-    return path3.posix.resolve("/", root.trim());
+    return path2.posix.resolve("/", root.trim());
   }
   #prefixPath(p) {
     if (!this.#root) {
@@ -1714,7 +1652,7 @@ var SqliteFs = class {
     if (p === "/") {
       return this.#root;
     }
-    return path3.posix.join(this.#root, p);
+    return path2.posix.join(this.#root, p);
   }
   #unprefixPath(p) {
     if (!this.#root) {
@@ -1735,15 +1673,18 @@ var SqliteFs = class {
       this.#db.exec("COMMIT");
       return result;
     } catch (error) {
-      this.#db.exec("ROLLBACK");
+      try {
+        this.#db.exec("ROLLBACK");
+      } catch {
+      }
       throw error;
     }
   }
   #normalizePath(p) {
-    return path3.posix.resolve("/", p);
+    return path2.posix.resolve("/", p);
   }
   #dirname(p) {
-    const dir = path3.posix.dirname(p);
+    const dir = path2.posix.dirname(p);
     return dir === "" ? "/" : dir;
   }
   #ensureParentExists(filePath) {
@@ -1817,7 +1758,7 @@ var SqliteFs = class {
     }
     seen.add(p);
     const target = this.#normalizePath(
-      path3.posix.resolve(this.#dirname(p), entry.symlinkTarget)
+      path2.posix.resolve(this.#dirname(p), entry.symlinkTarget)
     );
     return this.#resolveSymlink(target, seen);
   }
@@ -1970,11 +1911,11 @@ var SqliteFs = class {
     this.#useTransaction(() => {
       if (options?.recursive) {
         const rootPath = this.#root || "/";
-        const relativePath = path3.posix.relative(rootPath, prefixed);
+        const relativePath = path2.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 = path2.posix.join(currentPath, segment);
           const exists = typeRow.optional().parse(
             this.#stmt("SELECT type FROM fs_entries WHERE path = ?").get(
               currentPath
@@ -2031,7 +1972,7 @@ var SqliteFs = class {
          AND path NOT LIKE ? || '%/%'`
       ).all(prefix, resolved, prefix)
     );
-    return rows.map((row) => path3.posix.basename(row.path));
+    return rows.map((row) => path2.posix.basename(row.path));
   }
   async readdirWithFileTypes(dirPath) {
     const normalized = this.#normalizePath(dirPath);
@@ -2056,7 +1997,7 @@ var SqliteFs = class {
       ).all(prefix, resolved, prefix)
     );
     return rows.map((row) => ({
-      name: path3.posix.basename(row.path),
+      name: path2.posix.basename(row.path),
       isFile: row.type === "file",
       isDirectory: row.type === "directory",
       isSymbolicLink: row.type === "symlink"
@@ -2113,8 +2054,8 @@ var SqliteFs = class {
           ).all(srcPrefixed, srcPrefixed)
         );
         for (const entry of allEntries) {
-          const relativePath = path3.posix.relative(srcPrefixed, entry.path);
-          const newPath = path3.posix.join(destPrefixed, relativePath);
+          const relativePath = path2.posix.relative(srcPrefixed, entry.path);
+          const newPath = path2.posix.join(destPrefixed, relativePath);
           this.#stmt(
             `INSERT OR REPLACE INTO fs_entries (path, type, mode, size, mtime, symlinkTarget)
              VALUES (?, ?, ?, ?, ?, ?)`
@@ -2179,8 +2120,8 @@ var SqliteFs = class {
           ).all(srcPrefixed, srcPrefixed)
         );
         for (const entry of [...allEntries].reverse()) {
-          const relativePath = path3.posix.relative(srcPrefixed, entry.path);
-          const newPath = path3.posix.join(destPrefixed, relativePath);
+          const relativePath = path2.posix.relative(srcPrefixed, entry.path);
+          const newPath = path2.posix.join(destPrefixed, relativePath);
           this.#stmt(
             `INSERT INTO fs_entries (path, type, mode, size, mtime, symlinkTarget)
              VALUES (?, ?, ?, ?, ?, ?)`
@@ -2229,7 +2170,7 @@ var SqliteFs = class {
     });
   }
   resolvePath(base, relativePath) {
-    return path3.posix.resolve(base, relativePath);
+    return path2.posix.resolve(base, relativePath);
   }
   getAllPaths() {
     const rows = z6.array(pathRow).parse(this.#stmt("SELECT path FROM fs_entries ORDER BY path").all());
@@ -2339,7 +2280,7 @@ var SqliteFs = class {
 
 // packages/text2sql/src/lib/fs/mssql/mssql-fs.ts
 import { createRequire } from "node:module";
-import * as path4 from "node:path";
+import * as path3 from "node:path";
 import z7 from "zod";
 
 // packages/text2sql/src/lib/fs/mssql/ddl.mssql-fs.ts
@@ -2406,7 +2347,6 @@ var MssqlFs = class _MssqlFs {
   #root;
   #schema;
   #ownsPool;
-  #isInitialized = false;
   constructor(options) {
     this.#chunkSize = options.chunkSize ?? 1024 * 1024;
     const schema = options.schema ?? "dbo";
@@ -2438,7 +2378,18 @@ var MssqlFs = class _MssqlFs {
   #t(name) {
     return `[${this.#schema}].[${name}]`;
   }
-  async initialize() {
+  /** Opens the file system: creates its tables and its root directories. */
+  static async create(options) {
+    const fs = new _MssqlFs(options);
+    try {
+      await fs.#initialize();
+    } catch (error) {
+      await fs.close();
+      throw error;
+    }
+    return fs;
+  }
+  async #initialize() {
     if (this.#ownsPool) {
       await this.#pool.connect();
     }
@@ -2460,12 +2411,12 @@ var MssqlFs = class _MssqlFs {
     }
     const rootSlashExists = rowsOf(
       existsRow,
-      await this.#rawQuery(
+      await this.#query(
         `SELECT CASE WHEN EXISTS(SELECT 1 FROM ${this.#t("fs_entries")} WHERE path = '/') THEN 1 ELSE 0 END as [exists]`
       )
     );
     if (rootSlashExists[0].exists === 0) {
-      await this.#rawExec(
+      await this.#exec(
         `INSERT INTO ${this.#t("fs_entries")} (path, type, mode, size, mtime) VALUES ('/', 'directory', 493, 0, @p0)`,
         [Date.now()]
       );
@@ -2474,55 +2425,47 @@ var MssqlFs = class _MssqlFs {
       await this.#createParentDirs(this.#root);
       const rootExists = rowsOf(
         existsRow,
-        await this.#rawQuery(
+        await this.#query(
           `SELECT CASE WHEN EXISTS(SELECT 1 FROM ${this.#t("fs_entries")} WHERE path = @p0) THEN 1 ELSE 0 END as [exists]`,
           [this.#root]
         )
       );
       if (rootExists[0].exists === 0) {
-        await this.#rawExec(
+        await this.#exec(
           `INSERT INTO ${this.#t("fs_entries")} (path, type, mode, size, mtime) VALUES (@p0, 'directory', 493, 0, @p1)`,
           [this.#root, Date.now()]
         );
       }
     }
-    this.#isInitialized = true;
-  }
-  #ensureInitialized() {
-    if (!this.#isInitialized) {
-      throw new Error(
-        "MssqlFs not initialized. Call await fs.initialize() after construction."
-      );
-    }
   }
   async #createParentDirs(p) {
     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 = path3.posix.join(currentPath, segments[i]);
       const exists = rowsOf(
         existsRow,
-        await this.#rawQuery(
+        await this.#query(
           `SELECT CASE WHEN EXISTS(SELECT 1 FROM ${this.#t("fs_entries")} WHERE path = @p0) THEN 1 ELSE 0 END as [exists]`,
           [currentPath]
         )
       );
       if (exists[0].exists === 0) {
-        await this.#rawExec(
+        await this.#exec(
           `INSERT INTO ${this.#t("fs_entries")} (path, type, mode, size, mtime) VALUES (@p0, 'directory', 493, 0, @p1)`,
           [currentPath, Date.now()]
         );
       }
     }
   }
-  #rawQuery(sql, params) {
+  #query(sql, params) {
     const request = this.#pool.request();
     params?.forEach((value, index2) => {
       request.input(`p${index2}`, value);
     });
     return request.query(sql);
   }
-  async #rawExec(sql, params) {
+  async #exec(sql, params) {
     const request = this.#pool.request();
     params?.forEach((value, index2) => {
       request.input(`p${index2}`, value);
@@ -2530,16 +2473,7 @@ var MssqlFs = class _MssqlFs {
     const result = await request.query(sql);
     return result.rowsAffected[0] ?? 0;
   }
-  async #query(sql, params) {
-    this.#ensureInitialized();
-    return this.#rawQuery(sql, params);
-  }
-  async #exec(sql, params) {
-    this.#ensureInitialized();
-    return this.#rawExec(sql, params);
-  }
   async #useTransaction(fn) {
-    this.#ensureInitialized();
     const mssql = _MssqlFs.#requireMssql();
     const transaction = new mssql.Transaction(this.#pool);
     try {
@@ -2553,7 +2487,7 @@ var MssqlFs = class _MssqlFs {
     }
   }
   #normalizeRoot(root) {
-    return path4.posix.resolve("/", root.trim());
+    return path3.posix.resolve("/", root.trim());
   }
   #prefixPath(p) {
     if (!this.#root) {
@@ -2562,7 +2496,7 @@ var MssqlFs = class _MssqlFs {
     if (p === "/") {
       return this.#root;
     }
-    return path4.posix.join(this.#root, p);
+    return path3.posix.join(this.#root, p);
   }
   #unprefixPath(p) {
     if (!this.#root) {
@@ -2577,10 +2511,10 @@ var MssqlFs = class _MssqlFs {
     return p;
   }
   #normalizePath(p) {
-    return path4.posix.resolve("/", p);
+    return path3.posix.resolve("/", p);
   }
   #dirname(p) {
-    const dir = path4.posix.dirname(p);
+    const dir = path3.posix.dirname(p);
     return dir === "" ? "/" : dir;
   }
   async #ensureParentExists(filePath, transaction) {
@@ -2664,7 +2598,7 @@ var MssqlFs = class _MssqlFs {
     }
     seen.add(p);
     const target = this.#normalizePath(
-      path4.posix.resolve(this.#dirname(p), entry.symlinkTarget)
+      path3.posix.resolve(this.#dirname(p), entry.symlinkTarget)
     );
     return this.#resolveSymlink(target, seen);
   }
@@ -2861,11 +2795,11 @@ var MssqlFs = class _MssqlFs {
     await this.#useTransaction(async (transaction) => {
       if (options?.recursive) {
         const rootPath = this.#root || "/";
-        const relativePath = path4.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 = path4.posix.join(currentPath, segment);
+          currentPath = path3.posix.join(currentPath, segment);
           const checkReq = transaction.request();
           checkReq.input("p0", currentPath);
           const [exists] = rowsOf(
@@ -2938,7 +2872,7 @@ var MssqlFs = class _MssqlFs {
         [prefix, resolved]
       )
     );
-    return rows.map((row) => path4.posix.basename(row.path));
+    return rows.map((row) => path3.posix.basename(row.path));
   }
   async readdirWithFileTypes(dirPath) {
     const normalized = this.#normalizePath(dirPath);
@@ -2969,7 +2903,7 @@ var MssqlFs = class _MssqlFs {
       )
     );
     return rows.map((row) => ({
-      name: path4.posix.basename(row.path),
+      name: path3.posix.basename(row.path),
       isFile: row.type === "file",
       isDirectory: row.type === "directory",
       isSymbolicLink: row.type === "symlink"
@@ -3048,8 +2982,8 @@ var MssqlFs = class _MssqlFs {
           )
         );
         for (const entry of allEntries) {
-          const relativePath = path4.posix.relative(srcPrefixed, entry.path);
-          const newPath = path4.posix.join(destPrefixed, relativePath);
+          const relativePath = path3.posix.relative(srcPrefixed, entry.path);
+          const newPath = path3.posix.join(destPrefixed, relativePath);
           const insertReq = transaction.request();
           insertReq.input("p0", newPath);
           insertReq.input("p1", entry.type);
@@ -3169,8 +3103,8 @@ var MssqlFs = class _MssqlFs {
           `DELETE FROM ${this.#t("fs_entries")} WHERE path = @dp0 OR path LIKE @dp0 + '/%'`
         );
         for (const entry of [...allEntries].reverse()) {
-          const relativePath = path4.posix.relative(srcPrefixed, entry.path);
-          const newPath = path4.posix.join(destPrefixed, relativePath);
+          const relativePath = path3.posix.relative(srcPrefixed, entry.path);
+          const newPath = path3.posix.join(destPrefixed, relativePath);
           const insertReq = transaction.request();
           insertReq.input("p0", newPath);
           insertReq.input("p1", entry.type);
@@ -3269,7 +3203,7 @@ var MssqlFs = class _MssqlFs {
     });
   }
   resolvePath(base, relativePath) {
-    return path4.posix.resolve(base, relativePath);
+    return path3.posix.resolve(base, relativePath);
   }
   getAllPaths() {
     throw new Error(
@@ -3429,7 +3363,7 @@ var MssqlFs = class _MssqlFs {
 
 // packages/text2sql/src/lib/fs/postgres/postgres-fs.ts
 import { createRequire as createRequire2 } from "node:module";
-import * as path5 from "node:path";
+import * as path4 from "node:path";
 import z8 from "zod";
 
 // packages/text2sql/src/lib/fs/postgres/ddl.postgres-fs.ts
@@ -3492,7 +3426,6 @@ var PostgresFs = class _PostgresFs {
   #root;
   #schema;
   #ownsPool;
-  #isInitialized = false;
   constructor(options) {
     this.#chunkSize = options.chunkSize ?? 1024 * 1024;
     const schema = options.schema ?? "public";
@@ -3524,17 +3457,28 @@ var PostgresFs = class _PostgresFs {
   #t(name) {
     return `"${this.#schema}"."${name}"`;
   }
-  async initialize() {
+  /** Opens the file system: creates its tables and its root directories. */
+  static async create(options) {
+    const fs = new _PostgresFs(options);
+    try {
+      await fs.#initialize();
+    } catch (error) {
+      await fs.close();
+      throw error;
+    }
+    return fs;
+  }
+  async #initialize() {
     const ddl = postgresFsDDL(this.#schema);
     await this.#pool.query(ddl);
     const rootSlashExists = rowsOf2(
       existsRow2,
-      await this.#rawQuery(
+      await this.#query(
         `SELECT EXISTS(SELECT 1 FROM ${this.#t("fs_entries")} WHERE path = '/') AS exists`
       )
     );
     if (!rootSlashExists[0].exists) {
-      await this.#rawExec(
+      await this.#exec(
         `INSERT INTO ${this.#t("fs_entries")} (path, type, mode, size, mtime) VALUES ('/', 'directory', 493, 0, $1)`,
         [Date.now()]
       );
@@ -3543,64 +3487,47 @@ var PostgresFs = class _PostgresFs {
       await this.#createParentDirs(this.#root);
       const rootExists = rowsOf2(
         existsRow2,
-        await this.#rawQuery(
+        await this.#query(
           `SELECT EXISTS(SELECT 1 FROM ${this.#t("fs_entries")} WHERE path = $1) AS exists`,
           [this.#root]
         )
       );
       if (!rootExists[0].exists) {
-        await this.#rawExec(
+        await this.#exec(
           `INSERT INTO ${this.#t("fs_entries")} (path, type, mode, size, mtime) VALUES ($1, 'directory', 493, 0, $2)`,
           [this.#root, Date.now()]
         );
       }
     }
-    this.#isInitialized = true;
-  }
-  #ensureInitialized() {
-    if (!this.#isInitialized) {
-      throw new Error(
-        "PostgresFs not initialized. Call await fs.initialize() after construction."
-      );
-    }
   }
   async #createParentDirs(p) {
     const segments = p.split("/").filter(Boolean);
     let currentPath = "/";
     for (let i = 0; i < segments.length - 1; i++) {
-      currentPath = path5.posix.join(currentPath, segments[i]);
+      currentPath = path4.posix.join(currentPath, segments[i]);
       const exists = rowsOf2(
         existsRow2,
-        await this.#rawQuery(
+        await this.#query(
           `SELECT EXISTS(SELECT 1 FROM ${this.#t("fs_entries")} WHERE path = $1) AS exists`,
           [currentPath]
         )
       );
       if (!exists[0].exists) {
-        await this.#rawExec(
+        await this.#exec(
           `INSERT INTO ${this.#t("fs_entries")} (path, type, mode, size, mtime) VALUES ($1, 'directory', 493, 0, $2)`,
           [currentPath, Date.now()]
         );
       }
     }
   }
-  #rawQuery(sql, params) {
+  #query(sql, params) {
     return this.#pool.query(sql, params);
   }
-  async #rawExec(sql, params) {
+  async #exec(sql, params) {
     const result = await this.#pool.query(sql, params);
     return result.rowCount ?? 0;
   }
-  async #query(sql, params) {
-    this.#ensureInitialized();
-    return this.#rawQuery(sql, params);
-  }
-  async #exec(sql, params) {
-    this.#ensureInitialized();
-    return this.#rawExec(sql, params);
-  }
   async #useTransaction(fn) {
-    this.#ensureInitialized();
     const client = await this.#pool.connect();
     try {
       await client.query("BEGIN");
@@ -3615,7 +3542,7 @@ var PostgresFs = class _PostgresFs {
     }
   }
   #normalizeRoot(root) {
-    return path5.posix.resolve("/", root.trim());
+    return path4.posix.resolve("/", root.trim());
   }
   #prefixPath(p) {
     if (!this.#root) {
@@ -3624,7 +3551,7 @@ var PostgresFs = class _PostgresFs {
     if (p === "/") {
       return this.#root;
     }
-    return path5.posix.join(this.#root, p);
+    return path4.posix.join(this.#root, p);
   }
   #unprefixPath(p) {
     if (!this.#root) {
@@ -3639,10 +3566,10 @@ var PostgresFs = class _PostgresFs {
     return p;
   }
   #normalizePath(p) {
-    return path5.posix.resolve("/", p);
+    return path4.posix.resolve("/", p);
   }
   #dirname(p) {
-    const dir = path5.posix.dirname(p);
+    const dir = path4.posix.dirname(p);
     return dir === "" ? "/" : dir;
   }
   async #ensureParentExists(filePath, client) {
@@ -3718,7 +3645,7 @@ var PostgresFs = class _PostgresFs {
     }
     seen.add(p);
     const target = this.#normalizePath(
-      path5.posix.resolve(this.#dirname(p), entry.symlink_target)
+      path4.posix.resolve(this.#dirname(p), entry.symlink_target)
     );
     return this.#resolveSymlink(target, seen);
   }
@@ -3898,11 +3825,11 @@ var PostgresFs = class _PostgresFs {
     await this.#useTransaction(async (client) => {
       if (options?.recursive) {
         const rootPath = this.#root || "/";
-        const relativePath = path5.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 = path5.posix.join(currentPath, segment);
+          currentPath = path4.posix.join(currentPath, segment);
           const [exists] = rowsOf2(
             typeRow3,
             await client.query(
@@ -3969,7 +3896,7 @@ var PostgresFs = class _PostgresFs {
         [prefix, resolved]
       )
     );
-    return rows.map((row) => path5.posix.basename(row.path));
+    return rows.map((row) => path4.posix.basename(row.path));
   }
   async readdirWithFileTypes(dirPath) {
     const normalized = this.#normalizePath(dirPath);
@@ -4000,7 +3927,7 @@ var PostgresFs = class _PostgresFs {
       )
     );
     return rows.map((row) => ({
-      name: path5.posix.basename(row.path),
+      name: path4.posix.basename(row.path),
       isFile: row.type === "file",
       isDirectory: row.type === "directory",
       isSymbolicLink: row.type === "symlink"
@@ -4075,8 +4002,8 @@ var PostgresFs = class _PostgresFs {
           )
         );
         for (const entry of allEntries) {
-          const relativePath = path5.posix.relative(srcPrefixed, entry.path);
-          const newPath = path5.posix.join(destPrefixed, relativePath);
+          const relativePath = path4.posix.relative(srcPrefixed, entry.path);
+          const newPath = path4.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)
@@ -4176,8 +4103,8 @@ var PostgresFs = class _PostgresFs {
           [destPrefixed]
         );
         for (const entry of [...allEntries].reverse()) {
-          const relativePath = path5.posix.relative(srcPrefixed, entry.path);
-          const newPath = path5.posix.join(destPrefixed, relativePath);
+          const relativePath = path4.posix.relative(srcPrefixed, entry.path);
+          const newPath = path4.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)
@@ -4256,7 +4183,7 @@ var PostgresFs = class _PostgresFs {
     });
   }
   resolvePath(base, relativePath) {
-    return path5.posix.resolve(base, relativePath);
+    return path4.posix.resolve(base, relativePath);
   }
   getAllPaths() {
     throw new Error(
@@ -4411,29 +4338,29 @@ var ScopedFs = class {
     this.#base = options.base;
     this.#prefix = options.prefix.replace(/\/$/, "");
   }
-  #scope(path7) {
-    return `${this.#prefix}${path7}`;
+  #scope(path6) {
+    return `${this.#prefix}${path6}`;
   }
-  #unscope(path7) {
-    if (path7 === this.#prefix) {
+  #unscope(path6) {
+    if (path6 === this.#prefix) {
       return "/";
     }
-    if (path7.startsWith(this.#prefix + "/")) {
-      return path7.slice(this.#prefix.length) || "/";
+    if (path6.startsWith(this.#prefix + "/")) {
+      return path6.slice(this.#prefix.length) || "/";
     }
-    return path7;
+    return path6;
   }
-  async writeFile(path7, content, options) {
-    await this.#base.writeFile(this.#scope(path7), content, options);
+  async writeFile(path6, content, options) {
+    await this.#base.writeFile(this.#scope(path6), content, options);
   }
-  async appendFile(path7, content, options) {
-    await this.#base.appendFile(this.#scope(path7), content, options);
+  async appendFile(path6, content, options) {
+    await this.#base.appendFile(this.#scope(path6), content, options);
   }
-  async mkdir(path7, options) {
-    return this.#base.mkdir(this.#scope(path7), options);
+  async mkdir(path6, options) {
+    return this.#base.mkdir(this.#scope(path6), options);
   }
-  async rm(path7, options) {
-    await this.#base.rm(this.#scope(path7), options);
+  async rm(path6, options) {
+    await this.#base.rm(this.#scope(path6), options);
   }
   async cp(src, dest, options) {
     await this.#base.cp(this.#scope(src), this.#scope(dest), options);
@@ -4441,8 +4368,8 @@ var ScopedFs = class {
   async mv(src, dest) {
     await this.#base.mv(this.#scope(src), this.#scope(dest));
   }
-  async chmod(path7, mode) {
-    return this.#base.chmod(this.#scope(path7), mode);
+  async chmod(path6, mode) {
+    return this.#base.chmod(this.#scope(path6), mode);
   }
   async symlink(target, linkPath) {
     await this.#base.symlink(target, this.#scope(linkPath));
@@ -4450,35 +4377,35 @@ var ScopedFs = class {
   async link(existingPath, newPath) {
     await this.#base.link(this.#scope(existingPath), this.#scope(newPath));
   }
-  readFile(path7, options) {
-    return this.#base.readFile(this.#scope(path7), options);
+  readFile(path6, options) {
+    return this.#base.readFile(this.#scope(path6), options);
   }
-  readFileBuffer(path7) {
-    return this.#base.readFileBuffer(this.#scope(path7));
+  readFileBuffer(path6) {
+    return this.#base.readFileBuffer(this.#scope(path6));
   }
-  stat(path7) {
-    return this.#base.stat(this.#scope(path7));
+  stat(path6) {
+    return this.#base.stat(this.#scope(path6));
   }
-  lstat(path7) {
-    return this.#base.lstat(this.#scope(path7));
+  lstat(path6) {
+    return this.#base.lstat(this.#scope(path6));
   }
-  readdir(path7) {
-    return this.#base.readdir(this.#scope(path7));
+  readdir(path6) {
+    return this.#base.readdir(this.#scope(path6));
   }
-  readdirWithFileTypes(path7) {
-    return this.#base.readdirWithFileTypes(this.#scope(path7));
+  readdirWithFileTypes(path6) {
+    return this.#base.readdirWithFileTypes(this.#scope(path6));
   }
-  exists(path7) {
-    return this.#base.exists(this.#scope(path7));
+  exists(path6) {
+    return this.#base.exists(this.#scope(path6));
   }
-  readlink(path7) {
-    return this.#base.readlink(this.#scope(path7));
+  readlink(path6) {
+    return this.#base.readlink(this.#scope(path6));
   }
-  realpath(path7) {
-    return this.#base.realpath(this.#scope(path7)).then((p) => this.#unscope(p));
+  realpath(path6) {
+    return this.#base.realpath(this.#scope(path6)).then((p) => this.#unscope(p));
   }
-  utimes(path7, atime, mtime) {
-    return this.#base.utimes(this.#scope(path7), atime, mtime);
+  utimes(path6, atime, mtime) {
+    return this.#base.utimes(this.#scope(path6), atime, mtime);
   }
   resolvePath(base, relativePath) {
     return this.#base.resolvePath(base, relativePath);
@@ -4901,8 +4828,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 createHash4 } from "node:crypto";
-import * as path6 from "node:path";
+import { createHash as createHash3 } from "node:crypto";
+import * as path5 from "node:path";
 import {
   BashException,
   asStaticWordText as asStaticWordText2
@@ -5397,7 +5324,7 @@ function isBlockedSimpleCommand(command, context, mode, options) {
   if (!commandName) {
     return false;
   }
-  const normalizedName = path6.posix.basename(commandName).toLowerCase();
+  const normalizedName = path5.posix.basename(commandName).toLowerCase();
   if (BLOCKED_DB_CLIENT_COMMANDS.has(normalizedName)) {
     return true;
   }
@@ -5575,7 +5502,7 @@ function rewriteSqlCommand(cmd, ast) {
   const dbName = asStaticWordText2(cmd.args[1]);
   const sqlArgs = cmd.args.slice(2);
   const unquotedSql = extractSqlText(sqlArgs);
-  const hash2 = createHash4("sha256").update(serialize(ast)).digest("hex").slice(0, 12);
+  const hash2 = createHash3("sha256").update(serialize(ast)).digest("hex").slice(0, 12);
   const sqlPath = `/tmp/sql-inline-${subcommand}-${hash2}.sql`;
   const heredocTag = `SQL_${hash2.toUpperCase()}`;
   const groupScript = [
@@ -5687,7 +5614,6 @@ import {
 } from "@deepagents/context";
 
 // packages/text2sql/src/lib/sql.ts
-import "@deepagents/agent";
 var text2SqlValidationMarker = /* @__PURE__ */ Symbol("Text2SqlValidationError");
 var text2SqlUnknownAdapterMarker = /* @__PURE__ */ Symbol("Text2SqlUnknownAdapterError");
 var Text2SqlValidationError = class _Text2SqlValidationError extends Error {
@@ -5748,8 +5674,7 @@ var Text2Sql = class {
     this.#config = config;
     this.#indexer = new AdapterIndexer({
       adapters: config.adapters,
-      cache: config.cache,
-      lock: config.lock
+      cache: config.cache
     });
   }
   #requireAdapter(name) {
@@ -5759,13 +5684,6 @@ var Text2Sql = class {
     }
     return adapter;
   }
-  #requireModel(op) {
-    const model = this.#config.model;
-    if (!model) {
-      throw new Error(`Text2Sql.${op}() requires a model in Text2SqlConfig`);
-    }
-    return model;
-  }
   adapterNames() {
     return Object.keys(this.#config.adapters);
   }
@@ -5824,18 +5742,6 @@ var Text2Sql = class {
       onProgress: options.onProgress
     });
   }
-  async toSql(input, adapterName) {
-    const adapter = this.#requireAdapter(adapterName);
-    const model = this.#requireModel("toSql");
-    const fragments = await this.#indexer.indexAdapter(adapterName);
-    const result = await toSql({
-      input,
-      adapter,
-      fragments,
-      model
-    });
-    return result.sql;
-  }
   async toPairs(adapterName, factory) {
     const adapter = this.#requireAdapter(adapterName);
     const producer = factory(adapter);
@@ -6011,7 +5917,6 @@ export {
   Checkpoint,
   FileCache,
   FileIndexCache,
-  FileIndexLock,
   JsonCache,
   MssqlFs,
   Point,