pr-checkmate 1.0.0

package/LICENSE

@@ -0,0 +1,9 @@
+Copyright © 2025 Mybono.
+All rights reserved.
+
+This software and associated documentation files (the “Software”) are the exclusive property of the copyright holder.
+
+Permission is hereby NOT granted to any person or entity to copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, or use the Software in any manner, unless an explicit written permission is provided by the copyright holder.
+
+Any unauthorized use, modification, reproduction, or distribution of the Software is strictly prohibited and may result in civil and criminal penalties.
+

package/README.md

@@ -0,0 +1,107 @@
+# 🔍 PR CheckMate
+
+> **PR CheckMate** is a public npm package for automating Pull Request checks. It helps teams maintain code quality by validating linting, formatting, dependency changes, and spelling before merging to the main branch.
+
+---
+
+## ⚡ Why PR CheckMate?
+
+When a PR is opened, it's essential that the code follows project standards. PR CheckMate automatically checks:
+
+* ✅ **Linting** — TypeScript/JavaScript code compliance with ESLint rules
+* ✅ **Prettier Auto-Format** — automatically formats code and commits changes if needed
+* ✅ **Dependency Changes** — checks for updates in `package.json`/`package-lock.json` and warns about potential risks
+* ✅ **Spellcheck** — checks spelling in code, documentation, and JSON files using `cspell`
+
+---
+
+## 🛠 How It Works
+
+### 1. Install via npm
+
+```bash
+npm install --save-dev pr_checkmate
+```
+
+### 2. Run as a CLI command
+
+```bash
+npx pr-checks <job>
+```
+
+**`<job>` options:**
+
+| Job | Description |
+|-----|-------------|
+| `lint` | Lint code using ESLint |
+| `prettier` | Format code with Prettier and push changes |
+| `deps` | Check for dependency changes |
+| `spellcheck` | Run spellcheck on source and documentation |
+
+### 3. Use in GitHub Actions
+
+Automatically check PRs by adding to your workflow:
+
+```yaml
+jobs:
+  pr-checks:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v3
+        with:
+          node-version: 20
+      - run: npm ci
+      - run: npx pr-checks lint
+      - run: npx pr-checks prettier
+      - run: npx pr-checks deps
+      - run: npx pr-checks spellcheck
+```
+
+---
+
+## 🧰 Tech Stack
+
+* **Node.js 20** — executes scripts
+* **TypeScript** — fully typed code
+* **ESLint + @typescript-eslint** — code linting
+* **Prettier** — auto-formatting
+* **cspell** — spellchecking
+* **execa** — running CLI commands from Node.js
+
+---
+
+## 📦 Features
+
+* ✅ Works locally and in CI/CD pipelines (GitHub Actions, GitLab CI, etc.)
+* ✅ Uses a built-in `logger` for console output
+* ✅ Automatically detects the current Git branch and pushes commits after auto-formatting
+* ✅ Self-contained package — no external environment variables required
+
+---
+
+## 💻 Example Usage in Node.js
+
+```javascript
+import { 
+  runLint, 
+  runDependencyCheck,
+  runPrettier,
+  runSpellcheck
+} from 'pr_checkmate';
+
+async function runAllChecks() {
+  await runLint();
+  await runPrettier();
+  await runDependencyCheck();
+  await runSpellcheck();
+}
+
+runAllChecks();
+```
+
+---
+
+## 📜 License
+
+LicenseRef Proprietary © 2025

package/dist/index.js

@@ -0,0 +1,84 @@
+"use strict";
+/**
+ * PR CheckMate - Automated PR quality checks
+ *
+ * @module pr-checkmate
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = exports.runSpellcheck = exports.runPrettier = exports.runDependencyCheck = exports.runLint = void 0;
+exports.runAllChecks = runAllChecks;
+exports.runChecks = runChecks;
+var lint_1 = require("./scripts/lint");
+Object.defineProperty(exports, "runLint", { enumerable: true, get: function () { return lint_1.runLint; } });
+var dependency_check_1 = require("./scripts/dependency-check");
+Object.defineProperty(exports, "runDependencyCheck", { enumerable: true, get: function () { return dependency_check_1.runDependencyCheck; } });
+var prettier_autoformat_1 = require("./scripts/prettier-autoformat");
+Object.defineProperty(exports, "runPrettier", { enumerable: true, get: function () { return prettier_autoformat_1.runPrettier; } });
+var spellcheck_1 = require("./scripts/spellcheck");
+Object.defineProperty(exports, "runSpellcheck", { enumerable: true, get: function () { return spellcheck_1.runSpellcheck; } });
+var utils_1 = require("./utils");
+Object.defineProperty(exports, "logger", { enumerable: true, get: function () { return utils_1.logger; } });
+/**
+ * Run all checks sequentially
+ * @returns Promise that resolves when all checks complete
+ */
+async function runAllChecks() {
+    const { runLint } = await Promise.resolve().then(() => __importStar(require('./scripts/lint')));
+    const { runDependencyCheck } = await Promise.resolve().then(() => __importStar(require('./scripts/dependency-check')));
+    const { runPrettier } = await Promise.resolve().then(() => __importStar(require('./scripts/prettier-autoformat')));
+    const { runSpellcheck } = await Promise.resolve().then(() => __importStar(require('./scripts/spellcheck')));
+    await runLint();
+    await runDependencyCheck();
+    await runSpellcheck();
+    await runPrettier(); // Last to commit any fixes
+}
+/**
+ * Run checks based on configuration
+ */
+async function runChecks(config = {}) {
+    const { runLint } = await Promise.resolve().then(() => __importStar(require('./scripts/lint')));
+    const { runDependencyCheck } = await Promise.resolve().then(() => __importStar(require('./scripts/dependency-check')));
+    const { runPrettier } = await Promise.resolve().then(() => __importStar(require('./scripts/prettier-autoformat')));
+    const { runSpellcheck } = await Promise.resolve().then(() => __importStar(require('./scripts/spellcheck')));
+    if (!config.skipLint)
+        await runLint();
+    if (!config.skipDeps)
+        await runDependencyCheck();
+    if (!config.skipSpell)
+        await runSpellcheck();
+    if (!config.skipFormat && config.autoCommit)
+        await runPrettier();
+}

package/dist/scripts/dependency-check.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runDependencyCheck = runDependencyCheck;
+const utils_1 = require("../utils");
+const node_fs_1 = __importDefault(require("node:fs"));
+/**
+ * Check for changes in dependency files using CHANGED_FILES env variable.
+ */
+// export async function runDependencyCheck(): Promise<void> {
+//   try {
+//     const changedFiles = process.env.CHANGED_FILES ?? '';
+//     if (/package.*\.json/.test(changedFiles)) {
+//       logger.warn('[runDependencyCheck]: ⚠️ Dependencies changed!');
+//     } else {
+//       logger.log('[runDependencyCheck]: ✅ No dependency changes detected.');
+//     }
+//   } catch (err: unknown) {
+//     const errorMessage = err instanceof Error ? err.message : String(err);
+//     logger.error('[runDependencyCheck]: ❌ Dependency check failed:', errorMessage);
+//     throw err;
+//   }
+// }
+async function runDependencyCheck() {
+    utils_1.logger.info('Checking dependencies...');
+    if (!node_fs_1.default.existsSync('package.json')) {
+        utils_1.logger.warn('No package.json — skipping');
+        return;
+    }
+    utils_1.logger.info('Dependencies OK');
+}

package/dist/scripts/index.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const lint_1 = require("./lint");
+const dependency_check_1 = require("./dependency-check");
+const prettier_autoformat_1 = require("./prettier-autoformat");
+const spellcheck_1 = require("./spellcheck");
+const utils_1 = require("../utils");
+/**
+ * CLI entry point for PR CheckMate.
+ *
+ * Usage:
+ *   npx pr-checks <job>
+ *
+ * Available jobs:
+ *   all         - Run ESLint + Dependency check + Prettier + spellcheck
+ *   lint        - Run ESLint
+ *   deps        - Check for dependency changes
+ *   prettier    - Run Prettier auto-format
+ *   spellcheck  - Run cspell spellcheck
+ */
+const job = process.argv[2];
+async function runJob(jobName) {
+    switch (jobName) {
+        case 'all':
+            await (0, lint_1.runLint)();
+            await (0, dependency_check_1.runDependencyCheck)();
+            await (0, prettier_autoformat_1.runPrettier)();
+            await (0, spellcheck_1.runSpellcheck)();
+            break;
+        case 'lint':
+            await (0, lint_1.runLint)();
+            break;
+        case 'deps':
+            await (0, dependency_check_1.runDependencyCheck)();
+            break;
+        case 'prettier':
+            await (0, prettier_autoformat_1.runPrettier)();
+            break;
+        case 'spellcheck':
+            await (0, spellcheck_1.runSpellcheck)();
+            break;
+        default:
+            utils_1.logger.log('[runJob]: Available jobs: lint, deps, prettier, spellcheck');
+    }
+}
+runJob(job).catch(err => {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new Error(`[runJob]: ❌ CLI execution failed: ${message}`);
+});

package/dist/scripts/lint.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runLint = runLint;
+const execa_1 = require("execa");
+const utils_1 = require("../utils");
+const node_fs_1 = __importDefault(require("node:fs"));
+// /**
+//  * Run ESLint on the project.
+//  */
+// export async function runLint(): Promise<void> {
+//   try {
+//     logger.info('[runLint]: Running ESLint...');
+//     // Run ESLint
+//     await execa('npm', ['run', 'lint'], { stdio: 'inherit' });
+//     logger.log('[runLint]: ✅ ESLint passed successfully.');
+//   } catch (err: unknown) {
+//     const errorMessage = err instanceof Error ? err.message : String(err);
+//     logger.warn(`[runLint]: ⚠️  ESLint found issues: ${errorMessage}`);
+//     // Don't throw - allow process to continue
+//   }
+// }
+async function runLint() {
+    utils_1.logger.info('Running ESLint...');
+    const hasLocalConfig = node_fs_1.default.existsSync('eslint.config.mjs') ||
+        node_fs_1.default.existsSync('.eslintrc.js') ||
+        node_fs_1.default.existsSync('.eslintrc.json');
+    const args = hasLocalConfig
+        ? ['eslint', '.', '--ext', '.ts,.tsx', '--fix']
+        : ['eslint', 'src', '--ext', '.ts', '--fix'];
+    try {
+        await (0, execa_1.execa)('npx', args, { stdio: 'inherit' });
+        utils_1.logger.info('ESLint passed');
+    }
+    catch (err) {
+        utils_1.logger.warn('ESLint issues found');
+        throw err;
+    }
+}

package/dist/scripts/prettier-autoformat.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runPrettier = runPrettier;
+const execa_1 = require("execa");
+const utils_1 = require("../utils");
+const node_fs_1 = __importDefault(require("node:fs"));
+/**
+ * Run Prettier formatting inside container.
+ * Git commit/push is done on the runner, not in Docker.
+ */
+// export async function runPrettier(): Promise<void> {
+//   try {
+//     logger.info('[runPrettier]: Running Prettier auto-format...');
+//     await execa('npm', ['run', 'prettier'], { stdio: 'inherit' });
+//     logger.log(
+//       '[runPrettier]: ✅ Prettier formatting completed (no git operations inside container)',
+//     );
+//   } catch (err: unknown) {
+//     const errorMessage = err instanceof Error ? err.message : String(err);
+//     logger.error('[runPrettier]: ❌ Prettier failed:', errorMessage);
+//     throw err;
+//   }
+// }
+async function runPrettier() {
+    utils_1.logger.info('Running Prettier...');
+    const hasConfig = node_fs_1.default.existsSync('.prettierrc') ||
+        node_fs_1.default.existsSync('.prettierrc.json') ||
+        node_fs_1.default.existsSync('prettier.config.js');
+    const pattern = hasConfig ? '.' : 'src';
+    try {
+        await (0, execa_1.execa)('npx', ['prettier', '--write', `${pattern}/**/*`], {
+            stdio: 'inherit',
+        });
+        utils_1.logger.info('Prettier completed');
+    }
+    catch (err) {
+        utils_1.logger.error('Prettier failed');
+        throw err;
+    }
+}

package/dist/scripts/spellcheck.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runSpellcheck = runSpellcheck;
+const execa_1 = require("execa");
+const utils_1 = require("../utils");
+/**
+ * Run spellcheck on the project using cspell.
+ */
+// export async function runSpellcheck(): Promise<void> {
+//   try {
+//     logger.info('[runSpellcheck]: Running spellcheck...');
+//     await execa('npx', ['cspell', '**/*.{ts,tsx,js,jsx,md,json}', '--no-progress'], {
+//       stdio: 'inherit',
+//     });
+//     logger.log('[runSpellcheck]: ✅ Spellcheck passed successfully.');
+//   } catch (err: unknown) {
+//     const errorMessage = err instanceof Error ? err.message : String(err);
+//     logger.warn(`[runSpellcheck]: ⚠️  Spellcheck found errors: ${errorMessage}`);
+//     // Don't throw - allow process to continue
+//   }
+// }
+async function runSpellcheck() {
+    utils_1.logger.info('Running spellcheck...');
+    try {
+        await (0, execa_1.execa)('npx', ['cspell', '**/*'], { stdio: 'inherit' });
+        utils_1.logger.info('Spellcheck passed');
+    }
+    catch (err) {
+        utils_1.logger.warn('Spellcheck found issues');
+        throw err;
+    }
+}

package/dist/utils/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./logger"), exports);

package/dist/utils/logger.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = void 0;
+class Logger {
+    constructor() {
+        this.logs = [];
+        this.levelOrder = {
+            error: 0,
+            warn: 1,
+            info: 2,
+            log: 2,
+            debug: 3,
+        };
+        this.currentLevel = 'info';
+    }
+    getTimestamp() {
+        return new Date().toISOString();
+    }
+    shouldLog(level) {
+        return this.levelOrder[level] <= this.levelOrder[this.currentLevel];
+    }
+    colorize(level, message) {
+        const colors = {
+            error: '\x1b[31m', // red
+            warn: '\x1b[33m', // yellow
+            info: '\x1b[32m', // green
+            log: '\x1b[37m', // white
+            debug: '\x1b[36m', // cyan
+        };
+        const reset = '\x1b[0m';
+        return `${colors[level]}${message}${reset}`;
+    }
+    logMessage(level, message, error) {
+        if (!this.shouldLog(level))
+            return;
+        const timestamp = this.getTimestamp();
+        const fullMessage = `[${timestamp}] [${level.toUpperCase()}] ${message}` +
+            (error instanceof Error ? `\n${error.stack}` : '');
+        this.logs.push(fullMessage);
+        /* eslint-disable-next-line no-console */
+        console.log(this.colorize(level, fullMessage));
+    }
+    log(msg) {
+        this.logMessage('log', msg);
+    }
+    info(msg) {
+        this.logMessage('info', msg);
+    }
+    warn(msg) {
+        this.logMessage('warn', msg);
+    }
+    error(msg, err) {
+        this.logMessage('error', msg, err);
+    }
+    debug(msg) {
+        this.logMessage('debug', msg);
+    }
+    getLogs() {
+        return this.logs;
+    }
+    clear() {
+        this.logs = [];
+    }
+}
+exports.logger = new Logger();

package/package.json

@@ -0,0 +1,68 @@
+{
+    "name": "pr-checkmate",
+    "version": "1.0.0",
+    "description": "Automated PR quality checks: linting, formatting, dependency analysis, and spellcheck",
+    "keywords": [
+        "github-actions",
+        "pull-request",
+        "ci-cd",
+        "eslint",
+        "prettier",
+        "code-quality",
+        "automation"
+    ],
+    "main": "dist/index.js",
+    "types": "dist/index.d.ts",
+    "bin": {
+        "pr-checkmate": "./dist/scripts/index.js"
+    },
+    "files": [
+        "dist",
+        "README.md",
+        "LICENSE"
+    ],
+    "scripts": {
+        "check": "npm run build && npm run lint && npm run prettier && npm run spellcheck",
+        "build": "npm run clean && tsc",
+        "prepublishOnly": "npm run build",
+        "lint": "eslint \"src/**/*.{ts,tsx}\"",
+        "prettier": "prettier --write \"src/**/*.{ts,tsx,js,jsx,json,md}\"",
+        "spellcheck": "cspell '**/*.{ts,tsx,js,jsx,md,json}' --no-progress",
+        "test": "echo 'Tests coming soon'",
+        "clean": "rm -rf dist"
+    },
+    "engines": {
+        "node": ">=18.0.0",
+        "npm": ">=8.0.0"
+    },
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/YOUR_USERNAME/pr-checkmate.git"
+    },
+    "bugs": {
+        "url": "https://github.com/YOUR_USERNAME/pr-checkmate/issues"
+    },
+    "homepage": "https://github.com/YOUR_USERNAME/pr-checkmate#readme",
+    "author": "Your Name <your.email@example.com>",
+    "license": "LicenseRef-Proprietary",
+    "devDependencies": {
+        "@typescript-eslint/eslint-plugin": "^8.47.0",
+        "@typescript-eslint/parser": "^8.47.0",
+        "eslint": "^9.39.1",
+        "eslint-config-prettier": "^9.1.2",
+        "eslint-plugin-import": "^2.29.0",
+        "eslint-plugin-prettier": "^5.5.4",
+        "prettier": "^3.6.2",
+        "ts-node": "^10.9.1",
+        "typescript": "^5.2.0",
+        "cspell": "^6.30.0",
+        "execa": "^7.1.0"
+    },
+    "dependencies": {
+        "dotenv": "^17.2.3"
+    },
+    "peerDependencies": {
+        "eslint": ">=8.0.0",
+        "prettier": ">=3.0.0"
+    }
+}