fenge 0.0.0 → 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,20 @@
+# fenge
+
+## 0.1.0
+
+### Minor Changes
+
+- 27bbb4a: feat: migrate `git-validator` to fenge
+
+  IMPORTANT: We migrate all the features from `git-validator` to `fenge` now. `git-validator` will be deprecated later.
+
+### Patch Changes
+
+- Updated dependencies [514733a]
+- Updated dependencies [67f298b]
+- Updated dependencies [db5931d]
+- Updated dependencies [b5b70e3]
+  - @fenge/tsconfig@0.1.0
+  - @fenge/types@0.1.0
+  - @fenge/prettier-config@0.1.0
+  - @fenge/eslint-config@0.1.0

package/README.md

@@ -1 +1,262 @@
-# fenge(风格)
+<div align="center">
+
+<img height="180" src="https://raw.githubusercontent.com/zanminkian/static/main/fenge/style.svg">
+
+# Fenge(风格)
+
+> A CLI tool for JavaScript and TypeScript code quality.
+
+<font size=4> 😎 = 🇹 + 💃 + 📏 </font>
+
+[![](https://img.shields.io/npm/l/fenge.svg)](https://github.com/zanminkian/fenge/blob/main/LICENSE)
+[![](https://img.shields.io/npm/v/fenge.svg)](https://www.npmjs.com/package/fenge)
+[![](https://img.shields.io/npm/dm/fenge.svg)](https://www.npmjs.com/package/fenge)
+[![](https://packagephobia.com/badge?p=fenge)](https://packagephobia.com/result?p=fenge)
+[![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg)](https://makeapullrequest.com)
+
+</div>
+
+---
+
+## Philosophy
+
+<details>
+<summary>简体中文</summary>
+
+经过多年实践，我们发现，最影响现代 JavaScript 工程的代码质量和开发体验的主要有 3 个方面：
+
+- **类型安全**：用于提前发现类型、拼写错误，例如对象方法是否正确调用、函数参数传递的类型是否符合函数体的期望等。
+- **Formatting**：用于统一格式，提升代码可读性，减少代码冲突。主要关注例如缩进、换行、单/双引号、带/不带分号等问题。
+- **Linting**：用于提前发现逻辑漏洞和糟粕用法，减少 Bug，降低维护成本。其关注点可以是除了 `Formatting` 之外的任何地方，例如重复定义变量、switch 不带 break、圈复杂度等。
+
+> Note: `类型安全` 和 `Linting` 的关注点可能存在一定的交集，例如：“函数入参数量对不上”，既可能被类型安全的工具（如 TypeScript）检测到，也可能被 Linter（如 ESLint）检测出来。
+
+> Note：`Formatting` 和 `Linting` 的关注点，原则上不存在交集。早期 ESLint 也被用于格式化，但是近年来，`Linter` 和 `Formatter` 分开已经被社区越来越广泛采纳，例如[ESLint 废弃 Formatting Rules](https://eslint.org/blog/2023/10/deprecating-formatting-rules)、Deno 和 Biome 均把 `Linter` 和 `Formatter` 分开。
+>
+> 有些人会将后两者 `Formatting` 和 `Linting` 合并起来一并处理，例如 [@antfu/eslint-config](https://github.com/antfu/eslint-config)。我们强烈**不建议**这样做。首先是因为它们目的不一样，专业的事情应该交给专业的工具。其次是它们的造成心智负担不同，Review 代码时，我们往往不需要关注 Formatting 的改动，但是我们必须要仔细检查确认 Linting 的改动，因为 Formatting 的改动一般是安全的，但是 Linting 的改动可存在错误的修复。
+
+这 3 个方面也是更先进的运行时 [Deno](https://deno.com) 所内置的功能，[Node](https://nodejs.org) 并没有内置支持，取而代之的是社区里百花齐放的工具：TypeScript、Flow、Biome、ESLint、oxc-lint、Prettier、dprint。这些工具用在 Node 项目中存在 3 个非常影响**开发体验**的问题：
+
+- **工具选型问题**：我应该选择哪些工具集合来优化上述 3 个问题？选择后，下一个 Node 项目又选择不同工具集怎么办？
+- **工具之间冲突磨合问题**：确定使用的工具后，这些工具之间是否有冲突？代码提交时是先 format 还是先 lint？工具之间配合的最佳实践是什么？
+- **工具们的复杂配置问题**：每个工具都有很复杂难懂的配置，在项目根目录（或 `package.json` 里）到处拉屎。一来不美观简洁，二来增加理解成本。每个 Node 项目可能工具统一但配置不统一，进一步导致开发体验不一致。
+
+为了解决上述问题，现在有非常多教程文章讲解 TypeScript + Prettier + ESLint 的配置和实践，这些文章教程能缓解一部分问题，但仍然将<u>杂乱的工具链和繁琐的配置暴露给用户</u>。这不是我们的目标，我们的目标是**提供一个统一的工具屏蔽这些复杂的实践细节，给用户带来简单一致、开箱即用的良好开发体验**。
+
+</details>
+
+<details>
+<summary>English</summary>
+Coming soon...
+</details>
+
+## Features
+
+Based on the philosophy outlined above, this tool offers the following features:
+
+- 💪 **Enhanced Type Safety**: This tool provides the strictest `tsconfig` settings and type patches to bolster the type safety of TypeScript projects. It is also compatible with pure JavaScript projects.
+- 💃 **Formatting**: This tool ensures code consistency across your codebase and minimizes merge conflicts by automatically formatting code. It additionally supports the sorting of imports and `package.json` files.
+- 📏 **Linting**: This tool comes equipped with a comprehensive set of rules for static code analysis, which helps catch errors and prevent poor coding practices in JavaScript.
+- 🪝 **Git Hooks**: After installation, committing code via Git triggers automatic formatting and linting checks. No additional package installations are required.
+
+## Highlights
+
+We place a high value on `Development Experience` (DX).
+
+- 📦 **All-In-One**: You don't need to install `prettier`, `eslint`, `lint-staged` or `husky`.
+- ⚙️ **Zero Configs**: Comes with sensible default configurations for type safety, formatting, and linting, so you don't need to set up any configurations.
+- 😉 **Highly Customizable**: Every thing is optional. Every thing can be customized.
+
+## Quick Start
+
+To quick start, run command below to check formatting and linting style in your project.
+
+```sh
+npx fenge
+```
+
+## Install
+
+We recommend installing it as one of `devDependencies` in your project.
+
+```sh
+npm i -D fenge
+```
+
+## Usages
+
+Each of the following usages is optional. You can choose the ones that best fit your needs.
+
+### Type Safe
+
+#### Config the strictest `tsconfig.json`
+
+Config `tsconfig.json` file in your project root.
+
+```json
+{
+  "extends": "fenge/tsconfig"
+}
+```
+
+Config `tsconfig.build.json` file in sub-package or project root.
+
+```json
+{
+  "extends": "./tsconfig.json",
+  "include": ["src"],
+  "exclude": ["**/*.spec.ts", "**/*.test.ts"]
+}
+```
+
+Build your project by executing:
+
+```sh
+tsc -p ./tsconfig.build.json
+```
+
+Type-check your project by executing:
+
+```sh
+tsc -p ./tsconfig.build.json --noEmit
+```
+
+For more beat practices, please refer to [@fenge/tsconfig](https://www.npmjs.com/package/@fenge/tsconfig).
+
+#### Import type patch
+
+Add a [triple-slash-directive](https://www.typescriptlang.org/docs/handbook/triple-slash-directives.html) `/// <reference types="fenge/types" />` at the top of the ts file that serves as the entry point for your application or package. This will make the entire project more type-safe. The built-in type patch `fenge/types` re-exports from [@fenge/types](https://www.npmjs.com/package/@fenge/types).
+
+Application/Package Entry Point (eg: `src/main.ts` or `src/app.ts`)
+
+```ts
+/// <reference types="fenge/types" />
+import foo from "./foo";
+```
+
+Other File (eg: `src/other-file.ts`)
+
+<!-- prettier-ignore-start -->
+```ts
+console.log(JSON.parse('{"foo":"foo"}').bar);
+         // ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ❌ Object is of type 'unknown'.
+```
+<!-- prettier-ignore-end -->
+
+### Formatting & Linting
+
+Here are some main commands to format or lint code.
+
+```sh
+# Check project's formatting problems only
+$ fenge format
+
+# Check project's formatting problems and apply updates
+$ fenge format -u
+
+# Check project's linting problems only
+$ fenge lint
+
+# Check project's linting problems and apply updates
+$ fenge lint -u
+
+# Check both formatting and linting problems
+$ fenge
+
+# Check both formatting and linting problems and apply updates
+$ fenge -u
+```
+
+This tool does not require a configuration file. However, you can add a `fenge.config.js` file to customize formatting and linting rules. This file should export an object with two properties:
+
+- `format`: Accept a [Prettier Config](https://prettier.io/docs/en/configuration.html).
+- `lint`: Accept a [ESLint Flat Config](https://eslint.org/docs/latest/use/configure/configuration-files).
+
+```js
+export default {
+  format: {
+    semi: false,
+    singleQuote: true,
+  },
+  lint: [
+    {
+      files: ["**/*.{js,cjs,mjs,jsx}", "**/*.{ts,cts,mts,tsx}"],
+      rules: {
+        "no-unused-vars": "error",
+      },
+    },
+  ],
+};
+```
+
+Usually, we recommend reusing the built-in configurations rather than writing them from scratch. The built-in configurations re-export from [@fenge/prettier-config](https://www.npmjs.com/package/@fenge/prettier-config) and [@fenge/eslint-config](https://www.npmjs.com/package/@fenge/eslint-config).
+
+```js
+// @ts-check
+// See https://www.npmjs.com/package/@fenge/eslint-config for eslint-config detail usage
+import { Builder } from "fenge/eslint-config";
+// See https://www.npmjs.com/package/@fenge/prettier-config for prettier-config detail usage
+import prettierConfig from "fenge/prettier-config";
+
+export default {
+  format: {
+    ...prettierConfig,
+    // add config below to override the default behavior
+    semi: false,
+  },
+  lint: new Builder()
+    .enablePackagejson({
+      pick: ["packagejson/top-types"], // only these rules will work for package.json files
+    })
+    .enableJavascript({
+      omit: ["no-var"], // these rules will not work for js files
+    })
+    .enableTypescript({
+      project: "tsconfig.json", // tsconfig.json path
+      extend: {
+        // apply additional rules for ts files
+        "@typescript-eslint/no-explicit-any": "error",
+        "@typescript-eslint/consistent-type-assertions": [
+          "error",
+          { assertionStyle: "never" },
+        ],
+        "@typescript-eslint/no-non-null-assertion": "error",
+      },
+    })
+    .toConfig(),
+};
+```
+
+You can even install and use other third-party eslint-config, like [@sxzz/eslint-config](https://www.npmjs.com/package/@sxzz/eslint-config).
+
+### Set up Git hooks
+
+Executing `fenge install` in the project root will write a `pre-commit` file to the `${PROJECT_ROOT}/.git/hooks` folder. After editing `package.json -> scripts -> prepare` script and executing it once, each commit (via Git) will trigger a code style check for the committed files.
+
+```json
+{
+  "scripts": {
+    "prepare": "fenge install"
+  }
+}
+```
+
+```sh
+npm run prepare
+```
+
+## Contributing
+
+- Clone this repository.
+- Enable [Corepack](https://github.com/nodejs/corepack) using `corepack enable`.
+- Install dependencies using `pnpm install`.
+- Run `pnpm style:update` to develop.
+- Start coding and submit your PR.
+
+## Show your support
+
+Give a ⭐️ if this project helped you!
+
+## License
+
+MIT

package/package.json

@@ -1,11 +1,16 @@
 {
   "name": "fenge",
-  "version": "0.0.0",
-  "description": "The best practice about using TypeScript, ESLint and Prettier",
+  "version": "0.1.0",
+  "description": "A CLI tool for code quality",
   "keywords": [
+    "cli",
+    "quality",
     "typescript",
+    "format",
+    "lint",
     "eslint",
     "prettier",
+    "biome",
     "style",
     "code-style",
     "validator",
@@ -13,7 +18,8 @@
     "husky",
     "lint-staged",
     "xo",
-    "standard"
+    "standard",
+    "modern"
   ],
   "homepage": "https://github.com/zanminkian/fenge",
   "repository": {
@@ -22,5 +28,47 @@
   },
   "license": "MIT",
   "author": "hellozmj@qq.com",
-  "type": "module"
+  "type": "module",
+  "exports": {
+    "./eslint-config": "./src/re-export/eslint.config.js",
+    "./prettier-config": "./src/re-export/prettier.config.js",
+    "./types": {
+      "types": "./types/index.d.ts"
+    },
+    "./tsconfig": "./tsconfig/tsconfig.json",
+    "./tsconfig/*": "./tsconfig/*.json",
+    "./tsconfig/*.json": "./tsconfig/*.json"
+  },
+  "bin": "./src/bin/cli.js",
+  "dependencies": {
+    "chalk": "5.3.0",
+    "commander": "12.1.0",
+    "eslint": "8.57.0",
+    "lilconfig": "3.1.2",
+    "lint-staged": "15.2.10",
+    "ora": "8.1.0",
+    "prettier": "3.3.3",
+    "@fenge/eslint-config": "0.1.0",
+    "@fenge/prettier-config": "0.1.0",
+    "@fenge/tsconfig": "0.1.0",
+    "@fenge/types": "0.1.0",
+    "prettier-ignore": "0.1.3"
+  },
+  "devDependencies": {
+    "@types/node": "22.7.5"
+  },
+  "peerDependencies": {
+    "typescript": "^5.6.0"
+  },
+  "peerDependenciesMeta": {
+    "typescript": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "tsc --noEmit -p tsconfig.build.json"
+  }
 }

package/src/bin/cli.js

@@ -0,0 +1,81 @@
+#!/usr/bin/env node
+// @ts-check
+import process from "node:process";
+import { initAction, setup } from "@fenge/tsconfig/setup";
+import { Command } from "commander";
+import { format } from "../command/format.js";
+import { install } from "../command/install.js";
+import { lint } from "../command/lint.js";
+import { importJson } from "../utils.js";
+
+const pkgJson = await importJson(import.meta.url, "../../package.json");
+
+const program = new Command().enablePositionalOptions();
+
+program
+  .name(pkgJson.name)
+  .version(pkgJson.version)
+  .description("format and then lint code")
+  .option(
+    "-f, --fix",
+    "automatically fix linting problems only, will not format code",
+  )
+  .option(
+    "-w, --write",
+    "automatically format code only, will not fix linting problems",
+  )
+  .option("-u, --update", "automatically format code and fix linting problems")
+  .option(
+    "-d, --dry-run",
+    "print what command will be executed under the hood instead of executing",
+  )
+  .argument("[paths...]", "dir or file paths to format and lint")
+  .action(async (paths, options) => {
+    let code = (await format(paths, options)) || (await lint(paths, options));
+    if (options.fix || options.update) {
+      code ||= await format(paths, options);
+    }
+    process.exit(code);
+  });
+
+program
+  .command("lint")
+  .description("lint code")
+  .option("-f, --fix", "automatically fix linting problems")
+  .option("-u, --update", "alias for '--fix' option")
+  .option(
+    "-d, --dry-run",
+    "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)));
+
+program
+  .command("format")
+  .description("format code")
+  .option("-w, --write", "automatically format code")
+  .option("-u, --update", "alias for '--write' option")
+  .option(
+    "-d, --dry-run",
+    "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)));
+
+program
+  .command("install")
+  .description(
+    "write `pre-commit` hook file into `.git/hooks` folder, after that, the committed code will be formatted and linted",
+  )
+  .option("--no-format", "skip formatting code on git 'pre-commit' stage")
+  .option("--no-lint", "skip linting code on git 'pre-commit' stage")
+  .action(async (options) => await install(options));
+
+setup(program, {
+  initCommand: "init-tsconfig",
+  diffCommand: "diff-tsconfig",
+  initAction: (options) =>
+    initAction({ ...options, ext: `${pkgJson.name}/tsconfig` }),
+});
+
+program.parse();

package/src/command/format.js

@@ -0,0 +1,34 @@
+// @ts-check
+import path from "node:path";
+import process from "node:process";
+import { prettierignore } from "prettier-ignore";
+import { dir, execAsync, getBinPath } from "../utils.js";
+
+/**
+ * @param {Array<string>} paths
+ * @param {{update?: boolean, write?: boolean, dryRun?: boolean}} options
+ */
+export async function format(paths = [], options = {}) {
+  const { update = false, write = false, dryRun = false } = options;
+
+  const cwd = process.cwd();
+  const ignores = [".gitignore", ".prettierignore", prettierignore]
+    .map((p) => path.resolve(p))
+    .flatMap((p) => ["--ignore-path", p]);
+  return execAsync(
+    [
+      // "node",
+      await getBinPath("prettier"),
+      ...ignores,
+      "--log-level",
+      "warn",
+      "--config",
+      path.join(dir(import.meta.url), "..", "config", "prettier.config.js"),
+      "--ignore-unknown",
+      "--no-error-on-unmatched-pattern", // Not a good option name. It's for skipping formatting symlinks. https://github.com/prettier/prettier/pull/15533
+      ...(update || write ? ["--write"] : ["--check"]),
+      ...(paths.length <= 0 ? ["."] : paths).map((p) => path.resolve(cwd, p)),
+    ],
+    { topic: "💃 Checking formatting", dryRun },
+  );
+}

package/src/command/install.js

@@ -0,0 +1,57 @@
+// @ts-check
+import fs from "node:fs/promises";
+import path from "node:path";
+import process from "node:process";
+import { dir, exists, getBinPath } from "../utils.js";
+
+/**
+ * @param {string} file
+ * @param {string} content
+ */
+async function writeGitHook(file, content) {
+  const gitPath = path.resolve(process.cwd(), ".git");
+  if (!(await exists(gitPath))) {
+    throw new Error(
+      "Directory `.git` is not existing. Please run `git init` first.",
+    );
+  }
+
+  const hooksPath = path.resolve(gitPath, "hooks");
+  await fs.mkdir(hooksPath, { recursive: true });
+
+  const hookFilePath = path.resolve(hooksPath, file);
+  await fs.writeFile(hookFilePath, content);
+  await fs.chmod(hookFilePath, "777");
+}
+
+/**
+ * @param {{noEslint: boolean, noPrettier: boolean}} options
+ */
+async function writePreCommit({ noEslint, noPrettier }) {
+  let config = "lint-staged.config.js";
+  if (noEslint && !noPrettier) {
+    config = "lint-staged-without-eslint.config.js";
+  } else if (!noEslint && noPrettier) {
+    config = "lint-staged-without-prettier.config.js";
+  } else if (noEslint && noPrettier) {
+    return;
+  }
+  const content = [
+    "#!/bin/sh",
+    `${await getBinPath("lint-staged")} --config ${path.join(dir(import.meta.url), "..", "config", config)}`,
+  ].join("\n");
+
+  await writeGitHook("pre-commit", content);
+}
+
+/**
+ * @param {{lint: boolean, format: boolean}} options
+ */
+export async function install({ lint, format }) {
+  if (!lint && !format) {
+    throw new Error(
+      "'--no-lint' and '--no-format' should not be used at the same time",
+    );
+  }
+  await writePreCommit({ noEslint: !lint, noPrettier: !format });
+}

package/src/command/lint.js

@@ -0,0 +1,26 @@
+// @ts-check
+import path from "node:path";
+import process from "node:process";
+import { dir, execAsync, getBinPath } from "../utils.js";
+
+/**
+ * @param {Array<string>} paths
+ * @param {{update?: boolean, fix?: boolean, dryRun?: boolean}} options
+ */
+export async function lint(paths = [], options = {}) {
+  const { update = false, fix = false, dryRun = false } = options;
+
+  const cwd = process.cwd();
+  process.env["ESLINT_USE_FLAT_CONFIG"] = "true"; // TODO remove it once upgrade to eslint 9
+  return execAsync(
+    [
+      // "node",
+      await getBinPath("eslint"),
+      "--config",
+      path.join(dir(import.meta.url), "..", "config", "eslint.config.js"),
+      ...(update || fix ? ["--fix"] : []),
+      ...(paths.length <= 0 ? ["."] : paths).map((p) => path.resolve(cwd, p)),
+    ],
+    { topic: "📏 Checking linting", dryRun },
+  );
+}

package/src/config/eslint.config.js

@@ -0,0 +1,6 @@
+// @ts-check
+import { resolveConfig } from "../utils.js";
+
+export default (await resolveConfig("fenge"))?.config?.lint ??
+  (await resolveConfig("eslint"))?.config ??
+  (await import("../re-export/eslint.config.js")).default;

package/src/config/lint-staged-without-eslint.config.js

@@ -0,0 +1,7 @@
+// @ts-check
+import path from "node:path";
+import { dir, resolveConfig } from "../utils.js";
+
+const cliPath = path.resolve(dir(import.meta.url), "..", "bin", "cli.js");
+const defaultConfig = { "*": [`${cliPath} format -u`] };
+export default (await resolveConfig("lint-staged"))?.config ?? defaultConfig;

package/src/config/lint-staged-without-prettier.config.js

@@ -0,0 +1,7 @@
+// @ts-check
+import path from "node:path";
+import { dir, resolveConfig } from "../utils.js";
+
+const cliPath = path.resolve(dir(import.meta.url), "..", "bin", "cli.js");
+const defaultConfig = { "*": [`${cliPath} lint`] };
+export default (await resolveConfig("lint-staged"))?.config ?? defaultConfig;

package/src/config/lint-staged.config.js

@@ -0,0 +1,9 @@
+// @ts-check
+import path from "node:path";
+import { dir, resolveConfig } from "../utils.js";
+
+const cliPath = path.resolve(dir(import.meta.url), "..", "bin", "cli.js");
+const defaultConfig = {
+  "*": [`${cliPath} -w`],
+};
+export default (await resolveConfig("lint-staged"))?.config ?? defaultConfig;

package/src/config/prettier.config.js

@@ -0,0 +1,6 @@
+// @ts-check
+import { resolveConfig } from "../utils.js";
+
+export default (await resolveConfig("fenge"))?.config?.format ??
+  (await resolveConfig("prettier"))?.config ??
+  (await import("../re-export/prettier.config.js")).default;

package/src/re-export/eslint.config.d.ts

@@ -0,0 +1,2 @@
+export { default } from "@fenge/eslint-config";
+export * from "@fenge/eslint-config";

package/src/re-export/eslint.config.js

@@ -0,0 +1,3 @@
+// @ts-check
+export { default } from "@fenge/eslint-config";
+export * from "@fenge/eslint-config";

package/src/re-export/prettier.config.d.ts

@@ -0,0 +1,2 @@
+export { default } from "@fenge/prettier-config";
+export * from "@fenge/prettier-config";

package/src/re-export/prettier.config.js

@@ -0,0 +1,3 @@
+// @ts-check
+export { default } from "@fenge/prettier-config";
+export * from "@fenge/prettier-config";

package/src/utils.js

@@ -0,0 +1,158 @@
+// @ts-check
+import { Buffer } from "node:buffer";
+import childProcess from "node:child_process";
+import fs from "node:fs/promises";
+import { createRequire } from "node:module";
+import path from "node:path";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+import chalk from "chalk";
+import { lilconfig } from "lilconfig";
+import ora from "ora";
+
+/**
+ * @param {string} filepath
+ */
+export async function exists(filepath) {
+  return await fs
+    .access(filepath)
+    .then(() => true)
+    .catch(() => false);
+}
+
+/**
+ * Get current directory of the js file
+ * Usage: `dir(import.meta.url)`
+ * @param {string} importMetaUrl
+ */
+export function dir(importMetaUrl) {
+  return path.dirname(fileURLToPath(importMetaUrl));
+}
+
+/**
+ * @param {string} module
+ */
+export async function resolveConfig(module) {
+  return await lilconfig(module, { stopDir: process.cwd() }).search(
+    process.cwd(),
+  );
+}
+
+/**
+ * Usage: `importJson(import.meta.url, '../xx.json')`
+ * @param {string} importMetaUrl
+ * @param {string} jsonPath
+ * @returns {Promise<any>}
+ */
+export async function importJson(importMetaUrl, jsonPath) {
+  return JSON.parse(
+    await fs.readFile(path.resolve(dir(importMetaUrl), jsonPath), "utf-8"),
+  );
+}
+
+/**
+ * @param {number} startTime
+ */
+function getSpentTime(startTime) {
+  const cost = Date.now() - startTime;
+  if (cost < 1000) {
+    return `${cost}ms`;
+  } else if (cost < 60 * 1000) {
+    return `${cost / 1000}s`;
+  } else {
+    const second = Math.floor(cost / 1000);
+    return `${Math.floor(second / 60)}m${Math.floor(second % 60)}s`;
+  }
+}
+
+/**
+ * @param {string[]} command
+ * @param {{topic: string, dryRun: boolean}} options
+ * @returns {Promise<number>}
+ */
+export async function execAsync(command, { topic, dryRun }) {
+  const [cmd, ...args] = command;
+  if (!cmd) {
+    throw new Error("cmd not found");
+  }
+  if (dryRun) {
+    console.log(`${chalk.green(cmd)} ${args.join(" ")}`);
+    return 0;
+  }
+  const startTime = Date.now();
+  return new Promise((resolve) => {
+    const spinner = ora(`${topic}...`).start();
+    const cp = childProcess.spawn(cmd, args, {
+      env: { FORCE_COLOR: "true", ...process.env },
+    });
+    let stdout = Buffer.from([]);
+    let stderr = Buffer.from([]);
+    cp.stdout.on("data", (data) => {
+      stdout = Buffer.concat([stdout, data]);
+    });
+    cp.stderr.on("data", (data) => {
+      stderr = Buffer.concat([stderr, data]);
+    });
+    // The 'close' event will always emit after 'exit' was already emitted, or 'error' if the child failed to spawn.
+    cp.on("close", () => {
+      process.stdout.write(stdout);
+      process.stderr.write(stderr);
+    });
+    cp.on("error", (err) => {
+      spinner.fail(
+        `${topic} got error in ${chalk.yellow(getSpentTime(startTime))}`,
+      );
+      resolve(getExitCode(err));
+    });
+    // The 'exit' event may or may not fire after an error has occurred.
+    cp.on("exit", (code, signal) => {
+      const exitCode = getExitCode({ code, signal });
+      if (exitCode === 0) {
+        spinner.succeed(
+          `${topic} succeeded in ${chalk.yellow(getSpentTime(startTime))}`,
+        );
+      } else {
+        spinner.fail(
+          `${topic} failed in ${chalk.yellow(getSpentTime(startTime))}`,
+        );
+      }
+      resolve(exitCode);
+    });
+    process.on("SIGINT", () => !cp.killed && cp.kill("SIGINT"));
+    process.on("SIGTERM", () => !cp.killed && cp.kill("SIGTERM"));
+  });
+}
+
+/**
+ * @param {object} error
+ */
+function getExitCode(error) {
+  if ("signal" in error && error.signal === "SIGINT") {
+    return 2;
+  }
+  if ("signal" in error && error.signal === "SIGTERM") {
+    return 15;
+  }
+  if ("code" in error && typeof error.code === "number") {
+    return error.code;
+  }
+  return 1;
+}
+
+/**
+ * @param {string} moduleName `eslint` or `prettier` or `@commitlint/cli` or `lint-staged`
+ * @param {string} cliName
+ */
+export async function getBinPath(moduleName, cliName = moduleName) {
+  const packageJsonPath = createRequire(import.meta.url).resolve(
+    `${moduleName}/package.json`,
+  );
+  /** @type {any} */
+  const packageJson = JSON.parse(await fs.readFile(packageJsonPath, "utf8"));
+  const modulePath = packageJsonPath.slice(0, -"/package.json".length);
+  const binPath =
+    typeof packageJson.bin === "string"
+      ? packageJson.bin
+      : packageJson.bin[cliName];
+  return path.resolve(modulePath, binPath);
+}

package/tsconfig/cjs.json

@@ -0,0 +1,3 @@
+{
+  "extends": "@fenge/tsconfig/cjs.json"
+}

package/tsconfig/esm.json

@@ -0,0 +1,3 @@
+{
+  "extends": "@fenge/tsconfig/esm.json"
+}

package/tsconfig/tsconfig.json

@@ -0,0 +1,3 @@
+{
+  "extends": "@fenge/tsconfig/tsconfig.json"
+}

package/tsconfig.json

@@ -1,3 +1,3 @@
 {
-  "extends": "../../tsconfig"
+  "extends": "./tsconfig/tsconfig.json"
 }

package/types/index.d.ts

@@ -0,0 +1 @@
+import "@fenge/types";