0xray 4.0.34 → 4.0.36

package/dist/postprocessor/integration.js

@@ -1,194 +0,0 @@
-/**
- * 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
- */
-export { WebhookTrigger } from './triggers/WebhookTrigger.js';
-export { APITrigger } 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 class XrayIntegration {
-    postProcessor;
-    webhookTrigger = null;
-    apiTrigger = null;
-    constructor(postProcessor) {
-        this.postProcessor = postProcessor;
-    }
-    /**
-     * Initialize all triggers with default configuration
-     *
-     * @param config - Optional configuration for triggers
-     */
-    async initialize(config) {
-        const { WebhookTrigger } = await import('./triggers/WebhookTrigger.js');
-        const { APITrigger } = await import('./triggers/APITrigger.js');
-        // Initialize webhook trigger with default GitHub config
-        this.webhookTrigger = new WebhookTrigger(this.postProcessor, {
-            provider: 'github',
-            events: ['push', 'pull_request'],
-            path: '/webhooks/github',
-            verifySignature: true,
-            ...config?.webhook
-        });
-        await this.webhookTrigger.initialize();
-        // Initialize API trigger with default config
-        this.apiTrigger = new APITrigger(this.postProcessor, {
-            enabled: true,
-            path: '/api/post-process',
-            ...config?.api
-        });
-        await this.apiTrigger.initialize();
-    }
-    /**
-     * 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() {
-        return this.webhookTrigger?.getApp() ?? null;
-    }
-    /**
-     * Get webhook router (raw Express router)
-     *
-     * Useful for frameworks that need the router instance directly
-     * rather than the full Express app.
-     */
-    getWebhookRouter() {
-        return this.webhookTrigger?.getApp() ?? 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() {
-        return this.apiTrigger?.getApp() ?? null;
-    }
-    /**
-     * Get API trigger router (raw Express router)
-     *
-     * Useful for frameworks that need the router instance directly.
-     */
-    getAPIRouter() {
-        return this.apiTrigger?.getApp() ?? 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'
-     * });
-     * ```
-     */
-    async trigger(options) {
-        const context = {
-            commitSha: `manual-${Date.now()}`,
-            repository: '',
-            branch: '',
-            author: 'manual',
-            files: [],
-            trigger: 'manual',
-            tool: options.tool,
-            operation: options.operation,
-            ...(options.filePath !== undefined ? { filePath: options.filePath } : {}),
-            ...(options.directory !== undefined ? { directory: options.directory } : {}),
-        };
-        await this.postProcessor.executePostProcessorLoop(context);
-    }
-    /**
-     * Shutdown all triggers
-     */
-    async shutdown() {
-        if (this.webhookTrigger) {
-            this.webhookTrigger.shutdown();
-        }
-        if (this.apiTrigger) {
-            this.apiTrigger.shutdown();
-        }
-    }
-}
-/**
- * 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 function createXrayIntegration(postProcessor) {
-    return new XrayIntegration(postProcessor);
-}
-// Backward compat aliases

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

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

package/dist/postprocessor/metamorphosis/index.js

@@ -1 +0,0 @@
-export { SelfProposalEngine } from './SelfProposalEngine.js';

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

@@ -1,49 +0,0 @@
-/**
- * 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/redeploy/RetryHandler.js

@@ -1,118 +0,0 @@
-/**
- * Retry Handler for Redeploy Operations
- */
-import { frameworkLogger } from "../../core/framework-logger.js";
-export class RetryHandler {
-    config;
-    constructor(config = {
-        maxRetries: 3,
-        baseDelay: 30000,
-        backoffStrategy: "exponential",
-    }) {
-        this.config = config;
-    }
-    /**
-     * Execute an operation with retry logic
-     */
-    async executeWithRetry(operation, shouldRetry) {
-        let lastError = {};
-        for (let attempt = 0; attempt <= this.config.maxRetries; attempt++) {
-            try {
-                return await operation();
-            }
-            catch (error) {
-                const retryable = error;
-                lastError = retryable;
-                // Don't retry on the last attempt
-                if (attempt === this.config.maxRetries) {
-                    break;
-                }
-                // Check if we should retry this error
-                if (shouldRetry && !shouldRetry(retryable, attempt)) {
-                    break;
-                }
-                // Calculate delay and wait
-                const delay = this.calculateDelay(attempt);
-                await frameworkLogger.log("-retry-handler", "-operation-failed-attempt-attempt-1-retrying-in-de", "error", {
-                    message: `⏳ Operation failed (attempt ${attempt + 1}), retrying in ${delay}ms...`,
-                });
-                await this.wait(delay);
-            }
-        }
-        throw lastError;
-    }
-    /**
-     * Calculate delay based on backoff strategy
-     */
-    calculateDelay(attempt) {
-        const { baseDelay, backoffStrategy } = this.config;
-        switch (backoffStrategy) {
-            case "exponential":
-                return baseDelay * Math.pow(2, attempt);
-            case "linear":
-                return baseDelay * (attempt + 1);
-            default:
-                return baseDelay;
-        }
-    }
-    /**
-     * Wait for the specified duration
-     */
-    async wait(duration) {
-        return new Promise((resolve) => setTimeout(resolve, duration));
-    }
-    /**
-     * Default retry conditions for deployment operations
-     */
-    static shouldRetryDeployment(error, attempt) {
-        // Don't retry certain types of errors
-        const nonRetryableErrors = [
-            "authentication_failed",
-            "authorization_failed",
-            "invalid_configuration",
-            "quota_exceeded",
-        ];
-        if (nonRetryableErrors.some((type) => error.type?.includes(type))) {
-            return false;
-        }
-        // Don't retry after too many attempts for transient errors
-        if (attempt >= 2 && error.type === "transient") {
-            return false;
-        }
-        // Retry network and timeout errors
-        if (error.code === "ECONNRESET" ||
-            error.code === "ETIMEDOUT" ||
-            error.code === "ENOTFOUND") {
-            return true;
-        }
-        // Retry 5xx HTTP errors
-        if (error.statusCode >= 500 && error.statusCode < 600) {
-            return true;
-        }
-        // Default: retry for most errors
-        return true;
-    }
-    /**
-     * Specialized retry handler for deployment operations
-     */
-    async executeDeploymentWithRetry(deploymentOperation) {
-        return this.executeWithRetry(deploymentOperation, RetryHandler.shouldRetryDeployment);
-    }
-    /**
-     * Specialized retry handler for API calls
-     */
-    async executeApiCallWithRetry(apiCall) {
-        return this.executeWithRetry(apiCall, (error, attempt) => {
-            // Retry on network errors and 5xx status codes
-            return (error.code === "ECONNRESET" ||
-                error.code === "ETIMEDOUT" ||
-                (error.statusCode >= 500 && error.statusCode < 600));
-        });
-    }
-    /**
-     * Get retry statistics
-     */
-    getStats() {
-        return { ...this.config };
-    }
-}

package/dist/processors/implementations/session-capture-processor.d.ts

@@ -1,14 +0,0 @@
-/**
- * Session Capture Processor
- *
- * Extracted from InferenceImprovementProcessor - handles discovery of
- * session data sources (reflections, logs, reports) for inference workflows.
- *
- * @module processors/implementations
- */
-export declare class SessionCapture {
-    static findReflections(directory: string, reflectionsDir: string): string[];
-    static findLogs(directory: string, logsDir: string): string[];
-    static findReports(directory: string, reportsDir: string): string[];
-}
-export default SessionCapture;

package/dist/processors/implementations/session-capture-processor.js

@@ -1,37 +0,0 @@
-/**
- * Session Capture Processor
- *
- * Extracted from InferenceImprovementProcessor - handles discovery of
- * session data sources (reflections, logs, reports) for inference workflows.
- *
- * @module processors/implementations
- */
-import * as fs from "fs";
-import * as path from "path";
-export class SessionCapture {
-    static findReflections(directory, reflectionsDir) {
-        const reflectionsPath = path.join(directory, reflectionsDir);
-        if (!fs.existsSync(reflectionsPath))
-            return [];
-        return fs.readdirSync(reflectionsPath)
-            .filter(f => f.endsWith(".md"))
-            .map(f => path.join(reflectionsPath, f));
-    }
-    static findLogs(directory, logsDir) {
-        const logsPath = path.join(directory, logsDir);
-        if (!fs.existsSync(logsPath))
-            return [];
-        return fs.readdirSync(logsPath)
-            .filter(f => f.includes("routing") || f.includes("activity") || f.includes("session"))
-            .map(f => path.join(logsPath, f));
-    }
-    static findReports(directory, reportsDir) {
-        const reportsPath = path.join(directory, reportsDir);
-        if (!fs.existsSync(reportsPath))
-            return [];
-        return fs.readdirSync(reportsPath)
-            .filter(f => f.endsWith(".json") || f.endsWith(".md"))
-            .map(f => path.join(reportsPath, f));
-    }
-}
-export default SessionCapture;

package/dist/public/XrayService.d.ts

@@ -1,17 +0,0 @@
-import type { BeforeHookResult, AfterHookResult } from "../integrations/enforcement-gate.js";
-export interface XrayServiceConfig {
-    enabled?: boolean;
-    strictMode?: boolean;
-    logLevel?: string;
-}
-export declare class XrayService {
-    private config;
-    private initialized;
-    constructor(config?: XrayServiceConfig);
-    init(): Promise<void>;
-    beforeTool(tool: string, args: Record<string, unknown> | null, context?: {
-        directory?: string;
-    }): Promise<BeforeHookResult>;
-    afterTool(tool: string, args: Record<string, unknown> | null, result: unknown, error?: string | null): Promise<AfterHookResult>;
-    shutdown(): void;
-}

package/dist/public/XrayService.js

@@ -1,40 +0,0 @@
-import { frameworkLogger } from "../core/framework-logger.js";
-import { beforeToolHook, afterToolHook } from "../integrations/enforcement-gate.js";
-const defaultConfig = {
-    enabled: true,
-    strictMode: false,
-    logLevel: "info",
-};
-export class XrayService {
-    config;
-    initialized = false;
-    constructor(config) {
-        this.config = { ...defaultConfig, ...config };
-    }
-    async init() {
-        if (this.initialized)
-            return;
-        await frameworkLogger.log("XrayService", "init", "info", {
-            message: "XrayService initialized",
-            config: this.config,
-        });
-        this.initialized = true;
-    }
-    async beforeTool(tool, args, context) {
-        if (!this.config.enabled) {
-            return { allowed: true, blocked: false, violations: [], resonance: 1, duration: 0 };
-        }
-        const gateCtx = context ? { ...(context.directory ? { directory: context.directory } : {}) } : undefined;
-        return beforeToolHook(tool, args, gateCtx);
-    }
-    async afterTool(tool, args, result, error = null) {
-        if (!this.config.enabled) {
-            return { processed: false, violations: [], processorResults: [], governanceTriggered: false, duration: 0 };
-        }
-        return afterToolHook(tool, args, result, error);
-    }
-    shutdown() {
-        this.initialized = false;
-        frameworkLogger.log("XrayService", "shutdown", "info", { message: "XrayService shut down" });
-    }
-}

package/dist/public/index.d.ts

@@ -1,4 +0,0 @@
-export { XrayService } from "./XrayService.js";
-export type { XrayServiceConfig } from "./XrayService.js";
-export { beforeToolHook, afterToolHook } from "../integrations/enforcement-gate.js";
-export type { BeforeHookResult, AfterHookResult, GateViolation } from "../integrations/enforcement-gate.js";

package/dist/public/index.js

@@ -1,2 +0,0 @@
-export { XrayService } from "./XrayService.js";
-export { beforeToolHook, afterToolHook } from "../integrations/enforcement-gate.js";

package/dist/security/comprehensive-security-audit.d.ts

@@ -1,157 +0,0 @@
-/**
- * 0xRay Comprehensive Security Audit System
- *
- * Multi-agent security audit system with vulnerability scanning,
- * automated remediation, compliance checking, and weighted voting
- * for architectural decisions.
- *
- */
-export type SeverityLevel = "critical" | "high" | "medium" | "low" | "info";
-export type ComplianceStandard = "owasp-top-10" | "cwe" | "nist" | "iso-27001" | "pci-dss";
-export interface Vulnerability {
-    id: string;
-    title: string;
-    severity: SeverityLevel;
-    category: VulnerabilityCategory;
-    cwe: string;
-    owasp?: string | undefined;
-    file: string;
-    line: number;
-    column?: number | undefined;
-    description: string;
-    impact: string;
-    recommendation: string;
-    codeSnippet: string;
-    confidence: number;
-    autoRemediation?: RemediationStep[] | undefined;
-}
-export type VulnerabilityCategory = "injection" | "authentication" | "authorization" | "cryptography" | "configuration" | "data-protection" | "input-validation" | "sensitive-data-exposure" | "security-misconfiguration" | "dependency-vulnerability";
-export interface RemediationStep {
-    step: number;
-    action: string;
-    code?: string | undefined;
-    file?: string | undefined;
-    line?: number | undefined;
-    estimatedEffort: "low" | "medium" | "high";
-    automated: boolean;
-}
-export interface SecurityAuditConfig {
-    projectPath: string;
-    scanDepth?: "shallow" | "medium" | "deep";
-    includeDependencies?: boolean;
-    complianceStandards?: ComplianceStandard[];
-    enableAutoRemediation?: boolean;
-    enableWeightedVoting?: boolean;
-    agentWeights?: Record<string, number>;
-    outputPath?: string | undefined;
-}
-export interface WeightedVote {
-    agentId: string;
-    agentName: string;
-    vote: "approve" | "reject" | "abstain";
-    weight: number;
-    reasoning: string;
-    concerns?: string[] | undefined;
-}
-export interface ArchitecturalDecision {
-    id: string;
-    title: string;
-    description: string;
-    proposedBy: string;
-    votes: WeightedVote[];
-    finalDecision: "approved" | "rejected" | "needs-revision";
-    approvedBy: WeightedVote[];
-    rejectedBy: WeightedVote[];
-    timestamp: Date;
-}
-export interface ComplianceResult {
-    standard: ComplianceStandard;
-    passed: boolean;
-    score: number;
-    findings: Vulnerability[];
-    recommendations: string[];
-}
-export interface SecurityAuditReport {
-    metadata: {
-        auditId: string;
-        timestamp: Date;
-        projectPath: string;
-        totalFilesScanned: number;
-        duration: number;
-    };
-    summary: {
-        totalVulnerabilities: number;
-        bySeverity: Record<SeverityLevel, number>;
-        byCategory: Record<VulnerabilityCategory, number>;
-        securityScore: number;
-        complianceScore: number;
-    };
-    vulnerabilities: Vulnerability[];
-    compliance: ComplianceResult[];
-    remediation: {
-        totalIssues: number;
-        automatable: number;
-        manualRequired: number;
-        estimatedFixTime: string;
-        prioritizedFixes: RemediationPlan[];
-    };
-    architecturalDecisions: ArchitecturalDecision[];
-    agentConsensus: {
-        participatingAgents: string[];
-        averageAgreement: number;
-        contentiousIssues: Vulnerability[];
-    } | undefined;
-}
-export interface RemediationPlan {
-    vulnerabilityId: string;
-    title: string;
-    severity: SeverityLevel;
-    priority: number;
-    steps: RemediationStep[];
-    dependencies: string[];
-    estimatedTime: string;
-}
-export declare class ComprehensiveSecurityAuditSystem {
-    private config;
-    private vulnerabilities;
-    private architecturalDecisions;
-    private agentVotes;
-    private readonly severityWeights;
-    private readonly defaultAgentWeights;
-    private readonly dangerousPatterns;
-    constructor(config: SecurityAuditConfig);
-    runAudit(): Promise<SecurityAuditReport>;
-    private getProjectFiles;
-    private auditFile;
-    private createVulnerability;
-    private isFalsePositive;
-    private auditImports;
-    private auditDependencies;
-    private checkCompliance;
-    private evaluateStandard;
-    private evaluateOWASP;
-    private evaluateCWE;
-    private evaluateNIST;
-    private evaluateISO27001;
-    private evaluatePCIDSS;
-    private groupByCategory;
-    private generateRemediationPlan;
-    private prioritizeFixes;
-    private estimateFixTime;
-    private estimateFixTimeForVuln;
-    private calculateSummary;
-    private collectAgentVotes;
-    private simulateAgentVote;
-    private resolveArchitecturalDecisions;
-    private calculateAgentConsensus;
-    private saveReport;
-    generateMarkdownReport(report: SecurityAuditReport): string;
-    private getScoreEmoji;
-    private getSeverityEmoji;
-    addVote(vote: WeightedVote): void;
-    getVulnerabilities(): Vulnerability[];
-    getArchitecturalDecisions(): ArchitecturalDecision[];
-}
-export declare function createSecurityAuditSystem(config: SecurityAuditConfig): ComprehensiveSecurityAuditSystem;
-export declare function runQuickSecurityAudit(projectPath: string): Promise<SecurityAuditReport>;
-export declare function runDeepSecurityAudit(projectPath: string, outputPath?: string): Promise<SecurityAuditReport>;