@grepai/cli 0.6.8 → 0.7.0

package/index.js

@@ -13603,7 +13603,7 @@ var require_process = __commonJS((exports, module2) => {
 var require_filesystem = __commonJS((exports, module2) => {
   var fs2 = __require("fs");
   var LDD_PATH = "/usr/bin/ldd";
-  var readFileSync = (path4) => fs2.readFileSync(path4, "utf-8");
+  var readFileSync2 = (path4) => fs2.readFileSync(path4, "utf-8");
   var readFile3 = (path4) => new Promise((resolve4, reject) => {
     fs2.readFile(path4, "utf-8", (err2, data) => {
       if (err2) {
@@ -13615,7 +13615,7 @@ var require_filesystem = __commonJS((exports, module2) => {
   });
   module2.exports = {
     LDD_PATH,
-    readFileSync,
+    readFileSync: readFileSync2,
     readFile: readFile3
   };
 });
@@ -13624,7 +13624,7 @@ var require_filesystem = __commonJS((exports, module2) => {
 var require_detect_libc = __commonJS((exports, module2) => {
   var childProcess = __require("child_process");
   var { isLinux, getReport } = require_process();
-  var { LDD_PATH, readFile: readFile3, readFileSync } = require_filesystem();
+  var { LDD_PATH, readFile: readFile3, readFileSync: readFileSync2 } = require_filesystem();
   var cachedFamilyFilesystem;
   var cachedVersionFilesystem;
   var command = "getconf GNU_LIBC_VERSION 2>&1 || true; ldd --version 2>&1 || true";
@@ -13655,14 +13655,14 @@ var require_detect_libc = __commonJS((exports, module2) => {
   var MUSL = "musl";
   var GLIBC_ON_LDD = GLIBC.toUpperCase();
   var MUSL_ON_LDD = MUSL.toLowerCase();
-  var isFileMusl = (f) => f.includes("libc.musl-") || f.includes("ld-musl-");
+  var isFileMusl2 = (f) => f.includes("libc.musl-") || f.includes("ld-musl-");
   var familyFromReport = () => {
     const report = getReport();
     if (report.header && report.header.glibcVersionRuntime) {
       return GLIBC;
     }
     if (Array.isArray(report.sharedObjects)) {
-      if (report.sharedObjects.some(isFileMusl)) {
+      if (report.sharedObjects.some(isFileMusl2)) {
         return MUSL;
       }
     }
@@ -13704,7 +13704,7 @@ var require_detect_libc = __commonJS((exports, module2) => {
     }
     cachedFamilyFilesystem = null;
     try {
-      const lddContent = readFileSync(LDD_PATH);
+      const lddContent = readFileSync2(LDD_PATH);
       cachedFamilyFilesystem = getFamilyFromLddContent(lddContent);
     } catch (e) {}
     return cachedFamilyFilesystem;
@@ -13759,7 +13759,7 @@ var require_detect_libc = __commonJS((exports, module2) => {
     }
     cachedVersionFilesystem = null;
     try {
-      const lddContent = readFileSync(LDD_PATH);
+      const lddContent = readFileSync2(LDD_PATH);
       const versionMatch = lddContent.match(RE_GLIBC_VERSION);
       if (versionMatch) {
         cachedVersionFilesystem = versionMatch[1];
@@ -13828,9 +13828,9 @@ var require_detect_libc = __commonJS((exports, module2) => {
 // ../../node_modules/.bun/libsql@0.4.7/node_modules/libsql/sqlite-error.js
 var require_sqlite_error = __commonJS((exports, module2) => {
   var descriptor2 = { value: "SqliteError", writable: true, enumerable: false, configurable: true };
-  function SqliteError(message, code2, rawCode) {
-    if (new.target !== SqliteError) {
-      return new SqliteError(message, code2);
+  function SqliteError2(message, code2, rawCode) {
+    if (new.target !== SqliteError2) {
+      return new SqliteError2(message, code2);
     }
     if (typeof code2 !== "string") {
       throw new TypeError("Expected second argument to be a string");
@@ -13838,21 +13838,21 @@ var require_sqlite_error = __commonJS((exports, module2) => {
     Error.call(this, message);
     descriptor2.value = "" + message;
     Object.defineProperty(this, "message", descriptor2);
-    Error.captureStackTrace(this, SqliteError);
+    Error.captureStackTrace(this, SqliteError2);
     this.code = code2;
     this.rawCode = rawCode;
   }
-  Object.setPrototypeOf(SqliteError, Error);
-  Object.setPrototypeOf(SqliteError.prototype, Error.prototype);
-  Object.defineProperty(SqliteError.prototype, "name", descriptor2);
-  module2.exports = SqliteError;
+  Object.setPrototypeOf(SqliteError2, Error);
+  Object.setPrototypeOf(SqliteError2.prototype, Error.prototype);
+  Object.defineProperty(SqliteError2.prototype, "name", descriptor2);
+  module2.exports = SqliteError2;
 });
 
 // ../../node_modules/.bun/libsql@0.4.7/node_modules/libsql/index.js
 var require_libsql = __commonJS((exports, module2) => {
   var { currentTarget } = require_dist2();
   var { familySync, GLIBC } = require_detect_libc();
-  function requireNative() {
+  function requireNative2() {
     let target = currentTarget();
     if (familySync() == GLIBC) {
       switch (target) {
@@ -13886,16 +13886,16 @@ var require_libsql = __commonJS((exports, module2) => {
     statementColumns,
     statementSafeIntegers,
     rowsNext
-  } = requireNative();
-  var SqliteError = require_sqlite_error();
-  function convertError(err2) {
+  } = requireNative2();
+  var SqliteError2 = require_sqlite_error();
+  function convertError2(err2) {
     if (err2.libsqlError) {
-      return new SqliteError(err2.message, err2.code, err2.rawCode);
+      return new SqliteError2(err2.message, err2.code, err2.rawCode);
     }
     return err2;
   }
 
-  class Database {
+  class Database5 {
     constructor(path4, opts) {
       const encryptionCipher = opts?.encryptionCipher ?? "aes256cbc";
       if (opts && opts.syncUrl) {
@@ -13937,9 +13937,9 @@ var require_libsql = __commonJS((exports, module2) => {
     prepare(sql) {
       try {
         const stmt = databasePrepareSync.call(this.db, sql);
-        return new Statement(stmt);
+        return new Statement4(stmt);
       } catch (err2) {
-        throw convertError(err2);
+        throw convertError2(err2);
       }
     }
     transaction(fn) {
@@ -14032,7 +14032,7 @@ var require_libsql = __commonJS((exports, module2) => {
       try {
         databaseExecSync.call(this.db, sql);
       } catch (err2) {
-        throw convertError(err2);
+        throw convertError2(err2);
       }
     }
     close() {
@@ -14048,7 +14048,7 @@ var require_libsql = __commonJS((exports, module2) => {
     }
   }
 
-  class Statement {
+  class Statement4 {
     constructor(stmt) {
       this.stmt = stmt;
     }
@@ -14067,7 +14067,7 @@ var require_libsql = __commonJS((exports, module2) => {
           return statementRun.call(this.stmt, bindParameters.flat());
         }
       } catch (err2) {
-        throw convertError(err2);
+        throw convertError2(err2);
       }
     }
     get(...bindParameters) {
@@ -14121,8 +14121,8 @@ var require_libsql = __commonJS((exports, module2) => {
       return this;
     }
   }
-  module2.exports = Database;
-  module2.exports.SqliteError = SqliteError;
+  module2.exports = Database5;
+  module2.exports.SqliteError = SqliteError2;
 });
 
 // ../../node_modules/.bun/promise-limit@2.7.0/node_modules/promise-limit/index.js
@@ -17467,10 +17467,10 @@ var require_helper = __commonJS((exports, module2) => {
   var warnStream = process.stderr;
   var S_IRWXG = 56;
   var S_IRWXO = 7;
-  var S_IFMT = 61440;
-  var S_IFREG = 32768;
+  var S_IFMT2 = 61440;
+  var S_IFREG2 = 32768;
   function isRegFile(mode) {
-    return (mode & S_IFMT) == S_IFREG;
+    return (mode & S_IFMT2) == S_IFREG2;
   }
   var fieldNames = ["host", "port", "database", "user", "password"];
   var nrOfFields = fieldNames.length;
@@ -86746,7 +86746,12 @@ var GrepAiConfig = Struct({
   }), optional, withDecodingDefault(() => [])),
   storage: Storage.pipe(annotations2({
     description: "Database backend for storing chunks and embeddings"
-  }))
+  })),
+  experimental__agentFs: Struct({
+    syncMode: Literal2("push", "pull").pipe(optional, withDecodingDefault(() => "pull")),
+    url: String$,
+    authToken: String$
+  }).pipe(optional)
 });
 
 // ../core/src/domain/errors.ts
@@ -101779,8 +101784,2358 @@ function mergeWithinBudgetOrFlush(current, next, config3) {
   return { current: next, outputToAppend: current };
 }
 
-// ../core/src/internal/services/codebase-scanner-fs.ts
+// ../core/src/internal/services/codebase-scanner-agentfs.ts
 import { globSync } from "fs";
+import { connect as connect2 } from "@tursodatabase/sync";
+
+// ../../node_modules/.bun/@tursodatabase+database-common@0.4.4/node_modules/@tursodatabase/database-common/dist/bind.js
+function bindParams(stmt, params) {
+  const len = params?.length;
+  if (len === 0) {
+    return;
+  }
+  if (len === 1) {
+    const param = params[0];
+    if (isPlainObject2(param)) {
+      bindNamedParams(stmt, param);
+      return;
+    }
+    if (Array.isArray(param)) {
+      bindPositionalParams(stmt, [param]);
+      return;
+    }
+    bindValue(stmt, 1, param);
+    return;
+  }
+  bindPositionalParams(stmt, params);
+}
+function isPlainObject2(obj) {
+  if (!obj || typeof obj !== "object")
+    return false;
+  const proto25 = Object.getPrototypeOf(obj);
+  return proto25 === Object.prototype || proto25 === null;
+}
+function bindNamedParams(stmt, paramObj) {
+  const paramCount = stmt.parameterCount();
+  for (let i2 = 1;i2 <= paramCount; i2++) {
+    const paramName = stmt.parameterName(i2);
+    if (paramName) {
+      const key = paramName.substring(1);
+      const value6 = paramObj[key];
+      if (value6 !== undefined) {
+        bindValue(stmt, i2, value6);
+      }
+    }
+  }
+}
+function bindPositionalParams(stmt, params) {
+  let bindIndex = 1;
+  for (let i2 = 0;i2 < params.length; i2++) {
+    const param = params[i2];
+    if (Array.isArray(param)) {
+      for (let j = 0;j < param.length; j++) {
+        bindValue(stmt, bindIndex++, param[j]);
+      }
+    } else {
+      bindValue(stmt, bindIndex++, param);
+    }
+  }
+}
+function bindValue(stmt, index, value6) {
+  stmt.bindAt(index, value6);
+}
+
+// ../../node_modules/.bun/@tursodatabase+database-common@0.4.4/node_modules/@tursodatabase/database-common/dist/sqlite-error.js
+class SqliteError extends Error {
+  name;
+  code;
+  rawCode;
+  constructor(message, code2, rawCode) {
+    super(message);
+    this.name = "SqliteError";
+    this.code = code2;
+    this.rawCode = rawCode;
+    Error.captureStackTrace(this, SqliteError);
+  }
+}
+
+// ../../node_modules/.bun/@tursodatabase+database-common@0.4.4/node_modules/@tursodatabase/database-common/dist/types.js
+var STEP_ROW = 1;
+var STEP_DONE = 2;
+var STEP_IO = 3;
+
+// ../../node_modules/.bun/@tursodatabase+database-common@0.4.4/node_modules/@tursodatabase/database-common/dist/async-lock.js
+class AsyncLock {
+  locked;
+  queue;
+  constructor() {
+    this.locked = false;
+    this.queue = [];
+  }
+  async acquire() {
+    if (!this.locked) {
+      this.locked = true;
+      return Promise.resolve();
+    } else {
+      const block = new Promise((resolve4) => {
+        this.queue.push(resolve4);
+      });
+      return block;
+    }
+  }
+  release() {
+    if (this.locked == false) {
+      throw new Error("invalid state: lock was already unlocked");
+    }
+    const item = this.queue.shift();
+    if (item != null) {
+      this.locked = true;
+      item();
+    } else {
+      this.locked = false;
+    }
+  }
+}
+
+// ../../node_modules/.bun/@tursodatabase+database-common@0.4.4/node_modules/@tursodatabase/database-common/dist/promise.js
+var convertibleErrorTypes = { TypeError };
+var CONVERTIBLE_ERROR_PREFIX = "[TURSO_CONVERT_TYPE]";
+function convertError(err2) {
+  if ((err2.code ?? "").startsWith(CONVERTIBLE_ERROR_PREFIX)) {
+    return createErrorByName(err2.code.substring(CONVERTIBLE_ERROR_PREFIX.length), err2.message);
+  }
+  return new SqliteError(err2.message, err2.code, err2.rawCode);
+}
+function createErrorByName(name21, message) {
+  const ErrorConstructor = convertibleErrorTypes[name21];
+  if (!ErrorConstructor) {
+    throw new Error(`unknown error type ${name21} from Turso`);
+  }
+  return new ErrorConstructor(message);
+}
+
+class Database {
+  name;
+  readonly;
+  open;
+  memory;
+  inTransaction;
+  db;
+  ioStep;
+  execLock;
+  _inTransaction = false;
+  connected = false;
+  constructor(db, ioStep) {
+    this.db = db;
+    this.execLock = new AsyncLock;
+    this.ioStep = ioStep ?? (async () => {});
+    Object.defineProperties(this, {
+      name: { get: () => this.db.path },
+      readonly: { get: () => this.db.readonly },
+      open: { get: () => this.db.open },
+      memory: { get: () => this.db.memory },
+      inTransaction: { get: () => this._inTransaction }
+    });
+  }
+  async connect() {
+    if (this.connected) {
+      return;
+    }
+    await this.db.connectAsync();
+    this.connected = true;
+  }
+  prepare(sql) {
+    if (!sql) {
+      throw new RangeError("The supplied SQL string contains no statements");
+    }
+    try {
+      if (this.connected) {
+        return new Statement(maybeValue(this.db.prepare(sql)), this.db, this.execLock, this.ioStep);
+      } else {
+        return new Statement(maybePromise(() => this.connect().then(() => this.db.prepare(sql))), this.db, this.execLock, this.ioStep);
+      }
+    } catch (err2) {
+      throw convertError(err2);
+    }
+  }
+  transaction(fn) {
+    if (typeof fn !== "function")
+      throw new TypeError("Expected first argument to be a function");
+    const db = this;
+    const wrapTxn = (mode) => {
+      return async (...bindParameters) => {
+        await db.exec("BEGIN " + mode);
+        db._inTransaction = true;
+        try {
+          const result = await fn(...bindParameters);
+          await db.exec("COMMIT");
+          db._inTransaction = false;
+          return result;
+        } catch (err2) {
+          await db.exec("ROLLBACK");
+          db._inTransaction = false;
+          throw err2;
+        }
+      };
+    };
+    const properties = {
+      default: { value: wrapTxn("") },
+      deferred: { value: wrapTxn("DEFERRED") },
+      immediate: { value: wrapTxn("IMMEDIATE") },
+      exclusive: { value: wrapTxn("EXCLUSIVE") },
+      database: { value: this, enumerable: true }
+    };
+    Object.defineProperties(properties.default.value, properties);
+    Object.defineProperties(properties.deferred.value, properties);
+    Object.defineProperties(properties.immediate.value, properties);
+    Object.defineProperties(properties.exclusive.value, properties);
+    return properties.default.value;
+  }
+  async pragma(source, options7) {
+    if (options7 == null)
+      options7 = {};
+    if (typeof source !== "string")
+      throw new TypeError("Expected first argument to be a string");
+    if (typeof options7 !== "object")
+      throw new TypeError("Expected second argument to be an options object");
+    const pragma = `PRAGMA ${source}`;
+    const stmt = this.prepare(pragma);
+    try {
+      const results = await stmt.all();
+      return results;
+    } finally {
+      await stmt.close();
+    }
+  }
+  backup(filename, options7) {
+    throw new Error("not implemented");
+  }
+  serialize(options7) {
+    throw new Error("not implemented");
+  }
+  function(name21, options7, fn) {
+    throw new Error("not implemented");
+  }
+  aggregate(name21, options7) {
+    throw new Error("not implemented");
+  }
+  table(name21, factory) {
+    throw new Error("not implemented");
+  }
+  loadExtension(path4) {
+    throw new Error("not implemented");
+  }
+  maxWriteReplicationIndex() {
+    throw new Error("not implemented");
+  }
+  async exec(sql) {
+    await this.execLock.acquire();
+    const exec2 = this.db.executor(sql);
+    try {
+      while (true) {
+        const stepResult = exec2.stepSync();
+        if (stepResult === STEP_IO) {
+          await this.db.ioLoopAsync();
+          await this.ioStep();
+          continue;
+        }
+        if (stepResult === STEP_DONE) {
+          break;
+        }
+        if (stepResult === STEP_ROW) {
+          continue;
+        }
+      }
+    } finally {
+      exec2.reset();
+      this.execLock.release();
+    }
+  }
+  interrupt() {
+    throw new Error("not implemented");
+  }
+  defaultSafeIntegers(toggle3) {
+    this.db.defaultSafeIntegers(toggle3);
+  }
+  async close() {
+    this.db.close();
+  }
+}
+function maybePromise(arg) {
+  let lazy2 = arg;
+  let promise4 = null;
+  let value6 = null;
+  return {
+    apply(fn) {
+      let previous = lazy2;
+      lazy2 = async () => {
+        const result = await previous();
+        fn(result);
+        return result;
+      };
+    },
+    async resolve() {
+      if (promise4 != null) {
+        return await promise4;
+      }
+      let valueResolve, valueReject;
+      promise4 = new Promise((resolve4, reject) => {
+        valueResolve = (x) => {
+          resolve4(x);
+          value6 = x;
+        };
+        valueReject = reject;
+      });
+      await lazy2().then(valueResolve, valueReject);
+      return await promise4;
+    },
+    must() {
+      if (value6 == null) {
+        throw new Error(`database must be connected before execution the function`);
+      }
+      return value6;
+    }
+  };
+}
+function maybeValue(value6) {
+  return {
+    apply(fn) {
+      fn(value6);
+    },
+    resolve() {
+      return Promise.resolve(value6);
+    },
+    must() {
+      return value6;
+    }
+  };
+}
+
+class Statement {
+  stmt;
+  db;
+  execLock;
+  ioStep;
+  constructor(stmt, db, execLock, ioStep) {
+    this.stmt = stmt;
+    this.db = db;
+    this.execLock = execLock;
+    this.ioStep = ioStep;
+  }
+  raw(raw) {
+    this.stmt.apply((s) => s.raw(raw));
+    return this;
+  }
+  pluck(pluckMode) {
+    this.stmt.apply((s) => s.pluck(pluckMode));
+    return this;
+  }
+  safeIntegers(toggle3) {
+    this.stmt.apply((s) => s.safeIntegers(toggle3));
+    return this;
+  }
+  columns() {
+    return this.stmt.must().columns();
+  }
+  get source() {
+    throw new Error("not implemented");
+  }
+  get reader() {
+    throw new Error("not implemented");
+  }
+  get database() {
+    return this.db;
+  }
+  async run(...bindParameters) {
+    let stmt = await this.stmt.resolve();
+    bindParams(stmt, bindParameters);
+    const totalChangesBefore = this.db.totalChanges();
+    await this.execLock.acquire();
+    try {
+      while (true) {
+        const stepResult = await stmt.stepSync();
+        if (stepResult === STEP_IO) {
+          await this.io();
+          continue;
+        }
+        if (stepResult === STEP_DONE) {
+          break;
+        }
+        if (stepResult === STEP_ROW) {
+          continue;
+        }
+      }
+      const lastInsertRowid = this.db.lastInsertRowid();
+      const changes2 = this.db.totalChanges() === totalChangesBefore ? 0 : this.db.changes();
+      return { changes: changes2, lastInsertRowid };
+    } finally {
+      stmt.reset();
+      this.execLock.release();
+    }
+  }
+  async get(...bindParameters) {
+    let stmt = await this.stmt.resolve();
+    bindParams(stmt, bindParameters);
+    await this.execLock.acquire();
+    let row = undefined;
+    try {
+      while (true) {
+        const stepResult = await stmt.stepSync();
+        if (stepResult === STEP_IO) {
+          await this.io();
+          continue;
+        }
+        if (stepResult === STEP_DONE) {
+          break;
+        }
+        if (stepResult === STEP_ROW && row === undefined) {
+          row = stmt.row();
+          continue;
+        }
+      }
+      return row;
+    } finally {
+      stmt.reset();
+      this.execLock.release();
+    }
+  }
+  async* iterate(...bindParameters) {
+    let stmt = await this.stmt.resolve();
+    bindParams(stmt, bindParameters);
+    await this.execLock.acquire();
+    try {
+      while (true) {
+        const stepResult = await stmt.stepSync();
+        if (stepResult === STEP_IO) {
+          await this.db.ioLoopAsync();
+          continue;
+        }
+        if (stepResult === STEP_DONE) {
+          break;
+        }
+        if (stepResult === STEP_ROW) {
+          yield stmt.row();
+        }
+      }
+    } finally {
+      stmt.reset();
+      this.execLock.release();
+    }
+  }
+  async all(...bindParameters) {
+    let stmt = await this.stmt.resolve();
+    bindParams(stmt, bindParameters);
+    const rows = [];
+    await this.execLock.acquire();
+    try {
+      while (true) {
+        const stepResult = await stmt.stepSync();
+        if (stepResult === STEP_IO) {
+          await this.io();
+          continue;
+        }
+        if (stepResult === STEP_DONE) {
+          break;
+        }
+        if (stepResult === STEP_ROW) {
+          rows.push(stmt.row());
+        }
+      }
+      return rows;
+    } finally {
+      stmt.reset();
+      this.execLock.release();
+    }
+  }
+  async io() {
+    await this.db.ioLoopAsync();
+    await this.ioStep();
+  }
+  interrupt() {
+    throw new Error("not implemented");
+  }
+  bind(...bindParameters) {
+    try {
+      bindParams(this.stmt, bindParameters);
+      return this;
+    } catch (err2) {
+      throw convertError(err2);
+    }
+  }
+  close() {
+    let stmt;
+    try {
+      stmt = this.stmt.must();
+    } catch (e) {
+      return;
+    }
+    stmt.finalize();
+  }
+}
+
+// ../../node_modules/.bun/@tursodatabase+database@0.4.4/node_modules/@tursodatabase/database/index.js
+import { createRequire } from "module";
+var require2 = createRequire(import.meta.url);
+var __dirname2 = new URL(".", import.meta.url).pathname;
+var { readFileSync } = require2("node:fs");
+var nativeBinding = null;
+var loadErrors = [];
+var isMusl = () => {
+  let musl = false;
+  if (process.platform === "linux") {
+    musl = isMuslFromFilesystem();
+    if (musl === null) {
+      musl = isMuslFromReport();
+    }
+    if (musl === null) {
+      musl = isMuslFromChildProcess();
+    }
+  }
+  return musl;
+};
+var isFileMusl = (f) => f.includes("libc.musl-") || f.includes("ld-musl-");
+var isMuslFromFilesystem = () => {
+  try {
+    return readFileSync("/usr/bin/ldd", "utf-8").includes("musl");
+  } catch {
+    return null;
+  }
+};
+var isMuslFromReport = () => {
+  let report = null;
+  if (typeof process.report?.getReport === "function") {
+    process.report.excludeNetwork = true;
+    report = process.report.getReport();
+  }
+  if (!report) {
+    return null;
+  }
+  if (report.header && report.header.glibcVersionRuntime) {
+    return false;
+  }
+  if (Array.isArray(report.sharedObjects)) {
+    if (report.sharedObjects.some(isFileMusl)) {
+      return true;
+    }
+  }
+  return false;
+};
+var isMuslFromChildProcess = () => {
+  try {
+    return require2("child_process").execSync("ldd --version", { encoding: "utf8" }).includes("musl");
+  } catch (e) {
+    return false;
+  }
+};
+function requireNative() {
+  if (process.env.NAPI_RS_NATIVE_LIBRARY_PATH) {
+    try {
+      nativeBinding = require2(process.env.NAPI_RS_NATIVE_LIBRARY_PATH);
+    } catch (err2) {
+      loadErrors.push(err2);
+    }
+  } else if (process.platform === "android") {
+    if (process.arch === "arm64") {
+      try {
+        return require2("./turso.android-arm64.node");
+      } catch (e) {
+        loadErrors.push(e);
+      }
+      try {
+        const binding = require2("@tursodatabase/database-android-arm64");
+        const bindingPackageVersion = require2("@tursodatabase/database-android-arm64/package.json").version;
+        if (bindingPackageVersion !== "0.3.0-pre.4" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+          throw new Error(`Native binding package version mismatch, expected 0.3.0-pre.4 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+        }
+        return binding;
+      } catch (e) {
+        loadErrors.push(e);
+      }
+    } else if (process.arch === "arm") {
+      try {
+        return require2("./turso.android-arm-eabi.node");
+      } catch (e) {
+        loadErrors.push(e);
+      }
+      try {
+        const binding = require2("@tursodatabase/database-android-arm-eabi");
+        const bindingPackageVersion = require2("@tursodatabase/database-android-arm-eabi/package.json").version;
+        if (bindingPackageVersion !== "0.3.0-pre.4" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+          throw new Error(`Native binding package version mismatch, expected 0.3.0-pre.4 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+        }
+        return binding;
+      } catch (e) {
+        loadErrors.push(e);
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on Android ${process.arch}`));
+    }
+  } else if (process.platform === "win32") {
+    if (process.arch === "x64") {
+      try {
+        return require2("./turso.win32-x64-msvc.node");
+      } catch (e) {
+        loadErrors.push(e);
+      }
+      try {
+        const binding = require2("@tursodatabase/database-win32-x64-msvc");
+        const bindingPackageVersion = require2("@tursodatabase/database-win32-x64-msvc/package.json").version;
+        if (bindingPackageVersion !== "0.3.0-pre.4" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+          throw new Error(`Native binding package version mismatch, expected 0.3.0-pre.4 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+        }
+        return binding;
+      } catch (e) {
+        loadErrors.push(e);
+      }
+    } else if (process.arch === "ia32") {
+      try {
+        return require2("./turso.win32-ia32-msvc.node");
+      } catch (e) {
+        loadErrors.push(e);
+      }
+      try {
+        const binding = require2("@tursodatabase/database-win32-ia32-msvc");
+        const bindingPackageVersion = require2("@tursodatabase/database-win32-ia32-msvc/package.json").version;
+        if (bindingPackageVersion !== "0.3.0-pre.4" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+          throw new Error(`Native binding package version mismatch, expected 0.3.0-pre.4 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+        }
+        return binding;
+      } catch (e) {
+        loadErrors.push(e);
+      }
+    } else if (process.arch === "arm64") {
+      try {
+        return require2("./turso.win32-arm64-msvc.node");
+      } catch (e) {
+        loadErrors.push(e);
+      }
+      try {
+        const binding = require2("@tursodatabase/database-win32-arm64-msvc");
+        const bindingPackageVersion = require2("@tursodatabase/database-win32-arm64-msvc/package.json").version;
+        if (bindingPackageVersion !== "0.3.0-pre.4" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+          throw new Error(`Native binding package version mismatch, expected 0.3.0-pre.4 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+        }
+        return binding;
+      } catch (e) {
+        loadErrors.push(e);
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on Windows: ${process.arch}`));
+    }
+  } else if (process.platform === "darwin") {
+    try {
+      return require2("./turso.darwin-universal.node");
+    } catch (e) {
+      loadErrors.push(e);
+    }
+    try {
+      const binding = require2("@tursodatabase/database-darwin-universal");
+      const bindingPackageVersion = require2("@tursodatabase/database-darwin-universal/package.json").version;
+      if (bindingPackageVersion !== "0.3.0-pre.4" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+        throw new Error(`Native binding package version mismatch, expected 0.3.0-pre.4 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+      }
+      return binding;
+    } catch (e) {
+      loadErrors.push(e);
+    }
+    if (process.arch === "x64") {
+      try {
+        return require2("./turso.darwin-x64.node");
+      } catch (e) {
+        loadErrors.push(e);
+      }
+      try {
+        const binding = require2("@tursodatabase/database-darwin-x64");
+        const bindingPackageVersion = require2("@tursodatabase/database-darwin-x64/package.json").version;
+        if (bindingPackageVersion !== "0.3.0-pre.4" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+          throw new Error(`Native binding package version mismatch, expected 0.3.0-pre.4 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+        }
+        return binding;
+      } catch (e) {
+        loadErrors.push(e);
+      }
+    } else if (process.arch === "arm64") {
+      try {
+        return require2("./turso.darwin-arm64.node");
+      } catch (e) {
+        loadErrors.push(e);
+      }
+      try {
+        const binding = require2("@tursodatabase/database-darwin-arm64");
+        const bindingPackageVersion = require2("@tursodatabase/database-darwin-arm64/package.json").version;
+        if (bindingPackageVersion !== "0.3.0-pre.4" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+          throw new Error(`Native binding package version mismatch, expected 0.3.0-pre.4 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+        }
+        return binding;
+      } catch (e) {
+        loadErrors.push(e);
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on macOS: ${process.arch}`));
+    }
+  } else if (process.platform === "freebsd") {
+    if (process.arch === "x64") {
+      try {
+        return require2("./turso.freebsd-x64.node");
+      } catch (e) {
+        loadErrors.push(e);
+      }
+      try {
+        const binding = require2("@tursodatabase/database-freebsd-x64");
+        const bindingPackageVersion = require2("@tursodatabase/database-freebsd-x64/package.json").version;
+        if (bindingPackageVersion !== "0.3.0-pre.4" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+          throw new Error(`Native binding package version mismatch, expected 0.3.0-pre.4 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+        }
+        return binding;
+      } catch (e) {
+        loadErrors.push(e);
+      }
+    } else if (process.arch === "arm64") {
+      try {
+        return require2("./turso.freebsd-arm64.node");
+      } catch (e) {
+        loadErrors.push(e);
+      }
+      try {
+        const binding = require2("@tursodatabase/database-freebsd-arm64");
+        const bindingPackageVersion = require2("@tursodatabase/database-freebsd-arm64/package.json").version;
+        if (bindingPackageVersion !== "0.3.0-pre.4" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+          throw new Error(`Native binding package version mismatch, expected 0.3.0-pre.4 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+        }
+        return binding;
+      } catch (e) {
+        loadErrors.push(e);
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on FreeBSD: ${process.arch}`));
+    }
+  } else if (process.platform === "linux") {
+    if (process.arch === "x64") {
+      if (isMusl()) {
+        try {
+          return require2("./turso.linux-x64-musl.node");
+        } catch (e) {
+          loadErrors.push(e);
+        }
+        try {
+          const binding = require2("@tursodatabase/database-linux-x64-musl");
+          const bindingPackageVersion = require2("@tursodatabase/database-linux-x64-musl/package.json").version;
+          if (bindingPackageVersion !== "0.3.0-pre.4" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+            throw new Error(`Native binding package version mismatch, expected 0.3.0-pre.4 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+          }
+          return binding;
+        } catch (e) {
+          loadErrors.push(e);
+        }
+      } else {
+        try {
+          return require2("./turso.linux-x64-gnu.node");
+        } catch (e) {
+          loadErrors.push(e);
+        }
+        try {
+          const binding = require2("@tursodatabase/database-linux-x64-gnu");
+          const bindingPackageVersion = require2("@tursodatabase/database-linux-x64-gnu/package.json").version;
+          if (bindingPackageVersion !== "0.3.0-pre.4" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+            throw new Error(`Native binding package version mismatch, expected 0.3.0-pre.4 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+          }
+          return binding;
+        } catch (e) {
+          loadErrors.push(e);
+        }
+      }
+    } else if (process.arch === "arm64") {
+      if (isMusl()) {
+        try {
+          return require2("./turso.linux-arm64-musl.node");
+        } catch (e) {
+          loadErrors.push(e);
+        }
+        try {
+          const binding = require2("@tursodatabase/database-linux-arm64-musl");
+          const bindingPackageVersion = require2("@tursodatabase/database-linux-arm64-musl/package.json").version;
+          if (bindingPackageVersion !== "0.3.0-pre.4" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+            throw new Error(`Native binding package version mismatch, expected 0.3.0-pre.4 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+          }
+          return binding;
+        } catch (e) {
+          loadErrors.push(e);
+        }
+      } else {
+        try {
+          return require2("./turso.linux-arm64-gnu.node");
+        } catch (e) {
+          loadErrors.push(e);
+        }
+        try {
+          const binding = require2("@tursodatabase/database-linux-arm64-gnu");
+          const bindingPackageVersion = require2("@tursodatabase/database-linux-arm64-gnu/package.json").version;
+          if (bindingPackageVersion !== "0.3.0-pre.4" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+            throw new Error(`Native binding package version mismatch, expected 0.3.0-pre.4 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+          }
+          return binding;
+        } catch (e) {
+          loadErrors.push(e);
+        }
+      }
+    } else if (process.arch === "arm") {
+      if (isMusl()) {
+        try {
+          return require2("./turso.linux-arm-musleabihf.node");
+        } catch (e) {
+          loadErrors.push(e);
+        }
+        try {
+          const binding = require2("@tursodatabase/database-linux-arm-musleabihf");
+          const bindingPackageVersion = require2("@tursodatabase/database-linux-arm-musleabihf/package.json").version;
+          if (bindingPackageVersion !== "0.3.0-pre.4" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+            throw new Error(`Native binding package version mismatch, expected 0.3.0-pre.4 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+          }
+          return binding;
+        } catch (e) {
+          loadErrors.push(e);
+        }
+      } else {
+        try {
+          return require2("./turso.linux-arm-gnueabihf.node");
+        } catch (e) {
+          loadErrors.push(e);
+        }
+        try {
+          const binding = require2("@tursodatabase/database-linux-arm-gnueabihf");
+          const bindingPackageVersion = require2("@tursodatabase/database-linux-arm-gnueabihf/package.json").version;
+          if (bindingPackageVersion !== "0.3.0-pre.4" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+            throw new Error(`Native binding package version mismatch, expected 0.3.0-pre.4 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+          }
+          return binding;
+        } catch (e) {
+          loadErrors.push(e);
+        }
+      }
+    } else if (process.arch === "riscv64") {
+      if (isMusl()) {
+        try {
+          return require2("./turso.linux-riscv64-musl.node");
+        } catch (e) {
+          loadErrors.push(e);
+        }
+        try {
+          const binding = require2("@tursodatabase/database-linux-riscv64-musl");
+          const bindingPackageVersion = require2("@tursodatabase/database-linux-riscv64-musl/package.json").version;
+          if (bindingPackageVersion !== "0.3.0-pre.4" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+            throw new Error(`Native binding package version mismatch, expected 0.3.0-pre.4 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+          }
+          return binding;
+        } catch (e) {
+          loadErrors.push(e);
+        }
+      } else {
+        try {
+          return require2("./turso.linux-riscv64-gnu.node");
+        } catch (e) {
+          loadErrors.push(e);
+        }
+        try {
+          const binding = require2("@tursodatabase/database-linux-riscv64-gnu");
+          const bindingPackageVersion = require2("@tursodatabase/database-linux-riscv64-gnu/package.json").version;
+          if (bindingPackageVersion !== "0.3.0-pre.4" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+            throw new Error(`Native binding package version mismatch, expected 0.3.0-pre.4 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+          }
+          return binding;
+        } catch (e) {
+          loadErrors.push(e);
+        }
+      }
+    } else if (process.arch === "ppc64") {
+      try {
+        return require2("./turso.linux-ppc64-gnu.node");
+      } catch (e) {
+        loadErrors.push(e);
+      }
+      try {
+        const binding = require2("@tursodatabase/database-linux-ppc64-gnu");
+        const bindingPackageVersion = require2("@tursodatabase/database-linux-ppc64-gnu/package.json").version;
+        if (bindingPackageVersion !== "0.3.0-pre.4" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+          throw new Error(`Native binding package version mismatch, expected 0.3.0-pre.4 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+        }
+        return binding;
+      } catch (e) {
+        loadErrors.push(e);
+      }
+    } else if (process.arch === "s390x") {
+      try {
+        return require2("./turso.linux-s390x-gnu.node");
+      } catch (e) {
+        loadErrors.push(e);
+      }
+      try {
+        const binding = require2("@tursodatabase/database-linux-s390x-gnu");
+        const bindingPackageVersion = require2("@tursodatabase/database-linux-s390x-gnu/package.json").version;
+        if (bindingPackageVersion !== "0.3.0-pre.4" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+          throw new Error(`Native binding package version mismatch, expected 0.3.0-pre.4 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+        }
+        return binding;
+      } catch (e) {
+        loadErrors.push(e);
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on Linux: ${process.arch}`));
+    }
+  } else if (process.platform === "openharmony") {
+    if (process.arch === "arm64") {
+      try {
+        return require2("./turso.openharmony-arm64.node");
+      } catch (e) {
+        loadErrors.push(e);
+      }
+      try {
+        const binding = require2("@tursodatabase/database-openharmony-arm64");
+        const bindingPackageVersion = require2("@tursodatabase/database-openharmony-arm64/package.json").version;
+        if (bindingPackageVersion !== "0.3.0-pre.4" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+          throw new Error(`Native binding package version mismatch, expected 0.3.0-pre.4 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+        }
+        return binding;
+      } catch (e) {
+        loadErrors.push(e);
+      }
+    } else if (process.arch === "x64") {
+      try {
+        return require2("./turso.openharmony-x64.node");
+      } catch (e) {
+        loadErrors.push(e);
+      }
+      try {
+        const binding = require2("@tursodatabase/database-openharmony-x64");
+        const bindingPackageVersion = require2("@tursodatabase/database-openharmony-x64/package.json").version;
+        if (bindingPackageVersion !== "0.3.0-pre.4" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+          throw new Error(`Native binding package version mismatch, expected 0.3.0-pre.4 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+        }
+        return binding;
+      } catch (e) {
+        loadErrors.push(e);
+      }
+    } else if (process.arch === "arm") {
+      try {
+        return require2("./turso.openharmony-arm.node");
+      } catch (e) {
+        loadErrors.push(e);
+      }
+      try {
+        const binding = require2("@tursodatabase/database-openharmony-arm");
+        const bindingPackageVersion = require2("@tursodatabase/database-openharmony-arm/package.json").version;
+        if (bindingPackageVersion !== "0.3.0-pre.4" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+          throw new Error(`Native binding package version mismatch, expected 0.3.0-pre.4 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+        }
+        return binding;
+      } catch (e) {
+        loadErrors.push(e);
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on OpenHarmony: ${process.arch}`));
+    }
+  } else {
+    loadErrors.push(new Error(`Unsupported OS: ${process.platform}, architecture: ${process.arch}`));
+  }
+}
+nativeBinding = requireNative();
+if (!nativeBinding || process.env.NAPI_RS_FORCE_WASI) {
+  try {
+    nativeBinding = require2("./turso.wasi.cjs");
+  } catch (err2) {
+    if (process.env.NAPI_RS_FORCE_WASI) {
+      loadErrors.push(err2);
+    }
+  }
+  if (!nativeBinding) {
+    try {
+      nativeBinding = require2("@tursodatabase/database-wasm32-wasi");
+    } catch (err2) {
+      if (process.env.NAPI_RS_FORCE_WASI) {
+        loadErrors.push(err2);
+      }
+    }
+  }
+}
+if (!nativeBinding) {
+  if (loadErrors.length > 0) {
+    throw new Error(`Cannot find native binding. ` + `npm has a bug related to optional dependencies (https://github.com/npm/cli/issues/4828). ` + "Please try `npm i` again after removing both package-lock.json and node_modules directory.", { cause: loadErrors });
+  }
+  throw new Error(`Failed to load native binding`);
+}
+var { BatchExecutor, Database: Database3, Statement: Statement3 } = nativeBinding;
+
+// ../../node_modules/.bun/@tursodatabase+database@0.4.4/node_modules/@tursodatabase/database/dist/promise.js
+class Database4 extends Database {
+  constructor(path4, opts = {}) {
+    super(new Database3(path4, opts));
+  }
+}
+
+// ../../node_modules/.bun/agentfs-sdk@0.6.2/node_modules/agentfs-sdk/dist/index_node.js
+import { existsSync, mkdirSync } from "fs";
+
+// ../../node_modules/.bun/agentfs-sdk@0.6.2/node_modules/agentfs-sdk/dist/agentfs.js
+class AgentFSCore {
+  db;
+  kv;
+  fs;
+  tools;
+  constructor(db, kv, fs2, tools) {
+    this.db = db;
+    this.kv = kv;
+    this.fs = fs2;
+    this.tools = tools;
+  }
+  getDatabase() {
+    return this.db;
+  }
+  async close() {
+    await this.db.close();
+  }
+}
+
+// ../../node_modules/.bun/agentfs-sdk@0.6.2/node_modules/agentfs-sdk/dist/kvstore.js
+class KvStore {
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  static async fromDatabase(db) {
+    const kv = new KvStore(db);
+    await kv.initialize();
+    return kv;
+  }
+  async initialize() {
+    await this.db.exec(`
+      CREATE TABLE IF NOT EXISTS kv_store (
+        key TEXT PRIMARY KEY,
+        value TEXT NOT NULL,
+        created_at INTEGER DEFAULT (unixepoch()),
+        updated_at INTEGER DEFAULT (unixepoch())
+      )
+    `);
+    await this.db.exec(`
+      CREATE INDEX IF NOT EXISTS idx_kv_store_created_at
+      ON kv_store(created_at)
+    `);
+  }
+  async set(key, value6) {
+    const serializedValue = JSON.stringify(value6);
+    const stmt = this.db.prepare(`
+      INSERT INTO kv_store (key, value, updated_at)
+      VALUES (?, ?, unixepoch())
+      ON CONFLICT(key) DO UPDATE SET
+        value = excluded.value,
+        updated_at = unixepoch()
+    `);
+    await stmt.run(key, serializedValue);
+  }
+  async get(key) {
+    const stmt = this.db.prepare(`SELECT value FROM kv_store WHERE key = ?`);
+    const row = await stmt.get(key);
+    if (!row) {
+      return;
+    }
+    return JSON.parse(row.value);
+  }
+  async list(prefix) {
+    const stmt = this.db.prepare(`SELECT key, value FROM kv_store WHERE key LIKE ? ESCAPE '\\'`);
+    const escaped = prefix.replace("\\", "\\\\").replace("%", "\\%").replace("_", "\\_");
+    const rows = await stmt.all(escaped + "%");
+    return rows.map((r) => ({ key: r.key, value: JSON.parse(r.value) }));
+  }
+  async delete(key) {
+    const stmt = this.db.prepare(`DELETE FROM kv_store WHERE key = ?`);
+    await stmt.run(key);
+  }
+}
+
+// ../../node_modules/.bun/agentfs-sdk@0.6.2/node_modules/agentfs-sdk/dist/filesystem/interface.js
+var S_IFMT = 61440;
+var S_IFREG = 32768;
+var S_IFDIR = 16384;
+var S_IFLNK = 40960;
+var DEFAULT_FILE_MODE = S_IFREG | 420;
+var DEFAULT_DIR_MODE = S_IFDIR | 493;
+function createStats(data) {
+  return {
+    ...data,
+    isFile: () => (data.mode & S_IFMT) === S_IFREG,
+    isDirectory: () => (data.mode & S_IFMT) === S_IFDIR,
+    isSymbolicLink: () => (data.mode & S_IFMT) === S_IFLNK
+  };
+}
+// ../../node_modules/.bun/agentfs-sdk@0.6.2/node_modules/agentfs-sdk/dist/errors.js
+function createFsError(params) {
+  const { code: code2, syscall, path: path4, message } = params;
+  const base = message ?? code2;
+  const suffix = path4 !== undefined ? ` '${path4}'` : "";
+  const err2 = new Error(`${code2}: ${base}, ${syscall}${suffix}`);
+  err2.code = code2;
+  err2.syscall = syscall;
+  if (path4 !== undefined)
+    err2.path = path4;
+  return err2;
+}
+
+// ../../node_modules/.bun/agentfs-sdk@0.6.2/node_modules/agentfs-sdk/dist/guards.js
+async function getInodeMode(db, ino) {
+  const stmt = db.prepare("SELECT mode FROM fs_inode WHERE ino = ?");
+  const row = await stmt.get(ino);
+  return row?.mode ?? null;
+}
+function isDirMode(mode) {
+  return (mode & S_IFMT) === S_IFDIR;
+}
+async function getInodeModeOrThrow(db, ino, syscall, path4) {
+  const mode = await getInodeMode(db, ino);
+  if (mode === null) {
+    throw createFsError({
+      code: "ENOENT",
+      syscall,
+      path: path4,
+      message: "no such file or directory"
+    });
+  }
+  return mode;
+}
+function assertNotRoot(path4, syscall) {
+  if (path4 === "/") {
+    throw createFsError({
+      code: "EPERM",
+      syscall,
+      path: path4,
+      message: "operation not permitted on root directory"
+    });
+  }
+}
+function normalizeRmOptions(options7) {
+  return {
+    force: options7?.force === true,
+    recursive: options7?.recursive === true
+  };
+}
+function throwENOENTUnlessForce(path4, syscall, force) {
+  if (force)
+    return;
+  throw createFsError({
+    code: "ENOENT",
+    syscall,
+    path: path4,
+    message: "no such file or directory"
+  });
+}
+function assertNotSymlinkMode(mode, syscall, path4) {
+  if ((mode & S_IFMT) === S_IFLNK) {
+    throw createFsError({
+      code: "ENOSYS",
+      syscall,
+      path: path4,
+      message: "symbolic links not supported yet"
+    });
+  }
+}
+async function assertExistingNonDirNonSymlinkInode(db, ino, syscall, fullPathForError) {
+  const mode = await getInodeMode(db, ino);
+  if (mode === null) {
+    throw createFsError({
+      code: "ENOENT",
+      syscall,
+      path: fullPathForError,
+      message: "no such file or directory"
+    });
+  }
+  if (isDirMode(mode)) {
+    throw createFsError({
+      code: "EISDIR",
+      syscall,
+      path: fullPathForError,
+      message: "illegal operation on a directory"
+    });
+  }
+  assertNotSymlinkMode(mode, syscall, fullPathForError);
+}
+async function assertInodeIsDirectory(db, ino, syscall, fullPathForError) {
+  const mode = await getInodeMode(db, ino);
+  if (mode === null) {
+    throw createFsError({
+      code: "ENOENT",
+      syscall,
+      path: fullPathForError,
+      message: "no such file or directory"
+    });
+  }
+  if (!isDirMode(mode)) {
+    throw createFsError({
+      code: "ENOTDIR",
+      syscall,
+      path: fullPathForError,
+      message: "not a directory"
+    });
+  }
+}
+async function assertWritableExistingInode(db, ino, syscall, fullPathForError) {
+  await assertExistingNonDirNonSymlinkInode(db, ino, syscall, fullPathForError);
+}
+async function assertReadableExistingInode(db, ino, syscall, fullPathForError) {
+  await assertExistingNonDirNonSymlinkInode(db, ino, syscall, fullPathForError);
+}
+async function assertReaddirTargetInode(db, ino, fullPathForError) {
+  const syscall = "scandir";
+  const mode = await getInodeMode(db, ino);
+  if (mode === null) {
+    throw createFsError({
+      code: "ENOENT",
+      syscall,
+      path: fullPathForError,
+      message: "no such file or directory"
+    });
+  }
+  assertNotSymlinkMode(mode, syscall, fullPathForError);
+  if (!isDirMode(mode)) {
+    throw createFsError({
+      code: "ENOTDIR",
+      syscall,
+      path: fullPathForError,
+      message: "not a directory"
+    });
+  }
+}
+async function assertUnlinkTargetInode(db, ino, fullPathForError) {
+  const syscall = "unlink";
+  const mode = await getInodeMode(db, ino);
+  if (mode === null) {
+    throw createFsError({
+      code: "ENOENT",
+      syscall,
+      path: fullPathForError,
+      message: "no such file or directory"
+    });
+  }
+  if (isDirMode(mode)) {
+    throw createFsError({
+      code: "EISDIR",
+      syscall,
+      path: fullPathForError,
+      message: "illegal operation on a directory"
+    });
+  }
+  assertNotSymlinkMode(mode, syscall, fullPathForError);
+}
+
+// ../../node_modules/.bun/agentfs-sdk@0.6.2/node_modules/agentfs-sdk/dist/filesystem/agentfs.js
+var DEFAULT_CHUNK_SIZE = 4096;
+
+class AgentFSFile {
+  db;
+  bufferCtor;
+  ino;
+  chunkSize;
+  constructor(db, bufferCtor, ino, chunkSize) {
+    this.db = db;
+    this.bufferCtor = bufferCtor;
+    this.ino = ino;
+    this.chunkSize = chunkSize;
+  }
+  async pread(offset, size11) {
+    const startChunk = Math.floor(offset / this.chunkSize);
+    const endChunk = Math.floor((offset + size11 - 1) / this.chunkSize);
+    const stmt = this.db.prepare(`
+      SELECT chunk_index, data FROM fs_data
+      WHERE ino = ? AND chunk_index >= ? AND chunk_index <= ?
+      ORDER BY chunk_index ASC
+    `);
+    const rows = await stmt.all(this.ino, startChunk, endChunk);
+    const buffers = [];
+    let bytesCollected = 0;
+    const startOffsetInChunk = offset % this.chunkSize;
+    for (const row of rows) {
+      const skip = buffers.length === 0 ? startOffsetInChunk : 0;
+      if (skip >= row.data.length) {
+        continue;
+      }
+      const remaining = size11 - bytesCollected;
+      const take7 = Math.min(row.data.length - skip, remaining);
+      buffers.push(row.data.subarray(skip, skip + take7));
+      bytesCollected += take7;
+    }
+    if (buffers.length === 0) {
+      return this.bufferCtor.alloc(0);
+    }
+    return this.bufferCtor.concat(buffers);
+  }
+  async pwrite(offset, data) {
+    if (data.length === 0) {
+      return;
+    }
+    const sizeStmt = this.db.prepare("SELECT size FROM fs_inode WHERE ino = ?");
+    const sizeRow = await sizeStmt.get(this.ino);
+    const currentSize = sizeRow?.size ?? 0;
+    if (offset > currentSize) {
+      const zeros = this.bufferCtor.alloc(offset - currentSize);
+      await this.writeDataAtOffset(currentSize, zeros);
+    }
+    await this.writeDataAtOffset(offset, data);
+    const newSize = Math.max(currentSize, offset + data.length);
+    const now = Math.floor(Date.now() / 1000);
+    const updateStmt = this.db.prepare("UPDATE fs_inode SET size = ?, mtime = ? WHERE ino = ?");
+    await updateStmt.run(newSize, now, this.ino);
+  }
+  async writeDataAtOffset(offset, data) {
+    const startChunk = Math.floor(offset / this.chunkSize);
+    const endChunk = Math.floor((offset + data.length - 1) / this.chunkSize);
+    for (let chunkIdx = startChunk;chunkIdx <= endChunk; chunkIdx++) {
+      const chunkStart = chunkIdx * this.chunkSize;
+      const chunkEnd = chunkStart + this.chunkSize;
+      const dataStart = Math.max(0, chunkStart - offset);
+      const dataEnd = Math.min(data.length, chunkEnd - offset);
+      const writeOffset = Math.max(0, offset - chunkStart);
+      const selectStmt = this.db.prepare("SELECT data FROM fs_data WHERE ino = ? AND chunk_index = ?");
+      const existingRow = await selectStmt.get(this.ino, chunkIdx);
+      let chunkData;
+      if (existingRow) {
+        chunkData = this.bufferCtor.from(existingRow.data);
+        if (writeOffset + (dataEnd - dataStart) > chunkData.length) {
+          const newChunk = this.bufferCtor.alloc(writeOffset + (dataEnd - dataStart));
+          chunkData.copy(newChunk);
+          chunkData = newChunk;
+        }
+      } else {
+        chunkData = this.bufferCtor.alloc(writeOffset + (dataEnd - dataStart));
+      }
+      data.copy(chunkData, writeOffset, dataStart, dataEnd);
+      const upsertStmt = this.db.prepare(`
+        INSERT INTO fs_data (ino, chunk_index, data) VALUES (?, ?, ?)
+        ON CONFLICT(ino, chunk_index) DO UPDATE SET data = excluded.data
+      `);
+      await upsertStmt.run(this.ino, chunkIdx, chunkData);
+    }
+  }
+  async truncate(newSize) {
+    const sizeStmt = this.db.prepare("SELECT size FROM fs_inode WHERE ino = ?");
+    const sizeRow = await sizeStmt.get(this.ino);
+    const currentSize = sizeRow?.size ?? 0;
+    await this.db.exec("BEGIN");
+    try {
+      if (newSize === 0) {
+        const deleteStmt = this.db.prepare("DELETE FROM fs_data WHERE ino = ?");
+        await deleteStmt.run(this.ino);
+      } else if (newSize < currentSize) {
+        const lastChunkIdx = Math.floor((newSize - 1) / this.chunkSize);
+        const deleteStmt = this.db.prepare("DELETE FROM fs_data WHERE ino = ? AND chunk_index > ?");
+        await deleteStmt.run(this.ino, lastChunkIdx);
+        const offsetInChunk = newSize % this.chunkSize;
+        if (offsetInChunk > 0) {
+          const selectStmt = this.db.prepare("SELECT data FROM fs_data WHERE ino = ? AND chunk_index = ?");
+          const row = await selectStmt.get(this.ino, lastChunkIdx);
+          if (row && row.data.length > offsetInChunk) {
+            const truncatedChunk = row.data.subarray(0, offsetInChunk);
+            const updateStmt2 = this.db.prepare("UPDATE fs_data SET data = ? WHERE ino = ? AND chunk_index = ?");
+            await updateStmt2.run(truncatedChunk, this.ino, lastChunkIdx);
+          }
+        }
+      }
+      const now = Math.floor(Date.now() / 1000);
+      const updateStmt = this.db.prepare("UPDATE fs_inode SET size = ?, mtime = ? WHERE ino = ?");
+      await updateStmt.run(newSize, now, this.ino);
+      await this.db.exec("COMMIT");
+    } catch (e) {
+      await this.db.exec("ROLLBACK");
+      throw e;
+    }
+  }
+  async fsync() {
+    await this.db.exec("PRAGMA synchronous = FULL");
+    await this.db.exec("PRAGMA wal_checkpoint(TRUNCATE)");
+  }
+  async fstat() {
+    const stmt = this.db.prepare(`
+      SELECT ino, mode, nlink, uid, gid, size, atime, mtime, ctime
+      FROM fs_inode WHERE ino = ?
+    `);
+    const row = await stmt.get(this.ino);
+    if (!row) {
+      throw new Error("File handle refers to deleted inode");
+    }
+    return createStats(row);
+  }
+}
+
+class AgentFS {
+  db;
+  bufferCtor;
+  rootIno = 1;
+  chunkSize = DEFAULT_CHUNK_SIZE;
+  constructor(db, b) {
+    this.db = db;
+    this.bufferCtor = b;
+  }
+  static async fromDatabase(db, b) {
+    const fs2 = new AgentFS(db, b ?? Buffer);
+    await fs2.initialize();
+    return fs2;
+  }
+  getChunkSize() {
+    return this.chunkSize;
+  }
+  async initialize() {
+    await this.db.exec(`
+      CREATE TABLE IF NOT EXISTS fs_config (
+        key TEXT PRIMARY KEY,
+        value TEXT NOT NULL
+      )
+    `);
+    await this.db.exec(`
+      CREATE TABLE IF NOT EXISTS fs_inode (
+        ino INTEGER PRIMARY KEY AUTOINCREMENT,
+        mode INTEGER NOT NULL,
+        nlink INTEGER NOT NULL DEFAULT 0,
+        uid INTEGER NOT NULL DEFAULT 0,
+        gid INTEGER NOT NULL DEFAULT 0,
+        size INTEGER NOT NULL DEFAULT 0,
+        atime INTEGER NOT NULL,
+        mtime INTEGER NOT NULL,
+        ctime INTEGER NOT NULL,
+        rdev INTEGER NOT NULL DEFAULT 0,
+        atime_nsec INTEGER NOT NULL DEFAULT 0,
+        mtime_nsec INTEGER NOT NULL DEFAULT 0,
+        ctime_nsec INTEGER NOT NULL DEFAULT 0
+      )
+    `);
+    await this.db.exec(`
+      CREATE TABLE IF NOT EXISTS fs_dentry (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        name TEXT NOT NULL,
+        parent_ino INTEGER NOT NULL,
+        ino INTEGER NOT NULL,
+        UNIQUE(parent_ino, name)
+      )
+    `);
+    await this.db.exec(`
+      CREATE INDEX IF NOT EXISTS idx_fs_dentry_parent
+      ON fs_dentry(parent_ino, name)
+    `);
+    await this.db.exec(`
+      CREATE TABLE IF NOT EXISTS fs_data (
+        ino INTEGER NOT NULL,
+        chunk_index INTEGER NOT NULL,
+        data BLOB NOT NULL,
+        PRIMARY KEY (ino, chunk_index)
+      )
+    `);
+    await this.db.exec(`
+      CREATE TABLE IF NOT EXISTS fs_symlink (
+        ino INTEGER PRIMARY KEY,
+        target TEXT NOT NULL
+      )
+    `);
+    this.chunkSize = await this.ensureRoot();
+  }
+  async ensureRoot() {
+    const configStmt = this.db.prepare("SELECT value FROM fs_config WHERE key = 'chunk_size'");
+    const config3 = await configStmt.get();
+    let chunkSize;
+    if (!config3) {
+      const insertConfigStmt = this.db.prepare(`
+        INSERT INTO fs_config (key, value) VALUES ('chunk_size', ?)
+      `);
+      await insertConfigStmt.run(DEFAULT_CHUNK_SIZE.toString());
+      chunkSize = DEFAULT_CHUNK_SIZE;
+    } else {
+      chunkSize = parseInt(config3.value, 10) || DEFAULT_CHUNK_SIZE;
+    }
+    const schemaVersionStmt = this.db.prepare(`
+      INSERT OR REPLACE INTO fs_config (key, value) VALUES ('schema_version', '0.4')
+    `);
+    await schemaVersionStmt.run();
+    const stmt = this.db.prepare("SELECT ino FROM fs_inode WHERE ino = ?");
+    const root = await stmt.get(this.rootIno);
+    if (!root) {
+      const now = Math.floor(Date.now() / 1000);
+      const insertStmt = this.db.prepare(`
+        INSERT INTO fs_inode (ino, mode, nlink, uid, gid, size, atime, mtime, ctime)
+        VALUES (?, ?, 1, 0, 0, 0, ?, ?, ?)
+      `);
+      await insertStmt.run(this.rootIno, DEFAULT_DIR_MODE, now, now, now);
+    }
+    return chunkSize;
+  }
+  normalizePath(path4) {
+    const normalized = path4.replace(/\/+$/, "") || "/";
+    return normalized.startsWith("/") ? normalized : "/" + normalized;
+  }
+  splitPath(path4) {
+    const normalized = this.normalizePath(path4);
+    if (normalized === "/")
+      return [];
+    return normalized.split("/").filter((p3) => p3);
+  }
+  async resolvePathOrThrow(path4, syscall) {
+    const normalizedPath = this.normalizePath(path4);
+    const ino = await this.resolvePath(normalizedPath);
+    if (ino === null) {
+      throw createFsError({
+        code: "ENOENT",
+        syscall,
+        path: normalizedPath,
+        message: "no such file or directory"
+      });
+    }
+    return { normalizedPath, ino };
+  }
+  async resolvePath(path4) {
+    const normalized = this.normalizePath(path4);
+    if (normalized === "/") {
+      return this.rootIno;
+    }
+    const parts3 = this.splitPath(normalized);
+    let currentIno = this.rootIno;
+    for (const name21 of parts3) {
+      const stmt = this.db.prepare(`
+        SELECT ino FROM fs_dentry
+        WHERE parent_ino = ? AND name = ?
+      `);
+      const result = await stmt.get(currentIno, name21);
+      if (!result) {
+        return null;
+      }
+      currentIno = result.ino;
+    }
+    return currentIno;
+  }
+  async resolveParent(path4) {
+    const normalized = this.normalizePath(path4);
+    if (normalized === "/") {
+      return null;
+    }
+    const parts3 = this.splitPath(normalized);
+    const name21 = parts3[parts3.length - 1];
+    const parentPath = parts3.length === 1 ? "/" : "/" + parts3.slice(0, -1).join("/");
+    const parentIno = await this.resolvePath(parentPath);
+    if (parentIno === null) {
+      return null;
+    }
+    return { parentIno, name: name21 };
+  }
+  async createInode(mode, uid = 0, gid = 0) {
+    const now = Math.floor(Date.now() / 1000);
+    const stmt = this.db.prepare(`
+      INSERT INTO fs_inode (mode, uid, gid, size, atime, mtime, ctime)
+      VALUES (?, ?, ?, 0, ?, ?, ?)
+      RETURNING ino
+    `);
+    const { ino } = await stmt.get(mode, uid, gid, now, now, now);
+    return Number(ino);
+  }
+  async createDentry(parentIno, name21, ino) {
+    const stmt = this.db.prepare(`
+      INSERT INTO fs_dentry (name, parent_ino, ino)
+      VALUES (?, ?, ?)
+    `);
+    await stmt.run(name21, parentIno, ino);
+    const updateStmt = this.db.prepare("UPDATE fs_inode SET nlink = nlink + 1 WHERE ino = ?");
+    await updateStmt.run(ino);
+  }
+  async ensureParentDirs(path4) {
+    const parts3 = this.splitPath(path4);
+    parts3.pop();
+    let currentIno = this.rootIno;
+    for (const name21 of parts3) {
+      const stmt = this.db.prepare(`
+        SELECT ino FROM fs_dentry
+        WHERE parent_ino = ? AND name = ?
+      `);
+      const result = await stmt.get(currentIno, name21);
+      if (!result) {
+        const dirIno = await this.createInode(DEFAULT_DIR_MODE);
+        await this.createDentry(currentIno, name21, dirIno);
+        currentIno = dirIno;
+      } else {
+        await assertInodeIsDirectory(this.db, result.ino, "open", this.normalizePath(path4));
+        currentIno = result.ino;
+      }
+    }
+  }
+  async getLinkCount(ino) {
+    const stmt = this.db.prepare("SELECT nlink FROM fs_inode WHERE ino = ?");
+    const result = await stmt.get(ino);
+    return result?.nlink ?? 0;
+  }
+  async getInodeMode(ino) {
+    const stmt = this.db.prepare("SELECT mode FROM fs_inode WHERE ino = ?");
+    const row = await stmt.get(ino);
+    return row?.mode ?? null;
+  }
+  async writeFile(path4, content, options7) {
+    await this.ensureParentDirs(path4);
+    const ino = await this.resolvePath(path4);
+    const encoding = typeof options7 === "string" ? options7 : options7?.encoding;
+    const normalizedPath = this.normalizePath(path4);
+    if (ino !== null) {
+      await assertWritableExistingInode(this.db, ino, "open", normalizedPath);
+      await this.updateFileContent(ino, content, encoding);
+    } else {
+      const parent = await this.resolveParent(path4);
+      if (!parent) {
+        throw createFsError({
+          code: "ENOENT",
+          syscall: "open",
+          path: normalizedPath,
+          message: "no such file or directory"
+        });
+      }
+      await assertInodeIsDirectory(this.db, parent.parentIno, "open", normalizedPath);
+      const fileIno = await this.createInode(DEFAULT_FILE_MODE);
+      await this.createDentry(parent.parentIno, parent.name, fileIno);
+      await this.updateFileContent(fileIno, content, encoding);
+    }
+  }
+  async updateFileContent(ino, content, encoding) {
+    const buffer3 = typeof content === "string" ? this.bufferCtor.from(content, encoding ?? "utf8") : content;
+    const now = Math.floor(Date.now() / 1000);
+    const deleteStmt = this.db.prepare("DELETE FROM fs_data WHERE ino = ?");
+    await deleteStmt.run(ino);
+    if (buffer3.length > 0) {
+      const stmt = this.db.prepare(`
+        INSERT INTO fs_data (ino, chunk_index, data)
+        VALUES (?, ?, ?)
+      `);
+      let chunkIndex = 0;
+      for (let offset = 0;offset < buffer3.length; offset += this.chunkSize) {
+        const chunk4 = buffer3.subarray(offset, Math.min(offset + this.chunkSize, buffer3.length));
+        await stmt.run(ino, chunkIndex, chunk4);
+        chunkIndex++;
+      }
+    }
+    const updateStmt = this.db.prepare(`
+      UPDATE fs_inode
+      SET size = ?, mtime = ?
+      WHERE ino = ?
+    `);
+    await updateStmt.run(buffer3.length, now, ino);
+  }
+  async readFile(path4, options7) {
+    const encoding = typeof options7 === "string" ? options7 : options7?.encoding;
+    const { normalizedPath, ino } = await this.resolvePathOrThrow(path4, "open");
+    await assertReadableExistingInode(this.db, ino, "open", normalizedPath);
+    const stmt = this.db.prepare(`
+      SELECT data FROM fs_data
+      WHERE ino = ?
+      ORDER BY chunk_index ASC
+    `);
+    const rows = await stmt.all(ino);
+    let combined;
+    if (rows.length === 0) {
+      combined = this.bufferCtor.alloc(0);
+    } else {
+      const buffers = rows.map((row) => row.data);
+      combined = this.bufferCtor.concat(buffers);
+    }
+    const now = Math.floor(Date.now() / 1000);
+    const updateStmt = this.db.prepare("UPDATE fs_inode SET atime = ? WHERE ino = ?");
+    await updateStmt.run(now, ino);
+    if (encoding) {
+      return combined.toString(encoding);
+    }
+    return combined;
+  }
+  async readdir(path4) {
+    const { normalizedPath, ino } = await this.resolvePathOrThrow(path4, "scandir");
+    await assertReaddirTargetInode(this.db, ino, normalizedPath);
+    const stmt = this.db.prepare(`
+      SELECT name FROM fs_dentry
+      WHERE parent_ino = ?
+      ORDER BY name ASC
+    `);
+    const rows = await stmt.all(ino);
+    return rows.map((row) => row.name);
+  }
+  async readdirPlus(path4) {
+    const { normalizedPath, ino } = await this.resolvePathOrThrow(path4, "scandir");
+    await assertReaddirTargetInode(this.db, ino, normalizedPath);
+    const stmt = this.db.prepare(`
+      SELECT d.name, i.ino, i.mode, i.nlink, i.uid, i.gid, i.size, i.atime, i.mtime, i.ctime
+      FROM fs_dentry d
+      JOIN fs_inode i ON d.ino = i.ino
+      WHERE d.parent_ino = ?
+      ORDER BY d.name ASC
+    `);
+    const rows = await stmt.all(ino);
+    return rows.map((row) => ({
+      name: row.name,
+      stats: createStats({
+        ino: row.ino,
+        mode: row.mode,
+        nlink: row.nlink,
+        uid: row.uid,
+        gid: row.gid,
+        size: row.size,
+        atime: row.atime,
+        mtime: row.mtime,
+        ctime: row.ctime
+      })
+    }));
+  }
+  async stat(path4) {
+    const { normalizedPath, ino } = await this.resolvePathOrThrow(path4, "stat");
+    const stmt = this.db.prepare(`
+      SELECT ino, mode, nlink, uid, gid, size, atime, mtime, ctime
+      FROM fs_inode
+      WHERE ino = ?
+    `);
+    const row = await stmt.get(ino);
+    if (!row) {
+      throw createFsError({
+        code: "ENOENT",
+        syscall: "stat",
+        path: normalizedPath,
+        message: "no such file or directory"
+      });
+    }
+    return createStats(row);
+  }
+  async lstat(path4) {
+    return this.stat(path4);
+  }
+  async mkdir(path4) {
+    const normalizedPath = this.normalizePath(path4);
+    const existing = await this.resolvePath(normalizedPath);
+    if (existing !== null) {
+      throw createFsError({
+        code: "EEXIST",
+        syscall: "mkdir",
+        path: normalizedPath,
+        message: "file already exists"
+      });
+    }
+    const parent = await this.resolveParent(normalizedPath);
+    if (!parent) {
+      throw createFsError({
+        code: "ENOENT",
+        syscall: "mkdir",
+        path: normalizedPath,
+        message: "no such file or directory"
+      });
+    }
+    await assertInodeIsDirectory(this.db, parent.parentIno, "mkdir", normalizedPath);
+    const dirIno = await this.createInode(DEFAULT_DIR_MODE);
+    try {
+      await this.createDentry(parent.parentIno, parent.name, dirIno);
+    } catch {
+      throw createFsError({
+        code: "EEXIST",
+        syscall: "mkdir",
+        path: normalizedPath,
+        message: "file already exists"
+      });
+    }
+  }
+  async rmdir(path4) {
+    const normalizedPath = this.normalizePath(path4);
+    assertNotRoot(normalizedPath, "rmdir");
+    const { ino } = await this.resolvePathOrThrow(normalizedPath, "rmdir");
+    const mode = await getInodeModeOrThrow(this.db, ino, "rmdir", normalizedPath);
+    assertNotSymlinkMode(mode, "rmdir", normalizedPath);
+    if ((mode & S_IFMT) !== S_IFDIR) {
+      throw createFsError({
+        code: "ENOTDIR",
+        syscall: "rmdir",
+        path: normalizedPath,
+        message: "not a directory"
+      });
+    }
+    const stmt = this.db.prepare(`
+      SELECT 1 as one FROM fs_dentry
+      WHERE parent_ino = ?
+      LIMIT 1
+    `);
+    const child = await stmt.get(ino);
+    if (child) {
+      throw createFsError({
+        code: "ENOTEMPTY",
+        syscall: "rmdir",
+        path: normalizedPath,
+        message: "directory not empty"
+      });
+    }
+    const parent = await this.resolveParent(normalizedPath);
+    if (!parent) {
+      throw createFsError({
+        code: "EPERM",
+        syscall: "rmdir",
+        path: normalizedPath,
+        message: "operation not permitted"
+      });
+    }
+    await this.removeDentryAndMaybeInode(parent.parentIno, parent.name, ino);
+  }
+  async unlink(path4) {
+    const normalizedPath = this.normalizePath(path4);
+    assertNotRoot(normalizedPath, "unlink");
+    const { ino } = await this.resolvePathOrThrow(normalizedPath, "unlink");
+    await assertUnlinkTargetInode(this.db, ino, normalizedPath);
+    const parent = await this.resolveParent(normalizedPath);
+    const stmt = this.db.prepare(`
+      DELETE FROM fs_dentry
+      WHERE parent_ino = ? AND name = ?
+    `);
+    await stmt.run(parent.parentIno, parent.name);
+    const decrementStmt = this.db.prepare("UPDATE fs_inode SET nlink = nlink - 1 WHERE ino = ?");
+    await decrementStmt.run(ino);
+    const linkCount = await this.getLinkCount(ino);
+    if (linkCount === 0) {
+      const deleteInodeStmt = this.db.prepare("DELETE FROM fs_inode WHERE ino = ?");
+      await deleteInodeStmt.run(ino);
+      const deleteDataStmt = this.db.prepare("DELETE FROM fs_data WHERE ino = ?");
+      await deleteDataStmt.run(ino);
+    }
+  }
+  async rm(path4, options7) {
+    const normalizedPath = this.normalizePath(path4);
+    const { force, recursive } = normalizeRmOptions(options7);
+    assertNotRoot(normalizedPath, "rm");
+    const ino = await this.resolvePath(normalizedPath);
+    if (ino === null) {
+      throwENOENTUnlessForce(normalizedPath, "rm", force);
+      return;
+    }
+    const mode = await getInodeModeOrThrow(this.db, ino, "rm", normalizedPath);
+    assertNotSymlinkMode(mode, "rm", normalizedPath);
+    const parent = await this.resolveParent(normalizedPath);
+    if (!parent) {
+      throw createFsError({
+        code: "EPERM",
+        syscall: "rm",
+        path: normalizedPath,
+        message: "operation not permitted"
+      });
+    }
+    if ((mode & S_IFMT) === S_IFDIR) {
+      if (!recursive) {
+        throw createFsError({
+          code: "EISDIR",
+          syscall: "rm",
+          path: normalizedPath,
+          message: "illegal operation on a directory"
+        });
+      }
+      await this.rmDirContentsRecursive(ino);
+      await this.removeDentryAndMaybeInode(parent.parentIno, parent.name, ino);
+      return;
+    }
+    await this.removeDentryAndMaybeInode(parent.parentIno, parent.name, ino);
+  }
+  async rmDirContentsRecursive(dirIno) {
+    const stmt = this.db.prepare(`
+      SELECT name, ino FROM fs_dentry
+      WHERE parent_ino = ?
+      ORDER BY name ASC
+    `);
+    const children2 = await stmt.all(dirIno);
+    for (const child of children2) {
+      const mode = await this.getInodeMode(child.ino);
+      if (mode === null) {
+        continue;
+      }
+      if ((mode & S_IFMT) === S_IFDIR) {
+        await this.rmDirContentsRecursive(child.ino);
+        await this.removeDentryAndMaybeInode(dirIno, child.name, child.ino);
+      } else {
+        assertNotSymlinkMode(mode, "rm", "<symlink>");
+        await this.removeDentryAndMaybeInode(dirIno, child.name, child.ino);
+      }
+    }
+  }
+  async removeDentryAndMaybeInode(parentIno, name21, ino) {
+    const stmt = this.db.prepare(`
+      DELETE FROM fs_dentry
+      WHERE parent_ino = ? AND name = ?
+    `);
+    await stmt.run(parentIno, name21);
+    const decrementStmt = this.db.prepare("UPDATE fs_inode SET nlink = nlink - 1 WHERE ino = ?");
+    await decrementStmt.run(ino);
+    const linkCount = await this.getLinkCount(ino);
+    if (linkCount === 0) {
+      const deleteInodeStmt = this.db.prepare("DELETE FROM fs_inode WHERE ino = ?");
+      await deleteInodeStmt.run(ino);
+      const deleteDataStmt = this.db.prepare("DELETE FROM fs_data WHERE ino = ?");
+      await deleteDataStmt.run(ino);
+      const deleteSymlinkStmt = this.db.prepare("DELETE FROM fs_symlink WHERE ino = ?");
+      await deleteSymlinkStmt.run(ino);
+    }
+  }
+  async rename(oldPath, newPath) {
+    const oldNormalized = this.normalizePath(oldPath);
+    const newNormalized = this.normalizePath(newPath);
+    if (oldNormalized === newNormalized)
+      return;
+    assertNotRoot(oldNormalized, "rename");
+    assertNotRoot(newNormalized, "rename");
+    const oldParent = await this.resolveParent(oldNormalized);
+    if (!oldParent) {
+      throw createFsError({
+        code: "EPERM",
+        syscall: "rename",
+        path: oldNormalized,
+        message: "operation not permitted"
+      });
+    }
+    const newParent = await this.resolveParent(newNormalized);
+    if (!newParent) {
+      throw createFsError({
+        code: "ENOENT",
+        syscall: "rename",
+        path: newNormalized,
+        message: "no such file or directory"
+      });
+    }
+    await assertInodeIsDirectory(this.db, newParent.parentIno, "rename", newNormalized);
+    await this.db.exec("BEGIN");
+    try {
+      const oldResolved = await this.resolvePathOrThrow(oldNormalized, "rename");
+      const oldIno = oldResolved.ino;
+      const oldMode = await getInodeModeOrThrow(this.db, oldIno, "rename", oldNormalized);
+      assertNotSymlinkMode(oldMode, "rename", oldNormalized);
+      const oldIsDir = (oldMode & S_IFMT) === S_IFDIR;
+      if (oldIsDir && newNormalized.startsWith(oldNormalized + "/")) {
+        throw createFsError({
+          code: "EINVAL",
+          syscall: "rename",
+          path: newNormalized,
+          message: "invalid argument"
+        });
+      }
+      const newIno = await this.resolvePath(newNormalized);
+      if (newIno !== null) {
+        const newMode = await getInodeModeOrThrow(this.db, newIno, "rename", newNormalized);
+        assertNotSymlinkMode(newMode, "rename", newNormalized);
+        const newIsDir = (newMode & S_IFMT) === S_IFDIR;
+        if (newIsDir && !oldIsDir) {
+          throw createFsError({
+            code: "EISDIR",
+            syscall: "rename",
+            path: newNormalized,
+            message: "illegal operation on a directory"
+          });
+        }
+        if (!newIsDir && oldIsDir) {
+          throw createFsError({
+            code: "ENOTDIR",
+            syscall: "rename",
+            path: newNormalized,
+            message: "not a directory"
+          });
+        }
+        if (newIsDir) {
+          const stmt2 = this.db.prepare(`
+            SELECT 1 as one FROM fs_dentry
+            WHERE parent_ino = ?
+            LIMIT 1
+          `);
+          const child = await stmt2.get(newIno);
+          if (child) {
+            throw createFsError({
+              code: "ENOTEMPTY",
+              syscall: "rename",
+              path: newNormalized,
+              message: "directory not empty"
+            });
+          }
+        }
+        await this.removeDentryAndMaybeInode(newParent.parentIno, newParent.name, newIno);
+      }
+      const stmt = this.db.prepare(`
+        UPDATE fs_dentry
+        SET parent_ino = ?, name = ?
+        WHERE parent_ino = ? AND name = ?
+      `);
+      await stmt.run(newParent.parentIno, newParent.name, oldParent.parentIno, oldParent.name);
+      const now = Math.floor(Date.now() / 1000);
+      const updateInodeCtimeStmt = this.db.prepare(`
+        UPDATE fs_inode
+        SET ctime = ?
+        WHERE ino = ?
+      `);
+      await updateInodeCtimeStmt.run(now, oldIno);
+      const updateDirTimesStmt = this.db.prepare(`
+        UPDATE fs_inode
+        SET mtime = ?, ctime = ?
+        WHERE ino = ?
+      `);
+      await updateDirTimesStmt.run(now, now, oldParent.parentIno);
+      if (newParent.parentIno !== oldParent.parentIno) {
+        await updateDirTimesStmt.run(now, now, newParent.parentIno);
+      }
+      await this.db.exec("COMMIT");
+    } catch (e) {
+      await this.db.exec("ROLLBACK");
+      throw e;
+    }
+  }
+  async copyFile(src, dest) {
+    const srcNormalized = this.normalizePath(src);
+    const destNormalized = this.normalizePath(dest);
+    if (srcNormalized === destNormalized) {
+      throw createFsError({
+        code: "EINVAL",
+        syscall: "copyfile",
+        path: destNormalized,
+        message: "invalid argument"
+      });
+    }
+    const { ino: srcIno } = await this.resolvePathOrThrow(srcNormalized, "copyfile");
+    await assertReadableExistingInode(this.db, srcIno, "copyfile", srcNormalized);
+    const stmt = this.db.prepare(`
+      SELECT mode, uid, gid, size FROM fs_inode WHERE ino = ?
+    `);
+    const srcRow = await stmt.get(srcIno);
+    if (!srcRow) {
+      throw createFsError({
+        code: "ENOENT",
+        syscall: "copyfile",
+        path: srcNormalized,
+        message: "no such file or directory"
+      });
+    }
+    const destParent = await this.resolveParent(destNormalized);
+    if (!destParent) {
+      throw createFsError({
+        code: "ENOENT",
+        syscall: "copyfile",
+        path: destNormalized,
+        message: "no such file or directory"
+      });
+    }
+    await assertInodeIsDirectory(this.db, destParent.parentIno, "copyfile", destNormalized);
+    await this.db.exec("BEGIN");
+    try {
+      const now = Math.floor(Date.now() / 1000);
+      const destIno = await this.resolvePath(destNormalized);
+      if (destIno !== null) {
+        const destMode = await getInodeModeOrThrow(this.db, destIno, "copyfile", destNormalized);
+        assertNotSymlinkMode(destMode, "copyfile", destNormalized);
+        if ((destMode & S_IFMT) === S_IFDIR) {
+          throw createFsError({
+            code: "EISDIR",
+            syscall: "copyfile",
+            path: destNormalized,
+            message: "illegal operation on a directory"
+          });
+        }
+        const deleteStmt = this.db.prepare("DELETE FROM fs_data WHERE ino = ?");
+        await deleteStmt.run(destIno);
+        const copyStmt = this.db.prepare(`
+          INSERT INTO fs_data (ino, chunk_index, data)
+          SELECT ?, chunk_index, data
+          FROM fs_data
+          WHERE ino = ?
+          ORDER BY chunk_index ASC
+        `);
+        await copyStmt.run(destIno, srcIno);
+        const updateStmt = this.db.prepare(`
+          UPDATE fs_inode
+          SET mode = ?, uid = ?, gid = ?, size = ?, mtime = ?, ctime = ?
+          WHERE ino = ?
+        `);
+        await updateStmt.run(srcRow.mode, srcRow.uid, srcRow.gid, srcRow.size, now, now, destIno);
+      } else {
+        const destInoCreated = await this.createInode(srcRow.mode, srcRow.uid, srcRow.gid);
+        await this.createDentry(destParent.parentIno, destParent.name, destInoCreated);
+        const copyStmt = this.db.prepare(`
+          INSERT INTO fs_data (ino, chunk_index, data)
+          SELECT ?, chunk_index, data
+          FROM fs_data
+          WHERE ino = ?
+          ORDER BY chunk_index ASC
+        `);
+        await copyStmt.run(destInoCreated, srcIno);
+        const updateStmt = this.db.prepare(`
+          UPDATE fs_inode
+          SET size = ?, mtime = ?, ctime = ?
+          WHERE ino = ?
+        `);
+        await updateStmt.run(srcRow.size, now, now, destInoCreated);
+      }
+      await this.db.exec("COMMIT");
+    } catch (e) {
+      await this.db.exec("ROLLBACK");
+      throw e;
+    }
+  }
+  async symlink(target, linkpath) {
+    const normalizedLinkpath = this.normalizePath(linkpath);
+    const existing = await this.resolvePath(normalizedLinkpath);
+    if (existing !== null) {
+      throw createFsError({
+        code: "EEXIST",
+        syscall: "open",
+        path: normalizedLinkpath,
+        message: "file already exists"
+      });
+    }
+    const parent = await this.resolveParent(normalizedLinkpath);
+    if (!parent) {
+      throw createFsError({
+        code: "ENOENT",
+        syscall: "open",
+        path: normalizedLinkpath,
+        message: "no such file or directory"
+      });
+    }
+    await assertInodeIsDirectory(this.db, parent.parentIno, "open", normalizedLinkpath);
+    const mode = S_IFLNK | 511;
+    const symlinkIno = await this.createInode(mode);
+    await this.createDentry(parent.parentIno, parent.name, symlinkIno);
+    const stmt = this.db.prepare("INSERT INTO fs_symlink (ino, target) VALUES (?, ?)");
+    await stmt.run(symlinkIno, target);
+    const updateStmt = this.db.prepare("UPDATE fs_inode SET size = ? WHERE ino = ?");
+    await updateStmt.run(target.length, symlinkIno);
+  }
+  async readlink(path4) {
+    const { normalizedPath, ino } = await this.resolvePathOrThrow(path4, "open");
+    const mode = await this.getInodeMode(ino);
+    if (mode === null || (mode & S_IFMT) !== S_IFLNK) {
+      throw createFsError({
+        code: "EINVAL",
+        syscall: "open",
+        path: normalizedPath,
+        message: "invalid argument"
+      });
+    }
+    const stmt = this.db.prepare("SELECT target FROM fs_symlink WHERE ino = ?");
+    const row = await stmt.get(ino);
+    if (!row) {
+      throw createFsError({
+        code: "ENOENT",
+        syscall: "open",
+        path: normalizedPath,
+        message: "no such file or directory"
+      });
+    }
+    return row.target;
+  }
+  async access(path4) {
+    const normalizedPath = this.normalizePath(path4);
+    const ino = await this.resolvePath(normalizedPath);
+    if (ino === null) {
+      throw createFsError({
+        code: "ENOENT",
+        syscall: "access",
+        path: normalizedPath,
+        message: "no such file or directory"
+      });
+    }
+  }
+  async statfs() {
+    const inodeStmt = this.db.prepare("SELECT COUNT(*) as count FROM fs_inode");
+    const inodeRow = await inodeStmt.get();
+    const bytesStmt = this.db.prepare("SELECT COALESCE(SUM(LENGTH(data)), 0) as total FROM fs_data");
+    const bytesRow = await bytesStmt.get();
+    return {
+      inodes: inodeRow.count,
+      bytesUsed: bytesRow.total
+    };
+  }
+  async open(path4) {
+    const { normalizedPath, ino } = await this.resolvePathOrThrow(path4, "open");
+    await assertReadableExistingInode(this.db, ino, "open", normalizedPath);
+    return new AgentFSFile(this.db, this.bufferCtor, ino, this.chunkSize);
+  }
+  async deleteFile(path4) {
+    return await this.unlink(path4);
+  }
+}
+// ../../node_modules/.bun/agentfs-sdk@0.6.2/node_modules/agentfs-sdk/dist/toolcalls.js
+class ToolCalls {
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  static async fromDatabase(db) {
+    const tools = new ToolCalls(db);
+    await tools.initialize();
+    return tools;
+  }
+  async initialize() {
+    await this.db.exec(`
+      CREATE TABLE IF NOT EXISTS tool_calls (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        name TEXT NOT NULL,
+        parameters TEXT,
+        result TEXT,
+        error TEXT,
+        status TEXT NOT NULL DEFAULT 'pending',
+        started_at INTEGER NOT NULL,
+        completed_at INTEGER,
+        duration_ms INTEGER
+      )
+    `);
+    await this.db.exec(`
+      CREATE INDEX IF NOT EXISTS idx_tool_calls_name
+      ON tool_calls(name)
+    `);
+    await this.db.exec(`
+      CREATE INDEX IF NOT EXISTS idx_tool_calls_started_at
+      ON tool_calls(started_at)
+    `);
+  }
+  async start(name21, parameters) {
+    const serializedParams = parameters !== undefined ? JSON.stringify(parameters) : null;
+    const started_at = Math.floor(Date.now() / 1000);
+    const stmt = this.db.prepare(`
+      INSERT INTO tool_calls (name, parameters, status, started_at)
+      VALUES (?, ?, 'pending', ?)
+      RETURNING id
+    `);
+    const { id: id2 } = await stmt.get(name21, serializedParams, started_at);
+    return Number(id2);
+  }
+  async success(id2, result) {
+    const serializedResult = result !== undefined ? JSON.stringify(result) : null;
+    const completed_at = Math.floor(Date.now() / 1000);
+    const getStmt = this.db.prepare("SELECT started_at FROM tool_calls WHERE id = ?");
+    const row = await getStmt.get(id2);
+    if (!row) {
+      throw new Error(`Tool call with ID ${id2} not found`);
+    }
+    const duration_ms = (completed_at - row.started_at) * 1000;
+    const updateStmt = this.db.prepare(`
+      UPDATE tool_calls
+      SET status = 'success', result = ?, completed_at = ?, duration_ms = ?
+      WHERE id = ?
+    `);
+    await updateStmt.run(serializedResult, completed_at, duration_ms, id2);
+  }
+  async error(id2, error51) {
+    const completed_at = Math.floor(Date.now() / 1000);
+    const getStmt = this.db.prepare("SELECT started_at FROM tool_calls WHERE id = ?");
+    const row = await getStmt.get(id2);
+    if (!row) {
+      throw new Error(`Tool call with ID ${id2} not found`);
+    }
+    const duration_ms = (completed_at - row.started_at) * 1000;
+    const updateStmt = this.db.prepare(`
+      UPDATE tool_calls
+      SET status = 'error', error = ?, completed_at = ?, duration_ms = ?
+      WHERE id = ?
+    `);
+    await updateStmt.run(error51, completed_at, duration_ms, id2);
+  }
+  async record(name21, started_at, completed_at, parameters, result, error51) {
+    const serializedParams = parameters !== undefined ? JSON.stringify(parameters) : null;
+    const serializedResult = result !== undefined ? JSON.stringify(result) : null;
+    const duration_ms = (completed_at - started_at) * 1000;
+    const status2 = error51 ? "error" : "success";
+    const stmt = this.db.prepare(`
+      INSERT INTO tool_calls (name, parameters, result, error, status, started_at, completed_at, duration_ms)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+      RETURNING id
+    `);
+    const { id: id2 } = await stmt.get(name21, serializedParams, serializedResult, error51 || null, status2, started_at, completed_at, duration_ms);
+    return Number(id2);
+  }
+  async get(id2) {
+    const stmt = this.db.prepare(`
+      SELECT * FROM tool_calls WHERE id = ?
+    `);
+    const row = await stmt.get(id2);
+    if (!row) {
+      return;
+    }
+    return this.rowToToolCall(row);
+  }
+  async getByName(name21, limit) {
+    const limitClause = limit !== undefined ? `LIMIT ${limit}` : "";
+    const stmt = this.db.prepare(`
+      SELECT * FROM tool_calls
+      WHERE name = ?
+      ORDER BY started_at DESC
+      ${limitClause}
+    `);
+    const rows = await stmt.all(name21);
+    return rows.map((row) => this.rowToToolCall(row));
+  }
+  async getRecent(since, limit) {
+    const limitClause = limit !== undefined ? `LIMIT ${limit}` : "";
+    const stmt = this.db.prepare(`
+      SELECT * FROM tool_calls
+      WHERE started_at > ?
+      ORDER BY started_at DESC
+      ${limitClause}
+    `);
+    const rows = await stmt.all(since);
+    return rows.map((row) => this.rowToToolCall(row));
+  }
+  async getStats() {
+    const stmt = this.db.prepare(`
+      SELECT
+        name,
+        COUNT(*) as total_calls,
+        SUM(CASE WHEN status = 'success' THEN 1 ELSE 0 END) as successful,
+        SUM(CASE WHEN status = 'error' THEN 1 ELSE 0 END) as failed,
+        AVG(duration_ms) as avg_duration_ms
+      FROM tool_calls
+      WHERE status != 'pending'
+      GROUP BY name
+      ORDER BY total_calls DESC
+    `);
+    const rows = await stmt.all();
+    return rows.map((row) => ({
+      name: row.name,
+      total_calls: row.total_calls,
+      successful: row.successful,
+      failed: row.failed,
+      avg_duration_ms: row.avg_duration_ms || 0
+    }));
+  }
+  rowToToolCall(row) {
+    return {
+      id: row.id,
+      name: row.name,
+      parameters: row.parameters !== null ? JSON.parse(row.parameters) : undefined,
+      result: row.result !== null ? JSON.parse(row.result) : undefined,
+      error: row.error !== null ? row.error : undefined,
+      status: row.status,
+      started_at: row.started_at,
+      completed_at: row.completed_at !== null ? row.completed_at : undefined,
+      duration_ms: row.duration_ms !== null ? row.duration_ms : undefined
+    };
+  }
+}
+
+// ../../node_modules/.bun/agentfs-sdk@0.6.2/node_modules/agentfs-sdk/dist/index_node.js
+class AgentFS2 extends AgentFSCore {
+  static async open(options7) {
+    const { id: id2, path: path4 } = options7;
+    if (!id2 && !path4) {
+      throw new Error("AgentFS.open() requires at least 'id' or 'path'.");
+    }
+    if (id2 && !/^[a-zA-Z0-9_-]+$/.test(id2)) {
+      throw new Error("Agent ID must contain only alphanumeric characters, hyphens, and underscores");
+    }
+    let dbPath;
+    if (path4) {
+      dbPath = path4;
+    } else {
+      const dir2 = ".agentfs";
+      if (!existsSync(dir2)) {
+        mkdirSync(dir2, { recursive: true });
+      }
+      dbPath = `${dir2}/${id2}.db`;
+    }
+    const db = new Database4(dbPath);
+    await db.connect();
+    return await this.openWith(db);
+  }
+  static async openWith(db) {
+    const [kv, fs2, tools] = await Promise.all([
+      KvStore.fromDatabase(db),
+      AgentFS.fromDatabase(db),
+      ToolCalls.fromDatabase(db)
+    ]);
+    return new AgentFS2(db, kv, fs2, tools);
+  }
+}
 
 // ../core/src/domain/codebase-scanner.ts
 class CodebaseScanner extends Tag2("@grepai/core/domain/codebase-scanner/CodebaseScanner")() {
@@ -101790,14 +104145,143 @@ class CodebaseScanner extends Tag2("@grepai/core/domain/codebase-scanner/Codebas
 class DocumentStorage extends Tag2("@grepai/core/domain/document-storage/DocumentStorage")() {
 }
 
+// ../core/src/internal/services/codebase-scanner-agentfs.ts
+var CodebaseScannerAgentFs = scoped3(CodebaseScanner, gen2(function* () {
+  const fs2 = yield* exports_FileSystem.FileSystem;
+  const path4 = yield* exports_Path.Path;
+  const config3 = yield* Config;
+  const documentStorage = yield* DocumentStorage;
+  if (!config3.experimental__agentFs) {
+    return yield* new CodebaseScannerError({
+      cause: "`experimental__agentFs` is not enabled."
+    });
+  }
+  const { authToken, url: url3, syncMode } = config3.experimental__agentFs;
+  const baseAgentFsLocalPath = path4.resolve(config3.cwd, "./.grepai/agentfs");
+  yield* fs2.makeDirectory(baseAgentFsLocalPath, { recursive: true });
+  const db = yield* tryPromise2({
+    try: async () => {
+      const db2 = await connect2({
+        path: path4.join(baseAgentFsLocalPath, "local.db"),
+        url: url3,
+        authToken,
+        clientName: "grepai"
+      });
+      if (syncMode === "pull") {
+        await db2.pull();
+      }
+      return db2;
+    },
+    catch: (cause2) => new CodebaseScannerError({ cause: cause2 })
+  });
+  const agentFs = yield* tryPromise2({
+    try: () => AgentFS2.openWith(db),
+    catch: (cause2) => new CodebaseScannerError({ cause: cause2 })
+  });
+  yield* addFinalizer3(() => promise2(() => agentFs.close()));
+  const useAgentFs = (f) => tryPromise2({
+    try: () => f(agentFs),
+    catch: (cause2) => new CodebaseScannerError({ cause: cause2 })
+  });
+  function withLanguageOption(filePath) {
+    return value5(filePath.split(".").at(-1) ?? "").pipe(when5("ts", () => ({
+      filePath,
+      language: "typescript"
+    })), when5("tsx", () => ({
+      filePath,
+      language: "tsx"
+    })), option4);
+  }
+  const toScanResults = fnUntraced2(function* (files) {
+    const fileMap = fromIterableBy(files, ({ filePath }) => filePath);
+    const documents = yield* documentStorage.getAll();
+    const documentMap = fromIterableBy(documents, ({ filePath }) => filePath);
+    const newFiles = filter3(files, ({ filePath }) => !documentMap[filePath]);
+    const modified = filter3(files, ({ filePath, hash: hash3 }) => !!documentMap[filePath] && documentMap[filePath].hash !== hash3);
+    const unchanged = filter3(files, ({ filePath, hash: hash3 }) => !!documentMap[filePath] && documentMap[filePath].hash === hash3);
+    const deleted = filter3(documents, ({ filePath }) => !fileMap[filePath]);
+    return {
+      new: newFiles,
+      unchanged,
+      modified,
+      deleted
+    };
+  });
+  const scanFs = fnUntraced2(function* () {
+    const files = yield* try_3({
+      try: () => globSync(config3.include, {
+        cwd: config3.cwd,
+        exclude: config3.exclude.map((pattern2) => {
+          const hasPathSep = pattern2.includes("/") || pattern2.includes("\\");
+          if (!hasPathSep) {
+            return `**/${pattern2}`;
+          }
+          return pattern2;
+        })
+      }),
+      catch: (cause2) => new CodebaseScannerError({ cause: cause2 })
+    }).pipe(map16(filterMap2(withLanguageOption)), flatMap10(forEach5(({ filePath, language }) => fs2.readFileString(filePath).pipe(map16((content) => ({
+      filePath,
+      language,
+      hash: string(content).toString(),
+      content
+    }))))));
+    return yield* toScanResults(files);
+  }, catchTags2({
+    BadArgument: (cause2) => new CodebaseScannerError({ cause: cause2 }),
+    SystemError: (cause2) => new CodebaseScannerError({ cause: cause2 })
+  }));
+  const readDirRecursiveAgentFs = fnUntraced2(function* (path5 = "/") {
+    const results = [];
+    const entries2 = yield* useAgentFs((a) => a.fs.readdir(path5));
+    yield* forEach5(entries2, (entry) => gen2(function* () {
+      const normalizedPath = path5 === "/" ? "" : path5.replace(/\/$/, "");
+      const normalizedEntry = entry.replace(/^\//, "");
+      const fullPath = normalizedPath + normalizedEntry;
+      const stats = yield* useAgentFs((a) => a.fs.stat(fullPath));
+      if (stats.isDirectory()) {
+        const subFiles = yield* readDirRecursiveAgentFs(fullPath);
+        results.push(...subFiles);
+      } else {
+        results.push(fullPath);
+      }
+    }));
+    return results;
+  });
+  const scanAgentFs = fnUntraced2(function* () {
+    if (syncMode === "push") {
+      const results = yield* scanFs();
+      const { new: newFiles, modified, deleted } = results;
+      yield* forEach5([...newFiles, ...modified], ({ filePath, content }) => useAgentFs((a) => a.fs.writeFile(filePath, content)));
+      yield* forEach5(deleted, ({ filePath }) => useAgentFs((a) => a.fs.deleteFile(filePath)));
+      yield* tryPromise2({
+        try: () => db.push(),
+        catch: (cause2) => new CodebaseScannerError({ cause: cause2 })
+      });
+      return results;
+    }
+    const files = yield* readDirRecursiveAgentFs().pipe(map16(filterMap2(withLanguageOption)), flatMap10(forEach5(({ filePath, language }) => useAgentFs((a) => a.fs.readFile(filePath, { encoding: "utf-8" })).pipe(map16((content) => ({
+      filePath,
+      language,
+      hash: string(content).toString(),
+      content
+    }))))));
+    return yield* toScanResults(files);
+  });
+  return CodebaseScanner.of({
+    scan: scanAgentFs
+  });
+}));
+
 // ../core/src/internal/services/codebase-scanner-fs.ts
+import { globSync as globSync2 } from "fs";
 var CodebaseScannerFs = effect(CodebaseScanner, gen2(function* () {
   const fs2 = yield* exports_FileSystem.FileSystem;
   const config3 = yield* Config;
   const documentStorage = yield* DocumentStorage;
   const scan2 = fnUntraced2(function* () {
     const files = yield* try_3({
-      try: () => globSync(config3.include, {
+      try: () => globSync2(config3.include, {
         cwd: config3.cwd,
         exclude: config3.exclude.map((pattern2) => {
           const hasPathSep = pattern2.includes("/") || pattern2.includes("\\");
@@ -107820,7 +110304,8 @@ var GrepAiLive = unwrapEffect2(gen2(function* () {
   const DocumentStorageLive = value5(config3.storage.type).pipe(when5("turso", () => DocumentStorageSql.pipe(provide3(StorageSqlLiveLazy()))), when5("postgres", () => DocumentStorageSql.pipe(provide3(StorageSqlLiveLazy()))), when5("lancedb", () => DocumentStorageLanceDb.pipe(provide3(StorageLanceDbLiveLazy()))), exhaustive2);
   const ChunkStorageLive = value5(config3.storage.type).pipe(when5("turso", () => ChunkStorageSql.pipe(provide3(StorageSqlLiveLazy()))), when5("postgres", () => ChunkStorageSql.pipe(provide3(StorageSqlLiveLazy()))), when5("lancedb", () => ChunkStorageLanceDb.pipe(provide3(StorageLanceDbLiveLazy()))), exhaustive2);
   const FileIndexerLive = value5(config3.storage.type).pipe(when5("turso", () => FileIndexer.Default.pipe(provide3(StorageSqlLiveLazy()))), when5("postgres", () => FileIndexer.Default.pipe(provide3(StorageSqlLiveLazy()))), when5("lancedb", () => FileIndexer.Default), exhaustive2);
-  return Indexer.Default.pipe(provide3(FileIndexerLive), provideMerge2(ChunkStorageLive), provide3(CodebaseScannerFs), provide3(ChunkerAst), provide3(TokenCounterLive.pipe(provide3(exports_FetchHttpClient.layer))), provide3(EmbedderLive.pipe(provide3(EmbeddingNormalizer.Default), provide3(VercelAi.Default))), provide3(DocumentStorageLive));
+  const CodebaseScannerLive = value5(config3.experimental__agentFs).pipe(when5((val) => !!val, () => CodebaseScannerAgentFs), orElse12(() => CodebaseScannerFs));
+  return Indexer.Default.pipe(provide3(FileIndexerLive), provideMerge2(ChunkStorageLive), provide3(CodebaseScannerLive), provide3(ChunkerAst), provide3(TokenCounterLive.pipe(provide3(exports_FetchHttpClient.layer))), provide3(EmbedderLive.pipe(provide3(EmbeddingNormalizer.Default), provide3(VercelAi.Default))), provide3(DocumentStorageLive));
 })).pipe(provideMerge2(ConfigJson));
 
 class GrepAi extends Service()("@grepai/core/internal/services/grep-ai/GrepAi", {
@@ -109649,11 +112134,11 @@ var program = gen2(function* () {
   const command = exports_Command.make("grepai").pipe(exports_Command.withSubcommands([indexCommand, searchCommand]));
   const cli = exports_Command.run(command, {
     name: "GREP AI",
-    version: "v0.6.8"
+    version: "v0.7.0"
   });
   yield* cli(process.argv);
 });
 program.pipe(provide2(mergeAll5(GrepAi.Default).pipe(provideMerge2(Clack.Default), provideMerge2(exports_BunContext.layer))), exports_BunRuntime.runMain);
 
-//# debugId=12BD8BD86AE8435C64756E2164756E21
+//# debugId=039C99EDE759421464756E2164756E21
 //# sourceMappingURL=index.js.map