smart-coding-mcp 2.3.0 → 2.3.3

package/lib/embedding-worker.js

@@ -1,9 +1,31 @@
 import { parentPort, workerData } from "worker_threads";
 import { pipeline, layer_norm } from "@huggingface/transformers";
+import { existsSync, rmSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
 
 let embedder = null;
 const VALID_DIMENSIONS = [64, 128, 256, 512, 768];
 
+/**
+ * Clear the HuggingFace transformers cache for a specific model
+ * Used for auto-recovery from corrupted model files
+ */
+function clearModelCache(modelName) {
+  try {
+    const transformersPath = dirname(fileURLToPath(import.meta.resolve('@huggingface/transformers')));
+    const cacheDir = join(transformersPath, '.cache', ...modelName.split('/'));
+    if (existsSync(cacheDir)) {
+      console.error(`[Worker] Clearing corrupted cache: ${cacheDir}`);
+      rmSync(cacheDir, { recursive: true, force: true });
+      return true;
+    }
+  } catch (e) {
+    console.error(`[Worker] Failed to clear cache: ${e.message}`);
+  }
+  return false;
+}
+
 // Initialize the embedding model once when worker starts
 async function initializeEmbedder() {
   if (!embedder) {
@@ -11,12 +33,27 @@ async function initializeEmbedder() {
     const dimension = workerData.embeddingDimension || 256;
     const targetDim = VALID_DIMENSIONS.includes(dimension) ? dimension : 256;
     const isNomic = modelName.includes('nomic');
-    
-    const extractor = await pipeline("feature-extraction", modelName);
+
+    // Load model with auto-recovery for corrupted files
+    let extractor;
+    try {
+      extractor = await pipeline("feature-extraction", modelName);
+    } catch (err) {
+      if (err.message && err.message.includes('Protobuf parsing failed')) {
+        console.error(`[Worker] Corrupted model detected, attempting auto-recovery...`);
+        if (clearModelCache(modelName)) {
+          extractor = await pipeline("feature-extraction", modelName);
+        } else {
+          throw err;
+        }
+      } else {
+        throw err;
+      }
+    }
     
     if (isNomic) {
       // MRL embedder with dimension slicing
-      embedder = async function(text, options = {}) {
+      embedder = async function(text) {
         let embeddings = await extractor(text, { pooling: 'mean' });
         embeddings = layer_norm(embeddings, [embeddings.dims[1]])
           .slice(null, [0, targetDim])
@@ -26,7 +63,7 @@ async function initializeEmbedder() {
       embedder.dimension = targetDim;
     } else {
       // Legacy embedder (MiniLM etc.)
-      embedder = async function(text, options = {}) {
+      embedder = async function(text) {
         return await extractor(text, { pooling: 'mean', normalize: true });
       };
       embedder.dimension = 384;

package/lib/mrl-embedder.js

@@ -1,15 +1,50 @@
 /**
  * MRL (Matryoshka Representation Learning) Embedder
- * 
+ *
  * Provides flexible embedding dimensions (64, 128, 256, 512, 768) using
  * nomic-embed-text-v1.5 with layer normalization and dimension slicing.
  */
 
 import { pipeline, layer_norm } from '@huggingface/transformers';
+import { existsSync, rmSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
 
 // Valid MRL dimensions for nomic-embed-text-v1.5
 const VALID_DIMENSIONS = [64, 128, 256, 512, 768];
 
+/**
+ * Clear the HuggingFace transformers cache for a specific model
+ * Used for auto-recovery from corrupted model files
+ */
+function clearModelCache(modelName) {
+  try {
+    // Find the transformers package location
+    // import.meta.resolve may return .../dist/index.js, so check parent too
+    const resolvedPath = dirname(fileURLToPath(import.meta.resolve('@huggingface/transformers')));
+    const possibleRoots = [resolvedPath, dirname(resolvedPath)];
+
+    for (const root of possibleRoots) {
+      // Try different cache path patterns
+      const cachePaths = [
+        join(root, '.cache', modelName.replace('/', '-')),      // nomic-ai-nomic-embed-text-v1.5
+        join(root, '.cache', ...modelName.split('/'))           // nomic-ai/nomic-embed-text-v1.5
+      ];
+
+      for (const cacheDir of cachePaths) {
+        if (existsSync(cacheDir)) {
+          console.error(`[MRL] Clearing corrupted cache: ${cacheDir}`);
+          rmSync(cacheDir, { recursive: true, force: true });
+          return true;
+        }
+      }
+    }
+  } catch (e) {
+    console.error(`[MRL] Failed to clear cache: ${e.message}`);
+  }
+  return false;
+}
+
 /**
  * Create an MRL-enabled embedder with configurable output dimensions
  * 
@@ -35,34 +70,94 @@ export async function createMRLEmbedder(modelName, options = {}) {
   // Detect best device if auto
   const finalDevice = device === 'auto' ? detectBestDevice() : device;
   
-  // Create the feature extraction pipeline
+  // Create the feature extraction pipeline with auto-recovery for corrupted models
   const pipelineOptions = {};
   if (finalDevice === 'webgpu') {
     pipelineOptions.device = 'webgpu';
   }
-  
-  const extractor = await pipeline('feature-extraction', modelName, pipelineOptions);
-  
+
+  let extractor;
+
+  // Helper to detect corruption errors
+  function isCorruptionError(err) {
+    if (!err.message) return false;
+    return err.message.includes('Protobuf parsing failed') ||
+           err.message.includes('Invalid model') ||
+           err.message.includes('ONNX') && err.message.includes('corrupt');
+  }
+
+  // Helper to load/reload the extractor
+  async function loadExtractor(clearCache = false) {
+    if (clearCache) {
+      console.error(`[MRL] Corrupted model detected, attempting auto-recovery...`);
+      clearModelCache(modelName);
+    }
+    return await pipeline('feature-extraction', modelName, pipelineOptions);
+  }
+
+  try {
+    extractor = await loadExtractor();
+  } catch (err) {
+    if (isCorruptionError(err)) {
+      extractor = await loadExtractor(true);
+    } else {
+      throw err;
+    }
+  }
+
   console.error(`[MRL] Model loaded on ${finalDevice}`);
-  
+
+  // Fallback embedder for when MRL model fails at runtime
+  let fallbackEmbedder = null;
+
   /**
    * Embed text with MRL dimension slicing
    * Compatible with existing embedder(text, options) signature
+   * Includes runtime auto-recovery for corrupted models with fallback
    */
   async function embed(text, embedOptions = {}) {
-    // Generate full 768d embedding
-    let embeddings = await extractor(text, { pooling: 'mean' });
-    
-    // Apply MRL: layer_norm -> slice -> normalize
-    embeddings = layer_norm(embeddings, [embeddings.dims[1]])
-      .slice(null, [0, targetDim])
-      .normalize(2, -1);
-    
-    // Return in format compatible with existing code (has .data property)
-    return {
-      data: embeddings.data,
-      dims: [embeddings.dims[0], targetDim]
-    };
+    // If we've fallen back to legacy, use it
+    if (fallbackEmbedder) {
+      return await fallbackEmbedder(text, embedOptions);
+    }
+
+    async function doEmbed() {
+      // Generate full 768d embedding
+      let embeddings = await extractor(text, { pooling: 'mean' });
+
+      // Apply MRL: layer_norm -> slice -> normalize
+      embeddings = layer_norm(embeddings, [embeddings.dims[1]])
+        .slice(null, [0, targetDim])
+        .normalize(2, -1);
+
+      // Return in format compatible with existing code (has .data property)
+      return {
+        data: embeddings.data,
+        dims: [embeddings.dims[0], targetDim]
+      };
+    }
+
+    try {
+      return await doEmbed();
+    } catch (err) {
+      // Runtime corruption detection - try reload first
+      if (isCorruptionError(err)) {
+        console.error(`[MRL] Runtime corruption detected, attempting reload...`);
+        try {
+          extractor = await loadExtractor(true);
+          return await doEmbed();
+        } catch (reloadErr) {
+          // Reload failed - fall back to legacy model
+          console.error(`[MRL] Reload failed, falling back to legacy model...`);
+          const { createLegacyEmbedder } = await import('./mrl-embedder.js');
+          fallbackEmbedder = await createLegacyEmbedder();
+          embed.dimension = fallbackEmbedder.dimension;
+          embed.modelName = fallbackEmbedder.modelName;
+          return await fallbackEmbedder(text, embedOptions);
+        }
+      }
+      throw err;
+    }
   }
   
   // Attach metadata

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "smart-coding-mcp",
-  "version": "2.3.0",
+  "version": "2.3.3",
   "description": "An extensible MCP server that enhances coding productivity with AI-powered features including semantic code search, intelligent indexing, and more, using local LLMs",
   "type": "module",
   "main": "index.js",

package/test/model-cache-recovery.test.js

@@ -0,0 +1,242 @@
+/**
+ * Tests for Model Cache Auto-Recovery
+ *
+ * Tests the auto-recovery mechanism for corrupted ONNX model files:
+ * - Cache directory detection and clearing
+ * - Protobuf parsing error detection
+ * - Retry after cache clear
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { existsSync, mkdirSync, writeFileSync, rmSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { tmpdir } from 'os';
+
+// Create a test cache directory structure
+const testCacheBase = join(tmpdir(), 'smart-coding-mcp-test-cache');
+
+describe('Model Cache Recovery', () => {
+  beforeEach(() => {
+    // Clean up before each test
+    if (existsSync(testCacheBase)) {
+      rmSync(testCacheBase, { recursive: true, force: true });
+    }
+  });
+
+  afterEach(() => {
+    // Clean up after each test
+    if (existsSync(testCacheBase)) {
+      rmSync(testCacheBase, { recursive: true, force: true });
+    }
+  });
+
+  describe('Cache Directory Detection', () => {
+    it('should detect cache directory with forward slash model names', () => {
+      // Create a mock cache structure
+      const cacheDir = join(testCacheBase, 'nomic-ai', 'nomic-embed-text-v1.5', 'onnx');
+      mkdirSync(cacheDir, { recursive: true });
+      writeFileSync(join(cacheDir, 'model.onnx'), 'corrupted data');
+
+      expect(existsSync(cacheDir)).toBe(true);
+
+      // Simulate cache clear logic
+      const modelName = 'nomic-ai/nomic-embed-text-v1.5';
+      const cachePath = join(testCacheBase, ...modelName.split('/'));
+
+      if (existsSync(cachePath)) {
+        rmSync(cachePath, { recursive: true, force: true });
+      }
+
+      expect(existsSync(cachePath)).toBe(false);
+    });
+
+    it('should handle non-existent cache gracefully', () => {
+      const nonExistentPath = join(testCacheBase, 'does-not-exist');
+
+      // Should not throw
+      let cleared = false;
+      if (existsSync(nonExistentPath)) {
+        rmSync(nonExistentPath, { recursive: true, force: true });
+        cleared = true;
+      }
+
+      expect(cleared).toBe(false);
+    });
+
+    it('should clear nested model cache directories', () => {
+      // Create nested structure mimicking real cache
+      const modelDir = join(testCacheBase, 'nomic-ai', 'nomic-embed-text-v1.5');
+      const onnxDir = join(modelDir, 'onnx');
+      const tokenizerDir = join(modelDir, 'tokenizer');
+
+      mkdirSync(onnxDir, { recursive: true });
+      mkdirSync(tokenizerDir, { recursive: true });
+
+      writeFileSync(join(onnxDir, 'model.onnx'), 'corrupted');
+      writeFileSync(join(tokenizerDir, 'tokenizer.json'), '{}');
+
+      expect(existsSync(onnxDir)).toBe(true);
+      expect(existsSync(tokenizerDir)).toBe(true);
+
+      // Clear the model directory (not just onnx)
+      rmSync(modelDir, { recursive: true, force: true });
+
+      expect(existsSync(modelDir)).toBe(false);
+      expect(existsSync(onnxDir)).toBe(false);
+      expect(existsSync(tokenizerDir)).toBe(false);
+    });
+  });
+
+  describe('Error Detection', () => {
+    it('should identify Protobuf parsing errors as recoverable', () => {
+      const recoverableErrors = [
+        'Protobuf parsing failed',
+        'Load model from /path/to/model.onnx failed:Protobuf parsing failed.',
+        'Error: Protobuf parsing failed'
+      ];
+
+      for (const errorMsg of recoverableErrors) {
+        const isRecoverable = errorMsg.includes('Protobuf parsing failed');
+        expect(isRecoverable).toBe(true);
+      }
+    });
+
+    it('should not identify other errors as recoverable', () => {
+      const nonRecoverableErrors = [
+        'Network error',
+        'File not found',
+        'Out of memory',
+        'Invalid model format',
+        'ONNX runtime error'
+      ];
+
+      for (const errorMsg of nonRecoverableErrors) {
+        const isRecoverable = errorMsg.includes('Protobuf parsing failed');
+        expect(isRecoverable).toBe(false);
+      }
+    });
+  });
+
+  describe('Recovery Flow', () => {
+    it('should simulate recovery sequence', async () => {
+      // Create corrupted cache
+      const cacheDir = join(testCacheBase, 'nomic-ai', 'nomic-embed-text-v1.5');
+      mkdirSync(join(cacheDir, 'onnx'), { recursive: true });
+      writeFileSync(join(cacheDir, 'onnx', 'model.onnx'), 'corrupted protobuf data');
+
+      let loadAttempts = 0;
+      let cacheCleared = false;
+
+      // Simulate the recovery flow
+      const mockLoadModel = async () => {
+        loadAttempts++;
+        if (loadAttempts === 1 && !cacheCleared) {
+          throw new Error('Load model from /path/model.onnx failed:Protobuf parsing failed.');
+        }
+        return { success: true };
+      };
+
+      const mockClearCache = () => {
+        if (existsSync(cacheDir)) {
+          rmSync(cacheDir, { recursive: true, force: true });
+          cacheCleared = true;
+          return true;
+        }
+        return false;
+      };
+
+      // First attempt should fail
+      let result;
+      try {
+        result = await mockLoadModel();
+      } catch (err) {
+        if (err.message.includes('Protobuf parsing failed')) {
+          // Clear cache and retry
+          mockClearCache();
+          result = await mockLoadModel();
+        }
+      }
+
+      expect(loadAttempts).toBe(2);
+      expect(cacheCleared).toBe(true);
+      expect(result.success).toBe(true);
+      expect(existsSync(cacheDir)).toBe(false);
+    });
+
+    it('should propagate non-recoverable errors', async () => {
+      const mockLoadModel = async () => {
+        throw new Error('Network connection failed');
+      };
+
+      await expect(async () => {
+        try {
+          await mockLoadModel();
+        } catch (err) {
+          if (err.message.includes('Protobuf parsing failed')) {
+            // Would clear cache and retry, but this error is different
+          }
+          throw err;
+        }
+      }).rejects.toThrow('Network connection failed');
+    });
+
+    it('should handle cache clear failure gracefully', async () => {
+      let loadAttempts = 0;
+
+      const mockLoadModel = async () => {
+        loadAttempts++;
+        throw new Error('Protobuf parsing failed');
+      };
+
+      const mockClearCache = () => {
+        // Simulate cache clear failure (e.g., permission denied)
+        return false;
+      };
+
+      await expect(async () => {
+        try {
+          await mockLoadModel();
+        } catch (err) {
+          if (err.message.includes('Protobuf parsing failed')) {
+            if (!mockClearCache()) {
+              // Cache clear failed, re-throw original error
+              throw err;
+            }
+          } else {
+            throw err;
+          }
+        }
+      }).rejects.toThrow('Protobuf parsing failed');
+
+      expect(loadAttempts).toBe(1);
+    });
+  });
+
+  describe('Path Resolution', () => {
+    it('should handle model names with organization prefix', () => {
+      const modelName = 'nomic-ai/nomic-embed-text-v1.5';
+      const parts = modelName.split('/');
+
+      expect(parts).toEqual(['nomic-ai', 'nomic-embed-text-v1.5']);
+      expect(parts.length).toBe(2);
+    });
+
+    it('should handle model names without organization prefix', () => {
+      const modelName = 'all-MiniLM-L6-v2';
+      const parts = modelName.split('/');
+
+      expect(parts).toEqual(['all-MiniLM-L6-v2']);
+      expect(parts.length).toBe(1);
+    });
+
+    it('should build correct cache paths', () => {
+      const baseDir = '/some/cache/path';
+      const modelName = 'nomic-ai/nomic-embed-text-v1.5';
+
+      const cachePath = join(baseDir, ...modelName.split('/'));
+
+      expect(cachePath).toBe('/some/cache/path/nomic-ai/nomic-embed-text-v1.5');
+    });
+  });
+});

package/test/mrl-embedder.test.js

@@ -7,7 +7,7 @@
  * - Semantic similarity at different dimensions
  */
 
-import { describe, it, expect, beforeAll } from 'vitest';
+import { describe, it, expect, beforeAll, vi } from 'vitest';
 import { createMRLEmbedder, createLegacyEmbedder, createEmbedder, VALID_DIMENSIONS } from '../lib/mrl-embedder.js';
 import { cosineSimilarity } from '../lib/utils.js';
 
@@ -101,8 +101,114 @@ describe('createEmbedder Factory', () => {
       embeddingModel: 'Xenova/all-MiniLM-L6-v2',
       device: 'cpu'
     };
-    
+
     const embedder = await createEmbedder(config);
     expect(embedder.dimension).toBe(384);
   }, 120000);
 });
+
+describe('Auto-Recovery Logic', () => {
+  describe('Corruption Error Detection', () => {
+    it('should detect Protobuf parsing errors', async () => {
+      // We test this indirectly through the createEmbedder fallback behavior
+      // When MRL fails, it should fall back to legacy
+      const config = {
+        embeddingModel: 'nomic-ai/nomic-embed-text-v1.5',
+        embeddingDimension: 256,
+        device: 'cpu'
+      };
+
+      // This should succeed (model loads or recovers)
+      const embedder = await createEmbedder(config);
+      expect(embedder).toBeDefined();
+      expect(typeof embedder).toBe('function');
+    }, 120000);
+  });
+
+  describe('Runtime Recovery', () => {
+    let embedder;
+
+    beforeAll(async () => {
+      embedder = await createMRLEmbedder('nomic-ai/nomic-embed-text-v1.5', { dimension: 256 });
+    }, 120000);
+
+    it('should successfully embed after model is loaded', async () => {
+      const result = await embedder('test recovery');
+      expect(result.data).toBeDefined();
+      expect(result.dims[1]).toBe(256);
+    });
+
+    it('should have correct metadata after successful embedding', () => {
+      expect(embedder.dimension).toBe(256);
+      expect(embedder.modelName).toBe('nomic-ai/nomic-embed-text-v1.5');
+    });
+
+    it('should handle multiple sequential embeddings', async () => {
+      const texts = ['first text', 'second text', 'third text'];
+
+      for (const text of texts) {
+        const result = await embedder(text);
+        expect(result.data).toBeDefined();
+        expect(Array.from(result.data).length).toBe(256);
+      }
+    });
+  });
+
+  describe('Fallback Behavior', () => {
+    it('createEmbedder should fall back to legacy when MRL fails completely', async () => {
+      // Test that the factory handles failures gracefully
+      // Using a known-working legacy model
+      const config = {
+        embeddingModel: 'Xenova/all-MiniLM-L6-v2',
+        device: 'cpu'
+      };
+
+      const embedder = await createEmbedder(config);
+      expect(embedder.dimension).toBe(384);
+      expect(embedder.modelName).toBe('Xenova/all-MiniLM-L6-v2');
+
+      // Verify it actually works
+      const result = await embedder('fallback test');
+      expect(result.data).toBeDefined();
+    }, 120000);
+
+    it('legacy embedder should produce valid embeddings', async () => {
+      const embedder = await createLegacyEmbedder();
+
+      expect(embedder.dimension).toBe(384);
+      expect(embedder.modelName).toBe('Xenova/all-MiniLM-L6-v2');
+
+      const result = await embedder('legacy embedding test');
+      const vector = Array.from(result.data);
+
+      expect(vector.length).toBe(384);
+
+      // Check it's normalized
+      const magnitude = Math.sqrt(vector.reduce((sum, v) => sum + v * v, 0));
+      expect(magnitude).toBeCloseTo(1, 2);
+    }, 120000);
+  });
+});
+
+describe('Auto-Recovery with Mocked Pipeline', () => {
+  it('should handle corruption and recovery flow', async () => {
+    // This test verifies the recovery logic exists and embedder is resilient
+    const embedder = await createMRLEmbedder('nomic-ai/nomic-embed-text-v1.5', { dimension: 128 });
+
+    // Verify embedder works
+    const result1 = await embedder('before corruption test');
+    expect(result1.dims[1]).toBe(128);
+
+    // Run multiple embeddings to ensure stability
+    const results = await Promise.all([
+      embedder('concurrent test 1'),
+      embedder('concurrent test 2'),
+      embedder('concurrent test 3')
+    ]);
+
+    results.forEach(result => {
+      expect(result.dims[1]).toBe(128);
+      expect(Array.from(result.data).length).toBe(128);
+    });
+  }, 120000);
+});

package/test/mrl-recovery-real.test.js

@@ -0,0 +1,151 @@
+/**
+ * Real Integration Tests for MRL Auto-Recovery
+ *
+ * Tests embedder stability and error handling with real models.
+ * Destructive corruption tests are in mrl-recovery.test.js (mocked).
+ */
+
+import { describe, it, expect, beforeAll } from 'vitest';
+import { existsSync, readdirSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { createMRLEmbedder, createLegacyEmbedder, createEmbedder } from '../lib/mrl-embedder.js';
+
+// Find the transformers cache directory
+function getTransformersCacheDir() {
+  const transformersPath = dirname(fileURLToPath(import.meta.resolve('@huggingface/transformers')));
+  const cacheInParent = join(dirname(transformersPath), '.cache');
+  if (existsSync(cacheInParent)) return cacheInParent;
+  return join(transformersPath, '.cache');
+}
+
+describe('MRL Embedder Integration', () => {
+  const modelName = 'nomic-ai/nomic-embed-text-v1.5';
+  let embedder;
+
+  beforeAll(async () => {
+    console.log('[Test] Loading MRL embedder...');
+    embedder = await createMRLEmbedder(modelName, { dimension: 256 });
+    console.log('[Test] MRL embedder loaded');
+  }, 300000);
+
+  it('should create embedder with correct metadata', () => {
+    expect(embedder.dimension).toBe(256);
+    expect(embedder.modelName).toBe(modelName);
+    expect(embedder.device).toBe('cpu');
+  });
+
+  it('should produce correct dimension embeddings', async () => {
+    const result = await embedder('test embedding');
+    expect(result.data).toBeDefined();
+    expect(result.dims[1]).toBe(256);
+    expect(Array.from(result.data).length).toBe(256);
+  });
+
+  it('should produce normalized vectors', async () => {
+    const result = await embedder('normalized test');
+    const vector = Array.from(result.data);
+    const magnitude = Math.sqrt(vector.reduce((sum, v) => sum + v * v, 0));
+    expect(magnitude).toBeCloseTo(1, 3);
+  });
+
+  it('should handle multiple sequential embeddings', async () => {
+    const texts = ['first', 'second', 'third', 'fourth', 'fifth'];
+
+    for (const text of texts) {
+      const result = await embedder(text);
+      expect(result.data).toBeDefined();
+      expect(Array.from(result.data).length).toBe(256);
+    }
+  });
+
+  it('should handle concurrent embeddings', async () => {
+    const results = await Promise.all([
+      embedder('concurrent 1'),
+      embedder('concurrent 2'),
+      embedder('concurrent 3')
+    ]);
+
+    results.forEach(result => {
+      expect(result.data).toBeDefined();
+      expect(result.dims[1]).toBe(256);
+    });
+  });
+
+  it('should handle various input types', async () => {
+    const inputs = [
+      'normal text',
+      'a'.repeat(500),  // long text
+      'special: @#$%^&*()',
+      'unicode: 你好世界',
+      '   whitespace   '
+    ];
+
+    for (const input of inputs) {
+      const result = await embedder(input);
+      expect(result.data).toBeDefined();
+    }
+  });
+});
+
+describe('Legacy Embedder Integration', () => {
+  let embedder;
+
+  beforeAll(async () => {
+    embedder = await createLegacyEmbedder();
+  }, 120000);
+
+  it('should create legacy embedder with correct metadata', () => {
+    expect(embedder.dimension).toBe(384);
+    expect(embedder.modelName).toBe('Xenova/all-MiniLM-L6-v2');
+  });
+
+  it('should produce 384d embeddings', async () => {
+    const result = await embedder('legacy test');
+    expect(Array.from(result.data).length).toBe(384);
+  });
+});
+
+describe('Factory Function', () => {
+  it('should create MRL embedder for nomic model', async () => {
+    const embedder = await createEmbedder({
+      embeddingModel: 'nomic-ai/nomic-embed-text-v1.5',
+      embeddingDimension: 128,
+      device: 'cpu'
+    });
+
+    expect(embedder.dimension).toBe(128);
+    expect(embedder.modelName).toContain('nomic');
+  }, 300000);
+
+  it('should create legacy embedder for MiniLM', async () => {
+    const embedder = await createEmbedder({
+      embeddingModel: 'Xenova/all-MiniLM-L6-v2',
+      device: 'cpu'
+    });
+
+    expect(embedder.dimension).toBe(384);
+    expect(embedder.modelName).toBe('Xenova/all-MiniLM-L6-v2');
+  }, 120000);
+});
+
+describe('Cache Location Verification', () => {
+  it('should find transformers cache directory', () => {
+    const cacheDir = getTransformersCacheDir();
+    expect(existsSync(cacheDir)).toBe(true);
+    console.log(`[Test] Cache directory: ${cacheDir}`);
+  });
+
+  it('should have model files in cache', () => {
+    const cacheDir = getTransformersCacheDir();
+    const modelDir = join(cacheDir, 'nomic-ai', 'nomic-embed-text-v1.5', 'onnx');
+
+    if (existsSync(modelDir)) {
+      const files = readdirSync(modelDir);
+      expect(files.some(f => f.endsWith('.onnx'))).toBe(true);
+      console.log(`[Test] Model files: ${files.join(', ')}`);
+    } else {
+      console.log('[Test] Model directory not found (may need download)');
+    }
+  });
+});

package/test/mrl-recovery.test.js

@@ -0,0 +1,248 @@
+/**
+ * Tests for MRL Embedder Auto-Recovery
+ *
+ * Uses mocked pipeline to test corruption detection and recovery:
+ * - Startup corruption → clear cache → reload
+ * - Runtime corruption → reload → retry
+ * - Runtime corruption → reload fails → fallback to legacy
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+
+// Mock the transformers pipeline
+const mockPipeline = vi.fn();
+const mockLayerNorm = vi.fn();
+
+vi.mock('@huggingface/transformers', () => ({
+  pipeline: (...args) => mockPipeline(...args),
+  layer_norm: (...args) => mockLayerNorm(...args)
+}));
+
+// Mock fs for cache clearing
+vi.mock('fs', () => ({
+  existsSync: vi.fn(() => true),
+  rmSync: vi.fn()
+}));
+
+describe('MRL Auto-Recovery (Mocked)', () => {
+  let callCount = 0;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    callCount = 0;
+
+    // Default mock implementation for layer_norm
+    mockLayerNorm.mockImplementation((tensor) => ({
+      slice: () => ({
+        normalize: () => ({
+          data: new Float32Array(256).fill(0.1),
+          dims: [1, 256]
+        })
+      }),
+      dims: tensor.dims
+    }));
+  });
+
+  afterEach(() => {
+    vi.resetModules();
+  });
+
+  describe('Startup Recovery', () => {
+    it('should recover from corruption on first load', async () => {
+      // First call throws corruption, second succeeds
+      mockPipeline
+        .mockRejectedValueOnce(new Error('Protobuf parsing failed'))
+        .mockResolvedValueOnce(async () => ({
+          data: new Float32Array(768).fill(0.1),
+          dims: [1, 768]
+        }));
+
+      const { createMRLEmbedder } = await import('../lib/mrl-embedder.js');
+      const embedder = await createMRLEmbedder('test-model', { dimension: 256 });
+
+      expect(mockPipeline).toHaveBeenCalledTimes(2);
+      expect(embedder).toBeDefined();
+    });
+
+    it('should throw if recovery also fails with non-corruption error', async () => {
+      mockPipeline.mockRejectedValue(new Error('Network error'));
+
+      const { createMRLEmbedder } = await import('../lib/mrl-embedder.js');
+
+      await expect(createMRLEmbedder('test-model', { dimension: 256 }))
+        .rejects.toThrow('Network error');
+    });
+  });
+
+  describe('Runtime Recovery', () => {
+    it('should reload model on runtime corruption and retry', async () => {
+      let embedCallCount = 0;
+      const mockExtractor = vi.fn().mockImplementation(async () => {
+        embedCallCount++;
+        if (embedCallCount === 1) {
+          throw new Error('Protobuf parsing failed');
+        }
+        return {
+          data: new Float32Array(768).fill(0.1),
+          dims: [1, 768]
+        };
+      });
+
+      mockPipeline.mockResolvedValue(mockExtractor);
+
+      const { createMRLEmbedder } = await import('../lib/mrl-embedder.js');
+      const embedder = await createMRLEmbedder('test-model', { dimension: 256 });
+
+      // First embed triggers corruption, then reload and retry
+      const result = await embedder('test text');
+
+      expect(result.data).toBeDefined();
+      // Pipeline called: 1 (init) + 1 (reload after corruption) = 2
+      expect(mockPipeline).toHaveBeenCalledTimes(2);
+    });
+
+    it('should detect various corruption error messages', async () => {
+      const corruptionErrors = [
+        'Protobuf parsing failed',
+        'Invalid model format',
+        'ONNX model is corrupt'
+      ];
+
+      for (const errorMsg of corruptionErrors) {
+        vi.resetModules();
+        vi.clearAllMocks();
+
+        let throwError = true;
+        const mockExtractor = vi.fn().mockImplementation(async () => {
+          if (throwError) {
+            throwError = false;
+            throw new Error(errorMsg);
+          }
+          return {
+            data: new Float32Array(768).fill(0.1),
+            dims: [1, 768]
+          };
+        });
+
+        mockPipeline.mockResolvedValue(mockExtractor);
+        mockLayerNorm.mockImplementation((tensor) => ({
+          slice: () => ({
+            normalize: () => ({
+              data: new Float32Array(256).fill(0.1),
+              dims: [1, 256]
+            })
+          }),
+          dims: tensor.dims
+        }));
+
+        const { createMRLEmbedder } = await import('../lib/mrl-embedder.js');
+        const embedder = await createMRLEmbedder('test-model', { dimension: 256 });
+
+        const result = await embedder('test');
+        expect(result.data).toBeDefined();
+      }
+    });
+  });
+
+  describe('Fallback to Legacy', () => {
+    it('should fall back to legacy when reload also fails', async () => {
+      let pipelineCallCount = 0;
+      let embedCallCount = 0;
+
+      // Mock extractor that fails on first embed call
+      const corruptExtractor = vi.fn().mockImplementation(async () => {
+        embedCallCount++;
+        if (embedCallCount === 1) {
+          throw new Error('Protobuf parsing failed');
+        }
+        return {
+          data: new Float32Array(768).fill(0.1),
+          dims: [1, 768]
+        };
+      });
+
+      // Mock legacy extractor that works
+      const legacyExtractor = vi.fn().mockResolvedValue({
+        data: new Float32Array(384).fill(0.2),
+        dims: [1, 384]
+      });
+
+      mockPipeline.mockImplementation(async (task, model) => {
+        pipelineCallCount++;
+        if (pipelineCallCount <= 2) {
+          if (pipelineCallCount === 2) {
+            // Reload attempt fails
+            throw new Error('Network timeout');
+          }
+          return corruptExtractor;
+        }
+        // Third call is legacy model
+        return legacyExtractor;
+      });
+
+      const { createMRLEmbedder } = await import('../lib/mrl-embedder.js');
+      const embedder = await createMRLEmbedder('nomic-ai/nomic-embed-text-v1.5', { dimension: 256 });
+
+      // This should trigger: corruption → reload fail → fallback to legacy
+      const result = await embedder('test text');
+
+      expect(result.data).toBeDefined();
+      // Dimension should update to legacy (384)
+      expect(embedder.dimension).toBe(384);
+    });
+
+    it('should use fallback for subsequent calls after switching', async () => {
+      let pipelineCallCount = 0;
+      let embedCallCount = 0;
+
+      const corruptExtractor = vi.fn().mockImplementation(async () => {
+        embedCallCount++;
+        throw new Error('Protobuf parsing failed');
+      });
+
+      const legacyExtractor = vi.fn().mockResolvedValue({
+        data: new Float32Array(384).fill(0.2),
+        dims: [1, 384]
+      });
+
+      mockPipeline.mockImplementation(async (task, model) => {
+        pipelineCallCount++;
+        if (model.includes('nomic')) {
+          if (pipelineCallCount >= 2) {
+            throw new Error('Model unavailable');
+          }
+          return corruptExtractor;
+        }
+        return legacyExtractor;
+      });
+
+      const { createMRLEmbedder } = await import('../lib/mrl-embedder.js');
+      const embedder = await createMRLEmbedder('nomic-ai/nomic-embed-text-v1.5', { dimension: 256 });
+
+      // First call triggers fallback
+      await embedder('first');
+
+      // Subsequent calls should use legacy directly
+      const legacyCallsBefore = legacyExtractor.mock.calls.length;
+      await embedder('second');
+      await embedder('third');
+
+      expect(legacyExtractor.mock.calls.length).toBe(legacyCallsBefore + 2);
+    });
+  });
+
+  describe('Non-Corruption Errors', () => {
+    it('should throw non-corruption errors without recovery attempt', async () => {
+      const mockExtractor = vi.fn().mockRejectedValue(new Error('Out of memory'));
+      mockPipeline.mockResolvedValue(mockExtractor);
+
+      const { createMRLEmbedder } = await import('../lib/mrl-embedder.js');
+      const embedder = await createMRLEmbedder('test-model', { dimension: 256 });
+
+      await expect(embedder('test')).rejects.toThrow('Out of memory');
+
+      // Should not have attempted reload (only initial load)
+      expect(mockPipeline).toHaveBeenCalledTimes(1);
+    });
+  });
+});