@renseiai/agentfactory-code-intelligence 0.8.8 → 0.8.10

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

@@ -0,0 +1,63 @@
+import type { EmbeddingProvider } from '../embedding/embedding-provider.js';
+import type { VectorStore } from '../vector/vector-store.js';
+import type { FileAST } from '../types.js';
+export interface VectorIndexConfig {
+    enabled: boolean;
+    embeddingProvider: EmbeddingProvider;
+    vectorStore: VectorStore;
+    batchSize?: number;
+    maxConcurrentBatches?: number;
+}
+export interface VectorIndexProgress {
+    phase: 'chunking' | 'embedding' | 'indexing';
+    processed: number;
+    total: number;
+}
+/**
+ * Orchestrates the chunk -> embed -> store flow for dense vector indexing.
+ *
+ * Integrates with the EmbeddingProvider and VectorStore interfaces to
+ * compute embeddings for code chunks and maintain a searchable vector index.
+ */
+export declare class VectorIndexer {
+    private readonly enabled;
+    private readonly provider;
+    private readonly store;
+    private readonly batchSize;
+    private readonly maxConcurrentBatches;
+    private readonly chunker;
+    /** Tracks content hashes for previously indexed chunks (id -> hash). */
+    private chunkHashes;
+    constructor(config: VectorIndexConfig);
+    /**
+     * Index new/modified files: chunk -> embed -> insert into vector store.
+     */
+    indexFiles(asts: FileAST[], fileContents: Map<string, string>, onProgress?: (progress: VectorIndexProgress) => void): Promise<{
+        chunked: number;
+        embedded: number;
+    }>;
+    /**
+     * Remove all chunks for given file paths from vector store.
+     * Chunk IDs start with filePath, so we filter by prefix.
+     */
+    removeFiles(filePaths: string[]): Promise<void>;
+    /**
+     * Update chunks for modified files (delete old, insert new) with content-hash diffing.
+     * Only re-embeds chunks whose content actually changed.
+     */
+    updateFiles(asts: FileAST[], fileContents: Map<string, string>, onProgress?: (progress: VectorIndexProgress) => void): Promise<{
+        added: number;
+        removed: number;
+        unchanged: number;
+    }>;
+    /**
+     * Get the underlying vector store (for save/load operations).
+     */
+    getStore(): VectorStore;
+    /**
+     * Embed chunks in batches with controlled concurrency.
+     * Assigns embeddings back to the chunk objects in-place.
+     */
+    private embedChunks;
+}
+//# sourceMappingURL=vector-indexer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"vector-indexer.d.ts","sourceRoot":"","sources":["../../../src/indexing/vector-indexer.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oCAAoC,CAAA;AAC3E,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAA;AAE5D,OAAO,KAAK,EAAE,OAAO,EAAkB,MAAM,aAAa,CAAA;AAI1D,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,OAAO,CAAA;IAChB,iBAAiB,EAAE,iBAAiB,CAAA;IACpC,WAAW,EAAE,WAAW,CAAA;IACxB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,oBAAoB,CAAC,EAAE,MAAM,CAAA;CAC9B;AAID,MAAM,WAAW,mBAAmB;IAClC,KAAK,EAAE,UAAU,GAAG,WAAW,GAAG,UAAU,CAAA;IAC5C,SAAS,EAAE,MAAM,CAAA;IACjB,KAAK,EAAE,MAAM,CAAA;CACd;AAUD;;;;;GAKG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAmB;IAC5C,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAa;IACnC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAQ;IAClC,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAAQ;IAC7C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IAEjC,wEAAwE;IACxE,OAAO,CAAC,WAAW,CAAiC;gBAExC,MAAM,EAAE,iBAAiB;IASrC;;OAEG;IACG,UAAU,CACd,IAAI,EAAE,OAAO,EAAE,EACf,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EACjC,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE,mBAAmB,KAAK,IAAI,GACnD,OAAO,CAAC;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC;IA2BjD;;;OAGG;IACG,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAqBrD;;;OAGG;IACG,WAAW,CACf,IAAI,EAAE,OAAO,EAAE,EACf,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EACjC,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE,mBAAmB,KAAK,IAAI,GACnD,OAAO,CAAC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC;IAuFjE;;OAEG;IACH,QAAQ,IAAI,WAAW;IAMvB;;;OAGG;YACW,WAAW;CAsC1B"}

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

@@ -0,0 +1,197 @@
+import { createHash } from 'node:crypto';
+import { Chunker } from '../embedding/chunker.js';
+// ── Content Hashing ──────────────────────────────────────────────────
+function contentHash(text) {
+    return createHash('sha256').update(text).digest('hex').slice(0, 16);
+}
+// ── VectorIndexer ────────────────────────────────────────────────────
+/**
+ * Orchestrates the chunk -> embed -> store flow for dense vector indexing.
+ *
+ * Integrates with the EmbeddingProvider and VectorStore interfaces to
+ * compute embeddings for code chunks and maintain a searchable vector index.
+ */
+export class VectorIndexer {
+    enabled;
+    provider;
+    store;
+    batchSize;
+    maxConcurrentBatches;
+    chunker;
+    /** Tracks content hashes for previously indexed chunks (id -> hash). */
+    chunkHashes = new Map();
+    constructor(config) {
+        this.enabled = config.enabled;
+        this.provider = config.embeddingProvider;
+        this.store = config.vectorStore;
+        this.batchSize = config.batchSize ?? 128;
+        this.maxConcurrentBatches = config.maxConcurrentBatches ?? 2;
+        this.chunker = new Chunker();
+    }
+    /**
+     * Index new/modified files: chunk -> embed -> insert into vector store.
+     */
+    async indexFiles(asts, fileContents, onProgress) {
+        if (!this.enabled)
+            return { chunked: 0, embedded: 0 };
+        // Phase 1: Chunking
+        onProgress?.({ phase: 'chunking', processed: 0, total: asts.length });
+        const chunks = this.chunker.chunkFiles(asts, fileContents);
+        onProgress?.({ phase: 'chunking', processed: asts.length, total: asts.length });
+        if (chunks.length === 0)
+            return { chunked: 0, embedded: 0 };
+        // Phase 2: Embedding (batch)
+        await this.embedChunks(chunks, onProgress);
+        // Phase 3: Indexing (insert into store)
+        onProgress?.({ phase: 'indexing', processed: 0, total: chunks.length });
+        await this.store.insert(chunks);
+        // Track content hashes for future diffing
+        for (const chunk of chunks) {
+            this.chunkHashes.set(chunk.id, contentHash(chunk.content));
+        }
+        onProgress?.({ phase: 'indexing', processed: chunks.length, total: chunks.length });
+        return { chunked: chunks.length, embedded: chunks.length };
+    }
+    /**
+     * Remove all chunks for given file paths from vector store.
+     * Chunk IDs start with filePath, so we filter by prefix.
+     */
+    async removeFiles(filePaths) {
+        if (!this.enabled)
+            return;
+        const idsToDelete = [];
+        for (const [id] of this.chunkHashes) {
+            for (const filePath of filePaths) {
+                if (id.startsWith(filePath + ':')) {
+                    idsToDelete.push(id);
+                    break;
+                }
+            }
+        }
+        if (idsToDelete.length > 0) {
+            await this.store.delete(idsToDelete);
+            for (const id of idsToDelete) {
+                this.chunkHashes.delete(id);
+            }
+        }
+    }
+    /**
+     * Update chunks for modified files (delete old, insert new) with content-hash diffing.
+     * Only re-embeds chunks whose content actually changed.
+     */
+    async updateFiles(asts, fileContents, onProgress) {
+        if (!this.enabled)
+            return { added: 0, removed: 0, unchanged: 0 };
+        // Phase 1: Chunk the new versions
+        onProgress?.({ phase: 'chunking', processed: 0, total: asts.length });
+        const newChunks = this.chunker.chunkFiles(asts, fileContents);
+        onProgress?.({ phase: 'chunking', processed: asts.length, total: asts.length });
+        // Collect file paths being updated
+        const filePaths = new Set(asts.map(a => a.filePath));
+        // Collect old chunk IDs for these files
+        const oldChunkIds = new Set();
+        for (const [id] of this.chunkHashes) {
+            for (const filePath of filePaths) {
+                if (id.startsWith(filePath + ':')) {
+                    oldChunkIds.add(id);
+                    break;
+                }
+            }
+        }
+        // Diff: compare content hashes
+        const newChunkMap = new Map();
+        for (const chunk of newChunks) {
+            newChunkMap.set(chunk.id, chunk);
+        }
+        const unchangedIds = new Set();
+        const changedChunks = [];
+        const addedChunks = [];
+        for (const chunk of newChunks) {
+            const newHash = contentHash(chunk.content);
+            const oldHash = this.chunkHashes.get(chunk.id);
+            if (oldHash && oldHash === newHash) {
+                // Content unchanged — skip re-embedding
+                unchangedIds.add(chunk.id);
+            }
+            else if (oldHash) {
+                // Content changed — needs re-embedding
+                changedChunks.push(chunk);
+            }
+            else {
+                // New chunk
+                addedChunks.push(chunk);
+            }
+        }
+        // IDs to remove: old chunk IDs that are no longer present in new chunks
+        const removedIds = [];
+        for (const id of oldChunkIds) {
+            if (!newChunkMap.has(id)) {
+                removedIds.push(id);
+            }
+        }
+        // Delete removed and changed chunks from store
+        const idsToDelete = [...removedIds, ...changedChunks.map(c => c.id)];
+        if (idsToDelete.length > 0) {
+            await this.store.delete(idsToDelete);
+        }
+        // Embed and insert changed + added chunks
+        const toEmbed = [...changedChunks, ...addedChunks];
+        if (toEmbed.length > 0) {
+            await this.embedChunks(toEmbed, onProgress);
+            onProgress?.({ phase: 'indexing', processed: 0, total: toEmbed.length });
+            await this.store.insert(toEmbed);
+            onProgress?.({ phase: 'indexing', processed: toEmbed.length, total: toEmbed.length });
+        }
+        // Update content hashes
+        for (const id of removedIds) {
+            this.chunkHashes.delete(id);
+        }
+        for (const chunk of toEmbed) {
+            this.chunkHashes.set(chunk.id, contentHash(chunk.content));
+        }
+        return {
+            added: addedChunks.length + changedChunks.length,
+            removed: removedIds.length,
+            unchanged: unchangedIds.size,
+        };
+    }
+    /**
+     * Get the underlying vector store (for save/load operations).
+     */
+    getStore() {
+        return this.store;
+    }
+    // ── Private Helpers ──────────────────────────────────────────────
+    /**
+     * Embed chunks in batches with controlled concurrency.
+     * Assigns embeddings back to the chunk objects in-place.
+     */
+    async embedChunks(chunks, onProgress) {
+        const totalChunks = chunks.length;
+        let processedCount = 0;
+        onProgress?.({ phase: 'embedding', processed: 0, total: totalChunks });
+        // Split into batches
+        const batches = [];
+        for (let i = 0; i < chunks.length; i += this.batchSize) {
+            batches.push(chunks.slice(i, i + this.batchSize));
+        }
+        // Process batches with controlled concurrency
+        for (let i = 0; i < batches.length; i += this.maxConcurrentBatches) {
+            const concurrentBatches = batches.slice(i, i + this.maxConcurrentBatches);
+            const results = await Promise.all(concurrentBatches.map(batch => {
+                const texts = batch.map(c => c.content);
+                return this.provider.embed(texts);
+            }));
+            // Assign embeddings back to chunks
+            for (let batchIdx = 0; batchIdx < concurrentBatches.length; batchIdx++) {
+                const batch = concurrentBatches[batchIdx];
+                const embeddings = results[batchIdx];
+                for (let chunkIdx = 0; chunkIdx < batch.length; chunkIdx++) {
+                    batch[chunkIdx].embedding = embeddings[chunkIdx];
+                }
+                processedCount += batch.length;
+                onProgress?.({ phase: 'embedding', processed: processedCount, total: totalChunks });
+            }
+        }
+    }
+}

package/dist/src/plugin/code-intelligence-plugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"code-intelligence-plugin.d.ts","sourceRoot":"","sources":["../../../src/plugin/code-intelligence-plugin.ts"],"names":[],"mappings":"AACA,OAAO,EAAQ,KAAK,oBAAoB,EAAE,MAAM,gCAAgC,CAAA;AAahF,mEAAmE;AACnE,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAA;IACZ,WAAW,EAAE,MAAM,CAAA;IACnB,WAAW,CAAC,OAAO,EAAE,iBAAiB,GAAG,oBAAoB,CAAC,GAAG,CAAC,EAAE,CAAA;CACrE;AAED,qDAAqD;AACrD,MAAM,WAAW,iBAAiB;IAChC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC3B,GAAG,EAAE,MAAM,CAAA;CACZ;AAED,2CAA2C;AAC3C,eAAO,MAAM,sBAAsB,EAAE,UAiHpC,CAAA"}
+{"version":3,"file":"code-intelligence-plugin.d.ts","sourceRoot":"","sources":["../../../src/plugin/code-intelligence-plugin.ts"],"names":[],"mappings":"AACA,OAAO,EAAQ,KAAK,oBAAoB,EAAE,MAAM,gCAAgC,CAAA;AAchF,mEAAmE;AACnE,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAA;IACZ,WAAW,EAAE,MAAM,CAAA;IACnB,WAAW,CAAC,OAAO,EAAE,iBAAiB,GAAG,oBAAoB,CAAC,GAAG,CAAC,EAAE,CAAA;CACrE;AAED,qDAAqD;AACrD,MAAM,WAAW,iBAAiB;IAChC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC3B,GAAG,EAAE,MAAM,CAAA;CACZ;AAED,2CAA2C;AAC3C,eAAO,MAAM,sBAAsB,EAAE,UAkHpC,CAAA"}

package/dist/src/plugin/code-intelligence-plugin.js

@@ -3,6 +3,7 @@ import { tool } from '@anthropic-ai/claude-agent-sdk';
 import { SymbolExtractor } from '../parser/symbol-extractor.js';
 import { IncrementalIndexer } from '../indexing/incremental-indexer.js';
 import { SearchEngine } from '../search/search-engine.js';
+import { HybridSearchEngine } from '../search/hybrid-search.js';
 import { RepoMapGenerator } from '../repo-map/repo-map-generator.js';
 import { DedupPipeline } from '../memory/dedup-pipeline.js';
 import { InMemoryStore } from '../memory/memory-store.js';
@@ -14,6 +15,7 @@ export const codeIntelligencePlugin = {
         const extractor = new SymbolExtractor();
         const indexer = new IncrementalIndexer(extractor, { indexDir: '.agentfactory/code-index' });
         const searchEngine = new SearchEngine();
+        const hybridEngine = new HybridSearchEngine(searchEngine, null, null);
         const repoMapGen = new RepoMapGenerator();
         const dedupStore = new InMemoryStore();
         const dedupPipeline = new DedupPipeline(dedupStore);
@@ -59,13 +61,13 @@ export const codeIntelligencePlugin = {
                     };
                 }
             }),
-            tool('af_code_search_code', 'Search code using BM25 ranking with code-aware tokenization', {
+            tool('af_code_search_code', 'Search code using hybrid BM25 + semantic ranking with code-aware tokenization', {
                 query: z.string().describe('Code search query'),
                 max_results: z.number().optional().describe('Maximum results (default 20)'),
                 language: z.string().optional().describe('Filter by language'),
             }, async (args) => {
                 try {
-                    const results = searchEngine.search({
+                    const results = await hybridEngine.search({
                         query: args.query,
                         maxResults: args.max_results ?? 20,
                         language: args.language,

package/dist/src/reranking/__tests__/reranker.test.d.ts

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

package/dist/src/reranking/__tests__/reranker.test.d.ts.map

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