kiro-memory 1.0.0

package/plugin/dist/index.js

@@ -0,0 +1,2103 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// node_modules/better-sqlite3/lib/util.js
+var require_util = __commonJS({
+  "node_modules/better-sqlite3/lib/util.js"(exports) {
+    "use strict";
+    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 = /* @__PURE__ */ Symbol();
+    exports.inspect = /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom");
+  }
+});
+
+// node_modules/better-sqlite3/lib/sqlite-error.js
+var require_sqlite_error = __commonJS({
+  "node_modules/better-sqlite3/lib/sqlite-error.js"(exports, module) {
+    "use strict";
+    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({
+  "node_modules/file-uri-to-path/index.js"(exports, module) {
+    var sep = __require("path").sep || "/";
+    module.exports = fileUriToPath;
+    function fileUriToPath(uri) {
+      if ("string" != typeof uri || uri.length <= 7 || "file://" != uri.substring(0, 7)) {
+        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 ("localhost" == host) 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({
+  "node_modules/bindings/bindings.js"(exports, module) {
+    var fs = __require("fs");
+    var path = __require("path");
+    var fileURLToPath2 = require_file_uri_to_path();
+    var join3 = path.join;
+    var dirname2 = path.dirname;
+    var exists = fs.accessSync && function(path2) {
+      try {
+        fs.accessSync(path2);
+      } catch (e) {
+        return false;
+      }
+      return true;
+    } || fs.existsSync || path.existsSync;
+    var defaults = {
+      arrow: process.env.NODE_BINDINGS_ARROW || " \u2192 ",
+      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: [
+        // node-gyp's linked version in the "build" dir
+        ["module_root", "build", "bindings"],
+        // node-waf and gyp_addon (a.k.a node-gyp)
+        ["module_root", "build", "Debug", "bindings"],
+        ["module_root", "build", "Release", "bindings"],
+        // Debug files, for development (legacy behavior, remove for node v0.9)
+        ["module_root", "out", "Debug", "bindings"],
+        ["module_root", "Debug", "bindings"],
+        // Release files, but manually compiled (legacy behavior, remove for node v0.9)
+        ["module_root", "out", "Release", "bindings"],
+        ["module_root", "Release", "bindings"],
+        // Legacy from node-waf, node <= 0.4.x
+        ["module_root", "build", "default", "bindings"],
+        // Production "Release" buildtype binary (meh...)
+        ["module_root", "compiled", "version", "platform", "arch", "bindings"],
+        // node-qbs builds
+        ["module_root", "addon-build", "release", "install-root", "bindings"],
+        ["module_root", "addon-build", "debug", "install-root", "bindings"],
+        ["module_root", "addon-build", "default", "install-root", "bindings"],
+        // node-pre-gyp path ./lib/binding/{node_abi}-{platform}-{arch}
+        ["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(i2) {
+        if (!(i2 in opts)) opts[i2] = defaults[i2];
+      });
+      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 = [], i = 0, l = opts.try.length, n, b, err;
+      for (; i < l; i++) {
+        n = join3.apply(
+          null,
+          opts.try[i].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 (e) {
+          if (e.code !== "MODULE_NOT_FOUND" && e.code !== "QUALIFIED_PATH_RESOLUTION_FAILED" && !/not find/i.test(e.message)) {
+            throw e;
+          }
+        }
+      }
+      err = new Error(
+        "Could not locate the bindings file. Tried:\n" + tries.map(function(a) {
+          return opts.arrow + a;
+        }).join("\n")
+      );
+      err.tries = tries;
+      throw err;
+    }
+    module.exports = exports = bindings;
+    exports.getFileName = function getFileName(calling_file) {
+      var origPST = Error.prepareStackTrace, origSTL = Error.stackTraceLimit, dummy = {}, fileName;
+      Error.stackTraceLimit = 10;
+      Error.prepareStackTrace = function(e, st) {
+        for (var i = 0, l = st.length; i < l; i++) {
+          fileName = st[i].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 = fileURLToPath2(fileName);
+      }
+      return fileName;
+    };
+    exports.getRoot = function getRoot(file) {
+      var dir = dirname2(file), 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: "' + file + '". Do you have a `package.json` file? '
+          );
+        }
+        prev = dir;
+        dir = join3(dir, "..");
+      }
+    };
+  }
+});
+
+// node_modules/better-sqlite3/lib/methods/wrappers.js
+var require_wrappers = __commonJS({
+  "node_modules/better-sqlite3/lib/methods/wrappers.js"(exports) {
+    "use strict";
+    var { cppdb } = require_util();
+    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({
+  "node_modules/better-sqlite3/lib/methods/transaction.js"(exports, module) {
+    "use strict";
+    var { cppdb } = require_util();
+    var controllers = /* @__PURE__ */ new WeakMap();
+    module.exports = function transaction(fn) {
+      if (typeof fn !== "function") throw new TypeError("Expected first argument to be a function");
+      const db = this[cppdb];
+      const controller = getController(db, this);
+      const { apply } = Function.prototype;
+      const properties = {
+        default: { value: wrapTransaction(apply, fn, db, controller.default) },
+        deferred: { value: wrapTransaction(apply, fn, db, controller.deferred) },
+        immediate: { value: wrapTransaction(apply, fn, db, controller.immediate) },
+        exclusive: { value: wrapTransaction(apply, fn, db, 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 = (db, self) => {
+      let controller = controllers.get(db);
+      if (!controller) {
+        const shared = {
+          commit: db.prepare("COMMIT", self, false),
+          rollback: db.prepare("ROLLBACK", self, false),
+          savepoint: db.prepare("SAVEPOINT `	_bs3.	`", self, false),
+          release: db.prepare("RELEASE `	_bs3.	`", self, false),
+          rollbackTo: db.prepare("ROLLBACK TO `	_bs3.	`", self, false)
+        };
+        controllers.set(db, controller = {
+          default: Object.assign({ begin: db.prepare("BEGIN", self, false) }, shared),
+          deferred: Object.assign({ begin: db.prepare("BEGIN DEFERRED", self, false) }, shared),
+          immediate: Object.assign({ begin: db.prepare("BEGIN IMMEDIATE", self, false) }, shared),
+          exclusive: Object.assign({ begin: db.prepare("BEGIN EXCLUSIVE", self, false) }, shared)
+        });
+      }
+      return controller;
+    };
+    var wrapTransaction = (apply, fn, db, { begin, commit, rollback, savepoint, release, rollbackTo }) => function sqliteTransaction() {
+      let before, after, undo;
+      if (db.inTransaction) {
+        before = savepoint;
+        after = release;
+        undo = rollbackTo;
+      } else {
+        before = begin;
+        after = commit;
+        undo = rollback;
+      }
+      before.run();
+      try {
+        const result = apply.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 (db.inTransaction) {
+          undo.run();
+          if (undo !== rollback) after.run();
+        }
+        throw ex;
+      }
+    };
+  }
+});
+
+// node_modules/better-sqlite3/lib/methods/pragma.js
+var require_pragma = __commonJS({
+  "node_modules/better-sqlite3/lib/methods/pragma.js"(exports, module) {
+    "use strict";
+    var { getBooleanOption, cppdb } = require_util();
+    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({
+  "node_modules/better-sqlite3/lib/methods/backup.js"(exports, module) {
+    "use strict";
+    var fs = __require("fs");
+    var path = __require("path");
+    var { promisify } = __require("util");
+    var { cppdb } = require_util();
+    var fsAccess = promisify(fs.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 handler = "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 (handler != null && typeof handler !== "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), handler || null);
+    };
+    var runBackup = (backup, handler) => {
+      let rate = 0;
+      let useDefault = true;
+      return new Promise((resolve, reject) => {
+        setImmediate(function step() {
+          try {
+            const progress = backup.transfer(rate);
+            if (!progress.remainingPages) {
+              backup.close();
+              resolve(progress);
+              return;
+            }
+            if (useDefault) {
+              useDefault = false;
+              rate = 100;
+            }
+            if (handler) {
+              const ret = handler(progress);
+              if (ret !== void 0) {
+                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({
+  "node_modules/better-sqlite3/lib/methods/serialize.js"(exports, module) {
+    "use strict";
+    var { cppdb } = require_util();
+    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({
+  "node_modules/better-sqlite3/lib/methods/function.js"(exports, module) {
+    "use strict";
+    var { getBooleanOption, cppdb } = require_util();
+    module.exports = function defineFunction(name, options, fn) {
+      if (options == null) options = {};
+      if (typeof options === "function") {
+        fn = options;
+        options = {};
+      }
+      if (typeof name !== "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 (!name) 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, name, argCount, safeIntegers, deterministic, directOnly);
+      return this;
+    };
+  }
+});
+
+// node_modules/better-sqlite3/lib/methods/aggregate.js
+var require_aggregate = __commonJS({
+  "node_modules/better-sqlite3/lib/methods/aggregate.js"(exports, module) {
+    "use strict";
+    var { getBooleanOption, cppdb } = require_util();
+    module.exports = function defineAggregate(name, options) {
+      if (typeof name !== "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 (!name) 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, name, argCount, safeIntegers, deterministic, directOnly);
+      return this;
+    };
+    var getFunctionOption = (options, key, required) => {
+      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 (required) 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({
+  "node_modules/better-sqlite3/lib/methods/table.js"(exports, module) {
+    "use strict";
+    var { cppdb } = require_util();
+    module.exports = function defineTable(name, factory) {
+      if (typeof name !== "string") throw new TypeError("Expected first argument to be a string");
+      if (!name) 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", name));
+      } 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, name, eponymous);
+      return this;
+    };
+    function wrapFactory(factory) {
+      return function virtualTableFactory(moduleName, databaseName, tableName, ...args) {
+        const thisObject = {
+          module: moduleName,
+          database: databaseName,
+          table: tableName
+        };
+        const def = apply.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 (!hasOwnProperty.call(def, "rows")) {
+        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition without a "rows" property`);
+      }
+      if (!hasOwnProperty.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((x) => typeof x === "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 (hasOwnProperty.call(def, "parameters")) {
+        parameters = def.parameters;
+        if (!Array.isArray(parameters) || !(parameters = [...parameters]).every((x) => typeof x === "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 (hasOwnProperty.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 (hasOwnProperty.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((x, i) => [x, parameters.length + i])), moduleName),
+        parameters,
+        safeIntegers,
+        directOnly
+      ];
+    }
+    function wrapGenerator(generator, columnMap, moduleName) {
+      return function* virtualTable(...args) {
+        const output = args.map((x) => Buffer.isBuffer(x) ? Buffer.from(x) : x);
+        for (let i = 0; i < columnMap.size; ++i) {
+          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 i = 0; i < columnCount; ++i) {
+        output[i + offset] = row[i];
+      }
+    }
+    function extractRowObject(row, output, columnMap, moduleName) {
+      let count = 0;
+      for (const key of Object.keys(row)) {
+        const index = columnMap.get(key);
+        if (index === void 0) {
+          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 i = 0; i < length; ++i) {
+        params.push(`$${i + 1}`);
+      }
+      return params;
+    }
+    var { hasOwnProperty } = Object.prototype;
+    var { apply } = Function.prototype;
+    var GeneratorFunctionPrototype = Object.getPrototypeOf(function* () {
+    });
+    var identifier = (str) => `"${str.replace(/"/g, '""')}"`;
+    var defer = (x) => () => x;
+  }
+});
+
+// node_modules/better-sqlite3/lib/methods/inspect.js
+var require_inspect = __commonJS({
+  "node_modules/better-sqlite3/lib/methods/inspect.js"(exports, module) {
+    "use strict";
+    var DatabaseInspection = function Database2() {
+    };
+    module.exports = function inspect(depth, opts) {
+      return Object.assign(new DatabaseInspection(), this);
+    };
+  }
+});
+
+// node_modules/better-sqlite3/lib/database.js
+var require_database = __commonJS({
+  "node_modules/better-sqlite3/lib/database.js"(exports, module) {
+    "use strict";
+    var fs = __require("fs");
+    var path = __require("path");
+    var util = require_util();
+    var SqliteError = require_sqlite_error();
+    var DEFAULT_ADDON;
+    function Database2(filenameGiven, options) {
+      if (new.target == null) {
+        return new Database2(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 readonly = util.getBooleanOption(options, "readonly");
+      const fileMustExist = util.getBooleanOption(options, "fileMustExist");
+      const timeout = "timeout" in options ? options.timeout : 5e3;
+      const verbose = "verbose" in options ? options.verbose : null;
+      const nativeBinding = "nativeBinding" in options ? options.nativeBinding : null;
+      if (readonly && 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:") && !fs.existsSync(path.dirname(filename))) {
+        throw new TypeError("Cannot open database because the directory does not exist");
+      }
+      Object.defineProperties(this, {
+        [util.cppdb]: { value: new addon.Database(filename, filenameGiven, anonymous, readonly, fileMustExist, timeout, verbose || null, buffer || null) },
+        ...wrappers.getters
+      });
+    }
+    var wrappers = require_wrappers();
+    Database2.prototype.prepare = wrappers.prepare;
+    Database2.prototype.transaction = require_transaction();
+    Database2.prototype.pragma = require_pragma();
+    Database2.prototype.backup = require_backup();
+    Database2.prototype.serialize = require_serialize();
+    Database2.prototype.function = require_function();
+    Database2.prototype.aggregate = require_aggregate();
+    Database2.prototype.table = require_table();
+    Database2.prototype.loadExtension = wrappers.loadExtension;
+    Database2.prototype.exec = wrappers.exec;
+    Database2.prototype.close = wrappers.close;
+    Database2.prototype.defaultSafeIntegers = wrappers.defaultSafeIntegers;
+    Database2.prototype.unsafeMode = wrappers.unsafeMode;
+    Database2.prototype[util.inspect] = require_inspect();
+    module.exports = Database2;
+  }
+});
+
+// node_modules/better-sqlite3/lib/index.js
+var require_lib = __commonJS({
+  "node_modules/better-sqlite3/lib/index.js"(exports, module) {
+    "use strict";
+    module.exports = require_database();
+    module.exports.SqliteError = require_sqlite_error();
+  }
+});
+
+// src/services/sqlite/Sessions.ts
+var Sessions_exports = {};
+__export(Sessions_exports, {
+  completeSession: () => completeSession,
+  createSession: () => createSession,
+  failSession: () => failSession,
+  getActiveSessions: () => getActiveSessions,
+  getSessionByContentId: () => getSessionByContentId,
+  getSessionById: () => getSessionById,
+  getSessionsByProject: () => getSessionsByProject,
+  updateSessionMemoryId: () => updateSessionMemoryId
+});
+function createSession(db, contentSessionId, project, userPrompt) {
+  const now = /* @__PURE__ */ new Date();
+  const result = db.run(
+    `INSERT INTO sessions (content_session_id, project, user_prompt, status, started_at, started_at_epoch)
+     VALUES (?, ?, ?, 'active', ?, ?)`,
+    [contentSessionId, project, userPrompt, now.toISOString(), now.getTime()]
+  );
+  return Number(result.lastInsertRowid);
+}
+function getSessionByContentId(db, contentSessionId) {
+  const query = db.query("SELECT * FROM sessions WHERE content_session_id = ?");
+  return query.get(contentSessionId);
+}
+function getSessionById(db, id) {
+  const query = db.query("SELECT * FROM sessions WHERE id = ?");
+  return query.get(id);
+}
+function updateSessionMemoryId(db, id, memorySessionId) {
+  db.run(
+    "UPDATE sessions SET memory_session_id = ? WHERE id = ?",
+    [memorySessionId, id]
+  );
+}
+function completeSession(db, id) {
+  const now = /* @__PURE__ */ new Date();
+  db.run(
+    `UPDATE sessions 
+     SET status = 'completed', completed_at = ?, completed_at_epoch = ?
+     WHERE id = ?`,
+    [now.toISOString(), now.getTime(), id]
+  );
+}
+function failSession(db, id) {
+  const now = /* @__PURE__ */ new Date();
+  db.run(
+    `UPDATE sessions 
+     SET status = 'failed', completed_at = ?, completed_at_epoch = ?
+     WHERE id = ?`,
+    [now.toISOString(), now.getTime(), id]
+  );
+}
+function getActiveSessions(db) {
+  const query = db.query("SELECT * FROM sessions WHERE status = 'active' ORDER BY started_at_epoch DESC");
+  return query.all();
+}
+function getSessionsByProject(db, project, limit = 100) {
+  const query = db.query("SELECT * FROM sessions WHERE project = ? ORDER BY started_at_epoch DESC LIMIT ?");
+  return query.all(project, limit);
+}
+var init_Sessions = __esm({
+  "src/services/sqlite/Sessions.ts"() {
+    "use strict";
+  }
+});
+
+// src/services/sqlite/Observations.ts
+var Observations_exports = {};
+__export(Observations_exports, {
+  createObservation: () => createObservation,
+  deleteObservation: () => deleteObservation,
+  getObservationsByProject: () => getObservationsByProject,
+  getObservationsBySession: () => getObservationsBySession,
+  searchObservations: () => searchObservations
+});
+function createObservation(db, memorySessionId, project, type, title, subtitle, text, narrative, facts, concepts, filesRead, filesModified, promptNumber) {
+  const now = /* @__PURE__ */ new Date();
+  const result = db.run(
+    `INSERT INTO observations 
+     (memory_session_id, project, type, title, subtitle, text, narrative, facts, concepts, files_read, files_modified, prompt_number, created_at, created_at_epoch)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    [memorySessionId, project, type, title, subtitle, text, narrative, facts, concepts, filesRead, filesModified, promptNumber, now.toISOString(), now.getTime()]
+  );
+  return Number(result.lastInsertRowid);
+}
+function getObservationsBySession(db, memorySessionId) {
+  const query = db.query(
+    "SELECT * FROM observations WHERE memory_session_id = ? ORDER BY prompt_number ASC"
+  );
+  return query.all(memorySessionId);
+}
+function getObservationsByProject(db, project, limit = 100) {
+  const query = db.query(
+    "SELECT * FROM observations WHERE project = ? ORDER BY created_at_epoch DESC LIMIT ?"
+  );
+  return query.all(project, limit);
+}
+function searchObservations(db, searchTerm, project) {
+  const sql = project ? `SELECT * FROM observations 
+       WHERE project = ? AND (title LIKE ? OR text LIKE ? OR narrative LIKE ?)
+       ORDER BY created_at_epoch DESC` : `SELECT * FROM observations 
+       WHERE title LIKE ? OR text LIKE ? OR narrative LIKE ?
+       ORDER BY created_at_epoch DESC`;
+  const pattern = `%${searchTerm}%`;
+  const query = db.query(sql);
+  if (project) {
+    return query.all(project, pattern, pattern, pattern);
+  }
+  return query.all(pattern, pattern, pattern);
+}
+function deleteObservation(db, id) {
+  db.run("DELETE FROM observations WHERE id = ?", [id]);
+}
+var init_Observations = __esm({
+  "src/services/sqlite/Observations.ts"() {
+    "use strict";
+  }
+});
+
+// src/services/sqlite/Summaries.ts
+var Summaries_exports = {};
+__export(Summaries_exports, {
+  createSummary: () => createSummary,
+  deleteSummary: () => deleteSummary,
+  getSummariesByProject: () => getSummariesByProject,
+  getSummaryBySession: () => getSummaryBySession,
+  searchSummaries: () => searchSummaries
+});
+function createSummary(db, sessionId, project, request, investigated, learned, completed, nextSteps, notes) {
+  const now = /* @__PURE__ */ new Date();
+  const result = db.run(
+    `INSERT INTO summaries 
+     (session_id, project, request, investigated, learned, completed, next_steps, notes, created_at, created_at_epoch)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    [sessionId, project, request, investigated, learned, completed, nextSteps, notes, now.toISOString(), now.getTime()]
+  );
+  return Number(result.lastInsertRowid);
+}
+function getSummaryBySession(db, sessionId) {
+  const query = db.query("SELECT * FROM summaries WHERE session_id = ? ORDER BY created_at_epoch DESC LIMIT 1");
+  return query.get(sessionId);
+}
+function getSummariesByProject(db, project, limit = 50) {
+  const query = db.query(
+    "SELECT * FROM summaries WHERE project = ? ORDER BY created_at_epoch DESC LIMIT ?"
+  );
+  return query.all(project, limit);
+}
+function searchSummaries(db, searchTerm, project) {
+  const sql = project ? `SELECT * FROM summaries 
+       WHERE project = ? AND (request LIKE ? OR learned LIKE ? OR completed LIKE ? OR notes LIKE ?)
+       ORDER BY created_at_epoch DESC` : `SELECT * FROM summaries 
+       WHERE request LIKE ? OR learned LIKE ? OR completed LIKE ? OR notes LIKE ?
+       ORDER BY created_at_epoch DESC`;
+  const pattern = `%${searchTerm}%`;
+  const query = db.query(sql);
+  if (project) {
+    return query.all(project, pattern, pattern, pattern, pattern);
+  }
+  return query.all(pattern, pattern, pattern, pattern);
+}
+function deleteSummary(db, id) {
+  db.run("DELETE FROM summaries WHERE id = ?", [id]);
+}
+var init_Summaries = __esm({
+  "src/services/sqlite/Summaries.ts"() {
+    "use strict";
+  }
+});
+
+// src/services/sqlite/Prompts.ts
+var Prompts_exports = {};
+__export(Prompts_exports, {
+  createPrompt: () => createPrompt,
+  deletePrompt: () => deletePrompt,
+  getLatestPrompt: () => getLatestPrompt,
+  getPromptsByProject: () => getPromptsByProject,
+  getPromptsBySession: () => getPromptsBySession
+});
+function createPrompt(db, contentSessionId, project, promptNumber, promptText) {
+  const now = /* @__PURE__ */ new Date();
+  const result = db.run(
+    `INSERT INTO prompts 
+     (content_session_id, project, prompt_number, prompt_text, created_at, created_at_epoch)
+     VALUES (?, ?, ?, ?, ?, ?)`,
+    [contentSessionId, project, promptNumber, promptText, now.toISOString(), now.getTime()]
+  );
+  return Number(result.lastInsertRowid);
+}
+function getPromptsBySession(db, contentSessionId) {
+  const query = db.query(
+    "SELECT * FROM prompts WHERE content_session_id = ? ORDER BY prompt_number ASC"
+  );
+  return query.all(contentSessionId);
+}
+function getPromptsByProject(db, project, limit = 100) {
+  const query = db.query(
+    "SELECT * FROM prompts WHERE project = ? ORDER BY created_at_epoch DESC LIMIT ?"
+  );
+  return query.all(project, limit);
+}
+function getLatestPrompt(db, contentSessionId) {
+  const query = db.query(
+    "SELECT * FROM prompts WHERE content_session_id = ? ORDER BY prompt_number DESC LIMIT 1"
+  );
+  return query.get(contentSessionId);
+}
+function deletePrompt(db, id) {
+  db.run("DELETE FROM prompts WHERE id = ?", [id]);
+}
+var init_Prompts = __esm({
+  "src/services/sqlite/Prompts.ts"() {
+    "use strict";
+  }
+});
+
+// src/services/sqlite/Search.ts
+var Search_exports = {};
+__export(Search_exports, {
+  getObservationsByIds: () => getObservationsByIds,
+  getProjectStats: () => getProjectStats,
+  getTimeline: () => getTimeline,
+  searchObservationsFTS: () => searchObservationsFTS,
+  searchObservationsLIKE: () => searchObservationsLIKE,
+  searchSummariesFiltered: () => searchSummariesFiltered
+});
+function searchObservationsFTS(db, query, filters = {}) {
+  const limit = filters.limit || 50;
+  try {
+    let sql = `
+      SELECT o.* FROM observations o
+      JOIN observations_fts fts ON o.id = fts.rowid
+      WHERE observations_fts MATCH ?
+    `;
+    const params = [query];
+    if (filters.project) {
+      sql += " AND o.project = ?";
+      params.push(filters.project);
+    }
+    if (filters.type) {
+      sql += " AND o.type = ?";
+      params.push(filters.type);
+    }
+    if (filters.dateStart) {
+      sql += " AND o.created_at_epoch >= ?";
+      params.push(filters.dateStart);
+    }
+    if (filters.dateEnd) {
+      sql += " AND o.created_at_epoch <= ?";
+      params.push(filters.dateEnd);
+    }
+    sql += " ORDER BY rank LIMIT ?";
+    params.push(limit);
+    const stmt = db.query(sql);
+    return stmt.all(...params);
+  } catch {
+    return searchObservationsLIKE(db, query, filters);
+  }
+}
+function searchObservationsLIKE(db, query, filters = {}) {
+  const limit = filters.limit || 50;
+  const pattern = `%${query}%`;
+  let sql = `
+    SELECT * FROM observations
+    WHERE (title LIKE ? OR text LIKE ? OR narrative LIKE ? OR concepts LIKE ?)
+  `;
+  const params = [pattern, pattern, pattern, pattern];
+  if (filters.project) {
+    sql += " AND project = ?";
+    params.push(filters.project);
+  }
+  if (filters.type) {
+    sql += " AND type = ?";
+    params.push(filters.type);
+  }
+  if (filters.dateStart) {
+    sql += " AND created_at_epoch >= ?";
+    params.push(filters.dateStart);
+  }
+  if (filters.dateEnd) {
+    sql += " AND created_at_epoch <= ?";
+    params.push(filters.dateEnd);
+  }
+  sql += " ORDER BY created_at_epoch DESC LIMIT ?";
+  params.push(limit);
+  const stmt = db.query(sql);
+  return stmt.all(...params);
+}
+function searchSummariesFiltered(db, query, filters = {}) {
+  const limit = filters.limit || 20;
+  const pattern = `%${query}%`;
+  let sql = `
+    SELECT * FROM summaries
+    WHERE (request LIKE ? OR learned LIKE ? OR completed LIKE ? OR notes LIKE ? OR next_steps LIKE ?)
+  `;
+  const params = [pattern, pattern, pattern, pattern, pattern];
+  if (filters.project) {
+    sql += " AND project = ?";
+    params.push(filters.project);
+  }
+  if (filters.dateStart) {
+    sql += " AND created_at_epoch >= ?";
+    params.push(filters.dateStart);
+  }
+  if (filters.dateEnd) {
+    sql += " AND created_at_epoch <= ?";
+    params.push(filters.dateEnd);
+  }
+  sql += " ORDER BY created_at_epoch DESC LIMIT ?";
+  params.push(limit);
+  const stmt = db.query(sql);
+  return stmt.all(...params);
+}
+function getObservationsByIds(db, ids) {
+  if (ids.length === 0) return [];
+  const placeholders = ids.map(() => "?").join(",");
+  const sql = `SELECT * FROM observations WHERE id IN (${placeholders}) ORDER BY created_at_epoch DESC`;
+  const stmt = db.query(sql);
+  return stmt.all(...ids);
+}
+function getTimeline(db, anchorId, depthBefore = 5, depthAfter = 5) {
+  const anchorStmt = db.query("SELECT created_at_epoch FROM observations WHERE id = ?");
+  const anchor = anchorStmt.get(anchorId);
+  if (!anchor) return [];
+  const anchorEpoch = anchor.created_at_epoch;
+  const beforeStmt = db.query(`
+    SELECT id, 'observation' as type, title, text as content, project, created_at, created_at_epoch
+    FROM observations
+    WHERE created_at_epoch < ?
+    ORDER BY created_at_epoch DESC
+    LIMIT ?
+  `);
+  const before = beforeStmt.all(anchorEpoch, depthBefore).reverse();
+  const selfStmt = db.query(`
+    SELECT id, 'observation' as type, title, text as content, project, created_at, created_at_epoch
+    FROM observations WHERE id = ?
+  `);
+  const self = selfStmt.all(anchorId);
+  const afterStmt = db.query(`
+    SELECT id, 'observation' as type, title, text as content, project, created_at, created_at_epoch
+    FROM observations
+    WHERE created_at_epoch > ?
+    ORDER BY created_at_epoch ASC
+    LIMIT ?
+  `);
+  const after = afterStmt.all(anchorEpoch, depthAfter);
+  return [...before, ...self, ...after];
+}
+function getProjectStats(db, project) {
+  const obsStmt = db.query("SELECT COUNT(*) as count FROM observations WHERE project = ?");
+  const sumStmt = db.query("SELECT COUNT(*) as count FROM summaries WHERE project = ?");
+  const sesStmt = db.query("SELECT COUNT(*) as count FROM sessions WHERE project = ?");
+  const prmStmt = db.query("SELECT COUNT(*) as count FROM prompts WHERE project = ?");
+  return {
+    observations: obsStmt.get(project)?.count || 0,
+    summaries: sumStmt.get(project)?.count || 0,
+    sessions: sesStmt.get(project)?.count || 0,
+    prompts: prmStmt.get(project)?.count || 0
+  };
+}
+var init_Search = __esm({
+  "src/services/sqlite/Search.ts"() {
+    "use strict";
+  }
+});
+
+// src/shims/bun-sqlite.ts
+var import_better_sqlite3 = __toESM(require_lib());
+var Database = class {
+  _db;
+  constructor(path, options) {
+    this._db = new import_better_sqlite3.default(path, {
+      // better-sqlite3 crea il file di default (non serve 'create')
+      readonly: options?.readwrite === false ? true : false
+    });
+  }
+  /**
+   * Esegui una query SQL senza risultati
+   */
+  run(sql, params) {
+    const stmt = this._db.prepare(sql);
+    const result = params ? stmt.run(...params) : stmt.run();
+    return result;
+  }
+  /**
+   * Prepara una query con interfaccia compatibile bun:sqlite
+   */
+  query(sql) {
+    return new BunQueryCompat(this._db, sql);
+  }
+  /**
+   * Crea una transazione
+   */
+  transaction(fn) {
+    return this._db.transaction(fn);
+  }
+  /**
+   * Chiudi la connessione
+   */
+  close() {
+    this._db.close();
+  }
+};
+var BunQueryCompat = class {
+  _db;
+  _sql;
+  constructor(db, sql) {
+    this._db = db;
+    this._sql = sql;
+  }
+  /**
+   * Restituisce tutte le righe
+   */
+  all(...params) {
+    const stmt = this._db.prepare(this._sql);
+    return params.length > 0 ? stmt.all(...params) : stmt.all();
+  }
+  /**
+   * Restituisce la prima riga o null
+   */
+  get(...params) {
+    const stmt = this._db.prepare(this._sql);
+    return params.length > 0 ? stmt.get(...params) : stmt.get();
+  }
+  /**
+   * Esegui senza risultati
+   */
+  run(...params) {
+    const stmt = this._db.prepare(this._sql);
+    return params.length > 0 ? stmt.run(...params) : stmt.run();
+  }
+};
+
+// src/shared/paths.ts
+import { join as join2, dirname, basename } from "path";
+import { homedir as homedir2 } from "os";
+import { mkdirSync as mkdirSync2 } from "fs";
+import { fileURLToPath } from "url";
+
+// src/utils/logger.ts
+import { appendFileSync, existsSync, mkdirSync, readFileSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
+  LogLevel2[LogLevel2["DEBUG"] = 0] = "DEBUG";
+  LogLevel2[LogLevel2["INFO"] = 1] = "INFO";
+  LogLevel2[LogLevel2["WARN"] = 2] = "WARN";
+  LogLevel2[LogLevel2["ERROR"] = 3] = "ERROR";
+  LogLevel2[LogLevel2["SILENT"] = 4] = "SILENT";
+  return LogLevel2;
+})(LogLevel || {});
+var DEFAULT_DATA_DIR = join(homedir(), ".contextkit");
+var Logger = class {
+  level = null;
+  useColor;
+  logFilePath = null;
+  logFileInitialized = false;
+  constructor() {
+    this.useColor = process.stdout.isTTY ?? false;
+  }
+  /**
+   * Initialize log file path and ensure directory exists (lazy initialization)
+   */
+  ensureLogFileInitialized() {
+    if (this.logFileInitialized) return;
+    this.logFileInitialized = true;
+    try {
+      const logsDir = join(DEFAULT_DATA_DIR, "logs");
+      if (!existsSync(logsDir)) {
+        mkdirSync(logsDir, { recursive: true });
+      }
+      const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+      this.logFilePath = join(logsDir, `contextkit-${date}.log`);
+    } catch (error) {
+      console.error("[LOGGER] Failed to initialize log file:", error);
+      this.logFilePath = null;
+    }
+  }
+  /**
+   * Lazy-load log level from settings file
+   */
+  getLevel() {
+    if (this.level === null) {
+      try {
+        const settingsPath = join(DEFAULT_DATA_DIR, "settings.json");
+        if (existsSync(settingsPath)) {
+          const settingsData = readFileSync(settingsPath, "utf-8");
+          const settings = JSON.parse(settingsData);
+          const envLevel = (settings.CONTEXTKIT_LOG_LEVEL || "INFO").toUpperCase();
+          this.level = LogLevel[envLevel] ?? 1 /* INFO */;
+        } else {
+          this.level = 1 /* INFO */;
+        }
+      } catch (error) {
+        this.level = 1 /* INFO */;
+      }
+    }
+    return this.level;
+  }
+  /**
+   * Create correlation ID for tracking an observation through the pipeline
+   */
+  correlationId(sessionId, observationNum) {
+    return `obs-${sessionId}-${observationNum}`;
+  }
+  /**
+   * Create session correlation ID
+   */
+  sessionId(sessionId) {
+    return `session-${sessionId}`;
+  }
+  /**
+   * Format data for logging - create compact summaries instead of full dumps
+   */
+  formatData(data) {
+    if (data === null || data === void 0) return "";
+    if (typeof data === "string") return data;
+    if (typeof data === "number") return data.toString();
+    if (typeof data === "boolean") return data.toString();
+    if (typeof data === "object") {
+      if (data instanceof Error) {
+        return this.getLevel() === 0 /* DEBUG */ ? `${data.message}
+${data.stack}` : data.message;
+      }
+      if (Array.isArray(data)) {
+        return `[${data.length} items]`;
+      }
+      const keys = Object.keys(data);
+      if (keys.length === 0) return "{}";
+      if (keys.length <= 3) {
+        return JSON.stringify(data);
+      }
+      return `{${keys.length} keys: ${keys.slice(0, 3).join(", ")}...}`;
+    }
+    return String(data);
+  }
+  /**
+   * Format timestamp in local timezone (YYYY-MM-DD HH:MM:SS.mmm)
+   */
+  formatTimestamp(date) {
+    const year = date.getFullYear();
+    const month = String(date.getMonth() + 1).padStart(2, "0");
+    const day = String(date.getDate()).padStart(2, "0");
+    const hours = String(date.getHours()).padStart(2, "0");
+    const minutes = String(date.getMinutes()).padStart(2, "0");
+    const seconds = String(date.getSeconds()).padStart(2, "0");
+    const ms = String(date.getMilliseconds()).padStart(3, "0");
+    return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}.${ms}`;
+  }
+  /**
+   * Core logging method
+   */
+  log(level, component, message, context, data) {
+    if (level < this.getLevel()) return;
+    this.ensureLogFileInitialized();
+    const timestamp = this.formatTimestamp(/* @__PURE__ */ new Date());
+    const levelStr = LogLevel[level].padEnd(5);
+    const componentStr = component.padEnd(6);
+    let correlationStr = "";
+    if (context?.correlationId) {
+      correlationStr = `[${context.correlationId}] `;
+    } else if (context?.sessionId) {
+      correlationStr = `[session-${context.sessionId}] `;
+    }
+    let dataStr = "";
+    if (data !== void 0 && data !== null) {
+      if (data instanceof Error) {
+        dataStr = this.getLevel() === 0 /* DEBUG */ ? `
+${data.message}
+${data.stack}` : ` ${data.message}`;
+      } else if (this.getLevel() === 0 /* DEBUG */ && typeof data === "object") {
+        dataStr = "\n" + JSON.stringify(data, null, 2);
+      } else {
+        dataStr = " " + this.formatData(data);
+      }
+    }
+    let contextStr = "";
+    if (context) {
+      const { sessionId, memorySessionId, correlationId, ...rest } = context;
+      if (Object.keys(rest).length > 0) {
+        const pairs = Object.entries(rest).map(([k, v]) => `${k}=${v}`);
+        contextStr = ` {${pairs.join(", ")}}`;
+      }
+    }
+    const logLine = `[${timestamp}] [${levelStr}] [${componentStr}] ${correlationStr}${message}${contextStr}${dataStr}`;
+    if (this.logFilePath) {
+      try {
+        appendFileSync(this.logFilePath, logLine + "\n", "utf8");
+      } catch (error) {
+        process.stderr.write(`[LOGGER] Failed to write to log file: ${error}
+`);
+      }
+    } else {
+      process.stderr.write(logLine + "\n");
+    }
+  }
+  // Public logging methods
+  debug(component, message, context, data) {
+    this.log(0 /* DEBUG */, component, message, context, data);
+  }
+  info(component, message, context, data) {
+    this.log(1 /* INFO */, component, message, context, data);
+  }
+  warn(component, message, context, data) {
+    this.log(2 /* WARN */, component, message, context, data);
+  }
+  error(component, message, context, data) {
+    this.log(3 /* ERROR */, component, message, context, data);
+  }
+  /**
+   * Log data flow: input → processing
+   */
+  dataIn(component, message, context, data) {
+    this.info(component, `\u2192 ${message}`, context, data);
+  }
+  /**
+   * Log data flow: processing → output
+   */
+  dataOut(component, message, context, data) {
+    this.info(component, `\u2190 ${message}`, context, data);
+  }
+  /**
+   * Log successful completion
+   */
+  success(component, message, context, data) {
+    this.info(component, `\u2713 ${message}`, context, data);
+  }
+  /**
+   * Log failure
+   */
+  failure(component, message, context, data) {
+    this.error(component, `\u2717 ${message}`, context, data);
+  }
+  /**
+   * Log timing information
+   */
+  timing(component, message, durationMs, context) {
+    this.info(component, `\u23F1 ${message}`, context, { duration: `${durationMs}ms` });
+  }
+  /**
+   * Happy Path Error - logs when the expected "happy path" fails but we have a fallback
+   */
+  happyPathError(component, message, context, data, fallback = "") {
+    const stack = new Error().stack || "";
+    const stackLines = stack.split("\n");
+    const callerLine = stackLines[2] || "";
+    const callerMatch = callerLine.match(/at\s+(?:.*\s+)?\(?([^:]+):(\d+):(\d+)\)?/);
+    const location = callerMatch ? `${callerMatch[1].split("/").pop()}:${callerMatch[2]}` : "unknown";
+    const enhancedContext = {
+      ...context,
+      location
+    };
+    this.warn(component, `[HAPPY-PATH] ${message}`, enhancedContext, data);
+    return fallback;
+  }
+};
+var logger = new Logger();
+
+// src/shared/paths.ts
+function getDirname() {
+  if (typeof __dirname !== "undefined") {
+    return __dirname;
+  }
+  return dirname(fileURLToPath(import.meta.url));
+}
+var _dirname = getDirname();
+var DATA_DIR = process.env.CONTEXTKIT_DATA_DIR || join2(homedir2(), ".contextkit");
+var KIRO_CONFIG_DIR = process.env.KIRO_CONFIG_DIR || join2(homedir2(), ".kiro");
+var PLUGIN_ROOT = join2(KIRO_CONFIG_DIR, "plugins", "contextkit");
+var ARCHIVES_DIR = join2(DATA_DIR, "archives");
+var LOGS_DIR = join2(DATA_DIR, "logs");
+var TRASH_DIR = join2(DATA_DIR, "trash");
+var BACKUPS_DIR = join2(DATA_DIR, "backups");
+var MODES_DIR = join2(DATA_DIR, "modes");
+var USER_SETTINGS_PATH = join2(DATA_DIR, "settings.json");
+var DB_PATH = join2(DATA_DIR, "contextkit.db");
+var VECTOR_DB_DIR = join2(DATA_DIR, "vector-db");
+var OBSERVER_SESSIONS_DIR = join2(DATA_DIR, "observer-sessions");
+var KIRO_SETTINGS_PATH = join2(KIRO_CONFIG_DIR, "settings.json");
+var KIRO_CONTEXT_PATH = join2(KIRO_CONFIG_DIR, "context.md");
+function ensureDir(dirPath) {
+  mkdirSync2(dirPath, { recursive: true });
+}
+
+// src/services/sqlite/Database.ts
+var SQLITE_MMAP_SIZE_BYTES = 256 * 1024 * 1024;
+var SQLITE_CACHE_SIZE_PAGES = 1e4;
+var dbInstance = null;
+var ContextKitDatabase = class {
+  db;
+  constructor(dbPath = DB_PATH) {
+    if (dbPath !== ":memory:") {
+      ensureDir(DATA_DIR);
+    }
+    this.db = new Database(dbPath, { create: true, readwrite: true });
+    this.db.run("PRAGMA journal_mode = WAL");
+    this.db.run("PRAGMA synchronous = NORMAL");
+    this.db.run("PRAGMA foreign_keys = ON");
+    this.db.run("PRAGMA temp_store = memory");
+    this.db.run(`PRAGMA mmap_size = ${SQLITE_MMAP_SIZE_BYTES}`);
+    this.db.run(`PRAGMA cache_size = ${SQLITE_CACHE_SIZE_PAGES}`);
+    const migrationRunner = new MigrationRunner(this.db);
+    migrationRunner.runAllMigrations();
+  }
+  /**
+   * Close the database connection
+   */
+  close() {
+    this.db.close();
+  }
+};
+var DatabaseManager = class _DatabaseManager {
+  static instance;
+  db = null;
+  migrations = [];
+  static getInstance() {
+    if (!_DatabaseManager.instance) {
+      _DatabaseManager.instance = new _DatabaseManager();
+    }
+    return _DatabaseManager.instance;
+  }
+  /**
+   * Register a migration to be run during initialization
+   */
+  registerMigration(migration) {
+    this.migrations.push(migration);
+    this.migrations.sort((a, b) => a.version - b.version);
+  }
+  /**
+   * Initialize database connection with optimized settings
+   */
+  async initialize() {
+    if (this.db) {
+      return this.db;
+    }
+    ensureDir(DATA_DIR);
+    this.db = new Database(DB_PATH, { create: true, readwrite: true });
+    this.db.run("PRAGMA journal_mode = WAL");
+    this.db.run("PRAGMA synchronous = NORMAL");
+    this.db.run("PRAGMA foreign_keys = ON");
+    this.db.run("PRAGMA temp_store = memory");
+    this.db.run(`PRAGMA mmap_size = ${SQLITE_MMAP_SIZE_BYTES}`);
+    this.db.run(`PRAGMA cache_size = ${SQLITE_CACHE_SIZE_PAGES}`);
+    this.initializeSchemaVersions();
+    await this.runMigrations();
+    dbInstance = this.db;
+    return this.db;
+  }
+  /**
+   * Get the current database connection
+   */
+  getConnection() {
+    if (!this.db) {
+      throw new Error("Database not initialized. Call initialize() first.");
+    }
+    return this.db;
+  }
+  /**
+   * Execute a function within a transaction
+   */
+  withTransaction(fn) {
+    const db = this.getConnection();
+    const transaction = db.transaction(fn);
+    return transaction(db);
+  }
+  /**
+   * Close the database connection
+   */
+  close() {
+    if (this.db) {
+      this.db.close();
+      this.db = null;
+      dbInstance = null;
+    }
+  }
+  /**
+   * Initialize the schema_versions table
+   */
+  initializeSchemaVersions() {
+    if (!this.db) return;
+    this.db.run(`
+      CREATE TABLE IF NOT EXISTS schema_versions (
+        id INTEGER PRIMARY KEY,
+        version INTEGER UNIQUE NOT NULL,
+        applied_at TEXT NOT NULL
+      )
+    `);
+  }
+  /**
+   * Run all pending migrations
+   */
+  async runMigrations() {
+    if (!this.db) return;
+    const query = this.db.query("SELECT version FROM schema_versions ORDER BY version");
+    const appliedVersions = query.all().map((row) => row.version);
+    const maxApplied = appliedVersions.length > 0 ? Math.max(...appliedVersions) : 0;
+    for (const migration of this.migrations) {
+      if (migration.version > maxApplied) {
+        logger.info("DB", `Applying migration ${migration.version}`);
+        const transaction = this.db.transaction(() => {
+          migration.up(this.db);
+          const insertQuery = this.db.query("INSERT INTO schema_versions (version, applied_at) VALUES (?, ?)");
+          insertQuery.run(migration.version, (/* @__PURE__ */ new Date()).toISOString());
+        });
+        transaction();
+        logger.info("DB", `Migration ${migration.version} applied successfully`);
+      }
+    }
+  }
+  /**
+   * Get current schema version
+   */
+  getCurrentVersion() {
+    if (!this.db) return 0;
+    const query = this.db.query("SELECT MAX(version) as version FROM schema_versions");
+    const result = query.get();
+    return result?.version || 0;
+  }
+};
+var MigrationRunner = class {
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  runAllMigrations() {
+    this.db.run(`
+      CREATE TABLE IF NOT EXISTS schema_versions (
+        id INTEGER PRIMARY KEY,
+        version INTEGER UNIQUE NOT NULL,
+        applied_at TEXT NOT NULL
+      )
+    `);
+    const versionQuery = this.db.query("SELECT MAX(version) as version FROM schema_versions");
+    const result = versionQuery.get();
+    const currentVersion = result?.version || 0;
+    const migrations = this.getMigrations();
+    for (const migration of migrations) {
+      if (migration.version > currentVersion) {
+        logger.info("DB", `Applying migration ${migration.version}`);
+        const transaction = this.db.transaction(() => {
+          migration.up(this.db);
+          const insert = this.db.query("INSERT INTO schema_versions (version, applied_at) VALUES (?, ?)");
+          insert.run(migration.version, (/* @__PURE__ */ new Date()).toISOString());
+        });
+        transaction();
+        logger.info("DB", `Migration ${migration.version} applied successfully`);
+      }
+    }
+  }
+  getMigrations() {
+    return [
+      {
+        version: 1,
+        up: (db) => {
+          db.run(`
+            CREATE TABLE IF NOT EXISTS sessions (
+              id INTEGER PRIMARY KEY AUTOINCREMENT,
+              content_session_id TEXT NOT NULL UNIQUE,
+              project TEXT NOT NULL,
+              user_prompt TEXT NOT NULL,
+              memory_session_id TEXT,
+              status TEXT DEFAULT 'active',
+              started_at TEXT NOT NULL,
+              started_at_epoch INTEGER NOT NULL,
+              completed_at TEXT,
+              completed_at_epoch INTEGER
+            )
+          `);
+          db.run(`
+            CREATE TABLE IF NOT EXISTS observations (
+              id INTEGER PRIMARY KEY AUTOINCREMENT,
+              memory_session_id TEXT NOT NULL,
+              project TEXT NOT NULL,
+              type TEXT NOT NULL,
+              title TEXT NOT NULL,
+              subtitle TEXT,
+              text TEXT,
+              narrative TEXT,
+              facts TEXT,
+              concepts TEXT,
+              files_read TEXT,
+              files_modified TEXT,
+              prompt_number INTEGER NOT NULL,
+              created_at TEXT NOT NULL,
+              created_at_epoch INTEGER NOT NULL
+            )
+          `);
+          db.run(`
+            CREATE TABLE IF NOT EXISTS summaries (
+              id INTEGER PRIMARY KEY AUTOINCREMENT,
+              session_id TEXT NOT NULL,
+              project TEXT NOT NULL,
+              request TEXT,
+              investigated TEXT,
+              learned TEXT,
+              completed TEXT,
+              next_steps TEXT,
+              notes TEXT,
+              created_at TEXT NOT NULL,
+              created_at_epoch INTEGER NOT NULL
+            )
+          `);
+          db.run(`
+            CREATE TABLE IF NOT EXISTS prompts (
+              id INTEGER PRIMARY KEY AUTOINCREMENT,
+              content_session_id TEXT NOT NULL,
+              project TEXT NOT NULL,
+              prompt_number INTEGER NOT NULL,
+              prompt_text TEXT NOT NULL,
+              created_at TEXT NOT NULL,
+              created_at_epoch INTEGER NOT NULL
+            )
+          `);
+          db.run(`
+            CREATE TABLE IF NOT EXISTS pending_messages (
+              id INTEGER PRIMARY KEY AUTOINCREMENT,
+              content_session_id TEXT NOT NULL,
+              type TEXT NOT NULL,
+              data TEXT NOT NULL,
+              created_at TEXT NOT NULL,
+              created_at_epoch INTEGER NOT NULL
+            )
+          `);
+          db.run("CREATE INDEX IF NOT EXISTS idx_sessions_project ON sessions(project)");
+          db.run("CREATE INDEX IF NOT EXISTS idx_observations_project ON observations(project)");
+          db.run("CREATE INDEX IF NOT EXISTS idx_observations_session ON observations(memory_session_id)");
+          db.run("CREATE INDEX IF NOT EXISTS idx_summaries_session ON summaries(session_id)");
+          db.run("CREATE INDEX IF NOT EXISTS idx_prompts_session ON prompts(content_session_id)");
+        }
+      },
+      {
+        version: 2,
+        up: (db) => {
+          db.run(`
+            CREATE VIRTUAL TABLE IF NOT EXISTS observations_fts USING fts5(
+              title, text, narrative, concepts,
+              content='observations',
+              content_rowid='id'
+            )
+          `);
+          db.run(`
+            CREATE TRIGGER IF NOT EXISTS observations_ai AFTER INSERT ON observations BEGIN
+              INSERT INTO observations_fts(rowid, title, text, narrative, concepts)
+              VALUES (new.id, new.title, new.text, new.narrative, new.concepts);
+            END
+          `);
+          db.run(`
+            CREATE TRIGGER IF NOT EXISTS observations_ad AFTER DELETE ON observations BEGIN
+              INSERT INTO observations_fts(observations_fts, rowid, title, text, narrative, concepts)
+              VALUES ('delete', old.id, old.title, old.text, old.narrative, old.concepts);
+            END
+          `);
+          db.run(`
+            CREATE TRIGGER IF NOT EXISTS observations_au AFTER UPDATE ON observations BEGIN
+              INSERT INTO observations_fts(observations_fts, rowid, title, text, narrative, concepts)
+              VALUES ('delete', old.id, old.title, old.text, old.narrative, old.concepts);
+              INSERT INTO observations_fts(rowid, title, text, narrative, concepts)
+              VALUES (new.id, new.title, new.text, new.narrative, new.concepts);
+            END
+          `);
+          db.run(`
+            INSERT INTO observations_fts(rowid, title, text, narrative, concepts)
+            SELECT id, title, text, narrative, concepts FROM observations
+          `);
+          db.run("CREATE INDEX IF NOT EXISTS idx_observations_type ON observations(type)");
+          db.run("CREATE INDEX IF NOT EXISTS idx_observations_epoch ON observations(created_at_epoch)");
+          db.run("CREATE INDEX IF NOT EXISTS idx_summaries_project ON summaries(project)");
+          db.run("CREATE INDEX IF NOT EXISTS idx_summaries_epoch ON summaries(created_at_epoch)");
+          db.run("CREATE INDEX IF NOT EXISTS idx_prompts_project ON prompts(project)");
+        }
+      }
+    ];
+  }
+};
+function getDatabase() {
+  if (!dbInstance) {
+    throw new Error("Database not initialized. Call DatabaseManager.getInstance().initialize() first.");
+  }
+  return dbInstance;
+}
+async function initializeDatabase() {
+  const manager = DatabaseManager.getInstance();
+  return await manager.initialize();
+}
+
+// src/services/sqlite/index.ts
+init_Sessions();
+init_Observations();
+init_Summaries();
+init_Prompts();
+init_Search();
+
+// src/sdk/index.ts
+var ContextKitSDK = class {
+  db;
+  project;
+  constructor(config = {}) {
+    this.db = new ContextKitDatabase(config.dataDir);
+    this.project = config.project || this.detectProject();
+  }
+  detectProject() {
+    try {
+      const { execSync } = __require("child_process");
+      const gitRoot = execSync("git rev-parse --show-toplevel", {
+        cwd: process.cwd(),
+        encoding: "utf8",
+        stdio: ["pipe", "pipe", "ignore"]
+      }).trim();
+      return gitRoot.split("/").pop() || "default";
+    } catch {
+      return "default";
+    }
+  }
+  /**
+   * Get context for the current project
+   */
+  async getContext() {
+    const { getObservationsByProject: getObservationsByProject2 } = await Promise.resolve().then(() => (init_Observations(), Observations_exports));
+    const { getSummariesByProject: getSummariesByProject2 } = await Promise.resolve().then(() => (init_Summaries(), Summaries_exports));
+    const { getPromptsByProject: getPromptsByProject2 } = await Promise.resolve().then(() => (init_Prompts(), Prompts_exports));
+    return {
+      project: this.project,
+      relevantObservations: getObservationsByProject2(this.db.db, this.project, 20),
+      relevantSummaries: getSummariesByProject2(this.db.db, this.project, 5),
+      recentPrompts: getPromptsByProject2(this.db.db, this.project, 10)
+    };
+  }
+  /**
+   * Store a new observation
+   */
+  async storeObservation(data) {
+    const { createObservation: createObservation2 } = await Promise.resolve().then(() => (init_Observations(), Observations_exports));
+    return createObservation2(
+      this.db.db,
+      "sdk-" + Date.now(),
+      this.project,
+      data.type,
+      data.title,
+      null,
+      // subtitle
+      data.content,
+      null,
+      // narrative
+      null,
+      // facts
+      data.concepts?.join(", ") || null,
+      data.files?.join(", ") || null,
+      // files_read
+      data.files?.join(", ") || null,
+      // files_modified
+      0
+      // prompt_number
+    );
+  }
+  /**
+   * Store a session summary
+   */
+  async storeSummary(data) {
+    const { createSummary: createSummary2 } = await Promise.resolve().then(() => (init_Summaries(), Summaries_exports));
+    return createSummary2(
+      this.db.db,
+      "sdk-" + Date.now(),
+      this.project,
+      data.request || null,
+      null,
+      data.learned || null,
+      data.completed || null,
+      data.nextSteps || null,
+      null
+    );
+  }
+  /**
+   * Search across all stored context
+   */
+  async search(query) {
+    const { searchObservations: searchObservations2 } = await Promise.resolve().then(() => (init_Observations(), Observations_exports));
+    const { searchSummaries: searchSummaries2 } = await Promise.resolve().then(() => (init_Summaries(), Summaries_exports));
+    return {
+      observations: searchObservations2(this.db.db, query, this.project),
+      summaries: searchSummaries2(this.db.db, query, this.project)
+    };
+  }
+  /**
+   * Get recent observations
+   */
+  async getRecentObservations(limit = 10) {
+    const { getObservationsByProject: getObservationsByProject2 } = await Promise.resolve().then(() => (init_Observations(), Observations_exports));
+    return getObservationsByProject2(this.db.db, this.project, limit);
+  }
+  /**
+   * Get recent summaries
+   */
+  async getRecentSummaries(limit = 5) {
+    const { getSummariesByProject: getSummariesByProject2 } = await Promise.resolve().then(() => (init_Summaries(), Summaries_exports));
+    return getSummariesByProject2(this.db.db, this.project, limit);
+  }
+  /**
+   * Ricerca avanzata con FTS5 e filtri
+   */
+  async searchAdvanced(query, filters = {}) {
+    const { searchObservationsFTS: searchObservationsFTS2 } = await Promise.resolve().then(() => (init_Search(), Search_exports));
+    const { searchSummariesFiltered: searchSummariesFiltered2 } = await Promise.resolve().then(() => (init_Search(), Search_exports));
+    const projectFilters = { ...filters, project: filters.project || this.project };
+    return {
+      observations: searchObservationsFTS2(this.db.db, query, projectFilters),
+      summaries: searchSummariesFiltered2(this.db.db, query, projectFilters)
+    };
+  }
+  /**
+   * Recupera osservazioni per ID (batch)
+   */
+  async getObservationsByIds(ids) {
+    const { getObservationsByIds: getObservationsByIds2 } = await Promise.resolve().then(() => (init_Search(), Search_exports));
+    return getObservationsByIds2(this.db.db, ids);
+  }
+  /**
+   * Timeline: contesto cronologico attorno a un'osservazione
+   */
+  async getTimeline(anchorId, depthBefore = 5, depthAfter = 5) {
+    const { getTimeline: getTimeline2 } = await Promise.resolve().then(() => (init_Search(), Search_exports));
+    return getTimeline2(this.db.db, anchorId, depthBefore, depthAfter);
+  }
+  /**
+   * Crea o recupera una sessione per il progetto corrente
+   */
+  async getOrCreateSession(contentSessionId) {
+    const { getSessionByContentId: getSessionByContentId2, createSession: createSession2 } = await Promise.resolve().then(() => (init_Sessions(), Sessions_exports));
+    let session = getSessionByContentId2(this.db.db, contentSessionId);
+    if (!session) {
+      const id = createSession2(this.db.db, contentSessionId, this.project, "");
+      session = {
+        id,
+        content_session_id: contentSessionId,
+        project: this.project,
+        user_prompt: "",
+        memory_session_id: null,
+        status: "active",
+        started_at: (/* @__PURE__ */ new Date()).toISOString(),
+        started_at_epoch: Date.now(),
+        completed_at: null,
+        completed_at_epoch: null
+      };
+    }
+    return session;
+  }
+  /**
+   * Salva un prompt utente
+   */
+  async storePrompt(contentSessionId, promptNumber, text) {
+    const { createPrompt: createPrompt2 } = await Promise.resolve().then(() => (init_Prompts(), Prompts_exports));
+    return createPrompt2(this.db.db, contentSessionId, this.project, promptNumber, text);
+  }
+  /**
+   * Completa una sessione
+   */
+  async completeSession(sessionId) {
+    const { completeSession: completeSession2 } = await Promise.resolve().then(() => (init_Sessions(), Sessions_exports));
+    completeSession2(this.db.db, sessionId);
+  }
+  /**
+   * Getter per il nome progetto corrente
+   */
+  getProject() {
+    return this.project;
+  }
+  /**
+   * Getter per accesso diretto al database (per route API)
+   */
+  getDb() {
+    return this.db.db;
+  }
+  /**
+   * Close database connection
+   */
+  close() {
+    this.db.close();
+  }
+};
+function createContextKit(config) {
+  return new ContextKitSDK(config);
+}
+
+// src/index.ts
+init_Search();
+
+// src/hooks/utils.ts
+async function readStdin() {
+  return new Promise((resolve, reject) => {
+    let data = "";
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (chunk) => {
+      data += chunk;
+    });
+    process.stdin.on("end", () => {
+      try {
+        if (!data.trim()) {
+          resolve({
+            hook_event_name: "agentSpawn",
+            cwd: process.cwd()
+          });
+          return;
+        }
+        resolve(JSON.parse(data));
+      } catch (err) {
+        reject(new Error(`Errore parsing stdin JSON: ${err}`));
+      }
+    });
+    process.stdin.on("error", reject);
+    setTimeout(() => {
+      if (!data.trim()) {
+        resolve({
+          hook_event_name: "agentSpawn",
+          cwd: process.cwd()
+        });
+      }
+    }, 5e3);
+  });
+}
+function detectProject(cwd) {
+  try {
+    const { execSync } = __require("child_process");
+    const gitRoot = execSync("git rev-parse --show-toplevel", {
+      cwd,
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "ignore"]
+    }).trim();
+    return gitRoot.split("/").pop() || "default";
+  } catch {
+    return cwd.split("/").pop() || "default";
+  }
+}
+function formatContext(data) {
+  let output = "";
+  if (data.summaries && data.summaries.length > 0) {
+    output += "## Sessioni Precedenti\n\n";
+    data.summaries.slice(0, 3).forEach((sum) => {
+      if (sum.learned) output += `- **Appreso**: ${sum.learned}
+`;
+      if (sum.completed) output += `- **Completato**: ${sum.completed}
+`;
+      if (sum.next_steps) output += `- **Prossimi passi**: ${sum.next_steps}
+`;
+      output += "\n";
+    });
+  }
+  if (data.observations && data.observations.length > 0) {
+    output += "## Osservazioni Recenti\n\n";
+    data.observations.slice(0, 10).forEach((obs) => {
+      const text = obs.text ? obs.text.substring(0, 150) : "";
+      output += `- **[${obs.type || "obs"}] ${obs.title}**: ${text}
+`;
+    });
+    output += "\n";
+  }
+  return output;
+}
+async function runHook(name, handler) {
+  try {
+    const input = await readStdin();
+    await handler(input);
+    process.exit(0);
+  } catch (error) {
+    process.stderr.write(`[contextkit:${name}] Errore: ${error}
+`);
+    process.exit(0);
+  }
+}
+
+// src/index.ts
+var VERSION = "1.0.0";
+export {
+  ContextKitDatabase,
+  ContextKitSDK,
+  DatabaseManager,
+  LogLevel,
+  VERSION,
+  createContextKit,
+  detectProject,
+  formatContext,
+  getDatabase,
+  getObservationsByIds,
+  getProjectStats,
+  getTimeline,
+  initializeDatabase,
+  logger,
+  readStdin,
+  runHook,
+  searchObservationsFTS,
+  searchObservationsLIKE,
+  searchSummariesFiltered
+};