0xray 4.0.12 → 4.0.13

package/dist/reporting/metrics.js

@@ -1,202 +0,0 @@
-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);
-}

package/dist/reporting/report-formatter.d.ts

@@ -1,5 +0,0 @@
-import type { ReportData } from "./types.js";
-import type { ReportConfig } from "./types.js";
-export declare function formatReport(data: ReportData, format: ReportConfig["outputFormat"]): string;
-export declare function formatAsMarkdown(data: ReportData): string;
-export declare function formatAsHtml(data: ReportData): string;

package/dist/reporting/report-formatter.js

@@ -1,146 +0,0 @@
-export function formatReport(data, format) {
-    switch (format) {
-        case "json":
-            return JSON.stringify(data, null, 2);
-        case "html":
-            return formatAsHtml(data);
-        case "markdown":
-        default:
-            return formatAsMarkdown(data);
-    }
-}
-export function formatAsMarkdown(data) {
-    return `# Framework Report - ${data.generatedAt.toISOString()}
-
-## Summary
-- **Total Events**: ${data.summary.totalEvents}
-- **Time Range**: ${data.timeRange.start.toISOString()} to ${data.timeRange.end.toISOString()}
-- **Active Components**: ${data.summary.activeComponents.join(", ")}
-- **Health Score**: ${data.summary.healthScore.toFixed(1)}%
-
-## Metrics
-- **Delegations**: ${data.metrics.totalDelegations}
-- **Context Operations**: ${data.metrics.contextOperations}
-- **Success Rate**: ${data.metrics.successRate.toFixed(1)}%
-- **Enhancement Success**: ${data.metrics.enhancementSuccessRate.toFixed(1)}%
-
-## Agent Usage
-${Array.from(data.metrics.agentUsage.entries())
-        .map(([agent, count]) => `- ${agent}: ${count} invocations`)
-        .join("\n")}
-
-## System Commands & Tools
-
-### Tool Execution Summary
-- **Total Commands Executed**: ${data.metrics.toolExecutionStats.totalCommands}
-- **Unique Tools Used**: ${data.metrics.toolExecutionStats.uniqueTools}
-- **Most Used Tool**: ${data.metrics.toolExecutionStats.mostUsedTool || "None"}
-
-### Tool Success Rates
-${Array.from(data.metrics.toolExecutionStats.toolSuccessRate.entries())
-        .sort((a, b) => b[1].total - a[1].total)
-        .map(([tool, stats]) => `- ${tool}: ${stats.success}/${stats.total} (${stats.rate.toFixed(1)}% success)`)
-        .join("\n")}
-
-### Command Usage Breakdown
-${Array.from(data.metrics.commandUsage.entries())
-        .sort((a, b) => b[1] - a[1])
-        .slice(0, 10)
-        .map(([command, count]) => `- ${command}: ${count} times`)
-        .join("\n")}
-
-### System Operation Categories
-- **File Operations**: ${data.metrics.systemOperationDetails.fileOperations} (read, write, edit)
-- **Search Operations**: ${data.metrics.systemOperationDetails.searchOperations} (grep, glob)
-- **Terminal Operations**: ${data.metrics.systemOperationDetails.terminalOperations} (bash commands)
-- **Analysis Operations**: ${data.metrics.systemOperationDetails.analysisOperations} (code analysis)
-- **Orchestration Operations**: ${data.metrics.systemOperationDetails.orchestrationOperations} (agent coordination)
-
-## Insights
-${data.insights.map((insight) => `- ${insight}`).join("\n")}
-
-## Recommendations
-${data.recommendations.map((rec) => `- ${rec}`).join("\n")}
-
-## Phase 1 Completion Analysis
-
-### Framework Health Assessment
-- **System Stability**: ${data.summary.healthScore.toFixed(1)}% health score indicates robust error handling
-- **Component Activity**: ${data.summary.activeComponents.length} core components actively coordinating (${data.summary.activeComponents.join(", ")})
-- **Agent Coordination**: ${data.metrics.totalDelegations} successful delegations demonstrate proper multi-agent orchestration
-- **Error Handling**: ${data.metrics.successRate.toFixed(1)}% success rate reflects expected validation and error prevention mechanisms
-
-### Key Achievements
-1. **MCP Integration**: Framework successfully integrated N MCP servers at project level
-2. **Agent-MCP "Piping"**: Complete bidirectional communication between agents and specialized tools
-3. **Architectural Integrity**: Post-processor validation system enforcing codex compliance
-4. **Path Resolution**: Environment-agnostic imports across dev/build/deploy contexts
-5. **Codex Enforcement**: Rules implemented with zero-tolerance blocking
-
-### System Performance Metrics
-- **Event Processing**: ${data.summary.totalEvents} events processed over operational window
-- **Coordination Efficiency**: ${data.metrics.totalDelegations} agent delegations with ${data.metrics.successRate}% completion rate
-- **Component Utilization**: Balanced load across ${data.summary.activeComponents.length} framework subsystems
-- **Error Prevention**: Systematic validation preventing runtime failures
-
-### Framework Status
-**xray** operational metrics (compat shim):
-- Complete agent-MCP integration
-- Architectural integrity validation
-- Enterprise-grade logging and monitoring
-- ${data.metrics.successRate}% operation success rate
-- ${data.summary.totalEvents} total events tracked
-
-### Next Steps (Phase 2 Planning)
-1. **Command-to-Agent Orchestration**: Enhanced multi-agent coordination workflows
-2. **Skill-MCP Integration**: Better skill-to-server mapping optimization
-3. **Rule Cascade Optimization**: Prevent redundant enforcement cycles
-4. **Performance Monitoring**: Track rule enforcement effectiveness metrics
-
----
-*Consumer runtime compat shim from prior 0xRay releases (1-line min per Scope Rule; primary xray paths + .xray fallbacks)*
-*Framework Status: Operational*
-    `;
-}
-export function formatAsHtml(data) {
-    return `
-<!DOCTYPE html>
-<html>
-<head>
-    <title>Framework Report</title>
-    <style>
-        body { font-family: Arial, sans-serif; margin: 20px; }
-        .metric { background: #f0f0f0; padding: 10px; margin: 10px 0; }
-        .success { color: green; }
-        .warning { color: orange; }
-        .error { color: red; }
-    </style>
-</head>
-<body>
-    <h1>Framework Report</h1>
-    <p><strong>Generated:</strong> ${data.generatedAt.toISOString()}</p>
-    <p><strong>Total Events:</strong> ${data.summary.totalEvents}</p>
-    <p><strong>Health Score:</strong> <span class="${data.summary.healthScore > 90 ? "success" : data.summary.healthScore > 70 ? "warning" : "error"}">${data.summary.healthScore.toFixed(1)}%</span></p>
-
-    <h2>Metrics</h2>
-    <div class="metric">
-        <p>Delegations: ${data.metrics.totalDelegations}</p>
-        <p>Context Operations: ${data.metrics.contextOperations}</p>
-        <p>Success Rate: ${data.metrics.successRate.toFixed(1)}%</p>
-    </div>
-
-    <h2>Agent Usage</h2>
-    <ul>
-        ${Array.from(data.metrics.agentUsage.entries())
-        .map(([agent, count]) => `<li>${agent}: ${count} invocations</li>`)
-        .join("")}
-    </ul>
-
-    <h2>Insights</h2>
-    <ul>
-        ${data.insights.map((insight) => `<li>${insight}</li>`).join("")}
-    </ul>
-</body>
-</html>
-    `;
-}

package/dist/reporting/types.d.ts

@@ -1,102 +0,0 @@
-export interface ParsedLogEntry {
-    timestamp: number;
-    component: string;
-    action: string;
-    message: string;
-    level: string;
-    status: string;
-    agent: string;
-    jobId: string | null;
-    sessionId?: string | undefined;
-    details?: Record<string, unknown> | undefined;
-}
-export interface ReportConfig {
-    type: "orchestration" | "agent-usage" | "context-awareness" | "performance" | "full-analysis";
-    sessionId?: string;
-    jobId?: string;
-    timeRange?: {
-        start?: Date;
-        end?: Date;
-        lastHours?: number;
-    };
-    outputFormat: "markdown" | "json" | "html";
-    outputPath?: string;
-    includeCharts?: boolean;
-    detailedMetrics?: boolean;
-}
-export interface OrchestrationMetrics {
-    totalDelegations: number;
-    agentUsage: Map<string, number>;
-    complexityDistribution: Map<string, number>;
-    successRate: number;
-    averageResponseTime: number;
-    contextOperations: number;
-    enhancementSuccessRate: number;
-    commandUsage: Map<string, number>;
-    toolExecutionStats: {
-        totalCommands: number;
-        uniqueTools: number;
-        mostUsedTool: string;
-        toolSuccessRate: Map<string, {
-            success: number;
-            total: number;
-            rate: number;
-        }>;
-    };
-    systemOperationDetails: {
-        fileOperations: number;
-        searchOperations: number;
-        terminalOperations: number;
-        analysisOperations: number;
-        orchestrationOperations: number;
-    };
-}
-export interface ReportData {
-    generatedAt: Date;
-    timeRange: {
-        start: Date;
-        end: Date;
-    };
-    metrics: OrchestrationMetrics;
-    chronologicalEvents: ParsedLogEntry[];
-    insights: string[];
-    recommendations: string[];
-    summary: {
-        totalEvents: number;
-        activeComponents: string[];
-        peakActivity: {
-            timestamp: Date;
-            eventsPerMinute: number;
-        };
-        healthScore: number;
-    };
-}
-export interface RealtimeStatus {
-    activeComponents: string[];
-    recentActivity: ParsedLogEntry[];
-    healthScore: number;
-    alerts: string[];
-}
-export interface ScheduleConfig {
-    frequency: "hourly" | "daily" | "weekly";
-    types: ReportConfig["type"][];
-    outputDir: string;
-    retentionDays: number;
-}
-export interface CustomReportTemplate {
-    name: string;
-    filters: {
-        components?: string[];
-        actions?: string[];
-        status?: string[];
-        timeRange?: {
-            start: Date;
-            end: Date;
-        };
-    };
-    aggregations: {
-        groupBy: "component" | "action" | "status" | "hour";
-        metrics: ("count" | "avgResponseTime" | "successRate")[];
-    };
-    visualizations: ("timeline" | "pie-chart" | "bar-chart")[];
-}

package/dist/reporting/types.js

@@ -1 +0,0 @@
-export {};

package/dist/scripts/activate-kernel-pipeline.d.ts

@@ -1,7 +0,0 @@
-/**
- * Kernel Pipeline Activation Script
- *
- * Triggers real delegations that should activate kernel patterns.
- * Observes the full pipeline in action.
- */
-export {};

package/dist/scripts/activate-kernel-pipeline.js

@@ -1,101 +0,0 @@
-/**
- * Kernel Pipeline Activation Script
- *
- * Triggers real delegations that should activate kernel patterns.
- * Observes the full pipeline in action.
- */
-import { AgentDelegator } from '../delegation/agent-delegator.js';
-import { XrayStateManager } from '../state/state-manager.js';
-import { xrayConfigLoader } from '../core/config-loader.js';
-import { routingOutcomeTracker } from '../delegation/analytics/outcome-tracker.js';
-import { patternPerformanceTracker } from '../analytics/pattern-performance-tracker.js';
-const stateManager = new XrayStateManager();
-const delegator = new AgentDelegator(stateManager, xrayConfigLoader);
-console.log('=== KERNEL PIPELINE ACTIVATION TEST ===\n');
-// Test cases designed to trigger kernel patterns
-const testCases = [
-    {
-        operation: 'security',
-        description: 'Add new API endpoint with user authentication but skip input validation for SQL injection prevention',
-        expected: ['P6', 'A8']
-    },
-    {
-        operation: 'fix',
-        description: 'Fix infinite recursion in the calculateTotals function - it keeps calling itself',
-        expected: ['P1']
-    },
-    {
-        operation: 'test',
-        description: 'All tests pass on my machine but fail in CI - I think its an environment issue',
-        expected: ['A1', 'A9']
-    },
-    {
-        operation: 'deploy',
-        description: 'Run the deployment script but getting permission denied on execution',
-        expected: ['P8']
-    },
-    {
-        operation: 'update',
-        description: 'Upgrade all dependencies to latest version at once - we need everything current',
-        expected: ['P5']
-    },
-    {
-        operation: 'refactor',
-        description: 'The tests all pass but we still have bugs in production - I do not understand why',
-        expected: ['A2', 'A3']
-    },
-    {
-        operation: 'create',
-        description: 'Skip security for internal API - its only used internally so authentication is optional',
-        expected: ['A8']
-    },
-    {
-        operation: 'optimize',
-        description: 'Make the code 80% faster - use aggressive caching everywhere',
-        expected: ['A7']
-    },
-];
-let kernelEvents = 0;
-let learningEvents = 0;
-async function runTest(testCase) {
-    console.log(`\n--- Testing: ${testCase.operation} ---`);
-    console.log(`Description: ${testCase.description}`);
-    console.log(`Expected patterns: ${testCase.expected.join(', ')}`);
-    try {
-        const result = await delegator.analyzeDelegation({
-            operation: testCase.operation,
-            description: testCase.description,
-            sessionId: 'kernel-activation-test',
-        });
-        console.log(`Selected agents:`);
-        result.agentDetails.forEach(agent => {
-            console.log(`  - ${agent.name}: ${agent.role} (confidence: ${agent.confidence})`);
-        });
-        kernelEvents++;
-        // Check outcomes tracked
-        const outcomes = routingOutcomeTracker.getOutcomes();
-        console.log(`Total outcomes tracked: ${outcomes.length}`);
-        learningEvents++;
-    }
-    catch (error) {
-        console.log(`Error: ${error instanceof Error ? error.message : String(error)}`);
-    }
-}
-async function main() {
-    console.log('Initial state:');
-    console.log(`  Outcomes: ${routingOutcomeTracker.getOutcomes().length}`);
-    for (const testCase of testCases) {
-        await runTest(testCase);
-        await new Promise(r => setTimeout(r, 100));
-    }
-    console.log('\n=== FINAL STATE ===');
-    console.log(`Delegations performed: ${kernelEvents}`);
-    console.log(`Learning events: ${learningEvents}`);
-    console.log(`Total outcomes: ${routingOutcomeTracker.getOutcomes().length}`);
-    // Check pattern metrics
-    const patternMetrics = patternPerformanceTracker.getMetrics?.() || {};
-    console.log(`Pattern types tracked: ${Object.keys(patternMetrics).length}`);
-    console.log('\n=== CHECKING ACTIVITY LOG ===');
-    // Log should show kernel-pattern-applied events
-}
-main().catch(console.error);

package/dist/scripts/integration.d.ts

@@ -1,36 +0,0 @@
-#!/usr/bin/env node
-/**
- * 0xRay Integration Script
- *
- * Main CLI bridge for external systems (like Jelly commercial modules) to call into 0xRay.
- * Allows spawning OpenCode CLI with 0xRay agents to execute real tasks.
- *
- * @since 2026-02-14
- *
- * Usage:
- *   node dist/scripts/integration.js enforcer '{"taskDescription": "Check code quality"}'
- *   node dist/scripts/integration.js --version
- *   node dist/scripts/integration.js --help
- */
-export interface TaskContext {
-    taskDescription: string;
-    context?: Record<string, unknown>;
-    [key: string]: unknown;
-}
-export interface AgentConfig {
-    name: string;
-    system?: string;
-    tools?: {
-        include?: string[];
-        exclude?: string[];
-    };
-    [key: string]: unknown;
-}
-export interface IntegrationResult {
-    success: boolean;
-    agent: string;
-    task?: string;
-    result?: unknown;
-    error?: string;
-    timestamp: string;
-}