opencode-agile-agent 1.0.1

package/templates/.opencode/workflows/enhance.md

@@ -0,0 +1,253 @@
+---
+description: Improve existing code for better quality, performance, or maintainability.
+---
+
+# /enhance Workflow
+
+Improve existing code without changing its behavior.
+
+## When to Use
+
+- Code works but could be better
+- Refactoring for maintainability
+- Performance optimization
+- Adding error handling
+- Improving code quality
+
+## Workflow Steps
+
+### Step 1: Analyze Current State
+
+```
+Understand what exists:
+- What does this code do?
+- What are the pain points?
+- What improvements are needed?
+```
+
+### Step 2: Identify Improvements
+
+```
+Common improvements:
+- Extract duplicated code
+- Improve naming
+- Add error handling
+- Optimize performance
+- Increase test coverage
+- Improve type safety
+```
+
+### Step 3: Prioritize
+
+```
+Impact vs. Effort:
+- High impact, low effort → Do first
+- High impact, high effort → Plan carefully
+- Low impact, low effort → Do if time permits
+- Low impact, high effort → Skip
+```
+
+### Step 4: Implement
+
+```
+Small, incremental changes:
+1. Make one improvement
+2. Test thoroughly
+3. Commit
+4. Repeat
+```
+
+### Step 5: Verify
+
+```
+Ensure behavior unchanged:
+- All existing tests pass
+- New tests added for edge cases
+- Manual testing complete
+```
+
+## Enhancement Categories
+
+### Code Quality
+
+```typescript
+// Before
+function calc(a, b, c) {
+  if (a > 0) {
+    if (b > 0) {
+      return a + b + c;
+    }
+  }
+  return 0;
+}
+
+// After
+function calculateSum(base: number, addition: number, extra: number): number {
+  if (base <= 0 || addition <= 0) {
+    return 0;
+  }
+  return base + addition + extra;
+}
+```
+
+### Error Handling
+
+```typescript
+// Before
+async function getUser(id) {
+  const response = await fetch(`/api/users/${id}`);
+  return response.json();
+}
+
+// After
+async function getUser(id: string): Promise<User> {
+  validateUserId(id);
+  
+  const response = await fetch(`/api/users/${id}`);
+  
+  if (!response.ok) {
+    if (response.status === 404) {
+      throw new UserNotFoundError(id);
+    }
+    throw new ApiError(`Failed to fetch user: ${response.status}`);
+  }
+  
+  return response.json();
+}
+```
+
+### Performance
+
+```typescript
+// Before
+function findUser(users: User[], name: string): User | undefined {
+  return users.find(user => user.name === name);
+}
+const user = findUser(allUsers, 'John'); // O(n) per call
+
+// After
+class UserLookup {
+  private byName: Map<string, User>;
+  
+  constructor(users: User[]) {
+    this.byName = new Map(users.map(u => [u.name, u]));
+  }
+  
+  findByName(name: string): User | undefined {
+    return this.byName.get(name); // O(1)
+  }
+}
+```
+
+### Type Safety
+
+```typescript
+// Before
+function process(data) {
+  return data.items.map(i => i.value);
+}
+
+// After
+interface Data {
+  items: Array<{ value: number }>;
+}
+
+function process(data: Data): number[] {
+  return data.items.map(i => i.value);
+}
+```
+
+## Example
+
+```
+User: /enhance login function for better error handling
+
+Agent: I'll enhance the login function.
+
+**Current State:**
+```typescript
+async function login(email, password) {
+  const response = await fetch('/api/login', {
+    method: 'POST',
+    body: JSON.stringify({ email, password })
+  });
+  return response.json();
+}
+```
+
+**Issues:**
+1. No input validation
+2. No error handling
+3. No type safety
+4. No loading state
+5. Hardcoded URL
+
+**Improvements:**
+1.  Add input validation
+2.  Add error handling
+3.  Add type safety
+4.  Add loading state
+5.  Extract URL to config
+
+**Enhanced Version:**
+```typescript
+interface LoginCredentials {
+  email: string;
+  password: string;
+}
+
+interface LoginResult {
+  success: boolean;
+  user?: User;
+  error?: string;
+}
+
+async function login(
+  credentials: LoginCredentials
+): Promise<LoginResult> {
+  // Validation
+  if (!isValidEmail(credentials.email)) {
+    return { success: false, error: 'Invalid email' };
+  }
+  
+  if (credentials.password.length < 8) {
+    return { success: false, error: 'Password too short' };
+  }
+  
+  try {
+    const response = await fetch(API_CONFIG.loginUrl, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(credentials)
+    });
+    
+    if (!response.ok) {
+      return { 
+        success: false, 
+        error: mapError(response.status) 
+      };
+    }
+    
+    const user = await response.json();
+    return { success: true, user };
+    
+  } catch (error) {
+    return { 
+      success: false, 
+      error: 'Network error' 
+    };
+  }
+}
+```
+
+ Enhanced with:
+- Input validation
+- Error handling
+- Type safety
+- Configuration
+- Proper error messages
+```
+
+---
+
+**Enhance incrementally, verify constantly.**

package/templates/.opencode/workflows/orchestrate.md

@@ -0,0 +1,130 @@
+---
+description: Multi-agent coordination for complex tasks. Use when a task requires multiple specialists.
+---
+
+# /orchestrate Workflow
+
+Coordinate multiple agents for complex, multi-domain tasks.
+
+## When to Use
+
+- Tasks requiring multiple perspectives
+- Full-stack features
+- Comprehensive reviews
+- Complex implementations
+
+## Minimum Agent Requirement
+
+> **Orchestration requires at least 2 different agents.**
+
+## Workflow Steps
+
+### Step 1: Task Analysis
+
+```
+Analyze the task:
+1. What domains are involved?
+2. What skills are needed?
+3. What are the dependencies?
+4. What's the complexity level?
+```
+
+### Step 2: Agent Selection
+
+```
+Select appropriate agents:
+- Security → security-auditor
+- Frontend → frontend-specialist
+- Backend → backend-specialist
+- Database → database-architect
+- Testing → test-engineer
+- DevOps → devops-engineer
+```
+
+### Step 3: Plan Execution
+
+```
+Order agents by dependencies:
+1. Foundation agents (database, security)
+2. Core agents (backend, frontend)
+3. Polish agents (testing, performance)
+```
+
+### Step 4: Execute
+
+```
+Invoke agents with context:
+1. Pass full context to each agent
+2. Collect findings from each
+3. Handle any conflicts
+4. Ensure boundaries respected
+```
+
+### Step 5: Synthesize
+
+```
+Combine results:
+1. Merge findings
+2. Resolve conflicts
+3. Create unified report
+4. Provide recommendations
+```
+
+## Example
+
+```
+User: /orchestrate build secure user management
+
+Agent: I'll coordinate multiple agents for this task.
+
+**Task Analysis:**
+- Domains: Auth, Frontend, Backend, Database, Security
+- Complexity: High
+- Dependencies: DB → API → UI
+
+**Agents Selected:**
+1. database-architect (schema)
+2. backend-specialist (API)
+3. frontend-specialist (UI)
+4. security-auditor (review)
+5. test-engineer (tests)
+
+**Execution:**
+
+[database-architect]
+- Created user schema
+- Added indexes
+- Migration ready
+
+[backend-specialist]
+- Created auth endpoints
+- Implemented JWT
+- Added validation
+
+[frontend-specialist]
+- Created login/register forms
+- Implemented auth state
+- Added route guards
+
+[security-auditor]
+- Reviewed auth implementation
+- Identified 2 issues
+- Provided fixes
+
+[test-engineer]
+- Added unit tests
+- Added integration tests
+- Coverage: 85%
+
+**Synthesis Report:**
+- Files created: 12
+- Files modified: 5
+- Issues found: 2 (fixed)
+- Tests added: 24
+
+**Ready for review!**
+```
+
+---
+
+**Orchestration multiplies capability through coordination.**

package/templates/.opencode/workflows/plan.md

@@ -0,0 +1,163 @@
+---
+description: Create structured task breakdowns and plans. Use when starting complex work.
+---
+
+# /plan Workflow
+
+Create detailed plans and task breakdowns for complex work.
+
+## When to Use
+
+- Starting a new feature
+- Breaking down complex tasks
+- Creating project roadmaps
+- Need clear direction before coding
+
+## Workflow Steps
+
+### Step 1: Understand the Goal
+
+```
+Clarify the objective:
+1. What are we building?
+2. Why does it matter?
+3. What are the constraints?
+4. What does success look like?
+```
+
+### Step 2: Gather Requirements
+
+```
+Document requirements:
+- Functional requirements
+- Non-functional requirements
+- Constraints
+- Assumptions
+```
+
+### Step 3: Break Down Tasks
+
+```
+Decompose into atomic tasks:
+1. Each task should be completable in < 1 day
+2. Tasks should have clear deliverables
+3. Dependencies should be identified
+4. Effort estimates should be included
+```
+
+### Step 4: Sequence Tasks
+
+```
+Order by dependencies:
+- What must be done first?
+- What can be done in parallel?
+- What's the critical path?
+```
+
+### Step 5: Define Success Criteria
+
+```
+How will we know we're done?
+- Measurable outcomes
+- Acceptance criteria
+- Quality gates
+```
+
+### Step 6: Document the Plan
+
+```
+Create plan document:
+- Overview
+- Requirements
+- Tasks
+- Dependencies
+- Timeline
+- Success criteria
+```
+
+## Plan Template
+
+```markdown
+# PLAN: [Feature Name]
+
+## Overview
+Brief description.
+
+## Requirements
+### Functional
+- [ ] Requirement 1
+- [ ] Requirement 2
+
+### Non-Functional
+- Performance: [target]
+- Security: [requirements]
+
+## Tasks
+### Phase 1: [Name]
+| Task | Size | Dependencies |
+|------|------|--------------|
+| 1.1 [Task] | S | None |
+| 1.2 [Task] | M | 1.1 |
+
+### Phase 2: [Name]
+| Task | Size | Dependencies |
+|------|------|--------------|
+| 2.1 [Task] | S | 1.2 |
+
+## Success Criteria
+- [ ] Criterion 1
+- [ ] Criterion 2
+
+## Risks
+| Risk | Mitigation |
+|------|------------|
+| [Risk] | [Action] |
+```
+
+## Example
+
+```
+User: /plan shopping cart feature
+
+Agent: I'll create a plan for the shopping cart feature.
+
+**Goal Clarification:**
+- Add shopping cart to e-commerce site
+- Users can add/remove items
+- Persist across sessions
+- Calculate totals with tax
+
+**Requirements:**
+- Add to cart from product page
+- View cart with quantities
+- Update quantities
+- Remove items
+- Calculate subtotal, tax, total
+- Persist for logged-in users
+
+**Tasks:**
+| Task | Size | Dependencies |
+|------|------|--------------|
+| 1.1 Create CartItem type | XS | None |
+| 1.2 Create CartStore | S | 1.1 |
+| 1.3 Create AddToCart button | S | 1.2 |
+| 1.4 Create CartPage | M | 1.2 |
+| 1.5 Create CartItem component | S | 1.1 |
+| 1.6 Implement quantity update | S | 1.4 |
+| 1.7 Implement remove item | S | 1.4 |
+| 1.8 Implement totals calculation | S | 1.1 |
+| 1.9 Add persistence | M | 1.2 |
+| 1.10 Add tests | M | All |
+
+**Success Criteria:**
+- [ ] Users can add/remove items
+- [ ] Cart persists across sessions
+- [ ] Totals calculate correctly
+- [ ] All tests pass
+
+**Plan saved to: context/shopping-cart/PLAN.md**
+```
+
+---
+
+**Good plans make execution straightforward.**

package/templates/.opencode/workflows/review.md

@@ -0,0 +1,135 @@
+---
+description: Code review workflow for validating implementations. Use when reviewing code quality and standards compliance.
+---
+
+# /review Workflow
+
+Comprehensive code review against project standards and best practices.
+
+## When to Use
+
+- After completing implementation
+- Before merging PRs
+- Quality assurance
+- Standards compliance check
+
+## Workflow Steps
+
+### Step 1: Identify Scope
+
+```
+What to review:
+- Recent changes
+- Specific files
+- Full codebase
+- Specific concerns (security, performance, etc.)
+```
+
+### Step 2: Run Automated Checks
+
+```
+Automated quality gates:
+- [ ] Linting passes
+- [ ] TypeScript compiles
+- [ ] Tests pass
+- [ ] No security vulnerabilities
+```
+
+### Step 3: Manual Review
+
+```
+Code quality review:
+- [ ] Code follows project conventions
+- [ ] No anti-patterns detected
+- [ ] Proper error handling
+- [ ] Appropriate abstractions
+- [ ] Clear naming
+- [ ] Adequate comments
+```
+
+### Step 4: Domain-Specific Review
+
+```
+Based on code type:
+- Frontend: Accessibility, performance, responsive
+- Backend: Security, error handling, validation
+- Database: Indexes, query efficiency, migrations
+```
+
+### Step 5: Generate Report
+
+```
+Review summary:
+- Overall assessment
+- Issues found (critical, major, minor)
+- Recommendations
+- Approval status
+```
+
+## Review Checklist
+
+### General
+- [ ] Code is readable and maintainable
+- [ ] Functions have single responsibility
+- [ ] No code duplication
+- [ ] Proper error handling
+- [ ] Appropriate logging
+
+### Security
+- [ ] No hardcoded secrets
+- [ ] Input validation present
+- [ ] Proper authentication checks
+- [ ] SQL injection prevention
+- [ ] XSS prevention
+
+### Performance
+- [ ] No N+1 queries
+- [ ] Appropriate caching
+- [ ] No memory leaks
+- [ ] Efficient algorithms
+
+### Testing
+- [ ] Adequate test coverage
+- [ ] Tests are meaningful
+- [ ] Edge cases covered
+
+## Example
+
+```
+User: /review recent changes
+
+Agent: I'll review the recent changes.
+
+**Scope:** Last 5 commits (auth feature)
+
+**Automated Checks:**
+- [x] Lint: Pass
+- [x] TypeScript: Pass
+- [x] Tests: 12/12 Pass
+- [x] Security: No vulnerabilities
+
+**Code Review:**
+
+✅ Good:
+- Clear function naming
+- Proper error handling
+- Tests for edge cases
+
+⚠️ Issues Found:
+
+[MAJOR] auth.service.ts:45
+- Password comparison not timing-safe
+- Recommendation: Use bcrypt.compare()
+
+[MINOR] login.tsx:23
+- Missing loading state during submission
+- Recommendation: Add isSubmitting state
+
+**Verdict: CHANGES REQUESTED**
+
+Please address the timing-safe comparison issue before merging.
+```
+
+---
+
+**Review catches what automation misses.**