claudeinone-cli 1.0.2 → 1.0.3

package/kit/.claude/skills/test-integration.md

@@ -0,0 +1,216 @@
+# Integration Testing
+
+Testing interactions between multiple components and external services.
+
+## Setup
+
+```bash
+npm install -D vitest supertest jest axios
+```
+
+## API Integration Tests
+
+```typescript
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import request from 'supertest';
+import app from '../app';
+
+describe('User API Integration', () => {
+  let userId: string;
+  
+  beforeAll(async () => {
+    // Setup test database
+    await db.connect();
+  });
+
+  afterAll(async () => {
+    await db.disconnect();
+  });
+
+  it('should create a user', async () => {
+    const response = await request(app)
+      .post('/api/users')
+      .send({
+        email: 'test@example.com',
+        name: 'Test User'
+      });
+
+    expect(response.status).toBe(201);
+    expect(response.body).toHaveProperty('id');
+    userId = response.body.id;
+  });
+
+  it('should fetch created user', async () => {
+    const response = await request(app)
+      .get(`/api/users/${userId}`);
+
+    expect(response.status).toBe(200);
+    expect(response.body.email).toBe('test@example.com');
+  });
+
+  it('should update user', async () => {
+    const response = await request(app)
+      .patch(`/api/users/${userId}`)
+      .send({ name: 'Updated User' });
+
+    expect(response.status).toBe(200);
+    expect(response.body.name).toBe('Updated User');
+  });
+
+  it('should delete user', async () => {
+    const response = await request(app)
+      .delete(`/api/users/${userId}`);
+
+    expect(response.status).toBe(204);
+  });
+});
+```
+
+## Database Integration Tests
+
+```typescript
+import { describe, it, expect, beforeEach } from 'vitest';
+import { db } from '../db';
+
+describe('Database Operations', () => {
+  beforeEach(async () => {
+    await db.truncate('users');
+  });
+
+  it('should save and retrieve user', async () => {
+    const user = await db.users.create({
+      email: 'user@example.com',
+      name: 'John Doe'
+    });
+
+    const retrieved = await db.users.findById(user.id);
+    expect(retrieved.email).toBe('user@example.com');
+  });
+
+  it('should update user', async () => {
+    const user = await db.users.create({
+      email: 'old@example.com',
+      name: 'John'
+    });
+
+    await db.users.update(user.id, {
+      email: 'new@example.com'
+    });
+
+    const updated = await db.users.findById(user.id);
+    expect(updated.email).toBe('new@example.com');
+  });
+
+  it('should handle transactions', async () => {
+    await db.transaction(async (trx) => {
+      const user = await trx('users').insert({
+        email: 'tx@example.com',
+        name: 'Transaction'
+      });
+
+      await trx('profiles').insert({
+        userId: user[0],
+        bio: 'Bio'
+      });
+    });
+
+    const count = await db('users').count();
+    expect(count[0]['count(*)']).toBe(1);
+  });
+});
+```
+
+## Third-Party Service Mocking
+
+```typescript
+import { describe, it, expect, vi } from 'vitest';
+import axios from 'axios';
+
+// Mock external API
+vi.mock('axios');
+const mockedAxios = axios as jest.Mocked<typeof axios>;
+
+describe('Payment Service Integration', () => {
+  it('should process payment via Stripe', async () => {
+    mockedAxios.post.mockResolvedValueOnce({
+      data: { id: 'pi_123', status: 'succeeded' }
+    });
+
+    const result = await processPayment({
+      amount: 9999,
+      currency: 'USD'
+    });
+
+    expect(result.status).toBe('succeeded');
+    expect(mockedAxios.post).toHaveBeenCalledWith(
+      'https://api.stripe.com/v1/payment_intents',
+      expect.any(Object)
+    );
+  });
+
+  it('should handle payment failure', async () => {
+    mockedAxios.post.mockRejectedValueOnce(
+      new Error('Card declined')
+    );
+
+    await expect(processPayment({ amount: 9999 }))
+      .rejects
+      .toThrow('Card declined');
+  });
+});
+```
+
+## End-to-End API Chain
+
+```typescript
+import { describe, it, expect } from 'vitest';
+import request from 'supertest';
+import app from '../app';
+
+describe('User Workflow', () => {
+  it('should complete signup → verify → login flow', async () => {
+    // 1. Sign up
+    const signupRes = await request(app)
+      .post('/api/auth/signup')
+      .send({
+        email: 'new@example.com',
+        password: 'secure123'
+      });
+
+    expect(signupRes.status).toBe(201);
+    const { userId } = signupRes.body;
+
+    // 2. Send verification (mock email)
+    const verifyRes = await request(app)
+      .post(`/api/auth/verify/${userId}`)
+      .send({ code: '123456' });
+
+    expect(verifyRes.status).toBe(200);
+
+    // 3. Login
+    const loginRes = await request(app)
+      .post('/api/auth/login')
+      .send({
+        email: 'new@example.com',
+        password: 'secure123'
+      });
+
+    expect(loginRes.status).toBe(200);
+    expect(loginRes.body).toHaveProperty('token');
+  });
+});
+```
+
+## Best Practices
+
+✅ **Isolation** - Use test database, reset between tests
+✅ **Real calls vs mocks** - Mix real and mocked services
+✅ **Async handling** - Proper await and promise handling
+✅ **Cleanup** - Always teardown after tests
+✅ **Meaningful assertions** - Test behavior, not implementation
+
+## Resources
+
+- [Vitest Documentation](https://vitest.dev/)
+- [Supertest Guide](https://github.com/visionmedia/supertest)
+- [Testing Library](https://testing-library.com/)

package/kit/.claude/skills/test-performance.md

@@ -0,0 +1,162 @@
+# Performance Testing
+
+Load testing, stress testing, and performance profiling.
+
+## Setup
+
+```bash
+npm install -D k6 autocannon clinic
+```
+
+## K6 Load Testing
+
+```typescript
+import http from 'k6/http';
+import { check, sleep } from 'k6';
+
+export const options = {
+  vus: 100,           // 100 virtual users
+  duration: '30s',    // 30 second duration
+  thresholds: {
+    http_req_duration: ['p(95)<500', 'p(99)<1000'],
+    http_req_failed: ['rate<0.1']
+  }
+};
+
+export default function () {
+  const response = http.get('http://localhost:3000/api/users');
+  
+  check(response, {
+    'status is 200': (r) => r.status === 200,
+    'response time < 500ms': (r) => r.timings.duration < 500
+  });
+
+  sleep(1);
+}
+```
+
+## Autocannon Benchmarking
+
+```bash
+# Simple benchmark
+autocannon http://localhost:3000
+
+# Custom configuration
+autocannon -c 100 -d 30 -p 10 http://localhost:3000/api/users
+```
+
+## Clinic.js Profiling
+
+```bash
+# Profiler
+clinic doctor -- node app.js
+
+# Flame graph
+clinic flame -- node app.js
+
+# Bubbleprof
+clinic bubbleprof -- node app.js
+```
+
+## Custom Performance Tests
+
+```typescript
+import { describe, it, expect } from 'vitest';
+import { performance } from 'perf_hooks';
+
+describe('Performance Benchmarks', () => {
+  it('should calculate fibonacci < 1ms', () => {
+    const start = performance.now();
+    
+    const result = fibonacci(10);
+    
+    const duration = performance.now() - start;
+    expect(duration).toBeLessThan(1);
+    expect(result).toBe(55);
+  });
+
+  it('should handle 1000 items in array map < 5ms', () => {
+    const items = Array.from({ length: 1000 }, (_, i) => i);
+    
+    const start = performance.now();
+    const doubled = items.map(x => x * 2);
+    const duration = performance.now() - start;
+
+    expect(duration).toBeLessThan(5);
+    expect(doubled[0]).toBe(0);
+  });
+});
+```
+
+## Memory Profiling
+
+```typescript
+import { performance, PerformanceObserver } from 'perf_hooks';
+
+// Track memory usage
+function monitorMemory() {
+  const obs = new PerformanceObserver((items) => {
+    items.getEntries().forEach((entry) => {
+      console.log(`Memory: ${Math.round(entry.duration)} MB`);
+    });
+  });
+
+  obs.observe({ entryTypes: ['measure'] });
+
+  const start = performance.now();
+  
+  // Your code here
+  const largeArray = Array(1000000).fill(0);
+  
+  const end = performance.now();
+  performance.measure('memory-test', start, end);
+}
+```
+
+## Database Query Performance
+
+```typescript
+import { performance } from 'perf_hooks';
+
+describe('Query Performance', () => {
+  it('should fetch 1000 users < 100ms', async () => {
+    const start = performance.now();
+    
+    const users = await db('users')
+      .limit(1000)
+      .select();
+    
+    const duration = performance.now() - start;
+    expect(duration).toBeLessThan(100);
+  });
+
+  it('should index improves query speed', async () => {
+    // Without index
+    const noIndexTime = await measureQuery(
+      () => db('users').where('email', '=', 'test@example.com').first()
+    );
+
+    // With index (after adding)
+    const withIndexTime = await measureQuery(
+      () => db('users').where('email', '=', 'test@example.com').first()
+    );
+
+    // Index should be 10x faster
+    expect(withIndexTime).toBeLessThan(noIndexTime / 10);
+  });
+});
+```
+
+## Best Practices
+
+✅ **Establish baselines** - Record current performance
+✅ **Test under load** - Realistic user volumes
+✅ **Profile regularly** - Catch regressions early
+✅ **Monitor thresholds** - Set SLOs and alert on breaches
+✅ **Isolate variables** - Test one change at a time
+
+## Resources
+
+- [K6 Documentation](https://k6.io/docs/)
+- [Autocannon](https://github.com/mcollina/autocannon)
+- [Clinic.js](https://clinicjs.org/)

package/kit/.claude/skills/test-tdd.md

@@ -0,0 +1,170 @@
+# Test-Driven Development (TDD)
+
+Writing tests before implementation for better code design.
+
+## Red-Green-Refactor Cycle
+
+```typescript
+// Step 1: RED - Write failing test
+import { describe, it, expect } from 'vitest';
+import { Calculator } from '../calculator';
+
+describe('Calculator', () => {
+  it('should add two numbers', () => {
+    const calc = new Calculator();
+    expect(calc.add(2, 3)).toBe(5);
+  });
+
+  it('should multiply two numbers', () => {
+    const calc = new Calculator();
+    expect(calc.multiply(2, 3)).toBe(6);
+  });
+});
+
+// Step 2: GREEN - Write minimal implementation
+export class Calculator {
+  add(a: number, b: number): number {
+    return a + b;
+  }
+
+  multiply(a: number, b: number): number {
+    return a * b;
+  }
+}
+
+// Step 3: REFACTOR - Improve code while keeping tests passing
+```
+
+## API TDD Example
+
+```typescript
+// Test first
+import { describe, it, expect, beforeEach } from 'vitest';
+import request from 'supertest';
+import app from '../app';
+
+describe('User API', () => {
+  it('should create user and return 201', async () => {
+    const response = await request(app)
+      .post('/api/users')
+      .send({ email: 'test@example.com', name: 'Test' });
+
+    expect(response.status).toBe(201);
+    expect(response.body).toHaveProperty('id');
+    expect(response.body.email).toBe('test@example.com');
+  });
+
+  it('should return 400 for invalid email', async () => {
+    const response = await request(app)
+      .post('/api/users')
+      .send({ email: 'invalid', name: 'Test' });
+
+    expect(response.status).toBe(400);
+    expect(response.body.errors).toContain('Invalid email');
+  });
+});
+
+// Implementation
+app.post('/api/users', async (req, res) => {
+  const { email, name } = req.body;
+  const errors = [];
+
+  if (!email || !email.includes('@')) {
+    errors.push('Invalid email');
+  }
+
+  if (errors.length) {
+    return res.status(400).json({ errors });
+  }
+
+  const user = await db.users.create({ email, name });
+  res.status(201).json(user);
+});
+```
+
+## Contract Testing
+
+```typescript
+// Define contract first
+interface UserService {
+  getUser(id: string): Promise<{ id: string; email: string }>;
+  createUser(data: any): Promise<{ id: string; email: string }>;
+}
+
+// Test contract
+describe('UserService Contract', () => {
+  let service: UserService;
+
+  beforeEach(() => {
+    service = createUserService();
+  });
+
+  it('getUser returns object with id and email', async () => {
+    const user = await service.getUser('123');
+    
+    expect(user).toHaveProperty('id');
+    expect(user).toHaveProperty('email');
+    expect(typeof user.id).toBe('string');
+    expect(typeof user.email).toBe('string');
+  });
+});
+```
+
+## Acceptance Test-Driven Development
+
+```typescript
+// Feature specification
+Feature: User Registration
+  Scenario: User registers with valid credentials
+    Given user is on signup page
+    When user enters email "test@example.com"
+    And user enters password "secure123"
+    And user clicks "Sign Up"
+    Then user should be redirected to dashboard
+    And welcome email should be sent
+
+// Automated acceptance test
+import { test, expect } from '@playwright/test';
+
+test.describe('User Registration', () => {
+  test('should register with valid credentials', async ({ page }) => {
+    await page.goto('/signup');
+    
+    await page.fill('input[name="email"]', 'test@example.com');
+    await page.fill('input[name="password"]', 'secure123');
+    await page.click('button:has-text("Sign Up")');
+    
+    await expect(page).toHaveURL('/dashboard');
+  });
+});
+```
+
+## Mutation Testing
+
+```typescript
+// Detect weak tests
+import stryker from '@stryker-mutator/core';
+
+const results = await stryker.runMutationTest({
+  mutate: ['src/**/*.ts'],
+  testFramework: 'vitest',
+  reporters: ['json', 'html']
+});
+
+// If mutation score < 80%, tests are weak
+console.log(`Mutation score: ${results.mutationScore}%`);
+```
+
+## Best Practices
+
+✅ **Write one test per scenario** - Keep tests focused
+✅ **Meaningful test names** - Describe behavior
+✅ **Arrange-Act-Assert** - Clear test structure
+✅ **Fast feedback loop** - Run tests frequently
+✅ **Refactor with confidence** - Tests prevent regressions
+
+## Resources
+
+- [Test-Driven Development in Practice](https://www.youtube.com/watch?v=QCwqnjxqfmY)
+- [Vitest Documentation](https://vitest.dev/)
+- [Testing Library](https://testing-library.com/)