@renseiai/agentfactory-code-intelligence 0.8.8 → 0.8.9

package/dist/src/embedding/__tests__/embedding.test.d.ts

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

package/dist/src/embedding/__tests__/embedding.test.d.ts.map

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

package/dist/src/embedding/__tests__/embedding.test.js

@@ -0,0 +1,339 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { VoyageCodeProvider } from '../voyage-provider.js';
+import { Chunker } from '../chunker.js';
+// ── Helpers ──────────────────────────────────────────────────────────
+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: [] };
+}
+/** Create a mock fetch response. */
+function mockFetchResponse(status, body, headers) {
+    return {
+        ok: status >= 200 && status < 300,
+        status,
+        headers: new Headers(headers ?? {}),
+        json: async () => body,
+        text: async () => JSON.stringify(body),
+    };
+}
+/** Build a Voyage API success response for N inputs of D dimensions. */
+function voyageSuccessResponse(count, dimensions = 256) {
+    return {
+        data: Array.from({ length: count }, (_, i) => ({
+            embedding: Array.from({ length: dimensions }, (_, j) => (i + 1) * 0.01 + j * 0.001),
+            index: i,
+        })),
+        model: 'voyage-code-3',
+        usage: { total_tokens: count * 10 },
+    };
+}
+// ── VoyageCodeProvider ───────────────────────────────────────────────
+describe('VoyageCodeProvider', () => {
+    let originalEnv;
+    beforeEach(() => {
+        originalEnv = process.env.VOYAGE_API_KEY;
+        process.env.VOYAGE_API_KEY = 'test-api-key';
+    });
+    afterEach(() => {
+        if (originalEnv !== undefined) {
+            process.env.VOYAGE_API_KEY = originalEnv;
+        }
+        else {
+            delete process.env.VOYAGE_API_KEY;
+        }
+        vi.restoreAllMocks();
+    });
+    it('throws on missing API key', () => {
+        delete process.env.VOYAGE_API_KEY;
+        expect(() => new VoyageCodeProvider()).toThrow('VOYAGE_API_KEY');
+    });
+    it('uses default config values', () => {
+        const provider = new VoyageCodeProvider();
+        expect(provider.model).toBe('voyage-code-3');
+        expect(provider.dimensions).toBe(256);
+    });
+    it('accepts custom config values', () => {
+        const provider = new VoyageCodeProvider({
+            model: 'voyage-code-3',
+            dimensions: 1024,
+            batchSize: 64,
+            maxRetries: 5,
+        });
+        expect(provider.dimensions).toBe(1024);
+    });
+    it('embeds a single query', async () => {
+        const fetchSpy = vi.spyOn(globalThis, 'fetch').mockResolvedValueOnce(mockFetchResponse(200, voyageSuccessResponse(1)));
+        const provider = new VoyageCodeProvider();
+        const result = await provider.embedQuery('function hello()');
+        expect(result).toHaveLength(256);
+        expect(fetchSpy).toHaveBeenCalledTimes(1);
+        // Verify the request body includes input_type: 'query'
+        const callArgs = fetchSpy.mock.calls[0];
+        const body = JSON.parse(callArgs[1].body);
+        expect(body.input_type).toBe('query');
+        expect(body.output_dimension).toBe(256);
+    });
+    it('embeds a batch of texts', async () => {
+        const fetchSpy = vi.spyOn(globalThis, 'fetch').mockResolvedValueOnce(mockFetchResponse(200, voyageSuccessResponse(3)));
+        const provider = new VoyageCodeProvider();
+        const results = await provider.embed(['text 1', 'text 2', 'text 3']);
+        expect(results).toHaveLength(3);
+        expect(results[0]).toHaveLength(256);
+        expect(fetchSpy).toHaveBeenCalledTimes(1);
+        // Verify the request body includes input_type: 'document'
+        const callArgs = fetchSpy.mock.calls[0];
+        const body = JSON.parse(callArgs[1].body);
+        expect(body.input_type).toBe('document');
+    });
+    it('returns empty array for empty input', async () => {
+        const fetchSpy = vi.spyOn(globalThis, 'fetch');
+        const provider = new VoyageCodeProvider();
+        const results = await provider.embed([]);
+        expect(results).toHaveLength(0);
+        expect(fetchSpy).not.toHaveBeenCalled();
+    });
+    it('splits large batches into chunks of 128', async () => {
+        // Create 300 texts, should be split into 3 batches (128 + 128 + 44)
+        const texts = Array.from({ length: 300 }, (_, i) => `text ${i}`);
+        const fetchSpy = vi.spyOn(globalThis, 'fetch')
+            .mockResolvedValueOnce(mockFetchResponse(200, voyageSuccessResponse(128)))
+            .mockResolvedValueOnce(mockFetchResponse(200, voyageSuccessResponse(128)))
+            .mockResolvedValueOnce(mockFetchResponse(200, voyageSuccessResponse(44)));
+        const provider = new VoyageCodeProvider();
+        const results = await provider.embed(texts);
+        expect(results).toHaveLength(300);
+        expect(fetchSpy).toHaveBeenCalledTimes(3);
+    });
+    it('retries on 429 rate limit', async () => {
+        const fetchSpy = vi.spyOn(globalThis, 'fetch')
+            .mockResolvedValueOnce(mockFetchResponse(429, { detail: 'Rate limited' }))
+            .mockResolvedValueOnce(mockFetchResponse(200, voyageSuccessResponse(1)));
+        const provider = new VoyageCodeProvider({ maxRetries: 3 });
+        // Mock sleep to avoid waiting
+        vi.spyOn(provider, 'sleep').mockResolvedValue(undefined);
+        const result = await provider.embedQuery('test');
+        expect(result).toHaveLength(256);
+        expect(fetchSpy).toHaveBeenCalledTimes(2);
+    });
+    it('retries on 5xx server errors', async () => {
+        const fetchSpy = vi.spyOn(globalThis, 'fetch')
+            .mockResolvedValueOnce(mockFetchResponse(503, { detail: 'Service unavailable' }))
+            .mockResolvedValueOnce(mockFetchResponse(500, { detail: 'Internal error' }))
+            .mockResolvedValueOnce(mockFetchResponse(200, voyageSuccessResponse(1)));
+        const provider = new VoyageCodeProvider({ maxRetries: 3 });
+        vi.spyOn(provider, 'sleep').mockResolvedValue(undefined);
+        const result = await provider.embedQuery('test');
+        expect(result).toHaveLength(256);
+        expect(fetchSpy).toHaveBeenCalledTimes(3);
+    });
+    it('throws after exhausting retries', async () => {
+        vi.spyOn(globalThis, 'fetch')
+            .mockResolvedValue(mockFetchResponse(429, { detail: 'Rate limited' }));
+        const provider = new VoyageCodeProvider({ maxRetries: 2 });
+        vi.spyOn(provider, 'sleep').mockResolvedValue(undefined);
+        await expect(provider.embedQuery('test')).rejects.toThrow('429');
+    });
+    it('throws immediately on 4xx non-retryable errors', async () => {
+        vi.spyOn(globalThis, 'fetch').mockResolvedValueOnce(mockFetchResponse(401, { detail: 'Invalid API key' }));
+        const provider = new VoyageCodeProvider();
+        await expect(provider.embedQuery('test')).rejects.toThrow('Invalid API key');
+    });
+    it('respects Retry-After header', async () => {
+        const fetchSpy = vi.spyOn(globalThis, 'fetch')
+            .mockResolvedValueOnce(mockFetchResponse(429, { detail: 'Rate limited' }, { 'retry-after': '5' }))
+            .mockResolvedValueOnce(mockFetchResponse(200, voyageSuccessResponse(1)));
+        const provider = new VoyageCodeProvider({ maxRetries: 3 });
+        const sleepSpy = vi.spyOn(provider, 'sleep').mockResolvedValue(undefined);
+        await provider.embedQuery('test');
+        // Should have waited 5000ms (5 seconds from Retry-After header)
+        expect(sleepSpy).toHaveBeenCalledWith(5000);
+    });
+    it('sends correct Authorization header', async () => {
+        const fetchSpy = vi.spyOn(globalThis, 'fetch').mockResolvedValueOnce(mockFetchResponse(200, voyageSuccessResponse(1)));
+        const provider = new VoyageCodeProvider();
+        await provider.embedQuery('test');
+        const callArgs = fetchSpy.mock.calls[0];
+        const headers = callArgs[1].headers;
+        expect(headers['Authorization']).toBe('Bearer test-api-key');
+    });
+});
+// ── Chunker ──────────────────────────────────────────────────────────
+describe('Chunker', () => {
+    it('creates a chunk from a simple symbol', () => {
+        const chunker = new Chunker();
+        const ast = makeFileAST('src/utils.ts', 'typescript', [
+            makeSymbol('add', 'function', 'src/utils.ts', {
+                line: 0,
+                endLine: 3,
+                signature: 'function add(a: number, b: number): number',
+                documentation: 'Adds two numbers.',
+            }),
+        ]);
+        const fileContent = [
+            'function add(a: number, b: number): number {',
+            '  // Adds two numbers.',
+            '  return a + b',
+            '}',
+        ].join('\n');
+        const chunks = chunker.chunkFile(ast, fileContent);
+        expect(chunks).toHaveLength(1);
+        expect(chunks[0].id).toBe('src/utils.ts:add:0');
+        expect(chunks[0].content).toContain('function add(a: number, b: number): number');
+        expect(chunks[0].content).toContain('Adds two numbers.');
+        expect(chunks[0].metadata.filePath).toBe('src/utils.ts');
+        expect(chunks[0].metadata.symbolName).toBe('add');
+        expect(chunks[0].metadata.symbolKind).toBe('function');
+        expect(chunks[0].metadata.startLine).toBe(0);
+        expect(chunks[0].metadata.endLine).toBe(3);
+        expect(chunks[0].metadata.language).toBe('typescript');
+    });
+    it('creates chunks for multiple symbols in a file', () => {
+        const chunker = new Chunker();
+        const ast = makeFileAST('src/math.ts', 'typescript', [
+            makeSymbol('add', 'function', 'src/math.ts', { line: 0, endLine: 2 }),
+            makeSymbol('subtract', 'function', 'src/math.ts', { line: 4, endLine: 6 }),
+            makeSymbol('MathHelper', 'class', 'src/math.ts', { line: 8, endLine: 20 }),
+        ]);
+        const chunks = chunker.chunkFile(ast);
+        expect(chunks).toHaveLength(3);
+        expect(chunks[0].metadata.symbolName).toBe('add');
+        expect(chunks[1].metadata.symbolName).toBe('subtract');
+        expect(chunks[2].metadata.symbolName).toBe('MathHelper');
+    });
+    it('handles symbols without endLine as single-line', () => {
+        const chunker = new Chunker();
+        const ast = makeFileAST('src/types.ts', 'typescript', [
+            makeSymbol('Config', 'type', 'src/types.ts', { line: 5 }),
+        ]);
+        const chunks = chunker.chunkFile(ast);
+        expect(chunks).toHaveLength(1);
+        expect(chunks[0].metadata.startLine).toBe(5);
+        expect(chunks[0].metadata.endLine).toBe(5);
+    });
+    it('handles symbols without signature or documentation', () => {
+        const chunker = new Chunker();
+        const ast = makeFileAST('src/utils.ts', 'typescript', [
+            makeSymbol('helper', 'function', 'src/utils.ts', { line: 0, endLine: 2 }),
+        ]);
+        const fileContent = 'function helper() {\n  return true\n}';
+        const chunks = chunker.chunkFile(ast, fileContent);
+        expect(chunks).toHaveLength(1);
+        expect(chunks[0].content).toContain('function helper()');
+    });
+    it('uses sliding window for large symbols', () => {
+        const chunker = new Chunker({ maxChunkLines: 10, overlapLines: 2 });
+        const ast = makeFileAST('src/big.ts', 'typescript', [
+            makeSymbol('bigFunction', 'function', 'src/big.ts', {
+                line: 0,
+                endLine: 24,
+                signature: 'function bigFunction(): void',
+            }),
+        ]);
+        // Create 25 lines of content
+        const lines = Array.from({ length: 25 }, (_, i) => `  line ${i}`);
+        const fileContent = lines.join('\n');
+        const chunks = chunker.chunkFile(ast, fileContent);
+        // 25 lines with maxChunkLines=10, overlap=2 => step=8
+        // Window 0: 0-9, Window 1: 8-17, Window 2: 16-24, Window 3: 24-24
+        expect(chunks.length).toBe(4);
+        // First chunk should have signature prepended
+        expect(chunks[0].content).toContain('function bigFunction(): void');
+        expect(chunks[0].id).toBe('src/big.ts:bigFunction:0');
+        expect(chunks[0].metadata.startLine).toBe(0);
+        expect(chunks[0].metadata.endLine).toBe(9);
+        // Second chunk
+        expect(chunks[1].id).toBe('src/big.ts:bigFunction:8:1');
+        expect(chunks[1].metadata.startLine).toBe(8);
+        expect(chunks[1].metadata.endLine).toBe(17);
+        // Third chunk
+        expect(chunks[2].id).toBe('src/big.ts:bigFunction:16:2');
+        expect(chunks[2].metadata.startLine).toBe(16);
+        expect(chunks[2].metadata.endLine).toBe(24);
+        // Fourth chunk (tail)
+        expect(chunks[3].id).toBe('src/big.ts:bigFunction:24:3');
+        expect(chunks[3].metadata.startLine).toBe(24);
+        expect(chunks[3].metadata.endLine).toBe(24);
+    });
+    it('sliding window chunks overlap correctly', () => {
+        const chunker = new Chunker({ maxChunkLines: 10, overlapLines: 3 });
+        const ast = makeFileAST('src/big.ts', 'typescript', [
+            makeSymbol('fn', 'function', 'src/big.ts', { line: 0, endLine: 19 }),
+        ]);
+        // 20 lines total
+        const lines = Array.from({ length: 20 }, (_, i) => `line ${i}`);
+        const fileContent = lines.join('\n');
+        const chunks = chunker.chunkFile(ast, fileContent);
+        // step = 10 - 3 = 7
+        // Window 0: 0-9, Window 1: 7-16, Window 2: 14-19 => 3 chunks
+        expect(chunks.length).toBe(3);
+        // Lines 7-9 should appear in both first and second chunk (overlap)
+        expect(chunks[0].content).toContain('line 7');
+        expect(chunks[0].content).toContain('line 9');
+        expect(chunks[1].content).toContain('line 7');
+        expect(chunks[1].content).toContain('line 9');
+    });
+    it('chunks multiple FileASTs via chunkFiles', () => {
+        const chunker = new Chunker();
+        const asts = [
+            makeFileAST('a.ts', 'typescript', [
+                makeSymbol('foo', 'function', 'a.ts', { line: 0, endLine: 5 }),
+            ]),
+            makeFileAST('b.py', 'python', [
+                makeSymbol('bar', 'function', 'b.py', { line: 0, endLine: 3 }),
+                makeSymbol('baz', 'class', 'b.py', { line: 5, endLine: 15 }),
+            ]),
+        ];
+        const chunks = chunker.chunkFiles(asts);
+        expect(chunks).toHaveLength(3);
+        expect(chunks[0].metadata.language).toBe('typescript');
+        expect(chunks[1].metadata.language).toBe('python');
+        expect(chunks[2].metadata.language).toBe('python');
+    });
+    it('uses file contents map in chunkFiles', () => {
+        const chunker = new Chunker();
+        const asts = [
+            makeFileAST('a.ts', 'typescript', [
+                makeSymbol('hello', 'function', 'a.ts', { line: 0, endLine: 2 }),
+            ]),
+        ];
+        const contents = new Map([
+            ['a.ts', 'function hello() {\n  return "world"\n}'],
+        ]);
+        const chunks = chunker.chunkFiles(asts, contents);
+        expect(chunks).toHaveLength(1);
+        expect(chunks[0].content).toContain('return "world"');
+    });
+    it('produces valid chunk ids', () => {
+        const chunker = new Chunker();
+        const ast = makeFileAST('src/index.ts', 'typescript', [
+            makeSymbol('main', 'function', 'src/index.ts', { line: 10, endLine: 20 }),
+        ]);
+        const chunks = chunker.chunkFile(ast);
+        expect(chunks[0].id).toBe('src/index.ts:main:10');
+    });
+    it('handles empty symbol list', () => {
+        const chunker = new Chunker();
+        const ast = makeFileAST('empty.ts', 'typescript', []);
+        const chunks = chunker.chunkFile(ast);
+        expect(chunks).toHaveLength(0);
+    });
+    it('uses symbol name and kind when no body, signature, or docs available', () => {
+        const chunker = new Chunker();
+        const ast = makeFileAST('src/types.ts', 'typescript', [
+            makeSymbol('MyInterface', 'interface', 'src/types.ts', { line: 0 }),
+        ]);
+        // No file content provided, no signature, no docs
+        const chunks = chunker.chunkFile(ast);
+        expect(chunks).toHaveLength(1);
+        expect(chunks[0].content).toBe('interface MyInterface');
+    });
+});

package/dist/src/embedding/chunker.d.ts

@@ -0,0 +1,40 @@
+import type { FileAST, EmbeddingChunk } from '../types.js';
+export interface ChunkerOptions {
+    /** Maximum number of lines per chunk before sliding window kicks in. Default: 200 */
+    maxChunkLines?: number;
+    /** Overlap lines between sliding window chunks. Default: 20 */
+    overlapLines?: number;
+}
+/**
+ * Converts FileAST / CodeSymbol data into embedding-ready chunks.
+ *
+ * Each chunk contains a symbol's signature, documentation, and body.
+ * Large symbols exceeding maxChunkLines are split using a sliding window with overlap.
+ */
+export declare class Chunker {
+    private maxChunkLines;
+    private overlapLines;
+    constructor(options?: ChunkerOptions);
+    /**
+     * Convert a FileAST into embedding chunks.
+     * Each symbol with line/endLine info becomes one or more chunks.
+     * Symbols without endLine are treated as single-line.
+     */
+    chunkFile(ast: FileAST, fileContent?: string): EmbeddingChunk[];
+    /**
+     * Convert multiple FileASTs into chunks.
+     * Optionally accepts a map of filePath -> fileContent for body extraction.
+     */
+    chunkFiles(asts: FileAST[], fileContents?: Map<string, string>): EmbeddingChunk[];
+    /** Convert a single CodeSymbol into one or more chunks. */
+    private chunkSymbol;
+    /** Extract the body text of a symbol from source lines. */
+    private extractBody;
+    /** Build the full text content for a chunk from symbol metadata + body. */
+    private buildChunkContent;
+    /** Split a large symbol into overlapping window chunks. */
+    private slidingWindowChunks;
+    /** Create an EmbeddingChunk with a deterministic ID. */
+    private makeChunk;
+}
+//# sourceMappingURL=chunker.d.ts.map

package/dist/src/embedding/chunker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunker.d.ts","sourceRoot":"","sources":["../../../src/embedding/chunker.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAc,cAAc,EAAE,MAAM,aAAa,CAAA;AAEtE,MAAM,WAAW,cAAc;IAC7B,qFAAqF;IACrF,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,+DAA+D;IAC/D,YAAY,CAAC,EAAE,MAAM,CAAA;CACtB;AAKD;;;;;GAKG;AACH,qBAAa,OAAO;IAClB,OAAO,CAAC,aAAa,CAAQ;IAC7B,OAAO,CAAC,YAAY,CAAQ;gBAEhB,OAAO,GAAE,cAAmB;IAKxC;;;;OAIG;IACH,SAAS,CAAC,GAAG,EAAE,OAAO,EAAE,WAAW,CAAC,EAAE,MAAM,GAAG,cAAc,EAAE;IAY/D;;;OAGG;IACH,UAAU,CACR,IAAI,EAAE,OAAO,EAAE,EACf,YAAY,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GACjC,cAAc,EAAE;IASnB,2DAA2D;IAC3D,OAAO,CAAC,WAAW;IAsBnB,2DAA2D;IAC3D,OAAO,CAAC,WAAW;IAanB,2EAA2E;IAC3E,OAAO,CAAC,iBAAiB;IAuBzB,2DAA2D;IAC3D,OAAO,CAAC,mBAAmB;IAmD3B,wDAAwD;IACxD,OAAO,CAAC,SAAS;CA0BlB"}

package/dist/src/embedding/chunker.js

@@ -0,0 +1,135 @@
+const DEFAULT_MAX_CHUNK_LINES = 200;
+const DEFAULT_OVERLAP_LINES = 20;
+/**
+ * Converts FileAST / CodeSymbol data into embedding-ready chunks.
+ *
+ * Each chunk contains a symbol's signature, documentation, and body.
+ * Large symbols exceeding maxChunkLines are split using a sliding window with overlap.
+ */
+export class Chunker {
+    maxChunkLines;
+    overlapLines;
+    constructor(options = {}) {
+        this.maxChunkLines = options.maxChunkLines ?? DEFAULT_MAX_CHUNK_LINES;
+        this.overlapLines = options.overlapLines ?? DEFAULT_OVERLAP_LINES;
+    }
+    /**
+     * Convert a FileAST into embedding chunks.
+     * Each symbol with line/endLine info becomes one or more chunks.
+     * Symbols without endLine are treated as single-line.
+     */
+    chunkFile(ast, fileContent) {
+        const chunks = [];
+        const lines = fileContent ? fileContent.split('\n') : undefined;
+        for (const symbol of ast.symbols) {
+            const symbolChunks = this.chunkSymbol(symbol, ast.language, lines);
+            chunks.push(...symbolChunks);
+        }
+        return chunks;
+    }
+    /**
+     * Convert multiple FileASTs into chunks.
+     * Optionally accepts a map of filePath -> fileContent for body extraction.
+     */
+    chunkFiles(asts, fileContents) {
+        const chunks = [];
+        for (const ast of asts) {
+            const content = fileContents?.get(ast.filePath);
+            chunks.push(...this.chunkFile(ast, content));
+        }
+        return chunks;
+    }
+    /** Convert a single CodeSymbol into one or more chunks. */
+    chunkSymbol(symbol, language, lines) {
+        const startLine = symbol.line;
+        const endLine = symbol.endLine ?? symbol.line;
+        // Build the text content for this symbol
+        const body = this.extractBody(symbol, lines, startLine, endLine);
+        const fullContent = this.buildChunkContent(symbol, body);
+        const totalLines = endLine - startLine + 1;
+        // If the symbol fits within maxChunkLines, produce a single chunk
+        if (totalLines <= this.maxChunkLines) {
+            return [this.makeChunk(symbol, language, fullContent, startLine, endLine)];
+        }
+        // Sliding window for large symbols
+        return this.slidingWindowChunks(symbol, language, lines, startLine, endLine);
+    }
+    /** Extract the body text of a symbol from source lines. */
+    extractBody(symbol, lines, startLine, endLine) {
+        if (!lines)
+            return '';
+        // Lines are 0-indexed in the array, symbol lines are 0-indexed
+        const start = Math.max(0, startLine);
+        const end = Math.min(lines.length - 1, endLine);
+        return lines.slice(start, end + 1).join('\n');
+    }
+    /** Build the full text content for a chunk from symbol metadata + body. */
+    buildChunkContent(symbol, body) {
+        const parts = [];
+        if (symbol.signature) {
+            parts.push(symbol.signature);
+        }
+        if (symbol.documentation) {
+            parts.push(symbol.documentation);
+        }
+        if (body) {
+            parts.push(body);
+        }
+        // If we have no body and no signature, use just the name
+        if (parts.length === 0) {
+            parts.push(`${symbol.kind} ${symbol.name}`);
+        }
+        return parts.join('\n\n');
+    }
+    /** Split a large symbol into overlapping window chunks. */
+    slidingWindowChunks(symbol, language, lines, startLine, endLine) {
+        const chunks = [];
+        const step = this.maxChunkLines - this.overlapLines;
+        let windowStart = startLine;
+        let windowIndex = 0;
+        while (windowStart <= endLine) {
+            const windowEnd = Math.min(windowStart + this.maxChunkLines - 1, endLine);
+            const body = lines
+                ? lines.slice(Math.max(0, windowStart), Math.min(lines.length, windowEnd + 1)).join('\n')
+                : '';
+            // Prepend signature/docs to the first window only
+            let content;
+            if (windowIndex === 0) {
+                const preamble = [];
+                if (symbol.signature)
+                    preamble.push(symbol.signature);
+                if (symbol.documentation)
+                    preamble.push(symbol.documentation);
+                content = preamble.length > 0
+                    ? preamble.join('\n\n') + '\n\n' + body
+                    : body;
+            }
+            else {
+                content = body;
+            }
+            chunks.push(this.makeChunk(symbol, language, content, windowStart, windowEnd, windowIndex));
+            windowStart += step;
+            windowIndex++;
+        }
+        return chunks;
+    }
+    /** Create an EmbeddingChunk with a deterministic ID. */
+    makeChunk(symbol, language, content, startLine, endLine, windowIndex) {
+        const idParts = [symbol.filePath, symbol.name, String(startLine)];
+        if (windowIndex !== undefined && windowIndex > 0) {
+            idParts.push(String(windowIndex));
+        }
+        return {
+            id: idParts.join(':'),
+            content,
+            metadata: {
+                filePath: symbol.filePath,
+                symbolName: symbol.name,
+                symbolKind: symbol.kind,
+                startLine,
+                endLine,
+                language,
+            },
+        };
+    }
+}

package/dist/src/embedding/embedding-provider.d.ts

@@ -0,0 +1,15 @@
+import type { EmbeddingProviderConfig } from '../types.js';
+/**
+ * Abstract interface for embedding providers.
+ * Implementations produce dense vectors from text for semantic search.
+ */
+export interface EmbeddingProvider {
+    readonly model: string;
+    readonly dimensions: number;
+    /** Batch embed multiple texts, returning one vector per text. */
+    embed(texts: string[]): Promise<number[][]>;
+    /** Embed a single query text. */
+    embedQuery(text: string): Promise<number[]>;
+}
+export type { EmbeddingProviderConfig };
+//# sourceMappingURL=embedding-provider.d.ts.map

package/dist/src/embedding/embedding-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"embedding-provider.d.ts","sourceRoot":"","sources":["../../../src/embedding/embedding-provider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAA;AAE1D;;;GAGG;AACH,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;IAC3B,iEAAiE;IACjE,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAAA;IAC3C,iCAAiC;IACjC,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAAA;CAC5C;AAED,YAAY,EAAE,uBAAuB,EAAE,CAAA"}

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

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

package/dist/src/embedding/voyage-provider.d.ts

@@ -0,0 +1,39 @@
+import type { EmbeddingProvider } from './embedding-provider.js';
+import type { EmbeddingProviderConfig } from '../types.js';
+/**
+ * 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 declare class VoyageCodeProvider implements EmbeddingProvider {
+    readonly model: string;
+    readonly dimensions: number;
+    private batchSize;
+    private maxRetries;
+    private apiKey;
+    constructor(config?: Partial<EmbeddingProviderConfig>);
+    /**
+     * Embed multiple texts in batches.
+     * Returns one vector per input text, in the same order.
+     */
+    embed(texts: string[]): Promise<number[][]>;
+    /**
+     * Embed a single query text.
+     * Uses input_type "query" for asymmetric retrieval.
+     */
+    embedQuery(text: string): Promise<number[]>;
+    /** Split texts into batches of at most batchSize. */
+    private splitIntoBatches;
+    /** Call the Voyage embeddings API with retry logic. */
+    private callAPI;
+    /** Calculate retry delay with exponential backoff, respecting Retry-After header. */
+    private getRetryDelay;
+    private sleep;
+}
+//# sourceMappingURL=voyage-provider.d.ts.map

package/dist/src/embedding/voyage-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"voyage-provider.d.ts","sourceRoot":"","sources":["../../../src/embedding/voyage-provider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAA;AAChE,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAA;AAoB1D;;;;;;;;;;GAUG;AACH,qBAAa,kBAAmB,YAAW,iBAAiB;IAC1D,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;IAC3B,OAAO,CAAC,SAAS,CAAQ;IACzB,OAAO,CAAC,UAAU,CAAQ;IAC1B,OAAO,CAAC,MAAM,CAAQ;gBAEV,MAAM,GAAE,OAAO,CAAC,uBAAuB,CAAM;IAezD;;;OAGG;IACG,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC;IAkBjD;;;OAGG;IACG,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAKjD,qDAAqD;IACrD,OAAO,CAAC,gBAAgB;IAQxB,uDAAuD;YACzC,OAAO;IAoErB,qFAAqF;IACrF,OAAO,CAAC,aAAa;IAWrB,OAAO,CAAC,KAAK;CAGd"}