@utoo/lint 0.0.2

package/bin/migrate.js

@@ -0,0 +1,361 @@
+import { spawnSync } from "node:child_process";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, extname, resolve as resolvePath } from "node:path";
+import { pathToFileURL } from "node:url";
+
+import { Linter } from "../index.js";
+
+const ESLINT_CONFIG_FILENAMES = [
+  "eslint.config.js",
+  "eslint.config.mjs",
+  "eslint.config.cjs",
+  ".eslintrc.json",
+  ".eslintrc"
+];
+const JAVASCRIPT_CONFIG_EXTENSIONS = new Set([".js", ".mjs", ".cjs"]);
+const IGNORED_RULES = new Map([
+  ["prettier/prettier", "formatting is outside utoo-lint"]
+]);
+const SCHEMA_URL = "https://raw.githubusercontent.com/fireairforce/utoo-lint/main/npm/utoo-lint/schema.json";
+const JAVASCRIPT_CONFIG_LOADER_SCRIPT = `
+import { pathToFileURL } from "node:url";
+
+const loaded = await import(pathToFileURL(process.argv[1]).href);
+const seen = new Set();
+
+function strip(value) {
+  if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value === "function" || typeof value === "symbol" || typeof value === "undefined") {
+    return undefined;
+  }
+  if (typeof value !== "object") {
+    return undefined;
+  }
+  if (seen.has(value)) {
+    return undefined;
+  }
+  seen.add(value);
+  if (Array.isArray(value)) {
+    const items = value.map(strip).filter((item) => item !== undefined);
+    seen.delete(value);
+    return items;
+  }
+  const object = {};
+  for (const [key, item] of Object.entries(value)) {
+    const stripped = strip(item);
+    if (stripped !== undefined) {
+      object[key] = stripped;
+    }
+  }
+  seen.delete(value);
+  return object;
+}
+
+const json = JSON.stringify(strip(loaded.default ?? loaded));
+if (json === undefined) {
+  throw new TypeError("config did not export a migratable value");
+}
+process.stdout.write(json);
+`;
+
+export async function runMigrate(args) {
+  if (args.length === 0 || args[0] === "--help" || args[0] === "-h") {
+    printMigrateHelp();
+    return 0;
+  }
+
+  const source = args[0];
+  if (source !== "eslint") {
+    console.error(`utoo-lint migrate: unsupported source "${source}"`);
+    console.error("Supported sources: eslint");
+    return 2;
+  }
+
+  let options;
+  try {
+    options = parseEslintMigrateArgs(args.slice(1));
+  } catch (error) {
+    console.error(error.message);
+    return 2;
+  }
+
+  if (options.help) {
+    printEslintMigrateHelp();
+    return 0;
+  }
+
+  let result;
+  try {
+    result = migrateEslintConfig(options);
+  } catch (error) {
+    console.error(error.message);
+    return 2;
+  }
+
+  const configJson = JSON.stringify(result.config, null, 2) + "\n";
+  if (options.print) {
+    process.stdout.write(configJson);
+  } else {
+    if (existsSync(options.output) && !options.force) {
+      console.error(`utoo-lint migrate eslint: ${options.output} already exists; pass --force to overwrite it`);
+      return 2;
+    }
+    writeFileSync(options.output, configJson);
+  }
+
+  writeReport(result.report, options, options.print ? process.stderr : process.stdout);
+  return result.report.unsupportedRules.length > 0 ? 1 : 0;
+}
+
+function parseEslintMigrateArgs(args) {
+  const options = {
+    cwd: process.cwd(),
+    force: false,
+    from: undefined,
+    help: false,
+    output: "utoo.json",
+    print: false,
+    report: "text"
+  };
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--help" || arg === "-h") {
+      options.help = true;
+    } else if (arg === "--force") {
+      options.force = true;
+    } else if (arg === "--print") {
+      options.print = true;
+    } else if (arg === "--from") {
+      options.from = requireValue(args, ++index, "--from");
+    } else if (arg.startsWith("--from=")) {
+      options.from = arg.slice("--from=".length);
+    } else if (arg === "--output" || arg === "-o") {
+      options.output = requireValue(args, ++index, arg);
+    } else if (arg.startsWith("--output=")) {
+      options.output = arg.slice("--output=".length);
+    } else if (arg === "--report") {
+      options.report = parseReportFormat(requireValue(args, ++index, "--report"));
+    } else if (arg.startsWith("--report=")) {
+      options.report = parseReportFormat(arg.slice("--report=".length));
+    } else {
+      throw new Error(`utoo-lint migrate eslint: unknown option ${arg}`);
+    }
+  }
+
+  options.cwd = resolvePath(options.cwd);
+  options.output = resolvePath(options.cwd, options.output);
+  if (options.from) {
+    options.from = resolvePath(options.cwd, options.from);
+  }
+  return options;
+}
+
+function requireValue(args, index, flag) {
+  const value = args[index];
+  if (!value) {
+    throw new Error(`utoo-lint migrate eslint: ${flag} requires a value`);
+  }
+  return value;
+}
+
+function parseReportFormat(value) {
+  if (value === "text" || value === "json") {
+    return value;
+  }
+  throw new Error(`utoo-lint migrate eslint: unsupported --report value ${value}`);
+}
+
+function migrateEslintConfig(options) {
+  const sourcePath = options.from ?? findEslintConfig(options.cwd);
+  if (!sourcePath) {
+    throw new Error("utoo-lint migrate eslint: no ESLint config found; pass --from PATH");
+  }
+
+  const eslintConfig = loadEslintConfig(sourcePath, options.cwd);
+  const supportedRuleIds = new Set(new Linter().getRules().keys());
+  const entries = normalizeConfigEntries(eslintConfig);
+  const rules = {};
+  const files = new Set();
+  const ignores = new Set();
+  const supportedRules = [];
+  const unsupportedRules = [];
+  const ignoredRules = [];
+  const optionDroppedRules = [];
+
+  for (const entry of entries) {
+    addPatterns(files, entry.files);
+    addPatterns(ignores, entry.ignores);
+    if (!entry.rules || typeof entry.rules !== "object") {
+      continue;
+    }
+    for (const [ruleId, ruleConfig] of Object.entries(entry.rules)) {
+      if (IGNORED_RULES.has(ruleId)) {
+        ignoredRules.push({ ruleId, reason: IGNORED_RULES.get(ruleId) });
+        continue;
+      }
+      if (!supportedRuleIds.has(ruleId)) {
+        unsupportedRules.push(ruleId);
+        continue;
+      }
+      rules[ruleId] = severityOnly(ruleConfig);
+      supportedRules.push(ruleId);
+      if (Array.isArray(ruleConfig) && ruleConfig.length > 1) {
+        optionDroppedRules.push(ruleId);
+      }
+    }
+  }
+
+  const config = {
+    $schema: SCHEMA_URL
+  };
+  if (files.size > 0) {
+    config.files = [...files];
+  }
+  if (ignores.size > 0) {
+    config.ignores = [...ignores];
+  }
+  config.rules = sortObjectByKey(rules);
+
+  return {
+    config,
+    report: {
+      source: sourcePath,
+      output: options.print ? null : options.output,
+      supportedRules: uniqueSorted(supportedRules),
+      unsupportedRules: uniqueSorted(unsupportedRules),
+      ignoredRules: uniqueByRuleId(ignoredRules),
+      optionDroppedRules: uniqueSorted(optionDroppedRules)
+    }
+  };
+}
+
+function findEslintConfig(cwd) {
+  let current = cwd;
+  while (true) {
+    for (const filename of ESLINT_CONFIG_FILENAMES) {
+      const candidate = resolvePath(current, filename);
+      if (existsSync(candidate)) {
+        return candidate;
+      }
+    }
+    const parent = dirname(current);
+    if (parent === current) {
+      return undefined;
+    }
+    current = parent;
+  }
+}
+
+function loadEslintConfig(path, cwd) {
+  if (JAVASCRIPT_CONFIG_EXTENSIONS.has(extname(path))) {
+    const result = spawnSync(process.execPath, ["--input-type=module", "--eval", JAVASCRIPT_CONFIG_LOADER_SCRIPT, path], {
+      cwd,
+      encoding: "utf8"
+    });
+    if (result.error) {
+      throw result.error;
+    }
+    if (result.status !== 0) {
+      throw new Error(`utoo-lint migrate eslint: unable to load ${path}: ${(result.stderr ?? "").trim() || "JavaScript config loader failed"}`);
+    }
+    return parseJson(result.stdout, path);
+  }
+  return parseJson(readFileSync(path, "utf8"), path);
+}
+
+function parseJson(source, path) {
+  try {
+    return JSON.parse(source);
+  } catch (error) {
+    throw new Error(`utoo-lint migrate eslint: unable to parse ${path}: ${error.message}`);
+  }
+}
+
+function normalizeConfigEntries(config) {
+  if (Array.isArray(config)) {
+    return config.flatMap(normalizeConfigEntries);
+  }
+  if (config && typeof config === "object") {
+    return [config];
+  }
+  return [];
+}
+
+function addPatterns(target, value) {
+  if (!value) {
+    return;
+  }
+  for (const pattern of Array.isArray(value) ? value : [value]) {
+    if (typeof pattern === "string") {
+      target.add(pattern);
+    }
+  }
+}
+
+function severityOnly(ruleConfig) {
+  return Array.isArray(ruleConfig) ? ruleConfig[0] : ruleConfig;
+}
+
+function sortObjectByKey(object) {
+  return Object.fromEntries(Object.entries(object).sort(([left], [right]) => left.localeCompare(right)));
+}
+
+function uniqueSorted(values) {
+  return [...new Set(values)].sort();
+}
+
+function uniqueByRuleId(values) {
+  const result = new Map();
+  for (const value of values) {
+    result.set(value.ruleId, value);
+  }
+  return [...result.values()].sort((left, right) => left.ruleId.localeCompare(right.ruleId));
+}
+
+function writeReport(report, options, stream) {
+  if (options.report === "json") {
+    stream.write(JSON.stringify(report, null, 2) + "\n");
+    return;
+  }
+
+  stream.write(`utoo-lint migrate eslint: read ${pathToFileURL(report.source).href}\n`);
+  if (report.output) {
+    stream.write(`utoo-lint migrate eslint: wrote ${report.output}\n`);
+  }
+  stream.write(`utoo-lint migrate eslint: migrated ${report.supportedRules.length} supported rule(s)\n`);
+  if (report.optionDroppedRules.length > 0) {
+    stream.write(`utoo-lint migrate eslint: dropped options for ${report.optionDroppedRules.length} rule(s): ${report.optionDroppedRules.join(", ")}\n`);
+  }
+  if (report.ignoredRules.length > 0) {
+    stream.write(`utoo-lint migrate eslint: ignored ${report.ignoredRules.length} rule(s): ${report.ignoredRules.map((rule) => rule.ruleId).join(", ")}\n`);
+  }
+  if (report.unsupportedRules.length > 0) {
+    stream.write(`utoo-lint migrate eslint: ${report.unsupportedRules.length} unsupported rule(s): ${report.unsupportedRules.join(", ")}\n`);
+  }
+}
+
+function printMigrateHelp() {
+  console.log(`Usage:
+  utoo-lint migrate eslint [options]
+
+Sources:
+  eslint                  Convert an ESLint config into utoo.json
+
+Run "utoo-lint migrate eslint --help" for source-specific options.`);
+}
+
+function printEslintMigrateHelp() {
+  console.log(`Usage:
+  utoo-lint migrate eslint [options]
+
+Options:
+  --from=PATH             Read ESLint config from PATH
+  --output=PATH, -o PATH  Write utoo config to PATH (default: utoo.json)
+  --force                 Overwrite the output file when it exists
+  --print                 Print the generated config instead of writing it
+  --report=text|json      Select migration report format
+  --help, -h              Show this help message`);
+}

package/bin/utoo-lint.js

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+import { spawnSync } from "node:child_process";
+
+import { resolveBinary } from "../lib/binary.js";
+
+if (process.argv[2] === "migrate") {
+  const { runMigrate } = await import("./migrate.js");
+  process.exit(await runMigrate(process.argv.slice(3)));
+}
+
+let binary;
+try {
+  binary = resolveBinary();
+} catch (error) {
+  console.error(error.message);
+  process.exit(1);
+}
+
+const result = spawnSync(binary, process.argv.slice(2), { stdio: "inherit" });
+
+if (result.error) {
+  console.error(`utoo-lint: failed to run native binary: ${result.error.message}`);
+  process.exit(1);
+}
+
+process.exit(result.status ?? 1);

package/config.cjs

@@ -0,0 +1,155 @@
+let globalIgnoreCount = 0;
+
+function defineConfig(...args) {
+  if (args.length === 0) {
+    throw new TypeError("Expected one or more arguments.");
+  }
+  return flattenConfigArgs(args).flatMap((config, index) => expandConfigExtends(config, `UserConfig[${index}]`));
+}
+
+function globalIgnores(ignorePatterns, name) {
+  if (!Array.isArray(ignorePatterns)) {
+    throw new TypeError("ignorePatterns must be an array");
+  }
+  if (ignorePatterns.length === 0) {
+    throw new TypeError("ignorePatterns must contain at least one pattern");
+  }
+  const id = globalIgnoreCount++;
+  return {
+    name: name || `globalIgnores ${id}`,
+    ignores: ignorePatterns
+  };
+}
+
+function flattenConfigArgs(values) {
+  const configs = [];
+  for (const value of values) {
+    if (Array.isArray(value)) {
+      configs.push(...flattenConfigArgs(value));
+    } else if (typeof value === "object" && value !== null) {
+      configs.push(value);
+    } else {
+      throw new TypeError(`Expected an object but received ${String(value)}.`);
+    }
+  }
+  return configs;
+}
+
+function expandConfigExtends(config, baseConfigName) {
+  if (!("extends" in config)) {
+    return [config];
+  }
+  if (!Array.isArray(config.extends)) {
+    throw new TypeError("The `extends` property must be an array.");
+  }
+
+  const { extends: extendsList, ...baseConfig } = config;
+  const expanded = [];
+  for (const [index, extension] of flattenConfigArgs(resolveConfigExtends(config, extendsList)).entries()) {
+    if ("basePath" in extension) {
+      throw new TypeError("'basePath' in `extends` is not allowed.");
+    }
+    if ("extends" in extension) {
+      throw new TypeError("Nested 'extends' is not allowed.");
+    }
+    expanded.push(extendConfig(baseConfig, extension, baseConfigName, extension.name ?? extension.__utooLintConfigName ?? `ExtendedConfig[${index}]`));
+  }
+  if (!isGlobalIgnores(baseConfig)) {
+    expanded.push(baseConfig);
+  }
+  return expanded;
+}
+
+function resolveConfigExtends(config, extendsList) {
+  return extendsList.map((extension) => {
+    if (typeof extension !== "string") {
+      return extension;
+    }
+    const pluginConfig = pluginConfigForName(config, extension);
+    if (!pluginConfig) {
+      const { namespace, configName } = splitPluginConfigName(extension);
+      throw new TypeError(`Plugin config "${configName}" not found in plugin "${namespace}".`);
+    }
+    return withConfigNames(pluginConfig, extension);
+  });
+}
+
+function pluginConfigForName(config, name) {
+  const { namespace, configName } = splitPluginConfigName(name);
+  const plugin = config.plugins?.[namespace];
+  if (!plugin) {
+    throw new TypeError(`Plugin "${namespace}" not found.`);
+  }
+  return plugin.configs?.[configName] ?? plugin.configs?.[`flat/${configName}`];
+}
+
+function splitPluginConfigName(name) {
+  const slashIndex = name.indexOf("/");
+  if (slashIndex <= 0 || slashIndex === name.length - 1) {
+    throw new TypeError(`Invalid plugin config name "${name}".`);
+  }
+  return {
+    namespace: name.slice(0, slashIndex),
+    configName: name.slice(slashIndex + 1)
+  };
+}
+
+function extendConfig(baseConfig, extension, baseConfigName, extensionName) {
+  const { __utooLintConfigName: _name, ...extensionConfig } = extension;
+  const result = { ...extensionConfig };
+  if (!isGlobalIgnores(extension)) {
+    if (baseConfig.files) {
+      result.files = extendConfigFiles(baseConfig.files, extension.files);
+    }
+    if (baseConfig.ignores) {
+      result.ignores = baseConfig.ignores.concat(extension.ignores ?? []);
+    }
+  }
+  result.name = `${baseConfig.name ?? baseConfigName} > ${extensionName}`;
+  if (baseConfig.basePath) {
+    result.basePath = baseConfig.basePath;
+  }
+  return result;
+}
+
+function extendConfigFiles(baseFiles = [], extensionFiles = []) {
+  if (!extensionFiles.length) {
+    return baseFiles.concat();
+  }
+  if (!baseFiles.length) {
+    return extensionFiles.concat();
+  }
+  const result = [];
+  for (const baseFile of baseFiles) {
+    for (const extensionFile of extensionFiles) {
+      result.push([
+        ...(Array.isArray(baseFile) ? baseFile : [baseFile]),
+        ...(Array.isArray(extensionFile) ? extensionFile : [extensionFile])
+      ]);
+    }
+  }
+  return result;
+}
+
+function isGlobalIgnores(config) {
+  const keys = Object.keys(config);
+  return keys.includes("ignores") && keys.every((key) => key === "name" || key === "ignores");
+}
+
+function withConfigNames(config, name) {
+  if (Array.isArray(config)) {
+    return config.map((entry, index) => ({
+      ...entry,
+      __utooLintConfigName: `${name}[${index}]`
+    }));
+  }
+  return {
+    ...config,
+    __utooLintConfigName: name
+  };
+}
+
+module.exports = {
+  defineConfig,
+  globalIgnores
+};

package/config.d.ts

@@ -0,0 +1,4 @@
+import type { ConfigObject } from "./index.js";
+
+export function defineConfig(...configs: Array<ConfigObject | ConfigObject[]>): ConfigObject[];
+export function globalIgnores(ignorePatterns: string[], name?: string): ConfigObject;

package/config.js

@@ -0,0 +1,150 @@
+let globalIgnoreCount = 0;
+
+export function defineConfig(...args) {
+  if (args.length === 0) {
+    throw new TypeError("Expected one or more arguments.");
+  }
+  return flattenConfigArgs(args).flatMap((config, index) => expandConfigExtends(config, `UserConfig[${index}]`));
+}
+
+export function globalIgnores(ignorePatterns, name) {
+  if (!Array.isArray(ignorePatterns)) {
+    throw new TypeError("ignorePatterns must be an array");
+  }
+  if (ignorePatterns.length === 0) {
+    throw new TypeError("ignorePatterns must contain at least one pattern");
+  }
+  const id = globalIgnoreCount++;
+  return {
+    name: name || `globalIgnores ${id}`,
+    ignores: ignorePatterns
+  };
+}
+
+function flattenConfigArgs(values) {
+  const configs = [];
+  for (const value of values) {
+    if (Array.isArray(value)) {
+      configs.push(...flattenConfigArgs(value));
+    } else if (typeof value === "object" && value !== null) {
+      configs.push(value);
+    } else {
+      throw new TypeError(`Expected an object but received ${String(value)}.`);
+    }
+  }
+  return configs;
+}
+
+function expandConfigExtends(config, baseConfigName) {
+  if (!("extends" in config)) {
+    return [config];
+  }
+  if (!Array.isArray(config.extends)) {
+    throw new TypeError("The `extends` property must be an array.");
+  }
+
+  const { extends: extendsList, ...baseConfig } = config;
+  const expanded = [];
+  for (const [index, extension] of flattenConfigArgs(resolveConfigExtends(config, extendsList)).entries()) {
+    if ("basePath" in extension) {
+      throw new TypeError("'basePath' in `extends` is not allowed.");
+    }
+    if ("extends" in extension) {
+      throw new TypeError("Nested 'extends' is not allowed.");
+    }
+    expanded.push(extendConfig(baseConfig, extension, baseConfigName, extension.name ?? extension.__utooLintConfigName ?? `ExtendedConfig[${index}]`));
+  }
+  if (!isGlobalIgnores(baseConfig)) {
+    expanded.push(baseConfig);
+  }
+  return expanded;
+}
+
+function resolveConfigExtends(config, extendsList) {
+  return extendsList.map((extension) => {
+    if (typeof extension !== "string") {
+      return extension;
+    }
+    const pluginConfig = pluginConfigForName(config, extension);
+    if (!pluginConfig) {
+      const { namespace, configName } = splitPluginConfigName(extension);
+      throw new TypeError(`Plugin config "${configName}" not found in plugin "${namespace}".`);
+    }
+    return withConfigNames(pluginConfig, extension);
+  });
+}
+
+function pluginConfigForName(config, name) {
+  const { namespace, configName } = splitPluginConfigName(name);
+  const plugin = config.plugins?.[namespace];
+  if (!plugin) {
+    throw new TypeError(`Plugin "${namespace}" not found.`);
+  }
+  return plugin.configs?.[configName] ?? plugin.configs?.[`flat/${configName}`];
+}
+
+function splitPluginConfigName(name) {
+  const slashIndex = name.indexOf("/");
+  if (slashIndex <= 0 || slashIndex === name.length - 1) {
+    throw new TypeError(`Invalid plugin config name "${name}".`);
+  }
+  return {
+    namespace: name.slice(0, slashIndex),
+    configName: name.slice(slashIndex + 1)
+  };
+}
+
+function extendConfig(baseConfig, extension, baseConfigName, extensionName) {
+  const { __utooLintConfigName: _name, ...extensionConfig } = extension;
+  const result = { ...extensionConfig };
+  if (!isGlobalIgnores(extension)) {
+    if (baseConfig.files) {
+      result.files = extendConfigFiles(baseConfig.files, extension.files);
+    }
+    if (baseConfig.ignores) {
+      result.ignores = baseConfig.ignores.concat(extension.ignores ?? []);
+    }
+  }
+  result.name = `${baseConfig.name ?? baseConfigName} > ${extensionName}`;
+  if (baseConfig.basePath) {
+    result.basePath = baseConfig.basePath;
+  }
+  return result;
+}
+
+function extendConfigFiles(baseFiles = [], extensionFiles = []) {
+  if (!extensionFiles.length) {
+    return baseFiles.concat();
+  }
+  if (!baseFiles.length) {
+    return extensionFiles.concat();
+  }
+  const result = [];
+  for (const baseFile of baseFiles) {
+    for (const extensionFile of extensionFiles) {
+      result.push([
+        ...(Array.isArray(baseFile) ? baseFile : [baseFile]),
+        ...(Array.isArray(extensionFile) ? extensionFile : [extensionFile])
+      ]);
+    }
+  }
+  return result;
+}
+
+function isGlobalIgnores(config) {
+  const keys = Object.keys(config);
+  return keys.includes("ignores") && keys.every((key) => key === "name" || key === "ignores");
+}
+
+function withConfigNames(config, name) {
+  if (Array.isArray(config)) {
+    return config.map((entry, index) => ({
+      ...entry,
+      __utooLintConfigName: `${name}[${index}]`
+    }));
+  }
+  return {
+    ...config,
+    __utooLintConfigName: name
+  };
+}