@mandujs/ate 0.17.0

package/src/extractor.ts

@@ -0,0 +1,159 @@
+import fg from "fast-glob";
+import { relative, join } from "node:path";
+import { createEmptyGraph, addEdge, addNode } from "./ir";
+import { getAtePaths, writeJson } from "./fs";
+import type { ExtractInput, InteractionGraph } from "./types";
+
+const DEFAULT_ROUTE_GLOBS = ["app/**/page.tsx", "routes/**/page.tsx"]; // demo-first default
+
+function isStringLiteral(node: any /* ts-morph Node */, SyntaxKind: any): boolean {
+  return node.getKind() === SyntaxKind.StringLiteral;
+}
+
+function tryExtractLiteralArg(callExpr: any /* ts-morph CallExpression */, argIndex = 0, SyntaxKind: any): string | null {
+  const args = callExpr.getArguments();
+  const arg = args[argIndex];
+  if (!arg) return null;
+  if (isStringLiteral(arg, SyntaxKind)) return arg.getLiteralValue();
+  return null;
+}
+
+export async function extract(input: ExtractInput): Promise<{ ok: true; graphPath: string; summary: { nodes: number; edges: number }; warnings: string[] }> {
+  const repoRoot = input.repoRoot;
+  const buildSalt = input.buildSalt ?? process.env.MANDU_BUILD_SALT ?? "dev";
+  const paths = getAtePaths(repoRoot);
+  const warnings: string[] = [];
+
+  const graph: InteractionGraph = createEmptyGraph(buildSalt);
+
+  // Validate input
+  if (!repoRoot) {
+    throw new Error("repoRoot는 필수입니다");
+  }
+
+  const routeGlobs = input.routeGlobs?.length ? input.routeGlobs : DEFAULT_ROUTE_GLOBS;
+
+  let routeFiles: string[];
+  try {
+    routeFiles = await fg(routeGlobs, {
+      cwd: repoRoot,
+      absolute: true,
+      onlyFiles: true,
+      ignore: ["**/node_modules/**", "**/.mandu/**"],
+    });
+  } catch (err: any) {
+    throw new Error(`파일 검색 실패: ${err.message}`);
+  }
+
+  if (routeFiles.length === 0) {
+    warnings.push(`경고: route 파일을 찾을 수 없습니다 (globs: ${routeGlobs.join(", ")})`);
+  }
+
+  // Lazy load ts-morph only when needed
+  const { Project, SyntaxKind } = await import("ts-morph");
+
+  let project: any; // ts-morph Project
+  try {
+    project = new Project({
+      tsConfigFilePath: input.tsconfigPath ? join(repoRoot, input.tsconfigPath) : undefined,
+      skipAddingFilesFromTsConfig: true,
+    });
+  } catch (err: any) {
+    throw new Error(`TypeScript 프로젝트 초기화 실패: ${err.message}`);
+  }
+
+  for (const filePath of routeFiles) {
+    try {
+      const sourceFile = project.addSourceFileAtPath(filePath);
+      const rel = relative(repoRoot, filePath);
+      const relNormalized = rel.replace(/\\/g, "/");
+
+      // route node id: normalize to path without trailing /page.tsx
+      const routePath = relNormalized
+        .replace(/^app\//, "/")
+        .replace(/^routes\//, "/")
+        .replace(/\/page\.tsx$/, "")
+        .replace(/\/index\.tsx$/, "")
+        .replace(/\/page$/, "")
+        .replace(/\\/g, "/");
+
+      addNode(graph, { kind: "route", id: routePath === "" ? "/" : routePath, file: relNormalized, path: routePath === "" ? "/" : routePath });
+
+      // ManduLink / Link literal extraction: <Link href="/x"> or <ManduLink to="/x">
+      try {
+        const jsxAttrs = sourceFile.getDescendantsOfKind(SyntaxKind.JsxAttribute);
+        for (const attr of jsxAttrs) {
+          try {
+            const name = (attr as any).getNameNode?.().getText?.() ?? (attr as any).getName?.() ?? "";
+            if (name !== "to" && name !== "href") continue;
+            const init = (attr as any).getInitializer?.();
+            if (!init) continue;
+            if (init.getKind?.() === SyntaxKind.StringLiteral) {
+              const raw = (init as any).getLiteralValue?.() ?? init.getText?.();
+              const to = typeof raw === "string" ? raw.replace(/^"|"$/g, "") : null;
+              if (typeof to === "string" && to.startsWith("/")) {
+                addEdge(graph, { kind: "navigate", from: routePath || "/", to, file: relNormalized, source: `<jsx ${name}>` });
+              }
+            }
+          } catch (err: any) {
+            // Skip invalid JSX attributes
+            warnings.push(`JSX 속성 파싱 실패 (${relNormalized}): ${err.message}`);
+          }
+        }
+      } catch (err: any) {
+        warnings.push(`JSX 분석 실패 (${relNormalized}): ${err.message}`);
+      }
+
+      // mandu.navigate("/x") literal
+      try {
+        const calls = sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression);
+        for (const call of calls) {
+          try {
+            const exprText = call.getExpression().getText();
+            if (exprText === "mandu.navigate" || exprText.endsWith(".navigate")) {
+              const to = tryExtractLiteralArg(call, 0, SyntaxKind);
+              if (to && to.startsWith("/")) {
+                addEdge(graph, { kind: "navigate", from: routePath || "/", to, file: relNormalized, source: "mandu.navigate" });
+              }
+            }
+            if (exprText === "mandu.modal.open" || exprText.endsWith(".modal.open")) {
+              const modal = tryExtractLiteralArg(call, 0, SyntaxKind);
+              if (modal) {
+                addEdge(graph, { kind: "openModal", from: routePath || "/", modal, file: relNormalized, source: "mandu.modal.open" });
+              }
+            }
+            if (exprText === "mandu.action.run" || exprText.endsWith(".action.run")) {
+              const action = tryExtractLiteralArg(call, 0, SyntaxKind);
+              if (action) {
+                addEdge(graph, { kind: "runAction", from: routePath || "/", action, file: relNormalized, source: "mandu.action.run" });
+              }
+            }
+          } catch (err: any) {
+            // Skip invalid call expressions
+            warnings.push(`함수 호출 파싱 실패 (${relNormalized}): ${err.message}`);
+          }
+        }
+      } catch (err: any) {
+        warnings.push(`함수 호출 분석 실패 (${relNormalized}): ${err.message}`);
+      }
+    } catch (err: any) {
+      // Graceful degradation: skip this file and continue
+      warnings.push(`파일 파싱 실패 (${filePath}): ${err.message}`);
+      console.warn(`[ATE] 파일 스킵: ${filePath} - ${err.message}`);
+      continue;
+    }
+  }
+
+  try {
+    writeJson(paths.interactionGraphPath, graph);
+  } catch (err: any) {
+    throw new Error(`Interaction graph 저장 실패: ${err.message}`);
+  }
+
+  return {
+    ok: true,
+    graphPath: paths.interactionGraphPath,
+    summary: { nodes: graph.nodes.length, edges: graph.edges.length },
+    warnings,
+  };
+}

package/src/fs.ts

@@ -0,0 +1,145 @@
+import { mkdirSync, readFileSync, writeFileSync, existsSync } from "node:fs";
+import { dirname, join } from "node:path";
+import type { AtePaths } from "./types";
+
+export class ATEFileError extends Error {
+  constructor(
+    message: string,
+    public readonly code: string,
+    public readonly path: string,
+  ) {
+    super(message);
+    this.name = "ATEFileError";
+  }
+}
+
+export function getAtePaths(repoRoot: string): AtePaths {
+  const manduDir = join(repoRoot, ".mandu");
+  return {
+    repoRoot,
+    manduDir,
+    interactionGraphPath: join(manduDir, "interaction-graph.json"),
+    selectorMapPath: join(manduDir, "selector-map.json"),
+    scenariosPath: join(manduDir, "scenarios", "generated.json"),
+    reportsDir: join(manduDir, "reports"),
+    autoE2eDir: join(repoRoot, "tests", "e2e", "auto"),
+    manualE2eDir: join(repoRoot, "tests", "e2e", "manual"),
+  };
+}
+
+/**
+ * 디렉토리 생성 (재귀적)
+ * @throws ATEFileError - 권한 없음 또는 파일 시스템 에러
+ */
+export function ensureDir(path: string): void {
+  try {
+    mkdirSync(path, { recursive: true });
+  } catch (err: any) {
+    if (err.code === "EACCES") {
+      throw new ATEFileError(
+        `디렉토리 생성 권한이 없습니다: ${path}`,
+        "PERMISSION_DENIED",
+        path,
+      );
+    }
+    if (err.code === "ENOSPC") {
+      throw new ATEFileError(
+        `디스크 공간이 부족합니다: ${path}`,
+        "NO_SPACE",
+        path,
+      );
+    }
+    throw new ATEFileError(
+      `디렉토리 생성 실패: ${path} (${err.message})`,
+      err.code || "UNKNOWN",
+      path,
+    );
+  }
+}
+
+/**
+ * JSON 파일 쓰기
+ * @throws ATEFileError - 파일 쓰기 실패
+ */
+export function writeJson(path: string, data: unknown): void {
+  try {
+    ensureDir(dirname(path));
+    writeFileSync(path, JSON.stringify(data, null, 2), "utf8");
+  } catch (err: any) {
+    if (err instanceof ATEFileError) {
+      throw err;
+    }
+    if (err.code === "EACCES") {
+      throw new ATEFileError(
+        `파일 쓰기 권한이 없습니다: ${path}`,
+        "PERMISSION_DENIED",
+        path,
+      );
+    }
+    if (err.code === "ENOSPC") {
+      throw new ATEFileError(
+        `디스크 공간이 부족합니다: ${path}`,
+        "NO_SPACE",
+        path,
+      );
+    }
+    throw new ATEFileError(
+      `JSON 파일 쓰기 실패: ${path} (${err.message})`,
+      err.code || "UNKNOWN",
+      path,
+    );
+  }
+}
+
+/**
+ * JSON 파일 읽기
+ * @throws ATEFileError - 파일 없음, 읽기 실패, JSON 파싱 실패
+ */
+export function readJson<T>(path: string): T {
+  try {
+    if (!existsSync(path)) {
+      throw new ATEFileError(
+        `파일을 찾을 수 없습니다: ${path}`,
+        "FILE_NOT_FOUND",
+        path,
+      );
+    }
+
+    const content = readFileSync(path, "utf8");
+    return JSON.parse(content) as T;
+  } catch (err: any) {
+    if (err instanceof ATEFileError) {
+      throw err;
+    }
+    if (err.code === "EACCES") {
+      throw new ATEFileError(
+        `파일 읽기 권한이 없습니다: ${path}`,
+        "PERMISSION_DENIED",
+        path,
+      );
+    }
+    if (err instanceof SyntaxError) {
+      throw new ATEFileError(
+        `잘못된 JSON 형식입니다: ${path}`,
+        "INVALID_JSON",
+        path,
+      );
+    }
+    throw new ATEFileError(
+      `JSON 파일 읽기 실패: ${path} (${err.message})`,
+      err.code || "UNKNOWN",
+      path,
+    );
+  }
+}
+
+/**
+ * 파일 존재 여부 확인 (안전)
+ */
+export function fileExists(path: string): boolean {
+  try {
+    return existsSync(path);
+  } catch {
+    return false;
+  }
+}