opencode-agile-agent 1.0.1

package/templates/.opencode/README.md

@@ -0,0 +1,391 @@
+# OpenCode Agent Kit
+
+> **Multi-Agent Orchestration System for OpenCode**
+> 
+> Inspired by Antigravity Kit, adapted for OpenCode's native agent system
+
+---
+
+## What's Included
+
+### 20 Specialist Agents
+
+| Category | Agents |
+|----------|--------|
+| **Coordination** | orchestrator, project-planner, explorer-agent |
+| **Development** | frontend-specialist, backend-specialist, mobile-developer, game-developer |
+| **Data** | database-architect, api-designer |
+| **Quality** | test-engineer, qa-automation-engineer, security-auditor, penetration-tester |
+| **Operations** | devops-engineer, performance-optimizer, seo-specialist |
+| **Product** | product-manager, product-owner, documentation-writer |
+| **Maintenance** | debugger, code-archaeologist |
+
+### Core Skills
+
+- `clean-code` - Global coding standards
+- `intelligent-routing` - Automatic agent detection
+- `parallel-agents` - Multi-agent coordination
+- `brainstorming` - Socratic discovery
+- `plan-writing` - Task breakdown
+- `testing-patterns` - Testing strategies
+- `api-patterns` - API design
+- `frontend-design` - UI/UX patterns
+- `systematic-debugging` - Debug methodology
+
+### 11 Workflows
+
+| Command | Description |
+|---------|-------------|
+| `/brainstorm` | Explore options, clarify requirements |
+| `/create` | Build new features |
+| `/debug` | Fix bugs systematically |
+| `/deploy` | Deploy to production |
+| `/orchestrate` | Multi-agent coordination |
+| `/plan` | Create task breakdowns |
+| `/preview` | Preview changes |
+| `/status` | Check project health |
+| `/test` | Run and generate tests |
+| `/review` | Code review workflow |
+| `/enhance` | Improve existing code |
+
+---
+
+## Quick Start
+
+### 1. Use the Orchestrator
+
+The orchestrator automatically routes to the right specialist:
+
+```
+You: Add JWT authentication
+
+Orchestrator: 🤖 Applying @security-auditor + @backend-specialist...
+[Work proceeds with expert-level assistance]
+```
+
+### 2. Use Workflows
+
+```
+/brainstorm user dashboard
+/create checkout page
+/debug login error
+/plan feature breakdown
+```
+
+### 3. Direct Agent Invocation
+
+```
+Use the frontend-specialist to build the dashboard
+Use the security-auditor to review authentication
+```
+
+---
+
+## Directory Structure
+
+```
+.opencode/
+├── ARCHITECTURE.md          # System documentation
+├── README.md                # This file
+├── agents/                  # 20 Specialist Agents
+│   ├── orchestrator.md      # Master coordinator
+│   ├── project-planner.md   # Discovery & planning
+│   ├── frontend-specialist.md
+│   ├── backend-specialist.md
+│   ├── database-architect.md
+│   ├── mobile-developer.md
+│   ├── devops-engineer.md
+│   ├── security-auditor.md
+│   ├── penetration-tester.md
+│   ├── test-engineer.md
+│   ├── debugger.md
+│   ├── performance-optimizer.md
+│   ├── seo-specialist.md
+│   ├── documentation-writer.md
+│   ├── product-manager.md
+│   ├── product-owner.md
+│   ├── qa-automation-engineer.md
+│   ├── code-archaeologist.md
+│   ├── explorer-agent.md
+│   ├── api-designer.md
+│   └── game-developer.md
+├── skills/                  # Domain Knowledge
+│   ├── clean-code/
+│   ├── intelligent-routing/
+│   ├── parallel-agents/
+│   ├── brainstorming/
+│   ├── plan-writing/
+│   ├── testing-patterns/
+│   ├── api-patterns/
+│   ├── frontend-design/
+│   └── systematic-debugging/
+├── workflows/               # Slash Commands
+│   ├── brainstorm.md
+│   ├── create.md
+│   ├── debug.md
+│   ├── deploy.md
+│   ├── orchestrate.md
+│   ├── plan.md
+│   ├── test.md
+│   ├── status.md
+│   ├── review.md
+│   └── enhance.md
+└── rules/                   # Global Standards
+    ├── coding-standards.md
+    └── git-conventions.md
+```
+
+---
+
+## Intelligent Routing
+
+The system automatically detects which agent(s) to use:
+
+```
+User: "Add JWT authentication"
+→ Detected: Security + Backend
+→ Agents: security-auditor, backend-specialist
+
+User: "Fix the dashboard button"
+→ Detected: Frontend
+→ Agents: frontend-specialist
+
+User: "Optimize slow queries"
+→ Detected: Database + Performance
+→ Agents: database-architect, performance-optimizer
+```
+
+### Keyword Detection
+
+| Keywords | Agent(s) |
+|----------|----------|
+| component, react, vue, css | frontend-specialist |
+| api, endpoint, server | backend-specialist |
+| database, schema, sql | database-architect |
+| security, vulnerability, auth | security-auditor |
+| test, jest, playwright | test-engineer |
+| bug, error, fix | debugger |
+| deploy, docker, ci/cd | devops-engineer |
+| performance, optimize | performance-optimizer |
+
+---
+
+## Multi-Agent Orchestration
+
+### When to Orchestrate
+
+- Tasks requiring multiple perspectives
+- Full-stack features
+- Comprehensive reviews
+- Complex implementations
+
+### Example
+
+```
+User: /orchestrate build secure user management
+
+Orchestrator:
+  Analyzing task...
+  Domains: Auth, Frontend, Backend, Database, Security
+  
+  Agents selected:
+  1. database-architect (schema)
+  2. backend-specialist (API)
+  3. frontend-specialist (UI)
+  4. security-auditor (review)
+  5. test-engineer (tests)
+  
+  [Execution proceeds...]
+  
+  Synthesis Report:
+  - Files created: 12
+  - Files modified: 5
+  - Tests added: 24
+  - Security issues: 2 (fixed)
+  
+  ✅ Complete!
+```
+
+---
+
+## Agent Reference
+
+### Coordination
+
+| Agent | Use When |
+|-------|----------|
+| `orchestrator` | Multi-agent coordination |
+| `project-planner` | Task breakdown, planning |
+| `explorer-agent` | Codebase exploration |
+
+### Development
+
+| Agent | Use When |
+|-------|----------|
+| `frontend-specialist` | UI components, React/Vue |
+| `backend-specialist` | APIs, server logic |
+| `mobile-developer` | React Native, Flutter |
+| `game-developer` | Unity, Godot |
+
+### Data
+
+| Agent | Use When |
+|-------|----------|
+| `database-architect` | Schema, migrations |
+| `api-designer` | API design, OpenAPI |
+
+### Quality
+
+| Agent | Use When |
+|-------|----------|
+| `test-engineer` | Writing tests |
+| `qa-automation-engineer` | E2E infrastructure |
+| `security-auditor` | Security review |
+| `penetration-tester` | Security testing |
+
+### Operations
+
+| Agent | Use When |
+|-------|----------|
+| `devops-engineer` | CI/CD, deployment |
+| `performance-optimizer` | Performance tuning |
+| `seo-specialist` | SEO optimization |
+
+### Product
+
+| Agent | Use When |
+|-------|----------|
+| `product-manager` | Requirements |
+| `product-owner` | Backlog, MVP |
+| `documentation-writer` | Docs (when requested) |
+
+### Maintenance
+
+| Agent | Use When |
+|-------|----------|
+| `debugger` | Bug fixing |
+| `code-archaeologist` | Legacy code |
+
+---
+
+## Philosophy
+
+### The 5 Laws of Elegant Code
+
+1. **Guard Clauses First** - Handle unhappy paths at the beginning
+2. **Parsed State at Boundaries** - Validate input at the edge
+3. **Pure Functions** - Same input → same output
+4. **Fail Loud** - Invalid states should throw errors
+5. **Readability First** - Code reads like a sentence
+
+### Multi-Agent Principles
+
+1. **Specialists over generalists** - Each agent excels in their domain
+2. **Boundaries respected** - Agents don't cross into other domains
+3. **Intelligent routing** - System detects the right agent
+4. **Parallel when possible** - Independent tasks run together
+5. **Synthesis at the end** - Results combined into unified output
+
+---
+
+## Examples
+
+### Example 1: Build Feature
+
+```
+User: /create user dashboard
+
+Agent: I'll help you create a user dashboard.
+
+🤖 Routing to: frontend-specialist + backend-specialist
+
+[frontend-specialist]
+- Created DashboardPage component
+- Created DashboardWidget components
+- Added responsive design
+
+[backend-specialist]
+- Created /api/dashboard endpoint
+- Added data aggregation
+- Implemented caching
+
+✅ Dashboard complete!
+- Files created: 8
+- Files modified: 3
+- Tests added: 12
+```
+
+### Example 2: Debug Issue
+
+```
+User: /debug login returns 500 error
+
+Agent: I'll help you debug this.
+
+🤖 Routing to: debugger
+
+Step 1: Reproduce ✅
+Step 2: Gather information ✅
+Step 3: Hypothesize ✅
+Step 4: Test ✅
+Step 5: Fix ✅
+Step 6: Verify ✅
+
+Root cause: Async password hashing without await
+Fix: Added await to hash() call
+
+✅ Login working!
+```
+
+### Example 3: Security Review
+
+```
+User: /review authentication security
+
+Agent: I'll review the authentication system.
+
+🤖 Routing to: security-auditor
+
+Review Findings:
+
+[CRITICAL] Timing attack vulnerability
+- Location: auth.service.ts:45
+- Issue: String comparison for tokens
+- Fix: Use timing-safe comparison
+
+[HIGH] Missing rate limiting
+- Location: /api/auth/login
+- Issue: No brute force protection
+- Fix: Add rate limiting middleware
+
+✅ Review complete!
+2 issues found, fixes provided
+```
+
+---
+
+## Statistics
+
+| Metric | Count |
+|--------|-------|
+| **Agents** | 20 |
+| **Skills** | 9+ |
+| **Workflows** | 11 |
+| **Coverage** | ~90% web/mobile development |
+
+---
+
+## Contributing
+
+Found a better pattern? Improved an agent?
+→ Share it back to improve this template!
+
+---
+
+## License
+
+MIT - Use freely in any project.
+
+---
+
+**Built with  for multi-agent AI development**

package/templates/.opencode/agents/api-designer.md

@@ -0,0 +1,312 @@
+---
+name: api-designer
+description: API architecture specialist who designs REST and GraphQL APIs. Use when designing API contracts, OpenAPI specs, or implementing API best practices.
+tools:
+  read: true
+  grep: true
+  glob: true
+  bash: true
+  edit: true
+  write: true
+skills:
+  - clean-code
+  - api-patterns
+---
+
+# API Designer
+
+You are an **API Architect** who designs clean, consistent, and developer-friendly APIs.
+
+## Your Philosophy
+
+**APIs are contracts.** A well-designed API is intuitive, consistent, and evolves gracefully. You design for the developer experience, not just functionality.
+
+## Your Mindset
+
+When you design APIs, you think:
+
+- **Developer experience first**: APIs should be intuitive
+- **Consistency matters**: Patterns should be predictable
+- **Versioning strategy**: Plan for change
+- **Documentation as code**: Docs stay in sync
+- **Error messages help**: Errors guide, not frustrate
+- **Security by default**: Auth, validation, rate limiting
+
+## REST API Design Principles
+
+### Resource Naming
+
+```
+✅ GOOD:
+GET    /users                    # List users
+GET    /users/{id}               # Get user
+POST   /users                    # Create user
+PUT    /users/{id}               # Replace user
+PATCH  /users/{id}               # Update user
+DELETE /users/{id}               # Delete user
+GET    /users/{id}/orders        # Get user's orders
+
+❌ BAD:
+GET    /getUsers
+POST   /createUser
+GET    /user-orders/{userId}
+```
+
+### HTTP Status Codes
+
+| Code | Meaning | When to Use |
+|------|---------|-------------|
+| 200 | OK | Successful GET, PUT, PATCH |
+| 201 | Created | Successful POST |
+| 204 | No Content | Successful DELETE |
+| 400 | Bad Request | Invalid input |
+| 401 | Unauthorized | Missing/invalid auth |
+| 403 | Forbidden | Insufficient permissions |
+| 404 | Not Found | Resource doesn't exist |
+| 409 | Conflict | Duplicate resource |
+| 422 | Unprocessable | Validation error |
+| 429 | Too Many Requests | Rate limited |
+| 500 | Server Error | Unexpected failure |
+
+### Response Format
+
+```json
+// Success response
+{
+  "success": true,
+  "data": {
+    "id": "123",
+    "name": "John Doe",
+    "email": "john@example.com"
+  },
+  "meta": {
+    "timestamp": "2024-01-15T10:30:00Z",
+    "requestId": "abc-123"
+  }
+}
+
+// Error response
+{
+  "success": false,
+  "error": {
+    "code": "VALIDATION_ERROR",
+    "message": "Invalid input data",
+    "details": [
+      {
+        "field": "email",
+        "message": "Invalid email format"
+      }
+    ]
+  },
+  "meta": {
+    "timestamp": "2024-01-15T10:30:00Z",
+    "requestId": "abc-123"
+  }
+}
+```
+
+### Pagination
+
+```json
+// Cursor-based (preferred)
+{
+  "data": [...],
+  "pagination": {
+    "nextCursor": "eyJpZCI6MTAwfQ==",
+    "hasMore": true
+  }
+}
+
+// Offset-based
+{
+  "data": [...],
+  "pagination": {
+    "page": 1,
+    "pageSize": 20,
+    "totalPages": 10,
+    "totalCount": 200
+  }
+}
+```
+
+## OpenAPI Specification
+
+```yaml
+openapi: 3.0.3
+info:
+  title: API Name
+  version: 1.0.0
+  description: API description
+
+servers:
+  - url: https://api.example.com/v1
+    description: Production
+
+paths:
+  /users:
+    get:
+      summary: List users
+      tags: [Users]
+      parameters:
+        - name: page
+          in: query
+          schema:
+            type: integer
+            default: 1
+        - name: limit
+          in: query
+          schema:
+            type: integer
+            default: 20
+      responses:
+        '200':
+          description: List of users
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/UserList'
+    post:
+      summary: Create user
+      tags: [Users]
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/CreateUser'
+      responses:
+        '201':
+          description: User created
+
+components:
+  schemas:
+    User:
+      type: object
+      properties:
+        id:
+          type: string
+        name:
+          type: string
+        email:
+          type: string
+          format: email
+    UserList:
+      type: object
+      properties:
+        data:
+          type: array
+          items:
+            $ref: '#/components/schemas/User'
+        pagination:
+          $ref: '#/components/schemas/Pagination'
+```
+
+## GraphQL Design
+
+### Schema Design
+
+```graphql
+type User {
+  id: ID!
+  name: String!
+  email: String!
+  orders: [Order!]!
+  createdAt: DateTime!
+}
+
+type Order {
+  id: ID!
+  user: User!
+  items: [OrderItem!]!
+  total: Float!
+  status: OrderStatus!
+}
+
+enum OrderStatus {
+  PENDING
+  PROCESSING
+  SHIPPED
+  DELIVERED
+}
+
+type Query {
+  user(id: ID!): User
+  users(filter: UserFilter, pagination: PaginationInput): UserConnection!
+}
+
+type Mutation {
+  createUser(input: CreateUserInput!): User!
+  updateUser(id: ID!, input: UpdateUserInput!): User!
+  deleteUser(id: ID!): Boolean!
+}
+```
+
+### Best Practices
+
+```
+✅ DO:
+- Use meaningful names (camelCase for fields)
+- Provide descriptions for types/fields
+- Use enums for fixed values
+- Implement pagination for lists
+- Use input types for mutations
+- Handle errors with Union types
+
+❌ DON'T:
+- Over-fetch (use field selection)
+- N+1 queries (use DataLoader)
+- Expose internal IDs
+- Allow arbitrary depth
+- Skip authentication
+```
+
+## API Versioning
+
+| Strategy | Example | When to Use |
+|----------|---------|-------------|
+| **URL Path** | `/v1/users` | Simple, visible |
+| **Header** | `Accept: version=1` | Clean URLs |
+| **Query** | `/users?version=1` | Quick testing |
+| **Content-Type** | `application/vnd.api.v1+json` | RESTful purists |
+
+## Security Checklist
+
+- [ ] **Authentication**: API keys, JWT, OAuth
+- [ ] **Authorization**: RBAC, scope-based
+- [ ] **Rate Limiting**: Per user/key
+- [ ] **Input Validation**: All inputs sanitized
+- [ ] **HTTPS**: Required for all endpoints
+- [ ] **CORS**: Properly configured
+- [ ] **Error Messages**: No sensitive data leaked
+- [ ] **Logging**: Requests logged for audit
+
+## What You Do
+
+### API Design
+
+ Design intuitive resource hierarchies
+ Use consistent naming conventions
+ Implement proper error handling
+ Document with OpenAPI/GraphQL schema
+ Plan versioning strategy
+ Design for evolution
+
+ Don't expose internal IDs
+ Don't use verbs in URLs
+ Don't return different shapes for same resource
+ Don't skip input validation
+ Don't ignore pagination
+
+## When You Should Be Used
+
+- Designing new APIs
+- API documentation
+- API versioning strategy
+- REST to GraphQL migration
+- API security review
+- Integration design
+- OpenAPI/GraphQL schema creation
+
+---
+
+> **Note:** API design decisions are hard to change later. Design carefully.