create-unibest 2.5.1 → 3.0.1

package/dist/index.js

@@ -0,0 +1,748 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import process4 from "process";
+import minimist from "minimist";
+
+// src/commands/create/prompts.ts
+import { text, multiselect, select, confirm, cancel, isCancel } from "@clack/prompts";
+
+// src/utils/logger.ts
+import { bold, green, red, yellow, cyan } from "kolorist";
+var logger = {
+  /** 普通信息日志 */
+  info: (message) => {
+    console.log(`[${cyan("INFO")}] ${message}`);
+  },
+  /** 成功日志 */
+  success: (message) => {
+    console.log(`[${green("SUCCESS")}] ${bold(message)}`);
+  },
+  /** 错误日志 */
+  error: (message) => {
+    console.error(`[${red("ERROR")}] ${bold(message)}`);
+  },
+  /** 警告日志 */
+  warn: (message) => {
+    console.log(`[${yellow("WARN")}] ${message}`);
+  },
+  /** 提示日志 */
+  tip: (message) => {
+    console.log(`[${cyan("TIP")}] ${message}`);
+  }
+};
+
+// src/utils/validate.ts
+import { existsSync } from "fs";
+import { yellow as yellow2 } from "kolorist";
+import { join } from "path";
+function validateProjectName(name) {
+  const reg = /^[a-z0-9_-]+$/;
+  if (!reg.test(name)) {
+    return false;
+  }
+  if (name.startsWith("-") || name.endsWith("-")) {
+    return false;
+  }
+  return true;
+}
+function checkProjectNameExistAndValidate(_projectName) {
+  const projectName = _projectName.trim();
+  if (existsSync(join(process.cwd(), projectName))) {
+    return `\u76EE\u5F55 ${yellow2(projectName)} \u5DF2\u5B58\u5728\uFF0C\u8BF7\u9009\u62E9\u5176\u4ED6\u540D\u79F0`;
+  }
+  if (!validateProjectName(projectName)) {
+    return `\u9879\u76EE\u540D\u79F0 ${yellow2(projectName)} \u4E0D\u7B26\u5408\u89C4\u8303\uFF0C\u8BF7\u4F7F\u7528\u5B57\u6BCD\u3001\u6570\u5B57\u3001\u8FDE\u5B57\u7B26\u6216\u4E0B\u5212\u7EBF`;
+  }
+  return "";
+}
+
+// src/commands/create/prompts.ts
+import { green as green2 } from "kolorist";
+async function promptUser(projectName, argv = {}) {
+  try {
+    if (!projectName) {
+      const inputProjectName = await text({
+        message: `\u8BF7\u8F93\u5165\u9879\u76EE\u540D\u79F0${green2("[\u9879\u76EE\u540D\u79F0\u53EA\u80FD\u5305\u542B\u5B57\u6BCD\u3001\u6570\u5B57\u3001\u4E0B\u5212\u7EBF\u548C\u77ED\u6A2A\u7EBF\uFF0C\u5343\u4E07\u522B\u5199\u4E2D\u6587]")}`,
+        initialValue: "",
+        validate: (value) => {
+          if (!value.trim()) return "\u9879\u76EE\u540D\u79F0\u4E0D\u80FD\u4E3A\u7A7A";
+          const errorMessage = checkProjectNameExistAndValidate(value);
+          if (errorMessage) return errorMessage;
+          return;
+        }
+      });
+      if (isCancel(inputProjectName)) {
+        cancel("\u64CD\u4F5C\u5DF2\u53D6\u6D88");
+        process.exit(0);
+      }
+      projectName = inputProjectName;
+    }
+    const platforms = await multiselect({
+      message: `\u8BF7\u9009\u62E9\u9700\u8981\u652F\u6301\u7684\u5E73\u53F0\uFF08\u591A\u9009\uFF09${green2("[\u811A\u624B\u67B6\u5C06\u6839\u636E\u6240\u9009\u5E73\u53F0\u751F\u6210\u5BF9\u5E94\u7684\u5E73\u53F0\u4EE3\u7801\uFF0C\u8BF7\u6839\u636E\u5B9E\u9645\u60C5\u51B5\u9009\u62E9]")}`,
+      options: [
+        { value: "h5", label: "H5" },
+        { value: "mp-weixin", label: "\u5FAE\u4FE1\u5C0F\u7A0B\u5E8F" },
+        { value: "app", label: "APP" },
+        { value: "mp-alipay", label: "\u652F\u4ED8\u5B9D\u5C0F\u7A0B\u5E8F\uFF08\u5305\u542B\u9489\u9489\uFF09" },
+        { value: "mp-toutiao", label: "\u6296\u97F3\u5C0F\u7A0B\u5E8F" }
+      ],
+      initialValues: ["h5"],
+      // 默认选择 H5
+      required: true
+    });
+    if (isCancel(platforms)) {
+      cancel("\u64CD\u4F5C\u5DF2\u53D6\u6D88");
+      process.exit(0);
+    }
+    const uiLibrary = await select({
+      message: "\u8BF7\u9009\u62E9UI\u5E93",
+      options: [
+        { value: "none", label: "\u65E0UI\u5E93" },
+        { value: "wot-ui", label: "wot-ui" },
+        { value: "uview-pro", label: "uview-pro" },
+        { value: "sard-uniapp", label: "sard-uniapp" },
+        { value: "uv-ui", label: "uv-ui" },
+        { value: "uview-plus", label: "uview-plus" }
+      ],
+      initialValue: "none"
+    });
+    if (isCancel(uiLibrary)) {
+      cancel("\u64CD\u4F5C\u5DF2\u53D6\u6D88");
+      process.exit(0);
+    }
+    const loginStrategy = await confirm({
+      message: `\u662F\u5426\u9700\u8981\u767B\u5F55\u7B56\u7565\uFF08\u9ED1\u767D\u540D\u5355\u3001\u767B\u5F55\u62E6\u622A\u7B49\uFF09\uFF1F${green2("[\u6682\u4E0D\u77E5\u9053\u7684\uFF0C\u9009No\u5373\u53EF\uFF0C\u9879\u76EE\u751F\u6210\u540E\u4E5F\u53EF\u4EE5\u52A0\u8BE5\u7B56\u7565]")}`,
+      initialValue: false
+    });
+    if (isCancel(loginStrategy)) {
+      cancel("\u64CD\u4F5C\u5DF2\u53D6\u6D88");
+      process.exit(0);
+    }
+    const i18n = await confirm({
+      message: "\u662F\u5426\u9700\u8981\u591A\u8BED\u8A00i18n\uFF1F",
+      initialValue: false
+    });
+    if (isCancel(i18n)) {
+      cancel("\u64CD\u4F5C\u5DF2\u53D6\u6D88");
+      process.exit(0);
+    }
+    return {
+      projectName,
+      platforms,
+      uiLibrary,
+      loginStrategy,
+      i18n
+      // requestLibrary: requestLibrary as RequestLibrary,
+      // tokenStrategy: tokenStrategy as TokenStrategy,
+      // formatPlugin: formatPlugin as FormatPlugin,
+    };
+  } catch (error) {
+    logger.error(`\u8BE2\u95EE\u8FC7\u7A0B\u51FA\u9519: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+// src/commands/create/generate.ts
+import process3 from "process";
+
+// src/utils/cloneRepo.ts
+import { exec } from "child_process";
+import { promises as fs } from "fs";
+import { join as join3 } from "path";
+import process2 from "process";
+import { red as red2 } from "kolorist";
+
+// src/utils/replacePackageJson.ts
+import { readFileSync, writeFileSync } from "fs";
+import { join as join2 } from "path";
+function replaceContent(filePath, projectName, version2) {
+  const fileContent = JSON.parse(readFileSync(filePath, "utf8"));
+  fileContent.name = projectName;
+  fileContent.version = version2;
+  writeFileSync(filePath, JSON.stringify(fileContent, null, 2));
+}
+function replacePackageJson(root2, name, version2) {
+  const projectName = name.toLocaleLowerCase().replace(/\s/g, "-");
+  const pkgPath = join2(root2, "package.json");
+  replaceContent(pkgPath, projectName, version2);
+}
+
+// src/utils/cloneRepo.ts
+async function removeGitFolder(localPath) {
+  const gitFolderPath = join3(localPath, ".git");
+  await fs.rm(gitFolderPath, { recursive: true, force: true });
+}
+var REPO_URL = "https://gitee.com/feige996/unibest.git";
+async function cloneRepo(projectName, branch) {
+  try {
+    await new Promise((resolve, reject) => {
+      const execStr = `git clone --depth=1 -b ${branch} ${REPO_URL} "${projectName}"`;
+      exec(execStr, async (error) => {
+        if (error) {
+          console.error(`${red2("exec error:")} ${error}`);
+          reject(error);
+          return;
+        }
+        try {
+          await removeGitFolder(projectName);
+          resolve();
+        } catch (error2) {
+          reject(error2);
+        }
+      });
+    });
+    return;
+  } catch (error) {
+    console.error(`${red2("cloneRepo error:")} ${error}`);
+    throw new Error("cloneRepo error");
+  }
+}
+async function cloneRepoByBranch(root2, name, branch) {
+  try {
+    await cloneRepo(name, branch);
+  } catch (error) {
+    console.error(`${red2(`\u6A21\u677F\u7C7B\u578B${branch}\u4E0B\u8F7D\u5931\u8D25\uFF01`)} ${error}`);
+    process2.exit(1);
+  }
+  const projectPath = join3(root2, name);
+  replacePackageJson(projectPath, name, "1.0.0");
+}
+
+// src/utils/uiLibrary.ts
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync2 } from "fs";
+import { join as join4 } from "path";
+var UI_LIBRARY_CONFIGS = {
+  none: null,
+  "wot-ui": {
+    packageName: "wot-design-uni",
+    easycom: {
+      pattern: "^wd-(.*)",
+      path: "wot-design-uni/components/wd-$1/wd-$1.vue"
+    },
+    types: ["wot-design-uni/global.d.ts"]
+  },
+  "sard-uniapp": {
+    packageName: "sard-uniapp",
+    easycom: {
+      pattern: "^sar-(.*)",
+      path: "sard-uniapp/components/$1/$1.vue"
+    },
+    types: ["sard-uniapp/global"]
+  },
+  "uview-pro": {
+    packageName: "uview-pro",
+    easycom: {
+      pattern: "^u-(.*)",
+      path: "uview-pro/components/u-$1/u-$1.vue"
+    },
+    needMainImport: true,
+    mainImport: "import uViewPro from 'uview-pro';",
+    needUniScss: true,
+    uniScssImport: "@import 'uview-pro/theme.scss';",
+    needAppVue: true,
+    appVueImport: "@import 'uview-pro/index.scss';"
+  },
+  "uv-ui": {
+    packageName: "@climblee/uv-ui",
+    easycom: {
+      pattern: "^uv-(.*)",
+      path: "@climblee/uv-ui/components/uv-$1/uv-$1.vue"
+    },
+    types: ["@ttou/uv-typings/shim", "@ttou/uv-typings/v2"]
+  },
+  "uview-plus": {
+    packageName: "uview-plus",
+    // uview-plus 需要多个 easycom 配置
+    easycom: {
+      pattern: "^u--(.*)",
+      path: "uview-plus/components/u-$1/u-$1.vue"
+    },
+    types: ["uview-plus/types"],
+    needUniScss: true,
+    uniScssImport: "@import 'uview-plus/theme.scss'; // /* \u884C\u4E3A\u76F8\u5173\u989C\u8272 */"
+  }
+};
+function getUILibraryConfig(uiLibrary) {
+  return UI_LIBRARY_CONFIGS[uiLibrary];
+}
+async function applyUILibraryConfig(projectPath, uiLibrary) {
+  if (uiLibrary === "none") {
+    return;
+  }
+  const config = getUILibraryConfig(uiLibrary);
+  if (!config) {
+    return;
+  }
+  await updatePackageJson(projectPath, config.packageName);
+  if (config.easycom) {
+    await updatePagesConfig(projectPath, config.easycom);
+    if (uiLibrary === "uview-plus") {
+      await updatePagesConfig(projectPath, {
+        pattern: "^up-(.*)",
+        path: "uview-plus/components/u-$1/u-$1.vue"
+      });
+      await updatePagesConfig(projectPath, {
+        pattern: "^u-([^-].*)",
+        path: "uview-plus/components/u-$1/u-$1.vue"
+      });
+    }
+  }
+  if (config.types && config.types.length > 0) {
+    await updateTsConfig(projectPath, config.types);
+  }
+  if (config.needMainImport && config.mainImport) {
+    await updateMainTs(projectPath, config.mainImport);
+  }
+  if (config.needUniScss && config.uniScssImport) {
+    await updateUniScss(projectPath, config.uniScssImport);
+  }
+  if (config.needAppVue && config.appVueImport) {
+    await updateAppVue(projectPath, config.appVueImport);
+  }
+}
+async function updatePackageJson(projectPath, packageName) {
+  const packageJsonPath = join4(projectPath, "package.json");
+  if (!existsSync2(packageJsonPath)) {
+    return;
+  }
+  const packageJson = JSON.parse(readFileSync2(packageJsonPath, "utf8"));
+  if (!packageJson.dependencies) {
+    packageJson.dependencies = {};
+  }
+  if (!packageJson.dependencies[packageName]) {
+    packageJson.dependencies[packageName] = "latest";
+  }
+  writeFileSync2(packageJsonPath, JSON.stringify(packageJson, null, 2) + "\n");
+}
+async function updatePagesConfig(projectPath, easycom) {
+  const pagesConfigPath = join4(projectPath, "pages.config.ts");
+  if (!existsSync2(pagesConfigPath)) {
+    return;
+  }
+  const originalContent = readFileSync2(pagesConfigPath, "utf8");
+  let content = originalContent;
+  const patternLiteral = escapeSingleQuotes(easycom.pattern);
+  const pathLiteral = escapeSingleQuotes(easycom.path);
+  const existingEntryRegex = new RegExp(
+    `["']${escapeForRegExp(patternLiteral)}["']\\s*:\\s*["']${escapeForRegExp(pathLiteral)}["']`
+  );
+  if (existingEntryRegex.test(content)) {
+    return;
+  }
+  const entry = { pattern: patternLiteral, path: pathLiteral };
+  content = addToExistingCustomBlock(content, entry) ?? addCustomBlock(content, entry) ?? addEasycomBlock(content, entry) ?? appendEasycomBlock(content, entry);
+  if (content !== originalContent) {
+    writeFileSync2(pagesConfigPath, ensureTrailingNewline(content));
+  }
+}
+async function updateTsConfig(projectPath, types) {
+  const tsConfigPath = join4(projectPath, "tsconfig.json");
+  if (!existsSync2(tsConfigPath)) {
+    return;
+  }
+  const tsConfig = JSON.parse(readFileSync2(tsConfigPath, "utf8"));
+  if (!tsConfig.compilerOptions) {
+    tsConfig.compilerOptions = {};
+  }
+  if (!tsConfig.compilerOptions.types) {
+    tsConfig.compilerOptions.types = [];
+  }
+  const existingTypes = tsConfig.compilerOptions.types;
+  for (const type of types) {
+    if (!existingTypes.includes(type)) {
+      existingTypes.push(type);
+    }
+  }
+  writeFileSync2(tsConfigPath, JSON.stringify(tsConfig, null, 2) + "\n");
+}
+async function updateMainTs(projectPath, importCode) {
+  const mainTsPath = join4(projectPath, "src", "main.ts");
+  if (!existsSync2(mainTsPath)) {
+    return;
+  }
+  let content = readFileSync2(mainTsPath, "utf8");
+  const firstLine = importCode.split("\n")[0];
+  if (content.includes(firstLine)) {
+    return;
+  }
+  const vueImportRegex = /(import\s+.*from\s+['"]vue['"];?\s*\n)/;
+  const match = content.match(vueImportRegex);
+  if (match) {
+    content = content.replace(vueImportRegex, `$1${importCode}
+`);
+  } else {
+    content = `${importCode}
+
+${content}`;
+  }
+  if (importCode.includes("uview-pro")) {
+    const appUseRegex = /(const\s+app\s*=\s*createSSRApp\(App\);?\s*\n)/;
+    const appUseMatch = content.match(appUseRegex);
+    if (appUseMatch && !content.includes("app.use(uViewPro)")) {
+      content = content.replace(appUseRegex, `$1  app.use(uViewPro);
+`);
+    }
+  }
+  writeFileSync2(mainTsPath, content);
+}
+async function updateUniScss(projectPath, importCode) {
+  const uniScssPath = join4(projectPath, "src", "style", "uni.scss");
+  if (!existsSync2(uniScssPath)) {
+    const altPath = join4(projectPath, "uni.scss");
+    if (existsSync2(altPath)) {
+      await updateScssFile(altPath, importCode);
+    }
+    return;
+  }
+  await updateScssFile(uniScssPath, importCode);
+}
+async function updateScssFile(filePath, importCode) {
+  let content = readFileSync2(filePath, "utf8");
+  if (content.includes(importCode)) {
+    return;
+  }
+  content = `${content.trim()}
+${importCode}
+`;
+  writeFileSync2(filePath, content);
+}
+async function updateAppVue(projectPath, importCode) {
+  const appVuePath = join4(projectPath, "src", "App.vue");
+  if (!existsSync2(appVuePath)) {
+    return;
+  }
+  let content = readFileSync2(appVuePath, "utf8");
+  if (content.includes(importCode)) {
+    return;
+  }
+  const styleRegex = /(<style[^>]*>)/s;
+  const match = content.match(styleRegex);
+  if (match) {
+    content = content.replace(styleRegex, `$1
+${importCode}`);
+  } else {
+    content = `${content}
+<style lang="scss">
+${importCode}
+</style>`;
+  }
+  writeFileSync2(appVuePath, content);
+}
+function addToExistingCustomBlock(content, entry) {
+  const customIndex = content.indexOf("custom:");
+  if (customIndex === -1) {
+    return null;
+  }
+  const braceIndex = content.indexOf("{", customIndex);
+  if (braceIndex === -1) {
+    return null;
+  }
+  const closingIndex = findMatchingBrace(content, braceIndex);
+  if (closingIndex === -1) {
+    return null;
+  }
+  const inside = content.slice(braceIndex + 1, closingIndex);
+  const hasEntries = inside.trim().length > 0;
+  const entryIndent = getLineIndent(content, braceIndex) + "  ";
+  const entryLine = `${entryIndent}'${entry.pattern}': '${entry.path}',`;
+  if (!hasEntries) {
+    const closingIndent = getLineIndent(content, closingIndex);
+    return content.slice(0, braceIndex + 1) + `
+${entryLine}
+${closingIndent}` + content.slice(closingIndex);
+  }
+  const beforeRaw = content.slice(0, closingIndex).replace(/\s*$/, "");
+  const separator = beforeRaw.endsWith("\n") ? "" : "\n";
+  const after = content.slice(closingIndex);
+  return `${beforeRaw}${separator}${entryLine}
+${after}`;
+}
+function addCustomBlock(content, entry) {
+  const easycomIndex = content.indexOf("easycom:");
+  if (easycomIndex === -1) {
+    return null;
+  }
+  const braceIndex = content.indexOf("{", easycomIndex);
+  if (braceIndex === -1) {
+    return null;
+  }
+  const closingIndex = findMatchingBrace(content, braceIndex);
+  if (closingIndex === -1) {
+    return null;
+  }
+  const easycomIndent = getLineIndent(content, braceIndex);
+  const customIndent = easycomIndent + "  ";
+  const entryIndent = customIndent + "  ";
+  const customBlock = `${customIndent}custom: {
+${entryIndent}'${entry.pattern}': '${entry.path}',
+${customIndent}},`;
+  const beforeRaw = content.slice(0, closingIndex).replace(/\s*$/, "");
+  const separator = beforeRaw.endsWith("\n") ? "" : "\n";
+  const after = content.slice(closingIndex);
+  return `${beforeRaw}${separator}${customBlock}
+${after}`;
+}
+function addEasycomBlock(content, entry) {
+  const exportIndex = content.indexOf("export default");
+  if (exportIndex === -1) {
+    return null;
+  }
+  const braceIndex = content.indexOf("{", exportIndex);
+  if (braceIndex === -1) {
+    return null;
+  }
+  const closingIndex = findMatchingBrace(content, braceIndex);
+  if (closingIndex === -1) {
+    return null;
+  }
+  const blockIndent = getLineIndent(content, braceIndex) + "  ";
+  const entryIndent = blockIndent + "  ";
+  const block = `${blockIndent}easycom: {
+${blockIndent}  autoscan: true,
+${blockIndent}  custom: {
+${entryIndent}'${entry.pattern}': '${entry.path}',
+${blockIndent}  },
+${blockIndent}},`;
+  const before = content.slice(0, braceIndex + 1);
+  const after = content.slice(braceIndex + 1);
+  const prefix = before.endsWith("\n") ? before : `${before}
+`;
+  return `${prefix}${block}
+${after}`;
+}
+function appendEasycomBlock(content, entry) {
+  const block = `
+export const easycom = {
+  autoscan: true,
+  custom: {
+    '${entry.pattern}': '${entry.path}',
+  },
+}
+`;
+  return `${content}${block}`;
+}
+function findMatchingBrace(content, startIndex) {
+  let depth = 0;
+  for (let i = startIndex; i < content.length; i += 1) {
+    const char = content[i];
+    if (char === "{") {
+      depth += 1;
+    } else if (char === "}") {
+      depth -= 1;
+      if (depth === 0) {
+        return i;
+      }
+    }
+  }
+  return -1;
+}
+function getLineIndent(content, index) {
+  const lineStart = content.lastIndexOf("\n", index) + 1;
+  const line = content.slice(lineStart, index);
+  const match = line.match(/^\s*/);
+  return match ? match[0] : "";
+}
+function escapeSingleQuotes(value) {
+  return value.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+}
+function escapeForRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function ensureTrailingNewline(value) {
+  return value.endsWith("\n") ? value : `${value}
+`;
+}
+
+// src/utils/debug.ts
+import { magenta } from "kolorist";
+function debug(...args) {
+  const isDev = process.env.NODE_ENV === "development";
+  if (isDev) {
+    const debugPrefix = magenta("[debug]");
+    console.log(debugPrefix, ...args);
+  }
+}
+
+// src/commands/create/generate.ts
+import path from "path";
+var root = process3.cwd();
+async function generateProject(options) {
+  debug("generateProject options", options);
+  const { projectName, platforms, uiLibrary, loginStrategy, i18n } = options;
+  if (!loginStrategy && !i18n) {
+    debug("\u62C9\u53D6 base \u5206\u652F");
+    await cloneRepoByBranch(root, projectName, "base");
+  } else if (!loginStrategy && i18n) {
+    debug("\u62C9\u53D6 base-i18n \u5206\u652F");
+    await cloneRepoByBranch(root, projectName, "base-i18n");
+  } else if (loginStrategy && !i18n) {
+    debug("\u62C9\u53D6 base-login \u5206\u652F");
+    await cloneRepoByBranch(root, projectName, "base-login");
+  } else if (loginStrategy && i18n) {
+    debug("\u62C9\u53D6 base-login-i18n \u5206\u652F");
+    await cloneRepoByBranch(root, projectName, "base-login-i18n");
+  }
+  const projectPath = path.join(root, projectName);
+  if (uiLibrary === "none") {
+    debug("\u4E0D\u5F15\u5165\u4EFB\u4F55UI\u5E93");
+  } else {
+    debug(`\u914D\u7F6E UI \u5E93: ${uiLibrary}`);
+    try {
+      await applyUILibraryConfig(projectPath, uiLibrary);
+      logger.success(`UI \u5E93 ${uiLibrary} \u914D\u7F6E\u5B8C\u6210`);
+    } catch (error) {
+      logger.warn(`UI \u5E93 ${uiLibrary} \u914D\u7F6E\u5931\u8D25: ${error.message}`);
+      logger.info("\u60A8\u53EF\u4EE5\u5728\u9879\u76EE\u521B\u5EFA\u540E\u624B\u52A8\u914D\u7F6E UI \u5E93");
+    }
+  }
+  try {
+    logger.success(`\u9879\u76EE${projectName}\u521B\u5EFA\u6210\u529F\uFF01`);
+    logger.info("\u4E0B\u4E00\u6B65:");
+    logger.info(`  cd ${projectName}`);
+    logger.info("  pnpm install");
+    logger.info("  pnpm dev");
+    logger.info("  \u8FD0\u884C\u5B8C\u4EE5\u4E0A\u547D\u4EE4\u540E\uFF0C\u5373\u53EF\u5728\u5BF9\u5E94\u5E73\u53F0\u4E0A\u8FD0\u884C\u9879\u76EE");
+    logger.info("  \u5982\uFF1Apnpm dev:mp, pnpm dev:app \u7B49");
+  } catch (error) {
+    logger.error(`\u751F\u6210\u9879\u76EE\u5931\u8D25: ${error.message}`);
+    throw error;
+  }
+}
+
+// package.json
+var version = "3.0.1";
+
+// src/commands/create.ts
+import { intro, log } from "@clack/prompts";
+import { bold as bold3, yellow as yellow3, green as green3 } from "kolorist";
+
+// src/utils/unibestVersion.ts
+import fetch from "node-fetch";
+async function getUnibestVersion() {
+  try {
+    const apiUrl = `https://gitee.com/api/v5/repos/feige996/unibest/contents/package.json?ref=main`;
+    const response = await fetch(apiUrl, {
+      method: "GET",
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+    if (response.ok) {
+      const data = await response.json();
+      const { content, encoding } = data;
+      if (encoding === "base64") {
+        const decodedContent = Buffer.from(content, "base64").toString("utf8");
+        const packageJson = JSON.parse(decodedContent);
+        return packageJson.version || null;
+      } else {
+        return null;
+      }
+    } else {
+      return null;
+    }
+  } catch (error) {
+    return null;
+  }
+}
+var unibestVersion_default = getUnibestVersion;
+
+// src/commands/create.ts
+async function createCommand(args) {
+  const projectName = args._[1];
+  const versionUnibest = await unibestVersion_default() || "3.18.3";
+  intro(bold3(green3(`create-unibest@v${version} \u5FEB\u901F\u521B\u5EFA ${yellow3(`unibest@v${versionUnibest}`)} \u9879\u76EE`)));
+  if (projectName) {
+    const errorMessage = checkProjectNameExistAndValidate(projectName);
+    if (errorMessage) {
+      log.error(errorMessage);
+      process.exit(1);
+    }
+  }
+  try {
+    const projectOptions = await promptUser(projectName, args);
+    await generateProject(projectOptions);
+    log.success("\u9879\u76EE\u521B\u5EFA\u6210\u529F\uFF01");
+  } catch (error) {
+    log.error(`\u521B\u5EFA\u9879\u76EE\u5931\u8D25: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+// src/utils/color.ts
+import { blue, green as green4, magenta as magenta2, red as red3, yellow as yellow4 } from "kolorist";
+var color = {
+  blue,
+  green: green4,
+  magenta: magenta2,
+  red: red3,
+  yellow: yellow4
+};
+
+// src/utils/help.ts
+function printHelp() {
+  console.log(color.green("\nunibest - \u8DE8\u5E73\u53F0\u5F00\u53D1\u6846\u67B6\u811A\u624B\u67B6"));
+  console.log("");
+  console.log(color.blue("\u7528\u6CD5:"));
+  console.log("  unibest <command> [options]");
+  console.log("");
+  console.log(color.blue("\u547D\u4EE4:"));
+  console.log("  create <project-name>  \u521B\u5EFA\u65B0\u7684unibest\u9879\u76EE");
+  console.log("  help                   \u663E\u793A\u5E2E\u52A9\u4FE1\u606F");
+  console.log("  version                \u663E\u793A\u7248\u672C\u4FE1\u606F");
+  console.log("");
+  console.log(color.blue("\u9009\u9879:"));
+  console.log("  --ui, --ui-library     \u6307\u5B9AUI\u5E93");
+  console.log("  --ts, --typescript     \u4F7F\u7528TypeScript\uFF08\u9ED8\u8BA4\uFF09");
+  console.log("  --js, --javascript     \u4F7F\u7528JavaScript");
+  console.log("  --i18n                 \u542F\u7528i18n");
+  console.log("");
+  console.log(color.blue("\u793A\u4F8B:"));
+  console.log("  unibest create my-project");
+  console.log("  unibest create my-project --ui uv-ui --ts --i18n");
+  console.log("  unibest create my-project --ui wot-ui --js");
+}
+
+// src/index.ts
+import { green as green5 } from "kolorist";
+import { yellow as yellow5 } from "kolorist";
+function main() {
+  const args = minimist(process4.argv.slice(2));
+  const command = args._[0];
+  debug("command:", command);
+  debug("args:", args);
+  if (args.v || args.version) {
+    printVersion();
+    return;
+  }
+  switch (command) {
+    case "create":
+    case "new":
+      createCommand(args);
+      break;
+    case "-h":
+    case "--help":
+      printHelp();
+      break;
+    case "-v":
+    case "--version":
+      printVersion();
+      break;
+    default:
+      if (command) {
+        console.log(color.red(`\u672A\u77E5\u547D\u4EE4: ${command}`));
+      }
+      printHelp();
+      break;
+  }
+}
+async function printVersion() {
+  console.log(green5(`create-unibest: `) + yellow5(version));
+  try {
+    const unibestVersion = await unibestVersion_default();
+    console.log(green5(`unibest: `) + yellow5(unibestVersion || "1.0.0"));
+  } catch (error) {
+    console.log(green5(`unibest: \u672A\u80FD\u83B7\u53D6\u5230\u7248\u672C\u53F7`));
+  }
+}
+main();