0xray 2.0.0

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.js

@@ -0,0 +1,281 @@
+import * as fs from "fs";
+import * as path from "path";
+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 currentFileUrl = import.meta.url;
+    const currentFilePath = new URL(currentFileUrl).pathname;
+    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.js

@@ -0,0 +1,202 @@
+export function calculateTimeRange(logs, timeRange) {
+    if (logs.length === 0) {
+        return { start: new Date(), end: new Date() };
+    }
+    const timestamps = logs.map((log) => log.timestamp);
+    return {
+        start: new Date(Math.min(...timestamps)),
+        end: new Date(Math.max(...timestamps)),
+    };
+}
+export function calculateMetrics(logs) {
+    const agentUsage = new Map();
+    const complexityDistribution = new Map();
+    const commandUsage = new Map();
+    const toolSuccessRate = new Map();
+    let totalDelegations = 0;
+    let contextOperations = 0;
+    let enhancementFailures = 0;
+    let enhancementSuccesses = 0;
+    let fileOperations = 0;
+    let searchOperations = 0;
+    let terminalOperations = 0;
+    let analysisOperations = 0;
+    let orchestrationOperations = 0;
+    const responseTimes = [];
+    for (const log of logs) {
+        if (log.agent) {
+            agentUsage.set(log.agent, (agentUsage.get(log.agent) || 0) + 1);
+        }
+        if (log.action === "delegation decision made") {
+            totalDelegations++;
+            orchestrationOperations++;
+        }
+        if (log.component.includes("context") || log.component.includes("ast")) {
+            contextOperations++;
+            analysisOperations++;
+        }
+        if (log.action === "context-enhancement-failed") {
+            enhancementFailures++;
+        }
+        if (log.component === "complexity-analyzer" && log.status === "success") {
+            enhancementSuccesses++;
+        }
+        if (log.component === "framework-activity") {
+            const toolName = log.details?.tool || log.action;
+            commandUsage.set(toolName, (commandUsage.get(toolName) || 0) + 1);
+            if (!toolSuccessRate.has(toolName)) {
+                toolSuccessRate.set(toolName, { success: 0, total: 0, rate: 0 });
+            }
+            const toolStats = toolSuccessRate.get(toolName);
+            toolStats.total++;
+            if (log.status === "success") {
+                toolStats.success++;
+            }
+            toolStats.rate =
+                toolStats.total > 0 ? (toolStats.success / toolStats.total) * 100 : 0;
+            if (["write", "edit", "read"].includes(toolName)) {
+                fileOperations++;
+            }
+            else if (["grep", "glob"].includes(toolName)) {
+                searchOperations++;
+            }
+            else if (toolName === "bash") {
+                terminalOperations++;
+            }
+        }
+        if (log.component.includes("analyzer") ||
+            log.action.includes("analysis")) {
+            analysisOperations++;
+        }
+    }
+    toolSuccessRate.forEach((stats) => {
+        stats.rate = stats.total > 0 ? (stats.success / stats.total) * 100 : 0;
+    });
+    const successLogs = logs.filter((log) => log.status === "success");
+    const errorLogs = logs.filter((log) => log.status === "error");
+    const successRate = logs.length > 0 ? (successLogs.length / logs.length) * 100 : 100;
+    const enhancementSuccessRate = enhancementSuccesses + enhancementFailures > 0
+        ? (enhancementSuccesses /
+            (enhancementSuccesses + enhancementFailures)) *
+            100
+        : 100;
+    let mostUsedTool = "";
+    let maxUsage = 0;
+    for (const [tool, count] of commandUsage) {
+        if (count > maxUsage) {
+            maxUsage = count;
+            mostUsedTool = tool;
+        }
+    }
+    return {
+        totalDelegations,
+        agentUsage,
+        complexityDistribution,
+        successRate,
+        averageResponseTime: responseTimes.length > 0
+            ? responseTimes.reduce((a, b) => a + b) / responseTimes.length
+            : 0,
+        contextOperations,
+        enhancementSuccessRate,
+        commandUsage,
+        toolExecutionStats: {
+            totalCommands: Array.from(commandUsage.values()).reduce((sum, count) => sum + count, 0),
+            uniqueTools: commandUsage.size,
+            mostUsedTool,
+            toolSuccessRate,
+        },
+        systemOperationDetails: {
+            fileOperations,
+            searchOperations,
+            terminalOperations,
+            analysisOperations,
+            orchestrationOperations,
+        },
+    };
+}
+export function calculatePeakActivity(logs) {
+    const minuteGroups = new Map();
+    for (const log of logs) {
+        const minute = new Date(log.timestamp).toISOString().slice(0, 16);
+        minuteGroups.set(minute, (minuteGroups.get(minute) || 0) + 1);
+    }
+    let peakMinute = "";
+    let peakCount = 0;
+    for (const [minute, count] of minuteGroups) {
+        if (count > peakCount) {
+            peakCount = count;
+            peakMinute = minute;
+        }
+    }
+    return {
+        timestamp: peakMinute ? new Date(peakMinute + ":00Z") : new Date(),
+        eventsPerMinute: peakCount,
+    };
+}
+export function calculateHealthScore(logs) {
+    const successCount = logs.filter((log) => log.status === "success").length;
+    const errorCount = logs.filter((log) => log.status === "error").length;
+    if (successCount + errorCount === 0)
+        return 100;
+    return (successCount / (successCount + errorCount)) * 100;
+}
+export function generateInsights(logs, metrics) {
+    const insights = [];
+    if (metrics.totalDelegations > 0) {
+        insights.push(`Successfully orchestrated ${metrics.totalDelegations} agent delegations`);
+    }
+    if (metrics.contextOperations > 0) {
+        insights.push(`Performed ${metrics.contextOperations} context awareness operations`);
+    }
+    if (metrics.successRate > 95) {
+        insights.push(`Excellent system health with ${metrics.successRate.toFixed(1)}% success rate`);
+    }
+    const mostUsedAgent = Array.from(metrics.agentUsage.entries()).sort((a, b) => b[1] - a[1])[0];
+    if (mostUsedAgent) {
+        insights.push(`Primary agent: ${mostUsedAgent[0]} (${mostUsedAgent[1]} invocations)`);
+    }
+    return insights;
+}
+export function generateRecommendations(metrics) {
+    const recommendations = [];
+    if (metrics.successRate < 95) {
+        recommendations.push("Investigate and resolve error conditions to improve system reliability");
+    }
+    if (metrics.totalDelegations === 0) {
+        recommendations.push("Consider running delegation scenarios to test agent orchestration");
+    }
+    if (metrics.contextOperations === 0) {
+        recommendations.push("Enable context awareness features for enhanced intelligence");
+    }
+    if (metrics.agentUsage.size === 0) {
+        recommendations.push("Run agent-based operations to populate usage analytics");
+    }
+    return recommendations;
+}
+export function generateAlerts(logs) {
+    const alerts = [];
+    const recentErrors = logs
+        .filter((log) => log.status === "error")
+        .slice(0, 3);
+    for (const error of recentErrors) {
+        alerts.push(`${error.component}:${error.action} failed`);
+    }
+    const highFrequencyComponents = getHighFrequencyComponents(logs);
+    for (const component of highFrequencyComponents) {
+        alerts.push(`High activity detected in ${component}`);
+    }
+    return alerts;
+}
+export function getHighFrequencyComponents(logs) {
+    const componentCounts = new Map();
+    const timeWindowMs = 5 * 60 * 1000;
+    const cutoffTime = Date.now() - timeWindowMs;
+    for (const log of logs) {
+        if (log.timestamp > cutoffTime) {
+            componentCounts.set(log.component, (componentCounts.get(log.component) || 0) + 1);
+        }
+    }
+    return Array.from(componentCounts.entries())
+        .filter(([, count]) => count > 10)
+        .map(([component]) => component);
+}