claude-flow-novice 2.0.0 → 2.0.1

package/.claude-flow-novice/dist/src/cfn-loop/crash-detector.js

@@ -0,0 +1,362 @@
+/**
+ * Crash Detection System - Detect and Analyze Interrupted CFN Loop Executions
+ *
+ * Detects interrupted executions on CLI startup by scanning Redis for:
+ * - Epics with stale heartbeats (>5 minutes without update)
+ * - Sprints in progress vs completed states
+ * - Checkpoint timestamps vs current time
+ * - Estimated work loss and recovery time
+ *
+ * Acceptance Criteria:
+ * - Detect interrupted epics within 5 seconds of CLI start
+ * - Show accurate sprint progress percentages
+ * - Calculate estimated recovery time
+ * - Differentiate between crash and clean shutdown
+ *
+ * @module cfn-loop/crash-detector
+ */ function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+import { EventEmitter } from "node:events";
+import { Logger } from "../core/logger.js";
+import { createClient } from "redis";
+// ===== CRASH DETECTOR =====
+/**
+ * Detects interrupted CFN Loop executions on CLI startup
+ *
+ * Features:
+ * - Fast detection (<5 seconds)
+ * - Redis heartbeat analysis
+ * - Sprint progress calculation
+ * - Work loss estimation
+ * - Clean shutdown differentiation
+ *
+ * Usage:
+ * ```typescript
+ * const detector = new CrashDetector({
+ *   heartbeatTimeoutMs: 300000 // 5 minutes
+ * });
+ *
+ * await detector.initialize();
+ * const interrupted = await detector.detectInterruptedExecutions();
+ * ```
+ */ export class CrashDetector extends EventEmitter {
+    /**
+   * Initialize Redis connection
+   */ async initialize() {
+        try {
+            this.logger.info('Initializing crash detector');
+            // Create Redis client
+            this.redis = createClient({
+                url: this.config.redisUrl
+            });
+            this.redis.on('error', (err)=>{
+                this.logger.error('Redis client error', {
+                    error: err.message
+                });
+                this.emit('error', err);
+            });
+            await this.redis.connect();
+            this.logger.info('Crash detector initialized');
+            this.emit('initialized');
+        } catch (error) {
+            this.logger.error('Failed to initialize crash detector', {
+                error
+            });
+            throw error;
+        }
+    }
+    /**
+   * Detect all interrupted executions
+   */ async detectInterruptedExecutions() {
+        if (!this.redis) {
+            throw new Error('Redis not initialized');
+        }
+        const startTime = Date.now();
+        const interrupted = [];
+        try {
+            this.logger.info('Starting crash detection scan');
+            // Scan for stale heartbeats with timeout
+            const staleEpicIds = await this.withTimeout(this.scanRedisForStaleHeartbeats(), this.config.scanTimeoutMs, 'Heartbeat scan timeout');
+            this.stats.totalEpicsScanned = staleEpicIds.length;
+            // Analyze each stale epic
+            for (const epicId of staleEpicIds){
+                try {
+                    const execution = await this.analyzeInterruptedEpic(epicId);
+                    if (execution) {
+                        interrupted.push(execution);
+                        if (execution.isCleanShutdown) {
+                            this.stats.cleanShutdownsFound++;
+                        } else {
+                            this.stats.interruptedEpicsFound++;
+                        }
+                    }
+                } catch (error) {
+                    this.logger.error('Failed to analyze epic', {
+                        epicId,
+                        error
+                    });
+                }
+            }
+            // Update statistics
+            this.stats.scanDurationMs = Date.now() - startTime;
+            this.logger.info('Crash detection scan completed', {
+                interrupted: interrupted.length,
+                cleanShutdowns: this.stats.cleanShutdownsFound,
+                durationMs: this.stats.scanDurationMs
+            });
+            this.emit('scan-completed', {
+                interrupted,
+                stats: this.stats
+            });
+            return interrupted;
+        } catch (error) {
+            this.logger.error('Crash detection scan failed', {
+                error
+            });
+            throw error;
+        }
+    }
+    /**
+   * Scan Redis for running epics without recent heartbeats
+   */ async scanRedisForStaleHeartbeats() {
+        if (!this.redis) {
+            throw new Error('Redis not initialized');
+        }
+        try {
+            const now = Date.now();
+            const staleEpicIds = [];
+            // Find all epic heartbeat keys
+            const heartbeatKeys = await this.redis.keys('cfn:epic:*:heartbeat');
+            this.stats.redisKeysScanned += heartbeatKeys.length;
+            for (const key of heartbeatKeys){
+                const heartbeatData = await this.redis.get(key);
+                if (!heartbeatData) continue;
+                try {
+                    const heartbeat = JSON.parse(heartbeatData);
+                    const timeSinceHeartbeat = now - heartbeat.timestamp;
+                    // Check if heartbeat is stale (>5 minutes old)
+                    if (timeSinceHeartbeat > this.config.heartbeatTimeoutMs) {
+                        // Extract epic ID from key: cfn:epic:{epicId}:heartbeat
+                        const epicId = key.split(':')[2];
+                        staleEpicIds.push(epicId);
+                        this.logger.debug('Stale heartbeat detected', {
+                            epicId,
+                            timeSinceHeartbeat,
+                            lastHeartbeat: heartbeat.timestamp
+                        });
+                    }
+                } catch (error) {
+                    this.logger.warn('Failed to parse heartbeat data', {
+                        key,
+                        error
+                    });
+                }
+            }
+            return staleEpicIds;
+        } catch (error) {
+            this.logger.error('Failed to scan for stale heartbeats', {
+                error
+            });
+            throw error;
+        }
+    }
+    /**
+   * Analyze a specific interrupted epic
+   */ async analyzeInterruptedEpic(epicId) {
+        if (!this.redis) return null;
+        try {
+            // Get latest checkpoint
+            const checkpointKey = await this.redis.get(`cfn:checkpoint:${epicId}:latest`);
+            if (!checkpointKey) {
+                this.logger.debug('No checkpoint found for epic', {
+                    epicId
+                });
+                return null;
+            }
+            // Extract checkpoint version
+            const versionMatch = checkpointKey.match(/checkpoint-.+-(\d+)/);
+            if (!versionMatch) return null;
+            const checkpointVersion = parseInt(versionMatch[1], 10);
+            // Get checkpoint data
+            const checkpointData = await this.redis.get(checkpointKey.replace(':latest', `:${checkpointVersion}`));
+            if (!checkpointData) return null;
+            const { metadata, serialized } = JSON.parse(checkpointData);
+            // Parse epic state (simplified - in production would use CheckpointSerializer)
+            const epicState = JSON.parse(serialized.compressed || serialized.data);
+            // Get heartbeat data
+            const heartbeatData = await this.redis.get(`cfn:epic:${epicId}:heartbeat`);
+            const heartbeat = heartbeatData ? JSON.parse(heartbeatData) : null;
+            // Determine if clean shutdown
+            const isCleanShutdown = await this.differentiateCleanShutdown(epicId, epicState);
+            // Calculate sprint progress
+            const sprintsInProgress = this.calculateSprintProgress(epicState.sprints);
+            const sprintsCompleted = epicState.sprints.filter((s)=>s.status === 'completed').length;
+            // Calculate work loss and recovery time
+            const estimatedWorkLoss = this.calculateWorkLoss(epicState.sprints);
+            const recoveryTimeEstimate = await this.calculateRecoveryEstimate(epicId, epicState);
+            const execution = {
+                epicId,
+                epicName: epicState.name,
+                lastHeartbeat: heartbeat?.timestamp || metadata.timestamp,
+                timeSinceHeartbeat: Date.now() - (heartbeat?.timestamp || metadata.timestamp),
+                sprintsInProgress,
+                sprintsCompleted,
+                sprintsTotal: epicState.sprints.length,
+                estimatedWorkLoss,
+                recoveryTimeEstimate,
+                isCleanShutdown,
+                checkpointVersion,
+                lastCheckpointTime: metadata.timestamp
+            };
+            return execution;
+        } catch (error) {
+            this.logger.error('Failed to analyze interrupted epic', {
+                epicId,
+                error
+            });
+            return null;
+        }
+    }
+    /**
+   * Calculate sprint progress percentages
+   */ calculateSprintProgress(sprints) {
+        const inProgressSprints = [];
+        for (const sprint of sprints){
+            if (sprint.status !== 'in-progress') continue;
+            const phasesCompleted = sprint.phases.filter((p)=>p.status === 'completed').length;
+            const phasesTotal = sprint.phases.length;
+            const progress = phasesTotal > 0 ? phasesCompleted / phasesTotal : 0;
+            // Collect files in progress from phases
+            const filesInProgress = [];
+            for (const phase of sprint.phases){
+                if (phase.status !== 'completed' && phase.deliverables.length > 0) {
+                    filesInProgress.push(...phase.deliverables);
+                }
+            }
+            inProgressSprints.push({
+                sprintId: sprint.sprintId,
+                name: sprint.name,
+                progress,
+                filesInProgress,
+                phasesCompleted,
+                phasesTotal,
+                lastUpdateTime: sprint.lastUpdateTime
+            });
+        }
+        return inProgressSprints;
+    }
+    /**
+   * Calculate estimated work loss percentage
+   */ calculateWorkLoss(sprints) {
+        let totalPhases = 0;
+        let completedPhases = 0;
+        let inProgressPhases = 0;
+        for (const sprint of sprints){
+            totalPhases += sprint.phases.length;
+            completedPhases += sprint.phases.filter((p)=>p.status === 'completed').length;
+            inProgressPhases += sprint.phases.filter((p)=>p.status === 'loop3-in-progress' || p.status === 'loop2-validation').length;
+        }
+        if (totalPhases === 0) return 0;
+        // Work loss is the percentage of in-progress work that may need to be redone
+        // Completed work is safe, in-progress work may be partially lost
+        const workLossPercentage = inProgressPhases / totalPhases * 100;
+        return Math.round(workLossPercentage * 10) / 10; // Round to 1 decimal
+    }
+    /**
+   * Calculate estimated recovery time in minutes
+   */ async calculateRecoveryEstimate(epicId, epicState) {
+        let totalRecoveryMin = 0;
+        for (const sprint of epicState.sprints){
+            const inProgressPhases = sprint.phases.filter((p)=>p.status !== 'completed' && p.status !== 'failed').length;
+            // Estimate recovery time: 5 minutes per incomplete phase (configurable)
+            totalRecoveryMin += inProgressPhases * this.config.recoveryTimePerPhaseMin;
+        }
+        return totalRecoveryMin;
+    }
+    /**
+   * Differentiate between crash and clean shutdown
+   */ async differentiateCleanShutdown(epicId, epicState) {
+        if (!this.redis) return false;
+        try {
+            // Check for clean shutdown marker
+            const shutdownMarker = await this.redis.get(`cfn:epic:${epicId}:shutdown`);
+            if (shutdownMarker) {
+                return true;
+            }
+            // Check epic status
+            if (epicState.status === 'completed' || epicState.status === 'failed') {
+                return true;
+            }
+            // Check if all sprints are completed or failed
+            const allSprintsFinished = epicState.sprints.every((s)=>s.status === 'completed' || s.status === 'failed');
+            if (allSprintsFinished) {
+                return true;
+            }
+            // Otherwise, assume crash
+            return false;
+        } catch (error) {
+            this.logger.warn('Failed to check clean shutdown', {
+                epicId,
+                error
+            });
+            return false;
+        }
+    }
+    /**
+   * Get crash detection statistics
+   */ getStats() {
+        return {
+            ...this.stats
+        };
+    }
+    /**
+   * Helper to execute promise with timeout
+   */ async withTimeout(promise, timeoutMs, errorMessage) {
+        return Promise.race([
+            promise,
+            new Promise((_, reject)=>setTimeout(()=>reject(new Error(errorMessage)), timeoutMs))
+        ]);
+    }
+    /**
+   * Shutdown crash detector and close Redis connection
+   */ async shutdown() {
+        if (this.redis) {
+            await this.redis.quit();
+            this.redis = null;
+        }
+        this.logger.info('Crash detector shutdown');
+        this.emit('shutdown');
+    }
+    constructor(config = {}){
+        super(), _define_property(this, "logger", void 0), _define_property(this, "config", void 0), _define_property(this, "redis", null), _define_property(this, "stats", void 0);
+        this.logger = new Logger({
+            level: 'info',
+            format: 'json',
+            name: 'CrashDetector'
+        }, 'CrashDetector');
+        this.config = {
+            redisUrl: config.redisUrl || 'redis://localhost:6379',
+            heartbeatTimeoutMs: config.heartbeatTimeoutMs || 300000,
+            scanTimeoutMs: config.scanTimeoutMs || 5000,
+            recoveryTimePerPhaseMin: config.recoveryTimePerPhaseMin || 5
+        };
+        this.stats = {
+            totalEpicsScanned: 0,
+            interruptedEpicsFound: 0,
+            cleanShutdownsFound: 0,
+            scanDurationMs: 0,
+            redisKeysScanned: 0
+        };
+    }
+}

package/.claude-flow-novice/dist/src/cfn-loop/epic-report-generator.js

@@ -0,0 +1,283 @@
+/**
+ * Epic Report Generator with Coordination Validation
+ *
+ * Generates comprehensive epic completion reports including:
+ * - Coordination validation results
+ * - Timeline analysis
+ * - Sprint summaries
+ * - Consensus scores
+ * - Issue tracking
+ *
+ * @module cfn-loop/epic-report-generator
+ */ function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+import { CoordinationValidator } from "./coordination-validator.js";
+/**
+ * EpicReportGenerator generates comprehensive epic completion reports
+ *
+ * Uses CoordinationValidator to verify Redis pub/sub coordination
+ * and formats results into human-readable markdown reports.
+ *
+ * @example
+ * ```typescript
+ * const generator = new EpicReportGenerator({ redis });
+ * const report = await generator.generateReport('epic-123');
+ *
+ * console.log(report.markdown);
+ * ```
+ */ export class EpicReportGenerator {
+    /**
+   * Generate complete epic report
+   *
+   * @param epicId - Epic identifier
+   * @returns Complete epic report with validation
+   */ async generateReport(epicId) {
+        // Collect epic metadata
+        const metadata = await this.collectEpicMetadata(epicId);
+        // Run coordination validation
+        const validation = await this.validator.validateEpicCoordination(epicId);
+        // Generate summary
+        const summary = this.generateSummary(metadata, validation);
+        // Generate markdown report
+        const markdown = this.generateMarkdown(metadata, validation);
+        return {
+            metadata,
+            validation,
+            summary,
+            markdown,
+            timestamp: Date.now()
+        };
+    }
+    /**
+   * Collect epic metadata from Redis
+   *
+   * @param epicId - Epic identifier
+   * @returns Epic metadata
+   */ async collectEpicMetadata(epicId) {
+        // Get epic metadata from Redis
+        const epicKey = `epic:${epicId}:metadata`;
+        const epicDataRaw = await this.redis.get(epicKey);
+        let epicData = {};
+        if (epicDataRaw) {
+            try {
+                epicData = JSON.parse(epicDataRaw);
+            } catch (e) {
+                console.warn(`Failed to parse epic metadata for ${epicId}:`, e);
+            }
+        }
+        // Collect sprint summaries
+        const sprintKeys = await this.redis.keys(`epic:${epicId}:sprint:*`);
+        const sprints = [];
+        for (const key of sprintKeys){
+            const sprintDataRaw = await this.redis.get(key);
+            if (!sprintDataRaw) continue;
+            try {
+                const sprintData = JSON.parse(sprintDataRaw);
+                sprints.push({
+                    sprintId: sprintData.sprintId || key.split(':').pop() || 'unknown',
+                    name: sprintData.name || 'Unknown Sprint',
+                    status: sprintData.status || 'completed',
+                    confidence: sprintData.confidence || 0,
+                    consensusScore: sprintData.consensusScore || 0,
+                    startTime: sprintData.startTime || 0,
+                    endTime: sprintData.endTime || Date.now(),
+                    duration: sprintData.duration || 0,
+                    agents: sprintData.agents || [],
+                    deliverables: sprintData.deliverables || []
+                });
+            } catch (e) {
+                console.warn(`Failed to parse sprint data for ${key}:`, e);
+            }
+        }
+        // Calculate overall metrics
+        const totalAgents = new Set(sprints.flatMap((s)=>s.agents)).size;
+        const overallConfidence = sprints.length > 0 ? sprints.reduce((sum, s)=>sum + s.confidence, 0) / sprints.length : 0;
+        const overallConsensus = sprints.length > 0 ? sprints.reduce((sum, s)=>sum + s.consensusScore, 0) / sprints.length : 0;
+        const startTime = sprints.length > 0 ? Math.min(...sprints.map((s)=>s.startTime)) : Date.now();
+        const endTime = sprints.length > 0 ? Math.max(...sprints.map((s)=>s.endTime)) : Date.now();
+        return {
+            epicId,
+            name: epicData.name || `Epic ${epicId}`,
+            description: epicData.description,
+            startTime,
+            endTime,
+            totalDuration: endTime - startTime,
+            sprints: sprints.sort((a, b)=>a.startTime - b.startTime),
+            totalAgents,
+            overallConfidence,
+            overallConsensus
+        };
+    }
+    /**
+   * Generate text summary
+   *
+   * @param metadata - Epic metadata
+   * @param validation - Validation result
+   * @returns Text summary
+   */ generateSummary(metadata, validation) {
+        const passEmoji = validation.valid ? '✅' : '❌';
+        const scorePercent = (validation.score * 100).toFixed(1);
+        const confidencePercent = (metadata.overallConfidence * 100).toFixed(1);
+        const consensusPercent = (metadata.overallConsensus * 100).toFixed(1);
+        return `Epic ${metadata.epicId} ${passEmoji}
+Score: ${scorePercent}% | Confidence: ${confidencePercent}% | Consensus: ${consensusPercent}%
+Sprints: ${metadata.sprints.length} | Agents: ${metadata.totalAgents} | Messages: ${validation.metrics.totalMessages}`;
+    }
+    /**
+   * Generate markdown report
+   *
+   * @param metadata - Epic metadata
+   * @param validation - Validation result
+   * @returns Markdown report
+   */ generateMarkdown(metadata, validation) {
+        const passEmoji = validation.valid ? '✅' : '❌';
+        const scorePercent = (validation.score * 100).toFixed(1);
+        const confidencePercent = (metadata.overallConfidence * 100).toFixed(1);
+        const consensusPercent = (metadata.overallConsensus * 100).toFixed(1);
+        let markdown = `# Epic Completion Report: ${metadata.name}
+
+**Epic ID**: ${metadata.epicId}
+**Status**: ${passEmoji} ${validation.valid ? 'PASSED' : 'FAILED'}
+**Generated**: ${new Date(validation.timestamp).toISOString()}
+
+## Summary
+
+- **Overall Score**: ${scorePercent}%
+- **Confidence**: ${confidencePercent}%
+- **Consensus**: ${consensusPercent}%
+- **Sprints**: ${metadata.sprints.length}
+- **Agents**: ${metadata.totalAgents}
+- **Duration**: ${this.formatDuration(metadata.totalDuration)}
+
+## Coordination Validation
+
+**Validation Score**: ${scorePercent}% ${passEmoji}
+
+### Metrics
+
+- **Total Messages**: ${validation.metrics.totalMessages}
+- **Coordinators**: ${validation.metrics.coordinators.length} (${validation.metrics.coordinators.join(', ')})
+- **Channels Used**: ${validation.metrics.channelsUsed.join(', ')}
+- **Dependency Waiting**: ${validation.metrics.dependencyWaiting ? '✅' : '❌'}
+- **Interface Publishing**: ${validation.metrics.interfacePublishing ? '✅' : '❌'}
+- **Agent Lifecycle**: ${validation.metrics.agentLifecycleTracking ? '✅' : '❌'}
+- **Test Coordination**: ${validation.metrics.testCoordination ? '✅' : '❌'}
+
+`;
+        // Add issues section
+        if (this.config.includeIssues && validation.issues.length > 0) {
+            markdown += `### Issues Found\n\n`;
+            for (const issue of validation.issues){
+                const emoji = issue.severity === 'critical' ? '🚨' : issue.severity === 'high' ? '⚠️' : issue.severity === 'medium' ? '💡' : 'ℹ️';
+                markdown += `${emoji} **[${issue.severity.toUpperCase()}]** ${issue.issue}\n`;
+                markdown += `> ${issue.description}\n`;
+                if (this.config.includeRecommendations && issue.recommendation) {
+                    markdown += `> **Recommendation**: ${issue.recommendation}\n`;
+                }
+                markdown += '\n';
+            }
+        }
+        // Add timeline sample
+        if (this.config.includeTimeline && validation.metrics.timeline.length > 0) {
+            markdown += `### Timeline Sample (First ${this.config.maxTimelineEvents} Events)\n\n`;
+            const sample = validation.metrics.timeline.slice(0, this.config.maxTimelineEvents);
+            for (const event of sample){
+                const time = new Date(event.timestamp).toISOString();
+                markdown += `- **[${time}]** \`${event.channel}\` - ${event.type} (${event.coordinatorId})\n`;
+            }
+            markdown += '\n';
+        }
+        // Add sprint summaries
+        markdown += `## Sprint Summaries\n\n`;
+        for (const sprint of metadata.sprints){
+            const sprintEmoji = sprint.status === 'completed' ? '✅' : sprint.status === 'failed' ? '❌' : '⏳';
+            const sprintConfidence = (sprint.confidence * 100).toFixed(1);
+            const sprintConsensus = (sprint.consensusScore * 100).toFixed(1);
+            markdown += `### ${sprintEmoji} ${sprint.name}\n\n`;
+            markdown += `- **Sprint ID**: ${sprint.sprintId}\n`;
+            markdown += `- **Status**: ${sprint.status}\n`;
+            markdown += `- **Confidence**: ${sprintConfidence}%\n`;
+            markdown += `- **Consensus**: ${sprintConsensus}%\n`;
+            markdown += `- **Duration**: ${this.formatDuration(sprint.duration)}\n`;
+            markdown += `- **Agents**: ${sprint.agents.length} (${sprint.agents.join(', ')})\n`;
+            markdown += `- **Deliverables**: ${sprint.deliverables.length}\n`;
+            markdown += '\n';
+        }
+        // Add footer
+        markdown += `---
+
+**Report Generated**: ${new Date().toISOString()}
+**CFN Loop Version**: 2.0
+**Coordination Protocol**: Redis pub/sub (Rule #19)
+`;
+        return markdown;
+    }
+    /**
+   * Format duration in human-readable format
+   *
+   * @param ms - Duration in milliseconds
+   * @returns Formatted duration
+   */ formatDuration(ms) {
+        const seconds = Math.floor(ms / 1000);
+        const minutes = Math.floor(seconds / 60);
+        const hours = Math.floor(minutes / 60);
+        const days = Math.floor(hours / 24);
+        if (days > 0) return `${days}d ${hours % 24}h`;
+        if (hours > 0) return `${hours}h ${minutes % 60}m`;
+        if (minutes > 0) return `${minutes}m ${seconds % 60}s`;
+        return `${seconds}s`;
+    }
+    /**
+   * Save report to Redis
+   *
+   * @param epicId - Epic identifier
+   * @param report - Epic report
+   */ async saveReport(epicId, report) {
+        const key = `epic:${epicId}:report`;
+        await this.redis.setex(key, 86400, JSON.stringify(report)); // 24 hour TTL
+    }
+    /**
+   * Load report from Redis
+   *
+   * @param epicId - Epic identifier
+   * @returns Epic report or null if not found
+   */ async loadReport(epicId) {
+        const key = `epic:${epicId}:report`;
+        const data = await this.redis.get(key);
+        if (!data) return null;
+        try {
+            return JSON.parse(data);
+        } catch (e) {
+            console.warn(`Failed to parse epic report for ${epicId}:`, e);
+            return null;
+        }
+    }
+    constructor(config){
+        _define_property(this, "redis", void 0);
+        _define_property(this, "validator", void 0);
+        _define_property(this, "config", void 0);
+        this.redis = config.redis;
+        this.validator = new CoordinationValidator({
+            redis: config.redis
+        });
+        this.config = {
+            redis: config.redis,
+            includeTimeline: config.includeTimeline !== false,
+            maxTimelineEvents: config.maxTimelineEvents || 10,
+            includeIssues: config.includeIssues !== false,
+            includeRecommendations: config.includeRecommendations !== false
+        };
+    }
+}
+export default EpicReportGenerator;