mindforge-cc 1.0.0

package/tests/audit.test.js

@@ -0,0 +1,206 @@
+/**
+ * MindForge Audit System Tests
+ * Run: node tests/audit.test.js
+ */
+
+const fs = require('fs');
+const path = require('path');
+const assert = require('assert');
+
+let passed = 0;
+let failed = 0;
+
+function test(name, fn) {
+  try {
+    fn();
+    console.log(`  ✅ ${name}`);
+    passed++;
+  } catch (err) {
+    console.error(`  ❌ ${name}`);
+    console.error(`     ${err.message}`);
+    failed++;
+  }
+}
+
+// ── Audit utility functions to test ──────────────────────────────────────────
+
+function validateAuditEntry(entry) {
+  const required = ['id', 'timestamp', 'event', 'agent', 'session_id'];
+  const missing = required.filter(f => !entry[f]);
+  if (missing.length > 0) {
+    throw new Error(`Missing required fields: ${missing.join(', ')}`);
+  }
+  const ts = new Date(entry.timestamp);
+  if (isNaN(ts.getTime())) throw new Error(`Invalid timestamp: ${entry.timestamp}`);
+  if (!/^[0-9a-f-]{36}$/.test(entry.id)) throw new Error(`Invalid UUID format: ${entry.id}`);
+}
+
+function parseAuditLog(content) {
+  return content.trim().split('\n')
+    .filter(line => line.trim())
+    .map((line, index) => {
+      try {
+        return JSON.parse(line);
+      } catch (e) {
+        throw new Error(`Line ${index + 1} is not valid JSON: ${line.slice(0, 50)}...`);
+      }
+    });
+}
+
+// ── Tests ─────────────────────────────────────────────────────────────────────
+
+console.log('\nMindForge Day 2 — Audit System Tests\n');
+
+console.log('AUDIT.jsonl file:');
+
+test('AUDIT.jsonl exists', () => {
+  assert.ok(fs.existsSync('.planning/AUDIT.jsonl'), 'AUDIT.jsonl not found');
+});
+
+test('AUDIT.jsonl is valid (empty or valid JSONL)', () => {
+  const content = fs.readFileSync('.planning/AUDIT.jsonl', 'utf8');
+  if (content.trim().length === 0) return;
+  parseAuditLog(content);
+});
+
+console.log('\nAudit entry validation:');
+
+test('valid task_completed entry passes validation', () => {
+  const entry = {
+    id: '550e8400-e29b-41d4-a716-446655440000',
+    timestamp: new Date().toISOString(),
+    event: 'task_completed',
+    agent: 'mindforge-subagent-01',
+    phase: 1,
+    plan: '01',
+    session_id: 'sess_test',
+    task_name: 'Create user model',
+    commit_sha: 'abc1234',
+    verify_result: 'pass'
+  };
+  assert.doesNotThrow(() => validateAuditEntry(entry));
+});
+
+test('entry missing required field fails validation', () => {
+  const entry = {
+    timestamp: new Date().toISOString(),
+    event: 'task_completed',
+    agent: 'mindforge-subagent-01',
+  };
+  assert.throws(() => validateAuditEntry(entry), /Missing required fields/);
+});
+
+test('entry with invalid timestamp fails validation', () => {
+  const entry = {
+    id: '550e8400-e29b-41d4-a716-446655440000',
+    timestamp: 'not-a-date',
+    event: 'task_completed',
+    agent: 'mindforge-subagent-01',
+    session_id: 'sess_test',
+  };
+  assert.throws(() => validateAuditEntry(entry), /Invalid timestamp/);
+});
+
+test('JSONL parser handles multi-line audit log', () => {
+  const multiLine = [
+    '{"id":"550e8400-e29b-41d4-a716-446655440000","timestamp":"2026-03-20T10:00:00.000Z","event":"task_started","agent":"test","session_id":"s1"}',
+    '{"id":"550e8400-e29b-41d4-a716-446655440001","timestamp":"2026-03-20T10:05:00.000Z","event":"task_completed","agent":"test","session_id":"s1"}',
+  ].join('\n');
+  const entries = parseAuditLog(multiLine);
+  assert.strictEqual(entries.length, 2);
+  assert.strictEqual(entries[0].event, 'task_started');
+  assert.strictEqual(entries[1].event, 'task_completed');
+});
+
+test('JSONL parser rejects malformed JSON', () => {
+  const badLine = '{"id":"abc","timestamp": bad json}';
+  assert.throws(() => parseAuditLog(badLine), /not valid JSON/);
+});
+
+console.log('\nAudit schema files:');
+
+test('AUDIT-SCHEMA.md exists and has content', () => {
+  const schemaPath = '.mindforge/audit/AUDIT-SCHEMA.md';
+  assert.ok(fs.existsSync(schemaPath), 'AUDIT-SCHEMA.md not found');
+  const content = fs.readFileSync(schemaPath, 'utf8');
+  assert.ok(content.length > 500, 'AUDIT-SCHEMA.md seems too short');
+  assert.ok(content.includes('task_completed'), 'Missing task_completed event type');
+  assert.ok(content.includes('security_finding'), 'Missing security_finding event type');
+  assert.ok(content.includes('context_compaction'), 'Missing context_compaction event type');
+});
+
+test('HANDOFF.json has _warning anti-secret field', () => {
+  const handoff = JSON.parse(fs.readFileSync('.planning/HANDOFF.json', 'utf8'));
+  assert.ok(handoff._warning, 'Missing _warning anti-secret field in HANDOFF.json');
+  assert.ok(handoff._warning.toLowerCase().includes('secret'), 'Warning should mention secrets');
+});
+
+console.log('\nAdditional audit tests:');
+
+test('validates security_finding event type', () => {
+  const entry = {
+    id: '550e8400-e29b-41d4-a716-446655440002',
+    timestamp: new Date().toISOString(),
+    event: 'security_finding',
+    agent: 'mindforge-security-reviewer',
+    phase: 1,
+    session_id: 'sess_test',
+    severity: 'HIGH',
+    owasp_category: 'A03:Injection',
+    finding: 'SQL query built by string concatenation',
+    file: 'src/api/search.ts',
+    line: 42,
+    remediated: false
+  };
+  assert.doesNotThrow(() => validateAuditEntry(entry));
+  assert.strictEqual(entry.event, 'security_finding');
+});
+
+test('validates context_compaction event type', () => {
+  const entry = {
+    id: '550e8400-e29b-41d4-a716-446655440003',
+    timestamp: new Date().toISOString(),
+    event: 'context_compaction',
+    agent: 'mindforge-orchestrator',
+    phase: 2,
+    plan: '03',
+    session_id: 'sess_test',
+    context_usage_pct: 72,
+    handoff_written: true
+  };
+  assert.doesNotThrow(() => validateAuditEntry(entry));
+});
+
+test('rejects entry with malformed UUID', () => {
+  const entry = {
+    id: 'not-a-uuid',
+    timestamp: new Date().toISOString(),
+    event: 'task_completed',
+    agent: 'test',
+    session_id: 'sess_test'
+  };
+  assert.throws(() => validateAuditEntry(entry), /Invalid UUID/);
+});
+
+test('AUDIT.jsonl contains no secrets', () => {
+  const content = fs.readFileSync('.planning/AUDIT.jsonl', 'utf8');
+  const secretPatterns = [
+    /password\\s*["']?\\s*:\\s*["'][^"']{6,}/i,
+    /sk-[a-zA-Z0-9]{20,}/,
+    /-----BEGIN.*KEY-----/,
+  ];
+  secretPatterns.forEach(pattern => {
+    assert.ok(!pattern.test(content), `Potential secret found in AUDIT.jsonl`);
+  });
+});
+
+// ── Results ───────────────────────────────────────────────────────────────────
+console.log(`\n${'─'.repeat(50)}`);
+console.log(`Results: ${passed} passed, ${failed} failed`);
+
+if (failed > 0) {
+  console.error(`\n❌ ${failed} test(s) failed.\n`);
+  process.exit(1);
+} else {
+  console.log(`\n✅ All audit tests passed.\n`);
+}

package/tests/ci-mode.test.js

@@ -0,0 +1,162 @@
+/**
+ * MindForge Day 6 — CI Mode Tests
+ * Run: node tests/ci-mode.test.js
+ */
+'use strict';
+const fs = require('fs'), 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') : '';
+
+// ── CI mode detection simulation ──────────────────────────────────────────────
+function isCiMode() {
+  return process.env.CI === 'true' ||
+         process.env.MINDFORGE_CI === 'true' ||
+         process.stdin.isTTY === false;
+}
+
+// ── GitHub annotations format ─────────────────────────────────────────────────
+function formatGitHubAnnotation(level, message, file, line) {
+  const loc = file ? ` file=${file}${line ? `,line=${line}` : ''}` : '';
+  return `::${level}${loc}::${message}`;
+}
+
+// ── Tier3 CI block simulation ─────────────────────────────────────────────────
+function checkCiTierPolicy(tier, ciAutoApproveTier2 = false) {
+  if (tier === 1) return 'auto-approved';
+  if (tier === 2) return ciAutoApproveTier2 ? 'auto-approved' : 'blocked';
+  if (tier === 3) return 'blocked'; // Always blocked in CI
+  return 'unknown';
+}
+
+console.log('\nMindForge Day 6 — CI Mode Tests\n');
+
+console.log('CI engine files:');
+['ci-mode.md','github-actions-adapter.md','gitlab-ci-adapter.md'].forEach(f => {
+  test(`${f} exists`, () => {
+    assert.ok(fs.existsSync(`.mindforge/ci/${f}`), `Missing: .mindforge/ci/${f}`);
+  });
+});
+
+console.log('\nCI mode detection:');
+test('isCiMode returns false in normal test environment', () => {
+  const origCI = process.env.CI;
+  delete process.env.CI;
+  delete process.env.MINDFORGE_CI;
+  // In test environment, stdin.isTTY may be false — we test the env var logic only
+  const ciFromEnv = process.env.CI === 'true' || process.env.MINDFORGE_CI === 'true';
+  assert.strictEqual(ciFromEnv, false, 'Should not be CI mode from env vars');
+  if (origCI) process.env.CI = origCI;
+});
+
+test('CI=true activates CI mode', () => {
+  process.env.MINDFORGE_CI = 'true';
+  assert.strictEqual(process.env.MINDFORGE_CI, 'true');
+  delete process.env.MINDFORGE_CI;
+});
+
+console.log('\nCI tier policy:');
+test('Tier 1 is always auto-approved in CI', () => {
+  assert.strictEqual(checkCiTierPolicy(1), 'auto-approved');
+});
+
+test('Tier 2 blocked by default in CI (safety-first)', () => {
+  assert.strictEqual(checkCiTierPolicy(2, false), 'blocked');
+});
+
+test('Tier 2 can be auto-approved in CI when configured', () => {
+  assert.strictEqual(checkCiTierPolicy(2, true), 'auto-approved');
+});
+
+test('Tier 3 is ALWAYS blocked in CI regardless of config', () => {
+  assert.strictEqual(checkCiTierPolicy(3, true), 'blocked');  // even with true
+  assert.strictEqual(checkCiTierPolicy(3, false), 'blocked');
+});
+
+console.log('\nGitHub annotations format:');
+test('notice annotation format is correct', () => {
+  const ann = formatGitHubAnnotation('notice', 'Task 3-01 completed', null, null);
+  assert.strictEqual(ann, '::notice::Task 3-01 completed');
+});
+
+test('error annotation with file and line is correct', () => {
+  const ann = formatGitHubAnnotation('error', 'TypeScript error', 'src/auth.ts', 47);
+  assert.strictEqual(ann, '::error file=src/auth.ts,line=47::TypeScript error');
+});
+
+test('warning annotation with file only (no line)', () => {
+  const ann = formatGitHubAnnotation('warning', 'Security finding', 'src/utils.ts', null);
+  assert.strictEqual(ann, '::warning file=src/utils.ts::Security finding');
+});
+
+console.log('\nGitHub Actions workflow:');
+test('github-actions-adapter.md defines mindforge-ci.yml structure', () => {
+  const c = read('.mindforge/ci/github-actions-adapter.md');
+  assert.ok(c.includes('mindforge-ci.yml') || c.includes('on:'), 'Should define GitHub Actions workflow');
+  assert.ok(c.includes('mindforge-health'), 'Should include health check job');
+  assert.ok(c.includes('mindforge-security'), 'Should include security scan job');
+});
+
+test('ci-mode.md defines Tier 3 block policy', () => {
+  const c = read('.mindforge/ci/ci-mode.md');
+  assert.ok(
+    (c.includes('Tier 3') && c.includes('block')) || c.includes('ALWAYS fails'),
+    'CI mode should block Tier 3 changes'
+  );
+});
+
+test('ci-mode.md has timeout configuration', () => {
+  const c = read('.mindforge/ci/ci-mode.md');
+  assert.ok(c.includes('timeout') || c.includes('TIMEOUT'), 'CI mode should have timeout config');
+});
+
+console.log('\nMonorepo support:');
+['workspace-detector.md','cross-package-planner.md','dependency-graph-builder.md'].forEach(f => {
+  test(`${f} exists`, () => {
+    assert.ok(fs.existsSync(`.mindforge/monorepo/${f}`), `Missing: .mindforge/monorepo/${f}`);
+  });
+});
+
+test('workspace-detector supports major monorepo types', () => {
+  const c = read('.mindforge/monorepo/workspace-detector.md');
+  ['nx', 'turborepo', 'lerna', 'pnpm'].forEach(type => {
+    assert.ok(c.includes(type), `Should support ${type} monorepo type`);
+  });
+});
+
+test('cross-package-planner has topological sort', () => {
+  const c = read('.mindforge/monorepo/cross-package-planner.md');
+  assert.ok(
+    c.includes('topological') || c.includes('dependency order') || c.includes('Execution order'),
+    'Should use topological sort for package order'
+  );
+});
+
+console.log('\nHardening-prompted CI tests:');
+
+test('ci-mode uses exit code 0 for timeout (not 2)', () => {
+  const c = read('.mindforge/ci/ci-mode.md');
+  assert.ok(
+    c.includes('exit 0') && (c.includes('timeout') || c.includes('Timeout')),
+    'Timeout should exit with code 0'
+  );
+  // Should NOT say exit 2 for timeout
+  const exit2ForTimeout = c.match(/timeout.*exit 2|exit 2.*timeout/is);
+  assert.ok(!exit2ForTimeout, 'Should not use exit 2 for timeout');
+});
+
+test('github-actions adapter has Tier 3 governance block with clear message', () => {
+  const c = read('.mindforge/ci/github-actions-adapter.md');
+  assert.ok(
+    c.includes('Tier 3') && c.includes('block'),
+    'Should explain Tier 3 CI block clearly'
+  );
+});
+
+console.log(`\n${'─'.repeat(50)}`);
+console.log(`Results: ${passed} passed, ${failed} failed`);
+if (failed > 0) { console.error(`\n❌ ${failed} test(s) failed.\n`); process.exit(1); }
+else { console.log(`\n✅ All CI mode tests passed.\n`); }

package/tests/compaction.test.js

@@ -0,0 +1,161 @@
+/**
+ * MindForge Context Compaction Tests
+ * Run: node tests/compaction.test.js
+ */
+
+const fs = require('fs');
+const assert = require('assert');
+
+let passed = 0;
+let failed = 0;
+
+function test(name, fn) {
+  try {
+    fn();
+    console.log(`  ✅ ${name}`);
+    passed++;
+  } catch (err) {
+    console.error(`  ❌ ${name}`);
+    console.error(`     ${err.message}`);
+    failed++;
+  }
+}
+
+// ── Compaction state validator ─────────────────────────────────────────────────
+
+function validateHandoffJson(obj) {
+  const required = ['schema_version', 'next_task', '_warning', 'context_refs'];
+  const missing = required.filter(f => obj[f] === undefined);
+  if (missing.length > 0) throw new Error(`Missing: ${missing.join(', ')}`);
+  if (!Array.isArray(obj.context_refs)) throw new Error('context_refs must be an array');
+  if (!Array.isArray(obj.blockers)) throw new Error('blockers must be an array');
+  if (obj._warning.toLowerCase().includes('password') === false &&
+      obj._warning.toLowerCase().includes('secret') === false) {
+    throw new Error('_warning must mention secrets/passwords');
+  }
+}
+
+function validateStateHasCompactionCheckpoint(content) {
+  return content.includes('Compaction checkpoint') || content.includes('compaction');
+}
+
+// ── Tests ─────────────────────────────────────────────────────────────────────
+
+console.log('\nMindForge Day 2 — Context Compaction Tests\n');
+
+console.log('HANDOFF.json schema validation:');
+
+test('HANDOFF.json exists', () => {
+  assert.ok(fs.existsSync('.planning/HANDOFF.json'));
+});
+
+test('HANDOFF.json is valid JSON', () => {
+  const content = fs.readFileSync('.planning/HANDOFF.json', 'utf8');
+  assert.doesNotThrow(() => JSON.parse(content));
+});
+
+test('HANDOFF.json has all required fields', () => {
+  const obj = JSON.parse(fs.readFileSync('.planning/HANDOFF.json', 'utf8'));
+  validateHandoffJson(obj);
+});
+
+test('HANDOFF.json schema_version is 1.0.0', () => {
+  const obj = JSON.parse(fs.readFileSync('.planning/HANDOFF.json', 'utf8'));
+  assert.strictEqual(obj.schema_version, '1.0.0');
+});
+
+test('HANDOFF.json context_refs is an array', () => {
+  const obj = JSON.parse(fs.readFileSync('.planning/HANDOFF.json', 'utf8'));
+  assert.ok(Array.isArray(obj.context_refs));
+});
+
+test('HANDOFF.json blockers is an array', () => {
+  const obj = JSON.parse(fs.readFileSync('.planning/HANDOFF.json', 'utf8'));
+  assert.ok(Array.isArray(obj.blockers));
+});
+
+test('HANDOFF.json decisions_needed is an array', () => {
+  const obj = JSON.parse(fs.readFileSync('.planning/HANDOFF.json', 'utf8'));
+  assert.ok(Array.isArray(obj.decisions_needed));
+});
+
+console.log('\nCompaction protocol file:');
+
+test('compaction-protocol.md exists', () => {
+  assert.ok(
+    fs.existsSync('.mindforge/engine/compaction-protocol.md'),
+    'compaction-protocol.md not found'
+  );
+});
+
+test('compaction-protocol.md mentions 70% threshold', () => {
+  const content = fs.readFileSync('.mindforge/engine/compaction-protocol.md', 'utf8');
+  assert.ok(content.includes('70%'), 'Should specify 70% compaction threshold');
+});
+
+test('compaction-protocol.md has all 6 steps', () => {
+  const content = fs.readFileSync('.mindforge/engine/compaction-protocol.md', 'utf8');
+  assert.ok(content.includes('Step 1'), 'Missing Step 1');
+  assert.ok(content.includes('Step 2'), 'Missing Step 2');
+  assert.ok(content.includes('Step 3'), 'Missing Step 3');
+  assert.ok(content.includes('Step 4'), 'Missing Step 4');
+  assert.ok(content.includes('Step 5'), 'Missing Step 5');
+  assert.ok(content.includes('Step 6'), 'Missing Step 6');
+});
+
+test('compaction-protocol.md covers session restart procedure', () => {
+  const content = fs.readFileSync('.mindforge/engine/compaction-protocol.md', 'utf8');
+  assert.ok(
+    content.includes('Session restart') || content.includes('restart from HANDOFF'),
+    'Should cover session restart from HANDOFF.json'
+  );
+});
+
+console.log('\nAdditional compaction tests:');
+
+test('HANDOFF.json has recent_commits field', () => {
+  const obj = JSON.parse(fs.readFileSync('.planning/HANDOFF.json', 'utf8'));
+  assert.ok('recent_commits' in obj, 'Missing recent_commits field');
+  assert.ok(Array.isArray(obj.recent_commits), 'recent_commits must be an array');
+});
+
+test('HANDOFF.json has recent_files field', () => {
+  const obj = JSON.parse(fs.readFileSync('.planning/HANDOFF.json', 'utf8'));
+  assert.ok('recent_files' in obj, 'Missing recent_files field');
+  assert.ok(Array.isArray(obj.recent_files), 'recent_files must be an array');
+});
+
+test('compaction-protocol.md covers WIP commit with --no-verify', () => {
+  const content = fs.readFileSync('.mindforge/engine/compaction-protocol.md', 'utf8');
+  assert.ok(
+    content.includes('--no-verify') || content.includes('no-verify'),
+    'Should mention --no-verify for WIP commits that bypass hooks'
+  );
+});
+
+test('compaction-protocol.md covers staleness detection', () => {
+  const content = fs.readFileSync('.mindforge/engine/compaction-protocol.md', 'utf8');
+  assert.ok(
+    content.includes('48 hours') || content.includes('staleness') || content.includes('stale'),
+    'Should cover HANDOFF.json staleness detection'
+  );
+});
+
+test('compaction-protocol.md mentions 85% emergency compaction', () => {
+  const content = fs.readFileSync('.mindforge/engine/compaction-protocol.md', 'utf8');
+  assert.ok(
+    content.includes('85%') || content.includes('emergency'),
+    'Should cover emergency compaction when 85%+ context is reached'
+  );
+});
+
+// ── Results ───────────────────────────────────────────────────────────────────
+console.log(`\n${'─'.repeat(50)}`);
+console.log(`Results: ${passed} passed, ${failed} failed`);
+
+if (failed > 0) {
+  console.error(`\n❌ ${failed} test(s) failed.\n`);
+  process.exit(1);
+} else {
+  console.log(`\n✅ All compaction tests passed.\n`);
+}