qat-cli 0.3.5 → 0.3.7

package/README.md

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

package/dist/cli.js

@@ -787,6 +787,37 @@ function debugLog(tag, ...args) {
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().slice(11, 19);
   console.error(chalk2.gray(`[DEBUG ${timestamp}] [${tag}]`), ...args);
 }
+var ConcurrencyPool = class {
+  constructor(maxConcurrency) {
+    this.maxConcurrency = maxConcurrency;
+    this.running = 0;
+    this.queue = [];
+  }
+  async acquire() {
+    if (this.running < this.maxConcurrency) {
+      this.running++;
+      return;
+    }
+    return new Promise((resolve) => {
+      this.queue.push({ resolve });
+    });
+  }
+  release() {
+    this.running--;
+    const next = this.queue.shift();
+    if (next) {
+      this.running++;
+      next.resolve();
+    }
+  }
+  get pending() {
+    return this.queue.length;
+  }
+  get active() {
+    return this.running;
+  }
+};
+var aiPool = new ConcurrencyPool(3);
 var OpenAICompatibleProvider = class {
   constructor(config) {
     this.capabilities = {
@@ -902,9 +933,34 @@ ${errorDetails}`;
       return { ok: false, message: `\u8FDE\u63A5\u5931\u8D25: ${error instanceof Error ? error.message : String(error)}`, latencyMs };
     }
   }
+  /**
+   * 核心 chat 方法
+   *
+   * 调度策略：
+   * 1. 始终使用流式（stream: true），避免长时间等待无响应导致超时
+   * 2. 分段超时：连接/首chunk/后续chunk 各自独立超时，只要 AI 在输出就不超时
+   * 3. 并发池控制：acquire → 请求 → release，避免同时太多请求
+   * 4. 指数退避重试：429/5xx/timeout 自动重试，最多 2 次
+   */
   async chat(systemPrompt, userPrompt, retries = 2) {
+    await aiPool.acquire();
+    try {
+      return await this._chatInner(systemPrompt, userPrompt, retries);
+    } finally {
+      aiPool.release();
+    }
+  }
+  async _chatInner(systemPrompt, userPrompt, retries) {
     const url = `${this.baseUrl}/chat/completions`;
-    const useStream = isDebug();
+    const TIMEOUT = {
+      /** 连接建立超时：fetch 请求本身的最大等待时间 */
+      CONNECT: 15e3,
+      /** 首个 chunk 超时：连接建好后等待 AI 开始输出的时间 */
+      FIRST_CHUNK: 3e4,
+      /** chunk 间超时：每个 chunk 之间的最大间隔 */
+      CHUNK_INTERVAL: 2e4
+    };
+    debugLog("SCHEDULER", `\u5E76\u53D1\u6C60: active=${aiPool.active} pending=${aiPool.pending} \u5206\u6BB5\u8D85\u65F6: connect=${TIMEOUT.CONNECT / 1e3}s first=${TIMEOUT.FIRST_CHUNK / 1e3}s interval=${TIMEOUT.CHUNK_INTERVAL / 1e3}s`);
     const body = {
       model: this.model,
       messages: [
@@ -912,19 +968,16 @@ ${errorDetails}`;
         { role: "user", content: userPrompt }
       ],
       temperature: 0.3,
-      max_tokens: 4096
+      max_tokens: 4096,
+      stream: true
     };
-    if (useStream) {
-      body.stream = true;
-    }
     const headers = {
       "Content-Type": "application/json"
     };
     if (this.apiKey) {
       headers["Authorization"] = `Bearer ${this.apiKey}`;
     }
-    debugLog("REQUEST", `POST ${url}`);
-    debugLog("REQUEST", `model=${this.model} stream=${useStream}`);
+    debugLog("REQUEST", `POST ${url} model=${this.model} stream=true`);
     debugLog("SYSTEM", systemPrompt.length > 500 ? `${systemPrompt.slice(0, 500)}...` : systemPrompt);
     debugLog("USER", userPrompt.length > 1e3 ? `${userPrompt.slice(0, 1e3)}...` : userPrompt);
     let lastError = null;
@@ -933,12 +986,12 @@ ${errorDetails}`;
         if (attempt > 0) {
           debugLog("RETRY", `\u7B2C${attempt}\u6B21\u91CD\u8BD5...`);
         }
+        const connectStart = Date.now();
         const response = await fetch(url, {
           method: "POST",
           headers,
           body: JSON.stringify(body),
-          signal: AbortSignal.timeout(12e4)
-          // 120s timeout
+          signal: AbortSignal.timeout(TIMEOUT.CONNECT)
         });
         if (!response.ok) {
           const text = await response.text().catch(() => "");
@@ -951,17 +1004,21 @@ ${errorDetails}`;
           }
           throw new Error(`AI API \u8BF7\u6C42\u5931\u8D25 (${response.status}): ${text.slice(0, 500)}`);
         }
-        if (useStream && response.body) {
-          const content = await this.readStream(response.body);
-          debugLog("RESPONSE", content.length > 500 ? `${content.slice(0, 500)}...` : content);
+        const connectMs = Date.now() - connectStart;
+        debugLog("CONNECT", `\u8FDE\u63A5\u5EFA\u7ACB ${connectMs}ms`);
+        if (response.body) {
+          const content = await this.readStreamWithTimeout(
+            response.body,
+            TIMEOUT.FIRST_CHUNK,
+            TIMEOUT.CHUNK_INTERVAL
+          );
+          debugLog("RESPONSE", `${content.length} chars, \u603B\u8017\u65F6 ${Date.now() - connectStart}ms`);
           return content;
         }
         const data = await response.json();
         if (!data.choices?.[0]?.message?.content) {
           throw new Error("AI API \u8FD4\u56DE\u7A7A\u54CD\u5E94");
         }
-        debugLog("RESPONSE", `tokens: prompt=${data.usage?.prompt_tokens} completion=${data.usage?.completion_tokens} total=${data.usage?.total_tokens}`);
-        debugLog("RESPONSE", data.choices[0].message.content.length > 500 ? `${data.choices[0].message.content.slice(0, 500)}...` : data.choices[0].message.content);
         return data.choices[0].message.content;
       } catch (error) {
         if (error instanceof Error && error.name === "TimeoutError" && attempt < retries) {
@@ -975,18 +1032,53 @@ ${errorDetails}`;
     throw lastError || new Error("AI API \u8BF7\u6C42\u5931\u8D25");
   }
   /**
-   * 读取 SSE 流式响应，实时输出内容
+   * 分段超时的流式读取
+   *
+   * 核心思路：每个 chunk 独立超时，只要 AI 持续输出就永远不会超时
+   *
+   * 三级超时：
+   * - firstChunkTimeout: 连接建立后等待首个 AI 输出的超时（AI 思考时间）
+   * - chunkIntervalTimeout: 每个 chunk 之间的超时（网络中断检测）
+   * - 每个 read() 操作独立计时，收到 chunk 立即重置
    */
-  async readStream(body) {
+  async readStreamWithTimeout(body, firstChunkTimeout, chunkIntervalTimeout) {
     const chunks = [];
     const decoder = new TextDecoder();
     const reader = body.getReader();
     let buffer = "";
-    let lineCount = 0;
+    let isFirstChunk = true;
+    let lastChunkTime = Date.now();
     try {
       while (true) {
-        const { done, value } = await reader.read();
+        const currentTimeout = isFirstChunk ? firstChunkTimeout : chunkIntervalTimeout;
+        const elapsed = Date.now() - lastChunkTime;
+        if (elapsed > currentTimeout) {
+          const phase = isFirstChunk ? "\u9996chunk" : "chunk\u95F4";
+          debugLog("STREAM-TIMEOUT", `${phase}\u8D85\u65F6(${currentTimeout / 1e3}s)\uFF0C\u5DF2\u6536 ${chunks.length} chunks`);
+          if (chunks.length > 0) {
+            debugLog("STREAM-TIMEOUT", `\u5DF2\u6709\u5185\u5BB9\uFF0C\u8FD4\u56DE\u5DF2\u6536\u5230\u7684 ${chunks.join("").length} chars`);
+            break;
+          }
+          throw new Error(`AI \u6D41\u5F0F\u54CD\u5E94${phase}\u8D85\u65F6(${currentTimeout / 1e3}s)`);
+        }
+        const remainingMs = currentTimeout - elapsed;
+        let readResult;
+        try {
+          readResult = await Promise.race([
+            reader.read(),
+            new Promise(
+              (_, reject) => setTimeout(() => reject(new Error("__CHUNK_TIMEOUT__")), remainingMs)
+            )
+          ]);
+        } catch (e) {
+          if (e instanceof Error && e.message === "__CHUNK_TIMEOUT__") {
+            continue;
+          }
+          throw e;
+        }
+        const { done, value } = readResult;
         if (done) break;
+        lastChunkTime = Date.now();
         buffer += decoder.decode(value, { stream: true });
         const lines = buffer.split("\n");
         buffer = lines.pop() || "";
@@ -998,11 +1090,13 @@ ${errorDetails}`;
             const json = JSON.parse(trimmed.slice(6));
             const delta = json.choices?.[0]?.delta?.content;
             if (delta) {
+              if (isFirstChunk) {
+                isFirstChunk = false;
+                debugLog("STREAM", `\u9996chunk\u5230\u8FBE ${Date.now() - lastChunkTime}ms`);
+              }
               chunks.push(delta);
-              lineCount++;
-              process.stderr.write(chalk2.gray(delta));
-              if (lineCount % 20 === 0) {
-                process.stderr.write("\n");
+              if (isDebug()) {
+                process.stderr.write(chalk2.gray(delta));
               }
             }
             if (json.choices?.[0]?.finish_reason === "stop") {
@@ -1015,7 +1109,7 @@ ${errorDetails}`;
     } finally {
       reader.releaseLock();
     }
-    if (chunks.length > 0) {
+    if (isDebug() && chunks.length > 0) {
       process.stderr.write("\n");
     }
     return chunks.join("");
@@ -1156,6 +1250,8 @@ ${this.compressSourceCode(req.context, 3e3, importPathRewrites)}
     if (srcDirMatch) {
       variations.add(`@/${srcDirMatch[1]}`);
       variations.add(`@/${srcDirMatch[1].replace(/\.(ts|js|tsx|jsx)$/, "")}`);
+      variations.add(`#/${srcDirMatch[1]}`);
+      variations.add(`#/${srcDirMatch[1].replace(/\.(ts|js|tsx|jsx)$/, "")}`);
     }
     const pathParts = targetPath.replace(/^\.\//, "").split("/");
     const fileName = pathParts[pathParts.length - 1];
@@ -1890,7 +1986,7 @@ function extractImports(content) {
 function analyzeImportSignatures(imports, baseDir) {
   const signatures = [];
   for (const imp of imports) {
-    if (!imp.source.startsWith(".") && !imp.source.startsWith("@/") && !imp.source.startsWith("~")) {
+    if (!imp.source.startsWith(".") && !imp.source.startsWith("@/") && !imp.source.startsWith("#/") && !imp.source.startsWith("~")) {
       continue;
     }
     const resolvedPath = resolveImportPath(imp.source, baseDir);
@@ -1932,8 +2028,8 @@ function analyzeImportSignatures(imports, baseDir) {
 }
 function resolveImportPath(importSource, baseDir) {
   let resolved;
-  if (importSource.startsWith("@/") || importSource.startsWith("~")) {
-    const relativePath = importSource.replace(/^[@~]\//, "src/");
+  if (importSource.startsWith("@/") || importSource.startsWith("#/") || importSource.startsWith("~")) {
+    const relativePath = importSource.replace(/^[@#~]\//, "src/");
     resolved = path4.resolve(process.cwd(), relativePath);
   } else if (importSource.startsWith(".")) {
     resolved = path4.resolve(baseDir, importSource);
@@ -2718,6 +2814,7 @@ import ora2 from "ora";
 import path8 from "path";
 var MAX_RETRIES = 3;
 var REVIEW_THRESHOLD = 0.6;
+var REVIEW_SKIP_SOURCE_SIZE = 8e3;
 async function generateWithReview(params) {
   const { testType, targetPath, sourceCode, analysis, aiConfig, framework, onAttempt, onProgress } = params;
   const generatorProvider = createAIProvider(aiConfig);
@@ -2732,6 +2829,13 @@ async function generateWithReview(params) {
   let approved = false;
   let attempts = 0;
   const targetName = path8.basename(targetPath);
+  const skipReview = sourceCode.length > REVIEW_SKIP_SOURCE_SIZE;
+  if (skipReview) {
+    onProgress?.(`\u6E90\u7801\u8F83\u5927(${(sourceCode.length / 1024).toFixed(1)}KB)\uFF0C\u8DF3\u8FC7\u5BA1\u8BA1 \u2190 ${targetName}`);
+    if (process.env.QAT_DEBUG === "true") {
+      console.error(chalk4.gray(`[DEBUG] \u6E90\u7801 ${sourceCode.length} chars > ${REVIEW_SKIP_SOURCE_SIZE}\uFF0C\u8DF3\u8FC7\u5BA1\u8BA1\u73AF\u8282`));
+    }
+  }
   for (let i = 0; i < MAX_RETRIES; i++) {
     attempts = i + 1;
     onAttempt?.(attempts, MAX_RETRIES);
@@ -2760,6 +2864,11 @@ ${lastReview.suggestions.map((s) => `- ${s}`).join("\n")}
     currentCode = generateResponse.code;
     currentDescription = generateResponse.description;
     currentConfidence = generateResponse.confidence;
+    if (skipReview) {
+      approved = true;
+      lastReview = { approved: true, score: 0.7, feedback: "\u6E90\u7801\u8F83\u5927\uFF0C\u8DF3\u8FC7\u5BA1\u8BA1", issues: [], suggestions: [] };
+      break;
+    }
     onProgress?.(`\u5BA1\u8BA1\u5BA1\u67E5 \u2190 ${targetName}`);
     if (process.env.QAT_DEBUG === "true") {
       console.error(chalk4.gray(`[DEBUG] \u2500\u2500\u2500 \u5BA1\u8BA1\u5458 AI \u5BA1\u67E5 \u2500\u2500\u2500`));
@@ -2815,6 +2924,61 @@ function printReviewReport(report) {
 }
 
 // src/commands/create.ts
+var MultiProgressBar = class {
+  constructor(labels) {
+    this.lastRenderLines = 0;
+    this.renderScheduled = false;
+    this.labels = labels;
+    this.statuses = labels.map(() => "waiting");
+    this.statusLabels = labels.map(() => "\u7B49\u5F85\u4E2D");
+    this.render();
+  }
+  update(index, status, label) {
+    if (index < 0 || index >= this.labels.length) return;
+    this.statuses[index] = status;
+    this.statusLabels[index] = label;
+    if (!this.renderScheduled) {
+      this.renderScheduled = true;
+      queueMicrotask(() => {
+        this.renderScheduled = false;
+        this.render();
+      });
+    }
+  }
+  done() {
+    this.render();
+    process.stderr.write("\n");
+  }
+  render() {
+    if (this.lastRenderLines > 0) {
+      process.stderr.write(`\x1B[${this.lastRenderLines}A\x1B[0J`);
+    }
+    const lines = [];
+    for (let i = 0; i < this.labels.length; i++) {
+      const icon = this.getIcon(this.statuses[i]);
+      const label = this.statusLabels[i];
+      lines.push(`  ${icon} ${chalk5.bold(this.labels[i])} ${chalk5.gray(label)}`);
+    }
+    process.stderr.write(lines.join("\n") + "\n");
+    this.lastRenderLines = lines.length;
+  }
+  getIcon(status) {
+    switch (status) {
+      case "waiting":
+        return chalk5.gray("\u25CB");
+      case "generating":
+        return chalk5.cyan("\u27F3");
+      case "reviewing":
+        return chalk5.yellow("\u27F3");
+      case "done":
+        return chalk5.green("\u25CF");
+      case "failed":
+        return chalk5.red("\u2717");
+      case "paused":
+        return chalk5.yellow("\u23F8");
+    }
+  }
+};
 var TEST_TYPE_LABELS = {
   unit: "\u5355\u5143\u6D4B\u8BD5",
   component: "\u7EC4\u4EF6\u6D4B\u8BD5",
@@ -2914,59 +3078,114 @@ async function executeCreate(options) {
     ]);
     useAI = ai;
   }
+  const tasks = [];
+  for (const testType of types) {
+    for (const testTarget of targets) {
+      tasks.push({ testType, target: testTarget });
+    }
+  }
   const createdFiles = [];
   let skippedCount = 0;
   const reviewReportEntries = [];
-  for (const testType of types) {
-    for (const testTarget of targets) {
-      const spinner = ora3(`\u6B63\u5728\u751F\u6210 ${TEST_TYPE_LABELS[testType]} - ${path9.basename(testTarget)}...`).start();
-      try {
-        let content;
-        if (useAI && testTarget) {
-          const aiResult = await generateWithAI(testType, name, testTarget, config, (text) => {
-            spinner.text = `${text}`;
-          });
-          content = aiResult.code;
-          if (aiResult.reviewEntry) {
-            reviewReportEntries.push(aiResult.reviewEntry);
+  if (useAI && tasks.length > 0) {
+    const fileLabels = tasks.map((t) => path9.basename(t.target));
+    const progress = new MultiProgressBar(fileLabels);
+    const results = await Promise.allSettled(
+      tasks.map(async (task, idx) => {
+        progress.update(idx, "generating", "\u751F\u6210\u6D4B\u8BD5\u4EE3\u7801...");
+        const result = await generateWithAI(task.testType, name, task.target, config, (text) => {
+          const isReview = text.includes("\u5BA1\u8BA1");
+          const isRetry = text.includes("\u91CD\u65B0\u751F\u6210");
+          if (isReview) {
+            progress.update(idx, "reviewing", "\u5BA1\u8BA1\u5BA1\u67E5...");
+          } else if (isRetry) {
+            progress.update(idx, "generating", text);
+          } else {
+            progress.update(idx, "generating", text);
           }
+        });
+        return { ...task, ...result };
+      })
+    );
+    let approvedCount = 0;
+    let failedCount = 0;
+    for (let i = 0; i < results.length; i++) {
+      const r = results[i];
+      const task = tasks[i];
+      if (r.status === "rejected") {
+        progress.update(i, "failed", r.reason instanceof Error ? r.reason.message : String(r.reason));
+        failedCount++;
+        continue;
+      }
+      const { code, reviewEntry } = r.value;
+      const outputDir = getTestOutputDir(task.testType);
+      const filePath = path9.join(outputDir, `${name}.${task.testType === "e2e" ? "spec" : "test"}.ts`);
+      if (fs8.existsSync(filePath)) {
+        progress.update(i, "paused", "\u6587\u4EF6\u5DF2\u5B58\u5728\uFF0C\u8DF3\u8FC7");
+        skippedCount++;
+        continue;
+      }
+      if (!fs8.existsSync(outputDir)) {
+        fs8.mkdirSync(outputDir, { recursive: true });
+      }
+      fs8.writeFileSync(filePath, code, "utf-8");
+      createdFiles.push({ type: task.testType, filePath });
+      if (reviewEntry) {
+        reviewReportEntries.push(reviewEntry);
+        if (reviewEntry.approved) {
+          progress.update(i, "done", `\u5BA1\u8BA1\u901A\u8FC7 (${(reviewEntry.score * 100).toFixed(0)}%)`);
+          approvedCount++;
         } else {
-          const analysis = testTarget ? analyzeFile(testTarget) : void 0;
-          content = renderTemplate(testType, {
-            name,
-            target: testTarget || `./${config.project.srcDir}`,
-            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
-          });
+          progress.update(i, "paused", `\u5BA1\u8BA1\u672A\u901A\u8FC7 (${(reviewEntry.score * 100).toFixed(0)}%) \u2014 \u6682\u505C`);
+          failedCount++;
         }
-        const outputDir = getTestOutputDir(testType);
-        const filePath = path9.join(outputDir, `${name}.${testType === "e2e" ? "spec" : "test"}.ts`);
+      } else {
+        progress.update(i, "done", "\u5B8C\u6210");
+        approvedCount++;
+      }
+    }
+    progress.done();
+    console.log(chalk5.cyan(`
+  \u751F\u6210\u5B8C\u6210: ${chalk5.green(approvedCount + " \u901A\u8FC7")} ${failedCount > 0 ? chalk5.red(failedCount + " \u672A\u901A\u8FC7") : ""} ${skippedCount > 0 ? chalk5.yellow(skippedCount + " \u8DF3\u8FC7") : ""}`));
+  } else {
+    for (const task of tasks) {
+      const spinner = ora3(`\u6B63\u5728\u751F\u6210 ${TEST_TYPE_LABELS[task.testType]} - ${path9.basename(task.target)}...`).start();
+      try {
+        const analysis = task.target ? analyzeFile(task.target) : void 0;
+        const content = renderTemplate(task.testType, {
+          name,
+          target: task.target || `./${config.project.srcDir}`,
+          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
+        });
+        const outputDir = getTestOutputDir(task.testType);
+        const filePath = path9.join(outputDir, `${name}.${task.testType === "e2e" ? "spec" : "test"}.ts`);
         if (fs8.existsSync(filePath)) {
           spinner.warn(`\u6D4B\u8BD5\u6587\u4EF6\u5DF2\u5B58\u5728: ${path9.relative(process.cwd(), filePath)}`);
           skippedCount++;
@@ -2976,10 +3195,10 @@ async function executeCreate(options) {
           fs8.mkdirSync(outputDir, { recursive: true });
         }
         fs8.writeFileSync(filePath, content, "utf-8");
-        spinner.succeed(`${TEST_TYPE_LABELS[testType]} - ${path9.basename(testTarget)}`);
-        createdFiles.push({ type: testType, filePath });
+        spinner.succeed(`${TEST_TYPE_LABELS[task.testType]} - ${path9.basename(task.target)}`);
+        createdFiles.push({ type: task.testType, filePath });
       } catch (error) {
-        spinner.fail(`${TEST_TYPE_LABELS[testType]} - ${path9.basename(testTarget)} \u521B\u5EFA\u5931\u8D25`);
+        spinner.fail(`${TEST_TYPE_LABELS[task.testType]} - ${path9.basename(task.target)} \u521B\u5EFA\u5931\u8D25`);
         console.log(chalk5.gray(`    ${error instanceof Error ? error.message : String(error)}`));
       }
     }
@@ -2988,6 +3207,49 @@ async function executeCreate(options) {
   if (reviewReportEntries.length > 0) {
     printReviewReport(reviewReportEntries);
   }
+  const failedEntries = reviewReportEntries.filter((e) => !e.approved);
+  if (failedEntries.length > 0 && useAI) {
+    console.log();
+    console.log(chalk5.yellow(`  \u23F8 ${failedEntries.length} \u4E2A\u6D4B\u8BD5\u7528\u4F8B\u5BA1\u8BA1\u672A\u901A\u8FC7:`));
+    for (const entry of failedEntries) {
+      console.log(chalk5.gray(`    - ${path9.basename(entry.target)} (${(entry.score * 100).toFixed(0)}%) ${entry.feedback}`));
+    }
+    const { retry } = await inquirer2.prompt([
+      {
+        type: "confirm",
+        name: "retry",
+        message: `\u662F\u5426\u91CD\u65B0\u751F\u6210\u8FD9\u4E9B\u672A\u901A\u8FC7\u7684\u6D4B\u8BD5\u7528\u4F8B\uFF1F`,
+        default: false
+      }
+    ]);
+    if (retry) {
+      console.log();
+      const retryLabels = failedEntries.map((e) => path9.basename(e.target));
+      const retryProgress = new MultiProgressBar(retryLabels);
+      const retryResults = await Promise.allSettled(
+        failedEntries.map(async (entry, idx) => {
+          retryProgress.update(idx, "generating", "\u91CD\u65B0\u751F\u6210...");
+          const aiResult = await generateWithAI(entry.testType, name, entry.target, config, (text) => {
+            const isReview = text.includes("\u5BA1\u8BA1");
+            retryProgress.update(idx, isReview ? "reviewing" : "generating", text);
+          });
+          const outputDir = getTestOutputDir(entry.testType);
+          const filePath = path9.join(outputDir, `${name}.${entry.testType === "e2e" ? "spec" : "test"}.ts`);
+          fs8.writeFileSync(filePath, aiResult.code, "utf-8");
+          if (aiResult.reviewEntry?.approved) {
+            retryProgress.update(idx, "done", `\u5BA1\u8BA1\u901A\u8FC7 (${(aiResult.reviewEntry.score * 100).toFixed(0)}%)`);
+          } else {
+            retryProgress.update(idx, "failed", aiResult.reviewEntry ? `\u4ECD\u672A\u901A\u8FC7 (${(aiResult.reviewEntry.score * 100).toFixed(0)}%)` : "\u5931\u8D25");
+          }
+          return aiResult;
+        })
+      );
+      retryProgress.done();
+      const retryPassed = retryResults.filter((r) => r.status === "fulfilled" && r.value.reviewEntry?.approved).length;
+      const retryFailed = retryResults.length - retryPassed;
+      console.log(chalk5.cyan(`  \u91CD\u8BD5\u5B8C\u6210: ${chalk5.green(retryPassed + " \u901A\u8FC7")} ${retryFailed > 0 ? chalk5.red(retryFailed + " \u4ECD\u9700\u5BA1\u67E5") : ""}`));
+    }
+  }
 }
 async function selectTargets(types, projectInfo, srcDir) {
   const allTargets = [];
@@ -5922,7 +6184,7 @@ async function executeChange(_options) {
 }
 
 // src/cli.ts
-var VERSION = "0.3.05";
+var VERSION = "0.3.07";
 function printLogo() {
   const logo = `
   ${chalk13.bold.cyan("   ___            _          _           _              _               _____                _     _                 ")}