npm - @deepstorm/cli - Versions diffs - 0.6.6 → 0.7.1 - Mend

@deepstorm/cli 0.6.6 → 0.7.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (2) hide show

package/dist/cli.js +495 -405
package/package.json +2 -2

package/dist/cli.js CHANGED Viewed

@@ -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 {
@@ -7065,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
@@ -7130,6 +7130,16 @@ function writeTemplate(baseDir, relativePath, content) {
   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)}/`);
@@ -7160,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 {
@@ -7174,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 = "";
@@ -7224,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);
   }
@@ -7233,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;
@@ -7271,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"));
@@ -7663,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 = {};
@@ -7688,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;
@@ -7783,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();
@@ -7844,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;
   }
@@ -7861,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 {
       }
     }
@@ -7922,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])];
@@ -7931,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;
     }
@@ -7941,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("#")) {
@@ -7957,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();
@@ -8017,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/**";
@@ -8046,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 });
   }
 }
@@ -8085,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 });
   }
 }
@@ -8144,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);
@@ -8172,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);
@@ -8184,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);
       }
     }
@@ -8216,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);
@@ -8224,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",
@@ -8245,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`);
     }
   }
@@ -8261,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;
@@ -8280,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;
@@ -8291,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,
@@ -8307,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);
@@ -8318,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)) {
@@ -8328,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)
           );
         }
       }
@@ -8368,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;
@@ -8387,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++;
@@ -8404,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;
@@ -8430,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;
@@ -8438,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) {
@@ -8447,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) {
@@ -8509,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);
@@ -8528,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)) {
@@ -8574,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 {
@@ -8612,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("=");
@@ -8633,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,
@@ -8657,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",
@@ -8671,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) {
@@ -8685,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"
@@ -8764,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",
     "",
@@ -8776,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);
@@ -8881,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 {
@@ -8909,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);
     }
   }
@@ -8937,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;
@@ -8992,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 = {};
     }
@@ -9028,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) {
@@ -9066,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;
     }
@@ -9075,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++;
@@ -9090,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,
@@ -9134,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) {
@@ -9151,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;
@@ -9241,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
@@ -9260,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;
   }
@@ -9308,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";
       }
     }
@@ -9333,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;
@@ -9348,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;
       }
@@ -9366,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;
@@ -9412,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);
     }
@@ -9432,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);
     }
@@ -9443,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;
@@ -9453,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;
     }
@@ -9461,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;
     }
@@ -9494,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",
@@ -9524,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);
     }
   }
@@ -9657,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 {
   }
@@ -9727,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 {
@@ -9742,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 {
@@ -9769,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 [];
@@ -9791,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",
@@ -9799,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({
@@ -9822,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++;
@@ -9865,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);
       }
     }
@@ -9889,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",
@@ -9913,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",
@@ -9927,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) {
@@ -9955,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 = [];
@@ -10010,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 {
   }
@@ -10031,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/");
@@ -10051,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: {} };