0xray 3.4.2 → 3.4.4

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;
+}

package/dist/postprocessor/success/SuccessHandler.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Success Handler for Post-Processor
+ *
+ * Handles successful post-processor operations including metrics collection,
+ * notifications, cleanup, and reporting.
+ */
+import { PostProcessorContext, PostProcessorResult, MonitoringResult } from "../types.js";
+export interface SuccessHandlerConfig {
+    successConfirmation?: boolean;
+    cleanupEnabled?: boolean;
+    notificationEnabled?: boolean;
+    metricsCollection?: boolean;
+}
+export interface SuccessMetrics {
+    totalDuration: number;
+    attempts: number;
+    fixesApplied: number;
+    monitoringChecks: number;
+    redeployments: number;
+    timestamp: Date;
+}
+export declare class SuccessHandler {
+    private config;
+    constructor(config?: SuccessHandlerConfig);
+    /**
+     * Handle successful post-processor completion
+     */
+    handleSuccess(context: PostProcessorContext, result: PostProcessorResult, monitoringResults: MonitoringResult[]): Promise<SuccessMetrics>;
+    /**
+     * Confirm deployment success
+     */
+    private confirmSuccess;
+    /**
+     * Send success notifications
+     */
+    private sendNotifications;
+    /**
+     * Perform post-success cleanup
+     */
+    private performCleanup;
+    /**
+     * Collect success metrics
+     */
+    private collectMetrics;
+    /**
+     * Log success metrics
+     */
+    private logMetrics;
+    /**
+     * Generate comprehensive success report
+     */
+    generateSuccessReport(context: PostProcessorContext, result: PostProcessorResult, metrics: SuccessMetrics): string;
+    /**
+     * Get current configuration stats
+     */
+    getStats(): SuccessHandlerConfig;
+}

package/dist/postprocessor/triggers/APITrigger.d.ts

@@ -0,0 +1,34 @@
+/**
+ * API Trigger for Post-Processor
+ *
+ * Provides a REST API endpoint to manually trigger PostProcessor
+ * operations. Useful for CI/CD pipelines, manual test triggers,
+ * and retry mechanisms.
+ *
+ * @since 2026-03-08
+ */
+import express from 'express';
+import { PostProcessor } from '../PostProcessor.js';
+import { PostProcessorContext } from '../types.js';
+export interface APIConfig {
+    path?: string;
+    apiKey?: string;
+    enabled?: boolean;
+}
+export interface APIRequest {
+    tool?: string;
+    operation?: string;
+    reason?: string;
+}
+export declare class APITrigger {
+    private postProcessor;
+    private initialized;
+    private app;
+    private config;
+    constructor(postProcessor: PostProcessor, config: APIConfig);
+    initialize(): Promise<void>;
+    private setupAPIEndpoints;
+    triggerPostProcessor(context: PostProcessorContext): Promise<void>;
+    getApp(): express.Application;
+    shutdown(): void;
+}

package/dist/postprocessor/triggers/GitHookTrigger.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Git Hook Trigger for Post-Processor
+ */
+import { PostProcessor } from "../PostProcessor.js";
+import { PostProcessorContext } from "../types.js";
+interface LogArchiveConfig {
+    archiveDirectory: string;
+    maxFileSizeMB: number;
+    rotationIntervalHours: number;
+    compressionEnabled: boolean;
+    maxAgeHours: number;
+    directories: string[];
+    excludePatterns: string[];
+}
+export { cleanupLogFiles };
+export { archiveLogFiles };
+/**
+ * Archive and rotate log files to prevent unbounded growth
+ */
+declare function archiveLogFiles(config: LogArchiveConfig): Promise<{
+    archived: number;
+    errors: string[];
+}>;
+declare function cleanupLogFiles(config: any): Promise<{
+    cleaned: number;
+    errors: string[];
+}>;
+export declare class GitHookTrigger {
+    private postProcessor;
+    private initialized;
+    constructor(postProcessor: PostProcessor);
+    initialize(): Promise<void>;
+    private installHook;
+    private generateHookScript;
+    private activateGitHooks;
+    private backupExistingHook;
+    triggerPostProcessor(context: PostProcessorContext): Promise<void>;
+}

package/dist/postprocessor/triggers/WebhookTrigger.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Webhook Trigger for Post-Processor
+ *
+ * Provides a generic webhook server that receives events from external
+ * services (GitHub, GitLab, Bitbucket, Stripe) and routes them
+ * to the PostProcessor for execution.
+ *
+ * @since 2026-03-08
+ */
+import express from 'express';
+import { PostProcessor } from '../PostProcessor.js';
+import { PostProcessorContext } from '../types.js';
+export interface WebhookConfig {
+    secret?: string;
+    provider?: 'github' | 'gitlab' | 'bitbucket' | 'stripe';
+    events?: string[];
+    path?: string;
+    verifySignature?: boolean;
+}
+export interface WebhookEvent {
+    provider: string;
+    event: string;
+    payload: unknown;
+    headers: Record<string, string>;
+    signature?: string;
+}
+export declare class WebhookTrigger {
+    private postProcessor;
+    private initialized;
+    private app;
+    private config;
+    constructor(postProcessor: PostProcessor, config?: WebhookConfig);
+    initialize(): Promise<void>;
+    private setupWebhookEndpoint;
+    private verifySignature;
+    /**
+     * Extract files from webhook payload
+     *
+     * Different webhook providers have different payload structures.
+     * This method extracts files in a unified way.
+     */
+    private extractFilesFromPayload;
+    triggerPostProcessor(context: PostProcessorContext): Promise<void>;
+    getApp(): express.Application;
+    shutdown(): void;
+}

package/dist/postprocessor/types.d.ts

@@ -0,0 +1,227 @@
+/**
+ * Post-Processor Type Definitions
+ */
+export interface PostProcessorConfig {
+    triggers: {
+        gitHooks: boolean;
+        webhooks: boolean;
+        api: boolean;
+    };
+    monitoring: {
+        enabled: boolean;
+        interval: number;
+        timeout: number;
+    };
+    autoFix: {
+        enabled: boolean;
+        confidenceThreshold: number;
+        maxAttempts: number;
+    };
+    maxAttempts: number;
+    retryDelay: number;
+    escalation: {
+        manualInterventionThreshold: number;
+        rollbackThreshold: number;
+        emergencyThreshold: number;
+    };
+    redeploy: {
+        maxRetries: number;
+        retryDelay: number;
+        backoffStrategy: "linear" | "exponential";
+        canaryEnabled: boolean;
+        canaryPhases: number;
+        canaryTrafficIncrement: number;
+        healthCheckTimeout: number;
+        rollbackOnFailure: boolean;
+    };
+    success: {
+        successConfirmation: boolean;
+        cleanupEnabled: boolean;
+        notificationEnabled: boolean;
+        metricsCollection: boolean;
+    };
+    reporting: {
+        enabled: boolean;
+        autoGenerate: boolean;
+        reportThreshold: number;
+        reportDir: string;
+        retentionDays: number;
+    };
+}
+export interface PostProcessorContext {
+    commitSha: string;
+    repository: string;
+    branch: string;
+    author: string;
+    files: string[];
+    trigger: "git-hook" | "webhook" | "api" | "manual";
+    tool?: string | undefined;
+    operation?: string | undefined;
+    testResults?: {
+        unit?: {
+            passed: boolean;
+            coverage: number;
+        };
+        integration?: {
+            passed: boolean;
+            coverage: number;
+        };
+        e2e?: {
+            passed: boolean;
+            coverage: number;
+        };
+        performance?: {
+            passed: boolean;
+            coverage: number;
+        };
+    };
+    directory?: string;
+    filePath?: string;
+    args?: Record<string, unknown>;
+}
+export interface PostProcessorResult {
+    success: boolean;
+    commitSha: string;
+    sessionId: string;
+    attempts: number;
+    monitoringResults?: MonitoringResult[];
+    fixesApplied?: AppliedFix[];
+    error?: string;
+    duration?: number;
+}
+export interface MonitoringResult {
+    commitSha: string;
+    overallStatus: "success" | "failure" | "running";
+    timestamp: Date;
+    ciStatus?: CIStatus;
+    performanceStatus?: PerformanceStatus;
+    securityStatus?: SecurityStatus;
+    failedJobs?: string[];
+    duration: number;
+}
+export interface AppliedFix {
+    type: string;
+    files: string[];
+    description: string;
+    timestamp: Date;
+    rollbackData?: unknown;
+}
+export interface FixResult {
+    success: boolean;
+    appliedFixes: AppliedFix[];
+    requiresManualIntervention: boolean;
+    confidence: number;
+    rollbackAvailable: boolean;
+}
+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 interface FailureAnalysis {
+    category: string;
+    severity: "low" | "medium" | "high" | "critical";
+    confidence: number;
+    rootCause: string;
+    recommendedActions: string[];
+    suggestedFixes: SuggestedFix[];
+}
+export interface SuggestedFix {
+    type: "dependency-update" | "code-fix" | "config-change" | "test-regeneration";
+    confidence: number;
+    description: string;
+    files: string[];
+    changes: (Record<string, unknown> | string)[];
+}
+export interface FixResult {
+    success: boolean;
+    appliedFixes: AppliedFix[];
+    requiresManualIntervention: boolean;
+    confidence: number;
+    rollbackAvailable: boolean;
+}
+export interface EscalationResult {
+    level: "manual-intervention" | "rollback" | "emergency";
+    reason: string;
+    recommendations: string[];
+    incidentReport: IncidentReport;
+}
+export interface IncidentReport {
+    id: string;
+    commitSha: string;
+    timestamp: Date;
+    severity: string;
+    affectedSystems: string[];
+    rootCause: string;
+    impact: string;
+    resolution: string;
+    timeline: EventTimeline[];
+}
+export interface EventTimeline {
+    timestamp: Date;
+    event: string;
+    details: string;
+}
+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 type PostProcessorEvent = {
+    type: "initialized";
+    config: PostProcessorConfig;
+} | {
+    type: "loop-started";
+    context: PostProcessorContext;
+} | {
+    type: "monitoring-completed";
+    result: MonitoringResult;
+} | {
+    type: "failure-detected";
+    analysis: FailureAnalysis;
+} | {
+    type: "fix-applied";
+    result: FixResult;
+} | {
+    type: "redeployment-initiated";
+    commitSha: string;
+} | {
+    type: "loop-completed";
+    result: PostProcessorResult;
+} | {
+    type: "escalation-triggered";
+    result: EscalationResult;
+} | {
+    type: "error";
+    error: Error;
+    context: PostProcessorContext;
+};

package/dist/processors/doc-write-guard.d.ts

@@ -0,0 +1,6 @@
+export declare class DocWriteGuard {
+    static append(filePath: string, content: string): Promise<void>;
+    static createIfMissing(filePath: string, content: string): Promise<void>;
+    static isDocFile(filePath: string): boolean;
+    static isDocPath(filePath: string): boolean;
+}

package/dist/processors/implementations/agents-md-validation-processor.d.ts

@@ -0,0 +1,62 @@
+/**
+ * AGENTS.md Validation Processor
+ *
+ * Pre-processor that validates AGENTS.md exists and is up-to-date before
+ * allowing commits. Integrates with 0xRay's processor pipeline.
+ *
+ * @processor_type pre
+ * @priority 90 (high - runs early)
+ * @blocking true (blocks commit if AGENTS.md is invalid)
+ *
+ * @framework 0xRay 1.3.5
+ */
+export interface AgentsMdValidationResult {
+    valid: boolean;
+    errors: string[];
+    warnings: string[];
+    fixes?: string[];
+}
+export declare class AgentsMdValidationProcessor {
+    private projectRoot;
+    private agentsPath;
+    private readonly REQUIRED_SECTIONS;
+    private readonly REQUIRED_AGENTS;
+    private readonly RECOMMENDED_SECTIONS;
+    constructor(projectRoot?: string);
+    /**
+     * Main execution method - called by ProcessorManager
+     */
+    execute(context: {
+        tool: string;
+        args?: {
+            filePath?: string;
+            content?: string;
+        };
+        operation: string;
+    }): Promise<{
+        success: boolean;
+        blocked: boolean;
+        message: string;
+        result?: AgentsMdValidationResult;
+    }>;
+    /**
+     * Determine if the change is agent-related
+     */
+    private isAgentRelatedChange;
+    /**
+     * Validate AGENTS.md file
+     */
+    private validateAgentsMd;
+    /**
+     * Calculate days since date
+     */
+    private calculateDaysOld;
+    private getPackageVersion;
+    private getSectionTemplate;
+    appendMissing(): Promise<{
+        success: boolean;
+        message: string;
+        added: string[];
+    }>;
+}
+export declare const agentsMdValidationProcessor: AgentsMdValidationProcessor;