@cluerise/tools 3.0.1 → 4.0.1

package/dist/scripts/init/main.js

@@ -1,29 +1,225 @@
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var _packageName, _CoreConfig_static, rootDirectory_get, _command, _ConsoleStatusLogger_static, createResultMessage_fn, _origins, _names, _data, _PackageJson_instances, parseGitRepository_fn, _configDirectory, _configPackage, _ToolInitializer_instances, initCommitlint_fn, initEditorConfig_fn, initESLint_fn, initGit_fn, initLintStaged_fn, initNvm_fn, initPnpm_fn, initPrettier_fn, getReleaseConfigParams_fn, initRelease_fn, initTypeScript_fn, initVSCode_fn, _options, _eslint, _eslintFixer, _FileLinter_static, preparePrettierLintResult_fn, _FileLinter_instances, prettierLint_fn, prepareESLintLintResult_fn, eslintLint_fn;
 import { z, ZodError } from "zod";
-import FileSystem from "fs/promises";
-import Path from "path";
-import ChildProcess from "child_process";
+import Path from "node:path";
+import FileSystem from "node:fs/promises";
+import OS from "node:os";
+import Process from "node:process";
+import "@commitlint/load";
+import ChildProcess from "node:child_process";
 import { ESLint } from "eslint";
 import { glob } from "glob";
 import * as Prettier from "prettier";
-import "@commitlint/load";
-class ParseGitRepositoryError extends Error {
+class CoreConfig {
+  /**
+   * Determines if the application is running in production mode.
+   *
+   * This is based on the environment variable `import.meta.env.PROD`.
+   *
+   * @returns True if in production mode, false otherwise.
+   */
+  static get isProd() {
+    return true;
+  }
+  /**
+   * Returns the package and its path to the configuration files.
+   *
+   * This is used to load configurations from the package in production mode.
+   *
+   * @returns The path to the configuration files in the package.
+   */
+  static get configPackage() {
+    return `${__privateGet(this, _packageName)}/dist/configs`;
+  }
+  /**
+   * Returns the directory where configuration files are stored.
+   *
+   * In production mode, this points to the `dist/configs` directory within the package.
+   * In development mode, it points to the root directory.
+   *
+   * @returns The path to the configuration directory.
+   */
+  static get configDirectory() {
+    return this.isProd ? `${__privateGet(this, _CoreConfig_static, rootDirectory_get)}/dist/configs` : __privateGet(this, _CoreConfig_static, rootDirectory_get);
+  }
 }
+_packageName = new WeakMap();
+_CoreConfig_static = new WeakSet();
+rootDirectory_get = function() {
+  return this.isProd ? `./node_modules/${__privateGet(this, _packageName)}` : ".";
+};
+__privateAdd(CoreConfig, _CoreConfig_static);
+__privateAdd(CoreConfig, _packageName, "@cluerise/tools");
+const _ConsoleStatusLogger = class _ConsoleStatusLogger {
+  constructor(command) {
+    __privateAdd(this, _command);
+    __privateSet(this, _command, command);
+  }
+  /**
+   * Begins logging for a command with the specified argument.
+   *
+   * @param argument - The argument for the command.
+   *
+   * @example
+   * const logger = new ConsoleStatusLogger('Linting');
+   * logger.begin('src/index.ts'); // Logs: "Linting src/index.ts..."
+   */
+  begin(argument) {
+    console.info(`${__privateGet(this, _command)} ${argument}...`);
+  }
+  /**
+   * Ends logging for a command with the specified argument and exit code.
+   *
+   * @param argument - The argument for the command.
+   * @param exitCode - The exit code of the command execution. If null, it indicates completion without an error.
+   *
+   * @example
+   * const logger = new ConsoleStatusLogger('Linting');
+   * logger.end('src/index.ts'); // Logs: "Linting src/index.ts... Done"
+   * logger.end('src/index.ts', 0); // Logs: "Linting src/index.ts... OK"
+   * logger.end('src/index.ts', 1); // Logs: "Linting src/index.ts... Failed"
+   */
+  end(argument, exitCode = null) {
+    var _a;
+    console.info(`${__privateGet(this, _command)} ${argument}... ${__privateMethod(_a = _ConsoleStatusLogger, _ConsoleStatusLogger_static, createResultMessage_fn).call(_a, exitCode)}`);
+  }
+};
+_command = new WeakMap();
+_ConsoleStatusLogger_static = new WeakSet();
+createResultMessage_fn = function(exitCode) {
+  if (exitCode === null) {
+    return "Done";
+  }
+  return exitCode === 0 ? "OK" : "Failed";
+};
+__privateAdd(_ConsoleStatusLogger, _ConsoleStatusLogger_static);
+let ConsoleStatusLogger = _ConsoleStatusLogger;
 const gitProviderOrigins = {
   github: "https://github.com"
 };
-const gitProviderNames = Object.keys(gitProviderOrigins);
-const isGitProviderName = (name) => gitProviderNames.includes(name);
-const parseRepositoryUrl = (urlString) => {
+const _GitProvider = class _GitProvider {
+  /**
+   * Checks if the provided name is a valid Git provider name.
+   *
+   * @param name - The name of the Git provider to validate.
+   * @returns True if the name is valid, false otherwise.
+   */
+  static isValidName(name) {
+    return __privateGet(this, _names).includes(name);
+  }
+  /**
+   * Returns a Git provider origin.
+   *
+   * @param name - The name of the Git provider.
+   * @returns The origin URL of the Git provider.
+   */
+  static getOrigin(name) {
+    return __privateGet(this, _origins)[name];
+  }
+};
+_origins = new WeakMap();
+_names = new WeakMap();
+__privateAdd(_GitProvider, _origins, gitProviderOrigins);
+__privateAdd(_GitProvider, _names, Object.keys(__privateGet(_GitProvider, _origins)));
+let GitProvider = _GitProvider;
+const enginesSchema = z.object({
+  node: z.string()
+});
+const repositoryObjectSchema = z.object({
+  type: z.string(),
+  url: z.string(),
+  directory: z.ostring()
+});
+const repositorySchema = z.union([z.string(), repositoryObjectSchema]);
+const packageJsonDataSchema = z.object({
+  name: z.string(),
+  version: z.string(),
+  description: z.string(),
+  engines: enginesSchema.optional(),
+  repository: repositorySchema.optional()
+});
+const _PackageJson = class _PackageJson {
+  constructor(data) {
+    __privateAdd(this, _PackageJson_instances);
+    __privateAdd(this, _data);
+    __privateSet(this, _data, data);
+  }
+  static async init() {
+    const content = await FileSystem.readFile("package.json", { encoding: "utf8" });
+    const data = JsonUtils.parse(content);
+    const parseResult = packageJsonDataSchema.safeParse(data);
+    if (!parseResult.success) {
+      throw new Error("Invalid package.json", {
+        cause: parseResult.error
+      });
+    }
+    return new _PackageJson(parseResult.data);
+  }
+  /**
+   * Returns the required engines.
+   */
+  get engines() {
+    return __privateGet(this, _data).engines;
+  }
+  /**
+   * Sets the required engines.
+   *
+   * @param engines - The engines to set.
+   */
+  set engines(engines) {
+    __privateGet(this, _data).engines = engines;
+  }
+  /**
+   * Returns the repository information.
+   */
+  get repository() {
+    return __privateGet(this, _data).repository;
+  }
+  /**
+   * Parses the repository information from package.json.
+   *
+   * @returns The parsed GitRepository or null if no repository is defined.
+   */
+  parseGitRepository() {
+    if (!this.repository) {
+      return null;
+    }
+    if (typeof this.repository === "string") {
+      return __privateMethod(this, _PackageJson_instances, parseGitRepository_fn).call(this, this.repository);
+    }
+    return __privateMethod(this, _PackageJson_instances, parseGitRepository_fn).call(this, this.repository.url);
+  }
+  /**
+   * Saves the package.json file with the current data.
+   */
+  async save() {
+    const content = JsonUtils.prettify(__privateGet(this, _data)) + "\n";
+    await FileSystem.writeFile("package.json", content, { encoding: "utf8" });
+  }
+};
+_data = new WeakMap();
+_PackageJson_instances = new WeakSet();
+parseGitRepository_fn = function(urlString) {
+  if (!urlString) {
+    return null;
+  }
   const urlValue = urlString.includes(":") ? urlString : `https://${urlString}`;
   const url = new URL(urlValue);
   const scheme = url.protocol.slice(0, -1);
-  if (isGitProviderName(scheme)) {
+  if (GitProvider.isValidName(scheme)) {
     const [owner, repositoryName] = url.pathname.split("/");
     if (!owner || !repositoryName) {
-      throw new ParseGitRepositoryError("Unknown owner or repositoryName");
+      throw new Error("Unknown owner or repositoryName");
     }
     return {
-      origin: gitProviderOrigins[scheme],
+      origin: GitProvider.getOrigin(scheme),
       owner,
       repositoryName
     };
@@ -31,7 +227,7 @@ const parseRepositoryUrl = (urlString) => {
   if (scheme === "https") {
     const [, owner, repositoryName] = url.pathname.split("/");
     if (!owner || !repositoryName) {
-      throw new ParseGitRepositoryError("Unknown owner or repositoryName");
+      throw new Error("Unknown owner or repositoryName");
     }
     return {
       origin: url.origin,
@@ -39,313 +235,350 @@ const parseRepositoryUrl = (urlString) => {
       repositoryName: repositoryName.endsWith(".git") ? repositoryName.slice(0, -4) : repositoryName
     };
   }
-  throw new ParseGitRepositoryError("Unsupported repository URL");
-};
-const parsePackageJsonRepository = (repository) => {
-  if (typeof repository === "string") {
-    return parseRepositoryUrl(repository);
-  }
-  return parseRepositoryUrl(repository.url);
-};
-const enginesSchema = z.object({
-  node: z.string()
-});
-const repositoryObjectSchema = z.object({
-  type: z.string(),
-  url: z.string(),
-  directory: z.ostring()
-});
-const repositorySchema = z.union([z.string(), repositoryObjectSchema]);
-const packageJsonSchema = z.object({
-  name: z.string(),
-  version: z.string(),
-  description: z.string(),
-  engines: enginesSchema.optional(),
-  repository: repositorySchema.optional()
-});
-const readPackageJson = async () => {
-  const packageJsonData = await FileSystem.readFile("package.json", { encoding: "utf8" });
-  const packageJson = JSON.parse(packageJsonData);
-  const parseResult = packageJsonSchema.safeParse(packageJson);
-  if (!parseResult.success) {
-    throw parseResult.error;
-  }
-  return packageJson;
-};
-const CoreCommands = {
-  readPackageJson,
-  parsePackageJsonRepository
+  throw new Error("Unsupported repository URL");
 };
+let PackageJson = _PackageJson;
 const runMain = (main2) => {
-  main2(process.argv.slice(2)).then((exitCode) => {
+  Promise.resolve().then(() => main2(process.argv.slice(2))).then((exitCode) => {
     process.exit(exitCode);
   }).catch((error) => {
-    console.error(error);
+    console.error("Error:", error);
     process.exit(1);
   });
 };
-const createResultMessage = (exitCode) => {
-  if (exitCode === null) {
-    return "Done";
+class FileUtils {
+  static async createFile(path, content, options = {}) {
+    const absolutePath = Path.resolve(Process.cwd(), path);
+    const { trailingNewline = true } = options;
+    const fileContent = trailingNewline && !content.endsWith(OS.EOL) ? `${content}${OS.EOL}` : content;
+    await FileSystem.mkdir(Path.dirname(absolutePath), { recursive: true });
+    return FileSystem.writeFile(absolutePath, fileContent);
   }
-  return exitCode === 0 ? "OK" : "Failed";
-};
-const createStatusConsole = (command) => ({
-  printBegin: (arg) => console.info(`${command} ${arg}...`),
-  printEnd: (arg, exitCode = null) => console.info(`${command} ${arg}... ${createResultMessage(exitCode)}`)
-});
-const packageName = "@cluerise/tools";
-const rootAppDirectory = `./node_modules/${packageName}`;
-const toolsConfigPackage = `${packageName}/dist/configs`;
-const toolsConfigDirectory = `${rootAppDirectory}/dist/configs`;
-const AppConfig = {
-  toolsConfigPackage,
-  toolsConfigDirectory
-};
-const copyFile = async (sourceDirectory, filePath, destinationFilePath) => {
-  const sourcePath = Path.resolve(sourceDirectory, filePath);
-  const destinationPath = Path.resolve(process.cwd(), destinationFilePath ?? filePath);
-  await FileSystem.mkdir(Path.dirname(destinationPath), { recursive: true });
-  return FileSystem.copyFile(sourcePath, destinationPath);
-};
-const createFile = async (path, content) => {
-  const destinationPath = Path.resolve(process.cwd(), path);
-  await FileSystem.mkdir(Path.dirname(destinationPath), { recursive: true });
-  return FileSystem.writeFile(destinationPath, content);
-};
-const ConfigCommands = {
-  copyFile,
-  createFile
-};
-const commitlintConfigName = "commitlint.config";
-const commitlintConfigPath = `${commitlintConfigName}.ts`;
-const initCommitlint = async ({ configPackage }) => {
-  const configContent = `export { default } from '${configPackage}/${commitlintConfigName}';
+  static async copyFile(sourceDirectory, filePath, destinationFilePath) {
+    const sourcePath = Path.resolve(sourceDirectory, filePath);
+    const destinationPath = Path.resolve(Process.cwd(), destinationFilePath ?? filePath);
+    const sourceStat = await FileSystem.stat(sourcePath);
+    await FileSystem.mkdir(Path.dirname(destinationPath), { recursive: true });
+    return FileSystem.copyFile(sourcePath, destinationPath, sourceStat.mode);
+  }
+}
+class JsonUtils {
+  static stringify(value) {
+    return JSON.stringify(value);
+  }
+  static prettify(value) {
+    return JSON.stringify(value, null, 2);
+  }
+  static parse(value) {
+    return JSON.parse(value);
+  }
+}
+const toolNameSchema = z.union([
+  z.literal("commitlint"),
+  z.literal("editorconfig"),
+  z.literal("eslint"),
+  z.literal("git"),
+  z.literal("lint-staged"),
+  z.literal("nvm"),
+  z.literal("pnpm"),
+  z.literal("prettier"),
+  z.literal("release"),
+  z.literal("typescript"),
+  z.literal("vscode")
+]);
+class ToolInitializer {
+  constructor(configDirectory, configPackage) {
+    __privateAdd(this, _ToolInitializer_instances);
+    __privateAdd(this, _configDirectory);
+    __privateAdd(this, _configPackage);
+    __privateSet(this, _configDirectory, configDirectory);
+    __privateSet(this, _configPackage, configPackage);
+  }
+  /**
+   * Returns the names of all available tools.
+   *
+   * @returns An array of tool names.
+   */
+  get toolNames() {
+    return toolNameSchema.options.map((option) => option.value);
+  }
+  /**
+   * Initializes the specified tool.
+   *
+   * @param toolName - The name of the tool to initialize.
+   * @returns A promise that resolves when the tool is initialized.
+   */
+  async initTool(toolName) {
+    switch (toolName) {
+      case "commitlint":
+        return __privateMethod(this, _ToolInitializer_instances, initCommitlint_fn).call(this);
+      case "editorconfig":
+        return __privateMethod(this, _ToolInitializer_instances, initEditorConfig_fn).call(this);
+      case "eslint":
+        return __privateMethod(this, _ToolInitializer_instances, initESLint_fn).call(this);
+      case "git":
+        return __privateMethod(this, _ToolInitializer_instances, initGit_fn).call(this);
+      case "lint-staged":
+        return __privateMethod(this, _ToolInitializer_instances, initLintStaged_fn).call(this);
+      case "nvm":
+        return __privateMethod(this, _ToolInitializer_instances, initNvm_fn).call(this);
+      case "pnpm":
+        return __privateMethod(this, _ToolInitializer_instances, initPnpm_fn).call(this);
+      case "prettier":
+        return __privateMethod(this, _ToolInitializer_instances, initPrettier_fn).call(this);
+      case "release":
+        return __privateMethod(this, _ToolInitializer_instances, initRelease_fn).call(this);
+      case "typescript":
+        return __privateMethod(this, _ToolInitializer_instances, initTypeScript_fn).call(this);
+      case "vscode":
+        return __privateMethod(this, _ToolInitializer_instances, initVSCode_fn).call(this);
+      default: {
+        const unhandledToolName = toolName;
+        throw new Error(`Unknown tool name: ${unhandledToolName}`);
+      }
+    }
+  }
+}
+_configDirectory = new WeakMap();
+_configPackage = new WeakMap();
+_ToolInitializer_instances = new WeakSet();
+initCommitlint_fn = async function() {
+  const configName = "commitlint.config";
+  const configPath = `${configName}.ts`;
+  const configContent = `export { default } from '${__privateGet(this, _configPackage)}/${configName}';
 `;
-  await ConfigCommands.createFile(commitlintConfigPath, configContent);
+  await FileUtils.createFile(configPath, configContent);
 };
-const editorConfigPath = ".editorconfig";
-const initEditorConfig = async ({ configDirectory }) => {
-  await ConfigCommands.copyFile(configDirectory, editorConfigPath);
-};
-const eslintConfigPath = ".eslintrc.cjs";
-const eslintIgnorePath = ".eslintignore";
-const initEslint = async ({ configDirectory }) => {
-  const configContent = `module.exports = {
-  extends: '${configDirectory}/${eslintConfigPath}'
+initEditorConfig_fn = async function() {
+  await FileUtils.copyFile(__privateGet(this, _configDirectory), ".editorconfig");
 };
+initESLint_fn = async function() {
+  const configPath = "eslint.config.js";
+  const markdownConfigPath = "eslint-markdown.config.js";
+  const configContent = `export { default } from '${__privateGet(this, _configPackage)}/${configPath}';
 `;
-  await ConfigCommands.createFile(eslintConfigPath, configContent);
-  await ConfigCommands.copyFile(configDirectory, eslintIgnorePath);
-};
-const sourceGitignorePath = "_gitignore";
-const destinationGitignorePath = ".gitignore";
-const gitHookDirectory = "hooks";
-const gitHookPaths = [
-  Path.join(gitHookDirectory, "commit-msg"),
-  Path.join(gitHookDirectory, "post-commit"),
-  Path.join(gitHookDirectory, "pre-commit"),
-  Path.join(gitHookDirectory, "prepare-commit-msg")
-];
-const initGit = async ({ configDirectory }) => {
-  await ConfigCommands.copyFile(configDirectory, sourceGitignorePath, destinationGitignorePath);
-  await Promise.all(gitHookPaths.map((gitHookPath) => ConfigCommands.copyFile(configDirectory, gitHookPath)));
-};
-const lintStagedConfigPath = "lint-staged.config.js";
-const initLintStaged = async ({ configPackage }) => {
-  const configContent = `export { default } from '${configPackage}/${lintStagedConfigPath}';
+  const markdownConfigContent = `export { default } from '${__privateGet(this, _configPackage)}/${markdownConfigPath}';
+`;
+  await FileUtils.createFile(configPath, configContent);
+  await FileUtils.createFile(markdownConfigPath, markdownConfigContent);
+};
+initGit_fn = async function() {
+  const sourceGitignorePath = "_gitignore";
+  const destinationGitignorePath = ".gitignore";
+  await FileUtils.copyFile(__privateGet(this, _configDirectory), sourceGitignorePath, destinationGitignorePath);
+  const gitHookDirectory = "hooks";
+  const gitHookPaths = [
+    Path.join(gitHookDirectory, "commit-msg"),
+    Path.join(gitHookDirectory, "post-commit"),
+    Path.join(gitHookDirectory, "pre-commit"),
+    Path.join(gitHookDirectory, "prepare-commit-msg")
+  ];
+  await Promise.all(gitHookPaths.map((gitHookPath) => FileUtils.copyFile(__privateGet(this, _configDirectory), gitHookPath)));
+};
+initLintStaged_fn = async function() {
+  const configPath = "lint-staged.config.js";
+  const configContent = `export { default } from '${__privateGet(this, _configPackage)}/${configPath}';
 `;
-  await ConfigCommands.createFile(lintStagedConfigPath, configContent);
+  await FileUtils.createFile(configPath, configContent);
 };
-const sourceNpmrcPath = "_npmrc";
-const destinationNpmrcPath = ".npmrc";
-const initNpm = async ({ configDirectory }) => {
-  await ConfigCommands.copyFile(configDirectory, sourceNpmrcPath, destinationNpmrcPath);
+initNvm_fn = async function() {
+  await FileUtils.copyFile(__privateGet(this, _configDirectory), ".nvmrc");
 };
-const nvmrcPath = ".nvmrc";
-const initNvm = async ({ configDirectory }) => {
-  await ConfigCommands.copyFile(configDirectory, nvmrcPath);
+initPnpm_fn = async function() {
+  const workspacePath = "pnpm-workspace.yaml";
+  const workspaceContent = "engineStrict: true\n\npublicHoistPattern:\n  - '@commitlint/cli'\n  - eslint\n  - lint-staged\n  - prettier\n";
+  await FileUtils.createFile(workspacePath, workspaceContent);
 };
-const prettierConfigPath = "prettier.config.js";
-const initPrettier = async ({ configPackage }) => {
-  const configContent = `export { default } from '${configPackage}/${prettierConfigPath}';
+initPrettier_fn = async function() {
+  const configPath = "prettier.config.js";
+  const configContent = `export { default } from '${__privateGet(this, _configPackage)}/${configPath}';
 `;
-  await ConfigCommands.createFile(prettierConfigPath, configContent);
+  await FileUtils.createFile(configPath, configContent);
 };
-const releaseConfigPath = "release.config.js";
-const defaultReleaseConfigParams = {
-  host: "<host>",
-  owner: "<owner>",
-  repository: "<repository>"
-};
-const getReleaseConfigParams = async () => {
+getReleaseConfigParams_fn = async function() {
+  const defaultConfigParams = {
+    host: "<host>",
+    owner: "<owner>",
+    repository: "<repository>"
+  };
   try {
-    const { repository } = await CoreCommands.readPackageJson();
+    const packageJson = await PackageJson.init();
+    const repository = packageJson.parseGitRepository();
     if (!repository) {
-      return defaultReleaseConfigParams;
+      return defaultConfigParams;
     }
-    const { origin, owner, repositoryName } = CoreCommands.parsePackageJsonRepository(repository);
+    const { origin, owner, repositoryName } = repository;
     return {
       host: origin,
       owner,
       repository: repositoryName
     };
   } catch {
-    return defaultReleaseConfigParams;
+    return defaultConfigParams;
   }
 };
-const initRelease = async ({ configPackage }) => {
-  const releaseConfigParams = await getReleaseConfigParams();
-  const configContent = `import { createReleaseConfig } from '${configPackage}/${releaseConfigPath}';
+initRelease_fn = async function() {
+  const configPath = "release.config.js";
+  const configParams = await __privateMethod(this, _ToolInitializer_instances, getReleaseConfigParams_fn).call(this);
+  const configContent = `import { createReleaseConfig } from '${__privateGet(this, _configPackage)}/${configPath}';
 
-export default createReleaseConfig(${JSON.stringify(releaseConfigParams, null, 2)});
+export default createReleaseConfig(${JsonUtils.prettify(configParams)});
 `;
-  await ConfigCommands.createFile(releaseConfigPath, configContent);
+  await FileUtils.createFile(configPath, configContent);
 };
-const typescriptConfigPath = "tsconfig.json";
-const initTypescript = async ({ configDirectory }) => {
+initTypeScript_fn = async function() {
+  const configPath = "tsconfig.json";
   const configContent = `{
-  "extends": "${configDirectory}/${typescriptConfigPath}",
-  "compilerOptions": {
-    "baseUrl": "./"
-  }
-}
-`;
-  await ConfigCommands.createFile(typescriptConfigPath, configContent);
-};
-const vscodeSettingsPath = Path.join(".vscode", "settings.json");
-const initVscode = async () => {
-  const configContent = `{
-  "prettier.ignorePath": "node_modules/@cluerise/tools/dist/configs/.prettierignore",
-  "typescript.tsdk": "node_modules/typescript/lib"
+  "extends": "${__privateGet(this, _configDirectory)}/${configPath}"
 }
 `;
-  await ConfigCommands.createFile(vscodeSettingsPath, configContent);
-};
-const toolInitializers = {
-  commitlint: initCommitlint,
-  editorconfig: initEditorConfig,
-  eslint: initEslint,
-  git: initGit,
-  "lint-staged": initLintStaged,
-  npm: initNpm,
-  nvm: initNvm,
-  prettier: initPrettier,
-  release: initRelease,
-  typescript: initTypescript,
-  vscode: initVscode
-};
-const toolInitializerNames = Object.keys(toolInitializers);
-const toolNameSchema = z.union([
-  z.literal("commitlint"),
-  z.literal("editorconfig"),
-  z.literal("eslint"),
-  z.literal("git"),
-  z.literal("lint-staged"),
-  z.literal("npm"),
-  z.literal("nvm"),
-  z.literal("prettier"),
-  z.literal("release"),
-  z.literal("typescript"),
-  z.literal("vscode")
-]);
-const initializingConsole = createStatusConsole("Initializing");
-const initTool = async (name, params) => {
-  const toolInitializer = toolInitializers[name];
-  if (!toolInitializer) {
-    throw new Error(`Tool "${name}" is not supported.`);
-  }
-  initializingConsole.printBegin(name);
-  await toolInitializer(params);
-  initializingConsole.printEnd(name);
-};
-const initAllTools = async (params) => {
-  for (const name of toolInitializerNames) {
-    await initTool(name, params);
+  await FileUtils.createFile(configPath, configContent);
+};
+initVSCode_fn = async function() {
+  const settingsPath = Path.join(".vscode", "settings.json");
+  const settingsContent = '{\n  "editor.codeActionsOnSave": {\n    "source.fixAll.eslint": "explicit"\n  },\n  "prettier.ignorePath": "node_modules/@cluerise/tools/dist/configs/.prettierignore",\n  "typescript.tsdk": "node_modules/typescript/lib"\n}\n';
+  await FileUtils.createFile(settingsPath, settingsContent);
+};
+const _FileLinter = class _FileLinter {
+  constructor(options) {
+    __privateAdd(this, _FileLinter_instances);
+    __privateAdd(this, _options);
+    __privateAdd(this, _eslint);
+    __privateAdd(this, _eslintFixer, null);
+    __privateSet(this, _options, options ?? null);
+    __privateSet(this, _eslint, new ESLint({
+      overrideConfigFile: options == null ? void 0 : options.configPath
+    }));
+    if (options == null ? void 0 : options.fix) {
+      __privateSet(this, _eslintFixer, new ESLint({
+        fix: options.fix,
+        overrideConfigFile: options == null ? void 0 : options.configPath
+      }));
+    }
   }
-};
-const InitCommands = {
-  initAllTools,
-  initTool
-};
-const lintCommit = (args) => {
-  const { status } = ChildProcess.spawnSync("commitlint", args, { stdio: "inherit" });
-  return status ?? 0;
-};
-z.union([z.literal("all"), z.literal("code")]);
-const scopePatterns = {
-  all: ["**"],
-  code: ["src/**"]
-};
-const scopeShortcuts = Object.keys(scopePatterns);
-const isScopeShortcut = (scope) => scopeShortcuts.includes(scope);
-const resolveScope = (scope) => {
-  if (Array.isArray(scope)) {
-    return scope;
+  /**
+   * Lints files using `lint-staged` with the provided arguments.
+   *
+   * @param args - An array of arguments to pass to `lint-staged`.
+   * @returns The exit status of the `lint-staged` command.
+   */
+  static lintStaged(args) {
+    const { status } = ChildProcess.spawnSync("lint-staged", args, { stdio: "inherit" });
+    return status ?? 0;
   }
-  if (isScopeShortcut(scope)) {
-    return scopePatterns[scope];
+  /**
+   * Lints files matching the provided patterns using ESLint and Prettier.
+   *
+   * @param patterns - An array of glob patterns to match files against. Defaults to ['**'] which matches all files.
+   * @returns A promise that resolves to a LintFilesResult indicating the success or failure of the linting process.
+   */
+  async lint(patterns = ["**"]) {
+    var _a;
+    const prettierResults = await __privateMethod(this, _FileLinter_instances, prettierLint_fn).call(this, patterns);
+    const eslintResults = await __privateMethod(this, _FileLinter_instances, eslintLint_fn).call(this, patterns);
+    const eslintResult = await __privateMethod(this, _FileLinter_instances, prepareESLintLintResult_fn).call(this, eslintResults);
+    if (eslintResult.status === "failure") {
+      return eslintResult;
+    }
+    const prettierResult = __privateMethod(_a = _FileLinter, _FileLinter_static, preparePrettierLintResult_fn).call(_a, prettierResults);
+    if (prettierResult.status === "failure") {
+      return prettierResult;
+    }
+    return {
+      status: "success"
+    };
   }
-  return [scope];
 };
-const formatWithPrettier = async (patterns) => {
-  const eslint = new ESLint();
+_options = new WeakMap();
+_eslint = new WeakMap();
+_eslintFixer = new WeakMap();
+_FileLinter_static = new WeakSet();
+preparePrettierLintResult_fn = function(results) {
+  if (results.length === 0) {
+    return { status: "success" };
+  }
+  const title = `Linting with Prettier failed with ${results.length} problem${results.length === 1 ? "" : "s"}
+`;
+  let message = "Prettier failed with the following files:\n";
+  message += results.map((result) => `- ${result.path}`).join("\n");
+  message += OS.EOL;
+  return {
+    status: "failure",
+    title,
+    message,
+    problemCount: results.length
+  };
+};
+_FileLinter_instances = new WeakSet();
+prettierLint_fn = async function(patterns) {
   const configPath = await Prettier.resolveConfigFile();
   if (!configPath) {
-    return false;
+    return [];
   }
   const config = await Prettier.resolveConfig(configPath);
   if (!config) {
-    return false;
+    return [];
   }
   const paths = await glob(patterns, {
     nodir: true,
     ignore: "node_modules/**"
   });
-  await Promise.all(
+  const results = await Promise.all(
     paths.map(async (path) => {
-      if (await eslint.isPathIgnored(path)) {
-        return;
+      var _a;
+      if (await __privateGet(this, _eslint).isPathIgnored(path)) {
+        return null;
+      }
+      const contentBuffer = await FileSystem.readFile(path);
+      const content = contentBuffer.toString();
+      if ((_a = __privateGet(this, _options)) == null ? void 0 : _a.fix) {
+        const nextContent = await Prettier.format(content, {
+          ...config,
+          filepath: path
+        });
+        await FileSystem.writeFile(path, nextContent);
+        return null;
       }
-      const prevContent = (await FileSystem.readFile(path)).toString();
-      const nextContent = await Prettier.format(prevContent, {
+      const result = await Prettier.check(content, {
         ...config,
         filepath: path
       });
-      await FileSystem.writeFile(path, nextContent);
+      return result ? null : { path };
     })
   );
-};
-const lintFiles = async (scope, options) => {
-  const patterns = resolveScope(scope);
-  if (options == null ? void 0 : options.fix) {
-    await formatWithPrettier(patterns);
-  }
-  const eslint = new ESLint({
-    fix: options == null ? void 0 : options.fix
-  });
-  const results = await eslint.lintFiles(patterns);
-  const problemCount = results.reduce((sum, result) => sum + result.errorCount + result.warningCount, 0);
-  if (options == null ? void 0 : options.fix) {
-    await ESLint.outputFixes(results);
-  }
-  if (problemCount > 0) {
-    const formatter = await eslint.loadFormatter("stylish");
-    const resultText = formatter.format(results);
-    console.error(resultText);
-    const errorMessage = `Linting failed with ${problemCount} problem${problemCount === 1 ? "" : "s"}.`;
-    throw new Error(errorMessage);
+  return results.filter((result) => result !== null);
+};
+prepareESLintLintResult_fn = async function(results) {
+  const problemCount = results.reduce(
+    (sum, result) => {
+      var _a;
+      return sum + result.errorCount + result.warningCount + (((_a = __privateGet(this, _options)) == null ? void 0 : _a.fix) ? -(result.fixableErrorCount + result.fixableWarningCount) : 0);
+    },
+    0
+  );
+  if (problemCount === 0) {
+    return { status: "success" };
   }
+  const title = `ESLint failed with ${problemCount} problem${problemCount === 1 ? "" : "s"}`;
+  const formatter = await __privateGet(this, _eslint).loadFormatter("stylish");
+  const message = await formatter.format(results);
+  return {
+    status: "failure",
+    title,
+    message,
+    problemCount
+  };
 };
-const lintStaged = (args) => {
-  const { status } = ChildProcess.spawnSync("lint-staged", args, { stdio: "inherit" });
-  return status ?? 0;
-};
-const LintCommands = {
-  lintFiles,
-  lintCommit,
-  lintStaged
+eslintLint_fn = async function(patterns) {
+  const results = await __privateGet(this, _eslint).lintFiles(patterns);
+  const errorResults = ESLint.getErrorResults(results);
+  if (__privateGet(this, _eslintFixer) && errorResults.length > 0) {
+    await ESLint.outputFixes(await __privateGet(this, _eslintFixer).lintFiles(patterns));
+  }
+  return results;
 };
+__privateAdd(_FileLinter, _FileLinter_static);
+let FileLinter = _FileLinter;
 const toolNameArgSchema = z.union([z.literal("all"), toolNameSchema]);
 const parseInitArgs = ([nameArg]) => {
   const name = toolNameArgSchema.parse(nameArg);
@@ -353,33 +586,33 @@ const parseInitArgs = ([nameArg]) => {
     name
   };
 };
-const toolInitializerParams = {
-  configDirectory: AppConfig.toolsConfigDirectory,
-  configPackage: AppConfig.toolsConfigPackage
-};
 const main = async (args) => {
   try {
     const { name } = parseInitArgs(args);
-    if (name === "all") {
-      await InitCommands.initAllTools(toolInitializerParams);
-    } else {
-      await InitCommands.initTool(name, toolInitializerParams);
+    const toolInitializer = new ToolInitializer(CoreConfig.configDirectory, CoreConfig.configPackage);
+    const fileLinter = new FileLinter({ fix: true });
+    const statusLogger = new ConsoleStatusLogger("Initializing");
+    const toolNames = name === "all" ? toolInitializer.toolNames : [name];
+    for (const toolName of toolNames) {
+      statusLogger.begin(toolName);
+      await toolInitializer.initTool(toolName);
+      statusLogger.end(toolName);
     }
-    await LintCommands.lintFiles("all", { fix: true });
+    await fileLinter.lint();
     return 0;
   } catch (error) {
     if (error instanceof ZodError) {
       const firstIssue = error.issues[0];
       if ((firstIssue == null ? void 0 : firstIssue.code) === "invalid_union") {
-        console.error("Invalid tool name");
+        console.error("Error: Invalid tool name");
         return 1;
       }
     }
     if (error instanceof Error) {
-      console.error(error.message);
-      return 1;
+      console.error("Error:", error.message);
+    } else {
+      console.error("Error:", error);
     }
-    console.error(error);
     return 1;
   }
 };