ai-qakit 1.0.0

package/templates/.claude/skills/sequential-thinking/tests/process-thought.test.js

@@ -0,0 +1,215 @@
+/**
+ * Tests for Sequential Thinking Thought Processor
+ *
+ * Run with: npm test
+ */
+
+const { ThoughtProcessor } = require('../scripts/process-thought');
+const fs = require('fs');
+const path = require('path');
+
+// Mock history file for testing
+const TEST_HISTORY_FILE = path.join(__dirname, '../scripts/.thought-history.json');
+
+describe('ThoughtProcessor', () => {
+  let processor;
+
+  beforeEach(() => {
+    // Clean up any existing history file
+    if (fs.existsSync(TEST_HISTORY_FILE)) {
+      fs.unlinkSync(TEST_HISTORY_FILE);
+    }
+    processor = new ThoughtProcessor();
+  });
+
+  afterEach(() => {
+    // Clean up after tests
+    if (fs.existsSync(TEST_HISTORY_FILE)) {
+      fs.unlinkSync(TEST_HISTORY_FILE);
+    }
+  });
+
+  describe('Validation', () => {
+    test('rejects missing thought', () => {
+      const result = processor.processThought({
+        thoughtNumber: 1,
+        totalThoughts: 5,
+        nextThoughtNeeded: true
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.errors).toContain('Invalid thought: must be a non-empty string');
+    });
+
+    test('rejects empty thought string', () => {
+      const result = processor.processThought({
+        thought: '   ',
+        thoughtNumber: 1,
+        totalThoughts: 5,
+        nextThoughtNeeded: true
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.errors).toContain('Invalid thought: must be a non-empty string');
+    });
+
+    test('rejects invalid thoughtNumber', () => {
+      const result = processor.processThought({
+        thought: 'Test',
+        thoughtNumber: 0,
+        totalThoughts: 5,
+        nextThoughtNeeded: true
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.errors).toContain('Invalid thoughtNumber: must be a positive number');
+    });
+
+    test('rejects missing nextThoughtNeeded', () => {
+      const result = processor.processThought({
+        thought: 'Test',
+        thoughtNumber: 1,
+        totalThoughts: 5
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.errors).toContain('Invalid nextThoughtNeeded: must be a boolean');
+    });
+
+    test('accepts valid thought', () => {
+      const result = processor.processThought({
+        thought: 'Valid thought',
+        thoughtNumber: 1,
+        totalThoughts: 5,
+        nextThoughtNeeded: true
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.thoughtNumber).toBe(1);
+      expect(result.totalThoughts).toBe(5);
+    });
+  });
+
+  describe('Thought Processing', () => {
+    test('tracks thought history', () => {
+      processor.processThought({
+        thought: 'First thought',
+        thoughtNumber: 1,
+        totalThoughts: 3,
+        nextThoughtNeeded: true
+      });
+
+      processor.processThought({
+        thought: 'Second thought',
+        thoughtNumber: 2,
+        totalThoughts: 3,
+        nextThoughtNeeded: true
+      });
+
+      const result = processor.processThought({
+        thought: 'Third thought',
+        thoughtNumber: 3,
+        totalThoughts: 3,
+        nextThoughtNeeded: false
+      });
+
+      expect(result.thoughtHistoryLength).toBe(3);
+    });
+
+    test('auto-adjusts totalThoughts when exceeded', () => {
+      const result = processor.processThought({
+        thought: 'Thought 5',
+        thoughtNumber: 5,
+        totalThoughts: 3,
+        nextThoughtNeeded: true
+      });
+
+      expect(result.totalThoughts).toBe(5);
+    });
+
+    test('tracks revisions', () => {
+      processor.processThought({
+        thought: 'Original thought',
+        thoughtNumber: 1,
+        totalThoughts: 5,
+        nextThoughtNeeded: true
+      });
+
+      const result = processor.processThought({
+        thought: 'Revised thought',
+        thoughtNumber: 2,
+        totalThoughts: 5,
+        nextThoughtNeeded: true,
+        isRevision: true,
+        revisesThought: 1
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.thoughtHistoryLength).toBe(2);
+    });
+
+    test('tracks branches', () => {
+      processor.processThought({
+        thought: 'Main thought',
+        thoughtNumber: 1,
+        totalThoughts: 5,
+        nextThoughtNeeded: true
+      });
+
+      processor.processThought({
+        thought: 'Branch A',
+        thoughtNumber: 2,
+        totalThoughts: 5,
+        nextThoughtNeeded: true,
+        branchFromThought: 1,
+        branchId: 'branch-a'
+      });
+
+      const result = processor.processThought({
+        thought: 'Branch B',
+        thoughtNumber: 2,
+        totalThoughts: 5,
+        nextThoughtNeeded: false,
+        branchFromThought: 1,
+        branchId: 'branch-b'
+      });
+
+      expect(result.branches).toContain('branch-a');
+      expect(result.branches).toContain('branch-b');
+      expect(result.branches.length).toBe(2);
+    });
+  });
+
+  describe('History Management', () => {
+    test('resets history', () => {
+      processor.processThought({
+        thought: 'First thought',
+        thoughtNumber: 1,
+        totalThoughts: 5,
+        nextThoughtNeeded: true
+      });
+
+      processor.resetHistory();
+
+      const history = processor.getHistory();
+      expect(history.totalThoughts).toBe(0);
+      expect(history.thoughts.length).toBe(0);
+    });
+
+    test('persists and loads history', () => {
+      processor.processThought({
+        thought: 'Persisted thought',
+        thoughtNumber: 1,
+        totalThoughts: 5,
+        nextThoughtNeeded: true
+      });
+
+      // Create new processor instance (should load from file)
+      const newProcessor = new ThoughtProcessor();
+      const history = newProcessor.getHistory();
+
+      expect(history.totalThoughts).toBe(1);
+      expect(history.thoughts[0].thought).toBe('Persisted thought');
+    });
+  });
+});

package/templates/.claude/skills/test-automation/SKILL.md

@@ -0,0 +1,93 @@
+# Test Automation Skill
+
+## Overview
+
+Expert knowledge in test automation frameworks, patterns, and best practices for building maintainable and reliable automated test suites.
+
+## Triggers
+
+This skill activates when:
+- Writing or reviewing automated tests
+- Setting up test frameworks
+- Discussing test automation strategy
+- Debugging flaky tests
+- Optimizing test execution
+
+## Capabilities
+
+### Framework Expertise
+- **Unit Testing**: Jest, Vitest, Mocha, pytest, JUnit
+- **Integration Testing**: Supertest, TestContainers
+- **E2E Testing**: Playwright, WebdriverIO, Cypress
+- **API Testing**: REST, GraphQL, gRPC testing
+- **Mobile Testing**: Appium, Detox
+
+### Patterns & Practices
+- Page Object Model (POM)
+- Screenplay Pattern
+- Test Data Management
+- Test Fixtures & Factories
+- Mocking & Stubbing strategies
+- Parallel test execution
+- CI/CD integration
+
+### Quality Attributes
+- Test reliability (no flaky tests)
+- Test maintainability
+- Test readability
+- Test performance
+- Test isolation
+
+## Workflow
+
+1. **Analyze** - Understand what needs to be tested
+2. **Design** - Choose appropriate test strategy
+3. **Implement** - Write clean, maintainable tests
+4. **Validate** - Ensure tests are reliable
+5. **Optimize** - Improve test performance
+
+## Best Practices
+
+### Test Structure
+```typescript
+describe('Feature', () => {
+  beforeEach(() => {
+    // Setup - Arrange
+  });
+
+  it('should do something when condition', async () => {
+    // Act
+    const result = await action();
+    
+    // Assert
+    expect(result).toBe(expected);
+  });
+
+  afterEach(() => {
+    // Cleanup
+  });
+});
+```
+
+### Naming Conventions
+- `should [expected behavior] when [condition]`
+- `[method] returns [result] for [input]`
+
+### Assertions
+- One logical assertion per test
+- Use specific matchers
+- Include meaningful error messages
+
+## References
+
+See `references/` for detailed documentation on:
+- Framework-specific guides
+- Pattern implementations
+- CI/CD configurations
+
+## Examples
+
+See `examples/` for:
+- Test suite templates
+- Page object examples
+- Factory patterns

package/templates/.claude/skills/test-automation/examples/page-object.ts

@@ -0,0 +1,44 @@
+/**
+ * Page Object Model Example - Playwright
+ */
+import { Page, Locator, expect } from '@playwright/test';
+
+export class LoginPage {
+  readonly page: Page;
+  readonly emailInput: Locator;
+  readonly passwordInput: Locator;
+  readonly submitButton: Locator;
+  readonly errorMessage: Locator;
+
+  constructor(page: Page) {
+    this.page = page;
+    this.emailInput = page.getByLabel('Email');
+    this.passwordInput = page.getByLabel('Password');
+    this.submitButton = page.getByRole('button', { name: 'Sign in' });
+    this.errorMessage = page.getByRole('alert');
+  }
+
+  async goto() {
+    await this.page.goto('/login');
+  }
+
+  async login(email: string, password: string) {
+    await this.emailInput.fill(email);
+    await this.passwordInput.fill(password);
+    await this.submitButton.click();
+  }
+
+  async expectError(message: string) {
+    await expect(this.errorMessage).toContainText(message);
+  }
+
+  async expectLoggedIn() {
+    await expect(this.page).toHaveURL('/dashboard');
+  }
+}
+
+// Usage in test
+// const loginPage = new LoginPage(page);
+// await loginPage.goto();
+// await loginPage.login('user@example.com', 'password');
+// await loginPage.expectLoggedIn();

package/templates/.claude/skills/test-automation/references/frameworks.md

@@ -0,0 +1,96 @@
+# Test Automation Frameworks Reference
+
+## Unit Testing Frameworks
+
+### Jest (JavaScript/TypeScript)
+```typescript
+// jest.config.js
+export default {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  coverageThreshold: {
+    global: { branches: 80, functions: 80, lines: 80 }
+  }
+};
+```
+
+### Vitest (JavaScript/TypeScript)
+```typescript
+// vitest.config.ts
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'node',
+    coverage: { reporter: ['text', 'html'] }
+  }
+});
+```
+
+### pytest (Python)
+```python
+# pytest.ini
+[pytest]
+testpaths = tests
+python_files = test_*.py
+python_functions = test_*
+addopts = -v --cov=src --cov-report=html
+```
+
+## E2E Testing Frameworks
+
+### Playwright
+```typescript
+// playwright.config.ts
+import { defineConfig } from '@playwright/test';
+
+export default defineConfig({
+  testDir: './tests/e2e',
+  fullyParallel: true,
+  retries: process.env.CI ? 2 : 0,
+  use: {
+    baseURL: 'http://localhost:3000',
+    trace: 'on-first-retry',
+    screenshot: 'only-on-failure'
+  },
+  projects: [
+    { name: 'chromium', use: { browserName: 'chromium' } },
+    { name: 'firefox', use: { browserName: 'firefox' } },
+    { name: 'webkit', use: { browserName: 'webkit' } }
+  ]
+});
+```
+
+### WebdriverIO
+```typescript
+// wdio.conf.ts
+export const config: WebdriverIO.Config = {
+  specs: ['./tests/e2e/**/*.spec.ts'],
+  capabilities: [{
+    browserName: 'chrome',
+    'goog:chromeOptions': { args: ['--headless'] }
+  }],
+  framework: 'mocha',
+  reporters: ['spec', 'allure']
+};
+```
+
+## API Testing
+
+### Supertest
+```typescript
+import request from 'supertest';
+import app from '../src/app';
+
+describe('API Tests', () => {
+  it('GET /api/users returns users', async () => {
+    const response = await request(app)
+      .get('/api/users')
+      .set('Authorization', `Bearer ${token}`)
+      .expect(200);
+    
+    expect(response.body).toHaveProperty('users');
+  });
+});
+```

package/templates/.claude/skills/test-data-management/SKILL.md

@@ -0,0 +1,24 @@
+# Test Data Management Skill
+
+## Overview
+Expert knowledge in test data generation, fixtures, and data management.
+
+## Triggers
+- Creating test data
+- Managing fixtures
+- Data-driven testing
+- Test database setup
+
+## Patterns
+- Factory pattern (faker.js, factory_bot)
+- Builder pattern
+- Fixtures (static data)
+- Database seeding
+- Data masking/anonymization
+
+## Best Practices
+- Generate realistic data
+- Isolate test data
+- Clean up after tests
+- Version control fixtures
+- Handle sensitive data properly

package/templates/.claude/skills/test-design/SKILL.md

@@ -0,0 +1,25 @@
+# Test Design Skill
+
+## Overview
+Expert knowledge in test case design techniques and test strategy.
+
+## Triggers
+- Designing test cases
+- Test planning
+- Risk-based testing
+- Test coverage analysis
+
+## Techniques
+- Equivalence Partitioning
+- Boundary Value Analysis
+- Decision Tables
+- State Transition Testing
+- Pairwise Testing
+- Error Guessing
+
+## Best Practices
+- Start with requirements analysis
+- Apply multiple techniques
+- Prioritize by risk
+- Balance coverage and effort
+- Document test rationale

package/templates/.claude/skills/typescript-pro/SKILL.md

@@ -0,0 +1,84 @@
+---
+name: typescript-pro
+description: Master TypeScript's advanced type system including generics, conditional types, mapped types, template literals, and utility types for building type-safe applications. Use when implementing complex type logic, creating reusable type utilities, designing type-safe API clients, building form validation systems, or ensuring compile-time type safety. Triggers on "type inference", "generic constraints", "conditional type", "mapped type", "template literal type", "utility type".
+version: 1.0.0
+---
+
+# TypeScript Pro
+
+Comprehensive guidance for mastering TypeScript's advanced type system to build robust, type-safe applications.
+
+## When to Use
+
+- Building type-safe libraries or frameworks
+- Creating reusable generic components
+- Implementing complex type inference logic
+- Designing type-safe API clients
+- Building form validation systems
+- Creating strongly-typed configuration objects
+- Implementing type-safe state management
+- Migrating JavaScript to TypeScript
+
+## Core Concepts
+
+### Generics
+Create reusable, type-flexible components. See `references/generics.md` for:
+- Basic generic functions and classes
+- Generic constraints with `extends`
+- Multiple type parameters
+- Default type parameters
+
+### Conditional Types
+Create types that depend on conditions. See `references/conditional-types.md` for:
+- Basic conditional patterns
+- `infer` keyword for type extraction
+- Distributive conditional types
+- Nested conditions
+
+### Mapped Types
+Transform existing types by iterating properties. See `references/mapped-types.md` for:
+- Property transformation
+- Key remapping with `as`
+- Filtering properties
+- Modifier manipulation (+/- readonly/optional)
+
+### Template Literal Types
+String-based types with pattern matching. See `references/template-literals.md` for:
+- String manipulation utilities
+- Event naming patterns
+- Path building types
+
+### Utility Types
+Built-in type helpers. See `references/utility-types.md` for:
+- `Partial`, `Required`, `Readonly`
+- `Pick`, `Omit`, `Record`
+- `Exclude`, `Extract`, `NonNullable`
+- `Parameters`, `ReturnType`
+
+## Advanced Patterns
+
+See `references/advanced-patterns.md` for:
+- Type-safe event emitters
+- Type-safe API clients
+- Builder pattern with type safety
+- Deep Readonly/Partial
+- Discriminated unions
+- Type-safe form validation
+
+## Type Inference Techniques
+
+See `references/type-inference.md` for:
+- `infer` keyword patterns
+- Type guards (`is`)
+- Assertion functions (`asserts`)
+- `const` assertions
+
+## Best Practices
+
+See `references/best-practices.md` for:
+- `unknown` vs `any`
+- `interface` vs `type`
+- Strict mode configuration
+- Type testing patterns
+- Common pitfalls to avoid
+- Performance considerations

package/templates/.claude/skills/typescript-pro/references/advanced-patterns.md

@@ -0,0 +1,100 @@
+# Advanced Patterns
+
+## Type-Safe Event Emitter
+
+```typescript
+type EventMap = {
+  "user:created": { id: string; name: string };
+  "user:deleted": { id: string };
+};
+
+class TypedEmitter<T extends Record<string, any>> {
+  private listeners: { [K in keyof T]?: Array<(data: T[K]) => void> } = {};
+
+  on<K extends keyof T>(event: K, callback: (data: T[K]) => void): void {
+    (this.listeners[event] ??= []).push(callback);
+  }
+
+  emit<K extends keyof T>(event: K, data: T[K]): void {
+    this.listeners[event]?.forEach(cb => cb(data));
+  }
+}
+
+const emitter = new TypedEmitter<EventMap>();
+emitter.on("user:created", (data) => console.log(data.name));  // Type-safe
+```
+
+## Type-Safe API Client
+
+```typescript
+type Endpoints = {
+  "/users": { GET: { response: User[] }; POST: { body: NewUser; response: User } };
+};
+
+type ExtractResponse<T> = T extends { response: infer R } ? R : never;
+
+class APIClient<E extends Record<string, Record<string, any>>> {
+  async request<P extends keyof E, M extends keyof E[P]>(path: P, method: M): Promise<ExtractResponse<E[P][M]>> {
+    return {} as any;
+  }
+}
+
+const api = new APIClient<Endpoints>();
+const users = await api.request("/users", "GET");  // Type: User[]
+```
+
+## Builder Pattern
+
+```typescript
+class QueryBuilder<T, Selected extends keyof T = never> {
+  private selection: (keyof T)[] = [];
+
+  select<K extends keyof T>(...keys: K[]): QueryBuilder<T, Selected | K> {
+    this.selection.push(...keys);
+    return this as any;
+  }
+
+  build(): Pick<T, Selected> { return {} as any; }
+}
+
+const result = new QueryBuilder<User>()
+  .select("id", "name")
+  .build();  // Type: Pick<User, "id" | "name">
+```
+
+## Deep Utilities
+
+```typescript
+type DeepPartial<T> = T extends object
+  ? { [P in keyof T]?: DeepPartial<T[P]> }
+  : T;
+
+type DeepReadonly<T> = T extends object
+  ? { readonly [P in keyof T]: DeepReadonly<T[P]> }
+  : T;
+```
+
+## Discriminated Unions
+
+```typescript
+type AsyncState<T> = { status: "loading" } | { status: "success"; data: T } | { status: "error"; error: Error };
+
+function handle<T>(state: AsyncState<T>) {
+  if (state.status === "success") return state.data;  // Type narrowed
+  if (state.status === "error") throw state.error;
+  return null;
+}
+```
+
+## Form Validation Types
+
+```typescript
+type ValidationRule<T> = { validate: (v: T) => boolean; message: string };
+type FormRules<T> = { [K in keyof T]?: ValidationRule<T[K]>[] };
+type FormErrors<T> = { [K in keyof T]?: string[] };
+
+class Validator<T extends Record<string, any>> {
+  constructor(private rules: FormRules<T>) {}
+  validate(data: T): FormErrors<T> | null { return null; }
+}
+```