qat-cli 0.3.4 → 0.3.5

package/dist/cli.js

@@ -524,71 +524,6 @@ function validateConfig(config) {
   }
   return merged;
 }
-function generateConfigFile(overrides = {}) {
-  const config = validateConfig(overrides);
-  return `// @ts-check
-/**
- * QAT \u914D\u7F6E\u6587\u4EF6 - Quick Auto Testing
- * \u4FEE\u6539\u540E\u65E0\u9700\u91CD\u542F\uFF0C\u4E0B\u6B21\u8FD0\u884C qat \u547D\u4EE4\u65F6\u81EA\u52A8\u751F\u6548
- *
- * AI \u6A21\u578B\u914D\u7F6E\u8BF7\u8FD0\u884C: qat change
- * AI \u72B6\u6001\u67E5\u770B\u8BF7\u8FD0\u884C: qat status
- */
-import { defineConfig } from 'qat-cli';
-
-export default defineConfig({
-  project: {
-    framework: '${config.project.framework}',
-    vite: ${config.project.vite ?? true},
-    srcDir: '${config.project.srcDir}',
-  },
-  vitest: {
-    enabled: ${config.vitest.enabled},
-    coverage: ${config.vitest.coverage},
-    globals: ${config.vitest.globals},
-    environment: '${config.vitest.environment}',
-  },
-  playwright: {
-    enabled: ${config.playwright.enabled},
-    browsers: [${config.playwright.browsers.map((b) => `'${b}'`).join(", ")}],
-    baseURL: '${config.playwright.baseURL}',
-    screenshot: '${config.playwright.screenshot}',
-  },
-  visual: {
-    enabled: ${config.visual.enabled},
-    threshold: ${config.visual.threshold},
-    baselineDir: '${config.visual.baselineDir}',
-    diffDir: '${config.visual.diffDir}',
-  },
-  lighthouse: {
-    enabled: ${config.lighthouse.enabled},
-    urls: [${config.lighthouse.urls.map((u) => `'${u}'`).join(", ")}],
-    runs: ${config.lighthouse.runs},
-    thresholds: {${Object.entries(config.lighthouse.thresholds).map(([k, v]) => `
-      ${k}: ${v},`).join("")}
-    },
-  },
-  mock: {
-    enabled: ${config.mock.enabled},
-    port: ${config.mock.port},
-    routesDir: '${config.mock.routesDir}',
-  },
-  report: {
-    outputDir: '${config.report.outputDir}',
-    open: ${config.report.open},
-  },
-});
-`;
-}
-async function writeConfigFile(cwd, overrides = {}, force = false) {
-  const configPath = path2.join(cwd, "qat.config.js");
-  if (fs2.existsSync(configPath) && !force) {
-    throw new Error(`\u914D\u7F6E\u6587\u4EF6\u5DF2\u5B58\u5728: ${configPath}\uFF0C\u4F7F\u7528 --force \u8986\u76D6`);
-  }
-  const content = generateConfigFile(overrides);
-  fs2.writeFileSync(configPath, content, "utf-8");
-  return configPath;
-}
 function isFileNotFoundError(error) {
   if (error instanceof Error) {
     return error.message.includes("Cannot find") || error.message.includes("ENOENT") || error.message.includes("\u65E0\u6CD5\u52A0\u8F7D\u914D\u7F6E\u6587\u4EF6");
@@ -1088,9 +1023,15 @@ ${errorDetails}`;
   /**
    * 压缩源码：保留签名和关键逻辑，剔除注释、空行、样式块
    * 目标：在保留准确性的前提下减少 token 消耗
+   * @param code 源码内容
+   * @param maxLength 最大长度
+   * @param importPathRewrites import 路径重写映射（原路径→正确路径）
    */
-  compressSourceCode(code, maxLength = 3e3) {
+  compressSourceCode(code, maxLength = 3e3, importPathRewrites) {
     let compressed = code;
+    if (importPathRewrites && importPathRewrites.size > 0) {
+      compressed = this.rewriteImportPaths(compressed, importPathRewrites);
+    }
     compressed = compressed.replace(/<style[^>]*>[\s\S]*?<\/style>/gi, "");
     compressed = compressed.replace(/<template[^>]*>([\s\S]*?)<\/template>/gi, (_match, content) => {
       return `<template>${content.replace(/\s*(?:class|style)\s*=\s*["'][^"']*["']/gi, "")}</template>`;
@@ -1128,7 +1069,8 @@ ${errorDetails}`;
   }
   buildGenerateTestUserPrompt(req) {
     const importPath = this.computeTestImportPath(req.type, req.target);
-    let prompt = `\u4E3A${req.target}\u751F\u6210${req.type}\u6D4B\u8BD5\u3002import\u8DEF\u5F84:${importPath}
+    let prompt = `\u4E3A${req.target}\u751F\u6210${req.type}\u6D4B\u8BD5\u3002
+\u3010\u5F3A\u5236\u3011import\u88AB\u6D4B\u6A21\u5757\u5FC5\u987B\u7528: ${importPath}
 `;
     if (req.analysis) {
       const parts = [];
@@ -1150,13 +1092,19 @@ ${errorDetails}`;
       if (req.analysis.computed?.length) {
         parts.push(`Computed:${req.analysis.computed.join(",")}`);
       }
+      if (req.analysis.importSignatures?.length) {
+        parts.push(`\u4F9D\u8D56\u7B7E\u540D:${req.analysis.importSignatures.map(
+          (imp) => `${imp.source}{${Object.entries(imp.signatures).map(([k, v]) => `${k}:${v}`).join(",")}}`
+        ).join(";")}`);
+      }
       prompt += parts.join("\n") + "\n";
     }
     if (req.context) {
+      const importPathRewrites = this.buildImportPathRewrites(req.type, req.target);
       prompt += `
 \u6E90\u7801:
 \`\`\`
-${this.compressSourceCode(req.context)}
+${this.compressSourceCode(req.context, 3e3, importPathRewrites)}
 \`\`\`
 `;
     }
@@ -1191,6 +1139,56 @@ ${this.compressSourceCode(req.context)}
     }
     return `${prefix}${cleanPath}`;
   }
+  /**
+   * 构建 import 路径重写映射
+   * 将源码中可能引用自身的各种写法，映射到测试文件中正确的导入路径
+   */
+  buildImportPathRewrites(testType, targetPath) {
+    const rewrites = /* @__PURE__ */ new Map();
+    if (!targetPath) return rewrites;
+    const correctImportPath = this.computeTestImportPath(testType, targetPath);
+    const variations = /* @__PURE__ */ new Set();
+    variations.add(targetPath);
+    variations.add(targetPath.replace(/^\.\//, ""));
+    const withoutExt = targetPath.replace(/\.(ts|js|tsx|jsx)$/, "");
+    variations.add(withoutExt);
+    const srcDirMatch = targetPath.match(/^(?:\.\/)?(src\/.+)$/);
+    if (srcDirMatch) {
+      variations.add(`@/${srcDirMatch[1]}`);
+      variations.add(`@/${srcDirMatch[1].replace(/\.(ts|js|tsx|jsx)$/, "")}`);
+    }
+    const pathParts = targetPath.replace(/^\.\//, "").split("/");
+    const fileName = pathParts[pathParts.length - 1];
+    const fileNameNoExt = fileName.replace(/\.(ts|js|tsx|jsx|vue)$/, "");
+    variations.add(`./${fileName}`);
+    variations.add(`./${fileNameNoExt}`);
+    for (let i = 1; i < pathParts.length; i++) {
+      const relPath = "../".repeat(i) + pathParts.slice(i).join("/");
+      variations.add(relPath);
+      variations.add(relPath.replace(/\.(ts|js|tsx|jsx)$/, ""));
+    }
+    for (const variant of variations) {
+      if (variant && variant !== correctImportPath) {
+        rewrites.set(variant, correctImportPath);
+      }
+    }
+    return rewrites;
+  }
+  /**
+   * 重写源码中的 import 路径
+   * 将 from 'oldPath' / from "oldPath" 替换为正确的路径
+   */
+  rewriteImportPaths(code, rewrites) {
+    let result = code;
+    for (const [oldPath, newPath] of rewrites) {
+      const escaped = oldPath.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      const singleQuoteRegex = new RegExp(`(from\\s+')${escaped}(')`, "g");
+      const doubleQuoteRegex = new RegExp(`(from\\s+")${escaped}(")`, "g");
+      result = result.replace(singleQuoteRegex, `$1${newPath}$2`);
+      result = result.replace(doubleQuoteRegex, `$1${newPath}$2`);
+    }
+    return result;
+  }
   parseGenerateTestResponse(content) {
     const codeBlockMatch = content.match(/```(?:typescript|ts|javascript|js)?\s*\n([\s\S]*?)```/);
     const code = codeBlockMatch ? codeBlockMatch[1].trim() : content.replace(/^(?:```[\s\S]*?\n)?/, "").replace(/\n?```$/, "").trim();
@@ -1213,12 +1211,14 @@ SUGGESTIONS:- \u5EFA\u8BAE(\u6BCF\u884C\u4E00\u4E2A)`;
   }
   buildReviewTestUserPrompt(req) {
     const importPath = this.computeTestImportPath(req.testType, req.target);
-    let prompt = `\u5BA1\u67E5\u6D4B\u8BD5\u4EE3\u7801\u3002\u88AB\u6D4B:${req.target} \u7C7B\u578B:${req.testType} import\u8DEF\u5F84:${importPath}
+    let prompt = `\u5BA1\u67E5\u6D4B\u8BD5\u4EE3\u7801\u3002\u88AB\u6D4B:${req.target} \u7C7B\u578B:${req.testType}
+\u3010\u5F3A\u5236\u3011import\u88AB\u6D4B\u6A21\u5757\u5FC5\u987B\u7528: ${importPath}
 `;
+    const importPathRewrites = this.buildImportPathRewrites(req.testType, req.target);
     prompt += `
 \u6E90\u7801:
 \`\`\`
-${this.compressSourceCode(req.sourceCode, 2e3)}
+${this.compressSourceCode(req.sourceCode, 2e3, importPathRewrites)}
 \`\`\`
 `;
     prompt += `
@@ -1237,6 +1237,11 @@ ${req.testCode}
       if (req.analysis.emits?.length) {
         parts.push(`Emits:${req.analysis.emits.map((e) => `${e.name}(${e.params?.join(",") || ""})`).join(",")}`);
       }
+      if (req.analysis.importSignatures?.length) {
+        parts.push(`\u4F9D\u8D56:${req.analysis.importSignatures.map(
+          (imp) => `${imp.source}{${Object.entries(imp.signatures).map(([k, v]) => `${k}:${v}`).join(",")}}`
+        ).join(";")}`);
+      }
       if (parts.length > 0) {
         prompt += `
 \u5206\u6790:${parts.join("|")}`;
@@ -1428,15 +1433,18 @@ import path4 from "path";
 function analyzeFile(filePath) {
   const absolutePath = path4.resolve(process.cwd(), filePath);
   if (!fs4.existsSync(absolutePath)) {
-    return { filePath, exports: [], apiCalls: [] };
+    return { filePath, exports: [], imports: [], importSignatures: [], apiCalls: [] };
   }
   const content = fs4.readFileSync(absolutePath, "utf-8");
   const ext = path4.extname(filePath);
   const result = {
     filePath,
     exports: extractExports(content, ext),
+    imports: extractImports(content),
+    importSignatures: [],
     apiCalls: extractAPICalls(content, filePath)
   };
+  result.importSignatures = analyzeImportSignatures(result.imports, path4.dirname(absolutePath));
   if (ext === ".vue") {
     result.vueAnalysis = analyzeVueComponent(content, path4.basename(filePath, ".vue"));
     const scriptMatch = content.match(/<script[^>]*>([\s\S]*?)<\/script>/);
@@ -1856,6 +1864,90 @@ function generateMockRoutesFromAPICalls(apiCalls) {
   }
   return routes;
 }
+function extractImports(content) {
+  const imports = [];
+  const namedImportRegex = /import\s*\{([^}]+)\}\s*from\s*['"]([^'"]+)['"]/g;
+  let match;
+  while ((match = namedImportRegex.exec(content)) !== null) {
+    const names = match[1].split(",").map((n) => {
+      const parts = n.trim().split(/\s+as\s+/);
+      return parts[0].trim();
+    }).filter(Boolean);
+    imports.push({ names, source: match[2], isDefault: false, isNamespace: false });
+  }
+  const defaultImportRegex = /import\s+(\w+)\s+from\s*['"]([^'"]+)['"]/g;
+  while ((match = defaultImportRegex.exec(content)) !== null) {
+    const fullLine = content.slice(Math.max(0, match.index - 5), match.index + match[0].length);
+    if (fullLine.includes("{")) continue;
+    imports.push({ names: [match[1]], source: match[2], isDefault: true, isNamespace: false });
+  }
+  const namespaceImportRegex = /import\s*\*\s*as\s+(\w+)\s*from\s*['"]([^'"]+)['"]/g;
+  while ((match = namespaceImportRegex.exec(content)) !== null) {
+    imports.push({ names: [match[1]], source: match[2], isDefault: false, isNamespace: true });
+  }
+  return imports;
+}
+function analyzeImportSignatures(imports, baseDir) {
+  const signatures = [];
+  for (const imp of imports) {
+    if (!imp.source.startsWith(".") && !imp.source.startsWith("@/") && !imp.source.startsWith("~")) {
+      continue;
+    }
+    const resolvedPath = resolveImportPath(imp.source, baseDir);
+    if (!resolvedPath || !fs4.existsSync(resolvedPath)) continue;
+    try {
+      const content = fs4.readFileSync(resolvedPath, "utf-8");
+      const ext = path4.extname(resolvedPath);
+      const exports = extractExports(content, ext);
+      const sigMap = {};
+      for (const name of imp.names) {
+        const exp = exports.find((e) => e.name === name);
+        if (exp) {
+          const params = exp.params.length > 0 ? `(${exp.params.join(", ")})` : "";
+          const ret = exp.returnType ? `: ${exp.returnType}` : "";
+          const async = exp.isAsync ? "async " : "";
+          sigMap[name] = `${async}${exp.kind}${params}${ret}`;
+        } else if (imp.isDefault) {
+          const defaultExp = exports.find((e) => e.kind === "default");
+          if (defaultExp) {
+            sigMap[name] = `default[${defaultExp.name || "anonymous"}]`;
+          }
+        } else if (imp.isNamespace) {
+          sigMap[name] = `{${exports.map((e) => e.name).join(", ")}}`;
+        }
+      }
+      if (ext === ".vue") {
+        const vueAnalysis = analyzeVueComponent(content, path4.basename(resolvedPath, ".vue"));
+        if (vueAnalysis.props.length > 0) {
+          sigMap["__props__"] = vueAnalysis.props.map((p) => `${p.name}:${p.type}${p.required ? "!" : "?"}`).join(",");
+        }
+      }
+      if (Object.keys(sigMap).length > 0) {
+        signatures.push({ source: imp.source, signatures: sigMap });
+      }
+    } catch {
+    }
+  }
+  return signatures;
+}
+function resolveImportPath(importSource, baseDir) {
+  let resolved;
+  if (importSource.startsWith("@/") || importSource.startsWith("~")) {
+    const relativePath = importSource.replace(/^[@~]\//, "src/");
+    resolved = path4.resolve(process.cwd(), relativePath);
+  } else if (importSource.startsWith(".")) {
+    resolved = path4.resolve(baseDir, importSource);
+  } else {
+    return null;
+  }
+  const extensions = [".ts", ".tsx", ".js", ".jsx", ".vue", "/index.ts", "/index.js"];
+  if (fs4.existsSync(resolved)) return resolved;
+  for (const ext of extensions) {
+    const withExt = resolved + ext;
+    if (fs4.existsSync(withExt)) return withExt;
+  }
+  return null;
+}
 
 // src/services/global-config.ts
 import fs5 from "fs";
@@ -1960,41 +2052,13 @@ async function executeInit(options) {
     }
   }
   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(chalk3.gray("  \u4FDD\u7559\u73B0\u6709\u914D\u7F6E\u6587\u4EF6\uFF0C\u7EE7\u7EED\u540E\u7EED\u6B65\u9AA4..."));
-      configPath = existingConfigPath;
-    } else {
-      const fileSpinner = ora("\u6B63\u5728\u8986\u76D6\u914D\u7F6E\u6587\u4EF6...").start();
-      try {
-        configPath = await writeConfigFile(process.cwd(), config, true);
-        fileSpinner.succeed("\u914D\u7F6E\u6587\u4EF6\u5DF2\u8986\u76D6");
-      } catch (error) {
-        fileSpinner.fail("\u914D\u7F6E\u6587\u4EF6\u8986\u76D6\u5931\u8D25");
-        throw error;
-      }
-    }
+  if (!configExists) {
+    console.log(chalk3.gray("  \u672A\u627E\u5230\u914D\u7F6E\u6587\u4EF6\uFF0C\u4F7F\u7528\u9ED8\u8BA4\u914D\u7F6E\uFF08\u9700\u8981\u81EA\u5B9A\u4E49\u65F6\u53EF\u521B\u5EFA qat.config.js\uFF09"));
   } else {
-    const fileSpinner = ora("\u6B63\u5728\u751F\u6210\u914D\u7F6E\u6587\u4EF6...").start();
-    try {
-      configPath = await writeConfigFile(process.cwd(), config, options.force);
-      fileSpinner.succeed("\u914D\u7F6E\u6587\u4EF6\u5DF2\u751F\u6210");
-    } catch (error) {
-      fileSpinner.fail("\u914D\u7F6E\u6587\u4EF6\u751F\u6210\u5931\u8D25");
-      throw error;
-    }
+    console.log(chalk3.green(`  \u2713 \u5DF2\u6709\u914D\u7F6E\u6587\u4EF6: ${path6.basename(fs6.existsSync(existingConfigPath) ? existingConfigPath : existingTsPath)}`));
   }
   const dirSpinner = ora("\u6B63\u5728\u521B\u5EFA\u6D4B\u8BD5\u76EE\u5F55...").start();
   const createdDirs = createTestDirectories(config);
@@ -2023,7 +2087,7 @@ async function executeInit(options) {
     console.log(chalk3.cyan(`
   \u53D1\u73B0 ${totalFiles} \u4E2A\u53EF\u6D4B\u8BD5\u6587\u4EF6 (${components.length} \u7EC4\u4EF6, ${utilities.length} \u5DE5\u5177/\u670D\u52A1)`));
   }
-  displayResult(configPath, createdDirs, totalFiles, projectInfo);
+  displayResult(createdDirs, totalFiles, projectInfo);
 }
 async function promptAIConfig() {
   const answers = await inquirer.prompt([
@@ -2160,12 +2224,8 @@ function createTestDirectories(config) {
   }
   return dirs;
 }
-function displayResult(configPath, createdDirs, totalTestableFiles, projectInfo) {
-  const relativeConfig = path6.relative(process.cwd(), configPath);
+function displayResult(createdDirs, totalTestableFiles, projectInfo) {
   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 (createdDirs.length > 0) {
     console.log(chalk3.white("  \u5DF2\u521B\u5EFA\u76EE\u5F55:"));
     for (const dir of createdDirs) {
@@ -2173,6 +2233,9 @@ function displayResult(configPath, createdDirs, totalTestableFiles, projectInfo)
     }
     console.log();
   }
+  console.log(chalk3.white("  \u914D\u7F6E:"));
+  console.log(chalk3.gray("    \u9ED8\u8BA4\u914D\u7F6E\u5DF2\u5185\u7F6E\uFF0C\u9700\u8981\u81EA\u5B9A\u4E49\u65F6\u521B\u5EFA qat.config.js"));
+  console.log();
   console.log(chalk3.cyan("  \u4E0B\u4E00\u6B65:"));
   if (totalTestableFiles > 0) {
     console.log(chalk3.gray(`    1. qat create    \u9009\u62E9\u6587\u4EF6\u5E76\u751F\u6210\u6D4B\u8BD5\u7528\u4F8B (\u53D1\u73B0 ${totalTestableFiles} \u4E2A\u53EF\u6D4B\u8BD5\u6587\u4EF6)`));
@@ -2193,7 +2256,7 @@ import chalk5 from "chalk";
 import inquirer2 from "inquirer";
 import ora3 from "ora";
 import fs8 from "fs";
-import path8 from "path";
+import path9 from "path";
 
 // src/services/template.ts
 import fs7 from "fs";
@@ -2242,7 +2305,7 @@ Handlebars.registerHelper("propTestValue", (prop) => {
   };
   return map[prop.type] || "'test-value'";
 });
-function resolveImportPath(testType, targetPath) {
+function resolveImportPath2(testType, targetPath) {
   if (!targetPath) return targetPath;
   const testDirMap = {
     unit: "tests/unit",
@@ -2268,7 +2331,7 @@ function resolveImportPath(testType, targetPath) {
 function renderTemplate(type, context) {
   const templateContent = loadTemplate(type);
   const template = Handlebars.compile(templateContent);
-  const resolvedTarget = resolveImportPath(type, context.target);
+  const resolvedTarget = resolveImportPath2(type, context.target);
   const fullContext = {
     vueVersion: 3,
     typescript: true,
@@ -2652,10 +2715,11 @@ function toPascalCase(str) {
 // src/services/test-reviewer.ts
 import chalk4 from "chalk";
 import ora2 from "ora";
+import path8 from "path";
 var MAX_RETRIES = 3;
 var REVIEW_THRESHOLD = 0.6;
 async function generateWithReview(params) {
-  const { testType, targetPath, sourceCode, analysis, aiConfig, framework, onAttempt } = params;
+  const { testType, targetPath, sourceCode, analysis, aiConfig, framework, onAttempt, onProgress } = params;
   const generatorProvider = createAIProvider(aiConfig);
   const reviewerProvider = createAIProvider(aiConfig);
   if (!generatorProvider.capabilities.generateTest) {
@@ -2667,9 +2731,12 @@ async function generateWithReview(params) {
   let lastReview = null;
   let approved = false;
   let attempts = 0;
+  const targetName = path8.basename(targetPath);
   for (let i = 0; i < MAX_RETRIES; i++) {
     attempts = i + 1;
     onAttempt?.(attempts, MAX_RETRIES);
+    const genLabel = attempts > 1 ? `\u27F3 \u91CD\u65B0\u751F\u6210 (${attempts}/${MAX_RETRIES})` : "\u751F\u6210\u6D4B\u8BD5\u4EE3\u7801";
+    onProgress?.(`${genLabel} \u2190 ${targetName}`);
     if (process.env.QAT_DEBUG === "true") {
       console.error(chalk4.gray(`[DEBUG] \u2500\u2500\u2500 \u751F\u6210\u8005 AI \u7B2C${attempts}\u6B21\u5C1D\u8BD5 \u2500\u2500\u2500`));
     }
@@ -2693,6 +2760,7 @@ ${lastReview.suggestions.map((s) => `- ${s}`).join("\n")}
     currentCode = generateResponse.code;
     currentDescription = generateResponse.description;
     currentConfidence = generateResponse.confidence;
+    onProgress?.(`\u5BA1\u8BA1\u5BA1\u67E5 \u2190 ${targetName}`);
     if (process.env.QAT_DEBUG === "true") {
       console.error(chalk4.gray(`[DEBUG] \u2500\u2500\u2500 \u5BA1\u8BA1\u5458 AI \u5BA1\u67E5 \u2500\u2500\u2500`));
     }
@@ -2851,11 +2919,13 @@ async function executeCreate(options) {
   const reviewReportEntries = [];
   for (const testType of types) {
     for (const testTarget of targets) {
-      const spinner = ora3(`\u6B63\u5728\u751F\u6210 ${TEST_TYPE_LABELS[testType]} - ${path8.basename(testTarget)}...`).start();
+      const spinner = ora3(`\u6B63\u5728\u751F\u6210 ${TEST_TYPE_LABELS[testType]} - ${path9.basename(testTarget)}...`).start();
       try {
         let content;
         if (useAI && testTarget) {
-          const aiResult = await generateWithAI(testType, name, testTarget, config);
+          const aiResult = await generateWithAI(testType, name, testTarget, config, (text) => {
+            spinner.text = `${text}`;
+          });
           content = aiResult.code;
           if (aiResult.reviewEntry) {
             reviewReportEntries.push(aiResult.reviewEntry);
@@ -2896,9 +2966,9 @@ async function executeCreate(options) {
           });
         }
         const outputDir = getTestOutputDir(testType);
-        const filePath = path8.join(outputDir, `${name}.${testType === "e2e" ? "spec" : "test"}.ts`);
+        const filePath = path9.join(outputDir, `${name}.${testType === "e2e" ? "spec" : "test"}.ts`);
         if (fs8.existsSync(filePath)) {
-          spinner.warn(`\u6D4B\u8BD5\u6587\u4EF6\u5DF2\u5B58\u5728: ${path8.relative(process.cwd(), filePath)}`);
+          spinner.warn(`\u6D4B\u8BD5\u6587\u4EF6\u5DF2\u5B58\u5728: ${path9.relative(process.cwd(), filePath)}`);
           skippedCount++;
           continue;
         }
@@ -2906,10 +2976,10 @@ async function executeCreate(options) {
           fs8.mkdirSync(outputDir, { recursive: true });
         }
         fs8.writeFileSync(filePath, content, "utf-8");
-        spinner.succeed(`${TEST_TYPE_LABELS[testType]} - ${path8.basename(testTarget)}`);
+        spinner.succeed(`${TEST_TYPE_LABELS[testType]} - ${path9.basename(testTarget)}`);
         createdFiles.push({ type: testType, filePath });
       } catch (error) {
-        spinner.fail(`${TEST_TYPE_LABELS[testType]} - ${path8.basename(testTarget)} \u521B\u5EFA\u5931\u8D25`);
+        spinner.fail(`${TEST_TYPE_LABELS[testType]} - ${path9.basename(testTarget)} \u521B\u5EFA\u5931\u8D25`);
         console.log(chalk5.gray(`    ${error instanceof Error ? error.message : String(error)}`));
       }
     }
@@ -2976,22 +3046,22 @@ async function selectTargets(types, projectInfo, srcDir) {
 }
 function generateDefaultName(type, target) {
   if (!target) return `${type}-test`;
-  const basename = path8.basename(target, path8.extname(target));
+  const basename = path9.basename(target, path9.extname(target));
   const cleaned = basename.replace(/[^a-zA-Z0-9]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
   return cleaned || `${type}-test`;
 }
-async function generateWithAI(type, name, target, config) {
+async function generateWithAI(type, name, target, config, onProgress) {
   const provider = getAIProvider(config.ai);
   if (!provider.capabilities.generateTest) {
     throw new Error("\u5F53\u524D AI Provider \u4E0D\u652F\u6301\u6D4B\u8BD5\u751F\u6210");
   }
   let sourceCode = "";
-  const fullPath = path8.resolve(process.cwd(), target);
+  const fullPath = path9.resolve(process.cwd(), target);
   if (fs8.existsSync(fullPath)) {
     sourceCode = fs8.readFileSync(fullPath, "utf-8");
   }
   const analysis = analyzeFile(target);
-  const analysisSummary = analysis.exports.length > 0 || analysis.vueAnalysis ? {
+  const analysisSummary = analysis.exports.length > 0 || analysis.vueAnalysis || analysis.importSignatures.length > 0 ? {
     exports: analysis.exports.map((e) => ({
       name: e.name,
       kind: e.kind,
@@ -3008,7 +3078,8 @@ async function generateWithAI(type, name, target, config) {
       params: e.params
     })),
     methods: analysis.vueAnalysis?.methods,
-    computed: analysis.vueAnalysis?.computed
+    computed: analysis.vueAnalysis?.computed,
+    importSignatures: analysis.importSignatures.length > 0 ? analysis.importSignatures : void 0
   } : void 0;
   const reviewResult = await generateWithReview({
     testType: type,
@@ -3016,7 +3087,8 @@ async function generateWithAI(type, name, target, config) {
     sourceCode,
     analysis: analysisSummary,
     aiConfig: config.ai,
-    framework: "vue"
+    framework: "vue",
+    onProgress
   });
   const headerComment = [
     `// AI Generated Test - ${name}`,
@@ -3060,7 +3132,7 @@ function displayCreateResult(createdFiles, skippedCount, usedAI) {
   }
   console.log();
   for (const { type, filePath } of createdFiles) {
-    const relativePath = path8.relative(process.cwd(), filePath);
+    const relativePath = path9.relative(process.cwd(), filePath);
     console.log(chalk5.white(`    ${chalk5.cyan(TEST_TYPE_LABELS[type])}  ${chalk5.gray(relativePath)}`));
   }
   if (usedAI) {
@@ -3085,11 +3157,11 @@ import chalk6 from "chalk";
 import inquirer3 from "inquirer";
 import ora4 from "ora";
 import fs11 from "fs";
-import path12 from "path";
+import path13 from "path";
 
 // src/runners/vitest-runner.ts
 import { execFile } from "child_process";
-import path9 from "path";
+import path10 from "path";
 import fs9 from "fs";
 import os2 from "os";
 var isVerbose = () => process.env.QAT_VERBOSE === "true";
@@ -3171,7 +3243,7 @@ function buildVitestArgs(options) {
   return args;
 }
 async function execVitest(args) {
-  const tmpFile = path9.join(os2.tmpdir(), `qat-vitest-result-${Date.now()}.json`);
+  const tmpFile = path10.join(os2.tmpdir(), `qat-vitest-result-${Date.now()}.json`);
   const argsWithOutput = [...args, "--outputFile", tmpFile];
   return new Promise((resolve, reject) => {
     const npx = process.platform === "win32" ? "npx.cmd" : "npx";
@@ -3250,7 +3322,7 @@ function parseVitestJSON(jsonStr) {
     for (const fileResult of data.testResults) {
       const suiteTests = parseTestResults(fileResult);
       suites.push({
-        name: path9.basename(fileResult.name || "unknown"),
+        name: path10.basename(fileResult.name || "unknown"),
         file: fileResult.name || "unknown",
         type: "unit",
         status: mapVitestStatus(fileResult.status),
@@ -3361,7 +3433,7 @@ function parseFromStdout(output) {
     if (data.testResults && Array.isArray(data.testResults)) {
       for (const fileResult of data.testResults) {
         suites.push({
-          name: path9.basename(fileResult.name || "unknown"),
+          name: path10.basename(fileResult.name || "unknown"),
           file: fileResult.name || "unknown",
           type: "unit",
           status: mapVitestStatus(fileResult.status),
@@ -3397,7 +3469,7 @@ function parseVitestTextOutput(output, hasError) {
       if (isPassed) totalPassed += testCount;
       else totalFailed += testCount;
       suites.push({
-        name: path9.basename(file),
+        name: path10.basename(file),
         file,
         type: "unit",
         status: isPassed ? "passed" : "failed",
@@ -3498,7 +3570,7 @@ function extractCoverage(coverageMap) {
 
 // src/runners/playwright-runner.ts
 import { execFile as execFile2 } from "child_process";
-import path10 from "path";
+import path11 from "path";
 async function runPlaywright(options) {
   const startTime = Date.now();
   const args = buildPlaywrightArgs(options);
@@ -3698,7 +3770,7 @@ function parsePlaywrightTextOutput(output, hasError) {
       let existingSuite = suites.find((s) => s.file === file);
       if (!existingSuite) {
         existingSuite = {
-          name: path10.basename(file),
+          name: path11.basename(file),
           file,
           type: "e2e",
           status: "passed",
@@ -3933,7 +4005,7 @@ function calculateAverageMetrics(results) {
 
 // src/services/reporter.ts
 import fs10 from "fs";
-import path11 from "path";
+import path12 from "path";
 function aggregateResults(results) {
   const summary = {
     total: 0,
@@ -4129,13 +4201,13 @@ function generateMDReport(data) {
 }
 function writeReportToDisk(data, outputDir) {
   const md = generateMDReport(data);
-  const dir = path11.resolve(outputDir);
+  const dir = path12.resolve(outputDir);
   if (!fs10.existsSync(dir)) {
     fs10.mkdirSync(dir, { recursive: true });
   }
-  const mdPath = path11.join(dir, "report.md");
+  const mdPath = path12.join(dir, "report.md");
   fs10.writeFileSync(mdPath, md, "utf-8");
-  const jsonPath = path11.join(dir, "report.json");
+  const jsonPath = path12.join(dir, "report.json");
   fs10.writeFileSync(jsonPath, JSON.stringify(data, null, 2), "utf-8");
   return mdPath;
 }
@@ -4356,7 +4428,7 @@ async function executeRun(options) {
   const reportData = aggregateResults(results);
   const outputDir = config.report.outputDir || "qat-report";
   const reportPath = writeReportToDisk(reportData, outputDir);
-  const relativePath = path12.relative(process.cwd(), reportPath);
+  const relativePath = path13.relative(process.cwd(), reportPath);
   console.log(chalk6.gray(`
   \u62A5\u544A\u5DF2\u751F\u6210: ${chalk6.cyan(relativePath)}`));
   console.log();
@@ -4743,8 +4815,8 @@ async function checkDevServer(config) {
 }
 async function startDevServer(config) {
   const { spawn } = await import("child_process");
-  const hasPnpm = fs11.existsSync(path12.join(process.cwd(), "pnpm-lock.yaml"));
-  const hasYarn = fs11.existsSync(path12.join(process.cwd(), "yarn.lock"));
+  const hasPnpm = fs11.existsSync(path13.join(process.cwd(), "pnpm-lock.yaml"));
+  const hasYarn = fs11.existsSync(path13.join(process.cwd(), "yarn.lock"));
   const pkgCmd = hasPnpm ? "pnpm" : hasYarn ? "yarn" : "npm";
   console.log(chalk6.cyan(`  \u6B63\u5728\u542F\u52A8 dev server (${pkgCmd} run dev) ...`));
   const child = spawn(pkgCmd, ["run", "dev"], {
@@ -4773,13 +4845,13 @@ async function startDevServer(config) {
 }
 function saveRunResults(results) {
   if (results.length === 0) return;
-  const resultsPath = path12.join(process.cwd(), RESULTS_DIR);
+  const resultsPath = path13.join(process.cwd(), RESULTS_DIR);
   if (!fs11.existsSync(resultsPath)) {
     fs11.mkdirSync(resultsPath, { recursive: true });
   }
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
   const fileName = `result-${timestamp}.json`;
-  const filePath = path12.join(resultsPath, fileName);
+  const filePath = path13.join(resultsPath, fileName);
   const data = {
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
     results
@@ -4789,13 +4861,13 @@ function saveRunResults(results) {
     const files = fs11.readdirSync(resultsPath).filter((f) => f.startsWith("result-") && f.endsWith(".json")).sort();
     while (files.length > 20) {
       const oldest = files.shift();
-      fs11.unlinkSync(path12.join(resultsPath, oldest));
+      fs11.unlinkSync(path13.join(resultsPath, oldest));
     }
   } catch {
   }
 }
 function checkTestDependencies(types) {
-  const pkgPath = path12.join(process.cwd(), "package.json");
+  const pkgPath = path13.join(process.cwd(), "package.json");
   let allDeps = {};
   if (fs11.existsSync(pkgPath)) {
     try {
@@ -4821,8 +4893,8 @@ function checkTestDependencies(types) {
   return missingDeps;
 }
 async function installTestDependencies(missingDeps) {
-  const hasPnpm = fs11.existsSync(path12.join(process.cwd(), "pnpm-lock.yaml"));
-  const hasYarn = fs11.existsSync(path12.join(process.cwd(), "yarn.lock"));
+  const hasPnpm = fs11.existsSync(path13.join(process.cwd(), "pnpm-lock.yaml"));
+  const hasYarn = fs11.existsSync(path13.join(process.cwd(), "yarn.lock"));
   const pkgManager = hasPnpm ? "pnpm" : hasYarn ? "yarn" : "npm";
   const { execFile: execFile5 } = await import("child_process");
   let allSuccess = true;
@@ -4990,7 +5062,7 @@ function showStatus() {
 import chalk8 from "chalk";
 import ora6 from "ora";
 import fs12 from "fs";
-import path13 from "path";
+import path14 from "path";
 var RESULTS_DIR2 = ".qat-results";
 function registerReportCommand(program2) {
   program2.command("report").description("\u751F\u6210\u6D4B\u8BD5\u62A5\u544A - \u805A\u5408\u6240\u6709\u6D4B\u8BD5\u7ED3\u679C\u5E76\u8F93\u51FAHTML").option("-o, --output <dir>", "\u62A5\u544A\u8F93\u51FA\u76EE\u5F55").option("--open", "\u751F\u6210\u540E\u81EA\u52A8\u6253\u5F00\u62A5\u544A", false).action(async (options) => {
@@ -5026,13 +5098,13 @@ async function executeReport(options) {
 }
 function collectResults() {
   const results = [];
-  const resultsPath = path13.join(process.cwd(), RESULTS_DIR2);
+  const resultsPath = path14.join(process.cwd(), RESULTS_DIR2);
   if (!fs12.existsSync(resultsPath)) {
     return results;
   }
   const files = fs12.readdirSync(resultsPath).filter((f) => f.endsWith(".json")).sort().reverse();
   if (files.length > 0) {
-    const latestFile = path13.join(resultsPath, files[0]);
+    const latestFile = path14.join(resultsPath, files[0]);
     try {
       const data = JSON.parse(fs12.readFileSync(latestFile, "utf-8"));
       if (Array.isArray(data)) {
@@ -5046,22 +5118,22 @@ function collectResults() {
   return results;
 }
 function saveResultToHistory(reportData) {
-  const resultsPath = path13.join(process.cwd(), RESULTS_DIR2);
+  const resultsPath = path14.join(process.cwd(), RESULTS_DIR2);
   if (!fs12.existsSync(resultsPath)) {
     fs12.mkdirSync(resultsPath, { recursive: true });
   }
   const timestamp = new Date(reportData.timestamp).toISOString().replace(/[:.]/g, "-");
   const fileName = `result-${timestamp}.json`;
-  const filePath = path13.join(resultsPath, fileName);
+  const filePath = path14.join(resultsPath, fileName);
   fs12.writeFileSync(filePath, JSON.stringify(reportData, null, 2), "utf-8");
   const files = fs12.readdirSync(resultsPath).filter((f) => f.startsWith("result-") && f.endsWith(".json")).sort();
   while (files.length > 20) {
     const oldest = files.shift();
-    fs12.unlinkSync(path13.join(resultsPath, oldest));
+    fs12.unlinkSync(path14.join(resultsPath, oldest));
   }
 }
 function displayReportResult(reportPath, data) {
-  const relativePath = path13.relative(process.cwd(), reportPath);
+  const relativePath = path14.relative(process.cwd(), reportPath);
   const passRate = data.summary.total > 0 ? (data.summary.passed / data.summary.total * 100).toFixed(1) : "0";
   console.log();
   console.log(chalk8.green("  \u2713 \u6D4B\u8BD5\u62A5\u544A\u5DF2\u751F\u6210"));
@@ -5119,7 +5191,7 @@ import ora7 from "ora";
 
 // src/services/visual.ts
 import fs13 from "fs";
-import path14 from "path";
+import path15 from "path";
 import pixelmatch from "pixelmatch";
 import { PNG } from "pngjs";
 function compareImages(baselinePath, currentPath, diffOutputPath, threshold = 0.1) {
@@ -5158,7 +5230,7 @@ function compareImages(baselinePath, currentPath, diffOutputPath, threshold = 0.
   const passed = diffRatio <= threshold;
   let diffPath;
   if (diffPixels > 0) {
-    const diffDir = path14.dirname(diffOutputPath);
+    const diffDir = path15.dirname(diffOutputPath);
     if (!fs13.existsSync(diffDir)) {
       fs13.mkdirSync(diffDir, { recursive: true });
     }
@@ -5179,7 +5251,7 @@ function createBaseline(currentPath, baselinePath) {
   if (!fs13.existsSync(currentPath)) {
     throw new Error(`\u5F53\u524D\u622A\u56FE\u4E0D\u5B58\u5728: ${currentPath}`);
   }
-  const baselineDir = path14.dirname(baselinePath);
+  const baselineDir = path15.dirname(baselinePath);
   if (!fs13.existsSync(baselineDir)) {
     fs13.mkdirSync(baselineDir, { recursive: true });
   }
@@ -5193,9 +5265,9 @@ function updateAllBaselines(currentDir, baselineDir) {
   }
   const files = fs13.readdirSync(currentDir).filter((f) => f.endsWith(".png"));
   for (const file of files) {
-    const currentPath = path14.join(currentDir, file);
-    const baselinePath = path14.join(baselineDir, file);
-    const baselineDirAbs = path14.dirname(baselinePath);
+    const currentPath = path15.join(currentDir, file);
+    const baselinePath = path15.join(baselineDir, file);
+    const baselineDirAbs = path15.dirname(baselinePath);
     if (!fs13.existsSync(baselineDirAbs)) {
       fs13.mkdirSync(baselineDirAbs, { recursive: true });
     }
@@ -5211,7 +5283,7 @@ function cleanBaselines(baselineDir) {
   const files = fs13.readdirSync(baselineDir).filter((f) => f.endsWith(".png"));
   let count = 0;
   for (const file of files) {
-    fs13.unlinkSync(path14.join(baselineDir, file));
+    fs13.unlinkSync(path15.join(baselineDir, file));
     count++;
   }
   return count;
@@ -5223,7 +5295,7 @@ function cleanDiffs(diffDir) {
   const files = fs13.readdirSync(diffDir).filter((f) => f.endsWith(".png"));
   let count = 0;
   for (const file of files) {
-    fs13.unlinkSync(path14.join(diffDir, file));
+    fs13.unlinkSync(path15.join(diffDir, file));
     count++;
   }
   return count;
@@ -5235,9 +5307,9 @@ function compareDirectories(baselineDir, currentDir, diffDir, threshold = 0.1) {
   }
   const currentFiles = fs13.readdirSync(currentDir).filter((f) => f.endsWith(".png"));
   for (const file of currentFiles) {
-    const currentPath = path14.join(currentDir, file);
-    const baselinePath = path14.join(baselineDir, file);
-    const diffPath = path14.join(diffDir, file);
+    const currentPath = path15.join(currentDir, file);
+    const baselinePath = path15.join(baselineDir, file);
+    const diffPath = path15.join(diffDir, file);
     if (!fs13.existsSync(baselinePath)) {
       createBaseline(currentPath, baselinePath);
       results.push({
@@ -5271,7 +5343,7 @@ function compareDirectories(baselineDir, currentDir, diffDir, threshold = 0.1) {
 
 // src/commands/visual.ts
 import fs14 from "fs";
-import path15 from "path";
+import path16 from "path";
 function registerVisualCommand(program2) {
   program2.command("visual").description("\u89C6\u89C9\u56DE\u5F52\u6D4B\u8BD5 - \u622A\u56FE\u6BD4\u5BF9\u4E0E\u57FA\u7EBF\u7BA1\u7406").argument("<action>", "\u64CD\u4F5C\u7C7B\u578B (test|approve|clean)").option("--threshold <number>", "\u50CF\u7D20\u5DEE\u5F02\u9608\u503C (0-1)", "0.1").action(async (action, options) => {
     try {
@@ -5346,9 +5418,9 @@ async function runVisualTest(threshold, baselineDir, diffDir, config) {
 }
 function findCurrentScreenshotsDir(baselineDir) {
   const possibleDirs = [
-    path15.join(process.cwd(), "test-results"),
-    path15.join(process.cwd(), "tests", "visual", "current"),
-    path15.join(process.cwd(), baselineDir, "..", "current")
+    path16.join(process.cwd(), "test-results"),
+    path16.join(process.cwd(), "tests", "visual", "current"),
+    path16.join(process.cwd(), baselineDir, "..", "current")
   ];
   for (const dir of possibleDirs) {
     if (fs14.existsSync(dir)) {
@@ -5364,7 +5436,7 @@ function findPngFiles(dir) {
     if (!fs14.existsSync(d)) return;
     const entries = fs14.readdirSync(d, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path15.join(d, entry.name);
+      const fullPath = path16.join(d, entry.name);
       if (entry.isDirectory() && entry.name !== "node_modules") {
         walk(fullPath);
       } else if (entry.name.endsWith(".png")) {
@@ -5393,7 +5465,7 @@ function displayVisualResults(results, threshold) {
     console.log();
     console.log(chalk9.green("  \u901A\u8FC7\u7684\u622A\u56FE:"));
     for (const result of passed) {
-      const name = path15.basename(result.baselinePath);
+      const name = path16.basename(result.baselinePath);
       if (result.totalPixels > 0) {
         const diffPct = (result.diffRatio * 100).toFixed(2);
         console.log(chalk9.green(`    \u2713 ${name} (\u5DEE\u5F02: ${diffPct}%)`));
@@ -5406,7 +5478,7 @@ function displayVisualResults(results, threshold) {
     console.log();
     console.log(chalk9.red("  \u5931\u8D25\u7684\u622A\u56FE:"));
     for (const result of failed) {
-      const name = path15.basename(result.baselinePath);
+      const name = path16.basename(result.baselinePath);
       if (result.diffPixels === -1) {
         console.log(chalk9.red(`    \u2717 ${name} (\u5C3A\u5BF8\u4E0D\u5339\u914D)`));
       } else {
@@ -5414,7 +5486,7 @@ function displayVisualResults(results, threshold) {
         console.log(chalk9.red(`    \u2717 ${name} (\u5DEE\u5F02: ${diffPct}%)`));
       }
       if (result.diffPath) {
-        console.log(chalk9.gray(`      \u5DEE\u5F02\u56FE: ${path15.relative(process.cwd(), result.diffPath)}`));
+        console.log(chalk9.gray(`      \u5DEE\u5F02\u56FE: ${path16.relative(process.cwd(), result.diffPath)}`));
       }
     }
     console.log();
@@ -5461,7 +5533,7 @@ import inquirer4 from "inquirer";
 import ora8 from "ora";
 import { execFile as execFile4 } from "child_process";
 import fs15 from "fs";
-import path16 from "path";
+import path17 from "path";
 var DEPENDENCY_GROUPS = [
   {
     name: "Vitest (\u5355\u5143/\u7EC4\u4EF6/API\u6D4B\u8BD5)",
@@ -5495,7 +5567,7 @@ function registerSetupCommand(program2) {
 async function executeSetup(options) {
   console.log(chalk10.cyan("\n  QAT \u4F9D\u8D56\u5B89\u88C5\u5668\n"));
   const projectInfo = detectProject();
-  if (!fs15.existsSync(path16.join(process.cwd(), "package.json"))) {
+  if (!fs15.existsSync(path17.join(process.cwd(), "package.json"))) {
     throw new Error("\u672A\u627E\u5230 package.json\uFF0C\u8BF7\u5728\u9879\u76EE\u6839\u76EE\u5F55\u6267\u884C\u6B64\u547D\u4EE4");
   }
   if (projectInfo.frameworkConfidence > 0) {
@@ -5529,8 +5601,8 @@ async function executeSetup(options) {
       }
     ]);
     if (chooseDir !== "root") {
-      installDir = path16.join(process.cwd(), chooseDir);
-      if (!fs15.existsSync(path16.join(installDir, "package.json"))) {
+      installDir = path17.join(process.cwd(), chooseDir);
+      if (!fs15.existsSync(path17.join(installDir, "package.json"))) {
         throw new Error(`${chooseDir} \u4E0B\u6CA1\u6709 package.json`);
       }
     }
@@ -5569,7 +5641,7 @@ ${allPackages.map((p) => `  - ${p}`).join("\n")}`,
     const pm = getPackageManager(projectInfo.packageManager);
     const installCmd = pm === "npm" ? "npm install -D" : pm === "yarn" ? "yarn add -D" : pm === "pnpm" ? "pnpm add -D" : "bun add -D";
     for (const group of selectedGroups) {
-      const dirHint = installDir !== process.cwd() ? ` (\u5728 ${path16.relative(process.cwd(), installDir) || installDir})` : "";
+      const dirHint = installDir !== process.cwd() ? ` (\u5728 ${path17.relative(process.cwd(), installDir) || installDir})` : "";
       console.log(chalk10.white(`  ${installCmd} ${group.packages.join(" ")}${dirHint}`));
       if (group.postInstall) {
         for (const cmd of group.postInstall) {
@@ -5850,7 +5922,7 @@ async function executeChange(_options) {
 }
 
 // src/cli.ts
-var VERSION = "0.3.04";
+var VERSION = "0.3.05";
 function printLogo() {
   const logo = `
   ${chalk13.bold.cyan("   ___            _          _           _              _               _____                _     _                 ")}