@deepstorm/cli 0.2.2 → 0.2.3

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,11 +3110,11 @@ var require_util = __commonJS({
       }
       return joined;
     }
-    exports2.join = join20;
+    exports2.join = join21;
     exports2.isAbsolute = function(aPath) {
       return aPath.charAt(0) === "/" || urlRegexp.test(aPath);
     };
-    function relative(aRoot, aPath) {
+    function relative2(aRoot, aPath) {
       if (aRoot === "") {
         aRoot = ".";
       }
@@ -3133,7 +3133,7 @@ var require_util = __commonJS({
       }
       return Array(level + 1).join("../") + aPath.substr(aRoot.length + 1);
     }
-    exports2.relative = relative;
+    exports2.relative = relative2;
     var supportsNullProto = (function() {
       var obj = /* @__PURE__ */ Object.create(null);
       return !("__proto__" in obj);
@@ -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 fs24 = require("fs");
-      var templateString = fs24.readFileSync(filename, "utf8");
+      var fs25 = require("fs");
+      var templateString = fs25.readFileSync(filename, "utf8");
       module3.exports = handlebars.compile(templateString);
     }
     if (typeof require !== "undefined" && require.extensions) {
@@ -5911,8 +5911,8 @@ var require_lib = __commonJS({
 
 // src/index.ts
 var import_commander = require("commander");
-var fs23 = __toESM(require("node:fs"));
-var path21 = __toESM(require("node:path"));
+var fs24 = __toESM(require("node:fs"));
+var path22 = __toESM(require("node:path"));
 
 // src/commands/setup.ts
 var path6 = __toESM(require("node:path"));
@@ -8117,6 +8117,8 @@ function registerTemplateCommand(program2, registry2) {
 }
 
 // src/commands/update.ts
+var fs21 = __toESM(require("node:fs"));
+var path19 = __toESM(require("node:path"));
 var import_node_child_process = require("node:child_process");
 
 // src/utils/version.ts
@@ -8143,20 +8145,281 @@ function getCliVersion() {
 // src/commands/template-upgrade.ts
 var fs20 = __toESM(require("node:fs"));
 var path18 = __toESM(require("node:path"));
-function upgradeTemplates(cliDir2, targetDir, skillIds) {
-  const templatesDir = path18.join(targetDir, ".deepstorm", "templates");
+var crypto = __toESM(require("node:crypto"));
+var CHECKSUM_FILE = "deepstorm-checksums.json";
+function computeFileChecksum(filePath) {
+  try {
+    if (!fs20.existsSync(filePath)) return null;
+    const content = fs20.readFileSync(filePath);
+    return crypto.createHash("sha256").update(content).digest("hex");
+  } catch {
+    return null;
+  }
+}
+function computeDirChecksums(dirPath, relativeTo = dirPath) {
+  const result = {};
+  if (!fs20.existsSync(dirPath)) return result;
+  function walk(current) {
+    for (const entry of fs20.readdirSync(current, { withFileTypes: true })) {
+      const fullPath = path18.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 checksum = computeFileChecksum(fullPath);
+        if (checksum) result[relPath] = checksum;
+      }
+    }
+  }
+  walk(dirPath);
+  return result;
+}
+function loadChecksums(targetDir) {
+  const filePath = path18.join(targetDir, ".claude", CHECKSUM_FILE);
+  try {
+    return JSON.parse(fs20.readFileSync(filePath, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function saveChecksums(targetDir, checksums) {
+  const dir = path18.join(targetDir, ".claude");
+  ensureDir(dir);
+  fs20.writeFileSync(
+    path18.join(dir, CHECKSUM_FILE),
+    JSON.stringify(checksums, null, 2) + "\n",
+    "utf-8"
+  );
+}
+function backupFile(filePath) {
+  try {
+    if (!fs20.existsSync(filePath)) return null;
+    const dir = path18.dirname(filePath);
+    const ext = path18.extname(filePath);
+    const base = path18.basename(filePath, ext);
+    const timestamp = Date.now();
+    const bakName = `${base}.${timestamp}.bak`;
+    const bakPath = path18.join(dir, bakName);
+    fs20.cpSync(filePath, bakPath, { force: true });
+    return bakName;
+  } catch {
+    return null;
+  }
+}
+function checkAndBackup(fileKey, filePath, stored, backedUp) {
+  const lastChecksum = stored[fileKey];
+  if (!lastChecksum) return;
+  const current = computeFileChecksum(filePath);
+  if (current === null) return;
+  if (current === lastChecksum) return;
+  const bakName = backupFile(filePath);
+  if (bakName) {
+    backedUp.push(`${fileKey} \u2192 ${bakName}`);
+  }
+}
+function backupModifiedAssets(targetDir, skillIds, toolNames, registry2) {
+  const stored = loadChecksums(targetDir);
+  const backedUp = [];
   for (const skillId of skillIds) {
-    const userTemplate = path18.join(templatesDir, skillId);
-    if (fs20.existsSync(userTemplate)) {
-      console.log(`${skillId}\uFF1A\u68C0\u6D4B\u5230\u7528\u6237\u4FEE\u6539\uFF0C\u8DF3\u8FC7\u3002\u5982\u9700\u540C\u6B65\u8BF7\u8FD0\u884C deepstorm template apply ${skillId}`);
+    const skillDir = path18.join(targetDir, ".claude", "skills", skillId);
+    if (!fs20.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);
+    }
+  }
+  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 key = `agents/${agentFile.replace(/\.tmpl$/, "")}`;
+      checkAndBackup(key, filePath, stored, backedUp);
+    }
+  }
+  for (const tool of toolNames) {
+    const hooks = reader.getToolHooks(tool);
+    for (const hookFile of hooks) {
+      const filePath = path18.join(targetDir, ".claude", "hooks", hookFile);
+      const key = `hooks/${hookFile}`;
+      checkAndBackup(key, filePath, stored, backedUp);
+    }
+  }
+  return backedUp;
+}
+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 checksums = computeDirChecksums(skillDir);
+    for (const [relPath, checksum] of Object.entries(checksums)) {
+      newChecksums[`skills/${skillId}/${relPath}`] = checksum;
+    }
+  }
+  for (const tool of toolNames) {
+    const agents = reader.getToolAgents(tool);
+    for (const agentFile of agents) {
+      const installedName = agentFile.replace(/\.tmpl$/, "");
+      const filePath = path18.join(targetDir, ".claude", "agents", installedName);
+      const chk = computeFileChecksum(filePath);
+      if (chk) newChecksums[`agents/${installedName}`] = chk;
+    }
+  }
+  for (const tool of toolNames) {
+    const hooks = reader.getToolHooks(tool);
+    for (const hookFile of hooks) {
+      const filePath = path18.join(targetDir, ".claude", "hooks", hookFile);
+      const chk = computeFileChecksum(filePath);
+      if (chk) newChecksums[`hooks/${hookFile}`] = chk;
+    }
+  }
+  saveChecksums(targetDir, newChecksums);
+}
+function skillIdsToTools(skillIds, registry2) {
+  const toolSet = /* @__PURE__ */ new Set();
+  for (const skillId of skillIds) {
+    const skill = registry2.skills[skillId];
+    if (skill?.tool) {
+      toolSet.add(skill.tool);
+    }
+  }
+  return [...toolSet];
+}
+function readSettingsConfig(targetDir) {
+  const settingsPath = path18.join(targetDir, ".claude", "settings.json");
+  try {
+    const raw = fs20.readFileSync(settingsPath, "utf-8");
+    const settings = JSON.parse(raw);
+    const deepstorm = settings.deepstorm || {};
+    const metaKeys = /* @__PURE__ */ new Set([
+      "installedSkills",
+      "installedMcpServers",
+      "installedAt",
+      "mcpCapabilities"
+    ]);
+    const config = {};
+    flattenNestedConfig(deepstorm, "", config, metaKeys);
+    const installedMcpTools = deepstorm.installedMcpServers ?? [];
+    return { config, installedMcpTools };
+  } catch {
+    return { config: {}, installedMcpTools: [] };
+  }
+}
+function flattenNestedConfig(obj, prefix, result, skipKeys) {
+  for (const [key, value] of Object.entries(obj)) {
+    if (skipKeys.has(key)) continue;
+    const fullKey = prefix ? `${prefix}.${key}` : key;
+    if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+      flattenNestedConfig(value, fullKey, result, skipKeys);
+    } else if (typeof value === "string") {
+      result[fullKey] = value;
+    }
+  }
+}
+function loadRegistryFromCliDir(cliDir2) {
+  const registryPath = path18.join(cliDir2, "registry.json");
+  try {
+    const raw = fs20.readFileSync(registryPath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function mergeToolHooksJson(toolNames, cliDir2, targetDir) {
+  const hooksSrcDir = path18.join(cliDir2, "hooks");
+  const targetHooksDir = path18.join(targetDir, ".claude", "hooks");
+  const destHooksJson = path18.join(targetHooksDir, "hooks.json");
+  for (const tool of toolNames) {
+    const toolHooksJsonPath = path18.join(hooksSrcDir, `${tool}-hooks.json`);
+    if (fs20.existsSync(toolHooksJsonPath)) {
+      ensureDir(targetHooksDir);
+      const incoming = JSON.parse(fs20.readFileSync(toolHooksJsonPath, "utf-8"));
+      mergeHooks(destHooksJson, incoming);
+    }
+  }
+}
+function syncToolAssets(cliDir2, targetDir, installedSkillIds) {
+  const registry2 = loadRegistryFromCliDir(cliDir2);
+  if (!registry2) {
+    console.log("\u26A0 \u65E0\u6CD5\u52A0\u8F7D registry.json\uFF0C\u8DF3\u8FC7\u8D44\u4EA7\u540C\u6B65");
+    return { syncedSkills: [], syncedAgents: [], syncedHooks: [], backedUpFiles: [] };
+  }
+  const reader = new RegistryReader(registry2);
+  const toolNames = skillIdsToTools(installedSkillIds, registry2);
+  if (toolNames.length === 0) {
+    console.log("\u26A0 \u65E0\u6CD5\u4ECE\u5DF2\u5B89\u88C5 skill \u89E3\u6790\u5DE5\u5177\u540D\u79F0\uFF0C\u8DF3\u8FC7\u8D44\u4EA7\u540C\u6B65");
+    return { syncedSkills: [], syncedAgents: [], syncedHooks: [], backedUpFiles: [] };
+  }
+  const { config, installedMcpTools } = readSettingsConfig(targetDir);
+  const templateVariables = buildTemplateVariables(registry2, config, installedMcpTools);
+  const backedUpFiles = backupModifiedAssets(targetDir, installedSkillIds, toolNames, registry2);
+  if (backedUpFiles.length > 0) {
+    console.log("\n\u26A0 \u68C0\u6D4B\u5230\u7528\u6237\u4FEE\u6539\u7684\u6587\u4EF6\uFF1A");
+    for (const info of backedUpFiles) {
+      console.log(`  \u5DF2\u5907\u4EFD ${info}`);
+    }
+    console.log("");
+  }
+  const actualSkillIds = [];
+  const syncedAgents = [];
+  const syncedHooks = [];
+  let hasWarning = false;
+  for (const tool of toolNames) {
+    try {
+      reader.getToolEntry(tool);
+    } catch {
       continue;
     }
-    const src = path18.join(cliDir2, "skills", skillId);
-    const dest = path18.join(targetDir, ".claude", "skills", skillId);
-    if (fs20.existsSync(src)) {
-      ensureDir(path18.dirname(dest));
-      copyDir(src, dest);
-      console.log(`\u2714 ${skillId} \u5DF2\u66F4\u65B0`);
+    const beforeAgents = reader.getToolAgents(tool);
+    const beforeHooks = reader.getToolHooks(tool);
+    try {
+      const ids = renderToolAssets(
+        tool,
+        reader,
+        cliDir2,
+        targetDir,
+        templateVariables,
+        config,
+        registry2,
+        installedMcpTools,
+        ".claude"
+      );
+      actualSkillIds.push(...ids);
+      syncedAgents.push(...beforeAgents);
+      syncedHooks.push(...beforeHooks);
+    } catch (err) {
+      hasWarning = true;
+      console.log(`  \u26A0 ${tool} \u540C\u6B65\u51FA\u9519: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  const syncedSkills = actualSkillIds.length > 0 ? actualSkillIds : [...installedSkillIds];
+  mergeToolHooksJson(toolNames, cliDir2, targetDir);
+  storeNewChecksums(targetDir, installedSkillIds, toolNames, registry2);
+  if (hasWarning) {
+    console.log("\n\u26A0 \u90E8\u5206\u5DE5\u5177\u540C\u6B65\u51FA\u9519\uFF0C\u8BF7\u68C0\u67E5\u540E\u91CD\u8BD5");
+  }
+  const uniqueAgents = [...new Set(syncedAgents)];
+  const uniqueHooks = [...new Set(syncedHooks)];
+  return {
+    syncedSkills,
+    syncedAgents: uniqueAgents,
+    syncedHooks: uniqueHooks,
+    backedUpFiles
+  };
+}
+function upgradeTemplates(cliDir2, targetDir, skillIds) {
+  const report = syncToolAssets(cliDir2, targetDir, skillIds);
+  if (report.syncedSkills.length > 0) {
+    const count = report.syncedSkills.length;
+    const agentCount = report.syncedAgents.length;
+    const hookCount = report.syncedHooks.length;
+    console.log(`
+\u2714 \u540C\u6B65\u5B8C\u6210\uFF1A${count} \u4E2A skill${agentCount > 0 ? `\u3001${agentCount} \u4E2A agent` : ""}${hookCount > 0 ? `\u3001${hookCount} \u4E2A hook` : ""}`);
+    if (report.backedUpFiles.length > 0) {
+      console.log(`  \u5DF2\u5907\u4EFD ${report.backedUpFiles.length} \u4E2A\u4FEE\u6539\u8FC7\u7684\u6587\u4EF6`);
     }
   }
 }
@@ -8227,62 +8490,36 @@ async function updateCLI(fetchFn) {
     console.log("\u2713 \u5DF2\u662F\u6700\u65B0\u7248\u672C");
   }
 }
-function updateSkills(cliDir2, targetDir, skillIds) {
-  upgradeTemplates(cliDir2, targetDir, skillIds);
+function getInstalledSkillIds(targetDir) {
+  const settingsPath = path19.join(targetDir, ".claude", "settings.json");
+  try {
+    const raw = fs21.readFileSync(settingsPath, "utf-8");
+    const settings = JSON.parse(raw);
+    return settings.deepstorm?.installedSkills ?? [];
+  } catch {
+    return [];
+  }
 }
-function registerUpdateCommand(program2, registry2) {
+function registerUpdateCommand(program2) {
   const cliDir2 = __dirname;
-  const updateCmd = program2.command("update").description("\u68C0\u67E5\u66F4\u65B0\u5E76\u540C\u6B65 skill \u6A21\u677F");
-  updateCmd.option("--check", "\u4EC5\u68C0\u67E5 npm \u6700\u65B0\u7248\u672C").option("--cli", "\u66F4\u65B0 CLI \u81EA\u8EAB").option("--skills", "\u540C\u6B65 skill \u6A21\u677F\u5230\u672C\u5730").action(async (options) => {
-    const { check, cli, skills } = options;
-    if (!check && !cli && !skills) {
-      await updateCLI();
-      console.log("");
-      upgradeTemplates(cliDir2, process.cwd(), Object.keys(registry2.skills));
-      return;
-    }
-    if (check) {
-      const result = await checkNpmVersion();
-      printVersionInfo(result);
-      if (result.error) process.exit(1);
-      return;
-    }
-    if (cli) {
-      await updateCLI();
-      return;
-    }
-    if (skills) {
-      const skillIds = Object.keys(registry2.skills);
-      if (skillIds.length === 0) {
-        console.log("registry \u4E2D\u65E0\u5DF2\u6CE8\u518C skill");
-        return;
-      }
-      updateSkills(cliDir2, process.cwd(), skillIds);
-      return;
+  program2.command("update").description("\u68C0\u67E5 CLI \u66F4\u65B0\u5E76\u540C\u6B65\u5DF2\u5B89\u88C5 skill \u7684\u5B98\u65B9\u6700\u65B0\u6A21\u677F").action(async () => {
+    await updateCLI();
+    console.log("");
+    const installedIds = getInstalledSkillIds(process.cwd());
+    if (installedIds.length === 0) {
+      console.log("\u672A\u68C0\u6D4B\u5230\u5DF2\u5B89\u88C5\u7684 skill\uFF0C\u8DF3\u8FC7\u540C\u6B65");
+    } else {
+      upgradeTemplates(cliDir2, process.cwd(), installedIds);
     }
   });
 }
-function printVersionInfo(result) {
-  if (result.error) {
-    console.log(`\u26A0 \u65E0\u6CD5\u68C0\u67E5\u66F4\u65B0\uFF1A${result.error}`);
-    return;
-  }
-  console.log(`\u2714 \u5F53\u524D\u7248\u672C: v${result.current}`);
-  console.log(`\u2714 \u6700\u65B0\u7248\u672C: v${result.latest}`);
-  if (result.hasUpdate) {
-    console.log("");
-    console.log('\u2192 \u6709\u65B0\u7248\u672C\u53EF\u7528\uFF01\u8FD0\u884C "deepstorm update --cli" \u66F4\u65B0');
-  } else {
-    console.log("\u2713 \u5DF2\u662F\u6700\u65B0\u7248\u672C");
-  }
-}
 
 // src/commands/doctor.ts
-var fs21 = __toESM(require("node:fs"));
-var path19 = __toESM(require("node:path"));
+var fs22 = __toESM(require("node:fs"));
+var path20 = __toESM(require("node:path"));
 function getInstalledSkills(settingsPath) {
   try {
-    const settings = JSON.parse(fs21.readFileSync(settingsPath, "utf-8"));
+    const settings = JSON.parse(fs22.readFileSync(settingsPath, "utf-8"));
     return settings.deepstorm?.installedSkills || [];
   } catch {
     return [];
@@ -8291,7 +8528,7 @@ function getInstalledSkills(settingsPath) {
 function runDoctor(targetDir) {
   const checks = [];
   const version = getCliVersion();
-  const settingsPath = path19.join(targetDir, ".claude", "settings.json");
+  const settingsPath = path20.join(targetDir, ".claude", "settings.json");
   readDeepStormConfig(settingsPath);
   checks.push({
     name: "CLI \u7248\u672C",
@@ -8299,7 +8536,7 @@ function runDoctor(targetDir) {
     message: `v${version}\uFF08\u8FD0\u884C deepstorm update --check \u68C0\u67E5\u6700\u65B0\u7248\u672C\uFF09`
   });
   let hasDeepStorm = false;
-  if (!fs21.existsSync(settingsPath)) {
+  if (!fs22.existsSync(settingsPath)) {
     checks.push({
       name: "\u914D\u7F6E\u6587\u4EF6",
       status: "warn",
@@ -8307,7 +8544,7 @@ function runDoctor(targetDir) {
     });
   } else {
     try {
-      const settings = JSON.parse(fs21.readFileSync(settingsPath, "utf-8"));
+      const settings = JSON.parse(fs22.readFileSync(settingsPath, "utf-8"));
       if (settings.deepstorm) {
         hasDeepStorm = true;
         checks.push({
@@ -8330,20 +8567,20 @@ function runDoctor(targetDir) {
       });
     }
   }
-  const skillsDir = path19.join(targetDir, ".claude", "skills");
-  if (fs21.existsSync(skillsDir)) {
-    const skillDirs = fs21.readdirSync(skillsDir).filter(
-      (n) => fs21.statSync(path19.join(skillsDir, n)).isDirectory()
+  const skillsDir = path20.join(targetDir, ".claude", "skills");
+  if (fs22.existsSync(skillsDir)) {
+    const skillDirs = fs22.readdirSync(skillsDir).filter(
+      (n) => fs22.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 (!fs21.existsSync(skillMd)) {
+      const skillMd = path20.join(skillsDir, skillName, "SKILL.md");
+      if (!fs22.existsSync(skillMd)) {
         invalidCount++;
         continue;
       }
-      const content = fs21.readFileSync(skillMd, "utf-8");
+      const content = fs22.readFileSync(skillMd, "utf-8");
       const frontmatter = parseFrontmatter(content);
       if (frontmatter && frontmatter.name) {
         validCount++;
@@ -8373,7 +8610,7 @@ function runDoctor(targetDir) {
     const installedSkills = getInstalledSkills(settingsPath);
     const missingSkills = [];
     for (const skillId of installedSkills) {
-      if (!fs21.existsSync(path19.join(skillsDir, skillId))) {
+      if (!fs22.existsSync(path20.join(skillsDir, skillId))) {
         missingSkills.push(skillId);
       }
     }
@@ -8397,10 +8634,10 @@ function runDoctor(targetDir) {
       message: ".claude/skills/ \u4E0D\u5B58\u5728"
     });
   }
-  const mcpPath = path19.join(targetDir, ".mcp.json");
-  if (fs21.existsSync(mcpPath)) {
+  const mcpPath = path20.join(targetDir, ".mcp.json");
+  if (fs22.existsSync(mcpPath)) {
     try {
-      const mcp = JSON.parse(fs21.readFileSync(mcpPath, "utf-8"));
+      const mcp = JSON.parse(fs22.readFileSync(mcpPath, "utf-8"));
       const hasServers = mcp.mcpServers && Object.keys(mcp.mcpServers).length > 0;
       checks.push({
         name: "MCP \u670D\u52A1\u5668",
@@ -8421,12 +8658,12 @@ function runDoctor(targetDir) {
       message: ".mcp.json \u4E0D\u5B58\u5728"
     });
   }
-  if (hasDeepStorm && fs21.existsSync(settingsPath)) {
+  if (hasDeepStorm && fs22.existsSync(settingsPath)) {
     try {
-      const settings = JSON.parse(fs21.readFileSync(settingsPath, "utf-8"));
+      const settings = JSON.parse(fs22.readFileSync(settingsPath, "utf-8"));
       const installedMcp = settings.deepstorm?.installedMcpServers;
       if (installedMcp && installedMcp.length > 0) {
-        const mcpExists = fs21.existsSync(mcpPath);
+        const mcpExists = fs22.existsSync(mcpPath);
         if (!mcpExists) {
           checks.push({
             name: "MCP \u4E00\u81F4\u6027",
@@ -8435,7 +8672,7 @@ function runDoctor(targetDir) {
           });
         } else {
           try {
-            const mcpConfig = JSON.parse(fs21.readFileSync(mcpPath, "utf-8"));
+            const mcpConfig = JSON.parse(fs22.readFileSync(mcpPath, "utf-8"));
             const servers = mcpConfig.mcpServers || {};
             const missing = [];
             for (const toolName of installedMcp) {
@@ -8463,9 +8700,9 @@ function runDoctor(targetDir) {
     } catch {
     }
   }
-  if (hasDeepStorm && fs21.existsSync(settingsPath)) {
+  if (hasDeepStorm && fs22.existsSync(settingsPath)) {
     try {
-      const settings = JSON.parse(fs21.readFileSync(settingsPath, "utf-8"));
+      const settings = JSON.parse(fs22.readFileSync(settingsPath, "utf-8"));
       const config = settings.deepstorm;
       const validKeys = loadValidConfigKeys();
       if (validKeys.size > 0 && config) {
@@ -8519,18 +8756,18 @@ function printDoctorReport(report) {
 }
 
 // src/commands/uninstall.ts
-var fs22 = __toESM(require("node:fs"));
-var path20 = __toESM(require("node:path"));
+var fs23 = __toESM(require("node:fs"));
+var path21 = __toESM(require("node:path"));
 var import_prompts4 = require("@clack/prompts");
 async function uninstallDeepStorm(targetDir) {
-  const settingsPath = path20.join(targetDir, ".claude", "settings.json");
-  if (!fs22.existsSync(settingsPath)) {
+  const settingsPath = path21.join(targetDir, ".claude", "settings.json");
+  if (!fs23.existsSync(settingsPath)) {
     console.log("DeepStorm \u5C1A\u672A\u914D\u7F6E\uFF0C\u65E0\u9700\u5378\u8F7D");
     return;
   }
   let hasDeepStorm = false;
   try {
-    const settings = JSON.parse(fs22.readFileSync(settingsPath, "utf-8"));
+    const settings = JSON.parse(fs23.readFileSync(settingsPath, "utf-8"));
     hasDeepStorm = !!settings.deepstorm;
   } catch {
   }
@@ -8540,14 +8777,14 @@ async function uninstallDeepStorm(targetDir) {
   }
   cleanInstalled(targetDir);
   resetConfig(targetDir);
-  const templatesDir = path20.join(targetDir, ".deepstorm", "templates");
-  if (fs22.existsSync(templatesDir)) {
+  const templatesDir = path21.join(targetDir, ".deepstorm", "templates");
+  if (fs23.existsSync(templatesDir)) {
     const shouldDelete = await (0, import_prompts4.confirm)({
       message: "\u662F\u5426\u5220\u9664 .deepstorm/templates/ \u76EE\u5F55\uFF1F",
       initialValue: false
     });
     if (shouldDelete) {
-      fs22.rmSync(templatesDir, { recursive: true, force: true });
+      fs23.rmSync(templatesDir, { recursive: true, force: true });
       console.log("\u2714 .deepstorm/templates/ \u5DF2\u5220\u9664");
     } else {
       console.log("\u4FDD\u7559 .deepstorm/templates/");
@@ -8560,9 +8797,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 = fs23.readFileSync(registryPath, "utf-8");
+    const raw = fs24.readFileSync(registryPath, "utf-8");
     return JSON.parse(raw);
   } catch {
     return { version: "1", tools: {}, wizards: {}, skills: {} };
@@ -8573,7 +8810,7 @@ registerSetupCommand(program, registry);
 registerPluginBuildCommand(program, registry);
 registerConfigCommand(program, registry);
 registerTemplateCommand(program, registry);
-registerUpdateCommand(program, registry);
+registerUpdateCommand(program);
 program.command("doctor").description("\u8BCA\u65AD\u9879\u76EE DeepStorm \u914D\u7F6E\u72B6\u6001").action(() => {
   const report = runDoctor(process.cwd());
   printDoctorReport(report);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deepstorm/cli",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "description": "DeepStorm CLI — 一键配置项目开发环境",
   "license": "MIT",
   "author": "billkang",