@chatbi-v/cli 2.0.2 → 2.0.4

package/dist/index.js

@@ -1,201 +1,2477 @@
-"use strict";
-/**
- * @file index.ts
- * @description CLI 入口文件，定义所有命令行指令及交互逻辑
- * @author ChatBI Team
- */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// ../../node_modules/.pnpm/tsup@8.5.1_jiti@2.6.1_postcss@8.5.6_typescript@5.9.3_yaml@2.8.2/node_modules/tsup/assets/esm_shims.js
+import path from "path";
+import { fileURLToPath } from "url";
+var getFilename, getDirname, __dirname;
+var init_esm_shims = __esm({
+  "../../node_modules/.pnpm/tsup@8.5.1_jiti@2.6.1_postcss@8.5.6_typescript@5.9.3_yaml@2.8.2/node_modules/tsup/assets/esm_shims.js"() {
+    "use strict";
+    getFilename = () => fileURLToPath(import.meta.url);
+    getDirname = () => path.dirname(getFilename());
+    __dirname = /* @__PURE__ */ getDirname();
+  }
+});
+
+// src/utils.ts
+import path2 from "path";
+import fs from "fs-extra";
+import pc from "picocolors";
+import ora from "ora";
+import boxen from "boxen";
+var _require, _dirname, logger, createSpinner, printBox, findPackageRoot, getCliRoot;
+var init_utils = __esm({
+  "src/utils.ts"() {
+    "use strict";
+    init_esm_shims();
+    _require = __require;
+    _dirname = __dirname;
+    logger = {
+      info: (msg) => console.log(pc.cyan(`\u2139 ${msg}`)),
+      success: (msg) => console.log(pc.green(`\u2714 ${msg}`)),
+      warn: (msg) => console.log(pc.yellow(`\u26A0 ${msg}`)),
+      error: (msg, err) => {
+        console.error(pc.red(`
+\u274C ${msg}`));
+        if (err) {
+          if (err instanceof Error) {
+            console.error(pc.gray(err.stack || err.message));
+          } else {
+            console.error(pc.gray(String(err)));
+          }
+        }
+      },
+      bold: (msg) => pc.bold(msg),
+      cyan: (msg) => pc.cyan(msg),
+      green: (msg) => pc.green(msg),
+      yellow: (msg) => pc.yellow(msg),
+      red: (msg) => pc.red(msg),
+      gray: (msg) => pc.gray(msg)
+    };
+    createSpinner = (msg) => ora({
+      text: pc.cyan(msg),
+      color: "cyan"
+    });
+    printBox = (msg, title, options = {}) => {
+      console.log("\n" + boxen(msg, {
+        padding: 1,
+        borderStyle: "round",
+        borderColor: "cyan",
+        title,
+        titleAlignment: "center",
+        ...options
+      }));
+    };
+    findPackageRoot = (pkgName) => {
+      try {
+        const pkgPath = _require.resolve(`${pkgName}/package.json`);
+        return path2.dirname(pkgPath);
+      } catch (e) {
+        if (pkgName === "@chatbi-v/cli") {
+          return path2.resolve(_dirname, "../../");
+        }
+        const localPath = path2.resolve(_dirname, "../../node_modules", pkgName);
+        if (fs.existsSync(localPath)) {
+          return localPath;
+        }
+        throw new Error(`\u65E0\u6CD5\u627E\u5230\u5305 ${pkgName}\uFF0C\u8BF7\u786E\u4FDD\u5DF2\u901A\u8FC7 pnpm/npm \u5B89\u88C5\u3002`);
+      }
+    };
+    getCliRoot = async () => {
+      let myCliRoot = "";
+      let checkDir = _dirname;
+      while (checkDir !== path2.parse(checkDir).root) {
+        if (fs.existsSync(path2.join(checkDir, "package.json"))) {
+          const pkg = await fs.readJson(path2.join(checkDir, "package.json"));
+          if (pkg.name === "@chatbi-v/cli") {
+            myCliRoot = checkDir;
+            break;
+          }
+        }
+        checkDir = path2.dirname(checkDir);
+      }
+      if (!myCliRoot) {
+        myCliRoot = findPackageRoot("@chatbi-v/cli");
+      }
+      return myCliRoot;
+    };
+  }
+});
+
+// src/sandbox.ts
+import fs2 from "fs-extra";
+import path3 from "path";
+import os from "os";
+import pc2 from "picocolors";
+import { execa } from "execa";
+import Handlebars from "handlebars";
+import fg from "fast-glob";
+var Sandbox;
+var init_sandbox = __esm({
+  "src/sandbox.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_utils();
+    Sandbox = class _Sandbox {
+      static {
+        this.BASE_DIR = path3.join(os.homedir(), ".chatbi-v-core");
+      }
+      static {
+        this.CORE_PACKAGES = [
+          "@chatbi-v/core",
+          "@chatbi-v/mocks",
+          "@chatbi-v/tsconfig",
+          "@chatbi-v/tailwind-config",
+          "@chatbi-v/plugin-theme-manager",
+          "@chatbi-v/plugin-layout-transform",
+          "@chatbi-v/plugin-system-monitor"
+        ];
+      }
+      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 this.BASE_DIR;
+      }
+      static getVersionRoot() {
+        return path3.join(this.BASE_DIR, "versions");
+      }
+      static getVersionPath(version) {
+        if (version === "current") {
+          return path3.join(this.BASE_DIR, "versions", "current");
+        }
+        return path3.join(this.BASE_DIR, "versions", version);
+      }
+      /**
+       * 优雅清理缓存环境
+       * @param cwd 当前工作目录
+       * @param deep 是否递归清理子包
+       */
+      static async clean(cwd, deep = false) {
+        const localCache = path3.join(cwd, ".chatbi");
+        if (fs2.existsSync(localCache)) {
+          await fs2.remove(localCache);
+        }
+        if (deep) {
+          const pkgPath = path3.join(cwd, "package.json");
+          if (fs2.existsSync(pkgPath)) {
+            const pkg = await fs2.readJson(pkgPath);
+            if (pkg.workspaces || fs2.existsSync(path3.join(cwd, "pnpm-workspace.yaml"))) {
+              const subDirs = ["apps", "plugins", "packages"];
+              for (const dir of subDirs) {
+                const dirPath = path3.join(cwd, dir);
+                if (fs2.existsSync(dirPath)) {
+                  const entries = await fs2.readdir(dirPath, { withFileTypes: true });
+                  for (const entry of entries) {
+                    if (entry.isDirectory()) {
+                      const subPkgCache = path3.join(dirPath, entry.name, ".chatbi");
+                      if (fs2.existsSync(subPkgCache)) {
+                        await fs2.remove(subPkgCache);
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+        if (fs2.existsSync(this.BASE_DIR)) {
+          await fs2.remove(this.BASE_DIR);
+        }
+      }
+      /**
+       * 准备内核沙箱环境 (安装/更新)
+       */
+      static async prepare(version, force = false) {
+        const versionPath = this.getVersionPath(version);
+        if (fs2.existsSync(versionPath) && !force) {
+          if (fs2.existsSync(path3.join(versionPath, "node_modules/tailwindcss")) && fs2.existsSync(path3.join(versionPath, "node_modules/react-router-dom"))) {
+            return versionPath;
+          }
+        }
+        if (fs2.existsSync(versionPath)) {
+          await fs2.remove(path3.join(versionPath, "node_modules"));
+          await fs2.remove(path3.join(versionPath, "pnpm-lock.yaml"));
+        }
+        await fs2.ensureDir(versionPath);
+        const spinner = createSpinner(`\u6B63\u5728\u521D\u59CB\u5316\u5185\u6838\u6C99\u7BB1 ${pc2.cyan(version)}...`).start();
+        try {
+          const rootPkgJson = {
+            name: `chatbi-sandbox-${version}`,
+            private: true,
+            dependencies: {},
+            devDependencies: {
+              "tailwindcss": "^3.4.1",
+              "autoprefixer": "^10.4.17",
+              "postcss": "^8.4.35",
+              "vite": "^5.0.8",
+              "@vitejs/plugin-react": "^4.2.1",
+              "less": "^4.2.0",
+              "typescript": "^5.3.3",
+              "@types/react": "^18.3.1",
+              "@types/react-dom": "^18.3.1",
+              "@types/node": "^20.11.20"
+            }
+          };
+          for (const pkgName of _Sandbox.CORE_PACKAGES) {
+            rootPkgJson.dependencies[pkgName] = pkgName === "@chatbi-v/core" ? version : "latest";
+          }
+          for (const pkgName of _Sandbox.RUNTIME_DEPS) {
+            if (!rootPkgJson.dependencies[pkgName]) {
+              rootPkgJson.dependencies[pkgName] = "latest";
+            }
+          }
+          rootPkgJson.dependencies["react"] = "^18.3.1";
+          rootPkgJson.dependencies["react-dom"] = "^18.3.1";
+          rootPkgJson.dependencies["antd"] = "^5.20.0";
+          await fs2.writeJson(path3.join(versionPath, "package.json"), rootPkgJson, { spaces: 2 });
+          await fs2.writeFile(path3.join(versionPath, ".npmrc"), "shamefully-hoist=true\nauto-install-peers=true\n");
+          spinner.text = pc2.gray("  \u{1F50D} \u68C0\u67E5\u672C\u5730\u5F00\u53D1\u73AF\u5883...");
+          const isLocalDev = await this.tryLinkLocalPackages(versionPath);
+          const installArgs = ["install"];
+          if (isLocalDev) {
+            installArgs.push("--no-frozen-lockfile");
+          }
+          spinner.text = pc2.gray(`  \u23F3 \u6267\u884C pnpm ${installArgs.join(" ")}...`);
+          await execa("pnpm", installArgs, { cwd: versionPath });
+          spinner.text = pc2.gray("  \u{1F3A8} \u540C\u6B65 Shell \u6A21\u677F...");
+          await this.ensureShell(version, force);
+          spinner.succeed(pc2.green(`\u5185\u6838\u6C99\u7BB1 ${version} \u521D\u59CB\u5316\u6210\u529F`));
+        } catch (e) {
+          spinner.fail(pc2.red(`\u5185\u6838\u6C99\u7BB1\u521D\u59CB\u5316\u5931\u8D25: ${e.message}`));
+          throw e;
+        }
+        return versionPath;
+      }
+      /**
+       * 确保 Shell 模板已同步到沙箱
+       */
+      static async ensureShell(version, force = false) {
+        const versionPath = this.getVersionPath(version);
+        const shellDestDir = path3.join(versionPath, "shell");
+        const needsRender = force || !fs2.existsSync(shellDestDir) || !fs2.existsSync(path3.join(shellDestDir, "tsconfig.paths.json"));
+        if (!needsRender) {
+          return shellDestDir;
+        }
+        const cliRoot = await getCliRoot();
+        const shellTemplateDir = path3.join(cliRoot, "templates", "app");
+        if (fs2.existsSync(shellTemplateDir)) {
+          await fs2.remove(shellDestDir);
+          await fs2.ensureDir(path3.join(shellDestDir, "empty"));
+          let kernelVersion = version;
+          const templateData = {
+            name: "chatbi-shell",
+            projectName: "chatbi-shell",
+            projectTitle: "ChatBI Shell",
+            projectVersion: "0.1.0",
+            version: kernelVersion,
+            cliVersion: version,
+            theme: "standard",
+            isNebula: false,
+            isGlass: false,
+            isBusiness: true,
+            isApp: true,
+            isShell: true,
+            tsconfigPath: "./tsconfig.paths.json"
+          };
+          await this.renderDirectory(shellTemplateDir, shellDestDir, templateData);
+          const tsConfigPaths = {
+            compilerOptions: {
+              baseUrl: ".",
+              paths: {
+                "@/*": ["./src/*"]
+              }
+            }
+          };
+          await fs2.writeJson(path3.join(shellDestDir, "tsconfig.paths.json"), tsConfigPaths, { spaces: 2 });
+        }
+        return shellDestDir;
+      }
+      /**
+       * 递归渲染目录模板
+       */
+      static async renderDirectory(srcDir, destDir, data) {
+        const entries = await fs2.readdir(srcDir, { withFileTypes: true });
+        for (const entry of entries) {
+          const srcPath = path3.join(srcDir, entry.name);
+          const destPath = path3.join(destDir, entry.name.replace(/\.hbs$/, ""));
+          if (entry.isDirectory()) {
+            await fs2.ensureDir(destPath);
+            await this.renderDirectory(srcPath, destPath, data);
+          } else {
+            if (entry.name.endsWith(".hbs")) {
+              const content = await fs2.readFile(srcPath, "utf-8");
+              const hasHandlebarsVars = content.includes("{{");
+              if (hasHandlebarsVars) {
+                try {
+                  const safeContent = content.replace(/\{\{(?!\s*([#/]?(?:if|else|each|with|unless|name|version|projectName|projectTitle|projectVersion|cliVersion|tsconfigPath|theme|isNebula|isGlass|isBusiness|isApp|isShell|pluginName|pluginPackageName|pluginVersion|pluginDisplayName|pluginDescription|pluginClassName|pluginPath|pluginFolderName|pluginType|pluginId|className))\b)/g, "\\{{");
+                  const template = Handlebars.compile(safeContent);
+                  const result = template(data);
+                  await fs2.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, String(val));
+                  }
+                  await fs2.outputFile(destPath, result);
+                }
+              } else {
+                await fs2.outputFile(destPath, content);
+              }
+            } else {
+              await fs2.copy(srcPath, destPath);
+            }
+          }
+        }
+      }
+      /**
+       * 注入项目虚拟上下文 (tsconfig, alias)
+       */
+      static async injectContext(projectRoot, version) {
+        const chatbiDir = path3.join(projectRoot, ".chatbi");
+        await fs2.ensureDir(chatbiDir);
+        const versionPath = this.getVersionPath(version);
+        const sandboxNodeModules = path3.join(versionPath, "node_modules");
+        const corePaths = {};
+        for (const pkgName of _Sandbox.CORE_PACKAGES) {
+          corePaths[pkgName] = [`./node_modules/${pkgName}`];
+          corePaths[`${pkgName}/*`] = [`./node_modules/${pkgName}/*`];
+        }
+        for (const pkgName of _Sandbox.RUNTIME_DEPS) {
+          corePaths[pkgName] = [`./node_modules/${pkgName}`];
+          corePaths[`${pkgName}/*`] = [`./node_modules/${pkgName}/*`];
+          if (["react", "react-dom", "node"].includes(pkgName)) {
+            const typeName = pkgName === "node" ? "node" : pkgName;
+            corePaths[`@types/${typeName}`] = [`./node_modules/@types/${typeName}`];
+            corePaths[`@types/${typeName}/*`] = [`./node_modules/@types/${typeName}/*`];
+          }
+        }
+        corePaths["@types/*"] = ["./node_modules/@types/*"];
+        corePaths["vite/client"] = ["./node_modules/vite/client.d.ts"];
+        const baseConfigPath = path3.join(sandboxNodeModules, "@chatbi-v/tsconfig/base.json");
+        let projectPaths = { "@/*": ["../src/*"] };
+        const tsConfig = {
+          extends: baseConfigPath,
+          compilerOptions: {
+            baseUrl: ".",
+            moduleResolution: "bundler",
+            skipLibCheck: true,
+            // Fix: Use relative path to the symlinked node_modules in .chatbi
+            // This is much more robust as it works relative to the config file (.chatbi/tsconfig.json)
+            typeRoots: [
+              "./node_modules/@types"
+            ],
+            // Crucial for symlinked node_modules: treat them as if they are in the project
+            preserveSymlinks: true,
+            paths: {
+              ...corePaths,
+              ...projectPaths,
+              // Fallback: Try to find anything else in the virtual node_modules
+              "*": ["./node_modules/*"]
+            }
+          }
         };
-        return ownKeys(o);
+        await fs2.writeJson(path3.join(chatbiDir, "tsconfig.json"), tsConfig, { spaces: 2 });
+        await fs2.writeJson(path3.join(chatbiDir, "tsconfig.paths.json"), { compilerOptions: tsConfig.compilerOptions }, { spaces: 2 });
+        const virtualNodeModules = path3.join(chatbiDir, "node_modules");
+        if (!fs2.existsSync(sandboxNodeModules)) {
+          return;
+        }
+        try {
+          try {
+            const stats = await fs2.lstat(virtualNodeModules);
+            if (stats) {
+              await fs2.remove(virtualNodeModules);
+            }
+          } catch (e) {
+          }
+          await fs2.ensureSymlink(sandboxNodeModules, virtualNodeModules, "dir");
+          const rootNodeModules = path3.join(projectRoot, "node_modules");
+          let rootNmExists = false;
+          try {
+            rootNmExists = fs2.existsSync(rootNodeModules);
+          } catch (e) {
+          }
+          if (!rootNmExists) {
+            try {
+              await fs2.ensureSymlink(sandboxNodeModules, rootNodeModules, "dir");
+            } catch (linkErr) {
+              const appsDir = path3.join(projectRoot, "apps");
+              if (fs2.existsSync(appsDir)) {
+                const appDirs = await fg("*", { cwd: appsDir, onlyDirectories: true, absolute: true });
+                for (const appDir of appDirs) {
+                  const appNm = path3.join(appDir, "node_modules");
+                  if (!fs2.existsSync(appNm)) {
+                    await fs2.ensureSymlink(sandboxNodeModules, appNm, "dir").catch(() => {
+                    });
+                  }
+                }
+              }
+            }
+          }
+        } catch (e) {
+        }
+        const gitignorePath = path3.join(projectRoot, ".gitignore");
+        if (fs2.existsSync(gitignorePath)) {
+          let content = await fs2.readFile(gitignorePath, "utf-8");
+          if (!content.includes(".chatbi")) {
+            await fs2.appendFile(gitignorePath, "\n# ChatBI\n.chatbi\n");
+          }
+        }
+      }
+      /**
+       * 获取核心库的 Vite Alias 配置
+       */
+      static getCoreAlias(version) {
+        const versionPath = this.getVersionPath(version);
+        const sandboxNodeModules = path3.join(versionPath, "node_modules");
+        const aliases = {};
+        for (const pkg of this.CORE_PACKAGES) {
+          aliases[pkg] = path3.join(sandboxNodeModules, pkg);
+        }
+        return aliases;
+      }
+      /**
+       * 尝试将本地包 Link 到沙箱中 (模拟安装)
+       */
+      static async tryLinkLocalPackages(versionPath) {
+        try {
+          const cliRoot = await getCliRoot();
+          let projectRoot = path3.resolve(cliRoot, "../../..");
+          let currentDir = cliRoot;
+          while (currentDir !== path3.parse(currentDir).root) {
+            if (fs2.existsSync(path3.join(currentDir, "pnpm-workspace.yaml"))) {
+              projectRoot = currentDir;
+              break;
+            }
+            currentDir = path3.dirname(currentDir);
+          }
+          const possiblePackagesDirs = [
+            path3.join(projectRoot, "packages"),
+            // 兼容某些特殊结构，比如 chatbi-v 仓库
+            path3.resolve(projectRoot, "../chatbi-v/packages")
+          ];
+          const localPackages = {};
+          const patterns = possiblePackagesDirs.filter((dir) => fs2.existsSync(dir)).map((dir) => path3.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 fs2.readJson(pkgJsonPath);
+                if (this.CORE_PACKAGES.includes(pkgJson.name) || this.RUNTIME_DEPS.includes(pkgJson.name)) {
+                  localPackages[pkgJson.name] = path3.dirname(pkgJsonPath);
+                }
+              } catch (e) {
+              }
+            }
+          }
+          if (Object.keys(localPackages).length === 0) {
+            return false;
+          }
+          const linkSummary = Object.entries(localPackages).map(([name, pkgPath]) => `${pc2.cyan(name.padEnd(30))} -> ${pc2.gray(pkgPath)}`).join("\n");
+          printBox(
+            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 = path3.join(versionPath, "node_modules");
+          await fs2.ensureDir(sandboxNodeModules);
+          for (const [name, pkgPath] of Object.entries(localPackages)) {
+            const targetLinkPath = path3.join(sandboxNodeModules, name);
+            await fs2.ensureDir(path3.dirname(targetLinkPath));
+            try {
+              const stats = await fs2.lstat(targetLinkPath).catch(() => null);
+              if (stats) {
+                await fs2.remove(targetLinkPath);
+              }
+            } catch (e) {
+            }
+            await fs2.symlink(pkgPath, targetLinkPath, "dir");
+          }
+          const sandboxPkgJsonPath = path3.join(versionPath, "package.json");
+          const sandboxPkgJson = await fs2.readJson(sandboxPkgJsonPath);
+          const sections = ["dependencies", "devDependencies"];
+          let modified = false;
+          for (const section of sections) {
+            if (sandboxPkgJson[section]) {
+              for (const [name, pkgPath] of Object.entries(localPackages)) {
+                if (sandboxPkgJson[section][name]) {
+                  sandboxPkgJson[section][name] = `link:${pkgPath}`;
+                  modified = true;
+                }
+              }
+            }
+          }
+          if (modified) {
+            await fs2.writeJson(sandboxPkgJsonPath, sandboxPkgJson, { spaces: 2 });
+          }
+          return true;
+        } catch (e) {
+          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;
+        }
+      }
+      /**
+       * 切换全局当前使用的内核版本
+       */
+      static async useVersion(version) {
+        const versionRoot = this.getVersionRoot();
+        const currentLinkPath = path3.join(versionRoot, "current");
+        const targetPath = this.getVersionPath(version);
+        if (!fs2.existsSync(targetPath)) {
+          throw new Error(`\u7248\u672C ${version} \u5C1A\u672A\u5B89\u88C5`);
+        }
+        if (fs2.existsSync(currentLinkPath)) {
+          await fs2.remove(currentLinkPath);
+        }
+        await fs2.symlink(targetPath, currentLinkPath, "dir");
+      }
+      /**
+       * 可视化展示沙箱状态
+       */
+      static async visualizeStatus(projectRoot) {
+        const version = await this.getCurrentVersion(projectRoot);
+        const versionPath = this.getVersionPath(version);
+        const isInstalled = fs2.existsSync(versionPath);
+        const sandboxNm = path3.join(versionPath, "node_modules");
+        let statusText = "";
+        statusText += `${pc2.bold("\u5F53\u524D\u5185\u6838\u7248\u672C:")} ${pc2.cyan(version)}
+`;
+        statusText += `${pc2.bold("\u6C99\u7BB1\u5B89\u88C5\u8DEF\u5F84:")} ${pc2.gray(versionPath)}
+`;
+        statusText += `${pc2.bold("\u5B89\u88C5\u72B6\u6001:")} ${isInstalled ? pc2.green("\u5DF2\u5C31\u7EEA") : pc2.red("\u672A\u5B89\u88C5")}
+`;
+        if (isInstalled) {
+          const corePkgs = this.CORE_PACKAGES.map((pkg) => {
+            const pkgPath = path3.join(sandboxNm, pkg);
+            const exists = fs2.existsSync(pkgPath);
+            let linkTarget = "";
+            if (exists) {
+              try {
+                const stats = fs2.lstatSync(pkgPath);
+                if (stats.isSymbolicLink()) {
+                  linkTarget = ` -> ${pc2.yellow(fs2.readlinkSync(pkgPath))}`;
+                }
+              } catch (e) {
+              }
+            }
+            return `  ${exists ? pc2.green("\u2713") : pc2.red("\u2717")} ${pkg.padEnd(30)}${linkTarget}`;
+          }).join("\n");
+          statusText += `
+${pc2.bold("\u6838\u5FC3\u7EC4\u4EF6\u72B6\u6001:")}
+${corePkgs}`;
+        }
+        printBox(statusText, "ChatBI \u5185\u6838\u53EF\u89C2\u6D4B\u6027\u9762\u677F");
+      }
+      /**
+       * 获取当前项目使用的内核版本
+       */
+      static async getCurrentVersion(projectRoot) {
+        try {
+          const chatbiDir = path3.join(projectRoot, ".chatbi");
+          const tsconfigPath = path3.join(chatbiDir, "tsconfig.json");
+          if (fs2.existsSync(tsconfigPath)) {
+            const tsconfig = await fs2.readJson(tsconfigPath);
+            if (tsconfig.extends && tsconfig.extends.includes("/versions/")) {
+              const parts = tsconfig.extends.split("/");
+              const vIdx = parts.indexOf("versions");
+              if (vIdx !== -1 && parts[vIdx + 1]) {
+                return parts[vIdx + 1];
+              }
+            }
+          }
+        } catch (e) {
+        }
+        return "current";
+      }
     };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
+  }
+});
+
+// src/config.ts
+import fs3 from "fs-extra";
+import path4 from "path";
+import { createJiti } from "jiti";
+var ConfigManager;
+var init_config = __esm({
+  "src/config.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_utils();
+    ConfigManager = class {
+      static {
+        this.CONFIG_FILES = [
+          "chatbi.config.ts",
+          "chatbi.config.js",
+          "chatbi.config.json",
+          ".chatbirc",
+          ".chatbirc.json"
+        ];
+      }
+      /**
+       * 加载项目配置
+       * @param cwd 项目根目录
+       */
+      static async loadConfig(cwd = process.cwd()) {
+        const config = {};
+        const versionFilePath = path4.join(cwd, ".chatbi-version");
+        if (fs3.existsSync(versionFilePath)) {
+          try {
+            const version = (await fs3.readFile(versionFilePath, "utf-8")).trim();
+            if (version) {
+              config.coreVersion = version;
+            }
+          } catch (e) {
+          }
+        }
+        const jiti = createJiti(cwd);
+        for (const file of this.CONFIG_FILES) {
+          const configPath = path4.join(cwd, file);
+          if (fs3.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 fs3.readJson(configPath);
+              }
+              return {
+                ...projectConfig,
+                ...config
+              };
+            } catch (e) {
+              logger.error(`\u8BFB\u53D6\u914D\u7F6E\u6587\u4EF6 ${file} \u5931\u8D25`, e);
+            }
+          }
+        }
+        return config;
+      }
     };
-})();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const cac_1 = __importDefault(require("cac"));
-const picocolors_1 = __importDefault(require("picocolors"));
-const figlet_1 = __importDefault(require("figlet"));
-const gradient_string_1 = __importDefault(require("gradient-string"));
-const boxen_1 = __importDefault(require("boxen"));
-const build_1 = require("./commands/build");
-const dev_1 = require("./commands/dev");
-const init_1 = require("./commands/init");
-const add_1 = require("./commands/add");
-const gl_1 = require("./commands/gl");
-const sync_1 = require("./commands/sync");
-const doctor_1 = require("./commands/doctor");
-const discover_1 = require("./commands/discover");
-const ls_1 = require("./commands/ls");
-const use_1 = require("./commands/use");
-const fetch_1 = require("./commands/fetch");
-const install_1 = require("./commands/install");
-const package_json_1 = __importDefault(require("../package.json"));
-const utils_1 = require("./utils");
-const cli = (0, cac_1.default)('chatbi-cli');
-// 打印漂亮的 Header
-const showHeader = () => {
-    const title = figlet_1.default.textSync('ChatBI-V CLI', { font: 'Standard' });
-    console.log(gradient_string_1.default.pastel.multiline(title));
-    console.log((0, boxen_1.default)(picocolors_1.default.cyan(`ChatBI-V 统一开发工具 v${package_json_1.default.version}`), {
-        padding: 0,
-        margin: { top: 1, bottom: 1 },
-        borderStyle: 'round',
-        borderColor: 'cyan',
-        title: 'CoreKit Enabled',
-        titleAlignment: 'center'
-    }));
-};
-/**
- * 包装命令 Action，统一错误处理
- */
-const wrapAction = (action, commandName) => {
-    return async (...args) => {
-        showHeader();
+  }
+});
+
+// src/corekit.ts
+import path5 from "path";
+import fs4 from "fs-extra";
+import pc3 from "picocolors";
+import prompts from "prompts";
+import fg2 from "fast-glob";
+var CoreKit;
+var init_corekit = __esm({
+  "src/corekit.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_utils();
+    init_sandbox();
+    init_config();
+    CoreKit = class {
+      /**
+       * 解析项目模式
+       */
+      static async detectMode(cwd) {
+        const pkgPath = path5.join(cwd, "package.json");
+        if (!fs4.existsSync(pkgPath)) return "app";
+        const pkg = await fs4.readJson(pkgPath);
+        if (pkg.workspaces || fs4.existsSync(path5.join(cwd, "pnpm-workspace.yaml"))) {
+          return "monorepo";
+        }
+        if (pkg.chatbi?.type === "plugin" || pkg.plugin === true) return "plugin";
+        if (pkg.chatbi?.type === "app") return "app";
+        const pluginEntries = await fg2(["index.plugin.{ts,js}", "src/index.plugin.{ts,js}"], { cwd });
+        if (pluginEntries.length > 0) return "plugin";
+        if (fs4.existsSync(path5.join(cwd, "index.html"))) {
+          return "app";
+        }
+        if (fs4.existsSync(path5.join(cwd, "src/index.ts")) || fs4.existsSync(path5.join(cwd, "src/index.tsx"))) {
+          if (pkg.bin) return "lib";
+          if (pkg.peerDependencies?.react && !pkg.dependencies?.react) return "plugin";
+          return "lib";
+        }
+        return "app";
+      }
+      /**
+       * 获取当前生效的内核版本
+       * 优先序：项目配置 > 全局 current 软链 > 最新安装的版本
+       */
+      static async resolveVersion(projectRoot) {
+        if (projectRoot) {
+          const config = await ConfigManager.loadConfig(projectRoot);
+          if (config.coreVersion) return config.coreVersion;
+        }
+        try {
+          const cliRoot = await getCliRoot();
+          const cliVersionFile = path5.join(cliRoot, ".chatbi-version");
+          if (fs4.existsSync(cliVersionFile)) {
+            const version = (await fs4.readFile(cliVersionFile, "utf-8")).trim();
+            if (version) return version;
+          }
+        } catch (e) {
+        }
+        const currentLinkPath = path5.join(Sandbox.getVersionRoot(), "current");
+        if (fs4.existsSync(currentLinkPath)) {
+          try {
+            const realPath = await fs4.realpath(currentLinkPath);
+            return path5.basename(realPath);
+          } catch (e) {
+          }
+        }
+        const versions = await this.listVersions();
+        return versions[0] || "latest";
+      }
+      /**
+       * 列出所有已安装版本
+       */
+      static async listVersions() {
+        const versionsDir = Sandbox.getVersionRoot();
+        if (!fs4.existsSync(versionsDir)) return [];
+        const dirs = await fg2("*", {
+          cwd: versionsDir,
+          onlyDirectories: true,
+          deep: 1
+        });
+        return dirs.filter((d) => d !== "current").sort((a, b) => b.localeCompare(a, void 0, { numeric: true, sensitivity: "base" }));
+      }
+      /**
+       * 自动发现项目中的插件
+       */
+      static async discoverPlugins(rootDir) {
+        const pluginsDir = path5.join(rootDir, "plugins");
+        if (!fs4.existsSync(pluginsDir)) return [];
+        const pkgFiles = await fg2("*/package.json", { cwd: pluginsDir, absolute: true });
+        const plugins = [];
+        for (const pkgPath of pkgFiles) {
+          try {
+            const pkg = await fs4.readJson(pkgPath);
+            const pluginPath = path5.dirname(pkgPath);
+            plugins.push({
+              name: pkg.name || path5.basename(pluginPath),
+              path: pluginPath,
+              id: path5.basename(pluginPath)
+            });
+          } catch (e) {
+          }
+        }
+        return plugins;
+      }
+      /**
+       * 启动开发环境 (统一入口)
+       */
+      static async startDev(cwd, options = {}) {
+        const mode = await this.detectMode(cwd);
+        const version = await this.resolveVersion(cwd);
+        printBox(
+          `${pc3.cyan(pc3.bold("\u{1F680} ChatBI Dev Server"))}
+
+${pc3.gray("Mode:   ")} ${pc3.yellow(mode)}
+${pc3.gray("Kernel: ")} ${pc3.green(version)}
+${pc3.gray("Root:   ")} ${pc3.white(cwd)}`,
+          "Dev Server"
+        );
+        const spinner = createSpinner("\u6B63\u5728\u51C6\u5907\u6C99\u7BB1\u73AF\u5883...").start();
+        try {
+          await Sandbox.prepare(version);
+          spinner.text = pc3.cyan("\u6B63\u5728\u6CE8\u5165\u865A\u62DF\u4E0A\u4E0B\u6587...");
+          await Sandbox.injectContext(cwd, version);
+          spinner.succeed(pc3.green("\u73AF\u5883\u5C31\u7EEA"));
+          if (mode === "plugin") {
+            await this.startPluginDevServer(cwd, version, options.port);
+          } else if (mode === "app") {
+            await this.startAppDevServer(cwd, version, options.port);
+          } else {
+            await this.startMonorepoDevServer(cwd, version, options.port);
+          }
+        } catch (e) {
+          spinner.fail(pc3.red(`\u542F\u52A8\u5931\u8D25: ${e.message}`));
+        }
+      }
+      /**
+       * 启动 Monorepo 开发服务器
+       */
+      static async startMonorepoDevServer(rootDir, version, customPort) {
+        const appsDir = path5.join(rootDir, "apps");
+        if (!fs4.existsSync(appsDir)) {
+          logger.warn("\u5F53\u524D Monorepo \u4E0B\u672A\u627E\u5230 apps/ \u76EE\u5F55");
+          return;
+        }
+        const pkgFiles = await fg2("*/package.json", { cwd: appsDir, absolute: true });
+        const apps = pkgFiles.map((pkgPath) => ({
+          name: path5.basename(path5.dirname(pkgPath)),
+          path: path5.dirname(pkgPath)
+        }));
+        if (apps.length === 0) {
+          logger.warn("\u5F53\u524D Monorepo \u4E0B\u672A\u627E\u5230\u4EFB\u4F55\u5E94\u7528 (apps/)");
+          return;
+        }
+        const response = await prompts({
+          type: "select",
+          name: "appPath",
+          message: "\u8BF7\u9009\u62E9\u8981\u542F\u52A8\u7684\u5E94\u7528:",
+          choices: apps.map((app) => ({ title: app.name, value: app.path })),
+          initial: 0
+        });
+        if (!response.appPath) {
+          logger.info("\u5DF2\u53D6\u6D88");
+          return;
+        }
+        await this.startAppDevServer(response.appPath, version, customPort);
+      }
+      /**
+       * 启动插件开发服务器 (Hosted Mode)
+       */
+      static async startPluginDevServer(pluginDir, version, customPort) {
+        logger.info("\u6B63\u5728\u542F\u52A8\u6258\u7BA1\u5F0F Shell...");
+        const shellPort = customPort || 5173;
+        const sandboxRoot = Sandbox.getRoot();
+        const versionPath = Sandbox.getVersionPath(version);
+        const sandboxNodeModules = path5.join(versionPath, "node_modules");
+        const shellDir = await Sandbox.ensureShell(version);
+        const coreAlias = Sandbox.getCoreAlias(version);
+        const tailwindPath = path5.join(sandboxNodeModules, "tailwindcss");
+        const autoprefixerPath = path5.join(sandboxNodeModules, "autoprefixer");
+        let pluginEntry = path5.join(pluginDir, "src/index.tsx");
+        if (!fs4.existsSync(pluginEntry)) {
+          pluginEntry = path5.join(pluginDir, "src/index.ts");
+        }
+        const define = {
+          "process.env.CHATBI_PLUGIN_PATH": JSON.stringify(pluginDir)
+        };
+        const { createServer } = await import("vite");
         try {
-            await action(...args);
+          const server = await createServer({
+            root: shellDir,
+            configFile: false,
+            css: {
+              postcss: {
+                plugins: [
+                  __require(tailwindPath)({
+                    presets: [__require(path5.join(sandboxNodeModules, "@chatbi-v/tailwind-config"))],
+                    darkMode: "class",
+                    content: [
+                      path5.join(shellDir, "index.html"),
+                      path5.join(shellDir, "src/**/*.{ts,tsx}"),
+                      path5.join(pluginDir, "src/**/*.{ts,tsx}")
+                    ]
+                  }),
+                  __require(autoprefixerPath)
+                ]
+              }
+            },
+            server: {
+              port: shellPort,
+              host: true,
+              fs: {
+                allow: [
+                  sandboxRoot,
+                  pluginDir,
+                  path5.resolve(pluginDir, "../../")
+                ]
+              }
+            },
+            resolve: {
+              alias: {
+                ...coreAlias,
+                "react": path5.join(sandboxNodeModules, "react"),
+                "react-dom": path5.join(sandboxNodeModules, "react-dom"),
+                "@": path5.join(shellDir, "src"),
+                // 关键：将虚拟模块指向用户插件
+                "virtual:user-plugin": pluginEntry,
+                // 防止 glob 报错，提供空的映射
+                "@chatbi-plugins": path5.join(shellDir, "empty"),
+                "@chatbi-apps": path5.join(shellDir, "empty")
+              }
+            },
+            define
+          });
+          await server.listen();
+          const localUrl = `http://localhost:${shellPort}/`;
+          printBox(
+            `${pc3.green(pc3.bold("\u2705 \u6258\u7BA1\u5F0F Shell \u5DF2\u542F\u52A8"))}
+
+${pc3.white("Local: ")} ${pc3.cyan(pc3.underline(localUrl))}`,
+            "Shell Success"
+          );
+        } catch (e) {
+          logger.error("Shell \u670D\u52A1\u5668\u542F\u52A8\u5931\u8D25", e);
         }
-        catch (e) {
-            utils_1.logger.error(`${commandName} 执行失败`, e);
-            process.exit(1);
+      }
+      /**
+       * 启动应用开发服务器 (Integrated Mode)
+       */
+      static async startAppDevServer(appDir, version, customPort) {
+        logger.info("\u6B63\u5728\u542F\u52A8\u5E94\u7528...");
+        const versionPath = Sandbox.getVersionPath(version);
+        const sandboxNodeModules = path5.join(versionPath, "node_modules");
+        const coreAlias = Sandbox.getCoreAlias(version);
+        const { createServer, loadConfigFromFile } = await import("vite");
+        try {
+          const configContext = { command: "serve", mode: "development" };
+          const userConfig = await loadConfigFromFile(configContext, void 0, appDir).catch(() => null);
+          const server = await createServer({
+            root: appDir,
+            // 这里我们允许用户有自己的 vite config，但我们会 merge alias
+            // 实际场景中可能需要写一个 Vite 插件来做这件事，这里简单处理
+            resolve: {
+              alias: {
+                ...coreAlias,
+                // 补充常用的基础依赖映射，防止用户 vite.config.ts 中的插件找不到依赖
+                "react": path5.join(sandboxNodeModules, "react"),
+                "react-dom": path5.join(sandboxNodeModules, "react-dom"),
+                "@vitejs/plugin-react": path5.join(sandboxNodeModules, "@vitejs/plugin-react")
+              }
+            },
+            server: {
+              port: customPort || 3e3,
+              host: true,
+              fs: {
+                allow: [
+                  Sandbox.getRoot(),
+                  appDir,
+                  // 允许访问沙箱中的所有依赖
+                  sandboxNodeModules
+                ]
+              }
+            }
+          });
+          await server.listen();
+          const localUrl = `http://localhost:${server.config.server.port}/`;
+          printBox(
+            `${pc3.green(pc3.bold("\u2705 \u5E94\u7528\u5DF2\u6210\u529F\u542F\u52A8"))}
+
+${pc3.white("Local: ")} ${pc3.cyan(pc3.underline(localUrl))}`,
+            "App Success"
+          );
+        } catch (e) {
+          logger.error("\u5E94\u7528\u542F\u52A8\u5931\u8D25", e);
         }
+      }
     };
-};
-cli
-    .command('dev', '启动开发服务器')
-    .alias('d')
-    .option('--port <port>', '端口号')
-    .action(wrapAction(dev_1.dev, 'dev'));
-cli
-    .command('build', '构建当前项目')
-    .alias('b')
-    .option('--watch', '开启监听模式')
-    .action(wrapAction(build_1.build, 'build'));
-cli
-    .command('fetch <version>', '获取指定版本的内核 (支持打包)')
-    .option('--pack', '打包为离线安装包 (.tgz)')
-    .action(wrapAction(fetch_1.fetch, 'fetch'));
-cli
-    .command('install <target>', '安装内核 (支持版本号或离线包路径)')
-    .action(wrapAction(install_1.install, 'install'));
-cli
-    .command('init [name]', '初始化一个新的业务插件项目')
-    .alias('create')
-    .alias('i')
-    .option('--project-type <type>', '项目类型 (monorepo | app | plugin)')
-    .option('--include-app', 'Monorepo 中包含 App')
-    .option('--no-include-app', 'Monorepo 中不包含 App')
-    .option('--include-plugin', 'Monorepo 中包含 Plugin')
-    .option('--no-include-plugin', 'Monorepo 中不包含 Plugin')
-    .option('--plugin-type <type>', '插件类型 (business | system)')
-    .option('--theme <theme>', '主题 (standard | nebula | glass)')
-    .action(wrapAction(async (name, options) => {
-    await (0, init_1.init)({
-        name,
-        projectType: options.projectType,
-        includeApp: options.includeApp,
-        includePlugin: options.includePlugin,
-        pluginType: options.pluginType,
-        theme: options.theme
+  }
+});
+
+// src/commands/build.ts
+var build_exports = {};
+__export(build_exports, {
+  build: () => build
+});
+import { execa as execa2 } from "execa";
+import fs5 from "fs-extra";
+import path6 from "path";
+import pc4 from "picocolors";
+import { build as tsupBuild } from "tsup";
+async function build(options) {
+  const cwd = process.cwd();
+  const pkgPath = path6.join(cwd, "package.json");
+  if (!fs5.existsSync(pkgPath)) {
+    logger.error(`\u5728 ${cwd} \u4E2D\u672A\u627E\u5230 package.json`);
+    return;
+  }
+  const pkg = await fs5.readJson(pkgPath);
+  if (options.force) {
+    const spinnerClean = createSpinner("\u6B63\u5728\u6E05\u7406\u7F13\u5B58\u73AF\u5883...").start();
+    try {
+      await Sandbox.clean(cwd, true);
+      spinnerClean.succeed("\u7F13\u5B58\u73AF\u5883\u6E05\u7406\u5B8C\u6210");
+    } catch (e) {
+      spinnerClean.fail("\u7F13\u5B58\u6E05\u7406\u5931\u8D25");
+      logger.error("\u6E05\u7406\u8FC7\u7A0B\u4E2D\u53D1\u751F\u9519\u8BEF", e);
+    }
+  }
+  const version = await CoreKit.resolveVersion(cwd);
+  logger.info(`\u6B63\u5728\u6784\u5EFA\u9879\u76EE: ${pc4.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...";
+  await Sandbox.prepare(version, options.force);
+  if (pkg.workspaces || fs5.existsSync(path6.join(cwd, "pnpm-workspace.yaml"))) {
+    spinner.text = "\u68C0\u6D4B\u5230 Monorepo\uFF0C\u6B63\u5728\u521D\u59CB\u5316\u6839\u76EE\u5F55\u4E0A\u4E0B\u6587...";
+    await Sandbox.injectContext(cwd, version);
+    spinner.text = "\u6B63\u5728\u540C\u6B65\u5B50\u5305\u4E0A\u4E0B\u6587...";
+    const subDirs = ["apps", "plugins", "packages"];
+    for (const dir of subDirs) {
+      const dirPath = path6.join(cwd, dir);
+      if (fs5.existsSync(dirPath)) {
+        const entries = await fs5.readdir(dirPath, { withFileTypes: true });
+        for (const entry2 of entries) {
+          if (entry2.isDirectory()) {
+            const subPkgPath = path6.join(dirPath, entry2.name);
+            if (fs5.existsSync(path6.join(subPkgPath, "package.json"))) {
+              await Sandbox.injectContext(subPkgPath, version);
+            }
+          }
+        }
+      }
+    }
+  } else {
+    await Sandbox.injectContext(cwd, version);
+  }
+  spinner.succeed("\u6784\u5EFA\u73AF\u5883\u5C31\u7EEA");
+  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: ${pc4.cyan("npm run build")}`);
+      const args = ["run", "build"];
+      if (options.watch) {
+        args.push("--", "--watch");
+      }
+      await execa2("npm", args, {
+        stdio: "inherit",
+        env: { ...process.env, CHATBI_CLI_INTERNAL: "true" }
+      });
+      return;
+    }
+  }
+  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 execa2("pnpm", ["-r", "build"], { stdio: "inherit", cwd });
+    return;
+  }
+  if (mode === "app") {
+    logger.info("\u6B63\u5728\u6784\u5EFA\u5E94\u7528 (Vite)...");
+    const { build: viteBuild } = await import("vite");
+    const coreAlias = Sandbox.getCoreAlias(version);
+    await viteBuild({
+      root: cwd,
+      configFile: fs5.existsSync(path6.join(cwd, "vite.config.ts")) ? void 0 : false,
+      resolve: {
+        alias: {
+          ...coreAlias
+        }
+      },
+      build: {
+        watch: options.watch ? {} : null,
+        outDir: "dist",
+        emptyOutDir: true,
+        minify: !options.watch ? "esbuild" : false
+        // 生产环境开启压缩混淆
+      },
+      server: {
+        fs: {
+          allow: [
+            Sandbox.getRoot(),
+            cwd
+          ]
+        }
+      }
+    });
+    if (!options.watch) {
+      printBox(
+        pc4.green(pc4.bold("\u2728 \u5E94\u7528\u6784\u5EFA\u6210\u529F!")) + "\n\n" + pc4.white("\u4EA7\u7269\u76EE\u5F55: ") + pc4.cyan("dist"),
+        "Build Success"
+      );
+    }
+    return;
+  }
+  let entry = ["src/index.ts"];
+  if (fs5.existsSync(path6.join(cwd, "src/index.tsx"))) {
+    entry = ["src/index.tsx"];
+  } else if (!fs5.existsSync(path6.join(cwd, "src/index.ts"))) {
+    logger.error("\u672A\u627E\u5230\u5165\u53E3\u6587\u4EF6\u3002\u671F\u671B src/index.ts \u6216 src/index.tsx");
+    return;
+  }
+  const isPlugin = mode === "plugin";
+  if (!options.watch) {
+    await fs5.remove(path6.join(cwd, "dist"));
+    const tsbuildinfo = path6.join(cwd, "tsconfig.tsbuildinfo");
+    if (fs5.existsSync(tsbuildinfo)) {
+      await fs5.remove(tsbuildinfo);
+    }
+  }
+  const external = [
+    "react",
+    "react-dom",
+    "react/jsx-runtime",
+    "react-is",
+    "antd",
+    "@ant-design/icons",
+    "@ant-design/x",
+    ...Object.keys(pkg.dependencies || {}),
+    ...Object.keys(pkg.peerDependencies || {})
+  ];
+  if (isPlugin) {
+    const coreDeps = Sandbox.CORE_PACKAGES;
+    coreDeps.forEach((dep) => {
+      if (!external.includes(dep)) {
+        external.push(dep);
+      }
     });
-}, 'init'));
-cli
-    .command('add [name]', '在当前项目中添加一个新插件')
-    .option('-t, --type <type>', '插件类型 (business | system)')
-    .option('--display-name <name>', '插件显示名称')
-    .option('--desc <description>', '插件描述')
-    .action(wrapAction(async (name, options) => {
-    await (0, add_1.add)({
-        name,
-        type: options.type,
-        displayName: options.displayName,
-        description: options.desc
+  }
+  const commonConfig = {
+    entry,
+    dts: false,
+    clean: false,
+    sourcemap: false,
+    target: "esnext",
+    platform: isPlugin ? "browser" : "node",
+    external,
+    minify: !options.watch,
+    // 生产环境开启压缩混淆
+    watch: options.watch,
+    silent: true,
+    esbuildOptions(options2) {
+      options2.logOverride = {
+        "empty-import-meta": "silent"
+      };
+      options2.external = options2.external || [];
+      const forceExternal = [
+        "react",
+        "react-dom",
+        "antd",
+        "@ant-design/icons",
+        "@ant-design/x",
+        ...Sandbox.CORE_PACKAGES
+      ];
+      forceExternal.forEach((dep) => {
+        if (!options2.external.includes(dep)) {
+          options2.external.push(dep);
+        }
+      });
+    }
+  };
+  const buildSpinner = createSpinner("\u6B63\u5728\u7F16\u8BD1\u6E90\u7801...").start();
+  if (isPlugin) {
+    buildSpinner.text = "\u6B63\u5728\u6784\u5EFA ESM \u683C\u5F0F...";
+    await tsupBuild({
+      ...commonConfig,
+      format: ["esm"],
+      outExtension: () => ({ js: ".mjs" })
     });
-}, 'add'));
-cli
-    .command('update [targetVersion]', '更新内核版本')
-    .alias('up')
-    .action(wrapAction(async (targetVersion) => {
-    const { sync } = await Promise.resolve().then(() => __importStar(require('./commands/sync')));
-    await sync({ version: targetVersion, force: true });
-    utils_1.logger.success('更新完成！');
-}, 'update'));
-cli
-    .command('sync', '同步内核依赖与规范')
-    .alias('s')
-    .option('-v, --core-version <version>', '指定内核版本')
-    .option('-f, --force', '强制重新初始化内核沙箱')
-    .option('--clean', '清理并重置沙箱')
-    .action(wrapAction(async (options) => {
-    await (0, sync_1.sync)({ ...options, version: options.coreVersion });
-    console.log('');
-    await (0, doctor_1.doctor)({ fix: false });
-}, 'sync'));
-cli
-    .command('doctor', '诊断项目健康状况并修复')
-    .alias('dr')
-    .option('--fix', '自动修复发现的问题')
-    .action(wrapAction(doctor_1.doctor, 'doctor'));
-cli
-    .command('list', '列出所有已安装的内核沙箱版本')
-    .alias('ls')
-    .action(wrapAction(ls_1.ls, 'ls'));
-cli
-    .command('use <version>', '切换当前项目使用的内核版本')
-    .alias('u')
-    .option('--global', '切换全局默认内核版本')
-    .action(wrapAction(use_1.use, 'use'));
-cli
-    .command('gl', '使用 AI 脚手架生成代码或文档')
-    .option('-t, --type <type>', '生成类型 (plugin|util|doc|component)')
-    .option('-p, --prompt <prompt>', 'AI 需求描述')
-    .action(wrapAction(gl_1.gl, 'gl'));
-cli
-    .command('discover', '扫描并发现当前项目中的插件')
-    .action(wrapAction(discover_1.discover, 'discover'));
-cli
-    .command('bench', '运行 CLI 性能基准测试')
-    .action(wrapAction(async () => {
-    const { bench } = await Promise.resolve().then(() => __importStar(require('./commands/bench')));
-    await bench();
-}, 'bench'));
-cli.help((sections) => {
+    buildSpinner.text = "\u6B63\u5728\u6784\u5EFA IIFE \u683C\u5F0F (Plugin)...";
+    await tsupBuild({
+      ...commonConfig,
+      format: ["iife"],
+      globalName: pkg.name.replace(/[^a-zA-Z0-9]/g, "_"),
+      outExtension: () => ({ js: ".plugin.js" }),
+      platform: "browser",
+      define: {
+        "import.meta.env": "process.env"
+      },
+      esbuildOptions(options2) {
+        options2.logOverride = {
+          "empty-import-meta": "silent"
+        };
+        options2.external = options2.external || [];
+        const forceExternal = [
+          "react",
+          "react-dom",
+          "antd",
+          "@ant-design/icons",
+          "@ant-design/x",
+          ...Sandbox.CORE_PACKAGES
+        ];
+        forceExternal.forEach((dep) => {
+          if (!options2.external.includes(dep)) {
+            options2.external.push(dep);
+          }
+        });
+      }
+    });
+  } else {
+    buildSpinner.text = "\u6B63\u5728\u7F16\u8BD1\u6E90\u7801...";
+    await tsupBuild({
+      ...commonConfig,
+      format: ["cjs", "esm"],
+      outExtension({ format }) {
+        return { js: format === "esm" ? ".mjs" : ".cjs" };
+      }
+    });
+  }
+  buildSpinner.succeed("\u6E90\u7801\u7F16\u8BD1\u5B8C\u6210");
+  if (!options.watch) {
+    const dtsSpinner = createSpinner("\u6B63\u5728\u751F\u6210\u7C7B\u578B\u5B9A\u4E49...").start();
+    try {
+      const localTsc = path6.join(cwd, "node_modules/.bin/tsc");
+      const sandboxTsc = path6.join(Sandbox.getVersionPath(version), "node_modules/.bin/tsc");
+      let tscBin = "tsc";
+      if (fs5.existsSync(localTsc)) {
+        tscBin = localTsc;
+      } else if (fs5.existsSync(sandboxTsc)) {
+        tscBin = sandboxTsc;
+      } else {
+        if (fs5.existsSync(path6.join(cwd, "pnpm-lock.yaml"))) {
+          await execa2("pnpm", ["exec", "tsc", "--build", "tsconfig.json"]);
+          dtsSpinner.succeed("\u7C7B\u578B\u5B9A\u4E49\u751F\u6210\u5B8C\u6210");
+        } else {
+          await execa2("npx", ["-p", "typescript", "tsc", "--build", "tsconfig.json"]);
+          dtsSpinner.succeed("\u7C7B\u578B\u5B9A\u4E49\u751F\u6210\u5B8C\u6210");
+        }
+      }
+      if (tscBin !== "tsc") {
+        await execa2(tscBin, ["--build", "tsconfig.json"]);
+        dtsSpinner.succeed("\u7C7B\u578B\u5B9A\u4E49\u751F\u6210\u5B8C\u6210");
+      }
+    } catch (e) {
+      dtsSpinner.warn("\u7C7B\u578B\u751F\u6210\u5931\u8D25\uFF0C\u8BF7\u68C0\u67E5\u9879\u76EE\u4E2D\u7684 tsconfig.json \u914D\u7F6E");
+    }
+    printBox(
+      pc4.green(pc4.bold("\u2728 \u6784\u5EFA\u5B8C\u6210!")) + "\n\n" + pc4.white("\u4EA7\u7269\u76EE\u5F55: ") + pc4.cyan("dist") + "\n" + pc4.white("\u6784\u5EFA\u6A21\u5F0F: ") + pc4.cyan(isPlugin ? "Plugin" : "Library"),
+      "Build Success"
+    );
+  }
+}
+var init_build = __esm({
+  "src/commands/build.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_sandbox();
+    init_corekit();
+    init_utils();
+  }
+});
+
+// src/commands/sync.ts
+var sync_exports = {};
+__export(sync_exports, {
+  sync: () => sync
+});
+import fs6 from "fs-extra";
+import path7 from "path";
+import pc5 from "picocolors";
+async function sync(options = {}) {
+  const cwd = options.cwd || process.cwd();
+  const pkgPath = path7.join(cwd, "package.json");
+  if (!fs6.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 fs6.readJson(pkgPath);
+  let version = options.version;
+  if (!version) {
+    version = await CoreKit.resolveVersion(cwd);
+  }
+  if (options.clean) {
+    const cleanSpinner = createSpinner(`\u6B63\u5728\u6E05\u7406\u6C99\u7BB1\u7248\u672C ${version}...`).start();
+    await Sandbox.cleanVersion(version);
+    cleanSpinner.succeed(`\u6C99\u7BB1\u7248\u672C ${version} \u5DF2\u6E05\u7406`);
+  }
+  const mainSpinner = createSpinner(`\u6B63\u5728\u540C\u6B65\u5185\u6838\u4F9D\u8D56 (\u7248\u672C: ${version})...`).start();
+  mainSpinner.text = "\u6B63\u5728\u540C\u6B65\u6C99\u7BB1\u5185\u6838...";
+  await Sandbox.prepare(version, options.force);
+  mainSpinner.text = "\u6B63\u5728\u751F\u6210\u865A\u62DF\u4E0A\u4E0B\u6587...";
+  if (options.version) {
+    const versionFilePath = path7.join(cwd, ".chatbi-version");
+    await fs6.writeFile(versionFilePath, version, "utf-8");
+  }
+  await Sandbox.injectContext(cwd, version);
+  let modified = false;
+  const deps = pkg.dependencies || {};
+  const devDeps = pkg.devDependencies || {};
+  const isVirtualMode = true;
+  if (isVirtualMode) {
+    for (const pkgName of Sandbox.CORE_PACKAGES) {
+      if (deps[pkgName]) {
+        delete deps[pkgName];
+        modified = true;
+      }
+      if (devDeps[pkgName]) {
+        delete devDeps[pkgName];
+        modified = true;
+      }
+    }
+  }
+  if (modified) {
+    pkg.dependencies = deps;
+    pkg.devDependencies = devDeps;
+    await fs6.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");
+  }
+  if (!options.silent) {
+    printBox(
+      `${pc5.green(pc5.bold("\u2728 \u5185\u6838\u540C\u6B65\u6210\u529F!"))}
+
+${pc5.white("\u5F53\u524D\u7248\u672C: ")} ${pc5.cyan(version)}
+${pc5.white("\u6C99\u7BB1\u8DEF\u5F84: ")} ${pc5.gray(Sandbox.getVersionPath(version))}
+
+${pc5.white("\u63D0\u793A: ")} \u9879\u76EE\u73B0\u5728\u901A\u8FC7\u865A\u62DF\u522B\u540D\u5F15\u7528\u6838\u5FC3\u5305\uFF0C\u65E0\u9700\u663E\u5F0F\u5B89\u88C5\u4F9D\u8D56\u3002`,
+      "Sync Success"
+    );
+  }
+}
+var init_sync = __esm({
+  "src/commands/sync.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_utils();
+    init_sandbox();
+    init_corekit();
+  }
+});
+
+// src/commands/init.ts
+var init_exports = {};
+__export(init_exports, {
+  init: () => init
+});
+import fs7 from "fs-extra";
+import path8 from "path";
+import pc6 from "picocolors";
+import Handlebars2 from "handlebars";
+import prompts2 from "prompts";
+async function init(options) {
+  let { name, template, pluginType = "business", theme = "standard", projectType, includeApp, includePlugin } = options;
+  const response = await prompts2([
+    // ... (prompts remain the same)
+    {
+      type: name ? null : "text",
+      name: "projectName",
+      message: "\u8BF7\u8F93\u5165\u9879\u76EE\u540D\u79F0:",
+      initial: "my-chatbi-workspace"
+    },
+    {
+      type: projectType ? null : "select",
+      name: "projectType",
+      message: "\u8BF7\u9009\u62E9\u9879\u76EE\u7C7B\u578B:",
+      choices: [
+        { title: "Monorepo Workspace (\u5B8C\u6574\u5DE5\u4F5C\u7A7A\u95F4)", value: "monorepo", description: "\u5305\u542B Apps \u548C Plugins \u7684\u591A\u5305\u7BA1\u7406\u7ED3\u6784" },
+        { title: "Host App (\u72EC\u7ACB\u5BBF\u4E3B\u5E94\u7528)", value: "app", description: "\u72EC\u7ACB\u7684 ChatBI \u5E94\u7528\u6846\u67B6" },
+        { title: "Plugin (\u72EC\u7ACB\u63D2\u4EF6)", value: "plugin", description: "\u72EC\u7ACB\u7684\u4E1A\u52A1\u6216\u7CFB\u7EDF\u63D2\u4EF6" }
+      ],
+      initial: 0
+    },
+    // Monorepo specific questions
+    {
+      type: (prev) => (projectType === "monorepo" || prev === "monorepo") && includeApp === void 0 ? "confirm" : null,
+      name: "includeApp",
+      message: "\u662F\u5426\u521D\u59CB\u5316\u9ED8\u8BA4 Host App?",
+      initial: true
+    },
+    {
+      type: (prev) => (projectType === "monorepo" || prev === "monorepo") && includePlugin === void 0 ? "confirm" : null,
+      name: "includePlugin",
+      message: "\u662F\u5426\u521D\u59CB\u5316\u793A\u4F8B Plugin?",
+      initial: true
+    },
+    // Plugin specific questions
+    {
+      type: (prev, values) => (projectType === "plugin" || values.projectType === "plugin" || (includePlugin || values.includePlugin)) && !pluginType ? "select" : null,
+      name: "pluginType",
+      message: "\u8BF7\u9009\u62E9\u63D2\u4EF6\u7C7B\u578B:",
+      choices: [
+        { title: "Business (\u4E1A\u52A1\u63D2\u4EF6)", value: "business", description: "\u4FA7\u91CD\u4E8E\u4E1A\u52A1\u903B\u8F91\u548C UI \u5C55\u793A" },
+        { title: "System (\u7CFB\u7EDF\u63D2\u4EF6)", value: "system", description: "\u4FA7\u91CD\u4E8E\u7CFB\u7EDF\u80FD\u529B\u548C\u5E95\u5C42\u6269\u5C55" }
+      ],
+      initial: 0
+    },
+    // Theme selection (for App)
+    {
+      type: (prev, values) => (projectType === "app" || values.projectType === "app" || (includeApp || values.includeApp)) && !theme ? "select" : null,
+      name: "theme",
+      message: "\u8BF7\u9009\u62E9\u5E94\u7528\u9ED8\u8BA4\u4E3B\u9898:",
+      choices: [
+        { title: "Standard (\u7ECF\u5178\u84DD)", value: "standard" },
+        { title: "Nebula (\u661F\u4E91\u7D2B)", value: "nebula" },
+        { title: "Glass (\u6BDB\u73BB\u7483)", value: "glass" }
+      ],
+      initial: 0
+    }
+  ], {
+    onCancel: () => {
+      logger.warn("\u5DF2\u53D6\u6D88\u521D\u59CB\u5316");
+      process.exit(0);
+    }
+  });
+  name = name || response.projectName;
+  projectType = projectType || response.projectType || "monorepo";
+  pluginType = pluginType || response.pluginType || pluginType;
+  theme = theme || response.theme || theme;
+  const finalIncludeApp = includeApp !== void 0 ? includeApp : response.includeApp !== void 0 ? response.includeApp : true;
+  const finalIncludePlugin = includePlugin !== void 0 ? includePlugin : response.includePlugin !== void 0 ? response.includePlugin : true;
+  const isAppIncluded = finalIncludeApp;
+  const isPluginIncluded = finalIncludePlugin;
+  const rootDir = process.cwd();
+  const targetDir = path8.resolve(rootDir, name);
+  if (fs7.existsSync(targetDir)) {
+    logger.error(`\u76EE\u5F55 ${name} \u5DF2\u5B58\u5728\u3002`);
+    return;
+  }
+  logger.info(`\u6B63\u5728\u521D\u59CB\u5316\u9879\u76EE: ${pc6.bold(name)}...`);
+  logger.info(pc6.gray(`\u7C7B\u578B: ${projectType} | \u4E3B\u9898: ${theme || "N/A"}`));
+  console.log("");
+  try {
+    const myCliRoot = await getCliRoot();
+    const cliPkg = await fs7.readJson(path8.join(myCliRoot, "package.json"));
+    const cliVersion = cliPkg.version;
+    let kernelVersion = cliVersion;
+    const kernelVersionFile = path8.join(myCliRoot, ".chatbi-version");
+    if (fs7.existsSync(kernelVersionFile)) {
+      kernelVersion = (await fs7.readFile(kernelVersionFile, "utf-8")).trim();
+    }
+    const renderTemplate = async (templateName, destDir, extraData = {}) => {
+      const srcDir = path8.join(myCliRoot, "templates", templateName);
+      if (!fs7.existsSync(srcDir)) {
+        throw new Error(`\u627E\u4E0D\u5230\u6A21\u677F: ${templateName}\uFF0C\u8BF7\u68C0\u67E5\u8DEF\u5F84 ${srcDir} \u662F\u5426\u6B63\u786E\u3002`);
+      }
+      await fs7.ensureDir(destDir);
+      const templateData = {
+        name: path8.basename(destDir),
+        projectName: name,
+        // Original project name from CLI argument
+        projectTitle: name.split("-").map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join(" "),
+        projectVersion: "0.1.0",
+        version: kernelVersion,
+        // 使用内核版本作为依赖版本
+        cliVersion,
+        // CLI 自身版本
+        pluginType,
+        theme,
+        isNebula: theme === "nebula",
+        isGlass: theme === "glass",
+        isBusiness: pluginType === "business",
+        isApp: projectType === "app" || isAppIncluded,
+        // Zero Dependency Mode: No explicit core path needed in package.json
+        // tsconfig extends the virtual paths config
+        tsconfigPath: projectType === "monorepo" ? "../../.chatbi/tsconfig.json" : "./.chatbi/tsconfig.json",
+        ...extraData
+      };
+      const processFiles = async (currentSrc, currentDest) => {
+        const files = await fs7.readdir(currentSrc);
+        for (const file of files) {
+          if (file === ".DS_Store") continue;
+          const srcPath = path8.join(currentSrc, file);
+          const stats = await fs7.stat(srcPath);
+          if (stats.isDirectory()) {
+            const destPath = path8.join(currentDest, file);
+            await fs7.ensureDir(destPath);
+            await processFiles(srcPath, destPath);
+          } else if (file.endsWith(".hbs")) {
+            const content = await fs7.readFile(srcPath, "utf-8");
+            let result = content;
+            const hasHandlebarsVars = content.includes("{{");
+            if (hasHandlebarsVars) {
+              try {
+                const safeContent = content.replace(/\{\{(?!\s*([#/]?(?:if|else|each|with|unless|name|version|projectName|projectTitle|projectVersion|cliVersion|tsconfigPath|theme|isNebula|isGlass|isBusiness|isApp|isShell|pluginName|pluginPackageName|pluginVersion|pluginDisplayName|pluginDescription|pluginClassName|pluginPath|pluginFolderName|pluginType|pluginId|className))\b)/g, "\\{{");
+                const templateFn = Handlebars2.compile(safeContent);
+                result = templateFn(templateData);
+              } catch (e) {
+                result = content;
+                for (const [key, val] of Object.entries(templateData)) {
+                  const regex = new RegExp(`\\{\\{\\s*${key}\\s*\\}\\}`, "g");
+                  result = result.replace(regex, String(val));
+                }
+              }
+            }
+            const destPath = path8.join(currentDest, file.replace(/\.hbs$/, ""));
+            await fs7.outputFile(destPath, result);
+          } else {
+            const destPath = path8.join(currentDest, file);
+            await fs7.copy(srcPath, destPath);
+          }
+        }
+      };
+      await processFiles(srcDir, destDir);
+    };
+    const spinner = createSpinner("\u6B63\u5728\u751F\u6210\u9879\u76EE\u7ED3\u6784...").start();
+    if (projectType === "monorepo") {
+      spinner.text = "\u6B63\u5728\u751F\u6210 Monorepo \u9AA8\u67B6...";
+      await renderTemplate("monorepo", targetDir, { name });
+      if (isAppIncluded) {
+        spinner.text = "\u6B63\u5728\u751F\u6210 Host App...";
+        const appDir = path8.join(targetDir, "apps", "main");
+        await renderTemplate("app", appDir, { name: "@chatbi-v/main" });
+      }
+      if (isPluginIncluded) {
+        spinner.text = "\u6B63\u5728\u751F\u6210 Demo Plugin...";
+        const pluginDir = path8.join(targetDir, "plugins", "plugin-demo");
+        await renderTemplate("plugin", pluginDir, {
+          name: "@chatbi-v/plugin-demo",
+          pluginId: "demo",
+          pluginName: "demo",
+          pluginPackageName: "@chatbi-v/plugin-demo",
+          pluginVersion: "0.1.0",
+          pluginDisplayName: "\u793A\u4F8B\u63D2\u4EF6",
+          pluginDescription: "\u8FD9\u662F\u4E00\u4E2A\u521D\u59CB\u5316\u7684\u793A\u4F8B\u63D2\u4EF6",
+          pluginClassName: "DemoPlugin",
+          pluginPath: "plugin-demo",
+          pluginFolderName: "plugin-demo",
+          className: "DemoPlugin"
+        });
+      }
+    } else if (projectType === "app") {
+      spinner.text = "\u6B63\u5728\u751F\u6210\u72EC\u7ACB\u5E94\u7528...";
+      await renderTemplate("app", targetDir, { name });
+    } else if (projectType === "plugin") {
+      spinner.text = "\u6B63\u5728\u751F\u6210\u72EC\u7ACB\u63D2\u4EF6...";
+      await renderTemplate("plugin", targetDir, {
+        name: `@chatbi-v/plugin-${name}`,
+        pluginId: name,
+        pluginName: name,
+        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(""),
+        pluginPath: name,
+        pluginFolderName: name,
+        className: name.split("-").map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join("")
+      });
+    }
+    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 fs7.writeJson(path8.join(targetDir, "chatbi.config.json"), cliConfig, { spaces: 2 });
+    configSpinner.succeed("\u9879\u76EE\u914D\u7F6E\u751F\u6210\u5B8C\u6210");
+    printBox(
+      `${pc6.green(pc6.bold("\u2728 \u9879\u76EE\u5DF2\u6210\u529F\u521B\u5EFA!"))}
+
+${pc6.white("\u63A5\u4E0B\u6765\u4F60\u53EF\u4EE5:")}
+${pc6.cyan(`  cd ${name}`)}
+${pc6.cyan("  pnpm install")}
+${pc6.cyan("  pnpm dev")}`,
+      "Success"
+    );
+  } catch (error) {
+    logger.error("\u521D\u59CB\u5316\u5931\u8D25", error);
+    throw error;
+  }
+}
+var init_init = __esm({
+  "src/commands/init.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_utils();
+    init_sync();
+  }
+});
+
+// src/commands/fetch.ts
+var fetch_exports = {};
+__export(fetch_exports, {
+  fetch: () => fetch
+});
+import path13 from "path";
+import pc12 from "picocolors";
+import { execa as execa4 } from "execa";
+async function fetch(version, options = {}) {
+  const fetchSpinner = createSpinner(`\u6B63\u5728\u83B7\u53D6\u5185\u6838\u7248\u672C ${pc12.cyan(version)}...`).start();
+  const versionPath = await Sandbox.prepare(version, true);
+  fetchSpinner.succeed(`\u5185\u6838\u7248\u672C ${pc12.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 execa4("tar", [
+      "-czf",
+      tgzPath,
+      "-C",
+      path13.dirname(versionPath),
+      path13.basename(versionPath)
+    ]);
+    packSpinner.succeed("\u79BB\u7EBF\u8D44\u6E90\u6253\u5305\u5B8C\u6210");
+    printBox(
+      `${pc12.green(pc12.bold("\u2728 \u79BB\u7EBF\u5305\u5DF2\u751F\u6210!"))}
+
+${pc12.white("\u6587\u4EF6\u8DEF\u5F84: ")} ${pc12.cyan(tgzPath)}
+${pc12.white("\u5B89\u88C5\u547D\u4EE4: ")} ${pc12.gray(`chatbi install ${tgzName}`)}`,
+      "Pack Success"
+    );
+  } else {
+    logger.success(`\u5185\u6838\u7248\u672C ${pc12.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/bench.ts
+var bench_exports = {};
+__export(bench_exports, {
+  bench: () => bench
+});
+import pc14 from "picocolors";
+import fs13 from "fs-extra";
+import path15 from "path";
+import os2 from "os";
+async function bench() {
+  logger.info("\u6B63\u5728\u542F\u52A8 CLI \u6027\u80FD\u57FA\u51C6\u6D4B\u8BD5...");
+  const results = [];
+  const tmpDir = path15.join(os2.tmpdir(), `chatbi-bench-${Date.now()}`);
+  await fs13.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 = path15.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: ${pc14.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: ${pc14.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: ${pc14.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(
+      `${pc14.green(pc14.bold("\u2728 \u57FA\u51C6\u6D4B\u8BD5\u5B8C\u6210!"))}
+
+` + results.map((r) => `${pc14.white(r.scene.padEnd(20))}: ${pc14.cyan(r.actual)} (\u76EE\u6807 ${r.target})`).join("\n"),
+      "Benchmark Results"
+    );
+  } finally {
+    await fs13.remove(tmpDir);
+  }
+}
+var init_bench = __esm({
+  "src/commands/bench.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_utils();
+  }
+});
+
+// src/index.ts
+init_esm_shims();
+init_build();
+import cac from "cac";
+import pc15 from "picocolors";
+import figlet from "figlet";
+import gradient from "gradient-string";
+import boxen2 from "boxen";
+
+// src/commands/dev.ts
+init_esm_shims();
+init_corekit();
+async function dev(options = {}) {
+  const cwd = process.cwd();
+  await CoreKit.startDev(cwd, options);
+}
+
+// src/index.ts
+init_init();
+
+// src/commands/add.ts
+init_esm_shims();
+init_utils();
+init_config();
+import fs8 from "fs-extra";
+import path9 from "path";
+import pc7 from "picocolors";
+import prompts3 from "prompts";
+import Handlebars3 from "handlebars";
+async function add(options) {
+  let { name, type, displayName, description } = options;
+  const cwd = process.cwd();
+  const pkgPath = path9.join(cwd, "package.json");
+  if (!fs8.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 fs8.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 prompts3([
+    {
+      type: name ? null : "text",
+      name: "pluginName",
+      message: "\u8BF7\u8F93\u5165\u63D2\u4EF6\u540D\u79F0 (ID, \u5EFA\u8BAE\u5C0F\u5199\u548C\u4E2D\u5212\u7EBF):",
+      initial: "my-custom-plugin",
+      validate: (value) => /^[a-z0-9-]+$/.test(value) || "\u540D\u79F0\u53EA\u80FD\u5305\u542B\u5C0F\u5199\u5B57\u6BCD\u3001\u6570\u5B57\u548C\u4E2D\u5212\u7EBF"
+    },
+    {
+      type: displayName ? null : "text",
+      name: "pluginDisplayName",
+      message: "\u8BF7\u8F93\u5165\u63D2\u4EF6\u663E\u793A\u540D\u79F0 (\u4E2D\u6587):",
+      initial: (prev) => prev || name
+    },
+    {
+      type: description ? null : "text",
+      name: "pluginDescription",
+      message: "\u8BF7\u8F93\u5165\u63D2\u4EF6\u63CF\u8FF0:",
+      initial: "\u4E00\u4E2A\u7B80\u5355\u7684 ChatBI-V \u63D2\u4EF6"
+    },
+    {
+      type: type ? null : "select",
+      name: "pluginType",
+      message: "\u8BF7\u9009\u62E9\u63D2\u4EF6\u7C7B\u578B:",
+      choices: [
+        { title: "Business (\u4E1A\u52A1\u63D2\u4EF6)", value: "business", description: "\u5305\u542B UI \u754C\u9762\u548C\u4E1A\u52A1\u903B\u8F91" },
+        { title: "System (\u7CFB\u7EDF\u63D2\u4EF6)", value: "system", description: "\u4FA7\u91CD\u4E8E\u5E95\u5C42\u80FD\u529B\u548C\u7CFB\u7EDF\u6269\u5C55" }
+      ],
+      initial: 0
+    }
+  ], {
+    onCancel: () => {
+      logger.warn("\u5DF2\u53D6\u6D88\u6DFB\u52A0\u63D2\u4EF6");
+      process.exit(0);
+    }
+  });
+  name = name || response.pluginName;
+  type = type || response.pluginType;
+  displayName = displayName || response.pluginDisplayName || name;
+  description = description || response.pluginDescription || "";
+  let cleanName = name;
+  if (cleanName.endsWith("-plugin")) {
+    cleanName = cleanName.replace(/-plugin$/, "");
+  }
+  const folderName = cleanName.startsWith("plugin-") ? cleanName : `plugin-${cleanName}`;
+  const pluginDir = path9.resolve(cwd, "plugins", folderName);
+  if (fs8.existsSync(pluginDir)) {
+    logger.error(`\u63D2\u4EF6\u76EE\u5F55 ${folderName} \u5DF2\u5B58\u5728\u3002`);
+    return;
+  }
+  const spinner = createSpinner(`\u6B63\u5728\u6DFB\u52A0\u65B0\u63D2\u4EF6: ${pc7.bold(name)}...`).start();
+  const myCliRoot = await getCliRoot();
+  const templateDir = path9.join(myCliRoot, "templates/plugin");
+  if (!fs8.existsSync(templateDir)) {
+    spinner.fail("\u627E\u4E0D\u5230\u63D2\u4EF6\u6A21\u677F");
+    throw new Error(`\u627E\u4E0D\u5230\u63D2\u4EF6\u6A21\u677F: ${templateDir}`);
+  }
+  const targetDir = pluginDir;
+  spinner.text = "\u6B63\u5728\u52A0\u8F7D\u914D\u7F6E...";
+  const config = await ConfigManager.loadConfig(cwd);
+  const coreSource = config.coreSource || "local";
+  let corePath = "file:../../.chatbi/core";
+  if (coreSource === "npm") {
+    if (!config.coreVersion) {
+      const cliPkg = await fs8.readJson(path9.join(myCliRoot, "package.json"));
+      corePath = cliPkg.version;
+    } else {
+      corePath = config.coreVersion;
+    }
+  }
+  const data = {
+    // 兼容旧模板
+    name: `@chatbi-v/${folderName}`,
+    pluginId: cleanName,
+    pluginType: type,
+    className: cleanName.split("-").map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join(""),
+    isBusiness: type === "business",
+    corePath,
+    // 新模板变量
+    pluginName: cleanName,
+    pluginPackageName: `@chatbi-v/${folderName}`,
+    pluginVersion: "0.1.0",
+    pluginDisplayName: displayName,
+    pluginDescription: description,
+    pluginClassName: cleanName.split("-").map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join(""),
+    pluginPath: folderName,
+    pluginFolderName: folderName,
+    // Fix: 注入 tsconfigPath，确保 tsconfig.json 能正确 extend
+    tsconfigPath: "../../.chatbi/tsconfig.json"
+  };
+  const renderFile = async (src, dest) => {
+    const content = await fs8.readFile(src, "utf-8");
+    let result = content;
+    const hasHandlebarsVars = content.includes("{{");
+    if (hasHandlebarsVars) {
+      try {
+        const safeContent = content.replace(/\{\{(?!\s*([#/]?(?:if|else|each|with|unless|name|version|projectName|projectTitle|projectVersion|cliVersion|tsconfigPath|theme|isNebula|isGlass|isBusiness|isApp|isShell|pluginName|pluginPackageName|pluginVersion|pluginDisplayName|pluginDescription|pluginClassName|pluginPath|pluginFolderName|pluginType|pluginId|className))\b)/g, "\\{{");
+        const templateFn = Handlebars3.compile(safeContent);
+        result = templateFn(data);
+      } catch (e) {
+        result = content;
+        for (const [key, val] of Object.entries(data)) {
+          const regex = new RegExp(`\\{\\{\\s*${key}\\s*\\}\\}`, "g");
+          result = result.replace(regex, String(val));
+        }
+      }
+    }
+    await fs8.outputFile(dest.replace(".hbs", ""), result);
+  };
+  const processTemplates = async (currentSrc, currentDest) => {
+    const files = await fs8.readdir(currentSrc);
+    for (const file of files) {
+      const srcPath = path9.join(currentSrc, file);
+      const destPath = path9.join(currentDest, file);
+      const stats = await fs8.stat(srcPath);
+      if (stats.isDirectory()) {
+        await fs8.ensureDir(destPath);
+        await processTemplates(srcPath, destPath);
+      } else if (file.endsWith(".hbs")) {
+        await renderFile(srcPath, destPath);
+      } else {
+        await fs8.copy(srcPath, destPath);
+      }
+    }
+  };
+  spinner.text = "\u6B63\u5728\u751F\u6210\u63D2\u4EF6\u6587\u4EF6...";
+  await processTemplates(templateDir, targetDir);
+  spinner.succeed(`\u63D2\u4EF6 ${pc7.bold(name)} \u6DFB\u52A0\u6210\u529F\uFF01`);
+  printBox(
+    `${pc7.green(pc7.bold("\u2728 \u63D2\u4EF6\u521B\u5EFA\u6210\u529F!"))}
+
+${pc7.white("\u9879\u76EE\u8DEF\u5F84: ")} ${pc7.cyan(`plugins/${folderName}`)}
+${pc7.white("\u63D2\u4EF6 ID:   ")} ${pc7.cyan(cleanName)}
+${pc7.white("\u63D2\u4EF6\u7C7B\u578B: ")} ${pc7.cyan(type)}
+
+${pc7.white("\u63A5\u4E0B\u6765\u4F60\u53EF\u4EE5:")}
+${pc7.cyan("  pnpm dev")}  \u542F\u52A8\u5F00\u53D1\u73AF\u5883\u67E5\u770B\u6548\u679C`,
+    "Plugin Created"
+  );
+}
+
+// src/commands/gl.ts
+init_esm_shims();
+init_utils();
+import fs9 from "fs-extra";
+import path10 from "path";
+import pc8 from "picocolors";
+import prompts4 from "prompts";
+import { execa as execa3 } from "execa";
+async function gl(options) {
+  const { type: initialType, prompt: initialPrompt } = options;
+  const cwd = process.cwd();
+  const pkgPath = path10.join(cwd, "package.json");
+  if (!fs9.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 response = await prompts4([
+    {
+      type: initialType ? null : "select",
+      name: "genType",
+      message: "\u8BF7\u9009\u62E9 AI \u811A\u624B\u67B6\u6307\u4EE4:",
+      choices: [
+        { title: "\u{1F916} smart", value: "smart", description: "\u667A\u80FD\u51B3\u7B56 (\u6839\u636E\u9700\u6C42\u81EA\u52A8\u9009\u62E9\u5DE5\u5177)" },
+        { title: "\u{1F50C} plugin", value: "plugin", description: "\u751F\u6210\u65B0\u63D2\u4EF6" },
+        { title: "\u{1F9E9} component", value: "component", description: "\u751F\u6210\u4E1A\u52A1\u7EC4\u4EF6" },
+        { title: "\u{1F4E1} api", value: "api", description: "\u751F\u6210 API \u5B9A\u4E49\u4E0E\u8BF7\u6C42\u51FD\u6570" },
+        { title: "\u{1F3AD} mock", value: "mock", description: "\u751F\u6210 Mock \u6D4B\u8BD5\u6570\u636E" },
+        { title: "\u{1F6E0}\uFE0F  util", value: "util", description: "\u751F\u6210\u5DE5\u5177\u51FD\u6570" },
+        { title: "\u{1F4C4} doc", value: "doc", description: "\u751F\u6210\u9879\u76EE\u6587\u6863" },
+        { title: "\u2728 chat", value: "chat", description: "\u81EA\u7531\u5BF9\u8BDD" }
+      ],
+      initial: 0
+    },
+    {
+      type: (prev, values) => initialPrompt || values.genType === "chat" ? null : "text",
+      name: "userPrompt",
+      message: "\u8BF7\u8F93\u5165\u8BE6\u7EC6\u9700\u6C42\u63CF\u8FF0:",
+      initial: initialPrompt || ""
+    }
+  ], {
+    onCancel: () => {
+      logger.warn("\u5DF2\u53D6\u6D88 AI \u751F\u6210");
+      process.exit(0);
+    }
+  });
+  const genType = initialType || response.genType;
+  const userPrompt = initialPrompt || response.userPrompt;
+  if (!userPrompt && genType !== "chat") {
+    logger.error("\u9700\u6C42\u63CF\u8FF0\u4E0D\u80FD\u4E3A\u7A7A\u3002");
+    return;
+  }
+  logger.info(`\u6B63\u5728\u547C\u53EB AI \u5F15\u64CE [\u6A21\u5F0F: ${pc8.bold(genType)}]...`);
+  const toolsContext = `
+[Available Tools & Capabilities]
+- Tool: plugin -> For creating new feature modules. Requires: name, type (business|system).
+- Tool: component -> For UI elements. Tech: AntD5, Tailwind.
+- Tool: api -> For network requests. Structure: src/api/[name].ts, uses shared request util, defines TS interfaces.
+- Tool: mock -> For dev data. Structure: mock/[name].ts, follows Mock.js or MSW format.
+- Tool: util -> For pure functions. Structure: src/utils/[name].ts, requires unit tests.
+- Tool: doc -> For documentation. Format: Markdown, structure: docs/[type]/[name].md.
+
+[Tool Functions Implementation Details]
+- API Function: Should include request method, URL, params/data types, and response type. Use '@chatbi-v/core/request'.
+- Mock Function: Should provide realistic data based on API definition.
+- Plugin Function: Should follow the Micro-Kernel architecture, registering to 'pluginManager'.
+
+[Requirement Slots / Missing Info]
+If the user's request is ambiguous or missing key information, you MUST output: "SLOT_REQUIRED: [Field Name] | [Question to User]".
+`.trim();
+  const templatesContext = `
+[Project Templates Structure]
+- Plugin: class extends Plugin, metadata: { id, name, version, type, routes, extensions }.
+- API: export const fetchData = (params: T) => request.get<R>('/url', { params }).
+- Mock: export default { 'GET /api/test': { code: 200, data: {} } }.
+- UI: React 18, Ant Design 5, Tailwind CSS 3.
+`.trim();
+  const systemContext = `[Context: ChatBI-V System | Dir: ${cwd} | Tech: React18, AntD5, Tailwind, Micro-Kernel]
+${toolsContext}
+${templatesContext}
+
+[Decision Logic]
+If genType is 'smart', you must first decide which tool is most appropriate.
+If the requirement is clear, proceed with generation.
+If not, use the SLOT_REQUIRED format.`.trim();
+  const finalPrompt = userPrompt ? `${systemContext}
+
+[User Request]: ${userPrompt}` : systemContext;
+  const geminiCmd = genType === "smart" ? "chat" : genType;
+  const spinner = createSpinner("AI \u5F15\u64CE\u6B63\u5728\u601D\u8003\u4E2D... (\u53EF\u80FD\u9700\u8981\u51E0\u5341\u79D2\uFF0C\u8BF7\u8010\u5FC3\u7B49\u5F85)");
+  let currentPrompt = finalPrompt;
+  let retry = true;
+  while (retry) {
+    spinner.start();
+    try {
+      const { stdout } = await execa3("gemini", [geminiCmd, currentPrompt], {
+        stdio: "pipe"
+      });
+      spinner.stop();
+      if (stdout.includes("SLOT_REQUIRED:")) {
+        const slots = [];
+        const lines = stdout.split("\n");
+        for (const line of lines) {
+          if (line.includes("SLOT_REQUIRED:")) {
+            const match = line.match(/SLOT_REQUIRED:\s*([^|]+)\|\s*(.+)/);
+            if (match) {
+              slots.push({
+                type: "text",
+                name: match[1].trim(),
+                message: match[2].trim()
+              });
+            }
+          }
+        }
+        if (slots.length > 0) {
+          logger.info(pc8.yellow("\n\u{1F4DD} AI \u9700\u8981\u66F4\u591A\u4FE1\u606F\u4EE5\u7EE7\u7EED:"));
+          const answers = await prompts4(slots, {
+            onCancel: () => process.exit(0)
+          });
+          const answerContext = Object.entries(answers).map(([k, v]) => `[${k}]: ${v}`).join("\n");
+          currentPrompt += `
+
+[User Answers]:
+${answerContext}
+
+Please proceed with generation based on these answers.`;
+          logger.info("\u6B63\u5728\u6839\u636E\u60A8\u7684\u53CD\u9988\u91CD\u65B0\u547C\u53EB AI...");
+          continue;
+        }
+      }
+      console.log("\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(pc8.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}`);
+      }
+      throw error;
+    }
+  }
+}
+
+// src/index.ts
+init_sync();
+
+// src/commands/doctor.ts
+init_esm_shims();
+init_utils();
+init_sandbox();
+init_corekit();
+import fs10 from "fs-extra";
+import path11 from "path";
+import pc9 from "picocolors";
+import glob from "fast-glob";
+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..."));
+  const nodeVersion = process.version;
+  if (parseInt(nodeVersion.slice(1).split(".")[0]) < 18) {
+    logger.error(`Node.js \u7248\u672C\u592A\u4F4E: ${nodeVersion} (\u8981\u6C42 >=18)`);
+    hasIssues = true;
+    issues.push(`Node.js \u7248\u672C\u8FC7\u4F4E (${nodeVersion})`);
+  } else {
+    logger.success(`Node.js \u7248\u672C: ${nodeVersion}`);
+  }
+  try {
+    const { execa: execa6 } = await import("execa");
+    const { stdout: pnpmVer } = await execa6("pnpm", ["-v"]);
+    logger.success(`pnpm \u7248\u672C: ${pnpmVer}`);
+  } catch (e) {
+    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..."));
+  const version = await CoreKit.resolveVersion(cwd);
+  const versionPath = Sandbox.getVersionPath(version);
+  if (!fs10.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`));
+    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 = path11.join(versionPath, "node_modules");
+    if (!fs10.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 (!fs10.existsSync(path11.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 = path11.join(cwd, ".chatbi");
+  if (!fs10.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 = path11.join(chatbiDir, "tsconfig.paths.json");
+    const aliasJson = path11.join(chatbiDir, "vite.alias.json");
+    if (!fs10.existsSync(pathsJson) || !fs10.existsSync(aliasJson)) {
+      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");
+    } else {
+      logger.success("\u865A\u62DF\u4F9D\u8D56\u914D\u7F6E\u5DF2\u751F\u6210");
+    }
+  }
+  const tsConfigPath = path11.join(cwd, "tsconfig.json");
+  if (fs10.existsSync(tsConfigPath)) {
+    try {
+      const tsConfig = await fs10.readJson(tsConfigPath);
+      const extendsPath = tsConfig.extends;
+      const expectedPaths = ["./.chatbi/tsconfig.paths.json", ".chatbi/tsconfig.paths.json"];
+      let hasExtend = false;
+      if (typeof extendsPath === "string") {
+        hasExtend = expectedPaths.includes(extendsPath);
+      } else if (Array.isArray(extendsPath)) {
+        hasExtend = extendsPath.some((p) => expectedPaths.includes(p));
+      }
+      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");
+      } else {
+        logger.success("tsconfig.json \u914D\u7F6E\u6B63\u5E38");
+      }
+    } catch (e) {
+      logger.error("\u89E3\u6790 tsconfig.json \u5931\u8D25");
+    }
+  }
+  const viteConfigPath = path11.join(cwd, "vite.config.ts");
+  if (fs10.existsSync(viteConfigPath)) {
+    const content = await fs10.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");
+    }
+  }
+  logger.info(pc9.bold("\nStep 4: \u626B\u63CF\u4EE3\u7801\u89C4\u5219..."));
+  const rules = [
+    {
+      id: "plugin-lifecycle-init",
+      description: "\u63D2\u4EF6\u751F\u547D\u5468\u671F init() \u5DF2\u53D8\u66F4\u4E3A onLoad()",
+      pattern: /async\s+init\s*\(\s*context\s*:\s*PluginContext\s*\)/g,
+      fix: (content) => content.replace(/async\s+init\s*\(\s*context\s*:\s*PluginContext\s*\)/g, "async onLoad(context: PluginContext)")
+    },
+    {
+      id: "plugin-lifecycle-destroy",
+      description: "\u63D2\u4EF6\u751F\u547D\u5468\u671F destroy() \u5DF2\u53D8\u66F4\u4E3A onUnload()",
+      pattern: /async\s+destroy\s*\(\s*\)/g,
+      fix: (content) => content.replace(/async\s+destroy\s*\(\s*\)/g, "async onUnload()")
+    }
+  ];
+  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 fs10.readFile(file, "utf-8");
+      for (const rule of rules) {
+        if (rule.pattern.test(content)) {
+          codeIssues.push({
+            file,
+            ruleId: rule.id,
+            description: rule.description,
+            rule
+          });
+        }
+      }
+    }
+    if (codeIssues.length > 0) {
+      scanSpinner.fail(`\u53D1\u73B0 ${codeIssues.length} \u4E2A\u4EE3\u7801\u89C4\u8303\u95EE\u9898`);
+      hasIssues = true;
+      codeIssues.forEach((issue) => {
+        const relativePath = path11.relative(cwd, issue.file);
+        issues.push(`\u4EE3\u7801\u89C4\u8303 [${issue.ruleId}]: ${relativePath}`);
+      });
+    } else {
+      scanSpinner.succeed("\u4EE3\u7801\u89C4\u8303\u68C0\u67E5\u901A\u8FC7");
+    }
+  }
+  if (!hasIssues) {
+    printBox(
+      pc9.green(pc9.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");
+    printBox(
+      `${pc9.yellow(pc9.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")}`,
+      "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 fs10.readFile(issue.file, "utf-8");
+          const newContent = issue.rule.fix(content);
+          await fs10.writeFile(issue.file, newContent);
+        }
+        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");
+    }
+  }
+}
+
+// src/commands/discover.ts
+init_esm_shims();
+init_corekit();
+init_utils();
+import pc10 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(pc10.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 ${pc10.cyan(plugins.length)} \u4E2A\u63D2\u4EF6`);
+    const pluginList = plugins.map((p) => `- ${pc10.bold(p.name)} ${pc10.gray(`(${p.id})`)}
+  ${pc10.gray(p.path)}`).join("\n\n");
+    printBox(
+      `${pc10.green(pc10.bold("\u2728 \u63D2\u4EF6\u626B\u63CF\u7ED3\u679C"))}
+
+${pluginList}`,
+      "Plugin Discovery"
+    );
+  }
+}
+
+// src/commands/ls.ts
+init_esm_shims();
+init_corekit();
+init_sandbox();
+init_utils();
+import pc11 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 = pc11.green(" *");
+      } else if (isGlobalCurrent) {
+        prefix = pc11.blue(" >");
+      }
+      let suffix = "";
+      if (isProjectCurrent && isGlobalCurrent) {
+        suffix = pc11.gray(" (\u5F53\u524D\u9879\u76EE & \u5168\u5C40)");
+      } else if (isProjectCurrent) {
+        suffix = pc11.gray(" (\u5F53\u524D\u9879\u76EE)");
+      } else if (isGlobalCurrent) {
+        suffix = pc11.gray(" (\u5168\u5C40)");
+      }
+      return `${prefix} ${pc11.white(v)}${suffix}`;
+    }).join("\n");
+    printBox(
+      list + pc11.gray("\n\n\u63D0\u793A: * \u5F53\u524D\u9879\u76EE\u4F7F\u7528, > \u5168\u5C40\u9ED8\u8BA4\u4F7F\u7528"),
+      "Kernel Versions"
+    );
+  }
+  await Sandbox.visualizeStatus(process.cwd());
+}
+
+// src/commands/use.ts
+init_esm_shims();
+init_sandbox();
+init_corekit();
+init_sync();
+init_utils();
+import fs11 from "fs-extra";
+import path12 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 = path12.join(cwd, ".chatbi-version");
+    await fs11.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 });
+}
+
+// src/index.ts
+init_fetch();
+
+// src/commands/install.ts
+init_esm_shims();
+init_sandbox();
+init_utils();
+import fs12 from "fs-extra";
+import path14 from "path";
+import pc13 from "picocolors";
+import { execa as execa5 } from "execa";
+async function install(target) {
+  if (target.endsWith(".tgz") && fs12.existsSync(target)) {
+    const spinner = createSpinner(`\u6B63\u5728\u5B89\u88C5\u672C\u5730\u79BB\u7EBF\u5305: ${pc13.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 fs12.ensureDir(versionRoot);
+      spinner.text = "\u6B63\u5728\u89E3\u538B\u6587\u4EF6...";
+      await execa5("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;
+    }
+  } else {
+    const { fetch: fetch2 } = await Promise.resolve().then(() => (init_fetch(), fetch_exports));
+    await fetch2(target);
+  }
+}
+
+// package.json
+var package_default = {
+  name: "@chatbi-v/cli",
+  version: "2.0.4",
+  description: "Standardized CLI tooling for ChatBI Monorepo",
+  type: "module",
+  main: "dist/index.js",
+  module: "dist/index.js",
+  types: "dist/index.d.ts",
+  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/index.ts
+init_utils();
+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(pc15.cyan(`ChatBI-V \u7EDF\u4E00\u5F00\u53D1\u5DE5\u5177 v${package_default.version}`), {
+      padding: 0,
+      margin: { top: 1, bottom: 1 },
+      borderStyle: "round",
+      borderColor: "cyan",
+      title: "CoreKit Enabled",
+      titleAlignment: "center"
+    })
+  );
+};
+var wrapAction = (action, commandName) => {
+  return async (...args) => {
     showHeader();
-    sections[0].body = picocolors_1.default.white('ChatBI-V 开发者命令行工具，助力快速开发和构建插件。');
+    try {
+      await action(...args);
+    } catch (e) {
+      logger.error(`${commandName} \u6267\u884C\u5931\u8D25`, e);
+      process.exit(1);
+    }
+  };
+};
+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({
+    name,
+    projectType: options.projectType,
+    includeApp: options.includeApp,
+    includePlugin: options.includePlugin,
+    pluginType: options.pluginType,
+    theme: options.theme
+  });
+}, "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({
+    name,
+    type: options.type,
+    displayName: options.displayName,
+    description: options.desc
+  });
+}, "add"));
+cli.command("update [targetVersion]", "\u66F4\u65B0\u5185\u6838\u7248\u672C").alias("up").action(wrapAction(async (targetVersion) => {
+  const { sync: sync2 } = await Promise.resolve().then(() => (init_sync(), sync_exports));
+  await sync2({ version: targetVersion, force: true });
+  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 });
+}, "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("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 = pc15.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.version(package_json_1.default.version);
-// 处理空命令
+cli.version(package_default.version);
 if (process.argv.length <= 2) {
-    cli.outputHelp();
-}
-else {
-    cli.parse();
+  cli.outputHelp();
+} else {
+  cli.parse();
 }