claudeinone-cli 1.0.1 → 1.0.3

package/kit/.claude/skills/content-management.md

@@ -0,0 +1,197 @@
+# Content Management Systems
+
+Building and managing content with headless CMS or self-hosted solutions.
+
+## Headless CMS with Strapi
+
+```bash
+npm install strapi @strapi/strapi @strapi/plugin-users-permissions
+npx strapi new my-cms
+cd my-cms
+npx strapi develop
+```
+
+```typescript
+// Create content type via API
+const strapiClient = axios.create({
+  baseURL: 'http://localhost:1337/api',
+  headers: {
+    Authorization: `Bearer ${process.env.STRAPI_TOKEN}`
+  }
+});
+
+// Create post
+const response = await strapiClient.post('/posts', {
+  data: {
+    title: 'My Post',
+    content: 'Post content',
+    published: true
+  }
+});
+
+// Query posts
+const posts = await strapiClient.get('/posts?populate=author');
+```
+
+## Contentful Integration
+
+```typescript
+import { createClient } from 'contentful';
+
+const client = createClient({
+  space: process.env.CONTENTFUL_SPACE_ID,
+  accessToken: process.env.CONTENTFUL_ACCESS_TOKEN
+});
+
+// Fetch content
+const entries = await client.getEntries({
+  content_type: 'blogPost',
+  limit: 10,
+  order: '-sys.createdAt'
+});
+
+entries.items.forEach(item => {
+  console.log(item.fields.title);
+  console.log(item.fields.body);
+});
+
+// Fetch single entry
+const entry = await client.getEntry(entryId);
+```
+
+## Next.js with Markdown
+
+```typescript
+// pages/blog/[slug].tsx
+import { MDXRemote, MDXRemoteSerializeResult } from 'next-mdx-remote';
+import { serialize } from 'next-mdx-remote/serialize';
+import fs from 'fs';
+import path from 'path';
+
+interface PostProps {
+  source: MDXRemoteSerializeResult;
+  frontmatter: Record<string, any>;
+}
+
+export async function getStaticProps({ params }: any) {
+  const postPath = path.join(process.cwd(), 'posts', `${params.slug}.mdx`);
+  const source = fs.readFileSync(postPath, 'utf-8');
+
+  // Parse frontmatter
+  const { data: frontmatter, content } = matter(source);
+
+  // Serialize MDX
+  const mdxSource = await serialize(content);
+
+  return {
+    props: {
+      source: mdxSource,
+      frontmatter
+    }
+  };
+}
+
+export default function Post({ source, frontmatter }: PostProps) {
+  return (
+    <article>
+      <h1>{frontmatter.title}</h1>
+      <MDXRemote {...source} />
+    </article>
+  );
+}
+```
+
+## Rich Text Editor
+
+```typescript
+import { EditorState, convertToRaw, convertFromRaw } from 'draft-js';
+import 'draft-js/dist/Draft.css';
+
+function RichTextEditor({ content, onChange }: any) {
+  const [editorState, setEditorState] = useState(() => {
+    if (content) {
+      const contentState = convertFromRaw(content);
+      return EditorState.createWithContent(contentState);
+    }
+    return EditorState.createEmpty();
+  });
+
+  const handleChange = (state: EditorState) => {
+    setEditorState(state);
+
+    // Serialize to JSON
+    const contentState = state.getCurrentContent();
+    const raw = convertToRaw(contentState);
+    onChange(raw);
+  };
+
+  return (
+    <Editor
+      editorState={editorState}
+      onChange={handleChange}
+    />
+  );
+}
+```
+
+## Blog Platform Features
+
+```typescript
+// Full-text search
+const SearchPosts = async (query: string) => {
+  return await db.posts.find({
+    $or: [
+      { title: { $regex: query, $options: 'i' } },
+      { content: { $regex: query, $options: 'i' } }
+    ]
+  });
+};
+
+// Category filtering
+const PostsByCategory = async (category: string) => {
+  return await db.posts.find({ category });
+};
+
+// Pagination
+const getPaginatedPosts = async (page: number, pageSize: number) => {
+  const skip = (page - 1) * pageSize;
+  return await db.posts
+    .find()
+    .skip(skip)
+    .limit(pageSize)
+    .sort({ publishedAt: -1 });
+};
+
+// Comments
+interface Comment {
+  id: string;
+  postId: string;
+  userId: string;
+  content: string;
+  createdAt: Date;
+  parentId?: string; // For nested replies
+}
+
+const addComment = async (postId: string, userId: string, content: string) => {
+  return await db.comments.create({
+    postId,
+    userId,
+    content,
+    createdAt: new Date()
+  });
+};
+```
+
+## Best Practices
+
+✅ **Markdown for content** - Version control friendly
+✅ **Caching** - Cache rendered content
+✅ **Search** - Full-text indexing
+✅ **Comments moderation** - Review before publishing
+✅ **Media storage** - Use CDN for images/videos
+
+## Resources
+
+- [Strapi Documentation](https://docs.strapi.io/)
+- [Contentful CMS](https://www.contentful.com/)
+- [Next.js MDX](https://nextjs.org/docs/advanced-features/using-mdx)

package/kit/.claude/skills/cors-security.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/data-csv-excel.md

@@ -0,0 +1,210 @@
+# CSV & Excel Processing
+
+Reading, writing, and manipulating spreadsheet files.
+
+## CSV Handling
+
+```typescript
+import { parse } from 'csv-parse';
+import { stringify } from 'csv-stringify';
+import fs from 'fs';
+
+// Read CSV
+const parser = fs.createReadStream('data.csv')
+  .pipe(parse({
+    columns: true,
+    skip_empty_lines: true,
+    trim: true
+  }));
+
+const records: any[] = [];
+for await (const record of parser) {
+  records.push(record);
+}
+
+console.log(records);
+
+// Write CSV
+const output = fs.createWriteStream('output.csv');
+const stringifier = stringify({
+  columns: ['id', 'name', 'email'],
+  header: true
+});
+
+stringifier.pipe(output);
+
+records.forEach(record => {
+  stringifier.write({
+    id: record.id,
+    name: record.name,
+    email: record.email
+  });
+});
+
+stringifier.end();
+```
+
+## Excel Files (XLSX)
+
+```typescript
+import ExcelJS from 'exceljs';
+
+// Read Excel
+const workbook = new ExcelJS.Workbook();
+await workbook.xlsx.readFile('data.xlsx');
+
+const worksheet = workbook.getWorksheet(1);
+const rows: any[] = [];
+
+worksheet.eachRow((row, rowNumber) => {
+  if (rowNumber > 1) { // Skip header
+    rows.push({
+      id: row.getCell(1).value,
+      name: row.getCell(2).value,
+      email: row.getCell(3).value
+    });
+  }
+});
+
+// Write Excel
+const newWorkbook = new ExcelJS.Workbook();
+const newWorksheet = newWorkbook.addWorksheet('Data');
+
+// Add headers
+newWorksheet.columns = [
+  { header: 'ID', key: 'id', width: 10 },
+  { header: 'Name', key: 'name', width: 30 },
+  { header: 'Email', key: 'email', width: 40 }
+];
+
+// Add data
+rows.forEach(row => {
+  newWorksheet.addRow(row);
+});
+
+// Style
+newWorksheet.getRow(1).font = { bold: true };
+newWorksheet.getRow(1).fill = {
+  type: 'pattern',
+  pattern: 'solid',
+  fgColor: { argb: 'FFD3D3D3' }
+};
+
+await newWorkbook.xlsx.writeFile('output.xlsx');
+```
+
+## Data Transformation
+
+```typescript
+// Pipeline for data processing
+async function processImport(filePath: string) {
+  const records = await readCSV(filePath);
+
+  // Transform
+  const transformed = records
+    .map(record => ({
+      ...record,
+      email: record.email.toLowerCase().trim(),
+      name: record.name.toUpperCase(),
+      createdAt: new Date()
+    }))
+    .filter(record => record.email.includes('@'))
+    .filter((record, index, arr) =>
+      arr.findIndex(r => r.email === record.email) === index
+    ); // Deduplicate
+
+  // Validate
+  const validated = transformed.filter(record => {
+    const errors: string[] = [];
+
+    if (!record.email.match(/^[^\s@]+@[^\s@]+\.[^\s@]+$/)) {
+      errors.push('Invalid email');
+    }
+
+    if (record.name.length < 2) {
+      errors.push('Name too short');
+    }
+
+    if (errors.length > 0) {
+      console.warn(`Row invalid: ${errors.join(', ')}`);
+      return false;
+    }
+
+    return true;
+  });
+
+  // Store in database
+  await db.users.createMany(validated);
+
+  return {
+    total: records.length,
+    valid: validated.length,
+    invalid: records.length - validated.length
+  };
+}
+```
+
+## Streaming Large Files
+
+```typescript
+import { createReadStream } from 'fs';
+import { parse } from 'csv-parse';
+
+// Stream processing for large files
+async function processLargeCSV(filePath: string) {
+  const stream = createReadStream(filePath)
+    .pipe(parse({ columns: true, batchSize: 1000 }));
+
+  for await (const records of stream) {
+    // Process batch of 1000 records
+    await db.users.createMany(records);
+    console.log(`Processed ${records.length} records`);
+  }
+}
+```
+
+## Excel with Formulas
+
+```typescript
+import ExcelJS from 'exceljs';
+
+const workbook = new ExcelJS.Workbook();
+const worksheet = workbook.addWorksheet('Summary');
+
+// Data
+worksheet.columns = [
+  { header: 'Item', key: 'item' },
+  { header: 'Price', key: 'price' },
+  { header: 'Quantity', key: 'quantity' },
+  { header: 'Total', key: 'total' }
+];
+
+worksheet.addRows([
+  { item: 'Widget', price: 10, quantity: 5, total: '=B2*C2' },
+  { item: 'Gadget', price: 20, quantity: 3, total: '=B3*C3' }
+]);
+
+// Add summary row
+worksheet.addRow({
+  item: 'Total',
+  price: null,
+  quantity: '=SUM(C2:C3)',
+  total: '=SUM(D2:D3)'
+});
+
+await workbook.xlsx.writeFile('report.xlsx');
+```
+
+## Best Practices
+
+✅ **Stream large files** - Avoid loading entire file in memory
+✅ **Validate data** - Check before storing
+✅ **Batch operations** - Process in chunks
+✅ **Error handling** - Log invalid rows
+✅ **Consistent format** - Normalize data during import
+
+## Resources
+
+- [csv-parse Documentation](https://csv.js.org/parse/)
+- [ExcelJS](https://github.com/exceljs/exceljs)
+- [SheetJS](https://sheetjs.com/)

package/kit/.claude/skills/database-optimization.md

@@ -0,0 +1,196 @@
+# Database Query Optimization
+
+Techniques for improving database performance.
+
+## Indexes
+
+```sql
+-- Create indexes on frequently queried columns
+CREATE INDEX idx_users_email ON users(email);
+CREATE INDEX idx_posts_user_id ON posts(user_id);
+
+-- Composite index for multi-column queries
+CREATE INDEX idx_orders_user_date ON orders(user_id, created_at DESC);
+
+-- Full-text index
+CREATE FULLTEXT INDEX idx_articles_content ON articles(title, content);
+
+-- Check index usage
+EXPLAIN ANALYZE
+SELECT * FROM users WHERE email = 'user@example.com';
+```
+
+## Query Analysis
+
+```typescript
+// Analyze slow queries
+import { db } from './db';
+
+// Enable query logging
+db.logger.setLogLevel('query');
+
+// Use explain to see execution plan
+const plan = await db.connection.explain(`
+  SELECT u.*, COUNT(p.id) as post_count
+  FROM users u
+  LEFT JOIN posts p ON u.id = p.user_id
+  WHERE u.status = 'active'
+  GROUP BY u.id
+`);
+
+console.log('Query plan:', plan);
+```
+
+## N+1 Problem
+
+```typescript
+// Bad: N+1 queries
+const users = await db.users.find(); // 1 query
+for (const user of users) {
+  user.posts = await db.posts.find({ userId: user.id }); // N queries
+}
+
+// Good: Single query with join
+const users = await db.users.find({
+  include: { posts: true }
+});
+
+// Good: Use pagination
+const users = await db.users.find({
+  include: {
+    posts: {
+      select: { id: true, title: true }, // Only needed fields
+      take: 5 // Limit related records
+    }
+  }
+});
+```
+
+## Connection Pooling
+
+```typescript
+import { Pool } from 'pg';
+
+const pool = new Pool({
+  max: 20, // Maximum connections
+  min: 5,  // Minimum connections
+  idleTimeoutMillis: 30000,
+  connectionTimeoutMillis: 2000
+});
+
+// Use pool for queries
+const result = await pool.query('SELECT * FROM users WHERE id = $1', [userId]);
+```
+
+## Denormalization
+
+```typescript
+// Normalized schema (slow queries)
+users (id, email, name)
+posts (id, user_id, content)
+comments (id, post_id, user_id, text)
+
+// Query requires 3 joins
+SELECT u.name, COUNT(c.id) as comment_count
+FROM users u
+JOIN posts p ON u.id = p.user_id
+LEFT JOIN comments c ON p.id = c.post_id
+GROUP BY u.id
+
+// Denormalized schema (faster queries)
+posts (id, user_id, user_name, comment_count)
+
+// Query is direct
+SELECT user_name, comment_count FROM posts
+```
+
+## Query Caching
+
+```typescript
+import { redis } from './redis';
+
+async function getUserWithCache(userId: string) {
+  const cacheKey = `user:${userId}`;
+  
+  // Check cache
+  let user = await redis.get(cacheKey);
+  if (user) return JSON.parse(user);
+  
+  // Query database
+  user = await db.users.findById(userId);
+  
+  // Store in cache (1 hour TTL)
+  await redis.setex(cacheKey, 3600, JSON.stringify(user));
+  
+  return user;
+}
+
+// Invalidate on update
+async function updateUser(userId: string, data: any) {
+  const user = await db.users.update(userId, data);
+  
+  // Clear cache
+  await redis.del(`user:${userId}`);
+  
+  return user;
+}
+```
+
+## Batch Operations
+
+```typescript
+// Bad: Individual inserts
+for (const item of items) {
+  await db.items.create(item); // N queries
+}
+
+// Good: Batch insert
+await db.items.createMany(items); // 1 query
+
+// Good: Batch update
+await db.items.updateMany(
+  { status: 'pending' },
+  { status: 'active' }
+);
+
+// Good: Upsert
+await db.items.upsertMany(
+  items,
+  { upsertFields: ['externalId'] }
+);
+```
+
+## Partitioning & Sharding
+
+```sql
+-- Partition by date (time-series data)
+CREATE TABLE logs (
+  id INT,
+  timestamp TIMESTAMP,
+  message TEXT
+) PARTITION BY RANGE (YEAR(timestamp)) (
+  PARTITION p2023 VALUES LESS THAN (2024),
+  PARTITION p2024 VALUES LESS THAN (2025),
+  PARTITION p_future VALUES LESS THAN MAXVALUE
+);
+
+-- Shard by user_id (horizontal scaling)
+-- Each shard holds data for subset of users
+-- Shard 1: users 1-1M
+-- Shard 2: users 1M-2M
+-- etc.
+```
+
+## Best Practices
+
+✅ **Index strategically** - Only on frequently queried columns
+✅ **Avoid N+1** - Eager load related data
+✅ **Monitor slow queries** - Log and analyze slow operations
+✅ **Use pagination** - Don't fetch all rows
+✅ **Denormalize carefully** - Trade consistency for performance
+
+## Resources
+
+- [PostgreSQL Query Performance](https://www.postgresql.org/docs/current/performance.html)
+- [MySQL Optimization](https://dev.mysql.com/doc/refman/8.0/en/optimization.html)
+- [Database Design for Performance](https://www.sqlshack.com/query-optimization-performance-tuning/)

package/kit/.claude/skills/databases-transactions.md

@@ -0,0 +1,68 @@
+# Database Transactions
+
+## Overview
+Transactions ensure ACID guarantees — multiple operations succeed together or roll back entirely.
+
+## Prisma Transactions
+
+```typescript
+// Sequential transaction (use result of one in the next)
+async function transferFunds(fromId: string, toId: string, amount: number) {
+  return prisma.$transaction(async (tx) => {
+    const from = await tx.account.findUniqueOrThrow({ where: { id: fromId } });
+    if (from.balance < amount) throw new Error('Insufficient funds');
+
+    await tx.account.update({ where: { id: fromId }, data: { balance: { decrement: amount } } });
+    await tx.account.update({ where: { id: toId }, data: { balance: { increment: amount } } });
+    await tx.transaction.create({ data: { fromId, toId, amount } });
+  });
+}
+
+// Batch transaction
+const [user, profile] = await prisma.$transaction([
+  prisma.user.create({ data: { email, name } }),
+  prisma.profile.create({ data: { bio, userId: id } }),
+]);
+```
+
+## Raw SQL Transactions
+
+```typescript
+import { Pool } from 'pg';
+const pool = new Pool({ connectionString: process.env.DATABASE_URL });
+
+async function atomicOperation() {
+  const client = await pool.connect();
+  try {
+    await client.query('BEGIN');
+    await client.query('INSERT INTO orders (user_id, total) VALUES ($1, $2)', [userId, total]);
+    await client.query('UPDATE inventory SET qty = qty - $1 WHERE id = $2', [qty, productId]);
+    await client.query('COMMIT');
+  } catch (err) {
+    await client.query('ROLLBACK');
+    throw err;
+  } finally {
+    client.release();
+  }
+}
+```
+
+## Optimistic Locking
+
+```typescript
+// Use version field to detect concurrent updates
+const updated = await prisma.post.updateMany({
+  where: { id: post.id, version: post.version },
+  data: { title: newTitle, version: { increment: 1 } }
+});
+if (updated.count === 0) throw new Error('Concurrent update — please retry');
+```
+
+## Best Practices
+- Keep transactions short — long ones hold locks and block others
+- Never do HTTP calls inside a transaction
+- Use optimistic locking for high-contention data
+- Set transaction timeout: `SET statement_timeout = '5s'`
+
+## Resources
+- [Prisma transactions](https://www.prisma.io/docs/concepts/components/prisma-client/transactions)