@deepagents/text2sql 0.16.0 → 0.17.1

package/dist/index.js

@@ -510,7 +510,6 @@ var fragments = [
   hint("Support both natural language questions AND raw SQL input"),
   hint("When validating user SQL, explain any errors clearly")
 ];
-var developer_agent_default = { tools, fragments };
 
 // packages/text2sql/src/lib/agents/result-tools.ts
 import { tool as tool2 } from "ai";
@@ -522,6 +521,7 @@ import {
   OverlayFs,
   defineCommand
 } from "just-bash";
+import { AsyncLocalStorage } from "node:async_hooks";
 import * as path from "node:path";
 import { v7 } from "uuid";
 import z3 from "zod";
@@ -550,7 +550,7 @@ function validateReadOnly(query) {
   }
   return { valid: true };
 }
-function createSqlCommand(adapter) {
+function createSqlCommand(adapter, metaStore) {
   return createCommand("sql", {
     run: {
       usage: 'run "SELECT ..."',
@@ -573,6 +573,8 @@ function createSqlCommand(adapter) {
           };
         }
         const query = adapter.format(rawQuery);
+        const store = metaStore.getStore();
+        if (store) store.value = { formattedSql: query };
         const syntaxError = await adapter.validate(query);
         if (syntaxError) {
           return {
@@ -629,6 +631,8 @@ function createSqlCommand(adapter) {
           };
         }
         const query = adapter.format(rawQuery);
+        const store = metaStore.getStore();
+        if (store) store.value = { formattedSql: query };
         const syntaxError = await adapter.validate(query);
         if (syntaxError) {
           return {
@@ -648,7 +652,8 @@ function createSqlCommand(adapter) {
 }
 async function createResultTools(options) {
   const { adapter, skillMounts, filesystem: baseFs } = options;
-  const sqlCommand = createSqlCommand(adapter);
+  const metaStore = new AsyncLocalStorage();
+  const sqlCommand = createSqlCommand(adapter, metaStore);
   const fsMounts = skillMounts.map(({ host, sandbox: sandbox2 }) => ({
     mountPoint: path.dirname(sandbox2),
     filesystem: new OverlayFs({
@@ -687,10 +692,19 @@ async function createResultTools(options) {
       reasoning: z3.string().trim().describe("Brief reason for executing this command")
     }),
     execute: async ({ command }, execOptions) => {
-      if (!tools2.bash.execute) {
+      const execute = tools2.bash.execute;
+      if (!execute) {
         throw new Error("bash tool execution is not available");
       }
-      return tools2.bash.execute({ command }, execOptions);
+      return metaStore.run({}, async () => {
+        const result = await execute({ command }, execOptions);
+        const meta = metaStore.getStore()?.value;
+        return meta ? { ...result, meta } : result;
+      });
+    },
+    toModelOutput: ({ output }) => {
+      const { meta, ...rest } = output;
+      return { type: "json", value: rest };
     }
   });
   return {
@@ -714,8 +728,6 @@ import {
   defaultSettingsMiddleware,
   wrapLanguageModel
 } from "ai";
-import { Console } from "node:console";
-import { createWriteStream } from "node:fs";
 import pRetry from "p-retry";
 import z4 from "zod";
 import "@deepagents/agent";
@@ -726,11 +738,6 @@ import {
   structuredOutput as structuredOutput2,
   user as user2
 } from "@deepagents/context";
-var logger = new Console({
-  stdout: createWriteStream("./sql-agent.log", { flags: "a" }),
-  stderr: createWriteStream("./sql-agent-error.log", { flags: "a" }),
-  inspectOptions: { depth: null }
-});
 var RETRY_TEMPERATURES = [0, 0.2, 0.3];
 function extractSql(output) {
   const match = output.match(/```sql\n?([\s\S]*?)```/);
@@ -869,7 +876,6 @@ async function withRetry(computation, options = { retries: 3 }) {
         return APICallError.isInstance(context.error) || JSONParseError.isInstance(context.error) || TypeValidationError.isInstance(context.error) || NoObjectGeneratedError.isInstance(context.error) || NoOutputGeneratedError.isInstance(context.error) || NoContentGeneratedError.isInstance(context.error);
       },
       onFailedAttempt(context) {
-        logger.error(`toSQL`, context.error);
         console.log(
           `Attempt ${context.attemptNumber} failed. There are ${context.retriesLeft} retries left.`
         );
@@ -939,9 +945,9 @@ var Checkpoint = class _Checkpoint {
   points;
   path;
   configHash;
-  constructor(path5, configHash, points) {
+  constructor(path6, configHash, points) {
     this.points = points;
-    this.path = path5;
+    this.path = path6;
     this.configHash = configHash;
   }
   /**
@@ -949,14 +955,14 @@ var Checkpoint = class _Checkpoint {
    * Handles corrupted files and config changes gracefully.
    */
   static async load(options) {
-    const { path: path5, configHash } = options;
-    if (existsSync(path5)) {
+    const { path: path6, configHash } = options;
+    if (existsSync(path6)) {
       try {
-        const content = readFileSync(path5, "utf-8");
+        const content = readFileSync(path6, "utf-8");
         const file = JSON.parse(content);
         if (configHash && file.configHash && file.configHash !== configHash) {
           console.log("\u26A0 Config changed, starting fresh");
-          return new _Checkpoint(path5, configHash, {});
+          return new _Checkpoint(path6, configHash, {});
         }
         const points = file.points ?? {};
         const totalEntries = Object.values(points).reduce(
@@ -964,14 +970,14 @@ var Checkpoint = class _Checkpoint {
           0
         );
         console.log(`\u2713 Resuming from checkpoint (${totalEntries} entries)`);
-        return new _Checkpoint(path5, configHash, points);
+        return new _Checkpoint(path6, configHash, points);
       } catch {
         console.log("\u26A0 Checkpoint corrupted, starting fresh");
-        return new _Checkpoint(path5, configHash, {});
+        return new _Checkpoint(path6, configHash, {});
       }
     }
     console.log("Starting new checkpoint");
-    return new _Checkpoint(path5, configHash, {});
+    return new _Checkpoint(path6, configHash, {});
   }
   /**
    * Run a single computation with checkpointing.
@@ -1832,10 +1838,9 @@ import * as path4 from "node:path";
 
 // packages/text2sql/src/lib/fs/mssql/ddl.mssql-fs.ts
 function mssqlFsDDL(schema) {
-  const s = schema;
   return `
-IF NOT EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[${s}].[fs_entries]') AND type = 'U')
-CREATE TABLE [${s}].[fs_entries] (
+IF NOT EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[${schema}].[fs_entries]') AND type = 'U')
+CREATE TABLE [${schema}].[fs_entries] (
   path NVARCHAR(900) PRIMARY KEY,
   type NVARCHAR(20) NOT NULL,
   mode INT NOT NULL,
@@ -1845,17 +1850,17 @@ CREATE TABLE [${s}].[fs_entries] (
 );
 GO
 
-IF NOT EXISTS (SELECT * FROM sys.indexes WHERE name = 'idx_${s}_fs_entries_type')
-CREATE INDEX [idx_${s}_fs_entries_type] ON [${s}].[fs_entries](type);
+IF NOT EXISTS (SELECT * FROM sys.indexes WHERE name = 'idx_${schema}_fs_entries_type')
+CREATE INDEX [idx_${schema}_fs_entries_type] ON [${schema}].[fs_entries](type);
 GO
 
-IF NOT EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[${s}].[fs_chunks]') AND type = 'U')
-CREATE TABLE [${s}].[fs_chunks] (
+IF NOT EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[${schema}].[fs_chunks]') AND type = 'U')
+CREATE TABLE [${schema}].[fs_chunks] (
   path NVARCHAR(900) NOT NULL,
   chunkIndex INT NOT NULL,
   data VARBINARY(MAX) NOT NULL,
   PRIMARY KEY (path, chunkIndex),
-  FOREIGN KEY (path) REFERENCES [${s}].[fs_entries](path) ON DELETE CASCADE ON UPDATE CASCADE
+  FOREIGN KEY (path) REFERENCES [${schema}].[fs_entries](path) ON DELETE CASCADE ON UPDATE CASCADE
 );
 GO
 `;
@@ -2079,11 +2084,21 @@ var MssqlFs = class _MssqlFs {
       );
     }
   }
-  async #readChunks(filePath) {
-    const rows = await this.#query(
-      `SELECT data FROM ${this.#t("fs_chunks")} WHERE path = @p0 ORDER BY chunkIndex`,
-      [filePath]
-    );
+  async #readChunks(filePath, transaction) {
+    let rows;
+    if (transaction) {
+      const req = transaction.request();
+      req.input("p0", filePath);
+      const result2 = await req.query(
+        `SELECT data FROM ${this.#t("fs_chunks")} WHERE path = @p0 ORDER BY chunkIndex`
+      );
+      rows = result2.recordset;
+    } else {
+      rows = await this.#query(
+        `SELECT data FROM ${this.#t("fs_chunks")} WHERE path = @p0 ORDER BY chunkIndex`,
+        [filePath]
+      );
+    }
     if (rows.length === 0) {
       return new Uint8Array(0);
     }
@@ -2208,7 +2223,7 @@ var MssqlFs = class _MssqlFs {
       if (entry && entry.type !== "file") {
         throw new Error(`appendFile: not a file: ${filePath}`);
       }
-      const existing = entry ? await this.#readChunks(prefixed) : new Uint8Array(0);
+      const existing = entry ? await this.#readChunks(prefixed, transaction) : new Uint8Array(0);
       const combined = new Uint8Array(existing.length + newData.length);
       combined.set(existing, 0);
       combined.set(newData, existing.length);
@@ -2563,6 +2578,11 @@ var MssqlFs = class _MssqlFs {
         const allEntriesResult = await allEntriesReq.query(
           `SELECT * FROM ${this.#t("fs_entries")} WHERE path = @p0 OR path LIKE @p0 + '/%' ORDER BY path DESC`
         );
+        const destDeleteReq = transaction.request();
+        destDeleteReq.input("dp0", destPrefixed);
+        await destDeleteReq.query(
+          `DELETE FROM ${this.#t("fs_entries")} WHERE path = @dp0 OR path LIKE @dp0 + '/%'`
+        );
         for (const entry of [...allEntriesResult.recordset].reverse()) {
           const relativePath = path4.posix.relative(srcPrefixed, entry.path);
           const newPath = path4.posix.join(destPrefixed, relativePath);
@@ -2573,11 +2593,22 @@ var MssqlFs = class _MssqlFs {
           insertReq.input("p3", entry.size);
           insertReq.input("p4", Date.now());
           insertReq.input("p5", entry.symlinkTarget);
-          await insertReq.query(
-            `INSERT INTO ${this.#t("fs_entries")} (path, type, mode, size, mtime, symlinkTarget)
-             VALUES (@p0, @p1, @p2, @p3, @p4, @p5)`
-          );
+          await insertReq.query(`
+            MERGE ${this.#t("fs_entries")} AS target
+            USING (SELECT @p0 AS path) AS source
+            ON target.path = source.path
+            WHEN MATCHED THEN
+              UPDATE SET type = @p1, mode = @p2, size = @p3, mtime = @p4, symlinkTarget = @p5
+            WHEN NOT MATCHED THEN
+              INSERT (path, type, mode, size, mtime, symlinkTarget)
+              VALUES (@p0, @p1, @p2, @p3, @p4, @p5);
+          `);
           if (entry.type === "file") {
+            const deleteChunksReq = transaction.request();
+            deleteChunksReq.input("p0", newPath);
+            await deleteChunksReq.query(
+              `DELETE FROM ${this.#t("fs_chunks")} WHERE path = @p0`
+            );
             const chunksReq = transaction.request();
             chunksReq.input("p0", entry.path);
             const chunksResult = await chunksReq.query(
@@ -2607,11 +2638,22 @@ var MssqlFs = class _MssqlFs {
         insertReq.input("p3", srcEntry.size);
         insertReq.input("p4", Date.now());
         insertReq.input("p5", srcEntry.symlinkTarget);
-        await insertReq.query(
-          `INSERT INTO ${this.#t("fs_entries")} (path, type, mode, size, mtime, symlinkTarget)
-           VALUES (@p0, @p1, @p2, @p3, @p4, @p5)`
-        );
+        await insertReq.query(`
+          MERGE ${this.#t("fs_entries")} AS target
+          USING (SELECT @p0 AS path) AS source
+          ON target.path = source.path
+          WHEN MATCHED THEN
+            UPDATE SET type = @p1, mode = @p2, size = @p3, mtime = @p4, symlinkTarget = @p5
+          WHEN NOT MATCHED THEN
+            INSERT (path, type, mode, size, mtime, symlinkTarget)
+            VALUES (@p0, @p1, @p2, @p3, @p4, @p5);
+        `);
         if (srcEntry.type === "file") {
+          const deleteChunksReq = transaction.request();
+          deleteChunksReq.input("p0", destPrefixed);
+          await deleteChunksReq.query(
+            `DELETE FROM ${this.#t("fs_chunks")} WHERE path = @p0`
+          );
           const chunksReq = transaction.request();
           chunksReq.input("p0", srcPrefixed);
           const chunksResult = await chunksReq.query(
@@ -2775,136 +2817,1006 @@ var MssqlFs = class _MssqlFs {
   }
 };
 
-// packages/text2sql/src/lib/fs/scoped-fs.ts
-var ScopedFs = class {
-  #base;
-  #prefix;
+// packages/text2sql/src/lib/fs/postgres/postgres-fs.ts
+import { createRequire as createRequire2 } from "node:module";
+import * as path5 from "node:path";
+
+// packages/text2sql/src/lib/fs/postgres/ddl.postgres-fs.ts
+function postgresFsDDL(schema) {
+  return `
+CREATE SCHEMA IF NOT EXISTS "${schema}";
+
+CREATE TABLE IF NOT EXISTS "${schema}"."fs_entries" (
+  path TEXT PRIMARY KEY,
+  type TEXT NOT NULL,
+  mode INTEGER NOT NULL,
+  size BIGINT NOT NULL,
+  mtime BIGINT NOT NULL,
+  symlink_target TEXT
+);
+
+CREATE INDEX IF NOT EXISTS "idx_${schema}_fs_entries_type" ON "${schema}"."fs_entries"(type);
+
+CREATE TABLE IF NOT EXISTS "${schema}"."fs_chunks" (
+  path TEXT NOT NULL,
+  chunk_index INTEGER NOT NULL,
+  data BYTEA NOT NULL,
+  PRIMARY KEY (path, chunk_index),
+  FOREIGN KEY (path) REFERENCES "${schema}"."fs_entries"(path) ON DELETE CASCADE ON UPDATE CASCADE
+);
+`;
+}
+
+// packages/text2sql/src/lib/fs/postgres/postgres-fs.ts
+var PostgresFs = class _PostgresFs {
+  #pool;
+  #chunkSize;
+  #root;
+  #schema;
+  #ownsPool;
+  #isInitialized = false;
   constructor(options) {
-    this.#base = options.base;
-    this.#prefix = options.prefix.replace(/\/$/, "");
-  }
-  #scope(path5) {
-    return `${this.#prefix}${path5}`;
-  }
-  #unscope(path5) {
-    if (path5 === this.#prefix) {
-      return "/";
+    this.#chunkSize = options.chunkSize ?? 1024 * 1024;
+    const schema = options.schema ?? "public";
+    if (!/^[a-zA-Z_]\w*$/.test(schema)) {
+      throw new Error(`Invalid schema name: "${schema}"`);
     }
-    if (path5.startsWith(this.#prefix + "/")) {
-      return path5.slice(this.#prefix.length) || "/";
+    this.#schema = schema;
+    const normalizedRoot = this.#normalizeRoot(options.root);
+    this.#root = normalizedRoot === "/" ? "" : normalizedRoot;
+    const pg = _PostgresFs.#requirePg();
+    if (options.pool instanceof pg.Pool) {
+      this.#pool = options.pool;
+      this.#ownsPool = false;
+    } else {
+      this.#pool = typeof options.pool === "string" ? new pg.Pool({ connectionString: options.pool }) : new pg.Pool(options.pool);
+      this.#ownsPool = true;
     }
-    return path5;
   }
-  async writeFile(path5, content, options) {
-    await this.#base.writeFile(this.#scope(path5), content, options);
-  }
-  async appendFile(path5, content, options) {
-    await this.#base.appendFile(this.#scope(path5), content, options);
-  }
-  async mkdir(path5, options) {
-    return this.#base.mkdir(this.#scope(path5), options);
-  }
-  async rm(path5, options) {
-    await this.#base.rm(this.#scope(path5), options);
-  }
-  async cp(src, dest, options) {
-    await this.#base.cp(this.#scope(src), this.#scope(dest), options);
-  }
-  async mv(src, dest) {
-    await this.#base.mv(this.#scope(src), this.#scope(dest));
-  }
-  async chmod(path5, mode) {
-    return this.#base.chmod(this.#scope(path5), mode);
-  }
-  async symlink(target, linkPath) {
-    await this.#base.symlink(target, this.#scope(linkPath));
+  static #requirePg() {
+    try {
+      const require2 = createRequire2(import.meta.url);
+      return require2("pg");
+    } catch {
+      throw new Error(
+        'PostgresFs requires the "pg" package. Install it with: npm install pg'
+      );
+    }
   }
-  async link(existingPath, newPath) {
-    await this.#base.link(this.#scope(existingPath), this.#scope(newPath));
+  #t(name) {
+    return `"${this.#schema}"."${name}"`;
   }
-  readFile(path5, options) {
-    return this.#base.readFile(this.#scope(path5), options);
+  async initialize() {
+    const ddl = postgresFsDDL(this.#schema);
+    await this.#pool.query(ddl);
+    const rootSlashExists = await this.#rawQuery(
+      `SELECT EXISTS(SELECT 1 FROM ${this.#t("fs_entries")} WHERE path = '/') AS exists`
+    );
+    if (!rootSlashExists[0].exists) {
+      await this.#rawExec(
+        `INSERT INTO ${this.#t("fs_entries")} (path, type, mode, size, mtime) VALUES ('/', 'directory', 493, 0, $1)`,
+        [Date.now()]
+      );
+    }
+    if (this.#root) {
+      await this.#createParentDirs(this.#root);
+      const rootExists = await this.#rawQuery(
+        `SELECT EXISTS(SELECT 1 FROM ${this.#t("fs_entries")} WHERE path = $1) AS exists`,
+        [this.#root]
+      );
+      if (!rootExists[0].exists) {
+        await this.#rawExec(
+          `INSERT INTO ${this.#t("fs_entries")} (path, type, mode, size, mtime) VALUES ($1, 'directory', 493, 0, $2)`,
+          [this.#root, Date.now()]
+        );
+      }
+    }
+    this.#isInitialized = true;
   }
-  readFileBuffer(path5) {
-    return this.#base.readFileBuffer(this.#scope(path5));
+  #ensureInitialized() {
+    if (!this.#isInitialized) {
+      throw new Error(
+        "PostgresFs not initialized. Call await fs.initialize() after construction."
+      );
+    }
   }
-  stat(path5) {
-    return this.#base.stat(this.#scope(path5));
+  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]);
+      const exists = await this.#rawQuery(
+        `SELECT EXISTS(SELECT 1 FROM ${this.#t("fs_entries")} WHERE path = $1) AS exists`,
+        [currentPath]
+      );
+      if (!exists[0].exists) {
+        await this.#rawExec(
+          `INSERT INTO ${this.#t("fs_entries")} (path, type, mode, size, mtime) VALUES ($1, 'directory', 493, 0, $2)`,
+          [currentPath, Date.now()]
+        );
+      }
+    }
   }
-  lstat(path5) {
-    return this.#base.lstat(this.#scope(path5));
+  async #rawQuery(sql, params) {
+    const result = await this.#pool.query(sql, params);
+    return result.rows;
   }
-  readdir(path5) {
-    return this.#base.readdir(this.#scope(path5));
+  async #rawExec(sql, params) {
+    const result = await this.#pool.query(sql, params);
+    return result.rowCount ?? 0;
   }
-  readdirWithFileTypes(path5) {
-    return this.#base.readdirWithFileTypes(this.#scope(path5));
+  async #query(sql, params) {
+    this.#ensureInitialized();
+    return this.#rawQuery(sql, params);
   }
-  exists(path5) {
-    return this.#base.exists(this.#scope(path5));
+  async #exec(sql, params) {
+    this.#ensureInitialized();
+    return this.#rawExec(sql, params);
   }
-  readlink(path5) {
-    return this.#base.readlink(this.#scope(path5));
+  async #useTransaction(fn) {
+    this.#ensureInitialized();
+    const client = await this.#pool.connect();
+    try {
+      await client.query("BEGIN");
+      const result = await fn(client);
+      await client.query("COMMIT");
+      return result;
+    } catch (error) {
+      await client.query("ROLLBACK");
+      throw error;
+    } finally {
+      client.release();
+    }
   }
-  realpath(path5) {
-    return this.#base.realpath(this.#scope(path5)).then((p) => this.#unscope(p));
+  #normalizeRoot(root) {
+    return path5.posix.resolve("/", root.trim());
   }
-  utimes(path5, atime, mtime) {
-    return this.#base.utimes(this.#scope(path5), atime, mtime);
+  #prefixPath(p) {
+    if (!this.#root) {
+      return p;
+    }
+    if (p === "/") {
+      return this.#root;
+    }
+    return path5.posix.join(this.#root, p);
   }
-  resolvePath(base, relativePath) {
-    return this.#base.resolvePath(base, relativePath);
+  #unprefixPath(p) {
+    if (!this.#root) {
+      return p;
+    }
+    if (p === this.#root) {
+      return "/";
+    }
+    if (p.startsWith(this.#root + "/")) {
+      return p.slice(this.#root.length) || "/";
+    }
+    return p;
   }
-  getAllPaths() {
-    const allPaths = this.#base.getAllPaths?.() ?? [];
-    return allPaths.filter((p) => p.startsWith(this.#prefix)).map((p) => p.slice(this.#prefix.length) || "/");
+  #normalizePath(p) {
+    return path5.posix.resolve("/", p);
   }
-};
-
-// packages/text2sql/src/lib/fs/tracked-fs.ts
-var TrackedFs = class {
-  #base;
-  #createdFiles = /* @__PURE__ */ new Set();
-  constructor(base) {
-    this.#base = base;
+  #dirname(p) {
+    const dir = path5.posix.dirname(p);
+    return dir === "" ? "/" : dir;
   }
-  getCreatedFiles() {
-    return [...this.#createdFiles];
+  async #ensureParentExists(filePath, client) {
+    const parent = this.#dirname(filePath);
+    const rootPath = this.#root || "/";
+    if (parent === rootPath || parent === "/") return;
+    const result = await client.query(
+      `SELECT type FROM ${this.#t("fs_entries")} WHERE path = $1`,
+      [parent]
+    );
+    const entry = result.rows[0];
+    if (!entry) {
+      await this.#ensureParentExists(parent, client);
+      await client.query(
+        `INSERT INTO ${this.#t("fs_entries")} (path, type, mode, size, mtime) VALUES ($1, 'directory', 493, 0, $2)`,
+        [parent, Date.now()]
+      );
+    } else if (entry.type !== "directory") {
+      throw new Error(`mkdir: parent is not a directory: ${parent}`);
+    }
   }
-  async writeFile(path5, content, options) {
-    await this.#base.writeFile(path5, content, options);
-    this.#createdFiles.add(path5);
+  async #writeChunks(filePath, content, client) {
+    await client.query(`DELETE FROM ${this.#t("fs_chunks")} WHERE path = $1`, [
+      filePath
+    ]);
+    for (let i = 0; i < content.length; i += this.#chunkSize) {
+      const chunk = content.slice(
+        i,
+        Math.min(i + this.#chunkSize, content.length)
+      );
+      await client.query(
+        `INSERT INTO ${this.#t("fs_chunks")} (path, chunk_index, data) VALUES ($1, $2, $3)`,
+        [filePath, Math.floor(i / this.#chunkSize), Buffer.from(chunk)]
+      );
+    }
   }
-  async appendFile(path5, content, options) {
-    await this.#base.appendFile(path5, content, options);
-    this.#createdFiles.add(path5);
+  async #readChunks(filePath, client) {
+    let rows;
+    if (client) {
+      const result2 = await client.query(
+        `SELECT data FROM ${this.#t("fs_chunks")} WHERE path = $1 ORDER BY chunk_index`,
+        [filePath]
+      );
+      rows = result2.rows;
+    } else {
+      rows = await this.#query(
+        `SELECT data FROM ${this.#t("fs_chunks")} WHERE path = $1 ORDER BY chunk_index`,
+        [filePath]
+      );
+    }
+    if (rows.length === 0) {
+      return new Uint8Array(0);
+    }
+    const totalSize = rows.reduce((sum, row) => sum + row.data.length, 0);
+    const result = new Uint8Array(totalSize);
+    let offset = 0;
+    for (const row of rows) {
+      result.set(new Uint8Array(row.data), offset);
+      offset += row.data.length;
+    }
+    return result;
   }
-  async mkdir(path5, options) {
-    return this.#base.mkdir(path5, options);
+  async #resolveSymlink(p, seen = /* @__PURE__ */ new Set()) {
+    if (seen.has(p)) {
+      throw new Error(`readFile: circular symlink: ${p}`);
+    }
+    const rows = await this.#query(
+      `SELECT type, symlink_target FROM ${this.#t("fs_entries")} WHERE path = $1`,
+      [p]
+    );
+    const entry = rows[0];
+    if (!entry) {
+      throw new Error(`ENOENT: no such file or directory: ${p}`);
+    }
+    if (entry.type !== "symlink") {
+      return p;
+    }
+    seen.add(p);
+    const target = this.#normalizePath(
+      path5.posix.resolve(this.#dirname(p), entry.symlink_target)
+    );
+    return this.#resolveSymlink(target, seen);
   }
-  async rm(path5, options) {
-    await this.#base.rm(path5, options);
-    this.#createdFiles.delete(path5);
-    if (options?.recursive) {
-      const prefix = path5.endsWith("/") ? path5 : path5 + "/";
-      for (const file of this.#createdFiles) {
-        if (file.startsWith(prefix)) {
-          this.#createdFiles.delete(file);
-        }
-      }
+  #toUint8Array(content, encoding) {
+    if (content instanceof Uint8Array) {
+      return content;
     }
+    const enc = encoding ?? "utf8";
+    return new Uint8Array(Buffer.from(content, enc));
   }
-  async cp(src, dest, options) {
-    await this.#base.cp(src, dest, options);
-    this.#createdFiles.add(dest);
+  async close() {
+    if (this.#ownsPool) {
+      await this.#pool.end();
+    }
   }
-  async mv(src, dest) {
-    await this.#base.mv(src, dest);
+  // ============================================================================
+  // IFileSystem Implementation
+  // ============================================================================
+  async readFile(filePath, options) {
+    const normalized = this.#normalizePath(filePath);
+    const prefixed = this.#prefixPath(normalized);
+    const resolved = await this.#resolveSymlink(prefixed);
+    const rows = await this.#query(
+      `SELECT type FROM ${this.#t("fs_entries")} WHERE path = $1`,
+      [resolved]
+    );
+    const entry = rows[0];
+    if (!entry) {
+      throw new Error(`ENOENT: no such file or directory: ${filePath}`);
+    }
+    if (entry.type === "directory") {
+      throw new Error(`EISDIR: illegal operation on a directory: ${filePath}`);
+    }
+    const content = await this.#readChunks(resolved);
+    const encoding = typeof options === "string" ? options : options?.encoding ?? "utf8";
+    return Buffer.from(content).toString(encoding);
+  }
+  async readFileBuffer(filePath) {
+    const normalized = this.#normalizePath(filePath);
+    const prefixed = this.#prefixPath(normalized);
+    const resolved = await this.#resolveSymlink(prefixed);
+    const rows = await this.#query(
+      `SELECT type FROM ${this.#t("fs_entries")} WHERE path = $1`,
+      [resolved]
+    );
+    const entry = rows[0];
+    if (!entry) {
+      throw new Error(`ENOENT: no such file or directory: ${filePath}`);
+    }
+    if (entry.type === "directory") {
+      throw new Error(`EISDIR: illegal operation on a directory: ${filePath}`);
+    }
+    return this.#readChunks(resolved);
+  }
+  async writeFile(filePath, content, options) {
+    const normalized = this.#normalizePath(filePath);
+    const prefixed = this.#prefixPath(normalized);
+    const encoding = typeof options === "string" ? options : options?.encoding;
+    const data = this.#toUint8Array(content, encoding);
+    await this.#useTransaction(async (client) => {
+      await this.#ensureParentExists(prefixed, client);
+      await client.query(
+        `INSERT INTO ${this.#t("fs_entries")} (path, type, mode, size, mtime)
+         VALUES ($1, 'file', 420, $2, $3)
+         ON CONFLICT (path) DO UPDATE SET type = 'file', size = EXCLUDED.size, mtime = EXCLUDED.mtime`,
+        [prefixed, data.length, Date.now()]
+      );
+      await this.#writeChunks(prefixed, data, client);
+    });
+  }
+  async appendFile(filePath, content, options) {
+    const normalized = this.#normalizePath(filePath);
+    const prefixed = this.#prefixPath(normalized);
+    const encoding = typeof options === "string" ? options : options?.encoding;
+    const newData = this.#toUint8Array(content, encoding);
+    await this.#useTransaction(async (client) => {
+      await this.#ensureParentExists(prefixed, client);
+      const result = await client.query(
+        `SELECT type FROM ${this.#t("fs_entries")} WHERE path = $1`,
+        [prefixed]
+      );
+      const entry = result.rows[0];
+      if (entry && entry.type !== "file") {
+        throw new Error(`appendFile: not a file: ${filePath}`);
+      }
+      const existing = entry ? await this.#readChunks(prefixed, client) : new Uint8Array(0);
+      const combined = new Uint8Array(existing.length + newData.length);
+      combined.set(existing, 0);
+      combined.set(newData, existing.length);
+      await client.query(
+        `INSERT INTO ${this.#t("fs_entries")} (path, type, mode, size, mtime)
+         VALUES ($1, 'file', 420, $2, $3)
+         ON CONFLICT (path) DO UPDATE SET size = EXCLUDED.size, mtime = EXCLUDED.mtime`,
+        [prefixed, combined.length, Date.now()]
+      );
+      await this.#writeChunks(prefixed, combined, client);
+    });
+  }
+  async exists(filePath) {
+    const normalized = this.#normalizePath(filePath);
+    const prefixed = this.#prefixPath(normalized);
+    const rows = await this.#query(
+      `SELECT EXISTS(SELECT 1 FROM ${this.#t("fs_entries")} WHERE path = $1) AS exists`,
+      [prefixed]
+    );
+    return rows[0].exists;
+  }
+  async stat(filePath) {
+    const normalized = this.#normalizePath(filePath);
+    const prefixed = this.#prefixPath(normalized);
+    const resolved = await this.#resolveSymlink(prefixed);
+    const rows = await this.#query(
+      `SELECT * FROM ${this.#t("fs_entries")} WHERE path = $1`,
+      [resolved]
+    );
+    const entry = rows[0];
+    if (!entry) {
+      throw new Error(`ENOENT: no such file or directory: ${filePath}`);
+    }
+    return {
+      isFile: entry.type === "file",
+      isDirectory: entry.type === "directory",
+      isSymbolicLink: false,
+      mode: Number(entry.mode),
+      size: Number(entry.size),
+      mtime: new Date(Number(entry.mtime))
+    };
+  }
+  async lstat(filePath) {
+    const normalized = this.#normalizePath(filePath);
+    const prefixed = this.#prefixPath(normalized);
+    const rows = await this.#query(
+      `SELECT * FROM ${this.#t("fs_entries")} WHERE path = $1`,
+      [prefixed]
+    );
+    const entry = rows[0];
+    if (!entry) {
+      throw new Error(`ENOENT: no such file or directory: ${filePath}`);
+    }
+    return {
+      isFile: entry.type === "file",
+      isDirectory: entry.type === "directory",
+      isSymbolicLink: entry.type === "symlink",
+      mode: Number(entry.mode),
+      size: Number(entry.size),
+      mtime: new Date(Number(entry.mtime))
+    };
+  }
+  async mkdir(dirPath, options) {
+    const normalized = this.#normalizePath(dirPath);
+    const prefixed = this.#prefixPath(normalized);
+    const existingRows = await this.#query(
+      `SELECT type FROM ${this.#t("fs_entries")} WHERE path = $1`,
+      [prefixed]
+    );
+    const existing = existingRows[0];
+    if (existing) {
+      if (options?.recursive) {
+        return;
+      }
+      throw new Error(`EEXIST: file already exists: ${dirPath}`);
+    }
+    await this.#useTransaction(async (client) => {
+      if (options?.recursive) {
+        const rootPath = this.#root || "/";
+        const relativePath = path5.posix.relative(rootPath, prefixed);
+        const segments = relativePath.split("/").filter(Boolean);
+        let currentPath = rootPath;
+        for (const segment of segments) {
+          currentPath = path5.posix.join(currentPath, segment);
+          const result = await client.query(
+            `SELECT type FROM ${this.#t("fs_entries")} WHERE path = $1`,
+            [currentPath]
+          );
+          const exists = result.rows[0];
+          if (!exists) {
+            await client.query(
+              `INSERT INTO ${this.#t("fs_entries")} (path, type, mode, size, mtime) VALUES ($1, 'directory', 493, 0, $2)`,
+              [currentPath, Date.now()]
+            );
+          } else if (exists.type !== "directory") {
+            throw new Error(`mkdir: not a directory: ${currentPath}`);
+          }
+        }
+      } else {
+        const parent = this.#dirname(prefixed);
+        const parentResult = await client.query(
+          `SELECT type FROM ${this.#t("fs_entries")} WHERE path = $1`,
+          [parent]
+        );
+        const parentEntry = parentResult.rows[0];
+        if (!parentEntry) {
+          throw new Error(`mkdir: parent does not exist: ${parent}`);
+        }
+        if (parentEntry.type !== "directory") {
+          throw new Error(`mkdir: parent is not a directory: ${parent}`);
+        }
+        await client.query(
+          `INSERT INTO ${this.#t("fs_entries")} (path, type, mode, size, mtime) VALUES ($1, 'directory', 493, 0, $2)`,
+          [prefixed, Date.now()]
+        );
+      }
+    });
+  }
+  async readdir(dirPath) {
+    const normalized = this.#normalizePath(dirPath);
+    const prefixed = this.#prefixPath(normalized);
+    const resolved = await this.#resolveSymlink(prefixed);
+    const entryRows = await this.#query(
+      `SELECT type FROM ${this.#t("fs_entries")} WHERE path = $1`,
+      [resolved]
+    );
+    const entry = entryRows[0];
+    if (!entry) {
+      throw new Error(`ENOENT: no such file or directory: ${dirPath}`);
+    }
+    if (entry.type !== "directory") {
+      throw new Error(`ENOTDIR: not a directory: ${dirPath}`);
+    }
+    const prefix = resolved === "/" ? "/" : resolved + "/";
+    const rows = await this.#query(
+      `SELECT path FROM ${this.#t("fs_entries")}
+       WHERE path LIKE $1 || '%'
+         AND path != $2
+         AND path NOT LIKE $1 || '%/%'`,
+      [prefix, resolved]
+    );
+    return rows.map((row) => path5.posix.basename(row.path));
+  }
+  async readdirWithFileTypes(dirPath) {
+    const normalized = this.#normalizePath(dirPath);
+    const prefixed = this.#prefixPath(normalized);
+    const resolved = await this.#resolveSymlink(prefixed);
+    const entryRows = await this.#query(
+      `SELECT type FROM ${this.#t("fs_entries")} WHERE path = $1`,
+      [resolved]
+    );
+    const entry = entryRows[0];
+    if (!entry) {
+      throw new Error(`ENOENT: no such file or directory: ${dirPath}`);
+    }
+    if (entry.type !== "directory") {
+      throw new Error(`ENOTDIR: not a directory: ${dirPath}`);
+    }
+    const prefix = resolved === "/" ? "/" : resolved + "/";
+    const rows = await this.#query(
+      `SELECT path, type FROM ${this.#t("fs_entries")}
+       WHERE path LIKE $1 || '%'
+         AND path != $2
+         AND path NOT LIKE $1 || '%/%'`,
+      [prefix, resolved]
+    );
+    return rows.map((row) => ({
+      name: path5.posix.basename(row.path),
+      isFile: row.type === "file",
+      isDirectory: row.type === "directory",
+      isSymbolicLink: row.type === "symlink"
+    }));
+  }
+  async rm(filePath, options) {
+    const normalized = this.#normalizePath(filePath);
+    const prefixed = this.#prefixPath(normalized);
+    const rows = await this.#query(
+      `SELECT type FROM ${this.#t("fs_entries")} WHERE path = $1`,
+      [prefixed]
+    );
+    const entry = rows[0];
+    if (!entry) {
+      if (options?.force) {
+        return;
+      }
+      throw new Error(`ENOENT: no such file or directory: ${filePath}`);
+    }
+    await this.#useTransaction(async (client) => {
+      if (entry.type === "directory") {
+        const childrenResult = await client.query(
+          `SELECT EXISTS(SELECT 1 FROM ${this.#t("fs_entries")} WHERE path LIKE $1 || '/%') AS exists`,
+          [prefixed]
+        );
+        if (childrenResult.rows[0].exists && !options?.recursive) {
+          throw new Error(`ENOTEMPTY: directory not empty: ${filePath}`);
+        }
+        await client.query(
+          `DELETE FROM ${this.#t("fs_entries")} WHERE path = $1 OR path LIKE $1 || '/%'`,
+          [prefixed]
+        );
+      } else {
+        await client.query(
+          `DELETE FROM ${this.#t("fs_entries")} WHERE path = $1`,
+          [prefixed]
+        );
+      }
+    });
+  }
+  async cp(src, dest, options) {
+    const srcNormalized = this.#normalizePath(src);
+    const destNormalized = this.#normalizePath(dest);
+    const srcPrefixed = this.#prefixPath(srcNormalized);
+    const destPrefixed = this.#prefixPath(destNormalized);
+    const srcRows = await this.#query(
+      `SELECT * FROM ${this.#t("fs_entries")} WHERE path = $1`,
+      [srcPrefixed]
+    );
+    const srcEntry = srcRows[0];
+    if (!srcEntry) {
+      throw new Error(`ENOENT: no such file or directory: ${src}`);
+    }
+    if (srcEntry.type === "directory" && !options?.recursive) {
+      throw new Error(`cp: -r not specified; omitting directory: ${src}`);
+    }
+    await this.#useTransaction(async (client) => {
+      await this.#ensureParentExists(destPrefixed, client);
+      if (srcEntry.type === "directory") {
+        const allEntriesResult = await client.query(
+          `SELECT * FROM ${this.#t("fs_entries")} WHERE path = $1 OR path LIKE $1 || '/%'`,
+          [srcPrefixed]
+        );
+        for (const entry of allEntriesResult.rows) {
+          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)
+             ON CONFLICT (path) DO UPDATE SET type = EXCLUDED.type, mode = EXCLUDED.mode, size = EXCLUDED.size, mtime = EXCLUDED.mtime, symlink_target = EXCLUDED.symlink_target`,
+            [
+              newPath,
+              entry.type,
+              entry.mode,
+              entry.size,
+              Date.now(),
+              entry.symlink_target
+            ]
+          );
+          if (entry.type === "file") {
+            await client.query(
+              `DELETE FROM ${this.#t("fs_chunks")} WHERE path = $1`,
+              [newPath]
+            );
+            const chunksResult = await client.query(
+              `SELECT chunk_index, data FROM ${this.#t("fs_chunks")} WHERE path = $1`,
+              [entry.path]
+            );
+            for (const chunk of chunksResult.rows) {
+              await client.query(
+                `INSERT INTO ${this.#t("fs_chunks")} (path, chunk_index, data) VALUES ($1, $2, $3)`,
+                [newPath, chunk.chunk_index, chunk.data]
+              );
+            }
+          }
+        }
+      } else {
+        await client.query(
+          `INSERT INTO ${this.#t("fs_entries")} (path, type, mode, size, mtime, symlink_target)
+           VALUES ($1, $2, $3, $4, $5, $6)
+           ON CONFLICT (path) DO UPDATE SET type = EXCLUDED.type, mode = EXCLUDED.mode, size = EXCLUDED.size, mtime = EXCLUDED.mtime, symlink_target = EXCLUDED.symlink_target`,
+          [
+            destPrefixed,
+            srcEntry.type,
+            srcEntry.mode,
+            srcEntry.size,
+            Date.now(),
+            srcEntry.symlink_target
+          ]
+        );
+        if (srcEntry.type === "file") {
+          const chunksResult = await client.query(
+            `SELECT chunk_index, data FROM ${this.#t("fs_chunks")} WHERE path = $1`,
+            [srcPrefixed]
+          );
+          await client.query(
+            `DELETE FROM ${this.#t("fs_chunks")} WHERE path = $1`,
+            [destPrefixed]
+          );
+          for (const chunk of chunksResult.rows) {
+            await client.query(
+              `INSERT INTO ${this.#t("fs_chunks")} (path, chunk_index, data) VALUES ($1, $2, $3)`,
+              [destPrefixed, chunk.chunk_index, chunk.data]
+            );
+          }
+        }
+      }
+    });
+  }
+  async mv(src, dest) {
+    const srcNormalized = this.#normalizePath(src);
+    const destNormalized = this.#normalizePath(dest);
+    const srcPrefixed = this.#prefixPath(srcNormalized);
+    const destPrefixed = this.#prefixPath(destNormalized);
+    const srcRows = await this.#query(
+      `SELECT * FROM ${this.#t("fs_entries")} WHERE path = $1`,
+      [srcPrefixed]
+    );
+    const srcEntry = srcRows[0];
+    if (!srcEntry) {
+      throw new Error(`ENOENT: no such file or directory: ${src}`);
+    }
+    await this.#useTransaction(async (client) => {
+      await this.#ensureParentExists(destPrefixed, client);
+      if (srcEntry.type === "directory") {
+        const allEntriesResult = await client.query(
+          `SELECT * FROM ${this.#t("fs_entries")} WHERE path = $1 OR path LIKE $1 || '/%' ORDER BY path DESC`,
+          [srcPrefixed]
+        );
+        await client.query(
+          `DELETE FROM ${this.#t("fs_entries")} WHERE path = $1 OR path LIKE $1 || '/%'`,
+          [destPrefixed]
+        );
+        for (const entry of [...allEntriesResult.rows].reverse()) {
+          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)
+             ON CONFLICT (path) DO UPDATE SET type = EXCLUDED.type, mode = EXCLUDED.mode, size = EXCLUDED.size, mtime = EXCLUDED.mtime, symlink_target = EXCLUDED.symlink_target`,
+            [
+              newPath,
+              entry.type,
+              entry.mode,
+              entry.size,
+              Date.now(),
+              entry.symlink_target
+            ]
+          );
+          if (entry.type === "file") {
+            await client.query(
+              `DELETE FROM ${this.#t("fs_chunks")} WHERE path = $1`,
+              [newPath]
+            );
+            const chunksResult = await client.query(
+              `SELECT chunk_index, data FROM ${this.#t("fs_chunks")} WHERE path = $1`,
+              [entry.path]
+            );
+            for (const chunk of chunksResult.rows) {
+              await client.query(
+                `INSERT INTO ${this.#t("fs_chunks")} (path, chunk_index, data) VALUES ($1, $2, $3)`,
+                [newPath, chunk.chunk_index, chunk.data]
+              );
+            }
+          }
+        }
+        await client.query(
+          `DELETE FROM ${this.#t("fs_entries")} WHERE path = $1 OR path LIKE $1 || '/%'`,
+          [srcPrefixed]
+        );
+      } else {
+        await client.query(
+          `INSERT INTO ${this.#t("fs_entries")} (path, type, mode, size, mtime, symlink_target)
+           VALUES ($1, $2, $3, $4, $5, $6)
+           ON CONFLICT (path) DO UPDATE SET type = EXCLUDED.type, mode = EXCLUDED.mode, size = EXCLUDED.size, mtime = EXCLUDED.mtime, symlink_target = EXCLUDED.symlink_target`,
+          [
+            destPrefixed,
+            srcEntry.type,
+            srcEntry.mode,
+            srcEntry.size,
+            Date.now(),
+            srcEntry.symlink_target
+          ]
+        );
+        if (srcEntry.type === "file") {
+          await client.query(
+            `DELETE FROM ${this.#t("fs_chunks")} WHERE path = $1`,
+            [destPrefixed]
+          );
+          const chunksResult = await client.query(
+            `SELECT chunk_index, data FROM ${this.#t("fs_chunks")} WHERE path = $1`,
+            [srcPrefixed]
+          );
+          for (const chunk of chunksResult.rows) {
+            await client.query(
+              `INSERT INTO ${this.#t("fs_chunks")} (path, chunk_index, data) VALUES ($1, $2, $3)`,
+              [destPrefixed, chunk.chunk_index, chunk.data]
+            );
+          }
+        }
+        await client.query(
+          `DELETE FROM ${this.#t("fs_entries")} WHERE path = $1`,
+          [srcPrefixed]
+        );
+      }
+    });
+  }
+  resolvePath(base, relativePath) {
+    return path5.posix.resolve(base, relativePath);
+  }
+  getAllPaths() {
+    throw new Error(
+      "getAllPaths() is not supported in PostgresFs - use getAllPathsAsync() instead"
+    );
+  }
+  async getAllPathsAsync() {
+    const rows = await this.#query(
+      `SELECT path FROM ${this.#t("fs_entries")} ORDER BY path`
+    );
+    return rows.map((row) => row.path);
+  }
+  async realpath(filePath) {
+    const normalized = this.#normalizePath(filePath);
+    const prefixed = this.#prefixPath(normalized);
+    const resolved = await this.#resolveSymlink(prefixed);
+    const rows = await this.#query(
+      `SELECT EXISTS(SELECT 1 FROM ${this.#t("fs_entries")} WHERE path = $1) AS exists`,
+      [resolved]
+    );
+    if (!rows[0].exists) {
+      throw new Error(`ENOENT: no such file or directory: ${filePath}`);
+    }
+    return this.#unprefixPath(resolved);
+  }
+  async utimes(filePath, _atime, mtime) {
+    const normalized = this.#normalizePath(filePath);
+    const prefixed = this.#prefixPath(normalized);
+    const resolved = await this.#resolveSymlink(prefixed);
+    const result = await this.#exec(
+      `UPDATE ${this.#t("fs_entries")} SET mtime = $1 WHERE path = $2`,
+      [mtime.getTime(), resolved]
+    );
+    if (result === 0) {
+      throw new Error(`ENOENT: no such file or directory: ${filePath}`);
+    }
+  }
+  async chmod(filePath, mode) {
+    const normalized = this.#normalizePath(filePath);
+    const prefixed = this.#prefixPath(normalized);
+    const result = await this.#exec(
+      `UPDATE ${this.#t("fs_entries")} SET mode = $1 WHERE path = $2`,
+      [mode, prefixed]
+    );
+    if (result === 0) {
+      throw new Error(`ENOENT: no such file or directory: ${filePath}`);
+    }
+  }
+  async symlink(target, linkPath) {
+    const normalized = this.#normalizePath(linkPath);
+    const prefixed = this.#prefixPath(normalized);
+    const existingRows = await this.#query(
+      `SELECT EXISTS(SELECT 1 FROM ${this.#t("fs_entries")} WHERE path = $1) AS exists`,
+      [prefixed]
+    );
+    if (existingRows[0].exists) {
+      throw new Error(`EEXIST: file already exists: ${linkPath}`);
+    }
+    await this.#useTransaction(async (client) => {
+      await this.#ensureParentExists(prefixed, client);
+      await client.query(
+        `INSERT INTO ${this.#t("fs_entries")} (path, type, mode, size, mtime, symlink_target)
+         VALUES ($1, 'symlink', 511, 0, $2, $3)`,
+        [prefixed, Date.now(), target]
+      );
+    });
+  }
+  async link(existingPath, newPath) {
+    const srcNormalized = this.#normalizePath(existingPath);
+    const destNormalized = this.#normalizePath(newPath);
+    const srcPrefixed = this.#prefixPath(srcNormalized);
+    const destPrefixed = this.#prefixPath(destNormalized);
+    const srcRows = await this.#query(
+      `SELECT * FROM ${this.#t("fs_entries")} WHERE path = $1`,
+      [srcPrefixed]
+    );
+    const srcEntry = srcRows[0];
+    if (!srcEntry) {
+      throw new Error(`ENOENT: no such file or directory: ${existingPath}`);
+    }
+    if (srcEntry.type !== "file") {
+      throw new Error(`link: not supported for directories: ${existingPath}`);
+    }
+    const existingRows = await this.#query(
+      `SELECT EXISTS(SELECT 1 FROM ${this.#t("fs_entries")} WHERE path = $1) AS exists`,
+      [destPrefixed]
+    );
+    if (existingRows[0].exists) {
+      throw new Error(`EEXIST: file already exists: ${newPath}`);
+    }
+    await this.#useTransaction(async (client) => {
+      await this.#ensureParentExists(destPrefixed, client);
+      await client.query(
+        `INSERT INTO ${this.#t("fs_entries")} (path, type, mode, size, mtime)
+         VALUES ($1, 'file', $2, $3, $4)`,
+        [destPrefixed, srcEntry.mode, srcEntry.size, Date.now()]
+      );
+      const chunksResult = await client.query(
+        `SELECT chunk_index, data FROM ${this.#t("fs_chunks")} WHERE path = $1`,
+        [srcPrefixed]
+      );
+      for (const chunk of chunksResult.rows) {
+        await client.query(
+          `INSERT INTO ${this.#t("fs_chunks")} (path, chunk_index, data) VALUES ($1, $2, $3)`,
+          [destPrefixed, chunk.chunk_index, chunk.data]
+        );
+      }
+    });
+  }
+  async readlink(linkPath) {
+    const normalized = this.#normalizePath(linkPath);
+    const prefixed = this.#prefixPath(normalized);
+    const rows = await this.#query(
+      `SELECT type, symlink_target FROM ${this.#t("fs_entries")} WHERE path = $1`,
+      [prefixed]
+    );
+    const entry = rows[0];
+    if (!entry) {
+      throw new Error(`ENOENT: no such file or directory: ${linkPath}`);
+    }
+    if (entry.type !== "symlink") {
+      throw new Error(`readlink: not a symbolic link: ${linkPath}`);
+    }
+    return entry.symlink_target;
+  }
+};
+
+// packages/text2sql/src/lib/fs/scoped-fs.ts
+var ScopedFs = class {
+  #base;
+  #prefix;
+  constructor(options) {
+    this.#base = options.base;
+    this.#prefix = options.prefix.replace(/\/$/, "");
+  }
+  #scope(path6) {
+    return `${this.#prefix}${path6}`;
+  }
+  #unscope(path6) {
+    if (path6 === this.#prefix) {
+      return "/";
+    }
+    if (path6.startsWith(this.#prefix + "/")) {
+      return path6.slice(this.#prefix.length) || "/";
+    }
+    return path6;
+  }
+  async writeFile(path6, content, options) {
+    await this.#base.writeFile(this.#scope(path6), content, options);
+  }
+  async appendFile(path6, content, options) {
+    await this.#base.appendFile(this.#scope(path6), content, options);
+  }
+  async mkdir(path6, options) {
+    return this.#base.mkdir(this.#scope(path6), 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);
+  }
+  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 symlink(target, linkPath) {
+    await this.#base.symlink(target, this.#scope(linkPath));
+  }
+  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);
+  }
+  readFileBuffer(path6) {
+    return this.#base.readFileBuffer(this.#scope(path6));
+  }
+  stat(path6) {
+    return this.#base.stat(this.#scope(path6));
+  }
+  lstat(path6) {
+    return this.#base.lstat(this.#scope(path6));
+  }
+  readdir(path6) {
+    return this.#base.readdir(this.#scope(path6));
+  }
+  readdirWithFileTypes(path6) {
+    return this.#base.readdirWithFileTypes(this.#scope(path6));
+  }
+  exists(path6) {
+    return this.#base.exists(this.#scope(path6));
+  }
+  readlink(path6) {
+    return this.#base.readlink(this.#scope(path6));
+  }
+  realpath(path6) {
+    return this.#base.realpath(this.#scope(path6)).then((p) => this.#unscope(p));
+  }
+  utimes(path6, atime, mtime) {
+    return this.#base.utimes(this.#scope(path6), atime, mtime);
+  }
+  resolvePath(base, relativePath) {
+    return this.#base.resolvePath(base, relativePath);
+  }
+  getAllPaths() {
+    const allPaths = this.#base.getAllPaths?.() ?? [];
+    return allPaths.filter((p) => p.startsWith(this.#prefix)).map((p) => p.slice(this.#prefix.length) || "/");
+  }
+};
+
+// packages/text2sql/src/lib/fs/tracked-fs.ts
+var TrackedFs = class {
+  #base;
+  #createdFiles = /* @__PURE__ */ new Set();
+  constructor(base) {
+    this.#base = base;
+  }
+  getCreatedFiles() {
+    return [...this.#createdFiles];
+  }
+  async writeFile(path6, content, options) {
+    await this.#base.writeFile(path6, content, options);
+    this.#createdFiles.add(path6);
+  }
+  async appendFile(path6, content, options) {
+    await this.#base.appendFile(path6, content, options);
+    this.#createdFiles.add(path6);
+  }
+  async mkdir(path6, options) {
+    return this.#base.mkdir(path6, options);
+  }
+  async rm(path6, options) {
+    await this.#base.rm(path6, options);
+    this.#createdFiles.delete(path6);
+    if (options?.recursive) {
+      const prefix = path6.endsWith("/") ? path6 : path6 + "/";
+      for (const file of this.#createdFiles) {
+        if (file.startsWith(prefix)) {
+          this.#createdFiles.delete(file);
+        }
+      }
+    }
+  }
+  async cp(src, dest, options) {
+    await this.#base.cp(src, dest, options);
+    this.#createdFiles.add(dest);
+  }
+  async mv(src, dest) {
+    await this.#base.mv(src, dest);
     this.#createdFiles.delete(src);
     this.#createdFiles.add(dest);
   }
-  async chmod(path5, mode) {
-    return this.#base.chmod(path5, mode);
+  async chmod(path6, mode) {
+    return this.#base.chmod(path6, mode);
   }
   async symlink(target, linkPath) {
     await this.#base.symlink(target, linkPath);
@@ -2914,29 +3826,29 @@ var TrackedFs = class {
     await this.#base.link(existingPath, newPath);
     this.#createdFiles.add(newPath);
   }
-  readFile(path5, options) {
-    return this.#base.readFile(path5, options);
+  readFile(path6, options) {
+    return this.#base.readFile(path6, options);
   }
-  readFileBuffer(path5) {
-    return this.#base.readFileBuffer(path5);
+  readFileBuffer(path6) {
+    return this.#base.readFileBuffer(path6);
   }
-  stat(path5) {
-    return this.#base.stat(path5);
+  stat(path6) {
+    return this.#base.stat(path6);
   }
-  lstat(path5) {
-    return this.#base.lstat(path5);
+  lstat(path6) {
+    return this.#base.lstat(path6);
   }
-  readdir(path5) {
-    return this.#base.readdir(path5);
+  readdir(path6) {
+    return this.#base.readdir(path6);
   }
-  readdirWithFileTypes(path5) {
-    return this.#base.readdirWithFileTypes(path5);
+  readdirWithFileTypes(path6) {
+    return this.#base.readdirWithFileTypes(path6);
   }
-  exists(path5) {
-    return this.#base.exists(path5);
+  exists(path6) {
+    return this.#base.exists(path6);
   }
-  readlink(path5) {
-    return this.#base.readlink(path5);
+  readlink(path6) {
+    return this.#base.readlink(path6);
   }
   resolvePath(base, relativePath) {
     return this.#base.resolvePath(base, relativePath);
@@ -2944,11 +3856,11 @@ var TrackedFs = class {
   getAllPaths() {
     return this.#base.getAllPaths?.() ?? [];
   }
-  realpath(path5) {
-    return this.#base.realpath(path5);
+  realpath(path6) {
+    return this.#base.realpath(path6);
   }
-  utimes(path5, atime, mtime) {
-    return this.#base.utimes(path5, atime, mtime);
+  utimes(path6, atime, mtime) {
+    return this.#base.utimes(path6, atime, mtime);
   }
 };
 
@@ -3433,15 +4345,24 @@ var Text2Sql = class {
     return producer.toPairs();
   }
   async chat(messages) {
+    if (messages.length === 0) {
+      throw new Error("messages must not be empty");
+    }
     const trackedFs = new TrackedFs(this.#config.filesystem);
     const context = this.#config.context(
       ...guidelines(this.#config.teachingsOptions),
       ...await this.index()
     );
-    const userMsg = messages.at(-1);
-    if (userMsg) {
-      context.set(message(userMsg));
+    const lastMessage = messages[messages.length - 1];
+    let assistantMsgId;
+    if (lastMessage.role === "assistant") {
+      context.set(message(lastMessage));
+      await context.save({ branch: false });
+      assistantMsgId = lastMessage.id;
+    } else {
+      context.set(message(lastMessage));
       await context.save();
+      assistantMsgId = generateId();
     }
     const { mounts: skillMounts } = context.getSkillMounts();
     const { tools: tools2 } = await createResultTools({
@@ -3449,7 +4370,6 @@ var Text2Sql = class {
       skillMounts,
       filesystem: trackedFs
     });
-    const assistantMsgId = generateId();
     const chatAgent = agent2({
       name: "text2sql",
       model: this.#config.model,
@@ -3516,40 +4436,6 @@ var Text2Sql = class {
       }
     });
   }
-  async developer(messages) {
-    const context = this.#config.context(
-      ...guidelines(this.#config.teachingsOptions),
-      ...developer_agent_default.fragments,
-      ...await this.index()
-    );
-    const userMsg = messages.at(-1);
-    if (userMsg) {
-      context.set(message(userMsg));
-      await context.save();
-    }
-    const developerAgent = agent2({
-      name: "developer",
-      model: this.#config.model,
-      context,
-      tools: developer_agent_default.tools
-    });
-    const result = await developerAgent.stream({
-      adapter: this.#config.adapter
-    });
-    return result.toUIMessageStream({
-      onError: (error) => this.#formatError(error),
-      sendStart: true,
-      sendFinish: true,
-      sendReasoning: true,
-      sendSources: true,
-      generateMessageId: generateId,
-      onFinish: async ({ responseMessage }) => {
-        context.set(assistant(responseMessage));
-        await context.save();
-        await context.trackUsage(await result.totalUsage);
-      }
-    });
-  }
   #formatError(error) {
     if (NoSuchToolError.isInstance(error)) {
       return "The model tried to call an unknown tool.";
@@ -3571,6 +4457,7 @@ export {
   JsonCache,
   MssqlFs,
   Point,
+  PostgresFs,
   SQLValidationError,
   ScopedFs,
   SqliteFs,