isaacscript 1.1.55 → 1.1.59

package/src/commands/init/createMod.ts

@@ -1,4 +1,7 @@
+import chalk from "chalk";
+import commandExists from "command-exists";
 import path from "path";
+import yaml from "yaml";
 import * as configFile from "../../configFile";
 import {
   GITIGNORE,
@@ -16,15 +19,18 @@ import {
   TEMPLATES_STATIC_DIR,
 } from "../../constants";
 import * as file from "../../file";
-import { execShell, snakeKebabToCamel } from "../../util";
+import { getInputString, getInputYesNo } from "../../prompt";
+import { GitHubCLIHostsYAML } from "../../types/GitHubCLIHostsYAML";
+import { execShell } from "../../util";
 
-export function createMod(
+export async function createMod(
   projectName: string,
   projectPath: string,
   createNewDir: boolean,
   modsDirectory: string,
   saveSlot: number,
-): void {
+  skipNPMInstall: boolean,
+): Promise<void> {
   if (createNewDir) {
     file.makeDir(projectPath);
   }
@@ -37,7 +43,10 @@ export function createMod(
   copyStaticFiles(projectPath);
   copyDynamicFiles(projectName, projectPath, targetModDirectory);
   updateNodeModules(projectPath);
-  installNodeModules(projectPath);
+  await initGitRepository(projectPath, projectName);
+  installNodeModules(projectPath, skipNPMInstall);
+
+  console.log(`Successfully created mod: ${chalk.green(projectName)}`);
 }
 
 function makeSubdirectories(projectPath: string) {
@@ -91,7 +100,7 @@ function copyDynamicFiles(
     const fileName = PACKAGE_JSON;
     const templatePath = PACKAGE_JSON_TEMPLATE_PATH;
     const template = file.read(templatePath);
-    const packageJSON = template.replace(/MOD_NAME/g, projectName);
+    const packageJSON = template.replace(/MOD_NAME_TO_REPLACE/g, projectName);
     const destinationPath = path.join(projectPath, fileName);
     file.write(destinationPath, packageJSON);
   }
@@ -101,7 +110,7 @@ function copyDynamicFiles(
     const fileName = README_MD;
     const templatePath = README_MD_TEMPLATES_PATH;
     const template = file.read(templatePath);
-    const readmeMD = template.replace(/MOD_NAME/g, projectName);
+    const readmeMD = template.replace(/MOD_NAME_TO_REPLACE/g, projectName);
     const destinationPath = path.join(projectPath, fileName);
     file.write(destinationPath, readmeMD);
   }
@@ -111,7 +120,7 @@ function copyDynamicFiles(
     const fileName = METADATA_XML;
     const templatePath = METADATA_XML_TEMPLATE_PATH;
     const template = file.read(templatePath);
-    const metadataXML = template.replace(/MOD_NAME/g, projectName);
+    const metadataXML = template.replace(/MOD_NAME_TO_REPLACE/g, projectName);
     const modPath = path.join(projectPath, "mod");
     const destinationPath = path.join(modPath, fileName);
     file.write(destinationPath, metadataXML);
@@ -133,20 +142,126 @@ function copyDynamicFiles(
     // Convert snake_case and kebab-case to camelCase
     // (kebab-case in particular will make the example TypeScript file fail to compile)
     const srcPath = path.join(projectPath, "src");
-    const camelCaseProjectName = snakeKebabToCamel(projectName);
     const fileName = MAIN_TS;
     const templatePath = MAIN_TS_TEMPLATE_PATH;
     const template = file.read(templatePath);
-    const mainTS = template
-      .replace(/MOD_NAME initialized/g, `${projectName} initialized`)
-      .replace(/MOD_NAME/g, camelCaseProjectName);
+    const mainTS = template.replace(/MOD_NAME_TO_REPLACE/g, projectName);
     const destinationPath = path.join(srcPath, fileName);
     file.write(destinationPath, mainTS);
   }
 }
 
+async function initGitRepository(projectPath: string, projectName: string) {
+  if (!commandExists.sync("git")) {
+    console.log(
+      'Git does not seem to be installed. (The "git" command is not in the path.) Skipping Git-related things.',
+    );
+    return;
+  }
+
+  const remoteURL = await getGitRemoteURL(projectName);
+  if (remoteURL === "") {
+    return;
+  }
+
+  execShell("git", ["init"], false, projectPath);
+  execShell("git", ["branch", "-M", "main"], false, projectPath);
+  execShell("git", ["remote", "add", "origin", remoteURL], false, projectPath);
+  if (isGitNameAndEmailConfigured()) {
+    execShell("git", ["add", "--all"], false, projectPath);
+    execShell(
+      "git",
+      ["commit", "--message", "IsaacScript template"],
+      false,
+      projectPath,
+    );
+  }
+}
+
+async function getGitRemoteURL(projectName: string) {
+  const guessedRemoteURL = guessRemoteURL(projectName);
+  if (guessedRemoteURL !== undefined) {
+    const shouldUseGuessedURL = await getInputYesNo(
+      `Do you want to use a Git remote URL of: ${chalk.green(
+        guessedRemoteURL,
+      )}`,
+    );
+    if (shouldUseGuessedURL) {
+      return guessedRemoteURL;
+    }
+  }
+
+  return 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.
+`);
+}
+
+function guessRemoteURL(projectName: string) {
+  const gitHubUsername = getGitHubUsername();
+  if (gitHubUsername === undefined) {
+    return undefined;
+  }
+
+  return `git@github.com:${gitHubUsername}/${projectName}.git`;
+}
+
+function getGitHubUsername() {
+  // If the GitHub CLI is installed, we can derive the user's GitHub username
+  if (
+    !commandExists.sync("gh") ||
+    process.env.APPDATA === undefined ||
+    process.env.APPDATA === ""
+  ) {
+    return undefined;
+  }
+
+  const githubCLIHostsPath = path.join(
+    process.env.APPDATA,
+    "GitHub CLI",
+    "hosts.yml",
+  );
+  if (!file.exists(githubCLIHostsPath)) {
+    return undefined;
+  }
+
+  const configYAMLRaw = file.read(githubCLIHostsPath);
+  const configYAML = yaml.parse(configYAMLRaw) as GitHubCLIHostsYAML;
+
+  const githubCom = configYAML["github.com"];
+  if (githubCom === undefined) {
+    return undefined;
+  }
+
+  const { user } = githubCom;
+  if (user === "") {
+    return undefined;
+  }
+
+  return user;
+}
+
+function isGitNameAndEmailConfigured() {
+  const [nameExitStatus] = execShell(
+    "git",
+    ["config", "--global", "user.name"],
+    true,
+  );
+
+  const [emailExitStatus] = execShell(
+    "git",
+    ["config", "--global", "user.email"],
+    true,
+  );
+
+  return nameExitStatus === 0 && emailExitStatus === 0;
+}
+
 function updateNodeModules(projectPath: string) {
-  console.log("Updating node modules...");
+  console.log("Finding out the latest versions of the IsaacScript packages...");
   execShell(
     "npx",
     ["npm-check-updates", "--upgrade", "--packageFile", "package.json"],
@@ -155,7 +270,11 @@ function updateNodeModules(projectPath: string) {
   );
 }
 
-function installNodeModules(projectPath: string) {
+function installNodeModules(projectPath: string, skipNPMInstall: boolean) {
+  if (skipNPMInstall) {
+    return;
+  }
+
   console.log("Installing node modules... (This can take a long time.)");
   execShell("npm", ["install"], false, projectPath);
 }

package/src/commands/init/getModsDir.ts

@@ -1,13 +1,10 @@
 import chalk from "chalk";
-import os from "os";
 import path from "path";
-import prompts from "prompts";
+import { HOME_DIR } from "../../constants";
 import * as file from "../../file";
+import { getInputString } from "../../prompt";
 import { error } from "../../util";
 
-// https://stackoverflow.com/questions/9080085/node-js-find-home-directory-in-platform-agnostic-way
-const homeDir = os.homedir();
-
 const MODS = "mods";
 
 const DEFAULT_MODS_PATH_WINDOWS = path.join(
@@ -22,7 +19,7 @@ const DEFAULT_MODS_PATH_WINDOWS = path.join(
 
 // This is a subdirectory of $HOME
 const DEFAULT_MODS_PATH_LINUX = path.join(
-  homeDir,
+  HOME_DIR,
   ".local",
   "share",
   "Steam",
@@ -50,16 +47,13 @@ export async function getModsDir(
   console.error(
     `Failed to find your mods directory at: ${chalk.green(defaultModsPath)}`,
   );
-  const response = await prompts({
-    type: "text",
-    name: "modsDir",
-    message: `Enter the full path to the "${MODS}" directory on your system, which should be next to your "isaac-ng.exe" program:`,
-  });
+  const modsDir = await getInputString(
+    `Enter the full path to the "${MODS}" directory on your system, which should be next to your "isaac-ng.exe" program:`,
+  );
 
-  if (typeof response.modsDir !== "string") {
-    error("Error: The response was not a string.");
+  if (modsDir === "") {
+    error("Error: You did not provide a response; exiting.");
   }
-  const modsDir = response.modsDir.trim();
 
   if (!file.exists(modsDir)) {
     error(

package/src/commands/init/getProjectPath.ts

@@ -1,8 +1,8 @@
 import chalk from "chalk";
 import path from "path";
-import prompts from "prompts";
 import { CURRENT_DIRECTORY_NAME, CWD } from "../../constants";
-import { error, hasWhiteSpace } from "../../util";
+import { getInputString, getInputYesNo } from "../../prompt";
+import { hasWhiteSpace } from "../../util";
 
 // From: https://gist.github.com/doctaphred/d01d05291546186941e1b7ddc02034d3
 const ILLEGAL_CHARACTERS_FOR_WINDOWS_FILENAMES = [
@@ -54,29 +54,17 @@ function getProjectNameFromCommandLineArgument(
 
 async function getNewProjectName(): Promise<[string, string, boolean]> {
   console.log("You did not specify a project name as a command-line argument.");
-  const response1 = await prompts({
-    type: "confirm",
-    name: "useCurrentDir",
-    message: `Would you like to create a new project using the current directory "${chalk.green(
+  const shouldUseCurrentDir = await getInputYesNo(
+    `Would you like to create a new project using the current directory "${chalk.green(
       CURRENT_DIRECTORY_NAME,
     )}" as the root?`,
-    initial: true,
-  });
+  );
 
-  if (response1.useCurrentDir === true) {
+  if (shouldUseCurrentDir) {
     return [CURRENT_DIRECTORY_NAME, CWD, false];
   }
 
-  const response2 = await prompts({
-    type: "text",
-    name: "projectName",
-    message: "Enter the name of the project:",
-  });
-
-  if (typeof response2.projectName !== "string") {
-    error("Error: The response was not a string.");
-  }
-  const projectName = response2.projectName.trim();
+  const projectName = await getInputString("Enter the name of the project:");
   const projectPath = path.join(CWD, projectName);
 
   return [projectName, projectPath, true];

package/src/commands/init/init.ts

@@ -21,28 +21,31 @@ export async function init(argv: Record<string, unknown>): Promise<void> {
   const projectName = path.basename(projectPath);
   await checkModTargetDirectory(modsDirectory, projectName);
   const saveSlot = await promptSaveSlot(argv);
+  const skipNPMInstall = argv.skipNpmInstall === true;
 
-  // Begin the creation of the new mod
-  createMod(projectName, projectPath, createNewDir, modsDirectory, saveSlot);
-  console.log(`Successfully created mod: ${chalk.green(projectName)}`);
+  await createMod(
+    projectName,
+    projectPath,
+    createNewDir,
+    modsDirectory,
+    saveSlot,
+    skipNPMInstall,
+  );
+  await openVSCode(projectPath, argv);
+  printFinishMessage(projectPath, projectName);
+}
 
+async function openVSCode(projectPath: string, argv: Record<string, unknown>) {
   const VSCodeCommand = getVSCodeCommand();
   if (VSCodeCommand === null) {
     console.log(
       'VSCode does not seem to be installed. (The "code" command is not in the path.) Skipping VSCode-related things.',
     );
-  } else {
-    installVSCodeExtensions(projectPath, VSCodeCommand);
-    await promptVSCode(projectPath, argv, VSCodeCommand);
+    return;
   }
 
-  // Finished
-  let commandsToType = "";
-  if (projectPath !== CWD) {
-    commandsToType += `"${chalk.green(`cd ${projectName}`)}" and `;
-  }
-  commandsToType += `"${chalk.green("npx isaacscript")}"`;
-  console.log(`Now, start IsaacScript by typing ${commandsToType}.`);
+  installVSCodeExtensions(projectPath, VSCodeCommand);
+  await promptVSCode(projectPath, argv, VSCodeCommand);
 }
 
 function getVSCodeCommand() {
@@ -54,3 +57,12 @@ function getVSCodeCommand() {
 
   return null;
 }
+
+function printFinishMessage(projectPath: string, projectName: string) {
+  let commandsToType = "";
+  if (projectPath !== CWD) {
+    commandsToType += `"${chalk.green(`cd ${projectName}`)}" and `;
+  }
+  commandsToType += `"${chalk.green("npx isaacscript")}"`;
+  console.log(`Now, start IsaacScript by typing ${commandsToType}.`);
+}

package/src/commands/init/promptSaveSlot.ts

@@ -1,4 +1,4 @@
-import prompts from "prompts";
+import { getInputInt } from "../../prompt";
 import { error } from "../../util";
 
 export async function promptSaveSlot(
@@ -10,20 +10,13 @@ export async function promptSaveSlot(
     return argv.saveSlot as number;
   }
 
-  const response = await prompts({
-    type: "number",
-    name: "saveSlot",
-    message: "In-game, will you test your mod on save slot 1, 2, or 3?",
-    initial: 1,
-  });
+  const saveSlot = await getInputInt(
+    "In-game, will you test your mod on save slot 1, 2, or 3?",
+  );
 
-  if (
-    response.saveSlot !== 1 &&
-    response.saveSlot !== 2 &&
-    response.saveSlot !== 3
-  ) {
+  if (saveSlot !== 1 && saveSlot !== 2 && saveSlot !== 3) {
     error("Error: You must choose a number between 1 and 3.");
   }
 
-  return response.saveSlot as number;
+  return saveSlot;
 }

package/src/commands/init/promptVSCode.ts

@@ -1,6 +1,6 @@
 import path from "path";
-import prompts from "prompts";
 import { MAIN_TS } from "../../constants";
+import { getInputYesNo } from "../../prompt";
 import { execShell } from "../../util";
 
 export async function promptVSCode(
@@ -15,14 +15,10 @@ export async function promptVSCode(
     return;
   }
 
-  const response = await prompts({
-    type: "confirm",
-    name: "VSCode",
-    message: "Do you want to open your new project in VSCode now?",
-    initial: true,
-  });
-
-  if (response.VSCode === true) {
+  const shouldOpenVSCode = await getInputYesNo(
+    "Do you want to open your new project in VSCode now?",
+  );
+  if (shouldOpenVSCode) {
     openVSCode(projectPath, VSCodeCommand);
   }
 }

package/src/commands/monitor/modDirectorySyncer/modDirectorySyncer.ts

@@ -1,5 +1,3 @@
-/* eslint-disable import/no-unused-modules */
-
 import path from "path";
 import syncDirectory from "sync-directory";
 import { FILE_SYNCED_MESSAGE, MAIN_LUA } from "../../../constants";

package/src/commands/monitor/monitor.ts

@@ -37,7 +37,7 @@ export function monitor(argv: Record<string, unknown>, config: Config): void {
   spawnModDirectorySyncer(config);
 
   // Subprocess #3 - tstl --watch (to automatically convert TypeScript to Lua)
-  spawnTSTLWatcher();
+  spawnTSTLWatcher(argv);
 
   // Also, start constantly pinging the watcher mod
   setInterval(() => {
@@ -91,8 +91,17 @@ function spawnModDirectorySyncer(config: Config) {
   });
 }
 
-function spawnTSTLWatcher() {
+function spawnTSTLWatcher(argv: Record<string, unknown>) {
   const processDescription = "tstl";
+  const crashDebug = argv.crashDebug === true;
+
+  const tstlArgs = ["--watch", "--preserveWatchOutput"];
+  if (crashDebug) {
+    tstlArgs.push("--luaPlugins");
+    tstlArgs.push(
+      '\'{ "name": "./node_modules/isaacscript/src/plugins/addCrashDebugStatements.ts" }\'',
+    );
+  }
 
   let tstl: ChildProcessWithoutNullStreams;
   if (runningFromLocalPath()) {
@@ -105,12 +114,12 @@ function spawnTSTLWatcher() {
       "dist",
       "tstl.js",
     );
-    tstl = spawn("node", [tstlPath, "--watch", "--preserveWatchOutput"], {
+    tstl = spawn("node", [tstlPath, ...tstlArgs], {
       shell: true,
       cwd: CWD,
     });
   } else {
-    tstl = spawn("npx", ["tstl", "--watch", "--preserveWatchOutput"], {
+    tstl = spawn("npx", ["tstl", ...tstlArgs], {
       shell: true,
     });
   }

package/src/commands/monitor/saveDatWriter/saveDatWriter.ts

@@ -1,5 +1,3 @@
-/* eslint-disable import/no-unused-modules */
-
 import chalk from "chalk";
 import * as JSONC from "jsonc-parser";
 import path from "path";

package/src/commands/publish/publish.ts

@@ -24,9 +24,9 @@ const UPDATE_SCRIPT_NAME = "update.sh";
 
 export function publish(argv: Record<string, unknown>, config: Config): void {
   const skipVersionIncrement = argv.skip === true;
-  const setVersion = argv.setversion as string | undefined;
-  const dryRun = argv.dryrun === true;
-  const onlyUpload = argv.onlyupload === true;
+  const setVersion = argv.setVersion as string | undefined;
+  const dryRun = argv.dryRun === true;
+  const onlyUpload = argv.onlyUpload === true;
 
   const modTargetDirectoryName = getModTargetDirectoryName(config);
   const modTargetPath = path.join(config.modsDirectory, modTargetDirectoryName);
@@ -96,7 +96,7 @@ function updateDeps() {
     );
   }
 
-  execShell(UPDATE_SCRIPT_NAME);
+  execShell("bash", [UPDATE_SCRIPT_NAME]);
 }
 
 function getVersionFromPackageJSON() {

package/src/constants.ts

@@ -1,10 +1,15 @@
+import os from "os";
 import path from "path";
 
 const cwd = process.cwd();
 
+// https://stackoverflow.com/questions/9080085/node-js-find-home-directory-in-platform-agnostic-way
+const homeDir = os.homedir();
+
 // Miscellaneous
 export const CURRENT_DIRECTORY_NAME = path.basename(cwd);
 export const CWD = cwd;
+export const HOME_DIR = homeDir;
 export const FILE_SYNCED_MESSAGE = "File synced:";
 
 // isaacscript

package/src/main.ts

@@ -15,6 +15,7 @@ import { publish } from "./commands/publish/publish";
 import * as configFile from "./configFile";
 import { CWD } from "./constants";
 import { parseArgs } from "./parseArgs";
+import { promptInit } from "./prompt";
 import { Command, DEFAULT_COMMAND } from "./types/Command";
 import { Config } from "./types/Config";
 import { ensureAllCases, error } from "./util";
@@ -28,6 +29,7 @@ main().catch((err) => {
 
 async function main(): Promise<void> {
   sourceMapSupport.install();
+  promptInit();
   validateNodeVersion();
   validateOS();
 

package/src/monkeyPatch.ts

@@ -39,13 +39,14 @@ export function monkeyPatchMainLua(targetModDirectory: string): void {
   const mainLuaPath = path.join(targetModDirectory, MAIN_LUA);
   let mainLua = file.read(mainLuaPath);
 
-  mainLua = patchInformationalHeader(mainLua);
+  // mainLua = patchInformationalHeader(mainLua);
   mainLua = patchGlobalObjects(mainLua);
 
   file.write(mainLuaPath, mainLua);
 }
 
 // Add an informational header for people who happen to be browsing the Lua output
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
 function patchInformationalHeader(mainLua: string) {
   return INFORMATIONAL_HEADER + mainLua;
 }

package/src/parseArgs.ts

@@ -6,27 +6,28 @@ export function parseArgs() {
     .usage("usage: isaacscript <command> [options]")
     .scriptName("isaacscript")
 
-    .command(
-      "monitor",
-      "Monitor a project for changes. (default)",
-      (builder) => {
-        return builder
-          .option("mods-directory", {
-            alias: "m",
-            type: "string",
-            description: "The directory where Isaac mods live on your system",
-          })
-          .option("save-slot", {
-            alias: "s",
-            type: "number",
-            choices: [1, 2, 3],
-            description: "The save slot in-game that you use",
-          });
-      },
+    .command("monitor", "Monitor a project for changes. (default)", (builder) =>
+      builder
+        .option("mods-directory", {
+          alias: "m",
+          type: "string",
+          description: "The directory where Isaac mods live on your system",
+        })
+        .option("save-slot", {
+          alias: "s",
+          type: "number",
+          choices: [1, 2, 3],
+          description: "The save slot in-game that you use",
+        })
+        .option("crash-debug", {
+          alias: "c",
+          type: "boolean",
+          description: "Enable crash debugging",
+        }),
     )
 
-    .command("init [name]", "Initialize a new IsaacScript mod.", (builder) => {
-      return builder
+    .command("init [name]", "Initialize a new IsaacScript mod.", (builder) =>
+      builder
         .option("use-current-dir", {
           alias: "u",
           type: "boolean",
@@ -47,39 +48,44 @@ export function parseArgs() {
           alias: "c",
           type: "boolean",
           description: "Open the project in VSCode after initialization",
-        });
-    })
+        })
+        .option("skip-npm-install", {
+          alias: "i",
+          type: "boolean",
+          description:
+            'Don\'t automatically run "npm install" after initializing the project',
+        }),
+    )
 
     .command("copy", "Only compile & copy the mod.")
 
     .command(
       "publish",
       "Bump the version & automatically publish the new files using the steamcmd tool.",
-      (builder) => {
-        return builder
+      (builder) =>
+        builder
           .option("skip", {
             alias: "s",
             type: "boolean",
             description: "skip incrementing the version number",
           })
-          .option("setversion", {
+          .option("set-version", {
             alias: "t",
             type: "string",
             description:
               "specify the version number instead of incrementing it",
           })
-          .option("dryrun", {
+          .option("dry-run", {
             alias: "d",
             type: "boolean",
             description: "skip invoking steamcmd",
           })
-          .option("onlyupload", {
+          .option("only-upload", {
             alias: "u",
             type: "boolean",
             description:
               "only upload the mod to the Steam Workshop (without doing anything else)",
-          });
-      },
+          }),
     )
 
     .alias("h", "help") // By default, only "--help" is enabled