flake-monster 0.4.0 → 0.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flake-monster",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "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/test.js

@@ -10,7 +10,7 @@ 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
@@ -85,17 +85,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
@@ -115,11 +131,6 @@ export function registerTestCommand(program) {
             };
 
             reporter.printRunResult(result, runs);
-            results.push(result);
-
-            if (i < runs - 1) {
-              reporter.printProgressTally(results, runs);
-            }
           } else {
             // Create workspace
             const workspace = new ProjectWorkspace({
@@ -134,21 +145,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;
@@ -167,11 +194,6 @@ export function registerTestCommand(program) {
             };
 
             reporter.printRunResult(result, runs);
-            results.push(result);
-
-            if (i < runs - 1) {
-              reporter.printProgressTally(results, runs);
-            }
 
             // Cleanup
             if (!shouldKeep) {

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/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) {