@chatbi-v/cli 2.0.3 → 2.0.5

package/dist/index.js

@@ -1,201 +1,2657 @@
-"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;
-        };
-        return ownKeys(o);
-    };
-    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;
-    };
-})();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+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;
 };
-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'
-    }));
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-/**
- * 包装命令 Action，统一错误处理
- */
-const wrapAction = (action, commandName) => {
-    return async (...args) => {
-        showHeader();
+
+// ../../../chatbi-v/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({
+  "../../../chatbi-v/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, "../../");
+        }
+        return null;
+      }
+    };
+    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/constants.ts
+import path3 from "path";
+import os from "os";
+var SANDBOX_CONFIG, GLOBAL_PATHS, DEPENDENCY_VERSIONS, DEFAULT_CONFIG;
+var init_constants = __esm({
+  "src/constants.ts"() {
+    "use strict";
+    init_esm_shims();
+    SANDBOX_CONFIG = {
+      /** 用户主目录下的沙箱根目录名 */
+      BASE_NAME: ".chatbi-v-core",
+      /** 内部子目录结构 */
+      DIRS: {
+        VERSIONS: "versions",
+        CURRENT: "current",
+        CACHE: ".chatbi"
+      },
+      /** 关键标识文件 */
+      LOCK_FILE: ".chatbi-version"
+    };
+    GLOBAL_PATHS = {
+      /** 沙箱根路径 */
+      BASE_DIR: path3.join(os.homedir(), SANDBOX_CONFIG.BASE_NAME),
+      /** Monorepo 扫描目录 */
+      MONOREPO_ROOTS: ["apps", "plugins", "packages"]
+    };
+    DEPENDENCY_VERSIONS = {
+      // 基础框架
+      "react": "^18.3.1",
+      "react-dom": "^18.3.1",
+      "antd": "^5.20.0",
+      // 构建工具
+      "vite": "^5.0.8",
+      "typescript": "^5.3.3",
+      "tailwindcss": "^3.4.1",
+      "autoprefixer": "^10.4.17",
+      "postcss": "^8.4.35",
+      "less": "^4.2.0",
+      // 类型定义
+      "@types/react": "^18.3.1",
+      "@types/react-dom": "^18.3.1",
+      "@types/node": "^20.11.20",
+      "@vitejs/plugin-react": "^4.2.1"
+    };
+    DEFAULT_CONFIG = {
+      /** 支持的配置文件名 */
+      CONFIG_FILES: [
+        "chatbi.config.ts",
+        "chatbi.config.js",
+        "chatbi.config.json",
+        ".chatbirc"
+      ],
+      /** 默认 UI 主题 */
+      THEME: "standard"
+    };
+  }
+});
+
+// src/sandbox/SandboxPath.ts
+import path4 from "path";
+import fs2 from "fs-extra";
+var SandboxPath;
+var init_SandboxPath = __esm({
+  "src/sandbox/SandboxPath.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_constants();
+    SandboxPath = class {
+      static {
+        /**
+         * 沙箱的基础存储目录，通常位于用户主目录下的 .chatbi-v-core
+         */
+        this.BASE_DIR = GLOBAL_PATHS.BASE_DIR;
+      }
+      /**
+       * 获取沙箱根目录
+       * @returns 沙箱根目录的绝对路径
+       */
+      static getRoot() {
+        return this.BASE_DIR;
+      }
+      /**
+       * 获取存储所有版本的根目录
+       * @returns versions 目录的绝对路径
+       */
+      static getVersionRoot() {
+        return path4.join(this.BASE_DIR, SANDBOX_CONFIG.DIRS.VERSIONS);
+      }
+      /**
+       * 获取指定版本的沙箱路径
+       * @param version 版本号，或者 'current' 表示当前激活版本
+       * @returns 对应版本的绝对路径
+       */
+      static getVersionPath(version) {
+        if (version === SANDBOX_CONFIG.DIRS.CURRENT) {
+          return path4.join(this.BASE_DIR, SANDBOX_CONFIG.DIRS.VERSIONS, SANDBOX_CONFIG.DIRS.CURRENT);
+        }
+        return path4.join(this.BASE_DIR, SANDBOX_CONFIG.DIRS.VERSIONS, version);
+      }
+      /**
+       * 递归向上查找工作区根目录
+       * 识别标准：包含 pnpm-workspace.yaml 或 package.json 中定义了 workspaces
+       * @param cwd 起始查找目录
+       * @returns 查找到的工作区根目录路径，若未找到则返回 cwd
+       */
+      static async getWorkspaceRoot(cwd) {
+        let current = cwd;
+        while (current !== path4.parse(current).root) {
+          const pkgPath = path4.join(current, "package.json");
+          const pnpmWorkspacePath = path4.join(current, "pnpm-workspace.yaml");
+          if (fs2.existsSync(pnpmWorkspacePath)) return current;
+          if (fs2.existsSync(pkgPath)) {
+            try {
+              const pkg = await fs2.readJson(pkgPath);
+              if (pkg.workspaces) return current;
+            } catch (e) {
+            }
+          }
+          current = path4.dirname(current);
+        }
+        return cwd;
+      }
+    };
+  }
+});
+
+// src/sandbox/SandboxRenderer.ts
+import fs3 from "fs-extra";
+import path5 from "path";
+import Handlebars from "handlebars";
+var SandboxRenderer;
+var init_SandboxRenderer = __esm({
+  "src/sandbox/SandboxRenderer.ts"() {
+    "use strict";
+    init_esm_shims();
+    Handlebars.registerHelper("json", (obj) => JSON.stringify(obj, null, 2));
+    Handlebars.registerHelper("eq", (a, b) => a === b);
+    SandboxRenderer = class {
+      static {
+        /**
+         * 需要转义的模板关键字列表
+         * 只有匹配这些关键字的 {{ }} 才会被 Handlebars 处理，其余（如 React 的 {{ style }}）将被转义跳过
+         */
+        this.TEMPLATE_KEYWORDS = [
+          "name",
+          "version",
+          "projectName",
+          "projectTitle",
+          "projectVersion",
+          "cliVersion",
+          "tsconfigPath",
+          "theme",
+          "isNebula",
+          "isGlass",
+          "isBusiness",
+          "isApp",
+          "isShell",
+          "pluginName",
+          "pluginPackageName",
+          "pluginVersion",
+          "pluginDisplayName",
+          "pluginDescription",
+          "pluginClassName",
+          "pluginPath",
+          "pluginFolderName",
+          "pluginType",
+          "pluginId",
+          "className",
+          "dependencies",
+          "devDependencies",
+          "json"
+        ];
+      }
+      /**
+       * 递归渲染目录模板
+       * @param srcDir 模板源目录
+       * @param destDir 目标输出目录
+       * @param data 渲染模板所需的变量上下文
+       */
+      static async renderDirectory(srcDir, destDir, data) {
+        if (!fs3.existsSync(srcDir)) return;
+        const entries = await fs3.readdir(srcDir, { withFileTypes: true });
+        for (const entry of entries) {
+          const srcPath = path5.join(srcDir, entry.name);
+          const destPath = path5.join(destDir, entry.name.replace(/\.hbs$/, ""));
+          if (entry.isDirectory()) {
+            await fs3.ensureDir(destPath);
+            await this.renderDirectory(srcPath, destPath, data);
+          } else {
+            await this.renderFile(srcPath, destPath, data);
+          }
+        }
+      }
+      /**
+       * 渲染单个文件
+       */
+      static async renderFile(srcPath, destPath, data) {
+        const isTemplate = srcPath.endsWith(".hbs");
+        if (!isTemplate) {
+          await fs3.copy(srcPath, destPath);
+          return;
+        }
+        const content = await fs3.readFile(srcPath, "utf-8");
+        if (!content.includes("{{")) {
+          await fs3.outputFile(destPath, content);
+          return;
+        }
         try {
-            await action(...args);
+          const keywordsPattern = this.TEMPLATE_KEYWORDS.join("|");
+          const safeContent = content.replace(
+            new RegExp(`\\{\\{(?!\\{)(?!\\s*([#/]?(?:${keywordsPattern}))\\b)`, "g"),
+            "\\{{"
+          );
+          const template = Handlebars.compile(safeContent);
+          const result = template(data);
+          await fs3.outputFile(destPath, result);
+        } catch (e) {
+          let result = content;
+          for (const [key, val] of Object.entries(data)) {
+            const regex = new RegExp(`\\{\\{\\s*${key}\\s*\\}\\}`, "g");
+            result = result.replace(regex, typeof val === "object" ? JSON.stringify(val) : String(val));
+          }
+          await fs3.outputFile(destPath, result);
         }
-        catch (e) {
-            utils_1.logger.error(`${commandName} 执行失败`, e);
-            process.exit(1);
+      }
+    };
+  }
+});
+
+// src/sandbox/SandboxContext.ts
+import fs4 from "fs-extra";
+import path6 from "path";
+var SandboxContext;
+var init_SandboxContext = __esm({
+  "src/sandbox/SandboxContext.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_SandboxPath();
+    init_constants();
+    SandboxContext = class {
+      /**
+       * 注入项目虚拟上下文
+       * 包括：
+       * 1. 确定集中式 .chatbi 存放位置并处理子包软链
+       * 2. 生成适配沙箱的 tsconfig.json (配置路径别名)
+       * 3. 软链接沙箱的 node_modules 到项目 .chatbi 目录下
+       * 4. 确保 .chatbi 被加入 .gitignore
+       * 
+       * @param projectRoot 当前项目根目录
+       * @param version 内核版本号
+       * @param corePackages 核心包名列表
+       * @param runtimeDeps 运行时依赖包名列表
+       */
+      static async inject(projectRoot, version, corePackages, runtimeDeps) {
+        const workspaceRoot = await SandboxPath.getWorkspaceRoot(projectRoot);
+        const chatbiDir = path6.join(workspaceRoot, SANDBOX_CONFIG.DIRS.CACHE);
+        await fs4.ensureDir(chatbiDir);
+        if (workspaceRoot !== projectRoot) {
+          const localChatbi = path6.join(projectRoot, SANDBOX_CONFIG.DIRS.CACHE);
+          try {
+            const stats = await fs4.lstat(localChatbi).catch(() => null);
+            if (stats) {
+              if (stats.isSymbolicLink()) {
+                const linkTarget = await fs4.readlink(localChatbi);
+                if (linkTarget !== chatbiDir) {
+                  await fs4.remove(localChatbi);
+                  await fs4.symlink(chatbiDir, localChatbi, "dir");
+                }
+              } else {
+                await fs4.remove(localChatbi);
+                await fs4.symlink(chatbiDir, localChatbi, "dir");
+              }
+            } else {
+              await fs4.symlink(chatbiDir, localChatbi, "dir");
+            }
+          } catch (e) {
+          }
+        }
+        const versionPath = SandboxPath.getVersionPath(version);
+        const sandboxNodeModules = path6.join(versionPath, "node_modules");
+        const corePaths = {};
+        for (const pkgName of corePackages) {
+          corePaths[pkgName] = [`./node_modules/${pkgName}`];
+          corePaths[`${pkgName}/*`] = [`./node_modules/${pkgName}/*`];
         }
+        for (const pkgName of runtimeDeps) {
+          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 = path6.join(sandboxNodeModules, "@chatbi-v/tsconfig/base.json");
+        const tsConfig = {
+          extends: baseConfigPath,
+          compilerOptions: {
+            baseUrl: ".",
+            moduleResolution: "bundler",
+            skipLibCheck: true,
+            typeRoots: ["./node_modules/@types"],
+            preserveSymlinks: true,
+            paths: {
+              ...corePaths,
+              "@/*": ["../src/*"],
+              "*": ["./node_modules/*"]
+            }
+          }
+        };
+        await fs4.writeJson(path6.join(chatbiDir, "tsconfig.json"), tsConfig, { spaces: 2 });
+        await fs4.writeJson(path6.join(chatbiDir, "tsconfig.paths.json"), { compilerOptions: tsConfig.compilerOptions }, { spaces: 2 });
+        const virtualNodeModules = path6.join(chatbiDir, "node_modules");
+        if (fs4.existsSync(sandboxNodeModules)) {
+          try {
+            await fs4.remove(virtualNodeModules).catch(() => {
+            });
+            await fs4.ensureSymlink(sandboxNodeModules, virtualNodeModules, "dir");
+          } catch (e) {
+          }
+        }
+        const gitignorePath = path6.join(workspaceRoot, ".gitignore");
+        if (fs4.existsSync(gitignorePath)) {
+          let content = await fs4.readFile(gitignorePath, "utf-8");
+          if (!content.includes(SANDBOX_CONFIG.DIRS.CACHE)) {
+            await fs4.appendFile(gitignorePath, `
+# ChatBI
+${SANDBOX_CONFIG.DIRS.CACHE}
+`);
+          }
+        }
+      }
     };
-};
-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/sandbox/SandboxPkgManager.ts
+import fs5 from "fs-extra";
+import path7 from "path";
+import pc2 from "picocolors";
+import fg from "fast-glob";
+var SandboxPkgManager;
+var init_SandboxPkgManager = __esm({
+  "src/sandbox/SandboxPkgManager.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_utils();
+    init_SandboxPath();
+    SandboxPkgManager = class {
+      /**
+       * 尝试将本地开发环境的包 Link 到沙箱中 (模拟安装)
+       * 用于 Monorepo 场景下，让沙箱直接使用最新的本地源码
+       * @param versionPath 沙箱版本的存储路径
+       * @param corePackages 核心包名列表
+       * @param runtimeDeps 运行时依赖包名列表
+       * @returns 是否成功 Link 了至少一个包
+       */
+      static async tryLinkLocalPackages(versionPath, corePackages, runtimeDeps) {
+        try {
+          const cliRoot = await getCliRoot();
+          const projectRoot = await SandboxPath.getWorkspaceRoot(cliRoot);
+          if (projectRoot === cliRoot && !fs5.existsSync(path7.join(projectRoot, "pnpm-workspace.yaml"))) {
+            return false;
+          }
+          const possiblePackagesDirs = [
+            path7.join(projectRoot, "packages"),
+            // 兼容旧版或其他可能的路径结构
+            path7.resolve(projectRoot, "../chatbi-v/packages")
+          ];
+          const localPackages = {};
+          const patterns = possiblePackagesDirs.filter((dir) => fs5.existsSync(dir)).map((dir) => path7.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 fs5.readJson(pkgJsonPath);
+                if (corePackages.includes(pkgJson.name) || runtimeDeps.includes(pkgJson.name)) {
+                  localPackages[pkgJson.name] = path7.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 = path7.join(versionPath, "node_modules");
+          await fs5.ensureDir(sandboxNodeModules);
+          for (const [name, pkgPath] of Object.entries(localPackages)) {
+            const targetLinkPath = path7.join(sandboxNodeModules, name);
+            await fs5.ensureDir(path7.dirname(targetLinkPath));
+            try {
+              const stats = await fs5.lstat(targetLinkPath).catch(() => null);
+              if (stats) await fs5.remove(targetLinkPath);
+            } catch (e) {
+            }
+            await fs5.symlink(pkgPath, targetLinkPath, "dir");
+          }
+          const sandboxPkgJsonPath = path7.join(versionPath, "package.json");
+          const sandboxPkgJson = await fs5.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 fs5.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;
+        }
+      }
+    };
+  }
+});
+
+// src/sandbox.ts
+import fs6 from "fs-extra";
+import path8 from "path";
+import pc3 from "picocolors";
+import fg2 from "fast-glob";
+import { execa } from "execa";
+var Sandbox;
+var init_sandbox = __esm({
+  "src/sandbox.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_utils();
+    init_SandboxPath();
+    init_SandboxRenderer();
+    init_SandboxContext();
+    init_SandboxPkgManager();
+    init_constants();
+    Sandbox = class {
+      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 SandboxPath.getRoot();
+      }
+      /** 获取所有版本的根目录 */
+      static getVersionRoot() {
+        return SandboxPath.getVersionRoot();
+      }
+      /** 获取指定版本的沙箱路径 */
+      static getVersionPath(version) {
+        return SandboxPath.getVersionPath(version);
+      }
+      /** 获取项目的工作区根目录 (Monorepo 支持) */
+      static async getWorkspaceRoot(cwd) {
+        return SandboxPath.getWorkspaceRoot(cwd);
+      }
+      /** 清理指定版本的沙箱物理文件 */
+      static async cleanVersion(version) {
+        const versionPath = this.getVersionPath(version);
+        if (fs6.existsSync(versionPath)) {
+          await fs6.remove(versionPath);
+        }
+      }
+      /**
+       * 优雅清理缓存环境
+       * @param cwd 当前项目路径
+       * @param deep 是否执行深度清理
+       */
+      static async clean(cwd, deep = false) {
+        const spinner = createSpinner("\u6B63\u5728\u6E05\u7406\u7F13\u5B58\u76EE\u5F55...").start();
+        try {
+          const workspaceRoot = await this.getWorkspaceRoot(cwd);
+          let cleanedCount = 0;
+          const cachePatterns = [
+            path8.join(workspaceRoot, `**/${SANDBOX_CONFIG.DIRS.CACHE}`)
+          ];
+          const cacheDirs = await fg2(cachePatterns, {
+            onlyFiles: false,
+            // 允许匹配文件和符号链接
+            absolute: true,
+            ignore: ["**/node_modules/**"],
+            dot: true
+            // 确保能匹配到以 . 开头的目录
+          });
+          for (const dir of cacheDirs) {
+            const stats = await fs6.lstat(dir).catch(() => null);
+            if (stats) {
+              await fs6.remove(dir);
+              cleanedCount++;
+            }
+          }
+          if (deep) {
+            const distPatterns = [
+              path8.join(workspaceRoot, "**/dist")
+            ];
+            const distDirs = await fg2(distPatterns, {
+              onlyFiles: false,
+              absolute: true,
+              ignore: [
+                "**/node_modules/**",
+                "**/packages/cli/dist/**",
+                // 保护 CLI 自身构建产物
+                "**/.git/**"
+              ]
+            });
+            for (const dir of distDirs) {
+              const stats = await fs6.lstat(dir).catch(() => null);
+              if (stats) {
+                const hasPkg = fs6.existsSync(path8.join(path8.dirname(dir), "package.json"));
+                if (hasPkg) {
+                  await fs6.remove(dir);
+                  cleanedCount++;
+                }
+              }
+            }
+            const globalRoot = this.getRoot();
+            if (fs6.existsSync(globalRoot)) {
+              await fs6.remove(globalRoot);
+              cleanedCount++;
+            }
+          }
+          spinner.succeed(pc3.green(`\u6E05\u7406\u5B8C\u6210\uFF0C\u5171\u6E05\u7406 ${cleanedCount} \u4E2A\u9879\u76EE/\u7F13\u5B58\u76EE\u5F55`));
+        } catch (e) {
+          spinner.fail(pc3.red(`\u6E05\u7406\u5931\u8D25: ${e.message}`));
+        }
+      }
+      /**
+       * 准备内核沙箱环境 (安装/更新)
+       */
+      static async prepare(version, force = false) {
+        const versionPath = this.getVersionPath(version);
+        if (!force && fs6.existsSync(path8.join(versionPath, "node_modules/tailwindcss"))) {
+          return versionPath;
+        }
+        if (fs6.existsSync(versionPath)) {
+          await fs6.remove(path8.join(versionPath, "node_modules"));
+        }
+        await fs6.ensureDir(versionPath);
+        const spinner = createSpinner(`\u6B63\u5728\u521D\u59CB\u5316\u5185\u6838\u6C99\u7BB1 ${pc3.cyan(version)}...`).start();
+        try {
+          const cliRoot = await getCliRoot();
+          const dependencies = {};
+          for (const pkg of this.RUNTIME_DEPS) {
+            dependencies[pkg] = DEPENDENCY_VERSIONS[pkg] || "latest";
+          }
+          for (const pkg of this.CORE_PACKAGES) {
+            dependencies[pkg] = pkg === "@chatbi-v/core" ? version : "latest";
+          }
+          const templateData = {
+            version,
+            dependencies,
+            devDependencies: DEPENDENCY_VERSIONS
+          };
+          await SandboxRenderer.renderDirectory(
+            path8.join(cliRoot, "templates/sandbox"),
+            versionPath,
+            templateData
+          );
+          spinner.text = pc3.gray("  \u{1F50D} \u68C0\u67E5\u672C\u5730\u5F00\u53D1\u73AF\u5883...");
+          const isLocalDev = await SandboxPkgManager.tryLinkLocalPackages(versionPath, this.CORE_PACKAGES, this.RUNTIME_DEPS);
+          const installArgs = isLocalDev ? ["install", "--no-frozen-lockfile"] : ["install"];
+          spinner.text = pc3.gray(`  \u23F3 \u6267\u884C pnpm ${installArgs.join(" ")}...`);
+          await execa("pnpm", installArgs, { cwd: versionPath });
+          spinner.text = pc3.gray("  \u{1F3A8} \u540C\u6B65 Shell \u6A21\u677F...");
+          await this.ensureShell(version, force);
+          spinner.succeed(pc3.green(`\u5185\u6838\u6C99\u7BB1 ${version} \u521D\u59CB\u5316\u6210\u529F`));
+        } catch (e) {
+          spinner.fail(pc3.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 = path8.join(versionPath, "shell");
+        if (!force && fs6.existsSync(path8.join(shellDestDir, "tsconfig.paths.json"))) {
+          return shellDestDir;
+        }
+        const cliRoot = await getCliRoot();
+        const shellTemplateDir = path8.join(cliRoot, "templates/app");
+        if (fs6.existsSync(shellTemplateDir)) {
+          await fs6.remove(shellDestDir);
+          const templateData = {
+            name: "chatbi-shell",
+            version,
+            cliVersion: version,
+            theme: DEFAULT_CONFIG.THEME,
+            isShell: true,
+            isBusiness: true,
+            tsconfigPath: "./tsconfig.paths.json"
+          };
+          await SandboxRenderer.renderDirectory(shellTemplateDir, shellDestDir, templateData);
+          await fs6.writeJson(path8.join(shellDestDir, "tsconfig.paths.json"), {
+            compilerOptions: { baseUrl: ".", paths: { "@/*": ["./src/*"] } }
+          }, { spaces: 2 });
+        }
+        return shellDestDir;
+      }
+      /** 注入项目虚拟上下文 */
+      static async injectContext(projectRoot, version) {
+        return SandboxContext.inject(projectRoot, version, this.CORE_PACKAGES, this.RUNTIME_DEPS);
+      }
+      /** 获取核心库的 Vite Alias 配置 */
+      static getCoreAlias(version) {
+        const versionPath = this.getVersionPath(version);
+        const sandboxNodeModules = path8.join(versionPath, "node_modules");
+        return Object.fromEntries(this.CORE_PACKAGES.map((pkg) => [pkg, path8.join(sandboxNodeModules, pkg)]));
+      }
+      /** 切换内核版本 */
+      static async useVersion(version) {
+        const versionRoot = this.getVersionRoot();
+        const currentLink = path8.join(versionRoot, SANDBOX_CONFIG.DIRS.CURRENT);
+        const targetPath = this.getVersionPath(version);
+        if (!fs6.existsSync(targetPath)) throw new Error(`\u7248\u672C ${version} \u4E0D\u5B58\u5728`);
+        if (fs6.existsSync(currentLink)) await fs6.remove(currentLink);
+        await fs6.ensureSymlink(targetPath, currentLink, "dir");
+      }
+      /** 解析版本号 */
+      static async resolveVersion(version) {
+        if (!version || version === "latest" || version === "current") {
+          const currentLink = path8.join(this.getVersionRoot(), SANDBOX_CONFIG.DIRS.CURRENT);
+          if (fs6.existsSync(currentLink)) {
+            return path8.basename(await fs6.readlink(currentLink));
+          }
+          const versions = await this.listVersions();
+          return versions[0] || "1.0.0";
+        }
+        return version;
+      }
+      /** 列出所有已安装版本 */
+      static async listVersions() {
+        const versionRoot = this.getVersionRoot();
+        if (!fs6.existsSync(versionRoot)) return [];
+        const dirs = await fs6.readdir(versionRoot);
+        return dirs.filter((d) => d !== SANDBOX_CONFIG.DIRS.CURRENT && !d.startsWith(".")).sort().reverse();
+      }
+      /** 可视化展示沙箱状态 */
+      static async visualizeStatus(cwd) {
+        const workspaceRoot = await this.getWorkspaceRoot(cwd);
+        const isMonorepo = workspaceRoot !== cwd;
+        const currentVersion = await this.resolveVersion("current");
+        const versions = await this.listVersions();
+        const statusInfo = [
+          `${pc3.bold("\u9879\u76EE\u8DEF\u5F84:")}   ${pc3.cyan(cwd)}`,
+          `${pc3.bold("\u67B6\u6784\u6A21\u5F0F:")}   ${isMonorepo ? pc3.yellow("Monorepo") : pc3.green("Standalone")}`,
+          `${pc3.bold("\u5F53\u524D\u5185\u6838:")}   ${pc3.green(currentVersion)}`,
+          `${pc3.bold("\u5DF2\u88C5\u7248\u672C:")}   ${pc3.gray(versions.join(", ") || "none")}`,
+          `${pc3.bold("\u6C99\u7BB1\u6839\u76EE\u5F55:")} ${pc3.gray(this.getRoot())}`
+        ].join("\n");
+        printBox(statusInfo, "ChatBI Sandbox Status");
+      }
+    };
+  }
+});
+
+// src/config.ts
+import fs7 from "fs-extra";
+import path9 from "path";
+import { createJiti } from "jiti";
+var ConfigManager;
+var init_config = __esm({
+  "src/config.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_utils();
+    init_constants();
+    init_utils();
+    ConfigManager = class {
+      static {
+        this.CONFIG_FILES = DEFAULT_CONFIG.CONFIG_FILES;
+      }
+      /**
+       * 加载项目配置
+       * @param cwd 项目根目录
+       */
+      static async loadConfig(cwd = process.cwd()) {
+        const config = {};
+        const versionFilePath = path9.join(cwd, SANDBOX_CONFIG.LOCK_FILE);
+        if (fs7.existsSync(versionFilePath)) {
+          try {
+            const version = (await fs7.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 = path9.join(cwd, file);
+          if (fs7.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 fs7.readJson(configPath);
+              }
+              return {
+                ...projectConfig,
+                ...config
+              };
+            } catch (e) {
+              logger.error(`\u8BFB\u53D6\u914D\u7F6E\u6587\u4EF6 ${file} \u5931\u8D25`, e);
+            }
+          }
+        }
+        return config;
+      }
+      /**
+       * 解析核心依赖的具体路径或版本号
+       * @param config 项目配置
+       * @param relativeTo 相对路径（用于 local 模式下的 file: 协议生成）
+       */
+      static async resolveCoreDependency(config, relativeTo = ".") {
+        const { coreSource = "local", coreVersion } = config;
+        if (coreSource === "npm") {
+          if (coreVersion) return coreVersion;
+          const cliRoot = await getCliRoot();
+          const cliPkg = await fs7.readJson(path9.join(cliRoot, "package.json"));
+          return cliPkg.version;
+        }
+        const sandboxCorePath = path9.join(SANDBOX_CONFIG.DIRS.CACHE, "core");
+        const cwd = process.cwd();
+        const absoluteRelativeTo = path9.isAbsolute(relativeTo) ? relativeTo : path9.resolve(cwd, relativeTo);
+        const absoluteProjectRoot = cwd;
+        const relativePath = path9.relative(absoluteRelativeTo, path9.join(absoluteProjectRoot, sandboxCorePath));
+        return `file:${relativePath}`;
+      }
+      /**
+       * 加载 tsup 配置
+       * @param cwd 项目根目录
+       */
+      static async loadTsupConfig(cwd = process.cwd()) {
+        const TSUP_CONFIG_FILES = [
+          "tsup.config.ts",
+          "tsup.config.js",
+          "tsup.config.cjs",
+          "tsup.config.mjs",
+          "tsup.config.json"
+        ];
+        const jiti = createJiti(cwd);
+        for (const file of TSUP_CONFIG_FILES) {
+          const configPath = path9.join(cwd, file);
+          if (fs7.existsSync(configPath)) {
+            try {
+              if (file.endsWith(".json")) {
+                return await fs7.readJson(configPath);
+              } else {
+                const mod = await jiti.import(configPath, { default: true });
+                return mod.default || mod || {};
+              }
+            } catch (e) {
+              logger.warn(`\u52A0\u8F7D tsup \u914D\u7F6E\u6587\u4EF6 ${file} \u5931\u8D25: ${e.message}`);
+            }
+          }
+        }
+        const pkgPath = path9.join(cwd, "package.json");
+        if (fs7.existsSync(pkgPath)) {
+          try {
+            const pkg = await fs7.readJson(pkgPath);
+            if (pkg.tsup) {
+              return pkg.tsup;
+            }
+          } catch (e) {
+          }
+        }
+        return {};
+      }
+    };
+  }
+});
+
+// src/corekit.ts
+import path10 from "path";
+import fs8 from "fs-extra";
+import pc4 from "picocolors";
+import prompts from "prompts";
+import fg3 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 = path10.join(cwd, "package.json");
+        if (!fs8.existsSync(pkgPath)) return "app";
+        const pkg = await fs8.readJson(pkgPath);
+        if (pkg.workspaces || fs8.existsSync(path10.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 fg3(["index.plugin.{ts,js}", "src/index.plugin.{ts,js}"], { cwd });
+        if (pluginEntries.length > 0) return "plugin";
+        if (fs8.existsSync(path10.join(cwd, "index.html"))) {
+          return "app";
+        }
+        if (fs8.existsSync(path10.join(cwd, "src/index.ts")) || fs8.existsSync(path10.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 = path10.join(cliRoot, ".chatbi-version");
+          if (fs8.existsSync(cliVersionFile)) {
+            const version = (await fs8.readFile(cliVersionFile, "utf-8")).trim();
+            if (version) return version;
+          }
+        } catch (e) {
+        }
+        const currentLinkPath = path10.join(Sandbox.getVersionRoot(), "current");
+        if (fs8.existsSync(currentLinkPath)) {
+          try {
+            const realPath = await fs8.realpath(currentLinkPath);
+            return path10.basename(realPath);
+          } catch (e) {
+          }
+        }
+        const versions = await this.listVersions();
+        return versions[0] || "latest";
+      }
+      /**
+       * 列出所有已安装版本
+       */
+      static async listVersions() {
+        const versionsDir = Sandbox.getVersionRoot();
+        if (!fs8.existsSync(versionsDir)) return [];
+        const dirs = await fg3("*", {
+          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 = path10.join(rootDir, "plugins");
+        if (!fs8.existsSync(pluginsDir)) return [];
+        const pkgFiles = await fg3("*/package.json", { cwd: pluginsDir, absolute: true });
+        const plugins = [];
+        for (const pkgPath of pkgFiles) {
+          try {
+            const pkg = await fs8.readJson(pkgPath);
+            const pluginPath = path10.dirname(pkgPath);
+            plugins.push({
+              name: pkg.name || path10.basename(pluginPath),
+              path: pluginPath,
+              id: path10.basename(pluginPath)
+            });
+          } catch (e) {
+          }
+        }
+        return plugins;
+      }
+      /**
+       * 启动开发环境 (统一入口)
+       */
+      static async startDev(cwd, options = {}) {
+        const mode = await this.detectMode(cwd);
+        const version = await this.resolveVersion(cwd);
+        printBox(
+          `${pc4.cyan(pc4.bold("\u{1F680} ChatBI Dev Server"))}
+
+${pc4.gray("Mode:   ")} ${pc4.yellow(mode)}
+${pc4.gray("Kernel: ")} ${pc4.green(version)}
+${pc4.gray("Root:   ")} ${pc4.white(cwd)}`,
+          "Dev Server"
+        );
+        const spinner = createSpinner("\u6B63\u5728\u51C6\u5907\u6C99\u7BB1\u73AF\u5883...").start();
+        try {
+          await Sandbox.prepare(version);
+          spinner.text = pc4.cyan("\u6B63\u5728\u6CE8\u5165\u865A\u62DF\u4E0A\u4E0B\u6587...");
+          await Sandbox.injectContext(cwd, version);
+          spinner.succeed(pc4.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(pc4.red(`\u542F\u52A8\u5931\u8D25: ${e.message}`));
+        }
+      }
+      /**
+       * 启动 Monorepo 开发服务器
+       */
+      static async startMonorepoDevServer(rootDir, version, customPort) {
+        const appsDir = path10.join(rootDir, "apps");
+        if (!fs8.existsSync(appsDir)) {
+          logger.warn("\u5F53\u524D Monorepo \u4E0B\u672A\u627E\u5230 apps/ \u76EE\u5F55");
+          return;
+        }
+        const pkgFiles = await fg3("*/package.json", { cwd: appsDir, absolute: true });
+        const apps = pkgFiles.map((pkgPath) => ({
+          name: path10.basename(path10.dirname(pkgPath)),
+          path: path10.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 = path10.join(versionPath, "node_modules");
+        const shellDir = await Sandbox.ensureShell(version);
+        const coreAlias = Sandbox.getCoreAlias(version);
+        const tailwindPath = path10.join(sandboxNodeModules, "tailwindcss");
+        const autoprefixerPath = path10.join(sandboxNodeModules, "autoprefixer");
+        let pluginEntry = path10.join(pluginDir, "src/index.tsx");
+        if (!fs8.existsSync(pluginEntry)) {
+          pluginEntry = path10.join(pluginDir, "src/index.ts");
+        }
+        const define = {
+          "process.env.CHATBI_PLUGIN_PATH": JSON.stringify(pluginDir)
+        };
+        const { createServer } = await import("vite");
+        try {
+          const server = await createServer({
+            root: shellDir,
+            configFile: false,
+            css: {
+              postcss: {
+                plugins: [
+                  __require(tailwindPath)({
+                    presets: [__require(path10.join(sandboxNodeModules, "@chatbi-v/tailwind-config"))],
+                    darkMode: "class",
+                    content: [
+                      path10.join(shellDir, "index.html"),
+                      path10.join(shellDir, "src/**/*.{ts,tsx}"),
+                      path10.join(pluginDir, "src/**/*.{ts,tsx}")
+                    ]
+                  }),
+                  __require(autoprefixerPath)
+                ]
+              }
+            },
+            server: {
+              port: shellPort,
+              host: true,
+              watch: {
+                // 关键：排除沙箱和软链目录，防止 Vite 挂起
+                ignored: [
+                  "**/.chatbi/**",
+                  "**/node_modules/**",
+                  Sandbox.getRoot()
+                ]
+              },
+              fs: {
+                allow: [
+                  sandboxRoot,
+                  pluginDir,
+                  path10.resolve(pluginDir, "../../")
+                ]
+              }
+            },
+            resolve: {
+              alias: {
+                ...coreAlias,
+                "react": path10.join(sandboxNodeModules, "react"),
+                "react-dom": path10.join(sandboxNodeModules, "react-dom"),
+                "@": path10.join(shellDir, "src"),
+                // 关键：将虚拟模块指向用户插件
+                "virtual:user-plugin": pluginEntry,
+                // 防止 glob 报错，提供空的映射
+                "@chatbi-plugins": path10.join(shellDir, "empty"),
+                "@chatbi-apps": path10.join(shellDir, "empty")
+              }
+            },
+            define
+          });
+          await server.listen();
+          const localUrl = `http://localhost:${shellPort}/`;
+          printBox(
+            `${pc4.green(pc4.bold("\u2705 \u6258\u7BA1\u5F0F Shell \u5DF2\u542F\u52A8"))}
+
+${pc4.white("Local: ")} ${pc4.cyan(pc4.underline(localUrl))}`,
+            "Shell Success"
+          );
+        } catch (e) {
+          logger.error("Shell \u670D\u52A1\u5668\u542F\u52A8\u5931\u8D25", e);
+        }
+      }
+      /**
+       * 启动应用开发服务器 (Integrated Mode)
+       */
+      static async startAppDevServer(appDir, version, customPort) {
+        logger.info("\u6B63\u5728\u542F\u52A8\u5E94\u7528...");
+        const versionPath = Sandbox.getVersionPath(version);
+        const sandboxNodeModules = path10.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": path10.join(sandboxNodeModules, "react"),
+                "react-dom": path10.join(sandboxNodeModules, "react-dom"),
+                "@vitejs/plugin-react": path10.join(sandboxNodeModules, "@vitejs/plugin-react")
+              }
+            },
+            server: {
+              port: customPort || 3e3,
+              host: true,
+              watch: {
+                // 关键：排除沙箱和软链目录，防止 Vite 挂起
+                ignored: [
+                  "**/.chatbi/**",
+                  "**/node_modules/**",
+                  Sandbox.getRoot()
+                ]
+              },
+              fs: {
+                allow: [
+                  Sandbox.getRoot(),
+                  appDir,
+                  // 允许访问沙箱中的所有依赖
+                  sandboxNodeModules
+                ]
+              }
+            }
+          });
+          await server.listen();
+          const localUrl = `http://localhost:${server.config.server.port}/`;
+          printBox(
+            `${pc4.green(pc4.bold("\u2705 \u5E94\u7528\u5DF2\u6210\u529F\u542F\u52A8"))}
+
+${pc4.white("Local: ")} ${pc4.cyan(pc4.underline(localUrl))}`,
+            "App Success"
+          );
+        } catch (e) {
+          logger.error("\u5E94\u7528\u542F\u52A8\u5931\u8D25", e);
+        }
+      }
+    };
+  }
+});
+
+// src/commands/build.ts
+var build_exports = {};
+__export(build_exports, {
+  build: () => build
+});
+import { execa as execa2 } from "execa";
+import fs9 from "fs-extra";
+import path11 from "path";
+import pc5 from "picocolors";
+import { build as tsupBuild } from "tsup";
+async function build(options) {
+  const cwd = process.cwd();
+  const pkgPath = path11.join(cwd, "package.json");
+  if (!fs9.existsSync(pkgPath)) {
+    logger.error(`\u5728 ${cwd} \u4E2D\u672A\u627E\u5230 package.json`);
+    return;
+  }
+  const pkg = await fs9.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: ${pc5.bold(pkg.name || "unnamed")} (\u5185\u6838\u7248\u672C: ${version})
+`);
+  const spinner = createSpinner("\u6B63\u5728\u51C6\u5907\u6784\u5EFA\u73AF\u5883...").start();
+  spinner.text = "\u6B63\u5728\u540C\u6B65\u6C99\u7BB1\u5185\u6838...";
+  await Sandbox.prepare(version, options.force);
+  if (pkg.workspaces || fs9.existsSync(path11.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 = path11.join(cwd, dir);
+      if (fs9.existsSync(dirPath)) {
+        const entries = await fs9.readdir(dirPath, { withFileTypes: true });
+        for (const entry2 of entries) {
+          if (entry2.isDirectory()) {
+            const subPkgPath = path11.join(dirPath, entry2.name);
+            if (fs9.existsSync(path11.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: ${pc5.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: fs9.existsSync(path11.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
+          ]
+        }
+      }
     });
-}, '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
+    if (!options.watch) {
+      printBox(
+        pc5.green(pc5.bold("\u2728 \u5E94\u7528\u6784\u5EFA\u6210\u529F!")) + "\n\n" + pc5.white("\u4EA7\u7269\u76EE\u5F55: ") + pc5.cyan("dist"),
+        "Build Success"
+      );
+    }
+    return;
+  }
+  let entry = ["src/index.ts"];
+  if (fs9.existsSync(path11.join(cwd, "src/index.tsx"))) {
+    entry = ["src/index.tsx"];
+  } else if (!fs9.existsSync(path11.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";
+  const userConfig = await ConfigManager.loadTsupConfig(cwd);
+  if (Object.keys(userConfig).length > 0) {
+    logger.info(`\u5DF2\u52A0\u8F7D\u672C\u5730\u6784\u5EFA\u914D\u7F6E`);
+  }
+  if (!options.watch) {
+    await fs9.remove(path11.join(cwd, "dist"));
+    const tsbuildinfo = path11.join(cwd, "tsconfig.tsbuildinfo");
+    if (fs9.existsSync(tsbuildinfo)) {
+      await fs9.remove(tsbuildinfo);
+    }
+  }
+  if (isPlugin) {
+  }
+  const commonConfig = {
+    entry,
+    dts: false,
+    clean: false,
+    sourcemap: false,
+    target: "esnext",
+    platform: isPlugin ? "browser" : "node",
+    ...userConfig,
+    // 合并用户配置
+    external: [
+      .../* @__PURE__ */ new Set([
+        "react",
+        "react-dom",
+        "react/jsx-runtime",
+        "react-is",
+        "antd",
+        "@ant-design/icons",
+        "@ant-design/x",
+        ...Object.keys(pkg.dependencies || {}),
+        ...Object.keys(pkg.peerDependencies || {}),
+        ...isPlugin ? Sandbox.CORE_PACKAGES : [],
+        ...Array.isArray(userConfig.external) ? userConfig.external : []
+      ])
+    ],
+    minify: userConfig.minify !== void 0 ? userConfig.minify : !options.watch,
+    // 优先使用用户配置
+    watch: options.watch,
+    silent: true,
+    esbuildOptions(esbuildOpts) {
+      esbuildOpts.logOverride = {
+        "empty-import-meta": "silent"
+      };
+      esbuildOpts.external = esbuildOpts.external || [];
+      const forceExternal = [
+        "react",
+        "react-dom",
+        "antd",
+        "@ant-design/icons",
+        "@ant-design/x",
+        ...Sandbox.CORE_PACKAGES
+      ];
+      forceExternal.forEach((dep) => {
+        if (!esbuildOpts.external.includes(dep)) {
+          esbuildOpts.external.push(dep);
+        }
+      });
+      if (typeof userConfig.esbuildOptions === "function") {
+        userConfig.esbuildOptions(esbuildOpts);
+      }
+    }
+  };
+  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: commonConfig.esbuildOptions
+    });
+  } 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 = path11.join(cwd, "node_modules/.bin/tsc");
+      const sandboxTsc = path11.join(Sandbox.getVersionPath(version), "node_modules/.bin/tsc");
+      let tscBin = "tsc";
+      if (fs9.existsSync(localTsc)) {
+        tscBin = localTsc;
+      } else if (fs9.existsSync(sandboxTsc)) {
+        tscBin = sandboxTsc;
+      } else {
+        if (fs9.existsSync(path11.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(
+      pc5.green(pc5.bold("\u2728 \u6784\u5EFA\u5B8C\u6210!")) + "\n\n" + pc5.white("\u4EA7\u7269\u76EE\u5F55: ") + pc5.cyan("dist") + "\n" + pc5.white("\u6784\u5EFA\u6A21\u5F0F: ") + pc5.cyan(isPlugin ? "Plugin" : "Library"),
+      "Build Success"
+    );
+  }
+}
+var init_build = __esm({
+  "src/commands/build.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_sandbox();
+    init_corekit();
+    init_config();
+    init_utils();
+  }
+});
+
+// src/commands/sync.ts
+var sync_exports = {};
+__export(sync_exports, {
+  sync: () => sync
+});
+import fs10 from "fs-extra";
+import path12 from "path";
+import pc6 from "picocolors";
+async function sync(options = {}) {
+  const cwd = options.cwd || process.cwd();
+  const pkgPath = path12.join(cwd, "package.json");
+  if (!fs10.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 fs10.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 = path12.join(cwd, ".chatbi-version");
+    await fs10.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 fs10.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(
+      `${pc6.green(pc6.bold("\u2728 \u5185\u6838\u540C\u6B65\u6210\u529F!"))}
+
+${pc6.white("\u5F53\u524D\u7248\u672C: ")} ${pc6.cyan(version)}
+${pc6.white("\u6C99\u7BB1\u8DEF\u5F84: ")} ${pc6.gray(Sandbox.getVersionPath(version))}
+
+${pc6.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 fs11 from "fs-extra";
+import path13 from "path";
+import pc7 from "picocolors";
+import prompts2 from "prompts";
+async function init(options) {
+  let { name, pluginType = "business", theme = DEFAULT_CONFIG.THEME, projectType, includeApp, includePlugin, cwd } = 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 = cwd || process.cwd();
+  const targetDir = path13.resolve(rootDir, name);
+  if (fs11.existsSync(targetDir)) {
+    logger.error(`\u76EE\u5F55 ${name} \u5DF2\u5B58\u5728\u3002`);
+    return;
+  }
+  logger.info(`\u6B63\u5728\u521D\u59CB\u5316\u9879\u76EE: ${pc7.bold(name)}...`);
+  logger.info(pc7.gray(`\u7C7B\u578B: ${projectType} | \u4E3B\u9898: ${theme || "N/A"}`));
+  console.log("");
+  try {
+    const myCliRoot = await getCliRoot();
+    const cliPkg = await fs11.readJson(path13.join(myCliRoot, "package.json"));
+    const cliVersion = cliPkg.version;
+    const config = { coreSource: "npm" };
+    const kernelVersionFile = path13.join(myCliRoot, SANDBOX_CONFIG.LOCK_FILE);
+    if (fs11.existsSync(kernelVersionFile)) {
+      config.coreVersion = (await fs11.readFile(kernelVersionFile, "utf-8")).trim();
+    }
+    const kernelVersion = await ConfigManager.resolveCoreDependency(config);
+    const renderTemplate = async (templateName, destDir, extraData = {}) => {
+      const srcDir = path13.join(myCliRoot, "templates", templateName);
+      if (!fs11.existsSync(srcDir)) {
+        throw new Error(`\u627E\u4E0D\u5230\u6A21\u677F: ${templateName}\uFF0C\u8BF7\u68C0\u67E5\u8DEF\u5F84 ${srcDir} \u662F\u5426\u6B63\u786E\u3002`);
+      }
+      await fs11.ensureDir(destDir);
+      const templateData = {
+        name: path13.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" ? `../../${SANDBOX_CONFIG.DIRS.CACHE}/tsconfig.json` : `./${SANDBOX_CONFIG.DIRS.CACHE}/tsconfig.json`,
+        ...extraData
+      };
+      await SandboxRenderer.renderDirectory(srcDir, destDir, templateData);
+    };
+    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 = path13.join(targetDir, "apps", "main");
+        await renderTemplate("app", appDir, { name: "@chatbi-v/main" });
+      }
+      if (isPluginIncluded) {
+        spinner.text = "\u6B63\u5728\u751F\u6210 Demo Plugin...";
+        const pluginDir = path13.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 fs11.writeJson(path13.join(targetDir, "chatbi.config.json"), cliConfig, { spaces: 2 });
+    configSpinner.succeed("\u9879\u76EE\u914D\u7F6E\u751F\u6210\u5B8C\u6210");
+    printBox(
+      `${pc7.green(pc7.bold("\u2728 \u9879\u76EE\u5DF2\u6210\u529F\u521B\u5EFA!"))}
+
+${pc7.white("\u63A5\u4E0B\u6765\u4F60\u53EF\u4EE5:")}
+${pc7.cyan(`  cd ${name}`)}
+${pc7.cyan("  pnpm install")}
+${pc7.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();
+    init_constants();
+    init_config();
+    init_SandboxRenderer();
+  }
+});
+
+// src/commands/fetch.ts
+var fetch_exports = {};
+__export(fetch_exports, {
+  fetch: () => fetch
+});
+import path18 from "path";
+import pc13 from "picocolors";
+import { execa as execa4 } from "execa";
+async function fetch(version, options = {}) {
+  const fetchSpinner = createSpinner(`\u6B63\u5728\u83B7\u53D6\u5185\u6838\u7248\u672C ${pc13.cyan(version)}...`).start();
+  const versionPath = await Sandbox.prepare(version, true);
+  fetchSpinner.succeed(`\u5185\u6838\u7248\u672C ${pc13.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 = path18.resolve(process.cwd(), tgzName);
+    await execa4("tar", [
+      "-czf",
+      tgzPath,
+      "-C",
+      path18.dirname(versionPath),
+      path18.basename(versionPath)
+    ]);
+    packSpinner.succeed("\u79BB\u7EBF\u8D44\u6E90\u6253\u5305\u5B8C\u6210");
+    printBox(
+      `${pc13.green(pc13.bold("\u2728 \u79BB\u7EBF\u5305\u5DF2\u751F\u6210!"))}
+
+${pc13.white("\u6587\u4EF6\u8DEF\u5F84: ")} ${pc13.cyan(tgzPath)}
+${pc13.white("\u5B89\u88C5\u547D\u4EE4: ")} ${pc13.gray(`chatbi install ${tgzName}`)}`,
+      "Pack Success"
+    );
+  } else {
+    logger.success(`\u5185\u6838\u7248\u672C ${pc13.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 pc15 from "picocolors";
+import fs17 from "fs-extra";
+import path20 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 = path20.join(os2.tmpdir(), `chatbi-bench-${Date.now()}`);
+  await fs17.ensureDir(tmpDir);
+  try {
+    const initSpinner = createSpinner("\u6B63\u5728\u6D4B\u8BD5: \u521D\u59CB\u5316\u63D2\u4EF6\u9879\u76EE (init)...").start();
+    const startInit = Date.now();
+    const { init: init2 } = await Promise.resolve().then(() => (init_init(), init_exports));
+    const testProjDir = path20.join(tmpDir, "bench-proj");
+    await init2({ name: "bench-proj", projectType: "plugin", cwd: tmpDir });
+    const endInit = Date.now();
+    const initTime = (endInit - startInit) / 1e3;
+    initSpinner.succeed(`\u521D\u59CB\u5316\u5B8C\u6210: ${pc15.cyan(initTime.toFixed(2) + "s")}`);
+    results.push({
+      scene: "\u521D\u59CB\u5316\u63D2\u4EF6\u9879\u76EE (init)",
+      target: "\u2264 5.0 s",
+      actual: `${initTime.toFixed(2)} s`
+    });
+    const syncSpinner = createSpinner("\u6B63\u5728\u6D4B\u8BD5: \u6C99\u7BB1\u73AF\u5883\u540C\u6B65 (sync)...").start();
+    const startSync = Date.now();
+    const { sync: sync2 } = await Promise.resolve().then(() => (init_sync(), sync_exports));
+    await sync2({ cwd: testProjDir });
+    const endSync = Date.now();
+    const syncTime = (endSync - startSync) / 1e3;
+    syncSpinner.succeed(`\u540C\u6B65\u5B8C\u6210: ${pc15.cyan(syncTime.toFixed(2) + "s")}`);
+    results.push({
+      scene: "\u6C99\u7BB1\u73AF\u5883\u540C\u6B65 (sync)",
+      target: "\u2264 2.0 s",
+      actual: `${syncTime.toFixed(2)} s`
+    });
+    const buildSpinner = createSpinner("\u6B63\u5728\u6D4B\u8BD5: \u63D2\u4EF6\u9879\u76EE\u6784\u5EFA (build)...").start();
+    const startBuild = Date.now();
+    const { build: build2 } = await Promise.resolve().then(() => (init_build(), build_exports));
+    const originalCwd = process.cwd();
+    process.chdir(testProjDir);
+    await build2({ watch: false });
+    process.chdir(originalCwd);
+    const endBuild = Date.now();
+    const buildTime = (endBuild - startBuild) / 1e3;
+    buildSpinner.succeed(`\u6784\u5EFA\u5B8C\u6210: ${pc15.cyan(buildTime.toFixed(2) + "s")}`);
+    results.push({
+      scene: "\u63D2\u4EF6\u9879\u76EE\u6784\u5EFA (build)",
+      target: "\u2264 10.0 s",
+      actual: `${buildTime.toFixed(2)} s`
+    });
+    printBox(
+      `${pc15.green(pc15.bold("\u2728 \u57FA\u51C6\u6D4B\u8BD5\u5B8C\u6210!"))}
+
+` + results.map((r) => `${pc15.white(r.scene.padEnd(20))}: ${pc15.cyan(r.actual)} (\u76EE\u6807 ${r.target})`).join("\n"),
+      "Benchmark Results"
+    );
+  } finally {
+    await fs17.remove(tmpDir);
+  }
+}
+var init_bench = __esm({
+  "src/commands/bench.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_utils();
+  }
+});
+
+// src/index.ts
+init_esm_shims();
+init_build();
+import cac from "cac";
+import pc16 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();
+init_constants();
+init_SandboxRenderer();
+import fs12 from "fs-extra";
+import path14 from "path";
+import pc8 from "picocolors";
+import prompts3 from "prompts";
+async function add(options) {
+  let { name, type, displayName, description } = options;
+  const cwd = process.cwd();
+  const pkgPath = path14.join(cwd, "package.json");
+  if (!fs12.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 fs12.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 = path14.resolve(cwd, "plugins", folderName);
+  if (fs12.existsSync(pluginDir)) {
+    logger.error(`\u63D2\u4EF6\u76EE\u5F55 ${folderName} \u5DF2\u5B58\u5728\u3002`);
+    return;
+  }
+  const spinner = createSpinner(`\u6B63\u5728\u6DFB\u52A0\u65B0\u63D2\u4EF6: ${pc8.bold(name)}...`).start();
+  const myCliRoot = await getCliRoot();
+  const templateDir = path14.join(myCliRoot, "templates/plugin");
+  if (!fs12.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 corePath = await ConfigManager.resolveCoreDependency(config, pluginDir);
+  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: `../../${SANDBOX_CONFIG.DIRS.CACHE}/tsconfig.json`
+  };
+  spinner.text = "\u6B63\u5728\u751F\u6210\u63D2\u4EF6\u6587\u4EF6...";
+  await SandboxRenderer.renderDirectory(templateDir, targetDir, data);
+  spinner.succeed(`\u63D2\u4EF6 ${pc8.bold(name)} \u6DFB\u52A0\u6210\u529F\uFF01`);
+  printBox(
+    `${pc8.green(pc8.bold("\u2728 \u63D2\u4EF6\u521B\u5EFA\u6210\u529F!"))}
+
+${pc8.white("\u9879\u76EE\u8DEF\u5F84: ")} ${pc8.cyan(`plugins/${folderName}`)}
+${pc8.white("\u63D2\u4EF6 ID:   ")} ${pc8.cyan(cleanName)}
+${pc8.white("\u63D2\u4EF6\u7C7B\u578B: ")} ${pc8.cyan(type)}
+
+${pc8.white("\u63A5\u4E0B\u6765\u4F60\u53EF\u4EE5:")}
+${pc8.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 fs13 from "fs-extra";
+import path15 from "path";
+import pc9 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 = path15.join(cwd, "package.json");
+  if (!fs13.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: ${pc9.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(pc9.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(pc9.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 fs14 from "fs-extra";
+import path16 from "path";
+import pc10 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(pc10.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(pc10.bold("\nStep 2: \u68C0\u67E5\u5185\u6838\u6C99\u7BB1\u73AF\u5883..."));
+  const version = await CoreKit.resolveVersion(cwd);
+  const versionPath = Sandbox.getVersionPath(version);
+  if (!fs14.existsSync(versionPath)) {
+    logger.error(`\u5185\u6838\u6C99\u7BB1\u7248\u672C ${version} \u5C1A\u672A\u5B89\u88C5`);
+    console.log(pc10.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 = path16.join(versionPath, "node_modules");
+    if (!fs14.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 (!fs14.existsSync(path16.join(sandboxNm, dep))) {
+        missingDeps.push(dep);
+      }
+    }
+    if (missingDeps.length > 0) {
+    }
+  }
+  logger.info(pc10.bold("\nStep 3: \u68C0\u67E5\u865A\u62DF\u4F9D\u8D56\u6620\u5C04..."));
+  const chatbiDir = path16.join(cwd, ".chatbi");
+  if (!fs14.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 = path16.join(chatbiDir, "tsconfig.paths.json");
+    const aliasJson = path16.join(chatbiDir, "vite.alias.json");
+    if (!fs14.existsSync(pathsJson) || !fs14.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 = path16.join(cwd, "tsconfig.json");
+  if (fs14.existsSync(tsConfigPath)) {
+    try {
+      const tsConfig = await fs14.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 = path16.join(cwd, "vite.config.ts");
+  if (fs14.existsSync(viteConfigPath)) {
+    const content = await fs14.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(pc10.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 fs14.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 = path16.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(
+      pc10.green(pc10.bold("\u2728 \u8BCA\u65AD\u5B8C\u6210\uFF1A\u9879\u76EE\u4E00\u5207\u6B63\u5E38\uFF01")),
+      "Doctor Report"
+    );
+  } else {
+    const issueList = issues.map((i) => pc10.red(`\u2022 ${i}`)).join("\n");
+    printBox(
+      `${pc10.yellow(pc10.bold("\u26A0\uFE0F \u8BCA\u65AD\u5B8C\u6210\uFF1A\u53D1\u73B0\u4EE5\u4E0B\u95EE\u9898"))}
+
+${issueList}
+
+${pc10.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 fs14.readFile(issue.file, "utf-8");
+          const newContent = issue.rule.fix(content);
+          await fs14.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 pc11 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(pc11.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 ${pc11.cyan(plugins.length)} \u4E2A\u63D2\u4EF6`);
+    const pluginList = plugins.map((p) => `- ${pc11.bold(p.name)} ${pc11.gray(`(${p.id})`)}
+  ${pc11.gray(p.path)}`).join("\n\n");
+    printBox(
+      `${pc11.green(pc11.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 pc12 from "picocolors";
+async function ls() {
+  const versions = await CoreKit.listVersions();
+  const currentVersion = await CoreKit.resolveVersion(process.cwd());
+  const globalCurrentVersion = await CoreKit.resolveVersion();
+  logger.info("\u5DF2\u5B89\u88C5\u7684\u5185\u6838\u6C99\u7BB1\u7248\u672C:");
+  if (versions.length === 0) {
+    logger.warn("\u5C1A\u672A\u5B89\u88C5\u4EFB\u4F55\u7248\u672C\uFF0C\u8BF7\u8FD0\u884C chatbi sync \u8FDB\u884C\u5B89\u88C5\u3002");
+  } else {
+    const list = versions.map((v) => {
+      const isGlobalCurrent = v === globalCurrentVersion;
+      const isProjectCurrent = v === currentVersion;
+      let prefix = "  ";
+      if (isProjectCurrent) {
+        prefix = pc12.green(" *");
+      } else if (isGlobalCurrent) {
+        prefix = pc12.blue(" >");
+      }
+      let suffix = "";
+      if (isProjectCurrent && isGlobalCurrent) {
+        suffix = pc12.gray(" (\u5F53\u524D\u9879\u76EE & \u5168\u5C40)");
+      } else if (isProjectCurrent) {
+        suffix = pc12.gray(" (\u5F53\u524D\u9879\u76EE)");
+      } else if (isGlobalCurrent) {
+        suffix = pc12.gray(" (\u5168\u5C40)");
+      }
+      return `${prefix} ${pc12.white(v)}${suffix}`;
+    }).join("\n");
+    printBox(
+      list + pc12.gray("\n\n\u63D0\u793A: * \u5F53\u524D\u9879\u76EE\u4F7F\u7528, > \u5168\u5C40\u9ED8\u8BA4\u4F7F\u7528"),
+      "Kernel Versions"
+    );
+  }
+  await Sandbox.visualizeStatus(process.cwd());
+}
+
+// src/commands/use.ts
+init_esm_shims();
+init_sandbox();
+init_corekit();
+init_sync();
+init_utils();
+import fs15 from "fs-extra";
+import path17 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 = path17.join(cwd, ".chatbi-version");
+    await fs15.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 fs16 from "fs-extra";
+import path19 from "path";
+import pc14 from "picocolors";
+import { execa as execa5 } from "execa";
+async function install(target) {
+  if (target.endsWith(".tgz") && fs16.existsSync(target)) {
+    const spinner = createSpinner(`\u6B63\u5728\u5B89\u88C5\u672C\u5730\u79BB\u7EBF\u5305: ${pc14.bold(target)}...`).start();
+    try {
+      const tgzPath = path19.resolve(target);
+      const match = path19.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 fs16.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(
+        pc14.green(pc14.bold("\u2728 \u672C\u5730\u5185\u6838\u5B89\u88C5\u6210\u529F!")) + "\n\n" + pc14.white("\u7248\u672C: ") + pc14.cyan(version) + "\n" + pc14.white("\u8DEF\u5F84: ") + pc14.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);
+  }
+}
+
+// src/commands/clean.ts
+init_esm_shims();
+init_sandbox();
+async function clean(options) {
+  const cwd = process.cwd();
+  await Sandbox.clean(cwd, options.deep);
+}
+
+// package.json
+var package_default = {
+  name: "@chatbi-v/cli",
+  version: "2.0.5",
+  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(pc16.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("clean", "\u6E05\u7406 CLI \u4EA7\u751F\u7684\u7F13\u5B58\u76EE\u5F55").alias("cl").option("--deep", "\u6DF1\u5EA6\u6E05\u7406 (\u5305\u542B\u6240\u6709\u5B50\u5305\u7684 .chatbi \u76EE\u5F55\u53CA\u5168\u5C40\u6C99\u7BB1\u6839\u76EE\u5F55)").action(wrapAction(clean, "clean"));
+cli.command("bench", "\u8FD0\u884C CLI \u6027\u80FD\u57FA\u51C6\u6D4B\u8BD5").action(wrapAction(async () => {
+  const { bench: bench2 } = await Promise.resolve().then(() => (init_bench(), bench_exports));
+  await bench2();
+}, "bench"));
+cli.help((sections) => {
+  showHeader();
+  sections[0].body = pc16.white("ChatBI-V \u5F00\u53D1\u8005\u547D\u4EE4\u884C\u5DE5\u5177\uFF0C\u52A9\u529B\u5FEB\u901F\u5F00\u53D1\u548C\u6784\u5EFA\u63D2\u4EF6\u3002");
 });
-cli.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();
 }