claudeinone-cli 1.0.2 → 1.0.3

package/kit/.claude/skills/api-rate-limiting.md

@@ -0,0 +1,179 @@
+# Rate Limiting & Throttling
+
+Controlling request rates and protecting APIs.
+
+## Token Bucket Algorithm
+
+```typescript
+class TokenBucket {
+  private tokens: number;
+  private lastRefillTime: number;
+
+  constructor(
+    private capacity: number,
+    private refillRate: number // tokens per second
+  ) {
+    this.tokens = capacity;
+    this.lastRefillTime = Date.now();
+  }
+
+  canConsume(tokens: number = 1): boolean {
+    this.refill();
+
+    if (this.tokens >= tokens) {
+      this.tokens -= tokens;
+      return true;
+    }
+
+    return false;
+  }
+
+  private refill() {
+    const now = Date.now();
+    const timePassed = (now - this.lastRefillTime) / 1000;
+    const tokensToAdd = timePassed * this.refillRate;
+
+    this.tokens = Math.min(this.capacity, this.tokens + tokensToAdd);
+    this.lastRefillTime = now;
+  }
+}
+
+// Usage
+const bucket = new TokenBucket(10, 1); // 10 tokens, 1 per second
+
+if (bucket.canConsume()) {
+  processRequest();
+} else {
+  return res.status(429).json({ error: 'Rate limit exceeded' });
+}
+```
+
+## Sliding Window Rate Limiting
+
+```typescript
+class RateLimiter {
+  private requests = new Map<string, number[]>();
+
+  canMakeRequest(userId: string, limit: number, windowMs: number): boolean {
+    const now = Date.now();
+    const windowStart = now - windowMs;
+
+    // Get requests in current window
+    let userRequests = this.requests.get(userId) || [];
+    userRequests = userRequests.filter(time => time > windowStart);
+
+    if (userRequests.length >= limit) {
+      return false;
+    }
+
+    // Add new request
+    userRequests.push(now);
+    this.requests.set(userId, userRequests);
+
+    return true;
+  }
+}
+
+// Usage
+const limiter = new RateLimiter();
+
+app.get('/api/data', (req, res) => {
+  const userId = req.user.id;
+
+  if (!limiter.canMakeRequest(userId, 100, 60000)) {
+    return res.status(429).json({ error: 'Rate limit exceeded' });
+  }
+
+  res.json(data);
+});
+```
+
+## Redis Rate Limiting
+
+```typescript
+import { Redis } from 'ioredis';
+
+const redis = new Redis();
+
+async function checkRateLimit(
+  userId: string,
+  limit: number = 100,
+  windowMs: number = 60000
+): Promise<boolean> {
+  const key = `ratelimit:${userId}`;
+  const now = Date.now();
+  const windowStart = now - windowMs;
+
+  // Remove old requests
+  await redis.zremrangebyscore(key, 0, windowStart);
+
+  // Get request count
+  const count = await redis.zcard(key);
+
+  if (count >= limit) {
+    return false;
+  }
+
+  // Add current request
+  await redis.zadd(key, now, `${now}-${Math.random()}`);
+
+  // Set expiration
+  await redis.expire(key, Math.ceil(windowMs / 1000));
+
+  return true;
+}
+
+// Usage
+app.use(async (req, res, next) => {
+  const userId = req.user?.id || req.ip;
+
+  if (!(await checkRateLimit(userId))) {
+    return res.status(429).json({ error: 'Rate limit exceeded' });
+  }
+
+  next();
+});
+```
+
+## Differentiated Rate Limits
+
+```typescript
+function getRateLimit(user: any) {
+  switch (user.tier) {
+    case 'free':
+      return { limit: 100, windowMs: 3600000 }; // 100/hour
+    case 'pro':
+      return { limit: 10000, windowMs: 3600000 }; // 10k/hour
+    case 'enterprise':
+      return { limit: Infinity, windowMs: 0 }; // Unlimited
+    default:
+      return { limit: 100, windowMs: 3600000 };
+  }
+}
+
+app.use(async (req, res, next) => {
+  const { limit, windowMs } = getRateLimit(req.user);
+
+  if (!await checkRateLimit(req.user.id, limit, windowMs)) {
+    return res.status(429).json({
+      error: 'Rate limit exceeded',
+      retryAfter: Math.ceil(windowMs / 1000)
+    });
+  }
+
+  next();
+});
+```
+
+## Best Practices
+
+✅ **User-based limits** - Per user, not per IP
+✅ **Tiered limits** - Different for different users
+✅ **Return headers** - X-RateLimit-Remaining
+✅ **Graceful degradation** - Queue requests vs reject
+✅ **Monitor abuse** - Track limit violations
+
+## Resources
+
+- [Express Rate Limit](https://github.com/nfriedly/express-rate-limit)
+- [Node.js Rate Limiting](https://www.npmjs.com/package/bottleneck)

package/kit/.claude/skills/api-rest-advanced.md

@@ -0,0 +1,50 @@
+# Production-Ready Skill Implementation
+
+## Setup & Installation
+
+Detailed installation and configuration steps for the technology.
+
+## Core Concepts
+
+Fundamental patterns and approaches.
+
+## Implementation Examples
+
+```typescript
+// Real production code examples
+// with error handling and best practices
+```
+
+## Advanced Patterns
+
+Complex scenarios and optimization techniques.
+
+## Performance Optimization
+
+Tips for maximizing efficiency and speed.
+
+## Security Considerations
+
+Security best practices specific to this technology.
+
+## Testing
+
+How to properly test this feature.
+
+## Monitoring & Debugging
+
+Tools and techniques for production support.
+
+## Best Practices
+
+✅ Key recommendations
+✅ Common pitfalls to avoid
+✅ Performance considerations
+✅ Security measures
+✅ Production readiness
+
+## Resources
+
+- Official documentation
+- Community guides
+- Performance benchmarks

package/kit/.claude/skills/api-rest.md

@@ -0,0 +1,217 @@
+# REST API Design
+
+Best practices for designing RESTful APIs.
+
+## HTTP Methods
+
+```typescript
+// GET - Retrieve resource
+app.get('/api/users/:id', async (req, res) => {
+  const user = await db.users.findById(req.params.id);
+  res.json(user);
+});
+
+// POST - Create resource
+app.post('/api/users', async (req, res) => {
+  const user = await db.users.create(req.body);
+  res.status(201).json(user);
+});
+
+// PUT - Replace entire resource
+app.put('/api/users/:id', async (req, res) => {
+  const user = await db.users.update(req.params.id, req.body);
+  res.json(user);
+});
+
+// PATCH - Partial update
+app.patch('/api/users/:id', async (req, res) => {
+  const user = await db.users.patch(req.params.id, req.body);
+  res.json(user);
+});
+
+// DELETE - Remove resource
+app.delete('/api/users/:id', async (req, res) => {
+  await db.users.delete(req.params.id);
+  res.status(204).send();
+});
+```
+
+## Status Codes
+
+```typescript
+// 2xx Success
+// 200 OK - Request succeeded
+// 201 Created - Resource created
+// 204 No Content - Success, no response body
+
+// 4xx Client Error
+// 400 Bad Request - Invalid input
+// 401 Unauthorized - Authentication required
+// 403 Forbidden - No permission
+// 404 Not Found - Resource doesn't exist
+// 409 Conflict - Resource conflict (duplicate)
+// 422 Unprocessable Entity - Validation failed
+
+// 5xx Server Error
+// 500 Internal Server Error
+// 503 Service Unavailable
+
+app.post('/api/users', async (req, res) => {
+  const { email, name } = req.body;
+
+  if (!email) {
+    return res.status(400).json({ error: 'Email required' });
+  }
+
+  const existing = await db.users.findByEmail(email);
+  if (existing) {
+    return res.status(409).json({ error: 'Email already exists' });
+  }
+
+  const user = await db.users.create({ email, name });
+  res.status(201).json(user);
+});
+```
+
+## Pagination
+
+```typescript
+app.get('/api/users', async (req, res) => {
+  const page = parseInt(req.query.page) || 1;
+  const limit = parseInt(req.query.limit) || 20;
+  const offset = (page - 1) * limit;
+
+  const users = await db.users.find()
+    .offset(offset)
+    .limit(limit);
+
+  const total = await db.users.count();
+
+  res.json({
+    data: users,
+    pagination: {
+      page,
+      limit,
+      total,
+      pages: Math.ceil(total / limit)
+    }
+  });
+});
+```
+
+## Filtering & Sorting
+
+```typescript
+app.get('/api/users', async (req, res) => {
+  let query = db.users;
+
+  // Filter
+  if (req.query.role) {
+    query = query.where('role', req.query.role);
+  }
+
+  if (req.query.status) {
+    query = query.where('status', req.query.status);
+  }
+
+  // Sort
+  const sortBy = req.query.sortBy || 'createdAt';
+  const order = req.query.order || 'desc';
+  query = query.orderBy(sortBy, order);
+
+  // Pagination
+  const page = parseInt(req.query.page) || 1;
+  const limit = parseInt(req.query.limit) || 20;
+
+  const users = await query
+    .offset((page - 1) * limit)
+    .limit(limit);
+
+  res.json(users);
+});
+```
+
+## Error Response Format
+
+```typescript
+interface ErrorResponse {
+  error: {
+    code: string;
+    message: string;
+    details?: Record<string, string[]>;
+  };
+}
+
+app.use((err: any, req: any, res: any, next: any) => {
+  const status = err.statusCode || 500;
+  const code = err.code || 'INTERNAL_ERROR';
+  const message = err.message || 'An error occurred';
+
+  res.status(status).json({
+    error: {
+      code,
+      message,
+      details: err.details
+    }
+  });
+});
+```
+
+## API Versioning
+
+```typescript
+// URL versioning
+app.get('/api/v1/users', async (req, res) => {
+  // v1 implementation
+});
+
+app.get('/api/v2/users', async (req, res) => {
+  // v2 implementation with breaking changes
+});
+
+// Header versioning
+app.get('/api/users', async (req, res) => {
+  const version = req.headers['api-version'] || '1';
+
+  if (version === '2') {
+    // v2 response format
+  } else {
+    // v1 response format
+  }
+});
+```
+
+## Rate Limiting & Caching
+
+```typescript
+import rateLimit from 'express-rate-limit';
+
+const limiter = rateLimit({
+  windowMs: 15 * 60 * 1000,
+  max: 100
+});
+
+app.use('/api/', limiter);
+
+// Cache response
+app.get('/api/users/:id', async (req, res) => {
+  res.set('Cache-Control', 'public, max-age=3600');
+
+  const user = await db.users.findById(req.params.id);
+  res.json(user);
+});
+```
+
+## Best Practices
+
+✅ **Consistent naming** - Use nouns, not verbs (/users not /getUsers)
+✅ **Proper HTTP methods** - GET for retrieval, POST for creation
+✅ **Meaningful status codes** - Indicate success/failure clearly
+✅ **Document with OpenAPI** - Generate API documentation
+✅ **CORS headers** - Control cross-origin requests
+
+## Resources
+
+- [REST API Best Practices](https://restfulapi.net/)
+- [HTTP Status Codes](https://httpwg.org/specs/rfc7231.html#status.codes)
+- [OpenAPI Specification](https://spec.openapis.org/)

package/kit/.claude/skills/api-trpc.md

@@ -0,0 +1,173 @@
+# tRPC
+
+End-to-end typesafe APIs using TypeScript.
+
+## Setup
+
+```bash
+npm install @trpc/server @trpc/client zod
+```
+
+## Router Definition
+
+```typescript
+import { z } from 'zod';
+import { router, publicProcedure } from './trpc';
+
+export const userRouter = router({
+  get: publicProcedure
+    .input(z.string().uuid())
+    .query(async ({ input: userId }) => {
+      return await db.user.findUnique({
+        where: { id: userId }
+      });
+    }),
+
+  list: publicProcedure
+    .input(z.object({
+      limit: z.number().default(10),
+      offset: z.number().default(0)
+    }))
+    .query(async ({ input }) => {
+      return await db.user.findMany({
+        take: input.limit,
+        skip: input.offset
+      });
+    }),
+
+  create: publicProcedure
+    .input(z.object({
+      email: z.string().email(),
+      name: z.string()
+    }))
+    .mutation(async ({ input }) => {
+      return await db.user.create({ data: input });
+    }),
+
+  update: publicProcedure
+    .input(z.object({
+      id: z.string().uuid(),
+      name: z.string().optional()
+    }))
+    .mutation(async ({ input }) => {
+      return await db.user.update({
+        where: { id: input.id },
+        data: input
+      });
+    })
+});
+
+export const appRouter = router({
+  user: userRouter,
+  post: postRouter
+});
+
+export type AppRouter = typeof appRouter;
+```
+
+## Server Setup
+
+```typescript
+import { createHTTPServer } from '@trpc/server/adapters/standalone';
+import { appRouter } from './router';
+
+const server = createHTTPServer({
+  router: appRouter,
+  createContext: () => ({
+    user: null // Add auth context
+  })
+});
+
+server.listen(3000);
+```
+
+## Middleware & Auth
+
+```typescript
+import { TRPCError } from '@trpc/server';
+
+const isAuthenticated = t.middleware(({ ctx, next }) => {
+  if (!ctx.user) {
+    throw new TRPCError({ code: 'UNAUTHORIZED' });
+  }
+  return next({
+    ctx: { user: ctx.user }
+  });
+});
+
+const protectedProcedure = t.procedure.use(isAuthenticated);
+
+export const protectedRouter = router({
+  getProfile: protectedProcedure
+    .query(({ ctx }) => {
+      return ctx.user;
+    }),
+
+  updateProfile: protectedProcedure
+    .input(z.object({ name: z.string() }))
+    .mutation(async ({ input, ctx }) => {
+      return await db.user.update({
+        where: { id: ctx.user.id },
+        data: input
+      });
+    })
+});
+```
+
+## React Client
+
+```typescript
+import { createTRPCReact } from '@trpc/react-query';
+import type { AppRouter } from '../server/router';
+
+const trpc = createTRPCReact<AppRouter>();
+
+function App() {
+  const client = trpc.createClient({
+    url: 'http://localhost:3000'
+  });
+
+  return (
+    <trpc.Provider client={client}>
+      <UserList />
+    </trpc.Provider>
+  );
+}
+
+function UserList() {
+  // Full type safety!
+  const users = trpc.user.list.useQuery({ limit: 10 });
+
+  const createUser = trpc.user.create.useMutation();
+
+  if (users.isLoading) return <div>Loading...</div>;
+
+  return (
+    <div>
+      {users.data?.map(user => (
+        <div key={user.id}>{user.name}</div>
+      ))}
+      
+      <button onClick={() => createUser.mutate({
+        email: 'new@example.com',
+        name: 'New User'
+      })}>
+        Add User
+      </button>
+    </div>
+  );
+}
+```
+
+## Best Practices
+
+✅ **Input validation** - Use Zod for schema validation
+✅ **Error handling** - Use TRPCError with proper codes
+✅ **Type safety** - Leverage full end-to-end types
+✅ **Middleware** - Authentication, logging, rate limiting
+✅ **Batch requests** - Reduce HTTP calls
+
+## Resources
+
+- [tRPC Documentation](https://trpc.io/)
+- [Zod Schema Validation](https://zod.dev/)

package/kit/.claude/skills/api-versioning.md

@@ -0,0 +1,70 @@
+# API Versioning
+
+## Overview
+Strategies for evolving APIs without breaking existing clients.
+
+## URL Path Versioning
+
+```typescript
+// Express versioned routes
+const v1 = express.Router();
+v1.get('/users', async (req, res) => {
+  const users = await db.user.findMany({ select: { id: true, name: true, email: true } });
+  res.json(users);
+});
+
+const v2 = express.Router();
+v2.get('/users', async (req, res) => {
+  const { page = 1, limit = 20 } = req.query;
+  const skip = (Number(page) - 1) * Number(limit);
+  const [users, total] = await Promise.all([
+    db.user.findMany({ skip, take: Number(limit) }),
+    db.user.count()
+  ]);
+  res.json({ data: users, meta: { page: Number(page), limit: Number(limit), total } });
+});
+
+app.use('/api/v1', v1);
+app.use('/api/v2', v2);
+```
+
+## Next.js App Router Versioning
+
+```typescript
+// app/api/v1/users/route.ts
+export async function GET() {
+  const users = await prisma.user.findMany();
+  return Response.json(users);
+}
+
+// app/api/v2/users/route.ts
+export async function GET(req: Request) {
+  const { searchParams } = new URL(req.url);
+  const page = Number(searchParams.get('page') ?? 1);
+  const limit = Number(searchParams.get('limit') ?? 20);
+  const [users, total] = await Promise.all([
+    prisma.user.findMany({ skip: (page - 1) * limit, take: limit }),
+    prisma.user.count()
+  ]);
+  return Response.json({ data: users, meta: { page, limit, total } });
+}
+```
+
+## Deprecation Headers
+
+```typescript
+function addDeprecationHeaders(res: Response, sunset: string) {
+  res.setHeader('Deprecation', 'true');
+  res.setHeader('Sunset', sunset);
+  res.setHeader('Link', '</api/v2/users>; rel="successor-version"');
+}
+```
+
+## Best Practices
+- Version from day one
+- Keep v1 alive for 12+ months after v2 launch
+- Always return `X-API-Version` response header
+- Use `Sunset` header to communicate deprecation timelines
+
+## Resources
+- [Stripe API versioning](https://stripe.com/docs/api/versioning)