flake-monster 0.4.0 → 0.4.3

package/README.md

@@ -57,7 +57,16 @@ flake-monster test --runs 5 --cmd "npm test"
 flake-monster test --cmd "npx playwright test" "src/**/*.js"
 ```
 
-**CI flake gate**, Block merges that introduce flaky tests.
+**CI flake gate**, Block merges that introduce flaky tests. Use the [GitHub Action](https://github.com/growthboot/FlakeMonster-Action) for automatic PR comments:
+
+```yaml
+# .github/workflows/flake-monster.yml
+- uses: growthboot/FlakeMonster-Action@v1
+  with:
+    test-command: 'npm test'
+```
+
+Or run the CLI directly in any CI environment:
 
 ```bash
 flake-monster test --runs 10 --cmd "npm test"
@@ -276,6 +285,10 @@ Recovery mode: scanning for injected lines...
 
 You see exactly which lines will be removed and why (`stamp`, `ident`, or `import`), then confirm before any files are modified.
 
+## Changelog
+
+See [VERSIONS.md](VERSIONS.md) for detailed version history.
+
 ## License
 
 MIT

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flake-monster",
-  "version": "0.4.0",
+  "version": "0.4.3",
   "description": "Source-to-source test hardener that injects async delays to surface flaky tests",
   "type": "module",
   "bin": {

package/src/adapters/javascript/index.js

@@ -15,14 +15,14 @@ const RUNTIME_FILENAME = 'flake-monster.runtime.js';
  * @returns {string}
  */
 function computeRuntimeImportPath(filePath) {
-  // Count directory depth
-  const parts = filePath.split('/').filter(Boolean);
-  if (parts.length <= 1) {
+  const normalized = posix.normalize(filePath);
+  const dir = posix.dirname(normalized);
+  if (dir === '.') {
     // File is at root level
     return `./${RUNTIME_FILENAME}`;
   }
-  // Go up (parts.length - 1) directories
-  const ups = '../'.repeat(parts.length - 1);
+  const depth = dir.split('/').length;
+  const ups = '../'.repeat(depth);
   return `${ups}${RUNTIME_FILENAME}`;
 }
 

package/src/cli/commands/inject.js

@@ -1,12 +1,24 @@
 import { resolve } from 'node:path';
+import { createInterface } from 'node:readline';
 import { AdapterRegistry } from '../../adapters/registry.js';
 import { createJavaScriptAdapter } from '../../adapters/javascript/index.js';
 import { InjectorEngine } from '../../core/engine.js';
 import { FlakeProfile } from '../../core/profile.js';
 import { parseSeed } from '../../core/seed.js';
 import { ProjectWorkspace, getFlakeMonsterDir } from '../../core/workspace.js';
+import { Manifest } from '../../core/manifest.js';
 import { loadConfig, mergeWithCliOptions } from '../../core/config.js';
 
+function confirm(question) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim().toLowerCase() === 'y');
+    });
+  });
+}
+
 export function registerInjectCommand(program) {
   program
     .command('inject')
@@ -31,6 +43,23 @@ export function registerInjectCommand(program) {
         registry.register(createJavaScriptAdapter());
         const engine = new InjectorEngine(registry, profile);
 
+        // Guard against double injection
+        const flakeDirCheck = getFlakeMonsterDir(projectRoot);
+        const existingManifest = await Manifest.load(flakeDirCheck);
+        if (existingManifest) {
+          console.log(
+            `Active injection detected (seed: ${existingManifest.seed}, mode: ${existingManifest.mode}, injected at: ${existingManifest.createdAt}).`
+          );
+          const proceed = await confirm('Restore source files before re-injecting? (y/N) ');
+          if (!proceed) {
+            console.log('Aborted. Run `flake-monster restore` manually to clean up.');
+            process.exit(1);
+          }
+          await engine.restoreAll(projectRoot, existingManifest);
+          await Manifest.delete(flakeDirCheck);
+          console.log('Previous injections removed. Proceeding with fresh injection.\n');
+        }
+
         const useWorkspace = options.workspace;
         let targetDir = projectRoot;
         let workspace = null;

package/src/cli/commands/test.js

@@ -5,12 +5,13 @@ import { InjectorEngine } from '../../core/engine.js';
 import { FlakeProfile } from '../../core/profile.js';
 import { parseSeed, deriveSeed } from '../../core/seed.js';
 import { ProjectWorkspace, getFlakeMonsterDir, execAsync } from '../../core/workspace.js';
+import { Manifest } from '../../core/manifest.js';
 import { loadConfig, mergeWithCliOptions } from '../../core/config.js';
 import { Reporter } from '../../core/reporter.js';
 import { detectRunner, parseTestOutput } from '../../core/parsers/index.js';
 import { analyzeFlakiness } from '../../core/flake-analyzer.js';
 import * as terminal from '../terminal.js';
-import { Spinner } from '../terminal.js';
+import { StickyLine } from '../terminal.js';
 
 export function registerTestCommand(program) {
   program
@@ -53,6 +54,18 @@ export function registerTestCommand(program) {
         const engine = new InjectorEngine(registry, profile);
         const reporter = new Reporter({ quiet: jsonOutput, terminal });
 
+        // Guard against stale injection from a previous interrupted run
+        if (inPlace) {
+          const flakeDir = getFlakeMonsterDir(projectRoot);
+          const staleManifest = await Manifest.load(flakeDir);
+          if (staleManifest) {
+            reporter.log(`Stale injection detected (seed: ${staleManifest.seed}, mode: ${staleManifest.mode}). Restoring before proceeding...`);
+            await engine.restoreAll(projectRoot, staleManifest);
+            await Manifest.delete(flakeDir);
+            reporter.log('Stale injections removed. Source files are clean.\n');
+          }
+        }
+
         reporter.log(`FlakeMonster test harness`);
         reporter.log(`  Runs: ${runs} | Mode: ${profile.mode} | Base seed: ${baseSeed}`);
         reporter.log(`  Command: ${testCmd}`);
@@ -85,17 +98,33 @@ export function registerTestCommand(program) {
             lastManifest = manifest;
             reporter.printInjectionStats(manifest);
 
-            // Run tests with spinner
-            const spinner = new Spinner(`Run ${i + 1}/${runs}  seed=${runSeed}`);
-            if (!reporter.quiet) spinner.start();
+            // Run tests — stream output with sticky status line
+            const passed = results.filter(r => r.exitCode === 0).length;
+            const failed = results.length - passed;
+            const sticky = new StickyLine();
+            const start = Date.now();
+            let stickyTimer;
+
+            if (!reporter.quiet) {
+              const stickyContent = () => {
+                const elapsed = ((Date.now() - start) / 1000).toFixed(1);
+                const bar = terminal.progressBar(i, runs);
+                return terminal.dim(`  ${bar}  ${passed} passed  ${failed} failed  `) + `Run ${i + 1}/${runs}  ${elapsed}s`;
+              };
+              sticky.start(stickyContent());
+              stickyTimer = setInterval(() => sticky.update(stickyContent()), 200);
+            }
 
             let exitCode, stdout, stderr, durationMs;
-            const start = Date.now();
             try {
-              ({ exitCode, stdout, stderr } = await execAsync(testCmd, projectRoot));
+              ({ exitCode, stdout, stderr } = await execAsync(testCmd, projectRoot, {
+                onStdout: reporter.quiet ? undefined : (chunk) => sticky.writeAbove(chunk),
+                onStderr: reporter.quiet ? undefined : (chunk) => sticky.writeAboveStderr(chunk),
+              }));
               durationMs = Date.now() - start;
             } finally {
-              if (!reporter.quiet) spinner.stop();
+              if (stickyTimer) clearInterval(stickyTimer);
+              sticky.clear();
             }
 
             // Parse test output if we have a runner
@@ -114,12 +143,8 @@ export function registerTestCommand(program) {
               tests: parsed?.tests ?? [],
             };
 
-            reporter.printRunResult(result, runs);
             results.push(result);
-
-            if (i < runs - 1) {
-              reporter.printProgressTally(results, runs);
-            }
+            reporter.printRunResult(result, runs);
           } else {
             // Create workspace
             const workspace = new ProjectWorkspace({
@@ -134,21 +159,37 @@ export function registerTestCommand(program) {
             await manifest.save(flakeDir);
             reporter.printInjectionStats(manifest);
 
-            // Run tests with spinner
-            const spinner = new Spinner(`Run ${i + 1}/${runs}  seed=${runSeed}`);
-            if (!reporter.quiet) spinner.start();
+            // Run tests — stream output with sticky status line
+            const passed = results.filter(r => r.exitCode === 0).length;
+            const failed = results.length - passed;
+            const sticky = new StickyLine();
+            const start = Date.now();
+            let stickyTimer;
+
+            if (!reporter.quiet) {
+              const stickyContent = () => {
+                const elapsed = ((Date.now() - start) / 1000).toFixed(1);
+                const bar = terminal.progressBar(i, runs);
+                return terminal.dim(`  ${bar}  ${passed} passed  ${failed} failed  `) + `Run ${i + 1}/${runs}  ${elapsed}s`;
+              };
+              sticky.start(stickyContent());
+              stickyTimer = setInterval(() => sticky.update(stickyContent()), 200);
+            }
 
             let exitCode, stdout, stderr, durationMs;
-            const start = Date.now();
             try {
-              ({ exitCode, stdout, stderr } = await workspace.execAsync(testCmd));
+              ({ exitCode, stdout, stderr } = await workspace.execAsync(testCmd, {
+                onStdout: reporter.quiet ? undefined : (chunk) => sticky.writeAbove(chunk),
+                onStderr: reporter.quiet ? undefined : (chunk) => sticky.writeAboveStderr(chunk),
+              }));
               durationMs = Date.now() - start;
             } finally {
-              if (!reporter.quiet) spinner.stop();
+              if (stickyTimer) clearInterval(stickyTimer);
+              sticky.clear();
             }
 
-            const failed = exitCode !== 0;
-            const shouldKeep = (failed && options.keepOnFail) || options.keepAll;
+            const testFailed = exitCode !== 0;
+            const shouldKeep = (testFailed && options.keepOnFail) || options.keepAll;
 
             // Parse test output if we have a runner
             const parsed = runner ? parseTestOutput(runner, stdout) : null;
@@ -166,12 +207,8 @@ export function registerTestCommand(program) {
               tests: parsed?.tests ?? [],
             };
 
-            reporter.printRunResult(result, runs);
             results.push(result);
-
-            if (i < runs - 1) {
-              reporter.printProgressTally(results, runs);
-            }
+            reporter.printRunResult(result, runs);
 
             // Cleanup
             if (!shouldKeep) {

package/src/cli/index.js

@@ -1,15 +1,21 @@
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { resolve, dirname } from 'node:path';
 import { Command } from 'commander';
 import { registerInjectCommand } from './commands/inject.js';
 import { registerRestoreCommand } from './commands/restore.js';
 import { registerTestCommand } from './commands/test.js';
 
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const pkg = JSON.parse(readFileSync(resolve(__dirname, '../../package.json'), 'utf8'));
+
 export function createCli() {
   const program = new Command();
 
   program
     .name('flake-monster')
     .description('Source-to-source test hardener, injects async delays to surface flaky tests')
-    .version('0.4.0');
+    .version(pkg.version);
 
   registerInjectCommand(program);
   registerRestoreCommand(program);

package/src/cli/terminal.js

@@ -96,62 +96,91 @@ export function box(lines) {
   return [top, ...body, bottom].join('\n');
 }
 
-// ── Spinner ───────────────────────────────────────────────────────────
-
-const SPINNER_FRAMES = ['\u280B', '\u2819', '\u2839', '\u2838', '\u283C', '\u2834', '\u2826', '\u2827', '\u2807', '\u280F'];
-const SPINNER_INTERVAL = 80; // ms
+// ── Sticky line ───────────────────────────────────────────────────────
 
 /**
- * A simple terminal spinner with elapsed time display.
- * On non-TTY terminals, prints a single static line instead.
+ * A persistent status line that stays at the bottom of the terminal
+ * while other output scrolls above it.
+ *
+ * On non-TTY terminals, does nothing — output flows normally.
  */
-export class Spinner {
+export class StickyLine {
+  constructor() {
+    this._content = '';
+    this._active = false;
+  }
+
   /**
-   * @param {string} message - Text to show next to the spinner
+   * Start showing the sticky line.
+   * @param {string} content - Initial content
    */
-  constructor(message) {
-    this.message = message;
-    this._timer = null;
-    this._frame = 0;
-    this._startTime = null;
+  start(content) {
+    this._active = true;
+    this._content = content;
+    if (isTTY()) {
+      process.stdout.write(this._content);
+    }
   }
 
-  /** Start the spinner animation. */
-  start() {
-    this._startTime = Date.now();
+  /**
+   * Update the sticky line content (e.g. elapsed timer).
+   * @param {string} content
+   */
+  update(content) {
+    this._content = content;
+    if (this._active && isTTY()) {
+      process.stdout.write('\r\x1b[K' + this._content);
+    }
+  }
 
-    if (!isTTY()) {
-      process.stdout.write(`  ${this.message} ...\n`);
+  /**
+   * Write output above the sticky line.
+   * Clears the sticky, writes the chunk, then re-renders.
+   * @param {Buffer|string} chunk
+   */
+  writeAbove(chunk) {
+    if (!this._active || !isTTY()) {
+      process.stdout.write(chunk);
       return;
     }
-
-    this._render();
-    this._timer = setInterval(() => this._render(), SPINNER_INTERVAL);
+    // Clear sticky line
+    process.stdout.write('\r\x1b[K');
+    // Write the actual output
+    process.stdout.write(chunk);
+    // Ensure sticky gets its own line
+    const str = chunk.toString();
+    if (str.length > 0 && !str.endsWith('\n')) {
+      process.stdout.write('\n');
+    }
+    // Re-render sticky
+    process.stdout.write(this._content);
   }
 
-  /** Stop the spinner and clear the line. Returns elapsed ms. */
-  stop() {
-    const elapsed = this._startTime ? Date.now() - this._startTime : 0;
-
-    if (this._timer) {
-      clearInterval(this._timer);
-      this._timer = null;
+  /**
+   * Write stderr output above the sticky line.
+   * @param {Buffer|string} chunk
+   */
+  writeAboveStderr(chunk) {
+    if (!this._active || !isTTY()) {
+      process.stderr.write(chunk);
+      return;
     }
-
-    if (isTTY()) {
-      // Clear the spinner line
-      process.stdout.write('\r\x1b[K');
+    // Clear sticky on stdout, write stderr, re-render sticky
+    process.stdout.write('\r\x1b[K');
+    process.stderr.write(chunk);
+    const str = chunk.toString();
+    if (str.length > 0 && !str.endsWith('\n')) {
+      process.stderr.write('\n');
     }
-
-    return elapsed;
+    process.stdout.write(this._content);
   }
 
-  /** @private */
-  _render() {
-    const frame = SPINNER_FRAMES[this._frame % SPINNER_FRAMES.length];
-    this._frame++;
-    const elapsed = ((Date.now() - this._startTime) / 1000).toFixed(1);
-    const elapsedStr = dim(`(${elapsed}s)`);
-    process.stdout.write(`\r  ${frame} ${this.message} ${elapsedStr}\x1b[K`);
+  /** Clear the sticky line and deactivate. */
+  clear() {
+    if (this._active && isTTY()) {
+      process.stdout.write('\r\x1b[K');
+    }
+    this._active = false;
+    this._content = '';
   }
 }

package/src/core/parsers/index.js

@@ -1,10 +1,12 @@
 import { parseJestOutput } from './jest.js';
 import { parseNodeTestOutput } from './node-test.js';
+import { parsePlaywrightOutput } from './playwright.js';
 import { parseTapOutput } from './tap.js';
 
 const parsers = {
   jest: parseJestOutput,
   'node-test': parseNodeTestOutput,
+  playwright: parsePlaywrightOutput,
   tap: parseTapOutput,
 };
 
@@ -19,6 +21,9 @@ export function detectRunner(testCommand) {
   if (testCommand.includes('node --test') || testCommand.includes('node:test')) {
     return 'node-test';
   }
+  if (testCommand.includes('playwright')) {
+    return 'playwright';
+  }
   return 'tap';
 }
 

package/src/core/parsers/playwright.js

@@ -0,0 +1,98 @@
+/**
+ * Parses Playwright JSON reporter output (from `--reporter=json`).
+ *
+ * Playwright JSON schema:
+ * {
+ *   suites: [{
+ *     title: string,
+ *     file: string,
+ *     suites: [...],        // nested suites
+ *     specs: [{
+ *       title: string,
+ *       file: string,
+ *       tests: [{
+ *         projectName: string,
+ *         results: [{
+ *           status: "passed" | "failed" | "timedOut" | "skipped" | "interrupted",
+ *           duration: number (ms),
+ *           error?: { message: string, stack?: string }
+ *         }],
+ *         status: "expected" | "unexpected" | "flaky" | "skipped"
+ *       }]
+ *     }]
+ *   }]
+ * }
+ *
+ * Each spec may have multiple tests (one per project/browser).
+ * Each test may have multiple results (retries), but we use the
+ * overall test.status to determine passed/failed/skipped.
+ * Duration is summed from all results for that test.
+ */
+export function parsePlaywrightOutput(stdout) {
+  try {
+    const data = JSON.parse(stdout);
+    if (!data.suites || !Array.isArray(data.suites)) {
+      return { parsed: false, tests: [], totalPassed: 0, totalFailed: 0, totalSkipped: 0 };
+    }
+
+    const tests = [];
+    collectTests(data.suites, [], tests);
+
+    return {
+      parsed: true,
+      tests,
+      totalPassed: tests.filter(t => t.status === 'passed').length,
+      totalFailed: tests.filter(t => t.status === 'failed').length,
+      totalSkipped: tests.filter(t => t.status === 'skipped').length,
+    };
+  } catch {
+    return { parsed: false, tests: [], totalPassed: 0, totalFailed: 0, totalSkipped: 0 };
+  }
+}
+
+/**
+ * Recursively walk suites and collect leaf test entries.
+ */
+function collectTests(suites, titlePath, out) {
+  for (const suite of suites) {
+    const currentPath = suite.title ? [...titlePath, suite.title] : titlePath;
+
+    for (const spec of suite.specs || []) {
+      for (const test of spec.tests || []) {
+        const nameParts = [...currentPath, spec.title].filter(Boolean);
+        const name = nameParts.join(' > ');
+
+        const status =
+          test.status === 'skipped' ? 'skipped' :
+          test.status === 'expected' ? 'passed' : 'failed';
+
+        const results = test.results || [];
+        const durationMs = results.reduce((sum, r) => sum + (r.duration ?? 0), 0);
+
+        // Find the first error message from results
+        let failureMessage = null;
+        if (status === 'failed') {
+          for (const r of results) {
+            if (r.error) {
+              failureMessage = r.error.message || r.error.stack || String(r.error);
+              break;
+            }
+          }
+        }
+
+        out.push({
+          name,
+          file: spec.file || suite.file || null,
+          status,
+          durationMs: results.length > 0 ? durationMs : null,
+          failureMessage,
+        });
+      }
+    }
+
+    // Recurse into nested suites
+    if (suite.suites) {
+      collectTests(suite.suites, currentPath, out);
+    }
+  }
+}

package/src/core/workspace.js

@@ -158,11 +158,13 @@ export function getFlakeMonsterDir(projectRoot) {
  * @param {Object} [options]
  * @param {number} [options.timeout] - ms before killing the process
  * @param {Object} [options.env] - additional env vars
+ * @param {Function} [options.onStdout] - Callback for each stdout chunk (receives Buffer)
+ * @param {Function} [options.onStderr] - Callback for each stderr chunk (receives Buffer)
  * @returns {Promise<{ exitCode: number, stdout: string, stderr: string }>}
  */
 export function execAsync(command, cwd, options = {}) {
   return new Promise((resolve) => {
-    const { timeout, env } = options;
+    const { timeout, env, onStdout, onStderr } = options;
     const child = spawn(command, {
       cwd,
       shell: true,
@@ -173,8 +175,14 @@ export function execAsync(command, cwd, options = {}) {
     const stdoutChunks = [];
     const stderrChunks = [];
 
-    child.stdout.on('data', (chunk) => stdoutChunks.push(chunk));
-    child.stderr.on('data', (chunk) => stderrChunks.push(chunk));
+    child.stdout.on('data', (chunk) => {
+      stdoutChunks.push(chunk);
+      if (onStdout) onStdout(chunk);
+    });
+    child.stderr.on('data', (chunk) => {
+      stderrChunks.push(chunk);
+      if (onStderr) onStderr(chunk);
+    });
 
     let timer;
     if (timeout) {