pr-checkmate 1.21.14 → 1.21.15

package/.eslintrc.js

@@ -41,7 +41,7 @@ module.exports = {
     sourceType: 'module',
     project: './tsconfig.json',
   },
-  plugins: ['@typescript-eslint', 'prettier', 'import'],
+  plugins: ['@typescript-eslint', 'prettier', 'import', 'jsdoc'],
   extends: [
     'eslint:recommended',
     'plugin:@typescript-eslint/recommended',
@@ -80,6 +80,33 @@ module.exports = {
       { blankLine: 'always', prev: 'block', next: '*' },
       { blankLine: 'always', prev: '*', next: 'return' },
     ],
+    // Complexity analysis (#61)
+    complexity: ['warn', 15],
+    // Import ordering (#65)
+    'import/order': [
+      'warn',
+      {
+        groups: ['builtin', 'external', 'internal', 'parent', 'sibling', 'index'],
+        alphabetize: { order: 'asc', caseInsensitive: true },
+      },
+    ],
+    'import/no-duplicates': 'error',
+    // Documentation (#62)
+    'jsdoc/require-jsdoc': [
+      'warn',
+      {
+        publicOnly: true,
+        require: {
+          FunctionDeclaration: true,
+          MethodDefinition: true,
+          ClassDeclaration: true,
+          ArrowFunctionExpression: false,
+        },
+      },
+    ],
+    'jsdoc/check-param-names': 'warn',
+    'jsdoc/check-tag-names': 'warn',
+    'jsdoc/check-types': 'warn',
     'prettier/prettier': [
       'error',
       {

package/README.md

@@ -1,99 +1,41 @@
 # ♟️ PR CheckMate
 
 ![Build](https://img.shields.io/github/actions/workflow/status/Mybono/sdk_automation/publish.yml?branch=main&label=CI&color=blue)
-![ESLint](https://img.shields.io/npm/v/eslint?color=yellow&label=ESLint)
-![Prettier](https://img.shields.io/npm/v/prettier?color=orange&label=Prettier)
-
-> **PR CheckMate** is an npm package for automating Pull Request checks.
-> It helps teams maintain code quality by automatically validating linting, formatting, dependencies, security, and spelling before merging to `main`.
-
-## 🔍 Why PR CheckMate?
-
-* ✅ Automatic checks on every PR without extra setup.
-* ✅ No need to install ESLint, Prettier, or cspell in your project — all included.
-* ✅ Enforces a unified code style across repositories.
-* ✅ Detects unused and missing dependencies via `depcheck`.
-* ✅ Finds circular dependencies before they reach production.
-* ✅ Blocks GPL/AGPL/LGPL licensed packages from slipping in.
-* ✅ Validates PR title against Conventional Commits.
-* ✅ Warns about oversized PRs and major-behind packages.
-* ✅ Spellcheck for code, docs, and JSON with multilingual support (EN, RU, UK, HE, FR).
-* ✅ Package vulnerability check via `npm audit`.
-* ✅ Secret scanning via `gitleaks`.
-* ✅ **Delta mode** — in GitHub PR context only changed files are checked, not the entire project.
-* ✅ **Parallel execution** — all independent checks run concurrently, cutting CI time ~4×.
-* ✅ TypeScript type check — runs `tsc --noEmit`, catches type errors before merge. Skips if no `tsconfig.json` is found.
-* ✅ Diff code smells — scans PR diff for `console.*()` calls, `debugger` statements, and `TODO/FIXME/HACK/XXX` comments left in added lines.
-* ✅ PR description check — validates the PR body has at least 20 characters and includes a ticket reference (`Closes #123` or `PROJ-456` style).
-* ✅ Duplicate code detection — uses `jscpd` in delta mode (changed files in PR, or `src/` otherwise) with a 5-line / 50-token minimum threshold.
-* ✅ Diff security scan — detects XSS vectors, `eval()`/`new Function()`, prototype pollution, weak crypto, CORS wildcards, insecure HTTP calls, command injection, and SQL injection patterns in added PR lines (warning-only, delta mode).
-* ✅ Sensitive file guard — warns when the PR touches `.env` files, private keys/certificates, CI/CD pipeline configs, auth middleware, infrastructure files, or lockfiles (warning-only, PR context only).
-* ✅ PR summary comment — after `npx pr-checkmate all`, posts a summary table to the CI log and upserts a comment on the PR. No spam on repeated pushes.
-
-<br>
-> ⚠️ **Note:** Currently, PR CheckMate only supports **Node.js projects**.
-
-* [PR CheckMate](https://www.npmjs.com/package/pr-checkmate) – Zero-config CLI that automates ESLint, Prettier, spellcheck, dependency checks, and npm audit for pull requests.
-
-## 🚀 Zero-Config by Default
-
-You don't need to install or configure:
-
-* ESLint
-* Prettier
-* cspell (with multilingual dictionaries)
-* Security scanning tools
-
-> Everything works out of the box.
-<br>
-
-### 🧩 Fully Customizable
-
-Users can override:
-
-* ESLint rules and ignore patterns
-* Prettier rules
-* CSpell dictionary and ignore lists
-* Which checks run (skip flags)
-* Source code path
-
-User configuration is stored in:
-
-```text
-<project-root>/pr-checkmate.json
-```
+![npm](https://img.shields.io/npm/v/pr-checkmate?color=blue&label=npm)
+![License](https://img.shields.io/badge/license-Proprietary-lightgrey)
 
-<br>
+> **PR CheckMate** is a universal PR quality checker that runs as a single `npm install` and works across **TypeScript, JavaScript, Python, C++, Swift, and Android/Kotlin** repositories — no per-language toolchain setup required.
 
-### ⚙️ Example: pr-checkmate.json
+---
 
-```json
-{
-  "sourcePath": "src",
-  "eslint": {
-    "rules": {},
-    "ignorePatterns": []
-  },
-  "prettier": {
-    "rules": {}
-  },
-  "cspell": {
-    "words": [],
-    "ignorePaths": [],
-    "ignoreRegExpList": []
-  },
-  "documentation": {
-    "eslint": "https://eslint.org/docs/latest/rules/",
-    "typescriptEslint": "https://typescript-eslint.io/rules/",
-    "prettier": "https://prettier.io/docs/en/options.html",
-    "cspell": "https://cspell.org/configuration/"
-  }
-}
-```
+## Why PR CheckMate?
+
+Most teams wire up linters and formatters separately for each repository. PR CheckMate ships everything pre-bundled: you add one step to your GitHub Actions workflow and every check runs automatically, in parallel, on every PR.
+
+- **One package, any stack** — TypeScript, Python, C++, Swift, Android (Kotlin/Java). Language is auto-detected from your repo.
+- **Zero client tooling** — ESLint, Prettier, cspell, jscpd, gitleaks, clang-format (WASM), and Ruff (WASM) are bundled. Clients install nothing extra.
+- **Delta mode** — only changed files are checked in PR context. Full-project fallback for local runs.
+- **Parallel execution** — independent checks run concurrently (~4× faster than sequential CI).
+- **Non-intrusive** — every check can be disabled per-repo via `pr-checkmate.json`.
+
+---
 
-<br>
+## Language Support
 
-## 🛠 How It Works
+| Language | Detection | Lint | Format | Type Check | Notes |
+|---|---|---|---|---|---|
+| **TypeScript** | `tsconfig.json` | ESLint + SonarJS | Prettier | `tsc --noEmit` | Fully bundled |
+| **JavaScript** | `package.json` | ESLint | Prettier | — | Fully bundled |
+| **Python** | `pyproject.toml`, `requirements.txt` | Ruff (WASM) | Ruff (WASM) | — | Fully bundled, no Python install needed |
+| **C++** | `CMakeLists.txt` | — | clang-format (WASM) | — | Fully bundled, no clang install needed |
+| **Swift** | `Package.swift` | SwiftLint | — | — | Requires `swiftlint` on runner |
+| **Android/Kotlin** | `build.gradle`, `AndroidManifest.xml` | ktlint | — | — | Requires `ktlint` on runner |
+
+Universal checks (all languages): secret scanning, PR size, PR title, PR body, duplicate code, dead code, license compliance, markdown lint, spellcheck, sensitive file guard, diff security scan.
+
+---
+
+## Quickstart
 
 ### 1. Install
 
@@ -107,299 +49,278 @@ npm install --save-dev pr-checkmate
 npx pr-checkmate init
 ```
 
-> This creates:
->
-> * `pr-checkmate.json` — configuration file for source path and custom rules
-> * `.github/workflows/pr-checkmate.yml` — GitHub Actions workflow with per-job checks and auto-commit support
+Creates `pr-checkmate.json` and `.github/workflows/pr-checkmate.yml` tailored to the detected languages in your repo.
 
-### 3. Run Checks
+### 3. Run
 
 ```bash
-npx pr-checkmate <job>
+npx pr-checkmate all
 ```
 
-#### ⚡ Jobs
-
-| Job            | Description |
-|----------------|-------------|
-| `all`          | Run all checks in parallel (lint, deps, audit, security, circular, license, then spellcheck, pr-size, pr-title, outdated, markdown, typecheck, diff-smell, pr-body, duplicate, diff-security, sensitive-files, then prettier). Posts a PR summary comment when run in a GitHub Actions PR context. |
-| `lint`         | Lint code using ESLint |
-| `prettier`     | Format code using Prettier |
-| `deps`         | Check unused / missing dependencies via depcheck |
-| `security`     | Scan for secrets using gitleaks |
-| `spellcheck`   | Spellcheck via cspell (EN, RU, UK, HE, FR) |
-| `audit`        | Run `npm audit --audit-level=moderate` |
-| `circular`     | Detect circular dependencies via dpdm |
-| `license`      | Block GPL / AGPL / LGPL licensed packages |
-| `pr-size`      | Warn if PR exceeds 50 files or 1 000 changed lines |
-| `pr-title`     | Validate PR title against Conventional Commits format |
-| `outdated`     | Report packages that are major versions behind |
-| `markdown`     | Lint `.md`/`.mdx` files via markdownlint (warning-only, delta mode) |
-| `typecheck`    | Run `tsc --noEmit` to catch type errors (blocking). Skips automatically if no `tsconfig.json` is found. |
-| `diff-smell`   | Scan PR diff for `console.*()`, `debugger`, and `TODO/FIXME/HACK/XXX` in added lines (warning-only, delta mode) |
-| `pr-body`      | Check PR description for minimum length (20 chars) and a ticket reference (warning-only) |
-| `duplicate`    | Detect duplicate code with `jscpd` — min 5 lines / 50 tokens (warning-only, delta mode in PR context) |
-| `diff-security` | Scan PR diff for XSS vectors, `eval()`/`new Function()`, prototype pollution, weak crypto (MD5/SHA-1), CORS wildcards, insecure HTTP, command injection, and SQL injection in added lines (warning-only, delta mode, PR context only) |
-| `sensitive-files` | Detect PR changes to `.env` files, private keys/certificates, CI/CD configs, auth middleware, infrastructure files, and lockfiles (warning-only, PR context only) |
+---
 
-<br>
+## GitHub Actions — Examples by Language
 
-### ⚡ Delta Mode
+All examples follow the same structure: checkout → setup runtime (if needed) → `npm install pr-checkmate` → `npx pr-checkmate all`.
 
-In a GitHub Actions PR context, `lint`, `prettier`, `spellcheck`, `markdown`, `diff-smell`, `duplicate`, and `diff-security` automatically switch to **delta mode** — only the files changed in the PR are checked instead of the entire project. This is transparent and requires no configuration.
-
-Outside of a PR context (local runs, push workflows) the checks fall back to the full project scan.
-
-<br>
-
-## 🤖 GitHub Actions Workflow (Auto-Generated)
-
-When you run `npx pr-checkmate init`, it automatically creates `.github/workflows/pr-checkmate.yml`:
+### TypeScript / JavaScript
 
 ```yaml
-name: PR Checkmate Quality Checks
-
+name: PR CheckMate
 on:
   pull_request:
-    branches: [main, master, develop]
-    types: [opened, synchronize, reopened]
+    branches: [main]
 
 permissions:
   contents: write
   pull-requests: write
 
 jobs:
-  lint:
-    name: ESLint
+  quality:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
-        with: { ref: "${{ github.head_ref }}", fetch-depth: 0 }
+        with: { fetch-depth: 0 }
       - uses: actions/setup-node@v4
-        with: { node-version: 20 }
+        with: { node-version: 24 }
       - run: npm ci
-      - run: npx pr-checkmate lint
-        continue-on-error: true
+      - run: npx pr-checkmate all
+```
 
-  deps:
-    name: Dependency Check
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-        with: { ref: "${{ github.head_ref }}", fetch-depth: 0 }
-      - uses: actions/setup-node@v4
-        with: { node-version: 20 }
-      - run: npm ci
-      - run: npx pr-checkmate deps
-        continue-on-error: true
+---
 
-  circular-deps:
-    name: Circular Dependencies
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-        with: { ref: "${{ github.head_ref }}", fetch-depth: 0 }
-      - uses: actions/setup-node@v4
-        with: { node-version: 20 }
-      - run: npm ci
-      - run: npx pr-checkmate circular
-        continue-on-error: true
+### Python
 
-  license-check:
-    name: License Check
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-        with: { ref: "${{ github.head_ref }}", fetch-depth: 0 }
-      - uses: actions/setup-node@v4
-        with: { node-version: 20 }
-      - run: npm ci
-      - run: npx pr-checkmate license
-        continue-on-error: true
+```yaml
+name: PR CheckMate
+on:
+  pull_request:
+    branches: [main]
 
-  pr-size:
-    name: PR Size
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-        with: { ref: "${{ github.head_ref }}", fetch-depth: 0 }
-      - uses: actions/setup-node@v4
-        with: { node-version: 20 }
-      - run: npm ci
-      - run: npx pr-checkmate pr-size
-        continue-on-error: true
+permissions:
+  contents: read
+  pull-requests: write
 
-  pr-title:
-    name: PR Title Lint
+jobs:
+  quality:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
-        with: { ref: "${{ github.head_ref }}", fetch-depth: 0 }
+        with: { fetch-depth: 0 }
       - uses: actions/setup-node@v4
-        with: { node-version: 20 }
-      - run: npm ci
-      - run: npx pr-checkmate pr-title
-        continue-on-error: true
+        with: { node-version: 24 }
+      # No pip install needed — Ruff runs via bundled WASM
+      - run: npm install pr-checkmate
+      - run: npx pr-checkmate all
+```
 
-  outdated-deps:
-    name: Outdated Dependencies
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-        with: { ref: "${{ github.head_ref }}", fetch-depth: 0 }
-      - uses: actions/setup-node@v4
-        with: { node-version: 20 }
-      - run: npm ci
-      - run: npx pr-checkmate outdated
-        continue-on-error: true
+> Ruff (lint + format) runs via WASM — no Python or pip required on the runner.
 
-  markdown-lint:
-    name: Markdown Lint
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-        with: { ref: "${{ github.head_ref }}", fetch-depth: 0 }
-      - uses: actions/setup-node@v4
-        with: { node-version: 20 }
-      - run: npm ci
-      - run: npx pr-checkmate markdown
-        continue-on-error: true
+---
 
-  spellcheck:
-    name: Spellcheck
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-        with: { ref: "${{ github.head_ref }}", fetch-depth: 0 }
-      - uses: actions/setup-node@v4
-        with: { node-version: 20 }
-      - run: npm ci
-      - run: npx pr-checkmate spellcheck
-        continue-on-error: true
+### C++
+
+```yaml
+name: PR CheckMate
+on:
+  pull_request:
+    branches: [main]
 
-  security:
-    name: Security Scan
+permissions:
+  contents: write
+  pull-requests: write
+
+jobs:
+  quality:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
-        with: { ref: "${{ github.head_ref }}", fetch-depth: 0 }
+        with: { fetch-depth: 0 }
       - uses: actions/setup-node@v4
-        with: { node-version: 20 }
-      - run: npm ci
-      - run: npx pr-checkmate security
-        continue-on-error: true
+        with: { node-version: 24 }
+      # No clang install needed — clang-format runs via bundled WASM
+      - run: npm install pr-checkmate
+      - run: npx pr-checkmate all
+```
 
-  npm-audit:
-    name: NPM Audit
-    runs-on: ubuntu-latest
+> clang-format runs via WASM — no system clang or LLVM install required.
+
+---
+
+### Swift
+
+```yaml
+name: PR CheckMate
+on:
+  pull_request:
+    branches: [main]
+
+permissions:
+  contents: read
+  pull-requests: write
+
+jobs:
+  quality:
+    runs-on: macos-latest   # SwiftLint is pre-installed on macOS runners
     steps:
       - uses: actions/checkout@v4
-        with: { ref: "${{ github.head_ref }}", fetch-depth: 0 }
+        with: { fetch-depth: 0 }
       - uses: actions/setup-node@v4
-        with: { node-version: 20 }
-      - run: npm ci
-      - run: npx pr-checkmate audit
-        continue-on-error: true
+        with: { node-version: 24 }
+      - run: npm install pr-checkmate
+      - run: npx pr-checkmate all
+```
+
+> `swiftlint` is pre-installed on GitHub's `macos-latest` runner. If not available, the check is skipped automatically.
 
-  prettier:
-    name: Prettier
+---
+
+### Android / Kotlin
+
+```yaml
+name: PR CheckMate
+on:
+  pull_request:
+    branches: [main]
+
+permissions:
+  contents: read
+  pull-requests: write
+
+jobs:
+  quality:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
-        with: { ref: "${{ github.head_ref }}", fetch-depth: 0 }
+        with: { fetch-depth: 0 }
       - uses: actions/setup-node@v4
-        with: { node-version: 20 }
-      - run: npm ci
-      - run: npx pr-checkmate prettier
-        continue-on-error: true
-      - name: Auto-commit formatting changes
+        with: { node-version: 24 }
+      - name: Install ktlint
         run: |
-          git config user.name "github-actions[bot]"
-          git config user.email "github-actions[bot]@users.noreply.github.com"
-          git add -A
-          if ! git diff --cached --quiet; then
-            git commit -m "style: auto-format code with Prettier"
-            git push origin HEAD:${{ github.head_ref }}
-          fi
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          curl -sSLO https://github.com/pinterest/ktlint/releases/latest/download/ktlint
+          chmod +x ktlint
+          sudo mv ktlint /usr/local/bin/
+      - run: npm install pr-checkmate
+      - run: npx pr-checkmate all
 ```
 
-### ⚙️ GitHub Actions Permissions
+> `ktlint` is not pre-installed on Ubuntu runners — the snippet above fetches the latest release binary. If ktlint is unavailable, the check is skipped automatically.
+
+---
+
+## All Checks
+
+| Check | Phase | Description |
+|---|---|---|
+| ESLint + SonarJS + JSDoc | blocking | Lint with complexity, import order, and doc coverage rules |
+| TypeScript | blocking | `tsc --noEmit` type check |
+| Dependency Check | blocking | Unused / missing deps via depcheck |
+| NPM Audit | blocking | Vulnerability scan (`moderate`+) |
+| Circular Deps | blocking | Circular dependency detection |
+| License Check | blocking | Blocks GPL / AGPL / LGPL packages |
+| Ruff Lint | informational | Python linting via WASM |
+| SwiftLint | informational | Swift linting |
+| ktlint | informational | Kotlin linting |
+| Dead Code | informational | Unused exports (`ts-unused-exports`) |
+| Duplicate Code | informational | `jscpd` — 5 lines / 50 tokens threshold |
+| Diff Smell | informational | `console.*`, `debugger`, `TODO/FIXME` in added lines |
+| Diff Security | informational | XSS, `eval`, SQLi, weak crypto in added lines |
+| Sensitive Files | informational | `.env`, private keys, CI configs touched in PR |
+| PR Size | informational | Warns if PR > 50 files or 1 000 lines |
+| PR Title | informational | Conventional Commits format |
+| PR Body | informational | Min 20 chars + ticket reference |
+| Commitlint | informational | Commit message convention |
+| Outdated Deps | informational | Major-behind packages |
+| Markdown Lint | informational | `.md` / `.mdx` via markdownlint |
+| Spellcheck | informational | EN, ES, FR, RU, UK, HE dictionaries |
+| Prettier | format | Auto-format; commits fixes back to branch |
+| C++ Format | format | clang-format via WASM |
+| Python Format | format | Ruff formatter via WASM |
+
+---
+
+## Configuration
+
+All checks can be tuned or disabled per-repo via `pr-checkmate.json`:
 
-For the auto-commit feature to work, ensure your repository has the correct permissions:
+```json
+{
+  "sourcePath": "src",
+  "lint": {
+    "rules": { "no-console": "error" },
+    "ignorePatterns": ["**/*.generated.ts"]
+  },
+  "python": { "enabled": true, "ruff": { "lint": true, "format": true } },
+  "swift": { "enabled": true },
+  "kotlin": { "enabled": true },
+  "cpp": { "enabled": true, "clangFormat": { "style": "Google" } },
+  "duplicate": { "enabled": true, "minLines": 10 },
+  "deadCode": { "enabled": false },
+  "commitlint": {
+    "enabled": true,
+    "types": ["feat", "fix", "docs", "chore", "ci", "refactor", "test"]
+  },
+  "licenseCheck": {
+    "allowPackages": [],
+    "allowLicenses": ["LGPL-3.0"]
+  },
+  "prBody": { "enabled": true, "minLength": 20, "requireTicket": true }
+}
+```
 
-1. Go to **Settings** → **Actions** → **General** → **Workflow permissions**
-2. Select **"Read and write permissions"**
-3. Save changes
+---
 
-> The workflow will automatically commit Prettier formatting fixes directly to your PR branch.
+## Delta Mode
 
-<br>
+In GitHub Actions PR context, language checks automatically switch to **delta mode** — only files changed in the PR are checked. Outside PR context (local, push workflows) the checks fall back to a full project scan.
 
-### PR summary comment
+---
 
-After `npx pr-checkmate all` finishes, it prints a summary table to the CI log and posts a comment on the PR. On repeated pushes the comment is updated in place — no duplicate comments accumulate.
+## PR Summary Comment
 
-The comment looks like this:
+After `npx pr-checkmate all`, a summary table is posted to the PR. On repeated pushes the comment is updated in place — no duplicate comments.
 
-```text
+```
 ## PR CheckMate Summary
 
-**11 passed** · **3 warnings** · **0 failed** · **0 skipped**
+11 passed · 3 warnings · 0 failed · 0 skipped
 
-| Check | Result |
-|---|---|
-| ESLint | pass |
-| TypeScript | pass |
-| Diff Smells | warn — 2x console.*(), 1x TODO comment |
-| PR Body | warn — no ticket reference |
-...
+| Check          | Result                                  |
+|----------------|-----------------------------------------|
+| ESLint         | ✅ pass                                 |
+| TypeScript     | ✅ pass                                 |
+| Ruff Lint      | ⚠️ warn — 3 issues in 2 files          |
+| Diff Smell     | ⚠️ warn — 2x console.*(), 1x TODO      |
+| PR Body        | ⚠️ warn — no ticket reference          |
+| ...            | ...                                     |
 ```
 
-This requires `GITHUB_TOKEN` with `pull-requests: write` permission. The auto-generated workflow already includes both — no extra setup is needed.
-
-<br>
-
-## 🌍 Multilingual Spellcheck Support
+Requires `pull-requests: write` permission — the generated workflow includes this automatically.
 
-PR CheckMate includes built-in dictionaries for:
+---
 
-* 🇬🇧 English (en)
-* 🇪🇸 Spanish (es)
-* 🇫🇷 French (fr)
-* 🇷🇺 Russian (ru)
-* 🇺🇦 Ukrainian (uk)
-* 🇮🇱 Hebrew (he)
+## Tech Stack
 
-No additional configuration needed — just use `npx pr-checkmate spellcheck` and it will check spelling in all supported languages.
-
-<br>
-
-## 📌 Benefits
-
-* ✅ Self-contained — the package handles all checks internally
-* ✅ Works locally and in CI/CD (GitHub Actions, GitLab CI, etc.)
-* ✅ Enforces a unified code style across repositories
-* ✅ Automatic formatting and commits when needed
-* ✅ Multilingual spellcheck support out of the box
-* ✅ Minimal setup — just `init` and `npx pr-checkmate all`
-* ✅ Delta mode keeps CI fast — only changed files are scanned
-* ✅ License guard prevents copyleft packages from entering your project
-
-## 🧰 Tech Stack
-
-* **Node.js 20** — executes CLI scripts
-* **TypeScript** — fully typed code
-* **ESLint + @typescript-eslint** — code linting
-* **Prettier** — auto-formatting
-* **cspell** — spellchecking with multilingual dictionaries
-* **execa** — running CLI commands from Node.js
-* **gitleaks** — secret scanning
-* **depcheck** — unused and missing dependency analysis
-* **dpdm** — circular dependency detection
-* **license-checker** — license compliance validation
-
-## 📜 License
+| Tool | Role |
+|---|---|
+| ESLint + @typescript-eslint | TypeScript / JS linting |
+| eslint-plugin-sonarjs | Complexity analysis |
+| eslint-plugin-import | Import ordering |
+| eslint-plugin-jsdoc | Documentation coverage |
+| Prettier | Code formatting |
+| @astral-sh/ruff-wasm-nodejs | Python lint + format (WASM) |
+| @wasm-fmt/clang-format | C++ formatting (WASM) |
+| SwiftLint | Swift linting (system binary) |
+| ktlint | Kotlin linting (system binary) |
+| cspell | Multilingual spellcheck |
+| gitleaks | Secret scanning |
+| depcheck | Dependency analysis |
+| ts-unused-exports | Dead code detection |
+| jscpd | Duplicate code detection |
+| license-checker | License compliance |
+
+---
+
+## License
 
 LicenseRef Proprietary © 2025