opencode-skills-collection 3.0.34 → 3.0.36

package/bundled-skills/.antigravity-install-manifest.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "updatedAt": "2026-06-02T02:29:56.350Z",
+  "updatedAt": "2026-06-04T02:31:57.779Z",
   "entries": [
     "00-andruia-consultant",
     "007",
@@ -10,6 +10,9 @@
     "ab-test-setup",
     "acceptance-orchestrator",
     "accessibility-compliance-accessibility-audit",
+    "accesslint-audit",
+    "accesslint-diff",
+    "accesslint-scan",
     "active-directory-attacks",
     "activecampaign-automation",
     "ad-creative",
@@ -377,6 +380,7 @@
     "competitive-landscape",
     "competitor-alternatives",
     "complexity-cuts",
+    "composition-patterns",
     "comprehensive-review-full-review",
     "comprehensive-review-pr-enhance",
     "computer-use-agents",
@@ -458,6 +462,7 @@
     "debug-buttercup",
     "debugger",
     "debugging-strategies",
+    "debugging-toolkit",
     "debugging-toolkit-smart-debug",
     "decision-navigator",
     "deep-research",
@@ -465,6 +470,7 @@
     "defuddle",
     "dependency-management-deps-audit",
     "dependency-upgrade",
+    "deploy-to-vercel",
     "deployment-engineer",
     "deployment-pipeline-design",
     "deployment-procedures",
@@ -1029,6 +1035,7 @@
     "plotly",
     "podcast-generation",
     "polars",
+    "polis-protocol",
     "popup-cro",
     "posix-shell-pro",
     "postgres-best-practices",
@@ -1073,6 +1080,7 @@
     "pydantic-ai",
     "pydantic-models-py",
     "pypict-skill",
+    "python-development",
     "python-development-python-scaffold",
     "python-fastapi-development",
     "python-packaging",
@@ -1095,6 +1103,7 @@
     "react-flow-node-ts",
     "react-modernization",
     "react-native-architecture",
+    "react-native-skills",
     "react-nextjs-development",
     "react-patterns",
     "react-state-management",
@@ -1240,6 +1249,7 @@
     "skill-developer",
     "skill-improver",
     "skill-installer",
+    "skill-issue",
     "skill-optimizer",
     "skill-rails-upgrade",
     "skill-router",
@@ -1317,6 +1327,7 @@
     "tcm-constitution-analyzer",
     "tdd-orchestrator",
     "tdd-workflow",
+    "tdd-workflows",
     "tdd-workflows-tdd-cycle",
     "tdd-workflows-tdd-green",
     "tdd-workflows-tdd-red",
@@ -1399,6 +1410,7 @@
     "unsplash-integration",
     "upgrading-expo",
     "upstash-qstash",
+    "user-thoughts",
     "using-git-worktrees",
     "using-neon",
     "using-superpowers",
@@ -1416,7 +1428,10 @@
     "vector-index-tuning",
     "vercel-ai-sdk-expert",
     "vercel-automation",
+    "vercel-cli-with-tokens",
     "vercel-deployment",
+    "vercel-optimize",
+    "vercel-react-view-transitions",
     "verification-before-completion",
     "vexor",
     "vexor-cli",

package/bundled-skills/accesslint-audit/SKILL.md

@@ -0,0 +1,115 @@
+---
+name: accesslint-audit
+description: "Find and fix WCAG 2.2 accessibility issues. Two modes — report (sweep a codebase or page, produce a prioritized written report, no edits) and fix (audit→edit→verify loop on a target). Prefers direct-CDP live-DOM auditing; falls back to a browser-MCP composition or HTML-string audits."
+risk: safe
+source: "https://github.com/AccessLint/skills"
+date_added: "2026-06-02"
+---
+
+You audit accessibility and optionally fix what's broken.
+
+## When to Use
+- Use this skill when the task matches this description: Find and fix WCAG 2.2 accessibility issues. Two modes — report (sweep a codebase or page, produce a prioritized written report, no edits) and fix (audit→edit→verify loop on a target). Prefers direct-CDP live-DOM auditing; falls back to a browser-MCP composition or HTML-string audits.
+
+## Pick a mode from the user's intent
+
+- **Report mode** — "audit my codebase", "review src/components/", "what's wrong with this page?", "give me an a11y report". You audit + write a report. **You do not edit files.**
+- **Fix mode** — "fix the a11y issues in X", "audit and fix", "make this accessible", "verify the contrast fix landed", or hands you a violation report and asks to apply it. You audit → edit → verify.
+
+If unsure, ask. Don't default-to-fix when the user only asked for an audit.
+
+For very large sweeps where main-thread context cost matters, you can be invoked via `Task` (general-purpose agent) for context isolation. The recipe is the same either way.
+
+## Picking a flow
+
+Three flows, in order of preference.
+
+1. **`audit_live`** — try first for any URL. Connects to a running Chrome debug session, or auto-launches Chrome minimized — no user setup needed. Single call; IIFE bytes don't enter your context.
+2. **`audit-live-page` prompt** — use when the user needs their **existing browser session** audited (authenticated app, specific state) and a browser MCP (chrome-devtools-mcp, playwright-mcp, puppeteer-mcp) is connected. Invoke via `Skill` with `mode: "fix"` or `mode: "plan"`.
+3. **`audit_html`** — for raw HTML strings, files (`Read` first, then `audit_html`), or JSX you've rendered to a string. Pair with `audit_diff({ html })` for fix-mode verification.
+
+For non-URL targets, skip straight to flow 3. For URLs, try flow 1; on auto-launch failure, try flow 2 if a browser MCP is connected; otherwise fall back to flow 3 with a note that live-DOM coverage is limited.
+
+## Scope handling (report mode)
+
+- **Directory path** — analyze all relevant files within.
+- **Multiple files** — analyze the listed files plus imports they reach.
+- **A URL** — audit it. If it's a dev-server URL, that's flow 1 or 2.
+- **No arguments** — ask the user to narrow scope. Whole-codebase sweeps are rarely the right thing.
+
+State the scope explicitly at the start of your report.
+
+## Approach (report mode)
+
+1. **Map the surface.** Glob/Grep to enumerate components, templates, styles. Sample representative files; don't open everything blindly.
+2. **Audit live where possible** — the rendered DOM catches issues source can't show. Use the flow picker above.
+3. **Look for patterns.** If one component fails a rule, similar components likely do too. Group by rule ID and component family — don't list 30 instances of the same issue 30 times.
+4. **Prioritize by user impact.** Critical/serious first. Many low-impact violations of one rule are often a single root-cause fix.
+5. **Use `format: "compact"` for sweep-time calls.** Reserve verbose output for rules you'll expand in the report.
+6. **Trust `Source:` lines.** Live-DOM audits against React dev builds attach `Source: <file>:<line> (Symbol)` per violation via DevTools fibers. Use it as the file pointer instead of grepping selectors. Fall back to stable hooks → visible text → tree position when absent.
+7. **Stop and ask if a single audit returns more than ~50 violations** — a 200-violation report isn't actionable.
+
+The engine catches what's mechanically detectable. Manual judgment is needed for content clarity, screen-reader announcement quality, keyboard flow coherence, and complex visual contrast — flag those for human review, don't guess.
+
+### Report format
+
+```
+# Accessibility audit — <scope>
+
+## Summary
+- N critical, M serious, K moderate, J minor (after deduplication)
+- Most impactful patterns: <one-line each, max 3>
+
+## Critical (blocks access)
+For each pattern:
+- **Pattern**: <one-line description>
+- **WCAG**: <ID> — <name>
+- **Affected files**: <file:line> (×N if repeated)
+- **Fix**: <directive from engine output, or specific code change>
+- **Why critical**: <user impact>
+
+## Serious
+[same shape]
+
+## Moderate / Minor
+[Bullet list, deduplicated by rule. Skip per-instance detail unless the fix differs.]
+
+## Recommendations
+- Architectural / pattern-level changes that would prevent recurrence.
+- Tooling or component abstractions worth introducing.
+- What to verify manually (screen reader, keyboard, low-vision testing).
+
+## Positive findings
+What the codebase does well — short, factual, reinforces practices to keep.
+```
+
+Include rule IDs in every entry. Quote the `Fix:` directive verbatim for `mechanical` rules. For `visual` / `contextual`, leave a `TODO` with the rule ID; don't invent content.
+
+## Recipe (fix mode)
+
+1. **Baseline.** Audit with `name: "before"` and `format: "compact"`.
+2. **Plan + apply.** For each violation:
+   - `Source:` line present → open that file at that line. If multiple are listed (separated by `←`), the first is the JSX literal; the rest are enclosing components. Use `Symbol` to disambiguate.
+   - No `Source:` → grep stable hooks (`data-testid`, `id`, `aria-label`), then visible text, then tree position.
+   - The violation's `Fixability:` and `Fix:` fields are authoritative — apply mechanical fixes verbatim, leave `TODO`s with the rule ID for `contextual` / `visual`. Never invent content.
+   - Group same-file edits into one operation.
+   - Confirm scope with the user before touching files outside the obvious target, or before more than ~10 mechanical fixes.
+3. **Verify.** Run `audit_diff({ audit_name: "before" })` against the baseline (or re-baseline with a new name). Confirm `-fixed` covers your targets and `+new` is empty.
+
+`Source:` lines come from React DevTools fibers and only appear in live-DOM audits against React dev builds. Static audits won't have them — fall back to selectors.
+
+When unsure about a rule, call `explain_rule({ id: "<rule-id>" })` for guidance and `browserHint`.
+
+## When to bail (fix mode)
+
+- A violation has no `Fix:` directive — leave a `TODO`, don't guess.
+- Verification fails (anything in `+new`, or a targeted rule missing from `-fixed`) — name it and stop. Do not iterate silently.
+
+## Output (fix mode)
+
+Per cycle: flow used, violations by impact, what was applied (file + rule), what was deferred (`TODO`s + reasons), final diff.
+
+## Limitations
+- Use this skill only when the task clearly matches the scope described above.
+- Do not treat the output as a substitute for environment-specific validation, testing, or expert review.
+- Stop and ask for clarification if required inputs, permissions, safety boundaries, or success criteria are missing.

package/bundled-skills/accesslint-diff/SKILL.md

@@ -0,0 +1,81 @@
+---
+name: accesslint-diff
+description: "Diff a live page's accessibility violations against a baseline — by default compares uncommitted changes (stash-based), or pass --branch [<name>] to diff against a branch. Reports only new violations introduced, violations fixed, and pre-existing count. Use `scan` for a full audit with no diffing."
+risk: safe
+source: "https://github.com/AccessLint/skills"
+date_added: "2026-06-02"
+---
+
+Default branch: !`git symbolic-ref refs/remotes/origin/HEAD --short 2>/dev/null | sed 's|.*/||' || echo main`
+
+Report only what changed. Locate; don't fix. If no URL in `$ARGUMENTS`, ask for one.
+
+Parse `$ARGUMENTS`: strip `--branch <name>` if present → branch mode. If `--branch` has no value, use the default branch above. Remainder is the URL.
+
+## When to Use
+- Use this skill when the task matches this description: Diff a live page's accessibility violations against a baseline — by default compares uncommitted changes (stash-based), or pass --branch [<name>] to diff against a branch. Reports only new violations introduced, violations fixed, and pre-existing count. Use `scan` for a full audit with no diffing.
+
+## 1. Audit
+
+```bash
+PORT=$(npx -y @accesslint/chrome@latest ensure | node -e 'process.stdin.on("data",d=>process.stdout.write(""+JSON.parse(d).port))')
+```
+
+**Stash mode** (default — uncommitted changes). Tell the user first: _"Running in diff mode — stashing your changes to capture a baseline, then restoring. Your working tree will be fully restored."_ If `git stash push` fails, warn and exit.
+
+```bash
+git stash push -u -m "accesslint-diff-baseline"
+npx -y @accesslint/cli@latest "<url>" --port "$PORT" --snapshot accesslint-diff --snapshot-dir /tmp --update-snapshot
+git stash pop && sleep 2
+npx -y @accesslint/cli@latest "<url>" --port "$PORT" --snapshot accesslint-diff --snapshot-dir /tmp --format json
+```
+
+**Branch mode** (`--branch <name>`). Tell the user first: _"Diffing against `<name>` — checking out that branch to capture a baseline, then restoring. Your working tree will be fully restored."_
+
+Branch switching triggers a rebuild but not a browser reload — the CLI opens a fresh tab each time so it always reads the current build. Use `--wait-for "<selector>"` to gate the audit until the rebuild is ready; without it, warn the user that a slow build may yield a stale baseline.
+
+```bash
+git diff --quiet && git diff --cached --quiet || git stash push -u -m "accesslint-diff-branch"
+git checkout <branch>
+npx -y @accesslint/cli@latest "<url>" --port "$PORT" --snapshot accesslint-diff --snapshot-dir /tmp --update-snapshot [--wait-for "<selector>"]
+git checkout - && git stash pop 2>/dev/null
+npx -y @accesslint/cli@latest "<url>" --port "$PORT" --snapshot accesslint-diff --snapshot-dir /tmp --format json [--wait-for "<selector>"]
+```
+
+Pass `--selector`, `--include-aaa` to **both** runs.
+
+## 2. Report
+
+```
+Accessibility diff — http://localhost:3000/ vs main (94 rules, live DOM)
+2 new · 1 fixed · 4 pre-existing hidden
+
+New — Critical
+- color-contrast — 2.1:1 (needs 4.5:1), #bbb on #fff
+    where: main > p.subtitle   fix: darken to #767676
+Fixed
+- img-alt — <img src="old.jpg"> (no longer present)
+```
+
+Each new violation: **where** (selector verbatim + `file:line (symbol)` if `source` present — never fabricate), **evidence**, **fix** (mechanical change or `NEEDS HUMAN`).
+
+Don't edit. For fixes: apply mechanical ones then re-run `accesslint:diff` to verify; for bulk work hand off to `accesslint:audit`.
+
+## 3. Tear down
+
+```bash
+npx -y @accesslint/chrome@latest stop --all  # skip if ensure reported "managed":false
+```
+
+## Gotchas
+
+- `ensure` always determines the port — never hardcode 9222.
+- CLI exit 2 = bad URL or page never loaded; check the dev server.
+- Stash mode: `sleep 2` covers most HMR cases; if baseline looks identical to current, add `--wait-for "<selector>"`.
+- Branch mode: no HMR — CLI opens a fresh tab each run. `--wait-for` is the rebuild gate.
+- Heavy DOM changes between runs cause selector drift — re-run with `accesslint:scan` for the full picture.
+
+## Limitations
+- Use this skill only when the task clearly matches the scope described above.
+- Do not treat the output as a substitute for environment-specific validation, testing, or expert review.
+- Stop and ask for clarification if required inputs, permissions, safety boundaries, or success criteria are missing.

package/bundled-skills/accesslint-scan/SKILL.md

@@ -0,0 +1,47 @@
+---
+name: accesslint-scan
+description: "Audit a live page for accessibility issues, locate each WCAG violation precisely, and return a selector-grounded fix worklist without editing."
+risk: safe
+source: "https://github.com/AccessLint/skills"
+date_added: "2026-06-02"
+---
+
+Audit a live page and report what's broken and where. Locate; don't fix. If no URL in `$ARGUMENTS`, ask for one.
+
+## When to Use
+- Use this skill when the task matches this description: Audit a live page for accessibility issues, locate each WCAG violation precisely, and return a selector-grounded fix worklist without editing.
+
+## 1. Audit
+
+```bash
+PORT=$(npx -y @accesslint/chrome@latest ensure | node -e 'process.stdin.on("data",d=>process.stdout.write(""+JSON.parse(d).port))')
+npx -y @accesslint/cli@latest "<url>" --port "$PORT" --format json
+```
+
+Flags as needed: `--selector`, `--wait-for "<selector>"`, `--include-aaa`, `--disable <rules>`.
+
+## 2. Report
+
+Counts by impact, then one entry per violation:
+
+- **where** — selector verbatim + `file:line (symbol)` if `source` is present — never fabricate. If no violation has `source`, note "source mapping unavailable — located by selector only".
+- **evidence** — contrast ratio, missing attribute, empty name
+- **fix** — mechanical change or `NEEDS HUMAN`
+
+Don't edit. For fixes: apply mechanical ones then re-run to verify; for bulk work hand off to `accesslint:audit`.
+
+## 3. Tear down
+
+```bash
+npx -y @accesslint/chrome@latest stop --all  # skip if ensure reported "managed":false
+```
+
+## Gotchas
+
+- `ensure` always determines the port — never hardcode 9222.
+- CLI exit 2 = bad URL or page never loaded; check the dev server.
+
+## Limitations
+- Use this skill only when the task clearly matches the scope described above.
+- Do not treat the output as a substitute for environment-specific validation, testing, or expert review.
+- Stop and ask for clarification if required inputs, permissions, safety boundaries, or success criteria are missing.

package/bundled-skills/composition-patterns/SKILL.md

@@ -0,0 +1,87 @@
+---
+name: composition-patterns
+description: "Use when working with composition-patterns tasks or workflows"
+risk: safe
+source: "https://github.com/vercel-labs/agent-skills"
+date_added: "2026-06-02"
+---
+
+# React Composition Patterns
+
+Composition patterns for building flexible, maintainable React components. Avoid
+boolean prop proliferation by using compound components, lifting state, and
+composing internals. These patterns make codebases easier for both humans and AI
+agents to work with as they scale.
+
+## When to Use
+Reference these guidelines when:
+
+- Refactoring components with many boolean props
+- Building reusable component libraries
+- Designing flexible component APIs
+- Reviewing component architecture
+- Working with compound components or context providers
+
+## Rule Categories by Priority
+
+| Priority | Category                | Impact | Prefix          |
+| -------- | ----------------------- | ------ | --------------- |
+| 1        | Component Architecture  | HIGH   | `architecture-` |
+| 2        | State Management        | MEDIUM | `state-`        |
+| 3        | Implementation Patterns | MEDIUM | `patterns-`     |
+| 4        | React 19 APIs           | MEDIUM | `react19-`      |
+
+## Quick Reference
+
+### 1. Component Architecture (HIGH)
+
+- `architecture-avoid-boolean-props` - Don't add boolean props to customize
+  behavior; use composition
+- `architecture-compound-components` - Structure complex components with shared
+  context
+
+### 2. State Management (MEDIUM)
+
+- `state-decouple-implementation` - Provider is the only place that knows how
+  state is managed
+- `state-context-interface` - Define generic interface with state, actions, meta
+  for dependency injection
+- `state-lift-state` - Move state into provider components for sibling access
+
+### 3. Implementation Patterns (MEDIUM)
+
+- `patterns-explicit-variants` - Create explicit variant components instead of
+  boolean modes
+- `patterns-children-over-render-props` - Use children for composition instead
+  of renderX props
+
+### 4. React 19 APIs (MEDIUM)
+
+> **⚠️ React 19+ only.** Skip this section if using React 18 or earlier.
+
+- `react19-no-forwardref` - Don't use `forwardRef`; use `use()` instead of `useContext()`
+
+## How to Use
+
+Read individual rule files for detailed explanations and code examples:
+
+```
+rules/architecture-avoid-boolean-props.md
+rules/state-context-interface.md
+```
+
+Each rule file contains:
+
+- Brief explanation of why it matters
+- Incorrect code example with explanation
+- Correct code example with explanation
+- Additional context and references
+
+## Full Compiled Document
+
+For the complete guide with all rules expanded: `AGENTS.md`
+
+## Limitations
+- Use this skill only when the task clearly matches the scope described above.
+- Do not treat the output as a substitute for environment-specific validation, testing, or expert review.
+- Stop and ask for clarification if required inputs, permissions, safety boundaries, or success criteria are missing.

package/bundled-skills/composition-patterns/rules/_sections.md

@@ -0,0 +1,29 @@
+# Sections
+
+This file defines all sections, their ordering, impact levels, and descriptions.
+The section ID (in parentheses) is the filename prefix used to group rules.
+
+---
+
+## 1. Component Architecture (architecture)
+
+**Impact:** HIGH  
+**Description:** Fundamental patterns for structuring components to avoid prop
+proliferation and enable flexible composition.
+
+## 2. State Management (state)
+
+**Impact:** MEDIUM  
+**Description:** Patterns for lifting state and managing shared context across
+composed components.
+
+## 3. Implementation Patterns (patterns)
+
+**Impact:** MEDIUM  
+**Description:** Specific techniques for implementing compound components and
+context providers.
+
+## 4. React 19 APIs (react19)
+
+**Impact:** MEDIUM  
+**Description:** React 19+ only. Don't use `forwardRef`; use `use()` instead of `useContext()`.

package/bundled-skills/composition-patterns/rules/_template.md

@@ -0,0 +1,24 @@
+---
+title: Rule Title Here
+impact: MEDIUM
+impactDescription: brief description of impact
+tags: composition, components
+---
+
+## Rule Title Here
+
+Brief explanation of the rule and why it matters.
+
+**Incorrect:**
+
+```tsx
+// Bad code example
+```
+
+**Correct:**
+
+```tsx
+// Good code example
+```
+
+Reference: [Link](https://example.com)

package/bundled-skills/composition-patterns/rules/architecture-avoid-boolean-props.md

@@ -0,0 +1,100 @@
+---
+title: Avoid Boolean Prop Proliferation
+impact: CRITICAL
+impactDescription: prevents unmaintainable component variants
+tags: composition, props, architecture
+---
+
+## Avoid Boolean Prop Proliferation
+
+Don't add boolean props like `isThread`, `isEditing`, `isDMThread` to customize
+component behavior. Each boolean doubles possible states and creates
+unmaintainable conditional logic. Use composition instead.
+
+**Incorrect (boolean props create exponential complexity):**
+
+```tsx
+function Composer({
+  onSubmit,
+  isThread,
+  channelId,
+  isDMThread,
+  dmId,
+  isEditing,
+  isForwarding,
+}: Props) {
+  return (
+    <form>
+      <Header />
+      <Input />
+      {isDMThread ? (
+        <AlsoSendToDMField id={dmId} />
+      ) : isThread ? (
+        <AlsoSendToChannelField id={channelId} />
+      ) : null}
+      {isEditing ? (
+        <EditActions />
+      ) : isForwarding ? (
+        <ForwardActions />
+      ) : (
+        <DefaultActions />
+      )}
+      <Footer onSubmit={onSubmit} />
+    </form>
+  )
+}
+```
+
+**Correct (composition eliminates conditionals):**
+
+```tsx
+// Channel composer
+function ChannelComposer() {
+  return (
+    <Composer.Frame>
+      <Composer.Header />
+      <Composer.Input />
+      <Composer.Footer>
+        <Composer.Attachments />
+        <Composer.Formatting />
+        <Composer.Emojis />
+        <Composer.Submit />
+      </Composer.Footer>
+    </Composer.Frame>
+  )
+}
+
+// Thread composer - adds "also send to channel" field
+function ThreadComposer({ channelId }: { channelId: string }) {
+  return (
+    <Composer.Frame>
+      <Composer.Header />
+      <Composer.Input />
+      <AlsoSendToChannelField id={channelId} />
+      <Composer.Footer>
+        <Composer.Formatting />
+        <Composer.Emojis />
+        <Composer.Submit />
+      </Composer.Footer>
+    </Composer.Frame>
+  )
+}
+
+// Edit composer - different footer actions
+function EditComposer() {
+  return (
+    <Composer.Frame>
+      <Composer.Input />
+      <Composer.Footer>
+        <Composer.Formatting />
+        <Composer.Emojis />
+        <Composer.CancelEdit />
+        <Composer.SaveEdit />
+      </Composer.Footer>
+    </Composer.Frame>
+  )
+}
+```
+
+Each variant is explicit about what it renders. We can share internals without
+sharing a single monolithic parent.