mindforge-cc 8.2.0 → 9.0.0

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

@@ -1,111 +0,0 @@
-/**
- * MindForge v2 — Multi-Model Layer Tests
- */
-'use strict';
-
-const assert = require('assert');
-const Router = require('../bin/models/model-router');
-const CostTracker = require('../bin/models/cost-tracker');
-const FindingSynthesizer = require('../bin/review/finding-synthesizer');
-
-async function testRouter() {
-  console.log('Testing Model Router...');
-  
-  // Test Persona Mapping
-  const researchModel = Router.route('research-agent', 1).model;
-  assert.strictEqual(researchModel, 'gemini-1.5-pro');
-
-  // Test Tier Override (Tier 3 -> Security Model)
-  const securityModel = Router.route('developer', 3).model;
-  assert.strictEqual(securityModel, 'claude-3-opus-20240229');
-
-  // Test Budget Bias (Low difficulty/tier -> Cheap model)
-  const cheapModel = Router.route('developer', 1).model;
-  assert.strictEqual(cheapModel, 'claude-3-5-haiku-20241022');
-
-  console.log('✅ Router tests passed.');
-}
-
-async function testCostTracker() {
-  console.log('Testing Cost Tracker...');
-  
-  const initialSpend = await CostTracker.getTodaySpend();
-  
-  // Record a dummy call
-  await CostTracker.record({
-    model: 'gpt-4o',
-    input_tokens: 1000,
-    output_tokens: 500,
-    cost_usd: 0.0125
-  });
-
-  const newSpend = await CostTracker.getTodaySpend();
-  assert.ok(newSpend > initialSpend);
-
-  // Test Preflight (Budget enforcement)
-  try {
-    const canCall = await CostTracker.preflight(0.01);
-    assert.strictEqual(typeof canCall, 'undefined'); // preflight returns undefined or throws
-  } catch (e) {
-    if (e.code !== 'COST_LIMIT_REACHED') throw e;
-  }
-
-  console.log('✅ Cost Tracker tests passed.');
-}
-
-function testSynthesizer() {
-  console.log('Testing Finding Synthesizer...');
-
-  const review1 = {
-    model: 'claude-3-5-sonnet',
-    content: '**[HIGH]** `index.js:10` — Infinite loop detected.\n### Verdict: REQUEST_CHANGES'
-  };
-  const review2 = {
-    model: 'gpt-4o',
-    content: '**[CRITICAL]** `index.js:12` — Potential crash in error handler.\n### Verdict: REQUEST_CHANGES'
-  };
-
-  const synthesis = FindingSynthesizer.synthesizeFindings([review1, review2]);
-  
-  // Location normalization should group index.js:10 and index.js:12 (same 20-line band)
-  assert.strictEqual(synthesis.consensus.length, 1);
-  assert.strictEqual(synthesis.consensus[0].severity, 'CRITICAL');
-  assert.strictEqual(synthesis.overall_verdict, 'REQUEST_CHANGES');
-
-  console.log('✅ Synthesizer tests passed.');
-}
-
-async function testGeminiAuth() {
-  console.log('Testing Gemini Header Auth...');
-  
-  // This is a unit test of the provider's header generation logic
-  // (We don't make a real call here to avoid using keys)
-  const options = {
-    hostname: 'generativelanguage.googleapis.com',
-    path: '/v1beta/models/gemini-1.5-pro:generateContent',
-    method: 'POST',
-    headers: {
-      'Content-Type': 'application/json',
-      'x-goog-api-key': 'test-key'
-    }
-  };
-  
-  assert.strictEqual(options.headers['x-goog-api-key'], 'test-key');
-  console.log('✅ Gemini Auth verification passed.');
-}
-
-async function runAll() {
-  try {
-    await testRouter();
-    await testCostTracker();
-    testSynthesizer();
-    await testGeminiAuth();
-    console.log('\n✨ ALL MULTI-MODEL TESTS PASSED ✨');
-  } catch (e) {
-    console.error('\n❌ TEST FAILURE:');
-    console.error(e);
-    process.exit(1);
-  }
-}
-
-runAll();

package/.mindforge/mirrors/mirror-sre-776a1cf9/tests/nexus-tracing.test.js

@@ -1,49 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-const NexusTracer = require('../.mindforge/engine/nexus-tracer');
-
-describe('Nexus Tracer & ART Protocol', () => {
-  const auditPath = path.join(__dirname, '../.planning/AUDIT.jsonl');
-
-  beforeEach(() => {
-    // Clear audit log before tests
-    if (fs.existsSync(auditPath)) {
-      fs.truncateSync(auditPath, 0);
-    }
-  });
-
-  test('should initialize a valid trace and spans', async () => {
-    const span = await NexusTracer.startSpan('test_wave_01');
-    expect(span.trace_id).toBeDefined();
-    expect(span.id).toBeDefined(); // Use span.id instead of span_id
-    expect(span.name).toBe('test_wave_01');
-  });
-
-  test('should support hierarchical spans', async () => {
-    const parentId = await NexusTracer.startSpan('parent');
-    const childId = await NexusTracer.startSpan('child', {}, parentId);
-    
-    const child = NexusTracer.activeSpans.get(childId);
-    expect(child.trace_id).toBe(NexusTracer.currentTraceId);
-    expect(child.parent_id).toBe(parentId);
-  });
-
-  test('should record reasoning trace to AUDIT.jsonl', async () => {
-    const spanId = await NexusTracer.startSpan('reasoning_task');
-    await NexusTracer.recordReasoning(spanId, 'test-agent', 'Considering memory safety in Rust vs C++');
-    
-    const logs = fs.readFileSync(auditPath, 'utf8').split('\n').filter(Boolean);
-    const lastEntry = JSON.parse(logs[logs.length - 1]);
-    
-    expect(lastEntry.event).toBe('reasoning_trace');
-    expect(lastEntry.thought).toContain('memory safety');
-    expect(lastEntry.trace_id).toBe(NexusTracer.currentTraceId);
-  });
-
-  test('should close spans and update state', async () => {
-    const spanId = await NexusTracer.startSpan('closing_task');
-    await NexusTracer.endSpan(spanId);
-    
-    expect(NexusTracer.activeSpans.has(spanId)).toBe(false);
-  });
-});

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

@@ -1,416 +0,0 @@
-/**
- * MindForge Day 7 — Production Readiness Tests
- * Verifies the installer, updater, migration engine, plugin system,
- * token optimiser, and all 36 commands exist.
- *
- * Run: node tests/production.test.js
- */
-'use strict';
-
-const fs   = require('fs');
-const assert = require('assert');
-let passed = 0, failed = 0;
-
-function test(name, fn) {
-  try { fn(); console.log(`  ✅  ${name}`); passed++; }
-  catch(e) { console.error(`  ❌  ${name}\n      ${e.message}`); failed++; }
-}
-
-const read   = p  => fs.existsSync(p) ? fs.readFileSync(p, 'utf8') : '';
-const exists = p  => fs.existsSync(p);
-
-// ── Installer completeness ─────────────────────────────────────────────────────
-console.log('\nMindForge Day 7 — Production Readiness Tests\n');
-console.log('Installer:');
-
-test('bin/install.js exists with shebang', () => {
-  const c = read('bin/install.js');
-  assert.ok(c.includes('#!/usr/bin/env node'), 'Missing shebang');
-  assert.ok(c.length > 500, 'install.js seems too short');
-});
-
-test('bin/installer-core.js exists and exports run()', () => {
-  const c = read('bin/installer-core.js');
-  assert.ok(c.includes('module.exports'), 'Missing module.exports');
-  assert.ok(c.includes('async function run') || c.includes('function run'), 'Missing run function');
-});
-
-test('installer handles --version flag correctly', () => {
-  const c = read('bin/install.js');
-  assert.ok(c.includes('\'--version\'') || c.includes('"--version"'), 'Missing --version');
-  assert.ok(c.includes('process.exit(0)'), 'Should exit 0 for --version');
-});
-
-test('installer has Node.js version gate (≥ 18)', () => {
-  const combined = read('bin/install.js') + read('bin/installer-core.js');
-  assert.ok(combined.includes('18'), 'Should check for Node.js 18');
-  assert.ok(combined.includes('process.exit(1)') || combined.includes('exit(1)'), 'Should exit 1 for old node');
-});
-
-test('installer has CI mode detection', () => {
-  const c = read('bin/install.js');
-  assert.ok(c.includes('process.env.CI'), 'Should detect CI environment');
-  assert.ok(c.includes('IS_NON_INTERACTIVE'), 'Should have non-interactive flag');
-});
-
-test('installer backs up existing CLAUDE.md', () => {
-  const c = read('bin/installer-core.js');
-  assert.ok(c.includes('backup') || c.includes('.backup-'), 'Should back up CLAUDE.md');
-});
-
-test('installer has self-install detection', () => {
-  const c = read('bin/installer-core.js');
-  assert.ok(
-    c.includes('isSelfInstall') || c.includes('\'mindforge-cc\''),
-    'Should detect self-install scenario'
-  );
-});
-
-test('installer excludes sensitive files (*.env, *.key, *.pem)', () => {
-  const c = read('bin/installer-core.js');
-  assert.ok(
-    c.includes('.env') || c.includes('SENSITIVE_EXCLUDE') || c.includes('.key'),
-    'Should have sensitive file exclusion list'
-  );
-});
-
-test('installer verifies install after completing', () => {
-  const c = read('bin/installer-core.js');
-  assert.ok(
-    c.includes('verifyInstall') || c.includes('verification'),
-    'Should verify install after completing'
-  );
-});
-
-// ── Self-update system ─────────────────────────────────────────────────────────
-console.log('\nSelf-update system:');
-
-['version-comparator.js', 'changelog-fetcher.js', 'self-update.js'].forEach(f => {
-  test(`bin/updater/${f} exists`, () => {
-    assert.ok(exists(`bin/updater/${f}`), `Missing: bin/updater/${f}`);
-  });
-});
-
-test('compareSemver: 1.0.0 > 0.6.0', () => {
-  const { compareSemver } = require('../bin/updater/version-comparator');
-  assert.ok(compareSemver('1.0.0', '0.6.0') > 0);
-});
-
-test('compareSemver: 0.6.0 < 1.0.0', () => {
-  const { compareSemver } = require('../bin/updater/version-comparator');
-  assert.ok(compareSemver('0.6.0', '1.0.0') < 0);
-});
-
-test('compareSemver: 1.0.0 == 1.0.0', () => {
-  const { compareSemver } = require('../bin/updater/version-comparator');
-  assert.strictEqual(compareSemver('1.0.0', '1.0.0'), 0);
-});
-
-test('compareSemver handles v prefix', () => {
-  const { compareSemver } = require('../bin/updater/version-comparator');
-  assert.ok(compareSemver('v1.0.0', 'v0.6.0') > 0);
-});
-
-test('upgradeType: 0.6.0 → 1.0.0 is major', () => {
-  const { upgradeType } = require('../bin/updater/version-comparator');
-  assert.strictEqual(upgradeType('0.6.0', '1.0.0'), 'major');
-});
-
-test('upgradeType: 1.0.0 → 1.1.0 is minor', () => {
-  const { upgradeType } = require('../bin/updater/version-comparator');
-  assert.strictEqual(upgradeType('1.0.0', '1.1.0'), 'minor');
-});
-
-test('upgradeType: 1.0.0 → 1.0.1 is patch', () => {
-  const { upgradeType } = require('../bin/updater/version-comparator');
-  assert.strictEqual(upgradeType('1.0.0', '1.0.1'), 'patch');
-});
-
-test('upgradeType: 1.0.0 → 1.0.0 is none', () => {
-  const { upgradeType } = require('../bin/updater/version-comparator');
-  assert.strictEqual(upgradeType('1.0.0', '1.0.0'), 'none');
-});
-
-test('self-update has scope detection', () => {
-  const c = read('bin/updater/self-update.js');
-  assert.ok(c.includes('detectInstallScope'), 'Should have detectInstallScope()');
-});
-
-test('self-update reads schema_version before applying update', () => {
-  const c = read('bin/updater/self-update.js');
-  assert.ok(
-    c.includes('readHandoffSchemaVersion') || c.includes('schema_version'),
-    'Should read schema_version from HANDOFF before updating'
-  );
-});
-
-// ── Migration engine ────────────────────────────────────────────────────────────
-console.log('\nMigration engine:');
-
-['migrate.js', 'schema-versions.js', '0.1.0-to-0.5.0.js', '0.5.0-to-0.6.0.js', '0.6.0-to-1.0.0.js'].forEach(f => {
-  test(`bin/migrations/${f} exists`, () => {
-    assert.ok(exists(`bin/migrations/${f}`), `Missing: ${f}`);
-  });
-});
-
-test('migrate.js creates backup before migrating', () => {
-  const c = read('bin/migrations/migrate.js');
-  assert.ok(c.includes('backup') || c.includes('Backup'), 'Should create backup');
-});
-
-test('migrate.js aborts if backup fails', () => {
-  const c = read('bin/migrations/migrate.js');
-  assert.ok(
-    c.includes('backupErr') || c.includes('Migration aborted'),
-    'Should abort if backup creation fails'
-  );
-});
-
-test('migrate.js restores from backup on migration failure', () => {
-  const c = read('bin/migrations/migrate.js');
-  assert.ok(
-    c.includes('Restoring') || c.includes('restoreFromBackup') || c.includes('restore'),
-    'Should restore from backup on failure'
-  );
-});
-
-test('0.6.0-to-1.0.0 migration adds plugin_api_version', () => {
-  const c = read('bin/migrations/0.6.0-to-1.0.0.js');
-  assert.ok(c.includes('plugin_api_version'), 'Should add plugin_api_version field');
-});
-
-test('0.6.0-to-1.0.0 migration backfills session_id in AUDIT.jsonl', () => {
-  const c = read('bin/migrations/0.6.0-to-1.0.0.js');
-  assert.ok(c.includes('session_id'), 'Should backfill session_id');
-});
-
-test('0.6.0-to-1.0.0 migration converts VERIFY_PASS_RATE_WARNING_THRESHOLD', () => {
-  const c = read('bin/migrations/0.6.0-to-1.0.0.js');
-  assert.ok(
-    c.includes('VERIFY_PASS_RATE') || c.includes('val / 100'),
-    'Should convert percentage to decimal'
-  );
-});
-
-test('migration preserves invalid AUDIT.jsonl lines (no crash)', () => {
-  const c = read('bin/migrations/0.6.0-to-1.0.0.js');
-  assert.ok(c.includes('catch') || c.includes('try'), 'Should handle parse errors gracefully');
-});
-
-// ── Plugin system ────────────────────────────────────────────────────────────────
-console.log('\nPlugin system:');
-
-['plugin-schema.md', 'plugin-loader.md', 'PLUGINS-MANIFEST.md'].forEach(f => {
-  test(`.mindforge/plugins/${f} exists`, () => {
-    assert.ok(exists(`.mindforge/plugins/${f}`));
-  });
-});
-
-test('plugin schema defines permission model', () => {
-  const c = read('.mindforge/plugins/plugin-schema.md');
-  assert.ok(c.includes('permissions'), 'Should define permissions');
-  assert.ok(c.includes('write_state'), 'Should include write_state permission');
-  assert.ok(c.includes('network_access'), 'Should include network_access permission');
-});
-
-test('plugin loader has injection guard step', () => {
-  const c = read('.mindforge/plugins/plugin-loader.md');
-  assert.ok(c.includes('injection guard') || c.includes('Injection'), 'Should run injection guard');
-});
-
-test('plugin loader documents advisory permission model', () => {
-  const c = read('.mindforge/plugins/plugin-loader.md');
-  assert.ok(
-    c.includes('advisory') || c.includes('not OS-enforced') || c.includes('not enforced'),
-    'Should explain that permissions are advisory'
-  );
-});
-
-test('plugin schema lists all 36 reserved command names', () => {
-  const c = read('.mindforge/plugins/plugin-schema.md');
-  assert.ok(
-    c.includes('Reserved command names') || c.includes('reserved'),
-    'Should list reserved command names'
-  );
-  // Check a few specific reserved names are mentioned
-  assert.ok(c.includes('health'), 'Should list health as reserved');
-  assert.ok(c.includes('security-scan'), 'Should list security-scan as reserved');
-});
-
-// ── Token optimiser ─────────────────────────────────────────────────────────────
-console.log('\nToken optimiser:');
-
-test('token-optimiser.md exists', () => {
-  assert.ok(exists('.mindforge/production/token-optimiser.md'));
-});
-
-test('token optimiser defines efficiency formula', () => {
-  const c = read('.mindforge/production/token-optimiser.md');
-  assert.ok(c.includes('token_efficiency') || c.includes('efficiency'), 'Should define efficiency');
-  assert.ok(c.includes('useful_output') || c.includes('output_tokens'), 'Should define useful output');
-});
-
-test('token optimiser has lean plan strategy', () => {
-  const c = read('.mindforge/production/token-optimiser.md');
-  assert.ok(c.includes('Strategy 1') || c.includes('Lean'), 'Should have lean plan strategy');
-});
-
-// ── Production checklist ────────────────────────────────────────────────────────
-console.log('\nProduction checklist:');
-
-test('production-checklist.md has exactly 50 checkbox items', () => {
-  const c = read('.mindforge/production/production-checklist.md');
-  const boxes = (c.match(/- \[ \]/g) || []).length;
-  assert.ok(boxes >= 50, `Expected >= 50 items, found ${boxes}`);
-});
-
-// ── Documentation completeness ──────────────────────────────────────────────────
-console.log('\nDocumentation:');
-
-const DOC_FILES = [
-  'docs/reference/commands.md',
-  'docs/security/SECURITY.md',
-  'docs/security/threat-model.md',
-  'docs/architecture/decision-records-index.md',
-  'docs/contributing/CONTRIBUTING.md',
-];
-DOC_FILES.forEach(f => test(`${f} exists`, () => assert.ok(exists(f), `Missing: ${f}`)));
-
-test('threat model covers all 7 threat actors', () => {
-  const c = read('docs/security/threat-model.md');
-  for (let i = 1; i <= 7; i++) {
-    assert.ok(c.includes(`Threat Actor ${i}`), `Missing Threat Actor ${i}`);
-  }
-});
-
-test('ADR index lists all 20 ADRs', () => {
-  const c = read('docs/architecture/decision-records-index.md');
-  for (let i = 1; i <= 20; i++) {
-    const adrRef = `ADR-${String(i).padStart(3, '0')}`;
-    assert.ok(c.includes(adrRef) || c.includes(`ADR-${i}`), `Missing ${adrRef} in index`);
-  }
-});
-
-test('SECURITY.md has responsible disclosure policy', () => {
-  const c = read('docs/security/SECURITY.md');
-  assert.ok(c.includes('disclosure') || c.includes('24 hours'), 'Should have disclosure timeline');
-});
-
-// ── All 36 commands ─────────────────────────────────────────────────────────────
-console.log('\nAll 36 commands:');
-
-const ALL_COMMANDS = [
-  // Day 1
-  'help', 'init-project', 'plan-phase', 'execute-phase', 'verify-phase', 'ship',
-  // Day 2
-  'next', 'quick', 'status', 'debug',
-  // Day 3
-  'skills', 'review', 'security-scan', 'map-codebase', 'discuss-phase',
-  // Day 4
-  'audit', 'milestone', 'complete-milestone', 'approve', 'sync-jira', 'sync-confluence',
-  // Day 5
-  'health', 'retrospective', 'profile-team', 'metrics',
-  // Day 6
-  'init-org', 'install-skill', 'publish-skill', 'pr-review', 'workspace', 'benchmark',
-  // Day 7
-  'update', 'migrate', 'plugins', 'tokens', 'release',
-];
-
-assert.strictEqual(ALL_COMMANDS.length, 36, `Expected 36 commands, have ${ALL_COMMANDS.length}`);
-console.log(`  (verifying all ${ALL_COMMANDS.length} commands)`);
-
-test('all 36 commands in .claude/commands/mindforge/', () => {
-  const missing = ALL_COMMANDS.filter(cmd => !exists(`.claude/commands/mindforge/${cmd}.md`));
-  assert.strictEqual(missing.length, 0, `Missing: ${missing.join(', ')}`);
-});
-
-test('all 36 commands mirrored to .agent/mindforge/', () => {
-  const missing = ALL_COMMANDS.filter(cmd => !exists(`.agent/mindforge/${cmd}.md`));
-  assert.strictEqual(missing.length, 0, `Missing agent mirror: ${missing.join(', ')}`);
-});
-
-test('no command file is empty (> 100 chars)', () => {
-  const tiny = ALL_COMMANDS.filter(cmd => {
-    const p = `.claude/commands/mindforge/${cmd}.md`;
-    return exists(p) && fs.statSync(p).size < 100;
-  });
-  assert.strictEqual(tiny.length, 0, `Too small: ${tiny.join(', ')}`);
-});
-
-// ── Hardening tests ───────────────────────────────────────────────────────────
-console.log('\nHardening tests:');
-
-test('SENSITIVE_EXCLUDE properly excludes .env and .key files', () => {
-  const SENSITIVE_EXCLUDE = [
-    '.env', /^\.env\..*/, /\.key$/, /\.pem$/, 'secrets', /^secrets$/
-  ];
-  const shouldExclude = (name) =>
-    SENSITIVE_EXCLUDE.some(p => typeof p === 'string' ? p === name : p.test(name));
-
-  assert.ok(shouldExclude('.env'),               '.env should be excluded');
-  assert.ok(shouldExclude('.env.local'),         '.env.local should be excluded');
-  assert.ok(shouldExclude('private.key'),        'private.key should be excluded');
-  assert.ok(shouldExclude('certificate.pem'),    'certificate.pem should be excluded');
-  assert.ok(shouldExclude('secrets'),            'secrets directory should be excluded');
-  assert.ok(!shouldExclude('package.json'),      'package.json should NOT be excluded');
-  assert.ok(!shouldExclude('.mindforge'),        '.mindforge should NOT be excluded');
-  assert.ok(!shouldExclude('src'),               'src should NOT be excluded');
-});
-
-test('SENSITIVE_EXCLUDE uses regex for .key and .pem (not glob strings)', () => {
-  const c = fs.readFileSync('bin/installer-core.js', 'utf8');
-  // Should use regex pattern /\.key$/ not string '*.key'
-  assert.ok(!c.includes('\'*.key\''), 'Should not use glob string for .key');
-  assert.ok(!c.includes('\'*.pem\''), 'Should not use glob string for .pem');
-  assert.ok(
-    c.includes('\\.key$') || c.includes('/\\.key$/') || c.includes('/.key$/'),
-    'Should use regex for .key'
-  );
-});
-
-test('migration filter uses toVersion range check (not fromVersion)', () => {
-  const c = fs.readFileSync('bin/migrations/migrate.js', 'utf8');
-  // The correct filter uses compareSemver(m.toVersion, fromVersion) > 0
-  assert.ok(
-    c.includes('m.toVersion') && c.includes('> 0'),
-    'Should use toVersion range check for migration filter'
-  );
-});
-
-test('migration has CI auto-delete of backup', () => {
-  const c = fs.readFileSync('bin/migrations/migrate.js', 'utf8');
-  assert.ok(
-    c.includes('CI') && (c.includes('auto-deleted') || c.includes('rmSync')),
-    'Should auto-delete backup in CI mode'
-  );
-});
-
-// ── Final version check ────────────────────────────────────────────────────────
-console.log('\nVersion:');
-
-test('package.json version is >= 1.0.0', () => {
-  const pkg = JSON.parse(fs.readFileSync('package.json', 'utf8'));
-  assert.ok(pkg.version.startsWith('1.') || pkg.version.startsWith('2.'), `Expected v1 or v2, got ${pkg.version}`);
-});
-
-test('CHANGELOG.md has latest version entry', () => {
-  const c = read('CHANGELOG.md');
-  const pkg = JSON.parse(fs.readFileSync('package.json', 'utf8'));
-  assert.ok(c.includes(pkg.version.split('-')[0]) || c.includes(pkg.version), 'CHANGELOG.md should have current version entry');
-});
-
-test('all 20 ADR files present in .planning/decisions/', () => {
-  if (!exists('.planning/decisions/')) return; // Skip if no decisions dir yet
-  const adrs = fs.readdirSync('.planning/decisions/').filter(f => f.startsWith('ADR-') && f.endsWith('.md'));
-  assert.ok(adrs.length >= 20, `Expected >= 20 ADRs, found ${adrs.length}`);
-});
-
-// ── Results ─────────────────────────────────────────────────────────────────────
-console.log(`\n${'─'.repeat(55)}`);
-console.log(`Results: ${passed} passed, ${failed} failed`);
-if (failed > 0) {
-  console.error(`\n❌  ${failed} test(s) failed — not production ready.\n`);
-  process.exit(1);
-} else {
-  console.log('\n✅  All production readiness tests passed.\n');
-}

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

@@ -1,99 +0,0 @@
-/**
- * MindForge v2.0.0 — Release Validation Suite
- *
- * Verifies the "Autonomous Enterprise" release features.
- */
-'use strict';
-
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-const assert = require('assert');
-const { install, run } = require('../bin/installer-core');
-
-let passed = 0, failed = 0;
-
-function test(name, fn) {
-  try {
-    fn();
-    console.log(`  ✅  ${name}`);
-    passed++;
-  } catch (e) {
-    console.error(`  ❌  ${name}\n      ${e.message}`);
-    failed++;
-  }
-}
-
-// ── Setup ───────────────────────────────────────────────────────────────────
-const TEST_ROOT = path.join(os.tmpdir(), `mindforge-release-test-${Date.now()}`);
-fs.mkdirSync(TEST_ROOT, { recursive: true });
-
-// ── Tests ────────────────────────────────────────────────────────────────────
-console.log('\nMindForge v2.0.0 — Release Validation\n');
-
-test('Multi-runtime: RUNTIMES map contains all 6 platforms', () => {
-  const { RUNTIMES } = require('../bin/installer-core');
-  const expected = ['claude', 'antigravity', 'cursor', 'opencode', 'gemini', 'copilot'];
-  expected.forEach(rt => {
-    assert.ok(RUNTIMES[rt], `Missing runtime: ${rt}`);
-    assert.ok(RUNTIMES[rt].entryFile, `Missing entryFile for ${rt}`);
-  });
-});
-
-test('Installer: adapters generate preambles for Cursor/Copilot', () => {
-  const { generateEntryContent } = require('../bin/installer-core');
-  const baseContent = '# Project Rules\n\nRule 1: Always use MindForge.';
-  
-  const cursor = generateEntryContent('cursor', baseContent);
-  assert.ok(cursor.includes('MindForge command reference'), 'Cursor missing preamble');
-  
-  const copilot = generateEntryContent('copilot', baseContent);
-  assert.ok(copilot.includes('MindForge command reference'), 'Copilot missing preamble');
-});
-
-test('Installer: Gemini adapter performs model/path substitutions', () => {
-  const { generateEntryContent } = require('../bin/installer-core');
-  const baseContent = 'Use CLAUDE.md for rules. Use model claude-3-5-sonnet-20241022.';
-  
-  const gemini = generateEntryContent('gemini', baseContent);
-  assert.ok(gemini.includes('GEMINI.md'), 'Gemini missing filename replacement');
-  assert.ok(gemini.includes('gemini-2.0-flash-exp'), 'Gemini missing model replacement');
-  assert.ok(!gemini.includes('claude-3-5-sonnet'), 'Gemini still contains Claude model name');
-});
-
-test('Migration: 1.0.0 → 2.0.0 backfills AUDIT.jsonl', async () => {
-  const migration = require('../bin/migrations/1.0.0-to-2.0.0');
-  const v1Audit = JSON.stringify({ id: 'v1-1', event: 'test', timestamp: '2023' });
-  
-  // Custom mock for paths
-  const testAudit = path.join(TEST_ROOT, 'AUDIT.jsonl');
-  const testHandoff = path.join(TEST_ROOT, 'HANDOFF.json');
-  fs.writeFileSync(testAudit, v1Audit + '\n');
-  fs.writeFileSync(testHandoff, JSON.stringify({ plugin_api_version: '1.0.0' }));
-  
-  await migration.run({ audit: testAudit, handoff: testHandoff });
-  
-  const migrated = JSON.parse(fs.readFileSync(testAudit, 'utf8'));
-  assert.strictEqual(migrated.runtime, 'unknown', 'Audit runtime not backfilled');
-  assert.strictEqual(migrated.agent_id, 'migrated-v1', 'Audit agent_id not backfilled');
-  
-  const handoff = JSON.parse(fs.readFileSync(testHandoff, 'utf8'));
-  assert.strictEqual(handoff.plugin_api_version, '2.0.0', 'Handoff not upgraded to 2.0.0');
-});
-
-test('CLI: --runtime opencode parses correctly', async () => {
-  // Mock run() logic check indirectly via argument parsing logic
-  const args = ['--runtime', 'opencode', '--local'];
-  let runtime = null;
-  const rtIdx = args.indexOf('--runtime');
-  if (rtIdx !== -1 && args[rtIdx + 1]) {
-    runtime = args[rtIdx + 1].toLowerCase();
-  }
-  assert.strictEqual(runtime, 'opencode', 'Failed to parse --runtime flag');
-});
-
-console.log(`\n${'─'.repeat(55)}`);
-console.log(`Results: ${passed} passed, ${failed} failed`);
-
-if (failed > 0) process.exit(1);
-else console.log('\n✅  v2.0.0 Release Validation Passed.\n');