@mandujs/ate 0.17.0

package/src/oracle.ts

@@ -0,0 +1,152 @@
+import type { OracleLevel } from "./types";
+import { detectDomain, type AppDomain } from "./domain-detector";
+
+export interface OracleResult {
+  level: OracleLevel;
+  l0: { ok: boolean; errors: string[] };
+  l1: { ok: boolean; signals: string[] };
+  l2: { ok: boolean; signals: string[] };
+  l3: { ok: boolean; notes: string[] };
+}
+
+export function createDefaultOracle(level: OracleLevel): OracleResult {
+  return {
+    level,
+    l0: { ok: true, errors: [] },
+    l1: { ok: level !== "L0", signals: [] },
+    l2: { ok: true, signals: [] },
+    l3: { ok: true, notes: [] },
+  };
+}
+
+/**
+ * Generate L1 assertions based on detected domain
+ */
+export function generateL1Assertions(domain: AppDomain, routePath: string): string[] {
+  const assertions: string[] = [];
+
+  // Common structural assertions for all domains
+  assertions.push(`// L1: Domain-aware structure signals (${domain})`);
+  assertions.push(`await expect(page.locator("main, [role='main']")).toBeVisible();`);
+
+  switch (domain) {
+    case "ecommerce":
+      if (routePath.includes("/cart")) {
+        assertions.push(`await expect(page.locator("[data-testid='cart-items'], .cart-item, [class*='cart']")).toBeVisible();`);
+        assertions.push(`await expect(page.locator("button:has-text('Checkout'), button:has-text('Proceed')")).toBeVisible();`);
+      } else if (routePath.includes("/product")) {
+        assertions.push(`await expect(page.locator("h1, [data-testid='product-title']")).toBeVisible();`);
+        assertions.push(`await expect(page.locator("button:has-text('Add to Cart'), button[class*='add']")).toBeVisible();`);
+        assertions.push(`await expect(page.locator("[data-testid='price'], .price, [class*='price']")).toBeVisible();`);
+      } else if (routePath.includes("/checkout")) {
+        assertions.push(`await expect(page.locator("form, [data-testid='checkout-form']")).toBeVisible();`);
+        assertions.push(`await expect(page.locator("input[type='email'], input[name*='email']")).toBeVisible();`);
+      } else if (routePath.includes("/shop")) {
+        assertions.push(`await expect(page.locator("[data-testid='product-card'], .product, [class*='product']")).toHaveCount({ min: 1 });`);
+        assertions.push(`await expect(page.locator("a[href*='/product'], [data-testid='product-link']")).toHaveCount({ min: 1 });`);
+      } else {
+        // Generic ecommerce page fallback
+        assertions.push(`await expect(page.locator("nav, [role='navigation']")).toBeVisible();`);
+        assertions.push(`await expect(page.locator("a, button")).toHaveCount({ min: 1 });`);
+      }
+      break;
+
+    case "blog":
+      if (routePath.includes("/post") || routePath.includes("/article")) {
+        assertions.push(`await expect(page.locator("article, [role='article']")).toBeVisible();`);
+        assertions.push(`await expect(page.locator("h1, [data-testid='post-title']")).toBeVisible();`);
+        assertions.push(`await expect(page.locator("[data-testid='post-content'], .content, [class*='content']")).toBeVisible();`);
+      } else if (routePath.includes("/author")) {
+        assertions.push(`await expect(page.locator("[data-testid='author-name'], .author")).toBeVisible();`);
+        assertions.push(`await expect(page.locator("[data-testid='author-posts'], .posts")).toBeVisible();`);
+      } else {
+        // Blog index/listing fallback
+        assertions.push(`await expect(page.locator("h1, h2")).toBeVisible();`);
+        assertions.push(`await expect(page.locator("a")).toHaveCount({ min: 1 });`);
+      }
+      break;
+
+    case "dashboard":
+      assertions.push(`await expect(page.locator("nav, [role='navigation'], aside, [data-testid='sidebar']")).toBeVisible();`);
+      if (routePath.includes("/analytics") || routePath.includes("/dashboard")) {
+        assertions.push(`await expect(page.locator("canvas, svg, [data-testid='chart']")).toHaveCount({ min: 1 });`);
+        assertions.push(`await expect(page.locator("[data-testid='metric'], .metric, [class*='stat']")).toHaveCount({ min: 1 });`);
+      } else if (routePath.includes("/settings")) {
+        assertions.push(`await expect(page.locator("form, [data-testid='settings-form']")).toBeVisible();`);
+        assertions.push(`await expect(page.locator("button:has-text('Save'), button[type='submit']")).toBeVisible();`);
+      } else {
+        // Generic dashboard page fallback
+        assertions.push(`await expect(page.locator("h1, h2")).toBeVisible();`);
+        assertions.push(`await expect(page.locator("a, button")).toHaveCount({ min: 1 });`);
+      }
+      break;
+
+    case "auth":
+      assertions.push(`await expect(page.locator("form, [data-testid='auth-form']")).toBeVisible();`);
+      if (routePath.includes("/login")) {
+        assertions.push(`await expect(page.locator("input[type='email'], input[name*='email']")).toBeVisible();`);
+        assertions.push(`await expect(page.locator("input[type='password']")).toBeVisible();`);
+        assertions.push(`await expect(page.locator("button:has-text('Login'), button:has-text('Sign in')")).toBeVisible();`);
+      } else if (routePath.includes("/signup") || routePath.includes("/register")) {
+        assertions.push(`await expect(page.locator("input[type='email'], input[name*='email']")).toBeVisible();`);
+        assertions.push(`await expect(page.locator("input[type='password']")).toBeVisible();`);
+        assertions.push(`await expect(page.locator("button:has-text('Sign up'), button:has-text('Register')")).toBeVisible();`);
+      } else if (routePath.includes("/forgot-password")) {
+        assertions.push(`await expect(page.locator("input[type='email'], input[name*='email']")).toBeVisible();`);
+        assertions.push(`await expect(page.locator("button:has-text('Reset'), button:has-text('Send')")).toBeVisible();`);
+      } else {
+        // Generic auth page fallback
+        assertions.push(`await expect(page.locator("input")).toHaveCount({ min: 1 });`);
+        assertions.push(`await expect(page.locator("button[type='submit'], button")).toHaveCount({ min: 1 });`);
+      }
+      break;
+
+    case "generic":
+    default:
+      // Generic fallback assertions
+      assertions.push(`await expect(page.locator("h1")).toBeVisible();`);
+      assertions.push(`await expect(page.locator("a, button")).toHaveCount({ min: 1 });`);
+      assertions.push(`await expect(page).toHaveTitle(/.+/);`);
+      break;
+  }
+
+  return assertions;
+}
+
+/**
+ * Upgrade L0 test code to L1 with domain-aware assertions
+ */
+export function upgradeL0ToL1(testCode: string, routePath: string, sourceCode?: string): string {
+  const detection = detectDomain(routePath, sourceCode);
+  const l1Assertions = generateL1Assertions(detection.domain, routePath);
+
+  // Find the L0 error check assertion
+  const l0ErrorCheckRegex = /expect\(errors.*?\)\.toEqual\(\[\]\);/;
+  const match = testCode.match(l0ErrorCheckRegex);
+
+  if (!match) {
+    // If no L0 error check found, append L1 assertions before the closing braces
+    const closingBraceIndex = testCode.lastIndexOf("});");
+    if (closingBraceIndex === -1) return testCode;
+
+    const beforeClosing = testCode.slice(0, closingBraceIndex);
+    const afterClosing = testCode.slice(closingBraceIndex);
+
+    return `${beforeClosing}\n    ${l1Assertions.join("\n    ")}\n${afterClosing}`;
+  }
+
+  // Insert L1 assertions before the L0 error check
+  const insertIndex = match.index!;
+  const before = testCode.slice(0, insertIndex);
+  const after = testCode.slice(insertIndex);
+
+  return `${before}${l1Assertions.join("\n    ")}\n    ${after}`;
+}
+
+/**
+ * Get assertion count for a domain and route
+ */
+export function getAssertionCount(domain: AppDomain, routePath: string): number {
+  const assertions = generateL1Assertions(domain, routePath);
+  return assertions.filter((a) => a.includes("expect(")).length;
+}

package/src/pipeline.ts

@@ -0,0 +1,207 @@
+import type { OracleLevel } from "./types";
+import { ATEFileError } from "./fs";
+import { ateExtract, ateGenerate, ateRun, ateReport, ateImpact, ateHeal } from "./index";
+
+export interface AutoPipelineOptions {
+  repoRoot: string;
+  baseURL?: string;
+  oracleLevel?: OracleLevel;
+  ci?: boolean;
+  useImpactAnalysis?: boolean;
+  base?: string;
+  head?: string;
+  autoHeal?: boolean;
+  tsconfigPath?: string;
+  routeGlobs?: string[];
+  buildSalt?: string;
+}
+
+export interface AutoPipelineResult {
+  ok: boolean;
+  steps: {
+    extract: { ok: boolean; error?: string };
+    generate: { ok: boolean; error?: string };
+    impact?: { ok: boolean; mode: "full" | "subset"; selectedRoutes: string[]; error?: string };
+    run: { ok: boolean; runId: string; exitCode: number; error?: string };
+    report: { ok: boolean; summaryPath?: string; error?: string };
+    heal?: { ok: boolean; suggestionsCount: number; error?: string };
+  };
+}
+
+/**
+ * ATE 전체 파이프라인 자동 실행
+ * Extract → Generate → (Impact) → Run → Report → (Heal)
+ */
+export async function runFullPipeline(options: AutoPipelineOptions): Promise<AutoPipelineResult> {
+  const result: AutoPipelineResult = {
+    ok: false,
+    steps: {
+      extract: { ok: false },
+      generate: { ok: false },
+      run: { ok: false, runId: "", exitCode: -1 },
+      report: { ok: false },
+    },
+  };
+
+  const oracleLevel = options.oracleLevel ?? "L1";
+
+  try {
+    // Step 1: Extract
+    console.log("📊 [ATE Pipeline] Step 1/5: Extract - 상호작용 그래프 추출 중...");
+    try {
+      await ateExtract({
+        repoRoot: options.repoRoot,
+        tsconfigPath: options.tsconfigPath,
+        routeGlobs: options.routeGlobs,
+        buildSalt: options.buildSalt,
+      });
+      result.steps.extract.ok = true;
+      console.log("✅ [ATE Pipeline] Extract 완료");
+    } catch (err: any) {
+      result.steps.extract.error = err.message;
+      console.error(`❌ [ATE Pipeline] Extract 실패: ${err.message}`);
+      return result;
+    }
+
+    // Step 2: Generate
+    console.log("🎬 [ATE Pipeline] Step 2/5: Generate - 시나리오 및 테스트 생성 중...");
+    try {
+      await ateGenerate({
+        repoRoot: options.repoRoot,
+        oracleLevel,
+      });
+      result.steps.generate.ok = true;
+      console.log("✅ [ATE Pipeline] Generate 완료");
+    } catch (err: any) {
+      result.steps.generate.error = err.message;
+      console.error(`❌ [ATE Pipeline] Generate 실패: ${err.message}`);
+      return result;
+    }
+
+    // Step 3 (Optional): Impact Analysis
+    let impactResult: { changedFiles: string[]; selectedRoutes: string[] } | undefined;
+    if (options.useImpactAnalysis) {
+      console.log("🔍 [ATE Pipeline] Step 3/5: Impact Analysis - 변경 영향 분석 중...");
+      try {
+        const impact = await ateImpact({
+          repoRoot: options.repoRoot,
+          base: options.base,
+          head: options.head,
+        });
+        result.steps.impact = {
+          ok: true,
+          mode: impact.selectedRoutes.length > 0 ? "subset" : "full",
+          selectedRoutes: impact.selectedRoutes,
+        };
+        impactResult = {
+          changedFiles: impact.changedFiles,
+          selectedRoutes: impact.selectedRoutes,
+        };
+        console.log(
+          `✅ [ATE Pipeline] Impact Analysis 완료 - ${impact.selectedRoutes.length}개 라우트 선택됨`,
+        );
+      } catch (err: any) {
+        result.steps.impact = {
+          ok: false,
+          mode: "full",
+          selectedRoutes: [],
+          error: err.message,
+        };
+        console.warn(`⚠️ [ATE Pipeline] Impact Analysis 실패, 전체 테스트 실행: ${err.message}`);
+        // Impact analysis 실패 시에도 계속 진행 (full test)
+      }
+    }
+
+    // Step 4: Run
+    console.log("🧪 [ATE Pipeline] Step 4/5: Run - Playwright 테스트 실행 중...");
+    let runId = "";
+    let exitCode = -1;
+    let startedAt = "";
+    let finishedAt = "";
+    try {
+      const runResult = await ateRun({
+        repoRoot: options.repoRoot,
+        baseURL: options.baseURL,
+        ci: options.ci,
+      });
+      runId = runResult.runId;
+      exitCode = runResult.exitCode;
+      startedAt = runResult.startedAt;
+      finishedAt = runResult.finishedAt;
+      result.steps.run = { ok: exitCode === 0, runId, exitCode };
+      console.log(
+        `${exitCode === 0 ? "✅" : "⚠️"} [ATE Pipeline] Run 완료 - exitCode: ${exitCode}`,
+      );
+    } catch (err: any) {
+      result.steps.run.error = err.message;
+      console.error(`❌ [ATE Pipeline] Run 실패: ${err.message}`);
+      return result;
+    }
+
+    // Step 5: Report
+    console.log("📝 [ATE Pipeline] Step 5/5: Report - 테스트 리포트 생성 중...");
+    try {
+      const reportResult = await ateReport({
+        repoRoot: options.repoRoot,
+        runId,
+        startedAt,
+        finishedAt,
+        exitCode,
+        oracleLevel,
+        impact: impactResult
+          ? {
+              mode: impactResult.selectedRoutes.length > 0 ? "subset" : "full",
+              changedFiles: impactResult.changedFiles,
+              selectedRoutes: impactResult.selectedRoutes,
+            }
+          : undefined,
+      });
+      result.steps.report = { ok: true, summaryPath: reportResult.summaryPath };
+      console.log(`✅ [ATE Pipeline] Report 완료 - ${reportResult.summaryPath}`);
+    } catch (err: any) {
+      result.steps.report.error = err.message;
+      console.error(`❌ [ATE Pipeline] Report 실패: ${err.message}`);
+      return result;
+    }
+
+    // Step 6 (Optional): Heal
+    if (options.autoHeal && exitCode !== 0) {
+      console.log("🔧 [ATE Pipeline] Step 6/6: Heal - 자동 복구 제안 생성 중...");
+      try {
+        const healResult = await ateHeal({
+          repoRoot: options.repoRoot,
+          runId,
+        });
+        result.steps.heal = {
+          ok: true,
+          suggestionsCount: healResult.suggestions?.length ?? 0,
+        };
+        console.log(
+          `✅ [ATE Pipeline] Heal 완료 - ${healResult.suggestions?.length ?? 0}개 제안 생성됨`,
+        );
+      } catch (err: any) {
+        result.steps.heal = {
+          ok: false,
+          suggestionsCount: 0,
+          error: err.message,
+        };
+        console.warn(`⚠️ [ATE Pipeline] Heal 실패: ${err.message}`);
+        // Heal 실패는 전체 파이프라인 실패로 보지 않음
+      }
+    }
+
+    // 최종 결과
+    result.ok = result.steps.extract.ok && result.steps.generate.ok && result.steps.report.ok;
+    console.log(
+      `\n${result.ok ? "✅" : "⚠️"} [ATE Pipeline] 파이프라인 완료 - 전체 성공: ${result.ok}`,
+    );
+
+    return result;
+  } catch (err: any) {
+    throw new ATEFileError(
+      `파이프라인 실행 중 예상치 못한 오류: ${err.message}`,
+      "PIPELINE_ERROR",
+      options.repoRoot,
+    );
+  }
+}

package/src/report.ts

@@ -0,0 +1,129 @@
+import { join } from "node:path";
+import { getAtePaths, ensureDir, writeJson } from "./fs";
+import { createDefaultOracle } from "./oracle";
+import type { SummaryJson, OracleLevel } from "./types";
+import { generateHtmlReport, type HtmlReportOptions } from "./reporter/html";
+
+export function composeSummary(params: {
+  repoRoot: string;
+  runId: string;
+  startedAt: string;
+  finishedAt: string;
+  exitCode: number;
+  oracleLevel: OracleLevel;
+  impact?: { changedFiles: string[]; selectedRoutes: string[]; mode: "full" | "subset" };
+  heal?: { suggestions: Array<{ kind: string; title: string; diff: string }> };
+}): SummaryJson {
+  // Validate required params
+  if (!params.repoRoot) {
+    throw new Error("repoRoot는 필수입니다");
+  }
+  if (!params.runId) {
+    throw new Error("runId는 필수입니다");
+  }
+
+  const paths = getAtePaths(params.repoRoot);
+
+  let oracle;
+  try {
+    oracle = createDefaultOracle(params.oracleLevel);
+  } catch (err: any) {
+    throw new Error(`Oracle 생성 실패: ${err.message}`);
+  }
+
+  return {
+    schemaVersion: 1,
+    runId: params.runId,
+    startedAt: params.startedAt,
+    finishedAt: params.finishedAt,
+    ok: params.exitCode === 0,
+    oracle,
+    playwright: {
+      exitCode: params.exitCode,
+      reportDir: join(paths.reportsDir, params.runId),
+      jsonReportPath: join(paths.reportsDir, "latest", "playwright-report.json"),
+      junitPath: join(paths.reportsDir, "latest", "junit.xml"),
+    },
+    mandu: {
+      interactionGraphPath: paths.interactionGraphPath,
+      selectorMapPath: paths.selectorMapPath,
+      scenariosPath: paths.scenariosPath,
+    },
+    heal: {
+      attempted: true,
+      suggestions: params.heal?.suggestions ?? [],
+    },
+    impact: params.impact ?? {
+      mode: "full",
+      changedFiles: [],
+      selectedRoutes: [],
+    },
+  };
+}
+
+export function writeSummary(repoRoot: string, runId: string, summary: SummaryJson): string {
+  if (!repoRoot) {
+    throw new Error("repoRoot는 필수입니다");
+  }
+  if (!runId) {
+    throw new Error("runId는 필수입니다");
+  }
+
+  const paths = getAtePaths(repoRoot);
+  const runDir = join(paths.reportsDir, runId);
+
+  try {
+    ensureDir(runDir);
+  } catch (err: any) {
+    throw new Error(`Report 디렉토리 생성 실패: ${err.message}`);
+  }
+
+  const outPath = join(runDir, "summary.json");
+
+  try {
+    writeJson(outPath, summary);
+  } catch (err: any) {
+    throw new Error(`Summary 파일 저장 실패: ${err.message}`);
+  }
+
+  return outPath;
+}
+
+export type ReportFormat = "json" | "html" | "both";
+
+export interface GenerateReportOptions {
+  repoRoot: string;
+  runId: string;
+  format?: ReportFormat;
+  includeScreenshots?: boolean;
+  includeTraces?: boolean;
+}
+
+export async function generateReport(options: GenerateReportOptions): Promise<{ json?: string; html?: string }> {
+  const { repoRoot, runId, format = "both", includeScreenshots = true, includeTraces = true } = options;
+
+  const result: { json?: string; html?: string } = {};
+
+  // JSON은 이미 writeSummary로 생성되었다고 가정
+  if (format === "json" || format === "both") {
+    const paths = getAtePaths(repoRoot);
+    result.json = join(paths.reportsDir, runId, "summary.json");
+  }
+
+  // HTML 생성
+  if (format === "html" || format === "both") {
+    try {
+      const htmlResult = await generateHtmlReport({
+        repoRoot,
+        runId,
+        includeScreenshots,
+        includeTraces,
+      });
+      result.html = htmlResult.path;
+    } catch (err: any) {
+      throw new Error(`HTML 리포트 생성 실패: ${err.message}`);
+    }
+  }
+
+  return result;
+}