ultra11y 2.26.0 → 2.28.0

package/.agents/plugins/marketplace.json

@@ -0,0 +1,12 @@
+{
+  "name": "ultra11y",
+  "interface": { "displayName": "ultra11y" },
+  "plugins": [
+    {
+      "name": "ultra11y",
+      "source": { "source": "url", "url": "./" },
+      "policy": { "installation": "AVAILABLE", "authentication": "ON_INSTALL" },
+      "category": "Productivity"
+    }
+  ]
+}

package/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
       "name": "ultra11y",
       "source": "./",
       "description": "Automatic accessibility review of the code under change before every commit, push and pull request, plus full WCAG 2.2 AA / RGAA audits and conformance deliverables on demand.",
-      "version": "2.26.0",
+      "version": "2.28.0",
       "author": { "name": "maxgfr" },
       "homepage": "https://github.com/maxgfr/ultra11y",
       "repository": "https://github.com/maxgfr/ultra11y",

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "ultra11y",
   "description": "Accessibility for WCAG 2.2 AA and country standards (RGAA…): an automatic review of the code under change before every commit, push and pull request, plus full audits and conformance deliverables on demand.",
-  "version": "2.26.0",
+  "version": "2.28.0",
   "author": { "name": "maxgfr" },
   "homepage": "https://github.com/maxgfr/ultra11y",
   "repository": "https://github.com/maxgfr/ultra11y",

package/.codex-plugin/plugin.json

@@ -0,0 +1,21 @@
+{
+  "name": "ultra11y",
+  "description": "Accessibility for WCAG 2.2 AA and country standards (RGAA…): an automatic review of the code under change before every commit, push and pull request, plus full audits and conformance deliverables on demand.",
+  "version": "2.28.0",
+  "author": { "name": "maxgfr", "url": "https://github.com/maxgfr" },
+  "homepage": "https://github.com/maxgfr/ultra11y",
+  "repository": "https://github.com/maxgfr/ultra11y",
+  "license": "MIT",
+  "keywords": ["accessibility", "a11y", "wcag", "rgaa", "code-review", "audit"],
+  "skills": "./skills/",
+  "interface": {
+    "displayName": "ultra11y",
+    "shortDescription": "WCAG 2.2 AA review before you commit, push or open a PR.",
+    "longDescription": "Reviews exactly the code under change against WCAG 2.2 AA. A zero-dependency static engine — 78 checks tied to the success criteria, scored against the W3C ACT corpus — plus the agent's judgment on what a static pass cannot decide, with check/verify gates against invented non-conformities. Country standards (RGAA…) are pluggable in-repo packs.",
+    "developerName": "maxgfr",
+    "category": "Productivity",
+    "capabilities": ["Read", "Write"],
+    "websiteURL": "https://github.com/maxgfr/ultra11y",
+    "defaultPrompt": "Review my staged changes for accessibility."
+  }
+}

package/.opencode/plugins/ultra11y.js

@@ -0,0 +1,102 @@
+// The OpenCode plugin — what makes the `review-a11y` skill fire on its own before a
+// commit, push or pull request.
+//
+// This is hooks/pre-tool-use.mjs in a different costume, and deliberately so. OpenCode has
+// no permission-decision channel: a plugin blocks a tool call by THROWING, and the message
+// is what the agent sees. So the shape is the same two-stage split — this file pays only
+// the cost of a string test on each shell call, and the 2.5 MB engine is spawned only once
+// something could possibly be a publishing command.
+//
+// TWO RULES, the same two that govern src/hook.ts.
+//
+//  1. NEVER break a session. Every unexpected condition — no engine, spawn failure,
+//     timeout, unreadable output — is a silent no-op. The single `throw` below is our own
+//     decision and nothing else; note that the try/catch closes BEFORE it, so a bug in here
+//     can never surface to the user as a blocked `git push`.
+//  2. NEVER loop. The anti-loop marker lives in the engine (loopKey/firstSighting in
+//     src/hook.ts) and keys on the session id, so passing OpenCode's sessionID through is
+//     all that is required: one review per state of the change, exactly as on Claude Code.
+//
+// Zero dependencies, `node:` builtins only — it is loaded straight from disk by OpenCode.
+import { spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// Ownership marker: `ultra11y install --opencode` refuses to overwrite a plugin file that
+// does not carry it, so a user's own ultra11y.js is never clobbered.
+const ULTRA11Y_OPENCODE_PLUGIN = "ULTRA11Y_OPENCODE_PLUGIN";
+const ULTRA11Y_PLUGIN_VERSION = "2.28.0";
+
+const here = dirname(fileURLToPath(import.meta.url));
+
+/** The engine bundle, or null. Never `require.resolve` — this module is ESM and OpenCode's
+ *  loader is not guaranteed to have the package resolvable from here. */
+function resolveEngine() {
+  const candidates = [
+    process.env.ULTRA11Y_BIN, //                      explicit override (and what the tests set)
+    join(here, "ultra11y.mjs"), //                     a copy dropped beside the plugin
+    join(here, "..", "..", "scripts", "ultra11y.mjs"), // the npm-pin route: <pkgroot>/.opencode/plugins/
+    join(homedir(), ".ultra11y", "bin", "ultra11y.mjs"), // the pin written by `install --opencode`
+  ];
+  for (const c of candidates) if (c && existsSync(c)) return c;
+  return null;
+}
+
+/** Same literal as hooks/pre-tool-use.mjs — tests/harness-sync.test.ts asserts they match,
+ *  because two prefilters that disagree mean one harness silently reviews less. */
+const PREFILTER = /\bgit\b|\bgh\b/;
+
+export const Ultra11yPlugin = async (ctx) => {
+  const skillsDir = join(here, "..", "..", "skills");
+
+  return {
+    /** Register the two bundled skills so `review-a11y` is invocable by name once the gate
+     *  names it. Wrapped: if OpenCode's config shape differs, this is a harmless no-op and
+     *  the user still has the skills via `ultra11y install --opencode`. */
+    config: async (config) => {
+      try {
+        if (!existsSync(skillsDir)) return;
+        config.skills ??= {};
+        config.skills.paths ??= [];
+        if (!config.skills.paths.includes(skillsDir)) config.skills.paths.push(skillsDir);
+      } catch {
+        /* not fatal — the skills can also be installed into ~/.config/opencode/skills/ */
+      }
+    },
+
+    "tool.execute.before": async (input, output) => {
+      let text;
+      try {
+        if (String(input?.tool ?? "").toLowerCase() !== "bash") return;
+        const command = output?.args?.command;
+        if (typeof command !== "string" || !PREFILTER.test(command)) return;
+        if (process.env.SKIP_A11Y || process.env.ULTRA11Y_HOOK === "off") return;
+
+        const engine = resolveEngine();
+        if (!engine) return;
+
+        const payload = {
+          tool_name: "Bash",
+          tool_input: { command },
+          cwd: ctx?.directory ?? ctx?.worktree ?? process.cwd(),
+          session_id: input?.sessionID ?? `opencode-${process.pid}`,
+        };
+        const run = spawnSync(process.execPath, [engine, "hook", "--opencode"], {
+          input: JSON.stringify(payload),
+          encoding: "utf8",
+          timeout: 20_000,
+          maxBuffer: 8 * 1024 * 1024,
+        });
+        text = (run.stdout ?? "").trim();
+      } catch {
+        return; // unreadable input, spawn failure, timeout — say nothing
+      }
+      // Outside the try on purpose: this is the ONLY error allowed to reach the agent.
+      if (text) throw new Error(text);
+    },
+  };
+};
+
+export { ULTRA11Y_OPENCODE_PLUGIN, ULTRA11Y_PLUGIN_VERSION };

package/README.md

@@ -2,21 +2,25 @@
 
 [![CI](https://github.com/maxgfr/ultra11y/actions/workflows/ci.yml/badge.svg)](https://github.com/maxgfr/ultra11y/actions/workflows/ci.yml)
 [![npm](https://img.shields.io/npm/v/ultra11y?logo=npm)](https://www.npmjs.com/package/ultra11y)
-[![Claude Code plugin](https://img.shields.io/badge/Claude_Code-plugin-6b46c1)](#add-to-claude-code)
+[![agent plugin](https://img.shields.io/badge/Claude_Code_·_Codex_·_OpenCode-plugin-6b46c1)](#add-to-your-coding-agent)
 [![node](https://img.shields.io/node/v/ultra11y)](https://nodejs.org)
 [![license](https://img.shields.io/npm/l/ultra11y)](LICENSE)
 
-### Add to Claude Code
+### Add to your coding agent
 
 Two lines, and the accessibility review runs **by itself** before every commit, push and
 pull request — you never type the skill's name:
 
-```
-/plugin marketplace add maxgfr/ultra11y
-/plugin install ultra11y@ultra11y
-```
-
-<sub>Prefer the skills only, without the automatic hook? `npx skills add maxgfr/ultra11y`.
+| | |
+|---|---|
+| **Claude Code** | `/plugin marketplace add maxgfr/ultra11y` then `/plugin install ultra11y@ultra11y` |
+| **OpenAI Codex CLI** | `codex plugin marketplace add maxgfr/ultra11y` then `codex plugin add ultra11y@ultra11y` |
+| **OpenCode** | `npx ultra11y install --opencode` — or pin `"plugin": ["ultra11y@latest"]` in `opencode.json` |
+| **Anything else** | `npx ultra11y install --agents-md` (no hook API: see the caveat below) |
+
+<sub>Prefer the skills only, without the automatic hook? `npx skills add maxgfr/ultra11y`
+(`--agent codex`, `--agent opencode`, …). Already on npm and just want the gate?
+`npx ultra11y install --all`, and `npx ultra11y status` to check what is actually wired.
 Full details, thresholds and off-switches under [Install](#install).</sub>
 
 > Audit HTML/CSS/JSX against **WCAG 2.2 AA** accessibility and produce a dated compliance report — or author/review accessible markup without regressions. A [skills.sh](https://skills.sh) agent skill: a deterministic, zero-dependency static engine **plus** the agent's judgment, with `check`/`verify` gates against hallucinated non-conformities. **The central deliverable is the auditor conformance block** — theme, criterion + official wording, test(s), WCAG mapping + level, finding, expected state, verification, `file:line` occurrences — rendered identically by the `report` (compliance doc), the `prd` backlog and the GitHub issues, in the active standard's vocabulary and **in your language** (`--lang auto` follows the conversation/repo). **WCAG is the worldwide core; country standards (RGAA, …) are pluggable in-repo packs.**
@@ -61,27 +65,41 @@ working diff, or branch vs merge-base) and reports like a code reviewer. Both bu
 install-free engine.
 
 ```sh
-npx skills add maxgfr/ultra11y
+npx skills add maxgfr/ultra11y                 # this agent
+npx skills add maxgfr/ultra11y --agent codex   # …or opencode, cursor, gemini, amp, zed…
 ```
 
-**As a Claude Code plugin** — the same two skills, plus the hook that makes the review
+**As an agent plugin** — the same two skills, plus the hook that makes the review
 **automatic**. Installed this way, a pending `git commit`, `git push` or `gh pr create`
 that carries accessibility findings is stopped once and the agent is handed the findings,
 so `review-a11y` runs before the work goes out — you never type the skill's name.
 
 ```
-/plugin marketplace add maxgfr/ultra11y
-/plugin install ultra11y@ultra11y
+/plugin marketplace add maxgfr/ultra11y          # Claude Code
+codex plugin marketplace add maxgfr/ultra11y     # Codex CLI
+npx ultra11y install --opencode                  # OpenCode
 ```
 
-Three things worth knowing, because they bound what "automatic" means here:
+Codex's hook engine is a near-clone of Claude Code's — same events, same envelope, and it
+exports `${CLAUDE_PLUGIN_ROOT}` too — so both harnesses share one `hooks/hooks.json`.
+OpenCode has no permission-decision channel, so there the gate surfaces as a **failed bash
+call whose error message carries the findings**. Per-harness deltas, the Codex feature flag
+and the trust prompt: [`skills/ultra11y/references/harnesses.md`](skills/ultra11y/references/harnesses.md).
+
+Four things worth knowing, because they bound what "automatic" means here:
 
 - A hook **cannot force** a skill to be invoked. It blocks the command and hands over the
   reason and the findings; the agent is what invokes `review-a11y`. In practice a motivated
   `deny` is enough — it is not a guarantee.
-- **Hooks do not enable themselves.** Installing the plugin is what turns them on.
-- Claude Code has **no git event** (no `PreCommit`, no `PRCreated`), which is why the hook
-  listens on `PreToolUse` for the Bash tool and recognises the commands that publish work.
+- **Hooks do not enable themselves.** Installing the plugin is what turns them on. On Codex
+  they also need `[features] hooks = true`, which `install --codex` sets for you; run
+  `npx ultra11y status` if you are not sure what is live.
+- **No harness has a git event** (no `PreCommit`, no `PRCreated`), which is why the hook
+  listens on `PreToolUse` for the shell tool — `Bash` on Claude Code, `shell` on Codex —
+  and recognises the commands that publish work.
+- On a harness with **no hook API at all** (Cursor, Amp, Zed, Gemini CLI…), nothing is
+  automatic. `npx ultra11y install --agents-md` makes the engine discoverable and hands the
+  agent the adjudication protocol; `init --hook` below is what actually enforces the gate.
 
 The gate never blocks twice for the same findings, so a retry always lands. It stays out of
 the way when git's own `no-verify` bypass is used, outside a repository, and whenever the

package/hooks/hooks.json

@@ -2,7 +2,7 @@
   "hooks": {
     "PreToolUse": [
       {
-        "matcher": "Bash",
+        "matcher": "Bash|bash|shell|local_shell|exec_command|run_command|exec",
         "hooks": [
           {
             "type": "command",

package/hooks/pre-tool-use.mjs

@@ -1,16 +1,19 @@
 #!/usr/bin/env node
 // The plugin's PreToolUse guard — deliberately tiny.
 //
-// Claude Code has no git-aware hook event, so this runs on EVERY Bash tool call. The
-// engine next to it is a 2.4 MB bundle; parsing that before each shell command would be
-// an unacceptable tax on a session. So the split is: this file pays only a bare Node
-// start and answers "could this possibly be a publishing command?", and the engine —
-// spawned only when the answer is yes — makes the real decision (src/hook.ts).
+// No harness has a git-aware hook event, so this runs on EVERY shell tool call. The engine
+// next to it is a 2.4 MB bundle; parsing that before each shell command would be an
+// unacceptable tax on a session. So the split is: this file pays only a bare Node start
+// and answers "could this possibly be a publishing command?", and the engine — spawned
+// only when the answer is yes — makes the real decision (src/hook.ts).
 //
 // The prefilter is intentionally OVER-permissive: it matches any command mentioning git
 // or gh at all. Precision lives in one place, `matchGitIntent`, so the two cannot drift.
 //
-// Contract with Claude Code: print the hook JSON on stdout to act, print nothing to stay
+// Shared by Claude Code and Codex: both set ${CLAUDE_PLUGIN_ROOT}, use the same PreToolUse
+// payload fields and read the same `hookSpecificOutput` envelope.
+//
+// Contract with the harness: print the hook JSON on stdout to act, print nothing to stay
 // out of the way. Exit code is ALWAYS 0 — a guard that errors out on a user's `git push`
 // is worse than no guard, so every failure path here is silence.
 import { spawnSync } from "node:child_process";
@@ -20,8 +23,16 @@ import { fileURLToPath } from "node:url";
 
 try {
   const payload = JSON.parse(readFileSync(0, "utf8"));
-  if (payload.tool_name !== "Bash") process.exit(0);
-  const command = payload.tool_input?.command ?? "";
+  // Anchored so `BashOutput`/`KillShell` (background-shell polls) never reach the engine,
+  // but deliberately loose about WHICH shell: `Bash` on Claude Code, `shell` and friends on
+  // Codex. `isShellTool` in src/hook.ts is the precise check; tests/harness-sync.test.ts
+  // asserts this regex accepts exactly the same names.
+  if (!/^(?:bash|shell|exec|exec_command|local_?shell|run_command)$/i.test(String(payload.tool_name ?? ""))) process.exit(0);
+  // Codex passes an argv array. Joining it is WRONG for deciding intent (see `commandOf`)
+  // but exactly right here, where the only question is whether the words appear at all —
+  // and the payload is forwarded untouched, so the engine re-parses it properly.
+  const raw = payload.tool_input?.command;
+  const command = typeof raw === "string" ? raw : Array.isArray(raw) ? raw.join(" ") : "";
   // Prefilter: no mention of git or gh ⇒ nothing to do, and we never touched the engine.
   if (!/\bgit\b|\bgh\b/.test(command)) process.exit(0);
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ultra11y",
-  "version": "2.26.0",
+  "version": "2.28.0",
   "description": "Audit HTML/CSS/JSX against WCAG 2.2 AA and produce a dated compliance report, or author/review accessible markup (native-HTML-first). A skills.sh agent skill: an install-free static engine (bundled, no npm install) plus the agent's judgment, with check/verify gates against hallucinated non-conformities, and pluggable in-repo standards packs (RGAA France first; Section 508 & EN 301 549 next).",
   "type": "module",
   "packageManager": "pnpm@10.33.0",
@@ -13,6 +13,9 @@
     "skills",
     "docker",
     ".claude-plugin",
+    ".codex-plugin",
+    ".agents",
+    ".opencode",
     "hooks"
   ],
   "engines": {
@@ -75,5 +78,6 @@
   },
   "publishConfig": {
     "access": "public"
-  }
+  },
+  "main": ".opencode/plugins/ultra11y.js"
 }

package/scripts/sync-version.mjs

@@ -41,13 +41,21 @@ edit("src/types.ts", (s) => s.replace(/(export const VERSION = ")[^"]+(";)/, `$1
 edit("skills/ultra11y/SKILL.md", setVersionField);
 edit("skills/review-a11y/SKILL.md", setVersionField);
 
-// The Claude Code plugin manifests — what carries the automatic-review hook. A stale
-// version here is what makes an installed plugin report the wrong engine; both list it,
-// so both are rewritten (verify-skill-bundle.mjs fails the build if they drift).
+// The plugin manifests — what carries the automatic-review hook. A stale version here is
+// what makes an installed plugin report the wrong engine, so every harness's manifest is
+// rewritten (verify-skill-bundle.mjs fails the build if they drift). Codex resolves
+// .codex-plugin/plugin.json first and falls back to .claude-plugin/plugin.json, so the two
+// must agree. .agents/plugins/marketplace.json carries no version by design — it points at
+// the repo, and the plugin manifest inside it is the single source of the number.
 const setJsonVersion = (s) => s.replace(/("version":\s*")[^"]+(")/, `$1${version}$2`);
 edit(".claude-plugin/plugin.json", setJsonVersion);
 edit(".claude-plugin/marketplace.json", setJsonVersion);
+edit(".codex-plugin/plugin.json", setJsonVersion);
+
+// The OpenCode plugin is committed JS, not a manifest — its version lives in a constant the
+// installer and `status` read back. verify-skill-bundle.mjs fails the build if it drifts.
+edit(".opencode/plugins/ultra11y.js", (s) => s.replace(/(const ULTRA11Y_PLUGIN_VERSION = ")[^"]+(")/, `$1${version}$2`));
 
 console.log(
-  `sync-version: set ${version} in package.json, src/types.ts, skills/ultra11y/SKILL.md, skills/review-a11y/SKILL.md, .claude-plugin/plugin.json, .claude-plugin/marketplace.json`,
+  `sync-version: set ${version} in package.json, src/types.ts, skills/ultra11y/SKILL.md, skills/review-a11y/SKILL.md, .claude-plugin/plugin.json, .claude-plugin/marketplace.json, .codex-plugin/plugin.json`,
 );