@hanhnd/agent-kit 1.0.35 → 1.0.36

package/dist/cli.js

@@ -15310,12 +15310,11 @@ ${sanitized}`;
 
 // src/services/memory/store.ts
 var import_stopword = __toESM(require_stopword_cjs(), 1);
-import Database from "better-sqlite3";
+import Database from "libsql";
 import * as fs5 from "fs";
-import { createRequire } from "module";
 import * as path7 from "path";
-var require2 = createRequire(import.meta.url);
-var SCHEMA_VERSION = 2;
+var SCHEMA_VERSION = 3;
+var LibsqlDatabase = Database;
 var StoreError = class extends Error {
   constructor(message, cause) {
     super(message);
@@ -15330,13 +15329,11 @@ var MemoryStore = class {
     this.db = this.openDatabase(dbPath);
   }
   db;
-  _vecAvailable = false;
   openDatabase(dbPath) {
     try {
-      const db = new Database(dbPath);
+      const db = new LibsqlDatabase(dbPath);
       db.pragma("journal_mode = WAL");
       db.pragma("busy_timeout = 5000");
-      this.loadVecExtension(db);
       this.createSchema(db);
       return db;
     } catch (err) {
@@ -15345,33 +15342,27 @@ var MemoryStore = class {
         fs5.unlinkSync(dbPath);
       } catch {
       }
-      const db = new Database(dbPath);
-      db.pragma("journal_mode = WAL");
-      db.pragma("busy_timeout = 5000");
-      this.loadVecExtension(db);
-      this.createSchema(db);
-      return db;
-    }
-  }
-  loadVecExtension(db) {
-    try {
-      const sqliteVec = require2("sqlite-vec");
-      sqliteVec.load(db);
-      this._vecAvailable = true;
-    } catch (err) {
-      console.warn("[memory-store] sqlite-vec unavailable, degrading to FTS5-only:", err);
-      this._vecAvailable = false;
+      try {
+        const db = new LibsqlDatabase(dbPath);
+        db.pragma("journal_mode = WAL");
+        db.pragma("busy_timeout = 5000");
+        this.createSchema(db);
+        return db;
+      } catch (retryErr) {
+        throw new StoreError("database open failed", retryErr);
+      }
     }
   }
   createSchema(db) {
     try {
-      const current = Number(db.pragma("user_version", { simple: true }) ?? 0);
+      const current = this.readUserVersion(db);
       if (current < SCHEMA_VERSION) {
         db.exec(`
           DROP TRIGGER IF EXISTS memory_chunks_ai;
           DROP TRIGGER IF EXISTS memory_chunks_ad;
           DROP TABLE IF EXISTS memory_fts;
           DROP TABLE IF EXISTS memory_vec;
+          DROP INDEX IF EXISTS idx_memory_chunks_embedding;
           DROP TABLE IF EXISTS memory_chunks;
         `);
         db.pragma(`user_version = ${SCHEMA_VERSION}`);
@@ -15388,7 +15379,8 @@ var MemoryStore = class {
           line_start    INTEGER NOT NULL,
           line_end      INTEGER NOT NULL,
           indexed_at    INTEGER NOT NULL,
-          file_mtime_at INTEGER NOT NULL DEFAULT 0
+          file_mtime_at INTEGER NOT NULL DEFAULT 0,
+          embedding     F32_BLOB(${this.config.vectorDimension}) NOT NULL
         );
 
         CREATE INDEX IF NOT EXISTS idx_memory_chunks_type_mtime
@@ -15413,39 +15405,40 @@ var MemoryStore = class {
             INSERT INTO memory_fts(memory_fts, rowid, source, heading, content)
               VALUES ('delete', old.rowid, old.source, old.heading, old.content);
           END;
+
+        CREATE INDEX IF NOT EXISTS idx_memory_chunks_embedding
+          ON memory_chunks (libsql_vector_idx(embedding));
       `);
-      if (this._vecAvailable) {
-        try {
-          db.exec(`
-            CREATE VIRTUAL TABLE IF NOT EXISTS memory_vec USING vec0(
-              embedding FLOAT[${this.config.vectorDimension}]
-            );
-          `);
-        } catch (err) {
-          console.warn("[memory-store] Failed to create memory_vec, disabling vector search:", err);
-          this._vecAvailable = false;
-        }
-      }
     } catch (err) {
       throw new StoreError("schema migration failed", err);
     }
   }
+  readUserVersion(db) {
+    const value = db.pragma("user_version", { simple: true });
+    if (typeof value === "number") return value;
+    if (Array.isArray(value)) {
+      const [row] = value;
+      return typeof row?.user_version === "number" ? row.user_version : 0;
+    }
+    if (value && typeof value === "object" && "user_version" in value) {
+      const row = value;
+      return typeof row.user_version === "number" ? row.user_version : 0;
+    }
+    return 0;
+  }
   upsert(chunks, embeddings) {
     const insertChunk = this.db.prepare(`
       INSERT OR REPLACE INTO memory_chunks
-        (id, source, source_type, heading, heading_level, content, line_start, line_end, indexed_at, file_mtime_at)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        (id, source, source_type, heading, heading_level, content, line_start, line_end, indexed_at, file_mtime_at, embedding)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, vector32(?))
     `);
-    let insertVec = null;
-    if (this._vecAvailable) {
-      insertVec = this.db.prepare(`INSERT OR REPLACE INTO memory_vec (rowid, embedding) VALUES (?, ?)`);
-    }
     const upsertAll = this.db.transaction(() => {
       for (let i = 0; i < chunks.length; i++) {
         const chunk = chunks[i];
         try {
+          const vectorBinding = this.toVectorBinding(embeddings[i]);
           this.db.prepare(`DELETE FROM memory_chunks WHERE id = ?`).run(chunk.id);
-          const info = insertChunk.run(
+          insertChunk.run(
             chunk.id,
             chunk.source,
             chunk.sourceType,
@@ -15455,14 +15448,9 @@ var MemoryStore = class {
             chunk.lineStart,
             chunk.lineEnd,
             Date.now(),
-            chunk.fileMtimeAt
+            chunk.fileMtimeAt,
+            vectorBinding
           );
-          if (insertVec && embeddings[i] && info.lastInsertRowid) {
-            const rowid = typeof info.lastInsertRowid === "bigint" ? info.lastInsertRowid : BigInt(info.lastInsertRowid);
-            const emb = embeddings[i];
-            const buf = Buffer.from(emb.buffer, emb.byteOffset, emb.byteLength);
-            insertVec.run(rowid, buf);
-          }
         } catch (err) {
           console.warn(`[memory-store] Failed to upsert chunk ${chunk.id}:`, err);
         }
@@ -15474,6 +15462,20 @@ var MemoryStore = class {
       throw new StoreError("Full batch upsert failed", err);
     }
   }
+  toVectorBinding(embedding) {
+    if (!embedding) throw new Error("missing embedding");
+    if (!(embedding instanceof Float32Array)) throw new Error("missing embedding");
+    if (embedding.length !== this.config.vectorDimension) throw new Error("embedding dimension mismatch");
+    const values = Array.from(embedding, (value) => {
+      if (!Number.isFinite(value)) throw new Error("embedding contains non-finite value");
+      return value;
+    });
+    return JSON.stringify(values);
+  }
+  normalizeVectorDistance(distance) {
+    if (distance <= 0) return 1;
+    return Math.max(0, Math.min(1, 1 - distance));
+  }
   hashesBySource(source) {
     const rows = this.db.prepare(`SELECT id FROM memory_chunks WHERE source = ?`).all(source);
     return new Set(rows.map((r) => r.id));
@@ -15497,12 +15499,7 @@ var MemoryStore = class {
     }
   }
   deleteBySource(source) {
-    const rows = this.db.prepare(`SELECT rowid FROM memory_chunks WHERE source = ?`).all(source);
     const deleteAll = this.db.transaction(() => {
-      if (this._vecAvailable && rows.length > 0) {
-        const placeholders = rows.map(() => "?").join(", ");
-        this.db.prepare(`DELETE FROM memory_vec WHERE rowid IN (${placeholders})`).run(...rows.map((r) => r.rowid));
-      }
       this.db.prepare(`DELETE FROM memory_chunks WHERE source = ?`).run(source);
     });
     deleteAll();
@@ -15510,30 +15507,24 @@ var MemoryStore = class {
   deleteByIds(ids) {
     if (ids.length === 0) return;
     const placeholders = ids.map(() => "?").join(", ");
-    const rows = this.db.prepare(`SELECT rowid FROM memory_chunks WHERE id IN (${placeholders})`).all(...ids);
     const deleteAll = this.db.transaction(() => {
-      if (this._vecAvailable && rows.length > 0) {
-        const rPlaceholders = rows.map(() => "?").join(", ");
-        this.db.prepare(`DELETE FROM memory_vec WHERE rowid IN (${rPlaceholders})`).run(...rows.map((r) => r.rowid));
-      }
       this.db.prepare(`DELETE FROM memory_chunks WHERE id IN (${placeholders})`).run(...ids);
     });
     deleteAll();
   }
   searchDense(embedding, limit) {
-    if (!this._vecAvailable) return [];
     try {
-      const buf = Buffer.from(embedding.buffer);
+      const queryVector = this.toVectorBinding(embedding);
       const rows = this.db.prepare(
-        `SELECT mc.id, mv.distance
-           FROM memory_vec mv
-           JOIN memory_chunks mc ON mc.rowid = mv.rowid
-           WHERE mv.embedding MATCH ? AND k = ?
-           ORDER BY mv.distance`
-      ).all(buf, limit);
+        `SELECT mc.id, vector_distance_cos(mc.embedding, vector32(?)) AS distance
+           FROM vector_top_k('idx_memory_chunks_embedding', vector32(?), ?) AS vector_matches
+           JOIN memory_chunks mc ON mc.rowid = vector_matches.id
+           ORDER BY distance
+           LIMIT ?`
+      ).all(queryVector, queryVector, limit, limit);
       return rows.map((r) => ({
         id: r.id,
-        score: Math.max(0, 1 - r.distance)
+        score: this.normalizeVectorDistance(r.distance)
       }));
     } catch (err) {
       console.warn("[memory-store] Dense search failed:", err);
@@ -15588,7 +15579,7 @@ var MemoryStore = class {
     }));
   }
   get vecAvailable() {
-    return this._vecAvailable;
+    return true;
   }
   close() {
     this.db.close();

package/dist/server.js

@@ -37175,12 +37175,11 @@ ${content}
 
 // src/services/memory/store.ts
 var import_stopword = __toESM(require_stopword_cjs(), 1);
-import Database from "better-sqlite3";
+import Database from "libsql";
 import * as fs7 from "fs";
-import { createRequire } from "module";
 import * as path9 from "path";
-var require2 = createRequire(import.meta.url);
-var SCHEMA_VERSION = 2;
+var SCHEMA_VERSION = 3;
+var LibsqlDatabase = Database;
 var StoreError = class extends Error {
   constructor(message, cause) {
     super(message);
@@ -37195,13 +37194,11 @@ var MemoryStore = class {
     this.db = this.openDatabase(dbPath);
   }
   db;
-  _vecAvailable = false;
   openDatabase(dbPath) {
     try {
-      const db = new Database(dbPath);
+      const db = new LibsqlDatabase(dbPath);
       db.pragma("journal_mode = WAL");
       db.pragma("busy_timeout = 5000");
-      this.loadVecExtension(db);
       this.createSchema(db);
       return db;
     } catch (err) {
@@ -37210,33 +37207,27 @@ var MemoryStore = class {
         fs7.unlinkSync(dbPath);
       } catch {
       }
-      const db = new Database(dbPath);
-      db.pragma("journal_mode = WAL");
-      db.pragma("busy_timeout = 5000");
-      this.loadVecExtension(db);
-      this.createSchema(db);
-      return db;
-    }
-  }
-  loadVecExtension(db) {
-    try {
-      const sqliteVec = require2("sqlite-vec");
-      sqliteVec.load(db);
-      this._vecAvailable = true;
-    } catch (err) {
-      console.warn("[memory-store] sqlite-vec unavailable, degrading to FTS5-only:", err);
-      this._vecAvailable = false;
+      try {
+        const db = new LibsqlDatabase(dbPath);
+        db.pragma("journal_mode = WAL");
+        db.pragma("busy_timeout = 5000");
+        this.createSchema(db);
+        return db;
+      } catch (retryErr) {
+        throw new StoreError("database open failed", retryErr);
+      }
     }
   }
   createSchema(db) {
     try {
-      const current = Number(db.pragma("user_version", { simple: true }) ?? 0);
+      const current = this.readUserVersion(db);
       if (current < SCHEMA_VERSION) {
         db.exec(`
           DROP TRIGGER IF EXISTS memory_chunks_ai;
           DROP TRIGGER IF EXISTS memory_chunks_ad;
           DROP TABLE IF EXISTS memory_fts;
           DROP TABLE IF EXISTS memory_vec;
+          DROP INDEX IF EXISTS idx_memory_chunks_embedding;
           DROP TABLE IF EXISTS memory_chunks;
         `);
         db.pragma(`user_version = ${SCHEMA_VERSION}`);
@@ -37253,7 +37244,8 @@ var MemoryStore = class {
           line_start    INTEGER NOT NULL,
           line_end      INTEGER NOT NULL,
           indexed_at    INTEGER NOT NULL,
-          file_mtime_at INTEGER NOT NULL DEFAULT 0
+          file_mtime_at INTEGER NOT NULL DEFAULT 0,
+          embedding     F32_BLOB(${this.config.vectorDimension}) NOT NULL
         );
 
         CREATE INDEX IF NOT EXISTS idx_memory_chunks_type_mtime
@@ -37278,39 +37270,40 @@ var MemoryStore = class {
             INSERT INTO memory_fts(memory_fts, rowid, source, heading, content)
               VALUES ('delete', old.rowid, old.source, old.heading, old.content);
           END;
+
+        CREATE INDEX IF NOT EXISTS idx_memory_chunks_embedding
+          ON memory_chunks (libsql_vector_idx(embedding));
       `);
-      if (this._vecAvailable) {
-        try {
-          db.exec(`
-            CREATE VIRTUAL TABLE IF NOT EXISTS memory_vec USING vec0(
-              embedding FLOAT[${this.config.vectorDimension}]
-            );
-          `);
-        } catch (err) {
-          console.warn("[memory-store] Failed to create memory_vec, disabling vector search:", err);
-          this._vecAvailable = false;
-        }
-      }
     } catch (err) {
       throw new StoreError("schema migration failed", err);
     }
   }
+  readUserVersion(db) {
+    const value = db.pragma("user_version", { simple: true });
+    if (typeof value === "number") return value;
+    if (Array.isArray(value)) {
+      const [row] = value;
+      return typeof row?.user_version === "number" ? row.user_version : 0;
+    }
+    if (value && typeof value === "object" && "user_version" in value) {
+      const row = value;
+      return typeof row.user_version === "number" ? row.user_version : 0;
+    }
+    return 0;
+  }
   upsert(chunks, embeddings) {
     const insertChunk = this.db.prepare(`
       INSERT OR REPLACE INTO memory_chunks
-        (id, source, source_type, heading, heading_level, content, line_start, line_end, indexed_at, file_mtime_at)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        (id, source, source_type, heading, heading_level, content, line_start, line_end, indexed_at, file_mtime_at, embedding)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, vector32(?))
     `);
-    let insertVec = null;
-    if (this._vecAvailable) {
-      insertVec = this.db.prepare(`INSERT OR REPLACE INTO memory_vec (rowid, embedding) VALUES (?, ?)`);
-    }
     const upsertAll = this.db.transaction(() => {
       for (let i = 0; i < chunks.length; i++) {
         const chunk = chunks[i];
         try {
+          const vectorBinding = this.toVectorBinding(embeddings[i]);
           this.db.prepare(`DELETE FROM memory_chunks WHERE id = ?`).run(chunk.id);
-          const info = insertChunk.run(
+          insertChunk.run(
             chunk.id,
             chunk.source,
             chunk.sourceType,
@@ -37320,14 +37313,9 @@ var MemoryStore = class {
             chunk.lineStart,
             chunk.lineEnd,
             Date.now(),
-            chunk.fileMtimeAt
+            chunk.fileMtimeAt,
+            vectorBinding
           );
-          if (insertVec && embeddings[i] && info.lastInsertRowid) {
-            const rowid = typeof info.lastInsertRowid === "bigint" ? info.lastInsertRowid : BigInt(info.lastInsertRowid);
-            const emb = embeddings[i];
-            const buf = Buffer.from(emb.buffer, emb.byteOffset, emb.byteLength);
-            insertVec.run(rowid, buf);
-          }
         } catch (err) {
           console.warn(`[memory-store] Failed to upsert chunk ${chunk.id}:`, err);
         }
@@ -37339,6 +37327,20 @@ var MemoryStore = class {
       throw new StoreError("Full batch upsert failed", err);
     }
   }
+  toVectorBinding(embedding) {
+    if (!embedding) throw new Error("missing embedding");
+    if (!(embedding instanceof Float32Array)) throw new Error("missing embedding");
+    if (embedding.length !== this.config.vectorDimension) throw new Error("embedding dimension mismatch");
+    const values = Array.from(embedding, (value) => {
+      if (!Number.isFinite(value)) throw new Error("embedding contains non-finite value");
+      return value;
+    });
+    return JSON.stringify(values);
+  }
+  normalizeVectorDistance(distance) {
+    if (distance <= 0) return 1;
+    return Math.max(0, Math.min(1, 1 - distance));
+  }
   hashesBySource(source) {
     const rows = this.db.prepare(`SELECT id FROM memory_chunks WHERE source = ?`).all(source);
     return new Set(rows.map((r) => r.id));
@@ -37362,12 +37364,7 @@ var MemoryStore = class {
     }
   }
   deleteBySource(source) {
-    const rows = this.db.prepare(`SELECT rowid FROM memory_chunks WHERE source = ?`).all(source);
     const deleteAll = this.db.transaction(() => {
-      if (this._vecAvailable && rows.length > 0) {
-        const placeholders = rows.map(() => "?").join(", ");
-        this.db.prepare(`DELETE FROM memory_vec WHERE rowid IN (${placeholders})`).run(...rows.map((r) => r.rowid));
-      }
       this.db.prepare(`DELETE FROM memory_chunks WHERE source = ?`).run(source);
     });
     deleteAll();
@@ -37375,30 +37372,24 @@ var MemoryStore = class {
   deleteByIds(ids) {
     if (ids.length === 0) return;
     const placeholders = ids.map(() => "?").join(", ");
-    const rows = this.db.prepare(`SELECT rowid FROM memory_chunks WHERE id IN (${placeholders})`).all(...ids);
     const deleteAll = this.db.transaction(() => {
-      if (this._vecAvailable && rows.length > 0) {
-        const rPlaceholders = rows.map(() => "?").join(", ");
-        this.db.prepare(`DELETE FROM memory_vec WHERE rowid IN (${rPlaceholders})`).run(...rows.map((r) => r.rowid));
-      }
       this.db.prepare(`DELETE FROM memory_chunks WHERE id IN (${placeholders})`).run(...ids);
     });
     deleteAll();
   }
   searchDense(embedding, limit) {
-    if (!this._vecAvailable) return [];
     try {
-      const buf = Buffer.from(embedding.buffer);
+      const queryVector = this.toVectorBinding(embedding);
       const rows = this.db.prepare(
-        `SELECT mc.id, mv.distance
-           FROM memory_vec mv
-           JOIN memory_chunks mc ON mc.rowid = mv.rowid
-           WHERE mv.embedding MATCH ? AND k = ?
-           ORDER BY mv.distance`
-      ).all(buf, limit);
+        `SELECT mc.id, vector_distance_cos(mc.embedding, vector32(?)) AS distance
+           FROM vector_top_k('idx_memory_chunks_embedding', vector32(?), ?) AS vector_matches
+           JOIN memory_chunks mc ON mc.rowid = vector_matches.id
+           ORDER BY distance
+           LIMIT ?`
+      ).all(queryVector, queryVector, limit, limit);
       return rows.map((r) => ({
         id: r.id,
-        score: Math.max(0, 1 - r.distance)
+        score: this.normalizeVectorDistance(r.distance)
       }));
     } catch (err) {
       console.warn("[memory-store] Dense search failed:", err);
@@ -37453,7 +37444,7 @@ var MemoryStore = class {
     }));
   }
   get vecAvailable() {
-    return this._vecAvailable;
+    return true;
   }
   close() {
     this.db.close();

package/dist/services/digest/digest-processor.test.js

@@ -1,8 +1,6 @@
 import * as assert from 'node:assert/strict';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
-import Database from 'better-sqlite3';
-import { load as loadSqliteVec } from 'sqlite-vec';
 import { afterEach, describe, test } from 'node:test';
 import { createTempDirTracker } from '../../utils/temp-dir.test.js';
 import { DEFAULT_DIGEST_MODEL_ID } from './constants.js';
@@ -53,7 +51,7 @@ describe('digestConversationFile', () => {
         assert.equal(result.contentHash, input.contentHash);
         assert.match(path.basename(result.markdown), /^[a-f0-9]{16}-conv\.md$/);
     });
-    test('indexes existing provisional digest with real store vector rows when sqlite-vec is available', async () => {
+    test('indexes existing provisional digest with searchable store vector data', async () => {
         const workspace = tempDirs.makeTempDir('digest-processor-index-');
         const inputPath = path.join(workspace, '.agent-kit', 'wiki', 'archive', 'conversations', 'conv.md');
         fs.mkdirSync(path.dirname(inputPath), { recursive: true });
@@ -74,22 +72,10 @@ describe('digestConversationFile', () => {
             });
             assert.equal(result.indexed, true);
             assert.equal(result.markdown, markdownPath);
-            if (store.vecAvailable) {
-                const db = new Database(dbPath, { readonly: true });
-                try {
-                    loadSqliteVec(db);
-                    const row = db
-                        .prepare(`SELECT COUNT(*) AS count
-               FROM memory_vec mv
-               JOIN memory_chunks mc ON mc.rowid = mv.rowid
-               WHERE mc.source = ?`)
-                        .get(path.relative(config.wikiDir, markdownPath));
-                    assert.ok(row.count > 0, `Expected vector rows for ${markdownPath}`);
-                }
-                finally {
-                    db.close();
-                }
-            }
+            const denseResults = store.searchDense(new Float32Array(384).fill(0.05), 5);
+            const indexedSource = path.relative(config.wikiDir, markdownPath);
+            const indexedChunks = store.getChunksByIds(denseResults.map((denseResult) => denseResult.id));
+            assert.ok(indexedChunks.some((chunk) => chunk.source === indexedSource), `Expected dense search to return a chunk for ${indexedSource}`);
         }
         finally {
             store.close();

package/dist/services/memory/store.d.ts

@@ -1,17 +1,18 @@
 import type { MemoryChunk, MemoryConfig, RecentSource, SourceType } from './types.js';
-export declare const SCHEMA_VERSION = 2;
+export declare const SCHEMA_VERSION = 3;
 export declare class StoreError extends Error {
     constructor(message: string, cause?: unknown);
 }
 export declare class MemoryStore {
     private readonly config;
     private db;
-    private _vecAvailable;
     constructor(dbPath: string, config: MemoryConfig);
     private openDatabase;
-    private loadVecExtension;
     private createSchema;
+    private readUserVersion;
     upsert(chunks: MemoryChunk[], embeddings: Float32Array[]): void;
+    private toVectorBinding;
+    private normalizeVectorDistance;
     hashesBySource(source: string): Set<string>;
     indexedSources(): string[];
     getRecentSources(options: {

package/dist/services/memory/store.js

@@ -1,10 +1,9 @@
-import Database from 'better-sqlite3';
+import Database from 'libsql';
 import * as fs from 'fs';
-import { createRequire } from 'module';
 import * as path from 'path';
 import { eng, removeStopwords } from 'stopword';
-const require = createRequire(import.meta.url);
-export const SCHEMA_VERSION = 2;
+export const SCHEMA_VERSION = 3;
+const LibsqlDatabase = Database;
 export class StoreError extends Error {
     constructor(message, cause) {
         super(message);
@@ -16,7 +15,6 @@ export class StoreError extends Error {
 export class MemoryStore {
     config;
     db;
-    _vecAvailable = false;
     constructor(dbPath, config) {
         this.config = config;
         fs.mkdirSync(path.dirname(dbPath), { recursive: true });
@@ -24,10 +22,9 @@ export class MemoryStore {
     }
     openDatabase(dbPath) {
         try {
-            const db = new Database(dbPath);
+            const db = new LibsqlDatabase(dbPath);
             db.pragma('journal_mode = WAL');
             db.pragma('busy_timeout = 5000');
-            this.loadVecExtension(db);
             this.createSchema(db);
             return db;
         }
@@ -39,34 +36,28 @@ export class MemoryStore {
             catch {
                 // ignore
             }
-            const db = new Database(dbPath);
-            db.pragma('journal_mode = WAL');
-            db.pragma('busy_timeout = 5000');
-            this.loadVecExtension(db);
-            this.createSchema(db);
-            return db;
-        }
-    }
-    loadVecExtension(db) {
-        try {
-            const sqliteVec = require('sqlite-vec');
-            sqliteVec.load(db);
-            this._vecAvailable = true;
-        }
-        catch (err) {
-            console.warn('[memory-store] sqlite-vec unavailable, degrading to FTS5-only:', err);
-            this._vecAvailable = false;
+            try {
+                const db = new LibsqlDatabase(dbPath);
+                db.pragma('journal_mode = WAL');
+                db.pragma('busy_timeout = 5000');
+                this.createSchema(db);
+                return db;
+            }
+            catch (retryErr) {
+                throw new StoreError('database open failed', retryErr);
+            }
         }
     }
     createSchema(db) {
         try {
-            const current = Number(db.pragma('user_version', { simple: true }) ?? 0);
+            const current = this.readUserVersion(db);
             if (current < SCHEMA_VERSION) {
                 db.exec(`
           DROP TRIGGER IF EXISTS memory_chunks_ai;
           DROP TRIGGER IF EXISTS memory_chunks_ad;
           DROP TABLE IF EXISTS memory_fts;
           DROP TABLE IF EXISTS memory_vec;
+          DROP INDEX IF EXISTS idx_memory_chunks_embedding;
           DROP TABLE IF EXISTS memory_chunks;
         `);
                 db.pragma(`user_version = ${SCHEMA_VERSION}`);
@@ -83,7 +74,8 @@ export class MemoryStore {
           line_start    INTEGER NOT NULL,
           line_end      INTEGER NOT NULL,
           indexed_at    INTEGER NOT NULL,
-          file_mtime_at INTEGER NOT NULL DEFAULT 0
+          file_mtime_at INTEGER NOT NULL DEFAULT 0,
+          embedding     F32_BLOB(${this.config.vectorDimension}) NOT NULL
         );
 
         CREATE INDEX IF NOT EXISTS idx_memory_chunks_type_mtime
@@ -108,48 +100,43 @@ export class MemoryStore {
             INSERT INTO memory_fts(memory_fts, rowid, source, heading, content)
               VALUES ('delete', old.rowid, old.source, old.heading, old.content);
           END;
+
+        CREATE INDEX IF NOT EXISTS idx_memory_chunks_embedding
+          ON memory_chunks (libsql_vector_idx(embedding));
       `);
-            if (this._vecAvailable) {
-                try {
-                    db.exec(`
-            CREATE VIRTUAL TABLE IF NOT EXISTS memory_vec USING vec0(
-              embedding FLOAT[${this.config.vectorDimension}]
-            );
-          `);
-                }
-                catch (err) {
-                    console.warn('[memory-store] Failed to create memory_vec, disabling vector search:', err);
-                    this._vecAvailable = false;
-                }
-            }
         }
         catch (err) {
             throw new StoreError('schema migration failed', err);
         }
     }
+    readUserVersion(db) {
+        const value = db.pragma('user_version', { simple: true });
+        if (typeof value === 'number')
+            return value;
+        if (Array.isArray(value)) {
+            const [row] = value;
+            return typeof row?.user_version === 'number' ? row.user_version : 0;
+        }
+        if (value && typeof value === 'object' && 'user_version' in value) {
+            const row = value;
+            return typeof row.user_version === 'number' ? row.user_version : 0;
+        }
+        return 0;
+    }
     upsert(chunks, embeddings) {
         const insertChunk = this.db.prepare(`
       INSERT OR REPLACE INTO memory_chunks
-        (id, source, source_type, heading, heading_level, content, line_start, line_end, indexed_at, file_mtime_at)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        (id, source, source_type, heading, heading_level, content, line_start, line_end, indexed_at, file_mtime_at, embedding)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, vector32(?))
     `);
-        let insertVec = null;
-        if (this._vecAvailable) {
-            insertVec = this.db.prepare(`INSERT OR REPLACE INTO memory_vec (rowid, embedding) VALUES (?, ?)`);
-        }
         const upsertAll = this.db.transaction(() => {
             for (let i = 0; i < chunks.length; i++) {
                 const chunk = chunks[i];
                 try {
+                    const vectorBinding = this.toVectorBinding(embeddings[i]);
                     // Delete existing row first to get correct rowid
                     this.db.prepare(`DELETE FROM memory_chunks WHERE id = ?`).run(chunk.id);
-                    const info = insertChunk.run(chunk.id, chunk.source, chunk.sourceType, chunk.heading, chunk.headingLevel, chunk.content, chunk.lineStart, chunk.lineEnd, Date.now(), chunk.fileMtimeAt);
-                    if (insertVec && embeddings[i] && info.lastInsertRowid) {
-                        const rowid = typeof info.lastInsertRowid === 'bigint' ? info.lastInsertRowid : BigInt(info.lastInsertRowid);
-                        const emb = embeddings[i];
-                        const buf = Buffer.from(emb.buffer, emb.byteOffset, emb.byteLength);
-                        insertVec.run(rowid, buf);
-                    }
+                    insertChunk.run(chunk.id, chunk.source, chunk.sourceType, chunk.heading, chunk.headingLevel, chunk.content, chunk.lineStart, chunk.lineEnd, Date.now(), chunk.fileMtimeAt, vectorBinding);
                 }
                 catch (err) {
                     console.warn(`[memory-store] Failed to upsert chunk ${chunk.id}:`, err);
@@ -163,6 +150,25 @@ export class MemoryStore {
             throw new StoreError('Full batch upsert failed', err);
         }
     }
+    toVectorBinding(embedding) {
+        if (!embedding)
+            throw new Error('missing embedding');
+        if (!(embedding instanceof Float32Array))
+            throw new Error('missing embedding');
+        if (embedding.length !== this.config.vectorDimension)
+            throw new Error('embedding dimension mismatch');
+        const values = Array.from(embedding, (value) => {
+            if (!Number.isFinite(value))
+                throw new Error('embedding contains non-finite value');
+            return value;
+        });
+        return JSON.stringify(values);
+    }
+    normalizeVectorDistance(distance) {
+        if (distance <= 0)
+            return 1;
+        return Math.max(0, Math.min(1, 1 - distance));
+    }
     hashesBySource(source) {
         const rows = this.db.prepare(`SELECT id FROM memory_chunks WHERE source = ?`).all(source);
         return new Set(rows.map((r) => r.id));
@@ -187,12 +193,7 @@ export class MemoryStore {
         }
     }
     deleteBySource(source) {
-        const rows = this.db.prepare(`SELECT rowid FROM memory_chunks WHERE source = ?`).all(source);
         const deleteAll = this.db.transaction(() => {
-            if (this._vecAvailable && rows.length > 0) {
-                const placeholders = rows.map(() => '?').join(', ');
-                this.db.prepare(`DELETE FROM memory_vec WHERE rowid IN (${placeholders})`).run(...rows.map((r) => r.rowid));
-            }
             this.db.prepare(`DELETE FROM memory_chunks WHERE source = ?`).run(source);
         });
         deleteAll();
@@ -201,31 +202,24 @@ export class MemoryStore {
         if (ids.length === 0)
             return;
         const placeholders = ids.map(() => '?').join(', ');
-        const rows = this.db.prepare(`SELECT rowid FROM memory_chunks WHERE id IN (${placeholders})`).all(...ids);
         const deleteAll = this.db.transaction(() => {
-            if (this._vecAvailable && rows.length > 0) {
-                const rPlaceholders = rows.map(() => '?').join(', ');
-                this.db.prepare(`DELETE FROM memory_vec WHERE rowid IN (${rPlaceholders})`).run(...rows.map((r) => r.rowid));
-            }
             this.db.prepare(`DELETE FROM memory_chunks WHERE id IN (${placeholders})`).run(...ids);
         });
         deleteAll();
     }
     searchDense(embedding, limit) {
-        if (!this._vecAvailable)
-            return [];
         try {
-            const buf = Buffer.from(embedding.buffer);
+            const queryVector = this.toVectorBinding(embedding);
             const rows = this.db
-                .prepare(`SELECT mc.id, mv.distance
-           FROM memory_vec mv
-           JOIN memory_chunks mc ON mc.rowid = mv.rowid
-           WHERE mv.embedding MATCH ? AND k = ?
-           ORDER BY mv.distance`)
-                .all(buf, limit);
+                .prepare(`SELECT mc.id, vector_distance_cos(mc.embedding, vector32(?)) AS distance
+           FROM vector_top_k('idx_memory_chunks_embedding', vector32(?), ?) AS vector_matches
+           JOIN memory_chunks mc ON mc.rowid = vector_matches.id
+           ORDER BY distance
+           LIMIT ?`)
+                .all(queryVector, queryVector, limit, limit);
             return rows.map((r) => ({
                 id: r.id,
-                score: Math.max(0, 1 - r.distance),
+                score: this.normalizeVectorDistance(r.distance),
             }));
         }
         catch (err) {
@@ -293,7 +287,7 @@ export class MemoryStore {
         }));
     }
     get vecAvailable() {
-        return this._vecAvailable;
+        return true;
     }
     close() {
         this.db.close();

package/dist/services/memory/store.test.js

@@ -1,8 +1,8 @@
+import Database from 'libsql';
 import * as assert from 'node:assert/strict';
 import * as fs from 'node:fs';
 import * as os from 'node:os';
 import * as path from 'node:path';
-import Database from 'better-sqlite3';
 import { after, before, describe, test } from 'node:test';
 import { MemoryStore, SCHEMA_VERSION } from './store.js';
 import { EmbeddingModelName } from './types.js';
@@ -29,6 +29,25 @@ function makeChunk(overrides = {}) {
         ...overrides,
     };
 }
+function makeEmbedding(activeIndex, dimension = TEST_CONFIG.vectorDimension) {
+    const embedding = new Float32Array(dimension);
+    embedding[activeIndex] = 1;
+    return embedding;
+}
+function readUserVersion(db) {
+    const value = db.pragma('user_version', { simple: true });
+    if (typeof value === 'number')
+        return value;
+    if (Array.isArray(value)) {
+        const [row] = value;
+        return typeof row?.user_version === 'number' ? row.user_version : 0;
+    }
+    if (value && typeof value === 'object' && 'user_version' in value) {
+        const row = value;
+        return typeof row.user_version === 'number' ? row.user_version : 0;
+    }
+    return 0;
+}
 describe('MemoryStore', () => {
     let tmpDir;
     let dbPath;
@@ -42,8 +61,50 @@ describe('MemoryStore', () => {
         store.close();
         fs.rmSync(tmpDir, { recursive: true, force: true });
     });
-    test('vecAvailable is a boolean', () => {
-        assert.equal(typeof store.vecAvailable, 'boolean');
+    test('libsql supports required local driver and vector features', () => {
+        const libsqlDir = fs.mkdtempSync(path.join(os.tmpdir(), 'memory-libsql-compat-'));
+        const libsqlDb = new Database(path.join(libsqlDir, 'index.db'));
+        try {
+            assert.equal(readUserVersion(libsqlDb), 0);
+            libsqlDb.pragma('journal_mode = WAL');
+            libsqlDb.pragma('busy_timeout = 5000');
+            libsqlDb.pragma(`user_version = ${SCHEMA_VERSION}`);
+            assert.equal(readUserVersion(libsqlDb), SCHEMA_VERSION);
+            libsqlDb.exec(`
+        CREATE TABLE vector_items (
+          rowid INTEGER PRIMARY KEY AUTOINCREMENT,
+          name TEXT NOT NULL,
+          embedding F32_BLOB(3) NOT NULL
+        );
+        CREATE INDEX idx_vector_items_embedding
+          ON vector_items (libsql_vector_idx(embedding));
+      `);
+            const insert = libsqlDb.prepare(`INSERT INTO vector_items (name, embedding) VALUES (?, vector32(?))`);
+            const info = insert.run('alpha', '[1,0,0]');
+            assert.equal(info.lastInsertRowid, 1);
+            insert.run('beta', '[0,1,0]');
+            const insertGamma = libsqlDb.transaction(() => insert.run('gamma', '[0,0,1]'));
+            insertGamma();
+            const distance = libsqlDb
+                .prepare(`SELECT vector_distance_cos(embedding, vector32(?)) AS distance FROM vector_items WHERE name = ?`)
+                .get('[1,0,0]', 'alpha');
+            assert.equal(distance.distance, 0);
+            const rows = libsqlDb
+                .prepare(`SELECT vector_items.name
+           FROM vector_top_k('idx_vector_items_embedding', vector32(?), ?) AS vector_matches
+           JOIN vector_items ON vector_items.rowid = vector_matches.id
+           ORDER BY vector_distance_cos(vector_items.embedding, vector32(?))`)
+                .all('[1,0,0]', 2, '[1,0,0]');
+            assert.equal(rows[0].name, 'alpha');
+            assert.equal(rows.length, 2);
+        }
+        finally {
+            libsqlDb.close();
+            fs.rmSync(libsqlDir, { recursive: true, force: true });
+        }
+    });
+    test('vecAvailable is true after schema creation', () => {
+        assert.equal(store.vecAvailable, true);
     });
     test('hashesBySource returns empty set for unknown source', () => {
         const hashes = store.hashesBySource('nonexistent.md');
@@ -52,7 +113,7 @@ describe('MemoryStore', () => {
     });
     test('upsert stores chunks and hashesBySource returns their ids', () => {
         const chunk = makeChunk({ id: 'upsert-test-0001', source: 'upsert.md', sourceType: 'entity', fileMtimeAt: 2000 });
-        const embedding = new Float32Array(384).fill(0.1);
+        const embedding = makeEmbedding(0);
         store.upsert([chunk], [embedding]);
         const hashes = store.hashesBySource('upsert.md');
         assert.ok(hashes.has('upsert-test-0001'));
@@ -71,7 +132,7 @@ describe('MemoryStore', () => {
             source: 'deleteme.md',
             content: 'delete source chunk 2',
         });
-        store.upsert([c1, c2], [new Float32Array(384), new Float32Array(384)]);
+        store.upsert([c1, c2], [makeEmbedding(1), makeEmbedding(2)]);
         store.deleteBySource('deleteme.md');
         const hashes = store.hashesBySource('deleteme.md');
         assert.equal(hashes.size, 0);
@@ -82,7 +143,7 @@ describe('MemoryStore', () => {
             source: 'bm25.md',
             content: 'uniqueKeywordXYZ for BM25 testing',
         });
-        store.upsert([chunk], [new Float32Array(384)]);
+        store.upsert([chunk], [makeEmbedding(3)]);
         const results = store.searchBm25('uniqueKeywordXYZ', 5);
         assert.ok(results.length > 0, 'Expected at least one BM25 result');
         assert.ok(results.some((r) => r.id === 'bm25-search-0001'), `Expected chunk id in results, got: ${results.map((r) => r.id).join(', ')}`);
@@ -101,7 +162,7 @@ describe('MemoryStore', () => {
             heading: 'Open Questions',
             content: 'How should git manage worktree lifecycle decisions?',
         });
-        store.upsert([preference, unrelated], [new Float32Array(384), new Float32Array(384)]);
+        store.upsert([preference, unrelated], [makeEmbedding(4), makeEmbedding(5)]);
         const results = store.searchBm25('personal likes and preferences of the user', 5);
         assert.ok(results.length > 0, 'Expected preference query to return results');
         assert.equal(results[0].id, 'preference-search-0001');
@@ -122,7 +183,7 @@ describe('MemoryStore', () => {
             lineEnd: 20,
             fileMtimeAt: 3000,
         });
-        store.upsert([chunk], [new Float32Array(384)]);
+        store.upsert([chunk], [makeEmbedding(6)]);
         const results = store.getChunksByIds(['get-by-ids-0001']);
         assert.equal(results.length, 1);
         const [r] = results;
@@ -137,7 +198,7 @@ describe('MemoryStore', () => {
     });
     test('getChunksByIds returns only found rows for mixed ids', () => {
         const chunk = makeChunk({ id: 'partial-found-0001', source: 'partial.md', content: 'partial' });
-        store.upsert([chunk], [new Float32Array(384)]);
+        store.upsert([chunk], [makeEmbedding(7)]);
         const results = store.getChunksByIds(['partial-found-0001', 'does-not-exist-999']);
         assert.equal(results.length, 1);
         assert.equal(results[0].id, 'partial-found-0001');
@@ -148,14 +209,14 @@ describe('MemoryStore', () => {
             source: 'indexed-source.md',
             content: 'indexed',
         });
-        store.upsert([chunk], [new Float32Array(384)]);
+        store.upsert([chunk], [makeEmbedding(8)]);
         const sources = store.indexedSources();
         assert.ok(sources.includes('indexed-source.md'), `Expected 'indexed-source.md' in ${sources.join(', ')}`);
     });
     test('deleteByIds removes specific chunks', () => {
         const c1 = makeChunk({ id: 'del-ids-0001', source: 'del-ids.md', content: 'delete by id 1' });
         const c2 = makeChunk({ id: 'del-ids-0002', source: 'del-ids.md', content: 'delete by id 2' });
-        store.upsert([c1, c2], [new Float32Array(384), new Float32Array(384)]);
+        store.upsert([c1, c2], [makeEmbedding(9), makeEmbedding(10)]);
         store.deleteByIds(['del-ids-0001']);
         const hashes = store.hashesBySource('del-ids.md');
         assert.ok(!hashes.has('del-ids-0001'), 'Deleted chunk id must be gone');
@@ -168,7 +229,7 @@ describe('MemoryStore', () => {
             source: 'fts5.md',
             content: 'degradedModeTest keyword',
         });
-        store.upsert([chunk], [new Float32Array(384)]);
+        store.upsert([chunk], [makeEmbedding(11)]);
         const results = store.searchBm25('degradedModeTest', 5);
         assert.ok(results.length > 0, 'FTS5 search must work regardless of vecAvailable');
     });
@@ -205,7 +266,7 @@ describe('MemoryStore', () => {
                     fileMtimeAt: 500,
                     content: 'entity',
                 }),
-            ], [new Float32Array(384), new Float32Array(384), new Float32Array(384), new Float32Array(384)]);
+            ], [makeEmbedding(12), makeEmbedding(13), makeEmbedding(14), makeEmbedding(15)]);
             const allRows = recentStore.getRecentSources({ limit: 10 });
             assert.deepEqual(allRows.map((row) => row.source), [
                 'compiled/entities/entity.md',
@@ -221,7 +282,41 @@ describe('MemoryStore', () => {
             fs.rmSync(recentDir, { recursive: true, force: true });
         }
     });
-    test('schema migration recreates versioned schema with new columns and recency index', () => {
+    test('searchDense returns nearest vector with bounded scores', () => {
+        const denseDir = fs.mkdtempSync(path.join(os.tmpdir(), 'memory-dense-store-'));
+        const denseStore = new MemoryStore(path.join(denseDir, 'index.db'), { ...TEST_CONFIG, wikiDir: denseDir });
+        try {
+            denseStore.upsert([
+                makeChunk({ id: 'dense-alpha', source: 'dense.md', content: 'alpha vector' }),
+                makeChunk({ id: 'dense-beta', source: 'dense.md', content: 'beta vector' }),
+                makeChunk({ id: 'dense-gamma', source: 'dense.md', content: 'gamma vector' }),
+            ], [makeEmbedding(21), makeEmbedding(22), makeEmbedding(23)]);
+            const results = denseStore.searchDense(makeEmbedding(22), 3);
+            assert.ok(results.length > 0, 'Expected dense search results');
+            assert.equal(results[0].id, 'dense-beta');
+            assert.ok(results.every((result) => result.score >= 0 && result.score <= 1));
+        }
+        finally {
+            denseStore.close();
+            fs.rmSync(denseDir, { recursive: true, force: true });
+        }
+    });
+    test('searchDense returns empty array for invalid query embedding', () => {
+        assert.deepEqual(store.searchDense(new Float32Array(3), 5), []);
+    });
+    test('upsert skips invalid embeddings while persisting valid chunks', () => {
+        const validChunk = makeChunk({ id: 'valid-embedding-0001', source: 'embedding-validation.md' });
+        const invalidChunk = makeChunk({ id: 'invalid-embedding-0001', source: 'embedding-validation.md' });
+        const nonFiniteChunk = makeChunk({ id: 'non-finite-embedding-0001', source: 'embedding-validation.md' });
+        const nonFiniteEmbedding = makeEmbedding(24);
+        nonFiniteEmbedding[25] = Number.NaN;
+        store.upsert([validChunk, invalidChunk, nonFiniteChunk], [makeEmbedding(24), new Float32Array(3), nonFiniteEmbedding]);
+        const hashes = store.hashesBySource('embedding-validation.md');
+        assert.ok(hashes.has('valid-embedding-0001'));
+        assert.ok(!hashes.has('invalid-embedding-0001'));
+        assert.ok(!hashes.has('non-finite-embedding-0001'));
+    });
+    test('schema migration recreates versioned schema with new columns, vector index, and working BM25', () => {
         const migrationDir = fs.mkdtempSync(path.join(os.tmpdir(), 'memory-migration-'));
         const migrationDbPath = path.join(migrationDir, 'index.db');
         const db = new Database(migrationDbPath);
@@ -264,18 +359,28 @@ describe('MemoryStore', () => {
         try {
             const verifyDb = new Database(migrationDbPath, { readonly: true });
             try {
-                assert.equal(verifyDb.pragma('user_version', { simple: true }), SCHEMA_VERSION);
+                assert.equal(readUserVersion(verifyDb), SCHEMA_VERSION);
                 const columns = verifyDb.prepare(`PRAGMA table_info(memory_chunks)`).all();
                 assert.ok(columns.some((column) => column.name === 'source_type'));
                 assert.ok(columns.some((column) => column.name === 'file_mtime_at'));
+                assert.ok(columns.some((column) => column.name === 'embedding'));
                 const indexes = verifyDb.prepare(`PRAGMA index_list(memory_chunks)`).all();
                 assert.ok(indexes.some((index) => index.name === 'idx_memory_chunks_type_mtime'));
+                assert.ok(indexes.some((index) => index.name === 'idx_memory_chunks_embedding'));
                 const rowCount = verifyDb.prepare(`SELECT COUNT(*) AS count FROM memory_chunks`).get();
                 assert.equal(rowCount.count, 0);
             }
             finally {
                 verifyDb.close();
             }
+            const migratedChunk = makeChunk({
+                id: 'migrated-bm25-0001',
+                source: 'migrated.md',
+                content: 'postMigrationKeyword is searchable after migration',
+            });
+            migratedStore.upsert([migratedChunk], [makeEmbedding(16)]);
+            const results = migratedStore.searchBm25('postMigrationKeyword', 5);
+            assert.ok(results.some((result) => result.id === 'migrated-bm25-0001'));
         }
         finally {
             migratedStore.close();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hanhnd/agent-kit",
-  "version": "1.0.35",
+  "version": "1.0.36",
   "description": "Agent Kit MCP server for software development agent workflows",
   "type": "module",
   "main": "dist/server.js",
@@ -22,7 +22,7 @@
   },
   "scripts": {
     "build": "rm -rf dist && tsc && npm run bundle",
-    "bundle": "esbuild src/entrypoints/server.ts src/entrypoints/cli.ts --bundle --platform=node --format=esm --outdir=dist --external:node:* --external:better-sqlite3 --external:sqlite-vec --external:fastembed --external:node-llama-cpp",
+    "bundle": "esbuild src/entrypoints/server.ts src/entrypoints/cli.ts --bundle --platform=node --format=esm --outdir=dist --external:node:* --external:libsql --external:fastembed --external:node-llama-cpp",
     "dev": "tsc --watch",
     "prepublishOnly": "npm run build",
     "test": "tsc && node --test $(find dist -name '*.test.js' | tr '\\n' ' ')"
@@ -30,15 +30,13 @@
   "dependencies": {
     "node-llama-cpp": "^3.0.0",
     "@modelcontextprotocol/sdk": "^1.13.1",
-    "better-sqlite3": "^11.0.0",
     "dedent": "^1.5.3",
     "fastembed": "^1.14.0",
-    "sqlite-vec": "^0.1.0",
+    "libsql": "^0.5.29",
     "stopword": "^3.1.5",
     "zod": "^3.24.4"
   },
   "devDependencies": {
-    "@types/better-sqlite3": "^7.6.0",
     "@types/node": "^22.15.21",
     "esbuild": "^0.25.4",
     "typescript": "^5.8.3"