claudeinone-cli 1.0.1 → 1.0.3

package/kit/.claude/skills/db-firebase-firestore.md

@@ -0,0 +1,191 @@
+# Firebase & Firestore
+
+Google's real-time database for rapid development.
+
+## Setup
+
+```bash
+npm install firebase firebase-admin
+```
+
+## Client SDK
+
+```typescript
+import { initializeApp } from 'firebase/app';
+import { getFirestore, collection, doc, getDoc, getDocs, setDoc, updateDoc, deleteDoc, query, where, orderBy } from 'firebase/firestore';
+
+const firebaseConfig = {
+  apiKey: process.env.REACT_APP_FIREBASE_API_KEY,
+  projectId: process.env.REACT_APP_FIREBASE_PROJECT_ID,
+  // ...
+};
+
+const app = initializeApp(firebaseConfig);
+const db = getFirestore(app);
+
+// Create/Set
+await setDoc(doc(db, 'users', 'user123'), {
+  email: 'user@example.com',
+  name: 'John Doe',
+  createdAt: new Date()
+});
+
+// Read single
+const userDoc = await getDoc(doc(db, 'users', 'user123'));
+if (userDoc.exists()) {
+  console.log(userDoc.data());
+}
+
+// Read multiple
+const userQuery = query(
+  collection(db, 'users'),
+  where('status', '==', 'active'),
+  orderBy('createdAt', 'desc')
+);
+const querySnapshot = await getDocs(userQuery);
+
+querySnapshot.forEach(doc => {
+  console.log(doc.id, doc.data());
+});
+
+// Update
+await updateDoc(doc(db, 'users', 'user123'), {
+  name: 'Jane Doe'
+});
+
+// Delete
+await deleteDoc(doc(db, 'users', 'user123'));
+```
+
+## Real-time Listeners
+
+```typescript
+import { onSnapshot } from 'firebase/firestore';
+
+// Listen to single document
+const unsubscribe = onSnapshot(
+  doc(db, 'users', 'user123'),
+  (doc) => {
+    console.log('Current data:', doc.data());
+  }
+);
+
+// Listen to collection
+onSnapshot(
+  query(
+    collection(db, 'messages'),
+    where('conversationId', '==', 'conv123'),
+    orderBy('createdAt')
+  ),
+  (snapshot) => {
+    snapshot.forEach(doc => {
+      console.log(doc.data());
+    });
+  }
+);
+
+// Stop listening
+unsubscribe();
+```
+
+## Transactions
+
+```typescript
+import { runTransaction } from 'firebase/firestore';
+
+await runTransaction(db, async (transaction) => {
+  const userDoc = await transaction.get(doc(db, 'users', 'user1'));
+  const balance = userDoc.data().balance;
+
+  transaction.update(doc(db, 'users', 'user1'), {
+    balance: balance - 100
+  });
+
+  transaction.update(doc(db, 'users', 'user2'), {
+    balance: (await transaction.get(doc(db, 'users', 'user2'))).data().balance + 100
+  });
+});
+```
+
+## Firebase Authentication
+
+```typescript
+import { getAuth, createUserWithEmailAndPassword, signInWithEmailAndPassword, signOut } from 'firebase/auth';
+
+const auth = getAuth();
+
+// Sign up
+const userCredential = await createUserWithEmailAndPassword(auth, email, password);
+const user = userCredential.user;
+
+// Sign in
+await signInWithEmailAndPassword(auth, email, password);
+
+// Sign out
+await signOut(auth);
+
+// Listen to auth state
+onAuthStateChanged(auth, (user) => {
+  if (user) {
+    console.log('User logged in:', user.uid);
+  } else {
+    console.log('User logged out');
+  }
+});
+```
+
+## Admin SDK (Server-side)
+
+```typescript
+import * as admin from 'firebase-admin';
+
+admin.initializeApp({
+  credential: admin.credential.cert(serviceAccount),
+  databaseURL: process.env.FIREBASE_DATABASE_URL
+});
+
+const db = admin.firestore();
+
+// Server-side operations
+await db.collection('users').doc('user123').set({
+  email: 'user@example.com',
+  admin: true
+}, { merge: true });
+
+// Batch operations
+const batch = db.batch();
+batch.set(db.collection('users').doc('user1'), { status: 'active' });
+batch.set(db.collection('users').doc('user2'), { status: 'active' });
+await batch.commit();
+```
+
+## Security Rules
+
+```
+rules_version = '2';
+service cloud.firestore {
+  match /databases/{database}/documents {
+    match /users/{userId} {
+      allow read, write: if request.auth.uid == userId;
+    }
+    
+    match /public/{document=**} {
+      allow read: if true;
+      allow write: if false;
+    }
+  }
+}
+```
+
+## Best Practices
+
+✅ **Security rules** - Enforce access control
+✅ **Indexes** - Create for complex queries
+✅ **Denormalization** - Store related data together
+✅ **Real-time listeners** - Efficient subscriptions
+✅ **Pagination** - Use startAfter for large datasets
+
+## Resources
+
+- [Firestore Documentation](https://firebase.google.com/docs/firestore)
+- [Firebase CLI](https://firebase.google.com/docs/cli)

package/kit/.claude/skills/db-mongodb.md

@@ -0,0 +1,198 @@
+# MongoDB
+
+NoSQL document database for flexible schema design.
+
+## Setup
+
+```bash
+npm install mongodb
+```
+
+## Connection
+
+```typescript
+import { MongoClient } from 'mongodb';
+
+const client = new MongoClient(process.env.MONGODB_URI);
+
+async function main() {
+  try {
+    await client.connect();
+    const db = client.db('myapp');
+    const collection = db.collection('users');
+    
+    // Perform operations
+  } finally {
+    await client.close();
+  }
+}
+
+main();
+```
+
+## CRUD Operations
+
+```typescript
+const collection = db.collection('users');
+
+// Create
+await collection.insertOne({
+  email: 'user@example.com',
+  name: 'John Doe',
+  createdAt: new Date()
+});
+
+// Insert multiple
+await collection.insertMany([
+  { email: 'user1@example.com', name: 'User 1' },
+  { email: 'user2@example.com', name: 'User 2' }
+]);
+
+// Read
+const user = await collection.findOne({ email: 'user@example.com' });
+
+// Read multiple
+const users = await collection.find({ role: 'admin' }).toArray();
+
+// Update
+await collection.updateOne(
+  { _id: userId },
+  { $set: { name: 'Jane Doe' } }
+);
+
+// Update multiple
+await collection.updateMany(
+  { role: 'user' },
+  { $set: { status: 'active' } }
+);
+
+// Delete
+await collection.deleteOne({ _id: userId });
+
+// Delete multiple
+await collection.deleteMany({ status: 'inactive' });
+```
+
+## Queries
+
+```typescript
+// Filter
+const activeUsers = await collection
+  .find({ status: 'active' })
+  .toArray();
+
+// Comparison operators
+const adults = await collection
+  .find({ age: { $gte: 18 } })
+  .toArray();
+
+// Logical operators
+const users = await collection
+  .find({
+    $or: [
+      { role: 'admin' },
+      { verified: true }
+    ]
+  })
+  .toArray();
+
+// Text search
+await collection.createIndex({ name: 'text' });
+const results = await collection
+  .find({ $text: { $search: 'john' } })
+  .toArray();
+
+// Aggregation
+const pipeline = [
+  { $match: { status: 'active' } },
+  { $group: { _id: '$role', count: { $sum: 1 } } },
+  { $sort: { count: -1 } }
+];
+
+const results = await collection.aggregate(pipeline).toArray();
+```
+
+## Transactions
+
+```typescript
+const session = client.startSession();
+
+try {
+  await session.withTransaction(async () => {
+    const usersCollection = db.collection('users');
+    const transactionsCollection = db.collection('transactions');
+
+    // Both operations succeed or both fail
+    await usersCollection.updateOne(
+      { _id: user1Id },
+      { $inc: { balance: -100 } },
+      { session }
+    );
+
+    await usersCollection.updateOne(
+      { _id: user2Id },
+      { $inc: { balance: 100 } },
+      { session }
+    );
+  });
+} finally {
+  await session.endSession();
+}
+```
+
+## Indexes
+
+```typescript
+// Single field index
+await collection.createIndex({ email: 1 });
+
+// Composite index
+await collection.createIndex({ role: 1, createdAt: -1 });
+
+// Text index
+await collection.createIndex({ name: 'text', description: 'text' });
+
+// Unique index
+await collection.createIndex({ email: 1 }, { unique: true });
+
+// List indexes
+const indexes = await collection.listIndexes().toArray();
+
+// Drop index
+await collection.dropIndex('email_1');
+```
+
+## Validation
+
+```typescript
+// Schema validation
+db.createCollection('users', {
+  validator: {
+    $jsonSchema: {
+      bsonType: 'object',
+      required: ['email', 'name'],
+      properties: {
+        email: {
+          bsonType: 'string',
+          pattern: '^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$'
+        },
+        name: { bsonType: 'string' },
+        age: { bsonType: 'int', minimum: 0 }
+      }
+    }
+  }
+});
+```
+
+## Best Practices
+
+✅ **Use ObjectId** - MongoDB's built-in unique ID
+✅ **Index frequently queried fields** - Improve query performance
+✅ **Validate schema** - Enforce data structure
+✅ **Use transactions** - Multi-document consistency
+✅ **Pagination** - Use skip/limit for large results
+
+## Resources
+
+- [MongoDB Documentation](https://docs.mongodb.com/)
+- [Node.js Driver](https://docs.mongodb.com/drivers/node/)

package/kit/.claude/skills/db-mysql.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/db-neon.md

@@ -0,0 +1,72 @@
+# Neon Serverless Postgres
+
+## Overview
+Neon is serverless PostgreSQL with branching, autoscaling to zero, and a generous free tier.
+
+## Setup
+
+```bash
+npm install @neondatabase/serverless
+```
+
+```env
+DATABASE_URL=postgresql://user:pass@ep-xxx.us-east-2.aws.neon.tech/neondb?sslmode=require
+```
+
+## Direct SQL
+
+```typescript
+import { neon } from '@neondatabase/serverless';
+const sql = neon(process.env.DATABASE_URL!);
+
+const users = await sql`SELECT * FROM users WHERE active = true LIMIT 20`;
+const user = await sql`SELECT * FROM users WHERE id = ${userId}`;
+const [newUser] = await sql`INSERT INTO users (email, name) VALUES (${email}, ${name}) RETURNING *`;
+```
+
+## With Prisma
+
+```bash
+npm install prisma @prisma/client @prisma/adapter-neon
+```
+
+```typescript
+import { PrismaClient } from '@prisma/client';
+import { Pool, neonConfig } from '@neondatabase/serverless';
+import { PrismaNeon } from '@prisma/adapter-neon';
+import ws from 'ws';
+
+neonConfig.webSocketConstructor = ws;
+const pool = new Pool({ connectionString: process.env.DATABASE_URL });
+const adapter = new PrismaNeon(pool);
+export const prisma = new PrismaClient({ adapter });
+```
+
+```env
+# Use pooled for app, direct for migrations
+DATABASE_URL=...?pgbouncer=true
+DIRECT_URL=...  # without pgbouncer
+```
+
+## Database Branching for PRs
+
+```bash
+# Create branch for PR preview
+neon branches create --name preview/pr-123 --parent main
+
+# Get connection string
+neon connection-string preview/pr-123
+
+# Delete branch after PR merge
+neon branches delete preview/pr-123
+```
+
+## Best Practices
+- Always use pooled connection URL for serverless functions
+- Use `DIRECT_URL` for Prisma migrations
+- Enable autoscale-to-zero on dev/staging to save costs
+- Use branching in CI for isolated integration tests
+
+## Resources
+- [Neon docs](https://neon.tech/docs)
+- [Neon + Prisma](https://neon.tech/docs/guides/prisma)

package/kit/.claude/skills/db-planetscale.md

@@ -0,0 +1,76 @@
+# PlanetScale
+
+## Overview
+PlanetScale is a MySQL-compatible serverless database with Git-like branching and horizontal scaling via Vitess.
+
+## Setup
+
+```bash
+npm install @planetscale/database
+```
+
+```env
+DATABASE_URL=mysql://user:pass@aws.connect.psdb.cloud/mydb?ssl={"rejectUnauthorized":true}
+```
+
+## Direct SQL
+
+```typescript
+import { connect } from '@planetscale/database';
+const conn = connect({ url: process.env.DATABASE_URL });
+
+const { rows } = await conn.execute('SELECT * FROM users WHERE email = ?', [email]);
+const result = await conn.execute('INSERT INTO users (id, email, name) VALUES (?, ?, ?)', [id, email, name]);
+console.log(result.insertId);
+```
+
+## With Prisma
+
+```prisma
+datasource db {
+  provider     = "mysql"
+  url          = env("DATABASE_URL")
+  relationMode = "prisma"  // PlanetScale disables FK constraints
+}
+```
+
+```bash
+npx prisma db push  # Use db push instead of migrate for PlanetScale
+```
+
+## With Drizzle
+
+```typescript
+import { drizzle } from 'drizzle-orm/planetscale-serverless';
+import { connect } from '@planetscale/database';
+
+const connection = connect({ url: process.env.DATABASE_URL });
+const db = drizzle(connection);
+
+const results = await db.select().from(users).where(eq(users.email, email));
+await db.insert(users).values({ id: crypto.randomUUID(), email, name });
+```
+
+## Branch Workflow
+
+```bash
+# Create dev branch
+pscale branch create mydb dev
+
+# Connect to dev branch locally
+pscale connect mydb dev --port 3309
+
+# Create deploy request (schema PR)
+pscale deploy-request create mydb dev
+
+# Merge (runs online DDL, no downtime)
+pscale deploy-request deploy mydb 1
+```
+
+## Best Practices
+- Use `relationMode = "prisma"` since PlanetScale disables FK constraints
+- Never modify main branch directly — always use branches + deploy requests
+- Use deploy requests for zero-downtime schema migrations
+
+## Resources
+- [PlanetScale quickstart](https://planetscale.com/docs/tutorials/planetscale-quickstart-guide)

package/kit/.claude/skills/db-postgresql.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