omgkit 2.1.1 → 2.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omgkit",
-  "version": "2.1.1",
+  "version": "2.3.0",
   "description": "Omega-Level Development Kit - AI Team System for Claude Code. 23 agents, 54 commands, 72 skills, sprint management.",
   "keywords": [
     "claude-code",

package/plugin/skills/databases/mongodb/SKILL.md

@@ -1,43 +1,96 @@
 ---
-name: mongodb
-description: MongoDB database. Use for document storage, aggregation, NoSQL.
+name: Developing with MongoDB
+description: The agent implements MongoDB NoSQL database solutions with document modeling, aggregation pipelines, and Mongoose ODM. Use when building document-based applications, designing schemas, writing aggregations, or implementing NoSQL patterns.
 ---
 
-# MongoDB Skill
+# Developing with MongoDB
 
-## Document Design
-```javascript
-{
-  _id: ObjectId(),
-  email: "user@example.com",
+## Quick Start
+
+```typescript
+// Schema with Mongoose
+import mongoose, { Schema, Document } from 'mongoose';
+
+interface IUser extends Document {
+  email: string;
+  profile: { firstName: string; lastName: string };
+  createdAt: Date;
+}
+
+const userSchema = new Schema<IUser>({
+  email: { type: String, required: true, unique: true, lowercase: true },
   profile: {
-    name: "John",
-    avatar: "url"
+    firstName: { type: String, required: true },
+    lastName: { type: String, required: true },
   },
-  createdAt: ISODate()
+}, { timestamps: true });
+
+userSchema.index({ email: 1 });
+export const User = mongoose.model<IUser>('User', userSchema);
+```
+
+## Features
+
+| Feature | Description | Guide |
+|---------|-------------|-------|
+| Document Schema | Type-safe schema design with Mongoose | Embed related data, use references for large collections |
+| CRUD Operations | Create, read, update, delete with type safety | Use `findById`, `findOne`, `updateOne`, `deleteOne` |
+| Aggregation Pipelines | Complex data transformations and analytics | Chain `$match`, `$group`, `$lookup`, `$project` stages |
+| Indexing | Query optimization with proper indexes | Create compound indexes matching query patterns |
+| Transactions | Multi-document ACID operations | Use sessions for operations requiring atomicity |
+| Change Streams | Real-time data change notifications | Watch collections for inserts, updates, deletes |
+
+## Common Patterns
+
+### Repository Pattern with Pagination
+
+```typescript
+async findPaginated(filter: FilterQuery<IUser>, page = 1, limit = 20) {
+  const [data, total] = await Promise.all([
+    User.find(filter).sort({ createdAt: -1 }).skip((page - 1) * limit).limit(limit),
+    User.countDocuments(filter),
+  ]);
+  return { data, pagination: { page, limit, total, totalPages: Math.ceil(total / limit) } };
 }
 ```
 
-## Query Patterns
-```javascript
-// Find
-db.users.find({ email: /example.com/ });
+### Aggregation Pipeline
 
-// Aggregation
-db.users.aggregate([
-  { $match: { active: true } },
-  { $group: { _id: "$role", count: { $sum: 1 } } }
+```typescript
+const stats = await Order.aggregate([
+  { $match: { status: 'completed', createdAt: { $gte: startDate } } },
+  { $group: { _id: '$userId', total: { $sum: '$amount' }, count: { $sum: 1 } } },
+  { $sort: { total: -1 } },
+  { $limit: 10 },
 ]);
+```
 
-// Update
-db.users.updateOne(
-  { _id: id },
-  { $set: { name: "New Name" } }
-);
+### Transaction for Order Creation
+
+```typescript
+const session = await mongoose.startSession();
+try {
+  session.startTransaction();
+  await Product.updateOne({ _id: productId }, { $inc: { stock: -quantity } }, { session });
+  const order = await Order.create([{ userId, items, total }], { session });
+  await session.commitTransaction();
+  return order[0];
+} catch (error) {
+  await session.abortTransaction();
+  throw error;
+} finally {
+  session.endSession();
+}
 ```
 
 ## Best Practices
-- Design for queries
-- Embed related data
-- Use indexes
-- Avoid deep nesting
+
+| Do | Avoid |
+|----|-------|
+| Design schemas based on query patterns | Embedding large arrays in documents |
+| Create indexes for frequently queried fields | Using `$where` or mapReduce in production |
+| Use `lean()` for read-only queries | Skipping validation on writes |
+| Implement pagination for large datasets | Storing large files directly (use GridFS) |
+| Set connection pool size appropriately | Hardcoding connection strings |
+| Use transactions for multi-document ops | Ignoring index usage in explain plans |
+| Add TTL indexes for expiring data | Creating too many indexes (write overhead) |

package/plugin/skills/databases/prisma/SKILL.md

@@ -1,55 +1,110 @@
 ---
-name: prisma
-description: Prisma ORM. Use for database access, migrations, type-safe queries.
+name: Developing with Prisma
+description: The agent implements Prisma ORM for type-safe database access with schema design, migrations, and queries. Use when building database layers, designing relational schemas, implementing type-safe queries, or managing database migrations.
 ---
 
-# Prisma Skill
+# Developing with Prisma
+
+## Quick Start
 
-## Schema
 ```prisma
+// prisma/schema.prisma
+generator client {
+  provider = "prisma-client-js"
+}
+
+datasource db {
+  provider = "postgresql"
+  url      = env("DATABASE_URL")
+}
+
 model User {
   id        String   @id @default(cuid())
   email     String   @unique
   posts     Post[]
   createdAt DateTime @default(now())
+  @@index([email])
 }
 
 model Post {
   id       String @id @default(cuid())
   title    String
-  author   User   @relation(fields: [authorId], references: [id])
   authorId String
+  author   User   @relation(fields: [authorId], references: [id])
 }
 ```
 
-## Queries
+```bash
+npx prisma migrate dev --name init
+npx prisma generate
+```
+
+## Features
+
+| Feature | Description | Guide |
+|---------|-------------|-------|
+| Schema Design | Declarative data modeling with relations | Define models, relations, indexes in schema.prisma |
+| Type-Safe Queries | Auto-generated TypeScript types | Use `findMany`, `findUnique`, `create`, `update` |
+| Migrations | Version-controlled schema changes | `prisma migrate dev` for development, `deploy` for production |
+| Relations | One-to-one, one-to-many, many-to-many | Use `include` or `select` to load related data |
+| Transactions | ACID operations across multiple queries | Use `$transaction` for atomic operations |
+| Raw Queries | Execute raw SQL when needed | Use `$queryRaw` for complex queries |
+
+## Common Patterns
+
+### Repository with Pagination
+
 ```typescript
-// Create
-const user = await prisma.user.create({
-  data: { email: 'test@example.com' }
-});
-
-// Find with relations
-const users = await prisma.user.findMany({
-  include: { posts: true },
-  where: { email: { contains: '@example.com' } }
-});
-
-// Update
-await prisma.user.update({
-  where: { id },
-  data: { email: 'new@example.com' }
-});
-
-// Transaction
-await prisma.$transaction([
-  prisma.user.create({ data: userData }),
-  prisma.post.create({ data: postData })
-]);
+async function findUsers(page = 1, limit = 20, where?: Prisma.UserWhereInput) {
+  const [data, total] = await prisma.$transaction([
+    prisma.user.findMany({ where, skip: (page - 1) * limit, take: limit, include: { profile: true } }),
+    prisma.user.count({ where }),
+  ]);
+  return { data, pagination: { page, limit, total, totalPages: Math.ceil(total / limit) } };
+}
+```
+
+### Interactive Transaction
+
+```typescript
+async function createOrder(userId: string, items: { productId: string; qty: number }[]) {
+  return prisma.$transaction(async (tx) => {
+    let total = 0;
+    for (const item of items) {
+      const product = await tx.product.update({
+        where: { id: item.productId },
+        data: { stock: { decrement: item.qty } },
+      });
+      if (product.stock < 0) throw new Error(`Insufficient stock: ${product.name}`);
+      total += product.price * item.qty;
+    }
+    return tx.order.create({ data: { userId, total, items: { create: items } } });
+  });
+}
+```
+
+### Cursor-Based Pagination
+
+```typescript
+async function getPaginatedPosts(cursor?: string, take = 20) {
+  const posts = await prisma.post.findMany({
+    take: take + 1,
+    ...(cursor && { skip: 1, cursor: { id: cursor } }),
+    orderBy: { createdAt: 'desc' },
+  });
+  const hasMore = posts.length > take;
+  return { data: hasMore ? posts.slice(0, -1) : posts, nextCursor: hasMore ? posts[take - 1].id : null };
+}
 ```
 
 ## Best Practices
-- Use migrations
-- Use transactions
-- Include only needed relations
-- Use select for partial data
+
+| Do | Avoid |
+|----|-------|
+| Use `select` to fetch only needed fields | Exposing Prisma Client directly in APIs |
+| Create indexes for frequently queried fields | Skipping migrations in production |
+| Use transactions for multi-table operations | Ignoring N+1 query problems |
+| Run migrations in CI/CD pipelines | Hardcoding connection strings |
+| Use connection pooling in production | Using raw queries unless necessary |
+| Validate input before database operations | Using implicit many-to-many for complex joins |
+| Seed development databases consistently | Ignoring transaction isolation levels |

package/plugin/skills/databases/redis/SKILL.md

@@ -1,41 +1,94 @@
 ---
-name: redis
-description: Redis caching. Use for caching, sessions, pub/sub.
+name: Developing with Redis
+description: The agent implements Redis caching, data structures, and real-time messaging patterns. Use when implementing caching layers, session storage, rate limiting, pub/sub messaging, or distributed data structures.
 ---
 
-# Redis Skill
+# Developing with Redis
 
-## Patterns
+## Quick Start
 
-### Caching
-```javascript
-// Set with expiry
-await redis.set('user:123', JSON.stringify(user), 'EX', 3600);
+```typescript
+import Redis from 'ioredis';
 
-// Get
+const redis = new Redis({
+  host: process.env.REDIS_HOST || 'localhost',
+  port: parseInt(process.env.REDIS_PORT || '6379'),
+  maxRetriesPerRequest: 3,
+});
+
+// Basic caching
+await redis.setex('user:123', 3600, JSON.stringify(userData));
 const cached = await redis.get('user:123');
-if (cached) return JSON.parse(cached);
 ```
 
-### Session
-```javascript
-await redis.hset(`session:${id}`, {
-  userId: user.id,
-  createdAt: Date.now()
-});
-await redis.expire(`session:${id}`, 86400);
+## Features
+
+| Feature | Description | Guide |
+|---------|-------------|-------|
+| Caching | High-speed key-value storage with TTL | Use `setex` for auto-expiration, `get` for retrieval |
+| Session Storage | Distributed session management | Store sessions with user ID index for multi-device |
+| Rate Limiting | Request throttling with sliding windows | Use sorted sets or token bucket algorithms |
+| Pub/Sub | Real-time messaging between services | Separate subscriber connections from publishers |
+| Streams | Event sourcing and message queues | Consumer groups for reliable message processing |
+| Data Structures | Lists, sets, sorted sets, hashes | Choose structure based on access patterns |
+
+## Common Patterns
+
+### Cache-Aside Pattern
+
+```typescript
+async function getOrSet<T>(key: string, factory: () => Promise<T>, ttl = 3600): Promise<T> {
+  const cached = await redis.get(key);
+  if (cached) return JSON.parse(cached);
+
+  const value = await factory();
+  await redis.setex(key, ttl, JSON.stringify(value));
+  return value;
+}
 ```
 
-### Rate Limiting
-```javascript
-const key = `rate:${ip}`;
-const count = await redis.incr(key);
-if (count === 1) await redis.expire(key, 60);
-if (count > 100) throw new Error('Rate limited');
+### Sliding Window Rate Limiter
+
+```typescript
+async function checkRateLimit(key: string, limit: number, windowSec: number): Promise<boolean> {
+  const now = Date.now();
+  const windowStart = now - windowSec * 1000;
+
+  const pipeline = redis.pipeline();
+  pipeline.zremrangebyscore(key, '-inf', windowStart);
+  pipeline.zadd(key, now, `${now}:${Math.random()}`);
+  pipeline.zcard(key);
+  pipeline.expire(key, windowSec);
+
+  const results = await pipeline.exec();
+  const count = results?.[2]?.[1] as number;
+  return count <= limit;
+}
+```
+
+### Distributed Lock
+
+```typescript
+async function acquireLock(key: string, ttlMs = 10000): Promise<string | null> {
+  const lockId = crypto.randomUUID();
+  const acquired = await redis.set(`lock:${key}`, lockId, 'PX', ttlMs, 'NX');
+  return acquired === 'OK' ? lockId : null;
+}
+
+async function releaseLock(key: string, lockId: string): Promise<boolean> {
+  const script = `if redis.call("get",KEYS[1])==ARGV[1] then return redis.call("del",KEYS[1]) else return 0 end`;
+  return (await redis.eval(script, 1, `lock:${key}`, lockId)) === 1;
+}
 ```
 
 ## Best Practices
-- Set TTL on keys
-- Use pipelines for batch ops
-- Use appropriate data structures
-- Monitor memory usage
+
+| Do | Avoid |
+|----|-------|
+| Set TTL on all cache keys | Storing objects larger than 100KB |
+| Use pipelines for batch operations | Using `KEYS` command in production |
+| Implement connection pooling | Ignoring memory limits and eviction |
+| Use Lua scripts for atomic operations | Using Redis as primary database |
+| Add key prefixes for namespacing | Blocking on long-running operations |
+| Monitor memory with `INFO memory` | Storing sensitive data unencrypted |
+| Set up Redis Sentinel for HA | Skipping connection error handling |

package/plugin/skills/devops/aws/SKILL.md

@@ -1,51 +1,105 @@
 ---
-name: aws
-description: AWS services. Use for Lambda, S3, RDS, ECS, and other AWS services.
+name: Deploying to AWS
+description: The agent implements AWS cloud solutions with Lambda, S3, DynamoDB, ECS, and CDK infrastructure as code. Use when building serverless functions, deploying containers, managing cloud storage, or defining infrastructure as code.
 ---
 
-# AWS Skill
+# Deploying to AWS
 
-## Common Services
+## Quick Start
 
-### Lambda
 ```typescript
-export const handler = async (event: APIGatewayEvent) => {
-  const body = JSON.parse(event.body || '{}');
+// Lambda handler
+import { APIGatewayProxyEvent, APIGatewayProxyResult } from 'aws-lambda';
 
+export const handler = async (event: APIGatewayProxyEvent): Promise<APIGatewayProxyResult> => {
+  const { id } = event.pathParameters || {};
   return {
     statusCode: 200,
-    body: JSON.stringify({ message: 'Success' }),
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ id, message: 'Success' }),
   };
 };
 ```
 
-### S3
+```bash
+# Deploy with CDK
+npx cdk deploy --all
+```
+
+## Features
+
+| Feature | Description | Guide |
+|---------|-------------|-------|
+| Lambda | Serverless function execution | Use for APIs, event processing, scheduled tasks |
+| S3 | Object storage with presigned URLs | Store files, serve static assets, data lakes |
+| DynamoDB | NoSQL database with single-digit ms latency | Design single-table schemas with GSIs |
+| ECS/Fargate | Container orchestration | Run Docker containers without managing servers |
+| API Gateway | REST and WebSocket API management | Throttling, auth, request validation |
+| CDK | Infrastructure as TypeScript code | Define stacks, manage deployments programmatically |
+
+## Common Patterns
+
+### S3 Presigned Upload URL
+
 ```typescript
 import { S3Client, PutObjectCommand } from '@aws-sdk/client-s3';
+import { getSignedUrl } from '@aws-sdk/s3-request-presigner';
+
+const s3 = new S3Client({});
 
-const s3 = new S3Client({ region: 'us-east-1' });
+async function getUploadUrl(key: string, contentType: string): Promise<string> {
+  const command = new PutObjectCommand({ Bucket: process.env.BUCKET!, Key: key, ContentType: contentType });
+  return getSignedUrl(s3, command, { expiresIn: 3600 });
+}
+```
+
+### DynamoDB Single-Table Pattern
+
+```typescript
+import { DynamoDBDocumentClient, QueryCommand } from '@aws-sdk/lib-dynamodb';
 
-await s3.send(new PutObjectCommand({
-  Bucket: 'my-bucket',
-  Key: 'file.txt',
-  Body: 'content',
-}));
+// pk: USER#123, sk: PROFILE | ORDER#timestamp
+async function getUserWithOrders(userId: string) {
+  const result = await docClient.send(new QueryCommand({
+    TableName: process.env.TABLE!,
+    KeyConditionExpression: 'pk = :pk',
+    ExpressionAttributeValues: { ':pk': `USER#${userId}` },
+  }));
+  return result.Items;
+}
 ```
 
-### DynamoDB
+### CDK Stack Definition
+
 ```typescript
-import { DynamoDBClient, PutItemCommand } from '@aws-sdk/client-dynamodb';
+import * as cdk from 'aws-cdk-lib';
+import * as lambda from 'aws-cdk-lib/aws-lambda';
+import * as dynamodb from 'aws-cdk-lib/aws-dynamodb';
+
+const table = new dynamodb.Table(this, 'Table', {
+  partitionKey: { name: 'pk', type: dynamodb.AttributeType.STRING },
+  sortKey: { name: 'sk', type: dynamodb.AttributeType.STRING },
+  billingMode: dynamodb.BillingMode.PAY_PER_REQUEST,
+});
 
-const client = new DynamoDBClient({});
+const fn = new lambda.Function(this, 'Handler', {
+  runtime: lambda.Runtime.NODEJS_20_X,
+  handler: 'index.handler',
+  code: lambda.Code.fromAsset('dist'),
+  environment: { TABLE_NAME: table.tableName },
+});
 
-await client.send(new PutItemCommand({
-  TableName: 'users',
-  Item: { id: { S: '123' }, email: { S: 'test@example.com' } },
-}));
+table.grantReadWriteData(fn);
 ```
 
 ## Best Practices
-- Use IAM roles
-- Enable encryption
-- Use VPC for security
-- Monitor with CloudWatch
+
+| Do | Avoid |
+|----|-------|
+| Use IAM roles, never access keys in code | Hardcoding credentials or secrets |
+| Enable encryption at rest and in transit | Exposing S3 buckets publicly |
+| Tag resources for cost tracking | Over-provisioning resources |
+| Use environment variables for config | Skipping CloudWatch alarms |
+| Implement least-privilege IAM policies | Using root account for deployments |
+| Enable X-Ray tracing for debugging | Synchronous invocations for long tasks |
+| Use VPC for sensitive workloads | Ignoring backup and disaster recovery |

package/plugin/skills/devops/github-actions/SKILL.md

@@ -1,12 +1,14 @@
 ---
-name: github-actions
-description: GitHub Actions CI/CD. Use for workflows, automation, deployments.
+name: Automating with GitHub Actions
+description: The agent implements GitHub Actions CI/CD workflows with builds, tests, and deployments. Use when setting up continuous integration, automating deployments, creating reusable actions, or implementing security scanning.
 ---
 
-# GitHub Actions Skill
+# Automating with GitHub Actions
+
+## Quick Start
 
-## CI Workflow
 ```yaml
+# .github/workflows/ci.yml
 name: CI
 
 on:
@@ -16,48 +18,98 @@ on:
     branches: [main]
 
 jobs:
-  test:
+  build:
     runs-on: ubuntu-latest
-
     steps:
       - uses: actions/checkout@v4
-
       - uses: actions/setup-node@v4
         with:
-          node-version: '20'
-          cache: 'npm'
-
+          node-version: 20
+          cache: npm
       - run: npm ci
-      - run: npm run lint
       - run: npm test
       - run: npm run build
 ```
 
-## Deploy Workflow
+## Features
+
+| Feature | Description | Guide |
+|---------|-------------|-------|
+| Workflows | Event-driven automation pipelines | Trigger on push, PR, schedule, or manual dispatch |
+| Jobs | Parallel or sequential task execution | Use `needs` for dependencies, matrix for variations |
+| Actions | Reusable workflow components | Use marketplace actions or create custom composite |
+| Environments | Deployment targets with protection | Configure approvals, secrets, and URLs |
+| Artifacts | Build output persistence | Upload/download between jobs, retention policies |
+| Caching | Dependency caching for speed | Cache npm, pip, gradle directories |
+
+## Common Patterns
+
+### Matrix Build
+
 ```yaml
-deploy:
-  needs: test
-  if: github.ref == 'refs/heads/main'
-  runs-on: ubuntu-latest
-
-  steps:
-    - uses: actions/checkout@v4
-    - run: npm ci && npm run build
-    - uses: some/deploy-action@v1
-      with:
-        token: ${{ secrets.DEPLOY_TOKEN }}
+jobs:
+  test:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+        node: [18, 20, 22]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: ${{ matrix.node }}
+      - run: npm ci && npm test
 ```
 
-## Matrix Build
+### Deployment with Environments
+
 ```yaml
-strategy:
-  matrix:
-    node: [18, 20, 22]
-    os: [ubuntu-latest, macos-latest]
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+    environment:
+      name: production
+      url: https://example.com
+    steps:
+      - uses: actions/checkout@v4
+      - run: npm ci && npm run build
+      - name: Deploy
+        run: ./deploy.sh
+        env:
+          DEPLOY_TOKEN: ${{ secrets.DEPLOY_TOKEN }}
+```
+
+### Docker Build and Push
+
+```yaml
+jobs:
+  docker:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: docker/setup-buildx-action@v3
+      - uses: docker/login-action@v3
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+      - uses: docker/build-push-action@v5
+        with:
+          push: true
+          tags: ghcr.io/${{ github.repository }}:${{ github.sha }}
+          cache-from: type=gha
+          cache-to: type=gha,mode=max
 ```
 
 ## Best Practices
-- Cache dependencies
-- Use matrix for multiple versions
-- Use secrets for sensitive data
-- Add status badges
+
+| Do | Avoid |
+|----|-------|
+| Use concurrency groups to cancel stale runs | Hardcoding secrets in workflows |
+| Cache dependencies for faster builds | Skipping security scanning |
+| Use matrix strategies for cross-platform | Using deprecated action versions |
+| Implement environment protection rules | Running unnecessary jobs on PRs |
+| Set timeouts on long-running jobs | Ignoring workflow permissions |
+| Use reusable workflows for common patterns | Self-hosted runners without security review |
+| Upload test artifacts on failure | Skipping concurrency controls |