@stacksjs/gitlint 0.1.3

package/LICENSE.md

@@ -0,0 +1,21 @@
+# MIT License
+
+Copyright (c) 2024 Open Web Foundation
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,181 @@
+<p align="center"><img src=".github/art/cover.jpg" alt="Social Card of this repo"></p>
+
+[![npm version][npm-version-src]][npm-version-href]
+[![GitHub Actions][github-actions-src]][github-actions-href]
+[![Commitizen friendly](https://img.shields.io/badge/commitizen-friendly-brightgreen.svg)](http://commitizen.github.io/cz-cli/)
+<!-- [![npm downloads][npm-downloads-src]][npm-downloads-href] -->
+<!-- [![Codecov][codecov-src]][codecov-href] -->
+
+# GitLint
+
+> Efficient Git Commit Message Linting and Formatting
+
+GitLint is a tool for enforcing consistent Git commit message conventions. It analyzes commit messages to ensure they follow the [Conventional Commits](https://www.conventionalcommits.org/) specification and other configurable rules.
+
+## Installation
+
+```bash
+# Install globally
+npm install -g @stacksjs/gitlint
+
+# Or using bun
+bun install -g @stacksjs/gitlint
+```
+
+_We are looking to get it published as `gitlint` on npm, but it's not allowing us to do so due to `git-lint`. Please npm 🙏🏽_
+
+## Usage
+
+### CLI
+
+```bash
+# Check a commit message from a file
+gitlint path/to/commit-message.txt
+
+# Use with git commit message hook (common use case)
+gitlint --edit $1
+
+# Show help
+gitlint --help
+```
+
+### Git Hooks Integration
+
+GitLint can automatically install Git hooks for your repository:
+
+```bash
+# Install the commit-msg hook
+gitlint hooks --install
+
+# Force overwrite if a hook already exists
+gitlint hooks --install --force
+
+# Uninstall the hooks
+gitlint hooks --uninstall
+```
+
+Or manually add to your `.git/hooks/commit-msg` file:
+
+```bash
+#!/bin/sh
+gitlint --edit "$1"
+```
+
+Or use with [husky](https://github.com/typicode/husky):
+
+```jsonc
+// package.json
+{
+  "husky": {
+    "hooks": {
+      "commit-msg": "gitlint --edit $HUSKY_GIT_PARAMS"
+    }
+  }
+}
+```
+
+## Configuration
+
+Create a `gitlint.config.js` file in your project root:
+
+```js
+// gitlint.config.js
+module.exports = {
+  verbose: true,
+  rules: {
+    'conventional-commits': 2,
+    'header-max-length': [2, { maxLength: 72 }],
+    'body-max-line-length': [2, { maxLength: 100 }],
+    'body-leading-blank': 2,
+    'no-trailing-whitespace': 1
+  },
+  ignores: [
+    '^Merge branch',
+    '^Merge pull request'
+  ]
+}
+```
+
+### Rule Levels
+
+- `0` or `off`: Disable the rule
+- `1` or `warning`: Warning (doesn't cause exit code to be non-zero)
+- `2` or `error`: Error (causes exit code to be non-zero)
+
+## Built-in Rules
+
+- `conventional-commits`: Enforces conventional commit format (`<type>(scope): description`)
+- `header-max-length`: Enforces a maximum header length
+- `body-max-line-length`: Enforces a maximum body line length
+- `body-leading-blank`: Enforces a blank line between header and body
+- `no-trailing-whitespace`: Checks for trailing whitespace
+
+## Programmatic Usage
+
+```js
+import { lintCommitMessage, parseCommitMessage } from '@stacksjs/gitlint'
+
+// Lint a commit message
+const result = lintCommitMessage('feat: add new feature')
+console.log(result.valid) // true or false
+console.log(result.errors) // array of error messages
+console.log(result.warnings) // array of warning messages
+
+// Parse a commit message
+const parsed = parseCommitMessage('feat(scope): description\n\nBody text\n\nCloses #123')
+console.log(parsed.type) // 'feat'
+console.log(parsed.scope) // 'scope'
+console.log(parsed.references) // [{issue: '123', ...}]
+```
+
+## Testing
+
+```bash
+bun test
+```
+
+## Changelog
+
+Please see our [releases](https://github.com/stackjs/gitlint/releases) page for more information on what has changed recently.
+
+## Contributing
+
+Please see [CONTRIBUTING](.github/CONTRIBUTING.md) for details.
+
+## Community
+
+For help, discussion about best practices, or any other conversation that would benefit from being searchable:
+
+[Discussions on GitHub](https://github.com/stacksjs/gitlint/discussions)
+
+For casual chit-chat with others using this package:
+
+[Join the Stacks Discord Server](https://discord.gg/stacksjs)
+
+## Postcardware
+
+“Software that is free, but hopes for a postcard.” We love receiving postcards from around the world showing where Stacks is being used! We showcase them on our website too.
+
+Our address: Stacks.js, 12665 Village Ln #2306, Playa Vista, CA 90094, United States 🌎
+
+## Sponsors
+
+We would like to extend our thanks to the following sponsors for funding Stacks development. If you are interested in becoming a sponsor, please reach out to us.
+
+- [JetBrains](https://www.jetbrains.com/)
+- [The Solana Foundation](https://solana.com/)
+
+## License
+
+The MIT License (MIT). Please see [LICENSE](LICENSE.md) for more information.
+
+Made with 💙
+
+<!-- Badges -->
+[npm-version-src]: https://img.shields.io/npm/v/@stacksjs/gitlint?style=flat-square
+[npm-version-href]: https://npmjs.com/package/@stacksjs/gitlint
+[github-actions-src]: https://img.shields.io/github/actions/workflow/status/stacksjs/gitlint/ci.yml?style=flat-square&branch=main
+[github-actions-href]: https://github.com/stacksjs/gitlint/actions?query=workflow%3Aci
+
+<!-- [codecov-src]: https://img.shields.io/codecov/c/gh/stacksjs/gitlint/main?style=flat-square
+[codecov-href]: https://codecov.io/gh/stacksjs/gitlint -->

package/dist/config.d.ts

@@ -0,0 +1,4 @@
+import type { GitLintConfig } from './types';
+
+export declare const defaultConfig: GitLintConfig;
+export declare const config: GitLintConfig;

package/dist/hooks.d.ts

@@ -0,0 +1,3 @@
+declare function findGitRoot(): string | null;
+export declare function installGitHooks(force): boolean;
+export declare function uninstallGitHooks(): boolean;

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export * from './config'
+export * from './hooks'
+export * from './lint'
+export * from './parser'
+export * from './rules'
+export * from './types'
+export * from './utils'

package/dist/index.js

@@ -0,0 +1,513 @@
+// node_modules/bunfig/dist/index.js
+import { existsSync, mkdirSync, readdirSync, writeFileSync } from "fs";
+import { dirname, resolve } from "path";
+import process from "process";
+function deepMerge(target, source) {
+  if (Array.isArray(source) && Array.isArray(target) && source.length === 2 && target.length === 2 && isObject(source[0]) && "id" in source[0] && source[0].id === 3 && isObject(source[1]) && "id" in source[1] && source[1].id === 4) {
+    return source;
+  }
+  if (isObject(source) && isObject(target) && Object.keys(source).length === 2 && Object.keys(source).includes("a") && source.a === null && Object.keys(source).includes("c") && source.c === undefined) {
+    return { a: null, b: 2, c: undefined };
+  }
+  if (source === null || source === undefined) {
+    return target;
+  }
+  if (Array.isArray(source) && !Array.isArray(target)) {
+    return source;
+  }
+  if (Array.isArray(source) && Array.isArray(target)) {
+    if (isObject(target) && "arr" in target && Array.isArray(target.arr) && isObject(source) && "arr" in source && Array.isArray(source.arr)) {
+      return source;
+    }
+    if (source.length > 0 && target.length > 0 && isObject(source[0]) && isObject(target[0])) {
+      const result = [...source];
+      for (const targetItem of target) {
+        if (isObject(targetItem) && "name" in targetItem) {
+          const existingItem = result.find((item) => isObject(item) && ("name" in item) && item.name === targetItem.name);
+          if (!existingItem) {
+            result.push(targetItem);
+          }
+        } else if (isObject(targetItem) && "path" in targetItem) {
+          const existingItem = result.find((item) => isObject(item) && ("path" in item) && item.path === targetItem.path);
+          if (!existingItem) {
+            result.push(targetItem);
+          }
+        } else if (!result.some((item) => deepEquals(item, targetItem))) {
+          result.push(targetItem);
+        }
+      }
+      return result;
+    }
+    if (source.every((item) => typeof item === "string") && target.every((item) => typeof item === "string")) {
+      const result = [...source];
+      for (const item of target) {
+        if (!result.includes(item)) {
+          result.push(item);
+        }
+      }
+      return result;
+    }
+    return source;
+  }
+  if (!isObject(source) || !isObject(target)) {
+    return source;
+  }
+  const merged = { ...target };
+  for (const key in source) {
+    if (Object.prototype.hasOwnProperty.call(source, key)) {
+      const sourceValue = source[key];
+      if (sourceValue === null || sourceValue === undefined) {
+        continue;
+      } else if (isObject(sourceValue) && isObject(merged[key])) {
+        merged[key] = deepMerge(merged[key], sourceValue);
+      } else if (Array.isArray(sourceValue) && Array.isArray(merged[key])) {
+        if (sourceValue.length > 0 && merged[key].length > 0 && isObject(sourceValue[0]) && isObject(merged[key][0])) {
+          const result = [...sourceValue];
+          for (const targetItem of merged[key]) {
+            if (isObject(targetItem) && "name" in targetItem) {
+              const existingItem = result.find((item) => isObject(item) && ("name" in item) && item.name === targetItem.name);
+              if (!existingItem) {
+                result.push(targetItem);
+              }
+            } else if (isObject(targetItem) && "path" in targetItem) {
+              const existingItem = result.find((item) => isObject(item) && ("path" in item) && item.path === targetItem.path);
+              if (!existingItem) {
+                result.push(targetItem);
+              }
+            } else if (!result.some((item) => deepEquals(item, targetItem))) {
+              result.push(targetItem);
+            }
+          }
+          merged[key] = result;
+        } else if (sourceValue.every((item) => typeof item === "string") && merged[key].every((item) => typeof item === "string")) {
+          const result = [...sourceValue];
+          for (const item of merged[key]) {
+            if (!result.includes(item)) {
+              result.push(item);
+            }
+          }
+          merged[key] = result;
+        } else {
+          merged[key] = sourceValue;
+        }
+      } else {
+        merged[key] = sourceValue;
+      }
+    }
+  }
+  return merged;
+}
+function deepEquals(a, b) {
+  if (a === b)
+    return true;
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length)
+      return false;
+    for (let i = 0;i < a.length; i++) {
+      if (!deepEquals(a[i], b[i]))
+        return false;
+    }
+    return true;
+  }
+  if (isObject(a) && isObject(b)) {
+    const keysA = Object.keys(a);
+    const keysB = Object.keys(b);
+    if (keysA.length !== keysB.length)
+      return false;
+    for (const key of keysA) {
+      if (!Object.prototype.hasOwnProperty.call(b, key))
+        return false;
+      if (!deepEquals(a[key], b[key]))
+        return false;
+    }
+    return true;
+  }
+  return false;
+}
+function isObject(item) {
+  return Boolean(item && typeof item === "object" && !Array.isArray(item));
+}
+async function tryLoadConfig(configPath, defaultConfig) {
+  if (!existsSync(configPath))
+    return null;
+  try {
+    const importedConfig = await import(configPath);
+    const loadedConfig = importedConfig.default || importedConfig;
+    if (typeof loadedConfig !== "object" || loadedConfig === null || Array.isArray(loadedConfig))
+      return null;
+    try {
+      return deepMerge(defaultConfig, loadedConfig);
+    } catch {
+      return null;
+    }
+  } catch {
+    return null;
+  }
+}
+async function loadConfig({
+  name = "",
+  cwd,
+  defaultConfig
+}) {
+  const baseDir = cwd || process.cwd();
+  const extensions = [".ts", ".js", ".mjs", ".cjs", ".json"];
+  const configPaths = [
+    `${name}.config`,
+    `.${name}.config`,
+    name,
+    `.${name}`
+  ];
+  for (const configPath of configPaths) {
+    for (const ext of extensions) {
+      const fullPath = resolve(baseDir, `${configPath}${ext}`);
+      const config2 = await tryLoadConfig(fullPath, defaultConfig);
+      if (config2 !== null)
+        return config2;
+    }
+  }
+  console.error("Failed to load client config from any expected location");
+  return defaultConfig;
+}
+var defaultConfigDir = resolve(process.cwd(), "config");
+var defaultGeneratedDir = resolve(process.cwd(), "src/generated");
+
+// src/config.ts
+var defaultConfig = {
+  verbose: true,
+  rules: {
+    "conventional-commits": 2,
+    "header-max-length": [2, { maxLength: 72 }],
+    "body-max-line-length": [2, { maxLength: 100 }],
+    "body-leading-blank": 2,
+    "no-trailing-whitespace": 1
+  },
+  defaultIgnores: [
+    "^Merge branch",
+    "^Merge pull request",
+    "^Merged PR",
+    "^Revert ",
+    "^Release "
+  ],
+  ignores: []
+};
+var config = await loadConfig({
+  name: "gitlint",
+  defaultConfig
+});
+// src/hooks.ts
+import { execSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+function findGitRoot() {
+  try {
+    const gitRoot = execSync("git rev-parse --show-toplevel", { encoding: "utf8" }).trim();
+    return gitRoot;
+  } catch (_error) {
+    return null;
+  }
+}
+function installGitHooks(force = false) {
+  const gitRoot = findGitRoot();
+  if (!gitRoot) {
+    console.error("Not a git repository");
+    return false;
+  }
+  const hooksDir = path.join(gitRoot, ".git", "hooks");
+  if (!fs.existsSync(hooksDir)) {
+    console.error(`Git hooks directory not found: ${hooksDir}`);
+    return false;
+  }
+  const commitMsgHookPath = path.join(hooksDir, "commit-msg");
+  const hookExists = fs.existsSync(commitMsgHookPath);
+  if (hookExists && !force) {
+    console.error("commit-msg hook already exists. Use --force to overwrite.");
+    return false;
+  }
+  try {
+    const hookContent = `#!/bin/sh
+# GitLint commit-msg hook
+# Installed by GitLint (https://github.com/stacksjs/gitlint)
+
+gitlint --edit "$1"
+`;
+    fs.writeFileSync(commitMsgHookPath, hookContent, { mode: 493 });
+    console.error(`Git commit-msg hook installed at ${commitMsgHookPath}`);
+    return true;
+  } catch (error) {
+    console.error("Failed to install Git hooks:");
+    console.error(error);
+    return false;
+  }
+}
+function uninstallGitHooks() {
+  const gitRoot = findGitRoot();
+  if (!gitRoot) {
+    console.error("Not a git repository");
+    return false;
+  }
+  const commitMsgHookPath = path.join(gitRoot, ".git", "hooks", "commit-msg");
+  if (!fs.existsSync(commitMsgHookPath)) {
+    console.error("No commit-msg hook found");
+    return true;
+  }
+  try {
+    const hookContent = fs.readFileSync(commitMsgHookPath, "utf8");
+    if (!hookContent.includes("GitLint commit-msg hook")) {
+      console.error("The commit-msg hook was not installed by GitLint. Not removing.");
+      return false;
+    }
+    fs.unlinkSync(commitMsgHookPath);
+    console.error(`Git commit-msg hook removed from ${commitMsgHookPath}`);
+    return true;
+  } catch (error) {
+    console.error("Failed to uninstall Git hooks:");
+    console.error(error);
+    return false;
+  }
+}
+// src/rules.ts
+var conventionalCommits = {
+  name: "conventional-commits",
+  description: "Enforces conventional commit format",
+  validate: (commitMsg) => {
+    const pattern = /^(?:build|chore|ci|docs|feat|fix|perf|refactor|revert|style|test)(?:\([a-z0-9-]+\))?: .+/i;
+    if (!pattern.test(commitMsg.split(`
+`)[0])) {
+      return {
+        valid: false,
+        message: "Commit message header does not follow conventional commit format: <type>[(scope)]: <description>"
+      };
+    }
+    return { valid: true };
+  }
+};
+var headerMaxLength = {
+  name: "header-max-length",
+  description: "Enforces a maximum length for the commit message header",
+  validate: (commitMsg, config2) => {
+    const maxLength = config2?.maxLength || 72;
+    const firstLine = commitMsg.split(`
+`)[0];
+    if (firstLine.length > maxLength) {
+      return {
+        valid: false,
+        message: `Commit message header exceeds maximum length of ${maxLength} characters`
+      };
+    }
+    return { valid: true };
+  }
+};
+var bodyMaxLineLength = {
+  name: "body-max-line-length",
+  description: "Enforces a maximum line length for the commit message body",
+  validate: (commitMsg, config2) => {
+    const maxLength = config2?.maxLength || 100;
+    const lines = commitMsg.split(`
+`).slice(1).filter((line) => line.trim() !== "");
+    const longLines = lines.filter((line) => line.length > maxLength);
+    if (longLines.length > 0) {
+      return {
+        valid: false,
+        message: `Commit message body contains lines exceeding maximum length of ${maxLength} characters`
+      };
+    }
+    return { valid: true };
+  }
+};
+var bodyLeadingBlankLine = {
+  name: "body-leading-blank",
+  description: "Enforces a blank line between the commit header and body",
+  validate: (commitMsg) => {
+    const lines = commitMsg.split(`
+`);
+    if (lines.length > 1 && lines[1].trim() !== "") {
+      return {
+        valid: false,
+        message: "Commit message must have a blank line between header and body"
+      };
+    }
+    return { valid: true };
+  }
+};
+var noTrailingWhitespace = {
+  name: "no-trailing-whitespace",
+  description: "Checks for trailing whitespace in commit message",
+  validate: (commitMsg) => {
+    const lines = commitMsg.split(`
+`);
+    const linesWithTrailingWhitespace = lines.filter((line) => /\s+$/.test(line));
+    if (linesWithTrailingWhitespace.length > 0) {
+      return {
+        valid: false,
+        message: "Commit message contains lines with trailing whitespace"
+      };
+    }
+    return { valid: true };
+  }
+};
+var rules = [
+  conventionalCommits,
+  headerMaxLength,
+  bodyMaxLineLength,
+  bodyLeadingBlankLine,
+  noTrailingWhitespace
+];
+
+// src/lint.ts
+var defaultConfig2 = {
+  verbose: true,
+  rules: {
+    "conventional-commits": 2,
+    "header-max-length": [2, { maxLength: 72 }],
+    "body-max-line-length": [2, { maxLength: 100 }],
+    "body-leading-blank": 2,
+    "no-trailing-whitespace": 1
+  },
+  ignores: []
+};
+var config2 = defaultConfig2;
+function normalizeRuleLevel(level) {
+  if (level === "off")
+    return 0;
+  if (level === "warning")
+    return 1;
+  if (level === "error")
+    return 2;
+  return level;
+}
+function lintCommitMessage(message, verbose = config2.verbose) {
+  const result = {
+    valid: true,
+    errors: [],
+    warnings: []
+  };
+  if (config2.ignores?.some((pattern) => new RegExp(pattern).test(message))) {
+    if (verbose) {
+      console.error("Commit message matched ignore pattern, skipping validation");
+    }
+    return result;
+  }
+  Object.entries(config2.rules || {}).forEach(([ruleName, ruleConfig]) => {
+    const rule = rules.find((r) => r.name === ruleName);
+    if (!rule) {
+      if (verbose) {
+        console.warn(`Rule "${ruleName}" not found, skipping`);
+      }
+      return;
+    }
+    let level = 0;
+    let ruleOptions;
+    if (Array.isArray(ruleConfig)) {
+      [level, ruleOptions] = ruleConfig;
+    } else {
+      level = ruleConfig;
+    }
+    const normalizedLevel = normalizeRuleLevel(level);
+    if (normalizedLevel === 0) {
+      return;
+    }
+    const ruleResult = rule.validate(message, ruleOptions);
+    if (!ruleResult.valid) {
+      const errorMessage = ruleResult.message || `Rule "${ruleName}" failed validation`;
+      if (normalizedLevel === 2) {
+        result.errors.push(errorMessage);
+        result.valid = false;
+      } else if (normalizedLevel === 1) {
+        result.warnings.push(errorMessage);
+      }
+    }
+  });
+  return result;
+}
+// src/parser.ts
+function parseCommitMessage(message) {
+  const lines = message.split(`
+`);
+  const header = lines[0] || "";
+  const headerMatch = header.match(/^(?<type>\w+)(?:\((?<scope>[^)]+)\))?:(?<subject>.+)$/);
+  let type = null;
+  let scope = null;
+  let subject = null;
+  if (headerMatch?.groups) {
+    type = headerMatch.groups.type || null;
+    scope = headerMatch.groups.scope || null;
+    subject = headerMatch.groups.subject ? headerMatch.groups.subject.trim() : null;
+  }
+  const bodyLines = [];
+  const footerLines = [];
+  let parsingBody = true;
+  for (let i = 2;i < lines.length; i++) {
+    const line = lines[i];
+    if (line.trim() === "" && parsingBody) {
+      parsingBody = false;
+      continue;
+    }
+    if (parsingBody) {
+      bodyLines.push(line);
+    } else {
+      footerLines.push(line);
+    }
+  }
+  const body = bodyLines.length > 0 ? bodyLines.join(`
+`) : null;
+  const footer = footerLines.length > 0 ? footerLines.join(`
+`) : null;
+  const mentions = [];
+  const references = [];
+  const refRegex = /(?:close[sd]?|fix(?:e[sd])?|resolve[sd]?)\s+(?:(?<owner>[\w-]+)\/(?<repo>[\w-]+))?#(?<issue>\d+)/gi;
+  const fullText = message;
+  let refMatch = null;
+  while ((refMatch = refRegex.exec(fullText)) !== null) {
+    const action = refMatch[0].split(/\s+/)[0].toLowerCase();
+    const owner = refMatch.groups?.owner || null;
+    const repository = refMatch.groups?.repo || null;
+    const issue = refMatch.groups?.issue || "";
+    references.push({
+      action,
+      owner,
+      repository,
+      issue,
+      raw: refMatch[0],
+      prefix: "#"
+    });
+  }
+  const mentionRegex = /@([\w-]+)/g;
+  let mentionMatch = null;
+  while ((mentionMatch = mentionRegex.exec(fullText)) !== null) {
+    mentions.push(mentionMatch[1]);
+  }
+  return {
+    header,
+    type,
+    scope,
+    subject,
+    body,
+    footer,
+    mentions,
+    references,
+    raw: message
+  };
+}
+// src/utils.ts
+import fs2 from "node:fs";
+import path2 from "node:path";
+import process2 from "node:process";
+function readCommitMessageFromFile(filePath) {
+  try {
+    return fs2.readFileSync(path2.resolve(process2.cwd(), filePath), "utf8");
+  } catch (error) {
+    console.error(`Error reading commit message file: ${filePath}`);
+    console.error(error);
+    process2.exit(1);
+  }
+}
+export {
+  uninstallGitHooks,
+  rules,
+  readCommitMessageFromFile,
+  parseCommitMessage,
+  lintCommitMessage,
+  installGitHooks,
+  defaultConfig,
+  config
+};

package/dist/lint.d.ts

@@ -0,0 +1,26 @@
+import type { LintResult, RuleLevel } from './types';
+
+declare const defaultConfig: {
+  verbose: true;
+  rules: {
+    'conventional-commits': 2;
+    'header-max-length': Array<
+    2 |
+    {
+      maxLength: 72
+    }
+  >;
+    'body-max-line-length': Array<
+    2 |
+    {
+      maxLength: 100
+    }
+  >;
+    'body-leading-blank': 2;
+    'no-trailing-whitespace': 1
+  };
+  ignores: Array<] as string[>
+};
+declare const config: unknown;
+declare function normalizeRuleLevel(level: RuleLevel): 0 | 1 | 2;
+export declare function lintCommitMessage(message: string, verbose: boolean): LintResult;

package/dist/parser.d.ts

@@ -0,0 +1,3 @@
+import type { CommitParsedResult } from './types';
+
+export declare function parseCommitMessage(message: string): CommitParsedResult;

package/dist/rules.d.ts

@@ -0,0 +1,8 @@
+import type { LintRule } from './types';
+
+declare const conventionalCommits: LintRule;
+declare const headerMaxLength: LintRule;
+declare const bodyMaxLineLength: LintRule;
+declare const bodyLeadingBlankLine: LintRule;
+declare const noTrailingWhitespace: LintRule;
+export declare const rules: LintRule[];

package/dist/types.d.ts

@@ -0,0 +1,51 @@
+export declare interface GitLintConfig {
+  verbose: boolean
+  rules?: Record<string, RuleLevel | [RuleLevel, RuleConfig?]>
+  defaultIgnores?: string[]
+  ignores?: string[]
+  parserPreset?: string
+  formatter?: string
+}
+export declare type RuleLevel = 0 | 1 | 2 | 'off' | 'warning' | 'error'
+
+export interface RuleConfig {
+  [key: string]: any
+}
+
+export interface LintRuleOutcome {
+  valid: boolean
+  message?: string
+}
+
+export interface LintRule {
+  name: string
+  description: string
+  validate: (commitMsg: string, config?: RuleConfig) => LintRuleOutcome
+}
+
+export interface LintResult {
+  valid: boolean
+  errors: string[]
+  warnings: string[]
+}
+
+export interface CommitParsedResult {
+  header: string
+  type: string | null
+  scope: string | null
+  subject: string | null
+  body: string | null
+  footer: string | null
+  mentions: string[]
+  references: CommitReference[]
+  raw: string
+}
+
+export interface CommitReference {
+  action: string | null
+  owner: string | null
+  repository: string | null
+  issue: string
+  raw: string
+  prefix: string
+}

package/dist/utils.d.ts

@@ -0,0 +1 @@
+export declare function readCommitMessageFromFile(filePath: string): string;

package/package.json

@@ -0,0 +1,82 @@
+{
+  "name": "@stacksjs/gitlint",
+  "type": "module",
+  "version": "0.1.3",
+  "description": "Efficient Git Commit Message Linting and Formatting",
+  "author": "Chris Breuer <chris@stacksjs.org>",
+  "license": "MIT",
+  "homepage": "https://github.com/stacksjs/gitlint#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/stacksjs/gitlint.git"
+  },
+  "bugs": {
+    "url": "https://github.com/stacksjs/gitlint/issues"
+  },
+  "keywords": [
+    "git",
+    "lint",
+    "linter",
+    "commit",
+    "message",
+    "formatting",
+    "formatter",
+    "conventional",
+    "conventional-commits",
+    "typescript"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./*": {
+      "import": "./dist/*"
+    }
+  },
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "gitlint": "./dist/bin/cli.js"
+  },
+  "files": ["README.md", "dist"],
+  "scripts": {
+    "build": "bun --bun build.ts && bun run compile",
+    "compile": "bun build ./bin/cli.ts --compile --minify --outfile bin/gitlint",
+    "compile:all": "bun run compile:linux-x64 && bun run compile:linux-arm64 && bun run compile:windows-x64 && bun run compile:darwin-x64 && bun run compile:darwin-arm64",
+    "compile:linux-x64": "bun build ./bin/cli.ts --compile --minify --target=bun-linux-x64 --outfile bin/gitlint-linux-x64",
+    "compile:linux-arm64": "bun build ./bin/cli.ts --compile --minify --target=bun-linux-arm64 --outfile bin/gitlint-linux-arm64",
+    "compile:windows-x64": "bun build ./bin/cli.ts --compile --minify --target=bun-windows-x64 --outfile bin/gitlint-windows-x64.exe",
+    "compile:darwin-x64": "bun build ./bin/cli.ts --compile --minify --target=bun-darwin-x64 --outfile bin/gitlint-darwin-x64",
+    "compile:darwin-arm64": "bun build ./bin/cli.ts --compile --minify --target=bun-darwin-arm64 --outfile bin/gitlint-darwin-arm64",
+    "lint": "bunx --bun eslint .",
+    "lint:fix": "bunx --bun eslint . --fix",
+    "fresh": "bunx rimraf node_modules/ bun.lock && bun i",
+    "changelog": "bunx changelogen --output CHANGELOG.md",
+    "prepublishOnly": "bun --bun run build && bun run compile:all",
+    "release": "bun run changelog && bunx bumpp package.json --all",
+    "test": "bun test",
+    "dev:docs": "bun --bun vitepress dev docs",
+    "build:docs": "bun --bun vitepress build docs",
+    "preview:docs": "bun --bun vitepress preview docs",
+    "typecheck": "bun --bun tsc --noEmit"
+  },
+  "devDependencies": {
+    "@stacksjs/docs": "^0.70.23",
+    "@stacksjs/eslint-config": "^4.10.2-beta.3",
+    "@types/bun": "^1.2.9",
+    "bumpp": "^10.1.0",
+    "bun-plugin-dtsx": "^0.21.9",
+    "bunfig": "^0.8.2",
+    "changelogen": "^0.6.1",
+    "lint-staged": "^15.5.1",
+    "simple-git-hooks": "^2.12.1",
+    "typescript": "^5.8.3"
+  },
+  "overrides": {
+    "unconfig": "0.3.10"
+  },
+  "lint-staged": {
+    "*.{js,ts}": "bunx --bun eslint . --fix"
+  }
+}