@abelspithost/commitlint 0.0.1

package/LICENSE

@@ -0,0 +1,15 @@
+ISC License
+
+Copyright (c) 2026 Abel Spithost
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.

package/README.md

@@ -0,0 +1,137 @@
+# @abelspithost/commitlint
+
+A shared [commitlint](https://commitlint.js.org/) preset that extends `@commitlint/config-conventional` with stricter defaults, plus a CLI to set everything up in one command.
+
+## What's included
+
+- Commitlint configuration that extends `@commitlint/config-conventional`
+- Scope is optional by default
+- A `createConfig` helper to customize allowed types and scopes (providing scopes makes them mandatory)
+- An `init` CLI that installs and configures commitlint + husky automatically
+- Automatic package manager detection (npm, yarn, pnpm, bun)
+
+## Quick setup
+
+Run the init command in your project root:
+
+```sh
+npx -p @abelspithost/commitlint init
+```
+
+The CLI automatically detects your package manager by looking for `bun.lockb`/`bun.lock`, `pnpm-lock.yaml`, `yarn.lock`, or falling back to npm. It will:
+
+1. Install `husky`, `@commitlint/cli`, and `@abelspithost/commitlint` as dev dependencies
+2. Initialize husky
+3. Remove the default `pre-commit` hook created by husky
+4. Create a `.husky/commit-msg` hook (using the correct runner for your package manager)
+5. Generate a `commitlint.config.ts` that re-exports the preset (skipped if one already exists)
+
+## Manual setup (npm)
+
+Install the dependencies:
+
+```sh
+npm install --save-dev husky @commitlint/cli @abelspithost/commitlint
+```
+
+Create a `commitlint.config.ts` in your project root:
+
+```ts
+export { default } from '@abelspithost/commitlint';
+```
+
+Set up husky and add the commit-msg hook:
+
+```sh
+npx husky init
+```
+
+Then create a `.husky/commit-msg` file with the following content:
+
+```sh
+npx --no -- commitlint --edit $1
+```
+
+## Using `createConfig`
+
+Use the `createConfig` helper to customize allowed scopes and types:
+
+```ts
+import { createConfig } from '@abelspithost/commitlint';
+
+export default createConfig({
+  scopes: ['api', 'ui', 'core'],
+});
+```
+
+### Options
+
+| Option   | Type       | Default        | Description                          |
+| -------- | ---------- | -------------- | ------------------------------------ |
+| `scopes` | `string[]` | —              | Restrict commits to these scopes (makes scope mandatory) |
+| `types`  | `string[]` | `COMMIT_TYPES` | Override the allowed commit types     |
+
+When `scopes` is omitted, scope is optional and any value is accepted. When `scopes` is provided, a scope becomes **required** and must be one of the listed values. When `types` is omitted, it defaults to the built-in `COMMIT_TYPES`.
+
+### Examples
+
+```ts
+// Restrict scopes only
+import { createConfig } from '@abelspithost/commitlint';
+
+export default createConfig({
+  scopes: ['api', 'ui', 'core', 'docs'],
+});
+```
+
+```ts
+// Custom types and scopes
+import { createConfig } from '@abelspithost/commitlint';
+
+export default createConfig({
+  scopes: ['api', 'ui'],
+  types: ['feat', 'fix', 'chore'],
+});
+```
+
+## Extending the preset manually
+
+Import the default config and spread it into your own configuration in `commitlint.config.ts`:
+
+```ts
+import baseConfig, { RuleConfigSeverity, type UserConfig } from '@abelspithost/commitlint';
+
+const configuration: UserConfig = {
+  ...baseConfig,
+  rules: {
+    ...baseConfig.rules,
+    // require a scope in this project
+    'scope-empty': [RuleConfigSeverity.Error, 'never'],
+  },
+};
+
+export default configuration;
+```
+
+`RuleConfigSeverity` and `UserConfig` are re-exported from this package so you don't need to install `@commitlint/types` separately.
+
+## Commit message format
+
+Commits must follow the [Conventional Commits](https://www.conventionalcommits.org/) format:
+
+```
+type: description
+type(scope): description
+```
+
+### Allowed types
+
+`build`, `chore`, `ci`, `docs`, `feat`, `fix`, `perf`, `refactor`, `revert`, `style`, `test`
+
+### Examples
+
+```
+feat: add login endpoint
+fix(api): handle null response from user service
+docs(readme): add installation instructions
+```

package/bin/cli.mjs

@@ -0,0 +1,103 @@
+#!/usr/bin/env node
+import { execSync } from 'node:child_process';
+import { existsSync, unlinkSync, writeFileSync } from 'node:fs';
+
+function run(cmd) {
+  return execSync(cmd, { stdio: 'inherit' });
+}
+
+function step(description, fn) {
+  try {
+    fn();
+  } catch {
+    console.error(`\nFailed to ${description}. Please check the error above and retry.`);
+    process.exit(1);
+  }
+}
+
+function detectPackageManager() {
+  if (existsSync('bun.lockb') || existsSync('bun.lock')) return 'bun';
+  if (existsSync('pnpm-lock.yaml')) return 'pnpm';
+  if (existsSync('yarn.lock')) return 'yarn';
+  return 'npm';
+}
+
+function installCommand(pm, deps) {
+  const joined = deps.join(' ');
+  switch (pm) {
+    case 'bun':
+      return `bun add -D ${joined}`;
+    case 'pnpm':
+      return `pnpm add -D ${joined}`;
+    case 'yarn':
+      return `yarn add -D ${joined}`;
+    default:
+      return `npm install --save-dev ${joined}`;
+  }
+}
+
+const pm = detectPackageManager();
+const DEPS = ['husky', '@commitlint/cli', '@abelspithost/commitlint'];
+
+console.log(`Setting up commitlint with husky (using ${pm})...\n`);
+
+step('install dependencies', () => {
+  run(installCommand(pm, DEPS));
+});
+
+step('initialize husky', () => {
+  let scriptBase;
+  switch (pm) {
+    case 'bun':
+      scriptBase = 'bunx';
+      break;
+    case 'pnpm':
+      scriptBase = 'pnpm exec';
+      break;
+    case 'yarn':
+      scriptBase = 'yarn run';
+      break;
+    default:
+      scriptBase = 'npx';
+  }
+  run(`${scriptBase} husky init`);
+});
+
+step('remove default pre-commit hook', () => {
+  const preCommit = '.husky/pre-commit';
+  if (existsSync(preCommit)) {
+    unlinkSync(preCommit);
+  }
+});
+
+step('create commit-msg hook', () => {
+  let runner;
+  switch (pm) {
+    case 'bun':
+      runner = 'bunx --bun';
+      break;
+    case 'pnpm':
+      runner = 'pnpm exec';
+      break;
+    case 'yarn':
+      runner = 'yarn run';
+      break;
+    default:
+      runner = 'npx --no --';
+  }
+  writeFileSync('.husky/commit-msg', `${runner} commitlint --edit $1\n`);
+});
+
+step('create commitlint config', () => {
+  if (existsSync('commitlint.config.ts')) {
+    console.log('\ncommitlint.config.ts already exists, skipping');
+  } else {
+    writeFileSync(
+      'commitlint.config.ts',
+      "export { default } from '@abelspithost/commitlint';\n",
+    );
+    console.log('\nCreated commitlint.config.ts');
+  }
+});
+
+console.log('Done! Commitlint with husky is ready.');

package/bin/cli.spec.ts

@@ -0,0 +1,199 @@
+import type { MockInstance } from 'vitest';
+
+
+const mockExecSync = vi.fn();
+const mockExistsSync = vi.fn<(path: string) => boolean>();
+const mockUnlinkSync = vi.fn();
+const mockWriteFileSync = vi.fn();
+
+vi.mock('node:child_process', () => ({
+  execSync: mockExecSync,
+}));
+
+vi.mock('node:fs', () => ({
+  existsSync: mockExistsSync,
+  unlinkSync: mockUnlinkSync,
+  writeFileSync: mockWriteFileSync,
+}));
+
+async function runCli(): Promise<void> {
+  vi.resetModules();
+  // @ts-expect-error: CLI function in JavaScript
+  await import('./cli.mjs');
+}
+
+describe('cli.mjs', () => {
+  let exitSpy: MockInstance;
+
+  beforeEach(() => {
+    mockExecSync.mockReturnValue(Buffer.from(''));
+    mockExistsSync.mockReturnValue(false);
+    exitSpy = vi.spyOn(process, 'exit').mockImplementation(() => undefined as never);
+    vi.spyOn(console, 'log').mockReturnValue(undefined);
+    vi.spyOn(console, 'error').mockReturnValue(undefined);
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe('install command', () => {
+    it('runs npm install --save-dev for npm', async () => {
+      await runCli();
+
+      expect(mockExecSync).toHaveBeenCalledWith(
+        expect.stringContaining('npm install --save-dev'),
+        expect.anything(),
+      );
+    });
+
+    it('runs pnpm add -D for pnpm', async () => {
+      mockExistsSync.mockImplementation((path: string) => path === 'pnpm-lock.yaml');
+
+      await runCli();
+
+      expect(mockExecSync).toHaveBeenCalledWith(
+        expect.stringContaining('pnpm add -D'),
+        expect.anything(),
+      );
+    });
+
+    it('runs yarn add -D for yarn', async () => {
+      mockExistsSync.mockImplementation((path: string) => path === 'yarn.lock');
+
+      await runCli();
+
+      expect(mockExecSync).toHaveBeenCalledWith(
+        expect.stringContaining('yarn add -D'),
+        expect.anything(),
+      );
+    });
+
+    it('runs bun add -D for bun', async () => {
+      mockExistsSync.mockImplementation((path: string) => path === 'bun.lockb');
+
+      await runCli();
+
+      expect(mockExecSync).toHaveBeenCalledWith(
+        expect.stringContaining('bun add -D'),
+        expect.anything(),
+      );
+    });
+  });
+
+  describe('husky initialization', () => {
+    it('runs npx husky init for npm', async () => {
+      await runCli();
+
+      expect(mockExecSync).toHaveBeenCalledWith(
+        'npx husky init',
+        expect.anything(),
+      );
+    });
+
+    it('runs pnpm dlx husky init for pnpm', async () => {
+      mockExistsSync.mockImplementation((path: string) => path === 'pnpm-lock.yaml');
+
+      await runCli();
+
+      expect(mockExecSync).toHaveBeenCalledWith(
+        'pnpm exec husky init',
+        expect.anything(),
+      );
+    });
+  });
+
+  describe('pre-commit hook removal', () => {
+    it('removes the default pre-commit hook when it exists', async () => {
+      mockExistsSync.mockImplementation((path: string) => path === '.husky/pre-commit');
+
+      await runCli();
+
+      expect(mockUnlinkSync).toHaveBeenCalledWith('.husky/pre-commit');
+    });
+
+    it('skips removal when pre-commit hook does not exist', async () => {
+      await runCli();
+
+      expect(mockUnlinkSync).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('commit-msg hook', () => {
+    it('writes hook with npx runner for npm', async () => {
+      await runCli();
+
+      expect(mockWriteFileSync).toHaveBeenCalledWith(
+        '.husky/commit-msg',
+        'npx --no -- commitlint --edit $1\n',
+      );
+    });
+
+    it('writes hook with pnpm exec runner for pnpm', async () => {
+      mockExistsSync.mockImplementation((path: string) => path === 'pnpm-lock.yaml');
+
+      await runCli();
+
+      expect(mockWriteFileSync).toHaveBeenCalledWith(
+        '.husky/commit-msg',
+        'pnpm exec commitlint --edit $1\n',
+      );
+    });
+
+    it('writes hook with yarn run runner for yarn', async () => {
+      mockExistsSync.mockImplementation((path: string) => path === 'yarn.lock');
+
+      await runCli();
+
+      expect(mockWriteFileSync).toHaveBeenCalledWith(
+        '.husky/commit-msg',
+        'yarn run commitlint --edit $1\n',
+      );
+    });
+
+    it('writes hook with bunx runner for bun', async () => {
+      mockExistsSync.mockImplementation((path: string) => path === 'bun.lockb');
+
+      await runCli();
+
+      expect(mockWriteFileSync).toHaveBeenCalledWith(
+        '.husky/commit-msg',
+        'bunx --bun commitlint --edit $1\n',
+      );
+    });
+  });
+
+  describe('commitlint config', () => {
+    it('creates commitlint.config.ts with the expected export', async () => {
+      await runCli();
+
+      expect(mockWriteFileSync).toHaveBeenCalledWith(
+        'commitlint.config.ts',
+        "export { default } from '@abelspithost/commitlint';\n",
+      );
+    });
+
+    it('skips commitlint.config.ts if it already exists', async () => {
+      mockExistsSync.mockImplementation((path: string) => path === 'commitlint.config.ts');
+
+      await runCli();
+
+      expect(mockWriteFileSync).not.toHaveBeenCalledWith(
+        'commitlint.config.ts',
+        expect.anything(),
+      );
+    });
+  });
+
+  describe('error handling', () => {
+    it('calls process.exit(1) when a step fails', async () => {
+      mockExecSync.mockImplementation(() => {
+        throw new Error('command failed');
+      });
+
+      await runCli();
+
+      expect(exitSpy).toHaveBeenCalledWith(1);
+    });
+  });
+});

package/dist/config/config.d.ts

@@ -0,0 +1,45 @@
+import { type UserConfig } from '@commitlint/types';
+/**
+ * Default commitlint configuration.
+ *
+ * Extends `@commitlint/config-conventional` with stricter defaults:
+ * - Scope is optional.
+ * - Allowed types are restricted to {@link COMMIT_TYPES}.
+ *
+ * @example
+ * ```ts
+ * // commitlint.config.ts
+ * export { default } from '@abelspithost/commitlint';
+ * ```
+ */
+export declare const configuration: UserConfig;
+/**
+ * Create a customized commitlint configuration.
+ *
+ * Starts from the same base as {@link configuration} (extends
+ * `@commitlint/config-conventional`, scope optional) and lets you
+ * restrict the allowed scopes and/or override the allowed types.
+ *
+ * @param options - Configuration options.
+ * @param options.scopes - Restrict commits to these scopes. When provided,
+ *   a scope becomes **required** on every commit.
+ * @param options.types - Override the allowed commit types.
+ *   Defaults to {@link COMMIT_TYPES}.
+ * @returns A `UserConfig` object ready to be exported from
+ *   `commitlint.config.ts`.
+ *
+ * @example
+ * ```ts
+ * // commitlint.config.ts
+ * import { createConfig } from '@abelspithost/commitlint';
+ *
+ * export default createConfig({
+ *   scopes: ['api', 'ui', 'core'],
+ * });
+ * ```
+ */
+export declare function createConfig({ scopes, types, }: {
+    scopes?: string[];
+    types?: string[];
+}): UserConfig;
+//# sourceMappingURL=config.d.ts.map

package/dist/config/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/config/config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,KAAK,UAAU,EAAE,MAAM,mBAAmB,CAAC;AASxE;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,aAAa,EAAE,UAK3B,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,YAAY,CAAC,EAC3B,MAAM,EACN,KAAoB,GACrB,EAAG;IACF,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;CAClB,GAAG,UAAU,CAWb"}

package/dist/config/config.js

@@ -0,0 +1,63 @@
+import { RuleConfigSeverity } from '@commitlint/types';
+import { COMMIT_TYPES } from '../constants/commitTypes.js';
+const baseConfiguration = {
+    extends: ['@commitlint/config-conventional'],
+    formatter: '@commitlint/format',
+};
+/**
+ * Default commitlint configuration.
+ *
+ * Extends `@commitlint/config-conventional` with stricter defaults:
+ * - Scope is optional.
+ * - Allowed types are restricted to {@link COMMIT_TYPES}.
+ *
+ * @example
+ * ```ts
+ * // commitlint.config.ts
+ * export { default } from '@abelspithost/commitlint';
+ * ```
+ */
+export const configuration = {
+    ...baseConfiguration,
+    rules: {
+        'type-enum': [RuleConfigSeverity.Error, 'always', COMMIT_TYPES],
+    },
+};
+/**
+ * Create a customized commitlint configuration.
+ *
+ * Starts from the same base as {@link configuration} (extends
+ * `@commitlint/config-conventional`, scope optional) and lets you
+ * restrict the allowed scopes and/or override the allowed types.
+ *
+ * @param options - Configuration options.
+ * @param options.scopes - Restrict commits to these scopes. When provided,
+ *   a scope becomes **required** on every commit.
+ * @param options.types - Override the allowed commit types.
+ *   Defaults to {@link COMMIT_TYPES}.
+ * @returns A `UserConfig` object ready to be exported from
+ *   `commitlint.config.ts`.
+ *
+ * @example
+ * ```ts
+ * // commitlint.config.ts
+ * import { createConfig } from '@abelspithost/commitlint';
+ *
+ * export default createConfig({
+ *   scopes: ['api', 'ui', 'core'],
+ * });
+ * ```
+ */
+export function createConfig({ scopes, types = COMMIT_TYPES, }) {
+    return {
+        ...baseConfiguration,
+        rules: {
+            ...(scopes && {
+                'scope-empty': [RuleConfigSeverity.Error, 'never'],
+                'scope-enum': [RuleConfigSeverity.Error, 'always', scopes],
+            }),
+            'type-enum': [RuleConfigSeverity.Error, 'always', types],
+        },
+    };
+}
+//# sourceMappingURL=config.js.map

package/dist/config/config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.js","sourceRoot":"","sources":["../../src/config/config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAmB,MAAM,mBAAmB,CAAC;AAExE,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAE3D,MAAM,iBAAiB,GAAe;IACpC,OAAO,EAAE,CAAC,iCAAiC,CAAC;IAC5C,SAAS,EAAE,oBAAoB;CAChC,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,MAAM,aAAa,GAAe;IACvC,GAAG,iBAAiB;IACpB,KAAK,EAAE;QACL,WAAW,EAAE,CAAC,kBAAkB,CAAC,KAAK,EAAE,QAAQ,EAAE,YAAY,CAAC;KAChE;CACF,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,UAAU,YAAY,CAAC,EAC3B,MAAM,EACN,KAAK,GAAG,YAAY,GAIrB;IACC,OAAO;QACL,GAAG,iBAAiB;QACpB,KAAK,EAAE;YACL,GAAG,CAAC,MAAM,IAAI;gBACZ,aAAa,EAAE,CAAC,kBAAkB,CAAC,KAAK,EAAE,OAAO,CAAC;gBAClD,YAAY,EAAE,CAAC,kBAAkB,CAAC,KAAK,EAAE,QAAQ,EAAE,MAAM,CAAC;aAC3D,CAAC;YACF,WAAW,EAAE,CAAC,kBAAkB,CAAC,KAAK,EAAE,QAAQ,EAAE,KAAK,CAAC;SACzD;KACF,CAAC;AACJ,CAAC"}

package/dist/constants/commitTypes.d.ts

@@ -0,0 +1,7 @@
+/**
+ * The default set of allowed conventional commit types.
+ *
+ * Pass a custom array to {@link createConfig} to override.
+ */
+export declare const COMMIT_TYPES: string[];
+//# sourceMappingURL=commitTypes.d.ts.map

package/dist/constants/commitTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commitTypes.d.ts","sourceRoot":"","sources":["../../src/constants/commitTypes.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,eAAO,MAAM,YAAY,UAYxB,CAAC"}

package/dist/constants/commitTypes.js

@@ -0,0 +1,19 @@
+/**
+ * The default set of allowed conventional commit types.
+ *
+ * Pass a custom array to {@link createConfig} to override.
+ */
+export const COMMIT_TYPES = [
+    'build',
+    'ci',
+    'docs',
+    'feat',
+    'fix',
+    'perf',
+    'refactor',
+    'revert',
+    'test',
+    'chore',
+    'style',
+];
+//# sourceMappingURL=commitTypes.js.map

package/dist/constants/commitTypes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"commitTypes.js","sourceRoot":"","sources":["../../src/constants/commitTypes.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG;IAC1B,OAAO;IACP,IAAI;IACJ,MAAM;IACN,MAAM;IACN,KAAK;IACL,MAAM;IACN,UAAU;IACV,QAAQ;IACR,MAAM;IACN,OAAO;IACP,OAAO;CACR,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { RuleConfigSeverity, type UserConfig } from '@commitlint/types';
+export { COMMIT_TYPES } from './constants/commitTypes.js';
+export { configuration, configuration as default, createConfig } from './config/config.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,KAAK,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACxE,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC1D,OAAO,EAAE,aAAa,EAAE,aAAa,IAAI,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/index.js

@@ -0,0 +1,4 @@
+export { RuleConfigSeverity } from '@commitlint/types';
+export { COMMIT_TYPES } from './constants/commitTypes.js';
+export { configuration, configuration as default, createConfig } from './config/config.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAmB,MAAM,mBAAmB,CAAC;AACxE,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC1D,OAAO,EAAE,aAAa,EAAE,aAAa,IAAI,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC"}

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "@abelspithost/commitlint",
+  "version": "0.0.1",
+  "description": "Shared commitlint preset extending @commitlint/config-conventional with stricter defaults",
+  "keywords": [
+    "commitlint",
+    "commitlint-config",
+    "conventional",
+    "commits",
+    "conventional-commits",
+    "husky",
+    "git-hooks"
+  ],
+  "homepage": "https://github.com/aspithost/commitlint#readme",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/aspithost/commitlint.git"
+  },
+  "license": "ISC",
+  "author": {
+    "name": "Abel Spithost",
+    "url": "https://github.com/aspithost"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "bin": {
+    "init": "./bin/cli.mjs"
+  },
+  "files": [
+    "bin",
+    "dist"
+  ],
+  "scripts": {
+    "build": "npm run clean && tsc -p tsconfig.build.json",
+    "clean": "rimraf dist",
+    "lint": "eslint .",
+    "test:unit": "vitest",
+    "test:cov": "vitest run --coverage --coverage.reporter=text",
+    "typecheck": "tsc --noEmit",
+    "prepare": "husky"
+  },
+  "dependencies": {
+    "@commitlint/config-conventional": "^20.4.1",
+    "@commitlint/format": "^20.4.0",
+    "@commitlint/types": "^20.4.0"
+  },
+  "devDependencies": {
+    "@abelspithost/eslint-config-ts": "^0.1.3",
+    "@abelspithost/tsconfig-node": "^0.0.4",
+    "@commitlint/cli": "^20.4.1",
+    "@types/node": "^24.10.11",
+    "@vitest/coverage-v8": "^4.0.18",
+    "commitlint": "^20.4.1",
+    "eslint": "^9.39.2",
+    "husky": "^9.1.7",
+    "jiti": "^2.6.1",
+    "rimraf": "^6.1.2",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.18"
+  }
+}