rhine-lint 1.0.2 → 1.3.2

package/README.md

@@ -110,7 +110,7 @@ export default {
           'react/no-unknown-property': 'off'
         }
       }
-      ...
+      // ...
     ]
   },
 
@@ -119,7 +119,7 @@ export default {
     config: {
       printWidth: 100,
       semi: true,
-      ...
+      // ...
     }
   }
 } as Config;
@@ -132,6 +132,9 @@ CLI 参数优先级高于配置文件：
 - `--fix`: 自动修复错误。
 - `--config <path>`: 指定配置文件路径。
 - `--level <level>`: 强制指定项目类型（`js`, `ts`, `frontend`, `nextjs`）。
+- `--ignore <pattern>`: 添加忽略模式 (支持多次使用, e.g. `--ignore dist --ignore coverage`)。
+- `--no-ignore`: 强制禁用所有忽略规则 (包括 .gitignore)。
+- `--debug`: 打印调试信息（包括生成的配置、忽略列表等）。
 - `--cache-dir <dir>`: 指定缓存目录（默认使用 `node_modules/.cache/rhine-lint`）。
 
 ### 缓存目录 Cache Directory
@@ -202,10 +205,14 @@ graph TD
 这是项目最复杂的部分。为了实现「零配置」且不污染用户目录，我们采用 **虚拟配置 (Virtual Configuration)** 策略。
 
 - **动态生成**: 我们不依赖用户项目里的 `.eslintrc`。相反，我们在运行时，在 `node_modules/.cache/rhine-lint/` 下生成一个真实的 `eslint.config.mjs`。
-- **JIT 编译**: 生成的配置文件不仅仅是 JSON，它是一段 **JavaScript 代码**。
-  - 它会 `import` rhine-lint 内部的 `src/assets/eslint.config.js`。
-  - 它会使用 `jiti` 或动态导入 (`import()`) 来加载用户的 `rhine-lint.config.ts`。
-  - 它会在内存中通过 `defu` 库将默认配置和用户配置进行深层合并。
+- **TypeScript 配置编译 (TS Compilation)**: 如果检测到用户的配置文件是 `.ts` 格式：
+  - 会自动调用内置的 TypeScript 编译器将其转译为 `.mjs` 模块。
+  - 转译后的文件被保存在缓存目录（如 `.cache/rhine-lint/rhine-lint.user-config.mjs`）。
+  - 生成的 ESLint 配置会指向这个编译后的 JS 文件，从而解决 Node.js 原生无法加载 TS 文件的限制。
+- **智能缓存 (Smart Caching)**: 为了提高性能（尤其是 IDE 保存自动修复时），我们实现了一套基于指纹的缓存机制：
+  - **指纹计算**: 每次运行前会计算一个 SHA-256 哈希，包含：`package.json` 版本 + CLI 参数 + 用户配置文件内容 + `.gitignore` 状态。
+  - **极速命中**: 如果指纹与缓存的 `metadata.json` 匹配，则**完全跳过**繁重的转译、合并和文件写入操作，直接复用上次的配置。
+- **JIT 加载**: 除了上述静态编译，对于部分模块加载我们使用 `jiti` 确保兼容性。
 - **关键点**: 这种设计使得 `rhine-lint` 内部的依赖（如 `eslint-plugin-react`）可以被正确解析，而不需要用户显式安装它们。
 
 #### 规则资产 (`src/assets/`)

package/dist/assets/eslint.config.js

@@ -4,7 +4,6 @@ import { fileURLToPath } from 'node:url'
 import nextPlugin from '@next/eslint-plugin-next'
 import reactPlugin from 'eslint-plugin-react';
 import reactHooksPlugin from 'eslint-plugin-react-hooks';
-import { fixupConfigRules } from '@eslint/compat'
 
 import css from '@eslint/css'
 
@@ -15,7 +14,6 @@ import css from '@eslint/css'
 // ...
 
 
-import { FlatCompat } from '@eslint/eslintrc'
 import js from '@eslint/js'
 import json from '@eslint/json'
 import markdown from '@eslint/markdown'
@@ -29,9 +27,6 @@ import tseslint from 'typescript-eslint'
 
 const __filename = fileURLToPath(import.meta.url)
 const __dirname = path.dirname(__filename)
-const compat = new FlatCompat({
-  baseDirectory: __dirname,
-})
 
 const globalConfig = defineConfig([
   {
@@ -50,7 +45,7 @@ export default function createConfig(overrides = {}) {
   const OPTIONS = {
     ENABLE_SCRIPT: true, // Set to enable typescript javascript file features
     ENABLE_TYPE_CHECKED: true, // Set to enable type features
-    ENABLE_PROJECT_BASE_TYPE_CHECKED: false, // Set to enable project-based type features
+    ENABLE_PROJECT_BASE_TYPE_CHECKED: true, // Set to enable project-based type features
     ENABLE_FRONTEND: true, // Set to enable JSX, React, Reacts Hooks, and other frontend features
     ENABLE_NEXT: false, // Set to enable Next.js and other frontend features
     ENABLE_MARKDOWN: true, // Set to enable markdown file features

package/dist/cli.js

@@ -14,7 +14,9 @@ cli
     .option("--fix", "Fix lint errors")
     .option("--config <path>", "Path to config file")
     .option("--level <level>", "Project level (js, ts, frontend, nextjs)")
+    .option("--no-project-type-check", "Disable project-based type checking (faster for single files)")
     .option("--cache-dir <dir>", "Custom temporary cache directory")
+    .option("--debug", "Enable debug mode")
     .action(async (files, options) => {
     const cwd = process.cwd();
     // If files is empty, default to "."
@@ -34,7 +36,7 @@ cli
         }
         console.log();
         // 2. Generate Temp Configs
-        const temps = await generateTempConfig(cwd, userConfigResult, options.level, options.cacheDir);
+        const temps = await generateTempConfig(cwd, userConfigResult, options.level, options.cacheDir, options.debug, options.projectTypeCheck);
         usedCachePath = temps.cachePath; // Save for cleanup
         // 3. Run ESLint
         const eslintResult = await runEslint(cwd, temps.eslintPath, options.fix, targetFiles);

package/dist/config.d.ts

@@ -6,6 +6,14 @@ export type Config = {
         config?: [
         ];
         overlay?: boolean;
+        /**
+         * Enable project-based type checking with tsconfig.
+         * This enables `projectService` and `strictTypeChecked` rules.
+         * Slower but more accurate type-aware linting.
+         * Set to `false` to disable for faster single-file processing.
+         * @default true
+         */
+        projectTypeCheck?: boolean;
     };
     prettier?: {
         config?: {};

package/dist/core/config.d.ts

@@ -6,7 +6,7 @@ export declare function loadUserConfig(cwd: string): Promise<{
 export declare function generateTempConfig(cwd: string, userConfigResult: {
     config: Config;
     path?: string;
-}, cliLevel?: string, cliCacheDir?: string): Promise<{
+}, cliLevel?: string, cliCacheDir?: string, debug?: boolean, cliProjectTypeCheck?: boolean): Promise<{
     eslintPath: string;
     prettierPath: string;
     cachePath: string;

package/dist/core/config.js

@@ -1,9 +1,12 @@
+import { createJiti } from "jiti";
 import path from "node:path";
 import fs from "fs-extra";
-import { logger } from "../utils/logger.js";
+import { logger, logInfo } from "../utils/logger.js";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { createRequire } from "node:module";
+import { createHash } from "node:crypto";
 const require = createRequire(import.meta.url);
+const pkg = require('../../package.json');
 function getAssetPath(filename) {
     return path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../assets", filename);
 }
@@ -19,80 +22,198 @@ const CONFIG_FILENAMES = [
     "config/rhine-lint.config.cjs",
     "config/rhine-lint.config.json",
 ];
+function getCacheDir(cwd, userConfig, cliCacheDir) {
+    if (cliCacheDir)
+        return path.resolve(cwd, cliCacheDir);
+    if (userConfig?.cacheDir)
+        return path.resolve(cwd, userConfig.cacheDir);
+    const nodeModulesPath = path.join(cwd, "node_modules");
+    if (fs.existsSync(nodeModulesPath))
+        return path.join(nodeModulesPath, ".cache", "rhine-lint");
+    return path.join(cwd, ".cache", "rhine-lint");
+}
 export async function loadUserConfig(cwd) {
-    let configPath;
-    for (const file of CONFIG_FILENAMES) {
-        const p = path.join(cwd, file);
-        if (await fs.pathExists(p)) {
-            configPath = p;
-            break;
+    const jiti = createJiti(fileURLToPath(import.meta.url));
+    for (const filename of CONFIG_FILENAMES) {
+        const configPath = path.join(cwd, filename);
+        if (await fs.pathExists(configPath)) {
+            try {
+                const configModule = jiti(configPath);
+                const config = configModule.default || configModule;
+                logInfo(`Using config file: ${configPath}`);
+                return { config, path: configPath };
+            }
+            catch (e) {
+                logger.error(`Failed to load config file ${configPath}:`, e);
+                process.exit(1);
+            }
         }
     }
-    if (!configPath) {
-        return { config: {} };
-    }
+    logInfo("No config file found, using default configuration.");
+    return { config: {} };
+}
+export async function generateTempConfig(cwd, userConfigResult, cliLevel, cliCacheDir, debug, cliProjectTypeCheck) {
+    const cachePath = getCacheDir(cwd, userConfigResult.config, cliCacheDir);
+    await fs.ensureDir(cachePath);
+    const eslintTempPath = path.join(cachePath, "eslint.config.mjs");
+    const prettierTempPath = path.join(cachePath, "prettier.config.mjs");
+    const metaPath = path.join(cachePath, "metadata.json");
+    const gitignorePath = path.join(cwd, ".gitignore");
+    // Determine projectTypeCheck: CLI flag takes precedence over config file, default is true
+    // When --no-project-type-check is used, options.projectTypeCheck will be false
+    const projectTypeCheck = cliProjectTypeCheck ?? userConfigResult.config.eslint?.projectTypeCheck ?? true;
+    let calculatedHash = "";
     try {
-        // logInfo(`Loading config from ${configPath}`);
-        const isJson = configPath.endsWith(".json");
-        let loaded;
-        if (isJson) {
-            loaded = await fs.readJson(configPath);
+        const hash = createHash("sha256");
+        hash.update(pkg.version || "0.0.0");
+        hash.update(cliLevel || "default");
+        hash.update(projectTypeCheck ? "ptc-on" : "ptc-off");
+        if (userConfigResult.path && await fs.pathExists(userConfigResult.path)) {
+            const content = await fs.readFile(userConfigResult.path);
+            hash.update(content);
+        }
+        if (await fs.pathExists(gitignorePath)) {
+            const content = await fs.readFile(gitignorePath);
+            hash.update(content);
         }
         else {
-            const importUrl = pathToFileURL(configPath).href;
-            const mod = await import(importUrl);
-            loaded = mod.default || mod;
+            hash.update("no-gitignore");
+        }
+        calculatedHash = hash.digest("hex");
+        if (await fs.pathExists(metaPath)) {
+            const meta = await fs.readJson(metaPath);
+            if (meta.hash === calculatedHash && await fs.pathExists(eslintTempPath) && await fs.pathExists(prettierTempPath)) {
+                logger.debug(`Cache hit! Configs reused from ${cachePath}`);
+                return { eslintPath: eslintTempPath, prettierPath: prettierTempPath, cachePath };
+            }
         }
-        return {
-            config: loaded || {},
-            path: configPath
-        };
     }
     catch (e) {
-        logger.debug("Failed to load user config.", e);
-        logger.warn(`Found config file at ${configPath} but failed to load it.`);
-        return { config: {} };
+        logger.debug("Cache check failed, regenerating...", e);
     }
-}
-function getCacheDir(cwd, userConfig, cliCacheDir) {
-    // 1. CLI option
-    if (cliCacheDir) {
-        return path.resolve(cwd, cliCacheDir);
+    let ignoredPatterns = [];
+    // Parse .gitignore file and convert to ESLint ignore patterns
+    // ESLint ignores are relative to the cwd where ESLint runs (which is the project root)
+    // NOT relative to the config file location
+    const parseGitignore = (content) => {
+        const patterns = [];
+        const lines = content.split('\n');
+        for (let line of lines) {
+            // Remove Windows line endings and trim
+            line = line.replace(/\r$/, '').trim();
+            // Skip empty lines and comments
+            if (!line || line.startsWith('#'))
+                continue;
+            // Handle negation (un-ignore)
+            const isNegation = line.startsWith('!');
+            if (isNegation) {
+                line = line.slice(1);
+            }
+            // Determine if pattern is rooted (starts with /)
+            const isRooted = line.startsWith('/');
+            if (isRooted) {
+                line = line.slice(1);
+            }
+            // Normalize path separators
+            line = line.replace(/\\/g, '/');
+            // Handle directory patterns (ends with /)
+            const isDir = line.endsWith('/');
+            if (isDir) {
+                line = line.slice(0, -1);
+            }
+            // Build the ESLint ignore pattern
+            // Patterns are relative to the cwd where ESLint runs (project root)
+            let pattern;
+            if (isRooted) {
+                // Rooted patterns: only match at project root
+                // e.g., /node_modules -> node_modules/**
+                pattern = line;
+            }
+            else {
+                // Non-rooted patterns: match anywhere in the tree
+                // e.g., .next -> **/.next/**
+                pattern = `**/${line}`;
+            }
+            // Add /** suffix for directories and patterns that should match all contents
+            if (isDir || !line.includes('*')) {
+                // Check if it's likely a directory (no extension or common directory names)
+                const shouldMatchContents = isDir ||
+                    !path.extname(line) ||
+                    line.endsWith('.next') ||
+                    line.endsWith('.git') ||
+                    line.endsWith('.cache');
+                if (shouldMatchContents && !pattern.endsWith('/**')) {
+                    pattern += '/**';
+                }
+            }
+            // Apply negation prefix for ESLint if this was an un-ignore pattern
+            if (isNegation) {
+                pattern = '!' + pattern;
+            }
+            patterns.push(pattern);
+        }
+        return patterns;
+    };
+    // Default directories to always ignore (relative to project root)
+    const defaultIgnores = [
+        'node_modules', 'dist', '.next', '.git', '.output', '.nuxt', 'coverage', '.cache'
+    ].map(dir => `**/${dir}/**`);
+    if (await fs.pathExists(gitignorePath)) {
+        try {
+            const gitignoreContent = await fs.readFile(gitignorePath, 'utf-8');
+            if (debug) {
+                console.log("-----------------------------------------");
+                console.log("DEBUG: .gitignore content preview:");
+                console.log(gitignoreContent.substring(0, 500));
+                console.log("-----------------------------------------");
+            }
+            const parsedPatterns = parseGitignore(gitignoreContent);
+            if (debug) {
+                console.log("-----------------------------------------");
+                console.log("DEBUG: Parsed gitignore patterns:");
+                parsedPatterns.forEach((p, i) => console.log(`  [${i}] "${p}"`));
+                console.log("-----------------------------------------");
+            }
+            // Merge defaults with parsed patterns, removing duplicates
+            const allPatterns = [...defaultIgnores, ...parsedPatterns];
+            ignoredPatterns = [...new Set(allPatterns)];
+        }
+        catch (e) {
+            logger.debug("Failed to parse .gitignore", e);
+            ignoredPatterns = defaultIgnores;
+        }
     }
-    // 2. Config option
-    if (userConfig?.cacheDir) {
-        return path.resolve(cwd, userConfig.cacheDir);
+    else {
+        ignoredPatterns = defaultIgnores;
     }
-    // 3. Default: node_modules/.cache/rhine-lint
-    const nodeModulesPath = path.join(cwd, "node_modules");
-    if (fs.existsSync(nodeModulesPath)) {
-        return path.join(nodeModulesPath, ".cache", "rhine-lint");
+    if (debug) {
+        console.log("-----------------------------------------");
+        console.log("DEBUG: Final Ignores List:");
+        ignoredPatterns.forEach(p => console.log(p));
+        console.log("-----------------------------------------");
     }
-    // 4. Fallback: .cache/rhine-lint in root
-    return path.join(cwd, ".cache", "rhine-lint");
-}
-export async function generateTempConfig(cwd, userConfigResult, cliLevel, cliCacheDir) {
-    const cachePath = getCacheDir(cwd, userConfigResult.config, cliCacheDir);
-    await fs.ensureDir(cachePath);
-    const eslintTempPath = path.join(cachePath, "eslint.config.mjs");
-    const prettierTempPath = path.join(cachePath, "prettier.config.mjs");
     const defaultEslintPath = pathToFileURL(getAssetPath("eslint.config.js")).href;
     const defaultPrettierPath = pathToFileURL(getAssetPath("prettier.config.js")).href;
     const userConfigUrl = userConfigResult.path ? pathToFileURL(userConfigResult.path).href : null;
     const defuUrl = pathToFileURL(require.resolve("defu")).href;
     const jitiUrl = pathToFileURL(require.resolve("jiti")).href;
-    // Resolve @eslint/compat for includeIgnoreFile if needed
-    // We assume @eslint/compat is installed as dependency of rhine-lint
-    let compatUrl = null;
-    try {
-        compatUrl = pathToFileURL(require.resolve("@eslint/compat")).href;
-    }
-    catch (e) {
-        // ignore
+    let finalUserConfigUrl = userConfigUrl;
+    if (userConfigResult.path && (userConfigResult.path.endsWith('.ts') || userConfigResult.path.endsWith('.mts') || userConfigResult.path.endsWith('.cts'))) {
+        try {
+            const ts = await import('typescript');
+            const fileContent = await fs.readFile(userConfigResult.path, 'utf-8');
+            const transpiled = ts.transpileModule(fileContent, {
+                compilerOptions: { module: ts.ModuleKind.ESNext, target: ts.ScriptTarget.ESNext }
+            });
+            const compiledName = 'rhine-lint.user-config.mjs';
+            const compiledPath = path.join(cachePath, compiledName);
+            await fs.writeFile(compiledPath, transpiled.outputText);
+            finalUserConfigUrl = pathToFileURL(compiledPath).href;
+        }
+        catch (e) {
+            logger.debug("Failed to transpile user config.", e);
+        }
     }
-    const gitignorePath = path.join(cwd, ".gitignore");
-    const hasGitignore = await fs.pathExists(gitignorePath);
-    const gitignoreUrl = hasGitignore ? pathToFileURL(gitignorePath).href : null;
     const isEslintOverlay = userConfigResult.config.eslint?.overlay ?? false;
     const isPrettierOverlay = userConfigResult.config.prettier?.overlay ?? false;
     const eslintContent = `
@@ -101,36 +222,35 @@ import { fileURLToPath } from "node:url";
 import path from "node:path";
 import createConfig from "${defaultEslintPath}";
 import { defu } from "${defuUrl}";
-${compatUrl && hasGitignore ? `import { includeIgnoreFile } from "${compatUrl}";` : ''}
-
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const jiti = createJiti(__filename);
 
-${userConfigUrl ? `
-const loaded = await jiti.import("${userConfigUrl.replace('file:///', '').replace(/%20/g, ' ')}", { default: true });
+${finalUserConfigUrl ? `
+const loaded = await jiti.import("${finalUserConfigUrl.replace('file:///', '').replace(/%20/g, ' ')}", { default: true });
 const userOne = loaded.default || loaded;
 ` : 'const userOne = {};'}
 
 const userEslint = userOne.eslint || {};
 const level = "${cliLevel || ''}" || userOne.level || "frontend";
 
-let overrides = {};
+// Project-based type checking: CLI flag (${projectTypeCheck}) takes precedence over config file
+const projectTypeCheck = ${projectTypeCheck} || userEslint.projectTypeCheck || false;
+
+let overrides = { ENABLE_PROJECT_BASE_TYPE_CHECKED: projectTypeCheck };
 switch (level) {
-  case "nextjs": overrides = { ENABLE_NEXT: true }; break;
-  case "frontend": overrides = { ENABLE_FRONTEND: true, ENABLE_NEXT: false }; break;
-  case "ts": overrides = { ENABLE_FRONTEND: false }; break;
-  case "js": overrides = { ENABLE_FRONTEND: false, ENABLE_TYPE_CHECKED: false }; break;
+  case "nextjs": overrides = { ...overrides, ENABLE_NEXT: true }; break;
+  case "frontend": overrides = { ...overrides, ENABLE_FRONTEND: true, ENABLE_NEXT: false }; break;
+  case "ts": overrides = { ...overrides, ENABLE_FRONTEND: false }; break;
+  case "js": overrides = { ...overrides, ENABLE_FRONTEND: false, ENABLE_TYPE_CHECKED: false }; break;
 }
 
 const defaultEslint = createConfig(overrides);
-
 let finalConfig;
-
-// Prepend ignore file if exists
 const prefixConfig = [];
-${compatUrl && hasGitignore && gitignoreUrl ? `
-prefixConfig.push(includeIgnoreFile("${gitignoreUrl.replace('file:///', '').replace(/%20/g, ' ')}"));
+
+${ignoredPatterns.length > 0 ? `
+prefixConfig.push({ ignores: ${JSON.stringify(ignoredPatterns)} });
 ` : ''}
 
 if (${isEslintOverlay} || userEslint.overlay) {
@@ -138,7 +258,6 @@ if (${isEslintOverlay} || userEslint.overlay) {
         finalConfig = [...prefixConfig, ...defaultEslint, ...userEslint.config];
     } else {
         finalConfig = defu(userEslint, defaultEslint); 
-        // Note: merging object into array-based config is weird, assume flat config array concatenation for robustness
         if (!Array.isArray(finalConfig)) finalConfig = [...prefixConfig, finalConfig];
     }
 } else {
@@ -175,14 +294,11 @@ export default finalConfig;
 `;
     await fs.writeFile(eslintTempPath, eslintContent);
     await fs.writeFile(prettierTempPath, prettierContent);
+    await fs.writeJson(metaPath, { hash: calculatedHash, timestamp: Date.now() });
     return { eslintPath: eslintTempPath, prettierPath: prettierTempPath, cachePath };
 }
 export async function cleanup(cachePath) {
     if (cachePath && await fs.pathExists(cachePath)) {
-        // Safety check: ensure we are deleting a temp dir we own
-        // If it's node_modules/.cache/rhine-lint, delete it
-        // If it's custom, delete it (careful?)
-        // Generally standard to remove temp config dir.
-        await fs.remove(cachePath);
+        // await fs.remove(cachePath); 
     }
 }

package/dist/core/runner.js

@@ -1,38 +1,82 @@
 import { spawn } from "node:child_process";
+import { createRequire } from "node:module";
+import path from "node:path";
+import fs from "fs-extra";
 import { logger, logInfo, logError } from "../utils/logger.js";
-const IS_BUN = typeof process.versions.bun !== "undefined";
-const EXECUTOR = IS_BUN ? "bunx" : "npx";
-// Helper to strip ANSI codes for easier regex matching
+const require = createRequire(import.meta.url);
 function stripAnsi(str) {
     return str.replace(/[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g, '');
 }
+/**
+ * Robustly resolve a binary path from a package, handling exports restrictions.
+ */
+function resolveBin(pkgName, binPathRelative) {
+    // 1. Try strict resolve (fastest, but might be blocked by exports)
+    try {
+        return require.resolve(`${pkgName}/${binPathRelative}`);
+    }
+    catch (e) {
+        if (e.code !== 'ERR_PACKAGE_PATH_NOT_EXPORTED' && e.code !== 'MODULE_NOT_FOUND') {
+            logger.debug(`Resolve error for ${pkgName}/${binPathRelative}:`, e);
+        }
+    }
+    // 2. Fallback: Resolve main entry point, then traverse up to find package root
+    try {
+        const mainPath = require.resolve(pkgName);
+        let currentDir = path.dirname(mainPath);
+        // Traverse up (max 5 levels) to find package.json
+        for (let i = 0; i < 5; i++) {
+            const pkgJsonPath = path.join(currentDir, "package.json");
+            if (fs.existsSync(pkgJsonPath)) {
+                try {
+                    const pkg = fs.readJsonSync(pkgJsonPath);
+                    if (pkg.name === pkgName) {
+                        // Found it! Construct bin path
+                        const binPath = path.join(currentDir, binPathRelative);
+                        if (fs.existsSync(binPath)) {
+                            return binPath;
+                        }
+                    }
+                }
+                catch {
+                    // Ignore parsing errors
+                }
+            }
+            if (currentDir === path.dirname(currentDir))
+                break; // Root reached
+            currentDir = path.dirname(currentDir);
+        }
+    }
+    catch (e) {
+        logger.debug(`Deep resolve failed for ${pkgName}:`, e);
+    }
+    // 3. Fallback to system PATH (bare command)
+    return pkgName;
+}
 export async function runCommandWithOutput(command, args, cwd) {
     return new Promise((resolve, reject) => {
         logger.debug(`Executing: ${command} ${args.join(" ")}`);
         const proc = spawn(command, args, {
             cwd,
-            stdio: ["inherit", "pipe", "pipe"], // Pipe stdout/stderr so we can read it
-            shell: true,
+            stdio: ["inherit", "pipe", "pipe"],
+            shell: false,
         });
         let output = "";
         if (proc.stdout) {
             proc.stdout.on("data", (data) => {
-                process.stdout.write(data); // Passthrough to console
+                process.stdout.write(data);
                 output += data.toString();
             });
         }
         if (proc.stderr) {
             proc.stderr.on("data", (data) => {
-                process.stderr.write(data); // Passthrough to console
+                process.stderr.write(data);
                 output += data.toString();
             });
         }
         proc.on("close", (code) => {
-            // Resolve all exit codes (even 1 or 2 or others) so we can parse output.
-            // But we might want to differentiate "crash" vs "lint failure".
-            // ESLint exit code 1 = user lint error. code 2 = config/crash error.
             if (code === null)
-                code = 1; // Default to error if null
+                code = 1;
             resolve({ output, code });
         });
         proc.on("error", (err) => {
@@ -40,83 +84,75 @@ export async function runCommandWithOutput(command, args, cwd) {
         });
     });
 }
-// Return type: null means success (no errors), string means summary of errors/warnings
 export async function runEslint(cwd, configPath, fix, files = ["."]) {
     logInfo("Running ESLint...");
     console.log();
+    const eslintBin = resolveBin("eslint", "bin/eslint.js");
     const args = [
-        "eslint",
+        eslintBin,
         ...files,
         "--config", configPath,
         ...(fix ? ["--fix"] : []),
     ];
     try {
-        const { output, code } = await runCommandWithOutput(EXECUTOR, args, cwd);
-        if (!output.endsWith('\n')) {
-            console.log();
+        const { output, code } = await runCommandWithOutput(process.execPath, args, cwd);
+        if (code !== 0 && code !== 1) {
+            return `Process failed with exit code ${code}`;
         }
         const cleanOutput = stripAnsi(output);
-        // Try to match standard ESLint summary: "✖ 5 problems (5 errors, 0 warnings)"
-        const match = cleanOutput.match(/✖ (\d+) problems? \((\d+) errors?, (\d+) warnings?\)/);
-        if (match) {
-            return `${match[1]} problems (${match[2]} errors, ${match[3]} warnings)`;
-        }
-        // Check if there are errors but no summary line
-        if (cleanOutput.includes("error") || cleanOutput.includes("warning")) {
-            // Maybe custom format or specific error
-            // Try to count occurences of "error"
-            const errorCount = (cleanOutput.match(/error/gi) || []).length;
-            if (errorCount > 0)
-                return `${errorCount} issues found`;
-            return "Issues found";
+        const problemMatch = cleanOutput.match(/(\d+) problems? \((\d+) errors?, (\d+) warnings?\)/);
+        if (problemMatch) {
+            return problemMatch[0];
         }
-        // Key Fix: If exit code is non-zero and we haven't found a "summary" above, it's a crash or unparsed error.
-        if (code !== 0) {
-            return `Process failed with exit code ${code}`;
+        const errorMatch = cleanOutput.match(/(\d+) error/);
+        if (errorMatch) {
+            return `${errorMatch[0]} found`;
         }
-        return null;
+        if (code === 0)
+            return null;
+        return "Issues found";
     }
     catch (e) {
-        logError("ESLint execution failed.", e);
-        throw e;
+        logError("Failed to run ESLint", e);
+        return e.message || "Unknown error";
     }
 }
 export async function runPrettier(cwd, configPath, fix, files = ["."]) {
     logInfo("Running Prettier...");
-    console.log();
+    // Try Prettier v3 path first, then fallback (v3: bin/prettier.cjs, v2: bin-prettier.js)
+    let prettierBin = resolveBin("prettier", "bin/prettier.cjs");
+    // If resolved to "prettier" (PATH) or logic failed, check if file exists, if not try legacy
+    // Actually resolveBin returns bare "prettier" if not found.
+    // If it is just "prettier", we might want to try legacy path too before giving up.
+    if (prettierBin === "prettier" || !fs.existsSync(prettierBin)) {
+        const legacy = resolveBin("prettier", "bin-prettier.js");
+        if (legacy !== "prettier" && fs.existsSync(legacy)) {
+            prettierBin = legacy;
+        }
+    }
     const args = [
-        "prettier",
-        ...files,
-        "--config", configPath,
+        prettierBin,
         ...(fix ? ["--write"] : ["--check"]),
+        "--config", configPath,
+        "--ignore-path", ".gitignore",
+        ...files
     ];
     try {
-        const { output, code } = await runCommandWithOutput(EXECUTOR, args, cwd);
-        if (!output.endsWith('\n')) {
-            console.log();
-        }
-        const cleanOutput = stripAnsi(output);
-        if (!fix) {
-            // In check mode with issues: "Code style issues found in 2 files"
-            const match = cleanOutput.match(/Code style issues found in (\d+) files?/);
-            if (match) {
-                return `${match[1]} unformatted files`;
-            }
-            if (cleanOutput.includes("[warn]")) {
-                return "Style issues found";
-            }
-        }
-        // Prettier specific: exit code 2 usually means error/crash. code 1 (in check mode) means unformatted.
+        const { output, code } = await runCommandWithOutput(process.execPath, args, cwd);
         if (code !== 0) {
-            if (fix && code !== 0)
-                return `Process failed with exit code ${code}`;
-            // In check mode code 1 is covered above usually, but if fallback:
-            return "Style issues found";
+            if (!fix) {
+                if (stripAnsi(output).includes("Code style issues found")) {
+                    return "Code style issues found";
+                }
+                if (code === 1)
+                    return "Formatting issues found";
+            }
+            return `Process failed with exit code ${code}`;
         }
         return null;
     }
     catch (e) {
-        logError("Prettier execution failed.", e);
-        throw e;
+        logError("Failed to run Prettier", e);
+        return e.message || "Unknown error";
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rhine-lint",
-  "version": "1.0.2",
+  "version": "1.3.2",
   "module": "./dist/index.js",
   "type": "module",
   "main": "./dist/index.js",
@@ -34,17 +34,18 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@eslint/compat": "^1.3.2",
     "@eslint/css": "^0.10.0",
     "@eslint/eslintrc": "^3.3.1",
     "@eslint/json": "^0.13.1",
     "@eslint/markdown": "^7.1.0",
     "@next/eslint-plugin-next": "^16.1.1",
+    "ajv": "^8.12.0",
     "cac": "^6.7.14",
     "consola": "^3.4.2",
     "defu": "^6.1.4",
     "eslint": "^9.39.2",
     "eslint-config-prettier": "^10.1.8",
+    "eslint-import-resolver-typescript": "^4.4.4",
     "eslint-plugin-import-x": "^4.16.1",
     "eslint-plugin-react": "^7.37.5",
     "eslint-plugin-react-hooks": "^7.0.1",