qat-cli 0.2.98 → 0.3.2

package/dist/index.js

@@ -1374,6 +1374,7 @@ function aggregateResults(results) {
     pending: 0
   };
   const byType = {};
+  let coverage;
   for (const result of results) {
     const typeKey = result.type;
     if (!byType[typeKey]) {
@@ -1397,6 +1398,16 @@ function aggregateResults(results) {
         }
       }
     }
+    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 {
@@ -1404,7 +1415,8 @@ function aggregateResults(results) {
     duration: totalDuration,
     results,
     summary,
-    byType
+    byType,
+    coverage: coverage?.lines ? coverage : void 0
   };
 }
 function formatDuration(ms) {
@@ -1424,56 +1436,149 @@ function formatTimestamp(ts) {
     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 ? `
+function pct(value) {
+  return `${(value * 100).toFixed(1)}%`;
+}
+function renderCoverageMD(coverage) {
+  return `
+### \u8986\u76D6\u7387
 
-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">${formatDuration(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">${formatDuration(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;");
+| \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("");
+      }
+    }
+  }
+  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 writeReportToDisk(data, outputDir) {
+  const md = generateMDReport(data);
+  const dir = path4.resolve(outputDir);
+  if (!fs5.existsSync(dir)) {
+    fs5.mkdirSync(dir, { recursive: true });
+  }
+  const mdPath = path4.join(dir, "report.md");
+  fs5.writeFileSync(mdPath, md, "utf-8");
+  const jsonPath = path4.join(dir, "report.json");
+  fs5.writeFileSync(jsonPath, JSON.stringify(data, null, 2), "utf-8");
+  return mdPath;
 }
 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");
+  const md = generateMDReport(data);
+  const html = md.replace(/^### (.+)$/gm, "<h3>$1</h3>").replace(/^## (.+)$/gm, "<h2>$1</h2>").replace(/^# (.+)$/gm, "<h1>$1</h1>").replace(/^> (.+)$/gm, "<blockquote>$1</blockquote>").replace(/\*\*(.+?)\*\*/g, "<strong>$1</strong>").replace(/`([^`]+)`/g, "<code>$1</code>").replace(/^---$/gm, "<hr>").replace(/\|(.+)\|/g, (match) => {
+    const cells = match.split("|").filter(Boolean).map((c) => c.trim());
+    if (cells.every((c) => c.startsWith("-") || c === "")) return "";
+    const tds = cells.map((c) => `<td>${c}</td>`).join("");
+    return `<tr>${tds}</tr>`;
+  }).replace(/<tr>/g, "<table><tr>").replace(/<\/tr>(?!\s*<table>)/g, "</tr></table>").replace(/<\/table>\s*<table>/g, "").replace(/^✅/gm, '<span style="color:#22c55e">\u2705</span>').replace(/^❌/gm, '<span style="color:#ef4444">\u274C</span>').replace(/^⚠️/gm, '<span style="color:#f59e0b">\u26A0\uFE0F</span>');
   return `<!DOCTYPE html>
 <html lang="zh-CN">
 <head>
@@ -1481,162 +1586,60 @@ function generateHTMLReport(data) {
   <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;
-    }
+      max-width: 960px; margin: 0 auto; padding: 20px;
+      background: #f8fafc; color: #1e293b; line-height: 1.6;
+    }
+    h1 { border-bottom: 2px solid #3b82f6; padding-bottom: 8px; }
+    h2 { margin-top: 24px; color: #1e40af; }
+    h3 { margin-top: 16px; color: #334155; }
+    h4 { margin-top: 12px; color: #475569; }
+    blockquote { color: #64748b; border-left: 3px solid #cbd5e1; padding-left: 12px; margin: 8px 0; }
+    table { border-collapse: collapse; width: 100%; margin: 12px 0; }
+    td, th { border: 1px solid #e2e8f0; padding: 8px 12px; text-align: left; }
+    tr:nth-child(even) { background: #f1f5f9; }
+    code { background: #e2e8f0; padding: 2px 6px; border-radius: 3px; font-size: 0.9em; }
+    pre { background: #1e293b; color: #e2e8f0; padding: 16px; border-radius: 8px; overflow-x: auto; }
+    pre code { background: none; padding: 0; }
+    hr { border: none; border-top: 1px solid #e2e8f0; margin: 24px 0; }
+    details { margin: 8px 0; }
+    summary { cursor: pointer; color: #ef4444; font-weight: 600; }
+    strong { color: #1e293b; }
+    .pass-rate { font-size: 48px; font-weight: 700; text-align: center; margin: 20px 0;
+      color: ${parseFloat(passRate) >= 80 ? "#22c55e" : parseFloat(passRate) >= 50 ? "#f59e0b" : "#ef4444"};
+    }
+    .pass-rate-label { text-align: center; color: #64748b; margin-bottom: 20px; }
   </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: ${formatDuration(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>
+  <div class="pass-rate">${passRate}%</div>
+  <div class="pass-rate-label">\u6D4B\u8BD5\u901A\u8FC7\u7387</div>
+  ${html}
 </body>
 </html>`;
 }
-function writeReportToDisk(data, outputDir) {
-  const html = generateHTMLReport(data);
-  const dir = path4.resolve(outputDir);
-  if (!fs5.existsSync(dir)) {
-    fs5.mkdirSync(dir, { recursive: true });
-  }
-  const indexPath = path4.join(dir, "index.html");
-  fs5.writeFileSync(indexPath, html, "utf-8");
-  return indexPath;
-}
 
 // src/runners/vitest-runner.ts
 import { execFile } from "child_process";
 import path5 from "path";
+import fs6 from "fs";
+import os from "os";
+var isVerbose = () => process.env.QAT_VERBOSE === "true";
+function debug(label, ...args) {
+  if (isVerbose()) {
+    console.log(`\x1B[90m  [debug:${label}]\x1B[0m`, ...args);
+  }
+}
 async function runVitest(options) {
   const startTime = Date.now();
   const args = buildVitestArgs(options);
+  debug("vitest", "\u547D\u4EE4\u53C2\u6570:", args.join(" "));
   try {
     const result = await execVitest(args);
     const endTime = Date.now();
+    debug("vitest", `\u89E3\u6790\u7ED3\u679C: ${result.suites.length} \u4E2A\u5957\u4EF6, ${result.suites.reduce((s, su) => s + su.tests.length, 0)} \u4E2A\u7528\u4F8B`);
+    debug("vitest", "\u89E3\u6790\u65B9\u5F0F:", result.parseMethod);
     return {
       type: options.type,
       status: result.success ? "passed" : "failed",
@@ -1701,83 +1704,228 @@ function buildVitestArgs(options) {
   return args;
 }
 async function execVitest(args) {
+  const tmpFile = path5.join(os.tmpdir(), `qat-vitest-result-${Date.now()}.json`);
+  const argsWithOutput = [...args, "--outputFile", tmpFile];
   return new Promise((resolve, reject) => {
     const npx = process.platform === "win32" ? "npx.cmd" : "npx";
-    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 (fs6.existsSync(tmpFile)) {
+          jsonResult = fs6.readFileSync(tmpFile, "utf-8");
+          debug("vitest", `\u4ECE\u4E34\u65F6\u6587\u4EF6\u8BFB\u53D6\u5230 JSON (${jsonResult.length} \u5B57\u7B26)`);
+          debug("vitest", "JSON \u524D 500 \u5B57\u7B26:", jsonResult.substring(0, 500));
+          fs6.unlinkSync(tmpFile);
         } else {
-          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 {
+        fs6.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: path5.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: path5.basename(fileResult.name || fileResult.assertionResults?.[0]?.ancestorTitles?.[0] || "unknown"),
+        suites.push({
+          name: path5.basename(fileResult.name || "unknown"),
           file: fileResult.name || "unknown",
           type: "unit",
           status: mapVitestStatus(fileResult.status),
           duration: fileResult.duration || 0,
-          tests: (fileResult.assertionResults || []).map((assertion) => ({
-            name: assertion.title || assertion.fullName || "unknown",
-            file: fileResult.name || "unknown",
-            status: mapVitestStatus(assertion.status),
-            duration: assertion.duration || 0,
-            error: assertion.failureMessages?.length ? { message: assertion.failureMessages[0] } : void 0,
-            retries: 0
-          }))
-        };
-        suites.push(suite);
+          tests: parseTestResults(fileResult)
+        });
       }
     }
-    let coverage;
-    if (data.coverageMap) {
-      coverage = extractCoverage(data.coverageMap);
-    }
     const success = data.success !== false && suites.every((s) => s.status !== "failed");
+    let coverage;
+    if (data.coverageMap) coverage = extractCoverage(data.coverageMap);
     return { success, suites, coverage };
-  } catch {
-    return parseVitestTextOutput(output, false);
   }
+  const anyJsonMatch = output.match(/\{[\s\S]*"numTotalTests"[\s\S]*\}/);
+  if (anyJsonMatch) {
+    return parseVitestJSON(anyJsonMatch[0]);
+  }
+  throw new Error("stdout \u4E2D\u672A\u627E\u5230\u6709\u6548 JSON");
 }
 function parseVitestTextOutput(output, hasError) {
   const suites = [];
+  debug("vitest-text", "\u6587\u672C\u8F93\u51FA\u524D 1000 \u5B57\u7B26:", output.substring(0, 1e3));
+  const suiteRegex = /[✓✗×✕]\s+(.+\.test\.(ts|js)|.+\.spec\.(ts|js))\s*\((\d+)[^)]*\)/i;
+  const lines = output.split("\n");
   let totalPassed = 0;
   let totalFailed = 0;
-  const suiteRegex = /[✓✗×]\s+(.+\.test\.ts|.+\.spec\.ts)\s*\((\d+)\s+test/i;
-  const lines = output.split("\n");
   for (const line of lines) {
     const match = line.match(suiteRegex);
     if (match) {
       const file = match[1];
-      const testCount = parseInt(match[2], 10);
+      const testCount = parseInt(match[4], 10);
       const isPassed = line.includes("\u2713");
       if (isPassed) totalPassed += testCount;
       else totalFailed += testCount;
@@ -1797,15 +1945,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":
@@ -1813,6 +1985,7 @@ function mapVitestStatus(status) {
     case "skipped":
     case "skip":
     case "pending":
+    case "todo":
       return "skipped";
     default:
       return "pending";
@@ -2749,7 +2922,7 @@ async function testAIConnection(config) {
 }
 
 // src/services/mock-server.ts
-import fs6 from "fs";
+import fs7 from "fs";
 import path7 from "path";
 var serverState = {
   running: false,
@@ -2762,18 +2935,18 @@ function getMockServerState() {
 }
 async function loadMockRoutes(routesDir) {
   const absDir = path7.resolve(process.cwd(), routesDir);
-  if (!fs6.existsSync(absDir)) {
+  if (!fs7.existsSync(absDir)) {
     return [];
   }
   const routes = [];
-  const entries = fs6.readdirSync(absDir, { withFileTypes: true });
+  const entries = fs7.readdirSync(absDir, { withFileTypes: true });
   for (const entry of entries) {
     if (!entry.isFile()) continue;
     const filePath = path7.join(absDir, entry.name);
     const ext = path7.extname(entry.name);
     try {
       if (ext === ".json") {
-        const content = fs6.readFileSync(filePath, "utf-8");
+        const content = fs7.readFileSync(filePath, "utf-8");
         const parsed = JSON.parse(content);
         if (Array.isArray(parsed)) {
           routes.push(...parsed);
@@ -2965,11 +3138,11 @@ function generateMockRouteTemplate(name) {
 }
 function initMockRoutesDir(routesDir) {
   const absDir = path7.resolve(process.cwd(), routesDir);
-  if (!fs6.existsSync(absDir)) {
-    fs6.mkdirSync(absDir, { recursive: true });
+  if (!fs7.existsSync(absDir)) {
+    fs7.mkdirSync(absDir, { recursive: true });
   }
   const examplePath = path7.join(absDir, "example.json");
-  if (!fs6.existsSync(examplePath)) {
+  if (!fs7.existsSync(examplePath)) {
     const exampleRoutes = [
       {
         method: "GET",
@@ -2993,24 +3166,24 @@ function initMockRoutesDir(routesDir) {
         }
       }
     ];
-    fs6.writeFileSync(examplePath, JSON.stringify(exampleRoutes, null, 2), "utf-8");
+    fs7.writeFileSync(examplePath, JSON.stringify(exampleRoutes, null, 2), "utf-8");
   }
 }
 
 // src/services/visual.ts
-import fs7 from "fs";
+import fs8 from "fs";
 import path8 from "path";
 import pixelmatch from "pixelmatch";
 import { PNG } from "pngjs";
 function compareImages(baselinePath, currentPath, diffOutputPath, threshold = 0.1) {
-  if (!fs7.existsSync(baselinePath)) {
+  if (!fs8.existsSync(baselinePath)) {
     throw new Error(`\u57FA\u7EBF\u56FE\u7247\u4E0D\u5B58\u5728: ${baselinePath}`);
   }
-  if (!fs7.existsSync(currentPath)) {
+  if (!fs8.existsSync(currentPath)) {
     throw new Error(`\u5F53\u524D\u56FE\u7247\u4E0D\u5B58\u5728: ${currentPath}`);
   }
-  const baseline = PNG.sync.read(fs7.readFileSync(baselinePath));
-  const current = PNG.sync.read(fs7.readFileSync(currentPath));
+  const baseline = PNG.sync.read(fs8.readFileSync(baselinePath));
+  const current = PNG.sync.read(fs8.readFileSync(currentPath));
   if (baseline.width !== current.width || baseline.height !== current.height) {
     return {
       passed: false,
@@ -3039,10 +3212,10 @@ function compareImages(baselinePath, currentPath, diffOutputPath, threshold = 0.
   let diffPath;
   if (diffPixels > 0) {
     const diffDir = path8.dirname(diffOutputPath);
-    if (!fs7.existsSync(diffDir)) {
-      fs7.mkdirSync(diffDir, { recursive: true });
+    if (!fs8.existsSync(diffDir)) {
+      fs8.mkdirSync(diffDir, { recursive: true });
     }
-    fs7.writeFileSync(diffOutputPath, PNG.sync.write(diff));
+    fs8.writeFileSync(diffOutputPath, PNG.sync.write(diff));
     diffPath = diffOutputPath;
   }
   return {
@@ -3056,14 +3229,14 @@ function compareImages(baselinePath, currentPath, diffOutputPath, threshold = 0.
   };
 }
 function createBaseline(currentPath, baselinePath) {
-  if (!fs7.existsSync(currentPath)) {
+  if (!fs8.existsSync(currentPath)) {
     throw new Error(`\u5F53\u524D\u622A\u56FE\u4E0D\u5B58\u5728: ${currentPath}`);
   }
   const baselineDir = path8.dirname(baselinePath);
-  if (!fs7.existsSync(baselineDir)) {
-    fs7.mkdirSync(baselineDir, { recursive: true });
+  if (!fs8.existsSync(baselineDir)) {
+    fs8.mkdirSync(baselineDir, { recursive: true });
   }
-  fs7.copyFileSync(currentPath, baselinePath);
+  fs8.copyFileSync(currentPath, baselinePath);
   return baselinePath;
 }
 function updateBaseline(currentPath, baselinePath) {
@@ -3071,69 +3244,69 @@ function updateBaseline(currentPath, baselinePath) {
 }
 function updateAllBaselines(currentDir, baselineDir) {
   const updated = [];
-  if (!fs7.existsSync(currentDir)) {
+  if (!fs8.existsSync(currentDir)) {
     return updated;
   }
-  const files = fs7.readdirSync(currentDir).filter((f) => f.endsWith(".png"));
+  const files = fs8.readdirSync(currentDir).filter((f) => f.endsWith(".png"));
   for (const file of files) {
     const currentPath = path8.join(currentDir, file);
     const baselinePath = path8.join(baselineDir, file);
     const baselineDirAbs = path8.dirname(baselinePath);
-    if (!fs7.existsSync(baselineDirAbs)) {
-      fs7.mkdirSync(baselineDirAbs, { recursive: true });
+    if (!fs8.existsSync(baselineDirAbs)) {
+      fs8.mkdirSync(baselineDirAbs, { recursive: true });
     }
-    fs7.copyFileSync(currentPath, baselinePath);
+    fs8.copyFileSync(currentPath, baselinePath);
     updated.push(file);
   }
   return updated;
 }
 function cleanBaselines(baselineDir) {
-  if (!fs7.existsSync(baselineDir)) {
+  if (!fs8.existsSync(baselineDir)) {
     return 0;
   }
-  const files = fs7.readdirSync(baselineDir).filter((f) => f.endsWith(".png"));
+  const files = fs8.readdirSync(baselineDir).filter((f) => f.endsWith(".png"));
   let count = 0;
   for (const file of files) {
-    fs7.unlinkSync(path8.join(baselineDir, file));
+    fs8.unlinkSync(path8.join(baselineDir, file));
     count++;
   }
   return count;
 }
 function cleanDiffs(diffDir) {
-  if (!fs7.existsSync(diffDir)) {
+  if (!fs8.existsSync(diffDir)) {
     return 0;
   }
-  const files = fs7.readdirSync(diffDir).filter((f) => f.endsWith(".png"));
+  const files = fs8.readdirSync(diffDir).filter((f) => f.endsWith(".png"));
   let count = 0;
   for (const file of files) {
-    fs7.unlinkSync(path8.join(diffDir, file));
+    fs8.unlinkSync(path8.join(diffDir, file));
     count++;
   }
   return count;
 }
 function listBaselines(baselineDir) {
-  if (!fs7.existsSync(baselineDir)) {
+  if (!fs8.existsSync(baselineDir)) {
     return [];
   }
-  return fs7.readdirSync(baselineDir).filter((f) => f.endsWith(".png")).sort();
+  return fs8.readdirSync(baselineDir).filter((f) => f.endsWith(".png")).sort();
 }
 function listDiffs(diffDir) {
-  if (!fs7.existsSync(diffDir)) {
+  if (!fs8.existsSync(diffDir)) {
     return [];
   }
-  return fs7.readdirSync(diffDir).filter((f) => f.endsWith(".png")).sort();
+  return fs8.readdirSync(diffDir).filter((f) => f.endsWith(".png")).sort();
 }
 function compareDirectories(baselineDir, currentDir, diffDir, threshold = 0.1) {
   const results = [];
-  if (!fs7.existsSync(currentDir)) {
+  if (!fs8.existsSync(currentDir)) {
     return results;
   }
-  const currentFiles = fs7.readdirSync(currentDir).filter((f) => f.endsWith(".png"));
+  const currentFiles = fs8.readdirSync(currentDir).filter((f) => f.endsWith(".png"));
   for (const file of currentFiles) {
     const currentPath = path8.join(currentDir, file);
     const baselinePath = path8.join(baselineDir, file);
     const diffPath = path8.join(diffDir, file);
-    if (!fs7.existsSync(baselinePath)) {
+    if (!fs8.existsSync(baselinePath)) {
       createBaseline(currentPath, baselinePath);
       results.push({
         passed: true,
@@ -3165,14 +3338,14 @@ function compareDirectories(baselineDir, currentDir, diffDir, threshold = 0.1) {
 }
 
 // src/services/source-analyzer.ts
-import fs8 from "fs";
+import fs9 from "fs";
 import path9 from "path";
 function analyzeFile(filePath) {
   const absolutePath = path9.resolve(process.cwd(), filePath);
-  if (!fs8.existsSync(absolutePath)) {
+  if (!fs9.existsSync(absolutePath)) {
     return { filePath, exports: [], apiCalls: [] };
   }
-  const content = fs8.readFileSync(absolutePath, "utf-8");
+  const content = fs9.readFileSync(absolutePath, "utf-8");
   const ext = path9.extname(filePath);
   const result = {
     filePath,
@@ -3527,13 +3700,13 @@ function cleanTemplateUrl(url) {
 }
 function scanAPICalls(srcDir) {
   const absDir = path9.resolve(process.cwd(), srcDir);
-  if (!fs8.existsSync(absDir)) {
+  if (!fs9.existsSync(absDir)) {
     return [];
   }
   const allCalls = [];
   const seen = /* @__PURE__ */ new Set();
   function walk(dir) {
-    const entries = fs8.readdirSync(dir, { withFileTypes: true });
+    const entries = fs9.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "dist") continue;
       const fullPath = path9.join(dir, entry.name);
@@ -3541,7 +3714,7 @@ function scanAPICalls(srcDir) {
         walk(fullPath);
       } else if (entry.isFile() && /\.(ts|js|vue|mjs)$/.test(entry.name)) {
         try {
-          const content = fs8.readFileSync(fullPath, "utf-8");
+          const content = fs9.readFileSync(fullPath, "utf-8");
           const calls = extractAPICalls(content, path9.relative(process.cwd(), fullPath));
           for (const call of calls) {
             const key = `${call.method}:${call.url}`;