fenge 0.10.0 → 0.10.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fenge",
-  "version": "0.10.0",
+  "version": "0.10.2",
   "description": "A CLI tool for code quality",
   "keywords": [
     "cli",
@@ -51,8 +51,8 @@
     "prettier": "3.6.2",
     "pretty-ms": "9.2.0",
     "yoctocolors": "2.1.2",
-    "@fenge/eslint-config": "0.7.10",
-    "@fenge/prettier-config": "0.3.9",
+    "@fenge/eslint-config": "0.7.12",
+    "@fenge/prettier-config": "0.3.10",
     "@fenge/tsconfig": "0.7.0",
     "prettier-ignore": "0.4.0"
   },

package/src/bin/fenge.cli.js

@@ -35,14 +35,27 @@ program
   )
   .argument("[paths...]", "dir or file paths to format and lint")
   .action(async (paths, options) => {
+    /**
+     * @type {{code: number, stdout: string, stderr: string, fixedFiles?: string[]}}
+     */
     let result = await format(paths, options);
-    if (result === 0) {
+    result.stdout && console.log(result.stdout);
+    result.stderr && console.error(result.stderr);
+    if (result.code === 0) {
       result = await lint(paths, options);
-      if (result === 0 && (options.fix || options.update)) {
-        result = await format(paths, options);
+      result.stdout && console.log(result.stdout);
+      result.stderr && console.error(result.stderr);
+      if (
+        result.code === 0 &&
+        (options.fix || options.update) &&
+        result.fixedFiles?.length
+      ) {
+        result = await format(result.fixedFiles, options);
+        result.stdout && console.log(result.stdout);
+        result.stderr && console.error(result.stderr);
       }
     }
-    process.exit(result);
+    process.exit(result.code);
   });
 
 program
@@ -61,7 +74,12 @@ program
     "print what command will be executed under the hood instead of executing",
   )
   .argument("[paths...]", "dir or file paths to lint")
-  .action(async (paths, options) => process.exit(await lint(paths, options)));
+  .action(async (paths, options) => {
+    const { code, stdout, stderr } = await lint(paths, options);
+    stdout && console.log(stdout);
+    stderr && console.error(stderr);
+    process.exit(code);
+  });
 
 program
   .command("format")
@@ -78,7 +96,12 @@ program
     "print what command will be executed under the hood instead of executing",
   )
   .argument("[paths...]", "dir or file paths to format")
-  .action(async (paths, options) => process.exit(await format(paths, options)));
+  .action(async (paths, options) => {
+    const { code, stdout, stderr } = await format(paths, options);
+    stdout && console.log(stdout);
+    stderr && console.error(stderr);
+    process.exit(code);
+  });
 
 program
   .command("install")

package/src/command/format.js

@@ -18,8 +18,9 @@ export async function format(
     default: useDefaultConfig = false,
   } = {},
 ) {
-  return execAsync(
+  return execAsync("💃 Checking formatting")(
     [
+      process.execPath,
       await getPrettierPath(useDefaultConfig),
       // setup 3 ignore files
       ...[".gitignore", ".prettierignore", prettierignore]
@@ -37,7 +38,6 @@ export async function format(
       ),
     ],
     {
-      topic: "💃 Checking formatting",
       dryRun,
       env: {
         ...(config && { FENGE_CONFIG: config }),
@@ -51,11 +51,10 @@ export async function format(
  * @param {boolean} useDefaultConfig
  */
 async function getPrettierPath(useDefaultConfig) {
-  const builtinBinPath = await getBinPath("prettier");
   if (useDefaultConfig) {
-    return builtinBinPath;
+    return await getBinPath("prettier");
   }
-  return await getBinPath("prettier", process.cwd()).catch(
-    () => builtinBinPath,
+  return await getBinPath("prettier", process.cwd()).catch(() =>
+    getBinPath("prettier"),
   );
 }

package/src/command/lint.js

@@ -1,6 +1,7 @@
 // @ts-check
 import path from "node:path";
 import process from "node:process";
+import { ESLint } from "eslint";
 import { dir, execAsync, getBinPath } from "../utils.js";
 
 /**
@@ -18,9 +19,11 @@ export async function lint(
     timing = false,
   } = {},
 ) {
-  return execAsync(
+  const result = await execAsync("📏 Checking linting")(
     [
+      process.execPath,
       await getEslintPath(useDefaultConfig),
+      ...(timing ? [] : ["--format=json"]),
       "--config",
       path.join(dir(import.meta.url), "..", "config", "eslint.config.js"),
       ...(update || fix ? ["--fix"] : []),
@@ -29,7 +32,6 @@ export async function lint(
       ),
     ],
     {
-      topic: "📏 Checking linting",
       dryRun,
       env: {
         ...(config && { FENGE_CONFIG: config }),
@@ -38,15 +40,50 @@ export async function lint(
       },
     },
   );
+  // Loading formatter in this way is not very elegant, but it's the only way (maybe).
+  const formatter = await new ESLint().loadFormatter("stylish");
+  const stdoutResult = await handleJson(formatter, result.stdout);
+  const stderrResult = await handleJson(formatter, result.stderr);
+  return {
+    ...result,
+    stdout: stdoutResult.content,
+    stderr: stderrResult.content,
+    fixedFiles: [
+      ...new Set([...stdoutResult.fixedFiles, ...stderrResult.fixedFiles]),
+    ],
+  };
+}
+
+/**
+ * @param {import('eslint').ESLint.LoadedFormatter} formatter
+ * @param {string} str
+ */
+async function handleJson(formatter, str) {
+  try {
+    /** @type {import('eslint').ESLint.LintResult[]} */
+    const lintResults = JSON.parse(str);
+    return {
+      fixedFiles: lintResults
+        .filter((lintResult) => lintResult.output)
+        .map((lintResult) => lintResult.filePath),
+      content: await formatter.format(lintResults),
+    };
+  } catch {
+    return {
+      fixedFiles: [],
+      content: str,
+    };
+  }
 }
 
 /**
  * @param {boolean} useDefaultConfig
  */
 async function getEslintPath(useDefaultConfig) {
-  const builtinBinPath = await getBinPath("eslint");
   if (useDefaultConfig) {
-    return builtinBinPath;
+    return await getBinPath("eslint");
   }
-  return await getBinPath("eslint", process.cwd()).catch(() => builtinBinPath);
+  return await getBinPath("eslint", process.cwd()).catch(() =>
+    getBinPath("eslint"),
+  );
 }

package/src/utils.js

@@ -42,30 +42,65 @@ export async function resolveConfig(module, loadPath) {
     : await searcher.search(process.cwd());
 }
 
+/**
+ * Creates a spinner wrapper for async functions that shows progress and timing
+ * @template {readonly unknown[]} TArgs - The arguments type for the function
+ * @template {{ code: number }} TReturn - The return type that must have a code property
+ * @param {(...args: TArgs) => Promise<TReturn>} func - The async function to wrap
+ * @param {string} topic - The topic/description to show in the spinner
+ * @returns {(...args: TArgs) => Promise<TReturn>} The wrapped function with spinner
+ */
+export function spin(func, topic) {
+  return async (...args) => {
+    const startTime = Date.now();
+    const spinner = ora(`${topic}...`).start();
+    /** @type {"succeed" | "fail"} */
+    let succeedOrFail = "fail";
+    try {
+      const result = await func(...args);
+      if (result.code === 0) succeedOrFail = "succeed";
+      return result;
+    } finally {
+      spinner[succeedOrFail](
+        `${topic} ${succeedOrFail} in ${colors.yellow(prettyMs(Date.now() - startTime))}`,
+      );
+    }
+  };
+}
+
 /**
  * @param {string[]} command
- * @param {{topic: string, dryRun: boolean, env: Record<string, string>}} options
- * @returns {Promise<number>}
+ * @param {{dryRun: boolean, env: Record<string, string>}} options
+ * @returns {Promise<{code: number, stdout: string, stderr: string}>}
  */
-export function execAsync(command, { topic, dryRun, env }) {
+function execCmd(command, { dryRun, env }) {
   const [cmd, ...args] = command;
   if (!cmd) {
     return Promise.reject(new Error("cmd not found"));
   }
   if (dryRun) {
-    process.stdout.write(`${colors.green(cmd)} ${args.join(" ")};\n\n`);
-    return Promise.resolve(0);
+    return Promise.resolve({
+      code: 0,
+      stdout: `${colors.green(cmd)} ${args.join(" ")};\n`,
+      stderr: "",
+    });
   }
 
   return new Promise((resolve, reject) => {
-    const startTime = Date.now();
-    const spinner = ora(`${topic}...`).start();
     /**
      * @type {childProcess.ChildProcessWithoutNullStreams | undefined}
      */
     let cp = childProcess.spawn(cmd, args, {
       env: { FORCE_COLOR: "true", ...process.env, ...env },
     });
+
+    /**
+     * @param {NodeJS.Signals} signal
+     */
+    const listener = (signal) => cp && !cp.killed && cp.kill(signal);
+    process.on("SIGINT", listener);
+    process.on("SIGTERM", listener);
+
     let stdout = Buffer.alloc(0);
     let stderr = Buffer.alloc(0);
     cp.stdout.on("data", (data) => {
@@ -75,39 +110,37 @@ export function execAsync(command, { topic, dryRun, env }) {
       stderr = Buffer.concat([stderr, data]);
     });
     cp.on("error", (err) => {
+      process.removeListener("SIGINT", listener);
+      process.removeListener("SIGTERM", listener);
       reject(err);
     });
     // Why not listen to the 'exit' event?
     // 1. The 'close' event will always emit after 'exit' was already emitted, or 'error' if the child failed to spawn.
     // 2. The 'exit' event may or may not fire after an error has occurred.
     cp.on("close", (code, signal) => {
-      if (code === 0) {
-        spinner.succeed(
-          `${topic} succeeded in ${colors.yellow(prettyMs(Date.now() - startTime))}`,
-        );
-      } else {
-        spinner.fail(
-          `${topic} failed in ${colors.yellow(prettyMs(Date.now() - startTime))}`,
-        );
-      }
-      process.stdout.write(stdout);
-      process.stderr.write(stderr);
+      const stdoutString = stdout.toString("utf8");
+      const stderrString = stderr.toString("utf8");
       // When the cp exited, we should clean cp and the buffer to prevent memory leak.
       stdout = Buffer.alloc(0);
       stderr = Buffer.alloc(0);
       cp = undefined;
-      resolve(code ?? (signal ? 128 + os.constants.signals[signal] : 1));
-    });
 
-    /**
-     * @param {NodeJS.Signals} signal
-     */
-    const listener = (signal) => cp && !cp.killed && cp.kill(signal);
-    process.on("SIGINT", listener);
-    process.on("SIGTERM", listener);
+      process.removeListener("SIGINT", listener);
+      process.removeListener("SIGTERM", listener);
+      resolve({
+        code: code ?? (signal ? 128 + os.constants.signals[signal] : 1),
+        stdout: stdoutString.trim(),
+        stderr: stderrString.trim(),
+      });
+    });
   });
 }
 
+/**
+ * @param {string} topic
+ */
+export const execAsync = (topic) => spin(execCmd, topic);
+
 /**
  * @param {string} moduleName `eslint` or `prettier` or `@commitlint/cli` or `lint-staged`
  * @param {string} from directory path or file path