rintenki 0.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026-PRESENT Kazuhiro Kobayashi<https://github.com/kzhrk>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/bin/rintenki.js

@@ -0,0 +1,209 @@
+#!/usr/bin/env node
+
+const { existsSync, readFileSync, writeFileSync } = require("fs");
+const { resolve, relative } = require("path");
+const { glob } = require("tinyglobby");
+const { lint, fix } = require("../index");
+
+const COLORS = {
+  red: "\x1b[31m",
+  yellow: "\x1b[33m",
+  gray: "\x1b[90m",
+  bold: "\x1b[1m",
+  reset: "\x1b[0m",
+};
+
+const CONFIG_FILES = [".rintenkirc.json", ".rintenkirc"];
+const IGNORE_FILE = ".rintenkiignore";
+
+function parseJsonFile(filePath) {
+  try {
+    return JSON.parse(readFileSync(filePath, "utf-8"));
+  } catch (err) {
+    console.error(`Failed to parse config file: ${filePath}`);
+    console.error(err.message);
+    process.exit(1);
+  }
+}
+
+function loadConfig(configPath) {
+  if (configPath) {
+    const abs = resolve(configPath);
+    if (!existsSync(abs)) {
+      console.error(`Config file not found: ${configPath}`);
+      process.exit(1);
+    }
+    return parseJsonFile(abs);
+  }
+
+  for (const name of CONFIG_FILES) {
+    const abs = resolve(name);
+    if (existsSync(abs)) {
+      return parseJsonFile(abs);
+    }
+  }
+
+  return undefined;
+}
+
+function loadIgnorePatterns(config) {
+  const patterns = [];
+
+  // From .rintenkiignore file
+  const ignorePath = resolve(IGNORE_FILE);
+  if (existsSync(ignorePath)) {
+    const content = readFileSync(ignorePath, "utf-8");
+    for (const line of content.split("\n")) {
+      const trimmed = line.trim();
+      if (trimmed && !trimmed.startsWith("#")) {
+        patterns.push(trimmed);
+      }
+    }
+  }
+
+  // From config.ignore field
+  if (config?.ignore && Array.isArray(config.ignore)) {
+    patterns.push(...config.ignore);
+  }
+
+  // Always ignore node_modules
+  patterns.push("**/node_modules/**");
+
+  return patterns;
+}
+
+function formatDiagnostic(diagnostic) {
+  const severity =
+    diagnostic.severity === "error"
+      ? `${COLORS.red}error${COLORS.reset}`
+      : `${COLORS.yellow}warning${COLORS.reset}`;
+  const loc = diagnostic.line != null ? `${COLORS.gray}line ${diagnostic.line}${COLORS.reset}  ` : "";
+  return `  ${loc}${severity}  ${diagnostic.message}  ${COLORS.gray}${diagnostic.rule}${COLORS.reset}`;
+}
+
+function parseArgs(argv) {
+  const args = { files: [], config: undefined, help: false, maxWarnings: -1, format: "stylish", fix: false };
+  let i = 0;
+  while (i < argv.length) {
+    const arg = argv[i];
+    if (arg === "--help" || arg === "-h") {
+      args.help = true;
+    } else if (arg === "--config" || arg === "-c") {
+      args.config = argv[++i];
+    } else if (arg === "--max-warnings") {
+      args.maxWarnings = parseInt(argv[++i], 10);
+    } else if (arg === "--format" || arg === "-f") {
+      args.format = argv[++i];
+    } else if (arg === "--fix") {
+      args.fix = true;
+    } else if (!arg.startsWith("-")) {
+      args.files.push(arg);
+    }
+    i++;
+  }
+  return args;
+}
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+
+  if (args.help || args.files.length === 0) {
+    console.log(`Usage: rintenki [options] <files...>
+
+Options:
+  -c, --config <path>       Path to config file (default: .rintenkirc.json)
+  -f, --format <format>     Output format: stylish (default), json
+  --fix                     Auto-fix fixable issues
+  --max-warnings <number>   Exit with error if warnings exceed this number
+  -h, --help                Show help
+
+Ignore patterns:
+  Create a .rintenkiignore file or use "ignore" in config to exclude files.
+  node_modules is always ignored.
+
+Examples:
+  rintenki index.html
+  rintenki "src/**/*.html"
+  rintenki --format json "src/**/*.html"`);
+    process.exit(0);
+  }
+
+  const config = loadConfig(args.config);
+  const ignorePatterns = loadIgnorePatterns(config);
+  const files = await glob(args.files, { absolute: true, ignore: ignorePatterns });
+
+  if (files.length === 0) {
+    console.error("No files matched the given patterns.");
+    process.exit(1);
+  }
+
+  let totalErrors = 0;
+  let totalWarnings = 0;
+  const jsonOutput = [];
+
+  let totalFixed = 0;
+
+  for (const file of files) {
+    let html = readFileSync(file, "utf-8");
+
+    if (args.fix) {
+      const fixResult = fix(html, config);
+      if (fixResult.fixedCount > 0) {
+        writeFileSync(file, fixResult.output, "utf-8");
+        html = fixResult.output;
+        totalFixed += fixResult.fixedCount;
+      }
+    }
+
+    const result = lint(html, config);
+    const rel = relative(process.cwd(), file);
+
+    for (const d of result.diagnostics) {
+      if (d.severity === "error") totalErrors++;
+      else totalWarnings++;
+    }
+
+    if (args.format === "json") {
+      if (result.diagnostics.length > 0) {
+        jsonOutput.push({
+          file: rel,
+          diagnostics: result.diagnostics,
+        });
+      }
+    } else {
+      if (result.diagnostics.length === 0) continue;
+      console.log(`\n${COLORS.bold}${rel}${COLORS.reset}`);
+      for (const d of result.diagnostics) {
+        console.log(formatDiagnostic(d));
+      }
+    }
+  }
+
+  if (args.format === "json") {
+    console.log(JSON.stringify(jsonOutput, null, 2));
+  } else if (totalErrors > 0 || totalWarnings > 0) {
+    const parts = [];
+    if (totalErrors > 0) parts.push(`${totalErrors} error${totalErrors > 1 ? "s" : ""}`);
+    if (totalWarnings > 0) parts.push(`${totalWarnings} warning${totalWarnings > 1 ? "s" : ""}`);
+    console.log(
+      `\n${COLORS.bold}${parts.join(", ")} in ${files.length} file${files.length > 1 ? "s" : ""}${COLORS.reset}\n`
+    );
+  } else if (totalFixed > 0) {
+    console.log(`Fixed ${totalFixed} issue${totalFixed > 1 ? "s" : ""}.`);
+  } else {
+    console.log("No issues found.");
+  }
+
+  if (totalErrors > 0) {
+    process.exit(1);
+  }
+
+  if (args.maxWarnings >= 0 && totalWarnings > args.maxWarnings) {
+    process.exit(1);
+  }
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/index.d.ts

@@ -0,0 +1,32 @@
+export interface LintDiagnostic {
+  rule: string;
+  message: string;
+  severity: "error" | "warning";
+  line: number | null;
+  fixable: boolean;
+}
+
+export interface LintResult {
+  diagnostics: LintDiagnostic[];
+}
+
+export interface FixResult {
+  output: string;
+  fixedCount: number;
+}
+
+export type RuleSeverity = "error" | "warning" | "off" | boolean;
+
+export interface LintConfig {
+  /**
+   * Rule name -> severity.
+   * - "error": report as error
+   * - "warning" | "warn": report as warning
+   * - "off" | false: disable the rule
+   * - true: use default severity
+   */
+  rules?: Record<string, RuleSeverity>;
+}
+
+export function lint(html: string, config?: LintConfig): LintResult;
+export function fix(html: string, config?: LintConfig): FixResult;

package/index.js

@@ -0,0 +1,49 @@
+const { existsSync } = require("fs");
+const { join } = require("path");
+
+const { platform, arch } = process;
+
+function loadBinding() {
+  const triples = {
+    "darwin-arm64": "rintenki.darwin-arm64.node",
+    "darwin-x64": "rintenki.darwin-x64.node",
+    "linux-x64": "rintenki.linux-x64-gnu.node",
+    "linux-arm64": "rintenki.linux-arm64-gnu.node",
+    "win32-x64": "rintenki.win32-x64-msvc.node",
+    "win32-arm64": "rintenki.win32-arm64-msvc.node",
+  };
+
+  const packages = {
+    "darwin-arm64": "rintenki-darwin-arm64",
+    "darwin-x64": "rintenki-darwin-x64",
+    "linux-x64": "rintenki-linux-x64-gnu",
+    "linux-arm64": "rintenki-linux-arm64-gnu",
+    "win32-x64": "rintenki-win32-x64-msvc",
+    "win32-arm64": "rintenki-win32-arm64-msvc",
+  };
+
+  const key = `${platform}-${arch}`;
+  const file = triples[key];
+  if (!file) {
+    throw new Error(`Unsupported platform: ${key}`);
+  }
+
+  const localPath = join(__dirname, file);
+  if (existsSync(localPath)) {
+    return require(localPath);
+  }
+
+  const pkg = packages[key];
+  try {
+    return require(pkg);
+  } catch (_) {
+    throw new Error(
+      `Failed to load native binding for ${key}. ` +
+        `Tried ${localPath} and ${pkg}`
+    );
+  }
+}
+
+const binding = loadBinding();
+module.exports.lint = binding.lint;
+module.exports.fix = binding.fix;

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "rintenki",
+  "version": "0.0.0",
+  "description": "A fast HTML linter powered by html5ever + napi-rs",
+  "author": "Kazuhiro Kobayashi <https://github.com/kzhrk>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/kzhrk/rintenki",
+    "directory": "packages/rintenki"
+  },
+  "homepage": "https://github.com/kzhrk/rintenki",
+  "bugs": {
+    "url": "https://github.com/kzhrk/rintenki/issues"
+  },
+  "keywords": [
+    "html",
+    "linter",
+    "lint",
+    "html5",
+    "html5ever",
+    "accessibility",
+    "a11y",
+    "napi-rs"
+  ],
+  "main": "index.js",
+  "types": "index.d.ts",
+  "bin": {
+    "rintenki": "bin/rintenki.js"
+  },
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "bin/rintenki.js",
+    "rintenki.*.node"
+  ],
+  "napi": {
+    "binaryName": "rintenki",
+    "targets": [
+      "aarch64-apple-darwin",
+      "x86_64-apple-darwin",
+      "x86_64-unknown-linux-gnu",
+      "aarch64-unknown-linux-gnu",
+      "x86_64-pc-windows-msvc",
+      "aarch64-pc-windows-msvc"
+    ]
+  },
+  "dependencies": {
+    "tinyglobby": "0.2.15"
+  },
+  "devDependencies": {
+    "@napi-rs/cli": "3.5.1",
+    "@types/node": "25.5.0",
+    "typescript": "6.0.2",
+    "vitest": "4.1.2"
+  },
+  "scripts": {
+    "build": "napi build --release --platform --no-js --dts .napi-output.d.ts && rm -f .napi-output.d.ts",
+    "build:debug": "napi build --platform --no-js --dts .napi-output.d.ts && rm -f .napi-output.d.ts",
+    "test": "vitest run"
+  }
+}