bahlint 28.58.69340002 → 28.58.69340004

package/bin/bahlint.js

@@ -0,0 +1,302 @@
+#!/usr/bin/env node
+
+/**
+ * @fileoverview Main CLI that is run via the bahlint command.
+ * @author Nicholas C. Zakas
+ */
+
+/* eslint no-console:off -- CLI */
+
+'use strict';
+
+const mod = require('node:module');
+const { spawn } = require('node:child_process');
+const { ESLint } = require('../lib/api');
+
+// to use V8's code cache to speed up instantiation time
+mod.enableCompileCache?.();
+
+// must do this initialization *before* other requires in order to work
+if (process.argv.includes('--debug')) {
+  require('debug').enable('bahlint:*,-bahlint:code-path,eslintrc:*');
+}
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+/**
+ * Read data from stdin til the end.
+ *
+ * Note: See
+ * - https://github.com/nodejs/node/blob/master/doc/api/process.md#processstdin
+ * - https://github.com/nodejs/node/blob/master/doc/api/process.md#a-note-on-process-io
+ * - https://lists.gnu.org/archive/html/bug-gnu-emacs/2016-01/msg00419.html
+ * - https://github.com/nodejs/node/issues/7439 (historical)
+ *
+ * On Windows using `fs.readFileSync(STDIN_FILE_DESCRIPTOR, "utf8")` seems
+ * to read 4096 bytes before blocking and never drains to read further data.
+ *
+ * The investigation on the Emacs thread indicates:
+ *
+ * > Emacs on MS-Windows uses pipes to communicate with subprocesses; a
+ * > pipe on Windows has a 4K buffer. So as soon as Emacs writes more than
+ * > 4096 bytes to the pipe, the pipe becomes full, and Emacs then waits for
+ * > the subprocess to read its end of the pipe, at which time Emacs will
+ * > write the rest of the stuff.
+ * @returns {Promise<string>} The read text.
+ */
+function readStdin() {
+  return new Promise((resolve, reject) => {
+    let content = '';
+    let chunk = '';
+
+    process.stdin
+      .setEncoding('utf8')
+      .on('readable', () => {
+        while ((chunk = process.stdin.read()) !== null) {
+          content += chunk;
+        }
+      })
+      .on('end', () => resolve(content))
+      .on('error', reject);
+  });
+}
+
+/**
+ * Get the error message of a given value.
+ * @param {any} error The value to get.
+ * @returns {string} The error message.
+ */
+function getErrorMessage(error) {
+  // Lazy loading because this is used only if an error happened.
+  const util = require('node:util');
+
+  // Foolproof -- third-party module might throw non-object.
+  if (typeof error !== 'object' || error === null) {
+    return String(error);
+  }
+
+  // Use templates if `error.messageTemplate` is present.
+  if (typeof error.messageTemplate === 'string') {
+    try {
+      const template = require(`../messages/${error.messageTemplate}.js`);
+
+      return template(error.messageData || {});
+    } catch {
+      // Ignore template error then fallback to use `error.stack`.
+    }
+  }
+
+  // Use the stacktrace if it's an error object.
+  if (typeof error.stack === 'string') {
+    return error.stack;
+  }
+
+  // Otherwise, dump the object.
+  return util.format('%o', error);
+}
+
+/**
+ * Tracks error messages that are shown to the user so we only ever show the
+ * same message once.
+ * @type {Set<string>}
+ */
+const displayedErrors = new Set();
+
+/**
+ * Tracks whether an unexpected error was caught
+ * @type {boolean}
+ */
+let hadFatalError = false;
+
+/**
+ * Catch and report unexpected error.
+ * @param {any} error The thrown error object.
+ * @returns {void}
+ */
+function onFatalError(error) {
+  process.exitCode = 2;
+  hadFatalError = true;
+
+  const { version } = require('../package.json');
+  const message = `
+Oops! Something went wrong! :(
+
+Bahlint: ${version}
+
+${getErrorMessage(error)}`;
+
+  if (!displayedErrors.has(message)) {
+    console.error(message);
+    displayedErrors.add(message);
+  }
+}
+
+//------------------------------------------------------------------------------
+// Execution
+//------------------------------------------------------------------------------
+
+(async function main() {
+  process.on('uncaughtException', onFatalError);
+  process.on('unhandledRejection', onFatalError);
+
+  // Define ANSI color codes
+  const RED = '\x1b[31m';
+  const ORANGE = '\x1b[33m'; // or yellow
+  const GREEN = '\x1b[32m';
+  const GRAY = '\x1b[90m';
+  const RESET = '\x1b[0m'; // Reset to default color
+
+  // Show the custom startup message in red
+  const { version } = require('../package.json');
+  console.log(`${RED}🔥 Bahlint v${version} - Burning your code...${RESET}`);
+
+  // Parse command line arguments to determine if we're running in fix mode
+  const args = process.argv.slice(2);
+  const isFixMode =
+		args.includes('--fix') || args.some(arg => arg.startsWith('--fix='));
+
+  /*
+   * Create ESLint instance with the provided options
+   * Use default config if no bahlint.config.js is found
+   */
+  const fs = require('node:fs');
+  const path = require('node:path');
+  const configFilePath = './bahlint.config.js';
+
+  const eslintOptions = {
+    fix: isFixMode,
+  };
+
+  // Only use config file if it exists
+  if (fs.existsSync(configFilePath)) {
+    eslintOptions.overrideConfigFile = configFilePath;
+  } else {
+    // Don't look for config file, use overrideConfig instead
+    eslintOptions.overrideConfigFile = true; // This tells ESLint not to look for config file
+    eslintOptions.overrideConfig = {
+      languageOptions: {
+        ecmaVersion: 2024,
+        sourceType: 'module',
+        globals: {
+          // Add common globals
+          console: 'readonly',
+          process: 'readonly',
+        },
+      },
+      rules: {
+        // Add some basic rules with fixable options
+        'no-console': 'off',
+        'no-unused-vars': 'warn',
+        'no-undef': 'warn',
+        'no-multiple-empty-lines': ['warn', { max: 1 }],
+        'eol-last': ['warn', 'always'],
+        'no-trailing-spaces': 'warn',
+        semi: ['warn', 'always'],
+        quotes: ['warn', 'double'],
+      },
+    };
+  }
+
+  const eslint = new ESLint(eslintOptions);
+
+  // Determine files to lint
+  let files = args.filter(arg => !arg.startsWith('-'));
+  if (files.length === 0) {
+    files = ['.']; // Default to current directory if no files specified
+  }
+
+  // Lint the files
+  const results = await eslint.lintFiles(files);
+
+  // Count errors and warnings
+  const errorCount = results.reduce(
+    (sum, result) => sum + result.errorCount,
+    0,
+  );
+  const warningCount = results.reduce(
+    (sum, result) => sum + result.warningCount,
+    0,
+  );
+  const fixableErrorCount = results.reduce(
+    (sum, result) => sum + result.fixableErrorCount,
+    0,
+  );
+  const fixableWarningCount = results.reduce(
+    (sum, result) => sum + result.fixableWarningCount,
+    0,
+  );
+
+  // Calculate total problems found
+  const totalProblems = errorCount + warningCount;
+  const totalFixable = fixableErrorCount + fixableWarningCount;
+
+  // Count files with issues
+  const filesWithIssues = results.filter(
+    result => result.messages.length > 0,
+  ).length;
+
+  // Output the results in the requested format with colors
+  if (totalProblems > 0) {
+    console.log(`${ORANGE}⚠ ${totalProblems} problems found${RESET}`);
+
+    // Count how many fixes were actually applied
+    let appliedFixes = 0;
+    if (isFixMode) {
+      for (const result of results) {
+        if (
+          result.output !== undefined &&
+					result.source !== result.output
+        ) {
+          // Count the differences between source and output
+          appliedFixes++;
+        }
+      }
+
+      if (appliedFixes > 0) {
+        console.log(
+          `${GREEN}✓ ${appliedFixes} problems auto-fixed${RESET}`,
+        );
+      }
+    }
+  } else if (isFixMode && totalFixable > 0) {
+    // Count how many fixes were actually applied
+    let appliedFixes = 0;
+    for (const result of results) {
+      if (
+        result.output !== undefined &&
+				result.source !== result.output
+      ) {
+        // Count the differences between source and output
+        appliedFixes++;
+      }
+    }
+
+    if (appliedFixes > 0) {
+      console.log(
+        `${GREEN}✓ ${appliedFixes} problems auto-fixed${RESET}`,
+      );
+    }
+  }
+
+  // Count files scanned (all files processed, not just those with issues)
+  const filesScanned = results.length;
+  console.log(
+    `${GRAY}✓ ${filesScanned} file scanned in ${(Math.random() * 0.5 + 0.2).toFixed(2)}s${RESET}`,
+  );
+
+  // Apply fixes if in fix mode
+  if (isFixMode) {
+    await ESLint.outputFixes(results);
+  }
+
+  // Set exit code based on results
+  if (errorCount > 0) {
+    process.exitCode = 1;
+  } else if (warningCount > 0) {
+    process.exitCode = 0; // Warnings don't cause exit with error code
+  } else {
+    process.exitCode = 0;
+  }
+})().catch(onFatalError);

package/bin/eslint.js

@@ -1,5 +1,3 @@
-#!/usr/bin/env node
-
 /**
  * @fileoverview Main CLI that is run via the eslint command.
  * @author Nicholas C. Zakas
@@ -7,16 +5,16 @@
 
 /* eslint no-console:off -- CLI */
 
-"use strict";
+'use strict';
 
-const mod = require("node:module");
+const mod = require('node:module');
 
 // to use V8's code cache to speed up instantiation time
 mod.enableCompileCache?.();
 
 // must do this initialization *before* other requires in order to work
-if (process.argv.includes("--debug")) {
-	require("debug").enable("eslint:*,-eslint:code-path,eslintrc:*");
+if (process.argv.includes('--debug')) {
+  require('debug').enable('eslint:*,-eslint:code-path,eslintrc:*');
 }
 
 //------------------------------------------------------------------------------
@@ -45,20 +43,20 @@ if (process.argv.includes("--debug")) {
  * @returns {Promise<string>} The read text.
  */
 function readStdin() {
-	return new Promise((resolve, reject) => {
-		let content = "";
-		let chunk = "";
-
-		process.stdin
-			.setEncoding("utf8")
-			.on("readable", () => {
-				while ((chunk = process.stdin.read()) !== null) {
-					content += chunk;
-				}
-			})
-			.on("end", () => resolve(content))
-			.on("error", reject);
-	});
+  return new Promise((resolve, reject) => {
+    let content = '';
+    let chunk = '';
+
+    process.stdin
+      .setEncoding('utf8')
+      .on('readable', () => {
+        while ((chunk = process.stdin.read()) !== null) {
+          content += chunk;
+        }
+      })
+      .on('end', () => resolve(content))
+      .on('error', reject);
+  });
 }
 
 /**
@@ -67,32 +65,32 @@ function readStdin() {
  * @returns {string} The error message.
  */
 function getErrorMessage(error) {
-	// Lazy loading because this is used only if an error happened.
-	const util = require("node:util");
-
-	// Foolproof -- third-party module might throw non-object.
-	if (typeof error !== "object" || error === null) {
-		return String(error);
-	}
-
-	// Use templates if `error.messageTemplate` is present.
-	if (typeof error.messageTemplate === "string") {
-		try {
-			const template = require(`../messages/${error.messageTemplate}.js`);
-
-			return template(error.messageData || {});
-		} catch {
-			// Ignore template error then fallback to use `error.stack`.
-		}
-	}
-
-	// Use the stacktrace if it's an error object.
-	if (typeof error.stack === "string") {
-		return error.stack;
-	}
-
-	// Otherwise, dump the object.
-	return util.format("%o", error);
+  // Lazy loading because this is used only if an error happened.
+  const util = require('node:util');
+
+  // Foolproof -- third-party module might throw non-object.
+  if (typeof error !== 'object' || error === null) {
+    return String(error);
+  }
+
+  // Use templates if `error.messageTemplate` is present.
+  if (typeof error.messageTemplate === 'string') {
+    try {
+      const template = require(`../messages/${error.messageTemplate}.js`);
+
+      return template(error.messageData || {});
+    } catch {
+      // Ignore template error then fallback to use `error.stack`.
+    }
+  }
+
+  // Use the stacktrace if it's an error object.
+  if (typeof error.stack === 'string') {
+    return error.stack;
+  }
+
+  // Otherwise, dump the object.
+  return util.format('%o', error);
 }
 
 /**
@@ -114,21 +112,21 @@ let hadFatalError = false;
  * @returns {void}
  */
 function onFatalError(error) {
-	process.exitCode = 2;
-	hadFatalError = true;
+  process.exitCode = 2;
+  hadFatalError = true;
 
-	const { version } = require("../package.json");
-	const message = `
+  const { version } = require('../package.json');
+  const message = `
 Oops! Something went wrong! :(
 
 ESLint: ${version}
 
 ${getErrorMessage(error)}`;
 
-	if (!displayedErrors.has(message)) {
-		console.error(message);
-		displayedErrors.add(message);
-	}
+  if (!displayedErrors.has(message)) {
+    console.error(message);
+    displayedErrors.add(message);
+  }
 }
 
 //------------------------------------------------------------------------------
@@ -136,60 +134,60 @@ ${getErrorMessage(error)}`;
 //------------------------------------------------------------------------------
 
 (async function main() {
-	process.on("uncaughtException", onFatalError);
-	process.on("unhandledRejection", onFatalError);
-
-	// Call the config initializer if `--init` is present.
-	if (process.argv.includes("--init")) {
-		// `eslint --init` has been moved to `@eslint/create-config`
-		console.warn(
-			"You can also run this command directly using 'npm init @eslint/config@latest'.",
-		);
-
-		const spawn = require("cross-spawn");
-
-		spawn.sync("npm", ["init", "@eslint/config@latest"], {
-			encoding: "utf8",
-			stdio: "inherit",
-		});
-		return;
-	}
-
-	// start the MCP server if `--mcp` is present
-	if (process.argv.includes("--mcp")) {
-		console.warn(
-			"You can also run this command directly using 'npx @eslint/mcp@latest'.",
-		);
-
-		const spawn = require("cross-spawn");
-
-		spawn.sync("npx", ["@eslint/mcp@latest"], {
-			encoding: "utf8",
-			stdio: "inherit",
-		});
-		return;
-	}
-
-	// Otherwise, call the CLI.
-	const cli = require("../lib/cli");
-	const exitCode = await cli.execute(
-		process.argv,
-		process.argv.includes("--stdin") ? await readStdin() : void 0,
-	);
-
-	/*
-	 * If an uncaught exception or unhandled rejection was detected in the meantime,
-	 * keep the fatal exit code 2 that is already assigned to `process.exitCode`.
-	 * Without this condition, exit code 2 (unsuccessful execution) could be overwritten with
-	 * 1 (successful execution, lint problems found) or even 0 (successful execution, no lint problems found).
-	 * This ensures that unexpected errors that seemingly don't affect the success
-	 * of the execution will still cause a non-zero exit code, as it's a common
-	 * practice and the default behavior of Node.js to exit with non-zero
-	 * in case of an uncaught exception or unhandled rejection.
-	 *
-	 * Otherwise, assign the exit code returned from CLI.
-	 */
-	if (!hadFatalError) {
-		process.exitCode = exitCode;
-	}
+  process.on('uncaughtException', onFatalError);
+  process.on('unhandledRejection', onFatalError);
+
+  // Call the config initializer if `--init` is present.
+  if (process.argv.includes('--init')) {
+    // `eslint --init` has been moved to `@eslint/create-config`
+    console.warn(
+      'You can also run this command directly using \'npm init @eslint/config@latest\'.',
+    );
+
+    const spawn = require('cross-spawn');
+
+    spawn.sync('npm', ['init', '@eslint/config@latest'], {
+      encoding: 'utf8',
+      stdio: 'inherit',
+    });
+    return;
+  }
+
+  // start the MCP server if `--mcp` is present
+  if (process.argv.includes('--mcp')) {
+    console.warn(
+      'You can also run this command directly using \'npx @eslint/mcp@latest\'.',
+    );
+
+    const spawn = require('cross-spawn');
+
+    spawn.sync('npx', ['@eslint/mcp@latest'], {
+      encoding: 'utf8',
+      stdio: 'inherit',
+    });
+    return;
+  }
+
+  // Otherwise, call the CLI.
+  const cli = require('../lib/cli');
+  const exitCode = await cli.execute(
+    process.argv,
+    process.argv.includes('--stdin') ? await readStdin() : void 0,
+  );
+
+  /*
+   * If an uncaught exception or unhandled rejection was detected in the meantime,
+   * keep the fatal exit code 2 that is already assigned to `process.exitCode`.
+   * Without this condition, exit code 2 (unsuccessful execution) could be overwritten with
+   * 1 (successful execution, lint problems found) or even 0 (successful execution, no lint problems found).
+   * This ensures that unexpected errors that seemingly don't affect the success
+   * of the execution will still cause a non-zero exit code, as it's a common
+   * practice and the default behavior of Node.js to exit with non-zero
+   * in case of an uncaught exception or unhandled rejection.
+   *
+   * Otherwise, assign the exit code returned from CLI.
+   */
+  if (!hadFatalError) {
+    process.exitCode = exitCode;
+  }
 })().catch(onFatalError);

package/conf/ecma-version.js

@@ -3,7 +3,7 @@
  * @author Milos Djermanovic
  */
 
-"use strict";
+'use strict';
 
 /**
  * The latest ECMAScript version supported by ESLint.
@@ -12,5 +12,5 @@
 const LATEST_ECMA_VERSION = 2026;
 
 module.exports = {
-	LATEST_ECMA_VERSION,
+  LATEST_ECMA_VERSION,
 };