tribunal-kit 6.0.1 → 8.0.0

package/.agent/scripts/minimal_change_engine.js

@@ -29,42 +29,41 @@
  *   node .agent/scripts/minimal_change_engine.js search --query "fetchRetry"
  */
 
-"use strict";
+'use strict';
 
-const fs = require("fs");
-const path = require("path");
+const fs = require('fs');
+const path = require('path');
 
 // ── Shared Utilities & Colors ────────────────────────────────────────────────
-const { GREEN, YELLOW, CYAN, RED, BOLD, DIM, RESET } = require("./_colors");
-const { findAgentDir, loadJson, walkDir, DEFAULT_SKIP_DIRS } = require("./_utils");
+const { loadJson, DEFAULT_SKIP_DIRS } = require('./_utils');
 
 // ── Decision Order Hierarchy ─────────────────────────────────────────────────
 const DECISION_HIERARCHY = [
-  "NO_CHANGE",
-  "REUSE",
-  "CONFIGURE",
-  "DELETE",
-  "MODIFY",
-  "EXTEND",
-  "CREATE",
+  'NO_CHANGE',
+  'REUSE',
+  'CONFIGURE',
+  'DELETE',
+  'MODIFY',
+  'EXTEND',
+  'CREATE',
 ];
 
 // ── 14 Standardized Complexity Flag Types ────────────────────────────────────
 const COMPLEXITY_FLAG_TYPES = [
-  "UNNECESSARY_ABSTRACTION",
-  "DUPLICATE_FUNCTIONALITY",
-  "DEPENDENCY_BLOAT",
-  "FILE_PROLIFERATION",
-  "PREMATURE_GENERALIZATION",
-  "SCOPE_EXPANSION",
-  "UNNECESSARY_REWRITE",
-  "FRAMEWORK_REINVENTION",
-  "STANDARD_LIBRARY_REINVENTION",
-  "EXCESSIVE_BOILERPLATE",
-  "SPECULATIVE_FEATURE",
-  "UNJUSTIFIED_INFRASTRUCTURE",
-  "UNNECESSARY_CONFIGURATION",
-  "DEAD_CODE_INTRODUCTION",
+  'UNNECESSARY_ABSTRACTION',
+  'DUPLICATE_FUNCTIONALITY',
+  'DEPENDENCY_BLOAT',
+  'FILE_PROLIFERATION',
+  'PREMATURE_GENERALIZATION',
+  'SCOPE_EXPANSION',
+  'UNNECESSARY_REWRITE',
+  'FRAMEWORK_REINVENTION',
+  'STANDARD_LIBRARY_REINVENTION',
+  'EXCESSIVE_BOILERPLATE',
+  'SPECULATIVE_FEATURE',
+  'UNJUSTIFIED_INFRASTRUCTURE',
+  'UNNECESSARY_CONFIGURATION',
+  'DEAD_CODE_INTRODUCTION',
 ];
 
 // ── Strictness Configurations ────────────────────────────────────────────────
@@ -133,10 +132,10 @@ function calculateMinimalityScore(budget, classification, flags = []) {
   }
 
   // Penalties for complexity flags based on severity
-  flags.forEach((flag) => {
-    if (flag.severity === "high" || flag.severity === "critical") {
+  flags.forEach(flag => {
+    if (flag.severity === 'high' || flag.severity === 'critical') {
       score -= 15;
-    } else if (flag.severity === "medium") {
+    } else if (flag.severity === 'medium') {
       score -= 8;
     } else {
       score -= 4;
@@ -163,55 +162,55 @@ function calculateMinimalityScore(budget, classification, flags = []) {
 /**
  * Detects potential complexity flags within a proposed change or spec.
  */
-function detectComplexityFlags(proposal = {}, existingSymbols = [], mode = "balanced") {
+function detectComplexityFlags(proposal = {}, _existingSymbols = [], mode = 'balanced') {
   const flags = [];
   const limits = STRICTNESS_CONFIGS[mode] || STRICTNESS_CONFIGS.balanced;
 
   // Check 1: Dependency Bloat
   if (proposal.dependencies_added > limits.max_deps_warn) {
     flags.push({
-      type: "DEPENDENCY_BLOAT",
-      severity: proposal.dependencies_added > 1 ? "high" : "medium",
+      type: 'DEPENDENCY_BLOAT',
+      severity: proposal.dependencies_added > 1 ? 'high' : 'medium',
       evidence: `${proposal.dependencies_added} new dependency/dependencies proposed.`,
-      location: proposal.target_file || "package.json",
-      reason: "Adding dependencies increases security attack surface and maintenance overhead.",
-      recommended_action: "Use standard library or existing codebase utilities.",
+      location: proposal.target_file || 'package.json',
+      reason: 'Adding dependencies increases security attack surface and maintenance overhead.',
+      recommended_action: 'Use standard library or existing codebase utilities.',
     });
   }
 
   // Check 2: File Proliferation
   if (proposal.files_added > limits.max_files_added_warn) {
     flags.push({
-      type: "FILE_PROLIFERATION",
-      severity: proposal.files_added > 3 ? "high" : "medium",
+      type: 'FILE_PROLIFERATION',
+      severity: proposal.files_added > 3 ? 'high' : 'medium',
       evidence: `${proposal.files_added} new files proposed for creation.`,
-      location: proposal.target_file || "workspace",
-      reason: "Creating multiple new files increases architectural noise and fragmentation.",
-      recommended_action: "Modify or extend existing files instead of creating new ones.",
+      location: proposal.target_file || 'workspace',
+      reason: 'Creating multiple new files increases architectural noise and fragmentation.',
+      recommended_action: 'Modify or extend existing files instead of creating new ones.',
     });
   }
 
   // Check 3: Unnecessary Abstraction
   if (proposal.new_abstractions > limits.max_abstractions_warn) {
     flags.push({
-      type: "UNNECESSARY_ABSTRACTION",
-      severity: "medium",
+      type: 'UNNECESSARY_ABSTRACTION',
+      severity: 'medium',
       evidence: `${proposal.new_abstractions} new abstraction layer(s) proposed.`,
-      location: proposal.target_file || "codebase",
-      reason: "Adding wrappers or single-consumer interfaces increases complexity without benefit.",
-      recommended_action: "Implement concrete logic directly without extra abstraction.",
+      location: proposal.target_file || 'codebase',
+      reason: 'Adding wrappers or single-consumer interfaces increases complexity without benefit.',
+      recommended_action: 'Implement concrete logic directly without extra abstraction.',
     });
   }
 
   // Check 4: Duplicate Functionality
   if (proposal.duplicate_candidates && proposal.duplicate_candidates.length > 0) {
-    proposal.duplicate_candidates.forEach((cand) => {
+    proposal.duplicate_candidates.forEach(cand => {
       flags.push({
-        type: "DUPLICATE_FUNCTIONALITY",
-        severity: "high",
+        type: 'DUPLICATE_FUNCTIONALITY',
+        severity: 'high',
         evidence: `Existing equivalent symbol '${cand.name}' found in ${cand.file}`,
         location: cand.file,
-        reason: "Duplicate functionality leads to fragmented state and maintenance confusion.",
+        reason: 'Duplicate functionality leads to fragmented state and maintenance confusion.',
         recommended_action: `Reuse '${cand.name}' from ${cand.file}`,
       });
     });
@@ -220,11 +219,11 @@ function detectComplexityFlags(proposal = {}, existingSymbols = [], mode = "bala
   // Check 5: Framework/Stdlib Reinvention
   if (proposal.reinventing_stdlib) {
     flags.push({
-      type: "STANDARD_LIBRARY_REINVENTION",
-      severity: "medium",
+      type: 'STANDARD_LIBRARY_REINVENTION',
+      severity: 'medium',
       evidence: `Proposed custom utility '${proposal.reinventing_stdlib.name}'`,
-      location: proposal.target_file || "utils",
-      reason: "Language standard library already provides built-in methods for this.",
+      location: proposal.target_file || 'utils',
+      reason: 'Language standard library already provides built-in methods for this.',
       recommended_action: `Use native JS/TS methods (e.g., Array.prototype, URL, crypto).`,
     });
   }
@@ -238,26 +237,26 @@ function detectComplexityFlags(proposal = {}, existingSymbols = [], mode = "bala
 function searchRepositoryForCapability(query, searchDir) {
   const matches = [];
 
-  if (!query || typeof query !== "string") return matches;
+  if (!query || typeof query !== 'string') return matches;
 
   let agentDir = null;
   let current = path.resolve(searchDir || process.cwd());
   const rootPath = path.parse(current).root;
   while (current !== rootPath) {
-    const candidate = path.join(current, ".agent");
+    const candidate = path.join(current, '.agent');
     if (fs.existsSync(candidate) && fs.statSync(candidate).isDirectory()) {
       agentDir = candidate;
       break;
     }
     current = path.dirname(current);
   }
-  const repoRoot = agentDir ? path.dirname(agentDir) : (searchDir || process.cwd());
+  const repoRoot = agentDir ? path.dirname(agentDir) : searchDir || process.cwd();
 
   const normalizedQuery = query.toLowerCase();
-  const searchKeywords = normalizedQuery.split(/\s+/).filter((k) => k.length > 2);
+  const searchKeywords = normalizedQuery.split(/\s+/).filter(k => k.length > 2);
 
   // Search package.json dependencies
-  const pkgPath = path.join(repoRoot, "package.json");
+  const pkgPath = path.join(repoRoot, 'package.json');
   if (fs.existsSync(pkgPath)) {
     const pkg = loadJson(pkgPath);
     if (pkg) {
@@ -265,12 +264,12 @@ function searchRepositoryForCapability(query, searchDir) {
         ...pkg.dependencies,
         ...pkg.devDependencies,
       };
-      Object.keys(allDeps).forEach((dep) => {
+      Object.keys(allDeps).forEach(dep => {
         if (dep.toLowerCase().includes(normalizedQuery)) {
           matches.push({
-            type: "dependency",
+            type: 'dependency',
             name: dep,
-            file: "package.json",
+            file: 'package.json',
             snippet: `Version: ${allDeps[dep]}`,
           });
         }
@@ -286,28 +285,31 @@ function searchRepositoryForCapability(query, searchDir) {
     for (const entry of entries) {
       const fullPath = path.join(dir, entry.name);
       if (entry.isDirectory()) {
-        if (DEFAULT_SKIP_DIRS.has(entry.name) || entry.name === "target") {
+        if (DEFAULT_SKIP_DIRS.has(entry.name) || entry.name === 'target') {
           continue;
         }
         scan(fullPath);
       } else if (entry.isFile() && /\.(js|ts|tsx|jsx|json|md)$/.test(entry.name)) {
         try {
-          const content = fs.readFileSync(fullPath, "utf8");
+          const content = fs.readFileSync(fullPath, 'utf8');
           const lower = content.toLowerCase();
 
-          const hasMatch = searchKeywords.some((kw) => lower.includes(kw));
+          const hasMatch = searchKeywords.some(kw => lower.includes(kw));
           if (hasMatch) {
             const relPath = path.relative(repoRoot, fullPath);
             // Extract function/class exports
-            const symbolRegex = /(?:export\s+(?:function|class|const|let|var|type|interface)|module\.exports\s*=)\s+([A-Za-z0-9_]+)/g;
+            const symbolRegex =
+              /(?:export\s+(?:function|class|const|let|var|type|interface)|module\.exports\s*=)\s+([A-Za-z0-9_]+)/g;
             let m;
             while ((m = symbolRegex.exec(content)) !== null) {
               if (m[1].toLowerCase().includes(normalizedQuery)) {
                 matches.push({
-                  type: "symbol",
+                  type: 'symbol',
                   name: m[1],
                   file: relPath,
-                  snippet: content.substring(Math.max(0, m.index - 40), m.index + 80).replace(/\n/g, " "),
+                  snippet: content
+                    .substring(Math.max(0, m.index - 40), m.index + 80)
+                    .replace(/\n/g, ' '),
                 });
               }
             }
@@ -334,37 +336,37 @@ function classifyProposal(taskDescription, proposal = {}, repoMatches = []) {
   const estimatedLinesAdded = proposal.estimated_lines_added || 0;
 
   if (repoMatches.length > 0 && filesAdded === 0) {
-    return "REUSE";
+    return 'REUSE';
   }
 
   if (filesAdded === 0 && filesModified === 0 && filesDeleted === 0) {
-    return "NO_CHANGE";
+    return 'NO_CHANGE';
   }
 
   if (proposal.is_config_only) {
-    return "CONFIGURE";
+    return 'CONFIGURE';
   }
 
   if (filesDeleted > 0 && filesAdded === 0 && estimatedLinesAdded === 0) {
-    return "DELETE";
+    return 'DELETE';
   }
 
   if (filesAdded === 0 && filesModified <= 2 && newAbstractions === 0) {
-    return "MODIFY";
+    return 'MODIFY';
   }
 
   if (filesAdded <= 2 && newAbstractions <= 1) {
-    return "EXTEND";
+    return 'EXTEND';
   }
 
-  return "CREATE";
+  return 'CREATE';
 }
 
 /**
  * Evaluates an implementation proposal completely.
  */
 function evaluateMinimalChange(taskDescription, proposal = {}, options = {}) {
-  const mode = options.mode || "balanced";
+  const mode = options.mode || 'balanced';
   const searchDir = options.cwd || process.cwd();
 
   const budget = calculateChangeBudget(proposal);
@@ -379,18 +381,20 @@ function evaluateMinimalChange(taskDescription, proposal = {}, options = {}) {
   const score = calculateMinimalityScore(budget, classification, flags);
 
   const reuseOpportunities = repoMatches.map(
-    (m) => `Reuse existing ${m.type} '${m.name}' in ${m.file}`,
+    m => `Reuse existing ${m.type} '${m.name}' in ${m.file}`,
   );
 
   const recommendedReductions = [];
   if (budget.dependencies_added > 0) {
-    recommendedReductions.push("Avoid introducing new npm dependencies; leverage existing utilities.");
+    recommendedReductions.push(
+      'Avoid introducing new npm dependencies; leverage existing utilities.',
+    );
   }
   if (budget.files_added > 1) {
-    recommendedReductions.push("Combine proposed new files into existing module structure.");
+    recommendedReductions.push('Combine proposed new files into existing module structure.');
   }
   if (budget.new_abstractions > 0) {
-    recommendedReductions.push("Remove single-use interface/class abstractions.");
+    recommendedReductions.push('Remove single-use interface/class abstractions.');
   }
 
   return {
@@ -399,7 +403,7 @@ function evaluateMinimalChange(taskDescription, proposal = {}, options = {}) {
     change_budget: budget,
     complexity_flags: flags,
     reuse_opportunities: reuseOpportunities,
-    unnecessary_changes: flags.map((f) => f.evidence),
+    unnecessary_changes: flags.map(f => f.evidence),
     recommended_reductions: recommendedReductions,
     decision_order: DECISION_HIERARCHY,
     passed: score >= (STRICTNESS_CONFIGS[mode]?.min_score_pass || 75),
@@ -409,14 +413,18 @@ function evaluateMinimalChange(taskDescription, proposal = {}, options = {}) {
 // ── CLI Main Entry Point ────────────────────────────────────────────────────
 if (require.main === module) {
   const args = process.argv.slice(2);
-  const command = args[0] || "evaluate";
-  const taskArg = args.find((a) => a.startsWith("--task="))?.split("=")[1] || "Default Task";
-  const modeArg = args.find((a) => a.startsWith("--mode="))?.split("=")[1] || "balanced";
-
-  if (command === "evaluate" || command === "audit") {
-    const result = evaluateMinimalChange(taskArg, { files_modified: 1, estimated_lines_added: 12 }, { mode: modeArg });
+  const command = args[0] || 'evaluate';
+  const taskArg = args.find(a => a.startsWith('--task='))?.split('=')[1] || 'Default Task';
+  const modeArg = args.find(a => a.startsWith('--mode='))?.split('=')[1] || 'balanced';
+
+  if (command === 'evaluate' || command === 'audit') {
+    const result = evaluateMinimalChange(
+      taskArg,
+      { files_modified: 1, estimated_lines_added: 12 },
+      { mode: modeArg },
+    );
     console.log(JSON.stringify(result, null, 2));
-  } else if (command === "search") {
+  } else if (command === 'search') {
     const matches = searchRepositoryForCapability(taskArg);
     console.log(JSON.stringify(matches, null, 2));
   } else {

package/.agent/scripts/mutation_runner.js

@@ -8,24 +8,24 @@
  *         line number reporting, configurable --max-mutants.
  */
 
-const fs = require("fs");
-const path = require("path");
-const { spawnSync } = require("child_process");
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
 
 // ── Mutation Definitions ──────────────────────────────────────────────────────
 const MUTATIONS = [
-  { name: "Strict Equality", pattern: /===/g, replacement: "!==" },
-  { name: "Strict Inequality", pattern: /!==/g, replacement: "===" },
-  { name: "Logical AND", pattern: /&&/g, replacement: "||" },
-  { name: "Logical OR", pattern: /\|\|/g, replacement: "&&" },
-  { name: "True -> False", pattern: /\btrue\b/g, replacement: "false" },
-  { name: "False -> True", pattern: /\bfalse\b/g, replacement: "true" },
-  { name: "Greater Than", pattern: /(?<!=)>(?!=)/g, replacement: "<" },
-  { name: "Less Than", pattern: /(?<!=)<(?!=)/g, replacement: ">" },
+  { name: 'Strict Equality', pattern: /===/g, replacement: '!==' },
+  { name: 'Strict Inequality', pattern: /!==/g, replacement: '===' },
+  { name: 'Logical AND', pattern: /&&/g, replacement: '||' },
+  { name: 'Logical OR', pattern: /\|\|/g, replacement: '&&' },
+  { name: 'True -> False', pattern: /\btrue\b/g, replacement: 'false' },
+  { name: 'False -> True', pattern: /\bfalse\b/g, replacement: 'true' },
+  { name: 'Greater Than', pattern: /(?<!=)>(?!=)/g, replacement: '<' },
+  { name: 'Less Than', pattern: /(?<!=)<(?!=)/g, replacement: '>' },
   {
-    name: "Return Early Removal",
+    name: 'Return Early Removal',
     pattern: /\breturn\b/g,
-    replacement: "/* return */",
+    replacement: '/* return */',
   },
 ];
 
@@ -34,17 +34,17 @@ const MUTATIONS = [
 function buildCodeMask(source) {
   const mask = new Array(source.length).fill(true);
   let inString = false;
-  let stringChar = "";
+  let stringChar = '';
   let inBlockComment = false;
   let inLineComment = false;
 
   for (let i = 0; i < source.length; i++) {
     const ch = source[i];
-    const next = source[i + 1] || "";
+    const next = source[i + 1] || '';
 
     if (inBlockComment) {
       mask[i] = false;
-      if (ch === "*" && next === "/") {
+      if (ch === '*' && next === '/') {
         mask[i + 1] = false;
         inBlockComment = false;
         i++;
@@ -54,7 +54,7 @@ function buildCodeMask(source) {
 
     if (inLineComment) {
       mask[i] = false;
-      if (ch === "\n") {
+      if (ch === '\n') {
         inLineComment = false;
       }
       continue;
@@ -62,7 +62,7 @@ function buildCodeMask(source) {
 
     if (inString) {
       mask[i] = false;
-      if (ch === "\\") {
+      if (ch === '\\') {
         i++;
         if (i < source.length) mask[i] = false;
         continue;
@@ -74,7 +74,7 @@ function buildCodeMask(source) {
     }
 
     // Entering block comment
-    if (ch === "/" && next === "*") {
+    if (ch === '/' && next === '*') {
       mask[i] = false;
       mask[i + 1] = false;
       inBlockComment = true;
@@ -83,7 +83,7 @@ function buildCodeMask(source) {
     }
 
     // Entering line comment
-    if (ch === "/" && next === "/") {
+    if (ch === '/' && next === '/') {
       mask[i] = false;
       mask[i + 1] = false;
       inLineComment = true;
@@ -92,7 +92,7 @@ function buildCodeMask(source) {
     }
 
     // Entering string
-    if (ch === '"' || ch === "'" || ch === "`") {
+    if (ch === '"' || ch === "'" || ch === '`') {
       mask[i] = false;
       inString = true;
       stringChar = ch;
@@ -110,7 +110,7 @@ function buildCodeMask(source) {
 function getLineNumber(source, charIndex) {
   let line = 1;
   for (let i = 0; i < charIndex && i < source.length; i++) {
-    if (source[i] === "\n") line++;
+    if (source[i] === '\n') line++;
   }
   return line;
 }
@@ -123,7 +123,7 @@ let backupPath = null;
 function safeRestore() {
   if (targetFile && originalContent) {
     try {
-      fs.writeFileSync(targetFile, originalContent, "utf-8");
+      fs.writeFileSync(targetFile, originalContent, 'utf-8');
     } catch {
       // Last resort: tell user where the backup is
       if (backupPath) {
@@ -141,29 +141,29 @@ function safeRestore() {
 }
 
 // 🛑 ABSOLUTE SAFETY NET
-process.on("SIGINT", () => {
+process.on('SIGINT', () => {
   safeRestore();
-  console.error("\n[Tribunal] Mutation Engine aborted. Target file restored.");
+  console.error('\n[Tribunal] Mutation Engine aborted. Target file restored.');
   process.exit(1);
 });
 
-process.on("uncaughtException", (err) => {
+process.on('uncaughtException', err => {
   safeRestore();
-  console.error("\n[Tribunal] Critical error. File restored.", err);
+  console.error('\n[Tribunal] Critical error. File restored.', err);
   process.exit(1);
 });
 
-process.on("exit", safeRestore);
+process.on('exit', safeRestore);
 
 // ── CLI Argument Parsing ──────────────────────────────────────────────────────
 function parseCliArgs(argv) {
   const args = argv.slice(2);
   let maxMutants = 5; // default per mutation type
   let fileToMutate = null;
-  let testCommandParts = [];
+  const testCommandParts = [];
 
   for (let i = 0; i < args.length; i++) {
-    if (args[i] === "--max-mutants" && args[i + 1]) {
+    if (args[i] === '--max-mutants' && args[i + 1]) {
       maxMutants = parseInt(args[i + 1], 10) || 5;
       i++; // skip next
     } else if (!fileToMutate) {
@@ -173,7 +173,7 @@ function parseCliArgs(argv) {
     }
   }
 
-  return { fileToMutate, testCommand: testCommandParts.join(" "), maxMutants };
+  return { fileToMutate, testCommand: testCommandParts.join(' '), maxMutants };
 }
 
 // ── Main Engine ───────────────────────────────────────────────────────────────
@@ -185,9 +185,9 @@ function runMutationTesting(fileToMutate, testCommand, maxMutantsPerType) {
     process.exit(1);
   }
 
-  originalContent = fs.readFileSync(targetFile, "utf-8");
-  backupPath = targetFile + ".bak";
-  fs.writeFileSync(backupPath, originalContent, "utf-8");
+  originalContent = fs.readFileSync(targetFile, 'utf-8');
+  backupPath = targetFile + '.bak';
+  fs.writeFileSync(backupPath, originalContent, 'utf-8');
 
   console.log(`\n━━━ Tribunal Mutation Engine v2.1 ━━━`);
   console.log(`Target:       ${fileToMutate}`);
@@ -195,11 +195,9 @@ function runMutationTesting(fileToMutate, testCommand, maxMutantsPerType) {
   console.log(`Max/type:     ${maxMutantsPerType}`);
   console.log(`\nExecuting baseline test run...`);
 
-  const baseline = spawnSync(testCommand, { shell: true, stdio: "pipe" });
+  const baseline = spawnSync(testCommand, { shell: true, stdio: 'pipe' });
   if (baseline.status !== 0) {
-    console.error(
-      `ERROR: Baseline test failed! Fix your tests before mutating.`,
-    );
+    console.error(`ERROR: Baseline test failed! Fix your tests before mutating.`);
     console.error(baseline.stderr.toString());
     safeRestore();
     process.exit(1);
@@ -220,10 +218,7 @@ function runMutationTesting(fileToMutate, testCommand, maxMutantsPerType) {
     const matchIndices = [];
     let m;
 
-    while (
-      (m = regex.exec(originalContent)) !== null &&
-      matchIndices.length < maxMutantsPerType
-    ) {
+    while ((m = regex.exec(originalContent)) !== null && matchIndices.length < maxMutantsPerType) {
       // Context-aware: skip matches that are inside strings or comments
       const matchStart = m.index;
       const matchEnd = m.index + m[0].length - 1;
@@ -250,12 +245,10 @@ function runMutationTesting(fileToMutate, testCommand, maxMutantsPerType) {
         mutatedString +
         originalContent.substring(index + length);
 
-      fs.writeFileSync(targetFile, mutatedContent, "utf-8");
+      fs.writeFileSync(targetFile, mutatedContent, 'utf-8');
 
-      process.stdout.write(
-        `  [Mutant #${totalMutants}] ${mutation.name} (L${lineNum}) ... `,
-      );
-      const run = spawnSync(testCommand, { shell: true, stdio: "pipe" });
+      process.stdout.write(`  [Mutant #${totalMutants}] ${mutation.name} (L${lineNum}) ... `);
+      const run = spawnSync(testCommand, { shell: true, stdio: 'pipe' });
 
       if (run.status !== 0) {
         console.log(`✅ KILLED`);
@@ -272,12 +265,11 @@ function runMutationTesting(fileToMutate, testCommand, maxMutantsPerType) {
       }
 
       // Restore immediately after each mutant
-      fs.writeFileSync(targetFile, originalContent, "utf-8");
+      fs.writeFileSync(targetFile, originalContent, 'utf-8');
     }
   }
 
-  const score =
-    totalMutants > 0 ? Math.round((killedMutants / totalMutants) * 100) : 100;
+  const score = totalMutants > 0 ? Math.round((killedMutants / totalMutants) * 100) : 100;
 
   console.log(`\n━━━ Mutation Summary ━━━`);
   console.log(`  Total Mutants:  ${totalMutants}`);
@@ -288,14 +280,10 @@ function runMutationTesting(fileToMutate, testCommand, maxMutantsPerType) {
   if (survivors.length > 0) {
     console.log(`\n━━━ Surviving Mutants (Weak Test Coverage) ━━━`);
     survivors.forEach((s, i) => {
-      console.log(
-        `  ${i + 1}. Line ${s.line}: ${s.type}  (${s.original} → ${s.mutated})`,
-      );
+      console.log(`  ${i + 1}. Line ${s.line}: ${s.type}  (${s.original} → ${s.mutated})`);
     });
     console.log(`\n  ⚠ These lines have no test that catches the mutation.`);
-    console.log(
-      `    Add assertions that would FAIL if the operator were swapped.`,
-    );
+    console.log(`    Add assertions that would FAIL if the operator were swapped.`);
   }
 
   process.exit(score < 80 ? 1 : 0);
@@ -305,13 +293,9 @@ function runMutationTesting(fileToMutate, testCommand, maxMutantsPerType) {
 const { fileToMutate, testCommand, maxMutants } = parseCliArgs(process.argv);
 
 if (!fileToMutate || !testCommand) {
-  console.log(
-    `Usage: node mutation_runner.js <target_file> [--max-mutants N] <test_command>`,
-  );
+  console.log(`Usage: node mutation_runner.js <target_file> [--max-mutants N] <test_command>`);
   console.log(`\nExamples:`);
-  console.log(
-    `  node mutation_runner.js src/math.js "npx jest src/math.test.js"`,
-  );
+  console.log(`  node mutation_runner.js src/math.js "npx jest src/math.test.js"`);
   console.log(
     `  node mutation_runner.js src/auth.js --max-mutants 10 "npx jest test/auth.test.js"`,
   );