@agile-team/robot-cli 1.1.12 → 2.1.0

package/dist/index.js

@@ -0,0 +1,1720 @@
+// src/index.ts
+import { readFileSync } from "fs";
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
+import chalk4 from "chalk";
+import boxen from "boxen";
+import inquirer2 from "inquirer";
+import { Command } from "commander";
+
+// src/create.ts
+import fs3 from "fs-extra";
+import path3 from "path";
+import chalk2 from "chalk";
+import inquirer from "inquirer";
+import ora from "ora";
+import { execSync as execSync2 } from "child_process";
+
+// src/download.ts
+import fs from "fs-extra";
+import path from "path";
+import os from "os";
+import extract from "extract-zip";
+
+// src/config/templates.config.ts
+var TEMPLATE_CATEGORIES = {
+  frontend: {
+    name: "\u{1F3A8} \u524D\u7AEF\u9879\u76EE",
+    stacks: {
+      vue: {
+        name: "Vue.js",
+        patterns: {
+          monolith: {
+            name: "\u5355\u4F53\u5E94\u7528",
+            templates: {
+              "robot-admin": {
+                name: "Robot Admin \u5B8C\u6574\u7248",
+                description: "\u5305\u542B50+\u5B8C\u6574\u793A\u4F8B\u3001\u6743\u9650\u7BA1\u7406\u3001\u56FE\u8868\u7EC4\u4EF6\u3001\u6700\u4F73\u5B9E\u8DF5\u7B49\u7B49",
+                repoUrl: "https://github.com/ChenyCHENYU/Robot_Admin",
+                features: [
+                  "Naive UI",
+                  "Vue Router",
+                  "Pinia",
+                  "\u6743\u9650\u7BA1\u7406",
+                  "\u52A8\u6001\u8DEF\u7531",
+                  "\u56FE\u8868\u7EC4\u4EF6",
+                  "\u6027\u80FD\u4F18\u5316\u7B49\u7B49"
+                ],
+                version: "full"
+              },
+              "robot-admin-base": {
+                name: "Robot Admin \u7CBE\u7B80\u7248",
+                description: "\u57FA\u7840\u67B6\u6784\u3001\u6838\u5FC3\u529F\u80FD\u3001\u5FEB\u901F\u542F\u52A8",
+                repoUrl: "https://github.com/ChenyCHENYU/Robot_Admin_Base",
+                features: ["Naive UI", "Vue Router", "Pinia", "\u57FA\u7840\u5E03\u5C40"],
+                version: "base"
+              }
+            }
+          },
+          monorepo: {
+            name: "Monorepo \u67B6\u6784",
+            templates: {
+              "robot-monorepo": {
+                name: "Robot Monorepo",
+                description: "bun workspace + Monorepo \u591A\u5305\u7BA1\u7406\u67B6\u6784",
+                repoUrl: "https://github.com/ChenyCHENYU/Robot_Admin",
+                branch: "monorepo",
+                features: [
+                  "bun workspace",
+                  "Monorepo",
+                  "\u591A\u5305\u7BA1\u7406",
+                  "\u5171\u4EAB\u7EC4\u4EF6"
+                ],
+                version: "full"
+              }
+            }
+          },
+          microfrontend: {
+            name: "\u5FAE\u524D\u7AEF\u67B6\u6784",
+            templates: {
+              "robot-micro-app": {
+                name: "Robot MicroApp \u5FAE\u524D\u7AEF",
+                description: "\u57FA\u4E8E MicroApp \u7684\u5FAE\u524D\u7AEF\u67B6\u6784\u65B9\u6848",
+                repoUrl: "https://github.com/ChenyCHENYU/Robot_Admin",
+                branch: "micro-app",
+                features: [
+                  "MicroApp",
+                  "\u5FAE\u524D\u7AEF",
+                  "\u4E3B\u5B50\u5E94\u7528",
+                  "\u8DEF\u7531\u5171\u4EAB"
+                ],
+                version: "full"
+              },
+              "robot-module-federation": {
+                name: "Robot Module Federation \u6A21\u5757\u8054\u90A6",
+                description: "\u57FA\u4E8E Vite Module Federation \u7684\u6A21\u5757\u8054\u90A6\u65B9\u6848",
+                repoUrl: "https://github.com/ChenyCHENYU/Robot_Admin",
+                branch: "module-federation",
+                features: [
+                  "Module Federation",
+                  "\u6A21\u5757\u8054\u90A6",
+                  "Vite",
+                  "\u8FDC\u7A0B\u6A21\u5757"
+                ],
+                version: "full"
+              }
+            }
+          }
+        }
+      },
+      react: {
+        name: "React.js",
+        patterns: {
+          monolith: {
+            name: "\u5355\u4F53\u5E94\u7528",
+            templates: {
+              "robot-react": {
+                name: "Robot React \u5B8C\u6574\u7248",
+                description: "Ant Design + \u5B8C\u6574\u529F\u80FD\u6F14\u793A",
+                repoUrl: "https://github.com/ChenyCHENYU/Robot_React",
+                features: ["Ant Design", "React Router", "Redux Toolkit"],
+                version: "full"
+              },
+              "robot-react-base": {
+                name: "Robot React \u7CBE\u7B80\u7248",
+                description: "\u57FA\u7840React + \u6838\u5FC3\u529F\u80FD",
+                repoUrl: "https://github.com/ChenyCHENYU/Robot_React_Base",
+                features: ["React", "React Router", "\u57FA\u7840\u7EC4\u4EF6"],
+                version: "base"
+              }
+            }
+          }
+        }
+      }
+    }
+  },
+  mobile: {
+    name: "\u{1F4F1} \u79FB\u52A8\u7AEF\u9879\u76EE",
+    stacks: {
+      uniapp: {
+        name: "uni-app",
+        patterns: {
+          multiplatform: {
+            name: "\u591A\u7AEF\u5E94\u7528",
+            templates: {
+              "robot-uniapp": {
+                name: "Robot uni-app \u5B8C\u6574\u7248",
+                description: "\u591A\u7AEF\u9002\u914D + \u63D2\u4EF6\u5E02\u573A + \u5B8C\u6574\u793A\u4F8B",
+                repoUrl: "https://github.com/ChenyCHENYU/Robot_Uniapp",
+                features: ["\u591A\u7AEF\u53D1\u5E03", "uView UI", "\u63D2\u4EF6\u96C6\u6210"],
+                version: "full"
+              },
+              "robot-uniapp-base": {
+                name: "Robot uni-app \u7CBE\u7B80\u7248",
+                description: "\u57FA\u7840\u6846\u67B6 + \u6838\u5FC3\u529F\u80FD",
+                repoUrl: "https://github.com/ChenyCHENYU/Robot_Uniapp_Base",
+                features: ["\u57FA\u7840\u6846\u67B6", "\u8DEF\u7531\u914D\u7F6E"],
+                version: "base"
+              }
+            }
+          }
+        }
+      }
+    }
+  },
+  backend: {
+    name: "\u{1F680} \u540E\u7AEF\u9879\u76EE",
+    stacks: {
+      nestjs: {
+        name: "NestJS",
+        patterns: {
+          api: {
+            name: "API\u670D\u52A1",
+            templates: {
+              "robot-nest": {
+                name: "Robot NestJS \u5B8C\u6574\u7248",
+                description: "NestJS + TypeORM + JWT + Swagger + Redis + \u5B8C\u6574\u751F\u6001",
+                repoUrl: "https://github.com/ChenyCHENYU/Robot_Nest",
+                features: [
+                  "NestJS",
+                  "TypeORM",
+                  "JWT\u8BA4\u8BC1",
+                  "ApiFox\u6587\u6863",
+                  "Redis",
+                  "\u5FAE\u670D\u52A1"
+                ],
+                version: "full"
+              },
+              "robot-nest-base": {
+                name: "Robot NestJS \u7CBE\u7B80\u7248",
+                description: "\u57FA\u7840 NestJS + \u6838\u5FC3\u6A21\u5757",
+                repoUrl: "https://github.com/ChenyCHENYU/Robot_Nest_Base",
+                features: ["NestJS", "\u57FA\u7840\u8DEF\u7531", "\u9519\u8BEF\u5904\u7406"],
+                version: "base"
+              }
+            }
+          },
+          microservice: {
+            name: "\u5FAE\u670D\u52A1\u67B6\u6784",
+            templates: {
+              "robot-nest-micro": {
+                name: "Robot NestJS\u5FAE\u670D\u52A1\u7248",
+                description: "NestJS + \u5FAE\u670D\u52A1\u67B6\u6784 + gRPC + \u670D\u52A1\u53D1\u73B0",
+                repoUrl: "https://github.com/ChenyCHENYU/Robot_Nest_Micro",
+                features: ["NestJS", "\u5FAE\u670D\u52A1", "gRPC", "Redis", "\u670D\u52A1\u53D1\u73B0"],
+                version: "micro"
+              }
+            }
+          }
+        }
+      }
+    }
+  },
+  desktop: {
+    name: "\u{1F4BB} \u684C\u9762\u7AEF\u9879\u76EE",
+    stacks: {
+      electron: {
+        name: "Electron",
+        patterns: {
+          desktop: {
+            name: "\u684C\u9762\u5E94\u7528",
+            templates: {
+              "robot-electron": {
+                name: "Robot Electron \u5B8C\u6574\u7248",
+                description: "Vue3 + Electron + \u81EA\u52A8\u66F4\u65B0 + \u539F\u751F\u80FD\u529B",
+                repoUrl: "https://github.com/ChenyCHENYU/Robot_Electron",
+                features: ["Vue3", "Electron", "\u81EA\u52A8\u66F4\u65B0", "\u539F\u751FAPI"],
+                version: "full"
+              },
+              "robot-electron-base": {
+                name: "Robot Electron \u7CBE\u7B80\u7248",
+                description: "\u57FA\u7840Electron + Vue\u6846\u67B6",
+                repoUrl: "https://github.com/ChenyCHENYU/Robot_Electron_Base",
+                features: ["Vue3", "Electron", "\u57FA\u7840\u529F\u80FD"],
+                version: "base"
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+};
+
+// src/config/cli.config.ts
+var CACHE_DIR_NAME = "cache";
+var RECOMMENDED_TEMPLATE_KEYS = [
+  "robot-admin",
+  "robot-monorepo",
+  "robot-micro-app",
+  "robot-module-federation",
+  "robot-nest",
+  "robot-react"
+];
+var START_COMMAND_MAP = {
+  "robot-admin": "dev",
+  "robot-admin-base": "dev",
+  "robot-monorepo": "dev",
+  "robot-micro-app": "dev",
+  "robot-module-federation": "dev",
+  "robot-react": "start",
+  "robot-react-base": "start",
+  "robot-uniapp": "dev:h5",
+  "robot-uniapp-base": "dev:h5",
+  "robot-nest": "start:dev",
+  "robot-nest-base": "start:dev",
+  "robot-nest-micro": "start:dev",
+  "robot-electron": "electron:dev",
+  "robot-electron-base": "electron:dev"
+};
+
+// src/download.ts
+var CACHE_DIR = path.join(os.homedir(), ".robot-cli", CACHE_DIR_NAME);
+var CACHE_INDEX_PATH = path.join(CACHE_DIR, "index.json");
+function buildDownloadUrl(repoUrl, branch = "main") {
+  try {
+    const url = new URL(repoUrl);
+    const host = url.hostname;
+    const cleanUrl = repoUrl.replace(/\/+$/, "");
+    if (host === "github.com") return `${cleanUrl}/archive/refs/heads/${branch}.zip`;
+    if (host === "gitee.com")
+      return `${cleanUrl}/repository/archive/${branch}.zip`;
+    if (host === "gitlab.com") {
+      const name = cleanUrl.split("/").pop();
+      return `${cleanUrl}/-/archive/${branch}/${name}-${branch}.zip`;
+    }
+    return `${cleanUrl}/archive/refs/heads/${branch}.zip`;
+  } catch {
+    return `${repoUrl}/archive/refs/heads/${branch}.zip`;
+  }
+}
+function getCacheKey(repoUrl) {
+  let hash = 0;
+  for (let i = 0; i < repoUrl.length; i++) {
+    hash = (hash << 5) - hash + repoUrl.charCodeAt(i) | 0;
+  }
+  return Math.abs(hash).toString(36);
+}
+async function loadCacheIndex() {
+  try {
+    if (await fs.pathExists(CACHE_INDEX_PATH)) {
+      return await fs.readJson(CACHE_INDEX_PATH);
+    }
+  } catch {
+  }
+  return { version: 1, entries: {} };
+}
+async function saveCacheIndex(index) {
+  await fs.ensureDir(CACHE_DIR);
+  await fs.writeJson(CACHE_INDEX_PATH, index, { spaces: 2 });
+}
+async function getCachedTemplate(repoUrl) {
+  const key = getCacheKey(repoUrl);
+  const cachePath = path.join(CACHE_DIR, key);
+  if (await fs.pathExists(cachePath)) {
+    const pkgPath = path.join(cachePath, "package.json");
+    if (await fs.pathExists(pkgPath)) return cachePath;
+  }
+  return null;
+}
+async function saveToCache(repoUrl, sourcePath) {
+  try {
+    const key = getCacheKey(repoUrl);
+    const cachePath = path.join(CACHE_DIR, key);
+    await fs.ensureDir(CACHE_DIR);
+    await fs.remove(cachePath).catch(() => {
+    });
+    await fs.copy(sourcePath, cachePath);
+    const index = await loadCacheIndex();
+    const stat = await fs.stat(sourcePath);
+    index.entries[key] = {
+      repoUrl,
+      downloadedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      branch: "main",
+      size: stat.size
+    };
+    await saveCacheIndex(index);
+  } catch {
+  }
+}
+async function getCacheStats() {
+  const index = await loadCacheIndex();
+  const entries = Object.values(index.entries);
+  return {
+    count: entries.length,
+    totalSize: entries.reduce((sum, e) => sum + (e.size || 0), 0)
+  };
+}
+async function clearCache() {
+  await fs.remove(CACHE_DIR);
+}
+async function tryDownload(repoUrl, branch = "main", spinner) {
+  const url = new URL(repoUrl);
+  const host = url.hostname;
+  const mirrors = host === "github.com" ? [repoUrl, `https://ghproxy.com/${repoUrl}`] : [repoUrl];
+  for (let i = 0; i < mirrors.length; i++) {
+    const current = mirrors[i];
+    const isOriginal = current === repoUrl;
+    const sourceName = isOriginal ? `${host} \u5B98\u65B9` : `${host} \u955C\u50CF`;
+    try {
+      if (spinner) spinner.text = `\u{1F50D} \u8FDE\u63A5\u5230 ${sourceName}...`;
+      const downloadUrl = current.endsWith(".zip") ? current : buildDownloadUrl(current, branch);
+      if (spinner) spinner.text = `\u{1F4E6} \u4ECE ${sourceName} \u4E0B\u8F7D\u6A21\u677F...`;
+      const response = await fetch(downloadUrl, {
+        signal: AbortSignal.timeout(isOriginal ? 15e3 : 1e4),
+        headers: { "User-Agent": "Robot-CLI/2.0.0" }
+      });
+      if (!response.ok) {
+        if (response.status === 404) throw new Error(`\u4ED3\u5E93\u4E0D\u5B58\u5728: ${repoUrl}`);
+        throw new Error(`HTTP ${response.status}`);
+      }
+      if (spinner) {
+        const len = response.headers.get("content-length");
+        const sizeInfo = len ? `${(parseInt(len) / 1024 / 1024).toFixed(1)}MB ` : "";
+        spinner.text = `\u{1F4E6} \u4E0B\u8F7D\u4E2D... (${sizeInfo}from ${sourceName})`;
+      }
+      return { response, sourceName };
+    } catch (error) {
+      if (i === mirrors.length - 1) throw error;
+      if (spinner) spinner.text = `\u26A0\uFE0F  ${sourceName} \u8BBF\u95EE\u5931\u8D25\uFF0C\u5C1D\u8BD5\u5176\u4ED6\u6E90...`;
+      await new Promise((r) => setTimeout(r, 1e3));
+    }
+  }
+  throw new Error("\u6240\u6709\u4E0B\u8F7D\u6E90\u5747\u4E0D\u53EF\u7528");
+}
+async function downloadTemplate(template, options = {}) {
+  const { spinner, noCache } = options;
+  const branch = template.branch || "main";
+  if (!template?.repoUrl) {
+    throw new Error(`\u6A21\u677F\u914D\u7F6E\u65E0\u6548: ${JSON.stringify(template)}`);
+  }
+  try {
+    if (spinner) spinner.text = "\u{1F310} \u5F00\u59CB\u4E0B\u8F7D\u6700\u65B0\u6A21\u677F...";
+    const { response, sourceName } = await tryDownload(
+      template.repoUrl,
+      branch,
+      spinner
+    );
+    if (spinner) spinner.text = "\u{1F4BE} \u4FDD\u5B58\u4E0B\u8F7D\u6587\u4EF6...";
+    const timestamp = Date.now();
+    const tempZip = path.join(os.tmpdir(), `robot-template-${timestamp}.zip`);
+    const tempExtract = path.join(os.tmpdir(), `robot-extract-${timestamp}`);
+    const buffer = Buffer.from(await response.arrayBuffer());
+    await fs.writeFile(tempZip, buffer);
+    if (spinner) spinner.text = "\u{1F4C2} \u89E3\u538B\u6A21\u677F\u6587\u4EF6...";
+    await extract(tempZip, { dir: tempExtract });
+    if (spinner) spinner.text = "\u{1F50D} \u67E5\u627E\u9879\u76EE\u7ED3\u6784...";
+    const extractedItems = await fs.readdir(tempExtract);
+    const repoName = template.repoUrl.split("/").pop() || "";
+    const projectDir = extractedItems.find(
+      (item) => item === `${repoName}-${branch}` || item.endsWith(`-${branch}`) || item.endsWith("-main") || item.endsWith("-master") || item === repoName
+    );
+    if (!projectDir) {
+      throw new Error(
+        `\u89E3\u538B\u540E\u627E\u4E0D\u5230\u9879\u76EE\u76EE\u5F55\uFF0C\u53EF\u7528\u76EE\u5F55: ${extractedItems.join(", ")}`
+      );
+    }
+    const sourcePath = path.join(tempExtract, projectDir);
+    if (spinner) spinner.text = "\u2705 \u9A8C\u8BC1\u6A21\u677F\u5B8C\u6574\u6027...";
+    if (!fs.existsSync(path.join(sourcePath, "package.json"))) {
+      throw new Error("\u6A21\u677F\u7F3A\u5C11 package.json \u6587\u4EF6");
+    }
+    if (!noCache) {
+      saveToCache(template.repoUrl, sourcePath).catch(() => {
+      });
+    }
+    if (spinner) spinner.text = `\u{1F389} \u6A21\u677F\u4E0B\u8F7D\u5B8C\u6210 (via ${sourceName})`;
+    await fs.remove(tempZip).catch(() => {
+    });
+    return sourcePath;
+  } catch (downloadError) {
+    if (!noCache) {
+      const cached = await getCachedTemplate(template.repoUrl);
+      if (cached) {
+        if (spinner) spinner.text = "\u{1F4E6} \u7F51\u7EDC\u4E0D\u53EF\u7528\uFF0C\u4F7F\u7528\u7F13\u5B58\u6A21\u677F...";
+        console.log();
+        console.log(
+          `  ${import("chalk").then((c) => c.default.yellow("\u26A0\uFE0F  \u4F7F\u7528\u7F13\u5B58\u7248\u672C\uFF08\u975E\u6700\u65B0\uFF09"))}`
+        );
+        return cached;
+      }
+    }
+    try {
+      const tmpFiles = await fs.readdir(os.tmpdir());
+      for (const f of tmpFiles.filter(
+        (x) => x.includes("robot-template-") || x.includes("robot-extract-")
+      )) {
+        await fs.remove(path.join(os.tmpdir(), f)).catch(() => {
+        });
+      }
+    } catch {
+    }
+    let msg = `\u6A21\u677F\u4E0B\u8F7D\u5931\u8D25: ${downloadError.message}`;
+    if (downloadError.code === "ENOTFOUND") {
+      msg += "\n\n\u{1F4A1} \u5EFA\u8BAE:\n1. \u68C0\u67E5\u7F51\u7EDC\u8FDE\u63A5\n2. \u5982\u679C\u5728\u56FD\u5185\uFF0C\u5C1D\u8BD5\u4F7F\u7528\u79D1\u5B66\u4E0A\u7F51\n3. \u7A0D\u540E\u91CD\u8BD5";
+    }
+    throw new Error(msg);
+  }
+}
+
+// src/templates.ts
+var remoteTemplates = null;
+function getAllTemplates() {
+  const templates = {};
+  for (const category of Object.values(TEMPLATE_CATEGORIES)) {
+    for (const stack of Object.values(category.stacks)) {
+      for (const pattern of Object.values(stack.patterns)) {
+        Object.assign(templates, pattern.templates);
+      }
+    }
+  }
+  if (remoteTemplates) {
+    for (const [key, template] of Object.entries(remoteTemplates)) {
+      if (!templates[key]) {
+        templates[key] = template;
+      }
+    }
+  }
+  return templates;
+}
+function getTemplatesByCategory(categoryKey, stackKey, patternKey) {
+  const category = TEMPLATE_CATEGORIES[categoryKey];
+  if (!category) return {};
+  const stack = category.stacks[stackKey];
+  if (!stack) return {};
+  const pattern = stack.patterns[patternKey];
+  if (!pattern) return {};
+  return pattern.templates;
+}
+function searchTemplates(keyword) {
+  const all = getAllTemplates();
+  const results = {};
+  const lower = keyword.toLowerCase();
+  for (const [key, t] of Object.entries(all)) {
+    const haystack = `${t.name} ${t.description} ${t.features.join(" ")}`.toLowerCase();
+    if (haystack.includes(lower)) {
+      results[key] = t;
+    }
+  }
+  return results;
+}
+function getRecommendedTemplates() {
+  const all = getAllTemplates();
+  const recommended = {};
+  const keys = RECOMMENDED_TEMPLATE_KEYS;
+  for (const key of keys) {
+    if (all[key]) recommended[key] = all[key];
+  }
+  if (Object.keys(recommended).length < 4) {
+    for (const key of Object.keys(all)) {
+      if (!recommended[key] && Object.keys(recommended).length < 6) {
+        recommended[key] = all[key];
+      }
+    }
+  }
+  return recommended;
+}
+function getCategoryForTemplate(templateKey) {
+  for (const category of Object.values(TEMPLATE_CATEGORIES)) {
+    for (const stack of Object.values(category.stacks)) {
+      for (const pattern of Object.values(stack.patterns)) {
+        if (templateKey in pattern.templates) return category;
+      }
+    }
+  }
+  return void 0;
+}
+
+// src/utils.ts
+import fs2 from "fs-extra";
+import path2 from "path";
+import chalk from "chalk";
+import { execSync } from "child_process";
+function detectPackageManager() {
+  const managers = [];
+  const checks = ["bun", "pnpm", "yarn", "npm"];
+  for (const pm of checks) {
+    try {
+      execSync(`${pm} --version`, { stdio: "ignore" });
+      managers.push(pm);
+    } catch {
+    }
+  }
+  return managers.length > 0 ? managers : ["npm"];
+}
+function getGitUser() {
+  try {
+    return execSync("git config user.name", {
+      stdio: ["pipe", "pipe", "ignore"]
+    }).toString().trim();
+  } catch {
+    return "";
+  }
+}
+function validateProjectName(name) {
+  const errors = [];
+  if (!name || typeof name !== "string") {
+    return { valid: false, errors: ["\u9879\u76EE\u540D\u79F0\u4E0D\u80FD\u4E3A\u7A7A"] };
+  }
+  const t = name.trim();
+  if (t.length === 0) errors.push("\u9879\u76EE\u540D\u79F0\u4E0D\u80FD\u4E3A\u7A7A");
+  if (t.length > 214) errors.push("\u9879\u76EE\u540D\u79F0\u4E0D\u80FD\u8D85\u8FC7214\u4E2A\u5B57\u7B26");
+  if (t.toLowerCase() !== t) errors.push("\u9879\u76EE\u540D\u79F0\u53EA\u80FD\u5305\u542B\u5C0F\u5199\u5B57\u6BCD");
+  if (/^[._]/.test(t)) errors.push('\u9879\u76EE\u540D\u79F0\u4E0D\u80FD\u4EE5 "." \u6216 "_" \u5F00\u5934');
+  if (!/^[a-z0-9._-]+$/.test(t))
+    errors.push("\u9879\u76EE\u540D\u79F0\u53EA\u80FD\u5305\u542B\u5B57\u6BCD\u3001\u6570\u5B57\u3001\u70B9\u3001\u4E0B\u5212\u7EBF\u548C\u77ED\u6A2A\u7EBF");
+  const reserved = [
+    "node_modules",
+    "favicon.ico",
+    ".git",
+    ".env",
+    "package.json",
+    "npm",
+    "yarn",
+    "pnpm",
+    "bun",
+    "robot"
+  ];
+  if (reserved.includes(t)) errors.push(`"${t}" \u662F\u4FDD\u7559\u540D\u79F0\uFF0C\u8BF7\u4F7F\u7528\u5176\u4ED6\u540D\u79F0`);
+  return { valid: errors.length === 0, errors };
+}
+async function checkNetworkConnection(testUrl) {
+  const urls = testUrl ? [testUrl] : ["https://api.github.com", "https://www.npmjs.com"];
+  for (const url of urls) {
+    try {
+      const res = await fetch(url, {
+        method: "HEAD",
+        signal: AbortSignal.timeout(5e3)
+      });
+      if (res.ok) return true;
+    } catch {
+    }
+  }
+  return false;
+}
+async function checkForUpdates(packageName, currentVersion) {
+  try {
+    const res = await fetch(
+      `https://registry.npmjs.org/${packageName}/latest`,
+      {
+        signal: AbortSignal.timeout(3e3)
+      }
+    );
+    if (!res.ok) return null;
+    const data = await res.json();
+    return data.version !== currentVersion ? data.version : null;
+  } catch {
+    return null;
+  }
+}
+async function countFiles(dirPath) {
+  let count = 0;
+  const skip = /* @__PURE__ */ new Set(["node_modules", ".git", ".DS_Store"]);
+  async function walk(dir) {
+    const items = await fs2.readdir(dir);
+    for (const item of items) {
+      const full = path2.join(dir, item);
+      const stat = await fs2.stat(full);
+      if (stat.isDirectory()) {
+        if (!skip.has(item)) await walk(full);
+      } else {
+        count++;
+      }
+    }
+  }
+  await walk(dirPath);
+  return count;
+}
+async function copyTemplate(sourcePath, targetPath, spinner) {
+  if (!fs2.existsSync(sourcePath)) {
+    throw new Error(`\u6E90\u8DEF\u5F84\u4E0D\u5B58\u5728: ${sourcePath}`);
+  }
+  await fs2.ensureDir(targetPath);
+  if (spinner) spinner.text = "\u{1F4CA} \u7EDF\u8BA1\u6587\u4EF6\u6570\u91CF...";
+  const totalFiles = await countFiles(sourcePath);
+  if (spinner) spinner.text = `\u{1F4CB} \u5F00\u59CB\u590D\u5236 ${totalFiles} \u4E2A\u6587\u4EF6...`;
+  let copied = 0;
+  const skipDirs = /* @__PURE__ */ new Set([
+    "node_modules",
+    ".git",
+    ".DS_Store",
+    ".vscode",
+    ".idea"
+  ]);
+  async function copyDir(src, dest) {
+    const items = await fs2.readdir(src);
+    for (const item of items) {
+      const s = path2.join(src, item);
+      const d = path2.join(dest, item);
+      const stat = await fs2.stat(s);
+      if (stat.isDirectory()) {
+        if (skipDirs.has(item)) continue;
+        await fs2.ensureDir(d);
+        await copyDir(s, d);
+      } else {
+        await fs2.copy(s, d);
+        copied++;
+        if (spinner && (copied % 10 === 0 || copied === totalFiles)) {
+          const pct = Math.round(copied / totalFiles * 100);
+          spinner.text = `\u{1F4CB} \u590D\u5236\u4E2D... ${copied}/${totalFiles} (${pct}%)`;
+        }
+      }
+    }
+  }
+  await copyDir(sourcePath, targetPath);
+  if (spinner) spinner.text = `\u2705 \u6587\u4EF6\u590D\u5236\u5B8C\u6210 (${copied} \u4E2A\u6587\u4EF6)`;
+}
+async function installDependencies(projectPath, spinner, packageManager = "npm") {
+  try {
+    const pkgJson = path2.join(projectPath, "package.json");
+    if (!fs2.existsSync(pkgJson)) {
+      if (spinner) spinner.text = "\u26A0\uFE0F  \u8DF3\u8FC7\u4F9D\u8D56\u5B89\u88C5 (\u65E0 package.json)";
+      return;
+    }
+    const cmds = {
+      bun: "bun install",
+      pnpm: "pnpm install",
+      yarn: "yarn install",
+      npm: "npm install"
+    };
+    if (spinner) spinner.text = `\u{1F4E6} \u4F7F\u7528 ${packageManager} \u5B89\u88C5\u4F9D\u8D56...`;
+    execSync(cmds[packageManager], {
+      cwd: projectPath,
+      stdio: "ignore",
+      timeout: 3e5
+    });
+    if (spinner) spinner.text = `\u2705 \u4F9D\u8D56\u5B89\u88C5\u5B8C\u6210 (${packageManager})`;
+  } catch (error) {
+    if (spinner) spinner.text = "\u26A0\uFE0F  \u4F9D\u8D56\u5B89\u88C5\u5931\u8D25\uFF0C\u8BF7\u624B\u52A8\u5B89\u88C5";
+    console.log();
+    console.log(chalk.yellow("\u26A0\uFE0F  \u81EA\u52A8\u5B89\u88C5\u4F9D\u8D56\u5931\u8D25"));
+    console.log(chalk.dim(`   \u9519\u8BEF: ${error.message}`));
+    console.log();
+    console.log(chalk.blue("\u{1F4A1} \u8BF7\u624B\u52A8\u5B89\u88C5:"));
+    console.log(chalk.cyan(`   cd ${path2.basename(projectPath)}`));
+    console.log(chalk.cyan(`   ${packageManager} install`));
+    console.log();
+  }
+}
+async function generateProjectStats(projectPath) {
+  try {
+    const stats = {
+      files: 0,
+      directories: 0,
+      size: 0,
+      fileTypes: {}
+    };
+    const skip = /* @__PURE__ */ new Set(["node_modules", ".git", ".DS_Store"]);
+    async function walk(dir) {
+      const items = await fs2.readdir(dir);
+      for (const item of items) {
+        const full = path2.join(dir, item);
+        const stat = await fs2.stat(full);
+        if (stat.isDirectory()) {
+          if (!skip.has(item)) {
+            stats.directories++;
+            await walk(full);
+          }
+        } else {
+          stats.files++;
+          stats.size += stat.size;
+          const ext = path2.extname(item).toLowerCase();
+          if (ext) stats.fileTypes[ext] = (stats.fileTypes[ext] || 0) + 1;
+        }
+      }
+    }
+    await walk(projectPath);
+    return stats;
+  } catch {
+    return null;
+  }
+}
+function printProjectStats(stats) {
+  console.log(chalk.blue("\u{1F4CA} \u9879\u76EE\u7EDF\u8BA1:"));
+  console.log(`   \u6587\u4EF6\u6570\u91CF: ${chalk.cyan(String(stats.files))} \u4E2A`);
+  console.log(`   \u76EE\u5F55\u6570\u91CF: ${chalk.cyan(String(stats.directories))} \u4E2A`);
+  console.log(`   \u9879\u76EE\u5927\u5C0F: ${chalk.cyan(formatBytes(stats.size))}`);
+  const top = Object.entries(stats.fileTypes).sort(([, a], [, b]) => b - a).slice(0, 5);
+  if (top.length > 0) {
+    console.log("   \u4E3B\u8981\u6587\u4EF6\u7C7B\u578B:");
+    for (const [ext, count] of top) {
+      console.log(`     ${ext}: ${chalk.cyan(String(count))} \u4E2A`);
+    }
+  }
+}
+function formatBytes(bytes) {
+  if (bytes === 0) return "0 B";
+  const k = 1024;
+  const sizes = ["B", "KB", "MB", "GB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${parseFloat((bytes / Math.pow(k, i)).toFixed(2))} ${sizes[i]}`;
+}
+
+// src/create.ts
+async function createProject(projectName, options = {}) {
+  console.log();
+  console.log(chalk2.cyan("\u{1F680} Robot CLI - \u5F00\u59CB\u521B\u5EFA\u9879\u76EE"));
+  console.log();
+  let template;
+  if (options.from) {
+    template = {
+      key: "custom",
+      name: "Custom Template",
+      description: `\u6765\u81EA ${options.from}`,
+      repoUrl: options.from,
+      features: [],
+      version: "full"
+    };
+    console.log(chalk2.blue(`\u{1F4E6} \u4F7F\u7528\u81EA\u5B9A\u4E49\u6A21\u677F: ${chalk2.dim(options.from)}`));
+    console.log();
+  } else {
+    template = await selectTemplate(options.template);
+  }
+  const finalProjectName = await handleProjectName(projectName, template);
+  const projectConfig = await configureProject(options);
+  await confirmCreation(finalProjectName, template, projectConfig);
+  if (options.dryRun) {
+    console.log();
+    console.log(
+      chalk2.yellow("\u{1F50D} Dry Run \u6A21\u5F0F - \u4EE5\u4E0B\u4E3A\u9884\u89C8\u4FE1\u606F\uFF0C\u672A\u5B9E\u9645\u6267\u884C\u4EFB\u4F55\u64CD\u4F5C:")
+    );
+    console.log();
+    console.log(`  \u9879\u76EE\u8DEF\u5F84: ${chalk2.cyan(path3.resolve(finalProjectName))}`);
+    console.log(`  \u4E0B\u8F7D\u6765\u6E90: ${chalk2.dim(template.repoUrl)}`);
+    console.log("  \u6267\u884C\u6B65\u9AA4:");
+    console.log(chalk2.dim(`    1. \u4ECE ${template.repoUrl} \u4E0B\u8F7D\u6700\u65B0\u6A21\u677F`));
+    console.log(chalk2.dim(`    2. \u89E3\u538B\u5E76\u590D\u5236\u5230 ./${finalProjectName}`));
+    console.log(
+      chalk2.dim("    3. \u66F4\u65B0 package.json (name, description, author)")
+    );
+    let step = 4;
+    if (projectConfig.initGit) {
+      console.log(chalk2.dim(`    ${step}. \u521D\u59CB\u5316 Git \u4ED3\u5E93\u5E76\u63D0\u4EA4\u521D\u59CB\u4EE3\u7801`));
+      step++;
+    }
+    if (projectConfig.installDeps) {
+      console.log(
+        chalk2.dim(`    ${step}. \u4F7F\u7528 ${projectConfig.packageManager} \u5B89\u88C5\u4F9D\u8D56`)
+      );
+    }
+    console.log();
+    console.log(chalk2.dim("\u79FB\u9664 --dry-run \u53C2\u6570\u4EE5\u6267\u884C\u521B\u5EFA\u3002"));
+    console.log();
+    return;
+  }
+  await executeCreation(finalProjectName, template, projectConfig, options);
+}
+async function handleProjectName(projectName, template) {
+  if (projectName) {
+    const v = validateProjectName(projectName);
+    if (!v.valid) {
+      console.log(chalk2.red("\u274C \u9879\u76EE\u540D\u79F0\u4E0D\u5408\u6CD5:"));
+      v.errors.forEach((e) => console.log(chalk2.red(`   ${e}`)));
+      console.log();
+      const { newName } = await inquirer.prompt([
+        {
+          type: "input",
+          name: "newName",
+          message: "\u8BF7\u8F93\u5165\u65B0\u7684\u9879\u76EE\u540D\u79F0:",
+          validate: (input) => {
+            const r = validateProjectName(input);
+            return r.valid || r.errors[0];
+          }
+        }
+      ]);
+      return newName;
+    }
+    return projectName;
+  }
+  const defaultName = generateDefaultProjectName(template);
+  const { name } = await inquirer.prompt([
+    {
+      type: "input",
+      name: "name",
+      message: "\u8BF7\u8F93\u5165\u9879\u76EE\u540D\u79F0:",
+      default: defaultName,
+      validate: (input) => {
+        if (!input.trim()) return "\u9879\u76EE\u540D\u79F0\u4E0D\u80FD\u4E3A\u7A7A";
+        const r = validateProjectName(input);
+        return r.valid || r.errors[0];
+      }
+    }
+  ]);
+  return name;
+}
+function generateDefaultProjectName(template) {
+  const key = template.key || "project";
+  const ts = Date.now().toString().slice(-4);
+  const base = key.replace(/-(full|lite|base)$/, "");
+  return `my-${base}-${ts}`;
+}
+async function selectTemplate(templateOption) {
+  if (templateOption) {
+    const all = getAllTemplates();
+    if (all[templateOption]) {
+      return { key: templateOption, ...all[templateOption] };
+    }
+    console.log(chalk2.yellow(`\u26A0\uFE0F  \u6A21\u677F "${templateOption}" \u4E0D\u5B58\u5728`));
+    console.log();
+  }
+  return await selectTemplateMethod();
+}
+async function selectTemplateMethod() {
+  console.log();
+  console.log(chalk2.blue.bold("\u{1F3AF} \u9009\u62E9\u6A21\u677F\u521B\u5EFA\u65B9\u5F0F"));
+  console.log(chalk2.dim("\u8BF7\u9009\u62E9\u6700\u9002\u5408\u4F60\u7684\u6A21\u677F\u6D4F\u89C8\u65B9\u5F0F"));
+  console.log();
+  const { selectionMode } = await inquirer.prompt([
+    {
+      type: "list",
+      name: "selectionMode",
+      message: "\u6A21\u677F\u9009\u62E9\u65B9\u5F0F:",
+      choices: [
+        {
+          name: `\u25CF ${chalk2.bold("\u63A8\u8350\u6A21\u677F")} ${chalk2.dim("(\u5E38\u7528\u6A21\u677F\u5FEB\u901F\u9009\u62E9) - \u57FA\u4E8E\u56E2\u961F\u4F7F\u7528\u9891\u7387\u63A8\u8350\u7684\u70ED\u95E8\u6A21\u677F")}`,
+          value: "recommended"
+        },
+        { name: chalk2.dim("\u2500".repeat(70)), value: "sep1", disabled: true },
+        {
+          name: `\u25CF ${chalk2.bold("\u5206\u7C7B\u6A21\u677F")} ${chalk2.dim("(\u6309\u9879\u76EE\u7C7B\u578B\u5206\u7C7B\u9009\u62E9) - \u524D\u7AEF\u3001\u540E\u7AEF\u3001\u79FB\u52A8\u7AEF\u3001\u684C\u9762\u7AEF\u5206\u7C7B\u6D4F\u89C8")}`,
+          value: "category"
+        },
+        { name: chalk2.dim("\u2500".repeat(70)), value: "sep2", disabled: true },
+        {
+          name: `\u25CF ${chalk2.bold("\u641C\u7D22\u6A21\u677F")} ${chalk2.dim("(\u5173\u952E\u8BCD\u641C\u7D22) - \u901A\u8FC7\u6280\u672F\u6808\u3001\u529F\u80FD\u7279\u6027\u7B49\u5173\u952E\u8BCD\u5FEB\u901F\u67E5\u627E")}`,
+          value: "search"
+        },
+        { name: chalk2.dim("\u2500".repeat(70)), value: "sep3", disabled: true },
+        {
+          name: `\u25CF ${chalk2.bold("\u5168\u90E8\u6A21\u677F")} ${chalk2.dim("(\u67E5\u770B\u6240\u6709\u53EF\u7528\u6A21\u677F) - \u6309\u5206\u7C7B\u5C55\u793A\u6240\u6709\u53EF\u7528\u7684\u9879\u76EE\u6A21\u677F")}`,
+          value: "all"
+        }
+      ],
+      pageSize: 10
+    }
+  ]);
+  switch (selectionMode) {
+    case "recommended":
+      return await selectFromRecommended();
+    case "category":
+      return await selectByCategory();
+    case "search":
+      return await selectBySearch();
+    case "all":
+      return await selectFromAll();
+    default:
+      return await selectByCategory();
+  }
+}
+async function selectFromRecommended() {
+  const recommended = getRecommendedTemplates();
+  if (Object.keys(recommended).length === 0) {
+    console.log(chalk2.yellow("\u26A0\uFE0F  \u6682\u65E0\u63A8\u8350\u6A21\u677F"));
+    return await selectTemplateMethod();
+  }
+  console.log();
+  console.log(chalk2.blue.bold("\u{1F3AF} \u63A8\u8350\u6A21\u677F"));
+  console.log(chalk2.dim("\u57FA\u4E8E\u56E2\u961F\u4F7F\u7528\u9891\u7387\u548C\u9879\u76EE\u6210\u719F\u5EA6\u63A8\u8350"));
+  console.log();
+  const choices = [];
+  const entries = Object.entries(recommended);
+  entries.forEach(([key, template], index) => {
+    const tags = template.features.slice(0, 3).map((f) => chalk2.dim(`[${f}]`)).join(" ");
+    const ver = template.version === "full" ? chalk2.green("[\u5B8C\u6574\u7248]") : chalk2.yellow("[\u7CBE\u7B80\u7248]");
+    choices.push({
+      name: `${chalk2.bold.white(template.name.replace(/\s*(完整版|精简版)\s*$/, ""))} ${ver} - ${chalk2.dim(template.description)}
+   ${tags}${template.features.length > 3 ? chalk2.dim(` +${template.features.length - 3}more`) : ""}`,
+      value: { key, ...template },
+      short: template.name
+    });
+    if (index < entries.length - 1) {
+      choices.push({
+        name: chalk2.dim("\u2500".repeat(70)),
+        value: `sep_${index}`,
+        disabled: true
+      });
+    }
+  });
+  choices.push({ name: chalk2.dim("\u2B05\uFE0F  \u8FD4\u56DE\u9009\u62E9\u5176\u4ED6\u65B9\u5F0F"), value: "back" });
+  const { selectedTemplate } = await inquirer.prompt([
+    {
+      type: "list",
+      name: "selectedTemplate",
+      message: "\u9009\u62E9\u63A8\u8350\u6A21\u677F:",
+      choices,
+      pageSize: 15,
+      loop: false
+    }
+  ]);
+  if (selectedTemplate === "back") return await selectTemplateMethod();
+  return selectedTemplate;
+}
+async function selectByCategory() {
+  while (true) {
+    const cat = await selectCategory();
+    if (cat === "back_to_method") return await selectTemplateMethod();
+    const stack = await selectStack(cat);
+    if (stack === "back_to_category") continue;
+    if (stack === "back_to_method") return await selectTemplateMethod();
+    const pattern = await selectPattern(cat, stack);
+    if (pattern === "back_to_stack" || pattern === "back_to_category") continue;
+    if (pattern === "back_to_method") return await selectTemplateMethod();
+    const tpl = await selectSpecificTemplate(cat, stack, pattern);
+    if (typeof tpl === "string") continue;
+    return tpl;
+  }
+}
+async function selectCategory() {
+  const choices = Object.entries(TEMPLATE_CATEGORIES).map(([key, c]) => ({
+    name: c.name,
+    value: key
+  }));
+  choices.push({
+    name: chalk2.dim("\u2190 \u8FD4\u56DE\u6A21\u677F\u9009\u62E9\u65B9\u5F0F"),
+    value: "back_to_method"
+  });
+  const { categoryKey } = await inquirer.prompt([
+    { type: "list", name: "categoryKey", message: "\u8BF7\u9009\u62E9\u9879\u76EE\u7C7B\u578B:", choices }
+  ]);
+  return categoryKey;
+}
+async function selectStack(categoryKey) {
+  const category = TEMPLATE_CATEGORIES[categoryKey];
+  const choices = Object.entries(category.stacks).map(([key, s]) => ({
+    name: s.name,
+    value: key
+  }));
+  choices.push(
+    {
+      name: chalk2.dim("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"),
+      value: "separator",
+      disabled: true
+    },
+    { name: chalk2.dim("\u2190 \u8FD4\u56DE\u9879\u76EE\u7C7B\u578B\u9009\u62E9"), value: "back_to_category" },
+    { name: chalk2.dim("\u2190 \u8FD4\u56DE\u6A21\u677F\u9009\u62E9\u65B9\u5F0F"), value: "back_to_method" }
+  );
+  if (choices.length === 4) return choices[0].value;
+  const { stackKey } = await inquirer.prompt([
+    { type: "list", name: "stackKey", message: "\u8BF7\u9009\u62E9\u6280\u672F\u6808:", choices }
+  ]);
+  return stackKey;
+}
+async function selectPattern(catKey, stackKey) {
+  if (["back_to_category", "back_to_method"].includes(stackKey))
+    return stackKey;
+  const stack = TEMPLATE_CATEGORIES[catKey].stacks[stackKey];
+  const choices = Object.entries(stack.patterns).map(([key, p]) => ({
+    name: p.name,
+    value: key
+  }));
+  choices.push(
+    {
+      name: chalk2.dim("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"),
+      value: "separator",
+      disabled: true
+    },
+    { name: chalk2.dim("\u2190 \u8FD4\u56DE\u6280\u672F\u6808\u9009\u62E9"), value: "back_to_stack" },
+    { name: chalk2.dim("\u2190 \u8FD4\u56DE\u9879\u76EE\u7C7B\u578B\u9009\u62E9"), value: "back_to_category" },
+    { name: chalk2.dim("\u2190 \u8FD4\u56DE\u6A21\u677F\u9009\u62E9\u65B9\u5F0F"), value: "back_to_method" }
+  );
+  if (choices.length === 5) return choices[0].value;
+  const { patternKey } = await inquirer.prompt([
+    { type: "list", name: "patternKey", message: "\u8BF7\u9009\u62E9\u67B6\u6784\u6A21\u5F0F:", choices }
+  ]);
+  return patternKey;
+}
+async function selectSpecificTemplate(catKey, stackKey, patternKey) {
+  if (["back_to_stack", "back_to_category", "back_to_method"].includes(patternKey)) {
+    return patternKey;
+  }
+  const templates = getTemplatesByCategory(catKey, stackKey, patternKey);
+  const choices = Object.entries(templates).map(([key, t]) => ({
+    name: `${t.name} - ${chalk2.dim(t.description)}`,
+    value: { key, ...t },
+    short: t.name
+  }));
+  choices.push(
+    {
+      name: chalk2.dim("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"),
+      value: "separator",
+      disabled: true
+    },
+    { name: chalk2.dim("\u2190 \u8FD4\u56DE\u67B6\u6784\u6A21\u5F0F\u9009\u62E9"), value: "back_to_pattern" },
+    { name: chalk2.dim("\u2190 \u8FD4\u56DE\u6280\u672F\u6808\u9009\u62E9"), value: "back_to_stack" },
+    { name: chalk2.dim("\u2190 \u8FD4\u56DE\u9879\u76EE\u7C7B\u578B\u9009\u62E9"), value: "back_to_category" },
+    { name: chalk2.dim("\u2190 \u8FD4\u56DE\u6A21\u677F\u9009\u62E9\u65B9\u5F0F"), value: "back_to_method" }
+  );
+  const { selectedTemplate } = await inquirer.prompt([
+    {
+      type: "list",
+      name: "selectedTemplate",
+      message: "\u8BF7\u9009\u62E9\u6A21\u677F\u7248\u672C:",
+      choices
+    }
+  ]);
+  return selectedTemplate;
+}
+async function selectBySearch() {
+  while (true) {
+    const { keyword } = await inquirer.prompt([
+      {
+        type: "input",
+        name: "keyword",
+        message: "\u8BF7\u8F93\u5165\u641C\u7D22\u5173\u952E\u8BCD (\u540D\u79F0\u3001\u63CF\u8FF0\u3001\u6280\u672F\u6808):",
+        validate: (input) => input.trim() ? true : "\u5173\u952E\u8BCD\u4E0D\u80FD\u4E3A\u7A7A"
+      }
+    ]);
+    const results = searchTemplates(keyword);
+    if (Object.keys(results).length === 0) {
+      console.log();
+      console.log(chalk2.yellow("\u{1F50D} \u6CA1\u6709\u627E\u5230\u5339\u914D\u7684\u6A21\u677F"));
+      console.log(chalk2.dim(`\u641C\u7D22\u5173\u952E\u8BCD: "${keyword}"`));
+      console.log();
+      const { action } = await inquirer.prompt([
+        {
+          type: "list",
+          name: "action",
+          message: "\u8BF7\u9009\u62E9\u4E0B\u4E00\u6B65\u64CD\u4F5C:",
+          choices: [
+            { name: "\u{1F50D} \u91CD\u65B0\u641C\u7D22", value: "retry" },
+            { name: "\u2B05\uFE0F  \u8FD4\u56DE\u6A21\u677F\u9009\u62E9\u65B9\u5F0F", value: "back" }
+          ]
+        }
+      ]);
+      if (action === "retry") continue;
+      return await selectTemplateMethod();
+    }
+    console.log();
+    console.log(chalk2.green.bold("\u{1F50D} \u641C\u7D22\u7ED3\u679C"));
+    console.log(
+      chalk2.dim(
+        `\u5173\u952E\u8BCD: "${keyword}" \u2022 \u627E\u5230 ${Object.keys(results).length} \u4E2A\u5339\u914D\u6A21\u677F`
+      )
+    );
+    console.log();
+    const choices = Object.entries(results).map(([key, t]) => {
+      const hl = (text) => text.replace(
+        new RegExp(`(${keyword})`, "gi"),
+        chalk2.bgYellow.black("$1")
+      );
+      const ver = t.version === "full" ? chalk2.green("[\u5B8C\u6574\u7248]") : chalk2.yellow("[\u7CBE\u7B80\u7248]");
+      const info = t.features.slice(0, 2).join(" \u2022 ");
+      return {
+        name: `${chalk2.bold(hl(t.name.replace(/\s*(完整版|精简版)\s*$/, "")))} ${ver}
+   ${chalk2.dim(hl(t.description))}
+   ${chalk2.dim(`${info} \u2022 key: ${key}`)}
+   ${chalk2.dim("\u2500".repeat(60))}`,
+        value: { key, ...t },
+        short: t.name
+      };
+    });
+    choices.push(
+      { name: chalk2.dim("\u2501".repeat(70)), value: "separator", disabled: true },
+      { name: "\u{1F50D} \u91CD\u65B0\u641C\u7D22", value: "search_again" },
+      { name: "\u2B05\uFE0F  \u8FD4\u56DE\u6A21\u677F\u9009\u62E9\u65B9\u5F0F", value: "back_to_mode" }
+    );
+    const { selectedTemplate } = await inquirer.prompt([
+      {
+        type: "list",
+        name: "selectedTemplate",
+        message: "\u9009\u62E9\u6A21\u677F:",
+        choices,
+        pageSize: 15,
+        loop: false
+      }
+    ]);
+    if (selectedTemplate === "search_again") continue;
+    if (selectedTemplate === "back_to_mode")
+      return await selectTemplateMethod();
+    return selectedTemplate;
+  }
+}
+async function selectFromAll() {
+  const allTemplates = getAllTemplates();
+  console.log();
+  console.log(chalk2.blue.bold("\u{1F4CB} \u6240\u6709\u53EF\u7528\u6A21\u677F"));
+  console.log(chalk2.dim(`\u5171 ${Object.keys(allTemplates).length} \u4E2A\u6A21\u677F\u53EF\u9009`));
+  console.log();
+  const categorizedChoices = [];
+  for (const [_catKey, category] of Object.entries(TEMPLATE_CATEGORIES)) {
+    categorizedChoices.push({
+      name: chalk2.yellow.bold(category.name),
+      value: `${_catKey}_header`,
+      disabled: true
+    });
+    for (const [_sKey, stack] of Object.entries(category.stacks)) {
+      for (const _pattern of Object.values(stack.patterns)) {
+        for (const [key, t] of Object.entries(_pattern.templates)) {
+          const ver = t.version === "full" ? chalk2.green("[\u5B8C\u6574\u7248]") : chalk2.yellow("[\u7CBE\u7B80\u7248]");
+          categorizedChoices.push({
+            name: `  \u25CF ${chalk2.bold(t.name.replace(/\s*(完整版|精简版)\s*$/, ""))} ${ver} - ${chalk2.dim(t.description)}
+     ${chalk2.dim(`\u6280\u672F\u6808: ${stack.name} \u2022 \u547D\u4EE4: robot create my-app -t ${key}`)}`,
+            value: { key, ...t },
+            short: t.name
+          });
+          categorizedChoices.push({
+            name: chalk2.dim("    " + "\u2500".repeat(66)),
+            value: `sep_${key}`,
+            disabled: true
+          });
+        }
+      }
+    }
+  }
+  categorizedChoices.push(
+    { name: chalk2.dim("\u2501".repeat(70)), value: "separator", disabled: true },
+    { name: chalk2.dim("\u2B05\uFE0F  \u8FD4\u56DE\u6A21\u677F\u9009\u62E9\u65B9\u5F0F"), value: "back_to_mode" }
+  );
+  const { selectedTemplate } = await inquirer.prompt([
+    {
+      type: "list",
+      name: "selectedTemplate",
+      message: "\u9009\u62E9\u6A21\u677F:",
+      choices: categorizedChoices,
+      pageSize: 25,
+      loop: false
+    }
+  ]);
+  if (selectedTemplate === "back_to_mode") return await selectTemplateMethod();
+  return selectedTemplate;
+}
+async function configureProject(options) {
+  console.log();
+  console.log(chalk2.blue("\u2699\uFE0F  \u9879\u76EE\u914D\u7F6E"));
+  console.log();
+  const available = detectPackageManager();
+  const hasBun = available.includes("bun");
+  const hasPnpm = available.includes("pnpm");
+  const managerChoices = [];
+  if (available.includes("bun"))
+    managerChoices.push({
+      name: "bun (\u63A8\u8350 - \u6781\u901F\u5B89\u88C5\uFF0C\u73B0\u4EE3\u5316\uFF0C\u6027\u80FD\u6700\u4F73)",
+      value: "bun"
+    });
+  if (available.includes("pnpm"))
+    managerChoices.push({
+      name: "pnpm (\u63A8\u8350 - \u5FEB\u901F\u5B89\u88C5\uFF0C\u8282\u7701\u78C1\u76D8\u7A7A\u95F4)",
+      value: "pnpm"
+    });
+  if (available.includes("yarn"))
+    managerChoices.push({
+      name: "yarn (\u517C\u5BB9\u6027\u597D - \u9002\u7528\u4E8E\u73B0\u6709yarn\u9879\u76EE)",
+      value: "yarn"
+    });
+  if (available.includes("npm"))
+    managerChoices.push({
+      name: "npm (\u9ED8\u8BA4 - Node.js\u5185\u7F6E\uFF0C\u517C\u5BB9\u6027\u6700\u597D)",
+      value: "npm"
+    });
+  if (managerChoices.length === 0) {
+    managerChoices.push(
+      { name: "npm (\u9ED8\u8BA4)", value: "npm" },
+      { name: "bun (\u5982\u5DF2\u5B89\u88C5)", value: "bun" },
+      { name: "pnpm (\u5982\u5DF2\u5B89\u88C5)", value: "pnpm" },
+      { name: "yarn (\u5982\u5DF2\u5B89\u88C5)", value: "yarn" }
+    );
+  }
+  const config = await inquirer.prompt([
+    {
+      type: "confirm",
+      name: "initGit",
+      message: "\u662F\u5426\u521D\u59CB\u5316 Git \u4ED3\u5E93?",
+      default: true
+    },
+    {
+      type: "confirm",
+      name: "installDeps",
+      message: "\u662F\u5426\u7ACB\u5373\u5B89\u88C5\u4F9D\u8D56?",
+      default: !options.skipInstall
+    },
+    {
+      type: "list",
+      name: "packageManager",
+      message: "\u9009\u62E9\u5305\u7BA1\u7406\u5668:",
+      choices: managerChoices,
+      default: hasBun ? "bun" : hasPnpm ? "pnpm" : "npm",
+      when: (a) => a.installDeps
+    },
+    {
+      type: "input",
+      name: "description",
+      message: "\u9879\u76EE\u63CF\u8FF0 (\u53EF\u9009):",
+      default: ""
+    },
+    {
+      type: "input",
+      name: "author",
+      message: "\u4F5C\u8005 (\u53EF\u9009):",
+      default: getGitUser()
+    },
+    {
+      type: "confirm",
+      name: "confirmConfig",
+      message: "\u786E\u8BA4\u4EE5\u4E0A\u914D\u7F6E?",
+      default: true
+    }
+  ]);
+  if (!config.confirmConfig) {
+    const { action } = await inquirer.prompt([
+      {
+        type: "list",
+        name: "action",
+        message: "\u8BF7\u9009\u62E9\u64CD\u4F5C:",
+        choices: [
+          { name: "\u{1F504} \u91CD\u65B0\u914D\u7F6E", value: "reconfigure" },
+          { name: "\u274C \u53D6\u6D88\u521B\u5EFA", value: "cancel" }
+        ]
+      }
+    ]);
+    if (action === "reconfigure") return await configureProject(options);
+    console.log(chalk2.yellow("\u274C \u53D6\u6D88\u521B\u5EFA\u9879\u76EE"));
+    process.exit(0);
+  }
+  return config;
+}
+async function confirmCreation(projectName, template, config) {
+  console.log();
+  console.log(chalk2.blue("\u{1F4CB} \u9879\u76EE\u521B\u5EFA\u4FE1\u606F\u786E\u8BA4:"));
+  console.log();
+  console.log(`  \u9879\u76EE\u540D\u79F0: ${chalk2.cyan(projectName)}`);
+  console.log(`  \u9009\u62E9\u6A21\u677F: ${chalk2.cyan(template.name)}`);
+  console.log(`  \u6A21\u677F\u63CF\u8FF0: ${chalk2.dim(template.description)}`);
+  console.log(
+    `  \u5305\u542B\u529F\u80FD: ${chalk2.dim(template.features.join(", ") || "\u81EA\u5B9A\u4E49\u6A21\u677F")}`
+  );
+  if (config.description)
+    console.log(`  \u9879\u76EE\u63CF\u8FF0: ${chalk2.dim(config.description)}`);
+  if (config.author) console.log(`  \u4F5C\u3000\u3000\u8005: ${chalk2.dim(config.author)}`);
+  console.log(
+    `  \u521D\u59CB\u5316Git: ${config.initGit ? chalk2.green("\u662F") : chalk2.dim("\u5426")}`
+  );
+  console.log(
+    `  \u5B89\u88C5\u4F9D\u8D56: ${config.installDeps ? chalk2.green("\u662F") + chalk2.dim(` (${config.packageManager})`) : chalk2.dim("\u5426")}`
+  );
+  console.log(`  \u6E90\u7801\u4ED3\u5E93: ${chalk2.dim(template.repoUrl)}`);
+  console.log();
+  const { confirmed } = await inquirer.prompt([
+    {
+      type: "confirm",
+      name: "confirmed",
+      message: "\u786E\u8BA4\u521B\u5EFA\u9879\u76EE?",
+      default: true
+    }
+  ]);
+  if (!confirmed) {
+    console.log(chalk2.yellow("\u274C \u53D6\u6D88\u521B\u5EFA"));
+    process.exit(0);
+  }
+}
+async function executeCreation(projectName, template, config, options) {
+  if (!projectName) throw new Error(`\u9879\u76EE\u540D\u79F0\u65E0\u6548: ${projectName}`);
+  if (!template?.name)
+    throw new Error(`\u6A21\u677F\u6570\u636E\u65E0\u6548: ${JSON.stringify(template)}`);
+  const spinner = ora({
+    text: "\u{1F680} \u51C6\u5907\u521B\u5EFA\u9879\u76EE...",
+    spinner: "dots",
+    color: "cyan"
+  }).start();
+  let tempPath;
+  try {
+    spinner.text = "\u{1F4C1} \u68C0\u67E5\u9879\u76EE\u76EE\u5F55...";
+    const projectPath = path3.resolve(projectName);
+    if (fs3.existsSync(projectPath)) {
+      spinner.stop();
+      console.log(chalk2.yellow("\u26A0\uFE0F  \u9879\u76EE\u76EE\u5F55\u5DF2\u5B58\u5728"));
+      const { overwrite } = await inquirer.prompt([
+        {
+          type: "confirm",
+          name: "overwrite",
+          message: "\u76EE\u5F55\u5DF2\u5B58\u5728\uFF0C\u662F\u5426\u8986\u76D6?",
+          default: false
+        }
+      ]);
+      if (!overwrite) {
+        console.log(chalk2.yellow("\u274C \u53D6\u6D88\u521B\u5EFA"));
+        process.exit(0);
+      }
+      spinner.start("\u{1F5D1}\uFE0F  \u6E05\u7406\u73B0\u6709\u76EE\u5F55...");
+      await fs3.remove(projectPath);
+      spinner.text = "\u{1F4C1} \u51C6\u5907\u521B\u5EFA\u65B0\u76EE\u5F55...";
+    }
+    spinner.text = "\u{1F310} \u4E0B\u8F7D\u6700\u65B0\u6A21\u677F...";
+    try {
+      tempPath = await downloadTemplate(template, {
+        spinner,
+        noCache: options.noCache
+      });
+      if (!tempPath || !fs3.existsSync(tempPath))
+        throw new Error(`\u6A21\u677F\u8DEF\u5F84\u65E0\u6548: ${tempPath}`);
+    } catch (error) {
+      spinner.fail("\u6A21\u677F\u4E0B\u8F7D\u5931\u8D25");
+      console.log();
+      console.log(chalk2.red("\u274C \u6A21\u677F\u4E0B\u8F7D\u9519\u8BEF:"));
+      console.log(chalk2.dim(`   ${error.message}`));
+      console.log();
+      throw error;
+    }
+    await copyTemplate(tempPath, projectPath, spinner);
+    spinner.text = "\u2699\uFE0F  \u5904\u7406\u9879\u76EE\u914D\u7F6E...";
+    await processProjectConfig(projectPath, projectName, template, config);
+    if (config.initGit) {
+      spinner.text = "\u{1F4DD} \u521D\u59CB\u5316 Git \u4ED3\u5E93...";
+      initializeGitRepository(projectPath);
+    }
+    if (config.installDeps) {
+      spinner.text = `\u{1F4E6} \u4F7F\u7528 ${config.packageManager} \u5B89\u88C5\u4F9D\u8D56...`;
+      await installDependencies(projectPath, spinner, config.packageManager);
+    }
+    if (tempPath) {
+      spinner.text = "\u{1F9F9} \u6E05\u7406\u4E34\u65F6\u6587\u4EF6...";
+      await fs3.remove(tempPath).catch(() => {
+      });
+    }
+    spinner.succeed(chalk2.green("\u{1F389} \u9879\u76EE\u521B\u5EFA\u6210\u529F!"));
+    console.log();
+    console.log(chalk2.green("\u{1F389} \u9879\u76EE\u521B\u5EFA\u5B8C\u6210!"));
+    console.log();
+    console.log(chalk2.blue("\u{1F4C1} \u9879\u76EE\u4FE1\u606F:"));
+    console.log(`   \u4F4D\u7F6E: ${chalk2.cyan(projectPath)}`);
+    console.log(`   \u6A21\u677F: ${chalk2.cyan(template.name)}`);
+    console.log(
+      `   Git\u4ED3\u5E93: ${config.initGit ? chalk2.green("\u5DF2\u521D\u59CB\u5316") : chalk2.dim("\u672A\u521D\u59CB\u5316")}`
+    );
+    console.log(
+      `   \u4F9D\u8D56\u5B89\u88C5: ${config.installDeps ? chalk2.green("\u5DF2\u5B8C\u6210") : chalk2.dim("\u9700\u624B\u52A8\u5B89\u88C5")}`
+    );
+    console.log();
+    console.log(chalk2.blue("\u{1F680} \u5FEB\u901F\u5F00\u59CB:"));
+    console.log(chalk2.cyan(`   cd ${projectName}`));
+    const pm = config.packageManager || "bun";
+    if (!config.installDeps) {
+      console.log(chalk2.cyan(`   ${pm} install`));
+    }
+    const cmd = getStartCommand(template, pm);
+    if (cmd) console.log(chalk2.cyan(`   ${cmd}`));
+    if (pm === "bun")
+      console.log(chalk2.dim("   # \u6216\u4F7F\u7528 npm: npm install && npm run dev"));
+    else if (pm === "npm")
+      console.log(
+        chalk2.dim("   # \u6216\u4F7F\u7528 bun: bun install && bun run dev (\u5982\u5DF2\u5B89\u88C5)")
+      );
+    console.log();
+    spinner.start("\u{1F4CA} \u7EDF\u8BA1\u9879\u76EE\u4FE1\u606F...");
+    const stats = await generateProjectStats(projectPath);
+    spinner.stop();
+    if (stats) {
+      printProjectStats(stats);
+      console.log();
+    }
+  } catch (error) {
+    if (tempPath) await fs3.remove(tempPath).catch(() => {
+    });
+    spinner.fail("\u521B\u5EFA\u9879\u76EE\u5931\u8D25");
+    throw error;
+  }
+}
+async function processProjectConfig(projectPath, projectName, template, config) {
+  const pkgPath = path3.join(projectPath, "package.json");
+  if (fs3.existsSync(pkgPath)) {
+    const pkg = await fs3.readJson(pkgPath);
+    pkg.name = projectName;
+    pkg.description = config.description || `\u57FA\u4E8E ${template.name} \u521B\u5EFA\u7684\u9879\u76EE`;
+    if (config.author) pkg.author = config.author;
+    await fs3.writeJson(pkgPath, pkg, { spaces: 2 });
+  }
+  const readmePath = path3.join(projectPath, "README.md");
+  if (fs3.existsSync(readmePath)) {
+    let readme = await fs3.readFile(readmePath, "utf8");
+    readme = readme.replace(/# .+/, `# ${projectName}`);
+    const desc = config.description || `\u57FA\u4E8E ${template.name} \u521B\u5EFA\u7684\u9879\u76EE`;
+    readme = readme.replace(/项目描述.*/, desc);
+    if (config.author) readme += `
+
+## \u4F5C\u8005
+
+${config.author}
+`;
+    await fs3.writeFile(readmePath, readme);
+  }
+  for (const [from, to] of [
+    ["_gitignore", ".gitignore"],
+    ["_env.example", ".env.example"]
+  ]) {
+    const src = path3.join(projectPath, from);
+    const dest = path3.join(projectPath, to);
+    if (fs3.existsSync(src)) await fs3.move(src, dest);
+  }
+}
+function initializeGitRepository(projectPath) {
+  try {
+    execSync2("git --version", { stdio: "ignore" });
+    execSync2("git init", { cwd: projectPath, stdio: "ignore" });
+    execSync2("git add .", { cwd: projectPath, stdio: "ignore" });
+    execSync2('git commit -m "feat: \u521D\u59CB\u5316\u9879\u76EE"', {
+      cwd: projectPath,
+      stdio: "ignore"
+    });
+  } catch {
+    console.log(chalk2.yellow("\u26A0\uFE0F  Git \u4E0D\u53EF\u7528\uFF0C\u8DF3\u8FC7\u4ED3\u5E93\u521D\u59CB\u5316"));
+  }
+}
+function getStartCommand(template, pm) {
+  const script = START_COMMAND_MAP[template.key] || "dev";
+  return `${pm} run ${script}`;
+}
+
+// src/doctor.ts
+import chalk3 from "chalk";
+import ora2 from "ora";
+import { execSync as execSync3 } from "child_process";
+async function runDoctor(options = {}) {
+  console.log();
+  console.log(chalk3.blue.bold("\u{1F3E5} Robot CLI \u73AF\u5883\u8BCA\u65AD"));
+  console.log();
+  const results = [];
+  const nodeVersion = process.version;
+  const nodeMajor = parseInt(nodeVersion.slice(1), 10);
+  results.push({
+    name: "Node.js",
+    status: nodeMajor >= 20 ? "ok" : "error",
+    detail: nodeMajor >= 20 ? `${nodeVersion} (\u8981\u6C42 >= 20)` : `${nodeVersion} ${chalk3.red("(\u9700\u8981\u5347\u7EA7\u5230 Node.js 20+)")}`
+  });
+  try {
+    const gitVer = execSync3("git --version", { encoding: "utf8" }).trim().replace("git version ", "");
+    results.push({ name: "Git", status: "ok", detail: gitVer });
+  } catch {
+    results.push({ name: "Git", status: "error", detail: "\u672A\u5B89\u88C5" });
+  }
+  for (const pm of ["bun", "pnpm", "yarn", "npm"]) {
+    try {
+      const ver = execSync3(`${pm} --version`, {
+        encoding: "utf8",
+        stdio: ["pipe", "pipe", "ignore"]
+      }).trim();
+      const rec = pm === "bun" ? " (\u63A8\u8350)" : "";
+      results.push({
+        name: pm,
+        status: "ok",
+        detail: `v${ver.replace(/^v/, "")}${rec}`
+      });
+    } catch {
+      results.push({
+        name: pm,
+        status: pm === "npm" ? "error" : "warn",
+        detail: "\u672A\u5B89\u88C5"
+      });
+    }
+  }
+  const spinner = ora2({ text: "\u68C0\u67E5\u7F51\u7EDC...", spinner: "dots" }).start();
+  const githubOk = await checkNetworkConnection("https://github.com");
+  results.push({
+    name: "GitHub",
+    status: githubOk ? "ok" : "warn",
+    detail: githubOk ? "\u8FDE\u63A5\u6B63\u5E38" : "\u65E0\u6CD5\u8BBF\u95EE (\u53EF\u80FD\u9700\u8981\u4EE3\u7406)"
+  });
+  const npmOk = await checkNetworkConnection("https://registry.npmjs.org");
+  results.push({
+    name: "npm Registry",
+    status: npmOk ? "ok" : "warn",
+    detail: npmOk ? "\u8FDE\u63A5\u6B63\u5E38" : "\u65E0\u6CD5\u8BBF\u95EE"
+  });
+  spinner.stop();
+  const cacheStats = await getCacheStats();
+  results.push({
+    name: "\u7F13\u5B58",
+    status: "ok",
+    detail: cacheStats.count > 0 ? `${cacheStats.count} \u4E2A\u6A21\u677F (${formatBytes(cacheStats.totalSize)})` : "\u7A7A"
+  });
+  const icons = {
+    ok: chalk3.green("\u2705"),
+    warn: chalk3.yellow("\u26A0\uFE0F "),
+    error: chalk3.red("\u274C")
+  };
+  for (const r of results) {
+    const icon = icons[r.status];
+    console.log(`  ${icon} ${chalk3.bold(r.name.padEnd(14))} ${r.detail}`);
+  }
+  console.log();
+  const hasError = results.some((r) => r.status === "error");
+  const hasWarn = results.some((r) => r.status === "warn");
+  if (hasError) {
+    console.log(chalk3.red("  \u8BCA\u65AD\u7ED3\u679C: \u73AF\u5883\u5B58\u5728\u95EE\u9898\uFF0C\u8BF7\u4FEE\u590D\u4E0A\u8FF0\u9519\u8BEF \u274C"));
+  } else if (hasWarn) {
+    console.log(chalk3.yellow("  \u8BCA\u65AD\u7ED3\u679C: \u73AF\u5883\u57FA\u672C\u6B63\u5E38\uFF0C\u90E8\u5206\u7EC4\u4EF6\u7F3A\u5931 \u26A0\uFE0F"));
+  } else {
+    console.log(chalk3.green("  \u8BCA\u65AD\u7ED3\u679C: \u73AF\u5883\u5065\u5EB7 \u2705"));
+  }
+  console.log();
+  if (options.clearCache) {
+    const cSpinner = ora2("\u6E05\u7406\u6A21\u677F\u7F13\u5B58...").start();
+    await clearCache();
+    cSpinner.succeed("\u6A21\u677F\u7F13\u5B58\u5DF2\u6E05\u7406");
+    console.log();
+  }
+}
+
+// src/index.ts
+var __dirname = dirname(fileURLToPath(import.meta.url));
+function getPackageVersion() {
+  try {
+    const pkg = JSON.parse(
+      readFileSync(join(__dirname, "..", "package.json"), "utf8")
+    );
+    return pkg.version || "2.0.0";
+  } catch {
+    return "2.0.0";
+  }
+}
+var VERSION = getPackageVersion();
+function showWelcome() {
+  const banner = boxen(
+    [
+      "",
+      chalk4.bold.cyan("  \u{1F916}  R O B O T  -  C L I  "),
+      "",
+      chalk4.dim(`  v${VERSION} \u2014 \u5DE5\u7A0B\u5316\u9879\u76EE\u811A\u624B\u67B6`),
+      "",
+      chalk4.dim("  \u5FEB\u901F\u521B\u5EFA\u6807\u51C6\u5316\u524D\u7AEF/\u540E\u7AEF/\u79FB\u52A8\u7AEF/\u684C\u9762\u7AEF\u9879\u76EE"),
+      ""
+    ].join("\n"),
+    {
+      padding: 1,
+      margin: { top: 1, bottom: 1, left: 2, right: 2 },
+      borderStyle: "round",
+      borderColor: "cyan"
+    }
+  );
+  console.log(banner);
+}
+async function showMainMenu() {
+  const allTemplates = getAllTemplates();
+  const count = Object.keys(allTemplates).length;
+  console.log(
+    chalk4.dim(
+      `  \u{1F4E6} ${count} \u4E2A\u6A21\u677F\u53EF\u7528 \u2022 Node ${process.version} \u2022 v${VERSION}`
+    )
+  );
+  console.log();
+  const { action } = await inquirer2.prompt([
+    {
+      type: "list",
+      name: "action",
+      message: "\u8BF7\u9009\u62E9\u64CD\u4F5C:",
+      choices: [
+        {
+          name: `\u{1F680} ${chalk4.bold("\u521B\u5EFA\u65B0\u9879\u76EE")}  ${chalk4.dim("\u2014 \u9009\u62E9\u6A21\u677F\u521B\u5EFA\u9879\u76EE")}`,
+          value: "create"
+        },
+        {
+          name: `\u{1F4CB} ${chalk4.bold("\u67E5\u770B\u6A21\u677F\u5217\u8868")}  ${chalk4.dim("\u2014 \u6D4F\u89C8\u6240\u6709\u53EF\u7528\u6A21\u677F")}`,
+          value: "list"
+        },
+        {
+          name: `\u{1F50D} ${chalk4.bold("\u641C\u7D22\u6A21\u677F")}  ${chalk4.dim("\u2014 \u6309\u5173\u952E\u8BCD\u641C\u7D22\u6A21\u677F")}`,
+          value: "search"
+        },
+        {
+          name: `\u{1F3E5} ${chalk4.bold("\u73AF\u5883\u8BCA\u65AD")}  ${chalk4.dim("\u2014 \u68C0\u67E5\u5F00\u53D1\u73AF\u5883")}`,
+          value: "doctor"
+        },
+        { name: chalk4.dim("\u2500".repeat(50)), value: "sep", disabled: true },
+        { name: `\u274C ${chalk4.dim("\u9000\u51FA")}`, value: "exit" }
+      ]
+    }
+  ]);
+  switch (action) {
+    case "create":
+      await createProject(void 0, {});
+      break;
+    case "list":
+      showTemplateList(false);
+      break;
+    case "search":
+      await searchInteractive();
+      break;
+    case "doctor":
+      await runDoctor();
+      break;
+    case "exit":
+      console.log(chalk4.dim("\u{1F44B} \u518D\u89C1!"));
+      process.exit(0);
+  }
+}
+function showTemplateList(recommended) {
+  const templates = recommended ? getRecommendedTemplates() : getAllTemplates();
+  const title = recommended ? "\u{1F3AF} \u63A8\u8350\u6A21\u677F" : "\u{1F4CB} \u6240\u6709\u6A21\u677F";
+  const entries = Object.entries(templates);
+  console.log();
+  console.log(chalk4.blue.bold(title));
+  console.log(chalk4.dim(`\u5171 ${entries.length} \u4E2A\u6A21\u677F`));
+  console.log();
+  for (const [key, t] of entries) {
+    const ver = t.version === "full" ? chalk4.green("[\u5B8C\u6574\u7248]") : chalk4.yellow("[\u7CBE\u7B80\u7248]");
+    const cat = getCategoryForTemplate(key);
+    const catLabel = cat ? chalk4.dim(`[${cat}]`) : "";
+    console.log(`  ${chalk4.bold(t.name)} ${ver} ${catLabel}`);
+    console.log(`  ${chalk4.dim(t.description)}`);
+    console.log(`  ${chalk4.dim(`\u547D\u4EE4: robot create my-app -t ${key}`)}`);
+    console.log(`  ${chalk4.dim(`features: ${t.features.join(", ")}`)}`);
+    console.log();
+  }
+}
+async function searchInteractive() {
+  const { keyword } = await inquirer2.prompt([
+    {
+      type: "input",
+      name: "keyword",
+      message: "\u641C\u7D22\u5173\u952E\u8BCD:",
+      validate: (i) => i.trim() ? true : "\u8BF7\u8F93\u5165\u5173\u952E\u8BCD"
+    }
+  ]);
+  showSearchResults(keyword);
+}
+function showSearchResults(keyword) {
+  const results = searchTemplates(keyword);
+  const entries = Object.entries(results);
+  console.log();
+  if (entries.length === 0) {
+    console.log(chalk4.yellow(`\u{1F50D} \u6CA1\u6709\u627E\u5230\u300C${keyword}\u300D\u76F8\u5173\u6A21\u677F`));
+    console.log();
+    return;
+  }
+  console.log(chalk4.green.bold(`\u{1F50D} \u641C\u7D22\u7ED3\u679C: "${keyword}"`));
+  console.log(chalk4.dim(`\u627E\u5230 ${entries.length} \u4E2A\u5339\u914D`));
+  console.log();
+  for (const [key, t] of entries) {
+    const ver = t.version === "full" ? chalk4.green("[\u5B8C\u6574\u7248]") : chalk4.yellow("[\u7CBE\u7B80\u7248]");
+    console.log(`  ${chalk4.bold(t.name)} ${ver}`);
+    console.log(`  ${chalk4.dim(t.description)}`);
+    console.log(`  ${chalk4.dim(`robot create my-app -t ${key}`)}`);
+    console.log();
+  }
+}
+async function main() {
+  const program = new Command();
+  program.name("robot").description("\u{1F916} Robot CLI - \u5DE5\u7A0B\u5316\u9879\u76EE\u811A\u624B\u67B6").version(VERSION, "-v, --version");
+  program.command("create [project-name]").description("\u521B\u5EFA\u65B0\u9879\u76EE").option("-t, --template <name>", "\u6307\u5B9A\u6A21\u677F\u540D\u79F0").option("--skip-install", "\u8DF3\u8FC7\u4F9D\u8D56\u5B89\u88C5").option("--dry-run", "\u9884\u89C8\u6A21\u5F0F\uFF0C\u4E0D\u5B9E\u9645\u521B\u5EFA").option("--from <url>", "\u4ECE\u81EA\u5B9A\u4E49 Git \u4ED3\u5E93\u521B\u5EFA").option("--no-cache", "\u4E0D\u4F7F\u7528\u7F13\u5B58").action(async (projectName, opts) => {
+    showWelcome();
+    await createProject(projectName, opts);
+    checkForUpdates("@agile-team/robot-cli", VERSION).catch(() => {
+    });
+  });
+  program.command("list").description("\u67E5\u770B\u6A21\u677F\u5217\u8868").option("-r, --recommended", "\u53EA\u663E\u793A\u63A8\u8350\u6A21\u677F").action((opts) => {
+    showTemplateList(!!opts.recommended);
+  });
+  program.command("search <keyword>").description("\u641C\u7D22\u6A21\u677F").action((keyword) => {
+    showSearchResults(keyword);
+  });
+  program.command("doctor").description("\u8BCA\u65AD\u5F00\u53D1\u73AF\u5883").option("--clear-cache", "\u6E05\u7406\u6A21\u677F\u7F13\u5B58").action(async (opts) => {
+    await runDoctor(opts);
+  });
+  if (process.argv.length <= 2) {
+    showWelcome();
+    await showMainMenu();
+    return;
+  }
+  await program.parseAsync(process.argv);
+}
+export {
+  main
+};