opencode-mem 2.11.8 → 2.11.9

package/dist/services/vector-backends/exact-scan-backend.js

@@ -0,0 +1,63 @@
+export class ExactScanBackend {
+    getBackendName() {
+        return "exact-scan";
+    }
+    rankVectors(rows, queryVector, limit) {
+        return rows
+            .map((row) => ({
+            id: row.id,
+            distance: 1 - this.cosineSimilarity(row.vector, queryVector),
+        }))
+            .sort((a, b) => a.distance - b.distance)
+            .slice(0, limit);
+    }
+    async insert(_args) { }
+    async insertBatch(_args) { }
+    async delete(_args) { }
+    async search(args) {
+        const column = args.kind === "tags" ? "tags_vector" : "vector";
+        const rows = args.db
+            .prepare(`SELECT id, ${column} FROM memories WHERE ${column} IS NOT NULL`)
+            .all();
+        if (rows.length === 0) {
+            return [];
+        }
+        const rankedRows = rows
+            .map((row) => ({
+            id: row.id,
+            vector: this.decodeVector(args.kind === "tags" ? row.tags_vector : row.vector),
+        }))
+            .filter((row) => row.vector.length > 0);
+        return this.rankVectors(rankedRows, args.queryVector, args.limit);
+    }
+    async rebuildFromShard(_args) { }
+    async deleteShardIndexes(_args) { }
+    decodeVector(value) {
+        if (!value) {
+            return new Float32Array();
+        }
+        if (value instanceof Uint8Array) {
+            return new Float32Array(value.buffer.slice(value.byteOffset, value.byteOffset + value.byteLength));
+        }
+        return new Float32Array(value);
+    }
+    cosineSimilarity(a, b) {
+        if (a.length !== b.length) {
+            return 0;
+        }
+        let dot = 0;
+        let magA = 0;
+        let magB = 0;
+        for (let i = 0; i < a.length; i++) {
+            const av = a[i] ?? 0;
+            const bv = b[i] ?? 0;
+            dot += av * bv;
+            magA += av * av;
+            magB += bv * bv;
+        }
+        if (magA === 0 || magB === 0) {
+            return 0;
+        }
+        return dot / (Math.sqrt(magA) * Math.sqrt(magB));
+    }
+}

package/dist/services/vector-backends/types.d.ts

@@ -0,0 +1,51 @@
+import type { ShardInfo } from "../sqlite/types.js";
+export type VectorKind = "content" | "tags";
+export interface BackendSearchResult {
+    id: string;
+    distance: number;
+}
+export interface BackendInsertItem {
+    id: string;
+    vector: Float32Array;
+}
+export interface VectorBackendSearchParams {
+    db: unknown;
+    shard: ShardInfo;
+    kind: VectorKind;
+    queryVector: Float32Array;
+    limit: number;
+}
+export interface VectorBackend {
+    getBackendName(): string;
+    insert(args: {
+        id: string;
+        vector: Float32Array;
+        shard: ShardInfo;
+        kind: VectorKind;
+    }): Promise<void>;
+    insertBatch(args: {
+        items: BackendInsertItem[];
+        shard: ShardInfo;
+        kind: VectorKind;
+    }): Promise<void>;
+    delete(args: {
+        id: string;
+        shard: ShardInfo;
+        kind: VectorKind;
+    }): Promise<void>;
+    search(args: VectorBackendSearchParams): Promise<BackendSearchResult[]>;
+    rebuildFromShard(args: {
+        db: unknown;
+        shard: ShardInfo;
+        kind: VectorKind;
+    }): Promise<void>;
+    deleteShardIndexes(args: {
+        shard: ShardInfo;
+    }): Promise<void>;
+}
+export interface VectorBackendFactoryOptions {
+    vectorBackend: "usearch-first" | "usearch" | "exact-scan";
+    probeUSearch?: () => Promise<boolean>;
+    createUSearchBackend?: () => VectorBackend;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/services/vector-backends/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/services/vector-backends/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAEpD,MAAM,MAAM,UAAU,GAAG,SAAS,GAAG,MAAM,CAAC;AAE5C,MAAM,WAAW,mBAAmB;IAClC,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,iBAAiB;IAChC,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,YAAY,CAAC;CACtB;AAED,MAAM,WAAW,yBAAyB;IACxC,EAAE,EAAE,OAAO,CAAC;IACZ,KAAK,EAAE,SAAS,CAAC;IACjB,IAAI,EAAE,UAAU,CAAC;IACjB,WAAW,EAAE,YAAY,CAAC;IAC1B,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,aAAa;IAC5B,cAAc,IAAI,MAAM,CAAC;IACzB,MAAM,CAAC,IAAI,EAAE;QACX,EAAE,EAAE,MAAM,CAAC;QACX,MAAM,EAAE,YAAY,CAAC;QACrB,KAAK,EAAE,SAAS,CAAC;QACjB,IAAI,EAAE,UAAU,CAAC;KAClB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAClB,WAAW,CAAC,IAAI,EAAE;QAChB,KAAK,EAAE,iBAAiB,EAAE,CAAC;QAC3B,KAAK,EAAE,SAAS,CAAC;QACjB,IAAI,EAAE,UAAU,CAAC;KAClB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAClB,MAAM,CAAC,IAAI,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,SAAS,CAAC;QAAC,IAAI,EAAE,UAAU,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAChF,MAAM,CAAC,IAAI,EAAE,yBAAyB,GAAG,OAAO,CAAC,mBAAmB,EAAE,CAAC,CAAC;IACxE,gBAAgB,CAAC,IAAI,EAAE;QAAE,EAAE,EAAE,OAAO,CAAC;QAAC,KAAK,EAAE,SAAS,CAAC;QAAC,IAAI,EAAE,UAAU,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3F,kBAAkB,CAAC,IAAI,EAAE;QAAE,KAAK,EAAE,SAAS,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC/D;AAED,MAAM,WAAW,2BAA2B;IAC1C,aAAa,EAAE,eAAe,GAAG,SAAS,GAAG,YAAY,CAAC;IAC1D,YAAY,CAAC,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,CAAC;IACtC,oBAAoB,CAAC,EAAE,MAAM,aAAa,CAAC;CAC5C"}

package/dist/services/vector-backends/types.js

@@ -0,0 +1 @@
+export {};

package/dist/services/vector-backends/usearch-backend.d.ts

@@ -0,0 +1,47 @@
+import type { BackendInsertItem, BackendSearchResult, VectorBackend, VectorBackendSearchParams, VectorKind } from "./types.js";
+import type { ShardInfo } from "../sqlite/types.js";
+export declare class USearchBackend implements VectorBackend {
+    private readonly options;
+    private readonly indexes;
+    constructor(options: {
+        baseDir: string;
+        dimensions: number;
+    });
+    getBackendName(): string;
+    insert(args: {
+        id: string;
+        vector: Float32Array;
+        shard: ShardInfo;
+        kind: VectorKind;
+    }): Promise<void>;
+    insertBatch(args: {
+        items: BackendInsertItem[];
+        shard: ShardInfo;
+        kind: VectorKind;
+    }): Promise<void>;
+    delete(args: {
+        id: string;
+        shard: ShardInfo;
+        kind: VectorKind;
+    }): Promise<void>;
+    search(args: VectorBackendSearchParams): Promise<BackendSearchResult[]>;
+    rebuildFromShard(args: {
+        db: unknown;
+        shard: ShardInfo;
+        kind: VectorKind;
+    }): Promise<void>;
+    deleteShardIndexes(args: {
+        shard: ShardInfo;
+    }): Promise<void>;
+    insertManyForTest(indexKey: string, items: BackendInsertItem[]): Promise<void>;
+    searchForTest(indexKey: string, queryVector: Float32Array, limit: number): Promise<BackendSearchResult[]>;
+    private getOrCreateIndex;
+    private createEmptyIndex;
+    private ensureKey;
+    private addItems;
+    private upsertItem;
+    private decodeVector;
+    private getIndexKey;
+    private loadUSearch;
+}
+//# sourceMappingURL=usearch-backend.d.ts.map

package/dist/services/vector-backends/usearch-backend.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"usearch-backend.d.ts","sourceRoot":"","sources":["../../../src/services/vector-backends/usearch-backend.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,iBAAiB,EACjB,mBAAmB,EACnB,aAAa,EACb,yBAAyB,EACzB,UAAU,EACX,MAAM,YAAY,CAAC;AACpB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAcpD,qBAAa,cAAe,YAAW,aAAa;IAIhD,OAAO,CAAC,QAAQ,CAAC,OAAO;IAH1B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAkC;gBAGvC,OAAO,EAAE;QACxB,OAAO,EAAE,MAAM,CAAC;QAChB,UAAU,EAAE,MAAM,CAAC;KACpB;IAKH,cAAc,IAAI,MAAM;IAIlB,MAAM,CAAC,IAAI,EAAE;QACjB,EAAE,EAAE,MAAM,CAAC;QACX,MAAM,EAAE,YAAY,CAAC;QACrB,KAAK,EAAE,SAAS,CAAC;QACjB,IAAI,EAAE,UAAU,CAAC;KAClB,GAAG,OAAO,CAAC,IAAI,CAAC;IAWX,WAAW,CAAC,IAAI,EAAE;QACtB,KAAK,EAAE,iBAAiB,EAAE,CAAC;QAC3B,KAAK,EAAE,SAAS,CAAC;QACjB,IAAI,EAAE,UAAU,CAAC;KAClB,GAAG,OAAO,CAAC,IAAI,CAAC;IAWX,MAAM,CAAC,IAAI,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,SAAS,CAAC;QAAC,IAAI,EAAE,UAAU,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAS/E,MAAM,CAAC,IAAI,EAAE,yBAAyB,GAAG,OAAO,CAAC,mBAAmB,EAAE,CAAC;IAsBvE,gBAAgB,CAAC,IAAI,EAAE;QAAE,EAAE,EAAE,OAAO,CAAC;QAAC,KAAK,EAAE,SAAS,CAAC;QAAC,IAAI,EAAE,UAAU,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAmC1F,kBAAkB,CAAC,IAAI,EAAE;QAAE,KAAK,EAAE,SAAS,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAO7D,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,iBAAiB,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAM9E,aAAa,CACjB,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,YAAY,EACzB,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,mBAAmB,EAAE,CAAC;YAqBnB,gBAAgB;YAShB,gBAAgB;IAY9B,OAAO,CAAC,SAAS;IAWjB,OAAO,CAAC,QAAQ;IAMhB,OAAO,CAAC,UAAU;IASlB,OAAO,CAAC,YAAY;IAUpB,OAAO,CAAC,WAAW;YAIL,WAAW;CAO1B"}

package/dist/services/vector-backends/usearch-backend.js

@@ -0,0 +1,174 @@
+export class USearchBackend {
+    options;
+    indexes = new Map();
+    constructor(options) {
+        this.options = options;
+        void this.options.baseDir;
+    }
+    getBackendName() {
+        return "usearch";
+    }
+    async insert(args) {
+        const indexKey = this.getIndexKey(args.shard, args.kind);
+        const cache = await this.getOrCreateIndex(indexKey);
+        try {
+            this.upsertItem(cache, { id: args.id, vector: args.vector });
+            cache.initialized = true;
+        }
+        catch (error) {
+            throw new Error(`USearch insert failed for ${indexKey}: ${String(error)}`);
+        }
+    }
+    async insertBatch(args) {
+        const indexKey = this.getIndexKey(args.shard, args.kind);
+        const cache = await this.getOrCreateIndex(indexKey);
+        try {
+            this.addItems(cache, args.items);
+            cache.initialized = true;
+        }
+        catch (error) {
+            throw new Error(`USearch batch insert failed for ${indexKey}: ${String(error)}`);
+        }
+    }
+    async delete(args) {
+        const cache = await this.getOrCreateIndex(this.getIndexKey(args.shard, args.kind));
+        const key = cache.idToKey.get(args.id);
+        if (key === undefined)
+            return;
+        cache.index.remove(key);
+        cache.idToKey.delete(args.id);
+        cache.keyToId.delete(key);
+    }
+    async search(args) {
+        const indexKey = this.getIndexKey(args.shard, args.kind);
+        const cache = await this.getOrCreateIndex(indexKey);
+        try {
+            const matches = cache.index.search(args.queryVector, args.limit);
+            return Array.from(matches.keys, (key, index) => {
+                const id = cache.keyToId.get(key);
+                if (!id) {
+                    throw new Error(`USearch index metadata missing for key ${String(key)} in ${cache.indexKey}`);
+                }
+                return {
+                    id,
+                    distance: matches.distances[index] ?? 0,
+                };
+            });
+        }
+        catch (error) {
+            throw new Error(`USearch search failed for ${indexKey}: ${String(error)}`);
+        }
+    }
+    async rebuildFromShard(args) {
+        const indexKey = this.getIndexKey(args.shard, args.kind);
+        const existing = this.indexes.get(indexKey);
+        if (existing?.initialized) {
+            return;
+        }
+        const column = args.kind === "tags" ? "tags_vector" : "vector";
+        const rows = args.db
+            .prepare(`SELECT id, ${column} FROM memories WHERE ${column} IS NOT NULL`)
+            .all();
+        const cache = await this.createEmptyIndex(indexKey);
+        this.indexes.set(indexKey, cache);
+        for (const row of rows) {
+            const raw = args.kind === "tags" ? row.tags_vector : row.vector;
+            const vector = this.decodeVector(raw);
+            if (vector.length === 0)
+                continue;
+            this.upsertItem(cache, { id: row.id, vector });
+        }
+        cache.initialized = true;
+    }
+    async deleteShardIndexes(args) {
+        for (const kind of ["content", "tags"]) {
+            const indexKey = this.getIndexKey(args.shard, kind);
+            this.indexes.delete(indexKey);
+        }
+    }
+    async insertManyForTest(indexKey, items) {
+        const cache = await this.getOrCreateIndex(indexKey);
+        this.addItems(cache, items);
+        cache.initialized = true;
+    }
+    async searchForTest(indexKey, queryVector, limit) {
+        const cache = await this.getOrCreateIndex(indexKey);
+        try {
+            const matches = cache.index.search(queryVector, limit);
+            return Array.from(matches.keys, (key, index) => {
+                const id = cache.keyToId.get(key);
+                if (!id) {
+                    throw new Error(`USearch index metadata missing for key ${String(key)} in ${cache.indexKey}`);
+                }
+                return {
+                    id,
+                    distance: matches.distances[index] ?? 0,
+                };
+            });
+        }
+        catch (error) {
+            throw new Error(`USearch test search failed for ${indexKey}: ${String(error)}`);
+        }
+    }
+    async getOrCreateIndex(indexKey) {
+        const existing = this.indexes.get(indexKey);
+        if (existing)
+            return existing;
+        const cache = await this.createEmptyIndex(indexKey);
+        this.indexes.set(indexKey, cache);
+        return cache;
+    }
+    async createEmptyIndex(indexKey) {
+        const usearch = await this.loadUSearch();
+        return {
+            index: new usearch.Index({ dimensions: this.options.dimensions, metric: "cos" }),
+            idToKey: new Map(),
+            keyToId: new Map(),
+            nextKey: 1n,
+            indexKey,
+            initialized: false,
+        };
+    }
+    ensureKey(cache, id) {
+        const existing = cache.idToKey.get(id);
+        if (existing !== undefined)
+            return existing;
+        const key = cache.nextKey;
+        cache.nextKey += 1n;
+        cache.idToKey.set(id, key);
+        cache.keyToId.set(key, id);
+        return key;
+    }
+    addItems(cache, items) {
+        for (const item of items) {
+            this.upsertItem(cache, item);
+        }
+    }
+    upsertItem(cache, item) {
+        const existing = cache.idToKey.get(item.id);
+        if (existing !== undefined) {
+            cache.index.remove(existing);
+        }
+        const key = this.ensureKey(cache, item.id);
+        cache.index.add(key, item.vector);
+    }
+    decodeVector(value) {
+        if (!value)
+            return new Float32Array();
+        if (value instanceof Uint8Array) {
+            return new Float32Array(value.buffer.slice(value.byteOffset, value.byteOffset + value.byteLength));
+        }
+        return new Float32Array(value);
+    }
+    getIndexKey(shard, kind) {
+        return `${shard.scope}_${shard.scopeHash}_${shard.shardIndex}_${kind}`;
+    }
+    async loadUSearch() {
+        try {
+            return await import("usearch");
+        }
+        catch (error) {
+            throw new Error(`Failed to load usearch backend: ${String(error)}`);
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-mem",
-  "version": "2.11.8",
+  "version": "2.11.9",
   "description": "OpenCode plugin that gives coding agents persistent memory using local vector database",
   "type": "module",
   "main": "dist/plugin.js",
@@ -36,8 +36,8 @@
     "@opencode-ai/plugin": "^1.0.162",
     "@xenova/transformers": "^2.17.2",
     "franc-min": "^6.2.0",
-    "hnswlib-wasm": "^0.8.2",
-    "iso-639-3": "^3.0.1"
+    "iso-639-3": "^3.0.1",
+    "usearch": "^2.21.4"
   },
   "devDependencies": {
     "@types/bun": "^1.3.8",

package/dist/services/sqlite/hnsw-index.d.ts

@@ -1,37 +0,0 @@
-export interface HNSWIndexData {
-    id: string;
-    vector: Float32Array;
-}
-export declare class HNSWIndex {
-    private index;
-    private idMap;
-    private reverseMap;
-    private nextId;
-    private dimensions;
-    private indexPath;
-    private maxElements;
-    private initialized;
-    constructor(dimensions: number, indexPath: string);
-    private ensureInitialized;
-    insert(id: string, vector: Float32Array): Promise<void>;
-    insertBatch(items: HNSWIndexData[]): Promise<void>;
-    search(queryVector: Float32Array, k: number): Promise<{
-        id: string;
-        distance: number;
-    }[]>;
-    delete(id: string): Promise<void>;
-    save(): Promise<void>;
-    getCount(): number;
-    isPopulated(): boolean;
-}
-export declare class HNSWIndexManager {
-    private indexes;
-    private baseDir;
-    constructor(baseDir: string);
-    getIndex(scope: string, scopeHash: string, shardIndex: number): HNSWIndex;
-    getTagsIndex(scope: string, scopeHash: string, shardIndex: number): HNSWIndex;
-    rebuildFromShard(db: any, scope: string, scopeHash: string, shardIndex: number): Promise<void>;
-    deleteIndex(scope: string, scopeHash: string, shardIndex: number): Promise<void>;
-    cleanupOrphanedIndexes(validKeys: Set<string>): Promise<void>;
-}
-//# sourceMappingURL=hnsw-index.d.ts.map

package/dist/services/sqlite/hnsw-index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"hnsw-index.d.ts","sourceRoot":"","sources":["../../../src/services/sqlite/hnsw-index.ts"],"names":[],"mappings":"AAoBA,MAAM,WAAW,aAAa;IAC5B,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,YAAY,CAAC;CACtB;AAED,qBAAa,SAAS;IACpB,OAAO,CAAC,KAAK,CAAa;IAC1B,OAAO,CAAC,KAAK,CAAkC;IAC/C,OAAO,CAAC,UAAU,CAAkC;IACpD,OAAO,CAAC,MAAM,CAAa;IAC3B,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,WAAW,CAAiB;IACpC,OAAO,CAAC,WAAW,CAAkB;gBAEzB,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM;YAKnC,iBAAiB;IAyBzB,MAAM,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;IAiBvD,WAAW,CAAC,KAAK,EAAE,aAAa,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAmBlD,MAAM,CAAC,WAAW,EAAE,YAAY,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IAqBzF,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAYjC,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAmB3B,QAAQ,IAAI,MAAM;IAIlB,WAAW,IAAI,OAAO;CAGvB;AAED,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,OAAO,CAAqC;IACpD,OAAO,CAAC,OAAO,CAAS;gBAEZ,OAAO,EAAE,MAAM;IAO3B,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,SAAS;IAWzE,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,SAAS;IAWvE,gBAAgB,CACpB,EAAE,EAAE,GAAG,EACP,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,IAAI,CAAC;IAoCV,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAoBhF,sBAAsB,CAAC,SAAS,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;CA0BpE"}

package/dist/services/sqlite/hnsw-index.js

@@ -1,235 +0,0 @@
-import { mkdirSync, existsSync, writeFileSync, unlinkSync, readdirSync } from "node:fs";
-import { join, dirname, basename } from "node:path";
-import { log } from "../logger.js";
-import { CONFIG } from "../../config.js";
-let HNSWLib = null;
-async function loadHNSWLib() {
-    if (!HNSWLib) {
-        // hnswlib-wasm is compiled with Emscripten -sENVIRONMENT=web and requires
-        // a browser-like global. This monkey-patch allows it to load in Node.js/Bun.
-        if (typeof globalThis.window === "undefined") {
-            globalThis.window = globalThis;
-        }
-        const { loadHnswlib } = await import("hnswlib-wasm");
-        HNSWLib = await loadHnswlib();
-    }
-    return HNSWLib;
-}
-export class HNSWIndex {
-    index = null;
-    idMap = new Map();
-    reverseMap = new Map();
-    nextId = 0;
-    dimensions;
-    indexPath;
-    maxElements = 50000;
-    initialized = false;
-    constructor(dimensions, indexPath) {
-        this.dimensions = dimensions;
-        this.indexPath = indexPath;
-    }
-    async ensureInitialized() {
-        if (this.initialized)
-            return;
-        const hnsw = await loadHNSWLib();
-        const dir = dirname(this.indexPath);
-        if (!existsSync(dir)) {
-            mkdirSync(dir, { recursive: true });
-        }
-        // hnswlib-wasm uses Emscripten MEMFS (in-memory virtual FS) and has no
-        // exported FS API for bridging to real filesystem. HNSW indexes are kept
-        // purely in-memory and rebuilt from SQLite vectors on process restart.
-        // Constructor requires 3 args: (spaceName, numDimensions, autoSaveFilename)
-        this.index = new hnsw.HierarchicalNSW("cosine", this.dimensions, "");
-        // initIndex requires 4 args: (maxElements, m, efConstruction, randomSeed)
-        this.index.initIndex(this.maxElements, 16, 200, 100);
-        this.initialized = true;
-        log("HNSW index initialized (in-memory)", {
-            path: this.indexPath,
-            dimensions: this.dimensions,
-        });
-    }
-    async insert(id, vector) {
-        await this.ensureInitialized();
-        if (this.reverseMap.has(id)) {
-            const internalId = this.reverseMap.get(id);
-            this.index.markDelete(internalId);
-        }
-        const internalId = this.nextId++;
-        // hnswlib-wasm addPoint requires 3 args: (point, label, replaceDeleted)
-        this.index.addPoint(vector, internalId, false);
-        this.idMap.set(internalId, id);
-        this.reverseMap.set(id, internalId);
-        await this.save();
-    }
-    async insertBatch(items) {
-        await this.ensureInitialized();
-        for (const item of items) {
-            if (this.reverseMap.has(item.id)) {
-                const internalId = this.reverseMap.get(item.id);
-                this.index.markDelete(internalId);
-            }
-            const internalId = this.nextId++;
-            // hnswlib-wasm addPoint requires 3 args: (point, label, replaceDeleted)
-            this.index.addPoint(item.vector, internalId, false);
-            this.idMap.set(internalId, item.id);
-            this.reverseMap.set(item.id, internalId);
-        }
-        await this.save();
-    }
-    async search(queryVector, k) {
-        await this.ensureInitialized();
-        try {
-            // hnswlib-wasm searchKnn requires 3 args: (queryPoint, numNeighbors, filter)
-            const actualK = Math.min(k, this.reverseMap.size);
-            if (actualK === 0)
-                return [];
-            const results = this.index.searchKnn(queryVector, actualK, null);
-            return results.neighbors
-                .map((internalId, idx) => ({
-                id: this.idMap.get(internalId) || "",
-                distance: results.distances[idx] ?? 0,
-            }))
-                .filter((r) => r.id);
-        }
-        catch (error) {
-            log("HNSW search error", { error: String(error) });
-            return [];
-        }
-    }
-    async delete(id) {
-        await this.ensureInitialized();
-        if (this.reverseMap.has(id)) {
-            const internalId = this.reverseMap.get(id);
-            this.index.markDelete(internalId);
-            this.idMap.delete(internalId);
-            this.reverseMap.delete(id);
-            await this.save();
-        }
-    }
-    async save() {
-        if (!this.index)
-            return;
-        const dir = dirname(this.indexPath);
-        if (!existsSync(dir)) {
-            mkdirSync(dir, { recursive: true });
-        }
-        // Only persist id mapping (.meta file). HNSW index data lives in-memory
-        // and is rebuilt from SQLite vectors on process restart.
-        const metaPath = this.indexPath + ".meta";
-        const meta = {
-            nextId: this.nextId,
-            idMap: Object.fromEntries(this.idMap),
-            reverseMap: Object.fromEntries(this.reverseMap),
-        };
-        writeFileSync(metaPath, JSON.stringify(meta));
-    }
-    getCount() {
-        return this.reverseMap.size;
-    }
-    isPopulated() {
-        return this.reverseMap.size > 0;
-    }
-}
-export class HNSWIndexManager {
-    indexes = new Map();
-    baseDir;
-    constructor(baseDir) {
-        this.baseDir = baseDir;
-        if (!existsSync(baseDir)) {
-            mkdirSync(baseDir, { recursive: true });
-        }
-    }
-    getIndex(scope, scopeHash, shardIndex) {
-        const key = `${scope}_${scopeHash}_${shardIndex}`;
-        if (!this.indexes.has(key)) {
-            const indexPath = join(this.baseDir, scope + "s", `${key}.hnsw`);
-            this.indexes.set(key, new HNSWIndex(CONFIG.embeddingDimensions, indexPath));
-        }
-        return this.indexes.get(key);
-    }
-    getTagsIndex(scope, scopeHash, shardIndex) {
-        const key = `${scope}_${scopeHash}_${shardIndex}_tags`;
-        if (!this.indexes.has(key)) {
-            const indexPath = join(this.baseDir, scope + "s", `${key}.hnsw`);
-            this.indexes.set(key, new HNSWIndex(CONFIG.embeddingDimensions, indexPath));
-        }
-        return this.indexes.get(key);
-    }
-    async rebuildFromShard(db, scope, scopeHash, shardIndex) {
-        const contentIndex = this.getIndex(scope, scopeHash, shardIndex);
-        const tagsIndex = this.getTagsIndex(scope, scopeHash, shardIndex);
-        const rows = db.prepare("SELECT id, vector, tags_vector FROM memories").all();
-        const contentItems = [];
-        const tagsItems = [];
-        for (const row of rows) {
-            if (row.vector) {
-                const vector = new Float32Array(row.vector.buffer);
-                contentItems.push({ id: row.id, vector });
-            }
-            if (row.tags_vector) {
-                const tagsVector = new Float32Array(row.tags_vector.buffer);
-                tagsItems.push({ id: row.id, vector: tagsVector });
-            }
-        }
-        if (contentItems.length > 0) {
-            await contentIndex.insertBatch(contentItems);
-        }
-        if (tagsItems.length > 0) {
-            await tagsIndex.insertBatch(tagsItems);
-        }
-        log("HNSW indexes rebuilt", {
-            scope,
-            scopeHash,
-            shardIndex,
-            content: contentItems.length,
-            tags: tagsItems.length,
-        });
-    }
-    async deleteIndex(scope, scopeHash, shardIndex) {
-        const contentKey = `${scope}_${scopeHash}_${shardIndex}`;
-        const tagsKey = `${scope}_${scopeHash}_${shardIndex}_tags`;
-        this.indexes.delete(contentKey);
-        this.indexes.delete(tagsKey);
-        for (const key of [contentKey, tagsKey]) {
-            const indexPath = join(this.baseDir, scope + "s", `${key}.hnsw`);
-            const metaPath = indexPath + ".meta";
-            try {
-                if (existsSync(indexPath))
-                    unlinkSync(indexPath);
-                if (existsSync(metaPath))
-                    unlinkSync(metaPath);
-            }
-            catch (error) {
-                log("Error deleting HNSW index files", { path: indexPath, error: String(error) });
-            }
-        }
-    }
-    async cleanupOrphanedIndexes(validKeys) {
-        const scopeDirs = ["users", "projects"];
-        for (const scopeDir of scopeDirs) {
-            const dir = join(this.baseDir, scopeDir);
-            if (!existsSync(dir))
-                continue;
-            const files = readdirSync(dir);
-            for (const file of files) {
-                if (file.endsWith(".hnsw")) {
-                    const key = basename(file, ".hnsw");
-                    if (!validKeys.has(key)) {
-                        const indexPath = join(dir, file);
-                        const metaPath = indexPath + ".meta";
-                        try {
-                            unlinkSync(indexPath);
-                            if (existsSync(metaPath))
-                                unlinkSync(metaPath);
-                            log("Removed orphaned HNSW index", { path: indexPath });
-                        }
-                        catch (error) {
-                            log("Error removing orphaned index", { path: indexPath, error: String(error) });
-                        }
-                    }
-                }
-            }
-        }
-    }
-}