qat-cli 0.2.98 → 0.3.2

package/dist/cli.js

@@ -11,11 +11,11 @@ import { Command } from "commander";
 import chalk12 from "chalk";
 
 // src/commands/init.ts
-import chalk3 from "chalk";
+import chalk2 from "chalk";
 import inquirer from "inquirer";
-import ora2 from "ora";
-import fs7 from "fs";
-import path7 from "path";
+import ora from "ora";
+import fs6 from "fs";
+import path6 from "path";
 
 // src/services/detector.ts
 import fs from "fs";
@@ -1262,99 +1262,6 @@ async function testAIConnection(config) {
   return provider.testConnection();
 }
 
-// src/services/test-reviewer.ts
-import chalk2 from "chalk";
-import ora from "ora";
-var MAX_RETRIES = 3;
-var REVIEW_THRESHOLD = 0.6;
-async function generateWithReview(params) {
-  const { testType, targetPath, sourceCode, analysis, aiConfig, framework, onAttempt } = params;
-  const generatorProvider = createAIProvider(aiConfig);
-  const reviewerProvider = createAIProvider(aiConfig);
-  if (!generatorProvider.capabilities.generateTest) {
-    throw new Error("\u5F53\u524D AI Provider \u4E0D\u652F\u6301\u6D4B\u8BD5\u751F\u6210");
-  }
-  let currentCode = "";
-  let currentDescription = "";
-  let currentConfidence = 0;
-  let lastReview = null;
-  let approved = false;
-  let attempts = 0;
-  for (let i = 0; i < MAX_RETRIES; i++) {
-    attempts = i + 1;
-    onAttempt?.(attempts, MAX_RETRIES);
-    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}
-\u5177\u4F53\u95EE\u9898:
-${lastReview.issues.map((issue) => `- ${issue}`).join("\n")}
-\u6539\u8FDB\u5EFA\u8BAE:
-${lastReview.suggestions.map((s) => `- ${s}`).join("\n")}
-
-\u8BF7\u9488\u5BF9\u4EE5\u4E0A\u95EE\u9898\u91CD\u65B0\u751F\u6210\u66F4\u8D34\u5207\u3001\u66F4\u51C6\u786E\u7684\u6D4B\u8BD5\u7528\u4F8B\u3002`;
-    const generateResponse = await generatorProvider.generateTest({
-      type: testType,
-      target: targetPath,
-      context: i === 0 ? sourceCode : `${sourceCode}
-
---- \u5BA1\u8BA1\u53CD\u9988 ---
-${generationPrompt}`,
-      framework: framework || void 0,
-      analysis
-    });
-    currentCode = generateResponse.code;
-    currentDescription = generateResponse.description;
-    currentConfidence = generateResponse.confidence;
-    const reviewRequest = {
-      target: targetPath,
-      sourceCode,
-      analysis,
-      testCode: currentCode,
-      testType,
-      generationDescription: currentDescription
-    };
-    lastReview = await reviewerProvider.reviewTest(reviewRequest);
-    approved = lastReview.approved && lastReview.score >= REVIEW_THRESHOLD;
-    if (approved) {
-      break;
-    }
-  }
-  return {
-    code: currentCode,
-    description: currentDescription,
-    confidence: currentConfidence,
-    approved,
-    attempts,
-    reviewScore: lastReview?.score ?? 0,
-    reviewFeedback: lastReview?.feedback ?? "",
-    reviewIssues: lastReview?.issues ?? [],
-    reviewSuggestions: lastReview?.suggestions ?? []
-  };
-}
-function printReviewReport(report) {
-  if (report.length === 0) return;
-  const approved = report.filter((r) => r.approved);
-  const failed = report.filter((r) => !r.approved);
-  console.log();
-  console.log(chalk2.cyan("  \u5BA1\u8BA1\u62A5\u544A:"));
-  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"));
-  for (const entry of approved) {
-    console.log(`  ${chalk2.green("\u2713")} ${chalk2.gray(entry.target)} ${chalk2.green(`(${(entry.score * 100).toFixed(0)}%`)}${entry.attempts > 1 ? chalk2.yellow(` ${entry.attempts}\u6B21\u5C1D\u8BD5`) : ""})`);
-  }
-  for (const entry of failed) {
-    console.log(`  ${chalk2.red("\u2717")} ${chalk2.gray(entry.target)} ${chalk2.red(`(${(entry.score * 100).toFixed(0)}%)`)}`);
-    if (entry.issues.length > 0) {
-      for (const issue of entry.issues.slice(0, 3)) {
-        console.log(chalk2.gray(`      - ${issue}`));
-      }
-    }
-    if (entry.feedback) {
-      console.log(chalk2.gray(`      \u53CD\u9988: ${entry.feedback}`));
-    }
-  }
-  console.log();
-}
-
 // src/services/source-analyzer.ts
 import fs4 from "fs";
 import path4 from "path";
@@ -1790,154 +1697,492 @@ function generateMockRoutesFromAPICalls(apiCalls) {
   return routes;
 }
 
-// src/services/template.ts
+// src/services/global-config.ts
 import fs5 from "fs";
 import path5 from "path";
-import { fileURLToPath } from "url";
-import Handlebars from "handlebars";
-var __filename = fileURLToPath(import.meta.url);
-var __dirname = path5.dirname(__filename);
-var TEMPLATE_MAP = {
-  unit: "unit-test.hbs",
-  component: "component-test.hbs",
-  e2e: "e2e-test.hbs",
-  api: "api-test.hbs",
-  visual: "visual-test.hbs",
-  performance: "performance-test.hbs"
-};
-var customTemplates = /* @__PURE__ */ new Map();
-Handlebars.registerHelper("eq", (a, b) => a === b);
-Handlebars.registerHelper("neq", (a, b) => a !== b);
-Handlebars.registerHelper("includes", (arr, val) => Array.isArray(arr) && arr.includes(val));
-Handlebars.registerHelper("join", (arr, sep) => Array.isArray(arr) ? arr.join(sep) : "");
-Handlebars.registerHelper("camelCase", (str) => toCamelCase(str));
-Handlebars.registerHelper("pascalCase", (str) => toPascalCase(str));
-Handlebars.registerHelper("length", (arr) => Array.isArray(arr) ? arr.length : 0);
-Handlebars.registerHelper("gt", (a, b) => Number(a) > Number(b));
-Handlebars.registerHelper("and", (...args) => {
-  args.pop();
-  return args.every(Boolean);
-});
-Handlebars.registerHelper("or", (...args) => {
-  args.pop();
-  return args.some(Boolean);
-});
-Handlebars.registerHelper("propDefaultValue", (prop) => {
-  if (!prop.defaultValue) return "undefined";
-  const map = { String: "''", Number: "0", Boolean: "false", Array: "[]", Object: "{}" };
-  return map[prop.type] || prop.defaultValue;
-});
-Handlebars.registerHelper("propTestValue", (prop) => {
-  const map = {
-    String: "'test-value'",
-    Number: "42",
-    Boolean: "true",
-    Array: "[1, 2, 3]",
-    Object: '{ key: "value" }'
-  };
-  return map[prop.type] || "'test-value'";
-});
-function renderTemplate(type, context) {
-  const templateContent = loadTemplate(type);
-  const template = Handlebars.compile(templateContent);
-  const fullContext = {
-    vueVersion: 3,
-    typescript: true,
-    imports: [],
-    extraImports: [],
-    globalPlugins: [],
-    globalStubs: [],
-    mountOptions: "",
-    hasAnalysis: false,
-    exports: [],
-    functionExports: [],
-    valueExports: [],
-    props: [],
-    emits: [],
-    methods: [],
-    computed: [],
-    isVueComponent: false,
-    requiredProps: [],
-    optionalProps: [],
-    ...context,
-    framework: context.framework || "vue",
-    camelName: context.camelName || toCamelCase(context.name),
-    pascalName: context.pascalName || toPascalCase(context.name)
-  };
-  if (fullContext.exports && fullContext.exports.length > 0) {
-    fullContext.hasAnalysis = true;
-    fullContext.functionExports = fullContext.exports.filter(
-      (e) => e.kind === "function" || e.kind === "default"
-    );
-    fullContext.valueExports = fullContext.exports.filter(
-      (e) => e.kind !== "function" && e.kind !== "default" && e.kind !== "type"
-    );
-  }
-  if (fullContext.props && fullContext.props.length > 0) {
-    fullContext.isVueComponent = true;
-    fullContext.requiredProps = fullContext.props.filter((p) => p.required);
-    fullContext.optionalProps = fullContext.props.filter((p) => !p.required);
+import os from "os";
+var QAT_DIR = path5.join(os.homedir(), ".qat");
+var AI_CONFIG_PATH = path5.join(QAT_DIR, "ai.json");
+function loadGlobalAIConfig() {
+  if (!fs5.existsSync(AI_CONFIG_PATH)) {
+    return null;
   }
-  if (fullContext.emits && fullContext.emits.length > 0) {
-    fullContext.isVueComponent = true;
+  try {
+    const content = fs5.readFileSync(AI_CONFIG_PATH, "utf-8");
+    const config = JSON.parse(content);
+    if (!config.baseUrl || !config.model) {
+      return null;
+    }
+    return config;
+  } catch {
+    return null;
   }
-  return template(fullContext);
 }
-function loadTemplate(type) {
-  const custom = customTemplates.get(type);
-  if (custom) return custom;
-  const templateDir = getTemplateDir();
-  const templateFile = TEMPLATE_MAP[type];
-  const templatePath = path5.join(templateDir, templateFile);
-  if (fs5.existsSync(templatePath)) {
-    return fs5.readFileSync(templatePath, "utf-8");
+function saveGlobalAIConfig(config) {
+  if (!fs5.existsSync(QAT_DIR)) {
+    fs5.mkdirSync(QAT_DIR, { recursive: true });
   }
-  return getBuiltinTemplate(type);
+  fs5.writeFileSync(AI_CONFIG_PATH, JSON.stringify(config, null, 2), "utf-8");
 }
-function getTemplateDir() {
-  const projectTemplates = path5.join(process.cwd(), "templates");
-  if (fs5.existsSync(projectTemplates)) {
-    return projectTemplates;
-  }
-  return path5.join(__dirname, "..", "templates");
+function toAIConfig(globalConfig) {
+  return {
+    provider: globalConfig.provider || "openai",
+    apiKey: globalConfig.apiKey || void 0,
+    baseUrl: globalConfig.baseUrl,
+    model: globalConfig.model
+  };
+}
+function maskApiKey(apiKey) {
+  if (!apiKey) return "(\u672A\u8BBE\u7F6E)";
+  if (apiKey.length <= 8) return "****";
+  return apiKey.slice(0, 4) + "****" + apiKey.slice(-4);
+}
+function getAIConfigPath() {
+  return AI_CONFIG_PATH;
 }
-function getBuiltinTemplate(type) {
-  const templates = {
-    unit: `import { describe, it, expect } from 'vitest';
-{{#if hasAnalysis}}
-{{#each valueExports}}
-import { {{name}} } from '{{../target}}';
-{{/each}}
-{{#each functionExports}}
-import { {{name}} } from '{{../target}}';
-{{/each}}
-{{else}}
-import { {{camelName}} } from '{{target}}';
-{{/if}}
 
-describe('{{name}}', () => {
-{{#if hasAnalysis}}
-  {{#each functionExports}}
-  describe('{{name}}()', () => {
-    {{#if isAsync}}
-    it('should resolve successfully', async () => {
-      const result = await {{name}}({{#each params}}{{#unless @first}}, {{/unless}}{{this}}: undefined{{/each}});
-      expect(result).toBeDefined();
-    });
-    {{else}}
-    it('should return a value', () => {
-      const result = {{name}}({{#each params}}{{#unless @first}}, {{/unless}}undefined as any{{/each}});
-      expect(result).toBeDefined();
-    });
-    {{/if}}
-    {{#if returnType}}
-    it('should return correct type', () => {
-      {{#if isAsync}}
-      const result = await {{name}}({{#each params}}{{#unless @first}}, {{/unless}}undefined as any{{/each}});
-      {{else}}
-      const result = {{name}}({{#each params}}{{#unless @first}}, {{/unless}}undefined as any{{/each}});
-      {{/if}}
-      expect(result).toBeDefined();
+// src/commands/init.ts
+function registerInitCommand(program2) {
+  program2.command("init").description("\u521D\u59CB\u5316\u6D4B\u8BD5\u9879\u76EE - \u68C0\u6D4B\u9879\u76EE\u3001\u751F\u6210\u914D\u7F6E\u3001\u81EA\u52A8\u521B\u5EFA\u6D4B\u8BD5\u7528\u4F8B").option("-f, --force", "\u5F3A\u5236\u8986\u76D6\u5DF2\u6709\u914D\u7F6E\u6587\u4EF6").action(async (options) => {
+    try {
+      await executeInit(options);
+    } catch (error) {
+      console.error(chalk2.red(`
+  \u2717 ${error instanceof Error ? error.message : String(error)}
+`));
+      process.exit(1);
+    }
+  });
+}
+async function executeInit(options) {
+  const spinner = ora("\u6B63\u5728\u68C0\u6D4B\u9879\u76EE\u7ED3\u6784...").start();
+  const projectInfo = detectProject();
+  spinner.stop();
+  displayProjectInfo(projectInfo);
+  if (!projectInfo.isVue) {
+    const { proceed } = await inquirer.prompt([
+      {
+        type: "confirm",
+        name: "proceed",
+        message: "\u672A\u68C0\u6D4B\u5230 Vue \u9879\u76EE\uFF0C\u662F\u5426\u7EE7\u7EED\u521D\u59CB\u5316\uFF1F",
+        default: false
+      }
+    ]);
+    if (!proceed) {
+      console.log(chalk2.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"));
+    globalAI = await promptAIConfig();
+    saveGlobalAIConfig(globalAI);
+    console.log(chalk2.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)})
+`));
+  }
+  const aiConfig = toAIConfig(globalAI);
+  if (aiConfig.apiKey || aiConfig.baseUrl) {
+    const testSpinner = ora(`\u6B63\u5728\u6D4B\u8BD5 AI \u8FDE\u901A\u6027 (${globalAI.model})...`).start();
+    try {
+      const result = await testAIConnection(aiConfig);
+      if (result.ok) {
+        testSpinner.succeed(`AI \u8FDE\u901A\u6B63\u5E38 ${chalk2.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"));
+      }
+    } 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;
+      }
+    }
+  } 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;
+    }
+  }
+  const dirSpinner = ora("\u6B63\u5728\u521B\u5EFA\u6D4B\u8BD5\u76EE\u5F55...").start();
+  const createdDirs = createTestDirectories(config);
+  dirSpinner.succeed("\u6D4B\u8BD5\u76EE\u5F55\u5DF2\u521B\u5EFA");
+  if (config.mock?.enabled !== false) {
+    const mockDir = config.mock?.routesDir || DEFAULT_CONFIG.mock.routesDir;
+    initMockRoutesDir(mockDir);
+    const srcDir2 = config.project?.srcDir || "src";
+    const apiCalls = scanAPICalls(srcDir2);
+    if (apiCalls.length > 0) {
+      const mockRoutes = generateMockRoutesFromAPICalls(apiCalls);
+      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`));
+      }
+    } else {
+      console.log(chalk2.gray("    \u672A\u53D1\u73B0 API \u8C03\u7528\uFF0C\u5DF2\u751F\u6210\u793A\u4F8B Mock \u8DEF\u7531"));
+    }
+  }
+  const srcDir = config.project?.srcDir || "src";
+  const components = discoverVueComponents(process.cwd(), srcDir);
+  const utilities = discoverUtilityFiles(process.cwd(), srcDir);
+  const totalFiles = components.length + utilities.length;
+  if (totalFiles > 0) {
+    console.log(chalk2.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);
+}
+async function promptAIConfig() {
+  const answers = await inquirer.prompt([
+    {
+      type: "input",
+      name: "apiKey",
+      message: "API Key (Ollama \u672C\u5730\u53EF\u7559\u7A7A):",
+      default: ""
+    },
+    {
+      type: "input",
+      name: "baseUrl",
+      message: "API Base URL:",
+      default: "https://api.deepseek.com/v1",
+      validate: (input) => {
+        if (!input.trim()) return "Base URL \u4E0D\u80FD\u4E3A\u7A7A";
+        if (!input.trim().startsWith("http")) return "URL \u5FC5\u987B\u4EE5 http(s):// \u5F00\u5934";
+        return true;
+      }
+    },
+    {
+      type: "input",
+      name: "model",
+      message: "\u6A21\u578B\u540D\u79F0:",
+      default: "deepseek-chat",
+      validate: (input) => {
+        if (!input.trim()) return "\u6A21\u578B\u540D\u79F0\u4E0D\u80FD\u4E3A\u7A7A";
+        return true;
+      }
+    }
+  ]);
+  return {
+    provider: "openai",
+    apiKey: answers.apiKey?.trim() || "",
+    baseUrl: answers.baseUrl?.trim() || "https://api.deepseek.com/v1",
+    model: answers.model?.trim() || "deepseek-chat"
+  };
+}
+function buildProjectConfig(projectInfo) {
+  return {
+    project: {
+      framework: projectInfo.framework,
+      uiLibrary: projectInfo.uiLibrary !== "none" ? projectInfo.uiLibrary : void 0,
+      monorepo: projectInfo.monorepo !== "none" ? projectInfo.monorepo : void 0,
+      vite: projectInfo.isVite,
+      srcDir: projectInfo.srcDir,
+      appDir: projectInfo.appDirs.length > 0 ? projectInfo.appDirs[0] : void 0
+    },
+    vitest: {
+      enabled: true,
+      coverage: true,
+      globals: true,
+      environment: "happy-dom"
+    },
+    playwright: {
+      enabled: true,
+      browsers: ["chromium"],
+      baseURL: "http://localhost:5173",
+      screenshot: "only-on-failure"
+    },
+    visual: {
+      enabled: true,
+      threshold: 0.1,
+      baselineDir: "tests/visual/baseline",
+      diffDir: "tests/visual/diff"
+    },
+    lighthouse: {
+      enabled: true,
+      urls: ["http://localhost:5173"],
+      runs: 3,
+      thresholds: {
+        performance: 80,
+        accessibility: 90
+      }
+    },
+    mock: {
+      enabled: true,
+      port: 3456,
+      routesDir: "tests/mock/routes"
+    }
+  };
+}
+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"));
+  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],
+    ["Vue \u9879\u76EE", info.isVue ? `\u662F (v${info.vueVersion})` : "\u5426"],
+    ["UI \u7EC4\u4EF6\u5E93", info.uiLibrary !== "none" ? info.uiLibrary : "\u672A\u68C0\u6D4B\u5230"],
+    ["Vite \u6784\u5EFA", info.isVite ? "\u662F" : "\u5426"],
+    ["TypeScript", info.typescript ? "\u662F" : "\u5426"],
+    ["\u5305\u7BA1\u7406\u5668", info.packageManager],
+    ["Monorepo", info.monorepo !== "none" ? info.monorepo : "\u5426"],
+    ["\u6E90\u7801\u76EE\u5F55", info.srcDir]
+  ];
+  if (info.appDirs.length > 0) {
+    items.push(["\u5B50\u9879\u76EE", info.appDirs.join(", ")]);
+  }
+  if (info.testFrameworks.length > 0) {
+    items.push(["\u5DF2\u6709\u6D4B\u8BD5\u6846\u67B6", info.testFrameworks.join(", ")]);
+  }
+  if (info.componentDirs.length > 0) {
+    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}`);
+  }
+  console.log();
+}
+function createTestDirectories(config) {
+  const dirs = [];
+  const dirMap = {
+    "tests": true,
+    "tests/unit": config.vitest?.enabled !== false,
+    "tests/component": config.vitest?.enabled !== false,
+    "tests/e2e": config.playwright?.enabled !== false,
+    "tests/api": config.mock?.enabled !== false,
+    "tests/visual": config.visual?.enabled !== false,
+    "tests/visual/baseline": config.visual?.enabled !== false,
+    "tests/visual/diff": config.visual?.enabled !== false,
+    "tests/mock": config.mock?.enabled !== false,
+    "tests/mock/routes": config.mock?.enabled !== false
+  };
+  for (const [dir, shouldCreate] of Object.entries(dirMap)) {
+    if (shouldCreate) {
+      const fullPath = path6.join(process.cwd(), dir);
+      if (!fs6.existsSync(fullPath)) {
+        fs6.mkdirSync(fullPath, { recursive: true });
+        dirs.push(dir);
+      }
+    }
+  }
+  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();
+  if (createdDirs.length > 0) {
+    console.log(chalk2.white("  \u5DF2\u521B\u5EFA\u76EE\u5F55:"));
+    for (const dir of createdDirs) {
+      console.log(chalk2.gray(`    ${dir}/`));
+    }
+    console.log();
+  }
+  console.log(chalk2.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)`));
+  } else {
+    console.log(chalk2.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"));
+  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();
+}
+
+// src/commands/create.ts
+import chalk4 from "chalk";
+import inquirer2 from "inquirer";
+import ora3 from "ora";
+import fs8 from "fs";
+import path8 from "path";
+
+// src/services/template.ts
+import fs7 from "fs";
+import path7 from "path";
+import { fileURLToPath } from "url";
+import Handlebars from "handlebars";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path7.dirname(__filename);
+var TEMPLATE_MAP = {
+  unit: "unit-test.hbs",
+  component: "component-test.hbs",
+  e2e: "e2e-test.hbs",
+  api: "api-test.hbs",
+  visual: "visual-test.hbs",
+  performance: "performance-test.hbs"
+};
+var customTemplates = /* @__PURE__ */ new Map();
+Handlebars.registerHelper("eq", (a, b) => a === b);
+Handlebars.registerHelper("neq", (a, b) => a !== b);
+Handlebars.registerHelper("includes", (arr, val) => Array.isArray(arr) && arr.includes(val));
+Handlebars.registerHelper("join", (arr, sep) => Array.isArray(arr) ? arr.join(sep) : "");
+Handlebars.registerHelper("camelCase", (str) => toCamelCase(str));
+Handlebars.registerHelper("pascalCase", (str) => toPascalCase(str));
+Handlebars.registerHelper("length", (arr) => Array.isArray(arr) ? arr.length : 0);
+Handlebars.registerHelper("gt", (a, b) => Number(a) > Number(b));
+Handlebars.registerHelper("and", (...args) => {
+  args.pop();
+  return args.every(Boolean);
+});
+Handlebars.registerHelper("or", (...args) => {
+  args.pop();
+  return args.some(Boolean);
+});
+Handlebars.registerHelper("propDefaultValue", (prop) => {
+  if (!prop.defaultValue) return "undefined";
+  const map = { String: "''", Number: "0", Boolean: "false", Array: "[]", Object: "{}" };
+  return map[prop.type] || prop.defaultValue;
+});
+Handlebars.registerHelper("propTestValue", (prop) => {
+  const map = {
+    String: "'test-value'",
+    Number: "42",
+    Boolean: "true",
+    Array: "[1, 2, 3]",
+    Object: '{ key: "value" }'
+  };
+  return map[prop.type] || "'test-value'";
+});
+function renderTemplate(type, context) {
+  const templateContent = loadTemplate(type);
+  const template = Handlebars.compile(templateContent);
+  const fullContext = {
+    vueVersion: 3,
+    typescript: true,
+    imports: [],
+    extraImports: [],
+    globalPlugins: [],
+    globalStubs: [],
+    mountOptions: "",
+    hasAnalysis: false,
+    exports: [],
+    functionExports: [],
+    valueExports: [],
+    props: [],
+    emits: [],
+    methods: [],
+    computed: [],
+    isVueComponent: false,
+    requiredProps: [],
+    optionalProps: [],
+    ...context,
+    framework: context.framework || "vue",
+    camelName: context.camelName || toCamelCase(context.name),
+    pascalName: context.pascalName || toPascalCase(context.name)
+  };
+  if (fullContext.exports && fullContext.exports.length > 0) {
+    fullContext.hasAnalysis = true;
+    fullContext.functionExports = fullContext.exports.filter(
+      (e) => e.kind === "function" || e.kind === "default"
+    );
+    fullContext.valueExports = fullContext.exports.filter(
+      (e) => e.kind !== "function" && e.kind !== "default" && e.kind !== "type"
+    );
+  }
+  if (fullContext.props && fullContext.props.length > 0) {
+    fullContext.isVueComponent = true;
+    fullContext.requiredProps = fullContext.props.filter((p) => p.required);
+    fullContext.optionalProps = fullContext.props.filter((p) => !p.required);
+  }
+  if (fullContext.emits && fullContext.emits.length > 0) {
+    fullContext.isVueComponent = true;
+  }
+  return template(fullContext);
+}
+function loadTemplate(type) {
+  const custom = customTemplates.get(type);
+  if (custom) return custom;
+  const templateDir = getTemplateDir();
+  const templateFile = TEMPLATE_MAP[type];
+  const templatePath = path7.join(templateDir, templateFile);
+  if (fs7.existsSync(templatePath)) {
+    return fs7.readFileSync(templatePath, "utf-8");
+  }
+  return getBuiltinTemplate(type);
+}
+function getTemplateDir() {
+  const projectTemplates = path7.join(process.cwd(), "templates");
+  if (fs7.existsSync(projectTemplates)) {
+    return projectTemplates;
+  }
+  return path7.join(__dirname, "..", "templates");
+}
+function getBuiltinTemplate(type) {
+  const templates = {
+    unit: `import { describe, it, expect } from 'vitest';
+{{#if hasAnalysis}}
+{{#each valueExports}}
+import { {{name}} } from '{{../target}}';
+{{/each}}
+{{#each functionExports}}
+import { {{name}} } from '{{../target}}';
+{{/each}}
+{{else}}
+import { {{camelName}} } from '{{target}}';
+{{/if}}
+
+describe('{{name}}', () => {
+{{#if hasAnalysis}}
+  {{#each functionExports}}
+  describe('{{name}}()', () => {
+    {{#if isAsync}}
+    it('should resolve successfully', async () => {
+      const result = await {{name}}({{#each params}}{{#unless @first}}, {{/unless}}{{this}}: undefined{{/each}});
+      expect(result).toBeDefined();
+    });
+    {{else}}
+    it('should return a value', () => {
+      const result = {{name}}({{#each params}}{{#unless @first}}, {{/unless}}undefined as any{{/each}});
+      expect(result).toBeDefined();
+    });
+    {{/if}}
+    {{#if returnType}}
+    it('should return correct type', () => {
+      {{#if isAsync}}
+      const result = await {{name}}({{#each params}}{{#unless @first}}, {{/unless}}undefined as any{{/each}});
+      {{else}}
+      const result = {{name}}({{#each params}}{{#unless @first}}, {{/unless}}undefined as any{{/each}});
+      {{/if}}
+      expect(result).toBeDefined();
     });
     {{/if}}
     {{#if params.length}}
@@ -2066,772 +2311,252 @@ describe('{{name}}', () => {
     {{/each}}
     }{{/if}});
     // TODO: verify computed property '{{this}}'
-    // expect(wrapper.vm.{{this}}).toBeDefined();
-  });
-
-  {{/each}}
-  {{/if}}
-  {{#if methods}}
-  {{#each methods}}
-  it('calls {{this}} method', async () => {
-    const wrapper = mountComponent({{#if ../requiredProps}}{
-    {{#each ../requiredProps}}
-      {{name}}: {{propTestValue this}},
-    {{/each}}
-    }{{/if}});
-    // TODO: test method '{{this}}'
-    // await wrapper.vm.{{this}}();
-    // expect(someCondition).toBe(true);
-  });
-
-  {{/each}}
-  {{/if}}
-  {{else}}
-  it('renders correctly', () => {
-    const wrapper = mount({{pascalName}}{{#if mountOptions}}, {{mountOptions}}{{/if}});
-    expect(wrapper.exists()).toBe(true);
-  });
-
-  it('renders default slot content', () => {
-    const wrapper = mount({{pascalName}}, {
-      {{#if mountOptions}}
-      ...{{mountOptions}},
-      {{/if}}
-      slots: {
-        default: 'Test Content',
-      },
-    });
-    expect(wrapper.text()).toContain('Test Content');
-  });
-
-  it('handles user interaction', async () => {
-    const wrapper = mount({{pascalName}}{{#if mountOptions}}, {{mountOptions}}{{/if}});
-    // TODO: add interaction test
-  });
-  {{/if}}
-});
-`,
-    e2e: `import { test, expect } from '@playwright/test';
-
-test.describe('{{name}}', () => {
-  test.beforeEach(async ({ page }) => {
-    await page.goto('/');
-  });
-
-  test('should display page correctly', async ({ page }) => {
-    // TODO: \u6DFB\u52A0E2E\u6D4B\u8BD5\u65AD\u8A00
-    await expect(page).toHaveTitle(/.*/);
-  });
-
-  test('should navigate between pages', async ({ page }) => {
-    // TODO: \u6DFB\u52A0\u5BFC\u822A\u6D4B\u8BD5
-  });
-
-  test('should be responsive', async ({ page }) => {
-    await page.setViewportSize({ width: 375, height: 667 });
-    // TODO: \u6DFB\u52A0\u79FB\u52A8\u7AEF\u65AD\u8A00
-  });
-});
-`,
-    api: `import { describe, it, expect, beforeAll, afterAll } from 'vitest';
-{{#if imports}}
-{{#each imports}}
-import {{this}};
-{{/each}}
-{{/if}}
-
-describe('{{name}} API', () => {
-  const baseUrl = process.env.API_BASE_URL || 'http://localhost:3456';
-
-  it('should return 200 for GET request', async () => {
-    const response = await fetch(\`\${baseUrl}/api/{{camelName}}\`);
-    expect(response.status).toBe(200);
-  });
-
-  it('should return expected response format', async () => {
-    const response = await fetch(\`\${baseUrl}/api/{{camelName}}\`);
-    const data = await response.json();
-    expect(data).toBeDefined();
-  });
-
-  it('should handle error responses', async () => {
-    const response = await fetch(\`\${baseUrl}/api/{{camelName}}/nonexistent\`, {
-      method: 'GET',
-    });
-    expect(response.status).toBeGreaterThanOrEqual(400);
-  });
-});
-`,
-    visual: `import { test, expect } from '@playwright/test';
-
-test.describe('{{name}} visual regression', () => {
-  test.beforeEach(async ({ page }) => {
-    await page.goto('/');
-  });
-
-  test('should match baseline screenshot - desktop', async ({ page }) => {
-    await expect(page).toHaveScreenshot('{{name}}-desktop.png');
-  });
-
-  test('should match baseline screenshot - mobile', async ({ page }) => {
-    await page.setViewportSize({ width: 375, height: 667 });
-    await expect(page).toHaveScreenshot('{{name}}-mobile.png');
-  });
-});
-`,
-    performance: `import { test, expect } from '@playwright/test';
-
-test.describe('{{name}} performance', () => {
-  test('should meet Core Web Vitals thresholds', async ({ page }) => {
-    await page.goto('/');
-
-    // \u6D4B\u91CF\u9875\u9762\u52A0\u8F7D\u6027\u80FD
-    const performanceMetrics = await page.evaluate(() => {
-      const [entry] = performance.getEntriesByType('navigation') as PerformanceNavigationTiming[];
-      return {
-        domContentLoaded: entry?.domContentLoadedEventEnd - entry?.domContentLoadedEventStart ?? 0,
-        loadComplete: entry?.loadEventEnd - entry?.loadEventStart ?? 0,
-        domInteractive: entry?.domInteractive ?? 0,
-      };
-    });
-
-    // DOM \u5185\u5BB9\u52A0\u8F7D\u5E94\u5728 2s \u5185
-    expect(performanceMetrics.domInteractive).toBeLessThan(2000);
+    // expect(wrapper.vm.{{this}}).toBeDefined();
   });
 
-  test('should not have memory leaks', async ({ page }) => {
-    await page.goto('/');
-
-    const metrics = await page.metrics();
-    expect(metrics.JSHeapUsedSize).toBeLessThan(50 * 1024 * 1024); // 50MB
+  {{/each}}
+  {{/if}}
+  {{#if methods}}
+  {{#each methods}}
+  it('calls {{this}} method', async () => {
+    const wrapper = mountComponent({{#if ../requiredProps}}{
+    {{#each ../requiredProps}}
+      {{name}}: {{propTestValue this}},
+    {{/each}}
+    }{{/if}});
+    // TODO: test method '{{this}}'
+    // await wrapper.vm.{{this}}();
+    // expect(someCondition).toBe(true);
   });
-});
-`
-  };
-  return templates[type];
-}
-function toCamelCase(str) {
-  return str.replace(/[-_\s]+(.)?/g, (_, c) => c ? c.toUpperCase() : "").replace(/^[A-Z]/, (c) => c.toLowerCase());
-}
-function toPascalCase(str) {
-  const camel = toCamelCase(str);
-  return camel.charAt(0).toUpperCase() + camel.slice(1);
-}
-
-// src/services/global-config.ts
-import fs6 from "fs";
-import path6 from "path";
-import os from "os";
-var QAT_DIR = path6.join(os.homedir(), ".qat");
-var AI_CONFIG_PATH = path6.join(QAT_DIR, "ai.json");
-function loadGlobalAIConfig() {
-  if (!fs6.existsSync(AI_CONFIG_PATH)) {
-    return null;
-  }
-  try {
-    const content = fs6.readFileSync(AI_CONFIG_PATH, "utf-8");
-    const config = JSON.parse(content);
-    if (!config.baseUrl || !config.model) {
-      return null;
-    }
-    return config;
-  } catch {
-    return null;
-  }
-}
-function saveGlobalAIConfig(config) {
-  if (!fs6.existsSync(QAT_DIR)) {
-    fs6.mkdirSync(QAT_DIR, { recursive: true });
-  }
-  fs6.writeFileSync(AI_CONFIG_PATH, JSON.stringify(config, null, 2), "utf-8");
-}
-function toAIConfig(globalConfig) {
-  return {
-    provider: globalConfig.provider || "openai",
-    apiKey: globalConfig.apiKey || void 0,
-    baseUrl: globalConfig.baseUrl,
-    model: globalConfig.model
-  };
-}
-function maskApiKey(apiKey) {
-  if (!apiKey) return "(\u672A\u8BBE\u7F6E)";
-  if (apiKey.length <= 8) return "****";
-  return apiKey.slice(0, 4) + "****" + apiKey.slice(-4);
-}
-function getAIConfigPath() {
-  return AI_CONFIG_PATH;
-}
 
-// src/commands/init.ts
-var TEST_TYPE_DIR = {
-  unit: "tests/unit",
-  component: "tests/component",
-  e2e: "tests/e2e",
-  api: "tests/api",
-  visual: "tests/visual",
-  performance: "tests/e2e"
-};
-function inferTestType(filePath) {
-  const normalized = filePath.replace(/\\/g, "/").toLowerCase();
-  if (/\/api\//.test(normalized) || /api\.(ts|js)$/.test(normalized)) {
-    return "api";
-  }
-  if (normalized.endsWith(".vue")) {
-    return "component";
-  }
-  if (/\/composables?\//.test(normalized) || /\/hooks?\//.test(normalized) || /^use[A-Z]/.test(path7.basename(filePath))) {
-    return "unit";
-  }
-  if (/\/(utils|helpers|services|lib)\//.test(normalized)) {
-    return "unit";
-  }
-  return "unit";
-}
-function registerInitCommand(program2) {
-  program2.command("init").description("\u521D\u59CB\u5316\u6D4B\u8BD5\u9879\u76EE - \u68C0\u6D4B\u9879\u76EE\u3001\u751F\u6210\u914D\u7F6E\u3001\u81EA\u52A8\u521B\u5EFA\u6D4B\u8BD5\u7528\u4F8B").option("-f, --force", "\u5F3A\u5236\u8986\u76D6\u5DF2\u6709\u914D\u7F6E\u6587\u4EF6").action(async (options) => {
-    try {
-      await executeInit(options);
-    } catch (error) {
-      console.error(chalk3.red(`
-  \u2717 ${error instanceof Error ? error.message : String(error)}
-`));
-      process.exit(1);
-    }
+  {{/each}}
+  {{/if}}
+  {{else}}
+  it('renders correctly', () => {
+    const wrapper = mount({{pascalName}}{{#if mountOptions}}, {{mountOptions}}{{/if}});
+    expect(wrapper.exists()).toBe(true);
   });
-}
-async function executeInit(options) {
-  const spinner = ora2("\u6B63\u5728\u68C0\u6D4B\u9879\u76EE\u7ED3\u6784...").start();
-  const projectInfo = detectProject();
-  spinner.stop();
-  displayProjectInfo(projectInfo);
-  if (!projectInfo.isVue) {
-    const { proceed } = await inquirer.prompt([
-      {
-        type: "confirm",
-        name: "proceed",
-        message: "\u672A\u68C0\u6D4B\u5230 Vue \u9879\u76EE\uFF0C\u662F\u5426\u7EE7\u7EED\u521D\u59CB\u5316\uFF1F",
-        default: false
-      }
-    ]);
-    if (!proceed) {
-      console.log(chalk3.gray("\n  \u5DF2\u53D6\u6D88\u521D\u59CB\u5316\n"));
-      return;
-    }
-  }
-  let globalAI = loadGlobalAIConfig();
-  if (!globalAI) {
-    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(chalk3.gray(`  \u914D\u7F6E\u5DF2\u4FDD\u5B58\u81F3 ${getAIConfigPath()}
-`));
-  } else {
-    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);
-  if (aiConfig.apiKey || aiConfig.baseUrl) {
-    const testSpinner = ora2(`\u6B63\u5728\u6D4B\u8BD5 AI \u8FDE\u901A\u6027 (${globalAI.model})...`).start();
-    try {
-      const result = await testAIConnection(aiConfig);
-      if (result.ok) {
-        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(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 = path7.join(process.cwd(), "qat.config.js");
-  const existingTsPath = path7.join(process.cwd(), "qat.config.ts");
-  const configExists = fs7.existsSync(existingConfigPath) || fs7.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(chalk3.gray("  \u4FDD\u7559\u73B0\u6709\u914D\u7F6E\u6587\u4EF6\uFF0C\u7EE7\u7EED\u540E\u7EED\u6B65\u9AA4..."));
-      configPath = existingConfigPath;
-    } else {
-      const fileSpinner = ora2("\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;
-      }
-    }
-  } else {
-    const fileSpinner = ora2("\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;
-    }
-  }
-  const dirSpinner = ora2("\u6B63\u5728\u521B\u5EFA\u6D4B\u8BD5\u76EE\u5F55...").start();
-  const createdDirs = createTestDirectories(config);
-  dirSpinner.succeed("\u6D4B\u8BD5\u76EE\u5F55\u5DF2\u521B\u5EFA");
-  if (config.mock?.enabled !== false) {
-    const mockDir = config.mock?.routesDir || DEFAULT_CONFIG.mock.routesDir;
-    initMockRoutesDir(mockDir);
-    const srcDir = config.project?.srcDir || "src";
-    const apiCalls = scanAPICalls(srcDir);
-    if (apiCalls.length > 0) {
-      const mockRoutes = generateMockRoutesFromAPICalls(apiCalls);
-      const mockFilePath = path7.join(process.cwd(), mockDir, "auto-generated.json");
-      if (!fs7.existsSync(mockFilePath)) {
-        fs7.writeFileSync(mockFilePath, JSON.stringify(mockRoutes, null, 2), "utf-8");
-        console.log(chalk3.green(`    \u81EA\u52A8\u53D1\u73B0 ${apiCalls.length} \u4E2A API \u63A5\u53E3\uFF0C\u5DF2\u751F\u6210 Mock \u8DEF\u7531`));
-      }
-    } else {
-      console.log(chalk3.gray("    \u672A\u53D1\u73B0 API \u8C03\u7528\uFF0C\u5DF2\u751F\u6210\u793A\u4F8B Mock \u8DEF\u7531"));
-    }
-  }
-  const useAI = isAIAvailable(aiConfig);
-  const generatedFiles = await autoGenerateTests(config, projectInfo, aiConfig, useAI);
-  displayResult(configPath, createdDirs, generatedFiles, projectInfo);
-}
-async function promptAIConfig() {
-  const answers = await inquirer.prompt([
-    {
-      type: "input",
-      name: "apiKey",
-      message: "API Key (Ollama \u672C\u5730\u53EF\u7559\u7A7A):",
-      default: ""
-    },
-    {
-      type: "input",
-      name: "baseUrl",
-      message: "API Base URL:",
-      default: "https://api.deepseek.com/v1",
-      validate: (input) => {
-        if (!input.trim()) return "Base URL \u4E0D\u80FD\u4E3A\u7A7A";
-        if (!input.trim().startsWith("http")) return "URL \u5FC5\u987B\u4EE5 http(s):// \u5F00\u5934";
-        return true;
-      }
-    },
-    {
-      type: "input",
-      name: "model",
-      message: "\u6A21\u578B\u540D\u79F0:",
-      default: "deepseek-chat",
-      validate: (input) => {
-        if (!input.trim()) return "\u6A21\u578B\u540D\u79F0\u4E0D\u80FD\u4E3A\u7A7A";
-        return true;
-      }
-    }
-  ]);
-  return {
-    provider: "openai",
-    apiKey: answers.apiKey?.trim() || "",
-    baseUrl: answers.baseUrl?.trim() || "https://api.deepseek.com/v1",
-    model: answers.model?.trim() || "deepseek-chat"
-  };
-}
-function buildProjectConfig(projectInfo) {
-  return {
-    project: {
-      framework: projectInfo.framework,
-      uiLibrary: projectInfo.uiLibrary !== "none" ? projectInfo.uiLibrary : void 0,
-      monorepo: projectInfo.monorepo !== "none" ? projectInfo.monorepo : void 0,
-      vite: projectInfo.isVite,
-      srcDir: projectInfo.srcDir,
-      appDir: projectInfo.appDirs.length > 0 ? projectInfo.appDirs[0] : void 0
-    },
-    vitest: {
-      enabled: true,
-      coverage: true,
-      globals: true,
-      environment: "happy-dom"
-    },
-    playwright: {
-      enabled: true,
-      browsers: ["chromium"],
-      baseURL: "http://localhost:5173",
-      screenshot: "only-on-failure"
-    },
-    visual: {
-      enabled: true,
-      threshold: 0.1,
-      baselineDir: "tests/visual/baseline",
-      diffDir: "tests/visual/diff"
-    },
-    lighthouse: {
-      enabled: true,
-      urls: ["http://localhost:5173"],
-      runs: 3,
-      thresholds: {
-        performance: 80,
-        accessibility: 90
-      }
-    },
-    mock: {
-      enabled: true,
-      port: 3456,
-      routesDir: "tests/mock/routes"
-    }
+
+  it('renders default slot content', () => {
+    const wrapper = mount({{pascalName}}, {
+      {{#if mountOptions}}
+      ...{{mountOptions}},
+      {{/if}}
+      slots: {
+        default: 'Test Content',
+      },
+    });
+    expect(wrapper.text()).toContain('Test Content');
+  });
+
+  it('handles user interaction', async () => {
+    const wrapper = mount({{pascalName}}{{#if mountOptions}}, {{mountOptions}}{{/if}});
+    // TODO: add interaction test
+  });
+  {{/if}}
+});
+`,
+    e2e: `import { test, expect } from '@playwright/test';
+
+test.describe('{{name}}', () => {
+  test.beforeEach(async ({ page }) => {
+    await page.goto('/');
+  });
+
+  test('should display page correctly', async ({ page }) => {
+    // TODO: \u6DFB\u52A0E2E\u6D4B\u8BD5\u65AD\u8A00
+    await expect(page).toHaveTitle(/.*/);
+  });
+
+  test('should navigate between pages', async ({ page }) => {
+    // TODO: \u6DFB\u52A0\u5BFC\u822A\u6D4B\u8BD5
+  });
+
+  test('should be responsive', async ({ page }) => {
+    await page.setViewportSize({ width: 375, height: 667 });
+    // TODO: \u6DFB\u52A0\u79FB\u52A8\u7AEF\u65AD\u8A00
+  });
+});
+`,
+    api: `import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+{{#if imports}}
+{{#each imports}}
+import {{this}};
+{{/each}}
+{{/if}}
+
+describe('{{name}} API', () => {
+  const baseUrl = process.env.API_BASE_URL || 'http://localhost:3456';
+
+  it('should return 200 for GET request', async () => {
+    const response = await fetch(\`\${baseUrl}/api/{{camelName}}\`);
+    expect(response.status).toBe(200);
+  });
+
+  it('should return expected response format', async () => {
+    const response = await fetch(\`\${baseUrl}/api/{{camelName}}\`);
+    const data = await response.json();
+    expect(data).toBeDefined();
+  });
+
+  it('should handle error responses', async () => {
+    const response = await fetch(\`\${baseUrl}/api/{{camelName}}/nonexistent\`, {
+      method: 'GET',
+    });
+    expect(response.status).toBeGreaterThanOrEqual(400);
+  });
+});
+`,
+    visual: `import { test, expect } from '@playwright/test';
+
+test.describe('{{name}} visual regression', () => {
+  test.beforeEach(async ({ page }) => {
+    await page.goto('/');
+  });
+
+  test('should match baseline screenshot - desktop', async ({ page }) => {
+    await expect(page).toHaveScreenshot('{{name}}-desktop.png');
+  });
+
+  test('should match baseline screenshot - mobile', async ({ page }) => {
+    await page.setViewportSize({ width: 375, height: 667 });
+    await expect(page).toHaveScreenshot('{{name}}-mobile.png');
+  });
+});
+`,
+    performance: `import { test, expect } from '@playwright/test';
+
+test.describe('{{name}} performance', () => {
+  test('should meet Core Web Vitals thresholds', async ({ page }) => {
+    await page.goto('/');
+
+    // \u6D4B\u91CF\u9875\u9762\u52A0\u8F7D\u6027\u80FD
+    const performanceMetrics = await page.evaluate(() => {
+      const [entry] = performance.getEntriesByType('navigation') as PerformanceNavigationTiming[];
+      return {
+        domContentLoaded: entry?.domContentLoadedEventEnd - entry?.domContentLoadedEventStart ?? 0,
+        loadComplete: entry?.loadEventEnd - entry?.loadEventStart ?? 0,
+        domInteractive: entry?.domInteractive ?? 0,
+      };
+    });
+
+    // DOM \u5185\u5BB9\u52A0\u8F7D\u5E94\u5728 2s \u5185
+    expect(performanceMetrics.domInteractive).toBeLessThan(2000);
+  });
+
+  test('should not have memory leaks', async ({ page }) => {
+    await page.goto('/');
+
+    const metrics = await page.metrics();
+    expect(metrics.JSHeapUsedSize).toBeLessThan(50 * 1024 * 1024); // 50MB
+  });
+});
+`
   };
+  return templates[type];
 }
-async function autoGenerateTests(config, projectInfo, aiConfig, useAI) {
-  const srcDir = config.project?.srcDir || "src";
-  const components = discoverVueComponents(process.cwd(), srcDir);
-  const utilities = discoverUtilityFiles(process.cwd(), srcDir);
-  if (components.length === 0 && utilities.length === 0) {
-    console.log(chalk3.yellow("\n  \u672A\u53D1\u73B0\u53EF\u6D4B\u8BD5\u7684\u6E90\u7801\u6587\u4EF6\uFF0C\u8DF3\u8FC7\u6D4B\u8BD5\u7528\u4F8B\u751F\u6210\u3002"));
-    return [];
-  }
-  const allTargets = [];
-  for (const compPath of components.slice(0, 30)) {
-    allTargets.push({ filePath: compPath, testType: inferTestType(compPath) });
-  }
-  for (const utilPath of utilities.slice(0, 30)) {
-    allTargets.push({ filePath: utilPath, testType: inferTestType(utilPath) });
-  }
-  const selectedTargets = await selectTargetFiles(allTargets);
-  if (selectedTargets.length === 0) {
-    console.log(chalk3.gray("\n  \u672A\u9009\u62E9\u4EFB\u4F55\u6587\u4EF6\uFF0C\u8DF3\u8FC7\u6D4B\u8BD5\u7528\u4F8B\u751F\u6210\u3002"));
-    return [];
-  }
-  const total = selectedTargets.length;
-  const genSpinner = ora2(`\u6B63\u5728\u751F\u6210\u6D4B\u8BD5\u7528\u4F8B [0/${total}] ...`).start();
-  const generatedFiles = [];
-  const typeCount = {};
-  const reviewReport = [];
-  let current = 0;
-  let failed = 0;
-  for (const { filePath, testType } of selectedTargets) {
-    current++;
-    const fileLabel = path7.basename(filePath);
-    genSpinner.text = `\u6B63\u5728\u751F\u6210\u6D4B\u8BD5\u7528\u4F8B [${current}/${total}] ${chalk3.cyan(fileLabel)} ...`;
-    try {
-      const result = await generateTestForTarget(
-        testType,
-        filePath,
-        config,
-        projectInfo,
-        aiConfig,
-        useAI
-      );
-      if (result) {
-        generatedFiles.push(result.filePath);
-        typeCount[testType] = (typeCount[testType] || 0) + 1;
-        if (result.reviewEntry) {
-          reviewReport.push(result.reviewEntry);
-        }
-      }
-    } catch {
-      failed++;
-    }
-  }
-  if (generatedFiles.length > 0) {
-    const summary = Object.entries(typeCount).map(([type, count]) => `${count} ${type}`).join(", ");
-    const approvedCount = reviewReport.filter((r) => r.approved).length;
-    let msg = `\u5DF2\u751F\u6210 ${generatedFiles.length}/${total} \u4E2A\u6D4B\u8BD5\u7528\u4F8B (${summary}) \u2014 AI \u5BA1\u8BA1 ${approvedCount}/${reviewReport.length} \u901A\u8FC7`;
-    if (failed > 0) msg += chalk3.yellow(` ${failed} \u4E2A\u5931\u8D25`);
-    genSpinner.succeed(msg);
-  } else {
-    genSpinner.warn(`\u672A\u751F\u6210\u6D4B\u8BD5\u7528\u4F8B (${failed} \u4E2A\u5931\u8D25)`);
-  }
-  if (reviewReport.length > 0) {
-    printReviewReport(reviewReport);
-  }
-  return generatedFiles;
+function toCamelCase(str) {
+  return str.replace(/[-_\s]+(.)?/g, (_, c) => c ? c.toUpperCase() : "").replace(/^[A-Z]/, (c) => c.toLowerCase());
 }
-async function selectTargetFiles(allTargets) {
-  const testTypeLabels = {
-    unit: chalk3.blue("[unit]"),
-    component: chalk3.magenta("[comp]"),
-    e2e: chalk3.green("[e2e]"),
-    api: chalk3.yellow("[api]"),
-    visual: chalk3.cyan("[visual]"),
-    performance: chalk3.gray("[perf]")
-  };
-  const choices = allTargets.map(({ filePath, testType }) => ({
-    name: `${testTypeLabels[testType]} ${filePath}`,
-    value: filePath,
-    short: filePath
-  }));
-  choices.push({
-    name: chalk3.gray("\u270E \u624B\u52A8\u8F93\u5165\u6587\u4EF6/\u76EE\u5F55\u8DEF\u5F84"),
-    value: "__manual__",
-    short: "\u624B\u52A8\u8F93\u5165"
-  });
-  const { selected } = await inquirer.prompt([
-    {
-      type: "checkbox",
-      name: "selected",
-      message: "\u9009\u62E9\u8981\u751F\u6210\u6D4B\u8BD5\u7528\u4F8B\u7684\u6587\u4EF6 (\u7A7A\u683C\u9009\u62E9/\u53D6\u6D88\uFF0C\u56DE\u8F66\u786E\u8BA4):",
-      choices,
-      pageSize: 15
-    }
-  ]);
-  const manualPaths = [];
-  if (selected.includes("__manual__")) {
-    const { manualInput } = await inquirer.prompt([
-      {
-        type: "input",
-        name: "manualInput",
-        message: "\u8F93\u5165\u6587\u4EF6\u6216\u76EE\u5F55\u8DEF\u5F84\uFF08\u591A\u4E2A\u7528\u9017\u53F7\u5206\u9694\uFF09:",
-        default: "",
-        filter: (input) => input.split(",").map((s) => s.trim()).filter(Boolean)
-      }
-    ]);
-    for (const p of manualInput) {
-      const resolved = path7.resolve(process.cwd(), p);
-      if (fs7.existsSync(resolved)) {
-        const stat = fs7.statSync(resolved);
-        if (stat.isDirectory()) {
-          const dirFiles = walkDirForTestableFiles(resolved);
-          manualPaths.push(...dirFiles);
-        } else if (stat.isFile()) {
-          manualPaths.push(p.replace(/\\/g, "/"));
-        }
-      } else {
-        console.log(chalk3.yellow(`    \u8DEF\u5F84\u4E0D\u5B58\u5728\uFF0C\u5DF2\u8DF3\u8FC7: ${p}`));
-      }
-    }
-  }
-  const selectedPaths = selected.filter((s) => s !== "__manual__");
-  const selectedSet = new Set(selectedPaths);
-  const result = allTargets.filter((t) => selectedSet.has(t.filePath));
-  const existingPaths = new Set(result.map((t) => t.filePath));
-  for (const mp of manualPaths) {
-    if (!existingPaths.has(mp)) {
-      result.push({ filePath: mp, testType: inferTestType(mp) });
-    }
-  }
-  return result;
+function toPascalCase(str) {
+  const camel = toCamelCase(str);
+  return camel.charAt(0).toUpperCase() + camel.slice(1);
 }
-function walkDirForTestableFiles(dir) {
-  const files = [];
-  try {
-    const entries = fs7.readdirSync(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      if (entry.name === "node_modules" || entry.name === "dist" || entry.name.startsWith(".")) continue;
-      const fullPath = path7.join(dir, entry.name);
-      if (entry.isDirectory()) {
-        files.push(...walkDirForTestableFiles(fullPath));
-      } else if (entry.isFile() && /\.(vue|ts|js)$/.test(entry.name)) {
-        files.push(path7.relative(process.cwd(), fullPath).replace(/\\/g, "/"));
-      }
-    }
-  } catch {
+
+// src/services/test-reviewer.ts
+import chalk3 from "chalk";
+import ora2 from "ora";
+var MAX_RETRIES = 3;
+var REVIEW_THRESHOLD = 0.6;
+async function generateWithReview(params) {
+  const { testType, targetPath, sourceCode, analysis, aiConfig, framework, onAttempt } = params;
+  const generatorProvider = createAIProvider(aiConfig);
+  const reviewerProvider = createAIProvider(aiConfig);
+  if (!generatorProvider.capabilities.generateTest) {
+    throw new Error("\u5F53\u524D AI Provider \u4E0D\u652F\u6301\u6D4B\u8BD5\u751F\u6210");
   }
-  return files;
-}
-async function generateTestForTarget(testType, targetPath, config, projectInfo, aiConfig, useAI) {
-  const basename = path7.basename(targetPath, path7.extname(targetPath));
-  const name = basename.replace(/[^a-zA-Z0-9]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "") || `${testType}-test`;
-  const outputDir = TEST_TYPE_DIR[testType];
-  const fileName = `${name}.${testType === "e2e" ? "spec" : "test"}.ts`;
-  const filePath = path7.join(process.cwd(), outputDir, fileName);
-  if (fs7.existsSync(filePath)) return null;
-  let content;
-  let reviewEntry;
-  if (useAI) {
-    const result = await generateWithAIAndReview(testType, name, targetPath, aiConfig, projectInfo);
-    content = result.code;
-    reviewEntry = result.reviewEntry;
-  } else {
-    const analysis = analyzeFile(targetPath);
-    content = renderTemplate(testType, {
-      name,
+  let currentCode = "";
+  let currentDescription = "";
+  let currentConfidence = 0;
+  let lastReview = null;
+  let approved = false;
+  let attempts = 0;
+  for (let i = 0; i < MAX_RETRIES; i++) {
+    attempts = i + 1;
+    onAttempt?.(attempts, MAX_RETRIES);
+    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}
+\u5177\u4F53\u95EE\u9898:
+${lastReview.issues.map((issue) => `- ${issue}`).join("\n")}
+\u6539\u8FDB\u5EFA\u8BAE:
+${lastReview.suggestions.map((s) => `- ${s}`).join("\n")}
+
+\u8BF7\u9488\u5BF9\u4EE5\u4E0A\u95EE\u9898\u91CD\u65B0\u751F\u6210\u66F4\u8D34\u5207\u3001\u66F4\u51C6\u786E\u7684\u6D4B\u8BD5\u7528\u4F8B\u3002`;
+    const generateResponse = await generatorProvider.generateTest({
+      type: testType,
       target: targetPath,
-      framework: projectInfo.framework,
-      vueVersion: projectInfo.vueVersion,
-      typescript: projectInfo.typescript,
-      uiLibrary: projectInfo.uiLibrary,
-      extraImports: projectInfo.componentTestSetup?.extraImports,
-      globalPlugins: projectInfo.componentTestSetup?.globalPlugins,
-      globalStubs: projectInfo.componentTestSetup?.globalStubs,
-      mountOptions: projectInfo.componentTestSetup?.mountOptions,
-      exports: analysis.exports.map((e) => ({
-        name: e.name,
-        kind: e.kind,
-        params: e.params,
-        isAsync: e.isAsync,
-        returnType: e.returnType
-      })),
-      props: analysis.vueAnalysis?.props.map((p) => ({
-        name: p.name,
-        type: p.type,
-        required: p.required,
-        defaultValue: p.defaultValue
-      })),
-      emits: analysis.vueAnalysis?.emits.map((e) => ({
-        name: e.name,
-        params: e.params
-      })),
-      methods: analysis.vueAnalysis?.methods,
-      computed: analysis.vueAnalysis?.computed
-    });
-  }
-  if (!fs7.existsSync(path7.join(process.cwd(), outputDir))) {
-    fs7.mkdirSync(path7.join(process.cwd(), outputDir), { recursive: true });
-  }
-  fs7.writeFileSync(filePath, content, "utf-8");
-  return {
-    filePath: path7.relative(process.cwd(), filePath).replace(/\\/g, "/"),
-    reviewEntry
-  };
-}
-async function generateWithAIAndReview(type, name, target, aiConfig, projectInfo) {
-  const fullPath = path7.resolve(process.cwd(), target);
-  let sourceCode = "";
-  if (fs7.existsSync(fullPath)) {
-    sourceCode = fs7.readFileSync(fullPath, "utf-8");
-  }
-  const analysis = analyzeFile(target);
-  const analysisSummary = analysis.exports.length > 0 || analysis.vueAnalysis ? {
-    exports: analysis.exports.map((e) => ({
-      name: e.name,
-      kind: e.kind,
-      params: e.params,
-      isAsync: e.isAsync
-    })),
-    props: analysis.vueAnalysis?.props.map((p) => ({
-      name: p.name,
-      type: p.type,
-      required: p.required
-    })),
-    emits: analysis.vueAnalysis?.emits.map((e) => ({
-      name: e.name,
-      params: e.params
-    })),
-    methods: analysis.vueAnalysis?.methods,
-    computed: analysis.vueAnalysis?.computed
-  } : void 0;
-  const reviewResult = await generateWithReview({
-    testType: type,
-    targetPath: target,
-    sourceCode,
-    analysis: analysisSummary,
-    aiConfig,
-    framework: "vue"
-  });
-  const headerComment = [
-    `// AI Generated Test - ${name}`,
-    `// \u5BA1\u8BA1: ${reviewResult.approved ? "\u901A\u8FC7" : "\u672A\u901A\u8FC7"} (${(reviewResult.reviewScore * 100).toFixed(0)}%) \u2014 ${reviewResult.attempts}\u6B21\u5C1D\u8BD5`,
-    reviewResult.reviewFeedback ? `// \u5BA1\u8BA1\u610F\u89C1: ${reviewResult.reviewFeedback}` : "",
-    ""
-  ].filter(Boolean).join("\n");
-  const code = `${headerComment}
-${reviewResult.code}`;
-  const reviewEntry = {
-    target,
-    testType: type,
-    approved: reviewResult.approved,
-    attempts: reviewResult.attempts,
-    score: reviewResult.reviewScore,
-    feedback: reviewResult.reviewFeedback,
-    issues: reviewResult.approved ? [] : reviewResult.reviewIssues
+      context: i === 0 ? sourceCode : `${sourceCode}
+
+--- \u5BA1\u8BA1\u53CD\u9988 ---
+${generationPrompt}`,
+      framework: framework || void 0,
+      analysis
+    });
+    currentCode = generateResponse.code;
+    currentDescription = generateResponse.description;
+    currentConfidence = generateResponse.confidence;
+    const reviewRequest = {
+      target: targetPath,
+      sourceCode,
+      analysis,
+      testCode: currentCode,
+      testType,
+      generationDescription: currentDescription
+    };
+    lastReview = await reviewerProvider.reviewTest(reviewRequest);
+    approved = lastReview.approved && lastReview.score >= REVIEW_THRESHOLD;
+    if (approved) {
+      break;
+    }
+  }
+  return {
+    code: currentCode,
+    description: currentDescription,
+    confidence: currentConfidence,
+    approved,
+    attempts,
+    reviewScore: lastReview?.score ?? 0,
+    reviewFeedback: lastReview?.feedback ?? "",
+    reviewIssues: lastReview?.issues ?? [],
+    reviewSuggestions: lastReview?.suggestions ?? []
   };
-  return { code, reviewEntry };
 }
-function displayProjectInfo(info) {
-  console.log(chalk3.cyan("\n  \u9879\u76EE\u68C0\u6D4B\u7ED3\u679C:"));
+function printReviewReport(report) {
+  if (report.length === 0) return;
+  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"));
-  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],
-    ["Vue \u9879\u76EE", info.isVue ? `\u662F (v${info.vueVersion})` : "\u5426"],
-    ["UI \u7EC4\u4EF6\u5E93", info.uiLibrary !== "none" ? info.uiLibrary : "\u672A\u68C0\u6D4B\u5230"],
-    ["Vite \u6784\u5EFA", info.isVite ? "\u662F" : "\u5426"],
-    ["TypeScript", info.typescript ? "\u662F" : "\u5426"],
-    ["\u5305\u7BA1\u7406\u5668", info.packageManager],
-    ["Monorepo", info.monorepo !== "none" ? info.monorepo : "\u5426"],
-    ["\u6E90\u7801\u76EE\u5F55", info.srcDir]
-  ];
-  if (info.appDirs.length > 0) {
-    items.push(["\u5B50\u9879\u76EE", info.appDirs.join(", ")]);
-  }
-  if (info.testFrameworks.length > 0) {
-    items.push(["\u5DF2\u6709\u6D4B\u8BD5\u6846\u67B6", info.testFrameworks.join(", ")]);
-  }
-  if (info.componentDirs.length > 0) {
-    items.push(["\u7EC4\u4EF6\u76EE\u5F55", info.componentDirs.join(", ")]);
-  }
-  for (const [label, value] of items) {
-    const displayValue = value === true ? chalk3.green("\u2713") : value === false ? chalk3.red("\u2717") : String(value);
-    console.log(`  ${chalk3.white(label.padEnd(12))} ${displayValue}`);
+  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();
-}
-function createTestDirectories(config) {
-  const dirs = [];
-  const dirMap = {
-    "tests": true,
-    "tests/unit": config.vitest?.enabled !== false,
-    "tests/component": config.vitest?.enabled !== false,
-    "tests/e2e": config.playwright?.enabled !== false,
-    "tests/api": config.mock?.enabled !== false,
-    "tests/visual": config.visual?.enabled !== false,
-    "tests/visual/baseline": config.visual?.enabled !== false,
-    "tests/visual/diff": config.visual?.enabled !== false,
-    "tests/mock": config.mock?.enabled !== false,
-    "tests/mock/routes": config.mock?.enabled !== false
-  };
-  for (const [dir, shouldCreate] of Object.entries(dirMap)) {
-    if (shouldCreate) {
-      const fullPath = path7.join(process.cwd(), dir);
-      if (!fs7.existsSync(fullPath)) {
-        fs7.mkdirSync(fullPath, { recursive: true });
-        dirs.push(dir);
+  for (const entry of failed) {
+    console.log(`  ${chalk3.red("\u2717")} ${chalk3.gray(entry.target)} ${chalk3.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}`));
       }
     }
-  }
-  return dirs;
-}
-function displayResult(configPath, createdDirs, generatedFiles, projectInfo) {
-  const relativeConfig = path7.relative(process.cwd(), configPath);
-  console.log(chalk3.green("\n  \u2713 \u9879\u76EE\u521D\u59CB\u5316\u5B8C\u6210!\n"));
-  console.log(chalk3.white("  \u5DF2\u751F\u6210\u914D\u7F6E:"));
-  console.log(chalk3.gray(`    ${relativeConfig}`));
-  console.log();
-  if (generatedFiles.length > 0) {
-    console.log(chalk3.white("  \u5DF2\u751F\u6210\u6D4B\u8BD5\u7528\u4F8B:"));
-    for (const file of generatedFiles) {
-      const typeLabel = file.includes("/unit/") ? chalk3.blue("[unit]") : file.includes("/component/") ? chalk3.magenta("[comp]") : file.includes("/api/") ? chalk3.yellow("[api]") : chalk3.gray("[other]");
-      console.log(`    ${typeLabel} ${chalk3.gray(file)}`);
+    if (entry.feedback) {
+      console.log(chalk3.gray(`      \u53CD\u9988: ${entry.feedback}`));
     }
-    console.log();
-  }
-  console.log(chalk3.cyan("  \u4E0B\u4E00\u6B65:"));
-  if (generatedFiles.length > 0) {
-    console.log(chalk3.gray("    1. qat run       \u6267\u884C\u6D4B\u8BD5"));
-    console.log(chalk3.gray("    2. qat create    \u6DFB\u52A0\u66F4\u591A\u6D4B\u8BD5\u7528\u4F8B"));
-    console.log(chalk3.gray("    3. qat status    \u67E5\u770B AI \u6A21\u578B\u72B6\u6001"));
-  } else {
-    console.log(chalk3.gray("    1. qat change    \u914D\u7F6E AI \u6A21\u578B"));
-    console.log(chalk3.gray("    2. qat create    \u521B\u5EFA\u6D4B\u8BD5\u7528\u4F8B"));
-  }
-  if (projectInfo.testFrameworks.length === 0) {
-    console.log();
-    console.log(chalk3.yellow("  \u26A0 \u672A\u68C0\u6D4B\u5230\u6D4B\u8BD5\u6846\u67B6\u4F9D\u8D56\uFF0C\u5EFA\u8BAE\u8FD0\u884C:"));
-    console.log(chalk3.gray(`    qat setup`));
   }
   console.log();
 }
 
 // src/commands/create.ts
-import chalk4 from "chalk";
-import inquirer2 from "inquirer";
-import ora3 from "ora";
-import fs8 from "fs";
-import path8 from "path";
 var TEST_TYPE_LABELS = {
   unit: "\u5355\u5143\u6D4B\u8BD5",
   component: "\u7EC4\u4EF6\u6D4B\u8BD5",
@@ -3169,18 +2894,29 @@ function displayCreateResult(createdFiles, skippedCount, usedAI) {
 import chalk5 from "chalk";
 import inquirer3 from "inquirer";
 import ora4 from "ora";
-import fs9 from "fs";
-import path11 from "path";
+import fs11 from "fs";
+import path12 from "path";
 
 // src/runners/vitest-runner.ts
 import { execFile } from "child_process";
 import path9 from "path";
+import fs9 from "fs";
+import os2 from "os";
+var isVerbose = () => process.env.QAT_VERBOSE === "true";
+function debug(label, ...args) {
+  if (isVerbose()) {
+    console.log(`\x1B[90m  [debug:${label}]\x1B[0m`, ...args);
+  }
+}
 async function runVitest(options) {
   const startTime = Date.now();
   const args = buildVitestArgs(options);
+  debug("vitest", "\u547D\u4EE4\u53C2\u6570:", args.join(" "));
   try {
     const result = await execVitest(args);
     const endTime = Date.now();
+    debug("vitest", `\u89E3\u6790\u7ED3\u679C: ${result.suites.length} \u4E2A\u5957\u4EF6, ${result.suites.reduce((s, su) => s + su.tests.length, 0)} \u4E2A\u7528\u4F8B`);
+    debug("vitest", "\u89E3\u6790\u65B9\u5F0F:", result.parseMethod);
     return {
       type: options.type,
       status: result.success ? "passed" : "failed",
@@ -3245,83 +2981,228 @@ function buildVitestArgs(options) {
   return args;
 }
 async function execVitest(args) {
+  const tmpFile = path9.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";
-    const child = execFile(npx, args, {
+    debug("vitest", "\u6267\u884C\u547D\u4EE4:", npx, argsWithOutput.join(" "));
+    const child = execFile(npx, argsWithOutput, {
       cwd: process.cwd(),
-      env: { ...process.env, FORCE_COLOR: "0" },
+      env: { ...process.env, FORCE_COLOR: "0", NO_COLOR: "1" },
       maxBuffer: 50 * 1024 * 1024,
-      // 50MB
       shell: true
     }, (error, stdout, stderr) => {
-      const output = stdout || stderr || "";
+      const rawOutput = stdout || stderr || "";
+      const exitCode = error && "code" in error ? error.code : 0;
+      debug("vitest", `\u9000\u51FA\u7801: ${exitCode}`);
+      debug("vitest", `stdout \u957F\u5EA6: ${stdout?.length || 0}, stderr \u957F\u5EA6: ${stderr?.length || 0}`);
+      let jsonResult = null;
       try {
-        const parsed = parseVitestJSONOutput(output);
-        resolve(parsed);
-      } catch {
-        if (output) {
-          resolve(parseVitestTextOutput(output, !!error));
-        } else if (error && error.message.includes("ENOENT")) {
-          reject(new Error("\u672A\u627E\u5230 vitest\uFF0C\u8BF7\u786E\u4FDD\u5DF2\u5B89\u88C5: npm install -D vitest"));
+        if (fs9.existsSync(tmpFile)) {
+          jsonResult = fs9.readFileSync(tmpFile, "utf-8");
+          debug("vitest", `\u4ECE\u4E34\u65F6\u6587\u4EF6\u8BFB\u53D6\u5230 JSON (${jsonResult.length} \u5B57\u7B26)`);
+          debug("vitest", "JSON \u524D 500 \u5B57\u7B26:", jsonResult.substring(0, 500));
+          fs9.unlinkSync(tmpFile);
         } else {
-          resolve({ success: !error, suites: [] });
+          debug("vitest", "\u4E34\u65F6\u6587\u4EF6\u4E0D\u5B58\u5728:", tmpFile);
+        }
+      } catch (e) {
+        debug("vitest", "\u4E34\u65F6\u6587\u4EF6\u8BFB\u53D6\u5931\u8D25:", e instanceof Error ? e.message : String(e));
+      }
+      if (jsonResult) {
+        try {
+          const parsed = parseVitestJSON(jsonResult);
+          debug("vitest", "\u4ECE\u4E34\u65F6\u6587\u4EF6\u89E3\u6790\u6210\u529F:", parsed.suites.length, "\u4E2A\u5957\u4EF6");
+          resolve({ ...parsed, rawOutput, parseMethod: "outputFile-JSON" });
+          return;
+        } catch (e) {
+          debug("vitest", "\u4E34\u65F6\u6587\u4EF6 JSON \u89E3\u6790\u5931\u8D25:", e instanceof Error ? e.message : String(e));
         }
       }
+      debug("vitest", "\u5C1D\u8BD5\u4ECE stdout \u63D0\u53D6 JSON...");
+      try {
+        const parsed = parseFromStdout(rawOutput);
+        debug("vitest", "\u4ECE stdout \u89E3\u6790\u6210\u529F:", parsed.suites.length, "\u4E2A\u5957\u4EF6");
+        resolve({ ...parsed, rawOutput, parseMethod: "stdout-JSON" });
+        return;
+      } catch (e) {
+        debug("vitest", "stdout JSON \u89E3\u6790\u5931\u8D25:", e instanceof Error ? e.message : String(e));
+      }
+      debug("vitest", "\u5C1D\u8BD5\u4ECE\u6587\u672C\u8F93\u51FA\u89E3\u6790...");
+      if (rawOutput) {
+        const parsed = parseVitestTextOutput(rawOutput, !!error);
+        debug("vitest", "\u6587\u672C\u89E3\u6790\u7ED3\u679C:", parsed.suites.length, "\u4E2A\u5957\u4EF6");
+        resolve({ ...parsed, rawOutput, parseMethod: "text-fallback" });
+        return;
+      }
+      if (error && error.message.includes("ENOENT")) {
+        reject(new Error("\u672A\u627E\u5230 vitest\uFF0C\u8BF7\u786E\u4FDD\u5DF2\u5B89\u88C5: npm install -D vitest"));
+        return;
+      }
+      debug("vitest", "\u6240\u6709\u89E3\u6790\u65B9\u5F0F\u5747\u5931\u8D25\uFF0C\u8FD4\u56DE\u7A7A\u7ED3\u679C");
+      resolve({ success: !error, suites: [], rawOutput, parseMethod: "none" });
     });
     child.on("error", (err) => {
+      try {
+        fs9.unlinkSync(tmpFile);
+      } catch {
+      }
       reject(new Error(`Vitest \u6267\u884C\u5931\u8D25: ${err.message}`));
     });
   });
 }
-function parseVitestJSONOutput(output) {
-  const jsonMatch = output.match(/\{[\s\S]*"testResults"[\s\S]*\}/);
-  if (!jsonMatch) {
-    return parseVitestTextOutput(output, false);
+function parseVitestJSON(jsonStr) {
+  const data = JSON.parse(jsonStr);
+  const suites = [];
+  debug("vitest-json", "JSON \u9876\u5C42\u5B57\u6BB5:", Object.keys(data).join(", "));
+  if (data.testResults && Array.isArray(data.testResults)) {
+    debug("vitest-json", `testResults \u6570\u91CF: ${data.testResults.length}`);
+    for (const fileResult of data.testResults) {
+      const suiteTests = parseTestResults(fileResult);
+      suites.push({
+        name: path9.basename(fileResult.name || "unknown"),
+        file: fileResult.name || "unknown",
+        type: "unit",
+        status: mapVitestStatus(fileResult.status),
+        duration: fileResult.duration || 0,
+        tests: suiteTests
+      });
+    }
   }
-  try {
+  if (suites.length === 0 && data.numTotalTests !== void 0) {
+    debug("vitest-json", `\u4F7F\u7528\u6C47\u603B\u683C\u5F0F: total=${data.numTotalTests}, passed=${data.numPassedTests}`);
+    suites.push({
+      name: "Vitest Results",
+      file: "unknown",
+      type: "unit",
+      status: data.numFailedTests > 0 ? "failed" : "passed",
+      duration: 0,
+      tests: buildTestsFromSummary(data)
+    });
+  }
+  if (suites.length === 0 && data.suites && Array.isArray(data.suites)) {
+    debug("vitest-json", `suites \u6570\u91CF: ${data.suites.length}`);
+    for (const suiteData of data.suites) {
+      const suiteTests = [];
+      for (const test of suiteData.tests || []) {
+        suiteTests.push({
+          name: test.name || test.title || "unknown",
+          file: test.file || suiteData.file || "unknown",
+          status: mapVitestStatus(test.status || test.result?.status),
+          duration: test.duration || test.result?.duration || 0,
+          error: test.result?.errors?.[0] ? { message: test.result.errors[0].message || String(test.result.errors[0]) } : void 0,
+          retries: 0
+        });
+      }
+      suites.push({
+        name: suiteData.name || "unknown",
+        file: suiteData.file || "unknown",
+        type: "unit",
+        status: suiteTests.some((t) => t.status === "failed") ? "failed" : "passed",
+        duration: 0,
+        tests: suiteTests
+      });
+    }
+  }
+  let coverage;
+  if (data.coverageMap) {
+    coverage = extractCoverage(data.coverageMap);
+  }
+  if (!coverage && data.coverage && typeof data.coverage === "object") {
+    const cov = data.coverage;
+    const totals = cov.totals || cov;
+    const getVal = (key) => {
+      const v = totals[key];
+      return typeof v === "number" ? v : typeof v === "object" && v !== null && "pct" in v ? v.pct / 100 : 0;
+    };
+    coverage = {
+      lines: getVal("lines"),
+      statements: getVal("statements"),
+      functions: getVal("functions"),
+      branches: getVal("branches")
+    };
+  }
+  const success = data.success !== false ? data.numFailedTests !== void 0 ? data.numFailedTests === 0 : suites.every((s) => s.status !== "failed") : false;
+  return { success, suites, coverage };
+}
+function parseTestResults(fileResult) {
+  const tests = [];
+  const assertions = fileResult.assertionResults || fileResult.tests || [];
+  for (const assertion of assertions) {
+    tests.push({
+      name: assertion.title || assertion.fullName || assertion.name || "unknown",
+      file: fileResult.name || "unknown",
+      status: mapVitestStatus(assertion.status),
+      duration: assertion.duration || 0,
+      error: assertion.failureMessages?.length ? { message: assertion.failureMessages[0] } : assertion.failureMessage ? { message: assertion.failureMessage } : void 0,
+      retries: 0
+    });
+  }
+  if (tests.length === 0 && fileResult.numPassingTests !== void 0) {
+    tests.push(...buildTestsFromSummary(fileResult));
+  }
+  return tests;
+}
+function buildTestsFromSummary(data) {
+  const tests = [];
+  const counts = [
+    [data.numPassedTests || 0, "passed"],
+    [data.numFailedTests || 0, "failed"],
+    [data.numPendingTests || 0, "skipped"]
+  ];
+  for (const [n, s] of counts) {
+    for (let i = 0; i < n; i++) {
+      tests.push({
+        name: `${s} test ${i + 1}`,
+        file: data.name || "unknown",
+        status: s,
+        duration: 0,
+        retries: 0
+      });
+    }
+  }
+  return tests;
+}
+function parseFromStdout(output) {
+  const jsonMatch = output.match(/\{[\s\S]*"testResults"[\s\S]*\}/);
+  if (jsonMatch) {
     const data = JSON.parse(jsonMatch[0]);
     const suites = [];
     if (data.testResults && Array.isArray(data.testResults)) {
       for (const fileResult of data.testResults) {
-        const suite = {
-          name: path9.basename(fileResult.name || fileResult.assertionResults?.[0]?.ancestorTitles?.[0] || "unknown"),
+        suites.push({
+          name: path9.basename(fileResult.name || "unknown"),
           file: fileResult.name || "unknown",
           type: "unit",
           status: mapVitestStatus(fileResult.status),
           duration: fileResult.duration || 0,
-          tests: (fileResult.assertionResults || []).map((assertion) => ({
-            name: assertion.title || assertion.fullName || "unknown",
-            file: fileResult.name || "unknown",
-            status: mapVitestStatus(assertion.status),
-            duration: assertion.duration || 0,
-            error: assertion.failureMessages?.length ? { message: assertion.failureMessages[0] } : void 0,
-            retries: 0
-          }))
-        };
-        suites.push(suite);
+          tests: parseTestResults(fileResult)
+        });
       }
     }
-    let coverage;
-    if (data.coverageMap) {
-      coverage = extractCoverage(data.coverageMap);
-    }
     const success = data.success !== false && suites.every((s) => s.status !== "failed");
+    let coverage;
+    if (data.coverageMap) coverage = extractCoverage(data.coverageMap);
     return { success, suites, coverage };
-  } catch {
-    return parseVitestTextOutput(output, false);
   }
+  const anyJsonMatch = output.match(/\{[\s\S]*"numTotalTests"[\s\S]*\}/);
+  if (anyJsonMatch) {
+    return parseVitestJSON(anyJsonMatch[0]);
+  }
+  throw new Error("stdout \u4E2D\u672A\u627E\u5230\u6709\u6548 JSON");
 }
 function parseVitestTextOutput(output, hasError) {
   const suites = [];
+  debug("vitest-text", "\u6587\u672C\u8F93\u51FA\u524D 1000 \u5B57\u7B26:", output.substring(0, 1e3));
+  const suiteRegex = /[✓✗×✕]\s+(.+\.test\.(ts|js)|.+\.spec\.(ts|js))\s*\((\d+)[^)]*\)/i;
+  const lines = output.split("\n");
   let totalPassed = 0;
   let totalFailed = 0;
-  const suiteRegex = /[✓✗×]\s+(.+\.test\.ts|.+\.spec\.ts)\s*\((\d+)\s+test/i;
-  const lines = output.split("\n");
   for (const line of lines) {
     const match = line.match(suiteRegex);
     if (match) {
       const file = match[1];
-      const testCount = parseInt(match[2], 10);
+      const testCount = parseInt(match[4], 10);
       const isPassed = line.includes("\u2713");
       if (isPassed) totalPassed += testCount;
       else totalFailed += testCount;
@@ -3341,15 +3222,39 @@ function parseVitestTextOutput(output, hasError) {
       });
     }
   }
+  if (suites.length === 0) {
+    const summaryMatch = output.match(/Tests\s+(\d+)\s+(passed|failed)/i);
+    if (summaryMatch) {
+      const count = parseInt(summaryMatch[1], 10);
+      const status = summaryMatch[2].toLowerCase() === "passed" ? "passed" : "failed";
+      suites.push({
+        name: "Vitest Summary",
+        file: "unknown",
+        type: "unit",
+        status,
+        duration: 0,
+        tests: Array.from({ length: count }, (_, i) => ({
+          name: `test ${i + 1}`,
+          file: "unknown",
+          status,
+          duration: 0,
+          retries: 0
+        }))
+      });
+    }
+  }
+  debug("vitest-text", `\u89E3\u6790\u5230 ${suites.length} \u4E2A\u5957\u4EF6, ${totalPassed} \u901A\u8FC7, ${totalFailed} \u5931\u8D25`);
   return {
     success: !hasError || totalFailed === 0,
     suites
   };
 }
 function mapVitestStatus(status) {
+  if (!status) return "pending";
   switch (status) {
     case "passed":
     case "pass":
+    case "done":
       return "passed";
     case "failed":
     case "fail":
@@ -3357,6 +3262,7 @@ function mapVitestStatus(status) {
     case "skipped":
     case "skip":
     case "pending":
+    case "todo":
       return "skipped";
     default:
       return "pending";
@@ -3801,43 +3707,260 @@ function makeTestResult(name, value, threshold, isLowerBetter = false) {
     }
   }
   return {
-    name,
-    file: "lighthouse",
-    status,
-    duration: 0,
-    error,
-    retries: 0
+    name,
+    file: "lighthouse",
+    status,
+    duration: 0,
+    error,
+    retries: 0
+  };
+}
+function calculateAverageScores(results) {
+  const valid = results.filter((r) => !r.error);
+  if (valid.length === 0) {
+    return { performance: 0, accessibility: 0, bestPractices: 0, seo: 0 };
+  }
+  return {
+    performance: Math.round(valid.reduce((s, r) => s + r.scores.performance, 0) / valid.length),
+    accessibility: Math.round(valid.reduce((s, r) => s + r.scores.accessibility, 0) / valid.length),
+    bestPractices: Math.round(valid.reduce((s, r) => s + r.scores.bestPractices, 0) / valid.length),
+    seo: Math.round(valid.reduce((s, r) => s + r.scores.seo, 0) / valid.length)
+  };
+}
+function calculateAverageMetrics(results) {
+  const valid = results.filter((r) => !r.error);
+  const scores = calculateAverageScores(results);
+  const lcpValues = valid.map((r) => r.metrics.lcp).filter((v) => v !== void 0);
+  const fidValues = valid.map((r) => r.metrics.fid).filter((v) => v !== void 0);
+  const clsValues = valid.map((r) => r.metrics.cls).filter((v) => v !== void 0);
+  return {
+    ...scores,
+    lcp: lcpValues.length > 0 ? lcpValues.reduce((s, v) => s + v, 0) / lcpValues.length : void 0,
+    fid: fidValues.length > 0 ? fidValues.reduce((s, v) => s + v, 0) / fidValues.length : void 0,
+    cls: clsValues.length > 0 ? clsValues.reduce((s, v) => s + v, 0) / clsValues.length : void 0
+  };
+}
+
+// src/services/reporter.ts
+import fs10 from "fs";
+import path11 from "path";
+function aggregateResults(results) {
+  const summary = {
+    total: 0,
+    passed: 0,
+    failed: 0,
+    skipped: 0,
+    pending: 0
+  };
+  const byType = {};
+  let coverage;
+  for (const result of results) {
+    const typeKey = result.type;
+    if (!byType[typeKey]) {
+      byType[typeKey] = { total: 0, passed: 0, failed: 0, skipped: 0 };
+    }
+    for (const suite of result.suites) {
+      for (const test of suite.tests) {
+        summary.total++;
+        byType[typeKey].total++;
+        if (test.status === "passed") {
+          summary.passed++;
+          byType[typeKey].passed++;
+        } else if (test.status === "failed") {
+          summary.failed++;
+          byType[typeKey].failed++;
+        } else if (test.status === "skipped") {
+          summary.skipped++;
+          byType[typeKey].skipped++;
+        } else {
+          summary.pending++;
+        }
+      }
+    }
+    if (result.coverage) {
+      if (!coverage) {
+        coverage = { ...result.coverage };
+      } else {
+        coverage.lines = Math.max(coverage.lines, result.coverage.lines);
+        coverage.statements = Math.max(coverage.statements, result.coverage.statements);
+        coverage.functions = Math.max(coverage.functions, result.coverage.functions);
+        coverage.branches = Math.max(coverage.branches, result.coverage.branches);
+      }
+    }
+  }
+  const totalDuration = results.reduce((sum, r) => sum + r.duration, 0);
+  return {
+    timestamp: Date.now(),
+    duration: totalDuration,
+    results,
+    summary,
+    byType,
+    coverage: coverage?.lines ? coverage : void 0
   };
 }
-function calculateAverageScores(results) {
-  const valid = results.filter((r) => !r.error);
-  if (valid.length === 0) {
-    return { performance: 0, accessibility: 0, bestPractices: 0, seo: 0 };
+function formatDuration(ms) {
+  if (ms < 1e3) return `${ms}ms`;
+  if (ms < 6e4) return `${(ms / 1e3).toFixed(2)}s`;
+  const minutes = Math.floor(ms / 6e4);
+  const seconds = (ms % 6e4 / 1e3).toFixed(0);
+  return `${minutes}m ${seconds}s`;
+}
+function formatTimestamp(ts) {
+  return new Date(ts).toLocaleString("zh-CN", {
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit"
+  });
+}
+function pct(value) {
+  return `${(value * 100).toFixed(1)}%`;
+}
+function renderCoverageMD(coverage) {
+  return `
+### \u8986\u76D6\u7387
+
+| \u6307\u6807 | \u8986\u76D6\u7387 | \u8FDB\u5EA6 |
+|------|--------|------|
+| \u8BED\u53E5 (Statements) | ${pct(coverage.statements)} | ${renderProgressBar(coverage.statements)} |
+| \u5206\u652F (Branches) | ${pct(coverage.branches)} | ${renderProgressBar(coverage.branches)} |
+| \u51FD\u6570 (Functions) | ${pct(coverage.functions)} | ${renderProgressBar(coverage.functions)} |
+| \u884C (Lines) | ${pct(coverage.lines)} | ${renderProgressBar(coverage.lines)} |
+`;
+}
+function renderProgressBar(value) {
+  const filled = Math.round(value * 10);
+  const empty = 10 - filled;
+  return `${"\u2588".repeat(filled)}${"\u2591".repeat(empty)}`;
+}
+var TYPE_LABELS = {
+  unit: "\u5355\u5143\u6D4B\u8BD5",
+  component: "\u7EC4\u4EF6\u6D4B\u8BD5",
+  e2e: "E2E \u6D4B\u8BD5",
+  api: "API \u6D4B\u8BD5",
+  visual: "\u89C6\u89C9\u56DE\u5F52\u6D4B\u8BD5",
+  performance: "\u6027\u80FD\u6D4B\u8BD5"
+};
+function generateMDReport(data) {
+  const passRate = data.summary.total > 0 ? (data.summary.passed / data.summary.total * 100).toFixed(1) : "0";
+  const rateIcon = parseFloat(passRate) >= 80 ? "\u2705" : parseFloat(passRate) >= 50 ? "\u26A0\uFE0F" : "\u274C";
+  const lines = [];
+  lines.push(`# QAT \u6D4B\u8BD5\u62A5\u544A`);
+  lines.push("");
+  lines.push(`> \u751F\u6210\u65F6\u95F4: ${formatTimestamp(data.timestamp)} | \u603B\u8017\u65F6: ${formatDuration(data.duration)}`);
+  lines.push("");
+  lines.push(`## \u603B\u89C8`);
+  lines.push("");
+  lines.push(`| \u6307\u6807 | \u6570\u503C |`);
+  lines.push(`|------|------|`);
+  lines.push(`| \u901A\u8FC7\u7387 | ${rateIcon} **${passRate}%** |`);
+  lines.push(`| \u603B\u7528\u4F8B | ${data.summary.total} |`);
+  lines.push(`| \u2705 \u901A\u8FC7 | ${data.summary.passed} |`);
+  if (data.summary.failed > 0) lines.push(`| \u274C \u5931\u8D25 | ${data.summary.failed} |`);
+  if (data.summary.skipped > 0) lines.push(`| \u23ED\uFE0F \u8DF3\u8FC7 | ${data.summary.skipped} |`);
+  if (data.summary.pending > 0) lines.push(`| \u23F3 \u5F85\u5B9A | ${data.summary.pending} |`);
+  lines.push(`| \u23F1\uFE0F \u8017\u65F6 | ${formatDuration(data.duration)} |`);
+  lines.push("");
+  if (Object.keys(data.byType).length > 0) {
+    lines.push(`## \u6309\u7C7B\u578B\u7EDF\u8BA1`);
+    lines.push("");
+    lines.push(`| \u7C7B\u578B | \u901A\u8FC7 | \u5931\u8D25 | \u8DF3\u8FC7 | \u603B\u8BA1 | \u901A\u8FC7\u7387 |`);
+    lines.push(`|------|------|------|------|------|--------|`);
+    for (const [type, stats] of Object.entries(data.byType)) {
+      const label = TYPE_LABELS[type] || type;
+      const rate = stats.total > 0 ? (stats.passed / stats.total * 100).toFixed(0) + "%" : "-";
+      lines.push(`| ${label} | ${stats.passed} | ${stats.failed} | ${stats.skipped} | ${stats.total} | ${rate} |`);
+    }
+    lines.push("");
+  }
+  if (data.coverage) {
+    lines.push(renderCoverageMD(data.coverage));
+    lines.push("");
+  }
+  lines.push(`## \u6D4B\u8BD5\u8BE6\u60C5`);
+  lines.push("");
+  for (const result of data.results) {
+    const typeLabel = TYPE_LABELS[result.type] || result.type;
+    const statusIcon = result.status === "passed" ? "\u2705" : result.status === "failed" ? "\u274C" : "\u26A0\uFE0F";
+    lines.push(`### ${statusIcon} ${typeLabel}`);
+    lines.push("");
+    if (result.suites.length === 0) {
+      lines.push(`*\u65E0\u6D4B\u8BD5\u7ED3\u679C*`);
+      lines.push("");
+      continue;
+    }
+    for (const suite of result.suites) {
+      const suiteIcon = suite.status === "passed" ? "\u2705" : suite.status === "failed" ? "\u274C" : "\u26A0\uFE0F";
+      lines.push(`#### ${suiteIcon} ${suite.name}`);
+      lines.push("");
+      lines.push(`- \u6587\u4EF6: \`${suite.file}\``);
+      lines.push(`- \u8017\u65F6: ${formatDuration(suite.duration)}`);
+      lines.push("");
+      if (suite.tests.length > 0) {
+        lines.push(`| \u72B6\u6001 | \u6D4B\u8BD5\u540D\u79F0 | \u8017\u65F6 |`);
+        lines.push(`|------|----------|------|`);
+        for (const test of suite.tests) {
+          const testIcon = test.status === "passed" ? "\u2705" : test.status === "failed" ? "\u274C" : test.status === "skipped" ? "\u23ED\uFE0F" : "\u23F3";
+          const name = test.error ? `**${test.name}**` : test.name;
+          lines.push(`| ${testIcon} | ${name} | ${formatDuration(test.duration)} |`);
+        }
+        lines.push("");
+      }
+      const failedTests = suite.tests.filter((t) => t.status === "failed" && t.error);
+      if (failedTests.length > 0) {
+        lines.push(`<details>`);
+        lines.push(`<summary>\u274C \u5931\u8D25\u8BE6\u60C5 (${failedTests.length})</summary>`);
+        lines.push("");
+        for (const test of failedTests) {
+          lines.push(`**${test.name}**`);
+          lines.push("```");
+          lines.push(test.error.message);
+          if (test.error.stack) {
+            lines.push(test.error.stack);
+          }
+          if (test.error.expected && test.error.actual) {
+            lines.push(`Expected: ${test.error.expected}`);
+            lines.push(`Actual: ${test.error.actual}`);
+          }
+          lines.push("```");
+          lines.push("");
+        }
+        lines.push(`</details>`);
+        lines.push("");
+      }
+    }
   }
-  return {
-    performance: Math.round(valid.reduce((s, r) => s + r.scores.performance, 0) / valid.length),
-    accessibility: Math.round(valid.reduce((s, r) => s + r.scores.accessibility, 0) / valid.length),
-    bestPractices: Math.round(valid.reduce((s, r) => s + r.scores.bestPractices, 0) / valid.length),
-    seo: Math.round(valid.reduce((s, r) => s + r.scores.seo, 0) / valid.length)
-  };
+  lines.push("---");
+  lines.push("");
+  lines.push(`*\u7531 QAT \u81EA\u52A8\u5316\u6D4B\u8BD5\u5DE5\u5177\u751F\u6210 | ${formatTimestamp(data.timestamp)}*`);
+  return lines.join("\n");
 }
-function calculateAverageMetrics(results) {
-  const valid = results.filter((r) => !r.error);
-  const scores = calculateAverageScores(results);
-  const lcpValues = valid.map((r) => r.metrics.lcp).filter((v) => v !== void 0);
-  const fidValues = valid.map((r) => r.metrics.fid).filter((v) => v !== void 0);
-  const clsValues = valid.map((r) => r.metrics.cls).filter((v) => v !== void 0);
-  return {
-    ...scores,
-    lcp: lcpValues.length > 0 ? lcpValues.reduce((s, v) => s + v, 0) / lcpValues.length : void 0,
-    fid: fidValues.length > 0 ? fidValues.reduce((s, v) => s + v, 0) / fidValues.length : void 0,
-    cls: clsValues.length > 0 ? clsValues.reduce((s, v) => s + v, 0) / clsValues.length : void 0
-  };
+function writeReportToDisk(data, outputDir) {
+  const md = generateMDReport(data);
+  const dir = path11.resolve(outputDir);
+  if (!fs10.existsSync(dir)) {
+    fs10.mkdirSync(dir, { recursive: true });
+  }
+  const mdPath = path11.join(dir, "report.md");
+  fs10.writeFileSync(mdPath, md, "utf-8");
+  const jsonPath = path11.join(dir, "report.json");
+  fs10.writeFileSync(jsonPath, JSON.stringify(data, null, 2), "utf-8");
+  return mdPath;
 }
 
 // src/commands/run.ts
 var RESULTS_DIR = ".qat-results";
 var SERVER_REQUIRED_TYPES = ["e2e", "visual", "performance"];
+var TYPE_DEPENDENCIES = {
+  unit: { pkg: "vitest", runner: "Vitest", installCmd: "npm install -D vitest" },
+  component: { pkg: "vitest", runner: "Vitest", installCmd: "npm install -D vitest @vue/test-utils happy-dom" },
+  api: { pkg: "vitest", runner: "Vitest", installCmd: "npm install -D vitest" },
+  e2e: { pkg: "@playwright/test", runner: "Playwright", installCmd: "npm install -D @playwright/test && npx playwright install" },
+  visual: { pkg: "@playwright/test", runner: "Playwright", installCmd: "npm install -D @playwright/test && npx playwright install" },
+  performance: { pkg: "lighthouse", runner: "Lighthouse", installCmd: "npm install -D lighthouse" }
+};
 var TYPE_RUNNERS = {
   unit: "Vitest",
   component: "Vitest",
@@ -3846,7 +3969,7 @@ var TYPE_RUNNERS = {
   visual: "Playwright",
   performance: "Lighthouse"
 };
-var TYPE_LABELS = {
+var TYPE_LABELS2 = {
   unit: "\u5355\u5143\u6D4B\u8BD5",
   component: "\u7EC4\u4EF6\u6D4B\u8BD5",
   e2e: "E2E\u6D4B\u8BD5",
@@ -3882,6 +4005,61 @@ async function executeRun(options) {
     console.log(chalk5.yellow("\n  \u6CA1\u6709\u53EF\u8FD0\u884C\u7684\u6D4B\u8BD5\u7C7B\u578B\uFF08\u8BF7\u5728 qat.config.ts \u4E2D\u542F\u7528\uFF09\n"));
     return;
   }
+  const 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"));
+    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();
+    const { action } = await inquirer3.prompt([
+      {
+        type: "list",
+        name: "action",
+        message: "\u5982\u4F55\u5904\u7406\uFF1F",
+        choices: [
+          { name: "\u81EA\u52A8\u5B89\u88C5\u7F3A\u5931\u4F9D\u8D56", value: "install" },
+          { name: "\u8DF3\u8FC7\u672A\u5B89\u88C5\u7684\u6D4B\u8BD5\u7C7B\u578B", value: "skip" },
+          { name: "\u53D6\u6D88\u8FD0\u884C", value: "cancel" }
+        ],
+        default: "install"
+      }
+    ]);
+    if (action === "cancel") {
+      console.log(chalk5.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"));
+      }
+      const stillMissing = checkTestDependencies(typesToRun);
+      if (stillMissing.length > 0) {
+        const missingRunners = new Set(stillMissing.map((d) => d.pkg));
+        typesToRun = typesToRun.filter((t) => {
+          const dep = TYPE_DEPENDENCIES[t];
+          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"));
+          return;
+        }
+      }
+    }
+    if (action === "skip") {
+      const missingRunners = new Set(missingDeps.map((d) => d.pkg));
+      typesToRun = typesToRun.filter((t) => {
+        const dep = TYPE_DEPENDENCIES[t];
+        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"));
+        return;
+      }
+    }
+  }
   const serverNeededTypes = typesToRun.filter((t) => SERVER_REQUIRED_TYPES.includes(t));
   if (serverNeededTypes.length > 0) {
     const serverOk = await checkDevServer(config);
@@ -3890,7 +4068,7 @@ async function executeRun(options) {
         {
           type: "list",
           name: "action",
-          message: `\u8FD0\u884C ${serverNeededTypes.map((t) => TYPE_LABELS[t]).join("\u3001")} \u9700\u8981\u9879\u76EE\u670D\u52A1\u8FD0\u884C\uFF0C\u5982\u4F55\u5904\u7406\uFF1F`,
+          message: `\u8FD0\u884C ${serverNeededTypes.map((t) => TYPE_LABELS2[t]).join("\u3001")} \u9700\u8981\u9879\u76EE\u670D\u52A1\u8FD0\u884C\uFF0C\u5982\u4F55\u5904\u7406\uFF1F`,
           choices: [
             { name: "\u81EA\u52A8\u542F\u52A8 dev server \u5E76\u8FD0\u884C", value: "start" },
             { name: "\u8DF3\u8FC7\u8FD9\u4E9B\u6D4B\u8BD5\u7C7B\u578B\uFF0C\u4EC5\u8FD0\u884C\u5176\u4ED6\u6D4B\u8BD5", value: "skip" },
@@ -3971,7 +4149,7 @@ async function executeRun(options) {
     spinner.stop();
   } else {
     for (const testType of typesToRun) {
-      const label = TYPE_LABELS[testType] || testType;
+      const label = TYPE_LABELS2[testType] || testType;
       const spinner = ora4(`\u6B63\u5728\u8FD0\u884C ${label}...`).start();
       try {
         const result = await runTestType(testType, config, options);
@@ -3983,14 +4161,25 @@ async function executeRun(options) {
       }
     }
   }
-  displaySummary(results, config);
+  displayJestStyleResults(results);
   saveRunResults(results);
+  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)}`));
+  console.log();
+  const hasFailures = results.some((r) => r.status === "failed");
+  if (hasFailures && isAIAvailable(config.ai)) {
+    await aiAnalyzeFailures(results, config.ai);
+  }
 }
 function printDryRunCommands(types, options, config) {
   console.log();
   console.log(chalk5.cyan("  \u53EF\u6267\u884C\u7684\u6D4B\u8BD5\u547D\u4EE4:\n"));
   for (const testType of types) {
-    const label = TYPE_LABELS[testType];
+    const label = TYPE_LABELS2[testType];
     const runner = TYPE_RUNNERS[testType];
     let cmd;
     switch (runner) {
@@ -4058,7 +4247,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_LABELS[t]} (${chalk5.gray(TYPE_RUNNERS[t])})`,
+        name: `${TYPE_LABELS2[t]} (${chalk5.gray(TYPE_RUNNERS[t])})`,
         value: t,
         checked: true
       })),
@@ -4192,53 +4381,82 @@ function suiteStatusToSpinner(status) {
       return "warn";
   }
 }
-async function displaySummary(results, config) {
-  let totalSuites = 0;
+function displayJestStyleResults(results) {
+  console.log();
+  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`));
+      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)})`)}`);
+      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))}`);
+      }
+    }
+    console.log();
+  }
   let totalPassed = 0;
   let totalFailed = 0;
   let totalSkipped = 0;
   let totalDuration = 0;
+  const typeStats = {};
   for (const result of results) {
     totalDuration += result.duration;
+    if (!typeStats[result.type]) {
+      typeStats[result.type] = { passed: 0, failed: 0, skipped: 0, duration: 0 };
+    }
+    typeStats[result.type].duration += result.duration;
     for (const suite of result.suites) {
-      totalSuites++;
       for (const test of suite.tests) {
-        if (test.status === "passed") totalPassed++;
-        else if (test.status === "failed") totalFailed++;
-        else if (test.status === "skipped") totalSkipped++;
+        if (test.status === "passed") {
+          totalPassed++;
+          typeStats[result.type].passed++;
+        } else if (test.status === "failed") {
+          totalFailed++;
+          typeStats[result.type].failed++;
+        } else if (test.status === "skipped") {
+          totalSkipped++;
+          typeStats[result.type].skipped++;
+        }
       }
     }
   }
   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();
-  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"));
-  if (totalFailed > 0) {
-    console.log(chalk5.red("  \u2717 \u6D4B\u8BD5\u5931\u8D25"));
-  } else if (total === 0) {
-    console.log(chalk5.yellow("  \u26A0 \u6CA1\u6709\u53D1\u73B0\u6D4B\u8BD5\u7528\u4F8B"));
-  } else {
-    console.log(chalk5.green("  \u2713 \u5168\u90E8\u901A\u8FC7"));
-  }
+  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(`  ${"\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);
+    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);
+  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();
-  console.log(`  ${chalk5.white("\u6D4B\u8BD5\u7528\u4F8B:")} ${total} total`);
-  if (totalPassed > 0) console.log(`  ${chalk5.green("  \u901A\u8FC7:")} ${totalPassed}`);
-  if (totalFailed > 0) console.log(`  ${chalk5.red("  \u5931\u8D25:")} ${totalFailed}`);
-  if (totalSkipped > 0) console.log(`  ${chalk5.yellow("  \u8DF3\u8FC7:")} ${totalSkipped}`);
-  console.log(`  ${chalk5.gray("  \u5957\u4EF6:")} ${totalSuites}`);
-  console.log(`  ${chalk5.gray("  \u8017\u65F6:")} ${formatDuration(totalDuration)}`);
-  if (results.length > 1) {
-    console.log();
-    for (const result of results) {
-      const label = TYPE_LABELS[result.type] || result.type;
-      const icon = result.status === "passed" ? chalk5.green("\u2713") : result.status === "failed" ? chalk5.red("\u2717") : chalk5.yellow("\u26A0");
-      const testCount = result.suites.reduce((sum, s) => sum + s.tests.length, 0);
-      console.log(`  ${icon} ${label} (${testCount} tests, ${formatDuration(result.duration)})`);
+  for (const result of results) {
+    if (result.coverage) {
+      const c = result.coverage;
+      console.log(chalk5.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();
     }
   }
   for (const result of results) {
     if (result.type === "performance" && result.performance) {
       const p = result.performance;
-      console.log();
       console.log(chalk5.cyan("  \u6027\u80FD\u6307\u6807:"));
       console.log(`  Performance:  ${scoreColor(p.performance)} ${p.performance}/100`);
       console.log(`  Accessibility: ${scoreColor(p.accessibility)} ${p.accessibility}/100`);
@@ -4247,6 +4465,7 @@ async function displaySummary(results, config) {
       if (p.lcp !== void 0) console.log(`  LCP:           ${p.lcp.toFixed(0)}ms`);
       if (p.fid !== void 0) console.log(`  FID:           ${p.fid.toFixed(0)}ms`);
       if (p.cls !== void 0) console.log(`  CLS:           ${p.cls.toFixed(3)}`);
+      console.log();
     }
   }
   const failedTests = results.flatMap(
@@ -4255,23 +4474,31 @@ async function displaySummary(results, config) {
     )
   );
   if (failedTests.length > 0) {
-    console.log();
     console.log(chalk5.red("  \u5931\u8D25\u8BE6\u60C5:"));
     for (const { suite, test } of failedTests) {
-      console.log(chalk5.red(`    \u2717 ${suite.name} > ${test.name}`));
+      console.log(chalk5.red(`    \u2715 ${suite.name} > ${test.name}`));
       if (test.error?.message) {
         console.log(chalk5.gray(`      ${test.error.message.split("\n")[0]}`));
       }
     }
+    console.log();
   }
-  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"));
-  console.log();
   if (totalFailed > 0) {
+    console.log(chalk5.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"));
+  } else {
+    console.log(chalk5.green(`  Tests: ${totalPassed} passed, ${total} total`));
   }
-  if (totalFailed > 0 && isAIAvailable(config.ai)) {
-    await aiAnalyzeFailures(results, config.ai);
-  }
+  console.log(chalk5.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);
 }
 async function aiAnalyzeFailures(results, aiConfig) {
   const failedTests = results.flatMap(
@@ -4300,7 +4527,7 @@ async function aiAnalyzeFailures(results, aiConfig) {
     }
   }
 }
-function formatDuration(ms) {
+function formatDuration2(ms) {
   if (ms < 1e3) return `${ms}ms`;
   if (ms < 6e4) return `${(ms / 1e3).toFixed(1)}s`;
   const min = Math.floor(ms / 6e4);
@@ -4326,8 +4553,8 @@ async function checkDevServer(config) {
 }
 async function startDevServer(config) {
   const { spawn } = await import("child_process");
-  const hasPnpm = fs9.existsSync(path11.join(process.cwd(), "pnpm-lock.yaml"));
-  const hasYarn = fs9.existsSync(path11.join(process.cwd(), "yarn.lock"));
+  const hasPnpm = fs11.existsSync(path12.join(process.cwd(), "pnpm-lock.yaml"));
+  const hasYarn = fs11.existsSync(path12.join(process.cwd(), "yarn.lock"));
   const pkgCmd = hasPnpm ? "pnpm" : hasYarn ? "yarn" : "npm";
   console.log(chalk5.cyan(`  \u6B63\u5728\u542F\u52A8 dev server (${pkgCmd} run dev) ...`));
   const child = spawn(pkgCmd, ["run", "dev"], {
@@ -4356,27 +4583,99 @@ async function startDevServer(config) {
 }
 function saveRunResults(results) {
   if (results.length === 0) return;
-  const resultsPath = path11.join(process.cwd(), RESULTS_DIR);
-  if (!fs9.existsSync(resultsPath)) {
-    fs9.mkdirSync(resultsPath, { recursive: true });
+  const resultsPath = path12.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 = path11.join(resultsPath, fileName);
+  const filePath = path12.join(resultsPath, fileName);
   const data = {
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
     results
   };
-  fs9.writeFileSync(filePath, JSON.stringify(data, null, 2), "utf-8");
+  fs11.writeFileSync(filePath, JSON.stringify(data, null, 2), "utf-8");
   try {
-    const files = fs9.readdirSync(resultsPath).filter((f) => f.startsWith("result-") && f.endsWith(".json")).sort();
+    const files = fs11.readdirSync(resultsPath).filter((f) => f.startsWith("result-") && f.endsWith(".json")).sort();
     while (files.length > 20) {
       const oldest = files.shift();
-      fs9.unlinkSync(path11.join(resultsPath, oldest));
+      fs11.unlinkSync(path12.join(resultsPath, oldest));
     }
   } catch {
   }
 }
+function checkTestDependencies(types) {
+  const pkgPath = path12.join(process.cwd(), "package.json");
+  let allDeps = {};
+  if (fs11.existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(fs11.readFileSync(pkgPath, "utf-8"));
+      allDeps = {
+        ...pkg.dependencies,
+        ...pkg.devDependencies
+      };
+    } catch {
+    }
+  }
+  const missingDeps = [];
+  const checkedPkgs = /* @__PURE__ */ new Set();
+  for (const testType of types) {
+    const dep = TYPE_DEPENDENCIES[testType];
+    if (dep && !checkedPkgs.has(dep.pkg)) {
+      checkedPkgs.add(dep.pkg);
+      if (!allDeps[dep.pkg]) {
+        missingDeps.push(dep);
+      }
+    }
+  }
+  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 pkgManager = hasPnpm ? "pnpm" : hasYarn ? "yarn" : "npm";
+  const { execFile: execFile5 } = await import("child_process");
+  let allSuccess = true;
+  for (const dep of missingDeps) {
+    const spinner = ora4(`\u6B63\u5728\u5B89\u88C5 ${dep.pkg}...`).start();
+    const isPlaywright = dep.pkg === "@playwright/test";
+    const installArgs = hasPnpm ? ["add", "-D", dep.pkg] : hasYarn ? ["add", "-D", dep.pkg] : ["install", "-D", dep.pkg];
+    try {
+      await new Promise((resolve, reject) => {
+        const cmd = pkgManager === "npm" ? "npm" : pkgManager;
+        const child = execFile5(cmd, installArgs, {
+          cwd: process.cwd(),
+          shell: true,
+          stdio: "pipe"
+        }, (error) => {
+          if (error) reject(error);
+          else resolve();
+        });
+        child.on("error", reject);
+      });
+      if (isPlaywright) {
+        spinner.text = `\u6B63\u5728\u5B89\u88C5 Playwright \u6D4F\u89C8\u5668...`;
+        await new Promise((resolve, reject) => {
+          const child = execFile5("npx", ["playwright", "install"], {
+            cwd: process.cwd(),
+            shell: true,
+            stdio: "pipe"
+          }, (error) => {
+            if (error) reject(error);
+            else resolve();
+          });
+          child.on("error", reject);
+        });
+      }
+      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)}`));
+      allSuccess = false;
+    }
+  }
+  return allSuccess;
+}
 
 // src/commands/mock.ts
 import chalk6 from "chalk";
@@ -4500,276 +4799,8 @@ function showStatus() {
 // src/commands/report.ts
 import chalk7 from "chalk";
 import ora6 from "ora";
-import fs11 from "fs";
+import fs12 from "fs";
 import path13 from "path";
-
-// src/services/reporter.ts
-import fs10 from "fs";
-import path12 from "path";
-function aggregateResults(results) {
-  const summary = {
-    total: 0,
-    passed: 0,
-    failed: 0,
-    skipped: 0,
-    pending: 0
-  };
-  const byType = {};
-  for (const result of results) {
-    const typeKey = result.type;
-    if (!byType[typeKey]) {
-      byType[typeKey] = { total: 0, passed: 0, failed: 0, skipped: 0 };
-    }
-    for (const suite of result.suites) {
-      for (const test of suite.tests) {
-        summary.total++;
-        byType[typeKey].total++;
-        if (test.status === "passed") {
-          summary.passed++;
-          byType[typeKey].passed++;
-        } else if (test.status === "failed") {
-          summary.failed++;
-          byType[typeKey].failed++;
-        } else if (test.status === "skipped") {
-          summary.skipped++;
-          byType[typeKey].skipped++;
-        } else {
-          summary.pending++;
-        }
-      }
-    }
-  }
-  const totalDuration = results.reduce((sum, r) => sum + r.duration, 0);
-  return {
-    timestamp: Date.now(),
-    duration: totalDuration,
-    results,
-    summary,
-    byType
-  };
-}
-function formatDuration2(ms) {
-  if (ms < 1e3) return `${ms}ms`;
-  if (ms < 6e4) return `${(ms / 1e3).toFixed(2)}s`;
-  const minutes = Math.floor(ms / 6e4);
-  const seconds = (ms % 6e4 / 1e3).toFixed(0);
-  return `${minutes}m ${seconds}s`;
-}
-function formatTimestamp(ts) {
-  return new Date(ts).toLocaleString("zh-CN", {
-    year: "numeric",
-    month: "2-digit",
-    day: "2-digit",
-    hour: "2-digit",
-    minute: "2-digit",
-    second: "2-digit"
-  });
-}
-function renderSuiteHTML(suite) {
-  const statusClass = suite.status === "passed" ? "passed" : suite.status === "failed" ? "failed" : "skipped";
-  const testsHTML = suite.tests.map((test) => {
-    const testStatusClass = test.status;
-    const errorHTML = test.error ? `<div class="error-message"><strong>${escapeHTML(test.error.message)}</strong>${test.error.stack ? `
-${escapeHTML(test.error.stack)}` : ""}${test.error.expected && test.error.actual ? `
-
-Expected: ${escapeHTML(test.error.expected)}
-Actual: ${escapeHTML(test.error.actual)}` : ""}</div>` : "";
-    return `<div class="test-item">
-      <span class="status-dot ${testStatusClass}"></span>
-      <span class="test-name">${escapeHTML(test.name)}</span>
-      <span class="duration">${formatDuration2(test.duration)}</span>
-      ${test.retries > 0 ? `<span class="retries">\u91CD\u8BD5 ${test.retries} \u6B21</span>` : ""}
-    </div>
-    ${errorHTML}`;
-  }).join("");
-  return `<div class="suite">
-    <div class="suite-header" onclick="this.parentElement.classList.toggle('collapsed')">
-      <div>
-        <span class="status-dot ${statusClass}"></span>
-        <strong>${escapeHTML(suite.name)}</strong>
-        <span class="suite-file">${escapeHTML(suite.file)}</span>
-      </div>
-      <div>
-        <span class="duration">${formatDuration2(suite.duration)}</span>
-        <span class="toggle-icon">\u25BC</span>
-      </div>
-    </div>
-    <div class="suite-body">${testsHTML}</div>
-  </div>`;
-}
-function escapeHTML(str) {
-  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
-}
-function generateHTMLReport(data) {
-  const passRate = data.summary.total > 0 ? (data.summary.passed / data.summary.total * 100).toFixed(1) : "0";
-  const suitesHTML = data.results.flatMap((r) => r.suites).map(renderSuiteHTML).join("\n");
-  const byTypeHTML = Object.entries(data.byType).map(([type, stats]) => {
-    const rate = stats.total > 0 ? (stats.passed / stats.total * 100).toFixed(0) : "0";
-    return `<div class="type-card">
-        <div class="type-name">${type}</div>
-        <div class="type-stats">
-          <span class="passed">${stats.passed} \u901A\u8FC7</span>
-          <span class="failed">${stats.failed} \u5931\u8D25</span>
-          <span class="skipped">${stats.skipped} \u8DF3\u8FC7</span>
-        </div>
-        <div class="type-rate">${rate}%</div>
-      </div>`;
-  }).join("\n");
-  return `<!DOCTYPE html>
-<html lang="zh-CN">
-<head>
-  <meta charset="UTF-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1.0">
-  <title>QAT \u6D4B\u8BD5\u62A5\u544A - ${formatTimestamp(data.timestamp)}</title>
-  <style>
-    :root {
-      --color-passed: #22c55e;
-      --color-failed: #ef4444;
-      --color-skipped: #f59e0b;
-      --color-info: #3b82f6;
-      --bg-primary: #ffffff;
-      --bg-secondary: #f8fafc;
-      --text-primary: #1e293b;
-      --text-secondary: #64748b;
-      --border-color: #e2e8f0;
-    }
-    * { margin: 0; padding: 0; box-sizing: border-box; }
-    body {
-      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
-      background: var(--bg-secondary);
-      color: var(--text-primary);
-      line-height: 1.6;
-    }
-    .container { max-width: 1200px; margin: 0 auto; padding: 20px; }
-    header {
-      background: white;
-      border-bottom: 1px solid var(--border-color);
-      padding: 20px;
-      margin-bottom: 20px;
-      border-radius: 8px;
-    }
-    header h1 { font-size: 24px; font-weight: 600; }
-    header .meta { color: var(--text-secondary); font-size: 14px; margin-top: 4px; }
-    .summary { display: flex; gap: 16px; margin: 20px 0; flex-wrap: wrap; }
-    .card {
-      padding: 16px 24px; border-radius: 8px; color: white;
-      font-weight: 600; min-width: 120px; text-align: center;
-    }
-    .card.passed { background: var(--color-passed); }
-    .card.failed { background: var(--color-failed); }
-    .card.skipped { background: var(--color-skipped); }
-    .card.total { background: var(--color-info); }
-    .card .card-value { font-size: 28px; }
-    .card .card-label { font-size: 13px; opacity: 0.9; }
-    .pass-rate {
-      font-size: 48px; font-weight: 700; text-align: center; margin: 20px 0;
-      color: ${parseFloat(passRate) >= 80 ? "var(--color-passed)" : parseFloat(passRate) >= 50 ? "var(--color-skipped)" : "var(--color-failed)"};
-    }
-    .pass-rate-label { text-align: center; color: var(--text-secondary); margin-bottom: 20px; }
-    .by-type { display: flex; gap: 12px; flex-wrap: wrap; margin: 20px 0; }
-    .type-card {
-      background: white; border: 1px solid var(--border-color); border-radius: 8px;
-      padding: 12px 16px; min-width: 180px;
-    }
-    .type-name { font-weight: 600; text-transform: capitalize; margin-bottom: 4px; }
-    .type-stats { font-size: 13px; }
-    .type-stats span { margin-right: 8px; }
-    .type-stats .passed { color: var(--color-passed); }
-    .type-stats .failed { color: var(--color-failed); }
-    .type-stats .skipped { color: var(--color-skipped); }
-    .type-rate { font-size: 20px; font-weight: 700; margin-top: 4px; }
-    .suite {
-      background: white; border: 1px solid var(--border-color);
-      border-radius: 8px; margin-bottom: 12px; overflow: hidden;
-    }
-    .suite-header {
-      padding: 12px 16px; display: flex; justify-content: space-between;
-      align-items: center; cursor: pointer; user-select: none;
-    }
-    .suite-header:hover { background: var(--bg-secondary); }
-    .suite-header div { display: flex; align-items: center; gap: 8px; }
-    .suite.collapsed .suite-body { display: none; }
-    .suite-file { color: var(--text-secondary); font-size: 12px; }
-    .toggle-icon { font-size: 12px; color: var(--text-secondary); transition: transform 0.2s; }
-    .suite.collapsed .toggle-icon { transform: rotate(-90deg); }
-    .suite-body { border-top: 1px solid var(--border-color); padding: 8px 16px; }
-    .test-item {
-      padding: 8px 0; display: flex; align-items: center; gap: 8px;
-    }
-    .test-item + .test-item { border-top: 1px solid var(--border-color); }
-    .status-dot {
-      width: 8px; height: 8px; border-radius: 50%; flex-shrink: 0;
-    }
-    .status-dot.passed { background: var(--color-passed); }
-    .status-dot.failed { background: var(--color-failed); }
-    .status-dot.skipped { background: var(--color-skipped); }
-    .status-dot.pending { background: var(--text-secondary); }
-    .test-name { flex: 1; }
-    .duration { color: var(--text-secondary); font-size: 13px; }
-    .retries { color: var(--color-skipped); font-size: 12px; }
-    .error-message {
-      background: #fef2f2; color: #991b1b; padding: 12px;
-      border-radius: 4px; font-family: 'Fira Code', monospace;
-      font-size: 13px; margin: 8px 0 8px 16px; white-space: pre-wrap;
-      word-break: break-all;
-    }
-    footer {
-      text-align: center; padding: 20px; color: var(--text-secondary);
-      font-size: 13px; margin-top: 40px;
-    }
-  </style>
-</head>
-<body>
-  <div class="container">
-    <header>
-      <h1>QAT \u6D4B\u8BD5\u62A5\u544A</h1>
-      <div class="meta">\u751F\u6210\u65F6\u95F4: ${formatTimestamp(data.timestamp)} | \u603B\u8017\u65F6: ${formatDuration2(data.duration)}</div>
-    </header>
-
-    <div class="pass-rate">${passRate}%</div>
-    <div class="pass-rate-label">\u6D4B\u8BD5\u901A\u8FC7\u7387</div>
-
-    <div class="summary">
-      <div class="card total">
-        <div class="card-value">${data.summary.total}</div>
-        <div class="card-label">\u603B\u8BA1</div>
-      </div>
-      <div class="card passed">
-        <div class="card-value">${data.summary.passed}</div>
-        <div class="card-label">\u901A\u8FC7</div>
-      </div>
-      <div class="card failed">
-        <div class="card-value">${data.summary.failed}</div>
-        <div class="card-label">\u5931\u8D25</div>
-      </div>
-      <div class="card skipped">
-        <div class="card-value">${data.summary.skipped}</div>
-        <div class="card-label">\u8DF3\u8FC7</div>
-      </div>
-    </div>
-
-    ${Object.keys(data.byType).length > 0 ? `<h2 style="margin-top:30px;margin-bottom:10px;">\u6309\u7C7B\u578B\u7EDF\u8BA1</h2><div class="by-type">${byTypeHTML}</div>` : ""}
-
-    <h2 style="margin-top:30px;margin-bottom:10px;">\u6D4B\u8BD5\u8BE6\u60C5</h2>
-    ${suitesHTML || '<p style="color:var(--text-secondary)">\u6682\u65E0\u6D4B\u8BD5\u7ED3\u679C</p>'}
-
-    <footer>\u7531 QAT \u81EA\u52A8\u5316\u6D4B\u8BD5\u5DE5\u5177\u751F\u6210</footer>
-  </div>
-</body>
-</html>`;
-}
-function writeReportToDisk(data, outputDir) {
-  const html = generateHTMLReport(data);
-  const dir = path12.resolve(outputDir);
-  if (!fs10.existsSync(dir)) {
-    fs10.mkdirSync(dir, { recursive: true });
-  }
-  const indexPath = path12.join(dir, "index.html");
-  fs10.writeFileSync(indexPath, html, "utf-8");
-  return indexPath;
-}
-
-// src/commands/report.ts
 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) => {
@@ -4793,7 +4824,7 @@ async function executeReport(options) {
     console.log(chalk7.gray("\n  \u63D0\u793A: \u5148\u8FD0\u884C qat run \u751F\u6210\u6D4B\u8BD5\u7ED3\u679C\n"));
     return;
   }
-  spinner.text = "\u6B63\u5728\u751F\u6210HTML\u62A5\u544A...";
+  spinner.text = "\u6B63\u5728\u751F\u6210\u6D4B\u8BD5\u62A5\u544A...";
   const reportData = aggregateResults(results);
   const reportPath = writeReportToDisk(reportData, outputDir);
   saveResultToHistory(reportData);
@@ -4806,14 +4837,14 @@ async function executeReport(options) {
 function collectResults() {
   const results = [];
   const resultsPath = path13.join(process.cwd(), RESULTS_DIR2);
-  if (!fs11.existsSync(resultsPath)) {
+  if (!fs12.existsSync(resultsPath)) {
     return results;
   }
-  const files = fs11.readdirSync(resultsPath).filter((f) => f.endsWith(".json")).sort().reverse();
+  const files = fs12.readdirSync(resultsPath).filter((f) => f.endsWith(".json")).sort().reverse();
   if (files.length > 0) {
     const latestFile = path13.join(resultsPath, files[0]);
     try {
-      const data = JSON.parse(fs11.readFileSync(latestFile, "utf-8"));
+      const data = JSON.parse(fs12.readFileSync(latestFile, "utf-8"));
       if (Array.isArray(data)) {
         results.push(...data);
       } else if (data.results) {
@@ -4826,44 +4857,54 @@ function collectResults() {
 }
 function saveResultToHistory(reportData) {
   const resultsPath = path13.join(process.cwd(), RESULTS_DIR2);
-  if (!fs11.existsSync(resultsPath)) {
-    fs11.mkdirSync(resultsPath, { recursive: true });
+  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);
-  fs11.writeFileSync(filePath, JSON.stringify(reportData, null, 2), "utf-8");
-  const files = fs11.readdirSync(resultsPath).filter((f) => f.startsWith("result-") && f.endsWith(".json")).sort();
+  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();
-    fs11.unlinkSync(path13.join(resultsPath, oldest));
+    fs12.unlinkSync(path13.join(resultsPath, oldest));
   }
 }
 function displayReportResult(reportPath, data) {
   const relativePath = path13.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();
   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("  \u901A\u8FC7:"), chalk7.green(String(data.summary.passed)));
+  console.log(chalk7.white("  \u2705 \u901A\u8FC7:  "), chalk7.green(String(data.summary.passed)));
   if (data.summary.failed > 0) {
-    console.log(chalk7.white("  \u5931\u8D25:"), chalk7.red(String(data.summary.failed)));
+    console.log(chalk7.white("  \u274C \u5931\u8D25:  "), chalk7.red(String(data.summary.failed)));
   }
   if (data.summary.skipped > 0) {
-    console.log(chalk7.white("  \u8DF3\u8FC7:"), chalk7.yellow(String(data.summary.skipped)));
+    console.log(chalk7.white("  \u23ED\uFE0F \u8DF3\u8FC7:  "), chalk7.yellow(String(data.summary.skipped)));
   }
   if (Object.keys(data.byType).length > 0) {
     console.log();
     console.log(chalk7.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("\u2717") : chalk7.green("\u2713");
+      const icon = stats.failed > 0 ? chalk7.red("\u274C") : chalk7.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();
 }
+function pct2(value) {
+  return `${(value * 100).toFixed(1)}%`;
+}
 async function openReport(reportPath) {
   const { exec } = await import("child_process");
   const platform = process.platform;
@@ -4887,19 +4928,19 @@ import chalk8 from "chalk";
 import ora7 from "ora";
 
 // src/services/visual.ts
-import fs12 from "fs";
+import fs13 from "fs";
 import path14 from "path";
 import pixelmatch from "pixelmatch";
 import { PNG } from "pngjs";
 function compareImages(baselinePath, currentPath, diffOutputPath, threshold = 0.1) {
-  if (!fs12.existsSync(baselinePath)) {
+  if (!fs13.existsSync(baselinePath)) {
     throw new Error(`\u57FA\u7EBF\u56FE\u7247\u4E0D\u5B58\u5728: ${baselinePath}`);
   }
-  if (!fs12.existsSync(currentPath)) {
+  if (!fs13.existsSync(currentPath)) {
     throw new Error(`\u5F53\u524D\u56FE\u7247\u4E0D\u5B58\u5728: ${currentPath}`);
   }
-  const baseline = PNG.sync.read(fs12.readFileSync(baselinePath));
-  const current = PNG.sync.read(fs12.readFileSync(currentPath));
+  const baseline = PNG.sync.read(fs13.readFileSync(baselinePath));
+  const current = PNG.sync.read(fs13.readFileSync(currentPath));
   if (baseline.width !== current.width || baseline.height !== current.height) {
     return {
       passed: false,
@@ -4928,10 +4969,10 @@ function compareImages(baselinePath, currentPath, diffOutputPath, threshold = 0.
   let diffPath;
   if (diffPixels > 0) {
     const diffDir = path14.dirname(diffOutputPath);
-    if (!fs12.existsSync(diffDir)) {
-      fs12.mkdirSync(diffDir, { recursive: true });
+    if (!fs13.existsSync(diffDir)) {
+      fs13.mkdirSync(diffDir, { recursive: true });
     }
-    fs12.writeFileSync(diffOutputPath, PNG.sync.write(diff));
+    fs13.writeFileSync(diffOutputPath, PNG.sync.write(diff));
     diffPath = diffOutputPath;
   }
   return {
@@ -4945,69 +4986,69 @@ function compareImages(baselinePath, currentPath, diffOutputPath, threshold = 0.
   };
 }
 function createBaseline(currentPath, baselinePath) {
-  if (!fs12.existsSync(currentPath)) {
+  if (!fs13.existsSync(currentPath)) {
     throw new Error(`\u5F53\u524D\u622A\u56FE\u4E0D\u5B58\u5728: ${currentPath}`);
   }
   const baselineDir = path14.dirname(baselinePath);
-  if (!fs12.existsSync(baselineDir)) {
-    fs12.mkdirSync(baselineDir, { recursive: true });
+  if (!fs13.existsSync(baselineDir)) {
+    fs13.mkdirSync(baselineDir, { recursive: true });
   }
-  fs12.copyFileSync(currentPath, baselinePath);
+  fs13.copyFileSync(currentPath, baselinePath);
   return baselinePath;
 }
 function updateAllBaselines(currentDir, baselineDir) {
   const updated = [];
-  if (!fs12.existsSync(currentDir)) {
+  if (!fs13.existsSync(currentDir)) {
     return updated;
   }
-  const files = fs12.readdirSync(currentDir).filter((f) => f.endsWith(".png"));
+  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);
-    if (!fs12.existsSync(baselineDirAbs)) {
-      fs12.mkdirSync(baselineDirAbs, { recursive: true });
+    if (!fs13.existsSync(baselineDirAbs)) {
+      fs13.mkdirSync(baselineDirAbs, { recursive: true });
     }
-    fs12.copyFileSync(currentPath, baselinePath);
+    fs13.copyFileSync(currentPath, baselinePath);
     updated.push(file);
   }
   return updated;
 }
 function cleanBaselines(baselineDir) {
-  if (!fs12.existsSync(baselineDir)) {
+  if (!fs13.existsSync(baselineDir)) {
     return 0;
   }
-  const files = fs12.readdirSync(baselineDir).filter((f) => f.endsWith(".png"));
+  const files = fs13.readdirSync(baselineDir).filter((f) => f.endsWith(".png"));
   let count = 0;
   for (const file of files) {
-    fs12.unlinkSync(path14.join(baselineDir, file));
+    fs13.unlinkSync(path14.join(baselineDir, file));
     count++;
   }
   return count;
 }
 function cleanDiffs(diffDir) {
-  if (!fs12.existsSync(diffDir)) {
+  if (!fs13.existsSync(diffDir)) {
     return 0;
   }
-  const files = fs12.readdirSync(diffDir).filter((f) => f.endsWith(".png"));
+  const files = fs13.readdirSync(diffDir).filter((f) => f.endsWith(".png"));
   let count = 0;
   for (const file of files) {
-    fs12.unlinkSync(path14.join(diffDir, file));
+    fs13.unlinkSync(path14.join(diffDir, file));
     count++;
   }
   return count;
 }
 function compareDirectories(baselineDir, currentDir, diffDir, threshold = 0.1) {
   const results = [];
-  if (!fs12.existsSync(currentDir)) {
+  if (!fs13.existsSync(currentDir)) {
     return results;
   }
-  const currentFiles = fs12.readdirSync(currentDir).filter((f) => f.endsWith(".png"));
+  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);
-    if (!fs12.existsSync(baselinePath)) {
+    if (!fs13.existsSync(baselinePath)) {
       createBaseline(currentPath, baselinePath);
       results.push({
         passed: true,
@@ -5039,7 +5080,7 @@ function compareDirectories(baselineDir, currentDir, diffDir, threshold = 0.1) {
 }
 
 // src/commands/visual.ts
-import fs13 from "fs";
+import fs14 from "fs";
 import path15 from "path";
 function registerVisualCommand(program2) {
   program2.command("visual").description("\u89C6\u89C9\u56DE\u5F52\u6D4B\u8BD5 - \u622A\u56FE\u6BD4\u5BF9\u4E0E\u57FA\u7EBF\u7BA1\u7406").argument("<action>", "\u64CD\u4F5C\u7C7B\u578B (test|approve|clean)").option("--threshold <number>", "\u50CF\u7D20\u5DEE\u5F02\u9608\u503C (0-1)", "0.1").action(async (action, options) => {
@@ -5120,7 +5161,7 @@ function findCurrentScreenshotsDir(baselineDir) {
     path15.join(process.cwd(), baselineDir, "..", "current")
   ];
   for (const dir of possibleDirs) {
-    if (fs13.existsSync(dir)) {
+    if (fs14.existsSync(dir)) {
       const pngs = findPngFiles(dir);
       if (pngs.length > 0) return dir;
     }
@@ -5130,8 +5171,8 @@ function findCurrentScreenshotsDir(baselineDir) {
 function findPngFiles(dir) {
   const files = [];
   function walk(d) {
-    if (!fs13.existsSync(d)) return;
-    const entries = fs13.readdirSync(d, { withFileTypes: true });
+    if (!fs14.existsSync(d)) return;
+    const entries = fs14.readdirSync(d, { withFileTypes: true });
     for (const entry of entries) {
       const fullPath = path15.join(d, entry.name);
       if (entry.isDirectory() && entry.name !== "node_modules") {
@@ -5229,7 +5270,7 @@ import chalk9 from "chalk";
 import inquirer4 from "inquirer";
 import ora8 from "ora";
 import { execFile as execFile4 } from "child_process";
-import fs14 from "fs";
+import fs15 from "fs";
 import path16 from "path";
 var DEPENDENCY_GROUPS = [
   {
@@ -5264,7 +5305,7 @@ function registerSetupCommand(program2) {
 async function executeSetup(options) {
   console.log(chalk9.cyan("\n  QAT \u4F9D\u8D56\u5B89\u88C5\u5668\n"));
   const projectInfo = detectProject();
-  if (!fs14.existsSync(path16.join(process.cwd(), "package.json"))) {
+  if (!fs15.existsSync(path16.join(process.cwd(), "package.json"))) {
     throw new Error("\u672A\u627E\u5230 package.json\uFF0C\u8BF7\u5728\u9879\u76EE\u6839\u76EE\u5F55\u6267\u884C\u6B64\u547D\u4EE4");
   }
   if (projectInfo.frameworkConfidence > 0) {
@@ -5299,7 +5340,7 @@ async function executeSetup(options) {
     ]);
     if (chooseDir !== "root") {
       installDir = path16.join(process.cwd(), chooseDir);
-      if (!fs14.existsSync(path16.join(installDir, "package.json"))) {
+      if (!fs15.existsSync(path16.join(installDir, "package.json"))) {
         throw new Error(`${chooseDir} \u4E0B\u6CA1\u6709 package.json`);
       }
     }
@@ -5619,7 +5660,7 @@ async function executeChange(_options) {
 }
 
 // src/cli.ts
-var VERSION = "0.2.98";
+var VERSION = "0.3.02";
 function printLogo() {
   const logo = `
   ${chalk12.bold.cyan("   ___            _          _           _              _               _____                _     _                 ")}