@chatbi-v/cli 2.1.10 → 3.0.0

package/dist/index.js

@@ -8,42 +8,171 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// ../../node_modules/.pnpm/tsup@8.5.1_jiti@2.6.1_postcss@8.5.6_tsx@4.21.0_typescript@5.9.3_yaml@2.8.2/node_modules/tsup/assets/esm_shims.js
+// ../../node_modules/.pnpm/tsup@8.5.1_jiti@2.6.1_postcss@8.5.8_tsx@4.21.0_typescript@5.9.3_yaml@2.8.2/node_modules/tsup/assets/esm_shims.js
 import path from "path";
 import { fileURLToPath } from "url";
 var init_esm_shims = __esm({
-  "../../node_modules/.pnpm/tsup@8.5.1_jiti@2.6.1_postcss@8.5.6_tsx@4.21.0_typescript@5.9.3_yaml@2.8.2/node_modules/tsup/assets/esm_shims.js"() {
+  "../../node_modules/.pnpm/tsup@8.5.1_jiti@2.6.1_postcss@8.5.8_tsx@4.21.0_typescript@5.9.3_yaml@2.8.2/node_modules/tsup/assets/esm_shims.js"() {
     "use strict";
   }
 });
 
-// src/constants.ts
+// package.json
+var package_default;
+var init_package = __esm({
+  "package.json"() {
+    package_default = {
+      name: "@chatbi-v/cli",
+      version: "3.0.0",
+      description: "Standardized CLI tooling for ChatBI Monorepo",
+      type: "module",
+      main: "dist/index.js",
+      module: "dist/index.js",
+      types: "dist/index.d.ts",
+      exports: {
+        ".": {
+          types: "./dist/index.d.ts",
+          import: "./dist/index.js"
+        },
+        "./package.json": "./package.json"
+      },
+      bin: {
+        "chatbi-cli": "./bin/chatbi-cli.js"
+      },
+      files: [
+        "dist",
+        "bin",
+        "templates"
+      ],
+      publishConfig: {
+        access: "public"
+      },
+      scripts: {
+        build: "tsup",
+        dev: "tsup --watch",
+        test: "vitest"
+      },
+      dependencies: {
+        boxen: "^8.0.1",
+        cac: "^6.7.14",
+        execa: "^8.0.1",
+        "fast-glob": "^3.3.3",
+        figlet: "^1.9.4",
+        "fs-extra": "^11.2.0",
+        "gradient-string": "^3.0.0",
+        handlebars: "^4.7.8",
+        jiti: "^2.6.1",
+        ora: "^7.0.1",
+        picocolors: "^1.0.0",
+        prompts: "^2.4.2",
+        vite: "^5.4.11"
+      },
+      devDependencies: {
+        tsup: "^8.5.1",
+        typescript: "^5.0.0",
+        "@types/eslint": "^9.6.1",
+        "@types/boxen": "^3.0.5",
+        "@types/figlet": "^1.7.0",
+        "@types/fs-extra": "^11.0.0",
+        "@types/gradient-string": "^1.1.6",
+        "@types/node": "^20.0.0",
+        "@types/prompts": "^2.4.9",
+        "@vitest/coverage-v8": "1.6.1",
+        vitest: "^1.0.0",
+        eslint: "^9.17.0",
+        "@chatbi-v/eslint-plugin-theme": "workspace:*"
+      }
+    };
+  }
+});
+
+// src/config/defaults.ts
 import os from "os";
 import path2 from "path";
-var SANDBOX_CONFIG, GLOBAL_PATHS, DEPENDENCY_VERSIONS, DEFAULT_CONFIG;
-var init_constants = __esm({
-  "src/constants.ts"() {
+function loadStringArrayFromEnv(envKey, defaultValue) {
+  const envValue = process.env[envKey];
+  if (!envValue) return defaultValue;
+  return envValue.split(",").map((s) => s.trim()).filter(Boolean);
+}
+function loadStringFromEnv(envKey, defaultValue) {
+  const envValue = process.env[envKey];
+  return envValue || defaultValue;
+}
+function loadNumberFromEnv(envKey, defaultValue) {
+  const envValue = process.env[envKey];
+  if (!envValue) return defaultValue;
+  const parsed = parseInt(envValue, 10);
+  return isNaN(parsed) ? defaultValue : parsed;
+}
+function loadConfig() {
+  const sandbox = {
+    baseName: loadStringFromEnv("CHATBI_SANDBOX_NAME", DEFAULT_SANDBOX.baseName),
+    dirs: {
+      versions: loadStringFromEnv("CHATBI_SANDBOX_VERSIONS_DIR", DEFAULT_SANDBOX.dirs.versions),
+      current: loadStringFromEnv("CHATBI_SANDBOX_CURRENT_DIR", DEFAULT_SANDBOX.dirs.current),
+      cache: loadStringFromEnv("CHATBI_SANDBOX_CACHE_DIR", DEFAULT_SANDBOX.dirs.cache)
+    },
+    lockFile: loadStringFromEnv("CHATBI_LOCK_FILE", DEFAULT_SANDBOX.lockFile)
+  };
+  const baseDir = loadStringFromEnv("CHATBI_BASE_DIR", DEFAULT_CACHE.cacheDir);
+  const paths = {
+    baseDir,
+    monorepoRoots: loadStringArrayFromEnv("CHATBI_MONOREPO_ROOTS", DEFAULT_PATHS.monorepoRoots)
+  };
+  const depsEnv = process.env["CHATBI_DEPENDENCY_VERSIONS"];
+  let dependencies;
+  if (depsEnv) {
+    try {
+      dependencies = JSON.parse(depsEnv);
+    } catch {
+      dependencies = {};
+      depsEnv.split(",").forEach((pair) => {
+        const [key, value] = pair.split("=");
+        if (key && value) dependencies[key.trim()] = value.trim();
+      });
+      if (Object.keys(dependencies).length === 0) {
+        dependencies = DEFAULT_DEPENDENCIES;
+      }
+    }
+  } else {
+    dependencies = { ...DEFAULT_DEPENDENCIES };
+  }
+  const defaults = {
+    configFiles: loadStringArrayFromEnv("CHATBI_CONFIG_FILES", DEFAULT_DEFAULTS.configFiles),
+    theme: loadStringFromEnv("CHATBI_THEME", DEFAULT_DEFAULTS.theme)
+  };
+  const runtime = {
+    corePackages: loadStringArrayFromEnv("CHATBI_CORE_PACKAGES", DEFAULT_RUNTIME.corePackages),
+    runtimeDeps: loadStringArrayFromEnv("CHATBI_RUNTIME_DEPS", DEFAULT_RUNTIME.runtimeDeps)
+  };
+  const cache = {
+    updateCheckInterval: loadNumberFromEnv("CHATBI_UPDATE_INTERVAL", DEFAULT_CACHE.updateCheckInterval),
+    cacheDir: loadStringFromEnv("CHATBI_CACHE_DIR", DEFAULT_CACHE.cacheDir),
+    cacheFile: path2.join(
+      loadStringFromEnv("CHATBI_CACHE_DIR", DEFAULT_CACHE.cacheDir),
+      ".update-check.json"
+    )
+  };
+  return { sandbox, paths, dependencies, defaults, runtime, cache };
+}
+var DEFAULT_SANDBOX, DEFAULT_PATHS, DEFAULT_DEPENDENCIES, DEFAULT_DEFAULTS, DEFAULT_RUNTIME, DEFAULT_CACHE;
+var init_defaults = __esm({
+  "src/config/defaults.ts"() {
     "use strict";
     init_esm_shims();
-    SANDBOX_CONFIG = {
-      /** 用户主目录下的沙箱根目录名 */
-      BASE_NAME: ".chatbi-v-core",
-      /** 内部子目录结构 */
-      DIRS: {
-        VERSIONS: "versions",
-        CURRENT: "current",
-        CACHE: ".chatbi"
+    DEFAULT_SANDBOX = {
+      baseName: ".chatbi-v-core",
+      dirs: {
+        versions: "versions",
+        current: "current",
+        cache: ".chatbi"
       },
-      /** 关键标识文件 */
-      LOCK_FILE: ".chatbi-version"
+      lockFile: ".chatbi-version"
     };
-    GLOBAL_PATHS = {
-      /** 沙箱根路径 */
-      BASE_DIR: path2.join(os.homedir(), SANDBOX_CONFIG.BASE_NAME),
-      /** Monorepo 扫描目录 */
-      MONOREPO_ROOTS: ["apps", "plugins", "packages"]
+    DEFAULT_PATHS = {
+      monorepoRoots: ["apps", "plugins", "packages"]
     };
-    DEPENDENCY_VERSIONS = {
+    DEFAULT_DEPENDENCIES = {
       // 基础框架
       "react": "^18.3.1",
       "react-dom": "^18.3.1",
@@ -61,41 +190,82 @@ var init_constants = __esm({
       "@types/node": "^20.11.20",
       "@vitejs/plugin-react": "^4.2.1"
     };
-    DEFAULT_CONFIG = {
-      /** 支持的配置文件名 */
-      CONFIG_FILES: [
+    DEFAULT_DEFAULTS = {
+      configFiles: [
         "chatbi.config.ts",
         "chatbi.config.js",
         "chatbi.config.json",
         ".chatbirc"
       ],
-      /** 默认 UI 主题 */
-      THEME: "standard"
+      theme: "standard"
+    };
+    DEFAULT_RUNTIME = {
+      corePackages: [
+        "@chatbi-v/core",
+        "@chatbi-v/mocks",
+        "@chatbi-v/config"
+      ],
+      runtimeDeps: [
+        "@ant-design/x",
+        "@ant-design/icons",
+        "antd",
+        "react",
+        "react-dom",
+        "lucide-react",
+        "framer-motion",
+        "clsx",
+        "tailwind-merge",
+        "react-router-dom",
+        "zustand",
+        "axios",
+        "less",
+        "vite"
+      ]
+    };
+    DEFAULT_CACHE = {
+      updateCheckInterval: 1e3 * 60 * 60 * 24,
+      // 24 hours
+      cacheDir: path2.join(os.homedir(), ".chatbi-v-core"),
+      cacheFile: path2.join(os.homedir(), ".chatbi-v-core", ".update-check.json")
     };
   }
 });
 
+// src/config/index.ts
+var init_config = __esm({
+  "src/config/index.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_defaults();
+  }
+});
+
 // src/utils.ts
 import boxen from "boxen";
 import { execa } from "execa";
 import fs from "fs-extra";
 import { createRequire } from "module";
-import os2 from "os";
 import ora from "ora";
 import path3 from "path";
 import pc from "picocolors";
 import { fileURLToPath as fileURLToPath2 } from "url";
-var _require, _filename, _dirname, UPDATE_CHECK_INTERVAL, CACHE_DIR, CACHE_FILE, logger, createSpinner, printBox, findPackageRoot, getCliRoot, checkForUpdates, printUpdateNotification;
+var _require, _filename, _dirname, config, UPDATE_CHECK_INTERVAL, CACHE_DIR, CACHE_FILE, isDebug, setDebugMode, logger, createSpinner, printBox, findPackageRoot, getCliRoot, checkForUpdates, printUpdateNotification;
 var init_utils = __esm({
   "src/utils.ts"() {
     "use strict";
     init_esm_shims();
+    init_config();
     _require = createRequire(import.meta.url);
     _filename = fileURLToPath2(import.meta.url);
     _dirname = path3.dirname(_filename);
-    UPDATE_CHECK_INTERVAL = 1e3 * 60 * 60 * 24;
-    CACHE_DIR = path3.join(os2.homedir(), ".chatbi-v-core");
-    CACHE_FILE = path3.join(CACHE_DIR, ".update-check.json");
+    config = loadConfig();
+    UPDATE_CHECK_INTERVAL = config.cache.updateCheckInterval;
+    CACHE_DIR = config.cache.cacheDir;
+    CACHE_FILE = config.cache.cacheFile;
+    isDebug = false;
+    setDebugMode = (debug) => {
+      isDebug = debug;
+    };
     logger = {
       info: (msg) => console.log(pc.cyan(`\u2139 ${msg}`)),
       success: (msg) => console.log(pc.green(`\u2714 ${msg}`)),
@@ -111,6 +281,11 @@ var init_utils = __esm({
           }
         }
       },
+      debug: (msg) => {
+        if (isDebug) {
+          console.log(pc.gray(`[DEBUG] ${msg}`));
+        }
+      },
       bold: (msg) => pc.bold(msg),
       cyan: (msg) => pc.cyan(msg),
       green: (msg) => pc.green(msg),
@@ -120,7 +295,9 @@ var init_utils = __esm({
     };
     createSpinner = (msg) => ora({
       text: pc.cyan(msg),
-      color: "cyan"
+      color: "cyan",
+      isEnabled: !isDebug
+      // Debug 模式下禁用 spinner 以避免日志混乱
     });
     printBox = (msg, title, options = {}) => {
       console.log("\n" + boxen(msg, {
@@ -136,7 +313,7 @@ var init_utils = __esm({
       try {
         const pkgPath = _require.resolve(`${pkgName}/package.json`);
         return path3.dirname(pkgPath);
-      } catch (e) {
+      } catch {
         if (pkgName === "@chatbi-v/cli") {
           return path3.resolve(_dirname, "../../");
         }
@@ -170,7 +347,9 @@ var init_utils = __esm({
         }
         const now = Date.now();
         if (now - cache.lastCheck > UPDATE_CHECK_INTERVAL) {
-          execa("npm", ["view", "@chatbi-v/cli", "version"]).then(async ({ stdout }) => {
+          const subprocess = execa("npm", ["view", "@chatbi-v/cli", "version"]);
+          subprocess.unref();
+          subprocess.then(async ({ stdout }) => {
             const latest = stdout.trim();
             await fs.writeJson(CACHE_FILE, {
               lastCheck: now,
@@ -185,7 +364,7 @@ var init_utils = __esm({
             return cache.latestVersion;
           }
         }
-      } catch (e) {
+      } catch {
       }
       return null;
     };
@@ -205,12 +384,48 @@ var init_utils = __esm({
   }
 });
 
+// src/constants.ts
+var config2, SANDBOX_CONFIG, GLOBAL_PATHS, DEPENDENCY_VERSIONS, DEFAULT_CONFIG;
+var init_constants = __esm({
+  "src/constants.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_config();
+    config2 = loadConfig();
+    SANDBOX_CONFIG = {
+      /** 用户主目录下的沙箱根目录名 */
+      BASE_NAME: config2.sandbox.baseName,
+      /** 内部子目录结构 */
+      DIRS: {
+        VERSIONS: config2.sandbox.dirs.versions,
+        CURRENT: config2.sandbox.dirs.current,
+        CACHE: config2.sandbox.dirs.cache
+      },
+      /** 关键标识文件 */
+      LOCK_FILE: config2.sandbox.lockFile
+    };
+    GLOBAL_PATHS = {
+      /** 沙箱根路径 */
+      BASE_DIR: config2.paths.baseDir,
+      /** Monorepo 扫描目录 */
+      MONOREPO_ROOTS: config2.paths.monorepoRoots
+    };
+    DEPENDENCY_VERSIONS = config2.dependencies;
+    DEFAULT_CONFIG = {
+      /** 支持的配置文件名 */
+      CONFIG_FILES: config2.defaults.configFiles,
+      /** 默认 UI 主题 */
+      THEME: config2.defaults.theme
+    };
+  }
+});
+
 // src/config.ts
 import fs2 from "fs-extra";
 import { createJiti } from "jiti";
 import path4 from "path";
 var ConfigManager;
-var init_config = __esm({
+var init_config2 = __esm({
   "src/config.ts"() {
     "use strict";
     init_esm_shims();
@@ -218,55 +433,66 @@ var init_config = __esm({
     init_utils();
     init_utils();
     ConfigManager = class {
-      static {
-        this.CONFIG_FILES = DEFAULT_CONFIG.CONFIG_FILES;
-      }
+      static CONFIG_FILES = DEFAULT_CONFIG.CONFIG_FILES;
       /**
        * 加载项目配置
+       * 优先级（从低到高）: 配置文件 < .chatbi-version < 环境变量
        * @param cwd 项目根目录
        */
       static async loadConfig(cwd = process.cwd()) {
-        const config = {};
+        if (!fs2.existsSync(cwd)) {
+          logger.warn(`\u9879\u76EE\u76EE\u5F55\u4E0D\u5B58\u5728: ${cwd}\uFF0C\u4F7F\u7528\u9ED8\u8BA4\u914D\u7F6E`);
+          return {};
+        }
+        const config4 = {};
         const versionFilePath = path4.join(cwd, SANDBOX_CONFIG.LOCK_FILE);
         if (fs2.existsSync(versionFilePath)) {
           try {
             const version = (await fs2.readFile(versionFilePath, "utf-8")).trim();
             if (version) {
-              config.coreVersion = version;
+              config4.coreVersion = version;
             }
-          } catch (e) {
+          } catch {
           }
         }
         const jiti = createJiti(cwd);
+        let projectConfig = {};
         for (const file of this.CONFIG_FILES) {
           const configPath = path4.join(cwd, file);
           if (fs2.existsSync(configPath)) {
             try {
-              let projectConfig = {};
               if (file.endsWith(".ts") || file.endsWith(".js")) {
                 const mod = await jiti.import(configPath, { default: true });
                 projectConfig = mod.default || mod || {};
               } else if (file.endsWith(".json") || file.startsWith(".chatbirc")) {
                 projectConfig = await fs2.readJson(configPath);
               }
-              return {
-                ...projectConfig,
-                ...config
-              };
-            } catch (e) {
-              logger.error(`\u8BFB\u53D6\u914D\u7F6E\u6587\u4EF6 ${file} \u5931\u8D25`, e);
+              break;
+            } catch {
+              logger.error(`\u8BFB\u53D6\u914D\u7F6E\u6587\u4EF6 ${file} \u5931\u8D25`);
             }
           }
         }
-        return config;
+        const envConfig = {};
+        if (process.env.CHATBI_CORE_VERSION) {
+          envConfig.coreVersion = process.env.CHATBI_CORE_VERSION;
+        }
+        if (process.env.CHATBI_CORE_SOURCE === "npm" || process.env.CHATBI_CORE_SOURCE === "local") {
+          envConfig.coreSource = process.env.CHATBI_CORE_SOURCE;
+        }
+        return {
+          ...projectConfig,
+          ...config4,
+          ...envConfig
+        };
       }
       /**
        * 解析核心依赖的具体路径或版本号
        * @param config 项目配置
        * @param relativeTo 相对路径（用于 local 模式下的 file: 协议生成）
        */
-      static async resolveCoreDependency(config, relativeTo = ".") {
-        const { coreSource = "local", coreVersion } = config;
+      static async resolveCoreDependency(config4, relativeTo = ".") {
+        const { coreSource = "local", coreVersion } = config4;
         if (coreSource === "npm") {
           if (coreVersion) return coreVersion;
           const cliRoot = await getCliRoot();
@@ -315,7 +541,7 @@ var init_config = __esm({
             if (pkg.tsup) {
               return pkg.tsup;
             }
-          } catch (e) {
+          } catch {
           }
         }
         return {};
@@ -324,119 +550,9 @@ var init_config = __esm({
   }
 });
 
-// src/sandbox/SandboxRenderer.ts
+// src/sandbox/SandboxPath.ts
 import fs3 from "fs-extra";
-import Handlebars from "handlebars";
 import path5 from "path";
-var SandboxRenderer;
-var init_SandboxRenderer = __esm({
-  "src/sandbox/SandboxRenderer.ts"() {
-    "use strict";
-    init_esm_shims();
-    Handlebars.registerHelper("json", (obj) => JSON.stringify(obj, null, 2));
-    Handlebars.registerHelper("eq", (a, b) => a === b);
-    SandboxRenderer = class {
-      static {
-        /**
-         * 需要转义的模板关键字列表
-         * 只有匹配这些关键字的 {{ }} 才会被 Handlebars 处理，其余（如 React 的 {{ style }}）将被转义跳过
-         */
-        this.TEMPLATE_KEYWORDS = [
-          "name",
-          "version",
-          "projectName",
-          "projectTitle",
-          "projectVersion",
-          "cliVersion",
-          "tsconfigPath",
-          "theme",
-          "isNebula",
-          "isGlass",
-          "isBusiness",
-          "isApp",
-          "isShell",
-          "pluginName",
-          "pluginPackageName",
-          "pluginVersion",
-          "pluginDisplayName",
-          "pluginDescription",
-          "pluginClassName",
-          "pluginPath",
-          "pluginFolderName",
-          "pluginType",
-          "pluginId",
-          "className",
-          "dependencies",
-          "devDependencies",
-          "json",
-          "if",
-          "else",
-          "unless",
-          "each",
-          "with",
-          "log",
-          "lookup"
-        ];
-      }
-      /**
-       * 递归渲染目录模板
-       * @param srcDir 模板源目录
-       * @param destDir 目标输出目录
-       * @param data 渲染模板所需的变量上下文
-       */
-      static async renderDirectory(srcDir, destDir, data) {
-        if (!srcDir || !destDir || !fs3.existsSync(srcDir)) return;
-        const entries = await fs3.readdir(srcDir, { withFileTypes: true });
-        for (const entry of entries) {
-          const srcPath = path5.join(srcDir, entry.name);
-          const destPath = path5.join(destDir, entry.name.replace(/\.hbs$/, ""));
-          if (entry.isDirectory()) {
-            await fs3.ensureDir(destPath);
-            await this.renderDirectory(srcPath, destPath, data);
-          } else {
-            await this.renderFile(srcPath, destPath, data);
-          }
-        }
-      }
-      /**
-       * 渲染单个文件
-       */
-      static async renderFile(srcPath, destPath, data) {
-        const isTemplate = srcPath.endsWith(".hbs");
-        if (!isTemplate) {
-          await fs3.copy(srcPath, destPath);
-          return;
-        }
-        const content = await fs3.readFile(srcPath, "utf-8");
-        if (!content.includes("{{")) {
-          await fs3.outputFile(destPath, content);
-          return;
-        }
-        try {
-          const keywordsPattern = this.TEMPLATE_KEYWORDS.join("|");
-          const safeContent = content.replace(
-            new RegExp(`\\{\\{(?!\\{)(?!\\s*([#/]?(?:${keywordsPattern}))\\b)`, "g"),
-            "\\{{"
-          );
-          const template = Handlebars.compile(safeContent);
-          const result = template(data);
-          await fs3.outputFile(destPath, result);
-        } catch (e) {
-          let result = content;
-          for (const [key, val] of Object.entries(data)) {
-            const regex = new RegExp(`\\{\\{\\s*${key}\\s*\\}\\}`, "g");
-            result = result.replace(regex, typeof val === "object" ? JSON.stringify(val) : String(val));
-          }
-          await fs3.outputFile(destPath, result);
-        }
-      }
-    };
-  }
-});
-
-// src/sandbox/SandboxPath.ts
-import fs5 from "fs-extra";
-import path7 from "path";
 var SandboxPath;
 var init_SandboxPath = __esm({
   "src/sandbox/SandboxPath.ts"() {
@@ -444,12 +560,10 @@ var init_SandboxPath = __esm({
     init_esm_shims();
     init_constants();
     SandboxPath = class {
-      static {
-        /**
-         * 沙箱的基础存储目录，通常位于用户主目录下的 .chatbi-v-core
-         */
-        this.BASE_DIR = GLOBAL_PATHS.BASE_DIR;
-      }
+      /**
+       * 沙箱的基础存储目录，通常位于用户主目录下的 .chatbi-v-core
+       */
+      static BASE_DIR = GLOBAL_PATHS.BASE_DIR;
       /**
        * 获取沙箱根目录
        * @returns 沙箱根目录的绝对路径
@@ -462,7 +576,7 @@ var init_SandboxPath = __esm({
        * @returns versions 目录的绝对路径
        */
       static getVersionRoot() {
-        return path7.join(this.BASE_DIR, SANDBOX_CONFIG.DIRS.VERSIONS);
+        return path5.join(this.BASE_DIR, SANDBOX_CONFIG.DIRS.VERSIONS);
       }
       /**
        * 获取指定版本的沙箱路径
@@ -471,9 +585,9 @@ var init_SandboxPath = __esm({
        */
       static getVersionPath(version) {
         if (version === SANDBOX_CONFIG.DIRS.CURRENT) {
-          return path7.join(this.BASE_DIR, SANDBOX_CONFIG.DIRS.VERSIONS, SANDBOX_CONFIG.DIRS.CURRENT);
+          return path5.join(this.BASE_DIR, SANDBOX_CONFIG.DIRS.VERSIONS, SANDBOX_CONFIG.DIRS.CURRENT);
         }
-        return path7.join(this.BASE_DIR, SANDBOX_CONFIG.DIRS.VERSIONS, version);
+        return path5.join(this.BASE_DIR, SANDBOX_CONFIG.DIRS.VERSIONS, version);
       }
       /**
        * 递归向上查找工作区根目录
@@ -484,19 +598,19 @@ var init_SandboxPath = __esm({
       static async getWorkspaceRoot(cwd) {
         if (!cwd) return cwd;
         if (cwd.startsWith("/mock")) return cwd;
-        let current = path7.resolve(cwd);
-        while (current !== path7.parse(current).root) {
-          const pkgPath = path7.join(current, "package.json");
-          const pnpmWorkspacePath = path7.join(current, "pnpm-workspace.yaml");
-          if (fs5.existsSync(pnpmWorkspacePath)) return current;
-          if (fs5.existsSync(pkgPath)) {
+        let current = path5.resolve(cwd);
+        while (current !== path5.parse(current).root) {
+          const pkgPath = path5.join(current, "package.json");
+          const pnpmWorkspacePath = path5.join(current, "pnpm-workspace.yaml");
+          if (fs3.existsSync(pnpmWorkspacePath)) return current;
+          if (fs3.existsSync(pkgPath)) {
             try {
-              const pkg = await fs5.readJson(pkgPath);
+              const pkg = await fs3.readJson(pkgPath);
               if (pkg.workspaces) return current;
-            } catch (e) {
+            } catch {
             }
           }
-          current = path7.dirname(current);
+          current = path5.dirname(current);
         }
         return cwd;
       }
@@ -505,8 +619,8 @@ var init_SandboxPath = __esm({
 });
 
 // src/sandbox/SandboxContext.ts
-import fs6 from "fs-extra";
-import path8 from "path";
+import fs4 from "fs-extra";
+import path6 from "path";
 var SandboxContext;
 var init_SandboxContext = __esm({
   "src/sandbox/SandboxContext.ts"() {
@@ -517,11 +631,11 @@ var init_SandboxContext = __esm({
     SandboxContext = class {
       /**
        * 注入项目虚拟上下文
-       * 包括：
-       * 1. 确定集中式 .chatbi 存放位置并处理子包软链
-       * 2. 生成适配沙箱的 tsconfig.json (配置路径别名)
-       * 3. 软链接沙箱的 node_modules 到项目 .chatbi 目录下
-       * 4. 确保 .chatbi 被加入 .gitignore
+       * 策略：
+       * 1. 总是优先在 Workspace Root (Monorepo 根目录) 生成 .chatbi
+       * 2. 如果当前项目就是 Workspace Root，则直接生成
+       * 3. 如果当前项目是子包 (Sub-package)，则不生成 .chatbi，而是依赖根目录的配置
+       *    (需要确保子包的 tsconfig extends 了根目录的 tsconfig 或 .chatbi/tsconfig.json)
        * 
        * @param projectRoot 当前项目根目录
        * @param version 内核版本号
@@ -530,52 +644,92 @@ var init_SandboxContext = __esm({
        */
       static async inject(projectRoot, version, corePackages, runtimeDeps) {
         const workspaceRoot = await SandboxPath.getWorkspaceRoot(projectRoot);
-        if (!workspaceRoot) {
-          const chatbiDir2 = path8.join(projectRoot, SANDBOX_CONFIG.DIRS.CACHE);
-          await fs6.ensureDir(chatbiDir2);
-          return this.injectToDir(chatbiDir2, version, corePackages, runtimeDeps);
-        }
-        const chatbiDir = path8.join(workspaceRoot, SANDBOX_CONFIG.DIRS.CACHE);
-        await fs6.ensureDir(chatbiDir);
-        if (workspaceRoot !== projectRoot) {
-          const localChatbi = path8.join(projectRoot, SANDBOX_CONFIG.DIRS.CACHE);
+        const targetRoot = workspaceRoot || projectRoot;
+        const chatbiDir = path6.join(targetRoot, SANDBOX_CONFIG.DIRS.CACHE);
+        await fs4.ensureDir(chatbiDir);
+        if (projectRoot !== targetRoot) {
+          const localChatbiDir = path6.join(projectRoot, SANDBOX_CONFIG.DIRS.CACHE);
+          if (fs4.existsSync(localChatbiDir)) {
+            await fs4.remove(localChatbiDir);
+          }
+          await this.fixTsConfigExtends(projectRoot, targetRoot);
+          await this.ensureGitignore(targetRoot);
+          return this.injectToDir(chatbiDir, version, corePackages, runtimeDeps);
+        }
+        await this.ensureGitignore(targetRoot);
+        await this.ensureVSCodeSettings(targetRoot, version);
+        return this.injectToDir(chatbiDir, version, corePackages, runtimeDeps);
+      }
+      /**
+       * 确保 .vscode/settings.json 存在并配置了 typescript.tsdk
+       */
+      static async ensureVSCodeSettings(root, version) {
+        const vscodeDir = path6.join(root, ".vscode");
+        await fs4.ensureDir(vscodeDir);
+        const settingsPath = path6.join(vscodeDir, "settings.json");
+        let settings = {};
+        if (fs4.existsSync(settingsPath)) {
           try {
-            const stats = await fs6.lstat(localChatbi).catch(() => null);
-            if (stats) {
-              if (stats.isSymbolicLink()) {
-                const linkTarget = await fs6.readlink(localChatbi);
-                if (linkTarget !== chatbiDir) {
-                  await fs6.remove(localChatbi);
-                  await fs6.symlink(chatbiDir, localChatbi, "dir");
-                }
-              } else {
-                await fs6.remove(localChatbi);
-                await fs6.symlink(chatbiDir, localChatbi, "dir");
-              }
-            } else {
-              await fs6.symlink(chatbiDir, localChatbi, "dir");
+            settings = await fs4.readJson(settingsPath);
+          } catch {
+          }
+        }
+        const sandboxPath = SandboxPath.getVersionPath(version);
+        const tsdkPath = path6.join(sandboxPath, "node_modules/typescript/lib");
+        settings["typescript.tsdk"] = tsdkPath;
+        settings["typescript.enablePromptUseWorkspaceTsdk"] = true;
+        await fs4.writeJson(settingsPath, settings, { spaces: 2 });
+      }
+      /**
+       * 修复 tsconfig.json 的 extends 配置
+       * 确保它指向 Workspace Root 的 .chatbi/tsconfig.json
+       */
+      static async fixTsConfigExtends(projectRoot, workspaceRoot) {
+        const tsConfigPath = path6.join(projectRoot, "tsconfig.json");
+        if (!fs4.existsSync(tsConfigPath)) return;
+        try {
+          const tsConfig = await fs4.readJson(tsConfigPath);
+          let extendsTarget = path6.relative(projectRoot, path6.join(workspaceRoot, ".chatbi/tsconfig.json"));
+          if (!extendsTarget.startsWith(".")) extendsTarget = `./${extendsTarget}`;
+          const hasExtend = (p) => p.includes(".chatbi/tsconfig.json") || p.includes(".chatbi/tsconfig.paths.json");
+          if (Array.isArray(tsConfig.extends)) {
+            if (!tsConfig.extends.some((p) => hasExtend(p))) {
+              tsConfig.extends.push(extendsTarget);
+              await fs4.writeJson(tsConfigPath, tsConfig, { spaces: 2 });
+            }
+          } else if (typeof tsConfig.extends === "string") {
+            if (!hasExtend(tsConfig.extends)) {
+              tsConfig.extends = [tsConfig.extends, extendsTarget];
+              await fs4.writeJson(tsConfigPath, tsConfig, { spaces: 2 });
             }
-          } catch (e) {
+          } else {
+            tsConfig.extends = extendsTarget;
+            await fs4.writeJson(tsConfigPath, tsConfig, { spaces: 2 });
           }
+        } catch (e) {
         }
-        const gitignorePath = path8.join(workspaceRoot, ".gitignore");
-        if (fs6.existsSync(gitignorePath)) {
-          let content = await fs6.readFile(gitignorePath, "utf-8");
+      }
+      /**
+       * 确保 .gitignore 包含 .chatbi
+       */
+      static async ensureGitignore(root) {
+        const gitignorePath = path6.join(root, ".gitignore");
+        if (fs4.existsSync(gitignorePath)) {
+          let content = await fs4.readFile(gitignorePath, "utf-8");
           if (!content.includes(SANDBOX_CONFIG.DIRS.CACHE)) {
-            await fs6.appendFile(gitignorePath, `
+            await fs4.appendFile(gitignorePath, `
 # ChatBI
 ${SANDBOX_CONFIG.DIRS.CACHE}
 `);
           }
         }
-        return this.injectToDir(chatbiDir, version, corePackages, runtimeDeps);
       }
       /**
        * 内部注入逻辑：向指定的 .chatbi 目录写入配置
        */
       static async injectToDir(chatbiDir, version, corePackages, runtimeDeps) {
         const versionPath = SandboxPath.getVersionPath(version);
-        const sandboxNodeModules = path8.join(versionPath, "node_modules");
+        const sandboxNodeModules = path6.join(versionPath, "node_modules");
         const corePaths = {};
         for (const pkgName of corePackages) {
           corePaths[pkgName] = [`./node_modules/${pkgName}`];
@@ -591,56 +745,146 @@ ${SANDBOX_CONFIG.DIRS.CACHE}
           }
         }
         corePaths["@types/*"] = ["./node_modules/@types/*"];
+        corePaths["*"] = ["./node_modules/*"];
         corePaths["vite/client"] = ["./node_modules/vite/client.d.ts"];
-        const baseConfigPath = path8.join(sandboxNodeModules, "@chatbi-v/config/base.json");
+        const baseConfigPath = path6.join(sandboxNodeModules, "@chatbi-v/config/base.json");
         const tsConfig = {
           extends: baseConfigPath,
           compilerOptions: {
             baseUrl: ".",
+            // 使用 node 还是 bundler ?
+            // 现代项目推荐 bundler，但为了兼容性，特别是为了让 IDE 能够像 Node 一样查找依赖
             moduleResolution: "bundler",
             skipLibCheck: true,
-            typeRoots: ["./node_modules/@types"],
+            // 显式指定 typeRoots，确保 IDE 优先查找沙箱的 types
+            typeRoots: ["./node_modules/@types", "./node_modules"],
             preserveSymlinks: true,
             paths: {
               ...corePaths,
-              "@/*": ["../src/*"],
-              "*": ["./node_modules/*"]
+              // 修改: 适配 Monorepo 根目录结构
+              // 在根目录时，src 应该指向具体的 apps/xxx/src 或 packages/xxx/src
+              // 但这里主要用于沙箱环境的类型解析，"@/*" 的映射可能需要在具体项目的 tsconfig 中覆盖
+              "@/*": ["./src/*"]
+              // "*": ["./node_modules/*"] // 已经在上面添加了 corePaths['*']
             }
           }
         };
-        await fs6.writeJson(path8.join(chatbiDir, "tsconfig.json"), tsConfig, { spaces: 2 });
-        await fs6.writeJson(path8.join(chatbiDir, "tsconfig.paths.json"), { compilerOptions: tsConfig.compilerOptions }, { spaces: 2 });
-        const virtualNodeModules = path8.join(chatbiDir, "node_modules");
-        if (fs6.existsSync(sandboxNodeModules)) {
+        await fs4.writeJson(path6.join(chatbiDir, "tsconfig.json"), tsConfig, { spaces: 2 });
+        await fs4.writeJson(path6.join(chatbiDir, "tsconfig.paths.json"), { compilerOptions: tsConfig.compilerOptions }, { spaces: 2 });
+        const virtualNodeModules = path6.join(chatbiDir, "node_modules");
+        if (fs4.existsSync(sandboxNodeModules)) {
           try {
-            const stats = await fs6.lstat(virtualNodeModules).catch(() => null);
+            const stats = await fs4.lstat(virtualNodeModules).catch(() => null);
             if (stats) {
               if (stats.isSymbolicLink()) {
-                const linkTarget = await fs6.readlink(virtualNodeModules);
+                const linkTarget = await fs4.readlink(virtualNodeModules);
                 if (linkTarget !== sandboxNodeModules) {
-                  await fs6.remove(virtualNodeModules);
-                  await fs6.symlink(sandboxNodeModules, virtualNodeModules, "dir");
+                  await fs4.remove(virtualNodeModules);
+                  await fs4.symlink(sandboxNodeModules, virtualNodeModules, "dir");
                 }
               } else {
-                await fs6.remove(virtualNodeModules);
-                await fs6.symlink(sandboxNodeModules, virtualNodeModules, "dir");
+                await fs4.remove(virtualNodeModules);
+                await fs4.symlink(sandboxNodeModules, virtualNodeModules, "dir");
               }
             } else {
-              await fs6.symlink(sandboxNodeModules, virtualNodeModules, "dir");
+              await fs4.symlink(sandboxNodeModules, virtualNodeModules, "dir");
+            }
+          } catch {
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/sandbox/WorkspaceResolver.ts
+import { execa as execa2 } from "execa";
+import fs5 from "fs-extra";
+import path7 from "path";
+var WorkspaceResolver;
+var init_WorkspaceResolver = __esm({
+  "src/sandbox/WorkspaceResolver.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_utils();
+    WorkspaceResolver = class {
+      /**
+       * 解析工作区中的所有包
+       * @param workspaceRoot 工作区根目录
+       * @returns 包名到绝对路径的映射
+       */
+      static async resolvePackages(workspaceRoot) {
+        const packages = {};
+        try {
+          const { stdout } = await execa2("pnpm", ["m", "ls", "--json", "--depth", "-1"], {
+            cwd: workspaceRoot,
+            reject: false
+          });
+          try {
+            const pnpmPackages = JSON.parse(stdout);
+            if (Array.isArray(pnpmPackages)) {
+              for (const pkg of pnpmPackages) {
+                if (pkg.name && pkg.path) {
+                  packages[pkg.name] = pkg.path;
+                }
+              }
+              if (Object.keys(packages).length > 0) {
+                return packages;
+              }
+            }
+          } catch {
+          }
+        } catch (e) {
+          logger.warn(`pnpm \u89E3\u6790\u5931\u8D25: ${e.message}\uFF0C\u5C1D\u8BD5\u964D\u7EA7\u65B9\u6848...`);
+        }
+        try {
+          const workspaceYamlPath = path7.join(workspaceRoot, "pnpm-workspace.yaml");
+          let patterns = ["packages/*"];
+          if (fs5.existsSync(workspaceYamlPath)) {
+            const content = await fs5.readFile(workspaceYamlPath, "utf-8");
+            const match = content.match(/packages:\s*([\s\S]*?)(?:\n\S|$)/);
+            if (match && match[1]) {
+              const lines = match[1].split("\n").map((l) => l.trim()).filter((l) => l.startsWith("-")).map((l) => l.replace(/^-\s*['"]?|['"]?$/g, ""));
+              if (lines.length > 0) patterns = lines;
+            }
+          } else {
+            const pkgJsonPath = path7.join(workspaceRoot, "package.json");
+            if (fs5.existsSync(pkgJsonPath)) {
+              const pkg = await fs5.readJson(pkgJsonPath);
+              if (Array.isArray(pkg.workspaces)) {
+                patterns = pkg.workspaces;
+              }
+            }
+          }
+          const globPatterns = patterns.map((p) => path7.join(p, "package.json"));
+          const { default: fg3 } = await import("fast-glob");
+          const pkgJsonFiles = await fg3(globPatterns, {
+            cwd: workspaceRoot,
+            absolute: true,
+            ignore: ["**/node_modules/**", "**/dist/**"]
+          });
+          for (const file of pkgJsonFiles) {
+            try {
+              const pkg = await fs5.readJson(file);
+              if (pkg.name) {
+                packages[pkg.name] = path7.dirname(file);
+              }
+            } catch {
             }
-          } catch (e) {
           }
+        } catch (e) {
+          logger.warn(`\u5DE5\u4F5C\u533A\u626B\u63CF\u5931\u8D25: ${e.message}`);
         }
+        return packages;
       }
     };
   }
 });
 
 // src/sandbox/SandboxPkgManager.ts
-import fg from "fast-glob";
-import fs7 from "fs-extra";
-import path9 from "path";
-import pc3 from "picocolors";
+import fs6 from "fs-extra";
+import path8 from "path";
+import pc2 from "picocolors";
 var SandboxPkgManager;
 var init_SandboxPkgManager = __esm({
   "src/sandbox/SandboxPkgManager.ts"() {
@@ -648,6 +892,7 @@ var init_SandboxPkgManager = __esm({
     init_esm_shims();
     init_utils();
     init_SandboxPath();
+    init_WorkspaceResolver();
     SandboxPkgManager = class {
       /**
        * 尝试将本地开发环境的包 Link 到沙箱中 (模拟安装)
@@ -661,52 +906,36 @@ var init_SandboxPkgManager = __esm({
         try {
           const cliRoot = await getCliRoot();
           const projectRoot = await SandboxPath.getWorkspaceRoot(cliRoot);
-          if (projectRoot === cliRoot && !fs7.existsSync(path9.join(projectRoot, "pnpm-workspace.yaml"))) {
+          if (projectRoot === cliRoot && !fs6.existsSync(path8.join(projectRoot, "pnpm-workspace.yaml"))) {
             return false;
           }
-          const possiblePackagesDirs = [
-            path9.join(projectRoot, "packages"),
-            // 兼容旧版或其他可能的路径结构
-            path9.resolve(projectRoot, "../chatbi-v/packages")
-          ];
+          const allLocalPackages = await WorkspaceResolver.resolvePackages(projectRoot);
           const localPackages = {};
-          const patterns = possiblePackagesDirs.filter((dir) => fs7.existsSync(dir)).map((dir) => path9.join(dir, "**/package.json"));
-          if (patterns.length > 0) {
-            const pkgJsonFiles = await fg(patterns, {
-              ignore: ["**/node_modules/**", "**/dist/**", "**/.git/**"],
-              absolute: true,
-              deep: 5
-            });
-            for (const pkgJsonPath of pkgJsonFiles) {
-              try {
-                const pkgJson = await fs7.readJson(pkgJsonPath);
-                if (corePackages.includes(pkgJson.name) || runtimeDeps.includes(pkgJson.name)) {
-                  localPackages[pkgJson.name] = path9.dirname(pkgJsonPath);
-                }
-              } catch (e) {
-              }
+          for (const [name, pkgPath] of Object.entries(allLocalPackages)) {
+            if (corePackages.includes(name) || runtimeDeps.includes(name)) {
+              localPackages[name] = pkgPath;
             }
           }
           if (Object.keys(localPackages).length === 0) return false;
-          const linkSummary = Object.entries(localPackages).map(([name, pkgPath]) => `${pc3.cyan(name.padEnd(30))} -> ${pc3.gray(pkgPath)}`).join("\n");
+          const linkSummary = Object.entries(localPackages).map(([name, pkgPath]) => `${pc2.cyan(name.padEnd(30))} -> ${pc2.gray(pkgPath)}`).join("\n");
           printBox(
-            pc3.green("\u{1F517} \u5DF2\u68C0\u6D4B\u5230\u672C\u5730\u5F00\u53D1\u73AF\u5883\uFF0C\u5C06\u94FE\u63A5\u4EE5\u4E0B\u6838\u5FC3\u5305\uFF1A\n\n") + linkSummary,
+            pc2.green("\u{1F517} \u5DF2\u68C0\u6D4B\u5230\u672C\u5730\u5F00\u53D1\u73AF\u5883\uFF0C\u5C06\u94FE\u63A5\u4EE5\u4E0B\u6838\u5FC3\u5305\uFF1A\n\n") + linkSummary,
             "Monorepo Link Mode"
           );
-          const sandboxNodeModules = path9.join(versionPath, "node_modules");
-          await fs7.ensureDir(sandboxNodeModules);
+          const sandboxNodeModules = path8.join(versionPath, "node_modules");
+          await fs6.ensureDir(sandboxNodeModules);
           for (const [name, pkgPath] of Object.entries(localPackages)) {
-            const targetLinkPath = path9.join(sandboxNodeModules, name);
-            await fs7.ensureDir(path9.dirname(targetLinkPath));
+            const targetLinkPath = path8.join(sandboxNodeModules, name);
+            await fs6.ensureDir(path8.dirname(targetLinkPath));
             try {
-              const stats = await fs7.lstat(targetLinkPath).catch(() => null);
-              if (stats) await fs7.remove(targetLinkPath);
-            } catch (e) {
+              const stats = await fs6.lstat(targetLinkPath).catch(() => null);
+              if (stats) await fs6.remove(targetLinkPath);
+            } catch {
             }
-            await fs7.symlink(pkgPath, targetLinkPath, "dir");
+            await fs6.symlink(pkgPath, targetLinkPath, "dir");
           }
-          const sandboxPkgJsonPath = path9.join(versionPath, "package.json");
-          const sandboxPkgJson = await fs7.readJson(sandboxPkgJsonPath);
+          const sandboxPkgJsonPath = path8.join(versionPath, "package.json");
+          const sandboxPkgJson = await fs6.readJson(sandboxPkgJsonPath);
           const sections = ["dependencies", "devDependencies"];
           let modified = false;
           for (const section of sections) {
@@ -719,10 +948,10 @@ var init_SandboxPkgManager = __esm({
               }
             }
           }
-          if (modified) await fs7.writeJson(sandboxPkgJsonPath, sandboxPkgJson, { spaces: 2 });
+          if (modified) await fs6.writeJson(sandboxPkgJsonPath, sandboxPkgJson, { spaces: 2 });
           return true;
         } catch (e) {
-          console.warn(pc3.yellow(`  \u26A0\uFE0F  Link \u672C\u5730\u6E90\u7801\u5931\u8D25\uFF0C\u5C06\u5C1D\u8BD5\u4ECE NPM \u5B89\u88C5: ${e.message}`));
+          console.warn(pc2.yellow(`  \u26A0\uFE0F  Link \u672C\u5730\u6E90\u7801\u5931\u8D25\uFF0C\u5C06\u5C1D\u8BD5\u4ECE NPM \u5B89\u88C5: ${e.message}`));
           return false;
         }
       }
@@ -730,55 +959,144 @@ var init_SandboxPkgManager = __esm({
   }
 });
 
-// src/sandbox.ts
-import { execa as execa2 } from "execa";
-import fg2 from "fast-glob";
-import fs8 from "fs-extra";
-import path10 from "path";
-import pc4 from "picocolors";
-var Sandbox;
-var init_sandbox = __esm({
-  "src/sandbox.ts"() {
+// src/sandbox/SandboxRenderer.ts
+import fs7 from "fs-extra";
+import Handlebars from "handlebars";
+import path9 from "path";
+var SandboxRenderer;
+var init_SandboxRenderer = __esm({
+  "src/sandbox/SandboxRenderer.ts"() {
     "use strict";
     init_esm_shims();
-    init_constants();
-    init_SandboxContext();
-    init_SandboxPath();
-    init_SandboxPkgManager();
-    init_SandboxRenderer();
-    init_utils();
-    Sandbox = class {
-      static {
-        /** 核心源码包列表 */
-        this.CORE_PACKAGES = [
-          "@chatbi-v/core",
-          "@chatbi-v/mocks",
-          "@chatbi-v/config"
-        ];
-      }
-      static {
-        /** 运行时必须依赖 */
-        this.RUNTIME_DEPS = [
-          "@ant-design/x",
-          "@ant-design/icons",
-          "antd",
-          "react",
-          "react-dom",
-          "lucide-react",
-          "framer-motion",
-          "clsx",
-          "tailwind-merge",
-          "react-router-dom",
-          "zustand",
-          "axios",
-          "less",
-          "vite"
-        ];
-      }
-      /** 获取沙箱根目录 */
-      static getRoot() {
-        return SandboxPath.getRoot();
-      }
+    Handlebars.registerHelper("json", (obj) => JSON.stringify(obj, null, 2));
+    Handlebars.registerHelper("eq", (a, b) => a === b);
+    SandboxRenderer = class {
+      /**
+       * 需要转义的模板关键字列表
+       * 只有匹配这些关键字的 {{ }} 才会被 Handlebars 处理，其余（如 React 的 {{ style }}）将被转义跳过
+       */
+      static TEMPLATE_KEYWORDS = [
+        "name",
+        "version",
+        "projectName",
+        "projectTitle",
+        "projectVersion",
+        "cliVersion",
+        "tsconfigPath",
+        "theme",
+        "isNebula",
+        "isGlass",
+        "isBusiness",
+        "isApp",
+        "isShell",
+        "pluginName",
+        "pluginPackageName",
+        "pluginVersion",
+        "pluginDisplayName",
+        "pluginDescription",
+        "pluginClassName",
+        "pluginPath",
+        "pluginFolderName",
+        "pluginType",
+        "pluginId",
+        "className",
+        "dependencies",
+        "devDependencies",
+        "json",
+        "if",
+        "else",
+        "unless",
+        "each",
+        "with",
+        "log",
+        "lookup"
+      ];
+      /**
+       * 递归渲染目录模板
+       * @param srcDir 模板源目录
+       * @param destDir 目标输出目录
+       * @param data 渲染模板所需的变量上下文
+       */
+      static async renderDirectory(srcDir, destDir, data) {
+        if (!srcDir || !destDir || !fs7.existsSync(srcDir)) return;
+        const entries = await fs7.readdir(srcDir, { withFileTypes: true });
+        await Promise.all(entries.map(async (entry) => {
+          const srcPath = path9.join(srcDir, entry.name);
+          const destPath = path9.join(destDir, entry.name.replace(/\.hbs$/, ""));
+          if (entry.isDirectory()) {
+            await fs7.ensureDir(destPath);
+            await this.renderDirectory(srcPath, destPath, data);
+          } else {
+            await this.renderFile(srcPath, destPath, data);
+          }
+        }));
+      }
+      /**
+       * 渲染单个文件
+       */
+      static async renderFile(srcPath, destPath, data) {
+        const isTemplate = srcPath.endsWith(".hbs");
+        let content = await fs7.readFile(srcPath, "utf-8");
+        let outputContent = content;
+        if (isTemplate) {
+          if (content.includes("{{")) {
+            try {
+              const keywordsPattern = this.TEMPLATE_KEYWORDS.join("|");
+              const safeContent = content.replace(
+                new RegExp(`\\{\\{(?!\\{)(?!\\s*([#/]?(?:${keywordsPattern}))\\b)`, "g"),
+                "\\{{"
+              );
+              const template = Handlebars.compile(safeContent);
+              outputContent = template(data);
+            } catch {
+              outputContent = content;
+              for (const [key, val] of Object.entries(data)) {
+                const regex = new RegExp(`\\{\\{\\s*${key}\\s*\\}\\}`, "g");
+                outputContent = outputContent.replace(regex, typeof val === "object" ? JSON.stringify(val) : String(val));
+              }
+            }
+          }
+        }
+        if (fs7.existsSync(destPath)) {
+          const existingContent = await fs7.readFile(destPath, "utf-8");
+          if (existingContent === outputContent) {
+            return;
+          }
+        }
+        await fs7.outputFile(destPath, outputContent);
+      }
+    };
+  }
+});
+
+// src/sandbox.ts
+import { execa as execa3 } from "execa";
+import fg from "fast-glob";
+import fs8 from "fs-extra";
+import path10 from "path";
+import pc3 from "picocolors";
+var config3, Sandbox;
+var init_sandbox = __esm({
+  "src/sandbox.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_config();
+    init_constants();
+    init_SandboxContext();
+    init_SandboxPath();
+    init_SandboxPkgManager();
+    init_SandboxRenderer();
+    init_utils();
+    config3 = loadConfig();
+    Sandbox = class {
+      /** 核心源码包列表 */
+      static CORE_PACKAGES = config3.runtime.corePackages;
+      /** 运行时必须依赖 */
+      static RUNTIME_DEPS = config3.runtime.runtimeDeps;
+      /** 获取沙箱根目录 */
+      static getRoot() {
+        return SandboxPath.getRoot();
+      }
       /** 获取所有版本的根目录 */
       static getVersionRoot() {
         return SandboxPath.getVersionRoot();
@@ -802,16 +1120,18 @@ var init_sandbox = __esm({
        * 优雅清理缓存环境
        * @param cwd 当前项目路径
        * @param deep 是否执行深度清理
+       * @param dryRun 是否仅预览
        */
-      static async clean(cwd, deep = false) {
-        const spinner = createSpinner("\u6B63\u5728\u6E05\u7406\u7F13\u5B58\u76EE\u5F55...").start();
+      static async clean(cwd, deep = false, dryRun = false) {
+        const spinner = createSpinner(dryRun ? "\u6B63\u5728\u626B\u63CF\u7F13\u5B58\u76EE\u5F55..." : "\u6B63\u5728\u6E05\u7406\u7F13\u5B58\u76EE\u5F55...").start();
         try {
           const workspaceRoot = await this.getWorkspaceRoot(cwd);
           let cleanedCount = 0;
+          const targetDirs = [];
           const cachePatterns = [
             path10.join(workspaceRoot, `**/${SANDBOX_CONFIG.DIRS.CACHE}`)
           ];
-          const cacheDirs = await fg2(cachePatterns, {
+          const cacheDirs = await fg(cachePatterns, {
             onlyFiles: false,
             // 允许匹配文件和符号链接
             absolute: true,
@@ -822,15 +1142,14 @@ var init_sandbox = __esm({
           for (const dir of cacheDirs) {
             const stats = await fs8.lstat(dir).catch(() => null);
             if (stats) {
-              await fs8.remove(dir);
-              cleanedCount++;
+              targetDirs.push(dir);
             }
           }
           if (deep) {
             const distPatterns = [
               path10.join(workspaceRoot, "**/dist")
             ];
-            const distDirs = await fg2(distPatterns, {
+            const distDirs = await fg(distPatterns, {
               onlyFiles: false,
               absolute: true,
               ignore: [
@@ -845,20 +1164,36 @@ var init_sandbox = __esm({
               if (stats) {
                 const hasPkg = fs8.existsSync(path10.join(path10.dirname(dir), "package.json"));
                 if (hasPkg) {
-                  await fs8.remove(dir);
-                  cleanedCount++;
+                  targetDirs.push(dir);
                 }
               }
             }
             const globalRoot = this.getRoot();
             if (fs8.existsSync(globalRoot)) {
-              await fs8.remove(globalRoot);
-              cleanedCount++;
+              targetDirs.push(globalRoot);
+            }
+          }
+          if (dryRun) {
+            spinner.stop();
+            if (targetDirs.length === 0) {
+              console.log(pc3.green("\u2728 \u6CA1\u6709\u53D1\u73B0\u9700\u8981\u6E05\u7406\u7684\u7F13\u5B58\u76EE\u5F55"));
+            } else {
+              printBox(
+                `${pc3.yellow("\u5373\u5C06\u6E05\u7406\u4EE5\u4E0B\u76EE\u5F55\uFF1A")}
+
+` + targetDirs.map((d) => pc3.gray(`- ${d}`)).join("\n"),
+                "Dry Run"
+              );
             }
+            return;
+          }
+          for (const dir of targetDirs) {
+            await fs8.remove(dir);
+            cleanedCount++;
           }
-          spinner.succeed(pc4.green(`\u6E05\u7406\u5B8C\u6210\uFF0C\u5171\u6E05\u7406 ${cleanedCount} \u4E2A\u9879\u76EE/\u7F13\u5B58\u76EE\u5F55`));
+          spinner.succeed(pc3.green(`\u6E05\u7406\u5B8C\u6210\uFF0C\u5171\u6E05\u7406 ${cleanedCount} \u4E2A\u9879\u76EE/\u7F13\u5B58\u76EE\u5F55`));
         } catch (e) {
-          spinner.fail(pc4.red(`\u6E05\u7406\u5931\u8D25: ${e.message}`));
+          spinner.fail(pc3.red(`\u6E05\u7406\u5931\u8D25: ${e.message}`));
         }
       }
       /**
@@ -873,7 +1208,7 @@ var init_sandbox = __esm({
           await fs8.remove(path10.join(versionPath, "node_modules"));
         }
         await fs8.ensureDir(versionPath);
-        const spinner = createSpinner(`\u6B63\u5728\u521D\u59CB\u5316\u5185\u6838\u6C99\u7BB1 ${pc4.cyan(version)}...`).start();
+        const spinner = createSpinner(`\u6B63\u5728\u521D\u59CB\u5316\u5185\u6838\u6C99\u7BB1 ${pc3.cyan(version)}...`).start();
         try {
           const cliRoot = await getCliRoot();
           const dependencies = {};
@@ -881,7 +1216,7 @@ var init_sandbox = __esm({
             dependencies[pkg] = DEPENDENCY_VERSIONS[pkg] || "latest";
           }
           for (const pkg of this.CORE_PACKAGES) {
-            dependencies[pkg] = pkg === "@chatbi-v/core" ? version : "latest";
+            dependencies[pkg] = version;
           }
           const templateData = {
             version,
@@ -893,16 +1228,16 @@ var init_sandbox = __esm({
             versionPath,
             templateData
           );
-          spinner.text = pc4.gray("  \u{1F3A8} \u540C\u6B65 Shell \u6A21\u677F...");
+          spinner.text = pc3.gray("  \u{1F3A8} \u540C\u6B65 Shell \u6A21\u677F...");
           await this.ensureShell(version, force);
-          spinner.text = pc4.gray("  \u{1F50D} \u68C0\u67E5\u672C\u5730\u5F00\u53D1\u73AF\u5883...");
+          spinner.text = pc3.gray("  \u{1F50D} \u68C0\u67E5\u672C\u5730\u5F00\u53D1\u73AF\u5883...");
           const isLocalDev = await SandboxPkgManager.tryLinkLocalPackages(versionPath, this.CORE_PACKAGES, this.RUNTIME_DEPS);
           const installArgs = isLocalDev ? ["install", "--no-frozen-lockfile"] : ["install"];
-          spinner.text = pc4.gray(`  \u23F3 \u6267\u884C pnpm ${installArgs.join(" ")}...`);
-          await execa2("pnpm", installArgs, { cwd: versionPath });
-          spinner.succeed(pc4.green(`\u5185\u6838\u6C99\u7BB1 ${version} \u521D\u59CB\u5316\u6210\u529F`));
+          spinner.text = pc3.gray(`  \u23F3 \u6267\u884C pnpm ${installArgs.join(" ")}...`);
+          await execa3("pnpm", installArgs, { cwd: versionPath });
+          spinner.succeed(pc3.green(`\u5185\u6838\u6C99\u7BB1 ${version} \u521D\u59CB\u5316\u6210\u529F`));
         } catch (e) {
-          spinner.fail(pc4.red(`\u5185\u6838\u6C99\u7BB1\u521D\u59CB\u5316\u5931\u8D25: ${e.message}`));
+          spinner.fail(pc3.red(`\u5185\u6838\u6C99\u7BB1\u521D\u59CB\u5316\u5931\u8D25: ${e.message}`));
           throw e;
         }
         return versionPath;
@@ -981,11 +1316,11 @@ var init_sandbox = __esm({
         const currentVersion = await this.resolveVersion("current");
         const versions = await this.listVersions();
         const statusInfo = [
-          `${pc4.bold("\u9879\u76EE\u8DEF\u5F84:")}   ${pc4.cyan(cwd)}`,
-          `${pc4.bold("\u67B6\u6784\u6A21\u5F0F:")}   ${isMonorepo ? pc4.yellow("Monorepo") : pc4.green("Standalone")}`,
-          `${pc4.bold("\u5F53\u524D\u5185\u6838:")}   ${pc4.green(currentVersion)}`,
-          `${pc4.bold("\u5DF2\u88C5\u7248\u672C:")}   ${pc4.gray(versions.join(", ") || "none")}`,
-          `${pc4.bold("\u6C99\u7BB1\u6839\u76EE\u5F55:")} ${pc4.gray(this.getRoot())}`
+          `${pc3.bold("\u9879\u76EE\u8DEF\u5F84:")}   ${pc3.cyan(cwd)}`,
+          `${pc3.bold("\u67B6\u6784\u6A21\u5F0F:")}   ${isMonorepo ? pc3.yellow("Monorepo") : pc3.green("Standalone")}`,
+          `${pc3.bold("\u5F53\u524D\u5185\u6838:")}   ${pc3.green(currentVersion)}`,
+          `${pc3.bold("\u5DF2\u88C5\u7248\u672C:")}   ${pc3.gray(versions.join(", ") || "none")}`,
+          `${pc3.bold("\u6C99\u7BB1\u6839\u76EE\u5F55:")} ${pc3.gray(this.getRoot())}`
         ].join("\n");
         printBox(statusInfo, "ChatBI Sandbox Status");
       }
@@ -994,22 +1329,20 @@ var init_sandbox = __esm({
 });
 
 // src/corekit.ts
-import fg3 from "fast-glob";
+import fg2 from "fast-glob";
 import fs9 from "fs-extra";
-import { createRequire as createRequire3 } from "module";
+import { createRequire as createRequire2 } from "module";
 import path11 from "path";
-import pc5 from "picocolors";
-import prompts2 from "prompts";
-import { createJiti as createJiti2 } from "jiti";
+import pc4 from "picocolors";
 var nativeRequire, CoreKit;
 var init_corekit = __esm({
   "src/corekit.ts"() {
     "use strict";
     init_esm_shims();
-    init_config();
+    init_config2();
     init_sandbox();
     init_utils();
-    nativeRequire = createRequire3(import.meta.url);
+    nativeRequire = createRequire2(import.meta.url);
     CoreKit = class {
       /**
        * 解析项目模式
@@ -1023,7 +1356,7 @@ var init_corekit = __esm({
         }
         if (pkg.chatbi?.type === "plugin" || pkg.plugin === true) return "plugin";
         if (pkg.chatbi?.type === "app") return "app";
-        const pluginEntries = await fg3(["index.plugin.{ts,js}", "src/index.plugin.{ts,js}"], { cwd });
+        const pluginEntries = await fg2(["index.plugin.{ts,js}", "src/index.plugin.{ts,js}"], { cwd });
         if (pluginEntries.length > 0) return "plugin";
         if (fs9.existsSync(path11.join(cwd, "index.html"))) {
           return "app";
@@ -1041,8 +1374,8 @@ var init_corekit = __esm({
        */
       static async resolveVersion(projectRoot) {
         if (projectRoot) {
-          const config = await ConfigManager.loadConfig(projectRoot);
-          if (config.coreVersion) return config.coreVersion;
+          const config4 = await ConfigManager.loadConfig(projectRoot);
+          if (config4.coreVersion) return config4.coreVersion;
         }
         try {
           const cliRoot = await getCliRoot();
@@ -1051,14 +1384,14 @@ var init_corekit = __esm({
             const version = (await fs9.readFile(cliVersionFile, "utf-8")).trim();
             if (version) return version;
           }
-        } catch (e) {
+        } catch {
         }
         const currentLinkPath = path11.join(Sandbox.getVersionRoot(), "current");
         if (fs9.existsSync(currentLinkPath)) {
           try {
             const realPath = await fs9.realpath(currentLinkPath);
             return path11.basename(realPath);
-          } catch (e) {
+          } catch {
           }
         }
         const versions = await this.listVersions();
@@ -1070,7 +1403,7 @@ var init_corekit = __esm({
       static async listVersions() {
         const versionsDir = Sandbox.getVersionRoot();
         if (!fs9.existsSync(versionsDir)) return [];
-        const dirs = await fg3("*", {
+        const dirs = await fg2("*", {
           cwd: versionsDir,
           onlyDirectories: true,
           deep: 1
@@ -1083,7 +1416,7 @@ var init_corekit = __esm({
       static async discoverPlugins(rootDir) {
         const pluginsDir = path11.join(rootDir, "plugins");
         if (!fs9.existsSync(pluginsDir)) return [];
-        const pkgFiles = await fg3("*/package.json", { cwd: pluginsDir, absolute: true });
+        const pkgFiles = await fg2("*/package.json", { cwd: pluginsDir, absolute: true });
         const plugins = [];
         for (const pkgPath of pkgFiles) {
           try {
@@ -1094,7 +1427,7 @@ var init_corekit = __esm({
               path: pluginPath,
               id: path11.basename(pluginPath)
             });
-          } catch (e) {
+          } catch {
           }
         }
         return plugins;
@@ -1106,19 +1439,19 @@ var init_corekit = __esm({
         const mode = await this.detectMode(cwd);
         const version = await this.resolveVersion(cwd);
         printBox(
-          `${pc5.cyan(pc5.bold("\u{1F680} ChatBI Dev Server"))}
+          `${pc4.cyan(pc4.bold("\u{1F680} ChatBI Dev Server"))}
 
-${pc5.gray("Mode:   ")} ${pc5.yellow(mode)}
-${pc5.gray("Kernel: ")} ${pc5.green(version)}
-${pc5.gray("Root:   ")} ${pc5.white(cwd)}`,
+${pc4.gray("Mode:   ")} ${pc4.yellow(mode)}
+${pc4.gray("Kernel: ")} ${pc4.green(version)}
+${pc4.gray("Root:   ")} ${pc4.white(cwd)}`,
           "Dev Server"
         );
         const spinner = createSpinner("\u6B63\u5728\u51C6\u5907\u6C99\u7BB1\u73AF\u5883...").start();
         try {
           await Sandbox.prepare(version);
-          spinner.text = pc5.cyan("\u6B63\u5728\u6CE8\u5165\u865A\u62DF\u4E0A\u4E0B\u6587...");
+          spinner.text = pc4.cyan("\u6B63\u5728\u6CE8\u5165\u865A\u62DF\u4E0A\u4E0B\u6587...");
           await Sandbox.injectContext(cwd, version);
-          spinner.succeed(pc5.green("\u73AF\u5883\u5C31\u7EEA"));
+          spinner.succeed(pc4.green("\u73AF\u5883\u5C31\u7EEA"));
           if (mode === "plugin") {
             await this.startPluginDevServer(cwd, version, options.port);
           } else if (mode === "app") {
@@ -1127,7 +1460,7 @@ ${pc5.gray("Root:   ")} ${pc5.white(cwd)}`,
             await this.startMonorepoDevServer(cwd, version, options.port);
           }
         } catch (e) {
-          spinner.fail(pc5.red(`\u542F\u52A8\u5931\u8D25: ${e.message}`));
+          spinner.fail(pc4.red(`\u542F\u52A8\u5931\u8D25: ${e.message}`));
         }
       }
       /**
@@ -1139,7 +1472,7 @@ ${pc5.gray("Root:   ")} ${pc5.white(cwd)}`,
           logger.warn("\u5F53\u524D Monorepo \u4E0B\u672A\u627E\u5230 apps/ \u76EE\u5F55");
           return;
         }
-        const pkgFiles = await fg3("*/package.json", { cwd: appsDir, absolute: true });
+        const pkgFiles = await fg2("*/package.json", { cwd: appsDir, absolute: true });
         const apps = pkgFiles.map((pkgPath) => ({
           name: path11.basename(path11.dirname(pkgPath)),
           path: path11.dirname(pkgPath)
@@ -1148,7 +1481,8 @@ ${pc5.gray("Root:   ")} ${pc5.white(cwd)}`,
           logger.warn("\u5F53\u524D Monorepo \u4E0B\u672A\u627E\u5230\u4EFB\u4F55\u5E94\u7528 (apps/)");
           return;
         }
-        const response = await prompts2({
+        const { default: prompts5 } = await import("prompts");
+        const response = await prompts5({
           type: "select",
           name: "appPath",
           message: "\u8BF7\u9009\u62E9\u8981\u542F\u52A8\u7684\u5E94\u7528:",
@@ -1182,6 +1516,7 @@ ${pc5.gray("Root:   ")} ${pc5.white(cwd)}`,
           "process.env.CHATBI_PLUGIN_PATH": JSON.stringify(pluginDir)
         };
         const { createServer } = await import("vite");
+        const { createJiti: createJiti2 } = await import("jiti");
         const jiti = createJiti2(import.meta.url);
         const tailwindConfig = await jiti.import(path11.join(sandboxNodeModules, "@chatbi-v/config/tailwind.js"), { default: true });
         try {
@@ -1241,9 +1576,9 @@ ${pc5.gray("Root:   ")} ${pc5.white(cwd)}`,
           await server.listen();
           const localUrl = `http://localhost:${shellPort}/`;
           printBox(
-            `${pc5.green(pc5.bold("\u2705 \u6258\u7BA1\u5F0F Shell \u5DF2\u542F\u52A8"))}
+            `${pc4.green(pc4.bold("\u2705 \u6258\u7BA1\u5F0F Shell \u5DF2\u542F\u52A8"))}
 
-${pc5.white("Local: ")} ${pc5.cyan(pc5.underline(localUrl))}`,
+${pc4.white("Local: ")} ${pc4.cyan(pc4.underline(localUrl))}`,
             "Shell Success"
           );
         } catch (e) {
@@ -1265,7 +1600,7 @@ ${pc5.white("Local: ")} ${pc5.cyan(pc5.underline(localUrl))}`,
         const { createServer, loadConfigFromFile, searchForWorkspaceRoot } = await import("vite");
         try {
           const configContext = { command: "serve", mode: "development" };
-          const userConfig = await loadConfigFromFile(configContext, void 0, appDir).catch(() => null);
+          await loadConfigFromFile(configContext, void 0, appDir).catch(() => null);
           const server = await createServer({
             root: appDir,
             // 这里我们允许用户有自己的 vite config，但我们会 merge alias
@@ -1307,9 +1642,9 @@ ${pc5.white("Local: ")} ${pc5.cyan(pc5.underline(localUrl))}`,
           await server.listen();
           const localUrl = `http://localhost:${server.config.server.port}/`;
           printBox(
-            `${pc5.green(pc5.bold("\u2705 \u5E94\u7528\u5DF2\u6210\u529F\u542F\u52A8"))}
+            `${pc4.green(pc4.bold("\u2705 \u5E94\u7528\u5DF2\u6210\u529F\u542F\u52A8"))}
 
-${pc5.white("Local: ")} ${pc5.cyan(pc5.underline(localUrl))}`,
+${pc4.white("Local: ")} ${pc4.cyan(pc4.underline(localUrl))}`,
             "App Success"
           );
         } catch (e) {
@@ -1320,16 +1655,32 @@ ${pc5.white("Local: ")} ${pc5.cyan(pc5.underline(localUrl))}`,
   }
 });
 
+// src/commands/dev.ts
+var dev_exports = {};
+__export(dev_exports, {
+  dev: () => dev
+});
+async function dev(options = {}) {
+  const cwd = process.cwd();
+  await CoreKit.startDev(cwd, options);
+}
+var init_dev = __esm({
+  "src/commands/dev.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_corekit();
+  }
+});
+
 // src/commands/build.ts
 var build_exports = {};
 __export(build_exports, {
   build: () => build
 });
-import { execa as execa3 } from "execa";
+import { execa as execa4 } from "execa";
 import fs10 from "fs-extra";
 import path12 from "path";
-import pc6 from "picocolors";
-import { build as tsupBuild } from "tsup";
+import pc5 from "picocolors";
 async function build(options) {
   const cwd = process.cwd();
   const pkgPath = path12.join(cwd, "package.json");
@@ -1343,13 +1694,13 @@ async function build(options) {
     try {
       await Sandbox.clean(cwd, true);
       spinnerClean.succeed("\u7F13\u5B58\u73AF\u5883\u6E05\u7406\u5B8C\u6210");
-    } catch (e) {
+    } catch {
       spinnerClean.fail("\u7F13\u5B58\u6E05\u7406\u5931\u8D25");
-      logger.error("\u6E05\u7406\u8FC7\u7A0B\u4E2D\u53D1\u751F\u9519\u8BEF", e);
+      logger.error("\u6E05\u7406\u8FC7\u7A0B\u4E2D\u53D1\u751F\u9519\u8BEF");
     }
   }
   const version = await CoreKit.resolveVersion(cwd);
-  logger.info(`\u6B63\u5728\u6784\u5EFA\u9879\u76EE: ${pc6.bold(pkg.name || "unnamed")} (\u5185\u6838\u7248\u672C: ${version})
+  logger.info(`\u6B63\u5728\u6784\u5EFA\u9879\u76EE: ${pc5.bold(pkg.name || "unnamed")} (\u5185\u6838\u7248\u672C: ${version})
 `);
   const spinner = createSpinner("\u6B63\u5728\u51C6\u5907\u6784\u5EFA\u73AF\u5883...").start();
   spinner.text = "\u6B63\u5728\u540C\u6B65\u6C99\u7BB1\u5185\u6838...";
@@ -1380,12 +1731,12 @@ async function build(options) {
   if (pkg.scripts && pkg.scripts.build && !process.env.CHATBI_CLI_INTERNAL) {
     const buildScript = pkg.scripts.build;
     if (!buildScript.includes("chatbi-cli build") && !buildScript.includes("chatbi build")) {
-      logger.info(`\u68C0\u6D4B\u5230\u81EA\u5B9A\u4E49 build \u811A\u672C\uFF0C\u6B63\u5728\u6267\u884C: ${pc6.cyan("npm run build")}`);
+      logger.info(`\u68C0\u6D4B\u5230\u81EA\u5B9A\u4E49 build \u811A\u672C\uFF0C\u6B63\u5728\u6267\u884C: ${pc5.cyan("npm run build")}`);
       const args = ["run", "build"];
       if (options.watch) {
         args.push("--", "--watch");
       }
-      await execa3("npm", args, {
+      await execa4("npm", args, {
         stdio: "inherit",
         env: { ...process.env, CHATBI_CLI_INTERNAL: "true" }
       });
@@ -1395,7 +1746,7 @@ async function build(options) {
   const mode = await CoreKit.detectMode(cwd);
   if (mode === "monorepo") {
     logger.info("\u68C0\u6D4B\u5230 Monorepo \u9879\u76EE\uFF0C\u6B63\u5728\u9012\u5F52\u6784\u5EFA\u5B50\u5305...");
-    await execa3("pnpm", ["-r", "build"], { stdio: "inherit", cwd });
+    await execa4("pnpm", ["-r", "build"], { stdio: "inherit", cwd });
     return;
   }
   if (mode === "app") {
@@ -1428,12 +1779,13 @@ async function build(options) {
     });
     if (!options.watch) {
       printBox(
-        pc6.green(pc6.bold("\u2728 \u5E94\u7528\u6784\u5EFA\u6210\u529F!")) + "\n\n" + pc6.white("\u4EA7\u7269\u76EE\u5F55: ") + pc6.cyan("dist"),
+        pc5.green(pc5.bold("\u2728 \u5E94\u7528\u6784\u5EFA\u6210\u529F!")) + "\n\n" + pc5.white("\u4EA7\u7269\u76EE\u5F55: ") + pc5.cyan("dist"),
         "Build Success"
       );
     }
     return;
   }
+  const { build: tsupBuild } = await import("tsup");
   let entry = ["src/index.ts"];
   if (fs10.existsSync(path12.join(cwd, "src/index.tsx"))) {
     entry = ["src/index.tsx"];
@@ -1457,6 +1809,7 @@ async function build(options) {
   }
   const commonConfig = {
     entry,
+    splitting: false,
     dts: false,
     clean: false,
     sourcemap: false,
@@ -1475,6 +1828,7 @@ async function build(options) {
         "@ant-design/x",
         ...Object.keys(pkg.dependencies || {}),
         ...Object.keys(pkg.peerDependencies || {}),
+        ...Object.keys(pkg.devDependencies || {}),
         ...isPlugin ? Sandbox.CORE_PACKAGES : [],
         ...Array.isArray(userConfig.external) ? userConfig.external : []
       ])
@@ -1549,22 +1903,22 @@ async function build(options) {
         tscBin = sandboxTsc;
       } else {
         if (fs10.existsSync(path12.join(cwd, "pnpm-lock.yaml"))) {
-          await execa3("pnpm", ["exec", "tsc", "--build", "tsconfig.json"]);
+          await execa4("pnpm", ["exec", "tsc", "--build", "tsconfig.json"]);
           dtsSpinner.succeed("\u7C7B\u578B\u5B9A\u4E49\u751F\u6210\u5B8C\u6210");
         } else {
-          await execa3("npx", ["-p", "typescript", "tsc", "--build", "tsconfig.json"]);
+          await execa4("npx", ["-p", "typescript", "tsc", "--build", "tsconfig.json"]);
           dtsSpinner.succeed("\u7C7B\u578B\u5B9A\u4E49\u751F\u6210\u5B8C\u6210");
         }
       }
       if (tscBin !== "tsc") {
-        await execa3(tscBin, ["--build", "tsconfig.json"]);
+        await execa4(tscBin, ["--build", "tsconfig.json"]);
         dtsSpinner.succeed("\u7C7B\u578B\u5B9A\u4E49\u751F\u6210\u5B8C\u6210");
       }
-    } catch (e) {
+    } catch {
       dtsSpinner.warn("\u7C7B\u578B\u751F\u6210\u5931\u8D25\uFF0C\u8BF7\u68C0\u67E5\u9879\u76EE\u4E2D\u7684 tsconfig.json \u914D\u7F6E");
     }
     printBox(
-      pc6.green(pc6.bold("\u2728 \u6784\u5EFA\u5B8C\u6210!")) + "\n\n" + pc6.white("\u4EA7\u7269\u76EE\u5F55: ") + pc6.cyan("dist") + "\n" + pc6.white("\u6784\u5EFA\u6A21\u5F0F: ") + pc6.cyan(isPlugin ? "Plugin" : "Library"),
+      pc5.green(pc5.bold("\u2728 \u6784\u5EFA\u5B8C\u6210!")) + "\n\n" + pc5.white("\u4EA7\u7269\u76EE\u5F55: ") + pc5.cyan("dist") + "\n" + pc5.white("\u6784\u5EFA\u6A21\u5F0F: ") + pc5.cyan(isPlugin ? "Plugin" : "Library"),
       "Build Success"
     );
   }
@@ -1573,29 +1927,126 @@ var init_build = __esm({
   "src/commands/build.ts"() {
     "use strict";
     init_esm_shims();
-    init_config();
+    init_config2();
     init_corekit();
     init_sandbox();
     init_utils();
   }
 });
 
+// src/commands/fetch.ts
+var fetch_exports = {};
+__export(fetch_exports, {
+  fetch: () => fetch
+});
+import { execa as execa5 } from "execa";
+import path13 from "path";
+import pc6 from "picocolors";
+async function fetch(version, options = {}) {
+  const fetchSpinner = createSpinner(`\u6B63\u5728\u83B7\u53D6\u5185\u6838\u7248\u672C ${pc6.cyan(version)}...`).start();
+  const versionPath = await Sandbox.prepare(version, true);
+  fetchSpinner.succeed(`\u5185\u6838\u7248\u672C ${pc6.cyan(version)} \u83B7\u53D6\u6210\u529F`);
+  if (options.pack) {
+    const packSpinner = createSpinner("\u6B63\u5728\u6253\u5305\u79BB\u7EBF\u8D44\u6E90...").start();
+    const tgzName = `chatbi-core-${version}.tgz`;
+    const tgzPath = path13.resolve(process.cwd(), tgzName);
+    await execa5("tar", [
+      "-czf",
+      tgzPath,
+      "-C",
+      path13.dirname(versionPath),
+      path13.basename(versionPath)
+    ]);
+    packSpinner.succeed("\u79BB\u7EBF\u8D44\u6E90\u6253\u5305\u5B8C\u6210");
+    printBox(
+      `${pc6.green(pc6.bold("\u2728 \u79BB\u7EBF\u5305\u5DF2\u751F\u6210!"))}
+
+${pc6.white("\u6587\u4EF6\u8DEF\u5F84: ")} ${pc6.cyan(tgzPath)}
+${pc6.white("\u5B89\u88C5\u547D\u4EE4: ")} ${pc6.gray(`chatbi install ${tgzName}`)}`,
+      "Pack Success"
+    );
+  } else {
+    logger.success(`\u5185\u6838\u7248\u672C ${pc6.cyan(version)} \u5DF2\u51C6\u5907\u5C31\u7EEA\u3002`);
+  }
+}
+var init_fetch = __esm({
+  "src/commands/fetch.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_sandbox();
+    init_utils();
+  }
+});
+
+// src/commands/install.ts
+var install_exports = {};
+__export(install_exports, {
+  install: () => install
+});
+import { execa as execa6 } from "execa";
+import fs11 from "fs-extra";
+import path14 from "path";
+import pc7 from "picocolors";
+async function install(target) {
+  if (target.endsWith(".tgz") && fs11.existsSync(target)) {
+    const spinner = createSpinner(`\u6B63\u5728\u5B89\u88C5\u672C\u5730\u79BB\u7EBF\u5305: ${pc7.bold(target)}...`).start();
+    try {
+      const tgzPath = path14.resolve(target);
+      const match = path14.basename(target).match(/chatbi-core-(.+)\.tgz/);
+      let version = "unknown";
+      if (match) {
+        version = match[1];
+      }
+      if (version === "unknown") {
+        spinner.warn("\u65E0\u6CD5\u4ECE\u6587\u4EF6\u540D\u8BC6\u522B\u7248\u672C\uFF0C\u5C06\u4F7F\u7528\u5F53\u524D\u65F6\u95F4\u6233\u4F5C\u4E3A\u7248\u672C\u53F7");
+        version = `local-${Date.now()}`;
+      }
+      const versionRoot = Sandbox.getVersionRoot();
+      await fs11.ensureDir(versionRoot);
+      spinner.text = "\u6B63\u5728\u89E3\u538B\u6587\u4EF6...";
+      await execa6("tar", ["-xzf", tgzPath, "-C", versionRoot]);
+      spinner.succeed(`\u672C\u5730\u5305\u5DF2\u5B89\u88C5\u81F3\u6C99\u7BB1: ${version}`);
+      spinner.text = "\u6B63\u5728\u51C6\u5907\u5185\u6838\u73AF\u5883...";
+      await Sandbox.prepare(version);
+      spinner.succeed("\u5185\u6838\u73AF\u5883\u5C31\u7EEA");
+      printBox(
+        pc7.green(pc7.bold("\u2728 \u672C\u5730\u5185\u6838\u5B89\u88C5\u6210\u529F!")) + "\n\n" + pc7.white("\u7248\u672C: ") + pc7.cyan(version) + "\n" + pc7.white("\u8DEF\u5F84: ") + pc7.gray(Sandbox.getVersionPath(version)),
+        "Install Success"
+      );
+    } catch (e) {
+      spinner.fail("\u5B89\u88C5\u5931\u8D25");
+      throw e;
+    }
+  } else {
+    const { fetch: fetch2 } = await Promise.resolve().then(() => (init_fetch(), fetch_exports));
+    await fetch2(target);
+  }
+}
+var init_install = __esm({
+  "src/commands/install.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_sandbox();
+    init_utils();
+  }
+});
+
 // src/commands/sync.ts
 var sync_exports = {};
 __export(sync_exports, {
   sync: () => sync
 });
-import fs11 from "fs-extra";
-import path13 from "path";
+import fs12 from "fs-extra";
+import path15 from "path";
 import pc8 from "picocolors";
 async function sync(options = {}) {
   const cwd = options.cwd || process.cwd();
-  const pkgPath = path13.join(cwd, "package.json");
-  if (!fs11.existsSync(pkgPath)) {
+  const pkgPath = path15.join(cwd, "package.json");
+  if (!fs12.existsSync(pkgPath)) {
     logger.error("\u672A\u627E\u5230 package.json\u3002\u8BF7\u5728\u9879\u76EE\u6839\u76EE\u5F55\u4E0B\u8FD0\u884C\u3002");
     return;
   }
-  const pkg = await fs11.readJson(pkgPath);
+  const pkg = await fs12.readJson(pkgPath);
   let version = options.version;
   if (!version) {
     version = await CoreKit.resolveVersion(cwd);
@@ -1610,8 +2061,8 @@ async function sync(options = {}) {
   await Sandbox.prepare(version, options.force);
   mainSpinner.text = "\u6B63\u5728\u751F\u6210\u865A\u62DF\u4E0A\u4E0B\u6587...";
   if (options.version) {
-    const versionFilePath = path13.join(cwd, ".chatbi-version");
-    await fs11.writeFile(versionFilePath, version, "utf-8");
+    const versionFilePath = path15.join(cwd, ".chatbi-version");
+    await fs12.writeFile(versionFilePath, version, "utf-8");
   }
   await Sandbox.injectContext(cwd, version);
   let modified = false;
@@ -1633,7 +2084,7 @@ async function sync(options = {}) {
   if (modified) {
     pkg.dependencies = deps;
     pkg.devDependencies = devDeps;
-    await fs11.writeJson(pkgPath, pkg, { spaces: 2 });
+    await fs12.writeJson(pkgPath, pkg, { spaces: 2 });
     mainSpinner.succeed("\u5185\u6838\u540C\u6B65\u5B8C\u6210 (\u4F9D\u8D56\u5DF2\u4F18\u5316)");
   } else {
     mainSpinner.succeed("\u5185\u6838\u540C\u6B65\u5B8C\u6210");
@@ -1660,63 +2111,18 @@ var init_sync = __esm({
   }
 });
 
-// src/commands/fetch.ts
-var fetch_exports = {};
-__export(fetch_exports, {
-  fetch: () => fetch
-});
-import { execa as execa4 } from "execa";
-import path15 from "path";
-import pc10 from "picocolors";
-async function fetch(version, options = {}) {
-  const fetchSpinner = createSpinner(`\u6B63\u5728\u83B7\u53D6\u5185\u6838\u7248\u672C ${pc10.cyan(version)}...`).start();
-  const versionPath = await Sandbox.prepare(version, true);
-  fetchSpinner.succeed(`\u5185\u6838\u7248\u672C ${pc10.cyan(version)} \u83B7\u53D6\u6210\u529F`);
-  if (options.pack) {
-    const packSpinner = createSpinner("\u6B63\u5728\u6253\u5305\u79BB\u7EBF\u8D44\u6E90...").start();
-    const tgzName = `chatbi-core-${version}.tgz`;
-    const tgzPath = path15.resolve(process.cwd(), tgzName);
-    await execa4("tar", [
-      "-czf",
-      tgzPath,
-      "-C",
-      path15.dirname(versionPath),
-      path15.basename(versionPath)
-    ]);
-    packSpinner.succeed("\u79BB\u7EBF\u8D44\u6E90\u6253\u5305\u5B8C\u6210");
-    printBox(
-      `${pc10.green(pc10.bold("\u2728 \u79BB\u7EBF\u5305\u5DF2\u751F\u6210!"))}
-
-${pc10.white("\u6587\u4EF6\u8DEF\u5F84: ")} ${pc10.cyan(tgzPath)}
-${pc10.white("\u5B89\u88C5\u547D\u4EE4: ")} ${pc10.gray(`chatbi install ${tgzName}`)}`,
-      "Pack Success"
-    );
-  } else {
-    logger.success(`\u5185\u6838\u7248\u672C ${pc10.cyan(version)} \u5DF2\u51C6\u5907\u5C31\u7EEA\u3002`);
-  }
-}
-var init_fetch = __esm({
-  "src/commands/fetch.ts"() {
-    "use strict";
-    init_esm_shims();
-    init_sandbox();
-    init_utils();
-  }
-});
-
 // src/commands/init.ts
 var init_exports = {};
 __export(init_exports, {
   init: () => init
 });
-import fs14 from "fs-extra";
-import path17 from "path";
-import pc12 from "picocolors";
-import prompts4 from "prompts";
+import fs13 from "fs-extra";
+import path16 from "path";
+import pc9 from "picocolors";
+import prompts from "prompts";
 async function init(options) {
-  let { name, pluginType = "business", theme = DEFAULT_CONFIG.THEME, projectType, includeApp, includePlugin, cwd } = options;
-  const response = await prompts4([
-    // ... (prompts remain the same)
+  let { name, pluginType = "business", theme = DEFAULT_CONFIG.THEME, projectType, includeApp, includePlugin, cwd, force } = options;
+  const response = await prompts([
     {
       type: name ? null : "text",
       name: "projectName",
@@ -1785,32 +2191,61 @@ async function init(options) {
   const isAppIncluded = finalIncludeApp;
   const isPluginIncluded = finalIncludePlugin;
   const rootDir = cwd || process.cwd();
-  const targetDir = path17.resolve(rootDir, name);
-  if (fs14.existsSync(targetDir)) {
-    logger.error(`\u76EE\u5F55 ${name} \u5DF2\u5B58\u5728\u3002`);
-    return;
+  const targetDir = path16.resolve(rootDir, name);
+  if (fs13.existsSync(targetDir)) {
+    if (force) {
+      await fs13.remove(targetDir);
+    } else {
+      const { action } = await prompts({
+        type: "select",
+        name: "action",
+        message: `\u76EE\u5F55 ${name} \u5DF2\u5B58\u5728\uFF0C\u8BF7\u9009\u62E9\u64CD\u4F5C:`,
+        choices: [
+          { title: "\u8986\u76D6 (Overwrite)", value: "overwrite", description: "\u6E05\u7A7A\u539F\u76EE\u5F55\u5E76\u91CD\u65B0\u521B\u5EFA" },
+          { title: "\u5408\u5E76 (Merge)", value: "merge", description: "\u4FDD\u7559\u539F\u6709\u6587\u4EF6\uFF0C\u4EC5\u8986\u76D6\u51B2\u7A81\u6587\u4EF6" },
+          { title: "\u53D6\u6D88 (Cancel)", value: "cancel" }
+        ]
+      });
+      if (action === "cancel" || !action) {
+        logger.warn("\u5DF2\u53D6\u6D88\u521D\u59CB\u5316");
+        return;
+      }
+      if (action === "overwrite") {
+        const { confirm } = await prompts({
+          type: "confirm",
+          name: "confirm",
+          message: "\u786E\u5B9A\u8981\u6E05\u7A7A\u76EE\u6807\u76EE\u5F55\u5417\uFF1F\u6B64\u64CD\u4F5C\u4E0D\u53EF\u64A4\u9500\u3002",
+          initial: false
+        });
+        if (!confirm) {
+          logger.warn("\u5DF2\u53D6\u6D88\u8986\u76D6");
+          return;
+        }
+        await fs13.remove(targetDir);
+      }
+    }
   }
-  logger.info(`\u6B63\u5728\u521D\u59CB\u5316\u9879\u76EE: ${pc12.bold(name)}...`);
-  logger.info(pc12.gray(`\u7C7B\u578B: ${projectType} | \u4E3B\u9898: ${theme || "N/A"}`));
-  console.log("");
+  logger.info(`\u6B63\u5728\u521D\u59CB\u5316\u9879\u76EE: ${pc9.bold(name)}...`);
+  logger.info(pc9.gray(`\u7C7B\u578B: ${projectType} | \u4E3B\u9898: ${theme || "N/A"}`));
+  logger.info("");
   try {
     const myCliRoot = await getCliRoot();
-    const cliPkg = await fs14.readJson(path17.join(myCliRoot, "package.json"));
+    const cliPkg = await fs13.readJson(path16.join(myCliRoot, "package.json"));
     const cliVersion = cliPkg.version;
-    const config = { coreSource: "npm" };
-    const kernelVersionFile = path17.join(myCliRoot, SANDBOX_CONFIG.LOCK_FILE);
-    if (fs14.existsSync(kernelVersionFile)) {
-      config.coreVersion = (await fs14.readFile(kernelVersionFile, "utf-8")).trim();
+    const config4 = { coreSource: "npm" };
+    const kernelVersionFile = path16.join(myCliRoot, SANDBOX_CONFIG.LOCK_FILE);
+    if (fs13.existsSync(kernelVersionFile)) {
+      config4.coreVersion = (await fs13.readFile(kernelVersionFile, "utf-8")).trim();
     }
-    const kernelVersion = await ConfigManager.resolveCoreDependency(config);
+    const kernelVersion = await ConfigManager.resolveCoreDependency(config4);
     const renderTemplate = async (templateName, destDir, extraData = {}) => {
-      const srcDir = path17.join(myCliRoot, "templates", templateName);
-      if (!fs14.existsSync(srcDir)) {
+      const srcDir = path16.join(myCliRoot, "templates", templateName);
+      if (!fs13.existsSync(srcDir)) {
         throw new Error(`\u627E\u4E0D\u5230\u6A21\u677F: ${templateName}\uFF0C\u8BF7\u68C0\u67E5\u8DEF\u5F84 ${srcDir} \u662F\u5426\u6B63\u786E\u3002`);
       }
-      await fs14.ensureDir(destDir);
+      await fs13.ensureDir(destDir);
       const templateData = {
-        name: path17.basename(destDir),
+        name: path16.basename(destDir),
         projectName: name,
         // Original project name from CLI argument
         projectTitle: name.split("-").map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join(" "),
@@ -1838,12 +2273,12 @@ async function init(options) {
       await renderTemplate("monorepo", targetDir, { name });
       if (isAppIncluded) {
         spinner.text = "\u6B63\u5728\u751F\u6210 Host App...";
-        const appDir = path17.join(targetDir, "apps", "main");
+        const appDir = path16.join(targetDir, "apps", "main");
         await renderTemplate("app", appDir, { name: "@chatbi-v/main" });
       }
       if (isPluginIncluded) {
         spinner.text = "\u6B63\u5728\u751F\u6210 Demo Plugin...";
-        const pluginDir = path17.join(targetDir, "plugins", "plugin-demo");
+        const pluginDir = path16.join(targetDir, "plugins", "plugin-demo");
         await renderTemplate("plugin", pluginDir, {
           name: "@chatbi-v/plugin-demo",
           pluginId: "demo",
@@ -1870,42 +2305,35 @@ async function init(options) {
         pluginPackageName: `@chatbi-v/plugin-${name}`,
         pluginVersion: "0.1.0",
         pluginDisplayName: name,
-        pluginDescription: "A ChatBI-V Plugin",
-        pluginClassName: name.split("-").map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join(""),
+        pluginDescription: "\u8FD9\u662F\u4E00\u4E2A\u521D\u59CB\u5316\u7684\u793A\u4F8B\u63D2\u4EF6",
+        pluginClassName: name.split("-").map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join("") + "Plugin",
         pluginPath: name,
         pluginFolderName: name,
-        className: name.split("-").map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join("")
+        className: name.split("-").map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join("") + "Plugin"
       });
     }
-    spinner.succeed("\u9879\u76EE\u7ED3\u6784\u751F\u6210\u5B8C\u6210");
-    const syncSpinner = createSpinner("\u6B63\u5728\u540C\u6B65\u5185\u6838\u4F9D\u8D56...").start();
-    await sync({ cwd: targetDir, silent: true });
-    syncSpinner.succeed("\u5185\u6838\u4F9D\u8D56\u540C\u6B65\u5B8C\u6210");
-    const configSpinner = createSpinner("\u6B63\u5728\u751F\u6210\u9879\u76EE\u914D\u7F6E...").start();
-    const cliConfig = {
-      coreVersion: kernelVersion
-    };
-    await fs14.writeJson(path17.join(targetDir, "chatbi.config.json"), cliConfig, { spaces: 2 });
-    configSpinner.succeed("\u9879\u76EE\u914D\u7F6E\u751F\u6210\u5B8C\u6210");
+    spinner.succeed(pc9.green(`\u9879\u76EE ${name} \u521D\u59CB\u5316\u5B8C\u6210\uFF01`));
+    logger.info("");
+    logger.info(pc9.cyan("\u6B63\u5728\u521D\u59CB\u5316\u5185\u6838\u73AF\u5883..."));
+    const projectCwd = targetDir;
+    await sync({ force: true, cwd: projectCwd });
+    logger.info("");
     printBox(
-      `${pc12.green(pc12.bold("\u2728 \u9879\u76EE\u5DF2\u6210\u529F\u521B\u5EFA!"))}
+      `${pc9.green("\u{1F389} \u9879\u76EE\u51C6\u5907\u5C31\u7EEA\uFF01")}
 
-${pc12.white("\u63A5\u4E0B\u6765\u4F60\u53EF\u4EE5:")}
-${pc12.cyan(`  cd ${name}`)}
-${pc12.cyan("  pnpm install")}
-${pc12.cyan("  pnpm dev")}`,
-      "Success"
+cd ${name}
+chatbi dev`,
+      "Happy Coding"
     );
-  } catch (error) {
-    logger.error("\u521D\u59CB\u5316\u5931\u8D25", error);
-    throw error;
+  } catch (e) {
+    logger.error(`\u521D\u59CB\u5316\u5931\u8D25: ${e.message}`);
   }
 }
 var init_init = __esm({
   "src/commands/init.ts"() {
     "use strict";
     init_esm_shims();
-    init_config();
+    init_config2();
     init_constants();
     init_SandboxRenderer();
     init_utils();
@@ -1913,179 +2341,30 @@ var init_init = __esm({
   }
 });
 
-// src/commands/bench.ts
-var bench_exports = {};
-__export(bench_exports, {
-  bench: () => bench
+// src/commands/add.ts
+var add_exports = {};
+__export(add_exports, {
+  add: () => add
 });
-import fs17 from "fs-extra";
-import os3 from "os";
-import path20 from "path";
-import pc15 from "picocolors";
-async function bench() {
-  logger.info("\u6B63\u5728\u542F\u52A8 CLI \u6027\u80FD\u57FA\u51C6\u6D4B\u8BD5...");
-  const results = [];
-  const tmpDir = path20.join(os3.tmpdir(), `chatbi-bench-${Date.now()}`);
-  await fs17.ensureDir(tmpDir);
-  try {
-    const initSpinner = createSpinner("\u6B63\u5728\u6D4B\u8BD5: \u521D\u59CB\u5316\u63D2\u4EF6\u9879\u76EE (init)...").start();
-    const startInit = Date.now();
-    const { init: init2 } = await Promise.resolve().then(() => (init_init(), init_exports));
-    const testProjDir = path20.join(tmpDir, "bench-proj");
-    await init2({ name: "bench-proj", projectType: "plugin", cwd: tmpDir });
-    const endInit = Date.now();
-    const initTime = (endInit - startInit) / 1e3;
-    initSpinner.succeed(`\u521D\u59CB\u5316\u5B8C\u6210: ${pc15.cyan(initTime.toFixed(2) + "s")}`);
-    results.push({
-      scene: "\u521D\u59CB\u5316\u63D2\u4EF6\u9879\u76EE (init)",
-      target: "\u2264 5.0 s",
-      actual: `${initTime.toFixed(2)} s`
-    });
-    const syncSpinner = createSpinner("\u6B63\u5728\u6D4B\u8BD5: \u6C99\u7BB1\u73AF\u5883\u540C\u6B65 (sync)...").start();
-    const startSync = Date.now();
-    const { sync: sync2 } = await Promise.resolve().then(() => (init_sync(), sync_exports));
-    await sync2({ cwd: testProjDir });
-    const endSync = Date.now();
-    const syncTime = (endSync - startSync) / 1e3;
-    syncSpinner.succeed(`\u540C\u6B65\u5B8C\u6210: ${pc15.cyan(syncTime.toFixed(2) + "s")}`);
-    results.push({
-      scene: "\u6C99\u7BB1\u73AF\u5883\u540C\u6B65 (sync)",
-      target: "\u2264 2.0 s",
-      actual: `${syncTime.toFixed(2)} s`
-    });
-    const buildSpinner = createSpinner("\u6B63\u5728\u6D4B\u8BD5: \u63D2\u4EF6\u9879\u76EE\u6784\u5EFA (build)...").start();
-    const startBuild = Date.now();
-    const { build: build2 } = await Promise.resolve().then(() => (init_build(), build_exports));
-    const originalCwd = process.cwd();
-    process.chdir(testProjDir);
-    await build2({ watch: false });
-    process.chdir(originalCwd);
-    const endBuild = Date.now();
-    const buildTime = (endBuild - startBuild) / 1e3;
-    buildSpinner.succeed(`\u6784\u5EFA\u5B8C\u6210: ${pc15.cyan(buildTime.toFixed(2) + "s")}`);
-    results.push({
-      scene: "\u63D2\u4EF6\u9879\u76EE\u6784\u5EFA (build)",
-      target: "\u2264 10.0 s",
-      actual: `${buildTime.toFixed(2)} s`
-    });
-    printBox(
-      `${pc15.green(pc15.bold("\u2728 \u57FA\u51C6\u6D4B\u8BD5\u5B8C\u6210!"))}
-
-` + results.map((r) => `${pc15.white(r.scene.padEnd(20))}: ${pc15.cyan(r.actual)} (\u76EE\u6807 ${r.target})`).join("\n"),
-      "Benchmark Results"
-    );
-  } finally {
-    await fs17.remove(tmpDir);
-  }
-}
-var init_bench = __esm({
-  "src/commands/bench.ts"() {
-    "use strict";
-    init_esm_shims();
-    init_utils();
-  }
-});
-
-// src/index.ts
-init_esm_shims();
-import boxen2 from "boxen";
-import cac from "cac";
-import figlet from "figlet";
-import gradient from "gradient-string";
-import pc16 from "picocolors";
-
-// package.json
-var package_default = {
-  name: "@chatbi-v/cli",
-  version: "2.1.10",
-  description: "Standardized CLI tooling for ChatBI Monorepo",
-  type: "module",
-  main: "dist/index.js",
-  module: "dist/index.js",
-  types: "dist/index.d.ts",
-  exports: {
-    ".": {
-      types: "./dist/index.d.ts",
-      import: "./dist/index.js"
-    },
-    "./package.json": "./package.json"
-  },
-  bin: {
-    "chatbi-cli": "./bin/chatbi-cli.js"
-  },
-  files: [
-    "dist",
-    "bin",
-    "templates"
-  ],
-  publishConfig: {
-    access: "public"
-  },
-  scripts: {
-    build: "tsup",
-    dev: "tsup --watch",
-    test: "vitest"
-  },
-  dependencies: {
-    boxen: "^8.0.1",
-    cac: "^6.7.14",
-    execa: "^8.0.1",
-    "fast-glob": "^3.3.3",
-    figlet: "^1.9.4",
-    "fs-extra": "^11.2.0",
-    "gradient-string": "^3.0.0",
-    handlebars: "^4.7.8",
-    jiti: "^2.6.1",
-    ora: "^7.0.1",
-    picocolors: "^1.0.0",
-    prompts: "^2.4.2",
-    tsup: "^8.5.1",
-    typescript: "^5.0.0",
-    vite: "^5.4.21"
-  },
-  devDependencies: {
-    "@types/boxen": "^3.0.5",
-    "@types/figlet": "^1.7.0",
-    "@types/fs-extra": "^11.0.0",
-    "@types/gradient-string": "^1.1.6",
-    "@types/node": "^20.0.0",
-    "@types/prompts": "^2.4.9",
-    "@vitest/coverage-v8": "1.6.1",
-    tsup: "^8.5.1",
-    vitest: "^1.0.0"
-  }
-};
-
-// src/commands/add.ts
-init_esm_shims();
-init_config();
-init_constants();
-init_SandboxRenderer();
-init_utils();
-import fs4 from "fs-extra";
-import { createRequire as createRequire2 } from "module";
-import path6 from "path";
-import pc2 from "picocolors";
-import prompts from "prompts";
-import { fileURLToPath as fileURLToPath3 } from "url";
-var _require2 = createRequire2(import.meta.url);
-var _filename2 = fileURLToPath3(import.meta.url);
-var _dirname2 = path6.dirname(_filename2);
+import fs14 from "fs-extra";
+import path17 from "path";
+import pc10 from "picocolors";
+import prompts2 from "prompts";
 async function add(options) {
   let { name, type, displayName, description } = options;
   const cwd = process.cwd();
-  const pkgPath = path6.join(cwd, "package.json");
-  if (!fs4.existsSync(pkgPath)) {
+  const pkgPath = path17.join(cwd, "package.json");
+  if (!fs14.existsSync(pkgPath)) {
     logger.error("\u672A\u627E\u5230 package.json\u3002\u8BF7\u5728 ChatBI-V \u9879\u76EE\u6839\u76EE\u5F55\u4E0B\u8FD0\u884C\u6B64\u547D\u4EE4\u3002");
     return;
   }
-  const pkg = await fs4.readJson(pkgPath);
+  const pkg = await fs14.readJson(pkgPath);
   const isMonorepo = pkg.workspaces && (pkg.workspaces.includes("plugins/*") || pkg.workspaces.packages?.includes("plugins/*"));
   if (!isMonorepo) {
     logger.error("\u5F53\u524D\u4E0D\u662F Monorepo \u9879\u76EE\uFF0C\u65E0\u6CD5\u6DFB\u52A0\u63D2\u4EF6 (\u8BF7\u5728\u5305\u542B plugins/ \u5DE5\u4F5C\u7A7A\u95F4\u7684\u9879\u76EE\u4E2D\u8FD0\u884C)");
     process.exit(1);
   }
-  const response = await prompts([
+  const response = await prompts2([
     {
       type: name ? null : "text",
       name: "pluginName",
@@ -2130,16 +2409,16 @@ async function add(options) {
     cleanName = cleanName.replace(/-plugin$/, "");
   }
   const folderName = cleanName.startsWith("plugin-") ? cleanName : `plugin-${cleanName}`;
-  const pluginDir = path6.resolve(cwd, "plugins", folderName);
-  if (fs4.existsSync(pluginDir)) {
+  const pluginDir = path17.resolve(cwd, "plugins", folderName);
+  if (fs14.existsSync(pluginDir)) {
     logger.error(`\u63D2\u4EF6\u76EE\u5F55 ${folderName} \u5DF2\u5B58\u5728\u3002`);
     return;
   }
-  const spinner = createSpinner(`\u6B63\u5728\u6DFB\u52A0\u65B0\u63D2\u4EF6: ${pc2.bold(name)}...`).start();
+  const spinner = createSpinner(`\u6B63\u5728\u6DFB\u52A0\u65B0\u63D2\u4EF6: ${pc10.bold(name)}...`).start();
   const targetDir = pluginDir;
   spinner.text = "\u6B63\u5728\u52A0\u8F7D\u914D\u7F6E...";
-  const config = await ConfigManager.loadConfig(cwd);
-  const corePath = await ConfigManager.resolveCoreDependency(config, pluginDir);
+  const config4 = await ConfigManager.loadConfig(cwd);
+  const corePath = await ConfigManager.resolveCoreDependency(config4, pluginDir);
   const data = {
     // 兼容旧模板
     name: `@chatbi-v/${folderName}`,
@@ -2161,95 +2440,61 @@ async function add(options) {
     tsconfigPath: `../../${SANDBOX_CONFIG.DIRS.CACHE}/tsconfig.json`
   };
   const myCliRoot = await getCliRoot();
-  let templateDir = myCliRoot ? path6.join(myCliRoot, "templates/plugin") : "";
+  let templateDir = myCliRoot ? path17.join(myCliRoot, "templates/plugin") : "";
   if (process.env.NODE_ENV === "test" && !templateDir) {
     templateDir = "/mock/templates/plugin";
   }
   if (process.env.NODE_ENV === "test") {
-    spinner.succeed(`\u63D2\u4EF6 ${pc2.bold(name)} \u6DFB\u52A0\u6210\u529F\uFF01`);
-    console.log(`\u63D2\u4EF6 ${pc2.bold(name)} \u6DFB\u52A0\u6210\u529F\uFF01`);
-    console.log("\u2728 \u63D2\u4EF6\u521B\u5EFA\u6210\u529F!");
+    spinner.succeed(`\u63D2\u4EF6 ${pc10.bold(name)} \u6DFB\u52A0\u6210\u529F\uFF01`);
+    logger.success(`\u63D2\u4EF6 ${pc10.bold(name)} \u6DFB\u52A0\u6210\u529F\uFF01`);
+    logger.success("\u2728 \u63D2\u4EF6\u521B\u5EFA\u6210\u529F!");
     return;
   }
-  if (!templateDir || !fs4.existsSync(templateDir)) {
+  if (!templateDir || !fs14.existsSync(templateDir)) {
     spinner.fail("\u627E\u4E0D\u5230\u63D2\u4EF6\u6A21\u677F");
     throw new Error(`\u627E\u4E0D\u5230\u63D2\u4EF6\u6A21\u677F: ${templateDir || "undefined"}`);
   }
   spinner.text = "\u6B63\u5728\u751F\u6210\u63D2\u4EF6\u6587\u4EF6...";
   await SandboxRenderer.renderDirectory(templateDir, targetDir, data);
-  spinner.succeed(`\u63D2\u4EF6 ${pc2.bold(name)} \u6DFB\u52A0\u6210\u529F\uFF01`);
+  spinner.succeed(`\u63D2\u4EF6 ${pc10.bold(name)} \u6DFB\u52A0\u6210\u529F\uFF01`);
   printBox(
-    `${pc2.green(pc2.bold("\u2728 \u63D2\u4EF6\u521B\u5EFA\u6210\u529F!"))}
+    `${pc10.green(pc10.bold("\u2728 \u63D2\u4EF6\u521B\u5EFA\u6210\u529F!"))}
 
-${pc2.white("\u9879\u76EE\u8DEF\u5F84: ")} ${pc2.cyan(`plugins/${folderName}`)}
-${pc2.white("\u63D2\u4EF6 ID:   ")} ${pc2.cyan(cleanName)}
-${pc2.white("\u63D2\u4EF6\u7C7B\u578B: ")} ${pc2.cyan(type)}
+${pc10.white("\u9879\u76EE\u8DEF\u5F84: ")} ${pc10.cyan(`plugins/${folderName}`)}
+${pc10.white("\u63D2\u4EF6 ID:   ")} ${pc10.cyan(cleanName)}
+${pc10.white("\u63D2\u4EF6\u7C7B\u578B: ")} ${pc10.cyan(type)}
 
-${pc2.white("\u63A5\u4E0B\u6765\u4F60\u53EF\u4EE5:")}
-${pc2.cyan("  pnpm dev")}  \u542F\u52A8\u5F00\u53D1\u73AF\u5883\u67E5\u770B\u6548\u679C`,
+${pc10.white("\u63A5\u4E0B\u6765\u4F60\u53EF\u4EE5:")}
+${pc10.cyan("  pnpm dev")}  \u542F\u52A8\u5F00\u53D1\u73AF\u5883\u67E5\u770B\u6548\u679C`,
     "Plugin Created"
   );
 }
-
-// src/index.ts
-init_build();
-
-// src/commands/clean.ts
-init_esm_shims();
-init_sandbox();
-async function clean(options) {
-  const cwd = process.cwd();
-  await Sandbox.clean(cwd, options.deep);
-}
-
-// src/commands/dev.ts
-init_esm_shims();
-init_corekit();
-async function dev(options = {}) {
-  const cwd = process.cwd();
-  await CoreKit.startDev(cwd, options);
-}
-
-// src/commands/discover.ts
-init_esm_shims();
-init_corekit();
-init_utils();
-import pc7 from "picocolors";
-async function discover() {
-  const cwd = process.cwd();
-  const spinner = createSpinner("\u6B63\u5728\u626B\u63CF\u9879\u76EE\u4E2D\u7684\u63D2\u4EF6...").start();
-  const plugins = await CoreKit.discoverPlugins(cwd);
-  if (plugins.length === 0) {
-    spinner.warn("\u672A\u53D1\u73B0\u4EFB\u4F55\u63D2\u4EF6");
-    logger.info(pc7.gray("\u8BF7\u786E\u4FDD\u63D2\u4EF6\u4F4D\u4E8E plugins/ \u76EE\u5F55\u4E0B\uFF0C\u4E14\u5305\u542B package.json\u3002"));
-  } else {
-    spinner.succeed(`\u53D1\u73B0\u4E86 ${pc7.cyan(plugins.length)} \u4E2A\u63D2\u4EF6`);
-    const pluginList = plugins.map((p) => `- ${pc7.bold(p.name)} ${pc7.gray(`(${p.id})`)}
-  ${pc7.gray(p.path)}`).join("\n\n");
-    printBox(
-      `${pc7.green(pc7.bold("\u2728 \u63D2\u4EF6\u626B\u63CF\u7ED3\u679C"))}
-
-${pluginList}`,
-      "Plugin Discovery"
-    );
+var init_add = __esm({
+  "src/commands/add.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_config2();
+    init_constants();
+    init_SandboxRenderer();
+    init_utils();
   }
-}
+});
 
 // src/commands/doctor.ts
-init_esm_shims();
-init_corekit();
-init_sandbox();
-init_utils();
+var doctor_exports = {};
+__export(doctor_exports, {
+  doctor: () => doctor
+});
 import glob from "fast-glob";
-import fs12 from "fs-extra";
-import path14 from "path";
-import pc9 from "picocolors";
+import fs15 from "fs-extra";
+import path18 from "path";
+import pc11 from "picocolors";
 async function doctor(options = {}) {
   logger.info("\u6B63\u5728\u8BCA\u65AD\u9879\u76EE\u5065\u5EB7\u72B6\u51B5...\n");
   const cwd = process.cwd();
   let hasIssues = false;
   const issues = [];
-  logger.info(pc9.bold("Step 1: \u68C0\u67E5\u57FA\u7840\u73AF\u5883..."));
+  logger.info(pc11.bold("Step 1: \u68C0\u67E5\u57FA\u7840\u73AF\u5883..."));
   const nodeVersion = process.version;
   if (parseInt(nodeVersion.slice(1).split(".")[0]) < 18) {
     logger.error(`Node.js \u7248\u672C\u592A\u4F4E: ${nodeVersion} (\u8981\u6C42 >=18)`);
@@ -2259,47 +2504,55 @@ async function doctor(options = {}) {
     logger.success(`Node.js \u7248\u672C: ${nodeVersion}`);
   }
   try {
-    const { execa: execa7 } = await import("execa");
-    const { stdout: pnpmVer } = await execa7("pnpm", ["-v"]);
+    const { execa: execa8 } = await import("execa");
+    const { stdout: pnpmVer } = await execa8("pnpm", ["-v"]);
     logger.success(`pnpm \u7248\u672C: ${pnpmVer}`);
-  } catch (e) {
+  } catch {
     logger.warn("\u672A\u68C0\u6D4B\u5230 pnpm\uFF0C\u5EFA\u8BAE\u5B89\u88C5\u4EE5\u83B7\u5F97\u6700\u4F73\u4F53\u9A8C");
   }
-  logger.info(pc9.bold("\nStep 2: \u68C0\u67E5\u5185\u6838\u6C99\u7BB1\u73AF\u5883..."));
+  if (fs15.existsSync(path18.join(cwd, ".git"))) {
+    try {
+      const { execa: execa8 } = await import("execa");
+      const { stdout } = await execa8("git", ["status", "--porcelain"], { cwd });
+      if (stdout.trim()) {
+        logger.warn("Git \u5DE5\u4F5C\u533A\u4E0D\u5E72\u51C0\uFF0C\u5EFA\u8BAE\u5728\u63D0\u4EA4\u540E\u8FDB\u884C\u64CD\u4F5C");
+      } else {
+        logger.success("Git \u5DE5\u4F5C\u533A\u5E72\u51C0");
+      }
+    } catch {
+    }
+  }
+  logger.info(pc11.bold("\nStep 2: \u68C0\u67E5\u5185\u6838\u6C99\u7BB1\u73AF\u5883..."));
   const version = await CoreKit.resolveVersion(cwd);
   const versionPath = Sandbox.getVersionPath(version);
-  if (!fs12.existsSync(versionPath)) {
+  if (!fs15.existsSync(versionPath)) {
     logger.error(`\u5185\u6838\u6C99\u7BB1\u7248\u672C ${version} \u5C1A\u672A\u5B89\u88C5`);
-    console.log(pc9.gray(`   \u5EFA\u8BAE\u8FD0\u884C 'chatbi sync' \u6216 'chatbi use ${version}' \u8FDB\u884C\u5B89\u88C5\u3002`));
+    logger.info(pc11.gray(`   \u5EFA\u8BAE\u8FD0\u884C 'chatbi sync' \u6216 'chatbi use ${version}' \u8FDB\u884C\u5B89\u88C5\u3002`));
     hasIssues = true;
     issues.push(`\u5185\u6838\u6C99\u7BB1\u672A\u5B89\u88C5 (${version})`);
   } else {
     logger.success(`\u5185\u6838\u6C99\u7BB1\u5C31\u7EEA (\u7248\u672C: ${version})`);
-    const sandboxNm = path14.join(versionPath, "node_modules");
-    if (!fs12.existsSync(sandboxNm)) {
+    const sandboxNm = path18.join(versionPath, "node_modules");
+    if (!fs15.existsSync(sandboxNm)) {
       logger.warn("\u6C99\u7BB1\u4F9D\u8D56\u672A\u5B89\u88C5\uFF0C\u5C06\u5BFC\u81F4\u6784\u5EFA\u5931\u8D25");
       hasIssues = true;
       issues.push("\u6C99\u7BB1\u4F9D\u8D56\u7F3A\u5931");
     }
-    const missingDeps = [];
-    for (const dep of Sandbox.CORE_PACKAGES) {
-      if (!fs12.existsSync(path14.join(sandboxNm, dep))) {
-        missingDeps.push(dep);
-      }
-    }
-    if (missingDeps.length > 0) {
-    }
   }
-  logger.info(pc9.bold("\nStep 3: \u68C0\u67E5\u865A\u62DF\u4F9D\u8D56\u6620\u5C04..."));
-  const chatbiDir = path14.join(cwd, ".chatbi");
-  if (!fs12.existsSync(chatbiDir)) {
+  logger.info(pc11.bold("\nStep 3: \u68C0\u67E5\u865A\u62DF\u4F9D\u8D56\u6620\u5C04..."));
+  const workspaceRoot = await SandboxPath.getWorkspaceRoot(cwd);
+  const chatbiDir = path18.join(workspaceRoot, ".chatbi");
+  const isMonorepoSub = cwd !== workspaceRoot;
+  if (isMonorepoSub) {
+    logger.info(pc11.gray(`\u5F53\u524D\u4F4D\u4E8E\u5B50\u5305\uFF0C\u68C0\u67E5 Monorepo \u6839\u76EE\u5F55\u914D\u7F6E: ${workspaceRoot}`));
+  }
+  if (!fs15.existsSync(chatbiDir)) {
     logger.warn("\u672A\u53D1\u73B0\u865A\u62DF\u4F9D\u8D56\u914D\u7F6E (.chatbi \u76EE\u5F55)");
     hasIssues = true;
     issues.push("\u7F3A\u5931 .chatbi \u76EE\u5F55");
   } else {
-    const pathsJson = path14.join(chatbiDir, "tsconfig.paths.json");
-    const aliasJson = path14.join(chatbiDir, "vite.alias.json");
-    if (!fs12.existsSync(pathsJson) || !fs12.existsSync(aliasJson)) {
+    const pathsJson = path18.join(chatbiDir, "tsconfig.paths.json");
+    if (!fs15.existsSync(pathsJson)) {
       logger.warn("\u865A\u62DF\u4F9D\u8D56\u914D\u7F6E\u6587\u4EF6\u4E0D\u5B8C\u6574");
       hasIssues = true;
       issues.push("\u865A\u62DF\u4F9D\u8D56\u914D\u7F6E\u4E0D\u5B8C\u6574");
@@ -2307,37 +2560,48 @@ async function doctor(options = {}) {
       logger.success("\u865A\u62DF\u4F9D\u8D56\u914D\u7F6E\u5DF2\u751F\u6210");
     }
   }
-  const tsConfigPath = path14.join(cwd, "tsconfig.json");
-  if (fs12.existsSync(tsConfigPath)) {
+  const tsConfigPath = path18.join(cwd, "tsconfig.json");
+  let missingTsExtend = false;
+  if (fs15.existsSync(tsConfigPath)) {
     try {
-      const tsConfig = await fs12.readJson(tsConfigPath);
+      const tsConfig = await fs15.readJson(tsConfigPath);
       const extendsPath = tsConfig.extends;
-      const expectedPaths = ["./.chatbi/tsconfig.paths.json", ".chatbi/tsconfig.paths.json"];
+      const expectedPaths = [
+        "./.chatbi/tsconfig.paths.json",
+        ".chatbi/tsconfig.paths.json",
+        "../../.chatbi/tsconfig.paths.json",
+        // Monorepo 常见结构
+        "../../../.chatbi/tsconfig.paths.json",
+        "./.chatbi/tsconfig.json",
+        ".chatbi/tsconfig.json",
+        "../../.chatbi/tsconfig.json",
+        "../../../.chatbi/tsconfig.json"
+      ];
       let hasExtend = false;
       if (typeof extendsPath === "string") {
-        hasExtend = expectedPaths.includes(extendsPath);
+        hasExtend = expectedPaths.includes(extendsPath) || extendsPath.endsWith(".chatbi/tsconfig.paths.json") || extendsPath.endsWith(".chatbi/tsconfig.json");
       } else if (Array.isArray(extendsPath)) {
-        hasExtend = extendsPath.some((p) => expectedPaths.includes(p));
+        hasExtend = extendsPath.some((p) => expectedPaths.includes(p) || p.endsWith(".chatbi/tsconfig.paths.json") || p.endsWith(".chatbi/tsconfig.json"));
       }
       if (!hasExtend) {
         logger.warn("tsconfig.json \u672A\u7EE7\u627F\u865A\u62DF\u4F9D\u8D56\u914D\u7F6E");
         hasIssues = true;
         issues.push("tsconfig.json \u914D\u7F6E\u7F3A\u5931");
+        missingTsExtend = true;
       } else {
         logger.success("tsconfig.json \u914D\u7F6E\u6B63\u5E38");
       }
-    } catch (e) {
+    } catch {
       logger.error("\u89E3\u6790 tsconfig.json \u5931\u8D25");
     }
   }
-  const viteConfigPath = path14.join(cwd, "vite.config.ts");
-  if (fs12.existsSync(viteConfigPath)) {
-    const content = await fs12.readFile(viteConfigPath, "utf-8");
-    if (!content.includes("vite.alias.json")) {
-      logger.warn("vite.config.ts \u53EF\u80FD\u672A\u52A0\u8F7D\u865A\u62DF\u522B\u540D\u914D\u7F6E");
+  const viteConfigPath = path18.join(cwd, "vite.config.ts");
+  if (fs15.existsSync(viteConfigPath)) {
+    const content = await fs15.readFile(viteConfigPath, "utf-8");
+    if (!content.includes("vite.alias.json") && !content.includes("CoreKit")) {
     }
   }
-  logger.info(pc9.bold("\nStep 4: \u626B\u63CF\u4EE3\u7801\u89C4\u5219..."));
+  logger.info(pc11.bold("\nStep 4: \u626B\u63CF\u4EE3\u7801\u89C4\u5219..."));
   const rules = [
     {
       id: "plugin-lifecycle-init",
@@ -2355,25 +2619,28 @@ async function doctor(options = {}) {
   const files = await glob(["src/**/*.{ts,tsx}"], { cwd, absolute: true });
   const codeIssues = [];
   if (files.length > 0) {
-    const scanSpinner = createSpinner(`\u6B63\u5728\u626B\u63CF ${files.length} \u4E2A\u6587\u4EF6...`).start();
-    for (const file of files) {
-      const content = await fs12.readFile(file, "utf-8");
-      for (const rule of rules) {
-        if (rule.pattern.test(content)) {
-          codeIssues.push({
-            file,
-            ruleId: rule.id,
-            description: rule.description,
-            rule
-          });
+    const scanSpinner = createSpinner(`\u6B63\u5728\u5E76\u53D1\u626B\u63CF ${files.length} \u4E2A\u6587\u4EF6...`).start();
+    await Promise.all(files.map(async (file) => {
+      try {
+        const content = await fs15.readFile(file, "utf-8");
+        for (const rule of rules) {
+          if (rule.pattern.test(content)) {
+            codeIssues.push({
+              file,
+              ruleId: rule.id,
+              description: rule.description,
+              rule
+            });
+          }
         }
+      } catch {
       }
-    }
+    }));
     if (codeIssues.length > 0) {
       scanSpinner.fail(`\u53D1\u73B0 ${codeIssues.length} \u4E2A\u4EE3\u7801\u89C4\u8303\u95EE\u9898`);
       hasIssues = true;
       codeIssues.forEach((issue) => {
-        const relativePath = path14.relative(cwd, issue.file);
+        const relativePath = path18.relative(cwd, issue.file);
         issues.push(`\u4EE3\u7801\u89C4\u8303 [${issue.ruleId}]: ${relativePath}`);
       });
     } else {
@@ -2382,53 +2649,169 @@ async function doctor(options = {}) {
   }
   if (!hasIssues) {
     printBox(
-      pc9.green(pc9.bold("\u2728 \u8BCA\u65AD\u5B8C\u6210\uFF1A\u9879\u76EE\u4E00\u5207\u6B63\u5E38\uFF01")),
+      pc11.green(pc11.bold("\u2728 \u8BCA\u65AD\u5B8C\u6210\uFF1A\u9879\u76EE\u4E00\u5207\u6B63\u5E38\uFF01")),
       "Doctor Report"
     );
   } else {
-    const issueList = issues.map((i) => pc9.red(`\u2022 ${i}`)).join("\n");
+    const issueList = issues.map((i) => pc11.red(`\u2022 ${i}`)).join("\n");
     printBox(
-      `${pc9.yellow(pc9.bold("\u26A0\uFE0F \u8BCA\u65AD\u5B8C\u6210\uFF1A\u53D1\u73B0\u4EE5\u4E0B\u95EE\u9898"))}
+      `${pc11.yellow(pc11.bold("\u26A0\uFE0F \u8BCA\u65AD\u5B8C\u6210\uFF1A\u53D1\u73B0\u4EE5\u4E0B\u95EE\u9898"))}
 
 ${issueList}
 
-${pc9.cyan("\u5EFA\u8BAE\u6839\u636E\u63D0\u793A\u8FDB\u884C\u4FEE\u590D")}`,
+${pc11.cyan("\u5EFA\u8BAE\u6839\u636E\u63D0\u793A\u8FDB\u884C\u4FEE\u590D")}`,
       "Doctor Report"
     );
     if (options.fix) {
       if (codeIssues.length > 0) {
         const fixSpinner = createSpinner("\u6B63\u5728\u4FEE\u590D\u4EE3\u7801\u89C4\u8303\u95EE\u9898...").start();
         for (const issue of codeIssues) {
-          const content = await fs12.readFile(issue.file, "utf-8");
+          const content = await fs15.readFile(issue.file, "utf-8");
           const newContent = issue.rule.fix(content);
-          await fs12.writeFile(issue.file, newContent);
+          await fs15.writeFile(issue.file, newContent);
+        }
+        fixSpinner.succeed(`\u5DF2\u4FEE\u590D ${codeIssues.length} \u4E2A\u95EE\u9898`);
+      }
+      if (missingTsExtend && fs15.existsSync(tsConfigPath)) {
+        const fixSpinner = createSpinner("\u6B63\u5728\u4FEE\u590D tsconfig.json \u914D\u7F6E...").start();
+        try {
+          const tsConfig = await fs15.readJson(tsConfigPath);
+          let extendsTarget = "./.chatbi/tsconfig.json";
+          if (isMonorepoSub) {
+            extendsTarget = path18.relative(cwd, path18.join(workspaceRoot, ".chatbi/tsconfig.json"));
+            if (!extendsTarget.startsWith(".")) extendsTarget = `./${extendsTarget}`;
+          }
+          if (Array.isArray(tsConfig.extends)) {
+            if (!tsConfig.extends.some((p) => p.includes(".chatbi"))) {
+              tsConfig.extends.push(extendsTarget);
+            }
+          } else if (typeof tsConfig.extends === "string") {
+            if (!tsConfig.extends.includes(".chatbi")) {
+              tsConfig.extends = [tsConfig.extends, extendsTarget];
+            }
+          } else {
+            tsConfig.extends = extendsTarget;
+          }
+          await fs15.writeJson(tsConfigPath, tsConfig, { spaces: 2 });
+          fixSpinner.succeed("\u5DF2\u4FEE\u590D tsconfig.json \u7EE7\u627F\u914D\u7F6E");
+        } catch (e) {
+          fixSpinner.fail(`\u4FEE\u590D tsconfig.json \u5931\u8D25: ${e.message}`);
         }
-        fixSpinner.succeed("\u4EE3\u7801\u4FEE\u590D\u5B8C\u6210");
       }
-      logger.info("\u6B63\u5728\u4FEE\u590D\u73AF\u5883\u914D\u7F6E...");
-      const { sync: sync2 } = await Promise.resolve().then(() => (init_sync(), sync_exports));
-      await sync2({ force: true });
-      logger.success("\u81EA\u52A8\u4FEE\u590D\u5B8C\u6210\uFF0C\u8BF7\u91CD\u65B0\u8FD0\u884C\u8BCA\u65AD\u3002");
     }
   }
 }
+var init_doctor = __esm({
+  "src/commands/doctor.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_corekit();
+    init_sandbox();
+    init_SandboxPath();
+    init_utils();
+  }
+});
 
-// src/index.ts
-init_fetch();
+// src/commands/ls.ts
+var ls_exports = {};
+__export(ls_exports, {
+  ls: () => ls
+});
+import pc12 from "picocolors";
+async function ls() {
+  const versions = await CoreKit.listVersions();
+  const currentVersion = await CoreKit.resolveVersion(process.cwd());
+  const globalCurrentVersion = await CoreKit.resolveVersion();
+  logger.info("\u5DF2\u5B89\u88C5\u7684\u5185\u6838\u6C99\u7BB1\u7248\u672C:");
+  if (versions.length === 0) {
+    logger.warn("\u5C1A\u672A\u5B89\u88C5\u4EFB\u4F55\u7248\u672C\uFF0C\u8BF7\u8FD0\u884C chatbi sync \u8FDB\u884C\u5B89\u88C5\u3002");
+  } else {
+    const list = versions.map((v) => {
+      const isGlobalCurrent = v === globalCurrentVersion;
+      const isProjectCurrent = v === currentVersion;
+      let prefix = "  ";
+      if (isProjectCurrent) {
+        prefix = pc12.green(" *");
+      } else if (isGlobalCurrent) {
+        prefix = pc12.blue(" >");
+      }
+      let suffix = "";
+      if (isProjectCurrent && isGlobalCurrent) {
+        suffix = pc12.gray(" (\u5F53\u524D\u9879\u76EE & \u5168\u5C40)");
+      } else if (isProjectCurrent) {
+        suffix = pc12.gray(" (\u5F53\u524D\u9879\u76EE)");
+      } else if (isGlobalCurrent) {
+        suffix = pc12.gray(" (\u5168\u5C40)");
+      }
+      return `${prefix} ${pc12.white(v)}${suffix}`;
+    }).join("\n");
+    printBox(
+      list + pc12.gray("\n\n\u63D0\u793A: * \u5F53\u524D\u9879\u76EE\u4F7F\u7528, > \u5168\u5C40\u9ED8\u8BA4\u4F7F\u7528"),
+      "Kernel Versions"
+    );
+  }
+  await Sandbox.visualizeStatus(process.cwd());
+}
+var init_ls = __esm({
+  "src/commands/ls.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_corekit();
+    init_sandbox();
+    init_utils();
+  }
+});
+
+// src/commands/use.ts
+var use_exports = {};
+__export(use_exports, {
+  use: () => use
+});
+import fs16 from "fs-extra";
+import path19 from "path";
+async function use(version, options = {}) {
+  const versions = await CoreKit.listVersions();
+  if (!versions.includes(version)) {
+    logger.warn(`\u7248\u672C ${version} \u5C1A\u672A\u5B89\u88C5\uFF0C\u6B63\u5728\u5C1D\u8BD5\u5B89\u88C5...`);
+    await Sandbox.prepare(version);
+  }
+  if (options.global) {
+    await Sandbox.useVersion(version);
+    logger.success(`\u5DF2\u5207\u6362\u5168\u5C40\u5185\u6838\u7248\u672C\u81F3: ${version}`);
+  } else {
+    const cwd = process.cwd();
+    const versionFilePath = path19.join(cwd, ".chatbi-version");
+    await fs16.writeFile(versionFilePath, version, "utf-8");
+    logger.success(`\u5DF2\u5207\u6362\u5F53\u524D\u9879\u76EE\u5185\u6838\u7248\u672C\u4E3A: ${version}`);
+  }
+  await sync({ version, force: false });
+}
+var init_use = __esm({
+  "src/commands/use.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_corekit();
+    init_sandbox();
+    init_utils();
+    init_sync();
+  }
+});
 
 // src/commands/gl.ts
-init_esm_shims();
-init_utils();
-import { execa as execa5 } from "execa";
-import fs13 from "fs-extra";
-import path16 from "path";
-import pc11 from "picocolors";
+var gl_exports = {};
+__export(gl_exports, {
+  gl: () => gl
+});
+import { execa as execa7 } from "execa";
+import fs17 from "fs-extra";
+import path20 from "path";
+import pc13 from "picocolors";
 import prompts3 from "prompts";
 async function gl(options) {
   const { type: initialType, prompt: initialPrompt } = options;
   const cwd = process.cwd();
-  const pkgPath = path16.join(cwd, "package.json");
-  if (!fs13.existsSync(pkgPath)) {
+  const pkgPath = path20.join(cwd, "package.json");
+  if (!fs17.existsSync(pkgPath)) {
     logger.error("\u672A\u627E\u5230 package.json\u3002\u8BF7\u5728 ChatBI-V \u9879\u76EE\u6839\u76EE\u5F55\u4E0B\u8FD0\u884C\u6B64\u547D\u4EE4\u3002");
     return;
   }
@@ -2467,7 +2850,7 @@ async function gl(options) {
     logger.error("\u9700\u6C42\u63CF\u8FF0\u4E0D\u80FD\u4E3A\u7A7A\u3002");
     return;
   }
-  logger.info(`\u6B63\u5728\u547C\u53EB AI \u5F15\u64CE [\u6A21\u5F0F: ${pc11.bold(genType)}]...`);
+  logger.info(`\u6B63\u5728\u547C\u53EB AI \u5F15\u64CE [\u6A21\u5F0F: ${pc13.bold(genType)}]...`);
   const toolsContext = `
 [Available Tools & Capabilities]
 - Tool: plugin -> For creating new feature modules. Requires: name, type (business|system).
@@ -2510,7 +2893,7 @@ If not, use the SLOT_REQUIRED format.`.trim();
   while (retry) {
     spinner.start();
     try {
-      const { stdout } = await execa5("gemini", [geminiCmd, currentPrompt], {
+      const { stdout } = await execa7("gemini", [geminiCmd, currentPrompt], {
         stdio: "pipe"
       });
       spinner.stop();
@@ -2530,7 +2913,7 @@ If not, use the SLOT_REQUIRED format.`.trim();
           }
         }
         if (slots.length > 0) {
-          logger.info(pc11.yellow("\n\u{1F4DD} AI \u9700\u8981\u66F4\u591A\u4FE1\u606F\u4EE5\u7EE7\u7EED:"));
+          logger.info(pc13.yellow("\n\u{1F4DD} AI \u9700\u8981\u66F4\u591A\u4FE1\u606F\u4EE5\u7EE7\u7EED:"));
           const answers = await prompts3(slots, {
             onCancel: () => process.exit(0)
           });
@@ -2545,14 +2928,14 @@ Please proceed with generation based on these answers.`;
           continue;
         }
       }
-      console.log("\n" + stdout);
+      logger.info("\n" + stdout);
       retry = false;
       logger.success(`AI \u547D\u4EE4 [gemini ${geminiCmd}] \u6267\u884C\u5B8C\u6BD5!`);
     } catch (error) {
       spinner.stop();
       if (error.code === "ENOENT") {
         logger.error("\u672A\u5728\u7CFB\u7EDF\u4E2D\u627E\u5230 `gemini-cli` \u547D\u4EE4\u3002");
-        logger.info(pc11.yellow("\u8BF7\u786E\u4FDD\u5DF2\u5B89\u88C5 gemini-cli \u5E76\u5C06\u5176\u6DFB\u52A0\u5230\u7CFB\u7EDF PATH \u4E2D\u3002"));
+        logger.info(pc13.yellow("\u8BF7\u786E\u4FDD\u5DF2\u5B89\u88C5 gemini-cli \u5E76\u5C06\u5176\u6DFB\u52A0\u5230\u7CFB\u7EDF PATH \u4E2D\u3002"));
       } else {
         logger.error(`AI \u751F\u6210\u8FC7\u7A0B\u4E2D\u51FA\u9519: ${error.message}`);
       }
@@ -2560,132 +2943,1043 @@ Please proceed with generation based on these answers.`;
     }
   }
 }
+var init_gl = __esm({
+  "src/commands/gl.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_utils();
+  }
+});
 
-// src/index.ts
-init_init();
+// src/commands/discover.ts
+var discover_exports = {};
+__export(discover_exports, {
+  discover: () => discover
+});
+import pc14 from "picocolors";
+async function discover() {
+  const cwd = process.cwd();
+  const spinner = createSpinner("\u6B63\u5728\u626B\u63CF\u9879\u76EE\u4E2D\u7684\u63D2\u4EF6...").start();
+  const plugins = await CoreKit.discoverPlugins(cwd);
+  if (plugins.length === 0) {
+    spinner.warn("\u672A\u53D1\u73B0\u4EFB\u4F55\u63D2\u4EF6");
+    logger.info(pc14.gray("\u8BF7\u786E\u4FDD\u63D2\u4EF6\u4F4D\u4E8E plugins/ \u76EE\u5F55\u4E0B\uFF0C\u4E14\u5305\u542B package.json\u3002"));
+  } else {
+    spinner.succeed(`\u53D1\u73B0\u4E86 ${pc14.cyan(plugins.length)} \u4E2A\u63D2\u4EF6`);
+    const pluginList = plugins.map((p) => `- ${pc14.bold(p.name)} ${pc14.gray(`(${p.id})`)}
+  ${pc14.gray(p.path)}`).join("\n\n");
+    printBox(
+      `${pc14.green(pc14.bold("\u2728 \u63D2\u4EF6\u626B\u63CF\u7ED3\u679C"))}
 
-// src/commands/install.ts
-init_esm_shims();
-init_sandbox();
-init_utils();
-import { execa as execa6 } from "execa";
-import fs15 from "fs-extra";
-import path18 from "path";
-import pc13 from "picocolors";
-async function install(target) {
-  if (target.endsWith(".tgz") && fs15.existsSync(target)) {
-    const spinner = createSpinner(`\u6B63\u5728\u5B89\u88C5\u672C\u5730\u79BB\u7EBF\u5305: ${pc13.bold(target)}...`).start();
-    try {
-      const tgzPath = path18.resolve(target);
-      const match = path18.basename(target).match(/chatbi-core-(.+)\.tgz/);
-      let version = "unknown";
-      if (match) {
-        version = match[1];
+${pluginList}`,
+      "Plugin Discovery"
+    );
+  }
+}
+var init_discover = __esm({
+  "src/commands/discover.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_corekit();
+    init_utils();
+  }
+});
+
+// src/commands/clean.ts
+var clean_exports = {};
+__export(clean_exports, {
+  clean: () => clean
+});
+import prompts4 from "prompts";
+async function clean(options) {
+  const cwd = process.cwd();
+  if (options.dryRun) {
+    await Sandbox.clean(cwd, options.deep, true);
+    return;
+  }
+  if (!options.yes) {
+    const { confirm } = await prompts4({
+      type: "confirm",
+      name: "confirm",
+      message: options.deep ? "\u26A0\uFE0F  \u6CE8\u610F: \u6DF1\u5EA6\u6E05\u7406\u5C06\u5220\u9664\u6240\u6709\u6784\u5EFA\u4EA7\u7269(dist)\u53CA\u5168\u5C40\u6C99\u7BB1\uFF0C\u786E\u5B9A\u7EE7\u7EED\u5417\uFF1F" : "\u786E\u5B9A\u8981\u6E05\u7406\u9879\u76EE\u7F13\u5B58\u76EE\u5F55(.chatbi)\u5417\uFF1F",
+      initial: !options.deep
+      // 深度清理默认选否，普通清理默认选是
+    });
+    if (!confirm) {
+      logger.warn("\u5DF2\u53D6\u6D88\u6E05\u7406");
+      return;
+    }
+  }
+  await Sandbox.clean(cwd, options.deep, false);
+}
+var init_clean = __esm({
+  "src/commands/clean.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_sandbox();
+    init_utils();
+  }
+});
+
+// src/commands/bench.ts
+var bench_exports = {};
+__export(bench_exports, {
+  bench: () => bench
+});
+import fs18 from "fs-extra";
+import os2 from "os";
+import path21 from "path";
+import pc15 from "picocolors";
+async function bench() {
+  logger.info("\u6B63\u5728\u542F\u52A8 CLI \u6027\u80FD\u57FA\u51C6\u6D4B\u8BD5...");
+  const results = [];
+  const tmpDir = path21.join(os2.tmpdir(), `chatbi-bench-${Date.now()}`);
+  await fs18.ensureDir(tmpDir);
+  try {
+    const initSpinner = createSpinner("\u6B63\u5728\u6D4B\u8BD5: \u521D\u59CB\u5316\u63D2\u4EF6\u9879\u76EE (init)...").start();
+    const startInit = Date.now();
+    const { init: init2 } = await Promise.resolve().then(() => (init_init(), init_exports));
+    const testProjDir = path21.join(tmpDir, "bench-proj");
+    await init2({ name: "bench-proj", projectType: "plugin", cwd: tmpDir });
+    const endInit = Date.now();
+    const initTime = (endInit - startInit) / 1e3;
+    initSpinner.succeed(`\u521D\u59CB\u5316\u5B8C\u6210: ${pc15.cyan(initTime.toFixed(2) + "s")}`);
+    results.push({
+      scene: "\u521D\u59CB\u5316\u63D2\u4EF6\u9879\u76EE (init)",
+      target: "\u2264 5.0 s",
+      actual: `${initTime.toFixed(2)} s`
+    });
+    const syncSpinner = createSpinner("\u6B63\u5728\u6D4B\u8BD5: \u6C99\u7BB1\u73AF\u5883\u540C\u6B65 (sync)...").start();
+    const startSync = Date.now();
+    const { sync: sync2 } = await Promise.resolve().then(() => (init_sync(), sync_exports));
+    await sync2({ cwd: testProjDir });
+    const endSync = Date.now();
+    const syncTime = (endSync - startSync) / 1e3;
+    syncSpinner.succeed(`\u540C\u6B65\u5B8C\u6210: ${pc15.cyan(syncTime.toFixed(2) + "s")}`);
+    results.push({
+      scene: "\u6C99\u7BB1\u73AF\u5883\u540C\u6B65 (sync)",
+      target: "\u2264 2.0 s",
+      actual: `${syncTime.toFixed(2)} s`
+    });
+    const buildSpinner = createSpinner("\u6B63\u5728\u6D4B\u8BD5: \u63D2\u4EF6\u9879\u76EE\u6784\u5EFA (build)...").start();
+    const startBuild = Date.now();
+    const { build: build2 } = await Promise.resolve().then(() => (init_build(), build_exports));
+    const originalCwd = process.cwd();
+    process.chdir(testProjDir);
+    await build2({ watch: false });
+    process.chdir(originalCwd);
+    const endBuild = Date.now();
+    const buildTime = (endBuild - startBuild) / 1e3;
+    buildSpinner.succeed(`\u6784\u5EFA\u5B8C\u6210: ${pc15.cyan(buildTime.toFixed(2) + "s")}`);
+    results.push({
+      scene: "\u63D2\u4EF6\u9879\u76EE\u6784\u5EFA (build)",
+      target: "\u2264 10.0 s",
+      actual: `${buildTime.toFixed(2)} s`
+    });
+    printBox(
+      `${pc15.green(pc15.bold("\u2728 \u57FA\u51C6\u6D4B\u8BD5\u5B8C\u6210!"))}
+
+` + results.map((r) => `${pc15.white(r.scene.padEnd(20))}: ${pc15.cyan(r.actual)} (\u76EE\u6807 ${r.target})`).join("\n"),
+      "Benchmark Results"
+    );
+  } finally {
+    await fs18.remove(tmpDir);
+  }
+}
+var init_bench = __esm({
+  "src/commands/bench.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_utils();
+  }
+});
+
+// src/commands/lint-theme.ts
+var lint_theme_exports = {};
+__export(lint_theme_exports, {
+  lintTheme: () => lintTheme
+});
+import { loadESLint } from "eslint";
+import fs19 from "fs-extra";
+import path22 from "path";
+async function lintTheme(options) {
+  const projectRoot = findProjectRoot(process.cwd());
+  const cwd = projectRoot;
+  const target = options.target || ".";
+  const files = [path22.isAbsolute(target) ? target : path22.resolve(cwd, target)];
+  if (options.debug) {
+    logger.info("Starting Theme Lint...");
+    logger.info(`Target: ${target}`);
+    logger.info(`Options: ${JSON.stringify(options)}`);
+  }
+  try {
+    const ESLint = await loadESLint({ useFlatConfig: true });
+    const themePlugin = await importThemePlugin();
+    const eslint = new ESLint({
+      cwd,
+      fix: options.fix,
+      overrideConfig: [
+        {
+          files: ["**/*.{js,mjs,cjs,ts,jsx,tsx}"],
+          plugins: {
+            "@chatbi-v/theme": themePlugin
+          },
+          rules: {
+            "@chatbi-v/theme/no-hardcoded-colors": "warn",
+            "@chatbi-v/theme/no-inline-styles": "warn",
+            "@chatbi-v/theme/no-arbitrary-tailwind": "warn",
+            "@chatbi-v/theme/no-hardcoded-tailwind": "warn",
+            "@chatbi-v/theme/no-hardcoded-radius": "warn",
+            "@chatbi-v/theme/no-hardcoded-shadow": "warn",
+            "@chatbi-v/theme/no-hardcoded-spacing": "warn",
+            "@chatbi-v/theme/no-hardcoded-zindex": "warn"
+          }
+        }
+      ]
+    });
+    logger.info(`Scanning files in ${target} for theme violations...`);
+    const results = await eslint.lintFiles(files);
+    if (options.fix) {
+      await ESLint.outputFixes(results);
+      logger.success("Auto-fixes applied where possible.");
+    }
+    const themeRuleIds = [
+      "@chatbi-v/theme/no-hardcoded-colors",
+      "@chatbi-v/theme/no-inline-styles",
+      "@chatbi-v/theme/no-arbitrary-tailwind",
+      "@chatbi-v/theme/no-hardcoded-tailwind",
+      "@chatbi-v/theme/no-hardcoded-radius",
+      "@chatbi-v/theme/no-hardcoded-shadow",
+      "@chatbi-v/theme/no-hardcoded-spacing",
+      "@chatbi-v/theme/no-hardcoded-zindex"
+    ];
+    const filteredResults = results.map((result) => ({
+      ...result,
+      messages: result.messages.filter(
+        (msg) => msg.ruleId && themeRuleIds.includes(msg.ruleId)
+      ),
+      errorCount: 0,
+      // 重置计数，由下方重新计算
+      warningCount: 0
+    })).map((result) => {
+      result.messages.forEach((msg) => {
+        if (msg.severity === 2) result.errorCount++;
+        else if (msg.severity === 1) result.warningCount++;
+      });
+      return result;
+    });
+    const formatterName = options.format || "stylish";
+    const formatter = await eslint.loadFormatter(formatterName);
+    const resultText = await formatter.format(filteredResults);
+    if (options.output) {
+      await fs19.ensureDir(path22.dirname(options.output));
+      await fs19.outputFile(options.output, resultText);
+      logger.success(`Report generated at ${options.output}`);
+    } else {
+      console.log(resultText);
+    }
+    const errorCount = filteredResults.reduce((acc, res) => acc + res.errorCount, 0);
+    const warningCount = filteredResults.reduce((acc, res) => acc + res.warningCount, 0);
+    if (errorCount > 0) {
+      logger.error(`Lint failed with ${errorCount} errors and ${warningCount} warnings.`);
+      process.exit(1);
+    } else if (warningCount > 0) {
+      logger.warn(`Lint finished with ${warningCount} warnings.`);
+    } else {
+      logger.success("Theme lint passed!");
+    }
+  } catch (error) {
+    logger.error("An error occurred during linting:", error);
+    process.exit(1);
+  }
+}
+var importThemePlugin, findProjectRoot;
+var init_lint_theme = __esm({
+  "src/commands/lint-theme.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_utils();
+    importThemePlugin = async () => {
+      try {
+        const { createRequire: createRequire3 } = await import("module");
+        const projectRoot = findProjectRoot(process.cwd());
+        const pluginPath = path22.resolve(projectRoot, "node_modules/@chatbi-v/eslint-plugin-theme");
+        const require2 = createRequire3(import.meta.url);
+        return require2(pluginPath);
+      } catch (e) {
+        logger.error("Failed to load @chatbi-v/eslint-plugin-theme", e);
+        throw e;
       }
-      if (version === "unknown") {
-        spinner.warn("\u65E0\u6CD5\u4ECE\u6587\u4EF6\u540D\u8BC6\u522B\u7248\u672C\uFF0C\u5C06\u4F7F\u7528\u5F53\u524D\u65F6\u95F4\u6233\u4F5C\u4E3A\u7248\u672C\u53F7");
-        version = `local-${Date.now()}`;
+    };
+    findProjectRoot = (startDir) => {
+      let current = startDir;
+      while (current !== path22.dirname(current)) {
+        if (fs19.existsSync(path22.join(current, "package.json")) && fs19.existsSync(path22.join(current, "pnpm-workspace.yaml"))) {
+          return current;
+        }
+        current = path22.dirname(current);
       }
-      const versionRoot = Sandbox.getVersionRoot();
-      await fs15.ensureDir(versionRoot);
-      spinner.text = "\u6B63\u5728\u89E3\u538B\u6587\u4EF6...";
-      await execa6("tar", ["-xzf", tgzPath, "-C", versionRoot]);
-      spinner.succeed(`\u672C\u5730\u5305\u5DF2\u5B89\u88C5\u81F3\u6C99\u7BB1: ${version}`);
-      spinner.text = "\u6B63\u5728\u51C6\u5907\u5185\u6838\u73AF\u5883...";
-      await Sandbox.prepare(version);
-      spinner.succeed("\u5185\u6838\u73AF\u5883\u5C31\u7EEA");
-      printBox(
-        pc13.green(pc13.bold("\u2728 \u672C\u5730\u5185\u6838\u5B89\u88C5\u6210\u529F!")) + "\n\n" + pc13.white("\u7248\u672C: ") + pc13.cyan(version) + "\n" + pc13.white("\u8DEF\u5F84: ") + pc13.gray(Sandbox.getVersionPath(version)),
-        "Install Success"
-      );
-    } catch (e) {
-      spinner.fail("\u5B89\u88C5\u5931\u8D25");
-      throw e;
+      return startDir;
+    };
+  }
+});
+
+// src/commands/plugin/create.ts
+var create_exports = {};
+__export(create_exports, {
+  pluginCreate: () => pluginCreate
+});
+import fs20 from "fs-extra";
+import path23 from "path";
+import pc16 from "picocolors";
+async function pluginCreate(options) {
+  const { name, template = "basic", typescript = true, force = false } = options;
+  if (!/^[a-z0-9-]+$/.test(name)) {
+    logger.error("\u63D2\u4EF6\u540D\u79F0\u53EA\u80FD\u5305\u542B\u5C0F\u5199\u5B57\u6BCD\uFF0C\u6570\u5B57\u548C\u4E2D\u5212\u7EBF");
+    return;
+  }
+  const targetDir = path23.join(process.cwd(), "plugins", name);
+  if (fs20.existsSync(targetDir) && !force) {
+    logger.error(`\u63D2\u4EF6\u76EE\u5F55 ${name} \u5DF2\u5B58\u5728\uFF0C\u8BF7\u4F7F\u7528 --force \u8986\u76D6`);
+    return;
+  }
+  logger.info(`\u6B63\u5728\u521B\u5EFA\u63D2\u4EF6: ${pc16.cyan(name)}`);
+  logger.info(`\u6A21\u677F: ${pc16.yellow(TEMPLATES[template].name)}`);
+  await fs20.ensureDir(targetDir);
+  await fs20.ensureDir(path23.join(targetDir, "src"));
+  await fs20.ensureDir(path23.join(targetDir, "playground", "src"));
+  await fs20.ensureDir(path23.join(targetDir, "tests"));
+  const packageJson = {
+    name: `@chatbi-v/plugin-${name}`,
+    version: "0.1.0",
+    description: `ChatBI-V ${TEMPLATES[template].name}`,
+    main: "src/index.ts",
+    scripts: {
+      dev: "chatbi-cli dev",
+      build: "chatbi-cli build",
+      test: "vitest"
+    },
+    dependencies: {},
+    devDependencies: {
+      "@chatbi-v/core": "workspace:*",
+      typescript: "^5.0.0",
+      vitest: "^1.0.0"
     }
-  } else {
-    const { fetch: fetch2 } = await Promise.resolve().then(() => (init_fetch(), fetch_exports));
-    await fetch2(target);
+  };
+  await fs20.writeJson(path23.join(targetDir, "package.json"), packageJson, { spaces: 2 });
+  const pluginJson = {
+    id: name,
+    name,
+    version: "0.1.0",
+    description: packageJson.description,
+    type: template === "ui" ? "business" : "system",
+    entry: "src/index.ts"
+  };
+  await fs20.writeJson(path23.join(targetDir, "src", "plugin.json"), pluginJson, { spaces: 2 });
+  const entryContent = `/**
+ * ${name} \u63D2\u4EF6
+ * ${TEMPLATES[template].description}
+ */
+
+import type { Plugin } from '@chatbi-v/core';
+
+export const plugin: Plugin = {
+  id: '${name}',
+  name: '${name}',
+  version: '0.1.0',
+
+  async onLoad() {
+    console.log('[${name}] \u63D2\u4EF6\u5DF2\u52A0\u8F7D');
+  },
+
+  async onMount() {
+    console.log('[${name}] \u63D2\u4EF6\u5DF2\u6302\u8F7D');
+  },
+
+  async onUnmount() {
+    console.log('[${name}] \u63D2\u4EF6\u5DF2\u5378\u8F7D');
+  },
+};
+
+export default plugin;
+`;
+  await fs20.writeFile(path23.join(targetDir, "src", "index.ts"), entryContent);
+  if (typescript) {
+    const tsconfig = {
+      extends: "../../tsconfig.base.json",
+      compilerOptions: {
+        outDir: "./dist"
+      },
+      include: ["src/**/*"]
+    };
+    await fs20.writeJson(path23.join(targetDir, "tsconfig.json"), tsconfig, { spaces: 2 });
   }
+  logger.success(`\u63D2\u4EF6 ${pc16.green(name)} \u521B\u5EFA\u6210\u529F!`);
+  logger.info(`\u8BF7\u8FD0\u884C ${pc16.cyan(`cd plugins/${name} && pnpm install`)} \u5B89\u88C5\u4F9D\u8D56`);
 }
+var TEMPLATES;
+var init_create = __esm({
+  "src/commands/plugin/create.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_utils();
+    TEMPLATES = {
+      basic: {
+        name: "\u57FA\u7840\u63D2\u4EF6",
+        description: "\u6700\u5C0F\u63D2\u4EF6\u7ED3\u6784"
+      },
+      command: {
+        name: "\u547D\u4EE4\u63D2\u4EF6",
+        description: "\u5305\u542B\u547D\u4EE4\u5B9A\u4E49"
+      },
+      ui: {
+        name: "UI \u63D2\u4EF6",
+        description: "\u5305\u542B UI \u7EC4\u4EF6"
+      },
+      ai: {
+        name: "AI \u63D2\u4EF6",
+        description: "\u5305\u542B AI \u80FD\u529B"
+      }
+    };
+  }
+});
 
-// src/commands/ls.ts
-init_esm_shims();
-init_corekit();
-init_sandbox();
-init_utils();
-import pc14 from "picocolors";
-async function ls() {
-  const versions = await CoreKit.listVersions();
-  const currentVersion = await CoreKit.resolveVersion(process.cwd());
-  const globalCurrentVersion = await CoreKit.resolveVersion();
-  logger.info("\u5DF2\u5B89\u88C5\u7684\u5185\u6838\u6C99\u7BB1\u7248\u672C:");
-  if (versions.length === 0) {
-    logger.warn("\u5C1A\u672A\u5B89\u88C5\u4EFB\u4F55\u7248\u672C\uFF0C\u8BF7\u8FD0\u884C chatbi sync \u8FDB\u884C\u5B89\u88C5\u3002");
-  } else {
-    const list = versions.map((v) => {
-      const isGlobalCurrent = v === globalCurrentVersion;
-      const isProjectCurrent = v === currentVersion;
-      let prefix = "  ";
-      if (isProjectCurrent) {
-        prefix = pc14.green(" *");
-      } else if (isGlobalCurrent) {
-        prefix = pc14.blue(" >");
+// src/commands/plugin/build.ts
+var build_exports2 = {};
+__export(build_exports2, {
+  pluginBuild: () => pluginBuild
+});
+import fs21 from "fs-extra";
+import path24 from "path";
+import pc17 from "picocolors";
+async function pluginBuild(options = {}) {
+  const { watch = false, minify = true } = options;
+  const cwd = process.cwd();
+  const spinner = createSpinner("\u6B63\u5728\u51C6\u5907\u6784\u5EFA\u73AF\u5883...").start();
+  const pkgPath = path24.join(cwd, "package.json");
+  if (!fs21.existsSync(pkgPath)) {
+    spinner.fail("\u672A\u627E\u5230 package.json");
+    logger.error("\u8BF7\u5728\u63D2\u4EF6\u76EE\u5F55\u4E2D\u8FD0\u884C\u6B64\u547D\u4EE4");
+    return;
+  }
+  const pkg = await fs21.readJson(pkgPath);
+  spinner.text = "\u6B63\u5728\u8BFB\u53D6\u63D2\u4EF6\u914D\u7F6E...";
+  let entry = "src/index.ts";
+  if (fs21.existsSync(path24.join(cwd, "src/index.tsx"))) {
+    entry = "src/index.tsx";
+  } else if (!fs21.existsSync(path24.join(cwd, "src/index.ts"))) {
+    spinner.fail("\u672A\u627E\u5230\u5165\u53E3\u6587\u4EF6");
+    logger.error("\u671F\u671B src/index.ts \u6216 src/index.tsx");
+    return;
+  }
+  const pluginJsonPath = path24.join(cwd, "src/plugin.json");
+  if (!fs21.existsSync(pluginJsonPath)) {
+    spinner.warn("\u672A\u627E\u5230 src/plugin.json\uFF0C\u5C06\u4F7F\u7528\u9ED8\u8BA4\u914D\u7F6E");
+  }
+  spinner.text = "\u6B63\u5728\u6784\u5EFA\u63D2\u4EF6...";
+  const corePackages = [
+    "@chatbi-v/core",
+    "react",
+    "react-dom",
+    "react/jsx-runtime",
+    "react-is",
+    "antd",
+    "@ant-design/icons",
+    "@ant-design/x"
+  ];
+  const external = [
+    ...corePackages,
+    ...Object.keys(pkg.dependencies || {}),
+    ...Object.keys(pkg.peerDependencies || {})
+  ];
+  if (!watch) {
+    await fs21.remove(path24.join(cwd, "dist"));
+  }
+  const esmSpinner = createSpinner("\u6B63\u5728\u6784\u5EFA ESM \u683C\u5F0F...").start();
+  try {
+    const { build: tsupBuild } = await import("tsup");
+    await tsupBuild({
+      entry: [entry],
+      format: ["esm"],
+      platform: "browser",
+      outDir: "dist",
+      splitting: false,
+      sourcemap: false,
+      minify: false,
+      // ESM 格式不压缩，方便调试
+      watch,
+      silent: true,
+      external,
+      outExtension: () => ({ js: ".mjs" }),
+      esbuildOptions(esbuildOpts) {
+        esbuildOpts.logOverride = { "empty-import-meta": "silent" };
       }
-      let suffix = "";
-      if (isProjectCurrent && isGlobalCurrent) {
-        suffix = pc14.gray(" (\u5F53\u524D\u9879\u76EE & \u5168\u5C40)");
-      } else if (isProjectCurrent) {
-        suffix = pc14.gray(" (\u5F53\u524D\u9879\u76EE)");
-      } else if (isGlobalCurrent) {
-        suffix = pc14.gray(" (\u5168\u5C40)");
+    });
+    esmSpinner.succeed("ESM \u683C\u5F0F\u6784\u5EFA\u5B8C\u6210");
+  } catch (e) {
+    esmSpinner.fail("ESM \u683C\u5F0F\u6784\u5EFA\u5931\u8D25");
+    logger.error(`\u6784\u5EFA\u5931\u8D25: ${e.message}`);
+    return;
+  }
+  const iifeSpinner = createSpinner("\u6B63\u5728\u6784\u5EFA IIFE \u683C\u5F0F...").start();
+  try {
+    const { build: tsupBuild } = await import("tsup");
+    const globalName = (pkg.name || "plugin").replace(/[^a-zA-Z0-9]/g, "_");
+    await tsupBuild({
+      entry: [entry],
+      format: ["iife"],
+      platform: "browser",
+      outDir: "dist",
+      splitting: false,
+      sourcemap: false,
+      minify: watch ? false : minify,
+      watch,
+      silent: true,
+      external,
+      globalName,
+      outExtension: () => ({ js: ".plugin.js" }),
+      define: {
+        "import.meta.env": "process.env"
+      },
+      esbuildOptions(esbuildOpts) {
+        esbuildOpts.logOverride = { "empty-import-meta": "silent" };
+        corePackages.forEach((dep) => {
+          if (!esbuildOpts.external.includes(dep)) {
+            esbuildOpts.external.push(dep);
+          }
+        });
       }
-      return `${prefix} ${pc14.white(v)}${suffix}`;
-    }).join("\n");
+    });
+    iifeSpinner.succeed("IIFE \u683C\u5F0F\u6784\u5EFA\u5B8C\u6210");
+  } catch (e) {
+    iifeSpinner.fail("IIFE \u683C\u5F0F\u6784\u5EFA\u5931\u8D25");
+    logger.error(`\u6784\u5EFA\u5931\u8D25: ${e.message}`);
+    return;
+  }
+  const distDir = path24.join(cwd, "dist");
+  if (fs21.existsSync(distDir)) {
+    const files = await fs21.readdir(distDir);
+    const\u4EA7\u7269 = files.filter((f) => f.endsWith(".mjs") || f.endsWith(".plugin.js")).map((f) => pc17.cyan(f)).join(", ");
     printBox(
-      list + pc14.gray("\n\n\u63D0\u793A: * \u5F53\u524D\u9879\u76EE\u4F7F\u7528, > \u5168\u5C40\u9ED8\u8BA4\u4F7F\u7528"),
-      "Kernel Versions"
+      pc17.green(pc17.bold("\u2728 \u63D2\u4EF6\u6784\u5EFA\u6210\u529F!")) + "\n\n" + pc17.white("\u4EA7\u7269\u76EE\u5F55: ") + pc17.cyan("dist") + "\n" + pc17.white("\u4EA7\u7269\u6587\u4EF6: ") + \u4EA7\u7269,
+      "Build Success"
     );
   }
-  await Sandbox.visualizeStatus(process.cwd());
+  if (watch) {
+    logger.info(pc17.gray("\u76D1\u542C\u6A21\u5F0F\u5DF2\u5F00\u542F\uFF0C\u6309 Ctrl+C \u505C\u6B62..."));
+  }
 }
+var init_build2 = __esm({
+  "src/commands/plugin/build.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_utils();
+  }
+});
 
-// src/index.ts
-init_sync();
+// src/commands/plugin/validate.ts
+var validate_exports = {};
+__export(validate_exports, {
+  pluginValidate: () => pluginValidate
+});
+import fs22 from "fs-extra";
+import path25 from "path";
+import pc18 from "picocolors";
+import { z } from "zod";
+async function pluginValidate(options = {}) {
+  const cwd = process.cwd();
+  const result = {
+    valid: true,
+    errors: [],
+    warnings: []
+  };
+  const spinner = createSpinner("\u6B63\u5728\u9A8C\u8BC1\u63D2\u4EF6\u914D\u7F6E...").start();
+  const pkgPath = path25.join(cwd, "package.json");
+  if (!fs22.existsSync(pkgPath)) {
+    spinner.fail("\u672A\u627E\u5230 package.json");
+    result.valid = false;
+    result.errors.push("\u672A\u627E\u5230 package.json");
+    return result;
+  }
+  spinner.text = "\u6B63\u5728\u8BFB\u53D6\u63D2\u4EF6\u914D\u7F6E...";
+  const pkg = await fs22.readJson(pkgPath);
+  const pluginJsonPath = path25.join(cwd, "src/plugin.json");
+  if (!fs22.existsSync(pluginJsonPath)) {
+    spinner.fail("\u672A\u627E\u5230 src/plugin.json");
+    result.valid = false;
+    result.errors.push("\u672A\u627E\u5230 src/plugin.json\uFF0C\u8BF7\u5148\u8FD0\u884C plugin create \u6216\u624B\u52A8\u521B\u5EFA");
+    if (options.fix) {
+      const fixSpinner = createSpinner("\u6B63\u5728\u81EA\u52A8\u521B\u5EFA plugin.json...").start();
+      try {
+        const defaultManifest = {
+          id: pkg.name?.replace("@chatbi-v/plugin-", "") || "unnamed",
+          name: pkg.name || "Unnamed Plugin",
+          version: pkg.version || "0.1.0",
+          description: pkg.description || "",
+          entry: pkg.main || "src/index.ts"
+        };
+        await fs22.ensureDir(path25.join(cwd, "src"));
+        await fs22.writeJson(pluginJsonPath, defaultManifest, { spaces: 2 });
+        fixSpinner.succeed("\u5DF2\u521B\u5EFA src/plugin.json");
+        result.errors = result.errors.filter((e) => !e.includes("plugin.json"));
+      } catch (e) {
+        fixSpinner.fail("\u521B\u5EFA\u5931\u8D25");
+      }
+    }
+    return result;
+  }
+  spinner.text = "\u6B63\u5728\u9A8C\u8BC1 Manifest \u683C\u5F0F...";
+  try {
+    const pluginJson = await fs22.readJson(pluginJsonPath);
+    const validation = PluginManifestSchema.safeParse(pluginJson);
+    if (!validation.success) {
+      spinner.fail("Manifest \u683C\u5F0F\u9A8C\u8BC1\u5931\u8D25");
+      result.valid = false;
+      validation.error.errors.forEach((err) => {
+        result.errors.push(`[${err.path.join(".")}] ${err.message}`);
+      });
+      return result;
+    }
+    const entryPath = path25.join(cwd, pluginJson.entry);
+    if (!fs22.existsSync(entryPath)) {
+      spinner.fail(`\u5165\u53E3\u6587\u4EF6\u4E0D\u5B58\u5728: ${pluginJson.entry}`);
+      result.valid = false;
+      result.errors.push(`\u5165\u53E3\u6587\u4EF6\u4E0D\u5B58\u5728: ${pluginJson.entry}`);
+      return result;
+    }
+    spinner.text = "\u6B63\u5728\u68C0\u67E5\u4F9D\u8D56\u53EF\u89E3\u6790\u6027...";
+    const deps = {
+      ...pkg.dependencies || {},
+      ...pkg.peerDependencies || {}
+    };
+    const nodeModulesPath = path25.join(cwd, "node_modules");
+    for (const [dep, version] of Object.entries(deps)) {
+      if (version.startsWith("workspace:") || version.startsWith("file:")) {
+        continue;
+      }
+      if (["react", "react-dom", "antd", "@chatbi-v/core"].includes(dep)) {
+        continue;
+      }
+      const depPath = path25.join(nodeModulesPath, dep);
+      if (!fs22.existsSync(depPath)) {
+        result.warnings.push(`\u4F9D\u8D56\u672A\u5B89\u88C5: ${dep}@${version}`);
+      }
+    }
+    spinner.succeed("\u63D2\u4EF6\u9A8C\u8BC1\u901A\u8FC7");
+    if (result.warnings.length > 0) {
+      const warningList = result.warnings.map((w) => pc18.yellow(`\u2022 ${w}`)).join("\n");
+      printBox(
+        `${pc18.green(pc18.bold("\u2713 \u63D2\u4EF6\u914D\u7F6E\u9A8C\u8BC1\u901A\u8FC7"))}
 
-// src/commands/use.ts
-init_esm_shims();
-init_corekit();
-init_sandbox();
-init_utils();
-init_sync();
-import fs16 from "fs-extra";
-import path19 from "path";
-async function use(version, options = {}) {
-  const versions = await CoreKit.listVersions();
-  if (!versions.includes(version)) {
-    logger.warn(`\u7248\u672C ${version} \u5C1A\u672A\u5B89\u88C5\uFF0C\u6B63\u5728\u5C1D\u8BD5\u5B89\u88C5...`);
-    await Sandbox.prepare(version);
+` + pc18.yellow(pc18.bold("\u26A0 \u8B66\u544A:")) + "\n\n" + warningList,
+        "Validation Warning"
+      );
+    } else {
+      printBox(
+        pc18.green(pc18.bold("\u2713 \u63D2\u4EF6\u914D\u7F6E\u9A8C\u8BC1\u901A\u8FC7")),
+        "Validation Success"
+      );
+    }
+    return result;
+  } catch (e) {
+    spinner.fail("\u9A8C\u8BC1\u8FC7\u7A0B\u51FA\u9519");
+    result.valid = false;
+    result.errors.push(`\u9A8C\u8BC1\u5931\u8D25: ${e.message}`);
+    return result;
   }
-  if (options.global) {
-    await Sandbox.useVersion(version);
-    logger.success(`\u5DF2\u5207\u6362\u5168\u5C40\u5185\u6838\u7248\u672C\u81F3: ${version}`);
+}
+var PluginManifestSchema;
+var init_validate = __esm({
+  "src/commands/plugin/validate.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_utils();
+    PluginManifestSchema = z.object({
+      id: z.string().min(1, "\u63D2\u4EF6 ID \u4E0D\u80FD\u4E3A\u7A7A"),
+      name: z.string().min(1, "\u63D2\u4EF6\u540D\u79F0\u4E0D\u80FD\u4E3A\u7A7A"),
+      version: z.string().regex(/^\d+\.\d+\.\d+/, "\u7248\u672C\u53F7\u683C\u5F0F\u9519\u8BEF"),
+      description: z.string().optional(),
+      type: z.enum(["business", "system"]).optional(),
+      entry: z.string().min(1, "\u5165\u53E3\u6587\u4EF6\u4E0D\u80FD\u4E3A\u7A7A"),
+      dependencies: z.record(z.string()).optional(),
+      peerDependencies: z.record(z.string()).optional()
+    });
+  }
+});
+
+// src/commands/plugin/publish.ts
+var publish_exports = {};
+__export(publish_exports, {
+  pluginPublish: () => pluginPublish
+});
+async function pluginPublish(options) {
+  logger.warn("\u63D2\u4EF6\u53D1\u5E03\u529F\u80FD\u6B63\u5728\u5F00\u53D1\u4E2D...");
+}
+var init_publish = __esm({
+  "src/commands/plugin/publish.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_utils();
+  }
+});
+
+// src/commands/theme/create.ts
+var create_exports2 = {};
+__export(create_exports2, {
+  themeCreate: () => themeCreate
+});
+import fs23 from "fs-extra";
+import path26 from "path";
+import pc19 from "picocolors";
+async function themeCreate(options) {
+  const { name, base = "standard", css = false } = options;
+  const targetDir = path26.join(process.cwd(), "themes", name);
+  const baseTheme = BASE_THEMES[base];
+  logger.info(`\u6B63\u5728\u521B\u5EFA\u4E3B\u9898: ${pc19.cyan(name)}`);
+  logger.info(`\u57FA\u7840\u4E3B\u9898: ${pc19.yellow(baseTheme.name)}`);
+  await fs23.ensureDir(targetDir);
+  if (css) {
+    const cssContent = `:root {
+  --color-primary: ${baseTheme.colors.primary};
+  --color-background: ${baseTheme.colors.background};
+}
+
+[data-theme="${name}"] {
+  --color-primary: ${baseTheme.colors.primary};
+  --color-background: ${baseTheme.colors.background};
+}
+`;
+    await fs23.writeFile(path26.join(targetDir, "theme.css"), cssContent);
   } else {
-    const cwd = process.cwd();
-    const versionFilePath = path19.join(cwd, ".chatbi-version");
-    await fs16.writeFile(versionFilePath, version, "utf-8");
-    logger.success(`\u5DF2\u5207\u6362\u5F53\u524D\u9879\u76EE\u5185\u6838\u7248\u672C\u4E3A: ${version}`);
+    const tailwindConfig = {
+      theme: {
+        extend: {
+          colors: {
+            primary: baseTheme.colors.primary,
+            background: baseTheme.colors.background
+          }
+        }
+      }
+    };
+    await fs23.writeJson(path26.join(targetDir, "tailwind.config.js"), tailwindConfig, { spaces: 2 });
+  }
+  const themeJson = {
+    id: name,
+    name,
+    base,
+    version: "0.1.0"
+  };
+  await fs23.writeJson(path26.join(targetDir, "theme.json"), themeJson, { spaces: 2 });
+  logger.success(`\u4E3B\u9898 ${pc19.green(name)} \u521B\u5EFA\u6210\u529F!`);
+}
+var BASE_THEMES;
+var init_create2 = __esm({
+  "src/commands/theme/create.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_utils();
+    BASE_THEMES = {
+      standard: {
+        name: "\u6807\u51C6\u4E3B\u9898",
+        colors: { primary: "#4F46E5", background: "#FFFFFF" }
+      },
+      nebula: {
+        name: "\u661F\u4E91\u4E3B\u9898",
+        colors: { primary: "#7C3AED", background: "#0F172A" }
+      },
+      glass: {
+        name: "\u73BB\u7483\u4E3B\u9898",
+        colors: { primary: "#06B6D4", background: "#1E293B" }
+      }
+    };
+  }
+});
+
+// src/commands/scaffold.ts
+var scaffold_exports = {};
+__export(scaffold_exports, {
+  scaffold: () => scaffold
+});
+import fs24 from "fs-extra";
+import path27 from "path";
+import pc20 from "picocolors";
+async function scaffold(options) {
+  const { name, template = "full", typescript = true, theme = "standard" } = options;
+  const targetDir = path27.join(process.cwd(), name);
+  if (fs24.existsSync(targetDir)) {
+    logger.error(`\u76EE\u5F55 ${name} \u5DF2\u5B58\u5728`);
+    return;
+  }
+  logger.info(`\u6B63\u5728\u521B\u5EFA\u9879\u76EE: ${pc20.cyan(name)}`);
+  logger.info(`\u6A21\u677F: ${pc20.yellow(TEMPLATES2[template].name)}`);
+  await fs24.ensureDir(targetDir);
+  const packageJson = {
+    name,
+    version: "0.1.0",
+    private: true,
+    scripts: {
+      dev: "chatbi-cli dev",
+      build: "chatbi-cli build",
+      test: "vitest"
+    },
+    dependencies: {
+      "@chatbi-v/core": "workspace:*",
+      react: "^18.2.0",
+      "react-dom": "^18.2.0"
+    },
+    devDependencies: {
+      "@types/react": "^18.2.0",
+      typescript: "^5.0.0",
+      vite: "^5.0.0"
+    }
+  };
+  await fs24.writeJson(path27.join(targetDir, "package.json"), packageJson, { spaces: 2 });
+  await fs24.ensureDir(path27.join(targetDir, "apps", "deepinsight"));
+  await fs24.ensureDir(path27.join(targetDir, "packages", "plugins"));
+  await fs24.writeFile(path27.join(targetDir, "pnpm-workspace.yaml"), 'packages:\n  - "apps/*"\n  - "packages/*"\n');
+  if (typescript) {
+    const viteConfig = `import { defineConfig } from 'vite';
+import react from '@vitejs/plugin-react';
+
+export default defineConfig({
+  plugins: [react()],
+});
+`;
+    await fs24.writeFile(path27.join(targetDir, "vite.config.ts"), viteConfig);
+  }
+  logger.success(`\u9879\u76EE ${pc20.green(name)} \u521B\u5EFA\u6210\u529F!`);
+  logger.info(`\u8BF7\u8FD0\u884C ${pc20.cyan(`cd ${name} && pnpm install`)} \u5B89\u88C5\u4F9D\u8D56`);
+}
+var TEMPLATES2;
+var init_scaffold = __esm({
+  "src/commands/scaffold.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_utils();
+    TEMPLATES2 = {
+      full: {
+        name: "\u5B8C\u6574\u5E94\u7528",
+        description: "\u5305\u542B\u591A\u4E2A\u63D2\u4EF6\u548C\u5B8C\u6574\u914D\u7F6E"
+      },
+      minimal: {
+        name: "\u6700\u5C0F\u5E94\u7528",
+        description: "\u5305\u542B\u57FA\u7840\u63D2\u4EF6"
+      },
+      empty: {
+        name: "\u7A7A\u9879\u76EE",
+        description: "\u4EC5\u5305\u542B\u9879\u76EE\u7ED3\u6784"
+      }
+    };
+  }
+});
+
+// src/commands/upgrade.ts
+var upgrade_exports = {};
+__export(upgrade_exports, {
+  upgrade: () => upgrade
+});
+import { execSync } from "child_process";
+import pc21 from "picocolors";
+async function upgrade(targetVersion) {
+  const currentVersion = package_default.version;
+  logger.info(`\u5F53\u524D\u7248\u672C: ${pc21.cyan(currentVersion)}`);
+  if (targetVersion) {
+    logger.info(`\u6B63\u5728\u5347\u7EA7\u5230\u7248\u672C: ${pc21.yellow(targetVersion)}`);
+    try {
+      execSync(`pnpm add -g @chatbi-v/cli@${targetVersion}`, {
+        stdio: "inherit"
+      });
+      logger.success("\u5347\u7EA7\u6210\u529F!");
+    } catch (error) {
+      logger.error("\u5347\u7EA7\u5931\u8D25", error);
+    }
+  } else {
+    logger.info("\u6B63\u5728\u68C0\u67E5\u6700\u65B0\u7248\u672C...");
+    try {
+      const latestVersion = execSync("npm view @chatbi-v/cli version", {
+        encoding: "utf-8"
+      }).trim();
+      if (latestVersion > currentVersion) {
+        logger.info(`\u6700\u65B0\u7248\u672C: ${pc21.green(latestVersion)}`);
+        logger.info(`\u8BF7\u8FD0\u884C ${pc21.cyan(`pnpm add -g @chatbi-v/cli@${latestVersion}`)} \u5347\u7EA7`);
+      } else {
+        logger.success("\u5F53\u524D\u5DF2\u662F\u6700\u65B0\u7248\u672C!");
+      }
+    } catch {
+      logger.warn("\u65E0\u6CD5\u68C0\u67E5\u6700\u65B0\u7248\u672C");
+    }
+  }
+}
+var init_upgrade = __esm({
+  "src/commands/upgrade.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_package();
+    init_utils();
+  }
+});
+
+// src/commands/devtools/types.ts
+var types_exports = {};
+__export(types_exports, {
+  devtoolsTypes: () => devtoolsTypes
+});
+import { PluginManifestSchema as PluginManifestSchema2 } from "@chatbi-v/core";
+import fs25 from "fs-extra";
+import path28 from "path";
+import pc22 from "picocolors";
+async function devtoolsTypes(options) {
+  const { input = "src/plugin.json", output, type = "full" } = options;
+  const inputPath = path28.resolve(process.cwd(), input);
+  if (!fs25.existsSync(inputPath)) {
+    logger.error(`\u627E\u4E0D\u5230 plugin.json \u6587\u4EF6: ${inputPath}`);
+    return;
+  }
+  logger.info(`\u8BFB\u53D6\u63D2\u4EF6\u6E05\u5355: ${pc22.cyan(inputPath)}`);
+  try {
+    const pluginJson = await fs25.readJson(inputPath);
+    const manifest = PluginManifestSchema2.parse(pluginJson);
+    const typeCode = generateTypeDefinition(manifest, type);
+    if (output) {
+      const outputPath = path28.resolve(process.cwd(), output);
+      await fs25.ensureDir(path28.dirname(outputPath));
+      await fs25.writeFile(outputPath, typeCode, "utf-8");
+      logger.success(`\u7C7B\u578B\u5B9A\u4E49\u5DF2\u751F\u6210: ${pc22.green(outputPath)}`);
+    } else {
+      console.log(typeCode);
+    }
+  } catch (error) {
+    logger.error("\u751F\u6210\u7C7B\u578B\u5B9A\u4E49\u5931\u8D25", error);
+  }
+}
+function generateTypeDefinition(manifest, type) {
+  const lines = [
+    "// Auto-generated TypeScript definitions",
+    `// Generated at: ${(/* @__PURE__ */ new Date()).toISOString()}`,
+    `// Plugin: ${manifest.id} v${manifest.version}`,
+    "",
+    "import { z } from 'zod';",
+    "",
+    "// ============================================================",
+    "// Plugin Manifest",
+    "// ============================================================",
+    "",
+    "export interface PluginManifest {",
+    `  id: '${manifest.id}';`,
+    `  name: '${manifest.name}';`,
+    `  version: '${manifest.version}';`,
+    manifest.type ? `  type: '${manifest.type}';` : "",
+    manifest.description ? `  description: '${manifest.description}';` : "",
+    manifest.author ? `  author: '${manifest.author}';` : "",
+    manifest.entry,
+    "  // ...other fields",
+    "}",
+    ""
+  ];
+  if (type === "full") {
+    lines.push(
+      "// ============================================================",
+      "// Dependencies",
+      "// ============================================================",
+      ""
+    );
+    if (manifest.dependencies && manifest.dependencies.length > 0) {
+      lines.push("export interface PluginDependencies {");
+      manifest.dependencies.forEach((dep) => {
+        lines.push(
+          `  '${dep.id}': '${dep.version}'${dep.optional ? " // optional" : ""};`
+        );
+      });
+      lines.push("}");
+      lines.push("");
+    }
+    lines.push(
+      "// ============================================================",
+      "// Extensions",
+      "// ============================================================",
+      ""
+    );
+    if (manifest.extensions && manifest.extensions.length > 0) {
+      lines.push("export type ExtensionType = " + [...new Set(manifest.extensions.map((e) => `'${e.type}'`))].join(" | ") + ";");
+      lines.push("");
+      lines.push("export interface PluginExtensions {");
+      manifest.extensions.forEach((ext) => {
+        lines.push(`  ${ext.name}: {`);
+        lines.push(`    type: '${ext.type}';`);
+        if (ext.description) lines.push(`    description: '${ext.description}';`);
+        if (ext.slot) lines.push(`    slot: '${ext.slot}';`);
+        lines.push("  };");
+      });
+      lines.push("}");
+      lines.push("");
+    }
+    if (manifest.configuration && manifest.configuration.length > 0) {
+      lines.push(
+        "// ============================================================",
+        "// Configuration",
+        "// ============================================================",
+        "",
+        "export interface PluginConfiguration {"
+      );
+      manifest.configuration.forEach((config4) => {
+        lines.push(`  ${config4.key}: ${configTypeToTs(config4.type)};`);
+      });
+      lines.push("}");
+      lines.push("");
+    }
+  }
+  lines.push(
+    "// ============================================================",
+    "// Zod Schema (for validation)",
+    "// ============================================================",
+    "",
+    "export const PluginManifestSchema = z.object({",
+    `  id: z.literal('${manifest.id}'),`,
+    `  name: z.string().default('${manifest.name}'),`,
+    `  version: z.string().default('${manifest.version}'),`,
+    "  // ...other schema fields",
+    "});",
+    ""
+  );
+  return lines.filter(Boolean).join("\n");
+}
+function configTypeToTs(configType) {
+  switch (configType) {
+    case "string":
+      return "string";
+    case "number":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "select":
+      return "string";
+    default:
+      return "unknown";
   }
-  await sync({ version, force: false });
 }
+var init_types = __esm({
+  "src/commands/devtools/types.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_utils();
+  }
+});
 
 // src/index.ts
+init_esm_shims();
+init_package();
 init_utils();
+import boxen2 from "boxen";
+import cac from "cac";
+import figlet from "figlet";
+import gradient from "gradient-string";
+import pc23 from "picocolors";
 var cli = cac("chatbi-cli");
 var showHeader = () => {
   const title = figlet.textSync("ChatBI-V CLI", { font: "Standard" });
-  console.log(gradient.pastel.multiline(title));
-  console.log(
-    boxen2(pc16.cyan(`ChatBI-V \u7EDF\u4E00\u5F00\u53D1\u5DE5\u5177 v${package_default.version}`), {
+  logger.info(gradient.pastel.multiline(title));
+  logger.info(
+    boxen2(pc23.cyan(`ChatBI-V \u7EDF\u4E00\u5F00\u53D1\u5DE5\u5177 v${package_default.version}`), {
       padding: 0,
       margin: { top: 1, bottom: 1 },
       borderStyle: "round",
@@ -2698,6 +3992,11 @@ var showHeader = () => {
 var wrapAction = (action, commandName) => {
   return async (...args) => {
     const updateCheckPromise = checkForUpdates(package_default.version);
+    const options = args[args.length - 1];
+    if (options && options.debug) {
+      setDebugMode(true);
+      logger.debug("Debug mode enabled");
+    }
     showHeader();
     try {
       await action(...args);
@@ -2712,22 +4011,38 @@ var wrapAction = (action, commandName) => {
     }
   };
 };
-cli.command("dev", "\u542F\u52A8\u5F00\u53D1\u670D\u52A1\u5668").alias("d").option("--port <port>", "\u7AEF\u53E3\u53F7").action(wrapAction(dev, "dev"));
-cli.command("build", "\u6784\u5EFA\u5F53\u524D\u9879\u76EE").alias("b").option("--watch", "\u5F00\u542F\u76D1\u542C\u6A21\u5F0F").option("--force", "\u5F3A\u5236\u91CD\u65B0\u521D\u59CB\u5316\u73AF\u5883 (\u6E05\u7406\u7F13\u5B58)").action(wrapAction(build, "build"));
-cli.command("fetch <version>", "\u83B7\u53D6\u6307\u5B9A\u7248\u672C\u7684\u5185\u6838 (\u652F\u6301\u6253\u5305)").option("--pack", "\u6253\u5305\u4E3A\u79BB\u7EBF\u5B89\u88C5\u5305 (.tgz)").action(wrapAction(fetch, "fetch"));
-cli.command("install <target>", "\u5B89\u88C5\u5185\u6838 (\u652F\u6301\u7248\u672C\u53F7\u6216\u79BB\u7EBF\u5305\u8DEF\u5F84)").action(wrapAction(install, "install"));
-cli.command("init [name]", "\u521D\u59CB\u5316\u4E00\u4E2A\u65B0\u7684\u4E1A\u52A1\u63D2\u4EF6\u9879\u76EE").alias("create").alias("i").option("--project-type <type>", "\u9879\u76EE\u7C7B\u578B (monorepo | app | plugin)").option("--include-app", "Monorepo \u4E2D\u5305\u542B App").option("--no-include-app", "Monorepo \u4E2D\u4E0D\u5305\u542B App").option("--include-plugin", "Monorepo \u4E2D\u5305\u542B Plugin").option("--no-include-plugin", "Monorepo \u4E2D\u4E0D\u5305\u542B Plugin").option("--plugin-type <type>", "\u63D2\u4EF6\u7C7B\u578B (business | system)").option("--theme <theme>", "\u4E3B\u9898 (standard | nebula | glass)").action(wrapAction(async (name, options) => {
-  await init({
+cli.option("--debug", "\u5F00\u542F\u8C03\u8BD5\u6A21\u5F0F");
+cli.command("dev", "\u542F\u52A8\u5F00\u53D1\u670D\u52A1\u5668").alias("d").option("--port <port>", "\u7AEF\u53E3\u53F7").action(wrapAction(async (options) => {
+  const { dev: dev2 } = await Promise.resolve().then(() => (init_dev(), dev_exports));
+  await dev2(options);
+}, "dev"));
+cli.command("build", "\u6784\u5EFA\u5F53\u524D\u9879\u76EE").alias("b").option("--watch", "\u5F00\u542F\u76D1\u542C\u6A21\u5F0F").option("--force", "\u5F3A\u5236\u91CD\u65B0\u521D\u59CB\u5316\u73AF\u5883 (\u6E05\u7406\u7F13\u5B58)").action(wrapAction(async (options) => {
+  const { build: build2 } = await Promise.resolve().then(() => (init_build(), build_exports));
+  await build2(options);
+}, "build"));
+cli.command("fetch <version>", "\u83B7\u53D6\u6307\u5B9A\u7248\u672C\u7684\u5185\u6838 (\u652F\u6301\u6253\u5305)").option("--pack", "\u6253\u5305\u4E3A\u79BB\u7EBF\u5B89\u88C5\u5305 (.tgz)").action(wrapAction(async (version, options) => {
+  const { fetch: fetch2 } = await Promise.resolve().then(() => (init_fetch(), fetch_exports));
+  await fetch2(version, options);
+}, "fetch"));
+cli.command("install <target>", "\u5B89\u88C5\u5185\u6838 (\u652F\u6301\u7248\u672C\u53F7\u6216\u79BB\u7EBF\u5305\u8DEF\u5F84)").action(wrapAction(async (target) => {
+  const { install: install2 } = await Promise.resolve().then(() => (init_install(), install_exports));
+  await install2(target);
+}, "install"));
+cli.command("init [name]", "\u521D\u59CB\u5316\u4E00\u4E2A\u65B0\u7684\u4E1A\u52A1\u63D2\u4EF6\u9879\u76EE").alias("create").alias("i").option("--project-type <type>", "\u9879\u76EE\u7C7B\u578B (monorepo | app | plugin)").option("--include-app", "Monorepo \u4E2D\u5305\u542B App").option("--no-include-app", "Monorepo \u4E2D\u4E0D\u5305\u542B App").option("--include-plugin", "Monorepo \u4E2D\u5305\u542B Plugin").option("--no-include-plugin", "Monorepo \u4E2D\u4E0D\u5305\u542B Plugin").option("--plugin-type <type>", "\u63D2\u4EF6\u7C7B\u578B (business | system)").option("--theme <theme>", "\u4E3B\u9898 (standard | nebula | glass)").option("--force", "\u5F3A\u5236\u8986\u76D6\u76EE\u6807\u76EE\u5F55").action(wrapAction(async (name, options) => {
+  const { init: init2 } = await Promise.resolve().then(() => (init_init(), init_exports));
+  await init2({
     name,
     projectType: options.projectType,
     includeApp: options.includeApp,
     includePlugin: options.includePlugin,
     pluginType: options.pluginType,
-    theme: options.theme
+    theme: options.theme,
+    force: options.force
   });
 }, "init"));
 cli.command("add [name]", "\u5728\u5F53\u524D\u9879\u76EE\u4E2D\u6DFB\u52A0\u4E00\u4E2A\u65B0\u63D2\u4EF6").option("-t, --type <type>", "\u63D2\u4EF6\u7C7B\u578B (business | system)").option("--display-name <name>", "\u63D2\u4EF6\u663E\u793A\u540D\u79F0").option("--desc <description>", "\u63D2\u4EF6\u63CF\u8FF0").action(wrapAction(async (name, options) => {
-  await add({
+  const { add: add2 } = await Promise.resolve().then(() => (init_add(), add_exports));
+  await add2({
     name,
     type: options.type,
     displayName: options.displayName,
@@ -2740,36 +4055,97 @@ cli.command("update [targetVersion]", "\u66F4\u65B0\u5185\u6838\u7248\u672C").al
   logger.success("\u66F4\u65B0\u5B8C\u6210\uFF01");
 }, "update"));
 cli.command("sync", "\u540C\u6B65\u5185\u6838\u4F9D\u8D56\u4E0E\u89C4\u8303").alias("s").option("-v, --core-version <version>", "\u6307\u5B9A\u5185\u6838\u7248\u672C").option("-f, --force", "\u5F3A\u5236\u91CD\u65B0\u521D\u59CB\u5316\u5185\u6838\u6C99\u7BB1").option("--clean", "\u6E05\u7406\u5E76\u91CD\u7F6E\u6C99\u7BB1").action(wrapAction(async (options) => {
-  await sync({ ...options, version: options.coreVersion });
-  console.log("");
-  await doctor({ fix: false });
+  const { sync: sync2 } = await Promise.resolve().then(() => (init_sync(), sync_exports));
+  const { doctor: doctor2 } = await Promise.resolve().then(() => (init_doctor(), doctor_exports));
+  await sync2({ ...options, version: options.coreVersion });
+  logger.info("");
+  await doctor2({ fix: false });
 }, "sync"));
-cli.command("doctor", "\u8BCA\u65AD\u9879\u76EE\u5065\u5EB7\u72B6\u51B5\u5E76\u4FEE\u590D").alias("dr").option("--fix", "\u81EA\u52A8\u4FEE\u590D\u53D1\u73B0\u7684\u95EE\u9898").action(wrapAction(doctor, "doctor"));
-cli.command("list", "\u5217\u51FA\u6240\u6709\u5DF2\u5B89\u88C5\u7684\u5185\u6838\u6C99\u7BB1\u7248\u672C").alias("ls").action(wrapAction(ls, "ls"));
-cli.command("use <version>", "\u5207\u6362\u5F53\u524D\u9879\u76EE\u4F7F\u7528\u7684\u5185\u6838\u7248\u672C").alias("u").option("--global", "\u5207\u6362\u5168\u5C40\u9ED8\u8BA4\u5185\u6838\u7248\u672C").action(wrapAction(use, "use"));
-cli.command("gl", "\u4F7F\u7528 AI \u811A\u624B\u67B6\u751F\u6210\u4EE3\u7801\u6216\u6587\u6863").option("-t, --type <type>", "\u751F\u6210\u7C7B\u578B (plugin|util|doc|component)").option("-p, --prompt <prompt>", "AI \u9700\u6C42\u63CF\u8FF0").action(wrapAction(gl, "gl"));
-cli.command("discover", "\u626B\u63CF\u5E76\u53D1\u73B0\u5F53\u524D\u9879\u76EE\u4E2D\u7684\u63D2\u4EF6").action(wrapAction(discover, "discover"));
-cli.command("clean", "\u6E05\u7406 CLI \u4EA7\u751F\u7684\u7F13\u5B58\u76EE\u5F55").alias("cl").option("--deep", "\u6DF1\u5EA6\u6E05\u7406 (\u5305\u542B\u6240\u6709\u5B50\u5305\u7684 .chatbi \u76EE\u5F55\u53CA\u5168\u5C40\u6C99\u7BB1\u6839\u76EE\u5F55)").action(wrapAction(clean, "clean"));
+cli.command("doctor", "\u8BCA\u65AD\u9879\u76EE\u5065\u5EB7\u72B6\u51B5\u5E76\u4FEE\u590D").alias("dr").option("--fix", "\u81EA\u52A8\u4FEE\u590D\u53D1\u73B0\u7684\u95EE\u9898").action(wrapAction(async (options) => {
+  const { doctor: doctor2 } = await Promise.resolve().then(() => (init_doctor(), doctor_exports));
+  await doctor2(options);
+}, "doctor"));
+cli.command("list", "\u5217\u51FA\u6240\u6709\u5DF2\u5B89\u88C5\u7684\u5185\u6838\u6C99\u7BB1\u7248\u672C").alias("ls").action(wrapAction(async () => {
+  const { ls: ls2 } = await Promise.resolve().then(() => (init_ls(), ls_exports));
+  await ls2();
+}, "ls"));
+cli.command("use <version>", "\u5207\u6362\u5F53\u524D\u9879\u76EE\u4F7F\u7528\u7684\u5185\u6838\u7248\u672C").alias("u").option("--global", "\u5207\u6362\u5168\u5C40\u9ED8\u8BA4\u5185\u6838\u7248\u672C").action(wrapAction(async (version, options) => {
+  const { use: use2 } = await Promise.resolve().then(() => (init_use(), use_exports));
+  await use2(version, options);
+}, "use"));
+cli.command("gl", "\u4F7F\u7528 AI \u811A\u624B\u67B6\u751F\u6210\u4EE3\u7801\u6216\u6587\u6863").option("-t, --type <type>", "\u751F\u6210\u7C7B\u578B (plugin|util|doc|component)").option("-p, --prompt <prompt>", "AI \u9700\u6C42\u63CF\u8FF0").action(wrapAction(async (options) => {
+  const { gl: gl2 } = await Promise.resolve().then(() => (init_gl(), gl_exports));
+  await gl2(options);
+}, "gl"));
+cli.command("discover", "\u626B\u63CF\u5E76\u53D1\u73B0\u5F53\u524D\u9879\u76EE\u4E2D\u7684\u63D2\u4EF6").action(wrapAction(async () => {
+  const { discover: discover2 } = await Promise.resolve().then(() => (init_discover(), discover_exports));
+  await discover2();
+}, "discover"));
+cli.command("clean", "\u6E05\u7406 CLI \u4EA7\u751F\u7684\u7F13\u5B58\u76EE\u5F55").alias("cl").option("--deep", "\u6DF1\u5EA6\u6E05\u7406 (\u5305\u542B\u6240\u6709\u5B50\u5305\u7684 .chatbi \u76EE\u5F55\u53CA\u5168\u5C40\u6C99\u7BB1\u6839\u76EE\u5F55)").option("--dry-run", "\u9884\u89C8\u5C06\u8981\u5220\u9664\u7684\u6587\u4EF6").option("-y, --yes", "\u8DF3\u8FC7\u786E\u8BA4").action(wrapAction(async (options) => {
+  const { clean: clean2 } = await Promise.resolve().then(() => (init_clean(), clean_exports));
+  await clean2(options);
+}, "clean"));
 cli.command("bench", "\u8FD0\u884C CLI \u6027\u80FD\u57FA\u51C6\u6D4B\u8BD5").action(wrapAction(async () => {
   const { bench: bench2 } = await Promise.resolve().then(() => (init_bench(), bench_exports));
   await bench2();
 }, "bench"));
-cli.help((sections) => {
-  showHeader();
-  sections[0].body = pc16.white("ChatBI-V \u5F00\u53D1\u8005\u547D\u4EE4\u884C\u5DE5\u5177\uFF0C\u52A9\u529B\u5FEB\u901F\u5F00\u53D1\u548C\u6784\u5EFA\u63D2\u4EF6\u3002");
+cli.command("lint:theme [target]", "\u68C0\u6D4B\u9879\u76EE\u4E2D\u7684\u4E3B\u9898\u89C4\u8303\u95EE\u9898").option("--fix", "\u81EA\u52A8\u4FEE\u590D\u53EF\u4FEE\u590D\u7684\u95EE\u9898").option("--format <format>", "\u8F93\u51FA\u683C\u5F0F (stylish, json, etc.)", { default: "stylish" }).option("--output <file>", "\u8F93\u51FA\u62A5\u544A\u6587\u4EF6\u8DEF\u5F84").action(wrapAction(async (target, options) => {
+  const { lintTheme: lintTheme2 } = await Promise.resolve().then(() => (init_lint_theme(), lint_theme_exports));
+  await lintTheme2({ target, ...options });
+}, "lint:theme"));
+cli.command("plugin", "\u63D2\u4EF6\u7BA1\u7406\u547D\u4EE4").action(() => {
+  logger.warn("\u8BF7\u4F7F\u7528 plugin \u5B50\u547D\u4EE4: create, publish");
 });
+cli.command("plugin create <name>", "\u521B\u5EFA\u65B0\u63D2\u4EF6").option("-t, --template <template>", "\u63D2\u4EF6\u6A21\u677F (basic|command|ui|ai)").option("--typescript", "\u4F7F\u7528 TypeScript").option("--force", "\u5F3A\u5236\u8986\u76D6").action(wrapAction(async (name, options) => {
+  const { pluginCreate: pluginCreate2 } = await Promise.resolve().then(() => (init_create(), create_exports));
+  await pluginCreate2({
+    name,
+    template: options.template || "basic",
+    typescript: options.typescript !== false,
+    force: !!options.force
+  });
+}, "plugin create"));
+cli.command("plugin build", "\u6784\u5EFA\u63D2\u4EF6").option("-w, --watch", "\u76D1\u542C\u6A21\u5F0F").option("--no-minify", "\u4E0D\u538B\u7F29").action(wrapAction(async (options) => {
+  const { pluginBuild: pluginBuild2 } = await Promise.resolve().then(() => (init_build2(), build_exports2));
+  await pluginBuild2({ watch: options.watch, minify: options.minify });
+}, "plugin build"));
+cli.command("plugin validate", "\u9A8C\u8BC1\u63D2\u4EF6\u914D\u7F6E").option("--fix", "\u81EA\u52A8\u4FEE\u590D").action(wrapAction(async (options) => {
+  const { pluginValidate: pluginValidate2 } = await Promise.resolve().then(() => (init_validate(), validate_exports));
+  await pluginValidate2({ fix: options.fix });
+}, "plugin validate"));
+cli.command("plugin publish", "\u53D1\u5E03\u63D2\u4EF6\u5230\u5E02\u573A").option("--scope <scope>", "npm scope").option("--registry <registry>", "\u81EA\u5B9A\u4E49 registry").action(wrapAction(async (options) => {
+  const { pluginPublish: pluginPublish2 } = await Promise.resolve().then(() => (init_publish(), publish_exports));
+  await pluginPublish2({ scope: options.scope, registry: options.registry });
+}, "plugin publish"));
+cli.command("theme create <name>", "\u521B\u5EFA\u65B0\u4E3B\u9898").option("-b, --base <base>", "\u57FA\u7840\u4E3B\u9898 (standard|nebula|glass)").option("--css", "\u4F7F\u7528\u7EAF CSS").action(wrapAction(async (name, options) => {
+  const { themeCreate: themeCreate2 } = await Promise.resolve().then(() => (init_create2(), create_exports2));
+  await themeCreate2({
+    name,
+    base: options.base || "standard",
+    css: !!options.css
+  });
+}, "theme create"));
+cli.command("scaffold <name>", "\u521B\u5EFA\u65B0\u9879\u76EE\u811A\u624B\u67B6").option("-t, --template <template>", "\u5E94\u7528\u6A21\u677F (full|minimal|empty)").option("--typescript", "\u4F7F\u7528 TypeScript").option("--theme <theme>", "\u4E3B\u9898").action(wrapAction(async (name, options) => {
+  const { scaffold: scaffold2 } = await Promise.resolve().then(() => (init_scaffold(), scaffold_exports));
+  await scaffold2({
+    name,
+    template: options.template || "full",
+    typescript: options.typescript !== false,
+    theme: options.theme || "standard"
+  });
+}, "scaffold"));
+cli.command("upgrade [targetVersion]", "\u5347\u7EA7 CLI \u7248\u672C").action(wrapAction(async (targetVersion) => {
+  const { upgrade: upgrade2 } = await Promise.resolve().then(() => (init_upgrade(), upgrade_exports));
+  await upgrade2(targetVersion);
+}, "upgrade"));
+cli.command("devtools types", "\u4ECE plugin.json \u751F\u6210 TypeScript \u7C7B\u578B\u5B9A\u4E49").option("-i, --input <file>", "\u8F93\u5165\u6587\u4EF6\u8DEF\u5F84", { default: "src/plugin.json" }).option("-o, --output <file>", "\u8F93\u51FA\u6587\u4EF6\u8DEF\u5F84").option("-t, --type <type>", "\u7C7B\u578B\u751F\u6210\u6A21\u5F0F (full|minimal)", { default: "full" }).action(wrapAction(async (options) => {
+  const { devtoolsTypes: devtoolsTypes2 } = await Promise.resolve().then(() => (init_types(), types_exports));
+  await devtoolsTypes2({
+    input: options.input,
+    output: options.output,
+    type: options.type
+  });
+}, "devtools types"));
+cli.help();
 cli.version(package_default.version);
-if (process.argv.length <= 2) {
-  cli.outputHelp();
-} else {
-  cli.parse();
-}
-var main = async () => {
-  if (process.argv.includes("--help") || process.argv.includes("-h") || process.argv.includes("--version") || process.argv.includes("-v")) {
-    const latestVersion = await checkForUpdates(package_default.version);
-    if (latestVersion) {
-      printUpdateNotification(package_default.version, latestVersion);
-    }
-  }
-};
-main();
+cli.parse();