@softerist/heuristic-mcp 3.0.12 → 3.0.14

package/lib/embedding-worker.js

@@ -24,13 +24,51 @@ console.info = (...args) => console.error('[INFO]', ...args);
 console.warn = (...args) => console.error('[WARN]', ...args);
 
 import { RESULT_BATCH_SIZE, DEFAULT_INFERENCE_BATCH_SIZE } from './constants.js';
-const workerId = Number.isInteger(workerData.workerId) ? workerData.workerId : null;
-const workerLabel = workerId === null ? '[Worker]' : `[Worker ${workerId}]`;
-const workerThreads = Number.isFinite(workerData.numThreads) ? workerData.numThreads : 1;
-const logInfo = (...args) => {
-  console.info(...args);
-};
-let nativeBackendConfigured = false;
+const workerId = Number.isInteger(workerData.workerId) ? workerData.workerId : null;
+const workerLabel = workerId === null ? '[Worker]' : `[Worker ${workerId}]`;
+const workerThreads = Number.isFinite(workerData.numThreads) ? workerData.numThreads : 1;
+const explicitGcEnabled = workerData.enableExplicitGc !== false;
+const failFastEmbeddingErrors = workerData.failFastEmbeddingErrors === true;
+const FAIL_FAST_CONSECUTIVE_ERROR_LIMIT = 8;
+const logInfo = (...args) => {
+  console.info(...args);
+};
+let nativeBackendConfigured = false;
+
+function maybeRunGc() {
+  if (!explicitGcEnabled || typeof global.gc !== 'function') return;
+  global.gc();
+}
+
+function createFailFastState(scope) {
+  if (!failFastEmbeddingErrors) return null;
+  return { scope, consecutiveFailures: 0 };
+}
+
+function noteEmbeddingSuccess(failFastState) {
+  if (!failFastState) return;
+  failFastState.consecutiveFailures = 0;
+}
+
+function noteEmbeddingFailure(failFastState, err) {
+  if (!failFastState) return;
+  failFastState.consecutiveFailures += 1;
+
+  if (failFastState.consecutiveFailures >= FAIL_FAST_CONSECUTIVE_ERROR_LIMIT) {
+    const message =
+      `${failFastState.scope}: fail-fast breaker tripped after ` +
+      `${failFastState.consecutiveFailures} consecutive embedding failures (${err?.message || err})`;
+    console.warn(`${workerLabel} ${message}`);
+    throw new Error(message);
+  }
+
+  if (workerData.verbose) {
+    console.warn(
+      `${workerLabel} ${failFastState.scope}: embedding failure ` +
+      `${failFastState.consecutiveFailures}/${FAIL_FAST_CONSECUTIVE_ERROR_LIMIT}`
+    );
+  }
+}
 
 function ensureNativeBackend() {
   if (nativeBackendConfigured) return;
@@ -134,7 +172,7 @@ const embeddingDimension = workerData.embeddingDimension || null;
 // Use a promise to handle concurrent calls to initializeEmbedder safely
 let embedderPromise = null;
 
-async function initializeEmbedder() {
+async function initializeEmbedder() {
   if (!embedderPromise) {
     const modelLoadStart = Date.now();
 
@@ -145,11 +183,16 @@ async function initializeEmbedder() {
 
     embedderPromise = (async () => {
       try {
-        ensureNativeBackend();
-        const model = await pipeline('feature-extraction', workerData.embeddingModel, {
-          quantized: true,
-          dtype: 'fp32',
-        });
+        ensureNativeBackend();
+        const model = await pipeline('feature-extraction', workerData.embeddingModel, {
+          quantized: true,
+          dtype: 'fp32',
+          session_options: {
+            numThreads: workerThreads,
+            intraOpNumThreads: workerThreads,
+            interOpNumThreads: 1,
+          },
+        });
         const loadSeconds = ((Date.now() - modelLoadStart) / 1000).toFixed(1);
         logInfo(
           `${workerLabel} Embedding model ready: ${workerData.embeddingModel} (${loadSeconds}s)`
@@ -161,17 +204,48 @@ async function initializeEmbedder() {
       }
     })();
   }
-  return embedderPromise;
-}
-
-/**
- * Legacy Protocol: Process chunks with optimized single-text embedding
- * Streams results in batches.
- */
-async function processChunks(chunks, batchId) {
-  const embedder = await initializeEmbedder();
-  let results = [];
-  let transferList = [];
+  return embedderPromise;
+}
+
+function isFatalRuntimeEmbeddingError(err) {
+  const message = String(err?.message || err || '').toLowerCase();
+  return (
+    message.includes('exception is pending') ||
+    message.includes('invalid embedding output') ||
+    message.includes("cannot read properties of undefined (reading 'data')") ||
+    message.includes("cannot read properties of null (reading 'data')")
+  );
+}
+
+function getEmbeddingTensor(output, { requireDimsForBatch = false, batchSize = null } = {}) {
+  const data = output?.data;
+  if (!data || typeof data.length !== 'number') {
+    throw new Error('Invalid embedding output: missing tensor data');
+  }
+  if (!requireDimsForBatch) {
+    return { data };
+  }
+
+  const dims = Array.isArray(output?.dims) ? output.dims : null;
+  const hiddenSize = Number.isInteger(dims?.[dims.length - 1]) ? dims[dims.length - 1] : null;
+  if (!hiddenSize || hiddenSize <= 0) {
+    throw new Error('Invalid embedding output: missing tensor dims');
+  }
+  if (Number.isInteger(batchSize) && batchSize > 0 && data.length < hiddenSize * batchSize) {
+    throw new Error('Invalid embedding output: tensor length mismatch');
+  }
+  return { data, hiddenSize };
+}
+
+/**
+ * Legacy Protocol: Process chunks with optimized single-text embedding
+ * Streams results in batches.
+ */
+async function processChunks(chunks, batchId) {
+  const embedder = await initializeEmbedder();
+  let results = [];
+  let transferList = [];
+  const failFastState = createFailFastState('legacy chunk embedding');
 
   const flush = (done = false) => {
     // Only flush intermediate results when we have enough for a batch
@@ -196,15 +270,16 @@ async function processChunks(chunks, batchId) {
   };
 
   for (const chunk of chunks) {
-    try {
-      const output = await embedder(chunk.text, {
-        pooling: 'mean',
-        normalize: true,
-      });
-      // CRITICAL: Deep copy to release ONNX tensor memory
-      let vector = new Float32Array(output.data);
-      // Apply MRL dimension slicing if configured
-      vector = sliceAndNormalize(vector, embeddingDimension);
+    try {
+      const output = await embedder(chunk.text, {
+        pooling: 'mean',
+        normalize: true,
+      });
+      // CRITICAL: Deep copy to release ONNX tensor memory
+      const { data } = getEmbeddingTensor(output);
+      let vector = new Float32Array(data);
+      // Apply MRL dimension slicing if configured
+      vector = sliceAndNormalize(vector, embeddingDimension);
       // Properly dispose tensor to release ONNX runtime memory
       if (typeof output.dispose === 'function')
         try {
@@ -214,34 +289,37 @@ async function processChunks(chunks, batchId) {
             console.warn(`${workerLabel} Failed to dispose tensor: ${disposeErr.message}`);
           }
         }
-      results.push({
-        file: chunk.file,
-        startLine: chunk.startLine,
-        endLine: chunk.endLine,
-        content: chunk.text,
-        vector,
-        success: true,
-      });
-      transferList.push(vector.buffer);
-    } catch (error) {
-      results.push({
-        file: chunk.file,
-        startLine: chunk.startLine,
-        endLine: chunk.endLine,
-        error: error.message,
-        success: false,
-      });
-    }
-    flush();
-  }
-
-  flush(true);
-
-  // Force GC if available to free massive tensor buffers immediately
-  if (typeof global.gc === 'function') {
-    global.gc();
-  }
-}
+      results.push({
+        file: chunk.file,
+        startLine: chunk.startLine,
+        endLine: chunk.endLine,
+        content: chunk.text,
+        vector,
+        success: true,
+      });
+      transferList.push(vector.buffer);
+      noteEmbeddingSuccess(failFastState);
+    } catch (error) {
+      results.push({
+        file: chunk.file,
+        startLine: chunk.startLine,
+        endLine: chunk.endLine,
+        error: error.message,
+        success: false,
+      });
+      noteEmbeddingFailure(failFastState, error);
+      if (isFatalRuntimeEmbeddingError(error)) {
+        throw error;
+      }
+    }
+    flush();
+  }
+
+  flush(true);
+
+  // Force GC if available to free massive tensor buffers immediately
+  maybeRunGc();
+}
 
 // =====================================================================
 // SHARED HELPER FUNCTIONS
@@ -356,8 +434,9 @@ function processFileMetadata(file, content, options) {
  * New Protocol: Process entire file (read, chunk, embed) in worker.
  * Returns results once processing is complete.
  */
-async function processFileTask(message) {
-  const embedder = await initializeEmbedder();
+async function processFileTask(message) {
+  const embedder = await initializeEmbedder();
+  const failFastState = createFailFastState(`file-task ${path.basename(message.file || '')}`);
 
   const file = message.file;
   const force = !!message.force;
@@ -409,33 +488,38 @@ async function processFileTask(message) {
 
   // Batch size for inference (balance between speed and memory)
   // Configurable via workerData, default 4 balances memory and throughput
-  const INFERENCE_BATCH_SIZE = Number.isInteger(workerData.inferenceBatchSize)
-    ? workerData.inferenceBatchSize
-    : DEFAULT_INFERENCE_BATCH_SIZE;
-
-  for (let i = 0; i < chunks.length; i += INFERENCE_BATCH_SIZE) {
+  const INFERENCE_BATCH_SIZE = Number.isInteger(workerData.inferenceBatchSize)
+    ? workerData.inferenceBatchSize
+    : DEFAULT_INFERENCE_BATCH_SIZE;
+  let processedSinceGc = 0;
+
+  for (let i = 0; i < chunks.length; i += INFERENCE_BATCH_SIZE) {
     const batchChunks = chunks.slice(i, i + INFERENCE_BATCH_SIZE);
     const batchTexts = batchChunks.map((c) => c.text);
 
-    try {
-      // Run inference on the batch
-      const output = await embedder(batchTexts, {
-        pooling: 'mean',
-        normalize: true,
-      });
-
-      // Output is a Tensor with shape [batch_size, hidden_size]
-      // data is a flat Float32Array
-      const hiddenSize = output.dims[output.dims.length - 1];
-
-      for (let j = 0; j < batchChunks.length; j++) {
-        const c = batchChunks[j];
-
-        // Slice the flat buffer to get this chunk's vector
-        // specific slice for this element
-        const start = j * hiddenSize;
-        const end = start + hiddenSize;
-        const vectorView = output.data.subarray(start, end);
+    try {
+      // Run inference on the batch
+      const output = await embedder(batchTexts, {
+        pooling: 'mean',
+        normalize: true,
+      });
+
+      // Output is a Tensor with shape [batch_size, hidden_size]
+      // data is a flat Float32Array
+      const { data, hiddenSize } = getEmbeddingTensor(output, {
+        requireDimsForBatch: true,
+        batchSize: batchChunks.length,
+      });
+
+      for (let j = 0; j < batchChunks.length; j++) {
+        const c = batchChunks[j];
+
+        // Slice the flat buffer to get this chunk's vector
+        // specific slice for this element
+        const start = j * hiddenSize;
+        const end = start + hiddenSize;
+        const vectorView =
+          typeof data.subarray === 'function' ? data.subarray(start, end) : data.slice(start, end);
 
         // Deep copy to ensure independent buffer for transfer
         let vector = new Float32Array(vectorView);
@@ -451,22 +535,29 @@ async function processFileTask(message) {
         transferList.push(vector.buffer);
       }
       // Properly dispose tensor to release ONNX runtime memory
-      if (typeof output.dispose === 'function')
-        try {
-          output.dispose();
-        } catch (disposeErr) {
-          if (workerData.verbose) {
-            console.warn(`${workerLabel} Failed to dispose tensor: ${disposeErr.message}`);
-          }
-        }
-    } catch (err) {
-      // Fallback: if batch fails (e.g. OOM), try one by one for this batch
-      console.warn(`${workerLabel} Batch inference failed (${err.name}), retrying individually: ${err.message}`);
-
-      for (const c of batchChunks) {
-        try {
-          const output = await embedder(c.text, { pooling: 'mean', normalize: true });
-          let vector = new Float32Array(output.data);
+      if (typeof output.dispose === 'function')
+        try {
+          output.dispose();
+        } catch (disposeErr) {
+          if (workerData.verbose) {
+            console.warn(`${workerLabel} Failed to dispose tensor: ${disposeErr.message}`);
+          }
+        }
+      noteEmbeddingSuccess(failFastState);
+    } catch (err) {
+      if (isFatalRuntimeEmbeddingError(err)) {
+        noteEmbeddingFailure(failFastState, err);
+        throw err;
+      }
+      // Fallback: if batch fails (e.g. OOM), try one by one for this batch
+      console.warn(`${workerLabel} Batch inference failed (${err.name}), retrying individually: ${err.message}`);
+      noteEmbeddingFailure(failFastState, err);
+
+      for (const c of batchChunks) {
+        try {
+          const output = await embedder(c.text, { pooling: 'mean', normalize: true });
+          const { data } = getEmbeddingTensor(output);
+          let vector = new Float32Array(data);
           // Apply MRL dimension slicing if configured
           vector = sliceAndNormalize(vector, embeddingDimension);
           // Properly dispose tensor to release ONNX runtime memory
@@ -478,27 +569,36 @@ async function processFileTask(message) {
                 console.warn(`${workerLabel} Failed to dispose tensor: ${disposeErr.message}`);
               }
             }
-          results.push({
-            startLine: c.startLine,
-            endLine: c.endLine,
-            text: c.text,
-            vectorBuffer: vector.buffer,
-          });
-          transferList.push(vector.buffer);
-        } catch (innerErr) {
-          // Note: No tensor disposal needed - embedder() threw before returning a tensor
-          console.warn(`${workerLabel} Chunk embedding failed: ${innerErr.message}`);
-          // We omit this chunk from results, effectively skipping it
-        }
-      }
-    }
-
-    // Yield to event loop briefly between batches and trigger GC
-    if (chunks.length > INFERENCE_BATCH_SIZE) {
-      if (typeof global.gc === 'function') global.gc();
-      await new Promise((resolve) => setTimeout(resolve, 0));
-    }
-  }
+          results.push({
+            startLine: c.startLine,
+            endLine: c.endLine,
+            text: c.text,
+            vectorBuffer: vector.buffer,
+          });
+          transferList.push(vector.buffer);
+          noteEmbeddingSuccess(failFastState);
+        } catch (innerErr) {
+          // Note: No tensor disposal needed - embedder() threw before returning a tensor
+          console.warn(`${workerLabel} Chunk embedding failed: ${innerErr.message}`);
+          // We omit this chunk from results, effectively skipping it
+          noteEmbeddingFailure(failFastState, innerErr);
+          if (isFatalRuntimeEmbeddingError(innerErr)) {
+            throw innerErr;
+          }
+        }
+      }
+    }
+
+    // Yield to event loop briefly between batches and trigger GC
+    processedSinceGc += batchChunks.length;
+    if (chunks.length > INFERENCE_BATCH_SIZE) {
+      if (processedSinceGc >= 100) {
+        maybeRunGc();
+        processedSinceGc = 0;
+      }
+      await new Promise((resolve) => setTimeout(resolve, 0));
+    }
+  }
 
   return { status: 'indexed', hash, mtimeMs, size, callData, results, transferList };
 }
@@ -535,13 +635,13 @@ parentPort.on('message', async (message) => {
         
         // Clear references
         embedderPromise = null;
-      }
-      
-      // Trigger garbage collection if available
-      if (typeof global.gc === 'function') {
-        const before = process.memoryUsage();
-        global.gc();
-        const after = process.memoryUsage();
+      }
+      
+      // Trigger garbage collection if available
+      if (explicitGcEnabled && typeof global.gc === 'function') {
+        const before = process.memoryUsage();
+        global.gc();
+        const after = process.memoryUsage();
         logInfo(
           `${workerLabel} Post-unload GC: rss ${(before.rss / 1024 / 1024).toFixed(1)}MB -> ${(after.rss / 1024 / 1024).toFixed(1)}MB`
         );
@@ -572,9 +672,10 @@ parentPort.on('message', async (message) => {
     }
 
     // ---- Batch file processing ----
-    if (message.type === 'processFiles') {
-      const { files, batchId } = message;
-      const batchTransfer = [];
+    if (message.type === 'processFiles') {
+      const { files, batchId } = message;
+      const batchTransfer = [];
+      const failFastState = createFailFastState('cross-file batch embedding');
 
       // 1. Pre-process all files: Read, Stat, and Chunk
       // We do this first to gather a massive list of chunks for batched inference
@@ -659,13 +760,13 @@ parentPort.on('message', async (message) => {
             continue;
           }
 
-          const { hash, callData, chunks } = meta;
-          const chunkCount = chunks.length;
-
-          // Trigger GC every 100 files
-          if ((i + 1) % 100 === 0 && typeof global.gc === 'function') {
-            global.gc();
-          }
+          const { hash, callData, chunks } = meta;
+          const chunkCount = chunks.length;
+
+          // Trigger GC every 100 files
+          if ((i + 1) % 100 === 0) {
+            maybeRunGc();
+          }
 
           // Register chunks for batching
           if (chunks.length > 0) {
@@ -713,39 +814,52 @@ parentPort.on('message', async (message) => {
           const batchSlice = allPendingChunks.slice(i, i + INFERENCE_BATCH_SIZE);
           const batchTexts = batchSlice.map((c) => c.text);
 
-          try {
-            const output = await embedder(batchTexts, { pooling: 'mean', normalize: true });
-            const hiddenSize = output.dims[output.dims.length - 1];
-
-            for (let j = 0; j < batchSlice.length; j++) {
-              const start = j * hiddenSize;
-              const end = start + hiddenSize;
-              const vectorView = output.data.subarray(start, end);
-              // Deep copy the view to avoid WASM memory issues, then apply MRL slicing
-              const vector = sliceAndNormalize(new Float32Array(vectorView), embeddingDimension);
+          try {
+            const output = await embedder(batchTexts, { pooling: 'mean', normalize: true });
+            const { data, hiddenSize } = getEmbeddingTensor(output, {
+              requireDimsForBatch: true,
+              batchSize: batchSlice.length,
+            });
+
+            for (let j = 0; j < batchSlice.length; j++) {
+              const start = j * hiddenSize;
+              const end = start + hiddenSize;
+              const vectorView =
+                typeof data.subarray === 'function'
+                  ? data.subarray(start, end)
+                  : data.slice(start, end);
+              // Deep copy the view to avoid WASM memory issues, then apply MRL slicing
+              const vector = sliceAndNormalize(new Float32Array(vectorView), embeddingDimension);
 
               batchSlice[j].vectorBuffer = vector.buffer;
               batchTransfer.push(vector.buffer);
             }
             // Properly dispose tensor to release ONNX runtime memory
-            if (typeof output.dispose === 'function')
-              try {
-                output.dispose();
-              } catch (disposeErr) {
-                if (workerData.verbose) {
-                  console.warn(`${workerLabel} Failed to dispose tensor: ${disposeErr.message}`);
-                }
-              }
-          } catch (err) {
-            console.warn(
-              `${workerLabel} Cross-file batch inference failed, retrying individually: ${err.message}`
-            );
-            // Fallback: individual embedding for this failed batch
-            for (const item of batchSlice) {
-              try {
-                const output = await embedder(item.text, { pooling: 'mean', normalize: true });
-                // Deep copy and apply MRL slicing
-                const vector = sliceAndNormalize(new Float32Array(output.data), embeddingDimension);
+            if (typeof output.dispose === 'function')
+              try {
+                output.dispose();
+              } catch (disposeErr) {
+                if (workerData.verbose) {
+                  console.warn(`${workerLabel} Failed to dispose tensor: ${disposeErr.message}`);
+                }
+            }
+            noteEmbeddingSuccess(failFastState);
+          } catch (err) {
+            if (isFatalRuntimeEmbeddingError(err)) {
+              noteEmbeddingFailure(failFastState, err);
+              throw err;
+            }
+            console.warn(
+              `${workerLabel} Cross-file batch inference failed, retrying individually: ${err.message}`
+            );
+            noteEmbeddingFailure(failFastState, err);
+            // Fallback: individual embedding for this failed batch
+            for (const item of batchSlice) {
+              try {
+                const output = await embedder(item.text, { pooling: 'mean', normalize: true });
+                const { data } = getEmbeddingTensor(output);
+                // Deep copy and apply MRL slicing
+                const vector = sliceAndNormalize(new Float32Array(data), embeddingDimension);
                 // Properly dispose tensor to release ONNX runtime memory
                 if (typeof output.dispose === 'function')
                   try {
@@ -755,13 +869,18 @@ parentPort.on('message', async (message) => {
                       console.warn(`${workerLabel} Failed to dispose tensor: ${disposeErr.message}`);
                     }
                   }
-                item.vectorBuffer = vector.buffer;
-                batchTransfer.push(vector.buffer);
-              } catch (innerErr) {
-                console.warn(`${workerLabel} Chunk embedding failed: ${innerErr.message}`);
-              }
-            }
-          }
+                item.vectorBuffer = vector.buffer;
+                batchTransfer.push(vector.buffer);
+                noteEmbeddingSuccess(failFastState);
+              } catch (innerErr) {
+                console.warn(`${workerLabel} Chunk embedding failed: ${innerErr.message}`);
+                noteEmbeddingFailure(failFastState, innerErr);
+                if (isFatalRuntimeEmbeddingError(innerErr)) {
+                  throw innerErr;
+                }
+              }
+            }
+          }
 
           // Minimal yield to keep event loop breathing (optional, can be removed for max throughput)
           if (allPendingChunks.length > 50 && i % 50 === 0) {
@@ -825,10 +944,10 @@ parentPort.on('message', async (message) => {
         batchTransfer
       );
 
-      // Explicitly clear references and trigger GC
-      batchTransfer.length = 0;
-      if (global.gc) global.gc();
-      return;
+      // Explicitly clear references and trigger GC
+      batchTransfer.length = 0;
+      maybeRunGc();
+      return;
     }
 
     // ---- Legacy protocol: batch of chunks prepared by main thread ----

package/lib/project-detector.js

@@ -56,7 +56,7 @@ export class ProjectDetector {
 
     for (const [type, marker] of discoveredTypes) {
       this.detectedTypes.add(type);
-      console.error(`[Detector] Detected ${type} project (${marker})`);
+      console.info(`[Detector] Detected ${type} project (${marker})`);
     }
 
     return Array.from(this.detectedTypes);