testaro 71.1.0 → 72.1.1

package/.claude/settings.local.json

@@ -6,5 +6,6 @@
       "Bash(git commit -m ' *)",
       "Bash(git push *)"
     ]
-  }
+  },
+  "outputStyle": "Explanatory"
 }

package/CLAUDE.md

@@ -59,6 +59,8 @@ Two implementation patterns exist:
 
 ### Validation
 
+Validation is currently broken. A reconsideration of its architecture is anticipated, but in the meantime the next paragraph describes its current inoperative design.
+
 Validation tests live in `validation/tests/jobs/` (jobs with `expect` arrays) and `validation/tests/targets/` (static HTML pages served locally as test targets). Running `npm test <ruleID>` executes `validation/executors/test.js` → `validation/validateTest.js`, which runs the job and compares `result` fields against `expect` clauses.
 
 ### Tool XPath strategy
@@ -87,6 +89,8 @@ Key variables:
 
 ESLint (`eslintrc.json`): 2-space indent, single quotes, semicolons, Stroustrup brace style (`else`/`catch` on a new line after `}`), `no-use-before-define`. The `htmlcs/HTMLCS.js` file uses a separate, looser ESLint config and must not be reformatted.
 
+Long comments are not broken into multiple lines per paragraph.
+
 ## Adding a new Testaro rule
 
 1. Add an entry to `allRules` in `tests/testaro.js`.
@@ -97,7 +101,7 @@ ESLint (`eslintrc.json`): 2-space indent, single quotes, semicolons, Stroustrup
 ## Key files
 
 | File | Purpose |
-|------|---------|
+| ---- | ------- |
 | `run.js` | `doJob()` — the main entry point |
 | `call.js` | CLI wrapper for `run`, `dirWatch`, `netWatch` |
 | `procs/doActs.js` | Iterates acts; forks child for each tool |

package/README.md

@@ -502,7 +502,9 @@ The `testaro` tool (like the `ibm` tool) has a `withItems` property. If you set
 
 Unlike any other tool, the `testaro` tool requires a `stopOnFail` property, which specifies whether a failure to conform to any rule (i.e. any value of `totals` other than `[0, 0, 0, 0]`) should terminate the execution of tests for the remaining rules.
 
-Tests of the `testaro` tests (i.e. _validation_) can be performed as documented in the `VALIDATION.md` file.
+Tests of the `testaro` tests (i.e. _validation_) could previously be performed as documented in the `VALIDATION.md` file. This functionality has broken and its redesign is planned.
+
+One Testaro rule, `allCaps`, is currently being tested for in part with the assistance of the Claude Haiku artificial intelligence (AI) model. To obtain that assistance, you need an Anthropic API key, and its value must be assigned to the `ANTHROPIC_API_KEY` environment variable in the `.env` file. If no valid API key is set there, the rule will be tested for, but without AI assistance.
 
 ### WAVE
 

package/UPGRADES.md

@@ -809,7 +809,7 @@ You're absolutely right about `nuVal`'s limitations. Since it requires publicly
 
 1. **`htmlcs`** - Pure JavaScript, no external dependencies, works on any HTML
 2. **`wave`** - Also API-based, so same limitations as `nuVal`
-4. **`axe`** - Self-contained, works on any page, excellent for establishing patterns
+3. **`axe`** - Self-contained, works on any page, excellent for establishing patterns
 
 **I recommend starting with `axe`** because:
 

package/memory/MEMORY.md

@@ -0,0 +1,3 @@
+# Memory Index
+
+- [Validation system paused](project_validation_pause.md) — new validation tests on hold pending redesign of broken validation architecture

package/memory/project_validation_pause.md

@@ -0,0 +1,10 @@
+---
+name: Validation system paused
+description: All new validation test work is on hold pending a redesign of the currently broken validation architecture
+type: project
+---
+
+New validation tests and updates to existing validation tests are paused. The validation system is currently broken and a redesign is anticipated. Do not create or modify files in validation/tests/ until the user indicates the redesign is underway.
+
+**Why:** The validation architecture is broken and being reconsidered.
+**How to apply:** Skip validation file creation/updates when adding or modifying Testaro rules until further notice.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "testaro",
-  "version": "71.1.0",
+  "version": "72.1.1",
   "description": "Run 1000 web accessibility tests from 11 tools and get a standardized report",
   "main": "index.js",
   "scripts": {

package/testaro/allCaps.js

@@ -10,31 +10,180 @@
 /*
   allCaps
   Related to Tenon rule 153.
-  This test reports elements with native upper-case text at least 8 characters long. Blocks of upper-case text are difficult to read.
+  This test reports elements whose text contains upper-case strings that are not intrinsically upper-case (i.e., not acronyms, abbreviations, or terms whose standard form is all-capitals). Claude Haiku classifies qualifying catalog entries and estimates the probability of a rule violation. If the AI call fails, the test falls back to a rule-based check for 8+ consecutive upper-case letters.
 */
 
 // IMPORTS
 
-const {doTest} = require('../procs/testaro');
+const https = require('https');
+
+// PARAMETERS
+
+const MIN_CONFIDENCE = 0.8;
+const MAX_MARGIN = 100;
+const MAX_TOTAL = 2000;
+const MAX_QUALIFYING = 100;
+
+// CONSTANTS
+
+const ruleID = 'allCaps';
+const whats = 'Elements have all-capital text';
 
 // FUNCTIONS
 
-// Runs the test and returns the result.
-exports.reporter = async (page, catalog, withItems) => {
-  const getBadWhat = element => {
-    // Get the child text nodes of the element.
-    const childTextNodes = Array.from(element.childNodes).filter(
-      node => node.nodeType === Node.TEXT_NODE
-    );
-    // If any of them contains 8 or more consecutive capital letters:
-    if (childTextNodes.some(node => /[A-Z]{8,}/.test(node.nodeValue))) {
-      // Return a violation description.
-      return 'Element contains all-capital text';
+// Returns text limited to MAX_MARGIN characters before the first and after the last uppercase match, capped at MAX_TOTAL characters.
+const getContext = text => {
+  const matches = [...text.matchAll(/\p{Lu}{2,}/gu)];
+  const first = matches[0];
+  const last = matches[matches.length - 1];
+  const start = Math.max(0, first.index - MAX_MARGIN);
+  const end = Math.min(text.length, last.index + last[0].length + MAX_MARGIN);
+  return text.slice(start, end).slice(0, MAX_TOTAL);
+};
+
+// Returns violations using the rule-based fallback (8+ consecutive uppercase letters).
+const getRuleBasedViolations = catalog =>
+  Object.entries(catalog)
+    .filter(([, entry]) => entry.text && /\p{Lu}{8,}/u.test(entry.text))
+    .map(([index]) => ({
+      catalogIndex: index,
+      what: '[No AI available] Element contains all-capital text'
+    }));
+
+// Sends qualifying entries to Claude Haiku and returns confidence scores.
+const classifyWithAI = entries => new Promise((resolve, reject) => {
+  const apiKey = process.env.ANTHROPIC_API_KEY;
+  if (!apiKey) {
+    reject(new Error('ANTHROPIC_API_KEY not set'));
+    return;
+  }
+  const prompt =
+    'Classify HTML elements for an accessibility rule. All-capital text violates the rule UNLESS it is an acronym, abbreviation, or term whose standard form is all-capitals (NASA, WHO, etc.).\n\n'
+    + 'For each element, give a confidence score (0.0–1.0, rounded to one decimal place) for the probability that the element VIOLATES the rule (its all-caps text is NOT intrinsically all-caps).\n\n'
+    + 'Respond with ONLY a JSON array. Each element: {"index": <number>, "confidence": <number>}\n\n'
+    + 'Elements:\n'
+    + JSON.stringify(entries);
+  const payload = JSON.stringify({
+    model: 'claude-haiku-4-5-20251001',
+    max_tokens: 2048,
+    messages: [{role: 'user', content: prompt}]
+  });
+  const options = {
+    hostname: 'api.anthropic.com',
+    path: '/v1/messages',
+    method: 'POST',
+    headers: {
+      'x-api-key': apiKey,
+      'anthropic-version': '2023-06-01',
+      'content-type': 'application/json',
+      'content-length': Buffer.byteLength(payload)
     }
   };
-  const selector = 'body, body *:not(style, script, svg)';
-  const whats = 'Elements have all-capital text';
-  return await doTest(
-    page, catalog, withItems, 'allCaps', selector, whats, 0, getBadWhat.toString()
-  );
+  const req = https.request(options, res => {
+    let body = '';
+    res.on('data', chunk => { body += chunk; });
+    res.on('end', () => {
+      try {
+        const parsed = JSON.parse(body);
+        if (parsed.error) {
+          reject(new Error(parsed.error.message));
+          return;
+        }
+        const text = parsed.content[0].text;
+        resolve(
+          [...text.matchAll(/\{"index":\s*\d+,\s*"confidence":\s*[01]\.\d{1,2}\}/g)]
+          .map(m => {
+            const {index, confidence} = JSON.parse(m[0]);
+            return {index, confidence: Math.round(confidence * 10) / 10};
+          })
+        );
+      }
+      catch(error) {
+        reject(new Error(`Haiku response error: ${error.message}`));
+      }
+    });
+  });
+  req.on('error', reject);
+  req.setTimeout(20000, () => req.destroy(new Error('Haiku API timeout')));
+  req.write(payload);
+  req.end();
+});
+
+// Runs the test and returns the result.
+exports.reporter = async (_, catalog, withItems) => {
+  const data = {};
+  const totals = [0, 0, 0, 0];
+  const standardInstances = [];
+  // Get data on the catalog entries whose text values contain 2+ consecutive capital letters.
+  const qualifying = Object.entries(catalog)
+  .filter(([, entry]) => entry.text && /\p{Lu}{2,}/u.test(entry.text))
+  .map(([index, entry]) => ({
+    index: Number(index),
+    tagName: entry.tagName,
+    text: getContext(entry.text)
+  }));
+  // If there are none:
+  if (!qualifying.length) {
+    // Report this.
+    return {data, totals, standardInstances};
+  }
+  // Sort them, with unbiased (Fisher–Yates) randomization.
+  const sample = qualifying.slice();
+  for (let i = sample.length - 1; i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    [sample[i], sample[j]] = [sample[j], sample[i]];
+  }
+  // If their count exceeds the limit on AI assistance:
+  if (sample.length > MAX_QUALIFYING) {
+    // Truncate them.
+    sample.length = MAX_QUALIFYING;
+  }
+  let violations;
+  try {
+    // Get AI estimates of the probabilities of their violating the rule.
+    const classifications = await classifyWithAI(sample);
+    // Treat the entries with above-minimum violation confidence levels as violations.
+    violations = classifications
+    .filter(({confidence}) => confidence >= MIN_CONFIDENCE)
+    .map(({index, confidence}) => ({
+      catalogIndex: String(index),
+      what: `Element contains unnecessarily (with confidence ${Math.round(confidence * 100)}%) all-capital text`
+    }));
+    const evaluated = classifications.length;
+    const leftOut = qualifying.length - evaluated;
+    // If any entries were truncated out and any AI confidence levels were above-minimum:
+    if (leftOut > 0 && evaluated > 0) {
+      // Add data about the estimated violation rate among those entries.
+      data.leftOut = {
+        count: leftOut,
+        estimatedViolations: Math.round((violations.length / evaluated) * leftOut)
+      };
+    }
+  }
+  catch(error) {
+    data.aiError = error.message;
+    violations = getRuleBasedViolations(catalog);
+  }
+  const estimatedLeftOut = data.leftOut?.estimatedViolations ?? 0;
+  // Add the estimated violation count to the totals.
+  totals[0] = violations.length + estimatedLeftOut;
+  // If itemization is required:
+  if (withItems) {
+    // For each entry deemed a violation:
+    for (const {catalogIndex, what} of violations) {
+      // Add an instance to the standard instances.
+      standardInstances.push({ruleID, what, ordinalSeverity: 0, count: 1, catalogIndex});
+    }
+    // If any entries were truncated:
+    if (estimatedLeftOut) {
+      // Add a summary instance for them.
+      standardInstances.push({ruleID, what: whats, ordinalSeverity: 0, count: estimatedLeftOut});
+    }
+  }
+  // Otherwise, i.e. if itemization is not required, and if any violations exist:
+  else if (totals[0]) {
+    // Add a summary instance for them.
+    standardInstances.push({ruleID, what: whats, ordinalSeverity: 0, count: totals[0]});
+  }
+  return {data, totals, standardInstances};
 };

package/testaro/lineHeight.js

@@ -38,6 +38,20 @@ exports.reporter = async (page, catalog, withItems) => {
       const isBad = lineHeightNum < 1.495 * fontSizeNum;
       // If it does:
       if (isBad) {
+        const parent = element.parentElement;
+        // If the element has a parent:
+        if (parent) {
+          // Get the style properties of the parent.
+          const parentStyleDec = window.getComputedStyle(parent);
+          const {fontSize: parentFontSize, lineHeight: parentLineHeight} = parentStyleDec;
+          const parentFontSizeNum = Number.parseFloat(parentFontSize);
+          const parentLineHeightNum = Number.parseFloat(parentLineHeight);
+          // If the parent also violates the rule:
+          if (parentLineHeightNum < 1.495 * parentFontSizeNum) {
+            // Do not report a violation, because the line height may be inherited.
+            return null;
+          }
+        }
         const whatFontSize = `font size (${fontSizeNum.toFixed(1)}px)`;
         const whatLineHeight = `line height (${lineHeightNum.toFixed(1)}px)`;
         // Return a violation description.

package/testaro/miniText.js

@@ -40,6 +40,17 @@ exports.reporter = async (page, catalog, withItems) => {
         const fontSize = Number.parseFloat(fontSizeString);
         // If its font size is smaller than 11 pixels:
         if (fontSize < 11) {
+          const parent = element.parentElement;
+          // If the element has a parent:
+          if (parent) {
+            const parentStyleDec = window.getComputedStyle(parent);
+            const parentFontSize = Number.parseFloat(parentStyleDec.fontSize);
+            // If the parent also has a font size smaller than 11 pixels:
+            if (parentFontSize < 11) {
+              // Do not report a violation, because the font size may be inherited.
+              return null;
+            }
+          }
           // Return a violation description.
           return `Element is visible but its font size is ${fontSize}px, smaller than 11px`;
         }

package/tests/testaro.js

@@ -41,10 +41,10 @@ const allRules = [
   },
   {
     id: 'allCaps',
-    what: 'leaf elements with entirely upper-case text longer than 7 characters',
+    what: 'elements with unnecessarily all-capital text substrings',
     contaminates: false,
     needsAccessibleName: false,
-    timeOut: 5,
+    timeOut: 30,
     defaultOn: true
   },
   {

package/pw-aslint-claude.js

@@ -1,88 +0,0 @@
-/*
-  © 2025 Jonathan Robert Pool.
-  Licensed under the MIT License. See LICENSE file for details.
-*/
-
-// aslint.config.js
-const { defineConfig } = require('aslint');
-
-module.exports = defineConfig({
-  // Configure ASLint rules
-  rules: {
-    'image-alt': 'error',
-    'button-name': 'error',
-    'html-has-lang': 'error',
-    'link-name': 'error',
-    'page-title': 'error'
-  }
-});
-
-// test.spec.js
-const { test, expect } = require('@playwright/test');
-const { createASLinter } = require('aslint');
-
-test.describe('Accessibility Tests', () => {
-  let linter;
-
-  test.beforeAll(async () => {
-    linter = await createASLinter();
-  });
-
-  test('should pass accessibility checks', async ({ page }) => {
-    // Navigate to your page
-    await page.goto('https://your-website.com');
-
-    // Get the page content
-    const content = await page.content();
-
-    // Run ASLint
-    const results = await linter.lint(content);
-
-    // Assert no accessibility violations
-    expect(results.violations).toHaveLength(0);
-
-    // Optional: Log detailed results
-    if (results.violations.length > 0) {
-      console.log('Accessibility violations found:',
-        results.violations.map(v => ({
-          rule: v.rule,
-          message: v.message,
-          element: v.element
-        }))
-      );
-    }
-  });
-
-  // Test specific components
-  test('check specific component accessibility', async ({ page }) => {
-    await page.goto('https://your-website.com/component');
-
-    // Wait for specific component to be visible
-    await page.waitForSelector('.your-component');
-
-    // Get component HTML
-    const componentHTML = await page.$eval(
-      '.your-component',
-      el => el.outerHTML
-    );
-
-    const results = await linter.lint(componentHTML);
-    expect(results.violations).toHaveLength(0);
-  });
-});
-
-// playwright.config.js
-const { defineConfig } = require('@playwright/test');
-
-module.exports = defineConfig({
-  testDir: './tests',
-  /* Other Playwright configs */
-  use: {
-    // Enable automatic accessibility violations logging
-    trace: 'retain-on-failure'
-  },
-  reporter: [
-    ['html'],
-    ['list']
-  ]
-});