complete-cli 1.0.6 → 1.0.8

package/dist/commands/init/createProject.js

@@ -0,0 +1,130 @@
+import chalk from "chalk";
+import { repeat } from "complete-common";
+import { $q, copyFileOrDirectory, getFileNamesInDirectory, getPackageManagerInstallCICommand, getPackageManagerInstallCommand, isFile, makeDirectory, readFile, renameFile, updatePackageJSONDependencies, writeFile, } from "complete-node";
+import path from "node:path";
+import { ACTION_YML, ACTION_YML_TEMPLATE_PATH, TEMPLATES_DYNAMIC_DIR, TEMPLATES_STATIC_DIR, } from "../../constants.js";
+import { initGitRepository } from "../../git.js";
+import { promptError, promptLog, promptSpinnerStart } from "../../prompt.js";
+export async function createProject(projectName, authorName, projectPath, createNewDir, gitRemoteURL, skipInstall, packageManager) {
+    if (createNewDir) {
+        makeDirectory(projectPath);
+    }
+    copyStaticFiles(projectPath);
+    copyDynamicFiles(projectName, authorName, projectPath, packageManager);
+    // There is no package manager lock files yet, so we have to pass "false" to this function.
+    const updated = await updatePackageJSONDependencies(projectPath, false, true);
+    if (!updated) {
+        promptError('Failed to update the dependencies in the "package.json" file.');
+    }
+    await installNodeModules(projectPath, skipInstall, packageManager);
+    await formatFiles(projectPath);
+    // Only make the initial commit once all of the files have been copied and formatted.
+    await initGitRepository(projectPath, gitRemoteURL);
+    promptLog(`Successfully created project: ${chalk.green(projectName)}`);
+}
+/** Copy static files, like "eslint.config.mjs", "tsconfig.json", etc. */
+function copyStaticFiles(projectPath) {
+    copyTemplateDirectoryWithoutOverwriting(TEMPLATES_STATIC_DIR, projectPath);
+    // Rename "_gitattributes" to ".gitattributes". (If it is kept as ".gitattributes", then it won't
+    // be committed to git.)
+    const gitAttributesPath = path.join(projectPath, "_gitattributes");
+    const correctGitAttributesPath = path.join(projectPath, ".gitattributes");
+    renameFile(gitAttributesPath, correctGitAttributesPath);
+    // Rename "_cspell.config.jsonc" to "cspell.config.jsonc". (If it is kept as
+    // "cspell.config.jsonc", then local spell checking will fail.)
+    const cSpellConfigPath = path.join(projectPath, "_cspell.config.jsonc");
+    const correctCSpellConfigPath = path.join(projectPath, "cspell.config.jsonc");
+    renameFile(cSpellConfigPath, correctCSpellConfigPath);
+}
+function copyTemplateDirectoryWithoutOverwriting(templateDirPath, projectPath) {
+    const fileNames = getFileNamesInDirectory(templateDirPath);
+    for (const fileName of fileNames) {
+        const templateFilePath = path.join(templateDirPath, fileName);
+        const destinationFilePath = path.join(projectPath, fileName);
+        if (!isFile(destinationFilePath)) {
+            copyFileOrDirectory(templateFilePath, destinationFilePath);
+        }
+    }
+}
+/** Copy files that need to have text replaced inside of them. */
+function copyDynamicFiles(projectName, authorName, projectPath, packageManager) {
+    // `.github/workflows/setup/action.yml`
+    {
+        const fileName = ACTION_YML;
+        const templatePath = ACTION_YML_TEMPLATE_PATH;
+        const template = readFile(templatePath);
+        const installCommand = getPackageManagerInstallCICommand(packageManager);
+        const actionYML = template
+            .replaceAll("PACKAGE_MANAGER_NAME", packageManager)
+            .replaceAll("PACKAGE_MANAGER_INSTALL_COMMAND", installCommand);
+        const setupPath = path.join(projectPath, ".github", "workflows", "setup");
+        makeDirectory(setupPath);
+        const destinationPath = path.join(setupPath, fileName);
+        writeFile(destinationPath, actionYML);
+    }
+    // `.gitignore`
+    {
+        const templatePath = path.join(TEMPLATES_DYNAMIC_DIR, "_gitignore");
+        const template = readFile(templatePath);
+        // Prepend a header with the project name.
+        let separatorLine = "# ";
+        repeat(projectName.length, () => {
+            separatorLine += "-";
+        });
+        separatorLine += "\n";
+        const gitIgnoreHeader = `${separatorLine}# ${projectName}\n${separatorLine}\n`;
+        const nodeGitIgnorePath = path.join(TEMPLATES_DYNAMIC_DIR, "Node.gitignore");
+        const nodeGitIgnore = readFile(nodeGitIgnorePath);
+        // eslint-disable-next-line prefer-template
+        const gitignore = gitIgnoreHeader + template + "\n" + nodeGitIgnore;
+        // We need to replace the underscore with a period.
+        const destinationPath = path.join(projectPath, ".gitignore");
+        writeFile(destinationPath, gitignore);
+    }
+    // `package.json`
+    {
+        const templatePath = path.join(TEMPLATES_DYNAMIC_DIR, "package.json");
+        const template = readFile(templatePath);
+        const packageJSON = template
+            .replaceAll("project-name", projectName)
+            .replaceAll("author-name", authorName ?? "unknown");
+        const destinationPath = path.join(projectPath, "package.json");
+        writeFile(destinationPath, packageJSON);
+    }
+    // `README.md`
+    {
+        const templatePath = path.join(TEMPLATES_DYNAMIC_DIR, "README.md");
+        const template = readFile(templatePath);
+        // "PROJECT-NAME" must be hyphenated, as using an underscore will break Prettier for some
+        // reason.
+        const command = getPackageManagerInstallCICommand(packageManager);
+        const readmeMD = template
+            .replaceAll("PROJECT-NAME", projectName)
+            .replaceAll("PACKAGE-MANAGER-INSTALL-COMMAND", command);
+        const destinationPath = path.join(projectPath, "README.md");
+        writeFile(destinationPath, readmeMD);
+    }
+    const srcPath = path.join(projectPath, "src");
+    makeDirectory(srcPath);
+}
+async function installNodeModules(projectPath, skipInstall, packageManager) {
+    if (skipInstall) {
+        return;
+    }
+    const command = getPackageManagerInstallCommand(packageManager);
+    const s = promptSpinnerStart(`Installing the project dependencies with "${command}". (This can take a long time.)`);
+    try {
+        const $$q = $q({ cwd: projectPath });
+        const commandParts = command.split(" ");
+        await $$q `${commandParts}`;
+        s.stop("Installed.");
+    }
+    catch {
+        s.stop("Failed to install.");
+        promptError("Exiting.");
+    }
+}
+async function formatFiles(projectPath) {
+    const $$q = $q({ cwd: projectPath });
+    await $$q `prettier --write ${projectPath}`;
+}

package/dist/commands/init/getAuthorName.js

@@ -0,0 +1,17 @@
+import { getGitHubUsername } from "../../git.js";
+import { getInputString, promptError, promptLog } from "../../prompt.js";
+export async function getAuthorName() {
+    const gitHubUsername = await getGitHubUsername();
+    if (gitHubUsername !== undefined) {
+        return gitHubUsername;
+    }
+    return await getNewAuthorName();
+}
+async function getNewAuthorName() {
+    promptLog("The author name was not found from the GitHub CLI configuration file.");
+    const authorName = await getInputString("Enter the author of the project:");
+    if (authorName === "") {
+        promptError("You must enter an author name.");
+    }
+    return authorName;
+}

package/dist/commands/init/getProjectPath.js

@@ -0,0 +1,80 @@
+import chalk from "chalk";
+import { hasWhitespace, isKebabCase } from "complete-common";
+import path from "node:path";
+import { CURRENT_DIRECTORY_NAME, CWD } from "../../constants.js";
+import { getInputString, getInputYesNo, promptError, promptLog, } from "../../prompt.js";
+// From: https://gist.github.com/doctaphred/d01d05291546186941e1b7ddc02034d3
+const ILLEGAL_CHARACTERS_FOR_WINDOWS_FILENAMES = [
+    "<",
+    ">",
+    ":",
+    '"',
+    "/",
+    "\\",
+    "|",
+    "?",
+    "*",
+];
+export async function getProjectPath(name, useCurrentDirectory, customDirectory, yes, forceName) {
+    let projectName = name;
+    let projectPath;
+    let createNewDir;
+    if (useCurrentDirectory) {
+        // The "--use-current-directory" command-line flag was specified, so there is no need to prompt
+        // the user.
+        projectName = CURRENT_DIRECTORY_NAME;
+        projectPath = CWD;
+        createNewDir = false;
+    }
+    else if (projectName !== undefined) {
+        // The project name was specified on the command-line.
+        const baseDirectory = customDirectory === undefined ? CWD : path.join(CWD, customDirectory);
+        projectPath = path.join(baseDirectory, projectName);
+        createNewDir = true;
+    }
+    else if (yes) {
+        // The "--yes" command-line flag was specified and the project name was not specified on the
+        // command-line, so default to using the current directory.
+        projectName = CURRENT_DIRECTORY_NAME;
+        projectPath = CWD;
+        createNewDir = false;
+    }
+    else {
+        // The project name was not specified on the command-line, so prompt the user for it.
+        [projectName, projectPath, createNewDir] = await getNewProjectName();
+    }
+    validateProjectName(projectName, forceName);
+    promptLog(`Using a project name of: ${chalk.green(projectName)}`);
+    return { projectPath, createNewDir };
+}
+async function getNewProjectName() {
+    promptLog("You did not specify a project name as a command-line argument.");
+    const shouldUseCurrentDir = await getInputYesNo(`Would you like to create a new project using the current directory "${chalk.green(CURRENT_DIRECTORY_NAME)}" as the root?`);
+    if (shouldUseCurrentDir) {
+        return [CURRENT_DIRECTORY_NAME, CWD, false];
+    }
+    const projectName = await getInputString("Enter the name of the project:");
+    const projectPath = path.join(CWD, projectName);
+    return [projectName, projectPath, true];
+}
+function validateProjectName(projectName, forceName) {
+    if (projectName === "") {
+        promptError("You cannot have a blank project name.");
+    }
+    if (process.platform === "win32") {
+        for (const character of ILLEGAL_CHARACTERS_FOR_WINDOWS_FILENAMES) {
+            if (projectName.includes(character)) {
+                promptError(`The "${character}" character is not allowed in a Windows file name.`);
+            }
+        }
+    }
+    if (forceName) {
+        return;
+    }
+    if (hasWhitespace(projectName)) {
+        promptError('The project name has whitespace in it, which is not allowed. Use kebab-case for your project name. (e.g. "green-candle")');
+    }
+    if (!isKebabCase(projectName)) {
+        promptError('The project name is not in kebab-case. (Kebab-case is the style of using all lowercase letters, with words separated by hyphens.) Project names must use kebab-case to match GitHub repository standards. If necessary, you can override this check with the "--force-name" flag.');
+    }
+}

package/dist/commands/init/packageManager.js

@@ -0,0 +1,35 @@
+import chalk from "chalk";
+import { commandExists, PackageManager } from "complete-node";
+import { DEFAULT_PACKAGE_MANAGER } from "../../constants.js";
+import { promptError } from "../../prompt.js";
+export async function getPackageManagerUsedForNewProject(options) {
+    const packageManagerFromOptions = await getPackageManagerFromOptions(options);
+    if (packageManagerFromOptions !== undefined) {
+        return packageManagerFromOptions;
+    }
+    return DEFAULT_PACKAGE_MANAGER;
+}
+async function getPackageManagerFromOptions(options) {
+    if (options.npm) {
+        const npmExists = await commandExists("npm");
+        if (!npmExists) {
+            promptError(`You specified the "--npm" option, but "${chalk.green("npm")}" does not seem to be a valid command.`);
+        }
+        return PackageManager.npm;
+    }
+    if (options.yarn) {
+        const yarnExists = await commandExists("yarn");
+        if (!yarnExists) {
+            promptError(`You specified the "--yarn" option, but "${chalk.green("yarn")}" does not seem to be a valid command.`);
+        }
+        return PackageManager.yarn;
+    }
+    if (options.pnpm) {
+        const pnpmExists = await commandExists("pnpm");
+        if (!pnpmExists) {
+            promptError(`You specified the "--pnpm" option, but "${chalk.green("pnpm")}" does not seem to be a valid command.`);
+        }
+        return PackageManager.pnpm;
+    }
+    return undefined;
+}

package/dist/commands/init/vsCodeInit.js

@@ -0,0 +1,82 @@
+import { $, $q, commandExists, getJSONC, isFile } from "complete-node";
+import path from "node:path";
+import { getInputYesNo, promptError, promptLog } from "../../prompt.js";
+const VS_CODE_COMMANDS = [
+    "code",
+    "codium",
+    "code-oss",
+    "code-insiders",
+];
+export async function vsCodeInit(projectPath, vscode, yes) {
+    const VSCodeCommand = await getVSCodeCommand();
+    if (VSCodeCommand === undefined) {
+        promptLog('VSCode does not seem to be installed. (The "code" command is not in the path.) Skipping VSCode-related things.');
+        return;
+    }
+    await installVSCodeExtensions(projectPath, VSCodeCommand);
+    await promptVSCode(projectPath, VSCodeCommand, vscode, yes);
+}
+async function getVSCodeCommand() {
+    const commandCheckPromises = VS_CODE_COMMANDS.map((command) => ({
+        command,
+        existsPromise: commandExists(command),
+    }));
+    const commandChecks = await Promise.all(commandCheckPromises.map(async (check) => ({
+        command: check.command,
+        exists: await check.existsPromise,
+    })));
+    const existingCommands = commandChecks
+        .filter((check) => check.exists)
+        .map((check) => check.command);
+    return existingCommands[0];
+}
+async function installVSCodeExtensions(projectPath, vsCodeCommand) {
+    // Installing extensions from inside WSL on Windows will result in the VSCode process never
+    // exiting for some reason. Thus, skip this step on Linux. (Linux users will probably be smart
+    // enough to install the extensions on their own.)
+    if (process.platform === "linux") {
+        return;
+    }
+    const extensions = await getExtensionsFromJSON(projectPath);
+    await Promise.all(extensions.map(async (extension) => await $q `${vsCodeCommand} --install-extension ${extension}`));
+}
+async function getExtensionsFromJSON(projectPath) {
+    const extensionsJSONPath = path.join(projectPath, ".vscode", "extensions.json");
+    if (!isFile(extensionsJSONPath)) {
+        return [];
+    }
+    const extensionsJSON = await getJSONC(extensionsJSONPath);
+    const { recommendations } = extensionsJSON;
+    if (!Array.isArray(recommendations)) {
+        promptError('The "recommendations" field in the "extensions.json" file is not an array.');
+    }
+    for (const recommendation of recommendations) {
+        if (typeof recommendation !== "string") {
+            promptError('One of the entries in the "recommendations" field in the "extensions.json" file is not a string.');
+        }
+    }
+    return recommendations;
+}
+async function promptVSCode(projectPath, VSCodeCommand, vscode, yes) {
+    if (vscode) {
+        // They supplied the "--vscode" command-line flag, so there is no need to prompt the user.
+        await openVSCode(projectPath, VSCodeCommand);
+        return;
+    }
+    if (yes) {
+        // They supplied the "--yes" command-line flag, which implies that they want a silent install,
+        // so skip opening VSCode.
+        return;
+    }
+    // The VSCode command does not work properly inside WSL on Windows.
+    if (process.platform === "linux") {
+        return;
+    }
+    const shouldOpenVSCode = await getInputYesNo("Do you want to open your new project in VSCode now?");
+    if (shouldOpenVSCode) {
+        await openVSCode(projectPath, VSCodeCommand);
+    }
+}
+async function openVSCode(projectPath, VSCodeCommand) {
+    await $ `${VSCodeCommand} ${projectPath}`;
+}

package/dist/constants.js

@@ -0,0 +1,17 @@
+import { findPackageRoot, getPackageJSONFieldsMandatory, PackageManager, } from "complete-node";
+import os from "node:os";
+import path from "node:path";
+export const CWD = process.cwd();
+export const CURRENT_DIRECTORY_NAME = path.basename(CWD);
+export const HOME_DIR = os.homedir();
+const packageRoot = findPackageRoot();
+const { name, version } = getPackageJSONFieldsMandatory(packageRoot, "name", "version");
+export const PROJECT_NAME = name;
+export const PROJECT_VERSION = version;
+export const DEFAULT_PACKAGE_MANAGER = PackageManager.npm;
+// ---------
+const TEMPLATES_DIR = path.join(packageRoot, "file-templates");
+export const TEMPLATES_STATIC_DIR = path.join(TEMPLATES_DIR, "static");
+export const TEMPLATES_DYNAMIC_DIR = path.join(TEMPLATES_DIR, "dynamic");
+export const ACTION_YML = "action.yml";
+export const ACTION_YML_TEMPLATE_PATH = path.join(TEMPLATES_DYNAMIC_DIR, ".github", "workflows", "setup", ACTION_YML);

package/dist/git.js

@@ -0,0 +1,132 @@
+import chalk from "chalk";
+import { $, commandExists, isFileAsync, readFileAsync } from "complete-node";
+import path from "node:path";
+import yaml from "yaml";
+import { HOME_DIR, PROJECT_NAME, PROJECT_VERSION } from "./constants.js";
+import { getInputString, getInputYesNo, promptLog } from "./prompt.js";
+/**
+ * If the GitHub CLI is installed, we can derive the user's GitHub username from their YAML
+ * configuration.
+ */
+export async function getGitHubUsername() {
+    const ghExists = await commandExists("gh");
+    if (!ghExists) {
+        return undefined;
+    }
+    const githubCLIHostsPath = getGithubCLIHostsPath();
+    if (githubCLIHostsPath === undefined) {
+        return undefined;
+    }
+    const hostsPathExists = await isFileAsync(githubCLIHostsPath);
+    if (!hostsPathExists) {
+        return undefined;
+    }
+    const configYAMLRaw = await readFileAsync(githubCLIHostsPath);
+    const configYAML = yaml.parse(configYAMLRaw);
+    const githubCom = configYAML["github.com"];
+    if (githubCom === undefined) {
+        return undefined;
+    }
+    const { user } = githubCom;
+    if (user === undefined || user === "") {
+        return undefined;
+    }
+    return user;
+}
+function getGithubCLIHostsPath() {
+    if (process.platform === "win32") {
+        const appData = process.env["APPDATA"];
+        if (appData === undefined || appData === "") {
+            return undefined;
+        }
+        return path.join(appData, "GitHub CLI", "hosts.yml");
+    }
+    // The location is the same on both macOS and Linux.
+    return path.join(HOME_DIR, ".config", "gh", "hosts.yml");
+}
+/** @returns The git remote URL. For example: git@github.com:alice/foo.git */
+export async function promptGitHubRepoOrGitRemoteURL(projectName, yes, skipGit) {
+    if (skipGit) {
+        return undefined;
+    }
+    // Hard-code certain project names as never causing a Git repository to be initialized.
+    if (projectName.startsWith("test") || projectName === "foo") {
+        return undefined;
+    }
+    // We do not need to prompt the user if they do not have Git installed.
+    const gitExists = await commandExists("git");
+    if (!gitExists) {
+        promptLog('Git does not seem to be installed. (The "git" command is not in the path.) Skipping Git-related things.');
+        return undefined;
+    }
+    const gitHubUsername = await getGitHubUsername();
+    if (gitHubUsername !== undefined) {
+        const { exitCode } = await $ `gh repo view ${projectName}`;
+        const gitHubRepoExists = exitCode === 0;
+        const url = `https://github.com/${gitHubUsername}/${projectName}`;
+        if (gitHubRepoExists) {
+            promptLog(`Detected an existing GitHub repository at: ${chalk.green(url)}`);
+            const guessedRemoteURL = getGitRemoteURL(projectName, gitHubUsername);
+            if (yes) {
+                promptLog(`Using a Git remote URL of: ${chalk.green(guessedRemoteURL)}`);
+                return guessedRemoteURL;
+            }
+            const shouldUseGuessedURL = await getInputYesNo(`Do you want to use a Git remote URL of: ${chalk.green(guessedRemoteURL)}`);
+            if (shouldUseGuessedURL) {
+                return guessedRemoteURL;
+            }
+            // Assume that since they do not want to connect this project to the existing GitHub
+            // repository, they do not want to initialize a remote Git URL at all.
+            return undefined;
+        }
+        if (yes) {
+            await $ `gh repo create ${projectName} --public`;
+            promptLog(`Created a new GitHub repository at: ${chalk.green(url)}`);
+            return getGitRemoteURL(projectName, gitHubUsername);
+        }
+        const createNewGitHubRepo = await getInputYesNo(`Would you like to create a new GitHub repository at: ${chalk.green(url)}`);
+        if (createNewGitHubRepo) {
+            await $ `gh repo create ${projectName} --public`;
+            promptLog("Successfully created a new GitHub repository.");
+            return getGitRemoteURL(projectName, gitHubUsername);
+        }
+        // Assume that since they do not want to create a new GitHub repository, they do not want to
+        // initialize a remote Git URL at all.
+        return undefined;
+    }
+    const gitRemoteURL = await getInputString(`Paste in the remote Git URL for your project.
+For example, if you have an SSH key, it would be something like:
+${chalk.green("git@github.com:Alice/green-candle.git")}
+If you don't have an SSH key, it would be something like:
+${chalk.green("https://github.com/Alice/green-candle.git")}
+If you don't want to initialize a Git repository for this project, press enter to skip.
+`);
+    return gitRemoteURL === "" ? undefined : gitRemoteURL;
+}
+function getGitRemoteURL(projectName, gitHubUsername) {
+    return `git@github.com:${gitHubUsername}/${projectName}.git`;
+}
+export async function initGitRepository(projectPath, gitRemoteURL) {
+    const gitExists = await commandExists("git");
+    if (!gitExists) {
+        return;
+    }
+    if (gitRemoteURL === undefined) {
+        return;
+    }
+    const $$ = $({ cwd: projectPath });
+    await $$ `git init --initial-branch main`;
+    await $$ `git remote add origin ${gitRemoteURL}`;
+    const gitNameAndEmailConfigured = await isGitNameAndEmailConfigured();
+    if (gitNameAndEmailConfigured) {
+        await $$ `git add --all`;
+        const commitMessage = `chore: add files from ${PROJECT_NAME} ${PROJECT_VERSION} template`;
+        await $$ `git commit --message ${commitMessage}`;
+        await $$ `git push --set-upstream origin main`;
+    }
+}
+async function isGitNameAndEmailConfigured() {
+    const { exitCode: nameExitCode } = await $ `git config --global user.name`;
+    const { exitCode: emailExitCode } = await $ `git config --global user.email`;
+    return nameExitCode === 0 && emailExitCode === 0;
+}

package/dist/interfaces/GitHubCLIHostsYAML.js

@@ -0,0 +1 @@
+export {};

package/dist/main.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+import { Builtins, Cli } from "clipanion";
+import { CheckCommand } from "./commands/CheckCommand.js";
+import { InitCommand } from "./commands/InitCommand.js";
+import { NukeCommand } from "./commands/NukeCommand.js";
+import { PublishCommand } from "./commands/PublishCommand.js";
+import { UpdateCommand } from "./commands/UpdateCommand.js";
+import { PROJECT_NAME, PROJECT_VERSION } from "./constants.js";
+await main();
+async function main() {
+    const [_node, _app, ...args] = process.argv;
+    const cli = new Cli({
+        binaryLabel: PROJECT_NAME,
+        binaryName: PROJECT_NAME,
+        binaryVersion: PROJECT_VERSION,
+    });
+    cli.register(CheckCommand);
+    cli.register(InitCommand);
+    cli.register(NukeCommand);
+    cli.register(PublishCommand);
+    cli.register(UpdateCommand);
+    cli.register(Builtins.HelpCommand);
+    await cli.runExit(args);
+}

package/dist/prompt.js

@@ -0,0 +1,53 @@
+// Both the Inquirer.js library and the Prompts library have a bug where text is duplicated in a Git
+// Bash terminal. Thus, we revert to using the simpler Prompt library.
+import { cancel, confirm, intro, isCancel, log, outro, spinner, text, } from "@clack/prompts";
+import chalk from "chalk";
+import { PROJECT_NAME } from "./constants.js";
+export function promptStart() {
+    intro(chalk.inverse(PROJECT_NAME));
+}
+export function promptEnd(msg) {
+    outro(msg);
+    process.exit();
+}
+export async function getInputYesNo(msg, defaultValue = true) {
+    const input = await confirm({
+        message: msg,
+        initialValue: defaultValue,
+    });
+    if (isCancel(input)) {
+        cancel("Canceled.");
+        process.exit(1);
+    }
+    return input;
+}
+/** Returns trimmed input. */
+export async function getInputString(msg, defaultValue) {
+    const input = await text({
+        message: msg,
+        initialValue: defaultValue,
+    });
+    if (isCancel(input)) {
+        cancel("Canceled.");
+        process.exit(1);
+    }
+    const trimmedInput = input.trim();
+    if (trimmedInput === "") {
+        promptError("You must enter a non-empty value.");
+    }
+    return input.trim();
+}
+export function promptLog(msg) {
+    log.step(msg); // Step is a hollow green diamond.
+}
+export function promptSpinnerStart(msg) {
+    const s = spinner({
+        indicator: "timer",
+    });
+    s.start(msg);
+    return s;
+}
+export function promptError(msg) {
+    cancel(msg);
+    process.exit(1);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "complete-cli",
-  "version": "1.0.6",
+  "version": "1.0.8",
   "description": "A command line tool for bootstrapping TypeScript projects.",
   "keywords": [
     "typescript"
@@ -17,7 +17,7 @@
   "author": "Zamiell",
   "type": "module",
   "bin": {
-    "complete-cli": "./dist/main.cjs"
+    "complete-cli": "./dist/main.js"
   },
   "files": [
     "dist",
@@ -33,26 +33,26 @@
     "start": "tsx ./src/main.ts",
     "test": "glob \"./src/**/*.test.ts\" --cmd=\"node --import tsx --test --test-reporter spec\""
   },
-  "devDependencies": {
+  "dependencies": {
     "@clack/prompts": "0.10.0",
-    "@types/klaw-sync": "6.0.5",
-    "@types/node": "22.13.5",
-    "@types/source-map-support": "^0.5.10",
     "chalk": "5.4.1",
     "clipanion": "4.0.0-rc.4",
     "complete-common": "^1.1.1",
     "complete-node": "^3.0.1",
-    "glob": "11.0.1",
     "klaw-sync": "6.0.0",
-    "source-map-support": "^0.5.21",
+    "yaml": "2.7.0"
+  },
+  "devDependencies": {
+    "@types/klaw-sync": "6.0.5",
+    "@types/node": "22.13.5",
+    "glob": "11.0.1",
     "ts-loader": "9.5.2",
     "tsconfig-paths-webpack-plugin": "^4.2.0",
     "typescript": "5.7.3",
     "typescript-eslint": "8.24.1",
     "webpack": "5.98.0",
     "webpack-cli": "6.0.1",
-    "webpack-shebang-plugin": "^1.1.8",
-    "yaml": "2.7.0"
+    "webpack-shebang-plugin": "^1.1.8"
   },
   "engines": {
     "node": ">= 20.11.0"

package/src/main.ts

@@ -1,7 +1,6 @@
 #!/usr/bin/env node
 
 import { Builtins, Cli } from "clipanion";
-import { install } from "source-map-support";
 import { CheckCommand } from "./commands/CheckCommand.js";
 import { InitCommand } from "./commands/InitCommand.js";
 import { NukeCommand } from "./commands/NukeCommand.js";
@@ -12,8 +11,6 @@ import { PROJECT_NAME, PROJECT_VERSION } from "./constants.js";
 await main();
 
 async function main(): Promise<void> {
-  install();
-
   const [_node, _app, ...args] = process.argv;
 
   const cli = new Cli({