qat-cli 0.3.3 → 0.3.5

package/dist/cli.js

@@ -8,10 +8,10 @@ import {
 
 // src/cli.ts
 import { Command } from "commander";
-import chalk12 from "chalk";
+import chalk13 from "chalk";
 
 // src/commands/init.ts
-import chalk2 from "chalk";
+import chalk3 from "chalk";
 import inquirer from "inquirer";
 import ora from "ora";
 import fs6 from "fs";
@@ -524,71 +524,6 @@ function validateConfig(config) {
   }
   return merged;
 }
-function generateConfigFile(overrides = {}) {
-  const config = validateConfig(overrides);
-  return `// @ts-check
-/**
- * QAT \u914D\u7F6E\u6587\u4EF6 - Quick Auto Testing
- * \u4FEE\u6539\u540E\u65E0\u9700\u91CD\u542F\uFF0C\u4E0B\u6B21\u8FD0\u884C qat \u547D\u4EE4\u65F6\u81EA\u52A8\u751F\u6548
- *
- * AI \u6A21\u578B\u914D\u7F6E\u8BF7\u8FD0\u884C: qat change
- * AI \u72B6\u6001\u67E5\u770B\u8BF7\u8FD0\u884C: qat status
- */
-import { defineConfig } from 'qat-cli';
-
-export default defineConfig({
-  project: {
-    framework: '${config.project.framework}',
-    vite: ${config.project.vite ?? true},
-    srcDir: '${config.project.srcDir}',
-  },
-  vitest: {
-    enabled: ${config.vitest.enabled},
-    coverage: ${config.vitest.coverage},
-    globals: ${config.vitest.globals},
-    environment: '${config.vitest.environment}',
-  },
-  playwright: {
-    enabled: ${config.playwright.enabled},
-    browsers: [${config.playwright.browsers.map((b) => `'${b}'`).join(", ")}],
-    baseURL: '${config.playwright.baseURL}',
-    screenshot: '${config.playwright.screenshot}',
-  },
-  visual: {
-    enabled: ${config.visual.enabled},
-    threshold: ${config.visual.threshold},
-    baselineDir: '${config.visual.baselineDir}',
-    diffDir: '${config.visual.diffDir}',
-  },
-  lighthouse: {
-    enabled: ${config.lighthouse.enabled},
-    urls: [${config.lighthouse.urls.map((u) => `'${u}'`).join(", ")}],
-    runs: ${config.lighthouse.runs},
-    thresholds: {${Object.entries(config.lighthouse.thresholds).map(([k, v]) => `
-      ${k}: ${v},`).join("")}
-    },
-  },
-  mock: {
-    enabled: ${config.mock.enabled},
-    port: ${config.mock.port},
-    routesDir: '${config.mock.routesDir}',
-  },
-  report: {
-    outputDir: '${config.report.outputDir}',
-    open: ${config.report.open},
-  },
-});
-`;
-}
-async function writeConfigFile(cwd, overrides = {}, force = false) {
-  const configPath = path2.join(cwd, "qat.config.js");
-  if (fs2.existsSync(configPath) && !force) {
-    throw new Error(`\u914D\u7F6E\u6587\u4EF6\u5DF2\u5B58\u5728: ${configPath}\uFF0C\u4F7F\u7528 --force \u8986\u76D6`);
-  }
-  const content = generateConfigFile(overrides);
-  fs2.writeFileSync(configPath, content, "utf-8");
-  return configPath;
-}
 function isFileNotFoundError(error) {
   if (error instanceof Error) {
     return error.message.includes("Cannot find") || error.message.includes("ENOENT") || error.message.includes("\u65E0\u6CD5\u52A0\u8F7D\u914D\u7F6E\u6587\u4EF6");
@@ -843,6 +778,15 @@ var NoopAIProvider = class {
 };
 
 // src/ai/openai-provider.ts
+import chalk2 from "chalk";
+function isDebug() {
+  return process.env.QAT_DEBUG === "true";
+}
+function debugLog(tag, ...args) {
+  if (!isDebug()) return;
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().slice(11, 19);
+  console.error(chalk2.gray(`[DEBUG ${timestamp}] [${tag}]`), ...args);
+}
 var OpenAICompatibleProvider = class {
   constructor(config) {
     this.capabilities = {
@@ -856,25 +800,20 @@ var OpenAICompatibleProvider = class {
     this.baseUrl = config.baseUrl || this.getDefaultBaseUrl(config.provider);
   }
   async generateTest(req) {
+    debugLog("GENERATE", `type=${req.type} target=${req.target}`);
     const systemPrompt = this.buildGenerateTestSystemPrompt(req);
     const userPrompt = this.buildGenerateTestUserPrompt(req);
     const content = await this.chat(systemPrompt, userPrompt);
-    return this.parseGenerateTestResponse(content);
+    const result = this.parseGenerateTestResponse(content);
+    debugLog("GENERATE", `done code=${result.code.length}chars confidence=${result.confidence}`);
+    return result;
   }
   async analyzeResult(req) {
-    const systemPrompt = `\u4F60\u662F\u4E00\u4E2A\u4E13\u4E1A\u7684\u6D4B\u8BD5\u5206\u6790\u4E13\u5BB6\u3002\u5206\u6790\u6D4B\u8BD5\u8FD0\u884C\u7ED3\u679C\uFF0C\u627E\u51FA\u95EE\u9898\u6839\u56E0\uFF0C\u7ED9\u51FA\u5177\u4F53\u53EF\u64CD\u4F5C\u7684\u6539\u8FDB\u5EFA\u8BAE\u3002
-\u8F93\u51FA\u683C\u5F0F\uFF1A
-1. \u5206\u6790\u6458\u8981\uFF081-3\u53E5\u8BDD\uFF09
-2. \u6539\u8FDB\u5EFA\u8BAE\u5217\u8868\uFF08\u6BCF\u6761\u5EFA\u8BAE\u5177\u4F53\u3001\u53EF\u64CD\u4F5C\uFF09`;
-    const resultSummary = req.testResults.map((r) => {
-      const failed = r.suites.flatMap((s) => s.tests.filter((t) => t.status === "failed"));
-      return `\u7C7B\u578B: ${r.type}, \u72B6\u6001: ${r.status}, \u8017\u65F6: ${r.duration}ms, \u5931\u8D25\u7528\u4F8B: ${failed.length}`;
-    }).join("\n");
-    const errorDetails = req.errorLogs?.join("\n") || req.testResults.flatMap((r) => r.suites.flatMap((s) => s.tests.filter((t) => t.status === "failed" && t.error))).map((t) => `[${t.name}] ${t.error?.message}`).join("\n") || "\u65E0\u9519\u8BEF\u8BE6\u60C5";
-    const userPrompt = `\u6D4B\u8BD5\u7ED3\u679C:
-${resultSummary}
-
-\u9519\u8BEF\u8BE6\u60C5:
+    const systemPrompt = `\u6D4B\u8BD5\u5206\u6790\u4E13\u5BB6\u3002\u627E\u95EE\u9898\u6839\u56E0\uFF0C\u7ED9\u53EF\u64CD\u4F5C\u5EFA\u8BAE\u3002
+\u8F93\u51FA:1.\u6458\u8981(1-3\u53E5) 2.\u5EFA\u8BAE\u5217\u8868`;
+    const failed = req.testResults.flatMap((r) => r.suites.flatMap((s) => s.tests.filter((t) => t.status === "failed")));
+    const errorDetails = req.errorLogs?.join("\n") || failed.map((t) => `[${t.name}] ${t.error?.message}`).join("\n") || "\u65E0";
+    const userPrompt = `\u5931\u8D25:${failed.length}
 ${errorDetails}`;
     const content = await this.chat(systemPrompt, userPrompt);
     return {
@@ -884,23 +823,22 @@ ${errorDetails}`;
     };
   }
   async suggestFix(error) {
-    const systemPrompt = `\u4F60\u662F\u4E00\u4E2A\u4E13\u4E1A\u7684\u4EE3\u7801\u4FEE\u590D\u4E13\u5BB6\u3002\u6839\u636E\u6D4B\u8BD5\u9519\u8BEF\u4FE1\u606F\uFF0C\u7ED9\u51FA\u5177\u4F53\u7684\u4FEE\u590D\u5EFA\u8BAE\u3002
-\u6BCF\u6761\u5EFA\u8BAE\u5E94\u8BE5\u5305\u542B\uFF1A
-1. \u95EE\u9898\u5B9A\u4F4D
-2. \u4FEE\u590D\u65B9\u6848
-3. \u793A\u4F8B\u4EE3\u7801\uFF08\u5982\u679C\u9002\u7528\uFF09`;
-    const userPrompt = `\u9519\u8BEF\u4FE1\u606F: ${error.message}
-${error.stack ? `\u5806\u6808: ${error.stack}` : ""}
-${error.expected ? `\u671F\u671B\u503C: ${error.expected}` : ""}
-${error.actual ? `\u5B9E\u9645\u503C: ${error.actual}` : ""}`;
+    const systemPrompt = `\u4EE3\u7801\u4FEE\u590D\u4E13\u5BB6\u3002\u7ED9\u51FA:1.\u95EE\u9898\u5B9A\u4F4D 2.\u4FEE\u590D\u65B9\u6848 3.\u793A\u4F8B\u4EE3\u7801`;
+    const userPrompt = `\u9519\u8BEF:${error.message}${error.stack ? `
+\u5806\u6808:${error.stack}` : ""}${error.expected ? `
+\u671F\u671B:${error.expected}` : ""}${error.actual ? `
+\u5B9E\u9645:${error.actual}` : ""}`;
     const content = await this.chat(systemPrompt, userPrompt);
     return content.split("\n").filter((l) => l.trim().startsWith("-") || l.trim().startsWith("\u2022") || l.trim().match(/^\d+\./)).map((l) => l.replace(/^[-•\d.]+\s*/, "").trim()).filter(Boolean);
   }
   async reviewTest(req) {
+    debugLog("REVIEW", `target=${req.target} type=${req.testType}`);
     const systemPrompt = this.buildReviewTestSystemPrompt(req);
     const userPrompt = this.buildReviewTestUserPrompt(req);
     const content = await this.chat(systemPrompt, userPrompt);
-    return this.parseReviewTestResponse(content);
+    const result = this.parseReviewTestResponse(content);
+    debugLog("REVIEW", `approved=${result.approved} score=${result.score} feedback=${result.feedback}`);
+    return result;
   }
   // ─── 内部方法 ──────────────────────────────────────────────
   /**
@@ -964,8 +902,9 @@ ${error.actual ? `\u5B9E\u9645\u503C: ${error.actual}` : ""}`;
       return { ok: false, message: `\u8FDE\u63A5\u5931\u8D25: ${error instanceof Error ? error.message : String(error)}`, latencyMs };
     }
   }
-  async chat(systemPrompt, userPrompt) {
+  async chat(systemPrompt, userPrompt, retries = 2) {
     const url = `${this.baseUrl}/chat/completions`;
+    const useStream = isDebug();
     const body = {
       model: this.model,
       messages: [
@@ -975,101 +914,202 @@ ${error.actual ? `\u5B9E\u9645\u503C: ${error.actual}` : ""}`;
       temperature: 0.3,
       max_tokens: 4096
     };
+    if (useStream) {
+      body.stream = true;
+    }
     const headers = {
       "Content-Type": "application/json"
     };
     if (this.apiKey) {
       headers["Authorization"] = `Bearer ${this.apiKey}`;
     }
-    const response = await fetch(url, {
-      method: "POST",
-      headers,
-      body: JSON.stringify(body),
-      signal: AbortSignal.timeout(6e4)
-      // 60s timeout
-    });
-    if (!response.ok) {
-      const text = await response.text().catch(() => "");
-      throw new Error(`AI API \u8BF7\u6C42\u5931\u8D25 (${response.status}): ${text.slice(0, 500)}`);
+    debugLog("REQUEST", `POST ${url}`);
+    debugLog("REQUEST", `model=${this.model} stream=${useStream}`);
+    debugLog("SYSTEM", systemPrompt.length > 500 ? `${systemPrompt.slice(0, 500)}...` : systemPrompt);
+    debugLog("USER", userPrompt.length > 1e3 ? `${userPrompt.slice(0, 1e3)}...` : userPrompt);
+    let lastError = null;
+    for (let attempt = 0; attempt <= retries; attempt++) {
+      try {
+        if (attempt > 0) {
+          debugLog("RETRY", `\u7B2C${attempt}\u6B21\u91CD\u8BD5...`);
+        }
+        const response = await fetch(url, {
+          method: "POST",
+          headers,
+          body: JSON.stringify(body),
+          signal: AbortSignal.timeout(12e4)
+          // 120s timeout
+        });
+        if (!response.ok) {
+          const text = await response.text().catch(() => "");
+          if ((response.status === 429 || response.status >= 500) && attempt < retries) {
+            const delay = Math.min(1e3 * Math.pow(2, attempt), 8e3);
+            debugLog("RETRY", `HTTP ${response.status}, ${delay}ms\u540E\u91CD\u8BD5`);
+            await new Promise((r) => setTimeout(r, delay));
+            lastError = new Error(`AI API \u8BF7\u6C42\u5931\u8D25 (${response.status}): ${text.slice(0, 200)}`);
+            continue;
+          }
+          throw new Error(`AI API \u8BF7\u6C42\u5931\u8D25 (${response.status}): ${text.slice(0, 500)}`);
+        }
+        if (useStream && response.body) {
+          const content = await this.readStream(response.body);
+          debugLog("RESPONSE", content.length > 500 ? `${content.slice(0, 500)}...` : content);
+          return content;
+        }
+        const data = await response.json();
+        if (!data.choices?.[0]?.message?.content) {
+          throw new Error("AI API \u8FD4\u56DE\u7A7A\u54CD\u5E94");
+        }
+        debugLog("RESPONSE", `tokens: prompt=${data.usage?.prompt_tokens} completion=${data.usage?.completion_tokens} total=${data.usage?.total_tokens}`);
+        debugLog("RESPONSE", data.choices[0].message.content.length > 500 ? `${data.choices[0].message.content.slice(0, 500)}...` : data.choices[0].message.content);
+        return data.choices[0].message.content;
+      } catch (error) {
+        if (error instanceof Error && error.name === "TimeoutError" && attempt < retries) {
+          debugLog("TIMEOUT", `\u7B2C${attempt}\u6B21\u8D85\u65F6\uFF0C\u91CD\u8BD5\u4E2D...`);
+          lastError = error;
+          continue;
+        }
+        throw error;
+      }
     }
-    const data = await response.json();
-    if (!data.choices?.[0]?.message?.content) {
-      throw new Error("AI API \u8FD4\u56DE\u7A7A\u54CD\u5E94");
+    throw lastError || new Error("AI API \u8BF7\u6C42\u5931\u8D25");
+  }
+  /**
+   * 读取 SSE 流式响应，实时输出内容
+   */
+  async readStream(body) {
+    const chunks = [];
+    const decoder = new TextDecoder();
+    const reader = body.getReader();
+    let buffer = "";
+    let lineCount = 0;
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() || "";
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (!trimmed || trimmed === "data: [DONE]") continue;
+          if (!trimmed.startsWith("data: ")) continue;
+          try {
+            const json = JSON.parse(trimmed.slice(6));
+            const delta = json.choices?.[0]?.delta?.content;
+            if (delta) {
+              chunks.push(delta);
+              lineCount++;
+              process.stderr.write(chalk2.gray(delta));
+              if (lineCount % 20 === 0) {
+                process.stderr.write("\n");
+              }
+            }
+            if (json.choices?.[0]?.finish_reason === "stop") {
+              debugLog("STREAM", "\u5B8C\u6210");
+            }
+          } catch {
+          }
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+    if (chunks.length > 0) {
+      process.stderr.write("\n");
+    }
+    return chunks.join("");
+  }
+  /**
+   * 压缩源码：保留签名和关键逻辑，剔除注释、空行、样式块
+   * 目标：在保留准确性的前提下减少 token 消耗
+   * @param code 源码内容
+   * @param maxLength 最大长度
+   * @param importPathRewrites import 路径重写映射（原路径→正确路径）
+   */
+  compressSourceCode(code, maxLength = 3e3, importPathRewrites) {
+    let compressed = code;
+    if (importPathRewrites && importPathRewrites.size > 0) {
+      compressed = this.rewriteImportPaths(compressed, importPathRewrites);
+    }
+    compressed = compressed.replace(/<style[^>]*>[\s\S]*?<\/style>/gi, "");
+    compressed = compressed.replace(/<template[^>]*>([\s\S]*?)<\/template>/gi, (_match, content) => {
+      return `<template>${content.replace(/\s*(?:class|style)\s*=\s*["'][^"']*["']/gi, "")}</template>`;
+    });
+    compressed = compressed.replace(/\/\*[\s\S]*?\*\//g, "");
+    compressed = compressed.replace(/(^|[^:])(\/\/.*$)/gm, "$1");
+    compressed = compressed.replace(/\n\s*\n\s*\n/g, "\n\n");
+    compressed = compressed.split("\n").map((line) => line.trimEnd()).join("\n").trim();
+    if (compressed.length > maxLength) {
+      const scriptMatch = compressed.match(/<script[^>]*>([\s\S]*?)<\/script>/i);
+      const templateMatch = compressed.match(/<template[^>]*>([\s\S]*?)<\/template>/i);
+      if (scriptMatch) {
+        let scriptPart = scriptMatch[1].trim();
+        scriptPart = compressFunctionBodies(scriptPart, maxLength * 0.7);
+        const templatePart = templateMatch ? `<template>${templateMatch[1].replace(/\s+/g, " ").trim().slice(0, 300)}...</template>` : "";
+        compressed = `${templatePart}
+<script${scriptMatch[0].match(/<script[^>]*>/)?.[0]?.slice(7) || ">"}>${scriptPart}</script>`;
+      } else {
+        compressed = compressFunctionBodies(compressed, maxLength);
+      }
     }
-    return data.choices[0].message.content;
+    return compressed;
   }
   buildGenerateTestSystemPrompt(req) {
     const typeMap = {
-      unit: "\u5355\u5143\u6D4B\u8BD5\uFF08Vitest + @vue/test-utils\uFF09",
-      component: "\u7EC4\u4EF6\u6D4B\u8BD5\uFF08Vitest + @vue/test-utils + mount\uFF09",
-      e2e: "E2E\u7AEF\u5230\u7AEF\u6D4B\u8BD5\uFF08Playwright\uFF09",
-      api: "API\u63A5\u53E3\u6D4B\u8BD5\uFF08Vitest + fetch\uFF09",
-      visual: "\u89C6\u89C9\u56DE\u5F52\u6D4B\u8BD5\uFF08Playwright screenshot\uFF09",
-      performance: "\u6027\u80FD\u6D4B\u8BD5\uFF08Playwright + performance metrics\uFF09"
+      unit: "\u5355\u5143\u6D4B\u8BD5(Vitest)",
+      component: "\u7EC4\u4EF6\u6D4B\u8BD5(Vitest+@vue/test-utils)",
+      e2e: "E2E\u6D4B\u8BD5(Playwright)",
+      api: "API\u6D4B\u8BD5(Vitest+fetch)",
+      visual: "\u89C6\u89C9\u56DE\u5F52\u6D4B\u8BD5(Playwright)",
+      performance: "\u6027\u80FD\u6D4B\u8BD5(Playwright)"
     };
-    return `\u4F60\u662F\u4E00\u4E2A\u4E13\u4E1A\u7684\u524D\u7AEF\u6D4B\u8BD5\u5DE5\u7A0B\u5E08\uFF0C\u64C5\u957F\u7F16\u5199\u9AD8\u8D28\u91CF\u7684${typeMap[req.type] || req.type}\u3002
-\u8981\u6C42\uFF1A
-1. \u53EA\u8F93\u51FA\u6D4B\u8BD5\u4EE3\u7801\uFF0C\u4E0D\u8981\u591A\u4F59\u7684\u89E3\u91CA
-2. \u4EE3\u7801\u5FC5\u987B\u53EF\u76F4\u63A5\u8FD0\u884C\uFF0C\u5305\u542B\u6240\u6709\u5FC5\u8981\u7684 import
-3. \u6D4B\u8BD5\u7528\u4F8B\u8986\u76D6\uFF1A\u6B63\u5E38\u8DEF\u5F84\u3001\u8FB9\u754C\u6761\u4EF6\u3001\u9519\u8BEF\u5904\u7406
-4. \u4F7F\u7528\u4E2D\u6587\u63CF\u8FF0 it/test \u5757\u540D\u79F0
-5. Vue \u7EC4\u4EF6\u6D4B\u8BD5\u4F7F\u7528 @vue/test-utils \u7684 mount
-6. \u5982\u679C\u6709 props/emits \u4FE1\u606F\uFF0C\u52A1\u5FC5\u9488\u5BF9\u6BCF\u4E2A prop \u548C emit \u751F\u6210\u6D4B\u8BD5`;
+    return `\u4F60\u662F\u524D\u7AEF\u6D4B\u8BD5\u5DE5\u7A0B\u5E08\uFF0C\u7F16\u5199${typeMap[req.type] || req.type}\u3002
+\u89C4\u5219:1.\u53EA\u8F93\u51FA\u6D4B\u8BD5\u4EE3\u7801 2.\u5305\u542B\u6240\u6709import 3.\u8986\u76D6\u6B63\u5E38/\u8FB9\u754C/\u9519\u8BEF 4.it\u540D\u7528\u4E2D\u6587 5.Vue\u7528mount 6.\u5FC5\u6D4B\u6BCF\u4E2Aprop\u548Cemit`;
   }
   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
+    let prompt = `\u4E3A${req.target}\u751F\u6210${req.type}\u6D4B\u8BD5\u3002
+\u3010\u5F3A\u5236\u3011import\u88AB\u6D4B\u6A21\u5757\u5FC5\u987B\u7528: ${importPath}
 `;
     if (req.analysis) {
-      prompt += "\n\u6E90\u7801\u5206\u6790\u7ED3\u679C:\n";
+      const parts = [];
       if (req.analysis.exports?.length > 0) {
-        prompt += `\u5BFC\u51FA\u9879:
-${req.analysis.exports.map((e) => {
-          const params = e.params?.length ? `(${e.params.join(", ")})` : "";
-          const asyncFlag = e.isAsync ? "async " : "";
-          return `  - ${asyncFlag}${e.name}${params} [${e.kind}]`;
-        }).join("\n")}
-`;
+        parts.push(`\u5BFC\u51FA:${req.analysis.exports.map((e) => {
+          const p = e.params?.length ? `(${e.params.join(",")})` : "";
+          return `${e.isAsync ? "async " : ""}${e.name}${p}[${e.kind}]`;
+        }).join(",")}`);
       }
       if (req.analysis.props?.length) {
-        prompt += `Props:
-${req.analysis.props.map(
-          (p) => `  - ${p.name}: ${p.type}${p.required ? " (\u5FC5\u586B)" : " (\u53EF\u9009)"}`
-        ).join("\n")}
-`;
+        parts.push(`Props:${req.analysis.props.map((p) => `${p.name}:${p.type}${p.required ? "!" : "?"}`).join(",")}`);
       }
       if (req.analysis.emits?.length) {
-        prompt += `Emits:
-${req.analysis.emits.map(
-          (e) => `  - ${e.name}${e.params?.length ? `(${e.params.join(", ")})` : ""}`
-        ).join("\n")}
-`;
+        parts.push(`Emits:${req.analysis.emits.map((e) => `${e.name}(${e.params?.join(",") || ""})`).join(",")}`);
       }
       if (req.analysis.methods?.length) {
-        prompt += `Methods: ${req.analysis.methods.join(", ")}
-`;
+        parts.push(`Methods:${req.analysis.methods.join(",")}`);
       }
       if (req.analysis.computed?.length) {
-        prompt += `Computed: ${req.analysis.computed.join(", ")}
-`;
+        parts.push(`Computed:${req.analysis.computed.join(",")}`);
+      }
+      if (req.analysis.importSignatures?.length) {
+        parts.push(`\u4F9D\u8D56\u7B7E\u540D:${req.analysis.importSignatures.map(
+          (imp) => `${imp.source}{${Object.entries(imp.signatures).map(([k, v]) => `${k}:${v}`).join(",")}}`
+        ).join(";")}`);
       }
+      prompt += parts.join("\n") + "\n";
     }
     if (req.context) {
+      const importPathRewrites = this.buildImportPathRewrites(req.type, req.target);
       prompt += `
-\u6E90\u7801\u5185\u5BB9:
-\`\`\`typescript
-${req.context}
+\u6E90\u7801:
+\`\`\`
+${this.compressSourceCode(req.context, 3e3, importPathRewrites)}
 \`\`\`
 `;
     }
     if (req.framework) {
-      prompt += `
-\u6846\u67B6: ${req.framework}`;
+      prompt += `\u6846\u67B6:${req.framework}`;
     }
     return prompt;
   }
@@ -1100,18 +1140,54 @@ ${req.context}
     return `${prefix}${cleanPath}`;
   }
   /**
-   * 获取测试输出目录
+   * 构建 import 路径重写映射
+   * 将源码中可能引用自身的各种写法，映射到测试文件中正确的导入路径
    */
-  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";
+  buildImportPathRewrites(testType, targetPath) {
+    const rewrites = /* @__PURE__ */ new Map();
+    if (!targetPath) return rewrites;
+    const correctImportPath = this.computeTestImportPath(testType, targetPath);
+    const variations = /* @__PURE__ */ new Set();
+    variations.add(targetPath);
+    variations.add(targetPath.replace(/^\.\//, ""));
+    const withoutExt = targetPath.replace(/\.(ts|js|tsx|jsx)$/, "");
+    variations.add(withoutExt);
+    const srcDirMatch = targetPath.match(/^(?:\.\/)?(src\/.+)$/);
+    if (srcDirMatch) {
+      variations.add(`@/${srcDirMatch[1]}`);
+      variations.add(`@/${srcDirMatch[1].replace(/\.(ts|js|tsx|jsx)$/, "")}`);
+    }
+    const pathParts = targetPath.replace(/^\.\//, "").split("/");
+    const fileName = pathParts[pathParts.length - 1];
+    const fileNameNoExt = fileName.replace(/\.(ts|js|tsx|jsx|vue)$/, "");
+    variations.add(`./${fileName}`);
+    variations.add(`./${fileNameNoExt}`);
+    for (let i = 1; i < pathParts.length; i++) {
+      const relPath = "../".repeat(i) + pathParts.slice(i).join("/");
+      variations.add(relPath);
+      variations.add(relPath.replace(/\.(ts|js|tsx|jsx)$/, ""));
+    }
+    for (const variant of variations) {
+      if (variant && variant !== correctImportPath) {
+        rewrites.set(variant, correctImportPath);
+      }
+    }
+    return rewrites;
+  }
+  /**
+   * 重写源码中的 import 路径
+   * 将 from 'oldPath' / from "oldPath" 替换为正确的路径
+   */
+  rewriteImportPaths(code, rewrites) {
+    let result = code;
+    for (const [oldPath, newPath] of rewrites) {
+      const escaped = oldPath.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      const singleQuoteRegex = new RegExp(`(from\\s+')${escaped}(')`, "g");
+      const doubleQuoteRegex = new RegExp(`(from\\s+")${escaped}(")`, "g");
+      result = result.replace(singleQuoteRegex, `$1${newPath}$2`);
+      result = result.replace(doubleQuoteRegex, `$1${newPath}$2`);
+    }
+    return result;
   }
   parseGenerateTestResponse(content) {
     const codeBlockMatch = content.match(/```(?:typescript|ts|javascript|js)?\s*\n([\s\S]*?)```/);
@@ -1124,69 +1200,56 @@ ${req.context}
     };
   }
   buildReviewTestSystemPrompt(_req) {
-    return `\u4F60\u662F\u4E00\u4F4D\u4E25\u8C28\u7684\u6D4B\u8BD5\u5BA1\u8BA1\u4E13\u5BB6\u3002\u4F60\u7684\u804C\u8D23\u662F\u5BA1\u67E5 AI \u751F\u6210\u7684\u6D4B\u8BD5\u7528\u4F8B\u662F\u5426\u4E0E\u6E90\u7801\u8D34\u5207\u4E14\u51C6\u786E\u3002
-
-\u5BA1\u67E5\u6807\u51C6\uFF1A
-1. **\u6D4B\u8BD5\u7C7B\u578B\u5339\u914D**\uFF1A\u6D4B\u8BD5\u7C7B\u578B\u662F\u5426\u4E0E\u6E90\u7801\u6587\u4EF6\u6027\u8D28\u5339\u914D\uFF08\u5982 .vue \u5E94\u4E3A\u7EC4\u4EF6\u6D4B\u8BD5\uFF0Cutils \u5E94\u4E3A\u5355\u5143\u6D4B\u8BD5\uFF09
-2. **\u8986\u76D6\u5B8C\u6574\u6027**\uFF1A\u662F\u5426\u8986\u76D6\u4E86\u6E90\u7801\u4E2D\u7684\u6838\u5FC3\u5BFC\u51FA\u9879\uFF08\u51FD\u6570\u3001\u7EC4\u4EF6\u7684 props/emits/methods\uFF09
-3. **\u65AD\u8A00\u6709\u6548\u6027**\uFF1A\u65AD\u8A00\u662F\u5426\u771F\u5B9E\u68C0\u9A8C\u4E86\u88AB\u6D4B\u884C\u4E3A\uFF0C\u800C\u975E\u7A7A\u65AD\u8A00\u6216\u6C38\u771F\u65AD\u8A00
-4. **\u5BFC\u5165\u6B63\u786E\u6027**\uFF1Aimport \u8DEF\u5F84\u548C\u6A21\u5757\u662F\u5426\u6B63\u786E
-5. **\u4EE3\u7801\u53EF\u8FD0\u884C\u6027**\uFF1A\u6D4B\u8BD5\u4EE3\u7801\u662F\u5426\u53EF\u76F4\u63A5\u8FD0\u884C\uFF0C\u65E0\u8BED\u6CD5\u9519\u8BEF
-
-\u8F93\u51FA\u683C\u5F0F\uFF08\u4E25\u683C\u9075\u5B88\uFF09\uFF1A
-APPROVED: true \u6216 false
-SCORE: 0.0 \u5230 1.0 \u4E4B\u95F4\u7684\u8BC4\u5206
-FEEDBACK: \u4E00\u53E5\u8BDD\u5BA1\u8BA1\u610F\u89C1
-ISSUES: \u95EE\u9898\u5217\u8868\uFF08\u6BCF\u884C\u4E00\u4E2A\uFF0C\u683C\u5F0F "- \u95EE\u9898\u63CF\u8FF0"\uFF09
-SUGGESTIONS: \u6539\u8FDB\u5EFA\u8BAE\u5217\u8868\uFF08\u6BCF\u884C\u4E00\u4E2A\uFF0C\u683C\u5F0F "- \u5EFA\u8BAE\u63CF\u8FF0"\uFF09`;
+    return `\u4F60\u662F\u6D4B\u8BD5\u5BA1\u8BA1\u4E13\u5BB6\u3002\u5BA1\u67E5\u6D4B\u8BD5\u4EE3\u7801\u662F\u5426\u51C6\u786E\u3002
+\u6807\u51C6:1.\u7C7B\u578B\u5339\u914D 2.\u8986\u76D6\u6838\u5FC3\u5BFC\u51FA/props/emits 3.\u65AD\u8A00\u6709\u6548(\u975E\u6C38\u771F) 4.import\u6B63\u786E 5.\u53EF\u8FD0\u884C
+\u8F93\u51FA:
+APPROVED:true\u6216false
+SCORE:0.0-1.0
+FEEDBACK:\u4E00\u53E5\u8BDD
+ISSUES:- \u95EE\u9898(\u6BCF\u884C\u4E00\u4E2A)
+SUGGESTIONS:- \u5EFA\u8BAE(\u6BCF\u884C\u4E00\u4E2A)`;
   }
   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
-${req.sourceCode}
+    let prompt = `\u5BA1\u67E5\u6D4B\u8BD5\u4EE3\u7801\u3002\u88AB\u6D4B:${req.target} \u7C7B\u578B:${req.testType}
+\u3010\u5F3A\u5236\u3011import\u88AB\u6D4B\u6A21\u5757\u5FC5\u987B\u7528: ${importPath}
+`;
+    const importPathRewrites = this.buildImportPathRewrites(req.testType, req.target);
+    prompt += `
+\u6E90\u7801:
+\`\`\`
+${this.compressSourceCode(req.sourceCode, 2e3, importPathRewrites)}
+\`\`\`
+`;
+    prompt += `
+\u6D4B\u8BD5\u4EE3\u7801:
 \`\`\`
-
---- \u751F\u6210\u7684\u6D4B\u8BD5\u4EE3\u7801 ---
-\`\`\`typescript
 ${req.testCode}
 \`\`\``;
     if (req.analysis) {
-      prompt += "\n\n--- \u6E90\u7801\u5206\u6790 ---";
+      const parts = [];
       if (req.analysis.exports?.length > 0) {
-        prompt += `
-\u5BFC\u51FA\u9879:
-${req.analysis.exports.map((e) => {
-          const params = e.params?.length ? `(${e.params.join(", ")})` : "";
-          const asyncFlag = e.isAsync ? "async " : "";
-          return `  - ${asyncFlag}${e.name}${params} [${e.kind}]`;
-        }).join("\n")}`;
+        parts.push(`\u5BFC\u51FA:${req.analysis.exports.map((e) => `${e.isAsync ? "async " : ""}${e.name}(${e.params?.join(",") || ""})[${e.kind}]`).join(",")}`);
       }
       if (req.analysis.props?.length) {
-        prompt += `
-Props:
-${req.analysis.props.map(
-          (p) => `  - ${p.name}: ${p.type}${p.required ? " (\u5FC5\u586B)" : " (\u53EF\u9009)"}`
-        ).join("\n")}`;
+        parts.push(`Props:${req.analysis.props.map((p) => `${p.name}:${p.type}${p.required ? "!" : "?"}`).join(",")}`);
       }
       if (req.analysis.emits?.length) {
+        parts.push(`Emits:${req.analysis.emits.map((e) => `${e.name}(${e.params?.join(",") || ""})`).join(",")}`);
+      }
+      if (req.analysis.importSignatures?.length) {
+        parts.push(`\u4F9D\u8D56:${req.analysis.importSignatures.map(
+          (imp) => `${imp.source}{${Object.entries(imp.signatures).map(([k, v]) => `${k}:${v}`).join(",")}}`
+        ).join(";")}`);
+      }
+      if (parts.length > 0) {
         prompt += `
-Emits:
-${req.analysis.emits.map(
-          (e) => `  - ${e.name}${e.params?.length ? `(${e.params.join(", ")})` : ""}`
-        ).join("\n")}`;
+\u5206\u6790:${parts.join("|")}`;
       }
     }
     if (req.generationDescription) {
       prompt += `
-
-\u751F\u6210\u8005\u8BF4\u660E: ${req.generationDescription}`;
+\u8BF4\u660E:${req.generationDescription}`;
     }
     return prompt;
   }
@@ -1246,6 +1309,61 @@ ${req.analysis.emits.map(
     return urlMap[provider] || "https://api.openai.com/v1";
   }
 };
+function compressFunctionBodies(code, maxLength) {
+  const lines = code.split("\n");
+  const result = [];
+  let depth = 0;
+  let fnDepth = 0;
+  let inFunction = false;
+  let braceBalance = 0;
+  let capturedLines = 0;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    for (const ch of trimmed) {
+      if (ch === "{") {
+        braceBalance++;
+        depth++;
+      }
+      if (ch === "}") {
+        braceBalance--;
+        depth = Math.max(0, depth - 1);
+      }
+    }
+    const isFnSignature = /^(export\s+)?(async\s+)?function\s|=>\s*\{|=>\s*$/m.test(trimmed) || /^(const|let|var)\s+\w+\s*=\s*(async\s+)?(\([^)]*\)|[^=])\s*=>/.test(trimmed);
+    if (isFnSignature && !inFunction) {
+      inFunction = true;
+      fnDepth = depth;
+      result.push(line);
+      capturedLines++;
+      continue;
+    }
+    if (inFunction) {
+      const isReturn = trimmed.startsWith("return ");
+      const isBranch = /^(if|else|switch|case|try|catch|finally|for|while)/.test(trimmed);
+      const isClosing = trimmed === "}" && depth <= fnDepth - 1;
+      if (isClosing) {
+        result.push(line);
+        inFunction = false;
+        capturedLines++;
+      } else if (isReturn || isBranch) {
+        result.push(trimmed.length > 120 ? `${trimmed.slice(0, 120)}...` : line);
+        capturedLines++;
+      } else if (trimmed.startsWith("//") || trimmed === "") {
+      } else if (capturedLines < maxLength / 30) {
+        result.push(trimmed.length > 100 ? `${trimmed.slice(0, 100)}...` : line);
+        capturedLines++;
+      }
+    } else {
+      result.push(line);
+      capturedLines++;
+    }
+    if (result.join("\n").length > maxLength) {
+      result.push("// ... (truncated)");
+      break;
+    }
+  }
+  return result.join("\n");
+}
 
 // src/ai/provider.ts
 var providerRegistry = /* @__PURE__ */ new Map();
@@ -1315,15 +1433,18 @@ import path4 from "path";
 function analyzeFile(filePath) {
   const absolutePath = path4.resolve(process.cwd(), filePath);
   if (!fs4.existsSync(absolutePath)) {
-    return { filePath, exports: [], apiCalls: [] };
+    return { filePath, exports: [], imports: [], importSignatures: [], apiCalls: [] };
   }
   const content = fs4.readFileSync(absolutePath, "utf-8");
   const ext = path4.extname(filePath);
   const result = {
     filePath,
     exports: extractExports(content, ext),
+    imports: extractImports(content),
+    importSignatures: [],
     apiCalls: extractAPICalls(content, filePath)
   };
+  result.importSignatures = analyzeImportSignatures(result.imports, path4.dirname(absolutePath));
   if (ext === ".vue") {
     result.vueAnalysis = analyzeVueComponent(content, path4.basename(filePath, ".vue"));
     const scriptMatch = content.match(/<script[^>]*>([\s\S]*?)<\/script>/);
@@ -1743,6 +1864,90 @@ function generateMockRoutesFromAPICalls(apiCalls) {
   }
   return routes;
 }
+function extractImports(content) {
+  const imports = [];
+  const namedImportRegex = /import\s*\{([^}]+)\}\s*from\s*['"]([^'"]+)['"]/g;
+  let match;
+  while ((match = namedImportRegex.exec(content)) !== null) {
+    const names = match[1].split(",").map((n) => {
+      const parts = n.trim().split(/\s+as\s+/);
+      return parts[0].trim();
+    }).filter(Boolean);
+    imports.push({ names, source: match[2], isDefault: false, isNamespace: false });
+  }
+  const defaultImportRegex = /import\s+(\w+)\s+from\s*['"]([^'"]+)['"]/g;
+  while ((match = defaultImportRegex.exec(content)) !== null) {
+    const fullLine = content.slice(Math.max(0, match.index - 5), match.index + match[0].length);
+    if (fullLine.includes("{")) continue;
+    imports.push({ names: [match[1]], source: match[2], isDefault: true, isNamespace: false });
+  }
+  const namespaceImportRegex = /import\s*\*\s*as\s+(\w+)\s*from\s*['"]([^'"]+)['"]/g;
+  while ((match = namespaceImportRegex.exec(content)) !== null) {
+    imports.push({ names: [match[1]], source: match[2], isDefault: false, isNamespace: true });
+  }
+  return imports;
+}
+function analyzeImportSignatures(imports, baseDir) {
+  const signatures = [];
+  for (const imp of imports) {
+    if (!imp.source.startsWith(".") && !imp.source.startsWith("@/") && !imp.source.startsWith("~")) {
+      continue;
+    }
+    const resolvedPath = resolveImportPath(imp.source, baseDir);
+    if (!resolvedPath || !fs4.existsSync(resolvedPath)) continue;
+    try {
+      const content = fs4.readFileSync(resolvedPath, "utf-8");
+      const ext = path4.extname(resolvedPath);
+      const exports = extractExports(content, ext);
+      const sigMap = {};
+      for (const name of imp.names) {
+        const exp = exports.find((e) => e.name === name);
+        if (exp) {
+          const params = exp.params.length > 0 ? `(${exp.params.join(", ")})` : "";
+          const ret = exp.returnType ? `: ${exp.returnType}` : "";
+          const async = exp.isAsync ? "async " : "";
+          sigMap[name] = `${async}${exp.kind}${params}${ret}`;
+        } else if (imp.isDefault) {
+          const defaultExp = exports.find((e) => e.kind === "default");
+          if (defaultExp) {
+            sigMap[name] = `default[${defaultExp.name || "anonymous"}]`;
+          }
+        } else if (imp.isNamespace) {
+          sigMap[name] = `{${exports.map((e) => e.name).join(", ")}}`;
+        }
+      }
+      if (ext === ".vue") {
+        const vueAnalysis = analyzeVueComponent(content, path4.basename(resolvedPath, ".vue"));
+        if (vueAnalysis.props.length > 0) {
+          sigMap["__props__"] = vueAnalysis.props.map((p) => `${p.name}:${p.type}${p.required ? "!" : "?"}`).join(",");
+        }
+      }
+      if (Object.keys(sigMap).length > 0) {
+        signatures.push({ source: imp.source, signatures: sigMap });
+      }
+    } catch {
+    }
+  }
+  return signatures;
+}
+function resolveImportPath(importSource, baseDir) {
+  let resolved;
+  if (importSource.startsWith("@/") || importSource.startsWith("~")) {
+    const relativePath = importSource.replace(/^[@~]\//, "src/");
+    resolved = path4.resolve(process.cwd(), relativePath);
+  } else if (importSource.startsWith(".")) {
+    resolved = path4.resolve(baseDir, importSource);
+  } else {
+    return null;
+  }
+  const extensions = [".ts", ".tsx", ".js", ".jsx", ".vue", "/index.ts", "/index.js"];
+  if (fs4.existsSync(resolved)) return resolved;
+  for (const ext of extensions) {
+    const withExt = resolved + ext;
+    if (fs4.existsSync(withExt)) return withExt;
+  }
+  return null;
+}
 
 // src/services/global-config.ts
 import fs5 from "fs";
@@ -1794,7 +1999,7 @@ function registerInitCommand(program2) {
     try {
       await executeInit(options);
     } catch (error) {
-      console.error(chalk2.red(`
+      console.error(chalk3.red(`
   \u2717 ${error instanceof Error ? error.message : String(error)}
 `));
       process.exit(1);
@@ -1816,19 +2021,19 @@ async function executeInit(options) {
       }
     ]);
     if (!proceed) {
-      console.log(chalk2.gray("\n  \u5DF2\u53D6\u6D88\u521D\u59CB\u5316\n"));
+      console.log(chalk3.gray("\n  \u5DF2\u53D6\u6D88\u521D\u59CB\u5316\n"));
       return;
     }
   }
   let globalAI = loadGlobalAIConfig();
   if (!globalAI) {
-    console.log(chalk2.cyan("  AI \u6A21\u578B\u914D\u7F6E (\u9996\u6B21\u4F7F\u7528\u9700\u914D\u7F6E\uFF0C\u4E4B\u540E\u53EF\u901A\u8FC7 qat change \u4FEE\u6539)\n"));
+    console.log(chalk3.cyan("  AI \u6A21\u578B\u914D\u7F6E (\u9996\u6B21\u4F7F\u7528\u9700\u914D\u7F6E\uFF0C\u4E4B\u540E\u53EF\u901A\u8FC7 qat change \u4FEE\u6539)\n"));
     globalAI = await promptAIConfig();
     saveGlobalAIConfig(globalAI);
-    console.log(chalk2.gray(`  \u914D\u7F6E\u5DF2\u4FDD\u5B58\u81F3 ${getAIConfigPath()}
+    console.log(chalk3.gray(`  \u914D\u7F6E\u5DF2\u4FDD\u5B58\u81F3 ${getAIConfigPath()}
 `));
   } else {
-    console.log(chalk2.green(`  \u2713 \u5F53\u524D AI \u6A21\u578B: ${chalk2.white(globalAI.model)} @ ${chalk2.gray(globalAI.baseUrl)} (${maskApiKey(globalAI.apiKey)})
+    console.log(chalk3.green(`  \u2713 \u5F53\u524D AI \u6A21\u578B: ${chalk3.white(globalAI.model)} @ ${chalk3.gray(globalAI.baseUrl)} (${maskApiKey(globalAI.apiKey)})
 `));
   }
   const aiConfig = toAIConfig(globalAI);
@@ -1837,51 +2042,23 @@ async function executeInit(options) {
     try {
       const result = await testAIConnection(aiConfig);
       if (result.ok) {
-        testSpinner.succeed(`AI \u8FDE\u901A\u6B63\u5E38 ${chalk2.gray(`${globalAI.model} (${result.latencyMs}ms)`)}`);
+        testSpinner.succeed(`AI \u8FDE\u901A\u6B63\u5E38 ${chalk3.gray(`${globalAI.model} (${result.latencyMs}ms)`)}`);
       } else {
         testSpinner.fail(`AI \u8FDE\u901A\u5F02\u5E38: ${result.message}`);
-        console.log(chalk2.yellow("  \u53EF\u8FD0\u884C qat change \u4FEE\u6539 AI \u914D\u7F6E\u3002"));
+        console.log(chalk3.yellow("  \u53EF\u8FD0\u884C qat change \u4FEE\u6539 AI \u914D\u7F6E\u3002"));
       }
     } catch (error) {
       testSpinner.fail(`AI \u8FDE\u901A\u6D4B\u8BD5\u5931\u8D25: ${error instanceof Error ? error.message : String(error)}`);
     }
   }
   const config = buildProjectConfig(projectInfo);
-  let configPath;
   const existingConfigPath = path6.join(process.cwd(), "qat.config.js");
   const existingTsPath = path6.join(process.cwd(), "qat.config.ts");
   const configExists = fs6.existsSync(existingConfigPath) || fs6.existsSync(existingTsPath);
-  if (configExists && !options.force) {
-    const { overwrite } = await inquirer.prompt([
-      {
-        type: "confirm",
-        name: "overwrite",
-        message: "\u914D\u7F6E\u6587\u4EF6 qat.config.js \u5DF2\u5B58\u5728\uFF0C\u662F\u5426\u8986\u76D6\uFF1F",
-        default: true
-      }
-    ]);
-    if (!overwrite) {
-      console.log(chalk2.gray("  \u4FDD\u7559\u73B0\u6709\u914D\u7F6E\u6587\u4EF6\uFF0C\u7EE7\u7EED\u540E\u7EED\u6B65\u9AA4..."));
-      configPath = existingConfigPath;
-    } else {
-      const fileSpinner = ora("\u6B63\u5728\u8986\u76D6\u914D\u7F6E\u6587\u4EF6...").start();
-      try {
-        configPath = await writeConfigFile(process.cwd(), config, true);
-        fileSpinner.succeed("\u914D\u7F6E\u6587\u4EF6\u5DF2\u8986\u76D6");
-      } catch (error) {
-        fileSpinner.fail("\u914D\u7F6E\u6587\u4EF6\u8986\u76D6\u5931\u8D25");
-        throw error;
-      }
-    }
+  if (!configExists) {
+    console.log(chalk3.gray("  \u672A\u627E\u5230\u914D\u7F6E\u6587\u4EF6\uFF0C\u4F7F\u7528\u9ED8\u8BA4\u914D\u7F6E\uFF08\u9700\u8981\u81EA\u5B9A\u4E49\u65F6\u53EF\u521B\u5EFA qat.config.js\uFF09"));
   } else {
-    const fileSpinner = ora("\u6B63\u5728\u751F\u6210\u914D\u7F6E\u6587\u4EF6...").start();
-    try {
-      configPath = await writeConfigFile(process.cwd(), config, options.force);
-      fileSpinner.succeed("\u914D\u7F6E\u6587\u4EF6\u5DF2\u751F\u6210");
-    } catch (error) {
-      fileSpinner.fail("\u914D\u7F6E\u6587\u4EF6\u751F\u6210\u5931\u8D25");
-      throw error;
-    }
+    console.log(chalk3.green(`  \u2713 \u5DF2\u6709\u914D\u7F6E\u6587\u4EF6: ${path6.basename(fs6.existsSync(existingConfigPath) ? existingConfigPath : existingTsPath)}`));
   }
   const dirSpinner = ora("\u6B63\u5728\u521B\u5EFA\u6D4B\u8BD5\u76EE\u5F55...").start();
   const createdDirs = createTestDirectories(config);
@@ -1896,10 +2073,10 @@ async function executeInit(options) {
       const mockFilePath = path6.join(process.cwd(), mockDir, "auto-generated.json");
       if (!fs6.existsSync(mockFilePath)) {
         fs6.writeFileSync(mockFilePath, JSON.stringify(mockRoutes, null, 2), "utf-8");
-        console.log(chalk2.green(`    \u81EA\u52A8\u53D1\u73B0 ${apiCalls.length} \u4E2A API \u63A5\u53E3\uFF0C\u5DF2\u751F\u6210 Mock \u8DEF\u7531`));
+        console.log(chalk3.green(`    \u81EA\u52A8\u53D1\u73B0 ${apiCalls.length} \u4E2A API \u63A5\u53E3\uFF0C\u5DF2\u751F\u6210 Mock \u8DEF\u7531`));
       }
     } else {
-      console.log(chalk2.gray("    \u672A\u53D1\u73B0 API \u8C03\u7528\uFF0C\u5DF2\u751F\u6210\u793A\u4F8B Mock \u8DEF\u7531"));
+      console.log(chalk3.gray("    \u672A\u53D1\u73B0 API \u8C03\u7528\uFF0C\u5DF2\u751F\u6210\u793A\u4F8B Mock \u8DEF\u7531"));
     }
   }
   const srcDir = config.project?.srcDir || "src";
@@ -1907,10 +2084,10 @@ async function executeInit(options) {
   const utilities = discoverUtilityFiles(process.cwd(), srcDir);
   const totalFiles = components.length + utilities.length;
   if (totalFiles > 0) {
-    console.log(chalk2.cyan(`
+    console.log(chalk3.cyan(`
   \u53D1\u73B0 ${totalFiles} \u4E2A\u53EF\u6D4B\u8BD5\u6587\u4EF6 (${components.length} \u7EC4\u4EF6, ${utilities.length} \u5DE5\u5177/\u670D\u52A1)`));
   }
-  displayResult(configPath, createdDirs, totalFiles, projectInfo);
+  displayResult(createdDirs, totalFiles, projectInfo);
 }
 async function promptAIConfig() {
   const answers = await inquirer.prompt([
@@ -1994,8 +2171,8 @@ function buildProjectConfig(projectInfo) {
   };
 }
 function displayProjectInfo(info) {
-  console.log(chalk2.cyan("\n  \u9879\u76EE\u68C0\u6D4B\u7ED3\u679C:"));
-  console.log(chalk2.gray("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+  console.log(chalk3.cyan("\n  \u9879\u76EE\u68C0\u6D4B\u7ED3\u679C:"));
+  console.log(chalk3.gray("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
   const items = [
     ["\u9879\u76EE\u540D\u79F0", info.name],
     ["\u6846\u67B6", info.frameworkConfidence > 0.5 ? `${info.frameworkDisplayName} (\u7F6E\u4FE1\u5EA6 ${Math.round(info.frameworkConfidence * 100)}%)` : info.frameworkDisplayName],
@@ -2017,8 +2194,8 @@ function displayProjectInfo(info) {
     items.push(["\u7EC4\u4EF6\u76EE\u5F55", info.componentDirs.join(", ")]);
   }
   for (const [label, value] of items) {
-    const displayValue = value === true ? chalk2.green("\u2713") : value === false ? chalk2.red("\u2717") : String(value);
-    console.log(`  ${chalk2.white(label.padEnd(12))} ${displayValue}`);
+    const displayValue = value === true ? chalk3.green("\u2713") : value === false ? chalk3.red("\u2717") : String(value);
+    console.log(`  ${chalk3.white(label.padEnd(12))} ${displayValue}`);
   }
   console.log();
 }
@@ -2047,40 +2224,39 @@ function createTestDirectories(config) {
   }
   return dirs;
 }
-function displayResult(configPath, createdDirs, totalTestableFiles, projectInfo) {
-  const relativeConfig = path6.relative(process.cwd(), configPath);
-  console.log(chalk2.green("\n  \u2713 \u9879\u76EE\u521D\u59CB\u5316\u5B8C\u6210!\n"));
-  console.log(chalk2.white("  \u5DF2\u751F\u6210\u914D\u7F6E:"));
-  console.log(chalk2.gray(`    ${relativeConfig}`));
-  console.log();
+function displayResult(createdDirs, totalTestableFiles, projectInfo) {
+  console.log(chalk3.green("\n  \u2713 \u9879\u76EE\u521D\u59CB\u5316\u5B8C\u6210!\n"));
   if (createdDirs.length > 0) {
-    console.log(chalk2.white("  \u5DF2\u521B\u5EFA\u76EE\u5F55:"));
+    console.log(chalk3.white("  \u5DF2\u521B\u5EFA\u76EE\u5F55:"));
     for (const dir of createdDirs) {
-      console.log(chalk2.gray(`    ${dir}/`));
+      console.log(chalk3.gray(`    ${dir}/`));
     }
     console.log();
   }
-  console.log(chalk2.cyan("  \u4E0B\u4E00\u6B65:"));
+  console.log(chalk3.white("  \u914D\u7F6E:"));
+  console.log(chalk3.gray("    \u9ED8\u8BA4\u914D\u7F6E\u5DF2\u5185\u7F6E\uFF0C\u9700\u8981\u81EA\u5B9A\u4E49\u65F6\u521B\u5EFA qat.config.js"));
+  console.log();
+  console.log(chalk3.cyan("  \u4E0B\u4E00\u6B65:"));
   if (totalTestableFiles > 0) {
-    console.log(chalk2.gray(`    1. qat create    \u9009\u62E9\u6587\u4EF6\u5E76\u751F\u6210\u6D4B\u8BD5\u7528\u4F8B (\u53D1\u73B0 ${totalTestableFiles} \u4E2A\u53EF\u6D4B\u8BD5\u6587\u4EF6)`));
+    console.log(chalk3.gray(`    1. qat create    \u9009\u62E9\u6587\u4EF6\u5E76\u751F\u6210\u6D4B\u8BD5\u7528\u4F8B (\u53D1\u73B0 ${totalTestableFiles} \u4E2A\u53EF\u6D4B\u8BD5\u6587\u4EF6)`));
   } else {
-    console.log(chalk2.gray("    1. qat create    \u521B\u5EFA\u6D4B\u8BD5\u7528\u4F8B"));
+    console.log(chalk3.gray("    1. qat create    \u521B\u5EFA\u6D4B\u8BD5\u7528\u4F8B"));
   }
-  console.log(chalk2.gray("    2. qat run       \u6267\u884C\u6D4B\u8BD5"));
-  console.log(chalk2.gray("    3. qat status    \u67E5\u770B AI \u6A21\u578B\u72B6\u6001"));
+  console.log(chalk3.gray("    2. qat run       \u6267\u884C\u6D4B\u8BD5"));
+  console.log(chalk3.gray("    3. qat status    \u67E5\u770B AI \u6A21\u578B\u72B6\u6001"));
   if (projectInfo.testFrameworks.length === 0) {
     console.log();
-    console.log(chalk2.yellow("  \u26A0 \u672A\u68C0\u6D4B\u5230\u6D4B\u8BD5\u6846\u67B6\u4F9D\u8D56\uFF0C\u8FD0\u884C qat run \u65F6\u4F1A\u63D0\u793A\u5B89\u88C5"));
+    console.log(chalk3.yellow("  \u26A0 \u672A\u68C0\u6D4B\u5230\u6D4B\u8BD5\u6846\u67B6\u4F9D\u8D56\uFF0C\u8FD0\u884C qat run \u65F6\u4F1A\u63D0\u793A\u5B89\u88C5"));
   }
   console.log();
 }
 
 // src/commands/create.ts
-import chalk4 from "chalk";
+import chalk5 from "chalk";
 import inquirer2 from "inquirer";
 import ora3 from "ora";
 import fs8 from "fs";
-import path8 from "path";
+import path9 from "path";
 
 // src/services/template.ts
 import fs7 from "fs";
@@ -2129,7 +2305,7 @@ Handlebars.registerHelper("propTestValue", (prop) => {
   };
   return map[prop.type] || "'test-value'";
 });
-function resolveImportPath(testType, targetPath) {
+function resolveImportPath2(testType, targetPath) {
   if (!targetPath) return targetPath;
   const testDirMap = {
     unit: "tests/unit",
@@ -2155,7 +2331,7 @@ function resolveImportPath(testType, targetPath) {
 function renderTemplate(type, context) {
   const templateContent = loadTemplate(type);
   const template = Handlebars.compile(templateContent);
-  const resolvedTarget = resolveImportPath(type, context.target);
+  const resolvedTarget = resolveImportPath2(type, context.target);
   const fullContext = {
     vueVersion: 3,
     typescript: true,
@@ -2537,12 +2713,13 @@ function toPascalCase(str) {
 }
 
 // src/services/test-reviewer.ts
-import chalk3 from "chalk";
+import chalk4 from "chalk";
 import ora2 from "ora";
+import path8 from "path";
 var MAX_RETRIES = 3;
 var REVIEW_THRESHOLD = 0.6;
 async function generateWithReview(params) {
-  const { testType, targetPath, sourceCode, analysis, aiConfig, framework, onAttempt } = params;
+  const { testType, targetPath, sourceCode, analysis, aiConfig, framework, onAttempt, onProgress } = params;
   const generatorProvider = createAIProvider(aiConfig);
   const reviewerProvider = createAIProvider(aiConfig);
   if (!generatorProvider.capabilities.generateTest) {
@@ -2554,9 +2731,15 @@ async function generateWithReview(params) {
   let lastReview = null;
   let approved = false;
   let attempts = 0;
+  const targetName = path8.basename(targetPath);
   for (let i = 0; i < MAX_RETRIES; i++) {
     attempts = i + 1;
     onAttempt?.(attempts, MAX_RETRIES);
+    const genLabel = attempts > 1 ? `\u27F3 \u91CD\u65B0\u751F\u6210 (${attempts}/${MAX_RETRIES})` : "\u751F\u6210\u6D4B\u8BD5\u4EE3\u7801";
+    onProgress?.(`${genLabel} \u2190 ${targetName}`);
+    if (process.env.QAT_DEBUG === "true") {
+      console.error(chalk4.gray(`[DEBUG] \u2500\u2500\u2500 \u751F\u6210\u8005 AI \u7B2C${attempts}\u6B21\u5C1D\u8BD5 \u2500\u2500\u2500`));
+    }
     const generationPrompt = i === 0 ? void 0 : `\u4E0A\u6B21\u751F\u6210\u7684\u6D4B\u8BD5\u672A\u901A\u8FC7\u5BA1\u8BA1\uFF0C\u8BF7\u6839\u636E\u4EE5\u4E0B\u53CD\u9988\u91CD\u65B0\u751F\u6210\uFF1A
 \u5BA1\u8BA1\u8BC4\u5206: ${(lastReview.score * 100).toFixed(0)}%
 \u5BA1\u8BA1\u610F\u89C1: ${lastReview.feedback}
@@ -2569,16 +2752,18 @@ ${lastReview.suggestions.map((s) => `- ${s}`).join("\n")}
     const generateResponse = await generatorProvider.generateTest({
       type: testType,
       target: targetPath,
-      context: i === 0 ? sourceCode : `${sourceCode}
-
---- \u5BA1\u8BA1\u53CD\u9988 ---
-${generationPrompt}`,
+      // 重试时：源码已压缩在分析摘要中，context只传审计反馈以减少token
+      context: i === 0 ? sourceCode : generationPrompt,
       framework: framework || void 0,
       analysis
     });
     currentCode = generateResponse.code;
     currentDescription = generateResponse.description;
     currentConfidence = generateResponse.confidence;
+    onProgress?.(`\u5BA1\u8BA1\u5BA1\u67E5 \u2190 ${targetName}`);
+    if (process.env.QAT_DEBUG === "true") {
+      console.error(chalk4.gray(`[DEBUG] \u2500\u2500\u2500 \u5BA1\u8BA1\u5458 AI \u5BA1\u67E5 \u2500\u2500\u2500`));
+    }
     const reviewRequest = {
       target: targetPath,
       sourceCode,
@@ -2610,20 +2795,20 @@ function printReviewReport(report) {
   const approved = report.filter((r) => r.approved);
   const failed = report.filter((r) => !r.approved);
   console.log();
-  console.log(chalk3.cyan("  \u5BA1\u8BA1\u62A5\u544A:"));
-  console.log(chalk3.gray("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+  console.log(chalk4.cyan("  \u5BA1\u8BA1\u62A5\u544A:"));
+  console.log(chalk4.gray("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
   for (const entry of approved) {
-    console.log(`  ${chalk3.green("\u2713")} ${chalk3.gray(entry.target)} ${chalk3.green(`(${(entry.score * 100).toFixed(0)}%`)}${entry.attempts > 1 ? chalk3.yellow(` ${entry.attempts}\u6B21\u5C1D\u8BD5`) : ""})`);
+    console.log(`  ${chalk4.green("\u2713")} ${chalk4.gray(entry.target)} ${chalk4.green(`(${(entry.score * 100).toFixed(0)}%`)}${entry.attempts > 1 ? chalk4.yellow(` ${entry.attempts}\u6B21\u5C1D\u8BD5`) : ""})`);
   }
   for (const entry of failed) {
-    console.log(`  ${chalk3.red("\u2717")} ${chalk3.gray(entry.target)} ${chalk3.red(`(${(entry.score * 100).toFixed(0)}%)`)}`);
+    console.log(`  ${chalk4.red("\u2717")} ${chalk4.gray(entry.target)} ${chalk4.red(`(${(entry.score * 100).toFixed(0)}%)`)}`);
     if (entry.issues.length > 0) {
       for (const issue of entry.issues.slice(0, 3)) {
-        console.log(chalk3.gray(`      - ${issue}`));
+        console.log(chalk4.gray(`      - ${issue}`));
       }
     }
     if (entry.feedback) {
-      console.log(chalk3.gray(`      \u53CD\u9988: ${entry.feedback}`));
+      console.log(chalk4.gray(`      \u53CD\u9988: ${entry.feedback}`));
     }
   }
   console.log();
@@ -2651,7 +2836,7 @@ function registerCreateCommand(program2) {
     try {
       await executeCreate(options);
     } catch (error) {
-      console.error(chalk4.red(`
+      console.error(chalk5.red(`
   \u2717 ${error instanceof Error ? error.message : String(error)}
 `));
       process.exit(1);
@@ -2676,7 +2861,7 @@ async function executeCreate(options) {
         name: "types",
         message: "\u9009\u62E9\u6D4B\u8BD5\u7C7B\u578B (\u7A7A\u683C\u9009\u62E9/\u53D6\u6D88\uFF0C\u56DE\u8F66\u786E\u8BA4):",
         choices: Object.entries(TEST_TYPE_LABELS).map(([value, label]) => ({
-          name: `${label} - ${chalk4.gray(TEST_TYPE_DESCRIPTIONS[value])}`,
+          name: `${label} - ${chalk5.gray(TEST_TYPE_DESCRIPTIONS[value])}`,
           value,
           short: label,
           checked: value === "unit" || value === "component"
@@ -2734,11 +2919,13 @@ async function executeCreate(options) {
   const reviewReportEntries = [];
   for (const testType of types) {
     for (const testTarget of targets) {
-      const spinner = ora3(`\u6B63\u5728\u751F\u6210 ${TEST_TYPE_LABELS[testType]} - ${path8.basename(testTarget)}...`).start();
+      const spinner = ora3(`\u6B63\u5728\u751F\u6210 ${TEST_TYPE_LABELS[testType]} - ${path9.basename(testTarget)}...`).start();
       try {
         let content;
         if (useAI && testTarget) {
-          const aiResult = await generateWithAI(testType, name, testTarget, config);
+          const aiResult = await generateWithAI(testType, name, testTarget, config, (text) => {
+            spinner.text = `${text}`;
+          });
           content = aiResult.code;
           if (aiResult.reviewEntry) {
             reviewReportEntries.push(aiResult.reviewEntry);
@@ -2779,9 +2966,9 @@ async function executeCreate(options) {
           });
         }
         const outputDir = getTestOutputDir(testType);
-        const filePath = path8.join(outputDir, `${name}.${testType === "e2e" ? "spec" : "test"}.ts`);
+        const filePath = path9.join(outputDir, `${name}.${testType === "e2e" ? "spec" : "test"}.ts`);
         if (fs8.existsSync(filePath)) {
-          spinner.warn(`\u6D4B\u8BD5\u6587\u4EF6\u5DF2\u5B58\u5728: ${path8.relative(process.cwd(), filePath)}`);
+          spinner.warn(`\u6D4B\u8BD5\u6587\u4EF6\u5DF2\u5B58\u5728: ${path9.relative(process.cwd(), filePath)}`);
           skippedCount++;
           continue;
         }
@@ -2789,11 +2976,11 @@ async function executeCreate(options) {
           fs8.mkdirSync(outputDir, { recursive: true });
         }
         fs8.writeFileSync(filePath, content, "utf-8");
-        spinner.succeed(`${TEST_TYPE_LABELS[testType]} - ${path8.basename(testTarget)}`);
+        spinner.succeed(`${TEST_TYPE_LABELS[testType]} - ${path9.basename(testTarget)}`);
         createdFiles.push({ type: testType, filePath });
       } catch (error) {
-        spinner.fail(`${TEST_TYPE_LABELS[testType]} - ${path8.basename(testTarget)} \u521B\u5EFA\u5931\u8D25`);
-        console.log(chalk4.gray(`    ${error instanceof Error ? error.message : String(error)}`));
+        spinner.fail(`${TEST_TYPE_LABELS[testType]} - ${path9.basename(testTarget)} \u521B\u5EFA\u5931\u8D25`);
+        console.log(chalk5.gray(`    ${error instanceof Error ? error.message : String(error)}`));
       }
     }
   }
@@ -2807,13 +2994,13 @@ async function selectTargets(types, projectInfo, srcDir) {
   if (types.includes("unit")) {
     const utils = discoverUtilityFiles(process.cwd(), srcDir);
     for (const f of utils.slice(0, 30)) {
-      allTargets.push({ name: `${chalk4.gray("[unit]")} ${f}`, value: f });
+      allTargets.push({ name: `${chalk5.gray("[unit]")} ${f}`, value: f });
     }
   }
   if (types.includes("component")) {
     const components = discoverVueComponents(process.cwd(), srcDir);
     for (const f of components.slice(0, 30)) {
-      allTargets.push({ name: `${chalk4.gray("[comp]")} ${f}`, value: f });
+      allTargets.push({ name: `${chalk5.gray("[comp]")} ${f}`, value: f });
     }
   }
   if (allTargets.length === 0) {
@@ -2834,7 +3021,7 @@ async function selectTargets(types, projectInfo, srcDir) {
       message: "\u9009\u62E9\u88AB\u6D4B\u76EE\u6807 (\u7A7A\u683C\u9009\u62E9/\u53D6\u6D88\uFF0C\u56DE\u8F66\u786E\u8BA4):",
       choices: [
         ...allTargets,
-        { name: chalk4.gray("\u624B\u52A8\u8F93\u5165\u8DEF\u5F84"), value: "__manual__" }
+        { name: chalk5.gray("\u624B\u52A8\u8F93\u5165\u8DEF\u5F84"), value: "__manual__" }
       ],
       validate: (input) => {
         if (input.length === 0) return "\u8BF7\u81F3\u5C11\u9009\u62E9\u4E00\u4E2A\u76EE\u6807";
@@ -2859,22 +3046,22 @@ async function selectTargets(types, projectInfo, srcDir) {
 }
 function generateDefaultName(type, target) {
   if (!target) return `${type}-test`;
-  const basename = path8.basename(target, path8.extname(target));
+  const basename = path9.basename(target, path9.extname(target));
   const cleaned = basename.replace(/[^a-zA-Z0-9]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
   return cleaned || `${type}-test`;
 }
-async function generateWithAI(type, name, target, config) {
+async function generateWithAI(type, name, target, config, onProgress) {
   const provider = getAIProvider(config.ai);
   if (!provider.capabilities.generateTest) {
     throw new Error("\u5F53\u524D AI Provider \u4E0D\u652F\u6301\u6D4B\u8BD5\u751F\u6210");
   }
   let sourceCode = "";
-  const fullPath = path8.resolve(process.cwd(), target);
+  const fullPath = path9.resolve(process.cwd(), target);
   if (fs8.existsSync(fullPath)) {
     sourceCode = fs8.readFileSync(fullPath, "utf-8");
   }
   const analysis = analyzeFile(target);
-  const analysisSummary = analysis.exports.length > 0 || analysis.vueAnalysis ? {
+  const analysisSummary = analysis.exports.length > 0 || analysis.vueAnalysis || analysis.importSignatures.length > 0 ? {
     exports: analysis.exports.map((e) => ({
       name: e.name,
       kind: e.kind,
@@ -2891,7 +3078,8 @@ async function generateWithAI(type, name, target, config) {
       params: e.params
     })),
     methods: analysis.vueAnalysis?.methods,
-    computed: analysis.vueAnalysis?.computed
+    computed: analysis.vueAnalysis?.computed,
+    importSignatures: analysis.importSignatures.length > 0 ? analysis.importSignatures : void 0
   } : void 0;
   const reviewResult = await generateWithReview({
     testType: type,
@@ -2899,7 +3087,8 @@ async function generateWithAI(type, name, target, config) {
     sourceCode,
     analysis: analysisSummary,
     aiConfig: config.ai,
-    framework: "vue"
+    framework: "vue",
+    onProgress
   });
   const headerComment = [
     `// AI Generated Test - ${name}`,
@@ -2933,46 +3122,46 @@ function getTestOutputDir(type) {
 }
 function displayCreateResult(createdFiles, skippedCount, usedAI) {
   if (createdFiles.length === 0 && skippedCount === 0) {
-    console.log(chalk4.yellow("\n  \u6CA1\u6709\u521B\u5EFA\u4EFB\u4F55\u6D4B\u8BD5\u6587\u4EF6\n"));
+    console.log(chalk5.yellow("\n  \u6CA1\u6709\u521B\u5EFA\u4EFB\u4F55\u6D4B\u8BD5\u6587\u4EF6\n"));
     return;
   }
-  console.log(chalk4.green(`
+  console.log(chalk5.green(`
   \u2713 \u5DF2\u521B\u5EFA ${createdFiles.length} \u4E2A\u6D4B\u8BD5\u6587\u4EF6`));
   if (skippedCount > 0) {
-    console.log(chalk4.yellow(`  \u26A0 \u8DF3\u8FC7 ${skippedCount} \u4E2A\u5DF2\u5B58\u5728\u7684\u6587\u4EF6`));
+    console.log(chalk5.yellow(`  \u26A0 \u8DF3\u8FC7 ${skippedCount} \u4E2A\u5DF2\u5B58\u5728\u7684\u6587\u4EF6`));
   }
   console.log();
   for (const { type, filePath } of createdFiles) {
-    const relativePath = path8.relative(process.cwd(), filePath);
-    console.log(chalk4.white(`    ${chalk4.cyan(TEST_TYPE_LABELS[type])}  ${chalk4.gray(relativePath)}`));
+    const relativePath = path9.relative(process.cwd(), filePath);
+    console.log(chalk5.white(`    ${chalk5.cyan(TEST_TYPE_LABELS[type])}  ${chalk5.gray(relativePath)}`));
   }
   if (usedAI) {
     console.log();
-    console.log(chalk4.magenta("  \u751F\u6210\u65B9\u5F0F: AI \u8F85\u52A9"));
+    console.log(chalk5.magenta("  \u751F\u6210\u65B9\u5F0F: AI \u8F85\u52A9"));
   }
   console.log();
-  console.log(chalk4.gray("  \u8FD0\u884C\u6D4B\u8BD5:"));
+  console.log(chalk5.gray("  \u8FD0\u884C\u6D4B\u8BD5:"));
   const uniqueTypes = [...new Set(createdFiles.map((f) => f.type))];
   if (uniqueTypes.length === 1) {
-    console.log(chalk4.cyan(`    qat run -t ${uniqueTypes[0]}`));
+    console.log(chalk5.cyan(`    qat run -t ${uniqueTypes[0]}`));
   } else {
-    console.log(chalk4.cyan(`    qat run -t ${uniqueTypes.join(" -t ")}`));
-    console.log(chalk4.gray("    # \u6216\u8FD0\u884C\u5168\u90E8"));
-    console.log(chalk4.cyan("    qat run"));
+    console.log(chalk5.cyan(`    qat run -t ${uniqueTypes.join(" -t ")}`));
+    console.log(chalk5.gray("    # \u6216\u8FD0\u884C\u5168\u90E8"));
+    console.log(chalk5.cyan("    qat run"));
   }
   console.log();
 }
 
 // src/commands/run.ts
-import chalk5 from "chalk";
+import chalk6 from "chalk";
 import inquirer3 from "inquirer";
 import ora4 from "ora";
 import fs11 from "fs";
-import path12 from "path";
+import path13 from "path";
 
 // src/runners/vitest-runner.ts
 import { execFile } from "child_process";
-import path9 from "path";
+import path10 from "path";
 import fs9 from "fs";
 import os2 from "os";
 var isVerbose = () => process.env.QAT_VERBOSE === "true";
@@ -3054,7 +3243,7 @@ function buildVitestArgs(options) {
   return args;
 }
 async function execVitest(args) {
-  const tmpFile = path9.join(os2.tmpdir(), `qat-vitest-result-${Date.now()}.json`);
+  const tmpFile = path10.join(os2.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";
@@ -3133,7 +3322,7 @@ function parseVitestJSON(jsonStr) {
     for (const fileResult of data.testResults) {
       const suiteTests = parseTestResults(fileResult);
       suites.push({
-        name: path9.basename(fileResult.name || "unknown"),
+        name: path10.basename(fileResult.name || "unknown"),
         file: fileResult.name || "unknown",
         type: "unit",
         status: mapVitestStatus(fileResult.status),
@@ -3244,7 +3433,7 @@ function parseFromStdout(output) {
     if (data.testResults && Array.isArray(data.testResults)) {
       for (const fileResult of data.testResults) {
         suites.push({
-          name: path9.basename(fileResult.name || "unknown"),
+          name: path10.basename(fileResult.name || "unknown"),
           file: fileResult.name || "unknown",
           type: "unit",
           status: mapVitestStatus(fileResult.status),
@@ -3280,7 +3469,7 @@ function parseVitestTextOutput(output, hasError) {
       if (isPassed) totalPassed += testCount;
       else totalFailed += testCount;
       suites.push({
-        name: path9.basename(file),
+        name: path10.basename(file),
         file,
         type: "unit",
         status: isPassed ? "passed" : "failed",
@@ -3381,7 +3570,7 @@ function extractCoverage(coverageMap) {
 
 // src/runners/playwright-runner.ts
 import { execFile as execFile2 } from "child_process";
-import path10 from "path";
+import path11 from "path";
 async function runPlaywright(options) {
   const startTime = Date.now();
   const args = buildPlaywrightArgs(options);
@@ -3581,7 +3770,7 @@ function parsePlaywrightTextOutput(output, hasError) {
       let existingSuite = suites.find((s) => s.file === file);
       if (!existingSuite) {
         existingSuite = {
-          name: path10.basename(file),
+          name: path11.basename(file),
           file,
           type: "e2e",
           status: "passed",
@@ -3816,7 +4005,7 @@ function calculateAverageMetrics(results) {
 
 // src/services/reporter.ts
 import fs10 from "fs";
-import path11 from "path";
+import path12 from "path";
 function aggregateResults(results) {
   const summary = {
     total: 0,
@@ -4012,13 +4201,13 @@ function generateMDReport(data) {
 }
 function writeReportToDisk(data, outputDir) {
   const md = generateMDReport(data);
-  const dir = path11.resolve(outputDir);
+  const dir = path12.resolve(outputDir);
   if (!fs10.existsSync(dir)) {
     fs10.mkdirSync(dir, { recursive: true });
   }
-  const mdPath = path11.join(dir, "report.md");
+  const mdPath = path12.join(dir, "report.md");
   fs10.writeFileSync(mdPath, md, "utf-8");
-  const jsonPath = path11.join(dir, "report.json");
+  const jsonPath = path12.join(dir, "report.json");
   fs10.writeFileSync(jsonPath, JSON.stringify(data, null, 2), "utf-8");
   return mdPath;
 }
@@ -4055,7 +4244,7 @@ function registerRunCommand(program2) {
     try {
       await executeRun(options);
     } catch (error) {
-      console.error(chalk5.red(`
+      console.error(chalk6.red(`
   \u2717 ${error instanceof Error ? error.message : String(error)}
 `));
       process.exit(1);
@@ -4075,15 +4264,15 @@ async function executeRun(options) {
   }
   let typesToRun = await determineTypesToRun(type, file, config);
   if (typesToRun.length === 0) {
-    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"));
+    console.log(chalk6.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 missingDeps = checkTestDependencies(typesToRun);
   if (missingDeps.length > 0) {
-    console.log(chalk5.yellow("\n  \u26A0 \u4EE5\u4E0B\u6D4B\u8BD5\u6846\u67B6\u4F9D\u8D56\u672A\u5B89\u88C5:\n"));
+    console.log(chalk6.yellow("\n  \u26A0 \u4EE5\u4E0B\u6D4B\u8BD5\u6846\u67B6\u4F9D\u8D56\u672A\u5B89\u88C5:\n"));
     for (const dep of missingDeps) {
-      console.log(chalk5.white(`    ${dep.runner} (${dep.pkg})`));
-      console.log(chalk5.gray(`      \u5B89\u88C5\u547D\u4EE4: ${chalk5.cyan(dep.installCmd)}`));
+      console.log(chalk6.white(`    ${dep.runner} (${dep.pkg})`));
+      console.log(chalk6.gray(`      \u5B89\u88C5\u547D\u4EE4: ${chalk6.cyan(dep.installCmd)}`));
     }
     console.log();
     const { action } = await inquirer3.prompt([
@@ -4100,13 +4289,13 @@ async function executeRun(options) {
       }
     ]);
     if (action === "cancel") {
-      console.log(chalk5.gray("\n  \u5DF2\u53D6\u6D88\u8FD0\u884C\n"));
+      console.log(chalk6.gray("\n  \u5DF2\u53D6\u6D88\u8FD0\u884C\n"));
       return;
     }
     if (action === "install") {
       const installed = await installTestDependencies(missingDeps);
       if (!installed) {
-        console.log(chalk5.yellow("  \u90E8\u5206\u4F9D\u8D56\u5B89\u88C5\u5931\u8D25\uFF0C\u5C06\u8DF3\u8FC7\u5BF9\u5E94\u7684\u6D4B\u8BD5\u7C7B\u578B"));
+        console.log(chalk6.yellow("  \u90E8\u5206\u4F9D\u8D56\u5B89\u88C5\u5931\u8D25\uFF0C\u5C06\u8DF3\u8FC7\u5BF9\u5E94\u7684\u6D4B\u8BD5\u7C7B\u578B"));
       }
       const stillMissing = checkTestDependencies(typesToRun);
       if (stillMissing.length > 0) {
@@ -4116,7 +4305,7 @@ async function executeRun(options) {
           return !dep || !missingRunners.has(dep.pkg);
         });
         if (typesToRun.length === 0) {
-          console.log(chalk5.yellow("\n  \u6CA1\u6709\u53EF\u8FD0\u884C\u7684\u6D4B\u8BD5\u7C7B\u578B\uFF08\u4F9D\u8D56\u672A\u5B89\u88C5\uFF09\n"));
+          console.log(chalk6.yellow("\n  \u6CA1\u6709\u53EF\u8FD0\u884C\u7684\u6D4B\u8BD5\u7C7B\u578B\uFF08\u4F9D\u8D56\u672A\u5B89\u88C5\uFF09\n"));
           return;
         }
       }
@@ -4128,7 +4317,7 @@ async function executeRun(options) {
         return !dep || !missingRunners.has(dep.pkg);
       });
       if (typesToRun.length === 0) {
-        console.log(chalk5.yellow("\n  \u6CA1\u6709\u53EF\u8FD0\u884C\u7684\u6D4B\u8BD5\u7C7B\u578B\n"));
+        console.log(chalk6.yellow("\n  \u6CA1\u6709\u53EF\u8FD0\u884C\u7684\u6D4B\u8BD5\u7C7B\u578B\n"));
         return;
       }
     }
@@ -4151,13 +4340,13 @@ async function executeRun(options) {
         }
       ]);
       if (action === "cancel") {
-        console.log(chalk5.gray("\n  \u5DF2\u53D6\u6D88\u8FD0\u884C\n"));
+        console.log(chalk6.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"));
+          console.log(chalk6.yellow("\n  \u6CA1\u6709\u53EF\u8FD0\u884C\u7684\u6D4B\u8BD5\u7C7B\u578B\n"));
           return;
         }
       }
@@ -4177,12 +4366,12 @@ async function executeRun(options) {
             }
           ]);
           if (fallback === "cancel") {
-            console.log(chalk5.gray("\n  \u5DF2\u53D6\u6D88\u8FD0\u884C\n"));
+            console.log(chalk6.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"));
+            console.log(chalk6.yellow("\n  \u6CA1\u6709\u53EF\u8FD0\u884C\u7684\u6D4B\u8BD5\u7C7B\u578B\n"));
             return;
           }
         }
@@ -4239,9 +4428,9 @@ async function executeRun(options) {
   const reportData = aggregateResults(results);
   const outputDir = config.report.outputDir || "qat-report";
   const reportPath = writeReportToDisk(reportData, outputDir);
-  const relativePath = path12.relative(process.cwd(), reportPath);
-  console.log(chalk5.gray(`
-  \u62A5\u544A\u5DF2\u751F\u6210: ${chalk5.cyan(relativePath)}`));
+  const relativePath = path13.relative(process.cwd(), reportPath);
+  console.log(chalk6.gray(`
+  \u62A5\u544A\u5DF2\u751F\u6210: ${chalk6.cyan(relativePath)}`));
   console.log();
   const hasFailures = results.some((r) => r.status === "failed");
   if (hasFailures && isAIAvailable(config.ai)) {
@@ -4250,7 +4439,7 @@ async function executeRun(options) {
 }
 function printDryRunCommands(types, options, config) {
   console.log();
-  console.log(chalk5.cyan("  \u53EF\u6267\u884C\u7684\u6D4B\u8BD5\u547D\u4EE4:\n"));
+  console.log(chalk6.cyan("  \u53EF\u6267\u884C\u7684\u6D4B\u8BD5\u547D\u4EE4:\n"));
   for (const testType of types) {
     const label = TYPE_LABELS2[testType];
     const runner = TYPE_RUNNERS[testType];
@@ -4287,17 +4476,17 @@ function printDryRunCommands(types, options, config) {
       default:
         cmd = `# ${label}: \u672A\u77E5\u8FD0\u884C\u5668`;
     }
-    console.log(chalk5.white(`  ${label}:`));
-    console.log(chalk5.cyan(`    ${cmd}`));
+    console.log(chalk6.white(`  ${label}:`));
+    console.log(chalk6.cyan(`    ${cmd}`));
     console.log();
   }
-  console.log(chalk5.gray("  \u6216\u4F7F\u7528 QAT \u7EDF\u4E00\u8FD0\u884C:"));
+  console.log(chalk6.gray("  \u6216\u4F7F\u7528 QAT \u7EDF\u4E00\u8FD0\u884C:"));
   if (types.length === 1) {
-    console.log(chalk5.cyan(`    qat run -t ${types[0]}`));
+    console.log(chalk6.cyan(`    qat run -t ${types[0]}`));
   } else {
-    console.log(chalk5.cyan(`    qat run -t ${types.join(" -t ")}`));
-    console.log(chalk5.gray("    # \u5E76\u884C\u8FD0\u884C"));
-    console.log(chalk5.cyan("    qat run -p"));
+    console.log(chalk6.cyan(`    qat run -t ${types.join(" -t ")}`));
+    console.log(chalk6.gray("    # \u5E76\u884C\u8FD0\u884C"));
+    console.log(chalk6.cyan("    qat run -p"));
   }
   console.log();
 }
@@ -4320,7 +4509,7 @@ async function determineTypesToRun(type, file, config) {
       name: "selectedTypes",
       message: "\u9009\u62E9\u8981\u8FD0\u884C\u7684\u6D4B\u8BD5\u7C7B\u578B (\u7A7A\u683C\u9009\u62E9/\u53D6\u6D88\uFF0C\u56DE\u8F66\u786E\u8BA4):",
       choices: enabledTypes.map((t) => ({
-        name: `${TYPE_LABELS2[t]} (${chalk5.gray(TYPE_RUNNERS[t])})`,
+        name: `${TYPE_LABELS2[t]} (${chalk6.gray(TYPE_RUNNERS[t])})`,
         value: t,
         checked: true
       })),
@@ -4380,7 +4569,7 @@ async function runTestType(testType, config, options) {
   }
 }
 async function runWatchMode(_config, options) {
-  console.log(chalk5.cyan("  \u76D1\u542C\u6A21\u5F0F\u5DF2\u542F\u52A8 (Ctrl+C \u9000\u51FA)\n"));
+  console.log(chalk6.cyan("  \u76D1\u542C\u6A21\u5F0F\u5DF2\u542F\u52A8 (Ctrl+C \u9000\u51FA)\n"));
   const { spawn } = await import("child_process");
   const args = ["vitest", "--watch"];
   if (options.file) {
@@ -4404,7 +4593,7 @@ async function runWatchMode(_config, options) {
     shell: true
   });
   child.on("error", (err) => {
-    console.error(chalk5.red(`
+    console.error(chalk6.red(`
   Vitest \u542F\u52A8\u5931\u8D25: ${err.message}
 `));
   });
@@ -4459,17 +4648,17 @@ function displayJestStyleResults(results) {
   for (const result of results) {
     const typeLabel = TYPE_LABELS2[result.type] || result.type;
     if (result.suites.length === 0) {
-      console.log(chalk5.gray(`  ${typeLabel}: \u65E0\u6D4B\u8BD5\u7ED3\u679C`));
+      console.log(chalk6.gray(`  ${typeLabel}: \u65E0\u6D4B\u8BD5\u7ED3\u679C`));
       continue;
     }
     for (const suite of result.suites) {
       if (suite.tests.length === 0) continue;
-      const suiteIcon = suite.status === "passed" ? chalk5.green("PASS") : chalk5.red("FAIL");
-      console.log(`  ${suiteIcon} ${chalk5.white(suite.name)} ${chalk5.gray(`(${formatDuration2(suite.duration)})`)}`);
+      const suiteIcon = suite.status === "passed" ? chalk6.green("PASS") : chalk6.red("FAIL");
+      console.log(`  ${suiteIcon} ${chalk6.white(suite.name)} ${chalk6.gray(`(${formatDuration2(suite.duration)})`)}`);
       for (const test of suite.tests) {
-        const icon = test.status === "passed" ? chalk5.green("  \u2713") : test.status === "failed" ? chalk5.red("  \u2715") : chalk5.yellow("  \u25CB");
-        const name = test.status === "failed" ? chalk5.red(test.name) : test.name;
-        console.log(`    ${icon} ${name} ${chalk5.gray(formatDuration2(test.duration))}`);
+        const icon = test.status === "passed" ? chalk6.green("  \u2713") : test.status === "failed" ? chalk6.red("  \u2715") : chalk6.yellow("  \u25CB");
+        const name = test.status === "failed" ? chalk6.red(test.name) : test.name;
+        console.log(`    ${icon} ${name} ${chalk6.gray(formatDuration2(test.duration))}`);
       }
     }
     console.log();
@@ -4501,28 +4690,28 @@ function displayJestStyleResults(results) {
     }
   }
   const total = totalPassed + totalFailed + totalSkipped;
-  console.log(chalk5.cyan("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
-  console.log(chalk5.white("  \u6D4B\u8BD5\u7ED3\u679C\u6C47\u603B"));
-  console.log(chalk5.cyan("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+  console.log(chalk6.cyan("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+  console.log(chalk6.white("  \u6D4B\u8BD5\u7ED3\u679C\u6C47\u603B"));
+  console.log(chalk6.cyan("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
   console.log();
-  console.log(`  ${chalk5.white("\u7C7B\u578B".padEnd(14))} ${chalk5.white("\u901A\u8FC7".padStart(6))} ${chalk5.white("\u5931\u8D25".padStart(6))} ${chalk5.white("\u8DF3\u8FC7".padStart(6))} ${chalk5.white("\u603B\u8BA1".padStart(6))} ${chalk5.white("\u901A\u8FC7\u7387".padStart(8))} ${chalk5.white("\u8017\u65F6".padStart(8))}`);
+  console.log(`  ${chalk6.white("\u7C7B\u578B".padEnd(14))} ${chalk6.white("\u901A\u8FC7".padStart(6))} ${chalk6.white("\u5931\u8D25".padStart(6))} ${chalk6.white("\u8DF3\u8FC7".padStart(6))} ${chalk6.white("\u603B\u8BA1".padStart(6))} ${chalk6.white("\u901A\u8FC7\u7387".padStart(8))} ${chalk6.white("\u8017\u65F6".padStart(8))}`);
   console.log(`  ${"\u2500".repeat(14)} ${"\u2500".repeat(6)} ${"\u2500".repeat(6)} ${"\u2500".repeat(6)} ${"\u2500".repeat(6)} ${"\u2500".repeat(8)} ${"\u2500".repeat(8)}`);
   for (const [type, stats] of Object.entries(typeStats)) {
     const label = (TYPE_LABELS2[type] || type).padEnd(14);
     const typeTotal = stats.passed + stats.failed + stats.skipped;
     const rate = typeTotal > 0 ? (stats.passed / typeTotal * 100).toFixed(0) + "%" : "-";
-    const rateColored = typeTotal > 0 && stats.passed === typeTotal ? chalk5.green(rate.padStart(8)) : stats.failed > 0 ? chalk5.red(rate.padStart(8)) : rate.padStart(8);
+    const rateColored = typeTotal > 0 && stats.passed === typeTotal ? chalk6.green(rate.padStart(8)) : stats.failed > 0 ? chalk6.red(rate.padStart(8)) : rate.padStart(8);
     console.log(`  ${label} ${String(stats.passed).padStart(6)} ${String(stats.failed).padStart(6)} ${String(stats.skipped).padStart(6)} ${String(typeTotal).padStart(6)} ${rateColored} ${formatDuration2(stats.duration).padStart(8)}`);
   }
   console.log(`  ${"\u2500".repeat(14)} ${"\u2500".repeat(6)} ${"\u2500".repeat(6)} ${"\u2500".repeat(6)} ${"\u2500".repeat(6)} ${"\u2500".repeat(8)} ${"\u2500".repeat(8)}`);
   const totalRate = total > 0 ? (totalPassed / total * 100).toFixed(0) + "%" : "-";
-  const totalRateColored = total > 0 && totalFailed === 0 ? chalk5.green(totalRate.padStart(8)) : totalFailed > 0 ? chalk5.red(totalRate.padStart(8)) : totalRate.padStart(8);
+  const totalRateColored = total > 0 && totalFailed === 0 ? chalk6.green(totalRate.padStart(8)) : totalFailed > 0 ? chalk6.red(totalRate.padStart(8)) : totalRate.padStart(8);
   console.log(`  ${"\u603B\u8BA1".padEnd(14)} ${String(totalPassed).padStart(6)} ${String(totalFailed).padStart(6)} ${String(totalSkipped).padStart(6)} ${String(total).padStart(6)} ${totalRateColored} ${formatDuration2(totalDuration).padStart(8)}`);
   console.log();
   for (const result of results) {
     if (result.coverage) {
       const c = result.coverage;
-      console.log(chalk5.cyan("  \u8986\u76D6\u7387:"));
+      console.log(chalk6.cyan("  \u8986\u76D6\u7387:"));
       console.log(`  \u8BED\u53E5: ${coverageColor(c.statements)}  \u5206\u652F: ${coverageColor(c.branches)}  \u51FD\u6570: ${coverageColor(c.functions)}  \u884C: ${coverageColor(c.lines)}`);
       console.log();
     }
@@ -4530,7 +4719,7 @@ function displayJestStyleResults(results) {
   for (const result of results) {
     if (result.type === "performance" && result.performance) {
       const p = result.performance;
-      console.log(chalk5.cyan("  \u6027\u80FD\u6307\u6807:"));
+      console.log(chalk6.cyan("  \u6027\u80FD\u6307\u6807:"));
       console.log(`  Performance:  ${scoreColor(p.performance)} ${p.performance}/100`);
       console.log(`  Accessibility: ${scoreColor(p.accessibility)} ${p.accessibility}/100`);
       console.log(`  Best Practices: ${scoreColor(p.bestPractices)} ${p.bestPractices}/100`);
@@ -4547,31 +4736,31 @@ function displayJestStyleResults(results) {
     )
   );
   if (failedTests.length > 0) {
-    console.log(chalk5.red("  \u5931\u8D25\u8BE6\u60C5:"));
+    console.log(chalk6.red("  \u5931\u8D25\u8BE6\u60C5:"));
     for (const { suite, test } of failedTests) {
-      console.log(chalk5.red(`    \u2715 ${suite.name} > ${test.name}`));
+      console.log(chalk6.red(`    \u2715 ${suite.name} > ${test.name}`));
       if (test.error?.message) {
-        console.log(chalk5.gray(`      ${test.error.message.split("\n")[0]}`));
+        console.log(chalk6.gray(`      ${test.error.message.split("\n")[0]}`));
       }
     }
     console.log();
   }
   if (totalFailed > 0) {
-    console.log(chalk5.red(`  Tests: ${totalFailed} failed, ${totalPassed} passed, ${total} total`));
+    console.log(chalk6.red(`  Tests: ${totalFailed} failed, ${totalPassed} passed, ${total} total`));
     process.exitCode = 1;
   } else if (total === 0) {
-    console.log(chalk5.yellow("  \u6CA1\u6709\u53D1\u73B0\u6D4B\u8BD5\u7528\u4F8B"));
+    console.log(chalk6.yellow("  \u6CA1\u6709\u53D1\u73B0\u6D4B\u8BD5\u7528\u4F8B"));
   } else {
-    console.log(chalk5.green(`  Tests: ${totalPassed} passed, ${total} total`));
+    console.log(chalk6.green(`  Tests: ${totalPassed} passed, ${total} total`));
   }
-  console.log(chalk5.gray(`  Time:  ${formatDuration2(totalDuration)}`));
+  console.log(chalk6.gray(`  Time:  ${formatDuration2(totalDuration)}`));
   console.log();
 }
 function coverageColor(value) {
   const pct3 = `${(value * 100).toFixed(1)}%`;
-  if (value >= 0.8) return chalk5.green(pct3);
-  if (value >= 0.5) return chalk5.yellow(pct3);
-  return chalk5.red(pct3);
+  if (value >= 0.8) return chalk6.green(pct3);
+  if (value >= 0.5) return chalk6.yellow(pct3);
+  return chalk6.red(pct3);
 }
 async function aiAnalyzeFailures(results, aiConfig) {
   const failedTests = results.flatMap(
@@ -4580,23 +4769,23 @@ async function aiAnalyzeFailures(results, aiConfig) {
     )
   );
   if (failedTests.length === 0) return;
-  console.log(chalk5.magenta("  \u{1F916} AI \u5206\u6790\u5931\u8D25\u539F\u56E0..."));
+  console.log(chalk6.magenta("  \u{1F916} AI \u5206\u6790\u5931\u8D25\u539F\u56E0..."));
   console.log();
   const provider = getAIProvider(aiConfig);
   if (!provider.capabilities.suggestFix) return;
   for (const { suite, test } of failedTests.slice(0, 5)) {
     try {
       const suggestions = await provider.suggestFix(test.error);
-      console.log(chalk5.white(`    ${suite.name} > ${test.name}`));
+      console.log(chalk6.white(`    ${suite.name} > ${test.name}`));
       if (test.error?.message) {
-        console.log(chalk5.gray(`      \u9519\u8BEF: ${test.error.message.split("\n")[0]}`));
+        console.log(chalk6.gray(`      \u9519\u8BEF: ${test.error.message.split("\n")[0]}`));
       }
       for (const suggestion of suggestions.slice(0, 3)) {
-        console.log(chalk5.cyan(`      \u2192 ${suggestion}`));
+        console.log(chalk6.cyan(`      \u2192 ${suggestion}`));
       }
       console.log();
     } catch (error) {
-      console.log(chalk5.gray(`      AI \u5206\u6790\u5931\u8D25: ${error instanceof Error ? error.message : String(error)}`));
+      console.log(chalk6.gray(`      AI \u5206\u6790\u5931\u8D25: ${error instanceof Error ? error.message : String(error)}`));
     }
   }
 }
@@ -4608,9 +4797,9 @@ function formatDuration2(ms) {
   return `${min}m ${sec}s`;
 }
 function scoreColor(score) {
-  if (score >= 90) return chalk5.green("\u25CF");
-  if (score >= 50) return chalk5.yellow("\u25CF");
-  return chalk5.red("\u25CF");
+  if (score >= 90) return chalk6.green("\u25CF");
+  if (score >= 50) return chalk6.yellow("\u25CF");
+  return chalk6.red("\u25CF");
 }
 async function checkDevServer(config) {
   const baseUrl = config.playwright.baseURL || "http://localhost:5173";
@@ -4626,10 +4815,10 @@ async function checkDevServer(config) {
 }
 async function startDevServer(config) {
   const { spawn } = await import("child_process");
-  const hasPnpm = fs11.existsSync(path12.join(process.cwd(), "pnpm-lock.yaml"));
-  const hasYarn = fs11.existsSync(path12.join(process.cwd(), "yarn.lock"));
+  const hasPnpm = fs11.existsSync(path13.join(process.cwd(), "pnpm-lock.yaml"));
+  const hasYarn = fs11.existsSync(path13.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) ...`));
+  console.log(chalk6.cyan(`  \u6B63\u5728\u542F\u52A8 dev server (${pkgCmd} run dev) ...`));
   const child = spawn(pkgCmd, ["run", "dev"], {
     cwd: process.cwd(),
     stdio: "pipe",
@@ -4645,24 +4834,24 @@ async function startDevServer(config) {
     waited += interval;
     const isUp = await checkDevServer(config);
     if (isUp) {
-      console.log(chalk5.green(`  \u2713 dev server \u5DF2\u542F\u52A8 (${baseUrl})`));
+      console.log(chalk6.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"));
+  console.log(chalk6.red("  \u2717 dev server \u542F\u52A8\u8D85\u65F6"));
   return false;
 }
 function saveRunResults(results) {
   if (results.length === 0) return;
-  const resultsPath = path12.join(process.cwd(), RESULTS_DIR);
+  const resultsPath = path13.join(process.cwd(), RESULTS_DIR);
   if (!fs11.existsSync(resultsPath)) {
     fs11.mkdirSync(resultsPath, { recursive: true });
   }
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
   const fileName = `result-${timestamp}.json`;
-  const filePath = path12.join(resultsPath, fileName);
+  const filePath = path13.join(resultsPath, fileName);
   const data = {
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
     results
@@ -4672,13 +4861,13 @@ function saveRunResults(results) {
     const files = fs11.readdirSync(resultsPath).filter((f) => f.startsWith("result-") && f.endsWith(".json")).sort();
     while (files.length > 20) {
       const oldest = files.shift();
-      fs11.unlinkSync(path12.join(resultsPath, oldest));
+      fs11.unlinkSync(path13.join(resultsPath, oldest));
     }
   } catch {
   }
 }
 function checkTestDependencies(types) {
-  const pkgPath = path12.join(process.cwd(), "package.json");
+  const pkgPath = path13.join(process.cwd(), "package.json");
   let allDeps = {};
   if (fs11.existsSync(pkgPath)) {
     try {
@@ -4704,8 +4893,8 @@ function checkTestDependencies(types) {
   return missingDeps;
 }
 async function installTestDependencies(missingDeps) {
-  const hasPnpm = fs11.existsSync(path12.join(process.cwd(), "pnpm-lock.yaml"));
-  const hasYarn = fs11.existsSync(path12.join(process.cwd(), "yarn.lock"));
+  const hasPnpm = fs11.existsSync(path13.join(process.cwd(), "pnpm-lock.yaml"));
+  const hasYarn = fs11.existsSync(path13.join(process.cwd(), "yarn.lock"));
   const pkgManager = hasPnpm ? "pnpm" : hasYarn ? "yarn" : "npm";
   const { execFile: execFile5 } = await import("child_process");
   let allSuccess = true;
@@ -4743,7 +4932,7 @@ async function installTestDependencies(missingDeps) {
       spinner.succeed(`${dep.pkg} \u5B89\u88C5\u6210\u529F`);
     } catch (error) {
       spinner.fail(`${dep.pkg} \u5B89\u88C5\u5931\u8D25`);
-      console.log(chalk5.gray(`  \u53EF\u624B\u52A8\u5B89\u88C5: ${chalk5.cyan(dep.installCmd)}`));
+      console.log(chalk6.gray(`  \u53EF\u624B\u52A8\u5B89\u88C5: ${chalk6.cyan(dep.installCmd)}`));
       allSuccess = false;
     }
   }
@@ -4751,7 +4940,7 @@ async function installTestDependencies(missingDeps) {
 }
 
 // src/commands/mock.ts
-import chalk6 from "chalk";
+import chalk7 from "chalk";
 import ora5 from "ora";
 function registerMockCommand(program2) {
   program2.command("mock").description("Mock\u670D\u52A1\u7BA1\u7406 - \u542F\u52A8/\u505C\u6B62Mock API\u670D\u52A1\u5668").argument("<action>", "\u64CD\u4F5C\u7C7B\u578B (start|stop|status)").option("-p, --port <port>", "\u6307\u5B9A\u7AEF\u53E3\u53F7", "3456").action(async (action, options) => {
@@ -4762,7 +4951,7 @@ function registerMockCommand(program2) {
         config: options.config
       });
     } catch (error) {
-      console.error(chalk6.red(`
+      console.error(chalk7.red(`
   \u2717 ${error instanceof Error ? error.message : String(error)}
 `));
       process.exit(1);
@@ -4786,9 +4975,9 @@ async function executeMock(options) {
       break;
     }
     default: {
-      console.error(chalk6.red(`
+      console.error(chalk7.red(`
   \u672A\u77E5\u64CD\u4F5C: ${options.action}`));
-      console.log(chalk6.gray("  \u53EF\u7528\u64CD\u4F5C: start, stop, status\n"));
+      console.log(chalk7.gray("  \u53EF\u7528\u64CD\u4F5C: start, stop, status\n"));
       process.exit(1);
     }
   }
@@ -4796,7 +4985,7 @@ async function executeMock(options) {
 async function startMock(port, routesDir) {
   const state = getMockServerState();
   if (state.running) {
-    console.log(chalk6.yellow(`
+    console.log(chalk7.yellow(`
   Mock\u670D\u52A1\u5668\u5DF2\u5728\u8FD0\u884C (\u7AEF\u53E3: ${state.port})
 `));
     return;
@@ -4810,22 +4999,22 @@ async function startMock(port, routesDir) {
     await startMockServer(port, routes);
     spinner.succeed(`Mock\u670D\u52A1\u5668\u5DF2\u542F\u52A8`);
     console.log();
-    console.log(chalk6.white("  \u5730\u5740:"), chalk6.cyan(`http://localhost:${port}`));
-    console.log(chalk6.white("  \u8DEF\u7531:"), routes.length > 0 ? `${routes.length} \u4E2A` : chalk6.gray("\u4F7F\u7528\u9ED8\u8BA4\u8DEF\u7531"));
-    console.log(chalk6.white("  \u5065\u5EB7\u68C0\u67E5:"), chalk6.cyan(`http://localhost:${port}/api/health`));
+    console.log(chalk7.white("  \u5730\u5740:"), chalk7.cyan(`http://localhost:${port}`));
+    console.log(chalk7.white("  \u8DEF\u7531:"), routes.length > 0 ? `${routes.length} \u4E2A` : chalk7.gray("\u4F7F\u7528\u9ED8\u8BA4\u8DEF\u7531"));
+    console.log(chalk7.white("  \u5065\u5EB7\u68C0\u67E5:"), chalk7.cyan(`http://localhost:${port}/api/health`));
     if (routes.length > 0) {
       console.log();
-      console.log(chalk6.white("  \u5DF2\u6CE8\u518C\u8DEF\u7531:"));
+      console.log(chalk7.white("  \u5DF2\u6CE8\u518C\u8DEF\u7531:"));
       for (const route of routes.slice(0, 10)) {
-        const method = chalk6.gray(route.method.padEnd(6));
+        const method = chalk7.gray(route.method.padEnd(6));
         console.log(`    ${method} ${route.path}`);
       }
       if (routes.length > 10) {
-        console.log(chalk6.gray(`    ... \u8FD8\u6709 ${routes.length - 10} \u4E2A\u8DEF\u7531`));
+        console.log(chalk7.gray(`    ... \u8FD8\u6709 ${routes.length - 10} \u4E2A\u8DEF\u7531`));
       }
     }
     console.log();
-    console.log(chalk6.gray("  \u6309 Ctrl+C \u505C\u6B62\u670D\u52A1\u5668"));
+    console.log(chalk7.gray("  \u6309 Ctrl+C \u505C\u6B62\u670D\u52A1\u5668"));
     process.on("SIGINT", async () => {
       const stopSpinner = ora5("\u6B63\u5728\u505C\u6B62Mock\u670D\u52A1\u5668...").start();
       await stopMockServer();
@@ -4842,7 +5031,7 @@ async function startMock(port, routesDir) {
 async function stopMock() {
   const state = getMockServerState();
   if (!state.running) {
-    console.log(chalk6.yellow("\n  Mock\u670D\u52A1\u5668\u672A\u5728\u8FD0\u884C\n"));
+    console.log(chalk7.yellow("\n  Mock\u670D\u52A1\u5668\u672A\u5728\u8FD0\u884C\n"));
     return;
   }
   const spinner = ora5("\u6B63\u5728\u505C\u6B62Mock\u670D\u52A1\u5668...").start();
@@ -4859,28 +5048,28 @@ function showStatus() {
   const state = getMockServerState();
   console.log();
   if (state.running) {
-    console.log(chalk6.green("  \u25CF Mock\u670D\u52A1\u5668\u8FD0\u884C\u4E2D"));
-    console.log(chalk6.white("  \u7AEF\u53E3:"), state.port);
-    console.log(chalk6.white("  \u8DEF\u7531:"), state.routes.length);
+    console.log(chalk7.green("  \u25CF Mock\u670D\u52A1\u5668\u8FD0\u884C\u4E2D"));
+    console.log(chalk7.white("  \u7AEF\u53E3:"), state.port);
+    console.log(chalk7.white("  \u8DEF\u7531:"), state.routes.length);
   } else {
-    console.log(chalk6.gray("  \u25CB Mock\u670D\u52A1\u5668\u672A\u8FD0\u884C"));
-    console.log(chalk6.gray("  \u4F7F\u7528 qat mock start \u542F\u52A8"));
+    console.log(chalk7.gray("  \u25CB Mock\u670D\u52A1\u5668\u672A\u8FD0\u884C"));
+    console.log(chalk7.gray("  \u4F7F\u7528 qat mock start \u542F\u52A8"));
   }
   console.log();
 }
 
 // src/commands/report.ts
-import chalk7 from "chalk";
+import chalk8 from "chalk";
 import ora6 from "ora";
 import fs12 from "fs";
-import path13 from "path";
+import path14 from "path";
 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 {
       await executeReport(options);
     } catch (error) {
-      console.error(chalk7.red(`
+      console.error(chalk8.red(`
   \u2717 ${error instanceof Error ? error.message : String(error)}
 `));
       process.exit(1);
@@ -4894,7 +5083,7 @@ async function executeReport(options) {
   const results = collectResults();
   if (results.length === 0) {
     spinner.info("\u6CA1\u6709\u627E\u5230\u6D4B\u8BD5\u7ED3\u679C");
-    console.log(chalk7.gray("\n  \u63D0\u793A: \u5148\u8FD0\u884C qat run \u751F\u6210\u6D4B\u8BD5\u7ED3\u679C\n"));
+    console.log(chalk8.gray("\n  \u63D0\u793A: \u5148\u8FD0\u884C qat run \u751F\u6210\u6D4B\u8BD5\u7ED3\u679C\n"));
     return;
   }
   spinner.text = "\u6B63\u5728\u751F\u6210\u6D4B\u8BD5\u62A5\u544A...";
@@ -4909,13 +5098,13 @@ async function executeReport(options) {
 }
 function collectResults() {
   const results = [];
-  const resultsPath = path13.join(process.cwd(), RESULTS_DIR2);
+  const resultsPath = path14.join(process.cwd(), RESULTS_DIR2);
   if (!fs12.existsSync(resultsPath)) {
     return results;
   }
   const files = fs12.readdirSync(resultsPath).filter((f) => f.endsWith(".json")).sort().reverse();
   if (files.length > 0) {
-    const latestFile = path13.join(resultsPath, files[0]);
+    const latestFile = path14.join(resultsPath, files[0]);
     try {
       const data = JSON.parse(fs12.readFileSync(latestFile, "utf-8"));
       if (Array.isArray(data)) {
@@ -4929,49 +5118,49 @@ function collectResults() {
   return results;
 }
 function saveResultToHistory(reportData) {
-  const resultsPath = path13.join(process.cwd(), RESULTS_DIR2);
+  const resultsPath = path14.join(process.cwd(), RESULTS_DIR2);
   if (!fs12.existsSync(resultsPath)) {
     fs12.mkdirSync(resultsPath, { recursive: true });
   }
   const timestamp = new Date(reportData.timestamp).toISOString().replace(/[:.]/g, "-");
   const fileName = `result-${timestamp}.json`;
-  const filePath = path13.join(resultsPath, fileName);
+  const filePath = path14.join(resultsPath, fileName);
   fs12.writeFileSync(filePath, JSON.stringify(reportData, null, 2), "utf-8");
   const files = fs12.readdirSync(resultsPath).filter((f) => f.startsWith("result-") && f.endsWith(".json")).sort();
   while (files.length > 20) {
     const oldest = files.shift();
-    fs12.unlinkSync(path13.join(resultsPath, oldest));
+    fs12.unlinkSync(path14.join(resultsPath, oldest));
   }
 }
 function displayReportResult(reportPath, data) {
-  const relativePath = path13.relative(process.cwd(), reportPath);
+  const relativePath = path14.relative(process.cwd(), reportPath);
   const passRate = data.summary.total > 0 ? (data.summary.passed / data.summary.total * 100).toFixed(1) : "0";
   console.log();
-  console.log(chalk7.green("  \u2713 \u6D4B\u8BD5\u62A5\u544A\u5DF2\u751F\u6210"));
+  console.log(chalk8.green("  \u2713 \u6D4B\u8BD5\u62A5\u544A\u5DF2\u751F\u6210"));
   console.log();
-  console.log(chalk7.white("  \u62A5\u544A\u8DEF\u5F84:"), chalk7.cyan(relativePath));
-  console.log(chalk7.white("  \u901A\u8FC7\u7387:  "), parseFloat(passRate) >= 80 ? chalk7.green(`${passRate}%`) : parseFloat(passRate) >= 50 ? chalk7.yellow(`${passRate}%`) : chalk7.red(`${passRate}%`));
-  console.log(chalk7.white("  \u6D4B\u8BD5\u7528\u4F8B:"), `${data.summary.total} total`);
-  console.log(chalk7.white("  \u2705 \u901A\u8FC7:  "), chalk7.green(String(data.summary.passed)));
+  console.log(chalk8.white("  \u62A5\u544A\u8DEF\u5F84:"), chalk8.cyan(relativePath));
+  console.log(chalk8.white("  \u901A\u8FC7\u7387:  "), parseFloat(passRate) >= 80 ? chalk8.green(`${passRate}%`) : parseFloat(passRate) >= 50 ? chalk8.yellow(`${passRate}%`) : chalk8.red(`${passRate}%`));
+  console.log(chalk8.white("  \u6D4B\u8BD5\u7528\u4F8B:"), `${data.summary.total} total`);
+  console.log(chalk8.white("  \u2705 \u901A\u8FC7:  "), chalk8.green(String(data.summary.passed)));
   if (data.summary.failed > 0) {
-    console.log(chalk7.white("  \u274C \u5931\u8D25:  "), chalk7.red(String(data.summary.failed)));
+    console.log(chalk8.white("  \u274C \u5931\u8D25:  "), chalk8.red(String(data.summary.failed)));
   }
   if (data.summary.skipped > 0) {
-    console.log(chalk7.white("  \u23ED\uFE0F \u8DF3\u8FC7:  "), chalk7.yellow(String(data.summary.skipped)));
+    console.log(chalk8.white("  \u23ED\uFE0F \u8DF3\u8FC7:  "), chalk8.yellow(String(data.summary.skipped)));
   }
   if (Object.keys(data.byType).length > 0) {
     console.log();
-    console.log(chalk7.white("  \u6309\u7C7B\u578B:"));
+    console.log(chalk8.white("  \u6309\u7C7B\u578B:"));
     for (const [type, stats] of Object.entries(data.byType)) {
       const rate = stats.total > 0 ? (stats.passed / stats.total * 100).toFixed(0) : "0";
-      const icon = stats.failed > 0 ? chalk7.red("\u274C") : chalk7.green("\u2705");
+      const icon = stats.failed > 0 ? chalk8.red("\u274C") : chalk8.green("\u2705");
       console.log(`    ${icon} ${type}: ${stats.passed}/${stats.total} (${rate}%)`);
     }
   }
   if (data.coverage) {
     console.log();
-    console.log(chalk7.white("  \u8986\u76D6\u7387:"));
-    console.log(`    \u8BED\u53E5: ${chalk7.cyan(pct2(data.coverage.statements))}  \u5206\u652F: ${chalk7.cyan(pct2(data.coverage.branches))}  \u51FD\u6570: ${chalk7.cyan(pct2(data.coverage.functions))}  \u884C: ${chalk7.cyan(pct2(data.coverage.lines))}`);
+    console.log(chalk8.white("  \u8986\u76D6\u7387:"));
+    console.log(`    \u8BED\u53E5: ${chalk8.cyan(pct2(data.coverage.statements))}  \u5206\u652F: ${chalk8.cyan(pct2(data.coverage.branches))}  \u51FD\u6570: ${chalk8.cyan(pct2(data.coverage.functions))}  \u884C: ${chalk8.cyan(pct2(data.coverage.lines))}`);
   }
   console.log();
 }
@@ -4991,18 +5180,18 @@ async function openReport(reportPath) {
   }
   exec(command, { shell: true }, (error) => {
     if (error) {
-      console.log(chalk7.gray("  \u63D0\u793A: \u624B\u52A8\u6253\u5F00\u62A5\u544A\u67E5\u770B"));
+      console.log(chalk8.gray("  \u63D0\u793A: \u624B\u52A8\u6253\u5F00\u62A5\u544A\u67E5\u770B"));
     }
   });
 }
 
 // src/commands/visual.ts
-import chalk8 from "chalk";
+import chalk9 from "chalk";
 import ora7 from "ora";
 
 // src/services/visual.ts
 import fs13 from "fs";
-import path14 from "path";
+import path15 from "path";
 import pixelmatch from "pixelmatch";
 import { PNG } from "pngjs";
 function compareImages(baselinePath, currentPath, diffOutputPath, threshold = 0.1) {
@@ -5041,7 +5230,7 @@ function compareImages(baselinePath, currentPath, diffOutputPath, threshold = 0.
   const passed = diffRatio <= threshold;
   let diffPath;
   if (diffPixels > 0) {
-    const diffDir = path14.dirname(diffOutputPath);
+    const diffDir = path15.dirname(diffOutputPath);
     if (!fs13.existsSync(diffDir)) {
       fs13.mkdirSync(diffDir, { recursive: true });
     }
@@ -5062,7 +5251,7 @@ function createBaseline(currentPath, baselinePath) {
   if (!fs13.existsSync(currentPath)) {
     throw new Error(`\u5F53\u524D\u622A\u56FE\u4E0D\u5B58\u5728: ${currentPath}`);
   }
-  const baselineDir = path14.dirname(baselinePath);
+  const baselineDir = path15.dirname(baselinePath);
   if (!fs13.existsSync(baselineDir)) {
     fs13.mkdirSync(baselineDir, { recursive: true });
   }
@@ -5076,9 +5265,9 @@ function updateAllBaselines(currentDir, baselineDir) {
   }
   const files = fs13.readdirSync(currentDir).filter((f) => f.endsWith(".png"));
   for (const file of files) {
-    const currentPath = path14.join(currentDir, file);
-    const baselinePath = path14.join(baselineDir, file);
-    const baselineDirAbs = path14.dirname(baselinePath);
+    const currentPath = path15.join(currentDir, file);
+    const baselinePath = path15.join(baselineDir, file);
+    const baselineDirAbs = path15.dirname(baselinePath);
     if (!fs13.existsSync(baselineDirAbs)) {
       fs13.mkdirSync(baselineDirAbs, { recursive: true });
     }
@@ -5094,7 +5283,7 @@ function cleanBaselines(baselineDir) {
   const files = fs13.readdirSync(baselineDir).filter((f) => f.endsWith(".png"));
   let count = 0;
   for (const file of files) {
-    fs13.unlinkSync(path14.join(baselineDir, file));
+    fs13.unlinkSync(path15.join(baselineDir, file));
     count++;
   }
   return count;
@@ -5106,7 +5295,7 @@ function cleanDiffs(diffDir) {
   const files = fs13.readdirSync(diffDir).filter((f) => f.endsWith(".png"));
   let count = 0;
   for (const file of files) {
-    fs13.unlinkSync(path14.join(diffDir, file));
+    fs13.unlinkSync(path15.join(diffDir, file));
     count++;
   }
   return count;
@@ -5118,9 +5307,9 @@ function compareDirectories(baselineDir, currentDir, diffDir, threshold = 0.1) {
   }
   const currentFiles = fs13.readdirSync(currentDir).filter((f) => f.endsWith(".png"));
   for (const file of currentFiles) {
-    const currentPath = path14.join(currentDir, file);
-    const baselinePath = path14.join(baselineDir, file);
-    const diffPath = path14.join(diffDir, file);
+    const currentPath = path15.join(currentDir, file);
+    const baselinePath = path15.join(baselineDir, file);
+    const diffPath = path15.join(diffDir, file);
     if (!fs13.existsSync(baselinePath)) {
       createBaseline(currentPath, baselinePath);
       results.push({
@@ -5154,7 +5343,7 @@ function compareDirectories(baselineDir, currentDir, diffDir, threshold = 0.1) {
 
 // src/commands/visual.ts
 import fs14 from "fs";
-import path15 from "path";
+import path16 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 {
@@ -5164,7 +5353,7 @@ function registerVisualCommand(program2) {
         config: options.config
       });
     } catch (error) {
-      console.error(chalk8.red(`
+      console.error(chalk9.red(`
   \u2717 ${error instanceof Error ? error.message : String(error)}
 `));
       process.exit(1);
@@ -5190,9 +5379,9 @@ async function executeVisual(options) {
       break;
     }
     default: {
-      console.error(chalk8.red(`
+      console.error(chalk9.red(`
   \u672A\u77E5\u64CD\u4F5C: ${options.action}`));
-      console.log(chalk8.gray("  \u53EF\u7528\u64CD\u4F5C: test, approve, clean\n"));
+      console.log(chalk9.gray("  \u53EF\u7528\u64CD\u4F5C: test, approve, clean\n"));
       process.exit(1);
     }
   }
@@ -5216,7 +5405,7 @@ async function runVisualTest(threshold, baselineDir, diffDir, config) {
   const currentDir = findCurrentScreenshotsDir(baselineDir);
   if (!currentDir) {
     compareSpinner.info("\u6CA1\u6709\u627E\u5230\u622A\u56FE\u6587\u4EF6");
-    console.log(chalk8.gray("\n  \u63D0\u793A: \u5148\u8FD0\u884C qat run -t visual \u751F\u6210\u622A\u56FE\n"));
+    console.log(chalk9.gray("\n  \u63D0\u793A: \u5148\u8FD0\u884C qat run -t visual \u751F\u6210\u622A\u56FE\n"));
     return;
   }
   const results = compareDirectories(baselineDir, currentDir, diffDir, threshold);
@@ -5229,9 +5418,9 @@ async function runVisualTest(threshold, baselineDir, diffDir, config) {
 }
 function findCurrentScreenshotsDir(baselineDir) {
   const possibleDirs = [
-    path15.join(process.cwd(), "test-results"),
-    path15.join(process.cwd(), "tests", "visual", "current"),
-    path15.join(process.cwd(), baselineDir, "..", "current")
+    path16.join(process.cwd(), "test-results"),
+    path16.join(process.cwd(), "tests", "visual", "current"),
+    path16.join(process.cwd(), baselineDir, "..", "current")
   ];
   for (const dir of possibleDirs) {
     if (fs14.existsSync(dir)) {
@@ -5247,7 +5436,7 @@ function findPngFiles(dir) {
     if (!fs14.existsSync(d)) return;
     const entries = fs14.readdirSync(d, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path15.join(d, entry.name);
+      const fullPath = path16.join(d, entry.name);
       if (entry.isDirectory() && entry.name !== "node_modules") {
         walk(fullPath);
       } else if (entry.name.endsWith(".png")) {
@@ -5262,48 +5451,48 @@ function displayVisualResults(results, threshold) {
   const passed = results.filter((r) => r.passed);
   const failed = results.filter((r) => !r.passed);
   console.log();
-  console.log(chalk8.cyan("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+  console.log(chalk9.cyan("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
   if (failed.length === 0) {
-    console.log(chalk8.green(`  \u2713 \u5168\u90E8\u901A\u8FC7 (${results.length} \u4E2A\u622A\u56FE\u6BD4\u5BF9)`));
+    console.log(chalk9.green(`  \u2713 \u5168\u90E8\u901A\u8FC7 (${results.length} \u4E2A\u622A\u56FE\u6BD4\u5BF9)`));
   } else {
-    console.log(chalk8.red(`  \u2717 ${failed.length} \u4E2A\u622A\u56FE\u5B58\u5728\u5DEE\u5F02`));
+    console.log(chalk9.red(`  \u2717 ${failed.length} \u4E2A\u622A\u56FE\u5B58\u5728\u5DEE\u5F02`));
   }
   console.log();
-  console.log(`  ${chalk8.white("\u9608\u503C:")} ${(threshold * 100).toFixed(0)}%`);
-  console.log(`  ${chalk8.green("\u901A\u8FC7:")} ${passed.length}`);
-  console.log(`  ${chalk8.red("\u5931\u8D25:")} ${failed.length}`);
+  console.log(`  ${chalk9.white("\u9608\u503C:")} ${(threshold * 100).toFixed(0)}%`);
+  console.log(`  ${chalk9.green("\u901A\u8FC7:")} ${passed.length}`);
+  console.log(`  ${chalk9.red("\u5931\u8D25:")} ${failed.length}`);
   if (passed.length > 0) {
     console.log();
-    console.log(chalk8.green("  \u901A\u8FC7\u7684\u622A\u56FE:"));
+    console.log(chalk9.green("  \u901A\u8FC7\u7684\u622A\u56FE:"));
     for (const result of passed) {
-      const name = path15.basename(result.baselinePath);
+      const name = path16.basename(result.baselinePath);
       if (result.totalPixels > 0) {
         const diffPct = (result.diffRatio * 100).toFixed(2);
-        console.log(chalk8.green(`    \u2713 ${name} (\u5DEE\u5F02: ${diffPct}%)`));
+        console.log(chalk9.green(`    \u2713 ${name} (\u5DEE\u5F02: ${diffPct}%)`));
       } else {
-        console.log(chalk8.green(`    \u2713 ${name} (\u65B0\u5EFA\u57FA\u7EBF)`));
+        console.log(chalk9.green(`    \u2713 ${name} (\u65B0\u5EFA\u57FA\u7EBF)`));
       }
     }
   }
   if (failed.length > 0) {
     console.log();
-    console.log(chalk8.red("  \u5931\u8D25\u7684\u622A\u56FE:"));
+    console.log(chalk9.red("  \u5931\u8D25\u7684\u622A\u56FE:"));
     for (const result of failed) {
-      const name = path15.basename(result.baselinePath);
+      const name = path16.basename(result.baselinePath);
       if (result.diffPixels === -1) {
-        console.log(chalk8.red(`    \u2717 ${name} (\u5C3A\u5BF8\u4E0D\u5339\u914D)`));
+        console.log(chalk9.red(`    \u2717 ${name} (\u5C3A\u5BF8\u4E0D\u5339\u914D)`));
       } else {
         const diffPct = (result.diffRatio * 100).toFixed(2);
-        console.log(chalk8.red(`    \u2717 ${name} (\u5DEE\u5F02: ${diffPct}%)`));
+        console.log(chalk9.red(`    \u2717 ${name} (\u5DEE\u5F02: ${diffPct}%)`));
       }
       if (result.diffPath) {
-        console.log(chalk8.gray(`      \u5DEE\u5F02\u56FE: ${path15.relative(process.cwd(), result.diffPath)}`));
+        console.log(chalk9.gray(`      \u5DEE\u5F02\u56FE: ${path16.relative(process.cwd(), result.diffPath)}`));
       }
     }
     console.log();
-    console.log(chalk8.yellow("  \u63D0\u793A: \u8FD0\u884C qat visual approve \u66F4\u65B0\u57FA\u7EBF"));
+    console.log(chalk9.yellow("  \u63D0\u793A: \u8FD0\u884C qat visual approve \u66F4\u65B0\u57FA\u7EBF"));
   }
-  console.log(chalk8.cyan("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+  console.log(chalk9.cyan("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
   console.log();
 }
 async function approveBaselines(baselineDir, diffDir) {
@@ -5322,7 +5511,7 @@ async function approveBaselines(baselineDir, diffDir) {
   spinner.succeed(`\u5DF2\u66F4\u65B0 ${updated.length} \u4E2A\u57FA\u7EBF\u5FEB\u7167`);
   console.log();
   for (const file of updated) {
-    console.log(chalk8.green(`  \u2713 ${file}`));
+    console.log(chalk9.green(`  \u2713 ${file}`));
   }
   console.log();
 }
@@ -5332,19 +5521,19 @@ async function cleanAll(baselineDir, diffDir) {
   const diffs = cleanDiffs(diffDir);
   spinner.succeed("\u6E05\u7406\u5B8C\u6210");
   console.log();
-  console.log(chalk8.white("  \u5DF2\u5220\u9664:"));
+  console.log(chalk9.white("  \u5DF2\u5220\u9664:"));
   console.log(`    \u57FA\u7EBF: ${baselines} \u4E2A`);
   console.log(`    \u5DEE\u5F02: ${diffs} \u4E2A`);
   console.log();
 }
 
 // src/commands/setup.ts
-import chalk9 from "chalk";
+import chalk10 from "chalk";
 import inquirer4 from "inquirer";
 import ora8 from "ora";
 import { execFile as execFile4 } from "child_process";
 import fs15 from "fs";
-import path16 from "path";
+import path17 from "path";
 var DEPENDENCY_GROUPS = [
   {
     name: "Vitest (\u5355\u5143/\u7EC4\u4EF6/API\u6D4B\u8BD5)",
@@ -5368,7 +5557,7 @@ function registerSetupCommand(program2) {
     try {
       await executeSetup(options);
     } catch (error) {
-      console.error(chalk9.red(`
+      console.error(chalk10.red(`
   \u2717 ${error instanceof Error ? error.message : String(error)}
 `));
       process.exit(1);
@@ -5376,20 +5565,20 @@ function registerSetupCommand(program2) {
   });
 }
 async function executeSetup(options) {
-  console.log(chalk9.cyan("\n  QAT \u4F9D\u8D56\u5B89\u88C5\u5668\n"));
+  console.log(chalk10.cyan("\n  QAT \u4F9D\u8D56\u5B89\u88C5\u5668\n"));
   const projectInfo = detectProject();
-  if (!fs15.existsSync(path16.join(process.cwd(), "package.json"))) {
+  if (!fs15.existsSync(path17.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) {
-    console.log(chalk9.white(`  \u68C0\u6D4B\u5230\u6846\u67B6: ${chalk9.cyan(projectInfo.frameworkDisplayName)}`));
+    console.log(chalk10.white(`  \u68C0\u6D4B\u5230\u6846\u67B6: ${chalk10.cyan(projectInfo.frameworkDisplayName)}`));
     if (projectInfo.uiLibrary !== "none") {
-      console.log(chalk9.white(`  UI \u7EC4\u4EF6\u5E93: ${chalk9.cyan(projectInfo.uiLibrary)}`));
+      console.log(chalk10.white(`  UI \u7EC4\u4EF6\u5E93: ${chalk10.cyan(projectInfo.uiLibrary)}`));
     }
     if (projectInfo.monorepo !== "none") {
-      console.log(chalk9.white(`  Monorepo: ${chalk9.cyan(projectInfo.monorepo)}`));
+      console.log(chalk10.white(`  Monorepo: ${chalk10.cyan(projectInfo.monorepo)}`));
       if (projectInfo.appDirs.length > 0) {
-        console.log(chalk9.white(`  \u5B50\u9879\u76EE: ${chalk9.gray(projectInfo.appDirs.join(", "))}`));
+        console.log(chalk10.white(`  \u5B50\u9879\u76EE: ${chalk10.gray(projectInfo.appDirs.join(", "))}`));
       }
     }
     console.log();
@@ -5412,8 +5601,8 @@ async function executeSetup(options) {
       }
     ]);
     if (chooseDir !== "root") {
-      installDir = path16.join(process.cwd(), chooseDir);
-      if (!fs15.existsSync(path16.join(installDir, "package.json"))) {
+      installDir = path17.join(process.cwd(), chooseDir);
+      if (!fs15.existsSync(path17.join(installDir, "package.json"))) {
         throw new Error(`${chooseDir} \u4E0B\u6CA1\u6709 package.json`);
       }
     }
@@ -5425,12 +5614,12 @@ async function executeSetup(options) {
   }
   const groupsToInstall = determineGroups(config, projectInfo, options.force);
   if (groupsToInstall.length === 0) {
-    console.log(chalk9.green("  \u2713 \u6240\u6709\u4F9D\u8D56\u5DF2\u5B89\u88C5\uFF0C\u65E0\u9700\u989D\u5916\u64CD\u4F5C\n"));
+    console.log(chalk10.green("  \u2713 \u6240\u6709\u4F9D\u8D56\u5DF2\u5B89\u88C5\uFF0C\u65E0\u9700\u989D\u5916\u64CD\u4F5C\n"));
     return;
   }
   const selectedGroups = await selectGroups(groupsToInstall, options.dryRun);
   if (selectedGroups.length === 0) {
-    console.log(chalk9.gray("\n  \u5DF2\u53D6\u6D88\u5B89\u88C5\n"));
+    console.log(chalk10.gray("\n  \u5DF2\u53D6\u6D88\u5B89\u88C5\n"));
     return;
   }
   const allPackages = selectedGroups.flatMap((g) => g.packages);
@@ -5444,19 +5633,19 @@ ${allPackages.map((p) => `  - ${p}`).join("\n")}`,
     }
   ]);
   if (!confirmed) {
-    console.log(chalk9.gray("\n  \u5DF2\u53D6\u6D88\u5B89\u88C5\n"));
+    console.log(chalk10.gray("\n  \u5DF2\u53D6\u6D88\u5B89\u88C5\n"));
     return;
   }
   if (options.dryRun) {
-    console.log(chalk9.yellow("\n  [Dry Run] \u4EE5\u4E0B\u547D\u4EE4\u5C06\u88AB\u6267\u884C:\n"));
+    console.log(chalk10.yellow("\n  [Dry Run] \u4EE5\u4E0B\u547D\u4EE4\u5C06\u88AB\u6267\u884C:\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 ${path16.relative(process.cwd(), installDir) || installDir})` : "";
-      console.log(chalk9.white(`  ${installCmd} ${group.packages.join(" ")}${dirHint}`));
+      const dirHint = installDir !== process.cwd() ? ` (\u5728 ${path17.relative(process.cwd(), installDir) || installDir})` : "";
+      console.log(chalk10.white(`  ${installCmd} ${group.packages.join(" ")}${dirHint}`));
       if (group.postInstall) {
         for (const cmd of group.postInstall) {
-          console.log(chalk9.white(`  ${cmd}`));
+          console.log(chalk10.white(`  ${cmd}`));
         }
       }
     }
@@ -5569,36 +5758,36 @@ ${stderr}` : "")));
   });
 }
 function displaySetupResult(groups) {
-  console.log(chalk9.green("\n  \u2713 \u4F9D\u8D56\u5B89\u88C5\u5B8C\u6210!\n"));
-  console.log(chalk9.white("  \u5DF2\u5B89\u88C5:"));
+  console.log(chalk10.green("\n  \u2713 \u4F9D\u8D56\u5B89\u88C5\u5B8C\u6210!\n"));
+  console.log(chalk10.white("  \u5DF2\u5B89\u88C5:"));
   for (const group of groups) {
-    console.log(chalk9.cyan(`
+    console.log(chalk10.cyan(`
   ${group.name}`));
     for (const pkg of group.packages) {
-      console.log(chalk9.gray(`    \u2713 ${pkg}`));
+      console.log(chalk10.gray(`    \u2713 ${pkg}`));
     }
     if (group.postInstall) {
       for (const cmd of group.postInstall) {
-        console.log(chalk9.gray(`    \u2713 ${cmd}`));
+        console.log(chalk10.gray(`    \u2713 ${cmd}`));
       }
     }
   }
   console.log();
-  console.log(chalk9.cyan("  \u4E0B\u4E00\u6B65:"));
-  console.log(chalk9.gray("    1. \u8FD0\u884C qat create \u521B\u5EFA\u6D4B\u8BD5\u7528\u4F8B"));
-  console.log(chalk9.gray("    2. \u8FD0\u884C qat run \u6267\u884C\u6D4B\u8BD5"));
+  console.log(chalk10.cyan("  \u4E0B\u4E00\u6B65:"));
+  console.log(chalk10.gray("    1. \u8FD0\u884C qat create \u521B\u5EFA\u6D4B\u8BD5\u7528\u4F8B"));
+  console.log(chalk10.gray("    2. \u8FD0\u884C qat run \u6267\u884C\u6D4B\u8BD5"));
   console.log();
 }
 
 // src/commands/status.ts
-import chalk10 from "chalk";
+import chalk11 from "chalk";
 import ora9 from "ora";
 function registerStatusCommand(program2) {
   program2.command("status").description("\u67E5\u770B QAT \u72B6\u6001 - AI \u6A21\u578B\u4FE1\u606F\u3001\u9879\u76EE\u914D\u7F6E").action(async (options) => {
     try {
       await executeStatus(options);
     } catch (error) {
-      console.error(chalk10.red(`
+      console.error(chalk11.red(`
   \u2717 ${error instanceof Error ? error.message : String(error)}
 `));
       process.exit(1);
@@ -5606,24 +5795,24 @@ function registerStatusCommand(program2) {
   });
 }
 async function executeStatus(_options) {
-  console.log(chalk10.cyan("\n  AI \u6A21\u578B\u72B6\u6001"));
-  console.log(chalk10.gray("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+  console.log(chalk11.cyan("\n  AI \u6A21\u578B\u72B6\u6001"));
+  console.log(chalk11.gray("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
   const globalAI = loadGlobalAIConfig();
   if (!globalAI) {
-    console.log(chalk10.yellow("  \u2717 \u672A\u914D\u7F6E AI \u6A21\u578B"));
-    console.log(chalk10.gray("    \u8FD0\u884C qat change \u914D\u7F6E AI \u6A21\u578B"));
+    console.log(chalk11.yellow("  \u2717 \u672A\u914D\u7F6E AI \u6A21\u578B"));
+    console.log(chalk11.gray("    \u8FD0\u884C qat change \u914D\u7F6E AI \u6A21\u578B"));
   } else {
-    console.log(`  ${chalk10.white("\u6A21\u578B:")}     ${chalk10.green(globalAI.model)}`);
-    console.log(`  ${chalk10.white("API URL:")}  ${chalk10.gray(globalAI.baseUrl)}`);
-    console.log(`  ${chalk10.white("API Key:")}  ${chalk10.gray(maskApiKey(globalAI.apiKey))}`);
-    console.log(`  ${chalk10.white("Provider:")} ${chalk10.gray(globalAI.provider)}`);
-    console.log(`  ${chalk10.white("\u914D\u7F6E\u6587\u4EF6:")} ${chalk10.gray(getAIConfigPath())}`);
+    console.log(`  ${chalk11.white("\u6A21\u578B:")}     ${chalk11.green(globalAI.model)}`);
+    console.log(`  ${chalk11.white("API URL:")}  ${chalk11.gray(globalAI.baseUrl)}`);
+    console.log(`  ${chalk11.white("API Key:")}  ${chalk11.gray(maskApiKey(globalAI.apiKey))}`);
+    console.log(`  ${chalk11.white("Provider:")} ${chalk11.gray(globalAI.provider)}`);
+    console.log(`  ${chalk11.white("\u914D\u7F6E\u6587\u4EF6:")} ${chalk11.gray(getAIConfigPath())}`);
     const testSpinner = ora9("  \u6B63\u5728\u6D4B\u8BD5\u8FDE\u901A\u6027...").start();
     try {
       const aiConfig = toAIConfig(globalAI);
       const result = await testAIConnection(aiConfig);
       if (result.ok) {
-        testSpinner.succeed(`  \u8FDE\u901A\u6B63\u5E38 ${chalk10.gray(`(${result.latencyMs}ms)`)}`);
+        testSpinner.succeed(`  \u8FDE\u901A\u6B63\u5E38 ${chalk11.gray(`(${result.latencyMs}ms)`)}`);
       } else {
         testSpinner.fail(`  \u8FDE\u901A\u5F02\u5E38: ${result.message}`);
       }
@@ -5632,26 +5821,26 @@ async function executeStatus(_options) {
     }
   }
   console.log();
-  console.log(chalk10.cyan("  \u9879\u76EE\u914D\u7F6E"));
-  console.log(chalk10.gray("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+  console.log(chalk11.cyan("  \u9879\u76EE\u914D\u7F6E"));
+  console.log(chalk11.gray("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
   try {
     const config = await loadConfig();
     const projectInfo = detectProject();
-    console.log(`  ${chalk10.white("\u6846\u67B6:")}       ${projectInfo.frameworkDisplayName}`);
-    console.log(`  ${chalk10.white("\u6E90\u7801\u76EE\u5F55:")}   ${config.project.srcDir}`);
-    console.log(`  ${chalk10.white("Vitest:")}     ${config.vitest.enabled ? chalk10.green("\u2713") : chalk10.red("\u2717")} (${config.vitest.environment})`);
-    console.log(`  ${chalk10.white("Playwright:")} ${config.playwright.enabled ? chalk10.green("\u2713") : chalk10.red("\u2717")} (${config.playwright.browsers.join(", ")})`);
-    console.log(`  ${chalk10.white("Mock:")}       ${config.mock.enabled ? chalk10.green("\u2713") : chalk10.red("\u2717")} (port ${config.mock.port})`);
-    console.log(`  ${chalk10.white("Visual:")}     ${config.visual.enabled ? chalk10.green("\u2713") : chalk10.red("\u2717")}`);
-    console.log(`  ${chalk10.white("Lighthouse:")} ${config.lighthouse.enabled ? chalk10.green("\u2713") : chalk10.red("\u2717")}`);
+    console.log(`  ${chalk11.white("\u6846\u67B6:")}       ${projectInfo.frameworkDisplayName}`);
+    console.log(`  ${chalk11.white("\u6E90\u7801\u76EE\u5F55:")}   ${config.project.srcDir}`);
+    console.log(`  ${chalk11.white("Vitest:")}     ${config.vitest.enabled ? chalk11.green("\u2713") : chalk11.red("\u2717")} (${config.vitest.environment})`);
+    console.log(`  ${chalk11.white("Playwright:")} ${config.playwright.enabled ? chalk11.green("\u2713") : chalk11.red("\u2717")} (${config.playwright.browsers.join(", ")})`);
+    console.log(`  ${chalk11.white("Mock:")}       ${config.mock.enabled ? chalk11.green("\u2713") : chalk11.red("\u2717")} (port ${config.mock.port})`);
+    console.log(`  ${chalk11.white("Visual:")}     ${config.visual.enabled ? chalk11.green("\u2713") : chalk11.red("\u2717")}`);
+    console.log(`  ${chalk11.white("Lighthouse:")} ${config.lighthouse.enabled ? chalk11.green("\u2713") : chalk11.red("\u2717")}`);
   } catch {
-    console.log(chalk10.yellow("  \u2717 \u672A\u627E\u5230\u9879\u76EE\u914D\u7F6E (\u8FD0\u884C qat init \u521D\u59CB\u5316)"));
+    console.log(chalk11.yellow("  \u2717 \u672A\u627E\u5230\u9879\u76EE\u914D\u7F6E (\u8FD0\u884C qat init \u521D\u59CB\u5316)"));
   }
   console.log();
 }
 
 // src/commands/change.ts
-import chalk11 from "chalk";
+import chalk12 from "chalk";
 import inquirer5 from "inquirer";
 import ora10 from "ora";
 function registerChangeCommand(program2) {
@@ -5659,7 +5848,7 @@ function registerChangeCommand(program2) {
     try {
       await executeChange(options);
     } catch (error) {
-      console.error(chalk11.red(`
+      console.error(chalk12.red(`
   \u2717 ${error instanceof Error ? error.message : String(error)}
 `));
       process.exit(1);
@@ -5669,13 +5858,13 @@ function registerChangeCommand(program2) {
 async function executeChange(_options) {
   const current = loadGlobalAIConfig();
   if (current) {
-    console.log(chalk11.cyan("\n  \u5F53\u524D AI \u914D\u7F6E:"));
-    console.log(`  ${chalk11.white("\u6A21\u578B:")}     ${chalk11.green(current.model)}`);
-    console.log(`  ${chalk11.white("API URL:")}  ${chalk11.gray(current.baseUrl)}`);
-    console.log(`  ${chalk11.white("API Key:")}  ${chalk11.gray(maskApiKey(current.apiKey))}`);
+    console.log(chalk12.cyan("\n  \u5F53\u524D AI \u914D\u7F6E:"));
+    console.log(`  ${chalk12.white("\u6A21\u578B:")}     ${chalk12.green(current.model)}`);
+    console.log(`  ${chalk12.white("API URL:")}  ${chalk12.gray(current.baseUrl)}`);
+    console.log(`  ${chalk12.white("API Key:")}  ${chalk12.gray(maskApiKey(current.apiKey))}`);
     console.log();
   } else {
-    console.log(chalk11.yellow("\n  \u5F53\u524D\u672A\u914D\u7F6E AI \u6A21\u578B\uFF0C\u8BF7\u914D\u7F6E:\n"));
+    console.log(chalk12.yellow("\n  \u5F53\u524D\u672A\u914D\u7F6E AI \u6A21\u578B\uFF0C\u8BF7\u914D\u7F6E:\n"));
   }
   const answers = await inquirer5.prompt([
     {
@@ -5713,16 +5902,16 @@ async function executeChange(_options) {
     model: answers.model?.trim() || "deepseek-chat"
   };
   saveGlobalAIConfig(newConfig);
-  console.log(chalk11.green(`
+  console.log(chalk12.green(`
   \u2713 AI \u914D\u7F6E\u5DF2\u4FDD\u5B58`));
-  console.log(chalk11.gray(`    ${getAIConfigPath()}`));
-  console.log(`    ${chalk11.white("\u6A21\u578B:")} ${chalk11.green(newConfig.model)} @ ${chalk11.gray(newConfig.baseUrl)}`);
+  console.log(chalk12.gray(`    ${getAIConfigPath()}`));
+  console.log(`    ${chalk12.white("\u6A21\u578B:")} ${chalk12.green(newConfig.model)} @ ${chalk12.gray(newConfig.baseUrl)}`);
   const testSpinner = ora10("  \u6B63\u5728\u6D4B\u8BD5\u8FDE\u901A\u6027...").start();
   try {
     const aiConfig = toAIConfig(newConfig);
     const result = await testAIConnection(aiConfig);
     if (result.ok) {
-      testSpinner.succeed(`  AI \u8FDE\u901A\u6B63\u5E38 ${chalk11.gray(`(${newConfig.model}, ${result.latencyMs}ms)`)}`);
+      testSpinner.succeed(`  AI \u8FDE\u901A\u6B63\u5E38 ${chalk12.gray(`(${newConfig.model}, ${result.latencyMs}ms)`)}`);
     } else {
       testSpinner.fail(`  AI \u8FDE\u901A\u5F02\u5E38: ${result.message}`);
     }
@@ -5733,37 +5922,40 @@ async function executeChange(_options) {
 }
 
 // src/cli.ts
-var VERSION = "0.3.03";
+var VERSION = "0.3.05";
 function printLogo() {
   const logo = `
-  ${chalk12.bold.cyan("   ___            _          _           _              _               _____                _     _                 ")}
-  ${chalk12.bold.cyan("  / _ \\   _   _  (_)   ___  | | __      / \\     _   _  | |_    ___     |_   _|   ___   ___  | |_  (_)  _ __     __ _ ")}
-  ${chalk12.bold.cyan(" | | | | | | | | | |  / __| | |/ /     / _ \\   | | | | | __|  / _ \\      | |    / _ \\ / __| | __| | | | '_ \\   / _` |")}
-  ${chalk12.bold.cyan(" | |_| | | |_| | | | | (__  |   <     / ___ \\  | |_| | | |_  | (_) |     | |   |  __/ \\__ \\ | |_  | | | | | | | (_| |")}
-  ${chalk12.bold.cyan("  \\__\\_\\  \\__,_| |_|  \\___| |_|\\_\\   /_/   \\_\\  \\__,_|  \\__|  \\___/      |_|    \\___| |___/  \\__| |_| |_| |_|  \\__, |")}
-  ${chalk12.bold.cyan("                                                                                                               |___/ ")}
-  ${chalk12.gray("   CLI\u81EA\u52A8\u5316\u6D4B\u8BD5\u5DE5\u5177 v")}${chalk12.green(VERSION)}
+  ${chalk13.bold.cyan("   ___            _          _           _              _               _____                _     _                 ")}
+  ${chalk13.bold.cyan("  / _ \\   _   _  (_)   ___  | | __      / \\     _   _  | |_    ___     |_   _|   ___   ___  | |_  (_)  _ __     __ _ ")}
+  ${chalk13.bold.cyan(" | | | | | | | | | |  / __| | |/ /     / _ \\   | | | | | __|  / _ \\      | |    / _ \\ / __| | __| | | | '_ \\   / _` |")}
+  ${chalk13.bold.cyan(" | |_| | | |_| | | | | (__  |   <     / ___ \\  | |_| | | |_  | (_) |     | |   |  __/ \\__ \\ | |_  | | | | | | | (_| |")}
+  ${chalk13.bold.cyan("  \\__\\_\\  \\__,_| |_|  \\___| |_|\\_\\   /_/   \\_\\  \\__,_|  \\__|  \\___/      |_|    \\___| |___/  \\__| |_| |_| |_|  \\__, |")}
+  ${chalk13.bold.cyan("                                                                                                               |___/ ")}
+  ${chalk13.gray("   CLI\u81EA\u52A8\u5316\u6D4B\u8BD5\u5DE5\u5177 v")}${chalk13.green(VERSION)}
 `;
   console.log(logo);
 }
 var program = new Command();
-program.name("qat").description("CLI\u81EA\u52A8\u5316\u6D4B\u8BD5\u5DE5\u5177 - \u9762\u5411Vue\u9879\u76EE\uFF0C\u96C6\u6210Vitest\u3001Playwright\uFF0C\u8986\u76D6\u6D4B\u8BD5\u5168\u6D41\u7A0B").version(VERSION).option("-c, --config <path>", "\u6307\u5B9A\u914D\u7F6E\u6587\u4EF6\u8DEF\u5F84").option("-v, --verbose", "\u663E\u793A\u8BE6\u7EC6\u8F93\u51FA").hook("preAction", async (thisCommand) => {
+program.name("qat").description("CLI\u81EA\u52A8\u5316\u6D4B\u8BD5\u5DE5\u5177 - \u9762\u5411Vue\u9879\u76EE\uFF0C\u96C6\u6210Vitest\u3001Playwright\uFF0C\u8986\u76D6\u6D4B\u8BD5\u5168\u6D41\u7A0B").version(VERSION).option("-c, --config <path>", "\u6307\u5B9A\u914D\u7F6E\u6587\u4EF6\u8DEF\u5F84").option("-v, --verbose", "\u663E\u793A\u8BE6\u7EC6\u8F93\u51FA").option("-d, --debug", "\u8C03\u8BD5\u6A21\u5F0F\uFF1A\u663E\u793AAI\u8BF7\u6C42/\u54CD\u5E94\u8BE6\u60C5").hook("preAction", async (thisCommand) => {
   printLogo();
   const opts = thisCommand.opts();
   if (opts.verbose) {
     process.env.QAT_VERBOSE = "true";
   }
+  if (opts.debug) {
+    process.env.QAT_DEBUG = "true";
+  }
   if (opts.config) {
     process.env.QAT_CONFIG_PATH = opts.config;
   }
   const { loadExternalFrameworks } = await import("./framework-registry-YGZ63RDX.js");
   const loadResult = await loadExternalFrameworks(process.cwd());
   if (loadResult.loaded > 0 && opts.verbose) {
-    console.log(chalk12.gray(`  [ext] \u5DF2\u52A0\u8F7D ${loadResult.loaded} \u4E2A\u5916\u90E8\u6269\u5C55\u6587\u4EF6: ${loadResult.files.join(", ")}`));
+    console.log(chalk13.gray(`  [ext] \u5DF2\u52A0\u8F7D ${loadResult.loaded} \u4E2A\u5916\u90E8\u6269\u5C55\u6587\u4EF6: ${loadResult.files.join(", ")}`));
   }
   if (loadResult.errors.length > 0) {
     for (const err of loadResult.errors) {
-      console.log(chalk12.yellow(`  [ext] \u8B66\u544A: ${err.file} - ${err.error}`));
+      console.log(chalk13.yellow(`  [ext] \u8B66\u544A: ${err.file} - ${err.error}`));
     }
   }
 });
@@ -5777,9 +5969,9 @@ registerSetupCommand(program);
 registerStatusCommand(program);
 registerChangeCommand(program);
 program.on("command:*", (operands) => {
-  console.error(chalk12.red(`
+  console.error(chalk13.red(`
   \u672A\u77E5\u547D\u4EE4: ${operands[0]}`));
-  console.log(chalk12.gray(`  \u4F7F\u7528 qat --help \u67E5\u770B\u53EF\u7528\u547D\u4EE4
+  console.log(chalk13.gray(`  \u4F7F\u7528 qat --help \u67E5\u770B\u53EF\u7528\u547D\u4EE4
 `));
   process.exit(1);
 });