@mandujs/ate 0.17.0 → 0.17.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mandujs/ate",
-  "version": "0.17.0",
+  "version": "0.17.2",
   "description": "Mandu ATE (Automation Test Engine) - extract/generate/run/report/heal/impact in one package",
   "type": "module",
   "sideEffects": false,

package/src/codegen.ts

@@ -47,8 +47,8 @@ export function generatePlaywrightSpecs(repoRoot: string, opts?: { onlyRoutes?:
   let bundle: ScenarioBundle;
   try {
     bundle = readJson<ScenarioBundle>(paths.scenariosPath);
-  } catch (err: any) {
-    throw new Error(`시나리오 번들 읽기 실패: ${err.message}`);
+  } catch (err: unknown) {
+    throw new Error(`시나리오 번들 읽기 실패: ${err instanceof Error ? err.message : String(err)}`);
   }
 
   if (!bundle.scenarios || bundle.scenarios.length === 0) {
@@ -59,15 +59,15 @@ export function generatePlaywrightSpecs(repoRoot: string, opts?: { onlyRoutes?:
   let selectorMap;
   try {
     selectorMap = readSelectorMap(repoRoot);
-  } catch (err: any) {
+  } catch (err: unknown) {
     // Selector map is optional
-    warnings.push(`Selector map 읽기 실패 (무시): ${err.message}`);
+    warnings.push(`Selector map 읽기 실패 (무시): ${err instanceof Error ? err.message : String(err)}`);
   }
 
   try {
     ensureDir(paths.autoE2eDir);
-  } catch (err: any) {
-    throw new Error(`E2E 디렉토리 생성 실패: ${err.message}`);
+  } catch (err: unknown) {
+    throw new Error(`E2E 디렉토리 생성 실패: ${err instanceof Error ? err.message : String(err)}`);
   }
 
   const files: string[] = [];
@@ -78,40 +78,69 @@ export function generatePlaywrightSpecs(repoRoot: string, opts?: { onlyRoutes?:
       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`;
+      let code: string;
+
+      if (s.kind === "api-smoke") {
+        // API route: fetch-based test
+        const methods = s.methods ?? ["GET"];
+        const testCases = methods.map((method) => {
+          return [
+            `  test(${JSON.stringify(`${method} ${s.route}`)}, async ({ baseURL }) => {`,
+            `    const url = (baseURL ?? "http://localhost:3333") + ${JSON.stringify(s.route)};`,
+            `    const res = await fetch(url, { method: ${JSON.stringify(method)} });`,
+            `    expect(res.status).toBeLessThan(500);`,
+            `    expect(res.headers.get("content-type")).toBeTruthy();`,
+            method === "GET" ? `    const body = await res.text();\n    expect(body.length).toBeGreaterThan(0);` : "",
+            `  });`,
+          ].filter(Boolean).join("\n");
+        });
+
+        code = [
+          specHeader(),
+          `test.describe(${JSON.stringify(s.id)}, () => {`,
+          ...testCases,
+          `});`,
+          "",
+        ].join("\n");
+      } else {
+        // Page route: browser-based test
+        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`;
+        }
+
+        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");
       }
 
-      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: unknown) {
+        const msg = err instanceof Error ? err.message : String(err);
+        warnings.push(`Spec 파일 쓰기 실패 (${filePath}): ${msg}`);
+        console.error(`[ATE] Spec 생성 실패: ${filePath} - ${msg}`);
       }
-    } catch (err: any) {
-      warnings.push(`Spec 생성 실패 (${s.id}): ${err.message}`);
-      console.error(`[ATE] Spec 생성 에러: ${s.id} - ${err.message}`);
+    } catch (err: unknown) {
+      const msg = err instanceof Error ? err.message : String(err);
+      warnings.push(`Spec 생성 실패 (${s.id}): ${msg}`);
+      console.error(`[ATE] Spec 생성 에러: ${s.id} - ${msg}`);
       // Continue with next scenario
     }
   }
@@ -131,9 +160,10 @@ export function generatePlaywrightSpecs(repoRoot: string, opts?: { onlyRoutes?:
         Bun.write(configPath, desiredConfig);
       }
     }
-  } catch (err: any) {
-    warnings.push(`Playwright config 생성 실패: ${err.message}`);
-    console.warn(`[ATE] Playwright config 생성 실패: ${err.message}`);
+  } catch (err: unknown) {
+    const msg = err instanceof Error ? err.message : String(err);
+    warnings.push(`Playwright config 생성 실패: ${msg}`);
+    console.warn(`[ATE] Playwright config 생성 실패: ${msg}`);
   }
 
   return { files, warnings };

package/src/dep-graph.ts

@@ -38,10 +38,10 @@ function normalizePath(path: string, rootDir: string): string {
  * Resolve import specifier to file path
  */
 function resolveImport(
-  sourceFile: any, // ts-morph SourceFile (lazy loaded)
+  sourceFile: import("./ts-morph-types").SourceFile,
   importSpecifier: string,
   rootDir: string,
-  project: any // ts-morph Project (lazy loaded)
+  project: import("./ts-morph-types").Project
 ): string | null {
   // Skip external modules (no relative/absolute path)
   if (!importSpecifier.startsWith(".") && !importSpecifier.startsWith("/")) {

package/src/extractor.ts

@@ -3,18 +3,24 @@ import { relative, join } from "node:path";
 import { createEmptyGraph, addEdge, addNode } from "./ir";
 import { getAtePaths, writeJson } from "./fs";
 import type { ExtractInput, InteractionGraph } from "./types";
+import type { Node, CallExpression, JsxAttribute, SyntaxKindEnum } from "./ts-morph-types";
 
-const DEFAULT_ROUTE_GLOBS = ["app/**/page.tsx", "routes/**/page.tsx"]; // demo-first default
+const DEFAULT_ROUTE_GLOBS = [
+  "app/**/page.tsx",
+  "app/**/route.ts",
+  "routes/**/page.tsx",
+  "routes/**/route.ts",
+];
 
-function isStringLiteral(node: any /* ts-morph Node */, SyntaxKind: any): boolean {
-  return node.getKind() === SyntaxKind.StringLiteral;
+function isStringLiteral(node: Node, SK: SyntaxKindEnum): boolean {
+  return node.getKind() === SK.StringLiteral;
 }
 
-function tryExtractLiteralArg(callExpr: any /* ts-morph CallExpression */, argIndex = 0, SyntaxKind: any): string | null {
+function tryExtractLiteralArg(callExpr: CallExpression, argIndex = 0, SK: SyntaxKindEnum): string | null {
   const args = callExpr.getArguments();
   const arg = args[argIndex];
   if (!arg) return null;
-  if (isStringLiteral(arg, SyntaxKind)) return arg.getLiteralValue();
+  if (isStringLiteral(arg, SK)) return (arg as Node & { getLiteralValue(): string }).getLiteralValue();
   return null;
 }
 
@@ -41,8 +47,8 @@ export async function extract(input: ExtractInput): Promise<{ ok: true; graphPat
       onlyFiles: true,
       ignore: ["**/node_modules/**", "**/.mandu/**"],
     });
-  } catch (err: any) {
-    throw new Error(`파일 검색 실패: ${err.message}`);
+  } catch (err: unknown) {
+    throw new Error(`파일 검색 실패: ${err instanceof Error ? err.message : String(err)}`);
   }
 
   if (routeFiles.length === 0) {
@@ -51,15 +57,16 @@ export async function extract(input: ExtractInput): Promise<{ ok: true; graphPat
 
   // Lazy load ts-morph only when needed
   const { Project, SyntaxKind } = await import("ts-morph");
+  const SK = SyntaxKind as unknown as SyntaxKindEnum;
 
-  let project: any; // ts-morph Project
+  let project: InstanceType<typeof Project>;
   try {
     project = new Project({
       tsConfigFilePath: input.tsconfigPath ? join(repoRoot, input.tsconfigPath) : undefined,
       skipAddingFilesFromTsConfig: true,
     });
-  } catch (err: any) {
-    throw new Error(`TypeScript 프로젝트 초기화 실패: ${err.message}`);
+  } catch (err: unknown) {
+    throw new Error(`TypeScript 프로젝트 초기화 실패: ${err instanceof Error ? err.message : String(err)}`);
   }
 
   for (const filePath of routeFiles) {
@@ -68,86 +75,112 @@ export async function extract(input: ExtractInput): Promise<{ ok: true; graphPat
       const rel = relative(repoRoot, filePath);
       const relNormalized = rel.replace(/\\/g, "/");
 
-      // route node id: normalize to path without trailing /page.tsx
+      const isApiRoute = relNormalized.endsWith("/route.ts");
+
+      // route node id: normalize to path without trailing /page.tsx or /route.ts
       const routePath = relNormalized
         .replace(/^app\//, "/")
         .replace(/^routes\//, "/")
         .replace(/\/page\.tsx$/, "")
+        .replace(/\/route\.ts$/, "")
         .replace(/\/index\.tsx$/, "")
         .replace(/\/page$/, "")
         .replace(/\\/g, "/");
 
-      addNode(graph, { kind: "route", id: routePath === "" ? "/" : routePath, file: relNormalized, path: routePath === "" ? "/" : routePath });
+      // API route: extract HTTP methods from exports (GET, POST, PUT, PATCH, DELETE)
+      let methods: string[] = [];
+      if (isApiRoute) {
+        const HTTP_METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"];
+        const exportDecls = sourceFile.getExportedDeclarations();
+        for (const [name] of exportDecls) {
+          if (HTTP_METHODS.includes(name)) {
+            methods.push(name);
+          }
+        }
+        if (methods.length === 0) methods = ["GET"]; // default
+      }
+
+      addNode(graph, {
+        kind: "route",
+        id: routePath === "" ? "/" : routePath,
+        file: relNormalized,
+        path: routePath === "" ? "/" : routePath,
+        ...(isApiRoute ? { methods } : {}),
+      });
+
+      // API route에는 JSX/navigation이 없으므로 건너뜀
+      if (isApiRoute) continue;
 
       // ManduLink / Link literal extraction: <Link href="/x"> or <ManduLink to="/x">
       try {
-        const jsxAttrs = sourceFile.getDescendantsOfKind(SyntaxKind.JsxAttribute);
+        const jsxAttrs = sourceFile.getDescendantsOfKind(SyntaxKind.JsxAttribute) as unknown as JsxAttribute[];
         for (const attr of jsxAttrs) {
           try {
-            const name = (attr as any).getNameNode?.().getText?.() ?? (attr as any).getName?.() ?? "";
+            const name = attr.getNameNode?.().getText?.() ?? attr.getName?.() ?? "";
             if (name !== "to" && name !== "href") continue;
-            const init = (attr as any).getInitializer?.();
+            const init = attr.getInitializer?.();
             if (!init) continue;
-            if (init.getKind?.() === SyntaxKind.StringLiteral) {
-              const raw = (init as any).getLiteralValue?.() ?? init.getText?.();
+            if (init.getKind?.() === SK.StringLiteral) {
+              const raw = init.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) {
+          } catch (err: unknown) {
             // Skip invalid JSX attributes
-            warnings.push(`JSX 속성 파싱 실패 (${relNormalized}): ${err.message}`);
+            warnings.push(`JSX 속성 파싱 실패 (${relNormalized}): ${err instanceof Error ? err.message : String(err)}`);
           }
         }
-      } catch (err: any) {
-        warnings.push(`JSX 분석 실패 (${relNormalized}): ${err.message}`);
+      } catch (err: unknown) {
+        warnings.push(`JSX 분석 실패 (${relNormalized}): ${err instanceof Error ? err.message : String(err)}`);
       }
 
       // mandu.navigate("/x") literal
       try {
-        const calls = sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression);
+        const calls = sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression) as unknown as 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);
+              const to = tryExtractLiteralArg(call, 0, SK);
               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);
+              const modal = tryExtractLiteralArg(call, 0, SK);
               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);
+              const action = tryExtractLiteralArg(call, 0, SK);
               if (action) {
                 addEdge(graph, { kind: "runAction", from: routePath || "/", action, file: relNormalized, source: "mandu.action.run" });
               }
             }
-          } catch (err: any) {
+          } catch (err: unknown) {
             // Skip invalid call expressions
-            warnings.push(`함수 호출 파싱 실패 (${relNormalized}): ${err.message}`);
+            warnings.push(`함수 호출 파싱 실패 (${relNormalized}): ${err instanceof Error ? err.message : String(err)}`);
           }
         }
-      } catch (err: any) {
-        warnings.push(`함수 호출 분석 실패 (${relNormalized}): ${err.message}`);
+      } catch (err: unknown) {
+        warnings.push(`함수 호출 분석 실패 (${relNormalized}): ${err instanceof Error ? err.message : String(err)}`);
       }
-    } catch (err: any) {
+    } catch (err: unknown) {
       // Graceful degradation: skip this file and continue
-      warnings.push(`파일 파싱 실패 (${filePath}): ${err.message}`);
-      console.warn(`[ATE] 파일 스킵: ${filePath} - ${err.message}`);
+      const msg = err instanceof Error ? err.message : String(err);
+      warnings.push(`파일 파싱 실패 (${filePath}): ${msg}`);
+      console.warn(`[ATE] 파일 스킵: ${filePath} - ${msg}`);
       continue;
     }
   }
 
   try {
     writeJson(paths.interactionGraphPath, graph);
-  } catch (err: any) {
-    throw new Error(`Interaction graph 저장 실패: ${err.message}`);
+  } catch (err: unknown) {
+    throw new Error(`Interaction graph 저장 실패: ${err instanceof Error ? err.message : String(err)}`);
   }
 
   return {

package/src/fs.ts

@@ -34,15 +34,17 @@ export function getAtePaths(repoRoot: string): AtePaths {
 export function ensureDir(path: string): void {
   try {
     mkdirSync(path, { recursive: true });
-  } catch (err: any) {
-    if (err.code === "EACCES") {
+  } catch (err: unknown) {
+    const isNodeError = err instanceof Error && "code" in err;
+    const code = isNodeError ? (err as NodeJS.ErrnoException).code : undefined;
+    if (code === "EACCES") {
       throw new ATEFileError(
         `디렉토리 생성 권한이 없습니다: ${path}`,
         "PERMISSION_DENIED",
         path,
       );
     }
-    if (err.code === "ENOSPC") {
+    if (code === "ENOSPC") {
       throw new ATEFileError(
         `디스크 공간이 부족합니다: ${path}`,
         "NO_SPACE",
@@ -50,8 +52,8 @@ export function ensureDir(path: string): void {
       );
     }
     throw new ATEFileError(
-      `디렉토리 생성 실패: ${path} (${err.message})`,
-      err.code || "UNKNOWN",
+      `디렉토리 생성 실패: ${path} (${err instanceof Error ? err.message : String(err)})`,
+      code || "UNKNOWN",
       path,
     );
   }
@@ -65,18 +67,20 @@ export function writeJson(path: string, data: unknown): void {
   try {
     ensureDir(dirname(path));
     writeFileSync(path, JSON.stringify(data, null, 2), "utf8");
-  } catch (err: any) {
+  } catch (err: unknown) {
     if (err instanceof ATEFileError) {
       throw err;
     }
-    if (err.code === "EACCES") {
+    const isNodeError = err instanceof Error && "code" in err;
+    const code = isNodeError ? (err as NodeJS.ErrnoException).code : undefined;
+    if (code === "EACCES") {
       throw new ATEFileError(
         `파일 쓰기 권한이 없습니다: ${path}`,
         "PERMISSION_DENIED",
         path,
       );
     }
-    if (err.code === "ENOSPC") {
+    if (code === "ENOSPC") {
       throw new ATEFileError(
         `디스크 공간이 부족합니다: ${path}`,
         "NO_SPACE",
@@ -84,8 +88,8 @@ export function writeJson(path: string, data: unknown): void {
       );
     }
     throw new ATEFileError(
-      `JSON 파일 쓰기 실패: ${path} (${err.message})`,
-      err.code || "UNKNOWN",
+      `JSON 파일 쓰기 실패: ${path} (${err instanceof Error ? err.message : String(err)})`,
+      code || "UNKNOWN",
       path,
     );
   }
@@ -107,11 +111,13 @@ export function readJson<T>(path: string): T {
 
     const content = readFileSync(path, "utf8");
     return JSON.parse(content) as T;
-  } catch (err: any) {
+  } catch (err: unknown) {
     if (err instanceof ATEFileError) {
       throw err;
     }
-    if (err.code === "EACCES") {
+    const isNodeError = err instanceof Error && "code" in err;
+    const code = isNodeError ? (err as NodeJS.ErrnoException).code : undefined;
+    if (code === "EACCES") {
       throw new ATEFileError(
         `파일 읽기 권한이 없습니다: ${path}`,
         "PERMISSION_DENIED",
@@ -126,8 +132,8 @@ export function readJson<T>(path: string): T {
       );
     }
     throw new ATEFileError(
-      `JSON 파일 읽기 실패: ${path} (${err.message})`,
-      err.code || "UNKNOWN",
+      `JSON 파일 읽기 실패: ${path} (${err instanceof Error ? err.message : String(err)})`,
+      code || "UNKNOWN",
       path,
     );
   }

package/src/impact.ts

@@ -39,14 +39,14 @@ export async function computeImpact(input: ImpactInput): Promise<{ changedFiles:
   // Verify git revisions
   try {
     verifyGitRev(repoRoot, base);
-  } catch (err: any) {
-    throw new Error(`잘못된 base revision: ${base} (${err.message})`);
+  } catch (err: unknown) {
+    throw new Error(`잘못된 base revision: ${base} (${err instanceof Error ? err.message : String(err)})`);
   }
 
   try {
     verifyGitRev(repoRoot, head);
-  } catch (err: any) {
-    throw new Error(`잘못된 head revision: ${head} (${err.message})`);
+  } catch (err: unknown) {
+    throw new Error(`잘못된 head revision: ${head} (${err instanceof Error ? err.message : String(err)})`);
   }
 
   let out: string;
@@ -55,8 +55,8 @@ export async function computeImpact(input: ImpactInput): Promise<{ changedFiles:
       cwd: repoRoot,
       stdio: ["ignore", "pipe", "pipe"],
     }).toString("utf8");
-  } catch (err: any) {
-    throw new Error(`Git diff 실행 실패: ${err.message}`);
+  } catch (err: unknown) {
+    throw new Error(`Git diff 실행 실패: ${err instanceof Error ? err.message : String(err)}`);
   }
 
   const changedFiles = out.split("\n").map((s) => toPosixPath(s.trim())).filter(Boolean);
@@ -71,8 +71,8 @@ export async function computeImpact(input: ImpactInput): Promise<{ changedFiles:
   let graph: InteractionGraph;
   try {
     graph = readJson<InteractionGraph>(paths.interactionGraphPath);
-  } catch (err: any) {
-    throw new Error(`Interaction graph 읽기 실패: ${err.message}`);
+  } catch (err: unknown) {
+    throw new Error(`Interaction graph 읽기 실패: ${err instanceof Error ? err.message : String(err)}`);
   }
 
   if (!graph.nodes || graph.nodes.length === 0) {
@@ -95,8 +95,8 @@ export async function computeImpact(input: ImpactInput): Promise<{ changedFiles:
       include: ["**/*.ts", "**/*.tsx", "**/*.js", "**/*.jsx"],
       exclude: ["**/node_modules/**", "**/*.test.ts", "**/*.spec.ts"],
     });
-  } catch (err: any) {
-    warnings.push(`Dependency graph 빌드 실패: ${err.message}`);
+  } catch (err: unknown) {
+    warnings.push(`Dependency graph 빌드 실패: ${err instanceof Error ? err.message : String(err)}`);
     // Fallback: only direct file matching
     const selected = new Set<string>();
     for (const changedFile of changedFiles) {
@@ -136,8 +136,8 @@ export async function computeImpact(input: ImpactInput): Promise<{ changedFiles:
           }
         }
       }
-    } catch (err: any) {
-      warnings.push(`파일 영향 분석 실패 (${changedFile}): ${err.message}`);
+    } catch (err: unknown) {
+      warnings.push(`파일 영향 분석 실패 (${changedFile}): ${err instanceof Error ? err.message : String(err)}`);
       // Continue with next file
     }
   }

package/src/pipeline.ts

@@ -57,9 +57,10 @@ export async function runFullPipeline(options: AutoPipelineOptions): Promise<Aut
       });
       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}`);
+    } catch (err: unknown) {
+      const msg = err instanceof Error ? err.message : String(err);
+      result.steps.extract.error = msg;
+      console.error(`❌ [ATE Pipeline] Extract 실패: ${msg}`);
       return result;
     }
 
@@ -72,9 +73,10 @@ export async function runFullPipeline(options: AutoPipelineOptions): Promise<Aut
       });
       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}`);
+    } catch (err: unknown) {
+      const msg = err instanceof Error ? err.message : String(err);
+      result.steps.generate.error = msg;
+      console.error(`❌ [ATE Pipeline] Generate 실패: ${msg}`);
       return result;
     }
 
@@ -100,14 +102,15 @@ export async function runFullPipeline(options: AutoPipelineOptions): Promise<Aut
         console.log(
           `✅ [ATE Pipeline] Impact Analysis 완료 - ${impact.selectedRoutes.length}개 라우트 선택됨`,
         );
-      } catch (err: any) {
+      } catch (err: unknown) {
+        const msg = err instanceof Error ? err.message : String(err);
         result.steps.impact = {
           ok: false,
           mode: "full",
           selectedRoutes: [],
-          error: err.message,
+          error: msg,
         };
-        console.warn(`⚠️ [ATE Pipeline] Impact Analysis 실패, 전체 테스트 실행: ${err.message}`);
+        console.warn(`⚠️ [ATE Pipeline] Impact Analysis 실패, 전체 테스트 실행: ${msg}`);
         // Impact analysis 실패 시에도 계속 진행 (full test)
       }
     }
@@ -132,9 +135,10 @@ export async function runFullPipeline(options: AutoPipelineOptions): Promise<Aut
       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}`);
+    } catch (err: unknown) {
+      const msg = err instanceof Error ? err.message : String(err);
+      result.steps.run.error = msg;
+      console.error(`❌ [ATE Pipeline] Run 실패: ${msg}`);
       return result;
     }
 
@@ -158,9 +162,10 @@ export async function runFullPipeline(options: AutoPipelineOptions): Promise<Aut
       });
       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}`);
+    } catch (err: unknown) {
+      const msg = err instanceof Error ? err.message : String(err);
+      result.steps.report.error = msg;
+      console.error(`❌ [ATE Pipeline] Report 실패: ${msg}`);
       return result;
     }
 
@@ -179,13 +184,14 @@ export async function runFullPipeline(options: AutoPipelineOptions): Promise<Aut
         console.log(
           `✅ [ATE Pipeline] Heal 완료 - ${healResult.suggestions?.length ?? 0}개 제안 생성됨`,
         );
-      } catch (err: any) {
+      } catch (err: unknown) {
+        const msg = err instanceof Error ? err.message : String(err);
         result.steps.heal = {
           ok: false,
           suggestionsCount: 0,
-          error: err.message,
+          error: msg,
         };
-        console.warn(`⚠️ [ATE Pipeline] Heal 실패: ${err.message}`);
+        console.warn(`⚠️ [ATE Pipeline] Heal 실패: ${msg}`);
         // Heal 실패는 전체 파이프라인 실패로 보지 않음
       }
     }
@@ -197,9 +203,9 @@ export async function runFullPipeline(options: AutoPipelineOptions): Promise<Aut
     );
 
     return result;
-  } catch (err: any) {
+  } catch (err: unknown) {
     throw new ATEFileError(
-      `파이프라인 실행 중 예상치 못한 오류: ${err.message}`,
+      `파이프라인 실행 중 예상치 못한 오류: ${err instanceof Error ? err.message : String(err)}`,
       "PIPELINE_ERROR",
       options.repoRoot,
     );

package/src/report.ts

@@ -27,8 +27,8 @@ export function composeSummary(params: {
   let oracle;
   try {
     oracle = createDefaultOracle(params.oracleLevel);
-  } catch (err: any) {
-    throw new Error(`Oracle 생성 실패: ${err.message}`);
+  } catch (err: unknown) {
+    throw new Error(`Oracle 생성 실패: ${err instanceof Error ? err.message : String(err)}`);
   }
 
   return {
@@ -74,16 +74,16 @@ export function writeSummary(repoRoot: string, runId: string, summary: SummaryJs
 
   try {
     ensureDir(runDir);
-  } catch (err: any) {
-    throw new Error(`Report 디렉토리 생성 실패: ${err.message}`);
+  } catch (err: unknown) {
+    throw new Error(`Report 디렉토리 생성 실패: ${err instanceof Error ? err.message : String(err)}`);
   }
 
   const outPath = join(runDir, "summary.json");
 
   try {
     writeJson(outPath, summary);
-  } catch (err: any) {
-    throw new Error(`Summary 파일 저장 실패: ${err.message}`);
+  } catch (err: unknown) {
+    throw new Error(`Summary 파일 저장 실패: ${err instanceof Error ? err.message : String(err)}`);
   }
 
   return outPath;
@@ -120,8 +120,8 @@ export async function generateReport(options: GenerateReportOptions): Promise<{
         includeTraces,
       });
       result.html = htmlResult.path;
-    } catch (err: any) {
-      throw new Error(`HTML 리포트 생성 실패: ${err.message}`);
+    } catch (err: unknown) {
+      throw new Error(`HTML 리포트 생성 실패: ${err instanceof Error ? err.message : String(err)}`);
     }
   }
 

package/src/reporter/html.ts

@@ -40,8 +40,8 @@ export async function generateHtmlReport(options: HtmlReportOptions): Promise<Ht
   try {
     const content = readFileSync(summaryPath, "utf-8");
     summary = JSON.parse(content);
-  } catch (err: any) {
-    throw new Error(`Summary 파일 읽기 실패: ${err.message}`);
+  } catch (err: unknown) {
+    throw new Error(`Summary 파일 읽기 실패: ${err instanceof Error ? err.message : String(err)}`);
   }
 
   // 2. 스크린샷 URL 수집 (선택)
@@ -57,8 +57,8 @@ export async function generateHtmlReport(options: HtmlReportOptions): Promise<Ht
             screenshotUrls.push(`./screenshots/${f}`);
           });
       }
-    } catch (err: any) {
-      console.warn(`스크린샷 수집 실패: ${err.message}`);
+    } catch (err: unknown) {
+      console.warn(`스크린샷 수집 실패: ${err instanceof Error ? err.message : String(err)}`);
     }
   }
 
@@ -70,8 +70,8 @@ export async function generateHtmlReport(options: HtmlReportOptions): Promise<Ht
   try {
     ensureDir(join(htmlPath, "..")); // 상위 디렉토리 확인
     writeFileSync(htmlPath, html, "utf-8");
-  } catch (err: any) {
-    throw new Error(`HTML 파일 저장 실패: ${err.message}`);
+  } catch (err: unknown) {
+    throw new Error(`HTML 파일 저장 실패: ${err instanceof Error ? err.message : String(err)}`);
   }
 
   const size = Buffer.byteLength(html, "utf-8");

package/src/runner.ts

@@ -31,8 +31,8 @@ export async function runPlaywright(input: RunInput): Promise<RunResult> {
   try {
     ensureDir(runDir);
     ensureDir(latestDir);
-  } catch (err: any) {
-    throw new Error(`Report 디렉토리 생성 실패: ${err.message}`);
+  } catch (err: unknown) {
+    throw new Error(`Report 디렉토리 생성 실패: ${err instanceof Error ? err.message : String(err)}`);
   }
 
   const baseURL = input.baseURL ?? process.env.BASE_URL ?? "http://localhost:3333";
@@ -57,8 +57,8 @@ export async function runPlaywright(input: RunInput): Promise<RunResult> {
       stdio: "inherit",
       env,
     });
-  } catch (err: any) {
-    throw new Error(`Playwright 프로세스 시작 실패: ${err.message}`);
+  } catch (err: unknown) {
+    throw new Error(`Playwright 프로세스 시작 실패: ${err instanceof Error ? err.message : String(err)}`);
   }
 
   const exitCode: number = await new Promise((resolve, reject) => {
@@ -91,8 +91,8 @@ export async function runPlaywright(input: RunInput): Promise<RunResult> {
   // record minimal run metadata
   try {
     writeJson(join(runDir, "run.json"), { ...result, baseURL, at: new Date().toISOString() });
-  } catch (err: any) {
-    console.warn(`[ATE] Run metadata 저장 실패: ${err.message}`);
+  } catch (err: unknown) {
+    console.warn(`[ATE] Run metadata 저장 실패: ${err instanceof Error ? err.message : String(err)}`);
     // Non-fatal: continue
   }
 

package/src/scenario.ts

@@ -3,8 +3,9 @@ import { getAtePaths, readJson, writeJson } from "./fs";
 
 export interface GeneratedScenario {
   id: string;
-  kind: "route-smoke";
+  kind: "route-smoke" | "api-smoke";
   route: string;
+  methods?: string[];
   oracleLevel: OracleLevel;
 }
 
@@ -28,18 +29,22 @@ export function generateScenariosFromGraph(graph: InteractionGraph, oracleLevel:
     throw new Error("빈 interaction graph입니다 (nodes가 없습니다)");
   }
 
-  const routes = graph.nodes.filter((n) => n.kind === "route") as Array<{ kind: "route"; id: string; path: string }>;
+  const routes = graph.nodes.filter((n) => n.kind === "route") as Array<{ kind: "route"; id: string; path: string; methods?: string[] }>;
 
   if (routes.length === 0) {
     console.warn("[ATE] 경고: route가 없습니다. 빈 시나리오 번들을 생성합니다.");
   }
 
-  const scenarios: GeneratedScenario[] = routes.map((r) => ({
-    id: `route:${r.id}`,
-    kind: "route-smoke",
-    route: r.id,
-    oracleLevel,
-  }));
+  const scenarios: GeneratedScenario[] = routes.map((r) => {
+    const isApi = r.path.startsWith("/api/") || (r.methods && r.methods.length > 0);
+    return {
+      id: `${isApi ? "api" : "route"}:${r.id}`,
+      kind: isApi ? "api-smoke" : "route-smoke",
+      route: r.id,
+      ...(isApi && r.methods ? { methods: r.methods } : {}),
+      oracleLevel,
+    };
+  });
 
   return {
     schemaVersion: 1,
@@ -55,16 +60,16 @@ export function generateAndWriteScenarios(repoRoot: string, oracleLevel: OracleL
   let graph: InteractionGraph;
   try {
     graph = readJson<InteractionGraph>(paths.interactionGraphPath);
-  } catch (err: any) {
-    throw new Error(`Interaction graph 읽기 실패: ${err.message}`);
+  } catch (err: unknown) {
+    throw new Error(`Interaction graph 읽기 실패: ${err instanceof Error ? err.message : String(err)}`);
   }
 
   const bundle = generateScenariosFromGraph(graph, oracleLevel);
 
   try {
     writeJson(paths.scenariosPath, bundle);
-  } catch (err: any) {
-    throw new Error(`시나리오 파일 저장 실패: ${err.message}`);
+  } catch (err: unknown) {
+    throw new Error(`시나리오 파일 저장 실패: ${err instanceof Error ? err.message : String(err)}`);
   }
 
   return { scenariosPath: paths.scenariosPath, count: bundle.scenarios.length };

package/src/ts-morph-types.ts

@@ -0,0 +1,60 @@
+/**
+ * Lightweight type interfaces for ts-morph (lazily imported).
+ * These mirror the subset of ts-morph API used by ATE,
+ * avoiding a hard compile-time dependency on ts-morph.
+ */
+
+/** Minimal ts-morph Node interface */
+export interface Node {
+  getKind(): number;
+  getText(): string;
+  getDescendantsOfKind(kind: number): Node[];
+}
+
+/** ts-morph JsxAttribute */
+export interface JsxAttribute extends Node {
+  getNameNode?(): { getText(): string };
+  getName?(): string;
+  getInitializer?(): (Node & { getLiteralValue?(): string }) | undefined;
+}
+
+/** ts-morph CallExpression */
+export interface CallExpression extends Node {
+  getExpression(): Node;
+  getArguments(): (Node & { getLiteralValue?(): string })[];
+}
+
+/** ts-morph SourceFile */
+export interface SourceFile extends Node {
+  getFilePath(): string;
+  getExportedDeclarations(): ReadonlyMap<string, Node[]>;
+  getDescendantsOfKind(kind: number): Node[];
+  getImportDeclarations(): ImportDeclaration[];
+  getExportDeclarations(): ExportDeclaration[];
+}
+
+/** ts-morph ImportDeclaration */
+export interface ImportDeclaration extends Node {
+  getModuleSpecifierValue(): string;
+}
+
+/** ts-morph ExportDeclaration */
+export interface ExportDeclaration extends Node {
+  getModuleSpecifier(): (Node & { getLiteralText(): string }) | undefined;
+}
+
+/** ts-morph Project */
+export interface Project {
+  addSourceFileAtPath(filePath: string): SourceFile;
+  addSourceFilesAtPaths(globs: string[]): SourceFile[];
+  getSourceFile(filePath: string): SourceFile | undefined;
+  getSourceFiles(): SourceFile[];
+}
+
+/** SyntaxKind enum-like object used via dynamic import */
+export interface SyntaxKindEnum {
+  StringLiteral: number;
+  JsxAttribute: number;
+  CallExpression: number;
+  [key: string]: string | number;
+}

package/src/types.ts

@@ -36,7 +36,7 @@ export interface InteractionGraph {
 }
 
 export type InteractionNode =
-  | { kind: "route"; id: string; file: string; path: string }
+  | { kind: "route"; id: string; file: string; path: string; methods?: string[] }
   | { kind: "modal"; id: string; file: string; name: string }
   | { kind: "action"; id: string; file: string; name: string };