qat-cli 0.2.6 → 0.2.8

package/README.md

@@ -4,7 +4,7 @@
 
 **Quick Auto Testing — 面向 Vue 项目，集成 Vitest & Playwright，AI 驱动覆盖测试全流程**
 
-[![npm version](https://img.shields.io/badge/version-0.2.6-blue.svg)](https://www.npmjs.com/package/qat-cli)
+[![npm version](https://img.shields.io/badge/version-0.2.8-blue.svg)](https://www.npmjs.com/package/qat-cli)
 [![Node.js](https://img.shields.io/badge/node-%3E%3D18.0.0-green.svg)](https://nodejs.org/)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![TypeScript](https://img.shields.io/badge/TypeScript-5.6-blue.svg)](https://www.typescriptlang.org/)

package/dist/cli.js

@@ -467,17 +467,20 @@ async function loadConfig(configPath, forceReload = false) {
 }
 async function importConfig(filePath) {
   const { resolve } = await import("path");
+  const { pathToFileURL } = await import("url");
   const absolutePath = resolve(process.cwd(), filePath);
   if (!fs2.existsSync(absolutePath)) {
     throw new Error(`Cannot find module '${absolutePath}'`);
   }
+  const fileUrl = pathToFileURL(absolutePath).href;
   try {
-    const module = await import(absolutePath);
+    const module = await import(fileUrl);
     return module.default || module;
   } catch {
     const jsPath = absolutePath.replace(/\.ts$/, ".js");
-    if (fs2.existsSync(jsPath)) {
-      const module = await import(jsPath);
+    if (jsPath !== absolutePath && fs2.existsSync(jsPath)) {
+      const jsUrl = pathToFileURL(jsPath).href;
+      const module = await import(jsUrl);
       return module.default || module;
     }
     throw new Error(`\u65E0\u6CD5\u52A0\u8F7D\u914D\u7F6E\u6587\u4EF6: ${absolutePath}`);
@@ -3166,6 +3169,8 @@ function displayCreateResult(createdFiles, skippedCount, usedAI) {
 import chalk5 from "chalk";
 import inquirer3 from "inquirer";
 import ora4 from "ora";
+import fs9 from "fs";
+import path11 from "path";
 
 // src/runners/vitest-runner.ts
 import { execFile } from "child_process";
@@ -3831,6 +3836,8 @@ function calculateAverageMetrics(results) {
 }
 
 // src/commands/run.ts
+var RESULTS_DIR = ".qat-results";
+var SERVER_REQUIRED_TYPES = ["e2e", "visual", "performance"];
 var TYPE_RUNNERS = {
   unit: "Vitest",
   component: "Vitest",
@@ -3875,6 +3882,62 @@ async function executeRun(options) {
     console.log(chalk5.yellow("\n  \u6CA1\u6709\u53EF\u8FD0\u884C\u7684\u6D4B\u8BD5\u7C7B\u578B\uFF08\u8BF7\u5728 qat.config.ts \u4E2D\u542F\u7528\uFF09\n"));
     return;
   }
+  const serverNeededTypes = typesToRun.filter((t) => SERVER_REQUIRED_TYPES.includes(t));
+  if (serverNeededTypes.length > 0) {
+    const serverOk = await checkDevServer(config);
+    if (!serverOk) {
+      const { action } = await inquirer3.prompt([
+        {
+          type: "list",
+          name: "action",
+          message: `\u8FD0\u884C ${serverNeededTypes.map((t) => TYPE_LABELS[t]).join("\u3001")} \u9700\u8981\u9879\u76EE\u670D\u52A1\u8FD0\u884C\uFF0C\u5982\u4F55\u5904\u7406\uFF1F`,
+          choices: [
+            { name: "\u81EA\u52A8\u542F\u52A8 dev server \u5E76\u8FD0\u884C", value: "start" },
+            { name: "\u8DF3\u8FC7\u8FD9\u4E9B\u6D4B\u8BD5\u7C7B\u578B\uFF0C\u4EC5\u8FD0\u884C\u5176\u4ED6\u6D4B\u8BD5", value: "skip" },
+            { name: "\u53D6\u6D88\u8FD0\u884C", value: "cancel" }
+          ],
+          default: "start"
+        }
+      ]);
+      if (action === "cancel") {
+        console.log(chalk5.gray("\n  \u5DF2\u53D6\u6D88\u8FD0\u884C\n"));
+        return;
+      }
+      if (action === "skip") {
+        typesToRun = typesToRun.filter((t) => !SERVER_REQUIRED_TYPES.includes(t));
+        if (typesToRun.length === 0) {
+          console.log(chalk5.yellow("\n  \u6CA1\u6709\u53EF\u8FD0\u884C\u7684\u6D4B\u8BD5\u7C7B\u578B\n"));
+          return;
+        }
+      }
+      if (action === "start") {
+        const started = await startDevServer(config);
+        if (!started) {
+          const { fallback } = await inquirer3.prompt([
+            {
+              type: "list",
+              name: "fallback",
+              message: "dev server \u542F\u52A8\u5931\u8D25\uFF0C\u5982\u4F55\u5904\u7406\uFF1F",
+              choices: [
+                { name: "\u8DF3\u8FC7\u9700\u8981\u670D\u52A1\u7684\u6D4B\u8BD5\uFF0C\u4EC5\u8FD0\u884C\u5176\u4ED6\u6D4B\u8BD5", value: "skip" },
+                { name: "\u53D6\u6D88\u8FD0\u884C", value: "cancel" }
+              ],
+              default: "skip"
+            }
+          ]);
+          if (fallback === "cancel") {
+            console.log(chalk5.gray("\n  \u5DF2\u53D6\u6D88\u8FD0\u884C\n"));
+            return;
+          }
+          typesToRun = typesToRun.filter((t) => !SERVER_REQUIRED_TYPES.includes(t));
+          if (typesToRun.length === 0) {
+            console.log(chalk5.yellow("\n  \u6CA1\u6709\u53EF\u8FD0\u884C\u7684\u6D4B\u8BD5\u7C7B\u578B\n"));
+            return;
+          }
+        }
+      }
+    }
+  }
   if (!type && !file) {
     const { runMode } = await inquirer3.prompt([
       {
@@ -3921,6 +3984,7 @@ async function executeRun(options) {
     }
   }
   displaySummary(results, config);
+  saveRunResults(results);
 }
 function printDryRunCommands(types, options, config) {
   console.log();
@@ -4248,6 +4312,71 @@ function scoreColor(score) {
   if (score >= 50) return chalk5.yellow("\u25CF");
   return chalk5.red("\u25CF");
 }
+async function checkDevServer(config) {
+  const baseUrl = config.playwright.baseURL || "http://localhost:5173";
+  try {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 3e3);
+    const response = await fetch(baseUrl, { signal: controller.signal, method: "HEAD" });
+    clearTimeout(timer);
+    return response.status > 0;
+  } catch {
+    return false;
+  }
+}
+async function startDevServer(config) {
+  const { spawn } = await import("child_process");
+  const hasPnpm = fs9.existsSync(path11.join(process.cwd(), "pnpm-lock.yaml"));
+  const hasYarn = fs9.existsSync(path11.join(process.cwd(), "yarn.lock"));
+  const pkgCmd = hasPnpm ? "pnpm" : hasYarn ? "yarn" : "npm";
+  console.log(chalk5.cyan(`  \u6B63\u5728\u542F\u52A8 dev server (${pkgCmd} run dev) ...`));
+  const child = spawn(pkgCmd, ["run", "dev"], {
+    cwd: process.cwd(),
+    stdio: "pipe",
+    shell: true,
+    detached: true
+  });
+  const baseUrl = config.playwright.baseURL || "http://localhost:5173";
+  const maxWait = 3e4;
+  const interval = 1e3;
+  let waited = 0;
+  while (waited < maxWait) {
+    await new Promise((r) => setTimeout(r, interval));
+    waited += interval;
+    const isUp = await checkDevServer(config);
+    if (isUp) {
+      console.log(chalk5.green(`  \u2713 dev server \u5DF2\u542F\u52A8 (${baseUrl})`));
+      child.unref();
+      return true;
+    }
+  }
+  child.kill();
+  console.log(chalk5.red("  \u2717 dev server \u542F\u52A8\u8D85\u65F6"));
+  return false;
+}
+function saveRunResults(results) {
+  if (results.length === 0) return;
+  const resultsPath = path11.join(process.cwd(), RESULTS_DIR);
+  if (!fs9.existsSync(resultsPath)) {
+    fs9.mkdirSync(resultsPath, { recursive: true });
+  }
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const fileName = `result-${timestamp}.json`;
+  const filePath = path11.join(resultsPath, fileName);
+  const data = {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    results
+  };
+  fs9.writeFileSync(filePath, JSON.stringify(data, null, 2), "utf-8");
+  try {
+    const files = fs9.readdirSync(resultsPath).filter((f) => f.startsWith("result-") && f.endsWith(".json")).sort();
+    while (files.length > 20) {
+      const oldest = files.shift();
+      fs9.unlinkSync(path11.join(resultsPath, oldest));
+    }
+  } catch {
+  }
+}
 
 // src/commands/mock.ts
 import chalk6 from "chalk";
@@ -4371,12 +4500,12 @@ function showStatus() {
 // src/commands/report.ts
 import chalk7 from "chalk";
 import ora6 from "ora";
-import fs10 from "fs";
-import path12 from "path";
+import fs11 from "fs";
+import path13 from "path";
 
 // src/services/reporter.ts
-import fs9 from "fs";
-import path11 from "path";
+import fs10 from "fs";
+import path12 from "path";
 function aggregateResults(results) {
   const summary = {
     total: 0,
@@ -4631,17 +4760,17 @@ function generateHTMLReport(data) {
 }
 function writeReportToDisk(data, outputDir) {
   const html = generateHTMLReport(data);
-  const dir = path11.resolve(outputDir);
-  if (!fs9.existsSync(dir)) {
-    fs9.mkdirSync(dir, { recursive: true });
+  const dir = path12.resolve(outputDir);
+  if (!fs10.existsSync(dir)) {
+    fs10.mkdirSync(dir, { recursive: true });
   }
-  const indexPath = path11.join(dir, "index.html");
-  fs9.writeFileSync(indexPath, html, "utf-8");
+  const indexPath = path12.join(dir, "index.html");
+  fs10.writeFileSync(indexPath, html, "utf-8");
   return indexPath;
 }
 
 // src/commands/report.ts
-var RESULTS_DIR = ".qat-results";
+var RESULTS_DIR2 = ".qat-results";
 function registerReportCommand(program2) {
   program2.command("report").description("\u751F\u6210\u6D4B\u8BD5\u62A5\u544A - \u805A\u5408\u6240\u6709\u6D4B\u8BD5\u7ED3\u679C\u5E76\u8F93\u51FAHTML").option("-o, --output <dir>", "\u62A5\u544A\u8F93\u51FA\u76EE\u5F55").option("--open", "\u751F\u6210\u540E\u81EA\u52A8\u6253\u5F00\u62A5\u544A", false).action(async (options) => {
     try {
@@ -4676,15 +4805,15 @@ async function executeReport(options) {
 }
 function collectResults() {
   const results = [];
-  const resultsPath = path12.join(process.cwd(), RESULTS_DIR);
-  if (!fs10.existsSync(resultsPath)) {
+  const resultsPath = path13.join(process.cwd(), RESULTS_DIR2);
+  if (!fs11.existsSync(resultsPath)) {
     return results;
   }
-  const files = fs10.readdirSync(resultsPath).filter((f) => f.endsWith(".json")).sort().reverse();
+  const files = fs11.readdirSync(resultsPath).filter((f) => f.endsWith(".json")).sort().reverse();
   if (files.length > 0) {
-    const latestFile = path12.join(resultsPath, files[0]);
+    const latestFile = path13.join(resultsPath, files[0]);
     try {
-      const data = JSON.parse(fs10.readFileSync(latestFile, "utf-8"));
+      const data = JSON.parse(fs11.readFileSync(latestFile, "utf-8"));
       if (Array.isArray(data)) {
         results.push(...data);
       } else if (data.results) {
@@ -4696,22 +4825,22 @@ function collectResults() {
   return results;
 }
 function saveResultToHistory(reportData) {
-  const resultsPath = path12.join(process.cwd(), RESULTS_DIR);
-  if (!fs10.existsSync(resultsPath)) {
-    fs10.mkdirSync(resultsPath, { recursive: true });
+  const resultsPath = path13.join(process.cwd(), RESULTS_DIR2);
+  if (!fs11.existsSync(resultsPath)) {
+    fs11.mkdirSync(resultsPath, { recursive: true });
   }
   const timestamp = new Date(reportData.timestamp).toISOString().replace(/[:.]/g, "-");
   const fileName = `result-${timestamp}.json`;
-  const filePath = path12.join(resultsPath, fileName);
-  fs10.writeFileSync(filePath, JSON.stringify(reportData, null, 2), "utf-8");
-  const files = fs10.readdirSync(resultsPath).filter((f) => f.startsWith("result-") && f.endsWith(".json")).sort();
+  const filePath = path13.join(resultsPath, fileName);
+  fs11.writeFileSync(filePath, JSON.stringify(reportData, null, 2), "utf-8");
+  const files = fs11.readdirSync(resultsPath).filter((f) => f.startsWith("result-") && f.endsWith(".json")).sort();
   while (files.length > 20) {
     const oldest = files.shift();
-    fs10.unlinkSync(path12.join(resultsPath, oldest));
+    fs11.unlinkSync(path13.join(resultsPath, oldest));
   }
 }
 function displayReportResult(reportPath, data) {
-  const relativePath = path12.relative(process.cwd(), reportPath);
+  const relativePath = path13.relative(process.cwd(), reportPath);
   console.log();
   console.log(chalk7.green("  \u2713 \u6D4B\u8BD5\u62A5\u544A\u5DF2\u751F\u6210"));
   console.log();
@@ -4758,19 +4887,19 @@ import chalk8 from "chalk";
 import ora7 from "ora";
 
 // src/services/visual.ts
-import fs11 from "fs";
-import path13 from "path";
+import fs12 from "fs";
+import path14 from "path";
 import pixelmatch from "pixelmatch";
 import { PNG } from "pngjs";
 function compareImages(baselinePath, currentPath, diffOutputPath, threshold = 0.1) {
-  if (!fs11.existsSync(baselinePath)) {
+  if (!fs12.existsSync(baselinePath)) {
     throw new Error(`\u57FA\u7EBF\u56FE\u7247\u4E0D\u5B58\u5728: ${baselinePath}`);
   }
-  if (!fs11.existsSync(currentPath)) {
+  if (!fs12.existsSync(currentPath)) {
     throw new Error(`\u5F53\u524D\u56FE\u7247\u4E0D\u5B58\u5728: ${currentPath}`);
   }
-  const baseline = PNG.sync.read(fs11.readFileSync(baselinePath));
-  const current = PNG.sync.read(fs11.readFileSync(currentPath));
+  const baseline = PNG.sync.read(fs12.readFileSync(baselinePath));
+  const current = PNG.sync.read(fs12.readFileSync(currentPath));
   if (baseline.width !== current.width || baseline.height !== current.height) {
     return {
       passed: false,
@@ -4798,11 +4927,11 @@ function compareImages(baselinePath, currentPath, diffOutputPath, threshold = 0.
   const passed = diffRatio <= threshold;
   let diffPath;
   if (diffPixels > 0) {
-    const diffDir = path13.dirname(diffOutputPath);
-    if (!fs11.existsSync(diffDir)) {
-      fs11.mkdirSync(diffDir, { recursive: true });
+    const diffDir = path14.dirname(diffOutputPath);
+    if (!fs12.existsSync(diffDir)) {
+      fs12.mkdirSync(diffDir, { recursive: true });
     }
-    fs11.writeFileSync(diffOutputPath, PNG.sync.write(diff));
+    fs12.writeFileSync(diffOutputPath, PNG.sync.write(diff));
     diffPath = diffOutputPath;
   }
   return {
@@ -4816,69 +4945,69 @@ function compareImages(baselinePath, currentPath, diffOutputPath, threshold = 0.
   };
 }
 function createBaseline(currentPath, baselinePath) {
-  if (!fs11.existsSync(currentPath)) {
+  if (!fs12.existsSync(currentPath)) {
     throw new Error(`\u5F53\u524D\u622A\u56FE\u4E0D\u5B58\u5728: ${currentPath}`);
   }
-  const baselineDir = path13.dirname(baselinePath);
-  if (!fs11.existsSync(baselineDir)) {
-    fs11.mkdirSync(baselineDir, { recursive: true });
+  const baselineDir = path14.dirname(baselinePath);
+  if (!fs12.existsSync(baselineDir)) {
+    fs12.mkdirSync(baselineDir, { recursive: true });
   }
-  fs11.copyFileSync(currentPath, baselinePath);
+  fs12.copyFileSync(currentPath, baselinePath);
   return baselinePath;
 }
 function updateAllBaselines(currentDir, baselineDir) {
   const updated = [];
-  if (!fs11.existsSync(currentDir)) {
+  if (!fs12.existsSync(currentDir)) {
     return updated;
   }
-  const files = fs11.readdirSync(currentDir).filter((f) => f.endsWith(".png"));
+  const files = fs12.readdirSync(currentDir).filter((f) => f.endsWith(".png"));
   for (const file of files) {
-    const currentPath = path13.join(currentDir, file);
-    const baselinePath = path13.join(baselineDir, file);
-    const baselineDirAbs = path13.dirname(baselinePath);
-    if (!fs11.existsSync(baselineDirAbs)) {
-      fs11.mkdirSync(baselineDirAbs, { recursive: true });
+    const currentPath = path14.join(currentDir, file);
+    const baselinePath = path14.join(baselineDir, file);
+    const baselineDirAbs = path14.dirname(baselinePath);
+    if (!fs12.existsSync(baselineDirAbs)) {
+      fs12.mkdirSync(baselineDirAbs, { recursive: true });
     }
-    fs11.copyFileSync(currentPath, baselinePath);
+    fs12.copyFileSync(currentPath, baselinePath);
     updated.push(file);
   }
   return updated;
 }
 function cleanBaselines(baselineDir) {
-  if (!fs11.existsSync(baselineDir)) {
+  if (!fs12.existsSync(baselineDir)) {
     return 0;
   }
-  const files = fs11.readdirSync(baselineDir).filter((f) => f.endsWith(".png"));
+  const files = fs12.readdirSync(baselineDir).filter((f) => f.endsWith(".png"));
   let count = 0;
   for (const file of files) {
-    fs11.unlinkSync(path13.join(baselineDir, file));
+    fs12.unlinkSync(path14.join(baselineDir, file));
     count++;
   }
   return count;
 }
 function cleanDiffs(diffDir) {
-  if (!fs11.existsSync(diffDir)) {
+  if (!fs12.existsSync(diffDir)) {
     return 0;
   }
-  const files = fs11.readdirSync(diffDir).filter((f) => f.endsWith(".png"));
+  const files = fs12.readdirSync(diffDir).filter((f) => f.endsWith(".png"));
   let count = 0;
   for (const file of files) {
-    fs11.unlinkSync(path13.join(diffDir, file));
+    fs12.unlinkSync(path14.join(diffDir, file));
     count++;
   }
   return count;
 }
 function compareDirectories(baselineDir, currentDir, diffDir, threshold = 0.1) {
   const results = [];
-  if (!fs11.existsSync(currentDir)) {
+  if (!fs12.existsSync(currentDir)) {
     return results;
   }
-  const currentFiles = fs11.readdirSync(currentDir).filter((f) => f.endsWith(".png"));
+  const currentFiles = fs12.readdirSync(currentDir).filter((f) => f.endsWith(".png"));
   for (const file of currentFiles) {
-    const currentPath = path13.join(currentDir, file);
-    const baselinePath = path13.join(baselineDir, file);
-    const diffPath = path13.join(diffDir, file);
-    if (!fs11.existsSync(baselinePath)) {
+    const currentPath = path14.join(currentDir, file);
+    const baselinePath = path14.join(baselineDir, file);
+    const diffPath = path14.join(diffDir, file);
+    if (!fs12.existsSync(baselinePath)) {
       createBaseline(currentPath, baselinePath);
       results.push({
         passed: true,
@@ -4910,8 +5039,8 @@ function compareDirectories(baselineDir, currentDir, diffDir, threshold = 0.1) {
 }
 
 // src/commands/visual.ts
-import fs12 from "fs";
-import path14 from "path";
+import fs13 from "fs";
+import path15 from "path";
 function registerVisualCommand(program2) {
   program2.command("visual").description("\u89C6\u89C9\u56DE\u5F52\u6D4B\u8BD5 - \u622A\u56FE\u6BD4\u5BF9\u4E0E\u57FA\u7EBF\u7BA1\u7406").argument("<action>", "\u64CD\u4F5C\u7C7B\u578B (test|approve|clean)").option("--threshold <number>", "\u50CF\u7D20\u5DEE\u5F02\u9608\u503C (0-1)", "0.1").action(async (action, options) => {
     try {
@@ -4986,12 +5115,12 @@ async function runVisualTest(threshold, baselineDir, diffDir, config) {
 }
 function findCurrentScreenshotsDir(baselineDir) {
   const possibleDirs = [
-    path14.join(process.cwd(), "test-results"),
-    path14.join(process.cwd(), "tests", "visual", "current"),
-    path14.join(process.cwd(), baselineDir, "..", "current")
+    path15.join(process.cwd(), "test-results"),
+    path15.join(process.cwd(), "tests", "visual", "current"),
+    path15.join(process.cwd(), baselineDir, "..", "current")
   ];
   for (const dir of possibleDirs) {
-    if (fs12.existsSync(dir)) {
+    if (fs13.existsSync(dir)) {
       const pngs = findPngFiles(dir);
       if (pngs.length > 0) return dir;
     }
@@ -5001,10 +5130,10 @@ function findCurrentScreenshotsDir(baselineDir) {
 function findPngFiles(dir) {
   const files = [];
   function walk(d) {
-    if (!fs12.existsSync(d)) return;
-    const entries = fs12.readdirSync(d, { withFileTypes: true });
+    if (!fs13.existsSync(d)) return;
+    const entries = fs13.readdirSync(d, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path14.join(d, entry.name);
+      const fullPath = path15.join(d, entry.name);
       if (entry.isDirectory() && entry.name !== "node_modules") {
         walk(fullPath);
       } else if (entry.name.endsWith(".png")) {
@@ -5033,7 +5162,7 @@ function displayVisualResults(results, threshold) {
     console.log();
     console.log(chalk8.green("  \u901A\u8FC7\u7684\u622A\u56FE:"));
     for (const result of passed) {
-      const name = path14.basename(result.baselinePath);
+      const name = path15.basename(result.baselinePath);
       if (result.totalPixels > 0) {
         const diffPct = (result.diffRatio * 100).toFixed(2);
         console.log(chalk8.green(`    \u2713 ${name} (\u5DEE\u5F02: ${diffPct}%)`));
@@ -5046,7 +5175,7 @@ function displayVisualResults(results, threshold) {
     console.log();
     console.log(chalk8.red("  \u5931\u8D25\u7684\u622A\u56FE:"));
     for (const result of failed) {
-      const name = path14.basename(result.baselinePath);
+      const name = path15.basename(result.baselinePath);
       if (result.diffPixels === -1) {
         console.log(chalk8.red(`    \u2717 ${name} (\u5C3A\u5BF8\u4E0D\u5339\u914D)`));
       } else {
@@ -5054,7 +5183,7 @@ function displayVisualResults(results, threshold) {
         console.log(chalk8.red(`    \u2717 ${name} (\u5DEE\u5F02: ${diffPct}%)`));
       }
       if (result.diffPath) {
-        console.log(chalk8.gray(`      \u5DEE\u5F02\u56FE: ${path14.relative(process.cwd(), result.diffPath)}`));
+        console.log(chalk8.gray(`      \u5DEE\u5F02\u56FE: ${path15.relative(process.cwd(), result.diffPath)}`));
       }
     }
     console.log();
@@ -5100,8 +5229,8 @@ import chalk9 from "chalk";
 import inquirer4 from "inquirer";
 import ora8 from "ora";
 import { execFile as execFile4 } from "child_process";
-import fs13 from "fs";
-import path15 from "path";
+import fs14 from "fs";
+import path16 from "path";
 var DEPENDENCY_GROUPS = [
   {
     name: "Vitest (\u5355\u5143/\u7EC4\u4EF6/API\u6D4B\u8BD5)",
@@ -5135,7 +5264,7 @@ function registerSetupCommand(program2) {
 async function executeSetup(options) {
   console.log(chalk9.cyan("\n  QAT \u4F9D\u8D56\u5B89\u88C5\u5668\n"));
   const projectInfo = detectProject();
-  if (!fs13.existsSync(path15.join(process.cwd(), "package.json"))) {
+  if (!fs14.existsSync(path16.join(process.cwd(), "package.json"))) {
     throw new Error("\u672A\u627E\u5230 package.json\uFF0C\u8BF7\u5728\u9879\u76EE\u6839\u76EE\u5F55\u6267\u884C\u6B64\u547D\u4EE4");
   }
   if (projectInfo.frameworkConfidence > 0) {
@@ -5169,8 +5298,8 @@ async function executeSetup(options) {
       }
     ]);
     if (chooseDir !== "root") {
-      installDir = path15.join(process.cwd(), chooseDir);
-      if (!fs13.existsSync(path15.join(installDir, "package.json"))) {
+      installDir = path16.join(process.cwd(), chooseDir);
+      if (!fs14.existsSync(path16.join(installDir, "package.json"))) {
         throw new Error(`${chooseDir} \u4E0B\u6CA1\u6709 package.json`);
       }
     }
@@ -5209,7 +5338,7 @@ ${allPackages.map((p) => `  - ${p}`).join("\n")}`,
     const pm = getPackageManager(projectInfo.packageManager);
     const installCmd = pm === "npm" ? "npm install -D" : pm === "yarn" ? "yarn add -D" : pm === "pnpm" ? "pnpm add -D" : "bun add -D";
     for (const group of selectedGroups) {
-      const dirHint = installDir !== process.cwd() ? ` (\u5728 ${path15.relative(process.cwd(), installDir) || installDir})` : "";
+      const dirHint = installDir !== process.cwd() ? ` (\u5728 ${path16.relative(process.cwd(), installDir) || installDir})` : "";
       console.log(chalk9.white(`  ${installCmd} ${group.packages.join(" ")}${dirHint}`));
       if (group.postInstall) {
         for (const cmd of group.postInstall) {
@@ -5490,7 +5619,7 @@ async function executeChange(_options) {
 }
 
 // src/cli.ts
-var VERSION = "0.2.6";
+var VERSION = "0.2.8";
 function printLogo() {
   const logo = `
   ${chalk12.bold.cyan("   ___            _          _           _              _               _____                _     _                 ")}