mindforge-cc 8.2.0 → 9.0.0

package/.mindforge/mirrors/mirror-sre-776a1cf9/tests/knowledge-graph.test.js

@@ -1,593 +0,0 @@
-/**
- * MindForge v2.4.0 — Knowledge Graph Test Suite (RAG 2.0)
- * Tests: Embedding Engine, Graph Engine, Auto-Shadow, and Integration.
- */
-'use strict';
-
-const fs     = require('fs');
-const path   = require('path');
-const assert = require('assert');
-
-const Store    = require('../bin/memory/knowledge-store');
-const Embedder = require('../bin/memory/embedding-engine');
-const Graph    = require('../bin/memory/knowledge-graph');
-const Shadow   = require('../bin/memory/auto-shadow');
-
-// ── Test Environment ──────────────────────────────────────────────────────────
-// Use project-relative dir to stay within macOS App Sandbox scope
-const TEST_BASE = path.join(__dirname, 'tmp-graph');
-
-function setup() {
-  if (fs.existsSync(TEST_BASE)) fs.rmSync(TEST_BASE, { recursive: true });
-  fs.mkdirSync(TEST_BASE, { recursive: true });
-  // Use setTestMode to directly set memory dir (bypasses .mindforge/memory/ nesting)
-  Store.setTestMode(TEST_BASE);
-  Graph.setTestMode(TEST_BASE);
-}
-
-function cleanup() {
-  Store.setTestMode(null);
-  Graph.setTestMode(null);
-  if (fs.existsSync(TEST_BASE)) fs.rmSync(TEST_BASE, { recursive: true });
-}
-
-function seedEntries() {
-  const ids = {};
-
-  ids.jwt = Store.add({
-    type: 'architectural_decision', topic: 'JWT Authentication Strategy',
-    content: 'Use httpOnly cookies for JWT storage. Rotate refresh tokens on each use. Set access token TTL to 15 minutes.',
-    confidence: 0.9, tags: ['auth', 'security', 'jwt'],
-  });
-
-  ids.bcrypt = Store.add({
-    type: 'code_pattern', topic: 'Password Hashing with bcrypt',
-    content: 'Always use bcrypt with salt rounds >= 12 for password hashing. Never store plaintext passwords.',
-    confidence: 0.85, tags: ['auth', 'security'],
-  });
-
-  ids.sqlInjection = Store.add({
-    type: 'bug_pattern', topic: 'SQL Injection via Unsanitized Input',
-    content: 'Raw SQL string concatenation caused injection vulnerability. Root cause: missing parameterized queries.',
-    confidence: 0.8, tags: ['security', 'database'],
-    root_cause: 'String concatenation in SQL queries', fix: 'Use parameterized queries via Prisma/Drizzle',
-  });
-
-  ids.reactMemo = Store.add({
-    type: 'code_pattern', topic: 'React Performance with useMemo',
-    content: 'Use React.memo and useMemo for expensive computations. Avoid re-renders in list components.',
-    confidence: 0.7, tags: ['ui', 'performance', 'react'],
-  });
-
-  ids.tailwind = Store.add({
-    type: 'team_preference', topic: 'CSS Framework: Tailwind CSS',
-    content: 'Team prefers Tailwind CSS for all new UI components. Use utility-first approach.',
-    confidence: 0.75, tags: ['ui', 'css'],
-  });
-
-  ids.caching = Store.add({
-    type: 'domain_knowledge', topic: 'Redis Caching Strategy',
-    content: 'Use Redis for session storage and API response caching. Set TTL based on data volatility.',
-    confidence: 0.65, tags: ['performance', 'infra'],
-  });
-
-  return ids;
-}
-
-// ── Embedding Engine Tests ────────────────────────────────────────────────────
-
-async function testTokenizer() {
-  console.log('  Testing Tokenizer...');
-
-  const tokens = Embedder.tokenize('userId camelCase snake_case kebab-case');
-  assert.ok(tokens.includes('user'), 'Should split camelCase');
-  assert.ok(tokens.includes('camel'), 'Should split camelCase');
-  assert.ok(tokens.includes('snake'), 'Should split snake_case');
-  assert.ok(tokens.includes('kebab'), 'Should split kebab-case');
-
-  const stopwords = Embedder.tokenize('the a an is it in on at to for of');
-  assert.strictEqual(stopwords.length, 0, 'Should filter all stopwords');
-
-  const empty = Embedder.tokenize('');
-  assert.strictEqual(empty.length, 0, 'Empty string returns empty array');
-
-  const nullInput = Embedder.tokenize(null);
-  assert.strictEqual(nullInput.length, 0, 'Null returns empty array');
-
-  console.log('  ✅ Tokenizer passed');
-}
-
-async function testBigrams() {
-  console.log('  Testing Bigrams...');
-
-  const tokens = ['react', 'memo', 'performance'];
-  const bi = Embedder.bigrams(tokens);
-  assert.strictEqual(bi.length, 2);
-  assert.strictEqual(bi[0], 'react_memo');
-  assert.strictEqual(bi[1], 'memo_performance');
-
-  console.log('  ✅ Bigrams passed');
-}
-
-async function testCosineSimilarity() {
-  console.log('  Testing Cosine Similarity...');
-
-  // Identical vectors → similarity = 1.0
-  const vecA = { jwt: 1.0, auth: 0.5 };
-  const sim1 = Embedder.cosineSimilarity(vecA, vecA);
-  assert.ok(Math.abs(sim1 - 1.0) < 0.001, `Self-similarity should be 1.0, got ${sim1}`);
-
-  // Orthogonal vectors → similarity = 0.0
-  const vecB = { react: 1.0, css: 0.5 };
-  const sim2 = Embedder.cosineSimilarity(vecA, vecB);
-  assert.strictEqual(sim2, 0, 'Orthogonal vectors should have 0 similarity');
-
-  // Null vectors
-  assert.strictEqual(Embedder.cosineSimilarity(null, vecA), 0);
-  assert.strictEqual(Embedder.cosineSimilarity({}, vecA), 0);
-
-  console.log('  ✅ Cosine Similarity passed');
-}
-
-async function testBuildEmbeddings() {
-  console.log('  Testing Build Embeddings...');
-  setup();
-  const ids = seedEntries();
-
-  const entries = Store.readAll();
-  const { vectors, df, N } = Embedder.buildEmbeddings(entries);
-
-  assert.ok(vectors.size > 0, 'Should create vectors');
-  assert.ok(df.size > 0, 'Should build document frequency');
-  assert.ok(N > 0, 'Corpus size should be positive');
-
-  // JWT entry should have a vector
-  assert.ok(vectors.has(ids.jwt), 'JWT entry should have a vector');
-
-  console.log('  ✅ Build Embeddings passed');
-}
-
-async function testFindSimilar() {
-  console.log('  Testing Find Similar...');
-  setup();
-  seedEntries();
-
-  const entries = Store.readAll();
-  const { vectors, df, N } = Embedder.buildEmbeddings(entries);
-
-  // Query about auth should find JWT and bcrypt entries
-  const results = Embedder.findSimilar('authentication security JWT', vectors, df, N, 5, 0.1);
-  assert.ok(results.length > 0, 'Should find similar entries');
-  assert.ok(results[0].similarity > 0, 'Top result should have positive similarity');
-
-  console.log('  ✅ Find Similar passed');
-}
-
-async function testInferEdges() {
-  console.log('  Testing Infer Edges...');
-  setup();
-  const ids = seedEntries();
-
-  const entries = Store.readAll();
-  const { vectors } = Embedder.buildEmbeddings(entries);
-
-  // JWT and bcrypt are both about auth/security — should have high similarity
-  const candidates = Embedder.inferEdges(ids.jwt, vectors);
-  // At least one candidate should exist
-  assert.ok(Array.isArray(candidates), 'Should return array');
-
-  console.log('  ✅ Infer Edges passed');
-}
-
-// ── Graph Engine Tests ────────────────────────────────────────────────────────
-
-async function testAddEdge() {
-  console.log('  Testing Add Edge...');
-  setup();
-  const ids = seedEntries();
-
-  const edgeId = Graph.addEdge({
-    sourceId: ids.jwt,
-    targetId: ids.bcrypt,
-    type: 'RELATED_TO',
-    weight: 0.8,
-    reason: 'Both are about authentication security',
-  });
-
-  assert.ok(edgeId, 'Should return edge ID');
-
-  const edges = Graph.readAllEdges();
-  assert.strictEqual(edges.length, 1, 'Should have 1 edge');
-  assert.strictEqual(edges[0].type, 'RELATED_TO');
-  assert.strictEqual(edges[0].weight, 0.8);
-
-  console.log('  ✅ Add Edge passed');
-}
-
-async function testSelfRefGuard() {
-  console.log('  Testing Self-Reference Guard...');
-  setup();
-  const ids = seedEntries();
-
-  try {
-    Graph.addEdge({
-      sourceId: ids.jwt,
-      targetId: ids.jwt,
-      type: 'RELATED_TO',
-    });
-    assert.fail('Should throw for self-reference');
-  } catch (err) {
-    assert.ok(err.message.includes('Self-referencing'), `Got: ${err.message}`);
-  }
-
-  console.log('  ✅ Self-Reference Guard passed');
-}
-
-async function testInvalidEdgeType() {
-  console.log('  Testing Invalid Edge Type Guard...');
-  setup();
-  const ids = seedEntries();
-
-  try {
-    Graph.addEdge({
-      sourceId: ids.jwt,
-      targetId: ids.bcrypt,
-      type: 'INVALID_TYPE',
-    });
-    assert.fail('Should throw for invalid edge type');
-  } catch (err) {
-    assert.ok(err.message.includes('Invalid edge type'), `Got: ${err.message}`);
-  }
-
-  console.log('  ✅ Invalid Edge Type Guard passed');
-}
-
-async function testEdgeChecksum() {
-  console.log('  Testing Edge SHA-256 Checksum...');
-  setup();
-  const ids = seedEntries();
-
-  Graph.addEdge({
-    sourceId: ids.jwt,
-    targetId: ids.bcrypt,
-    type: 'RELATED_TO',
-    weight: 0.75,
-  });
-
-  const result = Graph.verifyEdgeIntegrity();
-  assert.strictEqual(result.valid, 1, 'Edge should pass integrity check');
-  assert.strictEqual(result.corrupted.length, 0, 'No corrupted edges');
-
-  console.log('  ✅ Edge SHA-256 Checksum passed');
-}
-
-async function testGraphTraversal() {
-  console.log('  Testing Graph Traversal...');
-  setup();
-  const ids = seedEntries();
-
-  // Create a chain: JWT → bcrypt → sqlInjection
-  Graph.addEdge({ sourceId: ids.jwt, targetId: ids.bcrypt, type: 'RELATED_TO', weight: 0.8 });
-  Graph.addEdge({ sourceId: ids.bcrypt, targetId: ids.sqlInjection, type: 'RELATED_TO', weight: 0.7 });
-
-  // 1-hop from JWT should find bcrypt
-  const hop1 = Graph.traverse(ids.jwt, 1);
-  assert.ok(hop1.some(r => r.id === ids.bcrypt), 'Should find bcrypt at 1 hop');
-  assert.ok(!hop1.some(r => r.id === ids.sqlInjection), 'Should NOT find sqlInjection at 1 hop');
-
-  // 2-hop from JWT should find both bcrypt and sqlInjection
-  const hop2 = Graph.traverse(ids.jwt, 2);
-  assert.ok(hop2.some(r => r.id === ids.bcrypt), 'Should find bcrypt at 2 hops');
-  assert.ok(hop2.some(r => r.id === ids.sqlInjection), 'Should find sqlInjection at 2 hops');
-
-  // Filter by edge type
-  Graph.addEdge({ sourceId: ids.jwt, targetId: ids.caching, type: 'INFORMS', weight: 0.5 });
-  const filtered = Graph.traverse(ids.jwt, 2, { edgeTypes: ['INFORMS'] });
-  assert.ok(filtered.some(r => r.id === ids.caching), 'Should find caching via INFORMS');
-  assert.ok(!filtered.some(r => r.id === ids.bcrypt), 'Should NOT find bcrypt when filtering INFORMS');
-
-  console.log('  ✅ Graph Traversal passed');
-}
-
-async function testEdgeReinforcement() {
-  console.log('  Testing Edge Reinforcement...');
-  setup();
-  const ids = seedEntries();
-
-  const edgeId = Graph.addEdge({
-    sourceId: ids.jwt, targetId: ids.bcrypt,
-    type: 'RELATED_TO', weight: 0.5,
-  });
-
-  Graph.reinforceEdge(edgeId);
-  const edges = Graph.readAllEdges();
-  const reinforced = edges.find(e => e.id === edgeId);
-  assert.ok(reinforced.weight > 0.5, 'Weight should increase after reinforcement');
-  assert.strictEqual(reinforced.traversal_count, 1, 'Traversal count should increment');
-  assert.ok(reinforced.last_traversed, 'Should set last_traversed timestamp');
-
-  console.log('  ✅ Edge Reinforcement passed');
-}
-
-async function testCycleDetection() {
-  console.log('  Testing Cycle Detection...');
-  setup();
-  const ids = seedEntries();
-
-  // Create a CAUSED_BY chain (no cycle)
-  Graph.addEdge({ sourceId: ids.sqlInjection, targetId: ids.bcrypt, type: 'CAUSED_BY', weight: 0.6 });
-  const noCycles = Graph.detectCycles();
-  assert.strictEqual(noCycles.length, 0, 'Should detect no cycles');
-
-  // Create a CAUSED_BY cycle
-  Graph.addEdge({ sourceId: ids.bcrypt, targetId: ids.sqlInjection, type: 'CAUSED_BY', weight: 0.5 });
-  const cycles = Graph.detectCycles();
-  assert.ok(cycles.length > 0, 'Should detect the cycle');
-
-  console.log('  ✅ Cycle Detection passed');
-}
-
-async function testGraphStats() {
-  console.log('  Testing Graph Statistics...');
-  setup();
-  const ids = seedEntries();
-
-  Graph.addEdge({ sourceId: ids.jwt, targetId: ids.bcrypt, type: 'RELATED_TO', weight: 0.8 });
-  Graph.addEdge({ sourceId: ids.bcrypt, targetId: ids.sqlInjection, type: 'CAUSED_BY', weight: 0.6 });
-
-  const stats = Graph.graphStats();
-  assert.strictEqual(stats.total_edges, 2, 'Should have 2 edges');
-  assert.ok(stats.total_nodes > 0, 'Should have nodes');
-  assert.ok(stats.edges_by_type['RELATED_TO'] === 1);
-  assert.ok(stats.edges_by_type['CAUSED_BY'] === 1);
-  assert.ok(stats.connected_ratio > 0, 'Some nodes should be connected');
-  assert.ok(stats.orphan_nodes >= 0, 'Orphan count should be non-negative');
-
-  console.log('  ✅ Graph Statistics passed');
-}
-
-// ── Auto-Shadow Tests ─────────────────────────────────────────────────────────
-
-async function testAutoShadowGeneration() {
-  console.log('  Testing Auto-Shadow Generation...');
-  setup();
-  const ids = seedEntries();
-
-  // Create some edges for graph traversal
-  Graph.addEdge({ sourceId: ids.jwt, targetId: ids.bcrypt, type: 'RELATED_TO', weight: 0.8 });
-
-  const result = Shadow.generateShadowContext({
-    taskDescription: 'Implement JWT authentication with secure password hashing',
-    techStack: ['node', 'express'],
-  });
-
-  assert.ok(result.count >= 0, 'Should return count');
-  assert.ok(result.budgetUsed >= 0, 'Should track budget used');
-  assert.ok(result.budgetUsed <= Shadow.MAX_SHADOW_CHARS, 'Should not exceed budget');
-
-  if (result.count > 0) {
-    assert.ok(result.formatted.includes('Auto-Shadow Context'), 'Should contain header');
-    assert.ok(result.formatted.includes('ghost patterns'), 'Should contain description');
-  }
-
-  console.log('  ✅ Auto-Shadow Generation passed');
-}
-
-async function testSecurityGuard() {
-  console.log('  Testing Security Guard...');
-
-  // SECRET entries should be filtered
-  const sensitiveEntry = {
-    topic: 'Restricted Data',
-    content: 'Pattern: [REDACTED_TYPE_A]',
-    tags: ['protected'],
-  };
-  assert.ok(Shadow.containsSecrets(sensitiveEntry), 'Should detect protected pattern');
-
-  const infraEntry = {
-    topic: 'Infrastructure Detail',
-    content: 'Pattern: [REDACTED_TYPE_B]',
-    tags: ['infra'],
-  };
-  assert.ok(Shadow.containsSecrets(infraEntry), 'Should detect infra pattern');
-
-  const safeEntry = {
-    topic: 'React Patterns',
-    content: 'Use composition over inheritance for component design.',
-    tags: ['ui'],
-  };
-  assert.ok(!Shadow.containsSecrets(safeEntry), 'Should allow safe entry');
-
-  console.log('  ✅ Security Guard passed');
-}
-
-async function testBudgetCap() {
-  console.log('  Testing Budget Cap...');
-  setup();
-
-  // Add many entries to test budget capping
-  for (let i = 0; i < 50; i++) {
-    Store.add({
-      type: 'domain_knowledge',
-      topic: `Knowledge Item ${i} about authentication and security patterns`,
-      content: `Detailed description ${i}: ${'Lorem ipsum dolor sit amet. '.repeat(10)}`,
-      confidence: 0.7 + (i % 10) * 0.02,
-      tags: ['auth', 'security'],
-    });
-  }
-
-  const result = Shadow.generateShadowContext({
-    taskDescription: 'authentication security implementation',
-  });
-
-  assert.ok(result.budgetUsed <= Shadow.MAX_SHADOW_CHARS,
-    `Budget ${result.budgetUsed} should not exceed ${Shadow.MAX_SHADOW_CHARS}`);
-  assert.ok(result.count <= Shadow.MAX_SHADOW_ITEMS,
-    `Item count ${result.count} should not exceed ${Shadow.MAX_SHADOW_ITEMS}`);
-
-  console.log('  ✅ Budget Cap passed');
-}
-
-async function testEmptyQuery() {
-  console.log('  Testing Empty Query...');
-  setup();
-
-  const result = Shadow.generateShadowContext({
-    taskDescription: '',
-  });
-
-  assert.strictEqual(result.count, 0, 'Empty query should return 0 items');
-  assert.strictEqual(result.formatted, '', 'Empty query should return empty string');
-
-  console.log('  ✅ Empty Query passed');
-}
-
-// ── Embedding Cache Tests ─────────────────────────────────────────────────────
-
-async function testEmbeddingCache() {
-  console.log('  Testing Embedding Cache...');
-  setup();
-  seedEntries();
-
-  const entries = Store.readAll();
-  const { vectors, df, N } = Embedder.buildEmbeddings(entries);
-
-  const cachePath = path.join(TEST_BASE, 'embeddings.json');
-
-  // Save cache
-  Embedder.saveCache(cachePath, vectors, df, N);
-  assert.ok(fs.existsSync(cachePath), 'Cache file should exist');
-
-  // Load cache
-  const loaded = Embedder.loadCache(cachePath);
-  assert.ok(loaded, 'Should load cache successfully');
-  assert.strictEqual(loaded.N, N, 'Corpus size should match');
-  assert.strictEqual(loaded.vectors.size, vectors.size, 'Vector count should match');
-
-  // Corrupt cache
-  fs.writeFileSync(cachePath, 'invalid json');
-  const corrupted = Embedder.loadCache(cachePath);
-  assert.strictEqual(corrupted, null, 'Should return null for corrupted cache');
-
-  console.log('  ✅ Embedding Cache passed');
-}
-
-// ── Integration Tests ─────────────────────────────────────────────────────────
-
-async function testHybridQuery() {
-  console.log('  Testing Hybrid Query (Embedding + Graph)...');
-  setup();
-  const ids = seedEntries();
-
-  // Create edges
-  Graph.addEdge({ sourceId: ids.jwt, targetId: ids.bcrypt, type: 'RELATED_TO', weight: 0.8 });
-  Graph.addEdge({ sourceId: ids.bcrypt, targetId: ids.sqlInjection, type: 'CAUSED_BY', weight: 0.6 });
-  Graph.addEdge({ sourceId: ids.jwt, targetId: ids.caching, type: 'INFORMS', weight: 0.4 });
-
-  const entries = Store.readAll();
-  const { vectors, df, N } = Embedder.buildEmbeddings(entries);
-
-  const results = Graph.findRelated('JWT authentication security', vectors, df, N, {
-    maxHops: 2, topK: 5,
-  });
-
-  // With a small 6-entry corpus, TF-IDF may or may not produce above-threshold results.
-  // Validate the pipeline returns a proper array with correct structure.
-  assert.ok(Array.isArray(results), 'Should return an array');
-  for (const r of results) {
-    assert.ok(r.id, 'Each result should have an id');
-    assert.ok(typeof r.score === 'number', 'Each result should have a numeric score');
-    assert.ok(r.score > 0, 'Score must be positive');
-    assert.ok(['embedding', 'graph', 'hybrid'].includes(r.source),
-      `Source should be embedding/graph/hybrid, got ${r.source}`);
-  }
-
-  // Verify that graph-only results can be found even without embedding matches
-  // by querying with exact terms from entries
-  const exactResults = Graph.findRelated('bcrypt salt password hashing security authentication', vectors, df, N, {
-    maxHops: 2, topK: 10,
-  });
-  // At minimum the graph should return connected nodes since we have explicit edges
-  assert.ok(Array.isArray(exactResults), 'Exact query should return array');
-
-  console.log('  ✅ Hybrid Query passed');
-}
-
-async function testEdgeDeprecation() {
-  console.log('  Testing Edge Deprecation...');
-  setup();
-  const ids = seedEntries();
-
-  const edgeId = Graph.addEdge({
-    sourceId: ids.jwt, targetId: ids.bcrypt,
-    type: 'RELATED_TO', weight: 0.5,
-  });
-
-  Graph.deprecateEdge(edgeId, 'No longer relevant');
-  const edges = Graph.readAllEdges();
-  assert.ok(!edges.some(e => e.id === edgeId), 'Deprecated edge should be filtered out');
-
-  console.log('  ✅ Edge Deprecation passed');
-}
-
-// ── Test Runner ───────────────────────────────────────────────────────────────
-
-async function runAll() {
-  console.log('--- MindForge Knowledge Graph (RAG 2.0) Test Suite ---\n');
-
-  let passed = 0;
-  let failed = 0;
-
-  const tests = [
-    // Embedding Engine
-    testTokenizer,
-    testBigrams,
-    testCosineSimilarity,
-    testBuildEmbeddings,
-    testFindSimilar,
-    testInferEdges,
-    // Graph Engine
-    testAddEdge,
-    testSelfRefGuard,
-    testInvalidEdgeType,
-    testEdgeChecksum,
-    testGraphTraversal,
-    testEdgeReinforcement,
-    testCycleDetection,
-    testGraphStats,
-    // Auto-Shadow
-    testAutoShadowGeneration,
-    testSecurityGuard,
-    testBudgetCap,
-    testEmptyQuery,
-    // Cache
-    testEmbeddingCache,
-    // Integration
-    testHybridQuery,
-    testEdgeDeprecation,
-  ];
-
-  for (const test of tests) {
-    try {
-      await test();
-      passed++;
-    } catch (err) {
-      failed++;
-      console.error(`  ❌ ${test.name} FAILED:`);
-      console.error(`     ${err.message}`);
-      if (process.env.MINDFORGE_DEBUG) console.error(err.stack);
-    }
-  }
-
-  cleanup();
-
-  console.log(`\n--- Results: ${passed}/${passed + failed} tests passed ---`);
-  if (failed > 0) {
-    console.error(`\n❌ ${failed} test(s) failed!`);
-    process.exit(1);
-  } else {
-    console.log('\n✅ All Knowledge Graph tests passed!');
-  }
-}
-
-runAll();

package/.mindforge/mirrors/mirror-sre-776a1cf9/tests/learning-engine.test.js

@@ -1,69 +0,0 @@
-/**
- * MindForge Learning Engine Test Suite
- * Part of the Sovereign Intelligence v6.2.0-alpha validation.
- */
-'use strict';
-
-const fs = require('fs');
-const path = require('path');
-const LearningManager = require('../bin/engine/learning-manager');
-
-async function runTests() {
-  console.log('🧪 Starting Learning Engine Tests...');
-  
-  const testDir = path.join(__dirname, 'tmp-learning-test');
-  if (fs.existsSync(testDir)) fs.rmSync(testDir, { recursive: true, force: true });
-  fs.mkdirSync(testDir, { recursive: true });
-
-  const manager = new LearningManager({
-    rootDir: testDir,
-    templateDir: path.join(__dirname, '../docs/templates/Project')
-  });
-
-  try {
-    // 1. Test Initialization
-    console.log('  Testing init()...');
-    const learningFile = await manager.init({
-      name: 'Test Project',
-      techStack: 'Node.js, Mocha',
-      systemDid: '0xunittest'
-    });
-
-    if (!fs.existsSync(learningFile)) throw new Error('Initialization failed: file not created');
-    const content = fs.readFileSync(learningFile, 'utf8');
-    if (!content.includes('Test Project')) throw new Error('Initialization failed: content not hydrated');
-    console.log('  ✅ init() passed');
-
-    // 2. Test Recording
-    console.log('  Testing record()...');
-    await manager.record({
-      context: 'Unit Test Wave',
-      mistake: 'Failing to clean up tmp-test-dir',
-      rootCause: 'Manual intervention omitted RM command',
-      fix: 'Implemented fs.rmSync in teardown',
-      category: 'Bug Fix',
-      did: 'did:mindforge:enclave:0xunittest'
-    });
-
-    const updatedContent = fs.readFileSync(learningFile, 'utf8');
-    if (!updatedContent.includes('Unit Test Wave')) throw new Error('Recording failed: entry not found');
-    if (!updatedContent.includes('did:mindforge:enclave:0xunittest')) throw new Error('Recording failed: DID not found');
-    console.log('  ✅ record() passed');
-
-    // 3. Test Status
-    console.log('  Testing getStatus()...');
-    const status = await manager.getStatus();
-    if (status.entryCount !== 1) throw new Error(`Status failed: expected 1 entry, got ${status.entryCount}`);
-    console.log('  ✅ getStatus() passed');
-
-    console.log('\n🎉 All Learning Engine tests passed!');
-  } catch (err) {
-    console.error(`\n❌ Test failed: ${err.message}`);
-    process.exit(1);
-  } finally {
-    // Cleanup
-    if (fs.existsSync(testDir)) fs.rmSync(testDir, { recursive: true, force: true });
-  }
-}
-
-runTests();

package/.mindforge/mirrors/mirror-sre-776a1cf9/tests/mca-routing-test.js

@@ -1,37 +0,0 @@
-/**
- * MindForge — Pillar V: Multi-Cloud Arbitrage Test
- * Verifies Affinity Routing based on historical task performance.
- */
-'use strict';
-
-const CloudBroker = require('../bin/models/cloud-broker');
-const fs = require('fs');
-const path = require('path');
-
-async function runTest() {
-  console.log('--- STARTING MCA AFFINITY ROUTING TEST ---');
-
-  const broker = new CloudBroker();
-  
-  // Test Case 1: Refactor Task
-  // Based on seed data: Anthropic (45/2) vs Google (25/8)
-  console.log('\n[TEST] Routing a "refactor" task...');
-  const provider1 = broker.getBestProvider({ taskType: 'refactor' });
-  console.log(`Result: ${provider1} (Expected: anthropic)`);
-
-  // Test Case 2: Test Task
-  // Based on seed data: Google (50/2) vs Anthropic (30/1)
-  // Google has more volume and high success, should be preferred for testing
-  console.log('\n[TEST] Routing a "test" task...');
-  const provider2 = broker.getBestProvider({ taskType: 'test' });
-  console.log(`Result: ${provider2} (Expected: google)`);
-
-  // Test Case 3: Unknown Task
-  console.log('\n[TEST] Routing an "unknown" task...');
-  const provider3 = broker.getBestProvider({ taskType: 'unknown' });
-  console.log(`Result: ${provider3} (Should fallback to latency/cost weight)`);
-
-  console.log('\n--- MCA TEST COMPLETE ---');
-}
-
-runTest().catch(console.error);