0xray 4.0.12 → 4.0.13

package/dist/core/framework-logger.js

@@ -1,275 +0,0 @@
-import { isLoggingEnabled, shouldLog, } from "./logging-config.js";
-import { promises as fs, existsSync, mkdirSync } from "fs";
-import { join } from "path";
-/**
- * Generate a unique job ID for tracking work sessions
- */
-export function generateJobId(prefix = "job") {
-    const timestamp = Date.now();
-    const random = Math.random().toString(36).substring(2, 8);
-    return `${prefix}-${timestamp}-${random}`;
-}
-// Global job context for correlation across all framework operations
-let currentJobContext = null;
-let currentTraceId = null;
-let currentSpanId = null;
-let currentParentSpanId = null;
-export function generateTraceId() {
-    return `trace-${Date.now()}-${Math.random().toString(36).substring(2, 10)}`;
-}
-export function generateSpanId() {
-    return `span-${Math.random().toString(36).substring(2, 10)}`;
-}
-export function setTraceContext(traceId, parentSpanId) {
-    currentTraceId = traceId;
-    currentSpanId = generateSpanId();
-    currentParentSpanId = parentSpanId ?? null;
-    return currentSpanId;
-}
-export function getTraceContext() {
-    return { traceId: currentTraceId, spanId: currentSpanId, parentSpanId: currentParentSpanId };
-}
-export function clearTraceContext() {
-    currentTraceId = null;
-    currentSpanId = null;
-    currentParentSpanId = null;
-}
-export function withTraceContext(traceId, operation, parentSpanId) {
-    const prevTrace = currentTraceId;
-    const prevSpan = currentSpanId;
-    const prevParent = currentParentSpanId;
-    const spanId = setTraceContext(traceId, parentSpanId);
-    try {
-        const result = operation(spanId);
-        if (result instanceof Promise) {
-            return result.finally(() => {
-                currentTraceId = prevTrace;
-                currentSpanId = prevSpan;
-                currentParentSpanId = prevParent;
-            });
-        }
-        currentTraceId = prevTrace;
-        currentSpanId = prevSpan;
-        currentParentSpanId = prevParent;
-        return Promise.resolve(result);
-    }
-    catch (err) {
-        currentTraceId = prevTrace;
-        currentSpanId = prevSpan;
-        currentParentSpanId = prevParent;
-        throw err;
-    }
-}
-export function getCurrentJobId() {
-    return currentJobContext?.jobId || null;
-}
-export function setCurrentJobContext(jobId) {
-    currentJobContext = new JobContext(jobId);
-    return currentJobContext;
-}
-export function withJobContext(operation, jobId) {
-    const originalContext = currentJobContext;
-    const jobContext = setCurrentJobContext(jobId);
-    try {
-        const result = operation();
-        if (result instanceof Promise) {
-            return result.finally(async () => {
-                // Auto-complete job on operation finish
-                await jobContext.complete(true).catch(() => { });
-                // Restore original context
-                currentJobContext = originalContext;
-            });
-        }
-        else {
-            // Sync operation - complete immediately
-            jobContext.complete(true).catch(() => { });
-            currentJobContext = originalContext;
-            return Promise.resolve(result);
-        }
-    }
-    catch (error) {
-        // Error occurred - complete job with failure
-        jobContext.complete(false, { error: String(error) }).catch(() => { });
-        currentJobContext = originalContext;
-        throw error;
-    }
-}
-export class JobContext {
-    jobId;
-    startTime;
-    complexityScore;
-    agentUsed;
-    operationType;
-    // NEW: Outcome tracking for pattern analysis
-    outcome;
-    // NEW: Predicted duration for accuracy comparison (in ms)
-    predictedDuration;
-    constructor(jobId) {
-        this.jobId = jobId || generateJobId("auto");
-        this.startTime = Date.now();
-    }
-    /**
-     * Set the outcome after task completion
-     */
-    setOutcome(success, escalated = false, autoFixed = false) {
-        if (escalated)
-            this.outcome = "escalated";
-        else if (autoFixed)
-            this.outcome = "auto-fixed";
-        else
-            this.outcome = success ? "success" : "fail";
-    }
-    /**
-     * Set predicted duration for complexity accuracy comparison
-     */
-    setPredictedDuration(completionTimeMs) {
-        this.predictedDuration = completionTimeMs;
-    }
-    /**
-     * Log job completion with diagnostic info
-     * Enhanced with outcome and complexity accuracy tracking
-     */
-    async complete(success = true, details) {
-        const actualDuration = Date.now() - this.startTime;
-        // Calculate complexity accuracy if we have both predicted and actual
-        let complexityAccuracy;
-        if (this.complexityScore && this.predictedDuration) {
-            const ratio = actualDuration / this.predictedDuration;
-            if (ratio > 1.5) {
-                complexityAccuracy = "underestimated";
-            }
-            else if (ratio < 0.5) {
-                complexityAccuracy = "overestimated";
-            }
-            else {
-                complexityAccuracy = "accurate";
-            }
-        }
-        else if (this.complexityScore && actualDuration) {
-            // Fallback: estimate predicted based on complexity score
-            const estimatedPredicted = this.complexityScore * 1000; // 1 second per complexity point
-            const ratio = actualDuration / estimatedPredicted;
-            if (ratio > 1.5) {
-                complexityAccuracy = "underestimated";
-            }
-            else if (ratio < 0.5) {
-                complexityAccuracy = "overestimated";
-            }
-            else {
-                complexityAccuracy = "accurate";
-            }
-        }
-        // Determine final outcome
-        const finalOutcome = this.outcome || (success ? "success" : "fail");
-        await frameworkLogger.log("job-context", "job-completed", success ? "success" : "error", {
-            duration: actualDuration,
-            complexityScore: this.complexityScore,
-            agentUsed: this.agentUsed,
-            operationType: this.operationType,
-            outcome: finalOutcome,
-            complexityAccuracy,
-            predictedDuration: this.predictedDuration,
-            ...details,
-        }, undefined, // sessionId
-        this.jobId);
-    }
-}
-export class FrameworkUsageLogger {
-    logs = [];
-    maxLogs = 1000;
-    buffer = [];
-    flushTimer;
-    flushing = false;
-    FLUSH_INTERVAL_MS = 5000;
-    MAX_BUFFER_SIZE = 100;
-    async log(component, action, status, details, sessionId, jobId) {
-        if (!isLoggingEnabled()) {
-            return;
-        }
-        if (!shouldLog(status)) {
-            return;
-        }
-        const actualJobId = jobId || getCurrentJobId() || generateJobId("auto");
-        if (!actualJobId) {
-            throw new Error("JobId generation failed");
-        }
-        const entry = {
-            timestamp: Date.now(),
-            component,
-            action,
-            status,
-            agent: "orchestrator",
-            ...(sessionId && { sessionId }),
-            jobId: actualJobId,
-            ...(currentTraceId && { traceId: currentTraceId }),
-            ...(currentSpanId && { spanId: currentSpanId }),
-            ...(currentParentSpanId && { parentSpanId: currentParentSpanId }),
-            details,
-        };
-        this.logs.push(entry);
-        if (this.logs.length > this.maxLogs) {
-            this.logs.shift();
-        }
-        this.bufferEntry(entry);
-    }
-    bufferEntry(entry) {
-        const jobIdPart = entry.jobId ? `[${entry.jobId}] ` : "";
-        const tracePart = entry.traceId ? `[${entry.traceId}.${entry.spanId}] ` : "";
-        const detailsPart = entry.details
-            ? ` | ${(() => { try {
-                return JSON.stringify(entry.details);
-            }
-            catch {
-                return String(entry.details);
-            } })()}`
-            : "";
-        const line = `${new Date(entry.timestamp).toISOString()} ${jobIdPart}${tracePart}[${entry.component}] ${entry.action} - ${entry.status.toUpperCase()}${detailsPart}\n`;
-        this.buffer.push(line);
-        if (this.buffer.length >= this.MAX_BUFFER_SIZE) {
-            this.flushBuffer();
-            return;
-        }
-        if (!this.flushTimer) {
-            this.flushTimer = setTimeout(() => {
-                this.flushTimer = undefined;
-                this.flushBuffer();
-            }, this.FLUSH_INTERVAL_MS);
-            if (this.flushTimer && typeof this.flushTimer === "object" && "unref" in this.flushTimer) {
-                this.flushTimer.unref();
-            }
-        }
-    }
-    async flushBuffer() {
-        if (this.flushing || this.buffer.length === 0)
-            return;
-        this.flushing = true;
-        const toWrite = this.buffer.splice(0, this.buffer.length);
-        const data = toWrite.join("");
-        try {
-            const cwd = process.cwd();
-            if (!cwd)
-                return;
-            const logDir = join(cwd, "logs", "framework");
-            const logFile = join(logDir, "activity.log");
-            if (!existsSync(logDir)) {
-                mkdirSync(logDir, { recursive: true });
-            }
-            await fs.appendFile(logFile, data).catch(() => { });
-            this.flushing = false;
-        }
-        catch {
-            this.flushing = false;
-        }
-    }
-    getRecentLogs(count = 50) {
-        return this.logs.slice(-count);
-    }
-    getComponentUsage(component) {
-        return this.logs.filter((log) => log.component === component);
-    }
-    // TODO: Implement or remove — currently a no-op placeholder
-    printRundown() {
-        // Framework usage analytics placeholder
-    }
-}
-export const frameworkLogger = new FrameworkUsageLogger();

package/dist/core/index.d.ts

@@ -1,5 +0,0 @@
-export { KernelOrchestrator } from "./orchestrator.js";
-export { defaultXrayConfig } from "./xray-activation.js";
-export { getConfigDir, resolveConfigPath, resolveStateDir, resolveProfilesDir, resolveCodexPath, resolveLogDir, resetConfigDirCache, XRAY_CONFIG_DIR_ENV, } from "./config-paths.js";
-export { formatCodexPrompt, formatMinimalCodexPrompt, getCodexConfig, findCodexPath, loadCodex, BUILTIN_CODEX, } from "./codex-formatter.js";
-export type { CodexTerm, CodexConfig, FormatOptions, FormatResult, } from "./codex-formatter.js";

package/dist/core/index.js

@@ -1,6 +0,0 @@
-export { KernelOrchestrator } from "./orchestrator.js";
-export { defaultXrayConfig } from "./xray-activation.js";
-// Decoupled config path resolution (Layer 1)
-export { getConfigDir, resolveConfigPath, resolveStateDir, resolveProfilesDir, resolveCodexPath, resolveLogDir, resetConfigDirCache, XRAY_CONFIG_DIR_ENV, } from "./config-paths.js";
-// Standalone codex formatter (Layer 2)
-export { formatCodexPrompt, formatMinimalCodexPrompt, getCodexConfig, findCodexPath, loadCodex, BUILTIN_CODEX, } from "./codex-formatter.js";

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

@@ -1,129 +0,0 @@
-/**
- * 0xRay Kernel Pattern Definitions
- *
- * Pattern definitions from v1.1.0 → v2.0 kernel update
- * Includes 35+ patterns from 80+ reflections
- *
- */
-export interface KernelPattern {
-    id: string;
-    trigger: string[];
-    action: string;
-    confidence: number;
-    level: 'L1' | 'L2' | 'L3' | 'L4' | 'L5';
-    category: 'FATAL' | 'CASCADE' | 'PREVENTION' | 'DECISION';
-}
-export interface FatalAssumption {
-    id: string;
-    trigger: string[];
-    action: string;
-    reason: string;
-    level: number;
-}
-export interface BugCascade {
-    id: string;
-    pattern: string;
-    detection: string;
-    fix: string;
-    priority: number;
-}
-export interface KernelInferenceResult {
-    pattern?: KernelPattern;
-    actionRequired?: string;
-    confidence: number;
-    fatalAssumptions?: FatalAssumption[];
-    cascadePatterns?: BugCascade[];
-    level?: 'L1' | 'L2' | 'L3' | 'L4' | 'L5';
-    recommendations?: string[];
-}
-export interface KernelConfig {
-    enabled: boolean;
-    confidenceThreshold: number;
-    maxPatternsPerAnalysis: number;
-    enableLearning: boolean;
-    autoPrevention: boolean;
-}
-export interface EmergentPattern {
-    id: string;
-    pattern: string;
-    trigger: string[];
-    action: string;
-    confidence: number;
-    category: 'FATAL' | 'CASCADE' | 'PREVENTION' | 'DECISION';
-    frequency: number;
-    lastDetected: Date;
-    effectiveness: number;
-    firstSeen?: Date;
-    lastSeen?: Date;
-    suggestedAction?: string;
-    userRequest?: string;
-    generatedPrompt?: string;
-    templatePrompt?: string;
-    evidence?: Record<string, unknown>[] | undefined;
-    stringEvidence?: string[] | undefined;
-}
-export interface PatternUpdate {
-    patternId: string;
-    type: 'CONFIDENCE' | 'FREQUENCY' | 'TRIGGER' | 'ACTION';
-    oldValue: number | string | string[];
-    newValue: number | string | string[];
-    timestamp: Date;
-    reason: string;
-    updateType?: string;
-    confidence?: number;
-    validated?: boolean;
-    changes?: Record<string, unknown>[];
-}
-export interface PatternDriftInfo {
-    patternId: string;
-    driftDetected: boolean;
-    severity: 'low' | 'medium' | 'high';
-    metrics: {
-        confidenceDrift: number;
-        frequencyChange: number;
-        effectivenessDecline: number;
-    };
-}
-export interface AdaptiveThresholds {
-    confidenceMin: number;
-    confidenceMax: number;
-    frequencyMin: number;
-    frequencyMax: number;
-    effectivenessMin: number;
-    effectivenessMax: number;
-    learningRate: number;
-    adaptationWindow: number;
-    perAgent?: Record<string, {
-        confidenceMin: number;
-        confidenceMax: number;
-        frequencyMin: number;
-        frequencyMax: number;
-        effectivenessMin: number;
-        effectivenessMax: number;
-    }>;
-    overall?: {
-        confidenceMin: number;
-        confidenceMax: number;
-        frequencyMin: number;
-        frequencyMax: number;
-    };
-}
-export declare class KernelAnalyzer {
-    private config;
-    private patterns;
-    private assumptions;
-    private cascades;
-    constructor(config?: Partial<KernelConfig>);
-    private initializePatterns;
-    analyze(observation: string): KernelInferenceResult;
-    process(task: string): KernelInferenceResult;
-    learn(outcome: {
-        success: boolean;
-        patternUsed: string;
-        feedback?: string;
-    }): void;
-    getConfig(): KernelConfig;
-    updateConfig(updates: Partial<KernelConfig>): void;
-}
-export declare function getKernel(): KernelAnalyzer;
-export declare function resetKernel(): void;