@pleaseai/context-please-core 0.1.0

package/dist/splitter/langchain-splitter.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LangChainCodeSplitter = void 0;
+const text_splitter_1 = require("langchain/text_splitter");
+class LangChainCodeSplitter {
+    constructor(chunkSize, chunkOverlap) {
+        this.chunkSize = 1000;
+        this.chunkOverlap = 200;
+        if (chunkSize)
+            this.chunkSize = chunkSize;
+        if (chunkOverlap)
+            this.chunkOverlap = chunkOverlap;
+    }
+    async split(code, language, filePath) {
+        try {
+            // Create language-specific splitter
+            const mappedLanguage = this.mapLanguage(language);
+            if (mappedLanguage) {
+                const splitter = text_splitter_1.RecursiveCharacterTextSplitter.fromLanguage(mappedLanguage, {
+                    chunkSize: this.chunkSize,
+                    chunkOverlap: this.chunkOverlap,
+                });
+                // Split code
+                const documents = await splitter.createDocuments([code]);
+                // Convert to CodeChunk format
+                return documents.map((doc, index) => {
+                    const lines = doc.metadata?.loc?.lines || { from: 1, to: 1 };
+                    return {
+                        content: doc.pageContent,
+                        metadata: {
+                            startLine: lines.from,
+                            endLine: lines.to,
+                            language,
+                            filePath,
+                        },
+                    };
+                });
+            }
+            else {
+                // If language is not supported, use generic splitter directly
+                return this.fallbackSplit(code, language, filePath);
+            }
+        }
+        catch (error) {
+            console.error('[LangChainSplitter] ❌ Error splitting code:', error);
+            // If specific language splitting fails, use generic splitter
+            return this.fallbackSplit(code, language, filePath);
+        }
+    }
+    setChunkSize(chunkSize) {
+        this.chunkSize = chunkSize;
+    }
+    setChunkOverlap(chunkOverlap) {
+        this.chunkOverlap = chunkOverlap;
+    }
+    mapLanguage(language) {
+        // Map common language names to LangChain supported formats
+        const languageMap = {
+            'javascript': 'js',
+            'typescript': 'js',
+            'python': 'python',
+            'java': 'java',
+            'cpp': 'cpp',
+            'c++': 'cpp',
+            'c': 'cpp',
+            'go': 'go',
+            'rust': 'rust',
+            'php': 'php',
+            'ruby': 'ruby',
+            'swift': 'swift',
+            'scala': 'scala',
+            'html': 'html',
+            'markdown': 'markdown',
+            'md': 'markdown',
+            'latex': 'latex',
+            'tex': 'latex',
+            'solidity': 'sol',
+            'sol': 'sol',
+        };
+        return languageMap[language.toLowerCase()] || null;
+    }
+    async fallbackSplit(code, language, filePath) {
+        // Generic splitter as fallback
+        const splitter = new text_splitter_1.RecursiveCharacterTextSplitter({
+            chunkSize: this.chunkSize,
+            chunkOverlap: this.chunkOverlap,
+        });
+        const documents = await splitter.createDocuments([code]);
+        return documents.map((doc, index) => {
+            const lines = this.estimateLines(doc.pageContent, code);
+            return {
+                content: doc.pageContent,
+                metadata: {
+                    startLine: lines.start,
+                    endLine: lines.end,
+                    language,
+                    filePath,
+                },
+            };
+        });
+    }
+    estimateLines(chunk, originalCode) {
+        // Simple line number estimation
+        const codeLines = originalCode.split('\n');
+        const chunkLines = chunk.split('\n');
+        // Find chunk position in original code
+        const chunkStart = originalCode.indexOf(chunk);
+        if (chunkStart === -1) {
+            return { start: 1, end: chunkLines.length };
+        }
+        const beforeChunk = originalCode.substring(0, chunkStart);
+        const startLine = beforeChunk.split('\n').length;
+        const endLine = startLine + chunkLines.length - 1;
+        return { start: startLine, end: endLine };
+    }
+}
+exports.LangChainCodeSplitter = LangChainCodeSplitter;
+//# sourceMappingURL=langchain-splitter.js.map

package/dist/splitter/langchain-splitter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"langchain-splitter.js","sourceRoot":"","sources":["../../src/splitter/langchain-splitter.ts"],"names":[],"mappings":"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"}

package/dist/sync/merkle.d.ts

@@ -0,0 +1,26 @@
+export interface MerkleDAGNode {
+    id: string;
+    hash: string;
+    data: string;
+    parents: string[];
+    children: string[];
+}
+export declare class MerkleDAG {
+    nodes: Map<string, MerkleDAGNode>;
+    rootIds: string[];
+    constructor();
+    private hash;
+    addNode(data: string, parentId?: string): string;
+    getNode(nodeId: string): MerkleDAGNode | undefined;
+    getAllNodes(): MerkleDAGNode[];
+    getRootNodes(): MerkleDAGNode[];
+    getLeafNodes(): MerkleDAGNode[];
+    serialize(): any;
+    static deserialize(data: any): MerkleDAG;
+    static compare(dag1: MerkleDAG, dag2: MerkleDAG): {
+        added: string[];
+        removed: string[];
+        modified: string[];
+    };
+}
+//# sourceMappingURL=merkle.d.ts.map

package/dist/sync/merkle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merkle.d.ts","sourceRoot":"","sources":["../../src/sync/merkle.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,aAAa;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,QAAQ,EAAE,MAAM,EAAE,CAAC;CACtB;AAED,qBAAa,SAAS;IAClB,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;IAClC,OAAO,EAAE,MAAM,EAAE,CAAC;;IAOlB,OAAO,CAAC,IAAI;IAIL,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM;IA2BhD,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,aAAa,GAAG,SAAS;IAIlD,WAAW,IAAI,aAAa,EAAE;IAI9B,YAAY,IAAI,aAAa,EAAE;IAI/B,YAAY,IAAI,aAAa,EAAE;IAI/B,SAAS,IAAI,GAAG;WAOT,WAAW,CAAC,IAAI,EAAE,GAAG,GAAG,SAAS;WAOjC,OAAO,CAAC,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,SAAS,GAAG;QAAE,KAAK,EAAE,MAAM,EAAE,CAAC;QAAC,OAAO,EAAE,MAAM,EAAE,CAAC;QAAC,QAAQ,EAAE,MAAM,EAAE,CAAA;KAAE;CAkBtH"}

package/dist/sync/merkle.js

@@ -0,0 +1,112 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MerkleDAG = void 0;
+const crypto = __importStar(require("crypto"));
+class MerkleDAG {
+    constructor() {
+        this.nodes = new Map();
+        this.rootIds = [];
+    }
+    hash(data) {
+        return crypto.createHash('sha256').update(data).digest('hex');
+    }
+    addNode(data, parentId) {
+        const nodeId = this.hash(data);
+        const node = {
+            id: nodeId,
+            hash: nodeId,
+            data,
+            parents: [],
+            children: []
+        };
+        // If there's a parent, create the relationship
+        if (parentId) {
+            const parentNode = this.nodes.get(parentId);
+            if (parentNode) {
+                node.parents.push(parentId);
+                parentNode.children.push(nodeId);
+                this.nodes.set(parentId, parentNode);
+            }
+        }
+        else {
+            // If no parent, it's a root node
+            this.rootIds.push(nodeId);
+        }
+        this.nodes.set(nodeId, node);
+        return nodeId;
+    }
+    getNode(nodeId) {
+        return this.nodes.get(nodeId);
+    }
+    getAllNodes() {
+        return Array.from(this.nodes.values());
+    }
+    getRootNodes() {
+        return this.rootIds.map(id => this.nodes.get(id)).filter(Boolean);
+    }
+    getLeafNodes() {
+        return Array.from(this.nodes.values()).filter(node => node.children.length === 0);
+    }
+    serialize() {
+        return {
+            nodes: Array.from(this.nodes.entries()),
+            rootIds: this.rootIds
+        };
+    }
+    static deserialize(data) {
+        const dag = new MerkleDAG();
+        dag.nodes = new Map(data.nodes);
+        dag.rootIds = data.rootIds;
+        return dag;
+    }
+    static compare(dag1, dag2) {
+        const nodes1 = new Map(Array.from(dag1.getAllNodes()).map(n => [n.id, n]));
+        const nodes2 = new Map(Array.from(dag2.getAllNodes()).map(n => [n.id, n]));
+        const added = Array.from(nodes2.keys()).filter(k => !nodes1.has(k));
+        const removed = Array.from(nodes1.keys()).filter(k => !nodes2.has(k));
+        // For modified, we'll check if the data has changed for nodes that exist in both
+        const modified = [];
+        for (const [id, node1] of Array.from(nodes1.entries())) {
+            const node2 = nodes2.get(id);
+            if (node2 && node1.data !== node2.data) {
+                modified.push(id);
+            }
+        }
+        return { added, removed, modified };
+    }
+}
+exports.MerkleDAG = MerkleDAG;
+//# sourceMappingURL=merkle.js.map

package/dist/sync/merkle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"merkle.js","sourceRoot":"","sources":["../../src/sync/merkle.ts"],"names":[],"mappings":"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"}

package/dist/sync/synchronizer.d.ts

@@ -0,0 +1,30 @@
+export declare class FileSynchronizer {
+    private fileHashes;
+    private merkleDAG;
+    private rootDir;
+    private snapshotPath;
+    private ignorePatterns;
+    constructor(rootDir: string, ignorePatterns?: string[]);
+    private getSnapshotPath;
+    private hashFile;
+    private generateFileHashes;
+    private shouldIgnore;
+    private matchPattern;
+    private simpleGlobMatch;
+    private buildMerkleDAG;
+    initialize(): Promise<void>;
+    checkForChanges(): Promise<{
+        added: string[];
+        removed: string[];
+        modified: string[];
+    }>;
+    private compareStates;
+    getFileHash(filePath: string): string | undefined;
+    private saveSnapshot;
+    private loadSnapshot;
+    /**
+     * Delete snapshot file for a given codebase path
+     */
+    static deleteSnapshot(codebasePath: string): Promise<void>;
+}
+//# sourceMappingURL=synchronizer.d.ts.map

package/dist/sync/synchronizer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"synchronizer.d.ts","sourceRoot":"","sources":["../../src/sync/synchronizer.ts"],"names":[],"mappings":"AAMA,qBAAa,gBAAgB;IACzB,OAAO,CAAC,UAAU,CAAsB;IACxC,OAAO,CAAC,SAAS,CAAY;IAC7B,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,cAAc,CAAW;gBAErB,OAAO,EAAE,MAAM,EAAE,cAAc,GAAE,MAAM,EAAO;IAQ1D,OAAO,CAAC,eAAe;YAUT,QAAQ;YAUR,kBAAkB;IAwDhC,OAAO,CAAC,YAAY;IAwDpB,OAAO,CAAC,YAAY;IA6BpB,OAAO,CAAC,eAAe;IAYvB,OAAO,CAAC,cAAc;IAsBT,UAAU;IAOV,eAAe,IAAI,OAAO,CAAC;QAAE,KAAK,EAAE,MAAM,EAAE,CAAC;QAAC,OAAO,EAAE,MAAM,EAAE,CAAC;QAAC,QAAQ,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;IA0BnG,OAAO,CAAC,aAAa;IA0Bd,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;YAI1C,YAAY;YAmBZ,YAAY;IA2B1B;;OAEG;WACU,cAAc,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAmBnE"}

package/dist/sync/synchronizer.js

@@ -0,0 +1,339 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileSynchronizer = void 0;
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const crypto = __importStar(require("crypto"));
+const merkle_1 = require("./merkle");
+const os = __importStar(require("os"));
+class FileSynchronizer {
+    constructor(rootDir, ignorePatterns = []) {
+        this.rootDir = rootDir;
+        this.snapshotPath = this.getSnapshotPath(rootDir);
+        this.fileHashes = new Map();
+        this.merkleDAG = new merkle_1.MerkleDAG();
+        this.ignorePatterns = ignorePatterns;
+    }
+    getSnapshotPath(codebasePath) {
+        const homeDir = os.homedir();
+        const merkleDir = path.join(homeDir, '.context', 'merkle');
+        const normalizedPath = path.resolve(codebasePath);
+        const hash = crypto.createHash('md5').update(normalizedPath).digest('hex');
+        return path.join(merkleDir, `${hash}.json`);
+    }
+    async hashFile(filePath) {
+        // Double-check that this is actually a file, not a directory
+        const stat = await fs.stat(filePath);
+        if (stat.isDirectory()) {
+            throw new Error(`Attempted to hash a directory: ${filePath}`);
+        }
+        const content = await fs.readFile(filePath, 'utf-8');
+        return crypto.createHash('sha256').update(content).digest('hex');
+    }
+    async generateFileHashes(dir) {
+        const fileHashes = new Map();
+        let entries;
+        try {
+            entries = await fs.readdir(dir, { withFileTypes: true });
+        }
+        catch (error) {
+            console.warn(`[Synchronizer] Cannot read directory ${dir}: ${error.message}`);
+            return fileHashes;
+        }
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            const relativePath = path.relative(this.rootDir, fullPath);
+            // Check if this path should be ignored BEFORE any file system operations
+            if (this.shouldIgnore(relativePath, entry.isDirectory())) {
+                continue; // Skip completely - no access at all
+            }
+            // Double-check with fs.stat to be absolutely sure about file type
+            let stat;
+            try {
+                stat = await fs.stat(fullPath);
+            }
+            catch (error) {
+                console.warn(`[Synchronizer] Cannot stat ${fullPath}: ${error.message}`);
+                continue;
+            }
+            if (stat.isDirectory()) {
+                // Verify it's really a directory and not ignored
+                if (!this.shouldIgnore(relativePath, true)) {
+                    const subHashes = await this.generateFileHashes(fullPath);
+                    const entries = Array.from(subHashes.entries());
+                    for (let i = 0; i < entries.length; i++) {
+                        const [p, h] = entries[i];
+                        fileHashes.set(p, h);
+                    }
+                }
+            }
+            else if (stat.isFile()) {
+                // Verify it's really a file and not ignored
+                if (!this.shouldIgnore(relativePath, false)) {
+                    try {
+                        const hash = await this.hashFile(fullPath);
+                        fileHashes.set(relativePath, hash);
+                    }
+                    catch (error) {
+                        console.warn(`[Synchronizer] Cannot hash file ${fullPath}: ${error.message}`);
+                        continue;
+                    }
+                }
+            }
+            // Skip other types (symlinks, etc.)
+        }
+        return fileHashes;
+    }
+    shouldIgnore(relativePath, isDirectory = false) {
+        // Always ignore hidden files and directories (starting with .)
+        const pathParts = relativePath.split(path.sep);
+        if (pathParts.some(part => part.startsWith('.'))) {
+            return true;
+        }
+        if (this.ignorePatterns.length === 0) {
+            return false;
+        }
+        // Normalize path separators and remove leading/trailing slashes
+        const normalizedPath = relativePath.replace(/\\/g, '/').replace(/^\/+|\/+$/g, '');
+        if (!normalizedPath) {
+            return false; // Don't ignore root
+        }
+        // Check direct pattern matches first
+        for (const pattern of this.ignorePatterns) {
+            if (this.matchPattern(normalizedPath, pattern, isDirectory)) {
+                return true;
+            }
+        }
+        // Check if any parent directory is ignored
+        const normalizedPathParts = normalizedPath.split('/');
+        for (let i = 0; i < normalizedPathParts.length; i++) {
+            const partialPath = normalizedPathParts.slice(0, i + 1).join('/');
+            for (const pattern of this.ignorePatterns) {
+                // Check directory patterns
+                if (pattern.endsWith('/')) {
+                    const dirPattern = pattern.slice(0, -1);
+                    if (this.simpleGlobMatch(partialPath, dirPattern) ||
+                        this.simpleGlobMatch(normalizedPathParts[i], dirPattern)) {
+                        return true;
+                    }
+                }
+                // Check exact path patterns
+                else if (pattern.includes('/')) {
+                    if (this.simpleGlobMatch(partialPath, pattern)) {
+                        return true;
+                    }
+                }
+                // Check filename patterns against any path component
+                else {
+                    if (this.simpleGlobMatch(normalizedPathParts[i], pattern)) {
+                        return true;
+                    }
+                }
+            }
+        }
+        return false;
+    }
+    matchPattern(filePath, pattern, isDirectory = false) {
+        // Clean both path and pattern
+        const cleanPath = filePath.replace(/^\/+|\/+$/g, '');
+        const cleanPattern = pattern.replace(/^\/+|\/+$/g, '');
+        if (!cleanPath || !cleanPattern) {
+            return false;
+        }
+        // Handle directory patterns (ending with /)
+        if (pattern.endsWith('/')) {
+            if (!isDirectory)
+                return false; // Directory pattern only matches directories
+            const dirPattern = cleanPattern.slice(0, -1);
+            // Direct match or any path component matches
+            return this.simpleGlobMatch(cleanPath, dirPattern) ||
+                cleanPath.split('/').some(part => this.simpleGlobMatch(part, dirPattern));
+        }
+        // Handle path patterns (containing /)
+        if (cleanPattern.includes('/')) {
+            return this.simpleGlobMatch(cleanPath, cleanPattern);
+        }
+        // Handle filename patterns (no /) - match against basename
+        const fileName = path.basename(cleanPath);
+        return this.simpleGlobMatch(fileName, cleanPattern);
+    }
+    simpleGlobMatch(text, pattern) {
+        if (!text || !pattern)
+            return false;
+        // Convert glob pattern to regex
+        const regexPattern = pattern
+            .replace(/[.+^${}()|[\]\\]/g, '\\$&') // Escape regex special chars except *
+            .replace(/\*/g, '.*'); // Convert * to .*
+        const regex = new RegExp(`^${regexPattern}$`);
+        return regex.test(text);
+    }
+    buildMerkleDAG(fileHashes) {
+        const dag = new merkle_1.MerkleDAG();
+        const keys = Array.from(fileHashes.keys());
+        const sortedPaths = keys.slice().sort(); // Create a sorted copy
+        // Create a root node for the entire directory
+        let valuesString = "";
+        keys.forEach(key => {
+            valuesString += fileHashes.get(key);
+        });
+        const rootNodeData = "root:" + valuesString;
+        const rootNodeId = dag.addNode(rootNodeData);
+        // Add each file as a child of the root
+        for (const path of sortedPaths) {
+            const fileData = path + ":" + fileHashes.get(path);
+            dag.addNode(fileData, rootNodeId);
+        }
+        return dag;
+    }
+    async initialize() {
+        console.log(`Initializing file synchronizer for ${this.rootDir}`);
+        await this.loadSnapshot();
+        this.merkleDAG = this.buildMerkleDAG(this.fileHashes);
+        console.log(`[Synchronizer] File synchronizer initialized. Loaded ${this.fileHashes.size} file hashes.`);
+    }
+    async checkForChanges() {
+        console.log('[Synchronizer] Checking for file changes...');
+        const newFileHashes = await this.generateFileHashes(this.rootDir);
+        const newMerkleDAG = this.buildMerkleDAG(newFileHashes);
+        // Compare the DAGs
+        const changes = merkle_1.MerkleDAG.compare(this.merkleDAG, newMerkleDAG);
+        // If there are any changes in the DAG, we should also do a file-level comparison
+        if (changes.added.length > 0 || changes.removed.length > 0 || changes.modified.length > 0) {
+            console.log('[Synchronizer] Merkle DAG has changed. Comparing file states...');
+            const fileChanges = this.compareStates(this.fileHashes, newFileHashes);
+            this.fileHashes = newFileHashes;
+            this.merkleDAG = newMerkleDAG;
+            await this.saveSnapshot();
+            console.log(`[Synchronizer] Found changes: ${fileChanges.added.length} added, ${fileChanges.removed.length} removed, ${fileChanges.modified.length} modified.`);
+            return fileChanges;
+        }
+        console.log('[Synchronizer] No changes detected based on Merkle DAG comparison.');
+        return { added: [], removed: [], modified: [] };
+    }
+    compareStates(oldHashes, newHashes) {
+        const added = [];
+        const removed = [];
+        const modified = [];
+        const newEntries = Array.from(newHashes.entries());
+        for (let i = 0; i < newEntries.length; i++) {
+            const [file, hash] = newEntries[i];
+            if (!oldHashes.has(file)) {
+                added.push(file);
+            }
+            else if (oldHashes.get(file) !== hash) {
+                modified.push(file);
+            }
+        }
+        const oldKeys = Array.from(oldHashes.keys());
+        for (let i = 0; i < oldKeys.length; i++) {
+            const file = oldKeys[i];
+            if (!newHashes.has(file)) {
+                removed.push(file);
+            }
+        }
+        return { added, removed, modified };
+    }
+    getFileHash(filePath) {
+        return this.fileHashes.get(filePath);
+    }
+    async saveSnapshot() {
+        const merkleDir = path.dirname(this.snapshotPath);
+        await fs.mkdir(merkleDir, { recursive: true });
+        // Convert Map to array without using iterator
+        const fileHashesArray = [];
+        const keys = Array.from(this.fileHashes.keys());
+        keys.forEach(key => {
+            fileHashesArray.push([key, this.fileHashes.get(key)]);
+        });
+        const data = JSON.stringify({
+            fileHashes: fileHashesArray,
+            merkleDAG: this.merkleDAG.serialize()
+        });
+        await fs.writeFile(this.snapshotPath, data, 'utf-8');
+        console.log(`Saved snapshot to ${this.snapshotPath}`);
+    }
+    async loadSnapshot() {
+        try {
+            const data = await fs.readFile(this.snapshotPath, 'utf-8');
+            const obj = JSON.parse(data);
+            // Reconstruct Map without using constructor with iterator
+            this.fileHashes = new Map();
+            for (const [key, value] of obj.fileHashes) {
+                this.fileHashes.set(key, value);
+            }
+            if (obj.merkleDAG) {
+                this.merkleDAG = merkle_1.MerkleDAG.deserialize(obj.merkleDAG);
+            }
+            console.log(`Loaded snapshot from ${this.snapshotPath}`);
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                console.log(`Snapshot file not found at ${this.snapshotPath}. Generating new one.`);
+                this.fileHashes = await this.generateFileHashes(this.rootDir);
+                this.merkleDAG = this.buildMerkleDAG(this.fileHashes);
+                await this.saveSnapshot();
+            }
+            else {
+                throw error;
+            }
+        }
+    }
+    /**
+     * Delete snapshot file for a given codebase path
+     */
+    static async deleteSnapshot(codebasePath) {
+        const homeDir = os.homedir();
+        const merkleDir = path.join(homeDir, '.context', 'merkle');
+        const normalizedPath = path.resolve(codebasePath);
+        const hash = crypto.createHash('md5').update(normalizedPath).digest('hex');
+        const snapshotPath = path.join(merkleDir, `${hash}.json`);
+        try {
+            await fs.unlink(snapshotPath);
+            console.log(`Deleted snapshot file: ${snapshotPath}`);
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                console.log(`Snapshot file not found (already deleted): ${snapshotPath}`);
+            }
+            else {
+                console.error(`[Synchronizer] Failed to delete snapshot file ${snapshotPath}:`, error.message);
+                throw error; // Re-throw non-ENOENT errors
+            }
+        }
+    }
+}
+exports.FileSynchronizer = FileSynchronizer;
+//# sourceMappingURL=synchronizer.js.map