0xray 2.0.0 → 2.1.0

package/dist/processors/processor-manager.d.ts

@@ -0,0 +1,80 @@
+import { XrayStateManager } from "../state/state-manager.js";
+import { ProcessorRegistration, ProcessorHook } from "./processor-types.js";
+import { IProcessor } from "./processor-interfaces.js";
+export interface StaggerPolicy {
+    minIntervalMs: number;
+}
+export interface ProcessorConfig {
+    name: string;
+    type: "pre" | "post";
+    priority: number;
+    enabled: boolean;
+    timeout?: number;
+    retryAttempts?: number;
+    hook?: ProcessorHook;
+    stagger?: StaggerPolicy;
+}
+export interface ProcessorResult {
+    success: boolean;
+    data?: unknown;
+    error?: string;
+    duration: number;
+    processorName: string;
+}
+export interface ProcessorHealth {
+    name: string;
+    status: "healthy" | "degraded" | "failed";
+    lastExecution: number;
+    successRate: number;
+    averageDuration: number;
+    errorCount: number;
+}
+export interface ProcessorMetrics {
+    totalExecutions: number;
+    successfulExecutions: number;
+    failedExecutions: number;
+    averageDuration: number;
+    lastExecutionTime: number;
+    healthStatus: ProcessorHealth["status"];
+}
+type ProcessorFactory = {
+    execute: (context: Record<string, unknown>) => Promise<unknown>;
+    init?: () => Promise<void>;
+};
+export declare class ProcessorManager {
+    private processors;
+    private metrics;
+    private stateManager;
+    private activeProcessors;
+    private factories;
+    private lastExecutionTime;
+    constructor(stateManager: XrayStateManager);
+    registerProcessorInstance(processor: IProcessor): boolean;
+    discoverProcessors(directory?: string): Promise<string[]>;
+    private instantiateWithDeps;
+    private registerBuiltInFactories;
+    registerFactory(name: string, factory: ProcessorFactory): void;
+    registerProcessorWithHook(registration: ProcessorRegistration): void;
+    registerProcessor(config: ProcessorConfig): void;
+    unregisterProcessor(name: string): void;
+    getProcessors(): Map<string, ProcessorConfig>;
+    initializeProcessors(): Promise<boolean>;
+    private initializeProcessor;
+    executePreProcessors(input: {
+        tool: string;
+        args?: Record<string, unknown>;
+        context?: Record<string, unknown>;
+    }): Promise<{
+        success: boolean;
+        results: ProcessorResult[];
+    }>;
+    executePostProcessors(operation: string, data: any, preResults: ProcessorResult[]): Promise<ProcessorResult[]>;
+    private executeProcessor;
+    private updateMetrics;
+    getProcessorHealth(): ProcessorHealth[];
+    private validateProcessorContext;
+    resolveProcessorConflicts(conflicts: ProcessorResult[]): ProcessorResult;
+    cleanupProcessors(): Promise<void>;
+    private cleanupProcessor;
+}
+export {};

package/dist/processors/processor-types.d.ts

@@ -0,0 +1,190 @@
+/**
+ * Processor Types
+ *
+ * Type definitions for the processor activation system.
+ * Replaces `any` types with proper interfaces for type safety.
+ * This file is the central source of truth for shared processor types
+ * to avoid circular dependencies.
+ *
+ * @version 1.2.0
+ * @since 2026-01-07
+ */
+/**
+ * Tool argument structure passed to processors
+ */
+export interface ToolInputArgs {
+    filePath?: string;
+    content?: string;
+    operation?: string;
+    directory?: string;
+    args?: Record<string, string>;
+}
+/**
+ * Tool input containing execution details
+ */
+export interface ToolInput {
+    tool?: string;
+    args?: ToolInputArgs;
+}
+/**
+ * Processor execution context - used by processors to understand their environment
+ */
+export interface ProcessorContext {
+    /** Tool input (for pre-processors) */
+    toolInput?: ToolInput;
+    /** File path being processed */
+    filePath?: string;
+    /** Operation being performed */
+    operation?: string;
+    /** Content being processed */
+    content?: string;
+    /** Working directory */
+    directory?: string;
+    /** Tool being executed */
+    tool?: string;
+    /** Additional context - string, numeric, boolean, or object values */
+    [key: string]: ToolInput | ToolInputArgs | string | number | boolean | object | undefined;
+}
+/**
+ * Standard result returned by all processors
+ * Uses unknown for data to handle any processor-specific return type
+ */
+export interface ProcessorResult {
+    success: boolean;
+    data?: unknown;
+    error?: string;
+    duration: number;
+    processorName: string;
+}
+export interface PreValidateContext {
+    operation: string;
+    data?: string;
+    syntaxCheck?: boolean;
+    codexCompliance?: boolean;
+    agentName?: string;
+    filesChanged?: string[];
+    riskLevel?: "low" | "medium" | "high" | "critical";
+    tool?: string;
+    directory?: string;
+    args?: ToolInputArgs;
+    config?: Record<string, unknown>;
+}
+export interface PostValidateContext {
+    operation: string;
+    data?: string;
+    preResults: ProcessorExecutionResult[];
+    testResults?: TestResults;
+    regressionResults?: RegressionResults;
+    stateValidation?: boolean;
+    tool?: string;
+    directory?: string;
+    args?: ToolInputArgs;
+}
+export interface ProcessorHook {
+    name: string;
+    execute: (context: PreValidateContext | PostValidateContext) => Promise<ProcessorExecutionResult>;
+    priority: number;
+    enabled: boolean;
+    before?: (context: PreValidateContext | PostValidateContext) => Promise<void>;
+    after?: (result: ProcessorExecutionResult) => Promise<void>;
+    onError?: (error: Error) => Promise<void>;
+}
+export interface ProcessorRegistration {
+    name: string;
+    type: "pre" | "post";
+    hook: ProcessorHook;
+}
+export interface ProcessorExecutionResult {
+    success: boolean;
+    result?: unknown;
+    error?: string;
+    duration: number;
+    processorName: string;
+    data?: unknown;
+}
+export interface ProcessorHealthCheck {
+    name: string;
+    status: "healthy" | "degraded" | "failed";
+    lastRun: number;
+    successRate: number;
+    averageExecutionTime: number;
+    totalRuns: number;
+    failedRuns: number;
+}
+export interface TestResults {
+    passed: number;
+    failed: number;
+    total: number;
+    duration: number;
+}
+export interface RegressionResults {
+    issues: string[];
+    passed: boolean;
+}
+export interface VersionComplianceProcessorResult {
+    success: boolean;
+    errors: string[];
+    warnings: string[];
+    checkedAt: string;
+}
+export interface CodexComplianceProcessorResult {
+    compliant: boolean;
+    violations: string[];
+    warnings: string[];
+    termsChecked: number;
+    operation: string;
+    timestamp: string;
+    error?: boolean;
+}
+export interface ErrorBoundaryResult {
+    boundaries: string;
+}
+export interface LogProtectionProcessorResult {
+    allowed: boolean;
+    reason?: string;
+}
+export interface AgentsMdValidationProcessorResult {
+    success: boolean;
+    blocked: boolean;
+    message?: string;
+    errors: string[];
+    warnings: string[];
+    checkedAt: string;
+}
+export interface TestExecutionResult {
+    testsExecuted: number;
+    passed: number;
+    failed: number;
+    exitCode?: number;
+    output?: string;
+    success: boolean;
+    error?: string;
+}
+export interface RegressionTestingResult {
+    regressions: string;
+    issues: string[];
+}
+export interface StateValidationResult {
+    stateValid: boolean;
+}
+export interface RefactoringLoggingResult {
+    logged: boolean;
+    success: boolean;
+    message: string;
+    error?: string;
+}
+export interface TestAutoCreationResult {
+    success: boolean;
+    message?: string;
+    data?: string[];
+    error?: string;
+}
+export interface CoverageAnalysisResult {
+    success: boolean;
+    message: string;
+    coverage: number;
+}
+export interface RuleViolationEntry {
+    rule: string;
+    message: string;
+}

package/dist/public/about.html

@@ -3,7 +3,7 @@
 <head>
   <meta charset="UTF-8">
   <meta name="viewport" content="width=device-width, initial-scale=1.0">
-  <title>About StringRay - Enterprise AI Orchestration</title>
+  <title>About 0xRay - Enterprise AI Orchestration</title>
   <style>
     * { margin: 0; padding: 0; box-sizing: border-box; }
     body {
@@ -113,7 +113,7 @@
   <div class="container">
     <header>
       <span class="version">v1.4.20</span>
-      <h1>StringRay</h1>
+      <h1>0xRay</h1>
       <p class="tagline">Enterprise AI Orchestration Framework</p>
     </header>
 
@@ -141,8 +141,8 @@
     </div>
 
     <section class="section">
-      <h2>🎯 What is StringRay?</h2>
-      <p>StringRay is an enterprise-grade AI orchestration framework that provides intelligent task routing, systematic error prevention, and comprehensive monitoring for AI-driven development workflows.</p>
+      <h2>🎯 What is 0xRay?</h2>
+      <p>0xRay is an enterprise-grade AI orchestration framework that provides intelligent task routing, systematic error prevention, and comprehensive monitoring for AI-driven development workflows.</p>
     </section>
 
     <section class="section">
@@ -191,7 +191,7 @@
       <h2>🔄 8 Pipeline System</h2>
       <div class="pipeline-diagram">
 ┌─────────────────────────────────────────────────────────────────┐
-│                    STRINGRAY FRAMEWORK v1.4.20                  │
+│                    0XRAY FRAMEWORK v1.4.20                     │
 ├─────────────────────────────────────────────────────────────────┤
 │  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐  ┌─────────┐ │
 │  │    INIT     │─▶│  AGENT      │─▶│   RULE      │─▶│  POST   │ │
@@ -220,7 +220,7 @@
     </section>
 
     <footer>
-      <p>StringRay Framework &copy; 2026 | Built for Enterprise AI Orchestration</p>
+      <p>0xRay Framework &copy; 2026 | Built for Enterprise AI Orchestration</p>
       <p style="margin-top: 10px; color: #6e7681;">338 logging points | 51 core files | JobId tracking enabled</p>
     </footer>
   </div>

package/dist/public/enterprise.html

@@ -3,7 +3,7 @@
 <head>
   <meta charset="UTF-8">
   <meta name="viewport" content="width=device-width, initial-scale=1.0">
-  <title>Enterprise - StringRay</title>
+  <title>Enterprise - 0xRay</title>
   <style>
     body { margin: 0; padding: 0; background: #0a0a0f; color: #e0e0e0; font-family: system-ui, sans-serif; }
     .container { max-width: 900px; margin: 0 auto; padding: 40px 20px; }

package/dist/public/features.html

@@ -3,7 +3,7 @@
 <head>
   <meta charset="UTF-8">
   <meta name="viewport" content="width=device-width, initial-scale=1.0">
-  <title>StringRay - Features</title>
+  <title>0xRay - Features</title>
   <style>
     * { margin: 0; padding: 0; box-sizing: border-box; }
     body {
@@ -56,7 +56,7 @@
 <body>
   <div class="container">
     <header>
-      <h1>StringRay Features</h1>
+      <h1>0xRay Features</h1>
       <p class="subtitle">Enterprise AI Orchestration Platform</p>
     </header>
     

package/dist/public/index.html

@@ -3,7 +3,7 @@
 <head>
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>⚡ StringRay Dashboard</title>
+    <title>⚡ 0xRay Dashboard</title>
     <style>
         body {
             font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
@@ -81,8 +81,8 @@
 <body>
     <div class="container">
         <div class="header">
-            <h1>⚡ StringRay</h1>
-            <p>AI Agent Orchestration Framework - Production-Ready Code, No Dead Ends</p>
+            <h1>⚡ 0xRay</h1>
+            <p>Self-Healing AI Governance OS - Production-Ready Code, No Dead Ends</p>
         </div>
 
         <div class="grid">
@@ -121,7 +121,7 @@
         </div>
 
         <div class="footer">
-            <p>🛡️ StringRay - The AI Sentinel: Your Unwavering Guardian Against AI Development Catastrophes</p>
+            <p>🛡️ 0xRay - Self-Healing, Governed, Autonomous: Catch AI Mistakes Before They Ship</p>
         </div>
     </div>
 

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/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/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[];

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

@@ -0,0 +1,5 @@
+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

@@ -98,7 +98,7 @@ ${data.recommendations.map((rec) => `- ${rec}`).join("\n")}
 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)*
+*Consumer runtime compat shim from prior StringRay releases (1-line min per Scope Rule; primary xray paths + XRAY_||STRRAY_ env + .xray fallbacks)*
 *Framework Status: Operational*
     `;
 }

package/dist/reporting/types.d.ts

@@ -0,0 +1,102 @@
+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/scripts/activate-kernel-pipeline.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 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

@@ -5,11 +5,11 @@
  * Observes the full pipeline in action.
  */
 import { AgentDelegator } from '../delegation/agent-delegator.js';
-import { StringRayStateManager } from '../state/state-manager.js';
+import { XrayStateManager } 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 stateManager = new XrayStateManager();
 const delegator = new AgentDelegator(stateManager, strRayConfigLoader);
 console.log('=== KERNEL PIPELINE ACTIVATION TEST ===\n');
 // Test cases designed to trigger kernel patterns

package/dist/scripts/integration.d.ts

@@ -0,0 +1,37 @@
+#!/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
+ */
+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;
+}

package/dist/scripts/pre-command

@@ -1,5 +1,5 @@
 #!/bin/bash
-# Pre-Command Hook for StringRay
+# Pre-Command Hook for 0xRay
 # 
 # Checks context window usage before each command.
 # If context is at 95%+ (configurable), auto-generates a reflection.