@robot-admin/git-standards 1.0.0

package/dist/index.js

@@ -0,0 +1,1228 @@
+// src/configs/lint-staged.ts
+function createLintStagedConfig(options = {}) {
+  const codePattern = options.filePatterns?.code || "src/**/*.{js,jsx,ts,tsx,vue}";
+  const markupPattern = options.filePatterns?.markup || "*.{json,md,yml,yaml}";
+  const codeCommands = [];
+  if (options.oxlint !== false) {
+    codeCommands.push("oxlint --max-warnings 0 --deny-warnings");
+  }
+  if (options.eslint !== false) {
+    codeCommands.push("eslint --fix --no-cache");
+  }
+  if (options.prettier !== false) {
+    codeCommands.push("prettier --write");
+  }
+  const config = {};
+  if (codeCommands.length > 0) {
+    config[codePattern] = codeCommands;
+  }
+  if (options.prettier !== false) {
+    config[markupPattern] = ["prettier --write"];
+  }
+  return config;
+}
+function generateLintStagedConfig(options = {}) {
+  return createLintStagedConfig(options);
+}
+
+// src/cli/init.ts
+import { resolve as resolve4 } from "path";
+import { unlinkSync, existsSync as existsSync4, rmSync } from "fs";
+import chalk from "chalk";
+import ora from "ora";
+import { execa as execa2 } from "execa";
+
+// src/utils/package-manager.ts
+import { existsSync } from "fs";
+import { resolve } from "path";
+async function detectPackageManager(cwd = process.cwd()) {
+  if (existsSync(resolve(cwd, "bun.lockb")) || existsSync(resolve(cwd, "bun.lock"))) {
+    return "bun";
+  }
+  if (existsSync(resolve(cwd, "pnpm-lock.yaml"))) {
+    return "pnpm";
+  }
+  if (existsSync(resolve(cwd, "yarn.lock"))) {
+    return "yarn";
+  }
+  if (existsSync(resolve(cwd, "package-lock.json"))) {
+    return "npm";
+  }
+  return "npm";
+}
+function getInstallCommand(pm) {
+  const commands = {
+    npm: "npm install --save-dev",
+    yarn: "yarn add --dev",
+    pnpm: "pnpm add -D",
+    bun: "bun add --dev"
+  };
+  return commands[pm];
+}
+function getExecCommand(pm) {
+  const commands = {
+    npm: "npx --no",
+    yarn: "yarn",
+    pnpm: "pnpm dlx",
+    bun: "bunx"
+  };
+  return commands[pm];
+}
+function getPackageManagerName(pm) {
+  const names = {
+    npm: "npm",
+    yarn: "Yarn",
+    pnpm: "pnpm",
+    bun: "Bun"
+  };
+  return names[pm];
+}
+
+// src/utils/git.ts
+import { existsSync as existsSync2 } from "fs";
+import { resolve as resolve2 } from "path";
+import { execa } from "execa";
+function isGitRepository(cwd = process.cwd()) {
+  return existsSync2(resolve2(cwd, ".git"));
+}
+async function initGitRepository(cwd = process.cwd()) {
+  if (!isGitRepository(cwd)) {
+    await execa("git", ["init"], { cwd });
+  }
+}
+
+// src/utils/file.ts
+import { existsSync as existsSync3 } from "fs";
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { resolve as resolve3, dirname } from "path";
+function fileExists(filePath) {
+  return existsSync3(filePath);
+}
+async function readFileContent(filePath) {
+  return await readFile(filePath, "utf-8");
+}
+async function writeFileContent(filePath, content) {
+  const dir = dirname(filePath);
+  if (!existsSync3(dir)) {
+    await mkdir(dir, { recursive: true });
+  }
+  await writeFile(filePath, content, "utf-8");
+}
+async function readJsonFile(filePath) {
+  const content = await readFileContent(filePath);
+  return JSON.parse(content);
+}
+async function writeJsonFile(filePath, data, pretty = true) {
+  const content = pretty ? JSON.stringify(data, null, 2) + "\n" : JSON.stringify(data);
+  await writeFileContent(filePath, content);
+}
+async function updatePackageJson(updates, cwd = process.cwd()) {
+  const packageJsonPath = resolve3(cwd, "package.json");
+  const packageJson = await readJsonFile(packageJsonPath);
+  const updated = { ...packageJson, ...updates };
+  await writeJsonFile(packageJsonPath, updated);
+}
+
+// src/cli/init.ts
+var BRAND = "#7C3AED";
+var S = {
+  LOGO: chalk.hex(BRAND).bold("[RS]"),
+  OK: chalk.green("\u2714"),
+  FAIL: chalk.red("\u2716"),
+  WARN: chalk.yellow("\u25B2"),
+  STEP: chalk.hex(BRAND)("\u25C6"),
+  ARROW: chalk.cyan("\u25B8"),
+  DOT: chalk.gray("\u25CF"),
+  INFO: chalk.blue("\u2139"),
+  LINE: chalk.gray("\u2500".repeat(48))
+};
+var PRESETS = {
+  minimal: {
+    name: "\u6781\u7B80\u6A21\u5F0F",
+    desc: "\u4EC5 Git \u63D0\u4EA4\u89C4\u8303 (Commitizen + Commitlint)",
+    features: {
+      eslint: false,
+      lintStaged: false,
+      prettier: false,
+      oxlint: false,
+      editorconfig: false
+    }
+  },
+  standard: {
+    name: "\u6807\u51C6\u6A21\u5F0F",
+    desc: "\u63D0\u4EA4\u89C4\u8303 + \u4EE3\u7801\u8D28\u91CF\u68C0\u67E5 (+ ESLint + lint-staged)",
+    features: {
+      eslint: true,
+      lintStaged: true,
+      prettier: false,
+      oxlint: false,
+      editorconfig: true
+    }
+  },
+  full: {
+    name: "\u5B8C\u6574\u6A21\u5F0F",
+    desc: "\u5168\u90E8\u5DE5\u5177\u94FE (+ Prettier + Oxlint + EditorConfig)",
+    features: {
+      eslint: true,
+      lintStaged: true,
+      prettier: true,
+      oxlint: true,
+      editorconfig: true
+    }
+  }
+};
+async function init(options = {}) {
+  const cwd = options.cwd || process.cwd();
+  printBanner();
+  console.log(`  ${S.STEP} ${chalk.bold("\u73AF\u5883\u68C0\u6D4B")}`);
+  console.log();
+  if (!isGitRepository(cwd)) {
+    const spinner = ora({
+      text: chalk.gray("\u521D\u59CB\u5316 Git \u4ED3\u5E93..."),
+      prefixText: "  ",
+      spinner: "dots"
+    }).start();
+    await initGitRepository(cwd);
+    spinner.succeed(chalk.white("Git \u4ED3\u5E93\u521D\u59CB\u5316\u5B8C\u6210"));
+  } else {
+    console.log(`  ${S.OK} Git \u4ED3\u5E93\u5DF2\u5C31\u7EEA`);
+  }
+  const pm = await detectPackageManager(cwd);
+  const pmName = getPackageManagerName(pm);
+  console.log(`  ${S.OK} \u5305\u7BA1\u7406\u5668: ${chalk.cyan.bold(pmName)}`);
+  console.log();
+  let features;
+  let eslintOpts = {
+    framework: "vue",
+    typescript: true,
+    jsdoc: false
+  };
+  if (options.ci) {
+    const presetId = options.preset || "standard";
+    if (presetId === "custom") {
+      features = {
+        eslint: true,
+        lintStaged: true,
+        prettier: options.prettier ?? true,
+        oxlint: options.oxlint ?? true,
+        editorconfig: true
+      };
+    } else {
+      features = { ...PRESETS[presetId].features };
+    }
+    if (options.prettier !== void 0) features.prettier = options.prettier;
+    if (options.oxlint !== void 0) features.oxlint = options.oxlint;
+    const jsdocDefault = presetId === "full" ? true : false;
+    eslintOpts = {
+      framework: options.framework || "vue",
+      typescript: options.typescript ?? true,
+      jsdoc: options.jsdoc ?? jsdocDefault
+    };
+    console.log(
+      `  ${S.INFO} ${chalk.gray("CI \u6A21\u5F0F")} ${chalk.white(
+        "\u9884\u8BBE:"
+      )} ${chalk.cyan(presetId)}`
+    );
+    console.log();
+  } else {
+    const result = await interactiveSetup(options);
+    features = result.features;
+    eslintOpts = result.eslintOpts;
+  }
+  printSummary(features, eslintOpts, pmName);
+  if (!options.ci) {
+    const { confirm } = await import("@inquirer/prompts");
+    const proceed = await confirm({
+      message: chalk.white("\u786E\u8BA4\u4EE5\u4E0A\u914D\u7F6E\u5E76\u5F00\u59CB\u5B89\u88C5?"),
+      default: true,
+      theme: { prefix: `  ${S.ARROW}` }
+    });
+    if (!proceed) {
+      console.log();
+      console.log(`  ${S.INFO} ${chalk.gray("\u91CD\u65B0\u9009\u62E9\u914D\u7F6E...")}`);
+      console.log();
+      const result = await interactiveSetup(options);
+      features = result.features;
+      eslintOpts = result.eslintOpts;
+      printSummary(features, eslintOpts, pmName);
+    }
+  }
+  console.log();
+  await installDependencies(cwd, pm, features, eslintOpts);
+  await generateConfigFiles(cwd, features, eslintOpts);
+  await setupHusky(cwd, pm, features);
+  await addPackageScripts(cwd, pm, features);
+  printCompletion(pm, features);
+}
+function printBanner() {
+  console.log();
+  console.log(S.LINE);
+  console.log(
+    `  ${S.LOGO}  ${chalk.bold("Robot Standards")}  ${chalk.gray("v1.0.0")}`
+  );
+  console.log(`  ${chalk.gray("\u96F6\u914D\u7F6E \xB7 \u6A21\u5757\u5316 \xB7 Git \u5DE5\u7A0B\u5316\u6807\u51C6\u5DE5\u5177\u5305")}`);
+  console.log(S.LINE);
+  console.log();
+}
+async function interactiveSetup(options) {
+  const { select, checkbox, confirm } = await import("@inquirer/prompts");
+  while (true) {
+    console.log(`  ${S.STEP} ${chalk.bold("\u9009\u62E9\u6A21\u5F0F")}`);
+    console.log();
+    const presetId = await select({
+      message: chalk.white("\u9009\u62E9\u9884\u8BBE\u65B9\u6848"),
+      choices: [
+        {
+          name: `\u6781\u7B80\u6A21\u5F0F  ${chalk.gray(
+            "\u2500\u2500 \u4EC5\u63D0\u4EA4\u89C4\u8303 (Commitizen + Commitlint)"
+          )}`,
+          value: "minimal",
+          description: chalk.gray("\u9002\u5408\u53EA\u9700\u89C4\u8303\u63D0\u4EA4\u4FE1\u606F\u7684\u9879\u76EE")
+        },
+        {
+          name: `\u6807\u51C6\u6A21\u5F0F  ${chalk.gray("\u2500\u2500 \u63D0\u4EA4\u89C4\u8303 + \u4EE3\u7801\u68C0\u67E5 (+ ESLint)")}`,
+          value: "standard",
+          description: chalk.gray("\u9002\u5408\u5927\u591A\u6570\u9879\u76EE")
+        },
+        {
+          name: `\u5B8C\u6574\u6A21\u5F0F  ${chalk.gray(
+            "\u2500\u2500 \u5168\u90E8\u5DE5\u5177\u94FE (+ Prettier + Oxlint)"
+          )}  ${chalk.hex(BRAND)("\u4E3B\u9879\u76EE(Robot_Admin)")}`,
+          value: "full",
+          description: chalk.gray("\u5168\u9762\u4EE3\u7801\u8D28\u91CF\u7BA1\u63A7")
+        },
+        {
+          name: `\u81EA\u5B9A\u4E49    ${chalk.gray("\u2500\u2500 \u81EA\u7531\u7EC4\u5408\u9700\u8981\u7684\u5DE5\u5177\u94FE")}`,
+          value: "custom",
+          description: chalk.gray("\u7CBE\u786E\u63A7\u5236\u6BCF\u4E2A\u529F\u80FD\u6A21\u5757")
+        }
+      ],
+      default: "standard",
+      theme: { prefix: `  ${S.ARROW}` }
+    });
+    let features;
+    if (presetId === "custom") {
+      console.log();
+      console.log(
+        `  ${S.STEP} ${chalk.bold("\u9009\u62E9\u529F\u80FD")} ${chalk.gray(
+          "(Git \u63D0\u4EA4\u89C4\u8303\u9ED8\u8BA4\u5305\u542B)"
+        )}`
+      );
+      console.log();
+      const selected = await checkbox({
+        message: chalk.white("\u9009\u62E9\u9644\u52A0\u529F\u80FD (\u7A7A\u683C\u5207\u6362, \u56DE\u8F66\u786E\u8BA4)"),
+        choices: [
+          {
+            name: `ESLint           ${chalk.gray("\u4EE3\u7801\u8D28\u91CF\u68C0\u67E5")}`,
+            value: "eslint"
+          },
+          {
+            name: `lint-staged      ${chalk.gray("\u6682\u5B58\u533A\u589E\u91CF\u68C0\u67E5")}`,
+            value: "lintStaged"
+          },
+          {
+            name: `Prettier         ${chalk.gray("\u4EE3\u7801\u81EA\u52A8\u683C\u5F0F\u5316")}`,
+            value: "prettier"
+          },
+          {
+            name: `Oxlint           ${chalk.gray(
+              "\u9AD8\u6027\u80FD Lint \u5F15\u64CE (50x faster)"
+            )}`,
+            value: "oxlint"
+          },
+          {
+            name: `EditorConfig     ${chalk.gray("\u7F16\u8F91\u5668\u7EDF\u4E00\u914D\u7F6E")}`,
+            value: "editorconfig"
+          },
+          {
+            name: chalk.yellow("\u21A9 \u8FD4\u56DE\u4E0A\u4E00\u6B65"),
+            value: "__back__"
+          }
+        ],
+        theme: { prefix: `  ${S.ARROW}` }
+      });
+      if (selected.includes("__back__")) continue;
+      features = {
+        eslint: selected.includes("eslint"),
+        lintStaged: selected.includes("lintStaged"),
+        prettier: selected.includes("prettier"),
+        oxlint: selected.includes("oxlint"),
+        editorconfig: selected.includes("editorconfig")
+      };
+      if (features.oxlint && !features.eslint) {
+        console.log(
+          `
+  ${S.INFO} ${chalk.gray(
+            "Oxlint \u9700\u8981 ESLint \u914D\u5408\uFF0C\u5DF2\u81EA\u52A8\u542F\u7528 ESLint"
+          )}`
+        );
+        features.eslint = true;
+      }
+      if (features.lintStaged && !features.eslint && !features.prettier) {
+        console.log(
+          `
+  ${S.INFO} ${chalk.gray(
+            "lint-staged \u9700\u8981 ESLint \u6216 Prettier\uFF0C\u5DF2\u81EA\u52A8\u542F\u7528 ESLint"
+          )}`
+        );
+        features.eslint = true;
+      }
+    } else {
+      features = { ...PRESETS[presetId].features };
+    }
+    let eslintOpts = {
+      framework: "vue",
+      typescript: true,
+      jsdoc: false
+    };
+    if (features.eslint) {
+      console.log();
+      console.log(`  ${S.STEP} ${chalk.bold("ESLint \u914D\u7F6E")}`);
+      console.log();
+      const framework = await select({
+        message: chalk.white("\u9879\u76EE\u6846\u67B6"),
+        choices: [
+          {
+            name: "Vue 3",
+            value: "vue"
+          },
+          { name: "React", value: "react" },
+          { name: "Vanilla JS / TS", value: "vanilla" },
+          {
+            name: chalk.yellow("\u21A9 \u8FD4\u56DE\u4E0A\u4E00\u6B65"),
+            value: "__back__"
+          }
+        ],
+        default: options.framework || "vue",
+        theme: { prefix: `  ${S.ARROW}` }
+      });
+      if (framework === "__back__") continue;
+      const typescript = await confirm({
+        message: chalk.white("\u4F7F\u7528 TypeScript"),
+        default: options.typescript ?? true,
+        theme: { prefix: `  ${S.ARROW}` }
+      });
+      const jsdoc = await confirm({
+        message: chalk.white("\u5F3A\u5236 JSDoc \u6CE8\u91CA"),
+        default: options.jsdoc ?? true,
+        theme: { prefix: `  ${S.ARROW}` }
+      });
+      eslintOpts = { framework, typescript, jsdoc };
+    }
+    return { features, eslintOpts };
+  }
+}
+function printSummary(features, eslintOpts, pmName) {
+  console.log();
+  console.log(`  ${S.STEP} ${chalk.bold("\u914D\u7F6E\u6458\u8981")}`);
+  console.log();
+  console.log(
+    `  ${S.OK} ${chalk.white("\u6838\u5FC3")}   Commitizen + Commitlint + Husky`
+  );
+  if (features.eslint) {
+    const fw = eslintOpts.framework === "vue" ? "Vue 3" : eslintOpts.framework === "react" ? "React" : "Vanilla";
+    const ts = eslintOpts.typescript ? " + TS" : "";
+    const jsdoc = eslintOpts.jsdoc ? " + JSDoc" : "";
+    console.log(
+      `  ${S.OK} ${chalk.white("\u68C0\u67E5")}   ESLint (${fw}${ts}${jsdoc})`
+    );
+  }
+  if (features.lintStaged) {
+    console.log(`  ${S.OK} ${chalk.white("\u6682\u5B58")}   lint-staged`);
+  }
+  if (features.oxlint) {
+    console.log(
+      `  ${S.OK} ${chalk.white("\u52A0\u901F")}   Oxlint ${chalk.gray("(50x faster)")}`
+    );
+  }
+  if (features.prettier) {
+    console.log(`  ${S.OK} ${chalk.white("\u683C\u5F0F")}   Prettier`);
+  }
+  if (features.editorconfig) {
+    console.log(`  ${S.OK} ${chalk.white("\u7F16\u8F91")}   EditorConfig`);
+  }
+  console.log(`  ${S.DOT} ${chalk.gray("\u7BA1\u7406")}   ${pmName}`);
+  console.log();
+}
+async function installDependencies(cwd, pm, features, eslintOpts) {
+  const spinner = ora({
+    text: chalk.gray("\u5206\u6790\u4F9D\u8D56..."),
+    prefixText: "  ",
+    spinner: "dots"
+  }).start();
+  const deps = [
+    "@commitlint/cli",
+    "@commitlint/config-conventional",
+    "commitizen",
+    "cz-customizable",
+    "husky"
+  ];
+  if (features.eslint) {
+    deps.push("eslint");
+    if (eslintOpts.framework === "vue") {
+      deps.push("eslint-plugin-vue", "@vue/eslint-config-typescript");
+    }
+    if (eslintOpts.typescript) {
+      deps.push(
+        "@typescript-eslint/eslint-plugin",
+        "@typescript-eslint/parser"
+      );
+    }
+    if (eslintOpts.jsdoc) {
+      deps.push("eslint-plugin-jsdoc");
+    }
+  }
+  if (features.lintStaged) {
+    deps.push("lint-staged");
+  }
+  if (features.oxlint) {
+    deps.push("oxlint", "eslint-plugin-oxlint");
+  }
+  if (features.prettier) {
+    deps.push("prettier");
+    if (features.eslint && eslintOpts.framework === "vue") {
+      deps.push("@vue/eslint-config-prettier");
+    }
+  }
+  spinner.text = chalk.gray(`\u5B89\u88C5 ${deps.length} \u4E2A\u4F9D\u8D56...`);
+  try {
+    const installCmd = getInstallCommand(pm);
+    await execa2(
+      installCmd.split(" ")[0],
+      [...installCmd.split(" ").slice(1), ...deps],
+      { cwd, stdio: "pipe" }
+    );
+    spinner.succeed(
+      chalk.white("\u4F9D\u8D56\u5B89\u88C5\u5B8C\u6210 ") + chalk.gray(`(${deps.length} packages)`)
+    );
+  } catch (error) {
+    spinner.fail(chalk.red("\u4F9D\u8D56\u5B89\u88C5\u5931\u8D25"));
+    throw error;
+  }
+}
+async function generateConfigFiles(cwd, features, eslintOpts) {
+  const spinner = ora({
+    text: chalk.gray("\u751F\u6210\u914D\u7F6E\u6587\u4EF6..."),
+    prefixText: "  ",
+    spinner: "dots"
+  }).start();
+  const generated = [];
+  try {
+    const czConfig = `/*
+ * Commitizen \u81EA\u5B9A\u4E49\u914D\u7F6E (cz-customizable)
+ * @generated by @robot-admin/git-standards
+ *
+ * \u76F4\u63A5\u4FEE\u6539\u6B64\u6587\u4EF6\u5373\u53EF\u81EA\u5B9A\u4E49\u63D0\u4EA4\u89C4\u8303
+ */
+module.exports = {
+  scopes: [],
+  allowEmptyScopes: false,
+  allowCustomScopes: true,
+
+  types: [
+    { value: 'wip', name: 'wip:      \u{1F6A7} \u5F00\u53D1\u4E2D' },
+    { value: 'feat', name: 'feat:     \u{1F3AF} \u65B0\u529F\u80FD' },
+    { value: 'fix', name: 'fix:      \u{1F41B} Bug \u4FEE\u590D' },
+    { value: 'perf', name: 'perf:     \u26A1\uFE0F \u6027\u80FD\u4F18\u5316' },
+    { value: 'deps', name: 'deps:     \u{1F4E6} \u4F9D\u8D56\u66F4\u65B0' },
+    { value: 'refactor', name: 'refactor: \u267B\uFE0F  \u91CD\u6784' },
+    { value: 'docs', name: 'docs:     \u{1F4DA} \u6587\u6863\u53D8\u66F4' },
+    { value: 'test', name: 'test:     \u{1F50E} \u6D4B\u8BD5\u76F8\u5173' },
+    { value: 'style', name: 'style:    \u{1F484} \u4EE3\u7801\u6837\u5F0F' },
+    { value: 'build', name: 'build:    \u{1F9F3} \u6784\u5EFA/\u6253\u5305' },
+    { value: 'chore', name: 'chore:    \u{1F527} \u5176\u4ED6\u6742\u9879' },
+    { value: 'revert', name: 'revert:   \u{1F519} \u56DE\u9000' },
+  ],
+
+  messages: {
+    type: '\u8BF7\u9009\u62E9\u63D0\u4EA4\u7C7B\u578B:',
+    customScope: '\u8BF7\u8F93\u5165\u4FEE\u6539\u8303\u56F4(\u5FC5\u586B\uFF0C\u683C\u5F0F\u5982\uFF1A\u6A21\u5757/\u5B50\u6A21\u5757):',
+    subject: '\u8BF7\u7B80\u8981\u63CF\u8FF0\u63D0\u4EA4(\u5FC5\u586B\uFF0C\u4E0D\u52A0\u53E5\u53F7):',
+    body: '\u8BF7\u8F93\u5165\u66F4\u8BE6\u7EC6\u7684\u8BF4\u660E(\u53EF\u9009):\\n',
+    footer: 'Footer(\u53EF\u9009): \u4F8B\u5982 "Closes #123" \u6216 "Release-As: 1.3.1"\\n',
+    confirmCommit: '\u786E\u8BA4\u63D0\u4EA4\u4EE5\u4E0A\u5185\u5BB9\uFF1F(y/n/e/h)',
+  },
+
+  skipQuestions: ['body'],
+
+  allowBreakingChanges: ['feat', 'fix', 'refactor'],
+  breakingPrefix: 'BREAKING CHANGE:',
+
+  subjectLimit: 88,
+}
+`;
+    await writeFileContent(resolve4(cwd, ".cz-config.js"), czConfig);
+    generated.push(".cz-config.js");
+    const commitlintConfig = `/*
+ * Commitlint \u914D\u7F6E
+ * @generated by @robot-admin/git-standards
+ *
+ * \u76F4\u63A5\u4FEE\u6539\u6B64\u6587\u4EF6\u5373\u53EF\u81EA\u5B9A\u4E49\u63D0\u4EA4\u6821\u9A8C\u89C4\u5219
+ */
+module.exports = {
+  extends: ['@commitlint/config-conventional'],
+  rules: {
+    'type-enum': [
+      2,
+      'always',
+      [
+        'wip', 'feat', 'fix', 'docs', 'style', 'refactor',
+        'perf', 'test', 'chore', 'revert', 'build', 'deps',
+      ],
+    ],
+    'subject-case': [0],
+  },
+}
+`;
+    await writeFileContent(
+      resolve4(cwd, "commitlint.config.js"),
+      commitlintConfig
+    );
+    generated.push("commitlint.config.js");
+    if (features.prettier) {
+      const prettierConfig = `/*
+ * Prettier \u914D\u7F6E
+ * @generated by @robot-admin/git-standards
+ *
+ * \u76F4\u63A5\u4FEE\u6539\u6B64\u6587\u4EF6\u5373\u53EF\u81EA\u5B9A\u4E49\u683C\u5F0F\u5316\u89C4\u5219
+ */
+module.exports = {
+  $schema: 'https://json.schemastore.org/prettierrc',
+  semi: false,
+  singleQuote: true,
+  printWidth: 80,
+  tabWidth: 2,
+  quoteProps: 'as-needed',
+  trailingComma: 'es5',
+  bracketSpacing: true,
+  jsxSingleQuote: true,
+  arrowParens: 'avoid',
+  endOfLine: 'auto',
+  htmlWhitespaceSensitivity: 'strict',
+  vueIndentScriptAndStyle: true,
+  singleAttributePerLine: true,
+}
+`;
+      await writeFileContent(resolve4(cwd, ".prettierrc.js"), prettierConfig);
+      generated.push(".prettierrc.js");
+    }
+    if (features.eslint) {
+      const hasOxlint = features.oxlint;
+      const hasPrettier = features.prettier;
+      const hasJsdoc = eslintOpts.jsdoc;
+      const isVue = eslintOpts.framework === "vue";
+      const isTs = eslintOpts.typescript;
+      const importLines = [];
+      if (isVue) importLines.push("import pluginVue from 'eslint-plugin-vue'");
+      if (isVue && isTs) {
+        importLines.push(
+          "import {\n  defineConfigWithVueTs,\n  vueTsConfigs,\n} from '@vue/eslint-config-typescript'"
+        );
+      }
+      if (hasOxlint)
+        importLines.push("import oxlint from 'eslint-plugin-oxlint'");
+      if (hasPrettier && isVue) {
+        importLines.push(
+          "import skipFormatting from '@vue/eslint-config-prettier/skip-formatting'"
+        );
+      }
+      if (hasJsdoc)
+        importLines.push("import jsdocPlugin from 'eslint-plugin-jsdoc'");
+      const fileExts = isTs ? "js,ts,mts,tsx,vue" : "js,jsx,vue";
+      const vue2DeprecationRules = isVue ? `
+      //! \u4E3B\u52A8\u7981\u6B62 Vue 2 \u5199\u6CD5
+      'vue/no-deprecated-props-default-this': 'error',
+      'vue/no-deprecated-events-api': 'error',
+      'vue/no-deprecated-filter': 'error',
+      'vue/no-deprecated-functional-template': 'error',
+` : "";
+      const vueComponentRules = isVue ? `
+      // Vue \u89C4\u8303
+      //! PascalCase \u547D\u540D\u89C4\u8303
+      'vue/component-name-in-template-casing': [
+        'error',
+        'PascalCase',
+        {
+          registeredComponentsOnly: false,
+          ignores: [
+            'router-view',
+            'router-link',
+            'transition',
+            'draggable',
+            '/^icon-/i',
+            '/^C_/',
+            '/^c_/',
+            'v-md-editor',
+          ],
+        },
+      ],
+      'vue/multi-word-component-names': [
+        'error',
+        {
+          ignores: ['index'],
+        },
+      ],
+      //! \u7981\u6B62\u5728\u6A21\u677F\u4E2D\u6CE8\u518C\u4F46\u672A\u4F7F\u7528\u7684\u7EC4\u4EF6
+      'vue/no-unused-components': 'error',
+${vue2DeprecationRules}` : "";
+      const jsdocBlock = hasJsdoc ? `
+  //MARK: \u81EA\u5B9A\u4E49\u89C4\u5219\u7EC4\uFF08\u4F18\u5148\u7EA7\u6700\u9AD8\uFF09
+  {
+    plugins: {
+      jsdoc: jsdocPlugin,
+    },
+    rules: {
+      //! JSDoc \u6CE8\u91CA\u89C4\u5219
+      'jsdoc/require-jsdoc': [
+        'error',
+        {
+          require: {
+            FunctionDeclaration: true,
+            MethodDefinition: true,
+            ClassDeclaration: true,
+            ArrowFunctionExpression: false,
+            FunctionExpression: true,
+          },
+          contexts: [
+            'FunctionDeclaration',
+            'ClassDeclaration',
+            'ClassProperty',
+            'MethodDefinition',
+            'FunctionExpression',
+          ],
+          checkConstructors: true,
+          checkGetters: true,
+          checkSetters: true,
+        },
+      ],
+` : `
+  // \u81EA\u5B9A\u4E49\u89C4\u5219\u7EC4
+  {
+    rules: {
+`;
+      const fileTypeOverrides = isTs ? `
+  //MARK: \u6587\u4EF6\u7C7B\u578B\u8986\u76D6\u89C4\u5219
+
+  //! \u53D8\u91CF\u4F7F\u7528\u89C4\u5219
+  {
+    files: ['**/*.js'],
+    rules: {
+      'no-unused-vars': 'error',
+      '@typescript-eslint/no-unused-vars': 'off',
+    },
+  },
+  {
+    files: ['**/*.{ts,mts,tsx,vue}'],
+    rules: {
+      'no-unused-vars': 'off',
+      '@typescript-eslint/no-unused-vars': 'error',
+    },
+  },
+` : "";
+      const jsdocWhitelist = hasJsdoc ? `
+  //MARK: JSDoc \u767D\u540D\u5355\u8986\u76D6\u89C4\u5219
+  {
+    files: [
+      'src/router/**/*.ts',
+      'src/stores/**/*.ts',
+      'src/views/**/components/*.vue',
+    ],
+    rules: {
+      'jsdoc/require-jsdoc': 'off',
+      '@typescript-eslint/require-jsdoc': 'off',
+    },
+  },
+` : "";
+      const ignoreAssets = `
+  //MARK: ESLINT \u767D\u540D\u5355\u914D\u7F6E\u7EC4
+  {
+    name: 'app/ignore-assets',
+    ignores: [
+      'src/assets/images/**/*',
+      '**/*.d.ts',
+      '**/auto-imports.d.ts',
+      'src/views/**/components/*.vue',
+      'scripts/**/*',
+    ],
+  },
+`;
+      const tsRules = isTs ? `
+      //! \u5173\u95ED\u4E0E oxlint \u91CD\u590D\u7684 ESLint \u89C4\u5219
+      'no-undef': 'off',
+
+      //! \u5F15\u53F7\u89C4\u8303
+      '@typescript-eslint/quotes': ['error', 'single'],${isVue ? "\n      'vue/html-quotes': ['error', 'double']," : ""}
+
+      //! TypeScript \u5B89\u5168
+      '@typescript-eslint/no-explicit-any': 'off',
+      '@typescript-eslint/ban-ts-comment': [
+        'error',
+        {
+          'ts-ignore': 'allow-with-description',
+        },
+      ],
+
+      //! \u8868\u8FBE\u5F0F\u89C4\u8303
+      '@typescript-eslint/no-unused-expressions': [
+        'error',
+        {
+          allowShortCircuit: true,
+          allowTernary: false,
+          allowTaggedTemplates: false,
+          enforceForJSX: true,
+        },
+      ],
+` : "";
+      const useWrapper = isVue && isTs;
+      const wrapperStart = useWrapper ? "export default defineConfigWithVueTs(" : "export default [";
+      const wrapperEnd = useWrapper ? ")" : "]";
+      const oxlintLine = hasOxlint ? "\n  ...oxlint.configs['flat/recommended'], // \u9AD8\u6027\u80FD\u57FA\u7840\u6821\u9A8C\n" : "";
+      const vueLine = isVue ? `
+  //! \u5FFD\u7565\u8F6C\u4E49\u5B57\u7B26
+  {
+    rules: {
+      'no-useless-escape': 'off',
+    },
+  },
+
+  pluginVue.configs['flat/essential'], // Vue \u4E13\u7528\u89C4\u5219` : "";
+      const tsLine = isVue && isTs ? "\n  vueTsConfigs.recommended, // TS \u4E13\u7528\u89C4\u5219" : "";
+      const skipLine = hasPrettier && isVue ? "\n  skipFormatting" : "";
+      const eslintConfig = `/*
+ * ESLint Flat Config
+ * @generated by @robot-admin/git-standards
+ *
+ * \u76F4\u63A5\u4FEE\u6539\u6B64\u6587\u4EF6\u5373\u53EF\u81EA\u5B9A\u4E49 ESLint \u89C4\u5219
+ */
+${importLines.join("\n")}
+
+${wrapperStart}
+  //MARK: \u57FA\u7840\u914D\u7F6E\u7EC4
+  {
+    name: 'app/files-to-lint',
+    files: ['**/*.{${fileExts}}'],
+  },
+
+  {
+    name: 'app/files-to-ignore',
+    ignores: [
+      '**/dist/**',
+      '**/dist-ssr/**',
+      '**/coverage/**',
+    ],
+  },
+
+  //MARK: \u6838\u5FC3\u89C4\u5219\u7EC4\uFF08\u6309\u4F18\u5148\u7EA7\u6392\u5E8F\uFF09
+${oxlintLine}${vueLine}${tsLine}
+${fileTypeOverrides}
+${jsdocBlock}${tsRules}
+      //! \u4EE3\u7801\u590D\u6742\u5EA6
+      'max-depth': ['error', 4],
+      complexity: ['warn', 10],
+
+      //! \u5F02\u6B65\u4EE3\u7801\u89C4\u8303
+      'no-await-in-loop': 'error',
+${vueComponentRules}
+      //MARK: \u683C\u5F0F\u89C4\u8303
+      'no-irregular-whitespace': 'error',
+      'no-multi-spaces': 'error',
+      'space-infix-ops': 'error',
+      'array-bracket-spacing': ['error', 'never'],
+      'arrow-spacing': ['error', { before: true, after: true }],
+      'max-params': ['warn', 6],
+      'no-eval': 'error',
+      'prefer-const': 'warn',
+      'no-var': 'warn',
+      'prefer-destructuring': [
+        1,
+        { object: true, array: false },
+      ],
+      'no-duplicate-imports': 'error',
+    },
+  },
+${ignoreAssets}${jsdocWhitelist}${skipLine}
+${wrapperEnd}
+`;
+      await writeFileContent(resolve4(cwd, "eslint.config.ts"), eslintConfig);
+      generated.push("eslint.config.ts");
+    }
+    if (features.editorconfig) {
+      const editorConfig = `# EditorConfig - \u7F16\u8F91\u5668\u7EDF\u4E00\u914D\u7F6E
+# @generated by @robot-admin/git-standards
+# \u53C2\u8003: https://editorconfig.org
+
+root = true
+
+[*]
+charset = utf-8
+indent_style = space
+indent_size = 2
+end_of_line = lf
+insert_final_newline = true
+trim_trailing_whitespace = true
+
+[*.md]
+trim_trailing_whitespace = false
+
+[*.{yml,yaml}]
+indent_size = 2
+
+[Makefile]
+indent_style = tab
+`;
+      await writeFileContent(resolve4(cwd, ".editorconfig"), editorConfig);
+      generated.push(".editorconfig");
+    }
+    spinner.succeed(
+      chalk.white("\u914D\u7F6E\u6587\u4EF6\u751F\u6210\u5B8C\u6210 ") + chalk.gray(`(${generated.join(", ")})`)
+    );
+  } catch (error) {
+    spinner.fail(chalk.red("\u914D\u7F6E\u6587\u4EF6\u751F\u6210\u5931\u8D25"));
+    throw error;
+  }
+}
+async function setupHusky(cwd, pm, features) {
+  const spinner = ora({
+    text: chalk.gray("\u521D\u59CB\u5316 Husky..."),
+    prefixText: "  ",
+    spinner: "dots"
+  }).start();
+  try {
+    const execCmd = getExecCommand(pm);
+    await execa2(execCmd, ["husky", "init"], { cwd, stdio: "pipe" });
+    const legacyDir = resolve4(cwd, ".husky/_");
+    if (existsSync4(legacyDir)) {
+      rmSync(legacyDir, { recursive: true, force: true });
+    }
+    const commitMsg = `${execCmd} --no-install commitlint --edit "$1"
+`;
+    await writeFileContent(resolve4(cwd, ".husky/commit-msg"), commitMsg);
+    const hooks = ["commit-msg"];
+    const needsPreCommit = features.eslint || features.lintStaged || features.oxlint;
+    if (needsPreCommit) {
+      const cmds = [];
+      if (features.oxlint) {
+        cmds.push(`${execCmd} oxlint --max-warnings 0`);
+      }
+      if (features.lintStaged) {
+        cmds.push(`${execCmd} lint-staged`);
+      } else if (features.eslint) {
+        cmds.push(`${execCmd} eslint . --fix`);
+      }
+      await writeFileContent(
+        resolve4(cwd, ".husky/pre-commit"),
+        cmds.join("\n") + "\n"
+      );
+      hooks.push("pre-commit");
+    } else {
+      const defaultPreCommit = resolve4(cwd, ".husky/pre-commit");
+      if (existsSync4(defaultPreCommit)) {
+        unlinkSync(defaultPreCommit);
+      }
+    }
+    spinner.succeed(
+      chalk.white("Husky \u521D\u59CB\u5316\u5B8C\u6210 ") + chalk.gray(`(${hooks.join(", ")})`)
+    );
+  } catch (error) {
+    spinner.fail(chalk.red("Husky \u521D\u59CB\u5316\u5931\u8D25"));
+    throw error;
+  }
+}
+async function addPackageScripts(cwd, pm, features) {
+  const spinner = ora({
+    text: chalk.gray("\u66F4\u65B0 package.json..."),
+    prefixText: "  ",
+    spinner: "dots"
+  }).start();
+  try {
+    const packageJsonPath = resolve4(cwd, "package.json");
+    const packageJson = await readJsonFile(packageJsonPath);
+    const scripts = packageJson.scripts || {};
+    scripts.cz = "git-cz";
+    scripts.prepare = "husky";
+    if (features.eslint) {
+      scripts.lint = features.oxlint ? "oxlint . --fix -D correctness --ignore-path .gitignore && eslint . --fix" : "eslint . --fix";
+    }
+    if (features.prettier) {
+      scripts.format = "prettier --write src/";
+    }
+    const czConfig = {
+      commitizen: { path: "node_modules/cz-customizable" }
+    };
+    const updates = { scripts, config: czConfig };
+    if (features.lintStaged) {
+      updates["lint-staged"] = generateLintStagedConfig({
+        eslint: features.eslint,
+        oxlint: features.oxlint,
+        prettier: features.prettier
+      });
+    }
+    await updatePackageJson(updates, cwd);
+    const parts = ["scripts"];
+    if (features.lintStaged) parts.push("lint-staged");
+    spinner.succeed(
+      chalk.white("package.json \u66F4\u65B0\u5B8C\u6210 ") + chalk.gray(`(${parts.join(" + ")})`)
+    );
+  } catch (error) {
+    spinner.fail(chalk.red("package.json \u66F4\u65B0\u5931\u8D25"));
+    throw error;
+  }
+}
+function printCompletion(pm, features) {
+  console.log();
+  console.log(S.LINE);
+  console.log(`  ${S.OK} ${chalk.green.bold("\u521D\u59CB\u5316\u5B8C\u6210!")}`);
+  console.log(S.LINE);
+  console.log();
+  console.log(`  ${chalk.bold("\u5FEB\u901F\u5F00\u59CB:")}`);
+  console.log();
+  console.log(`  ${S.DOT} \u63D0\u4EA4\u4EE3\u7801  ${chalk.cyan(`${pm} run cz`)}`);
+  if (features.eslint) {
+    console.log(`  ${S.DOT} \u68C0\u67E5\u4EE3\u7801  ${chalk.cyan(`${pm} run lint`)}`);
+  }
+  if (features.prettier) {
+    console.log(`  ${S.DOT} \u683C\u5F0F\u5316    ${chalk.cyan(`${pm} run format`)}`);
+  }
+  console.log();
+  console.log(
+    `  ${S.INFO} ${chalk.gray("\u5168\u5C40\u5B89\u88C5 commitizen \u540E\u53EF\u76F4\u63A5\u4F7F\u7528 git cz \u63D0\u4EA4")}`
+  );
+  console.log(`  ${S.DOT} ${chalk.gray(`npm install -g commitizen`)}`);
+  console.log();
+  console.log(
+    `  ${S.INFO} ${chalk.gray("\u6240\u6709\u914D\u7F6E\u6587\u4EF6\u5747\u652F\u6301\u8986\u76D6\u6269\u5C55\uFF0C\u8BE6\u89C1 README.md")}`
+  );
+  console.log();
+}
+
+// src/cli/doctor.ts
+import { resolve as resolve5 } from "path";
+import chalk2 from "chalk";
+var BRAND2 = "#7C3AED";
+var S2 = {
+  LOGO: chalk2.hex(BRAND2).bold("[RS]"),
+  OK: chalk2.green("\u2714"),
+  FAIL: chalk2.red("\u2716"),
+  WARN: chalk2.yellow("\u25B2"),
+  SKIP: chalk2.gray("\u25CB"),
+  LINE: chalk2.gray("\u2500".repeat(48))
+};
+async function doctor(options = {}) {
+  const cwd = options.cwd || process.cwd();
+  console.log();
+  console.log(S2.LINE);
+  console.log(
+    `  ${S2.LOGO}  ${chalk2.bold("Robot Standards")}  ${chalk2.gray("Doctor")}`
+  );
+  console.log(S2.LINE);
+  console.log();
+  const checks = [];
+  const isGit = isGitRepository(cwd);
+  checks.push({
+    name: "Git \u4ED3\u5E93",
+    status: isGit ? "pass" : "fail",
+    message: isGit ? void 0 : "\u672A\u521D\u59CB\u5316 Git \u4ED3\u5E93\uFF0C\u8FD0\u884C git init"
+  });
+  let packageJson = {};
+  const packageJsonPath = resolve5(cwd, "package.json");
+  const hasPackageJson = fileExists(packageJsonPath);
+  if (hasPackageJson) {
+    try {
+      packageJson = await readJsonFile(packageJsonPath);
+    } catch {
+    }
+  } else {
+    checks.push({
+      name: "package.json",
+      status: "fail",
+      message: "\u7F3A\u5C11 package.json"
+    });
+  }
+  const allDeps = {
+    ...packageJson.dependencies,
+    ...packageJson.devDependencies
+  };
+  const hasCommitizen = !!allDeps["commitizen"];
+  const hasCommitlint = !!allDeps["@commitlint/cli"];
+  const hasHusky = !!allDeps["husky"];
+  const hasEslint = !!allDeps["eslint"];
+  const hasLintStaged = !!allDeps["lint-staged"];
+  const hasPrettier = !!allDeps["prettier"];
+  console.log(`  ${chalk2.bold("\u6838\u5FC3\u529F\u80FD")}`);
+  console.log();
+  if (hasHusky) {
+    const huskyDir = fileExists(resolve5(cwd, ".husky"));
+    checks.push({
+      name: "Husky \u76EE\u5F55",
+      status: huskyDir ? "pass" : "fail",
+      message: huskyDir ? void 0 : "\u7F3A\u5C11 .husky \u76EE\u5F55"
+    });
+    const commitMsg = fileExists(resolve5(cwd, ".husky/commit-msg"));
+    checks.push({
+      name: "commit-msg hook",
+      status: commitMsg ? "pass" : "fail",
+      message: commitMsg ? void 0 : "\u7F3A\u5C11 commit-msg hook"
+    });
+  } else {
+    checks.push({
+      name: "Husky",
+      status: "fail",
+      message: "\u672A\u5B89\u88C5 husky"
+    });
+  }
+  if (hasCommitlint) {
+    const hasConfig = fileExists(resolve5(cwd, "commitlint.config.cjs")) || fileExists(resolve5(cwd, "commitlint.config.js")) || fileExists(resolve5(cwd, "commitlint.config.ts"));
+    checks.push({
+      name: "Commitlint \u914D\u7F6E",
+      status: hasConfig ? "pass" : "fail",
+      message: hasConfig ? void 0 : "\u7F3A\u5C11 commitlint.config.*"
+    });
+  } else {
+    checks.push({
+      name: "Commitlint",
+      status: "fail",
+      message: "\u672A\u5B89\u88C5 @commitlint/cli"
+    });
+  }
+  if (hasCommitizen) {
+    const hasCzConfig = fileExists(resolve5(cwd, ".cz-config.cjs")) || fileExists(resolve5(cwd, ".cz-config.js"));
+    checks.push({
+      name: "Commitizen \u914D\u7F6E",
+      status: hasCzConfig ? "pass" : "fail",
+      message: hasCzConfig ? void 0 : "\u7F3A\u5C11 .cz-config.*"
+    });
+    const hasCommitizenPath = !!packageJson.config?.commitizen;
+    checks.push({
+      name: "commitizen path \u914D\u7F6E",
+      status: hasCommitizenPath ? "pass" : "fail",
+      message: hasCommitizenPath ? void 0 : "package.json \u4E2D\u7F3A\u5C11 config.commitizen"
+    });
+  } else {
+    checks.push({
+      name: "Commitizen",
+      status: "fail",
+      message: "\u672A\u5B89\u88C5 commitizen"
+    });
+  }
+  const hasCzScript = !!packageJson.scripts?.cz;
+  checks.push({
+    name: "cz \u811A\u672C",
+    status: hasCzScript ? "pass" : "fail",
+    message: hasCzScript ? void 0 : "\u7F3A\u5C11 cz \u811A\u672C (bun run cz)"
+  });
+  const coreChecks = checks.slice();
+  for (const check of coreChecks) {
+    printCheck(check);
+  }
+  const extraChecks = [];
+  if (hasEslint) {
+    console.log();
+    console.log(`  ${chalk2.bold("\u4EE3\u7801\u68C0\u67E5")}`);
+    console.log();
+    const hasEslintConfig = fileExists(resolve5(cwd, "eslint.config.ts")) || fileExists(resolve5(cwd, "eslint.config.js")) || fileExists(resolve5(cwd, "eslint.config.mjs"));
+    const eslintCheck = {
+      name: "ESLint \u914D\u7F6E",
+      status: hasEslintConfig ? "pass" : "fail",
+      message: hasEslintConfig ? void 0 : "\u7F3A\u5C11 eslint.config.*"
+    };
+    extraChecks.push(eslintCheck);
+    printCheck(eslintCheck);
+    if (hasHusky) {
+      const preCommit = fileExists(resolve5(cwd, ".husky/pre-commit"));
+      const preCommitCheck = {
+        name: "pre-commit hook",
+        status: preCommit ? "pass" : "fail",
+        message: preCommit ? void 0 : "\u7F3A\u5C11 pre-commit hook"
+      };
+      extraChecks.push(preCommitCheck);
+      printCheck(preCommitCheck);
+    }
+  }
+  if (hasLintStaged) {
+    const lintStagedConfig = !!packageJson["lint-staged"];
+    const lintStagedCheck = {
+      name: "lint-staged \u914D\u7F6E",
+      status: lintStagedConfig ? "pass" : "fail",
+      message: lintStagedConfig ? void 0 : "package.json \u4E2D\u7F3A\u5C11 lint-staged \u914D\u7F6E"
+    };
+    extraChecks.push(lintStagedCheck);
+    printCheck(lintStagedCheck);
+  }
+  if (hasPrettier) {
+    console.log();
+    console.log(`  ${chalk2.bold("\u4EE3\u7801\u683C\u5F0F\u5316")}`);
+    console.log();
+    const hasPrettierConfig = fileExists(resolve5(cwd, ".prettierrc.cjs")) || fileExists(resolve5(cwd, ".prettierrc.js")) || fileExists(resolve5(cwd, ".prettierrc.json")) || fileExists(resolve5(cwd, ".prettierrc"));
+    const prettierCheck = {
+      name: "Prettier \u914D\u7F6E",
+      status: hasPrettierConfig ? "pass" : "fail",
+      message: hasPrettierConfig ? void 0 : "\u7F3A\u5C11 .prettierrc.*"
+    };
+    extraChecks.push(prettierCheck);
+    printCheck(prettierCheck);
+  }
+  const hasEditorConfig = fileExists(resolve5(cwd, ".editorconfig"));
+  if (hasEditorConfig) {
+  }
+  const notInstalled = [];
+  if (!hasEslint) notInstalled.push("ESLint");
+  if (!hasLintStaged) notInstalled.push("lint-staged");
+  if (!hasPrettier) notInstalled.push("Prettier");
+  if (!hasEditorConfig) notInstalled.push("EditorConfig");
+  if (notInstalled.length > 0) {
+    console.log();
+    console.log(`  ${chalk2.bold("\u672A\u542F\u7528\u7684\u529F\u80FD")}`);
+    console.log();
+    for (const name of notInstalled) {
+      console.log(`  ${S2.SKIP} ${chalk2.gray(name)}`);
+    }
+  }
+  const allChecks = [...coreChecks, ...extraChecks];
+  const passedCount = allChecks.filter((c) => c.status === "pass").length;
+  const failedCount = allChecks.filter((c) => c.status === "fail").length;
+  console.log();
+  console.log(S2.LINE);
+  console.log(
+    `  ${chalk2.bold("\u603B\u8BA1:")} ${chalk2.green(`${passedCount} \u901A\u8FC7`)}  ${failedCount > 0 ? chalk2.red(`${failedCount} \u5931\u8D25`) : chalk2.gray("0 \u5931\u8D25")}`
+  );
+  if (failedCount > 0) {
+    console.log();
+    console.log(
+      `  ${S2.WARN} ${chalk2.yellow("\u8FD0\u884C")} ${chalk2.cyan(
+        "robot-standards init"
+      )} ${chalk2.yellow("\u4FEE\u590D\u95EE\u9898")}`
+    );
+  } else {
+    console.log();
+    console.log(`  ${S2.OK} ${chalk2.green("\u6240\u6709\u68C0\u67E5\u901A\u8FC7!")}`);
+  }
+  console.log(S2.LINE);
+  console.log();
+  return failedCount === 0;
+}
+function printCheck(check) {
+  const icon = check.status === "pass" ? S2.OK : check.status === "fail" ? S2.FAIL : S2.SKIP;
+  console.log(`  ${icon} ${check.name}`);
+  if (check.message && check.status === "fail") {
+    console.log(`    ${chalk2.gray(check.message)}`);
+  }
+}
+export {
+  createLintStagedConfig,
+  detectPackageManager,
+  doctor,
+  fileExists,
+  generateLintStagedConfig,
+  getExecCommand,
+  getInstallCommand,
+  getPackageManagerName,
+  init,
+  initGitRepository,
+  isGitRepository,
+  readFileContent,
+  readJsonFile,
+  updatePackageJson,
+  writeFileContent,
+  writeJsonFile
+};
+//# sourceMappingURL=index.js.map