v1.1.0: pooled runtime, 959 tests, production hardening (0 squash)

scripts/mutation-test.js

@@ -0,0 +1,170 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs'
+import { execSync } from 'child_process'
+import { globSync } from 'glob'
+import path from 'path'
+
+const PACKAGES = [
+  'imhotep-solver',
+  'imhotep-geometry',
+  'imhotep-topology',
+  'imhotep-dsl'
+]
+
+const MUTATIONS = [
+  { name: 'reverse-equality', pattern: /===/g, replacement: '!==' },
+  { name: 'reverse-inequality', pattern: /!==/g, replacement: '===' },
+  { name: 'gt-to-gte', pattern: /(?<!<)>(?!=)/g, replacement: '>=' },
+  { name: 'lt-to-lte', pattern: /(?<!>)<(?!-)/g, replacement: '<=' },
+  { name: 'gte-to-gt', pattern: />=/g, replacement: '>' },
+  { name: 'lte-to-lt', pattern: /<=/g, replacement: '<' },
+  { name: 'and-to-or', pattern: /&&/g, replacement: '||' },
+  { name: 'or-to-and', pattern: /\|\|/g, replacement: '&&' },
+  { name: 'plus-to-minus', pattern: /(?<![+])\+(?![+=])/g, replacement: '-' },
+  { name: 'minus-to-plus', pattern: /(?<!-)\-(?!\-|=)/g, replacement: '+' },
+  { name: 'true-to-false', pattern: /: true\b/g, replacement: ': false' },
+  { name: 'false-to-true', pattern: /: false\b/g, replacement: ': true' }
+]
+
+function getSourceFiles(pkg) {
+  const srcDir = path.join('packages', pkg, 'src')
+  return globSync('**/*.ts', { cwd: srcDir, absolute: true })
+    .filter(f => !f.endsWith('.test.ts'))
+}
+
+function runTests(pkg) {
+  try {
+    execSync('npm test', {
+      cwd: path.join('packages', pkg),
+      stdio: 'pipe',
+      timeout: 30000
+    })
+    return { passed: true }
+  } catch (e) {
+    return { passed: false, output: e.stdout?.toString() || e.message }
+  }
+}
+
+function build(pkg) {
+  try {
+    execSync('npm run build', {
+      cwd: path.join('packages', pkg),
+      stdio: 'pipe',
+      timeout: 60000
+    })
+    return true
+  } catch (e) {
+    return false
+  }
+}
+
+function applyMutation(filePath, mutation, index) {
+  const content = readFileSync(filePath, 'utf8')
+  const matches = [...content.matchAll(mutation.pattern)]
+  
+  if (matches.length === 0) return null
+  if (index >= matches.length) return null
+  
+  const match = matches[index]
+  const before = content.slice(0, match.index)
+  const after = content.slice(match.index + match[0].length)
+  const mutated = before + mutation.replacement + after
+  
+  writeFileSync(filePath, mutated)
+  return {
+    line: content.slice(0, match.index).split('\n').length,
+    original: match[0],
+    mutated: mutation.replacement
+  }
+}
+
+function restoreFile(filePath, original) {
+  writeFileSync(filePath, original)
+}
+
+const results = {}
+
+for (const pkg of PACKAGES) {
+  console.log(`\n=== Package: ${pkg} ===`)
+  const files = getSourceFiles(pkg)
+  const pkgResults = {
+    total: 0,
+    killed: 0,
+    survived: 0,
+    timedOut: 0,
+    mutants: []
+  }
+  
+  for (const filePath of files) {
+    const content = readFileSync(filePath, 'utf8')
+    
+    for (const mutation of MUTATIONS) {
+      const matches = [...content.matchAll(mutation.pattern)]
+      
+      for (let i = 0; i < matches.length; i++) {
+        const info = applyMutation(filePath, mutation, i)
+        if (!info) continue
+        
+        pkgResults.total++
+        const shortFile = path.relative(process.cwd(), filePath)
+        
+        process.stdout.write(`  Mutant ${pkgResults.total}: ${shortFile}:${info.line} ${info.original} -> ${info.mutated} `)
+        
+        const built = build(pkg)
+        if (!built) {
+          pkgResults.timedOut++
+          console.log('BUILD ERROR')
+          restoreFile(filePath, content)
+          continue
+        }
+        
+        const testResult = runTests(pkg)
+        
+        if (!testResult.passed) {
+          pkgResults.killed++
+          console.log('KILLED')
+        } else {
+          pkgResults.survived++
+          console.log('SURVIVED')
+          pkgResults.mutants.push({
+            file: shortFile,
+            line: info.line,
+            mutation: `${info.original} -> ${info.mutated}`,
+            type: mutation.name
+          })
+        }
+        
+        restoreFile(filePath, content)
+      }
+    }
+  }
+  
+  const score = pkgResults.total > 0 
+    ? Math.round((pkgResults.killed / pkgResults.total) * 100) 
+    : 0
+  pkgResults.score = score
+  results[pkg] = pkgResults
+  
+  console.log(`\n  Score: ${score}% (${pkgResults.killed}/${pkgResults.total})`)
+  console.log(`  Survived: ${pkgResults.survived}, TimedOut: ${pkgResults.timedOut}`)
+}
+
+console.log('\n\n========== MUTATION TESTING SUMMARY ==========')
+console.log('| Package | Score | Survived | Killed | Timeout |')
+console.log('|---------|-------|----------|--------|---------|')
+for (const pkg of PACKAGES) {
+  const r = results[pkg]
+  console.log(`| ${pkg.padEnd(18)} | ${String(r.score).padStart(3)}% | ${String(r.survived).padStart(8)} | ${String(r.killed).padStart(6)} | ${String(r.timedOut).padStart(7)} |`)
+}
+
+console.log('\n\n========== SURVIVING MUTANTS ==========')
+for (const pkg of PACKAGES) {
+  const r = results[pkg]
+  if (r.mutants.length === 0) continue
+  
+  console.log(`\n--- ${pkg} ---`)
+  for (const m of r.mutants) {
+    console.log(`  ${m.file}:${m.line}  ${m.mutation} (${m.type})`)
+  }
+}
+
+console.log('\n\nDone.')