0xray 4.0.12 → 4.0.13

package/dist/core/kernel-patterns.js

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

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

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

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

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

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