@renseiai/agentfactory-code-intelligence 0.8.4

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Rensei AI
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

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

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

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

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

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

@@ -0,0 +1,187 @@
+import { describe, it, expect } from 'vitest';
+import { SymbolKindSchema, CodeSymbolSchema, FileASTSchema, FileIndexSchema, SearchQuerySchema, SearchResultSchema, MemoryEntrySchema, DedupResultSchema, IndexMetadataSchema, RepoMapEntrySchema, } from '../types.js';
+describe('SymbolKindSchema', () => {
+    it('accepts valid symbol kinds', () => {
+        const kinds = ['function', 'class', 'interface', 'type', 'variable', 'method',
+            'property', 'import', 'export', 'enum', 'struct', 'trait', 'impl', 'macro',
+            'decorator', 'module'];
+        for (const kind of kinds) {
+            expect(SymbolKindSchema.parse(kind)).toBe(kind);
+        }
+    });
+    it('rejects invalid symbol kinds', () => {
+        expect(() => SymbolKindSchema.parse('invalid')).toThrow();
+    });
+});
+describe('CodeSymbolSchema', () => {
+    it('parses a valid symbol', () => {
+        const symbol = CodeSymbolSchema.parse({
+            name: 'myFunction',
+            kind: 'function',
+            filePath: 'src/utils.ts',
+            line: 10,
+            exported: true,
+            signature: 'function myFunction(x: number): string',
+        });
+        expect(symbol.name).toBe('myFunction');
+        expect(symbol.kind).toBe('function');
+        expect(symbol.exported).toBe(true);
+    });
+    it('applies defaults', () => {
+        const symbol = CodeSymbolSchema.parse({
+            name: 'x',
+            kind: 'variable',
+            filePath: 'a.ts',
+            line: 0,
+        });
+        expect(symbol.exported).toBe(false);
+    });
+    it('rejects empty name', () => {
+        expect(() => CodeSymbolSchema.parse({
+            name: '',
+            kind: 'function',
+            filePath: 'a.ts',
+            line: 0,
+        })).toThrow();
+    });
+    it('rejects negative line number', () => {
+        expect(() => CodeSymbolSchema.parse({
+            name: 'x',
+            kind: 'function',
+            filePath: 'a.ts',
+            line: -1,
+        })).toThrow();
+    });
+});
+describe('FileASTSchema', () => {
+    it('parses valid file AST', () => {
+        const ast = FileASTSchema.parse({
+            filePath: 'src/main.ts',
+            language: 'typescript',
+            symbols: [{
+                    name: 'main',
+                    kind: 'function',
+                    filePath: 'src/main.ts',
+                    line: 1,
+                }],
+            imports: ['./utils'],
+            exports: ['main'],
+        });
+        expect(ast.symbols).toHaveLength(1);
+        expect(ast.imports).toEqual(['./utils']);
+    });
+});
+describe('FileIndexSchema', () => {
+    it('parses valid file index', () => {
+        const idx = FileIndexSchema.parse({
+            filePath: 'src/lib.ts',
+            gitHash: 'abc123def456',
+            symbols: [],
+            lastIndexed: Date.now(),
+        });
+        expect(idx.gitHash).toBe('abc123def456');
+    });
+});
+describe('SearchQuerySchema', () => {
+    it('parses minimal query', () => {
+        const q = SearchQuerySchema.parse({ query: 'myFunc' });
+        expect(q.query).toBe('myFunc');
+        expect(q.maxResults).toBe(20);
+    });
+    it('parses full query', () => {
+        const q = SearchQuerySchema.parse({
+            query: 'handler',
+            maxResults: 10,
+            filePattern: '*.ts',
+            symbolKinds: ['function', 'method'],
+            language: 'typescript',
+        });
+        expect(q.symbolKinds).toEqual(['function', 'method']);
+    });
+    it('rejects empty query', () => {
+        expect(() => SearchQuerySchema.parse({ query: '' })).toThrow();
+    });
+});
+describe('SearchResultSchema', () => {
+    it('parses valid result', () => {
+        const result = SearchResultSchema.parse({
+            symbol: {
+                name: 'foo',
+                kind: 'function',
+                filePath: 'a.ts',
+                line: 5,
+            },
+            score: 1.5,
+            matchType: 'bm25',
+        });
+        expect(result.score).toBe(1.5);
+        expect(result.matchType).toBe('bm25');
+    });
+});
+describe('MemoryEntrySchema', () => {
+    it('parses valid entry', () => {
+        const entry = MemoryEntrySchema.parse({
+            id: 'mem-001',
+            content: 'Some content',
+            xxhash: 'abcdef0123456789',
+            simhash: BigInt('0xdeadbeef'),
+            createdAt: Date.now(),
+            metadata: { source: 'test' },
+        });
+        expect(entry.id).toBe('mem-001');
+        expect(typeof entry.simhash).toBe('bigint');
+    });
+});
+describe('DedupResultSchema', () => {
+    it('parses exact match', () => {
+        const result = DedupResultSchema.parse({
+            isDuplicate: true,
+            matchType: 'exact',
+            existingId: 'mem-001',
+        });
+        expect(result.isDuplicate).toBe(true);
+    });
+    it('parses near match', () => {
+        const result = DedupResultSchema.parse({
+            isDuplicate: true,
+            matchType: 'near',
+            existingId: 'mem-002',
+            hammingDistance: 2,
+        });
+        expect(result.hammingDistance).toBe(2);
+    });
+    it('parses no match', () => {
+        const result = DedupResultSchema.parse({
+            isDuplicate: false,
+            matchType: 'none',
+        });
+        expect(result.existingId).toBeUndefined();
+    });
+});
+describe('IndexMetadataSchema', () => {
+    it('parses valid metadata', () => {
+        const meta = IndexMetadataSchema.parse({
+            version: 1,
+            rootHash: 'abc123',
+            totalFiles: 100,
+            totalSymbols: 1500,
+            lastUpdated: Date.now(),
+            languages: ['typescript', 'javascript'],
+        });
+        expect(meta.totalFiles).toBe(100);
+    });
+});
+describe('RepoMapEntrySchema', () => {
+    it('parses valid entry', () => {
+        const entry = RepoMapEntrySchema.parse({
+            filePath: 'src/index.ts',
+            rank: 0.85,
+            symbols: [
+                { name: 'main', kind: 'function', line: 1 },
+                { name: 'Config', kind: 'interface', line: 20 },
+            ],
+        });
+        expect(entry.symbols).toHaveLength(2);
+        expect(entry.rank).toBe(0.85);
+    });
+});

package/dist/src/index.d.ts

@@ -0,0 +1,26 @@
+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 { SymbolExtractor } from './parser/symbol-extractor.js';
+export type { LanguageExtractor } from './parser/symbol-extractor.js';
+export { TypeScriptExtractor } from './parser/typescript-extractor.js';
+export { PythonExtractor } from './parser/python-extractor.js';
+export { GoExtractor } from './parser/go-extractor.js';
+export { RustExtractor } from './parser/rust-extractor.js';
+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 { 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 { DependencyGraph } from './repo-map/dependency-graph.js';
+export { PageRank } from './repo-map/pagerank.js';
+export { RepoMapGenerator } from './repo-map/repo-map-generator.js';
+export { xxhash64 } from './memory/xxhash.js';
+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 { codeIntelligencePlugin } from './plugin/code-intelligence-plugin.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +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"}

package/dist/src/index.js

@@ -0,0 +1,29 @@
+// Core types and schemas
+export { SymbolKindSchema, CodeSymbolSchema, FileASTSchema, FileIndexSchema, SearchQuerySchema, SearchResultSchema, MemoryEntrySchema, DedupResultSchema, IndexMetadataSchema, RepoMapEntrySchema, } from './types.js';
+// Parser
+export { SymbolExtractor } from './parser/symbol-extractor.js';
+export { TypeScriptExtractor } from './parser/typescript-extractor.js';
+export { PythonExtractor } from './parser/python-extractor.js';
+export { GoExtractor } from './parser/go-extractor.js';
+export { RustExtractor } from './parser/rust-extractor.js';
+// Indexing
+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';
+// 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';
+// Repo Map
+export { DependencyGraph } from './repo-map/dependency-graph.js';
+export { PageRank } from './repo-map/pagerank.js';
+export { RepoMapGenerator } from './repo-map/repo-map-generator.js';
+// Memory
+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';
+// Plugin
+export { codeIntelligencePlugin } from './plugin/code-intelligence-plugin.js';

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

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

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

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

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

@@ -0,0 +1,193 @@
+import { describe, it, expect } from 'vitest';
+import { GitHashProvider } from '../git-hash-provider.js';
+import { MerkleTree } from '../merkle-tree.js';
+import { ChangeDetector } from '../change-detector.js';
+import { IncrementalIndexer } from '../incremental-indexer.js';
+import { SymbolExtractor } from '../../parser/symbol-extractor.js';
+describe('GitHashProvider', () => {
+    const provider = new GitHashProvider();
+    it('produces consistent hashes', () => {
+        const hash1 = provider.hashContent('hello world');
+        const hash2 = provider.hashContent('hello world');
+        expect(hash1).toBe(hash2);
+    });
+    it('produces different hashes for different content', () => {
+        const hash1 = provider.hashContent('hello');
+        const hash2 = provider.hashContent('world');
+        expect(hash1).not.toBe(hash2);
+    });
+    it('produces 40-char hex string (SHA-1)', () => {
+        const hash = provider.hashContent('test');
+        expect(hash).toMatch(/^[0-9a-f]{40}$/);
+    });
+    it('matches git hash-object format', () => {
+        // git hash-object computes sha1("blob <size>\0<content>")
+        // "hello world" -> blob 11\0hello world
+        const hash = provider.hashContent('hello world');
+        expect(hash).toHaveLength(40);
+    });
+    it('hashes directory from child hashes', () => {
+        const hash = provider.hashDirectory(['abc123', 'def456']);
+        expect(hash).toMatch(/^[0-9a-f]{40}$/);
+    });
+    it('directory hash is order-independent (sorted)', () => {
+        const hash1 = provider.hashDirectory(['abc', 'def']);
+        const hash2 = provider.hashDirectory(['def', 'abc']);
+        expect(hash1).toBe(hash2);
+    });
+});
+describe('MerkleTree', () => {
+    it('builds from files', () => {
+        const files = new Map([
+            ['src/index.ts', 'export const x = 1'],
+            ['src/utils.ts', 'export function foo() {}'],
+        ]);
+        const tree = MerkleTree.fromFiles(files);
+        expect(tree.getRootHash()).toBeTruthy();
+        expect(tree.getFiles().size).toBe(2);
+    });
+    it('same files produce same root hash', () => {
+        const files = new Map([
+            ['a.ts', 'content a'],
+            ['b.ts', 'content b'],
+        ]);
+        const tree1 = MerkleTree.fromFiles(files);
+        const tree2 = MerkleTree.fromFiles(files);
+        expect(tree1.getRootHash()).toBe(tree2.getRootHash());
+    });
+    it('different files produce different root hash', () => {
+        const tree1 = MerkleTree.fromFiles(new Map([['a.ts', 'v1']]));
+        const tree2 = MerkleTree.fromFiles(new Map([['a.ts', 'v2']]));
+        expect(tree1.getRootHash()).not.toBe(tree2.getRootHash());
+    });
+    it('retrieves node by path', () => {
+        const files = new Map([['src/lib/util.ts', 'content']]);
+        const tree = MerkleTree.fromFiles(files);
+        const node = tree.getNode('src/lib/util.ts');
+        expect(node).toBeDefined();
+        expect(node.isDirectory).toBe(false);
+    });
+    it('retrieves directory node', () => {
+        const files = new Map([
+            ['src/a.ts', 'a'],
+            ['src/b.ts', 'b'],
+        ]);
+        const tree = MerkleTree.fromFiles(files);
+        const dir = tree.getNode('src');
+        expect(dir).toBeDefined();
+        expect(dir.isDirectory).toBe(true);
+        expect(dir.children.size).toBe(2);
+    });
+    it('builds from pre-computed hashes', () => {
+        const hashes = new Map([
+            ['a.ts', 'abc123'],
+            ['b.ts', 'def456'],
+        ]);
+        const tree = MerkleTree.fromHashes(hashes);
+        expect(tree.getRootHash()).toBeTruthy();
+        const files = tree.getFiles();
+        expect(files.get('a.ts')).toBe('abc123');
+    });
+});
+describe('ChangeDetector', () => {
+    const detector = new ChangeDetector();
+    it('detects added files', () => {
+        const old = MerkleTree.fromFiles(new Map([['a.ts', 'a']]));
+        const nw = MerkleTree.fromFiles(new Map([['a.ts', 'a'], ['b.ts', 'b']]));
+        const changes = detector.detect(old, nw);
+        expect(changes.added).toEqual(['b.ts']);
+        expect(changes.modified).toEqual([]);
+        expect(changes.deleted).toEqual([]);
+    });
+    it('detects modified files', () => {
+        const old = MerkleTree.fromFiles(new Map([['a.ts', 'v1']]));
+        const nw = MerkleTree.fromFiles(new Map([['a.ts', 'v2']]));
+        const changes = detector.detect(old, nw);
+        expect(changes.modified).toEqual(['a.ts']);
+        expect(changes.added).toEqual([]);
+    });
+    it('detects deleted files', () => {
+        const old = MerkleTree.fromFiles(new Map([['a.ts', 'a'], ['b.ts', 'b']]));
+        const nw = MerkleTree.fromFiles(new Map([['a.ts', 'a']]));
+        const changes = detector.detect(old, nw);
+        expect(changes.deleted).toEqual(['b.ts']);
+    });
+    it('detects mixed changes', () => {
+        const old = MerkleTree.fromFiles(new Map([
+            ['keep.ts', 'same'],
+            ['modify.ts', 'old'],
+            ['delete.ts', 'gone'],
+        ]));
+        const nw = MerkleTree.fromFiles(new Map([
+            ['keep.ts', 'same'],
+            ['modify.ts', 'new'],
+            ['add.ts', 'new file'],
+        ]));
+        const changes = detector.detect(old, nw);
+        expect(changes.added).toEqual(['add.ts']);
+        expect(changes.modified).toEqual(['modify.ts']);
+        expect(changes.deleted).toEqual(['delete.ts']);
+    });
+    it('reports identical trees', () => {
+        const files = new Map([['a.ts', 'content']]);
+        const tree = MerkleTree.fromFiles(files);
+        expect(detector.isIdentical(tree, tree)).toBe(true);
+    });
+    it('reports different trees', () => {
+        const tree1 = MerkleTree.fromFiles(new Map([['a.ts', 'v1']]));
+        const tree2 = MerkleTree.fromFiles(new Map([['a.ts', 'v2']]));
+        expect(detector.isIdentical(tree1, tree2)).toBe(false);
+    });
+});
+describe('IncrementalIndexer', () => {
+    it('indexes all files on first run', async () => {
+        const extractor = new SymbolExtractor();
+        const indexer = new IncrementalIndexer(extractor);
+        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);
+    });
+    it('only re-indexes changed files', async () => {
+        const extractor = new SymbolExtractor();
+        const indexer = new IncrementalIndexer(extractor);
+        // First run
+        const files1 = new Map([
+            ['a.ts', 'export const x = 1'],
+            ['b.ts', 'export const y = 2'],
+        ]);
+        await indexer.index(files1);
+        // Second run with b.ts modified
+        const files2 = new Map([
+            ['a.ts', 'export const x = 1'],
+            ['b.ts', 'export const y = 3'],
+        ]);
+        const result = await indexer.index(files2);
+        expect(result.changes.added).toHaveLength(0);
+        expect(result.changes.modified).toEqual(['b.ts']);
+        expect(result.indexed).toHaveLength(1);
+        expect(result.indexed[0].filePath).toBe('b.ts');
+    });
+    it('detects deleted files', async () => {
+        const extractor = new SymbolExtractor();
+        const indexer = new IncrementalIndexer(extractor);
+        await indexer.index(new Map([['a.ts', 'x'], ['b.ts', 'y']]));
+        const result = await indexer.index(new Map([['a.ts', 'x']]));
+        expect(result.changes.deleted).toEqual(['b.ts']);
+        expect(result.metadata.totalFiles).toBe(1);
+    });
+    it('returns all symbols', async () => {
+        const extractor = new SymbolExtractor();
+        const indexer = new IncrementalIndexer(extractor);
+        await indexer.index(new Map([
+            ['a.ts', 'export function foo() {}\nexport function bar() {}'],
+        ]));
+        const symbols = indexer.getAllSymbols();
+        expect(symbols.length).toBeGreaterThanOrEqual(2);
+    });
+});

package/dist/src/indexing/change-detector.d.ts

@@ -0,0 +1,16 @@
+import { MerkleTree } from './merkle-tree.js';
+export interface ChangeSet {
+    added: string[];
+    modified: string[];
+    deleted: string[];
+}
+/**
+ * Diff two Merkle trees to identify changed files.
+ */
+export declare class ChangeDetector {
+    /** Compare old and new trees, returning the set of changes. */
+    detect(oldTree: MerkleTree, newTree: MerkleTree): ChangeSet;
+    /** Quick check if trees are identical (root hash comparison). */
+    isIdentical(oldTree: MerkleTree, newTree: MerkleTree): boolean;
+}
+//# sourceMappingURL=change-detector.d.ts.map

package/dist/src/indexing/change-detector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"change-detector.d.ts","sourceRoot":"","sources":["../../../src/indexing/change-detector.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAE7C,MAAM,WAAW,SAAS;IACxB,KAAK,EAAE,MAAM,EAAE,CAAA;IACf,QAAQ,EAAE,MAAM,EAAE,CAAA;IAClB,OAAO,EAAE,MAAM,EAAE,CAAA;CAClB;AAED;;GAEG;AACH,qBAAa,cAAc;IACzB,+DAA+D;IAC/D,MAAM,CAAC,OAAO,EAAE,UAAU,EAAE,OAAO,EAAE,UAAU,GAAG,SAAS;IAgC3D,iEAAiE;IACjE,WAAW,CAAC,OAAO,EAAE,UAAU,EAAE,OAAO,EAAE,UAAU,GAAG,OAAO;CAG/D"}

package/dist/src/indexing/change-detector.js

@@ -0,0 +1,38 @@
+/**
+ * Diff two Merkle trees to identify changed files.
+ */
+export class ChangeDetector {
+    /** Compare old and new trees, returning the set of changes. */
+    detect(oldTree, newTree) {
+        const oldFiles = oldTree.getFiles();
+        const newFiles = newTree.getFiles();
+        const added = [];
+        const modified = [];
+        const deleted = [];
+        // Find added and modified files
+        for (const [path, newHash] of newFiles) {
+            const oldHash = oldFiles.get(path);
+            if (oldHash === undefined) {
+                added.push(path);
+            }
+            else if (oldHash !== newHash) {
+                modified.push(path);
+            }
+        }
+        // Find deleted files
+        for (const path of oldFiles.keys()) {
+            if (!newFiles.has(path)) {
+                deleted.push(path);
+            }
+        }
+        return {
+            added: added.sort(),
+            modified: modified.sort(),
+            deleted: deleted.sort(),
+        };
+    }
+    /** Quick check if trees are identical (root hash comparison). */
+    isIdentical(oldTree, newTree) {
+        return oldTree.getRootHash() === newTree.getRootHash();
+    }
+}

package/dist/src/indexing/git-hash-provider.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Compute git-compatible object hashes for files.
+ * Git uses: sha1("blob <size>\0<content>")
+ */
+export declare class GitHashProvider {
+    /** Compute git blob hash for content (matches `git hash-object`). */
+    hashContent(content: string): string;
+    /** Compute a hash for a directory node (sorted child hashes). */
+    hashDirectory(childHashes: string[]): string;
+}
+//# sourceMappingURL=git-hash-provider.d.ts.map

package/dist/src/indexing/git-hash-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"git-hash-provider.d.ts","sourceRoot":"","sources":["../../../src/indexing/git-hash-provider.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,qBAAa,eAAe;IAC1B,qEAAqE;IACrE,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM;IASpC,iEAAiE;IACjE,aAAa,CAAC,WAAW,EAAE,MAAM,EAAE,GAAG,MAAM;CAQ7C"}

package/dist/src/indexing/git-hash-provider.js

@@ -0,0 +1,25 @@
+import { createHash } from 'node:crypto';
+/**
+ * Compute git-compatible object hashes for files.
+ * Git uses: sha1("blob <size>\0<content>")
+ */
+export class GitHashProvider {
+    /** Compute git blob hash for content (matches `git hash-object`). */
+    hashContent(content) {
+        const buffer = Buffer.from(content);
+        const header = `blob ${buffer.length}\0`;
+        const hash = createHash('sha1');
+        hash.update(header);
+        hash.update(buffer);
+        return hash.digest('hex');
+    }
+    /** Compute a hash for a directory node (sorted child hashes). */
+    hashDirectory(childHashes) {
+        const sorted = [...childHashes].sort();
+        const combined = sorted.join('\n');
+        const hash = createHash('sha1');
+        hash.update(`tree ${combined.length}\0`);
+        hash.update(combined);
+        return hash.digest('hex');
+    }
+}

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

@@ -0,0 +1,38 @@
+import type { FileIndex, IndexMetadata, CodeSymbol } from '../types.js';
+import { type ChangeSet } from './change-detector.js';
+import { SymbolExtractor } from '../parser/symbol-extractor.js';
+export interface IndexerOptions {
+    indexDir?: string;
+    filePatterns?: string[];
+}
+/**
+ * Orchestrates incremental re-indexing of only changed files.
+ * Persists index to `.agentfactory/code-index/`.
+ */
+export declare class IncrementalIndexer {
+    private hashProvider;
+    private changeDetector;
+    private extractor;
+    private indexDir;
+    private previousTree;
+    private fileIndex;
+    constructor(extractor: SymbolExtractor, options?: IndexerOptions);
+    /**
+     * Index files, returning only the changed ones.
+     * @param files Map of filePath -> content
+     */
+    index(files: Map<string, string>): Promise<{
+        changes: ChangeSet;
+        indexed: FileIndex[];
+        metadata: IndexMetadata;
+    }>;
+    /** Save index to disk. */
+    save(basePath: string): Promise<void>;
+    /** Load index from disk. */
+    load(basePath: string): Promise<boolean>;
+    /** Get all indexed symbols. */
+    getAllSymbols(): CodeSymbol[];
+    /** Get the current file index. */
+    getFileIndex(): Map<string, FileIndex>;
+}
+//# sourceMappingURL=incremental-indexer.d.ts.map

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

@@ -0,0 +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"}