@tenphi/eslint-plugin-tasty 1.19.0 → 1.19.1

package/README.md

@@ -419,6 +419,7 @@ usages still report. In multiline JSX, target the line containing the reported
 attribute or spread property. JSX child comments can use
 `{/* eslint-disable-next-line tasty/no-classname-prop -- library requires this class */}`
 immediately above the affected element when the attribute is on that next line.
+Oxlint reads these comments too, and its own `oxlint-disable-next-line` form.
 
 If `react/forbid-component-props` or `react/forbid-dom-props` also forbids
 `style`, a `style` exception has to name both rules, and the React part hides
@@ -643,7 +644,7 @@ The package ships an agent harness for [harnesspm](https://www.npmjs.com/package
 
 - a short always-on rule: lint the files you change and fix every `tasty/*` problem;
 - the rule pages of the installed version, in the docs index;
-- `npx harnesspm run tasty-lint:check <files> [--strict] [--json]`, which runs only the `tasty/*` rules with the project's `tasty.config.*` and prints each problem with its rule's page;
+- `npx harnesspm run tasty-lint:check <files> [--strict] [--json]`, which runs only the `tasty/*` rules and prints each problem with its rule's page;
 - a Claude Code hook that lints each file the agent edits, when it imports Tasty or a configured `importSources` module, and hands the new problems back to the agent.
 
 The tool and the hook run only in projects that trust the package, in `harnesspm.json`:
@@ -652,7 +653,14 @@ The tool and the hook run only in projects that trust the package, in `harnesspm
 { "trust": { "@tenphi/eslint-plugin-tasty": true } }
 ```
 
-They need `eslint`, and `typescript-eslint` or `@typescript-eslint/parser` for TypeScript files. They do not read the project's ESLint or Oxlint config, so other plugins, rule options and settings such as `typeAwareJSX` do not apply there.
+Both run the `tasty/*` rules as the project's own lint does, so they report the same problems:
+
+- **Config.** Each file gets the levels and options of the `tasty/*` rules, and `settings.tasty`, from the nearest config above it that loads the plugin: `.oxlintrc.json`, `.oxlintrc.jsonc`, `oxlint.config.ts`, `oxlint.config.mts`, or an ESLint flat config that imports `@tenphi/eslint-plugin-tasty`. Overrides and ignored files apply. Without such a config, they run the recommended preset (`--strict`: the strict one). With a config, `--strict` adds the strict preset's rules that the config does not set.
+- **Comments.** `eslint-disable` comments apply, and Oxlint's `oxlint-disable` ones unless the config is ESLint's.
+- **`typeAwareJSX`.** `tasty-lint:check` uses it. The hook skips it, since building the TypeScript program takes seconds on every edit, and reads JSX props by their names.
+- **Not covered.** Other plugins' rules do not run. A config the project's lint script names with `--config` is not found: only the names above count.
+
+They need `eslint`, even in a project that lints with Oxlint, and `typescript-eslint` or `@typescript-eslint/parser` for TypeScript files. Without `eslint`, the hook stays silent and `tasty-lint:check` says what to install.
 
 ## License
 

package/docs/rules/consistent-token-usage.md

@@ -55,6 +55,8 @@ const Rule = tasty({
 });
 ```
 
+With Oxlint, `// oxlint-disable-next-line` works the same way.
+
 ## Options
 
 ```js

package/docs/rules/no-classname-prop.md

@@ -44,6 +44,8 @@ const libraryElement = (
 );
 ```
 
+With Oxlint, `// oxlint-disable-next-line` works the same way.
+
 Place the directive immediately before the reported attribute line. It suppresses
 only this rule for that line. The warning message includes this exception path;
 the plugin does not silently exempt library-provided values or enforce reasons.

package/docs/rules/no-protected-restyle.md

@@ -183,6 +183,8 @@ A justified override takes a reasoned disable on its line:
 <Button fill="#brand" />;
 ```
 
+With Oxlint, `// oxlint-disable-next-line` works the same way.
+
 ## Relation to `no-styles-prop`
 
 `tasty/no-styles-prop` reports instance `styles` on every recognized Tasty

package/docs/rules/no-raw-color-values.md

@@ -44,6 +44,8 @@ For an intentional one-off color, disable the rule for that line, with a reason:
 fill: '#1db954',
 ```
 
+With Oxlint, `// oxlint-disable-next-line` works the same way.
+
 ## Options
 
 None.

package/docs/rules/no-style-prop.md

@@ -37,6 +37,8 @@ const floating = (
 );
 ```
 
+With Oxlint, `// oxlint-disable-next-line` works the same way.
+
 Place the directive immediately before the reported attribute line. It suppresses
 only this rule for that line. The warning message includes this exception path;
 the plugin does not silently exempt library-provided values or enforce reasons.

package/docs/rules/no-style-spread.md

@@ -48,6 +48,8 @@ const Card = tasty({
 });
 ```
 
+With Oxlint, `// oxlint-disable-next-line` works the same way.
+
 ## Options
 
 None.

package/docs/rules/no-styles-prop.md

@@ -40,6 +40,8 @@ const adapted = (
 );
 ```
 
+With Oxlint, `// oxlint-disable-next-line` works the same way.
+
 Place the directive immediately before the reported attribute line. It suppresses
 only this rule for that line. The warning message includes this exception path;
 the plugin does not silently exempt edge cases or enforce comment reasons.

package/harness/dev.harnesspm/rules/usage.md

@@ -8,4 +8,4 @@
 
 ## Exceptions
 
-- Disable a rule for one line only: `// eslint-disable-next-line tasty/<rule> -- <reason>`.
+- Disable a rule for one line only: `// eslint-disable-next-line tasty/<rule> -- <reason>`. With Oxlint, `oxlint-disable-next-line` works too.

package/harness/dev.harnesspm/scripts/check-edit.mjs

@@ -1,6 +1,7 @@
 /**
  * The check-edit hook: after an agent edits a file that imports Tasty, lints
- * it with the recommended Tasty rules and hands the new problems back.
+ * it with the Tasty rules the project's lint config sets (or the recommended
+ * ones) and hands the new problems back.
  *
  * Claude Code runs it on PostToolUse for Edit, Write and MultiEdit, with the
  * event as JSON on stdin. Exit 0 says nothing. Exit 2 puts stderr in front of
@@ -18,11 +19,13 @@ import {
   importsFrom,
   isLintable,
   isTypeScript,
+  lintOptions,
   loadESLint,
   loadTypeScriptParser,
   newProblems,
   rulePage,
 } from './lint.mjs';
+import { createConfigResolver, isOn } from './project-config.mjs';
 
 /** More problems than this are summed up, not listed. */
 const LIMIT = 20;
@@ -74,31 +77,56 @@ if (!importsFrom(text)) {
 }
 
 let problems;
+let linter;
+let typeAware = false;
 try {
-  const { default: plugin, recommended } = await import(build('index.js'));
   const dirs = [dirname(file), projectDir];
-  const ESLint = await loadESLint(dirs, PACKAGE_ROOT);
+  let loaded;
+  try {
+    loaded = await loadESLint(dirs, PACKAGE_ROOT);
+  } catch (error) {
+    // A project that lints with Oxlint alone may have no ESLint. Then the hook
+    // stays out of the way, and `tasty-lint:check` says what to install.
+    if (error?.code === 'NO_ESLINT') process.exit(0);
+    throw error;
+  }
+  const { ESLint, espree } = loaded;
+  const { default: plugin, recommended } = await import(build('index.js'));
+  const project = await createConfigResolver({
+    ESLint,
+    plugin,
+    packageRoot: PACKAGE_ROOT,
+  }).forFile(file);
+  linter = project.source?.linter;
+  const lint = lintOptions(project, { recommended, projectDir });
+  if (project.ignored || !Object.values(lint.rules).some(isOn)) process.exit(0);
   const parser = await loadTypeScriptParser(dirs);
   if (!parser && isTypeScript(file)) setupError(NO_PARSER);
+  // typeAwareJSX builds a TypeScript program of the whole project: on UI Kit,
+  // 13 s instead of 1 s for one file, on every edit. Without it, JSX props are
+  // classified by name, so `tasty-lint:check` has the last word on them.
+  const { typeAwareJSX, ...settings } = lint.settings;
+  typeAware = Boolean(typeAwareJSX);
   const eslint = createLinter({
     ESLint,
     plugin,
-    rules: recommended,
     parser,
-    cwd: projectDir,
+    espree,
+    ...lint,
+    settings,
   });
-  const lint = async (source) =>
+  const lintText = async (source) =>
     collectProblems(
       await eslint.lintText(source, { filePath: file }),
       projectDir,
     ).problems;
 
-  problems = await lint(text);
+  problems = await lintText(text);
   // Report only what this edit added, so problems an older line already had
   // do not come back after every edit of the file.
   const original = event.tool_response?.originalFile;
   if (problems.length > 0 && typeof original === 'string' && original) {
-    problems = newProblems(problems, text, await lint(original), original);
+    problems = newProblems(problems, text, await lintText(original), original);
   }
 } catch (error) {
   setupError(error instanceof Error ? error.message : String(error));
@@ -112,8 +140,10 @@ const relativeFile = shown[0].file;
 // agent's shell went last, such as a folder in node_modules.
 const pageOf = (name) =>
   rulePage(name, { projectDir, packageRoot: PACKAGE_ROOT, cwd: projectDir });
+// The disable comment the project's linter reads.
+const directive = `${linter === 'oxlint' ? 'oxlint' : 'eslint'}-disable-next-line`;
 const out = [
-  `tasty-lint: this edit left ${problems.length} Tasty lint problem${problems.length === 1 ? '' : 's'} in ${relativeFile}. Fix ${problems.length === 1 ? 'it' : 'them'}. For an intentional exception, put \`// eslint-disable-next-line tasty/<rule> -- <reason>\` above the line.`,
+  `tasty-lint: this edit left ${problems.length} Tasty lint problem${problems.length === 1 ? '' : 's'} in ${relativeFile}. Fix ${problems.length === 1 ? 'it' : 'them'}. For an intentional exception, put \`// ${directive} tasty/<rule> -- <reason>\` above the line.`,
   '',
   formatProblems(shown, pageOf),
 ];
@@ -123,5 +153,11 @@ if (problems.length > LIMIT) {
     `${problems.length - LIMIT} more: run \`npx harnesspm run tasty-lint:check ${relativeFile}\`.`,
   );
 }
+if (typeAware) {
+  out.push(
+    '',
+    `This hook skips typeAwareJSX to stay fast, so it reads JSX props by their names. If a reported JSX prop is not a style, check it with \`npx harnesspm run tasty-lint:check ${relativeFile}\`.`,
+  );
+}
 console.error(out.join('\n'));
 process.exit(2);

package/harness/dev.harnesspm/scripts/check.mjs

@@ -1,31 +1,39 @@
 /**
- * tasty-lint:check — lints files with this plugin's Tasty rules only, with the
- * project's tasty.config.* and ESLint.
+ * tasty-lint:check — lints files with this plugin's Tasty rules only, as the
+ * project's own lint config sets them, with the project's tasty.config.* and
+ * ESLint.
  */
-import { existsSync, realpathSync } from 'node:fs';
-import { join, resolve } from 'node:path';
+import { existsSync, readdirSync, realpathSync, statSync } from 'node:fs';
+import { join, relative, resolve } from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import {
   NO_PARSER,
   collectProblems,
   createLinter,
   formatProblems,
+  isLintable,
   isTypeScript,
+  lintOptions,
   loadESLint,
   loadTypeScriptParser,
   rulePage,
   summarize,
 } from './lint.mjs';
+import { createConfigResolver, isOn } from './project-config.mjs';
 
 const USAGE = `Usage: npx harnesspm run tasty-lint:check <files or folders>... [--strict] [--json]
 
-Lints the files with the Tasty rules of @tenphi/eslint-plugin-tasty only: the
-recommended preset, or the strict one with --strict. The rules read the
-project's tasty.config.* as they do in the project's own lint.
+Lints the files with the Tasty rules of @tenphi/eslint-plugin-tasty only, as
+the project's own lint runs them: each file gets the tasty/* rules, their
+options and settings.tasty (such as typeAwareJSX) from the nearest
+.oxlintrc.json, .oxlintrc.jsonc, oxlint.config.ts, oxlint.config.mts or ESLint
+flat config above it that loads the plugin, and the files that config ignores
+are skipped. Without such a config, it runs the recommended preset. The rules
+read the project's tasty.config.* too. Other plugins' rules do not run.
 
-It does not read the project's ESLint or Oxlint config, so other plugins, rule
-options and settings such as typeAwareJSX do not apply. Disable comments such
-as // eslint-disable-next-line tasty/<rule> -- <reason> do.
+Disable comments for the Tasty rules apply: // eslint-disable-next-line
+tasty/<rule> -- <reason>, and the oxlint-disable forms, unless the config is
+ESLint's.
 
 A path is read from the current folder, else from the project root. Each
 problem prints as file:line:col  tasty/<rule>  <severity>  message, with the
@@ -33,7 +41,7 @@ file relative to the project root. The page of each rule reported follows. Exit
 without errors (warnings allowed), 1 with errors, 2 when nothing could be
 linted.
 
---strict  also run the rules only the strict preset enables
+--strict  also run the strict preset's rules that the config does not set
 --json    print the problems as JSON`;
 
 const PACKAGE_ROOT = realpathSync(
@@ -48,6 +56,9 @@ function fail(message) {
   process.exit(2);
 }
 
+const errorText = (error) =>
+  error instanceof Error ? error.message : String(error);
+
 const options = { strict: false, json: false, help: false };
 const paths = [];
 for (const arg of process.argv.slice(2)) {
@@ -81,45 +92,129 @@ const {
 const preset = options.strict ? 'strict' : 'recommended';
 
 let ESLint;
+let espree;
 let parser;
 try {
-  ESLint = await loadESLint([cwd, projectDir], PACKAGE_ROOT);
+  ({ ESLint, espree } = await loadESLint([cwd, projectDir], PACKAGE_ROOT));
   parser = await loadTypeScriptParser([cwd, projectDir]);
 } catch (error) {
-  fail(error instanceof Error ? error.message : String(error));
+  fail(errorText(error));
+}
+
+const show = (file) => relative(projectDir, file) || file;
+
+/** The files in a folder that the tools lint, as ESLint skips node_modules. */
+function* walk(dir) {
+  const entries = readdirSync(dir, { withFileTypes: true }).sort((a, b) =>
+    a.name < b.name ? -1 : 1,
+  );
+  for (const entry of entries) {
+    const path = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (entry.name !== 'node_modules' && entry.name !== '.git') {
+        yield* walk(path);
+      }
+    } else if (isLintable(entry.name)) {
+      yield path;
+    }
+  }
 }
 
-const eslint = createLinter({
+// Each file gets the rules its config sets, so files are linted in groups of
+// the same rules and settings. A file named on the command line that is not
+// linted is reported; one found in a folder is skipped quietly, as ESLint does.
+const resolver = createConfigResolver({
   ESLint,
   plugin,
-  rules: options.strict ? strict : recommended,
-  parser,
-  cwd: projectDir,
+  packageRoot: PACKAGE_ROOT,
 });
+const groups = new Map();
+const skipped = [];
+const configs = new Set();
+for (const target of targets) {
+  const named = !statSync(target).isDirectory();
+  for (const file of named ? [target] : walk(target)) {
+    if (!isLintable(file)) {
+      skipped.push({
+        file: show(file),
+        reason: 'not a JavaScript or TypeScript file.',
+      });
+      continue;
+    }
+    let project;
+    try {
+      project = await resolver.forFile(file);
+    } catch (error) {
+      fail(
+        `cannot read the lint config for ${show(file)}: ${errorText(error)}`,
+      );
+    }
+    const config = project.source && show(project.source.file);
+    const lint = lintOptions(project, {
+      recommended,
+      strict,
+      useStrict: options.strict,
+      projectDir,
+    });
+    if (project.ignored || !Object.values(lint.rules).some(isOn)) {
+      if (named) {
+        skipped.push({
+          file: show(file),
+          reason: project.ignored
+            ? `${config} does not lint it.`
+            : `${config} runs no tasty/* rule on it.`,
+        });
+      }
+      continue;
+    }
+    if (config) configs.add(config);
+    const key = JSON.stringify(lint);
+    if (!groups.has(key)) groups.set(key, { lint, files: [], config });
+    groups.get(key).files.push(file);
+  }
+}
 
-let results;
-try {
-  results = await eslint.lintFiles(targets);
-} catch (error) {
-  fail(error instanceof Error ? error.message : String(error));
+const results = [];
+for (const { lint, files } of groups.values()) {
+  const eslint = createLinter({ ESLint, plugin, parser, espree, ...lint });
+  try {
+    results.push(...(await eslint.lintFiles(files)));
+  } catch (error) {
+    fail(errorText(error));
+  }
 }
+results.sort((a, b) => (a.filePath < b.filePath ? -1 : 1));
 
 if (!parser && results.some((result) => isTypeScript(result.filePath))) {
   fail(NO_PARSER);
 }
 
 // Paths print relative to the project root, as harnesspm runs from there.
-const { problems, skipped } = collectProblems(results, projectDir);
+const collected = collectProblems(results, projectDir);
+const { problems } = collected;
+skipped.push(...collected.skipped);
 const pageOf = (name) =>
   rulePage(name, { projectDir, packageRoot: PACKAGE_ROOT, cwd: projectDir });
 const errors = problems.filter((p) => p.severity === 'error').length;
-const linted = results.length - skipped.length;
+const linted = results.length - collected.skipped.length;
+
+// Which rules ran: a config's, with --strict also the strict preset's others,
+// and the preset for files without a config.
+const sources = [...new Set([...groups.values()].map((g) => g.config ?? null))];
+const ruleset = sources
+  .map((config) =>
+    config
+      ? `rules from ${config}${options.strict ? ' and the strict preset' : ''}`
+      : `${preset} rules`,
+  )
+  .join('; ');
 
 if (options.json) {
   console.log(
     JSON.stringify(
       {
         preset,
+        configs: [...configs],
         files: results.map((r) => r.filePath),
         linted,
         problems: problems.map((p) => ({
@@ -138,16 +233,16 @@ if (options.json) {
   if (linted === 0) {
     out.push(`Nothing linted in ${paths.join(', ')}.`);
   } else if (problems.length === 0) {
-    out.push(`No tasty/* problems in ${count} (${preset} rules).`);
+    out.push(`No tasty/* problems in ${count} (${ruleset}).`);
   } else {
     out.push(
       formatProblems(problems, pageOf),
       '',
-      `${summarize(problems)} in ${count} (${preset} rules).`,
+      `${summarize(problems)} in ${count} (${ruleset}).`,
     );
   }
   for (const s of skipped) out.push(`Skipped ${s.file}: ${s.reason}`);
-  if (results.length === 0) {
+  if (linted === 0 && skipped.length === 0) {
     out.push(
       'Pass .js, .jsx, .ts or .tsx files of the project, or folders with them.',
     );

package/harness/dev.harnesspm/scripts/lint.mjs

@@ -8,6 +8,7 @@ import { existsSync, realpathSync } from 'node:fs';
 import { createRequire } from 'node:module';
 import { dirname, join, relative } from 'node:path';
 import { pathToFileURL } from 'node:url';
+import { SOURCES } from './project-config.mjs';
 
 /** Files the tools lint: JavaScript and TypeScript, with or without JSX. */
 const LINTABLE = /\.(?:[cm]?[jt]s|[jt]sx)$/;
@@ -40,22 +41,71 @@ export function importsFrom(text, sources = []) {
 }
 
 /**
- * The ESLint flat config that runs only this plugin's rules. It does not read
- * the project's linter config, so `settings.tasty` is empty: in particular
- * `typeAwareJSX`, which builds a TypeScript program, stays off.
+ * Oxlint reads `oxlint-disable`, `oxlint-disable-next-line`,
+ * `oxlint-disable-line` and `oxlint-enable` comments as ESLint reads the
+ * `eslint-` ones, and also takes `eslint-disable` and `eslint-enable` in line
+ * comments, which ESLint skips. ESLint reads directives from each comment's
+ * `value`, so the parser below rewrites the value of those comments after
+ * parsing. The source text is not touched, so strings, code, lines and
+ * columns stay as they are.
  */
-export function lintConfig({ plugin, rules, parser }) {
+const OXLINT_DIRECTIVE =
+  /^(\s*)oxlint-(disable(?:-next-line|-line)?|enable)(?=\s|$)/;
+const BLOCK_DIRECTIVE = /^\s*eslint-(?:disable|enable)(?=\s|$)/;
+
+export function readOxlintComments(comment) {
+  comment.value = comment.value.replace(OXLINT_DIRECTIVE, '$1eslint-$2');
+  if (comment.type === 'Line' && BLOCK_DIRECTIVE.test(comment.value)) {
+    comment.type = 'Block';
+  }
+}
+
+/** The parser with Oxlint's disable comments read as ESLint's. */
+export function withOxlintComments(parser) {
+  return {
+    meta: { name: 'tasty-lint/oxlint-comments' },
+    parseForESLint(text, options) {
+      const result =
+        typeof parser.parseForESLint === 'function'
+          ? parser.parseForESLint(text, options)
+          : { ast: parser.parse(text, options) };
+      for (const comment of result.ast.comments ?? []) {
+        readOxlintComments(comment);
+      }
+      return result;
+    },
+  };
+}
+
+/**
+ * The ESLint flat config that runs only this plugin's rules: `rules` and
+ * `settings` (`settings.tasty`) come from the project's lint config, or the
+ * rules from a preset. `espree` is ESLint's own parser, for JavaScript, and
+ * `parser` the TypeScript one. With `oxlintComments`, Oxlint's disable
+ * comments count too.
+ */
+export function lintConfig({
+  plugin,
+  rules,
+  settings = {},
+  parser,
+  espree,
+  oxlintComments = true,
+}) {
+  const read = (p) => (oxlintComments ? withOxlintComments(p) : p);
   const config = [
     {
-      files: ['**/*.{js,jsx,mjs,cjs,ts,tsx,mts,cts}'],
+      files: [SOURCES],
       plugins: { tasty: plugin },
       // Directives for other plugins' rules are not this tool's business.
       linterOptions: { reportUnusedDisableDirectives: false },
       languageOptions: {
         ecmaVersion: 'latest',
         sourceType: 'module',
+        ...(espree ? { parser: read(espree) } : {}),
         parserOptions: { ecmaFeatures: { jsx: true } },
       },
+      settings: { tasty: settings },
       rules,
     },
   ];
@@ -64,21 +114,46 @@ export function lintConfig({ plugin, rules, parser }) {
       files: ['**/*.{ts,tsx,mts,cts}'],
       // The parser prints its TypeScript version warning on stdout, which
       // would break --json. The project's own lint still shows it.
-      languageOptions: { parser, parserOptions: { loggerFn: false } },
+      languageOptions: {
+        parser: read(parser),
+        parserOptions: { loggerFn: false },
+      },
     });
   }
   return config;
 }
 
-export function createLinter({ ESLint, plugin, rules, parser, cwd }) {
+export function createLinter({ ESLint, cwd, ...options }) {
   return new ESLint({
     cwd,
     overrideConfigFile: true,
-    overrideConfig: lintConfig({ plugin, rules, parser }),
+    overrideConfig: lintConfig(options),
     errorOnUnmatchedPattern: false,
   });
 }
 
+/**
+ * What to lint a file with, from what `createConfigResolver().forFile()` found:
+ * the project's rules and settings, or the recommended preset when no config
+ * loads the plugin. `useStrict` adds the strict preset's rules that the config
+ * does not set. Rules and patterns resolve from the config's folder.
+ */
+export function lintOptions(
+  project,
+  { recommended, strict, useStrict = false, projectDir },
+) {
+  let rules = useStrict ? strict : recommended;
+  if (project.rules) {
+    rules = useStrict ? { ...strict, ...project.rules } : project.rules;
+  }
+  return {
+    rules,
+    settings: project.settings,
+    oxlintComments: project.source?.linter !== 'eslint',
+    cwd: project.source?.dir ?? projectDir,
+  };
+}
+
 /**
  * The problems in ESLint's results: this plugin's rules and parse errors. A
  * message with no rule that is not fatal says that ESLint skipped the file.
@@ -177,25 +252,32 @@ async function importFile(file) {
   return mod.default ?? mod;
 }
 
+export const NO_ESLINT =
+  'cannot find eslint. Install it in the project as a dev dependency: it is a peer dependency of @tenphi/eslint-plugin-tasty, and the tool runs the Tasty rules through ESLint even in a project that lints with Oxlint.';
+
 /**
- * ESLint as the project installs it, else the copy this package resolves. The
- * flat config class: ESLint 9 and later, or 8.57 through `loadESLint()`.
+ * ESLint as the project installs it, else the copy this package resolves: the
+ * flat config class (ESLint 9 and later, or 8.57 through `loadESLint()`), and
+ * espree, its JavaScript parser. Without ESLint, the error's `code` is
+ * `NO_ESLINT`.
  */
 export async function loadESLint(dirs, packageRoot) {
   for (const dir of [...dirs, packageRoot]) {
     const file = resolveFrom(dir, 'eslint');
     if (!file) continue;
     const eslint = await importFile(file);
-    if (typeof eslint.loadESLint === 'function') {
-      return eslint.loadESLint({ useFlatConfig: true });
+    if (typeof eslint.loadESLint !== 'function') {
+      throw new Error(
+        `ESLint ${eslint.ESLint?.version ?? ''} at ${dirname(file)} is too old: the tool needs ESLint 8.57 or later.`,
+      );
     }
-    throw new Error(
-      `ESLint ${eslint.ESLint?.version ?? ''} at ${dirname(file)} is too old: the tool needs ESLint 8.57 or later.`,
-    );
+    const espree = resolveFrom(dirname(file), 'espree');
+    return {
+      ESLint: await eslint.loadESLint({ useFlatConfig: true }),
+      espree: espree ? await importFile(espree) : undefined,
+    };
   }
-  throw new Error(
-    'cannot find eslint. Install it in the project: it is a peer dependency of @tenphi/eslint-plugin-tasty.',
-  );
+  throw Object.assign(new Error(NO_ESLINT), { code: 'NO_ESLINT' });
 }
 
 /**

package/harness/dev.harnesspm/scripts/project-config.mjs

@@ -0,0 +1,316 @@
+/**
+ * The project's own Tasty lint config, so the tools report what the project's
+ * lint reports: the level and options of each tasty/* rule, `settings.tasty`,
+ * and the files the config ignores. It comes from the nearest Oxlint or ESLint
+ * config above a file that loads this plugin.
+ *
+ * Both are read through ESLint's `calculateConfigForFile()`: the project's ESLint
+ * config as it is, and an Oxlint config once it is turned into a flat config
+ * that holds only its Tasty part.
+ */
+import { existsSync, readFileSync, realpathSync } from 'node:fs';
+import { dirname, isAbsolute, join, resolve, sep } from 'node:path';
+
+const NAME = '@tenphi/eslint-plugin-tasty';
+
+/** The names Oxlint gives the plugin when `jsPlugins` lists it without one. */
+const OXLINT_NAMES = ['@tenphi/tasty', NAME];
+
+/** The files Oxlint 1.x finds by itself, in each folder from the file up. */
+export const OXLINT_CONFIGS = [
+  '.oxlintrc.json',
+  '.oxlintrc.jsonc',
+  'oxlint.config.ts',
+  'oxlint.config.mts',
+];
+
+export const ESLINT_CONFIGS = [
+  'eslint.config.js',
+  'eslint.config.mjs',
+  'eslint.config.cjs',
+  'eslint.config.ts',
+  'eslint.config.mts',
+  'eslint.config.cts',
+];
+
+/** The files the tools lint, in an ESLint `files` pattern. */
+export const SOURCES = '**/*.{js,jsx,mjs,cjs,ts,tsx,mts,cts}';
+
+const LEVELS = {
+  off: 'off',
+  allow: 'off',
+  0: 'off',
+  warn: 'warn',
+  1: 'warn',
+  error: 'error',
+  deny: 'error',
+  2: 'error',
+};
+
+/** Whether a rule entry turns the rule on. */
+export function isOn(entry) {
+  return LEVELS[Array.isArray(entry) ? entry[0] : entry] !== 'off';
+}
+
+/**
+ * JSON with comments and trailing commas, as Oxlint reads `.oxlintrc.json`.
+ * Strings are copied as they are.
+ */
+export function parseJsonc(text) {
+  const withoutComments = replaceOutsideStrings(
+    text,
+    /\/\/[^\n]*|\/\*[\s\S]*?(?:\*\/|$)/y,
+    ' ',
+  );
+  return JSON.parse(
+    replaceOutsideStrings(withoutComments, /,(?=\s*[}\]])/y, ''),
+  );
+}
+
+/** Replaces each match of the sticky `pattern` that starts outside a string. */
+function replaceOutsideStrings(text, pattern, replacement) {
+  let out = '';
+  let i = 0;
+  while (i < text.length) {
+    if (text[i] === '"') {
+      let end = i + 1;
+      while (end < text.length && text[end] !== '"') {
+        end += text[end] === '\\' ? 2 : 1;
+      }
+      out += text.slice(i, end + 1);
+      i = end + 1;
+      continue;
+    }
+    pattern.lastIndex = i;
+    const match = pattern.exec(text);
+    if (match) {
+      out += replacement;
+      i += match[0].length;
+    } else {
+      out += text[i++];
+    }
+  }
+  return out;
+}
+
+async function importConfig(file) {
+  // Loaded only for a TypeScript config: the hook starts on every edit.
+  const { createJiti } = await import('jiti');
+  const jiti = createJiti(file, { moduleCache: false });
+  const mod = await jiti.import(file);
+  return mod?.default ?? mod;
+}
+
+async function readOxlintConfig(file) {
+  return /\.jsonc?$/.test(file)
+    ? parseJsonc(readFileSync(file, 'utf8'))
+    : importConfig(file);
+}
+
+/** A config and the configs it extends, in the order Oxlint merges them. */
+async function oxlintLayers(config, dir, seen = new Set()) {
+  const layers = [];
+  for (const base of config?.extends ?? []) {
+    if (typeof base === 'string') {
+      const file = resolve(dir, base);
+      if (seen.has(file)) continue;
+      seen.add(file);
+      layers.push(
+        ...(await oxlintLayers(
+          await readOxlintConfig(file),
+          dirname(file),
+          seen,
+        )),
+      );
+    } else if (base && typeof base === 'object') {
+      layers.push(...(await oxlintLayers(base, dir, seen)));
+    }
+  }
+  if (config && typeof config === 'object') layers.push(config);
+  return layers;
+}
+
+/** Whether a `jsPlugins` specifier loads this package. */
+function isThisPlugin(specifier, dir, packageRoot) {
+  if (specifier === NAME || specifier.startsWith(`${NAME}/`)) return true;
+  if (!specifier.startsWith('.') && !isAbsolute(specifier)) return false;
+  try {
+    return realpathSync(resolve(dir, specifier)).startsWith(packageRoot + sep);
+  } catch {
+    return false;
+  }
+}
+
+/** The names an Oxlint config's `jsPlugins` give this plugin. */
+function oxlintNames(layers, dir, packageRoot) {
+  const names = new Set();
+  const entries = layers.flatMap((layer) => [
+    ...(layer.jsPlugins ?? []),
+    ...(layer.overrides ?? []).flatMap((o) => o?.jsPlugins ?? []),
+  ]);
+  for (const entry of entries) {
+    const { name, specifier } =
+      typeof entry === 'string' ? { specifier: entry } : (entry ?? {});
+    if (
+      typeof specifier !== 'string' ||
+      !isThisPlugin(specifier, dir, packageRoot)
+    ) {
+      continue;
+    }
+    for (const n of typeof name === 'string' ? [name] : OXLINT_NAMES) {
+      names.add(n);
+    }
+  }
+  return names;
+}
+
+/**
+ * The rules of this plugin in a rule map, renamed to `tasty/<rule>`, with
+ * Oxlint's levels (`allow`, `deny`) written as ESLint's.
+ */
+export function tastyRules(rules, names, known) {
+  const out = {};
+  for (const [key, entry] of Object.entries(rules ?? {})) {
+    const slash = key.lastIndexOf('/');
+    const rule = key.slice(slash + 1);
+    if (slash < 0 || !names.has(key.slice(0, slash)) || !known.has(rule)) {
+      continue;
+    }
+    const [level, ...options] = Array.isArray(entry) ? entry : [entry];
+    const severity = LEVELS[level];
+    if (severity) {
+      out[`tasty/${rule}`] = options.length ? [severity, ...options] : severity;
+    }
+  }
+  return out;
+}
+
+/** An Oxlint `files` pattern for ESLint: one without a slash matches at any depth. */
+export function fileGlob(pattern) {
+  const glob = pattern.replace(/^\.\//, '');
+  return glob.includes('/') ? glob : `**/${glob}`;
+}
+
+/** An Oxlint `ignorePatterns` entry, which follows `.gitignore`, for ESLint. */
+export function ignoreGlobs(pattern) {
+  const negated = pattern.startsWith('!');
+  let glob = negated ? pattern.slice(1) : pattern;
+  const folder = glob.endsWith('/');
+  if (folder) glob = glob.slice(0, -1);
+  if (glob.startsWith('/')) glob = glob.slice(1);
+  else if (!glob.includes('/')) glob = `**/${glob}`;
+  return (folder ? [`${glob}/**`] : [glob, `${glob}/**`]).map((g) =>
+    negated ? `!${g}` : g,
+  );
+}
+
+/**
+ * The flat config that holds the Tasty part of an Oxlint config: its rules,
+ * the overrides that change them, `settings.tasty` and `ignorePatterns`.
+ * Undefined when the config does not load the plugin.
+ */
+export async function oxlintFlatConfig(file, { plugin, packageRoot }) {
+  const dir = dirname(file);
+  const layers = await oxlintLayers(
+    await readOxlintConfig(file),
+    dir,
+    new Set([file]),
+  );
+  const names = oxlintNames(layers, dir, packageRoot);
+  if (names.size === 0) return undefined;
+  const known = new Set(Object.keys(plugin.rules));
+  const settings = Object.assign(
+    {},
+    ...layers.map((layer) => layer.settings?.tasty),
+  );
+  const ignores = layers
+    .flatMap((layer) => layer.ignorePatterns ?? [])
+    .flatMap(ignoreGlobs);
+  const overrides = layers.flatMap((layer) => layer.overrides ?? []);
+  return [
+    {
+      files: [SOURCES],
+      plugins: { tasty: plugin },
+      settings: { tasty: settings },
+    },
+    ...(ignores.length > 0 ? [{ ignores }] : []),
+    ...layers.map((layer) => ({
+      rules: tastyRules(layer.rules, names, known),
+    })),
+    ...overrides.map((override) => ({
+      files: (override.files ?? []).map(fileGlob),
+      ...(override.excludeFiles
+        ? { ignores: override.excludeFiles.map(fileGlob) }
+        : {}),
+      rules: tastyRules(override.rules, names, known),
+    })),
+  ];
+}
+
+/**
+ * Finds and reads the project's Tasty lint config for each file.
+ *
+ * `forFile(file)` gives `{ source, rules, settings }`: `source` is the config
+ * (`{ linter, file, dir }`), or null when no config above the file loads the
+ * plugin, and then `rules` is null too. `ignored` is true when the config does
+ * not lint the file.
+ */
+export function createConfigResolver({ ESLint, plugin, packageRoot }) {
+  const known = new Set(Object.keys(plugin.rules));
+  const byDir = new Map();
+
+  async function sourceIn(dir) {
+    const oxlint = OXLINT_CONFIGS.map((n) => join(dir, n)).find(existsSync);
+    if (oxlint) {
+      const config = await oxlintFlatConfig(oxlint, { plugin, packageRoot });
+      if (config) {
+        return {
+          linter: 'oxlint',
+          file: oxlint,
+          dir,
+          eslint: new ESLint({
+            cwd: dir,
+            overrideConfigFile: true,
+            overrideConfig: config,
+          }),
+        };
+      }
+    }
+    // A text test first: loading an ESLint config loads every plugin it uses.
+    const eslint = ESLINT_CONFIGS.map((n) => join(dir, n)).find(existsSync);
+    if (eslint && readFileSync(eslint, 'utf8').includes(NAME)) {
+      return {
+        linter: 'eslint',
+        file: eslint,
+        dir,
+        eslint: new ESLint({ cwd: dir, overrideConfigFile: eslint }),
+      };
+    }
+    const parent = dirname(dir);
+    return parent === dir ? null : sourceFor(parent);
+  }
+
+  function sourceFor(dir) {
+    if (!byDir.has(dir)) byDir.set(dir, sourceIn(dir));
+    return byDir.get(dir);
+  }
+
+  return {
+    async forFile(file) {
+      const source = await sourceFor(dirname(file));
+      if (!source) return { source: null, rules: null, settings: {} };
+      const config = await source.eslint.calculateConfigForFile(file);
+      if (!config) return { source, ignored: true, rules: {}, settings: {} };
+      const names = new Set(
+        Object.entries(config.plugins ?? {})
+          .filter(([, p]) => p === plugin || p?.meta?.name === NAME)
+          .map(([name]) => name),
+      );
+      return {
+        source,
+        rules: tastyRules(config.rules, names, known),
+        settings: { ...config.settings?.tasty },
+      };
+    },
+  };
+}

package/harness/plugin.json

@@ -11,7 +11,7 @@
       "scripts": {
         "check": {
           "file": "./dev.harnesspm/scripts/check.mjs",
-          "description": "Lint files or folders with only the tasty/* rules (recommended, or --strict) and the project's tasty.config, and print each problem with its rule's page",
+          "description": "Lint files or folders with only the tasty/* rules, as the project's Oxlint or ESLint config sets them (else the recommended preset, or --strict), and print each problem with its rule's page",
           "allow": true
         },
         "check-edit": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tenphi/eslint-plugin-tasty",
-  "version": "1.19.0",
+  "version": "1.19.1",
   "description": "ESLint plugin for validating tasty() and tastyStatic() style objects",
   "type": "module",
   "exports": {