@renseiai/agentfactory-code-intelligence 0.8.8 → 0.8.10

package/dist/src/types.d.ts

@@ -180,7 +180,12 @@ export declare const SearchResultSchema: z.ZodObject<{
         exact: "exact";
         fuzzy: "fuzzy";
         bm25: "bm25";
+        semantic: "semantic";
+        hybrid: "hybrid";
     }>;
+    bm25Score: z.ZodOptional<z.ZodNumber>;
+    vectorScore: z.ZodOptional<z.ZodNumber>;
+    rerankScore: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
 export type SearchResult = z.infer<typeof SearchResultSchema>;
 export declare const MemoryEntrySchema: z.ZodObject<{
@@ -239,4 +244,82 @@ export declare const RepoMapEntrySchema: z.ZodObject<{
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export type RepoMapEntry = z.infer<typeof RepoMapEntrySchema>;
+export declare const EmbeddingChunkSchema: z.ZodObject<{
+    id: z.ZodString;
+    content: z.ZodString;
+    embedding: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    metadata: z.ZodObject<{
+        filePath: z.ZodString;
+        symbolName: z.ZodOptional<z.ZodString>;
+        symbolKind: z.ZodOptional<z.ZodEnum<{
+            function: "function";
+            class: "class";
+            interface: "interface";
+            type: "type";
+            variable: "variable";
+            method: "method";
+            property: "property";
+            import: "import";
+            export: "export";
+            enum: "enum";
+            struct: "struct";
+            trait: "trait";
+            impl: "impl";
+            macro: "macro";
+            decorator: "decorator";
+            module: "module";
+        }>>;
+        startLine: z.ZodNumber;
+        endLine: z.ZodNumber;
+        language: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type EmbeddingChunk = z.infer<typeof EmbeddingChunkSchema>;
+export declare const EmbeddingProviderConfigSchema: z.ZodObject<{
+    model: z.ZodString;
+    dimensions: z.ZodOptional<z.ZodNumber>;
+    batchSize: z.ZodOptional<z.ZodNumber>;
+    maxRetries: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type EmbeddingProviderConfig = z.infer<typeof EmbeddingProviderConfigSchema>;
+export declare const VectorSearchResultSchema: z.ZodObject<{
+    chunk: z.ZodObject<{
+        id: z.ZodString;
+        content: z.ZodString;
+        embedding: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+        metadata: z.ZodObject<{
+            filePath: z.ZodString;
+            symbolName: z.ZodOptional<z.ZodString>;
+            symbolKind: z.ZodOptional<z.ZodEnum<{
+                function: "function";
+                class: "class";
+                interface: "interface";
+                type: "type";
+                variable: "variable";
+                method: "method";
+                property: "property";
+                import: "import";
+                export: "export";
+                enum: "enum";
+                struct: "struct";
+                trait: "trait";
+                impl: "impl";
+                macro: "macro";
+                decorator: "decorator";
+                module: "module";
+            }>>;
+            startLine: z.ZodNumber;
+            endLine: z.ZodNumber;
+            language: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    score: z.ZodNumber;
+}, z.core.$strip>;
+export type VectorSearchResult = z.infer<typeof VectorSearchResultSchema>;
+export declare const VectorIndexConfigSchema: z.ZodObject<{
+    enabled: z.ZodBoolean;
+    batchSize: z.ZodOptional<z.ZodNumber>;
+    maxConcurrentBatches: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type VectorIndexConfig = z.infer<typeof VectorIndexConfigSchema>;
 //# sourceMappingURL=types.d.ts.map

package/dist/src/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;EAiB3B,CAAA;AACF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAIzD,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAW3B,CAAA;AACF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAIzD,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAOxB,CAAA;AACF,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAA;AAInD,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAK1B,CAAA;AACF,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA;AAIvD,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;iBAM5B,CAAA;AACF,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAE3D,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAI7B,CAAA;AACF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAI7D,eAAO,MAAM,iBAAiB;;;;;;;iBAO5B,CAAA;AACF,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAE3D,eAAO,MAAM,iBAAiB;;;;;;;;;iBAK5B,CAAA;AACF,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAI3D,eAAO,MAAM,mBAAmB;;;;;;;iBAO9B,CAAA;AACF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAI/D,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;iBAQ7B,CAAA;AACF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;EAiB3B,CAAA;AACF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAIzD,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAW3B,CAAA;AACF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAIzD,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAOxB,CAAA;AACF,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAA;AAInD,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAK1B,CAAA;AACF,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA;AAIvD,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;iBAM5B,CAAA;AACF,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAE3D,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAO7B,CAAA;AACF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAI7D,eAAO,MAAM,iBAAiB;;;;;;;iBAO5B,CAAA;AACF,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAE3D,eAAO,MAAM,iBAAiB;;;;;;;;;iBAK5B,CAAA;AACF,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAI3D,eAAO,MAAM,mBAAmB;;;;;;;iBAO9B,CAAA;AACF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAI/D,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;iBAQ7B,CAAA;AACF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAI7D,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAY/B,CAAA;AACF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAEjE,eAAO,MAAM,6BAA6B;;;;;iBAKxC,CAAA;AACF,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAA;AAInF,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAGnC,CAAA;AACF,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAIzE,eAAO,MAAM,uBAAuB;;;;iBAIlC,CAAA;AACF,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA"}

package/dist/src/types.js

@@ -57,8 +57,11 @@ export const SearchQuerySchema = z.object({
 });
 export const SearchResultSchema = z.object({
     symbol: CodeSymbolSchema,
-    score: z.number().nonnegative(),
-    matchType: z.enum(['exact', 'fuzzy', 'bm25']),
+    score: z.number(),
+    matchType: z.enum(['exact', 'fuzzy', 'bm25', 'semantic', 'hybrid']),
+    bm25Score: z.number().optional(),
+    vectorScore: z.number().optional(),
+    rerankScore: z.number().optional(),
 });
 // ── Memory / Dedup ────────────────────────────────────────────────────
 export const MemoryEntrySchema = z.object({
@@ -94,3 +97,34 @@ export const RepoMapEntrySchema = z.object({
         line: z.number().int().nonnegative(),
     })),
 });
+// ── Embedding ────────────────────────────────────────────────────────
+export const EmbeddingChunkSchema = z.object({
+    id: z.string().min(1), // filePath:symbolName:startLine
+    content: z.string(), // Text sent to embedding model
+    embedding: z.array(z.number()).optional(), // Dense vector
+    metadata: z.object({
+        filePath: z.string().min(1),
+        symbolName: z.string().optional(),
+        symbolKind: SymbolKindSchema.optional(),
+        startLine: z.number().int().nonnegative(),
+        endLine: z.number().int().nonnegative(),
+        language: z.string(),
+    }),
+});
+export const EmbeddingProviderConfigSchema = z.object({
+    model: z.string().min(1),
+    dimensions: z.number().int().positive().optional(),
+    batchSize: z.number().int().positive().optional(),
+    maxRetries: z.number().int().nonnegative().optional(),
+});
+// ── Vector Store ─────────────────────────────────────────────────────
+export const VectorSearchResultSchema = z.object({
+    chunk: EmbeddingChunkSchema,
+    score: z.number(),
+});
+// ── Vector Indexing ──────────────────────────────────────────────────
+export const VectorIndexConfigSchema = z.object({
+    enabled: z.boolean(),
+    batchSize: z.number().int().positive().optional(),
+    maxConcurrentBatches: z.number().int().positive().optional(),
+});

package/dist/src/vector/__tests__/vector-store.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=vector-store.test.d.ts.map

package/dist/src/vector/__tests__/vector-store.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vector-store.test.d.ts","sourceRoot":"","sources":["../../../../src/vector/__tests__/vector-store.test.ts"],"names":[],"mappings":""}

package/dist/src/vector/__tests__/vector-store.test.js

@@ -0,0 +1,278 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { InMemoryVectorStore } from '../hnsw-store.js';
+// ── Helpers ──────────────────────────────────────────────────────────
+function makeChunk(id, embedding) {
+    return {
+        id,
+        content: `content for ${id}`,
+        embedding,
+        metadata: {
+            filePath: `src/${id}.ts`,
+            symbolName: id,
+            symbolKind: 'function',
+            startLine: 0,
+            endLine: 10,
+            language: 'typescript',
+        },
+    };
+}
+/** Generate a random unit vector of given dimensions. */
+function randomVector(dims) {
+    const v = Array.from({ length: dims }, () => Math.random() - 0.5);
+    const norm = Math.sqrt(v.reduce((sum, x) => sum + x * x, 0));
+    return v.map(x => x / norm);
+}
+/** Normalize a vector to unit length. */
+function normalize(v) {
+    const norm = Math.sqrt(v.reduce((sum, x) => sum + x * x, 0));
+    if (norm === 0)
+        return v;
+    return v.map(x => x / norm);
+}
+/** Cosine similarity between two vectors. */
+function cosine(a, b) {
+    let dot = 0, normA = 0, normB = 0;
+    for (let i = 0; i < a.length; i++) {
+        dot += a[i] * b[i];
+        normA += a[i] * a[i];
+        normB += b[i] * b[i];
+    }
+    const denom = Math.sqrt(normA) * Math.sqrt(normB);
+    return denom === 0 ? 0 : dot / denom;
+}
+// ── Tests ────────────────────────────────────────────────────────────
+describe('InMemoryVectorStore', () => {
+    let store;
+    beforeEach(() => {
+        store = new InMemoryVectorStore();
+    });
+    describe('empty store', () => {
+        it('returns empty array for search on empty store', async () => {
+            const results = await store.search([1, 0, 0], 5);
+            expect(results).toEqual([]);
+        });
+        it('has size 0', () => {
+            expect(store.size()).toBe(0);
+        });
+    });
+    describe('insert and search (brute-force)', () => {
+        it('inserts and retrieves basic vectors', async () => {
+            const chunks = [
+                makeChunk('a', [1, 0, 0]),
+                makeChunk('b', [0, 1, 0]),
+                makeChunk('c', [0, 0, 1]),
+            ];
+            await store.insert(chunks);
+            expect(store.size()).toBe(3);
+            const results = await store.search([1, 0, 0], 3);
+            expect(results).toHaveLength(3);
+            expect(results[0].chunk.id).toBe('a');
+            expect(results[0].score).toBeCloseTo(1.0, 5);
+        });
+        it('respects topK limit', async () => {
+            const chunks = Array.from({ length: 10 }, (_, i) => makeChunk(`v${i}`, randomVector(8)));
+            await store.insert(chunks);
+            const results = await store.search(randomVector(8), 3);
+            expect(results).toHaveLength(3);
+        });
+        it('skips chunks without embeddings', async () => {
+            const withEmbedding = makeChunk('a', [1, 0, 0]);
+            const withoutEmbedding = {
+                id: 'b',
+                content: 'no embedding',
+                metadata: {
+                    filePath: 'src/b.ts',
+                    startLine: 0,
+                    endLine: 5,
+                    language: 'typescript',
+                },
+            };
+            await store.insert([withEmbedding, withoutEmbedding]);
+            expect(store.size()).toBe(1);
+        });
+    });
+    describe('cosine similarity correctness', () => {
+        it('identical vectors have similarity 1', async () => {
+            const v = normalize([3, 4, 0]);
+            await store.insert([makeChunk('a', v)]);
+            const results = await store.search(v, 1);
+            expect(results[0].score).toBeCloseTo(1.0, 5);
+        });
+        it('orthogonal vectors have similarity 0', async () => {
+            await store.insert([
+                makeChunk('x', [1, 0, 0]),
+                makeChunk('y', [0, 1, 0]),
+            ]);
+            const results = await store.search([1, 0, 0], 2);
+            const yResult = results.find(r => r.chunk.id === 'y');
+            expect(yResult.score).toBeCloseTo(0.0, 5);
+        });
+        it('opposite vectors have similarity -1', async () => {
+            await store.insert([makeChunk('neg', [-1, 0, 0])]);
+            const results = await store.search([1, 0, 0], 1);
+            expect(results[0].score).toBeCloseTo(-1.0, 5);
+        });
+        it('scores match manual cosine computation', async () => {
+            const a = [1, 2, 3];
+            const b = [4, 5, 6];
+            await store.insert([makeChunk('b', b)]);
+            const results = await store.search(a, 1);
+            expect(results[0].score).toBeCloseTo(cosine(a, b), 5);
+        });
+    });
+    describe('delete', () => {
+        it('removes chunks so they do not appear in search', async () => {
+            await store.insert([
+                makeChunk('a', [1, 0, 0]),
+                makeChunk('b', [0, 1, 0]),
+                makeChunk('c', [0, 0, 1]),
+            ]);
+            await store.delete(['b']);
+            expect(store.size()).toBe(2);
+            const results = await store.search([0, 1, 0], 3);
+            const ids = results.map(r => r.chunk.id);
+            expect(ids).not.toContain('b');
+        });
+        it('handles deleting non-existent ids gracefully', async () => {
+            await store.insert([makeChunk('a', [1, 0, 0])]);
+            await store.delete(['nonexistent']);
+            expect(store.size()).toBe(1);
+        });
+    });
+    describe('clear', () => {
+        it('empties the store completely', async () => {
+            await store.insert([
+                makeChunk('a', [1, 0, 0]),
+                makeChunk('b', [0, 1, 0]),
+            ]);
+            expect(store.size()).toBe(2);
+            await store.clear();
+            expect(store.size()).toBe(0);
+            const results = await store.search([1, 0, 0], 5);
+            expect(results).toEqual([]);
+        });
+    });
+    describe('HNSW promotion', () => {
+        it('activates HNSW when threshold is exceeded', async () => {
+            store.setHNSWThreshold(50);
+            expect(store.isHNSWActive).toBe(false);
+            const chunks = Array.from({ length: 60 }, (_, i) => makeChunk(`v${i}`, randomVector(16)));
+            await store.insert(chunks);
+            expect(store.isHNSWActive).toBe(true);
+            expect(store.size()).toBe(60);
+        });
+        it('returns correct results after HNSW promotion', async () => {
+            store.setHNSWThreshold(50);
+            // Create a distinguishable target vector
+            const dims = 16;
+            const target = Array(dims).fill(0);
+            target[0] = 1.0; // Points strongly in dimension 0
+            const chunks = [makeChunk('target', normalize(target))];
+            // Fill with random vectors
+            for (let i = 0; i < 59; i++) {
+                chunks.push(makeChunk(`rand${i}`, randomVector(dims)));
+            }
+            await store.insert(chunks);
+            expect(store.isHNSWActive).toBe(true);
+            // Search for the target direction
+            const query = [...target];
+            const results = await store.search(query, 5);
+            expect(results.length).toBeGreaterThan(0);
+            // The target chunk should be among top results (HNSW is approximate, but with
+            // such a distinctive vector it should find it)
+            const topIds = results.map(r => r.chunk.id);
+            expect(topIds).toContain('target');
+        });
+        it('delete works after HNSW promotion', async () => {
+            store.setHNSWThreshold(50);
+            const chunks = Array.from({ length: 55 }, (_, i) => makeChunk(`v${i}`, randomVector(8)));
+            await store.insert(chunks);
+            expect(store.isHNSWActive).toBe(true);
+            await store.delete(['v0', 'v1', 'v2']);
+            expect(store.size()).toBe(52);
+            const results = await store.search(randomVector(8), 55);
+            const ids = results.map(r => r.chunk.id);
+            expect(ids).not.toContain('v0');
+            expect(ids).not.toContain('v1');
+            expect(ids).not.toContain('v2');
+        });
+    });
+    describe('persistence (save/load)', () => {
+        let tempDir;
+        beforeEach(async () => {
+            tempDir = await mkdtemp(join(tmpdir(), 'vector-store-test-'));
+        });
+        afterEach(async () => {
+            await rm(tempDir, { recursive: true, force: true });
+        });
+        it('saves and loads, preserving data', async () => {
+            await store.insert([
+                makeChunk('a', [1, 0, 0]),
+                makeChunk('b', [0, 1, 0]),
+                makeChunk('c', [0, 0, 1]),
+            ]);
+            await store.save(tempDir);
+            const loaded = new InMemoryVectorStore();
+            await loaded.load(tempDir);
+            expect(loaded.size()).toBe(3);
+            const results = await loaded.search([1, 0, 0], 3);
+            expect(results).toHaveLength(3);
+            expect(results[0].chunk.id).toBe('a');
+            expect(results[0].score).toBeCloseTo(1.0, 5);
+        });
+        it('saves and loads HNSW index', async () => {
+            store.setHNSWThreshold(50);
+            const dims = 8;
+            const chunks = Array.from({ length: 55 }, (_, i) => makeChunk(`v${i}`, randomVector(dims)));
+            // Make one very distinct chunk
+            const distinctVec = Array(dims).fill(0);
+            distinctVec[0] = 1.0;
+            chunks.push(makeChunk('distinct', normalize(distinctVec)));
+            await store.insert(chunks);
+            expect(store.isHNSWActive).toBe(true);
+            await store.save(tempDir);
+            const loaded = new InMemoryVectorStore();
+            loaded.setHNSWThreshold(50);
+            await loaded.load(tempDir);
+            expect(loaded.size()).toBe(56);
+            const results = await loaded.search(distinctVec, 5);
+            const topIds = results.map(r => r.chunk.id);
+            expect(topIds).toContain('distinct');
+        });
+    });
+    describe('index invalidation', () => {
+        let tempDir;
+        beforeEach(async () => {
+            tempDir = await mkdtemp(join(tmpdir(), 'vector-store-invalid-'));
+        });
+        afterEach(async () => {
+            await rm(tempDir, { recursive: true, force: true });
+        });
+        it('rejects loading when model config hash mismatches', async () => {
+            const storeV1 = new InMemoryVectorStore({ modelConfigHash: 'hash-v1' });
+            await storeV1.insert([makeChunk('a', [1, 0, 0])]);
+            await storeV1.save(tempDir);
+            const storeV2 = new InMemoryVectorStore({ modelConfigHash: 'hash-v2' });
+            await expect(storeV2.load(tempDir)).rejects.toThrow(/model config hash mismatch/);
+        });
+        it('loads successfully when model config hash matches', async () => {
+            const storeV1 = new InMemoryVectorStore({ modelConfigHash: 'hash-v1' });
+            await storeV1.insert([makeChunk('a', [1, 0, 0])]);
+            await storeV1.save(tempDir);
+            const storeV1Copy = new InMemoryVectorStore({ modelConfigHash: 'hash-v1' });
+            await storeV1Copy.load(tempDir);
+            expect(storeV1Copy.size()).toBe(1);
+        });
+        it('loads successfully when no hash is configured on loader', async () => {
+            const storeV1 = new InMemoryVectorStore({ modelConfigHash: 'hash-v1' });
+            await storeV1.insert([makeChunk('a', [1, 0, 0])]);
+            await storeV1.save(tempDir);
+            const noHash = new InMemoryVectorStore();
+            await noHash.load(tempDir);
+            expect(noHash.size()).toBe(1);
+        });
+    });
+});

package/dist/src/vector/hnsw-store.d.ts

@@ -0,0 +1,48 @@
+import type { EmbeddingChunk } from '../types.js';
+import type { VectorStore, VectorSearchResult } from './vector-store.js';
+export interface HNSWStoreOptions {
+    M?: number;
+    efConstruction?: number;
+    efSearch?: number;
+    modelConfigHash?: string;
+}
+export declare class InMemoryVectorStore implements VectorStore {
+    private readonly M;
+    private readonly efConstruction;
+    private readonly efSearch;
+    private readonly modelConfigHash;
+    private hnswThreshold;
+    private chunks;
+    private vectors;
+    private nodes;
+    private entryPoint;
+    private maxLevel;
+    private hnswBuilt;
+    constructor(options?: HNSWStoreOptions);
+    /**
+     * Override the HNSW promotion threshold (useful for testing).
+     */
+    setHNSWThreshold(n: number): void;
+    insert(chunks: EmbeddingChunk[]): Promise<void>;
+    search(query: number[], topK: number): Promise<VectorSearchResult[]>;
+    delete(ids: string[]): Promise<void>;
+    size(): number;
+    save(dirPath: string): Promise<void>;
+    load(dirPath: string): Promise<void>;
+    clear(): Promise<void>;
+    get isHNSWActive(): boolean;
+    private bruteForceSearch;
+    private buildHNSW;
+    private randomLevel;
+    private hnswInsert;
+    private hnswRemove;
+    private hnswSearch;
+    private greedyClosest;
+    private searchLayer;
+    private selectNeighbors;
+    private pruneConnections;
+    private serializeIndex;
+    private deserializeIndex;
+    private getFirstDimensions;
+}
+//# sourceMappingURL=hnsw-store.d.ts.map

package/dist/src/vector/hnsw-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hnsw-store.d.ts","sourceRoot":"","sources":["../../../src/vector/hnsw-store.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AACjD,OAAO,KAAK,EAAE,WAAW,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAA;AAIxE,MAAM,WAAW,gBAAgB;IAC/B,CAAC,CAAC,EAAE,MAAM,CAAA;IACV,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,eAAe,CAAC,EAAE,MAAM,CAAA;CACzB;AA6DD,qBAAa,mBAAoB,YAAW,WAAW;IACrD,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAQ;IAC1B,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAQ;IACvC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAQ;IACjC,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAQ;IACxC,OAAO,CAAC,aAAa,CAAQ;IAG7B,OAAO,CAAC,MAAM,CAAyC;IACvD,OAAO,CAAC,OAAO,CAAmC;IAGlD,OAAO,CAAC,KAAK,CAAmC;IAChD,OAAO,CAAC,UAAU,CAAwB;IAC1C,OAAO,CAAC,QAAQ,CAAI;IACpB,OAAO,CAAC,SAAS,CAAQ;gBAEb,OAAO,GAAE,gBAAqB;IAQ1C;;OAEG;IACH,gBAAgB,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI;IAM3B,MAAM,CAAC,MAAM,EAAE,cAAc,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAqB/C,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,kBAAkB,EAAE,CAAC;IASpE,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAU1C,IAAI,IAAI,MAAM;IAIR,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAiBpC,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAiBpC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAW5B,IAAI,YAAY,IAAI,OAAO,CAE1B;IAID,OAAO,CAAC,gBAAgB;IAexB,OAAO,CAAC,SAAS;IAcjB,OAAO,CAAC,WAAW;IAQnB,OAAO,CAAC,UAAU;IA6DlB,OAAO,CAAC,UAAU;IAoClB,OAAO,CAAC,UAAU;IAyBlB,OAAO,CAAC,aAAa;IAwBrB,OAAO,CAAC,WAAW;IA4DnB,OAAO,CAAC,eAAe;IAWvB,OAAO,CAAC,gBAAgB;IAqBxB,OAAO,CAAC,cAAc;IAsCtB,OAAO,CAAC,gBAAgB;IAgDxB,OAAO,CAAC,kBAAkB;CAM3B"}