0xray 4.0.13 → 4.0.15

package/dist/public/index.html

@@ -0,0 +1,145 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>⚡ 0xRay Dashboard</title>
+    <style>
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+            margin: 0;
+            padding: 20px;
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            color: white;
+            min-height: 100vh;
+        }
+        .container {
+            max-width: 1200px;
+            margin: 0 auto;
+        }
+        .header {
+            text-align: center;
+            margin-bottom: 40px;
+        }
+        .header h1 {
+            font-size: 3em;
+            margin-bottom: 10px;
+            text-shadow: 2px 2px 4px rgba(0,0,0,0.3);
+        }
+        .header p {
+            font-size: 1.2em;
+            opacity: 0.9;
+        }
+        .grid {
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(300px, 1fr));
+            gap: 20px;
+            margin-top: 30px;
+        }
+        .card {
+            background: rgba(255, 255, 255, 0.1);
+            border-radius: 10px;
+            padding: 20px;
+            backdrop-filter: blur(10px);
+            border: 1px solid rgba(255, 255, 255, 0.2);
+        }
+        .card h3 {
+            margin-top: 0;
+            color: #ffd700;
+        }
+        .agent-list {
+            display: grid;
+            grid-template-columns: repeat(2, 1fr);
+            gap: 10px;
+            margin-top: 15px;
+        }
+        .agent-item {
+            background: rgba(255, 255, 255, 0.1);
+            padding: 8px 12px;
+            border-radius: 5px;
+            font-size: 0.9em;
+        }
+        .status {
+            display: inline-block;
+            padding: 4px 8px;
+            border-radius: 4px;
+            font-size: 0.8em;
+            font-weight: bold;
+        }
+        .status.active {
+            background: #4CAF50;
+            color: white;
+        }
+        .footer {
+            text-align: center;
+            margin-top: 40px;
+            opacity: 0.7;
+            font-size: 0.9em;
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <div class="header">
+            <h1>⚡ 0xRay</h1>
+            <p>AI Agent Orchestration Framework - Production-Ready Code, No Dead Ends</p>
+        </div>
+
+        <div class="grid">
+            <div class="card">
+                <h3>🛡️ Framework Status</h3>
+                <p><strong>Version:</strong> 1.0.0</p>
+                <p><strong>Status:</strong> <span class="status active">Active</span></p>
+                <p><strong>Agents:</strong> 8 Specialized</p>
+                <p><strong>Error Prevention:</strong> 99.6%</p>
+            </div>
+
+            <div class="card">
+                <h3>🤖 AI Agents</h3>
+                <div class="agent-list" id="agents-list">
+                    <!-- Agents loaded via JavaScript -->
+                </div>
+            </div>
+
+            <div class="card">
+                <h3>🎯 Dead Ends Eliminated</h3>
+                <ul>
+                    <li>Spaghetti Code → Clean Lines</li>
+                    <li>AI Hallucinations → Grounded Output</li>
+                    <li>Code Rot → Modular Components</li>
+                    <li>Concurrency Chaos → Safe Patterns</li>
+                </ul>
+            </div>
+
+            <div class="card">
+                <h3>⚡ Quick Actions</h3>
+                <p><strong>Production-Ready Code:</strong> Every time</p>
+                <p><strong>99.6% Error Prevention:</strong> Built-in</p>
+                <p><strong>8 Agent Coordination:</strong> Seamless</p>
+                <p><strong>Ship Immediately:</strong> Clean. Tested. Modular. Done.</p>
+            </div>
+        </div>
+
+        <div class="footer">
+            <p>🛡️ 0xRay - The AI Sentinel: Your Unwavering Guardian Against AI Development Catastrophes</p>
+        </div>
+    </div>
+
+    <script>
+        // Load agents list
+        fetch('/api/agents')
+            .then(response => response.json())
+            .then(data => {
+                const agentsList = document.getElementById('agents-list');
+                data.agents.forEach(agent => {
+                    const agentItem = document.createElement('div');
+                    agentItem.className = 'agent-item';
+                    agentItem.textContent = agent.replace(/-/g, ' ').replace(/\b\w/g, l => l.toUpperCase());
+                    agentsList.appendChild(agentItem);
+                });
+            })
+            .catch(error => console.error('Error loading agents:', error));
+    </script>
+</body>
+</html></content>
+<parameter name="filePath">/Users/blaze/dev/xray/public/index.html

package/dist/public/index.js

@@ -0,0 +1,2 @@
+export { XrayService } from "./XrayService.js";
+export { beforeToolHook, afterToolHook } from "../integrations/enforcement-gate.js";

package/dist/reporting/framework-reporting-system.d.ts

@@ -0,0 +1,19 @@
+import { type ReportConfig, type ScheduleConfig, type RealtimeStatus, type CustomReportTemplate } from "./types.js";
+export type { ReportConfig, ReportData, OrchestrationMetrics, ParsedLogEntry, RealtimeStatus, ScheduleConfig, CustomReportTemplate } from "./types.js";
+export declare class FrameworkReportingSystem {
+    private logRetentionHours;
+    private reportCache;
+    generateReport(config: ReportConfig): Promise<string>;
+    scheduleAutomatedReports(schedule: ScheduleConfig): void;
+    getRealtimeStatus(): Promise<RealtimeStatus>;
+    createCustomReport(template: CustomReportTemplate): string;
+    private generateReportId;
+    private getCachedReport;
+    private isCacheValid;
+    private cacheReport;
+    private collectReportData;
+    private saveReportToFile;
+    private cleanupOldReports;
+    private getIntervalMs;
+}
+export declare const frameworkReportingSystem: FrameworkReportingSystem;

package/dist/reporting/framework-reporting-system.js

@@ -0,0 +1,187 @@
+import { frameworkLogger } from "../core/framework-logger.js";
+import * as fs from "fs";
+import * as path from "path";
+import { getComprehensiveLogs, filterLogsByConfig, frameworkLogToParsedEntry, } from "./log-parser.js";
+import { calculateTimeRange, calculateMetrics, calculatePeakActivity, calculateHealthScore, generateInsights, generateRecommendations, generateAlerts, } from "./metrics.js";
+import { formatReport } from "./report-formatter.js";
+export class FrameworkReportingSystem {
+    logRetentionHours = 24;
+    reportCache = new Map();
+    async generateReport(config) {
+        const reportId = this.generateReportId(config);
+        const cached = this.getCachedReport(reportId);
+        if (cached && this.isCacheValid(cached.timestamp)) {
+            return formatReport(cached.data, config.outputFormat);
+        }
+        const reportData = await this.collectReportData(config);
+        this.cacheReport(reportId, reportData);
+        const formattedReport = formatReport(reportData, config.outputFormat);
+        if (config.outputPath) {
+            await this.saveReportToFile(formattedReport, config.outputPath);
+        }
+        return formattedReport;
+    }
+    scheduleAutomatedReports(schedule) {
+        const intervalMs = this.getIntervalMs(schedule.frequency);
+        setInterval(async () => {
+            for (const type of schedule.types) {
+                const config = {
+                    type,
+                    timeRange: { lastHours: schedule.frequency === "hourly" ? 1 : 24 },
+                    outputFormat: "markdown",
+                    outputPath: path.join(schedule.outputDir, `${type}-report-${new Date().toISOString().split("T")[0]}.md`),
+                };
+                try {
+                    await this.generateReport(config);
+                    await frameworkLogger.log("framework-reporting-system", "automated-report-generated", "success", { reportType: type, outputPath: config.outputPath });
+                }
+                catch (error) {
+                    await frameworkLogger.log("framework-reporting-system", "automated-report-generation-failed", "error", { reportType: type, error: String(error) });
+                }
+            }
+            await this.cleanupOldReports(schedule.outputDir, schedule.retentionDays);
+        }, intervalMs);
+    }
+    async getRealtimeStatus() {
+        const recentLogs = frameworkLogger.getRecentLogs(50);
+        const parsedLogs = recentLogs.map(frameworkLogToParsedEntry);
+        const activeComponents = [
+            ...new Set(recentLogs.map((log) => log.component)),
+        ];
+        const recentActivity = parsedLogs.slice(0, 10);
+        const errorCount = recentLogs.filter((log) => log.status === "error").length;
+        const successCount = recentLogs.filter((log) => log.status === "success").length;
+        const healthScore = recentLogs.length > 0
+            ? (successCount / (successCount + errorCount)) * 100
+            : 100;
+        const alerts = generateAlerts(parsedLogs);
+        return {
+            activeComponents,
+            recentActivity,
+            healthScore,
+            alerts,
+        };
+    }
+    createCustomReport(template) {
+        return `
+# Custom Report: ${template.name}
+
+## Filters Applied
+${JSON.stringify(template.filters, null, 2)}
+
+## Aggregations
+${JSON.stringify(template.aggregations, null, 2)}
+
+## Visualizations
+${template.visualizations.join(", ")}
+
+## Usage
+\`\`\`typescript
+const report = await reportingSystem.generateCustomReport('${template.name}');
+\`\`\`
+    `;
+    }
+    generateReportId(config) {
+        const timeKey = config.timeRange?.lastHours || "all";
+        return `${config.type}-${config.outputFormat}-${timeKey}`;
+    }
+    getCachedReport(reportId) {
+        return this.reportCache.get(reportId) || null;
+    }
+    isCacheValid(timestamp) {
+        const cacheAgeMs = Date.now() - timestamp.getTime();
+        const maxCacheAgeMs = 5 * 60 * 1000;
+        return cacheAgeMs < maxCacheAgeMs;
+    }
+    cacheReport(reportId, data) {
+        this.reportCache.set(reportId, { data, timestamp: new Date() });
+        if (this.reportCache.size > 10) {
+            const keys = Array.from(this.reportCache.keys());
+            if (keys.length > 0) {
+                this.reportCache.delete(keys[0]);
+            }
+        }
+    }
+    async collectReportData(config) {
+        const logs = filterLogsByConfig(await getComprehensiveLogs(config), config);
+        const timeRange = calculateTimeRange(logs, config.timeRange);
+        const metrics = calculateMetrics(logs);
+        const chronologicalEvents = logs;
+        const insights = generateInsights(logs, metrics);
+        const recommendations = generateRecommendations(metrics);
+        const summary = {
+            totalEvents: logs.length,
+            activeComponents: [...new Set(logs.map((log) => log.component))],
+            peakActivity: calculatePeakActivity(logs),
+            healthScore: calculateHealthScore(logs),
+        };
+        return {
+            generatedAt: new Date(),
+            timeRange,
+            metrics,
+            chronologicalEvents,
+            insights,
+            recommendations,
+            summary,
+        };
+    }
+    async saveReportToFile(content, filePath) {
+        const dir = path.dirname(filePath);
+        await fs.promises.mkdir(dir, { recursive: true });
+        await fs.promises.writeFile(filePath, content, "utf8");
+    }
+    async cleanupOldReports(outputDir, retentionDays) {
+        try {
+            const files = await fs.promises.readdir(outputDir);
+            const cutoffTime = Date.now() - retentionDays * 24 * 60 * 60 * 1000;
+            for (const file of files) {
+                const filePath = path.join(outputDir, file);
+                const stats = await fs.promises.stat(filePath);
+                if (stats.mtime.getTime() < cutoffTime) {
+                    await fs.promises.unlink(filePath);
+                }
+            }
+        }
+        catch {
+            // Ignore cleanup errors
+        }
+    }
+    getIntervalMs(frequency) {
+        switch (frequency) {
+            case "hourly":
+                return 60 * 60 * 1000;
+            case "daily":
+                return 24 * 60 * 60 * 1000;
+            case "weekly":
+                return 7 * 24 * 60 * 60 * 1000;
+        }
+    }
+}
+export const frameworkReportingSystem = new FrameworkReportingSystem();
+if (import.meta.url === `file://${process.argv[1]}`) {
+    const args = process.argv.slice(2);
+    const reportType = args[0] || "full-analysis";
+    const outputFormat = args[1] || "markdown";
+    const config = {
+        type: reportType,
+        outputFormat,
+        outputPath: args[2] ||
+            `./reports/${reportType}-report-${new Date().toISOString().split("T")[0]}.${outputFormat === "markdown" ? "md" : outputFormat}`,
+        detailedMetrics: true,
+    };
+    frameworkReportingSystem
+        .generateReport(config)
+        .then(async (result) => {
+        await frameworkLogger.log("framework-reporting-system", "report-generated-successfully", "success", { message: "Report generated successfully" });
+        if (config.outputPath) {
+            await frameworkLogger.log("framework-reporting-system", "saved-to-output-path", "info", { message: `Saved to: ${config.outputPath}` });
+        }
+        else {
+            await frameworkLogger.log("framework-reporting-system", "result", "info", { message: result });
+        }
+    })
+        .catch(async (error) => {
+        await frameworkLogger.log("framework-reporting-system", "report-generation-failed", "error", { error: String(error) });
+        process.exit(1);
+    });
+}

package/dist/reporting/log-parser.d.ts

@@ -0,0 +1,10 @@
+import { type ParsedLogEntry, type ReportConfig } from "./types.js";
+export declare function levelToStatus(level: string): string;
+export declare function inferAgent(component: string): string;
+export declare function parseLogLine(line: string): ParsedLogEntry | null;
+export declare function frameworkLogToParsedEntry(entry: import("../core/framework-logger.js").FrameworkLogEntry): ParsedLogEntry;
+export declare function readCurrentLogFile(timeRange?: ReportConfig["timeRange"]): Promise<ParsedLogEntry[]>;
+export declare function parseCompressedLogFile(filePath: string, startTime: number, endTime: number): Promise<ParsedLogEntry[]>;
+export declare function readRotatedLogFiles(timeRange?: ReportConfig["timeRange"]): Promise<ParsedLogEntry[]>;
+export declare function getComprehensiveLogs(config: ReportConfig): Promise<ParsedLogEntry[]>;
+export declare function filterLogsByConfig(logs: ParsedLogEntry[], config: ReportConfig): ParsedLogEntry[];

package/dist/reporting/log-parser.js

@@ -0,0 +1,281 @@
+import * as fs from "fs";
+import * as path from "path";
+import { fileURLToPath } from "node:url";
+import { frameworkLogger } from "../core/framework-logger.js";
+export function levelToStatus(level) {
+    switch (level.toUpperCase()) {
+        case "ERROR":
+            return "error";
+        case "WARN":
+        case "WARNING":
+            return "warning";
+        case "INFO":
+            return "success";
+        case "DEBUG":
+            return "info";
+        default:
+            return "info";
+    }
+}
+export function inferAgent(component) {
+    if (component.includes("enforcer"))
+        return "enforcer";
+    if (component.includes("architect"))
+        return "architect";
+    if (component.includes("orchestrator"))
+        return "orchestrator";
+    if (component.includes("bug-triage"))
+        return "bug-triage-specialist";
+    if (component.includes("code-review"))
+        return "code-reviewer";
+    if (component.includes("security-audit"))
+        return "security-auditor";
+    if (component.includes("refactor"))
+        return "refactorer";
+    if (component.includes("testing-lead"))
+        return "testing-lead";
+    return "system";
+}
+export function parseLogLine(line) {
+    const logRegex = /^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z)\s+\[([^\]]+)\]\s+\[([^\]]+)\]\s+(.+?)\s+-\s+(\w+)$/;
+    const match = line.match(logRegex);
+    if (match && match[1] && match[2] && match[3] && match[4] && match[5]) {
+        const timestamp = match[1];
+        const jobId = match[2];
+        const component = match[3];
+        const message = match[4];
+        const level = match[5];
+        const action = message.includes(":")
+            ? (message.split(":")[0] || "").trim()
+            : message.trim();
+        const status = levelToStatus(level);
+        return {
+            timestamp: new Date(timestamp).getTime(),
+            jobId: jobId.trim(),
+            component: component.trim(),
+            action,
+            message: message.trim(),
+            level: level.toLowerCase(),
+            status,
+            agent: inferAgent(component),
+        };
+    }
+    const fallbackRegex = /^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z)\s+\[([^\]]+)\]\s+(.+?)\s+-\s+(\w+)$/;
+    const fallbackMatch = line.match(fallbackRegex);
+    if (fallbackMatch &&
+        fallbackMatch[1] &&
+        fallbackMatch[2] &&
+        fallbackMatch[3] &&
+        fallbackMatch[4]) {
+        const timestamp = fallbackMatch[1];
+        const component = fallbackMatch[2];
+        const message = fallbackMatch[3];
+        const level = fallbackMatch[4];
+        const action = message.includes(":")
+            ? (message.split(":")[0] || "").trim()
+            : message.trim();
+        const status = levelToStatus(level);
+        return {
+            timestamp: new Date(timestamp).getTime(),
+            jobId: null,
+            component: component.trim(),
+            action,
+            message: message.trim(),
+            level: level.toLowerCase(),
+            status,
+            agent: inferAgent(component),
+        };
+    }
+    return null;
+}
+export function frameworkLogToParsedEntry(entry) {
+    return {
+        timestamp: entry.timestamp,
+        component: entry.component,
+        action: entry.action,
+        message: entry.action,
+        level: entry.status,
+        status: entry.status,
+        agent: entry.agent,
+        jobId: entry.jobId ?? null,
+        sessionId: entry.sessionId,
+        details: entry.details,
+    };
+}
+export async function readCurrentLogFile(timeRange) {
+    const logs = [];
+    const currentFilePath = fileURLToPath(import.meta.url);
+    const projectRoot = path.resolve(path.dirname(currentFilePath), "../../");
+    const logDir = path.join(projectRoot, "logs", "framework");
+    const logFile = path.join(logDir, "activity.log");
+    try {
+        const fsModule = await import("fs");
+        if (!fsModule.existsSync(logFile)) {
+            return logs;
+        }
+        const content = fsModule.readFileSync(logFile, "utf8");
+        const lines = content.split("\n");
+        const startTime = timeRange?.start?.getTime() ??
+            (timeRange?.lastHours
+                ? Date.now() - timeRange.lastHours * 60 * 60 * 1000
+                : 0);
+        const endTime = timeRange?.end?.getTime() ?? Date.now();
+        for (const line of lines) {
+            if (line.trim()) {
+                try {
+                    const logEntry = parseLogLine(line);
+                    if (logEntry &&
+                        logEntry.timestamp >= startTime &&
+                        logEntry.timestamp <= endTime) {
+                        logs.push(logEntry);
+                    }
+                }
+                catch {
+                    // Continue processing other lines
+                }
+            }
+        }
+    }
+    catch (error) {
+        await frameworkLogger.log("framework-reporting-system", "current-log-read-failed", "warning", { error: String(error) });
+    }
+    return logs;
+}
+export async function parseCompressedLogFile(filePath, startTime, endTime) {
+    return new Promise((resolve, reject) => {
+        const logs = [];
+        (async () => {
+            try {
+                const zlib = await import("zlib");
+                const fsModule = await import("fs");
+                const readStream = fsModule.createReadStream(filePath);
+                const gunzip = zlib.createGunzip();
+                let buffer = "";
+                readStream
+                    .pipe(gunzip)
+                    .on("data", (chunk) => {
+                    buffer += chunk.toString();
+                    const lines = buffer.split("\n");
+                    buffer = lines.pop() || "";
+                    for (const line of lines) {
+                        if (line.trim()) {
+                            try {
+                                const logEntry = parseLogLine(line);
+                                if (logEntry &&
+                                    logEntry.timestamp >= startTime &&
+                                    logEntry.timestamp <= endTime) {
+                                    logs.push(logEntry);
+                                }
+                            }
+                            catch {
+                                // Skip malformed lines
+                            }
+                        }
+                    }
+                })
+                    .on("end", () => resolve(logs))
+                    .on("error", reject);
+            }
+            catch (error) {
+                reject(error);
+            }
+        })();
+    });
+}
+export async function readRotatedLogFiles(timeRange) {
+    const logs = [];
+    const logDir = path.join(process.cwd(), "logs", "framework");
+    if (!fs.existsSync(logDir))
+        return logs;
+    try {
+        const files = fs
+            .readdirSync(logDir)
+            .filter((file) => file.startsWith("framework-activity-") && file.endsWith(".log.gz"))
+            .sort()
+            .reverse();
+        const startTime = timeRange?.start?.getTime() ??
+            (timeRange?.lastHours
+                ? Date.now() - timeRange.lastHours * 60 * 60 * 1000
+                : 0);
+        const endTime = timeRange?.end?.getTime() ?? Date.now();
+        for (const file of files.slice(0, 3)) {
+            try {
+                const fileLogs = await parseCompressedLogFile(path.join(logDir, file), startTime, endTime);
+                logs.push(...fileLogs);
+                if (logs.length > 5000)
+                    break;
+            }
+            catch (error) {
+                await frameworkLogger.log("framework-reporting-system", "rotated-log-parse-failed", "warning", { file, error: String(error) });
+            }
+        }
+    }
+    catch (error) {
+        await frameworkLogger.log("framework-reporting-system", "rotated-logs-read-failed", "warning", { error: String(error) });
+    }
+    return logs;
+}
+export async function getComprehensiveLogs(config) {
+    const recentLogs = frameworkLogger.getRecentLogs(1000);
+    const convertedRecent = recentLogs.map(frameworkLogToParsedEntry);
+    let allLogs = [...convertedRecent];
+    try {
+        const currentLogs = await readCurrentLogFile(config.timeRange);
+        allLogs = [...allLogs, ...currentLogs];
+    }
+    catch (error) {
+        await frameworkLogger.log("framework-reporting-system", "current-log-read-failed", "warning", { error: String(error) });
+    }
+    if (config.timeRange &&
+        ((config.timeRange.lastHours && config.timeRange.lastHours > 24) ||
+            (config.timeRange.start &&
+                config.timeRange.end &&
+                config.timeRange.end.getTime() - config.timeRange.start.getTime() >
+                    24 * 60 * 60 * 1000))) {
+        try {
+            const rotatedLogs = await readRotatedLogFiles(config.timeRange);
+            allLogs = [...allLogs, ...rotatedLogs];
+        }
+        catch (error) {
+            await frameworkLogger.log("framework-reporting-system", "rotated-logs-read-failed", "warning", { error: String(error) });
+        }
+    }
+    const uniqueLogs = allLogs.filter((log, index, self) => index ===
+        self.findIndex((l) => l.timestamp === log.timestamp &&
+            l.component === log.component &&
+            l.action === log.action));
+    return uniqueLogs.sort((a, b) => a.timestamp - b.timestamp);
+}
+export function filterLogsByConfig(logs, config) {
+    let filtered = logs;
+    if (config.sessionId) {
+        filtered = filtered.filter((log) => log.sessionId === config.sessionId);
+    }
+    if (config.jobId) {
+        filtered = filtered.filter((log) => log.jobId === config.jobId);
+    }
+    if (config.timeRange) {
+        const startTime = config.timeRange.start?.getTime() ??
+            (config.timeRange.lastHours
+                ? Date.now() - config.timeRange.lastHours * 60 * 60 * 1000
+                : 0);
+        const endTime = config.timeRange.end?.getTime() ?? Date.now();
+        filtered = filtered.filter((log) => log.timestamp >= startTime && log.timestamp <= endTime);
+    }
+    switch (config.type) {
+        case "orchestration":
+            filtered = filtered.filter((log) => log.component === "agent-delegator" ||
+                log.action.includes("delegation"));
+            break;
+        case "agent-usage":
+            filtered = filtered.filter((log) => log.agent || log.component.includes("agent"));
+            break;
+        case "context-awareness":
+            filtered = filtered.filter((log) => log.component.includes("context") || log.component.includes("ast"));
+            break;
+        case "performance":
+            filtered = filtered.filter((log) => log.action.includes("complete") || log.action.includes("failed"));
+            break;
+    }
+    return filtered;
+}

package/dist/reporting/metrics.d.ts

@@ -0,0 +1,15 @@
+import type { ParsedLogEntry, OrchestrationMetrics, ReportConfig } from "./types.js";
+export declare function calculateTimeRange(logs: ParsedLogEntry[], timeRange?: ReportConfig["timeRange"]): {
+    start: Date;
+    end: Date;
+};
+export declare function calculateMetrics(logs: ParsedLogEntry[]): OrchestrationMetrics;
+export declare function calculatePeakActivity(logs: ParsedLogEntry[]): {
+    timestamp: Date;
+    eventsPerMinute: number;
+};
+export declare function calculateHealthScore(logs: ParsedLogEntry[]): number;
+export declare function generateInsights(logs: ParsedLogEntry[], metrics: OrchestrationMetrics): string[];
+export declare function generateRecommendations(metrics: OrchestrationMetrics): string[];
+export declare function generateAlerts(logs: ParsedLogEntry[]): string[];
+export declare function getHighFrequencyComponents(logs: ParsedLogEntry[]): string[];