0xray 4.0.13 → 4.0.14

package/dist/core/kernel-patterns.js

@@ -0,0 +1,301 @@
+/**
+ * 0xRay Kernel Pattern Definitions
+ *
+ * Pattern definitions from v1.1.0 → v2.0 kernel update
+ * Includes 35+ patterns from 80+ reflections
+ *
+ */
+export class KernelAnalyzer {
+    config;
+    patterns = new Map();
+    assumptions = new Map();
+    cascades = new Map();
+    constructor(config) {
+        this.config = {
+            enabled: config?.enabled ?? true,
+            confidenceThreshold: config?.confidenceThreshold ?? 0.75,
+            maxPatternsPerAnalysis: config?.maxPatternsPerAnalysis ?? 10,
+            enableLearning: config?.enableLearning ?? true,
+            autoPrevention: config?.autoPrevention ?? true,
+        };
+        this.initializePatterns();
+    }
+    initializePatterns() {
+        // FATAL ASSUMPTIONS (A1-A9)
+        this.assumptions.set('A1', {
+            id: 'A1',
+            trigger: ['works in dev', 'works locally', 'works on my machine'],
+            action: 'TEST WHERE IT RUNS',
+            reason: 'Works in dev assumption',
+            level: 1
+        });
+        this.assumptions.set('A2', {
+            id: 'A2',
+            trigger: ['test pass', 'tests pass', 'all tests pass'],
+            action: 'TESTS VALIDATE TESTS, NOT BUGS',
+            reason: 'Test pass assumption',
+            level: 1
+        });
+        this.assumptions.set('A3', {
+            id: 'A3',
+            trigger: ['code defined', 'function defined', 'code exist', 'function exist'],
+            action: 'VERIFY EXECUTION NOT DEFINITION',
+            reason: 'Code written assumption',
+            level: 1
+        });
+        this.assumptions.set('A4', {
+            id: 'A4',
+            trigger: ['I understand', 'understand the framework'],
+            action: 'FRAMEWORK SHAPES YOUR THINKING',
+            reason: 'Understanding assumption',
+            level: 3
+        });
+        this.assumptions.set('A5', {
+            id: 'A5',
+            trigger: ['manual process', 'manually', 'forgot to run', 'remember to'],
+            action: 'AUTOMATE OR IT FAILS',
+            reason: 'Manual process assumption',
+            level: 1
+        });
+        this.assumptions.set('A6', {
+            id: 'A6',
+            trigger: ['more test', 'higher coverage', 'coverage increase'],
+            action: 'SKIPPED TESTS = ARCHITECTURAL DEBT',
+            reason: 'More tests assumption',
+            level: 1
+        });
+        this.assumptions.set('A7', {
+            id: 'A7',
+            trigger: ['optimize', 'optimization', 'perfect'],
+            action: '75% THRESHOLD - BEYOND COSTS MORE',
+            reason: 'Optimization assumption',
+            level: 2
+        });
+        // NEW v2.0 ASSUMPTIONS
+        this.assumptions.set('A8', {
+            id: 'A8',
+            trigger: ['security later', 'optional security', 'after feature', 'not now security'],
+            action: 'SECURITY_IS_FOUNDATION',
+            reason: 'Security cannot be optional foundation',
+            level: 1
+        });
+        this.assumptions.set('A9', {
+            id: 'A9',
+            trigger: ['works locally', 'localhost secure', 'tested locally'],
+            action: 'PRODUCTION_ENVIRONMENT_TESTING',
+            reason: 'Local ≠ production security',
+            level: 2
+        });
+        // BUG CASCADE PATTERNS (P1-P8)
+        this.cascades.set('P1', {
+            id: 'P1',
+            pattern: 'RECURSIVE_LOOP',
+            detection: 'activity_log | spawn_governor',
+            fix: 'loop breaker + consultation limit',
+            priority: 1
+        });
+        this.cascades.set('P2', {
+            id: 'P2',
+            pattern: 'IMPLEMENTATION_DRIFT',
+            detection: 'test_health | review_cycles',
+            fix: 'regular test review cycles',
+            priority: 2
+        });
+        this.cascades.set('P3', {
+            id: 'P3',
+            pattern: 'CONSUMER_PATH_TRAP',
+            detection: 'fresh_test | consumer_default',
+            fix: 'use consumer paths as default',
+            priority: 1
+        });
+        this.cascades.set('P4', {
+            id: 'P4',
+            pattern: 'MCP_PROTOCOL_GAP',
+            detection: 'timeout_despite_running | handshake',
+            fix: 'add initialize request before tool calls',
+            priority: 1
+        });
+        this.cascades.set('P5', {
+            id: 'P5',
+            pattern: 'VERSION_CHAOS',
+            detection: 'auto_compliance | 3layer_enforce',
+            fix: 'automated version enforcement system',
+            priority: 2
+        });
+        // NEW v2.0 PATTERNS
+        this.cascades.set('P6', {
+            id: 'P6',
+            pattern: 'SECURITY_VULNERABILITY',
+            detection: 'security_audit | oauth2+api_key',
+            fix: 'complete security re-architecture',
+            priority: 1
+        });
+        this.cascades.set('P7', {
+            id: 'P7',
+            pattern: 'RELEASE_READINESS',
+            detection: 'precommit_fails | comprehensive_validation',
+            fix: '100% validation system',
+            priority: 1
+        });
+        this.cascades.set('P8', {
+            id: 'P8',
+            pattern: 'INFRASTRUCTURE_HARDENING',
+            detection: 'execution_failures | chmod+typecheck',
+            fix: 'script permission fixes',
+            priority: 2
+        });
+    }
+    analyze(observation) {
+        if (!this.config.enabled) {
+            return { confidence: 0, recommendations: ['Kernel is disabled'] };
+        }
+        const lowerObs = observation.toLowerCase();
+        const result = {
+            confidence: 0,
+            recommendations: [],
+            fatalAssumptions: [],
+            cascadePatterns: []
+        };
+        // Check fatal assumptions
+        for (const [id, assumption] of this.assumptions.entries()) {
+            for (const trigger of assumption.trigger) {
+                if (lowerObs.includes(trigger.toLowerCase())) {
+                    if (!result.fatalAssumptions)
+                        result.fatalAssumptions = [];
+                    result.fatalAssumptions.push(assumption);
+                    result.confidence = Math.max(result.confidence, 0.8);
+                    result.actionRequired = assumption.action;
+                    if (!result.recommendations)
+                        result.recommendations = [];
+                    result.recommendations.push(`Detected assumption ${id}: ${assumption.reason}`);
+                }
+            }
+        }
+        // Check cascade patterns
+        for (const [id, cascade] of this.cascades.entries()) {
+            if (lowerObs.includes(cascade.pattern.toLowerCase()) ||
+                lowerObs.includes(cascade.detection.toLowerCase()) ||
+                lowerObs.includes(cascade.id.toLowerCase())) {
+                if (!result.cascadePatterns)
+                    result.cascadePatterns = [];
+                result.cascadePatterns.push(cascade);
+                result.confidence = Math.max(result.confidence, 0.9);
+                result.actionRequired = cascade.fix;
+                if (!result.recommendations)
+                    result.recommendations = [];
+                result.recommendations.push(`Detected cascade ${id}: ${cascade.pattern}`);
+            }
+        }
+        // Apply confidence threshold
+        if (result.confidence < this.config.confidenceThreshold) {
+            result.recommendations?.push('Low confidence - investigate manually');
+        }
+        // Determine inference level
+        if (result.fatalAssumptions.length > 0) {
+            result.level = 'L3'; // Assumption surfacing
+        }
+        else if (result.cascadePatterns.length > 0) {
+            result.level = 'L2'; // Causal mapping
+        }
+        else {
+            result.level = 'L1'; // Pattern recognition
+        }
+        return result;
+    }
+    process(task) {
+        const analysis = this.analyze(task);
+        // Add meta-inference capabilities
+        if (analysis.level === 'L1') {
+            analysis.recommendations?.push('Pattern matched - proceed with caution');
+        }
+        else if (analysis.level === 'L2') {
+            analysis.recommendations?.push('Causal analysis detected - investigate root cause');
+        }
+        else if (analysis.level === 'L3') {
+            analysis.recommendations?.push('Assumptions detected - question and verify');
+        }
+        return analysis;
+    }
+    learn(outcome) {
+        if (!this.config.enableLearning)
+            return;
+        const input = outcome.patternUsed.toLowerCase();
+        // Update assumptions: if the input matches an assumption, reinforce it
+        for (const [id, assumption] of this.assumptions.entries()) {
+            let matched = false;
+            for (const trigger of assumption.trigger) {
+                if (input.includes(trigger.toLowerCase())) {
+                    matched = true;
+                    break;
+                }
+            }
+            if (matched) {
+                // Assumption was flagged in this input - boost confidence
+                // (We track effective confidence via an internal _confidence field)
+                const key = `__conf_${id}`;
+                const current = this[key] ?? 0.5;
+                this[key] = Math.min(current + 0.05, 1.0);
+            }
+        }
+        // Update cascades: if the input references a cascade pattern, reinforce it
+        for (const [id, cascade] of this.cascades.entries()) {
+            if (input.includes(cascade.pattern.toLowerCase()) ||
+                input.includes(cascade.detection.toLowerCase()) ||
+                input.includes(id.toLowerCase())) {
+                const key = `__conf_${id}`;
+                const current = this[key] ?? 0.5;
+                this[key] = Math.min(current + 0.05, 1.0);
+            }
+        }
+        // Decay confidence for assumptions that were NOT seen in recent inputs
+        for (const [id] of this.assumptions.entries()) {
+            const key = `__conf_${id}`;
+            const assumption = this.assumptions.get(id);
+            let matched = false;
+            for (const trigger of assumption.trigger) {
+                if (input.includes(trigger.toLowerCase())) {
+                    matched = true;
+                    break;
+                }
+            }
+            if (!matched) {
+                const current = this[key] ?? 0.5;
+                this[key] = Math.max(current - 0.02, 0.1);
+            }
+        }
+        // Apply success/failure adjustments to matched patterns
+        if (outcome.success) {
+            // Boost confidence for the pattern if it matches an assumption
+            const key = `__conf_${outcome.patternUsed}`;
+            const current = this[key];
+            if (current !== undefined) {
+                this[key] = Math.min(current + 0.05, 1.0);
+            }
+        }
+        else {
+            // Reduce confidence for failed patterns
+            const key = `__conf_${outcome.patternUsed}`;
+            const current = this[key];
+            if (current !== undefined) {
+                this[key] = Math.max(current - 0.1, 0.1);
+            }
+        }
+    }
+    getConfig() {
+        return { ...this.config };
+    }
+    updateConfig(updates) {
+        this.config = { ...this.config, ...updates };
+    }
+}
+// Export singleton instance
+let kernelInstance = null;
+export function getKernel() {
+    if (!kernelInstance) {
+        kernelInstance = new KernelAnalyzer();
+    }
+    return kernelInstance;
+}
+export function resetKernel() {
+    kernelInstance = null;
+}

package/dist/core/logging-config.d.ts

@@ -0,0 +1,10 @@
+export interface LoggingConfig {
+    enabled: boolean;
+    level: "debug" | "info" | "warn" | "error";
+    destinations: ("console" | "file" | "monitoring")[];
+    performanceMode: boolean;
+}
+export declare function getLoggingConfig(): LoggingConfig;
+export declare function setLoggingConfig(config: Partial<LoggingConfig>): void;
+export declare function isLoggingEnabled(): boolean;
+export declare function shouldLog(level: string): boolean;

package/dist/core/logging-config.js

@@ -0,0 +1,43 @@
+// Default logging configuration
+const defaultLoggingConfig = {
+    enabled: process.env.XRAY_LOGGING_ENABLED !== "false", // Default true, can be disabled
+    level: process.env.XRAY_LOG_LEVEL || "info",
+    destinations: ["console", "file"],
+    performanceMode: process.env.XRAY_PERFORMANCE_MODE === "true",
+};
+// Available log levels in priority order (higher index = more verbose)
+const LOG_LEVELS = ["debug", "info", "warn", "error"];
+// Global logging configuration instance
+let globalLoggingConfig = { ...defaultLoggingConfig };
+export function getLoggingConfig() {
+    return { ...globalLoggingConfig };
+}
+export function setLoggingConfig(config) {
+    globalLoggingConfig = { ...globalLoggingConfig, ...config };
+}
+export function isLoggingEnabled() {
+    return globalLoggingConfig.enabled;
+}
+export function shouldLog(level) {
+    if (!globalLoggingConfig.enabled) {
+        return false;
+    }
+    const currentLevelIndex = LOG_LEVELS.indexOf(globalLoggingConfig.level);
+    const messageLevelIndex = LOG_LEVELS.indexOf(level);
+    // If either level is not found, default to showing the message
+    if (currentLevelIndex === -1 || messageLevelIndex === -1) {
+        return true;
+    }
+    // Show message if its level is >= current configured level
+    return messageLevelIndex >= currentLevelIndex;
+}
+// Environment variable configuration
+if (process.env.XRAY_LOGGING_ENABLED === "false") {
+    setLoggingConfig({ enabled: false });
+}
+if (process.env.XRAY_LOG_LEVEL) {
+    setLoggingConfig({ level: process.env.XRAY_LOG_LEVEL });
+}
+if (process.env.XRAY_PERFORMANCE_MODE === "true") {
+    setLoggingConfig({ performanceMode: true });
+}

package/dist/core/model-router.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Model Router
+ *
+ * Intelligent model routing based on task complexity and type.
+ * Uses featuresConfigLoader as the single source of truth for all model config.
+ *
+ * @since 2026-01-25
+ */
+import { type TaskType } from "./features-config.js";
+interface TaskContext {
+    toolName?: string;
+    fileCount?: number;
+    isComplex?: boolean;
+    agentType?: string;
+}
+declare class ModelRouter {
+    private availableModels;
+    constructor();
+    private discoverModels;
+    /**
+     * Get the appropriate model for a specific task context
+     * Uses features-config for task-based routing when available
+     */
+    getModelForTask(context: TaskContext): string;
+    /**
+     * Get validated model for agent type
+     */
+    getValidatedModel(agentType?: string): string;
+    /**
+     * Get model for a specific task type directly
+     */
+    getModelForTaskType(taskType: TaskType): string;
+    /**
+     * Get max tokens for a task type
+     */
+    getMaxTokensForTaskType(taskType: TaskType): number;
+    private isModelAvailable;
+    /**
+     * Reload configuration from disk
+     */
+    reloadConfig(): void;
+    /**
+     * Get current configuration summary
+     */
+    getConfigSummary(): {
+        defaultModel: string;
+        fallbackModel: string;
+        taskRoutingEnabled: boolean;
+        availableModels: string[];
+    };
+}
+export declare const modelRouter: ModelRouter;
+export default modelRouter;
+export declare const getModelForTask: (context: TaskContext) => string;
+export declare const getModelForTaskType: (taskType: TaskType) => string;
+export declare const getValidatedModel: (agentType?: string) => string;

package/dist/core/model-router.js

@@ -0,0 +1,134 @@
+/**
+ * Model Router
+ *
+ * Intelligent model routing based on task complexity and type.
+ * Uses featuresConfigLoader as the single source of truth for all model config.
+ *
+ * @since 2026-01-25
+ */
+import { featuresConfigLoader, detectTaskType, } from "./features-config.js";
+// ============================================================================
+// Model Router Class
+// ============================================================================
+class ModelRouter {
+    availableModels;
+    constructor() {
+        this.availableModels = this.discoverModels();
+    }
+    discoverModels() {
+        const defaultModels = [
+            "claude-opus-4",
+            "claude-sonnet-4",
+            "claude-haiku-4",
+            "openai/gpt-4o",
+            "openai/gpt-4o-mini",
+            "google/gemini-pro-1.5",
+            "google/gemini-flash-1.5",
+            "meta/llama-3.1-70b-instruct",
+            "mistral/mistral-7b-instruct",
+        ];
+        const featuresConfig = featuresConfigLoader.loadConfig();
+        const configModels = [];
+        if (featuresConfig.model_routing?.task_routing) {
+            for (const route of Object.values(featuresConfig.model_routing.task_routing)) {
+                if (route?.model && !configModels.includes(route.model)) {
+                    configModels.push(route.model);
+                }
+            }
+        }
+        const uniqueModels = new Set([...defaultModels, ...configModels]);
+        return Array.from(uniqueModels);
+    }
+    /**
+     * Get the appropriate model for a specific task context
+     * Uses features-config for task-based routing when available
+     */
+    getModelForTask(context) {
+        const featuresConfig = featuresConfigLoader.loadConfig();
+        if (featuresConfig.model_routing.enabled && context.toolName) {
+            const taskContext = {};
+            if (context.fileCount !== undefined)
+                taskContext.fileCount = context.fileCount;
+            if (context.isComplex !== undefined)
+                taskContext.isComplex = context.isComplex;
+            const taskType = detectTaskType(context.toolName, taskContext);
+            if (taskType !== "unknown") {
+                const model = featuresConfigLoader.getModelForTask(taskType);
+                if (this.isModelAvailable(model)) {
+                    return model;
+                }
+            }
+        }
+        // Fall back to agent-specific routing
+        if (context.agentType) {
+            return this.getValidatedModel(context.agentType);
+        }
+        return this.getValidatedModel();
+    }
+    /**
+     * Get validated model for agent type
+     */
+    getValidatedModel(agentType) {
+        const featuresConfig = featuresConfigLoader.loadConfig();
+        // 1. Check features config for agent-specific model
+        if (agentType) {
+            const agentModel = featuresConfig.agent_management?.agent_models?.[agentType];
+            if (agentModel && this.isModelAvailable(agentModel)) {
+                return agentModel;
+            }
+        }
+        // 2. Framework default from features config
+        const defaultModel = featuresConfig.model_routing?.default_model;
+        if (defaultModel && this.isModelAvailable(defaultModel)) {
+            return defaultModel;
+        }
+        // 3. Hardcoded default
+        if (this.isModelAvailable("claude-sonnet-4")) {
+            return "claude-sonnet-4";
+        }
+        // 4. Ultimate fallback
+        const fallbackModel = featuresConfig.model_routing?.fallback_model || "claude-haiku-4";
+        return fallbackModel;
+    }
+    /**
+     * Get model for a specific task type directly
+     */
+    getModelForTaskType(taskType) {
+        return featuresConfigLoader.getModelForTask(taskType);
+    }
+    /**
+     * Get max tokens for a task type
+     */
+    getMaxTokensForTaskType(taskType) {
+        return featuresConfigLoader.getMaxTokensForTask(taskType);
+    }
+    isModelAvailable(_model) {
+        return true;
+    }
+    /**
+     * Reload configuration from disk
+     */
+    reloadConfig() {
+        featuresConfigLoader.clearCache();
+        this.availableModels = this.discoverModels();
+    }
+    /**
+     * Get current configuration summary
+     */
+    getConfigSummary() {
+        const featuresConfig = featuresConfigLoader.loadConfig();
+        return {
+            defaultModel: featuresConfig.model_routing?.default_model || "claude-sonnet-4",
+            fallbackModel: featuresConfig.model_routing?.fallback_model || "claude-haiku-4",
+            taskRoutingEnabled: featuresConfig.model_routing?.enabled || false,
+            availableModels: this.availableModels,
+        };
+    }
+}
+// Export singleton instance
+export const modelRouter = new ModelRouter();
+export default modelRouter;
+// Export convenience functions
+export const getModelForTask = (context) => modelRouter.getModelForTask(context);
+export const getModelForTaskType = (taskType) => modelRouter.getModelForTaskType(taskType);
+export const getValidatedModel = (agentType) => modelRouter.getValidatedModel(agentType);

package/dist/core/orchestrator.d.ts

@@ -0,0 +1,71 @@
+/**
+ * 0xRay Framework - Core Orchestrator
+ * Main orchestration engine for multi-agent task coordination
+ */
+import { TaskDefinition } from "../agents/types.js";
+export interface OrchestrationResult {
+    success: boolean;
+    taskId: string;
+    agentUsed: string;
+    duration: number;
+    result: unknown;
+    error?: string;
+    errors?: string[];
+}
+export interface OrchestratorConfig {
+    maxConcurrentTasks?: number;
+    taskTimeout?: number;
+    conflictResolutionStrategy?: "majority_vote" | "expert_priority";
+}
+export declare class KernelOrchestrator {
+    private taskQueue;
+    private activeTasks;
+    private totalProcessed;
+    private config;
+    private kernel;
+    constructor(config?: OrchestratorConfig);
+    executeTask(task: TaskDefinition): Promise<OrchestrationResult>;
+    /**
+     * Execute a single task by delegating to appropriate subagent
+     */
+    private executeSingleTask;
+    private dispatchToAgent;
+    executeComplexTask(description: string, tasks: TaskDefinition[], sessionId?: string): Promise<OrchestrationResult[]>;
+    private topologicalSort;
+    /**
+     * Validates that all task dependencies are within the current task batch.
+     * Prevents cross-orchestrator dependency errors by failing fast with a clear message.
+     */
+    private validateTaskDependencies;
+    executeComplexTaskSingle(task: TaskDefinition): Promise<OrchestrationResult>;
+    resolveConflicts(conflicts: Array<{
+        response?: unknown;
+        proposed?: unknown;
+        expertiseScore?: number;
+    }>): {
+        response: string;
+        expertiseScore: number;
+    };
+    private generateTaskId;
+    /**
+     * Delegate a task to a specific agent with timeout protection
+     */
+    delegateToSubagent(agentName: string, task: TaskDefinition): Promise<{
+        success: boolean;
+        result: unknown;
+        agentName: string;
+        executionTime: number;
+    }>;
+    private performDelegation;
+    getStatus(): {
+        queueSize: number;
+        activeTasks: number;
+        totalProcessed: number;
+        config: {
+            maxConcurrentTasks: number;
+            taskTimeout: number;
+            conflictResolutionStrategy: "majority_vote" | "expert_priority";
+        };
+    };
+}
+export declare const xrayOrchestrator: KernelOrchestrator;