autoworkflow 3.1.4 → 3.5.0

package/.claude/skills/redis.md

@@ -0,0 +1,391 @@
+# Redis Skill
+
+## Connection Setup
+\`\`\`typescript
+import Redis from 'ioredis';
+
+// Single instance
+const redis = new Redis({
+  host: process.env.REDIS_HOST || 'localhost',
+  port: parseInt(process.env.REDIS_PORT || '6379'),
+  password: process.env.REDIS_PASSWORD,
+  db: 0,
+  retryDelayOnFailover: 100,
+  maxRetriesPerRequest: 3,
+});
+
+// Cluster mode
+const cluster = new Redis.Cluster([
+  { host: 'node1', port: 6379 },
+  { host: 'node2', port: 6379 },
+]);
+
+// Connection events
+redis.on('connect', () => console.log('Redis connected'));
+redis.on('error', (err) => console.error('Redis error:', err));
+redis.on('reconnecting', () => console.log('Redis reconnecting'));
+\`\`\`
+
+## Data Structures
+
+### Strings (Key-Value)
+\`\`\`typescript
+// Basic operations
+await redis.set('key', 'value');
+await redis.set('key', 'value', 'EX', 3600);  // Expires in 1 hour
+await redis.set('key', 'value', 'NX');  // Only if not exists
+await redis.set('key', 'value', 'XX');  // Only if exists
+
+const value = await redis.get('key');
+const values = await redis.mget('key1', 'key2', 'key3');
+
+// Atomic operations
+await redis.incr('counter');
+await redis.incrby('counter', 5);
+await redis.decr('counter');
+await redis.incrbyfloat('price', 0.5);
+
+// Expiration
+await redis.expire('key', 3600);  // Set TTL
+await redis.ttl('key');  // Get remaining TTL
+await redis.persist('key');  // Remove expiration
+\`\`\`
+
+### Hashes (Objects)
+\`\`\`typescript
+// Store object fields
+await redis.hset('user:123', 'name', 'John', 'email', 'john@example.com');
+await redis.hset('user:123', { name: 'John', email: 'john@example.com', age: '30' });
+
+// Get fields
+const name = await redis.hget('user:123', 'name');
+const user = await redis.hgetall('user:123');  // All fields
+const fields = await redis.hmget('user:123', 'name', 'email');
+
+// Atomic increment
+await redis.hincrby('user:123', 'loginCount', 1);
+
+// Check/delete fields
+await redis.hexists('user:123', 'name');
+await redis.hdel('user:123', 'tempField');
+\`\`\`
+
+### Lists (Queues)
+\`\`\`typescript
+// Add to list
+await redis.lpush('queue', 'item1', 'item2');  // Add to front
+await redis.rpush('queue', 'item3');  // Add to back
+
+// Remove from list
+const item = await redis.lpop('queue');  // Remove from front
+const item = await redis.rpop('queue');  // Remove from back
+const item = await redis.blpop('queue', 30);  // Blocking pop (30s timeout)
+
+// Access elements
+const items = await redis.lrange('queue', 0, -1);  // All items
+const length = await redis.llen('queue');
+
+// Trim list (keep recent N)
+await redis.ltrim('recent:views', 0, 99);  // Keep last 100
+\`\`\`
+
+### Sets (Unique Collections)
+\`\`\`typescript
+// Add/remove members
+await redis.sadd('tags:post:123', 'redis', 'database', 'cache');
+await redis.srem('tags:post:123', 'cache');
+
+// Check membership
+const isMember = await redis.sismember('tags:post:123', 'redis');
+const members = await redis.smembers('tags:post:123');
+const count = await redis.scard('tags:post:123');
+
+// Set operations
+const common = await redis.sinter('user:1:skills', 'user:2:skills');  // Intersection
+const all = await redis.sunion('user:1:skills', 'user:2:skills');  // Union
+const diff = await redis.sdiff('user:1:skills', 'user:2:skills');  // Difference
+
+// Random member
+const random = await redis.srandmember('tags:post:123');
+\`\`\`
+
+### Sorted Sets (Ranked Data)
+\`\`\`typescript
+// Add with scores
+await redis.zadd('leaderboard', 100, 'player1', 85, 'player2', 120, 'player3');
+
+// Get rankings
+const top10 = await redis.zrevrange('leaderboard', 0, 9, 'WITHSCORES');  // Highest first
+const bottom10 = await redis.zrange('leaderboard', 0, 9, 'WITHSCORES');  // Lowest first
+
+// Get rank
+const rank = await redis.zrevrank('leaderboard', 'player1');  // 0-indexed from top
+const score = await redis.zscore('leaderboard', 'player1');
+
+// Range by score
+const players = await redis.zrangebyscore('leaderboard', 50, 100, 'WITHSCORES');
+
+// Increment score
+await redis.zincrby('leaderboard', 10, 'player1');
+
+// Remove
+await redis.zrem('leaderboard', 'player1');
+await redis.zremrangebyrank('leaderboard', 0, 9);  // Remove bottom 10
+\`\`\`
+
+## Common Patterns
+
+### Caching
+\`\`\`typescript
+async function getCachedUser(userId: string): Promise<User | null> {
+  const cacheKey = \`user:\${userId}\`;
+
+  // Try cache first
+  const cached = await redis.get(cacheKey);
+  if (cached) {
+    return JSON.parse(cached);
+  }
+
+  // Fetch from database
+  const user = await db.users.findById(userId);
+  if (user) {
+    // Cache for 1 hour
+    await redis.set(cacheKey, JSON.stringify(user), 'EX', 3600);
+  }
+
+  return user;
+}
+
+// Cache invalidation
+async function updateUser(userId: string, data: Partial<User>) {
+  await db.users.update(userId, data);
+  await redis.del(\`user:\${userId}\`);  // Invalidate cache
+}
+
+// Cache aside with lock (prevent stampede)
+async function getCachedWithLock(key: string, fetchFn: () => Promise<any>) {
+  const cached = await redis.get(key);
+  if (cached) return JSON.parse(cached);
+
+  const lockKey = \`lock:\${key}\`;
+  const acquired = await redis.set(lockKey, '1', 'NX', 'EX', 10);
+
+  if (acquired) {
+    const data = await fetchFn();
+    await redis.set(key, JSON.stringify(data), 'EX', 3600);
+    await redis.del(lockKey);
+    return data;
+  }
+
+  // Wait and retry if lock not acquired
+  await new Promise(resolve => setTimeout(resolve, 100));
+  return getCachedWithLock(key, fetchFn);
+}
+\`\`\`
+
+### Rate Limiting
+\`\`\`typescript
+// Fixed window rate limiting
+async function rateLimit(userId: string, limit: number, windowSec: number): Promise<boolean> {
+  const key = \`ratelimit:\${userId}:\${Math.floor(Date.now() / (windowSec * 1000))}\`;
+
+  const count = await redis.incr(key);
+  if (count === 1) {
+    await redis.expire(key, windowSec);
+  }
+
+  return count <= limit;
+}
+
+// Sliding window rate limiting (more accurate)
+async function slidingWindowRateLimit(
+  userId: string,
+  limit: number,
+  windowMs: number
+): Promise<{ allowed: boolean; remaining: number }> {
+  const key = \`ratelimit:\${userId}\`;
+  const now = Date.now();
+  const windowStart = now - windowMs;
+
+  // Remove old entries and add new one
+  await redis.zremrangebyscore(key, 0, windowStart);
+  const count = await redis.zcard(key);
+
+  if (count < limit) {
+    await redis.zadd(key, now, \`\${now}-\${Math.random()}\`);
+    await redis.expire(key, Math.ceil(windowMs / 1000));
+    return { allowed: true, remaining: limit - count - 1 };
+  }
+
+  return { allowed: false, remaining: 0 };
+}
+\`\`\`
+
+### Session Storage
+\`\`\`typescript
+// Store session
+async function createSession(userId: string, data: SessionData): Promise<string> {
+  const sessionId = crypto.randomUUID();
+  const key = \`session:\${sessionId}\`;
+
+  await redis.hset(key, {
+    userId,
+    ...data,
+    createdAt: Date.now().toString(),
+  });
+  await redis.expire(key, 86400);  // 24 hours
+
+  return sessionId;
+}
+
+// Get session
+async function getSession(sessionId: string): Promise<SessionData | null> {
+  const key = \`session:\${sessionId}\`;
+  const data = await redis.hgetall(key);
+
+  if (!data || Object.keys(data).length === 0) {
+    return null;
+  }
+
+  // Refresh TTL on access
+  await redis.expire(key, 86400);
+  return data as SessionData;
+}
+
+// Destroy session
+async function destroySession(sessionId: string): Promise<void> {
+  await redis.del(\`session:\${sessionId}\`);
+}
+\`\`\`
+
+### Pub/Sub
+\`\`\`typescript
+// Publisher
+const publisher = new Redis();
+await publisher.publish('notifications', JSON.stringify({
+  type: 'message',
+  userId: '123',
+  content: 'Hello!'
+}));
+
+// Subscriber
+const subscriber = new Redis();
+subscriber.subscribe('notifications', 'alerts');
+
+subscriber.on('message', (channel, message) => {
+  console.log(\`Received on \${channel}:\`, JSON.parse(message));
+});
+
+// Pattern subscription
+subscriber.psubscribe('events:*');
+subscriber.on('pmessage', (pattern, channel, message) => {
+  console.log(\`Pattern \${pattern}, channel \${channel}:\`, message);
+});
+\`\`\`
+
+### Distributed Locking
+\`\`\`typescript
+// Acquire lock with Redlock algorithm (simplified)
+async function acquireLock(
+  resource: string,
+  ttlMs: number
+): Promise<string | null> {
+  const lockKey = \`lock:\${resource}\`;
+  const lockValue = crypto.randomUUID();
+
+  const acquired = await redis.set(lockKey, lockValue, 'NX', 'PX', ttlMs);
+
+  return acquired ? lockValue : null;
+}
+
+// Release lock (only if we own it)
+async function releaseLock(resource: string, lockValue: string): Promise<boolean> {
+  const script = \`
+    if redis.call("get", KEYS[1]) == ARGV[1] then
+      return redis.call("del", KEYS[1])
+    else
+      return 0
+    end
+  \`;
+
+  const result = await redis.eval(script, 1, \`lock:\${resource}\`, lockValue);
+  return result === 1;
+}
+
+// Usage
+const lockValue = await acquireLock('order:123', 30000);
+if (lockValue) {
+  try {
+    // Do critical work
+  } finally {
+    await releaseLock('order:123', lockValue);
+  }
+}
+\`\`\`
+
+### Streams (Event Log)
+\`\`\`typescript
+// Add to stream
+await redis.xadd('events', '*', 'type', 'order_created', 'orderId', '123');
+
+// Read from stream
+const events = await redis.xrange('events', '-', '+', 'COUNT', 100);
+
+// Consumer group
+await redis.xgroup('CREATE', 'events', 'workers', '$', 'MKSTREAM');
+
+// Read as consumer
+const messages = await redis.xreadgroup(
+  'GROUP', 'workers', 'worker-1',
+  'COUNT', 10,
+  'BLOCK', 5000,
+  'STREAMS', 'events', '>'
+);
+
+// Acknowledge processed message
+await redis.xack('events', 'workers', messageId);
+\`\`\`
+
+## Transactions & Pipelines
+\`\`\`typescript
+// Pipeline (batch commands, no atomicity)
+const pipeline = redis.pipeline();
+pipeline.set('key1', 'value1');
+pipeline.set('key2', 'value2');
+pipeline.get('key1');
+const results = await pipeline.exec();
+
+// Transaction (atomic)
+const multi = redis.multi();
+multi.incr('counter');
+multi.set('lastUpdated', Date.now().toString());
+const results = await multi.exec();
+
+// Watch for optimistic locking
+await redis.watch('balance');
+const balance = parseInt(await redis.get('balance') || '0');
+if (balance >= 100) {
+  const multi = redis.multi();
+  multi.decrby('balance', 100);
+  multi.incr('purchases');
+  await multi.exec();  // Returns null if balance changed
+}
+\`\`\`
+
+## ❌ DON'T
+- Store large values (>100KB)
+- Use KEYS command in production (use SCAN)
+- Forget to set TTL on cache keys
+- Store sensitive data without encryption
+- Use blocking operations on main connection
+- Ignore connection errors/reconnection
+
+## ✅ DO
+- Use appropriate data structures for use case
+- Set TTL for all cache/temporary keys
+- Use pipelines for multiple operations
+- Use connection pooling in high-traffic apps
+- Monitor memory usage
+- Use Lua scripts for complex atomic operations
+- Design clear key naming conventions (namespace:id:field)
+- Use separate connections for pub/sub

package/.claude/skills/refactoring.md

@@ -0,0 +1,143 @@
+# Refactoring Skill
+
+## When to Refactor
+- Before adding new features
+- After getting tests passing
+- When you see duplication
+- When code is hard to understand
+- During code review feedback
+
+## Code Smells to Watch For
+
+### Complexity Smells
+- **Long Method**: > 20 lines, hard to understand
+- **Large Class**: Too many responsibilities
+- **Long Parameter List**: > 3 parameters
+- **Deep Nesting**: > 3 levels of indentation
+- **Complex Conditionals**: Hard to follow logic
+
+### Duplication Smells
+- **Repeated Code**: Same logic in multiple places
+- **Similar Classes**: Near-identical structures
+- **Magic Numbers**: Unexplained numeric values
+
+### Coupling Smells
+- **Feature Envy**: Method uses another class's data excessively
+- **Inappropriate Intimacy**: Classes too dependent on each other
+- **Message Chains**: a.getB().getC().getD()
+
+## Common Refactorings
+
+### Extract Function
+\`\`\`typescript
+// ❌ BEFORE
+function processOrder(order) {
+  // 30 lines of validation
+  // 20 lines of calculation
+  // 15 lines of notification
+}
+
+// ✅ AFTER
+function processOrder(order) {
+  validateOrder(order);
+  const total = calculateTotal(order);
+  notifyCustomer(order, total);
+}
+\`\`\`
+
+### Replace Conditional with Polymorphism
+\`\`\`typescript
+// ❌ BEFORE
+function getPrice(type) {
+  if (type === 'basic') return 10;
+  if (type === 'premium') return 20;
+  if (type === 'enterprise') return 50;
+}
+
+// ✅ AFTER
+const PRICES = { basic: 10, premium: 20, enterprise: 50 };
+const getPrice = (type) => PRICES[type];
+\`\`\`
+
+### Early Return (Guard Clauses)
+\`\`\`typescript
+// ❌ BEFORE
+function process(user) {
+  if (user) {
+    if (user.isActive) {
+      // deep nesting...
+    }
+  }
+}
+
+// ✅ AFTER
+function process(user) {
+  if (!user) return;
+  if (!user.isActive) return;
+  // flat code...
+}
+\`\`\`
+
+### Introduce Parameter Object
+\`\`\`typescript
+// ❌ BEFORE
+function createUser(name, email, age, role, department) { }
+
+// ✅ AFTER
+interface CreateUserParams {
+  name: string;
+  email: string;
+  age?: number;
+  role: string;
+  department: string;
+}
+function createUser(params: CreateUserParams) { }
+\`\`\`
+
+### Replace Magic Numbers
+\`\`\`typescript
+// ❌ BEFORE
+if (user.age >= 18) { }
+setTimeout(fn, 86400000);
+
+// ✅ AFTER
+const MINIMUM_AGE = 18;
+const ONE_DAY_MS = 24 * 60 * 60 * 1000;
+if (user.age >= MINIMUM_AGE) { }
+setTimeout(fn, ONE_DAY_MS);
+\`\`\`
+
+### Strangler Fig Pattern (Large Refactors)
+\`\`\`
+1. Create new implementation alongside old
+2. Route traffic gradually to new code
+3. Monitor for issues
+4. Remove old code when confident
+\`\`\`
+
+## IDE Shortcuts (VS Code)
+
+| Action | Windows/Linux | Mac |
+|--------|---------------|-----|
+| Rename Symbol | F2 | F2 |
+| Extract Function | Ctrl+Shift+R | Cmd+Shift+R |
+| Extract Variable | Ctrl+Shift+R | Cmd+Shift+R |
+| Move Line Up/Down | Alt+↑/↓ | Opt+↑/↓ |
+| Duplicate Line | Shift+Alt+↓ | Shift+Opt+↓ |
+| Delete Line | Ctrl+Shift+K | Cmd+Shift+K |
+| Quick Fix | Ctrl+. | Cmd+. |
+| Go to Definition | F12 | F12 |
+| Find All References | Shift+F12 | Shift+F12 |
+
+## ❌ DON'T
+- Refactor without tests
+- Refactor and add features at same time
+- Make huge changes in one commit
+- Refactor code you don't understand
+
+## ✅ DO
+- Small, incremental changes
+- Run tests after each change
+- Commit frequently
+- Use IDE refactoring tools (safer than manual)
+- Leave code cleaner than you found it