claudeinone-cli 1.0.2 → 1.0.3

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

@@ -0,0 +1,179 @@
+# LLamaIndex (formerly GPT Index)
+
+Framework for building production-grade LLM applications with data connectors and indexing.
+
+## Setup
+
+```bash
+npm install llamaindex openai dotenv
+```
+
+## Document Indexing
+
+```typescript
+import { VectorStoreIndex, Document } from 'llamaindex';
+import { OpenAI } from 'llamaindex/llm/openai';
+
+const documents = [
+  new Document({
+    text: 'React is a JavaScript library for building user interfaces.',
+    metadata: { source: 'docs' }
+  }),
+  new Document({
+    text: 'Vue is a progressive framework for building web interfaces.',
+    metadata: { source: 'docs' }
+  })
+];
+
+const llm = new OpenAI({ model: 'gpt-3.5-turbo' });
+
+const index = await VectorStoreIndex.fromDocuments(documents, {
+  llm
+});
+
+// Query
+const query = 'What is React?';
+const response = await index.asRetriever().retrieve(query);
+
+console.log(response);
+```
+
+## Loading Documents
+
+```typescript
+import { SimpleDirectoryReader } from 'llamaindex';
+
+// Load markdown files from directory
+const documents = await new SimpleDirectoryReader().loadData({
+  directoryPath: './data'
+});
+
+// Load PDF
+import { PDFReader } from 'llamaindex/readers';
+
+const pdfDocs = await new PDFReader().loadData({
+  filePath: 'document.pdf'
+});
+```
+
+## RAG (Retrieval-Augmented Generation)
+
+```typescript
+import { VectorStoreIndex, Document, PromptTemplate } from 'llamaindex';
+
+const documents = [
+  new Document({ text: 'Your company policies...' }),
+  new Document({ text: 'Product documentation...' })
+];
+
+const index = await VectorStoreIndex.fromDocuments(documents);
+const retriever = index.asRetriever();
+
+// Custom prompt
+const promptTemplate = new PromptTemplate({
+  template: `Answer the question using the context:
+{context_str}
+
+Question: {query_str}`
+});
+
+const queryEngine = index.asQueryEngine({
+  preFilters: { field: 'source', operator: 'eq', value: 'docs' }
+});
+
+const response = await queryEngine.query({
+  query: 'What are the payment terms?'
+});
+
+console.log(response.response);
+```
+
+## Chat with Memory
+
+```typescript
+import { VectorStoreIndex, Document, ChatMemoryBuffer } from 'llamaindex';
+
+const documents = [
+  new Document({ text: 'Product features...' })
+];
+
+const index = await VectorStoreIndex.fromDocuments(documents);
+const memory = new ChatMemoryBuffer({ tokenLimit: 3000 });
+
+const chatEngine = index.asChatEngine({ memory });
+
+// Multi-turn conversation
+const response1 = await chatEngine.chat({
+  message: 'Tell me about your products'
+});
+
+const response2 = await chatEngine.chat({
+  message: 'What about pricing?' // Has context from previous messages
+});
+
+console.log(response2.response);
+```
+
+## Custom Retrievers
+
+```typescript
+import { BaseRetriever, SimilarityType } from 'llamaindex';
+
+class CustomRetriever extends BaseRetriever {
+  async retrieve(query: string) {
+    // Custom retrieval logic (e.g., BM25, graph-based)
+    const results = await this.customSearch(query);
+    return results.map(r => ({
+      text: r.content,
+      score: r.relevance
+    }));
+  }
+}
+
+const customRetriever = new CustomRetriever();
+const queryEngine = index.asQueryEngine({
+  retriever: customRetriever
+});
+```
+
+## Agents
+
+```typescript
+import { createOpenAIAgent, Tool } from 'llamaindex/agent';
+import { ToolMetadata } from 'llamaindex';
+
+const tools = [
+  new Tool({
+    metadata: {
+      name: 'search_documents',
+      description: 'Search company documentation'
+    },
+    fn: async (query: string) => {
+      const index = await loadIndex();
+      return await index.asRetriever().retrieve(query);
+    }
+  })
+];
+
+const agent = createOpenAIAgent({
+  tools,
+  model: 'gpt-4'
+});
+
+const response = await agent.chat({
+  message: 'What are our refund policies?'
+});
+```
+
+## Best Practices
+
+✅ **Chunking** - Split documents appropriately
+✅ **Metadata** - Include source and date
+✅ **Evaluation** - Measure retrieval quality
+✅ **Caching** - Cache embeddings
+✅ **Error handling** - Handle API failures gracefully
+
+## Resources
+
+- [LLamaIndex Docs](https://docs.llamaindex.ai/)
+- [Data Connectors](https://docs.llamaindex.ai/en/stable/module_guides/data_loaders/root.html)

package/kit/.claude/skills/ai-mcp-builder.md

@@ -0,0 +1,101 @@
+# MCP Server Builder
+
+## Overview
+Build custom Model Context Protocol servers to extend Claude Code with your own tools, resources, and data sources.
+
+## Setup
+
+```bash
+npm install @modelcontextprotocol/sdk
+npx @modelcontextprotocol/create-server my-mcp-server
+```
+
+## Basic MCP Server
+
+```typescript
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+
+const server = new Server(
+  { name: "my-tools", version: "1.0.0" },
+  { capabilities: { tools: {} } }
+);
+
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+  tools: [
+    {
+      name: "get_user",
+      description: "Fetch a user from the database by ID",
+      inputSchema: {
+        type: "object",
+        properties: {
+          id: { type: "string", description: "User ID" }
+        },
+        required: ["id"]
+      }
+    }
+  ]
+}));
+
+server.setRequestHandler(CallToolRequestSchema, async (req) => {
+  if (req.params.name === "get_user") {
+    const { id } = req.params.arguments as { id: string };
+    const user = await db.findUser(id);
+    return {
+      content: [{ type: "text", text: JSON.stringify(user, null, 2) }]
+    };
+  }
+  throw new Error(`Unknown tool: ${req.params.name}`);
+});
+
+const transport = new StdioServerTransport();
+await server.connect(transport);
+```
+
+## Register in Claude Code
+
+```json
+// ~/.claude/claude_desktop_config.json
+{
+  "mcpServers": {
+    "my-tools": {
+      "command": "node",
+      "args": ["/path/to/my-mcp-server/dist/index.js"],
+      "env": {
+        "DATABASE_URL": "postgresql://..."
+      }
+    }
+  }
+}
+```
+
+## MCP with Resources (File/Data Provider)
+
+```typescript
+import { ListResourcesRequestSchema, ReadResourceRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+
+server.setRequestHandler(ListResourcesRequestSchema, async () => ({
+  resources: [
+    { uri: "db://users/list", name: "All Users", mimeType: "application/json" }
+  ]
+}));
+
+server.setRequestHandler(ReadResourceRequestSchema, async (req) => {
+  if (req.params.uri === "db://users/list") {
+    const users = await db.findAll();
+    return { contents: [{ uri: req.params.uri, mimeType: "application/json", text: JSON.stringify(users) }] };
+  }
+  throw new Error("Resource not found");
+});
+```
+
+## Best Practices
+- Keep tools focused — one tool does one thing well
+- Return structured JSON text for complex data
+- Validate all inputs with proper error messages
+- Use environment variables for secrets, never hardcode
+
+## Resources
+- [MCP SDK docs](https://modelcontextprotocol.io/docs)
+- [MCP server examples](https://github.com/modelcontextprotocol/servers)

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

@@ -0,0 +1,250 @@
+# OpenAI API
+
+Access GPT models, embeddings, and other AI services.
+
+## Setup
+
+```bash
+npm install openai
+```
+
+## Chat Completions
+
+```typescript
+import OpenAI from 'openai';
+
+const client = new OpenAI({
+  apiKey: process.env.OPENAI_API_KEY
+});
+
+async function chat(userMessage: string) {
+  const response = await client.chat.completions.create({
+    model: 'gpt-4-turbo',
+    messages: [
+      {
+        role: 'system',
+        content: 'You are a helpful programming assistant.'
+      },
+      {
+        role: 'user',
+        content: userMessage
+      }
+    ],
+    temperature: 0.7,
+    max_tokens: 500
+  });
+
+  return response.choices[0].message.content;
+}
+
+// Usage
+const answer = await chat('How do I implement caching in Node.js?');
+console.log(answer);
+```
+
+## Streaming Responses
+
+```typescript
+async function streamChat(userMessage: string) {
+  const stream = client.chat.completions.create({
+    model: 'gpt-4-turbo',
+    messages: [{ role: 'user', content: userMessage }],
+    stream: true
+  });
+
+  for await (const chunk of await stream) {
+    if (chunk.choices[0].delta.content) {
+      process.stdout.write(chunk.choices[0].delta.content);
+    }
+  }
+}
+```
+
+## Embeddings
+
+```typescript
+async function getEmbedding(text: string) {
+  const response = await client.embeddings.create({
+    model: 'text-embedding-3-small',
+    input: text
+  });
+
+  return response.data[0].embedding;
+}
+
+// Usage for semantic search
+const query = 'How to build a REST API?';
+const queryEmbedding = await getEmbedding(query);
+
+const documents = [
+  'REST API with Express and Node.js',
+  'GraphQL server setup',
+  'WebSocket real-time communication'
+];
+
+const docEmbeddings = await Promise.all(
+  documents.map(doc => getEmbedding(doc))
+);
+
+// Find most similar document
+const similarities = docEmbeddings.map((emb, idx) => ({
+  idx,
+  similarity: cosineSimilarity(queryEmbedding, emb)
+}));
+
+const mostSimilar = similarities.sort((a, b) => b.similarity - a.similarity)[0];
+console.log(`Most similar: ${documents[mostSimilar.idx]}`);
+```
+
+## Vision (Image Analysis)
+
+```typescript
+async function analyzeImage(imageUrl: string) {
+  const response = await client.chat.completions.create({
+    model: 'gpt-4-vision',
+    messages: [
+      {
+        role: 'user',
+        content: [
+          {
+            type: 'image_url',
+            image_url: { url: imageUrl }
+          },
+          {
+            type: 'text',
+            text: 'Describe this image in detail'
+          }
+        ]
+      }
+    ]
+  });
+
+  return response.choices[0].message.content;
+}
+
+// Local image
+async function analyzeLocalImage(imagePath: string) {
+  const fs = require('fs');
+  const base64 = fs.readFileSync(imagePath).toString('base64');
+
+  const response = await client.chat.completions.create({
+    model: 'gpt-4-vision',
+    messages: [
+      {
+        role: 'user',
+        content: [
+          {
+            type: 'image_url',
+            image_url: {
+              url: `data:image/jpeg;base64,${base64}`
+            }
+          },
+          {
+            type: 'text',
+            text: 'What is in this image?'
+          }
+        ]
+      }
+    ]
+  });
+
+  return response.choices[0].message.content;
+}
+```
+
+## Function Calling
+
+```typescript
+const tools = [
+  {
+    type: 'function',
+    function: {
+      name: 'get_current_weather',
+      description: 'Get the current weather in a location',
+      parameters: {
+        type: 'object',
+        properties: {
+          location: {
+            type: 'string',
+            description: 'The city and state, e.g. San Francisco, CA'
+          },
+          unit: {
+            type: 'string',
+            enum: ['celsius', 'fahrenheit']
+          }
+        },
+        required: ['location']
+      }
+    }
+  }
+];
+
+async function getWeatherAndRespond(query: string) {
+  const response = await client.chat.completions.create({
+    model: 'gpt-4-turbo',
+    messages: [{ role: 'user', content: query }],
+    tools: tools,
+    tool_choice: 'auto'
+  });
+
+  if (response.choices[0].message.tool_calls) {
+    const toolCall = response.choices[0].message.tool_calls[0];
+    
+    // Execute function based on tool_call.function.name
+    const result = await executeFunction(
+      toolCall.function.name,
+      JSON.parse(toolCall.function.arguments)
+    );
+
+    // Send result back for final response
+    const finalResponse = await client.chat.completions.create({
+      model: 'gpt-4-turbo',
+      messages: [
+        { role: 'user', content: query },
+        response.choices[0].message,
+        {
+          role: 'tool',
+          tool_call_id: toolCall.id,
+          content: JSON.stringify(result)
+        }
+      ]
+    });
+
+    return finalResponse.choices[0].message.content;
+  }
+}
+```
+
+## Error Handling
+
+```typescript
+try {
+  const response = await client.chat.completions.create({
+    model: 'gpt-4-turbo',
+    messages: [{ role: 'user', content: 'Hello' }],
+    max_tokens: 10
+  });
+} catch (error) {
+  if (error instanceof OpenAI.APIError) {
+    console.error(`API Error: ${error.status} - ${error.message}`);
+  } else if (error instanceof OpenAI.RateLimitError) {
+    console.error('Rate limit exceeded');
+  } else if (error instanceof OpenAI.AuthenticationError) {
+    console.error('Invalid API key');
+  }
+}
+```
+
+## Best Practices
+
+✅ **Use streaming** - Better UX for long responses
+✅ **Set temperature** - 0.7 for balanced, 0 for deterministic
+✅ **Token limits** - Monitor usage and costs
+✅ **Error handling** - Handle rate limits and API errors
+✅ **Caching** - Cache embeddings for reuse
+
+## Resources
+
+- [OpenAI API Documentation](https://platform.openai.com/docs/api-reference)
+- [Model Pricing](https://openai.com/pricing)
+- [Best Practices](https://platform.openai.com/docs/guides/gpt-best-practices)

package/kit/.claude/skills/ai-prompt-engineering.md

@@ -0,0 +1,173 @@
+# Prompt Engineering
+
+Techniques for effective LLM prompting and optimization.
+
+## Basic Prompting
+
+```typescript
+import { openai } from '@ai-sdk/openai';
+import { generateText } from 'ai';
+
+// Simple prompt
+const result = await generateText({
+  model: openai('gpt-4'),
+  prompt: 'Explain quantum computing in simple terms'
+});
+
+console.log(result.text);
+```
+
+## Few-Shot Prompting
+
+```typescript
+const examples = `
+Example 1:
+Question: What is 2 + 2?
+Answer: 4
+
+Example 2:
+Question: What is 5 * 3?
+Answer: 15
+
+Question: What is 10 - 3?
+`;
+
+const result = await generateText({
+  model: openai('gpt-4'),
+  prompt: examples
+});
+```
+
+## Role-Based Prompting
+
+```typescript
+const systemPrompt = `You are an expert JavaScript developer. 
+Provide clear, concise code examples with explanations.
+Focus on best practices and performance.
+Use TypeScript for type safety.`;
+
+const messages = [
+  {
+    role: 'system',
+    content: systemPrompt
+  },
+  {
+    role: 'user',
+    content: 'How do I optimize array operations in JavaScript?'
+  }
+];
+
+const result = await generateText({
+  model: openai('gpt-4'),
+  messages
+});
+```
+
+## Chain of Thought
+
+```typescript
+const prompt = `Answer the question by thinking step by step.
+
+Question: A train leaves New York traveling at 60 mph. 
+Another train leaves Boston traveling at 80 mph. 
+They are 215 miles apart. 
+When will they meet?
+
+Think through:
+1. Combined speed
+2. Time to meet
+3. Distance each travels`;
+
+const result = await generateText({
+  model: openai('gpt-4'),
+  prompt
+});
+```
+
+## Structured Output
+
+```typescript
+import { generateObject } from 'ai';
+
+const { object } = await generateObject({
+  model: openai('gpt-4'),
+  prompt: 'Extract contact information from: "Contact John Doe at john@example.com, phone: 555-1234"',
+  schema: z.object({
+    name: z.string(),
+    email: z.string().email(),
+    phone: z.string()
+  })
+});
+
+console.log(object); // { name: 'John Doe', email: 'john@example.com', phone: '555-1234' }
+```
+
+## Temperature & Sampling
+
+```typescript
+// Deterministic (temperature=0)
+const response1 = await generateText({
+  model: openai('gpt-4'),
+  temperature: 0, // Always the same answer
+  prompt: 'What is the capital of France?'
+});
+
+// Creative (temperature=1)
+const response2 = await generateText({
+  model: openai('gpt-4'),
+  temperature: 1, // More varied responses
+  prompt: 'Write a creative story about a robot'
+});
+```
+
+## Token Management
+
+```typescript
+import { countTokens } from 'js-tiktoken';
+import { encoding_for_model } from 'js-tiktoken';
+
+const enc = encoding_for_model('gpt-4');
+
+const text = 'This is a sample text to count tokens';
+const tokens = enc.encode(text);
+const tokenCount = tokens.length;
+
+console.log(`Token count: ${tokenCount}`);
+
+// Truncate if needed
+const maxTokens = 1000;
+if (tokenCount > maxTokens) {
+  const truncated = text.slice(0, Math.floor(text.length * (maxTokens / tokenCount)));
+}
+```
+
+## Prompt Optimization
+
+```typescript
+// Bad: Vague prompt
+'Write some code'
+
+// Good: Specific prompt
+'Write a TypeScript function that validates email addresses using regex. 
+The function should handle edge cases like subdomains and return true/false.'
+
+// Better: Include examples
+'Write a TypeScript function that validates email addresses.
+Examples:
+- "user@example.com" → true
+- "invalid@" → false
+- "user+tag@example.co.uk" → true'
+```
+
+## Best Practices
+
+✅ **Be specific** - Describe exactly what you want
+✅ **Use examples** - Show expected input/output
+✅ **Assign role** - Give context to the AI
+✅ **Set temperature** - Control creativity vs determinism
+✅ **Monitor tokens** - Manage costs and latency
+
+## Resources
+
+- [OpenAI Prompt Engineering Guide](https://platform.openai.com/docs/guides/prompt-engineering)
+- [Vercel AI SDK](https://sdk.vercel.ai/)