rhine-lint 1.0.1 → 1.3.2

package/README.md

@@ -6,25 +6,22 @@
   <img src="https://img.shields.io/badge/style-opinionated-blue?style=flat-square" alt="style" />
 </p>
 
-> **现在的 Web 开发中，配置 ESLint、Prettier、TypeScript 以及各种插件（React, Next.js, CSS, Markdown...）往往是一场噩梦。**
-> 重复的样板代码、版本冲突、复杂的 Flat Config 迁移... **Rhine Lint** 旨在结束这一切。
-
 **Rhine Lint** 是一个「零配置」的现代化代码规范解决方案。它深度整合了 **ESLint (v9 Flat Config)** 与 **Prettier**，为你提供开箱即用的最佳实践。你无需再手动安装数十个 `eslint-plugin-*` 依赖，也无需编写数百行的配置文件。只需一个依赖，一行命令，即可获得顶级的代码质量守护。
 
-## ✨ 特性 (Features)
+## 特性 Features
 
-- **⚡️ 零配置启动 (Zero Config)**: 默认提供适用于 TypeScript、React、Next.js 的最佳实践配置，安装即用。
-- **🛠️ 统一工具链 (Unified Toolchain)**: 一个 `rl` 命令同时执行代码检查 (Lint) 和代码格式化 (Format)。
-- **🏗️ 全栈支持 (Full Stack)**:
+- **零配置启动 Zero Config**: 默认提供适用于 TypeScript、React、Next.js 的最佳实践配置，安装即用。
+- **统一工具链 Unified Toolchain**: 一个 `rl` 命令同时执行代码检查 (Lint) 和代码格式化 (Format)。
+- **全栈支持 Full Stack**:
   - **JavaScript / TypeScript**: 完整的类型检查支持。
   - **Frontend**: React (v18/v19), React Hooks, JSX A11y.
   - **Frameworks**: Next.js (Pages & App Router).
   - **Styles**: CSS, SCSS format supports.
   - **Others**: JSON, Markdown support.
-- **🔧 智能配置生成 (Smart Config)**: 运行时动态生成配置文件，无需担心 ESLint/Prettier 配置文件污染项目根目录。
-- **🧩 灵活扩展 (Extensible)**: 支持 `rhine-lint.config.ts` 进行规则覆盖或深度定制。
+- **智能配置生成 Smart Config**: 运行时动态生成配置文件，无需担心 ESLint/Prettier 配置文件污染项目根目录。
+- **灵活扩展 Extensible**: 支持 `rhine-lint.config.ts` 进行规则覆盖或深度定制。
 
-## 📦 安装 (Installation)
+## 安装 Installation
 
 在你的项目中作为开发依赖安装：
 
@@ -42,7 +39,7 @@ pnpm add -D rhine-lint
 yarn add -D rhine-lint
 ```
 
-## 🚀 快速开始 (Quick Start)
+## 快速开始 Quick Start
 
 ### 命令行使用 (CLI)
 
@@ -75,7 +72,7 @@ npx rl --level nextjs
 }
 ```
 
-## ⚙️ 配置 (Configuration)
+## 配置 Configuration
 
 虽然 Rhine Lint 是零配置的，但也支持通过配置文件进行深度定制。它会自动检测项目根目录下的 `rhine-lint.config.{ts,js,mjs,json}`。
 
@@ -90,7 +87,10 @@ export default {
   level: 'nextjs',
 
   // 是否默认开启修复模式 (可选)
-  fix: false,
+  fix: false, 
+  
+  // 自定义缓存目录 (可选)
+  // cacheDir: './.cache/rhine-lint',
 
   // ESLint 专项配置
   eslint: {
@@ -110,6 +110,7 @@ export default {
           'react/no-unknown-property': 'off'
         }
       }
+      // ...
     ]
   },
 
@@ -117,7 +118,8 @@ export default {
   prettier: {
     config: {
       printWidth: 100,
-      semi: true
+      semi: true,
+      // ...
     }
   }
 } as Config;
@@ -130,9 +132,24 @@ 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`）。
 
-## 🔍 项目级别 (Project Levels)
+### 缓存目录 Cache Directory
+
+Rhine Lint 需要一个目录来存放运行时动态生成的 "Virtual Config" 文件。这些文件是临时的，通常不需要用户关心。
+缓存目录的解析优先级如下（由高到低）：
+
+1. **CLI 参数**: 命令行中显式指定 `--cache-dir <path>`。
+2. **配置文件**: `rhine-lint.config.ts` 中的 `cacheDir` 字段。
+3. **默认位置 (标准)**: `node_modules/.cache/rhine-lint`（如果项目中有 `node_modules` 目录）。
+4. **回退位置**: `.cache/rhine-lint`（如果找不到 `node_modules`，则在项目根目录下创建）。
+
+> **注意**: 如果你的项目触发了第 4 种情况（回退位置），建议将 `.cache/` 添加到你的 `.gitignore` 文件中，以免这些临时文件被提交到版本库。正常情况下，Rhine Lint 会在执行结束后尝试清理这些临时文件，但保留在 `.gitignore` 中是更安全的做法。
+
+## 项目级别 Project Levels
 
 Rhine Lint 根据 `level` 参数加载不同的规则集：
 
@@ -141,48 +158,114 @@ Rhine Lint 根据 `level` 参数加载不同的规则集：
 - **`frontend`** (默认): 前端 React 项目。包含 `ts` 级别所有规则，加上 `React`, `React Hooks`, `JSX` 相关规则。
 - **`nextjs`**: Next.js 项目。包含 `frontend` 级别所有规则，加上 `@next/eslint-plugin-next` 的 Core Web Vitals 等规则。
 
-## 🧠 技术实现与原理 (Implementation Details)
+## 技术实现与原理 Implementation Insights
 
-Rhine Lint 不仅仅是一个简单的 ESLint 配置包，它是一个 **Linter Orchestrator (检查器编排工具)**。以下是其内部工作流程，帮助理解它是如何保持项目清洁的。
+本章节详细阐述 **Rhine Lint** 的内部工作机制。如果你希望为本项目贡献代码，或者想深度定制功能，可以通过以下内容快速上手。
 
-### 1. 动态配置生成 (Dynamic Configuration Generation)
-传统的 ESLint 配置共享方式通常要求用户在项目中创建一个 `eslint.config.js` 并 `extend` 一个包。Rhine Lint 采用了不同的策略：**(Virtual Configuration)**。
+Rhine Lint 的核心本质是一个 **Configuration Factory (配置工厂)** 与 **Execution Orchestrator (执行编排器)**。它并没有重写 Linter，而是站在巨人的肩膀上（ESLint & Prettier），通过一层薄封装来解决配置复杂性问题。
 
-当你运行 `rl` 时：
-1.  **读取配置**: 它首先读取用户的 `rhine-lint.config.ts`。
-2.  **生成临时配置**: 在缓存目录（如 `node_modules/.cache/rhine-lint/`）中，它会基于内存中的逻辑动态生成真实的 `eslint.config.mjs` 和 `prettier.config.mjs` 文件。
-    - 这个过程将 `rhine-lint` 内部预设的规则与用户的自定义规则进行合并。
-    - 它自动处理了 `tsconfig.json` 的路径解析、Ignore 文件的合并等复杂逻辑。
-3.  **环境隔离**: 这种方式确保了你的项目根目录不会被各种工具的配置文件弄乱。
+### 1. 核心架构 Core Architecture
 
-### 2. 执行流程 (Execution Flow)
-Rhine Lint 实际上是 ESLint 和 Prettier 之上的一个 **Wrapper**：
+整个执行流程可以分为三个阶段：**初始化 (Init)** -> **生成 (Generate)** -> **执行 (Execute)**。
 
 ```mermaid
-graph LR
-    User[用户执行 rl] --> CLI[CLI Parser (cac)]
-    CLI --> Config[Config Loader]
-    Config --> Gen[Config Generator]
-    Gen --> Cache[写入临时 Config (.cache/)]
+graph TD
+    CLI[src/cli.ts] -->|解析参数| ConfigMgr[src/core/config.ts]
+    
+    subgraph Configuration Phase
+    ConfigMgr -->|1. 读取用户配置| UserConfig[rhine-lint.config.ts]
+    ConfigMgr -->|2. 读取内置模板| Assets[src/assets/*.js]
+    ConfigMgr -->|3. 合并与编译| VirtualConfig[生成临时 Config\n.cache/rhine-lint/*.mjs]
+    end
     
-    Cache --> AsyncRun{并发执行}
-    AsyncRun --> ESLint[Spawn: ESLint]
-    AsyncRun --> Prettier[Spawn: Prettier]
+    subgraph Execution Phase
+    CLI --> Executor[src/core/runner.ts]
+    Executor -->|Spawn Process| ESLint[(ESLint Binary)]
+    Executor -->|Spawn Process| Prettier[(Prettier Binary)]
+    ESLint -.->|读取| VirtualConfig
+    Prettier -.->|读取| VirtualConfig
+    end
     
-    ESLint --> Output[输出结果]
-    Prettier --> Output
+    ESLint -->|Output| Formatter[结果清洗与展示]
+    Prettier -->|Output| Formatter
 ```
 
-- **ESLint 执行**: 调用 `eslint` 二进制文件，指向生成的临时配置文件。利用 ESLint v9 的 Flat Config 系统，实现了极快的文件匹配和规则计算。
-- **Prettier 执行**: 调用 `prettier` 二进制文件，同样指向临时配置文件。
-- **结果聚合**: `rl` 会捕获子进程的输出流，进行清洗和格式化，最终以统一的格式呈现给用户。如果任一工具报错，`rl` 也会以非零状态码退出，确保 CI/CD 流程的正确性。
-
-### 3. 技术栈 (Tech Stack)
-- **Runtime**: Node.js (支持 ESM).
-- **ESLint v9**: 全面拥抱 Flat Config，不再支持旧版 `.eslintrc`。
-- **Prettier**: 强固的代码格式化。
-- **TypeScript-ESLint**: 最新的 TS 解析器和规则插件。
-- **Core Plugins**: 集成了 `eslint-plugin-react`, `eslint-plugin-react-hooks`, `@next/eslint-plugin-next`, `eslint-plugin-import-x`, `eslint-plugin-unused-imports`, `@eslint/markdown`, `@eslint/css` 等数十个核心插件。
+### 2. 模块详解 Module Deep Dive
+
+#### CLI 入口 (`src/cli.ts`)
+- **职责**: 程序的入口点。
+- **实现**: 使用 `cac` 库处理命令行参数（如 `--fix`, `--level`）。
+- **逻辑**: 
+  1. 它不会直接调用 ESLint API，而是准备好环境路径。
+  2. 调用 `generateTempConfig` 准备配置文件。
+  3. 调用 `runEslint` 和 `runPrettier` 启动子进程。
+  4. 最终根据子进程的 exit code 决定 `rl` 命令是成功还是失败。
+
+#### 配置生成器 (`src/core/config.ts`) 🔥核心
+这是项目最复杂的部分。为了实现「零配置」且不污染用户目录，我们采用 **虚拟配置 (Virtual Configuration)** 策略。
+
+- **动态生成**: 我们不依赖用户项目里的 `.eslintrc`。相反，我们在运行时，在 `node_modules/.cache/rhine-lint/` 下生成一个真实的 `eslint.config.mjs`。
+- **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/`)
+这里存放了 Lint 规则的「源头」。
+
+- **`eslint.config.js`**: 这是一个 **Factory Function**。它导出一个 `createConfig(options)` 函数。
+  - **Flat Config**: 采用了 ESLint v9 的 Flat Config 数组格式。
+  - **按需加载**: 根据传入的 `options.level` (如 `frontend` 或 `nextjs`)，它会动态 `push` 不同的配置块（Block）到数组中。例如，只有在 `nextjs` 模式下，才会加载 `@next/eslint-plugin-next` 相关规则。
+  - **插件集成**: 所有插件（`react`, `import-x`, `unused-imports` 等）都在这里被引入并配置。
+
+#### 执行引擎 (`src/core/runner.ts`)
+- **进程隔离**: 我们使用 Node.js 的 `child_process.spawn` 来调用 `eslint` 和 `prettier` 的可执行文件。
+- **为什么不使用 API?**: 
+  - 使用 API (如 `new ESLint()`) 可能会导致单例冲突，或者在某些边缘情况下与 CLI 行为不一致。
+  - 通过 spawn 调用 CLI 能够最大程度保证兼容性，并且利用多核 CPU 并行运行 Lint 和 Prettier。
+- **输出清洗**: 原生的 ESLint 输出对于普通用户来说可能太过冗长。我们在这一层捕获 stdout/stderr，移除了 ANSI 乱码，并提取出关键的 "X problems found" 摘要信息，给用户最直观的反馈。
+
+### 3. 开发指引 Development Guide
+
+如果你想为 Rhine Lint 添加新功能，请遵循以下路径：
+
+#### 添加一个新的 ESLint 插件
+1. **安装依赖**: 在 `rhine-lint` 项目中安装插件，例如 `bun add eslint-plugin-vue`。
+2. **注册插件**: 修改 `src/assets/eslint.config.js`。
+   - 导入插件。
+   - 在 `createConfig` 函数中，添加新的逻辑分支（例如 `if (OPTIONS.ENABLE_VUE) { ... }`）。
+   - 定义好 `plugins` 和 `rules`。
+3. **更新类型**: 在 `src/config.ts` 的 `Config` 类型定义中添加新的 Scope 开关。
+4. **测试**: 在 `playground` 目录中创建一个 Vue 文件，运行 `bun start --level vue` (假设你添加了 vue level) 进行验证。
+
+#### 调试 (Debugging)
+本项目完全使用 TypeScript 编写。
+
+- **Build**: `bun run build` (使用 `tsc` 编译到 `dist/`)。
+- **Link**: 在本项目根目录运行 `npm link`，然后在测试项目运行 `npm link rhine-lint`。
+- **Watch**: 也可以使用 `bun run dev` (如果配置了) 或手动监听文件变化。
+
+### 4. 目录结构
+
+```text
+rhine-lint/
+├── src/
+│   ├── assets/              # 默认的配置文件模板 (ESLint/Prettier)
+│   ├── core/
+│   │   ├── config.ts        # 配置加载与临时文件生成逻辑
+│   │   └── runner.ts        # 子进程执行器
+│   ├── utils/               # 工具函数 (Logger 等)
+│   ├── cli.ts               # 命令行入口
+│   ├── config.ts            # 类型定义
+│   └── index.ts             # 导出给用户的 API
+├── scripts/                 # 构建脚本
+└── package.json
+```
 
 ---
 

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.1",
+  "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",