flake-monster 0.3.2 → 0.3.4

package/README.md

@@ -4,11 +4,11 @@ A source-to-source test hardener that finds flaky tests by injecting async delay
 
 ## Why
 
-Automated tests run unrealistically fast. API calls resolve instantly against local mocks, database queries return in microseconds, commands are fired fasters than you can blink and eye, and every async operation completes in the exact same order every time. In production, none of that is true. Network latency varies, services respond unpredictably, computer performance varies, devices glitch, and users interact at human speed. Tests that pass in this perfectly-timed environment can hide real bugs, race conditions, missing `await`s, and unguarded state mutations, that only surface when timing shifts even slightly.
+Automated tests run unrealistically fast. API calls resolve instantly against local mocks, database queries return in microseconds, commands are fired faster than you can blink an eye, and every async operation completes in the exact same order every time. In production, none of that is true. Network latency varies, services respond unpredictably, computer performance varies, devices glitch, and users interact at human speed. Tests that pass in this perfectly-timed environment can hide real bugs, race conditions, missing `await`s, and unguarded state mutations, that only surface when timing shifts even slightly.
 
 FlakeMonster closes that gap. It **deliberately injects async delays** between statements in your `async` functions and at the module top level (using top-level `await`), forcing the event loop to yield where it normally wouldn't. Tests that depend on everything happening in a precise order will start failing, and that's the point. A test that only passes because it runs too fast to trigger its own race condition **should not be passing**.
 
-The goal isn't to slow your tests down. The goal is to increasing flake likelyhood random timing glitches so that you can catch the test flakes on your first tests.
+The goal isn't to slow your tests down. The goal is to increase the likelihood of timing glitches surfacing so you can catch flakes before they hit CI.
 
 Every run uses a **deterministic seed**, so when a test fails you get output like:
 

package/package.json

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

package/src/adapters/javascript/injector.js

@@ -405,13 +405,20 @@ export function computeRuntimeImportInsertion(ast, source, runtimeImportPath) {
     }
   }
 
-  // Find the newline after the last import (or start of file)
-  let insertOffset = lastImportEnd;
-  while (insertOffset < source.length && source[insertOffset] !== '\n') {
-    insertOffset++;
-  }
-  if (insertOffset < source.length) {
-    insertOffset++; // past the \n
+  let insertOffset;
+  if (lastImportEnd === 0) {
+    // No existing imports — insert at the very start of the file
+    // (not after the first line, which may be inside a block comment)
+    insertOffset = 0;
+  } else {
+    // Find the newline after the last import
+    insertOffset = lastImportEnd;
+    while (insertOffset < source.length && source[insertOffset] !== '\n') {
+      insertOffset++;
+    }
+    if (insertOffset < source.length) {
+      insertOffset++; // past the \n
+    }
   }
 
   const text = `import { ${DELAY_OBJECT} } from '${runtimeImportPath}';\n`;

package/src/cli/commands/restore.js

@@ -61,20 +61,49 @@ export function registerRestoreCommand(program) {
         const flakeDir = getFlakeMonsterDir(targetDir);
 
         const manifest = await Manifest.load(flakeDir);
-        if (!manifest) {
-          console.log('No manifest found. Nothing to restore.');
-          console.log(`Looked in: ${flakeDir}`);
-          return;
-        }
 
-        const profile = FlakeProfile.fromConfig({ ...config, mode: manifest.mode });
+        const mode = manifest ? manifest.mode : (config.mode || 'medium');
+        const profile = FlakeProfile.fromConfig({ ...config, mode });
         const engine = new InjectorEngine(registry, profile);
+        const globs = config.include || ['**/*.js', '**/*.mjs'];
+        const exclude = config.exclude || ['**/node_modules/**', '**/dist/**', '**/build/**'];
+
+        if (!manifest && !options.recover) {
+          // No manifest — quick-scan to see if there's leftover injected code
+          const scanResults = await engine.scanByGlobs(targetDir, globs, exclude);
+
+          if (scanResults.length === 0) {
+            console.log('No manifest found and no injected code detected. Nothing to restore.');
+            return;
+          }
+
+          // Injected code found — offer interactive recovery
+          let totalMatches = 0;
+          for (const { matches } of scanResults) totalMatches += matches.length;
+
+          console.log(`No manifest found, but detected ${totalMatches} injected line(s) across ${scanResults.length} file(s).`);
+          const proceed = await confirm('Run recovery to clean them up? (y/N) ');
+          if (!proceed) {
+            console.log('Aborted. No files were modified.');
+            return;
+          }
+
+          // User confirmed — fall through to recovery
+          options.recover = true;
+        }
 
         if (options.recover) {
           // Recovery mode: scan first, show results, then confirm
-          console.log('Recovery mode: scanning for injected lines...');
-
-          const scanResults = await engine.scanAll(targetDir, manifest);
+          // Works with or without a manifest
+          let scanResults;
+
+          if (manifest) {
+            console.log('Recovery mode: scanning manifest files for injected lines...');
+            scanResults = await engine.scanAll(targetDir, manifest);
+          } else {
+            console.log('Scanning all source files...');
+            scanResults = await engine.scanByGlobs(targetDir, globs, exclude);
+          }
 
           if (scanResults.length === 0) {
             console.log('No injected lines found. Files appear clean.');
@@ -89,10 +118,14 @@ export function registerRestoreCommand(program) {
             return;
           }
 
-          const { filesRestored, injectionsRemoved } = await engine.restoreAll(targetDir, manifest);
-          await Manifest.delete(flakeDir);
-
-          console.log(`\n  Recovered ${filesRestored} file(s), removed ${injectionsRemoved} line(s)`);
+          if (manifest) {
+            const { filesRestored, injectionsRemoved } = await engine.restoreAll(targetDir, manifest);
+            await Manifest.delete(flakeDir);
+            console.log(`\n  Recovered ${filesRestored} file(s), removed ${injectionsRemoved} line(s)`);
+          } else {
+            const { filesRestored, injectionsRemoved } = await engine.restoreByGlobs(targetDir, globs, exclude);
+            console.log(`\n  Recovered ${filesRestored} file(s), removed ${injectionsRemoved} line(s)`);
+          }
         } else {
           const { filesRestored, injectionsRemoved } = await engine.restoreAll(targetDir, manifest);
           await Manifest.delete(flakeDir);

package/src/core/engine.js

@@ -102,6 +102,90 @@ export class InjectorEngine {
     return results;
   }
 
+  /**
+   * Scan files by glob patterns for recovery matches (no manifest needed).
+   * Discovers files via fast-glob and routes them through registered adapters.
+   * @param {string} rootDir
+   * @param {string[]} globs - File patterns to scan
+   * @param {string[]} [exclude=[]] - Glob patterns to exclude
+   * @returns {Promise<{ file: string, matches: { line: number, content: string, reason: string }[] }[]>}
+   */
+  async scanByGlobs(rootDir, globs, exclude = []) {
+    const results = [];
+    const files = await fg(globs, { cwd: rootDir, absolute: false, ignore: exclude });
+
+    for (const filePath of files) {
+      const adapter = this.registry.getAdapterForFile(filePath);
+      if (!adapter || !adapter.scan) continue;
+
+      const absPath = join(rootDir, filePath);
+      let source;
+      try {
+        source = await readFile(absPath, 'utf-8');
+      } catch {
+        continue;
+      }
+
+      const matches = adapter.scan(source);
+      if (matches.length > 0) {
+        results.push({ file: filePath, matches });
+      }
+    }
+
+    return results;
+  }
+
+  /**
+   * Remove injections from files discovered by glob patterns (no manifest needed).
+   * @param {string} rootDir
+   * @param {string[]} globs - File patterns to process
+   * @param {string[]} [exclude=[]] - Glob patterns to exclude
+   * @returns {Promise<{ filesRestored: number, injectionsRemoved: number }>}
+   */
+  async restoreByGlobs(rootDir, globs, exclude = []) {
+    let filesRestored = 0;
+    let injectionsRemoved = 0;
+
+    const files = await fg(globs, { cwd: rootDir, absolute: false, ignore: exclude });
+
+    for (const filePath of files) {
+      const adapter = this.registry.getAdapterForFile(filePath);
+      if (!adapter) continue;
+
+      const absPath = join(rootDir, filePath);
+      let source;
+      try {
+        source = await readFile(absPath, 'utf-8');
+      } catch {
+        continue;
+      }
+
+      const result = adapter.remove(source);
+      if (result.removedCount === 0) continue;
+
+      await writeFile(absPath, result.source, 'utf-8');
+      filesRestored++;
+      injectionsRemoved += result.removedCount;
+    }
+
+    // Clean up runtime files
+    const { unlink } = await import('node:fs/promises');
+    const runtimeFiles = await fg(['**/flake-monster.runtime.*'], {
+      cwd: rootDir,
+      absolute: false,
+      ignore: exclude,
+    });
+    for (const rf of runtimeFiles) {
+      try {
+        await unlink(join(rootDir, rf));
+      } catch {
+        // Already gone
+      }
+    }
+
+    return { filesRestored, injectionsRemoved };
+  }
+
   /**
    * Remove all injections from files listed in the manifest.
    * @param {string} rootDir