complete-cli 1.0.1-dev.0

package/src/commands/init/createProject.ts

@@ -0,0 +1,197 @@
+import chalk from "chalk";
+import { repeat } from "complete-common";
+import type { PackageManager } from "complete-node";
+import {
+  $,
+  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 } from "../../prompt.js";
+
+export async function createProject(
+  projectName: string,
+  authorName: string | undefined,
+  projectPath: string,
+  createNewDir: boolean,
+  gitRemoteURL: string | undefined,
+  skipInstall: boolean,
+  packageManager: PackageManager,
+): Promise<void> {
+  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 = 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: string) {
+  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: string,
+  projectPath: string,
+) {
+  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: string,
+  authorName: string | undefined,
+  projectPath: string,
+  packageManager: 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", // Not named ".gitignore" to prevent npm from deleting it.
+    );
+    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: string,
+  skipInstall: boolean,
+  packageManager: PackageManager,
+) {
+  if (skipInstall) {
+    return;
+  }
+
+  const command = getPackageManagerInstallCommand(packageManager);
+  promptLog(
+    `Installing node modules with "${command}"... (This can take a long time.)`,
+  );
+  const $$ = $({ cwd: projectPath });
+  const commandParts = command.split(" ");
+  await $$`${commandParts}`;
+}
+
+async function formatFiles(projectPath: string) {
+  const $$ = $({ cwd: projectPath });
+  await $$`prettier --write ${projectPath}`;
+}

package/src/commands/init/getAuthorName.ts

@@ -0,0 +1,23 @@
+import { getGitHubUsername } from "../../git.js";
+import { getInputString, promptError, promptLog } from "../../prompt.js";
+
+export async function getAuthorName(): Promise<string | undefined> {
+  const gitHubUsername = getGitHubUsername();
+  if (gitHubUsername !== undefined) {
+    return gitHubUsername;
+  }
+
+  return await getNewAuthorName();
+}
+
+async function getNewAuthorName(): Promise<string> {
+  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/src/commands/init/getProjectPath.ts

@@ -0,0 +1,112 @@
+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 = [
+  "<",
+  ">",
+  ":",
+  '"',
+  "/",
+  "\\",
+  "|",
+  "?",
+  "*",
+] as const;
+
+export async function getProjectPath(
+  name: string | undefined,
+  useCurrentDirectory: boolean,
+  customDirectory: string | undefined,
+  yes: boolean,
+  forceName: boolean,
+): Promise<{ projectPath: string; createNewDir: boolean }> {
+  let projectName = name;
+  let projectPath: string;
+  let createNewDir: boolean;
+  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(): Promise<[string, string, boolean]> {
+  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: string, forceName: boolean) {
+  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/src/commands/init/packageManager.ts

@@ -0,0 +1,64 @@
+import chalk from "chalk";
+import { PackageManager, commandExists } from "complete-node";
+import { DEFAULT_PACKAGE_MANAGER } from "../../constants.js";
+import { promptError } from "../../prompt.js";
+
+interface PackageManagerOptions {
+  npm: boolean;
+  yarn: boolean;
+  pnpm: boolean;
+}
+
+export function getPackageManagerUsedForNewProject(
+  options: PackageManagerOptions,
+): PackageManager {
+  const packageManagerFromOptions = getPackageManagerFromOptions(options);
+  if (packageManagerFromOptions !== undefined) {
+    return packageManagerFromOptions;
+  }
+
+  return DEFAULT_PACKAGE_MANAGER;
+}
+
+function getPackageManagerFromOptions(options: PackageManagerOptions) {
+  if (options.npm) {
+    const npmExists = 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 = 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 = 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/src/commands/init/vsCodeInit.ts

@@ -0,0 +1,115 @@
+import { $, 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",
+] as const;
+
+export async function vsCodeInit(
+  projectPath: string,
+  vscode: boolean,
+  yes: boolean,
+): Promise<void> {
+  const VSCodeCommand = 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);
+}
+
+function getVSCodeCommand(): string | undefined {
+  return VS_CODE_COMMANDS.find((command) => commandExists(command));
+}
+
+async function installVSCodeExtensions(
+  projectPath: string,
+  vsCodeCommand: string,
+) {
+  // 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 = getExtensionsFromJSON(projectPath);
+  for (const extensionName of extensions) {
+    // eslint-disable-next-line no-await-in-loop
+    await $`${vsCodeCommand} --install-extension ${extensionName}`;
+  }
+}
+
+function getExtensionsFromJSON(projectPath: string): readonly string[] {
+  const extensionsJSONPath = path.join(
+    projectPath,
+    ".vscode",
+    "extensions.json",
+  );
+
+  if (!isFile(extensionsJSONPath)) {
+    return [];
+  }
+
+  const extensionsJSON = 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 as string[];
+}
+
+async function promptVSCode(
+  projectPath: string,
+  VSCodeCommand: string,
+  vscode: boolean,
+  yes: boolean,
+): Promise<void> {
+  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: string, VSCodeCommand: string) {
+  await $`${VSCodeCommand} ${projectPath}`;
+}

package/src/constants.ts

@@ -0,0 +1,39 @@
+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,
+);