@runa-ai/runa-cli 0.5.71 → 0.6.0

package/dist/chunk-P7U52PBY.js

@@ -0,0 +1,1149 @@
+#!/usr/bin/env node
+import { createRequire } from 'module';
+import { isPathContained } from './chunk-DRSUEMAK.js';
+import { emitJsonSuccess } from './chunk-UU55OH7P.js';
+import { init_esm_shims, __dirname as __dirname$1 } from './chunk-VRXHCR5K.js';
+import * as fs2 from 'fs';
+import * as path3 from 'path';
+import { clearInjectionRegistry, clearUnifiedRegistry, postProcessRegistries, isPageFile, isLayoutFile, isApiRouteFile, isMiddlewareFile, collectPageInfo, collectLayoutInfo, collectApiRouteInfo, collectAuthBoundaries, hasMachineDefinition, collectMachineDefinition, collectComponentInfo, createReadAndParseFile, createResolveImportPath, transformSync, getInjectionRegistry, buildManifest, getAllMachineDefinitions, generateSelectorTypeScript, getUnifiedRegistry, buildMachineLinks, registerInjection } from '@runa-ai/runa-xstate-test-plugin/standalone';
+import { glob } from 'glob';
+import { execa } from 'execa';
+import { HonoRouteAnalyzer } from '@runa-ai/runa/test-generators';
+import { createCLILogger, CLIError, findProjectRoot } from '@runa-ai/runa';
+import { z } from 'zod';
+
+createRequire(import.meta.url);
+
+// src/commands/inject-test-attrs/processor.ts
+init_esm_shims();
+
+// src/commands/inject-test-attrs/detection-diagnostics.ts
+init_esm_shims();
+var MAX_EXAMPLES = 20;
+function normalizeMachineId(id) {
+  return id.replace(/-([a-z])/g, (_, char) => char.toUpperCase()).replace(/Machine$/i, "").toLowerCase();
+}
+function buildDetectionDiagnostics(params) {
+  const bySource = {
+    explicit: 0,
+    import: 0,
+    inline: 0,
+    fallback: 0
+  };
+  const fallbackExamples = [];
+  for (const detail of params.resolutionDetails) {
+    bySource[detail.source] += 1;
+    if (detail.source === "fallback" && fallbackExamples.length < MAX_EXAMPLES) {
+      fallbackExamples.push(detail);
+    }
+  }
+  const linkedMachineIds = new Set(
+    params.machineLinks.filter((link) => link.usedIn.length > 0).map((link) => normalizeMachineId(link.machineName))
+  );
+  const linkedManifestMachineIds = [];
+  const unlinkedManifestMachineIds = [];
+  for (const machineId of params.manifestMachineIds) {
+    if (linkedMachineIds.has(normalizeMachineId(machineId))) {
+      linkedManifestMachineIds.push(machineId);
+      continue;
+    }
+    unlinkedManifestMachineIds.push(machineId);
+  }
+  const totalMachineUsages = params.resolutionDetails.length;
+  const fallbackRate = totalMachineUsages > 0 ? bySource.fallback / totalMachineUsages : 0;
+  const totalManifestMachines = params.manifestMachineIds.length;
+  const linkedManifestMachines = linkedManifestMachineIds.length;
+  const machineLinkCoverage = totalManifestMachines > 0 ? linkedManifestMachines / totalManifestMachines : 1;
+  return {
+    schemaVersion: 1,
+    scan: params.scanSummary,
+    resolution: {
+      totalMachineUsages,
+      bySource,
+      fallbackRate,
+      fallbackExamples
+    },
+    coverage: {
+      totalManifestMachines,
+      linkedManifestMachines,
+      unlinkedManifestMachines: totalManifestMachines - linkedManifestMachines,
+      machineLinkCoverage,
+      unlinkedManifestMachineIds: unlinkedManifestMachineIds.slice(0, MAX_EXAMPLES)
+    },
+    warnings: params.warnings
+  };
+}
+function evaluateStrictDetect(diagnostics) {
+  const reasons = [];
+  const fallbackCount = diagnostics.resolution.bySource.fallback;
+  if (fallbackCount > 0) {
+    reasons.push(`fallback machine resolution detected (${fallbackCount})`);
+  }
+  if (diagnostics.scan.filesWithMachineHooks > 0 && diagnostics.resolution.totalMachineUsages === 0) {
+    reasons.push(
+      `machine hooks were detected in ${diagnostics.scan.filesWithMachineHooks} files, but no machine usages were resolved`
+    );
+  }
+  if (diagnostics.resolution.totalMachineUsages > 0 && diagnostics.coverage.totalManifestMachines > 0 && diagnostics.coverage.linkedManifestMachines === 0) {
+    reasons.push("machine usages were detected, but no machines were linked to routes/pages");
+  }
+  return {
+    enabled: true,
+    passed: reasons.length === 0,
+    reasons
+  };
+}
+
+// src/commands/inject-test-attrs/formatter.ts
+init_esm_shims();
+async function formatFilesWithBiome(files, cwd) {
+  if (files.length === 0) return;
+  const relativePaths = files.map((f) => path3.relative(cwd, f));
+  try {
+    await execa("pnpm", ["exec", "biome", "format", "--write", ...relativePaths], {
+      cwd,
+      stdio: "pipe"
+    });
+  } catch {
+  }
+}
+
+// src/commands/inject-test-attrs/manifest-generator.ts
+init_esm_shims();
+
+// src/commands/inject-test-attrs/processor-utils.ts
+init_esm_shims();
+var CLI_INJECTION_MARKER = "@xstate-test-attrs-injected";
+var EXCLUDED_SCOPES = [
+  "packages/runa-templates/",
+  // runa-repo: Template files
+  "packages/sdk/",
+  // runa-repo: SDK internal machines
+  "packages/runa-xstate-test-plugin/",
+  // runa-repo: Plugin internals
+  "node_modules/",
+  // All: Dependencies
+  ".next/",
+  // Next.js: Build artifacts
+  "dist/"
+  // All: Build output
+];
+function isExcludedScope(filePath) {
+  return EXCLUDED_SCOPES.some((scope) => filePath.includes(scope));
+}
+var ATTRIBUTE_PATTERNS = {
+  /** Pattern to match data-action attribute */
+  action: /data-action="([^"]+)"/g,
+  /** Pattern to match data-field attribute */
+  field: /data-field="([^"]+)"/g,
+  /** Pattern to match data-testid attribute */
+  testId: /data-testid="([^"]+)"/g};
+function mightContainMachineHooks(code) {
+  return code.includes("useMachine") || code.includes("useActor") || code.includes("useMachineWithUI");
+}
+function mightContainJsx(code) {
+  return /<[A-Za-z]/.test(code);
+}
+function stripInjectedAttributes(code) {
+  return code.replace(/\/\*\s*@xstate-test-attrs-injected\s*\*\/\n?/g, "").replace(/\s*data-machine-id="[^"]*"/g, "").replace(/\s*data-state=\{[^}]+\}/g, "").replace(/\s*data-state="[^"]*"/g, "").replace(/\s*data-testid="[^"]*-container"/g, "").replace(/\s*data-testid="[^"]*-button"/g, "").replace(/\s*data-action="[^"]*"/g, "").replace(/\s*data-field="[^"]*"/g, "");
+}
+function extractAttributeValues(code, pattern) {
+  const freshPattern = new RegExp(pattern.source, pattern.flags);
+  const values = [];
+  for (const match of code.matchAll(freshPattern)) {
+    if (match[1]) values.push(match[1]);
+  }
+  return [...new Set(values)];
+}
+function extractInjectedAttributes(code) {
+  return {
+    actions: extractAttributeValues(code, ATTRIBUTE_PATTERNS.action),
+    fields: extractAttributeValues(code, ATTRIBUTE_PATTERNS.field),
+    testIds: extractAttributeValues(code, ATTRIBUTE_PATTERNS.testId)
+  };
+}
+function collectRouteInfo(relativePath, code, _verbose) {
+  if (isExcludedScope(relativePath)) {
+    return;
+  }
+  const isPage = isPageFile(relativePath);
+  const isLayout = isLayoutFile(relativePath);
+  const isApiRoute = isApiRouteFile(relativePath);
+  const isMiddleware = isMiddlewareFile(relativePath);
+  if (isPage) {
+    collectPageInfo(relativePath, code);
+  }
+  if (isLayout) {
+    collectLayoutInfo(relativePath, code);
+  }
+  if (isApiRoute) {
+    collectApiRouteInfo(relativePath, code);
+  }
+  if (isMiddleware) {
+    collectAuthBoundaries(relativePath, code);
+  }
+  if (hasMachineDefinition(code)) {
+    collectMachineDefinition(relativePath, code);
+  }
+  if (!isPage && !isLayout && !isApiRoute && !isMiddleware) {
+    collectComponentInfo(relativePath, code);
+  }
+}
+function emptyResult(filePath) {
+  return {
+    filePath,
+    injectedCount: 0,
+    machineIds: [],
+    changed: false,
+    actions: [],
+    fields: [],
+    testIds: [],
+    resolutionDetails: []
+  };
+}
+function ensureDirectoryExists(dirPath) {
+  if (!fs2.existsSync(dirPath)) {
+    fs2.mkdirSync(dirPath, { recursive: true });
+  }
+}
+function getGeneratorVersion() {
+  try {
+    const pkgPath = path3.resolve(__dirname$1, "../../../package.json");
+    if (fs2.existsSync(pkgPath)) {
+      const pkg = JSON.parse(fs2.readFileSync(pkgPath, "utf-8"));
+      return pkg.version ?? "unknown";
+    }
+  } catch {
+  }
+  return "unknown";
+}
+
+// src/commands/inject-test-attrs/manifest-generator.ts
+function detectPlatform(repoRoot) {
+  const nextConfigPatterns = ["next.config.ts", "next.config.js", "next.config.mjs"];
+  for (const pattern of nextConfigPatterns) {
+    const paths = [
+      path3.join(repoRoot, pattern),
+      path3.join(repoRoot, "apps", "web", pattern),
+      path3.join(repoRoot, "apps", "dashboard", pattern)
+    ];
+    if (paths.some((p) => fs2.existsSync(p))) {
+      return "nextjs";
+    }
+  }
+  const appJsonPath = path3.join(repoRoot, "app.json");
+  if (fs2.existsSync(appJsonPath)) {
+    try {
+      const appJson = JSON.parse(fs2.readFileSync(appJsonPath, "utf-8"));
+      if (appJson.expo) {
+        return "expo";
+      }
+    } catch {
+    }
+  }
+  if (fs2.existsSync(path3.join(repoRoot, "expo.json"))) {
+    return "expo";
+  }
+  const electronPatterns = [
+    "electron-builder.json",
+    "electron-builder.yml",
+    "electron.vite.config.ts",
+    "electron.vite.config.js"
+  ];
+  if (electronPatterns.some((p) => fs2.existsSync(path3.join(repoRoot, p)))) {
+    return "electron";
+  }
+  return "unknown";
+}
+function hasHonoRouteFiles(dir) {
+  try {
+    const files = fs2.readdirSync(dir);
+    return files.some(
+      (file) => file.endsWith(".ts") && !file.endsWith(".test.ts") && !file.endsWith(".spec.ts")
+    );
+  } catch {
+    return false;
+  }
+}
+function collectRouteDirsInScope(repoRoot, scope) {
+  const scopeDir = path3.join(repoRoot, scope);
+  if (!fs2.existsSync(scopeDir)) {
+    return [];
+  }
+  try {
+    const entries = fs2.readdirSync(scopeDir, { withFileTypes: true });
+    return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name).filter((entryName) => hasHonoRouteFiles(path3.join(scopeDir, entryName, "routes"))).map((entryName) => `${scope}/${entryName}/routes`);
+  } catch {
+    return [];
+  }
+}
+function findPossibleHonoDirs(repoRoot) {
+  return [
+    ...collectRouteDirsInScope(repoRoot, "apps"),
+    ...collectRouteDirsInScope(repoRoot, "packages")
+  ];
+}
+function collectManifestWarnings(repoRoot, platform, apiContracts, machinesWithoutE2EMeta, totalMachines) {
+  const warnings = [];
+  if (apiContracts.length === 0) {
+    const possibleDirs = findPossibleHonoDirs(repoRoot);
+    if (possibleDirs.length > 0) {
+      warnings.push({
+        severity: "warning",
+        message: "Potential Hono routes detected but not analyzed",
+        details: possibleDirs.map((d) => `  - ${d}`),
+        fix: "Add to runa.config.ts: testing.layer3.routesPath"
+      });
+    }
+  }
+  if (platform === "unknown") {
+    warnings.push({
+      severity: "info",
+      message: "Platform could not be detected (next.config.*, app.json, electron-builder.*)",
+      fix: "This is usually fine for non-frontend projects"
+    });
+  }
+  if (totalMachines > 0 && machinesWithoutE2EMeta.length > 0) {
+    const percentage = Math.round(machinesWithoutE2EMeta.length / totalMachines * 100);
+    if (percentage >= 50) {
+      warnings.push({
+        severity: "warning",
+        message: `${machinesWithoutE2EMeta.length}/${totalMachines} machines (${percentage}%) missing meta.e2e`,
+        details: machinesWithoutE2EMeta.slice(0, 5).map((m) => `  - ${m.id} (${m.sourceFile})`),
+        fix: "Add meta.e2e to machine states for E2E test generation"
+      });
+    } else if (machinesWithoutE2EMeta.length > 0) {
+      warnings.push({
+        severity: "hint",
+        message: `${machinesWithoutE2EMeta.length} machines missing meta.e2e (E2E tests may be incomplete)`
+      });
+    }
+  }
+  return warnings;
+}
+function printManifestWarnings(warnings, verbose) {
+  const warningsToShow = verbose ? warnings : warnings.filter((w) => w.severity === "warning" || w.severity === "info");
+  if (warningsToShow.length === 0) return;
+  console.log("");
+  for (const warning of warningsToShow) {
+    const icon = warning.severity === "warning" ? "\u26A0\uFE0F" : warning.severity === "info" ? "\u2139\uFE0F" : "\u{1F4A1}";
+    console.log(`${icon}  ${warning.message}`);
+    if (warning.details) {
+      for (const detail of warning.details) {
+        console.log(detail);
+      }
+    }
+    if (warning.fix) {
+      console.log(`   \u2192 ${warning.fix}`);
+    }
+  }
+}
+function toDetectionWarnings(warnings) {
+  return warnings.map((warning) => ({
+    severity: warning.severity,
+    message: warning.message
+  }));
+}
+function normalizeToCanonicalId(id) {
+  return id.replace(/-([a-z])/g, (_, c) => c.toUpperCase()).replace(/Machine$/i, "");
+}
+function buildDefinitionMap(definitions) {
+  const map = /* @__PURE__ */ new Map();
+  for (const def of definitions) {
+    if (def.id) {
+      map.set(def.id, def);
+      const normalizedName = normalizeToCanonicalId(def.id).toLowerCase();
+      map.set(normalizedName, def);
+    }
+  }
+  return map;
+}
+function buildEnhancedMachines(e2eManifest, definitionMap, machineDefinitions) {
+  const enhanced = {};
+  const normalizedIdToCanonical = /* @__PURE__ */ new Map();
+  const isMachineFile = (path5) => path5.includes("machine.ts") || path5.includes("machines/") || path5.includes(".machine.ts") || path5.includes("/machine/");
+  const addMachine = (id, sourceFile, entryBuilder) => {
+    const normalizedId = normalizeToCanonicalId(id).toLowerCase();
+    const existingCanonical = normalizedIdToCanonical.get(normalizedId);
+    if (existingCanonical) {
+      const existingEntry = enhanced[existingCanonical];
+      const existingSourceFile = existingEntry?.sourceFile ?? "";
+      const newIsMachineFile = isMachineFile(sourceFile);
+      const existingIsMachineFile = isMachineFile(existingSourceFile);
+      if (newIsMachineFile && !existingIsMachineFile) {
+        delete enhanced[existingCanonical];
+        normalizedIdToCanonical.set(normalizedId, id);
+        enhanced[id] = entryBuilder();
+      }
+      return;
+    }
+    normalizedIdToCanonical.set(normalizedId, id);
+    enhanced[id] = entryBuilder();
+  };
+  for (const [machineId, entry] of Object.entries(e2eManifest.machines)) {
+    const entryWithSource = entry;
+    const sourceFile = entryWithSource.sourceFile ?? "";
+    if (isExcludedScope(sourceFile)) {
+      continue;
+    }
+    const normalizedKey = normalizeToCanonicalId(machineId).toLowerCase();
+    const definition = definitionMap.get(machineId) ?? definitionMap.get(normalizedKey);
+    addMachine(machineId, sourceFile, () => ({
+      ...entry,
+      states: definition?.states ?? [],
+      events: definition?.events ?? [],
+      actors: definition?.actors ?? [],
+      guards: definition?.guards ?? [],
+      hasE2EMeta: definition?.hasE2EMeta ?? false,
+      brIds: definition?.brIds ?? []
+    }));
+  }
+  for (const def of machineDefinitions) {
+    if (!def.id) continue;
+    addMachine(def.id, def.sourceFile, () => ({
+      id: def.id,
+      sourceFile: def.sourceFile,
+      container: `[data-machine-id="${def.id}"]`,
+      stateSelector: `[data-machine-id="${def.id}"][data-state="\${state}"]`,
+      actions: [],
+      fields: [],
+      testIds: [],
+      isPage: false,
+      derivedRoute: null,
+      dynamicParams: [],
+      states: def.states,
+      events: def.events,
+      actors: def.actors,
+      guards: def.guards,
+      hasE2EMeta: def.hasE2EMeta,
+      brIds: def.brIds
+    }));
+  }
+  return enhanced;
+}
+async function analyzeHonoRoutes(repoRoot, verbose, resolveSchemas = false) {
+  try {
+    const routesPath = await HonoRouteAnalyzer.discoverRoutesPath(repoRoot);
+    if (!routesPath) {
+      if (verbose) {
+        console.log("  No Hono routes directory found, skipping API contract analysis");
+      }
+      return { apiContracts: [], schemasResolved: false };
+    }
+    if (verbose) {
+      console.log(`  Analyzing Hono routes in: ${path3.relative(repoRoot, routesPath)}`);
+      if (resolveSchemas) {
+        console.log("  Schema resolution enabled (--resolve-schemas)");
+      }
+    }
+    const analyzer = new HonoRouteAnalyzer(routesPath);
+    const result = resolveSchemas ? await analyzer.analyzeWithSchemas(repoRoot) : await analyzer.analyze();
+    const apiContracts = result.routes.map((route) => {
+      const contract = {
+        path: route.path,
+        method: route.method,
+        inputSchemaName: route.inputSchemaName,
+        statusCodes: route.statusCodes,
+        sourceFile: route.fileName,
+        resourceName: route.resourceName,
+        hasParams: route.hasParams,
+        params: route.params,
+        // v8+: Include export info for correct import generation
+        exportType: route.exportType,
+        exportName: route.exportName
+      };
+      if (resolveSchemas && "inputSchema" in route && route.inputSchema) {
+        contract.inputSchema = route.inputSchema;
+      }
+      return contract;
+    });
+    const schemasResolved = resolveSchemas && apiContracts.some(
+      (c) => "inputSchema" in c && c.inputSchema
+    );
+    if (verbose) {
+      console.log(`  Found ${apiContracts.length} API contracts`);
+      if (resolveSchemas) {
+        const resolvedCount = apiContracts.filter(
+          (c) => "inputSchema" in c && c.inputSchema
+        ).length;
+        console.log(`  Resolved schemas: ${resolvedCount}/${apiContracts.length}`);
+      }
+    }
+    return { apiContracts, schemasResolved };
+  } catch (error) {
+    if (verbose) {
+      console.error("  Error analyzing Hono routes:", error);
+    }
+    return { apiContracts: [], schemasResolved: false };
+  }
+}
+async function generateManifestFiles(manifestDir, repoRoot, verbose, resolveSchemas = false, diagnosticsInput) {
+  const registry = getInjectionRegistry();
+  const generatorVersion = getGeneratorVersion();
+  const e2eManifest = buildManifest(registry, generatorVersion);
+  const allMachineDefinitions = getAllMachineDefinitions();
+  const machineDefinitions = allMachineDefinitions.filter(
+    (def) => !isExcludedScope(def.sourceFile)
+  );
+  if (verbose && allMachineDefinitions.length !== machineDefinitions.length) {
+    const excludedCount = allMachineDefinitions.length - machineDefinitions.length;
+    console.log(`  Excluded ${excludedCount} machines from templates/SDK`);
+  }
+  const definitionMap = buildDefinitionMap(machineDefinitions);
+  const enhancedMachines = buildEnhancedMachines(e2eManifest, definitionMap, machineDefinitions);
+  const absoluteManifestDir = path3.isAbsolute(manifestDir) ? manifestDir : path3.join(repoRoot, manifestDir);
+  if (!isPathContained(repoRoot, absoluteManifestDir)) {
+    throw new Error(
+      `Security error: Manifest directory '${manifestDir}' would escape the project root. The --manifest-dir must be a relative path within the project directory.`
+    );
+  }
+  ensureDirectoryExists(absoluteManifestDir);
+  const generatedDir = path3.join(absoluteManifestDir, "generated");
+  ensureDirectoryExists(generatedDir);
+  const manifestsDir = path3.join(absoluteManifestDir, "manifests");
+  ensureDirectoryExists(manifestsDir);
+  const tsPath = path3.join(generatedDir, "selectors.ts");
+  await fs2.promises.writeFile(tsPath, generateSelectorTypeScript(e2eManifest), "utf-8");
+  const unifiedRegistry = getUnifiedRegistry();
+  const machineLinks = buildMachineLinks();
+  const { apiContracts, schemasResolved } = await analyzeHonoRoutes(
+    repoRoot,
+    verbose,
+    resolveSchemas
+  );
+  const manifestVersion = schemasResolved ? 7 : 4;
+  const platform = detectPlatform(repoRoot);
+  const now = /* @__PURE__ */ new Date();
+  const jstOffset = 9 * 60 * 60 * 1e3;
+  const jst = new Date(now.getTime() + jstOffset);
+  const generatedAtJST = `${jst.getUTCFullYear()}-${String(jst.getUTCMonth() + 1).padStart(2, "0")}-${String(jst.getUTCDate()).padStart(2, "0")}T${String(jst.getUTCHours()).padStart(2, "0")}:${String(jst.getUTCMinutes()).padStart(2, "0")}:${String(jst.getUTCSeconds()).padStart(2, "0")}+09:00`;
+  const machinesWithoutE2EMeta = machineDefinitions.filter(
+    (def) => !def.hasE2EMeta && typeof def.id === "string"
+  ).map((def) => ({ id: def.id, sourceFile: def.sourceFile }));
+  const warnings = collectManifestWarnings(
+    repoRoot,
+    platform,
+    apiContracts,
+    machinesWithoutE2EMeta,
+    machineDefinitions.length
+  );
+  printManifestWarnings(warnings, verbose);
+  const detectionDiagnostics = buildDetectionDiagnostics({
+    scanSummary: diagnosticsInput?.scanSummary ?? {
+      totalFiles: 0,
+      filesWithMachineDefinitions: 0,
+      filesWithMachineHooks: 0,
+      filesWithJsxOnly: 0
+    },
+    resolutionDetails: diagnosticsInput?.resolutionDetails ?? [],
+    manifestMachineIds: Object.keys(enhancedMachines),
+    machineLinks,
+    warnings: toDetectionWarnings(warnings)
+  });
+  const unifiedManifest = {
+    version: manifestVersion,
+    generatedAt: generatedAtJST,
+    generatorVersion,
+    platform,
+    machines: enhancedMachines,
+    routes: unifiedRegistry.pages,
+    layouts: unifiedRegistry.layouts,
+    apiRoutes: unifiedRegistry.apiRoutes,
+    authBoundaries: unifiedRegistry.authBoundaries,
+    machineDefinitions: unifiedRegistry.machineDefinitions,
+    machineLinks,
+    apiContracts,
+    detectionDiagnostics
+  };
+  const manifestPath = path3.join(manifestsDir, "manifest.json");
+  await fs2.promises.writeFile(manifestPath, JSON.stringify(unifiedManifest, null, 2), "utf-8");
+  if (verbose) {
+    console.log(`Generated selectors: ${path3.relative(repoRoot, tsPath)}`);
+    console.log(
+      `Generated manifest: ${path3.relative(repoRoot, manifestPath)} (v${manifestVersion})`
+    );
+    console.log(`  Platform: ${platform}`);
+    console.log(`  Machine definitions: ${machineDefinitions.length}`);
+    console.log(
+      `  Routes: ${unifiedRegistry.pages.length} pages, ${unifiedRegistry.layouts.length} layouts`
+    );
+    console.log(
+      `  API: ${unifiedRegistry.apiRoutes.length} routes, ${unifiedRegistry.authBoundaries.length} auth`
+    );
+    console.log(
+      `  API contracts: ${apiContracts.length}${schemasResolved ? " (with schemas)" : ""}`
+    );
+    console.log(`  Machine links: ${machineLinks.length}`);
+    console.log(
+      `  Detection: fallback=${detectionDiagnostics.resolution.bySource.fallback}, linkCoverage=${(detectionDiagnostics.coverage.machineLinkCoverage * 100).toFixed(1)}%`
+    );
+  }
+  return {
+    manifestPath: path3.relative(repoRoot, tsPath),
+    machineCount: Object.keys(enhancedMachines).length,
+    machinesWithoutE2EMeta,
+    detectionDiagnostics
+  };
+}
+
+// src/commands/inject-test-attrs/processor.ts
+async function discoverFiles(repoRoot, include, exclude) {
+  const allFiles = [];
+  for (const pattern of include) {
+    const files = await glob(pattern, {
+      cwd: repoRoot,
+      absolute: true,
+      ignore: exclude
+    });
+    allFiles.push(...files);
+  }
+  return [...new Set(allFiles)];
+}
+function registerExistingInjections(machineIds, attrs, sourceFile) {
+  for (const machineId of machineIds) {
+    for (const action of attrs.actions) {
+      registerInjection({ machineId, sourceFile, type: "action", value: action });
+    }
+    for (const field of attrs.fields) {
+      registerInjection({ machineId, sourceFile, type: "field", value: field });
+    }
+    for (const testId of attrs.testIds) {
+      registerInjection({ machineId, sourceFile, type: "testid", value: testId });
+    }
+  }
+}
+async function preprocessFile(filePath, repoRoot, options) {
+  let code = await fs2.promises.readFile(filePath, "utf-8");
+  const relativePath = path3.relative(repoRoot, filePath);
+  collectRouteInfo(relativePath, code, options.verbose);
+  const hasMarker = code.includes(CLI_INJECTION_MARKER);
+  if (hasMarker && options.force) {
+    code = stripInjectedAttributes(code);
+    if (options.verbose) {
+      console.log(`  [force] Stripping existing attributes from ${relativePath}`);
+    }
+    return { code, hasMarker: true, skipped: false };
+  }
+  if (hasMarker) {
+    const attrs = extractInjectedAttributes(code);
+    const machineIdMatches = code.matchAll(/data-machine-id="([^"]+)"/g);
+    const machineIds = [...new Set([...machineIdMatches].map((m) => m[1]).filter(Boolean))];
+    const resolutionDetails = machineIds.map((machineId) => ({
+      filePath: relativePath,
+      machineRef: machineId,
+      resolvedId: machineId,
+      source: "explicit"
+    }));
+    if (machineIds.length === 0 && mightContainMachineHooks(code)) {
+      if (options.verbose) {
+        console.log(`  [recovery] Marker found but no attributes in ${relativePath}, re-injecting`);
+      }
+      code = stripInjectedAttributes(code);
+      return { code, hasMarker: true, skipped: false };
+    }
+    registerExistingInjections(machineIds, attrs, relativePath);
+    return {
+      code,
+      hasMarker: true,
+      skipped: true,
+      skipResult: {
+        filePath,
+        injectedCount: 0,
+        machineIds,
+        changed: false,
+        ...attrs,
+        resolutionDetails
+      }
+    };
+  }
+  return { code, hasMarker: false, skipped: false };
+}
+function transformAndRegister(filePath, code, repoRoot, options) {
+  const relativePath = path3.relative(repoRoot, filePath);
+  const readAndParseFile = createReadAndParseFile(options.verbose);
+  const resolveImportPath = createResolveImportPath();
+  try {
+    const result = transformSync(code, {
+      filePath,
+      debug: options.verbose,
+      readAndParseFile,
+      resolveImportPath
+    });
+    if (!result || result.injectedCount === 0) return emptyResult(filePath);
+    const markerComment = `/* ${CLI_INJECTION_MARKER} */
+`;
+    const transformedCode = markerComment + result.code;
+    const { actions, fields, testIds } = extractInjectedAttributes(transformedCode);
+    const machineIds = [...result.resolvedIds.values()];
+    const resultWithResolution = result;
+    const rawResolutionDetails = Array.isArray(resultWithResolution.resolutionDetails) ? resultWithResolution.resolutionDetails : [];
+    const resolutionDetails = rawResolutionDetails.map((detail) => ({
+      filePath: relativePath,
+      machineRef: detail.machineRef,
+      resolvedId: detail.resolvedId,
+      source: detail.source
+    }));
+    registerExistingInjections(machineIds, { actions, fields, testIds }, relativePath);
+    return {
+      filePath,
+      injectedCount: result.injectedCount,
+      machineIds,
+      changed: true,
+      transformedCode,
+      actions,
+      fields,
+      testIds,
+      resolutionDetails
+    };
+  } catch (error) {
+    if (options.verbose) {
+      console.error(`Error processing ${filePath}:`, error);
+    }
+    return emptyResult(filePath);
+  }
+}
+async function processFile(filePath, repoRoot, options) {
+  const prep = await preprocessFile(filePath, repoRoot, options);
+  if (prep.skipped && prep.skipResult) return prep.skipResult;
+  const { code } = prep;
+  if (!mightContainMachineHooks(code)) return emptyResult(filePath);
+  return transformAndRegister(filePath, code, repoRoot, options);
+}
+async function processFileForChildInjection(filePath, repoRoot, options) {
+  const prep = await preprocessFile(filePath, repoRoot, options);
+  if (prep.skipped && prep.skipResult) return prep.skipResult;
+  const result = transformAndRegister(filePath, prep.code, repoRoot, options);
+  if (options.verbose && result.changed && result.injectedCount > 0) {
+    const relativePath = path3.relative(repoRoot, filePath);
+    console.log(
+      `  [child] Injected ${result.injectedCount} attrs in ${relativePath} (actions: ${result.actions.join(", ")})`
+    );
+  }
+  return result;
+}
+async function handleChangedFile(result, check, repoRoot, verbose, state) {
+  if (!result.changed || !result.transformedCode) return;
+  state.changes.push({
+    filePath: result.filePath,
+    injectedCount: result.injectedCount,
+    machineIds: result.machineIds,
+    changed: true
+  });
+  state.totalInjections += result.injectedCount;
+  if (check) return;
+  await fs2.promises.writeFile(result.filePath, result.transformedCode, "utf-8");
+  state.filesToFormat.push(result.filePath);
+  if (verbose) {
+    const relativePath = path3.relative(repoRoot, result.filePath);
+    console.log(`  Injected ${result.injectedCount} attrs in ${relativePath}`);
+  }
+}
+async function formatChangedFiles(filesToFormat, repoRoot, verbose) {
+  if (filesToFormat.length === 0) return;
+  if (verbose) {
+    console.log(`Formatting ${filesToFormat.length} files...`);
+  }
+  await formatFilesWithBiome(filesToFormat, repoRoot);
+}
+function createScanSummary(params) {
+  return {
+    totalFiles: params.files.length,
+    filesWithMachineDefinitions: params.withMachineDefinitions.length,
+    filesWithMachineHooks: params.withMachineHooks.length,
+    filesWithJsxOnly: params.withJsxOnly.length
+  };
+}
+async function resolveManifestArtifacts(params) {
+  let manifestPath;
+  let manifestMachineCount;
+  let machinesWithoutE2EMeta;
+  let detectionDiagnostics;
+  if (params.manifest && !params.check) {
+    const diagnosticsInput = {
+      scanSummary: params.scanSummary,
+      resolutionDetails: params.resolutionDetails
+    };
+    const manifestResult = await generateManifestFiles(
+      params.manifestDir,
+      params.repoRoot,
+      params.verbose,
+      params.resolveSchemas,
+      diagnosticsInput
+    );
+    manifestPath = manifestResult.manifestPath;
+    manifestMachineCount = manifestResult.machineCount;
+    machinesWithoutE2EMeta = manifestResult.machinesWithoutE2EMeta;
+    detectionDiagnostics = manifestResult.detectionDiagnostics;
+  } else if (params.manifest && params.check) {
+    const warnings = [];
+    detectionDiagnostics = buildDetectionDiagnostics({
+      scanSummary: params.scanSummary,
+      resolutionDetails: params.resolutionDetails,
+      manifestMachineIds: [],
+      machineLinks: [],
+      warnings
+    });
+  }
+  const strictDetectStatus = params.strictDetect ? detectionDiagnostics ? evaluateStrictDetect(detectionDiagnostics) : {
+    enabled: true,
+    passed: false,
+    reasons: [
+      "strict detect requires manifest diagnostics, but diagnostics were unavailable"
+    ]
+  } : void 0;
+  return {
+    manifestPath,
+    manifestMachineCount,
+    machinesWithoutE2EMeta,
+    detectionDiagnostics,
+    strictDetectStatus
+  };
+}
+function mightContainMachineDefinition(code) {
+  return code.includes("createMachine");
+}
+async function categorizeFiles(files) {
+  const withMachineDefinitions = [];
+  const withMachineHooks = [];
+  const withJsxOnly = [];
+  for (const filePath of files) {
+    try {
+      const code = await fs2.promises.readFile(filePath, "utf-8");
+      if (mightContainMachineHooks(code)) {
+        withMachineHooks.push(filePath);
+      } else if (mightContainJsx(code)) {
+        withJsxOnly.push(filePath);
+      } else if (mightContainMachineDefinition(code)) {
+        withMachineDefinitions.push(filePath);
+      }
+    } catch {
+    }
+  }
+  return { withMachineDefinitions, withMachineHooks, withJsxOnly };
+}
+async function processFiles(options) {
+  const {
+    repoRoot,
+    check,
+    verbose,
+    include,
+    exclude,
+    manifest,
+    manifestDir,
+    resolveSchemas,
+    strictDetect
+  } = options;
+  clearInjectionRegistry();
+  clearUnifiedRegistry();
+  const files = await discoverFiles(repoRoot, include, exclude);
+  if (verbose) console.log(`Found ${files.length} files to process`);
+  const state = {
+    changes: [],
+    filesToFormat: [],
+    totalInjections: 0,
+    resolutionDetails: []
+  };
+  const { withMachineDefinitions, withMachineHooks, withJsxOnly } = await categorizeFiles(files);
+  const scanSummary = createScanSummary({
+    files,
+    withMachineDefinitions,
+    withMachineHooks,
+    withJsxOnly
+  });
+  if (verbose) {
+    console.log(`  Files with machine definitions: ${withMachineDefinitions.length}`);
+    console.log(`  Files with machine hooks: ${withMachineHooks.length}`);
+    console.log(`  Files with JSX only: ${withJsxOnly.length}`);
+  }
+  const processOpts = { verbose, force: options.force ?? false };
+  for (const filePath of withMachineDefinitions) {
+    try {
+      const code = await fs2.promises.readFile(filePath, "utf-8");
+      const relativePath = path3.relative(repoRoot, filePath);
+      collectRouteInfo(relativePath, code, verbose);
+    } catch {
+    }
+  }
+  for (const filePath of withMachineHooks) {
+    const result = await processFile(filePath, repoRoot, processOpts);
+    state.resolutionDetails.push(...result.resolutionDetails);
+    await handleChangedFile(result, check, repoRoot, verbose, state);
+  }
+  for (const filePath of withJsxOnly) {
+    const result = await processFileForChildInjection(filePath, repoRoot, processOpts);
+    state.resolutionDetails.push(...result.resolutionDetails);
+    await handleChangedFile(result, check, repoRoot, verbose, state);
+  }
+  if (!check) {
+    await formatChangedFiles(state.filesToFormat, repoRoot, verbose);
+  }
+  postProcessRegistries();
+  const manifestArtifacts = await resolveManifestArtifacts({
+    manifest,
+    check,
+    manifestDir,
+    repoRoot,
+    verbose,
+    resolveSchemas: resolveSchemas ?? false,
+    strictDetect: strictDetect ?? false,
+    scanSummary,
+    resolutionDetails: state.resolutionDetails
+  });
+  const hasCheckFailure = check && state.changes.length > 0;
+  const hasStrictDetectFailure = manifestArtifacts.strictDetectStatus?.passed === false;
+  const exitCode = hasCheckFailure || hasStrictDetectFailure ? 1 : 0;
+  return {
+    totalFiles: files.length,
+    changedFiles: state.changes.length,
+    totalInjections: state.totalInjections,
+    changes: state.changes,
+    exitCode,
+    manifestPath: manifestArtifacts.manifestPath,
+    manifestMachineCount: manifestArtifacts.manifestMachineCount,
+    machinesWithoutE2EMeta: manifestArtifacts.machinesWithoutE2EMeta,
+    detectionDiagnostics: manifestArtifacts.detectionDiagnostics,
+    strictDetect: manifestArtifacts.strictDetectStatus
+  };
+}
+
+// src/commands/inject-test-attrs/action.ts
+init_esm_shims();
+
+// src/commands/inject-test-attrs/contract.ts
+init_esm_shims();
+var InjectTestAttrsInputSchema = z.object({
+  /** Dry-run mode: check without writing */
+  check: z.boolean().default(false),
+  /** Force overwrite even if marker exists */
+  force: z.boolean().default(false),
+  /** Verbose output */
+  verbose: z.boolean().default(false),
+  /** Include patterns (glob) - includes both .tsx and .ts for machine definition detection */
+  include: z.array(z.string()).default(["apps/**/*.tsx", "apps/**/*.ts", "packages/**/*.tsx", "packages/**/*.ts"]),
+  /** Exclude patterns (glob) */
+  exclude: z.array(z.string()).default([
+    "**/node_modules/**",
+    "**/.next/**",
+    "**/dist/**",
+    "**/*.test.*",
+    "**/*.spec.*",
+    "**/*.stories.*"
+  ]),
+  /** Generate E2E selector manifest */
+  manifest: z.boolean().default(true),
+  /** Manifest output directory */
+  manifestDir: z.string().default(".runa"),
+  /** Resolve Zod schemas to JSON Schema (v7+) for API contracts */
+  resolveSchemas: z.boolean().default(false),
+  /** Fail when heuristic fallback detection is used */
+  strictDetect: z.boolean().default(false)
+}).strict();
+var FileChangeSchema = z.object({
+  filePath: z.string(),
+  injectedCount: z.number(),
+  machineIds: z.array(z.string()),
+  changed: z.boolean()
+});
+var MachineWithoutE2EMetaSchema = z.object({
+  id: z.string(),
+  sourceFile: z.string()
+});
+var DetectionScanSummarySchema = z.object({
+  totalFiles: z.number().int().nonnegative(),
+  filesWithMachineDefinitions: z.number().int().nonnegative(),
+  filesWithMachineHooks: z.number().int().nonnegative(),
+  filesWithJsxOnly: z.number().int().nonnegative()
+}).strict();
+var MachineResolutionDetailSchema = z.object({
+  filePath: z.string(),
+  machineRef: z.string(),
+  resolvedId: z.string(),
+  source: z.enum(["explicit", "import", "inline", "fallback"])
+}).strict();
+var DetectionDiagnosticsSchema = z.object({
+  schemaVersion: z.literal(1),
+  scan: DetectionScanSummarySchema,
+  resolution: z.object({
+    totalMachineUsages: z.number().int().nonnegative(),
+    bySource: z.object({
+      explicit: z.number().int().nonnegative(),
+      import: z.number().int().nonnegative(),
+      inline: z.number().int().nonnegative(),
+      fallback: z.number().int().nonnegative()
+    }).strict(),
+    fallbackRate: z.number().min(0).max(1),
+    fallbackExamples: z.array(MachineResolutionDetailSchema)
+  }).strict(),
+  coverage: z.object({
+    totalManifestMachines: z.number().int().nonnegative(),
+    linkedManifestMachines: z.number().int().nonnegative(),
+    unlinkedManifestMachines: z.number().int().nonnegative(),
+    machineLinkCoverage: z.number().min(0).max(1),
+    unlinkedManifestMachineIds: z.array(z.string())
+  }).strict(),
+  warnings: z.array(
+    z.object({
+      severity: z.enum(["warning", "info", "hint"]),
+      message: z.string()
+    }).strict()
+  )
+}).strict();
+var StrictDetectStatusSchema = z.object({
+  enabled: z.literal(true),
+  passed: z.boolean(),
+  reasons: z.array(z.string())
+}).strict();
+var InjectTestAttrsOutputSchema = z.object({
+  totalFiles: z.number(),
+  changedFiles: z.number(),
+  totalInjections: z.number(),
+  changes: z.array(FileChangeSchema),
+  exitCode: z.union([z.literal(0), z.literal(1)]),
+  /** Generated manifest file path (if manifest=true) */
+  manifestPath: z.string().optional(),
+  /** Number of machines in manifest */
+  manifestMachineCount: z.number().optional(),
+  /** Machines without meta.e2e annotation (opt-in warning) */
+  machinesWithoutE2EMeta: z.array(MachineWithoutE2EMetaSchema).optional(),
+  /** Structured diagnostics for detection quality */
+  detectionDiagnostics: DetectionDiagnosticsSchema.optional(),
+  /** Strict detection mode result */
+  strictDetect: StrictDetectStatusSchema.optional()
+}).strict();
+
+// src/commands/inject-test-attrs/action.ts
+function logResultSummary(result, options, logger) {
+  if (result.changedFiles === 0) {
+    logger.success("All files are up to date");
+    return;
+  }
+  if (options.check) {
+    logger.warn(`${result.changedFiles} files need injection`);
+    for (const change of result.changes) {
+      logger.info(`  - ${change.filePath} (${change.injectedCount} attrs)`);
+    }
+    logger.info("");
+    logger.info("Run without --check to apply changes:");
+    logger.info("  runa inject-test-attrs");
+    return;
+  }
+  logger.success(`Injected ${result.totalInjections} attributes in ${result.changedFiles} files`);
+  if (options.verbose) {
+    for (const change of result.changes) {
+      logger.info(`  - ${change.filePath}: ${change.machineIds.join(", ")}`);
+    }
+  }
+}
+function logManifestInfo(result, logger) {
+  if (!result.manifestPath || result.manifestMachineCount === void 0) {
+    return;
+  }
+  logger.info("");
+  logger.success(
+    `Generated E2E manifest: ${result.manifestPath} (${result.manifestMachineCount} machines)`
+  );
+  logger.info("  Usage in tests:");
+  logger.info("    import { E2E_SELECTORS } from '.runa/e2e-selectors';");
+  logger.info("    await page.locator(E2E_SELECTORS.auth.container).click();");
+}
+function logMachinesWithoutE2EMeta(result, logger) {
+  if (!result.machinesWithoutE2EMeta || result.machinesWithoutE2EMeta.length === 0) {
+    return;
+  }
+  logger.info("");
+  logger.warn(`${result.machinesWithoutE2EMeta.length} machine(s) missing meta.e2e annotation:`);
+  for (const machine of result.machinesWithoutE2EMeta.slice(0, 5)) {
+    logger.info(`  - ${machine.id} (${machine.sourceFile})`);
+  }
+  if (result.machinesWithoutE2EMeta.length > 5) {
+    logger.info(`  ... and ${result.machinesWithoutE2EMeta.length - 5} more`);
+  }
+  logger.info("");
+  logger.info("  Add meta.e2e to states for E2E test generation:");
+  logger.info("    states: {");
+  logger.info("      idle: {");
+  logger.info('        meta: { e2e: { observable: "ui", assertions: [...] } }');
+  logger.info("      }");
+  logger.info("    }");
+  logger.info("  See: .claude/rules/xstate-design.md#meta.e2e");
+}
+function logDetectionDiagnostics(result, logger) {
+  if (!result.detectionDiagnostics) return;
+  const diagnostics = result.detectionDiagnostics;
+  const fallbackCount = diagnostics.resolution.bySource.fallback;
+  const fallbackRate = (diagnostics.resolution.fallbackRate * 100).toFixed(1);
+  const coverage = (diagnostics.coverage.machineLinkCoverage * 100).toFixed(1);
+  logger.info("");
+  logger.info(
+    `Detection diagnostics: usages=${diagnostics.resolution.totalMachineUsages}, fallback=${fallbackCount} (${fallbackRate}%), linkCoverage=${coverage}%`
+  );
+  if (fallbackCount > 0) {
+    for (const item of diagnostics.resolution.fallbackExamples.slice(0, 5)) {
+      logger.warn(
+        `  fallback: ${item.filePath} :: ${item.machineRef} -> ${item.resolvedId} (${item.source})`
+      );
+    }
+  }
+}
+function logStrictDetect(result, logger) {
+  if (!result.strictDetect) return;
+  if (result.strictDetect.passed) {
+    logger.success("Strict detect passed (no fallback resolution)");
+    return;
+  }
+  logger.error("Strict detect failed");
+  for (const reason of result.strictDetect.reasons) {
+    logger.error(`  - ${reason}`);
+  }
+}
+async function injectTestAttrsAction(rawOptions, command) {
+  const logger = createCLILogger("manifest");
+  const parseResult = InjectTestAttrsInputSchema.safeParse(rawOptions);
+  if (!parseResult.success) {
+    throw new CLIError("Invalid options", "INVALID_OPTIONS", [
+      parseResult.error.message,
+      "Run with --help for usage"
+    ]);
+  }
+  const options = parseResult.data;
+  if (options.strictDetect && options.check) {
+    throw new CLIError(
+      "--strict-detect cannot be used with --check",
+      "STRICT_DETECT_CHECK_UNSUPPORTED",
+      ["Run without --check to evaluate strict detection against manifest diagnostics"]
+    );
+  }
+  if (options.strictDetect && !options.manifest) {
+    throw new CLIError(
+      "--strict-detect requires manifest generation",
+      "STRICT_DETECT_MANIFEST_REQUIRED",
+      ["Remove --no-manifest, or disable --strict-detect"]
+    );
+  }
+  const repoRoot = findProjectRoot() ?? process.cwd();
+  if (!options.check) {
+    logger.section("Generating manifest (manifest.json)");
+  } else {
+    logger.section("Checking E2E manifest");
+  }
+  if (options.verbose) {
+    logger.info(`Repository root: ${repoRoot}`);
+    logger.info(`Include patterns: ${options.include.join(", ")}`);
+    logger.info(`Exclude patterns: ${options.exclude.join(", ")}`);
+  }
+  const result = await processFiles({
+    ...options,
+    repoRoot
+  });
+  logResultSummary(result, options, logger);
+  logManifestInfo(result, logger);
+  logMachinesWithoutE2EMeta(result, logger);
+  logDetectionDiagnostics(result, logger);
+  logStrictDetect(result, logger);
+  emitJsonSuccess(command, InjectTestAttrsOutputSchema, result);
+  if (result.exitCode !== 0) {
+    process.exit(result.exitCode);
+  }
+}
+
+export { injectTestAttrsAction, processFiles };