create-idp 0.1.0

package/dist/index.js

@@ -0,0 +1,702 @@
+#!/usr/bin/env node
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/cli.ts
+import { Command } from "commander";
+import pc6 from "picocolors";
+
+// package.json
+var version = "0.1.0";
+
+// src/prompts.ts
+import path2 from "path";
+import fs from "fs";
+import { input, select, confirm } from "@inquirer/prompts";
+import pc from "picocolors";
+
+// src/utils.ts
+import path from "path";
+import { fileURLToPath } from "url";
+import { spawn } from "child_process";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path.dirname(__filename);
+function getTemplatesDir() {
+  return path.resolve(__dirname, "..", "templates");
+}
+function isValidPackageName(name) {
+  return /^(?:@[a-z0-9-*~][a-z0-9-*._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/.test(name);
+}
+function toValidPackageName(name) {
+  return name.trim().toLowerCase().replace(/\s+/g, "-").replace(/^[._]/, "").replace(/[^a-z0-9-~]+/g, "-");
+}
+function isEmpty(dirPath) {
+  const fs5 = __require("fs");
+  if (!fs5.existsSync(dirPath)) {
+    return true;
+  }
+  const files = fs5.readdirSync(dirPath);
+  return files.length === 0 || files.length === 1 && files[0] === ".git";
+}
+function execAsync(command, args, options = {}) {
+  return new Promise((resolve) => {
+    const proc = spawn(command, args, {
+      cwd: options.cwd,
+      stdio: options.stdio === "inherit" ? "inherit" : "pipe",
+      shell: true
+    });
+    let stdout = "";
+    let stderr = "";
+    if (proc.stdout) {
+      proc.stdout.on("data", (data) => {
+        stdout += data.toString();
+      });
+    }
+    if (proc.stderr) {
+      proc.stderr.on("data", (data) => {
+        stderr += data.toString();
+      });
+    }
+    proc.on("close", (code) => {
+      resolve({ code: code ?? 1, stdout, stderr });
+    });
+    proc.on("error", () => {
+      resolve({ code: 1, stdout, stderr });
+    });
+  });
+}
+
+// src/prompts.ts
+async function runPrompts(argProjectName, options, userConfig = {}) {
+  const defaults = userConfig.defaults ?? {};
+  const templatesDir = getTemplatesDir();
+  const registryPath = path2.join(templatesDir, "template.config.json");
+  const registry = JSON.parse(
+    fs.readFileSync(registryPath, "utf-8")
+  );
+  let projectName = argProjectName;
+  if (!projectName) {
+    projectName = await input({
+      message: "\u9879\u76EE\u540D\u79F0:",
+      default: "my-project",
+      validate: (value) => {
+        if (!value.trim()) {
+          return "\u9879\u76EE\u540D\u79F0\u4E0D\u80FD\u4E3A\u7A7A";
+        }
+        if (!isValidPackageName(toValidPackageName(value))) {
+          return "\u65E0\u6548\u7684\u9879\u76EE\u540D\u79F0";
+        }
+        return true;
+      }
+    });
+  }
+  const validName = toValidPackageName(projectName);
+  const targetDir = path2.resolve(process.cwd(), validName);
+  if (fs.existsSync(targetDir) && !isEmpty(targetDir)) {
+    const overwrite = await confirm({
+      message: `\u76EE\u6807\u76EE\u5F55 "${validName}" \u975E\u7A7A\uFF0C\u662F\u5426\u7EE7\u7EED? (\u5C06\u8986\u76D6\u5DF2\u6709\u6587\u4EF6)`,
+      default: false
+    });
+    if (!overwrite) {
+      const error = new Error("PROMPT_CANCELLED");
+      throw error;
+    }
+  }
+  let template = options.template;
+  if (!template) {
+    const defaultTemplate = defaults.template;
+    const templateChoices = registry.templates.map((t) => ({
+      name: `${t.displayName} ${pc.dim(`- ${t.description}`)}`,
+      value: t.name
+    }));
+    template = await select({
+      message: "\u9009\u62E9\u6A21\u677F:",
+      choices: templateChoices,
+      default: defaultTemplate && registry.templates.some((t) => t.name === defaultTemplate) ? defaultTemplate : void 0
+    });
+  } else {
+    const found = registry.templates.find((t) => t.name === template);
+    if (!found) {
+      console.log(pc.red(`\u9519\u8BEF: \u672A\u627E\u5230\u6A21\u677F "${template}"`));
+      console.log(pc.dim(`\u53EF\u7528\u6A21\u677F: ${registry.templates.map((t) => t.name).join(", ")}`));
+      process.exit(1);
+    }
+  }
+  let initGit2 = options.git !== false;
+  if (options.git === void 0) {
+    initGit2 = await confirm({
+      message: "\u521D\u59CB\u5316 Git \u4ED3\u5E93?",
+      default: true
+    });
+  }
+  let createGithub = options.github ?? false;
+  if (initGit2 && options.github === void 0) {
+    createGithub = await confirm({
+      message: "\u5728 GitHub \u521B\u5EFA\u8FDC\u7A0B\u4ED3\u5E93?",
+      default: defaults.github ?? false
+    });
+  }
+  let isPublic = options.public ?? false;
+  if (createGithub && options.public === void 0) {
+    const publicDefault = defaults.public ?? false;
+    isPublic = await select({
+      message: "\u4ED3\u5E93\u53EF\u89C1\u6027:",
+      choices: [
+        { name: "private (\u79C1\u6709)", value: false },
+        { name: "public (\u516C\u5F00)", value: true }
+      ],
+      default: publicDefault
+    });
+  }
+  return {
+    projectName: validName,
+    template,
+    targetDir,
+    initGit: initGit2,
+    createGithub,
+    isPublic,
+    noInstall: options.install === false
+  };
+}
+
+// src/scaffold.ts
+import path3 from "path";
+import fs2 from "fs-extra";
+async function scaffoldProject(options) {
+  const templatesDir = getTemplatesDir();
+  const registryPath = path3.join(templatesDir, "template.config.json");
+  const registry = await fs2.readJson(registryPath);
+  const templateEntry = registry.templates.find((t) => t.name === options.template);
+  if (!templateEntry) {
+    throw new Error(`\u672A\u627E\u5230\u6A21\u677F: ${options.template}`);
+  }
+  const templateDir = path3.join(templatesDir, templateEntry.dir);
+  const templateConfigPath = path3.join(templateDir, "_template.json");
+  let templateConfig = null;
+  if (await fs2.pathExists(templateConfigPath)) {
+    templateConfig = await fs2.readJson(templateConfigPath);
+  }
+  await fs2.ensureDir(options.targetDir);
+  const files = await fs2.readdir(templateDir);
+  for (const file of files) {
+    if (file === "_template.json") {
+      continue;
+    }
+    const srcPath = path3.join(templateDir, file);
+    let destFileName = file;
+    if (templateConfig?.fileRenames?.[file]) {
+      destFileName = templateConfig.fileRenames[file];
+      if (destFileName === "{{projectName}}") {
+        destFileName = options.projectName;
+      }
+    }
+    const destPath = path3.join(options.targetDir, destFileName);
+    const stat = await fs2.stat(srcPath);
+    if (stat.isDirectory()) {
+      await copyDirectory(srcPath, destPath, options.projectName, templateConfig);
+    } else {
+      await copyFile(srcPath, destPath, options.projectName, templateConfig);
+    }
+  }
+  return templateConfig;
+}
+async function copyDirectory(srcDir, destDir, projectName, config) {
+  await fs2.ensureDir(destDir);
+  const files = await fs2.readdir(srcDir);
+  for (const file of files) {
+    const srcPath = path3.join(srcDir, file);
+    let destFileName = file;
+    if (config?.fileRenames?.[file]) {
+      destFileName = config.fileRenames[file];
+      if (destFileName === "{{projectName}}") {
+        destFileName = projectName;
+      }
+    }
+    const destPath = path3.join(destDir, destFileName);
+    const stat = await fs2.stat(srcPath);
+    if (stat.isDirectory()) {
+      await copyDirectory(srcPath, destPath, projectName, config);
+    } else {
+      await copyFile(srcPath, destPath, projectName, config);
+    }
+  }
+}
+async function copyFile(srcPath, destPath, projectName, config) {
+  const binaryExtensions = [
+    ".png",
+    ".jpg",
+    ".jpeg",
+    ".gif",
+    ".ico",
+    ".webp",
+    ".woff",
+    ".woff2",
+    ".ttf",
+    ".eot",
+    ".zip",
+    ".tar",
+    ".gz"
+  ];
+  const ext = path3.extname(srcPath).toLowerCase();
+  if (binaryExtensions.includes(ext)) {
+    await fs2.copy(srcPath, destPath);
+    return;
+  }
+  let content = await fs2.readFile(srcPath, "utf-8");
+  content = content.replace(/\{\{projectName\}\}/g, projectName);
+  if (config?.variables) {
+    for (const [key, value] of Object.entries(config.variables)) {
+      const placeholder = `{{${key}}}`;
+      const replacement = value === "{{projectName}}" ? projectName : value;
+      content = content.replace(new RegExp(placeholder.replace(/[{}]/g, "\\$&"), "g"), replacement);
+    }
+  }
+  await fs2.writeFile(destPath, content, "utf-8");
+}
+
+// src/git.ts
+import pc2 from "picocolors";
+
+// src/config.ts
+import fs3 from "fs";
+import path4 from "path";
+import os from "os";
+var CONFIG_PATH = path4.join(os.homedir(), ".create-idp.json");
+function loadConfig() {
+  try {
+    if (fs3.existsSync(CONFIG_PATH)) {
+      const content = fs3.readFileSync(CONFIG_PATH, "utf-8");
+      return JSON.parse(content);
+    }
+  } catch {
+  }
+  return {};
+}
+function saveConfig(config) {
+  fs3.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), "utf-8");
+  fs3.chmodSync(CONFIG_PATH, 384);
+}
+function getConfigPath() {
+  return CONFIG_PATH;
+}
+
+// src/github-api.ts
+var GITHUB_API_BASE = "https://api.github.com";
+async function githubFetch(endpoint, token, options = {}) {
+  const url = `${GITHUB_API_BASE}${endpoint}`;
+  try {
+    const response = await fetch(url, {
+      ...options,
+      headers: {
+        "Accept": "application/vnd.github+json",
+        "Authorization": `Bearer ${token}`,
+        "X-GitHub-Api-Version": "2022-11-28",
+        "User-Agent": "create-idp",
+        ...options.headers
+      }
+    });
+    if (response.status === 403) {
+      const rateLimitRemaining = response.headers.get("x-ratelimit-remaining");
+      const rateLimitReset = response.headers.get("x-ratelimit-reset");
+      if (rateLimitRemaining === "0" && rateLimitReset) {
+        const resetDate = new Date(parseInt(rateLimitReset) * 1e3);
+        return {
+          success: false,
+          error: "API \u8BF7\u6C42\u6B21\u6570\u5DF2\u8FBE\u4E0A\u9650",
+          statusCode: 403,
+          rateLimitReset: resetDate
+        };
+      }
+    }
+    if (response.status === 401) {
+      return {
+        success: false,
+        error: "Token \u65E0\u6548\u6216\u5DF2\u8FC7\u671F",
+        statusCode: 401
+      };
+    }
+    if (!response.ok) {
+      const errorData = await response.json();
+      return {
+        success: false,
+        error: errorData.message || `\u8BF7\u6C42\u5931\u8D25: ${response.status}`,
+        statusCode: response.status
+      };
+    }
+    const data = await response.json();
+    return { success: true, data };
+  } catch (err) {
+    return {
+      success: false,
+      error: err instanceof Error ? err.message : "\u7F51\u7EDC\u8BF7\u6C42\u5931\u8D25"
+    };
+  }
+}
+async function validateToken(token) {
+  return githubFetch("/user", token);
+}
+async function createRepository(token, options) {
+  const endpoint = options.org ? `/orgs/${options.org}/repos` : "/user/repos";
+  const body = {
+    name: options.name,
+    description: options.description || `Created with create-idp`,
+    private: options.isPrivate,
+    auto_init: false
+  };
+  return githubFetch(endpoint, token, {
+    method: "POST",
+    body: JSON.stringify(body)
+  });
+}
+
+// src/git.ts
+async function initGit(targetDir) {
+  await execAsync("git", ["init"], { cwd: targetDir });
+  await execAsync("git", ["add", "-A"], { cwd: targetDir });
+  await execAsync("git", ["commit", "-m", "Initial commit"], { cwd: targetDir });
+}
+async function createGithubRepo(repoName, targetDir, isPublic) {
+  const config = loadConfig();
+  if (!config.github?.token) {
+    console.log(pc2.yellow("\u26A0 \u672A\u914D\u7F6E GitHub Token\uFF0C\u8DF3\u8FC7\u4ED3\u5E93\u521B\u5EFA"));
+    console.log(pc2.dim(`  \u8FD0\u884C ${pc2.cyan("create-idp config --setup-github")} \u914D\u7F6E Token`));
+    console.log(pc2.dim(`  \u914D\u7F6E\u6587\u4EF6\u8DEF\u5F84: ${getConfigPath()}`));
+    return null;
+  }
+  const token = config.github.token;
+  const defaultOrg = config.github.defaultOrg;
+  const validateResult = await validateToken(token);
+  if (!validateResult.success) {
+    console.log(pc2.yellow(`\u26A0 GitHub Token \u65E0\u6548: ${validateResult.error}`));
+    if (validateResult.rateLimitReset) {
+      console.log(pc2.dim(`  Rate limit \u5C06\u5728 ${validateResult.rateLimitReset.toLocaleString()} \u91CD\u7F6E`));
+    }
+    console.log(pc2.dim(`  \u8FD0\u884C ${pc2.cyan("create-idp config --setup-github")} \u91CD\u65B0\u914D\u7F6E`));
+    return null;
+  }
+  const username = validateResult.data.login;
+  const createResult = await createRepository(token, {
+    name: repoName,
+    isPrivate: !isPublic,
+    org: defaultOrg
+  });
+  if (!createResult.success) {
+    if (createResult.statusCode === 422) {
+      console.log(pc2.yellow(`\u26A0 \u4ED3\u5E93 "${repoName}" \u5DF2\u5B58\u5728\uFF0C\u8BF7\u9009\u62E9\u5176\u4ED6\u540D\u79F0`));
+    } else if (createResult.rateLimitReset) {
+      console.log(pc2.yellow(`\u26A0 API \u8BF7\u6C42\u6B21\u6570\u5DF2\u8FBE\u4E0A\u9650`));
+      console.log(pc2.dim(`  \u5C06\u5728 ${createResult.rateLimitReset.toLocaleString()} \u91CD\u7F6E`));
+    } else {
+      console.log(pc2.yellow(`\u26A0 \u521B\u5EFA\u4ED3\u5E93\u5931\u8D25: ${createResult.error}`));
+    }
+    return null;
+  }
+  const repo = createResult.data;
+  const remoteResult = await execAsync(
+    "git",
+    ["remote", "add", "origin", repo.clone_url],
+    { cwd: targetDir }
+  );
+  if (remoteResult.code !== 0) {
+    await execAsync(
+      "git",
+      ["remote", "set-url", "origin", repo.clone_url],
+      { cwd: targetDir }
+    );
+  }
+  const pushResult = await execAsync(
+    "git",
+    ["push", "-u", "origin", "main"],
+    { cwd: targetDir }
+  );
+  if (pushResult.code !== 0) {
+    const pushMaster = await execAsync(
+      "git",
+      ["push", "-u", "origin", "master"],
+      { cwd: targetDir }
+    );
+    if (pushMaster.code !== 0) {
+      console.log(pc2.yellow(`\u26A0 \u63A8\u9001\u5931\u8D25: ${pushResult.stderr || pushMaster.stderr}`));
+      console.log(pc2.dim(`  \u4ED3\u5E93\u5DF2\u521B\u5EFA: ${repo.html_url}`));
+      console.log(pc2.dim("  \u8BF7\u624B\u52A8\u63A8\u9001\u4EE3\u7801"));
+      return repo.html_url;
+    }
+  }
+  return repo.html_url;
+}
+
+// src/post-init.ts
+import pc3 from "picocolors";
+async function runPostInit(targetDir, commands) {
+  for (const cmd of commands) {
+    console.log(pc3.dim(`  ${cmd.description}...`));
+    const [command, ...args] = cmd.command.split(" ");
+    const result = await execAsync(command, args, {
+      cwd: targetDir,
+      stdio: "pipe"
+    });
+    if (result.code !== 0) {
+      console.log(pc3.yellow(`\u26A0 ${cmd.description} \u5931\u8D25`));
+      if (result.stderr) {
+        console.log(pc3.dim(result.stderr.slice(0, 200)));
+      }
+    }
+  }
+}
+
+// src/update-check.ts
+import fs4 from "fs";
+import path5 from "path";
+import os2 from "os";
+import pc4 from "picocolors";
+var CACHE_PATH = path5.join(os2.homedir(), ".create-idp-update-check");
+var CACHE_TTL = 24 * 60 * 60 * 1e3;
+var PACKAGE_NAME = "create-idp";
+function readCache() {
+  try {
+    if (fs4.existsSync(CACHE_PATH)) {
+      const content = fs4.readFileSync(CACHE_PATH, "utf-8");
+      return JSON.parse(content);
+    }
+  } catch {
+  }
+  return null;
+}
+function writeCache(cache) {
+  try {
+    fs4.writeFileSync(CACHE_PATH, JSON.stringify(cache), "utf-8");
+  } catch {
+  }
+}
+async function fetchLatestVersion() {
+  try {
+    const response = await fetch(`https://registry.npmjs.org/${PACKAGE_NAME}/latest`);
+    if (!response.ok) {
+      return null;
+    }
+    const data = await response.json();
+    return data.version;
+  } catch {
+    return null;
+  }
+}
+function compareVersions(current, latest) {
+  const currentParts = current.split(".").map(Number);
+  const latestParts = latest.split(".").map(Number);
+  for (let i = 0; i < Math.max(currentParts.length, latestParts.length); i++) {
+    const c = currentParts[i] || 0;
+    const l = latestParts[i] || 0;
+    if (c < l) return -1;
+    if (c > l) return 1;
+  }
+  return 0;
+}
+async function checkForUpdates(currentVersion) {
+  const cache = readCache();
+  const now = Date.now();
+  let latestVersion = null;
+  if (cache && now - cache.lastCheck < CACHE_TTL) {
+    latestVersion = cache.latestVersion;
+  } else {
+    latestVersion = await fetchLatestVersion();
+    if (latestVersion) {
+      writeCache({ lastCheck: now, latestVersion });
+    }
+  }
+  if (latestVersion && compareVersions(currentVersion, latestVersion) < 0) {
+    console.log();
+    console.log(
+      pc4.yellow(`  \u26A0 \u53D1\u73B0\u65B0\u7248\u672C ${pc4.bold(latestVersion)}\uFF0C\u5F53\u524D ${currentVersion}`)
+    );
+    console.log(pc4.cyan(`    \u8FD0\u884C ${pc4.bold(`npm update -g ${PACKAGE_NAME}`)} \u66F4\u65B0`));
+    console.log();
+  }
+}
+
+// src/github-setup.ts
+import { input as input2, confirm as confirm2 } from "@inquirer/prompts";
+import pc5 from "picocolors";
+var TOKEN_HELP_URL = "https://github.com/settings/tokens/new?scopes=repo&description=create-idp";
+async function runGitHubSetup() {
+  console.log();
+  console.log(pc5.cyan("\u914D\u7F6E GitHub Token"));
+  console.log();
+  console.log("\u9700\u8981\u4E00\u4E2A\u5177\u6709 repo \u6743\u9650\u7684 Personal Access Token (Classic) \u6765\u521B\u5EFA\u4ED3\u5E93\u3002");
+  console.log();
+  console.log(pc5.dim("\u83B7\u53D6\u6B65\u9AA4:"));
+  console.log(pc5.dim("1. \u8BBF\u95EE GitHub Settings > Developer settings > Personal access tokens"));
+  console.log(pc5.dim('2. \u70B9\u51FB "Generate new token (classic)"'));
+  console.log(pc5.dim('3. \u52FE\u9009 "repo" \u6743\u9650'));
+  console.log(pc5.dim("4. \u751F\u6210\u5E76\u590D\u5236 Token"));
+  console.log();
+  console.log(pc5.dim(`\u5FEB\u6377\u94FE\u63A5: ${TOKEN_HELP_URL}`));
+  console.log();
+  const token = await input2({
+    message: "\u8BF7\u8F93\u5165 GitHub Token:",
+    validate: (value) => {
+      if (!value.trim()) {
+        return "Token \u4E0D\u80FD\u4E3A\u7A7A";
+      }
+      if (!value.startsWith("ghp_") && !value.startsWith("github_pat_")) {
+        return "Token \u683C\u5F0F\u4E0D\u6B63\u786E\uFF0C\u5E94\u4EE5 ghp_ \u6216 github_pat_ \u5F00\u5934";
+      }
+      return true;
+    }
+  });
+  console.log();
+  console.log(pc5.dim("\u6B63\u5728\u9A8C\u8BC1 Token..."));
+  const result = await validateToken(token.trim());
+  if (!result.success) {
+    console.log(pc5.red(`\u2717 Token \u9A8C\u8BC1\u5931\u8D25: ${result.error}`));
+    if (result.rateLimitReset) {
+      console.log(pc5.dim(`  Rate limit \u5C06\u5728 ${result.rateLimitReset.toLocaleString()} \u91CD\u7F6E`));
+    }
+    return false;
+  }
+  const user = result.data;
+  console.log(pc5.green(`\u2714 Token \u6709\u6548\uFF0C\u5DF2\u767B\u5F55\u4E3A: ${user.login}${user.name ? ` (${user.name})` : ""}`));
+  console.log();
+  const setOrg = await confirm2({
+    message: "\u662F\u5426\u8BBE\u7F6E\u9ED8\u8BA4\u7EC4\u7EC7? (\u5426\u5219\u4ED3\u5E93\u5C06\u521B\u5EFA\u5728\u4E2A\u4EBA\u8D26\u6237\u4E0B)",
+    default: false
+  });
+  let defaultOrg;
+  if (setOrg) {
+    defaultOrg = await input2({
+      message: "\u9ED8\u8BA4\u7EC4\u7EC7\u540D\u79F0:",
+      validate: (value) => {
+        if (!value.trim()) {
+          return "\u7EC4\u7EC7\u540D\u79F0\u4E0D\u80FD\u4E3A\u7A7A";
+        }
+        return true;
+      }
+    });
+    defaultOrg = defaultOrg.trim();
+  }
+  const config = loadConfig();
+  config.github = {
+    token: token.trim(),
+    ...defaultOrg && { defaultOrg }
+  };
+  saveConfig(config);
+  console.log();
+  console.log(pc5.green("\u2714 GitHub \u914D\u7F6E\u5DF2\u4FDD\u5B58"));
+  console.log(pc5.dim("  \u914D\u7F6E\u6587\u4EF6\u5DF2\u8BBE\u7F6E\u4E3A\u4EC5\u5F53\u524D\u7528\u6237\u53EF\u8BFB"));
+  return true;
+}
+function showConfig() {
+  const config = loadConfig();
+  console.log();
+  console.log(pc5.cyan("\u5F53\u524D\u914D\u7F6E:"));
+  console.log();
+  if (config.defaults) {
+    console.log(pc5.dim("defaults:"));
+    if (config.defaults.github !== void 0) {
+      console.log(`  github: ${config.defaults.github}`);
+    }
+    if (config.defaults.public !== void 0) {
+      console.log(`  public: ${config.defaults.public}`);
+    }
+    if (config.defaults.template !== void 0) {
+      console.log(`  template: ${config.defaults.template}`);
+    }
+  }
+  if (config.github) {
+    console.log(pc5.dim("github:"));
+    if (config.github.token) {
+      const masked = config.github.token.slice(0, 8) + "..." + config.github.token.slice(-4);
+      console.log(`  token: ${masked}`);
+    }
+    if (config.github.defaultOrg) {
+      console.log(`  defaultOrg: ${config.github.defaultOrg}`);
+    }
+  }
+  if (!config.defaults && !config.github) {
+    console.log(pc5.dim("(\u65E0\u914D\u7F6E)"));
+  }
+  console.log();
+}
+
+// src/cli.ts
+async function createCli() {
+  const program = new Command();
+  program.name("create-idp").description("CLI \u811A\u624B\u67B6\u5DE5\u5177\uFF0C\u5FEB\u901F\u521B\u5EFA\u9879\u76EE\u5E76\u53EF\u9009\u521D\u59CB\u5316 GitHub \u4ED3\u5E93").version(version).argument("[project-name]", "\u9879\u76EE\u540D\u79F0").option("-t, --template <template>", "\u4F7F\u7528\u6307\u5B9A\u6A21\u677F").option("--github", "\u5728 GitHub \u521B\u5EFA\u8FDC\u7A0B\u4ED3\u5E93").option("--public", "\u521B\u5EFA\u516C\u5F00\u4ED3\u5E93 (\u9ED8\u8BA4\u79C1\u6709)").option("--no-git", "\u8DF3\u8FC7 Git \u521D\u59CB\u5316").option("--no-install", "\u8DF3\u8FC7\u4F9D\u8D56\u5B89\u88C5").action(async (projectName, options) => {
+    console.log();
+    console.log(`  ${pc6.cyan("create-idp")} ${pc6.dim(`v${version}`)}`);
+    console.log();
+    checkForUpdates(version).catch(() => {
+    });
+    const userConfig = loadConfig();
+    try {
+      const projectOptions = await runPrompts(projectName, options, userConfig);
+      await executeProject(projectOptions);
+    } catch (err) {
+      if (err.message === "PROMPT_CANCELLED") {
+        console.log(pc6.yellow("\n\u64CD\u4F5C\u5DF2\u53D6\u6D88"));
+        process.exit(0);
+      }
+      throw err;
+    }
+  });
+  program.command("config").description("\u7BA1\u7406\u914D\u7F6E").option("--setup-github", "\u914D\u7F6E GitHub Token").option("--show", "\u663E\u793A\u5F53\u524D\u914D\u7F6E").option("--path", "\u663E\u793A\u914D\u7F6E\u6587\u4EF6\u8DEF\u5F84").action(async (options) => {
+    if (options.setupGithub) {
+      const success = await runGitHubSetup();
+      process.exit(success ? 0 : 1);
+    } else if (options.show) {
+      showConfig();
+    } else if (options.path) {
+      console.log(getConfigPath());
+    } else {
+      console.log();
+      console.log(pc6.cyan("\u914D\u7F6E\u7BA1\u7406\u547D\u4EE4:"));
+      console.log();
+      console.log(`  ${pc6.dim("create-idp config --setup-github")}  \u914D\u7F6E GitHub Token`);
+      console.log(`  ${pc6.dim("create-idp config --show")}          \u663E\u793A\u5F53\u524D\u914D\u7F6E`);
+      console.log(`  ${pc6.dim("create-idp config --path")}          \u663E\u793A\u914D\u7F6E\u6587\u4EF6\u8DEF\u5F84`);
+      console.log();
+    }
+  });
+  return program;
+}
+async function executeProject(options) {
+  const templateConfig = await scaffoldProject(options);
+  console.log(pc6.green("\u2714 \u9879\u76EE\u6587\u4EF6\u5DF2\u751F\u6210"));
+  if (!options.noInstall && templateConfig?.postInit) {
+    await runPostInit(options.targetDir, templateConfig.postInit);
+    console.log(pc6.green("\u2714 \u4F9D\u8D56\u5B89\u88C5\u5B8C\u6210"));
+  }
+  if (options.initGit) {
+    await initGit(options.targetDir);
+    console.log(pc6.green("\u2714 Git \u4ED3\u5E93\u5DF2\u521D\u59CB\u5316"));
+  }
+  if (options.createGithub) {
+    const repoUrl = await createGithubRepo(
+      options.projectName,
+      options.targetDir,
+      options.isPublic
+    );
+    if (repoUrl) {
+      console.log(pc6.green(`\u2714 GitHub \u4ED3\u5E93\u5DF2\u521B\u5EFA: ${pc6.cyan(repoUrl)}`));
+    }
+  }
+  console.log();
+  const pm = templateConfig?.packageManager ?? "pnpm";
+  const cdCmd = options.targetDir !== process.cwd() ? `cd ${options.projectName} && ` : "";
+  console.log(pc6.dim(`  ${cdCmd}${pm} dev`));
+  console.log();
+}
+
+// src/index.ts
+async function main() {
+  const program = await createCli();
+  await program.parseAsync(process.argv);
+}
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map