opencode-skills-collection 1.0.185 → 1.0.187

package/bundled-skills/idea-darwin/SKILL.md

@@ -0,0 +1,120 @@
+---
+name: idea-darwin
+description: "Darwinian idea evolution engine — toss rough ideas onto an evolution island, let them compete, crossbreed, and mutate through structured rounds to surface your strongest concepts."
+risk: safe
+source: community
+date_added: "2026-04-07"
+---
+
+# Idea Darwin Engine
+
+A round-based idea iteration system that treats ideas as competing organisms — scoring, selecting, crossing, and evolving them through structured rounds to surface the strongest concepts.
+
+## Overview
+
+Most idea management tools are filing cabinets: they store ideas, tag them, and let them rot. Idea Darwin flips the paradigm — instead of organizing ideas, it lets them **compete**. Every idea is a living species on an evolution island. Each round, the fittest get deepened, different ideas cross-pollinate to produce unexpected hybrids, and external stimuli trigger mutations.
+
+## When to Use This Skill
+
+- Use when you have many scattered ideas and need to systematically evaluate and develop them
+- Use when you want to discover unexpected connections between ideas from different domains
+- Use when you need structured iteration rather than one-shot brainstorming
+- Use when you want a scoring framework to prioritize which ideas deserve more investment
+
+## Core Concepts
+
+### Evolution Island Metaphor
+
+Your ideas are alive on this island. Like organisms, they follow three core laws:
+
+1. **Evolution** — Each round, the system deepens the most viable ideas through structured research: filling logical gaps, clarifying paths, identifying risks.
+2. **Crossbreeding** — The system cross-pollinates different ideas. A technical approach from work meets an observation from daily life, producing directions you never imagined.
+3. **Mutation** — External stimuli (industry news, theories, conversations) trigger mutations, spawning entirely new species.
+
+### Species Cards
+
+Every idea gets a structured card recording: core question, full description, lineage (parent/child IDs), 6-dimensional scores, and change history.
+
+### 6-Dimensional Scoring
+
+| Dimension | Weight | What It Measures |
+|---|---|---|
+| Novelty | 10% | Genuine breakthrough or repetition? |
+| Feasibility | 20% | Technically and resource-wise achievable? |
+| Value | 20% | Impact if successful? |
+| Logic | 20% | Internally consistent, no gaps? |
+| Cross Potential | 10% | Can spark something new when combined? |
+| Verifiability | 20% | Can we design a validation path? |
+
+### Idea Lifecycle
+
+```
+seed → exploring → refining → crossing → validated → dormant
+```
+
+The user always has final say on all life-or-death decisions. The system only recommends.
+
+## Step-by-Step Guide
+
+### 1. Write Your Ideas
+
+Create an `ideas.md` file:
+
+```markdown
+## Personal knowledge base that learns my style
+I want a system that reads everything I write and gradually learns how I think.
+
+## Commute-to-podcast converter
+Record voice memos during my commute, auto-convert them into podcast scripts.
+```
+
+### 2. Initialize Your Island
+
+```
+/idea-darwin init
+```
+
+### 3. Start Evolving
+
+```
+/idea-darwin round
+```
+
+### 4. Keep Feeding the Island
+
+Append new ideas to `ideas.md`, add environmental variables to `stimuli.md`.
+
+## Examples
+
+### Example 1: Initialize
+
+```
+/idea-darwin init --budget 8 --actions 3
+```
+
+### Example 2: Run Multiple Rounds
+
+```
+/idea-darwin round 3
+```
+
+### Example 3: Manage Ideas
+
+```
+/idea-darwin dormant IDEA-0005
+/idea-darwin wake IDEA-0005
+```
+
+## Best Practices
+
+- Do: Write ideas as rough as you want — the system structures them
+- Do: Add external stimuli to prevent idea convergence
+- Do: Run disruption rounds to surface overlooked ideas
+- Don't: Over-curate initial ideas — let evolution filter
+- Don't: Ignore the "Decisions Needed" section in briefings
+
+## Additional Resources
+
+- [GitHub Repository](https://github.com/warmskull/idea-darwin)
+- Available in 3 languages: English, Chinese, Japanese
+- ClawHub: `clawhub install idea-darwin`

package/bundled-skills/inngest/SKILL.md

@@ -1,23 +1,27 @@
 ---
 name: inngest
-description: "You are an Inngest expert who builds reliable background processing without managing infrastructure. You understand that serverless doesn't mean you can't have durable, long-running workflows - it means you don't manage the workers."
+description: Inngest expert for serverless-first background jobs, event-driven
+  workflows, and durable execution without managing queues or workers.
 risk: none
-source: "vibeship-spawner-skills (Apache 2.0)"
-date_added: "2026-02-27"
+source: vibeship-spawner-skills (Apache 2.0)
+date_added: 2026-02-27
 ---
 
 # Inngest Integration
 
-You are an Inngest expert who builds reliable background processing without
-managing infrastructure. You understand that serverless doesn't mean you can't
-have durable, long-running workflows - it means you don't manage the workers.
+Inngest expert for serverless-first background jobs, event-driven workflows,
+and durable execution without managing queues or workers.
 
-You've built AI pipelines that take minutes, onboarding flows that span days,
-and event-driven systems that process millions of events. You know that the
-magic of Inngest is in its steps - each one a checkpoint that survives failures.
+## Principles
 
-Your core philosophy:
-1. Event
+- Events are the primitive - everything triggers from events, not queues
+- Steps are your checkpoints - each step result is durably stored
+- Sleep is not a hack - Inngest sleeps are real, not blocking threads
+- Retries are automatic - but you control the policy
+- Functions are just HTTP handlers - deploy anywhere that serves HTTP
+- Concurrency is a first-class concern - protect downstream services
+- Idempotency keys prevent duplicates - use them for critical operations
+- Fan-out is built-in - one event can trigger many functions
 
 ## Capabilities
 
@@ -30,31 +34,442 @@ Your core philosophy:
 - concurrency-control
 - scheduled-functions
 
+## Scope
+
+- redis-queues -> bullmq-specialist
+- workflow-orchestration -> temporal-craftsman
+- message-streaming -> event-architect
+- infrastructure -> infra-architect
+
+## Tooling
+
+### Core
+
+- inngest
+- inngest-cli
+
+### Frameworks
+
+- nextjs
+- express
+- hono
+- remix
+- sveltekit
+
+### Deployment
+
+- vercel
+- cloudflare-workers
+- netlify
+- railway
+- fly-io
+
+### Patterns
+
+- step-functions
+- event-fan-out
+- scheduled-cron
+- webhook-handling
+
 ## Patterns
 
 ### Basic Function Setup
 
 Inngest function with typed events in Next.js
 
+**When to use**: Starting with Inngest in any Next.js project
+
+// lib/inngest/client.ts
+import { Inngest } from 'inngest';
+
+export const inngest = new Inngest({
+  id: 'my-app',
+  schemas: new EventSchemas().fromRecord<Events>(),
+});
+
+// Define your events with types
+type Events = {
+  'user/signed.up': { data: { userId: string; email: string } };
+  'order/placed': { data: { orderId: string; total: number } };
+};
+
+// lib/inngest/functions.ts
+import { inngest } from './client';
+
+export const sendWelcomeEmail = inngest.createFunction(
+  { id: 'send-welcome-email' },
+  { event: 'user/signed.up' },
+  async ({ event, step }) => {
+    // Step 1: Get user details
+    const user = await step.run('get-user', async () => {
+      return await db.users.findUnique({ where: { id: event.data.userId } });
+    });
+
+    // Step 2: Send welcome email
+    await step.run('send-email', async () => {
+      await resend.emails.send({
+        to: user.email,
+        subject: 'Welcome!',
+        template: 'welcome',
+      });
+    });
+
+    // Step 3: Wait 24 hours, then send tips
+    await step.sleep('wait-for-tips', '24h');
+
+    await step.run('send-tips', async () => {
+      await resend.emails.send({
+        to: user.email,
+        subject: 'Getting Started Tips',
+        template: 'tips',
+      });
+    });
+  }
+);
+
+// app/api/inngest/route.ts (Next.js App Router)
+import { serve } from 'inngest/next';
+import { inngest } from '@/lib/inngest/client';
+import { sendWelcomeEmail } from '@/lib/inngest/functions';
+
+export const { GET, POST, PUT } = serve({
+  client: inngest,
+  functions: [sendWelcomeEmail],
+});
+
 ### Multi-Step Workflow
 
 Complex workflow with parallel steps and error handling
 
+**When to use**: Processing that involves multiple services or long waits
+
+export const processOrder = inngest.createFunction(
+  {
+    id: 'process-order',
+    retries: 3,
+    concurrency: { limit: 10 },  // Max 10 orders processing at once
+  },
+  { event: 'order/placed' },
+  async ({ event, step }) => {
+    const { orderId } = event.data;
+
+    // Parallel steps - both run simultaneously
+    const [inventory, payment] = await Promise.all([
+      step.run('check-inventory', () => checkInventory(orderId)),
+      step.run('validate-payment', () => validatePayment(orderId)),
+    ]);
+
+    if (!inventory.available) {
+      // Send event instead of direct call (fan-out pattern)
+      await step.sendEvent('notify-backorder', {
+        name: 'order/backordered',
+        data: { orderId, items: inventory.missing },
+      });
+      return { status: 'backordered' };
+    }
+
+    // Process payment
+    const charge = await step.run('charge-payment', async () => {
+      return await stripe.charges.create({
+        amount: event.data.total,
+        customer: payment.customerId,
+      });
+    });
+
+    // Ship order
+    await step.run('ship-order', () => fulfillment.ship(orderId));
+
+    return { status: 'completed', chargeId: charge.id };
+  }
+);
+
 ### Scheduled/Cron Functions
 
 Functions that run on a schedule
 
-## Anti-Patterns
+**When to use**: Recurring tasks like daily reports or cleanup jobs
+
+export const dailyDigest = inngest.createFunction(
+  { id: 'daily-digest' },
+  { cron: '0 9 * * *' },  // Every day at 9am UTC
+  async ({ step }) => {
+    // Get all users who want digests
+    const users = await step.run('get-users', async () => {
+      return await db.users.findMany({
+        where: { digestEnabled: true },
+      });
+    });
+
+    // Send to each user (creates child events)
+    await step.sendEvent(
+      'send-digests',
+      users.map(user => ({
+        name: 'digest/send',
+        data: { userId: user.id },
+      }))
+    );
+
+    return { sent: users.length };
+  }
+);
+
+// Separate function handles individual digest sending
+export const sendDigest = inngest.createFunction(
+  { id: 'send-digest', concurrency: { limit: 50 } },
+  { event: 'digest/send' },
+  async ({ event, step }) => {
+    // ... send individual digest
+  }
+);
+
+### Webhook Handler with Idempotency
+
+Safely process webhooks with deduplication
+
+**When to use**: Handling Stripe, GitHub, or other webhooks
+
+export const handleStripeWebhook = inngest.createFunction(
+  {
+    id: 'stripe-webhook',
+    // Deduplicate by Stripe event ID
+    idempotency: 'event.data.stripeEventId',
+  },
+  { event: 'stripe/webhook.received' },
+  async ({ event, step }) => {
+    const { type, data } = event.data;
+
+    switch (type) {
+      case 'checkout.session.completed':
+        await step.run('fulfill-order', async () => {
+          await fulfillOrder(data.session.id);
+        });
+        break;
+
+      case 'customer.subscription.deleted':
+        await step.run('cancel-subscription', async () => {
+          await cancelSubscription(data.subscription.id);
+        });
+        break;
+    }
+  }
+);
+
+### AI Pipeline with Long Processing
+
+Multi-step AI processing with chunked work
+
+**When to use**: AI workflows that may take minutes to complete
+
+export const processDocument = inngest.createFunction(
+  {
+    id: 'process-document',
+    retries: 2,
+    concurrency: { limit: 5 },  // Limit API usage
+  },
+  { event: 'document/uploaded' },
+  async ({ event, step }) => {
+    // Step 1: Extract text (may take a while)
+    const text = await step.run('extract-text', async () => {
+      return await extractTextFromPDF(event.data.fileUrl);
+    });
+
+    // Step 2: Chunk for embedding
+    const chunks = await step.run('chunk-text', async () => {
+      return chunkText(text, { maxTokens: 500 });
+    });
+
+    // Step 3: Generate embeddings (API rate limited)
+    const embeddings = await step.run('generate-embeddings', async () => {
+      return await openai.embeddings.create({
+        model: 'text-embedding-3-small',
+        input: chunks,
+      });
+    });
+
+    // Step 4: Store in vector DB
+    await step.run('store-vectors', async () => {
+      await vectorDb.upsert({
+        vectors: embeddings.data.map((e, i) => ({
+          id: `${event.data.documentId}-${i}`,
+          values: e.embedding,
+          metadata: { chunk: chunks[i] },
+        })),
+      });
+    });
+
+    return { chunks: chunks.length, status: 'indexed' };
+  }
+);
+
+## Validation Checks
+
+### Inngest serve handler present
+
+Severity: CRITICAL
+
+Message: Inngest requires a serve handler to receive events
+
+Fix action: Create app/api/inngest/route.ts with serve() export
+
+### Functions registered with serve
+
+Severity: ERROR
 
-### ❌ Not Using Steps
+Message: Ensure all Inngest functions are registered in the serve() call
 
-### ❌ Huge Event Payloads
+Fix action: Add function to the functions array in serve()
 
-### ❌ Ignoring Concurrency
+### Step.run has descriptive name
+
+Severity: WARNING
+
+Message: Step names should be kebab-case and descriptive
+
+Fix action: Use descriptive step names like 'fetch-user' or 'send-email'
+
+### waitForEvent has timeout
+
+Severity: ERROR
+
+Message: waitForEvent should have a timeout to prevent infinite waits
+
+Fix action: Add timeout option: { timeout: '24h' }
+
+### Function has concurrency limit
+
+Severity: WARNING
+
+Message: Consider adding concurrency limits to protect downstream services
+
+Fix action: Add concurrency: { limit: 10 } to function config
+
+### Event types defined
+
+Severity: WARNING
+
+Message: Inngest client should define event schemas for type safety
+
+Fix action: Add schemas: new EventSchemas().fromRecord<Events>()
+
+### Function has unique ID
+
+Severity: CRITICAL
+
+Message: Every Inngest function must have a unique ID
+
+Fix action: Add id: 'my-function-name' to function config
+
+### Sleep uses duration string
+
+Severity: WARNING
+
+Message: step.sleep should use duration strings like '1h' or '30m', not milliseconds
+
+Fix action: Use duration string: step.sleep('wait', '1h')
+
+### Retry policy configured
+
+Severity: WARNING
+
+Message: Consider configuring retry policy for failure handling
+
+Fix action: Add retries: 3 or retries: { attempts: 3, backoff: { ... } }
+
+### Idempotency key for payment functions
+
+Severity: ERROR
+
+Message: Payment-related functions should use idempotency keys
+
+Fix action: Add idempotency: 'event.data.orderId' to function config
+
+## Collaboration
+
+### Delegation Triggers
+
+- redis|queue infrastructure|bullmq -> bullmq-specialist (Need Redis-based queue with existing infrastructure)
+- saga|compensation|rollback|long-running workflow -> temporal-craftsman (Need complex workflow orchestration with compensation)
+- event sourcing|event store|cqrs -> event-architect (Need event sourcing patterns)
+- vercel|deploy|production -> vercel-deployment (Need deployment configuration)
+- database|schema|data model -> supabase-backend (Need database for event data)
+- api|endpoint|route -> backend (Need API to trigger events)
+
+### Vercel Background Jobs
+
+Skills: inngest, nextjs-app-router, vercel-deployment
+
+Workflow:
+
+```
+1. Define Inngest functions (inngest)
+2. Set up serve handler in Next.js (nextjs-app-router)
+3. Configure function timeouts (vercel-deployment)
+4. Deploy and test (vercel-deployment)
+```
+
+### AI Pipeline
+
+Skills: inngest, ai-agents-architect, supabase-backend
+
+Workflow:
+
+```
+1. Design AI workflow steps (ai-agents-architect)
+2. Implement with Inngest durability (inngest)
+3. Store results in database (supabase-backend)
+4. Handle retries for API failures (inngest)
+```
+
+### Webhook Processing
+
+Skills: inngest, stripe-integration, backend
+
+Workflow:
+
+```
+1. Receive webhook (backend)
+2. Send to Inngest with idempotency (inngest)
+3. Process payment logic (stripe-integration)
+4. Update application state (backend)
+```
+
+### Email Automation
+
+Skills: inngest, email-systems, supabase-backend
+
+Workflow:
+
+```
+1. Trigger event from user action (inngest)
+2. Schedule drip emails with step.sleep (inngest)
+3. Send emails with retry (email-systems)
+4. Track email status (supabase-backend)
+```
+
+### Scheduled Tasks
+
+Skills: inngest, backend, analytics-architecture
+
+Workflow:
+
+```
+1. Define cron triggers (inngest)
+2. Implement processing logic (backend)
+3. Aggregate and report data (analytics-architecture)
+4. Handle failures with alerting (inngest)
+```
 
 ## Related Skills
 
 Works well with: `nextjs-app-router`, `vercel-deployment`, `supabase-backend`, `email-systems`, `ai-agents-architect`, `stripe-integration`
 
 ## When to Use
-This skill is applicable to execute the workflow or actions described in the overview.
+
+- User mentions or implies: inngest
+- User mentions or implies: serverless background job
+- User mentions or implies: event-driven workflow
+- User mentions or implies: step function
+- User mentions or implies: durable execution
+- User mentions or implies: vercel background job
+- User mentions or implies: scheduled function
+- User mentions or implies: fan out