@softerist/heuristic-mcp 3.0.17 → 3.2.0

package/lib/cache-utils.js

@@ -1,17 +1,15 @@
-import fs from 'fs/promises';
-import path from 'path';
-import os from 'os';
-import { getGlobalCacheDir } from './config.js';
-
-/**
- * Check if a process is running
- */
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+import { getGlobalCacheDir, isNonProjectDirectory } from './config.js';
+
+
 function isProcessRunning(pid) {
   try {
     process.kill(pid, 0);
     return true;
   } catch (err) {
-    // On Windows, EPERM can happen even if process exists
+    
     if (err && err.code === 'EPERM') {
       return true;
     }
@@ -19,42 +17,35 @@ function isProcessRunning(pid) {
   }
 }
 
-/**
- * Normalize workspace path for comparison
- * - Resolves symlinks
- * - Lowercase on Windows
- * - Normalizes path separators
- */
+
 async function normalizeWorkspacePath(workspacePath) {
   if (!workspacePath) return null;
 
   try {
     let normalized = workspacePath;
 
-    // Resolve symlinks if path exists
+    
     try {
       normalized = await fs.realpath(normalized);
     } catch {
-      // Path doesn't exist, use as-is
+      
     }
 
-    // Lowercase on Windows for case-insensitive comparison
+    
     if (process.platform === 'win32') {
       normalized = normalized.toLowerCase();
     }
 
-    // Normalize path separators
+    
     normalized = path.normalize(normalized);
 
     return normalized;
   } catch {
-    return workspacePath; // Return original if normalization fails
+    return workspacePath; 
   }
 }
 
-/**
- * Check if workspace path indicates a temporary/test workspace
- */
+
 function isTemporaryWorkspace(workspacePath) {
   if (!workspacePath) return false;
 
@@ -65,7 +56,7 @@ function isTemporaryWorkspace(workspacePath) {
     return true;
   }
 
-  // Check if under OS temp directory
+  
   try {
     const tempDir = os.tmpdir().toLowerCase();
     return normalized.startsWith(tempDir);
@@ -74,9 +65,7 @@ function isTemporaryWorkspace(workspacePath) {
   }
 }
 
-/**
- * Get timestamp from progress data
- */
+
 function getProgressTimestamp(cacheInfo) {
   if (cacheInfo.progress?.updatedAt) {
     const timestamp = Date.parse(cacheInfo.progress.updatedAt);
@@ -85,7 +74,7 @@ function getProgressTimestamp(cacheInfo) {
     }
   }
 
-  // Fallback to file mtime
+  
   if (cacheInfo.stats.progressFile) {
     return cacheInfo.stats.progressFile.mtimeMs;
   }
@@ -93,9 +82,7 @@ function getProgressTimestamp(cacheInfo) {
   return 0;
 }
 
-/**
- * Check if progress was updated recently
- */
+
 function hasRecentProgress(cacheInfo, thresholdMs = 5 * 60 * 1000) {
   if (!cacheInfo.progress) return false;
 
@@ -103,9 +90,7 @@ function hasRecentProgress(cacheInfo, thresholdMs = 5 * 60 * 1000) {
   return Date.now() - progressTime < thresholdMs;
 }
 
-/**
- * Safe file stat - returns null on error
- */
+
 async function safeStat(filePath) {
   try {
     return await fs.stat(filePath);
@@ -114,9 +99,7 @@ async function safeStat(filePath) {
   }
 }
 
-/**
- * Safe JSON parse - returns null on error
- */
+
 async function safeReadJson(filePath) {
   try {
     const content = await fs.readFile(filePath, 'utf-8');
@@ -126,14 +109,12 @@ async function safeReadJson(filePath) {
   }
 }
 
-/**
- * Collect comprehensive cache information
- */
+
 async function collectCacheInfo(cacheDir) {
   const cacheId = path.basename(cacheDir);
   const errors = [];
 
-  // File paths
+  
   const metaPath = path.join(cacheDir, 'meta.json');
   const progressPath = path.join(cacheDir, 'progress.json');
   const lockPath = path.join(cacheDir, 'server.lock.json');
@@ -142,14 +123,14 @@ async function collectCacheInfo(cacheDir) {
   const vectorsSqlitePath = path.join(cacheDir, 'vectors.sqlite');
   const annIndexPath = path.join(cacheDir, 'ann-index.bin');
 
-  // Read metadata
+  
   const [meta, progress, lock] = await Promise.all([
     safeReadJson(metaPath),
     safeReadJson(progressPath),
     safeReadJson(lockPath),
   ]);
 
-  // Gather file stats
+  
   const [
     cacheDirStat,
     metaFileStat,
@@ -170,13 +151,13 @@ async function collectCacheInfo(cacheDir) {
     safeStat(annIndexPath),
   ]);
 
-  // Determine embeddings file (prefer binary/sqlite over JSON)
+  
   const embeddingsFileStat = vectorsBinStat || vectorsSqliteStat || embeddingsJsonStat;
 
-  // Extract workspace path
+  
   const workspacePath = meta?.workspace || null;
 
-  // Check workspace existence
+  
   let workspaceExists = false;
   if (workspacePath) {
     try {
@@ -187,10 +168,10 @@ async function collectCacheInfo(cacheDir) {
     }
   }
 
-  // Normalize workspace path
+  
   const workspacePathNormalized = await normalizeWorkspacePath(workspacePath);
 
-  // Calculate lastActivityMs from all known timestamps
+  
   const timestamps = [
     meta?.lastSaveTime ? Date.parse(meta.lastSaveTime) : null,
     getProgressTimestamp({ progress, stats: { progressFile: progressFileStat } }),
@@ -204,10 +185,10 @@ async function collectCacheInfo(cacheDir) {
       ? Math.max(...timestamps)
       : cacheDirStat?.mtimeMs || 0;
 
-  // Determine if cache is active
+  
   let isActive = false;
 
-  // Check lock file with valid PID
+  
   if (lock && Number.isInteger(lock.pid)) {
     isActive = isProcessRunning(lock.pid);
   }
@@ -235,28 +216,49 @@ async function collectCacheInfo(cacheDir) {
   };
 }
 
-/**
- * Evaluate a single cache using the safe decision pipeline
- */
-function evaluateCache(cacheInfo, thresholds) {
-  const now = Date.now();
-  const age = now - cacheInfo.lastActivityMs;
-
-  // Step 1: Keep if active or within safety window
-  if (cacheInfo.isActive || age < thresholds.safetyWindowMs) {
-    return {
-      action: 'KEEP',
-      reason: cacheInfo.isActive ? 'active_lock' : 'recent_activity',
-      details: {
-        isActive: cacheInfo.isActive,
-        lockPid: cacheInfo.lock?.pid,
-        ageMs: age,
-      },
-    };
-  }
 
-  // Step 2: No meta.json
-  if (!cacheInfo.meta) {
+function evaluateCache(cacheInfo, thresholds) {
+  const now = Date.now();
+  const age = now - cacheInfo.lastActivityMs;
+
+  
+  if (cacheInfo.isActive) {
+    return {
+      action: 'KEEP',
+      reason: 'active_lock',
+      details: {
+        isActive: true,
+        lockPid: cacheInfo.lock?.pid,
+        ageMs: age,
+      },
+    };
+  }
+
+  
+  if (cacheInfo.workspacePath && isNonProjectDirectory(cacheInfo.workspacePath)) {
+    return {
+      action: 'REMOVE',
+      reason: 'system_workspace_cache',
+      details: {
+        workspace: cacheInfo.workspacePath,
+        ageMs: age,
+      },
+    };
+  }
+
+  
+  if (age < thresholds.safetyWindowMs) {
+    return {
+      action: 'KEEP',
+      reason: 'recent_activity',
+      details: {
+        ageMs: age,
+      },
+    };
+  }
+
+  
+  if (!cacheInfo.meta) {
     const dirAge = now - (cacheInfo.stats.cacheDir?.mtimeMs || 0);
     if (dirAge > thresholds.staleNoMetaMs && !hasRecentProgress(cacheInfo)) {
       return {
@@ -272,8 +274,8 @@ function evaluateCache(cacheInfo, thresholds) {
     };
   }
 
-  // Step 3: Temporary workspace (check BEFORE missing workspace - shorter threshold!)
-  // This ensures temp workspaces use 24h threshold instead of 7-day grace period
+  
+  
   if (isTemporaryWorkspace(cacheInfo.workspacePath)) {
     if (age > thresholds.tempThresholdMs) {
       return {
@@ -285,7 +287,7 @@ function evaluateCache(cacheInfo, thresholds) {
         },
       };
     }
-    // Recent temp workspace - keep for now
+    
     return {
       action: 'KEEP',
       reason: 'recent_temp_workspace',
@@ -296,7 +298,7 @@ function evaluateCache(cacheInfo, thresholds) {
     };
   }
 
-  // Step 4: Empty cache
+  
   const filesIndexed = cacheInfo.meta.filesIndexed ?? 0;
   const chunksStored = cacheInfo.meta.chunksStored ?? 0;
 
@@ -323,7 +325,7 @@ function evaluateCache(cacheInfo, thresholds) {
     };
   }
 
-  // Step 5: Missing workspace (non-temp workspaces only, due to Step 3 early return)
+  
   if (cacheInfo.workspacePath && !cacheInfo.workspaceExists) {
     if (age > thresholds.workspaceGraceMs) {
       return {
@@ -345,7 +347,7 @@ function evaluateCache(cacheInfo, thresholds) {
     };
   }
 
-  // Step 6: Stuck indexing
+  
   if (cacheInfo.progress && !hasRecentProgress(cacheInfo, thresholds.safetyWindowMs)) {
     const progressAge = now - getProgressTimestamp(cacheInfo);
     if (progressAge > thresholds.staleProgressMs) {
@@ -360,7 +362,7 @@ function evaluateCache(cacheInfo, thresholds) {
     }
   }
 
-  // Step 7: Long unused
+  
   if (age > thresholds.maxUnusedMs) {
     return {
       action: 'REMOVE',
@@ -369,7 +371,7 @@ function evaluateCache(cacheInfo, thresholds) {
     };
   }
 
-  // Step 8: Default - keep
+  
   return {
     action: 'KEEP',
     reason: 'valid_cache',
@@ -381,16 +383,14 @@ function evaluateCache(cacheInfo, thresholds) {
   };
 }
 
-/**
- * Find duplicate workspace caches
- */
+
 function findDuplicateWorkspaces(cacheInfos) {
-  const workspaceMap = new Map(); // normalized workspace -> [cacheInfos]
+  const workspaceMap = new Map(); 
 
   for (const info of cacheInfos) {
     if (!info.workspacePathNormalized) continue;
 
-    // Key includes embedding model + dimension to avoid deleting caches for different embeddings
+    
     const dimLabel = info.meta?.embeddingDimension ?? 'default';
     const key = `${info.workspacePathNormalized}::${info.meta?.embeddingModel || 'default'}::${dimLabel}`;
 
@@ -403,10 +403,10 @@ function findDuplicateWorkspaces(cacheInfos) {
   const duplicates = [];
   for (const [key, infos] of workspaceMap) {
     if (infos.length > 1) {
-      // Sort by lastActivityMs descending
+      
       infos.sort((a, b) => b.lastActivityMs - a.lastActivityMs);
 
-      // Keep newest, mark others for removal (if not active)
+      
       for (let i = 1; i < infos.length; i++) {
         if (!infos[i].isActive) {
           duplicates.push({
@@ -427,9 +427,7 @@ function findDuplicateWorkspaces(cacheInfos) {
   return duplicates;
 }
 
-/**
- * Main cache cleanup function with intelligent sanitization
- */
+
 export async function clearStaleCaches(options = {}) {
   const config = {
     staleNoMetaHours: 6,
@@ -445,7 +443,7 @@ export async function clearStaleCaches(options = {}) {
     ...options,
   };
 
-  // Convert to milliseconds
+  
   const thresholds = {
     staleNoMetaMs: config.staleNoMetaHours * 60 * 60 * 1000,
     emptyThresholdMs: config.emptyThresholdHours * 60 * 60 * 1000,
@@ -463,12 +461,12 @@ export async function clearStaleCaches(options = {}) {
     return { removed: 0, kept: 0, dryRun: config.dryRun, decisions: [] };
   }
 
-  // Step 1: Collect all cache info
+  
   const cacheInfos = await Promise.all(
     cacheDirs.map((dir) => collectCacheInfo(path.join(globalCacheRoot, dir)))
   );
 
-  // Step 2: Evaluate each cache individually
+  
   const decisions = cacheInfos.map((info) => {
     const evaluation = evaluateCache(info, thresholds);
     return {
@@ -479,11 +477,11 @@ export async function clearStaleCaches(options = {}) {
     };
   });
 
-  // Step 3: Find duplicates
+  
   if (config.removeDuplicates) {
     const duplicates = findDuplicateWorkspaces(cacheInfos);
     for (const dup of duplicates) {
-      // Override decision if not already marked for removal
+      
       const existing = decisions.find((d) => d.cacheId === dup.info.cacheId);
       if (existing && existing.action === 'KEEP') {
         existing.action = dup.action;
@@ -493,7 +491,7 @@ export async function clearStaleCaches(options = {}) {
     }
   }
 
-  // Step 4: Execute removals
+  
   let removed = 0;
   let kept = 0;
 
@@ -514,7 +512,7 @@ export async function clearStaleCaches(options = {}) {
               `[Cache] Failed to remove ${decision.cacheId}: ${err.message}`
             );
           }
-          // Count as kept if removal failed
+          
           kept++;
           decision.action = 'KEEP';
           decision.reason = 'removal_failed';
@@ -547,9 +545,7 @@ export async function clearStaleCaches(options = {}) {
   };
 }
 
-/**
- * Format age in human-readable form
- */
+
 function formatAge(ms) {
   if (!Number.isFinite(ms)) return 'unknown';