aiwf 0.3.0 → 0.3.2

package/lib/metrics-collector.js

@@ -0,0 +1,885 @@
+/**
+ * Metrics Collector
+ * Collects and analyzes metrics for AI persona performance
+ */
+
+import fs from 'fs/promises';
+import path from 'path';
+import { EventEmitter } from 'events';
+
+class MetricsCollector extends EventEmitter {
+  constructor(options = {}) {
+    super();
+    
+    this.options = {
+      metricsPath: options.metricsPath || 
+        path.join(process.cwd(), '.aiwf', 'metrics'),
+      maxHistorySize: options.maxHistorySize || 1000,
+      aggregationInterval: options.aggregationInterval || 3600000, // 1 hour
+      persistInterval: options.persistInterval || 300000, // 5 minutes
+      ...options
+    };
+
+    this.metrics = {
+      sessions: [],
+      personaPerformance: {},
+      taskOutcomes: [],
+      aggregated: {}
+    };
+
+    this.currentSession = null;
+    this.startTime = Date.now();
+    this.persistTimer = null;
+  }
+
+  /**
+   * Initialize metrics collector
+   */
+  async init() {
+    try {
+      // Ensure metrics directory exists
+      await fs.mkdir(this.options.metricsPath, { recursive: true });
+      
+      // Load existing metrics
+      await this.loadMetrics();
+      
+      // Start persist timer
+      this.startPersistTimer();
+      
+      this.emit('initialized', {
+        sessionsLoaded: this.metrics.sessions.length,
+        startTime: this.startTime
+      });
+      
+      return true;
+    } catch (error) {
+      this.emit('error', { error, phase: 'initialization' });
+      throw error;
+    }
+  }
+
+  /**
+   * Start a new metrics session
+   */
+  startSession(persona, task) {
+    // End current session if exists
+    if (this.currentSession) {
+      this.endSession();
+    }
+
+    this.currentSession = {
+      id: this.generateSessionId(),
+      persona: persona.name || persona,
+      task: {
+        type: task.type || 'general',
+        description: task.description || task.command || '',
+        complexity: this.estimateTaskComplexity(task)
+      },
+      startTime: Date.now(),
+      events: [],
+      metrics: {
+        tokenUsage: {
+          start: this.getCurrentTokenCount(),
+          end: null,
+          contextSwitches: 0
+        },
+        interactions: 0,
+        errors: 0,
+        completionStatus: null
+      }
+    };
+
+    this.emit('sessionStarted', {
+      sessionId: this.currentSession.id,
+      persona: this.currentSession.persona
+    });
+
+    return this.currentSession.id;
+  }
+
+  /**
+   * End current session
+   */
+  endSession(status = 'completed') {
+    if (!this.currentSession) return;
+
+    this.currentSession.endTime = Date.now();
+    this.currentSession.duration = this.currentSession.endTime - this.currentSession.startTime;
+    this.currentSession.metrics.completionStatus = status;
+    this.currentSession.metrics.tokenUsage.end = this.getCurrentTokenCount();
+
+    // Calculate quality metrics
+    this.currentSession.qualityMetrics = this.calculateQualityMetrics(this.currentSession);
+
+    // Store session
+    this.metrics.sessions.push(this.currentSession);
+    this.updatePersonaPerformance(this.currentSession);
+
+    // Limit history size
+    if (this.metrics.sessions.length > this.options.maxHistorySize) {
+      this.metrics.sessions = this.metrics.sessions.slice(-this.options.maxHistorySize);
+    }
+
+    this.emit('sessionEnded', {
+      sessionId: this.currentSession.id,
+      duration: this.currentSession.duration,
+      status
+    });
+
+    const session = this.currentSession;
+    this.currentSession = null;
+    
+    return session;
+  }
+
+  /**
+   * Track an event
+   */
+  trackEvent(eventType, data = {}) {
+    const event = {
+      type: eventType,
+      timestamp: Date.now(),
+      data
+    };
+
+    // Add to current session if active
+    if (this.currentSession) {
+      this.currentSession.events.push(event);
+      
+      // Update session metrics based on event
+      this.updateSessionMetrics(eventType, data);
+    }
+
+    // Track global events
+    this.trackGlobalEvent(eventType, data);
+
+    this.emit('eventTracked', event);
+  }
+
+  /**
+   * Update session metrics based on event
+   */
+  updateSessionMetrics(eventType, data) {
+    if (!this.currentSession) return;
+
+    switch (eventType) {
+      case 'interaction':
+        this.currentSession.metrics.interactions++;
+        break;
+        
+      case 'error':
+        this.currentSession.metrics.errors++;
+        break;
+        
+      case 'context_switch':
+        this.currentSession.metrics.tokenUsage.contextSwitches++;
+        break;
+        
+      case 'task_completed':
+        this.currentSession.metrics.completionStatus = 'completed';
+        break;
+        
+      case 'task_failed':
+        this.currentSession.metrics.completionStatus = 'failed';
+        break;
+    }
+  }
+
+  /**
+   * Track global events (not session-specific)
+   */
+  trackGlobalEvent(eventType, data) {
+    // Aggregate event counts
+    if (!this.metrics.aggregated.eventCounts) {
+      this.metrics.aggregated.eventCounts = {};
+    }
+    
+    this.metrics.aggregated.eventCounts[eventType] = 
+      (this.metrics.aggregated.eventCounts[eventType] || 0) + 1;
+
+    // Track persona switches
+    if (eventType === 'persona_switch') {
+      if (!this.metrics.aggregated.personaSwitches) {
+        this.metrics.aggregated.personaSwitches = [];
+      }
+      
+      this.metrics.aggregated.personaSwitches.push({
+        from: data.from,
+        to: data.to,
+        trigger: data.trigger,
+        timestamp: Date.now()
+      });
+    }
+  }
+
+  /**
+   * Calculate quality metrics for a session
+   */
+  calculateQualityMetrics(session) {
+    const metrics = {
+      completionTime: session.duration,
+      tokenEfficiency: this.calculateTokenEfficiency(session),
+      errorRate: this.calculateErrorRate(session),
+      interactionEfficiency: this.calculateInteractionEfficiency(session),
+      overallScore: 0
+    };
+
+    // Calculate overall score (0-1)
+    const weights = {
+      completion: 0.3,
+      tokenEfficiency: 0.3,
+      errorRate: 0.2,
+      interactionEfficiency: 0.2
+    };
+
+    let score = 0;
+    
+    // Completion score
+    if (session.metrics.completionStatus === 'completed') {
+      score += weights.completion;
+    }
+
+    // Token efficiency score
+    score += metrics.tokenEfficiency * weights.tokenEfficiency;
+
+    // Error rate score (inverse - lower is better)
+    score += (1 - metrics.errorRate) * weights.errorRate;
+
+    // Interaction efficiency score
+    score += metrics.interactionEfficiency * weights.interactionEfficiency;
+
+    metrics.overallScore = score;
+
+    return metrics;
+  }
+
+  /**
+   * Calculate token efficiency
+   */
+  calculateTokenEfficiency(session) {
+    const tokensUsed = (session.metrics.tokenUsage.end || 0) - 
+                      (session.metrics.tokenUsage.start || 0);
+    
+    if (tokensUsed === 0) return 1;
+
+    // Estimate expected tokens based on task complexity
+    const expectedTokens = session.task.complexity * 1000;
+    
+    // Efficiency is inverse of usage ratio (lower usage = higher efficiency)
+    const efficiency = Math.min(expectedTokens / tokensUsed, 1);
+    
+    return efficiency;
+  }
+
+  /**
+   * Calculate error rate
+   */
+  calculateErrorRate(session) {
+    if (session.metrics.interactions === 0) return 0;
+    
+    return Math.min(session.metrics.errors / session.metrics.interactions, 1);
+  }
+
+  /**
+   * Calculate interaction efficiency
+   */
+  calculateInteractionEfficiency(session) {
+    if (session.metrics.interactions === 0) return 0;
+    
+    // Estimate expected interactions based on task complexity
+    const expectedInteractions = Math.max(session.task.complexity * 2, 1);
+    
+    // Efficiency is inverse of interaction ratio
+    const efficiency = Math.min(expectedInteractions / session.metrics.interactions, 1);
+    
+    return efficiency;
+  }
+
+  /**
+   * Estimate task complexity
+   */
+  estimateTaskComplexity(task) {
+    let complexity = 1; // Base complexity
+
+    // Increase based on task type
+    const complexTypes = ['debug', 'optimize', 'architect', 'refactor'];
+    if (complexTypes.includes(task.type)) {
+      complexity += 1;
+    }
+
+    // Increase based on keywords
+    const complexKeywords = ['complex', 'difficult', 'large', 'entire', 'all'];
+    const description = (task.description || '').toLowerCase();
+    complexKeywords.forEach(keyword => {
+      if (description.includes(keyword)) {
+        complexity += 0.5;
+      }
+    });
+
+    // Cap at 5
+    return Math.min(complexity, 5);
+  }
+
+  /**
+   * Update persona performance metrics
+   */
+  updatePersonaPerformance(session) {
+    const personaName = session.persona;
+    
+    if (!this.metrics.personaPerformance[personaName]) {
+      this.metrics.personaPerformance[personaName] = {
+        totalSessions: 0,
+        completedSessions: 0,
+        totalDuration: 0,
+        totalTokens: 0,
+        totalErrors: 0,
+        qualityScores: [],
+        taskTypes: {}
+      };
+    }
+
+    const perf = this.metrics.personaPerformance[personaName];
+    
+    perf.totalSessions++;
+    if (session.metrics.completionStatus === 'completed') {
+      perf.completedSessions++;
+    }
+    
+    perf.totalDuration += session.duration;
+    
+    const tokensUsed = (session.metrics.tokenUsage.end || 0) - 
+                      (session.metrics.tokenUsage.start || 0);
+    perf.totalTokens += tokensUsed;
+    
+    perf.totalErrors += session.metrics.errors;
+    
+    if (session.qualityMetrics) {
+      perf.qualityScores.push(session.qualityMetrics.overallScore);
+    }
+    
+    // Track task types
+    const taskType = session.task.type;
+    perf.taskTypes[taskType] = (perf.taskTypes[taskType] || 0) + 1;
+  }
+
+  /**
+   * Get current token count (simulated)
+   */
+  getCurrentTokenCount() {
+    // In a real implementation, this would interface with the token tracking system
+    // For now, return a simulated increasing value
+    return Math.floor((Date.now() - this.startTime) / 100);
+  }
+
+  /**
+   * Collect current metrics
+   */
+  async collectCurrentMetrics() {
+    if (!this.currentSession) return null;
+
+    return {
+      duration: Date.now() - this.currentSession.startTime,
+      interactions: this.currentSession.metrics.interactions,
+      errors: this.currentSession.metrics.errors,
+      tokenUsage: {
+        current: this.getCurrentTokenCount() - this.currentSession.metrics.tokenUsage.start,
+        contextSwitches: this.currentSession.metrics.tokenUsage.contextSwitches
+      }
+    };
+  }
+
+  /**
+   * Get persona history
+   */
+  async getPersonaHistory(personaName) {
+    return this.metrics.sessions.filter(
+      session => session.persona === personaName
+    );
+  }
+
+  /**
+   * Get persona statistics
+   */
+  async getPersonaStats(personaName) {
+    const perf = this.metrics.personaPerformance[personaName];
+    
+    if (!perf || perf.totalSessions === 0) {
+      return {
+        message: `No data available for persona: ${personaName}`
+      };
+    }
+
+    const avgQualityScore = perf.qualityScores.length > 0 ?
+      perf.qualityScores.reduce((a, b) => a + b, 0) / perf.qualityScores.length : 0;
+
+    return {
+      totalSessions: perf.totalSessions,
+      completionRate: perf.completedSessions / perf.totalSessions,
+      averageDuration: perf.totalDuration / perf.totalSessions,
+      averageTokens: perf.totalTokens / perf.totalSessions,
+      errorRate: perf.totalErrors / perf.totalSessions,
+      averageQualityScore: avgQualityScore,
+      taskDistribution: perf.taskTypes
+    };
+  }
+
+  /**
+   * Generate comprehensive report
+   */
+  async generateReport(options = {}) {
+    const timeRange = options.timeRange || 'all';
+    const startTime = this.getStartTime(timeRange);
+    
+    // Filter sessions by time range
+    const sessions = this.metrics.sessions.filter(
+      session => session.startTime >= startTime
+    );
+
+    const report = {
+      generatedAt: new Date().toISOString(),
+      timeRange,
+      summary: {
+        totalSessions: sessions.length,
+        averageCompletionTime: this.calculateAverageTime(sessions),
+        personaUsage: this.getPersonaUsageStats(sessions),
+        qualityTrend: this.calculateQualityTrend(sessions)
+      },
+      personaAnalysis: this.analyzePersonaEffectiveness(sessions),
+      taskAnalysis: this.analyzeTaskTypes(sessions),
+      recommendations: this.generateRecommendations(sessions)
+    };
+
+    return report;
+  }
+
+  /**
+   * Get start time for time range
+   */
+  getStartTime(timeRange) {
+    const now = Date.now();
+    
+    switch (timeRange) {
+      case 'hour':
+        return now - 3600000;
+      case 'day':
+        return now - 86400000;
+      case 'week':
+        return now - 604800000;
+      case 'month':
+        return now - 2592000000;
+      default:
+        return 0;
+    }
+  }
+
+  /**
+   * Calculate average completion time
+   */
+  calculateAverageTime(sessions) {
+    if (sessions.length === 0) return 0;
+    
+    const totalTime = sessions.reduce((sum, session) => sum + session.duration, 0);
+    return totalTime / sessions.length;
+  }
+
+  /**
+   * Get persona usage statistics
+   */
+  getPersonaUsageStats(sessions) {
+    const usage = {};
+    
+    sessions.forEach(session => {
+      usage[session.persona] = (usage[session.persona] || 0) + 1;
+    });
+    
+    // Convert to percentages
+    const total = sessions.length;
+    const stats = {};
+    
+    for (const [persona, count] of Object.entries(usage)) {
+      stats[persona] = {
+        count,
+        percentage: (count / total) * 100
+      };
+    }
+    
+    return stats;
+  }
+
+  /**
+   * Calculate quality trend
+   */
+  calculateQualityTrend(sessions) {
+    if (sessions.length < 2) {
+      return { trend: 'insufficient_data' };
+    }
+
+    // Get quality scores over time
+    const scores = sessions
+      .filter(s => s.qualityMetrics)
+      .map(s => ({
+        time: s.startTime,
+        score: s.qualityMetrics.overallScore
+      }))
+      .sort((a, b) => a.time - b.time);
+
+    if (scores.length < 2) {
+      return { trend: 'insufficient_data' };
+    }
+
+    // Calculate trend (simple linear regression)
+    const n = scores.length;
+    const sumX = scores.reduce((sum, s, i) => sum + i, 0);
+    const sumY = scores.reduce((sum, s) => sum + s.score, 0);
+    const sumXY = scores.reduce((sum, s, i) => sum + i * s.score, 0);
+    const sumX2 = scores.reduce((sum, s, i) => sum + i * i, 0);
+
+    const slope = (n * sumXY - sumX * sumY) / (n * sumX2 - sumX * sumX);
+
+    return {
+      trend: slope > 0.01 ? 'improving' : slope < -0.01 ? 'declining' : 'stable',
+      slope,
+      latestScore: scores[scores.length - 1].score,
+      averageScore: sumY / n
+    };
+  }
+
+  /**
+   * Analyze persona effectiveness
+   */
+  analyzePersonaEffectiveness(sessions) {
+    const analysis = {};
+    
+    // Group sessions by persona
+    const personaSessions = {};
+    sessions.forEach(session => {
+      if (!personaSessions[session.persona]) {
+        personaSessions[session.persona] = [];
+      }
+      personaSessions[session.persona].push(session);
+    });
+
+    // Analyze each persona
+    for (const [persona, personaSessions] of Object.entries(personaSessions)) {
+      const completed = personaSessions.filter(s => s.metrics.completionStatus === 'completed');
+      const qualityScores = personaSessions
+        .filter(s => s.qualityMetrics)
+        .map(s => s.qualityMetrics.overallScore);
+
+      analysis[persona] = {
+        sessionCount: personaSessions.length,
+        completionRate: completed.length / personaSessions.length,
+        averageCompletionTime: this.calculateAverageTime(personaSessions),
+        averageQualityScore: qualityScores.length > 0 ?
+          qualityScores.reduce((a, b) => a + b, 0) / qualityScores.length : 0,
+        tokenEfficiency: this.calculateAverageTokenEfficiency(personaSessions),
+        bestUseCases: this.identifyBestUseCases(persona, personaSessions),
+        improvementAreas: this.identifyImprovementAreas(persona, personaSessions)
+      };
+    }
+
+    return analysis;
+  }
+
+  /**
+   * Calculate average token efficiency
+   */
+  calculateAverageTokenEfficiency(sessions) {
+    const efficiencies = sessions
+      .filter(s => s.qualityMetrics)
+      .map(s => s.qualityMetrics.tokenEfficiency);
+
+    if (efficiencies.length === 0) return 0;
+
+    return efficiencies.reduce((a, b) => a + b, 0) / efficiencies.length;
+  }
+
+  /**
+   * Identify best use cases for persona
+   */
+  identifyBestUseCases(persona, sessions) {
+    // Group by task type and calculate success rate
+    const taskStats = {};
+    
+    sessions.forEach(session => {
+      const taskType = session.task.type;
+      if (!taskStats[taskType]) {
+        taskStats[taskType] = {
+          total: 0,
+          successful: 0,
+          avgQuality: 0,
+          qualityCount: 0
+        };
+      }
+      
+      taskStats[taskType].total++;
+      
+      if (session.metrics.completionStatus === 'completed') {
+        taskStats[taskType].successful++;
+      }
+      
+      if (session.qualityMetrics) {
+        taskStats[taskType].avgQuality += session.qualityMetrics.overallScore;
+        taskStats[taskType].qualityCount++;
+      }
+    });
+
+    // Calculate success rates and find best
+    const taskScores = Object.entries(taskStats).map(([type, stats]) => ({
+      type,
+      successRate: stats.successful / stats.total,
+      avgQuality: stats.qualityCount > 0 ? stats.avgQuality / stats.qualityCount : 0,
+      count: stats.total
+    }));
+
+    // Return top 3 task types
+    return taskScores
+      .filter(t => t.count >= 2) // Minimum sample size
+      .sort((a, b) => (b.successRate + b.avgQuality) - (a.successRate + a.avgQuality))
+      .slice(0, 3)
+      .map(t => t.type);
+  }
+
+  /**
+   * Identify improvement areas
+   */
+  identifyImprovementAreas(persona, sessions) {
+    const areas = [];
+
+    // Check completion rate
+    const completionRate = sessions.filter(s => 
+      s.metrics.completionStatus === 'completed'
+    ).length / sessions.length;
+    
+    if (completionRate < 0.8) {
+      areas.push('completion_rate');
+    }
+
+    // Check error rate
+    const avgErrors = sessions.reduce((sum, s) => 
+      sum + s.metrics.errors, 0
+    ) / sessions.length;
+    
+    if (avgErrors > 1) {
+      areas.push('error_rate');
+    }
+
+    // Check token efficiency
+    const avgTokenEfficiency = this.calculateAverageTokenEfficiency(sessions);
+    if (avgTokenEfficiency < 0.5) {
+      areas.push('token_efficiency');
+    }
+
+    return areas;
+  }
+
+  /**
+   * Analyze task types
+   */
+  analyzeTaskTypes(sessions) {
+    const taskAnalysis = {};
+    
+    sessions.forEach(session => {
+      const taskType = session.task.type;
+      
+      if (!taskAnalysis[taskType]) {
+        taskAnalysis[taskType] = {
+          count: 0,
+          totalDuration: 0,
+          completedCount: 0,
+          totalQuality: 0,
+          qualityCount: 0,
+          personas: {}
+        };
+      }
+      
+      const analysis = taskAnalysis[taskType];
+      analysis.count++;
+      analysis.totalDuration += session.duration;
+      
+      if (session.metrics.completionStatus === 'completed') {
+        analysis.completedCount++;
+      }
+      
+      if (session.qualityMetrics) {
+        analysis.totalQuality += session.qualityMetrics.overallScore;
+        analysis.qualityCount++;
+      }
+      
+      // Track which personas handle this task type
+      analysis.personas[session.persona] = (analysis.personas[session.persona] || 0) + 1;
+    });
+
+    // Calculate averages
+    for (const [taskType, analysis] of Object.entries(taskAnalysis)) {
+      analysis.averageDuration = analysis.totalDuration / analysis.count;
+      analysis.completionRate = analysis.completedCount / analysis.count;
+      analysis.averageQuality = analysis.qualityCount > 0 ?
+        analysis.totalQuality / analysis.qualityCount : 0;
+      
+      // Find best persona for this task type
+      analysis.bestPersona = Object.entries(analysis.personas)
+        .sort(([,a], [,b]) => b - a)[0]?.[0];
+    }
+
+    return taskAnalysis;
+  }
+
+  /**
+   * Generate recommendations
+   */
+  generateRecommendations(sessions) {
+    const recommendations = [];
+    
+    // Analyze overall patterns
+    const personaAnalysis = this.analyzePersonaEffectiveness(sessions);
+    const taskAnalysis = this.analyzeTaskTypes(sessions);
+    
+    // Recommendation 1: Underutilized personas
+    for (const [persona, stats] of Object.entries(personaAnalysis)) {
+      if (stats.sessionCount < sessions.length * 0.1) {
+        recommendations.push({
+          type: 'persona_usage',
+          priority: 'medium',
+          message: `Consider using ${persona} persona more often for ${stats.bestUseCases.join(', ')} tasks`,
+          data: { persona, usage: stats.sessionCount }
+        });
+      }
+    }
+    
+    // Recommendation 2: Task-persona mismatches
+    for (const [taskType, analysis] of Object.entries(taskAnalysis)) {
+      if (analysis.averageQuality < 0.6 && analysis.count > 3) {
+        recommendations.push({
+          type: 'task_persona_match',
+          priority: 'high',
+          message: `${taskType} tasks have low quality scores. Try using ${analysis.bestPersona} persona`,
+          data: { taskType, currentQuality: analysis.averageQuality }
+        });
+      }
+    }
+    
+    // Recommendation 3: High error rates
+    for (const [persona, stats] of Object.entries(personaAnalysis)) {
+      if (stats.improvementAreas.includes('error_rate')) {
+        recommendations.push({
+          type: 'error_rate',
+          priority: 'high',
+          message: `${persona} persona has high error rate. Review context rules and tool recommendations`,
+          data: { persona, areas: stats.improvementAreas }
+        });
+      }
+    }
+    
+    return recommendations;
+  }
+
+  /**
+   * Load metrics from disk
+   */
+  async loadMetrics() {
+    try {
+      const metricsFile = path.join(this.options.metricsPath, 'metrics.json');
+      const data = await fs.readFile(metricsFile, 'utf-8');
+      const loaded = JSON.parse(data);
+      
+      // Merge with current metrics
+      this.metrics = {
+        ...this.metrics,
+        ...loaded,
+        sessions: [...(loaded.sessions || []), ...this.metrics.sessions]
+      };
+      
+      // Limit to max history size
+      if (this.metrics.sessions.length > this.options.maxHistorySize) {
+        this.metrics.sessions = this.metrics.sessions.slice(-this.options.maxHistorySize);
+      }
+    } catch (error) {
+      // No existing metrics or error loading - start fresh
+    }
+  }
+
+  /**
+   * Persist metrics to disk
+   */
+  async persistMetrics() {
+    try {
+      const metricsFile = path.join(this.options.metricsPath, 'metrics.json');
+      await fs.writeFile(
+        metricsFile,
+        JSON.stringify(this.metrics, null, 2),
+        'utf-8'
+      );
+      
+      this.emit('metricsPersisted', {
+        sessionCount: this.metrics.sessions.length
+      });
+    } catch (error) {
+      this.emit('error', { error, phase: 'persist' });
+    }
+  }
+
+  /**
+   * Start persist timer
+   */
+  startPersistTimer() {
+    this.persistTimer = setInterval(
+      () => this.persistMetrics(),
+      this.options.persistInterval
+    );
+  }
+
+  /**
+   * Generate session ID
+   */
+  generateSessionId() {
+    return `session_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+  }
+
+  /**
+   * Get current session metrics
+   */
+  async getCurrentSessionMetrics() {
+    if (!this.currentSession) {
+      return { message: 'No active session' };
+    }
+
+    return await this.collectCurrentMetrics();
+  }
+
+  /**
+   * Reset metrics
+   */
+  async reset() {
+    this.metrics = {
+      sessions: [],
+      personaPerformance: {},
+      taskOutcomes: [],
+      aggregated: {}
+    };
+    
+    this.currentSession = null;
+    
+    await this.persistMetrics();
+    
+    this.emit('reset');
+  }
+
+  /**
+   * Cleanup resources
+   */
+  async cleanup() {
+    if (this.persistTimer) {
+      clearInterval(this.persistTimer);
+      this.persistTimer = null;
+    }
+    
+    // Persist final metrics
+    await this.persistMetrics();
+    
+    this.removeAllListeners();
+  }
+}
+
+export default MetricsCollector;
+export { MetricsCollector };