pr-checkmate 1.6.0 → 1.7.0

package/cspell.json

@@ -2,6 +2,8 @@
   "version": "0.2",
   "language": "en",
   "words": [
+    "Artur",
+    "Polishchuk",
     "uiautomator",
     "UiAutomator2",
     "checkmate",
@@ -13,7 +15,12 @@
     "playwright",
     "pytest",
     "creds",
-    "UITM"
+    "UITM",
+    "venv",
+    "pycache",
+    "wdio",
+    "htmlcov",
+    "mochawesome"
   ],
   "ignorePaths": [
     "**/node_modules/**",

package/dist/config/index.js

@@ -18,17 +18,37 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SOURCE_PATH = exports.config = exports.CONFIG_FILE = void 0;
+exports.getSourcePath = getSourcePath;
 exports.getPackageConfigPath = getPackageConfigPath;
 exports.hasLocalConfig = hasLocalConfig;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
-__exportStar(require("./config"), exports);
+const utils_1 = require("../utils");
 __exportStar(require("./constants"), exports);
 exports.CONFIG_FILE = node_path_1.default.resolve(process.cwd(), 'pr-checkmate.json');
-exports.config = node_fs_1.default.existsSync(exports.CONFIG_FILE)
-    ? JSON.parse(node_fs_1.default.readFileSync(exports.CONFIG_FILE, 'utf-8'))
-    : { sourcePath: 'src' };
-exports.SOURCE_PATH = exports.config.sourcePath;
+/**
+ * Load configuration dynamically (always reads fresh config)
+ */
+function loadConfig() {
+    try {
+        if (node_fs_1.default.existsSync(exports.CONFIG_FILE)) {
+            const configContent = node_fs_1.default.readFileSync(exports.CONFIG_FILE, 'utf-8');
+            return JSON.parse(configContent);
+        }
+    }
+    catch (err) {
+        utils_1.logger.warn(`⚠️ Failed to read config from ${exports.CONFIG_FILE}, using defaults${err}`);
+    }
+    return { sourcePath: 'src' };
+}
+/**
+ * Get SOURCE_PATH dynamically
+ * This ensures fresh config is always read
+ */
+function getSourcePath() {
+    const config = loadConfig();
+    return config.sourcePath;
+}
 /**
  * Get path to package config files
  */
@@ -43,3 +63,9 @@ function hasLocalConfig(configNames) {
     const projectRoot = process.cwd();
     return configNames.some(name => node_fs_1.default.existsSync(node_path_1.default.join(projectRoot, name)));
 }
+/**
+ * For backward compatibility, also export as constant
+ * But this will be evaluated at module load time
+ */
+exports.config = loadConfig();
+exports.SOURCE_PATH = exports.config.sourcePath;

package/dist/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.logger = exports.runSecurityScan = exports.runSpellcheck = exports.runPrettier = exports.runDependencyCheck = exports.runLint = void 0;
+exports.runSecurityScan = exports.runSpellcheck = exports.runPrettier = exports.runDependencyCheck = exports.runLint = exports.hasLocalConfig = exports.getPackageConfigPath = exports.getSourcePath = void 0;
 exports.runAllChecks = runAllChecks;
 exports.runChecks = runChecks;
 /**
@@ -12,6 +12,10 @@ const lint_1 = require("./scripts/lint");
 const dependency_check_1 = require("./scripts/dependency-check");
 const prettier_autoformat_1 = require("./scripts/prettier-autoformat");
 const spellcheck_1 = require("./scripts/spellcheck");
+var config_1 = require("./config");
+Object.defineProperty(exports, "getSourcePath", { enumerable: true, get: function () { return config_1.getSourcePath; } });
+Object.defineProperty(exports, "getPackageConfigPath", { enumerable: true, get: function () { return config_1.getPackageConfigPath; } });
+Object.defineProperty(exports, "hasLocalConfig", { enumerable: true, get: function () { return config_1.hasLocalConfig; } });
 var lint_2 = require("./scripts/lint");
 Object.defineProperty(exports, "runLint", { enumerable: true, get: function () { return lint_2.runLint; } });
 var dependency_check_2 = require("./scripts/dependency-check");
@@ -22,8 +26,6 @@ var spellcheck_2 = require("./scripts/spellcheck");
 Object.defineProperty(exports, "runSpellcheck", { enumerable: true, get: function () { return spellcheck_2.runSpellcheck; } });
 var security_1 = require("./scripts/security");
 Object.defineProperty(exports, "runSecurityScan", { enumerable: true, get: function () { return security_1.runSecurityScan; } });
-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
@@ -32,7 +34,6 @@ async function runAllChecks() {
     await (0, lint_1.runLint)();
     await (0, dependency_check_1.runDependencyCheck)();
     await (0, spellcheck_1.runSpellcheck)();
-    // await runSecurityScan();
     await (0, prettier_autoformat_1.runPrettier)(); // Last to commit any fixes
 }
 /**

package/dist/init.js

@@ -10,9 +10,6 @@ const path_1 = __importDefault(require("path"));
 const inquirer_1 = __importDefault(require("inquirer"));
 const utils_1 = require("./utils");
 exports.CONFIG_FILE = path_1.default.resolve(process.cwd(), 'pr-checkmate.json');
-/**
- * Initialize pr-checkmate configuration file.
- */
 async function init() {
     if (!fs_1.default.existsSync(exports.CONFIG_FILE)) {
         const answers = await inquirer_1.default.prompt([
@@ -26,43 +23,39 @@ async function init() {
                 type: 'input',
                 name: 'manualPath',
                 message: 'Enter path:',
-                when: (a) => a.sourcePath === 'Enter manually',
-                validate: (input) => input.trim().length > 0 || 'Cannot be empty',
+                when: a => a.sourcePath === 'Enter manually',
+                validate: input => input.trim().length > 0 || 'Cannot be empty',
             },
         ]);
-        const config = {
-            sourcePath: answers.sourcePath === 'Enter manually' ? answers.manualPath : answers.sourcePath,
-        };
+        const sourcePath = answers.sourcePath === 'Enter manually' ? answers.manualPath : answers.sourcePath;
+        const config = { sourcePath };
         fs_1.default.writeFileSync(exports.CONFIG_FILE, JSON.stringify(config, null, 2));
-        utils_1.logger.info('✅ Created pr-checkmate.json');
+        utils_1.logger.info(`✅ Created pr-checkmate.json with sourcePath: ${sourcePath}`);
+        const root = process.cwd();
+        const tsconfigPath = path_1.default.join(root, 'tsconfig.json');
+        if (!fs_1.default.existsSync(tsconfigPath)) {
+            const newTsConfig = {
+                compilerOptions: {
+                    target: 'ES2020',
+                    module: 'NodeNext',
+                    outDir: 'dist',
+                    strict: true,
+                    rootDir: sourcePath,
+                    moduleResolution: 'NodeNext',
+                    esModuleInterop: true,
+                    resolveJsonModule: true,
+                    forceConsistentCasingInFileNames: true,
+                    skipLibCheck: true,
+                    types: ['node'],
+                },
+                include: [`${sourcePath}/**/*.ts`],
+                exclude: ['node_modules', 'dist'],
+            };
+            fs_1.default.writeFileSync(tsconfigPath, JSON.stringify(newTsConfig, null, 2));
+            utils_1.logger.info('✅ Created tsconfig.json using your sourcePath');
+        }
     }
     else {
         utils_1.logger.info('⚡ pr-checkmate.json already exists.');
     }
-    const root = process.cwd();
-    const tsconfigPath = path_1.default.join(root, 'tsconfig.json');
-    if (!fs_1.default.existsSync(tsconfigPath)) {
-        const defaultTsConfig = {
-            compilerOptions: {
-                target: 'ES2020',
-                module: 'NodeNext',
-                outDir: 'dist',
-                strict: true,
-                rootDir: 'src',
-                moduleResolution: 'NodeNext',
-                esModuleInterop: true,
-                resolveJsonModule: true,
-                forceConsistentCasingInFileNames: true,
-                skipLibCheck: true,
-                types: ['node'],
-            },
-            include: ['src/**/*.ts'],
-            exclude: ['node_modules', 'dist'],
-        };
-        fs_1.default.writeFileSync(tsconfigPath, JSON.stringify(defaultTsConfig, null, 2));
-        utils_1.logger.info('✅ Created default tsconfig.json');
-    }
-    else {
-        utils_1.logger.info('⚡ tsconfig.json already exists.');
-    }
 }

package/dist/scripts/dependency-check.js

@@ -9,10 +9,7 @@ const utils_1 = require("../utils");
 const node_path_1 = __importDefault(require("node:path"));
 const node_fs_1 = __importDefault(require("node:fs"));
 /**
- * Check for the presence of package.json and source folder.
- * Currently, only validates existence; can be extended for dependency checks.
- *
- * @throws Will throw an error if deeper checks are added and fail.
+ * Basic dependency checks with sourcePath support
  */
 async function runDependencyCheck() {
     utils_1.logger.info('📦 Checking dependencies...');
@@ -22,16 +19,17 @@ async function runDependencyCheck() {
         utils_1.logger.warn('⚠️ No package.json — skipping dependency check');
         return;
     }
-    const sourceFolder = node_path_1.default.join(projectRoot, config_1.SOURCE_PATH);
+    const sourcePath = (0, config_1.getSourcePath)();
+    const sourceFolder = node_path_1.default.join(projectRoot, sourcePath);
     if (!node_fs_1.default.existsSync(sourceFolder)) {
-        utils_1.logger.warn(`⚠️ Source folder "${config_1.SOURCE_PATH}" not found — skipping deeper checks`);
+        utils_1.logger.warn(`⚠️ Source folder "${sourcePath}" not found — skipping deeper checks`);
         return;
     }
-    const ignoredInSource = config_1.IGNORE_PATTERNS.some(pattern => {
-        const cleanPattern = pattern.replace(/\*\*/g, '').replace(/\//g, '');
-        return sourceFolder.includes(cleanPattern);
+    const ignored = config_1.IGNORE_PATTERNS.some(pattern => {
+        const clean = pattern.replace(/\*\*/g, '').replace(/\//g, '').trim();
+        return clean && sourceFolder.includes(clean);
     });
-    if (ignoredInSource) {
+    if (ignored) {
         utils_1.logger.warn('⚠️ Source path contains ignored directories');
     }
     utils_1.logger.info('✅ Dependencies OK');

package/dist/scripts/lint.js

@@ -1,16 +1,18 @@
 "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 config_1 = require("../config");
 const utils_1 = require("../utils");
 const execa_1 = require("execa");
-/**
- * Run ESLint on the project.
- * Uses local ESLint configuration if available; otherwise uses packaged config.
- */
+const node_path_1 = __importDefault(require("node:path"));
 async function runLint() {
     utils_1.logger.info('🔍 Running ESLint...');
     const projectRoot = process.cwd();
+    const sourcePath = (0, config_1.getSourcePath)();
+    const sourceFullPath = node_path_1.default.join(projectRoot, sourcePath);
     const hasLocal = (0, config_1.hasLocalConfig)([
         'eslint.config.mjs',
         'eslint.config.js',
@@ -20,30 +22,23 @@ async function runLint() {
     ]);
     let args;
     if (hasLocal) {
-        utils_1.logger.info('📋 Using local ESLint config');
-        args = [
-            'eslint',
-            projectRoot,
-            '--ext',
-            '.ts,.tsx,.js,.jsx',
-            '--fix',
-            ...config_1.IGNORE_PATTERNS.flatMap(pattern => ['--ignore-pattern', pattern]),
-        ];
+        utils_1.logger.info(`📋 Using local ESLint config (checking: ${sourcePath})`);
+        args = ['eslint', sourceFullPath, '--ext', '.ts,.tsx,.js,.jsx', '--fix'];
     }
     else {
-        utils_1.logger.info('📦 Using pr-checkmate ESLint config');
+        utils_1.logger.info(`📦 Using pr-checkmate ESLint config (checking: ${sourcePath})`);
         const configPath = (0, config_1.getPackageConfigPath)('eslint.config.mjs');
         args = [
             'eslint',
-            projectRoot,
+            sourceFullPath,
             '--ext',
             '.ts,.tsx,.js,.jsx',
             '--fix',
             '--config',
             configPath,
-            ...config_1.IGNORE_PATTERNS.flatMap(pattern => ['--ignore-pattern', pattern]),
         ];
     }
+    config_1.IGNORE_PATTERNS.forEach(p => args.push('--ignore-pattern', p));
     try {
         await (0, execa_1.execa)('npx', args, { stdio: 'inherit' });
         utils_1.logger.info('✅ ESLint passed');

package/dist/scripts/prettier-autoformat.js

@@ -13,37 +13,31 @@ const node_fs_1 = __importDefault(require("node:fs"));
  * Create temporary .prettierignore file with ignore patterns
  */
 function createTempIgnoreFile() {
-    const tempIgnoreFile = node_path_1.default.join(process.cwd(), '.prettierignore.temp');
-    const ignoreContent = config_1.IGNORE_PATTERNS.join('\n');
-    node_fs_1.default.writeFileSync(tempIgnoreFile, ignoreContent, 'utf-8');
-    return tempIgnoreFile;
+    const file = node_path_1.default.join(process.cwd(), '.prettierignore.temp');
+    node_fs_1.default.writeFileSync(file, config_1.IGNORE_PATTERNS.join('\n'), 'utf-8');
+    return file;
 }
 /**
- * Remove temporary ignore file
+ * Remove temporary file
  */
 function cleanupTempIgnoreFile(filePath) {
     try {
-        if (node_fs_1.default.existsSync(filePath)) {
+        if (node_fs_1.default.existsSync(filePath))
             node_fs_1.default.unlinkSync(filePath);
-        }
     }
     catch (err) {
-        utils_1.logger.warn(`[cleanupTempIgnoreFile]: ⚠️ Failed to cleanup temp file: ${filePath}\n${err}`);
+        utils_1.logger.warn(`[cleanupTempIgnoreFile]: ⚠️ Failed cleanup: ${filePath}\n${err}`);
     }
 }
 async function runPrettier() {
     utils_1.logger.info('🎨 Running Prettier...');
-    const projectRoot = process.cwd();
-    const projectIgnore = node_path_1.default.join(projectRoot, '.prettierignore');
-    const gitignore = node_path_1.default.join(projectRoot, '.gitignore');
-    const hasLocal = (0, config_1.hasLocalConfig)([
-        '.prettierrc',
-        '.prettierrc.json',
-        '.prettierrc.js',
-        'prettier.config.js',
-    ]);
-    let tempIgnoreFile = null;
+    const root = process.cwd();
+    const sourcePath = (0, config_1.getSourcePath)();
+    const targetGlob = `${node_path_1.default.join(root, sourcePath)}/**/*.{ts,tsx,js,jsx,json,md}`;
+    const projectIgnore = node_path_1.default.join(root, '.prettierignore');
+    const gitignore = node_path_1.default.join(root, '.gitignore');
     let ignorePath;
+    let temp = null;
     if (node_fs_1.default.existsSync(projectIgnore)) {
         ignorePath = projectIgnore;
     }
@@ -51,32 +45,24 @@ async function runPrettier() {
         ignorePath = gitignore;
     }
     else {
-        tempIgnoreFile = createTempIgnoreFile();
-        ignorePath = tempIgnoreFile;
+        temp = createTempIgnoreFile();
+        ignorePath = temp;
     }
+    const hasLocal = (0, config_1.hasLocalConfig)([
+        '.prettierrc',
+        '.prettierrc.json',
+        '.prettierrc.js',
+        'prettier.config.js',
+    ]);
     let args;
     if (hasLocal) {
-        utils_1.logger.info('📋 Using local Prettier config');
-        args = [
-            'prettier',
-            '--write',
-            `${projectRoot}/**/*.{ts,tsx,js,jsx,json,md}`,
-            '--ignore-path',
-            ignorePath,
-        ];
+        utils_1.logger.info(`📋 Using local Prettier config (checking: ${sourcePath})`);
+        args = ['prettier', '--write', targetGlob, '--ignore-path', ignorePath];
     }
     else {
-        utils_1.logger.info('📦 Using pr-checkmate Prettier config');
+        utils_1.logger.info(`📦 Using pr-checkmate Prettier config (checking: ${sourcePath})`);
         const configPath = (0, config_1.getPackageConfigPath)('.prettierrc');
-        args = [
-            'prettier',
-            '--write',
-            `${projectRoot}/**/*.{ts,tsx,js,jsx,json,md}`,
-            '--config',
-            configPath,
-            '--ignore-path',
-            ignorePath,
-        ];
+        args = ['prettier', '--write', targetGlob, '--config', configPath, '--ignore-path', ignorePath];
     }
     try {
         await (0, execa_1.execa)('npx', args, { stdio: 'inherit' });
@@ -87,8 +73,7 @@ async function runPrettier() {
         throw err;
     }
     finally {
-        if (tempIgnoreFile) {
-            cleanupTempIgnoreFile(tempIgnoreFile);
-        }
+        if (temp)
+            cleanupTempIgnoreFile(temp);
     }
 }

package/dist/scripts/spellcheck.js

@@ -4,31 +4,31 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runSpellcheck = runSpellcheck;
+const config_1 = require("../config");
+const utils_1 = require("../utils");
 const execa_1 = require("execa");
 const node_path_1 = __importDefault(require("node:path"));
-const utils_1 = require("../utils");
-const config_1 = require("../config");
 /**
- * Build glob patterns for spellcheck with ignore patterns
+ * Build cspell patterns + ignore patterns
  */
 function buildSpellcheckPatterns(projectRoot, sourcePath) {
-    const basePattern = node_path_1.default.join(projectRoot, sourcePath, '**/*.{ts,tsx,js,jsx,md,mdx,json}');
-    // create ignore glob flags: --exclude "**/node_modules/**"
-    const excludeArgs = config_1.IGNORE_PATTERNS.map(p => `--exclude=${p}`);
-    return [basePattern, ...excludeArgs];
+    const base = node_path_1.default.join(projectRoot, sourcePath, '**/*.{ts,tsx,js,jsx,md,mdx,json}');
+    const excludes = config_1.IGNORE_PATTERNS.map(p => `--exclude=${p}`);
+    return [base, ...excludes];
 }
 async function runSpellcheck() {
-    utils_1.logger.info('🔤 Running spellcheck...');
+    utils_1.logger.info('🔤 Running Spellcheck...');
     const projectRoot = process.cwd();
-    const patterns = buildSpellcheckPatterns(projectRoot, config_1.SOURCE_PATH);
+    const sourcePath = (0, config_1.getSourcePath)();
+    const patterns = buildSpellcheckPatterns(projectRoot, sourcePath);
     const hasLocal = (0, config_1.hasLocalConfig)(['cspell.json', '.cspell.json', 'cspell.config.json']);
     let args;
     if (hasLocal) {
-        utils_1.logger.info('📋 Using local cspell config');
+        utils_1.logger.info(`📋 Using local cspell config (checking: ${sourcePath})`);
         args = ['cspell', ...patterns, '--no-progress'];
     }
     else {
-        utils_1.logger.info('📦 Using pr-checkmate cspell config');
+        utils_1.logger.info(`📦 Using pr-checkmate cspell config (checking: ${sourcePath})`);
         const configPath = (0, config_1.getPackageConfigPath)('cspell.json');
         args = ['cspell', ...patterns, '--config', configPath, '--no-progress'];
     }

package/eslint.config.mjs

@@ -1,10 +1,23 @@
+import fs from 'fs';
 import tsPlugin from '@typescript-eslint/eslint-plugin';
 import tsParser from '@typescript-eslint/parser';
 import prettierPlugin from 'eslint-plugin-prettier';
 
+const config = JSON.parse(fs.readFileSync('./pr-checkmate.json', 'utf-8'));
+const SRC = config.sourcePath;
+
 export default [
   {
-    files: ['**/*.ts', '**/*.tsx', '**/*.js', '**/*.jsx'],
+    files: [`${SRC}/**/*.{ts,tsx,js,jsx}`],
+
+    ignores: [
+      '**/node_modules/**',
+      '**/dist/**',
+      '**/.git/**',
+      '**/build/**',
+      '**/coverage/**',
+    ],
+
     languageOptions: {
       parser: tsParser,
       parserOptions: {
@@ -19,64 +32,41 @@ export default [
       prettier: prettierPlugin,
     },
 
-    rules: {
-      'no-console': 'warn',
-      'no-debugger': 'error',
-      'prefer-const': 'error',
-      eqeqeq: ['error', 'always'],
-      '@typescript-eslint/no-unused-vars': [
-        'error',
-        { argsIgnorePattern: '^_', varsIgnorePattern: '^_' },
-      ],
-      '@typescript-eslint/explicit-function-return-type': ['warn'],
-      '@typescript-eslint/no-explicit-any': ['warn'],
-      '@typescript-eslint/no-floating-promises': ['error'],
-      'space-before-function-paren': 'off',
-      'operator-linebreak': 'off',
-      'max-len': ['warn', { code: 100 }],
-
-      // Formatting / Style Rules
-      semi: ['error', 'always'],
-      quotes: ['error', 'single', { avoidEscape: true }],
-      'object-curly-spacing': ['error', 'always'],
-      'space-infix-ops': 'error',
-      'keyword-spacing': ['error', { before: true, after: true }],
-      'padding-line-between-statements': [
-        'error',
-        { blankLine: 'always', prev: 'block', next: '*' },
-        { blankLine: 'always', prev: '*', next: 'return' },
-      ],
-
-      // Prettier integration
-      'prettier/prettier': [
-        'error',
-        {
-          semi: true,
-          singleQuote: true,
-          bracketSpacing: true,
-          arrowParens: 'avoid',
-          printWidth: 100,
-        },
-      ],
-    },
-  },
-
-  {
-    files: [
-      '*.config.js',
-      '*.config.ts',
-      'jest.config.js',
-      'wdio.config.js',
-      'playwright.config.js',
-      'cypress.config.js',
-    ],
-    languageOptions: {
-      parser: tsParser,
-      parserOptions: {
-        ecmaVersion: 2020,
-        sourceType: 'module',
-        project: undefined,
+      rules: {
+        'no-console': 'warn',
+        'no-debugger': 'error',
+        'prefer-const': 'error',
+        eqeqeq: ['error', 'always'],
+        '@typescript-eslint/no-unused-vars': [
+          'error',
+          { argsIgnorePattern: '^_', varsIgnorePattern: '^_' },
+        ],
+        '@typescript-eslint/explicit-function-return-type': ['warn'],
+        '@typescript-eslint/no-explicit-any': ['warn'],
+        '@typescript-eslint/no-floating-promises': ['error'],
+        'space-before-function-paren': 'off',
+        'operator-linebreak': 'off',
+        'max-len': ['warn', { code: 100 }],
+        semi: ['error', 'always'],
+        quotes: ['error', 'single', { avoidEscape: true }],
+        'object-curly-spacing': ['error', 'always'],
+        'space-infix-ops': 'error',
+        'keyword-spacing': ['error', { before: true, after: true }],
+        'padding-line-between-statements': [
+          'error',
+          { blankLine: 'always', prev: 'block', next: '*' },
+          { blankLine: 'always', prev: '*', next: 'return' },
+        ],
+        'prettier/prettier': [
+          'error',
+          {
+            semi: true,
+            singleQuote: true,
+            bracketSpacing: true,
+            arrowParens: 'avoid',
+            printWidth: 100,
+          },
+        ],
       },
-    },
   },
 ];

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "pr-checkmate",
-    "version": "1.6.0",
+    "version": "1.7.0",
     "description": "Automated PR quality checks: linting, formatting, dependency analysis, and spellcheck",
     "keywords": [
         "github-actions",