kiro-agent-team 1.0.0

package/.kiro/prompts/implement-fix.md

@@ -0,0 +1,228 @@
+---
+description: Implement fix from RCA document for GitHub issue
+argument-hint: [github-issue-id]
+allowed-tools: Read, Write, Edit, Bash(ruff:*), Bash(mypy:*), Bash(pytest:*), Bash(npm:*), Bash(bun:*)
+---
+
+# Implement Fix: GitHub Issue #$ARGUMENTS
+
+## Prerequisites
+
+**This command implements fixes for GitHub issues based on RCA documents:**
+- Working in a local Git repository with GitHub origin
+- RCA document exists at `docs/rca/issue-$ARGUMENTS.md`
+- GitHub CLI installed and authenticated (optional, for status updates)
+
+## RCA Document to Reference
+
+Read RCA: `docs/rca/issue-$ARGUMENTS.md`
+
+**Optional - View GitHub issue for context:**
+```bash
+gh issue view $ARGUMENTS
+```
+
+## Implementation Instructions
+
+### 1. Read and Understand RCA
+
+- Read the ENTIRE RCA document thoroughly
+- Review the GitHub issue details (issue #$ARGUMENTS)
+- Understand the root cause
+- Review the proposed fix strategy
+- Note all files to modify
+- Review testing requirements
+
+### 2. Verify Current State
+
+Before making changes:
+- Confirm the issue still exists
+- Check current state of affected files
+- Review any recent changes to those files
+
+### 3. Implement the Fix
+
+Following the "Proposed Fix" section of the RCA:
+
+**For each file to modify:**
+
+#### a. Read the existing file
+- Understand current implementation
+- Locate the specific code mentioned in RCA
+
+#### b. Make the fix
+- Implement the change as described in RCA
+- Follow the fix strategy exactly
+- Maintain code style and conventions
+- Add comments if the fix is non-obvious
+
+#### c. Handle related changes
+- Update any related code affected by the fix
+- Ensure consistency across the codebase
+- Update imports if needed
+
+### 4. Add/Update Tests
+
+Following the "Testing Requirements" from RCA:
+
+**Create test cases for:**
+1. Verify the fix resolves the issue
+2. Test edge cases related to the bug
+3. Ensure no regression in related functionality
+4. Test any new code paths introduced
+
+**Test file location:**
+- Follow project's test structure
+- Mirror the source file location
+- Use descriptive test names
+
+**Test implementation:**
+```python
+def test_issue_$ARGUMENTS_fix():
+    """Test that issue #$ARGUMENTS is fixed."""
+    # Arrange - set up the scenario that caused the bug
+    # Act - execute the code that previously failed
+    # Assert - verify it now works correctly
+```
+
+### 5. Run Validation
+
+Execute validation commands from RCA:
+
+```bash
+# Run linters
+[from RCA validation commands]
+
+# Run type checking
+[from RCA validation commands]
+
+# Run tests
+[from RCA validation commands]
+```
+
+**If validation fails:**
+- Fix the issues
+- Re-run validation
+- Don't proceed until all pass
+
+### 6. Verify Fix
+
+**Manually verify:**
+- Follow reproduction steps from RCA
+- Confirm issue no longer occurs
+- Test edge cases
+- Check for unintended side effects
+
+### 7. Update Documentation
+
+If needed:
+- Update code comments
+- Update API documentation
+- Update README if user-facing
+- Add notes about the fix
+
+## Output Report
+
+### Fix Implementation Summary
+
+**GitHub Issue #$ARGUMENTS**: [Brief title]
+
+**Issue URL**: [GitHub issue URL]
+
+**Root Cause** (from RCA):
+[One-line summary of root cause]
+
+### Changes Made
+
+**Files Modified:**
+1. **[file-path]**
+   - Change: [What was changed]
+   - Lines: [Line numbers]
+
+2. **[file-path]**
+   - Change: [What was changed]
+   - Lines: [Line numbers]
+
+### Tests Added
+
+**Test Files Created/Modified:**
+1. **[test-file-path]**
+   - Test cases: [List test functions added]
+
+**Test Coverage:**
+- ✅ Fix verification test
+- ✅ Edge case tests
+- ✅ Regression prevention tests
+
+### Validation Results
+
+```bash
+# Linter output
+[Show lint results]
+
+# Type check output
+[Show type check results]
+
+# Test output
+[Show test results - all passing]
+```
+
+### Verification
+
+**Manual Testing:**
+- ✅ Followed reproduction steps - issue resolved
+- ✅ Tested edge cases - all pass
+- ✅ No new issues introduced
+- ✅ Original functionality preserved
+
+### Files Summary
+
+**Total Changes:**
+- X files modified
+- Y files created (tests)
+- Z lines added
+- W lines removed
+
+### Ready for Commit
+
+All changes complete and validated. Ready for:
+```bash
+/commit
+```
+
+**Suggested commit message:**
+```
+fix(scope): resolve GitHub issue #$ARGUMENTS - [brief description]
+
+[Summary of what was fixed and how]
+
+Fixes #$ARGUMENTS
+```
+
+**Note:** Using `Fixes #$ARGUMENTS` in the commit message will automatically close the GitHub issue when merged to the default branch.
+
+### Optional: Update GitHub Issue
+
+**Add implementation comment to issue:**
+```bash
+gh issue comment $ARGUMENTS --body "Fix implemented in commit [commit-hash]. Ready for review."
+```
+
+**Update issue labels (if needed):**
+```bash
+gh issue edit $ARGUMENTS --add-label "fixed" --remove-label "bug"
+```
+
+**Close the issue (if not using auto-close via commit message):**
+```bash
+gh issue close $ARGUMENTS --comment "Fixed and merged."
+```
+
+## Notes
+
+- If the RCA document is missing or incomplete, request it be created first with `/rca $ARGUMENTS`
+- If you discover the RCA analysis was incorrect, document findings and update the RCA
+- If additional issues are found during implementation, note them for separate GitHub issues and RCAs
+- Follow project coding standards exactly
+- Ensure all validation passes before declaring complete
+- The commit message `Fixes #$ARGUMENTS` will link the commit to the GitHub issue

package/.kiro/prompts/plan-feature.md

@@ -0,0 +1,433 @@
+---
+description: "Create comprehensive feature plan with deep codebase analysis and research"
+---
+
+# Plan a new task
+
+## Feature: $ARGUMENTS
+
+## Mission
+
+Transform a feature request into a **comprehensive implementation plan** through systematic codebase analysis, external research, and strategic planning.
+
+**Core Principle**: We do NOT write code in this phase. Our goal is to create a context-rich implementation plan that enables one-pass implementation success for ai agents.
+
+**Key Philosophy**: Context is King. The plan must contain ALL information needed for implementation - patterns, mandatory reading, documentation, validation commands - so the execution agent succeeds on the first attempt.
+
+## Planning Process
+
+### Phase 1: Feature Understanding
+
+**Deep Feature Analysis:**
+
+- Extract the core problem being solved
+- Identify user value and business impact
+- Determine feature type: New Capability/Enhancement/Refactor/Bug Fix
+- Assess complexity: Low/Medium/High
+- Map affected systems and components
+
+**Create User Story Format Or Refine If Story Was Provided By The User:**
+
+```
+As a <type of user>
+I want to <action/goal>
+So that <benefit/value>
+```
+
+### Phase 2: Codebase Intelligence Gathering
+
+**Use specialized agents and parallel analysis:**
+
+**1. Project Structure Analysis**
+
+- Detect primary language(s), frameworks, and runtime versions
+- Map directory structure and architectural patterns
+- Identify service/component boundaries and integration points
+- Locate configuration files (pyproject.toml, package.json, etc.)
+- Find environment setup and build processes
+
+**2. Pattern Recognition** (Use specialized subagents when beneficial)
+
+- Search for similar implementations in codebase
+- Identify coding conventions:
+  - Naming patterns (CamelCase, snake_case, kebab-case)
+  - File organization and module structure
+  - Error handling approaches
+  - Logging patterns and standards
+- Extract common patterns for the feature's domain
+- Document anti-patterns to avoid
+- Check project-specific rules and conventions in steering documents
+
+**3. Dependency Analysis**
+
+- Catalog external libraries relevant to feature
+- Understand how libraries are integrated (check imports, configs)
+- Find relevant documentation in docs/, ai_docs/, .agents/reference or ai-wiki if available
+- Note library versions and compatibility requirements
+
+**4. Testing Patterns**
+
+- Identify test framework and structure (pytest, jest, etc.)
+- Find similar test examples for reference
+- Understand test organization (unit vs integration)
+- Note coverage requirements and testing standards
+
+**5. Integration Points**
+
+- Identify existing files that need updates
+- Determine new files that need creation and their locations
+- Map router/API registration patterns
+- Understand database/model patterns if applicable
+- Identify authentication/authorization patterns if relevant
+
+**Clarify Ambiguities:**
+
+- If requirements are unclear at this point, ask the user to clarify before you continue
+- Get specific implementation preferences (libraries, approaches, patterns)
+- Resolve architectural decisions before proceeding
+
+### Phase 3: External Research & Documentation
+
+**Use specialized subagents when beneficial for external research:**
+
+**Documentation Gathering:**
+
+- Research latest library versions and best practices
+- Find official documentation with specific section anchors
+- Locate implementation examples and tutorials
+- Identify common gotchas and known issues
+- Check for breaking changes and migration guides
+
+**Technology Trends:**
+
+- Research current best practices for the technology stack
+- Find relevant blog posts, guides, or case studies
+- Identify performance optimization patterns
+- Document security considerations
+
+**Compile Research References:**
+
+```markdown
+## Relevant Documentation
+
+- [Library Official Docs](https://example.com/docs#section)
+  - Specific feature implementation guide
+  - Why: Needed for X functionality
+- [Framework Guide](https://example.com/guide#integration)
+  - Integration patterns section
+  - Why: Shows how to connect components
+```
+
+### Phase 4: Deep Strategic Thinking
+
+**Think Harder About:**
+
+- How does this feature fit into the existing architecture?
+- What are the critical dependencies and order of operations?
+- What could go wrong? (Edge cases, race conditions, errors)
+- How will this be tested comprehensively?
+- What performance implications exist?
+- Are there security considerations?
+- How maintainable is this approach?
+
+**Design Decisions:**
+
+- Choose between alternative approaches with clear rationale
+- Design for extensibility and future modifications
+- Plan for backward compatibility if needed
+- Consider scalability implications
+
+### Phase 5: Plan Structure Generation
+
+**Create comprehensive plan with the following structure:**
+
+Whats below here is a template for you to fill for the implementation agent:
+
+```markdown
+# Feature: <feature-name>
+
+The following plan should be complete, but its important that you validate documentation and codebase patterns and task sanity before you start implementing.
+
+Pay special attention to naming of existing utils types and models. Import from the right files etc.
+
+## Feature Description
+
+<Detailed description of the feature, its purpose, and value to users>
+
+## User Story
+
+As a <type of user>
+I want to <action/goal>
+So that <benefit/value>
+
+## Problem Statement
+
+<Clearly define the specific problem or opportunity this feature addresses>
+
+## Solution Statement
+
+<Describe the proposed solution approach and how it solves the problem>
+
+## Feature Metadata
+
+**Feature Type**: [New Capability/Enhancement/Refactor/Bug Fix]
+**Estimated Complexity**: [Low/Medium/High]
+**Primary Systems Affected**: [List of main components/services]
+**Dependencies**: [External libraries or services required]
+
+---
+
+## CONTEXT REFERENCES
+
+### Relevant Codebase Files IMPORTANT: YOU MUST READ THESE FILES BEFORE IMPLEMENTING!
+
+<List files with line numbers and relevance>
+
+- `path/to/file.py` (lines 15-45) - Why: Contains pattern for X that we'll mirror
+- `path/to/model.py` (lines 100-120) - Why: Database model structure to follow
+- `path/to/test.py` - Why: Test pattern example
+
+### New Files to Create
+
+- `path/to/new_service.py` - Service implementation for X functionality
+- `path/to/new_model.py` - Data model for Y resource
+- `tests/path/to/test_new_service.py` - Unit tests for new service
+
+### Relevant Documentation YOU SHOULD READ THESE BEFORE IMPLEMENTING!
+
+- [Documentation Link 1](https://example.com/doc1#section)
+  - Specific section: Authentication setup
+  - Why: Required for implementing secure endpoints
+- [Documentation Link 2](https://example.com/doc2#integration)
+  - Specific section: Database integration
+  - Why: Shows proper async database patterns
+
+### Patterns to Follow
+
+<Specific patterns extracted from codebase - include actual code examples from the project>
+
+**Naming Conventions:** (for example)
+
+**Error Handling:** (for example)
+
+**Logging Pattern:** (for example)
+
+**Other Relevant Patterns:** (for example)
+
+---
+
+## IMPLEMENTATION PLAN
+
+### Phase 1: Foundation
+
+<Describe foundational work needed before main implementation>
+
+**Tasks:**
+
+- Set up base structures (schemas, types, interfaces)
+- Configure necessary dependencies
+- Create foundational utilities or helpers
+
+### Phase 2: Core Implementation
+
+<Describe the main implementation work>
+
+**Tasks:**
+
+- Implement core business logic
+- Create service layer components
+- Add API endpoints or interfaces
+- Implement data models
+
+### Phase 3: Integration
+
+<Describe how feature integrates with existing functionality>
+
+**Tasks:**
+
+- Connect to existing routers/handlers
+- Register new components
+- Update configuration files
+- Add middleware or interceptors if needed
+
+### Phase 4: Testing & Validation
+
+<Describe testing approach>
+
+**Tasks:**
+
+- Implement unit tests for each component
+- Create integration tests for feature workflow
+- Add edge case tests
+- Validate against acceptance criteria
+
+---
+
+## STEP-BY-STEP TASKS
+
+IMPORTANT: Execute every task in order, top to bottom. Each task is atomic and independently testable.
+
+### Task Format Guidelines
+
+Use information-dense keywords for clarity:
+
+- **CREATE**: New files or components
+- **UPDATE**: Modify existing files
+- **ADD**: Insert new functionality into existing code
+- **REMOVE**: Delete deprecated code
+- **REFACTOR**: Restructure without changing behavior
+- **MIRROR**: Copy pattern from elsewhere in codebase
+
+### {ACTION} {target_file}
+
+- **IMPLEMENT**: {Specific implementation detail}
+- **PATTERN**: {Reference to existing pattern - file:line}
+- **IMPORTS**: {Required imports and dependencies}
+- **GOTCHA**: {Known issues or constraints to avoid}
+- **VALIDATE**: `{executable validation command}`
+
+<Continue with all tasks in dependency order...>
+
+---
+
+## TESTING STRATEGY
+
+<Define testing approach based on project's test framework and patterns discovered in during research>
+
+### Unit Tests
+
+<Scope and requirements based on project standards>
+
+Design unit tests with fixtures and assertions following existing testing approaches
+
+### Integration Tests
+
+<Scope and requirements based on project standards>
+
+### Edge Cases
+
+<List specific edge cases that must be tested for this feature>
+
+---
+
+## VALIDATION COMMANDS
+
+<Define validation commands based on project's tools discovered in Phase 2>
+
+Execute every command to ensure zero regressions and 100% feature correctness.
+
+### Level 1: Syntax & Style
+
+<Project-specific linting and formatting commands>
+
+### Level 2: Unit Tests
+
+<Project-specific unit test commands>
+
+### Level 3: Integration Tests
+
+<Project-specific integration test commands>
+
+### Level 4: Manual Validation
+
+<Feature-specific manual testing steps - API calls, UI testing, etc.>
+
+### Level 5: Additional Validation (Optional)
+
+<MCP servers or additional CLI tools if available>
+
+---
+
+## ACCEPTANCE CRITERIA
+
+<List specific, measurable criteria that must be met for completion>
+
+- [ ] Feature implements all specified functionality
+- [ ] All validation commands pass with zero errors
+- [ ] Unit test coverage meets requirements (80%+)
+- [ ] Integration tests verify end-to-end workflows
+- [ ] Code follows project conventions and patterns
+- [ ] No regressions in existing functionality
+- [ ] Documentation is updated (if applicable)
+- [ ] Performance meets requirements (if applicable)
+- [ ] Security considerations addressed (if applicable)
+
+---
+
+## COMPLETION CHECKLIST
+
+- [ ] All tasks completed in order
+- [ ] Each task validation passed immediately
+- [ ] All validation commands executed successfully
+- [ ] Full test suite passes (unit + integration)
+- [ ] No linting or type checking errors
+- [ ] Manual testing confirms feature works
+- [ ] Acceptance criteria all met
+- [ ] Code reviewed for quality and maintainability
+
+---
+
+## NOTES
+
+<Additional context, design decisions, trade-offs>
+```
+
+## Output Format
+
+**Filename**: `.kiro/features/{kebab-case-descriptive-name}.md`
+
+- Replace `{kebab-case-descriptive-name}` with short, descriptive feature name
+- Examples: `add-user-authentication.md`, `implement-search-api.md`, `refactor-database-layer.md`
+
+**Directory**: Create `.kiro/features/` if it doesn't exist
+
+## Quality Criteria
+
+### Context Completeness ✓
+
+- [ ] All necessary patterns identified and documented
+- [ ] External library usage documented with links
+- [ ] Integration points clearly mapped
+- [ ] Gotchas and anti-patterns captured
+- [ ] Every task has executable validation command
+
+### Implementation Ready ✓
+
+- [ ] Another developer could execute without additional context
+- [ ] Tasks ordered by dependency (can execute top-to-bottom)
+- [ ] Each task is atomic and independently testable
+- [ ] Pattern references include specific file:line numbers
+
+### Pattern Consistency ✓
+
+- [ ] Tasks follow existing codebase conventions
+- [ ] New patterns justified with clear rationale
+- [ ] No reinvention of existing patterns or utils
+- [ ] Testing approach matches project standards
+
+### Information Density ✓
+
+- [ ] No generic references (all specific and actionable)
+- [ ] URLs include section anchors when applicable
+- [ ] Task descriptions use codebase keywords
+- [ ] Validation commands are non interactive executable
+
+## Success Metrics
+
+**One-Pass Implementation**: Execution agent can complete feature without additional research or clarification
+
+**Validation Complete**: Every task has at least one working validation command
+
+**Context Rich**: The Plan passes "No Prior Knowledge Test" - someone unfamiliar with codebase can implement using only Plan content
+
+**Confidence Score**: #/10 that execution will succeed on first attempt
+
+## Report
+
+After creating the Plan, provide:
+
+- Summary of feature and approach
+- Full path to created Plan file
+- Complexity assessment
+- Key implementation risks or considerations
+- Estimated confidence score for one-pass success. If confidence score is not 10/10, explain why and what it would take to make it a 10/10