e2e-ai 1.2.0 → 1.4.0

package/dist/config/schema.js

@@ -1,7 +1,7 @@
 import {
   E2eAiConfigSchema,
   defineConfig
-} from "../cli-ph82pe4b.js";
+} from "../cli-fgp618yt.js";
 import"../cli-wckvcay0.js";
 export {
   defineConfig,

package/dist/index.js

@@ -2,10 +2,10 @@ import {
   getPackageRoot,
   getProjectRoot,
   loadConfig
-} from "./cli-ba9d3pdp.js";
+} from "./cli-kx32qnf3.js";
 import {
   defineConfig
-} from "./cli-ph82pe4b.js";
+} from "./cli-fgp618yt.js";
 import"./cli-wckvcay0.js";
 export {
   loadConfig,

package/dist/mcp.js

@@ -1,11 +1,10 @@
 #!/usr/bin/env node
 import {
-  loadAgent,
-  scanCodebase
-} from "./cli-g7cc13w2.js";
+  loadAgent
+} from "./cli-98db6h2q.js";
 import {
   getPackageRoot
-} from "./cli-ba9d3pdp.js";
+} from "./cli-kx32qnf3.js";
 import {
   $ZodObject,
   $ZodType,
@@ -38,7 +37,7 @@ import {
   toJSONSchema,
   union,
   unknown
-} from "./cli-ph82pe4b.js";
+} from "./cli-fgp618yt.js";
 import {
   __commonJS,
   __toESM
@@ -14857,8 +14856,72 @@ class StdioServerTransport {
 }
 
 // src/mcp.ts
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
+import { readFileSync as readFileSync2 } from "node:fs";
+import { join as join2 } from "node:path";
+
+// src/utils/scan.ts
+import { readdirSync, existsSync, readFileSync } from "node:fs";
+import { join, relative } from "node:path";
+async function scanCodebase(root) {
+  const scan = {
+    testFiles: [],
+    configFiles: [],
+    fixtureFiles: [],
+    featureFiles: [],
+    tsconfigPaths: {},
+    playwrightConfig: null,
+    sampleTestContent: null
+  };
+  function walk(dir, depth = 0) {
+    if (depth > 5)
+      return [];
+    const files = [];
+    try {
+      for (const entry of readdirSync(dir, { withFileTypes: true })) {
+        if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "dist")
+          continue;
+        const full = join(dir, entry.name);
+        if (entry.isDirectory()) {
+          files.push(...walk(full, depth + 1));
+        } else {
+          files.push(full);
+        }
+      }
+    } catch {}
+    return files;
+  }
+  const allFiles = walk(root);
+  for (const file of allFiles) {
+    const rel = relative(root, file);
+    if (rel.endsWith(".test.ts") || rel.endsWith(".spec.ts")) {
+      scan.testFiles.push(rel);
+      if (!scan.sampleTestContent && scan.testFiles.length <= 3) {
+        try {
+          scan.sampleTestContent = readFileSync(file, "utf-8").slice(0, 3000);
+        } catch {}
+      }
+    }
+    if (rel.endsWith(".feature.ts"))
+      scan.featureFiles.push(rel);
+    if (rel.includes("fixture") && rel.endsWith(".ts"))
+      scan.fixtureFiles.push(rel);
+    if (rel === "playwright.config.ts" || rel === "playwright.config.js")
+      scan.playwrightConfig = rel;
+    if (rel === "tsconfig.json" || rel.endsWith("/tsconfig.json")) {
+      try {
+        const tsconfig = JSON.parse(readFileSync(file, "utf-8"));
+        if (tsconfig.compilerOptions?.paths) {
+          scan.tsconfigPaths = { ...scan.tsconfigPaths, ...tsconfig.compilerOptions.paths };
+        }
+      } catch {}
+    }
+  }
+  for (const name of ["playwright.config.ts", "vitest.config.ts", "jest.config.ts", "tsconfig.json", "package.json"]) {
+    if (existsSync(join(root, name)))
+      scan.configFiles.push(name);
+  }
+  return scan;
+}
 
 // src/utils/validateContext.ts
 var REQUIRED_SECTIONS = [
@@ -14955,8 +15018,8 @@ server.registerTool("e2e_ai_get_example", {
   inputSchema: exports_external.object({})
 }, async () => {
   try {
-    const examplePath = join(getPackageRoot(), "templates", "e2e-ai.context.example.md");
-    const content = readFileSync(examplePath, "utf-8");
+    const examplePath = join2(getPackageRoot(), "templates", "e2e-ai.context.example.md");
+    const content = readFileSync2(examplePath, "utf-8");
     return {
       content: [{ type: "text", text: content }]
     };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "e2e-ai",
   "description": "AI-powered test automation pipeline — record, transcribe, generate, heal and ship Playwright tests from a single CLI",
-  "version": "1.2.0",
+  "version": "1.4.0",
   "private": false,
   "type": "module",
   "bin": {
@@ -34,6 +34,7 @@
     "@modelcontextprotocol/sdk": "^1.27.1",
     "commander": "^13.1.0",
     "dotenv": "^17.2.0",
+    "glob": "^13.0.6",
     "ora": "^9.3.0",
     "picocolors": "^1.1.1",
     "yaml": "^2.7.1",

package/scripts/codegen-env.mjs

@@ -129,8 +129,54 @@ console.error(`Voice recording: ${voiceEnabled ? 'ENABLED' : 'disabled (--no-voi
 console.error(`Trace replay:    ${traceEnabled ? 'ENABLED' : 'disabled (--no-trace)'}`);
 console.error('(When you close the Playwright Inspector, the file is written there.)\n');
 
+// --- Session timing (always track, used for action timestamps) ---
+const sessionStartTime = Date.now();
+
+// --- Action timestamp tracking via file polling ---
+const actionPattern = /^\s*(await\s+page\.|await\s+expect\()/;
+let prevActionCount = 0;
+const actionElapsedSec = []; // elapsed seconds for each action, in order
+let pollInterval = null;
+
+function startActionPolling() {
+  pollInterval = setInterval(() => {
+    if (!existsSync(outputPath)) return;
+    try {
+      const content = readFileSync(outputPath, 'utf-8');
+      const actionLines = content.split('\n').filter((l) => actionPattern.test(l));
+      const newCount = actionLines.length;
+      if (newCount > prevActionCount) {
+        const elapsed = (Date.now() - sessionStartTime) / 1000;
+        for (let i = prevActionCount; i < newCount; i++) {
+          actionElapsedSec.push(elapsed);
+        }
+        prevActionCount = newCount;
+      }
+    } catch {
+      // File might be mid-write — ignore
+    }
+  }, 500);
+}
+
+/** Inject // @t:<seconds>s comments above each action line in the codegen file. */
+function injectActionTimestamps(filePath) {
+  if (actionElapsedSec.length === 0) return;
+  const content = readFileSync(filePath, 'utf-8');
+  const lines = content.split('\n');
+  const result = [];
+  let idx = 0;
+  for (const line of lines) {
+    if (actionPattern.test(line) && idx < actionElapsedSec.length) {
+      const indent = line.match(/^(\s*)/)[1];
+      result.push(`${indent}// @t:${actionElapsedSec[idx].toFixed(1)}s`);
+      idx++;
+    }
+    result.push(line);
+  }
+  writeFileSync(filePath, result.join('\n'));
+}
+
 // --- Voice setup ---
-let sessionStartTime = null;
 let recording = false;
 let currentRecProcess = null;
 let segmentIndex = 0;
@@ -147,8 +193,6 @@ if (voiceEnabled) {
     mkdirSync(recordingsDir, { recursive: true });
   }
 
-  sessionStartTime = Date.now();
-
   const segPath = resolve(recordingsDir, `seg-${String(segmentIndex).padStart(3, '0')}.wav`);
   segmentPaths.push(segPath);
   const rec = startRecording(segPath);
@@ -195,6 +239,9 @@ const child = spawn('npx', codegenArgs, {
   shell: true,
 });
 
+// Start polling the output file for new actions to capture timestamps
+startActionPolling();
+
 // --- Keyboard listener for pause/resume ---
 if (voiceEnabled && process.stdin.isTTY) {
   process.stdin.setRawMode(true);
@@ -238,16 +285,20 @@ function cleanupTerminal() {
 
 child.on('exit', async (code) => {
   cleanupTerminal();
+  if (pollInterval) clearInterval(pollInterval);
 
   if (code === 0) {
     console.error(`\nSaved: ${outputRelative}`);
   }
 
-  // --- Voice post-processing ---
-  if (voiceEnabled && segmentPaths.length > 0) {
-    const sessionEndTime = Date.now();
-    const durationSec = (sessionEndTime - sessionStartTime) / 1000;
+  // --- Inject action timestamps into codegen output ---
+  if (existsSync(outputPath) && actionElapsedSec.length > 0) {
+    injectActionTimestamps(outputPath);
+    console.error(`Injected ${actionElapsedSec.length} action timestamp(s) into: ${outputRelative}`);
+  }
 
+  // --- Voice post-processing: merge WAV segments only (transcription deferred to transcribe command) ---
+  if (voiceEnabled && segmentPaths.length > 0) {
     try {
       if (recording && currentRecProcess) {
         const { stopRecording } = await import(resolve(__dirname, 'voice', 'recorder.mjs'));
@@ -260,45 +311,26 @@ child.on('exit', async (code) => {
 
       if (existingSegments.length === 0) {
         console.error('No audio segments recorded.');
-        process.exit(code ?? 0);
-        return;
-      }
-
-      const mergedWavPath = resolve(recordingsDir, `voice-${timestamp}.wav`);
-
-      if (existingSegments.length === 1) {
-        renameSync(existingSegments[0], mergedWavPath);
       } else {
-        console.error(`Merging ${existingSegments.length} audio segments...`);
-        const args = ['--combine', 'concatenate', ...existingSegments, mergedWavPath];
-        execSync(`sox ${args.map((a) => `"${a}"`).join(' ')}`, { stdio: 'ignore' });
-
-        for (const seg of existingSegments) {
-          try { unlinkSync(seg); } catch {}
+        const mergedWavPath = resolve(recordingsDir, `voice-${timestamp}.wav`);
+
+        if (existingSegments.length === 1) {
+          renameSync(existingSegments[0], mergedWavPath);
+        } else {
+          console.error(`Merging ${existingSegments.length} audio segments...`);
+          const args = ['--combine', 'concatenate', ...existingSegments, mergedWavPath];
+          execSync(`sox ${args.map((a) => `"${a}"`).join(' ')}`, { stdio: 'ignore' });
+
+          for (const seg of existingSegments) {
+            try { unlinkSync(seg); } catch {}
+          }
         }
-      }
-
-      console.error(`Audio saved: ${relative(root, mergedWavPath)}`);
 
-      const { transcribe } = await import(resolve(__dirname, 'voice', 'transcriber.mjs'));
-      const segments = await transcribe(mergedWavPath);
-
-      const transcriptPath = resolve(recordingsDir, `voice-${timestamp}.json`);
-      writeFileSync(transcriptPath, JSON.stringify(segments, null, 2));
-      console.error(`Transcript saved: ${relative(root, transcriptPath)}`);
-
-      if (segments.length > 0 && existsSync(outputPath)) {
-        const { merge } = await import(resolve(__dirname, 'voice', 'merger.mjs'));
-        const codegenContent = readFileSync(outputPath, 'utf-8');
-        const annotated = merge(codegenContent, segments, durationSec);
-        writeFileSync(outputPath, annotated);
-        console.error(`Merged ${segments.length} voice segment(s) into: ${outputRelative}`);
+        console.error(`\nVoice recording summary:`);
+        console.error(`  Audio:   ${relative(root, mergedWavPath)}`);
+        console.error(`  Codegen: ${outputRelative}`);
+        console.error(`  (Run 'transcribe' to process voice → merge into codegen)`);
       }
-
-      console.error('\nVoice recording summary:');
-      console.error(`  Audio:      ${relative(root, mergedWavPath)}`);
-      console.error(`  Transcript: ${relative(root, transcriptPath)}`);
-      console.error(`  Codegen:    ${outputRelative}`);
     } catch (err) {
       console.error(`\nVoice processing error: ${err.message}`);
     }

package/scripts/voice/merger.mjs

@@ -9,16 +9,42 @@ function formatTime(sec) {
   return `${String(m).padStart(2, '0')}:${String(s).padStart(2, '0')}`;
 }
 
+/**
+ * Extract real action timestamps from // @t:<seconds>s comments injected during codegen.
+ * Returns an array of { lineIndex, elapsed } or null if no timestamps found.
+ *
+ * @param {string[]} lines
+ * @param {number[]} actionIndices - line indices of action lines
+ * @returns {number[] | null} elapsed seconds per action, or null
+ */
+function extractEmbeddedTimestamps(lines, actionIndices) {
+  const tsPattern = /^\s*\/\/\s*@t:([\d.]+)s\s*$/;
+  const timestamps = [];
+
+  for (const actionIdx of actionIndices) {
+    // Look at the line immediately before the action for a @t: comment
+    if (actionIdx > 0 && tsPattern.test(lines[actionIdx - 1])) {
+      const match = lines[actionIdx - 1].match(tsPattern);
+      timestamps.push(parseFloat(match[1]));
+    } else {
+      // Missing timestamp for this action — can't use embedded timestamps
+      return null;
+    }
+  }
+
+  return timestamps;
+}
+
 /**
  * Merge codegen output with voice transcript segments.
  *
- * Action lines (await page.* / await expect(*) are identified and distributed
- * linearly across the session duration. Each speech segment is inserted as a
- * comment before the nearest action line.
+ * If the codegen contains // @t:<seconds>s comments (injected during recording),
+ * those real timestamps are used for alignment. Otherwise, action timestamps are
+ * distributed linearly across the session duration (fallback).
  *
  * @param {string} codegenContent - The original codegen .ts file content
  * @param {Array<{ start: number, end: number, text: string }>} segments - Whisper transcript segments
- * @param {number} durationSec - Total session duration in seconds
+ * @param {number} durationSec - Total session duration in seconds (used only for linear fallback)
  * @returns {string} Annotated codegen content
  */
 export function merge(codegenContent, segments, durationSec) {
@@ -26,8 +52,9 @@ export function merge(codegenContent, segments, durationSec) {
 
   const lines = codegenContent.split('\n');
   const actionPattern = /^\s*(await\s+page\.|await\s+expect\()/;
+  const tsCommentPattern = /^\s*\/\/\s*@t:[\d.]+s\s*$/;
 
-  // Find indices of action lines
+  // Find indices of action lines (skip @t: comment lines)
   const actionIndices = [];
   for (let i = 0; i < lines.length; i++) {
     if (actionPattern.test(lines[i])) {
@@ -37,14 +64,16 @@ export function merge(codegenContent, segments, durationSec) {
 
   if (actionIndices.length === 0) return codegenContent;
 
-  // Estimate timestamp for each action: distribute linearly across the session
-  const actionTimestamps = actionIndices.map((_, idx) => {
-    if (actionIndices.length === 1) return durationSec / 2;
-    return (idx / (actionIndices.length - 1)) * durationSec;
-  });
+  // Try to use embedded timestamps, fall back to linear distribution
+  const embeddedTs = extractEmbeddedTimestamps(lines, actionIndices);
+  const actionTimestamps = embeddedTs
+    ? embeddedTs
+    : actionIndices.map((_, idx) => {
+        if (actionIndices.length === 1) return durationSec / 2;
+        return (idx / (actionIndices.length - 1)) * durationSec;
+      });
 
   // For each segment, find the nearest action by timestamp
-  // Map: actionIndex → list of segments to insert before it
   /** @type {Map<number, Array<{ start: number, end: number, text: string }>>} */
   const insertions = new Map();
 
@@ -68,12 +97,14 @@ export function merge(codegenContent, segments, durationSec) {
     insertions.get(actionLineIdx).push(seg);
   }
 
-  // Build result: insert comment lines before action lines
+  // Build result: strip old @t: comments and insert voice comments before action lines
   const result = [];
   for (let i = 0; i < lines.length; i++) {
+    // Skip @t: timestamp comments — they're consumed, not preserved
+    if (tsCommentPattern.test(lines[i])) continue;
+
     const segs = insertions.get(i);
     if (segs) {
-      // Detect indentation of the action line
       const indent = lines[i].match(/^(\s*)/)[1];
       for (const seg of segs) {
         result.push(