0xray 2.0.0

package/dist/reporting/report-formatter.js

@@ -0,0 +1,146 @@
+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 StringRay releases (1-line min per Scope Rule; primary xray paths + XRAY_||STRRAY_ env + .strray 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.js

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

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

@@ -0,0 +1,101 @@
+/**
+ * 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 { StringRayStateManager } from '../state/state-manager.js';
+import { strRayConfigLoader } from '../core/config-loader.js';
+import { routingOutcomeTracker } from '../delegation/analytics/outcome-tracker.js';
+import { patternPerformanceTracker } from '../analytics/pattern-performance-tracker.js';
+const stateManager = new StringRayStateManager();
+const delegator = new AgentDelegator(stateManager, strRayConfigLoader);
+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.js

@@ -0,0 +1,234 @@
+#!/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.
+ *
+ * @version 1.1.0
+ * @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
+ */
+import { spawn } from "child_process";
+import { resolveAgent } from "../mcps/agent-resolver.js";
+import { spawnGate } from "../core/agent-spawn-gate.js";
+/**
+ * Main entry point for the integration script
+ */
+async function main() {
+    const args = process.argv.slice(2);
+    // Handle --version flag
+    if (args.includes("--version")) {
+        console.log("0xRay Integration v1.1.0");
+        process.exit(0);
+    }
+    // Handle --help flag
+    if (args.includes("--help")) {
+        console.log(`
+0xRay Integration - OpenCode Bridge
+
+Usage:
+  node integration.js <agent-name> <task-json>
+  node integration.js --version
+  node integration.js --help
+
+Examples:
+  node integration.js enforcer '{"taskDescription": "Check code quality"}'
+  node integration.js architect '{"taskDescription": "Design API endpoints"}'
+
+Flow:
+  1. Loads agent configuration from 0xRay
+  2. Spawns OpenCode CLI with agent
+  3. OpenCode loads 0xRay MCP servers (tools/skills)
+  4. Agent executes task using available tools
+  5. Results returned as JSON
+    `);
+        process.exit(0);
+    }
+    // Validate arguments
+    if (args.length < 2) {
+        console.error("Error: Missing arguments");
+        console.error("Usage: node integration.js <agent-name> <task-json>");
+        process.exit(1);
+    }
+    const agentName = args[0];
+    let taskContext;
+    // Parse task JSON
+    try {
+        taskContext = JSON.parse(args[1]);
+    }
+    catch (error) {
+        console.error("Error: Invalid JSON task context");
+        process.exit(1);
+    }
+    // Execute the integration
+    try {
+        // Get agent configuration from 0xRay registry
+        const agent = await resolveAgent(agentName);
+        console.log(`[0xRay] Spawning OpenCode with agent: ${agentName}`);
+        console.log(`[0xRay] Task: ${taskContext.taskDescription || "No description"}`);
+        // Build the task prompt for OpenCode
+        const taskPrompt = buildTaskPrompt(agent, taskContext);
+        // Spawn OpenCode CLI
+        const result = await spawnOpenCode(agentName, taskPrompt);
+        // Output JSON result
+        const output = {
+            success: true,
+            agent: agentName,
+            task: taskContext.taskDescription,
+            result,
+            timestamp: new Date().toISOString(),
+        };
+        console.log(JSON.stringify(output, null, 2));
+    }
+    catch (error) {
+        const errorOutput = {
+            success: false,
+            agent: agentName,
+            error: error instanceof Error ? error.message : String(error),
+            timestamp: new Date().toISOString(),
+        };
+        console.error(JSON.stringify(errorOutput, null, 2));
+        process.exit(1);
+    }
+}
+/**
+ * Build task prompt from agent configuration
+ */
+function buildTaskPrompt(agent, taskContext) {
+    const availableTools = agent.tools?.include?.join(", ") || "read, grep, edit, bash commands";
+    return `You are the ${agent.name} agent.
+
+${agent.system || ""}
+
+## Your Task
+${taskContext.taskDescription}
+
+## Context
+${JSON.stringify(taskContext.context || {}, null, 2)}
+
+## Available Tools
+${availableTools}
+
+Execute this task using the available tools. Be thorough and provide detailed results.`;
+}
+/**
+ * Spawn OpenCode CLI process
+ */
+function spawnOpenCode(agentName, prompt) {
+    // Gate: prevent spawning unless explicitly enabled
+    spawnGate.assertAllowed("integration-script");
+    let isFinished = false;
+    return new Promise((resolve, reject) => {
+        // Spawn opencode with stdin for prompt - more reliable
+        let opencode;
+        try {
+            opencode = spawn("opencode", ["run", "-", "--agent", agentName, "-m", "opencode/big-pickle"], {
+                cwd: process.cwd(),
+                env: {
+                    ...process.env,
+                    NODE_ENV: "production",
+                    OPENCODE_MCP_CONFIG: "./node_modules/0xray/opencode.json",
+                },
+                stdio: ["pipe", "pipe", "pipe"],
+            });
+            if (opencode.pid) {
+                spawnGate.trackProcess(opencode.pid, "integration-script", `agent=${agentName}`);
+            }
+        }
+        catch (error) {
+            const msg = error instanceof Error && "code" in error && error.code === "ENOENT"
+                ? "OpenCode CLI not found. Please install opencode to use this command."
+                : `Failed to spawn opencode: ${error instanceof Error ? error.message : String(error)}`;
+            reject(new Error(msg));
+            return;
+        }
+        // Write prompt to stdin
+        opencode.stdin?.write(prompt);
+        opencode.stdin?.end();
+        let stdout = "";
+        let stderr = "";
+        if (opencode.stdout) {
+            opencode.stdout.on("data", (data) => {
+                stdout += data.toString();
+            });
+        }
+        if (opencode.stderr) {
+            opencode.stderr.on("data", (data) => {
+                stderr += data.toString();
+            });
+        }
+        // Graceful cleanup function
+        const cleanup = (force = false) => {
+            if (isFinished)
+                return;
+            isFinished = true;
+            if (force && opencode.pid !== undefined && !opencode.killed) {
+                try {
+                    process.kill(opencode.pid, "SIGTERM");
+                    // Give it 2 seconds to terminate gracefully, then force kill
+                    setTimeout(() => {
+                        if (!opencode.killed && opencode.pid !== undefined) {
+                            try {
+                                process.kill(opencode.pid, "SIGKILL");
+                            }
+                            catch (e) {
+                                // Process already dead
+                            }
+                        }
+                    }, 2000);
+                }
+                catch (e) {
+                    // Process already dead
+                }
+            }
+        };
+        opencode.on("close", (code) => {
+            cleanup(false);
+            if (opencode.pid) {
+                spawnGate.untrackProcess(opencode.pid);
+            }
+            if (code !== 0) {
+                reject(new Error(`OpenCode exited with code ${code}: ${stderr}`));
+                return;
+            }
+            try {
+                // Try to parse JSON output
+                const result = JSON.parse(stdout);
+                resolve(result);
+            }
+            catch (e) {
+                // Return raw output if not JSON
+                resolve({ output: stdout, errors: stderr });
+            }
+        });
+        opencode.on("error", (error) => {
+            cleanup(true);
+            if (error.code === "ENOENT") {
+                reject(new Error("OpenCode CLI not found. Please install: npm install -g opencode-ai"));
+            }
+            else {
+                reject(error);
+            }
+        });
+        // Timeout after 5 minutes - graceful first, then force
+        const timeout = setTimeout(() => {
+            console.log("[0xRay] OpenCode timed out, terminating...");
+            cleanup(true);
+            reject(new Error("OpenCode execution timeout (5 minutes)"));
+        }, 300000);
+        // Clear timeout on successful close
+        opencode.on("close", () => {
+            clearTimeout(timeout);
+        });
+    });
+}
+// Execute main function
+main().catch((error) => {
+    console.error("Fatal error:", error);
+    process.exit(1);
+});

package/dist/scripts/pre-command

@@ -0,0 +1,26 @@
+#!/bin/bash
+# Pre-Command Hook for StringRay
+# 
+# Checks context window usage before each command.
+# If context is at 95%+ (configurable), auto-generates a reflection.
+#
+# Usage:
+#   ./scripts/hooks/pre-command        # Normal call
+#   ./scripts/hooks/pre-command --dry-run  # Check without generating
+#   ./scripts/hooks/pre-command --ci     # CI mode (less verbose)
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="$(git rev-parse --show-toplevel 2>/dev/null || pwd)"
+
+export HOOK_PROJECT_ROOT="$PROJECT_ROOT"
+export HOOK_REFLECTIONS_DIR="${REFLECTIONS_DIR:-docs/reflections}"
+export HOOK_DRY_RUN="${HOOK_DRY_RUN:-0}"
+
+if [[ "$1" == "--dry-run" ]]; then
+    export HOOK_DRY_RUN=1
+elif [[ "$1" == "--ci" ]]; then
+    export CI=true
+fi
+
+cd "$PROJECT_ROOT"
+exec node "$SCRIPT_DIR/pre-command.mjs" "$@"