isaacscript 1.2.28 → 1.2.31

package/src/commands/init/getProjectPath.ts

@@ -2,7 +2,7 @@ import chalk from "chalk";
 import path from "path";
 import { CURRENT_DIRECTORY_NAME, CWD } from "../../constants";
 import { getInputString, getInputYesNo } from "../../prompt";
-import { hasWhiteSpace } from "../../utils";
+import { error, hasWhiteSpace, isKebabCase } from "../../utils";
 
 // From: https://gist.github.com/doctaphred/d01d05291546186941e1b7ddc02034d3
 const ILLEGAL_CHARACTERS_FOR_WINDOWS_FILENAMES = [
@@ -19,11 +19,13 @@ const ILLEGAL_CHARACTERS_FOR_WINDOWS_FILENAMES = [
 
 export async function getProjectPath(
   argv: Record<string, unknown>,
+  useCurrentDir: boolean,
+  yes: boolean,
 ): Promise<[string, boolean]> {
   let projectName = getProjectNameFromCommandLineArgument(argv);
   let projectPath: string;
   let createNewDir: boolean;
-  if (argv.useCurrentDir !== undefined) {
+  if (useCurrentDir) {
     // The "--use-current-dir" command-line flag was specified,
     // so there is no need to prompt the user
     projectName = CURRENT_DIRECTORY_NAME;
@@ -33,14 +35,18 @@ export async function getProjectPath(
     // The project name was specified on the command-line
     projectPath = path.join(CWD, 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();
   }
 
-  if (!validateProjectName(projectName)) {
-    process.exit(1);
-  }
+  validateProjectName(projectName);
 
   console.log(`Using a project name of: ${chalk.green(projectName)}`);
   return [projectPath, createNewDir];
@@ -74,27 +80,28 @@ async function getNewProjectName(): Promise<[string, string, boolean]> {
 
 function validateProjectName(projectName: string) {
   if (projectName === "") {
-    console.error("Error: You cannot have a blank project name.");
-    return false;
+    error("Error: You cannot have a blank project name.");
   }
 
   if (process.platform === "win32") {
     for (const character of ILLEGAL_CHARACTERS_FOR_WINDOWS_FILENAMES) {
       if (projectName.includes(character)) {
-        console.error(
+        error(
           `Error: The "${character}" character is not allowed in a Windows file name.`,
         );
-        return false;
       }
     }
   }
 
   if (hasWhiteSpace(projectName)) {
-    console.error(
+    error(
       'Error: The project name has whitespace in it, which is not allowed. Use kebab-case for your project name. (e.g. "green-candle")',
     );
-    return false;
   }
 
-  return true;
+  if (!isKebabCase(projectName)) {
+    error(
+      "Error: 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.",
+    );
+  }
 }

package/src/commands/init/git.ts

@@ -14,6 +14,7 @@ const REQUIRED_GIT_MINOR_VERSION = 30;
 
 export async function promptGitHubRepoOrGitRemoteURL(
   projectName: string,
+  yes: boolean,
   verbose: boolean,
 ): Promise<string | undefined> {
   // We do not need to prompt the user if they do not have Git installed
@@ -26,7 +27,7 @@ export async function promptGitHubRepoOrGitRemoteURL(
 
   validateNewGitVersion(verbose);
 
-  const gitHubUsername = getGitHubUsername();
+  const gitHubUsername = getGitHubUsername(verbose);
   if (gitHubUsername !== undefined) {
     const [exitStatus] = execShell(
       "gh",
@@ -42,6 +43,14 @@ export async function promptGitHubRepoOrGitRemoteURL(
         `Detected an existing GitHub repository at: ${chalk.green(url)}`,
       );
       const guessedRemoteURL = getGitRemoteURL(projectName, gitHubUsername);
+
+      if (yes) {
+        console.log(
+          `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,
@@ -52,23 +61,29 @@ export async function promptGitHubRepoOrGitRemoteURL(
       }
 
       // Assume that since they do not want to connect this project to the existing GitHub
-      // repository, they do not want to initialize Git either
+      // repository, they do not want to initialize a remote Git URL at all
       return undefined;
     }
 
+    if (yes) {
+      execShell("gh", ["repo", "create", projectName, "--public"]);
+      console.log(`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) {
-      execShell("gh", ["repo", "create", "poop", "--public"]);
+      execShell("gh", ["repo", "create", projectName, "--public"]);
       console.log("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 Git either
+    // initialize a remote Git URL at all
     return undefined;
   }
 
@@ -116,7 +131,7 @@ function validateNewGitVersion(verbose: boolean) {
   process.exit(1);
 }
 
-function getGitHubUsername() {
+function getGitHubUsername(verbose: boolean) {
   // If the GitHub CLI is installed, we can derive the user's GitHub username
   if (
     !commandExists.sync("gh") ||
@@ -131,11 +146,11 @@ function getGitHubUsername() {
     "GitHub CLI",
     "hosts.yml",
   );
-  if (!file.exists(githubCLIHostsPath)) {
+  if (!file.exists(githubCLIHostsPath, verbose)) {
     return undefined;
   }
 
-  const configYAMLRaw = file.read(githubCLIHostsPath);
+  const configYAMLRaw = file.read(githubCLIHostsPath, verbose);
   const configYAML = yaml.parse(configYAMLRaw) as GitHubCLIHostsYAML;
 
   const githubCom = configYAML["github.com"];
@@ -144,7 +159,7 @@ function getGitHubUsername() {
   }
 
   const { user } = githubCom;
-  if (user === "") {
+  if (user === undefined || user === "") {
     return undefined;
   }
 
@@ -160,21 +175,12 @@ export function initGitRepository(
   gitRemoteURL: string | undefined,
   verbose: boolean,
 ): void {
-  // We already checked to see if the "git" command is installed earlier on in the initialization
-  // process
-  if (gitRemoteURL === undefined) {
+  if (!commandExists.sync("git")) {
     return;
   }
 
   execShell("git", ["init"], verbose, false, projectPath);
   execShell("git", ["branch", "-M", "main"], verbose, false, projectPath);
-  execShell(
-    "git",
-    ["remote", "add", "origin", gitRemoteURL],
-    verbose,
-    false,
-    projectPath,
-  );
 
   if (isGitNameAndEmailConfigured(verbose)) {
     execShell("git", ["add", "--all"], verbose, false, projectPath);
@@ -186,6 +192,16 @@ export function initGitRepository(
       projectPath,
     );
   }
+
+  if (gitRemoteURL !== undefined) {
+    execShell(
+      "git",
+      ["remote", "add", "origin", gitRemoteURL],
+      verbose,
+      false,
+      projectPath,
+    );
+  }
 }
 
 function isGitNameAndEmailConfigured(verbose: boolean) {

package/src/commands/init/init.ts

@@ -14,23 +14,31 @@ import { promptSaveSlot } from "./promptSaveSlot";
 import { promptVSCode } from "./promptVSCode";
 
 export async function init(argv: Record<string, unknown>): Promise<void> {
-  const vscode = argv.vscode === true;
   const skipNPMInstall = argv.skipNpmInstall === true;
+  const useCurrentDir = argv.useCurrentDir === true;
   const verbose = argv.verbose === true;
+  const vscode = argv.vscode === true;
+  const yes = argv.yes === true;
 
   // Prompt the end-user for some information (and validate it as we go)
-  const [projectPath, createNewDir] = await getProjectPath(argv);
-  await checkIfProjectPathExists(projectPath, verbose);
-  const modsDirectory = await getModsDir(argv);
+  const [projectPath, createNewDir] = await getProjectPath(
+    argv,
+    useCurrentDir,
+    yes,
+  );
+  await checkIfProjectPathExists(projectPath, yes, verbose);
+  const modsDirectory = await getModsDir(argv, verbose);
   checkModSubdirectory(projectPath, modsDirectory);
   const projectName = path.basename(projectPath);
-  await checkModTargetDirectory(modsDirectory, projectName, verbose);
-  const saveSlot = await promptSaveSlot(argv);
+  await checkModTargetDirectory(modsDirectory, projectName, yes, verbose);
+  const saveSlot = await promptSaveSlot(argv, yes);
   const gitRemoteURL = await promptGitHubRepoOrGitRemoteURL(
     projectName,
+    yes,
     verbose,
   );
 
+  // Now that we have asked the user all of the questions we need, we can create the project
   createMod(
     projectName,
     projectPath,

package/src/commands/init/installVSCodeExtensions.ts

@@ -10,7 +10,7 @@ export function installVSCodeExtensions(
   VSCodeCommand: string,
   verbose: boolean,
 ): void {
-  const extensions = getExtensionsFromJSON(projectPath);
+  const extensions = getExtensionsFromJSON(projectPath, verbose);
   for (const extensionName of extensions) {
     execShell(VSCodeCommand, ["--install-extension", extensionName], verbose);
   }
@@ -20,18 +20,18 @@ interface ExtensionsJSON {
   recommendations: string[];
 }
 
-function getExtensionsFromJSON(projectPath: string) {
+function getExtensionsFromJSON(projectPath: string, verbose: boolean) {
   const extensionsJSONPath = path.join(
     projectPath,
     ".vscode",
     "extensions.json",
   );
 
-  if (!file.exists(extensionsJSONPath)) {
+  if (!file.exists(extensionsJSONPath, verbose)) {
     return [];
   }
 
-  const extensionsJSONRaw = file.read(extensionsJSONPath);
+  const extensionsJSONRaw = file.read(extensionsJSONPath, verbose);
 
   let extensionsJSON: ExtensionsJSON;
   try {

package/src/commands/init/promptSaveSlot.ts

@@ -3,6 +3,7 @@ import { error } from "../../utils";
 
 export async function promptSaveSlot(
   argv: Record<string, unknown>,
+  yes: boolean,
 ): Promise<number> {
   if (argv.saveSlot !== undefined) {
     // They specified the "--save-slot" command-line flag,
@@ -10,6 +11,10 @@ export async function promptSaveSlot(
     return argv.saveSlot as number;
   }
 
+  if (yes) {
+    return 1;
+  }
+
   const saveSlot = await getInputInt(
     "In-game, will you test your mod on save slot 1, 2, or 3?",
   );

package/src/commands/monitor/copyWatcherMod.ts

@@ -12,11 +12,11 @@ export function copyWatcherMod(config: Config, verbose: boolean): void {
   // Check to see if this mod was disabled
   const watcherModPath = path.join(config.modsDirectory, WATCHER_MOD_NAME);
   const disableItPath = path.join(watcherModPath, DISABLE_IT_FILE);
-  const watcherModDisabled = file.exists(disableItPath);
+  const watcherModDisabled = file.exists(disableItPath, verbose);
 
   // Delete and re-copy the watcher mod every time IsaacScript starts
   // This ensures that it is always the latest version
-  if (file.exists(watcherModPath)) {
+  if (file.exists(watcherModPath, verbose)) {
     file.deleteFileOrDirectory(watcherModPath, verbose);
   }
 
@@ -45,7 +45,7 @@ function disableIsaacScriptWatcherAutomaticRestart(
   verbose: boolean,
 ) {
   const mainLuaPath = path.join(watcherModPath, MAIN_LUA);
-  const mainLua = file.read(mainLuaPath);
+  const mainLua = file.read(mainLuaPath, verbose);
 
   const modifiedMainLua = mainLua.replace(
     "local RESTART_GAME_ON_RECOMPILATION = true",

package/src/commands/monitor/getTSConfigInclude.ts

@@ -4,8 +4,8 @@ import { TSCONFIG_PATH } from "../../constants";
 import * as file from "../../file";
 import { error } from "../../utils";
 
-export function getTSConfigInclude(): string {
-  const tsConfigRaw = file.read(TSCONFIG_PATH);
+export function getTSConfigInclude(verbose: boolean): string {
+  const tsConfigRaw = file.read(TSCONFIG_PATH, verbose);
   let tsConfig: Record<string, string[]>;
   try {
     tsConfig = JSONC.parse(tsConfigRaw) as Record<string, string[]>;

package/src/commands/monitor/monitor.ts

@@ -29,7 +29,7 @@ export function monitor(argv: Record<string, unknown>, config: Config): void {
   }
 
   // Read the "tsconfig.json" file
-  const tsConfigInclude = getTSConfigInclude();
+  const tsConfigInclude = getTSConfigInclude(verbose);
   const resolvedIncludePath = path.resolve(CWD, tsConfigInclude);
   const modTargetDirectoryName = getModTargetDirectoryName(config);
   const modTargetPath = path.join(config.modsDirectory, modTargetDirectoryName);
@@ -40,7 +40,7 @@ export function monitor(argv: Record<string, unknown>, config: Config): void {
 
   // Delete and re-copy the mod every time IsaacScript starts
   // This ensures that it is always the latest version
-  if (file.exists(modTargetPath)) {
+  if (file.exists(modTargetPath, verbose)) {
     file.deleteFileOrDirectory(modTargetPath, true);
   }
 

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

@@ -7,14 +7,15 @@ import { ensureAllCases, error } from "../../../utils";
 import { SaveDatMessage, SaveDatMessageType } from "./types";
 
 const MAX_MESSAGES = 100;
+const VERBOSE = false;
 
 let saveDatPath: string;
 let saveDatFileName: string;
 
-init();
+init(VERBOSE);
 
-function init() {
-  const numArgs = 1;
+function init(verbose: boolean) {
+  const numArgs = 2;
   if (process.argv.length !== 2 + numArgs) {
     throw new Error(
       "The Save.dat writer process did not get the right amount of arguments.",
@@ -26,8 +27,8 @@ function init() {
 
   // Check to see if the data directory exists
   const watcherModDataPath = path.dirname(saveDatPath);
-  if (!file.exists(watcherModDataPath)) {
-    file.makeDir(watcherModDataPath, false);
+  if (!file.exists(watcherModDataPath, verbose)) {
+    file.makeDir(watcherModDataPath, verbose);
   }
 
   // Listen for messages from the parent process
@@ -37,7 +38,7 @@ function init() {
 }
 
 function onMessage(type: SaveDatMessageType, data: string, numRetries = 0) {
-  const saveDat = readSaveDatFromDisk();
+  const saveDat = readSaveDatFromDisk(VERBOSE);
   if (saveDat.length > MAX_MESSAGES) {
     // If IsaacScript is running and
     // 1) the game is not open
@@ -50,13 +51,13 @@ function onMessage(type: SaveDatMessageType, data: string, numRetries = 0) {
     return;
   }
   addMessageToSaveDat(type, saveDat, data); // Mutates saveDat
-  writeSaveDatToDisk(type, data, saveDat, numRetries);
+  writeSaveDatToDisk(type, data, saveDat, numRetries, VERBOSE);
 }
 
-function readSaveDatFromDisk() {
+function readSaveDatFromDisk(verbose: boolean) {
   let saveDat: SaveDatMessage[];
-  if (file.exists(saveDatPath)) {
-    const saveDatRaw = file.read(saveDatPath);
+  if (file.exists(saveDatPath, verbose)) {
+    const saveDatRaw = file.read(saveDatPath, verbose);
     try {
       saveDat = JSONC.parse(saveDatRaw) as SaveDatMessage[];
     } catch (err) {
@@ -111,11 +112,12 @@ function writeSaveDatToDisk(
   type: SaveDatMessageType,
   data: string,
   saveDat: SaveDatMessage[],
-  numRetries = 0,
+  numRetries: number,
+  verbose: boolean,
 ) {
   const saveDatRaw = JSON.stringify(saveDat, null, 2);
   try {
-    file.writeTry(saveDatPath, saveDatRaw);
+    file.writeTry(saveDatPath, saveDatRaw, verbose);
   } catch (err) {
     if (numRetries > 4) {
       console.error(

package/src/commands/monitor/touchWatcherSaveDatFiles.ts

@@ -9,12 +9,12 @@ export function touchWatcherSaveDatFiles(
 ): void {
   const modsDataPath = path.join(config.modsDirectory, "..", "data");
   const watcherModDataPath = path.join(modsDataPath, WATCHER_MOD_NAME);
-  if (!file.exists(watcherModDataPath)) {
+  if (!file.exists(watcherModDataPath, verbose)) {
     file.makeDir(watcherModDataPath, verbose);
   }
   const saveDatFileName = `save${config.saveSlot}.dat`;
   const saveDatPath = path.join(watcherModDataPath, saveDatFileName);
-  if (!file.exists(saveDatPath)) {
+  if (!file.exists(saveDatPath, verbose)) {
     file.touch(saveDatPath, verbose);
   }
 }

package/src/commands/publish/publish.ts

@@ -109,7 +109,7 @@ function startPublish(
   updateDeps(verbose);
 
   let version =
-    setVersion === undefined ? getVersionFromPackageJSON() : setVersion;
+    setVersion === undefined ? getVersionFromPackageJSON(verbose) : setVersion;
   if (!skipVersionIncrement && setVersion === undefined) {
     version = bumpVersionInPackageJSON(version, verbose);
   } else if (setVersion !== undefined) {
@@ -134,7 +134,7 @@ function startPublish(
 }
 
 function updateDeps(verbose: boolean) {
-  if (!file.exists(UPDATE_SCRIPT_NAME)) {
+  if (!file.exists(UPDATE_SCRIPT_NAME, verbose)) {
     error(
       `The "${UPDATE_SCRIPT_NAME}" script does not exist in the current working directory.`,
     );
@@ -143,8 +143,8 @@ function updateDeps(verbose: boolean) {
   execShell("bash", [UPDATE_SCRIPT_NAME], verbose);
 }
 
-function getVersionFromPackageJSON() {
-  if (!file.exists(PACKAGE_JSON_PATH)) {
+function getVersionFromPackageJSON(verbose: boolean) {
+  if (!file.exists(PACKAGE_JSON_PATH, verbose)) {
     error(
       chalk.red(
         `A "${PACKAGE_JSON_PATH}" was not found in the current directory.`,
@@ -152,7 +152,7 @@ function getVersionFromPackageJSON() {
     );
   }
 
-  const packageJSONRaw = file.read(PACKAGE_JSON_PATH);
+  const packageJSONRaw = file.read(PACKAGE_JSON_PATH, verbose);
   let packageJSON: Record<string, unknown>;
   try {
     packageJSON = JSON.parse(packageJSONRaw) as Record<string, unknown>;
@@ -204,7 +204,7 @@ function bumpVersionInPackageJSON(version: string, verbose: boolean): string {
   const incrementedPatchVersion = patchVersion + 1;
   const incrementedVersion = `${versionPrefix}${incrementedPatchVersion}`;
 
-  const packageJSON = file.read(PACKAGE_JSON_PATH);
+  const packageJSON = file.read(PACKAGE_JSON_PATH, verbose);
   const newPackageJSON = packageJSON.replace(
     /"version": ".+",/,
     `"version": "${incrementedVersion}",`,
@@ -219,7 +219,7 @@ function bumpVersionInPackageJSON(version: string, verbose: boolean): string {
 }
 
 function writeVersionInPackageJSON(version: string, verbose: boolean) {
-  const packageJSON = file.read(PACKAGE_JSON_PATH);
+  const packageJSON = file.read(PACKAGE_JSON_PATH, verbose);
   const newPackageJSON = packageJSON.replace(
     /"version": ".+",/,
     `"version": "${version}",`,
@@ -230,14 +230,14 @@ function writeVersionInPackageJSON(version: string, verbose: boolean) {
 }
 
 function writeVersionToConstantsTS(version: string, verbose: boolean) {
-  if (!file.exists(CONSTANTS_TS_PATH)) {
+  if (!file.exists(CONSTANTS_TS_PATH, verbose)) {
     console.log(
       'Skipping writing the version to "constants.ts" since it was not found.',
     );
     return;
   }
 
-  const constantsTS = file.read(CONSTANTS_TS_PATH);
+  const constantsTS = file.read(CONSTANTS_TS_PATH, verbose);
   const newConstantsTS = constantsTS.replace(
     /const VERSION = ".+"/,
     `const VERSION = "${version}"`,
@@ -248,7 +248,7 @@ function writeVersionToConstantsTS(version: string, verbose: boolean) {
 }
 
 function writeVersionToMetadataXML(version: string, verbose: boolean) {
-  const metadataXML = file.read(METADATA_XML_PATH);
+  const metadataXML = file.read(METADATA_XML_PATH, verbose);
   const newMetadataXML = metadataXML.replace(
     /<version>.+<\/version>/,
     `<version>${version}</version>`,
@@ -265,7 +265,7 @@ function writeVersionToVersionTXT(version: string, verbose: boolean) {
 }
 
 function runReleaseScriptPreCopy(verbose: boolean) {
-  if (!file.exists(PUBLISH_PRE_COPY_PY_PATH)) {
+  if (!file.exists(PUBLISH_PRE_COPY_PY_PATH, verbose)) {
     return;
   }
 
@@ -278,7 +278,7 @@ function runReleaseScriptPreCopy(verbose: boolean) {
 }
 
 function runReleaseScriptPostCopy(verbose: boolean) {
-  if (!file.exists(PUBLISH_POST_COPY_PY_PATH)) {
+  if (!file.exists(PUBLISH_POST_COPY_PY_PATH, verbose)) {
     return;
   }
 
@@ -292,11 +292,11 @@ function runReleaseScriptPostCopy(verbose: boolean) {
 
 function purgeRoomXMLs(modTargetPath: string, verbose: boolean) {
   const roomsPath = path.join(modTargetPath, "resources", "rooms");
-  if (!file.exists(roomsPath) || !file.isDir(roomsPath)) {
+  if (!file.exists(roomsPath, verbose) || !file.isDir(roomsPath, verbose)) {
     return;
   }
 
-  const roomFileList = file.getDirList(roomsPath);
+  const roomFileList = file.getDirList(roomsPath, verbose);
   roomFileList.forEach((fileName: string) => {
     if (path.extname(fileName) === ".xml") {
       const roomFilePath = path.join(roomsPath, fileName);
@@ -327,7 +327,7 @@ function runSteamCmd(
   steamCmdPath: string,
   verbose: boolean,
 ) {
-  if (!file.exists(steamCmdPath)) {
+  if (!file.exists(steamCmdPath, verbose)) {
     error(
       chalk.red(
         `The path provided for "steamCmdPath" is "${steamCmdPath}", but that does not exist.`,
@@ -336,7 +336,7 @@ function runSteamCmd(
   }
 
   const metadataVDFPath = path.join(modTargetPath, "metadata.vdf");
-  if (!file.exists(metadataVDFPath)) {
+  if (!file.exists(metadataVDFPath, verbose)) {
     console.error(
       chalk.red(
         `A "metadata.vdf" file was not found in your mod directory. You must create this file in order for "steamcmd.exe" to work. Please see the ${PROJECT_NAME} docs:`,

package/src/configFile.ts

@@ -10,27 +10,28 @@ import { error } from "./utils";
 
 export async function get(argv: Record<string, unknown>): Promise<Config> {
   const verbose = argv.verbose === true;
+  const yes = argv.yes === true;
 
-  const existingConfig = readExistingConfig();
+  const existingConfig = readExistingConfig(verbose);
   if (existingConfig !== undefined) {
     return existingConfig;
   }
 
   // No config file exists, so prompt the user for some information and create one
-  const modsDirectory = await getModsDir(argv);
-  const saveSlot = await promptSaveSlot(argv);
+  const modsDirectory = await getModsDir(argv, verbose);
+  const saveSlot = await promptSaveSlot(argv, yes);
   const config = createObject(modsDirectory, saveSlot);
   createFile(CWD, config, verbose);
 
   return config;
 }
 
-function readExistingConfig(): Config | undefined {
-  if (!file.exists(CONFIG_FILE_PATH)) {
+function readExistingConfig(verbose: boolean): Config | undefined {
+  if (!file.exists(CONFIG_FILE_PATH, verbose)) {
     return undefined;
   }
 
-  const configRaw = file.read(CONFIG_FILE_PATH);
+  const configRaw = file.read(CONFIG_FILE_PATH, verbose);
   let config: Config;
   try {
     config = JSONC.parse(configRaw) as Config;

package/src/exec.ts

@@ -3,7 +3,7 @@ import { execSync, spawnSync, SpawnSyncReturns } from "child_process";
 import { CWD } from "./constants";
 import { error } from "./utils";
 
-export function execExe(path: string, verbose = false, cwd = CWD): string {
+export function execExe(path: string, verbose: boolean, cwd = CWD): string {
   if (verbose) {
     console.log(`Executing binary: ${path}`);
   }
@@ -103,9 +103,7 @@ export function execShell(
 
   const exitStatus = spawnSyncReturns.status;
   if (exitStatus === null) {
-    error(
-      `Failed to get the return status of th command: ${commandDescription}`,
-    );
+    error(`Failed to get the return status of command: ${commandDescription}`);
   }
 
   const stdout = spawnSyncReturns.output.join("\n").trim();