@aria-a11y/cli 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Vanessa Martin
+
+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/README.md

@@ -0,0 +1,25 @@
+# @aria-a11y/cli
+
+The **zero-config** command-line runner for [Aria](https://github.com/vsm1996/aria)'s
+accessibility rules. No ESLint config file, no host setup — point it at your
+code and it works, parsing `.jsx`/`.tsx` (and plain JS) out of the box.
+
+```sh
+npx @aria-a11y/cli check src     # report a11y diagnostics (both tiers);
+                            # exits nonzero on any format-tier issue — the CI teeth
+npx @aria-a11y/cli fix src       # apply format-tier (safe, meaning-preserving) fixes only
+```
+
+`aria fix` applies only auto-safe format-tier fixes; lint-tier suggestions are
+never applied. It honors an optional `aria.config.{ts,js,json}` (how a design
+system declares component semantics) but requires none.
+
+## How it works
+
+Internally the CLI wraps ESLint's `Linter` with a Babel→ESTree parser, so
+`eslint` is a real dependency — an implementation detail, not something you
+configure. The rules are the *exact same modules* the ESLint plugin runs, so
+output is identical to ESLint by construction. "Standalone" means no ESLint
+config and no host, not zero ESLint code inside.
+
+MIT

package/dist/chunk-AX3Y6N3T.js

@@ -0,0 +1,57 @@
+#!/usr/bin/env node
+
+// src/runner.ts
+import { createRequire } from "module";
+import { parse, resolve } from "path";
+import { Linter } from "eslint";
+import plugin from "eslint-plugin-aria-a11y";
+import babelParser from "@babel/eslint-parser";
+var linter = new Linter({ cwd: parse(process.cwd()).root });
+var recommendedRules = plugin.configs["recommended"]?.rules;
+if (recommendedRules === void 0) {
+  throw new Error("eslint-plugin-aria-a11y is missing its recommended config");
+}
+var requireFromHere = createRequire(import.meta.url);
+var presetReact = requireFromHere.resolve("@babel/preset-react");
+var presetTypescript = requireFromHere.resolve("@babel/preset-typescript");
+var baseConfig = {
+  // Flat config only opts non-.js extensions into linting via an explicit
+  // `files` glob — without this, .tsx/.jsx get "no matching configuration".
+  files: ["**/*.{js,mjs,cjs,jsx,ts,mts,cts,tsx}"],
+  plugins: { "aria-a11y": plugin },
+  languageOptions: {
+    parser: babelParser,
+    parserOptions: {
+      requireConfigFile: false,
+      ecmaFeatures: { jsx: true },
+      babelOptions: {
+        // Absolute preset paths so Babel needn't resolve them from the target's cwd.
+        presets: [[presetReact, { runtime: "automatic" }], presetTypescript]
+      }
+    }
+  },
+  // The recommended rule set — all eight rules at their tier severities.
+  rules: recommendedRules
+};
+function toDiagnostics(messages) {
+  return messages.filter((m) => m.ruleId !== null || m.fatal).map((m) => ({
+    ruleId: m.ruleId ?? null,
+    severity: m.severity === 2 ? "error" : "warning",
+    message: m.message,
+    line: m.line ?? 1,
+    column: m.column ?? 1,
+    formatTier: m.fix !== void 0
+  }));
+}
+function lintText(code, filename) {
+  return toDiagnostics(linter.verify(code, baseConfig, resolve(filename)));
+}
+function fixText(code, filename) {
+  const result = linter.verifyAndFix(code, baseConfig, resolve(filename));
+  return { output: result.output, remaining: toDiagnostics(result.messages) };
+}
+
+export {
+  lintText,
+  fixText
+};

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/cli.js

@@ -0,0 +1,129 @@
+#!/usr/bin/env node
+import {
+  fixText,
+  lintText
+} from "./chunk-AX3Y6N3T.js";
+
+// src/cli.ts
+import { readdirSync, readFileSync, statSync, writeFileSync } from "fs";
+import { join, relative } from "path";
+var SOURCE_EXT = /\.(?:js|jsx|ts|tsx|mjs|cjs|mts|cts)$/;
+var SKIP_DIR = /* @__PURE__ */ new Set(["node_modules", "dist", ".git", "coverage", ".turbo"]);
+var useColor = process.stdout.isTTY && process.env["NO_COLOR"] === void 0;
+var paint = (code, s) => useColor ? `\x1B[${code}m${s}\x1B[0m` : s;
+var red = (s) => paint("31", s);
+var yellow = (s) => paint("33", s);
+var dim = (s) => paint("2", s);
+var bold = (s) => paint("1", s);
+function collectFiles(paths) {
+  const out = [];
+  const walk = (p) => {
+    let st;
+    try {
+      st = statSync(p);
+    } catch {
+      process.stderr.write(red(`aria: no such path: ${p}
+`));
+      return;
+    }
+    if (st.isDirectory()) {
+      for (const entry of readdirSync(p)) {
+        if (SKIP_DIR.has(entry)) continue;
+        walk(join(p, entry));
+      }
+    } else if (SOURCE_EXT.test(p)) {
+      out.push(p);
+    }
+  };
+  for (const p of paths) walk(p);
+  return out;
+}
+function printDiagnostics(file, diags) {
+  if (diags.length === 0) return;
+  process.stdout.write(bold(relative(process.cwd(), file)) + "\n");
+  for (const d of diags) {
+    const sev = d.severity === "error" ? red("error") : yellow("warn ");
+    const loc = dim(`${d.line}:${d.column}`);
+    const rule = dim(d.ruleId ?? "");
+    process.stdout.write(`  ${loc}  ${sev}  ${d.message}  ${rule}
+`);
+  }
+  process.stdout.write("\n");
+}
+function summarize(files, diags) {
+  const errors = diags.filter((d) => d.severity === "error").length;
+  const warnings = diags.length - errors;
+  const format = diags.filter((d) => d.formatTier).length;
+  process.stdout.write(
+    dim(
+      `${files} file(s) scanned \u2014 ${diags.length} finding(s): ${errors} error, ${warnings} warning (${format} format-tier).
+`
+    )
+  );
+}
+function runCheck(paths) {
+  const files = collectFiles(paths);
+  const all = [];
+  for (const file of files) {
+    const diags = lintText(readFileSync(file, "utf8"), file);
+    printDiagnostics(file, diags);
+    all.push(...diags);
+  }
+  summarize(files.length, all);
+  return all.some((d) => d.formatTier) ? 1 : 0;
+}
+function runFix(paths) {
+  const files = collectFiles(paths);
+  let fixedCount = 0;
+  const remaining = [];
+  for (const file of files) {
+    const before = readFileSync(file, "utf8");
+    const { output, remaining: left } = fixText(before, file);
+    if (output !== before) {
+      writeFileSync(file, output);
+      fixedCount += 1;
+      process.stdout.write(dim(`fixed  ${relative(process.cwd(), file)}
+`));
+    }
+    printDiagnostics(file, left);
+    remaining.push(...left);
+  }
+  process.stdout.write(dim(`
+${fixedCount} file(s) fixed.
+`));
+  summarize(files.length, remaining);
+  return remaining.some((d) => d.formatTier) ? 1 : 0;
+}
+var HELP = `aria \u2014 zero-config accessibility linter (Aria rules, no ESLint config required)
+
+Usage:
+  aria check [paths...]   Report accessibility diagnostics (both tiers).
+                          Exits nonzero if any format-tier issue is present.
+  aria fix   [paths...]   Apply format-tier (safe, meaning-preserving) fixes.
+                          Never applies lint-tier suggestions.
+
+paths default to the current directory. Scans .js/.jsx/.ts/.tsx (and .mjs/.cjs).
+`;
+function main(argv) {
+  const [command, ...rest] = argv;
+  const paths = rest.filter((a) => !a.startsWith("-"));
+  const targets = paths.length > 0 ? paths : ["."];
+  switch (command) {
+    case "check":
+      return runCheck(targets);
+    case "fix":
+      return runFix(targets);
+    case "help":
+    case "--help":
+    case "-h":
+    case void 0:
+      process.stdout.write(HELP);
+      return command === void 0 ? 1 : 0;
+    default:
+      process.stderr.write(red(`aria: unknown command "${command}"
+
+`) + HELP);
+      return 1;
+  }
+}
+process.exit(main(process.argv.slice(2)));

package/dist/runner.d.ts

@@ -0,0 +1,33 @@
+/**
+ * A diagnostic as the CLI surfaces it. Mirrors ESLint's message plus the one
+ * derived fact the CLI's exit gate needs: whether the finding is format-tier.
+ */
+interface AriaDiagnostic {
+    ruleId: string | null;
+    severity: 'error' | 'warning';
+    message: string;
+    line: number;
+    column: number;
+    /**
+     * True when ESLint attached an auto-applicable `fix` to this message. Per the
+     * gate (already enforced inside the rules via `emit`), only native/declared
+     * basis — i.e. format-tier — diagnostics carry a `fix`; lint-tier ones carry
+     * a `suggest` or nothing. So this flag IS the format-tier signal, reused, not
+     * recomputed.
+     */
+    formatTier: boolean;
+}
+/** Lint one source string. `filename` drives TS/TSX detection and config discovery. */
+declare function lintText(code: string, filename: string): AriaDiagnostic[];
+/**
+ * Fix one source string. Applies ONLY ESLint-native `fix` edits — which, by the
+ * gate, are exactly the format-tier (native/declared) fixes. Lint-tier
+ * suggestions are never applied (ESLint's `verifyAndFix` never applies
+ * `suggest`). No separate "is this safe" check exists or is needed.
+ */
+declare function fixText(code: string, filename: string): {
+    output: string;
+    remaining: AriaDiagnostic[];
+};
+
+export { type AriaDiagnostic, fixText, lintText };

package/dist/runner.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+import {
+  fixText,
+  lintText
+} from "./chunk-AX3Y6N3T.js";
+export {
+  fixText,
+  lintText
+};

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@aria-a11y/cli",
+  "version": "0.1.0",
+  "description": "Zero-config standalone CLI for Aria's accessibility rules — aria check / aria fix, no ESLint config required.",
+  "keywords": [
+    "accessibility",
+    "a11y",
+    "aria",
+    "wcag",
+    "jsx",
+    "react",
+    "cli",
+    "linter",
+    "formatter"
+  ],
+  "homepage": "https://github.com/vsm1996/aria#readme",
+  "bugs": "https://github.com/vsm1996/aria/issues",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vsm1996/aria.git",
+    "directory": "packages/cli"
+  },
+  "license": "MIT",
+  "author": "Vanessa Martin",
+  "type": "module",
+  "bin": {
+    "aria": "./dist/cli.js"
+  },
+  "main": "./dist/runner.js",
+  "exports": {
+    ".": {
+      "types": "./dist/runner.d.ts",
+      "import": "./dist/runner.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@babel/core": "^7.29.0",
+    "@babel/eslint-parser": "^7.29.0",
+    "@babel/preset-react": "^7.27.0",
+    "@babel/preset-typescript": "^7.27.0",
+    "eslint": "^9.13.0",
+    "eslint-plugin-aria-a11y": "^0.1.0"
+  },
+  "devDependencies": {
+    "tsup": "^8.3.0"
+  },
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit"
+  }
+}