0xray 4.0.12 → 4.0.13

package/dist/core/activity-logger.js

@@ -1,259 +0,0 @@
-/**
- * Activity Logger
- *
- * Comprehensive logging for all 0xRay activities including:
- * - Framework operations
- * - Development sessions
- * - Script executions
- * - File operations
- * - Test results
- *
- * Enable/Disable via:
- *   XRAY_ACTIVITY_LOGGING=true  (enable)
- *   XRAY_ACTIVITY_LOGGING=false (disable, default)
- *
- * @module core/activity-logger
- */
-import * as fs from "fs";
-import * as path from "path";
-import * as zlib from "zlib";
-import { frameworkLogger } from "./framework-logger.js";
-const MAX_LOG_SIZE_BYTES = 5 * 1024 * 1024; // 5MB before rotation
-// Global state
-let activityLoggerEnabled = process.env.XRAY_ACTIVITY_LOGGING !== "false";
-let activityLogPath;
-let sessionId;
-let sessionStartTime;
-/**
- * Initialize activity logger with config from features.json
- * Called by boot-orchestrator during initialization
- */
-export function initializeActivityLogger(config) {
-    // Allow override via config (features.json) or environment
-    if (config?.enabled !== undefined) {
-        activityLoggerEnabled = config.enabled;
-    }
-    // Use config path or default
-    const logDir = config?.log_path
-        ? config.log_path.replace(/\/logs$/, "")
-        : path.join(process.cwd(), "logs", "framework");
-    if (!fs.existsSync(logDir)) {
-        fs.mkdirSync(logDir, { recursive: true });
-    }
-    activityLogPath = path.join(logDir, "activity.log");
-    // Initialize session if not already done
-    if (!sessionId) {
-        sessionId = generateSessionId();
-        sessionStartTime = Date.now();
-        initializeLogFile();
-        initializeReportFile();
-    }
-}
-/**
- * Initialize the activity logger
- */
-function initialize() {
-    const cwd = process.cwd();
-    const logDir = path.join(cwd, "logs", "framework");
-    // Create log directory if it doesn't exist
-    if (!fs.existsSync(logDir)) {
-        fs.mkdirSync(logDir, { recursive: true });
-    }
-    activityLogPath = path.join(logDir, "activity.log");
-    sessionId = generateSessionId();
-    sessionStartTime = Date.now();
-    // Initialize files
-    initializeLogFile();
-    initializeReportFile();
-    logActivity("session", "info", "session-started", "Activity logging session started", {
-        sessionId,
-        cwd,
-        pid: process.pid,
-        nodeVersion: process.version,
-    });
-}
-/**
- * Generate unique session ID
- */
-function generateSessionId() {
-    const timestamp = Date.now();
-    const random = Math.random().toString(36).substring(2, 8);
-    return `session-${timestamp}-${random}`;
-}
-/**
- * Generate unique activity ID
- */
-function generateActivityId() {
-    const timestamp = Date.now();
-    const random = Math.random().toString(36).substring(2, 8);
-    return `act-${timestamp}-${random}`;
-}
-/**
- * Rotate log file if it exceeds max size
- */
-function rotateIfNeeded() {
-    try {
-        if (!fs.existsSync(activityLogPath))
-            return;
-        const stat = fs.statSync(activityLogPath);
-        if (stat.size < MAX_LOG_SIZE_BYTES)
-            return;
-        const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
-        const archivePath = activityLogPath.replace(/\.log$/, `-${timestamp}.log.gz`);
-        const content = fs.readFileSync(activityLogPath);
-        fs.writeFileSync(archivePath, zlib.gzipSync(content));
-        fs.writeFileSync(activityLogPath, "");
-        frameworkLogger.log("activity-logger", "log-rotated", "info", {
-            archivePath,
-            sizeBytes: stat.size,
-        });
-    }
-    catch (error) {
-        frameworkLogger.log("activity-logger", "log-rotate-failed", "error", { error });
-    }
-}
-/**
- * Initialize activity log file
- */
-function initializeLogFile() {
-    rotateIfNeeded();
-    if (!fs.existsSync(activityLogPath)) {
-        fs.writeFileSync(activityLogPath, "");
-    }
-}
-/**
- * Initialize activity report JSON file
- */
-function initializeReportFile() {
-    const reportPath = path.join(path.dirname(activityLogPath), "activity-report.json");
-    if (!fs.existsSync(reportPath)) {
-        fs.writeFileSync(reportPath, JSON.stringify({
-            sessions: [],
-            activities: [],
-            stats: {
-                total: 0,
-                byCategory: {},
-                byLevel: {},
-            }
-        }, null, 2));
-    }
-}
-/**
- * Check if activity logging is enabled
- */
-export function isActivityLoggingEnabled() {
-    return activityLoggerEnabled;
-}
-/**
- * Enable or disable activity logging
- */
-export function setActivityLoggingEnabled(enabled) {
-    activityLoggerEnabled = enabled;
-}
-/**
- * Get current session ID
- */
-export function getSessionId() {
-    return sessionId;
-}
-/**
- * Log an activity
- */
-export function logActivity(category, level, action, message, details, options) {
-    if (!activityLoggerEnabled) {
-        return;
-    }
-    const record = {
-        timestamp: new Date().toISOString(),
-        id: generateActivityId(),
-        category,
-        level,
-        action,
-        message,
-        sessionId: options?.sessionId || sessionId,
-    };
-    if (details) {
-        record.details = details;
-    }
-    if (options?.jobId) {
-        record.jobId = options.jobId;
-    }
-    // Write to log file
-    writeToLogFile(record);
-    // Write to report JSON
-    writeToReportFile(record);
-    // Console output for debug mode
-    if (process.env.XRAY_ACTIVITY_CONSOLE === "true") {
-        frameworkLogger.log("activity-logger", "console-output", "info", { message: `[${record.timestamp}] [${record.category}] ${level.toUpperCase()}: ${message}`, details: details || "" });
-    }
-}
-/**
- * Write activity to log file
- */
-function writeToLogFile(record) {
-    try {
-        rotateIfNeeded();
-        const detailsPart = record.details
-            ? ` | ${JSON.stringify(record.details)}`
-            : "";
-        const jobIdPart = record.jobId ? `[${record.jobId}] ` : "";
-        const logLine = `${record.timestamp} ${jobIdPart}[${record.category}] ${record.action} - ${record.level.toUpperCase()}${detailsPart}\n`;
-        fs.appendFileSync(activityLogPath, logLine);
-    }
-    catch (error) {
-        frameworkLogger.log("activity-logger", "write-log-failed", "error", { error, message: "Failed to write to activity log" });
-    }
-}
-/**
- * Write activity to report JSON
- */
-function writeToReportFile(record) {
-    try {
-        const reportPath = path.join(path.dirname(activityLogPath), "activity-report.json");
-        let report;
-        try {
-            report = JSON.parse(fs.readFileSync(reportPath, "utf-8"));
-        }
-        catch {
-            // New file or invalid JSON
-            report = { sessions: [], activities: [], stats: { total: 0, byCategory: {}, byLevel: {} } };
-        }
-        // Add activity
-        report.activities.push(record);
-        report.stats.total++;
-        report.stats.byCategory[record.category] = (report.stats.byCategory[record.category] || 0) + 1;
-        report.stats.byLevel[record.level] = (report.stats.byLevel[record.level] || 0) + 1;
-        // Keep only last 1000 activities
-        if (report.activities.length > 1000) {
-            report.activities = report.activities.slice(-1000);
-        }
-        fs.writeFileSync(reportPath, JSON.stringify(report, null, 2));
-    }
-    catch (error) {
-        frameworkLogger.log("activity-logger", "write-report-failed", "error", { error, message: "Failed to write to activity report" });
-    }
-}
-// Convenience methods
-export const activity = {
-    framework: (action, message, details) => logActivity("framework", "info", action, message, details),
-    development: (action, message, details) => logActivity("development", "info", action, message, details),
-    script: (action, message, details) => logActivity("script", "info", action, message, details),
-    file: (action, message, details) => logActivity("file", "info", action, message, details),
-    test: (action, message, details) => logActivity("test", "info", action, message, details),
-    commit: (action, message, details) => logActivity("commit", "info", action, message, details),
-    session: (action, message, details) => logActivity("session", "info", action, message, details),
-    agent: (action, message, details) => logActivity("agent", "info", action, message, details),
-    processor: (action, message, details) => logActivity("processor", "info", action, message, details),
-    config: (action, message, details) => logActivity("config", "info", action, message, details),
-    success: (category, action, message, details) => logActivity(category, "success", action, message, details),
-    error: (category, action, message, details) => logActivity(category, "error", action, message, details),
-    warn: (category, action, message, details) => logActivity(category, "warn", action, message, details),
-};
-// Initialize on module load
-initialize();
-// Also listen for process events to log session end
-process.on("exit", () => {
-    logActivity("session", "info", "session-ended", "Activity logging session ended", {
-        duration: Date.now() - sessionStartTime,
-    });
-});

package/dist/core/adaptive-kernel.d.ts

@@ -1,108 +0,0 @@
-/**
- * Adaptive Kernel Extension for P9 - ADAPTIVE_PATTERN_LEARNING
- *
- * Composes with existing Kernel to add self-modifying pattern learning capabilities.
- * Enables continuous pattern improvement based on performance data.
- *
- * @since 2026-03-05
- */
-import { type KernelInferenceResult, type AdaptiveThresholds, type EmergentPattern, type PatternUpdate } from "../core/kernel-patterns.js";
-import { patternPerformanceTracker } from "../analytics/pattern-performance-tracker.js";
-import { emergingPatternDetector } from "../analytics/emerging-pattern-detector.js";
-import { patternLearningEngine } from "../analytics/pattern-learning-engine.js";
-export interface AdaptiveKernelConfig {
-    enabled: boolean;
-    enableP9Learning: boolean;
-    learningIntervalMs: number;
-    autoApplyThreshold: number;
-    confidenceThreshold: number;
-    maxPatternsPerAnalysis: number;
-}
-export interface P9AnalysisResult extends KernelInferenceResult {
-    patternDriftDetected: boolean;
-    driftAnalyses: Array<{
-        patternId: string;
-        driftMagnitude: number;
-        driftDirection: 'increasing' | 'decreasing' | 'unstable';
-        recommendedAction: string;
-    }>;
-    emergentPatterns: EmergentPattern[];
-    suggestedUpdates: PatternUpdate[];
-    adaptiveThresholds?: AdaptiveThresholds;
-    learningApplied: boolean;
-}
-export declare class AdaptiveKernelAnalyzer {
-    private adaptiveConfig;
-    private baseKernel;
-    private lastLearningRun;
-    private cachedP9Analysis;
-    private cacheValidMs;
-    constructor(config?: Partial<AdaptiveKernelConfig>);
-    /**
-     * Analyze observation using base kernel enhanced with P9 learning
-     */
-    analyze(observation: string): KernelInferenceResult;
-    /**
-     * Enhanced analyze with P9 learning capabilities
-     */
-    analyzeWithP9(observation: string): P9AnalysisResult;
-    /**
-     * Perform P9 adaptive pattern learning analysis
-     */
-    private performP9Analysis;
-    /**
-     * Get current adaptive thresholds
-     */
-    getAdaptiveThresholds(): AdaptiveThresholds;
-    /**
-     * Get pattern drift analyses
-     */
-    getPatternDrift(): Array<{
-        patternId: string;
-        driftMagnitude: number;
-        driftDirection: 'increasing' | 'decreasing' | 'unstable';
-        recommendedAction: string;
-    }>;
-    /**
-     * Manually trigger learning cycle
-     */
-    triggerLearning(outcomes: Array<{
-        taskId: string;
-        taskDescription: string;
-        routedAgent: string;
-        routedSkill: string;
-        confidence: number;
-        success: boolean;
-    }>, existingMappings: Array<{
-        keywords: string[];
-        skill: string;
-        agent: string;
-        confidence: number;
-    }>): {
-        newPatterns: number;
-        modifiedPatterns: number;
-        removedPatterns: number;
-        thresholdUpdates: number;
-        recommendations: string[];
-    };
-    /**
-     * Get learning statistics
-     */
-    getLearningStats(): {
-        lastLearningRun: Date;
-        cacheValid: boolean;
-        patternsTracked: number;
-        driftDetected: number;
-        thresholdsCalibrated: boolean;
-    };
-    /**
-     * Update configuration
-     */
-    updateConfig(newConfig: Partial<AdaptiveKernelConfig>): void;
-    /**
-     * Get current configuration
-     */
-    getConfig(): AdaptiveKernelConfig;
-}
-export declare function getAdaptiveKernel(config?: Partial<AdaptiveKernelConfig>): AdaptiveKernelAnalyzer;
-export { patternPerformanceTracker, emergingPatternDetector, patternLearningEngine };

package/dist/core/adaptive-kernel.js

@@ -1,191 +0,0 @@
-/**
- * Adaptive Kernel Extension for P9 - ADAPTIVE_PATTERN_LEARNING
- *
- * Composes with existing Kernel to add self-modifying pattern learning capabilities.
- * Enables continuous pattern improvement based on performance data.
- *
- * @since 2026-03-05
- */
-import { getKernel } from "../core/kernel-patterns.js";
-import { patternPerformanceTracker } from "../analytics/pattern-performance-tracker.js";
-import { emergingPatternDetector } from "../analytics/emerging-pattern-detector.js";
-import { patternLearningEngine } from "../analytics/pattern-learning-engine.js";
-import { frameworkLogger } from "../core/framework-logger.js";
-export class AdaptiveKernelAnalyzer {
-    adaptiveConfig;
-    baseKernel;
-    lastLearningRun = new Date();
-    cachedP9Analysis = null;
-    cacheValidMs = 60000; // 1 minute cache
-    constructor(config) {
-        this.baseKernel = getKernel();
-        this.adaptiveConfig = {
-            enabled: config?.enabled ?? true,
-            enableP9Learning: config?.enableP9Learning ?? true,
-            learningIntervalMs: config?.learningIntervalMs ?? 300000, // 5 minutes default
-            autoApplyThreshold: config?.autoApplyThreshold ?? 0.9,
-            confidenceThreshold: config?.confidenceThreshold ?? 0.75,
-            maxPatternsPerAnalysis: config?.maxPatternsPerAnalysis ?? 10,
-        };
-    }
-    /**
-     * Analyze observation using base kernel enhanced with P9 learning
-     */
-    analyze(observation) {
-        // Delegate to base kernel
-        return this.baseKernel.analyze(observation);
-    }
-    /**
-     * Enhanced analyze with P9 learning capabilities
-     */
-    analyzeWithP9(observation) {
-        // Get base analysis
-        const baseResult = this.baseKernel.analyze(observation);
-        if (!this.adaptiveConfig.enableP9Learning) {
-            return {
-                ...baseResult,
-                patternDriftDetected: false,
-                driftAnalyses: [],
-                emergentPatterns: [],
-                suggestedUpdates: [],
-                learningApplied: false
-            };
-        }
-        // Check cache validity
-        const now = new Date();
-        const cacheAge = now.getTime() - this.lastLearningRun.getTime();
-        if (this.cachedP9Analysis && cacheAge < this.cacheValidMs) {
-            return this.cachedP9Analysis;
-        }
-        // Run P9 analysis
-        const p9Result = this.performP9Analysis(baseResult, observation);
-        // Cache result
-        this.cachedP9Analysis = p9Result;
-        this.lastLearningRun = now;
-        return p9Result;
-    }
-    /**
-     * Perform P9 adaptive pattern learning analysis
-     */
-    performP9Analysis(baseResult, _observation) {
-        const p9Result = {
-            ...baseResult,
-            patternDriftDetected: false,
-            driftAnalyses: [],
-            emergentPatterns: [],
-            suggestedUpdates: [],
-            learningApplied: false
-        };
-        // 1. Check for pattern drift
-        const allDriftAnalyses = patternPerformanceTracker.getAllDriftAnalyses();
-        const significantDrift = allDriftAnalyses.filter((a) => a.drifted && a.driftDirection === 'decreasing');
-        if (significantDrift.length > 0) {
-            p9Result.patternDriftDetected = true;
-            p9Result.driftAnalyses = significantDrift.map((a) => ({
-                patternId: a.patternId,
-                driftMagnitude: a.driftMagnitude,
-                driftDirection: a.driftDirection,
-                recommendedAction: a.recommendedAction
-            }));
-        }
-        // 2. Get adaptive thresholds
-        p9Result.adaptiveThresholds = patternPerformanceTracker.calculateAdaptiveThresholds();
-        // 3. Perform learning if enough time has passed
-        const now = new Date();
-        const timeSinceLastLearning = now.getTime() - this.lastLearningRun.getTime();
-        if (timeSinceLastLearning >= this.adaptiveConfig.learningIntervalMs) {
-            const learningResult = patternLearningEngine.learnFromData([], // Will be populated from actual routing outcomes
-            [] // Will be populated from existing mappings
-            );
-            p9Result.suggestedUpdates = [
-                ...learningResult.modifiedPatterns,
-                ...learningResult.newPatterns,
-                ...learningResult.removedPatterns,
-                ...learningResult.thresholdUpdates
-            ];
-            // Auto-apply high-confidence updates
-            const autoApply = p9Result.suggestedUpdates.filter((u) => (u.confidence || 0) >= this.adaptiveConfig.autoApplyThreshold && u.validated);
-            if (autoApply.length > 0) {
-                p9Result.learningApplied = true;
-                frameworkLogger.log("adaptive-kernel", "auto-applied-updates", "info", { count: autoApply.length }, undefined);
-            }
-        }
-        return p9Result;
-    }
-    /**
-     * Get current adaptive thresholds
-     */
-    getAdaptiveThresholds() {
-        return patternPerformanceTracker.calculateAdaptiveThresholds();
-    }
-    /**
-     * Get pattern drift analyses
-     */
-    getPatternDrift() {
-        const analyses = patternPerformanceTracker.getAllDriftAnalyses();
-        return analyses
-            .filter((a) => a.drifted)
-            .map((a) => ({
-            patternId: a.patternId,
-            driftMagnitude: a.driftMagnitude,
-            driftDirection: a.driftDirection,
-            recommendedAction: a.recommendedAction
-        }));
-    }
-    /**
-     * Manually trigger learning cycle
-     */
-    triggerLearning(outcomes, existingMappings) {
-        const result = patternLearningEngine.learnFromData(outcomes, existingMappings);
-        this.lastLearningRun = new Date();
-        this.cachedP9Analysis = null; // Invalidate cache
-        return {
-            newPatterns: result.newPatterns.length,
-            modifiedPatterns: result.modifiedPatterns.length,
-            removedPatterns: result.removedPatterns.length,
-            thresholdUpdates: result.thresholdUpdates.length,
-            recommendations: result.recommendations
-        };
-    }
-    /**
-     * Get learning statistics
-     */
-    getLearningStats() {
-        const allMetrics = patternPerformanceTracker.getAllPatternMetrics();
-        const allDrift = patternPerformanceTracker.getAllDriftAnalyses();
-        return {
-            lastLearningRun: this.lastLearningRun,
-            cacheValid: (new Date().getTime() - this.lastLearningRun.getTime()) < this.cacheValidMs,
-            patternsTracked: allMetrics.length,
-            driftDetected: allDrift.filter((a) => a.drifted).length,
-            thresholdsCalibrated: true
-        };
-    }
-    /**
-     * Update configuration
-     */
-    updateConfig(newConfig) {
-        this.adaptiveConfig = {
-            ...this.adaptiveConfig,
-            ...newConfig
-        };
-        // Invalidate cache on config change
-        this.cachedP9Analysis = null;
-    }
-    /**
-     * Get current configuration
-     */
-    getConfig() {
-        return { ...this.adaptiveConfig };
-    }
-}
-// Singleton instance
-let adaptiveKernelInstance = null;
-export function getAdaptiveKernel(config) {
-    if (!adaptiveKernelInstance) {
-        adaptiveKernelInstance = new AdaptiveKernelAnalyzer(config);
-    }
-    return adaptiveKernelInstance;
-}
-// Re-export for convenience
-export { patternPerformanceTracker, emergingPatternDetector, patternLearningEngine };

package/dist/core/agent-spawn-gate.d.ts

@@ -1,56 +0,0 @@
-/**
- * Agent Spawn Gate — Singleton (provider-agnostic)
- *
- * CENTRALIZED CONTROL for all agent process spawning across 0xRay
- * (OpenCode, Hermes, or any other MCP-compatible host).
- *
- * Purpose:
- *   Prevent runaway recursive agent spawning.
- *
- * Design:
- *   - Singleton instance shared across all modules
- *   - Explicit enable/disable with state persistence
- *   - Tracks all active spawned processes for cleanup
- *   - Gates every spawn path: inference, orchestrator, scripts, tests
- *
- * Usage:
- *   import { spawnGate } from "./agent-spawn-gate.js";
- *
- *   // Before spawning
- *   spawnGate.assertAllowed("inference-cycle");
- *
- *   // Global disable (emergency brake)
- *   spawnGate.disable("emergency: runaway processes detected");
- */
-declare class AgentSpawnGate {
-    private static instance;
-    private state;
-    private constructor();
-    static getInstance(): AgentSpawnGate;
-    /** Check if spawning is globally allowed */
-    isAllowed(): boolean;
-    /** Enable spawning (opt-in, not default) */
-    enable(reason: string): void;
-    /** Disable spawning globally */
-    disable(reason: string): void;
-    /** Assert spawning is allowed or throw */
-    assertAllowed(module: string): void;
-    /** Register a spawned process PID for tracking */
-    trackProcess(pid: number, module: string, description: string): void;
-    /** Unregister a process when it exits */
-    untrackProcess(pid: number): void;
-    /** Kill all tracked processes (emergency cleanup) */
-    killAllProcesses(signal?: NodeJS.Signals): Promise<number>;
-    /** Get current gate status */
-    getStatus(): {
-        enabled: boolean;
-        reason: string | undefined;
-        disabledAt: number | undefined;
-        activeProcesses: number;
-        totalSpawned: number;
-        totalBlocked: number;
-    };
-}
-/** Singleton export — use this everywhere (provider-agnostic) */
-export declare const spawnGate: AgentSpawnGate;
-export default spawnGate;