@deepstorm/cli 0.4.1 → 0.6.0

package/dist/cli.js

@@ -1187,13 +1187,13 @@ var require_ast = __commonJS({
         helperExpression: function helperExpression(node) {
           return node.type === "SubExpression" || (node.type === "MustacheStatement" || node.type === "BlockStatement") && !!(node.params && node.params.length || node.hash);
         },
-        scopedId: function scopedId(path23) {
-          return /^\.|this\b/.test(path23.original);
+        scopedId: function scopedId(path24) {
+          return /^\.|this\b/.test(path24.original);
         },
         // an ID is simple if it only has one part, and that part is not
         // `..` or `this`.
-        simpleId: function simpleId(path23) {
-          return path23.parts.length === 1 && !AST.helpers.scopedId(path23) && !path23.depth;
+        simpleId: function simpleId(path24) {
+          return path24.parts.length === 1 && !AST.helpers.scopedId(path24) && !path24.depth;
         }
       }
     };
@@ -2263,12 +2263,12 @@ var require_helpers2 = __commonJS({
         loc
       };
     }
-    function prepareMustache(path23, params, hash, open, strip, locInfo) {
+    function prepareMustache(path24, 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: path23,
+        path: path24,
         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), path23 = decorator.path;
+        var params = this.setupFullMustacheParams(decorator, program2, void 0), path24 = decorator.path;
         this.useDecorators = true;
-        this.opcode("registerDecorator", params.length, path23.original);
+        this.opcode("registerDecorator", params.length, path24.original);
       },
       PartialStatement: function PartialStatement(partial) {
         this.usePartial = true;
@@ -2652,46 +2652,46 @@ var require_compiler = __commonJS({
         }
       },
       ambiguousSexpr: function ambiguousSexpr(sexpr, program2, inverse) {
-        var path23 = sexpr.path, name = path23.parts[0], isBlock = program2 != null || inverse != null;
-        this.opcode("getContext", path23.depth);
+        var path24 = sexpr.path, name = path24.parts[0], isBlock = program2 != null || inverse != null;
+        this.opcode("getContext", path24.depth);
         this.opcode("pushProgram", program2);
         this.opcode("pushProgram", inverse);
-        path23.strict = true;
-        this.accept(path23);
+        path24.strict = true;
+        this.accept(path24);
         this.opcode("invokeAmbiguous", name, isBlock);
       },
       simpleSexpr: function simpleSexpr(sexpr) {
-        var path23 = sexpr.path;
-        path23.strict = true;
-        this.accept(path23);
+        var path24 = sexpr.path;
+        path24.strict = true;
+        this.accept(path24);
         this.opcode("resolvePossibleLambda");
       },
       helperSexpr: function helperSexpr(sexpr, program2, inverse) {
-        var params = this.setupFullMustacheParams(sexpr, program2, inverse), path23 = sexpr.path, name = path23.parts[0];
+        var params = this.setupFullMustacheParams(sexpr, program2, inverse), path24 = sexpr.path, name = path24.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 {
-          path23.strict = true;
-          path23.falsy = true;
-          this.accept(path23);
-          this.opcode("invokeHelper", params.length, path23.original, _ast2["default"].helpers.simpleId(path23));
+          path24.strict = true;
+          path24.falsy = true;
+          this.accept(path24);
+          this.opcode("invokeHelper", params.length, path24.original, _ast2["default"].helpers.simpleId(path24));
         }
       },
-      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);
+      PathExpression: function PathExpression(path24) {
+        this.addDepth(path24.depth);
+        this.opcode("getContext", path24.depth);
+        var name = path24.parts[0], scoped = _ast2["default"].helpers.scopedId(path24), blockParamId = !path24.depth && !scoped && this.blockParamIndex(name);
         if (blockParamId) {
-          this.opcode("lookupBlockParam", blockParamId, path23.parts);
+          this.opcode("lookupBlockParam", blockParamId, path24.parts);
         } else if (!name) {
           this.opcode("pushContext");
-        } else if (path23.data) {
+        } else if (path24.data) {
           this.options.data = true;
-          this.opcode("lookupData", path23.depth, path23.parts, path23.strict);
+          this.opcode("lookupData", path24.depth, path24.parts, path24.strict);
         } else {
-          this.opcode("lookupOnContext", path23.parts, path23.falsy, path23.strict, scoped);
+          this.opcode("lookupOnContext", path24.parts, path24.falsy, path24.strict, scoped);
         }
       },
       StringLiteral: function StringLiteral(string) {
@@ -3041,16 +3041,16 @@ var require_util = __commonJS({
     }
     exports2.urlGenerate = urlGenerate;
     function normalize(aPath) {
-      var path23 = aPath;
+      var path24 = aPath;
       var url = urlParse(aPath);
       if (url) {
         if (!url.path) {
           return aPath;
         }
-        path23 = url.path;
+        path24 = url.path;
       }
-      var isAbsolute = exports2.isAbsolute(path23);
-      var parts = path23.split(/\/+/);
+      var isAbsolute = exports2.isAbsolute(path24);
+      var parts = path24.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({
           }
         }
       }
-      path23 = parts.join("/");
-      if (path23 === "") {
-        path23 = isAbsolute ? "/" : ".";
+      path24 = parts.join("/");
+      if (path24 === "") {
+        path24 = isAbsolute ? "/" : ".";
       }
       if (url) {
-        url.path = path23;
+        url.path = path24;
         return urlGenerate(url);
       }
-      return path23;
+      return path24;
     }
     exports2.normalize = normalize;
-    function join21(aRoot, aPath) {
+    function join22(aRoot, aPath) {
       if (aRoot === "") {
         aRoot = ".";
       }
@@ -3110,7 +3110,7 @@ var require_util = __commonJS({
       }
       return joined;
     }
-    exports2.join = join21;
+    exports2.join = join22;
     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 = join21(urlGenerate(parsed), sourceURL);
+        sourceURL = join22(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 path23 = id.parts.join("/");
-      return (id.data ? "@" : "") + "PATH:" + path23;
+      var path24 = id.parts.join("/");
+      return (id.data ? "@" : "") + "PATH:" + path24;
     };
     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 fs25 = require("fs");
-      var templateString = fs25.readFileSync(filename, "utf8");
+      var fs26 = require("fs");
+      var templateString = fs26.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 fs24 = __toESM(require("node:fs"));
-var path22 = __toESM(require("node:path"));
+var fs25 = __toESM(require("node:fs"));
+var path23 = __toESM(require("node:path"));
 
 // src/commands/setup.ts
 var path6 = __toESM(require("node:path"));
@@ -7449,23 +7449,815 @@ function readExistingEnvKeys(envPath) {
   return keys;
 }
 
+// src/commands/init.ts
+var fs11 = __toESM(require("node:fs"));
+var path7 = __toESM(require("node:path"));
+var VALID_PROJECT_NAME = /^[a-zA-Z0-9_-]+$/;
+function parseInitArgs(raw) {
+  const opts = {};
+  if (raw.name && typeof raw.name === "string") opts.projectName = raw.name;
+  if (raw.frontend && typeof raw.frontend === "string") opts.frontend = raw.frontend;
+  if (raw.backend && typeof raw.backend === "string") opts.backend = raw.backend;
+  if (raw.output && typeof raw.output === "string") opts.output = raw.output;
+  if (raw.uiLib && typeof raw.uiLib === "string") opts.uiLib = raw.uiLib;
+  if (raw.cssFramework && typeof raw.cssFramework === "string") opts.cssFramework = raw.cssFramework;
+  if (raw.orm && typeof raw.orm === "string") opts.orm = raw.orm;
+  if (raw.migration && typeof raw.migration === "string") opts.migration = raw.migration;
+  if (raw.ai && typeof raw.ai === "string") opts.ai = raw.ai;
+  if (raw["ui-lib"] && typeof raw["ui-lib"] === "string") opts.uiLib = raw["ui-lib"];
+  if (raw["css"] && typeof raw["css"] === "string") opts.cssFramework = raw["css"];
+  return opts;
+}
+function registerInitCommand(program2) {
+  program2.command("init").description("\u521D\u59CB\u5316\u9879\u76EE\u811A\u624B\u67B6 \u2014 \u9009\u62E9\u6280\u672F\u6808\uFF0C\u751F\u6210\u9879\u76EE\u9AA8\u67B6").option("--name <name>", "\u9879\u76EE\u540D\u79F0").option("--frontend <framework>", "\u524D\u7AEF\u6846\u67B6\uFF08angular\uFF09").option("--backend <language>", "\u540E\u7AEF\u8BED\u8A00\uFF08java\uFF09").option("--output <dir>", "\u8F93\u51FA\u76EE\u5F55\uFF08\u9ED8\u8BA4\u4E3A\u5F53\u524D\u76EE\u5F55\uFF09").option("--ui-lib <lib>", "UI \u5E93\uFF08primeng\uFF09").option("--css <framework>", "CSS \u6846\u67B6\uFF08tailwind\uFF09").option("--orm <orm>", "ORM \u6846\u67B6\uFF08hibernate\uFF09").option("--migration <tool>", "\u6570\u636E\u5E93\u8FC1\u79FB\u5DE5\u5177\uFF08liquibase\uFF09").option("--ai <framework>", "AI \u6846\u67B6\uFF08spring-ai\uFF09").action(async (options) => {
+    const args = parseInitArgs(options);
+    const targetDir = options.output || process.cwd();
+    if (args.projectName && (args.frontend || args.backend)) {
+      await runInit(targetDir, args);
+    } else {
+      await runInteractiveMode(targetDir);
+    }
+  });
+}
+function buildContext(opts) {
+  return {
+    projectName: opts.projectName,
+    packageName: opts.projectName.replace(/[_-]/g, "").toLowerCase(),
+    groupId: "com.example",
+    frontend: opts.frontend || false,
+    backend: opts.backend || false,
+    uiLib: opts.uiLib || false,
+    cssFramework: opts.cssFramework || false,
+    orm: opts.orm || false,
+    migration: opts.migration || false,
+    ai: opts.ai || false
+  };
+}
+async function runInteractiveMode(targetDir) {
+  const { intro: intro2, outro: outro2, text: text2, select: select2, isCancel: isCancel8, confirm: confirm6 } = await import("@clack/prompts");
+  intro2("\u{1F680} DeepStorm Init \u2014 \u9879\u76EE\u811A\u624B\u67B6\u521D\u59CB\u5316");
+  const projectName = await text2({
+    message: "\u9879\u76EE\u540D\u79F0\uFF1A",
+    placeholder: "my-project",
+    validate: (value) => {
+      if (!value) return "\u8BF7\u8F93\u5165\u9879\u76EE\u540D\u79F0";
+      if (!VALID_PROJECT_NAME.test(value)) return "\u9879\u76EE\u540D\u4EC5\u652F\u6301\u5B57\u6BCD\u3001\u6570\u5B57\u3001\u4E0B\u5212\u7EBF\u548C\u77ED\u6A2A\u7EBF";
+      return void 0;
+    }
+  });
+  if (isCancel8(projectName) || typeof projectName !== "string") {
+    outro2("\u5DF2\u53D6\u6D88");
+    return;
+  }
+  const frontendChoice = await select2({
+    message: "\u9009\u62E9\u524D\u7AEF\u6846\u67B6\uFF1A",
+    options: [
+      { value: "angular", label: "Angular" },
+      { value: "none", label: "\u4E0D\u9700\u8981\u524D\u7AEF" }
+    ]
+  });
+  if (isCancel8(frontendChoice)) {
+    outro2("\u5DF2\u53D6\u6D88");
+    return;
+  }
+  let uiLib;
+  let cssFramework;
+  if (frontendChoice === "angular") {
+    uiLib = await select2({
+      message: "\u9009\u62E9 UI \u5E93\uFF1A",
+      options: [
+        { value: "primeng", label: "PrimeNG" },
+        { value: "none", label: "\u65E0\uFF08\u4EC5 Angular \u6838\u5FC3\uFF09" }
+      ]
+    });
+    if (isCancel8(uiLib)) {
+      outro2("\u5DF2\u53D6\u6D88");
+      return;
+    }
+    cssFramework = await select2({
+      message: "\u9009\u62E9 CSS \u65B9\u6848\uFF1A",
+      options: [
+        { value: "tailwind", label: "Tailwind CSS" },
+        { value: "none", label: "\u6807\u51C6 CSS" }
+      ]
+    });
+    if (isCancel8(cssFramework)) {
+      outro2("\u5DF2\u53D6\u6D88");
+      return;
+    }
+  }
+  const backendChoice = await select2({
+    message: "\u9009\u62E9\u540E\u7AEF\u6846\u67B6\uFF1A",
+    options: [
+      { value: "java", label: "Java (Spring Boot)" },
+      { value: "none", label: "\u4E0D\u9700\u8981\u540E\u7AEF" }
+    ]
+  });
+  if (isCancel8(backendChoice)) {
+    outro2("\u5DF2\u53D6\u6D88");
+    return;
+  }
+  let orm;
+  let migration;
+  let aiChoice;
+  if (backendChoice === "java") {
+    orm = await select2({
+      message: "\u9009\u62E9 ORM \u6846\u67B6\uFF1A",
+      options: [
+        { value: "hibernate", label: "Hibernate" },
+        { value: "none", label: "\u65E0" }
+      ]
+    });
+    if (isCancel8(orm)) {
+      outro2("\u5DF2\u53D6\u6D88");
+      return;
+    }
+    migration = await select2({
+      message: "\u9009\u62E9\u6570\u636E\u5E93\u8FC1\u79FB\u5DE5\u5177\uFF1A",
+      options: [
+        { value: "liquibase", label: "Liquibase" },
+        { value: "none", label: "\u65E0" }
+      ]
+    });
+    if (isCancel8(migration)) {
+      outro2("\u5DF2\u53D6\u6D88");
+      return;
+    }
+    aiChoice = await select2({
+      message: "\u9009\u62E9 AI \u6846\u67B6\uFF1A",
+      options: [
+        { value: "spring-ai", label: "Spring AI" },
+        { value: "none", label: "\u65E0" }
+      ]
+    });
+    if (isCancel8(aiChoice)) {
+      outro2("\u5DF2\u53D6\u6D88");
+      return;
+    }
+  }
+  if ((!frontendChoice || frontendChoice === "none") && (!backendChoice || backendChoice === "none")) {
+    console.error("\u274C \u81F3\u5C11\u9700\u8981\u9009\u62E9\u524D\u7AEF\u6216\u540E\u7AEF\u4E4B\u4E00");
+    outro2("\u521D\u59CB\u5316\u5931\u8D25");
+    return;
+  }
+  await runInit(targetDir, {
+    projectName,
+    frontend: frontendChoice === "none" ? void 0 : frontendChoice,
+    backend: backendChoice === "none" ? void 0 : backendChoice,
+    uiLib: uiLib && uiLib !== "none" ? uiLib : void 0,
+    cssFramework: cssFramework && cssFramework !== "none" ? cssFramework : void 0,
+    orm: orm && orm !== "none" ? orm : void 0,
+    migration: migration && migration !== "none" ? migration : void 0,
+    ai: aiChoice && aiChoice !== "none" ? aiChoice : void 0
+  });
+  outro2("\u2705 \u9879\u76EE\u5DF2\u751F\u6210\uFF01");
+}
+async function runInit(baseDir, opts) {
+  if (!opts.projectName) {
+    throw new Error("\u9879\u76EE\u540D\u79F0\u4E3A\u5FC5\u586B\u9879");
+  }
+  if (!VALID_PROJECT_NAME.test(opts.projectName)) {
+    throw new Error(`\u9879\u76EE\u540D "${opts.projectName}" \u5305\u542B\u975E\u6CD5\u5B57\u7B26\u3002\u4EC5\u652F\u6301\u5B57\u6BCD\u3001\u6570\u5B57\u3001\u4E0B\u5212\u7EBF\u548C\u77ED\u6A2A\u7EBF\u3002`);
+  }
+  const projectDir = path7.join(baseDir, opts.projectName);
+  if (fs11.existsSync(projectDir)) {
+    throw new Error(`\u76EE\u6807\u76EE\u5F55 ${projectDir} \u5DF2\u5B58\u5728\u3002\u8BF7\u5220\u9664\u540E\u91CD\u8BD5\u6216\u4F7F\u7528\u5176\u4ED6\u9879\u76EE\u540D\u3002`);
+  }
+  const ctx = buildContext(opts);
+  fs11.mkdirSync(projectDir, { recursive: true });
+  const hasFrontend = opts.frontend === "angular";
+  const hasBackend = opts.backend === "java";
+  try {
+    if (hasFrontend) {
+      renderAngularTemplate(projectDir, ctx);
+    }
+    if (hasBackend) {
+      renderJavaTemplate(projectDir, ctx);
+    }
+    renderCommonFiles(projectDir, ctx);
+    console.log(`
+\u2714 \u9879\u76EE\u5DF2\u521B\u5EFA: ${projectDir}`);
+    console.log("\n\u4E0B\u4E00\u6B65:");
+    console.log(`  cd ${opts.projectName}`);
+    if (opts.frontend) console.log(`  pnpm install        # \u5B89\u88C5\u524D\u7AEF\u4F9D\u8D56`);
+    if (opts.backend) console.log(`  ./gradlew build      # \u6784\u5EFA\u540E\u7AEF`);
+    console.log();
+    printProjectTree(projectDir, hasFrontend, hasBackend);
+  } catch (err) {
+    if (fs11.existsSync(projectDir)) {
+      fs11.rmSync(projectDir, { recursive: true, force: true });
+    }
+    throw err;
+  }
+}
+function renderAngularTemplate(projectDir, ctx) {
+  const hasPrimeng = ctx.uiLib === "primeng";
+  const hasTailwind = ctx.cssFramework === "tailwind";
+  writeTemplate(projectDir, "angular.json", JSON.stringify({
+    $schema: "./node_modules/@angular/cli/lib/config/schema.json",
+    version: 1,
+    newProjectRoot: "projects",
+    projects: {
+      [ctx.packageName]: {
+        projectType: "application",
+        root: "",
+        sourceRoot: "src/main/web",
+        prefix: "app",
+        architect: {
+          build: {
+            builder: "@angular-devkit/build-angular:application",
+            options: {
+              outputPath: "build",
+              index: "src/main/web/index.html",
+              browser: "src/main/web/main.ts",
+              polyfills: ["zone.js"],
+              tsConfig: "tsconfig.app.json",
+              assets: [{ glob: "**/*", input: "public" }],
+              styles: getAngularStyles(hasPrimeng),
+              scripts: []
+            },
+            configurations: {
+              production: { budgets: [], outputHashing: "all" },
+              development: { optimization: false, extractLicenses: false, sourceMap: true }
+            },
+            defaultConfiguration: "production"
+          },
+          serve: {
+            builder: "@angular-devkit/build-angular:dev-server",
+            configurations: { production: { buildTarget: `${ctx.packageName}:build:production` }, development: { buildTarget: `${ctx.packageName}:build:development` } },
+            defaultConfiguration: "development",
+            options: { proxyConfig: "proxy.conf.json" }
+          },
+          test: {
+            builder: "@angular-devkit/build-angular:karma",
+            options: { polyfills: ["zone.js", "zone.js/testing"], tsConfig: "tsconfig.spec.json", assets: [{ glob: "**/*", input: "public" }], styles: getAngularStyles(hasPrimeng), scripts: [] }
+          }
+        }
+      }
+    }
+  }, null, 2));
+  writeTemplate(projectDir, "tsconfig.json", JSON.stringify({
+    compileOnSave: false,
+    compilerOptions: {
+      baseUrl: "./",
+      outDir: "./dist",
+      forceConsistentCasingInFileNames: true,
+      strict: true,
+      noImplicitOverride: true,
+      noPropertyAccessFromIndexSignature: true,
+      noImplicitReturns: true,
+      noFallthroughCasesInSwitch: true,
+      sourceMap: true,
+      declaration: false,
+      downlevelIteration: true,
+      experimentalDecorators: true,
+      moduleResolution: "bundler",
+      importHelpers: true,
+      target: "ES2022",
+      module: "ES2022",
+      lib: ["ES2022", "dom"],
+      skipLibCheck: true
+    },
+    angularCompilerOptions: {
+      enableI18nLegacyMessageIdFormat: false,
+      strictInjectionParameters: true,
+      strictInputAccessModifiers: true,
+      strictTemplates: true
+    }
+  }, null, 2));
+  writeTemplate(projectDir, "tsconfig.app.json", JSON.stringify({
+    extends: "./tsconfig.json",
+    compilerOptions: { outDir: "./out-tsc/app", types: [] },
+    files: ["src/main/web/main.ts"],
+    include: ["src/**/*.d.ts"]
+  }, null, 2));
+  writeTemplate(projectDir, "tsconfig.spec.json", JSON.stringify({
+    extends: "./tsconfig.json",
+    compilerOptions: { outDir: "./out-tsc/spec", types: ["jasmine"] },
+    include: ["src/**/*.spec.ts", "src/**/*.d.ts"]
+  }, null, 2));
+  const pkgDeps = {
+    "@angular/animations": "^21.0.0",
+    "@angular/common": "^21.0.0",
+    "@angular/compiler": "^21.0.0",
+    "@angular/core": "^21.0.0",
+    "@angular/forms": "^21.0.0",
+    "@angular/platform-browser": "^21.0.0",
+    "@angular/router": "^21.0.0",
+    "rxjs": "~7.8.0",
+    "tslib": "^2.3.0",
+    "zone.js": "~0.15.0"
+  };
+  const devDeps = {
+    "@angular-devkit/build-angular": "^21.0.0",
+    "@angular/cli": "^21.0.0",
+    "@angular/compiler-cli": "^21.0.0",
+    "typescript": "~5.7.0"
+  };
+  if (hasPrimeng) {
+    pkgDeps["primeng"] = "^21.0.0";
+    pkgDeps["@primeng/themes"] = "^21.0.0";
+    pkgDeps["@primeuix/themes"] = "^2.0.0";
+  }
+  writeTemplate(projectDir, "package.json", JSON.stringify({
+    name: ctx.packageName,
+    version: "1.0.0-dev",
+    private: true,
+    packageManager: "pnpm@10.0.0",
+    scripts: {
+      ng: "ng",
+      start: "ng serve",
+      build: "ng build",
+      watch: "ng build --watch --configuration development",
+      test: "ng test",
+      lint: "ng lint",
+      typecheck: "tsc --build --noEmit"
+    },
+    dependencies: pkgDeps,
+    devDependencies: devDeps
+  }, null, 2));
+  writeTemplate(projectDir, "proxy.conf.json", JSON.stringify({
+    "/api": {
+      target: "http://localhost:8080",
+      secure: false
+    }
+  }, null, 2));
+  writeTemplate(projectDir, "eslint.config.mjs", `import globals from "globals";
+import pluginJs from "@eslint/js";
+import tseslint from "typescript-eslint";
+
+export default [
+  { files: ["**/*.{js,mjs,cjs,ts}"] },
+  { languageOptions: { globals: globals.browser } },
+  pluginJs.configs.recommended,
+  ...tseslint.configs.recommended,
+];
+`);
+  ensureDir2(path7.join(projectDir, "public"));
+  ensureDir2(path7.join(projectDir, "src/main/web/app"));
+  writeTemplate(projectDir, "src/main/web/index.html", `<!doctype html>
+<html lang="zh-CN">
+<head>
+  <meta charset="utf-8">
+  <title>${ctx.projectName}</title>
+  <base href="/">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <link rel="icon" type="image/x-icon" href="favicon.ico">
+</head>
+<body>
+  <app-root></app-root>
+</body>
+</html>
+`);
+  writeTemplate(projectDir, "src/main/web/main.ts", `import { bootstrapApplication } from '@angular/platform-browser';
+import { appConfig } from './app/app.config';
+import { App } from './app/app';
+
+bootstrapApplication(App, appConfig).catch((err) => console.error(err));
+`);
+  const stylesContent = hasTailwind ? `@import "tailwindcss";
+
+/* \u5168\u5C40\u6837\u5F0F */
+` : `/* \u5168\u5C40\u6837\u5F0F */
+`;
+  writeTemplate(projectDir, "src/main/web/styles.css", stylesContent);
+  writeTemplate(projectDir, "src/main/web/app/app.ts", `import { Component } from '@angular/core';
+import { RouterOutlet } from '@angular/router';
+
+@Component({
+  selector: 'app-root',
+  standalone: true,
+  imports: [RouterOutlet],
+  template: \`<router-outlet></router-outlet>\`,
+})
+export class App {}
+`);
+  writeTemplate(projectDir, "src/main/web/app/app.config.ts", `import { ApplicationConfig, provideZoneChangeDetection } from '@angular/core';
+import { provideRouter } from '@angular/router';
+import { routes } from './app.routes';
+
+export const appConfig: ApplicationConfig = {
+  providers: [
+    provideZoneChangeDetection({ eventCoalescing: true }),
+    provideRouter(routes),
+  ],
+};
+`);
+  writeTemplate(projectDir, "src/main/web/app/app.routes.ts", `import { Routes } from '@angular/router';
+
+export const routes: Routes = [];
+`);
+  if (hasTailwind) {
+    writeTemplate(projectDir, "postcss.config.json", JSON.stringify({
+      plugins: { "@tailwindcss/postcss": {} }
+    }, null, 2));
+  }
+}
+function getAngularStyles(hasPrimeng) {
+  const styles = [];
+  if (hasPrimeng) {
+    styles.push("@primeng/themes/aura/aura.css");
+  }
+  styles.push("src/main/web/styles.css");
+  return styles;
+}
+function renderJavaTemplate(projectDir, ctx) {
+  const hasOrm = ctx.orm === "hibernate";
+  const hasLiquibase = ctx.migration === "liquibase";
+  const hasSpringAi = ctx.ai === "spring-ai";
+  writeTemplate(projectDir, "settings.gradle.kts", `rootProject.name = "${ctx.packageName}"
+`);
+  writeTemplate(projectDir, "gradle.properties", `# Gradle JVM \u53C2\u6570
+org.gradle.jvmargs=-Xmx2048m -Dfile.encoding=UTF-8
+# \u5E76\u884C\u6784\u5EFA
+org.gradle.parallel=true
+`);
+  const plugins = [
+    "java",
+    "org.springframework.boot",
+    "io.spring.dependency-management"
+  ];
+  const gradleDeps = [
+    'implementation("org.springframework.boot:spring-boot-starter-web")',
+    'implementation("org.springframework.boot:spring-boot-starter-validation")',
+    'compileOnly("org.jetbrains:annotations:26.0.2")'
+  ];
+  if (hasOrm) {
+    gradleDeps.push('implementation("org.springframework.boot:spring-boot-starter-data-jpa")');
+  }
+  if (hasLiquibase) {
+    gradleDeps.unshift('id("org.liquibase.gradle") version "2.2.2"');
+    gradleDeps.push('implementation("org.liquibase:liquibase-core")');
+  }
+  if (hasSpringAi) {
+    gradleDeps.push('implementation("org.springframework.ai:spring-ai-openai-spring-boot-starter")');
+  }
+  const reposExtra = hasSpringAi ? '\n  maven { url = uri("https://repo.spring.io/milestone") }' : "";
+  writeTemplate(projectDir, "build.gradle.kts", `plugins {
+  ${plugins.map((p7) => `id("${p7}") version "3.4.0"`).join("\n  ")}${hasLiquibase ? `
+  id("org.liquibase.gradle") version "2.2.2"` : ""}
+}
+
+group = "${ctx.groupId}"
+version = "1.0.0-SNAPSHOT"
+description = "${ctx.projectName}"
+
+java {
+  toolchain {
+    languageVersion = JavaLanguageVersion.of(21)
+  }
+}
+
+repositories {
+  mavenCentral()${reposExtra}
+}
+
+dependencies {
+  ${gradleDeps.join("\n  ")}
+
+  testImplementation("org.springframework.boot:spring-boot-starter-test")
+  testRuntimeOnly("org.junit.platform:junit-platform-launcher")
+}
+
+tasks.withType<Test> {
+  useJUnitPlatform()
+}
+`);
+  const appPackage = `${ctx.groupId}.${ctx.packageName}`.replace(/[.-]/g, ".");
+  const appDir = `src/main/java/${appPackage.replace(/\./g, "/")}`;
+  ensureDir2(path7.join(projectDir, appDir));
+  writeTemplate(projectDir, `${appDir}/Application.java`, `package ${appPackage};
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+
+@SpringBootApplication
+public class Application {
+
+  public static void main(String[] args) {
+    SpringApplication.run(Application.class, args);
+  }
+}
+`);
+  const controllerDir = `${appDir}/controller`;
+  ensureDir2(path7.join(projectDir, controllerDir));
+  writeTemplate(projectDir, `${controllerDir}/HealthController.java`, `package ${appPackage}.controller;
+
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+public class HealthController {
+
+  @GetMapping("/api/health")
+  public String health() {
+    return "OK";
+  }
+}
+`);
+  const serviceDir = `${appDir}/service`;
+  ensureDir2(path7.join(projectDir, serviceDir));
+  if (hasOrm) {
+    const repositoryDir = `${appDir}/repository`;
+    ensureDir2(path7.join(projectDir, repositoryDir));
+    const entityDir = `${appDir}/entity`;
+    ensureDir2(path7.join(projectDir, entityDir));
+    writeTemplate(projectDir, `${entityDir}/BaseEntity.java`, `package ${appPackage}.entity;
+
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import jakarta.persistence.MappedSuperclass;
+import java.time.LocalDateTime;
+
+@MappedSuperclass
+public abstract class BaseEntity {
+
+  @Id
+  @GeneratedValue(strategy = GenerationType.IDENTITY)
+  private Long id;
+
+  private LocalDateTime createdAt;
+  private LocalDateTime updatedAt;
+
+  public Long getId() { return id; }
+  public void setId(Long id) { this.id = id; }
+  public LocalDateTime getCreatedAt() { return createdAt; }
+  public void setCreatedAt(LocalDateTime createdAt) { this.createdAt = createdAt; }
+  public LocalDateTime getUpdatedAt() { return updatedAt; }
+  public void setUpdatedAt(LocalDateTime updatedAt) { this.updatedAt = updatedAt; }
+}
+`);
+  }
+  ensureDir2(path7.join(projectDir, "src/main/resources"));
+  const datasourceConfig = hasOrm ? `
+spring:
+  datasource:
+    url: jdbc:h2:mem:${ctx.packageName}
+    driver-class-name: org.h2.Driver
+    username: sa
+    password:
+  jpa:
+    hibernate:
+      ddl-auto: create-drop
+    show-sql: false
+    properties:
+      hibernate:
+        format_sql: true
+` : "";
+  const liquibaseConfig = hasLiquibase ? `
+  liquibase:
+    change-log: classpath:db/changelog/db.changelog-master.xml
+` : "";
+  writeTemplate(projectDir, "src/main/resources/application.yml", `server:
+  port: 8080
+${datasourceConfig}${liquibaseConfig}
+logging:
+  level:
+    root: INFO
+    ${ctx.packageName}: DEBUG
+`);
+  if (hasLiquibase) {
+    ensureDir2(path7.join(projectDir, "src/main/resources/db/changelog"));
+    writeTemplate(projectDir, "src/main/resources/db/changelog/db.changelog-master.xml", `<?xml version="1.0" encoding="UTF-8"?>
+<databaseChangeLog
+  xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
+  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog
+    http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-latest.xsd">
+
+  <changeSet id="001" author="deepstorm">
+    <createTable tableName="flyway_schema_history">
+      <column name="version" type="VARCHAR(50)"/>
+    </createTable>
+  </changeSet>
+</databaseChangeLog>
+`);
+  }
+  const testDir = `src/test/java/${appPackage.replace(/\./g, "/")}`;
+  ensureDir2(path7.join(projectDir, testDir));
+  ensureDir2(path7.join(projectDir, "src/test/resources"));
+  writeTemplate(projectDir, `${testDir}/ApplicationTests.java`, `package ${appPackage};
+
+import org.junit.jupiter.api.Test;
+import org.springframework.boot.test.context.SpringBootTest;
+
+@SpringBootTest
+class ApplicationTests {
+
+  @Test
+  void contextLoads() {
+  }
+}
+`);
+  writeTemplate(projectDir, "src/test/resources/junit-platform.properties", `junit.jupiter.testinstance.lifecycle.default = per_class
+`);
+  ensureDir2(path7.join(projectDir, "gradle/wrapper"));
+  writeTemplate(projectDir, "gradle/wrapper/gradle-wrapper.properties", `distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\\://services.gradle.org/distributions/gradle-8.12-bin.zip
+networkTimeout=10000
+validateDistributionUrl=true
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists
+`);
+  writeTemplate(projectDir, "gradlew", `#!/bin/sh
+
+#
+# Gradle start up script for POSIX generated by Gradle.
+#
+
+# Attempt to set APP_HOME
+PRG="$0"
+while [ -h "$PRG" ] ; do
+  ls=$(ls -ld "$PRG")
+  link=$(expr "$ls" : '.*-> \\(.*\\)$')
+  if expr "$link" : '/.*' > /dev/null; then
+    PRG="$link"
+  else
+    PRG=$(dirname "$PRG")/"$link"
+  fi
+done
+SAVED="$(pwd)"
+cd "$(dirname "$PRG")/" >/dev/null
+APP_HOME="$(pwd -P)"
+cd "$SAVED" >/dev/null
+
+APP_NAME="Gradle"
+APP_BASE_NAME=$(basename "$0")
+
+MAX_FD="maximum"
+
+warn () {
+  echo "$*"
+} >&2
+
+die () {
+  echo
+  echo "$*"
+  echo
+  exit 1
+} >&2
+
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+  if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+    JAVACMD="$JAVA_HOME/jre/sh/java"
+  else
+    JAVACMD="$JAVA_HOME/bin/java"
+  fi
+  if [ ! -x "$JAVACMD" ] ; then
+    die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME"
+  fi
+else
+  JAVACMD="java"
+  which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH."
+fi
+
+exec "$JAVACMD" $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS -classpath "$CLASSPATH" org.gradle.wrapper.GradleWrapperMain "$@"
+`);
+  writeTemplate(projectDir, "gradlew.bat", `@rem
+@rem Gradle startup script for Windows
+@rem
+@if "%DEBUG%"=="" @echo off
+@rem Set local scope for the variables
+setlocal enabledelayedexpansion
+set APP_BASE_NAME=%~n0
+set APP_HOME=%CD%
+set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
+set CLASSPATH=%APP_HOME%/gradle/wrapper/gradle-wrapper.jar
+"%JAVA_HOME%/bin/java.exe" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
+:end
+@endlocal & exit /b %ERRORLEVEL%
+`);
+}
+function renderCommonFiles(projectDir, ctx) {
+  writeTemplate(projectDir, ".gitignore", `node_modules/
+.gradle/
+build/
+target/
+dist/
+.env
+*.log
+.DS_Store
+__pycache__/
+*.pyc
+.idea/
+.vscode/
+*.iml
+`);
+  writeTemplate(projectDir, ".env.example", `# \u6570\u636E\u5E93\u914D\u7F6E
+DB_URL=jdbc:postgresql://localhost:5432/${ctx.packageName}
+DB_USERNAME=postgres
+DB_PASSWORD=change-me
+
+# API Keys
+OPENAI_API_KEY=sk-your-key-here
+`);
+  const readme = generateReadme(ctx);
+  writeTemplate(projectDir, "README.md", readme);
+}
+function generateReadme(ctx) {
+  const lines = [];
+  lines.push(`# ${ctx.projectName}`, "");
+  lines.push("## \u6280\u672F\u6808", "");
+  if (ctx.frontend) lines.push("- **\u524D\u7AEF\uFF1A** Angular + TypeScript");
+  if (ctx.backend) lines.push("- **\u540E\u7AEF\uFF1A** Java 21 + Spring Boot 3.x + Gradle");
+  lines.push("");
+  lines.push("## \u5FEB\u901F\u5F00\u59CB", "");
+  if (ctx.frontend) {
+    lines.push("### \u524D\u7AEF", "");
+    lines.push("```bash");
+    lines.push("pnpm install");
+    lines.push("pnpm start");
+    lines.push("```", "");
+  }
+  if (ctx.backend) {
+    lines.push("### \u540E\u7AEF", "");
+    lines.push("```bash");
+    lines.push("./gradlew build");
+    lines.push("./gradlew bootRun");
+    lines.push("```", "");
+  }
+  lines.push("## \u9879\u76EE\u7ED3\u6784", "");
+  lines.push("```");
+  if (ctx.frontend && ctx.backend) {
+    lines.push("\u251C\u2500\u2500 src/main/web/          # Angular \u524D\u7AEF");
+    lines.push("\u251C\u2500\u2500 src/main/java/         # Java \u540E\u7AEF");
+    lines.push("\u251C\u2500\u2500 src/main/resources/    # \u914D\u7F6E");
+    lines.push("\u251C\u2500\u2500 build.gradle.kts       # Gradle \u6784\u5EFA");
+    lines.push("\u2514\u2500\u2500 angular.json           # Angular \u914D\u7F6E");
+  } else if (ctx.frontend) {
+    lines.push("\u251C\u2500\u2500 src/main/web/          # Angular \u524D\u7AEF");
+    lines.push("\u2514\u2500\u2500 angular.json           # Angular \u914D\u7F6E");
+  } else if (ctx.backend) {
+    lines.push("\u251C\u2500\u2500 src/main/java/         # Java \u540E\u7AEF");
+    lines.push("\u2514\u2500\u2500 build.gradle.kts       # Gradle \u6784\u5EFA");
+  }
+  lines.push("```", "");
+  return lines.join("\n");
+}
+function ensureDir2(dir) {
+  if (!fs11.existsSync(dir)) {
+    fs11.mkdirSync(dir, { recursive: true });
+  }
+}
+function writeTemplate(baseDir, relativePath, content) {
+  const fullPath = path7.join(baseDir, relativePath);
+  ensureDir2(path7.dirname(fullPath));
+  fs11.writeFileSync(fullPath, content, "utf-8");
+}
+function printProjectTree(projectDir, hasFrontend, hasBackend) {
+  console.log("\u76EE\u5F55\u7ED3\u6784:");
+  console.log(`  ${path7.basename(projectDir)}/`);
+  if (hasFrontend && hasBackend) {
+    console.log("  \u251C\u2500\u2500 src/");
+    console.log("  \u2502   \u251C\u2500\u2500 main/");
+    console.log("  \u2502   \u2502   \u251C\u2500\u2500 web/          # Angular \u524D\u7AEF");
+    console.log("  \u2502   \u2502   \u251C\u2500\u2500 java/         # Java \u540E\u7AEF");
+    console.log("  \u2502   \u2502   \u2514\u2500\u2500 resources/    # \u914D\u7F6E");
+    console.log("  \u2502   \u2514\u2500\u2500 test/");
+    console.log("  \u2502       \u251C\u2500\u2500 java/");
+    console.log("  \u2502       \u2514\u2500\u2500 resources/");
+    console.log("  \u251C\u2500\u2500 build.gradle.kts");
+    console.log("  \u251C\u2500\u2500 angular.json");
+    console.log("  \u2514\u2500\u2500 package.json");
+  } else if (hasFrontend) {
+    console.log("  \u251C\u2500\u2500 src/main/web/         # Angular \u524D\u7AEF");
+    console.log("  \u251C\u2500\u2500 angular.json");
+    console.log("  \u2514\u2500\u2500 package.json");
+  } else if (hasBackend) {
+    console.log("  \u251C\u2500\u2500 src/");
+    console.log("  \u2502   \u251C\u2500\u2500 main/java/");
+    console.log("  \u2502   \u251C\u2500\u2500 main/resources/");
+    console.log("  \u2502   \u251C\u2500\u2500 test/java/");
+    console.log("  \u2502   \u2514\u2500\u2500 test/resources/");
+    console.log("  \u251C\u2500\u2500 build.gradle.kts");
+    console.log("  \u2514\u2500\u2500 settings.gradle.kts");
+  }
+}
+
 // src/commands/plugin-build.ts
-var fs12 = __toESM(require("node:fs"));
-var path8 = __toESM(require("node:path"));
+var fs13 = __toESM(require("node:fs"));
+var path9 = __toESM(require("node:path"));
 
 // src/engine/plugin-builder.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"));
 async function buildPlugin(config) {
   const { marketplaceName, tools, selectedMcpTools, cliDir: cliDir2, targetDir } = config;
-  const outputDir = path7.join(targetDir, ".deepstorm");
-  if (fs11.existsSync(outputDir)) {
-    fs11.rmSync(outputDir, { recursive: true, force: true });
+  const outputDir = path8.join(targetDir, ".deepstorm");
+  if (fs12.existsSync(outputDir)) {
+    fs12.rmSync(outputDir, { recursive: true, force: true });
   }
-  fs11.mkdirSync(outputDir, { recursive: true });
+  fs12.mkdirSync(outputDir, { recursive: true });
   const rootPkgMeta = readRootPackageJson(targetDir);
-  const claudePluginDir = path7.join(outputDir, ".claude-plugin");
-  fs11.mkdirSync(claudePluginDir, { recursive: true });
+  const claudePluginDir = path8.join(outputDir, ".claude-plugin");
+  fs12.mkdirSync(claudePluginDir, { recursive: true });
   const pluginJson = {
     name: "deepstorm",
     description: rootPkgMeta.description,
@@ -7474,7 +8266,7 @@ async function buildPlugin(config) {
     license: "MIT",
     keywords: ["deepstorm", "ai", "software-engineering", ...tools]
   };
-  fs11.writeFileSync(path7.join(claudePluginDir, "plugin.json"), JSON.stringify(pluginJson, null, 2), "utf-8");
+  fs12.writeFileSync(path8.join(claudePluginDir, "plugin.json"), JSON.stringify(pluginJson, null, 2), "utf-8");
   const marketplaceJson = {
     name: marketplaceName,
     description: "DeepStorm Claude Code \u63D2\u4EF6",
@@ -7488,11 +8280,11 @@ async function buildPlugin(config) {
       }
     ]
   };
-  fs11.writeFileSync(path7.join(claudePluginDir, "marketplace.json"), JSON.stringify(marketplaceJson, null, 2), "utf-8");
+  fs12.writeFileSync(path8.join(claudePluginDir, "marketplace.json"), JSON.stringify(marketplaceJson, null, 2), "utf-8");
   const settingsJson = {
     enabledMcpjsonServers: selectedMcpTools
   };
-  fs11.writeFileSync(path7.join(outputDir, "settings.json"), JSON.stringify(settingsJson, null, 2), "utf-8");
+  fs12.writeFileSync(path8.join(outputDir, "settings.json"), JSON.stringify(settingsJson, null, 2), "utf-8");
   if (selectedMcpTools.length > 0) {
     const mcpServers = {};
     for (const mcpName of selectedMcpTools) {
@@ -7502,46 +8294,46 @@ async function buildPlugin(config) {
       }
     }
     if (Object.keys(mcpServers).length > 0) {
-      fs11.writeFileSync(
-        path7.join(outputDir, ".mcp.json"),
+      fs12.writeFileSync(
+        path8.join(outputDir, ".mcp.json"),
         JSON.stringify({ mcpServers }, null, 2) + "\n",
         "utf-8"
       );
     }
   }
   if (selectedMcpTools.length > 0) {
-    const envPath = path7.join(outputDir, ".env.example");
+    const envPath = path8.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",
       ""
     ];
     for (const mcpName of selectedMcpTools) {
-      const envExampleFile = path7.join(cliDir2, "env-examples", `${mcpName}.env-example`);
-      if (fs11.existsSync(envExampleFile)) {
-        const content = fs11.readFileSync(envExampleFile, "utf-8");
+      const envExampleFile = path8.join(cliDir2, "env-examples", `${mcpName}.env-example`);
+      if (fs12.existsSync(envExampleFile)) {
+        const content = fs12.readFileSync(envExampleFile, "utf-8");
         envLines.push(`# ${mcpName}`);
         envLines.push(content);
         envLines.push("");
       }
     }
-    fs11.writeFileSync(envPath, envLines.join("\n"), "utf-8");
+    fs12.writeFileSync(envPath, envLines.join("\n"), "utf-8");
   }
-  const readmeContent = generateReadme(marketplaceName, tools, selectedMcpTools, rootPkgMeta.version);
-  fs11.writeFileSync(path7.join(outputDir, "README.md"), readmeContent, "utf-8");
+  const readmeContent = generateReadme2(marketplaceName, tools, selectedMcpTools, rootPkgMeta.version);
+  fs12.writeFileSync(path8.join(outputDir, "README.md"), readmeContent, "utf-8");
   const changelogContent = `# Changelog
 
 ## v${rootPkgMeta.version}
 
 - \u9996\u6B21\u6784\u5EFA DeepStorm Plugin
 `;
-  fs11.writeFileSync(path7.join(outputDir, "CHANGELOG.md"), changelogContent, "utf-8");
+  fs12.writeFileSync(path8.join(outputDir, "CHANGELOG.md"), changelogContent, "utf-8");
   return outputDir;
 }
 function readRootPackageJson(targetDir) {
-  const pkgPath = path7.join(targetDir, "package.json");
+  const pkgPath = path8.join(targetDir, "package.json");
   try {
-    const pkg = JSON.parse(fs11.readFileSync(pkgPath, "utf-8"));
+    const pkg = JSON.parse(fs12.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"
@@ -7553,7 +8345,7 @@ function readRootPackageJson(targetDir) {
     };
   }
 }
-function generateReadme(marketplaceName, tools, selectedMcpTools, version) {
+function generateReadme2(marketplaceName, tools, selectedMcpTools, version) {
   const lines = [
     `# DeepStorm Plugin (${marketplaceName})`,
     "",
@@ -7593,16 +8385,16 @@ function generateReadme(marketplaceName, tools, selectedMcpTools, version) {
   return lines.join("\n");
 }
 function readMcpServerConfig(cliDir2, mcpName) {
-  const mcpDir = path7.join(cliDir2, "mcp");
-  if (!fs11.existsSync(mcpDir)) return null;
-  const entries = fs11.readdirSync(mcpDir, { withFileTypes: true });
+  const mcpDir = path8.join(cliDir2, "mcp");
+  if (!fs12.existsSync(mcpDir)) return null;
+  const entries = fs12.readdirSync(mcpDir, { withFileTypes: true });
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    const domainDir = path7.join(mcpDir, entry.name);
-    const files = fs11.readdirSync(domainDir).filter((f) => f.endsWith(".json"));
+    const domainDir = path8.join(mcpDir, entry.name);
+    const files = fs12.readdirSync(domainDir).filter((f) => f.endsWith(".json"));
     for (const file of files) {
       try {
-        const content = JSON.parse(fs11.readFileSync(path7.join(domainDir, file), "utf-8"));
+        const content = JSON.parse(fs12.readFileSync(path8.join(domainDir, file), "utf-8"));
         if (content.name === mcpName && content.mcpServers) {
           const servers = content.mcpServers;
           const keys = Object.keys(servers);
@@ -7698,27 +8490,27 @@ function registerPluginBuildCommand(program2, registry2) {
   });
 }
 function updatePluginJsonHooks(pluginDir) {
-  const hooksDir = path8.join(pluginDir, "hooks");
-  const pluginJsonPath = path8.join(pluginDir, ".claude-plugin", "plugin.json");
-  if (!fs12.existsSync(hooksDir) || !fs12.existsSync(pluginJsonPath)) return;
+  const hooksDir = path9.join(pluginDir, "hooks");
+  const pluginJsonPath = path9.join(pluginDir, ".claude-plugin", "plugin.json");
+  if (!fs13.existsSync(hooksDir) || !fs13.existsSync(pluginJsonPath)) return;
   try {
-    const pluginJson = JSON.parse(fs12.readFileSync(pluginJsonPath, "utf-8"));
+    const pluginJson = JSON.parse(fs13.readFileSync(pluginJsonPath, "utf-8"));
     pluginJson.hooks = "./hooks/deepstorm-hooks.json";
-    fs12.writeFileSync(pluginJsonPath, JSON.stringify(pluginJson, null, 2) + "\n", "utf-8");
+    fs13.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 = path8.join(targetDir, ".gitignore");
+  const gitIgnorePath = path9.join(targetDir, ".gitignore");
   const line = ".deepstorm/";
   try {
-    if (fs12.existsSync(gitIgnorePath)) {
-      const content = fs12.readFileSync(gitIgnorePath, "utf-8");
+    if (fs13.existsSync(gitIgnorePath)) {
+      const content = fs13.readFileSync(gitIgnorePath, "utf-8");
       if (content.includes(line)) return;
-      fs12.writeFileSync(gitIgnorePath, content.trimEnd() + "\n" + line + "\n", "utf-8");
+      fs13.writeFileSync(gitIgnorePath, content.trimEnd() + "\n" + line + "\n", "utf-8");
     } else {
-      fs12.writeFileSync(gitIgnorePath, line + "\n", "utf-8");
+      fs13.writeFileSync(gitIgnorePath, line + "\n", "utf-8");
     }
     console.log("\u2714 .gitignore \u5DF2\u6DFB\u52A0 .deepstorm/ \u5FFD\u7565\u89C4\u5219");
   } catch {
@@ -7726,27 +8518,27 @@ function ensureGitIgnore(targetDir) {
 }
 function mergePluginHooks(tools, reader, pluginDir, packagesDir) {
   if (!tools.some((tool) => reader.getToolHooks(tool).length > 0)) return;
-  const pkgsDir = packagesDir ?? path8.resolve(process.cwd(), "packages");
-  const pluginHooksDir = path8.join(pluginDir, "hooks");
-  const destHooksJson = path8.join(pluginHooksDir, "deepstorm-hooks.json");
+  const pkgsDir = packagesDir ?? path9.resolve(process.cwd(), "packages");
+  const pluginHooksDir = path9.join(pluginDir, "hooks");
+  const destHooksJson = path9.join(pluginHooksDir, "deepstorm-hooks.json");
   for (const tool of tools) {
-    const srcPath = path8.join(pkgsDir, tool, "hooks", "hooks.json");
-    if (fs12.existsSync(srcPath)) {
-      fs12.mkdirSync(pluginHooksDir, { recursive: true });
-      const incoming = JSON.parse(fs12.readFileSync(srcPath, "utf-8"));
+    const srcPath = path9.join(pkgsDir, tool, "hooks", "hooks.json");
+    if (fs13.existsSync(srcPath)) {
+      fs13.mkdirSync(pluginHooksDir, { recursive: true });
+      const incoming = JSON.parse(fs13.readFileSync(srcPath, "utf-8"));
       mergeHooks(destHooksJson, incoming);
     }
   }
 }
 
 // src/commands/config.ts
-var path14 = __toESM(require("node:path"));
+var path15 = __toESM(require("node:path"));
 var import_prompts2 = require("@clack/prompts");
 
 // src/commands/config-view.ts
-var path9 = __toESM(require("node:path"));
+var path10 = __toESM(require("node:path"));
 function viewConfig(targetDir) {
-  const settingsPath = path9.join(targetDir, ".claude", "settings.json");
+  const settingsPath = path10.join(targetDir, ".claude", "settings.json");
   const deepstorm = readDeepStormConfig(settingsPath);
   if (!deepstorm) {
     console.log("\u5C1A\u672A\u914D\u7F6E DeepStorm\uFF0C\u8BF7\u8FD0\u884C deepstorm setup");
@@ -7757,24 +8549,24 @@ function viewConfig(targetDir) {
 }
 
 // src/commands/config-set.ts
-var fs14 = __toESM(require("node:fs"));
-var path11 = __toESM(require("node:path"));
+var fs15 = __toESM(require("node:fs"));
+var path12 = __toESM(require("node:path"));
 var p6 = __toESM(require("@clack/prompts"));
 
 // src/utils/config-schema.ts
-var fs13 = __toESM(require("node:fs"));
-var path10 = __toESM(require("node:path"));
+var fs14 = __toESM(require("node:fs"));
+var path11 = __toESM(require("node:path"));
 function loadValidConfigKeys() {
   const candidates = [
-    path10.resolve(__dirname, "config-schema.json"),
-    path10.resolve(__dirname, "..", "config-schema.json"),
-    path10.resolve(process.cwd(), "config-schema.json"),
-    path10.resolve(process.cwd(), "packages", "cli", "config-schema.json")
+    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")
   ];
   for (const schemaPath of candidates) {
     try {
-      if (!fs13.existsSync(schemaPath)) continue;
-      const schema = JSON.parse(fs13.readFileSync(schemaPath, "utf-8"));
+      if (!fs14.existsSync(schemaPath)) continue;
+      const schema = JSON.parse(fs14.readFileSync(schemaPath, "utf-8"));
       const keys = /* @__PURE__ */ new Set();
       collectLeafPaths(schema.properties, "", keys);
       return keys;
@@ -7809,12 +8601,12 @@ async function setConfigValue(targetDir, key, value, registry2) {
   if (!validateConfigKey(key)) {
     return;
   }
-  const settingsPath = path11.join(targetDir, ".claude", "settings.json");
+  const settingsPath = path12.join(targetDir, ".claude", "settings.json");
   readDeepStormConfig(settingsPath);
   let settings = {};
-  if (fs14.existsSync(settingsPath)) {
+  if (fs15.existsSync(settingsPath)) {
     try {
-      settings = JSON.parse(fs14.readFileSync(settingsPath, "utf-8"));
+      settings = JSON.parse(fs15.readFileSync(settingsPath, "utf-8"));
     } catch {
       settings = {};
     }
@@ -7852,7 +8644,7 @@ async function setConfigValue(targetDir, key, value, registry2) {
     writePointer = writePointer[parts[i]];
   }
   writePointer[parts[parts.length - 1]] = value;
-  fs14.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
+  fs15.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
   console.log(`\u2714 ${key} \u5DF2\u66F4\u65B0\u4E3A ${value}`);
   const affected = findAffectedTemplates(registry2, key);
   if (affected.length === 0) {
@@ -7890,8 +8682,8 @@ async function setConfigValue(targetDir, key, value, registry2) {
   const templateVariables = buildTemplateVariables(registry2, fullConfig, installedMcpServers);
   let renderCount = 0;
   for (const tmplRelPath of affected) {
-    const tmplPath = path11.join(cliDir, tmplRelPath);
-    if (!fs14.existsSync(tmplPath)) {
+    const tmplPath = path12.join(cliDir, tmplRelPath);
+    if (!fs15.existsSync(tmplPath)) {
       console.warn(`  \u26A0 \u6A21\u677F\u6587\u4EF6\u4E0D\u5B58\u5728: ${tmplRelPath}\uFF0C\u8DF3\u8FC7`);
       continue;
     }
@@ -7899,12 +8691,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 = path11.join(targetDir, ".claude", assetType, assetName);
+    const targetDirPath = path12.join(targetDir, ".claude", assetType, assetName);
     ensureDir(targetDirPath);
-    const outputPath = path11.join(targetDirPath, outputFile);
+    const outputPath = path12.join(targetDirPath, outputFile);
     renderTemplate(tmplPath, templateVariables, outputPath);
-    const variantsDir = path11.join(cliDir, assetType, assetName, "variants");
-    if (fs14.existsSync(variantsDir)) {
+    const variantsDir = path12.join(cliDir, assetType, assetName, "variants");
+    if (fs15.existsSync(variantsDir)) {
       copyVariants(variantsDir, value, targetDirPath, true);
     }
     renderCount++;
@@ -7914,33 +8706,33 @@ async function setConfigValue(targetDir, key, value, registry2) {
 }
 
 // src/commands/config-reset.ts
-var fs15 = __toESM(require("node:fs"));
-var path12 = __toESM(require("node:path"));
+var fs16 = __toESM(require("node:fs"));
+var path13 = __toESM(require("node:path"));
 function resetConfig(targetDir) {
-  const settingsPath = path12.join(targetDir, ".claude", "settings.json");
-  if (!fs15.existsSync(settingsPath)) return;
+  const settingsPath = path13.join(targetDir, ".claude", "settings.json");
+  if (!fs16.existsSync(settingsPath)) return;
   try {
-    const settings = JSON.parse(fs15.readFileSync(settingsPath, "utf-8"));
+    const settings = JSON.parse(fs16.readFileSync(settingsPath, "utf-8"));
     if (!settings.deepstorm) return;
     delete settings.deepstorm;
-    fs15.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
+    fs16.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
   } catch {
   }
 }
 
 // src/commands/config-refresh.ts
-var fs16 = __toESM(require("node:fs"));
-var path13 = __toESM(require("node:path"));
+var fs17 = __toESM(require("node:fs"));
+var path14 = __toESM(require("node:path"));
 function refreshConfig(cliDir2, targetDotClaudeDir, registry2) {
   const result = { refreshed: [], errors: [] };
-  const settingsPath = path13.join(targetDotClaudeDir, "settings.json");
-  if (!fs16.existsSync(settingsPath)) {
+  const settingsPath = path14.join(targetDotClaudeDir, "settings.json");
+  if (!fs17.existsSync(settingsPath)) {
     return result;
   }
   readDeepStormConfig(settingsPath);
   let settings;
   try {
-    settings = JSON.parse(fs16.readFileSync(settingsPath, "utf-8"));
+    settings = JSON.parse(fs17.readFileSync(settingsPath, "utf-8"));
   } catch {
     return result;
   }
@@ -7950,10 +8742,10 @@ function refreshConfig(cliDir2, targetDotClaudeDir, registry2) {
   const installedMcpServers = deepstorm.installedMcpServers ?? [];
   if (installedSkills.length === 0) return result;
   for (const skillId of installedSkills) {
-    const tmplPath = path13.join(cliDir2, "skills", skillId, "SKILL.md.tmpl");
-    if (!fs16.existsSync(tmplPath)) continue;
-    const targetSkillDir = path13.join(targetDotClaudeDir, "skills", skillId);
-    const outputPath = path13.join(targetSkillDir, "SKILL.md");
+    const tmplPath = path14.join(cliDir2, "skills", skillId, "SKILL.md.tmpl");
+    if (!fs17.existsSync(tmplPath)) continue;
+    const targetSkillDir = path14.join(targetDotClaudeDir, "skills", skillId);
+    const outputPath = path14.join(targetSkillDir, "SKILL.md");
     try {
       const enrichedVars = injectSkillCapabilities(
         tmplPath,
@@ -7961,7 +8753,7 @@ function refreshConfig(cliDir2, targetDotClaudeDir, registry2) {
         installedMcpServers,
         registry2.mcpTools ?? {}
       );
-      fs16.mkdirSync(targetSkillDir, { recursive: true });
+      fs17.mkdirSync(targetSkillDir, { recursive: true });
       renderTemplate(tmplPath, enrichedVars, outputPath);
       result.refreshed.push(skillId);
     } catch (err) {
@@ -7978,14 +8770,14 @@ function refreshConfig(cliDir2, targetDotClaudeDir, registry2) {
 }
 function buildUnifiedMcpCapabilities2(cliDir2, installedMcpTools, mcpTools) {
   const allDeclarations = {};
-  const skillsDir = path13.join(cliDir2, "skills");
-  if (!fs16.existsSync(skillsDir)) return {};
-  const skillDirs = fs16.readdirSync(skillsDir, { withFileTypes: true });
+  const skillsDir = path14.join(cliDir2, "skills");
+  if (!fs17.existsSync(skillsDir)) return {};
+  const skillDirs = fs17.readdirSync(skillsDir, { withFileTypes: true });
   for (const entry of skillDirs) {
     if (!entry.isDirectory()) continue;
-    const tmplPath = path13.join(skillsDir, entry.name, "SKILL.md.tmpl");
-    if (!fs16.existsSync(tmplPath)) continue;
-    const content = fs16.readFileSync(tmplPath, "utf-8");
+    const tmplPath = path14.join(skillsDir, entry.name, "SKILL.md.tmpl");
+    if (!fs17.existsSync(tmplPath)) continue;
+    const content = fs17.readFileSync(tmplPath, "utf-8");
     const fm = parseFrontmatter(content);
     if (!fm) continue;
     const mcpCap = fm.mcpCapabilities;
@@ -8028,7 +8820,7 @@ function registerConfigCommand(program2, registry2) {
   });
   configCmd.command("refresh").description("\u6839\u636E\u6700\u65B0 MCP \u5B89\u88C5\u72B6\u6001\uFF0C\u5237\u65B0\u6240\u6709\u5DF2\u5B89\u88C5 skill \u7684\u6A21\u677F\u6E32\u67D3").action(() => {
     const targetDir = process.cwd();
-    const dotClaudeDir = path14.join(targetDir, ".claude");
+    const dotClaudeDir = path15.join(targetDir, ".claude");
     const cliDir2 = __dirname;
     const result = refreshConfig(cliDir2, dotClaudeDir, registry2);
     if (result.errors.length > 0) {
@@ -8069,17 +8861,17 @@ function listTemplates(registry2, tool) {
 }
 
 // src/commands/template-init.ts
-var fs17 = __toESM(require("node:fs"));
-var path15 = __toESM(require("node:path"));
+var fs18 = __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 (!fs17.existsSync(srcDir)) {
+  const srcDir = path16.join(cliDir2, "skills", skillId);
+  const destDir = path16.join(targetDir, ".deepstorm", "templates", skillId);
+  if (!fs18.existsSync(srcDir)) {
     console.log(`\u6A21\u677F\u4E0D\u5B58\u5728\uFF1A${skillId}`);
     return;
   }
-  if (fs17.existsSync(destDir)) {
+  if (fs18.existsSync(destDir)) {
     const shouldOverwrite = await (0, import_prompts3.confirm)({
       message: `\u6A21\u677F ${skillId} \u5DF2\u5B58\u5728\uFF0C\u662F\u5426\u8986\u76D6\uFF1F`,
       initialValue: false
@@ -8088,21 +8880,21 @@ async function initTemplate(cliDir2, targetDir, skillId) {
       console.log("\u5DF2\u53D6\u6D88");
       return;
     }
-    fs17.rmSync(destDir, { recursive: true, force: true });
+    fs18.rmSync(destDir, { recursive: true, force: true });
   }
-  ensureDir(path15.dirname(destDir));
+  ensureDir(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 fs18 = __toESM(require("node:fs"));
-var path16 = __toESM(require("node:path"));
+var fs19 = __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 (!fs18.existsSync(srcDir)) {
+  const srcDir = path17.join(targetDir, ".deepstorm", "templates", skillId);
+  const destDir = path17.join(targetDir, ".claude", "skills", skillId);
+  if (!fs19.existsSync(srcDir)) {
     console.log(`\u6A21\u677F\u4E0D\u5B58\u5728\uFF0C\u8BF7\u5148\u8FD0\u884C deepstorm template init ${skillId}`);
     return;
   }
@@ -8136,22 +8928,22 @@ function registerTemplateCommand(program2, registry2) {
 }
 
 // src/commands/update.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"));
 var import_node_child_process = require("node:child_process");
 
 // src/utils/version.ts
-var fs19 = __toESM(require("node:fs"));
-var path17 = __toESM(require("node:path"));
+var fs20 = __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 (fs19.existsSync(pkgPath)) {
-        const pkg = JSON.parse(fs19.readFileSync(pkgPath, "utf-8"));
+      if (fs20.existsSync(pkgPath)) {
+        const pkg = JSON.parse(fs20.readFileSync(pkgPath, "utf-8"));
         return pkg.version || "0.0.0";
       }
     }
@@ -8162,14 +8954,14 @@ function getCliVersion() {
 }
 
 // src/commands/template-upgrade.ts
-var fs20 = __toESM(require("node:fs"));
-var path18 = __toESM(require("node:path"));
+var fs21 = __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 (!fs20.existsSync(filePath)) return null;
-    const content = fs20.readFileSync(filePath);
+    if (!fs21.existsSync(filePath)) return null;
+    const content = fs21.readFileSync(filePath);
     return crypto.createHash("sha256").update(content).digest("hex");
   } catch {
     return null;
@@ -8177,15 +8969,15 @@ function computeFileChecksum(filePath) {
 }
 function computeDirChecksums(dirPath, relativeTo = dirPath) {
   const result = {};
-  if (!fs20.existsSync(dirPath)) return result;
+  if (!fs21.existsSync(dirPath)) return result;
   function walk(current) {
-    for (const entry of fs20.readdirSync(current, { withFileTypes: true })) {
-      const fullPath = path18.join(current, entry.name);
+    for (const entry of fs21.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;
       }
@@ -8195,32 +8987,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(fs20.readFileSync(filePath, "utf-8"));
+    return JSON.parse(fs21.readFileSync(filePath, "utf-8"));
   } catch {
     return {};
   }
 }
 function saveChecksums(targetDir, checksums) {
-  const dir = path18.join(targetDir, ".claude");
+  const dir = path19.join(targetDir, ".claude");
   ensureDir(dir);
-  fs20.writeFileSync(
-    path18.join(dir, CHECKSUM_FILE),
+  fs21.writeFileSync(
+    path19.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);
+    if (!fs21.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);
-    fs20.cpSync(filePath, bakPath, { force: true });
+    const bakPath = path19.join(dir, bakName);
+    fs21.cpSync(filePath, bakPath, { force: true });
     return bakName;
   } catch {
     return null;
@@ -8241,19 +9033,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 (!fs20.existsSync(skillDir)) continue;
+    const skillDir = path19.join(targetDir, ".claude", "skills", skillId);
+    if (!fs21.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);
     }
@@ -8261,7 +9053,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);
     }
@@ -8272,7 +9064,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;
@@ -8282,7 +9074,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;
     }
@@ -8290,7 +9082,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;
     }
@@ -8321,9 +9113,9 @@ function detectToolsFromConfig(config, registry2) {
   return [...found];
 }
 function readSettingsConfig(targetDir) {
-  const settingsPath = path18.join(targetDir, ".claude", "settings.json");
+  const settingsPath = path19.join(targetDir, ".claude", "settings.json");
   try {
-    const raw = fs20.readFileSync(settingsPath, "utf-8");
+    const raw = fs21.readFileSync(settingsPath, "utf-8");
     const settings = JSON.parse(raw);
     const deepstorm = settings.deepstorm || {};
     const metaKeys = /* @__PURE__ */ new Set([
@@ -8352,22 +9144,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 = fs20.readFileSync(registryPath, "utf-8");
+    const raw = fs21.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 (fs20.existsSync(toolHooksJsonPath)) {
-      ensureDir(path18.join(targetDir, ".claude"));
-      const incoming = JSON.parse(fs20.readFileSync(toolHooksJsonPath, "utf-8"));
+    const toolHooksJsonPath = path19.join(hooksSrcDir, `${tool}-hooks.json`);
+    if (fs21.existsSync(toolHooksJsonPath)) {
+      ensureDir(path19.join(targetDir, ".claude"));
+      const incoming = JSON.parse(fs21.readFileSync(toolHooksJsonPath, "utf-8"));
       mergeHooks(destHooksJson, incoming);
     }
   }
@@ -8485,8 +9277,8 @@ function readLocalRegistryFile(url) {
     filePath = filePath.slice(7);
   }
   try {
-    if (fs21.existsSync(filePath)) {
-      return JSON.parse(fs21.readFileSync(filePath, "utf-8"));
+    if (fs22.existsSync(filePath)) {
+      return JSON.parse(fs22.readFileSync(filePath, "utf-8"));
     }
   } catch {
   }
@@ -8568,9 +9360,9 @@ async function updateCLI(fetchFn) {
   return result;
 }
 function getInstalledSkillIds(targetDir) {
-  const settingsPath = path19.join(targetDir, ".claude", "settings.json");
+  const settingsPath = path20.join(targetDir, ".claude", "settings.json");
   try {
-    const raw = fs21.readFileSync(settingsPath, "utf-8");
+    const raw = fs22.readFileSync(settingsPath, "utf-8");
     const settings = JSON.parse(raw);
     return settings.deepstorm?.installedSkills ?? [];
   } catch {
@@ -8590,12 +9382,18 @@ function registerUpdateCommand(program2) {
   });
 }
 
+// src/commands/pilot.ts
+var import_pilot = require("@deepstorm/pilot");
+function registerPilotCommands(program2) {
+  (0, import_pilot.registerPilotCommands)(program2);
+}
+
 // src/commands/doctor.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"));
 function getInstalledSkills(settingsPath) {
   try {
-    const settings = JSON.parse(fs22.readFileSync(settingsPath, "utf-8"));
+    const settings = JSON.parse(fs23.readFileSync(settingsPath, "utf-8"));
     return settings.deepstorm?.installedSkills || [];
   } catch {
     return [];
@@ -8604,7 +9402,7 @@ function getInstalledSkills(settingsPath) {
 function runDoctor(targetDir) {
   const checks = [];
   const version = getCliVersion();
-  const settingsPath = path20.join(targetDir, ".claude", "settings.json");
+  const settingsPath = path21.join(targetDir, ".claude", "settings.json");
   readDeepStormConfig(settingsPath);
   checks.push({
     name: "CLI \u7248\u672C",
@@ -8612,7 +9410,7 @@ function runDoctor(targetDir) {
     message: `v${version}\uFF08\u8FD0\u884C deepstorm update --check \u68C0\u67E5\u6700\u65B0\u7248\u672C\uFF09`
   });
   let hasDeepStorm = false;
-  if (!fs22.existsSync(settingsPath)) {
+  if (!fs23.existsSync(settingsPath)) {
     checks.push({
       name: "\u914D\u7F6E\u6587\u4EF6",
       status: "warn",
@@ -8620,7 +9418,7 @@ function runDoctor(targetDir) {
     });
   } else {
     try {
-      const settings = JSON.parse(fs22.readFileSync(settingsPath, "utf-8"));
+      const settings = JSON.parse(fs23.readFileSync(settingsPath, "utf-8"));
       if (settings.deepstorm) {
         hasDeepStorm = true;
         checks.push({
@@ -8643,20 +9441,20 @@ function runDoctor(targetDir) {
       });
     }
   }
-  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()
+  const skillsDir = path21.join(targetDir, ".claude", "skills");
+  if (fs23.existsSync(skillsDir)) {
+    const skillDirs = fs23.readdirSync(skillsDir).filter(
+      (n) => fs23.statSync(path21.join(skillsDir, n)).isDirectory()
     );
     let validCount = 0;
     let invalidCount = 0;
     for (const skillName of skillDirs) {
-      const skillMd = path20.join(skillsDir, skillName, "SKILL.md");
-      if (!fs22.existsSync(skillMd)) {
+      const skillMd = path21.join(skillsDir, skillName, "SKILL.md");
+      if (!fs23.existsSync(skillMd)) {
         invalidCount++;
         continue;
       }
-      const content = fs22.readFileSync(skillMd, "utf-8");
+      const content = fs23.readFileSync(skillMd, "utf-8");
       const frontmatter = parseFrontmatter(content);
       if (frontmatter && frontmatter.name) {
         validCount++;
@@ -8686,7 +9484,7 @@ function runDoctor(targetDir) {
     const installedSkills = getInstalledSkills(settingsPath);
     const missingSkills = [];
     for (const skillId of installedSkills) {
-      if (!fs22.existsSync(path20.join(skillsDir, skillId))) {
+      if (!fs23.existsSync(path21.join(skillsDir, skillId))) {
         missingSkills.push(skillId);
       }
     }
@@ -8710,10 +9508,10 @@ function runDoctor(targetDir) {
       message: ".claude/skills/ \u4E0D\u5B58\u5728"
     });
   }
-  const mcpPath = path20.join(targetDir, ".mcp.json");
-  if (fs22.existsSync(mcpPath)) {
+  const mcpPath = path21.join(targetDir, ".mcp.json");
+  if (fs23.existsSync(mcpPath)) {
     try {
-      const mcp = JSON.parse(fs22.readFileSync(mcpPath, "utf-8"));
+      const mcp = JSON.parse(fs23.readFileSync(mcpPath, "utf-8"));
       const hasServers = mcp.mcpServers && Object.keys(mcp.mcpServers).length > 0;
       checks.push({
         name: "MCP \u670D\u52A1\u5668",
@@ -8734,12 +9532,12 @@ function runDoctor(targetDir) {
       message: ".mcp.json \u4E0D\u5B58\u5728"
     });
   }
-  if (hasDeepStorm && fs22.existsSync(settingsPath)) {
+  if (hasDeepStorm && fs23.existsSync(settingsPath)) {
     try {
-      const settings = JSON.parse(fs22.readFileSync(settingsPath, "utf-8"));
+      const settings = JSON.parse(fs23.readFileSync(settingsPath, "utf-8"));
       const installedMcp = settings.deepstorm?.installedMcpServers;
       if (installedMcp && installedMcp.length > 0) {
-        const mcpExists = fs22.existsSync(mcpPath);
+        const mcpExists = fs23.existsSync(mcpPath);
         if (!mcpExists) {
           checks.push({
             name: "MCP \u4E00\u81F4\u6027",
@@ -8748,7 +9546,7 @@ function runDoctor(targetDir) {
           });
         } else {
           try {
-            const mcpConfig = JSON.parse(fs22.readFileSync(mcpPath, "utf-8"));
+            const mcpConfig = JSON.parse(fs23.readFileSync(mcpPath, "utf-8"));
             const servers = mcpConfig.mcpServers || {};
             const missing = [];
             for (const toolName of installedMcp) {
@@ -8776,9 +9574,9 @@ function runDoctor(targetDir) {
     } catch {
     }
   }
-  if (hasDeepStorm && fs22.existsSync(settingsPath)) {
+  if (hasDeepStorm && fs23.existsSync(settingsPath)) {
     try {
-      const settings = JSON.parse(fs22.readFileSync(settingsPath, "utf-8"));
+      const settings = JSON.parse(fs23.readFileSync(settingsPath, "utf-8"));
       const config = settings.deepstorm;
       const validKeys = loadValidConfigKeys();
       if (validKeys.size > 0 && config) {
@@ -8832,18 +9630,18 @@ function printDoctorReport(report) {
 }
 
 // src/commands/uninstall.ts
-var fs23 = __toESM(require("node:fs"));
-var path21 = __toESM(require("node:path"));
+var fs24 = __toESM(require("node:fs"));
+var path22 = __toESM(require("node:path"));
 var import_prompts4 = require("@clack/prompts");
 async function uninstallDeepStorm(targetDir) {
-  const settingsPath = path21.join(targetDir, ".claude", "settings.json");
-  if (!fs23.existsSync(settingsPath)) {
+  const settingsPath = path22.join(targetDir, ".claude", "settings.json");
+  if (!fs24.existsSync(settingsPath)) {
     console.log("DeepStorm \u5C1A\u672A\u914D\u7F6E\uFF0C\u65E0\u9700\u5378\u8F7D");
     return;
   }
   let hasDeepStorm = false;
   try {
-    const settings = JSON.parse(fs23.readFileSync(settingsPath, "utf-8"));
+    const settings = JSON.parse(fs24.readFileSync(settingsPath, "utf-8"));
     hasDeepStorm = !!settings.deepstorm;
   } catch {
   }
@@ -8853,14 +9651,14 @@ async function uninstallDeepStorm(targetDir) {
   }
   cleanInstalled(targetDir);
   resetConfig(targetDir);
-  const templatesDir = path21.join(targetDir, ".deepstorm", "templates");
-  if (fs23.existsSync(templatesDir)) {
+  const templatesDir = path22.join(targetDir, ".deepstorm", "templates");
+  if (fs24.existsSync(templatesDir)) {
     const shouldDelete = await (0, import_prompts4.confirm)({
       message: "\u662F\u5426\u5220\u9664 .deepstorm/templates/ \u76EE\u5F55\uFF1F",
       initialValue: false
     });
     if (shouldDelete) {
-      fs23.rmSync(templatesDir, { recursive: true, force: true });
+      fs24.rmSync(templatesDir, { recursive: true, force: true });
       console.log("\u2714 .deepstorm/templates/ \u5DF2\u5220\u9664");
     } else {
       console.log("\u4FDD\u7559 .deepstorm/templates/");
@@ -8873,9 +9671,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 = path22.join(__dirname, "registry.json");
+  const registryPath = path23.join(__dirname, "registry.json");
   try {
-    const raw = fs24.readFileSync(registryPath, "utf-8");
+    const raw = fs25.readFileSync(registryPath, "utf-8");
     return JSON.parse(raw);
   } catch {
     return { version: "1", tools: {}, wizards: {}, skills: {} };
@@ -8883,10 +9681,12 @@ function loadRegistry() {
 }
 var registry = loadRegistry();
 registerSetupCommand(program, registry);
+registerInitCommand(program);
 registerPluginBuildCommand(program, registry);
 registerConfigCommand(program, registry);
 registerTemplateCommand(program, registry);
 registerUpdateCommand(program);
+registerPilotCommands(program);
 program.command("doctor").description("\u8BCA\u65AD\u9879\u76EE DeepStorm \u914D\u7F6E\u72B6\u6001").action(() => {
   const report = runDoctor(process.cwd());
   printDoctorReport(report);