flake-monster 0.4.1 → 0.4.4

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.1",
+  "version": "0.4.4",
   "description": "Source-to-source test hardener that injects async delays to surface flaky tests",
   "type": "module",
   "bin": {

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,6 +5,7 @@ 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';
@@ -47,15 +48,32 @@ export function registerTestCommand(program) {
           ? detectRunner(testCmd)
           : options.runner;
 
+        // node:test needs --test-reporter json for machine-parseable output
+        const effectiveCmd = (runner === 'node-test' && !testCmd.includes('--test-reporter'))
+          ? testCmd.replace(/node\s+--test/, 'node --test --test-reporter json')
+          : testCmd;
+
         const profile = FlakeProfile.fromConfig(merged);
         const registry = new AdapterRegistry();
         registry.register(createJavaScriptAdapter());
         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}`);
+        reporter.log(`  Command: ${effectiveCmd}`);
         reporter.log(`  Patterns: ${globs.join(', ')}`);
         if (runner) {
           reporter.log(`  Runner: ${runner}`);
@@ -104,7 +122,7 @@ export function registerTestCommand(program) {
 
             let exitCode, stdout, stderr, durationMs;
             try {
-              ({ exitCode, stdout, stderr } = await execAsync(testCmd, projectRoot, {
+              ({ exitCode, stdout, stderr } = await execAsync(effectiveCmd, projectRoot, {
                 onStdout: reporter.quiet ? undefined : (chunk) => sticky.writeAbove(chunk),
                 onStderr: reporter.quiet ? undefined : (chunk) => sticky.writeAboveStderr(chunk),
               }));
@@ -130,6 +148,7 @@ export function registerTestCommand(program) {
               tests: parsed?.tests ?? [],
             };
 
+            results.push(result);
             reporter.printRunResult(result, runs);
           } else {
             // Create workspace
@@ -164,7 +183,7 @@ export function registerTestCommand(program) {
 
             let exitCode, stdout, stderr, durationMs;
             try {
-              ({ exitCode, stdout, stderr } = await workspace.execAsync(testCmd, {
+              ({ exitCode, stdout, stderr } = await workspace.execAsync(effectiveCmd, {
                 onStdout: reporter.quiet ? undefined : (chunk) => sticky.writeAbove(chunk),
                 onStderr: reporter.quiet ? undefined : (chunk) => sticky.writeAboveStderr(chunk),
               }));
@@ -193,6 +212,7 @@ export function registerTestCommand(program) {
               tests: parsed?.tests ?? [],
             };
 
+            results.push(result);
             reporter.printRunResult(result, runs);
 
             // Cleanup

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/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);
+    }
+  }
+}