@project-ajax/create 0.0.37 → 0.0.39

package/dist/index.js

@@ -1,29 +1,219 @@
 #!/usr/bin/env node
+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(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../../node_modules/picocolors/picocolors.js
+var require_picocolors = __commonJS({
+  "../../node_modules/picocolors/picocolors.js"(exports, module) {
+    "use strict";
+    var p = process || {};
+    var argv = p.argv || [];
+    var env = p.env || {};
+    var isColorSupported = !(!!env.NO_COLOR || argv.includes("--no-color")) && (!!env.FORCE_COLOR || argv.includes("--color") || p.platform === "win32" || (p.stdout || {}).isTTY && env.TERM !== "dumb" || !!env.CI);
+    var formatter = (open, close, replace = open) => (input2) => {
+      let string = "" + input2, index = string.indexOf(close, open.length);
+      return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
+    };
+    var replaceClose = (string, close, replace, index) => {
+      let result = "", cursor = 0;
+      do {
+        result += string.substring(cursor, index) + replace;
+        cursor = index + close.length;
+        index = string.indexOf(close, cursor);
+      } while (~index);
+      return result + string.substring(cursor);
+    };
+    var createColors = (enabled = isColorSupported) => {
+      let f = enabled ? formatter : () => String;
+      return {
+        isColorSupported: enabled,
+        reset: f("\x1B[0m", "\x1B[0m"),
+        bold: f("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m"),
+        dim: f("\x1B[2m", "\x1B[22m", "\x1B[22m\x1B[2m"),
+        italic: f("\x1B[3m", "\x1B[23m"),
+        underline: f("\x1B[4m", "\x1B[24m"),
+        inverse: f("\x1B[7m", "\x1B[27m"),
+        hidden: f("\x1B[8m", "\x1B[28m"),
+        strikethrough: f("\x1B[9m", "\x1B[29m"),
+        black: f("\x1B[30m", "\x1B[39m"),
+        red: f("\x1B[31m", "\x1B[39m"),
+        green: f("\x1B[32m", "\x1B[39m"),
+        yellow: f("\x1B[33m", "\x1B[39m"),
+        blue: f("\x1B[34m", "\x1B[39m"),
+        magenta: f("\x1B[35m", "\x1B[39m"),
+        cyan: f("\x1B[36m", "\x1B[39m"),
+        white: f("\x1B[37m", "\x1B[39m"),
+        gray: f("\x1B[90m", "\x1B[39m"),
+        bgBlack: f("\x1B[40m", "\x1B[49m"),
+        bgRed: f("\x1B[41m", "\x1B[49m"),
+        bgGreen: f("\x1B[42m", "\x1B[49m"),
+        bgYellow: f("\x1B[43m", "\x1B[49m"),
+        bgBlue: f("\x1B[44m", "\x1B[49m"),
+        bgMagenta: f("\x1B[45m", "\x1B[49m"),
+        bgCyan: f("\x1B[46m", "\x1B[49m"),
+        bgWhite: f("\x1B[47m", "\x1B[49m"),
+        blackBright: f("\x1B[90m", "\x1B[39m"),
+        redBright: f("\x1B[91m", "\x1B[39m"),
+        greenBright: f("\x1B[92m", "\x1B[39m"),
+        yellowBright: f("\x1B[93m", "\x1B[39m"),
+        blueBright: f("\x1B[94m", "\x1B[39m"),
+        magentaBright: f("\x1B[95m", "\x1B[39m"),
+        cyanBright: f("\x1B[96m", "\x1B[39m"),
+        whiteBright: f("\x1B[97m", "\x1B[39m"),
+        bgBlackBright: f("\x1B[100m", "\x1B[49m"),
+        bgRedBright: f("\x1B[101m", "\x1B[49m"),
+        bgGreenBright: f("\x1B[102m", "\x1B[49m"),
+        bgYellowBright: f("\x1B[103m", "\x1B[49m"),
+        bgBlueBright: f("\x1B[104m", "\x1B[49m"),
+        bgMagentaBright: f("\x1B[105m", "\x1B[49m"),
+        bgCyanBright: f("\x1B[106m", "\x1B[49m"),
+        bgWhiteBright: f("\x1B[107m", "\x1B[49m")
+      };
+    };
+    module.exports = createColors();
+    module.exports.createColors = createColors;
+  }
+});
 
 // src/run-create.ts
-import { execSync } from "child_process";
-import fs from "fs";
+import { spawn, spawnSync } from "child_process";
+import fs from "fs/promises";
 import path from "path";
 import { fileURLToPath } from "url";
 import { parseArgs } from "util";
 import * as prompts from "@inquirer/prompts";
-import chalk from "chalk";
-import ora from "ora";
+
+// ../shared/dist/colors.js
+var import_picocolors = __toESM(require_picocolors(), 1);
+var colors = {
+  bold: import_picocolors.default.bold,
+  dim: import_picocolors.default.dim,
+  red: import_picocolors.default.red,
+  green: import_picocolors.default.green,
+  yellow: import_picocolors.default.yellow,
+  cyan: import_picocolors.default.cyan,
+  // Semantic aliases
+  success: import_picocolors.default.green,
+  error: import_picocolors.default.red,
+  warn: import_picocolors.default.yellow,
+  info: import_picocolors.default.cyan,
+  isColorSupported: import_picocolors.default.isColorSupported
+};
+
+// ../shared/dist/spinner.js
+var BRAILLE_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+var REFRESH_INTERVAL = 80;
+function isAnimationEnabled(stream) {
+  if (!stream.isTTY) return false;
+  if (process.env.CI) return false;
+  if (process.env.TERM === "dumb") return false;
+  return true;
+}
+function createSpinner(options) {
+  const stream = options.stream ?? process.stderr;
+  let text = options.text;
+  let frameIndex = 0;
+  let intervalId = null;
+  const animated = isAnimationEnabled(stream);
+  function clearLine() {
+    if (animated) {
+      stream.clearLine(0);
+      stream.cursorTo(0);
+    }
+  }
+  function render() {
+    clearLine();
+    stream.write(`${BRAILLE_FRAMES[frameIndex]} ${text}`);
+    frameIndex = (frameIndex + 1) % BRAILLE_FRAMES.length;
+  }
+  function writeLine(prefix, message) {
+    clearLine();
+    stream.write(`${prefix} ${message}
+`);
+  }
+  function stop() {
+    if (intervalId) {
+      clearInterval(intervalId);
+      intervalId = null;
+    }
+    clearLine();
+  }
+  return {
+    start() {
+      if (animated) {
+        render();
+        intervalId = setInterval(render, REFRESH_INTERVAL);
+      } else {
+        stream.write(`${text}
+`);
+      }
+    },
+    update(newText) {
+      text = newText;
+      if (!animated) {
+        stream.write(`${text}
+`);
+      }
+    },
+    succeed(finalText) {
+      stop();
+      writeLine(colors.success("\u2713"), finalText ?? text);
+    },
+    fail(finalText) {
+      stop();
+      writeLine(colors.error("\u2717"), finalText ?? text);
+    },
+    warn(finalText) {
+      stop();
+      writeLine(colors.warn("\u26A0"), finalText ?? text);
+    },
+    stop
+  };
+}
+
+// src/run-create.ts
 var __filename = fileURLToPath(import.meta.url);
 var __dirname = path.dirname(__filename);
+function detectPackageManager() {
+  const userAgent = process.env.npm_config_user_agent ?? "";
+  return userAgent.includes("bun/") ? "bun" : "npm";
+}
 async function runCreate() {
   try {
     await run();
     process.exit(0);
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
-    console.error(chalk.red(`
+    console.error(colors.red(`
 ${message}`));
     process.exit(1);
   }
 }
 async function run() {
-  console.log(chalk.bold.cyan("\n\u{1F680} Create a new worker\n"));
+  console.log(colors.bold(colors.cyan("\n\u{1F680} Create a new worker\n")));
   const { values } = parseArgs({
     options: {
       directory: { type: "string", short: "d" },
@@ -43,7 +233,7 @@ async function run() {
   if (!directoryName) {
     if (!isTTY) {
       console.error(
-        chalk.red(
+        colors.red(
           "Provide the path to the new worker project with --directory"
         )
       );
@@ -56,17 +246,17 @@ async function run() {
     });
   }
   if (!directoryName) {
-    console.log(chalk.red("Cancelled."));
+    console.log(colors.red("Cancelled."));
     process.exit(1);
   }
   const destPath = directoryName === "." ? process.cwd() : path.resolve(process.cwd(), directoryName);
   const templatePath = getTemplatePath();
-  const conflicts = analyzeConflicts(destPath, templatePath);
+  const conflicts = await analyzeConflicts(destPath, templatePath);
   if (conflicts.hasConflicts) {
     if (values.force) {
     } else if (!isTTY) {
       console.error(
-        chalk.red(
+        colors.red(
           `Directory has conflicting files: ${conflicts.conflicts.join(", ")}
 Use --force to overwrite.`
         )
@@ -74,7 +264,7 @@ Use --force to overwrite.`
       process.exit(1);
     } else if (useDefaults) {
       console.error(
-        chalk.red(
+        colors.red(
           "Directory has conflicting files. Use --force with --yes to overwrite."
         )
       );
@@ -91,14 +281,21 @@ Use --force to overwrite.`
         ]
       });
       if (action === "cancel") {
-        console.log(chalk.yellow("Cancelled."));
+        console.log(colors.yellow("Cancelled."));
         process.exit(0);
       }
     }
   }
-  const existingGit = fs.existsSync(path.join(destPath, ".git"));
+  const gitAvailable = isGitAvailable();
+  const destExists = await pathExists(destPath);
+  let existingGit = false;
+  if (gitAvailable && destExists) {
+    existingGit = isGitRepository(destPath);
+  }
   let shouldInitGit = false;
-  if (existingGit) {
+  if (!gitAvailable) {
+    shouldInitGit = false;
+  } else if (existingGit) {
   } else if (values.git) {
     shouldInitGit = true;
   } else if (values["no-git"]) {
@@ -111,7 +308,7 @@ Use --force to overwrite.`
       default: true
     });
   }
-  const packageManager = values.bun ? "bun" : "npm";
+  const packageManager = values.bun ? "bun" : detectPackageManager();
   let shouldInstall = false;
   if (values.install) {
     shouldInstall = true;
@@ -125,17 +322,23 @@ Use --force to overwrite.`
       default: true
     });
   }
-  const spinner = ora("Setting up template...").start();
+  const spinner = createSpinner({ text: "Setting up template..." });
+  spinner.start();
+  let createdDestPath = false;
   try {
-    if (!fs.existsSync(destPath)) {
-      fs.mkdirSync(destPath, { recursive: true });
+    if (!await pathExists(destPath)) {
+      await fs.mkdir(destPath, { recursive: true });
+      createdDestPath = true;
     }
-    spinner.text = "Copying template files...";
-    copyTemplate(templatePath, destPath);
+    spinner.update("Copying template files...");
+    await copyTemplate(templatePath, destPath);
     spinner.succeed("Template files copied");
     if (shouldInitGit) {
-      const gitSpinner = ora("Initializing git repository...").start();
-      const gitSuccess = initializeGit(destPath);
+      const gitSpinner = createSpinner({
+        text: "Initializing git repository..."
+      });
+      gitSpinner.start();
+      const gitSuccess = await initializeGit(destPath);
       if (gitSuccess) {
         gitSpinner.succeed("Git repository initialized");
       } else {
@@ -144,24 +347,25 @@ Use --force to overwrite.`
         );
       }
     } else if (existingGit) {
-      console.log(chalk.dim("  Git repository already exists"));
+      console.log(colors.dim("  Git repository already exists"));
     }
     if (shouldInstall) {
-      const installSpinner = ora(
-        `Installing dependencies with ${packageManager}...`
-      ).start();
-      const installSuccess = installPackages(destPath, packageManager);
+      const installSpinner = createSpinner({
+        text: `Installing dependencies with ${packageManager}...`
+      });
+      installSpinner.start();
+      const installSuccess = await installPackages(destPath, packageManager);
       if (installSuccess) {
         installSpinner.succeed(`Dependencies installed with ${packageManager}`);
       } else {
         installSpinner.fail("Failed to install dependencies");
         const cmd = packageManager === "bun" ? "bun install" : "npm install";
         console.log(
-          chalk.yellow(`  Run '${cmd}' manually to install dependencies`)
+          colors.yellow(`  Run '${cmd}' manually to install dependencies`)
         );
       }
     }
-    console.log(chalk.green("\n\u2728 Worker project created successfully!"));
+    console.log(colors.green("\n\u2728 Worker project created successfully!"));
     printNextSteps({
       directoryName,
       gitInitialized: shouldInitGit || existingGit,
@@ -170,27 +374,35 @@ Use --force to overwrite.`
     });
   } catch (err) {
     spinner.fail("Failed to create worker project.");
+    if (createdDestPath) {
+      try {
+        if (await pathExists(destPath) && (await fs.readdir(destPath)).length === 0) {
+          await fs.rm(destPath, { recursive: true, force: true });
+        }
+      } catch {
+      }
+    }
     throw err;
   }
 }
 function validateFlags(values) {
   if (values.git && values["no-git"]) {
-    console.error(chalk.red("Cannot use both --git and --no-git"));
+    console.error(colors.red("Cannot use both --git and --no-git"));
     process.exit(1);
   }
   if (values.install && values["no-install"]) {
-    console.error(chalk.red("Cannot use both --install and --no-install"));
+    console.error(colors.red("Cannot use both --install and --no-install"));
     process.exit(1);
   }
 }
-function analyzeConflicts(destPath, templatePath) {
-  if (!fs.existsSync(destPath)) {
+async function analyzeConflicts(destPath, templatePath) {
+  if (!await pathExists(destPath)) {
     return { conflicts: [], hasConflicts: false };
   }
-  const templateFiles = fs.readdirSync(templatePath);
+  const templateFiles = await fs.readdir(templatePath);
   const conflicts = [];
   for (const file of templateFiles) {
-    if (fs.existsSync(path.join(destPath, file))) {
+    if (await pathExists(path.join(destPath, file))) {
       conflicts.push(file);
     }
   }
@@ -199,42 +411,60 @@ function analyzeConflicts(destPath, templatePath) {
 function getTemplatePath() {
   return path.resolve(__dirname, "..", "template");
 }
-function copyTemplate(templatePath, destPath) {
-  if (!fs.existsSync(templatePath)) {
+async function pathExists(filepath) {
+  try {
+    await fs.access(filepath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function copyTemplate(templatePath, destPath) {
+  if (!await pathExists(templatePath)) {
     throw new Error(
       `Template directory not found at ${templatePath}. This is likely a packaging issue.`
     );
   }
-  const templateFiles = fs.readdirSync(templatePath);
+  const templateFiles = await fs.readdir(templatePath);
   for (const file of templateFiles) {
     const srcPath = path.join(templatePath, file);
     const destFilePath = path.join(destPath, file);
-    fs.cpSync(srcPath, destFilePath, { recursive: true });
+    await fs.cp(srcPath, destFilePath, { recursive: true });
   }
 }
-function initializeGit(destPath) {
-  try {
-    execSync("git init", { cwd: destPath, stdio: "pipe" });
-    return true;
-  } catch {
-    return false;
-  }
+async function initializeGit(destPath) {
+  return new Promise((resolve) => {
+    const child = spawn("git", ["init"], {
+      cwd: destPath,
+      stdio: "pipe"
+    });
+    child.on("close", (code) => {
+      resolve(code === 0);
+    });
+    child.on("error", () => {
+      resolve(false);
+    });
+  });
 }
-function installPackages(destPath, pm) {
-  const cmd = pm === "bun" ? "bun install" : "npm install";
-  try {
-    execSync(cmd, {
+async function installPackages(destPath, pm) {
+  return new Promise((resolve) => {
+    const command = pm === "bun" ? "bun" : "npm";
+    const args = ["install"];
+    const child = spawn(command, args, {
       cwd: destPath,
       stdio: "pipe",
       env: { ...process.env, FORCE_COLOR: "1" }
     });
-    return true;
-  } catch {
-    return false;
-  }
+    child.on("close", (code) => {
+      resolve(code === 0);
+    });
+    child.on("error", () => {
+      resolve(false);
+    });
+  });
 }
 function printNextSteps(state) {
-  console.log(chalk.cyan("\nNext steps:\n"));
+  console.log(colors.cyan("\nNext steps:\n"));
   const steps = [];
   if (state.directoryName !== ".") {
     steps.push(`cd ${state.directoryName}`);
@@ -246,16 +476,64 @@ function printNextSteps(state) {
   const runPrefix = state.packageManager === "bun" ? "bunx" : "npx";
   steps.push(`${runPrefix} workers deploy`);
   for (let i = 0; i < steps.length; i++) {
-    console.log(`  ${chalk.bold(`${i + 1}.`)} ${chalk.bold(steps[i])}`);
+    console.log(`  ${colors.bold(`${i + 1}.`)} ${colors.bold(steps[i])}`);
   }
   console.log("");
   console.log(
-    chalk.dim(
+    colors.dim(
       `  Tip: Run '${state.packageManager === "bun" ? "bunx" : "npx"} workers auth login' to connect to your Notion workspace.
 `
     )
   );
 }
+function isGitAvailable() {
+  const result = spawnSync("git", ["--version"], { encoding: "utf-8" });
+  if (result.error) {
+    if (result.error.code === "ENOENT") {
+      return false;
+    }
+    throw new Error(
+      `Failed to check git availability: ${result.error.message}`
+    );
+  }
+  return result.status === 0;
+}
+function isGitRepository(rootPath) {
+  const isInsideWorkTree = readGitRevParseBoolean(
+    rootPath,
+    "--is-inside-work-tree"
+  );
+  if (isInsideWorkTree === null) {
+    return false;
+  }
+  const isBareRepository = readGitRevParseBoolean(
+    rootPath,
+    "--is-bare-repository"
+  );
+  if (isBareRepository === null) {
+    return false;
+  }
+  return isInsideWorkTree || isBareRepository;
+}
+function readGitRevParseBoolean(rootPath, flag) {
+  const result = spawnSync("git", ["rev-parse", flag], {
+    cwd: rootPath,
+    encoding: "utf-8"
+  });
+  if (result.error) {
+    throw new Error(`Failed to check git repository: ${result.error.message}`);
+  }
+  if (result.status !== 0) {
+    const stderr = typeof result.stderr === "string" ? result.stderr.trim() : "";
+    if (stderr.includes("not a git repository")) {
+      return null;
+    }
+    const message = stderr ? `Failed to check git repository: ${stderr}` : "Failed to check git repository.";
+    throw new Error(message);
+  }
+  const stdout = typeof result.stdout === "string" ? result.stdout.trim() : "";
+  return stdout === "true";
+}
 function safeInput(config) {
   return prompts.input(config).catch(handlePromptExit);
 }
@@ -267,7 +545,7 @@ function safeSelect(config) {
 }
 function handlePromptExit(err) {
   if (err instanceof Error && err.name === "ExitPromptError") {
-    console.log(chalk.yellow("\nCancelled."));
+    console.log(colors.yellow("\nCancelled."));
     process.exit(0);
   }
   throw err;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@project-ajax/create",
-	"version": "0.0.37",
+	"version": "0.0.39",
 	"description": "Initialize a new Notion Workers extensions repo.",
 	"bin": {
 		"create-ajax": "dist/index.js"
@@ -14,6 +14,9 @@
 		"entry": [
 			"src/index.ts"
 		],
+		"noExternal": [
+			"@project-ajax/shared"
+		],
 		"splitting": false,
 		"sourcemap": false,
 		"clean": true,
@@ -29,8 +32,7 @@
 	],
 	"dependencies": {
 		"@inquirer/prompts": "^8.0.1",
-		"chalk": "^5.3.0",
-		"ora": "^8.0.1"
+		"@project-ajax/shared": "*"
 	},
 	"devDependencies": {
 		"@types/node": "^22.19.0",