qat-cli 0.3.1 → 0.3.3

package/dist/index.js

@@ -955,12 +955,36 @@ Handlebars.registerHelper("propTestValue", (prop) => {
   };
   return map[prop.type] || "'test-value'";
 });
+function resolveImportPath(testType, targetPath) {
+  if (!targetPath) return targetPath;
+  const testDirMap = {
+    unit: "tests/unit",
+    component: "tests/component",
+    e2e: "tests/e2e",
+    api: "tests/api",
+    visual: "tests/visual",
+    performance: "tests/e2e"
+  };
+  const testDir = testDirMap[testType];
+  if (!testDir) return targetPath;
+  if (targetPath.startsWith("../") || targetPath.startsWith("./../")) {
+    return targetPath;
+  }
+  const depth = testDir.split("/").length;
+  const prefix = "../".repeat(depth);
+  let cleanPath = targetPath.replace(/^\.\//, "");
+  if (!cleanPath.endsWith(".vue")) {
+    cleanPath = cleanPath.replace(/\.(ts|js|tsx|jsx)$/, "");
+  }
+  return `${prefix}${cleanPath}`;
+}
 function registerTemplate(type, templateContent) {
   customTemplates.set(type, templateContent);
 }
 function renderTemplate(type, context) {
   const templateContent = loadTemplate(type);
   const template = Handlebars.compile(templateContent);
+  const resolvedTarget = resolveImportPath(type, context.target);
   const fullContext = {
     vueVersion: 3,
     typescript: true,
@@ -981,6 +1005,8 @@ function renderTemplate(type, context) {
     requiredProps: [],
     optionalProps: [],
     ...context,
+    // 使用计算后的正确路径
+    target: resolvedTarget,
     framework: context.framework || "vue",
     camelName: context.camelName || toCamelCase(context.name),
     pascalName: context.pascalName || toPascalCase(context.name)
@@ -1623,12 +1649,23 @@ function generateHTMLReport(data) {
 // src/runners/vitest-runner.ts
 import { execFile } from "child_process";
 import path5 from "path";
+import fs6 from "fs";
+import os from "os";
+var isVerbose = () => process.env.QAT_VERBOSE === "true";
+function debug(label, ...args) {
+  if (isVerbose()) {
+    console.log(`\x1B[90m  [debug:${label}]\x1B[0m`, ...args);
+  }
+}
 async function runVitest(options) {
   const startTime = Date.now();
   const args = buildVitestArgs(options);
+  debug("vitest", "\u547D\u4EE4\u53C2\u6570:", args.join(" "));
   try {
     const result = await execVitest(args);
     const endTime = Date.now();
+    debug("vitest", `\u89E3\u6790\u7ED3\u679C: ${result.suites.length} \u4E2A\u5957\u4EF6, ${result.suites.reduce((s, su) => s + su.tests.length, 0)} \u4E2A\u7528\u4F8B`);
+    debug("vitest", "\u89E3\u6790\u65B9\u5F0F:", result.parseMethod);
     return {
       type: options.type,
       status: result.success ? "passed" : "failed",
@@ -1671,14 +1708,14 @@ function buildVitestArgs(options) {
   if (options.files && options.files.length > 0) {
     args.push(...options.files);
   } else {
-    const includeMap = {
-      unit: ["tests/unit"],
-      component: ["tests/component"],
-      api: ["tests/api"]
+    const pathMap = {
+      unit: "tests/unit/**/*.test.ts",
+      component: "tests/component/**/*.test.ts",
+      api: "tests/api/**/*.test.ts"
     };
-    const includes = includeMap[options.type];
-    if (includes) {
-      args.push("--include", includes.map((d) => `${d}/**/*.test.ts`).join(","));
+    const testPattern = pathMap[options.type];
+    if (testPattern) {
+      args.push(testPattern);
     }
   }
   if (options.coverage) {
@@ -1693,12 +1730,11 @@ function buildVitestArgs(options) {
   return args;
 }
 async function execVitest(args) {
-  const os = await import("os");
-  const fs9 = await import("fs");
   const tmpFile = path5.join(os.tmpdir(), `qat-vitest-result-${Date.now()}.json`);
   const argsWithOutput = [...args, "--outputFile", tmpFile];
   return new Promise((resolve, reject) => {
     const npx = process.platform === "win32" ? "npx.cmd" : "npx";
+    debug("vitest", "\u6267\u884C\u547D\u4EE4:", npx, argsWithOutput.join(" "));
     const child = execFile(npx, argsWithOutput, {
       cwd: process.cwd(),
       env: { ...process.env, FORCE_COLOR: "0", NO_COLOR: "1" },
@@ -1706,85 +1742,113 @@ async function execVitest(args) {
       shell: true
     }, (error, stdout, stderr) => {
       const rawOutput = stdout || stderr || "";
+      const exitCode = error && "code" in error ? error.code : 0;
+      debug("vitest", `\u9000\u51FA\u7801: ${exitCode}`);
+      debug("vitest", `stdout \u957F\u5EA6: ${stdout?.length || 0}, stderr \u957F\u5EA6: ${stderr?.length || 0}`);
       let jsonResult = null;
       try {
-        if (fs9.existsSync(tmpFile)) {
-          jsonResult = fs9.readFileSync(tmpFile, "utf-8");
-          fs9.unlinkSync(tmpFile);
+        if (fs6.existsSync(tmpFile)) {
+          jsonResult = fs6.readFileSync(tmpFile, "utf-8");
+          debug("vitest", `\u4ECE\u4E34\u65F6\u6587\u4EF6\u8BFB\u53D6\u5230 JSON (${jsonResult.length} \u5B57\u7B26)`);
+          debug("vitest", "JSON \u524D 500 \u5B57\u7B26:", jsonResult.substring(0, 500));
+          fs6.unlinkSync(tmpFile);
+        } else {
+          debug("vitest", "\u4E34\u65F6\u6587\u4EF6\u4E0D\u5B58\u5728:", tmpFile);
         }
-      } catch {
+      } catch (e) {
+        debug("vitest", "\u4E34\u65F6\u6587\u4EF6\u8BFB\u53D6\u5931\u8D25:", e instanceof Error ? e.message : String(e));
       }
       if (jsonResult) {
         try {
-          const parsed = parseVitestJSONResult(jsonResult);
-          resolve({ ...parsed, rawOutput });
+          const parsed = parseVitestJSON(jsonResult);
+          debug("vitest", "\u4ECE\u4E34\u65F6\u6587\u4EF6\u89E3\u6790\u6210\u529F:", parsed.suites.length, "\u4E2A\u5957\u4EF6");
+          resolve({ ...parsed, rawOutput, parseMethod: "outputFile-JSON" });
           return;
-        } catch {
+        } catch (e) {
+          debug("vitest", "\u4E34\u65F6\u6587\u4EF6 JSON \u89E3\u6790\u5931\u8D25:", e instanceof Error ? e.message : String(e));
         }
       }
+      debug("vitest", "\u5C1D\u8BD5\u4ECE stdout \u63D0\u53D6 JSON...");
       try {
-        const parsed = parseVitestJSONOutput(rawOutput);
-        resolve({ ...parsed, rawOutput });
-      } catch {
-        if (rawOutput) {
-          resolve({ ...parseVitestTextOutput(rawOutput, !!error), rawOutput });
-        } else if (error && error.message.includes("ENOENT")) {
-          reject(new Error("\u672A\u627E\u5230 vitest\uFF0C\u8BF7\u786E\u4FDD\u5DF2\u5B89\u88C5: npm install -D vitest"));
-        } else {
-          resolve({ success: !error, suites: [], rawOutput });
-        }
+        const parsed = parseFromStdout(rawOutput);
+        debug("vitest", "\u4ECE stdout \u89E3\u6790\u6210\u529F:", parsed.suites.length, "\u4E2A\u5957\u4EF6");
+        resolve({ ...parsed, rawOutput, parseMethod: "stdout-JSON" });
+        return;
+      } catch (e) {
+        debug("vitest", "stdout JSON \u89E3\u6790\u5931\u8D25:", e instanceof Error ? e.message : String(e));
+      }
+      debug("vitest", "\u5C1D\u8BD5\u4ECE\u6587\u672C\u8F93\u51FA\u89E3\u6790...");
+      if (rawOutput) {
+        const parsed = parseVitestTextOutput(rawOutput, !!error);
+        debug("vitest", "\u6587\u672C\u89E3\u6790\u7ED3\u679C:", parsed.suites.length, "\u4E2A\u5957\u4EF6");
+        resolve({ ...parsed, rawOutput, parseMethod: "text-fallback" });
+        return;
       }
+      if (error && error.message.includes("ENOENT")) {
+        reject(new Error("\u672A\u627E\u5230 vitest\uFF0C\u8BF7\u786E\u4FDD\u5DF2\u5B89\u88C5: npm install -D vitest"));
+        return;
+      }
+      debug("vitest", "\u6240\u6709\u89E3\u6790\u65B9\u5F0F\u5747\u5931\u8D25\uFF0C\u8FD4\u56DE\u7A7A\u7ED3\u679C");
+      resolve({ success: !error, suites: [], rawOutput, parseMethod: "none" });
     });
     child.on("error", (err) => {
       try {
-        fs9.unlinkSync(tmpFile);
+        fs6.unlinkSync(tmpFile);
       } catch {
       }
       reject(new Error(`Vitest \u6267\u884C\u5931\u8D25: ${err.message}`));
     });
   });
 }
-function parseVitestJSONResult(jsonStr) {
+function parseVitestJSON(jsonStr) {
   const data = JSON.parse(jsonStr);
   const suites = [];
+  debug("vitest-json", "JSON \u9876\u5C42\u5B57\u6BB5:", Object.keys(data).join(", "));
   if (data.testResults && Array.isArray(data.testResults)) {
+    debug("vitest-json", `testResults \u6570\u91CF: ${data.testResults.length}`);
     for (const fileResult of data.testResults) {
+      const suiteTests = parseTestResults(fileResult);
+      suites.push({
+        name: path5.basename(fileResult.name || "unknown"),
+        file: fileResult.name || "unknown",
+        type: "unit",
+        status: mapVitestStatus(fileResult.status),
+        duration: fileResult.duration || 0,
+        tests: suiteTests
+      });
+    }
+  }
+  if (suites.length === 0 && data.numTotalTests !== void 0) {
+    debug("vitest-json", `\u4F7F\u7528\u6C47\u603B\u683C\u5F0F: total=${data.numTotalTests}, passed=${data.numPassedTests}`);
+    suites.push({
+      name: "Vitest Results",
+      file: "unknown",
+      type: "unit",
+      status: data.numFailedTests > 0 ? "failed" : "passed",
+      duration: 0,
+      tests: buildTestsFromSummary(data)
+    });
+  }
+  if (suites.length === 0 && data.suites && Array.isArray(data.suites)) {
+    debug("vitest-json", `suites \u6570\u91CF: ${data.suites.length}`);
+    for (const suiteData of data.suites) {
       const suiteTests = [];
-      const assertions = fileResult.assertionResults || fileResult.tests || [];
-      for (const assertion of assertions) {
+      for (const test of suiteData.tests || []) {
         suiteTests.push({
-          name: assertion.title || assertion.fullName || assertion.name || "unknown",
-          file: fileResult.name || "unknown",
-          status: mapVitestStatus(assertion.status),
-          duration: assertion.duration || 0,
-          error: assertion.failureMessages?.length ? { message: assertion.failureMessages[0] } : assertion.failureMessage ? { message: assertion.failureMessage } : void 0,
+          name: test.name || test.title || "unknown",
+          file: test.file || suiteData.file || "unknown",
+          status: mapVitestStatus(test.status || test.result?.status),
+          duration: test.duration || test.result?.duration || 0,
+          error: test.result?.errors?.[0] ? { message: test.result.errors[0].message || String(test.result.errors[0]) } : void 0,
           retries: 0
         });
       }
-      if (suiteTests.length === 0 && fileResult.numPassingTests !== void 0) {
-        const counts = [
-          { n: fileResult.numPassingTests || 0, s: "passed" },
-          { n: fileResult.numFailingTests || 0, s: "failed" },
-          { n: fileResult.numPendingTests || 0, s: "skipped" }
-        ];
-        for (const { n, s } of counts) {
-          for (let i = 0; i < n; i++) {
-            suiteTests.push({
-              name: `${s} test ${i + 1}`,
-              file: fileResult.name || "unknown",
-              status: s,
-              duration: 0,
-              retries: 0
-            });
-          }
-        }
-      }
       suites.push({
-        name: path5.basename(fileResult.name || "unknown"),
-        file: fileResult.name || "unknown",
+        name: suiteData.name || "unknown",
+        file: suiteData.file || "unknown",
         type: "unit",
-        status: mapVitestStatus(fileResult.status),
-        duration: fileResult.duration || 0,
+        status: suiteTests.some((t) => t.status === "failed") ? "failed" : "passed",
+        duration: 0,
         tests: suiteTests
       });
     }
@@ -1793,58 +1857,101 @@ function parseVitestJSONResult(jsonStr) {
   if (data.coverageMap) {
     coverage = extractCoverage(data.coverageMap);
   }
-  const success = data.success !== false && data.numFailedTests === void 0 ? suites.every((s) => s.status !== "failed") : (data.numFailedTests || 0) === 0;
+  if (!coverage && data.coverage && typeof data.coverage === "object") {
+    const cov = data.coverage;
+    const totals = cov.totals || cov;
+    const getVal = (key) => {
+      const v = totals[key];
+      return typeof v === "number" ? v : typeof v === "object" && v !== null && "pct" in v ? v.pct / 100 : 0;
+    };
+    coverage = {
+      lines: getVal("lines"),
+      statements: getVal("statements"),
+      functions: getVal("functions"),
+      branches: getVal("branches")
+    };
+  }
+  const success = data.success !== false ? data.numFailedTests !== void 0 ? data.numFailedTests === 0 : suites.every((s) => s.status !== "failed") : false;
   return { success, suites, coverage };
 }
-function parseVitestJSONOutput(output) {
-  const jsonMatch = output.match(/\{[\s\S]*"testResults"[\s\S]*\}/);
-  if (!jsonMatch) {
-    return parseVitestTextOutput(output, false);
+function parseTestResults(fileResult) {
+  const tests = [];
+  const assertions = fileResult.assertionResults || fileResult.tests || [];
+  for (const assertion of assertions) {
+    tests.push({
+      name: assertion.title || assertion.fullName || assertion.name || "unknown",
+      file: fileResult.name || "unknown",
+      status: mapVitestStatus(assertion.status),
+      duration: assertion.duration || 0,
+      error: assertion.failureMessages?.length ? { message: assertion.failureMessages[0] } : assertion.failureMessage ? { message: assertion.failureMessage } : void 0,
+      retries: 0
+    });
   }
-  try {
+  if (tests.length === 0 && fileResult.numPassingTests !== void 0) {
+    tests.push(...buildTestsFromSummary(fileResult));
+  }
+  return tests;
+}
+function buildTestsFromSummary(data) {
+  const tests = [];
+  const counts = [
+    [data.numPassedTests || 0, "passed"],
+    [data.numFailedTests || 0, "failed"],
+    [data.numPendingTests || 0, "skipped"]
+  ];
+  for (const [n, s] of counts) {
+    for (let i = 0; i < n; i++) {
+      tests.push({
+        name: `${s} test ${i + 1}`,
+        file: data.name || "unknown",
+        status: s,
+        duration: 0,
+        retries: 0
+      });
+    }
+  }
+  return tests;
+}
+function parseFromStdout(output) {
+  const jsonMatch = output.match(/\{[\s\S]*"testResults"[\s\S]*\}/);
+  if (jsonMatch) {
     const data = JSON.parse(jsonMatch[0]);
     const suites = [];
     if (data.testResults && Array.isArray(data.testResults)) {
       for (const fileResult of data.testResults) {
-        const suite = {
-          name: path5.basename(fileResult.name || fileResult.assertionResults?.[0]?.ancestorTitles?.[0] || "unknown"),
+        suites.push({
+          name: path5.basename(fileResult.name || "unknown"),
           file: fileResult.name || "unknown",
           type: "unit",
           status: mapVitestStatus(fileResult.status),
           duration: fileResult.duration || 0,
-          tests: (fileResult.assertionResults || []).map((assertion) => ({
-            name: assertion.title || assertion.fullName || "unknown",
-            file: fileResult.name || "unknown",
-            status: mapVitestStatus(assertion.status),
-            duration: assertion.duration || 0,
-            error: assertion.failureMessages?.length ? { message: assertion.failureMessages[0] } : void 0,
-            retries: 0
-          }))
-        };
-        suites.push(suite);
+          tests: parseTestResults(fileResult)
+        });
       }
     }
-    let coverage;
-    if (data.coverageMap) {
-      coverage = extractCoverage(data.coverageMap);
-    }
     const success = data.success !== false && suites.every((s) => s.status !== "failed");
+    let coverage;
+    if (data.coverageMap) coverage = extractCoverage(data.coverageMap);
     return { success, suites, coverage };
-  } catch {
-    return parseVitestTextOutput(output, false);
   }
+  const anyJsonMatch = output.match(/\{[\s\S]*"numTotalTests"[\s\S]*\}/);
+  if (anyJsonMatch) {
+    return parseVitestJSON(anyJsonMatch[0]);
+  }
+  throw new Error("stdout \u4E2D\u672A\u627E\u5230\u6709\u6548 JSON");
 }
 function parseVitestTextOutput(output, hasError) {
   const suites = [];
+  debug("vitest-text", "\u6587\u672C\u8F93\u51FA\u524D 1000 \u5B57\u7B26:", output.substring(0, 1e3));
+  const suiteRegex = /[✓✗×✕]\s+(.+\.test\.(ts|js)|.+\.spec\.(ts|js))\s*\((\d+)[^)]*\)/i;
+  const lines = output.split("\n");
   let totalPassed = 0;
   let totalFailed = 0;
-  const suiteRegex = /[✓✗×]\s+(.+\.test\.ts|.+\.spec\.ts)\s*\((\d+)\s+test/i;
-  const lines = output.split("\n");
   for (const line of lines) {
     const match = line.match(suiteRegex);
     if (match) {
       const file = match[1];
-      const testCount = parseInt(match[2], 10);
+      const testCount = parseInt(match[4], 10);
       const isPassed = line.includes("\u2713");
       if (isPassed) totalPassed += testCount;
       else totalFailed += testCount;
@@ -1864,15 +1971,39 @@ function parseVitestTextOutput(output, hasError) {
       });
     }
   }
+  if (suites.length === 0) {
+    const summaryMatch = output.match(/Tests\s+(\d+)\s+(passed|failed)/i);
+    if (summaryMatch) {
+      const count = parseInt(summaryMatch[1], 10);
+      const status = summaryMatch[2].toLowerCase() === "passed" ? "passed" : "failed";
+      suites.push({
+        name: "Vitest Summary",
+        file: "unknown",
+        type: "unit",
+        status,
+        duration: 0,
+        tests: Array.from({ length: count }, (_, i) => ({
+          name: `test ${i + 1}`,
+          file: "unknown",
+          status,
+          duration: 0,
+          retries: 0
+        }))
+      });
+    }
+  }
+  debug("vitest-text", `\u89E3\u6790\u5230 ${suites.length} \u4E2A\u5957\u4EF6, ${totalPassed} \u901A\u8FC7, ${totalFailed} \u5931\u8D25`);
   return {
     success: !hasError || totalFailed === 0,
     suites
   };
 }
 function mapVitestStatus(status) {
+  if (!status) return "pending";
   switch (status) {
     case "passed":
     case "pass":
+    case "done":
       return "passed";
     case "failed":
     case "fail":
@@ -1880,6 +2011,7 @@ function mapVitestStatus(status) {
     case "skipped":
     case "skip":
     case "pending":
+    case "todo":
       return "skipped";
     default:
       return "pending";
@@ -2566,8 +2698,13 @@ ${error.actual ? `\u5B9E\u9645\u503C: ${error.actual}` : ""}`;
 6. \u5982\u679C\u6709 props/emits \u4FE1\u606F\uFF0C\u52A1\u5FC5\u9488\u5BF9\u6BCF\u4E2A prop \u548C emit \u751F\u6210\u6D4B\u8BD5`;
   }
   buildGenerateTestUserPrompt(req) {
+    const importPath = this.computeTestImportPath(req.type, req.target);
     let prompt = `\u8BF7\u4E3A\u4EE5\u4E0B\u6587\u4EF6\u751F\u6210${req.type}\u6D4B\u8BD5\u4EE3\u7801:
 \u76EE\u6807\u6587\u4EF6: ${req.target}
+\u6D4B\u8BD5\u6587\u4EF6\u5C06\u653E\u5728: ${this.getTestOutputDir(req.type)}/
+\u6B63\u786E\u7684 import \u8DEF\u5F84: ${importPath}
+
+\u91CD\u8981\uFF1Aimport \u8BED\u53E5\u4E2D\u5FC5\u987B\u4F7F\u7528\u4E0A\u8FF0\u6B63\u786E\u7684\u76F8\u5BF9\u8DEF\u5F84 ${importPath}\uFF0C\u4E0D\u8981\u4F7F\u7528 ${req.target} \u6216\u5176\u4ED6\u8DEF\u5F84\uFF01
 `;
     if (req.analysis) {
       prompt += "\n\u6E90\u7801\u5206\u6790\u7ED3\u679C:\n";
@@ -2617,6 +2754,46 @@ ${req.context}
     }
     return prompt;
   }
+  /**
+   * 根据测试类型和源文件路径，计算从测试文件到源文件的正确相对导入路径
+   */
+  computeTestImportPath(testType, targetPath) {
+    if (!targetPath) return targetPath;
+    const testDirMap = {
+      unit: "tests/unit",
+      component: "tests/component",
+      e2e: "tests/e2e",
+      api: "tests/api",
+      visual: "tests/visual",
+      performance: "tests/e2e"
+    };
+    const testDir = testDirMap[testType];
+    if (!testDir) return targetPath;
+    if (targetPath.startsWith("../") || targetPath.startsWith("./../")) {
+      return targetPath;
+    }
+    const depth = testDir.split("/").length;
+    const prefix = "../".repeat(depth);
+    let cleanPath = targetPath.replace(/^\.\//, "");
+    if (!cleanPath.endsWith(".vue")) {
+      cleanPath = cleanPath.replace(/\.(ts|js|tsx|jsx)$/, "");
+    }
+    return `${prefix}${cleanPath}`;
+  }
+  /**
+   * 获取测试输出目录
+   */
+  getTestOutputDir(testType) {
+    const dirMap = {
+      unit: "tests/unit",
+      component: "tests/component",
+      e2e: "tests/e2e",
+      api: "tests/api",
+      visual: "tests/visual",
+      performance: "tests/e2e"
+    };
+    return dirMap[testType] || "tests/unit";
+  }
   parseGenerateTestResponse(content) {
     const codeBlockMatch = content.match(/```(?:typescript|ts|javascript|js)?\s*\n([\s\S]*?)```/);
     const code = codeBlockMatch ? codeBlockMatch[1].trim() : content.replace(/^(?:```[\s\S]*?\n)?/, "").replace(/\n?```$/, "").trim();
@@ -2645,10 +2822,12 @@ ISSUES: \u95EE\u9898\u5217\u8868\uFF08\u6BCF\u884C\u4E00\u4E2A\uFF0C\u683C\u5F0F
 SUGGESTIONS: \u6539\u8FDB\u5EFA\u8BAE\u5217\u8868\uFF08\u6BCF\u884C\u4E00\u4E2A\uFF0C\u683C\u5F0F "- \u5EFA\u8BAE\u63CF\u8FF0"\uFF09`;
   }
   buildReviewTestUserPrompt(req) {
+    const importPath = this.computeTestImportPath(req.testType, req.target);
     let prompt = `\u8BF7\u5BA1\u67E5\u4EE5\u4E0B\u6D4B\u8BD5\u7528\u4F8B\u662F\u5426\u4E0E\u6E90\u7801\u8D34\u5207\u4E14\u51C6\u786E\u3002
 
 \u88AB\u6D4B\u6587\u4EF6: ${req.target}
 \u6D4B\u8BD5\u7C7B\u578B: ${req.testType}
+\u6B63\u786E\u7684 import \u8DEF\u5F84\u5E94\u4E3A: ${importPath}\uFF08\u6D4B\u8BD5\u6587\u4EF6\u4F4D\u4E8E ${this.getTestOutputDir(req.testType)}/\uFF09
 
 --- \u6E90\u7801\u5185\u5BB9 ---
 \`\`\`typescript
@@ -2816,7 +2995,7 @@ async function testAIConnection(config) {
 }
 
 // src/services/mock-server.ts
-import fs6 from "fs";
+import fs7 from "fs";
 import path7 from "path";
 var serverState = {
   running: false,
@@ -2829,18 +3008,18 @@ function getMockServerState() {
 }
 async function loadMockRoutes(routesDir) {
   const absDir = path7.resolve(process.cwd(), routesDir);
-  if (!fs6.existsSync(absDir)) {
+  if (!fs7.existsSync(absDir)) {
     return [];
   }
   const routes = [];
-  const entries = fs6.readdirSync(absDir, { withFileTypes: true });
+  const entries = fs7.readdirSync(absDir, { withFileTypes: true });
   for (const entry of entries) {
     if (!entry.isFile()) continue;
     const filePath = path7.join(absDir, entry.name);
     const ext = path7.extname(entry.name);
     try {
       if (ext === ".json") {
-        const content = fs6.readFileSync(filePath, "utf-8");
+        const content = fs7.readFileSync(filePath, "utf-8");
         const parsed = JSON.parse(content);
         if (Array.isArray(parsed)) {
           routes.push(...parsed);
@@ -3032,11 +3211,11 @@ function generateMockRouteTemplate(name) {
 }
 function initMockRoutesDir(routesDir) {
   const absDir = path7.resolve(process.cwd(), routesDir);
-  if (!fs6.existsSync(absDir)) {
-    fs6.mkdirSync(absDir, { recursive: true });
+  if (!fs7.existsSync(absDir)) {
+    fs7.mkdirSync(absDir, { recursive: true });
   }
   const examplePath = path7.join(absDir, "example.json");
-  if (!fs6.existsSync(examplePath)) {
+  if (!fs7.existsSync(examplePath)) {
     const exampleRoutes = [
       {
         method: "GET",
@@ -3060,24 +3239,24 @@ function initMockRoutesDir(routesDir) {
         }
       }
     ];
-    fs6.writeFileSync(examplePath, JSON.stringify(exampleRoutes, null, 2), "utf-8");
+    fs7.writeFileSync(examplePath, JSON.stringify(exampleRoutes, null, 2), "utf-8");
   }
 }
 
 // src/services/visual.ts
-import fs7 from "fs";
+import fs8 from "fs";
 import path8 from "path";
 import pixelmatch from "pixelmatch";
 import { PNG } from "pngjs";
 function compareImages(baselinePath, currentPath, diffOutputPath, threshold = 0.1) {
-  if (!fs7.existsSync(baselinePath)) {
+  if (!fs8.existsSync(baselinePath)) {
     throw new Error(`\u57FA\u7EBF\u56FE\u7247\u4E0D\u5B58\u5728: ${baselinePath}`);
   }
-  if (!fs7.existsSync(currentPath)) {
+  if (!fs8.existsSync(currentPath)) {
     throw new Error(`\u5F53\u524D\u56FE\u7247\u4E0D\u5B58\u5728: ${currentPath}`);
   }
-  const baseline = PNG.sync.read(fs7.readFileSync(baselinePath));
-  const current = PNG.sync.read(fs7.readFileSync(currentPath));
+  const baseline = PNG.sync.read(fs8.readFileSync(baselinePath));
+  const current = PNG.sync.read(fs8.readFileSync(currentPath));
   if (baseline.width !== current.width || baseline.height !== current.height) {
     return {
       passed: false,
@@ -3106,10 +3285,10 @@ function compareImages(baselinePath, currentPath, diffOutputPath, threshold = 0.
   let diffPath;
   if (diffPixels > 0) {
     const diffDir = path8.dirname(diffOutputPath);
-    if (!fs7.existsSync(diffDir)) {
-      fs7.mkdirSync(diffDir, { recursive: true });
+    if (!fs8.existsSync(diffDir)) {
+      fs8.mkdirSync(diffDir, { recursive: true });
     }
-    fs7.writeFileSync(diffOutputPath, PNG.sync.write(diff));
+    fs8.writeFileSync(diffOutputPath, PNG.sync.write(diff));
     diffPath = diffOutputPath;
   }
   return {
@@ -3123,14 +3302,14 @@ function compareImages(baselinePath, currentPath, diffOutputPath, threshold = 0.
   };
 }
 function createBaseline(currentPath, baselinePath) {
-  if (!fs7.existsSync(currentPath)) {
+  if (!fs8.existsSync(currentPath)) {
     throw new Error(`\u5F53\u524D\u622A\u56FE\u4E0D\u5B58\u5728: ${currentPath}`);
   }
   const baselineDir = path8.dirname(baselinePath);
-  if (!fs7.existsSync(baselineDir)) {
-    fs7.mkdirSync(baselineDir, { recursive: true });
+  if (!fs8.existsSync(baselineDir)) {
+    fs8.mkdirSync(baselineDir, { recursive: true });
   }
-  fs7.copyFileSync(currentPath, baselinePath);
+  fs8.copyFileSync(currentPath, baselinePath);
   return baselinePath;
 }
 function updateBaseline(currentPath, baselinePath) {
@@ -3138,69 +3317,69 @@ function updateBaseline(currentPath, baselinePath) {
 }
 function updateAllBaselines(currentDir, baselineDir) {
   const updated = [];
-  if (!fs7.existsSync(currentDir)) {
+  if (!fs8.existsSync(currentDir)) {
     return updated;
   }
-  const files = fs7.readdirSync(currentDir).filter((f) => f.endsWith(".png"));
+  const files = fs8.readdirSync(currentDir).filter((f) => f.endsWith(".png"));
   for (const file of files) {
     const currentPath = path8.join(currentDir, file);
     const baselinePath = path8.join(baselineDir, file);
     const baselineDirAbs = path8.dirname(baselinePath);
-    if (!fs7.existsSync(baselineDirAbs)) {
-      fs7.mkdirSync(baselineDirAbs, { recursive: true });
+    if (!fs8.existsSync(baselineDirAbs)) {
+      fs8.mkdirSync(baselineDirAbs, { recursive: true });
     }
-    fs7.copyFileSync(currentPath, baselinePath);
+    fs8.copyFileSync(currentPath, baselinePath);
     updated.push(file);
   }
   return updated;
 }
 function cleanBaselines(baselineDir) {
-  if (!fs7.existsSync(baselineDir)) {
+  if (!fs8.existsSync(baselineDir)) {
     return 0;
   }
-  const files = fs7.readdirSync(baselineDir).filter((f) => f.endsWith(".png"));
+  const files = fs8.readdirSync(baselineDir).filter((f) => f.endsWith(".png"));
   let count = 0;
   for (const file of files) {
-    fs7.unlinkSync(path8.join(baselineDir, file));
+    fs8.unlinkSync(path8.join(baselineDir, file));
     count++;
   }
   return count;
 }
 function cleanDiffs(diffDir) {
-  if (!fs7.existsSync(diffDir)) {
+  if (!fs8.existsSync(diffDir)) {
     return 0;
   }
-  const files = fs7.readdirSync(diffDir).filter((f) => f.endsWith(".png"));
+  const files = fs8.readdirSync(diffDir).filter((f) => f.endsWith(".png"));
   let count = 0;
   for (const file of files) {
-    fs7.unlinkSync(path8.join(diffDir, file));
+    fs8.unlinkSync(path8.join(diffDir, file));
     count++;
   }
   return count;
 }
 function listBaselines(baselineDir) {
-  if (!fs7.existsSync(baselineDir)) {
+  if (!fs8.existsSync(baselineDir)) {
     return [];
   }
-  return fs7.readdirSync(baselineDir).filter((f) => f.endsWith(".png")).sort();
+  return fs8.readdirSync(baselineDir).filter((f) => f.endsWith(".png")).sort();
 }
 function listDiffs(diffDir) {
-  if (!fs7.existsSync(diffDir)) {
+  if (!fs8.existsSync(diffDir)) {
     return [];
   }
-  return fs7.readdirSync(diffDir).filter((f) => f.endsWith(".png")).sort();
+  return fs8.readdirSync(diffDir).filter((f) => f.endsWith(".png")).sort();
 }
 function compareDirectories(baselineDir, currentDir, diffDir, threshold = 0.1) {
   const results = [];
-  if (!fs7.existsSync(currentDir)) {
+  if (!fs8.existsSync(currentDir)) {
     return results;
   }
-  const currentFiles = fs7.readdirSync(currentDir).filter((f) => f.endsWith(".png"));
+  const currentFiles = fs8.readdirSync(currentDir).filter((f) => f.endsWith(".png"));
   for (const file of currentFiles) {
     const currentPath = path8.join(currentDir, file);
     const baselinePath = path8.join(baselineDir, file);
     const diffPath = path8.join(diffDir, file);
-    if (!fs7.existsSync(baselinePath)) {
+    if (!fs8.existsSync(baselinePath)) {
       createBaseline(currentPath, baselinePath);
       results.push({
         passed: true,
@@ -3232,14 +3411,14 @@ function compareDirectories(baselineDir, currentDir, diffDir, threshold = 0.1) {
 }
 
 // src/services/source-analyzer.ts
-import fs8 from "fs";
+import fs9 from "fs";
 import path9 from "path";
 function analyzeFile(filePath) {
   const absolutePath = path9.resolve(process.cwd(), filePath);
-  if (!fs8.existsSync(absolutePath)) {
+  if (!fs9.existsSync(absolutePath)) {
     return { filePath, exports: [], apiCalls: [] };
   }
-  const content = fs8.readFileSync(absolutePath, "utf-8");
+  const content = fs9.readFileSync(absolutePath, "utf-8");
   const ext = path9.extname(filePath);
   const result = {
     filePath,
@@ -3594,13 +3773,13 @@ function cleanTemplateUrl(url) {
 }
 function scanAPICalls(srcDir) {
   const absDir = path9.resolve(process.cwd(), srcDir);
-  if (!fs8.existsSync(absDir)) {
+  if (!fs9.existsSync(absDir)) {
     return [];
   }
   const allCalls = [];
   const seen = /* @__PURE__ */ new Set();
   function walk(dir) {
-    const entries = fs8.readdirSync(dir, { withFileTypes: true });
+    const entries = fs9.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "dist") continue;
       const fullPath = path9.join(dir, entry.name);
@@ -3608,7 +3787,7 @@ function scanAPICalls(srcDir) {
         walk(fullPath);
       } else if (entry.isFile() && /\.(ts|js|vue|mjs)$/.test(entry.name)) {
         try {
-          const content = fs8.readFileSync(fullPath, "utf-8");
+          const content = fs9.readFileSync(fullPath, "utf-8");
           const calls = extractAPICalls(content, path9.relative(process.cwd(), fullPath));
           for (const call of calls) {
             const key = `${call.method}:${call.url}`;