create-astro 2.0.2 → 3.0.1

package/dist/index.js

@@ -1,48 +1,628 @@
-import { color, generateProjectName, label, say } from "@astrojs/cli-kit";
-import { forceUnicode, random } from "@astrojs/cli-kit/utils";
-import { assign, parse, stringify } from "comment-json";
-import { execa, execaCommand } from "execa";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../../node_modules/.pnpm/arg@5.0.2/node_modules/arg/index.js
+var require_arg = __commonJS({
+  "../../node_modules/.pnpm/arg@5.0.2/node_modules/arg/index.js"(exports, module) {
+    var flagSymbol = Symbol("arg flag");
+    var ArgError = class extends Error {
+      constructor(msg, code) {
+        super(msg);
+        this.name = "ArgError";
+        this.code = code;
+        Object.setPrototypeOf(this, ArgError.prototype);
+      }
+    };
+    function arg2(opts, {
+      argv = process.argv.slice(2),
+      permissive = false,
+      stopAtPositional = false
+    } = {}) {
+      if (!opts) {
+        throw new ArgError(
+          "argument specification object is required",
+          "ARG_CONFIG_NO_SPEC"
+        );
+      }
+      const result = { _: [] };
+      const aliases = {};
+      const handlers = {};
+      for (const key of Object.keys(opts)) {
+        if (!key) {
+          throw new ArgError(
+            "argument key cannot be an empty string",
+            "ARG_CONFIG_EMPTY_KEY"
+          );
+        }
+        if (key[0] !== "-") {
+          throw new ArgError(
+            `argument key must start with '-' but found: '${key}'`,
+            "ARG_CONFIG_NONOPT_KEY"
+          );
+        }
+        if (key.length === 1) {
+          throw new ArgError(
+            `argument key must have a name; singular '-' keys are not allowed: ${key}`,
+            "ARG_CONFIG_NONAME_KEY"
+          );
+        }
+        if (typeof opts[key] === "string") {
+          aliases[key] = opts[key];
+          continue;
+        }
+        let type = opts[key];
+        let isFlag = false;
+        if (Array.isArray(type) && type.length === 1 && typeof type[0] === "function") {
+          const [fn] = type;
+          type = (value, name, prev = []) => {
+            prev.push(fn(value, name, prev[prev.length - 1]));
+            return prev;
+          };
+          isFlag = fn === Boolean || fn[flagSymbol] === true;
+        } else if (typeof type === "function") {
+          isFlag = type === Boolean || type[flagSymbol] === true;
+        } else {
+          throw new ArgError(
+            `type missing or not a function or valid array type: ${key}`,
+            "ARG_CONFIG_VAD_TYPE"
+          );
+        }
+        if (key[1] !== "-" && key.length > 2) {
+          throw new ArgError(
+            `short argument keys (with a single hyphen) must have only one character: ${key}`,
+            "ARG_CONFIG_SHORTOPT_TOOLONG"
+          );
+        }
+        handlers[key] = [type, isFlag];
+      }
+      for (let i = 0, len = argv.length; i < len; i++) {
+        const wholeArg = argv[i];
+        if (stopAtPositional && result._.length > 0) {
+          result._ = result._.concat(argv.slice(i));
+          break;
+        }
+        if (wholeArg === "--") {
+          result._ = result._.concat(argv.slice(i + 1));
+          break;
+        }
+        if (wholeArg.length > 1 && wholeArg[0] === "-") {
+          const separatedArguments = wholeArg[1] === "-" || wholeArg.length === 2 ? [wholeArg] : wholeArg.slice(1).split("").map((a) => `-${a}`);
+          for (let j = 0; j < separatedArguments.length; j++) {
+            const arg3 = separatedArguments[j];
+            const [originalArgName, argStr] = arg3[1] === "-" ? arg3.split(/=(.*)/, 2) : [arg3, void 0];
+            let argName = originalArgName;
+            while (argName in aliases) {
+              argName = aliases[argName];
+            }
+            if (!(argName in handlers)) {
+              if (permissive) {
+                result._.push(arg3);
+                continue;
+              } else {
+                throw new ArgError(
+                  `unknown or unexpected option: ${originalArgName}`,
+                  "ARG_UNKNOWN_OPTION"
+                );
+              }
+            }
+            const [type, isFlag] = handlers[argName];
+            if (!isFlag && j + 1 < separatedArguments.length) {
+              throw new ArgError(
+                `option requires argument (but was followed by another short argument): ${originalArgName}`,
+                "ARG_MISSING_REQUIRED_SHORTARG"
+              );
+            }
+            if (isFlag) {
+              result[argName] = type(true, argName, result[argName]);
+            } else if (argStr === void 0) {
+              if (argv.length < i + 2 || argv[i + 1].length > 1 && argv[i + 1][0] === "-" && !(argv[i + 1].match(/^-?\d*(\.(?=\d))?\d*$/) && (type === Number || typeof BigInt !== "undefined" && type === BigInt))) {
+                const extended = originalArgName === argName ? "" : ` (alias for ${argName})`;
+                throw new ArgError(
+                  `option requires argument: ${originalArgName}${extended}`,
+                  "ARG_MISSING_REQUIRED_LONGARG"
+                );
+              }
+              result[argName] = type(argv[i + 1], argName, result[argName]);
+              ++i;
+            } else {
+              result[argName] = type(argStr, argName, result[argName]);
+            }
+          }
+        } else {
+          result._.push(wholeArg);
+        }
+      }
+      return result;
+    }
+    arg2.flag = (fn) => {
+      fn[flagSymbol] = true;
+      return fn;
+    };
+    arg2.COUNT = arg2.flag((v2, name, existingCount) => (existingCount || 0) + 1);
+    arg2.ArgError = ArgError;
+    module.exports = arg2;
+  }
+});
+
+// ../../node_modules/.pnpm/which-pm-runs@1.1.0/node_modules/which-pm-runs/index.js
+var require_which_pm_runs = __commonJS({
+  "../../node_modules/.pnpm/which-pm-runs@1.1.0/node_modules/which-pm-runs/index.js"(exports, module) {
+    "use strict";
+    module.exports = function() {
+      if (!process.env.npm_config_user_agent) {
+        return void 0;
+      }
+      return pmFromUserAgent(process.env.npm_config_user_agent);
+    };
+    function pmFromUserAgent(userAgent) {
+      const pmSpec = userAgent.split(" ")[0];
+      const separatorPos = pmSpec.lastIndexOf("/");
+      const name = pmSpec.substring(0, separatorPos);
+      return {
+        name: name === "npminstall" ? "cnpm" : name,
+        version: pmSpec.substring(separatorPos + 1)
+      };
+    }
+  }
+});
+
+// src/actions/context.ts
+var import_arg = __toESM(require_arg(), 1);
+var import_which_pm_runs = __toESM(require_which_pm_runs(), 1);
+import { prompt } from "@astrojs/cli-kit";
+import os from "os";
+
+// src/messages.ts
+import { color, label, say as houston, spinner as load } from "@astrojs/cli-kit";
+import { align, sleep } from "@astrojs/cli-kit/utils";
+import { exec } from "child_process";
+import { get } from "https";
+
+// ../../node_modules/.pnpm/ansi-regex@6.0.1/node_modules/ansi-regex/index.js
+function ansiRegex({ onlyFirst = false } = {}) {
+  const pattern = [
+    "[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)",
+    "(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))"
+  ].join("|");
+  return new RegExp(pattern, onlyFirst ? void 0 : "g");
+}
+
+// ../../node_modules/.pnpm/strip-ansi@7.0.1/node_modules/strip-ansi/index.js
+function stripAnsi(string) {
+  if (typeof string !== "string") {
+    throw new TypeError(`Expected a \`string\`, got \`${typeof string}\``);
+  }
+  return string.replace(ansiRegex(), "");
+}
+
+// src/messages.ts
+var stdout = process.stdout;
+function setStdout(writable) {
+  stdout = writable;
+}
+async function say(messages, { clear = false, hat = "" } = {}) {
+  return houston(messages, { clear, hat, stdout });
+}
+async function spinner(args) {
+  await load(args, { stdout });
+}
+var title = (text) => align(label(text), "end", 7) + " ";
+var welcome = [
+  `Let's claim your corner of the internet.`,
+  `I'll be your assistant today.`,
+  `Let's build something awesome!`,
+  `Let's build something great!`,
+  `Let's build something fast!`,
+  `Let's build the web we want.`,
+  `Let's make the web weird!`,
+  `Let's make the web a better place!`,
+  `Let's create a new project!`,
+  `Let's create something unique!`,
+  `Time to build a new website.`,
+  `Time to build a faster website.`,
+  `Time to build a sweet new website.`,
+  `We're glad to have you on board.`,
+  `Keeping the internet weird since 2021.`,
+  `Initiating launch sequence...`,
+  `Initiating launch sequence... right... now!`,
+  `Awaiting further instructions.`
+];
+var getName = () => new Promise((resolve) => {
+  exec("git config user.name", { encoding: "utf-8" }, (_1, gitName, _2) => {
+    if (gitName.trim()) {
+      return resolve(gitName.split(" ")[0].trim());
+    }
+    exec("whoami", { encoding: "utf-8" }, (_3, whoami, _4) => {
+      if (whoami.trim()) {
+        return resolve(whoami.split(" ")[0].trim());
+      }
+      return resolve("astronaut");
+    });
+  });
+});
+var v;
+var getVersion = () => new Promise((resolve) => {
+  if (v)
+    return resolve(v);
+  get("https://registry.npmjs.org/astro/latest", (res) => {
+    let body = "";
+    res.on("data", (chunk) => body += chunk);
+    res.on("end", () => {
+      const { version } = JSON.parse(body);
+      v = version;
+      resolve(version);
+    });
+  });
+});
+var log = (message) => stdout.write(message + "\n");
+var banner = async (version) => log(
+  `
+${label("astro", color.bgGreen, color.black)}  ${color.green(
+    color.bold(`v${version}`)
+  )} ${color.bold("Launch sequence initiated.")}`
+);
+var info = async (prefix, text) => {
+  await sleep(100);
+  if (stdout.columns < 80) {
+    log(`${" ".repeat(5)} ${color.cyan("\u25FC")}  ${color.cyan(prefix)}`);
+    log(`${" ".repeat(9)}${color.dim(text)}`);
+  } else {
+    log(`${" ".repeat(5)} ${color.cyan("\u25FC")}  ${color.cyan(prefix)} ${color.dim(text)}`);
+  }
+};
+var error = async (prefix, text) => {
+  if (stdout.columns < 80) {
+    log(`${" ".repeat(5)} ${color.red("\u25B2")}  ${color.red(prefix)}`);
+    log(`${" ".repeat(9)}${color.dim(text)}`);
+  } else {
+    log(`${" ".repeat(5)} ${color.red("\u25B2")}  ${color.red(prefix)} ${color.dim(text)}`);
+  }
+};
+var typescriptByDefault = async () => {
+  await info(`No worries!`, "TypeScript is supported in Astro by default,");
+  log(`${" ".repeat(9)}${color.dim("but you are free to continue writing JavaScript instead.")}`);
+  await sleep(1e3);
+};
+var nextSteps = async ({ projectDir, devCmd }) => {
+  const max = stdout.columns;
+  const prefix = max < 80 ? " " : " ".repeat(9);
+  await sleep(200);
+  log(
+    `
+ ${color.bgCyan(` ${color.black("next")} `)}  ${color.bold(
+      "Liftoff confirmed. Explore your project!"
+    )}`
+  );
+  await sleep(100);
+  if (projectDir !== "") {
+    const enter = [
+      `
+${prefix}Enter your project directory using`,
+      color.cyan(`cd ./${projectDir}`, "")
+    ];
+    const len = enter[0].length + stripAnsi(enter[1]).length;
+    log(enter.join(len > max ? "\n" + prefix : " "));
+  }
+  log(
+    `${prefix}Run ${color.cyan(devCmd)} to start the dev server. ${color.cyan("CTRL+C")} to stop.`
+  );
+  await sleep(100);
+  log(
+    `${prefix}Add frameworks like ${color.cyan(`react`)} or ${color.cyan(
+      "tailwind"
+    )} using ${color.cyan("astro add")}.`
+  );
+  await sleep(100);
+  log(`
+${prefix}Stuck? Join us at ${color.cyan(`https://astro.build/chat`)}`);
+  await sleep(200);
+};
+function printHelp({
+  commandName,
+  headline,
+  usage,
+  tables,
+  description
+}) {
+  const linebreak = () => "";
+  const table = (rows, { padding }) => {
+    const split = stdout.columns < 60;
+    let raw = "";
+    for (const row of rows) {
+      if (split) {
+        raw += `    ${row[0]}
+    `;
+      } else {
+        raw += `${`${row[0]}`.padStart(padding)}`;
+      }
+      raw += "  " + color.dim(row[1]) + "\n";
+    }
+    return raw.slice(0, -1);
+  };
+  let message = [];
+  if (headline) {
+    message.push(
+      linebreak(),
+      `${title(commandName)} ${color.green(`v${"3.0.1"}`)} ${headline}`
+    );
+  }
+  if (usage) {
+    message.push(linebreak(), `${color.green(commandName)} ${color.bold(usage)}`);
+  }
+  if (tables) {
+    let calculateTablePadding2 = function(rows) {
+      return rows.reduce((val, [first]) => Math.max(val, first.length), 0);
+    };
+    var calculateTablePadding = calculateTablePadding2;
+    const tableEntries = Object.entries(tables);
+    const padding = Math.max(...tableEntries.map(([, rows]) => calculateTablePadding2(rows)));
+    for (const [, tableRows] of tableEntries) {
+      message.push(linebreak(), table(tableRows, { padding }));
+    }
+  }
+  if (description) {
+    message.push(linebreak(), `${description}`);
+  }
+  log(message.join("\n") + "\n");
+}
+
+// src/actions/context.ts
+async function getContext(argv) {
+  var _a;
+  const flags = (0, import_arg.default)(
+    {
+      "--template": String,
+      "--ref": String,
+      "--yes": Boolean,
+      "--no": Boolean,
+      "--install": Boolean,
+      "--no-install": Boolean,
+      "--git": Boolean,
+      "--no-git": Boolean,
+      "--typescript": String,
+      "--skip-houston": Boolean,
+      "--dry-run": Boolean,
+      "--help": Boolean,
+      "--fancy": Boolean,
+      "-y": "--yes",
+      "-n": "--no",
+      "-h": "--help"
+    },
+    { argv, permissive: true }
+  );
+  const pkgManager = ((_a = (0, import_which_pm_runs.default)()) == null ? void 0 : _a.name) ?? "npm";
+  const [username, version] = await Promise.all([getName(), getVersion()]);
+  let cwd = flags["_"][0];
+  let {
+    "--help": help2 = false,
+    "--template": template2,
+    "--no": no,
+    "--yes": yes,
+    "--install": install2,
+    "--no-install": noInstall,
+    "--git": git2,
+    "--no-git": noGit,
+    "--typescript": typescript2,
+    "--fancy": fancy,
+    "--skip-houston": skipHouston,
+    "--dry-run": dryRun,
+    "--ref": ref
+  } = flags;
+  let projectName2 = cwd;
+  if (no) {
+    yes = false;
+    if (install2 == void 0)
+      install2 = false;
+    if (git2 == void 0)
+      git2 = false;
+    if (typescript2 == void 0)
+      typescript2 = "strict";
+  }
+  skipHouston = (os.platform() === "win32" && !fancy || skipHouston) ?? [yes, no, install2, git2, typescript2].some((v2) => v2 !== void 0);
+  const context = {
+    help: help2,
+    prompt,
+    pkgManager,
+    username,
+    version,
+    skipHouston,
+    dryRun,
+    projectName: projectName2,
+    template: template2,
+    ref: ref ?? "latest",
+    yes,
+    install: install2 ?? (noInstall ? false : void 0),
+    git: git2 ?? (noGit ? false : void 0),
+    typescript: typescript2,
+    cwd,
+    exit(code) {
+      process.exit(code);
+    }
+  };
+  return context;
+}
+
+// src/actions/dependencies.ts
+import { execa } from "execa";
+async function dependencies(ctx) {
+  let deps = ctx.install ?? ctx.yes;
+  if (deps === void 0) {
+    ({ deps } = await ctx.prompt({
+      name: "deps",
+      type: "confirm",
+      label: title("deps"),
+      message: `Install dependencies?`,
+      hint: "recommended",
+      initial: true
+    }));
+    ctx.install = deps;
+  }
+  if (ctx.dryRun) {
+    await info("--dry-run", `Skipping dependency installation`);
+  } else if (deps) {
+    await spinner({
+      start: `Dependencies installing with ${ctx.pkgManager}...`,
+      end: "Dependencies installed",
+      while: () => install({ pkgManager: ctx.pkgManager, cwd: ctx.cwd }).catch((e) => {
+        error("error", e);
+        process.exit(1);
+      })
+    });
+  } else {
+    await info(
+      ctx.yes === false ? "deps [skip]" : "No problem!",
+      "Remember to install dependencies after setup."
+    );
+  }
+}
+async function install({ pkgManager, cwd }) {
+  const installExec = execa(pkgManager, ["install"], { cwd });
+  return new Promise((resolve, reject) => {
+    setTimeout(() => reject(`Request timed out after one minute`), 6e4);
+    installExec.on("error", (e) => reject(e));
+    installExec.on("close", () => resolve());
+  });
+}
+
+// src/actions/git.ts
 import fs from "fs";
-import { downloadTemplate } from "giget";
-import { bold, dim, green, reset, yellow } from "kleur/colors";
-import ora from "ora";
-import { platform } from "os";
 import path from "path";
-import prompts from "prompts";
-import detectPackageManager from "which-pm-runs";
-import yargs from "yargs-parser";
-import { loadWithRocketGradient, rocketAscii } from "./gradient.js";
-import { logger } from "./logger.js";
-import {
-  banner,
-  getName,
-  getVersion,
-  info,
-  nextSteps,
-  typescriptByDefault,
-  welcome
-} from "./messages.js";
-import { TEMPLATES } from "./templates.js";
-const cleanArgv = process.argv.filter((arg) => arg !== "--");
-const args = yargs(cleanArgv, { boolean: ["fancy", "y"], alias: { y: "yes" } });
-if (platform() === "win32")
-  args.skipHouston = true;
-prompts.override(args);
-if (args.fancy) {
-  forceUnicode();
+import { color as color2 } from "@astrojs/cli-kit";
+import { execa as execa2 } from "execa";
+async function git(ctx) {
+  if (fs.existsSync(path.join(ctx.cwd, ".git"))) {
+    await info("Nice!", `Git has already been initialized`);
+    return;
+  }
+  let _git = ctx.git ?? ctx.yes;
+  if (_git === void 0) {
+    ({ git: _git } = await ctx.prompt({
+      name: "git",
+      type: "confirm",
+      label: title("git"),
+      message: `Initialize a new git repository?`,
+      hint: "optional",
+      initial: true
+    }));
+  }
+  if (ctx.dryRun) {
+    await info("--dry-run", `Skipping Git initialization`);
+  } else if (_git) {
+    await spinner({
+      start: "Git initializing...",
+      end: "Git initialized",
+      while: () => init({ cwd: ctx.cwd }).catch((e) => {
+        error("error", e);
+        process.exit(1);
+      })
+    });
+  } else {
+    await info(
+      ctx.yes === false ? "git [skip]" : "Sounds good!",
+      `You can always run ${color2.reset("git init")}${color2.dim(" manually.")}`
+    );
+  }
 }
-function mkdirp(dir) {
+async function init({ cwd }) {
   try {
-    fs.mkdirSync(dir, { recursive: true });
+    await execa2("git", ["init"], { cwd, stdio: "ignore" });
+    await execa2("git", ["add", "-A"], { cwd, stdio: "ignore" });
+    await execa2(
+      "git",
+      [
+        "commit",
+        "-m",
+        "Initial commit from Astro",
+        '--author="houston[bot] <astrobot-houston@users.noreply.github.com>"'
+      ],
+      { cwd, stdio: "ignore" }
+    );
   } catch (e) {
-    if (e.code === "EEXIST")
-      return;
-    throw e;
   }
 }
-const VALID_PROJECT_DIRECTORY_SAFE_LIST = [
+
+// src/actions/help.ts
+function help() {
+  printHelp({
+    commandName: "create-astro",
+    usage: "[dir] [...flags]",
+    headline: "Scaffold Astro projects.",
+    tables: {
+      Flags: [
+        ["--template <name>", "Specify your template."],
+        ["--install / --no-install", "Install dependencies (or not)."],
+        ["--git / --no-git", "Initialize git repo (or not)."],
+        ["--yes (-y)", "Skip all prompt by accepting defaults."],
+        ["--no (-n)", "Skip all prompt by declining defaults."],
+        ["--dry-run", "Walk through steps without executing."],
+        ["--skip-houston", "Skip Houston animation."]
+      ]
+    }
+  });
+}
+
+// src/actions/intro.ts
+import { color as color3, label as label2 } from "@astrojs/cli-kit";
+import { random } from "@astrojs/cli-kit/utils";
+async function intro(ctx) {
+  if (!ctx.skipHouston) {
+    await say([
+      [
+        "Welcome",
+        "to",
+        label2("astro", color3.bgGreen, color3.black),
+        color3.green(`v${ctx.version}`) + ",",
+        `${ctx.username}!`
+      ],
+      random(welcome)
+    ]);
+    await banner(ctx.version);
+  } else {
+    await banner(ctx.version);
+  }
+}
+
+// src/actions/next-steps.ts
+import path2 from "path";
+async function next(ctx) {
+  let projectDir = path2.relative(process.cwd(), ctx.cwd);
+  const devCmd = ctx.pkgManager === "npm" ? "npm run dev" : `${ctx.pkgManager} dev`;
+  await nextSteps({ projectDir, devCmd });
+  if (!ctx.skipHouston) {
+    await say(["Good luck out there, astronaut! \u{1F680}"]);
+  }
+  return;
+}
+
+// src/actions/project-name.ts
+import { color as color4, generateProjectName } from "@astrojs/cli-kit";
+import path3 from "path";
+
+// src/actions/shared.ts
+import fs2 from "fs";
+var VALID_PROJECT_DIRECTORY_SAFE_LIST = [
   ".DS_Store",
   ".git",
+  ".gitkeep",
   ".gitattributes",
   ".gitignore",
   ".gitlab-ci.yml",
@@ -63,279 +643,366 @@ const VALID_PROJECT_DIRECTORY_SAFE_LIST = [
   /^yarn-debug\.log/,
   /^yarn-error\.log/
 ];
-function isValidProjectDirectory(dirPath) {
-  if (!fs.existsSync(dirPath)) {
+function isEmpty(dirPath) {
+  if (!fs2.existsSync(dirPath)) {
     return true;
   }
-  const conflicts = fs.readdirSync(dirPath).filter((content) => {
+  const conflicts = fs2.readdirSync(dirPath).filter((content) => {
     return !VALID_PROJECT_DIRECTORY_SAFE_LIST.some((safeContent) => {
       return typeof safeContent === "string" ? content === safeContent : safeContent.test(content);
     });
   });
   return conflicts.length === 0;
 }
-const FILES_TO_REMOVE = [".stackblitzrc", "sandbox.config.json", "CHANGELOG.md"];
-async function main() {
-  var _a;
-  const pkgManager = ((_a = detectPackageManager()) == null ? void 0 : _a.name) || "npm";
-  const [username, version] = await Promise.all([getName(), getVersion()]);
-  logger.debug("Verbose logging turned on");
-  if (!args.skipHouston) {
-    await say(
-      [
-        [
-          "Welcome",
-          "to",
-          label("astro", color.bgGreen, color.black),
-          color.green(`v${version}`) + ",",
-          `${username}!`
-        ],
-        random(welcome)
-      ],
-      { hat: args.fancy ? "\u{1F3A9}" : void 0 }
-    );
-    await banner(version);
-  }
-  let cwd = args["_"][2];
-  if (cwd && isValidProjectDirectory(cwd)) {
-    let acknowledgeProjectDir = ora({
-      color: "green",
-      text: `Using ${bold(cwd)} as project directory.`
-    });
-    acknowledgeProjectDir.succeed();
-  }
-  if (!cwd || !isValidProjectDirectory(cwd)) {
-    const notEmptyMsg = (dirPath) => `"${bold(dirPath)}" is not empty!`;
-    if (!isValidProjectDirectory(cwd)) {
-      let rejectProjectDir = ora({ color: "red", text: notEmptyMsg(cwd) });
-      rejectProjectDir.fail();
+function isValidName(projectName2) {
+  return /^(?:@[a-z\d\-*~][a-z\d\-*._~]*\/)?[a-z\d\-~][a-z\d\-._~]*$/.test(projectName2);
+}
+function toValidName(projectName2) {
+  if (isValidName(projectName2))
+    return projectName2;
+  return projectName2.trim().toLowerCase().replace(/\s+/g, "-").replace(/^[._]/, "").replace(/[^a-z\d\-~]+/g, "-").replace(/^-+/, "").replace(/-+$/, "");
+}
+
+// src/actions/project-name.ts
+async function projectName(ctx) {
+  await checkCwd(ctx.cwd);
+  if (!ctx.cwd || !isEmpty(ctx.cwd)) {
+    if (!isEmpty(ctx.cwd)) {
+      await info("Hmm...", `${color4.reset(`"${ctx.cwd}"`)}${color4.dim(` is not empty!`)}`);
     }
-    const dirResponse = await prompts(
-      {
-        type: "text",
-        name: "directory",
-        message: "Where would you like to create your new project?",
-        initial: generateProjectName(),
-        validate(value) {
-          if (!isValidProjectDirectory(value)) {
-            return notEmptyMsg(value);
-          }
-          return true;
+    const { name } = await ctx.prompt({
+      name: "name",
+      type: "text",
+      label: title("dir"),
+      message: "Where should we create your new project?",
+      initial: `./${generateProjectName()}`,
+      validate(value) {
+        if (!isEmpty(value)) {
+          return `Directory is not empty!`;
         }
-      },
-      { onCancel: () => ora().info(dim("Operation cancelled. See you later, astronaut!")) }
-    );
-    cwd = dirResponse.directory;
-  }
-  if (!cwd) {
-    ora().info(dim("No directory provided. See you later, astronaut!"));
-    process.exit(1);
-  }
-  const options = await prompts(
-    [
-      {
-        type: "select",
-        name: "template",
-        message: "How would you like to setup your new project?",
-        choices: TEMPLATES
+        return true;
       }
-    ],
-    { onCancel: () => ora().info(dim("Operation cancelled. See you later, astronaut!")) }
-  );
-  if (!options.template || options.template === true) {
-    ora().info(dim("No template provided. See you later, astronaut!"));
-    process.exit(1);
-  }
-  let templateSpinner = await loadWithRocketGradient("Copying project files...");
-  const hash = args.commit ? `#${args.commit}` : "";
-  const isThirdParty = options.template.includes("/");
-  const templateTarget = isThirdParty ? options.template : `withastro/astro/examples/${options.template}#latest`;
-  if (!args.dryRun) {
+    });
+    ctx.cwd = name;
+    ctx.projectName = toValidName(name);
+  } else {
+    let name = ctx.cwd;
+    if (name === "." || name === "./") {
+      const parts = process.cwd().split(path3.sep);
+      name = parts[parts.length - 1];
+    } else if (name.startsWith("./") || name.startsWith("../")) {
+      const parts = name.split("/");
+      name = parts[parts.length - 1];
+    }
+    ctx.projectName = toValidName(name);
+  }
+  if (!ctx.cwd) {
+    ctx.exit(1);
+  }
+}
+async function checkCwd(cwd) {
+  const empty = cwd && isEmpty(cwd);
+  if (empty) {
+    log("");
+    await info("dir", `Using ${color4.reset(cwd)}${color4.dim(" as project directory")}`);
+  }
+  return empty;
+}
+
+// src/actions/template.ts
+import { color as color5 } from "@astrojs/cli-kit";
+import { downloadTemplate } from "giget";
+import fs3 from "fs";
+import path4 from "path";
+async function template(ctx) {
+  if (!ctx.template) {
+    const { template: tmpl } = await ctx.prompt({
+      name: "template",
+      type: "select",
+      label: title("tmpl"),
+      message: "How would you like to start your new project?",
+      initial: "basics",
+      choices: [
+        { value: "basics", label: "Include sample files", hint: "(recommended)" },
+        { value: "blog", label: "Use blog template" },
+        { value: "minimal", label: "Empty" }
+      ]
+    });
+    ctx.template = tmpl;
+  } else {
+    await info("tmpl", `Using ${color5.reset(ctx.template)}${color5.dim(" as project template")}`);
+  }
+  if (ctx.dryRun) {
+    await info("--dry-run", `Skipping template copying`);
+  } else if (ctx.template) {
+    await spinner({
+      start: "Template copying...",
+      end: "Template copied",
+      while: () => copyTemplate(ctx.template, ctx).catch((e) => {
+        error("error", e);
+        process.exit(1);
+      })
+    });
+  } else {
+    ctx.exit(1);
+  }
+}
+var FILES_TO_REMOVE = ["sandbox.config.json", "CHANGELOG.md"];
+var FILES_TO_UPDATE = {
+  "package.json": (file, overrides) => fs3.promises.readFile(file, "utf-8").then(
+    (value) => fs3.promises.writeFile(
+      file,
+      JSON.stringify(
+        Object.assign(JSON.parse(value), Object.assign(overrides, { private: void 0 })),
+        null,
+        "	"
+      ),
+      "utf-8"
+    )
+  )
+};
+async function copyTemplate(tmpl, ctx) {
+  const ref = ctx.ref || "latest";
+  const isThirdParty = tmpl.includes("/");
+  const templateTarget = isThirdParty ? tmpl : `github:withastro/astro/examples/${tmpl}#${ref}`;
+  if (!ctx.dryRun) {
     try {
-      await downloadTemplate(`${templateTarget}${hash}`, {
+      await downloadTemplate(templateTarget, {
         force: true,
         provider: "github",
-        cwd,
+        cwd: ctx.cwd,
         dir: "."
       });
     } catch (err) {
-      fs.rmdirSync(cwd);
+      fs3.rmdirSync(ctx.cwd);
       if (err.message.includes("404")) {
-        console.error(`Could not find template ${color.underline(options.template)}!`);
-        if (isThirdParty) {
-          const hasBranch = options.template.includes("#");
-          if (hasBranch) {
-            console.error("Are you sure this GitHub repo and branch exist?");
-          } else {
-            console.error(
-              `Are you sure this GitHub repo exists?This command uses the ${color.bold("main")} branch by default.
-If the repo doesn't have a main branch, specify a custom branch name:
-` + color.underline(options.template + color.bold("#branch-name"))
-            );
-          }
-        }
+        await error("Error", `Template ${color5.reset(tmpl)} ${color5.dim("does not exist!")}`);
       } else {
         console.error(err.message);
       }
-      process.exit(1);
+      ctx.exit(1);
     }
-    await Promise.all(
-      FILES_TO_REMOVE.map(async (file) => {
-        const fileLoc = path.resolve(path.join(cwd, file));
-        if (fs.existsSync(fileLoc)) {
-          return fs.promises.rm(fileLoc, {});
-        }
-      })
-    );
-  }
-  templateSpinner.text = green("Template copied!");
-  templateSpinner.succeed();
-  const install = args.y ? true : (await prompts(
-    {
-      type: "confirm",
-      name: "install",
-      message: `Would you like to install ${pkgManager} dependencies? ${reset(
-        dim("(recommended)")
-      )}`,
-      initial: true
-    },
-    {
-      onCancel: () => {
-        ora().info(
-          dim(
-            "Operation cancelled. Your project folder has already been created, however no dependencies have been installed"
-          )
-        );
-        process.exit(1);
+    const removeFiles = FILES_TO_REMOVE.map(async (file) => {
+      const fileLoc = path4.resolve(path4.join(ctx.cwd, file));
+      if (fs3.existsSync(fileLoc)) {
+        return fs3.promises.rm(fileLoc, { recursive: true });
       }
-    }
-  )).install;
-  if (args.dryRun) {
-    ora().info(dim(`--dry-run enabled, skipping.`));
-  } else if (install) {
-    const installExec = execa(pkgManager, ["install"], { cwd });
-    const installingPackagesMsg = `Installing packages${emojiWithFallback(" \u{1F4E6}", "...")}`;
-    const installSpinner = await loadWithRocketGradient(installingPackagesMsg);
-    await new Promise((resolve, reject) => {
-      var _a2;
-      (_a2 = installExec.stdout) == null ? void 0 : _a2.on("data", function(data) {
-        installSpinner.text = `${rocketAscii} ${installingPackagesMsg}
-${bold(
-          `[${pkgManager}]`
-        )} ${data}`;
-      });
-      installExec.on("error", (error) => reject(error));
-      installExec.on("close", () => resolve());
     });
-    installSpinner.text = green("Packages installed!");
-    installSpinner.succeed();
-  } else {
-    await info("No problem!", "Remember to install dependencies after setup.");
+    const updateFiles = Object.entries(FILES_TO_UPDATE).map(async ([file, update]) => {
+      const fileLoc = path4.resolve(path4.join(ctx.cwd, file));
+      if (fs3.existsSync(fileLoc)) {
+        return update(fileLoc, { name: ctx.projectName });
+      }
+    });
+    await Promise.all([...removeFiles, ...updateFiles]);
   }
-  const gitResponse = args.y ? true : (await prompts(
-    {
-      type: "confirm",
-      name: "git",
-      message: `Would you like to initialize a new git repository? ${reset(
-        dim("(optional)")
-      )}`,
-      initial: true
-    },
-    {
-      onCancel: () => {
-        ora().info(
-          dim("Operation cancelled. No worries, your project folder has already been created")
-        );
-        process.exit(1);
+}
+
+// src/actions/typescript.ts
+import { color as color6 } from "@astrojs/cli-kit";
+import fs4 from "fs";
+import { readFile } from "fs/promises";
+import path5 from "path";
+
+// ../../node_modules/.pnpm/strip-json-comments@5.0.0/node_modules/strip-json-comments/index.js
+var singleComment = Symbol("singleComment");
+var multiComment = Symbol("multiComment");
+var stripWithoutWhitespace = () => "";
+var stripWithWhitespace = (string, start, end) => string.slice(start, end).replace(/\S/g, " ");
+var isEscaped = (jsonString, quotePosition) => {
+  let index = quotePosition - 1;
+  let backslashCount = 0;
+  while (jsonString[index] === "\\") {
+    index -= 1;
+    backslashCount += 1;
+  }
+  return Boolean(backslashCount % 2);
+};
+function stripJsonComments(jsonString, { whitespace = true, trailingCommas = false } = {}) {
+  if (typeof jsonString !== "string") {
+    throw new TypeError(`Expected argument \`jsonString\` to be a \`string\`, got \`${typeof jsonString}\``);
+  }
+  const strip = whitespace ? stripWithWhitespace : stripWithoutWhitespace;
+  let isInsideString = false;
+  let isInsideComment = false;
+  let offset = 0;
+  let buffer = "";
+  let result = "";
+  let commaIndex = -1;
+  for (let index = 0; index < jsonString.length; index++) {
+    const currentCharacter = jsonString[index];
+    const nextCharacter = jsonString[index + 1];
+    if (!isInsideComment && currentCharacter === '"') {
+      const escaped = isEscaped(jsonString, index);
+      if (!escaped) {
+        isInsideString = !isInsideString;
       }
     }
-  )).git;
-  if (args.dryRun) {
-    ora().info(dim(`--dry-run enabled, skipping.`));
-  } else if (gitResponse) {
-    const gitDir = "./.git";
-    if (fs.existsSync(gitDir)) {
-      ora().info(dim("A .git directory already exists. Skipping creating a new Git repository."));
-    } else {
-      await execaCommand("git init", { cwd });
-      ora().succeed("Git repository created!");
+    if (isInsideString) {
+      continue;
+    }
+    if (!isInsideComment && currentCharacter + nextCharacter === "//") {
+      buffer += jsonString.slice(offset, index);
+      offset = index;
+      isInsideComment = singleComment;
+      index++;
+    } else if (isInsideComment === singleComment && currentCharacter + nextCharacter === "\r\n") {
+      index++;
+      isInsideComment = false;
+      buffer += strip(jsonString, offset, index);
+      offset = index;
+      continue;
+    } else if (isInsideComment === singleComment && currentCharacter === "\n") {
+      isInsideComment = false;
+      buffer += strip(jsonString, offset, index);
+      offset = index;
+    } else if (!isInsideComment && currentCharacter + nextCharacter === "/*") {
+      buffer += jsonString.slice(offset, index);
+      offset = index;
+      isInsideComment = multiComment;
+      index++;
+      continue;
+    } else if (isInsideComment === multiComment && currentCharacter + nextCharacter === "*/") {
+      index++;
+      isInsideComment = false;
+      buffer += strip(jsonString, offset, index + 1);
+      offset = index + 1;
+      continue;
+    } else if (trailingCommas && !isInsideComment) {
+      if (commaIndex !== -1) {
+        if (currentCharacter === "}" || currentCharacter === "]") {
+          buffer += jsonString.slice(offset, index);
+          result += strip(buffer, 0, 1) + buffer.slice(1);
+          buffer = "";
+          offset = index;
+          commaIndex = -1;
+        } else if (currentCharacter !== " " && currentCharacter !== "	" && currentCharacter !== "\r" && currentCharacter !== "\n") {
+          buffer += jsonString.slice(offset, index);
+          offset = index;
+          commaIndex = -1;
+        }
+      } else if (currentCharacter === ",") {
+        result += buffer + jsonString.slice(offset, index);
+        buffer = "";
+        offset = index;
+        commaIndex = index;
+      }
     }
-  } else {
-    await info(
-      "Sounds good!",
-      `You can come back and run ${color.reset(`git init`)}${color.dim(" later.")}`
-    );
-  }
-  if (args.y && !args.typescript) {
-    ora().warn(dim('--typescript <choice> missing. Defaulting to "strict"'));
-    args.typescript = "strict";
   }
-  let tsResponse = args.typescript || (await prompts(
-    {
+  return result + buffer + (isInsideComment ? strip(jsonString.slice(offset)) : jsonString.slice(offset));
+}
+
+// src/actions/typescript.ts
+async function typescript(ctx) {
+  let ts = ctx.typescript ?? (typeof ctx.yes !== "undefined" ? "strict" : void 0);
+  if (ts === void 0) {
+    const { useTs } = await ctx.prompt({
+      name: "useTs",
+      type: "confirm",
+      label: title("ts"),
+      message: `Do you plan to write TypeScript?`,
+      initial: true
+    });
+    if (!useTs) {
+      await typescriptByDefault();
+      return;
+    }
+    ({ ts } = await ctx.prompt({
+      name: "ts",
       type: "select",
-      name: "typescript",
-      message: "How would you like to setup TypeScript?",
+      label: title("use"),
+      message: `How strict should TypeScript be?`,
+      initial: "strict",
       choices: [
-        { value: "strict", title: "Strict", description: "(recommended)" },
-        { value: "strictest", title: "Strictest" },
-        { value: "base", title: "Relaxed" },
-        { value: "unsure", title: "Help me choose" }
+        { value: "strict", label: "Strict", hint: `(recommended)` },
+        { value: "strictest", label: "Strictest" },
+        { value: "base", label: "Relaxed" }
       ]
-    },
-    {
-      onCancel: () => {
-        ora().info(
-          dim(
-            "Operation cancelled. Your project folder has been created but no TypeScript configuration file was created."
-          )
-        );
-        process.exit(1);
+    }));
+  } else {
+    if (!["strict", "strictest", "relaxed", "default", "base"].includes(ts)) {
+      if (!ctx.dryRun) {
+        fs4.rmSync(ctx.cwd, { recursive: true, force: true });
       }
+      error(
+        "Error",
+        `Unknown TypeScript option ${color6.reset(ts)}${color6.dim(
+          "! Expected strict | strictest | relaxed"
+        )}`
+      );
+      ctx.exit(1);
     }
-  )).typescript;
-  if (tsResponse === "unsure") {
-    await typescriptByDefault();
-    tsResponse = "base";
-  }
-  if (args.dryRun) {
-    ora().info(dim(`--dry-run enabled, skipping.`));
-  } else if (tsResponse) {
-    const templateTSConfigPath = path.join(cwd, "tsconfig.json");
-    fs.readFile(templateTSConfigPath, (err, data) => {
-      if (err && err.code === "ENOENT") {
-        fs.writeFileSync(
-          templateTSConfigPath,
-          stringify({ extends: `astro/tsconfigs/${tsResponse ?? "base"}` }, null, 2)
-        );
-        return;
-      }
-      const templateTSConfig = parse(data.toString());
-      if (templateTSConfig && typeof templateTSConfig === "object") {
-        const result = assign(templateTSConfig, {
-          extends: `astro/tsconfigs/${tsResponse ?? "base"}`
-        });
-        fs.writeFileSync(templateTSConfigPath, stringify(result, null, 2));
-      } else {
-        console.log(
-          yellow(
-            "There was an error applying the requested TypeScript settings. This could be because the template's tsconfig.json is malformed"
-          )
-        );
-      }
+    await info("ts", `Using ${color6.reset(ts)}${color6.dim(" TypeScript configuration")}`);
+  }
+  if (ctx.dryRun) {
+    await info("--dry-run", `Skipping TypeScript setup`);
+  } else if (ts && ts !== "unsure") {
+    if (ts === "relaxed" || ts === "default") {
+      ts = "base";
+    }
+    await spinner({
+      start: "TypeScript customizing...",
+      end: "TypeScript customized",
+      while: () => setupTypeScript(ts, { cwd: ctx.cwd }).catch((e) => {
+        error("error", e);
+        process.exit(1);
+      })
     });
-    ora().succeed("TypeScript settings applied!");
+  } else {
   }
-  let projectDir = path.relative(process.cwd(), cwd);
-  const devCmd = pkgManager === "npm" ? "npm run dev" : `${pkgManager} dev`;
-  await nextSteps({ projectDir, devCmd });
-  if (!args.skipHouston) {
-    await say(["Good luck out there, astronaut!"]);
+}
+async function setupTypeScript(value, { cwd }) {
+  const templateTSConfigPath = path5.join(cwd, "tsconfig.json");
+  try {
+    const data = await readFile(templateTSConfigPath, { encoding: "utf-8" });
+    const templateTSConfig = JSON.parse(stripJsonComments(data));
+    if (templateTSConfig && typeof templateTSConfig === "object") {
+      const result = Object.assign(templateTSConfig, {
+        extends: `astro/tsconfigs/${value}`
+      });
+      fs4.writeFileSync(templateTSConfigPath, JSON.stringify(result, null, 2));
+    } else {
+      throw new Error(
+        "There was an error applying the requested TypeScript settings. This could be because the template's tsconfig.json is malformed"
+      );
+    }
+  } catch (err) {
+    if (err && err.code === "ENOENT") {
+      fs4.writeFileSync(
+        templateTSConfigPath,
+        JSON.stringify({ extends: `astro/tsconfigs/${value}` }, null, 2)
+      );
+    }
   }
 }
-function emojiWithFallback(char, fallback) {
-  return process.platform !== "win32" ? char : fallback;
+
+// src/index.ts
+var exit = () => process.exit(0);
+process.on("SIGINT", exit);
+process.on("SIGTERM", exit);
+async function main() {
+  const cleanArgv = process.argv.slice(2).filter((arg2) => arg2 !== "--");
+  const ctx = await getContext(cleanArgv);
+  if (ctx.help) {
+    help();
+    return;
+  }
+  const steps = [intro, projectName, template, dependencies, git, typescript, next];
+  for (const step of steps) {
+    await step(ctx);
+  }
+  process.exit(0);
 }
 export {
+  dependencies,
+  getContext,
+  git,
+  intro,
   main,
-  mkdirp
+  next,
+  projectName,
+  setStdout,
+  setupTypeScript,
+  template,
+  typescript
 };