raggrep 0.10.5 → 0.10.8

package/dist/domain/entities/fileIndex.d.ts

@@ -36,6 +36,11 @@ export interface FileManifestEntry {
      * This prevents false positives when git updates mtime on branch switches.
      */
     contentHash?: string;
+    /**
+     * File size in bytes. Used as a quick filter:
+     * If mtime changed but size is same, content is likely unchanged.
+     */
+    fileSize?: number;
 }
 /**
  * Manifest tracking all indexed files for a specific module.

package/dist/index.js

@@ -12099,7 +12099,12 @@ async function ensureIndexFresh(rootDir, options = {}) {
   let cleanupMs = 0;
   let filesDiscovered = 0;
   let filesStatChecked = 0;
-  let filesIndexed = 0;
+  let filesWithChanges = 0;
+  let filesReindexed = 0;
+  let totalDiagNewFiles = 0;
+  let totalDiagNoFileSize = 0;
+  let totalDiagSizeMismatch = 0;
+  let totalDiagNoContentHash = 0;
   const logger = options.logger ? options.logger : quiet ? createSilentLogger() : createLogger({ verbose });
   rootDir = path21.resolve(rootDir);
   const status = await getIndexStatus(rootDir);
@@ -12141,7 +12146,8 @@ async function ensureIndexFresh(rootDir, options = {}) {
         cleanupMs: 0,
         filesDiscovered: 0,
         filesStatChecked: 0,
-        filesIndexed: 0,
+        filesWithChanges: 0,
+        filesReindexed: 0,
         fromCache: true
       };
     }
@@ -12236,41 +12242,91 @@ async function ensureIndexFresh(rootDir, options = {}) {
       try {
         const stats = await fs8.stat(filepath);
         const lastModified = stats.mtime.toISOString();
+        const fileSize = stats.size;
         const existingEntry = manifest.files[relativePath];
         if (!existingEntry) {
-          return { filepath, relativePath, lastModified, needsCheck: true, isNew: true };
+          return { filepath, relativePath, lastModified, fileSize, needsCheck: true, isNew: true };
         }
         if (existingEntry.lastModified === lastModified) {
-          return { filepath, relativePath, lastModified, needsCheck: false, isNew: false };
+          return { filepath, relativePath, lastModified, fileSize, needsCheck: false, isNew: false };
         }
-        return { filepath, relativePath, lastModified, needsCheck: true, isNew: false };
+        if (existingEntry.fileSize !== undefined && existingEntry.fileSize === fileSize && existingEntry.contentHash) {
+          return { filepath, relativePath, lastModified, fileSize, needsCheck: false, isNew: false, existingContentHash: existingEntry.contentHash };
+        }
+        return { filepath, relativePath, lastModified, fileSize, needsCheck: true, isNew: false, existingContentHash: existingEntry.contentHash };
       } catch {
         return null;
       }
     };
+    const moduleFiles = module2.supportsFile ? currentFiles.filter((f) => module2.supportsFile(f)) : currentFiles;
     const statCheckStart = Date.now();
-    const statResults = await parallelMap(currentFiles, statCheck, STAT_CONCURRENCY);
+    const statResults = await parallelMap(moduleFiles, statCheck, STAT_CONCURRENCY);
     statCheckMs += Date.now() - statCheckStart;
-    filesStatChecked += currentFiles.length;
+    filesStatChecked += moduleFiles.length;
     const filesToProcess = [];
+    const filesWithMtimeOnlyChange = [];
     let unchangedCount = 0;
+    let diagNewFiles = 0;
+    let diagNoFileSize = 0;
+    let diagSizeMismatch = 0;
+    let diagNoContentHash = 0;
     for (const result2 of statResults) {
       if (!result2.success || !result2.value)
         continue;
       if (result2.value.needsCheck) {
         filesToProcess.push(result2.value);
+        if (result2.value.isNew) {
+          diagNewFiles++;
+        } else {
+          const existingEntry = manifest.files[result2.value.relativePath];
+          if (existingEntry) {
+            if (existingEntry.fileSize === undefined)
+              diagNoFileSize++;
+            else if (existingEntry.fileSize !== result2.value.fileSize)
+              diagSizeMismatch++;
+            else if (!existingEntry.contentHash)
+              diagNoContentHash++;
+          }
+        }
       } else {
         unchangedCount++;
+        const existingEntry = manifest.files[result2.value.relativePath];
+        if (existingEntry && existingEntry.lastModified !== result2.value.lastModified) {
+          filesWithMtimeOnlyChange.push(result2.value);
+        }
+      }
+    }
+    totalDiagNewFiles += diagNewFiles;
+    totalDiagNoFileSize += diagNoFileSize;
+    totalDiagSizeMismatch += diagSizeMismatch;
+    totalDiagNoContentHash += diagNoContentHash;
+    if (filesToProcess.length > 100 && verbose) {
+      logger.info(`  [Diagnostic] Phase 2 reasons: new=${diagNewFiles}, noSize=${diagNoFileSize}, sizeMismatch=${diagSizeMismatch}, noHash=${diagNoContentHash}`);
+    }
+    let mtimeOnlyUpdates = 0;
+    for (const file of filesWithMtimeOnlyChange) {
+      const existingEntry = manifest.files[file.relativePath];
+      if (existingEntry) {
+        manifest.files[file.relativePath] = {
+          ...existingEntry,
+          lastModified: file.lastModified,
+          fileSize: file.fileSize
+        };
+        mtimeOnlyUpdates++;
       }
     }
     if (filesToProcess.length === 0) {
       totalUnchanged += unchangedCount;
+      if (mtimeOnlyUpdates > 0) {
+        manifest.lastUpdated = new Date().toISOString();
+        await writeModuleManifest(rootDir, module2.id, manifest, config);
+      }
       continue;
     }
     let completedCount = 0;
     const totalToProcess = filesToProcess.length;
     const processChangedFile = async (statResult) => {
-      const { filepath, relativePath, lastModified, isNew } = statResult;
+      const { filepath, relativePath, lastModified, fileSize, isNew } = statResult;
       try {
         const content = await fs8.readFile(filepath, "utf-8");
         const contentHash = computeContentHash(content);
@@ -12281,6 +12337,7 @@ async function ensureIndexFresh(rootDir, options = {}) {
             relativePath,
             status: "mtime_updated",
             lastModified,
+            fileSize,
             contentHash
           };
         }
@@ -12289,13 +12346,14 @@ async function ensureIndexFresh(rootDir, options = {}) {
         introspection.addFile(relativePath, content);
         const fileIndex = await module2.indexFile(relativePath, content, ctx);
         if (!fileIndex) {
-          return { relativePath, status: "unchanged" };
+          return { relativePath, status: "unchanged", fileSize };
         }
         await writeFileIndex(rootDir, module2.id, relativePath, fileIndex, config);
         return {
           relativePath,
           status: "indexed",
           lastModified,
+          fileSize,
           chunkCount: fileIndex.chunks.length,
           contentHash
         };
@@ -12308,7 +12366,7 @@ async function ensureIndexFresh(rootDir, options = {}) {
     const concurrency = options.concurrency ?? DEFAULT_CONCURRENCY;
     const results = await parallelMap(filesToProcess, processChangedFile, concurrency);
     indexingMs += Date.now() - indexingStart;
-    filesIndexed += filesToProcess.length;
+    filesWithChanges += filesToProcess.length;
     totalUnchanged += unchangedCount;
     logger.clearProgress();
     let mtimeUpdates = 0;
@@ -12322,7 +12380,8 @@ async function ensureIndexFresh(rootDir, options = {}) {
           manifest.files[fileResult.relativePath] = {
             lastModified: fileResult.lastModified,
             chunkCount: fileResult.chunkCount,
-            contentHash: fileResult.contentHash
+            contentHash: fileResult.contentHash,
+            fileSize: fileResult.fileSize
           };
           totalIndexed++;
           break;
@@ -12331,7 +12390,8 @@ async function ensureIndexFresh(rootDir, options = {}) {
             manifest.files[fileResult.relativePath] = {
               ...manifest.files[fileResult.relativePath],
               lastModified: fileResult.lastModified,
-              contentHash: fileResult.contentHash
+              contentHash: fileResult.contentHash,
+              fileSize: fileResult.fileSize
             };
             mtimeUpdates++;
           }
@@ -12345,7 +12405,7 @@ async function ensureIndexFresh(rootDir, options = {}) {
           break;
       }
     }
-    const hasManifestChanges = totalIndexed > 0 || totalRemoved > 0 || mtimeUpdates > 0;
+    const hasManifestChanges = totalIndexed > 0 || totalRemoved > 0 || mtimeUpdates > 0 || mtimeOnlyUpdates > 0;
     if (hasManifestChanges) {
       manifest.lastUpdated = new Date().toISOString();
       await writeModuleManifest(rootDir, module2.id, manifest, config);
@@ -12379,8 +12439,15 @@ async function ensureIndexFresh(rootDir, options = {}) {
       cleanupMs,
       filesDiscovered,
       filesStatChecked,
-      filesIndexed,
-      fromCache: false
+      filesWithChanges,
+      filesReindexed: totalIndexed,
+      fromCache: false,
+      phase2Reasons: {
+        newFiles: totalDiagNewFiles,
+        noFileSize: totalDiagNoFileSize,
+        sizeMismatch: totalDiagSizeMismatch,
+        noContentHash: totalDiagNoContentHash
+      }
     };
   }
   let finalManifestMtime = currentManifestMtime;
@@ -12449,6 +12516,7 @@ async function indexWithModule(rootDir, files, module2, config, verbose, introsp
     try {
       const stats = await fs8.stat(filepath);
       const lastModified = stats.mtime.toISOString();
+      const fileSize = stats.size;
       const existingEntry = manifest.files[relativePath];
       if (existingEntry && existingEntry.lastModified === lastModified) {
         completedCount++;
@@ -12464,6 +12532,7 @@ async function indexWithModule(rootDir, files, module2, config, verbose, introsp
           relativePath,
           status: "skipped",
           lastModified,
+          fileSize,
           contentHash
         };
       }
@@ -12473,13 +12542,14 @@ async function indexWithModule(rootDir, files, module2, config, verbose, introsp
       const fileIndex = await module2.indexFile(relativePath, content, ctx);
       if (!fileIndex) {
         logger.debug(`  [${completedCount}/${totalFiles}] Skipped ${relativePath} (no chunks)`);
-        return { relativePath, status: "skipped" };
+        return { relativePath, status: "skipped", fileSize };
       }
       await writeFileIndex(rootDir, module2.id, relativePath, fileIndex, config);
       return {
         relativePath,
         status: "indexed",
         lastModified,
+        fileSize,
         chunkCount: fileIndex.chunks.length,
         contentHash
       };
@@ -12502,7 +12572,8 @@ async function indexWithModule(rootDir, files, module2, config, verbose, introsp
         manifest.files[fileResult.relativePath] = {
           lastModified: fileResult.lastModified,
           chunkCount: fileResult.chunkCount,
-          contentHash: fileResult.contentHash
+          contentHash: fileResult.contentHash,
+          fileSize: fileResult.fileSize
         };
         result.indexed++;
         break;
@@ -12513,7 +12584,8 @@ async function indexWithModule(rootDir, files, module2, config, verbose, introsp
             manifest.files[fileResult.relativePath] = {
               ...existingEntry,
               lastModified: fileResult.lastModified,
-              contentHash: fileResult.contentHash
+              contentHash: fileResult.contentHash,
+              fileSize: fileResult.fileSize
             };
           }
         }
@@ -14115,4 +14187,4 @@ export {
   ConsoleLogger
 };
 
-//# debugId=7829AFEE37F24D3164756E2164756E21
+//# debugId=3F7DE957CF0C467164756E2164756E21