opencode-agile-agent 1.0.1

package/templates/.opencode/workflows/brainstorm.md

@@ -0,0 +1,110 @@
+---
+description: Explore options and clarify requirements before implementation. Use when requirements are unclear or you need to explore possibilities.
+---
+
+# /brainstorm Workflow
+
+Explore options, clarify requirements, and discover the best approach.
+
+## When to Use
+
+- Requirements are vague or incomplete
+- Multiple approaches are possible
+- You need to understand the problem space
+- Starting a new feature or project
+
+## Workflow Steps
+
+### Step 1: Understand the Request
+
+```
+Ask clarifying questions:
+1. What problem are you trying to solve?
+2. Who is this for?
+3. What are the constraints?
+4. What does success look like?
+```
+
+### Step 2: Explore Options
+
+```
+Generate multiple approaches:
+- Option A: [description]
+- Option B: [description]
+- Option C: [description]
+
+For each option, consider:
+- Pros and cons
+- Effort required
+- Risks involved
+```
+
+### Step 3: Narrow Down
+
+```
+Apply constraints to filter options:
+- Must-have requirements
+- Timeline constraints
+- Technical limitations
+- Resource availability
+```
+
+### Step 4: Recommend
+
+```
+Based on analysis, recommend:
+- Best approach
+- Why it's recommended
+- Trade-offs to accept
+```
+
+### Step 5: Validate
+
+```
+Confirm with user:
+"Based on our discussion, I recommend [approach].
+This will [benefit].
+The trade-offs are [trade-offs].
+Should we proceed with this approach?"
+```
+
+## Example
+
+```
+User: /brainstorm user authentication
+
+Agent: I'll help you explore authentication options.
+
+**Clarifying Questions:**
+1. What type of users? (consumers, employees, both?)
+2. What security level is required? (basic, MFA, enterprise?)
+3. Any existing auth system to integrate?
+
+User: Consumers, basic security, no existing system
+
+Agent: **Options:**
+
+**Option A: Email/Password**
+- Pros: Simple, familiar to users
+- Cons: Password management, security concerns
+- Effort: Medium
+
+**Option B: Social Login (Google, GitHub)**
+- Pros: No password management, faster signup
+- Cons: Dependency on providers, privacy concerns
+- Effort: Low
+
+**Option C: Magic Links**
+- Pros: No passwords, secure
+- Cons: Email deliverability, less familiar
+- Effort: Medium
+
+**Recommendation:** Option B (Social Login) with Option A as fallback.
+This gives you the best UX with minimal security overhead.
+
+Proceed with this approach?
+```
+
+---
+
+**End with clear direction, not endless exploration.**

package/templates/.opencode/workflows/create.md

@@ -0,0 +1,108 @@
+---
+description: Create new features, components, or projects. Use when building something new.
+---
+
+# /create Workflow
+
+Build new features, components, or entire projects with structured approach.
+
+## When to Use
+
+- Creating a new feature
+- Building a new component
+- Starting a new project
+- Adding significant new functionality
+
+## Workflow Steps
+
+### Step 1: Gather Requirements
+
+```
+Understand what to create:
+- What are you building?
+- What are the requirements?
+- Any design specifications?
+- Technical constraints?
+```
+
+### Step 2: Plan the Approach
+
+```
+Break down the task:
+1. What files need to be created?
+2. What files need to be modified?
+3. What dependencies are needed?
+4. What's the order of operations?
+```
+
+### Step 3: Select Agent(s)
+
+```
+Based on the task, select appropriate agent(s):
+- Frontend work → frontend-specialist
+- Backend work → backend-specialist
+- Database work → database-architect
+- Multiple domains → orchestrator for coordination
+```
+
+### Step 4: Implement
+
+```
+Execute the plan:
+1. Create/modify files
+2. Follow project conventions
+3. Add appropriate error handling
+4. Include necessary tests
+```
+
+### Step 5: Verify
+
+```
+Quality checks:
+- [ ] Code compiles/builds
+- [ ] Linting passes
+- [ ] Tests pass
+- [ ] Feature works as expected
+```
+
+### Step 6: Document
+
+```
+Document what was created:
+- Summary of changes
+- How to use the new feature
+- Any important notes
+```
+
+## Example
+
+```
+User: /create user profile page
+
+Agent: I'll help you create a user profile page.
+
+**Requirements Check:**
+- Display user info: name, email, avatar
+- Allow editing profile
+- Show activity history
+- Responsive design
+
+**Plan:**
+1. Create ProfilePage component
+2. Create ProfileForm component
+3. Create ActivityList component
+4. Add API endpoints
+5. Add tests
+
+**Agents:** frontend-specialist + backend-specialist
+
+Proceed with this plan?
+
+User: Yes
+
+Agent: [Implementation proceeds...]
+```
+
+---
+
+**Create with purpose, verify with care.**

package/templates/.opencode/workflows/debug.md

@@ -0,0 +1,128 @@
+---
+description: Systematically debug and fix issues. Use when encountering errors, bugs, or unexpected behavior.
+---
+
+# /debug Workflow
+
+Systematically identify and fix bugs, errors, and unexpected behavior.
+
+## When to Use
+
+- Application is crashing
+- Feature not working as expected
+- Error messages appearing
+- Performance issues
+- Unexpected behavior
+
+## Workflow Steps
+
+### Step 1: Reproduce
+
+```
+Document the issue:
+1. What is the expected behavior?
+2. What is the actual behavior?
+3. What are the exact steps to reproduce?
+4. What environment? (browser, OS, version)
+```
+
+### Step 2: Gather Information
+
+```
+Collect evidence:
+- Error messages and stack traces
+- Logs and console output
+- Recent code changes
+- Environment differences
+```
+
+### Step 3: Hypothesize
+
+```
+Generate possible causes:
+1. [Hypothesis 1] - Why it might be happening
+2. [Hypothesis 2] - Alternative explanation
+3. [Hypothesis 3] - Another possibility
+```
+
+### Step 4: Test Hypotheses
+
+```
+For each hypothesis:
+1. Design a test to verify/falsify
+2. Run the test
+3. Document results
+4. Narrow down root cause
+```
+
+### Step 5: Fix Root Cause
+
+```
+Once root cause is identified:
+1. Implement the fix
+2. Address the underlying issue, not just symptoms
+3. Add safeguards to prevent recurrence
+```
+
+### Step 6: Verify Fix
+
+```
+Ensure the fix works:
+1. Test the original reproduction steps
+2. Test edge cases
+3. Check for regressions
+4. Run existing tests
+```
+
+### Step 7: Document
+
+```
+Record the fix:
+- What was the issue?
+- What was the root cause?
+- What was the fix?
+- How to prevent in future?
+```
+
+## Example
+
+```
+User: /debug login returns 500 error
+
+Agent: I'll help you debug the login error.
+
+**Step 1: Reproduce**
+- Navigate to /login
+- Enter valid credentials
+- Click login
+- Error: "500 Internal Server Error"
+
+**Step 2: Gather Information**
+- Stack trace points to auth.service.ts:45
+- Recent commit modified password hashing
+- Error: "Cannot read property 'hash' of undefined"
+
+**Step 3: Hypothesize**
+1. Password object is undefined
+2. Hash function signature changed
+3. Missing null check
+
+**Step 4: Test**
+- Checked password hashing library update
+- Found: hash() now returns Promise, was sync
+
+**Step 5: Fix**
+- Added await to hash() call
+- Added null check for password
+
+**Step 6: Verify**
+- Login works correctly
+- Tests pass
+- No regressions
+
+**Fixed:** Added await to async password hashing function.
+```
+
+---
+
+**Debug systematically, fix root causes, not symptoms.**

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

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