0xray 2.0.0 → 2.0.1

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/monitoring/MonitoringEngine.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Post-Processor Monitoring Engine
+ */
+import { StringRayStateManager } 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: StringRayStateManager, 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/services/RegressionAnalysisService.d.ts

@@ -0,0 +1,40 @@
+/**
+ * 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.
+ *
+ * @version 1.0.0
+ * @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,35 @@
+/**
+ * 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.
+ *
+ * @version 2.0.0
+ * @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,47 @@
+/**
+ * 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.
+ *
+ * @version 2.0.0
+ * @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;
+}