kiro-agent-team 1.0.0

package/.kiro/prompts/execute-testing.md

@@ -0,0 +1,528 @@
+# Execute: Testing Implementation
+
+## Testing-Specific Implementation Framework
+
+This specialized execution framework is optimized for testing and quality assurance tasks, focusing on comprehensive test coverage, quality validation, and systematic testing strategies.
+
+## Testing Implementation Process
+
+### Phase 1: Testing Requirements Analysis
+**Testing-Specific Analysis:**
+- Test coverage requirements and quality standards
+- Testing scope and strategy definition
+- Performance and reliability testing needs
+- Accessibility and compliance testing requirements
+- Risk assessment and critical path identification
+- Testing tool and framework selection
+
+**Questions to Address:**
+- What types of testing are required for this implementation?
+- What are the quality gates and acceptance criteria?
+- What test coverage levels need to be achieved?
+- What performance benchmarks must be met?
+- What accessibility and compliance standards apply?
+- What are the critical user paths that must be validated?
+
+### Phase 2: Testing Strategy Design
+**Testing Architecture Planning:**
+- Test pyramid strategy (unit, integration, e2e)
+- Test data management and fixture design
+- Testing environment setup and configuration
+- Continuous integration and automated testing
+- Performance testing and benchmarking approach
+- Quality metrics and reporting strategy
+
+**Testing Design Decisions:**
+- Choose appropriate testing frameworks and tools
+- Define test data strategies and management
+- Plan testing environments and infrastructure
+- Establish quality gates and validation criteria
+- Design performance testing and monitoring
+
+### Phase 3: Implementation
+**Systematic Testing Implementation:**
+
+#### Unit Testing Implementation
+```typescript
+// Example comprehensive unit test suite
+describe('TaskService', () => {
+  let taskService: TaskService;
+  let mockRepository: jest.Mocked<TaskRepository>;
+  
+  beforeEach(() => {
+    mockRepository = createMockRepository();
+    taskService = new TaskService(mockRepository);
+  });
+
+  describe('createTask', () => {
+    it('should create task with valid data', async () => {
+      const taskData = {
+        title: 'Test Task',
+        description: 'Test Description',
+        assigneeId: 'user-123'
+      };
+      
+      const expectedTask = { id: 'task-456', ...taskData };
+      mockRepository.create.mockResolvedValue(expectedTask);
+      
+      const result = await taskService.createTask(taskData);
+      
+      expect(result).toEqual(expectedTask);
+      expect(mockRepository.create).toHaveBeenCalledWith(taskData);
+    });
+
+    it('should validate required fields', async () => {
+      const invalidData = { description: 'Missing title' };
+      
+      await expect(taskService.createTask(invalidData))
+        .rejects.toThrow('Title is required');
+    });
+
+    it('should handle repository errors gracefully', async () => {
+      const taskData = { title: 'Test', description: 'Test' };
+      mockRepository.create.mockRejectedValue(new Error('Database error'));
+      
+      await expect(taskService.createTask(taskData))
+        .rejects.toThrow('Failed to create task');
+    });
+  });
+
+  describe('updateTaskStatus', () => {
+    it('should update task status with audit trail', async () => {
+      const taskId = 'task-123';
+      const newStatus = 'completed';
+      const userId = 'user-456';
+      
+      const existingTask = { id: taskId, status: 'in-progress' };
+      const updatedTask = { ...existingTask, status: newStatus };
+      
+      mockRepository.findById.mockResolvedValue(existingTask);
+      mockRepository.update.mockResolvedValue(updatedTask);
+      
+      const result = await taskService.updateTaskStatus(taskId, newStatus, userId);
+      
+      expect(result.status).toBe(newStatus);
+      expect(mockRepository.update).toHaveBeenCalledWith(taskId, { status: newStatus });
+      // Verify audit trail creation
+      expect(mockRepository.createAuditEntry).toHaveBeenCalledWith({
+        taskId,
+        action: 'status_change',
+        oldValue: 'in-progress',
+        newValue: newStatus,
+        userId
+      });
+    });
+  });
+});
+```
+
+#### Integration Testing Implementation
+```typescript
+// Example API integration test
+describe('Task API Integration', () => {
+  let app: Application;
+  let testDb: TestDatabase;
+  let authToken: string;
+
+  beforeAll(async () => {
+    testDb = await setupTestDatabase();
+    app = createTestApp(testDb);
+    authToken = await getTestAuthToken();
+  });
+
+  afterAll(async () => {
+    await testDb.cleanup();
+  });
+
+  beforeEach(async () => {
+    await testDb.reset();
+  });
+
+  describe('POST /api/tasks', () => {
+    it('should create task with authentication', async () => {
+      const taskData = {
+        title: 'Integration Test Task',
+        description: 'Testing API integration',
+        priority: 'high'
+      };
+
+      const response = await request(app)
+        .post('/api/tasks')
+        .set('Authorization', `Bearer ${authToken}`)
+        .send(taskData)
+        .expect(201);
+
+      expect(response.body).toMatchObject({
+        success: true,
+        data: expect.objectContaining({
+          id: expect.any(String),
+          title: taskData.title,
+          description: taskData.description,
+          priority: taskData.priority,
+          status: 'todo',
+          createdAt: expect.any(String)
+        })
+      });
+
+      // Verify task was actually created in database
+      const createdTask = await testDb.tasks.findById(response.body.data.id);
+      expect(createdTask).toBeTruthy();
+      expect(createdTask.title).toBe(taskData.title);
+    });
+
+    it('should reject unauthenticated requests', async () => {
+      const taskData = { title: 'Unauthorized Task' };
+
+      await request(app)
+        .post('/api/tasks')
+        .send(taskData)
+        .expect(401);
+    });
+
+    it('should validate input data', async () => {
+      const invalidData = { description: 'Missing title' };
+
+      const response = await request(app)
+        .post('/api/tasks')
+        .set('Authorization', `Bearer ${authToken}`)
+        .send(invalidData)
+        .expect(400);
+
+      expect(response.body.error).toContain('title');
+    });
+  });
+
+  describe('GET /api/tasks', () => {
+    beforeEach(async () => {
+      // Seed test data
+      await testDb.tasks.createMany([
+        { title: 'Task 1', status: 'todo', assigneeId: 'user-1' },
+        { title: 'Task 2', status: 'in-progress', assigneeId: 'user-1' },
+        { title: 'Task 3', status: 'completed', assigneeId: 'user-2' }
+      ]);
+    });
+
+    it('should return user tasks with pagination', async () => {
+      const response = await request(app)
+        .get('/api/tasks?page=1&limit=2')
+        .set('Authorization', `Bearer ${authToken}`)
+        .expect(200);
+
+      expect(response.body).toMatchObject({
+        success: true,
+        data: expect.arrayContaining([
+          expect.objectContaining({ title: expect.any(String) })
+        ]),
+        pagination: {
+          page: 1,
+          limit: 2,
+          total: expect.any(Number),
+          totalPages: expect.any(Number)
+        }
+      });
+    });
+
+    it('should filter tasks by status', async () => {
+      const response = await request(app)
+        .get('/api/tasks?status=completed')
+        .set('Authorization', `Bearer ${authToken}`)
+        .expect(200);
+
+      expect(response.body.data).toHaveLength(1);
+      expect(response.body.data[0].status).toBe('completed');
+    });
+  });
+});
+```
+
+#### End-to-End Testing Implementation
+```typescript
+// Example E2E test with Playwright
+import { test, expect } from '@playwright/test';
+
+test.describe('Task Management Workflow', () => {
+  test.beforeEach(async ({ page }) => {
+    // Setup test data and authenticate
+    await page.goto('/login');
+    await page.fill('[data-testid="email"]', 'test@example.com');
+    await page.fill('[data-testid="password"]', 'testpassword');
+    await page.click('[data-testid="login-button"]');
+    await expect(page).toHaveURL('/dashboard');
+  });
+
+  test('should complete full task lifecycle', async ({ page }) => {
+    // Create new task
+    await page.click('[data-testid="create-task-button"]');
+    await page.fill('[data-testid="task-title"]', 'E2E Test Task');
+    await page.fill('[data-testid="task-description"]', 'Testing complete workflow');
+    await page.selectOption('[data-testid="task-priority"]', 'high');
+    await page.click('[data-testid="save-task-button"]');
+
+    // Verify task appears in list
+    await expect(page.locator('[data-testid="task-list"]')).toContainText('E2E Test Task');
+    
+    // Update task status
+    const taskCard = page.locator('[data-testid="task-card"]').filter({ hasText: 'E2E Test Task' });
+    await taskCard.locator('[data-testid="status-dropdown"]').selectOption('in-progress');
+    
+    // Verify status update
+    await expect(taskCard.locator('[data-testid="task-status"]')).toHaveText('In Progress');
+    
+    // Complete task
+    await taskCard.locator('[data-testid="status-dropdown"]').selectOption('completed');
+    await expect(taskCard.locator('[data-testid="task-status"]')).toHaveText('Completed');
+    
+    // Verify task completion timestamp
+    await expect(taskCard.locator('[data-testid="completed-at"]')).toBeVisible();
+  });
+
+  test('should handle task validation errors', async ({ page }) => {
+    await page.click('[data-testid="create-task-button"]');
+    
+    // Try to save without required fields
+    await page.click('[data-testid="save-task-button"]');
+    
+    // Verify validation errors
+    await expect(page.locator('[data-testid="title-error"]')).toHaveText('Title is required');
+    
+    // Fill title and try again
+    await page.fill('[data-testid="task-title"]', 'Valid Title');
+    await page.click('[data-testid="save-task-button"]');
+    
+    // Should succeed now
+    await expect(page.locator('[data-testid="task-list"]')).toContainText('Valid Title');
+  });
+
+  test('should support task search and filtering', async ({ page }) => {
+    // Search for specific task
+    await page.fill('[data-testid="search-input"]', 'E2E Test');
+    await page.press('[data-testid="search-input"]', 'Enter');
+    
+    // Verify search results
+    const searchResults = page.locator('[data-testid="task-card"]');
+    await expect(searchResults).toHaveCount(1);
+    await expect(searchResults.first()).toContainText('E2E Test Task');
+    
+    // Filter by status
+    await page.selectOption('[data-testid="status-filter"]', 'completed');
+    await expect(page.locator('[data-testid="task-card"]')).toHaveCount(1);
+    
+    // Clear filters
+    await page.click('[data-testid="clear-filters"]');
+    await expect(page.locator('[data-testid="task-card"]')).toHaveCount.toBeGreaterThan(1);
+  });
+});
+```
+
+### Phase 4: Performance Testing Implementation
+**Performance Testing Strategy:**
+- Load testing for API endpoints
+- Stress testing for concurrent users
+- Performance regression testing
+- Database query performance validation
+- Frontend rendering performance testing
+- Memory leak detection and prevention
+
+**Performance Testing Examples:**
+```typescript
+// API Load Testing
+describe('API Performance Tests', () => {
+  test('should handle concurrent task creation', async () => {
+    const concurrentRequests = 50;
+    const taskData = { title: 'Load Test Task', description: 'Performance testing' };
+    
+    const startTime = Date.now();
+    
+    const promises = Array(concurrentRequests).fill(null).map(() =>
+      request(app)
+        .post('/api/tasks')
+        .set('Authorization', `Bearer ${authToken}`)
+        .send(taskData)
+    );
+    
+    const responses = await Promise.all(promises);
+    const endTime = Date.now();
+    
+    // Verify all requests succeeded
+    responses.forEach(response => {
+      expect(response.status).toBe(201);
+    });
+    
+    // Verify performance requirements
+    const totalTime = endTime - startTime;
+    const avgResponseTime = totalTime / concurrentRequests;
+    
+    expect(avgResponseTime).toBeLessThan(500); // < 500ms average
+    expect(totalTime).toBeLessThan(5000); // < 5s total
+  });
+});
+
+// Frontend Performance Testing
+test('should render task list within performance budget', async ({ page }) => {
+  // Navigate to page with many tasks
+  await page.goto('/tasks?limit=100');
+  
+  // Measure performance metrics
+  const metrics = await page.evaluate(() => {
+    return {
+      lcp: performance.getEntriesByType('largest-contentful-paint')[0]?.startTime,
+      fid: performance.getEntriesByType('first-input')[0]?.processingStart,
+      cls: performance.getEntriesByType('layout-shift').reduce((sum, entry) => sum + entry.value, 0)
+    };
+  });
+  
+  // Verify Core Web Vitals
+  expect(metrics.lcp).toBeLessThan(2500); // LCP < 2.5s
+  expect(metrics.fid).toBeLessThan(100);  // FID < 100ms
+  expect(metrics.cls).toBeLessThan(0.1);  // CLS < 0.1
+});
+```
+
+### Phase 5: Accessibility Testing Implementation
+**Accessibility Testing Strategy:**
+- Automated accessibility scanning
+- Keyboard navigation testing
+- Screen reader compatibility testing
+- Color contrast validation
+- ARIA attribute verification
+- Focus management testing
+
+**Accessibility Testing Examples:**
+```typescript
+// Automated Accessibility Testing
+import { axe, toHaveNoViolations } from 'jest-axe';
+
+expect.extend(toHaveNoViolations);
+
+describe('Accessibility Tests', () => {
+  test('should have no accessibility violations', async () => {
+    const { container } = render(<TaskList tasks={mockTasks} />);
+    const results = await axe(container);
+    expect(results).toHaveNoViolations();
+  });
+
+  test('should support keyboard navigation', async ({ page }) => {
+    await page.goto('/tasks');
+    
+    // Tab through interactive elements
+    await page.keyboard.press('Tab');
+    await expect(page.locator('[data-testid="create-task-button"]')).toBeFocused();
+    
+    await page.keyboard.press('Tab');
+    await expect(page.locator('[data-testid="search-input"]')).toBeFocused();
+    
+    // Test keyboard activation
+    await page.keyboard.press('Enter');
+    await expect(page.locator('[data-testid="task-modal"]')).toBeVisible();
+    
+    // Test escape key
+    await page.keyboard.press('Escape');
+    await expect(page.locator('[data-testid="task-modal"]')).not.toBeVisible();
+  });
+
+  test('should provide proper ARIA labels', async ({ page }) => {
+    await page.goto('/tasks');
+    
+    // Verify ARIA labels exist
+    await expect(page.locator('[aria-label="Create new task"]')).toBeVisible();
+    await expect(page.locator('[aria-label="Search tasks"]')).toBeVisible();
+    
+    // Verify screen reader announcements
+    const taskCard = page.locator('[data-testid="task-card"]').first();
+    await expect(taskCard).toHaveAttribute('role', 'article');
+    await expect(taskCard).toHaveAttribute('aria-labelledby');
+  });
+});
+```
+
+### Phase 6: Quality Metrics and Reporting
+**Quality Metrics Collection:**
+- Test coverage analysis and reporting
+- Performance benchmark tracking
+- Accessibility compliance scoring
+- Code quality metrics integration
+- Bug detection and resolution tracking
+- Quality trend analysis and insights
+
+### Phase 7: Continuous Integration
+**CI/CD Testing Integration:**
+- Automated test execution on code changes
+- Quality gate enforcement in deployment pipeline
+- Performance regression detection
+- Security vulnerability scanning
+- Accessibility compliance validation
+- Test result reporting and notifications
+
+## Testing-Specific Validation Checklist
+
+### Test Coverage Validation
+- [ ] Unit test coverage meets target thresholds (80%+)
+- [ ] Integration tests cover all API endpoints
+- [ ] E2E tests validate critical user journeys
+- [ ] Edge cases and error scenarios tested
+- [ ] Performance tests validate response times
+- [ ] Accessibility tests ensure WCAG compliance
+
+### Quality Gate Validation
+- [ ] All tests pass before deployment
+- [ ] Code coverage thresholds maintained
+- [ ] Performance benchmarks not regressed
+- [ ] Security scans show no critical issues
+- [ ] Accessibility compliance verified
+- [ ] Documentation updated with test results
+
+### Testing Infrastructure Validation
+- [ ] Test environments properly configured
+- [ ] Test data management automated
+- [ ] CI/CD pipeline includes all test types
+- [ ] Test results properly reported
+- [ ] Quality metrics tracked over time
+- [ ] Testing tools and frameworks up to date
+
+### Performance Validation
+- [ ] API response times within acceptable limits
+- [ ] Frontend performance meets Core Web Vitals
+- [ ] Database queries optimized and tested
+- [ ] Memory usage within acceptable bounds
+- [ ] Concurrent user load handled properly
+- [ ] Performance regression tests automated
+
+### Accessibility Validation
+- [ ] WCAG 2.1 AA compliance achieved
+- [ ] Keyboard navigation fully functional
+- [ ] Screen reader compatibility verified
+- [ ] Color contrast meets standards
+- [ ] Focus management appropriate
+- [ ] ARIA attributes properly implemented
+
+## Testing Implementation Success Criteria
+
+### Comprehensive Coverage
+- All functionality covered by appropriate test types
+- Critical user paths validated with E2E tests
+- Performance requirements verified with benchmarks
+- Accessibility standards met with automated testing
+- Security vulnerabilities prevented with scanning
+
+### Quality Assurance
+- Quality gates prevent regression and maintain standards
+- Automated testing provides fast feedback
+- Performance monitoring prevents degradation
+- Accessibility compliance ensures inclusive design
+- Security testing prevents vulnerabilities
+
+### Process Excellence
+- Testing is integrated into development workflow
+- Quality metrics provide actionable insights
+- Continuous improvement based on test results
+- Team adoption of testing best practices
+- Documentation supports testing activities
+
+### Reliability and Maintainability
+- Tests are reliable and not flaky
+- Test maintenance is manageable and efficient
+- Testing infrastructure is scalable
+- Quality standards are consistently enforced
+- Testing provides confidence for deployments
+
+This testing-specific execution framework ensures comprehensive quality validation with systematic testing strategies, automated quality gates, and continuous improvement processes.

package/.kiro/prompts/execute.md

@@ -0,0 +1,101 @@
+---
+description: Execute an implementation plan
+argument-hint: [path-to-plan]
+---
+
+# Execute: Implement from Plan
+
+## Plan to Execute
+
+Read plan file: `$ARGUMENTS`
+
+## Execution Instructions
+
+### 1. Read and Understand
+
+- Read the ENTIRE plan carefully
+- Understand all tasks and their dependencies
+- Note the validation commands to run
+- Review the testing strategy
+
+### 2. Execute Tasks in Order
+
+For EACH task in "Step by Step Tasks":
+
+#### a. Navigate to the task
+- Identify the file and action required
+- Read existing related files if modifying
+
+#### b. Implement the task
+- Follow the detailed specifications exactly
+- Maintain consistency with existing code patterns
+- Include proper type hints and documentation
+- Add structured logging where appropriate
+
+#### c. Verify as you go
+- After each file change, check syntax
+- Ensure imports are correct
+- Verify types are properly defined
+
+### 3. Implement Testing Strategy
+
+After completing implementation tasks:
+
+- Create all test files specified in the plan
+- Implement all test cases mentioned
+- Follow the testing approach outlined
+- Ensure tests cover edge cases
+
+### 4. Run Validation Commands
+
+Execute ALL validation commands from the plan in order:
+
+```bash
+# Run each command exactly as specified in plan
+```
+
+If any command fails:
+- Fix the issue
+- Re-run the command
+- Continue only when it passes
+
+### 5. Final Verification
+
+Before completing:
+
+- ✅ All tasks from plan completed
+- ✅ All tests created and passing
+- ✅ All validation commands pass
+- ✅ Code follows project conventions
+- ✅ Documentation added/updated as needed
+
+## Output Report
+
+Provide summary:
+
+### Completed Tasks
+- List of all tasks completed
+- Files created (with paths)
+- Files modified (with paths)
+
+### Tests Added
+- Test files created
+- Test cases implemented
+- Test results
+
+### Validation Results
+```bash
+# Output from each validation command
+```
+
+### Ready for Commit
+- Confirm all changes are complete
+- Confirm all validations pass
+- Ready for `/commit` command
+
+## Notes
+
+- If you encounter issues not addressed in the plan, document them
+- If you need to deviate from the plan, explain why
+- If tests fail, fix implementation until they pass
+- Don't skip validation steps

package/.kiro/prompts/execution-report.md

@@ -0,0 +1,72 @@
+---
+description: Generate implementation report for system review
+---
+
+# Execution Report
+
+Review and deeply analyze the implementation you just completed.
+
+## Context
+
+You have just finished implementing a feature. Before moving on, reflect on:
+
+- What you implemented
+- How it aligns with the plan
+- What challenges you encountered
+- What diverged and why
+
+## Generate Report
+
+Save to: `.kiro/execution-reports/[feature-name].md`
+
+### Meta Information
+
+- Plan file: [path to plan that guided this implementation]
+- Files added: [list with paths]
+- Files modified: [list with paths]
+- Lines changed: +X -Y
+
+### Validation Results
+
+- Syntax & Linting: ✓/✗ [details if failed]
+- Type Checking: ✓/✗ [details if failed]
+- Unit Tests: ✓/✗ [X passed, Y failed]
+- Integration Tests: ✓/✗ [X passed, Y failed]
+
+### What Went Well
+
+List specific things that worked smoothly:
+
+- [concrete examples]
+
+### Challenges Encountered
+
+List specific difficulties:
+
+- [what was difficult and why]
+
+### Divergences from Plan
+
+For each divergence, document:
+
+**[Divergence Title]**
+
+- Planned: [what the plan specified]
+- Actual: [what was implemented instead]
+- Reason: [why this divergence occurred]
+- Type: [Better approach found | Plan assumption wrong | Security concern | Performance issue | Other]
+
+### Skipped Items
+
+List anything from the plan that was not implemented:
+
+- [what was skipped]
+- Reason: [why it was skipped]
+
+### Recommendations
+
+Based on this implementation, what should change for next time?
+
+- Plan command improvements: [suggestions]
+- Execute command improvements: [suggestions]
+- Steering document additions: [suggestions]