@ngxtm/devkit 3.7.0 → 3.9.0

package/merged-commands/event-sourcing-architect.md

@@ -0,0 +1,58 @@
+---
+name: event-sourcing-architect
+description: "Expert in event sourcing, CQRS, and event-driven architecture patterns. Masters event store design, projection building, saga orchestration, and eventual consistency patterns. Use PROACTIVELY for event-sourced systems, audit trails, or temporal queries."
+---
+
+# Event Sourcing Architect
+
+Expert in event sourcing, CQRS, and event-driven architecture patterns. Masters event store design, projection building, saga orchestration, and eventual consistency patterns. Use PROACTIVELY for event-sourced systems, audit trail requirements, or complex domain modeling with temporal queries.
+
+## Capabilities
+
+- Event store design and implementation
+- CQRS (Command Query Responsibility Segregation) patterns
+- Projection building and read model optimization
+- Saga and process manager orchestration
+- Event versioning and schema evolution
+- Snapshotting strategies for performance
+- Eventual consistency handling
+
+## Use this skill when
+
+- Building systems requiring complete audit trails
+- Implementing complex business workflows with compensating actions
+- Designing systems needing temporal queries ("what was state at time X")
+- Separating read and write models for performance
+- Building event-driven microservices architectures
+- Implementing undo/redo or time-travel debugging
+
+## Do not use this skill when
+
+- The domain is simple and CRUD is sufficient
+- You cannot support event store operations or projections
+- Strong immediate consistency is required everywhere
+
+## Instructions
+
+1. Identify aggregate boundaries and event streams
+2. Design events as immutable facts
+3. Implement command handlers and event application
+4. Build projections for query requirements
+5. Design saga/process managers for cross-aggregate workflows
+6. Implement snapshotting for long-lived aggregates
+7. Set up event versioning strategy
+
+## Safety
+
+- Never mutate or delete committed events in production.
+- Rebuild projections in staging before running in production.
+
+## Best Practices
+
+- Events are facts - never delete or modify them
+- Keep events small and focused
+- Version events from day one
+- Design for eventual consistency
+- Use correlation IDs for tracing
+- Implement idempotent event handlers
+- Plan for projection rebuilding

package/merged-commands/event-store-design.md

@@ -0,0 +1,449 @@
+---
+name: event-store-design
+description: Design and implement event stores for event-sourced systems. Use when building event sourcing infrastructure, choosing event store technologies, or implementing event persistence patterns.
+---
+
+# Event Store Design
+
+Comprehensive guide to designing event stores for event-sourced applications.
+
+## Do not use this skill when
+
+- The task is unrelated to event store design
+- You need a different domain or tool outside this scope
+
+## Instructions
+
+- Clarify goals, constraints, and required inputs.
+- Apply relevant best practices and validate outcomes.
+- Provide actionable steps and verification.
+- If detailed examples are required, open `resources/implementation-playbook.md`.
+
+## Use this skill when
+
+- Designing event sourcing infrastructure
+- Choosing between event store technologies
+- Implementing custom event stores
+- Optimizing event storage and retrieval
+- Setting up event store schemas
+- Planning for event store scaling
+
+## Core Concepts
+
+### 1. Event Store Architecture
+
+```
+┌─────────────────────────────────────────────────────┐
+│                    Event Store                       │
+├─────────────────────────────────────────────────────┤
+│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐ │
+│  │   Stream 1   │  │   Stream 2   │  │   Stream 3   │ │
+│  │ (Aggregate)  │  │ (Aggregate)  │  │ (Aggregate)  │ │
+│  ├─────────────┤  ├─────────────┤  ├─────────────┤ │
+│  │ Event 1     │  │ Event 1     │  │ Event 1     │ │
+│  │ Event 2     │  │ Event 2     │  │ Event 2     │ │
+│  │ Event 3     │  │ ...         │  │ Event 3     │ │
+│  │ ...         │  │             │  │ Event 4     │ │
+│  └─────────────┘  └─────────────┘  └─────────────┘ │
+├─────────────────────────────────────────────────────┤
+│  Global Position: 1 → 2 → 3 → 4 → 5 → 6 → ...     │
+└─────────────────────────────────────────────────────┘
+```
+
+### 2. Event Store Requirements
+
+| Requirement       | Description                        |
+| ----------------- | ---------------------------------- |
+| **Append-only**   | Events are immutable, only appends |
+| **Ordered**       | Per-stream and global ordering     |
+| **Versioned**     | Optimistic concurrency control     |
+| **Subscriptions** | Real-time event notifications      |
+| **Idempotent**    | Handle duplicate writes safely     |
+
+## Technology Comparison
+
+| Technology       | Best For                  | Limitations                      |
+| ---------------- | ------------------------- | -------------------------------- |
+| **EventStoreDB** | Pure event sourcing       | Single-purpose                   |
+| **PostgreSQL**   | Existing Postgres stack   | Manual implementation            |
+| **Kafka**        | High-throughput streaming | Not ideal for per-stream queries |
+| **DynamoDB**     | Serverless, AWS-native    | Query limitations                |
+| **Marten**       | .NET ecosystems           | .NET specific                    |
+
+## Templates
+
+### Template 1: PostgreSQL Event Store Schema
+
+```sql
+-- Events table
+CREATE TABLE events (
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    stream_id VARCHAR(255) NOT NULL,
+    stream_type VARCHAR(255) NOT NULL,
+    event_type VARCHAR(255) NOT NULL,
+    event_data JSONB NOT NULL,
+    metadata JSONB DEFAULT '{}',
+    version BIGINT NOT NULL,
+    global_position BIGSERIAL,
+    created_at TIMESTAMPTZ DEFAULT NOW(),
+
+    CONSTRAINT unique_stream_version UNIQUE (stream_id, version)
+);
+
+-- Index for stream queries
+CREATE INDEX idx_events_stream_id ON events(stream_id, version);
+
+-- Index for global subscription
+CREATE INDEX idx_events_global_position ON events(global_position);
+
+-- Index for event type queries
+CREATE INDEX idx_events_event_type ON events(event_type);
+
+-- Index for time-based queries
+CREATE INDEX idx_events_created_at ON events(created_at);
+
+-- Snapshots table
+CREATE TABLE snapshots (
+    stream_id VARCHAR(255) PRIMARY KEY,
+    stream_type VARCHAR(255) NOT NULL,
+    snapshot_data JSONB NOT NULL,
+    version BIGINT NOT NULL,
+    created_at TIMESTAMPTZ DEFAULT NOW()
+);
+
+-- Subscriptions checkpoint table
+CREATE TABLE subscription_checkpoints (
+    subscription_id VARCHAR(255) PRIMARY KEY,
+    last_position BIGINT NOT NULL DEFAULT 0,
+    updated_at TIMESTAMPTZ DEFAULT NOW()
+);
+```
+
+### Template 2: Python Event Store Implementation
+
+```python
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Any, Optional, List
+from uuid import UUID, uuid4
+import json
+import asyncpg
+
+@dataclass
+class Event:
+    stream_id: str
+    event_type: str
+    data: dict
+    metadata: dict = field(default_factory=dict)
+    event_id: UUID = field(default_factory=uuid4)
+    version: Optional[int] = None
+    global_position: Optional[int] = None
+    created_at: datetime = field(default_factory=datetime.utcnow)
+
+
+class EventStore:
+    def __init__(self, pool: asyncpg.Pool):
+        self.pool = pool
+
+    async def append_events(
+        self,
+        stream_id: str,
+        stream_type: str,
+        events: List[Event],
+        expected_version: Optional[int] = None
+    ) -> List[Event]:
+        """Append events to a stream with optimistic concurrency."""
+        async with self.pool.acquire() as conn:
+            async with conn.transaction():
+                # Check expected version
+                if expected_version is not None:
+                    current = await conn.fetchval(
+                        "SELECT MAX(version) FROM events WHERE stream_id = $1",
+                        stream_id
+                    )
+                    current = current or 0
+                    if current != expected_version:
+                        raise ConcurrencyError(
+                            f"Expected version {expected_version}, got {current}"
+                        )
+
+                # Get starting version
+                start_version = await conn.fetchval(
+                    "SELECT COALESCE(MAX(version), 0) + 1 FROM events WHERE stream_id = $1",
+                    stream_id
+                )
+
+                # Insert events
+                saved_events = []
+                for i, event in enumerate(events):
+                    event.version = start_version + i
+                    row = await conn.fetchrow(
+                        """
+                        INSERT INTO events (id, stream_id, stream_type, event_type,
+                                          event_data, metadata, version, created_at)
+                        VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
+                        RETURNING global_position
+                        """,
+                        event.event_id,
+                        stream_id,
+                        stream_type,
+                        event.event_type,
+                        json.dumps(event.data),
+                        json.dumps(event.metadata),
+                        event.version,
+                        event.created_at
+                    )
+                    event.global_position = row['global_position']
+                    saved_events.append(event)
+
+                return saved_events
+
+    async def read_stream(
+        self,
+        stream_id: str,
+        from_version: int = 0,
+        limit: int = 1000
+    ) -> List[Event]:
+        """Read events from a stream."""
+        async with self.pool.acquire() as conn:
+            rows = await conn.fetch(
+                """
+                SELECT id, stream_id, event_type, event_data, metadata,
+                       version, global_position, created_at
+                FROM events
+                WHERE stream_id = $1 AND version >= $2
+                ORDER BY version
+                LIMIT $3
+                """,
+                stream_id, from_version, limit
+            )
+            return [self._row_to_event(row) for row in rows]
+
+    async def read_all(
+        self,
+        from_position: int = 0,
+        limit: int = 1000
+    ) -> List[Event]:
+        """Read all events globally."""
+        async with self.pool.acquire() as conn:
+            rows = await conn.fetch(
+                """
+                SELECT id, stream_id, event_type, event_data, metadata,
+                       version, global_position, created_at
+                FROM events
+                WHERE global_position > $1
+                ORDER BY global_position
+                LIMIT $2
+                """,
+                from_position, limit
+            )
+            return [self._row_to_event(row) for row in rows]
+
+    async def subscribe(
+        self,
+        subscription_id: str,
+        handler,
+        from_position: int = 0,
+        batch_size: int = 100
+    ):
+        """Subscribe to all events from a position."""
+        # Get checkpoint
+        async with self.pool.acquire() as conn:
+            checkpoint = await conn.fetchval(
+                """
+                SELECT last_position FROM subscription_checkpoints
+                WHERE subscription_id = $1
+                """,
+                subscription_id
+            )
+            position = checkpoint or from_position
+
+        while True:
+            events = await self.read_all(position, batch_size)
+            if not events:
+                await asyncio.sleep(1)  # Poll interval
+                continue
+
+            for event in events:
+                await handler(event)
+                position = event.global_position
+
+            # Save checkpoint
+            async with self.pool.acquire() as conn:
+                await conn.execute(
+                    """
+                    INSERT INTO subscription_checkpoints (subscription_id, last_position)
+                    VALUES ($1, $2)
+                    ON CONFLICT (subscription_id)
+                    DO UPDATE SET last_position = $2, updated_at = NOW()
+                    """,
+                    subscription_id, position
+                )
+
+    def _row_to_event(self, row) -> Event:
+        return Event(
+            event_id=row['id'],
+            stream_id=row['stream_id'],
+            event_type=row['event_type'],
+            data=json.loads(row['event_data']),
+            metadata=json.loads(row['metadata']),
+            version=row['version'],
+            global_position=row['global_position'],
+            created_at=row['created_at']
+        )
+
+
+class ConcurrencyError(Exception):
+    """Raised when optimistic concurrency check fails."""
+    pass
+```
+
+### Template 3: EventStoreDB Usage
+
+```python
+from esdbclient import EventStoreDBClient, NewEvent, StreamState
+import json
+
+# Connect
+client = EventStoreDBClient(uri="esdb://localhost:2113?tls=false")
+
+# Append events
+def append_events(stream_name: str, events: list, expected_revision=None):
+    new_events = [
+        NewEvent(
+            type=event['type'],
+            data=json.dumps(event['data']).encode(),
+            metadata=json.dumps(event.get('metadata', {})).encode()
+        )
+        for event in events
+    ]
+
+    if expected_revision is None:
+        state = StreamState.ANY
+    elif expected_revision == -1:
+        state = StreamState.NO_STREAM
+    else:
+        state = expected_revision
+
+    return client.append_to_stream(
+        stream_name=stream_name,
+        events=new_events,
+        current_version=state
+    )
+
+# Read stream
+def read_stream(stream_name: str, from_revision: int = 0):
+    events = client.get_stream(
+        stream_name=stream_name,
+        stream_position=from_revision
+    )
+    return [
+        {
+            'type': event.type,
+            'data': json.loads(event.data),
+            'metadata': json.loads(event.metadata) if event.metadata else {},
+            'stream_position': event.stream_position,
+            'commit_position': event.commit_position
+        }
+        for event in events
+    ]
+
+# Subscribe to all
+async def subscribe_to_all(handler, from_position: int = 0):
+    subscription = client.subscribe_to_all(commit_position=from_position)
+    async for event in subscription:
+        await handler({
+            'type': event.type,
+            'data': json.loads(event.data),
+            'stream_id': event.stream_name,
+            'position': event.commit_position
+        })
+
+# Category projection ($ce-Category)
+def read_category(category: str):
+    """Read all events for a category using system projection."""
+    return read_stream(f"$ce-{category}")
+```
+
+### Template 4: DynamoDB Event Store
+
+```python
+import boto3
+from boto3.dynamodb.conditions import Key
+from datetime import datetime
+import json
+import uuid
+
+class DynamoEventStore:
+    def __init__(self, table_name: str):
+        self.dynamodb = boto3.resource('dynamodb')
+        self.table = self.dynamodb.Table(table_name)
+
+    def append_events(self, stream_id: str, events: list, expected_version: int = None):
+        """Append events with conditional write for concurrency."""
+        with self.table.batch_writer() as batch:
+            for i, event in enumerate(events):
+                version = (expected_version or 0) + i + 1
+                item = {
+                    'PK': f"STREAM#{stream_id}",
+                    'SK': f"VERSION#{version:020d}",
+                    'GSI1PK': 'EVENTS',
+                    'GSI1SK': datetime.utcnow().isoformat(),
+                    'event_id': str(uuid.uuid4()),
+                    'stream_id': stream_id,
+                    'event_type': event['type'],
+                    'event_data': json.dumps(event['data']),
+                    'version': version,
+                    'created_at': datetime.utcnow().isoformat()
+                }
+                batch.put_item(Item=item)
+        return events
+
+    def read_stream(self, stream_id: str, from_version: int = 0):
+        """Read events from a stream."""
+        response = self.table.query(
+            KeyConditionExpression=Key('PK').eq(f"STREAM#{stream_id}") &
+                                  Key('SK').gte(f"VERSION#{from_version:020d}")
+        )
+        return [
+            {
+                'event_type': item['event_type'],
+                'data': json.loads(item['event_data']),
+                'version': item['version']
+            }
+            for item in response['Items']
+        ]
+
+# Table definition (CloudFormation/Terraform)
+"""
+DynamoDB Table:
+  - PK (Partition Key): String
+  - SK (Sort Key): String
+  - GSI1PK, GSI1SK for global ordering
+
+Capacity: On-demand or provisioned based on throughput needs
+"""
+```
+
+## Best Practices
+
+### Do's
+
+- **Use stream IDs that include aggregate type** - `Order-{uuid}`
+- **Include correlation/causation IDs** - For tracing
+- **Version events from day one** - Plan for schema evolution
+- **Implement idempotency** - Use event IDs for deduplication
+- **Index appropriately** - For your query patterns
+
+### Don'ts
+
+- **Don't update or delete events** - They're immutable facts
+- **Don't store large payloads** - Keep events small
+- **Don't skip optimistic concurrency** - Prevents data corruption
+- **Don't ignore backpressure** - Handle slow consumers
+
+## Resources
+
+- [EventStoreDB](https://www.eventstore.com/)
+- [Marten Events](https://martendb.io/events/)
+- [Event Sourcing Pattern](https://docs.microsoft.com/en-us/azure/architecture/patterns/event-sourcing)

package/merged-commands/exa-search.md

@@ -0,0 +1,36 @@
+---
+name: exa-search
+description: Semantic search, similar content discovery, and structured research using Exa API
+---
+
+# exa-search
+
+## Overview
+Semantic search, similar content discovery, and structured research using Exa API
+
+## When to Use
+- When you need semantic/embeddings-based search
+- When finding similar content
+- When searching by category (company, people, research papers, etc.)
+
+## Installation
+```bash
+npx skills add -g BenedictKing/exa-search
+```
+
+## Step-by-Step Guide
+1. Install the skill using the command above
+2. Configure Exa API key
+3. Use naturally in Claude Code conversations
+
+## Examples
+See [GitHub Repository](https://github.com/BenedictKing/exa-search) for examples.
+
+## Best Practices
+- Configure API keys via environment variables
+
+## Troubleshooting
+See the GitHub repository for troubleshooting guides.
+
+## Related Skills
+- context7-auto-research, tavily-web, firecrawl-scraper, codex-review

package/merged-commands/executing-plans.md

@@ -0,0 +1,76 @@
+---
+name: executing-plans
+description: Use when you have a written implementation plan to execute in a separate session with review checkpoints
+---
+
+# Executing Plans
+
+## Overview
+
+Load plan, review critically, execute tasks in batches, report for review between batches.
+
+**Core principle:** Batch execution with checkpoints for architect review.
+
+**Announce at start:** "I'm using the executing-plans skill to implement this plan."
+
+## The Process
+
+### Step 1: Load and Review Plan
+1. Read plan file
+2. Review critically - identify any questions or concerns about the plan
+3. If concerns: Raise them with your human partner before starting
+4. If no concerns: Create TodoWrite and proceed
+
+### Step 2: Execute Batch
+**Default: First 3 tasks**
+
+For each task:
+1. Mark as in_progress
+2. Follow each step exactly (plan has bite-sized steps)
+3. Run verifications as specified
+4. Mark as completed
+
+### Step 3: Report
+When batch complete:
+- Show what was implemented
+- Show verification output
+- Say: "Ready for feedback."
+
+### Step 4: Continue
+Based on feedback:
+- Apply changes if needed
+- Execute next batch
+- Repeat until complete
+
+### Step 5: Complete Development
+
+After all tasks complete and verified:
+- Announce: "I'm using the finishing-a-development-branch skill to complete this work."
+- **REQUIRED SUB-SKILL:** Use superpowers:finishing-a-development-branch
+- Follow that skill to verify tests, present options, execute choice
+
+## When to Stop and Ask for Help
+
+**STOP executing immediately when:**
+- Hit a blocker mid-batch (missing dependency, test fails, instruction unclear)
+- Plan has critical gaps preventing starting
+- You don't understand an instruction
+- Verification fails repeatedly
+
+**Ask for clarification rather than guessing.**
+
+## When to Revisit Earlier Steps
+
+**Return to Review (Step 1) when:**
+- Partner updates the plan based on your feedback
+- Fundamental approach needs rethinking
+
+**Don't force through blockers** - stop and ask.
+
+## Remember
+- Review plan critically first
+- Follow plan steps exactly
+- Don't skip verifications
+- Reference skills when plan says to
+- Between batches: just report and wait
+- Stop when blocked, don't guess

package/merged-commands/expo-app-design.md

@@ -0,0 +1,22 @@
+---
+name: expo-app-design
+description: Build beautiful cross-platform mobile apps with Expo Router, NativeWind, and React Native.
+author: expo
+category: development
+tags: [expo, react, typescript]
+---
+
+# Expo App Design
+
+Build beautiful cross-platform mobile apps with Expo Router, NativeWind, and React Native.
+
+## When to Use
+
+- Building mobile apps with Expo
+- Navigation with Expo Router
+- Styling with NativeWind/Tailwind
+- Native tabs and animations
+
+## Source
+
+This skill references patterns from [Expo's skills](https://github.com/expo/skills).