0xray 3.4.1 → 3.4.3

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;

package/dist/processors/implementations/async-pattern-processor.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Async Pattern Processor
+ *
+ * Enforces codex term #31: Async Pattern Detection.
+ * Detects anti-patterns in async code: callback patterns, long promise chains,
+ * missing await inside async functions, and mixed callback/promise styles.
+ *
+ * @since 2026-03-28
+ */
+import type { PreValidateContext, ProcessorExecutionResult } from "../processor-types.js";
+export type AsyncViolationType = "callbackPattern" | "longPromiseChain" | "missingAwait" | "mixedCallbackAsync";
+export interface AsyncViolation {
+    type: AsyncViolationType;
+    line?: number;
+    message: string;
+    snippet?: string;
+}
+export declare class AsyncPatternProcessor {
+    /**
+     * Run all async-pattern checks against `content`.
+     */
+    checkCode(content: string): AsyncViolation[];
+    /**
+     * Detect node-style callbacks: `function(err, ` or inline function callbacks.
+     */
+    hasCallbackPattern(content: string): boolean;
+    /**
+     * Detect promise chains with more than 3 .then() calls.
+     */
+    hasLongPromiseChain(content: string): boolean;
+    /**
+     * Detect async functions that contain .then() or `new Promise` without an
+     * accompanying await in the same scope.
+     */
+    hasMissingAwait(content: string): boolean;
+    /**
+     * Detect callbacks used inside async functions.
+     */
+    hasMixedCallbackAsync(content: string): boolean;
+    private countPromiseChains;
+    /**
+     * Within an async function body, check if .then() or new Promise is used
+     * without await. If so, return a marker string; otherwise return original.
+     */
+    private _checkAsyncBodyForMissingAwait;
+}
+export declare function runAsyncPatternCheck(context: PreValidateContext): Promise<ProcessorExecutionResult>;

package/dist/processors/implementations/codex-compliance-processor.d.ts

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

package/dist/processors/implementations/commit-batcher-processor.d.ts

@@ -0,0 +1,13 @@
+import { PostProcessor } from "../processor-interfaces.js";
+import type { ProcessorContext, ProcessorResult } from "../processor-types.js";
+import { IntelligentCommitBatcher } from "../../orchestrator/intelligent-commit-batcher.js";
+export declare class CommitBatcherProcessor extends PostProcessor {
+    readonly name = "commitBatcher";
+    readonly priority = 85;
+    private trackedCount;
+    private batcher;
+    constructor(batcher?: IntelligentCommitBatcher);
+    protected run(context: ProcessorContext): Promise<Record<string, unknown>>;
+    private inferChangeType;
+}
+export declare function executeCommitBatcherProcessor(context: ProcessorContext): Promise<ProcessorResult>;

package/dist/processors/implementations/console-log-guard-processor.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Console Log Guard Processor
+ *
+ * Enforces codex term #33: Console Log Guard.
+ * Scans code for forbidden console.log/warn/error/info/debug usage,
+ * ensuring all logging goes through frameworkLogger instead.
+ *
+ * @since 2026-03-28
+ */
+import type { PreValidateContext, ProcessorExecutionResult } from "../processor-types.js";
+export interface ConsoleLogViolation {
+    line: number;
+    type: "log" | "warn" | "error" | "info" | "debug";
+    matched: string;
+}
+export declare class ConsoleLogGuardProcessor {
+    /**
+     * Scan code content for forbidden console method calls.
+     * Returns violations with line numbers.
+     */
+    checkCode(content: string, filePath?: string): ConsoleLogViolation[];
+    /**
+     * Determine if a file path points to a test file.
+     */
+    isTestFile(filePath: string): boolean;
+    /**
+     * Remove single-line (//) and multi-line comments from source code.
+     * Preserves line structure so line numbers remain valid.
+     */
+    stripComments(content: string): string;
+}
+export declare function runConsoleLogGuard(context: PreValidateContext): Promise<ProcessorExecutionResult>;

package/dist/processors/implementations/coverage-analysis-processor.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Coverage Analysis Processor
+ *
+ * Analyzes test coverage for modified files and reports coverage gaps.
+ *
+ * @module processors/implementations
+ */
+import { PostProcessor } from "../processor-interfaces.js";
+import { ProcessorContext } from "../processor-types.js";
+export declare class CoverageAnalysisProcessor extends PostProcessor {
+    readonly name = "coverageAnalysis";
+    readonly priority = 45;
+    protected run(context: ProcessorContext): Promise<unknown>;
+    private analyzeCoverage;
+    private findRelatedTestFiles;
+    private countSourceLines;
+    private countTestLines;
+}
+export declare const coverageAnalysisProcessor: CoverageAnalysisProcessor;

package/dist/processors/implementations/error-boundary-processor.d.ts

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

package/dist/processors/implementations/inference-improvement-processor.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Inference Improvement Coordinator
+ *
+ * Lightweight processor that coordinates the agent-based inference workflow.
+ * The actual analysis is done by collaborating agents (researcher, code-analyzer,
+ * architect, code-reviewer, enforcer) - this processor prepares context and triggers.
+ *
+ * @module processors/implementations
+ */
+import { PostProcessor } from "../processor-interfaces.js";
+export declare class InferenceImprovementProcessor extends PostProcessor {
+    readonly name = "inferenceImprovement";
+    readonly priority = 5;
+    private readonly reflectionsDir;
+    private readonly logsDir;
+    private readonly reportsDir;
+    private readonly workflowDir;
+    private readonly inferenceEnabled;
+    private readonly patternMatchingEnabled;
+    private readonly patternMatchingThreshold;
+    constructor();
+    private loadInferenceConfig;
+    protected run(context: unknown): Promise<unknown>;
+    private prepareWorkflowContext;
+    private findReflections;
+    private findLogs;
+    private findReports;
+    private saveWorkflowContext;
+    private generateAgentPrompts;
+    private generateResearcherPrompt;
+    private generateCodeAnalyzerPrompt;
+    private generateArchitectPrompt;
+    private generateCodeReviewerPrompt;
+    private generateEnforcerPrompt;
+    private triggerAgentWorkflow;
+}

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;