kiro-agent-team 1.0.0

package/.kiro/prompts/prime.md

@@ -0,0 +1,73 @@
+# Prime: Load Project Context
+
+## Objective
+Build comprehensive understanding of the codebase by analyzing structure, documentation, and key files.
+
+## Process
+
+### 1. Analyze Project Structure
+If this is a git repository, list tracked files:
+```bash
+git ls-files
+```
+
+Show directory structure:
+```bash
+tree -L 3 -I 'node_modules|__pycache__|.git|dist|build'
+```
+(or use `ls -la` and explore key directories if tree is not available)
+
+### 2. Read Core Documentation
+- Read README files at project root and major directories
+- Read any architecture documentation
+- Review steering documents for project context (already loaded in context)
+- Avoid reading anything in examples or content_plan folders
+
+### 3. Identify Key Files
+Based on the structure, identify and read:
+- Main entry points (main.py, index.ts, app.py, etc.)
+- Core configuration files (pyproject.toml, package.json, tsconfig.json)
+- Key model/schema definitions
+- Important service or controller files
+
+### 4. Understand Current State (if git repository)
+Check recent activity:
+```bash
+git log -10 --oneline
+```
+
+Check current branch and status:
+```bash
+git status
+```
+
+## Output Report
+Provide a concise summary covering:
+
+### Project Overview
+- Purpose and type of application
+- Primary technologies and frameworks
+- Current version/state
+
+### Architecture
+- Overall structure and organization
+- Key architectural patterns identified
+- Important directories and their purposes
+
+### Tech Stack
+- Languages and versions
+- Frameworks and major libraries
+- Build tools and package managers
+- Testing frameworks
+
+### Core Principles
+- Code style and conventions observed
+- Documentation standards
+- Testing approach
+
+### Current State
+- Active branch (if git repository)
+- Recent changes or development focus (if git repository)
+- Any immediate observations or concerns
+
+**Make this summary easy to scan - use bullet points and clear headers.**

package/.kiro/prompts/quality-metrics.md

@@ -0,0 +1,622 @@
+# Quality Metrics Collection and Analysis
+
+## Automated Quality Metrics Framework
+
+This framework provides systematic collection, analysis, and reporting of quality metrics across all development activities, enabling data-driven process improvement and quality assurance.
+
+## Quality Metrics Categories
+
+### 1. Code Quality Metrics
+**Static Analysis Metrics:**
+- Code complexity (cyclomatic complexity, cognitive complexity)
+- Code duplication percentage and hotspots
+- Technical debt ratio and accumulation trends
+- Code coverage percentage and trend analysis
+- Security vulnerability count and severity distribution
+- Code style compliance and consistency scores
+
+**Dynamic Analysis Metrics:**
+- Runtime performance characteristics
+- Memory usage patterns and leak detection
+- Error rates and exception frequency
+- API response times and throughput
+- Database query performance and optimization opportunities
+- Resource utilization efficiency
+
+### 2. Development Process Metrics
+**Velocity and Productivity:**
+- Feature delivery velocity (story points per sprint)
+- Code commit frequency and size distribution
+- Pull request cycle time (creation to merge)
+- Build success rate and failure analysis
+- Deployment frequency and success rate
+- Time to resolution for bugs and issues
+
+**Collaboration and Communication:**
+- Agent handoff efficiency and context preservation
+- Code review participation and effectiveness
+- Knowledge sharing frequency and quality
+- Cross-functional collaboration patterns
+- Communication clarity and completeness scores
+- Conflict resolution time and effectiveness
+
+### 3. Quality Assurance Metrics
+**Testing Effectiveness:**
+- Test coverage percentage by type (unit, integration, e2e)
+- Test execution time and efficiency trends
+- Test failure rate and root cause analysis
+- Bug detection rate in different testing phases
+- Regression test effectiveness and coverage
+- Performance test results and benchmark compliance
+
+**Defect Management:**
+- Bug discovery rate by phase and severity
+- Mean time to detection (MTTD) for issues
+- Mean time to resolution (MTTR) for bugs
+- Defect escape rate to production
+- Customer-reported issue frequency and severity
+- Quality gate compliance and bypass frequency
+
+### 4. User Experience Metrics
+**Performance and Accessibility:**
+- Core Web Vitals (LCP, FID, CLS) compliance
+- Page load times and performance budgets
+- Accessibility compliance (WCAG 2.1 AA/AAA)
+- Cross-browser compatibility scores
+- Mobile responsiveness and usability
+- User interface consistency and design system adherence
+
+**Usability and Satisfaction:**
+- User task completion rates and efficiency
+- User error rates and recovery patterns
+- Feature adoption rates and usage patterns
+- User satisfaction scores and feedback sentiment
+- Support ticket volume and resolution time
+- User retention and engagement metrics
+
+## Quality Metrics Collection Implementation
+
+### Automated Metrics Collection System
+```typescript
+// Quality Metrics Collection Framework
+interface QualityMetrics {
+  timestamp: Date;
+  sessionId: string;
+  category: MetricCategory;
+  metrics: Record<string, number | string | boolean>;
+  context: MetricContext;
+  trends: MetricTrend[];
+  alerts: QualityAlert[];
+}
+
+class QualityMetricsCollector {
+  private collectors: Map<MetricCategory, MetricCollector> = new Map();
+  private analyzers: Map<MetricCategory, MetricAnalyzer> = new Map();
+  private reporters: QualityReporter[] = [];
+
+  async collectAllMetrics(sessionId: string): Promise<QualityMetrics[]> {
+    const metrics: QualityMetrics[] = [];
+    
+    // Collect code quality metrics
+    const codeMetrics = await this.collectCodeQualityMetrics(sessionId);
+    metrics.push(codeMetrics);
+    
+    // Collect process metrics
+    const processMetrics = await this.collectProcessMetrics(sessionId);
+    metrics.push(processMetrics);
+    
+    // Collect testing metrics
+    const testingMetrics = await this.collectTestingMetrics(sessionId);
+    metrics.push(testingMetrics);
+    
+    // Collect performance metrics
+    const performanceMetrics = await this.collectPerformanceMetrics(sessionId);
+    metrics.push(performanceMetrics);
+    
+    // Analyze trends and generate alerts
+    for (const metric of metrics) {
+      metric.trends = await this.analyzeTrends(metric);
+      metric.alerts = await this.generateAlerts(metric);
+    }
+    
+    return metrics;
+  }
+
+  async collectCodeQualityMetrics(sessionId: string): Promise<QualityMetrics> {
+    const startTime = Date.now();
+    
+    // Run static analysis tools
+    const eslintResults = await this.runESLint();
+    const sonarResults = await this.runSonarAnalysis();
+    const coverageResults = await this.runCoverageAnalysis();
+    const securityResults = await this.runSecurityScan();
+    
+    const metrics = {
+      // Complexity metrics
+      cyclomaticComplexity: sonarResults.complexity.cyclomatic,
+      cognitiveComplexity: sonarResults.complexity.cognitive,
+      
+      // Quality metrics
+      codeSmells: sonarResults.issues.codeSmells,
+      technicalDebt: sonarResults.debt.total,
+      duplication: sonarResults.duplication.percentage,
+      
+      // Coverage metrics
+      lineCoverage: coverageResults.lines.percentage,
+      branchCoverage: coverageResults.branches.percentage,
+      functionCoverage: coverageResults.functions.percentage,
+      
+      // Security metrics
+      vulnerabilities: securityResults.vulnerabilities.length,
+      securityHotspots: securityResults.hotspots.length,
+      
+      // Style and consistency
+      eslintErrors: eslintResults.errorCount,
+      eslintWarnings: eslintResults.warningCount,
+      
+      // Collection metadata
+      collectionTime: Date.now() - startTime,
+      toolsUsed: ['eslint', 'sonar', 'jest', 'snyk']
+    };
+
+    return {
+      timestamp: new Date(),
+      sessionId,
+      category: 'code_quality',
+      metrics,
+      context: await this.getCodeContext(sessionId),
+      trends: [],
+      alerts: []
+    };
+  }
+
+  async collectProcessMetrics(sessionId: string): Promise<QualityMetrics> {
+    const session = await this.getSession(sessionId);
+    const gitMetrics = await this.collectGitMetrics(sessionId);
+    const buildMetrics = await this.collectBuildMetrics(sessionId);
+    const deploymentMetrics = await this.collectDeploymentMetrics(sessionId);
+    
+    const metrics = {
+      // Development velocity
+      sessionDuration: session.duration,
+      linesOfCodeChanged: gitMetrics.linesChanged,
+      filesModified: gitMetrics.filesModified,
+      commitsCount: gitMetrics.commitsCount,
+      
+      // Build and deployment
+      buildTime: buildMetrics.duration,
+      buildSuccess: buildMetrics.success,
+      deploymentTime: deploymentMetrics.duration,
+      deploymentSuccess: deploymentMetrics.success,
+      
+      // Collaboration
+      agentHandoffs: session.collaboratingAgents.length,
+      communicationEffectiveness: session.communicationScore,
+      contextPreservation: session.contextScore,
+      
+      // Quality gates
+      qualityGatesPassed: session.qualityGates.passed,
+      qualityGatesFailed: session.qualityGates.failed,
+      qualityGatesBypass: session.qualityGates.bypassed
+    };
+
+    return {
+      timestamp: new Date(),
+      sessionId,
+      category: 'process',
+      metrics,
+      context: await this.getProcessContext(sessionId),
+      trends: [],
+      alerts: []
+    };
+  }
+
+  async collectTestingMetrics(sessionId: string): Promise<QualityMetrics> {
+    const testResults = await this.runAllTests();
+    const performanceTests = await this.runPerformanceTests();
+    const accessibilityTests = await this.runAccessibilityTests();
+    
+    const metrics = {
+      // Test execution
+      totalTests: testResults.total,
+      passedTests: testResults.passed,
+      failedTests: testResults.failed,
+      skippedTests: testResults.skipped,
+      testExecutionTime: testResults.duration,
+      
+      // Test coverage
+      unitTestCoverage: testResults.coverage.unit,
+      integrationTestCoverage: testResults.coverage.integration,
+      e2eTestCoverage: testResults.coverage.e2e,
+      
+      // Performance testing
+      averageResponseTime: performanceTests.averageResponseTime,
+      maxResponseTime: performanceTests.maxResponseTime,
+      throughput: performanceTests.throughput,
+      errorRate: performanceTests.errorRate,
+      
+      // Accessibility testing
+      accessibilityScore: accessibilityTests.score,
+      wcagViolations: accessibilityTests.violations.length,
+      contrastIssues: accessibilityTests.contrastIssues,
+      keyboardNavigationIssues: accessibilityTests.keyboardIssues,
+      
+      // Quality indicators
+      testReliability: this.calculateTestReliability(testResults),
+      testMaintainability: this.calculateTestMaintainability(testResults)
+    };
+
+    return {
+      timestamp: new Date(),
+      sessionId,
+      category: 'testing',
+      metrics,
+      context: await this.getTestingContext(sessionId),
+      trends: [],
+      alerts: []
+    };
+  }
+}
+```
+
+### Quality Trend Analysis
+```typescript
+// Quality Trend Analysis System
+class QualityTrendAnalyzer {
+  async analyzeTrends(metrics: QualityMetrics[]): Promise<QualityTrendReport> {
+    const report: QualityTrendReport = {
+      timeframe: this.getTimeframe(metrics),
+      categories: {},
+      overallTrend: 'stable',
+      keyInsights: [],
+      recommendations: [],
+      alerts: []
+    };
+
+    // Analyze trends by category
+    for (const category of this.getCategories(metrics)) {
+      const categoryMetrics = metrics.filter(m => m.category === category);
+      report.categories[category] = await this.analyzeCategoryTrend(categoryMetrics);
+    }
+
+    // Generate overall assessment
+    report.overallTrend = this.calculateOverallTrend(report.categories);
+    
+    // Extract key insights
+    report.keyInsights = await this.extractKeyInsights(report.categories);
+    
+    // Generate recommendations
+    report.recommendations = await this.generateRecommendations(report);
+    
+    // Identify alerts
+    report.alerts = await this.identifyQualityAlerts(report);
+
+    return report;
+  }
+
+  async analyzeCategoryTrend(metrics: QualityMetrics[]): Promise<CategoryTrend> {
+    const trend: CategoryTrend = {
+      direction: 'stable',
+      velocity: 0,
+      confidence: 0,
+      keyMetrics: {},
+      patterns: [],
+      anomalies: []
+    };
+
+    // Calculate trend direction and velocity
+    for (const metricName of this.getMetricNames(metrics)) {
+      const values = metrics.map(m => m.metrics[metricName] as number);
+      const trendAnalysis = this.calculateTrendDirection(values);
+      
+      trend.keyMetrics[metricName] = {
+        current: values[values.length - 1],
+        previous: values[values.length - 2],
+        change: trendAnalysis.change,
+        direction: trendAnalysis.direction,
+        significance: trendAnalysis.significance
+      };
+    }
+
+    // Identify patterns
+    trend.patterns = await this.identifyPatterns(metrics);
+    
+    // Detect anomalies
+    trend.anomalies = await this.detectAnomalies(metrics);
+    
+    // Calculate overall trend
+    trend.direction = this.calculateCategoryDirection(trend.keyMetrics);
+    trend.velocity = this.calculateCategoryVelocity(trend.keyMetrics);
+    trend.confidence = this.calculateConfidence(trend.keyMetrics, trend.patterns);
+
+    return trend;
+  }
+
+  async generateQualityInsights(trends: QualityTrendReport): Promise<QualityInsight[]> {
+    const insights: QualityInsight[] = [];
+
+    // Code quality insights
+    if (trends.categories.code_quality) {
+      const codeQuality = trends.categories.code_quality;
+      
+      if (codeQuality.direction === 'improving') {
+        insights.push({
+          type: 'positive_trend',
+          category: 'code_quality',
+          title: 'Code Quality Improving',
+          description: 'Code quality metrics show consistent improvement',
+          impact: 'high',
+          confidence: codeQuality.confidence,
+          recommendations: [
+            'Continue current development practices',
+            'Document successful quality improvement strategies',
+            'Share best practices with team'
+          ]
+        });
+      }
+      
+      if (codeQuality.keyMetrics.technicalDebt?.direction === 'worsening') {
+        insights.push({
+          type: 'concern',
+          category: 'code_quality',
+          title: 'Technical Debt Accumulating',
+          description: 'Technical debt is increasing faster than resolution',
+          impact: 'medium',
+          confidence: codeQuality.confidence,
+          recommendations: [
+            'Allocate dedicated time for technical debt reduction',
+            'Implement stricter code review standards',
+            'Consider refactoring high-debt areas'
+          ]
+        });
+      }
+    }
+
+    // Process efficiency insights
+    if (trends.categories.process) {
+      const process = trends.categories.process;
+      
+      if (process.keyMetrics.buildTime?.direction === 'worsening') {
+        insights.push({
+          type: 'performance_concern',
+          category: 'process',
+          title: 'Build Times Increasing',
+          description: 'Build times are trending upward, impacting development velocity',
+          impact: 'medium',
+          confidence: process.confidence,
+          recommendations: [
+            'Analyze build performance bottlenecks',
+            'Implement build caching strategies',
+            'Consider build optimization tools'
+          ]
+        });
+      }
+    }
+
+    // Testing effectiveness insights
+    if (trends.categories.testing) {
+      const testing = trends.categories.testing;
+      
+      if (testing.keyMetrics.testCoverage?.direction === 'improving') {
+        insights.push({
+          type: 'positive_trend',
+          category: 'testing',
+          title: 'Test Coverage Improving',
+          description: 'Test coverage is consistently increasing',
+          impact: 'high',
+          confidence: testing.confidence,
+          recommendations: [
+            'Maintain current testing discipline',
+            'Focus on testing critical business logic',
+            'Consider adding more integration tests'
+          ]
+        });
+      }
+    }
+
+    return insights;
+  }
+}
+```
+
+### Quality Alerts and Notifications
+```typescript
+// Quality Alert System
+class QualityAlertSystem {
+  private alertRules: QualityAlertRule[] = [
+    {
+      name: 'Critical Security Vulnerability',
+      condition: (metrics) => metrics.vulnerabilities > 0 && metrics.severity === 'critical',
+      severity: 'critical',
+      action: 'immediate_notification'
+    },
+    {
+      name: 'Test Coverage Drop',
+      condition: (metrics) => metrics.testCoverage < 80 && metrics.coverageChange < -5,
+      severity: 'high',
+      action: 'quality_gate_block'
+    },
+    {
+      name: 'Build Time Regression',
+      condition: (metrics) => metrics.buildTime > 300 && metrics.buildTimeChange > 50,
+      severity: 'medium',
+      action: 'performance_investigation'
+    },
+    {
+      name: 'Technical Debt Threshold',
+      condition: (metrics) => metrics.technicalDebt > 100 && metrics.debtTrend === 'increasing',
+      severity: 'medium',
+      action: 'refactoring_recommendation'
+    }
+  ];
+
+  async evaluateAlerts(metrics: QualityMetrics[]): Promise<QualityAlert[]> {
+    const alerts: QualityAlert[] = [];
+    
+    for (const metric of metrics) {
+      for (const rule of this.alertRules) {
+        if (rule.condition(metric.metrics)) {
+          const alert: QualityAlert = {
+            id: generateAlertId(),
+            timestamp: new Date(),
+            rule: rule.name,
+            severity: rule.severity,
+            category: metric.category,
+            sessionId: metric.sessionId,
+            description: this.generateAlertDescription(rule, metric),
+            recommendations: this.generateAlertRecommendations(rule, metric),
+            action: rule.action,
+            status: 'active'
+          };
+          
+          alerts.push(alert);
+        }
+      }
+    }
+    
+    return alerts;
+  }
+
+  async processAlerts(alerts: QualityAlert[]): Promise<void> {
+    for (const alert of alerts) {
+      switch (alert.action) {
+        case 'immediate_notification':
+          await this.sendImmediateNotification(alert);
+          break;
+        case 'quality_gate_block':
+          await this.blockQualityGate(alert);
+          break;
+        case 'performance_investigation':
+          await this.triggerPerformanceInvestigation(alert);
+          break;
+        case 'refactoring_recommendation':
+          await this.createRefactoringTask(alert);
+          break;
+      }
+    }
+  }
+}
+```
+
+### Quality Reporting and Dashboards
+```typescript
+// Quality Reporting System
+class QualityReporter {
+  async generateQualityReport(timeframe: TimeFrame): Promise<QualityReport> {
+    const metrics = await this.getMetricsForTimeframe(timeframe);
+    const trends = await this.analyzeTrends(metrics);
+    const insights = await this.generateInsights(trends);
+    const recommendations = await this.generateRecommendations(insights);
+
+    const report: QualityReport = {
+      timeframe,
+      executiveSummary: await this.generateExecutiveSummary(trends, insights),
+      qualityScore: this.calculateOverallQualityScore(metrics),
+      categoryScores: this.calculateCategoryScores(metrics),
+      trends,
+      insights,
+      recommendations,
+      actionItems: await this.generateActionItems(recommendations),
+      appendices: {
+        detailedMetrics: metrics,
+        methodologyNotes: this.getMethodologyNotes(),
+        dataQualityNotes: this.getDataQualityNotes()
+      }
+    };
+
+    return report;
+  }
+
+  async generateDashboard(timeframe: TimeFrame): Promise<QualityDashboard> {
+    const metrics = await this.getMetricsForTimeframe(timeframe);
+    
+    return {
+      overview: {
+        qualityScore: this.calculateOverallQualityScore(metrics),
+        trendDirection: this.calculateOverallTrend(metrics),
+        activeAlerts: await this.getActiveAlerts(),
+        keyMetrics: this.getKeyMetrics(metrics)
+      },
+      charts: {
+        qualityTrend: this.generateQualityTrendChart(metrics),
+        categoryBreakdown: this.generateCategoryBreakdownChart(metrics),
+        alertsOverTime: this.generateAlertsChart(metrics),
+        performanceTrends: this.generatePerformanceTrendsChart(metrics)
+      },
+      insights: await this.generateDashboardInsights(metrics),
+      recommendations: await this.generateDashboardRecommendations(metrics)
+    };
+  }
+}
+```
+
+## Quality Metrics Integration with Agent Hooks
+
+### Automated Collection Triggers
+```yaml
+# Quality Metrics Collection Hooks
+quality_metrics:
+  - name: "session_metrics_collection"
+    description: "Collect quality metrics at session completion"
+    trigger:
+      type: "session_end"
+    action:
+      type: "execute_prompt"
+      prompt: "quality-metrics.md"
+      message: "Collecting comprehensive quality metrics for session analysis..."
+      include_context:
+        - session_data: true
+        - performance_metrics: true
+        - quality_indicators: true
+
+  - name: "milestone_quality_assessment"
+    description: "Comprehensive quality assessment at milestones"
+    trigger:
+      type: "milestone_completion"
+    action:
+      type: "execute_prompt"
+      prompt: "quality-metrics.md"
+      message: "Conducting milestone quality assessment and trend analysis..."
+      include_context:
+        - milestone_scope: true
+        - quality_history: true
+        - trend_data: true
+
+  - name: "quality_alert_processing"
+    description: "Process quality alerts and recommendations"
+    trigger:
+      type: "quality_threshold_breach"
+    action:
+      type: "execute_prompt"
+      prompt: "quality-metrics.md"
+      message: "Processing quality alert and generating improvement recommendations..."
+      include_context:
+        - alert_details: true
+        - historical_context: true
+        - improvement_options: true
+```
+
+## Quality Metrics Success Criteria
+
+### Comprehensive Coverage
+- All aspects of development quality systematically measured
+- Metrics collection automated and integrated into workflow
+- Trend analysis provides actionable insights
+- Alerts prevent quality degradation
+- Reporting supports decision-making
+
+### Actionable Insights
+- Quality metrics drive concrete improvements
+- Trends inform strategic quality decisions
+- Alerts enable proactive quality management
+- Recommendations are specific and implementable
+- Process optimization measurably improves quality
+
+### Continuous Improvement
+- Quality standards continuously evolve and improve
+- Team learning from quality metrics enhanced
+- Quality processes systematically optimized
+- Tool and practice adoption data-driven
+- Quality culture strengthened through visibility
+
+This quality metrics framework ensures systematic measurement, analysis, and improvement of all aspects of development quality, enabling data-driven excellence and continuous improvement.