@diegovelasquezweb/a11y-engine 0.11.27 → 0.11.29

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@diegovelasquezweb/a11y-engine",
-  "version": "0.11.27",
+  "version": "0.11.29",
   "description": "WCAG 2.2 accessibility audit engine — scanner, analyzer, and report builders",
   "type": "module",
   "license": "MIT",

package/src/fixes/apply-finding-fix.mjs

@@ -208,7 +208,7 @@ function groupFindingsByFile(domFindings, projectDir) {
     return { abs, rel, content };
   });
 
-  const groups = new Map();
+  const initialGroups = new Map();
 
   for (const finding of domFindings) {
     const tokens = selectorTokens(finding.selector);
@@ -219,13 +219,29 @@ function groupFindingsByFile(domFindings, projectDir) {
       .slice(0, MAX_CANDIDATE_FILES);
 
     const key = ranked.length > 0 ? ranked[0].rel : `__no_candidates_${finding.id}`;
-    if (!groups.has(key)) {
-      groups.set(key, { candidates: ranked, findings: [] });
+    if (!initialGroups.has(key)) {
+      initialGroups.set(key, { candidates: ranked, findings: [] });
     }
-    groups.get(key).findings.push(finding);
+    initialGroups.get(key).findings.push(finding);
   }
 
-  return groups;
+  const merged = [];
+  for (const group of initialGroups.values()) {
+    const fileSet = new Set(group.candidates.map((c) => c.rel));
+    const existing = merged.find((m) => m.candidates.some((c) => fileSet.has(c.rel)));
+    if (existing) {
+      existing.findings.push(...group.findings);
+      for (const candidate of group.candidates) {
+        if (!existing.candidates.some((c) => c.rel === candidate.rel)) {
+          existing.candidates.push(candidate);
+        }
+      }
+    } else {
+      merged.push({ candidates: [...group.candidates], findings: [...group.findings] });
+    }
+  }
+
+  return merged;
 }
 
 function buildAiFixInputMulti({ findings, intelligenceRules, candidates, projectHints }) {
@@ -300,16 +316,22 @@ function parseJsonBlock(text) {
 }
 
 async function callClaudeForPatch({ apiKey, model, aiInput }) {
+  const isMulti = Array.isArray(aiInput.findings);
   const system = [
     "You are an accessibility fix engine.",
     "Return JSON only.",
     "Generate deterministic text replacements for provided files.",
-    "Use finding.fixDescription and execution.constraints.must as guidance for what to fix and how.",
+    "Use finding.fixDescription and constraints.must as guidance for what to fix and how.",
     "For insertions (new element that does not yet exist in the file), use the nearest existing parent element as the search anchor. The replace value must include that anchor plus the new content.",
     "Do not create files. Do not modify paths outside provided filePath values.",
+    isMulti
+      ? "You are fixing MULTIPLE findings at once. Generate at least one change per finding. Set findingId on each change to the exact finding ID it addresses."
+      : "",
     "Schema:",
-    "{\"changes\":[{\"filePath\":\"...\",\"search\":\"...\",\"replace\":\"...\"}],\"verifyRule\":\"...\",\"verifyRoute\":\"...\",\"notes\":\"...\"}",
-  ].join("\n");
+    isMulti
+      ? "{\"changes\":[{\"findingId\":\"...(required: exact finding id)\",\"filePath\":\"...\",\"search\":\"...\",\"replace\":\"...\"}],\"notes\":\"...\"}"
+      : "{\"changes\":[{\"filePath\":\"...\",\"search\":\"...\",\"replace\":\"...\"}],\"notes\":\"...\"}",
+  ].filter(Boolean).join("\n");
 
   const userMessage = JSON.stringify(aiInput, null, 2);
 
@@ -372,19 +394,23 @@ function validateAiPatchOutput(output, projectDir, fileSet) {
 function applyChanges(projectDir, changes) {
   const changedFiles = [];
   const patchParts = [];
+  const succeededFindingIds = new Set();
 
   for (const change of changes) {
     const rel = change.filePath;
     const abs = path.resolve(projectDir, rel);
     const original = fs.readFileSync(abs, "utf8");
     if (!original.includes(change.search)) {
-      return { ok: false, reason: `Search block not found in ${rel}` };
+      continue;
     }
     const updated = original.replace(change.search, change.replace);
     if (updated === original) continue;
     fs.writeFileSync(abs, updated, "utf8");
     changedFiles.push(rel);
     patchParts.push(`--- ${rel}\n+++ ${rel}\n@@\n-${change.search}\n+${change.replace}`);
+    if (typeof change.findingId === "string" && change.findingId.trim()) {
+      succeededFindingIds.add(change.findingId.trim());
+    }
   }
 
   if (changedFiles.length === 0) return { ok: false, reason: "No effective changes were applied" };
@@ -393,6 +419,7 @@ function applyChanges(projectDir, changes) {
     ok: true,
     changedFiles: [...new Set(changedFiles)],
     patch: patchParts.join("\n"),
+    succeededFindingIds,
   };
 }
 
@@ -645,8 +672,8 @@ export async function applyFindingFix(input) {
     message: "Patch applied successfully.",
     changedFiles: applied.changedFiles,
     patch: applied.patch,
-    verifyRule: patchOutput.verifyRule || execution.verify.ruleId,
-    verifyRoute: patchOutput.verifyRoute || execution.verify.route,
+    verifyRule: execution.verify.ruleId,
+    verifyRoute: execution.verify.route,
     findingTitle: finding.title || "",
     branchSlug: slugify(`${findingId}-${ruleId}`),
     usage: claudeUsage,
@@ -738,7 +765,7 @@ export async function applyFindingsFix(input) {
 
   const groups = groupFindingsByFile(domFindings, projectDir);
 
-  for (const [topFile, { candidates, findings: groupFindings }] of groups) {
+  for (const { candidates, findings: groupFindings } of groups) {
     if (candidates.length === 0) {
       for (const finding of groupFindings) {
         resultMap.set(
@@ -800,7 +827,7 @@ export async function applyFindingsFix(input) {
           makeResult(finding.id, {
             applied: false,
             reason: FIX_ERROR_CODES.PATCH_GENERATION_FAILED,
-            message: `Could not generate patch output for file group (top file: ${topFile}).`,
+            message: `Could not generate patch output for file group (top file: ${candidates[0]?.rel || "unknown"}).`,
             findingTitle: finding.title || "",
             branchSlug: slugify(`${finding.id}-${finding.rule_id || ""}`),
             usage: claudeUsage,
@@ -851,20 +878,31 @@ export async function applyFindingsFix(input) {
     const perInput = Math.round(claudeUsage.input_tokens / n);
     const perOutput = Math.round(claudeUsage.output_tokens / n);
 
+    // If Claude tagged changes with findingId, use those for per-finding success tracking.
+    // If no findingId tags were emitted, fall back to group-level success for all findings.
+    const hasFindingIdTracking = applied.succeededFindingIds.size > 0;
+
     for (const finding of withRules) {
       const ruleId = typeof finding.rule_id === "string" ? finding.rule_id.trim() : "";
       const intelligenceRule = intelligenceRules[ruleId] || {};
       const execution = buildExecution(ruleId, intelligenceRule, finding);
+
+      const findingApplied = hasFindingIdTracking
+        ? applied.succeededFindingIds.has(finding.id)
+        : true;
+
       resultMap.set(
         finding.id,
         makeResult(finding.id, {
-          applied: true,
-          reason: "",
-          message: "Patch applied successfully.",
+          applied: findingApplied,
+          reason: findingApplied ? "" : FIX_ERROR_CODES.PATCH_APPLY_FAILED,
+          message: findingApplied
+            ? "Patch applied successfully."
+            : "The change for this finding could not be applied (search block not found).",
           changedFiles: applied.changedFiles,
           patch: applied.patch,
-          verifyRule: patchOutput.verifyRule || execution.verify.ruleId,
-          verifyRoute: patchOutput.verifyRoute || execution.verify.route,
+          verifyRule: execution.verify.ruleId,
+          verifyRoute: execution.verify.route,
           findingTitle: finding.title || "",
           branchSlug: slugify(`${finding.id}-${ruleId}`),
           usage: { input_tokens: perInput, output_tokens: perOutput },

package/src/pipeline/dom-scanner.mjs

@@ -605,8 +605,11 @@ async function analyzeRoute(
       const builder = new AxeBuilder({ page });
 
       if (onlyRule) {
-        log.info(`Targeted Audit: Only checking rule "${onlyRule}"`);
-        builder.withRules([onlyRule]);
+        const rules = onlyRule.includes(",")
+          ? onlyRule.split(",").map((r) => r.trim()).filter(Boolean)
+          : [onlyRule];
+        log.info(`Targeted Audit: Only checking rules "${rules.join(", ")}"`);
+        builder.withRules(rules);
       } else {
         const tagsToUse = axeTags || AXE_TAGS;
         builder.withTags(tagsToUse);