@renseiai/agentfactory-code-intelligence 0.8.8 → 0.8.10

package/dist/src/embedding/voyage-provider.js

@@ -0,0 +1,146 @@
+const VOYAGE_API_URL = 'https://api.voyageai.com/v1/embeddings';
+const DEFAULT_MODEL = 'voyage-code-3';
+const DEFAULT_DIMENSIONS = 256;
+const DEFAULT_BATCH_SIZE = 128;
+const DEFAULT_MAX_RETRIES = 3;
+const BASE_RETRY_DELAY_MS = 1000;
+/**
+ * Embedding provider for Voyage AI's voyage-code-3 model.
+ *
+ * Features:
+ * - 32K token context window
+ * - 2048 native dimensions with Matryoshka support (256–2048)
+ * - Batched requests (max 128 texts per API call)
+ * - Exponential backoff retry on 429 / 5xx errors
+ *
+ * Requires the VOYAGE_API_KEY environment variable.
+ */
+export class VoyageCodeProvider {
+    model;
+    dimensions;
+    batchSize;
+    maxRetries;
+    apiKey;
+    constructor(config = {}) {
+        const apiKey = process.env.VOYAGE_API_KEY;
+        if (!apiKey) {
+            throw new Error('VOYAGE_API_KEY environment variable is required. '
+                + 'Get your API key at https://dash.voyageai.com/');
+        }
+        this.apiKey = apiKey;
+        this.model = config.model ?? DEFAULT_MODEL;
+        this.dimensions = config.dimensions ?? DEFAULT_DIMENSIONS;
+        this.batchSize = config.batchSize ?? DEFAULT_BATCH_SIZE;
+        this.maxRetries = config.maxRetries ?? DEFAULT_MAX_RETRIES;
+    }
+    /**
+     * Embed multiple texts in batches.
+     * Returns one vector per input text, in the same order.
+     */
+    async embed(texts) {
+        if (texts.length === 0)
+            return [];
+        const results = new Array(texts.length);
+        const batches = this.splitIntoBatches(texts);
+        let offset = 0;
+        for (const batch of batches) {
+            const embeddings = await this.callAPI(batch, 'document');
+            for (let i = 0; i < embeddings.length; i++) {
+                results[offset + i] = embeddings[i];
+            }
+            offset += batch.length;
+        }
+        return results;
+    }
+    /**
+     * Embed a single query text.
+     * Uses input_type "query" for asymmetric retrieval.
+     */
+    async embedQuery(text) {
+        const [result] = await this.callAPI([text], 'query');
+        return result;
+    }
+    /** Split texts into batches of at most batchSize. */
+    splitIntoBatches(texts) {
+        const batches = [];
+        for (let i = 0; i < texts.length; i += this.batchSize) {
+            batches.push(texts.slice(i, i + this.batchSize));
+        }
+        return batches;
+    }
+    /** Call the Voyage embeddings API with retry logic. */
+    async callAPI(texts, inputType) {
+        const body = JSON.stringify({
+            model: this.model,
+            input: texts,
+            input_type: inputType,
+            output_dimension: this.dimensions,
+        });
+        let lastError;
+        for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+            try {
+                const response = await fetch(VOYAGE_API_URL, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'Authorization': `Bearer ${this.apiKey}`,
+                    },
+                    body,
+                });
+                if (response.ok) {
+                    const json = (await response.json());
+                    // Sort by index to preserve input order
+                    const sorted = json.data.sort((a, b) => a.index - b.index);
+                    return sorted.map((d) => d.embedding);
+                }
+                // Retry on rate limit or server errors
+                if (response.status === 429 || response.status >= 500) {
+                    const errorBody = await response.text();
+                    lastError = new Error(`Voyage API returned ${response.status}: ${errorBody}`);
+                    if (attempt < this.maxRetries) {
+                        await this.sleep(this.getRetryDelay(attempt, response));
+                        continue;
+                    }
+                }
+                else {
+                    // Non-retryable error
+                    const errorBody = await response.text();
+                    let message;
+                    try {
+                        const parsed = JSON.parse(errorBody);
+                        message = parsed.detail ?? parsed.message ?? errorBody;
+                    }
+                    catch {
+                        message = errorBody;
+                    }
+                    throw new Error(`Voyage API error (${response.status}): ${message}`);
+                }
+            }
+            catch (error) {
+                if (error instanceof Error && error.message.startsWith('Voyage API error')) {
+                    throw error;
+                }
+                lastError = error instanceof Error ? error : new Error(String(error));
+                if (attempt < this.maxRetries) {
+                    await this.sleep(BASE_RETRY_DELAY_MS * Math.pow(2, attempt));
+                    continue;
+                }
+            }
+        }
+        throw lastError ?? new Error('Voyage API request failed after retries');
+    }
+    /** Calculate retry delay with exponential backoff, respecting Retry-After header. */
+    getRetryDelay(attempt, response) {
+        const retryAfter = response.headers.get('retry-after');
+        if (retryAfter) {
+            const seconds = Number(retryAfter);
+            if (!Number.isNaN(seconds)) {
+                return seconds * 1000;
+            }
+        }
+        return BASE_RETRY_DELAY_MS * Math.pow(2, attempt);
+    }
+    sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+}

package/dist/src/index.d.ts

@@ -1,5 +1,5 @@
-export { SymbolKindSchema, CodeSymbolSchema, FileASTSchema, FileIndexSchema, SearchQuerySchema, SearchResultSchema, MemoryEntrySchema, DedupResultSchema, IndexMetadataSchema, RepoMapEntrySchema, } from './types.js';
-export type { SymbolKind, CodeSymbol, FileAST, FileIndex, SearchQuery, SearchResult, MemoryEntry, DedupResult, IndexMetadata, RepoMapEntry, } from './types.js';
+export { SymbolKindSchema, CodeSymbolSchema, FileASTSchema, FileIndexSchema, SearchQuerySchema, SearchResultSchema, MemoryEntrySchema, DedupResultSchema, IndexMetadataSchema, RepoMapEntrySchema, EmbeddingChunkSchema, EmbeddingProviderConfigSchema, VectorSearchResultSchema, VectorIndexConfigSchema, } from './types.js';
+export type { SymbolKind, CodeSymbol, FileAST, FileIndex, SearchQuery, SearchResult, MemoryEntry, DedupResult, IndexMetadata, RepoMapEntry, EmbeddingChunk, EmbeddingProviderConfig, VectorSearchResult, VectorIndexConfig, } from './types.js';
 export { SymbolExtractor } from './parser/symbol-extractor.js';
 export type { LanguageExtractor } from './parser/symbol-extractor.js';
 export { TypeScriptExtractor } from './parser/typescript-extractor.js';
@@ -10,10 +10,14 @@ export { MerkleTree, type MerkleNode } from './indexing/merkle-tree.js';
 export { GitHashProvider } from './indexing/git-hash-provider.js';
 export { ChangeDetector } from './indexing/change-detector.js';
 export { IncrementalIndexer } from './indexing/incremental-indexer.js';
+export { VectorIndexer } from './indexing/vector-indexer.js';
 export { CodeTokenizer } from './search/tokenizer.js';
 export { InvertedIndex } from './search/inverted-index.js';
 export { BM25 } from './search/bm25.js';
 export { SearchEngine } from './search/search-engine.js';
+export { HybridSearchEngine } from './search/hybrid-search.js';
+export { classifyQuery } from './search/query-classifier.js';
+export { minMaxNormalize } from './search/score-normalizer.js';
 export { DependencyGraph } from './repo-map/dependency-graph.js';
 export { PageRank } from './repo-map/pagerank.js';
 export { RepoMapGenerator } from './repo-map/repo-map-generator.js';
@@ -22,5 +26,13 @@ export { SimHash } from './memory/simhash.js';
 export { DedupPipeline } from './memory/dedup-pipeline.js';
 export type { MemoryStore } from './memory/memory-store.js';
 export { InMemoryStore } from './memory/memory-store.js';
+export type { EmbeddingProvider } from './embedding/embedding-provider.js';
+export { VoyageCodeProvider } from './embedding/voyage-provider.js';
+export { Chunker } from './embedding/chunker.js';
+export type { VectorStore } from './vector/vector-store.js';
+export { InMemoryVectorStore } from './vector/hnsw-store.js';
+export type { RerankerProvider, RerankDocument, RerankResult, RerankerConfig } from './reranking/reranker-provider.js';
+export { CohereReranker } from './reranking/cohere-reranker.js';
+export { VoyageReranker } from './reranking/voyage-reranker.js';
 export { codeIntelligencePlugin } from './plugin/code-intelligence-plugin.js';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EACL,gBAAgB,EAChB,gBAAgB,EAChB,aAAa,EACb,eAAe,EACf,iBAAiB,EACjB,kBAAkB,EAClB,iBAAiB,EACjB,iBAAiB,EACjB,mBAAmB,EACnB,kBAAkB,GACnB,MAAM,YAAY,CAAA;AACnB,YAAY,EACV,UAAU,EACV,UAAU,EACV,OAAO,EACP,SAAS,EACT,WAAW,EACX,YAAY,EACZ,WAAW,EACX,WAAW,EACX,aAAa,EACb,YAAY,GACb,MAAM,YAAY,CAAA;AAGnB,OAAO,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAA;AAC9D,YAAY,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAA;AACrE,OAAO,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAA;AACtE,OAAO,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAA;AAC9D,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAA;AACtD,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAG1D,OAAO,EAAE,UAAU,EAAE,KAAK,UAAU,EAAE,MAAM,2BAA2B,CAAA;AACvE,OAAO,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAA;AACjE,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAC9D,OAAO,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAA;AAGtE,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAA;AACrD,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAC1D,OAAO,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAA;AACvC,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAA;AAGxD,OAAO,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAA;AAChE,OAAO,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAA;AACjD,OAAO,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAA;AAGnE,OAAO,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAA;AAC7C,OAAO,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAC7C,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAC1D,YAAY,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAA;AAC3D,OAAO,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAA;AAGxD,OAAO,EAAE,sBAAsB,EAAE,MAAM,sCAAsC,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EACL,gBAAgB,EAChB,gBAAgB,EAChB,aAAa,EACb,eAAe,EACf,iBAAiB,EACjB,kBAAkB,EAClB,iBAAiB,EACjB,iBAAiB,EACjB,mBAAmB,EACnB,kBAAkB,EAClB,oBAAoB,EACpB,6BAA6B,EAC7B,wBAAwB,EACxB,uBAAuB,GACxB,MAAM,YAAY,CAAA;AACnB,YAAY,EACV,UAAU,EACV,UAAU,EACV,OAAO,EACP,SAAS,EACT,WAAW,EACX,YAAY,EACZ,WAAW,EACX,WAAW,EACX,aAAa,EACb,YAAY,EACZ,cAAc,EACd,uBAAuB,EACvB,kBAAkB,EAClB,iBAAiB,GAClB,MAAM,YAAY,CAAA;AAGnB,OAAO,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAA;AAC9D,YAAY,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAA;AACrE,OAAO,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAA;AACtE,OAAO,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAA;AAC9D,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAA;AACtD,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAG1D,OAAO,EAAE,UAAU,EAAE,KAAK,UAAU,EAAE,MAAM,2BAA2B,CAAA;AACvE,OAAO,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAA;AACjE,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAC9D,OAAO,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAA;AACtE,OAAO,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAA;AAG5D,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAA;AACrD,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAC1D,OAAO,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAA;AACvC,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAA;AACxD,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAA;AAC9D,OAAO,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAA;AAC5D,OAAO,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAA;AAG9D,OAAO,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAA;AAChE,OAAO,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAA;AACjD,OAAO,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAA;AAGnE,OAAO,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAA;AAC7C,OAAO,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAC7C,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAC1D,YAAY,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAA;AAC3D,OAAO,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAA;AAGxD,YAAY,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAA;AAC1E,OAAO,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAA;AACnE,OAAO,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAA;AAGhD,YAAY,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAA;AAC3D,OAAO,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAA;AAG5D,YAAY,EAAE,gBAAgB,EAAE,cAAc,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAA;AACtH,OAAO,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAA;AAC/D,OAAO,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAA;AAG/D,OAAO,EAAE,sBAAsB,EAAE,MAAM,sCAAsC,CAAA"}

package/dist/src/index.js

@@ -1,5 +1,5 @@
 // Core types and schemas
-export { SymbolKindSchema, CodeSymbolSchema, FileASTSchema, FileIndexSchema, SearchQuerySchema, SearchResultSchema, MemoryEntrySchema, DedupResultSchema, IndexMetadataSchema, RepoMapEntrySchema, } from './types.js';
+export { SymbolKindSchema, CodeSymbolSchema, FileASTSchema, FileIndexSchema, SearchQuerySchema, SearchResultSchema, MemoryEntrySchema, DedupResultSchema, IndexMetadataSchema, RepoMapEntrySchema, EmbeddingChunkSchema, EmbeddingProviderConfigSchema, VectorSearchResultSchema, VectorIndexConfigSchema, } from './types.js';
 // Parser
 export { SymbolExtractor } from './parser/symbol-extractor.js';
 export { TypeScriptExtractor } from './parser/typescript-extractor.js';
@@ -11,11 +11,15 @@ export { MerkleTree } from './indexing/merkle-tree.js';
 export { GitHashProvider } from './indexing/git-hash-provider.js';
 export { ChangeDetector } from './indexing/change-detector.js';
 export { IncrementalIndexer } from './indexing/incremental-indexer.js';
+export { VectorIndexer } from './indexing/vector-indexer.js';
 // Search
 export { CodeTokenizer } from './search/tokenizer.js';
 export { InvertedIndex } from './search/inverted-index.js';
 export { BM25 } from './search/bm25.js';
 export { SearchEngine } from './search/search-engine.js';
+export { HybridSearchEngine } from './search/hybrid-search.js';
+export { classifyQuery } from './search/query-classifier.js';
+export { minMaxNormalize } from './search/score-normalizer.js';
 // Repo Map
 export { DependencyGraph } from './repo-map/dependency-graph.js';
 export { PageRank } from './repo-map/pagerank.js';
@@ -25,5 +29,10 @@ export { xxhash64 } from './memory/xxhash.js';
 export { SimHash } from './memory/simhash.js';
 export { DedupPipeline } from './memory/dedup-pipeline.js';
 export { InMemoryStore } from './memory/memory-store.js';
+export { VoyageCodeProvider } from './embedding/voyage-provider.js';
+export { Chunker } from './embedding/chunker.js';
+export { InMemoryVectorStore } from './vector/hnsw-store.js';
+export { CohereReranker } from './reranking/cohere-reranker.js';
+export { VoyageReranker } from './reranking/voyage-reranker.js';
 // Plugin
 export { codeIntelligencePlugin } from './plugin/code-intelligence-plugin.js';

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

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

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

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

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

@@ -0,0 +1,291 @@
+import { describe, it, expect, vi } from 'vitest';
+import { VectorIndexer } from '../vector-indexer.js';
+import { IncrementalIndexer } from '../incremental-indexer.js';
+import { SymbolExtractor } from '../../parser/symbol-extractor.js';
+import { InMemoryVectorStore } from '../../vector/hnsw-store.js';
+// ── Helpers ──────────────────────────────────────────────────────────
+const mockProvider = {
+    model: 'mock-model',
+    dimensions: 4,
+    async embed(texts) {
+        return texts.map(t => [t.length / 100, 0.5, 0.3, 0.1]);
+    },
+    async embedQuery(text) {
+        return [text.length / 100, 0.5, 0.3, 0.1];
+    },
+};
+function makeSymbol(name, kind, filePath, extra) {
+    return {
+        name,
+        kind: kind,
+        filePath,
+        line: 0,
+        exported: true,
+        ...extra,
+    };
+}
+function makeFileAST(filePath, language, symbols) {
+    return { filePath, language, symbols, imports: [], exports: [] };
+}
+// ── VectorIndexer ────────────────────────────────────────────────────
+describe('VectorIndexer', () => {
+    it('indexes files: chunks, embeds, and inserts into store', async () => {
+        const store = new InMemoryVectorStore();
+        const indexer = new VectorIndexer({
+            enabled: true,
+            embeddingProvider: mockProvider,
+            vectorStore: store,
+        });
+        const asts = [
+            makeFileAST('src/utils.ts', 'typescript', [
+                makeSymbol('add', 'function', 'src/utils.ts', {
+                    line: 0,
+                    endLine: 3,
+                    signature: 'function add(a: number, b: number): number',
+                }),
+                makeSymbol('subtract', 'function', 'src/utils.ts', {
+                    line: 5,
+                    endLine: 8,
+                    signature: 'function subtract(a: number, b: number): number',
+                }),
+            ]),
+        ];
+        const fileContents = new Map([
+            ['src/utils.ts', 'function add(a: number, b: number): number {\n  return a + b\n}\n\nfunction subtract(a: number, b: number): number {\n  return a - b\n}\n'],
+        ]);
+        const result = await indexer.indexFiles(asts, fileContents);
+        expect(result.chunked).toBe(2);
+        expect(result.embedded).toBe(2);
+        expect(store.size()).toBe(2);
+    });
+    it('handles disabled config (no-ops)', async () => {
+        const store = new InMemoryVectorStore();
+        const indexer = new VectorIndexer({
+            enabled: false,
+            embeddingProvider: mockProvider,
+            vectorStore: store,
+        });
+        const asts = [
+            makeFileAST('src/utils.ts', 'typescript', [
+                makeSymbol('add', 'function', 'src/utils.ts', { line: 0, endLine: 3 }),
+            ]),
+        ];
+        const fileContents = new Map([['src/utils.ts', 'function add() { return 1 }']]);
+        const indexResult = await indexer.indexFiles(asts, fileContents);
+        expect(indexResult.chunked).toBe(0);
+        expect(indexResult.embedded).toBe(0);
+        expect(store.size()).toBe(0);
+        // removeFiles is also a no-op
+        await indexer.removeFiles(['src/utils.ts']);
+        expect(store.size()).toBe(0);
+        // updateFiles is also a no-op
+        const updateResult = await indexer.updateFiles(asts, fileContents);
+        expect(updateResult.added).toBe(0);
+        expect(updateResult.removed).toBe(0);
+        expect(updateResult.unchanged).toBe(0);
+    });
+    it('removes files by path', async () => {
+        const store = new InMemoryVectorStore();
+        const indexer = new VectorIndexer({
+            enabled: true,
+            embeddingProvider: mockProvider,
+            vectorStore: store,
+        });
+        // Index two files
+        const asts = [
+            makeFileAST('src/a.ts', 'typescript', [
+                makeSymbol('foo', 'function', 'src/a.ts', { line: 0, endLine: 2 }),
+            ]),
+            makeFileAST('src/b.ts', 'typescript', [
+                makeSymbol('bar', 'function', 'src/b.ts', { line: 0, endLine: 2 }),
+            ]),
+        ];
+        const fileContents = new Map([
+            ['src/a.ts', 'function foo() {}\n'],
+            ['src/b.ts', 'function bar() {}\n'],
+        ]);
+        await indexer.indexFiles(asts, fileContents);
+        expect(store.size()).toBe(2);
+        // Remove one file
+        await indexer.removeFiles(['src/a.ts']);
+        expect(store.size()).toBe(1);
+    });
+    it('updates modified files (only re-embeds changed chunks)', async () => {
+        const store = new InMemoryVectorStore();
+        const embedSpy = vi.fn(mockProvider.embed.bind(mockProvider));
+        const spyProvider = {
+            ...mockProvider,
+            embed: embedSpy,
+        };
+        const indexer = new VectorIndexer({
+            enabled: true,
+            embeddingProvider: spyProvider,
+            vectorStore: store,
+            batchSize: 128,
+        });
+        // Initial index with two symbols
+        const initialAsts = [
+            makeFileAST('src/math.ts', 'typescript', [
+                makeSymbol('add', 'function', 'src/math.ts', {
+                    line: 0,
+                    endLine: 2,
+                    signature: 'function add(a: number, b: number): number',
+                }),
+                makeSymbol('multiply', 'function', 'src/math.ts', {
+                    line: 4,
+                    endLine: 6,
+                    signature: 'function multiply(a: number, b: number): number',
+                }),
+            ]),
+        ];
+        const initialContents = new Map([
+            ['src/math.ts', 'function add(a: number, b: number): number {\n  return a + b\n}\n\nfunction multiply(a: number, b: number): number {\n  return a * b\n}\n'],
+        ]);
+        await indexer.indexFiles(initialAsts, initialContents);
+        expect(store.size()).toBe(2);
+        const initialEmbedCalls = embedSpy.mock.calls.length;
+        // Update: only change `add`, keep `multiply` the same
+        const updatedAsts = [
+            makeFileAST('src/math.ts', 'typescript', [
+                makeSymbol('add', 'function', 'src/math.ts', {
+                    line: 0,
+                    endLine: 3,
+                    signature: 'function add(a: number, b: number): number',
+                }),
+                makeSymbol('multiply', 'function', 'src/math.ts', {
+                    line: 5,
+                    endLine: 7,
+                    signature: 'function multiply(a: number, b: number): number',
+                }),
+            ]),
+        ];
+        const updatedContents = new Map([
+            ['src/math.ts', 'function add(a: number, b: number): number {\n  // Enhanced add\n  return a + b\n}\n\nfunction multiply(a: number, b: number): number {\n  return a * b\n}\n'],
+        ]);
+        const result = await indexer.updateFiles(updatedAsts, updatedContents);
+        // `add` content changed, `multiply` content unchanged
+        expect(result.unchanged).toBeGreaterThanOrEqual(0); // multiply may or may not have changed depending on chunk IDs
+        expect(result.added).toBeGreaterThanOrEqual(1); // at least `add` was re-embedded
+        expect(store.size()).toBe(2);
+    });
+    it('emits progress events', async () => {
+        const store = new InMemoryVectorStore();
+        const indexer = new VectorIndexer({
+            enabled: true,
+            embeddingProvider: mockProvider,
+            vectorStore: store,
+        });
+        const asts = [
+            makeFileAST('src/a.ts', 'typescript', [
+                makeSymbol('foo', 'function', 'src/a.ts', { line: 0, endLine: 2 }),
+            ]),
+        ];
+        const fileContents = new Map([['src/a.ts', 'function foo() { return 1 }']]);
+        const progress = [];
+        await indexer.indexFiles(asts, fileContents, (p) => {
+            progress.push({ ...p });
+        });
+        // Should have progress events for chunking, embedding, and indexing phases
+        const phases = progress.map(p => p.phase);
+        expect(phases).toContain('chunking');
+        expect(phases).toContain('embedding');
+        expect(phases).toContain('indexing');
+    });
+    it('handles batch splitting', async () => {
+        const store = new InMemoryVectorStore();
+        const embedSpy = vi.fn(mockProvider.embed.bind(mockProvider));
+        const spyProvider = {
+            ...mockProvider,
+            embed: embedSpy,
+        };
+        const indexer = new VectorIndexer({
+            enabled: true,
+            embeddingProvider: spyProvider,
+            vectorStore: store,
+            batchSize: 2, // Small batch to test splitting
+            maxConcurrentBatches: 1,
+        });
+        // Create 5 symbols => 5 chunks => should be split into 3 batches (2+2+1)
+        const symbols = Array.from({ length: 5 }, (_, i) => makeSymbol(`fn${i}`, 'function', 'src/many.ts', { line: i * 3, endLine: i * 3 + 2 }));
+        const asts = [
+            makeFileAST('src/many.ts', 'typescript', symbols),
+        ];
+        const lines = Array.from({ length: 15 }, (_, i) => `line ${i}`);
+        const fileContents = new Map([['src/many.ts', lines.join('\n')]]);
+        await indexer.indexFiles(asts, fileContents);
+        // 5 chunks / batchSize 2 = 3 embed calls
+        expect(embedSpy).toHaveBeenCalledTimes(3);
+        expect(store.size()).toBe(5);
+    });
+});
+// ── IncrementalIndexer + VectorIndexer Integration ───────────────────
+describe('IncrementalIndexer with VectorIndexer', () => {
+    it('added files get vector-indexed', async () => {
+        const extractor = new SymbolExtractor();
+        const store = new InMemoryVectorStore();
+        const vectorIndexer = new VectorIndexer({
+            enabled: true,
+            embeddingProvider: mockProvider,
+            vectorStore: store,
+        });
+        const indexer = new IncrementalIndexer(extractor);
+        indexer.setVectorIndexer(vectorIndexer);
+        const files = new Map([
+            ['src/main.ts', 'export function main() { return 1 }'],
+            ['src/utils.ts', 'export function helper() { return 42 }'],
+        ]);
+        const result = await indexer.index(files);
+        expect(result.changes.added).toHaveLength(2);
+        // Vector store should have chunks for the added files
+        expect(store.size()).toBeGreaterThan(0);
+    });
+    it('deleted files get removed from vector store', async () => {
+        const extractor = new SymbolExtractor();
+        const store = new InMemoryVectorStore();
+        const vectorIndexer = new VectorIndexer({
+            enabled: true,
+            embeddingProvider: mockProvider,
+            vectorStore: store,
+        });
+        const indexer = new IncrementalIndexer(extractor);
+        indexer.setVectorIndexer(vectorIndexer);
+        // First index: two files
+        const files1 = new Map([
+            ['src/a.ts', 'export function foo() { return 1 }'],
+            ['src/b.ts', 'export function bar() { return 2 }'],
+        ]);
+        await indexer.index(files1);
+        const sizeAfterFirstIndex = store.size();
+        expect(sizeAfterFirstIndex).toBeGreaterThan(0);
+        // Second index: remove src/b.ts
+        const files2 = new Map([
+            ['src/a.ts', 'export function foo() { return 1 }'],
+        ]);
+        const result = await indexer.index(files2);
+        expect(result.changes.deleted).toEqual(['src/b.ts']);
+        // Store should have fewer chunks
+        expect(store.size()).toBeLessThan(sizeAfterFirstIndex);
+    });
+    it('works exactly as before without vector indexer', async () => {
+        const extractor = new SymbolExtractor();
+        const indexer = new IncrementalIndexer(extractor);
+        // No setVectorIndexer call — should work fine
+        const files = new Map([
+            ['src/main.ts', 'export function main() {}'],
+            ['src/utils.ts', 'export const helper = () => 42'],
+        ]);
+        const result = await indexer.index(files);
+        expect(result.changes.added).toHaveLength(2);
+        expect(result.changes.modified).toHaveLength(0);
+        expect(result.indexed).toHaveLength(2);
+        expect(result.metadata.totalFiles).toBe(2);
+        // Second pass with modification
+        const files2 = new Map([
+            ['src/main.ts', 'export function main() {}'],
+            ['src/utils.ts', 'export const helper = () => 99'],
+        ]);
+        const result2 = await indexer.index(files2);
+        expect(result2.changes.modified).toEqual(['src/utils.ts']);
+        expect(result2.indexed).toHaveLength(1);
+    });
+});

package/dist/src/indexing/incremental-indexer.d.ts

@@ -1,6 +1,7 @@
 import type { FileIndex, IndexMetadata, CodeSymbol } from '../types.js';
 import { type ChangeSet } from './change-detector.js';
 import { SymbolExtractor } from '../parser/symbol-extractor.js';
+import type { VectorIndexer } from './vector-indexer.js';
 export interface IndexerOptions {
     indexDir?: string;
     filePatterns?: string[];
@@ -16,7 +17,10 @@ export declare class IncrementalIndexer {
     private indexDir;
     private previousTree;
     private fileIndex;
+    private vectorIndexer;
     constructor(extractor: SymbolExtractor, options?: IndexerOptions);
+    /** Set an optional VectorIndexer for dense vector indexing. */
+    setVectorIndexer(indexer: VectorIndexer): void;
     /**
      * Index files, returning only the changed ones.
      * @param files Map of filePath -> content

package/dist/src/indexing/incremental-indexer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"incremental-indexer.d.ts","sourceRoot":"","sources":["../../../src/indexing/incremental-indexer.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAEvE,OAAO,EAAkB,KAAK,SAAS,EAAE,MAAM,sBAAsB,CAAA;AAErE,OAAO,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAA;AAE/D,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,YAAY,CAAC,EAAE,MAAM,EAAE,CAAA;CACxB;AAED;;;GAGG;AACH,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,YAAY,CAAwB;IAC5C,OAAO,CAAC,cAAc,CAAuB;IAC7C,OAAO,CAAC,SAAS,CAAiB;IAClC,OAAO,CAAC,QAAQ,CAAQ;IACxB,OAAO,CAAC,YAAY,CAAwB;IAC5C,OAAO,CAAC,SAAS,CAAoC;gBAEzC,SAAS,EAAE,eAAe,EAAE,OAAO,GAAE,cAAmB;IAKpE;;;OAGG;IACG,KAAK,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC;QAC/C,OAAO,EAAE,SAAS,CAAA;QAClB,OAAO,EAAE,SAAS,EAAE,CAAA;QACpB,QAAQ,EAAE,aAAa,CAAA;KACxB,CAAC;IA+DF,0BAA0B;IACpB,IAAI,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAW3C,4BAA4B;IACtB,IAAI,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAmB9C,+BAA+B;IAC/B,aAAa,IAAI,UAAU,EAAE;IAQ7B,kCAAkC;IAClC,YAAY,IAAI,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC;CAGvC"}
+{"version":3,"file":"incremental-indexer.d.ts","sourceRoot":"","sources":["../../../src/indexing/incremental-indexer.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,aAAa,EAAE,UAAU,EAAW,MAAM,aAAa,CAAA;AAEhF,OAAO,EAAkB,KAAK,SAAS,EAAE,MAAM,sBAAsB,CAAA;AAErE,OAAO,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAA;AAC/D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAA;AAExD,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,YAAY,CAAC,EAAE,MAAM,EAAE,CAAA;CACxB;AAED;;;GAGG;AACH,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,YAAY,CAAwB;IAC5C,OAAO,CAAC,cAAc,CAAuB;IAC7C,OAAO,CAAC,SAAS,CAAiB;IAClC,OAAO,CAAC,QAAQ,CAAQ;IACxB,OAAO,CAAC,YAAY,CAAwB;IAC5C,OAAO,CAAC,SAAS,CAAoC;IACrD,OAAO,CAAC,aAAa,CAA2B;gBAEpC,SAAS,EAAE,eAAe,EAAE,OAAO,GAAE,cAAmB;IAKpE,+DAA+D;IAC/D,gBAAgB,CAAC,OAAO,EAAE,aAAa,GAAG,IAAI;IAI9C;;;OAGG;IACG,KAAK,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC;QAC/C,OAAO,EAAE,SAAS,CAAA;QAClB,OAAO,EAAE,SAAS,EAAE,CAAA;QACpB,QAAQ,EAAE,aAAa,CAAA;KACxB,CAAC;IA0FF,0BAA0B;IACpB,IAAI,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAiB3C,4BAA4B;IACtB,IAAI,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IA8B9C,+BAA+B;IAC/B,aAAa,IAAI,UAAU,EAAE;IAQ7B,kCAAkC;IAClC,YAAY,IAAI,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC;CAGvC"}

package/dist/src/indexing/incremental-indexer.js

@@ -14,10 +14,15 @@ export class IncrementalIndexer {
     indexDir;
     previousTree;
     fileIndex = new Map();
+    vectorIndexer;
     constructor(extractor, options = {}) {
         this.extractor = extractor;
         this.indexDir = options.indexDir ?? '.agentfactory/code-index';
     }
+    /** Set an optional VectorIndexer for dense vector indexing. */
+    setVectorIndexer(indexer) {
+        this.vectorIndexer = indexer;
+    }
     /**
      * Index files, returning only the changed ones.
      * @param files Map of filePath -> content
@@ -41,6 +46,10 @@ export class IncrementalIndexer {
         }
         // Index added and modified files
         const indexed = [];
+        const addedAsts = [];
+        const addedContents = new Map();
+        const modifiedAsts = [];
+        const modifiedContents = new Map();
         const toIndex = [...changes.added, ...changes.modified];
         for (const path of toIndex) {
             const content = files.get(path);
@@ -56,6 +65,27 @@ export class IncrementalIndexer {
             };
             this.fileIndex.set(path, fileIdx);
             indexed.push(fileIdx);
+            // Collect ASTs/contents for vector indexing
+            if (changes.added.includes(path)) {
+                addedAsts.push(ast);
+                addedContents.set(path, content);
+            }
+            else {
+                modifiedAsts.push(ast);
+                modifiedContents.set(path, content);
+            }
+        }
+        // Vector indexing (optional)
+        if (this.vectorIndexer) {
+            if (changes.deleted.length > 0) {
+                await this.vectorIndexer.removeFiles(changes.deleted);
+            }
+            if (addedAsts.length > 0) {
+                await this.vectorIndexer.indexFiles(addedAsts, addedContents);
+            }
+            if (modifiedAsts.length > 0) {
+                await this.vectorIndexer.updateFiles(modifiedAsts, modifiedContents);
+            }
         }
         this.previousTree = newTree;
         // Collect all symbols for metadata
@@ -87,6 +117,11 @@ export class IncrementalIndexer {
             rootHash: this.previousTree?.getRootHash() ?? '',
         };
         await writeFile(join(dir, 'index.json'), JSON.stringify(data, null, 2));
+        // Save vector store if available
+        if (this.vectorIndexer) {
+            const vectorDir = join(dir, 'vectors');
+            await this.vectorIndexer.getStore().save(vectorDir);
+        }
     }
     /** Load index from disk. */
     async load(basePath) {
@@ -101,6 +136,16 @@ export class IncrementalIndexer {
                 fileHashes.set(path, fi.gitHash);
             }
             this.previousTree = MerkleTree.fromHashes(fileHashes);
+            // Load vector store if available
+            if (this.vectorIndexer) {
+                const vectorDir = join(basePath, this.indexDir, 'vectors');
+                try {
+                    await this.vectorIndexer.getStore().load(vectorDir);
+                }
+                catch {
+                    // Vector store may not exist yet — that's fine
+                }
+            }
             return true;
         }
         catch {