rhine-lint 1.0.0

package/dist/core/config.js

@@ -0,0 +1,188 @@
+import path from "node:path";
+import fs from "fs-extra";
+import { logger } from "../utils/logger.js";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
+function getAssetPath(filename) {
+    return path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../assets", filename);
+}
+const CONFIG_FILENAMES = [
+    "rhine-lint.config.ts",
+    "rhine-lint.config.js",
+    "rhine-lint.config.mjs",
+    "rhine-lint.config.cjs",
+    "rhine-lint.config.json",
+    "config/rhine-lint.config.ts",
+    "config/rhine-lint.config.js",
+    "config/rhine-lint.config.mjs",
+    "config/rhine-lint.config.cjs",
+    "config/rhine-lint.config.json",
+];
+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;
+        }
+    }
+    if (!configPath) {
+        return { config: {} };
+    }
+    try {
+        // logInfo(`Loading config from ${configPath}`);
+        const isJson = configPath.endsWith(".json");
+        let loaded;
+        if (isJson) {
+            loaded = await fs.readJson(configPath);
+        }
+        else {
+            const importUrl = pathToFileURL(configPath).href;
+            const mod = await import(importUrl);
+            loaded = mod.default || mod;
+        }
+        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: {} };
+    }
+}
+function getCacheDir(cwd, userConfig, cliCacheDir) {
+    // 1. CLI option
+    if (cliCacheDir) {
+        return path.resolve(cwd, cliCacheDir);
+    }
+    // 2. Config option
+    if (userConfig?.cacheDir) {
+        return path.resolve(cwd, userConfig.cacheDir);
+    }
+    // 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");
+    }
+    // 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
+    }
+    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 = `
+import { createJiti } from "${jitiUrl}";
+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 });
+const userOne = loaded.default || loaded;
+` : 'const userOne = {};'}
+
+const userEslint = userOne.eslint || {};
+const level = "${cliLevel || ''}" || userOne.level || "frontend";
+
+let overrides = {};
+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;
+}
+
+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, ' ')}"));
+` : ''}
+
+if (${isEslintOverlay} || userEslint.overlay) {
+    if (Array.isArray(userEslint.config)) {
+        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 {
+    const userConf = userEslint.config || [];
+    const defaultConf = Array.isArray(defaultEslint) ? defaultEslint : [defaultEslint];
+    finalConfig = [...prefixConfig, ...defaultConf, ...userConf];
+}
+
+export default finalConfig;
+`;
+    const prettierContent = `
+import { createJiti } from "${jitiUrl}";
+import defaultOne from "${defaultPrettierPath}";
+import { defu } from "${defuUrl}";
+
+const jiti = createJiti(import.meta.url);
+
+${userConfigUrl ? `
+const loaded = await jiti.import("${userConfigUrl}", { default: true });
+const userOne = loaded.default || loaded;
+` : 'const userOne = {};'}
+
+const userPrettier = userOne.prettier || {};
+const defaultPrettier = defaultOne;
+
+let finalConfig;
+if (${isPrettierOverlay} || userPrettier.overlay) {
+    finalConfig = defu(userPrettier.config || {}, defaultPrettier);
+} else {
+    finalConfig = defu(userPrettier.config || {}, defaultPrettier);
+}
+
+export default finalConfig;
+`;
+    await fs.writeFile(eslintTempPath, eslintContent);
+    await fs.writeFile(prettierTempPath, prettierContent);
+    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);
+    }
+}

package/dist/core/runner.d.ts

@@ -0,0 +1,6 @@
+export declare function runCommandWithOutput(command: string, args: string[], cwd: string): Promise<{
+    output: string;
+    code: number;
+}>;
+export declare function runEslint(cwd: string, configPath: string, fix: boolean, files?: string[]): Promise<string | null>;
+export declare function runPrettier(cwd: string, configPath: string, fix: boolean, files?: string[]): Promise<string | null>;

package/dist/core/runner.js

@@ -0,0 +1,122 @@
+import { spawn } from "node:child_process";
+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
+function stripAnsi(str) {
+    return str.replace(/[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g, '');
+}
+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,
+        });
+        let output = "";
+        if (proc.stdout) {
+            proc.stdout.on("data", (data) => {
+                process.stdout.write(data); // Passthrough to console
+                output += data.toString();
+            });
+        }
+        if (proc.stderr) {
+            proc.stderr.on("data", (data) => {
+                process.stderr.write(data); // Passthrough to console
+                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
+            resolve({ output, code });
+        });
+        proc.on("error", (err) => {
+            reject(err);
+        });
+    });
+}
+// 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 args = [
+        "eslint",
+        ...files,
+        "--config", configPath,
+        ...(fix ? ["--fix"] : []),
+    ];
+    try {
+        const { output, code } = await runCommandWithOutput(EXECUTOR, args, cwd);
+        if (!output.endsWith('\n')) {
+            console.log();
+        }
+        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";
+        }
+        // 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}`;
+        }
+        return null;
+    }
+    catch (e) {
+        logError("ESLint execution failed.", e);
+        throw e;
+    }
+}
+export async function runPrettier(cwd, configPath, fix, files = ["."]) {
+    logInfo("Running Prettier...");
+    console.log();
+    const args = [
+        "prettier",
+        ...files,
+        "--config", configPath,
+        ...(fix ? ["--write"] : ["--check"]),
+    ];
+    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.
+        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";
+        }
+        return null;
+    }
+    catch (e) {
+        logError("Prettier execution failed.", e);
+        throw e;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export * from './config.js';

package/dist/index.js

@@ -0,0 +1 @@
+export * from './config.js';

package/dist/utils/logger.d.ts

@@ -0,0 +1,5 @@
+export declare const logger: import("consola").ConsolaInstance;
+export declare function logInfo(message: string): void;
+export declare function logSuccess(message: string): void;
+export declare function logWarn(message: string): void;
+export declare function logError(message: string, error?: unknown): void;

package/dist/utils/logger.js

@@ -0,0 +1,29 @@
+import { createConsola } from "consola";
+import { colors } from "consola/utils";
+const { cyan, red, green, yellow } = colors;
+// Custom logger to satisfy "RL" prefix requirement
+const rLine = (colorFn, type, msg) => {
+    console.log(`${colorFn("RL")} ${msg}`);
+};
+export const logger = createConsola({
+    level: 3,
+});
+export function logInfo(message) {
+    // Manually format to match requested style: "RL <message>"
+    console.log(`${cyan("RL")} ${message}`);
+}
+export function logSuccess(message) {
+    console.log(`${green("RL")} ${message}`);
+}
+export function logWarn(message) {
+    console.log(`${yellow("RL")} ${message}`);
+}
+export function logError(message, error) {
+    // For errors, we want red "RL"
+    if (error) {
+        console.error(`${red("RL")} ${message}`, error);
+    }
+    else {
+        console.error(`${red("RL")} ${message}`);
+    }
+}

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "rhine-lint",
+  "version": "1.0.0",
+  "module": "./dist/index.js",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "rl": "./dist/cli.js"
+  },
+  "description": "An opinionated linting solution merging ESLint and Prettier with zero config.",
+  "keywords": [
+    "eslint",
+    "prettier",
+    "lint",
+    "typescript",
+    "nextjs",
+    "react",
+    "opinionated"
+  ],
+  "author": "RhineAI <hran@rhine.ai>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/RhineAI/rhine-lint.git"
+  },
+  "files": [
+    "dist",
+    "LICENSE",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc && node scripts/copy-assets.js",
+    "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",
+    "cac": "^6.7.14",
+    "consola": "^3.4.2",
+    "defu": "^6.1.4",
+    "eslint": "^9.39.2",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-import-x": "^4.16.1",
+    "eslint-plugin-react": "^7.37.5",
+    "eslint-plugin-react-hooks": "^7.0.1",
+    "eslint-plugin-tsdoc": "^0.5.0",
+    "eslint-plugin-unused-imports": "^4.2.0",
+    "fs-extra": "^11.3.3",
+    "jiti": "^2.5.1",
+    "prettier": "^3.6.2",
+    "typescript": "^5",
+    "typescript-eslint": "^8.39.1"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^11.0.4"
+  }
+}