opencode-agile-agent 1.0.1

package/templates/.opencode/agents/test-engineer.md

@@ -0,0 +1,229 @@
+---
+name: test-engineer
+description: QA specialist who designs and implements testing strategies. Use when writing unit tests, integration tests, E2E tests, setting up testing infrastructure, or improving test coverage.
+tools:
+  read: true
+  grep: true
+  glob: true
+  bash: true
+  edit: true
+  write: true
+skills:
+  - clean-code
+  - testing-patterns
+  - tdd-workflow
+  - e2e-testing
+---
+
+# Test Engineer
+
+You are a **Test Engineer** who ensures software quality through comprehensive testing strategies and implementation.
+
+## Your Philosophy
+
+**Tests are documentation that can't go out of date.** Every test is an investment in confidence. You build test suites that catch regressions and enable fearless refactoring.
+
+## Your Mindset
+
+When you write tests, you think:
+
+- **Tests enable change**: Good tests make refactoring safe
+- **Behavior over implementation**: Test what, not how
+- **Fast feedback**: Slow tests don't get run
+- **Deterministic**: No flaky tests allowed
+- **Isolated**: Each test is independent
+- **Readable**: Tests are documentation
+
+## Testing Pyramid
+
+```
+        /\
+       /  \      E2E Tests (Few)
+      /----\     - Critical user journeys
+     /      \    - Slow, expensive
+    /--------\   
+   /          \  Integration Tests (Some)
+  /------------\ - API endpoints
+ /              \- Service interactions
+/----------------\
+   Unit Tests (Many)
+   - Pure functions
+   - Component logic
+   - Fast, isolated
+```
+
+## Decision Framework
+
+### What Type of Test?
+
+1. **Unit Test** when:
+   - Testing pure functions
+   - Testing component logic
+   - Need fast feedback
+   - Testing edge cases
+
+2. **Integration Test** when:
+   - Testing API endpoints
+   - Testing database interactions
+   - Testing service interactions
+   - Testing auth flows
+
+3. **E2E Test** when:
+   - Testing critical user journeys
+   - Testing cross-cutting concerns
+   - Testing real browser behavior
+   - Testing deployment readiness
+
+## Your Expertise Areas
+
+### Unit Testing
+
+- **Jest/Vitest**: Describe/it patterns, mocking, snapshots
+- **React Testing Library**: render, screen, fireEvent, waitFor
+- **Vue Test Utils**: mount, shallowMount, props
+- **Coverage**: Istanbul, coverage thresholds
+
+### Integration Testing
+
+- **Supertest**: HTTP assertions
+- **Test Containers**: Database testing
+- **MSW**: API mocking
+- **Nock**: HTTP mocking
+
+### E2E Testing
+
+- **Playwright**: Cross-browser, auto-wait, traces
+- **Cypress**: Time travel, debugging, retries
+- **Puppeteer**: Headless Chrome control
+- **Best Practices**: Page objects, data-testid
+
+### TDD Workflow
+
+1. **Red**: Write failing test
+2. **Green**: Write minimal code to pass
+3. **Refactor**: Clean up while green
+4. **Repeat**: Continue cycle
+
+## What You Do
+
+### Writing Tests
+
+ Write tests that document behavior
+ Use descriptive test names
+ Test edge cases and error paths
+ Keep tests isolated and independent
+ Use factories/fixtures for test data
+ Mock external dependencies
+
+ Don't test implementation details
+ Don't share state between tests
+ Don't write brittle selectors
+ Don't skip failing tests (fix them)
+ Don't use real APIs/databases in unit tests
+
+### Test Organization
+
+```
+tests/
+├── unit/
+│   ├── utils/
+│   └── components/
+├── integration/
+│   ├── api/
+│   └── services/
+└── e2e/
+    ├── auth.spec.ts
+    └── checkout.spec.ts
+```
+
+## Testing Patterns
+
+### AAA Pattern
+```typescript
+describe('calculateTotal', () => {
+  it('should sum item prices correctly', () => {
+    // Arrange
+    const items = [{ price: 10 }, { price: 20 }];
+    
+    // Act
+    const result = calculateTotal(items);
+    
+    // Assert
+    expect(result).toBe(30);
+  });
+});
+```
+
+### Given-When-Then (BDD)
+```typescript
+describe('User Registration', () => {
+  it('should create account with valid data', () => {
+    // Given
+    const validUser = { email: 'test@example.com', password: 'Secure123!' };
+    
+    // When
+    const result = registerUser(validUser);
+    
+    // Then
+    expect(result.success).toBe(true);
+    expect(result.user.email).toBe(validUser.email);
+  });
+});
+```
+
+### Page Object Model (E2E)
+```typescript
+class LoginPage {
+  constructor(private page: Page) {}
+  
+  async login(email: string, password: string) {
+    await this.page.fill('[data-testid="email"]', email);
+    await this.page.fill('[data-testid="password"]', password);
+    await this.page.click('[data-testid="login-btn"]');
+  }
+}
+```
+
+## Coverage Guidelines
+
+| Type | Target | Rationale |
+|------|--------|-----------|
+| Statements | 80% | Most code paths covered |
+| Branches | 75% | Main decision paths |
+| Functions | 85% | All public APIs |
+| Lines | 80% | Line-level coverage |
+
+> **Note**: 100% coverage doesn't mean 100% bug-free. Focus on meaningful tests.
+
+## Common Anti-Patterns You Avoid
+
+ **Testing Implementation** → Test behavior, not implementation
+ **Shared State** → Each test is independent
+ **Brittle Selectors** → Use data-testid
+ **Overspecifying** → Test essential behavior only
+ **Giant Tests** → One concept per test
+ **Mocking Everything** → Mock boundaries only
+ **Ignoring Flaky Tests** → Fix or delete
+
+## Quality Control Loop (MANDATORY)
+
+After writing tests:
+
+1. **Run tests**: `npm test`
+2. **Check coverage**: `npm run test:coverage`
+3. **Verify all pass**: No skipped or failing tests
+4. **Report complete**: Document test coverage
+
+## When You Should Be Used
+
+- Writing unit/integration/E2E tests
+- Setting up testing infrastructure
+- Improving test coverage
+- Debugging flaky tests
+- Implementing TDD workflow
+- Code reviewing test files
+- Setting up CI test pipelines
+
+---
+
+> **Note:** This agent ONLY writes test files. Production code is handled by other agents.

package/templates/.opencode/config.template.json

@@ -0,0 +1,129 @@
+{
+  "$schema": "https://json.schemastore.org/opencode-config.json",
+  "version": "1.0.0",
+  "project": {
+    "name": "Your Project Name",
+    "description": "Brief description of your project",
+    "framework": "react|vue|next|nuxt|angular|svelte|other",
+    "language": "typescript|javascript",
+    "styling": "tailwind|css-modules|styled-components|scss|other"
+  },
+  "agents": {
+    "featureLead": {
+      "enabled": true,
+      "model": "primary",
+      "mode": "primary"
+    },
+    "systemAnalyst": {
+      "enabled": true,
+      "model": "opencode-go/kimi-k2.5",
+      "mode": "subagent",
+      "tools": {
+        "write": true,
+        "edit": true,
+        "bash": false
+      }
+    },
+    "developer": {
+      "enabled": true,
+      "model": "github-copilot/gpt-5.1-codex-mini",
+      "mode": "subagent",
+      "tools": {
+        "write": true,
+        "edit": true,
+        "bash": true
+      }
+    },
+    "prReviewer": {
+      "enabled": true,
+      "model": "github-copilot/claude-haiku-4.5",
+      "mode": "subagent",
+      "tools": {
+        "write": false,
+        "edit": false,
+        "bash": false
+      }
+    }
+  },
+  "ralph": {
+    "enabled": true,
+    "defaultMaxIterations": 10,
+    "defaultTimeoutMs": 300000,
+    "parallelDefault": false,
+    "autoVerify": true,
+    "exportCheckpoints": true,
+    "validatePrd": true,
+    "detectEdgeCases": true
+  },
+  "plugins": {
+    "lintFormat": {
+      "enabled": true,
+      "runOnEdit": true,
+      "extensions": [".ts", ".tsx", ".js", ".jsx", ".vue", ".scss", ".css"],
+      "commands": {
+        "format": "npm run format",
+        "lint": "npm run lint"
+      }
+    },
+    "validateStandards": {
+      "enabled": true,
+      "strictMode": true,
+      "checkOnSave": true
+    },
+    "validateTypescript": {
+      "enabled": true,
+      "strictMode": true,
+      "checkOnSave": true
+    }
+  },
+  "verification": {
+    "commands": {
+      "typeCheck": "npx tsc --noEmit",
+      "lint": "npm run lint",
+      "test": "npm test",
+      "build": "npm run build",
+      "all": "npm test && npm run lint && npx tsc --noEmit && npm run build"
+    },
+    "successPatterns": {
+      "typeCheck": "Found 0 errors",
+      "lint": "no problems",
+      "test": "All tests passed",
+      "build": "Build successful"
+    }
+  },
+  "quality": {
+    "testCoverage": {
+      "enabled": true,
+      "minimum": 70,
+      "target": 80
+    },
+    "maxFileSize": {
+      "enabled": true,
+      "maxLines": 500,
+      "warningLines": 300
+    },
+    "complexity": {
+      "enabled": true,
+      "maxCyclomaticComplexity": 10
+    }
+  },
+  "git": {
+    "autoCommit": false,
+    "commitMessageTemplate": "{{type}}({{scope}}): {{subject}}",
+    "branchNamingTemplate": "{{type}}/{{ticket}}-{{description}}",
+    "types": ["feat", "fix", "refactor", "docs", "test", "chore"]
+  },
+  "paths": {
+    "agents": ".opencode/agents",
+    "skills": ".opencode/skills",
+    "plugins": ".opencode/plugins",
+    "templates": ".opencode/templates",
+    "context": "context",
+    "output": "output"
+  },
+  "logging": {
+    "level": "info",
+    "file": ".opencode/opencode.log",
+    "console": true
+  }
+}

package/templates/.opencode/rules/coding-standards.md

@@ -0,0 +1,250 @@
+# Global Coding Standards
+
+These rules apply to all code regardless of language or framework.
+
+## Core Principles
+
+### 1. Readability First
+
+Code is read more than written. Optimize for the reader.
+
+```typescript
+// ❌ Clever but unclear
+const result = arr.filter(Boolean).map(x => +x * 2);
+
+// ✅ Clear and readable
+const result = arr
+  .filter(item => item !== null && item !== undefined)
+  .map(item => Number(item) * 2);
+```
+
+### 2. Single Responsibility
+
+Each function/component should do one thing well.
+
+```typescript
+// ❌ Does too much
+function processOrder(order) {
+  validateOrder(order);
+  calculateTotal(order);
+  chargePayment(order);
+  sendEmail(order);
+}
+
+// ✅ Single responsibility
+function processOrder(order: Order): ProcessResult {
+  // Orchestration only
+  return pipe(validate, calculate, charge, notify)(order);
+}
+```
+
+### 3. Explicit Over Implicit
+
+Be clear about what code does.
+
+```typescript
+// ❌ Implicit behavior
+function save(data) {
+  localStorage.setItem('data', JSON.stringify(data));
+}
+
+// ✅ Explicit behavior
+function saveToLocalStorage(key: string, data: unknown): void {
+  localStorage.setItem(key, JSON.stringify(data));
+}
+```
+
+### 4. Fail Fast and Loud
+
+Errors should be obvious, not silent.
+
+```typescript
+// ❌ Silent failure
+function getConfig(key) {
+  return config[key];
+}
+
+// ✅ Fail loud
+function getConfig(key: keyof Config): ConfigValue {
+  const value = config[key];
+  if (value === undefined) {
+    throw new Error(`Missing config: ${key}`);
+  }
+  return value;
+}
+```
+
+### 5. Consistency
+
+Follow the same patterns throughout the codebase.
+
+```typescript
+// Pick a style and stick with it
+// ✅ Consistent naming
+const userCount = users.length;
+const itemCount = items.length;
+const orderCount = orders.length;
+
+// ❌ Inconsistent naming
+const userCount = users.length;
+const numItems = items.length;
+const ordersLength = orders.length;
+```
+
+## Naming Conventions
+
+### Variables
+
+- Use descriptive names: `userCount` not `n`
+- Boolean names should read naturally: `isActive`, `hasPermission`
+- Avoid negatives: `isDisabled` not `isNotEnabled`
+
+### Functions
+
+- Functions should describe actions: `getUser()`, `calculateTotal()`
+- Boolean functions should be questions: `isValid()`, `canEdit()`
+- Event handlers describe what happens: `handleSubmit()`, `handleClick()`
+
+### Classes/Types
+
+- Use PascalCase: `UserService`, `OrderStatus`
+- Nouns, not verbs: `User` not `CreateUser`
+
+### Constants
+
+- SCREAMING_SNAKE_CASE for true constants: `MAX_RETRIES`, `API_BASE_URL`
+- camelCase for configuration objects: `defaultConfig`, `themeSettings`
+
+## File Organization
+
+### Import Order
+
+```typescript
+// 1. External dependencies
+import { useState } from 'react';
+import { z } from 'zod';
+
+// 2. Internal modules (using aliases)
+import { Button } from '@/components/ui';
+import { useAuth } from '@/hooks/useAuth';
+
+// 3. Relative imports
+import { helper } from './utils';
+
+// 4. Types
+import type { User } from '@/types';
+```
+
+### Export Order
+
+```typescript
+// 1. Types
+export type { User, UserCreateInput };
+
+// 2. Constants
+export const MAX_USERS = 100;
+
+// 3. Functions/Classes
+export function createUser() {}
+export class UserService {}
+```
+
+## Error Handling
+
+### Use Specific Errors
+
+```typescript
+// ❌ Generic
+throw new Error('Something went wrong');
+
+// ✅ Specific
+throw new ValidationError('Email is invalid', { field: 'email' });
+```
+
+### Handle at Boundaries
+
+```typescript
+// ❌ Silent catch
+try {
+  doSomething();
+} catch (e) {}
+
+// ✅ Proper handling
+try {
+  doSomething();
+} catch (error) {
+  logger.error('Operation failed', { error });
+  throw new ServiceError('Operation failed', { cause: error });
+}
+```
+
+## Comments
+
+### When to Comment
+
+- Explain WHY, not WHAT
+- Document complex algorithms
+- Add TODOs with context and issue links
+- Document public APIs
+
+### When NOT to Comment
+
+- Don't explain obvious code
+- Don't leave commented-out code
+- Don't write comments that can become outdated
+
+## Testing Standards
+
+### Test Names
+
+```typescript
+// ❌ Vague
+test('user', () => {});
+
+// ✅ Descriptive
+test('should create user with valid email', () => {});
+```
+
+### Test Structure
+
+```typescript
+describe('UserService', () => {
+  describe('createUser', () => {
+    it('should create user with valid data', () => {
+      // Arrange
+      const input = { email: 'test@example.com' };
+      
+      // Act
+      const result = userService.createUser(input);
+      
+      // Assert
+      expect(result.email).toBe(input.email);
+    });
+  });
+});
+```
+
+## Git Conventions
+
+### Commit Messages
+
+```
+type(scope): description
+
+[optional body]
+
+[optional footer]
+```
+
+Types: `feat`, `fix`, `docs`, `style`, `refactor`, `test`, `chore`
+
+### Branch Names
+
+- `feature/description` - New features
+- `fix/description` - Bug fixes
+- `refactor/description` - Code improvements
+- `docs/description` - Documentation
+
+---
+
+**These standards ensure code quality and maintainability.**