claudeinone-cli 1.0.1 → 1.0.3

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

@@ -0,0 +1,89 @@
+# Apache Cassandra
+
+## Overview
+Cassandra is a distributed NoSQL database designed for high write throughput, linear scalability, and no single point of failure.
+
+## Setup with cassandra-driver
+
+```bash
+npm install cassandra-driver
+```
+
+```typescript
+import { Client, auth } from 'cassandra-driver';
+
+const client = new Client({
+  contactPoints: [process.env.CASSANDRA_HOST!],
+  localDataCenter: 'datacenter1',
+  credentials: {
+    username: process.env.CASSANDRA_USER!,
+    password: process.env.CASSANDRA_PASSWORD!,
+  },
+  keyspace: 'myapp',
+});
+
+await client.connect();
+```
+
+## Schema (CQL)
+
+```sql
+CREATE KEYSPACE IF NOT EXISTS myapp
+  WITH replication = {'class': 'SimpleStrategy', 'replication_factor': 3};
+
+USE myapp;
+
+-- Time-series events table (common pattern)
+CREATE TABLE IF NOT EXISTS user_events (
+  user_id UUID,
+  event_time TIMESTAMP,
+  event_type TEXT,
+  data TEXT,
+  PRIMARY KEY (user_id, event_time)
+) WITH CLUSTERING ORDER BY (event_time DESC);
+
+-- Wide row for user timeline
+CREATE TABLE IF NOT EXISTS user_timeline (
+  user_id UUID,
+  post_id TIMEUUID,
+  content TEXT,
+  PRIMARY KEY (user_id, post_id)
+) WITH CLUSTERING ORDER BY (post_id DESC);
+```
+
+## CRUD Operations
+
+```typescript
+// Insert
+await client.execute(
+  'INSERT INTO user_events (user_id, event_time, event_type, data) VALUES (?, ?, ?, ?)',
+  [userId, new Date(), 'login', JSON.stringify({ ip: '127.0.0.1' })],
+  { prepare: true }
+);
+
+// Query
+const result = await client.execute(
+  'SELECT * FROM user_events WHERE user_id = ? ORDER BY event_time DESC LIMIT 20',
+  [userId],
+  { prepare: true }
+);
+const events = result.rows;
+
+// Batch write
+const batch = [
+  { query: 'INSERT INTO user_events ...', params: [...] },
+  { query: 'UPDATE user_stats ...', params: [...] },
+];
+await client.batch(batch, { prepare: true });
+```
+
+## Best Practices
+- Design tables for query patterns — denormalize heavily
+- Use `prepare: true` for all parameterized queries
+- Partition key determines which node holds data — choose for even distribution
+- Avoid `ALLOW FILTERING` — it causes full table scans
+- Use TTL for time-series or expiring data: `INSERT ... USING TTL 86400`
+
+## Resources
+- [cassandra-driver docs](https://docs.datastax.com/en/developer/nodejs-driver/)
+- [Cassandra data modeling](https://cassandra.apache.org/doc/latest/cassandra/data_modeling/)

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

@@ -0,0 +1,363 @@
+# Drizzle ORM
+
+Lightweight TypeScript-first ORM with native async/await support and zero dependencies.
+
+## Setup
+
+```bash
+npm install drizzle-orm drizzle-kit
+npm install pg # for PostgreSQL
+npm install -D @types/pg
+
+# Initialize schema
+npx drizzle-kit init
+```
+
+## Schema Definition
+
+```typescript
+import { pgTable, serial, text, varchar, boolean, timestamp, integer, foreignKey } from 'drizzle-orm/pg-core';
+import { relations } from 'drizzle-orm';
+
+// Users table
+export const users = pgTable(
+  'users',
+  {
+    id: serial('id').primaryKey(),
+    email: varchar('email', { length: 255 }).unique().notNull(),
+    name: varchar('name', { length: 255 }).notNull(),
+    password: varchar('password', { length: 255 }).notNull(),
+    createdAt: timestamp('created_at').defaultNow(),
+    updatedAt: timestamp('updated_at').defaultNow()
+  },
+  (table) => ({
+    emailIdx: uniqueIndex('email_idx').on(table.email)
+  })
+);
+
+// Posts table
+export const posts = pgTable(
+  'posts',
+  {
+    id: serial('id').primaryKey(),
+    title: varchar('title', { length: 255 }).notNull(),
+    content: text('content'),
+    published: boolean('published').default(false),
+    authorId: integer('author_id')
+      .notNull()
+      .references(() => users.id, { onDelete: 'cascade' }),
+    createdAt: timestamp('created_at').defaultNow(),
+    updatedAt: timestamp('updated_at').defaultNow()
+  },
+  (table) => ({
+    authorIdx: index('author_idx').on(table.authorId)
+  })
+);
+
+// Relationships
+export const usersRelations = relations(users, ({ many }) => ({
+  posts: many(posts)
+}));
+
+export const postsRelations = relations(posts, ({ one }) => ({
+  author: one(users, {
+    fields: [posts.authorId],
+    references: [users.id]
+  })
+}));
+```
+
+## Migrations
+
+```bash
+# Generate migration
+npx drizzle-kit generate:pg
+
+# Push schema to database
+npx drizzle-kit push:pg
+
+# Create migration manually
+npx drizzle-kit up:pg
+
+# Drop schema
+npx drizzle-kit drop
+
+# View migration status
+npx drizzle-kit status:pg
+```
+
+## Database Connection
+
+```typescript
+import { drizzle } from 'drizzle-orm/node-postgres';
+import { Pool } from 'pg';
+
+// Create connection pool
+const pool = new Pool({
+  host: 'localhost',
+  port: 5432,
+  user: 'user',
+  password: 'password',
+  database: 'mydb'
+});
+
+// Create Drizzle ORM instance
+export const db = drizzle(pool);
+```
+
+## Basic Queries
+
+```typescript
+import { db } from './db';
+import { users, posts } from './schema';
+import { eq } from 'drizzle-orm';
+
+// Create
+const newUser = await db.insert(users).values({
+  email: 'john@example.com',
+  name: 'John Doe',
+  password: 'hashed_password'
+});
+
+// Read - single
+const user = await db.select().from(users).where(eq(users.id, 1));
+
+// Read - all
+const allUsers = await db.select().from(users);
+
+// Read - with condition
+const activeUsers = await db
+  .select()
+  .from(users)
+  .where(eq(users.status, 'active'));
+
+// Update
+const updated = await db
+  .update(users)
+  .set({ name: 'Jane Doe' })
+  .where(eq(users.id, 1));
+
+// Delete
+await db.delete(users).where(eq(users.id, 1));
+```
+
+## Relationships and Joins
+
+```typescript
+// Get user with all posts
+const userWithPosts = await db.query.users.findFirst({
+  where: eq(users.id, 1),
+  with: {
+    posts: true
+  }
+});
+
+// Join syntax
+const postsWithAuthors = await db
+  .select({
+    postId: posts.id,
+    title: posts.title,
+    authorName: users.name
+  })
+  .from(posts)
+  .leftJoin(users, eq(posts.authorId, users.id));
+
+// Multiple joins
+const postsWithComments = await db
+  .select()
+  .from(posts)
+  .innerJoin(users, eq(posts.authorId, users.id))
+  .leftJoin(comments, eq(posts.id, comments.postId));
+```
+
+## Filtering and Conditions
+
+```typescript
+import { and, or, like, gte, lte, inArray } from 'drizzle-orm';
+
+// Multiple conditions (AND)
+const posts = await db
+  .select()
+  .from(posts)
+  .where(
+    and(
+      eq(posts.published, true),
+      gte(posts.createdAt, new Date('2024-01-01'))
+    )
+  );
+
+// OR condition
+const results = await db
+  .select()
+  .from(users)
+  .where(
+    or(
+      eq(users.email, 'john@example.com'),
+      eq(users.email, 'jane@example.com')
+    )
+  );
+
+// LIKE search
+const search = await db
+  .select()
+  .from(users)
+  .where(like(users.name, '%John%'));
+
+// IN clause
+const specific = await db
+  .select()
+  .from(posts)
+  .where(inArray(posts.authorId, [1, 2, 3]));
+```
+
+## Pagination and Ordering
+
+```typescript
+// Pagination
+const pageSize = 10;
+const page = 1;
+
+const paginated = await db
+  .select()
+  .from(posts)
+  .limit(pageSize)
+  .offset((page - 1) * pageSize)
+  .orderBy(posts.createdAt);
+
+// Get total count
+const total = await db
+  .select({ count: countDistinct(posts.id) })
+  .from(posts);
+
+const totalPages = Math.ceil(total[0].count / pageSize);
+```
+
+## Aggregations
+
+```typescript
+import { count, sum, avg, max, min } from 'drizzle-orm';
+
+// Count
+const postCount = await db
+  .select({ value: count() })
+  .from(posts);
+
+// With grouping
+const postsByAuthor = await db
+  .select({
+    authorId: posts.authorId,
+    count: count(posts.id)
+  })
+  .from(posts)
+  .groupBy(posts.authorId)
+  .orderBy(({ count: cnt }) => desc(cnt));
+
+// Aggregations
+const stats = await db
+  .select({
+    totalPosts: count(posts.id),
+    avgLength: avg(posts.content),
+    maxLength: max(posts.content)
+  })
+  .from(posts)
+  .where(eq(posts.published, true));
+```
+
+## Transactions
+
+```typescript
+// Atomic transactions
+const result = await db.transaction(async (tx) => {
+  const user = await tx.insert(users).values({
+    email: 'john@example.com',
+    name: 'John',
+    password: 'hash'
+  });
+
+  const post = await tx.insert(posts).values({
+    title: 'First Post',
+    content: 'Content...',
+    authorId: user[0].id
+  });
+
+  return { user, post };
+});
+
+// Rollback on error
+try {
+  await db.transaction(async (tx) => {
+    // Operations
+    throw new Error('Rollback!');
+  });
+} catch (err) {
+  console.log('Transaction rolled back');
+}
+```
+
+## Parameterized Queries (SQL Injection Prevention)
+
+```typescript
+import { sql } from 'drizzle-orm';
+
+// Safe parameter usage
+const email = 'john@example.com';
+const user = await db
+  .select()
+  .from(users)
+  .where(sql`${users.email} = ${email}`);
+
+// Raw SQL with parameters
+const query = await db.execute(
+  sql`SELECT * FROM ${users} WHERE email = ${email}`
+);
+```
+
+## Migrations with Version History
+
+```bash
+# Show migrations status
+npx drizzle-kit status:pg --dir ./drizzle
+
+# Migrate to specific version
+npx drizzle-kit migrate --migrations ./drizzle
+
+# View all migrations
+ls drizzle/migrations/
+```
+
+## Best Practices
+
+✅ **Type safety** - Full TypeScript support with zero-cost abstractions
+✅ **Minimal ORM** - No magic, explicit queries
+✅ **Auto-migrations** - Generate migrations from schema changes
+✅ **Connection pooling** - Reuse connections efficiently
+✅ **Prepared statements** - SQL injection protected by default
+✅ **Query building** - Composable, chainable queries
+✅ **Relations** - Optional eager loading with `with` syntax
+
+## Performance Tips
+
+- Use `select()` with specific columns to reduce payload
+- Add indexes to frequently filtered columns
+- Use connection pooling in production
+- Batch inserts: `db.insert().values([...])`
+- Monitor slow queries with database logs
+
+## When to Use Drizzle
+
+✅ Want lightweight, TypeScript-first ORM
+✅ Need explicit SQL control
+✅ PostgreSQL, MySQL, SQLite projects
+✅ Building serverless apps (Vercel, AWS Lambda)
+✅ Prefer generated migrations
+
+❌ Need GraphQL-first tooling (use Prisma)
+❌ Complex stored procedures needed
+❌ Learning ORM for the first time
+
+## Resources
+
+- [Drizzle Documentation](https://orm.drizzle.team/)
+- [Drizzle ORM API](https://orm.drizzle.team/docs/get-started)
+- [Drizzle Kit](https://orm.drizzle.team/kit-docs/overview)
+- [Examples](https://github.com/drizzle-team/drizzle-orm/tree/main/examples)

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

@@ -0,0 +1,83 @@
+# DynamoDB
+
+## Overview
+AWS DynamoDB is a fully managed NoSQL database optimized for high-scale, predictable-latency workloads.
+
+## Setup
+
+```bash
+npm install @aws-sdk/client-dynamodb @aws-sdk/lib-dynamodb
+```
+
+```typescript
+import { DynamoDBClient } from '@aws-sdk/client-dynamodb';
+import { DynamoDBDocumentClient, GetCommand, PutCommand, QueryCommand, UpdateCommand, DeleteCommand } from '@aws-sdk/lib-dynamodb';
+
+const client = new DynamoDBClient({ region: process.env.AWS_REGION ?? 'us-east-1' });
+const db = DynamoDBDocumentClient.from(client);
+const TABLE = process.env.DYNAMODB_TABLE!;
+```
+
+## CRUD Operations
+
+```typescript
+// Create
+await db.send(new PutCommand({
+  TableName: TABLE,
+  Item: { PK: `USER#${user.id}`, SK: `PROFILE#${user.id}`, ...user, createdAt: new Date().toISOString() },
+  ConditionExpression: 'attribute_not_exists(PK)',
+}));
+
+// Read
+const result = await db.send(new GetCommand({
+  TableName: TABLE,
+  Key: { PK: `USER#${id}`, SK: `PROFILE#${id}` }
+}));
+const user = result.Item;
+
+// Update
+await db.send(new UpdateCommand({
+  TableName: TABLE,
+  Key: { PK: `USER#${id}`, SK: `PROFILE#${id}` },
+  UpdateExpression: 'SET #name = :name, updatedAt = :now',
+  ExpressionAttributeNames: { '#name': 'name' },
+  ExpressionAttributeValues: { ':name': newName, ':now': new Date().toISOString() }
+}));
+
+// Delete
+await db.send(new DeleteCommand({ TableName: TABLE, Key: { PK: `USER#${id}`, SK: `PROFILE#${id}` } }));
+```
+
+## Query Pattern
+
+```typescript
+// Get all orders for a user
+const result = await db.send(new QueryCommand({
+  TableName: TABLE,
+  KeyConditionExpression: 'PK = :pk AND begins_with(SK, :prefix)',
+  ExpressionAttributeValues: { ':pk': `USER#${userId}`, ':prefix': 'ORDER#' },
+  ScanIndexForward: false, // newest first
+  Limit: 20,
+}));
+const orders = result.Items ?? [];
+```
+
+## Single-Table Design
+
+```
+PK              | SK                 | Type
+USER#u1         | PROFILE#u1         | User profile
+USER#u1         | ORDER#2024-01#o1   | Order (date-sortable)
+PRODUCT#p1      | METADATA#p1        | Product
+ORDER#o1        | ITEM#1             | Order line item
+```
+
+## Best Practices
+- Design for access patterns first — DynamoDB doesn't support ad-hoc queries
+- Use single-table design to minimize RCUs/WCUs
+- Never scan large tables — always query with a partition key
+- Use TTL attribute for automatic expiry (sessions, caches)
+
+## Resources
+- [DynamoDB Developer Guide](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/)
+- [The DynamoDB Book](https://www.dynamodbbook.com/)

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

@@ -0,0 +1,105 @@
+# Elasticsearch
+
+Distributed search and analytics engine.
+
+## Setup
+
+```bash
+npm install @elastic/elasticsearch
+```
+
+## Indexing
+
+```typescript
+import { Client } from '@elastic/elasticsearch';
+
+const client = new Client({ node: 'http://localhost:9200' });
+
+// Create index with mapping
+await client.indices.create({
+  index: 'products',
+  body: {
+    mappings: {
+      properties: {
+        name: { type: 'text' },
+        description: { type: 'text' },
+        price: { type: 'float' },
+        category: { type: 'keyword' },
+        tags: { type: 'keyword' },
+        created_at: { type: 'date' }
+      }
+    }
+  }
+});
+
+// Index document
+await client.index({
+  index: 'products',
+  id: '1',
+  document: {
+    name: 'Laptop',
+    description: 'High-performance laptop',
+    price: 999.99,
+    category: 'electronics',
+    tags: ['computer', 'work'],
+    created_at: new Date()
+  }
+});
+
+// Bulk indexing
+await client.bulk({
+  operations: documents.flatMap(doc => [
+    { index: { _index: 'products', _id: doc.id } },
+    doc
+  ])
+});
+```
+
+## Searching
+
+```typescript
+// Simple search
+const results = await client.search({
+  index: 'products',
+  query: {
+    match: { name: 'laptop' }
+  }
+});
+
+// Complex query
+const results = await client.search({
+  index: 'products',
+  query: {
+    bool: {
+      must: [
+        { match: { name: 'laptop' } }
+      ],
+      filter: [
+        { range: { price: { lte: 1000 } } },
+        { term: { category: 'electronics' } }
+      ]
+    }
+  }
+});
+
+// Aggregations
+const stats = await client.search({
+  index: 'products',
+  aggs: {
+    avg_price: { avg: { field: 'price' } },
+    categories: { terms: { field: 'category' } }
+  }
+});
+```
+
+## Best Practices
+
+✅ **Proper mapping** - Define field types
+✅ **Shard allocation** - Balance shards across nodes
+✅ **Indexing strategy** - Time-based indices
+✅ **Query optimization** - Use filters for performance
+✅ **Monitoring** - Track cluster health
+
+## Resources
+
+- [Elasticsearch Guide](https://www.elastic.co/guide/index.html)