equall-cli 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Bureau61
+
+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,117 @@
+# Equall
+
+Open-source accessibility scoring for dev teams. Aggregates axe-core, eslint-plugin-jsx-a11y, and more into a unified score.
+
+**One command. Real score. No config.**
+
+```bash
+equall scan .
+```
+
+```
+  ◆ EQUALL — Accessibility Score
+
+  58   ~A   WCAG 2.2
+
+  POUR Breakdown
+  P Perceivable    ███████████████████░ 97
+  O Operable       █████████░░░░░░░░░░░ 46
+  U Understandable ░░░░░░░░░░░░░░░░░░░░ n/a
+  R Robust         ██████████████████░░ 91
+
+  Summary
+  33 files scanned  ·  18 WCAG violations · 5 best-practice issues
+  2 critical  2 serious  19 moderate  0 minor
+```
+
+## Why Equall?
+
+Accessibility tools today fall into two camps: dev tools that show violations without context (axe, Lighthouse), and enterprise platforms that cost $75K+/year (Deque, Siteimprove). Nothing in between.
+
+Equall aggregates existing open-source scanners and adds what's missing: a **score**, a **trend**, and a **POUR breakdown** that tells you where to focus.
+
+- **Aggregator, not reinventor** — wraps axe-core, eslint-plugin-jsx-a11y, and more. We don't rewrite rules, we unify results.
+- **Score 0-100** — weighted by severity, grouped by WCAG criterion, with a conformance level (A / AA / AAA).
+- **POUR breakdown** — see which accessibility principle (Perceivable, Operable, Understandable, Robust) is your weakest.
+- **Zero config** — point it at a folder, get a score. No setup, no account, no signup.
+- **Honest about coverage** — we tell you exactly which criteria we test and which need manual review. No "100% compliant" bullshit.
+
+## Usage
+
+### Scan a project
+
+```bash
+equall scan .                    # current directory
+equall scan ./my-app             # specific path
+equall scan . --level A          # target Level A only
+equall scan . --level AAA        # include Level AAA criteria
+```
+
+### JSON output
+
+```bash
+equall scan . --json             # pipe to other tools
+equall scan . --json > report.json
+```
+
+### Filter files
+
+```bash
+equall scan . --include "src/**/*.tsx"
+equall scan . --exclude "**/*.stories.*"
+equall scan . --no-color             # disable colored output
+```
+
+## What gets scanned
+
+Equall discovers and scans: `.html`, `.htm`, `.jsx`, `.tsx`, `.vue`, `.svelte`, `.astro`
+
+It automatically skips: `node_modules`, `dist`, `build`, `.next`, test files, stories, and respects `.gitignore`.
+
+## Scanners
+
+| Scanner | What it checks | WCAG criteria covered |
+|---------|---------------|----------------------|
+| **axe-core** | HTML structure, ARIA, landmarks, forms, media | 24 |
+| **eslint-plugin-jsx-a11y** | JSX/React-specific a11y patterns | 17 |
+
+## Scoring
+
+The score (0-100) is designed to be fair and scalable, whether you are scanning 5 files or 5,000. It is calculated using a **density-based asymptotic algorithm**:
+
+- **Severity Weights**: Violations add a penalty based on severity (critical: 10, serious: 5, moderate: 2, minor: 1).
+- **Criterion Caps**: Penalties are capped at 15 points per WCAG criterion to prevent a single recurring issue from entirely destroying the score.
+- **Density Scaling**: Total penalties are scaled down logarithmically based on the number of files scanned (`1 / (1 + log10(files))`). A large repository is allowed more absolute errors than a tiny project for the same score.
+- **Exponential Curve**: The final score follows an asymptotic decay curve (`100 * exp(-k * penalty)`). It drops quickly for the first few errors but smoothly approaches `0` without ever hitting it brutally, leaving room to measure progression.
+
+### POUR Breakdown
+The POUR metrics (Perceivable, Operable, Understandable, Robust) strictly follow the same scoring logic, isolated by principle, providing an independent 0-100 score for each accessibility pillar.
+
+### 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.
+
+## Programmatic API
+
+```typescript
+import { runScan } from 'equall'
+
+const result = await runScan({
+  path: './my-project',
+  level: 'AA',
+})
+
+console.log(result.score)              // 73
+console.log(result.conformance_level)  // 'A'
+console.log(result.pour_scores)        // { perceivable: 90, operable: 65, ... }
+console.log(result.issues.length)      // 12
+```
+
+## Exit codes
+
+- `0` — score >= 50
+- `1` — score < 50 (useful for CI gates)
+- `2` — scan error
+
+## License
+
+MIT

package/dist/chunk-UA3BFAGG.js

@@ -0,0 +1,690 @@
+// src/scoring/score.ts
+var SEVERITY_WEIGHT = {
+  critical: 10,
+  serious: 5,
+  moderate: 2,
+  minor: 1
+};
+var MAX_PENALTY_PER_CRITERION = 15;
+function computeScanResult(issues, filesScanned, scannersUsed, durationMs, targetLevel = "AA", criteriaCovered = [], criteriaTotal = 0) {
+  const summary = computeSummary(issues, filesScanned);
+  const score = computeScore(issues, filesScanned);
+  const pourScores = computePourScores(issues, filesScanned);
+  const conformanceLevel = computeConformanceLevel(issues, summary, targetLevel);
+  return {
+    score,
+    conformance_level: conformanceLevel,
+    pour_scores: pourScores,
+    issues,
+    summary,
+    scanners_used: scannersUsed,
+    criteria_covered: criteriaCovered,
+    criteria_total: criteriaTotal,
+    scanned_at: (/* @__PURE__ */ new Date()).toISOString(),
+    duration_ms: durationMs
+  };
+}
+function computeSummary(issues, filesScanned) {
+  const bySeverity = {
+    critical: 0,
+    serious: 0,
+    moderate: 0,
+    minor: 0
+  };
+  const byScanner = {};
+  const criteriaSet = /* @__PURE__ */ new Set();
+  const failedCriteriaSet = /* @__PURE__ */ new Set();
+  for (const issue of issues) {
+    bySeverity[issue.severity]++;
+    byScanner[issue.scanner] = (byScanner[issue.scanner] ?? 0) + 1;
+    for (const c of issue.wcag_criteria) {
+      criteriaSet.add(c);
+      failedCriteriaSet.add(c);
+    }
+  }
+  return {
+    files_scanned: filesScanned,
+    total_issues: issues.length,
+    by_severity: bySeverity,
+    by_scanner: byScanner,
+    criteria_tested: [...criteriaSet].sort(),
+    criteria_failed: [...failedCriteriaSet].sort()
+  };
+}
+function computeScore(issues, filesScanned) {
+  if (issues.length === 0) return 100;
+  const penaltyByCriterion = /* @__PURE__ */ new Map();
+  for (const issue of issues) {
+    const weight = SEVERITY_WEIGHT[issue.severity];
+    for (const criterion of issue.wcag_criteria) {
+      const current = penaltyByCriterion.get(criterion) ?? 0;
+      penaltyByCriterion.set(criterion, Math.min(current + weight, MAX_PENALTY_PER_CRITERION));
+    }
+    if (issue.wcag_criteria.length === 0) {
+      const key = `_${issue.scanner}:${issue.scanner_rule_id}`;
+      const current = penaltyByCriterion.get(key) ?? 0;
+      penaltyByCriterion.set(key, Math.min(current + weight, MAX_PENALTY_PER_CRITERION));
+    }
+  }
+  const totalRawPenalty = [...penaltyByCriterion.values()].reduce((a, b) => a + b, 0);
+  const scaleFactor = 1 / (1 + Math.log10(Math.max(1, filesScanned)));
+  const scaledPenalty = totalRawPenalty * scaleFactor;
+  const k = 0.02;
+  const score = 100 * Math.exp(-k * scaledPenalty);
+  return Math.max(0, Math.round(score));
+}
+function computePourScores(issues, filesScanned) {
+  const pourIssues = {
+    perceivable: [],
+    operable: [],
+    understandable: [],
+    robust: []
+  };
+  const pourCriteria = {
+    perceivable: /* @__PURE__ */ new Set(),
+    operable: /* @__PURE__ */ new Set(),
+    understandable: /* @__PURE__ */ new Set(),
+    robust: /* @__PURE__ */ new Set()
+  };
+  for (const issue of issues) {
+    if (!issue.pour) continue;
+    pourIssues[issue.pour].push(issue);
+    for (const c of issue.wcag_criteria) {
+      pourCriteria[issue.pour].add(c);
+    }
+  }
+  const scaleFactor = 1 / (1 + Math.log10(Math.max(1, filesScanned)));
+  const k = 0.02;
+  function pourScore(principle) {
+    const principleIssues = pourIssues[principle];
+    const criteriaCount = pourCriteria[principle].size;
+    if (criteriaCount === 0 && principleIssues.length === 0) return null;
+    if (principleIssues.length === 0) return 100;
+    const penaltyByCriterion = /* @__PURE__ */ new Map();
+    for (const issue of principleIssues) {
+      const weight = SEVERITY_WEIGHT[issue.severity];
+      for (const criterion of issue.wcag_criteria) {
+        const current = penaltyByCriterion.get(criterion) ?? 0;
+        penaltyByCriterion.set(criterion, Math.min(current + weight, MAX_PENALTY_PER_CRITERION));
+      }
+      if (issue.wcag_criteria.length === 0) {
+        const key = `_${issue.scanner}:${issue.scanner_rule_id}`;
+        const current = penaltyByCriterion.get(key) ?? 0;
+        penaltyByCriterion.set(key, Math.min(current + weight, MAX_PENALTY_PER_CRITERION));
+      }
+    }
+    const totalRawPenalty = [...penaltyByCriterion.values()].reduce((a, b) => a + b, 0);
+    const scaledPenalty = totalRawPenalty * scaleFactor;
+    return Math.max(0, Math.round(100 * Math.exp(-k * scaledPenalty)));
+  }
+  return {
+    perceivable: pourScore("perceivable"),
+    operable: pourScore("operable"),
+    understandable: pourScore("understandable"),
+    robust: pourScore("robust")
+  };
+}
+function computeConformanceLevel(issues, summary, targetLevel) {
+  const failedByLevel = {
+    A: /* @__PURE__ */ new Set(),
+    AA: /* @__PURE__ */ new Set(),
+    AAA: /* @__PURE__ */ new Set()
+  };
+  for (const issue of issues) {
+    if (!issue.wcag_level) continue;
+    for (const c of issue.wcag_criteria) {
+      failedByLevel[issue.wcag_level].add(c);
+    }
+  }
+  const hasA = failedByLevel.A.size > 0;
+  const hasAA = failedByLevel.AA.size > 0;
+  const hasAAA = failedByLevel.AAA.size > 0;
+  if (targetLevel === "A") {
+    if (!hasA) return summary.criteria_tested.length > 0 ? "A" : "None";
+    return "Partial A";
+  }
+  if (targetLevel === "AA") {
+    if (!hasA && !hasAA) return summary.criteria_tested.length > 0 ? "AA" : "None";
+    if (!hasA) return "A";
+    return "Partial A";
+  }
+  if (targetLevel === "AAA") {
+    if (!hasA && !hasAA && !hasAAA) return summary.criteria_tested.length > 0 ? "AAA" : "None";
+    if (!hasA && !hasAA) return "AA";
+    if (!hasA) return "A";
+    return "Partial A";
+  }
+  return "None";
+}
+
+// src/scan.ts
+import { resolve as resolve2 } from "path";
+
+// src/discover.ts
+import { readFile } from "fs/promises";
+import { resolve, extname } from "path";
+var EXT_MAP = {
+  ".html": "html",
+  ".htm": "html",
+  ".jsx": "jsx",
+  ".tsx": "tsx",
+  ".vue": "vue",
+  ".svelte": "svelte",
+  ".astro": "astro"
+};
+var DEFAULT_INCLUDE = [
+  "**/*.html",
+  "**/*.htm",
+  "**/*.jsx",
+  "**/*.tsx",
+  "**/*.vue",
+  "**/*.svelte",
+  "**/*.astro"
+];
+var DEFAULT_EXCLUDE = [
+  "**/node_modules/**",
+  "**/dist/**",
+  "**/build/**",
+  "**/.next/**",
+  "**/.nuxt/**",
+  "**/coverage/**",
+  "**/*.min.*",
+  "**/*.test.*",
+  "**/*.spec.*",
+  "**/__tests__/**",
+  "**/*.stories.*",
+  "**/storybook-static/**"
+];
+async function discoverFiles(rootPath, options) {
+  const { globby } = await import("globby");
+  const includePatterns = options.include_patterns.length > 0 ? options.include_patterns : DEFAULT_INCLUDE;
+  const excludePatterns = [
+    ...DEFAULT_EXCLUDE,
+    ...options.exclude_patterns
+  ];
+  const paths = await globby(includePatterns, {
+    cwd: rootPath,
+    ignore: excludePatterns,
+    absolute: false,
+    gitignore: true
+  });
+  const files = [];
+  for (const relativePath of paths) {
+    const absolutePath = resolve(rootPath, relativePath);
+    try {
+      const content = await readFile(absolutePath, "utf-8");
+      const ext = extname(relativePath).toLowerCase();
+      const type = EXT_MAP[ext] ?? "other";
+      files.push({
+        path: relativePath,
+        absolute_path: absolutePath,
+        content,
+        type
+      });
+    } catch {
+    }
+  }
+  return files;
+}
+
+// src/scanners/axe-scanner.ts
+function parseWcagTags(tags) {
+  const criteria = [];
+  let level = null;
+  let pour = null;
+  for (const tag of tags) {
+    const criterionMatch = tag.match(/^wcag([1-4])(\d)(\d+)$/);
+    if (criterionMatch) {
+      criteria.push(`${criterionMatch[1]}.${criterionMatch[2]}.${criterionMatch[3]}`);
+      continue;
+    }
+    if (tag === "wcag2a" || tag === "wcag21a" || tag === "wcag22a") level = "A";
+    else if (tag === "wcag2aa" || tag === "wcag21aa" || tag === "wcag22aa") level = "AA";
+    else if (tag === "wcag2aaa" || tag === "wcag21aaa" || tag === "wcag22aaa") level = "AAA";
+    if (tag === "cat.text-alternatives" || tag === "cat.color" || tag === "cat.sensory-and-visual-cues" || tag === "cat.time-and-media" || tag === "cat.tables" || tag === "cat.forms") {
+      pour = pour ?? "perceivable";
+    }
+    if (tag === "cat.keyboard" || tag === "cat.navigation" || tag === "cat.time-and-media") {
+      pour = pour ?? "operable";
+    }
+    if (tag === "cat.language" || tag === "cat.parsing" || tag === "cat.forms") {
+      pour = pour ?? "understandable";
+    }
+    if (tag === "cat.name-role-value" || tag === "cat.structure" || tag === "cat.aria") {
+      pour = pour ?? "robust";
+    }
+  }
+  return { criteria, level, pour };
+}
+function mapSeverity(impact) {
+  switch (impact) {
+    case "critical":
+      return "critical";
+    case "serious":
+      return "serious";
+    case "moderate":
+      return "moderate";
+    case "minor":
+      return "minor";
+    default:
+      return "moderate";
+  }
+}
+function pourFromCriterion(criterion) {
+  const principle = criterion.charAt(0);
+  switch (principle) {
+    case "1":
+      return "perceivable";
+    case "2":
+      return "operable";
+    case "3":
+      return "understandable";
+    case "4":
+      return "robust";
+    default:
+      return null;
+  }
+}
+var AxeScanner = class {
+  name = "axe-core";
+  version = "";
+  coveredCriteria = [
+    "1.1.1",
+    "1.2.1",
+    "1.2.2",
+    "1.3.1",
+    "1.3.4",
+    "1.3.5",
+    "1.4.1",
+    "1.4.2",
+    "1.4.3",
+    "1.4.4",
+    "1.4.12",
+    "2.1.1",
+    "2.1.3",
+    "2.2.1",
+    "2.2.2",
+    "2.4.1",
+    "2.4.2",
+    "2.4.4",
+    "2.5.3",
+    "2.5.8",
+    "3.1.1",
+    "3.1.2",
+    "3.3.2",
+    "4.1.2"
+  ];
+  async isAvailable() {
+    try {
+      await import("axe-core");
+      await import("jsdom");
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async scan(context) {
+    const axeModule = await import("axe-core");
+    const axe = axeModule.default ?? axeModule;
+    const { JSDOM } = await import("jsdom");
+    this.version = axe.version ?? "unknown";
+    const htmlFiles = context.files.filter(
+      (f) => f.type === "html" || f.type === "jsx" || f.type === "tsx" || f.type === "vue"
+    );
+    const scannableFiles = htmlFiles.filter((f) => {
+      if (f.type === "html") return true;
+      return f.content.includes("<") && (f.content.includes("return") || f.content.includes("<template"));
+    });
+    const allIssues = [];
+    const runTags = buildRunTags(context.options.wcag_level);
+    for (const file of scannableFiles) {
+      try {
+        const html = extractHtml(file.content, file.type);
+        if (!html.trim()) continue;
+        const issues = await this.scanHtml(axe, JSDOM, html, file.path, runTags);
+        allIssues.push(...issues);
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        console.warn(`  [axe-core] Skipped ${file.path}: ${msg.slice(0, 80)}`);
+      }
+    }
+    return allIssues;
+  }
+  async scanHtml(axe, JSDOMClass, html, filePath, runTags) {
+    const fullHtml = html.includes("<html") ? html : `
+      <!DOCTYPE html>
+      <html lang="en">
+        <head><title>Scan</title></head>
+        <body>${html}</body>
+      </html>
+    `;
+    const originalConsoleError = console.error;
+    console.error = (...args) => {
+      const msg = String(args[0] ?? "");
+      if (msg.includes("Not implemented") || msg.includes("HTMLCanvasElement")) return;
+      originalConsoleError(...args);
+    };
+    const dom = new JSDOMClass(fullHtml, {
+      runScripts: "outside-only",
+      pretendToBeVisual: true,
+      virtualConsole: new (await import("jsdom")).VirtualConsole()
+    });
+    try {
+      const document = dom.window.document;
+      axe.configure({
+        rules: [
+          { id: "color-contrast", enabled: false },
+          { id: "color-contrast-enhanced", enabled: false }
+        ]
+      });
+      const results = await axe.run(document.documentElement, {
+        runOnly: {
+          type: "tag",
+          values: runTags
+        },
+        resultTypes: ["violations"]
+      });
+      const issues = [];
+      for (const violation of results.violations) {
+        const { criteria, level, pour } = parseWcagTags(violation.tags);
+        const derivedPour = pour ?? (criteria[0] ? pourFromCriterion(criteria[0]) : null);
+        for (const node of violation.nodes) {
+          issues.push({
+            scanner: "axe-core",
+            scanner_rule_id: violation.id,
+            wcag_criteria: criteria,
+            wcag_level: level,
+            pour: derivedPour,
+            file_path: filePath,
+            line: null,
+            // axe-core doesn't provide line numbers on static HTML
+            column: null,
+            html_snippet: node.html?.slice(0, 200) ?? null,
+            severity: mapSeverity(violation.impact),
+            message: `${violation.help} (${violation.id})`,
+            help_url: violation.helpUrl ?? null,
+            suggestion: node.failureSummary ?? null
+          });
+        }
+      }
+      return issues;
+    } finally {
+      dom.window.close();
+      console.error = originalConsoleError;
+    }
+  }
+};
+function buildRunTags(level) {
+  const tags = ["wcag2a", "wcag21a", "wcag22a"];
+  if (level === "AA" || level === "AAA") {
+    tags.push("wcag2aa", "wcag21aa", "wcag22aa");
+  }
+  if (level === "AAA") {
+    tags.push("wcag2aaa", "wcag21aaa", "wcag22aaa");
+  }
+  tags.push("best-practice");
+  return tags;
+}
+function extractHtml(content, type) {
+  if (type === "html") return content;
+  if (type === "vue") {
+    const templateMatch = content.match(/<template[^>]*>([\s\S]*?)<\/template>/);
+    return templateMatch?.[1] ?? "";
+  }
+  if (type === "jsx" || type === "tsx") {
+    const returnMatch = content.match(/return\s*\(\s*([\s\S]*?)\s*\)\s*[;\n}]/);
+    if (returnMatch) return returnMatch[1];
+    const singleReturn = content.match(/return\s+(<[\s\S]*?>[\s\S]*?<\/[\s\S]*?>)/);
+    return singleReturn?.[1] ?? "";
+  }
+  return content;
+}
+
+// src/scanners/eslint-jsx-a11y-scanner.ts
+var RULE_WCAG_MAP = {
+  "jsx-a11y/alt-text": { criteria: ["1.1.1"], pour: "perceivable" },
+  "jsx-a11y/anchor-has-content": { criteria: ["2.4.4", "4.1.2"], pour: "operable" },
+  "jsx-a11y/anchor-is-valid": { criteria: ["2.4.4"], pour: "operable" },
+  "jsx-a11y/aria-activedescendant-has-tabindex": { criteria: ["4.1.2"], pour: "robust" },
+  "jsx-a11y/aria-props": { criteria: ["4.1.2"], pour: "robust" },
+  "jsx-a11y/aria-proptypes": { criteria: ["4.1.2"], pour: "robust" },
+  "jsx-a11y/aria-role": { criteria: ["4.1.2"], pour: "robust" },
+  "jsx-a11y/aria-unsupported-elements": { criteria: ["4.1.2"], pour: "robust" },
+  "jsx-a11y/autocomplete-valid": { criteria: ["1.3.5"], pour: "perceivable" },
+  "jsx-a11y/click-events-have-key-events": { criteria: ["2.1.1"], pour: "operable" },
+  "jsx-a11y/heading-has-content": { criteria: ["2.4.6"], pour: "operable" },
+  "jsx-a11y/html-has-lang": { criteria: ["3.1.1"], pour: "understandable" },
+  "jsx-a11y/iframe-has-title": { criteria: ["2.4.1", "4.1.2"], pour: "operable" },
+  "jsx-a11y/img-redundant-alt": { criteria: ["1.1.1"], pour: "perceivable" },
+  "jsx-a11y/interactive-supports-focus": { criteria: ["2.1.1", "2.4.7"], pour: "operable" },
+  "jsx-a11y/label-has-associated-control": { criteria: ["1.3.1", "3.3.2"], pour: "perceivable" },
+  "jsx-a11y/lang": { criteria: ["3.1.2"], pour: "understandable" },
+  "jsx-a11y/media-has-caption": { criteria: ["1.2.2", "1.2.3"], pour: "perceivable" },
+  "jsx-a11y/mouse-events-have-key-events": { criteria: ["2.1.1"], pour: "operable" },
+  "jsx-a11y/no-access-key": { criteria: ["2.1.1"], pour: "operable" },
+  "jsx-a11y/no-autofocus": { criteria: ["2.4.3"], pour: "operable" },
+  "jsx-a11y/no-distracting-elements": { criteria: ["2.3.1"], pour: "operable" },
+  "jsx-a11y/no-interactive-element-to-noninteractive-role": { criteria: ["4.1.2"], pour: "robust" },
+  "jsx-a11y/no-noninteractive-element-interactions": { criteria: ["2.1.1"], pour: "operable" },
+  "jsx-a11y/no-noninteractive-element-to-interactive-role": { criteria: ["4.1.2"], pour: "robust" },
+  "jsx-a11y/no-noninteractive-tabindex": { criteria: ["2.4.3"], pour: "operable" },
+  "jsx-a11y/no-redundant-roles": { criteria: ["4.1.2"], pour: "robust" },
+  "jsx-a11y/no-static-element-interactions": { criteria: ["2.1.1"], pour: "operable" },
+  "jsx-a11y/prefer-tag-over-role": { criteria: ["4.1.2"], pour: "robust" },
+  "jsx-a11y/role-has-required-aria-props": { criteria: ["4.1.2"], pour: "robust" },
+  "jsx-a11y/role-supports-aria-props": { criteria: ["4.1.2"], pour: "robust" },
+  "jsx-a11y/scope": { criteria: ["1.3.1"], pour: "perceivable" },
+  "jsx-a11y/tabindex-no-positive": { criteria: ["2.4.3"], pour: "operable" }
+};
+function mapSeverity2(eslintSeverity) {
+  switch (eslintSeverity) {
+    case 2:
+      return "serious";
+    // error
+    case 1:
+      return "moderate";
+    // warning
+    default:
+      return "minor";
+  }
+}
+var AA_CRITERIA = /* @__PURE__ */ new Set(["1.3.5", "2.4.6", "2.4.7", "3.1.2", "3.3.2"]);
+var EslintJsxA11yScanner = class {
+  name = "eslint-jsx-a11y";
+  version = "";
+  coveredCriteria = [
+    "1.1.1",
+    "1.2.2",
+    "1.2.3",
+    "1.3.1",
+    "1.3.5",
+    "2.1.1",
+    "2.3.1",
+    "2.4.1",
+    "2.4.3",
+    "2.4.4",
+    "2.4.6",
+    "2.4.7",
+    "3.1.1",
+    "3.1.2",
+    "3.3.2",
+    "4.1.2"
+  ];
+  async isAvailable() {
+    try {
+      await import("eslint");
+      await import("eslint-plugin-jsx-a11y");
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async scan(context) {
+    const { ESLint } = await import("eslint");
+    const jsxA11yModule = await import("eslint-plugin-jsx-a11y");
+    const jsxA11y = jsxA11yModule.default ?? jsxA11yModule;
+    try {
+      const { createRequire } = await import("module");
+      const require2 = createRequire(import.meta.url);
+      const pluginPkg = require2("eslint-plugin-jsx-a11y/package.json");
+      this.version = pluginPkg.version ?? "unknown";
+    } catch {
+      this.version = jsxA11y?.meta?.version ?? "unknown";
+    }
+    const jsxFiles = context.files.filter((f) => f.type === "jsx" || f.type === "tsx");
+    if (jsxFiles.length === 0) return [];
+    const tsParser = await import("@typescript-eslint/parser");
+    const eslint = new ESLint({
+      overrideConfigFile: true,
+      overrideConfig: [
+        {
+          files: ["**/*.{jsx,tsx,js,ts}"],
+          plugins: {
+            "jsx-a11y": jsxA11y
+          },
+          rules: Object.fromEntries(
+            Object.keys(RULE_WCAG_MAP).map((rule) => [rule, "error"])
+          ),
+          languageOptions: {
+            parser: tsParser.default ?? tsParser,
+            parserOptions: {
+              ecmaFeatures: { jsx: true }
+            }
+          }
+        }
+      ],
+      cwd: context.root_path
+    });
+    const allIssues = [];
+    const filePaths = jsxFiles.map((f) => f.absolute_path);
+    try {
+      const results = await eslint.lintFiles(filePaths);
+      for (const result of results) {
+        const relativePath = jsxFiles.find(
+          (f) => f.absolute_path === result.filePath
+        )?.path ?? result.filePath;
+        for (const msg of result.messages) {
+          if (!msg.ruleId || !msg.ruleId.startsWith("jsx-a11y/")) continue;
+          const wcagMapping = RULE_WCAG_MAP[msg.ruleId];
+          const criteria = wcagMapping?.criteria ?? [];
+          const pour = wcagMapping?.pour ?? null;
+          const aCriteria = criteria.filter((c) => !AA_CRITERIA.has(c));
+          const aaCriteria = criteria.filter((c) => AA_CRITERIA.has(c));
+          const groups = [];
+          if (aCriteria.length > 0) groups.push({ criteria: aCriteria, level: "A" });
+          if (aaCriteria.length > 0) groups.push({ criteria: aaCriteria, level: "AA" });
+          if (groups.length === 0) groups.push({ criteria, level: "A" });
+          for (const group of groups) {
+            allIssues.push({
+              scanner: "eslint-jsx-a11y",
+              scanner_rule_id: msg.ruleId,
+              wcag_criteria: group.criteria,
+              wcag_level: group.level,
+              pour,
+              file_path: relativePath,
+              line: msg.line ?? null,
+              column: msg.column ?? null,
+              html_snippet: null,
+              severity: mapSeverity2(msg.severity),
+              message: `${msg.message} (${msg.ruleId})`,
+              help_url: `https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/blob/main/docs/rules/${msg.ruleId.replace("jsx-a11y/", "")}.md`,
+              suggestion: msg.fix ? "Auto-fixable" : null
+            });
+          }
+        }
+      }
+    } catch (error) {
+      const errMsg = error instanceof Error ? error.message : String(error);
+      console.warn(`  [eslint-jsx-a11y] Scan failed: ${errMsg.slice(0, 120)}`);
+    }
+    return allIssues;
+  }
+};
+
+// src/scanners/index.ts
+var ALL_SCANNERS = [
+  new AxeScanner(),
+  new EslintJsxA11yScanner()
+];
+async function getAvailableScanners() {
+  const checks = await Promise.all(
+    ALL_SCANNERS.map(async (scanner) => ({
+      scanner,
+      available: await scanner.isAvailable()
+    }))
+  );
+  return checks.filter((c) => c.available).map((c) => c.scanner);
+}
+
+// src/scan.ts
+async function runScan(options = {}) {
+  const rootPath = resolve2(options.path ?? process.cwd());
+  const startTime = Date.now();
+  const scanOptions = {
+    wcag_level: options.level ?? "AA",
+    include_patterns: options.include ?? [],
+    exclude_patterns: options.exclude ?? []
+  };
+  const files = await discoverFiles(rootPath, scanOptions);
+  if (files.length === 0) {
+    return computeScanResult([], 0, [], Date.now() - startTime, scanOptions.wcag_level);
+  }
+  const scanners = await getAvailableScanners();
+  if (scanners.length === 0) {
+    console.warn("No scanners available. Install axe-core and jsdom for HTML scanning.");
+    return computeScanResult([], files.length, [], Date.now() - startTime, scanOptions.wcag_level);
+  }
+  const scanContext = { root_path: rootPath, files, options: scanOptions };
+  const scannerResults = await Promise.allSettled(
+    scanners.map(async (scanner) => {
+      const issues = await scanner.scan(scanContext);
+      return {
+        scanner,
+        issues
+      };
+    })
+  );
+  const allIssues = [];
+  const scannersUsed = [];
+  for (const result of scannerResults) {
+    if (result.status === "fulfilled") {
+      const { scanner, issues } = result.value;
+      allIssues.push(...issues);
+      scannersUsed.push({
+        name: scanner.name,
+        version: scanner.version,
+        rules_count: 0,
+        // Could be enhanced per scanner
+        issues_found: issues.length
+      });
+    } else {
+      const err = result.reason instanceof Error ? result.reason.message : String(result.reason);
+      console.warn(`  [scanner] Failed: ${err.slice(0, 120)}`);
+    }
+  }
+  const deduped = deduplicateIssues(allIssues);
+  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);
+}
+function deduplicateIssues(issues) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const issue of issues) {
+    const sortedCriteria = [...issue.wcag_criteria].sort().join(",");
+    const location = issue.line != null ? `L${issue.line}:${issue.column ?? 0}` : issue.html_snippet?.slice(0, 80) ?? "no-loc";
+    const key = `${issue.file_path}|${sortedCriteria}|${location}`;
+    if (!seen.has(key)) {
+      seen.add(key);
+      result.push(issue);
+    }
+  }
+  return result;
+}
+
+export {
+  computeScanResult,
+  runScan
+};

package/dist/cli.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli.js

@@ -0,0 +1,305 @@
+#!/usr/bin/env node
+import {
+  runScan
+} from "./chunk-UA3BFAGG.js";
+
+// src/cli.ts
+import { Command } from "commander";
+
+// src/output/terminal.ts
+var WCAG_A_CRITERIA = /* @__PURE__ */ new Set([
+  "1.1.1",
+  "1.2.1",
+  "1.2.2",
+  "1.2.3",
+  "1.3.1",
+  "1.3.2",
+  "1.3.3",
+  "1.4.1",
+  "1.4.2",
+  "2.1.1",
+  "2.1.2",
+  "2.1.4",
+  "2.2.1",
+  "2.2.2",
+  "2.3.1",
+  "2.4.1",
+  "2.4.2",
+  "2.4.3",
+  "2.4.4",
+  "2.5.1",
+  "2.5.2",
+  "2.5.3",
+  "2.5.4",
+  "3.1.1",
+  "3.2.1",
+  "3.2.2",
+  "3.2.6",
+  "3.3.1",
+  "3.3.7",
+  "4.1.2"
+]);
+var WCAG_A_TOTAL = 30;
+var BP_HINTS = {
+  "region": "Landmarks help screen reader users navigate page sections",
+  "landmark-main-is-top-level": "Nested landmarks confuse assistive technology",
+  "heading-order": "Skipping heading levels makes content harder to navigate",
+  "landmark-one-main": "Pages should have exactly one main landmark",
+  "landmark-unique": "Duplicate landmarks make navigation ambiguous",
+  "page-has-heading-one": "Pages should start with a top-level heading",
+  "landmark-complementary-is-top-level": "Complementary landmarks should not be nested",
+  "landmark-no-duplicate-banner": "Multiple banner landmarks confuse screen readers",
+  "landmark-no-duplicate-contentinfo": "Multiple contentinfo landmarks confuse screen readers"
+};
+var BOLD = "\x1B[1m";
+var DIM = "\x1B[2m";
+var RESET = "\x1B[0m";
+var RED = "\x1B[31m";
+var YELLOW = "\x1B[33m";
+var GREEN = "\x1B[32m";
+var CYAN = "\x1B[36m";
+var MAGENTA = "\x1B[35m";
+var WHITE = "\x1B[37m";
+var BG_RED = "\x1B[41m";
+var BG_YELLOW = "\x1B[43m";
+var BG_GREEN = "\x1B[42m";
+var BG_CYAN = "\x1B[46m";
+function scoreColor(score) {
+  if (score >= 80) return GREEN;
+  if (score >= 50) return YELLOW;
+  return RED;
+}
+function scoreBg(score) {
+  if (score >= 80) return BG_GREEN;
+  if (score >= 50) return BG_YELLOW;
+  return BG_RED;
+}
+function severityIcon(s) {
+  switch (s) {
+    case "critical":
+      return `${RED}\u25CF${RESET}`;
+    case "serious":
+      return `${YELLOW}\u25CF${RESET}`;
+    case "moderate":
+      return `${CYAN}\u25CF${RESET}`;
+    case "minor":
+      return `${DIM}\u25CF${RESET}`;
+  }
+}
+function conformanceBadge(level) {
+  switch (level) {
+    case "AAA":
+      return `${BG_GREEN}${WHITE} AAA ${RESET}`;
+    case "AA":
+      return `${BG_GREEN}${WHITE} AA ${RESET}`;
+    case "A":
+      return `${BG_CYAN}${WHITE} A ${RESET}`;
+    case "Partial A":
+      return `${BG_YELLOW}${WHITE} ~A ${RESET}`;
+    case "None":
+      return `${BG_RED}${WHITE} \u2014 ${RESET}`;
+    default:
+      return level;
+  }
+}
+function bar(value, width = 20) {
+  if (value === null) return `${DIM}${"\u2591".repeat(width)} n/a${RESET}`;
+  const filled = Math.round(value / 100 * width);
+  const empty = width - filled;
+  const color = scoreColor(value);
+  return `${color}${"\u2588".repeat(filled)}${DIM}${"\u2591".repeat(empty)}${RESET} ${color}${value}${RESET}`;
+}
+function printResult(result) {
+  const { score, conformance_level, pour_scores, summary, scanners_used, duration_ms } = result;
+  console.log();
+  console.log(`${BOLD}  \u25C6 EQUALL \u2014 Accessibility Score${RESET}`);
+  console.log();
+  const color = scoreColor(score);
+  console.log(`  ${scoreBg(score)}${BOLD}${WHITE}  ${score}  ${RESET}  ${conformanceBadge(conformance_level)}  ${DIM}WCAG 2.2${RESET}`);
+  console.log();
+  console.log(`  ${BOLD}POUR Breakdown${RESET}`);
+  console.log(`  ${MAGENTA}P${RESET} Perceivable    ${bar(pour_scores.perceivable)}`);
+  console.log(`  ${MAGENTA}O${RESET} Operable       ${bar(pour_scores.operable)}`);
+  console.log(`  ${MAGENTA}U${RESET} Understandable ${bar(pour_scores.understandable)}`);
+  console.log(`  ${MAGENTA}R${RESET} Robust         ${bar(pour_scores.robust)}`);
+  console.log();
+  console.log(`  ${BOLD}Summary${RESET}`);
+  const wcagIssuesCount = result.issues.filter((i) => i.wcag_criteria.length > 0).length;
+  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 (result.criteria_total > 0) {
+    const covered = result.criteria_covered.length;
+    const total = result.criteria_total;
+    const failedASet = /* @__PURE__ */ new Set();
+    const failedAllSet = /* @__PURE__ */ new Set();
+    for (const issue of result.issues) {
+      for (const c of issue.wcag_criteria) {
+        failedAllSet.add(c);
+        if (WCAG_A_CRITERIA.has(c)) failedASet.add(c);
+      }
+    }
+    const isTargetAA = total > WCAG_A_TOTAL && total <= 57;
+    if (isTargetAA && failedASet.size > 0) {
+      const coveredA = result.criteria_covered.filter((c) => WCAG_A_CRITERIA.has(c)).length;
+      const pctA = Math.round(coveredA / WCAG_A_TOTAL * 100);
+      const pctAA = Math.round(covered / total * 100);
+      const pad = " ".repeat(`  Score ${score}/100  \xB7  `.length);
+      console.log(`  ${BOLD}Score ${score}/100${RESET}  \xB7  ${coveredA}/${WCAG_A_TOTAL} Level A criteria checked (${pctA}%)  \xB7  ${RED}${failedASet.size} failed${RESET}`);
+      console.log(`${pad}${covered}/${total} Level AA criteria checked (${pctAA}%)  \xB7  ${RED}${failedAllSet.size} failed${RESET}`);
+    } else {
+      const levelLabel = total <= WCAG_A_TOTAL ? "Level A" : `Level AA`;
+      const pct = Math.round(covered / total * 100);
+      console.log(`  ${BOLD}Score ${score}/100${RESET}  \xB7  ${covered}/${total} ${levelLabel} criteria checked (${pct}%)  \xB7  ${RED}${failedAllSet.size} failed${RESET}`);
+    }
+  }
+  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);
+  if (wcagIssues.length > 0) {
+    console.log(`  ${BOLD}WCAG Violations${RESET}`);
+    const grouped = groupByCriterion(wcagIssues);
+    const sorted = [...grouped.entries()].sort((a, b) => b[1].weight - a[1].weight).slice(0, 8);
+    for (const [criterion, group] of sorted) {
+      const topSeverity = group.issues[0].severity;
+      console.log(`  ${severityIcon(topSeverity)} ${BOLD}${criterion}${RESET} ${DIM}\u2014 ${group.issues.length} issue${group.issues.length > 1 ? "s" : ""}${RESET}`);
+      for (const issue of group.issues.slice(0, 2)) {
+        const location = issue.line ? `:${issue.line}` : "";
+        console.log(`    ${DIM}${issue.file_path}${location}${RESET}`);
+        console.log(`    ${issue.message}`);
+        if (issue.suggestion) {
+          console.log(`    ${GREEN}\u2192 ${issue.suggestion}${RESET}`);
+        }
+        if (issue.help_url) {
+          console.log(`    ${DIM}\u2197 ${issue.help_url}${RESET}`);
+        }
+      }
+      if (group.issues.length > 2) {
+        console.log(`    ${DIM}... and ${group.issues.length - 2} more${RESET}`);
+      }
+      console.log();
+    }
+  }
+  if (bpIssues.length > 0) {
+    console.log(`  ${BOLD}Best Practices${RESET}`);
+    const grouped = groupByCriterion(bpIssues);
+    const sorted = [...grouped.entries()].sort((a, b) => b[1].weight - a[1].weight);
+    for (const [criterion, group] of sorted) {
+      const topSeverity = group.issues[0].severity;
+      const hint = BP_HINTS[criterion];
+      const hintSuffix = hint ? `  ${DIM}${hint}${RESET}` : "";
+      console.log(`  ${severityIcon(topSeverity)} ${BOLD}${criterion}${RESET} ${DIM}\u2014 ${group.issues.length} issue${group.issues.length > 1 ? "s" : ""}${RESET}${hintSuffix}`);
+    }
+    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();
+}
+function printCoaching(result) {
+  const { summary, criteria_covered, criteria_total } = result;
+  const levelAFailed = [];
+  const levelAAFailed = [];
+  for (const issue of result.issues) {
+    if (issue.wcag_criteria.length === 0) continue;
+    if (issue.wcag_level === "A") {
+      for (const c of issue.wcag_criteria) {
+        if (!levelAFailed.includes(c)) levelAFailed.push(c);
+      }
+    } else if (issue.wcag_level === "AA") {
+      for (const c of issue.wcag_criteria) {
+        if (!levelAAFailed.includes(c)) levelAAFailed.push(c);
+      }
+    }
+  }
+  const remaining = criteria_total - criteria_covered.length;
+  if (levelAFailed.length > 0) {
+    const list = levelAFailed.sort().join(", ");
+    console.log(`  ${YELLOW}\u24D8${RESET} You're failing ${BOLD}${levelAFailed.length} Level A${RESET} criteria (${list}).`);
+    console.log(`    Level A is the legal minimum \u2014 it means all users can access your core content. Fix these first.`);
+  } else if (levelAAFailed.length > 0) {
+    console.log(`  ${GREEN}\u24D8${RESET} ${BOLD}Level A passed!${RESET} You're now failing ${BOLD}${levelAAFailed.length} Level AA${RESET} criteria.`);
+    console.log(`    Level AA is the recommended standard \u2014 it covers usability for assistive tech users (contrast, resize, focus visible).`);
+  } else {
+    console.log(`  ${GREEN}\u24D8${RESET} ${BOLD}All automated checks pass!${RESET} ${remaining} criteria still require manual testing or browser-based scanning.`);
+  }
+  if (remaining > 0) {
+    console.log(`    ${DIM}${remaining} criteria can't be tested automatically \u2014 they need manual review or a real browser.${RESET}`);
+  }
+}
+function groupByCriterion(issues) {
+  const map = /* @__PURE__ */ new Map();
+  const severityWeight = {
+    critical: 100,
+    serious: 50,
+    moderate: 10,
+    minor: 1
+  };
+  for (const issue of issues) {
+    const keys = issue.wcag_criteria.length > 0 ? issue.wcag_criteria : [issue.scanner_rule_id];
+    for (const key of keys) {
+      if (!map.has(key)) {
+        map.set(key, { issues: [], weight: 0 });
+      }
+      const group = map.get(key);
+      group.issues.push(issue);
+      group.weight += severityWeight[issue.severity];
+    }
+  }
+  for (const group of map.values()) {
+    group.issues.sort((a, b) => severityWeight[b.severity] - severityWeight[a.severity]);
+  }
+  return map;
+}
+function printJson(result) {
+  console.log(JSON.stringify(result, null, 2));
+}
+
+// src/cli.ts
+var program = new Command();
+program.name("equall").description("Open-source accessibility scoring \u2014 aggregates axe-core, eslint-plugin-jsx-a11y, and more.").version("0.1.0");
+program.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) => {
+  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 { resolve, basename } = await import("path");
+  const displayName = basename(resolve(path));
+  const ora = (await import("ora")).default;
+  const spinner = opts.json ? null : ora({ text: `Scanning ${displayName}`, indent: 2 }).start();
+  try {
+    const result = await runScan({
+      path,
+      level,
+      include: opts.include,
+      exclude: opts.exclude
+    });
+    spinner?.stop();
+    if (result.summary.files_scanned === 0) {
+      if (opts.json) {
+        printJson(result);
+      } else {
+        console.log("\n  No scannable files found (.html, .jsx, .tsx, .vue, .svelte, .astro)");
+        console.log("  Check the path or use --include to specify patterns.\n");
+      }
+      process.exit(0);
+    }
+    if (opts.json) {
+      printJson(result);
+    } else {
+      printResult(result);
+    }
+    if (result.score < 50) process.exit(1);
+  } catch (error) {
+    spinner?.stop();
+    const msg = error instanceof Error ? error.message : String(error);
+    console.error(`
+  Error: ${msg}
+`);
+    process.exit(2);
+  }
+});
+program.parse();

package/dist/index.d.ts

@@ -0,0 +1,87 @@
+interface GladosIssue {
+    scanner: string;
+    scanner_rule_id: string;
+    wcag_criteria: string[];
+    wcag_level: WcagLevel | null;
+    pour: PourPrinciple | null;
+    file_path: string;
+    line: number | null;
+    column: number | null;
+    html_snippet: string | null;
+    severity: Severity;
+    message: string;
+    help_url: string | null;
+    suggestion: string | null;
+}
+type WcagLevel = 'A' | 'AA' | 'AAA';
+type PourPrinciple = 'perceivable' | 'operable' | 'understandable' | 'robust';
+type Severity = 'critical' | 'serious' | 'moderate' | 'minor';
+interface ScannerAdapter {
+    name: string;
+    version: string;
+    coveredCriteria: string[];
+    scan(context: ScanContext): Promise<GladosIssue[]>;
+    isAvailable(): Promise<boolean>;
+}
+interface ScanContext {
+    root_path: string;
+    files: FileEntry[];
+    options: ScanOptions;
+}
+interface FileEntry {
+    path: string;
+    absolute_path: string;
+    content: string;
+    type: FileType;
+}
+type FileType = 'html' | 'jsx' | 'tsx' | 'vue' | 'svelte' | 'astro' | 'other';
+interface ScanOptions {
+    wcag_level: WcagLevel;
+    include_patterns: string[];
+    exclude_patterns: string[];
+}
+interface ScanResult {
+    score: number;
+    conformance_level: ConformanceLevel;
+    pour_scores: PourScores;
+    issues: GladosIssue[];
+    summary: ScanSummary;
+    scanners_used: ScannerInfo[];
+    criteria_covered: string[];
+    criteria_total: number;
+    scanned_at: string;
+    duration_ms: number;
+}
+interface PourScores {
+    perceivable: number | null;
+    operable: number | null;
+    understandable: number | null;
+    robust: number | null;
+}
+type ConformanceLevel = 'AAA' | 'AA' | 'A' | 'Partial A' | 'None';
+interface ScanSummary {
+    files_scanned: number;
+    total_issues: number;
+    by_severity: Record<Severity, number>;
+    by_scanner: Record<string, number>;
+    criteria_tested: string[];
+    criteria_failed: string[];
+}
+interface ScannerInfo {
+    name: string;
+    version: string;
+    rules_count: number;
+    issues_found: number;
+}
+
+interface RunScanOptions {
+    path?: string;
+    level?: WcagLevel;
+    include?: string[];
+    exclude?: string[];
+}
+declare function runScan(options?: RunScanOptions): Promise<ScanResult>;
+
+declare function computeScanResult(issues: GladosIssue[], filesScanned: number, scannersUsed: ScannerInfo[], durationMs: number, targetLevel?: WcagLevel, criteriaCovered?: string[], criteriaTotal?: number): ScanResult;
+
+export { type ConformanceLevel, type GladosIssue, type PourPrinciple, type PourScores, type RunScanOptions, type ScanContext, type ScanOptions, type ScanResult, type ScannerAdapter, type Severity, type WcagLevel, computeScanResult, runScan };

package/dist/index.js

@@ -0,0 +1,8 @@
+import {
+  computeScanResult,
+  runScan
+} from "./chunk-UA3BFAGG.js";
+export {
+  computeScanResult,
+  runScan
+};

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "equall-cli",
+  "version": "0.1.0",
+  "description": "Open-source accessibility scoring CLI — aggregates axe-core, eslint-plugin-jsx-a11y, and more into a unified score.",
+  "keywords": [
+    "accessibility",
+    "a11y",
+    "wcag",
+    "scoring",
+    "cli",
+    "axe-core",
+    "eslint",
+    "audit"
+  ],
+  "license": "MIT",
+  "author": "Bureau61 <kevin@bureau61.com>",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/bureau61/equall"
+  },
+  "type": "module",
+  "bin": {
+    "equall": "./dist/cli.js"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsup src/cli.ts src/index.ts --format esm --dts --clean",
+    "dev": "tsup src/cli.ts src/index.ts --format esm --dts --watch",
+    "scan": "tsx src/cli.ts",
+    "lint": "eslint src/",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "@typescript-eslint/parser": "^8.57.2",
+    "axe-core": "^4.10.0",
+    "commander": "^12.1.0",
+    "eslint": "^9.0.0",
+    "eslint-plugin-jsx-a11y": "^6.10.0",
+    "globby": "^14.0.0",
+    "jsdom": "^25.0.0",
+    "ora": "^9.3.0"
+  },
+  "devDependencies": {
+    "@types/jsdom": "^21.1.7",
+    "@types/node": "^22.0.0",
+    "tsup": "^8.0.0",
+    "tsx": "^4.0.0",
+    "typescript": "^5.9.3",
+    "vitest": "^2.0.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}