@mandujs/ate 0.17.0

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@mandujs/ate",
+  "version": "0.17.0",
+  "description": "Mandu ATE (Automation Test Engine) - extract/generate/run/report/heal/impact in one package",
+  "type": "module",
+  "sideEffects": false,
+  "main": "./src/index.ts",
+  "exports": {
+    ".": "./src/index.ts",
+    "./extractor": "./src/extractor.ts",
+    "./ir": "./src/ir.ts",
+    "./scenario": "./src/scenario.ts",
+    "./codegen": "./src/codegen.ts",
+    "./runner": "./src/runner.ts",
+    "./oracle": "./src/oracle.ts",
+    "./report": "./src/report.ts",
+    "./heal": "./src/heal.ts",
+    "./trace-parser": "./src/trace-parser.ts",
+    "./impact": "./src/impact.ts",
+    "./fs": "./src/fs.ts",
+    "./types": "./src/types.ts"
+  },
+  "files": [
+    "src/**/*"
+  ],
+  "keywords": [
+    "mandu",
+    "ate",
+    "automation",
+    "e2e",
+    "playwright",
+    "ts-morph"
+  ],
+  "license": "MPL-2.0",
+  "dependencies": {
+    "fast-glob": "^3.3.2",
+    "ts-morph": "^26.0.0"
+  },
+  "peerDependencies": {
+    "@playwright/test": ">=1.40.0",
+    "playwright": ">=1.40.0"
+  },
+  "engines": {
+    "bun": ">=1.0.0"
+  }
+}

package/src/codegen.ts

@@ -0,0 +1,140 @@
+import { join } from "node:path";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { getAtePaths, ensureDir, readJson, writeJson } from "./fs";
+import type { ScenarioBundle } from "./scenario";
+import type { OracleLevel } from "./types";
+import { readSelectorMap, buildPlaywrightLocatorChain } from "./selector-map";
+import { generateL1Assertions } from "./oracle";
+import { detectDomain } from "./domain-detector";
+
+function specHeader(): string {
+  return `import { test, expect } from "@playwright/test";\n\n`;
+}
+
+function oracleTemplate(level: OracleLevel, routePath: string): { setup: string; assertions: string } {
+  const setup: string[] = [];
+  const assertions: string[] = [];
+
+  // L0 baseline always
+  setup.push(`// L0: no console.error / uncaught exception / 5xx`);
+  setup.push(`const errors: string[] = [];`);
+  setup.push(`page.on("console", (msg) => { if (msg.type() === "error") errors.push(msg.text()); });`);
+  setup.push(`page.on("pageerror", (err) => errors.push(String(err)));`);
+
+  if (level === "L1" || level === "L2" || level === "L3") {
+    // Use domain-aware L1 assertions
+    const domain = detectDomain(routePath).domain;
+    const l1Assertions = generateL1Assertions(domain, routePath);
+    assertions.push(...l1Assertions);
+  }
+  if (level === "L2" || level === "L3") {
+    assertions.push(`// L2: behavior signals (placeholder - extend per app)`);
+    assertions.push(`await expect(page).toHaveURL(/.*/);`);
+  }
+  if (level === "L3") {
+    assertions.push(`// L3: domain hints (placeholder)`);
+  }
+
+  assertions.push(`expect(errors, "console/page errors").toEqual([]);`);
+
+  return { setup: setup.join("\n"), assertions: assertions.join("\n") };
+}
+
+export function generatePlaywrightSpecs(repoRoot: string, opts?: { onlyRoutes?: string[] }): { files: string[]; warnings: string[] } {
+  const paths = getAtePaths(repoRoot);
+  const warnings: string[] = [];
+
+  let bundle: ScenarioBundle;
+  try {
+    bundle = readJson<ScenarioBundle>(paths.scenariosPath);
+  } catch (err: any) {
+    throw new Error(`시나리오 번들 읽기 실패: ${err.message}`);
+  }
+
+  if (!bundle.scenarios || bundle.scenarios.length === 0) {
+    warnings.push("경고: 생성할 시나리오가 없습니다");
+    return { files: [], warnings };
+  }
+
+  let selectorMap;
+  try {
+    selectorMap = readSelectorMap(repoRoot);
+  } catch (err: any) {
+    // Selector map is optional
+    warnings.push(`Selector map 읽기 실패 (무시): ${err.message}`);
+  }
+
+  try {
+    ensureDir(paths.autoE2eDir);
+  } catch (err: any) {
+    throw new Error(`E2E 디렉토리 생성 실패: ${err.message}`);
+  }
+
+  const files: string[] = [];
+  for (const s of bundle.scenarios) {
+    if (opts?.onlyRoutes?.length && !opts.onlyRoutes.includes(s.route)) continue;
+
+    try {
+      const safeId = s.id.replace(/[^a-zA-Z0-9_-]/g, "_");
+      const filePath = join(paths.autoE2eDir, `${safeId}.spec.ts`);
+
+      const oracle = oracleTemplate(s.oracleLevel, s.route);
+
+      // Generate selector examples if selector map exists
+      let selectorExamples = "";
+      if (selectorMap && selectorMap.entries.length > 0) {
+        const exampleEntry = selectorMap.entries[0];
+        const locatorChain = buildPlaywrightLocatorChain(exampleEntry);
+        selectorExamples = `    // Example: Selector with fallback chain\n    // const loginBtn = ${locatorChain};\n`;
+      }
+
+      const code = [
+        specHeader(),
+        `test.describe(${JSON.stringify(s.id)}, () => {`,
+        `  test(${JSON.stringify(`smoke ${s.route}`)}, async ({ page, baseURL }) => {`,
+        `    const url = (baseURL ?? "http://localhost:3333") + ${JSON.stringify(s.route === "/" ? "/" : s.route)};`,
+        `    ${oracle.setup.split("\n").join("\n    ")}`,
+        `    await page.goto(url);`,
+        selectorExamples,
+        `    ${oracle.assertions.split("\n").join("\n    ")}`,
+        `  });`,
+        `});`,
+        "",
+      ].join("\n");
+
+      try {
+        writeFileSync(filePath, code, "utf8");
+        files.push(filePath);
+      } catch (err: any) {
+        warnings.push(`Spec 파일 쓰기 실패 (${filePath}): ${err.message}`);
+        console.error(`[ATE] Spec 생성 실패: ${filePath} - ${err.message}`);
+      }
+    } catch (err: any) {
+      warnings.push(`Spec 생성 실패 (${s.id}): ${err.message}`);
+      console.error(`[ATE] Spec 생성 에러: ${s.id} - ${err.message}`);
+      // Continue with next scenario
+    }
+  }
+
+  // ensure playwright config exists (minimal)
+  try {
+    const configPath = join(repoRoot, "tests", "e2e", "playwright.config.ts");
+    ensureDir(join(repoRoot, "tests", "e2e"));
+    const desiredConfig = `import { defineConfig } from "@playwright/test";\n\nexport default defineConfig({\n  // NOTE: resolved relative to this config file (tests/e2e).\n  testDir: ".",\n  timeout: 60_000,\n  use: {\n    baseURL: process.env.BASE_URL ?? "http://localhost:3333",\n    trace: process.env.CI ? "on-first-retry" : "retain-on-failure",\n    video: process.env.CI ? "retain-on-failure" : "off",\n    screenshot: "only-on-failure",\n  },\n  reporter: [\n    ["html", { outputFolder: "../../.mandu/reports/latest/playwright-html", open: "never" }],\n    ["json", { outputFile: "../../.mandu/reports/latest/playwright-report.json" }],\n    ["junit", { outputFile: "../../.mandu/reports/latest/junit.xml" }],\n  ],\n});\n`;
+
+    if (!existsSync(configPath)) {
+      Bun.write(configPath, desiredConfig);
+    } else {
+      // migrate older auto-generated config that used testDir: "tests/e2e" (breaks because config is already under tests/e2e)
+      const current = readFileSync(configPath, "utf8");
+      if (current.includes('testDir: "tests/e2e"')) {
+        Bun.write(configPath, desiredConfig);
+      }
+    }
+  } catch (err: any) {
+    warnings.push(`Playwright config 생성 실패: ${err.message}`);
+    console.warn(`[ATE] Playwright config 생성 실패: ${err.message}`);
+  }
+
+  return { files, warnings };
+}

package/src/dep-graph.ts

@@ -0,0 +1,279 @@
+import { normalize, resolve, relative, dirname, sep } from "node:path";
+
+/**
+ * Dependency graph: file → Set of files it depends on
+ */
+export interface DependencyGraph {
+  /** Map: normalized file path → Set of normalized dependency paths */
+  dependencies: Map<string, Set<string>>;
+  /** Map: normalized file path → Set of files that depend on it (reverse) */
+  dependents: Map<string, Set<string>>;
+  /** All files in the graph */
+  files: Set<string>;
+}
+
+/**
+ * Build options for dependency graph
+ */
+export interface BuildGraphOptions {
+  /** Root directory to resolve relative paths */
+  rootDir: string;
+  /** tsconfig.json path for TypeScript configuration */
+  tsconfigPath?: string;
+  /** File glob patterns to include */
+  include?: string[];
+  /** File glob patterns to exclude */
+  exclude?: string[];
+}
+
+/**
+ * Normalize path to forward slashes and resolve to absolute
+ */
+function normalizePath(path: string, rootDir: string): string {
+  const abs = resolve(rootDir, path);
+  return abs.replace(/\\/g, "/");
+}
+
+/**
+ * Resolve import specifier to file path
+ */
+function resolveImport(
+  sourceFile: any, // ts-morph SourceFile (lazy loaded)
+  importSpecifier: string,
+  rootDir: string,
+  project: any // ts-morph Project (lazy loaded)
+): string | null {
+  // Skip external modules (no relative/absolute path)
+  if (!importSpecifier.startsWith(".") && !importSpecifier.startsWith("/")) {
+    return null;
+  }
+
+  const sourceDir = dirname(sourceFile.getFilePath());
+  let targetPath = resolve(sourceDir, importSpecifier);
+
+  // Try extensions: .ts, .tsx, .js, .jsx
+  const extensions = [".ts", ".tsx", ".js", ".jsx", ""];
+  for (const ext of extensions) {
+    const candidate = targetPath + ext;
+    const sourceFileFound = project.getSourceFile(candidate);
+    if (sourceFileFound) {
+      return normalizePath(candidate, rootDir);
+    }
+  }
+
+  // Try index files
+  for (const ext of [".ts", ".tsx", ".js", ".jsx"]) {
+    const indexPath = resolve(targetPath, `index${ext}`);
+    const sourceFileFound = project.getSourceFile(indexPath);
+    if (sourceFileFound) {
+      return normalizePath(indexPath, rootDir);
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Build dependency graph from TypeScript project
+ */
+function shouldExcludeFile(filePath: string, excludePatterns: string[]): boolean {
+  if (excludePatterns.length === 0) return false;
+
+  const normalizedPath = filePath.replace(/\\/g, "/");
+  return excludePatterns.some((pattern) => {
+    // **/*.spec.ts → remove **/ and * to get .spec.ts
+    let processedPattern = pattern;
+
+    // Remove **/ prefix
+    if (processedPattern.startsWith("**/")) {
+      processedPattern = processedPattern.substring(3);
+    }
+
+    // Remove * prefix
+    if (processedPattern.startsWith("*")) {
+      processedPattern = processedPattern.substring(1);
+    }
+
+    // Now check if file ends with the processed pattern
+    return normalizedPath.endsWith(processedPattern);
+  });
+}
+
+export async function buildDependencyGraph(options: BuildGraphOptions): Promise<DependencyGraph> {
+  const { rootDir, tsconfigPath, include, exclude = [] } = options;
+
+  // Lazy load ts-morph only when needed
+  const { Project } = await import("ts-morph");
+
+  const project = new Project({
+    tsConfigFilePath: tsconfigPath,
+    skipAddingFilesFromTsConfig: !tsconfigPath,
+  });
+
+  // Add files if no tsconfig
+  if (!tsconfigPath && include) {
+    project.addSourceFilesAtPaths(include);
+  }
+
+  const dependencies = new Map<string, Set<string>>();
+  const dependents = new Map<string, Set<string>>();
+  const files = new Set<string>();
+
+  const sourceFiles = project.getSourceFiles();
+
+  // First pass: collect all files (excluding filtered ones)
+  for (const sourceFile of sourceFiles) {
+    const filePath = normalizePath(sourceFile.getFilePath(), rootDir);
+
+    // Skip excluded files
+    if (shouldExcludeFile(filePath, exclude)) {
+      continue;
+    }
+
+    files.add(filePath);
+    dependencies.set(filePath, new Set());
+    dependents.set(filePath, new Set());
+  }
+
+  // Second pass: extract imports
+  for (const sourceFile of sourceFiles) {
+    const filePath = normalizePath(sourceFile.getFilePath(), rootDir);
+
+    // Skip excluded files
+    if (shouldExcludeFile(filePath, exclude)) {
+      continue;
+    }
+
+    const deps = dependencies.get(filePath)!;
+
+    // Process import declarations
+    for (const importDecl of sourceFile.getImportDeclarations()) {
+      const specifier = importDecl.getModuleSpecifierValue();
+      const resolvedPath = resolveImport(sourceFile, specifier, rootDir, project);
+
+      if (resolvedPath && files.has(resolvedPath)) {
+        deps.add(resolvedPath);
+        dependents.get(resolvedPath)?.add(filePath);
+      }
+    }
+
+    // Process export declarations with from clause
+    for (const exportDecl of sourceFile.getExportDeclarations()) {
+      const moduleSpecifier = exportDecl.getModuleSpecifier();
+      if (moduleSpecifier) {
+        const specifier = moduleSpecifier.getLiteralText();
+        const resolvedPath = resolveImport(sourceFile, specifier, rootDir, project);
+
+        if (resolvedPath && files.has(resolvedPath)) {
+          deps.add(resolvedPath);
+          dependents.get(resolvedPath)?.add(filePath);
+        }
+      }
+    }
+  }
+
+  return { dependencies, dependents, files };
+}
+
+/**
+ * Find all files that transitively depend on the given file
+ * Uses DFS to traverse the dependency graph in reverse
+ */
+export function findDependents(
+  graph: DependencyGraph,
+  changedFile: string,
+  options?: { maxDepth?: number }
+): Set<string> {
+  const result = new Set<string>();
+  const visited = new Set<string>();
+  const maxDepth = options?.maxDepth ?? Infinity;
+
+  function dfs(file: string, depth: number) {
+    if (visited.has(file)) return; // Prevent infinite loop (circular deps)
+    visited.add(file);
+
+    const deps = graph.dependents.get(file);
+    if (!deps) return;
+
+    for (const dependent of deps) {
+      if (depth < maxDepth) {
+        result.add(dependent);
+        dfs(dependent, depth + 1);
+      }
+    }
+  }
+
+  dfs(changedFile, 0);
+  return result;
+}
+
+/**
+ * Find all files that the given file transitively depends on
+ * Uses DFS to traverse the dependency graph forward
+ */
+export function findDependencies(
+  graph: DependencyGraph,
+  file: string,
+  options?: { maxDepth?: number }
+): Set<string> {
+  const result = new Set<string>();
+  const visited = new Set<string>();
+  const maxDepth = options?.maxDepth ?? Infinity;
+
+  function dfs(currentFile: string, depth: number) {
+    if (depth > maxDepth) return;
+    if (visited.has(currentFile)) return;
+    visited.add(currentFile);
+
+    const deps = graph.dependencies.get(currentFile);
+    if (!deps) return;
+
+    for (const dep of deps) {
+      result.add(dep);
+      dfs(dep, depth + 1);
+    }
+  }
+
+  dfs(file, 0);
+  return result;
+}
+
+/**
+ * Detect circular dependencies in the graph
+ */
+export function detectCircularDependencies(graph: DependencyGraph): string[][] {
+  const cycles: string[][] = [];
+  const visited = new Set<string>();
+  const recursionStack = new Set<string>();
+
+  function dfs(file: string, path: string[]) {
+    if (recursionStack.has(file)) {
+      // Found a cycle
+      const cycleStart = path.indexOf(file);
+      const cycle = path.slice(cycleStart);
+      cycles.push([...cycle, file]);
+      return;
+    }
+
+    if (visited.has(file)) return;
+    visited.add(file);
+    recursionStack.add(file);
+
+    const deps = graph.dependencies.get(file);
+    if (deps) {
+      for (const dep of deps) {
+        dfs(dep, [...path, file]);
+      }
+    }
+
+    recursionStack.delete(file);
+  }
+
+  for (const file of graph.files) {
+    if (!visited.has(file)) {
+      dfs(file, []);
+    }
+  }
+
+  return cycles;
+}

package/src/domain-detector.ts

@@ -0,0 +1,194 @@
+/**
+ * Domain detection for context-aware test assertions
+ * Analyzes route paths, imports, and keywords to identify application domain
+ */
+
+export type AppDomain = "ecommerce" | "blog" | "dashboard" | "auth" | "generic";
+
+export interface DomainDetectionResult {
+  domain: AppDomain;
+  confidence: number; // 0-1
+  signals: string[];
+}
+
+interface DomainPattern {
+  domain: AppDomain;
+  routePatterns: RegExp[];
+  importKeywords: string[];
+  codeKeywords: string[];
+}
+
+const DOMAIN_PATTERNS: DomainPattern[] = [
+  {
+    domain: "ecommerce",
+    routePatterns: [
+      /\/shop/i,
+      /\/cart/i,
+      /\/checkout/i,
+      /\/product/i,
+      /\/order/i,
+      /\/payment/i,
+    ],
+    importKeywords: ["stripe", "commerce", "cart", "checkout", "payment"],
+    codeKeywords: ["addToCart", "removeFromCart", "checkout", "price", "product", "order"],
+  },
+  {
+    domain: "blog",
+    routePatterns: [
+      /\/blog/i,
+      /\/post/i,
+      /\/article/i,
+      /\/author/i,
+      /\/category/i,
+    ],
+    importKeywords: ["markdown", "mdx", "contentlayer", "sanity", "cms"],
+    codeKeywords: ["post", "article", "author", "publish", "content", "comment"],
+  },
+  {
+    domain: "dashboard",
+    routePatterns: [
+      /\/dashboard/i,
+      /\/admin/i,
+      /\/analytics/i,
+      /\/settings/i,
+      /\/profile/i,
+    ],
+    importKeywords: ["chart", "recharts", "d3", "analytics", "table", "zustand", "react-query"],
+    codeKeywords: ["chart", "table", "sidebar", "analytics", "report", "metric"],
+  },
+  {
+    domain: "auth",
+    routePatterns: [
+      /\/login/i,
+      /\/signup/i,
+      /\/register/i,
+      /\/auth/i,
+      /\/forgot-password/i,
+    ],
+    importKeywords: ["auth", "clerk", "nextauth", "supabase", "firebase"],
+    codeKeywords: ["login", "logout", "signup", "register", "authenticate", "session"],
+  },
+];
+
+/**
+ * Detect application domain from route path
+ */
+export function detectDomainFromRoute(routePath: string): DomainDetectionResult {
+  const results: Array<{ domain: AppDomain; score: number; signals: string[] }> = [];
+
+  for (const pattern of DOMAIN_PATTERNS) {
+    const signals: string[] = [];
+    let score = 0;
+
+    for (const regex of pattern.routePatterns) {
+      if (regex.test(routePath)) {
+        score += 1;
+        signals.push(`route pattern: ${regex.source}`);
+      }
+    }
+
+    if (score > 0) {
+      results.push({ domain: pattern.domain, score, signals });
+    }
+  }
+
+  // Sort by score descending
+  results.sort((a, b) => b.score - a.score);
+
+  if (results.length > 0 && results[0].score > 0) {
+    const best = results[0];
+    return {
+      domain: best.domain,
+      confidence: Math.min(best.score / 2, 1), // Normalize confidence
+      signals: best.signals,
+    };
+  }
+
+  return {
+    domain: "generic",
+    confidence: 1,
+    signals: ["no domain-specific patterns detected"],
+  };
+}
+
+/**
+ * Detect application domain from source code content
+ */
+export function detectDomainFromSource(sourceCode: string): DomainDetectionResult {
+  const results: Array<{ domain: AppDomain; score: number; signals: string[] }> = [];
+
+  for (const pattern of DOMAIN_PATTERNS) {
+    const signals: string[] = [];
+    let score = 0;
+
+    // Check import keywords
+    for (const keyword of pattern.importKeywords) {
+      const importRegex = new RegExp(`import\\s+.*from\\s+["'].*${keyword}.*["']`, "i");
+      if (importRegex.test(sourceCode)) {
+        score += 2;
+        signals.push(`import: ${keyword}`);
+      }
+    }
+
+    // Check code keywords
+    for (const keyword of pattern.codeKeywords) {
+      const codeRegex = new RegExp(`\\b${keyword}\\b`, "i");
+      if (codeRegex.test(sourceCode)) {
+        score += 1;
+        signals.push(`code keyword: ${keyword}`);
+      }
+    }
+
+    if (score > 0) {
+      results.push({ domain: pattern.domain, score, signals });
+    }
+  }
+
+  // Sort by score descending
+  results.sort((a, b) => b.score - a.score);
+
+  if (results.length > 0 && results[0].score >= 3) {
+    const best = results[0];
+    return {
+      domain: best.domain,
+      confidence: Math.min(best.score / 10, 1), // Normalize confidence
+      signals: best.signals.slice(0, 5), // Limit signals
+    };
+  }
+
+  return {
+    domain: "generic",
+    confidence: 1,
+    signals: ["no strong domain signals in source code"],
+  };
+}
+
+/**
+ * Combine multiple detection strategies
+ */
+export function detectDomain(routePath: string, sourceCode?: string): DomainDetectionResult {
+  const routeResult = detectDomainFromRoute(routePath);
+
+  if (!sourceCode) {
+    return routeResult;
+  }
+
+  const sourceResult = detectDomainFromSource(sourceCode);
+
+  // If both agree, combine confidence
+  if (routeResult.domain === sourceResult.domain) {
+    return {
+      domain: routeResult.domain,
+      confidence: Math.min((routeResult.confidence + sourceResult.confidence) / 2 + 0.2, 1),
+      signals: [...routeResult.signals, ...sourceResult.signals],
+    };
+  }
+
+  // If they disagree, prefer route result if it's not generic
+  if (routeResult.domain !== "generic") {
+    return routeResult;
+  }
+
+  // Otherwise use source result
+  return sourceResult;
+}