@deepstorm/cli 0.11.0 → 0.11.1

package/dist/cli.js

@@ -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");
         }
@@ -10510,7 +10693,7 @@ function registerPilotCommands(program2) {
 // src/record/browser-recorder.ts
 var path22 = __toESM(require("node:path"));
 var fs26 = __toESM(require("node:fs"));
-var import_playwright = require("playwright");
+var import_node_child_process3 = require("node:child_process");
 
 // src/record/recorder.ts
 var path21 = __toESM(require("node:path"));
@@ -10528,8 +10711,7 @@ function dedupEvents(events) {
   if (events.length === 0) return [];
   const result = [];
   const inputElements = /* @__PURE__ */ new Map();
-  for (let i = 0; i < events.length; i++) {
-    const current = events[i];
+  for (const current of events) {
     if (current.type === "input" || current.type === "select") {
       const key = eventGroupKey(current);
       const dedupKey = `${key.cssSelector}|${key.type}`;
@@ -10586,6 +10768,82 @@ function getNextSeq(datePrefix) {
 }
 
 // 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 {
@@ -10593,12 +10851,11 @@ async function recordBrowserSession(url) {
   } catch {
     throw new Error(`\u65E0\u6548\u7684 URL: ${url}`);
   }
-  if (!await isPlaywrightAvailable()) {
-    console.error("Playwright \u6D4F\u89C8\u5668\u672A\u5B89\u88C5\uFF0C\u8BF7\u6267\u884C npx playwright install");
-    process.exit(1);
-  }
+  await ensurePlaywrightPackage();
+  await ensurePlaywrightBrowsers();
+  const pw = await getPlaywright();
   const startTime = Date.now();
-  const browser = await import_playwright.chromium.launch({ headless: false });
+  const browser = await pw.chromium.launch({ headless: false });
   const context = await browser.newContext();
   const page = await context.newPage();
   const events = [];
@@ -10769,8 +11026,13 @@ async function recordBrowserSession(url) {
   })();`);
   console.log("\u{1F3A5} \u5F55\u5236\u4E2D... \u6309 Ctrl+D \u505C\u6B62");
   const stopPromise = new Promise((resolve4) => {
-    const wasRaw = process.stdin.isRaw;
-    process.stdin.setRawMode?.(true);
+    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) {
@@ -10783,7 +11045,12 @@ async function recordBrowserSession(url) {
       resolve4();
     });
     function cleanup() {
-      process.stdin.setRawMode?.(wasRaw ?? false);
+      if (rawModeSupported) {
+        try {
+          process.stdin.setRawMode?.(false);
+        } catch {
+        }
+      }
       process.stdin.pause();
     }
   });
@@ -10798,7 +11065,10 @@ async function recordBrowserSession(url) {
     console.error("\n\u6D4F\u89C8\u5668\u8FDE\u63A5\u65AD\u5F00\uFF0C\u5F55\u5236\u5DF2\u7EC8\u6B62");
     throw err;
   } finally {
-    process.stdin.setRawMode?.(false);
+    try {
+      process.stdin.setRawMode?.(false);
+    } catch {
+    }
     process.stdin.pause();
   }
   const duration = Date.now() - startTime;
@@ -10839,20 +11109,6 @@ async function recordBrowserSession(url) {
   console.log(`   \u6587\u4EF6\u8DEF\u5F84: ${filePath}`);
   return filePath;
 }
-async function isPlaywrightAvailable() {
-  try {
-    const { execSync: execSync3 } = await import("node:child_process");
-    execSync3(
-      "npx playwright install --dry-run 2>/dev/null || npx playwright --version 2>/dev/null",
-      { stdio: "ignore" }
-    );
-    const browser = await import_playwright.chromium.launch({ headless: true });
-    await browser.close();
-    return true;
-  } catch {
-    return false;
-  }
-}
 
 // src/commands/record.ts
 function registerRecordCommand(program2) {
@@ -10930,9 +11186,7 @@ function runDoctor(targetDir) {
   }
   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()
-    );
+    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) {