@renseiai/agentfactory-code-intelligence 0.8.4

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

@@ -0,0 +1,122 @@
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { MerkleTree } from './merkle-tree.js';
+import { ChangeDetector } from './change-detector.js';
+import { GitHashProvider } from './git-hash-provider.js';
+/**
+ * Orchestrates incremental re-indexing of only changed files.
+ * Persists index to `.agentfactory/code-index/`.
+ */
+export class IncrementalIndexer {
+    hashProvider = new GitHashProvider();
+    changeDetector = new ChangeDetector();
+    extractor;
+    indexDir;
+    previousTree;
+    fileIndex = new Map();
+    constructor(extractor, options = {}) {
+        this.extractor = extractor;
+        this.indexDir = options.indexDir ?? '.agentfactory/code-index';
+    }
+    /**
+     * Index files, returning only the changed ones.
+     * @param files Map of filePath -> content
+     */
+    async index(files) {
+        const newTree = MerkleTree.fromFiles(files);
+        let changes;
+        if (this.previousTree) {
+            changes = this.changeDetector.detect(this.previousTree, newTree);
+        }
+        else {
+            changes = {
+                added: [...files.keys()].sort(),
+                modified: [],
+                deleted: [],
+            };
+        }
+        // Remove deleted files from index
+        for (const path of changes.deleted) {
+            this.fileIndex.delete(path);
+        }
+        // Index added and modified files
+        const indexed = [];
+        const toIndex = [...changes.added, ...changes.modified];
+        for (const path of toIndex) {
+            const content = files.get(path);
+            if (!content)
+                continue;
+            const ast = this.extractor.extractFromSource(content, path);
+            const gitHash = this.hashProvider.hashContent(content);
+            const fileIdx = {
+                filePath: path,
+                gitHash,
+                symbols: ast.symbols,
+                lastIndexed: Date.now(),
+            };
+            this.fileIndex.set(path, fileIdx);
+            indexed.push(fileIdx);
+        }
+        this.previousTree = newTree;
+        // Collect all symbols for metadata
+        const allSymbols = [];
+        const languages = new Set();
+        for (const fi of this.fileIndex.values()) {
+            allSymbols.push(...fi.symbols);
+            for (const s of fi.symbols) {
+                if (s.language)
+                    languages.add(s.language);
+            }
+        }
+        const metadata = {
+            version: 1,
+            rootHash: newTree.getRootHash(),
+            totalFiles: this.fileIndex.size,
+            totalSymbols: allSymbols.length,
+            lastUpdated: Date.now(),
+            languages: [...languages].sort(),
+        };
+        return { changes, indexed, metadata };
+    }
+    /** Save index to disk. */
+    async save(basePath) {
+        const dir = join(basePath, this.indexDir);
+        await mkdir(dir, { recursive: true });
+        const data = {
+            files: Object.fromEntries(this.fileIndex),
+            rootHash: this.previousTree?.getRootHash() ?? '',
+        };
+        await writeFile(join(dir, 'index.json'), JSON.stringify(data, null, 2));
+    }
+    /** Load index from disk. */
+    async load(basePath) {
+        const indexPath = join(basePath, this.indexDir, 'index.json');
+        try {
+            const raw = await readFile(indexPath, 'utf-8');
+            const data = JSON.parse(raw);
+            this.fileIndex = new Map(Object.entries(data.files));
+            // Rebuild Merkle tree from stored hashes
+            const fileHashes = new Map();
+            for (const [path, fi] of this.fileIndex) {
+                fileHashes.set(path, fi.gitHash);
+            }
+            this.previousTree = MerkleTree.fromHashes(fileHashes);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /** Get all indexed symbols. */
+    getAllSymbols() {
+        const symbols = [];
+        for (const fi of this.fileIndex.values()) {
+            symbols.push(...fi.symbols);
+        }
+        return symbols;
+    }
+    /** Get the current file index. */
+    getFileIndex() {
+        return new Map(this.fileIndex);
+    }
+}

package/dist/src/indexing/merkle-tree.d.ts

@@ -0,0 +1,33 @@
+export interface MerkleNode {
+    path: string;
+    hash: string;
+    isDirectory: boolean;
+    children: Map<string, MerkleNode>;
+}
+/**
+ * Merkle tree for incremental code indexing.
+ * Builds a tree from file paths + content hashes, enabling efficient diff.
+ */
+export declare class MerkleTree {
+    private root;
+    private hashProvider;
+    constructor();
+    /** Build tree from file path -> content map. */
+    static fromFiles(files: Map<string, string>): MerkleTree;
+    /** Build tree from file path -> pre-computed hash map. */
+    static fromHashes(fileHashes: Map<string, string>): MerkleTree;
+    addFile(path: string, content: string): void;
+    addFileWithHash(path: string, hash: string): void;
+    /** Recompute all directory hashes bottom-up. */
+    computeHashes(): void;
+    /** Get the root hash of the tree. */
+    getRootHash(): string;
+    /** Get all file nodes in the tree. */
+    getFiles(): Map<string, string>;
+    /** Get a specific node by path. */
+    getNode(path: string): MerkleNode | undefined;
+    private computeNodeHash;
+    private collectFiles;
+    private createDirNode;
+}
+//# sourceMappingURL=merkle-tree.d.ts.map

package/dist/src/indexing/merkle-tree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merkle-tree.d.ts","sourceRoot":"","sources":["../../../src/indexing/merkle-tree.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,WAAW,EAAE,OAAO,CAAA;IACpB,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAA;CAClC;AAED;;;GAGG;AACH,qBAAa,UAAU;IACrB,OAAO,CAAC,IAAI,CAAY;IACxB,OAAO,CAAC,YAAY,CAAiB;;IAOrC,gDAAgD;IAChD,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,UAAU;IASxD,0DAA0D;IAC1D,MAAM,CAAC,UAAU,CAAC,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,UAAU;IAS9D,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI;IAK5C,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI;IAwBjD,gDAAgD;IAChD,aAAa,IAAI,IAAI;IAIrB,qCAAqC;IACrC,WAAW,IAAI,MAAM;IAIrB,sCAAsC;IACtC,QAAQ,IAAI,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC;IAM/B,mCAAmC;IACnC,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,GAAG,SAAS;IAY7C,OAAO,CAAC,eAAe;IAYvB,OAAO,CAAC,YAAY;IAUpB,OAAO,CAAC,aAAa;CAGtB"}

package/dist/src/indexing/merkle-tree.js

@@ -0,0 +1,107 @@
+import { GitHashProvider } from './git-hash-provider.js';
+/**
+ * Merkle tree for incremental code indexing.
+ * Builds a tree from file paths + content hashes, enabling efficient diff.
+ */
+export class MerkleTree {
+    root;
+    hashProvider;
+    constructor() {
+        this.hashProvider = new GitHashProvider();
+        this.root = this.createDirNode('');
+    }
+    /** Build tree from file path -> content map. */
+    static fromFiles(files) {
+        const tree = new MerkleTree();
+        for (const [path, content] of files) {
+            tree.addFile(path, content);
+        }
+        tree.computeHashes();
+        return tree;
+    }
+    /** Build tree from file path -> pre-computed hash map. */
+    static fromHashes(fileHashes) {
+        const tree = new MerkleTree();
+        for (const [path, hash] of fileHashes) {
+            tree.addFileWithHash(path, hash);
+        }
+        tree.computeHashes();
+        return tree;
+    }
+    addFile(path, content) {
+        const hash = this.hashProvider.hashContent(content);
+        this.addFileWithHash(path, hash);
+    }
+    addFileWithHash(path, hash) {
+        const parts = path.split('/').filter(Boolean);
+        let current = this.root;
+        // Create directory nodes
+        for (let i = 0; i < parts.length - 1; i++) {
+            const part = parts[i];
+            if (!current.children.has(part)) {
+                const dirPath = parts.slice(0, i + 1).join('/');
+                current.children.set(part, this.createDirNode(dirPath));
+            }
+            current = current.children.get(part);
+        }
+        // Create file node
+        const fileName = parts[parts.length - 1];
+        current.children.set(fileName, {
+            path,
+            hash,
+            isDirectory: false,
+            children: new Map(),
+        });
+    }
+    /** Recompute all directory hashes bottom-up. */
+    computeHashes() {
+        this.computeNodeHash(this.root);
+    }
+    /** Get the root hash of the tree. */
+    getRootHash() {
+        return this.root.hash;
+    }
+    /** Get all file nodes in the tree. */
+    getFiles() {
+        const files = new Map();
+        this.collectFiles(this.root, files);
+        return files;
+    }
+    /** Get a specific node by path. */
+    getNode(path) {
+        if (path === '' || path === '/')
+            return this.root;
+        const parts = path.split('/').filter(Boolean);
+        let current = this.root;
+        for (const part of parts) {
+            const child = current.children.get(part);
+            if (!child)
+                return undefined;
+            current = child;
+        }
+        return current;
+    }
+    computeNodeHash(node) {
+        if (!node.isDirectory)
+            return node.hash;
+        const childHashes = [];
+        for (const [name, child] of [...node.children.entries()].sort((a, b) => a[0].localeCompare(b[0]))) {
+            const childHash = this.computeNodeHash(child);
+            childHashes.push(`${name}:${childHash}`);
+        }
+        node.hash = this.hashProvider.hashDirectory(childHashes);
+        return node.hash;
+    }
+    collectFiles(node, files) {
+        if (!node.isDirectory) {
+            files.set(node.path, node.hash);
+            return;
+        }
+        for (const child of node.children.values()) {
+            this.collectFiles(child, files);
+        }
+    }
+    createDirNode(path) {
+        return { path, hash: '', isDirectory: true, children: new Map() };
+    }
+}

package/dist/src/memory/__tests__/dedup.test.d.ts

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

package/dist/src/memory/__tests__/dedup.test.d.ts.map

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

package/dist/src/memory/__tests__/dedup.test.js

@@ -0,0 +1,173 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { xxhash64 } from '../xxhash.js';
+import { SimHash } from '../simhash.js';
+import { InMemoryStore } from '../memory-store.js';
+import { DedupPipeline } from '../dedup-pipeline.js';
+describe('xxhash64', () => {
+    it('produces consistent hashes for identical content', async () => {
+        const hash1 = await xxhash64('hello world');
+        const hash2 = await xxhash64('hello world');
+        expect(hash1).toBe(hash2);
+    });
+    it('produces different hashes for different content', async () => {
+        const hash1 = await xxhash64('hello world');
+        const hash2 = await xxhash64('hello world!');
+        expect(hash1).not.toBe(hash2);
+    });
+    it('returns a hex string', async () => {
+        const hash = await xxhash64('test');
+        expect(hash).toMatch(/^[0-9a-f]+$/i);
+    });
+    it('handles empty string', async () => {
+        const hash = await xxhash64('');
+        expect(typeof hash).toBe('string');
+        expect(hash.length).toBeGreaterThan(0);
+    });
+});
+describe('SimHash', () => {
+    const simhash = new SimHash();
+    it('produces identical fingerprint for identical text', () => {
+        const fp1 = simhash.compute('the quick brown fox jumps over the lazy dog');
+        const fp2 = simhash.compute('the quick brown fox jumps over the lazy dog');
+        expect(fp1).toBe(fp2);
+    });
+    it('produces similar fingerprint for similar text', () => {
+        const fp1 = simhash.compute('the quick brown fox jumps over the lazy dog');
+        const fp2 = simhash.compute('the quick brown fox leaps over the lazy dog');
+        const distance = simhash.hammingDistance(fp1, fp2);
+        expect(distance).toBeLessThan(10);
+    });
+    it('produces different fingerprint for different text', () => {
+        const fp1 = simhash.compute('the quick brown fox jumps over the lazy dog');
+        const fp2 = simhash.compute('completely unrelated text about quantum physics and mathematics');
+        const distance = simhash.hammingDistance(fp1, fp2);
+        expect(distance).toBeGreaterThan(5);
+    });
+    it('computes hamming distance correctly', () => {
+        expect(simhash.hammingDistance(10n, 9n)).toBe(2);
+        expect(simhash.hammingDistance(0n, 0n)).toBe(0);
+        expect(simhash.hammingDistance(15n, 0n)).toBe(4);
+    });
+    it('detects near-duplicates within threshold', () => {
+        const fp1 = simhash.compute('hello world this is a test document for simhash');
+        const fp2 = simhash.compute('hello world this is a test document for simhash!');
+        expect(simhash.isNearDuplicate(fp1, fp2, 5)).toBe(true);
+    });
+    it('handles empty text', () => {
+        const fp = simhash.compute('');
+        expect(fp).toBe(0n);
+    });
+});
+describe('InMemoryStore', () => {
+    let store;
+    beforeEach(() => {
+        store = new InMemoryStore();
+    });
+    it('stores and retrieves entries', async () => {
+        const entry = {
+            id: 'test-1',
+            content: 'hello',
+            xxhash: 'abc123',
+            simhash: 42n,
+            createdAt: Date.now(),
+        };
+        await store.put(entry);
+        const retrieved = await store.get('test-1');
+        expect(retrieved).toEqual(entry);
+    });
+    it('finds by xxhash', async () => {
+        const entry = {
+            id: 'test-1',
+            content: 'hello',
+            xxhash: 'abc123',
+            simhash: 42n,
+            createdAt: Date.now(),
+        };
+        await store.put(entry);
+        const found = await store.findByXxhash('abc123');
+        expect(found?.id).toBe('test-1');
+    });
+    it('returns undefined for missing entries', async () => {
+        expect(await store.get('nonexistent')).toBeUndefined();
+        expect(await store.findByXxhash('nonexistent')).toBeUndefined();
+    });
+    it('deletes entries', async () => {
+        await store.put({
+            id: 'test-1', content: 'hello', xxhash: 'abc', simhash: 0n, createdAt: Date.now(),
+        });
+        expect(await store.delete('test-1')).toBe(true);
+        expect(await store.get('test-1')).toBeUndefined();
+        expect(await store.delete('test-1')).toBe(false);
+    });
+    it('clears all entries', async () => {
+        await store.put({ id: '1', content: 'a', xxhash: 'a', simhash: 0n, createdAt: Date.now() });
+        await store.put({ id: '2', content: 'b', xxhash: 'b', simhash: 0n, createdAt: Date.now() });
+        await store.clear();
+        const all = await store.getAll();
+        expect(all).toHaveLength(0);
+    });
+    it('lists all entries', async () => {
+        await store.put({ id: '1', content: 'a', xxhash: 'a', simhash: 0n, createdAt: Date.now() });
+        await store.put({ id: '2', content: 'b', xxhash: 'b', simhash: 0n, createdAt: Date.now() });
+        const all = await store.getAll();
+        expect(all).toHaveLength(2);
+    });
+});
+describe('DedupPipeline', () => {
+    let store;
+    let pipeline;
+    beforeEach(() => {
+        store = new InMemoryStore();
+        pipeline = new DedupPipeline(store);
+    });
+    it('normalizes content', () => {
+        const normalized = pipeline.normalize('  hello\r\n  world\t\t  ');
+        expect(normalized).toBe('hello\n  world');
+    });
+    it('detects no duplicate in empty store', async () => {
+        const result = await pipeline.check('test content');
+        expect(result.isDuplicate).toBe(false);
+        expect(result.matchType).toBe('none');
+    });
+    it('detects exact duplicate', async () => {
+        await pipeline.storeContent('entry-1', 'hello world test content');
+        const result = await pipeline.check('hello world test content');
+        expect(result.isDuplicate).toBe(true);
+        expect(result.matchType).toBe('exact');
+        expect(result.existingId).toBe('entry-1');
+    });
+    it('detects near-duplicate', async () => {
+        // Use a wider threshold for near-duplicate detection in this test
+        const widePipeline = new DedupPipeline(store, { simhashThreshold: 10 });
+        await widePipeline.storeContent('entry-1', 'the quick brown fox jumps over the lazy dog and runs through the forest');
+        const result = await widePipeline.check('the quick brown fox leaps over the lazy dog and runs through the forest');
+        expect(result.isDuplicate).toBe(true);
+        expect(['exact', 'near']).toContain(result.matchType);
+    });
+    it('does not match completely different content', async () => {
+        await pipeline.storeContent('entry-1', 'the quick brown fox jumps over the lazy dog in the morning');
+        const result = await pipeline.check('quantum physics explains particle behavior in accelerators');
+        expect(result.isDuplicate).toBe(false);
+        expect(result.matchType).toBe('none');
+    });
+    it('stores content with metadata', async () => {
+        const entry = await pipeline.storeContent('test-1', 'sample content here', { source: 'test' });
+        expect(entry.id).toBe('test-1');
+        expect(entry.xxhash).toBeTruthy();
+        expect(typeof entry.simhash).toBe('bigint');
+        expect(entry.metadata).toEqual({ source: 'test' });
+    });
+    it('handles whitespace normalization for dedup', async () => {
+        await pipeline.storeContent('entry-1', 'hello   world');
+        // Same content after normalization
+        const result = await pipeline.check('hello   world');
+        expect(result.isDuplicate).toBe(true);
+        expect(result.matchType).toBe('exact');
+    });
+    it('treats line ending variations as same content', async () => {
+        await pipeline.storeContent('entry-1', 'hello\nworld');
+        const result = await pipeline.check('hello\r\nworld');
+        expect(result.isDuplicate).toBe(true);
+        expect(result.matchType).toBe('exact');
+    });
+});

package/dist/src/memory/dedup-pipeline.d.ts

@@ -0,0 +1,24 @@
+import type { DedupResult, MemoryEntry } from '../types.js';
+import type { MemoryStore } from './memory-store.js';
+export interface DedupPipelineOptions {
+    /** Hamming distance threshold for near-duplicate detection (default: 3). */
+    simhashThreshold?: number;
+}
+/**
+ * Two-tier deduplication pipeline.
+ * Tier 1: xxHash64 exact content matching.
+ * Tier 2: SimHash fuzzy matching with configurable Hamming threshold.
+ */
+export declare class DedupPipeline {
+    private memoryStore;
+    private simhash;
+    private threshold;
+    constructor(store: MemoryStore, options?: DedupPipelineOptions);
+    /** Normalize content for consistent hashing. */
+    normalize(content: string): string;
+    /** Check content against existing memory for duplicates. */
+    check(content: string): Promise<DedupResult>;
+    /** Store new content, returning the created entry. */
+    storeContent(id: string, content: string, metadata?: Record<string, unknown>): Promise<MemoryEntry>;
+}
+//# sourceMappingURL=dedup-pipeline.d.ts.map

package/dist/src/memory/dedup-pipeline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dedup-pipeline.d.ts","sourceRoot":"","sources":["../../../src/memory/dedup-pipeline.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,aAAa,CAAA;AAC3D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAIpD,MAAM,WAAW,oBAAoB;IACnC,4EAA4E;IAC5E,gBAAgB,CAAC,EAAE,MAAM,CAAA;CAC1B;AAED;;;;GAIG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,WAAW,CAAa;IAChC,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,SAAS,CAAQ;gBAEb,KAAK,EAAE,WAAW,EAAE,OAAO,GAAE,oBAAyB;IAMlE,gDAAgD;IAChD,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM;IAQlC,4DAA4D;IACtD,KAAK,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC;IAmClD,sDAAsD;IAChD,YAAY,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,WAAW,CAAC;CAgB1G"}

package/dist/src/memory/dedup-pipeline.js

@@ -0,0 +1,73 @@
+import { xxhash64 } from './xxhash.js';
+import { SimHash } from './simhash.js';
+/**
+ * Two-tier deduplication pipeline.
+ * Tier 1: xxHash64 exact content matching.
+ * Tier 2: SimHash fuzzy matching with configurable Hamming threshold.
+ */
+export class DedupPipeline {
+    memoryStore;
+    simhash;
+    threshold;
+    constructor(store, options = {}) {
+        this.memoryStore = store;
+        this.simhash = new SimHash();
+        this.threshold = options.simhashThreshold ?? 3;
+    }
+    /** Normalize content for consistent hashing. */
+    normalize(content) {
+        return content
+            .replace(/\r\n/g, '\n') // Normalize line endings
+            .replace(/\t/g, '  ') // Normalize tabs
+            .replace(/ +$/gm, '') // Strip trailing whitespace
+            .trim();
+    }
+    /** Check content against existing memory for duplicates. */
+    async check(content) {
+        const normalized = this.normalize(content);
+        const hash = await xxhash64(normalized);
+        // Tier 1: exact match via xxHash64
+        const exactMatch = await this.memoryStore.findByXxhash(hash);
+        if (exactMatch) {
+            return {
+                isDuplicate: true,
+                matchType: 'exact',
+                existingId: exactMatch.id,
+            };
+        }
+        // Tier 2: fuzzy match via SimHash
+        const fingerprint = this.simhash.compute(normalized);
+        const allEntries = await this.memoryStore.getAll();
+        for (const entry of allEntries) {
+            const distance = this.simhash.hammingDistance(fingerprint, entry.simhash);
+            if (distance <= this.threshold) {
+                return {
+                    isDuplicate: true,
+                    matchType: 'near',
+                    existingId: entry.id,
+                    hammingDistance: distance,
+                };
+            }
+        }
+        return {
+            isDuplicate: false,
+            matchType: 'none',
+        };
+    }
+    /** Store new content, returning the created entry. */
+    async storeContent(id, content, metadata) {
+        const normalized = this.normalize(content);
+        const hash = await xxhash64(normalized);
+        const fingerprint = this.simhash.compute(normalized);
+        const entry = {
+            id,
+            content: normalized,
+            xxhash: hash,
+            simhash: fingerprint,
+            createdAt: Date.now(),
+            ...(metadata ? { metadata } : {}),
+        };
+        await this.memoryStore.put(entry);
+        return entry;
+    }
+}

package/dist/src/memory/memory-store.d.ts

@@ -0,0 +1,22 @@
+import type { MemoryEntry } from '../types.js';
+/** Interface for persistent memory storage. */
+export interface MemoryStore {
+    get(id: string): Promise<MemoryEntry | undefined>;
+    put(entry: MemoryEntry): Promise<void>;
+    findByXxhash(hash: string): Promise<MemoryEntry | undefined>;
+    getAll(): Promise<MemoryEntry[]>;
+    delete(id: string): Promise<boolean>;
+    clear(): Promise<void>;
+}
+/** In-memory implementation of MemoryStore for testing and lightweight use. */
+export declare class InMemoryStore implements MemoryStore {
+    private entries;
+    private xxhashIndex;
+    get(id: string): Promise<MemoryEntry | undefined>;
+    put(entry: MemoryEntry): Promise<void>;
+    findByXxhash(hash: string): Promise<MemoryEntry | undefined>;
+    getAll(): Promise<MemoryEntry[]>;
+    delete(id: string): Promise<boolean>;
+    clear(): Promise<void>;
+}
+//# sourceMappingURL=memory-store.d.ts.map

package/dist/src/memory/memory-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-store.d.ts","sourceRoot":"","sources":["../../../src/memory/memory-store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAe,MAAM,aAAa,CAAA;AAE3D,+CAA+C;AAC/C,MAAM,WAAW,WAAW;IAC1B,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,GAAG,SAAS,CAAC,CAAA;IACjD,GAAG,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IACtC,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,GAAG,SAAS,CAAC,CAAA;IAC5D,MAAM,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC,CAAA;IAChC,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;IACpC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;CACvB;AAED,+EAA+E;AAC/E,qBAAa,aAAc,YAAW,WAAW;IAC/C,OAAO,CAAC,OAAO,CAAsC;IACrD,OAAO,CAAC,WAAW,CAAiC;IAE9C,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,GAAG,SAAS,CAAC;IAIjD,GAAG,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IAKtC,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,GAAG,SAAS,CAAC;IAM5D,MAAM,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC;IAIhC,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAOpC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAI7B"}

package/dist/src/memory/memory-store.js

@@ -0,0 +1,32 @@
+/** In-memory implementation of MemoryStore for testing and lightweight use. */
+export class InMemoryStore {
+    entries = new Map();
+    xxhashIndex = new Map(); // xxhash -> id
+    async get(id) {
+        return this.entries.get(id);
+    }
+    async put(entry) {
+        this.entries.set(entry.id, entry);
+        this.xxhashIndex.set(entry.xxhash, entry.id);
+    }
+    async findByXxhash(hash) {
+        const id = this.xxhashIndex.get(hash);
+        if (!id)
+            return undefined;
+        return this.entries.get(id);
+    }
+    async getAll() {
+        return Array.from(this.entries.values());
+    }
+    async delete(id) {
+        const entry = this.entries.get(id);
+        if (!entry)
+            return false;
+        this.xxhashIndex.delete(entry.xxhash);
+        return this.entries.delete(id);
+    }
+    async clear() {
+        this.entries.clear();
+        this.xxhashIndex.clear();
+    }
+}

package/dist/src/memory/simhash.d.ts

@@ -0,0 +1,16 @@
+/**
+ * SimHash implementation for near-duplicate detection.
+ * Produces a 64-bit fingerprint where similar content produces similar hashes.
+ */
+export declare class SimHash {
+    private bits;
+    constructor(bits?: number);
+    /** Compute a SimHash fingerprint for the given text. */
+    compute(text: string): bigint;
+    /** Compute Hamming distance between two fingerprints. */
+    hammingDistance(a: bigint, b: bigint): number;
+    /** Check if two fingerprints are near-duplicates within threshold. */
+    isNearDuplicate(a: bigint, b: bigint, threshold?: number): boolean;
+    private tokenize;
+}
+//# sourceMappingURL=simhash.d.ts.map

package/dist/src/memory/simhash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"simhash.d.ts","sourceRoot":"","sources":["../../../src/memory/simhash.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAYH,qBAAa,OAAO;IAClB,OAAO,CAAC,IAAI,CAAQ;gBAER,IAAI,SAAK;IAIrB,wDAAwD;IACxD,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IA4B7B,yDAAyD;IACzD,eAAe,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM;IAU7C,sEAAsE;IACtE,eAAe,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,SAAS,SAAI,GAAG,OAAO;IAI7D,OAAO,CAAC,QAAQ;CAOjB"}