claudeinone-cli 1.0.1 → 1.0.3

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

@@ -0,0 +1,94 @@
+# Fly.io
+
+## Overview
+Fly.io runs Docker containers globally across 30+ regions with anycast networking and built-in scaling.
+
+## Installation
+
+```bash
+curl -L https://fly.io/install.sh | sh
+fly auth login
+fly launch  # creates fly.toml and Dockerfile
+```
+
+## fly.toml
+
+```toml
+app = "my-app"
+primary_region = "sjc"
+
+[build]
+  dockerfile = "Dockerfile"
+
+[env]
+  NODE_ENV = "production"
+  PORT = "3000"
+
+[http_service]
+  internal_port = 3000
+  force_https = true
+  auto_stop_machines = true
+  auto_start_machines = true
+  min_machines_running = 0
+
+[[vm]]
+  cpu_kind = "shared"
+  cpus = 1
+  memory_mb = 512
+```
+
+## Next.js Dockerfile
+
+```dockerfile
+FROM node:20-alpine AS base
+WORKDIR /app
+
+FROM base AS deps
+COPY package*.json ./
+RUN npm ci
+
+FROM base AS builder
+COPY --from=deps /app/node_modules ./node_modules
+COPY . .
+RUN npm run build
+
+FROM base AS runner
+ENV NODE_ENV=production
+COPY --from=builder /app/.next/standalone ./
+COPY --from=builder /app/.next/static ./.next/static
+COPY --from=builder /app/public ./public
+EXPOSE 3000
+CMD ["node", "server.js"]
+```
+
+## Secrets & Deploy
+
+```bash
+fly secrets set DATABASE_URL="postgresql://..."
+fly secrets set NEXTAUTH_SECRET="..."
+
+fly deploy
+
+# Logs
+fly logs --app my-app
+
+# Scale
+fly scale count 2 --region sjc
+```
+
+## Managed Postgres
+
+```bash
+fly postgres create --name my-db --region sjc
+fly postgres attach my-db --app my-app  # sets DATABASE_URL automatically
+```
+
+## Best Practices
+- Use `auto_stop_machines = true` for dev apps (scale to zero)
+- Set `min_machines_running = 1` for production (avoid cold starts)
+- Store secrets with `fly secrets set`, never in fly.toml
+- Use Fly volumes for SQLite or file uploads
+
+## Resources
+- [Fly.io docs](https://fly.io/docs)
+- [Deploy Next.js on Fly](https://fly.io/docs/js/frameworks/nextjs/)

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

@@ -0,0 +1,160 @@
+# Google Cloud Platform (GCP)
+
+Managed cloud services with Compute Engine, Cloud Functions, Firestore, and BigQuery.
+
+## Cloud Functions
+
+```typescript
+import functions from '@google-cloud/functions-framework';
+
+functions.http('helloWorld', (req, res) => {
+  res.send('Hello from Cloud Functions!');
+});
+
+// With async operations
+functions.http('asyncExample', async (req, res) => {
+  const result = await someAsyncOperation();
+  res.json(result);
+});
+
+// Event-driven (Pub/Sub)
+functions.cloud.pubsub('processPubSub', (message) => {
+  const data = Buffer.from(message.data, 'base64').toString();
+  console.log(`Processing: ${data}`);
+});
+```
+
+## Firestore
+
+```typescript
+import { Firestore } from '@google-cloud/firestore';
+
+const db = new Firestore();
+
+// Write
+await db.collection('users').doc('user-123').set({
+  email: 'user@example.com',
+  createdAt: new Date()
+});
+
+// Read
+const doc = await db.collection('users').doc('user-123').get();
+const user = doc.data();
+
+// Query
+const snapshot = await db.collection('users')
+  .where('email', '==', 'user@example.com')
+  .limit(10)
+  .get();
+
+snapshot.forEach(doc => console.log(doc.data()));
+
+// Batch write
+const batch = db.batch();
+batch.set(db.collection('users').doc('user-1'), { name: 'Alice' });
+batch.set(db.collection('users').doc('user-2'), { name: 'Bob' });
+await batch.commit();
+```
+
+## Cloud Storage
+
+```typescript
+import { Storage } from '@google-cloud/storage';
+
+const storage = new Storage();
+const bucket = storage.bucket('my-bucket');
+
+// Upload file
+await bucket.file('path/to/file.txt').save('content', {
+  contentType: 'text/plain'
+});
+
+// Download file
+const [contents] = await bucket.file('path/to/file.txt').download();
+
+// List files
+const [files] = await bucket.getFiles({ prefix: 'uploads/' });
+files.forEach(file => console.log(file.name));
+```
+
+## BigQuery
+
+```typescript
+import { BigQuery } from '@google-cloud/bigquery';
+
+const bq = new BigQuery();
+
+// Query
+const [rows] = await bq.query({
+  query: 'SELECT * FROM `dataset.table` WHERE age > @age LIMIT 10',
+  location: 'US',
+  params: { age: 18 }
+});
+
+// Insert rows
+await bq.dataset('my_dataset')
+  .table('users')
+  .insert([
+    { id: '1', name: 'Alice', age: 30 },
+    { id: '2', name: 'Bob', age: 25 }
+  ]);
+```
+
+## Pub/Sub Messaging
+
+```typescript
+import { PubSub } from '@google-cloud/pubsub';
+
+const pubsub = new PubSub();
+
+// Publisher
+const topic = pubsub.topic('my-topic');
+const messageId = await topic.publish(
+  Buffer.from(JSON.stringify({ userId: '123', action: 'login' }))
+);
+
+// Subscriber
+const subscription = pubsub.subscription('my-subscription');
+
+subscription.on('message', (message) => {
+  const data = JSON.parse(message.data.toString());
+  console.log('Received:', data);
+  message.ack();
+});
+```
+
+## Cloud Run (Containers)
+
+```yaml
+# Dockerfile
+FROM node:20-alpine
+WORKDIR /app
+COPY package*.json ./
+RUN npm ci --only=production
+COPY . .
+EXPOSE 3000
+CMD ["node", "index.js"]
+```
+
+```bash
+# Deploy to Cloud Run
+gcloud run deploy my-service \
+  --source . \
+  --platform managed \
+  --region us-central1 \
+  --allow-unauthenticated
+```
+
+## Best Practices
+
+✅ **Use Firebase for real-time** - Easier than raw Firestore
+✅ **Indexing** - Create composite indexes for complex queries
+✅ **Transactions** - ACID guarantees for critical operations
+✅ **Access control** - Use IAM roles and Firestore Security Rules
+✅ **Caching** - Use Memorystore (Redis) for hot data
+
+## Resources
+
+- [GCP Documentation](https://cloud.google.com/docs)
+- [Firestore Guide](https://cloud.google.com/firestore/docs)
+- [Cloud Functions](https://cloud.google.com/functions/docs)

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

@@ -0,0 +1,92 @@
+# Railway
+
+Simple cloud platform for deploying full-stack applications.
+
+## Setup & Deployment
+
+```bash
+npm install -g @railway/cli
+railway login
+railway init
+```
+
+## railway.json Configuration
+
+```json
+{
+  "name": "my-app",
+  "services": {
+    "api": {
+      "buildCommand": "npm run build",
+      "startCommand": "npm start",
+      "environment": {
+        "NODE_ENV": "production",
+        "DATABASE_URL": "${{ database.DATABASE_URL }}"
+      }
+    },
+    "database": {
+      "image": "postgres:15",
+      "environment": {
+        "POSTGRES_PASSWORD": "${{ POSTGRES_PASSWORD }}"
+      }
+    }
+  }
+}
+```
+
+## Deployment
+
+```bash
+# Deploy application
+railway up
+
+# View logs
+railway logs
+
+# Check status
+railway status
+
+# Set environment variables
+railway variables set DATABASE_URL=postgresql://...
+railway variables get DATABASE_URL
+```
+
+## Database Integration
+
+```typescript
+import { Pool } from 'pg';
+
+const pool = new Pool({
+  connectionString: process.env.DATABASE_URL
+});
+
+async function getUsers() {
+  const result = await pool.query('SELECT * FROM users');
+  return result.rows;
+}
+```
+
+## Environment Management
+
+```bash
+# Development
+railway env dev
+railway up --environment dev
+
+# Production
+railway env prod
+railway up --environment prod
+```
+
+## Best Practices
+
+✅ **Simple deployments** - Just git push
+✅ **Built-in databases** - PostgreSQL, MongoDB, Redis
+✅ **Environment separation** - Dev/prod isolation
+✅ **Database backups** - Automatic backups included
+✅ **Custom domains** - Easy domain setup
+
+## Resources
+
+- [Railway Documentation](https://docs.railway.app/)
+- [Pricing & Limits](https://railway.app/pricing)

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

@@ -0,0 +1,70 @@
+# Render
+
+Simple cloud platform with generous free tier.
+
+## Deployment
+
+```bash
+# Connect to GitHub
+# Create render.yaml in root
+
+# Or use Render dashboard to connect repo
+```
+
+## render.yaml
+
+```yaml
+services:
+  - type: web
+    name: api
+    env: node
+    buildCommand: npm run build
+    startCommand: npm start
+    envVars:
+      - key: NODE_ENV
+        value: production
+      - key: DATABASE_URL
+        scope: service
+        value: ${{ database.DATABASE_URL }}
+    
+  - type: pserv
+    name: database
+    env: postgres
+    plan: free
+    ipAllowList: []
+    envVars:
+      - key: POSTGRES_USER
+        value: user
+      - key: POSTGRES_PASSWORD
+        generateValue: true
+```
+
+## Deployment Workflow
+
+```bash
+# Push to GitHub
+git push origin main
+
+# Render automatically deploys
+# No additional commands needed
+```
+
+## Environment Variables
+
+```bash
+# Set via Render dashboard
+# Or use render.yaml with generateValue: true
+```
+
+## Best Practices
+
+✅ **Free tier** - Adequate for small projects
+✅ **Auto-deploy** - Git integration
+✅ **Database included** - PostgreSQL built-in
+✅ **Easy scaling** - Upgrade instance type
+✅ **Cron jobs** - Background tasks
+
+## Resources
+
+- [Render Docs](https://render.com/docs)
+- [Pricing](https://render.com/pricing)

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

@@ -0,0 +1,68 @@
+# Serverless Architecture
+
+## Overview
+Serverless runs functions on demand with automatic scaling and pay-per-execution pricing.
+
+## AWS Lambda (TypeScript)
+
+```typescript
+import { APIGatewayProxyEvent, APIGatewayProxyResult } from 'aws-lambda';
+import { DynamoDBDocumentClient, GetCommand } from '@aws-sdk/lib-dynamodb';
+import { DynamoDBClient } from '@aws-sdk/client-dynamodb';
+
+// Initialize outside handler — reused across warm invocations
+const db = DynamoDBDocumentClient.from(new DynamoDBClient({}));
+
+export const handler = async (event: APIGatewayProxyEvent): Promise<APIGatewayProxyResult> => {
+  const id = event.pathParameters?.id;
+  if (!id) return { statusCode: 400, body: JSON.stringify({ error: 'Missing id' }) };
+
+  const result = await db.send(new GetCommand({
+    TableName: process.env.TABLE_NAME!,
+    Key: { PK: `USER#${id}`, SK: `PROFILE#${id}` }
+  }));
+
+  if (!result.Item) return { statusCode: 404, body: JSON.stringify({ error: 'Not found' }) };
+  return { statusCode: 200, headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(result.Item) };
+};
+```
+
+## Cloudflare Workers
+
+```typescript
+export interface Env { DB: D1Database; KV: KVNamespace; }
+
+export default {
+  async fetch(req: Request, env: Env): Promise<Response> {
+    const url = new URL(req.url);
+    if (url.pathname === '/api/users') {
+      const { results } = await env.DB.prepare('SELECT * FROM users LIMIT 20').all();
+      return Response.json(results);
+    }
+    return new Response('Not Found', { status: 404 });
+  }
+};
+```
+
+## Vercel Edge Function
+
+```typescript
+// app/api/edge/route.ts
+export const runtime = 'edge';
+
+export async function GET(req: Request) {
+  const country = req.headers.get('x-vercel-ip-country') ?? 'US';
+  return Response.json({ country, timestamp: Date.now() });
+}
+```
+
+## Best Practices
+- Initialize DB clients outside handlers (reuse on warm invocations)
+- Use DynamoDB/Redis — SQL connection pools don't work well with serverless
+- Bundle with esbuild for small Lambda packages
+- Set appropriate memory — more memory = more CPU on AWS Lambda
+- Use SQS for async work — don't block the function on slow tasks
+
+## Resources
+- [AWS Lambda docs](https://docs.aws.amazon.com/lambda/)
+- [Cloudflare Workers](https://developers.cloudflare.com/workers/)

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

@@ -0,0 +1,76 @@
+# Vercel
+
+Serverless platform optimized for Next.js and edge functions.
+
+## Deployment
+
+```bash
+# Install Vercel CLI
+npm i -g vercel
+
+# Deploy
+vercel
+
+# Production deployment
+vercel --prod
+```
+
+## Vercel Config
+
+```json
+{
+  "buildCommand": "npm run build",
+  "outputDirectory": ".next",
+  "framework": "nextjs",
+  "env": [
+    "DATABASE_URL",
+    "API_SECRET"
+  ],
+  "regions": ["sfo1"]
+}
+```
+
+## Environment Variables
+
+```bash
+# Set in Vercel dashboard or via CLI
+vercel env add DATABASE_URL
+
+# Pull to local .env.local
+vercel env pull
+```
+
+## Edge Functions
+
+```typescript
+// api/middleware.ts
+import { NextResponse } from 'next/server';
+import type { NextRequest } from 'next/server';
+
+export function middleware(request: NextRequest) {
+  const token = request.headers.get('authorization');
+  
+  if (!token) {
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+  }
+
+  return NextResponse.next();
+}
+
+export const config = {
+  matcher: ['/api/:path*']
+};
+```
+
+## Best Practices
+
+✅ **Use environment variables** - Keep secrets secure
+✅ **Enable serverless function caching** - Improve performance
+✅ **Monitor analytics** - Track usage and performance
+✅ **Set up preview deployments** - Test before production
+✅ **Use ISR** - Incremental Static Regeneration
+
+## Resources
+
+- [Vercel Docs](https://vercel.com/docs)
+- [Next.js Deployment](https://nextjs.org/docs/deployment)

package/kit/.claude/skills/component-patterns.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