amazingteam 3.0.0

package/.ai-team/opencode.template.jsonc

@@ -0,0 +1,216 @@
+{
+  "$schema": "https://opencode.ai/schema.json",
+  "version": "{{AI_TEAM_VERSION}}",
+  "project": {
+    "name": "{{PROJECT_NAME}}",
+    "description": "{{PROJECT_DESCRIPTION}}",
+    "language": "{{LANGUAGE}}",
+    "framework": "{{FRAMEWORK}}"
+  },
+  "agents": {
+    "planner": {
+      "description": "Decomposes tasks and coordinates workflow progression",
+      "model": "default",
+      "skills": ["task-breakdown-and-dispatch"],
+      "commands": [],
+      "memory": {
+        "read": ["docs/", "AGENTS.md", ".ai-team/memory/planner/", ".ai-team/memory/architect/", ".ai-team/memory/triage/", ".ai-team/memory/failures/", "tasks/"],
+        "write": [".ai-team/memory/planner/", "tasks/{task_id}/task.yaml"]
+      }
+    },
+    "architect": {
+      "description": "Analyzes requirements and designs solutions",
+      "model": "default",
+      "skills": ["repo-architecture-reader"],
+      "commands": ["/design"],
+      "memory": {
+        "read": ["docs/", "AGENTS.md", ".ai-team/memory/planner/", ".ai-team/memory/architect/", ".ai-team/memory/developer/", ".ai-team/memory/failures/", "tasks/"],
+        "write": [".ai-team/memory/architect/", "tasks/{task_id}/analysis.md", "tasks/{task_id}/design.md"]
+      }
+    },
+    "developer": {
+      "description": "Implements features and fixes bugs",
+      "model": "default",
+      "skills": ["test-first-feature-dev", "bugfix-playbook"],
+      "commands": ["/implement"],
+      "memory": {
+        "read": ["docs/", "AGENTS.md", ".ai-team/memory/planner/", ".ai-team/memory/architect/", ".ai-team/memory/developer/", ".ai-team/memory/failures/", "tasks/{task_id}/"],
+        "write": [".ai-team/memory/developer/", "tasks/{task_id}/implementation.md", "src/", "tests/"]
+      }
+    },
+    "qa": {
+      "description": "Validates implementations and ensures quality",
+      "model": "default",
+      "skills": ["test-first-feature-dev", "regression-checklist"],
+      "commands": ["/test"],
+      "memory": {
+        "read": ["docs/", "AGENTS.md", ".ai-team/memory/planner/", ".ai-team/memory/architect/", ".ai-team/memory/qa/", ".ai-team/memory/failures/", "tasks/{task_id}/"],
+        "write": [".ai-team/memory/qa/", "tasks/{task_id}/validation.md", "tests/"]
+      }
+    },
+    "reviewer": {
+      "description": "Reviews code for quality and correctness",
+      "model": "default",
+      "skills": ["safe-refactor-checklist", "regression-checklist", "release-readiness-check"],
+      "commands": ["/review", "/release-check"],
+      "memory": {
+        "read": ["docs/", "AGENTS.md", ".ai-team/memory/", ".ai-team/memory/failures/", "tasks/{task_id}/"],
+        "write": [".ai-team/memory/reviewer/", "tasks/{task_id}/review.md", "tasks/{task_id}/release.md"]
+      }
+    },
+    "triage": {
+      "description": "Classifies issues and performs first-pass debug analysis",
+      "model": "default",
+      "skills": ["issue-triage", "bugfix-playbook"],
+      "commands": ["/triage"],
+      "memory": {
+        "read": ["docs/", "AGENTS.md", ".ai-team/memory/triage/", ".ai-team/memory/failures/", "tasks/{task_id}/"],
+        "write": [".ai-team/memory/triage/", "tasks/{task_id}/"]
+      }
+    },
+    "ci-analyst": {
+      "description": "Investigates CI failures and documents patterns",
+      "model": "default",
+      "skills": ["ci-failure-analysis", "bugfix-playbook"],
+      "commands": ["/ci-analyze"],
+      "memory": {
+        "read": ["docs/", "AGENTS.md", ".ai-team/memory/ci-analyst/", ".ai-team/memory/failures/", "tasks/{task_id}/", "docs/runbooks/ci/"],
+        "write": [".ai-team/memory/ci-analyst/", ".ai-team/memory/failures/", "tasks/{task_id}/"]
+      }
+    }
+  },
+  "skills": {
+    "repo-architecture-reader": {
+      "path": ".ai-team/skills/repo-architecture-reader/skill.md"
+    },
+    "bugfix-playbook": {
+      "path": ".ai-team/skills/bugfix-playbook/skill.md"
+    },
+    "test-first-feature-dev": {
+      "path": ".ai-team/skills/test-first-feature-dev/skill.md"
+    },
+    "safe-refactor-checklist": {
+      "path": ".ai-team/skills/safe-refactor-checklist/skill.md"
+    },
+    "task-breakdown-and-dispatch": {
+      "path": ".ai-team/skills/task-breakdown-and-dispatch/skill.md"
+    },
+    "issue-triage": {
+      "path": ".ai-team/skills/issue-triage/skill.md"
+    },
+    "ci-failure-analysis": {
+      "path": ".ai-team/skills/ci-failure-analysis/skill.md"
+    },
+    "regression-checklist": {
+      "path": ".ai-team/skills/regression-checklist/skill.md"
+    },
+    "release-readiness-check": {
+      "path": ".ai-team/skills/release-readiness-check/skill.md"
+    }
+  },
+  "commands": {
+    "/triage": {
+      "path": ".ai-team/commands/triage.md",
+      "agent": "triage"
+    },
+    "/design": {
+      "path": ".ai-team/commands/design.md",
+      "agent": "architect"
+    },
+    "/implement": {
+      "path": ".ai-team/commands/implement.md",
+      "agent": "developer"
+    },
+    "/test": {
+      "path": ".ai-team/commands/test.md",
+      "agent": "qa"
+    },
+    "/review": {
+      "path": ".ai-team/commands/review.md",
+      "agent": "reviewer"
+    },
+    "/ci-analyze": {
+      "path": ".ai-team/commands/ci-analyze.md",
+      "agent": "ci-analyst"
+    },
+    "/release-check": {
+      "path": ".ai-team/commands/release-check.md",
+      "agent": "reviewer"
+    }
+  },
+  "workflows": {
+    "feature": ["planner", "architect", "developer", "qa", "reviewer"],
+    "bugfix": ["triage", "architect", "developer", "qa", "reviewer"],
+    "refactor": ["architect", "developer", "reviewer"],
+    "ci-failure": ["ci-analyst", "developer", "qa"],
+    "release": ["reviewer"]
+  },
+  "memory": {
+    "global": {
+      "locations": ["docs/", "AGENTS.md"],
+      "writeRequiresApproval": true
+    },
+    "role": {
+      "base_path": ".ai-team/memory",
+      "roles": {
+        "planner": {
+          "files": ["decomposition_notes.md", "flow_rules.md"]
+        },
+        "architect": {
+          "files": ["architecture_notes.md", "module_map.md", "design_rationale.md"]
+        },
+        "developer": {
+          "files": ["implementation_notes.md", "bug_investigation.md", "build_issues.md"]
+        },
+        "qa": {
+          "files": ["test_strategy.md", "regression_cases.md", "validation_notes.md"]
+        },
+        "reviewer": {
+          "files": ["review_notes.md", "quality_rules.md", "recurring_risks.md"]
+        },
+        "triage": {
+          "files": ["classification_heuristics.md", "debug_notes.md"]
+        },
+        "ci-analyst": {
+          "files": ["failure_patterns.md", "runbook_references.md"]
+        }
+      }
+    },
+    "failures": {
+      "path": ".ai-team/memory/failures",
+      "files": ["failure_library.md"],
+      "writableBy": ["ci-analyst"]
+    },
+    "task": {
+      "base_path": "tasks",
+      "naming": "issue-{issue_id}",
+      "files": ["task.yaml", "analysis.md", "design.md", "implementation.md", "validation.md", "review.md", "release.md"],
+      "autoCreate": true,
+      "preserveAfterCompletion": true
+    }
+  },
+  "rules": {
+    "maxChangesPerCommit": 10,
+    "requireTests": true,
+    "requireReview": true,
+    "autoMerge": false,
+    "memoryIsolation": true,
+    "protectedPaths": ["docs/architecture/", "docs/decisions/"],
+    "humanApprovalRequired": ["architecture changes", "release operations", "breaking changes"]
+  },
+  "integrations": {
+    "github": {
+      "enabled": true,
+      "autoLabel": true,
+      "autoAssign": true
+    },
+    "ci": {
+      "enabled": true,
+      "requirePassing": true,
+      "failureAnalysis": {
+        "enabled": true,
+        "agent": "ci-analyst"
+      }
+    }
+  }
+}

package/.ai-team/skills/bugfix-playbook/skill.md

@@ -0,0 +1,174 @@
+# Bug Fix Playbook
+
+## Purpose
+
+This skill provides a systematic approach to identifying, analyzing, and fixing bugs.
+
+## When to Use
+
+- Fixing reported bugs
+- Debugging production issues
+- Investigating test failures
+- Resolving regression issues
+
+## Steps
+
+### 1. Reproduce the Bug
+
+```
+1. Document exact reproduction steps
+2. Verify the bug exists in current version
+3. Identify if bug is environment-specific
+4. Create minimal reproduction case
+5. Capture relevant logs/errors
+```
+
+### 2. Gather Information
+
+```
+1. Review bug report details
+2. Check for related issues (past or present)
+3. Review recent changes that might be related
+4. Collect stack traces and error logs
+5. Note any user-reported symptoms
+```
+
+### 3. Locate the Source
+
+```
+1. Use stack traces to identify locations
+2. Search for error messages in codebase
+3. Trace execution flow from entry point
+4. Use debugging tools (logs, breakpoints, etc.)
+5. Identify the specific file and function
+```
+
+### 4. Analyze the Root Cause
+
+```
+1. Understand the expected behavior
+2. Compare with actual behavior
+3. Identify why the discrepancy occurs
+4. Consider edge cases
+5. Document the root cause clearly
+```
+
+### 5. Design the Fix
+
+```
+1. Determine the minimal change needed
+2. Consider potential side effects
+3. Think about similar issues elsewhere
+4. Plan any necessary refactoring
+5. Document the fix approach
+```
+
+### 6. Implement the Fix
+
+```
+1. Write the fix (minimal, targeted)
+2. Add/update tests
+3. Verify fix resolves the issue
+4. Run all tests to catch regressions
+5. Update documentation if needed
+```
+
+### 7. Verify the Solution
+
+```
+1. Reproduce original bug (should fail before fix)
+2. Apply fix
+3. Verify bug is resolved
+4. Run test suite
+5. Manual testing of affected area
+6. Check for related issues
+```
+
+## Root Cause Analysis Template
+
+```markdown
+## Bug Analysis: [Bug Title]
+
+### Issue
+[Description of the bug]
+
+### Symptoms
+- [Symptom 1]
+- [Symptom 2]
+
+### Root Cause
+[Explanation of why the bug occurs]
+
+### Affected Code
+- `file_path:line_number` - [Description]
+
+### Fix Approach
+[Description of how to fix]
+
+### Risk Assessment
+- **Risk Level**: [Low/Medium/High]
+- **Impact if unfixed**: [Description]
+- **Potential side effects**: [Description]
+
+### Tests to Add
+1. [Test case 1]
+2. [Test case 2]
+```
+
+## Commit Message Template
+
+```
+fix(scope): brief description of the fix
+
+- What was the issue
+- What was the root cause
+- How it was fixed
+
+Fixes #issue-number
+```
+
+## Checklist
+
+- [ ] Bug reproduced
+- [ ] Root cause identified
+- [ ] Fix implemented (minimal change)
+- [ ] Tests added for the bug
+- [ ] All tests pass
+- [ ] No regressions detected
+- [ ] Documentation updated (if needed)
+- [ ] PR created with proper description
+
+## Common Bug Patterns
+
+### Null/Undefined Errors
+- Missing null checks
+- Uninitialized variables
+- Optional chaining issues
+
+### Logic Errors
+- Off-by-one errors
+- Incorrect conditions
+- Missing edge cases
+
+### Async Issues
+- Race conditions
+- Unhandled promises
+- Incorrect async/await usage
+
+### State Issues
+- Stale state
+- Incorrect state updates
+- Missing state reset
+
+### Integration Issues
+- API contract mismatch
+- Version incompatibility
+- Environment differences
+
+## Best Practices
+
+- Fix the root cause, not the symptom
+- Add regression tests for all bugs
+- Keep fixes minimal and focused
+- Update documentation if behavior changes
+- Consider if similar bugs exist elsewhere

package/.ai-team/skills/ci-failure-analysis/skill.md

@@ -0,0 +1,176 @@
+# CI Failure Analysis
+
+## Purpose
+
+This skill provides systematic investigation and resolution of CI pipeline failures.
+
+## When to Use
+
+- CI pipeline failure
+- Flaky test investigation
+- Build failure diagnosis
+- Infrastructure issue investigation
+
+## Steps
+
+### 1. Gather Failure Context
+
+```
+1. Identify failed pipeline/stage
+2. Collect error messages and logs
+3. Note failure timestamp and branch
+4. Identify commit that triggered failure
+5. Check if failure is intermittent or consistent
+```
+
+### 2. Classify Failure Type
+
+```
+1. Build failure:
+   - Compilation error
+   - Dependency resolution failure
+   - Configuration error
+2. Test failure:
+   - Unit test failure
+   - Integration test failure
+   - E2E test failure
+3. Infrastructure failure:
+   - Resource unavailability
+   - Timeout
+   - Network issue
+4. Code quality failure:
+   - Lint error
+   - Type error
+   - Security scan failure
+```
+
+### 3. Analyze Root Cause
+
+```
+1. Examine error stack trace
+2. Check recent changes to affected files
+3. Compare with previous successful builds
+4. Identify environment differences
+5. Check for resource constraints
+```
+
+### 4. Check Known Patterns
+
+```
+1. Query failure library for similar issues
+2. Check docs/runbooks/ci/ for known problems
+3. Review .ai-team/memory/failures/ for patterns
+4. Identify if this is a recurring issue
+5. Note any infrastructure issues
+```
+
+### 5. Determine Fix Strategy
+
+```
+1. Code fix:
+   - Identify files to change
+   - Determine minimal fix
+   - Create fix branch
+2. Configuration fix:
+   - Identify config files
+   - Update settings
+   - Test locally
+3. Infrastructure fix:
+   - Document infrastructure issue
+   - Request infrastructure support
+   - Add workaround if possible
+```
+
+### 6. Implement and Verify
+
+```
+1. Apply fix
+2. Run relevant tests locally
+3. Push fix to CI
+4. Monitor pipeline
+5. Document resolution
+```
+
+### 7. Update Knowledge Base
+
+```
+1. If new failure pattern: add to failure library
+2. If infrastructure issue: update runbook
+3. Document solution for future reference
+4. Update CI memory if recurring issue
+```
+
+## Failure Analysis Report Template
+
+```markdown
+## CI Failure Analysis: [Build #]
+
+### Summary
+- **Pipeline**: [Pipeline name]
+- **Stage**: [Failed stage]
+- **Branch**: [Branch name]
+- **Commit**: [Commit hash]
+- **Timestamp**: [Failure time]
+
+### Failure Classification
+- **Type**: build | test | infrastructure | quality
+- **Severity**: blocking | non-blocking
+- **Pattern**: new | recurring | flaky
+
+### Error Details
+```
+[Paste relevant error logs]
+```
+
+### Root Cause
+[Explanation of why the failure occurred]
+
+### Affected Files
+- `path/to/file.ts` - [Impact description]
+
+### Resolution
+- **Fix Type**: code | config | infrastructure
+- **Fix Description**: [How to fix]
+- **PR/Commit**: [Reference to fix]
+
+### Prevention
+[How to prevent this in the future]
+
+### Related Issues
+- #[issue number] - [description]
+```
+
+## Failure Classification Matrix
+
+| Error Type | Likely Cause | Investigation Path |
+|------------|--------------|---------------------|
+| Compilation error | Syntax/type error | Check error line, recent changes |
+| Dependency error | Missing/incompatible package | Check package.json, lock file |
+| Test assertion failure | Code logic error | Check test, implementation |
+| Test timeout | Slow operation/hang | Profile, check resources |
+| Flaky test | Race condition/timing | Check async code, mocks |
+| Out of memory | Resource leak | Check memory usage, leaks |
+| Network timeout | External dependency | Check service status, add retry |
+| Permission denied | Access control | Check permissions, CI config |
+
+## Checklist
+
+- [ ] Failure context gathered
+- [ ] Failure type classified
+- [ ] Root cause analyzed
+- [ ] Known patterns checked
+- [ ] Fix strategy determined
+- [ ] Fix implemented
+- [ ] CI verification passed
+- [ ] Knowledge base updated
+- [ ] Failure library updated (if new pattern)
+
+## Best Practices
+
+- Always check recent commits first
+- Compare with last successful build
+- Check if failure is environment-specific
+- Document all findings, even negative ones
+- Add flaky tests to known flaky list
+- Create regression tests for bug fixes
+- Update runbooks for recurring issues