opencode-agile-agent 1.0.1 → 1.0.2

package/templates/.opencode/workflows/deploy.md

@@ -1,160 +0,0 @@
----
-description: Deploy application to production or staging. Use when ready to release.
----
-
-# /deploy Workflow
-
-Deploy applications to production, staging, or other environments.
-
-## When to Use
-
-- Ready to release to production
-- Deploying to staging for testing
-- Rolling out a new version
-- Setting up CI/CD
-
-## Workflow Steps
-
-### Step 1: Pre-Deployment Check
-
-```
-Verify readiness:
-- [ ] All tests pass
-- [ ] Code reviewed and approved
-- [ ] Changelog updated
-- [ ] Environment variables configured
-- [ ] Database migrations ready (if needed)
-```
-
-### Step 2: Build
-
-```
-Prepare the build:
-1. Install dependencies
-2. Run build command
-3. Verify build output
-4. Check bundle size
-```
-
-### Step 3: Deploy
-
-```
-Execute deployment:
-1. Choose deployment target
-2. Deploy to environment
-3. Monitor deployment progress
-4. Verify deployment success
-```
-
-### Step 4: Post-Deployment Verification
-
-```
-Verify the deployment:
-1. Health check endpoints
-2. Smoke tests
-3. Key user flows
-4. Error monitoring
-```
-
-### Step 5: Monitor
-
-```
-Watch for issues:
-- Error rates
-- Response times
-- Resource usage
-- User feedback
-```
-
-## Deployment Targets
-
-### Vercel
-
-```bash
-# Install CLI
-npm i -g vercel
-
-# Deploy
-vercel --prod
-```
-
-### Docker
-
-```bash
-# Build image
-docker build -t app:latest .
-
-# Run container
-docker run -p 3000:3000 app:latest
-```
-
-### Kubernetes
-
-```bash
-# Apply manifests
-kubectl apply -f k8s/
-
-# Verify deployment
-kubectl get pods
-```
-
-### AWS
-
-```bash
-# Deploy to ECS
-aws ecs update-service --cluster prod --service app --force-new-deployment
-
-# Or use SAM/CDK
-sam deploy --guided
-```
-
-## Rollback Plan
-
-```
-If deployment fails:
-1. Identify the issue
-2. Rollback to previous version
-3. Investigate in development
-4. Fix and redeploy
-
-Rollback commands:
-- Vercel: vercel rollback
-- Docker: docker tag app:previous app:latest
-- K8s: kubectl rollout undo deployment/app
-```
-
-## Example
-
-```
-User: /deploy to production
-
-Agent: I'll help you deploy to production.
-
-**Pre-Deployment Check:**
-- [x] All tests pass
-- [x] Code reviewed
-- [x] Changelog updated
-- [x] Environment configured
-
-**Build:**
-- Installing dependencies...
-- Building application...
-- Bundle size: 245KB (within budget)
-
-**Deploy:**
-- Target: Vercel
-- Environment: production
-- Deploying...
-
-**Verification:**
-- Health check: ✅
-- Smoke tests: ✅
-- Key flows: ✅
-
-**Deployed Successfully!**
-URL: https://app.example.com
-```
-
----
-
-**Deploy with confidence, rollback with ease.**

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

@@ -1,253 +0,0 @@
----
-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

@@ -1,130 +0,0 @@
----
-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

@@ -1,163 +0,0 @@
----
-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.**