claude-code-arcane 1.0.0

package/skills/pdf-generator/scripts/render_cover.js

@@ -0,0 +1,111 @@
+#!/usr/bin/env node
+/**
+ * render_cover.js — Render cover.html → cover.pdf via Playwright.
+ *
+ * Usage:
+ *   node render_cover.js --input cover.html --out cover.pdf
+ *   node render_cover.js --input cover.html --out cover.pdf --wait 1200
+ *
+ * Exit codes: 0 success, 1 bad args, 2 dependency missing, 3 render error
+ */
+
+const path = require("path");
+const fs   = require("fs");
+
+function usage() {
+  console.error("Usage: node render_cover.js --input <file.html> --out <file.pdf> [--wait <ms>]");
+  process.exit(1);
+}
+
+// ── Arg parsing ────────────────────────────────────────────────────────────────
+const args = process.argv.slice(2);
+let inputFile = null, outFile = null, waitMs = 800;
+
+for (let i = 0; i < args.length; i++) {
+  if (args[i] === "--input" && args[i + 1]) { inputFile = args[++i]; }
+  else if (args[i] === "--out"   && args[i + 1]) { outFile   = args[++i]; }
+  else if (args[i] === "--wait"  && args[i + 1]) { waitMs    = parseInt(args[++i], 10); }
+}
+
+if (!inputFile || !outFile) usage();
+if (!fs.existsSync(inputFile)) {
+  console.error(JSON.stringify({ status: "error", error: `File not found: ${inputFile}` }));
+  process.exit(1);
+}
+
+// ── Playwright loader (tolerates global npm installs) ─────────────────────────
+function loadPlaywright() {
+  const { execSync } = require("child_process");
+  try { return require("playwright"); } catch (_) {}
+  try {
+    const root = execSync("npm root -g", { stdio: ["ignore","pipe","ignore"] }).toString().trim();
+    return require(path.join(root, "playwright"));
+  } catch (_) {}
+  console.error(JSON.stringify({
+    status: "error",
+    error: "playwright not found",
+    hint: "Run: npm install -g playwright && npx playwright install chromium"
+  }));
+  process.exit(2);
+}
+
+// ── Main ───────────────────────────────────────────────────────────────────────
+(async () => {
+  const { chromium } = loadPlaywright();
+
+  let browser;
+  try {
+    browser = await chromium.launch();
+  } catch (e) {
+    // Chromium binary missing — try installing
+    const { spawnSync } = require("child_process");
+    const r = spawnSync("npx", ["playwright", "install", "chromium"], { stdio: "inherit", shell: true });
+    if (r.status !== 0) {
+      console.error(JSON.stringify({
+        status: "error",
+        error: "Chromium not installed and auto-install failed",
+        hint: "Run: npx playwright install chromium"
+      }));
+      process.exit(2);
+    }
+    browser = await chromium.launch();
+  }
+
+  try {
+    const page = await browser.newPage();
+    const fileUrl = "file://" + path.resolve(inputFile);
+    await page.goto(fileUrl);
+    await page.waitForTimeout(waitMs);   // let CSS + any JS settle
+
+    await page.pdf({
+      path:            outFile,
+      width:           "794px",
+      height:          "1123px",
+      printBackground: true,
+    });
+
+    await browser.close();
+
+    // Basic sanity: output file must exist and be > 5 KB
+    const stat = fs.statSync(outFile);
+    if (stat.size < 5000) {
+      console.error(JSON.stringify({
+        status: "error",
+        error: "Output PDF is suspiciously small — cover may be blank",
+        hint:  "Check cover.html for render errors"
+      }));
+      process.exit(3);
+    }
+
+    console.log(JSON.stringify({
+      status: "ok",
+      out:    outFile,
+      size_kb: Math.round(stat.size / 1024),
+    }));
+
+  } catch (e) {
+    if (browser) await browser.close().catch(() => {});
+    console.error(JSON.stringify({ status: "error", error: String(e) }));
+    process.exit(3);
+  }
+})();

package/skills/perf-profile/SKILL.md

@@ -0,0 +1,82 @@
+---
+name: perf-profile
+description: "Performance profiling workflow: identify bottlenecks, measure against budgets, prioritize optimizations."
+category: "testing"
+argument-hint: "[system-name or 'full']"
+user-invocable: true
+agent: performance-analyst
+allowed-tools: Read, Glob, Grep, Bash
+---
+
+## Scope
+
+System name argument → profile that system. `full` → all systems.
+
+## Performance Budgets
+
+Load from design docs or CLAUDE.md. Typical targets:
+
+| Metric | Mobile (RN) | Web | Notes |
+|--------|-------------|-----|-------|
+| JS thread | <16.67ms/frame | — | 60fps budget |
+| TTI | <3s | <2s | Time to interactive |
+| Memory | <200MB | — | Per-app on device |
+| Bundle size | <10MB OTA | <200KB initial | Compressed |
+| Core Web Vitals | — | LCP<2.5s, FID<100ms, CLS<0.1 | Web only |
+
+## Tool Selection
+
+| Scenario | Tool | When to use |
+|----------|------|-------------|
+| React re-renders | React DevTools Profiler | Unnecessary renders, slow components |
+| JS thread bottlenecks | Flipper / Hermes profiler | Frame drops, slow interactions |
+| Native iOS perf | Xcode Instruments | Memory leaks, CPU spikes, energy |
+| Native Android perf | Android Studio Profiler | Memory, CPU, network on-device |
+| Web performance | Lighthouse + Chrome DevTools | CWV, bundle analysis, network |
+| Bundle bloat | `npx expo-doctor`, source-map-explorer | Large dependencies, tree-shaking |
+
+## What to Profile
+
+**CPU:** nested loops over large collections, string ops in hot paths, per-frame allocations, expensive bridge calls
+**Memory:** data structure growth, leaked refs, image/asset footprint, caches without eviction
+**Rendering:** overlapping views (overdraw), non-virtualized lists, animations not on UI thread, unoptimized images
+**I/O:** sync storage on main thread, network waterfalls, large payload serialization
+
+## Common Bottlenecks — Decision Table
+
+| Symptom | Likely cause | Fix approach |
+|---------|-------------|--------------|
+| Choppy scrolling | Non-virtualized list or heavy row render | FlatList/FlashList + memo rows |
+| Slow navigation | Heavy screen mount + data fetch | Prefetch + lazy load |
+| Memory climbs over time | Listener/subscription leaks | Cleanup in useEffect returns |
+| Large bundle | Unused deps or unshaken imports | Bundle analysis + code splitting |
+| Slow startup | Too much sync init work | Defer non-critical init, lazy imports |
+| Bridge spam | Frequent native↔JS calls | Batch operations, use JSI where possible |
+
+## Report Sections
+
+1. **Budget vs Actual** — table with OK / WARNING / OVER status
+2. **Hotspots** — location, issue, estimated impact, fix effort (S/M/L)
+3. **Recommendations** — priority-ordered with expected gain and risk
+4. **Quick Wins** — fixable in <1 hour
+5. **Needs Runtime Profiling** — static analysis cannot confirm
+
+For M/L effort hotspots, ask user: **Implement now** | **Reduce scope** (`/scope-check`) | **Defer** | **Escalate** (`/architecture-decision`)
+
+## Anti-patterns
+
+- Optimizing without measuring — gut feelings are unreliable
+- Profiling in dev mode — always use production/release builds
+- Ignoring memory leaks — they compound and cause OOM crashes
+- Recommendations without estimated impact — "make it faster" is not actionable
+- Profiling only on simulator — always validate on real target hardware
+- Premature optimization — profile first, optimize the proven bottleneck
+
+## Checklist
+
+- [ ] Performance budgets loaded from design docs or CLAUDE.md
+- [ ] Profiling tools selected matching the target platform and scenario
+- [ ] Bottlenecks measured with actual numbers compared against budget thresholds
+- [ ] Hotspot fixes prioritized by impact (estimated gain) and effort (S/M/L)
+- [ ] Report generated with Budget vs Actual table and OK/WARNING/OVER status
+- [ ] Items needing runtime profiling explicitly flagged as unconfirmed by static analysis

package/skills/performance/SKILL.md

@@ -0,0 +1,37 @@
+---
+name: performance
+description: "Rate limiting and caching strategy for backend services."
+category: "backend"
+argument-hint: "[rate-limit|cache|full]"
+user-invocable: true
+allowed-tools: ["Read", "Edit", "Write", "Bash", "Glob", "Grep"]
+---
+# performance — Rate Limiting & Caching Strategy
+
+Stack: Fastify + Prisma + PostgreSQL + Redis + Zod + TypeScript.
+
+## RATE LIMITING
+
+**Default algorithm:** Sliding Window Counter. Three tiers required: CDN/WAF, API Gateway, App Middleware (Redis). Use `rate-limiter-flexible` with Redis.
+
+> → Read references/rate-limit-config.md for algorithm comparison, implementation tiers, recommended limits per endpoint, key dimensions, response headers, and failure modes
+
+## CACHING
+
+**Rule Zero:** Before caching, profile. Caching hides problems a database index would solve. **Default pattern:** cache-aside. **Default invalidation:** short TTL.
+
+> → Read references/cache-strategy.md for cache layer decision table, TTL strategy, patterns, stampede prevention, HTTP headers, and Redis key conventions
+
+## ANTI-PATTERNS
+
+> → Read references/anti-patterns.md for rate limiting (7 items) and caching (11 items) anti-patterns
+
+## Checklist
+
+- [ ] Algorithm matches use case; all three tiers covered
+- [ ] Keys include user dimension; RateLimit-* headers + Retry-After on 429
+- [ ] Fail-open default, fail-closed for sensitive endpoints
+- [ ] Cache justified by profiling; TTL has explicit rationale
+- [ ] Invalidation strategy documented; stampede protection on hot paths
+- [ ] App works when Redis is down; hit/miss/eviction metrics exported
+- [ ] Redis key naming follows `domain:entity:id:variant` convention

package/skills/performance/references/anti-patterns.md

@@ -0,0 +1,25 @@
+# Anti-patterns - Performance (Rate Limiting & Caching)
+
+## Rate Limiting
+
+- Client-only limiting (bypassed)
+- In-memory counters on multi-pod (unsynchronized)
+- No user dimension in key
+- No limit on signup/forgot-password
+- 429 without Retry-After
+- Retries without jitter
+- Fail-closed everywhere
+
+## Caching
+
+- Caching without profiling
+- Infinite TTL without invalidation
+- Caching PII without `private, no-store`
+- Caching errors
+- Cache failure crashes app
+- `KEYS *` in prod (use SCAN)
+- No namespace in keys
+- Per-user in CDN without `Vary`
+- No hit/miss metrics
+- Mutable auth data with long TTL
+- Sessions in app memory

package/skills/performance/references/cache-strategy.md

@@ -0,0 +1,48 @@
+# Cache Strategy - Performance
+
+## Cache Layer Decision
+
+| Data Type | Layer |
+|-----------|-------|
+| Static assets | CDN + browser (immutable + versioned URLs) |
+| Public API responses | CDN + Redis (cache-aside, `s-maxage`) |
+| Per-user API responses | Redis + client (cache-aside, `private`) |
+| Config / feature flags | In-memory LRU (warm on boot, 30s TTL) |
+| DB query results | Redis (cache-aside) |
+| Sessions / tokens | Redis no-eviction (dedicated instance) |
+
+## TTL Strategy
+
+| Data | TTL | Rationale |
+|------|-----|-----------|
+| Versioned assets | 1 year | URL changes on content change |
+| Public listings | 5 min | Acceptable staleness |
+| Entity detail | 1 min | Editable by users |
+| User profile | 5 min | Invalidate on write |
+| Config / flags | 30 sec | Fast visibility |
+
+## Patterns
+
+- **cache-aside** (default): app checks cache, miss->DB->write cache
+- **read-through**: CDN/proxy handles
+- **write-through**: always fresh
+- **write-behind**: metrics only, data loss risk
+
+## Invalidation
+
+Default to **short TTL**. Add explicit invalidation (delete on write, event-driven pub/sub, versioned keys) only when TTL is insufficient.
+
+## Stampede Prevention
+
+Single-flight/mutex (one request loads, others wait), distributed lock (Redis SETNX), early probabilistic refresh, stale-while-revalidate.
+
+## HTTP Headers
+
+- Versioned assets: `public, max-age=31536000, immutable`
+- Public API: `public, s-maxage=300, stale-while-revalidate=3600`
+- Per-user/PII: `private, no-store`
+- Must-revalidate: `no-cache` + ETag
+
+## Redis Key Convention
+
+Key format: `<domain>:<entity>:<id>:<variant>`. Separate instances: cache (allkeys-lru), session (noeviction), queue.

package/skills/performance/references/rate-limit-config.md

@@ -0,0 +1,48 @@
+# Rate Limit Configuration - Performance
+
+## Algorithm Selection
+
+| Algorithm | Best For | Trade-off |
+|-----------|----------|-----------|
+| **Fixed Window** | Daily/monthly quotas | 2x burst at window boundary |
+| **Sliding Window Counter** | **Default** — most endpoints | ~10% approximation error |
+| **Token Bucket** | APIs where burst is useful | More config tuning |
+| **Leaky Bucket** | Smooth output (uploads) | No burst tolerance |
+
+## Implementation Tiers (all three required)
+
+| Tier | Scope | Catches |
+|------|-------|---------|
+| CDN / WAF | Global, L4-L7 | DDoS, bot challenges |
+| API Gateway / Ingress | Per-IP crude | Volumetric abuse pre-auth |
+| App Middleware (Redis) | Per-user, per-endpoint, per-plan | Authenticated abuse, plan limits |
+
+## Recommended Limits
+
+| Endpoint | Limit | Window | Key |
+|----------|-------|--------|-----|
+| POST /auth/login | 5 | 15min | ip + email |
+| POST /auth/signup | 3 | 1h | ip |
+| POST /auth/forgot-password | 3 | 1h | email |
+| Authenticated API | 1000 | 1min | user |
+| Anonymous API | 60 | 1min | ip |
+| Exports/reports | 10 | 1h | user |
+| LLM/AI endpoints | 30 | 1min | user + tenant |
+
+Start permissive, tighten with evidence. Use `rate-limiter-flexible` with Redis.
+
+## Key Dimensions
+
+`ip:<ip>` (unauth), `user:<userId>` (default auth), `endpoint:<route>:<userId>` (expensive), `action:<name>:<id>` (login/signup), `tenant:<orgId>` (multi-tenant). Combine when needed: `action:login:ip:<ip>` + `action:login:email:<email>`.
+
+## Response Headers
+
+Always include `X-RateLimit-Limit`, `X-RateLimit-Remaining`, `X-RateLimit-Reset`. On 429: add `Retry-After` (seconds), RFC 7807 problem+json body.
+
+## Failure Modes
+
+Fail-open default (allow all if Redis down). Fail-closed only for auth/payment/admin. Emit metric + alert on limiter failure.
+
+## Abuse Prevention
+
+Rate limit login by email (not just IP) for distributed brute force. Combine with temporary lockout. Escalate sustained 429 clusters to SIEM.

package/skills/performance-test/SKILL.md

@@ -0,0 +1,87 @@
+---
+name: performance-test
+description: "Performance y load testing para apps Educabot (Go/TS/React/RN): k6 scripts, smoke/load/stress/soak/spike, thresholds por SLO, CI integration, reporte."
+category: "testing"
+argument-hint: "[smoke|load|stress|soak|spike]"
+user-invocable: true
+allowed-tools: Read, Glob, Grep, Bash, Write, Edit, Task
+---
+# performance-test — Load & Performance Testing
+
+Framework basado en **k6** (Grafana Labs) — scripting JS, ejecución Go, integración Prometheus/Grafana.
+
+## Test Types
+
+| Tipo | Objetivo | Duración | VUs |
+|------|----------|----------|-----|
+| **Smoke** | Verificar sin error grueso | 1-2min | 1-5 |
+| **Load** | Carga esperada sostenida | 15-30min | N esperado |
+| **Stress** | Encontrar breaking point | 30-60min | Ramp hasta romper |
+| **Soak** | Degradación/leaks sostenido | 2-8h | N esperado |
+| **Spike** | Resiliencia picos súbitos | 5-15min | 0→10x→0 |
+
+## Project Structure
+
+```
+perf/k6/
+  config/envs.js, thresholds.js
+  lib/auth.js, data.js
+  scenarios/smoke.js, load-api.js, stress-login.js, soak-dashboard.js
+  results/  (gitignored)
+```
+
+## Thresholds from SLOs
+
+SLO availability 99.9% → `http_req_failed: rate<0.001`. SLO p95 <500ms → `http_req_duration: p(95)<500`. Test falla (exit 1) si no se cumple → gate en CI.
+
+## Execution
+
+```bash
+k6 run k6/scenarios/smoke.js
+BASE_URL=https://staging.educabot.com k6 run k6/scenarios/load-api.js
+k6 run -o experimental-prometheus-rw k6/scenarios/load-api.js
+```
+
+## CI Integration
+
+- Scheduled weekly (lunes 3am) con `workflow_dispatch` manual
+- **Solo smoke en PRs** — stress/soak en scheduled/manual
+- Upload `results/summary.json` como artifact
+
+## Key Metrics
+
+| Métrica | Qué significa |
+|---------|---------------|
+| `http_req_duration` | Latencia total (DNS+TCP+TLS+server) |
+| `http_req_waiting` | TTFB — latencia server |
+| `http_req_failed` | Error rate |
+| `iterations` | Completaciones del flow |
+
+## Quick Diagnosis
+
+| Señal | Probable causa |
+|-------|---------------|
+| p95 alto + error rate bajo | Server lento → profiler (pprof/clinic.js) |
+| Error rate sube con VUs | Saturación → pool DB, file descriptors, CPU |
+| p99 >> p95 | Long-tail → GC, cold cache, head-of-line blocking |
+| Throughput plateau | Bottleneck identificado (DB/CPU/red) |
+
+## Checklist
+
+- [ ] Avisar al team (Slack)
+- [ ] Confirmar env staging/perf (NO prod sin autorización)
+- [ ] Feature flags para disable paths destructivos
+- [ ] Monitorear dashboards en tiempo real
+- [ ] Plan rollback si rompe shared resources
+- [ ] Teardown data generada post-test
+
+## Anti-patterns
+
+- Load test contra prod sin aviso, thresholds sin relación a SLO
+- Stress en cada PR (ruidoso, costoso), test users compartidos con reales
+- Sin think time (tráfico irreal), confundir VUs = RPS
+- No limpiar data generada, correr desde laptop (red falsea p95)
+
+## Grafana Dashboard
+
+Import template ID 19665 (k6 Prometheus): RPS por endpoint, p50/p95/p99, error rate por status, VUs vs throughput.

package/skills/playtest-report/SKILL.md

@@ -0,0 +1,45 @@
+---
+name: playtest-report
+description: "Generates a structured playtest report template or analyzes existing playtest notes into a structured format. Use this to standardize playtest feedback collection and analysis."
+category: "gamedev"
+argument-hint: "[new|analyze path-to-notes] [--review full|lean|solo]"
+user-invocable: true
+allowed-tools: Read, Glob, Grep, Write, Task, AskUserQuestion
+---
+
+## Phase 1: Parse Arguments
+
+Resolve review mode: `--review` arg > `production/review-mode.txt` > default `lean`. See `.claude/docs/director-gates.md`.
+
+Modes: `new` → blank template, `analyze [path]` → structured findings from raw notes.
+
+## Phase 2A: New Template Mode
+
+Generate template with sections: Session Info (date, build, duration, tester, platform, input method, session type), Test Focus, First Impressions (understood goal/controls, emotional response), Gameplay Flow (worked well, pain points with severity, confusion points, moments of delight), Bugs Encountered (table: description, severity, reproducible), Feature-Specific Feedback (per feature: understood purpose, engaging, suggestions), Quantitative Data (deaths, time per area, items used, features discovered vs missed), Overall Assessment (play again, difficulty, pacing, session length), Top 3 Priorities.
+
+## Phase 2B: Analyze Mode
+
+Read raw notes. Cross-reference with design documents. Fill template with structured findings. Flag observations that conflict with design intent.
+
+## Phase 3: Action Routing
+
+| Bucket | Route |
+|--------|-------|
+| Design changes | `/propagate-design-change [path]` for downstream impacts |
+| Balance adjustments | `/balance-check [system]` before tuning |
+| Bugs | `/bug-report` to formally track |
+| Polish items | Add to `production/` polish backlog |
+
+## Phase 3b: Creative Director Review
+
+Review mode: `solo`/`lean` → skip CD-PLAYTEST. `full` → spawn `creative-director` via Task with gate CD-PLAYTEST. Pass report, pillars/core fantasy, hypothesis. Add `## Creative Director Assessment` if CONCERNS/REJECT.
+
+## Phase 4: Save Report
+
+Ask to write to `production/qa/playtests/playtest-[date]-[tester].md`.
+
+## Phase 5: Next Steps
+
+- Act on highest-priority finding category first
+- Design changes → `/design-review` on updated GDD
+- Bugs → `/bug-triage` to update priorities

package/skills/playwright-pro/.mcp.json

@@ -0,0 +1,27 @@
+{
+  "mcpServers": {
+    "pw-testrail": {
+      "command": "npx",
+      "args": [
+        "tsx",
+        "${CLAUDE_PLUGIN_ROOT}/integrations/testrail-mcp/src/index.ts"
+      ],
+      "env": {
+        "TESTRAIL_URL": "${TESTRAIL_URL}",
+        "TESTRAIL_USER": "${TESTRAIL_USER}",
+        "TESTRAIL_API_KEY": "${TESTRAIL_API_KEY}"
+      }
+    },
+    "pw-browserstack": {
+      "command": "npx",
+      "args": [
+        "tsx",
+        "${CLAUDE_PLUGIN_ROOT}/integrations/browserstack-mcp/src/index.ts"
+      ],
+      "env": {
+        "BROWSERSTACK_USERNAME": "${BROWSERSTACK_USERNAME}",
+        "BROWSERSTACK_ACCESS_KEY": "${BROWSERSTACK_ACCESS_KEY}"
+      }
+    }
+  }
+}

package/skills/playwright-pro/CLAUDE.md

@@ -0,0 +1,84 @@
+# Playwright Pro — Agent Context
+
+You are working in a project with the Playwright Pro plugin installed. Follow these rules for all test-related work.
+
+## Golden Rules (Non-Negotiable)
+
+1. **`getByRole()` over CSS/XPath** — resilient to markup changes, mirrors how users see the page
+2. **Never `page.waitForTimeout()`** — use `expect(locator).toBeVisible()` or `page.waitForURL()`
+3. **Web-first assertions** — `expect(locator)` auto-retries; `expect(await locator.textContent())` does not
+4. **Isolate every test** — no shared state, no execution-order dependencies
+5. **`baseURL` in config** — zero hardcoded URLs in tests
+6. **Retries: `2` in CI, `0` locally** — surface flakiness where it matters
+7. **Traces: `'on-first-retry'`** — rich debugging without CI slowdown
+8. **Fixtures over globals** — share state via `test.extend()`, not module-level variables
+9. **One behavior per test** — multiple related `expect()` calls are fine
+10. **Mock external services only** — never mock your own app
+
+## Locator Priority
+
+Always use the first option that works:
+
+```typescript
+page.getByRole('button', { name: 'Submit' })        // 1. Role (default)
+page.getByLabel('Email address')                     // 2. Label (form fields)
+page.getByText('Welcome back')                       // 3. Text (non-interactive)
+page.getByPlaceholder('Search...')                    // 4. Placeholder
+page.getByAltText('Company logo')                    // 5. Alt text (images)
+page.getByTitle('Close dialog')                      // 6. Title attribute
+page.getByTestId('checkout-summary')                 // 7. Test ID (last semantic)
+page.locator('.legacy-widget')                       // 8. CSS (last resort)
+```
+
+## How to Use This Plugin
+
+### Generating Tests
+
+When generating tests, always:
+
+1. Use the `Explore` subagent to scan the project structure first
+2. Check `playwright.config.ts` for `testDir`, `baseURL`, and project settings
+3. Load relevant templates from `templates/` directory
+4. Match the project's language (check for `tsconfig.json` → TypeScript, else JavaScript)
+5. Place tests in the configured `testDir` (default: `tests/` or `e2e/`)
+6. Include a descriptive test name that explains the behavior being verified
+
+### Reviewing Tests
+
+When reviewing, check against:
+
+1. All 10 golden rules above
+2. The anti-patterns in `skills/review/anti-patterns.md`
+3. Missing edge cases (empty state, error state, loading state)
+4. Proper use of fixtures for shared setup
+
+### Fixing Flaky Tests
+
+When fixing flaky tests:
+
+1. Categorize first: timing, isolation, environment, or infrastructure
+2. Use `npx playwright test <file> --repeat-each=10` to reproduce
+3. Use `--trace=on` for every attempt
+4. Apply the targeted fix from `skills/fix/flaky-taxonomy.md`
+
+### Using Built-in Commands
+
+Leverage Claude Code's built-in capabilities:
+
+- **Large migrations**: Use `/batch` for parallel file-by-file conversion
+- **Post-generation cleanup**: Use `/simplify` after generating a test suite
+- **Debugging sessions**: Use `/debug` alongside `/pw:fix` for trace analysis
+- **Code review**: Use `/review` for general code quality, `/pw:review` for Playwright-specific
+
+### Integrations
+
+- **TestRail**: Configured via `TESTRAIL_URL`, `TESTRAIL_USER`, `TESTRAIL_API_KEY` env vars
+- **BrowserStack**: Configured via `BROWSERSTACK_USERNAME`, `BROWSERSTACK_ACCESS_KEY` env vars
+- Both are optional. The plugin works fully without them.
+
+## File Conventions
+
+- Test files: `*.spec.ts` or `*.spec.js`
+- Page objects: `*.page.ts` in a `pages/` directory
+- Fixtures: `fixtures.ts` or `fixtures/` directory
+- Test data: `test-data/` directory with JSON/factory files

package/skills/playwright-pro/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Reza Rezvani
+
+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.