@zokizuan/satori-core 0.2.0 → 1.1.0

package/dist/sync/synchronizer.js

@@ -37,98 +37,113 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FileSynchronizer = void 0;
-const fs = __importStar(require("fs/promises"));
+const fsp = __importStar(require("fs/promises"));
+const fsSync = __importStar(require("fs"));
+const fs_1 = require("fs");
 const path = __importStar(require("path"));
 const crypto = __importStar(require("crypto"));
-const merkle_1 = require("./merkle");
 const os = __importStar(require("os"));
 const ignore_1 = __importDefault(require("ignore"));
+const merkle_1 = require("./merkle");
+const SNAPSHOT_VERSION = 2;
+const DEFAULT_HASH_CONCURRENCY = 16;
 class FileSynchronizer {
     constructor(rootDir, ignorePatterns = []) {
-        this.rootDir = rootDir;
-        this.snapshotPath = this.getSnapshotPath(rootDir);
+        this.rootDir = FileSynchronizer.canonicalizeSnapshotIdentityPath(rootDir);
+        this.snapshotPath = FileSynchronizer.getSnapshotPathForCodebase(this.rootDir);
         this.fileHashes = new Map();
-        this.merkleDAG = new merkle_1.MerkleDAG();
+        this.fileStats = new Map();
+        this.merkleRoot = '';
         this.ignorePatterns = ignorePatterns;
         this.ignoreMatcher = (0, ignore_1.default)();
         this.ignoreMatcher.add(this.ignorePatterns);
+        this.partialScan = false;
+        this.unscannedDirPrefixes = [];
+        this.fullHashCounter = 0;
+    }
+    static canonicalizeSnapshotIdentityPath(codebasePath) {
+        const resolved = path.resolve(codebasePath);
+        try {
+            const realPath = typeof fsSync.realpathSync.native === 'function'
+                ? fsSync.realpathSync.native(resolved)
+                : fsSync.realpathSync(resolved);
+            return FileSynchronizer.trimTrailingSeparators(path.normalize(realPath));
+        }
+        catch {
+            return FileSynchronizer.trimTrailingSeparators(path.normalize(resolved));
+        }
     }
-    getSnapshotPath(codebasePath) {
+    static snapshotPathFromCanonicalPath(canonicalPath) {
         const homeDir = os.homedir();
         const merkleDir = path.join(homeDir, '.satori', 'merkle');
-        const normalizedPath = path.resolve(codebasePath);
-        const hash = crypto.createHash('md5').update(normalizedPath).digest('hex');
+        const hash = crypto.createHash('md5').update(canonicalPath).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');
+    static getSnapshotPathForCodebase(codebasePath) {
+        const canonicalPath = FileSynchronizer.canonicalizeSnapshotIdentityPath(codebasePath);
+        return FileSynchronizer.snapshotPathFromCanonicalPath(canonicalPath);
     }
-    async generateFileHashes(dir) {
-        const fileHashes = new Map();
-        let entries;
-        try {
-            entries = await fs.readdir(dir, { withFileTypes: true });
+    static trimTrailingSeparators(inputPath) {
+        const parsedRoot = path.parse(inputPath).root;
+        if (inputPath === parsedRoot) {
+            return inputPath;
         }
-        catch (error) {
-            console.warn(`[Synchronizer] Cannot read directory ${dir}: ${error.message}`);
-            return fileHashes;
+        return inputPath.replace(/[\\/]+$/, '');
+    }
+    normalizeRelPath(candidatePath) {
+        if (typeof candidatePath !== 'string') {
+            return '';
         }
-        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}`);
+        const trimmed = candidatePath.trim();
+        if (!trimmed) {
+            return '';
+        }
+        let normalized = trimmed.replace(/\\/g, '/');
+        normalized = normalized.replace(/\/+/g, '/');
+        normalized = normalized.replace(/^(\.\/)+/, '');
+        normalized = normalized.replace(/^\/+/, '');
+        normalized = normalized.replace(/\/+$/, '');
+        if (!normalized || normalized === '.') {
+            return '';
+        }
+        const parts = normalized.split('/');
+        const cleanParts = [];
+        for (const part of parts) {
+            if (!part || part === '.') {
                 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);
-                    }
-                }
+            if (part === '..') {
+                return '';
             }
-            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;
-                    }
-                }
+            cleanParts.push(part);
+        }
+        if (cleanParts.length === 0) {
+            return '';
+        }
+        return cleanParts.join('/');
+    }
+    isPathWithinPrefix(candidatePath, prefix) {
+        return candidatePath === prefix || candidatePath.startsWith(`${prefix}/`);
+    }
+    normalizeAndCompressPrefixes(prefixes) {
+        const normalized = Array.from(prefixes)
+            .map((prefix) => this.normalizeRelPath(prefix))
+            .filter((prefix) => prefix.length > 0)
+            .sort();
+        const compressed = [];
+        for (const prefix of normalized) {
+            const covered = compressed.some((existingPrefix) => this.isPathWithinPrefix(prefix, existingPrefix));
+            if (!covered) {
+                compressed.push(prefix);
             }
-            // Skip other types (symlinks, etc.)
         }
-        return fileHashes;
+        return compressed;
     }
     shouldIgnore(relativePath, isDirectory = false) {
-        const normalizedPath = relativePath.replace(/\\/g, '/').replace(/^\/+|\/+$/g, '');
-        if (!normalizedPath || normalizedPath === '.') {
-            return false; // Don't ignore root
+        const normalizedPath = this.normalizeRelPath(relativePath);
+        if (!normalizedPath) {
+            return false;
         }
-        // Always ignore hidden files and directories (starting with .)
         const pathParts = normalizedPath.split('/');
         if (pathParts.some(part => part.startsWith('.'))) {
             return true;
@@ -142,135 +157,408 @@ class FileSynchronizer {
         }
         return this.ignoreMatcher.ignores(normalizedPath);
     }
-    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);
+    parsePositiveInt(rawValue, fallback, min, max) {
+        if (!rawValue || rawValue.trim().length === 0) {
+            return fallback;
+        }
+        const parsed = Number.parseInt(rawValue, 10);
+        if (!Number.isFinite(parsed) || Number.isNaN(parsed)) {
+            return fallback;
+        }
+        if (parsed < min) {
+            return min;
+        }
+        if (parsed > max) {
+            return max;
+        }
+        return parsed;
+    }
+    getHashConcurrency() {
+        return this.parsePositiveInt(process.env.SATORI_SYNC_HASH_CONCURRENCY, DEFAULT_HASH_CONCURRENCY, 1, 64);
+    }
+    getFullHashInterval() {
+        return this.parsePositiveInt(process.env.SATORI_SYNC_FULL_HASH_EVERY_N, 0, 0, 1000000);
+    }
+    async hashFileBytes(filePath) {
+        const stat = await fsp.stat(filePath);
+        if (!stat.isFile()) {
+            throw new Error(`Attempted to hash non-file path: ${filePath}`);
+        }
+        return new Promise((resolve, reject) => {
+            const hasher = crypto.createHash('sha256');
+            const stream = (0, fs_1.createReadStream)(filePath);
+            stream.on('data', (chunk) => {
+                hasher.update(chunk);
+            });
+            stream.on('error', reject);
+            stream.on('end', () => {
+                resolve(hasher.digest('hex'));
+            });
         });
-        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.`);
+    isSignatureEqual(a, b) {
+        return !!a && a.size === b.size && a.mtimeMs === b.mtimeMs && a.ctimeMs === b.ctimeMs;
     }
-    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;
+    async scanDirectory(directoryPath, previousHashes, previousStats, forceFullHash, result) {
+        let entries;
+        try {
+            entries = await fsp.readdir(directoryPath, { withFileTypes: true });
+        }
+        catch (error) {
+            if (directoryPath === this.rootDir) {
+                throw new Error(`[Synchronizer] Cannot read root directory ${directoryPath}: ${error.message}`);
+            }
+            const relativeDir = this.normalizeRelPath(path.relative(this.rootDir, directoryPath));
+            if (relativeDir) {
+                result.unscannedDirPrefixes.add(relativeDir);
+            }
+            console.warn(`[Synchronizer] Cannot read directory ${directoryPath}: ${error.message}`);
+            return;
+        }
+        entries.sort((a, b) => a.name.localeCompare(b.name));
+        for (const entry of entries) {
+            const absolutePath = path.join(directoryPath, entry.name);
+            const relativePath = this.normalizeRelPath(path.relative(this.rootDir, absolutePath));
+            if (!relativePath) {
+                continue;
+            }
+            if (this.shouldIgnore(relativePath, entry.isDirectory())) {
+                continue;
+            }
+            let stat;
+            try {
+                stat = await fsp.stat(absolutePath);
+            }
+            catch (error) {
+                if (entry.isDirectory()) {
+                    result.unscannedDirPrefixes.add(relativePath);
+                }
+                else {
+                    result.unreadableFiles.add(relativePath);
+                }
+                console.warn(`[Synchronizer] Cannot stat ${absolutePath}: ${error.message}`);
+                continue;
+            }
+            if (stat.isDirectory()) {
+                if (!this.shouldIgnore(relativePath, true)) {
+                    await this.scanDirectory(absolutePath, previousHashes, previousStats, forceFullHash, result);
+                }
+                continue;
+            }
+            if (!stat.isFile()) {
+                continue;
+            }
+            if (this.shouldIgnore(relativePath, false)) {
+                continue;
+            }
+            const signature = {
+                size: stat.size,
+                mtimeMs: Number(stat.mtimeMs),
+                ctimeMs: Number(stat.ctimeMs)
+            };
+            result.scannedStats.set(relativePath, signature);
+            const previousSignature = previousStats.get(relativePath);
+            const previousHash = previousHashes.get(relativePath);
+            const canReuseHash = !forceFullHash
+                && this.isSignatureEqual(previousSignature, signature)
+                && typeof previousHash === 'string';
+            if (canReuseHash) {
+                result.scannedHashes.set(relativePath, previousHash);
+                continue;
+            }
+            result.hashCandidates.push({ relativePath, absolutePath, signature });
+        }
+    }
+    async hashCandidatesWithConcurrency(result) {
+        if (result.hashCandidates.length === 0) {
+            return 0;
+        }
+        const concurrency = this.getHashConcurrency();
+        let cursor = 0;
+        let hashedCount = 0;
+        const workers = Array.from({ length: Math.min(concurrency, result.hashCandidates.length) }).map(async () => {
+            while (true) {
+                const currentIndex = cursor;
+                cursor += 1;
+                if (currentIndex >= result.hashCandidates.length) {
+                    return;
+                }
+                const candidate = result.hashCandidates[currentIndex];
+                try {
+                    const hash = await this.hashFileBytes(candidate.absolutePath);
+                    result.scannedHashes.set(candidate.relativePath, hash);
+                    hashedCount += 1;
+                }
+                catch (error) {
+                    result.unreadableFiles.add(candidate.relativePath);
+                    result.scannedStats.delete(candidate.relativePath);
+                    console.warn(`[Synchronizer] Cannot hash file ${candidate.absolutePath}: ${error.message}`);
+                }
+            }
+        });
+        await Promise.all(workers);
+        return hashedCount;
+    }
+    buildEffectiveState(previousHashes, previousStats, result) {
+        const unscannedDirPrefixes = this.normalizeAndCompressPrefixes(result.unscannedDirPrefixes);
+        const partialScan = unscannedDirPrefixes.length > 0 || result.unreadableFiles.size > 0;
+        const effectiveHashes = new Map();
+        const effectiveStats = new Map();
+        for (const [relativePath, hash] of result.scannedHashes.entries()) {
+            effectiveHashes.set(relativePath, hash);
+        }
+        for (const [relativePath, signature] of result.scannedStats.entries()) {
+            effectiveStats.set(relativePath, signature);
+        }
+        const shouldPreservePrevious = (relativePath) => {
+            if (result.unreadableFiles.has(relativePath)) {
+                return true;
+            }
+            return unscannedDirPrefixes.some((prefix) => this.isPathWithinPrefix(relativePath, prefix));
+        };
+        for (const [relativePath, previousHash] of previousHashes.entries()) {
+            if (effectiveHashes.has(relativePath)) {
+                continue;
+            }
+            if (!shouldPreservePrevious(relativePath)) {
+                continue;
+            }
+            if (this.shouldIgnore(relativePath, false)) {
+                continue;
+            }
+            effectiveHashes.set(relativePath, previousHash);
+            const previousSignature = previousStats.get(relativePath);
+            if (previousSignature) {
+                effectiveStats.set(relativePath, previousSignature);
+            }
         }
-        console.log('[Synchronizer] No changes detected based on Merkle DAG comparison.');
-        return { added: [], removed: [], modified: [] };
+        for (const relativePath of Array.from(effectiveHashes.keys())) {
+            if (this.shouldIgnore(relativePath, false)) {
+                effectiveHashes.delete(relativePath);
+                effectiveStats.delete(relativePath);
+            }
+        }
+        return {
+            fileHashes: effectiveHashes,
+            fileStats: effectiveStats,
+            unscannedDirPrefixes,
+            partialScan
+        };
     }
     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);
+        for (const [filePath, hash] of newHashes.entries()) {
+            const previousHash = oldHashes.get(filePath);
+            if (typeof previousHash === 'undefined') {
+                added.push(filePath);
+                continue;
             }
-            else if (oldHashes.get(file) !== hash) {
-                modified.push(file);
+            if (previousHash !== hash) {
+                modified.push(filePath);
             }
         }
-        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);
+        for (const filePath of oldHashes.keys()) {
+            if (!newHashes.has(filePath)) {
+                removed.push(filePath);
             }
         }
+        added.sort();
+        removed.sort();
+        modified.sort();
         return { added, removed, modified };
     }
-    getFileHash(filePath) {
-        return this.fileHashes.get(filePath);
-    }
-    /**
-     * Return tracked (currently considered indexable) relative file paths.
-     * This reflects the synchronizer snapshot under the active ignore rules.
-     */
-    getTrackedRelativePaths() {
-        return Array.from(this.fileHashes.keys()).sort();
+    arraysEqual(a, b) {
+        if (a.length !== b.length) {
+            return false;
+        }
+        for (let i = 0; i < a.length; i += 1) {
+            if (a[i] !== b[i]) {
+                return false;
+            }
+        }
+        return true;
     }
     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');
+        await fsp.mkdir(merkleDir, { recursive: true });
+        const fileHashes = Array.from(this.fileHashes.entries()).sort(([a], [b]) => a.localeCompare(b));
+        const fileStats = Array.from(this.fileStats.entries()).sort(([a], [b]) => a.localeCompare(b));
+        const payload = {
+            snapshotVersion: SNAPSHOT_VERSION,
+            fileHashes,
+            fileStats,
+            merkleRoot: this.merkleRoot,
+            partialScan: this.partialScan,
+            unscannedDirPrefixes: [...this.unscannedDirPrefixes],
+            fullHashCounter: this.fullHashCounter
+        };
+        await fsp.writeFile(this.snapshotPath, JSON.stringify(payload), 'utf-8');
         console.log(`Saved snapshot to ${this.snapshotPath}`);
     }
     async loadSnapshot() {
         try {
-            const data = await fs.readFile(this.snapshotPath, 'utf-8');
+            const data = await fsp.readFile(this.snapshotPath, 'utf-8');
             const obj = JSON.parse(data);
-            // Reconstruct Map without using constructor with iterator
+            const rawFileHashes = Array.isArray(obj.fileHashes) ? obj.fileHashes : [];
             this.fileHashes = new Map();
-            for (const [key, value] of obj.fileHashes) {
-                this.fileHashes.set(key, value);
+            for (const entry of rawFileHashes) {
+                if (!Array.isArray(entry) || entry.length !== 2) {
+                    continue;
+                }
+                const normalizedPath = this.normalizeRelPath(String(entry[0] ?? ''));
+                const hash = String(entry[1] ?? '');
+                if (!normalizedPath || !hash) {
+                    continue;
+                }
+                this.fileHashes.set(normalizedPath, hash);
             }
-            if (obj.merkleDAG) {
-                this.merkleDAG = merkle_1.MerkleDAG.deserialize(obj.merkleDAG);
+            const rawFileStats = Array.isArray(obj.fileStats) ? obj.fileStats : [];
+            this.fileStats = new Map();
+            for (const entry of rawFileStats) {
+                if (!Array.isArray(entry) || entry.length !== 2) {
+                    continue;
+                }
+                const normalizedPath = this.normalizeRelPath(String(entry[0] ?? ''));
+                const rawSignature = entry[1];
+                if (!normalizedPath || !rawSignature) {
+                    continue;
+                }
+                const size = Number(rawSignature.size);
+                const mtimeMs = Number(rawSignature.mtimeMs);
+                const ctimeMs = Number(rawSignature.ctimeMs ?? rawSignature.mtimeMs);
+                if (!Number.isFinite(size) || !Number.isFinite(mtimeMs) || !Number.isFinite(ctimeMs)) {
+                    continue;
+                }
+                this.fileStats.set(normalizedPath, {
+                    size,
+                    mtimeMs,
+                    ctimeMs
+                });
+            }
+            this.merkleRoot = typeof obj.merkleRoot === 'string' ? obj.merkleRoot : '';
+            this.partialScan = Boolean(obj.partialScan);
+            this.unscannedDirPrefixes = this.normalizeAndCompressPrefixes(new Set(Array.isArray(obj.unscannedDirPrefixes) ? obj.unscannedDirPrefixes : []));
+            this.fullHashCounter = Number.isFinite(Number(obj.fullHashCounter)) ? Number(obj.fullHashCounter) : 0;
+            const isV2 = obj.snapshotVersion === SNAPSHOT_VERSION;
+            const hasCompatibleStats = this.fileStats.size > 0 || this.fileHashes.size === 0;
+            const migrated = !isV2 || !hasCompatibleStats;
+            if (migrated) {
+                console.log(`Loaded legacy snapshot from ${this.snapshotPath}. Migration to v${SNAPSHOT_VERSION} required.`);
+            }
+            else {
+                console.log(`Loaded snapshot from ${this.snapshotPath}`);
             }
-            console.log(`Loaded snapshot from ${this.snapshotPath}`);
+            return { migrated };
         }
         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;
+                console.log(`Snapshot file not found at ${this.snapshotPath}. Creating baseline snapshot.`);
+                this.fileHashes = new Map();
+                this.fileStats = new Map();
+                this.merkleRoot = '';
+                this.partialScan = false;
+                this.unscannedDirPrefixes = [];
+                this.fullHashCounter = 0;
+                return { migrated: true };
             }
+            throw error;
+        }
+    }
+    async scanCurrentState(previousHashes, previousStats, forceFullHash) {
+        const scanResult = {
+            scannedHashes: new Map(),
+            scannedStats: new Map(),
+            hashCandidates: [],
+            unreadableFiles: new Set(),
+            unscannedDirPrefixes: new Set()
+        };
+        await this.scanDirectory(this.rootDir, previousHashes, previousStats, forceFullHash, scanResult);
+        const hashedCount = await this.hashCandidatesWithConcurrency(scanResult);
+        const effective = this.buildEffectiveState(previousHashes, previousStats, scanResult);
+        return { effective, hashedCount };
+    }
+    async initialize() {
+        console.log(`Initializing file synchronizer for ${this.rootDir}`);
+        const { migrated } = await this.loadSnapshot();
+        if (migrated) {
+            const previousHashes = new Map(this.fileHashes);
+            const previousStats = new Map(this.fileStats);
+            const { effective } = await this.scanCurrentState(previousHashes, previousStats, true);
+            this.fileHashes = effective.fileHashes;
+            this.fileStats = effective.fileStats;
+            this.partialScan = effective.partialScan;
+            this.unscannedDirPrefixes = effective.unscannedDirPrefixes;
+            this.merkleRoot = (0, merkle_1.computeMerkleRoot)(this.fileHashes);
+            await this.saveSnapshot();
+        }
+        else if (!this.merkleRoot) {
+            this.merkleRoot = (0, merkle_1.computeMerkleRoot)(this.fileHashes);
+        }
+        console.log(`[Synchronizer] File synchronizer initialized. Loaded ${this.fileHashes.size} tracked files.`);
+    }
+    async checkForChanges() {
+        console.log('[Synchronizer] Checking for file changes...');
+        const previousHashes = new Map(this.fileHashes);
+        const previousStats = new Map(this.fileStats);
+        const previousPartialScan = this.partialScan;
+        const previousUnscannedDirPrefixes = [...this.unscannedDirPrefixes];
+        const previousCounter = this.fullHashCounter;
+        const fullHashInterval = this.getFullHashInterval();
+        const nextCounter = fullHashInterval > 0 ? this.fullHashCounter + 1 : this.fullHashCounter;
+        const fullHashRun = fullHashInterval > 0 && nextCounter % fullHashInterval === 0;
+        const { effective, hashedCount } = await this.scanCurrentState(previousHashes, previousStats, fullHashRun);
+        const nextMerkleRoot = (0, merkle_1.computeMerkleRoot)(effective.fileHashes);
+        const fileChanges = this.compareStates(previousHashes, effective.fileHashes);
+        this.fileHashes = effective.fileHashes;
+        this.fileStats = effective.fileStats;
+        this.partialScan = effective.partialScan;
+        this.unscannedDirPrefixes = effective.unscannedDirPrefixes;
+        this.merkleRoot = nextMerkleRoot;
+        this.fullHashCounter = nextCounter;
+        const hasDiffs = fileChanges.added.length > 0 || fileChanges.removed.length > 0 || fileChanges.modified.length > 0;
+        const metadataChanged = previousPartialScan !== this.partialScan
+            || !this.arraysEqual(previousUnscannedDirPrefixes, this.unscannedDirPrefixes);
+        const counterAdvanced = previousCounter !== this.fullHashCounter;
+        if (hasDiffs || hashedCount > 0 || metadataChanged || counterAdvanced) {
+            await this.saveSnapshot();
+        }
+        if (hasDiffs) {
+            console.log(`[Synchronizer] Found changes: ${fileChanges.added.length} added, ${fileChanges.removed.length} removed, ${fileChanges.modified.length} modified.`);
+        }
+        else {
+            console.log('[Synchronizer] No file content changes detected.');
         }
+        return {
+            ...fileChanges,
+            hashedCount,
+            partialScan: this.partialScan,
+            unscannedDirPrefixes: [...this.unscannedDirPrefixes],
+            fullHashRun
+        };
+    }
+    getFileHash(filePath) {
+        const normalizedPath = this.normalizeRelPath(filePath);
+        if (!normalizedPath) {
+            return undefined;
+        }
+        return this.fileHashes.get(normalizedPath);
     }
     /**
-     * Delete snapshot file for a given codebase path
+     * Return tracked (currently considered indexable) relative file paths.
+     * This reflects the synchronizer snapshot under the active ignore rules.
+     */
+    getTrackedRelativePaths() {
+        return Array.from(this.fileHashes.keys()).sort();
+    }
+    /**
+     * Delete snapshot file for a given codebase path.
      */
     static async deleteSnapshot(codebasePath) {
-        const homeDir = os.homedir();
-        const merkleDir = path.join(homeDir, '.satori', 'merkle');
-        const normalizedPath = path.resolve(codebasePath);
-        const hash = crypto.createHash('md5').update(normalizedPath).digest('hex');
-        const snapshotPath = path.join(merkleDir, `${hash}.json`);
+        const snapshotPath = FileSynchronizer.getSnapshotPathForCodebase(codebasePath);
         try {
-            await fs.unlink(snapshotPath);
+            await fsp.unlink(snapshotPath);
             console.log(`Deleted snapshot file: ${snapshotPath}`);
         }
         catch (error) {
@@ -279,7 +567,7 @@ class FileSynchronizer {
             }
             else {
                 console.error(`[Synchronizer] Failed to delete snapshot file ${snapshotPath}:`, error.message);
-                throw error; // Re-throw non-ENOENT errors
+                throw error;
             }
         }
     }