codeply-cli 0.1.1 → 0.3.0

package/lib/typecheck-worker.js

@@ -0,0 +1,147 @@
+/**
+ * Type-checks single files with the project's own TypeScript, in a separate
+ * process so a slow first build never blocks the app. One worker per project
+ * root; it keeps a LanguageService warm, so after the first file each check
+ * only re-reads what changed.
+ *
+ * Messages in:  { id, file }            Messages out: { id, problems: string[] } | { id, error }
+ * Started with: argv[2] = project root (folder with tsconfig/jsconfig), argv[3] = typescript module path
+ */
+const fs = require('fs');
+const path = require('path');
+
+const root = process.argv[2];
+const ts = require(process.argv[3]);
+const MAX = 10;
+
+const configPath = ts.findConfigFile(root, ts.sys.fileExists, 'tsconfig.json') || ts.findConfigFile(root, ts.sys.fileExists, 'jsconfig.json');
+let options = { allowJs: true, noEmit: true, skipLibCheck: true };
+let fileNames = [];
+if (configPath) {
+  const cfg = ts.readConfigFile(configPath, ts.sys.readFile);
+  const parsed = ts.parseJsonConfigFileContent(cfg.config || {}, ts.sys, path.dirname(configPath));
+  options = { ...parsed.options, noEmit: true };
+  fileNames = parsed.fileNames;
+}
+const extra = new Set(); // files checked that the config doesn't list
+
+const versions = new Map();
+const version = (f) => {
+  try { return String(fs.statSync(f).mtimeMs); } catch { return '0'; }
+};
+
+const host = {
+  getScriptFileNames: () => [...fileNames, ...extra],
+  getScriptVersion: (f) => version(f),
+  getScriptSnapshot: (f) => {
+    if (!fs.existsSync(f)) return undefined;
+    return ts.ScriptSnapshot.fromString(fs.readFileSync(f, 'utf8'));
+  },
+  getCurrentDirectory: () => root,
+  getCompilationSettings: () => options,
+  getDefaultLibFileName: (o) => ts.getDefaultLibFilePath(o),
+  fileExists: ts.sys.fileExists,
+  readFile: ts.sys.readFile,
+  readDirectory: ts.sys.readDirectory,
+  directoryExists: ts.sys.directoryExists,
+  getDirectories: ts.sys.getDirectories,
+};
+const service = ts.createLanguageService(host, ts.createDocumentRegistry());
+
+function check(file) {
+  const abs = path.resolve(file);
+  const norm = abs.replace(/\\/g, '/');
+  if (!fileNames.some((f) => path.resolve(f) === abs)) extra.add(norm);
+  versions.set(abs, version(abs));
+  const diags = [...service.getSyntacticDiagnostics(norm), ...service.getSemanticDiagnostics(norm)]
+    .filter((d) => d.category === ts.DiagnosticCategory.Error);
+  return diags.slice(0, MAX).map((d) => {
+    const line = d.file && d.start != null ? d.file.getLineAndCharacterOfPosition(d.start).line + 1 : null;
+    return `${line ? `line ${line}: ` : ''}TS${d.code}: ${ts.flattenDiagnosticMessageText(d.messageText, ' ')}`;
+  });
+}
+
+// ── Code navigation (the lsp tool): definition, references, hover, symbols ──
+const rel = (f) => path.relative(root, f).replace(/\\/g, '/') || f;
+function place(fileName, start) {
+  const sf = service.getProgram().getSourceFile(fileName);
+  if (!sf) return `${rel(fileName)}`;
+  const { line, character } = sf.getLineAndCharacterOfPosition(start);
+  return `${rel(fileName)}:${line + 1}:${character + 1}`;
+}
+function lineText(fileName, start) {
+  const sf = service.getProgram().getSourceFile(fileName);
+  if (!sf) return '';
+  const { line } = sf.getLineAndCharacterOfPosition(start);
+  return sf.text.split('\n')[line].trim().slice(0, 160);
+}
+let navFile = null;
+function flattenTree(node, out, depth = 0) {
+  for (const c of node.childItems || []) {
+    const line = c.spans[0] ? navFile.getLineAndCharacterOfPosition(c.spans[0].start).line + 1 : '?';
+    if (c.kind !== 'alias') out.push(`${'  '.repeat(depth)}${c.kind} ${c.text}  (line ${line})`);
+    flattenTree(c, out, depth + 1);
+  }
+}
+
+function navigate(msg) {
+  const abs = path.resolve(msg.file || root);
+  const norm = abs.replace(/\\/g, '/');
+  if (msg.file && fs.existsSync(abs) && !fileNames.some((f) => path.resolve(f) === abs)) extra.add(norm);
+  const op = msg.op;
+  if (op === 'workspaceSymbol') {
+    const items = (service.getNavigateToItems(msg.query || '', 200) || [])
+      .filter((i) => !/[\\/]node_modules[\\/]/.test(i.fileName) && !/[\\/]typescript[\\/]lib[\\/]/.test(i.fileName))
+      .slice(0, 40);
+    return items.map((i) => `${i.kind} ${i.name}  ${place(i.fileName, i.textSpan.start)}`).join('\n') || 'No symbols match.';
+  }
+  const sf = service.getProgram().getSourceFile(norm);
+  if (!sf) return `${msg.file} is not part of a TypeScript/JavaScript project this checker can see.`;
+  if (op === 'documentSymbol') {
+    navFile = sf;
+    const out = [];
+    flattenTree(service.getNavigationTree(norm), out);
+    return out.join('\n') || 'No symbols in this file.';
+  }
+  // Position-based: 1-based line/character from the caller.
+  const lines = sf.text.split('\n');
+  const li = Math.min(Math.max((msg.line || 1) - 1, 0), lines.length - 1);
+  let col = msg.character ? msg.character - 1 : -1;
+  if (col < 0 && msg.symbol) {
+    const at = lines[li].indexOf(msg.symbol);
+    col = at >= 0 ? at : -1;
+    if (col < 0) {
+      const whole = new RegExp(`\\b${msg.symbol.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`).exec(sf.text);
+      if (whole) return navigateAt(op, norm, whole.index);
+      return `Could not find "${msg.symbol}" in ${msg.file}.`;
+    }
+  }
+  if (col < 0) col = Math.max(0, lines[li].search(/\S/));
+  const pos = sf.getPositionOfLineAndCharacter(li, col);
+  return navigateAt(op, norm, pos);
+}
+function navigateAt(op, norm, pos) {
+  if (op === 'hover') {
+    const info = service.getQuickInfoAtPosition(norm, pos);
+    if (!info) return 'No type information at that position.';
+    const sig = ts.displayPartsToString(info.displayParts);
+    const doc = ts.displayPartsToString(info.documentation);
+    return doc ? `${sig}\n\n${doc}` : sig;
+  }
+  let locs;
+  if (op === 'definition') locs = service.getDefinitionAtPosition(norm, pos) || [];
+  else if (op === 'implementation') locs = service.getImplementationAtPosition(norm, pos) || [];
+  else if (op === 'references') locs = service.getReferencesAtPosition(norm, pos) || [];
+  else return `Unknown operation "${op}".`;
+  if (!locs.length) return `No ${op} found at that position.`;
+  const shown = locs.slice(0, 40).map((l) => `${place(l.fileName, l.textSpan.start)}  ${lineText(l.fileName, l.textSpan.start)}`);
+  return `${locs.length} ${op === 'references' ? 'reference' : 'location'}${locs.length === 1 ? '' : 's'}${locs.length > 40 ? ' (first 40)' : ''}:\n${shown.join('\n')}`;
+}
+
+process.on('message', (msg) => {
+  try {
+    if (msg.op) process.send({ id: msg.id, text: navigate(msg) });
+    else process.send({ id: msg.id, problems: check(msg.file) });
+  } catch (e) { process.send({ id: msg.id, error: e.message }); }
+});
+process.send({ ready: true, hasConfig: !!configPath });

package/lib/web-tools.js

@@ -0,0 +1,158 @@
+/**
+ * Web access for the agent: fetch a page as readable text, and search the web.
+ *
+ * Search uses Exa's public MCP endpoint (the same one opencode's websearch tool
+ * talks to; no key needed) and falls back to DuckDuckGo's HTML results when
+ * Exa is unreachable. Fetching converts HTML to plain markdown-ish text so the
+ * model gets the content, not the markup.
+ */
+
+const UA = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0 Safari/537.36 Codeply';
+const MAX_BYTES = 5 * 1024 * 1024;
+const FETCH_TIMEOUT_MS = 30000;
+const SEARCH_TIMEOUT_MS = 25000;
+
+const ENTITIES = { amp: '&', lt: '<', gt: '>', quot: '"', apos: "'", nbsp: ' ', ndash: '-', mdash: '-', hellip: '...', rsquo: "'", lsquo: "'", rdquo: '"', ldquo: '"', copy: '(c)' };
+
+function decodeEntities(s) {
+  return s
+    .replace(/&#(\d+);/g, (_, n) => { try { return String.fromCodePoint(Number(n)); } catch { return ''; } })
+    .replace(/&#x([0-9a-f]+);/gi, (_, n) => { try { return String.fromCodePoint(parseInt(n, 16)); } catch { return ''; } })
+    .replace(/&([a-z]+);/gi, (m, n) => (ENTITIES[n.toLowerCase()] ?? m));
+}
+
+/** HTML -> readable text: headings, links, lists, code and paragraphs survive; the rest goes. */
+function htmlToText(html, baseUrl) {
+  let s = String(html);
+  s = s.replace(/<!--[\s\S]*?-->/g, '');
+  s = s.replace(/<(script|style|noscript|template|svg|iframe|head)\b[\s\S]*?<\/\1>/gi, '');
+  s = s.replace(/<pre\b[^>]*>([\s\S]*?)<\/pre>/gi, (_, code) => '\n```\n' + code.replace(/<[^>]+>/g, '') + '\n```\n');
+  s = s.replace(/<code\b[^>]*>([\s\S]*?)<\/code>/gi, (_, c) => '`' + c.replace(/<[^>]+>/g, '') + '`');
+  s = s.replace(/<h([1-6])\b[^>]*>([\s\S]*?)<\/h\1>/gi, (_, n, t) => `\n\n${'#'.repeat(Number(n))} ${t.replace(/<[^>]+>/g, '').trim()}\n\n`);
+  s = s.replace(/<a\b[^>]*href\s*=\s*["']([^"']*)["'][^>]*>([\s\S]*?)<\/a>/gi, (_, href, t) => {
+    const label = t.replace(/<[^>]+>/g, '').replace(/\s+/g, ' ').trim();
+    if (!label) return '';
+    if (!href || href.startsWith('#') || /^(javascript|mailto):/i.test(href)) return label;
+    let abs = href;
+    try { abs = new URL(href, baseUrl).href; } catch {}
+    return `[${label}](${abs})`;
+  });
+  s = s.replace(/<li\b[^>]*>/gi, '\n- ');
+  s = s.replace(/<br\s*\/?>/gi, '\n');
+  s = s.replace(/<\/(p|div|section|article|header|footer|main|nav|ul|ol|table|tr|blockquote|figure)>/gi, '\n');
+  s = s.replace(/<\/t[dh]>/gi, ' | ');
+  s = s.replace(/<[^>]+>/g, '');
+  s = decodeEntities(s);
+  s = s.replace(/[ \t\f\v]+/g, ' ').replace(/ *\n */g, '\n').replace(/\n{3,}/g, '\n\n');
+  return s.trim();
+}
+
+/**
+ * @param {string} url
+ * @param {{format?:'text'|'html'|'raw', signal?:AbortSignal, maxChars?:number}} [opts]
+ * @returns {Promise<{ok:boolean, text?:string, error?:string, status?:number, contentType?:string, finalUrl?:string}>}
+ */
+async function fetchPage(url, opts = {}) {
+  let parsed;
+  try { parsed = new URL(url); } catch { return { ok: false, error: `Not a valid URL: ${url}` }; }
+  if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') return { ok: false, error: 'web_fetch only supports http:// and https:// URLs.' };
+  const signals = [AbortSignal.timeout(FETCH_TIMEOUT_MS)];
+  if (opts.signal) signals.push(opts.signal);
+  let res;
+  try {
+    res = await fetch(parsed.href, {
+      redirect: 'follow',
+      signal: AbortSignal.any(signals),
+      headers: { 'User-Agent': UA, Accept: 'text/html,application/xhtml+xml,application/json,text/plain,text/markdown;q=0.9,*/*;q=0.5', 'Accept-Language': 'en-US,en;q=0.9' },
+    });
+  } catch (e) {
+    return { ok: false, error: `Could not reach ${parsed.href}: ${e.name === 'TimeoutError' ? 'timed out' : e.message}` };
+  }
+  if (!res.ok) return { ok: false, status: res.status, error: `${parsed.href} returned HTTP ${res.status}.` };
+  const contentType = (res.headers.get('content-type') || '').split(';')[0].trim().toLowerCase();
+  const declared = Number(res.headers.get('content-length') || 0);
+  if (declared > MAX_BYTES) return { ok: false, error: `The page is ${(declared / 1e6).toFixed(1)}MB, over the ${MAX_BYTES / 1e6}MB limit.` };
+  if (/^(image|video|audio)\//.test(contentType) || /^application\/(zip|octet-stream|pdf|gzip)/.test(contentType)) {
+    return { ok: false, contentType, error: `${parsed.href} is ${contentType}, not text. Use fetch_image for images or run curl to download a file.` };
+  }
+  let buf;
+  try { buf = Buffer.from(await res.arrayBuffer()); } catch (e) { return { ok: false, error: `Failed reading ${parsed.href}: ${e.message}` }; }
+  if (buf.length > MAX_BYTES) return { ok: false, error: `The page is over the ${MAX_BYTES / 1e6}MB limit.` };
+  const body = buf.toString('utf8');
+  const format = opts.format || 'text';
+  const isHtml = contentType.includes('html') || (!contentType && /^\s*<(!doctype|html)/i.test(body));
+  let text = body;
+  if (isHtml && format === 'text') text = htmlToText(body, res.url || parsed.href);
+  else if (contentType.includes('json') && format !== 'raw') {
+    try { text = JSON.stringify(JSON.parse(body), null, 2); } catch {}
+  }
+  return { ok: true, text, contentType, finalUrl: res.url || parsed.href, status: res.status };
+}
+
+// ─── Search ──────────────────────────────────────────────────────────────────
+
+async function exaSearch(query, num, signal) {
+  const signals = [AbortSignal.timeout(SEARCH_TIMEOUT_MS)];
+  if (signal) signals.push(signal);
+  const res = await fetch('https://mcp.exa.ai/mcp', {
+    method: 'POST',
+    signal: AbortSignal.any(signals),
+    headers: { 'Content-Type': 'application/json', Accept: 'application/json, text/event-stream' },
+    body: JSON.stringify({
+      jsonrpc: '2.0', id: 1, method: 'tools/call',
+      params: { name: 'web_search_exa', arguments: { query, numResults: num, type: 'auto', livecrawl: 'fallback' } },
+    }),
+  });
+  if (!res.ok) throw new Error(`Exa returned HTTP ${res.status}`);
+  const raw = await res.text();
+  // The reply is either plain JSON or an SSE stream of "data: {...}" lines.
+  const payloads = [];
+  if (raw.trimStart().startsWith('{')) payloads.push(raw);
+  else for (const line of raw.split('\n')) if (line.startsWith('data:')) payloads.push(line.slice(5).trim());
+  for (const p of payloads) {
+    let j;
+    try { j = JSON.parse(p); } catch { continue; }
+    if (j.error) throw new Error(j.error.message || 'Exa error');
+    const text = (j.result?.content || []).filter((c) => c.type === 'text').map((c) => c.text).join('\n').trim();
+    if (text) return text;
+  }
+  throw new Error('Exa returned no results');
+}
+
+async function ddgSearch(query, num, signal) {
+  const signals = [AbortSignal.timeout(SEARCH_TIMEOUT_MS)];
+  if (signal) signals.push(signal);
+  const res = await fetch('https://html.duckduckgo.com/html/', {
+    method: 'POST',
+    signal: AbortSignal.any(signals),
+    headers: { 'User-Agent': UA, 'Content-Type': 'application/x-www-form-urlencoded' },
+    body: `q=${encodeURIComponent(query)}`,
+  });
+  if (!res.ok) throw new Error(`DuckDuckGo returned HTTP ${res.status}`);
+  const html = await res.text();
+  const out = [];
+  const re = /<a[^>]+class="result__a"[^>]+href="([^"]+)"[^>]*>([\s\S]*?)<\/a>[\s\S]*?(?:<a[^>]+class="result__snippet"[^>]*>([\s\S]*?)<\/a>)?/gi;
+  let m;
+  while ((m = re.exec(html)) && out.length < num) {
+    let href = decodeEntities(m[1]);
+    const u = /[?&]uddg=([^&]+)/.exec(href);
+    if (u) { try { href = decodeURIComponent(u[1]); } catch {} }
+    const title = decodeEntities(m[2].replace(/<[^>]+>/g, '')).trim();
+    const snippet = decodeEntities((m[3] || '').replace(/<[^>]+>/g, '')).trim();
+    if (title && /^https?:/.test(href)) out.push(`Title: ${title}\nURL: ${href}${snippet ? `\n${snippet}` : ''}`);
+  }
+  if (!out.length) throw new Error('DuckDuckGo returned no results');
+  return out.join('\n\n');
+}
+
+/** @returns {Promise<{ok:boolean, text?:string, error?:string, via?:string}>} */
+async function webSearch(query, opts = {}) {
+  const num = Math.min(Math.max(Number(opts.num) || 8, 1), 20);
+  const errors = [];
+  try { return { ok: true, text: await exaSearch(query, num, opts.signal), via: 'exa' }; } catch (e) { errors.push(e.message); }
+  if (opts.signal?.aborted) return { ok: false, error: 'Search cancelled.' };
+  try { return { ok: true, text: await ddgSearch(query, num, opts.signal), via: 'duckduckgo' }; } catch (e) { errors.push(e.message); }
+  return { ok: false, error: `Web search failed (${errors.join('; ')}).` };
+}
+
+module.exports = { fetchPage, webSearch, htmlToText };

package/package.json

@@ -1,14 +1,16 @@
 {
   "name": "codeply-cli",
-  "version": "0.1.1",
-  "description": "Codeply from the terminal — an interactive AI coding agent, or a single apply <instruction> --file <path> command.",
+  "version": "0.3.0",
+  "description": "Codeply from the terminal: an interactive AI coding agent, a local server (codeply serve), and a GitHub agent that runs in your own Actions runner.",
   "main": "bin/codeply.js",
   "bin": {
     "codeply": "bin/codeply.js"
   },
   "files": [
     "bin",
-    "lib"
+    "lib",
+    "skills",
+    "THIRD_PARTY_NOTICES.md"
   ],
   "engines": {
     "node": ">=18"

package/skills/SOURCE.md

@@ -0,0 +1,58 @@
+# Where these skills came from
+
+The skill library in this directory — all 281 of them — is vendored from
+[affaan-m/ECC](https://github.com/affaan-m/ECC) ("Every Coding Copilot"), an
+open-source collection of agent skills for Claude Code, Codex, and other
+harnesses. It's their full `skills/` library, not a subset — every `SKILL.md`
+and its `references/*.md` companions, unmodified.
+
+Codeply loads its skill format directly from that project's convention: a
+`SKILL.md` per skill with YAML frontmatter (`name`, `description`) and a
+markdown body. See [lib/skills.js](../lib/skills.js) for the loader.
+
+Only `SKILL.md` and `references/*.md` were vendored — each skill's
+`agents/openai.yaml` (a tool schema for a different harness's native
+function-calling) was left out, since Codeply calls skills through its own
+text-based action protocol and has no use for it.
+
+Not every one of the 281 is loaded into the agent's context by default —
+`lib/skills.js` shows a curated "daily" subset (ECC's own `.agents/skills/`
+curation of its full library) to keep the always-injected index small; the
+rest are still fully installed and reachable with `list_skills <query>` or
+`codeply skill show <name>`.
+
+## License
+
+ECC is MIT-licensed. Its license and copyright notice, reproduced here as MIT
+requires when redistributing:
+
+```
+MIT License
+
+Copyright (c) 2026 Affaan Mustafa
+
+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.
+```
+
+## Adding your own
+
+Anything you drop in `~/.codeply/skills/<name>/SKILL.md` (same frontmatter
+format) is picked up the same way, and takes priority over a bundled skill of
+the same name. `codeply skill install <path-or-github-url>` automates that —
+see `codeply skill --help`.

package/skills/accessibility/SKILL.md

@@ -0,0 +1,147 @@
+---
+name: accessibility
+description: Design, implement, and audit inclusive digital products using WCAG 2.2 Level AA
+  standards. Use this skill to generate semantic ARIA for Web and accessibility traits for Web and Native platforms (iOS/Android).
+metadata:
+  origin: ECC
+---
+
+# Accessibility (WCAG 2.2)
+
+This skill ensures that digital interfaces are Perceivable, Operable, Understandable, and Robust (POUR) for all users, including those using screen readers, switch controls, or keyboard navigation. It focuses on the technical implementation of WCAG 2.2 success criteria.
+
+## When to Use
+
+- Defining UI component specifications for Web, iOS, or Android.
+- Auditing existing code for accessibility barriers or compliance gaps.
+- Implementing new WCAG 2.2 standards like Target Size (Minimum) and Focus Appearance.
+- Mapping high-level design requirements to technical attributes (ARIA roles, traits, hints).
+
+## Core Concepts
+
+- **POUR Principles**: The foundation of WCAG (Perceivable, Operable, Understandable, Robust).
+- **Semantic Mapping**: Using native elements over generic containers to provide built-in accessibility.
+- **Accessibility Tree**: The representation of the UI that assistive technologies actually "read."
+- **Focus Management**: Controlling the order and visibility of the keyboard/screen reader cursor.
+- **Labeling & Hints**: Providing context through `aria-label`, `accessibilityLabel`, and `contentDescription`.
+
+## How It Works
+
+### Step 1: Identify the Component Role
+
+Determine the functional purpose (e.g., Is this a button, a link, or a tab?). Use the most semantic native element available before resorting to custom roles.
+
+### Step 2: Define Perceivable Attributes
+
+- Ensure text contrast meets **4.5:1** (normal) or **3:1** (large/UI).
+- Add text alternatives for non-text content (images, icons).
+- Implement responsive reflow (up to 400% zoom without loss of function).
+
+### Step 3: Implement Operable Controls
+
+- Ensure a minimum **24x24 CSS pixel** target size (WCAG 2.2 SC 2.5.8).
+- Verify all interactive elements are reachable via keyboard and have a visible focus indicator (SC 2.4.11).
+- Provide single-pointer alternatives for dragging movements.
+
+### Step 4: Ensure Understandable Logic
+
+- Use consistent navigation patterns.
+- Provide descriptive error messages and suggestions for correction (SC 3.3.3).
+- Implement "Redundant Entry" (SC 3.3.7) to prevent asking for the same data twice.
+
+### Step 5: Verify Robust Compatibility
+
+- Use correct `Name, Role, Value` patterns.
+- Implement `aria-live` or live regions for dynamic status updates.
+
+## Accessibility Architecture Diagram
+
+```mermaid
+flowchart TD
+  UI["UI Component"] --> Platform{Platform?}
+  Platform -->|Web| ARIA["WAI-ARIA + HTML5"]
+  Platform -->|iOS| SwiftUI["Accessibility Traits + Labels"]
+  Platform -->|Android| Compose["Semantics + ContentDesc"]
+
+  ARIA --> AT["Assistive Technology (Screen Readers, Switches)"]
+  SwiftUI --> AT
+  Compose --> AT
+```
+
+## Cross-Platform Mapping
+
+| Feature            | Web (HTML/ARIA)          | iOS (SwiftUI)                        | Android (Compose)                                           |
+| :----------------- | :----------------------- | :----------------------------------- | :---------------------------------------------------------- |
+| **Primary Label**  | `aria-label` / `<label>` | `.accessibilityLabel()`              | `contentDescription`                                        |
+| **Secondary Hint** | `aria-describedby`       | `.accessibilityHint()`               | `Modifier.semantics { stateDescription = ... }`             |
+| **Action Role**    | `role="button"`          | `.accessibilityAddTraits(.isButton)` | `Modifier.semantics { role = Role.Button }`                 |
+| **Live Updates**   | `aria-live="polite"`     | `.accessibilityLiveRegion(.polite)`  | `Modifier.semantics { liveRegion = LiveRegionMode.Polite }` |
+
+## Examples
+
+### Web: Accessible Search
+
+```html
+<form role="search">
+  <label for="search-input" class="sr-only">Search products</label>
+  <input type="search" id="search-input" placeholder="Search..." />
+  <button type="submit" aria-label="Submit Search">
+    <svg aria-hidden="true">...</svg>
+  </button>
+</form>
+```
+
+### iOS: Accessible Action Button
+
+```swift
+Button(action: deleteItem) {
+    Image(systemName: "trash")
+}
+.accessibilityLabel("Delete item")
+.accessibilityHint("Permanently removes this item from your list")
+.accessibilityAddTraits(.isButton)
+```
+
+### Android: Accessible Toggle
+
+```kotlin
+Switch(
+    checked = isEnabled,
+    onCheckedChange = { onToggle() },
+    modifier = Modifier.semantics {
+        contentDescription = "Enable notifications"
+    }
+)
+```
+
+## Anti-Patterns to Avoid
+
+- **Div-Buttons**: Using a `<div>` or `<span>` for a click event without adding a role and keyboard support.
+- **Color-Only Meaning**: Indicating an error or status _only_ with a color change (e.g., turning a border red).
+- **Uncontained Modal Focus**: Modals that don't trap focus, allowing keyboard users to navigate background content while the modal is open. Focus must be contained _and_ escapable via the `Escape` key or an explicit close button (WCAG SC 2.1.2).
+- **Redundant Alt Text**: Using "Image of..." or "Picture of..." in alt text (screen readers already announce the role "Image").
+
+## Best Practices Checklist
+
+- [ ] Interactive elements meet the **24x24px** (Web) or **44x44pt** (Native) target size.
+- [ ] Focus indicators are clearly visible and high-contrast.
+- [ ] Modals **contain focus** while open, and release it cleanly on close (`Escape` key or close button).
+- [ ] Dropdowns and menus restore focus to the trigger element on close.
+- [ ] Forms provide text-based error suggestions.
+- [ ] All icon-only buttons have a descriptive text label.
+- [ ] Content reflows properly when text is scaled.
+
+## References
+
+- [WCAG 2.2 Guidelines](https://www.w3.org/TR/WCAG22/)
+- [WAI-ARIA Authoring Practices](https://www.w3.org/TR/wai-aria-practices/)
+- [iOS Accessibility Programming Guide](https://developer.apple.com/documentation/accessibility)
+- [iOS Human Interface Guidelines - Accessibility](https://developer.apple.com/design/human-interface-guidelines/accessibility)
+- [Android Accessibility Developer Guide](https://developer.android.com/guide/topics/ui/accessibility)
+
+## Related Skills
+
+- `frontend-patterns`
+- `design-system`
+- `liquid-glass-design`
+- `swiftui-patterns`