ocs-stats 1.0.0 → 1.1.0

package/README.md

@@ -59,10 +59,14 @@ OpenCode automatically loads any `.opencode` folder in your project root.
 
 ## Check Your Progress
 
-Use the `stats` command to view your security agent's progress:
+Use the `stats` command to view your agent progress:
 
 ```bash
+# Security agent
 npx ocs-stats stats
+
+# Testing agent
+npx ocs-stats stats testing
 ```
 
 Example output:
@@ -95,6 +99,7 @@ npx ocs-stats update
 | Agent | Description |
 |-------|-------------|
 | `security` | Security expert with XP-based leveling system for auditing and fixing vulnerabilities |
+| `testing` | Testing expert for unit, integration, and E2E tests with Playwright integration |
 
 ### Skills
 
@@ -104,6 +109,7 @@ npx ocs-stats update
 | `memories` | Session memory for tracking work context and pending tasks |
 | `mobile` | Mobile development (React Native, Flutter, Swift) |
 | `security` | Security patterns, auth approach, and anti-patterns |
+| `testing` | Testing patterns (Vitest, Jest, React Testing Library, Playwright) |
 | `webapp` | Web development (React, Vue, Svelte, Angular) |
 
 ## Customization
@@ -143,7 +149,7 @@ The security agent includes an XP-based leveling system that tracks your progres
 | 2 | Apprentice | 150 |
 | 3 | Practitioner | 450 |
 | 4 | Expert | 900 |
-| 5 | Master | 1500 |
+| 5 | Master | 1,500 |
 | 6 | Grandmaster | 3,000 |
 
 ### XP Awards (Fix-Only System)
@@ -164,21 +170,58 @@ Before risky operations (auth changes, DB schema, middleware), the agent:
 2. Confirms user permission
 3. Documents rollback plan
 
+## Testing Agent Features
+
+The testing agent helps you write tests with an XP-based leveling system:
+
+| Level | Title | XP Required | Focus |
+|-------|-------|-------------|-------|
+| 1 | Novice | 0 | Basic unit tests |
+| 2 | Apprentice | 100 | Integration tests |
+| 3 | Practitioner | 300 | E2E tests |
+| 4 | Expert | 600 | Test patterns & mocking |
+| 5 | Master | 1,200 | Full coverage strategies |
+| 6 | Grandmaster | 2,500 | Testing excellence |
+
+### XP Awards
+
+| Action | XP |
+|--------|-----|
+| Write unit test | +10 XP |
+| Write integration test | +15 XP |
+| Write E2E test | +20 XP |
+| Fix broken test | +10 XP |
+| Add test pattern | +30 XP |
+| Complete package test suite | +100 XP |
+
+### Playwright Integration
+
+When you need E2E testing:
+1. The testing agent checks for Playwright MCP
+2. If not configured, prompts you to enable it
+3. Creates `opencode.json` with Playwright MCP config
+4. Installs `@playwright/test` and browser binaries
+
 ## File Structure
 
 ```
 .opencode/
 ├── agents/
-│   └── security.md          # Security audit agent
+│   ├── security.md          # Security audit agent
+│   └── testing.md           # Testing agent
 ├── skills/
 │   ├── commit/SKILL.md      # Commit conventions
 │   ├── memories/SKILL.md    # Session memory (auto-updated)
 │   ├── mobile/SKILL.md      # Mobile patterns (RN, Flutter, Swift)
 │   ├── security/SKILL.md    # Security patterns
+│   ├── testing/SKILL.md     # Testing patterns
 │   └── webapp/SKILL.md      # Web patterns (React, Vue, Svelte, Angular)
-└── security/
-    ├── xp.json              # XP tracking (auto-updated)
-    └── knowledge.md         # Accumulated findings (auto-updated)
+├── security/
+│   ├── xp.json              # XP tracking (auto-updated)
+│   └── knowledge.md         # Accumulated findings (auto-updated)
+└── testing/
+    ├── xp.json              # Testing XP tracking (auto-updated)
+    └── knowledge.md         # Testing patterns & lessons (auto-updated)
 ```
 
 ## For Contributors
@@ -193,8 +236,11 @@ opencode-skills/
 │   └── stats.js
 ├── templates/               # Files copied to user projects
 │   ├── agents/
+│   │   ├── security.md
+│   │   └── testing.md
 │   ├── skills/
-│   └── security/
+│   ├── security/
+│   └── testing/
 ├── README.md
 └── LICENSE
 ```
@@ -226,6 +272,13 @@ rm .opencode/security/xp.json
 rm .opencode/security/knowledge.md
 ```
 
+### Want to reset testing XP?
+
+```bash
+rm .opencode/testing/xp.json
+rm .opencode/testing/knowledge.md
+```
+
 ## Contributing
 
 Feel free to submit issues and pull requests to improve these skills and agents.

package/bin/cli.js

@@ -17,6 +17,7 @@ Usage:
   npx ocs-stats --global     Install globally (~/.opencode)
   npx ocs-stats update       Update skills (removes existing)
   npx ocs-stats stats        Show security agent progress
+  npx ocs-stats stats testing   Show testing agent progress
   npx ocs-stats display-xp <amount> "<reason>"
                                           Display XP gain (used by agent)
 
@@ -28,7 +29,9 @@ Examples:
   npx ocs-stats
   npx ocs-stats update
   npx ocs-stats stats
+  npx ocs-stats stats testing
   npx ocs-stats display-xp 35 "Fixed high issue"
+  npx ocs-stats display-xp 80 "Wrote 8 unit tests [testing]"
 `);
   process.exit(0);
 }
@@ -42,14 +45,17 @@ if (command === 'update') {
 }
 
 if (command === 'stats') {
-  stats();
+  const category = args[1] || 'security';
+  stats(category);
   process.exit(0);
 }
 
 if (command === 'display-xp') {
   const amount = args[1];
-  const reason = args[2];
-  displayXp(amount, reason);
+  const reason = args.slice(2).join(' ') || 'XP earned';
+  const category = reason.includes('[testing]') ? 'testing' : 'security';
+  const cleanReason = reason.replace(/\[testing\]/g, '').trim();
+  displayXp(amount, cleanReason, category);
   process.exit(0);
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ocs-stats",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "OpenCode Skills - One-click installer with gamified XP stats",
   "type": "module",
   "bin": {

package/src/display.js

@@ -44,7 +44,7 @@ function emptyLine() {
   return '║' + ' '.repeat(CONTENT_WIDTH) + '║';
 }
 
-export function showXpGain(amount, reason, data) {
+export function showXpGain(amount, reason, data, category = 'security') {
   const { xp, level, title } = data;
   const nextLevelXp = getNextLevelXp(level);
   
@@ -69,20 +69,21 @@ export function showXpGain(amount, reason, data) {
   console.log('');
 }
 
-export function showStats(data) {
-  const { xp, level, title, issuesFixed, totalAudits, patternsAdded, mistakes } = data;
+export function showStats(data, category = 'security') {
+  const { xp, level, title, issuesFixed, totalAudits, patternsAdded, mistakes, testsWritten, testsFixed, totalTests } = data;
   const nextLevelXp = getNextLevelXp(level);
   
-  const totalFixed = (issuesFixed?.critical || 0) + 
-                     (issuesFixed?.high || 0) + 
-                     (issuesFixed?.medium || 0) + 
-                     (issuesFixed?.low || 0);
+  const categoryTitle = category === 'testing' ? 'TESTING AGENT' : 'SECURITY AGENT';
+  
+  const totalFixed = category === 'security' 
+    ? ((issuesFixed?.critical || 0) + (issuesFixed?.high || 0) + (issuesFixed?.medium || 0) + (issuesFixed?.low || 0))
+    : (testsFixed || 0);
   
   const totalPenalty = mistakes?.totalPenaltyXP || 0;
   
   console.log('');
   console.log(topBorder());
-  console.log(line('        SECURITY AGENT'));
+  console.log(line(`        ${categoryTitle}`));
   console.log(divider());
   console.log(line(`  Level ${level} - ${title}`));
   
@@ -98,10 +99,21 @@ export function showStats(data) {
   
   console.log(emptyLine());
   console.log(line('  Stats:'));
-  console.log(line(`  * Issues Fixed:  ${totalFixed}`));
-  console.log(line(`  * Audits Done:   ${totalAudits || 0}`));
-  console.log(line(`  * Patterns Added: ${patternsAdded || 0}`));
-  console.log(line(`  * XP Penalties:  ${totalPenalty}`));
+  
+  if (category === 'testing') {
+    console.log(line(`  * Tests Written:   ${totalTests || 0}`));
+    console.log(line(`  * Unit Tests:      ${testsWritten?.unit || 0}`));
+    console.log(line(`  * Integration:     ${testsWritten?.integration || 0}`));
+    console.log(line(`  * E2E Tests:       ${testsWritten?.e2e || 0}`));
+    console.log(line(`  * Tests Fixed:     ${testsFixed || 0}`));
+    console.log(line(`  * Patterns Added:  ${patternsAdded || 0}`));
+  } else {
+    console.log(line(`  * Issues Fixed:    ${totalFixed}`));
+    console.log(line(`  * Audits Done:     ${totalAudits || 0}`));
+    console.log(line(`  * Patterns Added:  ${patternsAdded || 0}`));
+  }
+  
+  console.log(line(`  * XP Penalties:    ${totalPenalty}`));
   console.log(bottomBorder());
   console.log('');
 }

package/src/init.js

@@ -30,9 +30,10 @@ export async function init({ isGlobal = false } = {}) {
 
   console.log('Installed successfully!\n');
   console.log('What was installed:');
-  console.log('  * Agents: security');
-  console.log('  * Skills: commit, memories, mobile, security, webapp');
-  console.log('  * Security: XP tracking, knowledge base\n');
+  console.log('  * Agents: security, testing');
+  console.log('  * Skills: commit, memories, mobile, security, testing, webapp');
+  console.log('  * Security: XP tracking, knowledge base');
+  console.log('  * Testing: XP tracking, knowledge base\n');
   
   if (!isGlobal) {
     console.log('Next steps:');
@@ -64,9 +65,10 @@ export async function update({ isGlobal = false } = {}) {
 
   console.log('Updated successfully!\n');
   console.log('What was installed:');
-  console.log('  * Agents: security');
-  console.log('  * Skills: commit, memories, mobile, security, webapp');
-  console.log('  * Security: XP tracking, knowledge base\n');
+  console.log('  * Agents: security, testing');
+  console.log('  * Skills: commit, memories, mobile, security, testing, webapp');
+  console.log('  * Security: XP tracking, knowledge base');
+  console.log('  * Testing: XP tracking, knowledge base\n');
 }
 
 function copyDir(src, dest) {

package/src/stats.js

@@ -2,8 +2,8 @@ import fs from 'fs';
 import path from 'path';
 import { showStats, showXpGain } from './display.js';
 
-function findXpJson() {
-  const cwdPath = path.join(process.cwd(), '.opencode', 'security', 'xp.json');
+function findXpJson(category = 'security') {
+  const cwdPath = path.join(process.cwd(), '.opencode', category, 'xp.json');
   
   if (fs.existsSync(cwdPath)) {
     return cwdPath;
@@ -12,12 +12,12 @@ function findXpJson() {
   return null;
 }
 
-export function stats() {
-  const xpPath = findXpJson();
+export function stats(category = 'security') {
+  const xpPath = findXpJson(category);
   
   if (!xpPath) {
     console.log('');
-    console.log('  No .opencode/security/xp.json found in this project.');
+    console.log(`  No .opencode/${category}/xp.json found in this project.`);
     console.log('');
     console.log('  Make sure you\'re in a project with opencode-skills installed.');
     console.log('  Run: npx create-opencode-skills');
@@ -26,11 +26,11 @@ export function stats() {
   }
   
   const data = JSON.parse(fs.readFileSync(xpPath, 'utf-8'));
-  showStats(data);
+  showStats(data, category);
 }
 
-export function displayXp(amount, reason) {
-  const xpPath = findXpJson();
+export function displayXp(amount, reason, category = 'security') {
+  const xpPath = findXpJson(category);
   
   if (!xpPath) {
     console.log('No xp.json found');
@@ -44,5 +44,5 @@ export function displayXp(amount, reason) {
   
   const data = JSON.parse(fs.readFileSync(xpPath, 'utf-8'));
   const reasonText = reason || 'XP earned';
-  showXpGain(parseInt(amount, 10), reasonText, data);
+  showXpGain(parseInt(amount, 10), reasonText, data, category);
 }

package/templates/agents/testing.md

@@ -0,0 +1,303 @@
+---
+description: Testing expert agent for writing unit, integration, and E2E tests
+mode: subagent
+tools:
+  write: true
+  edit: true
+  bash: true
+---
+
+You are a testing expert agent specialized in writing, fixing, and improving tests. You have a leveling system that tracks your experience and growth.
+
+## Current Status
+
+Your current status is stored in `.opencode/testing/xp.json`:
+- Level: {READ from .opencode/testing/xp.json}
+- XP: {READ from .opencode/testing/xp.json}
+- Title: {READ from .opencode/testing/xp.json}
+
+## Level System
+
+### XP Awards
+
+| Action | XP |
+|--------|-----|
+| Write passing unit test | +10 XP |
+| Write passing integration test | +15 XP |
+| Write passing E2E test | +20 XP |
+| Fix broken/flaky test | +10 XP |
+| Add new test pattern to skill | +30 XP |
+| Complete test suite (single file) | +20 XP |
+| Complete test suite (package) | +100 XP |
+
+### Deduplication
+
+- Same pattern in multiple tests: **80% XP reduction** (only 20% XP awarded)
+- Track seen patterns in `.opencode/testing/xp.json` under `seenPatterns`
+
+### Penalty System
+
+| Mistake | XP Penalty |
+|---------|------------|
+| Introduce flaky test | **-25 XP** |
+| Repeat a previous mistake | **-15 XP** |
+
+### Mistake Tracking
+
+All mistakes are recorded in:
+- `xp.json` → `mistakes` object and `mistakeHistory` array
+- `knowledge.md` → `## Lessons Learned` section
+
+**Before writing tests, ALWAYS check `Lessons Learned` to avoid repeating mistakes.**
+
+### Level Thresholds
+
+| Level | Title | XP Required | Focus |
+|-------|-------|-------------|-------|
+| 1 | Novice | 0 | Basic unit tests |
+| 2 | Apprentice | 100 | Integration tests |
+| 3 | Practitioner | 300 | E2E tests |
+| 4 | Expert | 600 | Test patterns & mocking |
+| 5 | Master | 1200 | Full coverage strategies |
+| 6 | Grandmaster | 2500 | Testing excellence |
+
+## Level-Specific Focus
+
+### Level 1 - Novice (Current)
+Focus on:
+- Basic unit tests with AAA pattern
+- Simple function testing
+- Common matchers
+
+### Level 2 - Apprentice (100 XP)
+Adds:
+- Integration tests
+- API testing with mocked context
+- Database testing patterns
+
+### Level 3 - Practitioner (300 XP)
+Adds:
+- E2E testing with Playwright
+- Browser automation
+- User flow testing
+
+### Level 4 - Expert (600 XP)
+Adds:
+- Advanced mocking patterns
+- Test utilities and factories
+- Test organization
+
+### Level 5 - Master (1200 XP)
+Adds:
+- Coverage strategies
+- Flaky test prevention
+- Performance testing
+
+### Level 6 - Grandmaster (2500 XP)
+Adds:
+- Testing architecture
+- CI/CD integration
+- Custom test frameworks
+
+## Available Resources
+
+You have access to:
+- `.opencode/skills/testing/SKILL.md` - Core testing patterns
+- `.opencode/testing/xp.json` - Your XP and level
+- `.opencode/testing/knowledge.md` - Accumulated testing knowledge
+- `opencode.json` - MCP configuration (created on-demand when needed)
+
+## Playwright Integration
+
+### MCP Setup Flow
+
+When user asks for E2E tests or browser automation:
+
+1. **Check if opencode.json exists:**
+   - Try to read `opencode.json` from project root
+   
+2. **If opencode.json does NOT exist, create it with Playwright MCP:**
+   ```json
+   {
+     "$schema": "https://opencode.ai/config.json",
+     "mcp": {
+       "playwright": {
+         "type": "local",
+         "command": ["npx", "-y", "@playwright/mcp-server"],
+         "enabled": true
+       }
+     }
+   }
+   ```
+   
+3. **If opencode.json exists but NO Playwright MCP, add it:**
+   - Read existing opencode.json
+   - Add playwright to mcp section
+   - Write back the updated config
+
+4. **If already configured, skip setup**
+
+5. **Prompt user:**
+   ```
+   Enable Playwright for E2E testing? This will:
+   - Create opencode.json with Playwright MCP (for AI-driven browser automation)
+   - Install @playwright/test in your project (for CLI tests)
+   - Run: npx playwright install (browser binaries)
+   
+   This enables both AI-assisted testing and direct Playwright usage.
+   ```
+
+6. **If user agrees, install dependencies:**
+   ```bash
+   npm install -D @playwright/test
+   npx playwright install
+   ```
+   
+7. **Restart OpenCode** to load the MCP server
+
+8. **If already available, use directly:**
+   - MCP provides browser automation tools
+   - Also use `@playwright/test` for CLI test runs
+
+## Workflow
+
+1. **Read your current status**: Read `.opencode/testing/xp.json` to know your level
+2. **Read knowledge base**: Check `.opencode/testing/knowledge.md` for known patterns AND lessons learned
+3. **Detect frameworks**: Check package.json for test framework (Vitest, Jest, Playwright)
+4. **Identify code to test**: Look at unimplemented test files or code needing coverage
+5. **Write tests**: Apply patterns from `.opencode/skills/testing/SKILL.md`
+6. **Run tests**: Verify tests pass before claiming XP
+7. **Check Playwright need**: If E2E needed, follow MCP setup flow above
+8. **Award XP**: Only after tests pass successfully
+9. **Update knowledge**: Add any new patterns discovered
+10. **If mistake made**: Record in `mistakeHistory` (xp.json) and `Lessons Learned` (knowledge.md)
+
+## Test Execution
+
+### Run Tests
+
+```bash
+# Unit/Integration tests
+npm test
+# or
+npm run test:watch
+
+# Playwright E2E
+npx playwright test
+
+# Specific file
+npx playwright test tests/login.e2e.ts
+
+# With UI
+npx playwright test --ui
+```
+
+### Debug Failed Tests
+
+```bash
+# Show console logs
+npx playwright test --reporter=line
+
+# Debug mode
+npx playwright test --debug
+```
+
+## Output Format
+
+### Test Writing Phase (No XP Yet)
+
+```
+## Test Plan
+
+### Files to Create/Modify
+
+1. `src/utils/__tests__/calculate.test.ts`
+   - Test: calculateTotal with tax
+   - Test: calculateTotal with discounts
+   - Test: calculateTotal edge cases
+
+2. `src/utils/__tests__/format.test.ts`
+   - Test: formatCurrency
+   - Test: formatDate
+
+### Estimated Tests
+- Unit tests: 8
+- Expected XP: 80 XP (after passing)
+```
+
+### After Tests Pass
+
+```
+## Test Results
+
+### Tests Created
+- `src/utils/__tests__/calculate.test.ts` - 5 tests
+- `src/utils/__tests__/format.test.ts` - 3 tests
+
+### XP Earned
+- Unit tests: 8 × 10 XP = 80 XP
+- Total: 80 XP
+
+### Level Progress
+- Current: Level 1 - Novice
+- XP: 80 / 100
+- Next: Level 2 (Apprentice) at 100 XP
+```
+
+Display XP gain:
+```bash
+npx ocs-stats display-xp 80 "Wrote 8 unit tests [testing]"
+```
+
+## Mistake Recording
+
+If you introduce a flaky test or make a mistake:
+
+### 1. Record in xp.json
+
+Update the `mistakes` object and add to `mistakeHistory`:
+
+```json
+{
+  "mistakes": {
+    "flakyTests": 1,
+    "repeatedMistakes": 0,
+    "totalPenaltyXP": -25
+  },
+  "mistakeHistory": [
+    {
+      "date": "2025-02-25",
+      "type": "flaky_test",
+      "description": "Test depends on random value without seed",
+      "file": "src/utils/random.test.ts:15",
+      "xpPenalty": -25,
+      "lesson": "Always seed random values or use deterministic test data"
+    }
+  ]
+}
+```
+
+### 2. Record in knowledge.md
+
+Add to `## Lessons Learned` table:
+
+| Date | Mistake | Severity | Lesson Learned | Fixed In |
+|------|---------|----------|----------------|----------|
+| 2025-02-25 | Test depends on random value | High | Always seed random values or use deterministic test data | src/utils/random.test.ts:15 |
+
+### 3. Before Writing Similar Tests
+
+Always check `mistakeHistory` and `Lessons Learned` to ensure you're not repeating a pattern that caused issues before.
+
+## Important Rules
+
+1. ALWAYS read your current level from `.opencode/testing/xp.json` at the start
+2. NEVER award XP for failing tests - only for passing ones
+3. ALWAYS check `.opencode/testing/knowledge.md` for duplicates before claiming XP
+4. ALWAYS check `Lessons Learned` before writing tests to avoid repeating mistakes
+5. ALWAYS run tests to verify they pass before claiming XP
+6. For E2E tests, follow the Playwright MCP setup flow
+7. NEVER write flaky tests (random values, timing-dependent, external APIs)
+8. ALWAYS use deterministic test data
+9. Record mistakes in both `xp.json` and `knowledge.md` if you introduce a flaky test
+10. Repeated mistakes incur additional -15 XP penalty

package/templates/skills/testing/SKILL.md

@@ -0,0 +1,499 @@
+---
+name: testing
+description: Testing patterns, frameworks, and best practices for unit, integration, and E2E tests
+---
+
+# Testing Patterns
+
+## Framework Detection
+
+| Indicator | Framework |
+|-----------|-----------|
+| `vitest` in package.json | Vitest |
+| `jest` in package.json | Jest |
+| `@testing-library/react` | React Testing Library |
+| `@testing-library/vue` | Vue Testing Library |
+| `@playwright/test` | Playwright |
+| `cypress` | Cypress |
+
+---
+
+## 1. Unit Testing (Vitest/Jest)
+
+### AAA Pattern
+
+```typescript
+describe('calculateTotal', () => {
+  it('should calculate total with tax', () => {
+    // Arrange
+    const items = [{ price: 100 }, { price: 50 }];
+    const taxRate = 0. Act
+    const1;
+
+    // result = calculateTotal(items, taxRate);
+
+    // Assert
+    expect(result).toBe(165);
+  });
+});
+```
+
+### Test File Naming
+
+| Type | Pattern | Example |
+|------|---------|---------|
+| Unit | `*.test.ts` or `*.spec.ts` | `utils.test.ts` |
+| Component | `*.test.tsx` or `*.spec.tsx` | `Button.test.tsx` |
+| Integration | `*.integration.test.ts` | `api.integration.test.ts` |
+| E2E | `*.e2e.test.ts` | `login.e2e.test.ts` |
+
+### Common Matchers
+
+```typescript
+// Equality
+expect(value).toBe(42);
+expect(value).toEqual({ name: 'test' });
+
+// Truthiness
+expect(value).toBeTruthy();
+expect(value).toBeFalsy();
+expect(value).toBeNull();
+expect(value).toBeUndefined();
+
+// Numbers
+expect(value).toBeGreaterThan(10);
+expect(value).toBeLessThanOrEqual(100);
+expect(value).toBeCloseTo(3.14, 2);
+
+// Strings
+expect(text).toMatch(/regex/);
+expect(text).toContain('substring');
+
+// Arrays
+expect(array).toContain(item);
+expect(array).toHaveLength(3);
+
+// Objects
+expect(obj).toHaveProperty('key');
+expect(obj).toMatchObject({ key: 'value' });
+
+// Exceptions
+expect(() => throwError()).toThrow();
+```
+
+---
+
+## 2. tRPC/API Testing
+
+### Testing Routers with Context
+
+```typescript
+import { appRouter } from '../src/routers/_app';
+import { createTRPCContext } from '../src/server/trpc';
+
+describe('userRouter', () => {
+  const createMockContext = (overrides = {}) => {
+    return createTRPCContext({
+      req: {} as Request,
+      res: {} as Response,
+      ...overrides,
+    });
+  };
+
+  it('should get user profile', async () => {
+    const ctx = createMockContext();
+    const caller = appRouter.createCaller(ctx);
+
+    const result = await caller.user.getProfile({ userId: '123' });
+
+    expect(result).toHaveProperty('id');
+  });
+
+  it('should throw on invalid input', async () => {
+    const ctx = createMockContext();
+    const caller = appRouter.createCaller(ctx);
+
+    await expect(
+      caller.user.getProfile({ userId: '' })
+    ).rejects.toThrow();
+  });
+});
+```
+
+### Testing Input Validation
+
+```typescript
+it('should reject invalid email', async () => {
+  const ctx = createMockContext();
+  const caller = appRouter.createCaller(ctx);
+
+  await expect(
+    caller.user.create({
+      email: 'not-an-email',
+      username: 'test'
+    })
+  ).rejects.toThrow('Invalid email');
+});
+```
+
+### Testing Error Handling
+
+```typescript
+it('should throw NOT_FOUND for non-existent user', async () => {
+  const ctx = createMockContext();
+  const caller = appRouter.createCaller(ctx);
+
+  await expect(
+    caller.user.getProfile({ userId: 'non-existent' })
+  ).rejects.toMatchObject({
+    code: 'NOT_FOUND',
+    message: expect.stringContaining('not found')
+  });
+});
+```
+
+---
+
+## 3. React Component Testing (Testing Library)
+
+### Query Priority
+
+Use queries in this order (most to least preferred):
+
+1. **`getByRole`** - Most accessible
+   ```typescript
+   expect(screen.getByRole('button', { name: /submit/i })).toBeDisabled();
+   expect(screen.getByRole('textbox', { name: /email/i })).toHaveValue('test@test.com');
+   ```
+
+2. **`getByLabelText`** - For form fields
+   ```typescript
+   expect(screen.getByLabelText(/email/i)).toHaveValue('test@test.com');
+   ```
+
+3. **`getByPlaceholderText`** - If no label
+   ```typescript
+   screen.getByPlaceholderText('Enter your email');
+   ```
+
+4. **`getByText`** - For non-interactive elements
+   ```typescript
+   expect(screen.getByText(/welcome back/i)).toBeInTheDocument();
+   ```
+
+5. **`getByTestId`** - Last resort
+   ```typescript
+   <div data-testid="custom-element" />
+   ```
+
+### User Events (Preferred over fireEvent)
+
+```typescript
+import userEvent from '@testing-library/user-event';
+
+it('should submit form', async () => {
+  const user = userEvent.setup();
+  
+  await user.type(screen.getByLabelText(/email/i), 'test@test.com');
+  await user.click(screen.getByRole('button', { name: /submit/i }));
+  
+  expect(screen.getByText(/submitted/i)).toBeInTheDocument();
+});
+```
+
+### Testing Forms
+
+```typescript
+it('should show validation errors', async () => {
+  const user = userEvent.setup();
+  
+  const submitButton = screen.getByRole('button', { name: /submit/i });
+  await user.click(submitButton);
+  
+  expect(screen.getByText(/email is required/i)).toBeInTheDocument();
+  expect(submitButton).toBeDisabled();
+});
+
+it('should submit with valid data', async () => {
+  const user = userEvent.setup();
+  const onSubmit = vi.fn();
+  
+  await user.type(screen.getByLabelText(/email/i), 'test@test.com');
+  await user.click(screen.getByRole('button', { name: /submit/i }));
+  
+  expect(onSubmit).toHaveBeenCalledWith({
+    email: 'test@test.com'
+  });
+});
+```
+
+### Testing Async Components
+
+```typescript
+it('should show loading then data', async () => {
+  render(<UserProfile userId="123" />);
+  
+  expect(screen.getByText(/loading/i)).toBeInTheDocument();
+  
+  await waitFor(() => {
+    expect(screen.getByText(/john doe/i)).toBeInTheDocument();
+  });
+});
+
+it('should handle error state', async () => {
+  server.use(...mockErrorResponse);
+  
+  render(<UserProfile userId="123" />);
+  
+  await waitFor(() => {
+    expect(screen.getByText(/error loading user/i)).toBeInTheDocument();
+  });
+});
+```
+
+---
+
+## 4. Playwright E2E Testing
+
+### Setup
+
+```typescript
+import { test, expect } from '@playwright/test';
+
+test.describe('Login Flow', () => {
+  test.beforeEach(async ({ page }) => {
+    await page.goto('/login');
+  });
+
+  test('should login successfully', async ({ page }) => {
+    await page.fill('[name="email"]', 'test@example.com');
+    await page.fill('[name="password"]', 'password123');
+    await page.click('button[type="submit"]');
+    
+    await expect(page).toHaveURL('/dashboard');
+    await expect(page.locator('[data-testid="welcome"]')).toContainText('Welcome');
+  });
+
+  test('should show error on invalid credentials', async ({ page }) => {
+    await page.fill('[name="email"]', 'wrong@example.com');
+    await page.fill('[name="password"]', 'wrongpass');
+    await page.click('button[type="submit"]');
+    
+    await expect(page.locator('[role="alert"]')).toContainText('Invalid credentials');
+  });
+});
+```
+
+### Playwright MCP Integration
+
+When user needs E2E testing assistance:
+
+1. **Check if Playwright MCP is configured:**
+   - Read `opencode.json` and check for `mcp.playwright` configuration
+
+2. **If not configured, prompt user:**
+   ```
+   Enable Playwright for E2E testing? This will:
+   - Add Playwright MCP to opencode.json (for AI-driven testing)
+   - Install @playwright/test as dev dependency
+   - Install browser binaries
+   ```
+
+3. **If user agrees, setup:**
+   ```bash
+   # Add to opencode.json
+   npm install -D @playwright/test
+   npx playwright install
+   ```
+
+4. **If already available, use directly**
+
+### Best Practices
+
+```typescript
+// ✅ GOOD - Use locators
+const submitButton = page.getByRole('button', { name: /submit/i });
+await submitButton.click();
+
+// ✅ GOOD - Wait for assertions
+await expect(page.locator('.data-loaded')).toBeVisible();
+
+// ✅ GOOD - Use test hooks
+test.beforeEach(async ({ page }) => {
+  await page.goto('/reset-state');
+});
+
+// ❌ BAD - Race conditions
+await page.click('button');
+await expect(page.locator('.success')).toBeVisible();
+
+// ✅ GOOD - Proper waiting
+await page.click('button');
+await expect(page.locator('.success')).toBeVisible({ timeout: 10000 });
+```
+
+---
+
+## 5. Mocking Patterns
+
+### Mocking tRPC Procedures
+
+```typescript
+import { vi } from 'vitest';
+
+vi.mock('../trpc', () => ({
+  createTRPCContext: vi.fn(() => ({
+    prisma: mockPrisma,
+    user: null,
+  })),
+}));
+```
+
+### Mocking Prisma
+
+```typescript
+const mockPrisma = {
+  user: {
+    findUnique: vi.fn(),
+    create: vi.fn(),
+    update: vi.fn(),
+    delete: vi.fn(),
+  },
+  // ... other models
+};
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  mockPrisma.user.findUnique.mockResolvedValue(null);
+});
+```
+
+### Mocking External APIs
+
+```typescript
+import { http, HttpResponse } from 'msw';
+import { setupServer } from 'msw/node';
+
+const server = setupServer(
+  http.get('/api/users', () => {
+    return HttpResponse.json([
+      { id: '1', name: 'John' }
+    ]);
+  })
+);
+
+beforeAll(() => server.listen());
+afterEach(() => server.resetHandlers());
+afterAll(() => server.close());
+```
+
+---
+
+## 6. Anti-Patterns
+
+### Testing Implementation Details
+
+```typescript
+// ❌ BAD - Testing internal state
+const instance = new MyClass();
+instance['privateMethod']();
+
+// ✅ GOOD - Testing behavior
+expect(instance.calculate(2, 3)).toBe(5);
+```
+
+### Using fireEvent (Prefer userEvent)
+
+```typescript
+// ❌ BAD
+fireEvent.change(input, { target: { value: 'test' } });
+
+// ✅ GOOD
+await userEvent.type(input, 'test');
+```
+
+### Index as Key
+
+```typescript
+// ❌ BAD
+items.map((item, index) => <div key={index}>...</div>);
+
+// ✅ GOOD
+items.map(item => <div key={item.id}>...</div>);
+```
+
+### Missing Cleanup
+
+```typescript
+// ❌ BAD
+it('test', () => {
+  const instance = new Class();
+});
+
+// ✅ GOOD
+let instance;
+beforeEach(() => instance = new Class());
+afterEach(() => instance = null);
+```
+
+### Hardcoded Time/Dates
+
+```typescript
+// ❌ BAD
+expect(new Date().toISOString()).toBe('2024-01-01T00:00:00.000Z');
+
+// ✅ GOOD - Use fake timers
+vi.useFakeTimers();
+vi.setSystemTime(new Date('2024-01-01'));
+```
+
+---
+
+## 7. Coverage Guidelines
+
+### Prioritize Testing
+
+| Priority | What to Test |
+|----------|-------------|
+| **High** | Business logic, calculations, transformations |
+| **High** | Edge cases, boundary conditions |
+| **High** | Error handling, exceptions |
+| **Medium** | Component rendering, user interactions |
+| **Medium** | API endpoints, integrations |
+| **Low** | Simple getters/setters |
+| **Low** | Boilerplate, types only |
+
+### What NOT to Test
+
+- TypeScript types (already enforced by compiler)
+- Simple utility functions that just pass through
+- Third-party library internals
+- Implementation details
+
+---
+
+## 8. Fix-First Testing Process
+
+### Process
+
+1. Identify code that needs tests
+2. Write tests (NO XP awarded yet)
+3. Run tests to verify they pass
+4. Document any patterns discovered
+5. Award XP for passing tests
+6. Update knowledge.md
+
+### XP Awards
+
+- **Unit test:** +10 XP
+- **Integration test:** +15 XP  
+- **E2E test:** +20 XP
+- **Fix broken test:** +10 XP
+- **Add pattern to skill:** +30 XP
+
+### Rules
+
+- XP only awarded for PASSING tests
+- Track seen patterns to avoid duplicate XP
+- Record mistakes in knowledge.md
+- Always run tests before claiming XP

package/templates/testing/knowledge.md

@@ -0,0 +1,77 @@
+# Testing Agent Knowledge Base
+
+This file stores accumulated testing patterns, lessons learned, and test knowledge.
+
+## Version History
+
+- v1.0 (Level 1 - Novice): Initial knowledge base
+- v1.1: Added Lessons Learned section for mistake tracking
+
+---
+
+## Lessons Learned (Mistakes to Avoid)
+
+This section tracks mistakes the agent has made to prevent repeating them.
+
+| Date | Mistake | Severity | Lesson Learned | Fixed In |
+|------|---------|----------|----------------|----------|
+| _None yet_ | - | - | - | - |
+
+### How to Use This Section
+
+When the agent writes a flaky test or makes a testing mistake:
+1. Record the mistake with date, description, and severity
+2. Document the lesson learned (what should have been done)
+3. Reference the file where it was fixed
+4. **Always check this section before writing similar tests**
+
+---
+
+## Known Test Patterns
+
+### Unit Testing Patterns
+
+| Pattern | Description | Status | Example |
+|---------|-------------|--------|---------|
+| _None documented yet_ | - | - | - |
+
+### Integration Testing Patterns
+
+| Pattern | Description | Status | Example |
+|---------|-------------|--------|---------|
+| _None documented yet_ | - | - | - |
+
+### E2E Testing Patterns
+
+| Pattern | Description | Status | Example |
+|---------|-------------|--------|---------|
+| _None documented yet_ | - | - | - |
+
+---
+
+## Fixes Applied
+
+_No fixes documented yet._
+
+---
+
+## Test Suites Completed
+
+_No test suites completed yet._
+
+---
+
+## Anti-Patterns to Avoid
+
+| Anti-Pattern | Why Bad | Correct Approach |
+|--------------|---------|------------------|
+| _None documented yet_ | - | - |
+
+---
+
+## Notes
+
+- Level 1: Focus on basic unit test patterns
+- Higher levels unlock integration and E2E testing
+- XP awarded for writing tests AND fixing broken ones
+- Mistakes tracked to prevent repetition

package/templates/testing/xp.json

@@ -0,0 +1,60 @@
+{
+  "xp": 0,
+  "level": 1,
+  "title": "Novice",
+  "totalTests": 0,
+  "testsWritten": {
+    "unit": 0,
+    "integration": 0,
+    "e2e": 0
+  },
+  "testsFixed": 0,
+  "patternsAdded": 0,
+  "completedSuites": [],
+  "seenPatterns": [],
+  "mistakes": {
+    "flakyTests": 0,
+    "repeatedMistakes": 0,
+    "totalPenaltyXP": 0
+  },
+  "mistakeHistory": [],
+  "levelHistory": [
+    {
+      "level": 1,
+      "title": "Novice",
+      "xpRequired": 0,
+      "unlockedAt": null
+    }
+  ],
+  "xpTable": {
+    "tests": {
+      "unit": 10,
+      "integration": 15,
+      "e2e": 20
+    },
+    "fixes": {
+      "brokenTest": 10,
+      "flakyTest": 15
+    },
+    "knowledge": {
+      "addPattern": 30,
+      "documentPattern": 20
+    },
+    "completion": {
+      "singleFile": 20,
+      "package": 100
+    },
+    "penalty": {
+      "introduceFlaky": -25,
+      "repeatMistake": -15
+    }
+  },
+  "levelThresholds": [
+    { "level": 1, "title": "Novice", "xpRequired": 0, "focus": "Basic unit tests" },
+    { "level": 2, "title": "Apprentice", "xpRequired": 100, "focus": "Integration tests" },
+    { "level": 3, "title": "Practitioner", "xpRequired": 300, "focus": "E2E tests" },
+    { "level": 4, "title": "Expert", "xpRequired": 600, "focus": "Test patterns & mocking" },
+    { "level": 5, "title": "Master", "xpRequired": 1200, "focus": "Full coverage strategies" },
+    { "level": 6, "title": "Grandmaster", "xpRequired": 2500, "focus": "Testing excellence" }
+  ]
+}