complete-cli 1.0.1-dev.0

package/src/git.ts

@@ -0,0 +1,182 @@
+import chalk from "chalk";
+import { $, commandExists, isFile, readFile } from "complete-node";
+import path from "node:path";
+import yaml from "yaml";
+import { HOME_DIR, PROJECT_NAME, PROJECT_VERSION } from "./constants.js";
+import type { GitHubCLIHostsYAML } from "./interfaces/GitHubCLIHostsYAML.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 function getGitHubUsername(): string | undefined {
+  if (!commandExists("gh")) {
+    return undefined;
+  }
+
+  const githubCLIHostsPath = getGithubCLIHostsPath();
+  if (githubCLIHostsPath === undefined) {
+    return undefined;
+  }
+
+  if (!isFile(githubCLIHostsPath)) {
+    return undefined;
+  }
+
+  const configYAMLRaw = readFile(githubCLIHostsPath);
+  const configYAML = yaml.parse(configYAMLRaw) as GitHubCLIHostsYAML;
+
+  const githubCom = configYAML["github.com"];
+  if (githubCom === undefined) {
+    return undefined;
+  }
+
+  const { user } = githubCom;
+  if (user === undefined || user === "") {
+    return undefined;
+  }
+
+  return user;
+}
+
+function getGithubCLIHostsPath(): string | undefined {
+  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: string,
+  yes: boolean,
+  skipGit: boolean,
+): Promise<string | undefined> {
+  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.
+  if (!commandExists("git")) {
+    promptLog(
+      'Git does not seem to be installed. (The "git" command is not in the path.) Skipping Git-related things.',
+    );
+    return undefined;
+  }
+
+  const gitHubUsername = 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: string, gitHubUsername: string) {
+  return `git@github.com:${gitHubUsername}/${projectName}.git`;
+}
+
+export async function initGitRepository(
+  projectPath: string,
+  gitRemoteURL: string | undefined,
+): Promise<void> {
+  if (!commandExists("git")) {
+    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(): Promise<boolean> {
+  const { exitCode: nameExitCode } = await $`git config --global user.name`;
+  const { exitCode: emailExitCode } = await $`git config --global user.email`;
+
+  return nameExitCode === 0 && emailExitCode === 0;
+}

package/src/interfaces/GitHubCLIHostsYAML.ts

@@ -0,0 +1,7 @@
+export interface GitHubCLIHostsYAML {
+  "github.com"?: {
+    user?: string;
+    oauth_token?: string;
+    git_protocol?: string;
+  };
+}

package/src/main.ts

@@ -0,0 +1,34 @@
+#!/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";
+import { validateNodeVersion } from "./validateNoteVersion.js";
+
+await main();
+
+async function main(): Promise<void> {
+  validateNodeVersion();
+
+  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/src/prompt.ts

@@ -0,0 +1,72 @@
+// 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,
+  text,
+} from "@clack/prompts";
+import chalk from "chalk";
+import { PROJECT_NAME } from "./constants.js";
+
+export function promptStart(): void {
+  intro(chalk.inverse(PROJECT_NAME));
+}
+
+export function promptEnd(msg: string): never {
+  outro(msg);
+  process.exit();
+}
+
+export async function getInputYesNo(
+  msg: string,
+  defaultValue = true,
+): Promise<boolean> {
+  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: string,
+  defaultValue?: string,
+): Promise<string> {
+  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: string): void {
+  log.step(msg); // Step is a hollow green diamond.
+}
+
+export function promptError(msg: string): never {
+  cancel(msg);
+  process.exit(1);
+}

package/src/validateNoteVersion.ts

@@ -0,0 +1,39 @@
+import chalk from "chalk";
+import { parseSemanticVersion } from "complete-common";
+import { PROJECT_NAME } from "./constants.js";
+
+// 20.11 is the minimum version that supports `import.meta.dirname`.
+const REQUIRED_NODE_JS_MAJOR_VERSION = 20;
+const REQUIRED_NODE_JS_MINOR_VERSION = 11;
+
+export function validateNodeVersion(): void {
+  const { version } = process;
+
+  const semanticVersion = parseSemanticVersion(version);
+  if (semanticVersion === undefined) {
+    throw new Error(`Failed to parse the Node version: ${version}`);
+  }
+
+  const { majorVersion, minorVersion } = semanticVersion;
+  if (majorVersion > REQUIRED_NODE_JS_MAJOR_VERSION) {
+    return;
+  }
+
+  if (
+    majorVersion === REQUIRED_NODE_JS_MAJOR_VERSION &&
+    minorVersion >= REQUIRED_NODE_JS_MINOR_VERSION
+  ) {
+    return;
+  }
+
+  console.error(`Your Node.js version is: ${chalk.red(version)}`);
+  console.error(
+    `${PROJECT_NAME} requires a Node.js version of ${chalk.red(
+      `${REQUIRED_NODE_JS_MAJOR_VERSION}.${REQUIRED_NODE_JS_MINOR_VERSION}.0`,
+    )} or greater.`,
+  );
+  console.error(
+    `Please upgrade your version of Node.js before using ${PROJECT_NAME}.`,
+  );
+  process.exit(1);
+}