claudeinone-cli 1.0.1 → 1.0.3

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

@@ -0,0 +1,301 @@
+# Unit Testing
+
+Write isolated tests for individual functions and components using Jest and Vitest.
+
+## Jest Setup
+
+```bash
+npm install -D jest @types/jest ts-jest
+npx jest --init
+```
+
+## Basic Tests
+
+```typescript
+describe('Calculator', () => {
+  test('adds two numbers', () => {
+    const add = (a: number, b: number) => a + b;
+    expect(add(2, 3)).toBe(5);
+  });
+
+  test('throws error on invalid input', () => {
+    expect(() => {
+      const divide = (a: number, b: number) => {
+        if (b === 0) throw new Error('Division by zero');
+        return a / b;
+      };
+      divide(10, 0);
+    }).toThrow('Division by zero');
+  });
+});
+```
+
+## Testing Async Functions
+
+```typescript
+test('fetches user data', async () => {
+  const fetchUser = async (id: number) => {
+    const res = await fetch(`/api/users/${id}`);
+    return res.json();
+  };
+
+  // Using async/await
+  const user = await fetchUser(1);
+  expect(user.name).toBe('John');
+
+  // Or using .then()
+  return fetchUser(1).then((user) => {
+    expect(user.email).toBe('john@example.com');
+  });
+});
+```
+
+## Mocking
+
+```typescript
+// Mock entire module
+jest.mock('./api', () => ({
+  fetchUser: jest.fn().mockResolvedValue({ id: 1, name: 'John' })
+}));
+
+// Mock specific function
+const mockFn = jest.fn((x) => x * 2);
+expect(mockFn(3)).toBe(6);
+expect(mockFn).toHaveBeenCalledWith(3);
+expect(mockFn).toHaveBeenCalledTimes(1);
+```
+
+## React Component Tests
+
+```typescript
+import { render, screen } from '@testing-library/react';
+import { Button } from './Button';
+
+test('renders button with text', () => {
+  render(<Button>Click me</Button>);
+  const button = screen.getByRole('button', { name: /click me/i });
+  expect(button).toBeInTheDocument();
+});
+
+test('calls onClick handler', () => {
+  const handleClick = jest.fn();
+  render(<Button onClick={handleClick}>Click</Button>);
+
+  screen.getByRole('button').click();
+  expect(handleClick).toHaveBeenCalled();
+});
+```
+
+## Test Coverage
+
+```bash
+# Run with coverage report
+jest --coverage
+
+# Generate HTML report
+jest --coverage --coverageReporters=html
+```
+
+## Best Practices
+
+✅ **Arrange-Act-Assert** - Setup, execute, verify
+✅ **One assertion per test** - Keep tests focused
+✅ **Descriptive names** - Use clear test descriptions
+✅ **Avoid test interdependencies** - Each test independent
+✅ **Mock external dependencies** - Don't test third-party code
+
+## Resources
+
+- [Jest Documentation](https://jestjs.io/)
+- [React Testing Library](https://testing-library.com/)
+
+## Core Patterns & Implementations
+
+### Key Concepts
+- Industry standards and best practices
+- Proven architectural patterns
+- Performance optimization techniques
+- Security-first development approach
+- Testing and quality assurance
+
+### Common Use Cases
+- Building production applications
+- Solving complex technical problems
+- Optimizing performance and scalability
+- Implementing security best practices
+- Team collaboration and knowledge transfer
+
+## Implementation Guide
+
+### Setup & Configuration
+- Framework/tool initialization
+- Environment setup
+- Configuration best practices
+- Development vs production settings
+
+### Code Examples
+- Real-world patterns and solutions
+- Integration with other tools
+- Error handling approaches
+- Performance optimization
+
+### Architecture Patterns
+- Proven design patterns
+- Component organization
+- Data flow and state management
+- Scalability considerations
+
+## Best Practices
+
+1. **Code Quality** — Follow conventions, write clean code
+2. **Performance** — Profile and optimize bottlenecks
+3. **Security** — Implement security-first practices
+4. **Testing** — Comprehensive test coverage
+5. **Documentation** — Clear, maintainable documentation
+6. **Monitoring** — Track health and metrics
+7. **Scalability** — Design for growth
+
+## Testing Strategies
+
+- Unit testing fundamentals
+- Integration testing approaches
+- End-to-end testing patterns
+- Performance testing methods
+- Security testing checklist
+
+## Performance Considerations
+
+- Optimization techniques
+- Caching strategies
+- Database optimization
+- API performance
+- Front-end performance
+- Monitoring and profiling
+
+## Security Checklist
+
+- Input validation and sanitization
+- Authentication and authorization
+- Data encryption
+- Secure dependencies
+- Common vulnerability patterns
+- Security headers and configuration
+
+## Deployment & Operations
+
+- Preparation for production
+- Deployment strategies
+- Rollback procedures
+- Monitoring and alerting
+- Logging and debugging
+- Incident response
+
+## Integration Points
+
+Works seamlessly with:
+- Related technologies and frameworks
+- Development and deployment tools
+- Monitoring and observability
+- Security and compliance tools
+
+## Tools & Technologies
+
+- Popular frameworks and libraries
+- Development utilities
+- Testing frameworks
+- Deployment platforms
+- Monitoring solutions
+
+## Common Pitfalls to Avoid
+
+- Premature optimization
+- Ignoring security requirements
+- Insufficient testing
+- Poor error handling
+- Technical debt accumulation
+- Monolithic approaches
+- Lack of monitoring
+
+## Learning Path
+
+1. Understand core concepts
+2. Study best practices
+3. Review real-world examples
+4. Build sample projects
+5. Apply in production
+6. Mentor others
+7. Stay current
+
+## Advanced Topics
+
+- Optimization strategies
+- Distributed systems
+- High-availability patterns
+- Advanced security
+- Performance at scale
+- Cloud-native patterns
+
+## Resources
+
+- Official documentation
+- Community guides and tutorials
+- Best practices and patterns
+- Example implementations
+- Performance optimization guides
+- Security hardening resources
+- Case studies and real-world examples
+
+## Success Criteria
+
+✅ Implementation follows best practices
+✅ Code is clean and maintainable
+✅ Performance is optimized
+✅ Security requirements met
+✅ Tests provide good coverage
+✅ Documentation is complete
+✅ Monitoring and alerting configured
+✅ Deployment is smooth and safe
+
+## When to Use This Skill
+
+Apply this skill when:
+- Building production applications
+- Solving complex problems
+- Optimizing performance
+- Implementing security
+- Making architectural decisions
+- Training team members
+- Reviewing code quality
+
+## Integration with Other Skills
+
+This skill complements:
+- Related framework/tool skills
+- Architecture pattern skills
+- Testing and quality skills
+- DevOps and deployment skills
+- Security and compliance skills
+
+## Version Notes
+
+- Latest stable releases
+- Feature deprecations
+- Migration guides
+- Breaking changes
+- Upgrade paths
+
+## Community & Support
+
+- Official forums and discussions
+- Community Slack/Discord channels
+- Stack Overflow resources
+- GitHub discussions
+- Blog posts and articles
+
+## Roadmap & Future
+
+- Upcoming features
+- Planned improvements
+- Community contributions
+- Performance roadmap
+- Security improvements

package/kit/.claude/skills/testing-accessibility.md

@@ -0,0 +1,117 @@
+# Accessibility Testing
+
+Ensuring applications are usable by everyone.
+
+## Automated Testing
+
+```typescript
+import { axe } from 'jest-axe';
+import { render } from '@testing-library/react';
+
+describe('Button Accessibility', () => {
+  it('should have no accessibility violations', async () => {
+    const { container } = render(<Button>Click me</Button>);
+    const results = await axe(container);
+    expect(results).toHaveNoViolations();
+  });
+});
+```
+
+## Manual Testing Checklist
+
+```
+Keyboard Navigation:
+✓ All interactive elements are keyboard accessible
+✓ Tab order is logical
+✓ Focus is visible
+✓ Can close modals with ESC
+
+Color & Contrast:
+✓ Text contrast ratio ≥ 4.5:1 (normal text)
+✓ Text contrast ratio ≥ 3:1 (large text)
+✓ Information is not conveyed by color alone
+
+Screen Readers:
+✓ Page has proper heading hierarchy
+✓ Images have alt text
+✓ Form labels are associated with inputs
+✓ Dynamic content is announced
+```
+
+## Screen Reader Testing
+
+```typescript
+// Semantic HTML
+<form>
+  <label htmlFor="email">Email:</label>
+  <input id="email" type="email" required />
+
+  <label htmlFor="password">Password:</label>
+  <input id="password" type="password" required />
+
+  <button type="submit">Sign In</button>
+</form>
+
+// ARIA when semantic HTML isn't enough
+<button aria-label="Close menu">×</button>
+<div role="alert">{errorMessage}</div>
+<div aria-live="polite">{statusMessage}</div>
+```
+
+## WebAIM Tools
+
+```bash
+# Install accessibility testing tools
+npm install -D @testing-library/jest-dom axe-core jest-axe pa11y
+
+# Run pa11y
+pa11y http://localhost:3000
+```
+
+## Color Contrast Checker
+
+```typescript
+function getContrastRatio(foreground: string, background: string): number {
+  const getLuminance = (color: string): number => {
+    const rgb = parseInt(color.slice(1), 16);
+    const r = (rgb >> 16) & 0xff;
+    const g = (rgb >> 8) & 0xff;
+    const b = rgb & 0xff;
+
+    const [rs, gs, bs] = [r, g, b].map(x => {
+      x = x / 255;
+      return x <= 0.03928 ? x / 12.92 : Math.pow((x + 0.055) / 1.055, 2.4);
+    });
+
+    return 0.2126 * rs + 0.7152 * gs + 0.0722 * bs;
+  };
+
+  const l1 = getLuminance(foreground);
+  const l2 = getLuminance(background);
+
+  const lighter = Math.max(l1, l2);
+  const darker = Math.min(l1, l2);
+
+  return (lighter + 0.05) / (darker + 0.05);
+}
+
+// Usage
+const ratio = getContrastRatio('#333333', '#ffffff');
+console.log(`Contrast ratio: ${ratio.toFixed(2)}:1`);
+```
+
+## Best Practices
+
+✅ **Use semantic HTML** - `<button>` not `<div onClick>`
+✅ **Alt text for images** - Describe image content
+✅ **Form labels** - Associate with inputs
+✅ **Keyboard navigation** - Navigate without mouse
+✅ **Color not only** - Don't convey info via color alone
+✅ **Focus visible** - Clear focus indicator
+✅ **Sufficient contrast** - WCAG AA standard
+
+## Resources
+
+- [WebAIM](https://webaim.org/)
+- [WCAG 2.1 Guidelines](https://www.w3.org/WAI/WCAG21/quickref/)
+- [jest-axe](https://github.com/nickcolley/jest-axe)

package/kit/.claude/skills/testing-contract.md

@@ -0,0 +1,75 @@
+# Contract Testing
+
+Testing API contracts between services.
+
+## Pact Setup
+
+```bash
+npm install -D @pact-foundation/pact
+```
+
+## Consumer Test
+
+```typescript
+import { Pact, Matchers } from '@pact-foundation/pact';
+
+describe('UserService Consumer', () => {
+  const provider = new Pact({
+    consumer: 'Frontend',
+    provider: 'UserAPI'
+  });
+
+  it('fetches user successfully', async () => {
+    await provider.addInteraction({
+      state: 'user with ID 1 exists',
+      uponReceiving: 'a request for user 1',
+      withRequest: {
+        method: 'GET',
+        path: '/api/users/1'
+      },
+      willRespondWith: {
+        status: 200,
+        body: {
+          id: Matchers.like(1),
+          email: Matchers.like('user@example.com'),
+          name: Matchers.like('John')
+        }
+      }
+    });
+
+    const user = await userService.getUser(1);
+
+    expect(user.email).toBe('user@example.com');
+  });
+
+  afterAll(() => provider.finalize());
+});
+```
+
+## Provider Test
+
+```typescript
+describe('UserAPI Provider', () => {
+  it('honors the consumer contract', async () => {
+    const opts = {
+      consumerVersionSelectors: [{ tag: 'main' }],
+      providerBaseUrl: 'http://localhost:3000'
+    };
+
+    await verifyPacts(opts);
+  });
+});
+```
+
+## Benefits
+
+✅ **Prevents integration breaks** - Catch issues early
+✅ **Consumer-driven** - Tests reflect real usage
+✅ **Independent testing** - No need for other service
+✅ **Documentation** - Contract serves as spec
+✅ **Confidence** - Verify contracts between services
+
+## Resources
+
+- [Pact Documentation](https://docs.pact.dev/)
+- [Contract Testing](https://martinfowler.com/articles/consumerDrivenContracts.html)

package/kit/.claude/skills/testing-e2e-advanced.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/testing-load-stress.md

@@ -0,0 +1,79 @@
+# Load & Stress Testing
+
+Testing application behavior under load.
+
+## Apache JMeter
+
+```bash
+# Create test plan graphically
+jmeter
+
+# Run from command line
+jmeter -n -t test.jmx -l results.jtl -j logs.txt
+```
+
+## Locust (Python-based)
+
+```python
+from locust import HttpUser, task, between
+
+class APIUser(HttpUser):
+    wait_time = between(1, 5)
+
+    @task(3)
+    def get_users(self):
+        self.client.get("/api/users")
+
+    @task(1)
+    def create_user(self):
+        self.client.post("/api/users", {
+            "email": "test@example.com",
+            "name": "Test User"
+        })
+
+# Run: locust -f locustfile.py --host=http://localhost:3000
+```
+
+## Artillery Load Testing
+
+```yaml
+# load-test.yml
+config:
+  target: "http://localhost:3000"
+  phases:
+    - duration: 60
+      arrivalRate: 10
+      name: "Warm up"
+    - duration: 60
+      arrivalRate: 20
+      name: "Sustained load"
+
+scenarios:
+  - name: "API Load Test"
+    flow:
+      - get:
+          url: "/api/users"
+      - post:
+          url: "/api/users"
+          json:
+            email: "test@example.com"
+            name: "Test"
+```
+
+```bash
+artillery run load-test.yml
+```
+
+## Best Practices
+
+✅ **Gradual ramp-up** - Start low, increase gradually
+✅ **Realistic scenarios** - Mimic actual usage
+✅ **Monitor metrics** - CPU, memory, database
+✅ **Identify bottlenecks** - Find breaking points
+✅ **Set thresholds** - Define acceptable limits
+
+## Resources
+
+- [Apache JMeter](https://jmeter.apache.org/)
+- [Locust](https://locust.io/)
+- [Artillery](https://artillery.io/)

package/kit/.claude/skills/testing-mutation.md

@@ -0,0 +1,92 @@
+# Mutation Testing
+
+Testing the quality of your tests.
+
+## Stryker Setup
+
+```bash
+npm install -D @stryker-mutator/core @stryker-mutator/typescript-checker
+npx stryker init
+```
+
+## Configuration
+
+```json
+{
+  "stryker-config": {
+    "mutate": ["src/**/*.ts"],
+    "mutator": "typescript",
+    "testRunner": "vitest",
+    "reporters": ["html", "json", "dashboard"],
+    "basePath": ".",
+    "concurrency": 4,
+    "coverageAnalysis": "all"
+  }
+}
+```
+
+## Running Tests
+
+```bash
+# Run mutation testing
+npm run stryker
+
+# Generate report
+npx stryker report --baseDir baseline
+```
+
+## Understanding Mutations
+
+```typescript
+// Original code
+function add(a: number, b: number): number {
+  return a + b;
+}
+
+// Possible mutations
+// 1. return a - b;
+// 2. return a * b;
+// 3. return a / b;
+// 4. return 0;
+
+// Test quality
+describe('add', () => {
+  it('should add numbers', () => {
+    expect(add(2, 3)).toBe(5);
+  });
+
+  // Good: kills multiple mutations
+  it('should handle negative numbers', () => {
+    expect(add(-2, 3)).toBe(1);
+  });
+
+  // Better: more specific assertions
+  it('should not use multiplication', () => {
+    expect(add(2, 3)).not.toBe(6);
+  });
+});
+```
+
+## Mutation Score Interpretation
+
+```
+Killed: Test caught the mutation
+Survived: Test missed the mutation
+Timeout: Mutation caused infinite loop
+Error: Mutation caused compilation error
+
+Score = (Killed / (Killed + Survived)) * 100
+Target: > 80% mutation score
+```
+
+## Best Practices
+
+✅ **Kill mutations** - Tests should fail when code changes
+✅ **Avoid flaky tests** - Deterministic behavior
+✅ **Full coverage** - High code coverage + mutation score
+✅ **Edge cases** - Test boundaries
+✅ **Assertions** - Multiple assertions per test
+
+## Resources
+
+- [Stryker Mutator](https://stryker-mutator.io/)