0xray 4.0.13 → 4.0.14

package/dist/processors/implementations/log-protection-processor.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Log Protection Processor
+ *
+ * Prevents deletion of critical inference log files that are essential
+ * for the tuning engines and pattern learning system.
+ *
+ * Protected files:
+ * - routing-outcomes.json (routing analytics - NEVER delete)
+ * - activity.log (framework activity - NEVER delete)
+ * - xray-plugin-*.log (plugin logs)
+ *
+ * Archival flow is ALLOWED:
+ * - framework-activity-*.log.gz (archived/compressed logs)
+ * - Copy operations to create new archive files
+ *
+ * @module processors/implementations
+ */
+import { PreProcessor } from "../processor-interfaces.js";
+import { ProcessorContext } from "../processor-types.js";
+export declare class LogProtectionProcessor extends PreProcessor {
+    readonly name = "logProtection";
+    readonly priority = 10;
+    protected run(context: ProcessorContext): Promise<unknown>;
+    private isDeleteOperation;
+    private isArchiveCleanup;
+    private getActiveLogFile;
+    private getOperation;
+}
+export declare const logProtectionProcessor: LogProtectionProcessor;

package/dist/processors/implementations/log-protection-processor.js

@@ -0,0 +1,117 @@
+/**
+ * Log Protection Processor
+ *
+ * Prevents deletion of critical inference log files that are essential
+ * for the tuning engines and pattern learning system.
+ *
+ * Protected files:
+ * - routing-outcomes.json (routing analytics - NEVER delete)
+ * - activity.log (framework activity - NEVER delete)
+ * - xray-plugin-*.log (plugin logs)
+ *
+ * Archival flow is ALLOWED:
+ * - framework-activity-*.log.gz (archived/compressed logs)
+ * - Copy operations to create new archive files
+ *
+ * @module processors/implementations
+ */
+import { PreProcessor } from "../processor-interfaces.js";
+import { frameworkLogger } from "../../core/framework-logger.js";
+/**
+ * Files that are ACTIVE and MUST be protected (never delete)
+ */
+const ACTIVE_LOG_PATTERNS = [
+    /routing-outcomes\.json$/,
+    /activity\.log$/,
+    /activity\.log\.gz$/,
+];
+/**
+ * Archived log files that CAN be cleaned up (old rotations)
+ */
+const ARCHIVE_PATTERNS = [
+    /framework-activity-.+\.log\.gz$/,
+    /xray-plugin-.+\.log\.gz$/,
+];
+/**
+ * Directories/files that are protected
+ */
+const PROTECTED_PATH_PATTERNS = [
+    /\.opencode\/state\//,
+    /routing-outcomes\.json$/,
+];
+export class LogProtectionProcessor extends PreProcessor {
+    name = "logProtection";
+    priority = 10;
+    async run(context) {
+        const filePath = this.getFilePath(context);
+        const operation = this.getOperation(context);
+        if (!filePath) {
+            return { allowed: true, reason: "no file path specified" };
+        }
+        const normalizedPath = filePath.replace(/\\/g, "/");
+        const isDeleteOp = this.isDeleteOperation(operation);
+        if (!isDeleteOp) {
+            return { allowed: true, reason: "not a delete operation" };
+        }
+        // Check if this is an archive cleanup operation (allowed)
+        if (this.isArchiveCleanup(normalizedPath)) {
+            frameworkLogger.log("log-protection-processor", "archive-cleanup-allowed", "info", { filePath: normalizedPath, operation });
+            return { allowed: true, isArchiveCleanup: true };
+        }
+        // Check if trying to delete active log files
+        const activeFile = this.getActiveLogFile(normalizedPath);
+        if (activeFile) {
+            frameworkLogger.log("log-protection-processor", "deletion-blocked", "warning", {
+                filePath: normalizedPath,
+                operation,
+                reason: `Active log file '${activeFile}' - deletion prohibited`,
+            });
+            return {
+                allowed: false,
+                reason: `Deletion of active log file '${activeFile}' is prohibited. These files are essential for the inference engine and pattern learning system.`,
+                suggestion: "Use 'npx 0xray archive-logs' to safely archive and rotate logs.",
+                protectedFiles: [
+                    "routing-outcomes.json - routing analytics data (NEVER delete)",
+                    "activity.log - framework activity tracking (NEVER delete)",
+                ],
+            };
+        }
+        return { allowed: true };
+    }
+    isDeleteOperation(operation) {
+        if (!operation)
+            return false;
+        const deleteOps = ["delete", "remove", "rm", "unlink", "del", "erase", "clear"];
+        return deleteOps.some((op) => operation.toLowerCase().includes(op));
+    }
+    isArchiveCleanup(filePath) {
+        const fileName = filePath.split("/").pop() || "";
+        // Archived files (with timestamps) can be cleaned up
+        for (const pattern of ARCHIVE_PATTERNS) {
+            if (pattern.test(fileName) || pattern.test(filePath)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    getActiveLogFile(filePath) {
+        const fileName = filePath.split("/").pop() || "";
+        // Check for active log files
+        for (const pattern of ACTIVE_LOG_PATTERNS) {
+            if (pattern.test(fileName)) {
+                return fileName;
+            }
+        }
+        // Check protected paths
+        for (const pattern of PROTECTED_PATH_PATTERNS) {
+            if (pattern.test(filePath)) {
+                return filePath.split("/").pop() || filePath;
+            }
+        }
+        return null;
+    }
+    getOperation(context) {
+        return (context.operation || context.toolInput?.args?.operation);
+    }
+}
+export const logProtectionProcessor = new LogProtectionProcessor();

package/dist/processors/implementations/nudge-processor.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Nudge Processor - Integrates Nudge Watchdog with processor system
+ *
+ * Post-processor that monitors agent actions and triggers nudges
+ * when stuck patterns are detected.
+ *
+ * @module processors/implementations
+ */
+import { PostProcessor } from "../processor-interfaces.js";
+import { ProcessorContext, ProcessorResult } from "../processor-types.js";
+export declare class NudgeProcessor extends PostProcessor {
+    readonly name = "nudge";
+    readonly priority = 100;
+    private nudgeEnabled;
+    constructor();
+    private loadConfig;
+    protected run(context: ProcessorContext): Promise<unknown>;
+    private detectMostUrgentNudge;
+}
+export declare const nudgeProcessor: NudgeProcessor;
+export declare function executeNudgeProcessor(context: ProcessorContext): Promise<ProcessorResult>;

package/dist/processors/implementations/nudge-processor.js

@@ -0,0 +1,129 @@
+/**
+ * Nudge Processor - Integrates Nudge Watchdog with processor system
+ *
+ * Post-processor that monitors agent actions and triggers nudges
+ * when stuck patterns are detected.
+ *
+ * @module processors/implementations
+ */
+import { PostProcessor } from "../processor-interfaces.js";
+import { frameworkLogger } from "../../core/framework-logger.js";
+import { nudgeWatchdog, recordThinkTag, recordCodeChange, recordToolCall, recordFixAttempt, recordExplanation, getNudgeSuggestion, } from "../../monitoring/nudge-watchdog.js";
+import { featuresConfigLoader } from "../../core/features-config.js";
+export class NudgeProcessor extends PostProcessor {
+    name = "nudge";
+    priority = 100;
+    nudgeEnabled = true;
+    constructor() {
+        super();
+        this.loadConfig();
+    }
+    loadConfig() {
+        try {
+            const features = featuresConfigLoader.loadConfig();
+            const nudgeConfig = features?.nudge_watchdog;
+            if (nudgeConfig) {
+                this.nudgeEnabled = nudgeConfig.enabled !== false;
+            }
+        }
+        catch {
+            // Use defaults
+        }
+    }
+    async run(context) {
+        if (!this.nudgeEnabled) {
+            return { success: true, reason: "nudge processor disabled" };
+        }
+        const tool = context.tool;
+        const filePath = context.filePath;
+        const content = context.content;
+        const toolInput = context.toolInput;
+        if (toolInput?.tool) {
+            recordToolCall(toolInput.tool, JSON.stringify(toolInput.args || {}));
+        }
+        if (tool === "edit" || tool === "write") {
+            recordCodeChange();
+        }
+        if (tool === "read" || tool === "Glob") {
+            const args = toolInput?.args;
+            if (args?.operation === "read-multiple" || args?.filePath) {
+                recordFixAttempt(args.filePath, "repeated-read");
+            }
+        }
+        if (content) {
+            const hasThinkingTags = /<thinking>[\s\S]*?<\/thinking>/gi.test(content);
+            if (hasThinkingTags) {
+                const thinkingMatches = content.match(/<thinking>[\s\S]*?<\/thinking>/gi);
+                if (thinkingMatches) {
+                    for (let i = 0; i < thinkingMatches.length; i++) {
+                        recordThinkTag();
+                    }
+                }
+            }
+            const explanationPatterns = [
+                /(?:let me| i think| essentially| in other words| what i mean is)/gi,
+                /^\s*(Here's the|An|a) \w+:/gim,
+            ];
+            for (const pattern of explanationPatterns) {
+                const matches = content.match(pattern);
+                if (matches && matches.length > 2) {
+                    recordExplanation();
+                }
+            }
+        }
+        const stats = nudgeWatchdog.getStats();
+        if (stats.activePatterns > 0) {
+            const nudge = this.detectMostUrgentNudge(stats);
+            if (nudge) {
+                const suggestion = getNudgeSuggestion(nudge, { filePath });
+                frameworkLogger.log("nudge-processor", "stuck-pattern-detected", "warning", {
+                    pattern: nudge,
+                    stats,
+                    suggestion,
+                });
+                return {
+                    success: true,
+                    nudgeDetected: true,
+                    pattern: nudge,
+                    suggestion,
+                    stats,
+                };
+            }
+        }
+        return {
+            success: true,
+            nudgeDetected: false,
+            stats,
+        };
+    }
+    detectMostUrgentNudge(stats) {
+        const thresholds = {
+            "think-loop": stats.thinkTags,
+            "syntax-loop": stats.thinkTags,
+            "death-spiral": stats.explanations,
+            "tool-loop": stats.activePatterns,
+            "repair-failure": stats.activePatterns,
+        };
+        let maxType = null;
+        let maxCount = 0;
+        const priorities = [
+            "repair-failure",
+            "syntax-loop",
+            "think-loop",
+            "tool-loop",
+            "death-spiral",
+        ];
+        for (const type of priorities) {
+            const count = thresholds[type] || 0;
+            if (count > maxCount) {
+                maxCount = count;
+                maxType = type;
+            }
+        }
+        return maxType;
+    }
+}
+export const nudgeProcessor = new NudgeProcessor();
+export async function executeNudgeProcessor(context) {
+    return nudgeProcessor.execute(context);
+}

package/dist/processors/implementations/performance-budget-processor.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Performance Budget Processor
+ *
+ * Enforces codex term #28: Performance Budgets.
+ * Checks code content against configurable size, function-length, nesting-depth,
+ * and parameter-count budgets. Returns structured violation lists.
+ *
+ * @since 2026-03-28
+ */
+import type { PreValidateContext, ProcessorExecutionResult } from "../processor-types.js";
+export type PerformanceViolationType = "fileTooLarge" | "functionTooLong" | "nestingTooDeep" | "tooManyParameters";
+export interface PerformanceViolation {
+    type: PerformanceViolationType;
+    filePath: string;
+    line?: number;
+    message: string;
+    actual: number;
+    limit: number;
+}
+export interface PerformanceBudgetConfig {
+    maxFileSizeBytes: number;
+    maxFunctionLines: number;
+    maxNestingDepth: number;
+    maxParameters: number;
+}
+export declare const DEFAULT_PERFORMANCE_BUDGET: PerformanceBudgetConfig;
+export declare class PerformanceBudgetProcessor {
+    private readonly config;
+    constructor(config?: Partial<PerformanceBudgetConfig>);
+    /**
+     * Check a file against all budget rules.
+     */
+    checkFile(filePath: string, content: string): PerformanceViolation[];
+    /**
+     * Analyse every function body in `content` and check complexity budgets.
+     */
+    checkFunctionComplexity(content: string): PerformanceViolation[];
+    /**
+     * Regex-based extraction of named functions / methods / arrow functions.
+     * Does NOT require a full AST – keeps the processor zero-dependency.
+     */
+    private extractFunctions;
+    /**
+     * Measure the maximum nesting depth by tracking control-flow keywords
+     * (if / for / while / switch / try) inside the function body.
+     */
+    private measureMaxNesting;
+}
+export declare function runPerformanceBudgetCheck(context: PreValidateContext): Promise<ProcessorExecutionResult>;

package/dist/processors/implementations/performance-budget-processor.js

@@ -0,0 +1,216 @@
+/**
+ * Performance Budget Processor
+ *
+ * Enforces codex term #28: Performance Budgets.
+ * Checks code content against configurable size, function-length, nesting-depth,
+ * and parameter-count budgets. Returns structured violation lists.
+ *
+ * @since 2026-03-28
+ */
+import { frameworkLogger } from "../../core/framework-logger.js";
+// ---------------------------------------------------------------------------
+// Defaults
+// ---------------------------------------------------------------------------
+export const DEFAULT_PERFORMANCE_BUDGET = {
+    maxFileSizeBytes: 10 * 1024, // 10 KB
+    maxFunctionLines: 50,
+    maxNestingDepth: 5,
+    maxParameters: 5,
+};
+// ---------------------------------------------------------------------------
+// Processor
+// ---------------------------------------------------------------------------
+export class PerformanceBudgetProcessor {
+    config;
+    constructor(config) {
+        this.config = { ...DEFAULT_PERFORMANCE_BUDGET, ...config };
+    }
+    /**
+     * Check a file against all budget rules.
+     */
+    checkFile(filePath, content) {
+        const violations = [];
+        // --- file size ---
+        const byteSize = Buffer.byteLength(content, "utf-8");
+        if (byteSize > this.config.maxFileSizeBytes) {
+            violations.push({
+                type: "fileTooLarge",
+                filePath,
+                message: `File size ${byteSize} bytes exceeds budget of ${this.config.maxFileSizeBytes} bytes`,
+                actual: byteSize,
+                limit: this.config.maxFileSizeBytes,
+            });
+        }
+        // --- function-level checks ---
+        const funcViolations = this.checkFunctionComplexity(content);
+        for (const v of funcViolations) {
+            violations.push({ ...v, filePath });
+        }
+        return violations;
+    }
+    /**
+     * Analyse every function body in `content` and check complexity budgets.
+     */
+    checkFunctionComplexity(content) {
+        const violations = [];
+        const functions = this.extractFunctions(content);
+        for (const fn of functions) {
+            // function length
+            if (fn.bodyLineCount > this.config.maxFunctionLines) {
+                violations.push({
+                    type: "functionTooLong",
+                    filePath: "",
+                    line: fn.startLine,
+                    message: `Function "${fn.name}" has ${fn.bodyLineCount} lines (max ${this.config.maxFunctionLines})`,
+                    actual: fn.bodyLineCount,
+                    limit: this.config.maxFunctionLines,
+                });
+            }
+            // nesting depth
+            const depth = this.measureMaxNesting(fn.body);
+            if (depth > this.config.maxNestingDepth) {
+                violations.push({
+                    type: "nestingTooDeep",
+                    filePath: "",
+                    line: fn.startLine,
+                    message: `Function "${fn.name}" has nesting depth ${depth} (max ${this.config.maxNestingDepth})`,
+                    actual: depth,
+                    limit: this.config.maxNestingDepth,
+                });
+            }
+            // parameter count
+            if (fn.paramCount > this.config.maxParameters) {
+                violations.push({
+                    type: "tooManyParameters",
+                    filePath: "",
+                    line: fn.startLine,
+                    message: `Function "${fn.name}" has ${fn.paramCount} parameters (max ${this.config.maxParameters})`,
+                    actual: fn.paramCount,
+                    limit: this.config.maxParameters,
+                });
+            }
+        }
+        return violations;
+    }
+    // -----------------------------------------------------------------------
+    // Internal helpers
+    // -----------------------------------------------------------------------
+    /**
+     * Regex-based extraction of named functions / methods / arrow functions.
+     * Does NOT require a full AST – keeps the processor zero-dependency.
+     */
+    extractFunctions(content) {
+        const results = [];
+        const lines = content.split("\n");
+        // Alternative 1: function name(params) {  →  groups: [name, params]
+        // Alternative 2: const/let/var name = ... =>  →  groups: [name, empty]
+        // Alternative 3: methodName(params) {  →  groups: [name, params]
+        const funcRegex = /(?:(?:export\s+)?(?:async\s+)?function\s+(\w+)\s*\(([^)]*)\)|(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s+)?(?:\([^)]*\)|[^=])\s*=>|(?:async\s+)?(\w+)\s*\(([^)]*)\)\s*\{)/g;
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            if (!line)
+                continue;
+            // Skip comments
+            if (line.trimStart().startsWith("//") || line.trimStart().startsWith("*")) {
+                continue;
+            }
+            funcRegex.lastIndex = 0;
+            const match = funcRegex.exec(line);
+            if (!match)
+                continue;
+            const name = match[1] ?? match[3] ?? match[5] ?? "anonymous";
+            const params = match[2] ?? match[6];
+            const paramCount = params
+                ? params.split(",").filter((p) => p.trim().length > 0).length
+                : 0;
+            // Collect body lines until brace depth returns to 0
+            let depth = 0;
+            let started = false;
+            const bodyLines = [];
+            for (let j = i; j < lines.length; j++) {
+                const l = lines[j];
+                if (!l)
+                    continue;
+                for (const ch of l) {
+                    if (ch === "{") {
+                        depth++;
+                        started = true;
+                    }
+                    else if (ch === "}") {
+                        depth--;
+                    }
+                }
+                bodyLines.push(l);
+                if (started && depth <= 0)
+                    break;
+            }
+            const body = bodyLines.join("\n");
+            results.push({
+                name,
+                startLine: i + 1,
+                body,
+                bodyLineCount: bodyLines.length,
+                paramCount,
+            });
+        }
+        return results;
+    }
+    /**
+     * Measure the maximum nesting depth by tracking control-flow keywords
+     * (if / for / while / switch / try) inside the function body.
+     */
+    measureMaxNesting(body) {
+        let maxDepth = 0;
+        let currentDepth = 0;
+        const lines = body.split("\n");
+        for (const line of lines) {
+            const trimmed = line.trim();
+            // Count opening structures that increase nesting
+            const openingMatches = trimmed.match(/\b(if|for|while|switch|try|catch|else)\b/g);
+            if (openingMatches) {
+                // 'else' and 'catch' partially close+reopen, so net +0 for those
+                const netOpen = openingMatches.length -
+                    (trimmed.includes("else") ? 1 : 0) -
+                    (trimmed.includes("catch") ? 1 : 0);
+                currentDepth += Math.max(0, netOpen);
+                maxDepth = Math.max(maxDepth, currentDepth);
+            }
+            // Simple heuristic: decrease depth when line closes braces
+            const closeBraces = (trimmed.match(/}/g) || []).length;
+            currentDepth = Math.max(0, currentDepth - closeBraces);
+        }
+        return maxDepth;
+    }
+}
+// ---------------------------------------------------------------------------
+// Standalone runner for processor-manager integration
+// ---------------------------------------------------------------------------
+export async function runPerformanceBudgetCheck(context) {
+    const start = performance.now();
+    try {
+        const content = context.data ?? "";
+        const filePath = context.filesChanged?.[0] ?? "unknown";
+        const config = context.config ?? {};
+        const processor = new PerformanceBudgetProcessor(config);
+        const violations = processor.checkFile(filePath, content);
+        const hasViolations = violations.length > 0;
+        if (hasViolations) {
+            frameworkLogger.log("performance-budget-processor", "violations_found", "warning", { filePath, violations });
+        }
+        return {
+            success: !hasViolations,
+            processorName: "performance-budget-processor",
+            duration: performance.now() - start,
+            result: { violations },
+        };
+    }
+    catch (error) {
+        frameworkLogger.log("performance-budget-processor", "check_failed", "error", { error: error.message });
+        return {
+            success: false,
+            processorName: "performance-budget-processor",
+            duration: performance.now() - start,
+            error: error.message,
+        };
+    }
+}

package/dist/processors/implementations/postprocessor-chain-validator.d.ts

@@ -0,0 +1,45 @@
+/**
+ * PostProcessor Chain Validator
+ *
+ * Validates postprocessor execution chain integrity.
+ * Checks that all registered postprocessors executed without errors,
+ * validates priority ordering, and detects skipped or crashed processors.
+ *
+ * @since 2026-03-28
+ */
+import type { PostValidateContext, ProcessorExecutionResult } from "../processor-types.js";
+export interface ChainValidationResult {
+    valid: boolean;
+    issues: ChainIssue[];
+}
+export interface ChainIssue {
+    severity: "error" | "warning";
+    processorName: string;
+    message: string;
+}
+export interface ChainReport {
+    totalProcessors: number;
+    successful: number;
+    failed: number;
+    skipped: number;
+    issues: ChainIssue[];
+    averageDuration: number;
+    executedInPriorityOrder: boolean;
+}
+export declare class PostProcessorChainValidator {
+    private chainReport;
+    /**
+     * Validate the postprocessor execution chain.
+     */
+    validateChain(results: Array<{
+        name: string;
+        success: boolean;
+        duration: number;
+        priority?: number;
+    }>): ChainValidationResult;
+    /**
+     * Get the chain report from the most recent validation.
+     */
+    getChainReport(): ChainReport;
+}
+export declare function runPostProcessorChainValidation(context: PostValidateContext): Promise<ProcessorExecutionResult>;