0xray 3.4.1 → 3.4.3

package/dist/postprocessor/autofix/FixValidator.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Fix Validator for Post-Processor Auto-Fix System
+ *
+ * Validates applied fixes and provides rollback functionality.
+ */
+import { FailureAnalysis, PostProcessorContext } from "../types.js";
+export interface AppliedFix {
+    type: string;
+    files: string[];
+    description: string;
+    timestamp: Date;
+    rollbackData?: any;
+}
+export declare class FixValidator {
+    /**
+     * Validate that applied fixes resolve the original issue
+     */
+    validateFixes(appliedFixes: AppliedFix[], analysis: FailureAnalysis, context: PostProcessorContext): Promise<boolean>;
+    /**
+     * Rollback applied fixes
+     */
+    rollbackFixes(appliedFixes: AppliedFix[]): Promise<void>;
+}

package/dist/postprocessor/config/ProcessorConfigLoader.d.ts

@@ -0,0 +1,44 @@
+export declare class ProcessorConfigLoader {
+    loadProcessorConfig(): Promise<{
+        preValidate?: {
+            enabled?: boolean;
+        };
+        codexCompliance?: {
+            enabled?: boolean;
+        };
+        testAutoCreation?: {
+            enabled?: boolean;
+        };
+        versionCompliance?: {
+            enabled?: boolean;
+        };
+        errorBoundary?: {
+            enabled?: boolean;
+        };
+        agentsMdValidation?: {
+            enabled?: boolean;
+        };
+        stateValidation?: {
+            enabled?: boolean;
+        };
+        post_processors?: {
+            enabled?: boolean;
+            priority_order?: string[];
+        };
+        storytellingTrigger?: {
+            enabled?: boolean;
+        };
+        sessionSummary?: {
+            enabled?: boolean;
+        };
+        testExecution?: {
+            enabled?: boolean;
+        };
+        regressionTesting?: {
+            enabled?: boolean;
+        };
+        inferenceImprovement?: {
+            enabled?: boolean;
+        };
+    }>;
+}

package/dist/postprocessor/config.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Post-Processor Configuration
+ */
+import { PostProcessorConfig } from "./types.js";
+export declare const defaultConfig: PostProcessorConfig;
+export declare function validateConfig(config: Partial<PostProcessorConfig>): PostProcessorConfig;

package/dist/postprocessor/escalation/EscalationEngine.d.ts

@@ -0,0 +1,154 @@
+/**
+ * Escalation Engine for Post-Processor
+ * Handles incident reporting, manual intervention triggers, and alerting
+ */
+import { PostProcessorContext, EscalationResult, IncidentReport, MonitoringResult } from "../types.js";
+export interface EscalationConfig {
+    manualInterventionThreshold: number;
+    rollbackThreshold: number;
+    emergencyThreshold: number;
+    alertChannels: string[];
+    incidentReporting: boolean;
+    reportingEndpoints?: ReportingEndpoint[];
+}
+export interface ReportingEndpoint {
+    name: string;
+    url: string;
+    type: "webhook" | "pagerduty" | "slack" | "email" | "custom";
+    enabled: boolean;
+    priorityThreshold?: "low" | "medium" | "high" | "critical";
+    headers?: Record<string, string>;
+}
+export interface AlertMessage {
+    level: "info" | "warning" | "error" | "critical";
+    title: string;
+    message: string;
+    context: PostProcessorContext;
+    metadata?: Record<string, unknown>;
+}
+export interface IncidentReportPayload {
+    incident: IncidentReport;
+    formattedMessage: string;
+    affectedSystems: string[];
+    recommendedActions: string[];
+}
+export declare class EscalationEngine {
+    private config;
+    private incidents;
+    private reportingHistory;
+    constructor(config?: Partial<EscalationConfig>);
+    /**
+     * Evaluate if escalation is needed based on failure context
+     */
+    evaluateEscalation(context: PostProcessorContext, attempts: number, error: string, monitoringResults: MonitoringResult[]): Promise<EscalationResult | null>;
+    /**
+     * Create a detailed incident report
+     */
+    private createIncidentReport;
+    /**
+     * Report incident to configured external systems
+     */
+    private reportIncidentToExternalSystems;
+    /**
+     * Send incident to a specific endpoint
+     */
+    private sendToEndpoint;
+    /**
+     * Build incident payload for reporting
+     */
+    private buildIncidentPayload;
+    /**
+     * Format incident message for external systems
+     */
+    private formatIncidentMessage;
+    /**
+     * Get recommended actions based on severity
+     */
+    private getRecommendedActions;
+    /**
+     * Send to Slack webhook
+     */
+    private sendToSlack;
+    /**
+     * Send to PagerDuty
+     */
+    private sendToPagerDuty;
+    /**
+     * Send generic webhook
+     */
+    private sendWebhook;
+    /**
+     * Send email notification (placeholder - would need SMTP configuration)
+     */
+    private sendEmail;
+    /**
+     * Get color for severity level (for Slack attachments)
+     */
+    private getSeverityColor;
+    /**
+     * Get reporting history
+     */
+    getReportingHistory(): ReadonlyArray<{
+        incidentId: string;
+        endpoint: string;
+        success: boolean;
+        timestamp: number;
+        response?: string;
+    }>;
+    /**
+     * Clear reporting history
+     */
+    clearReportingHistory(): void;
+    /**
+     * Add reporting endpoint dynamically
+     */
+    addReportingEndpoint(endpoint: ReportingEndpoint): void;
+    /**
+     * Remove reporting endpoint
+     */
+    removeReportingEndpoint(name: string): boolean;
+    /**
+     * Get configured reporting endpoints
+     */
+    getReportingEndpoints(): ReportingEndpoint[];
+    /**
+     * Send alerts through configured channels
+     */
+    private sendAlerts;
+    /**
+     * Send alert to specific channel
+     */
+    private sendAlertToChannel;
+    /**
+     * Get emoji for alert level
+     */
+    private getAlertEmoji;
+    /**
+     * Map escalation level to severity
+     */
+    private mapLevelToSeverity;
+    /**
+     * Map escalation level to alert level
+     */
+    private mapLevelToAlertLevel;
+    /**
+     * Get incident report by ID
+     */
+    getIncidentReport(incidentId: string): IncidentReport | undefined;
+    /**
+     * Get all active incidents
+     */
+    getActiveIncidents(): IncidentReport[];
+    /**
+     * Resolve an incident
+     */
+    resolveIncident(incidentId: string, resolution: string): boolean;
+    /**
+     * Get escalation statistics
+     */
+    getStats(): {
+        totalIncidents: number;
+        activeIncidents: number;
+        escalationsByLevel: Record<string, number>;
+    };
+}

package/dist/postprocessor/integration.d.ts

@@ -0,0 +1,156 @@
+/**
+ * 0xRay Integration Layer
+ *
+ * Provides generic connectors for integrating 0xRay's PostProcessor
+ * with external applications and frameworks.
+ *
+ * This is framework-agnostic - works with Express, Fastify, Koa, etc.
+ *
+ * @since 2026-03-08
+ */
+import express from "express";
+import { PostProcessor } from './PostProcessor.js';
+import type { WebhookConfig } from './triggers/WebhookTrigger.js';
+import type { APIConfig } from './triggers/APITrigger.js';
+export { WebhookTrigger } from './triggers/WebhookTrigger.js';
+export { APITrigger } from './triggers/APITrigger.js';
+export type { WebhookConfig, WebhookEvent } from './triggers/WebhookTrigger.js';
+export type { APIConfig, APIRequest } from './triggers/APITrigger.js';
+/**
+ * Generic 0xRay integration for any external application
+ *
+ * Provides:
+ * - Webhook receivers (GitHub, GitLab, Bitbucket, Stripe)
+ * - REST API triggers (manual trigger, retry, status)
+ * - Framework-agnostic (works with Express, Fastify, Koa, etc.)
+ *
+ * @example
+ * ```typescript
+ * import { createXrayIntegration } from '0xray/integration';
+ *
+ * const postProcessor = new PostProcessor(stateManager);
+ * const integration = createXrayIntegration(postProcessor);
+ *
+ * // Get Express app for mounting
+ * app.use('/webhooks', integration.getWebhookApp());
+ * app.use('/api/post-process', integration.getAPIApp());
+ *
+ * // Or get raw routers for Fastify/Koa
+ * const webhookRouter = integration.getWebhookRouter();
+ * const apiRouter = integration.getAPIRouter();
+ * ```
+ */
+export declare class XrayIntegration {
+    private postProcessor;
+    private webhookTrigger;
+    private apiTrigger;
+    constructor(postProcessor: PostProcessor);
+    /**
+     * Initialize all triggers with default configuration
+     *
+     * @param config - Optional configuration for triggers
+     */
+    initialize(config?: {
+        webhook?: Partial<WebhookConfig>;
+        api?: Partial<APIConfig>;
+    }): Promise<void>;
+    /**
+     * Get webhook app for framework-specific mounting
+     *
+     * Returns an Express Application. For other frameworks,
+     * use getWebhookRouter() to get the router instance.
+     *
+     * @example
+     * ```typescript
+     * // Express
+     * app.use('/webhooks', integration.getWebhookApp());
+     *
+     * // Fastify
+     * await fastify.register(integration.getWebhookRouter(), { prefix: '/webhooks' });
+     *
+     * // Koa
+     * app.use(integration.getWebhookRouter().routes());
+     * ```
+     */
+    getWebhookApp(): express.Application | null;
+    /**
+     * Get webhook router (raw Express router)
+     *
+     * Useful for frameworks that need the router instance directly
+     * rather than the full Express app.
+     */
+    getWebhookRouter(): express.Router | null;
+    /**
+     * Get API trigger app for framework-specific mounting
+     *
+     * @example
+     * ```typescript
+     * // Express
+     * app.use('/api/post-process', integration.getAPIApp());
+     *
+     * // Fastify
+     * await fastify.register(integration.getAPIRouter(), { prefix: '/api/post-process' });
+     * ```
+     */
+    getAPIApp(): express.Application | null;
+    /**
+     * Get API trigger router (raw Express router)
+     *
+     * Useful for frameworks that need the router instance directly.
+     */
+    getAPIRouter(): express.Router | null;
+    /**
+     * Manually trigger PostProcessor via API
+     *
+     * Convenience method for programmatic triggering without
+     * going through the HTTP endpoint.
+     *
+     * @example
+     * ```typescript
+     * await integration.trigger({
+     *   tool: 'test',
+     *   operation: 'run',
+     *   reason: 'Manual test trigger'
+     * });
+     * ```
+     */
+    trigger(options: {
+        tool: string;
+        operation: string;
+        filePath?: string;
+        directory?: string;
+        reason?: string;
+    }): Promise<void>;
+    /**
+     * Shutdown all triggers
+     */
+    shutdown(): Promise<void>;
+}
+/**
+ * Factory function for easy integration setup
+ *
+ * @example
+ * ```typescript
+ * import { createXrayIntegration } from '0xray/integration';
+ *
+ * // With default configuration
+ * const integration = createXrayIntegration(postProcessor);
+ * await integration.initialize();
+ *
+ * // With custom configuration
+ * const integration = createXrayIntegration(postProcessor);
+ * await integration.initialize({
+ *   webhook: {
+ *     provider: 'gitlab',
+ *     secret: process.env.GITLAB_WEBHOOK_SECRET,
+ *     events: ['push', 'merge_request'],
+ *     path: '/webhooks/gitlab'
+ *   },
+ *   api: {
+ *     path: '/api/stray-trigger',
+ *     apiKey: process.env.API_KEY
+ *   }
+ * });
+ * ```
+ */
+export declare function createXrayIntegration(postProcessor: PostProcessor): XrayIntegration;

package/dist/postprocessor/metamorphosis/SelfProposalEngine.d.ts

@@ -0,0 +1,87 @@
+/**
+ * SelfProposalEngine — Phase 2.2
+ *
+ * Concrete MetamorphosisEngine that reads activity.log, parses structured
+ * log entries, detects semantic patterns, generates governance proposals
+ * (type: 'metamorphosis'), and submits them through the full 3-agent +
+ * Dynamo governance pipeline.
+ *
+ * Safety constraints:
+ * - Max proposals per hour (default 1, configurable)
+ * - Circuit breaker: after N consecutive failures, halt for cooldown (default 3/24h)
+ * - Only proposes changes to whitelisted targets
+ * - All proposals go through full governance with metamorphosisThreshold (default 0.7)
+ * - Detection thresholds are configurable (not hard-coded)
+ *
+ * Coupling note: currently triggered by PostProcessor.onPhase(). A future
+ * refactor should extract log-reading into a dedicated LogReader that can
+ * run on its own schedule or fs.watch, decoupling from PostProcessor lifecycle.
+ */
+import type { MetamorphosisEngine, MetamorphosisProposal } from '../../types/metamorphosis.js';
+export interface SelfProposalConfig {
+    maxProposalsPerHour?: number;
+    circuitBreakerThreshold?: number;
+    circuitBreakerCooldownHours?: number;
+    activityLogPath?: string;
+    whitelistedTargets?: string[];
+    /** Number of recent log lines to analyze (default: 100) */
+    maxLogLines?: number;
+    /** Minimum error entries to trigger an error-handling proposal (default: 5) */
+    errorThreshold?: number;
+    /** Minimum warning entries to trigger a monitoring proposal (default: 10) */
+    warningThreshold?: number;
+    /** Minimum governance rejections of same type to trigger a pattern proposal (default: 3) */
+    governanceRejectionThreshold?: number;
+    /** Minimum confidence for generated proposals (default: 0.7) */
+    proposalConfidence?: number;
+    /** Metamorphosis score threshold for approval (default: 0.7) */
+    metamorphosisThreshold?: number;
+    /** Project root for resolving whitelisted target paths (default: process.cwd()) */
+    projectRoot?: string;
+}
+export interface SelfEvolutionMetrics {
+    totalProposals: number;
+    recentProposals: number;
+    consecutiveFailures: number;
+    circuitBreakerActive: boolean;
+    circuitBreakerUntil: number;
+    successRate: number;
+}
+export declare class SelfProposalEngine implements MetamorphosisEngine {
+    readonly name = "self-proposal";
+    private config;
+    private proposalHistory;
+    private consecutiveFailures;
+    private circuitBreakerUntil;
+    constructor(config?: SelfProposalConfig);
+    onPhase(phase: string, context: unknown): Promise<void>;
+    onProposal(proposal: MetamorphosisProposal): Promise<void>;
+    private isCircuitBreakerActive;
+    private isRateLimited;
+    getMetrics(): SelfEvolutionMetrics;
+    private evaluateAndPropose;
+    /**
+     * Detect actionable patterns from parsed activity log entries.
+     * Uses structured parsing instead of raw string matching to handle
+     * the actual xray log format:
+     *   ISO_TIMESTAMP [jobId] [traceId.spanId] [component] action - STATUS | {details}
+     */
+    detectPatterns(entries: string[]): MetamorphosisProposal[];
+    /**
+     * Apply an approved self-evolution proposal by recording the change
+     * in a state file within the first matching whitelisted target directory.
+     * Returns true if the change was written and verified, false otherwise.
+     */
+    private applySelfProposal;
+    private submitProposal;
+    /**
+     * Post-apply audit for Term 72 (Self-Evolution Traceability).
+     * For 0xray-tagged proposals (framework self-evolution), asserts that
+     * frameworkLogger entries exist with full provenance:
+     *   - source proposal ID
+     *   - governance vote results / finalDecision / averageConfidence
+     *   - metamorphosisScore
+     * Logs the audit outcome via frameworkLogger.
+     */
+    private audit0xrayProposalTraceability;
+}

package/dist/postprocessor/metamorphosis/index.d.ts

@@ -0,0 +1,2 @@
+export { type MetamorphosisEngine, type MetamorphosisProposal } from '../../types/metamorphosis.js';
+export { SelfProposalEngine, type SelfProposalConfig } from './SelfProposalEngine.js';

package/dist/postprocessor/monitoring/MonitoringEngine.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Post-Processor Monitoring Engine
+ */
+import { XrayStateManager } from "../../state/state-manager.js";
+import { SessionMonitor } from "../../session/session-monitor.js";
+import { MonitoringResult } from "../types.js";
+export interface CIStatus {
+    status: "success" | "failure" | "running";
+    failedJobs: string[];
+    totalJobs: number;
+    duration: number;
+}
+export interface PerformanceStatus {
+    status: "passed" | "failed" | "warning";
+    score: number;
+    regressions: string[];
+    duration: number;
+}
+export interface SecurityStatus {
+    status: "passed" | "failed" | "warning";
+    vulnerabilities: number;
+    criticalVulnerabilities: number;
+    scanDuration: number;
+}
+export declare class PostProcessorMonitoringEngine {
+    private stateManager;
+    private sessionMonitor?;
+    constructor(stateManager: XrayStateManager, sessionMonitor?: SessionMonitor | undefined);
+    initialize(): Promise<void>;
+    monitorDeployment(commitSha: string): Promise<MonitoringResult>;
+    private checkCIStatus;
+    private checkPerformanceStatus;
+    private checkSecurityStatus;
+    private determineOverallStatus;
+    getStatus(): Promise<{
+        monitoringEnabled: boolean;
+        activeSessions: number;
+        lastCheck: Date;
+    }>;
+}

package/dist/postprocessor/redeploy/RedeployCoordinator.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Redeploy Coordinator for Post-Processor
+ */
+import { FixResult, PostProcessorContext } from "../types.js";
+export interface RedeployResult {
+    success: boolean;
+    deploymentId: string;
+    commitSha: string;
+    environment: string;
+    duration: number;
+    error?: string;
+    rollbackPerformed?: boolean;
+    canaryResults?: CanaryResult[];
+}
+export interface CanaryResult {
+    phase: number;
+    trafficPercentage: number;
+    success: boolean;
+    metrics: {
+        responseTime: number;
+        errorRate: number;
+        throughput: number;
+    };
+    duration: number;
+}
+export interface RedeployConfig {
+    maxRetries: number;
+    retryDelay: number;
+    backoffStrategy: "linear" | "exponential";
+    canaryEnabled: boolean;
+    canaryPhases: number;
+    canaryTrafficIncrement: number;
+    healthCheckTimeout: number;
+    rollbackOnFailure: boolean;
+}
+export declare class RedeployCoordinator {
+    private config;
+    constructor(config?: Partial<RedeployConfig>);
+    /**
+     * Execute redeployment with fixes
+     */
+    executeRedeploy(context: PostProcessorContext, fixResult: FixResult): Promise<RedeployResult>;
+    /**
+     * Validate pre-deployment requirements
+     */
+    private validatePreDeployment;
+    /**
+     * Execute deployment with retry logic
+     */
+    private deployWithRetry;
+    /**
+     * Execute canary deployment with progressive traffic rollout
+     */
+    private executeCanaryDeployment;
+    /**
+     * Execute direct deployment (no canary)
+     */
+    private executeDirectDeployment;
+    /**
+     * Deploy to canary environment
+     */
+    private deployToCanary;
+    /**
+     * Monitor canary health during deployment
+     */
+    private monitorCanaryHealth;
+    /**
+     * Check if canary metrics indicate healthy deployment
+     */
+    private isCanaryHealthy;
+    /**
+     * Wait between canary phases
+     */
+    private waitBetweenPhases;
+    /**
+     * Promote canary deployment to production
+     */
+    private promoteToProduction;
+    /**
+     * Validate post-deployment health
+     */
+    private validatePostDeployment;
+    /**
+     * Rollback deployment on failure
+     */
+    private rollbackDeployment;
+    /**
+     * Calculate wait time before retry using backoff strategy
+     */
+    private waitBeforeRetry;
+}

package/dist/postprocessor/redeploy/RetryHandler.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Retry Handler for Redeploy Operations
+ */
+export interface RetryConfig {
+    maxRetries: number;
+    baseDelay: number;
+    backoffStrategy: "linear" | "exponential";
+}
+export interface RetryableError {
+    type?: string;
+    code?: string;
+    statusCode?: number;
+}
+export declare class RetryHandler {
+    private config;
+    constructor(config?: RetryConfig);
+    /**
+     * Execute an operation with retry logic
+     */
+    executeWithRetry<T>(operation: () => Promise<T>, shouldRetry?: (error: RetryableError, attempt: number) => boolean): Promise<T>;
+    /**
+     * Calculate delay based on backoff strategy
+     */
+    private calculateDelay;
+    /**
+     * Wait for the specified duration
+     */
+    private wait;
+    /**
+     * Default retry conditions for deployment operations
+     */
+    static shouldRetryDeployment(error: RetryableError, attempt: number): boolean;
+    /**
+     * Specialized retry handler for deployment operations
+     */
+    executeDeploymentWithRetry<T>(deploymentOperation: () => Promise<T>): Promise<T>;
+    /**
+     * Specialized retry handler for API calls
+     */
+    executeApiCallWithRetry<T>(apiCall: () => Promise<T>): Promise<T>;
+    /**
+     * Get retry statistics
+     */
+    getStats(): {
+        maxRetries: number;
+        baseDelay: number;
+        backoffStrategy: string;
+    };
+}

package/dist/postprocessor/services/RegressionAnalysisService.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Regression Analysis Service
+ *
+ * Systematically analyzes PostProcessor operations to detect regressions,
+ * AI code removal attempts, and other critical issues.
+ * Triggers multi-agent conferences when analysis is required.
+ *
+ * @since 2026-03-08
+ */
+import { PostProcessorContext } from '../types.js';
+export interface AnalysisDecision {
+    required: boolean;
+    reason?: string;
+    agents?: string[];
+    depth?: 'shallow' | 'deep' | 'comprehensive';
+    confidence?: number;
+}
+/**
+ * Main service for systematic regression analysis
+ */
+export declare class RegressionAnalysisService {
+    private kernel;
+    /**
+     * Determine if regression analysis is required for this context
+     */
+    shouldAnalyze(context: PostProcessorContext): Promise<AnalysisDecision>;
+    /**
+     * Invoke regression analysis with appropriate agents
+     */
+    invokeAnalysis(context: PostProcessorContext, decision: AnalysisDecision): Promise<void>;
+    /**
+     * Validate that no regression was introduced after operation
+     */
+    validateNoRegression(context: PostProcessorContext): Promise<void>;
+    /**
+     * Detect if operation is attempting to remove code
+     */
+    private isCodeRemovalAttempt;
+}