@chatbi-v/cli 2.1.6 → 2.1.8

package/dist/index.js

@@ -8,31 +8,94 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// ../../../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
+// ../../node_modules/.pnpm/tsup@8.5.1_jiti@2.6.1_postcss@8.5.6_tsx@4.21.0_typescript@5.9.3_yaml@2.8.2/node_modules/tsup/assets/esm_shims.js
 import path from "path";
 import { fileURLToPath } from "url";
 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"() {
+  "../../node_modules/.pnpm/tsup@8.5.1_jiti@2.6.1_postcss@8.5.6_tsx@4.21.0_typescript@5.9.3_yaml@2.8.2/node_modules/tsup/assets/esm_shims.js"() {
     "use strict";
   }
 });
 
-// src/utils.ts
+// src/constants.ts
+import os from "os";
 import path2 from "path";
-import { createRequire } from "module";
-import { fileURLToPath as fileURLToPath2 } from "url";
+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: path2.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/utils.ts
+import boxen from "boxen";
+import { execa } from "execa";
 import fs from "fs-extra";
-import pc from "picocolors";
+import { createRequire } from "module";
+import os2 from "os";
 import ora from "ora";
-import boxen from "boxen";
-var _require, _filename, _dirname, logger, createSpinner, printBox, findPackageRoot, getCliRoot;
+import path3 from "path";
+import pc from "picocolors";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var _require, _filename, _dirname, UPDATE_CHECK_INTERVAL, CACHE_DIR, CACHE_FILE, logger, createSpinner, printBox, findPackageRoot, getCliRoot, checkForUpdates, printUpdateNotification;
 var init_utils = __esm({
   "src/utils.ts"() {
     "use strict";
     init_esm_shims();
     _require = createRequire(import.meta.url);
     _filename = fileURLToPath2(import.meta.url);
-    _dirname = path2.dirname(_filename);
+    _dirname = path3.dirname(_filename);
+    UPDATE_CHECK_INTERVAL = 1e3 * 60 * 60 * 24;
+    CACHE_DIR = path3.join(os2.homedir(), ".chatbi-v-core");
+    CACHE_FILE = path3.join(CACHE_DIR, ".update-check.json");
     logger = {
       info: (msg) => console.log(pc.cyan(`\u2139 ${msg}`)),
       success: (msg) => console.log(pc.green(`\u2714 ${msg}`)),
@@ -72,10 +135,10 @@ var init_utils = __esm({
     findPackageRoot = (pkgName) => {
       try {
         const pkgPath = _require.resolve(`${pkgName}/package.json`);
-        return path2.dirname(pkgPath);
+        return path3.dirname(pkgPath);
       } catch (e) {
         if (pkgName === "@chatbi-v/cli") {
-          return path2.resolve(_dirname, "../../");
+          return path3.resolve(_dirname, "../../");
         }
         throw new Error(`Package ${pkgName} not found`);
       }
@@ -83,147 +146,179 @@ var init_utils = __esm({
     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"));
+      while (checkDir !== path3.parse(checkDir).root) {
+        if (fs.existsSync(path3.join(checkDir, "package.json"))) {
+          const pkg = await fs.readJson(path3.join(checkDir, "package.json"));
           if (pkg.name === "@chatbi-v/cli") {
             myCliRoot = checkDir;
             break;
           }
         }
-        checkDir = path2.dirname(checkDir);
+        checkDir = path3.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"
+    checkForUpdates = async (currentVersion) => {
+      try {
+        await fs.ensureDir(CACHE_DIR);
+        let cache = { lastCheck: 0, latestVersion: currentVersion };
+        if (fs.existsSync(CACHE_FILE)) {
+          cache = await fs.readJson(CACHE_FILE);
+        }
+        const now = Date.now();
+        if (now - cache.lastCheck > UPDATE_CHECK_INTERVAL) {
+          execa("npm", ["view", "@chatbi-v/cli", "version"]).then(async ({ stdout }) => {
+            const latest = stdout.trim();
+            await fs.writeJson(CACHE_FILE, {
+              lastCheck: now,
+              latestVersion: latest
+            });
+          }).catch(() => {
+          });
+        }
+        if (cache.latestVersion && cache.latestVersion !== currentVersion) {
+          const isNewer = cache.latestVersion.localeCompare(currentVersion, void 0, { numeric: true }) > 0;
+          if (isNewer) {
+            return cache.latestVersion;
+          }
+        }
+      } catch (e) {
+      }
+      return null;
     };
-    DEFAULT_CONFIG = {
-      /** 支持的配置文件名 */
-      CONFIG_FILES: [
-        "chatbi.config.ts",
-        "chatbi.config.js",
-        "chatbi.config.json",
-        ".chatbirc"
-      ],
-      /** 默认 UI 主题 */
-      THEME: "standard"
+    printUpdateNotification = (current, latest) => {
+      const message = `\u66F4\u65B0\u53EF\u7528 ${pc.gray(current)} \u2192 ${pc.green(latest)}
+\u8FD0\u884C ${pc.cyan("npm install -g @chatbi-v/cli")} \u5373\u53EF\u66F4\u65B0`;
+      console.log(
+        boxen(message, {
+          padding: 1,
+          margin: { top: 1, bottom: 1 },
+          align: "center",
+          borderColor: "yellow",
+          borderStyle: "round"
+        })
+      );
     };
   }
 });
 
-// src/sandbox/SandboxPath.ts
-import path4 from "path";
+// src/config.ts
 import fs2 from "fs-extra";
-var SandboxPath;
-var init_SandboxPath = __esm({
-  "src/sandbox/SandboxPath.ts"() {
+import { createJiti } from "jiti";
+import path4 from "path";
+var ConfigManager;
+var init_config = __esm({
+  "src/config.ts"() {
     "use strict";
     init_esm_shims();
     init_constants();
-    SandboxPath = class {
+    init_utils();
+    init_utils();
+    ConfigManager = class {
       static {
-        /**
-         * 沙箱的基础存储目录，通常位于用户主目录下的 .chatbi-v-core
-         */
-        this.BASE_DIR = GLOBAL_PATHS.BASE_DIR;
-      }
-      /**
-       * 获取沙箱根目录
-       * @returns 沙箱根目录的绝对路径
-       */
-      static getRoot() {
-        return this.BASE_DIR;
+        this.CONFIG_FILES = DEFAULT_CONFIG.CONFIG_FILES;
       }
       /**
-       * 获取存储所有版本的根目录
-       * @returns versions 目录的绝对路径
+       * 加载项目配置
+       * @param cwd 项目根目录
        */
-      static getVersionRoot() {
-        return path4.join(this.BASE_DIR, SANDBOX_CONFIG.DIRS.VERSIONS);
+      static async loadConfig(cwd = process.cwd()) {
+        const config = {};
+        const versionFilePath = path4.join(cwd, SANDBOX_CONFIG.LOCK_FILE);
+        if (fs2.existsSync(versionFilePath)) {
+          try {
+            const version = (await fs2.readFile(versionFilePath, "utf-8")).trim();
+            if (version) {
+              config.coreVersion = version;
+            }
+          } catch (e) {
+          }
+        }
+        const jiti = createJiti(cwd);
+        for (const file of this.CONFIG_FILES) {
+          const configPath = path4.join(cwd, file);
+          if (fs2.existsSync(configPath)) {
+            try {
+              let projectConfig = {};
+              if (file.endsWith(".ts") || file.endsWith(".js")) {
+                const mod = await jiti.import(configPath, { default: true });
+                projectConfig = mod.default || mod || {};
+              } else if (file.endsWith(".json") || file.startsWith(".chatbirc")) {
+                projectConfig = await fs2.readJson(configPath);
+              }
+              return {
+                ...projectConfig,
+                ...config
+              };
+            } catch (e) {
+              logger.error(`\u8BFB\u53D6\u914D\u7F6E\u6587\u4EF6 ${file} \u5931\u8D25`, e);
+            }
+          }
+        }
+        return config;
       }
       /**
-       * 获取指定版本的沙箱路径
-       * @param version 版本号，或者 'current' 表示当前激活版本
-       * @returns 对应版本的绝对路径
+       * 解析核心依赖的具体路径或版本号
+       * @param config 项目配置
+       * @param relativeTo 相对路径（用于 local 模式下的 file: 协议生成）
        */
-      static getVersionPath(version) {
-        if (version === SANDBOX_CONFIG.DIRS.CURRENT) {
-          return path4.join(this.BASE_DIR, SANDBOX_CONFIG.DIRS.VERSIONS, SANDBOX_CONFIG.DIRS.CURRENT);
+      static async resolveCoreDependency(config, relativeTo = ".") {
+        const { coreSource = "local", coreVersion } = config;
+        if (coreSource === "npm") {
+          if (coreVersion) return coreVersion;
+          const cliRoot = await getCliRoot();
+          const cliPkg = await fs2.readJson(path4.join(cliRoot, "package.json"));
+          return cliPkg.version;
         }
-        return path4.join(this.BASE_DIR, SANDBOX_CONFIG.DIRS.VERSIONS, version);
+        const sandboxCorePath = path4.join(SANDBOX_CONFIG.DIRS.CACHE, "core");
+        const cwd = process.cwd();
+        const absoluteRelativeTo = path4.isAbsolute(relativeTo) ? relativeTo : path4.resolve(cwd, relativeTo);
+        const absoluteProjectRoot = cwd;
+        const relativePath = path4.relative(absoluteRelativeTo, path4.join(absoluteProjectRoot, sandboxCorePath));
+        return `file:${relativePath}`;
       }
       /**
-       * 递归向上查找工作区根目录
-       * 识别标准：包含 pnpm-workspace.yaml 或 package.json 中定义了 workspaces
-       * @param cwd 起始查找目录
-       * @returns 查找到的工作区根目录路径，若未找到则返回 cwd
+       * 加载 tsup 配置
+       * @param cwd 项目根目录
        */
-      static async getWorkspaceRoot(cwd) {
-        if (!cwd) return cwd;
-        if (cwd.startsWith("/mock")) return cwd;
-        let current = path4.resolve(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)) {
+      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 = path4.join(cwd, file);
+          if (fs2.existsSync(configPath)) {
             try {
-              const pkg = await fs2.readJson(pkgPath);
-              if (pkg.workspaces) return current;
+              if (file.endsWith(".json")) {
+                return await fs2.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}`);
             }
           }
-          current = path4.dirname(current);
         }
-        return cwd;
+        const pkgPath = path4.join(cwd, "package.json");
+        if (fs2.existsSync(pkgPath)) {
+          try {
+            const pkg = await fs2.readJson(pkgPath);
+            if (pkg.tsup) {
+              return pkg.tsup;
+            }
+          } catch (e) {
+          }
+        }
+        return {};
       }
     };
   }
@@ -231,8 +326,8 @@ var init_SandboxPath = __esm({
 
 // src/sandbox/SandboxRenderer.ts
 import fs3 from "fs-extra";
-import path5 from "path";
 import Handlebars from "handlebars";
+import path5 from "path";
 var SandboxRenderer;
 var init_SandboxRenderer = __esm({
   "src/sandbox/SandboxRenderer.ts"() {
@@ -339,16 +434,86 @@ var init_SandboxRenderer = __esm({
   }
 });
 
-// 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();
+// src/sandbox/SandboxPath.ts
+import fs5 from "fs-extra";
+import path7 from "path";
+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 path7.join(this.BASE_DIR, SANDBOX_CONFIG.DIRS.VERSIONS);
+      }
+      /**
+       * 获取指定版本的沙箱路径
+       * @param version 版本号，或者 'current' 表示当前激活版本
+       * @returns 对应版本的绝对路径
+       */
+      static getVersionPath(version) {
+        if (version === SANDBOX_CONFIG.DIRS.CURRENT) {
+          return path7.join(this.BASE_DIR, SANDBOX_CONFIG.DIRS.VERSIONS, SANDBOX_CONFIG.DIRS.CURRENT);
+        }
+        return path7.join(this.BASE_DIR, SANDBOX_CONFIG.DIRS.VERSIONS, version);
+      }
+      /**
+       * 递归向上查找工作区根目录
+       * 识别标准：包含 pnpm-workspace.yaml 或 package.json 中定义了 workspaces
+       * @param cwd 起始查找目录
+       * @returns 查找到的工作区根目录路径，若未找到则返回 cwd
+       */
+      static async getWorkspaceRoot(cwd) {
+        if (!cwd) return cwd;
+        if (cwd.startsWith("/mock")) return cwd;
+        let current = path7.resolve(cwd);
+        while (current !== path7.parse(current).root) {
+          const pkgPath = path7.join(current, "package.json");
+          const pnpmWorkspacePath = path7.join(current, "pnpm-workspace.yaml");
+          if (fs5.existsSync(pnpmWorkspacePath)) return current;
+          if (fs5.existsSync(pkgPath)) {
+            try {
+              const pkg = await fs5.readJson(pkgPath);
+              if (pkg.workspaces) return current;
+            } catch (e) {
+            }
+          }
+          current = path7.dirname(current);
+        }
+        return cwd;
+      }
+    };
+  }
+});
+
+// src/sandbox/SandboxContext.ts
+import fs6 from "fs-extra";
+import path8 from "path";
+var SandboxContext;
+var init_SandboxContext = __esm({
+  "src/sandbox/SandboxContext.ts"() {
+    "use strict";
+    init_esm_shims();
     init_constants();
+    init_SandboxPath();
     SandboxContext = class {
       /**
        * 注入项目虚拟上下文
@@ -366,38 +531,38 @@ var init_SandboxContext = __esm({
       static async inject(projectRoot, version, corePackages, runtimeDeps) {
         const workspaceRoot = await SandboxPath.getWorkspaceRoot(projectRoot);
         if (!workspaceRoot) {
-          const chatbiDir2 = path6.join(projectRoot, SANDBOX_CONFIG.DIRS.CACHE);
-          await fs4.ensureDir(chatbiDir2);
+          const chatbiDir2 = path8.join(projectRoot, SANDBOX_CONFIG.DIRS.CACHE);
+          await fs6.ensureDir(chatbiDir2);
           return this.injectToDir(chatbiDir2, version, corePackages, runtimeDeps);
         }
-        const chatbiDir = path6.join(workspaceRoot, SANDBOX_CONFIG.DIRS.CACHE);
-        await fs4.ensureDir(chatbiDir);
+        const chatbiDir = path8.join(workspaceRoot, SANDBOX_CONFIG.DIRS.CACHE);
+        await fs6.ensureDir(chatbiDir);
         if (workspaceRoot !== projectRoot) {
-          const localChatbi = path6.join(projectRoot, SANDBOX_CONFIG.DIRS.CACHE);
+          const localChatbi = path8.join(projectRoot, SANDBOX_CONFIG.DIRS.CACHE);
           try {
-            const stats = await fs4.lstat(localChatbi).catch(() => null);
+            const stats = await fs6.lstat(localChatbi).catch(() => null);
             if (stats) {
               if (stats.isSymbolicLink()) {
-                const linkTarget = await fs4.readlink(localChatbi);
+                const linkTarget = await fs6.readlink(localChatbi);
                 if (linkTarget !== chatbiDir) {
-                  await fs4.remove(localChatbi);
-                  await fs4.symlink(chatbiDir, localChatbi, "dir");
+                  await fs6.remove(localChatbi);
+                  await fs6.symlink(chatbiDir, localChatbi, "dir");
                 }
               } else {
-                await fs4.remove(localChatbi);
-                await fs4.symlink(chatbiDir, localChatbi, "dir");
+                await fs6.remove(localChatbi);
+                await fs6.symlink(chatbiDir, localChatbi, "dir");
               }
             } else {
-              await fs4.symlink(chatbiDir, localChatbi, "dir");
+              await fs6.symlink(chatbiDir, localChatbi, "dir");
             }
           } catch (e) {
           }
         }
-        const gitignorePath = path6.join(workspaceRoot, ".gitignore");
-        if (fs4.existsSync(gitignorePath)) {
-          let content = await fs4.readFile(gitignorePath, "utf-8");
+        const gitignorePath = path8.join(workspaceRoot, ".gitignore");
+        if (fs6.existsSync(gitignorePath)) {
+          let content = await fs6.readFile(gitignorePath, "utf-8");
           if (!content.includes(SANDBOX_CONFIG.DIRS.CACHE)) {
-            await fs4.appendFile(gitignorePath, `
+            await fs6.appendFile(gitignorePath, `
 # ChatBI
 ${SANDBOX_CONFIG.DIRS.CACHE}
 `);
@@ -410,7 +575,7 @@ ${SANDBOX_CONFIG.DIRS.CACHE}
        */
       static async injectToDir(chatbiDir, version, corePackages, runtimeDeps) {
         const versionPath = SandboxPath.getVersionPath(version);
-        const sandboxNodeModules = path6.join(versionPath, "node_modules");
+        const sandboxNodeModules = path8.join(versionPath, "node_modules");
         const corePaths = {};
         for (const pkgName of corePackages) {
           corePaths[pkgName] = [`./node_modules/${pkgName}`];
@@ -427,7 +592,7 @@ ${SANDBOX_CONFIG.DIRS.CACHE}
         }
         corePaths["@types/*"] = ["./node_modules/@types/*"];
         corePaths["vite/client"] = ["./node_modules/vite/client.d.ts"];
-        const baseConfigPath = path6.join(sandboxNodeModules, "@chatbi-v/config/base.json");
+        const baseConfigPath = path8.join(sandboxNodeModules, "@chatbi-v/config/base.json");
         const tsConfig = {
           extends: baseConfigPath,
           compilerOptions: {
@@ -443,25 +608,25 @@ ${SANDBOX_CONFIG.DIRS.CACHE}
             }
           }
         };
-        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)) {
+        await fs6.writeJson(path8.join(chatbiDir, "tsconfig.json"), tsConfig, { spaces: 2 });
+        await fs6.writeJson(path8.join(chatbiDir, "tsconfig.paths.json"), { compilerOptions: tsConfig.compilerOptions }, { spaces: 2 });
+        const virtualNodeModules = path8.join(chatbiDir, "node_modules");
+        if (fs6.existsSync(sandboxNodeModules)) {
           try {
-            const stats = await fs4.lstat(virtualNodeModules).catch(() => null);
+            const stats = await fs6.lstat(virtualNodeModules).catch(() => null);
             if (stats) {
               if (stats.isSymbolicLink()) {
-                const linkTarget = await fs4.readlink(virtualNodeModules);
+                const linkTarget = await fs6.readlink(virtualNodeModules);
                 if (linkTarget !== sandboxNodeModules) {
-                  await fs4.remove(virtualNodeModules);
-                  await fs4.symlink(sandboxNodeModules, virtualNodeModules, "dir");
+                  await fs6.remove(virtualNodeModules);
+                  await fs6.symlink(sandboxNodeModules, virtualNodeModules, "dir");
                 }
               } else {
-                await fs4.remove(virtualNodeModules);
-                await fs4.symlink(sandboxNodeModules, virtualNodeModules, "dir");
+                await fs6.remove(virtualNodeModules);
+                await fs6.symlink(sandboxNodeModules, virtualNodeModules, "dir");
               }
             } else {
-              await fs4.symlink(sandboxNodeModules, virtualNodeModules, "dir");
+              await fs6.symlink(sandboxNodeModules, virtualNodeModules, "dir");
             }
           } catch (e) {
           }
@@ -472,10 +637,10 @@ ${SANDBOX_CONFIG.DIRS.CACHE}
 });
 
 // src/sandbox/SandboxPkgManager.ts
-import fs5 from "fs-extra";
-import path7 from "path";
-import pc2 from "picocolors";
 import fg from "fast-glob";
+import fs7 from "fs-extra";
+import path9 from "path";
+import pc3 from "picocolors";
 var SandboxPkgManager;
 var init_SandboxPkgManager = __esm({
   "src/sandbox/SandboxPkgManager.ts"() {
@@ -496,16 +661,16 @@ var init_SandboxPkgManager = __esm({
         try {
           const cliRoot = await getCliRoot();
           const projectRoot = await SandboxPath.getWorkspaceRoot(cliRoot);
-          if (projectRoot === cliRoot && !fs5.existsSync(path7.join(projectRoot, "pnpm-workspace.yaml"))) {
+          if (projectRoot === cliRoot && !fs7.existsSync(path9.join(projectRoot, "pnpm-workspace.yaml"))) {
             return false;
           }
           const possiblePackagesDirs = [
-            path7.join(projectRoot, "packages"),
+            path9.join(projectRoot, "packages"),
             // 兼容旧版或其他可能的路径结构
-            path7.resolve(projectRoot, "../chatbi-v/packages")
+            path9.resolve(projectRoot, "../chatbi-v/packages")
           ];
           const localPackages = {};
-          const patterns = possiblePackagesDirs.filter((dir) => fs5.existsSync(dir)).map((dir) => path7.join(dir, "**/package.json"));
+          const patterns = possiblePackagesDirs.filter((dir) => fs7.existsSync(dir)).map((dir) => path9.join(dir, "**/package.json"));
           if (patterns.length > 0) {
             const pkgJsonFiles = await fg(patterns, {
               ignore: ["**/node_modules/**", "**/dist/**", "**/.git/**"],
@@ -514,34 +679,34 @@ var init_SandboxPkgManager = __esm({
             });
             for (const pkgJsonPath of pkgJsonFiles) {
               try {
-                const pkgJson = await fs5.readJson(pkgJsonPath);
+                const pkgJson = await fs7.readJson(pkgJsonPath);
                 if (corePackages.includes(pkgJson.name) || runtimeDeps.includes(pkgJson.name)) {
-                  localPackages[pkgJson.name] = path7.dirname(pkgJsonPath);
+                  localPackages[pkgJson.name] = path9.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");
+          const linkSummary = Object.entries(localPackages).map(([name, pkgPath]) => `${pc3.cyan(name.padEnd(30))} -> ${pc3.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,
+            pc3.green("\u{1F517} \u5DF2\u68C0\u6D4B\u5230\u672C\u5730\u5F00\u53D1\u73AF\u5883\uFF0C\u5C06\u94FE\u63A5\u4EE5\u4E0B\u6838\u5FC3\u5305\uFF1A\n\n") + linkSummary,
             "Monorepo Link Mode"
           );
-          const sandboxNodeModules = path7.join(versionPath, "node_modules");
-          await fs5.ensureDir(sandboxNodeModules);
+          const sandboxNodeModules = path9.join(versionPath, "node_modules");
+          await fs7.ensureDir(sandboxNodeModules);
           for (const [name, pkgPath] of Object.entries(localPackages)) {
-            const targetLinkPath = path7.join(sandboxNodeModules, name);
-            await fs5.ensureDir(path7.dirname(targetLinkPath));
+            const targetLinkPath = path9.join(sandboxNodeModules, name);
+            await fs7.ensureDir(path9.dirname(targetLinkPath));
             try {
-              const stats = await fs5.lstat(targetLinkPath).catch(() => null);
-              if (stats) await fs5.remove(targetLinkPath);
+              const stats = await fs7.lstat(targetLinkPath).catch(() => null);
+              if (stats) await fs7.remove(targetLinkPath);
             } catch (e) {
             }
-            await fs5.symlink(pkgPath, targetLinkPath, "dir");
+            await fs7.symlink(pkgPath, targetLinkPath, "dir");
           }
-          const sandboxPkgJsonPath = path7.join(versionPath, "package.json");
-          const sandboxPkgJson = await fs5.readJson(sandboxPkgJsonPath);
+          const sandboxPkgJsonPath = path9.join(versionPath, "package.json");
+          const sandboxPkgJson = await fs7.readJson(sandboxPkgJsonPath);
           const sections = ["dependencies", "devDependencies"];
           let modified = false;
           for (const section of sections) {
@@ -554,10 +719,10 @@ var init_SandboxPkgManager = __esm({
               }
             }
           }
-          if (modified) await fs5.writeJson(sandboxPkgJsonPath, sandboxPkgJson, { spaces: 2 });
+          if (modified) await fs7.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}`));
+          console.warn(pc3.yellow(`  \u26A0\uFE0F  Link \u672C\u5730\u6E90\u7801\u5931\u8D25\uFF0C\u5C06\u5C1D\u8BD5\u4ECE NPM \u5B89\u88C5: ${e.message}`));
           return false;
         }
       }
@@ -566,32 +731,29 @@ var init_SandboxPkgManager = __esm({
 });
 
 // src/sandbox.ts
-import fs6 from "fs-extra";
-import path8 from "path";
-import pc3 from "picocolors";
+import { execa as execa2 } from "execa";
 import fg2 from "fast-glob";
-import { execa } from "execa";
+import fs8 from "fs-extra";
+import path10 from "path";
+import pc4 from "picocolors";
 var Sandbox;
 var init_sandbox = __esm({
   "src/sandbox.ts"() {
     "use strict";
     init_esm_shims();
-    init_utils();
-    init_SandboxPath();
-    init_SandboxRenderer();
+    init_constants();
     init_SandboxContext();
+    init_SandboxPath();
     init_SandboxPkgManager();
-    init_constants();
+    init_SandboxRenderer();
+    init_utils();
     Sandbox = class {
       static {
         /** 核心源码包列表 */
         this.CORE_PACKAGES = [
           "@chatbi-v/core",
           "@chatbi-v/mocks",
-          "@chatbi-v/config",
-          "@chatbi-v/plugin-theme-manager",
-          "@chatbi-v/plugin-layout-transform",
-          "@chatbi-v/plugin-system-monitor"
+          "@chatbi-v/config"
         ];
       }
       static {
@@ -632,8 +794,8 @@ var init_sandbox = __esm({
       /** 清理指定版本的沙箱物理文件 */
       static async cleanVersion(version) {
         const versionPath = this.getVersionPath(version);
-        if (fs6.existsSync(versionPath)) {
-          await fs6.remove(versionPath);
+        if (fs8.existsSync(versionPath)) {
+          await fs8.remove(versionPath);
         }
       }
       /**
@@ -647,7 +809,7 @@ var init_sandbox = __esm({
           const workspaceRoot = await this.getWorkspaceRoot(cwd);
           let cleanedCount = 0;
           const cachePatterns = [
-            path8.join(workspaceRoot, `**/${SANDBOX_CONFIG.DIRS.CACHE}`)
+            path10.join(workspaceRoot, `**/${SANDBOX_CONFIG.DIRS.CACHE}`)
           ];
           const cacheDirs = await fg2(cachePatterns, {
             onlyFiles: false,
@@ -658,15 +820,15 @@ var init_sandbox = __esm({
             // 确保能匹配到以 . 开头的目录
           });
           for (const dir of cacheDirs) {
-            const stats = await fs6.lstat(dir).catch(() => null);
+            const stats = await fs8.lstat(dir).catch(() => null);
             if (stats) {
-              await fs6.remove(dir);
+              await fs8.remove(dir);
               cleanedCount++;
             }
           }
           if (deep) {
             const distPatterns = [
-              path8.join(workspaceRoot, "**/dist")
+              path10.join(workspaceRoot, "**/dist")
             ];
             const distDirs = await fg2(distPatterns, {
               onlyFiles: false,
@@ -679,24 +841,24 @@ var init_sandbox = __esm({
               ]
             });
             for (const dir of distDirs) {
-              const stats = await fs6.lstat(dir).catch(() => null);
+              const stats = await fs8.lstat(dir).catch(() => null);
               if (stats) {
-                const hasPkg = fs6.existsSync(path8.join(path8.dirname(dir), "package.json"));
+                const hasPkg = fs8.existsSync(path10.join(path10.dirname(dir), "package.json"));
                 if (hasPkg) {
-                  await fs6.remove(dir);
+                  await fs8.remove(dir);
                   cleanedCount++;
                 }
               }
             }
             const globalRoot = this.getRoot();
-            if (fs6.existsSync(globalRoot)) {
-              await fs6.remove(globalRoot);
+            if (fs8.existsSync(globalRoot)) {
+              await fs8.remove(globalRoot);
               cleanedCount++;
             }
           }
-          spinner.succeed(pc3.green(`\u6E05\u7406\u5B8C\u6210\uFF0C\u5171\u6E05\u7406 ${cleanedCount} \u4E2A\u9879\u76EE/\u7F13\u5B58\u76EE\u5F55`));
+          spinner.succeed(pc4.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}`));
+          spinner.fail(pc4.red(`\u6E05\u7406\u5931\u8D25: ${e.message}`));
         }
       }
       /**
@@ -704,14 +866,14 @@ var init_sandbox = __esm({
        */
       static async prepare(version, force = false) {
         const versionPath = this.getVersionPath(version);
-        if (!force && fs6.existsSync(path8.join(versionPath, "node_modules/tailwindcss"))) {
+        if (!force && fs8.existsSync(path10.join(versionPath, "node_modules/tailwindcss"))) {
           return versionPath;
         }
-        if (fs6.existsSync(versionPath)) {
-          await fs6.remove(path8.join(versionPath, "node_modules"));
+        if (fs8.existsSync(versionPath)) {
+          await fs8.remove(path10.join(versionPath, "node_modules"));
         }
-        await fs6.ensureDir(versionPath);
-        const spinner = createSpinner(`\u6B63\u5728\u521D\u59CB\u5316\u5185\u6838\u6C99\u7BB1 ${pc3.cyan(version)}...`).start();
+        await fs8.ensureDir(versionPath);
+        const spinner = createSpinner(`\u6B63\u5728\u521D\u59CB\u5316\u5185\u6838\u6C99\u7BB1 ${pc4.cyan(version)}...`).start();
         try {
           const cliRoot = await getCliRoot();
           const dependencies = {};
@@ -727,20 +889,20 @@ var init_sandbox = __esm({
             devDependencies: DEPENDENCY_VERSIONS
           };
           await SandboxRenderer.renderDirectory(
-            path8.join(cliRoot, "templates/sandbox"),
+            path10.join(cliRoot, "templates/sandbox"),
             versionPath,
             templateData
           );
-          spinner.text = pc3.gray("  \u{1F50D} \u68C0\u67E5\u672C\u5730\u5F00\u53D1\u73AF\u5883...");
+          spinner.text = pc4.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...");
+          spinner.text = pc4.gray(`  \u23F3 \u6267\u884C pnpm ${installArgs.join(" ")}...`);
+          await execa2("pnpm", installArgs, { cwd: versionPath });
+          spinner.text = pc4.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`));
+          spinner.succeed(pc4.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}`));
+          spinner.fail(pc4.red(`\u5185\u6838\u6C99\u7BB1\u521D\u59CB\u5316\u5931\u8D25: ${e.message}`));
           throw e;
         }
         return versionPath;
@@ -750,14 +912,14 @@ var init_sandbox = __esm({
        */
       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"))) {
+        const shellDestDir = path10.join(versionPath, "shell");
+        if (!force && fs8.existsSync(path10.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 shellTemplateDir = path10.join(cliRoot, "templates/app");
+        if (fs8.existsSync(shellTemplateDir)) {
+          await fs8.remove(shellDestDir);
           const templateData = {
             name: "chatbi-shell",
             version,
@@ -768,7 +930,7 @@ var init_sandbox = __esm({
             tsconfigPath: "./tsconfig.paths.json"
           };
           await SandboxRenderer.renderDirectory(shellTemplateDir, shellDestDir, templateData);
-          await fs6.writeJson(path8.join(shellDestDir, "tsconfig.paths.json"), {
+          await fs8.writeJson(path10.join(shellDestDir, "tsconfig.paths.json"), {
             compilerOptions: { baseUrl: ".", paths: { "@/*": ["./src/*"] } }
           }, { spaces: 2 });
         }
@@ -781,24 +943,24 @@ var init_sandbox = __esm({
       /** 获取核心库的 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)]));
+        const sandboxNodeModules = path10.join(versionPath, "node_modules");
+        return Object.fromEntries(this.CORE_PACKAGES.map((pkg) => [pkg, path10.join(sandboxNodeModules, pkg)]));
       }
       /** 切换内核版本 */
       static async useVersion(version) {
         const versionRoot = this.getVersionRoot();
-        const currentLink = path8.join(versionRoot, SANDBOX_CONFIG.DIRS.CURRENT);
+        const currentLink = path10.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");
+        if (!fs8.existsSync(targetPath)) throw new Error(`\u7248\u672C ${version} \u4E0D\u5B58\u5728`);
+        if (fs8.existsSync(currentLink)) await fs8.remove(currentLink);
+        await fs8.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 currentLink = path10.join(this.getVersionRoot(), SANDBOX_CONFIG.DIRS.CURRENT);
+          if (fs8.existsSync(currentLink)) {
+            return path10.basename(await fs8.readlink(currentLink));
           }
           const versions = await this.listVersions();
           return versions[0] || "1.0.0";
@@ -808,8 +970,8 @@ var init_sandbox = __esm({
       /** 列出所有已安装版本 */
       static async listVersions() {
         const versionRoot = this.getVersionRoot();
-        if (!fs6.existsSync(versionRoot)) return [];
-        const dirs = await fs6.readdir(versionRoot);
+        if (!fs8.existsSync(versionRoot)) return [];
+        const dirs = await fs8.readdir(versionRoot);
         return dirs.filter((d) => d !== SANDBOX_CONFIG.DIRS.CURRENT && !d.startsWith(".")).sort().reverse();
       }
       /** 可视化展示沙箱状态 */
@@ -819,11 +981,11 @@ var init_sandbox = __esm({
         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())}`
+          `${pc4.bold("\u9879\u76EE\u8DEF\u5F84:")}   ${pc4.cyan(cwd)}`,
+          `${pc4.bold("\u67B6\u6784\u6A21\u5F0F:")}   ${isMonorepo ? pc4.yellow("Monorepo") : pc4.green("Standalone")}`,
+          `${pc4.bold("\u5F53\u524D\u5185\u6838:")}   ${pc4.green(currentVersion)}`,
+          `${pc4.bold("\u5DF2\u88C5\u7248\u672C:")}   ${pc4.gray(versions.join(", ") || "none")}`,
+          `${pc4.bold("\u6C99\u7BB1\u6839\u76EE\u5F55:")} ${pc4.gray(this.getRoot())}`
         ].join("\n");
         printBox(statusInfo, "ChatBI Sandbox Status");
       }
@@ -831,160 +993,42 @@ var init_sandbox = __esm({
   }
 });
 
-// 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 { createRequire as createRequire2 } from "module";
-import path10 from "path";
-import fs8 from "fs-extra";
-import pc4 from "picocolors";
-import prompts from "prompts";
 import fg3 from "fast-glob";
+import fs9 from "fs-extra";
+import { createRequire as createRequire3 } from "module";
+import path11 from "path";
+import pc5 from "picocolors";
+import prompts2 from "prompts";
+import { createJiti as createJiti2 } from "jiti";
 var nativeRequire, CoreKit;
 var init_corekit = __esm({
   "src/corekit.ts"() {
     "use strict";
     init_esm_shims();
-    init_utils();
-    init_sandbox();
     init_config();
-    nativeRequire = createRequire2(import.meta.url);
+    init_sandbox();
+    init_utils();
+    nativeRequire = createRequire3(import.meta.url);
     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"))) {
+        const pkgPath = path11.join(cwd, "package.json");
+        if (!fs9.existsSync(pkgPath)) return "app";
+        const pkg = await fs9.readJson(pkgPath);
+        if (pkg.workspaces || fs9.existsSync(path11.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"))) {
+        if (fs9.existsSync(path11.join(cwd, "index.html"))) {
           return "app";
         }
-        if (fs8.existsSync(path10.join(cwd, "src/index.ts")) || fs8.existsSync(path10.join(cwd, "src/index.tsx"))) {
+        if (fs9.existsSync(path11.join(cwd, "src/index.ts")) || fs9.existsSync(path11.join(cwd, "src/index.tsx"))) {
           if (pkg.bin) return "lib";
           if (pkg.peerDependencies?.react && !pkg.dependencies?.react) return "plugin";
           return "lib";
@@ -1002,18 +1046,18 @@ var init_corekit = __esm({
         }
         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();
+          const cliVersionFile = path11.join(cliRoot, ".chatbi-version");
+          if (fs9.existsSync(cliVersionFile)) {
+            const version = (await fs9.readFile(cliVersionFile, "utf-8")).trim();
             if (version) return version;
           }
         } catch (e) {
         }
-        const currentLinkPath = path10.join(Sandbox.getVersionRoot(), "current");
-        if (fs8.existsSync(currentLinkPath)) {
+        const currentLinkPath = path11.join(Sandbox.getVersionRoot(), "current");
+        if (fs9.existsSync(currentLinkPath)) {
           try {
-            const realPath = await fs8.realpath(currentLinkPath);
-            return path10.basename(realPath);
+            const realPath = await fs9.realpath(currentLinkPath);
+            return path11.basename(realPath);
           } catch (e) {
           }
         }
@@ -1025,7 +1069,7 @@ var init_corekit = __esm({
        */
       static async listVersions() {
         const versionsDir = Sandbox.getVersionRoot();
-        if (!fs8.existsSync(versionsDir)) return [];
+        if (!fs9.existsSync(versionsDir)) return [];
         const dirs = await fg3("*", {
           cwd: versionsDir,
           onlyDirectories: true,
@@ -1037,18 +1081,18 @@ var init_corekit = __esm({
        * 自动发现项目中的插件
        */
       static async discoverPlugins(rootDir) {
-        const pluginsDir = path10.join(rootDir, "plugins");
-        if (!fs8.existsSync(pluginsDir)) return [];
+        const pluginsDir = path11.join(rootDir, "plugins");
+        if (!fs9.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);
+            const pkg = await fs9.readJson(pkgPath);
+            const pluginPath = path11.dirname(pkgPath);
             plugins.push({
-              name: pkg.name || path10.basename(pluginPath),
+              name: pkg.name || path11.basename(pluginPath),
               path: pluginPath,
-              id: path10.basename(pluginPath)
+              id: path11.basename(pluginPath)
             });
           } catch (e) {
           }
@@ -1062,19 +1106,19 @@ var init_corekit = __esm({
         const mode = await this.detectMode(cwd);
         const version = await this.resolveVersion(cwd);
         printBox(
-          `${pc4.cyan(pc4.bold("\u{1F680} ChatBI Dev Server"))}
+          `${pc5.cyan(pc5.bold("\u{1F680} ChatBI Dev Server"))}
 
-${pc4.gray("Mode:   ")} ${pc4.yellow(mode)}
-${pc4.gray("Kernel: ")} ${pc4.green(version)}
-${pc4.gray("Root:   ")} ${pc4.white(cwd)}`,
+${pc5.gray("Mode:   ")} ${pc5.yellow(mode)}
+${pc5.gray("Kernel: ")} ${pc5.green(version)}
+${pc5.gray("Root:   ")} ${pc5.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...");
+          spinner.text = pc5.cyan("\u6B63\u5728\u6CE8\u5165\u865A\u62DF\u4E0A\u4E0B\u6587...");
           await Sandbox.injectContext(cwd, version);
-          spinner.succeed(pc4.green("\u73AF\u5883\u5C31\u7EEA"));
+          spinner.succeed(pc5.green("\u73AF\u5883\u5C31\u7EEA"));
           if (mode === "plugin") {
             await this.startPluginDevServer(cwd, version, options.port);
           } else if (mode === "app") {
@@ -1083,28 +1127,28 @@ ${pc4.gray("Root:   ")} ${pc4.white(cwd)}`,
             await this.startMonorepoDevServer(cwd, version, options.port);
           }
         } catch (e) {
-          spinner.fail(pc4.red(`\u542F\u52A8\u5931\u8D25: ${e.message}`));
+          spinner.fail(pc5.red(`\u542F\u52A8\u5931\u8D25: ${e.message}`));
         }
       }
       /**
        * 启动 Monorepo 开发服务器
        */
       static async startMonorepoDevServer(rootDir, version, customPort) {
-        const appsDir = path10.join(rootDir, "apps");
-        if (!fs8.existsSync(appsDir)) {
+        const appsDir = path11.join(rootDir, "apps");
+        if (!fs9.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)
+          name: path11.basename(path11.dirname(pkgPath)),
+          path: path11.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({
+        const response = await prompts2({
           type: "select",
           name: "appPath",
           message: "\u8BF7\u9009\u62E9\u8981\u542F\u52A8\u7684\u5E94\u7528:",
@@ -1115,7 +1159,7 @@ ${pc4.gray("Root:   ")} ${pc4.white(cwd)}`,
           logger.info("\u5DF2\u53D6\u6D88");
           return;
         }
-        await this.startAppDevServer(response.appPath, version, customPort);
+        await this.startAppDevServer(response.appPath, version, customPort, true);
       }
       /**
        * 启动插件开发服务器 (Hosted Mode)
@@ -1125,19 +1169,21 @@ ${pc4.gray("Root:   ")} ${pc4.white(cwd)}`,
         const shellPort = customPort || 5173;
         const sandboxRoot = Sandbox.getRoot();
         const versionPath = Sandbox.getVersionPath(version);
-        const sandboxNodeModules = path10.join(versionPath, "node_modules");
+        const sandboxNodeModules = path11.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 tailwindPath = path11.join(sandboxNodeModules, "tailwindcss");
+        const autoprefixerPath = path11.join(sandboxNodeModules, "autoprefixer");
+        let pluginEntry = path11.join(pluginDir, "src/index.tsx");
+        if (!fs9.existsSync(pluginEntry)) {
+          pluginEntry = path11.join(pluginDir, "src/index.ts");
         }
         const define = {
           "process.env.CHATBI_PLUGIN_PATH": JSON.stringify(pluginDir)
         };
         const { createServer } = await import("vite");
+        const jiti = createJiti2(import.meta.url);
+        const tailwindConfig = await jiti.import(path11.join(sandboxNodeModules, "@chatbi-v/config/tailwind.js"), { default: true });
         try {
           const server = await createServer({
             root: shellDir,
@@ -1146,12 +1192,12 @@ ${pc4.gray("Root:   ")} ${pc4.white(cwd)}`,
               postcss: {
                 plugins: [
                   nativeRequire(tailwindPath)({
-                    presets: [nativeRequire(path10.join(sandboxNodeModules, "@chatbi-v/config/tailwind.js"))],
+                    presets: [tailwindConfig],
                     darkMode: "class",
                     content: [
-                      path10.join(shellDir, "index.html"),
-                      path10.join(shellDir, "src/**/*.{ts,tsx}"),
-                      path10.join(pluginDir, "src/**/*.{ts,tsx}")
+                      path11.join(shellDir, "index.html"),
+                      path11.join(shellDir, "src/**/*.{ts,tsx}"),
+                      path11.join(pluginDir, "src/**/*.{ts,tsx}")
                     ]
                   }),
                   nativeRequire(autoprefixerPath)
@@ -1173,21 +1219,21 @@ ${pc4.gray("Root:   ")} ${pc4.white(cwd)}`,
                 allow: [
                   sandboxRoot,
                   pluginDir,
-                  path10.resolve(pluginDir, "../../")
+                  path11.resolve(pluginDir, "../../")
                 ]
               }
             },
             resolve: {
               alias: {
                 ...coreAlias,
-                "react": path10.join(sandboxNodeModules, "react"),
-                "react-dom": path10.join(sandboxNodeModules, "react-dom"),
-                "@": path10.join(shellDir, "src"),
+                "react": path11.join(sandboxNodeModules, "react"),
+                "react-dom": path11.join(sandboxNodeModules, "react-dom"),
+                "@": path11.join(shellDir, "src"),
                 // 关键：将虚拟模块指向用户插件
                 "virtual:user-plugin": pluginEntry,
                 // 防止 glob 报错，提供空的映射
-                "@chatbi-plugins": path10.join(shellDir, "empty"),
-                "@chatbi-apps": path10.join(shellDir, "empty")
+                "@chatbi-plugins": path11.join(shellDir, "empty"),
+                "@chatbi-apps": path11.join(shellDir, "empty")
               }
             },
             define
@@ -1195,9 +1241,9 @@ ${pc4.gray("Root:   ")} ${pc4.white(cwd)}`,
           await server.listen();
           const localUrl = `http://localhost:${shellPort}/`;
           printBox(
-            `${pc4.green(pc4.bold("\u2705 \u6258\u7BA1\u5F0F Shell \u5DF2\u542F\u52A8"))}
+            `${pc5.green(pc5.bold("\u2705 \u6258\u7BA1\u5F0F Shell \u5DF2\u542F\u52A8"))}
 
-${pc4.white("Local: ")} ${pc4.cyan(pc4.underline(localUrl))}`,
+${pc5.white("Local: ")} ${pc5.cyan(pc5.underline(localUrl))}`,
             "Shell Success"
           );
         } catch (e) {
@@ -1207,12 +1253,16 @@ ${pc4.white("Local: ")} ${pc4.cyan(pc4.underline(localUrl))}`,
       /**
        * 启动应用开发服务器 (Integrated Mode)
        */
-      static async startAppDevServer(appDir, version, customPort) {
+      static async startAppDevServer(appDir, version, customPort, isMonorepo = false) {
         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");
+        const sandboxNodeModules = path11.join(versionPath, "node_modules");
+        const pkgPath = path11.join(appDir, "package.json");
+        const pkg = await fs9.readJson(pkgPath).catch(() => ({}));
+        const hasCoreDep = pkg.dependencies?.["@chatbi-v/core"] || pkg.devDependencies?.["@chatbi-v/core"];
+        const shouldUseSandboxAlias = !(isMonorepo && hasCoreDep);
+        const coreAlias = shouldUseSandboxAlias ? Sandbox.getCoreAlias(version) : {};
+        const { createServer, loadConfigFromFile, searchForWorkspaceRoot } = await import("vite");
         try {
           const configContext = { command: "serve", mode: "development" };
           const userConfig = await loadConfigFromFile(configContext, void 0, appDir).catch(() => null);
@@ -1224,9 +1274,12 @@ ${pc4.white("Local: ")} ${pc4.cyan(pc4.underline(localUrl))}`,
               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")
+                // 只有在需要使用沙箱时才注入 React Alias
+                ...shouldUseSandboxAlias ? {
+                  "react": path11.join(sandboxNodeModules, "react"),
+                  "react-dom": path11.join(sandboxNodeModules, "react-dom"),
+                  "@vitejs/plugin-react": path11.join(sandboxNodeModules, "@vitejs/plugin-react")
+                } : {}
               }
             },
             server: {
@@ -1242,6 +1295,7 @@ ${pc4.white("Local: ")} ${pc4.cyan(pc4.underline(localUrl))}`,
               },
               fs: {
                 allow: [
+                  searchForWorkspaceRoot(appDir),
                   Sandbox.getRoot(),
                   appDir,
                   // 允许访问沙箱中的所有依赖
@@ -1253,9 +1307,9 @@ ${pc4.white("Local: ")} ${pc4.cyan(pc4.underline(localUrl))}`,
           await server.listen();
           const localUrl = `http://localhost:${server.config.server.port}/`;
           printBox(
-            `${pc4.green(pc4.bold("\u2705 \u5E94\u7528\u5DF2\u6210\u529F\u542F\u52A8"))}
+            `${pc5.green(pc5.bold("\u2705 \u5E94\u7528\u5DF2\u6210\u529F\u542F\u52A8"))}
 
-${pc4.white("Local: ")} ${pc4.cyan(pc4.underline(localUrl))}`,
+${pc5.white("Local: ")} ${pc5.cyan(pc5.underline(localUrl))}`,
             "App Success"
           );
         } catch (e) {
@@ -1271,19 +1325,19 @@ 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 { execa as execa3 } from "execa";
+import fs10 from "fs-extra";
+import path12 from "path";
+import pc6 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)) {
+  const pkgPath = path12.join(cwd, "package.json");
+  if (!fs10.existsSync(pkgPath)) {
     logger.error(`\u5728 ${cwd} \u4E2D\u672A\u627E\u5230 package.json`);
     return;
   }
-  const pkg = await fs9.readJson(pkgPath);
+  const pkg = await fs10.readJson(pkgPath);
   if (options.force) {
     const spinnerClean = createSpinner("\u6B63\u5728\u6E05\u7406\u7F13\u5B58\u73AF\u5883...").start();
     try {
@@ -1295,24 +1349,24 @@ async function build(options) {
     }
   }
   const version = await CoreKit.resolveVersion(cwd);
-  logger.info(`\u6B63\u5728\u6784\u5EFA\u9879\u76EE: ${pc5.bold(pkg.name || "unnamed")} (\u5185\u6838\u7248\u672C: ${version})
+  logger.info(`\u6B63\u5728\u6784\u5EFA\u9879\u76EE: ${pc6.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"))) {
+  if (pkg.workspaces || fs10.existsSync(path12.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 });
+      const dirPath = path12.join(cwd, dir);
+      if (fs10.existsSync(dirPath)) {
+        const entries = await fs10.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"))) {
+            const subPkgPath = path12.join(dirPath, entry2.name);
+            if (fs10.existsSync(path12.join(subPkgPath, "package.json"))) {
               await Sandbox.injectContext(subPkgPath, version);
             }
           }
@@ -1326,12 +1380,12 @@ async function build(options) {
   if (pkg.scripts && pkg.scripts.build && !process.env.CHATBI_CLI_INTERNAL) {
     const buildScript = pkg.scripts.build;
     if (!buildScript.includes("chatbi-cli build") && !buildScript.includes("chatbi build")) {
-      logger.info(`\u68C0\u6D4B\u5230\u81EA\u5B9A\u4E49 build \u811A\u672C\uFF0C\u6B63\u5728\u6267\u884C: ${pc5.cyan("npm run build")}`);
+      logger.info(`\u68C0\u6D4B\u5230\u81EA\u5B9A\u4E49 build \u811A\u672C\uFF0C\u6B63\u5728\u6267\u884C: ${pc6.cyan("npm run build")}`);
       const args = ["run", "build"];
       if (options.watch) {
         args.push("--", "--watch");
       }
-      await execa2("npm", args, {
+      await execa3("npm", args, {
         stdio: "inherit",
         env: { ...process.env, CHATBI_CLI_INTERNAL: "true" }
       });
@@ -1341,7 +1395,7 @@ async function build(options) {
   const mode = await CoreKit.detectMode(cwd);
   if (mode === "monorepo") {
     logger.info("\u68C0\u6D4B\u5230 Monorepo \u9879\u76EE\uFF0C\u6B63\u5728\u9012\u5F52\u6784\u5EFA\u5B50\u5305...");
-    await execa2("pnpm", ["-r", "build"], { stdio: "inherit", cwd });
+    await execa3("pnpm", ["-r", "build"], { stdio: "inherit", cwd });
     return;
   }
   if (mode === "app") {
@@ -1350,7 +1404,7 @@ async function build(options) {
     const coreAlias = Sandbox.getCoreAlias(version);
     await viteBuild({
       root: cwd,
-      configFile: fs9.existsSync(path11.join(cwd, "vite.config.ts")) ? void 0 : false,
+      configFile: fs10.existsSync(path12.join(cwd, "vite.config.ts")) ? void 0 : false,
       resolve: {
         alias: {
           ...coreAlias
@@ -1374,16 +1428,16 @@ async function build(options) {
     });
     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"),
+        pc6.green(pc6.bold("\u2728 \u5E94\u7528\u6784\u5EFA\u6210\u529F!")) + "\n\n" + pc6.white("\u4EA7\u7269\u76EE\u5F55: ") + pc6.cyan("dist"),
         "Build Success"
       );
     }
     return;
   }
   let entry = ["src/index.ts"];
-  if (fs9.existsSync(path11.join(cwd, "src/index.tsx"))) {
+  if (fs10.existsSync(path12.join(cwd, "src/index.tsx"))) {
     entry = ["src/index.tsx"];
-  } else if (!fs9.existsSync(path11.join(cwd, "src/index.ts"))) {
+  } else if (!fs10.existsSync(path12.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;
   }
@@ -1393,10 +1447,10 @@ async function build(options) {
     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);
+    await fs10.remove(path12.join(cwd, "dist"));
+    const tsbuildinfo = path12.join(cwd, "tsconfig.tsbuildinfo");
+    if (fs10.existsSync(tsbuildinfo)) {
+      await fs10.remove(tsbuildinfo);
     }
   }
   if (isPlugin) {
@@ -1486,31 +1540,31 @@ async function build(options) {
   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");
+      const localTsc = path12.join(cwd, "node_modules/.bin/tsc");
+      const sandboxTsc = path12.join(Sandbox.getVersionPath(version), "node_modules/.bin/tsc");
       let tscBin = "tsc";
-      if (fs9.existsSync(localTsc)) {
+      if (fs10.existsSync(localTsc)) {
         tscBin = localTsc;
-      } else if (fs9.existsSync(sandboxTsc)) {
+      } else if (fs10.existsSync(sandboxTsc)) {
         tscBin = sandboxTsc;
       } else {
-        if (fs9.existsSync(path11.join(cwd, "pnpm-lock.yaml"))) {
-          await execa2("pnpm", ["exec", "tsc", "--build", "tsconfig.json"]);
+        if (fs10.existsSync(path12.join(cwd, "pnpm-lock.yaml"))) {
+          await execa3("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"]);
+          await execa3("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"]);
+        await execa3(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"),
+      pc6.green(pc6.bold("\u2728 \u6784\u5EFA\u5B8C\u6210!")) + "\n\n" + pc6.white("\u4EA7\u7269\u76EE\u5F55: ") + pc6.cyan("dist") + "\n" + pc6.white("\u6784\u5EFA\u6A21\u5F0F: ") + pc6.cyan(isPlugin ? "Plugin" : "Library"),
       "Build Success"
     );
   }
@@ -1519,9 +1573,9 @@ var init_build = __esm({
   "src/commands/build.ts"() {
     "use strict";
     init_esm_shims();
-    init_sandbox();
-    init_corekit();
     init_config();
+    init_corekit();
+    init_sandbox();
     init_utils();
   }
 });
@@ -1531,17 +1585,17 @@ var sync_exports = {};
 __export(sync_exports, {
   sync: () => sync
 });
-import fs10 from "fs-extra";
-import path12 from "path";
-import pc6 from "picocolors";
+import fs11 from "fs-extra";
+import path13 from "path";
+import pc8 from "picocolors";
 async function sync(options = {}) {
   const cwd = options.cwd || process.cwd();
-  const pkgPath = path12.join(cwd, "package.json");
-  if (!fs10.existsSync(pkgPath)) {
+  const pkgPath = path13.join(cwd, "package.json");
+  if (!fs11.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);
+  const pkg = await fs11.readJson(pkgPath);
   let version = options.version;
   if (!version) {
     version = await CoreKit.resolveVersion(cwd);
@@ -1556,8 +1610,8 @@ async function sync(options = {}) {
   await Sandbox.prepare(version, options.force);
   mainSpinner.text = "\u6B63\u5728\u751F\u6210\u865A\u62DF\u4E0A\u4E0B\u6587...";
   if (options.version) {
-    const versionFilePath = path12.join(cwd, ".chatbi-version");
-    await fs10.writeFile(versionFilePath, version, "utf-8");
+    const versionFilePath = path13.join(cwd, ".chatbi-version");
+    await fs11.writeFile(versionFilePath, version, "utf-8");
   }
   await Sandbox.injectContext(cwd, version);
   let modified = false;
@@ -1579,19 +1633,19 @@ async function sync(options = {}) {
   if (modified) {
     pkg.dependencies = deps;
     pkg.devDependencies = devDeps;
-    await fs10.writeJson(pkgPath, pkg, { spaces: 2 });
+    await fs11.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!"))}
+      `${pc8.green(pc8.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))}
+${pc8.white("\u5F53\u524D\u7248\u672C: ")} ${pc8.cyan(version)}
+${pc8.white("\u6C99\u7BB1\u8DEF\u5F84: ")} ${pc8.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`,
+${pc8.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"
     );
   }
@@ -1600,24 +1654,68 @@ var init_sync = __esm({
   "src/commands/sync.ts"() {
     "use strict";
     init_esm_shims();
-    init_utils();
-    init_sandbox();
     init_corekit();
+    init_sandbox();
+    init_utils();
   }
 });
 
-// src/commands/init.ts
-var init_exports = {};
-__export(init_exports, {
-  init: () => init
+// src/commands/fetch.ts
+var fetch_exports = {};
+__export(fetch_exports, {
+  fetch: () => fetch
 });
-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([
+import { execa as execa4 } from "execa";
+import path15 from "path";
+import pc10 from "picocolors";
+async function fetch(version, options = {}) {
+  const fetchSpinner = createSpinner(`\u6B63\u5728\u83B7\u53D6\u5185\u6838\u7248\u672C ${pc10.cyan(version)}...`).start();
+  const versionPath = await Sandbox.prepare(version, true);
+  fetchSpinner.succeed(`\u5185\u6838\u7248\u672C ${pc10.cyan(version)} \u83B7\u53D6\u6210\u529F`);
+  if (options.pack) {
+    const packSpinner = createSpinner("\u6B63\u5728\u6253\u5305\u79BB\u7EBF\u8D44\u6E90...").start();
+    const tgzName = `chatbi-core-${version}.tgz`;
+    const tgzPath = path15.resolve(process.cwd(), tgzName);
+    await execa4("tar", [
+      "-czf",
+      tgzPath,
+      "-C",
+      path15.dirname(versionPath),
+      path15.basename(versionPath)
+    ]);
+    packSpinner.succeed("\u79BB\u7EBF\u8D44\u6E90\u6253\u5305\u5B8C\u6210");
+    printBox(
+      `${pc10.green(pc10.bold("\u2728 \u79BB\u7EBF\u5305\u5DF2\u751F\u6210!"))}
+
+${pc10.white("\u6587\u4EF6\u8DEF\u5F84: ")} ${pc10.cyan(tgzPath)}
+${pc10.white("\u5B89\u88C5\u547D\u4EE4: ")} ${pc10.gray(`chatbi install ${tgzName}`)}`,
+      "Pack Success"
+    );
+  } else {
+    logger.success(`\u5185\u6838\u7248\u672C ${pc10.cyan(version)} \u5DF2\u51C6\u5907\u5C31\u7EEA\u3002`);
+  }
+}
+var init_fetch = __esm({
+  "src/commands/fetch.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_sandbox();
+    init_utils();
+  }
+});
+
+// src/commands/init.ts
+var init_exports = {};
+__export(init_exports, {
+  init: () => init
+});
+import fs14 from "fs-extra";
+import path17 from "path";
+import pc12 from "picocolors";
+import prompts4 from "prompts";
+async function init(options) {
+  let { name, pluginType = "business", theme = DEFAULT_CONFIG.THEME, projectType, includeApp, includePlugin, cwd } = options;
+  const response = await prompts4([
     // ... (prompts remain the same)
     {
       type: name ? null : "text",
@@ -1687,32 +1785,32 @@ async function init(options) {
   const isAppIncluded = finalIncludeApp;
   const isPluginIncluded = finalIncludePlugin;
   const rootDir = cwd || process.cwd();
-  const targetDir = path13.resolve(rootDir, name);
-  if (fs11.existsSync(targetDir)) {
+  const targetDir = path17.resolve(rootDir, name);
+  if (fs14.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"}`));
+  logger.info(`\u6B63\u5728\u521D\u59CB\u5316\u9879\u76EE: ${pc12.bold(name)}...`);
+  logger.info(pc12.gray(`\u7C7B\u578B: ${projectType} | \u4E3B\u9898: ${theme || "N/A"}`));
   console.log("");
   try {
     const myCliRoot = await getCliRoot();
-    const cliPkg = await fs11.readJson(path13.join(myCliRoot, "package.json"));
+    const cliPkg = await fs14.readJson(path17.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 kernelVersionFile = path17.join(myCliRoot, SANDBOX_CONFIG.LOCK_FILE);
+    if (fs14.existsSync(kernelVersionFile)) {
+      config.coreVersion = (await fs14.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)) {
+      const srcDir = path17.join(myCliRoot, "templates", templateName);
+      if (!fs14.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);
+      await fs14.ensureDir(destDir);
       const templateData = {
-        name: path13.basename(destDir),
+        name: path17.basename(destDir),
         projectName: name,
         // Original project name from CLI argument
         projectTitle: name.split("-").map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join(" "),
@@ -1740,12 +1838,12 @@ async function init(options) {
       await renderTemplate("monorepo", targetDir, { name });
       if (isAppIncluded) {
         spinner.text = "\u6B63\u5728\u751F\u6210 Host App...";
-        const appDir = path13.join(targetDir, "apps", "main");
+        const appDir = path17.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");
+        const pluginDir = path17.join(targetDir, "plugins", "plugin-demo");
         await renderTemplate("plugin", pluginDir, {
           name: "@chatbi-v/plugin-demo",
           pluginId: "demo",
@@ -1787,15 +1885,15 @@ async function init(options) {
     const cliConfig = {
       coreVersion: kernelVersion
     };
-    await fs11.writeJson(path13.join(targetDir, "chatbi.config.json"), cliConfig, { spaces: 2 });
+    await fs14.writeJson(path17.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!"))}
+      `${pc12.green(pc12.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")}`,
+${pc12.white("\u63A5\u4E0B\u6765\u4F60\u53EF\u4EE5:")}
+${pc12.cyan(`  cd ${name}`)}
+${pc12.cyan("  pnpm install")}
+${pc12.cyan("  pnpm dev")}`,
       "Success"
     );
   } catch (error) {
@@ -1807,55 +1905,11 @@ var init_init = __esm({
   "src/commands/init.ts"() {
     "use strict";
     init_esm_shims();
-    init_utils();
-    init_sync();
-    init_constants();
     init_config();
+    init_constants();
     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();
+    init_sync();
   }
 });
 
@@ -1864,14 +1918,14 @@ var bench_exports = {};
 __export(bench_exports, {
   bench: () => bench
 });
-import pc15 from "picocolors";
 import fs17 from "fs-extra";
+import os3 from "os";
 import path20 from "path";
-import os2 from "os";
+import pc15 from "picocolors";
 async function bench() {
   logger.info("\u6B63\u5728\u542F\u52A8 CLI \u6027\u80FD\u57FA\u51C6\u6D4B\u8BD5...");
   const results = [];
-  const tmpDir = path20.join(os2.tmpdir(), `chatbi-bench-${Date.now()}`);
+  const tmpDir = path20.join(os3.tmpdir(), `chatbi-bench-${Date.now()}`);
   await fs17.ensureDir(tmpDir);
   try {
     const initSpinner = createSpinner("\u6B63\u5728\u6D4B\u8BD5: \u521D\u59CB\u5316\u63D2\u4EF6\u9879\u76EE (init)...").start();
@@ -1934,54 +1988,104 @@ var init_bench = __esm({
 
 // src/index.ts
 init_esm_shims();
-init_build();
+import boxen2 from "boxen";
 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);
-}
+import pc16 from "picocolors";
 
-// src/index.ts
-init_init();
+// package.json
+var package_default = {
+  name: "@chatbi-v/cli",
+  version: "2.1.8",
+  description: "Standardized CLI tooling for ChatBI Monorepo",
+  type: "module",
+  main: "dist/index.js",
+  module: "dist/index.js",
+  types: "dist/index.d.ts",
+  exports: {
+    ".": {
+      types: "./dist/index.d.ts",
+      import: "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  bin: {
+    "chatbi-cli": "./bin/chatbi-cli.js"
+  },
+  files: [
+    "dist",
+    "bin",
+    "templates"
+  ],
+  publishConfig: {
+    access: "public"
+  },
+  scripts: {
+    build: "tsup",
+    dev: "tsup --watch",
+    test: "vitest"
+  },
+  dependencies: {
+    boxen: "^8.0.1",
+    cac: "^6.7.14",
+    execa: "^8.0.1",
+    "fast-glob": "^3.3.3",
+    figlet: "^1.9.4",
+    "fs-extra": "^11.2.0",
+    "gradient-string": "^3.0.0",
+    handlebars: "^4.7.8",
+    jiti: "^2.6.1",
+    ora: "^7.0.1",
+    picocolors: "^1.0.0",
+    prompts: "^2.4.2",
+    tsup: "^8.5.1",
+    typescript: "^5.0.0",
+    vite: "^5.4.21"
+  },
+  devDependencies: {
+    "@types/boxen": "^3.0.5",
+    "@types/figlet": "^1.7.0",
+    "@types/fs-extra": "^11.0.0",
+    "@types/gradient-string": "^1.1.6",
+    "@types/node": "^20.0.0",
+    "@types/prompts": "^2.4.9",
+    "@vitest/coverage-v8": "1.6.1",
+    tsup: "^8.5.1",
+    vitest: "^1.0.0"
+  }
+};
 
 // src/commands/add.ts
 init_esm_shims();
-init_utils();
 init_config();
 init_constants();
 init_SandboxRenderer();
-import fs12 from "fs-extra";
-import path14 from "path";
-import pc8 from "picocolors";
-import prompts3 from "prompts";
-import { createRequire as createRequire3 } from "module";
+init_utils();
+import fs4 from "fs-extra";
+import { createRequire as createRequire2 } from "module";
+import path6 from "path";
+import pc2 from "picocolors";
+import prompts from "prompts";
 import { fileURLToPath as fileURLToPath3 } from "url";
-var _require2 = createRequire3(import.meta.url);
+var _require2 = createRequire2(import.meta.url);
 var _filename2 = fileURLToPath3(import.meta.url);
-var _dirname2 = path14.dirname(_filename2);
+var _dirname2 = path6.dirname(_filename2);
 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)) {
+  const pkgPath = path6.join(cwd, "package.json");
+  if (!fs4.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 pkg = await fs4.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([
+  const response = await prompts([
     {
       type: name ? null : "text",
       name: "pluginName",
@@ -2026,12 +2130,12 @@ async function add(options) {
     cleanName = cleanName.replace(/-plugin$/, "");
   }
   const folderName = cleanName.startsWith("plugin-") ? cleanName : `plugin-${cleanName}`;
-  const pluginDir = path14.resolve(cwd, "plugins", folderName);
-  if (fs12.existsSync(pluginDir)) {
+  const pluginDir = path6.resolve(cwd, "plugins", folderName);
+  if (fs4.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 spinner = createSpinner(`\u6B63\u5728\u6DFB\u52A0\u65B0\u63D2\u4EF6: ${pc2.bold(name)}...`).start();
   const targetDir = pluginDir;
   spinner.text = "\u6B63\u5728\u52A0\u8F7D\u914D\u7F6E...";
   const config = await ConfigManager.loadConfig(cwd);
@@ -2057,199 +2161,95 @@ async function add(options) {
     tsconfigPath: `../../${SANDBOX_CONFIG.DIRS.CACHE}/tsconfig.json`
   };
   const myCliRoot = await getCliRoot();
-  let templateDir = myCliRoot ? path14.join(myCliRoot, "templates/plugin") : "";
+  let templateDir = myCliRoot ? path6.join(myCliRoot, "templates/plugin") : "";
   if (process.env.NODE_ENV === "test" && !templateDir) {
     templateDir = "/mock/templates/plugin";
   }
   if (process.env.NODE_ENV === "test") {
-    spinner.succeed(`\u63D2\u4EF6 ${pc8.bold(name)} \u6DFB\u52A0\u6210\u529F\uFF01`);
-    console.log(`\u63D2\u4EF6 ${pc8.bold(name)} \u6DFB\u52A0\u6210\u529F\uFF01`);
+    spinner.succeed(`\u63D2\u4EF6 ${pc2.bold(name)} \u6DFB\u52A0\u6210\u529F\uFF01`);
+    console.log(`\u63D2\u4EF6 ${pc2.bold(name)} \u6DFB\u52A0\u6210\u529F\uFF01`);
     console.log("\u2728 \u63D2\u4EF6\u521B\u5EFA\u6210\u529F!");
     return;
   }
-  if (!templateDir || !fs12.existsSync(templateDir)) {
+  if (!templateDir || !fs4.existsSync(templateDir)) {
     spinner.fail("\u627E\u4E0D\u5230\u63D2\u4EF6\u6A21\u677F");
     throw new Error(`\u627E\u4E0D\u5230\u63D2\u4EF6\u6A21\u677F: ${templateDir || "undefined"}`);
   }
   spinner.text = "\u6B63\u5728\u751F\u6210\u63D2\u4EF6\u6587\u4EF6...";
   await SandboxRenderer.renderDirectory(templateDir, targetDir, data);
-  spinner.succeed(`\u63D2\u4EF6 ${pc8.bold(name)} \u6DFB\u52A0\u6210\u529F\uFF01`);
+  spinner.succeed(`\u63D2\u4EF6 ${pc2.bold(name)} \u6DFB\u52A0\u6210\u529F\uFF01`);
   printBox(
-    `${pc8.green(pc8.bold("\u2728 \u63D2\u4EF6\u521B\u5EFA\u6210\u529F!"))}
+    `${pc2.green(pc2.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)}
+${pc2.white("\u9879\u76EE\u8DEF\u5F84: ")} ${pc2.cyan(`plugins/${folderName}`)}
+${pc2.white("\u63D2\u4EF6 ID:   ")} ${pc2.cyan(cleanName)}
+${pc2.white("\u63D2\u4EF6\u7C7B\u578B: ")} ${pc2.cyan(type)}
 
-${pc8.white("\u63A5\u4E0B\u6765\u4F60\u53EF\u4EE5:")}
-${pc8.cyan("  pnpm dev")}  \u542F\u52A8\u5F00\u53D1\u73AF\u5883\u67E5\u770B\u6548\u679C`,
+${pc2.white("\u63A5\u4E0B\u6765\u4F60\u53EF\u4EE5:")}
+${pc2.cyan("  pnpm dev")}  \u542F\u52A8\u5F00\u53D1\u73AF\u5883\u67E5\u770B\u6548\u679C`,
     "Plugin Created"
   );
 }
 
-// src/commands/gl.ts
+// src/index.ts
+init_build();
+
+// src/commands/clean.ts
+init_esm_shims();
+init_sandbox();
+async function clean(options) {
+  const cwd = process.cwd();
+  await Sandbox.clean(cwd, options.deep);
+}
+
+// src/commands/dev.ts
+init_esm_shims();
+init_corekit();
+async function dev(options = {}) {
+  const cwd = process.cwd();
+  await CoreKit.startDev(cwd, options);
+}
+
+// src/commands/discover.ts
 init_esm_shims();
+init_corekit();
 init_utils();
-import 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;
+import pc7 from "picocolors";
+async function discover() {
   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;
+  const spinner = createSpinner("\u6B63\u5728\u626B\u63CF\u9879\u76EE\u4E2D\u7684\u63D2\u4EF6...").start();
+  const plugins = await CoreKit.discoverPlugins(cwd);
+  if (plugins.length === 0) {
+    spinner.warn("\u672A\u53D1\u73B0\u4EFB\u4F55\u63D2\u4EF6");
+    logger.info(pc7.gray("\u8BF7\u786E\u4FDD\u63D2\u4EF6\u4F4D\u4E8E plugins/ \u76EE\u5F55\u4E0B\uFF0C\u4E14\u5305\u542B package.json\u3002"));
+  } else {
+    spinner.succeed(`\u53D1\u73B0\u4E86 ${pc7.cyan(plugins.length)} \u4E2A\u63D2\u4EF6`);
+    const pluginList = plugins.map((p) => `- ${pc7.bold(p.name)} ${pc7.gray(`(${p.id})`)}
+  ${pc7.gray(p.path)}`).join("\n\n");
+    printBox(
+      `${pc7.green(pc7.bold("\u2728 \u63D2\u4EF6\u626B\u63CF\u7ED3\u679C"))}
+
+${pluginList}`,
+      "Plugin Discovery"
+    );
   }
-  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";
+init_sandbox();
+init_utils();
 import glob from "fast-glob";
+import fs12 from "fs-extra";
+import path14 from "path";
+import pc9 from "picocolors";
 async function doctor(options = {}) {
   logger.info("\u6B63\u5728\u8BCA\u65AD\u9879\u76EE\u5065\u5EB7\u72B6\u51B5...\n");
   const cwd = process.cwd();
   let hasIssues = false;
   const issues = [];
-  logger.info(pc10.bold("Step 1: \u68C0\u67E5\u57FA\u7840\u73AF\u5883..."));
+  logger.info(pc9.bold("Step 1: \u68C0\u67E5\u57FA\u7840\u73AF\u5883..."));
   const nodeVersion = process.version;
   if (parseInt(nodeVersion.slice(1).split(".")[0]) < 18) {
     logger.error(`Node.js \u7248\u672C\u592A\u4F4E: ${nodeVersion} (\u8981\u6C42 >=18)`);
@@ -2259,47 +2259,47 @@ async function doctor(options = {}) {
     logger.success(`Node.js \u7248\u672C: ${nodeVersion}`);
   }
   try {
-    const { execa: execa6 } = await import("execa");
-    const { stdout: pnpmVer } = await execa6("pnpm", ["-v"]);
+    const { execa: execa7 } = await import("execa");
+    const { stdout: pnpmVer } = await execa7("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..."));
+  logger.info(pc9.bold("\nStep 2: \u68C0\u67E5\u5185\u6838\u6C99\u7BB1\u73AF\u5883..."));
   const version = await CoreKit.resolveVersion(cwd);
   const versionPath = Sandbox.getVersionPath(version);
-  if (!fs14.existsSync(versionPath)) {
+  if (!fs12.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`));
+    console.log(pc9.gray(`   \u5EFA\u8BAE\u8FD0\u884C 'chatbi sync' \u6216 'chatbi use ${version}' \u8FDB\u884C\u5B89\u88C5\u3002`));
     hasIssues = true;
     issues.push(`\u5185\u6838\u6C99\u7BB1\u672A\u5B89\u88C5 (${version})`);
   } else {
     logger.success(`\u5185\u6838\u6C99\u7BB1\u5C31\u7EEA (\u7248\u672C: ${version})`);
-    const sandboxNm = path16.join(versionPath, "node_modules");
-    if (!fs14.existsSync(sandboxNm)) {
+    const sandboxNm = path14.join(versionPath, "node_modules");
+    if (!fs12.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))) {
+      if (!fs12.existsSync(path14.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.info(pc9.bold("\nStep 3: \u68C0\u67E5\u865A\u62DF\u4F9D\u8D56\u6620\u5C04..."));
+  const chatbiDir = path14.join(cwd, ".chatbi");
+  if (!fs12.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)) {
+    const pathsJson = path14.join(chatbiDir, "tsconfig.paths.json");
+    const aliasJson = path14.join(chatbiDir, "vite.alias.json");
+    if (!fs12.existsSync(pathsJson) || !fs12.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");
@@ -2307,10 +2307,10 @@ async function doctor(options = {}) {
       logger.success("\u865A\u62DF\u4F9D\u8D56\u914D\u7F6E\u5DF2\u751F\u6210");
     }
   }
-  const tsConfigPath = path16.join(cwd, "tsconfig.json");
-  if (fs14.existsSync(tsConfigPath)) {
+  const tsConfigPath = path14.join(cwd, "tsconfig.json");
+  if (fs12.existsSync(tsConfigPath)) {
     try {
-      const tsConfig = await fs14.readJson(tsConfigPath);
+      const tsConfig = await fs12.readJson(tsConfigPath);
       const extendsPath = tsConfig.extends;
       const expectedPaths = ["./.chatbi/tsconfig.paths.json", ".chatbi/tsconfig.paths.json"];
       let hasExtend = false;
@@ -2330,14 +2330,14 @@ async function doctor(options = {}) {
       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");
+  const viteConfigPath = path14.join(cwd, "vite.config.ts");
+  if (fs12.existsSync(viteConfigPath)) {
+    const content = await fs12.readFile(viteConfigPath, "utf-8");
     if (!content.includes("vite.alias.json")) {
       logger.warn("vite.config.ts \u53EF\u80FD\u672A\u52A0\u8F7D\u865A\u62DF\u522B\u540D\u914D\u7F6E");
     }
   }
-  logger.info(pc10.bold("\nStep 4: \u626B\u63CF\u4EE3\u7801\u89C4\u5219..."));
+  logger.info(pc9.bold("\nStep 4: \u626B\u63CF\u4EE3\u7801\u89C4\u5219..."));
   const rules = [
     {
       id: "plugin-lifecycle-init",
@@ -2357,7 +2357,7 @@ async function doctor(options = {}) {
   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");
+      const content = await fs12.readFile(file, "utf-8");
       for (const rule of rules) {
         if (rule.pattern.test(content)) {
           codeIssues.push({
@@ -2373,7 +2373,7 @@ async function doctor(options = {}) {
       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);
+        const relativePath = path14.relative(cwd, issue.file);
         issues.push(`\u4EE3\u7801\u89C4\u8303 [${issue.ruleId}]: ${relativePath}`);
       });
     } else {
@@ -2382,26 +2382,26 @@ async function doctor(options = {}) {
   }
   if (!hasIssues) {
     printBox(
-      pc10.green(pc10.bold("\u2728 \u8BCA\u65AD\u5B8C\u6210\uFF1A\u9879\u76EE\u4E00\u5207\u6B63\u5E38\uFF01")),
+      pc9.green(pc9.bold("\u2728 \u8BCA\u65AD\u5B8C\u6210\uFF1A\u9879\u76EE\u4E00\u5207\u6B63\u5E38\uFF01")),
       "Doctor Report"
     );
   } else {
-    const issueList = issues.map((i) => pc10.red(`\u2022 ${i}`)).join("\n");
+    const issueList = issues.map((i) => pc9.red(`\u2022 ${i}`)).join("\n");
     printBox(
-      `${pc10.yellow(pc10.bold("\u26A0\uFE0F \u8BCA\u65AD\u5B8C\u6210\uFF1A\u53D1\u73B0\u4EE5\u4E0B\u95EE\u9898"))}
+      `${pc9.yellow(pc9.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")}`,
+${pc9.cyan("\u5EFA\u8BAE\u6839\u636E\u63D0\u793A\u8FDB\u884C\u4FEE\u590D")}`,
       "Doctor Report"
     );
     if (options.fix) {
       if (codeIssues.length > 0) {
         const fixSpinner = createSpinner("\u6B63\u5728\u4FEE\u590D\u4EE3\u7801\u89C4\u8303\u95EE\u9898...").start();
         for (const issue of codeIssues) {
-          const content = await fs14.readFile(issue.file, "utf-8");
+          const content = await fs12.readFile(issue.file, "utf-8");
           const newContent = issue.rule.fix(content);
-          await fs14.writeFile(issue.file, newContent);
+          await fs12.writeFile(issue.file, newContent);
         }
         fixSpinner.succeed("\u4EE3\u7801\u4FEE\u590D\u5B8C\u6210");
       }
@@ -2413,28 +2413,198 @@ ${pc10.cyan("\u5EFA\u8BAE\u6839\u636E\u63D0\u793A\u8FDB\u884C\u4FEE\u590D")}`,
   }
 }
 
-// src/commands/discover.ts
+// src/index.ts
+init_fetch();
+
+// src/commands/gl.ts
 init_esm_shims();
-init_corekit();
 init_utils();
+import { execa as execa5 } from "execa";
+import fs13 from "fs-extra";
+import path16 from "path";
 import pc11 from "picocolors";
-async function discover() {
+import prompts3 from "prompts";
+async function gl(options) {
+  const { type: initialType, prompt: initialPrompt } = options;
   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"))}
+  const pkgPath = path16.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 prompts3([
+    {
+      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: ${pc11.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.
 
-${pluginList}`,
-      "Plugin Discovery"
-    );
+[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 execa5("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(pc11.yellow("\n\u{1F4DD} AI \u9700\u8981\u66F4\u591A\u4FE1\u606F\u4EE5\u7EE7\u7EED:"));
+          const answers = await prompts3(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(pc11.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_init();
+
+// src/commands/install.ts
+init_esm_shims();
+init_sandbox();
+init_utils();
+import { execa as execa6 } from "execa";
+import fs15 from "fs-extra";
+import path18 from "path";
+import pc13 from "picocolors";
+async function install(target) {
+  if (target.endsWith(".tgz") && fs15.existsSync(target)) {
+    const spinner = createSpinner(`\u6B63\u5728\u5B89\u88C5\u672C\u5730\u79BB\u7EBF\u5305: ${pc13.bold(target)}...`).start();
+    try {
+      const tgzPath = path18.resolve(target);
+      const match = path18.basename(target).match(/chatbi-core-(.+)\.tgz/);
+      let version = "unknown";
+      if (match) {
+        version = match[1];
+      }
+      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 fs15.ensureDir(versionRoot);
+      spinner.text = "\u6B63\u5728\u89E3\u538B\u6587\u4EF6...";
+      await execa6("tar", ["-xzf", tgzPath, "-C", versionRoot]);
+      spinner.succeed(`\u672C\u5730\u5305\u5DF2\u5B89\u88C5\u81F3\u6C99\u7BB1: ${version}`);
+      spinner.text = "\u6B63\u5728\u51C6\u5907\u5185\u6838\u73AF\u5883...";
+      await Sandbox.prepare(version);
+      spinner.succeed("\u5185\u6838\u73AF\u5883\u5C31\u7EEA");
+      printBox(
+        pc13.green(pc13.bold("\u2728 \u672C\u5730\u5185\u6838\u5B89\u88C5\u6210\u529F!")) + "\n\n" + pc13.white("\u7248\u672C: ") + pc13.cyan(version) + "\n" + pc13.white("\u8DEF\u5F84: ") + pc13.gray(Sandbox.getVersionPath(version)),
+        "Install Success"
+      );
+    } catch (e) {
+      spinner.fail("\u5B89\u88C5\u5931\u8D25");
+      throw e;
+    }
+  } else {
+    const { fetch: fetch2 } = await Promise.resolve().then(() => (init_fetch(), fetch_exports));
+    await fetch2(target);
   }
 }
 
@@ -2443,7 +2613,7 @@ init_esm_shims();
 init_corekit();
 init_sandbox();
 init_utils();
-import pc12 from "picocolors";
+import pc14 from "picocolors";
 async function ls() {
   const versions = await CoreKit.listVersions();
   const currentVersion = await CoreKit.resolveVersion(process.cwd());
@@ -2457,36 +2627,39 @@ async function ls() {
       const isProjectCurrent = v === currentVersion;
       let prefix = "  ";
       if (isProjectCurrent) {
-        prefix = pc12.green(" *");
+        prefix = pc14.green(" *");
       } else if (isGlobalCurrent) {
-        prefix = pc12.blue(" >");
+        prefix = pc14.blue(" >");
       }
       let suffix = "";
       if (isProjectCurrent && isGlobalCurrent) {
-        suffix = pc12.gray(" (\u5F53\u524D\u9879\u76EE & \u5168\u5C40)");
+        suffix = pc14.gray(" (\u5F53\u524D\u9879\u76EE & \u5168\u5C40)");
       } else if (isProjectCurrent) {
-        suffix = pc12.gray(" (\u5F53\u524D\u9879\u76EE)");
+        suffix = pc14.gray(" (\u5F53\u524D\u9879\u76EE)");
       } else if (isGlobalCurrent) {
-        suffix = pc12.gray(" (\u5168\u5C40)");
+        suffix = pc14.gray(" (\u5168\u5C40)");
       }
-      return `${prefix} ${pc12.white(v)}${suffix}`;
+      return `${prefix} ${pc14.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"),
+      list + pc14.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/index.ts
+init_sync();
+
 // src/commands/use.ts
 init_esm_shims();
-init_sandbox();
 init_corekit();
-init_sync();
+init_sandbox();
 init_utils();
-import fs15 from "fs-extra";
-import path17 from "path";
+init_sync();
+import fs16 from "fs-extra";
+import path19 from "path";
 async function use(version, options = {}) {
   const versions = await CoreKit.listVersions();
   if (!versions.includes(version)) {
@@ -2498,123 +2671,13 @@ async function use(version, options = {}) {
     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");
+    const versionFilePath = path19.join(cwd, ".chatbi-version");
+    await fs16.writeFile(versionFilePath, version, "utf-8");
     logger.success(`\u5DF2\u5207\u6362\u5F53\u524D\u9879\u76EE\u5185\u6838\u7248\u672C\u4E3A: ${version}`);
   }
   await sync({ version, force: false });
 }
 
-// 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.1.6",
-  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");
@@ -2634,12 +2697,18 @@ var showHeader = () => {
 };
 var wrapAction = (action, commandName) => {
   return async (...args) => {
+    const updateCheckPromise = checkForUpdates(package_default.version);
     showHeader();
     try {
       await action(...args);
     } catch (e) {
       logger.error(`${commandName} \u6267\u884C\u5931\u8D25`, e);
       process.exit(1);
+    } finally {
+      const latestVersion = await updateCheckPromise;
+      if (latestVersion) {
+        printUpdateNotification(package_default.version, latestVersion);
+      }
     }
   };
 };
@@ -2695,3 +2764,12 @@ if (process.argv.length <= 2) {
 } else {
   cli.parse();
 }
+var main = async () => {
+  if (process.argv.includes("--help") || process.argv.includes("-h") || process.argv.includes("--version") || process.argv.includes("-v")) {
+    const latestVersion = await checkForUpdates(package_default.version);
+    if (latestVersion) {
+      printUpdateNotification(package_default.version, latestVersion);
+    }
+  }
+};
+main();