equall-cli 0.1.2 → 0.1.3

package/README.md

@@ -11,17 +11,26 @@ equall scan .
 ```
   ◆ EQUALL — Accessibility Score
 
-  58   ~A   WCAG 2.2
+  56   ~A   WCAG 2.2
 
   POUR Breakdown
-  P Perceivable    ███████████████████░ 97
-  O Operable       █████████░░░░░░░░░░░ 46
+  P Perceivable    ██████████████████░░ 89
+  O Operable       ███████████████░░░░░ 76
   U Understandable ░░░░░░░░░░░░░░░░░░░░ n/a
-  R Robust         ██████████████████░░ 91
+  R Robust         █████████████████░░░ 85
 
   Summary
-  33 files scanned  ·  18 WCAG violations · 5 best-practice issues
-  2 critical  2 serious  19 moderate  0 minor
+  33 files scanned  ·  15 WCAG violations · 19 best-practice issues
+  2 critical  11 serious  19 moderate  0 minor
+  2 issues ignored via equall-ignore
+  Score 56/100  ·  18/30 Level A criteria checked (60%)  ·  5 failed
+                   29/57 Level AA criteria checked (51%)  ·  6 failed
+
+  ⓘ You're failing 5 Level A criteria (1.3.1, 2.1.1, 2.4.2, 2.4.4, 4.1.2).
+    Level A is the legal minimum — fix these first.
+
+  Scanners: axe-core@4.11.1 (23 issues), eslint-jsx-a11y@6.10.2 (13 issues)
+  Completed in 0.8s
 ```
 
 ## Install
@@ -102,6 +111,40 @@ The POUR metrics (Perceivable, Operable, Understandable, Robust) strictly follow
 ### Conformance Level
 Conformance (A / AA / AAA) is evaluated strictly against your `--level` target. If you target `AA`, any `AAA` rules incidentally flagged by the scanners will not downgrade your conformance status.
 
+## Ignoring issues
+
+Some issues are false positives (e.g. an orphan `<li>` in a component that's always rendered inside a `<ul>`). Suppress them with inline comments:
+
+```tsx
+// equall-ignore-next-line
+<li>{item.name}</li>
+
+// equall-ignore-next-line jsx-a11y/alt-text
+<img src={logo} />
+
+{/* equall-ignore-next-line */}
+<div onClick={handler}>...</div>
+```
+
+```html
+<!-- equall-ignore-next-line -->
+<img src="decorative.png" />
+```
+
+Add `// equall-ignore-file` in the first 5 lines to ignore an entire file.
+
+Or use the CLI to inject/manage comments without opening the file:
+
+```bash
+equall ignore src/Modal.tsx:89                          # ignore all rules at line 89
+equall ignore src/Modal.tsx:89 jsx-a11y/alt-text        # ignore a specific rule
+equall ignore .                                         # list all ignores
+equall ignore --remove src/Modal.tsx:89                 # remove an ignore
+equall ignore --clear                                   # remove all ignores
+```
+
+Ignored issues are excluded from the score. Use `equall scan . -i` to show them, or `--json` to get them with `"ignored": true`.
+
 ## Programmatic API
 
 ```typescript
@@ -124,6 +167,10 @@ console.log(result.issues.length)      // 12
 - `1` — score < 50 (useful for CI gates)
 - `2` — scan error
 
+## Contributing
+
+Issues and PRs welcome — https://github.com/GotaBird/equall/issues
+
 ## License
 
 MIT

package/dist/{chunk-JMFHJMBB.js → chunk-5YPLWCOT.js}

@@ -39268,7 +39268,8 @@ function computeSummary(issues, filesScanned) {
     by_severity: bySeverity,
     by_scanner: byScanner,
     criteria_tested: [...criteriaSet].sort(),
-    criteria_failed: [...failedCriteriaSet].sort()
+    criteria_failed: [...failedCriteriaSet].sort(),
+    ignored_count: 0
   };
 }
 function computeScore(issues, filesScanned) {
@@ -40373,9 +40374,9 @@ async function runScan(options = {}) {
   );
   const allIssues = [];
   const scannersUsed = [];
-  for (const result of scannerResults) {
-    if (result.status === "fulfilled") {
-      const { scanner, issues } = result.value;
+  for (const result2 of scannerResults) {
+    if (result2.status === "fulfilled") {
+      const { scanner, issues } = result2.value;
       allIssues.push(...issues);
       scannersUsed.push({
         name: scanner.name,
@@ -40385,16 +40386,63 @@ async function runScan(options = {}) {
         issues_found: issues.length
       });
     } else {
-      const err = result.reason instanceof Error ? result.reason.message : String(result.reason);
+      const err = result2.reason instanceof Error ? result2.reason.message : String(result2.reason);
       console.warn(`  [scanner] Failed: ${err.slice(0, 120)}`);
     }
   }
   const deduped = deduplicateIssues(allIssues);
+  const { active, ignored } = applyIgnoreComments(deduped, files);
   const criteriaCovered = [...new Set(scanners.flatMap((s) => s.coveredCriteria))].sort();
   const WCAG_TOTAL = { A: 30, AA: 57, AAA: 78 };
   const criteriaTotal = WCAG_TOTAL[scanOptions.wcag_level] ?? 57;
   const durationMs = Date.now() - startTime;
-  return computeScanResult(deduped, files.length, scannersUsed, durationMs, scanOptions.wcag_level, criteriaCovered, criteriaTotal);
+  const result = computeScanResult(active, files.length, scannersUsed, durationMs, scanOptions.wcag_level, criteriaCovered, criteriaTotal);
+  result.issues = [...active, ...ignored];
+  result.summary.ignored_count = ignored.length;
+  return result;
+}
+function applyIgnoreComments(issues, files) {
+  const fileContentMap = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const lines = file.content.split("\n");
+    fileContentMap.set(file.path, lines);
+  }
+  const ignoredFiles = /* @__PURE__ */ new Set();
+  for (const [filePath, lines] of fileContentMap) {
+    const header = lines.slice(0, 5);
+    if (header.some((line) => line.includes("equall-ignore-file"))) {
+      ignoredFiles.add(filePath);
+    }
+  }
+  const active = [];
+  const ignored = [];
+  for (const issue of issues) {
+    if (ignoredFiles.has(issue.file_path)) {
+      ignored.push({ ...issue, ignored: true });
+      continue;
+    }
+    if (issue.line != null && issue.line > 1) {
+      const lines = fileContentMap.get(issue.file_path);
+      if (lines) {
+        const prevLine = lines[issue.line - 2] ?? "";
+        if (prevLine.includes("equall-ignore-next-line")) {
+          const stripped = prevLine.replace(/\s*(?:-->|\*\/\}?)\s*$/g, "");
+          const match = stripped.match(/equall-ignore-next-line\s+([\w\-/.]+)/);
+          if (match) {
+            if (match[1] === issue.scanner_rule_id) {
+              ignored.push({ ...issue, ignored: true });
+              continue;
+            }
+          } else {
+            ignored.push({ ...issue, ignored: true });
+            continue;
+          }
+        }
+      }
+    }
+    active.push(issue);
+  }
+  return { active, ignored };
 }
 function deduplicateIssues(issues) {
   const seen = /* @__PURE__ */ new Set();
@@ -40416,6 +40464,7 @@ export {
   __commonJS,
   __export,
   __toESM,
+  globby,
   computeScanResult,
   runScan
 };

package/dist/cli.js

@@ -5,8 +5,9 @@ import {
   __export,
   __require,
   __toESM,
+  globby,
   runScan
-} from "./chunk-JMFHJMBB.js";
+} from "./chunk-5YPLWCOT.js";
 
 // node_modules/commander/lib/error.js
 var require_error = __commonJS({
@@ -3009,7 +3010,7 @@ var require_commander = __commonJS({
 });
 
 // src/cli.ts
-import { resolve, basename } from "path";
+import { resolve as resolve2, basename } from "path";
 
 // node_modules/commander/esm.mjs
 var import_index = __toESM(require_commander(), 1);
@@ -6512,7 +6513,7 @@ function bar(value, width = 20) {
   const color = scoreColor(value);
   return `${color}${"\u2588".repeat(filled)}${DIM}${"\u2591".repeat(empty)}${RESET} ${color}${value}${RESET}`;
 }
-function printResult(result) {
+function printResult(result, options = {}) {
   const { score, conformance_level, pour_scores, summary, scanners_used, duration_ms } = result;
   console.log();
   console.log(`${BOLD}  \u25C6 EQUALL \u2014 Accessibility Score${RESET}`);
@@ -6531,6 +6532,9 @@ function printResult(result) {
   const bpIssuesCount = result.issues.length - wcagIssuesCount;
   console.log(`  ${summary.files_scanned} files scanned  \xB7  ${wcagIssuesCount} WCAG violations \xB7 ${bpIssuesCount} best-practice issues`);
   console.log(`  ${RED}${summary.by_severity.critical} critical${RESET}  ${YELLOW}${summary.by_severity.serious} serious${RESET}  ${CYAN}${summary.by_severity.moderate} moderate${RESET}  ${DIM}${summary.by_severity.minor} minor${RESET}`);
+  if (summary.ignored_count > 0) {
+    console.log(`  ${DIM}${summary.ignored_count} issue${summary.ignored_count > 1 ? "s" : ""} ignored via equall-ignore${RESET}`);
+  }
   if (result.criteria_total > 0) {
     const covered = result.criteria_covered.length;
     const total = result.criteria_total;
@@ -6559,8 +6563,9 @@ function printResult(result) {
   console.log();
   printCoaching(result);
   console.log();
-  const wcagIssues = result.issues.filter((i) => i.wcag_criteria.length > 0);
-  const bpIssues = result.issues.filter((i) => i.wcag_criteria.length === 0);
+  const visibleIssues = result.issues.filter((i) => !i.ignored);
+  const wcagIssues = visibleIssues.filter((i) => i.wcag_criteria.length > 0);
+  const bpIssues = visibleIssues.filter((i) => i.wcag_criteria.length === 0);
   if (wcagIssues.length > 0) {
     console.log(`  ${BOLD}WCAG Violations${RESET}`);
     const grouped = groupByCriterion(wcagIssues);
@@ -6597,6 +6602,17 @@ function printResult(result) {
     }
     console.log();
   }
+  if (options.showIgnored) {
+    const ignoredIssues = result.issues.filter((i) => i.ignored);
+    if (ignoredIssues.length > 0) {
+      console.log(`  ${BOLD}Ignored${RESET}`);
+      for (const issue of ignoredIssues) {
+        const location = issue.line ? `:${issue.line}` : "";
+        console.log(`  ${DIM}\u2298${RESET} ${DIM}${issue.file_path}${location}${RESET}  ${issue.scanner_rule_id}`);
+      }
+      console.log();
+    }
+  }
   console.log(`  ${DIM}Scanners: ${scanners_used.map((s) => `${s.name}@${s.version} (${s.issues_found} issues)`).join(", ")}${RESET}`);
   console.log(`  ${DIM}Completed in ${(duration_ms / 1e3).toFixed(1)}s${RESET}`);
   console.log();
@@ -6660,16 +6676,148 @@ function printJson(result) {
   console.log(JSON.stringify(result, null, 2));
 }
 
+// src/ignores.ts
+import { readFile, writeFile } from "fs/promises";
+import { resolve } from "path";
+var IGNORE_PATTERN = /equall-ignore-(next-line|file)(?:\s+(\S+))?/;
+async function findIgnores(rootPath) {
+  const paths = await globby(
+    ["**/*.{html,htm,jsx,tsx,vue,svelte,astro}"],
+    {
+      cwd: rootPath,
+      ignore: ["**/node_modules/**", "**/dist/**", "**/build/**", "**/.next/**"],
+      absolute: false,
+      gitignore: true
+    }
+  );
+  const entries = [];
+  for (const relativePath of paths) {
+    const absolutePath = resolve(rootPath, relativePath);
+    let content;
+    try {
+      content = await readFile(absolutePath, "utf-8");
+    } catch {
+      continue;
+    }
+    const lines = content.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      const match = lines[i].match(IGNORE_PATTERN);
+      if (!match) continue;
+      const type = match[1];
+      if (type === "file" && i >= 5) continue;
+      entries.push({
+        file_path: relativePath,
+        line: i + 1,
+        type,
+        rule_id: match[2] ?? null,
+        raw: lines[i].trim()
+      });
+    }
+  }
+  return entries.sort((a, b) => a.file_path.localeCompare(b.file_path) || a.line - b.line);
+}
+async function removeIgnore(rootPath, target) {
+  const ignores = await findIgnores(rootPath);
+  const colonIdx = target.lastIndexOf(":");
+  let targetFile;
+  let targetLine = null;
+  if (colonIdx > 0) {
+    const maybeLine = parseInt(target.slice(colonIdx + 1), 10);
+    if (!isNaN(maybeLine)) {
+      targetFile = target.slice(0, colonIdx);
+      targetLine = maybeLine;
+    } else {
+      targetFile = target;
+    }
+  } else {
+    targetFile = target;
+  }
+  const matches = ignores.filter((e) => {
+    if (e.file_path !== targetFile) return false;
+    if (targetLine !== null) return e.line === targetLine;
+    return true;
+  });
+  if (matches.length === 0) {
+    return { removed: [], notFound: true };
+  }
+  const byFile = /* @__PURE__ */ new Map();
+  for (const m of matches) {
+    const lines = byFile.get(m.file_path) ?? [];
+    lines.push(m.line);
+    byFile.set(m.file_path, lines);
+  }
+  for (const [filePath, lineNumbers] of byFile) {
+    const absolutePath = resolve(rootPath, filePath);
+    const content = await readFile(absolutePath, "utf-8");
+    const lines = content.split("\n");
+    const toRemove = new Set(lineNumbers.map((l) => l - 1));
+    const newLines = lines.filter((_, i) => !toRemove.has(i));
+    await writeFile(absolutePath, newLines.join("\n"), "utf-8");
+  }
+  return { removed: matches, notFound: false };
+}
+async function addIgnore(rootPath, target, ruleId) {
+  const colonIdx = target.lastIndexOf(":");
+  if (colonIdx <= 0) return null;
+  const targetFile = target.slice(0, colonIdx);
+  const targetLine = parseInt(target.slice(colonIdx + 1), 10);
+  if (isNaN(targetLine) || targetLine < 1) return null;
+  const absolutePath = resolve(rootPath, targetFile);
+  let content;
+  try {
+    content = await readFile(absolutePath, "utf-8");
+  } catch {
+    return null;
+  }
+  const lines = content.split("\n");
+  if (targetLine > lines.length) return null;
+  const targetContent = lines[targetLine - 1];
+  const indent = targetContent.match(/^(\s*)/)?.[1] ?? "";
+  const ext = targetFile.split(".").pop()?.toLowerCase();
+  const ruleSuffix = ruleId ? ` ${ruleId}` : "";
+  let comment;
+  if (ext === "html" || ext === "htm") {
+    comment = `${indent}<!-- equall-ignore-next-line${ruleSuffix} -->`;
+  } else if (ext === "jsx" || ext === "tsx") {
+    const inJsx = targetContent.trimStart().startsWith("<") || targetContent.includes(">");
+    comment = inJsx ? `${indent}{/* equall-ignore-next-line${ruleSuffix} */}` : `${indent}// equall-ignore-next-line${ruleSuffix}`;
+  } else {
+    comment = `${indent}// equall-ignore-next-line${ruleSuffix}`;
+  }
+  lines.splice(targetLine - 1, 0, comment);
+  await writeFile(absolutePath, lines.join("\n"), "utf-8");
+  return { file: targetFile, line: targetLine, comment };
+}
+async function clearAllIgnores(rootPath) {
+  const ignores = await findIgnores(rootPath);
+  if (ignores.length === 0) return [];
+  const byFile = /* @__PURE__ */ new Map();
+  for (const entry of ignores) {
+    const lines = byFile.get(entry.file_path) ?? [];
+    lines.push(entry.line);
+    byFile.set(entry.file_path, lines);
+  }
+  for (const [filePath, lineNumbers] of byFile) {
+    const absolutePath = resolve(rootPath, filePath);
+    const content = await readFile(absolutePath, "utf-8");
+    const lines = content.split("\n");
+    const toRemove = new Set(lineNumbers.map((l) => l - 1));
+    const newLines = lines.filter((_, i) => !toRemove.has(i));
+    await writeFile(absolutePath, newLines.join("\n"), "utf-8");
+  }
+  return ignores;
+}
+
 // src/cli.ts
 var program2 = new Command();
 program2.name("equall").description("Open-source accessibility scoring \u2014 aggregates axe-core, eslint-plugin-jsx-a11y, and more.").version("0.1.0");
-program2.command("scan").description("Scan a project for accessibility issues").argument("[path]", "Path to project root", ".").option("-l, --level <level>", "WCAG conformance target: A, AA, or AAA", "AA").option("--include <patterns...>", "Glob patterns to include").option("--exclude <patterns...>", "Glob patterns to exclude").option("--json", "Output results as JSON").option("--no-color", "Disable colored output").action(async (path, opts) => {
+program2.command("scan").description("Scan a project for accessibility issues").argument("[path]", "Path to project root", ".").option("-l, --level <level>", "WCAG conformance target: A, AA, or AAA", "AA").option("--include <patterns...>", "Glob patterns to include").option("--exclude <patterns...>", "Glob patterns to exclude").option("--json", "Output results as JSON").option("-i, --show-ignored", "Show ignored issues in output").option("--no-color", "Disable colored output").action(async (path, opts) => {
   const level = opts.level.toUpperCase();
   if (!["A", "AA", "AAA"].includes(level)) {
     console.error(`Invalid level "${opts.level}". Use A, AA, or AAA.`);
     process.exit(1);
   }
-  const displayName = basename(resolve(path));
+  const displayName = basename(resolve2(path));
   const spinner = opts.json ? null : ora({ text: `Scanning ${displayName}`, indent: 2 }).start();
   try {
     const result = await runScan({
@@ -6691,7 +6839,7 @@ program2.command("scan").description("Scan a project for accessibility issues").
     if (opts.json) {
       printJson(result);
     } else {
-      printResult(result);
+      printResult(result, { showIgnored: opts.showIgnored });
     }
     if (result.score < 50) process.exit(1);
   } catch (error2) {
@@ -6703,4 +6851,68 @@ program2.command("scan").description("Scan a project for accessibility issues").
     process.exit(2);
   }
 });
+var DIM2 = "\x1B[2m";
+var BOLD2 = "\x1B[1m";
+var RESET2 = "\x1B[0m";
+var GREEN2 = "\x1B[32m";
+var YELLOW2 = "\x1B[33m";
+program2.command("ignore").description("Add, list, or remove equall-ignore comments").argument("[target]", "File:line to ignore (e.g. src/Modal.tsx:89)").argument("[rule-id]", "Optional rule ID (e.g. jsx-a11y/alt-text)").option("-p, --path <path>", "Path to project root", ".").option("--remove <target>", "Remove ignore at file:line or all ignores in a file").option("--clear", "Remove all equall-ignore comments from the project").option("--list", "List all equall-ignore comments").action(async (target, ruleId, opts) => {
+  const rootPath = resolve2(opts.path);
+  if (opts.clear) {
+    const removed = await clearAllIgnores(rootPath);
+    if (removed.length === 0) {
+      console.log("\n  No equall-ignore comments found.\n");
+    } else {
+      console.log(`
+  ${GREEN2}Removed ${removed.length} ignore comment${removed.length > 1 ? "s" : ""}${RESET2}
+`);
+    }
+    return;
+  }
+  if (opts.remove) {
+    const { removed, notFound } = await removeIgnore(rootPath, opts.remove);
+    if (notFound) {
+      console.error(`
+  No equall-ignore found at ${opts.remove}
+`);
+      process.exit(1);
+    }
+    for (const entry of removed) {
+      const location = entry.type === "file" ? "" : `:${entry.line}`;
+      console.log(`  ${GREEN2}Removed${RESET2} ${entry.file_path}${location}  ${DIM2}${entry.raw}${RESET2}`);
+    }
+    console.log();
+    return;
+  }
+  if (target && target.includes(":")) {
+    const result = await addIgnore(rootPath, target, ruleId);
+    if (!result) {
+      console.error(`
+  Could not add ignore at ${target}. Check that the file and line exist.
+`);
+      process.exit(1);
+    }
+    console.log(`
+  ${GREEN2}Added${RESET2} ${result.file}:${result.line}`);
+    console.log(`  ${DIM2}${result.comment.trim()}${RESET2}
+`);
+    return;
+  }
+  const listPath = target ? resolve2(target) : rootPath;
+  const ignores = await findIgnores(listPath);
+  if (ignores.length === 0) {
+    console.log("\n  No equall-ignore comments found.\n");
+    return;
+  }
+  console.log(`
+  ${BOLD2}${ignores.length} ignore${ignores.length > 1 ? "s" : ""}${RESET2}
+`);
+  for (const entry of ignores) {
+    const location = `:${entry.line}`;
+    const type = entry.type === "file" ? `${YELLOW2}equall-ignore-file${RESET2}` : `equall-ignore-next-line`;
+    const rule = entry.rule_id ? `  ${DIM2}${entry.rule_id}${RESET2}` : `  ${DIM2}(all rules)${RESET2}`;
+    console.log(`  ${entry.file_path}${location}${" ".repeat(Math.max(1, 40 - entry.file_path.length - location.length))}${type}${rule}`);
+  }
+  console.log();
+});
 program2.parse();

package/dist/index.d.ts

@@ -12,6 +12,7 @@ interface GladosIssue {
     message: string;
     help_url: string | null;
     suggestion: string | null;
+    ignored?: boolean;
 }
 type WcagLevel = 'A' | 'AA' | 'AAA';
 type PourPrinciple = 'perceivable' | 'operable' | 'understandable' | 'robust';
@@ -66,6 +67,7 @@ interface ScanSummary {
     by_scanner: Record<string, number>;
     criteria_tested: string[];
     criteria_failed: string[];
+    ignored_count: number;
 }
 interface ScannerInfo {
     name: string;

package/dist/index.js

@@ -2,7 +2,7 @@ import { createRequire as __createRequire } from 'module'; import { fileURLToPat
 import {
   computeScanResult,
   runScan
-} from "./chunk-JMFHJMBB.js";
+} from "./chunk-5YPLWCOT.js";
 export {
   computeScanResult,
   runScan

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "equall-cli",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "Open-source accessibility scoring CLI — aggregates axe-core, eslint-plugin-jsx-a11y, and more into a unified score.",
   "keywords": [
     "accessibility",
@@ -65,4 +65,4 @@
   "engines": {
     "node": ">=18.0.0"
   }
-}
+}