@deepstorm/cli 0.6.5 → 0.7.0

package/dist/cli.js

@@ -1187,13 +1187,13 @@ var require_ast = __commonJS({
         helperExpression: function helperExpression(node) {
           return node.type === "SubExpression" || (node.type === "MustacheStatement" || node.type === "BlockStatement") && !!(node.params && node.params.length || node.hash);
         },
-        scopedId: function scopedId(path22) {
-          return /^\.|this\b/.test(path22.original);
+        scopedId: function scopedId(path23) {
+          return /^\.|this\b/.test(path23.original);
         },
         // an ID is simple if it only has one part, and that part is not
         // `..` or `this`.
-        simpleId: function simpleId(path22) {
-          return path22.parts.length === 1 && !AST.helpers.scopedId(path22) && !path22.depth;
+        simpleId: function simpleId(path23) {
+          return path23.parts.length === 1 && !AST.helpers.scopedId(path23) && !path23.depth;
         }
       }
     };
@@ -2263,12 +2263,12 @@ var require_helpers2 = __commonJS({
         loc
       };
     }
-    function prepareMustache(path22, params, hash, open, strip, locInfo) {
+    function prepareMustache(path23, params, hash, open, strip, locInfo) {
       var escapeFlag = open.charAt(3) || open.charAt(2), escaped = escapeFlag !== "{" && escapeFlag !== "&";
       var decorator = /\*/.test(open);
       return {
         type: decorator ? "Decorator" : "MustacheStatement",
-        path: path22,
+        path: path23,
         params,
         hash,
         escaped,
@@ -2586,9 +2586,9 @@ var require_compiler = __commonJS({
       },
       DecoratorBlock: function DecoratorBlock(decorator) {
         var program2 = decorator.program && this.compileProgram(decorator.program);
-        var params = this.setupFullMustacheParams(decorator, program2, void 0), path22 = decorator.path;
+        var params = this.setupFullMustacheParams(decorator, program2, void 0), path23 = decorator.path;
         this.useDecorators = true;
-        this.opcode("registerDecorator", params.length, path22.original);
+        this.opcode("registerDecorator", params.length, path23.original);
       },
       PartialStatement: function PartialStatement(partial) {
         this.usePartial = true;
@@ -2652,46 +2652,46 @@ var require_compiler = __commonJS({
         }
       },
       ambiguousSexpr: function ambiguousSexpr(sexpr, program2, inverse) {
-        var path22 = sexpr.path, name = path22.parts[0], isBlock = program2 != null || inverse != null;
-        this.opcode("getContext", path22.depth);
+        var path23 = sexpr.path, name = path23.parts[0], isBlock = program2 != null || inverse != null;
+        this.opcode("getContext", path23.depth);
         this.opcode("pushProgram", program2);
         this.opcode("pushProgram", inverse);
-        path22.strict = true;
-        this.accept(path22);
+        path23.strict = true;
+        this.accept(path23);
         this.opcode("invokeAmbiguous", name, isBlock);
       },
       simpleSexpr: function simpleSexpr(sexpr) {
-        var path22 = sexpr.path;
-        path22.strict = true;
-        this.accept(path22);
+        var path23 = sexpr.path;
+        path23.strict = true;
+        this.accept(path23);
         this.opcode("resolvePossibleLambda");
       },
       helperSexpr: function helperSexpr(sexpr, program2, inverse) {
-        var params = this.setupFullMustacheParams(sexpr, program2, inverse), path22 = sexpr.path, name = path22.parts[0];
+        var params = this.setupFullMustacheParams(sexpr, program2, inverse), path23 = sexpr.path, name = path23.parts[0];
         if (this.options.knownHelpers[name]) {
           this.opcode("invokeKnownHelper", params.length, name);
         } else if (this.options.knownHelpersOnly) {
           throw new _exception2["default"]("You specified knownHelpersOnly, but used the unknown helper " + name, sexpr);
         } else {
-          path22.strict = true;
-          path22.falsy = true;
-          this.accept(path22);
-          this.opcode("invokeHelper", params.length, path22.original, _ast2["default"].helpers.simpleId(path22));
+          path23.strict = true;
+          path23.falsy = true;
+          this.accept(path23);
+          this.opcode("invokeHelper", params.length, path23.original, _ast2["default"].helpers.simpleId(path23));
         }
       },
-      PathExpression: function PathExpression(path22) {
-        this.addDepth(path22.depth);
-        this.opcode("getContext", path22.depth);
-        var name = path22.parts[0], scoped = _ast2["default"].helpers.scopedId(path22), blockParamId = !path22.depth && !scoped && this.blockParamIndex(name);
+      PathExpression: function PathExpression(path23) {
+        this.addDepth(path23.depth);
+        this.opcode("getContext", path23.depth);
+        var name = path23.parts[0], scoped = _ast2["default"].helpers.scopedId(path23), blockParamId = !path23.depth && !scoped && this.blockParamIndex(name);
         if (blockParamId) {
-          this.opcode("lookupBlockParam", blockParamId, path22.parts);
+          this.opcode("lookupBlockParam", blockParamId, path23.parts);
         } else if (!name) {
           this.opcode("pushContext");
-        } else if (path22.data) {
+        } else if (path23.data) {
           this.options.data = true;
-          this.opcode("lookupData", path22.depth, path22.parts, path22.strict);
+          this.opcode("lookupData", path23.depth, path23.parts, path23.strict);
         } else {
-          this.opcode("lookupOnContext", path22.parts, path22.falsy, path22.strict, scoped);
+          this.opcode("lookupOnContext", path23.parts, path23.falsy, path23.strict, scoped);
         }
       },
       StringLiteral: function StringLiteral(string) {
@@ -3041,16 +3041,16 @@ var require_util = __commonJS({
     }
     exports2.urlGenerate = urlGenerate;
     function normalize(aPath) {
-      var path22 = aPath;
+      var path23 = aPath;
       var url = urlParse(aPath);
       if (url) {
         if (!url.path) {
           return aPath;
         }
-        path22 = url.path;
+        path23 = url.path;
       }
-      var isAbsolute = exports2.isAbsolute(path22);
-      var parts = path22.split(/\/+/);
+      var isAbsolute = exports2.isAbsolute(path23);
+      var parts = path23.split(/\/+/);
       for (var part, up = 0, i = parts.length - 1; i >= 0; i--) {
         part = parts[i];
         if (part === ".") {
@@ -3067,18 +3067,18 @@ var require_util = __commonJS({
           }
         }
       }
-      path22 = parts.join("/");
-      if (path22 === "") {
-        path22 = isAbsolute ? "/" : ".";
+      path23 = parts.join("/");
+      if (path23 === "") {
+        path23 = isAbsolute ? "/" : ".";
       }
       if (url) {
-        url.path = path22;
+        url.path = path23;
         return urlGenerate(url);
       }
-      return path22;
+      return path23;
     }
     exports2.normalize = normalize;
-    function join20(aRoot, aPath) {
+    function join21(aRoot, aPath) {
       if (aRoot === "") {
         aRoot = ".";
       }
@@ -3110,7 +3110,7 @@ var require_util = __commonJS({
       }
       return joined;
     }
-    exports2.join = join20;
+    exports2.join = join21;
     exports2.isAbsolute = function(aPath) {
       return aPath.charAt(0) === "/" || urlRegexp.test(aPath);
     };
@@ -3283,7 +3283,7 @@ var require_util = __commonJS({
             parsed.path = parsed.path.substring(0, index + 1);
           }
         }
-        sourceURL = join20(urlGenerate(parsed), sourceURL);
+        sourceURL = join21(urlGenerate(parsed), sourceURL);
       }
       return normalize(sourceURL);
     }
@@ -5858,8 +5858,8 @@ var require_printer = __commonJS({
       return this.accept(sexpr.path) + " " + params + hash;
     };
     PrintVisitor.prototype.PathExpression = function(id) {
-      var path22 = id.parts.join("/");
-      return (id.data ? "@" : "") + "PATH:" + path22;
+      var path23 = id.parts.join("/");
+      return (id.data ? "@" : "") + "PATH:" + path23;
     };
     PrintVisitor.prototype.StringLiteral = function(string) {
       return '"' + string.value + '"';
@@ -5898,8 +5898,8 @@ var require_lib = __commonJS({
     handlebars.print = printer.print;
     module2.exports = handlebars;
     function extension(module3, filename) {
-      var fs27 = require("fs");
-      var templateString = fs27.readFileSync(filename, "utf8");
+      var fs28 = require("fs");
+      var templateString = fs28.readFileSync(filename, "utf8");
       module3.exports = handlebars.compile(templateString);
     }
     if (typeof require !== "undefined" && require.extensions) {
@@ -5911,12 +5911,12 @@ var require_lib = __commonJS({
 
 // src/index.ts
 var import_commander = require("commander");
-var fs26 = __toESM(require("node:fs"));
-var path21 = __toESM(require("node:path"));
+var fs27 = __toESM(require("node:fs"));
+var path22 = __toESM(require("node:path"));
 
 // src/commands/setup.ts
-var path8 = __toESM(require("node:path"));
-var fs12 = __toESM(require("node:fs"));
+var path9 = __toESM(require("node:path"));
+var fs13 = __toESM(require("node:fs"));
 
 // src/engine/registry.ts
 var RegistryReader = class {
@@ -6247,19 +6247,38 @@ function initContextMap(targetDir, opts) {
   const content = CONTEXT_MD_TEMPLATE.replace("{backend.language}", backendLang).replace("{frontend.framework}", frontendFramework);
   fs2.writeFileSync(contextPath, content, "utf-8");
   console.log("\u2714 \u5DF2\u521B\u5EFA .deepstorm/context.md \u9879\u76EE\u4E0A\u4E0B\u6587\u5730\u56FE");
-  appendClaudeMdRef(targetDir);
 }
-function appendClaudeMdRef(targetDir) {
-  const claudeMdPath = path2.join(targetDir, "CLAUDE.md");
-  const refLine = "\n> \u9879\u76EE\u4E8B\u5B9E\u89C1 .deepstorm/context.md\n";
-  if (!fs2.existsSync(claudeMdPath)) {
-    fs2.writeFileSync(claudeMdPath, refLine, "utf-8");
-    return;
+function initClaudeMd(targetDir, opts) {
+  const claudeDir = path2.join(targetDir, ".claude");
+  const claudeMdPath = path2.join(claudeDir, "CLAUDE.md");
+  if (fs2.existsSync(claudeMdPath)) return;
+  ensureDir2(claudeDir);
+  const projectName = opts.projectName || "unknown";
+  const lines = [
+    `# ${projectName}`,
+    ""
+  ];
+  const techLines = [];
+  if (opts.frontend) {
+    techLines.push(`- **\u524D\u7AEF**\uFF1A${opts.frontend}`);
+    if (opts.uiLib) techLines.push(`- **UI \u5E93**\uFF1A${opts.uiLib}`);
+    if (opts.cssFramework) techLines.push(`- **CSS \u65B9\u6848**\uFF1A${opts.cssFramework}`);
+  }
+  if (opts.backend) {
+    techLines.push(`- **\u540E\u7AEF**\uFF1A${opts.backend}`);
+    if (opts.orm) techLines.push(`- **ORM**\uFF1A${opts.orm}`);
+    if (opts.migration) techLines.push(`- **\u6570\u636E\u5E93\u8FC1\u79FB**\uFF1A${opts.migration}`);
+    if (opts.ai) techLines.push(`- **AI \u6846\u67B6**\uFF1A${opts.ai}`);
   }
-  const existing = fs2.readFileSync(claudeMdPath, "utf-8");
-  if (existing.includes(".deepstorm/context.md")) return;
-  fs2.appendFileSync(claudeMdPath, refLine, "utf-8");
-  console.log("\u2714 \u5DF2\u5728 CLAUDE.md \u8FFD\u52A0\u9879\u76EE\u4E0A\u4E0B\u6587\u5F15\u7528");
+  if (techLines.length > 0) {
+    lines.push("## \u6280\u672F\u6808", "");
+    lines.push(...techLines);
+    lines.push("");
+  }
+  lines.push("> \u9879\u76EE\u4E8B\u5B9E\u89C1 .deepstorm/context.md");
+  lines.push("");
+  fs2.writeFileSync(claudeMdPath, lines.join("\n"), "utf-8");
+  console.log("\u2714 \u5DF2\u521B\u5EFA .claude/claude.md \u9879\u76EE\u4FE1\u606F");
 }
 function writeInitTechStack(baseDir, opts) {
   const config = {};
@@ -6280,6 +6299,7 @@ function writeInitTechStack(baseDir, opts) {
   const nested = buildInitNestedConfig(config);
   writeDeepStormConfig(baseDir, nested);
   initContextMap(baseDir, opts);
+  initClaudeMd(baseDir, opts);
 }
 function buildInitNestedConfig(flat) {
   const result = { reef: {} };
@@ -6346,9 +6366,10 @@ async function promptContinueSetup(targetDir, projectName, registry2) {
   }
 }
 function buildContext(opts) {
+  const projectName = opts.projectName || "project";
   return {
-    projectName: opts.projectName,
-    packageName: opts.projectName.replace(/[_-]/g, "").toLowerCase(),
+    projectName,
+    packageName: projectName.replace(/[_-]/g, "").toLowerCase(),
     groupId: "com.example",
     frontend: opts.frontend || false,
     backend: opts.backend || false,
@@ -6362,19 +6383,34 @@ function buildContext(opts) {
 async function runInteractiveMode(targetDir) {
   const { intro: intro2, outro: outro2, text: text2, select: select2, isCancel: isCancel8, confirm: confirm6 } = await import("@clack/prompts");
   intro2("\u{1F680} DeepStorm Init \u2014 \u9879\u76EE\u811A\u624B\u67B6\u521D\u59CB\u5316");
-  const projectName = await text2({
-    message: "\u9879\u76EE\u540D\u79F0\uFF1A",
-    placeholder: "my-project",
-    validate: (value) => {
-      if (!value) return "\u8BF7\u8F93\u5165\u9879\u76EE\u540D\u79F0";
-      if (!VALID_PROJECT_NAME.test(value)) return "\u9879\u76EE\u540D\u4EC5\u652F\u6301\u5B57\u6BCD\u3001\u6570\u5B57\u3001\u4E0B\u5212\u7EBF\u548C\u77ED\u6A2A\u7EBF";
-      return void 0;
-    }
+  const isProjectDir = await confirm6({
+    message: "\u5F53\u524D\u8DEF\u5F84\u662F\u5426\u4E3A\u9879\u76EE\u76EE\u5F55\uFF1F",
+    initialValue: false
   });
-  if (isCancel8(projectName) || typeof projectName !== "string") {
+  if (isCancel8(isProjectDir)) {
     outro2("\u5DF2\u53D6\u6D88");
     return;
   }
+  let projectName;
+  if (isProjectDir) {
+    console.log("\u2713 \u5C06\u5728\u5F53\u524D\u76EE\u5F55\u76F4\u63A5\u751F\u6210\u811A\u624B\u67B6");
+    projectName = void 0;
+  } else {
+    const name = await text2({
+      message: "\u9879\u76EE\u540D\u79F0\uFF1A",
+      placeholder: "my-project",
+      validate: (value) => {
+        if (!value) return "\u8BF7\u8F93\u5165\u9879\u76EE\u540D\u79F0";
+        if (!VALID_PROJECT_NAME.test(value)) return "\u9879\u76EE\u540D\u4EC5\u652F\u6301\u5B57\u6BCD\u3001\u6570\u5B57\u3001\u4E0B\u5212\u7EBF\u548C\u77ED\u6A2A\u7EBF";
+        return void 0;
+      }
+    });
+    if (isCancel8(name) || typeof name !== "string") {
+      outro2("\u5DF2\u53D6\u6D88");
+      return;
+    }
+    projectName = name;
+  }
   const frontendChoice = await select2({
     message: "\u9009\u62E9\u524D\u7AEF\u6846\u67B6\uFF1A",
     options: [
@@ -6389,28 +6425,30 @@ async function runInteractiveMode(targetDir) {
   let uiLib;
   let cssFramework;
   if (frontendChoice === "angular") {
-    uiLib = await select2({
+    const uiLibResult = await select2({
       message: "\u9009\u62E9 UI \u5E93\uFF1A",
       options: [
         { value: "primeng", label: "PrimeNG" },
         { value: "none", label: "\u65E0\uFF08\u4EC5 Angular \u6838\u5FC3\uFF09" }
       ]
     });
-    if (isCancel8(uiLib)) {
+    if (isCancel8(uiLibResult)) {
       outro2("\u5DF2\u53D6\u6D88");
       return;
     }
-    cssFramework = await select2({
+    uiLib = uiLibResult;
+    const cssResult = await select2({
       message: "\u9009\u62E9 CSS \u65B9\u6848\uFF1A",
       options: [
         { value: "tailwind", label: "Tailwind CSS" },
         { value: "none", label: "\u6807\u51C6 CSS" }
       ]
     });
-    if (isCancel8(cssFramework)) {
+    if (isCancel8(cssResult)) {
       outro2("\u5DF2\u53D6\u6D88");
       return;
     }
+    cssFramework = cssResult;
   }
   const backendChoice = await select2({
     message: "\u9009\u62E9\u540E\u7AEF\u6846\u67B6\uFF1A",
@@ -6427,39 +6465,42 @@ async function runInteractiveMode(targetDir) {
   let migration;
   let aiChoice;
   if (backendChoice === "java") {
-    orm = await select2({
+    const ormResult = await select2({
       message: "\u9009\u62E9 ORM \u6846\u67B6\uFF1A",
       options: [
         { value: "hibernate", label: "Hibernate" },
         { value: "none", label: "\u65E0" }
       ]
     });
-    if (isCancel8(orm)) {
+    if (isCancel8(ormResult)) {
       outro2("\u5DF2\u53D6\u6D88");
       return;
     }
-    migration = await select2({
+    orm = ormResult;
+    const migrationResult = await select2({
       message: "\u9009\u62E9\u6570\u636E\u5E93\u8FC1\u79FB\u5DE5\u5177\uFF1A",
       options: [
         { value: "liquibase", label: "Liquibase" },
         { value: "none", label: "\u65E0" }
       ]
     });
-    if (isCancel8(migration)) {
+    if (isCancel8(migrationResult)) {
       outro2("\u5DF2\u53D6\u6D88");
       return;
     }
-    aiChoice = await select2({
+    migration = migrationResult;
+    const aiResult = await select2({
       message: "\u9009\u62E9 AI \u6846\u67B6\uFF1A",
       options: [
         { value: "spring-ai", label: "Spring AI" },
         { value: "none", label: "\u65E0" }
       ]
     });
-    if (isCancel8(aiChoice)) {
+    if (isCancel8(aiResult)) {
       outro2("\u5DF2\u53D6\u6D88");
       return;
     }
+    aiChoice = aiResult;
   }
   if ((!frontendChoice || frontendChoice === "none") && (!backendChoice || backendChoice === "none")) {
     console.error("\u274C \u81F3\u5C11\u9700\u8981\u9009\u62E9\u524D\u7AEF\u6216\u540E\u7AEF\u4E4B\u4E00");
@@ -6481,18 +6522,19 @@ async function runInteractiveMode(targetDir) {
   return opts;
 }
 async function runInit(baseDir, opts) {
-  if (!opts.projectName) {
-    throw new Error("\u9879\u76EE\u540D\u79F0\u4E3A\u5FC5\u586B\u9879");
-  }
-  if (!VALID_PROJECT_NAME.test(opts.projectName)) {
-    throw new Error(`\u9879\u76EE\u540D "${opts.projectName}" \u5305\u542B\u975E\u6CD5\u5B57\u7B26\u3002\u4EC5\u652F\u6301\u5B57\u6BCD\u3001\u6570\u5B57\u3001\u4E0B\u5212\u7EBF\u548C\u77ED\u6A2A\u7EBF\u3002`);
+  const inPlace = !opts.projectName;
+  const projectName = inPlace ? "project" : opts.projectName;
+  if (!inPlace && !VALID_PROJECT_NAME.test(projectName)) {
+    throw new Error(`\u9879\u76EE\u540D "${projectName}" \u5305\u542B\u975E\u6CD5\u5B57\u7B26\u3002\u4EC5\u652F\u6301\u5B57\u6BCD\u3001\u6570\u5B57\u3001\u4E0B\u5212\u7EBF\u548C\u77ED\u6A2A\u7EBF\u3002`);
   }
-  const projectDir = path2.join(baseDir, opts.projectName);
-  if (fs2.existsSync(projectDir)) {
+  const projectDir = inPlace ? baseDir : path2.join(baseDir, projectName);
+  if (!inPlace && fs2.existsSync(projectDir)) {
     throw new Error(`\u76EE\u6807\u76EE\u5F55 ${projectDir} \u5DF2\u5B58\u5728\u3002\u8BF7\u5220\u9664\u540E\u91CD\u8BD5\u6216\u4F7F\u7528\u5176\u4ED6\u9879\u76EE\u540D\u3002`);
   }
+  if (!inPlace) {
+    fs2.mkdirSync(projectDir, { recursive: true });
+  }
   const ctx = buildContext(opts);
-  fs2.mkdirSync(projectDir, { recursive: true });
   const hasFrontend = opts.frontend === "angular";
   const hasBackend = opts.backend === "java";
   try {
@@ -6506,13 +6548,18 @@ async function runInit(baseDir, opts) {
     console.log(`
 \u2714 \u9879\u76EE\u5DF2\u521B\u5EFA: ${projectDir}`);
     console.log("\n\u4E0B\u4E00\u6B65:");
-    console.log(`  cd ${opts.projectName}`);
+    if (!inPlace) {
+      console.log(`  cd ${opts.projectName}`);
+    }
     if (opts.frontend) console.log(`  pnpm install        # \u5B89\u88C5\u524D\u7AEF\u4F9D\u8D56`);
     if (opts.backend) console.log(`  ./gradlew build      # \u6784\u5EFA\u540E\u7AEF`);
     console.log();
     printProjectTree(projectDir, hasFrontend, hasBackend);
+    if (inPlace) {
+      initClaudeMd(baseDir, opts);
+    }
   } catch (err) {
-    if (fs2.existsSync(projectDir)) {
+    if (!inPlace && fs2.existsSync(projectDir)) {
       fs2.rmSync(projectDir, { recursive: true, force: true });
     }
     throw err;
@@ -7018,7 +7065,7 @@ __pycache__/
 .vscode/
 *.iml
 `);
-  writeTemplate(projectDir, ".env.example", `# \u6570\u636E\u5E93\u914D\u7F6E
+  writeEnvFile(projectDir, `# \u6570\u636E\u5E93\u914D\u7F6E
 DB_URL=jdbc:postgresql://localhost:5432/${ctx.packageName}
 DB_USERNAME=postgres
 DB_PASSWORD=change-me
@@ -7076,9 +7123,23 @@ function ensureDir2(dir) {
 }
 function writeTemplate(baseDir, relativePath, content) {
   const fullPath = path2.join(baseDir, relativePath);
+  if (fs2.existsSync(fullPath)) {
+    console.log(`  \u2139 \u8DF3\u8FC7\u5DF2\u6709\u6587\u4EF6: ${relativePath}`);
+    return;
+  }
   ensureDir2(path2.dirname(fullPath));
   fs2.writeFileSync(fullPath, content, "utf-8");
 }
+function writeEnvFile(baseDir, content) {
+  const envPath = path2.join(baseDir, ".env");
+  ensureDir2(path2.dirname(envPath));
+  if (fs2.existsSync(envPath)) {
+    const existing = fs2.readFileSync(envPath, "utf-8").trimEnd();
+    fs2.writeFileSync(envPath, existing + "\n\n" + content, "utf-8");
+  } else {
+    fs2.writeFileSync(envPath, content, "utf-8");
+  }
+}
 function printProjectTree(projectDir, hasFrontend, hasBackend) {
   console.log("\u76EE\u5F55\u7ED3\u6784:");
   console.log(`  ${path2.basename(projectDir)}/`);
@@ -7109,13 +7170,90 @@ function printProjectTree(projectDir, hasFrontend, hasBackend) {
   }
 }
 
-// src/merger/mcp.ts
+// src/utils/auto-install.ts
 var fs3 = __toESM(require("node:fs"));
+var path3 = __toESM(require("node:path"));
+var import_node_child_process = require("node:child_process");
+var EXEC_OPTIONS = { encoding: "utf-8", timeout: 12e4, stdio: "pipe" };
+function execSafe(command) {
+  try {
+    const output = (0, import_node_child_process.execSync)(command, EXEC_OPTIONS);
+    return { success: true, output: output.toString() };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { success: false, output: message };
+  }
+}
+function isBmadInstalled() {
+  const result = execSafe("npx bmad-method status");
+  return result.success && result.output.includes("Version:");
+}
+function isGrillMeInstalled(targetDir) {
+  return fs3.existsSync(path3.join(targetDir, ".claude", "skills", "grill-me", "SKILL.md"));
+}
+function installBmadMethod() {
+  if (isBmadInstalled()) {
+    console.log("\u2139 BMAD Method \u5DF2\u5B58\u5728\uFF0C\u8DF3\u8FC7\u5B89\u88C5");
+    return;
+  }
+  const result = execSafe("npx bmad-method install");
+  if (result.success) {
+    console.log("\u2714 BMAD Method \u5DF2\u5B89\u88C5");
+  } else {
+    console.log("\u26A0 BMAD Method \u5B89\u88C5\u5931\u8D25\uFF0C\u8BF7\u624B\u52A8\u6267\u884C npx bmad-method install");
+  }
+}
+function installGrillMe(targetDir) {
+  if (isGrillMeInstalled(targetDir)) {
+    console.log("\u2139 grill-me \u5DF2\u5B58\u5728\uFF0C\u8DF3\u8FC7\u5B89\u88C5");
+    return;
+  }
+  const skillDir = path3.join(targetDir, ".claude", "skills", "grill-me");
+  fs3.mkdirSync(skillDir, { recursive: true });
+  try {
+    (0, import_node_child_process.execSync)(
+      "curl -fsSL https://raw.githubusercontent.com/mattpocock/skills/main/grill-me/SKILL.md -o SKILL.md",
+      { ...EXEC_OPTIONS, cwd: skillDir }
+    );
+    console.log("\u2714 grill-me skill \u5DF2\u5B89\u88C5");
+  } catch {
+    console.log("\u26A0 grill-me \u5B89\u88C5\u5931\u8D25\uFF0C\u8BF7\u624B\u52A8\u5B89\u88C5 https://github.com/mattpocock/skills");
+  }
+}
+function isPlaywrightInstalled(targetDir) {
+  const result = execSafe("npx playwright install --dry-run");
+  return result.success && !result.output.toLowerCase().includes("to install");
+}
+function installPlaywright(config, targetDir) {
+  if (config["sweep.e2eFramework"] !== "playwright") return;
+  if (isPlaywrightInstalled(targetDir)) {
+    console.log("\u2139 Playwright \u6D4F\u89C8\u5668\u5DF2\u5B58\u5728\uFF0C\u8DF3\u8FC7\u5B89\u88C5");
+    return;
+  }
+  const result = execSafe("npx playwright install");
+  if (result.success) {
+    console.log("\u2714 Playwright \u6D4F\u89C8\u5668\u5DF2\u5B89\u88C5");
+  } else {
+    console.log("\u26A0 Playwright \u6D4F\u89C8\u5668\u5B89\u88C5\u5931\u8D25\uFF0C\u8BF7\u624B\u52A8\u6267\u884C npx playwright install");
+  }
+}
+function step9AutoInstallDeps(tools, config, targetDir) {
+  if (tools.includes("tide")) {
+    installBmadMethod();
+    installGrillMe(targetDir);
+  }
+  if (tools.includes("sweep")) {
+    installPlaywright(config, targetDir);
+  }
+}
+
+// src/merger/mcp.ts
+var fs4 = __toESM(require("node:fs"));
 function mergeMcpServers(mcpPath, servers) {
   let mcp = {};
   try {
-    if (fs3.existsSync(mcpPath)) {
-      const raw = fs3.readFileSync(mcpPath, "utf-8");
+    if (fs4.existsSync(mcpPath)) {
+      const raw = fs4.readFileSync(mcpPath, "utf-8");
       mcp = JSON.parse(raw);
     }
   } catch {
@@ -7123,31 +7261,31 @@ function mergeMcpServers(mcpPath, servers) {
   }
   const existingServers = mcp.mcpServers || {};
   mcp.mcpServers = deepMerge(existingServers, servers);
-  fs3.writeFileSync(mcpPath, JSON.stringify(mcp, null, 2) + "\n", "utf-8");
+  fs4.writeFileSync(mcpPath, JSON.stringify(mcp, null, 2) + "\n", "utf-8");
 }
 
 // src/merger/hooks.ts
-var fs4 = __toESM(require("node:fs"));
+var fs5 = __toESM(require("node:fs"));
 function mergeHooks(hooksPath, hooks) {
   let existing = {};
   try {
-    if (fs4.existsSync(hooksPath)) {
-      const raw = fs4.readFileSync(hooksPath, "utf-8");
+    if (fs5.existsSync(hooksPath)) {
+      const raw = fs5.readFileSync(hooksPath, "utf-8");
       existing = JSON.parse(raw);
     }
   } catch {
     existing = {};
   }
   const merged = deepMerge(existing, hooks);
-  fs4.writeFileSync(hooksPath, JSON.stringify(merged, null, 2) + "\n", "utf-8");
+  fs5.writeFileSync(hooksPath, JSON.stringify(merged, null, 2) + "\n", "utf-8");
 }
 
 // src/wizard/mcp-env.ts
-var fs5 = __toESM(require("node:fs"));
-var path3 = __toESM(require("node:path"));
+var fs6 = __toESM(require("node:fs"));
+var path4 = __toESM(require("node:path"));
 function parseEnvExampleFile(filePath) {
-  if (!fs5.existsSync(filePath)) return [];
-  const content = fs5.readFileSync(filePath, "utf-8");
+  if (!fs6.existsSync(filePath)) return [];
+  const content = fs6.readFileSync(filePath, "utf-8");
   const lines = content.split("\n");
   const entries = [];
   let lastComment = "";
@@ -7173,7 +7311,7 @@ function getMcpEnvStubs(selectedTools, examplesDir) {
   if (!examplesDir) return [];
   const result = [];
   for (const tool of selectedTools) {
-    const filePath = path3.join(examplesDir, `${tool}.env-example`);
+    const filePath = path4.join(examplesDir, `${tool}.env-example`);
     const entries = parseEnvExampleFile(filePath);
     result.push(...entries);
   }
@@ -7182,9 +7320,9 @@ function getMcpEnvStubs(selectedTools, examplesDir) {
 function collectEnvSections(selectedTools, examplesDir, existingKeys) {
   const sections = [];
   for (const tool of selectedTools) {
-    const filePath = path3.join(examplesDir, `${tool}.env-example`);
-    if (!fs5.existsSync(filePath)) continue;
-    const content = fs5.readFileSync(filePath, "utf-8").trimEnd();
+    const filePath = path4.join(examplesDir, `${tool}.env-example`);
+    if (!fs6.existsSync(filePath)) continue;
+    const content = fs6.readFileSync(filePath, "utf-8").trimEnd();
     const entries = parseEnvExampleFile(filePath);
     const allExist = entries.every((e) => existingKeys.has(e.key));
     if (allExist) continue;
@@ -7220,7 +7358,7 @@ function filterExistingKeys(content, existingKeys) {
 
 // src/wizard/wizard-flow.ts
 var p4 = __toESM(require("@clack/prompts"));
-var fs7 = __toESM(require("node:fs"));
+var fs8 = __toESM(require("node:fs"));
 
 // src/wizard/tool-select.ts
 var p = __toESM(require("@clack/prompts"));
@@ -7612,7 +7750,7 @@ function parseFrontmatter(content) {
 }
 
 // src/template/registry.ts
-var fs6 = __toESM(require("node:fs"));
+var fs7 = __toESM(require("node:fs"));
 function buildMcpCapabilities(mcpCapabilities, installedMcpServers, mcpTools) {
   const installedSet = new Set(installedMcpServers);
   const result = {};
@@ -7637,8 +7775,8 @@ function deriveVariableName(frontmatter) {
   return "tide_capabilities";
 }
 function injectSkillCapabilities(tmplFilePath, baseVariables, installedMcpServers, mcpTools, variableName) {
-  if (!fs6.existsSync(tmplFilePath)) return baseVariables;
-  const content = fs6.readFileSync(tmplFilePath, "utf-8");
+  if (!fs7.existsSync(tmplFilePath)) return baseVariables;
+  const content = fs7.readFileSync(tmplFilePath, "utf-8");
   const fm = parseFrontmatter(content);
   if (!fm) return baseVariables;
   const mcpCapabilities = fm.mcpCapabilities;
@@ -7732,9 +7870,9 @@ function buildTemplateVariables(registry2, config, installedMcpTools = []) {
 // src/wizard/wizard-flow.ts
 function loadExistingConfigKeys(targetDir) {
   const settingsPath = getDeepStormConfigPath(targetDir);
-  if (!fs7.existsSync(settingsPath)) return /* @__PURE__ */ new Set();
+  if (!fs8.existsSync(settingsPath)) return /* @__PURE__ */ new Set();
   try {
-    const raw = fs7.readFileSync(settingsPath, "utf-8");
+    const raw = fs8.readFileSync(settingsPath, "utf-8");
     const config = JSON.parse(raw);
     if (!config || Object.keys(config).length === 0) return /* @__PURE__ */ new Set();
     const keys = /* @__PURE__ */ new Set();
@@ -7793,16 +7931,16 @@ async function runWizardFlow(reader, registry2, initialMcpValues, targetDir) {
 }
 
 // src/wizard/reconfigure.ts
-var fs8 = __toESM(require("node:fs"));
-var path4 = __toESM(require("node:path"));
+var fs9 = __toESM(require("node:fs"));
+var path5 = __toESM(require("node:path"));
 function cleanInstalled(targetDir) {
   const settingsPath = getDeepStormConfigPath(targetDir);
-  if (!fs8.existsSync(settingsPath)) {
+  if (!fs9.existsSync(settingsPath)) {
     return;
   }
   let config;
   try {
-    config = JSON.parse(fs8.readFileSync(settingsPath, "utf-8"));
+    config = JSON.parse(fs9.readFileSync(settingsPath, "utf-8"));
   } catch {
     return;
   }
@@ -7810,41 +7948,41 @@ function cleanInstalled(targetDir) {
   const installedSkills = config.installedSkills;
   if (installedSkills) {
     for (const skillId of installedSkills) {
-      const skillDir = path4.join(targetDir, ".claude", "skills", skillId);
-      if (fs8.existsSync(skillDir)) {
-        fs8.rmSync(skillDir, { recursive: true, force: true });
+      const skillDir = path5.join(targetDir, ".claude", "skills", skillId);
+      if (fs9.existsSync(skillDir)) {
+        fs9.rmSync(skillDir, { recursive: true, force: true });
       }
     }
   }
   const installedAgents = config.installedAgents;
   if (installedAgents) {
     for (const agent of installedAgents) {
-      const agentDir = path4.join(targetDir, ".claude", "agents", agent);
-      if (fs8.existsSync(agentDir)) {
-        fs8.rmSync(agentDir, { recursive: true, force: true });
+      const agentDir = path5.join(targetDir, ".claude", "agents", agent);
+      if (fs9.existsSync(agentDir)) {
+        fs9.rmSync(agentDir, { recursive: true, force: true });
       }
     }
   }
-  const hooksJson = path4.join(targetDir, ".claude", "hooks.json");
-  if (fs8.existsSync(hooksJson)) {
-    fs8.rmSync(hooksJson, { force: true });
+  const hooksJson = path5.join(targetDir, ".claude", "hooks.json");
+  if (fs9.existsSync(hooksJson)) {
+    fs9.rmSync(hooksJson, { force: true });
   }
-  const hooksDir = path4.join(targetDir, ".claude", "hooks");
-  if (fs8.existsSync(hooksDir)) {
-    fs8.rmSync(hooksDir, { recursive: true, force: true });
+  const hooksDir = path5.join(targetDir, ".claude", "hooks");
+  if (fs9.existsSync(hooksDir)) {
+    fs9.rmSync(hooksDir, { recursive: true, force: true });
   }
   const installedMcp = config.installedMcpServers;
   if (installedMcp) {
-    const mcpPath = path4.join(targetDir, ".mcp.json");
-    if (fs8.existsSync(mcpPath)) {
+    const mcpPath = path5.join(targetDir, ".mcp.json");
+    if (fs9.existsSync(mcpPath)) {
       try {
-        const mcp = JSON.parse(fs8.readFileSync(mcpPath, "utf-8"));
+        const mcp = JSON.parse(fs9.readFileSync(mcpPath, "utf-8"));
         if (mcp.mcpServers) {
           for (const serverName of installedMcp) {
             delete mcp.mcpServers[`deepstorm-${serverName}`];
           }
         }
-        fs8.writeFileSync(mcpPath, JSON.stringify(mcp, null, 2) + "\n", "utf-8");
+        fs9.writeFileSync(mcpPath, JSON.stringify(mcp, null, 2) + "\n", "utf-8");
       } catch {
       }
     }
@@ -7871,8 +8009,8 @@ function parseNonInteractiveArgs(toolsStr, setValues) {
 }
 
 // src/wizard/guide.ts
-var fs9 = __toESM(require("node:fs"));
-var path5 = __toESM(require("node:path"));
+var fs10 = __toESM(require("node:fs"));
+var path6 = __toESM(require("node:path"));
 var import_prompts = require("@clack/prompts");
 function printMcpEnvStatus(mcpTools, installedMcpServices, examplesDir, targetDir) {
   const allMcp = [.../* @__PURE__ */ new Set([...mcpTools, ...installedMcpServices])];
@@ -7880,8 +8018,8 @@ function printMcpEnvStatus(mcpTools, installedMcpServices, examplesDir, targetDi
   console.log("");
   console.log("  \u73AF\u5883\u53D8\u91CF\u914D\u7F6E\u72B6\u6001\uFF1A");
   for (const mcp of allMcp) {
-    const filePath = path5.join(examplesDir, `${mcp}.env-example`);
-    if (!fs9.existsSync(filePath)) {
+    const filePath = path6.join(examplesDir, `${mcp}.env-example`);
+    if (!fs10.existsSync(filePath)) {
       console.log(`  \u2139 ${mcp}: \u65E0\u9700\u73AF\u5883\u53D8\u91CF\u914D\u7F6E`);
       continue;
     }
@@ -7890,10 +8028,10 @@ function printMcpEnvStatus(mcpTools, installedMcpServices, examplesDir, targetDi
       console.log(`  \u2139 ${mcp}: \u65E0\u9700\u73AF\u5883\u53D8\u91CF\u914D\u7F6E`);
       continue;
     }
-    const dotEnvPath = path5.join(targetDir, ".env");
+    const dotEnvPath = path6.join(targetDir, ".env");
     const dotEnvMap = /* @__PURE__ */ new Map();
-    if (fs9.existsSync(dotEnvPath)) {
-      const content = fs9.readFileSync(dotEnvPath, "utf-8");
+    if (fs10.existsSync(dotEnvPath)) {
+      const content = fs10.readFileSync(dotEnvPath, "utf-8");
       for (const line of content.split("\n")) {
         const trimmed = line.trim();
         if (trimmed.includes("=") && !trimmed.startsWith("#")) {
@@ -7906,7 +8044,7 @@ function printMcpEnvStatus(mcpTools, installedMcpServices, examplesDir, targetDi
         }
       }
     }
-    const envDefaultContent = fs9.readFileSync(filePath, "utf-8");
+    const envDefaultContent = fs10.readFileSync(filePath, "utf-8");
     const defaults = /* @__PURE__ */ new Map();
     for (const line of envDefaultContent.split("\n")) {
       const trimmed = line.trim();
@@ -7966,17 +8104,17 @@ async function printGuide(options) {
   console.log("  \u4E0B\u4E00\u6B65\uFF1A");
   console.log("    \u8FD0\u884C Claude Code\uFF0C\u8F93\u5165 /help \u67E5\u770B\u6240\u6709\u53EF\u7528\u7684 DeepStorm \u547D\u4EE4");
   console.log("");
-  const gitDir = path5.join(options.targetDir, ".git");
-  if (fs9.existsSync(gitDir)) {
+  const gitDir = path6.join(options.targetDir, ".git");
+  if (fs10.existsSync(gitDir)) {
     const shouldAdd = await (0, import_prompts.confirm)({
       message: "\u662F\u5426\u5C06 .claude/ \u914D\u7F6E\u63D0\u4EA4\u5230 Git\uFF1F(.gitignore \u9700\u8981\u5FFD\u7565 .claude/)",
       initialValue: false
     });
     if (!(0, import_prompts.isCancel)(shouldAdd) && shouldAdd) {
-      const gitignorePath = path5.join(options.targetDir, ".gitignore");
+      const gitignorePath = path6.join(options.targetDir, ".gitignore");
       let isIgnored = false;
-      if (fs9.existsSync(gitignorePath)) {
-        const gitignore = fs9.readFileSync(gitignorePath, "utf-8");
+      if (fs10.existsSync(gitignorePath)) {
+        const gitignore = fs10.readFileSync(gitignorePath, "utf-8");
         isIgnored = gitignore.split("\n").some((line) => {
           const trimmed = line.trim();
           return trimmed === ".claude" || trimmed === ".claude/" || trimmed === ".claude/**";
@@ -7995,25 +8133,25 @@ async function printGuide(options) {
 }
 
 // src/template/renderer.ts
-var fs11 = __toESM(require("node:fs"));
-var path7 = __toESM(require("node:path"));
+var fs12 = __toESM(require("node:fs"));
+var path8 = __toESM(require("node:path"));
 var import_handlebars = __toESM(require_lib());
 
 // src/utils/fs.ts
-var fs10 = __toESM(require("node:fs"));
-var path6 = __toESM(require("node:path"));
+var fs11 = __toESM(require("node:fs"));
+var path7 = __toESM(require("node:path"));
 function ensureDir3(dir) {
-  fs10.mkdirSync(dir, { recursive: true });
+  fs11.mkdirSync(dir, { recursive: true });
 }
 function copyDir(src, dest) {
-  fs10.cpSync(src, dest, { recursive: true, force: true });
+  fs11.cpSync(src, dest, { recursive: true, force: true });
 }
 function removeDirContents(dir) {
-  const entries = fs10.readdirSync(dir);
+  const entries = fs11.readdirSync(dir);
   for (const entry of entries) {
     if (entry === ".DS_Store") continue;
-    const fullPath = path6.join(dir, entry);
-    fs10.rmSync(fullPath, { recursive: true, force: true });
+    const fullPath = path7.join(dir, entry);
+    fs11.rmSync(fullPath, { recursive: true, force: true });
   }
 }
 
@@ -8034,38 +8172,38 @@ function toNested(vars) {
 }
 var compiledCache = /* @__PURE__ */ new Map();
 function renderTemplate(tmplPath, variables, outputPath) {
-  if (!fs11.existsSync(tmplPath)) {
+  if (!fs12.existsSync(tmplPath)) {
     throw new Error(`\u6A21\u677F\u6587\u4EF6\u4E0D\u5B58\u5728: ${tmplPath}`);
   }
   let templateFn = compiledCache.get(tmplPath);
   if (!templateFn) {
-    const source = fs11.readFileSync(tmplPath, "utf-8");
+    const source = fs12.readFileSync(tmplPath, "utf-8");
     templateFn = import_handlebars.default.compile(source, { noEscape: true });
     compiledCache.set(tmplPath, templateFn);
   }
   const nestedVars = toNested(variables);
   const content = templateFn(nestedVars);
-  ensureDir3(path7.dirname(outputPath));
-  fs11.writeFileSync(outputPath, content, "utf-8");
+  ensureDir3(path8.dirname(outputPath));
+  fs12.writeFileSync(outputPath, content, "utf-8");
 }
 function copyVariants(sourceVariantsDir, selectedValue, targetDir, clean = false) {
-  const variantDir = path7.join(sourceVariantsDir, selectedValue);
-  if (!fs11.existsSync(variantDir)) {
+  const variantDir = path8.join(sourceVariantsDir, selectedValue);
+  if (!fs12.existsSync(variantDir)) {
     console.warn(
       `[template] \u26A0 \u53D8\u4F53\u76EE\u5F55\u4E0D\u5B58\u5728: ${variantDir}\uFF08\u76F8\u5BF9\u4E8E ${sourceVariantsDir}\uFF09\uFF0C\u8DF3\u8FC7`
     );
     return;
   }
-  if (clean && fs11.existsSync(targetDir)) {
+  if (clean && fs12.existsSync(targetDir)) {
     removeDirContents(targetDir);
   }
   ensureDir3(targetDir);
-  const entries = fs11.readdirSync(variantDir);
+  const entries = fs12.readdirSync(variantDir);
   for (const entry of entries) {
     if (entry === ".DS_Store") continue;
-    const src = path7.join(variantDir, entry);
-    const dest = path7.join(targetDir, entry);
-    fs11.cpSync(src, dest, { recursive: true, force: true });
+    const src = path8.join(variantDir, entry);
+    const dest = path8.join(targetDir, entry);
+    fs12.cpSync(src, dest, { recursive: true, force: true });
   }
 }
 
@@ -8093,7 +8231,7 @@ async function runSetup(reader, targetDir, cliDir2, options, registry2) {
   let selectedMcpTools = [];
   let templateVariables = {};
   let enabledMcpJsonServers = [];
-  const examplesDir = path8.join(cliDir2, "env-examples");
+  const examplesDir = path9.join(cliDir2, "env-examples");
   const installedSkillIds = [];
   if (options.nonInteractive) {
     const parsed = parseNonInteractiveArgs(options.tools, options.set);
@@ -8121,7 +8259,7 @@ async function runSetup(reader, targetDir, cliDir2, options, registry2) {
     templateVariables = wizardResult.templateVariables;
   }
   if (selectedMcpTools.length > 0) {
-    const mcpPath = path8.join(targetDir, ".mcp.json");
+    const mcpPath = path9.join(targetDir, ".mcp.json");
     const servers = loadMcpServerConfigs(cliDir2, selectedMcpTools);
     mergeMcpServers(mcpPath, servers);
     enabledMcpJsonServers = Object.keys(servers);
@@ -8133,13 +8271,13 @@ async function runSetup(reader, targetDir, cliDir2, options, registry2) {
     installedSkillIds.push(...ids);
   }
   if (shouldInstallGlobalHooks(tools, reader)) {
-    const hooksSrcDir = path8.join(cliDir2, "hooks");
-    const destHooksJson = path8.join(targetDir, ".claude", "hooks.json");
+    const hooksSrcDir = path9.join(cliDir2, "hooks");
+    const destHooksJson = path9.join(targetDir, ".claude", "hooks.json");
     for (const tool of tools) {
-      const toolHooksJsonPath = path8.join(hooksSrcDir, `${tool}-hooks.json`);
-      if (fs12.existsSync(toolHooksJsonPath)) {
-        ensureDir3(path8.join(targetDir, ".claude"));
-        const incoming = JSON.parse(fs12.readFileSync(toolHooksJsonPath, "utf-8"));
+      const toolHooksJsonPath = path9.join(hooksSrcDir, `${tool}-hooks.json`);
+      if (fs13.existsSync(toolHooksJsonPath)) {
+        ensureDir3(path9.join(targetDir, ".claude"));
+        const incoming = JSON.parse(fs13.readFileSync(toolHooksJsonPath, "utf-8"));
         mergeHooks(destHooksJson, incoming);
       }
     }
@@ -8165,7 +8303,7 @@ async function runSetup(reader, targetDir, cliDir2, options, registry2) {
   const frontend = nestedConfig.reef?.frontend?.framework ?? void 0;
   const backend = nestedConfig.reef?.backend?.language ?? void 0;
   initContextMap(targetDir, { frontend, backend, projectName: "" });
-  const claudeSettingsPath = path8.join(targetDir, ".claude", "settings.json");
+  const claudeSettingsPath = path9.join(targetDir, ".claude", "settings.json");
   if (enabledMcpJsonServers.length > 0) {
     writeEnabledMcpJsonServers(claudeSettingsPath, enabledMcpJsonServers);
     const servers = loadMcpServerConfigs(cliDir2, selectedMcpTools);
@@ -8173,13 +8311,13 @@ async function runSetup(reader, targetDir, cliDir2, options, registry2) {
   }
   mergeSandboxDisabled(claudeSettingsPath);
   if (selectedMcpTools.length > 0) {
-    const envPath = path8.join(targetDir, ".env");
+    const envPath = path9.join(targetDir, ".env");
     const existingKeys = readExistingEnvKeys(envPath);
     const sections = collectEnvSections(selectedMcpTools, examplesDir, existingKeys);
     if (sections.length > 0) {
       let existing = "";
-      if (fs12.existsSync(envPath)) {
-        existing = fs12.readFileSync(envPath, "utf-8").trimEnd();
+      if (fs13.existsSync(envPath)) {
+        existing = fs13.readFileSync(envPath, "utf-8").trimEnd();
       }
       const deepstormHeader = [
         "# \u2500\u2500 DeepStorm \u2500\u2500",
@@ -8194,7 +8332,7 @@ async function runSetup(reader, targetDir, cliDir2, options, registry2) {
         ""
       ].join("\n");
       const content = existing ? existing + "\n\n" + deepstormHeader + sections.join("\n\n") + "\n" : deepstormHeader + sections.join("\n\n") + "\n";
-      fs12.writeFileSync(envPath, content, "utf-8");
+      fs13.writeFileSync(envPath, content, "utf-8");
       console.log(`\u2714 \u5DF2\u751F\u6210 .env \u73AF\u5883\u53D8\u91CF\u6A21\u677F`);
     }
   }
@@ -8210,6 +8348,7 @@ async function runSetup(reader, targetDir, cliDir2, options, registry2) {
     mcpTools: selectedMcpTools.length > 0 ? selectedMcpTools : void 0,
     mcpEnvStubs: mcpEnvStubs.length > 0 ? mcpEnvStubs : void 0
   });
+  step9AutoInstallDeps(tools, config, targetDir);
 }
 function shouldSkipSkill(skill, config) {
   if (!skill.configKey) return false;
@@ -8229,9 +8368,9 @@ function shouldSkipAgent(agentFile, config) {
 }
 function renderToolAssets(tool, reader, cliDir2, targetDir, templateVariables, config, registry2, installedMcpTools = [], targetSubDir = ".claude", skillIdFilter) {
   const installedSkillIds = [];
-  const targetSkillsDir = targetSubDir ? path8.join(targetDir, targetSubDir, "skills") : path8.join(targetDir, "skills");
+  const targetSkillsDir = targetSubDir ? path9.join(targetDir, targetSubDir, "skills") : path9.join(targetDir, "skills");
   const toolSkills = reader.getToolSkills(tool);
-  const skillsDir = path8.join(cliDir2, "skills");
+  const skillsDir = path9.join(cliDir2, "skills");
   for (const skill of toolSkills) {
     const skillId = getSkillId(skill, registry2);
     if (!skillId) continue;
@@ -8240,12 +8379,12 @@ function renderToolAssets(tool, reader, cliDir2, targetDir, templateVariables, c
       console.log(`  \u23ED ${skillId}\uFF1A\u4F9D\u8D56 ${skill.configKey} \u672A\u914D\u7F6E\uFF0C\u8DF3\u8FC7`);
       continue;
     }
-    const srcDir = path8.join(skillsDir, skillId);
-    const targetDirPath = path8.join(targetSkillsDir, skillId);
-    if (!fs12.existsSync(srcDir)) continue;
-    const tmplPath = path8.join(srcDir, "SKILL.md.tmpl");
-    const variantsDir = path8.join(srcDir, "variants");
-    if (fs12.existsSync(tmplPath)) {
+    const srcDir = path9.join(skillsDir, skillId);
+    const targetDirPath = path9.join(targetSkillsDir, skillId);
+    if (!fs13.existsSync(srcDir)) continue;
+    const tmplPath = path9.join(srcDir, "SKILL.md.tmpl");
+    const variantsDir = path9.join(srcDir, "variants");
+    if (fs13.existsSync(tmplPath)) {
       const enrichedVars = injectSkillCapabilities(
         tmplPath,
         templateVariables,
@@ -8256,7 +8395,7 @@ function renderToolAssets(tool, reader, cliDir2, targetDir, templateVariables, c
       renderTemplate(
         tmplPath,
         enrichedVars,
-        path8.join(targetDirPath, "SKILL.md")
+        path9.join(targetDirPath, "SKILL.md")
       );
       copyVariantsForConfig(variantsDir, config, targetDirPath, skill.configKey);
       copyFragmentsForSkill(skillId, srcDir, config, registry2, targetDirPath);
@@ -8267,9 +8406,9 @@ function renderToolAssets(tool, reader, cliDir2, targetDir, templateVariables, c
     installedSkillIds.push(skillId);
   }
   const toolAgents = reader.getToolAgents(tool);
-  const agentsSrcDir = path8.join(cliDir2, "agents");
-  const targetAgentsDir = targetSubDir ? path8.join(targetDir, targetSubDir, "agents") : path8.join(targetDir, "agents");
-  if (fs12.existsSync(agentsSrcDir)) {
+  const agentsSrcDir = path9.join(cliDir2, "agents");
+  const targetAgentsDir = targetSubDir ? path9.join(targetDir, targetSubDir, "agents") : path9.join(targetDir, "agents");
+  if (fs13.existsSync(agentsSrcDir)) {
     ensureDir3(targetAgentsDir);
     for (const agentFile of toolAgents) {
       if (shouldSkipAgent(agentFile, config)) {
@@ -8277,38 +8416,38 @@ function renderToolAssets(tool, reader, cliDir2, targetDir, templateVariables, c
         console.log(`  \u23ED ${base}\uFF1A\u4F9D\u8D56\u672A\u914D\u7F6E\uFF0C\u8DF3\u8FC7`);
         continue;
       }
-      const srcPath = path8.join(agentsSrcDir, agentFile);
-      if (!fs12.existsSync(srcPath)) {
-        const tmplSrcPath = path8.join(agentsSrcDir, agentFile.replace(/\.md$/, ".md.tmpl"));
-        if (fs12.existsSync(tmplSrcPath)) {
+      const srcPath = path9.join(agentsSrcDir, agentFile);
+      if (!fs13.existsSync(srcPath)) {
+        const tmplSrcPath = path9.join(agentsSrcDir, agentFile.replace(/\.md$/, ".md.tmpl"));
+        if (fs13.existsSync(tmplSrcPath)) {
           const outputName = agentFile.replace(/\.tmpl$/, "");
           renderTemplate(
             tmplSrcPath,
             templateVariables,
-            path8.join(targetAgentsDir, outputName)
+            path9.join(targetAgentsDir, outputName)
           );
         }
         continue;
       }
-      copyDir(srcPath, path8.join(targetAgentsDir, agentFile));
+      copyDir(srcPath, path9.join(targetAgentsDir, agentFile));
     }
   }
   const toolHooks = reader.getToolHooks(tool);
-  const hooksSrcDir = path8.join(cliDir2, "hooks");
-  const targetHooksDir = targetSubDir ? path8.join(targetDir, targetSubDir, "hooks") : path8.join(targetDir, "hooks");
-  if (fs12.existsSync(hooksSrcDir)) {
+  const hooksSrcDir = path9.join(cliDir2, "hooks");
+  const targetHooksDir = targetSubDir ? path9.join(targetDir, targetSubDir, "hooks") : path9.join(targetDir, "hooks");
+  if (fs13.existsSync(hooksSrcDir)) {
     ensureDir3(targetHooksDir);
     for (const hookFile of toolHooks) {
-      const srcPath = path8.join(hooksSrcDir, hookFile);
-      if (fs12.existsSync(srcPath)) {
-        copyDir(srcPath, path8.join(targetHooksDir, hookFile));
+      const srcPath = path9.join(hooksSrcDir, hookFile);
+      if (fs13.existsSync(srcPath)) {
+        copyDir(srcPath, path9.join(targetHooksDir, hookFile));
       } else {
         const tmplPath = srcPath + ".tmpl";
-        if (fs12.existsSync(tmplPath)) {
+        if (fs13.existsSync(tmplPath)) {
           renderTemplate(
             tmplPath,
             templateVariables,
-            path8.join(targetHooksDir, hookFile)
+            path9.join(targetHooksDir, hookFile)
           );
         }
       }
@@ -8317,9 +8456,9 @@ function renderToolAssets(tool, reader, cliDir2, targetDir, templateVariables, c
   return installedSkillIds;
 }
 function installMcpSkills(tools, reader, cliDir2, targetDir, installedSkillIds, selectedMcpTools = []) {
-  const mcpSkillsDir = path8.join(cliDir2, "mcp-skills");
-  const targetSkillsDir = path8.join(targetDir, ".claude", "skills");
-  if (!fs12.existsSync(mcpSkillsDir)) return;
+  const mcpSkillsDir = path9.join(cliDir2, "mcp-skills");
+  const targetSkillsDir = path9.join(targetDir, ".claude", "skills");
+  if (!fs13.existsSync(mcpSkillsDir)) return;
   if (selectedMcpTools.length === 0) {
     console.log("\u23ED \u672A\u9009\u62E9 MCP \u670D\u52A1\uFF0C\u8DF3\u8FC7 MCP \u6280\u80FD\u5B89\u88C5");
     return;
@@ -8336,9 +8475,9 @@ function installMcpSkills(tools, reader, cliDir2, targetDir, installedSkillIds,
   }
   let installed = 0;
   for (const skillId of neededSkills) {
-    const srcDir = path8.join(mcpSkillsDir, skillId);
-    if (fs12.existsSync(srcDir)) {
-      const targetDirPath = path8.join(targetSkillsDir, skillId);
+    const srcDir = path9.join(mcpSkillsDir, skillId);
+    if (fs13.existsSync(srcDir)) {
+      const targetDirPath = path9.join(targetSkillsDir, skillId);
       copyDir(srcDir, targetDirPath);
       installedSkillIds.push(skillId);
       installed++;
@@ -8353,14 +8492,14 @@ function shouldInstallGlobalHooks(tools, reader) {
 }
 function buildUnifiedMcpCapabilities(cliDir2, installedMcpTools, mcpTools) {
   const allDeclarations = {};
-  const skillsDir = path8.join(cliDir2, "skills");
-  if (!fs12.existsSync(skillsDir)) return {};
-  const skillDirs = fs12.readdirSync(skillsDir, { withFileTypes: true });
+  const skillsDir = path9.join(cliDir2, "skills");
+  if (!fs13.existsSync(skillsDir)) return {};
+  const skillDirs = fs13.readdirSync(skillsDir, { withFileTypes: true });
   for (const entry of skillDirs) {
     if (!entry.isDirectory()) continue;
-    const tmplPath = path8.join(skillsDir, entry.name, "SKILL.md.tmpl");
-    if (!fs12.existsSync(tmplPath)) continue;
-    const content = fs12.readFileSync(tmplPath, "utf-8");
+    const tmplPath = path9.join(skillsDir, entry.name, "SKILL.md.tmpl");
+    if (!fs13.existsSync(tmplPath)) continue;
+    const content = fs13.readFileSync(tmplPath, "utf-8");
     const fm = parseFrontmatter(content);
     if (!fm) continue;
     const mcpCap = fm.mcpCapabilities;
@@ -8379,7 +8518,7 @@ function getSkillId(skill, registry2) {
   return void 0;
 }
 function copyVariantsForConfig(variantsDir, config, targetDir, configKey) {
-  if (!fs12.existsSync(variantsDir)) return;
+  if (!fs13.existsSync(variantsDir)) return;
   for (const [key, value] of Object.entries(config)) {
     if (configKey && key !== configKey) continue;
     if (value.includes(",")) continue;
@@ -8387,8 +8526,8 @@ function copyVariantsForConfig(variantsDir, config, targetDir, configKey) {
   }
 }
 function copyFragmentsForSkill(skillId, srcDir, config, registry2, targetDir) {
-  const fragmentsDir = path8.join(srcDir, "fragments");
-  if (!fs12.existsSync(fragmentsDir)) return;
+  const fragmentsDir = path9.join(srcDir, "fragments");
+  if (!fs13.existsSync(fragmentsDir)) return;
   const selectedFragments = [];
   for (const wizard of Object.values(registry2.wizards)) {
     for (const question of wizard.questions) {
@@ -8396,43 +8535,43 @@ function copyFragmentsForSkill(skillId, srcDir, config, registry2, targetDir) {
     }
   }
   if (selectedFragments.length === 0) return;
-  const targetExamplesDir = path8.join(targetDir, "examples");
+  const targetExamplesDir = path9.join(targetDir, "examples");
   for (const { category, value } of selectedFragments) {
-    const srcPath = path8.join(fragmentsDir, category, value);
-    if (!fs12.existsSync(srcPath)) continue;
-    const srcQr = path8.join(srcPath, "quick-reference.md");
-    if (fs12.existsSync(srcQr)) {
-      fs12.cpSync(srcQr, path8.join(targetDir, `${value}.md`), { force: true });
-    }
-    const srcExamples = path8.join(srcPath, "examples");
-    if (fs12.existsSync(srcExamples)) {
-      const exampleFiles = fs12.readdirSync(srcExamples);
+    const srcPath = path9.join(fragmentsDir, category, value);
+    if (!fs13.existsSync(srcPath)) continue;
+    const srcQr = path9.join(srcPath, "quick-reference.md");
+    if (fs13.existsSync(srcQr)) {
+      fs13.cpSync(srcQr, path9.join(targetDir, `${value}.md`), { force: true });
+    }
+    const srcExamples = path9.join(srcPath, "examples");
+    if (fs13.existsSync(srcExamples)) {
+      const exampleFiles = fs13.readdirSync(srcExamples);
       for (const file of exampleFiles) {
         if (file === ".DS_Store") continue;
         ensureDir3(targetExamplesDir);
-        fs12.cpSync(
-          path8.join(srcExamples, file),
-          path8.join(targetExamplesDir, `${value}-${file}`),
+        fs13.cpSync(
+          path9.join(srcExamples, file),
+          path9.join(targetExamplesDir, `${value}-${file}`),
           { force: true }
         );
       }
     }
-    const allFiles = fs12.readdirSync(srcPath);
+    const allFiles = fs13.readdirSync(srcPath);
     for (const file of allFiles) {
       if (file === ".DS_Store") continue;
       if (file === "quick-reference.md") continue;
       if (file === "examples") continue;
       if (!file.endsWith(".md")) continue;
-      fs12.cpSync(path8.join(srcPath, file), path8.join(targetDir, file), { force: true });
+      fs13.cpSync(path9.join(srcPath, file), path9.join(targetDir, file), { force: true });
     }
   }
 }
 function copyReferencesForSkill(srcDir, targetDir) {
-  const referencesDir = path8.join(srcDir, "references");
-  if (fs12.existsSync(referencesDir)) {
-    const targetReferencesDir = path8.join(targetDir, "references");
+  const referencesDir = path9.join(srcDir, "references");
+  if (fs13.existsSync(referencesDir)) {
+    const targetReferencesDir = path9.join(targetDir, "references");
     ensureDir3(targetReferencesDir);
-    fs12.cpSync(referencesDir, targetReferencesDir, { recursive: true, force: true });
+    fs13.cpSync(referencesDir, targetReferencesDir, { recursive: true, force: true });
   }
 }
 function collectFragmentsFromQuestion(question, config, selectedFragments) {
@@ -8458,15 +8597,15 @@ function collectFragmentsFromQuestion(question, config, selectedFragments) {
   }
 }
 function loadMcpServerConfigs(cliDir2, selectedTools) {
-  const mcpDir = path8.join(cliDir2, "mcp");
-  if (!fs12.existsSync(mcpDir)) return {};
+  const mcpDir = path9.join(cliDir2, "mcp");
+  if (!fs13.existsSync(mcpDir)) return {};
   const servers = {};
   function collectJsonFiles(dir) {
     const results = [];
-    for (const entry of fs12.readdirSync(dir)) {
-      const fullPath = path8.join(dir, entry);
+    for (const entry of fs13.readdirSync(dir)) {
+      const fullPath = path9.join(dir, entry);
       if (entry === ".DS_Store") continue;
-      if (fs12.statSync(fullPath).isDirectory()) {
+      if (fs13.statSync(fullPath).isDirectory()) {
         results.push(...collectJsonFiles(fullPath));
       } else if (entry.endsWith(".json")) {
         results.push(fullPath);
@@ -8477,7 +8616,7 @@ function loadMcpServerConfigs(cliDir2, selectedTools) {
   const jsonFiles = collectJsonFiles(mcpDir);
   for (const jsonPath of jsonFiles) {
     try {
-      const data = JSON.parse(fs12.readFileSync(jsonPath, "utf-8"));
+      const data = JSON.parse(fs13.readFileSync(jsonPath, "utf-8"));
       if (!data.name || !selectedTools.includes(data.name)) continue;
       if (!data.mcpServers || typeof data.mcpServers !== "object") continue;
       for (const [serverName, serverConfig] of Object.entries(data.mcpServers)) {
@@ -8523,37 +8662,37 @@ function writeEnabledMcpJsonServers(settingsPath, serverNames) {
   if (serverNames.length === 0) return;
   let settings = {};
   try {
-    if (fs12.existsSync(settingsPath)) {
-      const raw = fs12.readFileSync(settingsPath, "utf-8");
+    if (fs13.existsSync(settingsPath)) {
+      const raw = fs13.readFileSync(settingsPath, "utf-8");
       settings = JSON.parse(raw);
     }
   } catch {
     settings = {};
   }
   settings.enabledMcpjsonServers = serverNames;
-  ensureDir3(path8.dirname(settingsPath));
-  fs12.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
+  ensureDir3(path9.dirname(settingsPath));
+  fs13.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
 }
 function mergeSandboxDisabled(settingsPath) {
   let settings = {};
   try {
-    if (fs12.existsSync(settingsPath)) {
-      const raw = fs12.readFileSync(settingsPath, "utf-8");
+    if (fs13.existsSync(settingsPath)) {
+      const raw = fs13.readFileSync(settingsPath, "utf-8");
       settings = JSON.parse(raw);
     }
   } catch {
     settings = {};
   }
   settings.sandbox = { enabled: false };
-  ensureDir3(path8.dirname(settingsPath));
-  fs12.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
+  ensureDir3(path9.dirname(settingsPath));
+  fs13.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
 }
 function mergeSettingsMcpServers(settingsPath, servers) {
   if (!servers || Object.keys(servers).length === 0) return;
   let settings = {};
   try {
-    if (fs12.existsSync(settingsPath)) {
-      const raw = fs12.readFileSync(settingsPath, "utf-8");
+    if (fs13.existsSync(settingsPath)) {
+      const raw = fs13.readFileSync(settingsPath, "utf-8");
       settings = JSON.parse(raw);
     }
   } catch {
@@ -8561,13 +8700,13 @@ function mergeSettingsMcpServers(settingsPath, servers) {
   }
   const existingServers = settings.mcpServers || {};
   settings.mcpServers = deepMerge(existingServers, servers);
-  ensureDir3(path8.dirname(settingsPath));
-  fs12.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
+  ensureDir3(path9.dirname(settingsPath));
+  fs13.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
 }
 function readExistingEnvKeys(envPath) {
   const keys = /* @__PURE__ */ new Set();
-  if (!fs12.existsSync(envPath)) return keys;
-  for (const line of fs12.readFileSync(envPath, "utf-8").split("\n")) {
+  if (!fs13.existsSync(envPath)) return keys;
+  for (const line of fs13.readFileSync(envPath, "utf-8").split("\n")) {
     const trimmed = line.trim();
     if (!trimmed || trimmed.startsWith("#")) continue;
     const eqIdx = trimmed.indexOf("=");
@@ -8582,22 +8721,22 @@ function readExistingEnvKeys(envPath) {
 }
 
 // src/commands/plugin-build.ts
-var fs14 = __toESM(require("node:fs"));
-var path10 = __toESM(require("node:path"));
+var fs15 = __toESM(require("node:fs"));
+var path11 = __toESM(require("node:path"));
 
 // src/engine/plugin-builder.ts
-var fs13 = __toESM(require("node:fs"));
-var path9 = __toESM(require("node:path"));
+var fs14 = __toESM(require("node:fs"));
+var path10 = __toESM(require("node:path"));
 async function buildPlugin(config) {
   const { marketplaceName, tools, selectedMcpTools, cliDir: cliDir2, targetDir } = config;
-  const outputDir = path9.join(targetDir, ".deepstorm");
-  if (fs13.existsSync(outputDir)) {
-    fs13.rmSync(outputDir, { recursive: true, force: true });
+  const outputDir = path10.join(targetDir, ".deepstorm");
+  if (fs14.existsSync(outputDir)) {
+    fs14.rmSync(outputDir, { recursive: true, force: true });
   }
-  fs13.mkdirSync(outputDir, { recursive: true });
+  fs14.mkdirSync(outputDir, { recursive: true });
   const rootPkgMeta = readRootPackageJson(targetDir);
-  const claudePluginDir = path9.join(outputDir, ".claude-plugin");
-  fs13.mkdirSync(claudePluginDir, { recursive: true });
+  const claudePluginDir = path10.join(outputDir, ".claude-plugin");
+  fs14.mkdirSync(claudePluginDir, { recursive: true });
   const pluginJson = {
     name: "deepstorm",
     description: rootPkgMeta.description,
@@ -8606,7 +8745,7 @@ async function buildPlugin(config) {
     license: "MIT",
     keywords: ["deepstorm", "ai", "software-engineering", ...tools]
   };
-  fs13.writeFileSync(path9.join(claudePluginDir, "plugin.json"), JSON.stringify(pluginJson, null, 2), "utf-8");
+  fs14.writeFileSync(path10.join(claudePluginDir, "plugin.json"), JSON.stringify(pluginJson, null, 2), "utf-8");
   const marketplaceJson = {
     name: marketplaceName,
     description: "DeepStorm Claude Code \u63D2\u4EF6",
@@ -8620,11 +8759,11 @@ async function buildPlugin(config) {
       }
     ]
   };
-  fs13.writeFileSync(path9.join(claudePluginDir, "marketplace.json"), JSON.stringify(marketplaceJson, null, 2), "utf-8");
+  fs14.writeFileSync(path10.join(claudePluginDir, "marketplace.json"), JSON.stringify(marketplaceJson, null, 2), "utf-8");
   const settingsJson = {
     enabledMcpjsonServers: selectedMcpTools
   };
-  fs13.writeFileSync(path9.join(outputDir, "settings.json"), JSON.stringify(settingsJson, null, 2), "utf-8");
+  fs14.writeFileSync(path10.join(outputDir, "settings.json"), JSON.stringify(settingsJson, null, 2), "utf-8");
   if (selectedMcpTools.length > 0) {
     const mcpServers = {};
     for (const mcpName of selectedMcpTools) {
@@ -8634,46 +8773,48 @@ async function buildPlugin(config) {
       }
     }
     if (Object.keys(mcpServers).length > 0) {
-      fs13.writeFileSync(
-        path9.join(outputDir, ".mcp.json"),
+      fs14.writeFileSync(
+        path10.join(outputDir, ".mcp.json"),
         JSON.stringify({ mcpServers }, null, 2) + "\n",
         "utf-8"
       );
     }
   }
   if (selectedMcpTools.length > 0) {
-    const envPath = path9.join(outputDir, ".env.example");
-    const envLines = [
-      "# DeepStorm Plugin MCP \u73AF\u5883\u53D8\u91CF\u914D\u7F6E",
-      "# \u590D\u5236\u6B64\u6587\u4EF6\u4E3A .env \u5E76\u586B\u5199\u5B9E\u9645\u503C",
-      ""
-    ];
+    const envPath = path10.join(targetDir, ".env");
+    const header = "# \u2500\u2500 DeepStorm Plugin MCP \u73AF\u5883\u53D8\u91CF \u2500\u2500\n\n";
+    const sections = [];
     for (const mcpName of selectedMcpTools) {
-      const envExampleFile = path9.join(cliDir2, "env-examples", `${mcpName}.env-example`);
-      if (fs13.existsSync(envExampleFile)) {
-        const content = fs13.readFileSync(envExampleFile, "utf-8");
-        envLines.push(`# ${mcpName}`);
-        envLines.push(content);
-        envLines.push("");
+      const envExampleFile = path10.join(cliDir2, "env-examples", `${mcpName}.env-example`);
+      if (fs14.existsSync(envExampleFile)) {
+        const content = fs14.readFileSync(envExampleFile, "utf-8");
+        sections.push(`# ${mcpName}`);
+        sections.push(content);
       }
     }
-    fs13.writeFileSync(envPath, envLines.join("\n"), "utf-8");
+    const newContent = header + sections.join("\n") + "\n";
+    if (fs14.existsSync(envPath)) {
+      const existing = fs14.readFileSync(envPath, "utf-8").trimEnd();
+      fs14.writeFileSync(envPath, existing + "\n\n" + newContent, "utf-8");
+    } else {
+      fs14.writeFileSync(envPath, newContent, "utf-8");
+    }
   }
   const readmeContent = generateReadme2(marketplaceName, tools, selectedMcpTools, rootPkgMeta.version);
-  fs13.writeFileSync(path9.join(outputDir, "README.md"), readmeContent, "utf-8");
+  fs14.writeFileSync(path10.join(outputDir, "README.md"), readmeContent, "utf-8");
   const changelogContent = `# Changelog
 
 ## v${rootPkgMeta.version}
 
 - \u9996\u6B21\u6784\u5EFA DeepStorm Plugin
 `;
-  fs13.writeFileSync(path9.join(outputDir, "CHANGELOG.md"), changelogContent, "utf-8");
+  fs14.writeFileSync(path10.join(outputDir, "CHANGELOG.md"), changelogContent, "utf-8");
   return outputDir;
 }
 function readRootPackageJson(targetDir) {
-  const pkgPath = path9.join(targetDir, "package.json");
+  const pkgPath = path10.join(targetDir, "package.json");
   try {
-    const pkg = JSON.parse(fs13.readFileSync(pkgPath, "utf-8"));
+    const pkg = JSON.parse(fs14.readFileSync(pkgPath, "utf-8"));
     return {
       version: pkg.version || "0.1.0",
       description: pkg.description || "DeepStorm \u2014 Spec \u9A71\u52A8\u7684 AI \u534F\u540C\u8F6F\u4EF6\u5DE5\u7A0B\u5B9E\u8DF5\u5DE5\u5177\u96C6"
@@ -8713,7 +8854,7 @@ function generateReadme2(marketplaceName, tools, selectedMcpTools, version) {
     "",
     "## \u73AF\u5883\u53D8\u91CF",
     "",
-    "\u590D\u5236 .env.example \u4E3A .env\uFF0C\u586B\u5199\u5BF9\u5E94\u7684 API Token \u540E\u91CD\u542F Claude Code \u4F1A\u8BDD\u3002",
+    "\u7F16\u8F91 .env \u6587\u4EF6\uFF0C\u586B\u5199\u5BF9\u5E94\u7684 API Token \u540E\u91CD\u542F Claude Code \u4F1A\u8BDD\u3002",
     "",
     "## \u5F00\u53D1",
     "",
@@ -8725,16 +8866,16 @@ function generateReadme2(marketplaceName, tools, selectedMcpTools, version) {
   return lines.join("\n");
 }
 function readMcpServerConfig(cliDir2, mcpName) {
-  const mcpDir = path9.join(cliDir2, "mcp");
-  if (!fs13.existsSync(mcpDir)) return null;
-  const entries = fs13.readdirSync(mcpDir, { withFileTypes: true });
+  const mcpDir = path10.join(cliDir2, "mcp");
+  if (!fs14.existsSync(mcpDir)) return null;
+  const entries = fs14.readdirSync(mcpDir, { withFileTypes: true });
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    const domainDir = path9.join(mcpDir, entry.name);
-    const files = fs13.readdirSync(domainDir).filter((f) => f.endsWith(".json"));
+    const domainDir = path10.join(mcpDir, entry.name);
+    const files = fs14.readdirSync(domainDir).filter((f) => f.endsWith(".json"));
     for (const file of files) {
       try {
-        const content = JSON.parse(fs13.readFileSync(path9.join(domainDir, file), "utf-8"));
+        const content = JSON.parse(fs14.readFileSync(path10.join(domainDir, file), "utf-8"));
         if (content.name === mcpName && content.mcpServers) {
           const servers = content.mcpServers;
           const keys = Object.keys(servers);
@@ -8830,27 +8971,27 @@ function registerPluginBuildCommand(program2, registry2) {
   });
 }
 function updatePluginJsonHooks(pluginDir) {
-  const hooksDir = path10.join(pluginDir, "hooks");
-  const pluginJsonPath = path10.join(pluginDir, ".claude-plugin", "plugin.json");
-  if (!fs14.existsSync(hooksDir) || !fs14.existsSync(pluginJsonPath)) return;
+  const hooksDir = path11.join(pluginDir, "hooks");
+  const pluginJsonPath = path11.join(pluginDir, ".claude-plugin", "plugin.json");
+  if (!fs15.existsSync(hooksDir) || !fs15.existsSync(pluginJsonPath)) return;
   try {
-    const pluginJson = JSON.parse(fs14.readFileSync(pluginJsonPath, "utf-8"));
+    const pluginJson = JSON.parse(fs15.readFileSync(pluginJsonPath, "utf-8"));
     pluginJson.hooks = "./hooks/deepstorm-hooks.json";
-    fs14.writeFileSync(pluginJsonPath, JSON.stringify(pluginJson, null, 2) + "\n", "utf-8");
+    fs15.writeFileSync(pluginJsonPath, JSON.stringify(pluginJson, null, 2) + "\n", "utf-8");
     console.log("\u2714 plugin.json \u5DF2\u6DFB\u52A0 hooks \u58F0\u660E");
   } catch {
   }
 }
 function ensureGitIgnore(targetDir) {
-  const gitIgnorePath = path10.join(targetDir, ".gitignore");
+  const gitIgnorePath = path11.join(targetDir, ".gitignore");
   const line = ".deepstorm/";
   try {
-    if (fs14.existsSync(gitIgnorePath)) {
-      const content = fs14.readFileSync(gitIgnorePath, "utf-8");
+    if (fs15.existsSync(gitIgnorePath)) {
+      const content = fs15.readFileSync(gitIgnorePath, "utf-8");
       if (content.includes(line)) return;
-      fs14.writeFileSync(gitIgnorePath, content.trimEnd() + "\n" + line + "\n", "utf-8");
+      fs15.writeFileSync(gitIgnorePath, content.trimEnd() + "\n" + line + "\n", "utf-8");
     } else {
-      fs14.writeFileSync(gitIgnorePath, line + "\n", "utf-8");
+      fs15.writeFileSync(gitIgnorePath, line + "\n", "utf-8");
     }
     console.log("\u2714 .gitignore \u5DF2\u6DFB\u52A0 .deepstorm/ \u5FFD\u7565\u89C4\u5219");
   } catch {
@@ -8858,14 +8999,14 @@ function ensureGitIgnore(targetDir) {
 }
 function mergePluginHooks(tools, reader, pluginDir, packagesDir) {
   if (!tools.some((tool) => reader.getToolHooks(tool).length > 0)) return;
-  const pkgsDir = packagesDir ?? path10.resolve(process.cwd(), "packages");
-  const pluginHooksDir = path10.join(pluginDir, "hooks");
-  const destHooksJson = path10.join(pluginHooksDir, "deepstorm-hooks.json");
+  const pkgsDir = packagesDir ?? path11.resolve(process.cwd(), "packages");
+  const pluginHooksDir = path11.join(pluginDir, "hooks");
+  const destHooksJson = path11.join(pluginHooksDir, "deepstorm-hooks.json");
   for (const tool of tools) {
-    const srcPath = path10.join(pkgsDir, tool, "hooks", "hooks.json");
-    if (fs14.existsSync(srcPath)) {
-      fs14.mkdirSync(pluginHooksDir, { recursive: true });
-      const incoming = JSON.parse(fs14.readFileSync(srcPath, "utf-8"));
+    const srcPath = path11.join(pkgsDir, tool, "hooks", "hooks.json");
+    if (fs15.existsSync(srcPath)) {
+      fs15.mkdirSync(pluginHooksDir, { recursive: true });
+      const incoming = JSON.parse(fs15.readFileSync(srcPath, "utf-8"));
       mergeHooks(destHooksJson, incoming);
     }
   }
@@ -8886,24 +9027,24 @@ function viewConfig(targetDir) {
 }
 
 // src/commands/config-set.ts
-var fs16 = __toESM(require("node:fs"));
-var path12 = __toESM(require("node:path"));
+var fs17 = __toESM(require("node:fs"));
+var path13 = __toESM(require("node:path"));
 var p6 = __toESM(require("@clack/prompts"));
 
 // src/utils/config-schema.ts
-var fs15 = __toESM(require("node:fs"));
-var path11 = __toESM(require("node:path"));
+var fs16 = __toESM(require("node:fs"));
+var path12 = __toESM(require("node:path"));
 function loadValidConfigKeys() {
   const candidates = [
-    path11.resolve(__dirname, "config-schema.json"),
-    path11.resolve(__dirname, "..", "config-schema.json"),
-    path11.resolve(process.cwd(), "config-schema.json"),
-    path11.resolve(process.cwd(), "packages", "cli", "config-schema.json")
+    path12.resolve(__dirname, "config-schema.json"),
+    path12.resolve(__dirname, "..", "config-schema.json"),
+    path12.resolve(process.cwd(), "config-schema.json"),
+    path12.resolve(process.cwd(), "packages", "cli", "config-schema.json")
   ];
   for (const schemaPath of candidates) {
     try {
-      if (!fs15.existsSync(schemaPath)) continue;
-      const schema = JSON.parse(fs15.readFileSync(schemaPath, "utf-8"));
+      if (!fs16.existsSync(schemaPath)) continue;
+      const schema = JSON.parse(fs16.readFileSync(schemaPath, "utf-8"));
       const keys = /* @__PURE__ */ new Set();
       collectLeafPaths(schema.properties, "", keys);
       return keys;
@@ -8941,9 +9082,9 @@ async function setConfigValue(targetDir, key, value, registry2) {
   const settingsPath = getDeepStormConfigPath(targetDir);
   readDeepStormConfig(targetDir);
   let config = {};
-  if (fs16.existsSync(settingsPath)) {
+  if (fs17.existsSync(settingsPath)) {
     try {
-      config = JSON.parse(fs16.readFileSync(settingsPath, "utf-8"));
+      config = JSON.parse(fs17.readFileSync(settingsPath, "utf-8"));
     } catch {
       config = {};
     }
@@ -8977,7 +9118,7 @@ async function setConfigValue(targetDir, key, value, registry2) {
     writePointer = writePointer[parts[i]];
   }
   writePointer[parts[parts.length - 1]] = value;
-  fs16.writeFileSync(settingsPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+  fs17.writeFileSync(settingsPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
   console.log(`\u2714 ${key} \u5DF2\u66F4\u65B0\u4E3A ${value}`);
   const affected = findAffectedTemplates(registry2, key);
   if (affected.length === 0) {
@@ -9015,8 +9156,8 @@ async function setConfigValue(targetDir, key, value, registry2) {
   const templateVariables = buildTemplateVariables(registry2, fullConfig, installedMcpServers);
   let renderCount = 0;
   for (const tmplRelPath of affected) {
-    const tmplPath = path12.join(cliDir, tmplRelPath);
-    if (!fs16.existsSync(tmplPath)) {
+    const tmplPath = path13.join(cliDir, tmplRelPath);
+    if (!fs17.existsSync(tmplPath)) {
       console.warn(`  \u26A0 \u6A21\u677F\u6587\u4EF6\u4E0D\u5B58\u5728: ${tmplRelPath}\uFF0C\u8DF3\u8FC7`);
       continue;
     }
@@ -9024,12 +9165,12 @@ async function setConfigValue(targetDir, key, value, registry2) {
     const assetType = pathParts[0];
     const assetName = pathParts[1];
     const outputFile = pathParts[pathParts.length - 1].replace(/\.tmpl$/, "");
-    const targetDirPath = path12.join(targetDir, ".claude", assetType, assetName);
+    const targetDirPath = path13.join(targetDir, ".claude", assetType, assetName);
     ensureDir3(targetDirPath);
-    const outputPath = path12.join(targetDirPath, outputFile);
+    const outputPath = path13.join(targetDirPath, outputFile);
     renderTemplate(tmplPath, templateVariables, outputPath);
-    const variantsDir = path12.join(cliDir, assetType, assetName, "variants");
-    if (fs16.existsSync(variantsDir)) {
+    const variantsDir = path13.join(cliDir, assetType, assetName, "variants");
+    if (fs17.existsSync(variantsDir)) {
       copyVariants(variantsDir, value, targetDirPath, true);
     }
     renderCount++;
@@ -9039,43 +9180,43 @@ async function setConfigValue(targetDir, key, value, registry2) {
 }
 
 // src/commands/config-reset.ts
-var fs17 = __toESM(require("node:fs"));
-var path13 = __toESM(require("node:path"));
+var fs18 = __toESM(require("node:fs"));
+var path14 = __toESM(require("node:path"));
 function resetConfig(targetDir) {
-  const settingsPath = path13.join(targetDir, ".deepstorm", "settings.json");
-  if (!fs17.existsSync(settingsPath)) return;
+  const settingsPath = path14.join(targetDir, ".deepstorm", "settings.json");
+  if (!fs18.existsSync(settingsPath)) return;
   try {
-    fs17.unlinkSync(settingsPath);
+    fs18.unlinkSync(settingsPath);
     console.log("\u2714 \u5DF2\u6E05\u9664 DeepStorm \u914D\u7F6E");
   } catch {
   }
 }
 
 // src/commands/config-refresh.ts
-var fs18 = __toESM(require("node:fs"));
-var path14 = __toESM(require("node:path"));
+var fs19 = __toESM(require("node:fs"));
+var path15 = __toESM(require("node:path"));
 function refreshConfig(cliDir2, targetDir, registry2) {
   const result = { refreshed: [], errors: [] };
   const settingsPath = getDeepStormConfigPath(targetDir);
-  if (!fs18.existsSync(settingsPath)) {
+  if (!fs19.existsSync(settingsPath)) {
     return result;
   }
   readDeepStormConfig(targetDir);
   let config;
   try {
-    config = JSON.parse(fs18.readFileSync(settingsPath, "utf-8"));
+    config = JSON.parse(fs19.readFileSync(settingsPath, "utf-8"));
   } catch {
     return result;
   }
   const installedSkills = config.installedSkills ?? [];
   const installedMcpServers = config.installedMcpServers ?? [];
-  const targetDotClaudeDir = path14.join(targetDir, ".claude");
+  const targetDotClaudeDir = path15.join(targetDir, ".claude");
   if (installedSkills.length === 0) return result;
   for (const skillId of installedSkills) {
-    const tmplPath = path14.join(cliDir2, "skills", skillId, "SKILL.md.tmpl");
-    if (!fs18.existsSync(tmplPath)) continue;
-    const targetSkillDir = path14.join(targetDotClaudeDir, "skills", skillId);
-    const outputPath = path14.join(targetSkillDir, "SKILL.md");
+    const tmplPath = path15.join(cliDir2, "skills", skillId, "SKILL.md.tmpl");
+    if (!fs19.existsSync(tmplPath)) continue;
+    const targetSkillDir = path15.join(targetDotClaudeDir, "skills", skillId);
+    const outputPath = path15.join(targetSkillDir, "SKILL.md");
     try {
       const enrichedVars = injectSkillCapabilities(
         tmplPath,
@@ -9083,7 +9224,7 @@ function refreshConfig(cliDir2, targetDir, registry2) {
         installedMcpServers,
         registry2.mcpTools ?? {}
       );
-      fs18.mkdirSync(targetSkillDir, { recursive: true });
+      fs19.mkdirSync(targetSkillDir, { recursive: true });
       renderTemplate(tmplPath, enrichedVars, outputPath);
       result.refreshed.push(skillId);
     } catch (err) {
@@ -9100,14 +9241,14 @@ function refreshConfig(cliDir2, targetDir, registry2) {
 }
 function buildUnifiedMcpCapabilities2(cliDir2, installedMcpTools, mcpTools) {
   const allDeclarations = {};
-  const skillsDir = path14.join(cliDir2, "skills");
-  if (!fs18.existsSync(skillsDir)) return {};
-  const skillDirs = fs18.readdirSync(skillsDir, { withFileTypes: true });
+  const skillsDir = path15.join(cliDir2, "skills");
+  if (!fs19.existsSync(skillsDir)) return {};
+  const skillDirs = fs19.readdirSync(skillsDir, { withFileTypes: true });
   for (const entry of skillDirs) {
     if (!entry.isDirectory()) continue;
-    const tmplPath = path14.join(skillsDir, entry.name, "SKILL.md.tmpl");
-    if (!fs18.existsSync(tmplPath)) continue;
-    const content = fs18.readFileSync(tmplPath, "utf-8");
+    const tmplPath = path15.join(skillsDir, entry.name, "SKILL.md.tmpl");
+    if (!fs19.existsSync(tmplPath)) continue;
+    const content = fs19.readFileSync(tmplPath, "utf-8");
     const fm = parseFrontmatter(content);
     if (!fm) continue;
     const mcpCap = fm.mcpCapabilities;
@@ -9190,17 +9331,17 @@ function listTemplates(registry2, tool) {
 }
 
 // src/commands/template-init.ts
-var fs19 = __toESM(require("node:fs"));
-var path15 = __toESM(require("node:path"));
+var fs20 = __toESM(require("node:fs"));
+var path16 = __toESM(require("node:path"));
 var import_prompts3 = require("@clack/prompts");
 async function initTemplate(cliDir2, targetDir, skillId) {
-  const srcDir = path15.join(cliDir2, "skills", skillId);
-  const destDir = path15.join(targetDir, ".deepstorm", "templates", skillId);
-  if (!fs19.existsSync(srcDir)) {
+  const srcDir = path16.join(cliDir2, "skills", skillId);
+  const destDir = path16.join(targetDir, ".deepstorm", "templates", skillId);
+  if (!fs20.existsSync(srcDir)) {
     console.log(`\u6A21\u677F\u4E0D\u5B58\u5728\uFF1A${skillId}`);
     return;
   }
-  if (fs19.existsSync(destDir)) {
+  if (fs20.existsSync(destDir)) {
     const shouldOverwrite = await (0, import_prompts3.confirm)({
       message: `\u6A21\u677F ${skillId} \u5DF2\u5B58\u5728\uFF0C\u662F\u5426\u8986\u76D6\uFF1F`,
       initialValue: false
@@ -9209,21 +9350,21 @@ async function initTemplate(cliDir2, targetDir, skillId) {
       console.log("\u5DF2\u53D6\u6D88");
       return;
     }
-    fs19.rmSync(destDir, { recursive: true, force: true });
+    fs20.rmSync(destDir, { recursive: true, force: true });
   }
-  ensureDir3(path15.dirname(destDir));
+  ensureDir3(path16.dirname(destDir));
   copyDir(srcDir, destDir);
   console.log(`\u2714 \u6A21\u677F\u5DF2\u5BFC\u51FA\u5230 .deepstorm/templates/${skillId}/`);
   console.log(`  \u4FEE\u6539\u5B8C\u6210\u540E\u8FD0\u884C deepstorm template apply ${skillId} \u5E94\u7528\u66F4\u6539`);
 }
 
 // src/commands/template-apply.ts
-var fs20 = __toESM(require("node:fs"));
-var path16 = __toESM(require("node:path"));
+var fs21 = __toESM(require("node:fs"));
+var path17 = __toESM(require("node:path"));
 function applyTemplate(targetDir, skillId) {
-  const srcDir = path16.join(targetDir, ".deepstorm", "templates", skillId);
-  const destDir = path16.join(targetDir, ".claude", "skills", skillId);
-  if (!fs20.existsSync(srcDir)) {
+  const srcDir = path17.join(targetDir, ".deepstorm", "templates", skillId);
+  const destDir = path17.join(targetDir, ".claude", "skills", skillId);
+  if (!fs21.existsSync(srcDir)) {
     console.log(`\u6A21\u677F\u4E0D\u5B58\u5728\uFF0C\u8BF7\u5148\u8FD0\u884C deepstorm template init ${skillId}`);
     return;
   }
@@ -9257,21 +9398,21 @@ function registerTemplateCommand(program2, registry2) {
 }
 
 // src/commands/update.ts
-var fs23 = __toESM(require("node:fs"));
-var import_node_child_process = require("node:child_process");
+var fs24 = __toESM(require("node:fs"));
+var import_node_child_process2 = require("node:child_process");
 
 // src/utils/version.ts
-var fs21 = __toESM(require("node:fs"));
-var path17 = __toESM(require("node:path"));
+var fs22 = __toESM(require("node:fs"));
+var path18 = __toESM(require("node:path"));
 function getCliVersion() {
   try {
     const paths = [
-      path17.resolve(__dirname, "package.json"),
-      path17.resolve(__dirname, "..", "package.json")
+      path18.resolve(__dirname, "package.json"),
+      path18.resolve(__dirname, "..", "package.json")
     ];
     for (const pkgPath of paths) {
-      if (fs21.existsSync(pkgPath)) {
-        const pkg = JSON.parse(fs21.readFileSync(pkgPath, "utf-8"));
+      if (fs22.existsSync(pkgPath)) {
+        const pkg = JSON.parse(fs22.readFileSync(pkgPath, "utf-8"));
         return pkg.version || "0.0.0";
       }
     }
@@ -9282,14 +9423,14 @@ function getCliVersion() {
 }
 
 // src/commands/template-upgrade.ts
-var fs22 = __toESM(require("node:fs"));
-var path18 = __toESM(require("node:path"));
+var fs23 = __toESM(require("node:fs"));
+var path19 = __toESM(require("node:path"));
 var crypto = __toESM(require("node:crypto"));
 var CHECKSUM_FILE = "deepstorm-checksums.json";
 function computeFileChecksum(filePath) {
   try {
-    if (!fs22.existsSync(filePath)) return null;
-    const content = fs22.readFileSync(filePath);
+    if (!fs23.existsSync(filePath)) return null;
+    const content = fs23.readFileSync(filePath);
     return crypto.createHash("sha256").update(content).digest("hex");
   } catch {
     return null;
@@ -9297,15 +9438,15 @@ function computeFileChecksum(filePath) {
 }
 function computeDirChecksums(dirPath, relativeTo = dirPath) {
   const result = {};
-  if (!fs22.existsSync(dirPath)) return result;
+  if (!fs23.existsSync(dirPath)) return result;
   function walk(current) {
-    for (const entry of fs22.readdirSync(current, { withFileTypes: true })) {
-      const fullPath = path18.join(current, entry.name);
+    for (const entry of fs23.readdirSync(current, { withFileTypes: true })) {
+      const fullPath = path19.join(current, entry.name);
       if (entry.name === ".DS_Store") continue;
       if (entry.isDirectory()) {
         walk(fullPath);
       } else if (entry.isFile()) {
-        const relPath = path18.relative(relativeTo, fullPath);
+        const relPath = path19.relative(relativeTo, fullPath);
         const checksum = computeFileChecksum(fullPath);
         if (checksum) result[relPath] = checksum;
       }
@@ -9315,32 +9456,32 @@ function computeDirChecksums(dirPath, relativeTo = dirPath) {
   return result;
 }
 function loadChecksums(targetDir) {
-  const filePath = path18.join(targetDir, ".claude", CHECKSUM_FILE);
+  const filePath = path19.join(targetDir, ".claude", CHECKSUM_FILE);
   try {
-    return JSON.parse(fs22.readFileSync(filePath, "utf-8"));
+    return JSON.parse(fs23.readFileSync(filePath, "utf-8"));
   } catch {
     return {};
   }
 }
 function saveChecksums(targetDir, checksums) {
-  const dir = path18.join(targetDir, ".claude");
+  const dir = path19.join(targetDir, ".claude");
   ensureDir3(dir);
-  fs22.writeFileSync(
-    path18.join(dir, CHECKSUM_FILE),
+  fs23.writeFileSync(
+    path19.join(dir, CHECKSUM_FILE),
     JSON.stringify(checksums, null, 2) + "\n",
     "utf-8"
   );
 }
 function backupFile(filePath) {
   try {
-    if (!fs22.existsSync(filePath)) return null;
-    const dir = path18.dirname(filePath);
-    const ext = path18.extname(filePath);
-    const base = path18.basename(filePath, ext);
+    if (!fs23.existsSync(filePath)) return null;
+    const dir = path19.dirname(filePath);
+    const ext = path19.extname(filePath);
+    const base = path19.basename(filePath, ext);
     const timestamp = Date.now();
     const bakName = `${base}.${timestamp}.bak`;
-    const bakPath = path18.join(dir, bakName);
-    fs22.cpSync(filePath, bakPath, { force: true });
+    const bakPath = path19.join(dir, bakName);
+    fs23.cpSync(filePath, bakPath, { force: true });
     return bakName;
   } catch {
     return null;
@@ -9361,19 +9502,19 @@ function backupModifiedAssets(targetDir, skillIds, toolNames, registry2) {
   const stored = loadChecksums(targetDir);
   const backedUp = [];
   for (const skillId of skillIds) {
-    const skillDir = path18.join(targetDir, ".claude", "skills", skillId);
-    if (!fs22.existsSync(skillDir)) continue;
+    const skillDir = path19.join(targetDir, ".claude", "skills", skillId);
+    if (!fs23.existsSync(skillDir)) continue;
     const checksums = computeDirChecksums(skillDir);
     for (const [relPath] of Object.entries(checksums)) {
       const key = `skills/${skillId}/${relPath}`;
-      checkAndBackup(key, path18.join(skillDir, relPath), stored, backedUp);
+      checkAndBackup(key, path19.join(skillDir, relPath), stored, backedUp);
     }
   }
   const reader = new RegistryReader(registry2);
   for (const tool of toolNames) {
     const agents = reader.getToolAgents(tool);
     for (const agentFile of agents) {
-      const filePath = path18.join(targetDir, ".claude", "agents", agentFile.replace(/\.tmpl$/, ""));
+      const filePath = path19.join(targetDir, ".claude", "agents", agentFile.replace(/\.tmpl$/, ""));
       const key = `agents/${agentFile.replace(/\.tmpl$/, "")}`;
       checkAndBackup(key, filePath, stored, backedUp);
     }
@@ -9381,7 +9522,7 @@ function backupModifiedAssets(targetDir, skillIds, toolNames, registry2) {
   for (const tool of toolNames) {
     const hooks = reader.getToolHooks(tool);
     for (const hookFile of hooks) {
-      const filePath = path18.join(targetDir, ".claude", "hooks", hookFile);
+      const filePath = path19.join(targetDir, ".claude", "hooks", hookFile);
       const key = `hooks/${hookFile}`;
       checkAndBackup(key, filePath, stored, backedUp);
     }
@@ -9392,7 +9533,7 @@ function storeNewChecksums(targetDir, skillIds, toolNames, registry2) {
   const newChecksums = {};
   const reader = new RegistryReader(registry2);
   for (const skillId of skillIds) {
-    const skillDir = path18.join(targetDir, ".claude", "skills", skillId);
+    const skillDir = path19.join(targetDir, ".claude", "skills", skillId);
     const checksums = computeDirChecksums(skillDir);
     for (const [relPath, checksum] of Object.entries(checksums)) {
       newChecksums[`skills/${skillId}/${relPath}`] = checksum;
@@ -9402,7 +9543,7 @@ function storeNewChecksums(targetDir, skillIds, toolNames, registry2) {
     const agents = reader.getToolAgents(tool);
     for (const agentFile of agents) {
       const installedName = agentFile.replace(/\.tmpl$/, "");
-      const filePath = path18.join(targetDir, ".claude", "agents", installedName);
+      const filePath = path19.join(targetDir, ".claude", "agents", installedName);
       const chk = computeFileChecksum(filePath);
       if (chk) newChecksums[`agents/${installedName}`] = chk;
     }
@@ -9410,7 +9551,7 @@ function storeNewChecksums(targetDir, skillIds, toolNames, registry2) {
   for (const tool of toolNames) {
     const hooks = reader.getToolHooks(tool);
     for (const hookFile of hooks) {
-      const filePath = path18.join(targetDir, ".claude", "hooks", hookFile);
+      const filePath = path19.join(targetDir, ".claude", "hooks", hookFile);
       const chk = computeFileChecksum(filePath);
       if (chk) newChecksums[`hooks/${hookFile}`] = chk;
     }
@@ -9443,7 +9584,7 @@ function detectToolsFromConfig(config, registry2) {
 function readSettingsConfig(targetDir) {
   const settingsPath = getDeepStormConfigPath(targetDir);
   try {
-    const raw = fs22.readFileSync(settingsPath, "utf-8");
+    const raw = fs23.readFileSync(settingsPath, "utf-8");
     const config = JSON.parse(raw);
     const metaKeys = /* @__PURE__ */ new Set([
       "installedSkills",
@@ -9473,22 +9614,22 @@ function flattenNestedConfig(obj, prefix, result, skipKeys) {
   }
 }
 function loadRegistryFromCliDir(cliDir2) {
-  const registryPath = path18.join(cliDir2, "registry.json");
+  const registryPath = path19.join(cliDir2, "registry.json");
   try {
-    const raw = fs22.readFileSync(registryPath, "utf-8");
+    const raw = fs23.readFileSync(registryPath, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
   }
 }
 function mergeToolHooksJson(toolNames, cliDir2, targetDir) {
-  const hooksSrcDir = path18.join(cliDir2, "hooks");
-  const destHooksJson = path18.join(targetDir, ".claude", "hooks.json");
+  const hooksSrcDir = path19.join(cliDir2, "hooks");
+  const destHooksJson = path19.join(targetDir, ".claude", "hooks.json");
   for (const tool of toolNames) {
-    const toolHooksJsonPath = path18.join(hooksSrcDir, `${tool}-hooks.json`);
-    if (fs22.existsSync(toolHooksJsonPath)) {
-      ensureDir3(path18.join(targetDir, ".claude"));
-      const incoming = JSON.parse(fs22.readFileSync(toolHooksJsonPath, "utf-8"));
+    const toolHooksJsonPath = path19.join(hooksSrcDir, `${tool}-hooks.json`);
+    if (fs23.existsSync(toolHooksJsonPath)) {
+      ensureDir3(path19.join(targetDir, ".claude"));
+      const incoming = JSON.parse(fs23.readFileSync(toolHooksJsonPath, "utf-8"));
       mergeHooks(destHooksJson, incoming);
     }
   }
@@ -9606,8 +9747,8 @@ function readLocalRegistryFile(url) {
     filePath = filePath.slice(7);
   }
   try {
-    if (fs23.existsSync(filePath)) {
-      return JSON.parse(fs23.readFileSync(filePath, "utf-8"));
+    if (fs24.existsSync(filePath)) {
+      return JSON.parse(fs24.readFileSync(filePath, "utf-8"));
     }
   } catch {
   }
@@ -9676,7 +9817,7 @@ async function updateCLI(fetchFn) {
     console.log("\u2192 \u6B63\u5728\u81EA\u52A8\u66F4\u65B0...");
     const updateCmd = process.env.DEEPSTORM_UPDATE_CMD || "npm install -g @deepstorm/cli@latest";
     try {
-      (0, import_node_child_process.execSync)(updateCmd, { stdio: "inherit" });
+      (0, import_node_child_process2.execSync)(updateCmd, { stdio: "inherit" });
       console.log(`
 \u2714 \u5DF2\u66F4\u65B0\u81F3 v${result.latest}`);
     } catch {
@@ -9691,7 +9832,7 @@ async function updateCLI(fetchFn) {
 function getInstalledSkillIds(targetDir) {
   const settingsPath = getDeepStormConfigPath(targetDir);
   try {
-    const raw = fs23.readFileSync(settingsPath, "utf-8");
+    const raw = fs24.readFileSync(settingsPath, "utf-8");
     const config = JSON.parse(raw);
     return config.installedSkills ?? [];
   } catch {
@@ -9718,12 +9859,12 @@ function registerPilotCommands(program2) {
 }
 
 // src/commands/doctor.ts
-var fs24 = __toESM(require("node:fs"));
-var path19 = __toESM(require("node:path"));
+var fs25 = __toESM(require("node:fs"));
+var path20 = __toESM(require("node:path"));
 function getInstalledSkills(targetDir) {
   const settingsPath = getDeepStormConfigPath(targetDir);
   try {
-    const settings = JSON.parse(fs24.readFileSync(settingsPath, "utf-8"));
+    const settings = JSON.parse(fs25.readFileSync(settingsPath, "utf-8"));
     return settings.installedSkills || [];
   } catch {
     return [];
@@ -9740,7 +9881,7 @@ function runDoctor(targetDir) {
     message: `v${version}\uFF08\u8FD0\u884C deepstorm update --check \u68C0\u67E5\u6700\u65B0\u7248\u672C\uFF09`
   });
   let hasDeepStorm = false;
-  if (!fs24.existsSync(settingsPath)) {
+  if (!fs25.existsSync(settingsPath)) {
     checks.push({
       name: "\u914D\u7F6E\u6587\u4EF6",
       status: "warn",
@@ -9748,7 +9889,7 @@ function runDoctor(targetDir) {
     });
   } else {
     try {
-      const config = JSON.parse(fs24.readFileSync(settingsPath, "utf-8"));
+      const config = JSON.parse(fs25.readFileSync(settingsPath, "utf-8"));
       if (config && Object.keys(config).length > 0) {
         hasDeepStorm = true;
         checks.push({
@@ -9771,20 +9912,20 @@ function runDoctor(targetDir) {
       });
     }
   }
-  const skillsDir = path19.join(targetDir, ".claude", "skills");
-  if (fs24.existsSync(skillsDir)) {
-    const skillDirs = fs24.readdirSync(skillsDir).filter(
-      (n) => fs24.statSync(path19.join(skillsDir, n)).isDirectory()
+  const skillsDir = path20.join(targetDir, ".claude", "skills");
+  if (fs25.existsSync(skillsDir)) {
+    const skillDirs = fs25.readdirSync(skillsDir).filter(
+      (n) => fs25.statSync(path20.join(skillsDir, n)).isDirectory()
     );
     let validCount = 0;
     let invalidCount = 0;
     for (const skillName of skillDirs) {
-      const skillMd = path19.join(skillsDir, skillName, "SKILL.md");
-      if (!fs24.existsSync(skillMd)) {
+      const skillMd = path20.join(skillsDir, skillName, "SKILL.md");
+      if (!fs25.existsSync(skillMd)) {
         invalidCount++;
         continue;
       }
-      const content = fs24.readFileSync(skillMd, "utf-8");
+      const content = fs25.readFileSync(skillMd, "utf-8");
       const frontmatter = parseFrontmatter(content);
       if (frontmatter && frontmatter.name) {
         validCount++;
@@ -9814,7 +9955,7 @@ function runDoctor(targetDir) {
     const installedSkills = getInstalledSkills(targetDir);
     const missingSkills = [];
     for (const skillId of installedSkills) {
-      if (!fs24.existsSync(path19.join(skillsDir, skillId))) {
+      if (!fs25.existsSync(path20.join(skillsDir, skillId))) {
         missingSkills.push(skillId);
       }
     }
@@ -9838,10 +9979,10 @@ function runDoctor(targetDir) {
       message: ".claude/skills/ \u4E0D\u5B58\u5728"
     });
   }
-  const mcpPath = path19.join(targetDir, ".mcp.json");
-  if (fs24.existsSync(mcpPath)) {
+  const mcpPath = path20.join(targetDir, ".mcp.json");
+  if (fs25.existsSync(mcpPath)) {
     try {
-      const mcp = JSON.parse(fs24.readFileSync(mcpPath, "utf-8"));
+      const mcp = JSON.parse(fs25.readFileSync(mcpPath, "utf-8"));
       const hasServers = mcp.mcpServers && Object.keys(mcp.mcpServers).length > 0;
       checks.push({
         name: "MCP \u670D\u52A1\u5668",
@@ -9862,12 +10003,12 @@ function runDoctor(targetDir) {
       message: ".mcp.json \u4E0D\u5B58\u5728"
     });
   }
-  if (hasDeepStorm && fs24.existsSync(settingsPath)) {
+  if (hasDeepStorm && fs25.existsSync(settingsPath)) {
     try {
-      const config = JSON.parse(fs24.readFileSync(settingsPath, "utf-8"));
+      const config = JSON.parse(fs25.readFileSync(settingsPath, "utf-8"));
       const installedMcp = config.installedMcpServers;
       if (installedMcp && installedMcp.length > 0) {
-        const mcpExists = fs24.existsSync(mcpPath);
+        const mcpExists = fs25.existsSync(mcpPath);
         if (!mcpExists) {
           checks.push({
             name: "MCP \u4E00\u81F4\u6027",
@@ -9876,7 +10017,7 @@ function runDoctor(targetDir) {
           });
         } else {
           try {
-            const mcpConfig = JSON.parse(fs24.readFileSync(mcpPath, "utf-8"));
+            const mcpConfig = JSON.parse(fs25.readFileSync(mcpPath, "utf-8"));
             const servers = mcpConfig.mcpServers || {};
             const missing = [];
             for (const toolName of installedMcp) {
@@ -9904,9 +10045,9 @@ function runDoctor(targetDir) {
     } catch {
     }
   }
-  if (hasDeepStorm && fs24.existsSync(settingsPath)) {
+  if (hasDeepStorm && fs25.existsSync(settingsPath)) {
     try {
-      const config = JSON.parse(fs24.readFileSync(settingsPath, "utf-8"));
+      const config = JSON.parse(fs25.readFileSync(settingsPath, "utf-8"));
       const validKeys = loadValidConfigKeys();
       if (validKeys.size > 0 && config) {
         const configKeys = [];
@@ -9959,18 +10100,18 @@ function printDoctorReport(report) {
 }
 
 // src/commands/uninstall.ts
-var fs25 = __toESM(require("node:fs"));
-var path20 = __toESM(require("node:path"));
+var fs26 = __toESM(require("node:fs"));
+var path21 = __toESM(require("node:path"));
 var import_prompts4 = require("@clack/prompts");
 async function uninstallDeepStorm(targetDir) {
   const settingsPath = getDeepStormConfigPath(targetDir);
-  if (!fs25.existsSync(settingsPath)) {
+  if (!fs26.existsSync(settingsPath)) {
     console.log("DeepStorm \u5C1A\u672A\u914D\u7F6E\uFF0C\u65E0\u9700\u5378\u8F7D");
     return;
   }
   let hasDeepStorm = false;
   try {
-    const settings = JSON.parse(fs25.readFileSync(settingsPath, "utf-8"));
+    const settings = JSON.parse(fs26.readFileSync(settingsPath, "utf-8"));
     hasDeepStorm = !!settings && Object.keys(settings).length > 0;
   } catch {
   }
@@ -9980,14 +10121,14 @@ async function uninstallDeepStorm(targetDir) {
   }
   cleanInstalled(targetDir);
   resetConfig(targetDir);
-  const templatesDir = path20.join(targetDir, ".deepstorm", "templates");
-  if (fs25.existsSync(templatesDir)) {
+  const templatesDir = path21.join(targetDir, ".deepstorm", "templates");
+  if (fs26.existsSync(templatesDir)) {
     const shouldDelete = await (0, import_prompts4.confirm)({
       message: "\u662F\u5426\u5220\u9664 .deepstorm/templates/ \u76EE\u5F55\uFF1F",
       initialValue: false
     });
     if (shouldDelete) {
-      fs25.rmSync(templatesDir, { recursive: true, force: true });
+      fs26.rmSync(templatesDir, { recursive: true, force: true });
       console.log("\u2714 .deepstorm/templates/ \u5DF2\u5220\u9664");
     } else {
       console.log("\u4FDD\u7559 .deepstorm/templates/");
@@ -10000,9 +10141,9 @@ async function uninstallDeepStorm(targetDir) {
 var program = new import_commander.Command();
 program.name("deepstorm").description("DeepStorm CLI \u2014 \u4E00\u952E\u914D\u7F6E\u9879\u76EE\u5F00\u53D1\u73AF\u5883").version(getCliVersion(), "-v, --version", "\u8F93\u51FA\u7248\u672C\u53F7");
 function loadRegistry() {
-  const registryPath = path21.join(__dirname, "registry.json");
+  const registryPath = path22.join(__dirname, "registry.json");
   try {
-    const raw = fs26.readFileSync(registryPath, "utf-8");
+    const raw = fs27.readFileSync(registryPath, "utf-8");
     return JSON.parse(raw);
   } catch {
     return { version: "1", tools: {}, wizards: {}, skills: {} };