@khalidsaidi/skillrunner 0.1.2 → 0.1.3

package/dist/registry/skills/openai-cloudflare-deploy/upstream/references/wrangler/patterns.md

@@ -0,0 +1,209 @@
+# Wrangler Development Patterns
+
+Common workflows and best practices.
+
+## New Worker Project
+
+```bash
+wrangler init my-worker && cd my-worker
+wrangler dev              # Develop locally
+wrangler deploy           # Deploy
+```
+
+## Local Development
+
+```bash
+wrangler dev              # Local mode (fast, simulated)
+wrangler dev --remote     # Remote mode (production-accurate)
+wrangler dev --env staging --port 8787
+wrangler dev --inspector-port 9229  # Enable debugging
+```
+
+Debug: chrome://inspect → Configure → localhost:9229
+
+## Secrets
+
+```bash
+# Production
+echo "secret-value" | wrangler secret put SECRET_KEY
+
+# Local: use .dev.vars (gitignored)
+# SECRET_KEY=local-dev-key
+```
+
+## Adding KV
+
+```bash
+wrangler kv namespace create MY_KV
+wrangler kv namespace create MY_KV --preview
+# Add to wrangler.jsonc: { "binding": "MY_KV", "id": "abc123" }
+wrangler deploy
+```
+
+## Adding D1
+
+```bash
+wrangler d1 create my-db
+wrangler d1 migrations create my-db "initial_schema"
+# Edit migration file in migrations/, then:
+wrangler d1 migrations apply my-db --local
+wrangler deploy
+wrangler d1 migrations apply my-db --remote
+
+# Time Travel (restore to point in time)
+wrangler d1 time-travel restore my-db --timestamp 2025-01-01T12:00:00Z
+```
+
+## Multi-Environment
+
+```bash
+wrangler deploy --env staging
+wrangler deploy --env production
+```
+
+```jsonc
+{ "env": { "staging": { "vars": { "ENV": "staging" } } } }
+```
+
+## Testing
+
+### Integration Tests with Node.js Test Runner
+
+```typescript
+import { startWorker } from "wrangler";
+import { describe, it, before, after } from "node:test";
+import assert from "node:assert";
+
+describe("API", () => {
+  let worker;
+  
+  before(async () => {
+    worker = await startWorker({ 
+      config: "wrangler.jsonc",
+      remote: "minimal"  // Fast tests with real bindings
+    });
+  });
+  
+  after(async () => await worker.dispose());
+  
+  it("creates user", async () => {
+    const response = await worker.fetch("http://example.com/api/users", {
+      method: "POST",
+      body: JSON.stringify({ name: "Alice" })
+    });
+    assert.strictEqual(response.status, 201);
+  });
+});
+```
+
+### Testing with Vitest
+
+Install: `npm install -D vitest @cloudflare/vitest-pool-workers`
+
+**vitest.config.ts:**
+```typescript
+import { defineWorkersConfig } from "@cloudflare/vitest-pool-workers/config";
+export default defineWorkersConfig({
+  test: { poolOptions: { workers: { wrangler: { configPath: "./wrangler.jsonc" } } } }
+});
+```
+
+**tests/api.test.ts:**
+```typescript
+import { env, SELF } from "cloudflare:test";
+import { describe, it, expect } from "vitest";
+
+it("fetches users", async () => {
+  const response = await SELF.fetch("https://example.com/api/users");
+  expect(response.status).toBe(200);
+});
+
+it("uses bindings", async () => {
+  await env.MY_KV.put("key", "value");
+  expect(await env.MY_KV.get("key")).toBe("value");
+});
+```
+
+### Multi-Worker Development (Service Bindings)
+
+```typescript
+const authWorker = await startWorker({ config: "./auth/wrangler.jsonc" });
+const apiWorker = await startWorker({
+  config: "./api/wrangler.jsonc",
+  bindings: { AUTH: authWorker }  // Service binding
+});
+
+// Test API calling AUTH
+const response = await apiWorker.fetch("http://example.com/api/protected");
+await authWorker.dispose();
+await apiWorker.dispose();
+```
+
+### Mock External APIs
+
+```typescript
+const worker = await startWorker({ 
+  config: "wrangler.jsonc",
+  outboundService: (req) => {
+    const url = new URL(req.url);
+    if (url.hostname === "api.external.com") {
+      return new Response(JSON.stringify({ mocked: true }), {
+        headers: { "content-type": "application/json" }
+      });
+    }
+    return fetch(req);  // Pass through other requests
+  }
+});
+
+// Test Worker that calls external API
+const response = await worker.fetch("http://example.com/proxy");
+// Worker internally fetches api.external.com - gets mocked response
+```
+
+## Monitoring & Versions
+
+```bash
+wrangler tail                 # Real-time logs
+wrangler tail --status error  # Filter errors
+wrangler versions list
+wrangler rollback [id]
+```
+
+## TypeScript
+
+```bash
+wrangler types  # Generate types from config
+```
+
+```typescript
+export default {
+  async fetch(request: Request, env: Env): Promise<Response> {
+    return Response.json({ value: await env.MY_KV.get("key") });
+  }
+} satisfies ExportedHandler<Env>;
+```
+
+## Workers Assets
+
+```jsonc
+{ "assets": { "directory": "./dist", "binding": "ASSETS" } }
+```
+
+```typescript
+export default {
+  async fetch(request, env) {
+    // API routes first
+    if (new URL(request.url).pathname.startsWith("/api/")) {
+      return Response.json({ data: "from API" });
+    }
+    return env.ASSETS.fetch(request);  // Static assets
+  }
+}
+```
+
+## See Also
+
+- [README.md](./README.md) - Commands
+- [configuration.md](./configuration.md) - Config
+- [api.md](./api.md) - Programmatic API
+- [gotchas.md](./gotchas.md) - Issues

package/dist/registry/skills/openai-cloudflare-deploy/upstream/references/zaraz/IMPLEMENTATION_SUMMARY.md

@@ -0,0 +1,121 @@
+# Zaraz Reference Implementation Summary
+
+## Files Created
+
+| File | Lines | Purpose |
+|------|-------|---------|
+| README.md | 111 | Navigation, decision tree, quick start |
+| api.md | 287 | Web API reference, Zaraz Context |
+| configuration.md | 307 | Dashboard setup, triggers, tools, consent |
+| patterns.md | 430 | SPA, e-commerce, Worker integration |
+| gotchas.md | 317 | Troubleshooting, limits, tool-specific issues |
+| **Total** | **1,452** | **vs 366 original** |
+
+## Key Improvements Applied
+
+### Structure
+- ✅ Created 5-file progressive disclosure system
+- ✅ Added navigation table in README
+- ✅ Added decision tree for routing
+- ✅ Added "Reading Order by Task" guide
+- ✅ Cross-referenced files throughout
+
+### New Content Added
+- ✅ Zaraz Context (system/client properties)
+- ✅ History Change trigger for SPA tracking
+- ✅ Context Enrichers pattern
+- ✅ Worker Variables pattern
+- ✅ Consent management deep dive
+- ✅ Tool-specific quirks (GA4, Facebook, Google Ads)
+- ✅ GTM migration guide
+- ✅ Comprehensive troubleshooting
+- ✅ "When NOT to use Zaraz" section
+- ✅ TypeScript type definitions
+
+### Preserved Content
+- ✅ All original API methods
+- ✅ E-commerce tracking examples
+- ✅ Consent management
+- ✅ Workers integration (expanded)
+- ✅ Common patterns (expanded)
+- ✅ Debugging tools
+- ✅ Reference links
+
+## Progressive Disclosure Impact
+
+### Before (Monolithic)
+All tasks loaded 366 lines regardless of need.
+
+### After (Progressive)
+- **Track event task**: README (111) + api.md (287) = 398 lines
+- **Debug issue**: gotchas.md (317) = 317 lines (13% reduction)
+- **Configure tool**: configuration.md (307) = 307 lines (16% reduction)
+- **SPA tracking**: README + patterns.md (SPA section) ~180 lines (51% reduction)
+
+**Net effect:** Task-specific loading reduces unnecessary content by 13-51% depending on use case.
+
+## File Summary
+
+### README.md (111 lines)
+- Overview and core concepts
+- Quick start guide
+- When to use Zaraz vs Workers
+- Navigation table
+- Reading order by task
+- Decision tree
+
+### api.md (287 lines)
+- zaraz.track()
+- zaraz.set()
+- zaraz.ecommerce()
+- Zaraz Context (system/client properties)
+- zaraz.consent API
+- zaraz.debug
+- Cookie methods
+- TypeScript definitions
+
+### configuration.md (307 lines)
+- Dashboard setup flow
+- Trigger types (including History Change)
+- Tool configuration (GA4, Facebook, Google Ads)
+- Actions and action rules
+- Selective loading
+- Consent management setup
+- Privacy features
+- Testing workflow
+
+### patterns.md (430 lines)
+- SPA tracking (React, Vue, Next.js)
+- User identification flows
+- Complete e-commerce funnel
+- A/B testing
+- Worker integration (Context Enrichers, Worker Variables, HTML injection)
+- Multi-tool coordination
+- GTM migration
+- Best practices
+
+### gotchas.md (317 lines)
+- Events not firing (5-step debug process)
+- Consent issues
+- SPA tracking pitfalls
+- Performance issues
+- Tool-specific quirks
+- Data layer issues
+- Limits table
+- When NOT to use Zaraz
+- Debug checklist
+
+## Quality Metrics
+
+- ✅ All files use consistent markdown formatting
+- ✅ Code examples include language tags
+- ✅ Tables for structured data (limits, parameters, comparisons)
+- ✅ Problem → Cause → Solution format in gotchas
+- ✅ Cross-references between files
+- ✅ No "see documentation" placeholders
+- ✅ Real, actionable examples throughout
+- ✅ Verified API syntax for Workers
+
+## Original Backup
+
+Original SKILL.md preserved as `_SKILL_old.md` for reference.

package/dist/registry/skills/openai-cloudflare-deploy/upstream/references/zaraz/README.md

@@ -0,0 +1,111 @@
+# Cloudflare Zaraz
+
+Expert guidance for Cloudflare Zaraz - server-side tag manager for loading third-party tools at the edge.
+
+## What is Zaraz?
+
+Zaraz offloads third-party scripts (analytics, ads, chat, marketing) to Cloudflare's edge, improving site speed, privacy, and security. Zero client-side performance impact.
+
+**Core Concepts:**
+- **Server-side execution** - Scripts run on Cloudflare, not user's browser
+- **Single HTTP request** - All tools loaded via one endpoint
+- **Privacy-first** - Control data sent to third parties
+- **No client-side JS overhead** - Minimal browser impact
+
+## Quick Start
+
+1. Navigate to domain > Zaraz in Cloudflare dashboard
+2. Click "Start setup"
+3. Add tools (Google Analytics, Facebook Pixel, etc.)
+4. Configure triggers (when tools fire)
+5. Add tracking code to your site:
+
+```javascript
+// Track page view
+zaraz.track('page_view');
+
+// Track custom event
+zaraz.track('button_click', { button_id: 'cta' });
+
+// Set user properties
+zaraz.set('userId', 'user_123');
+```
+
+## When to Use Zaraz
+
+**Use Zaraz when:**
+- Adding multiple third-party tools (analytics, ads, marketing)
+- Site performance is critical (no client-side JS overhead)
+- Privacy compliance required (GDPR, CCPA)
+- Non-technical teams need to manage tools
+
+**Use Workers directly when:**
+- Building custom server-side tracking logic
+- Need full control over data processing
+- Integrating with complex backend systems
+- Zaraz's tool library doesn't meet needs
+
+## In This Reference
+
+| File | Purpose | When to Read |
+|------|---------|--------------|
+| [api.md](./api.md) | Web API, zaraz object, consent methods | Implementing tracking calls |
+| [configuration.md](./configuration.md) | Dashboard setup, triggers, tools | Initial setup, adding tools |
+| [patterns.md](./patterns.md) | SPA, e-commerce, Worker integration | Best practices, common scenarios |
+| [gotchas.md](./gotchas.md) | Troubleshooting, limits, pitfalls | Debugging issues |
+
+## Reading Order by Task
+
+| Task | Files to Read |
+|------|---------------|
+| Add analytics to site | README → configuration.md |
+| Track custom events | README → api.md |
+| Debug tracking issues | gotchas.md |
+| SPA tracking | api.md → patterns.md (SPA section) |
+| E-commerce tracking | api.md#ecommerce → patterns.md#ecommerce |
+| Worker integration | patterns.md#worker-integration |
+| GDPR compliance | api.md#consent → configuration.md#consent |
+
+## Decision Tree
+
+```
+What do you need?
+
+├─ Track events in browser → api.md
+│   ├─ Page views, clicks → zaraz.track()
+│   ├─ User properties → zaraz.set()
+│   └─ E-commerce → zaraz.ecommerce()
+│
+├─ Configure Zaraz → configuration.md
+│   ├─ Add GA4/Facebook → tools setup
+│   ├─ When tools fire → triggers
+│   └─ GDPR consent → consent purposes
+│
+├─ Integrate with Workers → patterns.md#worker-integration
+│   ├─ Enrich context → Context Enrichers
+│   └─ Inject tracking → HTML rewriting
+│
+└─ Debug issues → gotchas.md
+    ├─ Events not firing → troubleshooting
+    ├─ Consent issues → consent debugging
+    └─ Performance → debugging tools
+```
+
+## Key Features
+
+- **100+ Pre-built Tools** - GA4, Facebook, Google Ads, TikTok, etc.
+- **Zero Client Impact** - Runs at Cloudflare's edge, not browser
+- **Privacy Controls** - Consent management, data filtering
+- **Custom Tools** - Build Managed Components for proprietary systems
+- **Worker Integration** - Enrich context, compute dynamic values
+- **Debug Mode** - Real-time event inspection
+
+## Reference
+
+- [Zaraz Docs](https://developers.cloudflare.com/zaraz/)
+- [Web API](https://developers.cloudflare.com/zaraz/web-api/)
+- [Managed Components](https://developers.cloudflare.com/zaraz/advanced/load-custom-managed-component/)
+
+---
+
+This skill focuses exclusively on Zaraz. For Workers development, see `cloudflare-workers` skill.

package/dist/registry/skills/openai-cloudflare-deploy/upstream/references/zaraz/api.md

@@ -0,0 +1,112 @@
+# Zaraz Web API
+
+Client-side JavaScript API for tracking events, setting properties, and managing consent.
+
+## zaraz.track()
+
+```javascript
+zaraz.track('button_click');
+zaraz.track('purchase', { value: 99.99, currency: 'USD', item_id: '12345' });
+zaraz.track('pageview', { page_path: '/products', page_title: 'Products' }); // SPA
+```
+
+**Params:** `eventName` (string), `properties` (object, optional). Fire-and-forget.
+
+## zaraz.set()
+
+```javascript
+zaraz.set('userId', 'user_12345');
+zaraz.set({ email: '[email protected]', plan: 'premium', country: 'US' });
+```
+
+Properties persist for page session. Use for user identification and segmentation.
+
+## zaraz.ecommerce()
+
+```javascript
+zaraz.ecommerce('Product Viewed', { product_id: 'SKU123', name: 'Widget', price: 49.99 });
+zaraz.ecommerce('Product Added', { product_id: 'SKU123', quantity: 2, price: 49.99 });
+zaraz.ecommerce('Order Completed', {
+  order_id: 'ORD-789', total: 149.98, currency: 'USD',
+  products: [{ product_id: 'SKU123', quantity: 2, price: 49.99 }]
+});
+```
+
+**Events:** `Product Viewed`, `Product Added`, `Product Removed`, `Cart Viewed`, `Checkout Started`, `Order Completed`
+
+Tools auto-map to GA4, Facebook CAPI, etc.
+
+## System Properties (Triggers)
+
+```
+{{system.page.url}}   {{system.page.title}}   {{system.page.referrer}}
+{{system.device.ip}}  {{system.device.userAgent}}  {{system.device.language}}
+{{system.cookies.name}}  {{client.__zarazTrack.userId}}
+```
+
+## zaraz.consent
+
+```javascript
+// Check
+const purposes = zaraz.consent.getAll(); // { analytics: true, marketing: false }
+
+// Set
+zaraz.consent.modal = true; // Show modal
+zaraz.consent.setAll({ analytics: true, marketing: false });
+zaraz.consent.set('marketing', true);
+
+// Listen
+zaraz.consent.addEventListener('consentChanged', () => {
+  if (zaraz.consent.getAll().marketing) zaraz.track('marketing_consent_granted');
+});
+```
+
+**Flow:** Configure purposes in dashboard → Map tools to purposes → Show modal/set programmatically → Tools fire when allowed
+
+## zaraz.debug
+
+```javascript
+zaraz.debug = true;
+zaraz.track('test_event');
+console.log(zaraz.tools); // View loaded tools
+```
+
+## Cookie Methods
+
+```javascript
+zaraz.getCookie('session_id');  // Zaraz namespace
+zaraz.readCookie('_ga');        // Any cookie
+```
+
+## Async Behavior
+
+All methods fire-and-forget. Events batched and sent asynchronously:
+
+```javascript
+zaraz.track('event1');
+zaraz.set('prop', 'value');
+zaraz.track('event2'); // All batched
+```
+
+## TypeScript Types
+
+```typescript
+interface Zaraz {
+  track(event: string, properties?: Record<string, unknown>): void;
+  set(key: string, value: unknown): void;
+  set(properties: Record<string, unknown>): void;
+  ecommerce(event: string, properties: Record<string, unknown>): void;
+  consent: {
+    getAll(): Record<string, boolean>;
+    setAll(purposes: Record<string, boolean>): void;
+    set(purpose: string, value: boolean): void;
+    addEventListener(event: 'consentChanged', callback: () => void): void;
+    modal: boolean;
+  };
+  debug: boolean;
+  tools?: string[];
+  getCookie(name: string): string | undefined;
+  readCookie(name: string): string | undefined;
+}
+declare global { interface Window { zaraz: Zaraz; } }
+```

package/dist/registry/skills/openai-cloudflare-deploy/upstream/references/zaraz/configuration.md

@@ -0,0 +1,90 @@
+# Zaraz Configuration
+
+## Dashboard Setup
+
+1. Domain → Zaraz → Start setup
+2. Add tool (e.g., Google Analytics 4)
+3. Enter credentials (GA4: `G-XXXXXXXXXX`)
+4. Configure triggers
+5. Save and Publish
+
+## Triggers
+
+| Type | When | Use Case |
+|------|------|----------|
+| Pageview | Page load | Track page views |
+| Click | Element clicked | Button tracking |
+| Form Submission | Form submitted | Lead capture |
+| History Change | URL changes (SPA) | React/Vue routing |
+| Variable Match | Custom condition | Conditional firing |
+
+### History Change (SPA)
+
+```
+Type: History Change
+Event: pageview
+```
+
+Fires on `pushState`, `replaceState`, hash changes. **No manual tracking needed.**
+
+### Click Trigger
+
+```
+Type: Click
+CSS Selector: .buy-button
+Event: purchase_intent
+Properties:
+  button_text: {{system.clickElement.text}}
+```
+
+## Tool Configuration
+
+**GA4:**
+```
+Measurement ID: G-XXXXXXXXXX
+Events: page_view, purchase, user_engagement
+```
+
+**Facebook Pixel:**
+```
+Pixel ID: 1234567890123456
+Events: PageView, Purchase, AddToCart
+```
+
+**Google Ads:**
+```
+Conversion ID: AW-XXXXXXXXX
+Conversion Label: YYYYYYYYYY
+```
+
+## Consent Management
+
+1. Settings → Consent → Create purposes (analytics, marketing)
+2. Map tools to purposes
+3. Set behavior: "Do not load until consent granted"
+
+**Programmatic consent:**
+```javascript
+zaraz.consent.setAll({ analytics: true, marketing: true });
+```
+
+## Privacy Features
+
+| Feature | Default |
+|---------|---------|
+| IP Anonymization | Enabled |
+| Cookie Control | Via consent purposes |
+| GDPR/CCPA | Consent modal |
+
+## Testing
+
+1. **Preview Mode** - test without publishing
+2. **Debug Mode** - `zaraz.debug = true`
+3. **Network tab** - filter "zaraz"
+
+## Limits
+
+| Resource | Limit |
+|----------|-------|
+| Event properties | 100KB |
+| Consent purposes | 20 |