@deepstorm/cli 0.10.2 → 0.11.1

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(path24) {
-          return /^\.|this\b/.test(path24.original);
+        scopedId: function scopedId(path26) {
+          return /^\.|this\b/.test(path26.original);
         },
         // an ID is simple if it only has one part, and that part is not
         // `..` or `this`.
-        simpleId: function simpleId(path24) {
-          return path24.parts.length === 1 && !AST.helpers.scopedId(path24) && !path24.depth;
+        simpleId: function simpleId(path26) {
+          return path26.parts.length === 1 && !AST.helpers.scopedId(path26) && !path26.depth;
         }
       }
     };
@@ -2263,12 +2263,12 @@ var require_helpers2 = __commonJS({
         loc
       };
     }
-    function prepareMustache(path24, params, hash, open, strip, locInfo) {
+    function prepareMustache(path26, 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: path24,
+        path: path26,
         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), path24 = decorator.path;
+        var params = this.setupFullMustacheParams(decorator, program2, void 0), path26 = decorator.path;
         this.useDecorators = true;
-        this.opcode("registerDecorator", params.length, path24.original);
+        this.opcode("registerDecorator", params.length, path26.original);
       },
       PartialStatement: function PartialStatement(partial) {
         this.usePartial = true;
@@ -2652,46 +2652,46 @@ var require_compiler = __commonJS({
         }
       },
       ambiguousSexpr: function ambiguousSexpr(sexpr, program2, inverse) {
-        var path24 = sexpr.path, name = path24.parts[0], isBlock = program2 != null || inverse != null;
-        this.opcode("getContext", path24.depth);
+        var path26 = sexpr.path, name = path26.parts[0], isBlock = program2 != null || inverse != null;
+        this.opcode("getContext", path26.depth);
         this.opcode("pushProgram", program2);
         this.opcode("pushProgram", inverse);
-        path24.strict = true;
-        this.accept(path24);
+        path26.strict = true;
+        this.accept(path26);
         this.opcode("invokeAmbiguous", name, isBlock);
       },
       simpleSexpr: function simpleSexpr(sexpr) {
-        var path24 = sexpr.path;
-        path24.strict = true;
-        this.accept(path24);
+        var path26 = sexpr.path;
+        path26.strict = true;
+        this.accept(path26);
         this.opcode("resolvePossibleLambda");
       },
       helperSexpr: function helperSexpr(sexpr, program2, inverse) {
-        var params = this.setupFullMustacheParams(sexpr, program2, inverse), path24 = sexpr.path, name = path24.parts[0];
+        var params = this.setupFullMustacheParams(sexpr, program2, inverse), path26 = sexpr.path, name = path26.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 {
-          path24.strict = true;
-          path24.falsy = true;
-          this.accept(path24);
-          this.opcode("invokeHelper", params.length, path24.original, _ast2["default"].helpers.simpleId(path24));
+          path26.strict = true;
+          path26.falsy = true;
+          this.accept(path26);
+          this.opcode("invokeHelper", params.length, path26.original, _ast2["default"].helpers.simpleId(path26));
         }
       },
-      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);
+      PathExpression: function PathExpression(path26) {
+        this.addDepth(path26.depth);
+        this.opcode("getContext", path26.depth);
+        var name = path26.parts[0], scoped = _ast2["default"].helpers.scopedId(path26), blockParamId = !path26.depth && !scoped && this.blockParamIndex(name);
         if (blockParamId) {
-          this.opcode("lookupBlockParam", blockParamId, path24.parts);
+          this.opcode("lookupBlockParam", blockParamId, path26.parts);
         } else if (!name) {
           this.opcode("pushContext");
-        } else if (path24.data) {
+        } else if (path26.data) {
           this.options.data = true;
-          this.opcode("lookupData", path24.depth, path24.parts, path24.strict);
+          this.opcode("lookupData", path26.depth, path26.parts, path26.strict);
         } else {
-          this.opcode("lookupOnContext", path24.parts, path24.falsy, path24.strict, scoped);
+          this.opcode("lookupOnContext", path26.parts, path26.falsy, path26.strict, scoped);
         }
       },
       StringLiteral: function StringLiteral(string) {
@@ -3041,16 +3041,16 @@ var require_util = __commonJS({
     }
     exports2.urlGenerate = urlGenerate;
     function normalize(aPath) {
-      var path24 = aPath;
+      var path26 = aPath;
       var url = urlParse(aPath);
       if (url) {
         if (!url.path) {
           return aPath;
         }
-        path24 = url.path;
+        path26 = url.path;
       }
-      var isAbsolute = exports2.isAbsolute(path24);
-      var parts = path24.split(/\/+/);
+      var isAbsolute = exports2.isAbsolute(path26);
+      var parts = path26.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({
           }
         }
       }
-      path24 = parts.join("/");
-      if (path24 === "") {
-        path24 = isAbsolute ? "/" : ".";
+      path26 = parts.join("/");
+      if (path26 === "") {
+        path26 = isAbsolute ? "/" : ".";
       }
       if (url) {
-        url.path = path24;
+        url.path = path26;
         return urlGenerate(url);
       }
-      return path24;
+      return path26;
     }
     exports2.normalize = normalize;
-    function join22(aRoot, aPath) {
+    function join24(aRoot, aPath) {
       if (aRoot === "") {
         aRoot = ".";
       }
@@ -3110,7 +3110,7 @@ var require_util = __commonJS({
       }
       return joined;
     }
-    exports2.join = join22;
+    exports2.join = join24;
     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 = join22(urlGenerate(parsed), sourceURL);
+        sourceURL = join24(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 path24 = id.parts.join("/");
-      return (id.data ? "@" : "") + "PATH:" + path24;
+      var path26 = id.parts.join("/");
+      return (id.data ? "@" : "") + "PATH:" + path26;
     };
     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 fs28 = require("fs");
-      var templateString = fs28.readFileSync(filename, "utf8");
+      var fs30 = require("fs");
+      var templateString = fs30.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 fs27 = __toESM(require("node:fs"));
-var path23 = __toESM(require("node:path"));
+var fs29 = __toESM(require("node:fs"));
+var path25 = __toESM(require("node:path"));
 
 // src/commands/setup.ts
 var path9 = __toESM(require("node:path"));
@@ -5931,9 +5931,7 @@ var RegistryReader = class {
   }
   /** 按 configKey + configValue 匹配 skill，返回 skill ID 列表 */
   findSkillIds(configKey, configValue) {
-    return Object.entries(this.registry.skills).filter(
-      ([, s]) => s.configKey === configKey && s.configValue === configValue
-    ).map(([id]) => id);
+    return Object.entries(this.registry.skills).filter(([, s]) => s.configKey === configKey && s.configValue === configValue).map(([id]) => id);
   }
   /** 获取所有工具名称列表 */
   getTools() {
@@ -5953,9 +5951,7 @@ var RegistryReader = class {
   }
   /** 获取指定工具的所有 skill */
   getToolSkills(toolName) {
-    return Object.values(this.registry.skills).filter(
-      (s) => s.tool === toolName
-    );
+    return Object.values(this.registry.skills).filter((s) => s.tool === toolName);
   }
   /** 获取指定工具的 agent 文件名列表 */
   getToolAgents(toolName) {
@@ -6001,10 +5997,7 @@ function deepMerge(target, source) {
     const val = source[key];
     const existing = result[key];
     if (isPlainObject(existing) && isPlainObject(val)) {
-      result[key] = deepMerge(
-        existing,
-        val
-      );
+      result[key] = deepMerge(existing, val);
     } else {
       result[key] = val;
     }
@@ -6232,7 +6225,10 @@ function initContextMap(targetDir, opts) {
   ensureDir2(deepstormDir);
   const backendLang = opts.backend || "none";
   const frontendFramework = opts.frontend || "none";
-  const content = CONTEXT_MD_TEMPLATE.replace("{backend.language}", backendLang).replace("{frontend.framework}", frontendFramework);
+  const content = CONTEXT_MD_TEMPLATE.replace("{backend.language}", backendLang).replace(
+    "{frontend.framework}",
+    frontendFramework
+  );
   fs2.writeFileSync(contextPath, content, "utf-8");
   console.log("\u2714 \u5DF2\u521B\u5EFA .deepstorm/context.md \u9879\u76EE\u4E0A\u4E0B\u6587\u5730\u56FE");
 }
@@ -6242,10 +6238,7 @@ function initClaudeMd(targetDir, opts) {
   if (fs2.existsSync(claudeMdPath)) return;
   ensureDir2(claudeDir);
   const projectName = opts.projectName || "unknown";
-  const lines = [
-    `# ${projectName}`,
-    ""
-  ];
+  const lines = [`# ${projectName}`, ""];
   const techLines = [];
   if (opts.frontend) {
     techLines.push(`- **\u524D\u7AEF**\uFF1A${opts.frontend}`);
@@ -6342,7 +6335,6 @@ async function promptContinueSetup(targetDir, projectName, registry2) {
   if (!registry2) return;
   if (!registry2.tools || Object.keys(registry2.tools).length === 0) return;
   const { confirm: confirm6, isCancel: isCancel8, outro: outro2 } = await import("@clack/prompts");
-  const projectPath = path2.join(targetDir, projectName);
   const shouldContinue = await confirm6({
     message: `\u662F\u5426\u7EE7\u7EED\u5B89\u88C5 DeepStorm \u5F00\u53D1\u73AF\u5883\uFF08skills + MCP \u670D\u52A1\uFF09\uFF1F`,
     initialValue: true
@@ -6568,7 +6560,6 @@ async function runInit(baseDir, opts) {
   const hasFrontend = opts.frontend === "angular";
   const hasJavaBackend = opts.backend === "java";
   const hasNodeBackend = opts.backend === "nodejs";
-  const hasBackend = hasJavaBackend || hasNodeBackend;
   try {
     const isMonorepo = hasFrontend && hasNodeBackend;
     if (isMonorepo) {
@@ -6618,89 +6609,130 @@ function renderAngularTemplate(projectDir, ctx, subPkg = false) {
   const hasPrimeng = ctx.uiLib === "primeng";
   const hasTailwind = ctx.cssFramework === "tailwind";
   const webRoot = subPkg ? "src" : "src/main/web";
-  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: webRoot,
-        prefix: "app",
-        architect: {
-          build: {
-            builder: "@angular-devkit/build-angular:application",
-            options: {
-              outputPath: "build",
-              index: `${webRoot}/index.html`,
-              browser: `${webRoot}/main.ts`,
-              polyfills: ["zone.js"],
-              tsConfig: "tsconfig.app.json",
-              assets: [{ glob: "**/*", input: "public" }],
-              styles: getAngularStyles(hasPrimeng, webRoot),
-              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, webRoot), scripts: [] }
+  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: webRoot,
+            prefix: "app",
+            architect: {
+              build: {
+                builder: "@angular-devkit/build-angular:application",
+                options: {
+                  outputPath: "build",
+                  index: `${webRoot}/index.html`,
+                  browser: `${webRoot}/main.ts`,
+                  polyfills: ["zone.js"],
+                  tsConfig: "tsconfig.app.json",
+                  assets: [{ glob: "**/*", input: "public" }],
+                  styles: getAngularStyles(hasPrimeng, webRoot),
+                  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, webRoot),
+                  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: [`${webRoot}/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));
+      },
+      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: [`${webRoot}/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",
@@ -6709,45 +6741,64 @@ function renderAngularTemplate(projectDir, ctx, subPkg = false) {
     "@angular/forms": "^21.0.0",
     "@angular/platform-browser": "^21.0.0",
     "@angular/router": "^21.0.0",
-    "rxjs": "~7.8.0",
-    "tslib": "^2.3.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"
+    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";
+  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";
 
@@ -6757,10 +6808,14 @@ export default [
   pluginJs.configs.recommended,
   ...tseslint.configs.recommended,
 ];
-`);
+`
+  );
   ensureDir2(path2.join(projectDir, "public"));
   ensureDir2(path2.join(projectDir, webRoot, "app"));
-  writeTemplate(projectDir, `${webRoot}/index.html`, `<!doctype html>
+  writeTemplate(
+    projectDir,
+    `${webRoot}/index.html`,
+    `<!doctype html>
 <html lang="zh-CN">
 <head>
   <meta charset="utf-8">
@@ -6773,20 +6828,28 @@ export default [
   <app-root></app-root>
 </body>
 </html>
-`);
-  writeTemplate(projectDir, `${webRoot}/main.ts`, `import { bootstrapApplication } from '@angular/platform-browser';
+`
+  );
+  writeTemplate(
+    projectDir,
+    `${webRoot}/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, `${webRoot}/styles.css`, stylesContent);
-  writeTemplate(projectDir, `${webRoot}/app/app.ts`, `import { Component } from '@angular/core';
+  writeTemplate(
+    projectDir,
+    `${webRoot}/app/app.ts`,
+    `import { Component } from '@angular/core';
 import { RouterOutlet } from '@angular/router';
 
 @Component({
@@ -6796,8 +6859,12 @@ import { RouterOutlet } from '@angular/router';
   template: \`<router-outlet></router-outlet>\`,
 })
 export class App {}
-`);
-  writeTemplate(projectDir, `${webRoot}/app/app.config.ts`, `import { ApplicationConfig, provideZoneChangeDetection } from '@angular/core';
+`
+  );
+  writeTemplate(
+    projectDir,
+    `${webRoot}/app/app.config.ts`,
+    `import { ApplicationConfig, provideZoneChangeDetection } from '@angular/core';
 import { provideRouter } from '@angular/router';
 import { routes } from './app.routes';
 
@@ -6807,15 +6874,28 @@ export const appConfig: ApplicationConfig = {
     provideRouter(routes),
   ],
 };
-`);
-  writeTemplate(projectDir, `${webRoot}/app/app.routes.ts`, `import { Routes } from '@angular/router';
+`
+  );
+  writeTemplate(
+    projectDir,
+    `${webRoot}/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));
+    writeTemplate(
+      projectDir,
+      "postcss.config.json",
+      JSON.stringify(
+        {
+          plugins: { "@tailwindcss/postcss": {} }
+        },
+        null,
+        2
+      )
+    );
   }
 }
 function getAngularStyles(hasPrimeng, webRoot) {
@@ -6827,40 +6907,56 @@ function getAngularStyles(hasPrimeng, webRoot) {
   return styles;
 }
 function renderMonorepoRoot(projectDir, ctx) {
-  writeTemplate(projectDir, "package.json", JSON.stringify({
-    name: ctx.packageName,
-    version: "0.1.0",
-    private: true,
-    description: "",
-    scripts: {
-      dev: "pnpm --filter server dev & pnpm --filter client dev",
-      build: "pnpm --filter server build",
-      lint: "pnpm --filter server lint",
-      format: "pnpm --filter server format",
-      test: "pnpm --filter server test"
-    }
-  }, null, 2));
-  writeTemplate(projectDir, "pnpm-workspace.yaml", `packages:
+  writeTemplate(
+    projectDir,
+    "package.json",
+    JSON.stringify(
+      {
+        name: ctx.packageName,
+        version: "0.1.0",
+        private: true,
+        description: "",
+        scripts: {
+          dev: "pnpm --filter server dev & pnpm --filter client dev",
+          build: "pnpm --filter server build",
+          lint: "pnpm --filter server lint",
+          format: "pnpm --filter server format",
+          test: "pnpm --filter server test"
+        }
+      },
+      null,
+      2
+    )
+  );
+  writeTemplate(
+    projectDir,
+    "pnpm-workspace.yaml",
+    `packages:
   - "server"
   - "client"
-`);
+`
+  );
 }
 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
+  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 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")',
@@ -6877,7 +6973,10 @@ org.gradle.parallel=true
     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 {
+  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"` : ""}
 }
@@ -6906,11 +7005,15 @@ dependencies {
 tasks.withType<Test> {
   useJUnitPlatform()
 }
-`);
+`
+  );
   const appPackage = ctx.groupId.replace(/[.-]/g, ".");
   const appDir = `src/main/java/${appPackage.replace(/\./g, "/")}`;
   ensureDir2(path2.join(projectDir, appDir));
-  writeTemplate(projectDir, `${appDir}/Application.java`, `package ${appPackage};
+  writeTemplate(
+    projectDir,
+    `${appDir}/Application.java`,
+    `package ${appPackage};
 
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
@@ -6922,10 +7025,14 @@ public class Application {
     SpringApplication.run(Application.class, args);
   }
 }
-`);
+`
+  );
   const controllerDir = `${appDir}/controller`;
   ensureDir2(path2.join(projectDir, controllerDir));
-  writeTemplate(projectDir, `${controllerDir}/HealthController.java`, `package ${appPackage}.controller;
+  writeTemplate(
+    projectDir,
+    `${controllerDir}/HealthController.java`,
+    `package ${appPackage}.controller;
 
 import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.RestController;
@@ -6938,7 +7045,8 @@ public class HealthController {
     return "OK";
   }
 }
-`);
+`
+  );
   const serviceDir = `${appDir}/service`;
   ensureDir2(path2.join(projectDir, serviceDir));
   if (hasOrm) {
@@ -6946,7 +7054,10 @@ public class HealthController {
     ensureDir2(path2.join(projectDir, repositoryDir));
     const entityDir = `${appDir}/entity`;
     ensureDir2(path2.join(projectDir, entityDir));
-    writeTemplate(projectDir, `${entityDir}/BaseEntity.java`, `package ${appPackage}.entity;
+    writeTemplate(
+      projectDir,
+      `${entityDir}/BaseEntity.java`,
+      `package ${appPackage}.entity;
 
 import jakarta.persistence.GeneratedValue;
 import jakarta.persistence.GenerationType;
@@ -6971,7 +7082,8 @@ public abstract class BaseEntity {
   public LocalDateTime getUpdatedAt() { return updatedAt; }
   public void setUpdatedAt(LocalDateTime updatedAt) { this.updatedAt = updatedAt; }
 }
-`);
+`
+    );
   }
   ensureDir2(path2.join(projectDir, "src/main/resources"));
   const datasourceConfig = hasOrm ? `
@@ -6993,19 +7105,26 @@ spring:
   liquibase:
     change-log: classpath:db/changelog/db.changelog-master.xml
 ` : "";
-  writeTemplate(projectDir, "src/main/resources/application.yml", `server:
+  writeTemplate(
+    projectDir,
+    "src/main/resources/application.yml",
+    `server:
   port: 8080
 ${datasourceConfig}${liquibaseConfig}
 logging:
   level:
     root: INFO
     ${ctx.packageName}: DEBUG
-`);
+`
+  );
   if (hasLiquibase) {
     const now = /* @__PURE__ */ new Date();
     const ts = now.toISOString().replace(/\D/g, "").slice(0, 12);
     ensureDir2(path2.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"?>
+    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"
@@ -7018,12 +7137,16 @@ logging:
     </createTable>
   </changeSet>
 </databaseChangeLog>
-`);
+`
+    );
   }
   const testDir = `src/test/java/${appPackage.replace(/\./g, "/")}`;
   ensureDir2(path2.join(projectDir, testDir));
   ensureDir2(path2.join(projectDir, "src/test/resources"));
-  writeTemplate(projectDir, `${testDir}/ApplicationTests.java`, `package ${appPackage};
+  writeTemplate(
+    projectDir,
+    `${testDir}/ApplicationTests.java`,
+    `package ${appPackage};
 
 import org.junit.jupiter.api.Test;
 import org.springframework.boot.test.context.SpringBootTest;
@@ -7035,19 +7158,31 @@ class ApplicationTests {
   void contextLoads() {
   }
 }
-`);
-  writeTemplate(projectDir, "src/test/resources/junit-platform.properties", `junit.jupiter.testinstance.lifecycle.default = per_class
-`);
+`
+  );
+  writeTemplate(
+    projectDir,
+    "src/test/resources/junit-platform.properties",
+    `junit.jupiter.testinstance.lifecycle.default = per_class
+`
+  );
   ensureDir2(path2.join(projectDir, "gradle/wrapper"));
-  writeTemplate(projectDir, "gradle/wrapper/gradle-wrapper.properties", `distributionBase=GRADLE_USER_HOME
+  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
+`
+  );
+  writeTemplate(
+    projectDir,
+    "gradlew",
+    `#!/bin/sh
 
 #
 # Gradle start up script for POSIX generated by Gradle.
@@ -7105,8 +7240,12 @@ else
 fi
 
 exec "$JAVACMD" $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS -classpath "$CLASSPATH" org.gradle.wrapper.GradleWrapperMain "$@"
-`);
-  writeTemplate(projectDir, "gradlew.bat", `@rem
+`
+  );
+  writeTemplate(
+    projectDir,
+    "gradlew.bat",
+    `@rem
 @rem Gradle startup script for Windows
 @rem
 @if "%DEBUG%"=="" @echo off
@@ -7119,7 +7258,8 @@ 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 renderNestJSTemplate(projectDir, ctx, opts) {
   const hasPrisma = opts.nodejsOrm === "prisma";
@@ -7163,127 +7303,159 @@ function renderNestJSTemplate(projectDir, ctx, opts) {
   if (hasAgentSdk) {
     pkgDeps["@anthropic-ai/sdk"] = "^0.40.0";
   }
-  writeTemplate(projectDir, "package.json", JSON.stringify({
-    name: ctx.packageName,
-    version: "0.1.0",
-    description: "",
-    private: true,
-    scripts: {
-      build: "nest build",
-      format: 'prettier --write "src/**/*.ts"',
-      start: "nest start",
-      "start:dev": "nest start --watch",
-      "start:prod": "node dist/main",
-      lint: 'eslint "{src,test}/**/*.ts" --fix',
-      test: "jest",
-      "test:watch": "jest --watch",
-      "test:cov": "jest --coverage",
-      "test:e2e": "jest --config ./test/jest-e2e.json"
-    },
-    dependencies: pkgDeps,
-    devDependencies: devDeps,
-    jest: {
-      moduleFileExtensions: ["js", "json", "ts"],
-      rootDir: "src",
-      testRegex: ".*\\.spec\\.ts$",
-      transform: { "^.+\\.(t|j)s$": "ts-jest" },
-      collectCoverageFrom: ["**/*.(t|j)s"],
-      coverageDirectory: "../coverage",
-      testEnvironment: "node"
-    }
-  }, null, 2));
-  writeTemplate(projectDir, "tsconfig.json", JSON.stringify({
-    compilerOptions: {
-      module: "commonjs",
-      declaration: true,
-      removeComments: true,
-      emitDecoratorMetadata: true,
-      experimentalDecorators: true,
-      allowSyntheticDefaultImports: true,
-      target: "ES2023",
-      sourceMap: true,
-      outDir: "./dist",
-      baseUrl: "./",
-      incremental: true,
-      skipLibCheck: true,
-      strict: true,
-      strictNullChecks: true,
-      noImplicitAny: true,
-      strictBindCallApply: true,
-      forceConsistentCasingInFileNames: true,
-      noFallthroughCasesInSwitch: true,
-      esModuleInterop: true,
-      resolveJsonModule: true
-    }
-  }, null, 2));
-  writeTemplate(projectDir, "nest-cli.json", JSON.stringify({
-    $schema: "https://json.schemastore.org/nest-cli",
-    collection: "@nestjs/schematics",
-    sourceRoot: "src",
-    compilerOptions: { deleteOutDir: true }
-  }, null, 2));
-  writeTemplate(projectDir, ".prettierrc", JSON.stringify({
-    singleQuote: true,
-    trailingComma: "all",
-    tabWidth: 2,
-    semi: true,
-    printWidth: 120
-  }, null, 2));
+  writeTemplate(
+    projectDir,
+    "package.json",
+    JSON.stringify(
+      {
+        name: ctx.packageName,
+        version: "0.1.0",
+        description: "",
+        private: true,
+        scripts: {
+          build: "nest build",
+          format: 'prettier --write "src/**/*.ts"',
+          start: "nest start",
+          "start:dev": "nest start --watch",
+          "start:prod": "node dist/main",
+          lint: 'eslint "{src,test}/**/*.ts" --fix',
+          test: "jest",
+          "test:watch": "jest --watch",
+          "test:cov": "jest --coverage",
+          "test:e2e": "jest --config ./test/jest-e2e.json"
+        },
+        dependencies: pkgDeps,
+        devDependencies: devDeps,
+        jest: {
+          moduleFileExtensions: ["js", "json", "ts"],
+          rootDir: "src",
+          testRegex: ".*\\.spec\\.ts$",
+          transform: { "^.+\\.(t|j)s$": "ts-jest" },
+          collectCoverageFrom: ["**/*.(t|j)s"],
+          coverageDirectory: "../coverage",
+          testEnvironment: "node"
+        }
+      },
+      null,
+      2
+    )
+  );
+  writeTemplate(
+    projectDir,
+    "tsconfig.json",
+    JSON.stringify(
+      {
+        compilerOptions: {
+          module: "commonjs",
+          declaration: true,
+          removeComments: true,
+          emitDecoratorMetadata: true,
+          experimentalDecorators: true,
+          allowSyntheticDefaultImports: true,
+          target: "ES2023",
+          sourceMap: true,
+          outDir: "./dist",
+          baseUrl: "./",
+          incremental: true,
+          skipLibCheck: true,
+          strict: true,
+          strictNullChecks: true,
+          noImplicitAny: true,
+          strictBindCallApply: true,
+          forceConsistentCasingInFileNames: true,
+          noFallthroughCasesInSwitch: true,
+          esModuleInterop: true,
+          resolveJsonModule: true
+        }
+      },
+      null,
+      2
+    )
+  );
+  writeTemplate(
+    projectDir,
+    "nest-cli.json",
+    JSON.stringify(
+      {
+        $schema: "https://json.schemastore.org/nest-cli",
+        collection: "@nestjs/schematics",
+        sourceRoot: "src",
+        compilerOptions: { deleteOutDir: true }
+      },
+      null,
+      2
+    )
+  );
+  writeTemplate(
+    projectDir,
+    ".prettierrc",
+    JSON.stringify(
+      {
+        singleQuote: true,
+        trailingComma: "all",
+        tabWidth: 2,
+        semi: true,
+        printWidth: 120
+      },
+      null,
+      2
+    )
+  );
   ensureDir2(path2.join(projectDir, "src"));
-  writeTemplate(projectDir, "src/main.ts", [
-    "import { NestFactory } from '@nestjs/core';",
-    "import { ValidationPipe, Logger } from '@nestjs/common';",
-    "import { SwaggerModule, DocumentBuilder } from '@nestjs/swagger';",
-    "import { AppModule } from './app.module';",
-    "",
-    "async function bootstrap() {",
-    "  const app = await NestFactory.create(AppModule);",
-    "  const logger = new Logger('Bootstrap');",
-    "",
-    "  app.setGlobalPrefix('api/v1');",
-    "",
-    "  app.useGlobalPipes(",
-    "    new ValidationPipe({",
-    "      whitelist: true,",
-    "      forbidNonWhitelisted: true,",
-    "      transform: true,",
-    "    }),",
-    "  );",
-    "",
-    "  const config = new DocumentBuilder()",
-    `    .setTitle('${ctx.projectName}')`,
-    "    .setDescription('API documentation')",
-    "    .setVersion('1.0')",
-    "    .addBearerAuth()",
-    "    .build();",
-    "  const document = SwaggerModule.createDocument(app, config);",
-    "  SwaggerModule.setup('api/docs', app, document);",
-    "",
-    "  app.enableCors({",
-    "    origin: process.env.CORS_ORIGIN || '*',",
-    "    methods: 'GET,HEAD,PUT,PATCH,POST,DELETE',",
-    "    credentials: true,",
-    "  });",
-    "",
-    "  const port = process.env.PORT || 3000;",
-    "  await app.listen(port);",
-    "  logger.log(`Application running on http://localhost:${port}`);",
-    "  logger.log(`Swagger docs at http://localhost:${port}/api/docs`);",
-    "}",
-    "bootstrap();",
-    ""
-  ].join("\n"));
+  writeTemplate(
+    projectDir,
+    "src/main.ts",
+    [
+      "import { NestFactory } from '@nestjs/core';",
+      "import { ValidationPipe, Logger } from '@nestjs/common';",
+      "import { SwaggerModule, DocumentBuilder } from '@nestjs/swagger';",
+      "import { AppModule } from './app.module';",
+      "",
+      "async function bootstrap() {",
+      "  const app = await NestFactory.create(AppModule);",
+      "  const logger = new Logger('Bootstrap');",
+      "",
+      "  app.setGlobalPrefix('api/v1');",
+      "",
+      "  app.useGlobalPipes(",
+      "    new ValidationPipe({",
+      "      whitelist: true,",
+      "      forbidNonWhitelisted: true,",
+      "      transform: true,",
+      "    }),",
+      "  );",
+      "",
+      "  const config = new DocumentBuilder()",
+      `    .setTitle('${ctx.projectName}')`,
+      "    .setDescription('API documentation')",
+      "    .setVersion('1.0')",
+      "    .addBearerAuth()",
+      "    .build();",
+      "  const document = SwaggerModule.createDocument(app, config);",
+      "  SwaggerModule.setup('api/docs', app, document);",
+      "",
+      "  app.enableCors({",
+      "    origin: process.env.CORS_ORIGIN || '*',",
+      "    methods: 'GET,HEAD,PUT,PATCH,POST,DELETE',",
+      "    credentials: true,",
+      "  });",
+      "",
+      "  const port = process.env.PORT || 3000;",
+      "  await app.listen(port);",
+      "  logger.log(`Application running on http://localhost:${port}`);",
+      "  logger.log(`Swagger docs at http://localhost:${port}/api/docs`);",
+      "}",
+      "bootstrap();",
+      ""
+    ].join("\n")
+  );
   const appModuleContent = [
     "import { Module } from '@nestjs/common';",
     "import { ConfigModule } from '@nestjs/config';",
     "import { AppController } from './app.controller';",
     "import { AppService } from './app.service';"
   ];
-  const appModuleImports = [
-    "    ConfigModule.forRoot({",
-    "      isGlobal: true,",
-    "    }),"
-  ];
+  const appModuleImports = ["    ConfigModule.forRoot({", "      isGlobal: true,", "    }),"];
   if (hasPrisma) {
     appModuleContent.push("import { PrismaModule } from './prisma/prisma.module';");
     appModuleImports.push("    PrismaModule,");
@@ -7305,188 +7477,223 @@ function renderNestJSTemplate(projectDir, ctx, opts) {
   appModuleContent.push("})");
   appModuleContent.push("export class AppModule {}");
   writeTemplate(projectDir, "src/app.module.ts", appModuleContent.join("\n"));
-  writeTemplate(projectDir, "src/app.controller.ts", [
-    "import { Controller, Get } from '@nestjs/common';",
-    "import { ApiTags, ApiOperation } from '@nestjs/swagger';",
-    "import { AppService } from './app.service';",
-    "",
-    "@ApiTags('Health')",
-    "@Controller()",
-    "export class AppController {",
-    "  constructor(private readonly appService: AppService) {}",
-    "",
-    "  @Get()",
-    "  @ApiOperation({ summary: '\u5065\u5EB7\u68C0\u67E5' })",
-    "  getHello(): string {",
-    "    return this.appService.getHello();",
-    "  }",
-    "}",
-    ""
-  ].join("\n"));
-  writeTemplate(projectDir, "src/app.service.ts", [
-    "import { Injectable } from '@nestjs/common';",
-    "",
-    "@Injectable()",
-    "export class AppService {",
-    "  getHello(): string {",
-    `    return 'Hello from ${ctx.projectName}!';`,
-    "  }",
-    "}",
-    ""
-  ].join("\n"));
-  if (hasPrisma) {
-    ensureDir2(path2.join(projectDir, "prisma"));
-    writeTemplate(projectDir, "prisma/schema.prisma", [
-      "generator client {",
-      '  provider = "prisma-client-js"',
-      "}",
+  writeTemplate(
+    projectDir,
+    "src/app.controller.ts",
+    [
+      "import { Controller, Get } from '@nestjs/common';",
+      "import { ApiTags, ApiOperation } from '@nestjs/swagger';",
+      "import { AppService } from './app.service';",
       "",
-      "datasource db {",
-      '  provider = "postgresql"',
-      '  url      = env("DATABASE_URL")',
-      "}",
+      "@ApiTags('Health')",
+      "@Controller()",
+      "export class AppController {",
+      "  constructor(private readonly appService: AppService) {}",
       "",
-      "/// \u7528\u6237",
-      "model User {",
-      "  id        Int      @id @default(autoincrement())",
-      "  name      String",
-      "  email     String   @unique",
-      "  active    Boolean  @default(true)",
-      "  createdAt DateTime @default(now())",
-      "  updatedAt DateTime @updatedAt",
-      "",
-      '  @@map("users")',
+      "  @Get()",
+      "  @ApiOperation({ summary: '\u5065\u5EB7\u68C0\u67E5' })",
+      "  getHello(): string {",
+      "    return this.appService.getHello();",
+      "  }",
       "}",
       ""
-    ].join("\n"));
-    ensureDir2(path2.join(projectDir, "src/prisma"));
-    writeTemplate(projectDir, "src/prisma/prisma.module.ts", [
-      "import { Global, Module } from '@nestjs/common';",
-      "import { PrismaService } from './prisma.service';",
-      "",
-      "@Global()",
-      "@Module({",
-      "  providers: [PrismaService],",
-      "  exports: [PrismaService],",
-      "})",
-      "export class PrismaModule {}",
-      ""
-    ].join("\n"));
-    writeTemplate(projectDir, "src/prisma/prisma.service.ts", [
-      "import { Injectable, Logger, OnModuleInit, OnModuleDestroy } from '@nestjs/common';",
-      "import { PrismaClient } from '@prisma/client';",
+    ].join("\n")
+  );
+  writeTemplate(
+    projectDir,
+    "src/app.service.ts",
+    [
+      "import { Injectable } from '@nestjs/common';",
       "",
       "@Injectable()",
-      "export class PrismaService extends PrismaClient implements OnModuleInit, OnModuleDestroy {",
-      "  private readonly logger = new Logger(PrismaService.name);",
-      "",
-      "  async onModuleInit() {",
-      "    await this.$connect();",
-      "    this.logger.log('Database connected');",
-      "  }",
-      "",
-      "  async onModuleDestroy() {",
-      "    await this.$disconnect();",
-      "    this.logger.log('Database disconnected');",
+      "export class AppService {",
+      "  getHello(): string {",
+      `    return 'Hello from ${ctx.projectName}!';`,
       "  }",
       "}",
       ""
-    ].join("\n"));
+    ].join("\n")
+  );
+  if (hasPrisma) {
+    ensureDir2(path2.join(projectDir, "prisma"));
+    writeTemplate(
+      projectDir,
+      "prisma/schema.prisma",
+      [
+        "generator client {",
+        '  provider = "prisma-client-js"',
+        "}",
+        "",
+        "datasource db {",
+        '  provider = "postgresql"',
+        '  url      = env("DATABASE_URL")',
+        "}",
+        "",
+        "/// \u7528\u6237",
+        "model User {",
+        "  id        Int      @id @default(autoincrement())",
+        "  name      String",
+        "  email     String   @unique",
+        "  active    Boolean  @default(true)",
+        "  createdAt DateTime @default(now())",
+        "  updatedAt DateTime @updatedAt",
+        "",
+        '  @@map("users")',
+        "}",
+        ""
+      ].join("\n")
+    );
+    ensureDir2(path2.join(projectDir, "src/prisma"));
+    writeTemplate(
+      projectDir,
+      "src/prisma/prisma.module.ts",
+      [
+        "import { Global, Module } from '@nestjs/common';",
+        "import { PrismaService } from './prisma.service';",
+        "",
+        "@Global()",
+        "@Module({",
+        "  providers: [PrismaService],",
+        "  exports: [PrismaService],",
+        "})",
+        "export class PrismaModule {}",
+        ""
+      ].join("\n")
+    );
+    writeTemplate(
+      projectDir,
+      "src/prisma/prisma.service.ts",
+      [
+        "import { Injectable, Logger, OnModuleInit, OnModuleDestroy } from '@nestjs/common';",
+        "import { PrismaClient } from '@prisma/client';",
+        "",
+        "@Injectable()",
+        "export class PrismaService extends PrismaClient implements OnModuleInit, OnModuleDestroy {",
+        "  private readonly logger = new Logger(PrismaService.name);",
+        "",
+        "  async onModuleInit() {",
+        "    await this.$connect();",
+        "    this.logger.log('Database connected');",
+        "  }",
+        "",
+        "  async onModuleDestroy() {",
+        "    await this.$disconnect();",
+        "    this.logger.log('Database disconnected');",
+        "  }",
+        "}",
+        ""
+      ].join("\n")
+    );
   }
   if (hasAgentSdk) {
     ensureDir2(path2.join(projectDir, "src/agent/tools"));
-    writeTemplate(projectDir, "src/agent/agent.module.ts", [
-      "import { Module } from '@nestjs/common';",
-      "import { AgentService } from './agent.service';",
-      "",
-      "@Module({",
-      "  providers: [AgentService],",
-      "  exports: [AgentService],",
-      "})",
-      "export class AgentModule {}",
-      ""
-    ].join("\n"));
-    writeTemplate(projectDir, "src/agent/agent.service.ts", [
-      "import { Injectable, Logger } from '@nestjs/common';",
-      "import { ConfigService } from '@nestjs/config';",
-      "",
-      "/**",
-      " * Claude Agent \u670D\u52A1",
-      " *",
-      " * \u5C01\u88C5 Claude Agent SDK\uFF0C\u63D0\u4F9B Agent \u4EA4\u4E92\u80FD\u529B\u3002",
-      " * \u4F7F\u7528\u524D\u9700\u5728 .env \u4E2D\u914D\u7F6E ANTHROPIC_API_KEY\u3002",
-      " */",
-      "@Injectable()",
-      "export class AgentService {",
-      "  private readonly logger = new Logger(AgentService.name);",
-      "",
-      "  constructor(private readonly configService: ConfigService) {",
-      "    const apiKey = this.configService.get<string>('ANTHROPIC_API_KEY');",
-      "    if (!apiKey) {",
-      "      this.logger.warn('ANTHROPIC_API_KEY is not configured');",
-      "    }",
-      "  }",
-      "",
-      "  async ask(question: string): Promise<string> {",
-      '    this.logger.debug(`Agent ask: "${question}"`);',
-      "    return 'Agent response placeholder -- configure ANTHROPIC_API_KEY to enable';",
-      "  }",
-      "}",
-      ""
-    ].join("\n"));
-    writeTemplate(projectDir, "src/agent/tools/example.tool.ts", [
-      "import { Injectable, Logger } from '@nestjs/common';",
-      "",
-      "export interface ToolDefinition {",
-      "  name: string;",
-      "  description: string;",
-      "  input_schema: Record<string, unknown>;",
-      "  execute: (input: Record<string, unknown>) => Promise<unknown>;",
-      "}",
-      "",
-      "@Injectable()",
-      "export class ExampleTool implements ToolDefinition {",
-      "  private readonly logger = new Logger(ExampleTool.name);",
-      "",
-      "  name = 'get_current_time';",
-      "  description = '\u83B7\u53D6\u5F53\u524D\u65E5\u671F\u548C\u65F6\u95F4';",
-      "  input_schema = {",
-      "    type: 'object',",
-      "    properties: {",
-      "      timezone: {",
-      "        type: 'string',",
-      "        description: '\u65F6\u533A\uFF08\u53EF\u9009\uFF0C\u9ED8\u8BA4 UTC\uFF09',",
-      "        enum: ['UTC', 'Asia/Shanghai', 'America/New_York'],",
-      "      },",
-      "    },",
-      "  };",
-      "",
-      "  async execute(input: Record<string, unknown>): Promise<unknown> {",
-      "    try {",
-      "      this.logger.debug(`Tool execute: get_current_time with input: ${JSON.stringify(input)}`);",
-      "      const now = new Date();",
-      "      return {",
-      "        success: true,",
-      "        data: {",
-      "          iso: now.toISOString(),",
-      "          timestamp: now.getTime(),",
-      "        },",
-      "      };",
-      "    } catch (error) {",
-      "      this.logger.error(`Tool execution failed: ${error}`);",
-      "      return {",
-      "        success: false,",
-      "        error: error instanceof Error ? error.message : 'Unknown error',",
-      "      };",
-      "    }",
-      "  }",
-      "}",
-      ""
-    ].join("\n"));
+    writeTemplate(
+      projectDir,
+      "src/agent/agent.module.ts",
+      [
+        "import { Module } from '@nestjs/common';",
+        "import { AgentService } from './agent.service';",
+        "",
+        "@Module({",
+        "  providers: [AgentService],",
+        "  exports: [AgentService],",
+        "})",
+        "export class AgentModule {}",
+        ""
+      ].join("\n")
+    );
+    writeTemplate(
+      projectDir,
+      "src/agent/agent.service.ts",
+      [
+        "import { Injectable, Logger } from '@nestjs/common';",
+        "import { ConfigService } from '@nestjs/config';",
+        "",
+        "/**",
+        " * Claude Agent \u670D\u52A1",
+        " *",
+        " * \u5C01\u88C5 Claude Agent SDK\uFF0C\u63D0\u4F9B Agent \u4EA4\u4E92\u80FD\u529B\u3002",
+        " * \u4F7F\u7528\u524D\u9700\u5728 .env \u4E2D\u914D\u7F6E ANTHROPIC_API_KEY\u3002",
+        " */",
+        "@Injectable()",
+        "export class AgentService {",
+        "  private readonly logger = new Logger(AgentService.name);",
+        "",
+        "  constructor(private readonly configService: ConfigService) {",
+        "    const apiKey = this.configService.get<string>('ANTHROPIC_API_KEY');",
+        "    if (!apiKey) {",
+        "      this.logger.warn('ANTHROPIC_API_KEY is not configured');",
+        "    }",
+        "  }",
+        "",
+        "  async ask(question: string): Promise<string> {",
+        '    this.logger.debug(`Agent ask: "${question}"`);',
+        "    return 'Agent response placeholder -- configure ANTHROPIC_API_KEY to enable';",
+        "  }",
+        "}",
+        ""
+      ].join("\n")
+    );
+    writeTemplate(
+      projectDir,
+      "src/agent/tools/example.tool.ts",
+      [
+        "import { Injectable, Logger } from '@nestjs/common';",
+        "",
+        "export interface ToolDefinition {",
+        "  name: string;",
+        "  description: string;",
+        "  input_schema: Record<string, unknown>;",
+        "  execute: (input: Record<string, unknown>) => Promise<unknown>;",
+        "}",
+        "",
+        "@Injectable()",
+        "export class ExampleTool implements ToolDefinition {",
+        "  private readonly logger = new Logger(ExampleTool.name);",
+        "",
+        "  name = 'get_current_time';",
+        "  description = '\u83B7\u53D6\u5F53\u524D\u65E5\u671F\u548C\u65F6\u95F4';",
+        "  input_schema = {",
+        "    type: 'object',",
+        "    properties: {",
+        "      timezone: {",
+        "        type: 'string',",
+        "        description: '\u65F6\u533A\uFF08\u53EF\u9009\uFF0C\u9ED8\u8BA4 UTC\uFF09',",
+        "        enum: ['UTC', 'Asia/Shanghai', 'America/New_York'],",
+        "      },",
+        "    },",
+        "  };",
+        "",
+        "  async execute(input: Record<string, unknown>): Promise<unknown> {",
+        "    try {",
+        "      this.logger.debug(`Tool execute: get_current_time with input: ${JSON.stringify(input)}`);",
+        "      const now = new Date();",
+        "      return {",
+        "        success: true,",
+        "        data: {",
+        "          iso: now.toISOString(),",
+        "          timestamp: now.getTime(),",
+        "        },",
+        "      };",
+        "    } catch (error) {",
+        "      this.logger.error(`Tool execution failed: ${error}`);",
+        "      return {",
+        "        success: false,",
+        "        error: error instanceof Error ? error.message : 'Unknown error',",
+        "      };",
+        "    }",
+        "  }",
+        "}",
+        ""
+      ].join("\n")
+    );
   }
 }
 function renderCommonFiles(projectDir, ctx, opts) {
-  writeTemplate(projectDir, ".gitignore", `node_modules/
+  writeTemplate(
+    projectDir,
+    ".gitignore",
+    `node_modules/
 .gradle/
 build/
 target/
@@ -7499,10 +7706,13 @@ __pycache__/
 .idea/
 .vscode/
 *.iml
-`);
+`
+  );
   const hasNodeBackend = opts?.backend === "nodejs";
   if (hasNodeBackend) {
-    writeEnvFile(projectDir, `# \u6570\u636E\u5E93\u914D\u7F6E
+    writeEnvFile(
+      projectDir,
+      `# \u6570\u636E\u5E93\u914D\u7F6E
 DATABASE_URL=postgresql://user:password@localhost:5432/${ctx.packageName}
 
 # Claude Agent SDK
@@ -7512,16 +7722,20 @@ AGENT_MODEL=claude-sonnet-5
 # Server
 PORT=3000
 CORS_ORIGIN=http://localhost:4200
-`);
+`
+    );
   } else {
-    writeEnvFile(projectDir, `# \u6570\u636E\u5E93\u914D\u7F6E
+    writeEnvFile(
+      projectDir,
+      `# \u6570\u636E\u5E93\u914D\u7F6E
 DB_URL=jdbc:postgresql://localhost:5432/${ctx.packageName}
 DB_USERNAME=postgres
 DB_PASSWORD=change-me
 
 # API Keys
 OPENAI_API_KEY=sk-your-key-here
-`);
+`
+    );
   }
   const readme = generateReadme(ctx, opts);
   writeTemplate(projectDir, "README.md", readme);
@@ -7743,22 +7957,22 @@ function installGrillMe(targetDir) {
   const skillDir = path3.join(targetDir, ".claude", "skills", "grill-me");
   fs3.mkdirSync(skillDir, { recursive: true });
   try {
-    (0, import_node_child_process.execSync)(
-      "curl -fsSL https://raw.githubusercontent.com/mattpocock/skills/main/grill-me/SKILL.md -o SKILL.md",
-      { ...EXEC_OPTIONS, cwd: skillDir }
-    );
+    (0, import_node_child_process.execSync)("curl -fsSL https://raw.githubusercontent.com/mattpocock/skills/main/grill-me/SKILL.md -o SKILL.md", {
+      ...EXEC_OPTIONS,
+      cwd: skillDir
+    });
     console.log("\u2714 grill-me skill \u5DF2\u5B89\u88C5");
   } catch {
     console.log("\u26A0 grill-me \u5B89\u88C5\u5931\u8D25\uFF0C\u8BF7\u624B\u52A8\u5B89\u88C5 https://github.com/mattpocock/skills");
   }
 }
-function isPlaywrightInstalled(targetDir) {
+function isPlaywrightInstalled() {
   const result = execSafe("npx playwright install --dry-run");
   return result.success && !result.output.toLowerCase().includes("to install");
 }
-function installPlaywright(config, targetDir) {
+function installPlaywright(config, _targetDir) {
   if (config["sweep.e2eFramework"] !== "playwright") return;
-  if (isPlaywrightInstalled(targetDir)) {
+  if (isPlaywrightInstalled()) {
     console.log("\u2139 Playwright \u6D4F\u89C8\u5668\u5DF2\u5B58\u5728\uFF0C\u8DF3\u8FC7\u5B89\u88C5");
     return;
   }
@@ -7867,8 +8081,8 @@ function filterExistingKeys(content, existingKeys) {
   const lines = content.split("\n");
   const result = [];
   let skipUntilDecor = false;
-  for (let i = 0; i < lines.length; i++) {
-    const trimmed = lines[i].trim();
+  for (const line of lines) {
+    const trimmed = line.trim();
     if (trimmed.includes("=") && !trimmed.startsWith("#")) {
       const key = trimmed.slice(0, trimmed.indexOf("=")).trim();
       if (existingKeys.has(key)) {
@@ -7877,20 +8091,20 @@ function filterExistingKeys(content, existingKeys) {
       }
     }
     if (skipUntilDecor) {
-      if (lines[i].match(/^#\s*[═━]/)) {
+      if (line.match(/^#\s*[═━]/)) {
         skipUntilDecor = false;
-        result.push(lines[i]);
+        result.push(line);
       }
       continue;
     }
-    result.push(lines[i]);
+    result.push(line);
   }
   return result.join("\n").trimEnd();
 }
 
 // src/wizard/wizard-flow.ts
-var p4 = __toESM(require("@clack/prompts"));
 var fs8 = __toESM(require("node:fs"));
+var p4 = __toESM(require("@clack/prompts"));
 
 // src/wizard/tool-select.ts
 var p = __toESM(require("@clack/prompts"));
@@ -8123,9 +8337,7 @@ async function renderAsSingleGroup(questions, multiselectKey, selectedTechs, con
           const hasOptionDependsOn = opts.some((o) => o.dependsOn);
           if (hasOptionDependsOn) {
             groupPrompts[sub.key] = ({ results }) => {
-              const filtered = opts.filter(
-                (o) => !o.dependsOn || Object.values(results).includes(o.dependsOn)
-              );
+              const filtered = opts.filter((o) => !o.dependsOn || Object.values(results).includes(o.dependsOn));
               return p3.select({
                 message: sub.label,
                 options: filtered.map((o) => ({
@@ -8220,13 +8432,7 @@ async function runToolWizard(wizard, configuredKeys) {
       );
       if (hasTabs) {
         const selectedTechs = (config[question.key] || "").split(",").map((v) => v.trim()).filter(Boolean);
-        await renderAsSingleGroup(
-          wizard.questions,
-          question.key,
-          selectedTechs,
-          config,
-          configuredKeys
-        );
+        await renderAsSingleGroup(wizard.questions, question.key, selectedTechs, config, configuredKeys);
         break;
       }
     } else if (question.dependsOn?.contains) {
@@ -8604,7 +8810,7 @@ function printMcpEnvStatus(mcpTools, installedMcpServices, examplesDir, targetDi
   }
 }
 async function printGuide(options) {
-  const { installedSkills, config, targetDir, mcpTools, mcpEnvStubs } = options;
+  const { installedSkills, mcpTools, mcpEnvStubs } = options;
   console.log("");
   console.log("  \u2714 \u914D\u7F6E\u5DF2\u4FDD\u5B58\uFF08DeepStorm \u2192 .deepstorm/settings.json\uFF0CClaude Code \u2192 .claude/settings.json\uFF09");
   if (mcpTools && mcpTools.length > 0) {
@@ -8721,9 +8927,7 @@ function renderTemplate(tmplPath, variables, outputPath) {
 function copyVariants(sourceVariantsDir, selectedValue, targetDir, clean = false) {
   const variantDir = path8.join(sourceVariantsDir, selectedValue);
   if (!fs12.existsSync(variantDir)) {
-    console.warn(
-      `[template] \u26A0 \u53D8\u4F53\u76EE\u5F55\u4E0D\u5B58\u5728: ${variantDir}\uFF08\u76F8\u5BF9\u4E8E ${sourceVariantsDir}\uFF09\uFF0C\u8DF3\u8FC7`
-    );
+    console.warn(`[template] \u26A0 \u53D8\u4F53\u76EE\u5F55\u4E0D\u5B58\u5728: ${variantDir}\uFF08\u76F8\u5BF9\u4E8E ${sourceVariantsDir}\uFF09\uFF0C\u8DF3\u8FC7`);
     return;
   }
   if (clean && fs12.existsSync(targetDir)) {
@@ -8758,10 +8962,10 @@ async function runSetup(reader, targetDir, cliDir2, options, registry2) {
     cleanInstalled(targetDir);
     console.log("\u2714 \u65E7\u5B89\u88C5\u5DF2\u6E05\u7406");
   }
-  let tools = [];
-  let config = {};
+  let tools;
+  let config;
   let selectedMcpTools = [];
-  let templateVariables = {};
+  let templateVariables;
   let enabledMcpJsonServers = [];
   const examplesDir = path9.join(cliDir2, "env-examples");
   const installedSkillIds = [];
@@ -8799,7 +9003,16 @@ async function runSetup(reader, targetDir, cliDir2, options, registry2) {
   }
   installMcpSkills(tools, reader, cliDir2, targetDir, installedSkillIds, selectedMcpTools);
   for (const tool of tools) {
-    const ids = renderToolAssets(tool, reader, cliDir2, targetDir, templateVariables, config, registry2, selectedMcpTools);
+    const ids = renderToolAssets(
+      tool,
+      reader,
+      cliDir2,
+      targetDir,
+      templateVariables,
+      config,
+      registry2,
+      selectedMcpTools
+    );
     installedSkillIds.push(...ids);
   }
   if (shouldInstallGlobalHooks(tools, reader)) {
@@ -8832,8 +9045,8 @@ async function runSetup(reader, targetDir, cliDir2, options, registry2) {
     deepstormConfig.installedMcpServers = [.../* @__PURE__ */ new Set([...existingMcp, ...selectedMcpTools])];
   }
   writeDeepStormConfig(targetDir, deepstormConfig);
-  const frontend = nestedConfig.reef?.frontend?.framework ?? void 0;
-  const backend = nestedConfig.reef?.backend?.language ?? void 0;
+  const frontend = deepstormConfig.reef?.frontend?.framework ?? void 0;
+  const backend = deepstormConfig.reef?.backend?.language ?? void 0;
   initContextMap(targetDir, { frontend, backend, projectName: "" });
   const claudeSettingsPath = path9.join(targetDir, ".claude", "settings.json");
   if (enabledMcpJsonServers.length > 0) {
@@ -8924,11 +9137,7 @@ function renderToolAssets(tool, reader, cliDir2, targetDir, templateVariables, c
         registry2.mcpTools ?? {}
       );
       ensureDir3(targetDirPath);
-      renderTemplate(
-        tmplPath,
-        enrichedVars,
-        path9.join(targetDirPath, "SKILL.md")
-      );
+      renderTemplate(tmplPath, enrichedVars, path9.join(targetDirPath, "SKILL.md"));
       copyVariantsForConfig(variantsDir, config, targetDirPath, skill.configKey);
       copyFragmentsForSkill(skillId, srcDir, config, registry2, targetDirPath);
       copyReferencesForSkill(srcDir, targetDirPath);
@@ -8953,11 +9162,7 @@ function renderToolAssets(tool, reader, cliDir2, targetDir, templateVariables, c
         const tmplSrcPath = path9.join(agentsSrcDir, agentFile.replace(/\.md$/, ".md.tmpl"));
         if (fs13.existsSync(tmplSrcPath)) {
           const outputName = agentFile.replace(/\.tmpl$/, "");
-          renderTemplate(
-            tmplSrcPath,
-            templateVariables,
-            path9.join(targetAgentsDir, outputName)
-          );
+          renderTemplate(tmplSrcPath, templateVariables, path9.join(targetAgentsDir, outputName));
         }
         continue;
       }
@@ -8976,11 +9181,7 @@ function renderToolAssets(tool, reader, cliDir2, targetDir, templateVariables, c
       } else {
         const tmplPath = srcPath + ".tmpl";
         if (fs13.existsSync(tmplPath)) {
-          renderTemplate(
-            tmplPath,
-            templateVariables,
-            path9.join(targetHooksDir, hookFile)
-          );
+          renderTemplate(tmplPath, templateVariables, path9.join(targetHooksDir, hookFile));
         }
       }
     }
@@ -9081,11 +9282,7 @@ function copyFragmentsForSkill(skillId, srcDir, config, registry2, targetDir) {
       for (const file of exampleFiles) {
         if (file === ".DS_Store") continue;
         ensureDir3(targetExamplesDir);
-        fs13.cpSync(
-          path9.join(srcExamples, file),
-          path9.join(targetExamplesDir, `${value}-${file}`),
-          { force: true }
-        );
+        fs13.cpSync(path9.join(srcExamples, file), path9.join(targetExamplesDir, `${value}-${file}`), { force: true });
       }
     }
     const allFiles = fs13.readdirSync(srcPath);
@@ -9305,11 +9502,7 @@ async function buildPlugin(config) {
       }
     }
     if (Object.keys(mcpServers).length > 0) {
-      fs14.writeFileSync(
-        path10.join(outputDir, ".mcp.json"),
-        JSON.stringify({ mcpServers }, null, 2) + "\n",
-        "utf-8"
-      );
+      fs14.writeFileSync(path10.join(outputDir, ".mcp.json"), JSON.stringify({ mcpServers }, null, 2) + "\n", "utf-8");
     }
   }
   if (selectedMcpTools.length > 0) {
@@ -9590,7 +9783,7 @@ function collectLeafPaths(props, prefix, keys) {
   if (!props) return;
   for (const [key, value] of Object.entries(props)) {
     const fullPath = prefix ? `${prefix}.${key}` : key;
-    if (value.properties && typeof value.properties === "object") {
+    if (value.properties) {
       collectLeafPaths(value.properties, fullPath, keys);
     } else {
       keys.add(fullPath);
@@ -9656,9 +9849,7 @@ async function setConfigValue(targetDir, key, value, registry2) {
   if (affected.length === 0) {
     return;
   }
-  const assetNames = affected.map(
-    (t) => t.replace(/\/SKILL\.md\.tmpl$/, "").replace(/\/[^/]+\.md\.tmpl$/, "")
-  );
+  const assetNames = affected.map((t) => t.replace(/\/SKILL\.md\.tmpl$/, "").replace(/\/[^/]+\.md\.tmpl$/, ""));
   console.log("");
   console.log("\u68C0\u6D4B\u5230\u914D\u7F6E\u53D8\u66F4\uFF0C\u9700\u8981\u91CD\u65B0\u751F\u6210\u4EE5\u4E0B\u5185\u5BB9\uFF1A");
   for (const name of assetNames) {
@@ -9750,19 +9941,12 @@ function refreshConfig(cliDir2, targetDir, registry2) {
     const targetSkillDir = path15.join(targetDotClaudeDir, "skills", skillId);
     const outputPath = path15.join(targetSkillDir, "SKILL.md");
     try {
-      const enrichedVars = injectSkillCapabilities(
-        tmplPath,
-        {},
-        installedMcpServers,
-        registry2.mcpTools ?? {}
-      );
+      const enrichedVars = injectSkillCapabilities(tmplPath, {}, installedMcpServers, registry2.mcpTools ?? {});
       fs19.mkdirSync(targetSkillDir, { recursive: true });
       renderTemplate(tmplPath, enrichedVars, outputPath);
       result.refreshed.push(skillId);
     } catch (err) {
-      result.errors.push(
-        `\u5237\u65B0 skill "${skillId}" \u5931\u8D25: ${err instanceof Error ? err.message : String(err)}`
-      );
+      result.errors.push(`\u5237\u65B0 skill "${skillId}" \u5931\u8D25: ${err instanceof Error ? err.message : String(err)}`);
     }
   }
   const mcpCapabilities = buildUnifiedMcpCapabilities2(cliDir2, installedMcpServers, registry2.mcpTools ?? {});
@@ -9844,7 +10028,7 @@ function registerConfigCommand(program2, registry2) {
 // src/commands/template-list.ts
 function listTemplates(registry2, tool) {
   const reader = new RegistryReader(registry2);
-  const skills = tool ? reader.getToolSkills(tool) : Object.entries(registry2.skills).map(([id, entry]) => ({ id, ...entry }));
+  const skills = tool ? reader.getToolSkills(tool).map((s) => ({ ...s, id: "" })) : Object.entries(registry2.skills).map(([id, entry]) => ({ id, ...entry }));
   if (skills.length === 0) {
     console.log("\u6CA1\u6709\u627E\u5230\u53EF\u7528\u7684\u6A21\u677F");
     return;
@@ -9852,7 +10036,7 @@ function listTemplates(registry2, tool) {
   console.log("\u53EF\u7528\u7684\u6A21\u677F:");
   console.log("");
   for (const skill of skills) {
-    const id = "id" in skill ? skill.id : "";
+    const id = skill.id;
     const toolName = skill.tool || "";
     const toolLabel = toolName.charAt(0).toUpperCase() + toolName.slice(1);
     const displayName = skill.name || id;
@@ -9939,10 +10123,7 @@ var fs22 = __toESM(require("node:fs"));
 var path18 = __toESM(require("node:path"));
 function getCliVersion() {
   try {
-    const paths = [
-      path18.resolve(__dirname, "package.json"),
-      path18.resolve(__dirname, "..", "package.json")
-    ];
+    const paths = [path18.resolve(__dirname, "package.json"), path18.resolve(__dirname, "..", "package.json")];
     for (const pkgPath of paths) {
       if (fs22.existsSync(pkgPath)) {
         const pkg = JSON.parse(fs22.readFileSync(pkgPath, "utf-8"));
@@ -9999,11 +10180,7 @@ function loadChecksums(targetDir) {
 function saveChecksums(targetDir, checksums) {
   const dir = path19.join(targetDir, ".claude");
   ensureDir3(dir);
-  fs23.writeFileSync(
-    path19.join(dir, CHECKSUM_FILE),
-    JSON.stringify(checksums, null, 2) + "\n",
-    "utf-8"
-  );
+  fs23.writeFileSync(path19.join(dir, CHECKSUM_FILE), JSON.stringify(checksums, null, 2) + "\n", "utf-8");
 }
 function backupFile(filePath) {
   try {
@@ -10261,8 +10438,10 @@ function upgradeTemplates(cliDir2, targetDir, skillIds) {
     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` : ""}`);
+    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`);
     }
@@ -10448,7 +10627,11 @@ function migrateOldDataSources(targetDir) {
         }
         const cleaned = remainingLines.join("\n").trimEnd();
         if (cleaned === "") {
-          fs24.writeFileSync(envPath, "# \u73AF\u5883 baseURL \u914D\u7F6E\u5DF2\u8FC1\u79FB\u81F3 .deepstorm/settings.json\n# \u8BF7\u52FF\u5728\u6B64\u5904\u91CD\u590D\u5B9A\u4E49 BASE_URL_* \u914D\u7F6E\n", "utf-8");
+          fs24.writeFileSync(
+            envPath,
+            "# \u73AF\u5883 baseURL \u914D\u7F6E\u5DF2\u8FC1\u79FB\u81F3 .deepstorm/settings.json\n# \u8BF7\u52FF\u5728\u6B64\u5904\u91CD\u590D\u5B9A\u4E49 BASE_URL_* \u914D\u7F6E\n",
+            "utf-8"
+          );
         } else if (hasDefaultEnv || Object.keys(baseUrlVars).length > 0) {
           fs24.writeFileSync(envPath, cleaned + "\n", "utf-8");
         }
@@ -10507,13 +10690,453 @@ function registerPilotCommands(program2) {
   (0, import_pilot.registerPilotCommands)(program2);
 }
 
-// src/commands/doctor.ts
-var fs25 = __toESM(require("node:fs"));
+// src/record/browser-recorder.ts
+var path22 = __toESM(require("node:path"));
+var fs26 = __toESM(require("node:fs"));
+var import_node_child_process3 = require("node:child_process");
+
+// src/record/recorder.ts
 var path21 = __toESM(require("node:path"));
+var fs25 = __toESM(require("node:fs"));
+function filterNoiseEvents(events) {
+  const noiseTypes = [];
+  const noiseSet = new Set(noiseTypes);
+  return events.filter((e) => !noiseSet.has(e.type));
+}
+function eventGroupKey(e) {
+  const selector = e.data?.cssSelector || "";
+  return { cssSelector: selector, type: e.type };
+}
+function dedupEvents(events) {
+  if (events.length === 0) return [];
+  const result = [];
+  const inputElements = /* @__PURE__ */ new Map();
+  for (const current of events) {
+    if (current.type === "input" || current.type === "select") {
+      const key = eventGroupKey(current);
+      const dedupKey = `${key.cssSelector}|${key.type}`;
+      inputElements.set(dedupKey, current);
+      continue;
+    }
+    if (current.type === "click") {
+      const lastEvent = result.length > 0 ? result[result.length - 1] : null;
+      if (lastEvent && lastEvent.type === "click") {
+        const currentKey = eventGroupKey(current);
+        const lastKey = eventGroupKey(lastEvent);
+        const sameElement = currentKey.cssSelector === lastKey.cssSelector;
+        const withinThreshold = current.ts - lastEvent.ts <= 500;
+        if (sameElement && withinThreshold) {
+          continue;
+        }
+      }
+    }
+    result.push(current);
+  }
+  inputElements.forEach((event) => {
+    result.push(event);
+  });
+  result.sort((a, b) => a.ts - b.ts);
+  return result;
+}
+function serializeRecording(data) {
+  return JSON.stringify(data, null, 2);
+}
+function buildRecordingFileName(seq = 1) {
+  const now = /* @__PURE__ */ new Date();
+  const pad = (n) => String(n).padStart(2, "0");
+  const dateTime = `${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())}-${pad(now.getHours())}${pad(now.getMinutes())}${pad(now.getSeconds())}`;
+  const seqStr = seq > 1 ? `-${seq}` : "";
+  return `${dateTime}${seqStr}.recording.json`;
+}
+function recordingsDir() {
+  return path21.join(process.cwd(), ".deepstorm", "recordings");
+}
+function getNextSeq(datePrefix) {
+  const dir = recordingsDir();
+  if (!fs25.existsSync(dir)) return 1;
+  const files = fs25.readdirSync(dir).filter((f) => f.startsWith(datePrefix));
+  if (files.length === 0) return 1;
+  let maxSeq = 0;
+  for (const f of files) {
+    const match = f.match(/(?:-(\d+))?\.recording\.json$/);
+    if (match) {
+      const s = match[1] ? parseInt(match[1], 10) : 1;
+      maxSeq = Math.max(maxSeq, s);
+    }
+  }
+  return maxSeq + 1;
+}
+
+// src/record/browser-recorder.ts
+var playwrightModule = null;
+async function getPlaywright() {
+  if (!playwrightModule) {
+    playwrightModule = await import("playwright");
+  }
+  return playwrightModule;
+}
+function isPlaywrightPackageInstalled() {
+  try {
+    require.resolve("playwright");
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function ensurePlaywrightPackage() {
+  if (isPlaywrightPackageInstalled()) return;
+  console.log("\u{1F4E6} \u672A\u68C0\u6D4B\u5230 Playwright\uFF0C\u6B63\u5728\u81EA\u52A8\u5B89\u88C5...");
+  const targetDir = process.cwd();
+  try {
+    (0, import_node_child_process3.execSync)("npm install playwright@latest --no-save", {
+      cwd: targetDir,
+      stdio: "inherit",
+      env: { ...process.env, NODE_ENV: void 0 }
+    });
+  } catch {
+    console.log("npm install \u5931\u8D25\uFF0C\u5C1D\u8BD5\u901A\u8FC7 npx \u5B89\u88C5...");
+    (0, import_node_child_process3.execSync)("npx --yes playwright@latest install --dry-run", {
+      stdio: "inherit"
+    });
+  }
+  if (!isPlaywrightPackageInstalled()) {
+    console.error("\u274C Playwright \u81EA\u52A8\u5B89\u88C5\u5931\u8D25\u3002\u8BF7\u624B\u52A8\u6267\u884C:");
+    console.error("   npm install playwright");
+    process.exit(1);
+  }
+  console.log("\u2705 Playwright \u5B89\u88C5\u6210\u529F");
+}
+async function isPlaywrightBrowserAvailable() {
+  try {
+    const pw = await getPlaywright();
+    const browser = await pw.chromium.launch({ headless: true });
+    await browser.close();
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function ensurePlaywrightBrowsers() {
+  if (await isPlaywrightBrowserAvailable()) return;
+  console.log("\u{1F310} \u672A\u68C0\u6D4B\u5230 Playwright Chromium \u6D4F\u89C8\u5668\uFF0C\u6B63\u5728\u81EA\u52A8\u5B89\u88C5...");
+  try {
+    const pw = await getPlaywright();
+    await pw.chromium.launch({ headless: true, executablePath: void 0 });
+  } catch {
+    try {
+      (0, import_node_child_process3.execSync)("npx playwright install chromium", {
+        stdio: "inherit",
+        env: { ...process.env, PLAYWRIGHT_BROWSERS_PATH: "0" }
+      });
+    } catch {
+      console.error("\u274C \u6D4F\u89C8\u5668\u81EA\u52A8\u5B89\u88C5\u5931\u8D25\u3002\u8BF7\u624B\u52A8\u6267\u884C:");
+      console.error("   npx playwright install chromium");
+      console.error("");
+      console.error("   \u6216\u6307\u5B9A\u5DF2\u5B89\u88C5\u7684\u6D4F\u89C8\u5668\u8DEF\u5F84:");
+      console.error("   export PLAYWRIGHT_CHROMIUM_EXECUTABLE_PATH=/path/to/chrome");
+      process.exit(1);
+    }
+  }
+  if (await isPlaywrightBrowserAvailable()) {
+    console.log("\u2705 \u6D4F\u89C8\u5668\u5B89\u88C5\u6210\u529F");
+  } else {
+    console.error("\u274C \u6D4F\u89C8\u5668\u5B89\u88C5\u540E\u4ECD\u7136\u4E0D\u53EF\u7528\uFF0C\u8BF7\u624B\u52A8\u6267\u884C: npx playwright install chromium");
+    process.exit(1);
+  }
+}
+async function recordBrowserSession(url) {
+  let targetUrl;
+  try {
+    targetUrl = new URL(url);
+  } catch {
+    throw new Error(`\u65E0\u6548\u7684 URL: ${url}`);
+  }
+  await ensurePlaywrightPackage();
+  await ensurePlaywrightBrowsers();
+  const pw = await getPlaywright();
+  const startTime = Date.now();
+  const browser = await pw.chromium.launch({ headless: false });
+  const context = await browser.newContext();
+  const page = await context.newPage();
+  const events = [];
+  const requestMethods = /* @__PURE__ */ new Map();
+  const cdpSession = await context.newCDPSession(page);
+  cdpSession.on("Network.requestWillBeSent", (params) => {
+    const { request, type, requestId } = params;
+    requestMethods.set(requestId, request.method);
+    if (type === "XHR" || type === "Fetch") {
+      events.push({
+        ts: Date.now() - startTime,
+        type: "network",
+        data: {
+          url: request.url,
+          method: request.method,
+          type: "request"
+        }
+      });
+    }
+  });
+  cdpSession.on("Network.responseReceived", (params) => {
+    const { response, type, requestId } = params;
+    const method = requestMethods.get(requestId) ?? "GET";
+    if (type === "XHR" || type === "Fetch") {
+      events.push({
+        ts: Date.now() - startTime,
+        type: "network",
+        data: {
+          url: response.url,
+          method,
+          statusCode: response.status,
+          type: "response"
+        }
+      });
+    }
+  });
+  cdpSession.on("Page.frameNavigated", (params) => {
+    const { frame } = params;
+    if (frame.parentId === void 0 || frame.parentId === null) {
+      events.push({
+        ts: Date.now() - startTime,
+        type: "navigation",
+        data: {
+          url: frame.url,
+          title: frame.name || frame.url,
+          type: "full"
+        }
+      });
+    }
+  });
+  cdpSession.on("Page.navigatedWithinDocument", (params) => {
+    events.push({
+      ts: Date.now() - startTime,
+      type: "navigation",
+      data: {
+        url: params.url,
+        type: "spa"
+      }
+    });
+  });
+  await page.exposeFunction("__deepstorm_recordEvent", (type, data) => {
+    events.push({
+      ts: Date.now() - startTime,
+      type,
+      data
+    });
+  });
+  await page.goto(targetUrl.href);
+  await page.evaluate(`(function() {
+    var send = window.__deepstorm_recordEvent;
+
+    // Click listener (capture phase)
+    document.addEventListener('click', function(e) {
+      var target = e.target;
+      if (!target || target === document.body || target === document.documentElement) return;
+
+      var info = {
+        tagName: target.tagName.toLowerCase(),
+        id: target.id || undefined,
+        className: (target.className || '').toString().slice(0, 100) || undefined,
+        textContent: (target.textContent || '').trim().slice(0, 100) || undefined
+      };
+
+      var role = target.getAttribute('role');
+      if (role) info.role = role;
+      var ariaLabel = target.getAttribute('aria-label');
+      if (ariaLabel) info.ariaLabel = ariaLabel;
+      var placeholder = target.getAttribute('placeholder');
+      if (placeholder) info.placeholder = placeholder;
+      var dataTestId = target.getAttribute('data-testid');
+      if (dataTestId) info.dataTestId = dataTestId;
+
+      info.cssSelector = buildSimpleSelector(target);
+      send('click', info);
+    }, true);
+
+    // Input listener (change event for final value)
+    document.addEventListener('change', function(e) {
+      var target = e.target;
+      if (!target) return;
+
+      if (target.tagName === 'SELECT') {
+        send('select', {
+          tagName: 'select',
+          value: target.value,
+          name: target.name || undefined,
+          cssSelector: buildSimpleSelector(target)
+        });
+        return;
+      }
+
+      if (target.type === 'password') {
+        send('input', {
+          tagName: target.tagName.toLowerCase(),
+          type: 'password',
+          value: '****',
+          name: target.name || undefined,
+          placeholder: target.placeholder || undefined,
+          cssSelector: buildSimpleSelector(target)
+        });
+        return;
+      }
+
+      send('input', {
+        tagName: target.tagName.toLowerCase(),
+        type: target.type || undefined,
+        value: target.value,
+        name: target.name || undefined,
+        placeholder: target.placeholder || undefined,
+        cssSelector: buildSimpleSelector(target)
+      });
+    }, true);
+
+    // Submit listener
+    document.addEventListener('submit', function(e) {
+      var form = e.target;
+      if (!form) return;
+      send('submit', {
+        cssSelector: buildSimpleSelector(form),
+        id: form.id || undefined,
+        action: form.action || undefined
+      });
+    }, true);
+
+    // Helper: build simple CSS selector
+    function buildSimpleSelector(el) {
+      if (el.id) return '#' + CSS.escape(el.id);
+      var testId = el.getAttribute('data-testid');
+      if (testId) return '[data-testid="' + CSS.escape(testId) + '"]';
+      var tag = el.tagName.toLowerCase();
+      var cls = '';
+      for (var i = 0; i < el.classList.length; i++) {
+        cls += '.' + CSS.escape(el.classList[i]);
+      }
+      if (cls) return tag + cls;
+      var parent = el.parentElement;
+      if (parent) {
+        var siblings = Array.from(parent.children).filter(function(s) {
+          return s.tagName === el.tagName;
+        });
+        if (siblings.length > 1) {
+          var idx = siblings.indexOf(el) + 1;
+          return tag + ':nth-child(' + idx + ')';
+        }
+      }
+      return tag;
+    }
+  })();`);
+  console.log("\u{1F3A5} \u5F55\u5236\u4E2D... \u6309 Ctrl+D \u505C\u6B62");
+  const stopPromise = new Promise((resolve4) => {
+    let rawModeSupported = false;
+    try {
+      process.stdin.setRawMode?.(true);
+      rawModeSupported = true;
+    } catch {
+      console.log("\u24D8 \u5F53\u524D\u7EC8\u7AEF\u4E0D\u652F\u6301 raw mode\uFF0C\u8BF7\u5173\u95ED\u6D4F\u89C8\u5668\u7A97\u53E3\u505C\u6B62\u5F55\u5236");
+    }
+    process.stdin.resume();
+    process.stdin.on("data", (chunk) => {
+      if (chunk.length === 1 && chunk[0] === 4) {
+        cleanup();
+        resolve4();
+      }
+    });
+    process.stdin.on("end", () => {
+      cleanup();
+      resolve4();
+    });
+    function cleanup() {
+      if (rawModeSupported) {
+        try {
+          process.stdin.setRawMode?.(false);
+        } catch {
+        }
+      }
+      process.stdin.pause();
+    }
+  });
+  const crashPromise = new Promise((_resolve, reject) => {
+    browser.on("disconnected", () => {
+      reject(new Error("\u6D4F\u89C8\u5668\u8FDE\u63A5\u65AD\u5F00"));
+    });
+  });
+  try {
+    await Promise.race([stopPromise, crashPromise]);
+  } catch (err) {
+    console.error("\n\u6D4F\u89C8\u5668\u8FDE\u63A5\u65AD\u5F00\uFF0C\u5F55\u5236\u5DF2\u7EC8\u6B62");
+    throw err;
+  } finally {
+    try {
+      process.stdin.setRawMode?.(false);
+    } catch {
+    }
+    process.stdin.pause();
+  }
+  const duration = Date.now() - startTime;
+  try {
+    const screenshotBuffer = await page.screenshot({ type: "jpeg", quality: 70 });
+    events.push({
+      ts: Date.now() - startTime,
+      type: "screenshot",
+      data: {
+        label: "final",
+        data: screenshotBuffer.toString("base64")
+      }
+    });
+  } catch {
+  }
+  await browser.close();
+  const filteredEvents = dedupEvents(filterNoiseEvents(events));
+  const recordingData = {
+    meta: {
+      url: targetUrl.href,
+      recordedAt: new Date(startTime).toISOString(),
+      duration,
+      browser: `Playwright Chromium ${browser.version()}`
+    },
+    events: filteredEvents
+  };
+  const dir = recordingsDir();
+  fs26.mkdirSync(dir, { recursive: true });
+  const datePrefix = buildRecordingFileName().replace(".recording.json", "");
+  const seq = getNextSeq(datePrefix);
+  const fileName = buildRecordingFileName(seq);
+  const filePath = path22.join(dir, fileName);
+  fs26.writeFileSync(filePath, serializeRecording(recordingData), "utf-8");
+  console.log(`
+\u2705 \u5F55\u5236\u5B8C\u6210`);
+  console.log(`   \u6301\u7EED\u65F6\u95F4: ${(duration / 1e3).toFixed(1)} \u79D2`);
+  console.log(`   \u4E8B\u4EF6\u603B\u6570: ${filteredEvents.length}`);
+  console.log(`   \u6587\u4EF6\u8DEF\u5F84: ${filePath}`);
+  return filePath;
+}
+
+// src/commands/record.ts
+function registerRecordCommand(program2) {
+  const recordCmd = program2.command("record").description("\u6D4F\u89C8\u5668\u64CD\u4F5C\u5F55\u5236 \u2014 \u542F\u52A8 headed \u6D4F\u89C8\u5668\u5F55\u5236\u7528\u6237\u64CD\u4F5C\uFF0C\u8F93\u51FA .recording.json");
+  recordCmd.command("start").description("\u5F00\u59CB\u5F55\u5236 \u2014 \u542F\u52A8 headed \u6D4F\u89C8\u5668\u5E76\u6253\u5F00\u6307\u5B9A URL").option("-u, --url <url>", "\u76EE\u6807 URL").action(async (options) => {
+    if (!options.url) {
+      console.error("\u8BF7\u4F7F\u7528 -u <url> \u6307\u5B9A\u76EE\u6807 URL");
+      process.exit(1);
+    }
+    try {
+      await recordBrowserSession(options.url);
+    } catch (err) {
+      console.error("\u5F55\u5236\u5931\u8D25:", err instanceof Error ? err.message : err);
+      process.exit(1);
+    }
+  });
+  recordCmd.command("stop").description("\u505C\u6B62\u5F55\u5236 \u2014 \u505C\u6B62\u5F53\u524D\u5F55\u5236\u5E76\u5199\u5165\u6587\u4EF6").action(() => {
+    console.log("\u8BF7\u5728\u5F55\u5236\u7EC8\u7AEF\u6309 Ctrl+D \u505C\u6B62\u5F55\u5236");
+  });
+}
+
+// src/commands/doctor.ts
+var fs27 = __toESM(require("node:fs"));
+var path23 = __toESM(require("node:path"));
 function getInstalledSkills(targetDir) {
   const settingsPath = getDeepStormConfigPath(targetDir);
   try {
-    const settings = JSON.parse(fs25.readFileSync(settingsPath, "utf-8"));
+    const settings = JSON.parse(fs27.readFileSync(settingsPath, "utf-8"));
     return settings.installedSkills || [];
   } catch {
     return [];
@@ -10530,7 +11153,7 @@ function runDoctor(targetDir) {
     message: `v${version}\uFF08\u8FD0\u884C deepstorm update \u68C0\u67E5\u6700\u65B0\u7248\u672C\uFF09`
   });
   let hasDeepStorm = false;
-  if (!fs25.existsSync(settingsPath)) {
+  if (!fs27.existsSync(settingsPath)) {
     checks.push({
       name: "\u914D\u7F6E\u6587\u4EF6",
       status: "warn",
@@ -10538,7 +11161,7 @@ function runDoctor(targetDir) {
     });
   } else {
     try {
-      const config = JSON.parse(fs25.readFileSync(settingsPath, "utf-8"));
+      const config = JSON.parse(fs27.readFileSync(settingsPath, "utf-8"));
       if (config && Object.keys(config).length > 0) {
         hasDeepStorm = true;
         checks.push({
@@ -10561,20 +11184,18 @@ function runDoctor(targetDir) {
       });
     }
   }
-  const skillsDir = path21.join(targetDir, ".claude", "skills");
-  if (fs25.existsSync(skillsDir)) {
-    const skillDirs = fs25.readdirSync(skillsDir).filter(
-      (n) => fs25.statSync(path21.join(skillsDir, n)).isDirectory()
-    );
+  const skillsDir = path23.join(targetDir, ".claude", "skills");
+  if (fs27.existsSync(skillsDir)) {
+    const skillDirs = fs27.readdirSync(skillsDir).filter((n) => fs27.statSync(path23.join(skillsDir, n)).isDirectory());
     let validCount = 0;
     let invalidCount = 0;
     for (const skillName of skillDirs) {
-      const skillMd = path21.join(skillsDir, skillName, "SKILL.md");
-      if (!fs25.existsSync(skillMd)) {
+      const skillMd = path23.join(skillsDir, skillName, "SKILL.md");
+      if (!fs27.existsSync(skillMd)) {
         invalidCount++;
         continue;
       }
-      const content = fs25.readFileSync(skillMd, "utf-8");
+      const content = fs27.readFileSync(skillMd, "utf-8");
       const frontmatter = parseFrontmatter(content);
       if (frontmatter && frontmatter.name) {
         validCount++;
@@ -10604,7 +11225,7 @@ function runDoctor(targetDir) {
     const installedSkills = getInstalledSkills(targetDir);
     const missingSkills = [];
     for (const skillId of installedSkills) {
-      if (!fs25.existsSync(path21.join(skillsDir, skillId))) {
+      if (!fs27.existsSync(path23.join(skillsDir, skillId))) {
         missingSkills.push(skillId);
       }
     }
@@ -10628,10 +11249,10 @@ function runDoctor(targetDir) {
       message: ".claude/skills/ \u4E0D\u5B58\u5728"
     });
   }
-  const mcpPath = path21.join(targetDir, ".mcp.json");
-  if (fs25.existsSync(mcpPath)) {
+  const mcpPath = path23.join(targetDir, ".mcp.json");
+  if (fs27.existsSync(mcpPath)) {
     try {
-      const mcp = JSON.parse(fs25.readFileSync(mcpPath, "utf-8"));
+      const mcp = JSON.parse(fs27.readFileSync(mcpPath, "utf-8"));
       const hasServers = mcp.mcpServers && Object.keys(mcp.mcpServers).length > 0;
       checks.push({
         name: "MCP \u670D\u52A1\u5668",
@@ -10652,12 +11273,12 @@ function runDoctor(targetDir) {
       message: ".mcp.json \u4E0D\u5B58\u5728"
     });
   }
-  if (hasDeepStorm && fs25.existsSync(settingsPath)) {
+  if (hasDeepStorm && fs27.existsSync(settingsPath)) {
     try {
-      const config = JSON.parse(fs25.readFileSync(settingsPath, "utf-8"));
+      const config = JSON.parse(fs27.readFileSync(settingsPath, "utf-8"));
       const installedMcp = config.installedMcpServers;
       if (installedMcp && installedMcp.length > 0) {
-        const mcpExists = fs25.existsSync(mcpPath);
+        const mcpExists = fs27.existsSync(mcpPath);
         if (!mcpExists) {
           checks.push({
             name: "MCP \u4E00\u81F4\u6027",
@@ -10666,7 +11287,7 @@ function runDoctor(targetDir) {
           });
         } else {
           try {
-            const mcpConfig = JSON.parse(fs25.readFileSync(mcpPath, "utf-8"));
+            const mcpConfig = JSON.parse(fs27.readFileSync(mcpPath, "utf-8"));
             const servers = mcpConfig.mcpServers || {};
             const missing = [];
             for (const toolName of installedMcp) {
@@ -10694,9 +11315,9 @@ function runDoctor(targetDir) {
     } catch {
     }
   }
-  if (hasDeepStorm && fs25.existsSync(settingsPath)) {
+  if (hasDeepStorm && fs27.existsSync(settingsPath)) {
     try {
-      const config = JSON.parse(fs25.readFileSync(settingsPath, "utf-8"));
+      const config = JSON.parse(fs27.readFileSync(settingsPath, "utf-8"));
       const validKeys = loadValidConfigKeys();
       if (validKeys.size > 0 && config) {
         const configKeys = [];
@@ -10749,18 +11370,18 @@ function printDoctorReport(report) {
 }
 
 // src/commands/uninstall.ts
-var fs26 = __toESM(require("node:fs"));
-var path22 = __toESM(require("node:path"));
+var fs28 = __toESM(require("node:fs"));
+var path24 = __toESM(require("node:path"));
 var import_prompts4 = require("@clack/prompts");
 async function uninstallDeepStorm(targetDir) {
   const settingsPath = getDeepStormConfigPath(targetDir);
-  if (!fs26.existsSync(settingsPath)) {
+  if (!fs28.existsSync(settingsPath)) {
     console.log("DeepStorm \u5C1A\u672A\u914D\u7F6E\uFF0C\u65E0\u9700\u5378\u8F7D");
     return;
   }
   let hasDeepStorm = false;
   try {
-    const settings = JSON.parse(fs26.readFileSync(settingsPath, "utf-8"));
+    const settings = JSON.parse(fs28.readFileSync(settingsPath, "utf-8"));
     hasDeepStorm = !!settings && Object.keys(settings).length > 0;
   } catch {
   }
@@ -10770,14 +11391,14 @@ async function uninstallDeepStorm(targetDir) {
   }
   cleanInstalled(targetDir);
   resetConfig(targetDir);
-  const templatesDir = path22.join(targetDir, ".deepstorm", "templates");
-  if (fs26.existsSync(templatesDir)) {
+  const templatesDir = path24.join(targetDir, ".deepstorm", "templates");
+  if (fs28.existsSync(templatesDir)) {
     const shouldDelete = await (0, import_prompts4.confirm)({
       message: "\u662F\u5426\u5220\u9664 .deepstorm/templates/ \u76EE\u5F55\uFF1F",
       initialValue: false
     });
     if (shouldDelete) {
-      fs26.rmSync(templatesDir, { recursive: true, force: true });
+      fs28.rmSync(templatesDir, { recursive: true, force: true });
       console.log("\u2714 .deepstorm/templates/ \u5DF2\u5220\u9664");
     } else {
       console.log("\u4FDD\u7559 .deepstorm/templates/");
@@ -10790,9 +11411,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 = path23.join(__dirname, "registry.json");
+  const registryPath = path25.join(__dirname, "registry.json");
   try {
-    const raw = fs27.readFileSync(registryPath, "utf-8");
+    const raw = fs29.readFileSync(registryPath, "utf-8");
     return JSON.parse(raw);
   } catch {
     return { version: "1", tools: {}, wizards: {}, skills: {} };
@@ -10806,6 +11427,7 @@ registerConfigCommand(program, registry);
 registerTemplateCommand(program, registry);
 registerUpdateCommand(program);
 registerPilotCommands(program);
+registerRecordCommand(program);
 program.command("doctor").description("\u8BCA\u65AD\u9879\u76EE DeepStorm \u914D\u7F6E\u72B6\u6001").action(() => {
   const report = runDoctor(process.cwd());
   printDoctorReport(report);