kiro-agent-team 1.0.0

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

@@ -0,0 +1,491 @@
+# Execute: Development Logging
+
+## Development Logging-Specific Implementation Framework
+
+This specialized execution framework is optimized for development experience tracking, process analysis, and systematic knowledge capture throughout the development lifecycle.
+
+## Development Logging Process
+
+### Phase 1: Logging Requirements Analysis
+**Logging-Specific Analysis:**
+- Development experience tracking scope and objectives
+- Process improvement goals and success metrics
+- Knowledge capture and retention requirements
+- Team collaboration and communication patterns
+- Performance and productivity measurement needs
+- Learning and insight generation requirements
+
+**Questions to Address:**
+- What aspects of the development process need tracking?
+- What insights and improvements are we seeking?
+- How detailed should the logging and analysis be?
+- What patterns and trends should we identify?
+- How will the captured knowledge be used and shared?
+- What reporting and analysis capabilities are needed?
+
+### Phase 2: Logging Strategy Design
+**Logging Architecture Planning:**
+- Development session tracking and categorization
+- Performance metrics collection and analysis
+- Collaboration pattern identification and optimization
+- Knowledge capture and documentation strategies
+- Process improvement identification and implementation
+- Reporting and insight generation workflows
+
+**Logging Design Decisions:**
+- Choose appropriate metrics and tracking points
+- Define session categorization and tagging systems
+- Plan knowledge capture and storage strategies
+- Establish analysis and reporting frameworks
+- Design process improvement feedback loops
+
+### Phase 3: Implementation
+**Systematic Development Logging Implementation:**
+
+#### Session Tracking Implementation
+```typescript
+// Example development session tracking
+interface DevelopmentSession {
+  id: string;
+  startTime: Date;
+  endTime?: Date;
+  duration?: number;
+  primaryAgent: string;
+  collaboratingAgents: string[];
+  taskType: 'feature' | 'bug' | 'refactor' | 'documentation' | 'testing';
+  complexity: 1 | 2 | 3 | 4 | 5;
+  status: 'in-progress' | 'completed' | 'blocked' | 'paused';
+  artifacts: SessionArtifact[];
+  metrics: SessionMetrics;
+  insights: SessionInsight[];
+}
+
+interface SessionMetrics {
+  linesOfCodeChanged: number;
+  filesModified: number;
+  testsAdded: number;
+  testCoverage: number;
+  buildTime: number;
+  testExecutionTime: number;
+  errorCount: number;
+  warningCount: number;
+  performanceImpact: 'positive' | 'neutral' | 'negative';
+}
+
+class DevelopmentLogger {
+  async startSession(config: SessionConfig): Promise<DevelopmentSession> {
+    const session: DevelopmentSession = {
+      id: generateSessionId(),
+      startTime: new Date(),
+      primaryAgent: config.agent,
+      collaboratingAgents: [],
+      taskType: config.taskType,
+      complexity: config.complexity,
+      status: 'in-progress',
+      artifacts: [],
+      metrics: this.initializeMetrics(),
+      insights: []
+    };
+
+    // Initialize performance tracking
+    await this.initializePerformanceTracking(session.id);
+    
+    // Set up collaboration monitoring
+    await this.setupCollaborationTracking(session.id);
+    
+    // Begin artifact collection
+    await this.startArtifactCollection(session.id);
+
+    return session;
+  }
+
+  async updateSessionProgress(sessionId: string, update: SessionUpdate): Promise<void> {
+    const session = await this.getSession(sessionId);
+    
+    // Update metrics
+    session.metrics = await this.collectCurrentMetrics(sessionId);
+    
+    // Track collaboration events
+    if (update.agentChange) {
+      session.collaboratingAgents.push(update.newAgent);
+      await this.logAgentHandoff(sessionId, update.previousAgent, update.newAgent);
+    }
+    
+    // Capture artifacts
+    if (update.artifacts) {
+      session.artifacts.push(...update.artifacts);
+    }
+    
+    // Generate real-time insights
+    const newInsights = await this.generateInsights(session);
+    session.insights.push(...newInsights);
+    
+    await this.saveSession(session);
+  }
+
+  async finalizeSession(sessionId: string): Promise<SessionSummary> {
+    const session = await this.getSession(sessionId);
+    session.endTime = new Date();
+    session.duration = session.endTime.getTime() - session.startTime.getTime();
+    session.status = 'completed';
+
+    // Generate comprehensive session analysis
+    const analysis = await this.analyzeSession(session);
+    
+    // Extract key learnings
+    const learnings = await this.extractLearnings(session);
+    
+    // Identify process improvements
+    const improvements = await this.identifyImprovements(session);
+    
+    // Create session summary
+    const summary: SessionSummary = {
+      session,
+      analysis,
+      learnings,
+      improvements,
+      recommendations: await this.generateRecommendations(session)
+    };
+
+    // Store in knowledge base
+    await this.storeInKnowledgeBase(summary);
+    
+    // Update process metrics
+    await this.updateProcessMetrics(summary);
+
+    return summary;
+  }
+}
+```
+
+#### Performance Metrics Collection
+```typescript
+// Example performance metrics tracking
+class PerformanceTracker {
+  async collectBuildMetrics(sessionId: string): Promise<BuildMetrics> {
+    const startTime = Date.now();
+    
+    // Execute build and capture metrics
+    const buildResult = await this.executeBuild();
+    
+    const endTime = Date.now();
+    const duration = endTime - startTime;
+
+    const metrics: BuildMetrics = {
+      duration,
+      success: buildResult.success,
+      warningCount: buildResult.warnings.length,
+      errorCount: buildResult.errors.length,
+      bundleSize: buildResult.bundleSize,
+      chunkSizes: buildResult.chunkSizes,
+      optimizationApplied: buildResult.optimizations,
+      performanceImpact: this.assessPerformanceImpact(buildResult)
+    };
+
+    await this.logMetrics(sessionId, 'build', metrics);
+    return metrics;
+  }
+
+  async collectTestMetrics(sessionId: string): Promise<TestMetrics> {
+    const startTime = Date.now();
+    
+    // Execute tests and capture results
+    const testResult = await this.executeTests();
+    
+    const endTime = Date.now();
+    const duration = endTime - startTime;
+
+    const metrics: TestMetrics = {
+      duration,
+      totalTests: testResult.total,
+      passedTests: testResult.passed,
+      failedTests: testResult.failed,
+      skippedTests: testResult.skipped,
+      coverage: testResult.coverage,
+      coverageChange: await this.calculateCoverageChange(testResult.coverage),
+      slowestTests: testResult.slowestTests,
+      newTests: testResult.newTests
+    };
+
+    await this.logMetrics(sessionId, 'test', metrics);
+    return metrics;
+  }
+
+  async collectDatabaseMetrics(sessionId: string): Promise<DatabaseMetrics> {
+    const queryMetrics = await this.analyzeQueryPerformance();
+    const migrationMetrics = await this.analyzeMigrationPerformance();
+
+    const metrics: DatabaseMetrics = {
+      queryCount: queryMetrics.totalQueries,
+      averageQueryTime: queryMetrics.averageTime,
+      slowestQueries: queryMetrics.slowestQueries,
+      indexUsage: queryMetrics.indexUsage,
+      migrationTime: migrationMetrics.duration,
+      schemaChanges: migrationMetrics.changes,
+      dataIntegrityChecks: migrationMetrics.integrityResults
+    };
+
+    await this.logMetrics(sessionId, 'database', metrics);
+    return metrics;
+  }
+}
+```
+
+#### Collaboration Pattern Analysis
+```typescript
+// Example collaboration tracking and analysis
+class CollaborationAnalyzer {
+  async trackAgentHandoff(sessionId: string, fromAgent: string, toAgent: string, context: HandoffContext): Promise<void> {
+    const handoff: AgentHandoff = {
+      sessionId,
+      timestamp: new Date(),
+      fromAgent,
+      toAgent,
+      context,
+      handoffType: this.classifyHandoff(fromAgent, toAgent),
+      contextTransferred: context.artifacts.length,
+      communicationEffectiveness: await this.assessCommunication(context),
+      coordinationChallenges: context.challenges || []
+    };
+
+    await this.logHandoff(handoff);
+    await this.analyzeHandoffPatterns(sessionId);
+  }
+
+  async analyzeCollaborationEffectiveness(sessionId: string): Promise<CollaborationAnalysis> {
+    const session = await this.getSession(sessionId);
+    const handoffs = await this.getSessionHandoffs(sessionId);
+
+    const analysis: CollaborationAnalysis = {
+      totalHandoffs: handoffs.length,
+      averageHandoffTime: this.calculateAverageHandoffTime(handoffs),
+      communicationQuality: this.assessCommunicationQuality(handoffs),
+      contextPreservation: this.assessContextPreservation(handoffs),
+      coordinationEfficiency: this.assessCoordinationEfficiency(handoffs),
+      collaborationPatterns: this.identifyCollaborationPatterns(handoffs),
+      improvementOpportunities: this.identifyImprovementOpportunities(handoffs)
+    };
+
+    return analysis;
+  }
+
+  async generateCollaborationInsights(sessionId: string): Promise<CollaborationInsight[]> {
+    const analysis = await this.analyzeCollaborationEffectiveness(sessionId);
+    const insights: CollaborationInsight[] = [];
+
+    // Identify effective collaboration patterns
+    if (analysis.communicationQuality > 0.8) {
+      insights.push({
+        type: 'positive_pattern',
+        description: 'Excellent communication effectiveness observed',
+        recommendation: 'Document and replicate this communication approach',
+        impact: 'high'
+      });
+    }
+
+    // Identify coordination challenges
+    if (analysis.coordinationEfficiency < 0.6) {
+      insights.push({
+        type: 'improvement_opportunity',
+        description: 'Coordination efficiency below optimal levels',
+        recommendation: 'Implement clearer handoff protocols and context sharing',
+        impact: 'medium'
+      });
+    }
+
+    // Identify successful agent combinations
+    const effectivePairs = this.identifyEffectiveAgentPairs(analysis);
+    if (effectivePairs.length > 0) {
+      insights.push({
+        type: 'best_practice',
+        description: `Highly effective agent combinations identified: ${effectivePairs.join(', ')}`,
+        recommendation: 'Prioritize these agent combinations for complex tasks',
+        impact: 'high'
+      });
+    }
+
+    return insights;
+  }
+}
+```
+
+#### Knowledge Capture and Documentation
+```typescript
+// Example knowledge capture system
+class KnowledgeCapture {
+  async captureSessionKnowledge(session: DevelopmentSession): Promise<KnowledgeEntry> {
+    const knowledge: KnowledgeEntry = {
+      id: generateKnowledgeId(),
+      sessionId: session.id,
+      timestamp: new Date(),
+      category: this.categorizeKnowledge(session),
+      technicalDecisions: await this.extractTechnicalDecisions(session),
+      problemsSolved: await this.extractProblemsSolved(session),
+      solutionsApplied: await this.extractSolutionsApplied(session),
+      lessonsLearned: await this.extractLessonsLearned(session),
+      bestPractices: await this.extractBestPractices(session),
+      antiPatterns: await this.extractAntiPatterns(session),
+      processInsights: await this.extractProcessInsights(session),
+      toolEffectiveness: await this.assessToolEffectiveness(session),
+      reusablePatterns: await this.identifyReusablePatterns(session)
+    };
+
+    // Store in searchable knowledge base
+    await this.storeKnowledge(knowledge);
+    
+    // Update knowledge graphs and relationships
+    await this.updateKnowledgeGraph(knowledge);
+    
+    // Generate knowledge recommendations
+    await this.generateKnowledgeRecommendations(knowledge);
+
+    return knowledge;
+  }
+
+  async generateProcessInsights(timeframe: TimeFrame): Promise<ProcessInsight[]> {
+    const sessions = await this.getSessionsInTimeframe(timeframe);
+    const insights: ProcessInsight[] = [];
+
+    // Analyze productivity patterns
+    const productivityAnalysis = await this.analyzeProductivityPatterns(sessions);
+    insights.push(...this.generateProductivityInsights(productivityAnalysis));
+
+    // Analyze quality patterns
+    const qualityAnalysis = await this.analyzeQualityPatterns(sessions);
+    insights.push(...this.generateQualityInsights(qualityAnalysis));
+
+    // Analyze collaboration patterns
+    const collaborationAnalysis = await this.analyzeCollaborationPatterns(sessions);
+    insights.push(...this.generateCollaborationInsights(collaborationAnalysis));
+
+    // Analyze tool effectiveness
+    const toolAnalysis = await this.analyzeToolEffectiveness(sessions);
+    insights.push(...this.generateToolInsights(toolAnalysis));
+
+    return insights;
+  }
+
+  async identifyImprovementOpportunities(sessions: DevelopmentSession[]): Promise<ImprovementOpportunity[]> {
+    const opportunities: ImprovementOpportunity[] = [];
+
+    // Identify recurring challenges
+    const challenges = this.identifyRecurringChallenges(sessions);
+    opportunities.push(...this.generateChallengeImprovements(challenges));
+
+    // Identify inefficient patterns
+    const inefficiencies = this.identifyInefficiencies(sessions);
+    opportunities.push(...this.generateEfficiencyImprovements(inefficiencies));
+
+    // Identify knowledge gaps
+    const knowledgeGaps = this.identifyKnowledgeGaps(sessions);
+    opportunities.push(...this.generateKnowledgeImprovements(knowledgeGaps));
+
+    // Identify tool optimization opportunities
+    const toolOptimizations = this.identifyToolOptimizations(sessions);
+    opportunities.push(...this.generateToolImprovements(toolOptimizations));
+
+    return opportunities;
+  }
+}
+```
+
+### Phase 4: Process Analysis Implementation
+**Process Analysis Strategy:**
+- Development velocity and productivity tracking
+- Quality metrics and trend analysis
+- Collaboration effectiveness measurement
+- Tool and workflow optimization identification
+- Learning and knowledge retention assessment
+- Process improvement recommendation generation
+
+### Phase 5: Reporting and Insights Generation
+**Reporting Implementation:**
+- Real-time development dashboards
+- Periodic process effectiveness reports
+- Trend analysis and pattern identification
+- Improvement opportunity recommendations
+- Knowledge sharing and best practice documentation
+- Team performance and satisfaction metrics
+
+### Phase 6: Continuous Improvement Integration
+**Improvement Process Implementation:**
+- Systematic process review and optimization
+- Knowledge-driven workflow enhancements
+- Tool and technology adoption recommendations
+- Team skill development identification
+- Process standardization and documentation
+- Feedback loop implementation and monitoring
+
+## Development Logging Validation Checklist
+
+### Session Tracking Validation
+- [ ] All development sessions properly tracked and categorized
+- [ ] Performance metrics accurately collected and analyzed
+- [ ] Collaboration patterns identified and documented
+- [ ] Artifacts and deliverables systematically captured
+- [ ] Real-time insights generated during development
+- [ ] Session summaries comprehensive and actionable
+
+### Knowledge Capture Validation
+- [ ] Technical decisions and rationale documented
+- [ ] Problems and solutions systematically recorded
+- [ ] Lessons learned captured and categorized
+- [ ] Best practices identified and documented
+- [ ] Anti-patterns recognized and avoided
+- [ ] Reusable patterns extracted and shared
+
+### Process Analysis Validation
+- [ ] Development velocity trends identified
+- [ ] Quality metrics tracked and analyzed
+- [ ] Collaboration effectiveness measured
+- [ ] Tool effectiveness assessed and optimized
+- [ ] Workflow inefficiencies identified and addressed
+- [ ] Improvement opportunities systematically generated
+
+### Reporting and Insights Validation
+- [ ] Reports provide actionable insights
+- [ ] Trends and patterns clearly identified
+- [ ] Recommendations specific and implementable
+- [ ] Knowledge sharing effective and accessible
+- [ ] Team feedback incorporated and addressed
+- [ ] Process improvements tracked and validated
+
+### Integration and Automation Validation
+- [ ] Logging integrated into development workflow
+- [ ] Metrics collection automated and reliable
+- [ ] Analysis and reporting automated where possible
+- [ ] Knowledge base searchable and accessible
+- [ ] Improvement recommendations actionable
+- [ ] Feedback loops effective and responsive
+
+## Development Logging Success Criteria
+
+### Comprehensive Tracking
+- All aspects of development process systematically tracked
+- Performance metrics provide actionable insights
+- Collaboration patterns identified and optimized
+- Knowledge systematically captured and retained
+- Process improvements continuously identified and implemented
+
+### Actionable Insights
+- Reports and analysis drive concrete improvements
+- Trends and patterns inform strategic decisions
+- Recommendations are specific and implementable
+- Knowledge sharing improves team effectiveness
+- Process optimization measurably improves outcomes
+
+### Continuous Improvement
+- Development process continuously evolves and improves
+- Team learning and knowledge retention enhanced
+- Workflow efficiency systematically optimized
+- Tool and technology adoption data-driven
+- Quality and productivity trends positive
+
+### Team Adoption and Value
+- Development team actively uses logging insights
+- Process improvements adopted and sustained
+- Knowledge sharing becomes standard practice
+- Team satisfaction with development process improves
+- Business value from development activities increases
+
+This development logging-specific execution framework ensures systematic capture of development experience, comprehensive process analysis, and continuous improvement through data-driven insights and knowledge retention.