0xray 2.0.0

package/dist/core/framework-logger.js

@@ -0,0 +1,275 @@
+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.js

@@ -0,0 +1,6 @@
+export { KernelOrchestrator } from "./orchestrator.js";
+export { defaultStringRayConfig } from "./xray-activation.js"; // consumer runtime compat from prior StringRay releases (1-line min per Scope Rule)
+// Decoupled config path resolution (Layer 1)
+export { getConfigDir, resolveConfigPath, resolveStateDir, resolveProfilesDir, resolveCodexPath, resolveLogDir, resetConfigDirCache, STRRAY_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.js

@@ -0,0 +1,302 @@
+/**
+ * 0xRay Kernel Pattern Definitions
+ *
+ * Pattern definitions from v1.1.0 → v2.0 kernel update
+ * Includes 35+ patterns from 80+ reflections
+ *
+ * @version 2.0.0-SECURITY-ENHANCED
+ */
+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.js

@@ -0,0 +1,43 @@
+// Default logging configuration
+const defaultLoggingConfig = {
+    enabled: process.env.STRRAY_LOGGING_ENABLED !== "false", // Default true, can be disabled
+    level: process.env.STRRAY_LOG_LEVEL || "info",
+    destinations: ["console", "file"],
+    performanceMode: process.env.STRRAY_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.STRRAY_LOGGING_ENABLED === "false") {
+    setLoggingConfig({ enabled: false });
+}
+if (process.env.STRRAY_LOG_LEVEL) {
+    setLoggingConfig({ level: process.env.STRRAY_LOG_LEVEL });
+}
+if (process.env.STRRAY_PERFORMANCE_MODE === "true") {
+    setLoggingConfig({ performanceMode: true });
+}