claudeinone-cli 1.0.1 → 1.0.3

package/kit/.claude/commands/plan/plan-parallel.md

@@ -0,0 +1,25 @@
+# Plan Parallel
+
+## Invocation
+`/plan:parallel [feature]`
+
+## Purpose
+Generate plan via parallel investigation tracks.
+
+## Agent Routing
+- researcher
+- planner
+
+## Execution Protocol
+1. Split research into independent threads.
+2. Merge findings into unified plan.
+3. Highlight conflicting assumptions.
+
+## Validation
+- Verify assumptions before changing files.
+- Run the smallest relevant checks first, then broader checks when risk is high.
+- Report residual risks explicitly.
+
+## Output Format
+1. Combined plan
+2. Conflict resolutions

package/kit/.claude/commands/plan/plan-two.md

@@ -0,0 +1,29 @@
+# Plan Two Approaches
+
+## Invocation
+`/plan:two [task]`
+
+## Purpose
+Produce two contrasting implementation approaches and recommendation.
+
+## Agent Routing
+- researcher
+- planner
+- risk-analyst
+
+## Execution Protocol
+1. Define decision criteria.
+2. Build approach A and B.
+3. Compare scalability/security/simplicity/perf.
+4. Recommend one with rationale.
+
+## Validation
+- Verify assumptions before changing files.
+- Run the smallest relevant checks first, then broader checks when risk is high.
+- Report residual risks explicitly.
+
+## Output Format
+1. Approach A plan
+2. Approach B plan
+3. Comparison matrix
+4. Final recommendation

package/kit/.claude/commands/plan/plan-validate.md

@@ -0,0 +1,27 @@
+# Plan Validate
+
+## Invocation
+`/plan:validate`
+
+## Purpose
+Assess an existing plan for feasibility and missing pieces.
+
+## Agent Routing
+- planner
+- risk-analyst
+- tester
+
+## Execution Protocol
+1. Read target plan artifact.
+2. Check completeness, dependencies, and verification steps.
+3. Return pass/fail with concrete fixes.
+
+## Validation
+- Verify assumptions before changing files.
+- Run the smallest relevant checks first, then broader checks when risk is high.
+- Report residual risks explicitly.
+
+## Output Format
+1. Validation result
+2. Missing sections
+3. Recommended edits

package/kit/.claude/commands/plan/plan.md

@@ -0,0 +1,27 @@
+# Plan
+
+## Invocation
+`/plan [feature]`
+
+## Purpose
+Create implementation-ready plan before coding.
+
+## Agent Routing
+- researcher
+- planner
+
+## Execution Protocol
+1. Run parallel research passes.
+2. Synthesize architecture and phased tasks.
+3. Save plan artifact in plans/.
+4. Wait for review before implementation.
+
+## Validation
+- Verify assumptions before changing files.
+- Run the smallest relevant checks first, then broader checks when risk is high.
+- Report residual risks explicitly.
+
+## Output Format
+1. Plan file path
+2. Phase breakdown
+3. Risks and assumptions

package/kit/.claude/commands/plan/validate.md

@@ -0,0 +1,27 @@
+# Plan Validate
+
+## Invocation
+`/plan:validate`
+
+## Purpose
+Assess an existing plan for feasibility and missing pieces.
+
+## Agent Routing
+- planner
+- risk-analyst
+- tester
+
+## Execution Protocol
+1. Read target plan artifact.
+2. Check completeness, dependencies, and verification steps.
+3. Return pass/fail with concrete fixes.
+
+## Validation
+- Verify assumptions before changing files.
+- Run the smallest relevant checks first, then broader checks when risk is high.
+- Report residual risks explicitly.
+
+## Output Format
+1. Validation result
+2. Missing sections
+3. Recommended edits

package/kit/.claude/commands/skill/fix-logs.md

@@ -0,0 +1,28 @@
+# Skill Fix Logs
+
+## Invocation
+`/skill:fix-logs [skill-path]`
+
+## Purpose
+Repair skill failures discovered in logs.txt.
+
+## Agent Routing
+- debugger
+- skill-creator
+- tester
+
+## Execution Protocol
+1. Classify log errors.
+2. Map failures to broken skill sections.
+3. Rewrite unclear/problematic instructions and examples.
+4. Re-validate with checklist.
+
+## Validation
+- Verify assumptions before changing files.
+- Run the smallest relevant checks first, then broader checks when risk is high.
+- Report residual risks explicitly.
+
+## Output Format
+1. Updated skill changes
+2. Fix report
+3. Validation report

package/kit/.claude/commands/skill/skill-create.md

@@ -0,0 +1,29 @@
+# Skill Create
+
+## Invocation
+`/skill:create [prompt|url]`
+
+## Purpose
+Create a new reusable skill markdown with examples and validation.
+
+## Agent Routing
+- researcher
+- skill-creator
+- code-reviewer
+- tester
+
+## Execution Protocol
+1. Research source material.
+2. Generate skill content and examples.
+3. Review structure/completeness.
+4. Validate usefulness and readiness.
+
+## Validation
+- Verify assumptions before changing files.
+- Run the smallest relevant checks first, then broader checks when risk is high.
+- Report residual risks explicitly.
+
+## Output Format
+1. Skill file path
+2. Quality checklist
+3. Suggested improvements

package/kit/.claude/commands/skill/skill-fix-logs.md

@@ -0,0 +1,28 @@
+# Skill Fix Logs
+
+## Invocation
+`/skill:fix-logs [skill-path]`
+
+## Purpose
+Repair skill failures discovered in logs.txt.
+
+## Agent Routing
+- debugger
+- skill-creator
+- tester
+
+## Execution Protocol
+1. Classify log errors.
+2. Map failures to broken skill sections.
+3. Rewrite unclear/problematic instructions and examples.
+4. Re-validate with checklist.
+
+## Validation
+- Verify assumptions before changing files.
+- Run the smallest relevant checks first, then broader checks when risk is high.
+- Report residual risks explicitly.
+
+## Output Format
+1. Updated skill changes
+2. Fix report
+3. Validation report

package/kit/.claude/settings.json

@@ -0,0 +1,16 @@
+{
+  "version": "1.0.0",
+  "hooks": {
+    "pre-commit": "npm run lint && npm run test:unit",
+    "pre-push": "npm run build && npm run test"
+  },
+  "permissions": {
+    "read": true,
+    "write": true,
+    "execute": true,
+    "publish": false
+  },
+  "mcp-servers": {
+    "enabled": []
+  }
+}

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

@@ -0,0 +1,100 @@
+# Anthropic Claude API
+
+## Overview
+Build AI features with the Anthropic SDK — chat, streaming, tool use, and vision.
+
+## Setup
+
+```bash
+npm install @anthropic-ai/sdk
+```
+
+```typescript
+import Anthropic from '@anthropic-ai/sdk';
+const client = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY });
+```
+
+## Basic Chat
+
+```typescript
+const message = await client.messages.create({
+  model: 'claude-sonnet-4-6',
+  max_tokens: 1024,
+  messages: [{ role: 'user', content: 'Explain async/await in 3 sentences.' }],
+});
+console.log(message.content[0].text);
+```
+
+## Streaming
+
+```typescript
+const stream = await client.messages.stream({
+  model: 'claude-sonnet-4-6',
+  max_tokens: 1024,
+  messages: [{ role: 'user', content: 'Write a poem about TypeScript' }],
+});
+
+for await (const chunk of stream) {
+  if (chunk.type === 'content_block_delta' && chunk.delta.type === 'text_delta') {
+    process.stdout.write(chunk.delta.text);
+  }
+}
+```
+
+## Next.js Streaming API Route
+
+```typescript
+// app/api/chat/route.ts
+import Anthropic from '@anthropic-ai/sdk';
+const client = new Anthropic();
+
+export async function POST(req: Request) {
+  const { messages } = await req.json();
+  const stream = await client.messages.stream({ model: 'claude-sonnet-4-6', max_tokens: 1024, messages });
+
+  return new Response(new ReadableStream({
+    async start(controller) {
+      for await (const chunk of stream) {
+        if (chunk.type === 'content_block_delta' && chunk.delta.type === 'text_delta') {
+          controller.enqueue(new TextEncoder().encode(chunk.delta.text));
+        }
+      }
+      controller.close();
+    }
+  }), { headers: { 'Content-Type': 'text/plain; charset=utf-8' } });
+}
+```
+
+## Tool Use
+
+```typescript
+const response = await client.messages.create({
+  model: 'claude-opus-4-6',
+  max_tokens: 1024,
+  tools: [{
+    name: 'get_weather',
+    description: 'Get weather for a city',
+    input_schema: {
+      type: 'object',
+      properties: { location: { type: 'string' } },
+      required: ['location']
+    }
+  }],
+  messages: [{ role: 'user', content: 'Weather in Tokyo?' }]
+});
+
+if (response.stop_reason === 'tool_use') {
+  const tool = response.content.find(c => c.type === 'tool_use');
+  // handle tool call...
+}
+```
+
+## Model Selection
+| Model | Use Case |
+|-------|----------|
+| `claude-opus-4-6` | Complex reasoning, code generation |
+| `claude-sonnet-4-6` | Balanced — most tasks |
+| `claude-haiku-4-5` | Fast, cost-sensitive |
+
+## Resources
+- [Anthropic SDK docs](https://docs.anthropic.com/en/api/getting-started)

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

@@ -0,0 +1,113 @@
+# Context Engineering
+
+## Overview
+Context engineering is the practice of structuring information given to LLMs to maximize response quality and minimize token usage.
+
+## System Prompt Structure
+
+```typescript
+const SYSTEM_PROMPT = `You are a senior TypeScript developer assistant.
+
+## Your Capabilities
+- Write production-ready TypeScript and React code
+- Debug errors with clear explanations
+- Suggest architectural patterns
+
+## Response Format
+- Use code blocks with language tags
+- Explain the "why" not just the "what"
+- Be concise — no padding or filler
+
+## Constraints
+- Never suggest deprecated APIs
+- Always use TypeScript strict mode
+- Prefer composition over inheritance`;
+
+const response = await client.messages.create({
+  model: 'claude-sonnet-4-6',
+  max_tokens: 2048,
+  system: SYSTEM_PROMPT,
+  messages: [{ role: 'user', content: userMessage }],
+});
+```
+
+## Few-Shot Examples
+
+```typescript
+const messages = [
+  {
+    role: 'user' as const,
+    content: 'Convert this to TypeScript: function add(a, b) { return a + b; }'
+  },
+  {
+    role: 'assistant' as const,
+    content: 'function add(a: number, b: number): number { return a + b; }'
+  },
+  {
+    role: 'user' as const,
+    content: userInput // actual request
+  }
+];
+```
+
+## Retrieval-Augmented Context (RAG)
+
+```typescript
+async function buildContextualPrompt(userQuestion: string): Promise<string> {
+  // 1. Embed the question
+  const queryEmbedding = await openai.embeddings.create({
+    model: 'text-embedding-3-small',
+    input: userQuestion,
+  });
+
+  // 2. Find relevant docs
+  const relevant = await vectorDB.query({
+    vector: queryEmbedding.data[0].embedding,
+    topK: 5,
+  });
+
+  // 3. Build context
+  const context = relevant.matches
+    .map(m => `[${m.metadata.title}]
+${m.metadata.content}`)
+    .join('
+
+---
+
+');
+
+  return `Answer based on this context:
+
+${context}
+
+Question: ${userQuestion}`;
+}
+```
+
+## Conversation Memory with Summarization
+
+```typescript
+async function summarizeOldMessages(messages: Message[]): Promise<string> {
+  const toSummarize = messages.slice(0, -10); // keep last 10 fresh
+  const response = await client.messages.create({
+    model: 'claude-haiku-4-5',
+    max_tokens: 512,
+    messages: [{
+      role: 'user',
+      content: `Summarize this conversation in 3-5 bullet points:
+${JSON.stringify(toSummarize)}`
+    }]
+  });
+  return response.content[0].text;
+}
+```
+
+## Best Practices
+- Put the most important instructions at the start and end of the system prompt
+- Use XML tags to clearly delimit sections (`<context>`, `<instructions>`, `<examples>`)
+- Few-shot examples are powerful — show don't tell
+- Keep context relevant — irrelevant content degrades quality
+- Use `claude-haiku-4-5` for cheap tasks like summarization/routing
+
+## Resources
+- [Anthropic prompt engineering guide](https://docs.anthropic.com/en/docs/build-with-claude/prompt-engineering/overview)

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

@@ -0,0 +1,152 @@
+# Google Gemini API
+
+Multimodal AI model for text, images, and code generation.
+
+## Setup
+
+```bash
+npm install @google/generative-ai
+```
+
+## Text Generation
+
+```typescript
+import { GoogleGenerativeAI } from '@google/generative-ai';
+
+const client = new GoogleGenerativeAI(process.env.GEMINI_API_KEY);
+const model = client.getGenerativeModel({ model: 'gemini-pro' });
+
+async function generateContent(prompt: string) {
+  const result = await model.generateContent(prompt);
+  const response = await result.response;
+  return response.text();
+}
+
+// Usage
+const text = await generateContent('Write a short poem about JavaScript');
+console.log(text);
+```
+
+## Vision (Image Analysis)
+
+```typescript
+import fs from 'fs';
+
+const model = client.getGenerativeModel({ model: 'gemini-pro-vision' });
+
+async function analyzeImage(imagePath: string) {
+  const imageData = fs.readFileSync(imagePath);
+  const base64Image = imageData.toString('base64');
+
+  const result = await model.generateContent([
+    {
+      inlineData: {
+        mimeType: 'image/jpeg',
+        data: base64Image,
+      },
+    },
+    'Describe what you see in this image',
+  ]);
+
+  const response = await result.response;
+  return response.text();
+}
+
+// Usage
+const description = await analyzeImage('photo.jpg');
+console.log(description);
+```
+
+## Chat
+
+```typescript
+const model = client.getGenerativeModel({ model: 'gemini-pro' });
+const chat = model.startChat({
+  history: [
+    {
+      role: 'user',
+      parts: 'Hello',
+    },
+    {
+      role: 'model',
+      parts: 'Great to meet you. What would you like to know?',
+    },
+  ],
+});
+
+async function chat_conversation() {
+  const msg = 'Explain quantum computing in simple terms';
+
+  const result = await chat.sendMessage(msg);
+  const response = await result.response;
+  console.log(response.text());
+}
+```
+
+## Streaming
+
+```typescript
+const model = client.getGenerativeModel({ model: 'gemini-pro' });
+
+async function streamContent(prompt: string) {
+  const result = await model.generateContentStream(prompt);
+
+  for await (const chunk of result.stream) {
+    const chunkText = chunk.text();
+    process.stdout.write(chunkText);
+  }
+}
+
+// Usage
+streamContent('Write a story about time travel');
+```
+
+## Safety Settings
+
+```typescript
+import { HarmBlockThreshold, HarmCategory } from '@google/generative-ai';
+
+const model = client.getGenerativeModel({
+  model: 'gemini-pro',
+  safetySettings: [
+    {
+      category: HarmCategory.HARM_CATEGORY_HATE_SPEECH,
+      threshold: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
+    },
+    {
+      category: HarmCategory.HARM_CATEGORY_VIOLENCE,
+      threshold: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
+    },
+  ],
+});
+```
+
+## Structured Output
+
+```typescript
+async function extractData(text: string) {
+  const prompt = `Extract JSON with name, email, phone from: "${text}"
+  Return only valid JSON like: {"name": "...", "email": "...", "phone": "..."}`;
+
+  const result = await model.generateContent(prompt);
+  const response = await result.response;
+  const jsonText = response.text();
+
+  // Parse JSON from response
+  const json = JSON.parse(jsonText);
+  return json;
+}
+```
+
+## Best Practices
+
+✅ **Rate limiting** - Implement backoff and retries
+✅ **Caching** - Cache common queries
+✅ **Streaming** - Use streaming for long responses
+✅ **Safety filtering** - Set appropriate harm thresholds
+✅ **Tokenization** - Track token usage
+
+## Resources
+
+- [Gemini API Docs](https://ai.google.dev/)
+- [Model Garden](https://makersuite.google.com/)

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

@@ -0,0 +1,93 @@
+# LangChain
+
+Framework for developing applications powered by language models.
+
+## Setup
+
+```bash
+npm install langchain openai
+```
+
+## Basic Chain
+
+```typescript
+import { OpenAI } from 'langchain/llms/openai';
+import { PromptTemplate } from 'langchain/prompts';
+import { LLMChain } from 'langchain/chains';
+
+const model = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
+
+const prompt = new PromptTemplate({
+  template: 'Write a {type} joke about {subject}',
+  inputVariables: ['type', 'subject']
+});
+
+const chain = new LLMChain({ llm: model, prompt });
+
+const result = await chain.call({
+  type: 'funny',
+  subject: 'programming'
+});
+
+console.log(result.text);
+```
+
+## Document Loading
+
+```typescript
+import { PDFLoader } from 'langchain/document_loaders/fs/pdf';
+import { RecursiveCharacterTextSplitter } from 'langchain/text_splitter';
+
+// Load documents
+const loader = new PDFLoader('document.pdf');
+const docs = await loader.load();
+
+// Split into chunks
+const splitter = new RecursiveCharacterTextSplitter({
+  chunkSize: 1000,
+  chunkOverlap: 200
+});
+
+const chunks = await splitter.splitDocuments(docs);
+```
+
+## Embedding & Vector Store
+
+```typescript
+import { OpenAIEmbeddings } from 'langchain/embeddings/openai';
+import { MemoryVectorStore } from 'langchain/vectorstores/memory';
+
+const embeddings = new OpenAIEmbeddings();
+
+const vectorStore = await MemoryVectorStore.fromDocuments(
+  docs,
+  embeddings
+);
+
+// Query
+const results = await vectorStore.similaritySearch('topic', 3);
+```
+
+## Agents
+
+```typescript
+import { initializeAgentExecutor } from 'langchain/agents';
+import { Tool } from 'langchain/tools';
+
+const tools = [
+  new Tool({
+    name: 'Calculator',
+    func: async (input) => eval(input),
+    description: 'Useful for math operations'
+  })
+];
+
+const agent = await initializeAgentExecutor(tools, model, 'zero-shot-react-description');
+
+const result = await agent.call({ input: 'What is 2 + 2?' });
+```
+
+## Resources
+
+- [LangChain Docs](https://js.langchain.com/)
+- [Integrations](https://js.langchain.com/docs/integrations)