0xray 2.0.0

package/dist/core/context-validator.js

@@ -0,0 +1,212 @@
+/**
+ * 0xRay Context Size Validator
+ *
+ * Prevents system prompt bloat by validating and rejecting context-injection attempts
+ * that would exceed token budgets.
+ *
+ * @version 1.0.0
+ * @since 2026-03-03
+ */
+/**
+ * Default configuration settings
+ */
+const DEFAULT_CONFIG = {
+    maxSystemPromptLength: 8000, // Max system prompt length
+    maxCodexContextLength: 4000, // Max codex terms (increased)
+    maxTotalPromptLength: 16000, // Maximum total token budget (increased)
+    enableCompression: true, // Enable automatic compression
+    preventDuplicateContent: true, // Prevent duplicate context blocks
+};
+/**
+ * Estimate text size in tokens (rough approximation: 1 token ≈ 4 characters)
+ */
+function estimateTokenCount(text) {
+    return Math.ceil(text.length / 4);
+}
+/**
+ * Detect duplicate content patterns
+ */
+function detectDuplicatePatterns(content) {
+    const patterns = [
+        // Multiple version blocks
+        /0xRay Codex Context v[\d.]+.*?Source: [\s\S]*?---/g,
+        // Duplicate ASCII art
+        /═+/g,
+        // Repeated framework banners  
+        /0xRay Framework v[\d.]+.*?Successfully Loaded/g,
+        // Multiple interweaves/lenses sections
+        /Interweaves:|Lenses:|Anti-patterns:/g
+    ];
+    const duplicates = [];
+    patterns.forEach(pattern => {
+        const matches = content.match(pattern);
+        if (matches && matches.length > 1) {
+            duplicates.push(`Found ${matches.length} instances of pattern: ${pattern}`);
+        }
+    });
+    return duplicates;
+}
+/**
+ * Compress codex content by keeping only essential terms
+ */
+function compressCodexContent(content, maxLength) {
+    if (content.length <= maxLength)
+        return content;
+    // Split content into lines and keep only essential parts
+    const lines = content.split('\n');
+    const essentialLines = [];
+    let currentLength = 0;
+    // Prioritize: essential terms first, then metadata, then non-critical content
+    const essentialKeywords = [
+        'Progressive Prod-Ready Code',
+        'No Patches/Boiler/Stubs/Bridge Code',
+        'Resolve All Errors',
+        'Prevent Infinite Loops',
+        'Type Safety First',
+        'Core Terms:',
+        'Essential Rules:',
+        'Universal Development Codex'
+    ];
+    // Add essential content first
+    for (const line of lines) {
+        if (currentLength + line.length >= maxLength)
+            break;
+        // Prioritize lines with essential keywords
+        if (essentialKeywords.some(keyword => line.includes(keyword))) {
+            essentialLines.push(line);
+            currentLength += line.length;
+        }
+    }
+    // Add remaining content if space permits
+    for (const line of lines) {
+        if (currentLength + line.length >= maxLength)
+            break;
+        if (!essentialLines.includes(line)) {
+            essentialLines.push(line);
+            currentLength += line.length;
+        }
+    }
+    const compressed = essentialLines.join('\n') + '\n... (content optimized for token efficiency)';
+    return compressed;
+}
+/**
+ * Validate context size and detect bloat
+ */
+export function validateContext(context, config = {}) {
+    const finalConfig = { ...DEFAULT_CONFIG, ...config };
+    const warnings = [];
+    let compressionApplied = false;
+    // Estimate token count
+    const sizeInTokens = estimateTokenCount(context);
+    const exceedsBudget = sizeInTokens > finalConfig.maxTotalPromptLength;
+    // Check for duplicate content
+    if (finalConfig.preventDuplicateContent) {
+        const duplicates = detectDuplicatePatterns(context);
+        if (duplicates.length > 0) {
+            warnings.push("Duplicate content patterns detected:");
+            warnings.push(...duplicates);
+        }
+    }
+    // Check for ASCII art (major token consumer)
+    const asciiArtLines = context.split('\n').filter(line => line.includes('═') || line.includes('╔') || line.includes('╝'));
+    if (asciiArtLines.length > 2) {
+        warnings.push(`Excessive ASCII art detected (${asciiArtLines.length} lines, ~${asciiArtLines.length * 50} tokens)`);
+    }
+    // Check codex-specific bloat
+    if (context.includes('Universal Development Codex') && sizeInTokens > 3000) {
+        warnings.push("Codex context may be too verbose (>3000 tokens)");
+    }
+    // Apply compression if needed and enabled
+    let optimizedContent = context;
+    if (exceedsBudget && finalConfig.enableCompression) {
+        optimizedContent = compressCodexContent(context, finalConfig.maxTotalPromptLength);
+        compressionApplied = true;
+        warnings.push(`Content compressed to ${estimateTokenCount(optimizedContent)} tokens`);
+    }
+    // Additional size-based warnings
+    if (sizeInTokens > finalConfig.maxTotalPromptLength * 0.9) {
+        warnings.push(`Context approaching token limit (${sizeInTokens}/${finalConfig.maxTotalPromptLength})`);
+    }
+    return {
+        isValid: !exceedsBudget,
+        sizeInTokens,
+        exceedsBudget,
+        warnings,
+        compressionApplied,
+        optimizedContent: compressionApplied ? optimizedContent : undefined
+    };
+}
+/**
+ * Validate context collection (multiple contexts combined)
+ */
+export function validateContextCollection(contexts, config = {}) {
+    const finalConfig = { ...DEFAULT_CONFIG, ...config };
+    // Combine all contexts
+    const combinedContext = contexts.join('\n\n');
+    // Validate combined context
+    return validateContext(combinedContext, finalConfig);
+}
+/**
+ * Prevent system prompt bloat middleware
+ */
+export function preventSystemPromptBloat(context, onWarning) {
+    const validation = validateContext(context, {
+        maxSystemPromptLength: 3000,
+        enableCompression: true,
+        preventDuplicateContent: true
+    });
+    // Log warnings if callback provided
+    if (onWarning) {
+        validation.warnings.forEach(warning => onWarning(warning));
+    }
+    // Return optimized content or original if validation passes
+    return validation.optimizedContent || context;
+}
+/**
+ * Utility function to check if a prompt is likely to cause overflow
+ */
+export function isPromptLikelyToOverflow(prompt) {
+    // Heuristic checks for known bloat patterns
+    const bloatIndicators = [
+        // Multiple version blocks
+        /0xRay Codex Context v[\d.]+.*?0xRay Codex Context v[\d.]+/s,
+        // Extremely long prompts (>12,000 tokens)
+        prompt.length > 48000,
+        // Multiple ASCII art banners
+        /═+/g,
+        // Repeated context sections
+        /Terms Loaded: \d+.*?Terms Loaded: \d+/s
+    ];
+    return bloatIndicators.some(indicator => {
+        if (typeof indicator === 'string') {
+            return prompt.includes(indicator);
+        }
+        else if (indicator instanceof RegExp) {
+            return indicator.test(prompt);
+        }
+        return false;
+    });
+}
+/**
+ * Generate a safe system prompt template
+ */
+export function generateSafeSystemPrompt(baseTemplate, additionalContext, maxTokens = 6000) {
+    // Check if additional context causes overflow
+    const contextValidation = validateContext(additionalContext, {
+        maxTotalPromptLength: maxTokens
+    });
+    if (!contextValidation.isValid) {
+        // Use minimal context only
+        const minimalContext = additionalContext.split('\n').slice(0, 10).join('\n');
+        const finalPrompt = `${baseTemplate}\n\n${minimalContext}`;
+        return {
+            prompt: finalPrompt,
+            safe: true
+        };
+    }
+    const finalPrompt = `${baseTemplate}\n\n${additionalContext}`;
+    return {
+        prompt: finalPrompt,
+        safe: estimateTokenCount(finalPrompt) <= maxTokens
+    };
+}

package/dist/core/features-config.js

@@ -0,0 +1,457 @@
+/**
+ * Features Configuration Loader
+ *
+ * Loads and validates the unified features configuration from features.json
+ * Supports token optimization, model routing, batch operations, and more.
+ *
+ * @version 1.0.0
+ * @since 2026-01-25
+ */
+import * as fs from "fs";
+import * as path from "path";
+import { getConfigDir, resolveConfigPath } from "./config-paths.js";
+/**
+ * Detect task type from tool name and context
+ */
+export function detectTaskType(toolName, context) {
+    const toolLower = toolName.toLowerCase();
+    // File operations
+    if (toolLower.includes("read") || toolLower === "cat") {
+        return "file_read";
+    }
+    // Search operations
+    if (toolLower.includes("grep") ||
+        toolLower.includes("search") ||
+        toolLower.includes("find")) {
+        return "grep_search";
+    }
+    // Git operations
+    if (toolLower.includes("git") ||
+        toolLower.includes("commit") ||
+        toolLower.includes("push")) {
+        return "git_operations";
+    }
+    // Edit operations - check complexity
+    if (toolLower.includes("edit") ||
+        toolLower.includes("write") ||
+        toolLower.includes("sed")) {
+        const fileCount = context?.fileCount ?? 1;
+        const isComplex = context?.isComplex ?? false;
+        if (fileCount > 5 || isComplex) {
+            return "bulk_refactor";
+        }
+        return "simple_edit";
+    }
+    // Documentation
+    if (toolLower.includes("doc") ||
+        toolLower.includes("readme") ||
+        toolLower.includes("markdown")) {
+        return "documentation";
+    }
+    // Security
+    if (toolLower.includes("security") ||
+        toolLower.includes("audit") ||
+        toolLower.includes("vulnerability")) {
+        return "security_audit";
+    }
+    // Architecture
+    if (toolLower.includes("architect") ||
+        toolLower.includes("design") ||
+        toolLower.includes("structure")) {
+        return "architecture_review";
+    }
+    // Code generation
+    if (toolLower.includes("generate") ||
+        toolLower.includes("create") ||
+        toolLower.includes("implement")) {
+        return "code_generation";
+    }
+    // Debugging
+    if (toolLower.includes("debug") ||
+        toolLower.includes("fix") ||
+        toolLower.includes("error")) {
+        return "debugging";
+    }
+    return "unknown";
+}
+// ============================================================================
+// Features Config Loader
+// ============================================================================
+export class FeaturesConfigLoader {
+    featuresPath;
+    cachedConfig = null;
+    cacheExpiry = 30000; // 30 seconds
+    lastLoadTime = 0;
+    constructor(featuresPath) {
+        this.featuresPath = featuresPath || resolveConfigPath("features.json") || path.join(getConfigDir(), "features.json");
+    }
+    /**
+     * Load features configuration
+     */
+    loadConfig() {
+        const now = Date.now();
+        // Return cached config if still valid
+        if (this.cachedConfig && now - this.lastLoadTime < this.cacheExpiry) {
+            return this.cachedConfig;
+        }
+        try {
+            const configPath = path.resolve(process.cwd(), this.featuresPath);
+            if (!fs.existsSync(configPath)) {
+                return this.getDefaultConfig();
+            }
+            const configData = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+            const config = this.mergeWithDefaults(configData);
+            this.cachedConfig = config;
+            this.lastLoadTime = now;
+            return config;
+        }
+        catch (error) {
+            // Silent fallback to defaults on error - frameworkLogger not available here
+            return this.getDefaultConfig();
+        }
+    }
+    /**
+     * Get model for a specific task type
+     */
+    getModelForTask(taskType) {
+        const config = this.loadConfig();
+        if (!config.model_routing?.enabled) {
+            return config.model_routing?.default_model || "claude-sonnet-4";
+        }
+        const taskRouting = config.model_routing?.task_routing;
+        const taskConfig = taskRouting
+            ? taskRouting[taskType]
+            : undefined;
+        if (taskConfig) {
+            return taskConfig.model;
+        }
+        return config.model_routing?.default_model || "claude-sonnet-4";
+    }
+    /**
+     * Get max tokens for a specific task type
+     */
+    getMaxTokensForTask(taskType) {
+        const config = this.loadConfig();
+        const taskRouting = config.model_routing?.task_routing;
+        const taskConfig = taskRouting
+            ? taskRouting[taskType]
+            : undefined;
+        if (taskConfig) {
+            return taskConfig.max_tokens;
+        }
+        return 4000; // Default
+    }
+    /**
+     * Check if a feature is enabled
+     */
+    isFeatureEnabled(feature) {
+        const config = this.loadConfig();
+        const featureConfig = config[feature];
+        if (typeof featureConfig === "object" &&
+            featureConfig !== null &&
+            "enabled" in featureConfig) {
+            return featureConfig.enabled;
+        }
+        return false;
+    }
+    /**
+     * Get token optimization settings
+     */
+    getTokenOptimization() {
+        return this.loadConfig().token_optimization;
+    }
+    /**
+     * Get batch operation settings
+     */
+    getBatchOperations() {
+        return this.loadConfig().batch_operations;
+    }
+    /**
+     * Get agent spawn settings
+     */
+    getAgentSpawn() {
+        return this.loadConfig().agent_spawn;
+    }
+    /**
+     * Get activity logging settings
+     */
+    getActivityLogging() {
+        return this.loadConfig().activity_logging;
+    }
+    /**
+     * Get performance monitoring alerting settings
+     */
+    getAlertingConfig() {
+        return this.loadConfig().performance_monitoring?.alerting || {
+            enabled: true,
+            performance_degradation_threshold: 20,
+            error_rate_threshold: 5,
+            cost_threshold_daily: 10,
+        };
+    }
+    /**
+     * Check if alerting is enabled from config
+     */
+    isAlertingEnabled() {
+        return this.loadConfig().performance_monitoring?.alerting?.enabled ?? true;
+    }
+    /**
+     * Check if agent is disabled
+     */
+    isAgentDisabled(agentName) {
+        const config = this.loadConfig();
+        return config.agent_management.disabled_agents.includes(agentName);
+    }
+    /**
+     * Get agent model assignment
+     */
+    getAgentModel(agentName) {
+        const config = this.loadConfig();
+        return (config.agent_management?.agent_models?.[agentName] ||
+            config.model_routing?.default_model ||
+            "claude-sonnet-4");
+    }
+    /**
+     * Merge loaded config with defaults
+     */
+    mergeWithDefaults(configData) {
+        const defaults = this.getDefaultConfig();
+        return {
+            ...defaults,
+            ...configData,
+            token_optimization: {
+                ...defaults.token_optimization,
+                ...configData.token_optimization,
+                context_compression: {
+                    ...defaults.token_optimization.context_compression,
+                    ...configData.token_optimization?.context_compression,
+                },
+            },
+            model_routing: {
+                ...defaults.model_routing,
+                ...configData.model_routing,
+                task_routing: {
+                    ...defaults.model_routing.task_routing,
+                    ...configData.model_routing?.task_routing,
+                },
+            },
+            batch_operations: {
+                ...defaults.batch_operations,
+                ...configData.batch_operations,
+            },
+            multi_agent_orchestration: {
+                ...defaults.multi_agent_orchestration,
+                ...configData.multi_agent_orchestration,
+            },
+            autonomous_reporting: {
+                ...defaults.autonomous_reporting,
+                ...configData.autonomous_reporting,
+            },
+            agent_management: {
+                ...defaults.agent_management,
+                ...configData.agent_management,
+                performance_limits: {
+                    ...defaults.agent_management.performance_limits,
+                    ...configData.agent_management?.performance_limits,
+                },
+            },
+            refactoring: {
+                ...defaults.refactoring,
+                ...configData.refactoring,
+            },
+            activity_logging: {
+                ...defaults.activity_logging,
+                ...configData.activity_logging,
+            },
+            security: {
+                ...defaults.security,
+                ...configData.security,
+            },
+            performance_monitoring: {
+                ...defaults.performance_monitoring,
+                ...configData.performance_monitoring,
+                alerting: {
+                    ...defaults.performance_monitoring.alerting,
+                    ...configData.performance_monitoring?.alerting,
+                },
+            },
+            caching: {
+                ...defaults.caching,
+                ...configData.caching,
+            },
+        };
+    }
+    /**
+     * Get default configuration
+     */
+    getDefaultConfig() {
+        return {
+            version: "1.22.67",
+            description: "0xRay Framework - Unified Feature Configuration",
+            token_optimization: {
+                enabled: true,
+                max_context_tokens: 50000,
+                prune_after_task: true,
+                summarize_tool_outputs: true,
+                context_compression: {
+                    enabled: true,
+                    threshold_tokens: 40000,
+                    compression_ratio: 0.5,
+                },
+            },
+            model_routing: {
+                enabled: true,
+                // Use OpenCode's default model for all tasks
+                // Task-based model selection can be configured in opencode.json
+            },
+            batch_operations: {
+                enabled: true,
+                prefer_sed_for_replacements: true,
+                parallel_file_updates: true,
+                max_concurrent_edits: 10,
+                auto_batch_threshold: 5,
+            },
+            multi_agent_orchestration: {
+                enabled: true,
+                coordination_model: "async-multi-agent",
+                max_concurrent_agents: 3,
+                task_distribution_strategy: "capability-based",
+                conflict_resolution: "expert-priority",
+                progress_tracking: true,
+                session_persistence: true,
+            },
+            autonomous_reporting: {
+                enabled: true,
+                interval_minutes: 60,
+                auto_schedule: true,
+                include_health_assessment: true,
+                include_agent_activities: true,
+                include_pipeline_operations: true,
+                include_critical_issues: true,
+                include_recommendations: true,
+                report_retention_days: 30,
+                notification_channels: ["console"],
+            },
+            agent_management: {
+                disabled_agents: [],
+                agent_models: {
+                // Use default model from OpenCode configuration
+                },
+                performance_limits: {
+                    max_task_duration_ms: 30000,
+                    max_memory_usage_mb: 512,
+                    max_tokens_per_request: 16000,
+                },
+            },
+            refactoring: {
+                enabled: true,
+                automatic_detection: true,
+                require_user_approval: false,
+                max_complexity_threshold: 80,
+                safe_mode: true,
+                batch_mode: true,
+            },
+            activity_logging: {
+                enabled: false, // Disabled by default to reduce verbose logging
+                level: "warn", // Only log warnings and errors by default
+                include_performance_metrics: false,
+                include_agent_states: false,
+                include_token_usage: true, // Keep token usage for debugging
+                retention_days: 3, // Shorter retention
+                log_to_file: false, // Don't log to file by default
+                log_path: ".opencode/logs",
+            },
+            security: {
+                enabled: true,
+                prompt_sanitization: true,
+                vulnerability_scanning: true,
+                code_review_enforcement: true,
+                security_score_threshold: 70,
+            },
+            performance_monitoring: {
+                enabled: true,
+                real_time_metrics: true,
+                benchmark_tracking: true,
+                token_tracking: true,
+                cost_tracking: true,
+                alerting: {
+                    enabled: true,
+                    performance_degradation_threshold: 20,
+                    error_rate_threshold: 5,
+                    cost_threshold_daily: 10.0,
+                },
+            },
+            caching: {
+                enabled: true,
+                file_content_cache: true,
+                search_result_cache: true,
+                cache_ttl_seconds: 300,
+                max_cache_size_mb: 50,
+            },
+        };
+    }
+    /**
+     * Clear configuration cache
+     */
+    clearCache() {
+        this.cachedConfig = null;
+        this.lastLoadTime = 0;
+    }
+    /**
+     * Save current configuration to file
+     */
+    saveConfig(config) {
+        try {
+            const configPath = path.resolve(process.cwd(), this.featuresPath);
+            const currentConfig = this.loadConfig();
+            const mergedConfig = this.mergeWithDefaults({
+                ...currentConfig,
+                ...config,
+            });
+            fs.writeFileSync(configPath, JSON.stringify(mergedConfig, null, 2));
+            this.clearCache();
+        }
+        catch (error) {
+            // Silent fail - frameworkLogger not available here
+            throw error;
+        }
+    }
+    /**
+     * Enable a feature
+     */
+    enableFeature(feature) {
+        const config = this.loadConfig();
+        const featureConfig = config[feature];
+        if (typeof featureConfig === "object" &&
+            featureConfig !== null &&
+            "enabled" in featureConfig) {
+            featureConfig.enabled = true;
+            this.saveConfig({
+                [feature]: featureConfig,
+            });
+        }
+    }
+    /**
+     * Disable a feature
+     */
+    disableFeature(feature) {
+        const config = this.loadConfig();
+        const featureConfig = config[feature];
+        if (typeof featureConfig === "object" &&
+            featureConfig !== null &&
+            "enabled" in featureConfig) {
+            featureConfig.enabled = false;
+            this.saveConfig({
+                [feature]: featureConfig,
+            });
+        }
+    }
+}
+// Export singleton instance
+export const featuresConfigLoader = new FeaturesConfigLoader();
+// Export convenience functions
+export const getModelForTask = (taskType) => featuresConfigLoader.getModelForTask(taskType);
+export const isFeatureEnabled = (feature) => featuresConfigLoader.isFeatureEnabled(feature);
+export const getTokenOptimization = () => featuresConfigLoader.getTokenOptimization();
+export const getBatchOperations = () => featuresConfigLoader.getBatchOperations();
+export const getAgentSpawn = () => featuresConfigLoader.getAgentSpawn();