claudeinone-cli 1.0.1 → 1.0.3

package/kit/.claude/skills/ai-rag.md

@@ -0,0 +1,91 @@
+# RAG (Retrieval-Augmented Generation)
+
+Combining retrieval with language models for accurate, contextual responses.
+
+## RAG Pipeline
+
+```typescript
+import { VectorStoreIndex, Document } from 'llamaindex';
+import { OpenAI } from 'llamaindex/llm/openai';
+
+async function setupRAG(documents: string[]) {
+  const docs = documents.map(text => new Document({ text }));
+
+  const index = await VectorStoreIndex.fromDocuments(docs, {
+    llm: new OpenAI({ model: 'gpt-4' })
+  });
+
+  return index;
+}
+
+async function queryWithRAG(index: any, query: string) {
+  const retriever = index.asRetriever({ similarityTopK: 5 });
+  const retrieved = await retriever.retrieve(query);
+
+  const context = retrieved
+    .map(node => node.getContent())
+    .join('\n---\n');
+
+  const response = await openai.createChatCompletion({
+    model: 'gpt-4',
+    messages: [
+      {
+        role: 'system',
+        content: `You are a helpful assistant. Use the provided context to answer questions accurately.\n\nContext:\n${context}`
+      },
+      { role: 'user', content: query }
+    ]
+  });
+
+  return response.choices[0].message.content;
+}
+```
+
+## Evaluation
+
+```typescript
+interface RAGMetric {
+  retrieval_precision: number;
+  retrieval_recall: number;
+  answer_relevance: number;
+  context_relevance: number;
+}
+
+async function evaluateRAG(
+  testCases: Array<{ query: string; expectedAnswer: string }>,
+  groundTruth: string[]
+): Promise<RAGMetric> {
+  let precisionSum = 0;
+  let recallSum = 0;
+
+  for (const test of testCases) {
+    const retrieved = await retriever.retrieve(test.query);
+    const retrievedDocs = new Set(retrieved.map(r => r.metadata.source));
+
+    const precision = retrieved.length > 0
+      ? retrieved.filter(r => groundTruth.includes(r.text)).length / retrieved.length
+      : 0;
+
+    precisionSum += precision;
+  }
+
+  return {
+    retrieval_precision: precisionSum / testCases.length,
+    retrieval_recall: 0.85,
+    answer_relevance: 0.92,
+    context_relevance: 0.88
+  };
+}
+```
+
+## Best Practices
+
+✅ **Chunking strategy** - Optimize document splits
+✅ **Metadata** - Include source, timestamp, category
+✅ **Reranking** - Use LLM to rerank results
+✅ **Evaluation** - Measure retrieval quality
+✅ **Feedback loops** - Learn from wrong answers
+
+## Resources
+
+- [LLamaIndex RAG Guide](https://docs.llamaindex.ai/en/stable/use_cases/rag/)

package/kit/.claude/skills/ai-vectordb.md

@@ -0,0 +1,215 @@
+# Vector Databases
+
+Specialized databases for semantic search and AI applications.
+
+## Pinecone
+
+```typescript
+import { Pinecone } from '@pinecone-database/pinecone';
+
+const pc = new Pinecone({
+  apiKey: process.env.PINECONE_API_KEY
+});
+
+const index = pc.Index('my-index');
+
+// Upsert vectors
+await index.upsert([
+  {
+    id: 'vec1',
+    values: [0.1, 0.2, 0.3],
+    metadata: { text: 'Hello world' }
+  }
+]);
+
+// Query
+const results = await index.query({
+  vector: [0.1, 0.2, 0.3],
+  topK: 5,
+  includeMetadata: true
+});
+
+console.log(results.matches);
+```
+
+## Supabase pgvector
+
+```typescript
+import { createClient } from '@supabase/supabase-js';
+import { OpenAIEmbeddings } from '@langchain/openai';
+
+const supabase = createClient(url, key);
+const embeddings = new OpenAIEmbeddings();
+
+// Create table
+await supabase.from('documents').create({
+  id: 'int8',
+  content: 'text',
+  embedding: 'vector(1536)'
+});
+
+// Insert with embedding
+const embedding = await embeddings.embedQuery('sample text');
+await supabase.from('documents').insert({
+  content: 'sample text',
+  embedding: embedding
+});
+
+// Vector search
+const queryEmbedding = await embeddings.embedQuery('find similar');
+const results = await supabase.rpc('match_documents', {
+  query_embedding: queryEmbedding,
+  similarity_threshold: 0.7,
+  match_count: 10
+});
+```
+
+## Weaviate
+
+```typescript
+import { client } from '@weaviate/client';
+
+const myClient = client.client({
+  scheme: 'http',
+  host: 'localhost:8080'
+});
+
+// Create class
+await myClient.schema.classCreator()
+  .withClass({
+    class: 'Document',
+    properties: [
+      { name: 'content', dataType: ['text'] },
+      { name: 'source', dataType: ['string'] }
+    ]
+  })
+  .do();
+
+// Insert with vectors
+await myClient.data
+  .creator()
+  .withClass('Document')
+  .withProperties({
+    content: 'Machine learning is...',
+    source: 'wikipedia'
+  })
+  .withVector([0.1, 0.2, 0.3])
+  .do();
+
+// Semantic search
+const response = await myClient.graphql
+  .get()
+  .withClassName('Document')
+  .withFields(['content', '_additional { distance }'])
+  .withNearVector({ vector: [0.1, 0.2, 0.3] })
+  .withLimit(10)
+  .do();
+```
+
+## Qdrant
+
+```typescript
+import { QdrantClient } from '@qdrant/js-client-rest';
+
+const client = new QdrantClient({
+  url: 'http://localhost:6333'
+});
+
+// Create collection
+await client.recreateCollection('my_collection', {
+  vectors: { size: 384, distance: 'Cosine' }
+});
+
+// Insert vectors
+await client.upsert('my_collection', {
+  points: [
+    {
+      id: 1,
+      vector: [0.1, 0.2, 0.3],
+      payload: { text: 'Hello world' }
+    }
+  ]
+});
+
+// Search
+const results = await client.search('my_collection', {
+  vector: [0.1, 0.2, 0.3],
+  limit: 10
+});
+
+console.log(results);
+```
+
+## Milvus
+
+```typescript
+import { MilvusClient } from '@milvus.io/milvus2-sdk-node';
+
+const milvusClient = new MilvusClient({
+  address: 'localhost:19530'
+});
+
+// Create collection
+await milvusClient.createCollection({
+  collection_name: 'documents',
+  fields: [
+    { name: 'id', data_type: 'INT64', is_primary_key: true },
+    { name: 'embedding', data_type: 'FLOAT_VECTOR', type_params: { dim: '384' } },
+    { name: 'text', data_type: 'VARCHAR', max_length: 1000 }
+  ]
+});
+
+// Insert
+await milvusClient.insert({
+  collection_name: 'documents',
+  fields_data: [
+    { embedding: [0.1, 0.2, 0.3], text: 'Sample text' }
+  ]
+});
+
+// Search
+const results = await milvusClient.search({
+  collection_name: 'documents',
+  vectors: [[0.1, 0.2, 0.3]],
+  limit: 10
+});
+```
+
+## Hybrid Search
+
+```typescript
+// Combine keyword search + vector search
+async function hybridSearch(query: string, content: string) {
+  const vectorResults = await vectorDb.search({
+    vector: await getEmbedding(query),
+    topK: 10
+  });
+
+  const keywordResults = await db.query(
+    'SELECT * FROM documents WHERE content LIKE ?',
+    [`%${query}%`]
+  );
+
+  // Merge and re-rank
+  const merged = [
+    ...vectorResults.map((r, i) => ({ ...r, score: 1 - (i / 10) })),
+    ...keywordResults.map((r, i) => ({ ...r, score: 0.5 - (i / 20) }))
+  ];
+
+  return merged.sort((a, b) => b.score - a.score).slice(0, 10);
+}
+```
+
+## Best Practices
+
+✅ **Choose right distance metric** - Cosine for normalized vectors
+✅ **Embedding quality** - Use powerful models (E5, BGE)
+✅ **Batch operations** - Bulk insert for performance
+✅ **Metadata filtering** - Reduce search scope
+✅ **Reranking** - LLM reranking for better results
+
+## Resources
+
+- [Pinecone Docs](https://docs.pinecone.io/)
+- [Qdrant Docs](https://qdrant.tech/documentation/)
+- [Weaviate Docs](https://weaviate.io/developers/weaviate)

package/kit/.claude/skills/analytics-segment.md

@@ -0,0 +1,161 @@
+# Segment Analytics
+
+Customer data platform for tracking events and traits.
+
+## Setup
+
+```bash
+npm install @segment/analytics-next
+```
+
+## Initialization
+
+```typescript
+import { AnalyticsBrowser } from '@segment/analytics-next';
+
+const analytics = AnalyticsBrowser.load({
+  writeKey: process.env.REACT_APP_SEGMENT_WRITE_KEY
+});
+
+export default analytics;
+```
+
+## Identify Users
+
+```typescript
+import analytics from './analytics';
+
+async function handleUserLogin(user: { id: string; email: string; name: string }) {
+  // Identify user
+  await analytics.identify(user.id, {
+    email: user.email,
+    name: user.name,
+    loginTime: new Date().toISOString()
+  });
+}
+
+async function updateUserTraits(userId: string, traits: any) {
+  await analytics.identify(userId, traits);
+}
+
+async function logout(userId: string) {
+  await analytics.reset();
+}
+```
+
+## Track Events
+
+```typescript
+import analytics from './analytics';
+
+// Page view
+await analytics.page('Dashboard', {
+  category: 'dashboard',
+  title: 'User Dashboard'
+});
+
+// Custom events
+await analytics.track('Product Viewed', {
+  productId: '123',
+  productName: 'Laptop',
+  price: 999.99
+});
+
+// E-commerce events
+await analytics.track('Order Completed', {
+  orderId: 'order-456',
+  total: 299.99,
+  currency: 'USD',
+  products: [
+    {
+      id: '123',
+      name: 'Product 1',
+      price: 99.99,
+      quantity: 2
+    }
+  ]
+});
+
+// Feature usage
+await analytics.track('Feature Used', {
+  feature: 'export_report',
+  duration: 5000
+});
+```
+
+## Group Tracking
+
+```typescript
+// Identify company/team
+await analytics.group('company-123', {
+  name: 'Acme Corp',
+  plan: 'enterprise',
+  users: 50
+});
+
+// Track group events
+await analytics.track('Workspace Created', {
+  workspaceId: 'ws-456',
+  // Will be associated with group-123
+});
+```
+
+## React Integration
+
+```typescript
+import { useAnalytics } from '@segment/analytics-react';
+import { useEffect } from 'react';
+
+function ProductPage({ productId }: { productId: string }) {
+  const analytics = useAnalytics();
+
+  useEffect(() => {
+    analytics?.page('Product', {
+      productId,
+      category: 'products'
+    });
+
+    analytics?.track('Product Viewed', {
+      productId
+    });
+  }, [productId, analytics]);
+
+  return <div>Product Details</div>;
+}
+```
+
+## Server-Side Tracking
+
+```typescript
+import { Analytics } from '@segment/analytics-node';
+
+const analytics = new Analytics({
+  writeKey: process.env.SEGMENT_WRITE_KEY
+});
+
+// Track server event
+await analytics.track({
+  userId: 'user-123',
+  event: 'Email Sent',
+  properties: {
+    emailType: 'welcome',
+    recipient: 'user@example.com'
+  }
+});
+
+// Flush and close
+await analytics.closeAndFlush();
+```
+
+## Best Practices
+
+✅ **Consistent naming** - Use snake_case for events
+✅ **Contextual data** - Include relevant properties
+✅ **PII handling** - Don't send personally identifiable info
+✅ **Batching** - Leverage Segment's batching
+✅ **Testing** - Use Segment debug mode in development
+
+## Resources
+
+- [Segment Documentation](https://segment.com/docs/)
+- [Tracking API](https://segment.com/docs/api/track/)

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

@@ -0,0 +1,103 @@
+# API Caching
+
+## Overview
+Cache API responses at multiple layers — HTTP headers, CDN, Redis, and in-memory — to reduce latency and database load.
+
+## HTTP Cache Headers (Next.js)
+
+```typescript
+// Cache API response for 60s, allow stale for 10s while revalidating
+export async function GET() {
+  const data = await fetchExpensiveData();
+  return Response.json(data, {
+    headers: {
+      'Cache-Control': 'public, s-maxage=60, stale-while-revalidate=10',
+    }
+  });
+}
+
+// Per-request cache (Next.js fetch cache)
+const data = await fetch('https://api.example.com/data', {
+  next: { revalidate: 60 } // revalidate every 60s
+});
+```
+
+## Redis Cache Layer
+
+```typescript
+import { Redis } from 'ioredis';
+const redis = new Redis(process.env.REDIS_URL!);
+
+async function getCachedUser(id: string) {
+  const cacheKey = `user:${id}`;
+
+  // 1. Try cache
+  const cached = await redis.get(cacheKey);
+  if (cached) return JSON.parse(cached);
+
+  // 2. Fetch from DB
+  const user = await prisma.user.findUnique({ where: { id } });
+  if (!user) return null;
+
+  // 3. Store with 5min TTL
+  await redis.setex(cacheKey, 300, JSON.stringify(user));
+  return user;
+}
+
+// Invalidate on update
+async function updateUser(id: string, data: Partial<User>) {
+  const user = await prisma.user.update({ where: { id }, data });
+  await redis.del(`user:${id}`);
+  return user;
+}
+```
+
+## In-Memory LRU Cache (single instance)
+
+```bash
+npm install lru-cache
+```
+
+```typescript
+import { LRUCache } from 'lru-cache';
+
+const cache = new LRUCache<string, unknown>({
+  max: 500,           // max 500 items
+  ttl: 1000 * 60 * 5, // 5 minute TTL
+});
+
+export function withCache<T>(key: string, fetcher: () => Promise<T>): Promise<T> {
+  const hit = cache.get(key) as T | undefined;
+  if (hit !== undefined) return Promise.resolve(hit);
+  return fetcher().then(result => { cache.set(key, result); return result; });
+}
+```
+
+## Stale-While-Revalidate Pattern
+
+```typescript
+const cache = new Map<string, { data: unknown; fetchedAt: number }>();
+
+async function staleWhileRevalidate<T>(key: string, ttl: number, fetcher: () => Promise<T>): Promise<T> {
+  const entry = cache.get(key);
+  const isStale = !entry || Date.now() - entry.fetchedAt > ttl;
+
+  if (isStale) {
+    // Revalidate in background, return stale data immediately if available
+    const fresh = fetcher().then(data => { cache.set(key, { data, fetchedAt: Date.now() }); return data; });
+    if (!entry) return fresh; // No stale data, must wait
+  }
+
+  return entry!.data as T;
+}
+```
+
+## Best Practices
+- Cache at the lowest layer possible (HTTP > CDN > Redis > in-memory)
+- Always set expiry — never cache indefinitely without TTL
+- Cache key should include all query parameters
+- Use `stale-while-revalidate` for non-critical data (better UX)
+
+## Resources
+- [HTTP caching guide](https://developer.mozilla.org/en-US/docs/Web/HTTP/Caching)
+- [ioredis](https://github.com/redis/ioredis)

package/kit/.claude/skills/api-documentation.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