0xray 4.0.11 → 4.0.13

package/dist/processors/implementations/postprocessor-chain-validator.js

@@ -1,148 +0,0 @@
-/**
- * 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 { frameworkLogger } from "../../core/framework-logger.js";
-// ---------------------------------------------------------------------------
-// Processor
-// ---------------------------------------------------------------------------
-export class PostProcessorChainValidator {
-    chainReport = null;
-    /**
-     * Validate the postprocessor execution chain.
-     */
-    validateChain(results) {
-        const issues = [];
-        if (results.length === 0) {
-            const emptyReport = {
-                totalProcessors: 0,
-                successful: 0,
-                failed: 0,
-                skipped: 0,
-                issues: [],
-                averageDuration: 0,
-                executedInPriorityOrder: true,
-            };
-            this.chainReport = emptyReport;
-            return { valid: true, issues: [] };
-        }
-        // Check for failed processors
-        for (const result of results) {
-            if (!result.success) {
-                issues.push({
-                    severity: "error",
-                    processorName: result.name,
-                    message: `Processor "${result.name}" failed during execution`,
-                });
-            }
-        }
-        // Validate priority ordering if priorities are provided
-        const withPriority = results.filter((r) => r.priority !== undefined);
-        if (withPriority.length > 1) {
-            for (let i = 1; i < withPriority.length; i++) {
-                const prev = withPriority[i - 1];
-                const curr = withPriority[i];
-                if (!prev || !curr)
-                    continue;
-                if (prev.priority !== undefined &&
-                    curr.priority !== undefined &&
-                    prev.priority > curr.priority) {
-                    issues.push({
-                        severity: "warning",
-                        processorName: curr.name,
-                        message: `Processor "${curr.name}" (priority ${curr.priority}) ran after "${prev.name}" (priority ${prev.priority}) — expected ascending priority order`,
-                    });
-                }
-            }
-        }
-        // Detect processors with zero or negative duration (potential skips)
-        for (const result of results) {
-            if (result.success && result.duration <= 0) {
-                issues.push({
-                    severity: "warning",
-                    processorName: result.name,
-                    message: `Processor "${result.name}" reports zero/negative duration (${result.duration}ms) — may have been skipped`,
-                });
-            }
-        }
-        // Build chain report
-        const successful = results.filter((r) => r.success).length;
-        const failed = results.filter((r) => !r.success).length;
-        const skipped = results.filter((r) => r.success && r.duration <= 0).length;
-        const totalDuration = results.reduce((sum, r) => sum + r.duration, 0);
-        const executedInPriorityOrder = !issues.some((issue) => issue.message.includes("expected ascending priority order"));
-        this.chainReport = {
-            totalProcessors: results.length,
-            successful,
-            failed,
-            skipped,
-            issues,
-            averageDuration: results.length > 0 ? totalDuration / results.length : 0,
-            executedInPriorityOrder,
-        };
-        return {
-            valid: issues.filter((i) => i.severity === "error").length === 0,
-            issues,
-        };
-    }
-    /**
-     * Get the chain report from the most recent validation.
-     */
-    getChainReport() {
-        if (!this.chainReport) {
-            return {
-                totalProcessors: 0,
-                successful: 0,
-                failed: 0,
-                skipped: 0,
-                issues: [],
-                averageDuration: 0,
-                executedInPriorityOrder: true,
-            };
-        }
-        return this.chainReport;
-    }
-}
-// ---------------------------------------------------------------------------
-// Standalone runner for processor-manager integration
-// ---------------------------------------------------------------------------
-export async function runPostProcessorChainValidation(context) {
-    const start = performance.now();
-    try {
-        const preResults = context.preResults ?? [];
-        const validator = new PostProcessorChainValidator();
-        const chainEntries = preResults.map((r) => ({
-            name: r.processorName,
-            success: r.success,
-            duration: r.duration,
-        }));
-        const validationResult = validator.validateChain(chainEntries);
-        const report = validator.getChainReport();
-        if (!validationResult.valid) {
-            frameworkLogger.log("postprocessor-chain-validator", "chain_invalid", "warning", { issues: validationResult.issues });
-        }
-        return {
-            success: validationResult.valid,
-            processorName: "postprocessor-chain-validator",
-            duration: performance.now() - start,
-            result: {
-                validation: validationResult,
-                report,
-            },
-        };
-    }
-    catch (error) {
-        frameworkLogger.log("postprocessor-chain-validator", "validation_failed", "error", { error: error.message });
-        return {
-            success: false,
-            processorName: "postprocessor-chain-validator",
-            duration: performance.now() - start,
-            error: error.message,
-        };
-    }
-}

package/dist/processors/implementations/pre-validate-processor.d.ts

@@ -1,7 +0,0 @@
-import { PreProcessor } from "../processor-interfaces.js";
-import type { ProcessorContext } from "../processor-types.js";
-export declare class PreValidateProcessor extends PreProcessor {
-    readonly name = "preValidate";
-    readonly priority = 1;
-    protected run(context: ProcessorContext): Promise<Record<string, unknown>>;
-}

package/dist/processors/implementations/pre-validate-processor.js

@@ -1,18 +0,0 @@
-import { PreProcessor } from "../processor-interfaces.js";
-export class PreValidateProcessor extends PreProcessor {
-    name = "preValidate";
-    priority = 1;
-    async run(context) {
-        const { data, filePath } = context;
-        if (!data && !filePath) {
-            return { validated: true, syntaxCheck: "skipped", reason: "no data provided" };
-        }
-        if (!data) {
-            return { validated: true, syntaxCheck: "skipped", reason: "no data in context" };
-        }
-        if (typeof data === "string" && data.includes("undefined")) {
-            throw new Error("Potential undefined usage detected");
-        }
-        return { validated: true, syntaxCheck: "passed" };
-    }
-}

package/dist/processors/implementations/publish-preflight-processor.d.ts

@@ -1,37 +0,0 @@
-/**
- * Publish Preflight Processor
- *
- * Post-processor that validates documentation completeness before publishing.
- * Ensures README.md, AGENTS.md, and reflection documents are up-to-date
- * before allowing npm publish.
- *
- * Configuration is read from .xray/features.json
- *
- * @processor_type post
- * @priority 10 (runs early after post-processing starts)
- * @blocking true (blocks publish on violations)
- *
- * @framework 0xRay 1.15.41
- */
-import { PostProcessor } from "../processor-interfaces.js";
-import { ProcessorContext, ProcessorResult } from "../processor-types.js";
-export interface PreflightResult {
-    compliant: boolean;
-    checks: PreflightCheck[];
-    summary: string;
-}
-export interface PreflightCheck {
-    name: string;
-    passed: boolean;
-    message: string;
-    required: boolean;
-}
-export declare class PublishPreflightProcessor extends PostProcessor {
-    readonly name = "publishPreflight";
-    readonly priority = 10;
-    private config;
-    constructor();
-    private loadConfig;
-    protected run(context: ProcessorContext): Promise<unknown>;
-    execute(context: ProcessorContext): Promise<ProcessorResult>;
-}

package/dist/processors/implementations/publish-preflight-processor.js

@@ -1,240 +0,0 @@
-/**
- * Publish Preflight Processor
- *
- * Post-processor that validates documentation completeness before publishing.
- * Ensures README.md, AGENTS.md, and reflection documents are up-to-date
- * before allowing npm publish.
- *
- * Configuration is read from .xray/features.json
- *
- * @processor_type post
- * @priority 10 (runs early after post-processing starts)
- * @blocking true (blocks publish on violations)
- *
- * @framework 0xRay 1.15.41
- */
-import * as fs from "fs";
-import * as path from "path";
-import { PostProcessor } from "../processor-interfaces.js";
-import { frameworkLogger } from "../../core/framework-logger.js";
-import { featuresConfigLoader } from "../../core/features-config.js";
-export class PublishPreflightProcessor extends PostProcessor {
-    name = "publishPreflight";
-    priority = 10;
-    config = {
-        enabled: true,
-        require_documentation: {
-            enabled: true,
-            required_files: ["README.md", "AGENTS.md", "CHANGELOG.md"],
-            readme_version_sync: true,
-        },
-        require_reflection: {
-            enabled: true,
-            max_age_days: 7,
-            auto_create_on_publish: true,
-        },
-        require_pipeline_tests: {
-            enabled: true,
-            min_pipeline_tests: 3,
-        },
-    };
-    constructor() {
-        super();
-        this.loadConfig();
-    }
-    loadConfig() {
-        try {
-            const publishConfig = featuresConfigLoader.loadConfig().publish;
-            if (publishConfig) {
-                this.config = { ...this.config, ...publishConfig };
-            }
-        }
-        catch (e) {
-            frameworkLogger.log("publish-preflight-processor", "config-load-failed", "warning", { error: e instanceof Error ? e.message : String(e) });
-        }
-    }
-    async run(context) {
-        const projectRoot = process.cwd();
-        await frameworkLogger.log("publish-preflight-processor", "starting", "info", { operation: context.operation });
-        const checks = [];
-        const pubConfig = this.config;
-        const docConfig = pubConfig?.require_documentation ?? {
-            enabled: true,
-            required_files: ["README.md", "AGENTS.md", "CHANGELOG.md"],
-            readme_version_sync: true,
-        };
-        const reflectionConfig = pubConfig?.require_reflection ?? {
-            enabled: true,
-            max_age_days: 7,
-            auto_create_on_publish: true,
-        };
-        const pipelineConfig = pubConfig?.require_pipeline_tests ?? {
-            enabled: true,
-            min_pipeline_tests: 3,
-        };
-        // Check 1: Required documentation files exist
-        if (docConfig.enabled) {
-            for (const docFile of docConfig.required_files) {
-                const docPath = path.join(projectRoot, docFile);
-                const exists = fs.existsSync(docPath);
-                checks.push({
-                    name: `${docFile} exists`,
-                    passed: exists,
-                    message: exists
-                        ? `${docFile} found`
-                        : `${docFile} is missing - required for publish`,
-                    required: true,
-                });
-            }
-        }
-        // Check 2: Required directories exist
-        const reflectionsDir = path.join(projectRoot, "docs/reflections");
-        const pipelineTestDir = path.join(projectRoot, "src/__tests__/pipeline");
-        const reflectionsExists = fs.existsSync(reflectionsDir);
-        const pipelineTestsExist = fs.existsSync(pipelineTestDir);
-        checks.push({
-            name: "docs/reflections exists",
-            passed: reflectionsExists,
-            message: reflectionsExists
-                ? "docs/reflections directory found"
-                : "docs/reflections directory is missing",
-            required: reflectionConfig.enabled,
-        });
-        checks.push({
-            name: "Pipeline tests directory exists",
-            passed: pipelineTestsExist,
-            message: pipelineTestsExist
-                ? "src/__tests__/pipeline directory found"
-                : "src/__tests__/pipeline directory is missing",
-            required: pipelineConfig.enabled,
-        });
-        // Check 3: README version matches package.json
-        if (docConfig.readme_version_sync) {
-            const pkgPath = path.join(projectRoot, "package.json");
-            const readmePath = path.join(projectRoot, "README.md");
-            if (fs.existsSync(pkgPath) && fs.existsSync(readmePath)) {
-                try {
-                    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
-                    const readme = fs.readFileSync(readmePath, "utf-8");
-                    const pkgVersion = pkg.version;
-                    const readmeHasVersion = readme.includes(pkgVersion);
-                    checks.push({
-                        name: "README version sync",
-                        passed: readmeHasVersion,
-                        message: readmeHasVersion
-                            ? `README references version ${pkgVersion}`
-                            : `README does not reference current version ${pkgVersion}`,
-                        required: false,
-                    });
-                }
-                catch (e) {
-                    checks.push({
-                        name: "README version sync",
-                        passed: false,
-                        message: "Could not verify README version sync",
-                        required: false,
-                    });
-                }
-            }
-        }
-        // Check 4: Latest reflection exists (within configured days)
-        if (reflectionConfig.enabled && reflectionsExists) {
-            const reflectionFiles = fs.readdirSync(reflectionsDir)
-                .filter(f => f.endsWith(".md"))
-                .map(f => ({
-                name: f,
-                path: path.join(reflectionsDir, f),
-                mtime: fs.statSync(path.join(reflectionsDir, f)).mtime.getTime(),
-            }))
-                .sort((a, b) => b.mtime - a.mtime);
-            const maxAgeMs = reflectionConfig.max_age_days * 24 * 60 * 60 * 1000;
-            const latestReflection = reflectionFiles[0];
-            const hasRecentReflection = latestReflection !== undefined &&
-                latestReflection.mtime > (Date.now() - maxAgeMs);
-            checks.push({
-                name: "Recent reflection",
-                passed: hasRecentReflection,
-                message: hasRecentReflection
-                    ? `Latest reflection: ${latestReflection.name}`
-                    : `No reflection documents from last ${reflectionConfig.max_age_days} days - reflection required before publish`,
-                required: true,
-            });
-        }
-        // Check 5: Pipeline tests exist - must match all discoverable pipelines
-        const pipelineInventoryPath = path.join(projectRoot, "docs/architecture/PIPELINE_INVENTORY.md");
-        let requiredPipelineTests = pipelineConfig.min_pipeline_tests;
-        if (fs.existsSync(pipelineInventoryPath)) {
-            try {
-                const inventory = fs.readFileSync(pipelineInventoryPath, "utf-8");
-                const mainPipelineMatches = inventory.match(/### Main Pipelines \((\d+)\)/);
-                const subPipelineSectionMatch = inventory.match(/### Sub-Pipelines[\s\S]*?(?=### |\n## |\n$)/);
-                let subCount = 0;
-                if (subPipelineSectionMatch) {
-                    const subLines = subPipelineSectionMatch[0].split('\n').filter(l => l.match(/^\|.*\*\*.*\|/));
-                    subCount = subLines.length;
-                }
-                if (mainPipelineMatches || subCount > 0) {
-                    const mainPipelineCount = mainPipelineMatches?.[1] ?? "0";
-                    const mainCount = parseInt(mainPipelineCount, 10);
-                    requiredPipelineTests = mainCount + subCount;
-                }
-            }
-            catch (e) {
-                frameworkLogger.log("publish-preflight-processor", "inventory-parse-failed", "warning", { error: e instanceof Error ? e.message : String(e) });
-            }
-        }
-        if (pipelineConfig.enabled && pipelineTestsExist) {
-            const testFiles = fs.readdirSync(pipelineTestDir)
-                .filter(f => f.endsWith(".mjs") || f.endsWith(".test.mjs"));
-            const hasEnoughTests = testFiles.length >= requiredPipelineTests;
-            const requiredStr = requiredPipelineTests.toString();
-            checks.push({
-                name: "Pipeline tests",
-                passed: hasEnoughTests,
-                message: hasEnoughTests
-                    ? `Found ${testFiles.length} pipeline test files (required: ${requiredStr})`
-                    : `Only ${testFiles.length} pipeline test files - ${requiredStr} required (from PIPELINE_INVENTORY.md)`,
-                required: true,
-            });
-        }
-        // Determine overall compliance
-        const failedRequired = checks.filter(c => c.required && !c.passed);
-        const compliant = failedRequired.length === 0;
-        const summary = compliant
-            ? "✅ All preflight checks passed"
-            : `❌ ${failedRequired.length} required check(s) failed: ${failedRequired.map(c => c.name).join(", ")}`;
-        if (!compliant) {
-            await frameworkLogger.log("publish-preflight-processor", "failed", "error", { failedChecks: failedRequired.map(c => c.name) });
-        }
-        return {
-            compliant,
-            checks,
-            summary,
-            checkedAt: new Date().toISOString(),
-        };
-    }
-    async execute(context) {
-        const startTime = Date.now();
-        const result = await this.run(context);
-        const duration = Date.now() - startTime;
-        if (!result.compliant) {
-            const failedChecks = result.checks
-                .filter(c => c.required && !c.passed)
-                .map(c => c.message)
-                .join("; ");
-            return {
-                success: false,
-                error: `Publish preflight failed: ${failedChecks}`,
-                data: result,
-                duration,
-                processorName: this.name,
-            };
-        }
-        return {
-            success: true,
-            data: result,
-            duration,
-            processorName: this.name,
-        };
-    }
-}

package/dist/processors/implementations/refactoring-logging-processor-wrapper.d.ts

@@ -1,7 +0,0 @@
-import { PreProcessor } from "../processor-interfaces.js";
-import type { ProcessorContext } from "../processor-types.js";
-export declare class RefactoringLoggingProcessorWrapper extends PreProcessor {
-    readonly name = "refactoringLogging";
-    readonly priority = 8;
-    protected run(context: ProcessorContext): Promise<Record<string, unknown>>;
-}

package/dist/processors/implementations/refactoring-logging-processor-wrapper.js

@@ -1,33 +0,0 @@
-import { PreProcessor } from "../processor-interfaces.js";
-import { frameworkLogger } from "../../core/framework-logger.js";
-export class RefactoringLoggingProcessorWrapper extends PreProcessor {
-    name = "refactoringLogging";
-    priority = 8;
-    async run(context) {
-        try {
-            const { RefactoringLoggingProcessor } = await import("./refactoring-logging-processor.js");
-            const processor = new RefactoringLoggingProcessor();
-            if (context.agentName &&
-                context.task &&
-                typeof context.startTime === "number") {
-                const result = await processor.execute(context);
-                return {
-                    logged: result.logged || false,
-                    success: true,
-                    message: result.logged ? "Agent completion logged" : "No logging needed",
-                };
-            }
-            return { logged: false, success: true, message: "Not an agent task completion context" };
-        }
-        catch (error) {
-            frameworkLogger.log("refactoring-logging-processor", "failed", "error", {
-                error: error instanceof Error ? error.message : String(error),
-            });
-            return {
-                logged: false,
-                success: false,
-                error: error instanceof Error ? error.message : String(error),
-            };
-        }
-    }
-}

package/dist/processors/implementations/refactoring-logging-processor.d.ts

@@ -1,31 +0,0 @@
-export interface RefactoringContext {
-    agentName: string;
-    task: {
-        id?: string;
-        description?: string;
-        operationType?: string;
-    };
-    startTime: number;
-    complexityScore?: number;
-    changes?: Array<{
-        description?: string;
-        type?: string;
-    }>;
-    files?: string[];
-    metrics?: Record<string, unknown>;
-    operationType?: string;
-}
-export interface RefactoringLogResult {
-    logged: boolean;
-    success: boolean;
-    message: string;
-    error?: string;
-}
-export declare class RefactoringLoggingProcessor {
-    private logPath;
-    constructor();
-    private ensureLogDirectory;
-    execute(context: RefactoringContext): Promise<RefactoringLogResult>;
-    private createLogEntry;
-    private appendToLog;
-}

package/dist/processors/implementations/refactoring-logging-processor.js

@@ -1,96 +0,0 @@
-import { frameworkLogger } from "../../core/framework-logger.js";
-import * as fs from "fs";
-import * as path from "path";
-export class RefactoringLoggingProcessor {
-    logPath;
-    constructor() {
-        this.logPath = path.join(process.cwd(), "logs", "agents", "refactoring-log.md");
-        this.ensureLogDirectory();
-    }
-    ensureLogDirectory() {
-        const logDir = path.dirname(this.logPath);
-        if (!fs.existsSync(logDir)) {
-            fs.mkdirSync(logDir, { recursive: true });
-        }
-    }
-    async execute(context) {
-        try {
-            if (context.agentName &&
-                context.task &&
-                typeof context.startTime === "number") {
-                const logEntry = this.createLogEntry(context);
-                await this.appendToLog(logEntry);
-                return {
-                    logged: true,
-                    success: true,
-                    message: "Agent refactoring completion logged successfully",
-                };
-            }
-            return {
-                logged: false,
-                success: true,
-                message: "Not an agent task completion context",
-            };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            await frameworkLogger.log("refactoring-logging-processor", "-refactoring-logging-failed-error-instanceof-error-", "error", { message: `Refactoring logging failed: ${errorMessage}` });
-            return {
-                logged: false,
-                success: false,
-                message: `Refactoring logging failed: ${errorMessage}`,
-                error: errorMessage,
-            };
-        }
-    }
-    createLogEntry(context) {
-        const timestamp = new Date().toISOString();
-        const duration = Date.now() - context.startTime;
-        let logEntry = `## Refactoring Operation - ${timestamp}\n\n`;
-        logEntry += `**Agent:** ${context.agentName}\n`;
-        logEntry += `**Task:** ${context.task.description || context.task.id || "Unknown"}\n`;
-        logEntry += `**Duration:** ${duration}ms\n`;
-        logEntry += `**Operation Type:** ${context.task.operationType || context.operationType || "refactor"}\n`;
-        if (context.complexityScore) {
-            logEntry += `**Complexity Score:** ${context.complexityScore}\n`;
-        }
-        if (context.changes && Array.isArray(context.changes)) {
-            logEntry += `\n**Changes Made:**\n`;
-            context.changes.forEach((change, index) => {
-                logEntry += `${index + 1}. ${change.description || change.type || "Unknown change"}\n`;
-            });
-        }
-        if (context.files && Array.isArray(context.files)) {
-            logEntry += `\n**Files Modified:**\n`;
-            context.files.forEach((file) => {
-                logEntry += `- ${file}\n`;
-            });
-        }
-        if (context.metrics) {
-            logEntry += `\n**Metrics:**\n`;
-            Object.entries(context.metrics).forEach(([key, value]) => {
-                logEntry += `- ${key}: ${value}\n`;
-            });
-        }
-        logEntry += `\n---\n\n`;
-        return logEntry;
-    }
-    async appendToLog(entry) {
-        try {
-            if (!fs.existsSync(this.logPath)) {
-                let header = `# 0xRay Framework Refactoring Log\n\n`;
-                header += `This log tracks all refactoring operations performed by 0xRay agents.\n\n`;
-                header += `Generated on: ${new Date().toISOString()}\n\n`;
-                header += `---\n\n`;
-                fs.writeFileSync(this.logPath, header, "utf8");
-            }
-            fs.appendFileSync(this.logPath, entry, "utf8");
-            await frameworkLogger.log("refactoring-logging-processor", "-refactoring-operation-logged-successfully-", "info", { message: "Refactoring operation logged successfully" });
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            await frameworkLogger.log("refactoring-logging-processor", "-failed-to-append-to-refactoring-log-error-instanceof-", "error", { message: `Failed to append to refactoring log: ${errorMessage}` });
-            throw error;
-        }
-    }
-}

package/dist/processors/implementations/regression-testing-processor.d.ts

@@ -1,20 +0,0 @@
-import { PostProcessor } from "../processor-interfaces.js";
-import type { ProcessorContext } from "../processor-types.js";
-interface RegressionResult {
-    regressions: number;
-    issues: RegressionIssue[];
-    baseline: string | null;
-    current: string | null;
-}
-interface RegressionIssue {
-    type: "new_failure" | "coverage_drop" | "performance_degradation";
-    description: string;
-    file?: string;
-}
-export declare class RegressionTestingProcessor extends PostProcessor {
-    readonly name = "regressionTesting";
-    readonly priority = 15;
-    protected run(context: ProcessorContext): Promise<RegressionResult>;
-    private getCurrentTestCount;
-}
-export {};