claudeinone-cli 1.0.1 → 1.0.3

package/kit/.claude/skills/cache-redis.md

@@ -0,0 +1,195 @@
+# Redis Caching
+
+In-memory data store for caching, sessions, and real-time data.
+
+## Setup
+
+```bash
+npm install redis ioredis
+```
+
+## Basic Caching
+
+```typescript
+import { createClient } from 'redis';
+
+const redis = createClient({
+  host: 'localhost',
+  port: 6379
+});
+
+await redis.connect();
+
+// Set cache
+await redis.set('user:123', JSON.stringify({ id: '123', name: 'John' }), {
+  EX: 3600 // Expire in 1 hour
+});
+
+// Get cache
+const cached = await redis.get('user:123');
+const user = JSON.parse(cached || '{}');
+
+// Delete cache
+await redis.del('user:123');
+
+// Check exists
+const exists = await redis.exists('user:123');
+```
+
+## Cache-Aside Pattern
+
+```typescript
+async function getUser(userId: string) {
+  // Check cache first
+  const cached = await redis.get(`user:${userId}`);
+  if (cached) {
+    return JSON.parse(cached);
+  }
+
+  // Fetch from database
+  const user = await db.users.findById(userId);
+
+  // Store in cache
+  if (user) {
+    await redis.set(`user:${userId}`, JSON.stringify(user), {
+      EX: 3600
+    });
+  }
+
+  return user;
+}
+```
+
+## Cache Invalidation
+
+```typescript
+// Invalidate on update
+async function updateUser(userId: string, updates: any) {
+  const user = await db.users.update(userId, updates);
+
+  // Clear cache
+  await redis.del(`user:${userId}`);
+  
+  // Clear related caches
+  await redis.del(`user:${userId}:posts`);
+
+  return user;
+}
+
+// Pattern invalidation
+async function invalidateUserCaches(userId: string) {
+  const keys = await redis.keys(`user:${userId}:*`);
+  if (keys.length > 0) {
+    await redis.del(keys);
+  }
+}
+```
+
+## Session Storage
+
+```typescript
+import session from 'express-session';
+import RedisStore from 'connect-redis';
+
+const redisClient = createClient();
+
+const sessionStore = new RedisStore({ client: redisClient });
+
+app.use(
+  session({
+    store: sessionStore,
+    secret: process.env.SESSION_SECRET,
+    resave: false,
+    saveUninitialized: false,
+    cookie: {
+      httpOnly: true,
+      secure: process.env.NODE_ENV === 'production',
+      maxAge: 1000 * 60 * 60 * 24 // 24 hours
+    }
+  })
+);
+```
+
+## Lists & Queues
+
+```typescript
+// Push to queue
+await redis.lPush('email:queue', JSON.stringify({
+  to: 'user@example.com',
+  subject: 'Welcome'
+}));
+
+// Pop from queue
+const job = await redis.rPop('email:queue');
+
+// List length
+const count = await redis.lLen('email:queue');
+
+// Get range
+const jobs = await redis.lRange('email:queue', 0, -1);
+```
+
+## Sorted Sets (Leaderboards)
+
+```typescript
+// Add score
+await redis.zAdd('leaderboard', {
+  score: 100,
+  member: 'user:123'
+});
+
+// Increment score
+await redis.zIncrBy('leaderboard', 10, 'user:123');
+
+// Get top 10
+const topPlayers = await redis.zRevRange('leaderboard', 0, 9, {
+  WITHSCORES: true
+});
+
+// Get rank
+const rank = await redis.zRevRank('leaderboard', 'user:123');
+```
+
+## Pub/Sub
+
+```typescript
+// Subscriber
+const subscriber = redis.duplicate();
+await subscriber.connect();
+
+await subscriber.subscribe('channel:notifications', (message) => {
+  console.log('Notification:', message);
+});
+
+// Publisher
+await redis.publish('channel:notifications', JSON.stringify({
+  type: 'user:created',
+  userId: '123'
+}));
+```
+
+## Transactions
+
+```typescript
+const pipeline = redis.multi();
+
+pipeline.set('key1', 'value1');
+pipeline.set('key2', 'value2');
+pipeline.get('key1');
+pipeline.incr('counter');
+
+const results = await pipeline.exec();
+```
+
+## Best Practices
+
+✅ **TTL values** - Always set expiration times
+✅ **Key naming** - Use consistent patterns (entity:id:property)
+✅ **Connection pooling** - Reuse connections
+✅ **Monitoring** - Track hit rates and evictions
+✅ **Persistence** - Enable AOF/RDB for important data
+
+## Resources
+
+- [Redis Documentation](https://redis.io/documentation)
+- [Redis Node.js Client](https://github.com/luin/ioredis)

package/kit/.claude/skills/caching-strategies.md

@@ -0,0 +1,100 @@
+# Caching Strategies
+
+Implementing effective caching.
+
+## Cache Invalidation
+
+```typescript
+// Time-based expiration
+async function getCachedUser(id: string) {
+  const cache = new Map();
+  const CacheTTL = 60 * 60 * 1000; // 1 hour
+
+  const cached = cache.get(id);
+  if (cached && Date.now() - cached.timestamp < CacheTTL) {
+    return cached.data;
+  }
+
+  const user = await db.users.findById(id);
+  cache.set(id, { data: user, timestamp: Date.now() });
+  return user;
+}
+
+// Event-based invalidation
+async function updateUser(id: string, data: any) {
+  const user = await db.users.update(id, data);
+  
+  // Clear cache
+  cache.delete(`user:${id}`);
+  cache.delete('users:list');
+  
+  // Publish event
+  eventBus.emit('user:updated', user);
+  
+  return user;
+}
+
+// Dependency-based
+const userCache = cache.with('user', {
+  expires: 3600,
+  dependencies: ['user']
+});
+```
+
+## Multi-Level Caching
+
+```typescript
+// L1: Memory, L2: Redis, L3: Database
+async function getUser(id: string) {
+  // L1: Memory cache
+  if (memoryCache.has(`user:${id}`)) {
+    return memoryCache.get(`user:${id}`);
+  }
+
+  // L2: Redis
+  const cached = await redis.get(`user:${id}`);
+  if (cached) {
+    const user = JSON.parse(cached);
+    memoryCache.set(`user:${id}`, user);
+    return user;
+  }
+
+  // L3: Database
+  const user = await db.users.findById(id);
+  await redis.set(`user:${id}`, JSON.stringify(user), 'EX', 3600);
+  memoryCache.set(`user:${id}`, user);
+  
+  return user;
+}
+```
+
+## Cache Warming
+
+```typescript
+async function warmCache() {
+  const users = await db.users.find({ featured: true });
+  
+  for (const user of users) {
+    await redis.set(`user:${user.id}`, JSON.stringify(user), 'EX', 86400);
+  }
+  
+  console.log('Cache warmed');
+}
+
+// Run on startup
+app.listen(3000, () => {
+  warmCache().catch(console.error);
+});
+```
+
+## Best Practices
+
+✅ **Cache invalidation** - Know when to clear
+✅ **TTL strategy** - Appropriate expiration
+✅ **Multi-level** - Memory + Redis + DB
+✅ **Monitoring** - Track hit rates
+✅ **Size limits** - Prevent memory bloat
+
+## Resources
+
+- [Caching Patterns](https://codeahoy.com/2017/08/11/caching-strategies-explained/)

package/kit/.claude/skills/cloud-aws.md

@@ -0,0 +1,165 @@
+# AWS
+
+Cloud platform with EC2, S3, Lambda, DynamoDB, and RDS.
+
+## Lambda Functions
+
+```typescript
+// Basic handler
+export const handler = async (event: any) => {
+  return {
+    statusCode: 200,
+    body: JSON.stringify({ message: 'Hello from Lambda' })
+  };
+};
+
+// API Gateway integration
+export const apiHandler = async (event: APIGatewayProxyEvent) => {
+  const { pathParameters, body } = event;
+  const data = JSON.parse(body || '{}');
+  
+  return {
+    statusCode: 200,
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ data })
+  };
+};
+
+// S3 event trigger
+export const s3Handler = async (event: S3Event) => {
+  for (const record of event.Records) {
+    const bucket = record.s3.bucket.name;
+    const key = record.s3.object.key;
+    console.log(`Processing ${bucket}/${key}`);
+  }
+};
+```
+
+## S3 Storage
+
+```typescript
+import { S3Client, PutObjectCommand, GetObjectCommand } from '@aws-sdk/client-s3';
+
+const s3 = new S3Client({ region: 'us-east-1' });
+
+// Upload
+await s3.send(new PutObjectCommand({
+  Bucket: 'my-bucket',
+  Key: 'path/to/file.txt',
+  Body: Buffer.from('content'),
+  ContentType: 'text/plain'
+}));
+
+// Download
+const response = await s3.send(new GetObjectCommand({
+  Bucket: 'my-bucket',
+  Key: 'path/to/file.txt'
+}));
+
+const body = await response.Body?.transformToString();
+```
+
+## DynamoDB
+
+```typescript
+import { DynamoDBClient } from '@aws-sdk/client-dynamodb';
+import { DynamoDBDocumentClient, PutCommand, QueryCommand } from '@aws-sdk/lib-dynamodb';
+
+const db = DynamoDBDocumentClient.from(new DynamoDBClient({}));
+
+// Write
+await db.send(new PutCommand({
+  TableName: 'Users',
+  Item: {
+    userId: 'user-123',
+    email: 'user@example.com',
+    createdAt: Date.now()
+  }
+}));
+
+// Query
+const { Items } = await db.send(new QueryCommand({
+  TableName: 'Users',
+  KeyConditionExpression: 'userId = :id',
+  ExpressionAttributeValues: { ':id': 'user-123' }
+}));
+```
+
+## RDS (Relational Database)
+
+```typescript
+import mysql from 'mysql2/promise';
+
+const connection = await mysql.createConnection({
+  host: process.env.DB_HOST,
+  user: process.env.DB_USER,
+  password: process.env.DB_PASSWORD,
+  database: process.env.DB_NAME
+});
+
+const [rows] = await connection.execute(
+  'SELECT * FROM users WHERE id = ?',
+  [userId]
+);
+
+await connection.execute(
+  'INSERT INTO users (email, name) VALUES (?, ?)',
+  [email, name]
+);
+```
+
+## IAM & Secrets
+
+```typescript
+import { SecretsManagerClient, GetSecretValueCommand } from '@aws-sdk/client-secrets-manager';
+
+const secrets = new SecretsManagerClient({});
+
+const { SecretString } = await secrets.send(new GetSecretValueCommand({
+  SecretId: 'my-secret'
+}));
+
+const secret = JSON.parse(SecretString || '{}');
+```
+
+## CloudFormation
+
+```yaml
+AWSTemplateFormatVersion: '2010-09-09'
+Resources:
+  MyTable:
+    Type: AWS::DynamoDB::Table
+    Properties:
+      TableName: my-table
+      BillingMode: PAY_PER_REQUEST
+      AttributeDefinitions:
+        - AttributeName: id
+          AttributeType: S
+      KeySchema:
+        - AttributeName: id
+          KeyType: HASH
+
+  MyLambda:
+    Type: AWS::Lambda::Function
+    Properties:
+      FunctionName: my-function
+      Runtime: nodejs20.x
+      Handler: index.handler
+      Code:
+        ZipFile: |
+          exports.handler = async () => ({ statusCode: 200 });
+```
+
+## Best Practices
+
+✅ **Use SDK v3** - Modular imports reduce bundle size
+✅ **Connection pooling** - Reuse connections for RDS
+✅ **IAM roles** - Least privilege permissions
+✅ **Environment variables** - Store config in AWS Systems Manager
+✅ **CloudWatch logs** - Monitor function execution
+
+## Resources
+
+- [AWS SDK for JavaScript](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/)
+- [Lambda Developer Guide](https://docs.aws.amazon.com/lambda/)
+- [DynamoDB Documentation](https://docs.aws.amazon.com/dynamodb/)

package/kit/.claude/skills/cloud-azure.md

@@ -0,0 +1,187 @@
+# Microsoft Azure
+
+Cloud platform with App Service, Functions, Cosmos DB, and SQL Database.
+
+## Azure Functions
+
+```typescript
+import { AzureFunction, Context, HttpRequest } from '@azure/functions';
+
+const httpTrigger: AzureFunction = async (
+  context: Context,
+  req: HttpRequest
+): Promise<void> => {
+  context.log('HTTP trigger function processed a request.');
+
+  const name = req.query.name || req.body?.name || 'World';
+
+  context.res = {
+    status: 200,
+    body: `Hello, ${name}!`
+  };
+};
+
+export default httpTrigger;
+
+// Timer trigger
+const timerTrigger: AzureFunction = async (context: Context) => {
+  const timeStamp = new Date().toISOString();
+  context.log('Timer trigger function ran!', timeStamp);
+};
+```
+
+## Cosmos DB
+
+```typescript
+import { CosmosClient } from '@azure/cosmos';
+
+const client = new CosmosClient({
+  endpoint: process.env.COSMOS_ENDPOINT,
+  key: process.env.COSMOS_KEY
+});
+
+const database = client.database('my-db');
+const container = database.container('users');
+
+// Create item
+const { resource: createdItem } = await container.items.create({
+  id: 'user-123',
+  email: 'user@example.com',
+  age: 30
+});
+
+// Read item
+const { resource: item } = await container
+  .item('user-123', 'user-123')
+  .read();
+
+// Query
+const { resources: items } = await container.items
+  .query('SELECT * FROM c WHERE c.age > @age', { parameters: [{ name: '@age', value: 25 }] })
+  .fetchAll();
+
+// Update
+await container
+  .item('user-123', 'user-123')
+  .replace({ ...item, age: 31 });
+```
+
+## Azure SQL Database
+
+```typescript
+import sql from 'mssql';
+
+const config = {
+  user: process.env.DB_USER,
+  password: process.env.DB_PASSWORD,
+  server: process.env.DB_SERVER,
+  database: process.env.DB_NAME,
+  authentication: {
+    type: 'default'
+  },
+  options: {
+    encrypt: true,
+    trustServerCertificate: false,
+    connectionTimeout: 15000
+  }
+};
+
+const pool = new sql.ConnectionPool(config);
+await pool.connect();
+
+// Query
+const result = await pool.request()
+  .input('email', sql.VarChar, 'user@example.com')
+  .query('SELECT * FROM Users WHERE email = @email');
+
+console.log(result.recordset);
+
+// Insert
+await pool.request()
+  .input('email', sql.VarChar, 'new@example.com')
+  .input('name', sql.VarChar, 'John Doe')
+  .query('INSERT INTO Users (email, name) VALUES (@email, @name)');
+
+await pool.close();
+```
+
+## Blob Storage
+
+```typescript
+import { BlobServiceClient } from '@azure/storage-blob';
+
+const blobServiceClient = BlobServiceClient.fromConnectionString(
+  process.env.STORAGE_CONNECTION_STRING
+);
+
+const containerClient = blobServiceClient.getContainerClient('my-container');
+
+// Upload blob
+const blockBlobClient = containerClient.getBlockBlobClient('my-blob.txt');
+await blockBlobClient.upload('content', 7);
+
+// Download blob
+const downloadBlockBlobResponse = await blockBlobClient.download(0);
+const downloaded = await streamToString(downloadBlockBlobResponse.readableStreamBody);
+
+// List blobs
+for await (const blob of containerClient.listBlobsFlat()) {
+  console.log(`\t${blob.name}`);
+}
+```
+
+## Azure Key Vault
+
+```typescript
+import { SecretClient } from '@azure/keyvault-secrets';
+import { DefaultAzureCredential } from '@azure/identity';
+
+const vaultUrl = `https://${process.env.VAULT_NAME}.vault.azure.net`;
+const client = new SecretClient(vaultUrl, new DefaultAzureCredential());
+
+// Get secret
+const secret = await client.getSecret('my-secret');
+console.log(secret.value);
+
+// Set secret
+await client.setSecret('new-secret', 'secret-value');
+```
+
+## Application Insights (Monitoring)
+
+```typescript
+import appInsights from 'applicationinsights';
+
+appInsights.setup(process.env.APPINSIGHTS_INSTRUMENTATION_KEY)
+  .setAutoCollectConsole(true)
+  .start();
+
+const client = appInsights.defaultClient;
+
+// Track event
+client.trackEvent({
+  name: 'UserLogin',
+  properties: { userId: '123', method: 'OAuth' }
+});
+
+// Track exception
+try {
+  throw new Error('Something went wrong');
+} catch (error) {
+  client.trackException({ exception: error });
+}
+```
+
+## Best Practices
+
+✅ **Use managed identities** - Avoid connection strings in code
+✅ **Cosmos DB partitioning** - Design partition key for scalability
+✅ **Connection pooling** - Reuse SQL connections
+✅ **Application Insights** - Monitor performance and errors
+✅ **Use Azure DevOps** - CI/CD integration
+
+## Resources
+
+- [Azure Documentation](https://learn.microsoft.com/en-us/azure/)
+- [Cosmos DB Guide](https://learn.microsoft.com/en-us/azure/cosmos-db/)
+- [Azure Functions](https://learn.microsoft.com/en-us/azure/azure-functions/)

package/kit/.claude/skills/cloud-cloudflare.md

@@ -0,0 +1,74 @@
+# Cloudflare
+
+Edge computing platform with Workers, KV, and D1 database.
+
+## Workers
+
+```typescript
+// Basic worker
+export default {
+  async fetch(request: Request) {
+    return new Response('Hello World!', {
+      status: 200,
+      headers: { 'Content-Type': 'text/plain' }
+    });
+  }
+};
+```
+
+## KV Storage
+
+```typescript
+// Store data
+await NAMESPACE.put('key', 'value', { expirationTtl: 3600 });
+
+// Retrieve data
+const value = await NAMESPACE.get('key');
+
+// Delete
+await NAMESPACE.delete('key');
+```
+
+## D1 Database
+
+```typescript
+// Query database
+const { success, results } = await env.DB.prepare(
+  'SELECT * FROM users WHERE id = ?'
+).bind(1).all();
+
+// Insert
+await env.DB.prepare(
+  'INSERT INTO users (name, email) VALUES (?, ?)'
+).bind('John', 'john@example.com').run();
+```
+
+## Routes
+
+```toml
+# wrangler.toml
+name = "my-worker"
+main = "src/index.ts"
+compatibility_date = "2024-01-01"
+
+[[routes]]
+pattern = "example.com/api/*"
+zone_name = "example.com"
+
+[env.production]
+routes = [
+  { pattern = "example.com/*", zone_name = "example.com" }
+]
+```
+
+## Best Practices
+
+✅ **Use caching** - Reduce origin requests
+✅ **Monitor metrics** - Track performance
+✅ **Secure with authentication** - Use API keys
+✅ **Enable WAF rules** - Protect from attacks
+
+## Resources
+
+- [Cloudflare Docs](https://developers.cloudflare.com/)
+- [Workers Guide](https://developers.cloudflare.com/workers/)