@polka-codes/cli-shared 0.9.88 → 0.9.89

package/dist/index.js

@@ -15363,7 +15363,7 @@ var init_multipart_parser = __esm(() => {
 
 // ../../node_modules/node-fetch/src/body.js
 import Stream, { PassThrough } from "node:stream";
-import { types as types3, deprecate, promisify } from "node:util";
+import { types as types4, deprecate, promisify } from "node:util";
 import { Buffer as Buffer4 } from "node:buffer";
 
 class Body {
@@ -15375,7 +15375,7 @@ class Body {
       body = null;
     } else if (isURLSearchParameters(body)) {
       body = Buffer4.from(body.toString());
-    } else if (isBlob(body)) {} else if (Buffer4.isBuffer(body)) {} else if (types3.isAnyArrayBuffer(body)) {
+    } else if (isBlob(body)) {} else if (Buffer4.isBuffer(body)) {} else if (types4.isAnyArrayBuffer(body)) {
       body = Buffer4.from(body);
     } else if (ArrayBuffer.isView(body)) {
       body = Buffer4.from(body.buffer, body.byteOffset, body.byteLength);
@@ -15521,7 +15521,7 @@ var pipeline, INTERNALS, clone2 = (instance, highWaterMark) => {
   if (isBlob(body)) {
     return body.type || null;
   }
-  if (Buffer4.isBuffer(body) || types3.isAnyArrayBuffer(body) || ArrayBuffer.isView(body)) {
+  if (Buffer4.isBuffer(body) || types4.isAnyArrayBuffer(body) || ArrayBuffer.isView(body)) {
     return null;
   }
   if (body instanceof FormData2) {
@@ -15578,7 +15578,7 @@ var init_body = __esm(() => {
 });
 
 // ../../node_modules/node-fetch/src/headers.js
-import { types as types4 } from "node:util";
+import { types as types5 } from "node:util";
 import http from "node:http";
 function fromRawHeaders(headers = []) {
   return new Headers2(headers.reduce((result, value, index, array2) => {
@@ -15620,7 +15620,7 @@ var init_headers = __esm(() => {
         for (const [name17, values] of Object.entries(raw)) {
           result.push(...values.map((value) => [name17, value]));
         }
-      } else if (init == null) {} else if (typeof init === "object" && !types4.isBoxedPrimitive(init)) {
+      } else if (init == null) {} else if (typeof init === "object" && !types5.isBoxedPrimitive(init)) {
         const method = init[Symbol.iterator];
         if (method == null) {
           result.push(...Object.entries(init));
@@ -15629,7 +15629,7 @@ var init_headers = __esm(() => {
             throw new TypeError("Header pairs must be iterable");
           }
           result = [...init].map((pair) => {
-            if (typeof pair !== "object" || types4.isBoxedPrimitive(pair)) {
+            if (typeof pair !== "object" || types5.isBoxedPrimitive(pair)) {
               throw new TypeError("Each header pair must be an iterable object");
             }
             return [...pair];
@@ -35104,6 +35104,771 @@ var require_mimeScore = __commonJS((exports, module) => {
   };
 });
 
+// ../../node_modules/better-sqlite3/lib/util.js
+var require_util3 = __commonJS((exports) => {
+  exports.getBooleanOption = (options, key) => {
+    let value = false;
+    if (key in options && typeof (value = options[key]) !== "boolean") {
+      throw new TypeError(`Expected the "${key}" option to be a boolean`);
+    }
+    return value;
+  };
+  exports.cppdb = Symbol();
+  exports.inspect = Symbol.for("nodejs.util.inspect.custom");
+});
+
+// ../../node_modules/better-sqlite3/lib/sqlite-error.js
+var require_sqlite_error = __commonJS((exports, module) => {
+  var descriptor = { value: "SqliteError", writable: true, enumerable: false, configurable: true };
+  function SqliteError(message, code) {
+    if (new.target !== SqliteError) {
+      return new SqliteError(message, code);
+    }
+    if (typeof code !== "string") {
+      throw new TypeError("Expected second argument to be a string");
+    }
+    Error.call(this, message);
+    descriptor.value = "" + message;
+    Object.defineProperty(this, "message", descriptor);
+    Error.captureStackTrace(this, SqliteError);
+    this.code = code;
+  }
+  Object.setPrototypeOf(SqliteError, Error);
+  Object.setPrototypeOf(SqliteError.prototype, Error.prototype);
+  Object.defineProperty(SqliteError.prototype, "name", descriptor);
+  module.exports = SqliteError;
+});
+
+// ../../node_modules/file-uri-to-path/index.js
+var require_file_uri_to_path = __commonJS((exports, module) => {
+  var sep = __require("path").sep || "/";
+  module.exports = fileUriToPath;
+  function fileUriToPath(uri) {
+    if (typeof uri != "string" || uri.length <= 7 || uri.substring(0, 7) != "file://") {
+      throw new TypeError("must pass in a file:// URI to convert to a file path");
+    }
+    var rest = decodeURI(uri.substring(7));
+    var firstSlash = rest.indexOf("/");
+    var host = rest.substring(0, firstSlash);
+    var path = rest.substring(firstSlash + 1);
+    if (host == "localhost")
+      host = "";
+    if (host) {
+      host = sep + sep + host;
+    }
+    path = path.replace(/^(.+)\|/, "$1:");
+    if (sep == "\\") {
+      path = path.replace(/\//g, "\\");
+    }
+    if (/^.+\:/.test(path)) {} else {
+      path = sep + path;
+    }
+    return host + path;
+  }
+});
+
+// ../../node_modules/bindings/bindings.js
+var require_bindings = __commonJS((exports, module) => {
+  var __filename = "/Users/xiliangchen/projects/polka-codes/node_modules/bindings/bindings.js";
+  var fs4 = __require("fs");
+  var path = __require("path");
+  var fileURLToPath = require_file_uri_to_path();
+  var join3 = path.join;
+  var dirname2 = path.dirname;
+  var exists = fs4.accessSync && function(path2) {
+    try {
+      fs4.accessSync(path2);
+    } catch (e2) {
+      return false;
+    }
+    return true;
+  } || fs4.existsSync || path.existsSync;
+  var defaults = {
+    arrow: process.env.NODE_BINDINGS_ARROW || " → ",
+    compiled: process.env.NODE_BINDINGS_COMPILED_DIR || "compiled",
+    platform: process.platform,
+    arch: process.arch,
+    nodePreGyp: "node-v" + process.versions.modules + "-" + process.platform + "-" + process.arch,
+    version: process.versions.node,
+    bindings: "bindings.node",
+    try: [
+      ["module_root", "build", "bindings"],
+      ["module_root", "build", "Debug", "bindings"],
+      ["module_root", "build", "Release", "bindings"],
+      ["module_root", "out", "Debug", "bindings"],
+      ["module_root", "Debug", "bindings"],
+      ["module_root", "out", "Release", "bindings"],
+      ["module_root", "Release", "bindings"],
+      ["module_root", "build", "default", "bindings"],
+      ["module_root", "compiled", "version", "platform", "arch", "bindings"],
+      ["module_root", "addon-build", "release", "install-root", "bindings"],
+      ["module_root", "addon-build", "debug", "install-root", "bindings"],
+      ["module_root", "addon-build", "default", "install-root", "bindings"],
+      ["module_root", "lib", "binding", "nodePreGyp", "bindings"]
+    ]
+  };
+  function bindings(opts) {
+    if (typeof opts == "string") {
+      opts = { bindings: opts };
+    } else if (!opts) {
+      opts = {};
+    }
+    Object.keys(defaults).map(function(i3) {
+      if (!(i3 in opts))
+        opts[i3] = defaults[i3];
+    });
+    if (!opts.module_root) {
+      opts.module_root = exports.getRoot(exports.getFileName());
+    }
+    if (path.extname(opts.bindings) != ".node") {
+      opts.bindings += ".node";
+    }
+    var requireFunc = typeof __webpack_require__ === "function" ? __non_webpack_require__ : __require;
+    var tries = [], i2 = 0, l = opts.try.length, n, b, err;
+    for (;i2 < l; i2++) {
+      n = join3.apply(null, opts.try[i2].map(function(p) {
+        return opts[p] || p;
+      }));
+      tries.push(n);
+      try {
+        b = opts.path ? requireFunc.resolve(n) : requireFunc(n);
+        if (!opts.path) {
+          b.path = n;
+        }
+        return b;
+      } catch (e2) {
+        if (e2.code !== "MODULE_NOT_FOUND" && e2.code !== "QUALIFIED_PATH_RESOLUTION_FAILED" && !/not find/i.test(e2.message)) {
+          throw e2;
+        }
+      }
+    }
+    err = new Error(`Could not locate the bindings file. Tried:
+` + tries.map(function(a) {
+      return opts.arrow + a;
+    }).join(`
+`));
+    err.tries = tries;
+    throw err;
+  }
+  module.exports = exports = bindings;
+  exports.getFileName = function getFileName(calling_file) {
+    var { prepareStackTrace: origPST, stackTraceLimit: origSTL } = Error, dummy = {}, fileName;
+    Error.stackTraceLimit = 10;
+    Error.prepareStackTrace = function(e2, st) {
+      for (var i2 = 0, l = st.length;i2 < l; i2++) {
+        fileName = st[i2].getFileName();
+        if (fileName !== __filename) {
+          if (calling_file) {
+            if (fileName !== calling_file) {
+              return;
+            }
+          } else {
+            return;
+          }
+        }
+      }
+    };
+    Error.captureStackTrace(dummy);
+    dummy.stack;
+    Error.prepareStackTrace = origPST;
+    Error.stackTraceLimit = origSTL;
+    var fileSchema = "file://";
+    if (fileName.indexOf(fileSchema) === 0) {
+      fileName = fileURLToPath(fileName);
+    }
+    return fileName;
+  };
+  exports.getRoot = function getRoot(file2) {
+    var dir = dirname2(file2), prev;
+    while (true) {
+      if (dir === ".") {
+        dir = process.cwd();
+      }
+      if (exists(join3(dir, "package.json")) || exists(join3(dir, "node_modules"))) {
+        return dir;
+      }
+      if (prev === dir) {
+        throw new Error('Could not find module root given file: "' + file2 + '". Do you have a `package.json` file? ');
+      }
+      prev = dir;
+      dir = join3(dir, "..");
+    }
+  };
+});
+
+// ../../node_modules/better-sqlite3/lib/methods/wrappers.js
+var require_wrappers = __commonJS((exports) => {
+  var { cppdb } = require_util3();
+  exports.prepare = function prepare(sql) {
+    return this[cppdb].prepare(sql, this, false);
+  };
+  exports.exec = function exec(sql) {
+    this[cppdb].exec(sql);
+    return this;
+  };
+  exports.close = function close() {
+    this[cppdb].close();
+    return this;
+  };
+  exports.loadExtension = function loadExtension(...args) {
+    this[cppdb].loadExtension(...args);
+    return this;
+  };
+  exports.defaultSafeIntegers = function defaultSafeIntegers(...args) {
+    this[cppdb].defaultSafeIntegers(...args);
+    return this;
+  };
+  exports.unsafeMode = function unsafeMode(...args) {
+    this[cppdb].unsafeMode(...args);
+    return this;
+  };
+  exports.getters = {
+    name: {
+      get: function name() {
+        return this[cppdb].name;
+      },
+      enumerable: true
+    },
+    open: {
+      get: function open() {
+        return this[cppdb].open;
+      },
+      enumerable: true
+    },
+    inTransaction: {
+      get: function inTransaction() {
+        return this[cppdb].inTransaction;
+      },
+      enumerable: true
+    },
+    readonly: {
+      get: function readonly() {
+        return this[cppdb].readonly;
+      },
+      enumerable: true
+    },
+    memory: {
+      get: function memory() {
+        return this[cppdb].memory;
+      },
+      enumerable: true
+    }
+  };
+});
+
+// ../../node_modules/better-sqlite3/lib/methods/transaction.js
+var require_transaction = __commonJS((exports, module) => {
+  var { cppdb } = require_util3();
+  var controllers = new WeakMap;
+  module.exports = function transaction(fn) {
+    if (typeof fn !== "function")
+      throw new TypeError("Expected first argument to be a function");
+    const db2 = this[cppdb];
+    const controller = getController(db2, this);
+    const { apply: apply2 } = Function.prototype;
+    const properties = {
+      default: { value: wrapTransaction(apply2, fn, db2, controller.default) },
+      deferred: { value: wrapTransaction(apply2, fn, db2, controller.deferred) },
+      immediate: { value: wrapTransaction(apply2, fn, db2, controller.immediate) },
+      exclusive: { value: wrapTransaction(apply2, fn, db2, controller.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;
+  };
+  var getController = (db2, self2) => {
+    let controller = controllers.get(db2);
+    if (!controller) {
+      const shared = {
+        commit: db2.prepare("COMMIT", self2, false),
+        rollback: db2.prepare("ROLLBACK", self2, false),
+        savepoint: db2.prepare("SAVEPOINT `\t_bs3.\t`", self2, false),
+        release: db2.prepare("RELEASE `\t_bs3.\t`", self2, false),
+        rollbackTo: db2.prepare("ROLLBACK TO `\t_bs3.\t`", self2, false)
+      };
+      controllers.set(db2, controller = {
+        default: Object.assign({ begin: db2.prepare("BEGIN", self2, false) }, shared),
+        deferred: Object.assign({ begin: db2.prepare("BEGIN DEFERRED", self2, false) }, shared),
+        immediate: Object.assign({ begin: db2.prepare("BEGIN IMMEDIATE", self2, false) }, shared),
+        exclusive: Object.assign({ begin: db2.prepare("BEGIN EXCLUSIVE", self2, false) }, shared)
+      });
+    }
+    return controller;
+  };
+  var wrapTransaction = (apply2, fn, db2, { begin, commit, rollback, savepoint, release, rollbackTo }) => function sqliteTransaction() {
+    let before, after, undo;
+    if (db2.inTransaction) {
+      before = savepoint;
+      after = release;
+      undo = rollbackTo;
+    } else {
+      before = begin;
+      after = commit;
+      undo = rollback;
+    }
+    before.run();
+    try {
+      const result = apply2.call(fn, this, arguments);
+      if (result && typeof result.then === "function") {
+        throw new TypeError("Transaction function cannot return a promise");
+      }
+      after.run();
+      return result;
+    } catch (ex) {
+      if (db2.inTransaction) {
+        undo.run();
+        if (undo !== rollback)
+          after.run();
+      }
+      throw ex;
+    }
+  };
+});
+
+// ../../node_modules/better-sqlite3/lib/methods/pragma.js
+var require_pragma = __commonJS((exports, module) => {
+  var { getBooleanOption, cppdb } = require_util3();
+  module.exports = function pragma(source, options) {
+    if (options == null)
+      options = {};
+    if (typeof source !== "string")
+      throw new TypeError("Expected first argument to be a string");
+    if (typeof options !== "object")
+      throw new TypeError("Expected second argument to be an options object");
+    const simple = getBooleanOption(options, "simple");
+    const stmt = this[cppdb].prepare(`PRAGMA ${source}`, this, true);
+    return simple ? stmt.pluck().get() : stmt.all();
+  };
+});
+
+// ../../node_modules/better-sqlite3/lib/methods/backup.js
+var require_backup = __commonJS((exports, module) => {
+  var fs4 = __require("fs");
+  var path = __require("path");
+  var { promisify: promisify2 } = __require("util");
+  var { cppdb } = require_util3();
+  var fsAccess = promisify2(fs4.access);
+  module.exports = async function backup(filename, options) {
+    if (options == null)
+      options = {};
+    if (typeof filename !== "string")
+      throw new TypeError("Expected first argument to be a string");
+    if (typeof options !== "object")
+      throw new TypeError("Expected second argument to be an options object");
+    filename = filename.trim();
+    const attachedName = "attached" in options ? options.attached : "main";
+    const handler13 = "progress" in options ? options.progress : null;
+    if (!filename)
+      throw new TypeError("Backup filename cannot be an empty string");
+    if (filename === ":memory:")
+      throw new TypeError('Invalid backup filename ":memory:"');
+    if (typeof attachedName !== "string")
+      throw new TypeError('Expected the "attached" option to be a string');
+    if (!attachedName)
+      throw new TypeError('The "attached" option cannot be an empty string');
+    if (handler13 != null && typeof handler13 !== "function")
+      throw new TypeError('Expected the "progress" option to be a function');
+    await fsAccess(path.dirname(filename)).catch(() => {
+      throw new TypeError("Cannot save backup because the directory does not exist");
+    });
+    const isNewFile = await fsAccess(filename).then(() => false, () => true);
+    return runBackup(this[cppdb].backup(this, attachedName, filename, isNewFile), handler13 || null);
+  };
+  var runBackup = (backup, handler13) => {
+    let rate = 0;
+    let useDefault = true;
+    return new Promise((resolve4, reject) => {
+      setImmediate(function step() {
+        try {
+          const progress = backup.transfer(rate);
+          if (!progress.remainingPages) {
+            backup.close();
+            resolve4(progress);
+            return;
+          }
+          if (useDefault) {
+            useDefault = false;
+            rate = 100;
+          }
+          if (handler13) {
+            const ret = handler13(progress);
+            if (ret !== undefined) {
+              if (typeof ret === "number" && ret === ret)
+                rate = Math.max(0, Math.min(2147483647, Math.round(ret)));
+              else
+                throw new TypeError("Expected progress callback to return a number or undefined");
+            }
+          }
+          setImmediate(step);
+        } catch (err) {
+          backup.close();
+          reject(err);
+        }
+      });
+    });
+  };
+});
+
+// ../../node_modules/better-sqlite3/lib/methods/serialize.js
+var require_serialize = __commonJS((exports, module) => {
+  var { cppdb } = require_util3();
+  module.exports = function serialize(options) {
+    if (options == null)
+      options = {};
+    if (typeof options !== "object")
+      throw new TypeError("Expected first argument to be an options object");
+    const attachedName = "attached" in options ? options.attached : "main";
+    if (typeof attachedName !== "string")
+      throw new TypeError('Expected the "attached" option to be a string');
+    if (!attachedName)
+      throw new TypeError('The "attached" option cannot be an empty string');
+    return this[cppdb].serialize(attachedName);
+  };
+});
+
+// ../../node_modules/better-sqlite3/lib/methods/function.js
+var require_function = __commonJS((exports, module) => {
+  var { getBooleanOption, cppdb } = require_util3();
+  module.exports = function defineFunction(name17, options, fn) {
+    if (options == null)
+      options = {};
+    if (typeof options === "function") {
+      fn = options;
+      options = {};
+    }
+    if (typeof name17 !== "string")
+      throw new TypeError("Expected first argument to be a string");
+    if (typeof fn !== "function")
+      throw new TypeError("Expected last argument to be a function");
+    if (typeof options !== "object")
+      throw new TypeError("Expected second argument to be an options object");
+    if (!name17)
+      throw new TypeError("User-defined function name cannot be an empty string");
+    const safeIntegers = "safeIntegers" in options ? +getBooleanOption(options, "safeIntegers") : 2;
+    const deterministic = getBooleanOption(options, "deterministic");
+    const directOnly = getBooleanOption(options, "directOnly");
+    const varargs = getBooleanOption(options, "varargs");
+    let argCount = -1;
+    if (!varargs) {
+      argCount = fn.length;
+      if (!Number.isInteger(argCount) || argCount < 0)
+        throw new TypeError("Expected function.length to be a positive integer");
+      if (argCount > 100)
+        throw new RangeError("User-defined functions cannot have more than 100 arguments");
+    }
+    this[cppdb].function(fn, name17, argCount, safeIntegers, deterministic, directOnly);
+    return this;
+  };
+});
+
+// ../../node_modules/better-sqlite3/lib/methods/aggregate.js
+var require_aggregate = __commonJS((exports, module) => {
+  var { getBooleanOption, cppdb } = require_util3();
+  module.exports = function defineAggregate(name17, options) {
+    if (typeof name17 !== "string")
+      throw new TypeError("Expected first argument to be a string");
+    if (typeof options !== "object" || options === null)
+      throw new TypeError("Expected second argument to be an options object");
+    if (!name17)
+      throw new TypeError("User-defined function name cannot be an empty string");
+    const start = "start" in options ? options.start : null;
+    const step = getFunctionOption(options, "step", true);
+    const inverse = getFunctionOption(options, "inverse", false);
+    const result = getFunctionOption(options, "result", false);
+    const safeIntegers = "safeIntegers" in options ? +getBooleanOption(options, "safeIntegers") : 2;
+    const deterministic = getBooleanOption(options, "deterministic");
+    const directOnly = getBooleanOption(options, "directOnly");
+    const varargs = getBooleanOption(options, "varargs");
+    let argCount = -1;
+    if (!varargs) {
+      argCount = Math.max(getLength(step), inverse ? getLength(inverse) : 0);
+      if (argCount > 0)
+        argCount -= 1;
+      if (argCount > 100)
+        throw new RangeError("User-defined functions cannot have more than 100 arguments");
+    }
+    this[cppdb].aggregate(start, step, inverse, result, name17, argCount, safeIntegers, deterministic, directOnly);
+    return this;
+  };
+  var getFunctionOption = (options, key, required2) => {
+    const value = key in options ? options[key] : null;
+    if (typeof value === "function")
+      return value;
+    if (value != null)
+      throw new TypeError(`Expected the "${key}" option to be a function`);
+    if (required2)
+      throw new TypeError(`Missing required option "${key}"`);
+    return null;
+  };
+  var getLength = ({ length }) => {
+    if (Number.isInteger(length) && length >= 0)
+      return length;
+    throw new TypeError("Expected function.length to be a positive integer");
+  };
+});
+
+// ../../node_modules/better-sqlite3/lib/methods/table.js
+var require_table = __commonJS((exports, module) => {
+  var { cppdb } = require_util3();
+  module.exports = function defineTable(name17, factory) {
+    if (typeof name17 !== "string")
+      throw new TypeError("Expected first argument to be a string");
+    if (!name17)
+      throw new TypeError("Virtual table module name cannot be an empty string");
+    let eponymous = false;
+    if (typeof factory === "object" && factory !== null) {
+      eponymous = true;
+      factory = defer(parseTableDefinition(factory, "used", name17));
+    } else {
+      if (typeof factory !== "function")
+        throw new TypeError("Expected second argument to be a function or a table definition object");
+      factory = wrapFactory(factory);
+    }
+    this[cppdb].table(factory, name17, eponymous);
+    return this;
+  };
+  function wrapFactory(factory) {
+    return function virtualTableFactory(moduleName, databaseName, tableName, ...args) {
+      const thisObject = {
+        module: moduleName,
+        database: databaseName,
+        table: tableName
+      };
+      const def = apply2.call(factory, thisObject, args);
+      if (typeof def !== "object" || def === null) {
+        throw new TypeError(`Virtual table module "${moduleName}" did not return a table definition object`);
+      }
+      return parseTableDefinition(def, "returned", moduleName);
+    };
+  }
+  function parseTableDefinition(def, verb, moduleName) {
+    if (!hasOwnProperty10.call(def, "rows")) {
+      throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition without a "rows" property`);
+    }
+    if (!hasOwnProperty10.call(def, "columns")) {
+      throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition without a "columns" property`);
+    }
+    const rows = def.rows;
+    if (typeof rows !== "function" || Object.getPrototypeOf(rows) !== GeneratorFunctionPrototype) {
+      throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "rows" property (should be a generator function)`);
+    }
+    let columns = def.columns;
+    if (!Array.isArray(columns) || !(columns = [...columns]).every((x2) => typeof x2 === "string")) {
+      throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "columns" property (should be an array of strings)`);
+    }
+    if (columns.length !== new Set(columns).size) {
+      throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with duplicate column names`);
+    }
+    if (!columns.length) {
+      throw new RangeError(`Virtual table module "${moduleName}" ${verb} a table definition with zero columns`);
+    }
+    let parameters;
+    if (hasOwnProperty10.call(def, "parameters")) {
+      parameters = def.parameters;
+      if (!Array.isArray(parameters) || !(parameters = [...parameters]).every((x2) => typeof x2 === "string")) {
+        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "parameters" property (should be an array of strings)`);
+      }
+    } else {
+      parameters = inferParameters(rows);
+    }
+    if (parameters.length !== new Set(parameters).size) {
+      throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with duplicate parameter names`);
+    }
+    if (parameters.length > 32) {
+      throw new RangeError(`Virtual table module "${moduleName}" ${verb} a table definition with more than the maximum number of 32 parameters`);
+    }
+    for (const parameter of parameters) {
+      if (columns.includes(parameter)) {
+        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with column "${parameter}" which was ambiguously defined as both a column and parameter`);
+      }
+    }
+    let safeIntegers = 2;
+    if (hasOwnProperty10.call(def, "safeIntegers")) {
+      const bool = def.safeIntegers;
+      if (typeof bool !== "boolean") {
+        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "safeIntegers" property (should be a boolean)`);
+      }
+      safeIntegers = +bool;
+    }
+    let directOnly = false;
+    if (hasOwnProperty10.call(def, "directOnly")) {
+      directOnly = def.directOnly;
+      if (typeof directOnly !== "boolean") {
+        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "directOnly" property (should be a boolean)`);
+      }
+    }
+    const columnDefinitions = [
+      ...parameters.map(identifier).map((str) => `${str} HIDDEN`),
+      ...columns.map(identifier)
+    ];
+    return [
+      `CREATE TABLE x(${columnDefinitions.join(", ")});`,
+      wrapGenerator(rows, new Map(columns.map((x2, i2) => [x2, parameters.length + i2])), moduleName),
+      parameters,
+      safeIntegers,
+      directOnly
+    ];
+  }
+  function wrapGenerator(generator, columnMap, moduleName) {
+    return function* virtualTable(...args) {
+      const output = args.map((x2) => Buffer.isBuffer(x2) ? Buffer.from(x2) : x2);
+      for (let i2 = 0;i2 < columnMap.size; ++i2) {
+        output.push(null);
+      }
+      for (const row of generator(...args)) {
+        if (Array.isArray(row)) {
+          extractRowArray(row, output, columnMap.size, moduleName);
+          yield output;
+        } else if (typeof row === "object" && row !== null) {
+          extractRowObject(row, output, columnMap, moduleName);
+          yield output;
+        } else {
+          throw new TypeError(`Virtual table module "${moduleName}" yielded something that isn't a valid row object`);
+        }
+      }
+    };
+  }
+  function extractRowArray(row, output, columnCount, moduleName) {
+    if (row.length !== columnCount) {
+      throw new TypeError(`Virtual table module "${moduleName}" yielded a row with an incorrect number of columns`);
+    }
+    const offset = output.length - columnCount;
+    for (let i2 = 0;i2 < columnCount; ++i2) {
+      output[i2 + offset] = row[i2];
+    }
+  }
+  function extractRowObject(row, output, columnMap, moduleName) {
+    let count = 0;
+    for (const key of Object.keys(row)) {
+      const index = columnMap.get(key);
+      if (index === undefined) {
+        throw new TypeError(`Virtual table module "${moduleName}" yielded a row with an undeclared column "${key}"`);
+      }
+      output[index] = row[key];
+      count += 1;
+    }
+    if (count !== columnMap.size) {
+      throw new TypeError(`Virtual table module "${moduleName}" yielded a row with missing columns`);
+    }
+  }
+  function inferParameters({ length }) {
+    if (!Number.isInteger(length) || length < 0) {
+      throw new TypeError("Expected function.length to be a positive integer");
+    }
+    const params = [];
+    for (let i2 = 0;i2 < length; ++i2) {
+      params.push(`$${i2 + 1}`);
+    }
+    return params;
+  }
+  var { hasOwnProperty: hasOwnProperty10 } = Object.prototype;
+  var { apply: apply2 } = Function.prototype;
+  var GeneratorFunctionPrototype = Object.getPrototypeOf(function* () {});
+  var identifier = (str) => `"${str.replace(/"/g, '""')}"`;
+  var defer = (x2) => () => x2;
+});
+
+// ../../node_modules/better-sqlite3/lib/methods/inspect.js
+var require_inspect = __commonJS((exports, module) => {
+  var DatabaseInspection = function Database() {};
+  module.exports = function inspect(depth, opts) {
+    return Object.assign(new DatabaseInspection, this);
+  };
+});
+
+// ../../node_modules/better-sqlite3/lib/database.js
+var require_database = __commonJS((exports, module) => {
+  var fs4 = __require("fs");
+  var path = __require("path");
+  var util2 = require_util3();
+  var SqliteError = require_sqlite_error();
+  var DEFAULT_ADDON;
+  function Database(filenameGiven, options) {
+    if (new.target == null) {
+      return new Database(filenameGiven, options);
+    }
+    let buffer;
+    if (Buffer.isBuffer(filenameGiven)) {
+      buffer = filenameGiven;
+      filenameGiven = ":memory:";
+    }
+    if (filenameGiven == null)
+      filenameGiven = "";
+    if (options == null)
+      options = {};
+    if (typeof filenameGiven !== "string")
+      throw new TypeError("Expected first argument to be a string");
+    if (typeof options !== "object")
+      throw new TypeError("Expected second argument to be an options object");
+    if ("readOnly" in options)
+      throw new TypeError('Misspelled option "readOnly" should be "readonly"');
+    if ("memory" in options)
+      throw new TypeError('Option "memory" was removed in v7.0.0 (use ":memory:" filename instead)');
+    const filename = filenameGiven.trim();
+    const anonymous = filename === "" || filename === ":memory:";
+    const readonly2 = util2.getBooleanOption(options, "readonly");
+    const fileMustExist = util2.getBooleanOption(options, "fileMustExist");
+    const timeout = "timeout" in options ? options.timeout : 5000;
+    const verbose = "verbose" in options ? options.verbose : null;
+    const nativeBinding = "nativeBinding" in options ? options.nativeBinding : null;
+    if (readonly2 && anonymous && !buffer)
+      throw new TypeError("In-memory/temporary databases cannot be readonly");
+    if (!Number.isInteger(timeout) || timeout < 0)
+      throw new TypeError('Expected the "timeout" option to be a positive integer');
+    if (timeout > 2147483647)
+      throw new RangeError('Option "timeout" cannot be greater than 2147483647');
+    if (verbose != null && typeof verbose !== "function")
+      throw new TypeError('Expected the "verbose" option to be a function');
+    if (nativeBinding != null && typeof nativeBinding !== "string" && typeof nativeBinding !== "object")
+      throw new TypeError('Expected the "nativeBinding" option to be a string or addon object');
+    let addon;
+    if (nativeBinding == null) {
+      addon = DEFAULT_ADDON || (DEFAULT_ADDON = require_bindings()("better_sqlite3.node"));
+    } else if (typeof nativeBinding === "string") {
+      const requireFunc = typeof __non_webpack_require__ === "function" ? __non_webpack_require__ : __require;
+      addon = requireFunc(path.resolve(nativeBinding).replace(/(\.node)?$/, ".node"));
+    } else {
+      addon = nativeBinding;
+    }
+    if (!addon.isInitialized) {
+      addon.setErrorConstructor(SqliteError);
+      addon.isInitialized = true;
+    }
+    if (!anonymous && !filename.startsWith("file:") && !fs4.existsSync(path.dirname(filename))) {
+      throw new TypeError("Cannot open database because the directory does not exist");
+    }
+    Object.defineProperties(this, {
+      [util2.cppdb]: { value: new addon.Database(filename, filenameGiven, anonymous, readonly2, fileMustExist, timeout, verbose || null, buffer || null) },
+      ...wrappers.getters
+    });
+  }
+  var wrappers = require_wrappers();
+  Database.prototype.prepare = wrappers.prepare;
+  Database.prototype.transaction = require_transaction();
+  Database.prototype.pragma = require_pragma();
+  Database.prototype.backup = require_backup();
+  Database.prototype.serialize = require_serialize();
+  Database.prototype.function = require_function();
+  Database.prototype.aggregate = require_aggregate();
+  Database.prototype.table = require_table();
+  Database.prototype.loadExtension = wrappers.loadExtension;
+  Database.prototype.exec = wrappers.exec;
+  Database.prototype.close = wrappers.close;
+  Database.prototype.defaultSafeIntegers = wrappers.defaultSafeIntegers;
+  Database.prototype.unsafeMode = wrappers.unsafeMode;
+  Database.prototype[util2.inspect] = require_inspect();
+  module.exports = Database;
+});
+
+// ../../node_modules/better-sqlite3/lib/index.js
+var require_lib2 = __commonJS((exports, module) => {
+  module.exports = require_database();
+  module.exports.SqliteError = require_sqlite_error();
+});
+
 // src/config.ts
 import { existsSync, readFileSync } from "node:fs";
 import { readFile } from "node:fs/promises";
@@ -48641,6 +49406,13 @@ function date4(params) {
 
 // ../../node_modules/zod/v4/classic/external.js
 config(en_default());
+// ../core/src/config/memory.ts
+var memoryConfigSchema = exports_external.object({
+  enabled: exports_external.boolean().optional().default(true),
+  type: exports_external.enum(["sqlite", "memory"]).optional().default("sqlite"),
+  path: exports_external.string().optional().default("~/.config/polka-codes/memory.sqlite")
+}).strict().optional();
+
 // ../core/src/config.ts
 var ruleSchema = exports_external.union([
   exports_external.string(),
@@ -48773,7 +49545,8 @@ var configSchema = exports_external.object({
   mcpServers: exports_external.record(exports_external.string(), mcpServerConfigSchema).optional(),
   rules: exports_external.array(ruleSchema).optional().or(exports_external.string()).optional(),
   excludeFiles: exports_external.array(exports_external.string()).optional(),
-  agent: agentSchema
+  agent: agentSchema,
+  memory: memoryConfigSchema
 }).strict().nullish();
 // ../core/src/skills/constants.ts
 var SKILL_LIMITS = {
@@ -49246,14 +50019,40 @@ var readBinaryFile_default = {
 // ../core/src/tools/readFile.ts
 var toolInfo6 = {
   name: "readFile",
-  description: "Request to read the contents of one or multiple files at the specified paths. Use comma separated paths to read multiple files. Use this when you need to examine the contents of an existing file you do not know the contents of, for example to analyze code, review text files, or extract information from configuration files. May not be suitable for other types of binary files, as it returns the raw content as a string. Try to list all the potential files are relevent to the task, and then use this tool to read all the relevant files.",
+  description: `Request to read the contents of one or multiple files at the specified paths.
+
+When to use:
+- Examining file contents you don't know
+- Analyzing code, reviewing text files, extracting configuration info
+- Reading multiple files at once (use comma-separated paths)
+- Understanding file structure before editing
+
+When NOT to use:
+- For file existence checks: Use listFiles instead
+- For searching within files: Use grep instead
+- For file name searches: Use searchFiles instead
+- Prefer this tool over executeCommand with cat/head/tail
+
+Features:
+- Supports comma-separated paths for multiple files
+- Line numbers included for easy reference
+- Optional offset/limit for partial file reading
+- Automatically handles different file types
+
+IMPORTANT:
+- Line numbers are included for easy reference
+- Use offset/limit for large files to read specific sections`,
   parameters: exports_external.object({
     path: exports_external.preprocess((val) => {
       if (!val)
         return [];
-      const values = Array.isArray(val) ? val : [val];
-      return values.flatMap((i) => typeof i === "string" ? i.split(",") : []).filter((s) => s.length > 0);
+      if (Array.isArray(val)) {
+        return val.filter((s) => typeof s === "string" && s.length > 0);
+      }
+      return val.split(",").filter((s) => s.length > 0);
     }, exports_external.array(exports_external.string())).describe("The path of the file to read").meta({ usageValue: "Comma separated paths here" }),
+    offset: exports_external.number().optional().describe("Skip first N lines (for partial file reading)").meta({ usageValue: "100" }),
+    limit: exports_external.number().optional().describe("Read at most N lines (for partial file reading)").meta({ usageValue: "50" }),
     includeIgnored: exports_external.preprocess(preprocessBoolean, exports_external.boolean().nullish().default(false)).describe("Whether to include ignored files. Use true to include files ignored by .gitignore.").meta({ usageValue: "true or false (optional)" })
   }).meta({
     examples: [
@@ -49268,6 +50067,14 @@ var toolInfo6 = {
         input: {
           path: "src/main.js,src/index.js"
         }
+      },
+      {
+        description: "Read partial file (lines 100-150)",
+        input: {
+          path: "src/large-file.ts",
+          offset: 100,
+          limit: 50
+        }
       }
     ]
   })
@@ -49276,15 +50083,39 @@ var handler6 = async (provider, args) => {
   if (!provider.readFile) {
     return createProviderErrorResponse("read file");
   }
-  const { path: paths, includeIgnored } = toolInfo6.parameters.parse(args);
+  const parsed = toolInfo6.parameters.safeParse(args);
+  if (!parsed.success) {
+    return {
+      success: false,
+      message: {
+        type: "error-text",
+        value: `Invalid arguments for readFile: ${parsed.error.message}`
+      }
+    };
+  }
+  const { path: paths, offset, limit, includeIgnored } = parsed.data;
   const resp = [];
   for (const path of paths) {
     const fileContent = await provider.readFile(path, includeIgnored ?? false);
     if (!fileContent) {
       resp.push(createFileElement("read_file_file_content", path, undefined, { file_not_found: "true" }));
-    } else {
-      resp.push(createFileElement("read_file_file_content", path, fileContent));
+      continue;
     }
+    let lines = fileContent.split(`
+`);
+    const start = offset ?? 0;
+    const end = limit ? start + limit : lines.length;
+    if (offset !== undefined || limit !== undefined) {
+      lines = lines.slice(start, end);
+    }
+    const lineOffset = offset ?? 0;
+    const numberedContent = lines.map((line, i) => {
+      const lineNumber = lineOffset + i + 1;
+      const paddedNumber = String(lineNumber).padStart(6, " ");
+      return `${paddedNumber}→${line}`;
+    }).join(`
+`);
+    resp.push(createFileElement("read_file_file_content", path, numberedContent));
   }
   return {
     success: true,
@@ -49481,7 +50312,43 @@ var replaceInFile = (fileContent, diff) => {
 // ../core/src/tools/replaceInFile.ts
 var toolInfo9 = {
   name: "replaceInFile",
-  description: "Request to replace sections of content in an existing file using SEARCH/REPLACE blocks that define exact changes to specific parts of the file. This tool should be used when you need to make targeted changes to specific parts of a file.",
+  description: `Request to replace sections of content in an existing file using
+SEARCH/REPLACE blocks.
+
+When to use:
+- Making targeted changes to specific parts of a file
+- Replacing variable names, function signatures, imports
+- Fixing bugs in existing code
+- When you know the exact content to replace
+
+When NOT to use:
+- For creating new files: Use writeToFile instead
+- For completely replacing file contents: Use writeToFile instead
+- When you don't know the exact content: Read file first
+
+SEARCH/REPLACE FORMAT:
+<<<<<<< SEARCH
+[exact content to find]
+=======
+[new content to replace with]
+>>>>>>> REPLACE
+
+Critical rules:
+1. SEARCH content must match EXACTLY (character-for-character including whitespace)
+2. Each block replaces only first occurrence
+3. Include just enough lines for uniqueness (not too many, not too few)
+4. Keep blocks concise (don't include long unchanged sections)
+5. List blocks in order they appear in file
+6. Use multiple blocks for multiple independent changes
+
+Special operations:
+- Move code: Two blocks (delete from original + insert at new location)
+- Delete code: Empty REPLACE section
+
+IMPORTANT CONSTRAINTS:
+- SEARCH text must match file content exactly
+- Each block is independent (doesn't affect other blocks)
+- Cannot use for appending or inserting without SEARCH context`,
   parameters: exports_external.object({
     path: exports_external.string().describe("The path of the file to modify").meta({ usageValue: "File path here" }),
     diff: exports_external.string().describe(`One or more SEARCH/REPLACE blocks following this exact format:
@@ -49507,7 +50374,7 @@ Critical rules:
     * Each line must be complete. Never truncate lines mid-way through as this can cause matching failures.
 4. Special operations:
     * To move code: Use two SEARCH/REPLACE blocks (one to delete from original + one to insert at new location)
-    * To delete code: Use empty REPLACE section`).meta({ usageValue: "Search and replace blocks here" })
+    * To delete code: Empty REPLACE section`).meta({ usageValue: "Search and replace blocks here" })
   }).meta({
     examples: [
       {
@@ -49835,7 +50702,27 @@ var UpdateTodoItemOutputSchema = exports_external.object({
 // ../core/src/tools/writeToFile.ts
 var toolInfo12 = {
   name: "writeToFile",
-  description: "Request to write content to a file at the specified path. If the file exists, it will be overwritten with the provided content. If the file doesn't exist, it will be created. This tool will automatically create any directories needed to write the file. Ensure that the output content does not include incorrect escaped character patterns such as `&lt;`, `&gt;`, or `&amp;`. Also ensure there is no unwanted CDATA tags in the content.",
+  description: `Request to write content to a file at the specified path.
+
+When to use:
+- Creating new files
+- Completely replacing file contents
+- When you have the complete intended content
+
+When NOT to use:
+- For modifying existing files: Use replaceInFile instead
+- For appending content: Use executeCommand with echo >> instead
+- For targeted edits: Use replaceInFile instead
+
+Features:
+- Automatically creates any directories needed
+- Overwrites existing files completely
+- Must provide complete file content (no truncation)
+
+IMPORTANT CONSTRAINT:
+- Always provide COMPLETE intended content (no omissions)
+- Ensure no incorrect escape sequences (&lt;, &gt;, &amp;)
+- Ensure no unwanted CDATA tags in content`,
   parameters: exports_external.object({
     path: exports_external.string().describe("The path of the file to write to").meta({ usageValue: "File path here" }),
     content: exports_external.string().describe("The content to write to the file. ALWAYS provide the COMPLETE intended content of the file, without any truncation or omissions. You MUST include ALL parts of the file, even if they haven't been modified.").meta({ usageValue: "Your file content here" })
@@ -49876,10 +50763,7 @@ var handler12 = async (provider, args) => {
       }
     };
   }
-  let { path, content } = parsed.data;
-  const trimmedContent = content.trim();
-  if (trimmedContent.startsWith("<![CDATA[") && trimmedContent.endsWith("]]>"))
-    content = trimmedContent.slice(9, -3);
+  const { path, content } = parsed.data;
   await provider.writeFile(path, content);
   return {
     success: true,
@@ -53028,9 +53912,9 @@ class ZodUnion2 extends ZodType2 {
     return this._def.options;
   }
 }
-ZodUnion2.create = (types2, params) => {
+ZodUnion2.create = (types3, params) => {
   return new ZodUnion2({
-    options: types2,
+    options: types3,
     typeName: ZodFirstPartyTypeKind2.ZodUnion,
     ...processCreateParams(params)
   });
@@ -55524,15 +56408,15 @@ var primitiveMappings = {
 function parseUnionDef(def, refs) {
   const options = def.options instanceof Map ? Array.from(def.options.values()) : def.options;
   if (options.every((x) => (x._def.typeName in primitiveMappings) && (!x._def.checks || !x._def.checks.length))) {
-    const types2 = options.reduce((types22, x) => {
+    const types3 = options.reduce((types22, x) => {
       const type = primitiveMappings[x._def.typeName];
       return type && !types22.includes(type) ? [...types22, type] : types22;
     }, []);
     return {
-      type: types2.length > 1 ? types2 : types2[0]
+      type: types3.length > 1 ? types3 : types3[0]
     };
   } else if (options.every((x) => x._def.typeName === "ZodLiteral" && !x.description)) {
-    const types2 = options.reduce((acc, x) => {
+    const types3 = options.reduce((acc, x) => {
       const type = typeof x._def.value;
       switch (type) {
         case "string":
@@ -55551,8 +56435,8 @@ function parseUnionDef(def, refs) {
           return acc;
       }
     }, []);
-    if (types2.length === options.length) {
-      const uniqueTypes = types2.filter((x, i, a) => a.indexOf(x) === i);
+    if (types3.length === options.length) {
+      const uniqueTypes = types3.filter((x, i, a) => a.indexOf(x) === i);
       return {
         type: uniqueTypes.length > 1 ? uniqueTypes : uniqueTypes[0],
         enum: options.reduce((acc, x) => {
@@ -60290,9 +61174,9 @@ var moduleExports2 = freeModule2 && freeModule2.exports === freeExports2;
 var freeProcess = moduleExports2 && _freeGlobal_default.process;
 var nodeUtil = function() {
   try {
-    var types3 = freeModule2 && freeModule2.require && freeModule2.require("util").types;
-    if (types3) {
-      return types3;
+    var types4 = freeModule2 && freeModule2.require && freeModule2.require("util").types;
+    if (types4) {
+      return types4;
     }
     return freeProcess && freeProcess.binding && freeProcess.binding("util");
   } catch (e) {}
@@ -60992,6 +61876,37 @@ var readLocalConfig = (path) => {
     return;
   }
 };
+// src/memory-manager.ts
+class MemoryManager {
+  store;
+  constructor(store, _cwd) {
+    this.store = store;
+  }
+  async readMemory(topic) {
+    return this.store.readMemory(topic);
+  }
+  async updateMemory(operation, topic, content, metadata) {
+    return this.store.updateMemory(operation, topic, content, metadata);
+  }
+  async queryMemory(query = {}, options) {
+    const finalQuery = {
+      ...query
+    };
+    if (!options?.operation && !finalQuery.limit) {
+      finalQuery.limit = 1000;
+    }
+    return this.store.queryMemory(finalQuery, options);
+  }
+  async batchUpdateMemory(operations) {
+    return this.store.batchUpdateMemory(operations);
+  }
+  async getStats() {
+    return this.store.getStats();
+  }
+  close() {
+    this.store.close();
+  }
+}
 // src/provider.ts
 import { spawn as spawn2 } from "node:child_process";
 import { mkdir, readFile as readFile2, rename, unlink, writeFile } from "node:fs/promises";
@@ -64357,7 +65272,7 @@ function lookup(path) {
   }
   return $types[extension2] || false;
 }
-function populateMaps(extensions, types5) {
+function populateMaps(extensions, types6) {
   Object.keys(db).forEach(function forEachMimeType(type) {
     var mime = db[type];
     var exts = mime.extensions;
@@ -64367,10 +65282,10 @@ function populateMaps(extensions, types5) {
     extensions[type] = exts;
     for (var i2 = 0;i2 < exts.length; i2++) {
       var extension2 = exts[i2];
-      types5[extension2] = _preferredType(extension2, types5[extension2], type);
-      const legacyType = _preferredTypeLegacy(extension2, types5[extension2], type);
-      if (legacyType !== types5[extension2]) {
-        $_extensionConflicts.push([extension2, legacyType, types5[extension2]]);
+      types6[extension2] = _preferredType(extension2, types6[extension2], type);
+      const legacyType = _preferredTypeLegacy(extension2, types6[extension2], type);
+      if (legacyType !== types6[extension2]) {
+        $_extensionConflicts.push([extension2, legacyType, types6[extension2]]);
       }
     }
   });
@@ -64675,35 +65590,35 @@ var getProvider = (options = {}) => {
       }
     },
     listMemoryTopics: async () => {
-      const memory = await memoryStore.read() ?? {};
-      return Object.keys(memory);
+      const memory2 = await memoryStore.read() ?? {};
+      return Object.keys(memory2);
     },
     readMemory: async (topic = defaultMemoryTopic) => {
-      const memory = await memoryStore.read() ?? {};
-      return memory[topic];
+      const memory2 = await memoryStore.read() ?? {};
+      return memory2[topic];
     },
     updateMemory: async (operation, topic, content) => {
       const memoryTopic = topic ?? defaultMemoryTopic;
-      const memory = await memoryStore.read() ?? {};
+      const memory2 = await memoryStore.read() ?? {};
       switch (operation) {
         case "append":
           if (content === undefined) {
             throw new Error("Content is required for append operation.");
           }
-          memory[memoryTopic] = `${memory[memoryTopic] || ""}
+          memory2[memoryTopic] = `${memory2[memoryTopic] || ""}
 ${content}`;
           break;
         case "replace":
           if (content === undefined) {
             throw new Error("Content is required for replace operation.");
           }
-          memory[memoryTopic] = content;
+          memory2[memoryTopic] = content;
           break;
         case "remove":
-          delete memory[memoryTopic];
+          delete memory2[memoryTopic];
           break;
       }
-      await memoryStore.write(memory);
+      await memoryStore.write(memory2);
     },
     readFile: async (path, includeIgnored) => {
       if (!includeIgnored && ig.ignores(path)) {
@@ -64870,6 +65785,409 @@ ${content}`;
   }
   return provider2;
 };
+// src/sqlite-memory-store.ts
+var import_better_sqlite3 = __toESM(require_lib2(), 1);
+import { randomUUID } from "node:crypto";
+import { existsSync as existsSync2 } from "node:fs";
+import { mkdir as mkdir2, rename as rename2 } from "node:fs/promises";
+import { dirname as dirname2, resolve as resolve4 } from "node:path";
+
+class SQLiteMemoryStore {
+  db = null;
+  dbPromise = null;
+  config;
+  currentScope;
+  maxRetries = 3;
+  retryDelay = 100;
+  static SORT_COLUMNS = {
+    created: "created_at",
+    updated: "updated_at",
+    accessed: "last_accessed",
+    name: "name"
+  };
+  static ALLOWED_SORT_ORDERS = ["asc", "desc"];
+  static ALLOWED_PRIORITIES = ["low", "medium", "high", "critical"];
+  constructor(config3, scope) {
+    this.config = config3;
+    this.currentScope = scope;
+  }
+  async initializeDatabase() {
+    if (this.dbPromise) {
+      return this.dbPromise;
+    }
+    this.dbPromise = (async () => {
+      if (this.db) {
+        return this.db;
+      }
+      const dbPath = this.resolvePath(this.config.path || "~/.config/polka-codes/memory.sqlite");
+      try {
+        const dir = dirname2(dbPath);
+        if (!existsSync2(dir)) {
+          await mkdir2(dir, { recursive: true, mode: 448 });
+        }
+        if (!existsSync2(dbPath)) {
+          const { openSync, closeSync } = await import("node:fs");
+          const fd = openSync(dbPath, "w");
+          closeSync(fd);
+          await import("node:fs/promises").then((fs4) => fs4.chmod(dbPath, 384));
+        }
+        const db2 = new import_better_sqlite3.default(dbPath, {
+          verbose: process.env.SQLITE_DEBUG ? console.log : undefined
+        });
+        this.configurePragmas(db2);
+        this.checkIntegrity(db2);
+        this.initializeSchema(db2);
+        this.db = db2;
+        return db2;
+      } catch (error48) {
+        console.error("[SQLiteMemoryStore] Initialization failed:", error48);
+        if (existsSync2(dbPath)) {
+          const backupPath = `${dbPath}.corrupted.${Date.now()}`;
+          console.warn(`[SQLiteMemoryStore] Backing up corrupted database to: ${backupPath}`);
+          try {
+            await rename2(dbPath, backupPath);
+          } catch (backupError) {
+            console.error("[SQLiteMemoryStore] Failed to backup corrupted database:", backupError);
+            this.dbPromise = null;
+            throw backupError;
+          }
+          this.dbPromise = null;
+          return this.initializeDatabase();
+        }
+        this.dbPromise = null;
+        throw error48;
+      }
+    })();
+    return this.dbPromise;
+  }
+  configurePragmas(db2) {
+    db2.pragma("journal_mode = WAL");
+    db2.pragma("synchronous = NORMAL");
+    db2.pragma("busy_timeout = 5000");
+    db2.pragma("foreign_keys = ON");
+    db2.pragma("temp_store = MEMORY");
+    db2.pragma("mmap_size = 30000000000");
+    db2.pragma("page_size = 4096");
+  }
+  checkIntegrity(db2) {
+    try {
+      const result = db2.pragma("integrity_check", { simple: true });
+      if (result !== "ok") {
+        throw new Error(`Database integrity check failed: ${result}`);
+      }
+    } catch (error48) {
+      console.error("[SQLiteMemoryStore] Integrity check failed:", error48);
+      throw new Error("Database is corrupted");
+    }
+  }
+  initializeSchema(db2) {
+    db2.exec(`
+      CREATE TABLE IF NOT EXISTS memory_entries (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL CHECK(length(name) > 0),
+        scope TEXT NOT NULL CHECK(scope IN ('global') OR scope LIKE 'project:%'),
+        content TEXT NOT NULL CHECK(length(content) > 0),
+        entry_type TEXT NOT NULL CHECK(length(entry_type) > 0),
+        status TEXT CHECK(status IS NULL OR length(status) > 0),
+        priority TEXT CHECK(priority IS NULL OR priority IN ('low', 'medium', 'high', 'critical')),
+        tags TEXT CHECK(tags IS NULL OR length(tags) > 0),
+        metadata TEXT CHECK(metadata IS NULL OR json_valid(metadata)),
+        created_at INTEGER NOT NULL CHECK(created_at > 0),
+        updated_at INTEGER NOT NULL CHECK(updated_at > 0),
+        last_accessed INTEGER NOT NULL CHECK(last_accessed > 0),
+        UNIQUE(name, scope)
+      )
+    `);
+    db2.exec(`
+      CREATE INDEX IF NOT EXISTS idx_memory_entries_scope_type ON memory_entries(scope, entry_type);
+      CREATE INDEX IF NOT EXISTS idx_memory_entries_updated ON memory_entries(updated_at);
+    `);
+  }
+  async getDatabase() {
+    if (!this.db) {
+      this.db = await this.initializeDatabase();
+    }
+    return this.db;
+  }
+  resolvePath(path) {
+    if (path.startsWith("~")) {
+      const home = process.env.HOME || process.env.USERPROFILE || ".";
+      if (home === ".") {
+        throw new Error("Cannot resolve home directory");
+      }
+      const expanded = `${home}${path.slice(1)}`;
+      const resolved = resolve4(expanded);
+      const sep = process.platform === "win32" ? "\\" : "/";
+      if (resolved !== home && !resolved.startsWith(home + sep)) {
+        throw new Error(`Path escapes home directory: ${path}`);
+      }
+      return resolved;
+    }
+    return resolve4(path);
+  }
+  generateUUID() {
+    return randomUUID();
+  }
+  now() {
+    return Date.now();
+  }
+  sleep(ms) {
+    return new Promise((resolve5) => setTimeout(resolve5, ms));
+  }
+  isRetryableError(error48) {
+    if (error48 instanceof Error) {
+      const message = error48.message.toLowerCase();
+      return message.includes("database is locked") || message.includes("database is busy") || message.includes("sqlite_busy") || message.includes("sqlite_locked");
+    }
+    return false;
+  }
+  async transaction(callback, options = {}) {
+    const db2 = await this.getDatabase();
+    const retries = options.retries ?? this.maxRetries;
+    for (let attempt = 0;attempt < retries; attempt++) {
+      try {
+        db2.exec("BEGIN IMMEDIATE");
+        const result = await callback();
+        db2.exec("COMMIT");
+        return result;
+      } catch (error48) {
+        try {
+          db2.exec("ROLLBACK");
+        } catch (rollbackError) {
+          console.error("[SQLiteMemoryStore] Rollback failed:", rollbackError);
+        }
+        const isRetryable = this.isRetryableError(error48);
+        if (isRetryable && attempt < retries - 1) {
+          const delay2 = this.retryDelay * 2 ** attempt;
+          console.warn(`[SQLiteMemoryStore] Retryable error, retrying in ${delay2}ms...`);
+          await this.sleep(delay2);
+          continue;
+        }
+        throw error48;
+      }
+    }
+    throw new Error("Maximum retries exceeded");
+  }
+  async readMemory(topic) {
+    const db2 = await this.getDatabase();
+    const scope = this.currentScope;
+    return this.transaction(async () => {
+      const stmt = db2.prepare("SELECT content FROM memory_entries WHERE name = ? AND scope = ?");
+      const row = stmt.get(topic, scope);
+      if (row) {
+        const updateStmt = db2.prepare("UPDATE memory_entries SET last_accessed = ? WHERE name = ? AND scope = ?");
+        updateStmt.run(this.now(), topic, scope);
+      }
+      return row?.content;
+    });
+  }
+  async updateMemoryInternal(db2, operation, topic, content, metadata) {
+    const scope = this.currentScope;
+    const now = this.now();
+    if (operation === "remove") {
+      const stmt = db2.prepare("DELETE FROM memory_entries WHERE name = ? AND scope = ?");
+      stmt.run(topic, scope);
+      return;
+    }
+    const existingStmt = db2.prepare("SELECT content, entry_type, status, priority, tags FROM memory_entries WHERE name = ? AND scope = ?");
+    const existing = existingStmt.get(topic, scope);
+    let finalContent;
+    let entry_type;
+    let status;
+    let priority;
+    let tags;
+    if (existing) {
+      if (operation === "append") {
+        if (!content) {
+          throw new Error("Content is required for append operation.");
+        }
+        finalContent = `${existing.content}
+${content}`;
+      } else {
+        if (!content) {
+          throw new Error("Content is required for replace operation.");
+        }
+        finalContent = content;
+      }
+      entry_type = metadata?.entry_type || existing.entry_type;
+      status = metadata?.status || existing.status;
+      priority = metadata?.priority || existing.priority;
+      tags = metadata?.tags || existing.tags;
+    } else {
+      if (!content) {
+        throw new Error("Content is required for new memory entries.");
+      }
+      finalContent = content;
+      entry_type = metadata?.entry_type || "note";
+      status = metadata?.status;
+      priority = metadata?.priority;
+      tags = metadata?.tags;
+    }
+    const upsertStmt = db2.prepare(`
+      INSERT INTO memory_entries (id, name, scope, content, entry_type, status, priority, tags, created_at, updated_at, last_accessed)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(name, scope) DO UPDATE SET
+        content = excluded.content,
+        entry_type = excluded.entry_type,
+        status = excluded.status,
+        priority = excluded.priority,
+        tags = excluded.tags,
+        updated_at = excluded.updated_at,
+        last_accessed = excluded.last_accessed
+    `);
+    upsertStmt.run(this.generateUUID(), topic, scope, finalContent, entry_type, status || null, priority || null, tags || null, now, now, now);
+  }
+  async updateMemory(operation, topic, content, metadata) {
+    return this.transaction(async () => {
+      const db2 = await this.getDatabase();
+      await this.updateMemoryInternal(db2, operation, topic, content, metadata);
+    });
+  }
+  async queryMemory(query = {}, options = {}) {
+    const db2 = await this.getDatabase();
+    const { sql, params } = this.buildQuery(query, options);
+    if (options.operation === "count") {
+      const countStmt = db2.prepare(`SELECT COUNT(*) as count FROM (${sql})`);
+      const result = countStmt.get(...params);
+      return result.count;
+    }
+    if (options.operation === "delete") {
+      const deleteStmt = db2.prepare(`DELETE FROM memory_entries WHERE id IN (SELECT id FROM (${sql}))`);
+      const info = deleteStmt.run(...params);
+      return info.changes;
+    }
+    const stmt = db2.prepare(sql);
+    return stmt.all(...params);
+  }
+  buildQuery(query, _options) {
+    const conditions = [];
+    const params = [];
+    let sql = "SELECT * FROM memory_entries WHERE 1=1";
+    const scope = query.scope === "auto" ? this.currentScope : query.scope;
+    if (scope === "global") {
+      conditions.push("scope = ?");
+      params.push("global");
+    } else if (scope === "project" || !scope && this.currentScope !== "global") {
+      conditions.push("scope = ?");
+      params.push(this.currentScope);
+    }
+    if (query.type) {
+      if (!query.type.trim()) {
+        throw new Error("Type cannot be empty");
+      }
+      conditions.push("entry_type = ?");
+      params.push(query.type.trim());
+    }
+    if (query.status) {
+      conditions.push("status = ?");
+      params.push(query.status);
+    }
+    if (query.priority) {
+      if (!SQLiteMemoryStore.ALLOWED_PRIORITIES.includes(query.priority)) {
+        throw new Error(`Invalid priority: ${query.priority}`);
+      }
+      conditions.push("priority = ?");
+      params.push(query.priority);
+    }
+    if (query.tags) {
+      const tags = Array.isArray(query.tags) ? query.tags : [query.tags];
+      for (const tag of tags) {
+        const trimmed = tag.trim();
+        if (!trimmed) {
+          throw new Error("Tags cannot be empty");
+        }
+        conditions.push("(tags = ? OR tags LIKE ? OR tags LIKE ? OR tags LIKE ?)");
+        params.push(trimmed, `${trimmed},%`, `%,${trimmed}`, `%,${trimmed},%`);
+      }
+    }
+    if (query.search) {
+      const searchTerm = query.search.trim();
+      const sanitized = searchTerm.replace(/[\\_%]/g, "\\$&");
+      conditions.push("(content LIKE ? OR name LIKE ?)");
+      params.push(`%${sanitized}%`, `%${sanitized}%`);
+    }
+    if (query.createdAfter) {
+      conditions.push("created_at >= ?");
+      params.push(query.createdAfter);
+    }
+    if (query.createdBefore) {
+      conditions.push("created_at <= ?");
+      params.push(query.createdBefore);
+    }
+    if (query.updatedAfter) {
+      conditions.push("updated_at >= ?");
+      params.push(query.updatedAfter);
+    }
+    if (query.updatedBefore) {
+      conditions.push("updated_at <= ?");
+      params.push(query.updatedBefore);
+    }
+    if (conditions.length > 0) {
+      sql += ` AND ${conditions.join(" AND ")}`;
+    }
+    if (query.sortBy) {
+      const column = SQLiteMemoryStore.SORT_COLUMNS[query.sortBy];
+      if (!column) {
+        throw new Error(`Invalid sortBy: ${query.sortBy}`);
+      }
+      const order = query.sortOrder || "desc";
+      if (!SQLiteMemoryStore.ALLOWED_SORT_ORDERS.includes(order)) {
+        throw new Error(`Invalid sortOrder: ${order}`);
+      }
+      sql += ` ORDER BY ${column} ${order.toUpperCase()}`;
+    }
+    if (query.limit) {
+      const limit = Number(query.limit);
+      if (Number.isNaN(limit) || limit < 1 || limit > 1e4) {
+        throw new Error("Limit must be between 1 and 10000");
+      }
+      sql += " LIMIT ?";
+      params.push(limit);
+      if (query.offset) {
+        const offset = Number(query.offset);
+        if (Number.isNaN(offset) || offset < 0) {
+          throw new Error("Offset must be >= 0");
+        }
+        sql += " OFFSET ?";
+        params.push(offset);
+      }
+    }
+    return { sql, params };
+  }
+  async batchUpdateMemory(operations) {
+    return this.transaction(async () => {
+      const db2 = await this.getDatabase();
+      for (const op of operations) {
+        await this.updateMemoryInternal(db2, op.operation, op.name, op.content, op.metadata);
+      }
+    });
+  }
+  close() {
+    if (this.db) {
+      this.db.close();
+      this.db = null;
+    }
+  }
+  async getStats() {
+    const db2 = await this.getDatabase();
+    const countStmt = db2.prepare("SELECT COUNT(*) as count FROM memory_entries");
+    const { count: totalEntries } = countStmt.get();
+    const typeStmt = db2.prepare("SELECT entry_type, COUNT(*) as count FROM memory_entries GROUP BY entry_type");
+    const typeRows = typeStmt.all();
+    const entriesByType = Object.fromEntries(typeRows.map((r2) => [r2.entry_type, r2.count]));
+    const dbPath = this.resolvePath(this.config.path || "~/.config/polka-codes/memory.sqlite");
+    let databaseSize = 0;
+    try {
+      const stats = await import("node:fs/promises").then((fs4) => fs4.stat(dbPath));
+      databaseSize = stats.size;
+    } catch {}
+    return {
+      totalEntries,
+      entriesByType,
+      databaseSize
+    };
+  }
+}
 // src/utils/eventHandler.ts
 import { Console } from "node:console";
 
@@ -65630,7 +66948,7 @@ Tool error:`, event.tool));
 // src/utils/readMultiline.ts
 import readline3 from "node:readline";
 function readMultiline(prompt = "Enter text (Ctrl+D to finish):") {
-  return new Promise((resolve4) => {
+  return new Promise((resolve5) => {
     console.log(prompt);
     const rl = readline3.createInterface({
       input: process.stdin,
@@ -65642,7 +66960,7 @@ function readMultiline(prompt = "Enter text (Ctrl+D to finish):") {
       lines.push(line);
     });
     rl.on("close", () => {
-      resolve4(lines.join(`
+      resolve5(lines.join(`
 `));
     });
   });
@@ -65666,5 +66984,7 @@ export {
   getGlobalConfigPath,
   configSchema,
   checkRipgrep,
+  SQLiteMemoryStore,
+  MemoryManager,
   InMemoryStore
 };