0xray 4.0.34 → 4.0.36

package/dist/analytics/consent-manager.js

@@ -1,257 +0,0 @@
-/**
- * Consent Manager for 0xRay Central Analytics
- *
- * Manages user consent for analytics data submission with granular
- * control over what categories can be shared.
- *
- * @since 2026-03-06
- */
-import * as fs from "fs/promises";
-import * as path from "path";
-import { frameworkLogger } from "../core/framework-logger.js";
-import { getConfigDir, resolveConfigPath } from "../core/config-paths.js";
-export class ConsentManager {
-    configPath;
-    config = null;
-    submissionQueue = [];
-    constructor(configPath = undefined) {
-        this.configPath = configPath || resolveConfigPath("consent.json") || path.join(getConfigDir(), "consent.json");
-    }
-    /**
-     * Initialize consent manager - load existing config or create default
-     */
-    async initialize() {
-        try {
-            await this.loadConfig();
-            if (!this.config) {
-                // Create default disabled configuration
-                this.config = this.createDefaultConfig();
-                await this.saveConfig();
-            }
-            return this.config;
-        }
-        catch (error) {
-            // If config doesn't exist, create default
-            this.config = this.createDefaultConfig();
-            await this.saveConfig();
-            return this.config;
-        }
-    }
-    /**
-     * Enable analytics (opt-in)
-     */
-    async enableConsent(categories) {
-        if (!this.config) {
-            await this.initialize();
-        }
-        if (!this.config) {
-            throw new Error("Failed to initialize consent configuration");
-        }
-        // Enable all categories if none specified
-        const categoriesToEnable = categories || Object.keys(this.config.categories);
-        // Enable main analytics flag
-        this.config.analyticsEnabled = true;
-        this.config.consentDate = new Date();
-        this.config.consentVersion = "1.0";
-        // Enable specified categories
-        categoriesToEnable.forEach(cat => {
-            if (this.config && cat in this.config.categories) {
-                this.config.categories[cat] = true;
-            }
-        });
-        // Generate project ID if not exists
-        if (!this.config.projectId || this.config.projectId === "") {
-            this.config.projectId = this.generateProjectId();
-        }
-        await this.saveConfig();
-    }
-    /**
-     * Disable analytics (opt-out)
-     */
-    async disableConsent() {
-        if (!this.config) {
-            await this.initialize();
-        }
-        if (!this.config) {
-            throw new Error("Failed to initialize consent configuration");
-        }
-        // Disable all analytics
-        this.config.analyticsEnabled = false;
-        this.config.lastOptOut = new Date();
-        // Disable all categories
-        Object.keys(this.config.categories).forEach(cat => {
-            this.config.categories[cat] = false;
-        });
-        await this.saveConfig();
-        // Clear submission queue
-        await this.clearSubmissionQueue();
-    }
-    /**
-     * Check if submission is allowed for a category
-     */
-    canSubmit(category) {
-        if (!this.config) {
-            return false;
-        }
-        return this.config.analyticsEnabled &&
-            this.config.categories[category] === true;
-    }
-    /**
-     * Get current consent status
-     */
-    async getStatus() {
-        if (!this.config) {
-            await this.initialize();
-        }
-        if (!this.config) {
-            throw new Error("Failed to load consent configuration");
-        }
-        return { ...this.config };
-    }
-    /**
-     * Enable specific category
-     */
-    async enableCategory(category) {
-        if (!this.config) {
-            await this.initialize();
-        }
-        if (!this.config || !(category in this.config.categories)) {
-            throw new Error(`Invalid category: ${category}`);
-        }
-        this.config.categories[category] = true;
-        await this.saveConfig();
-    }
-    /**
-     * Disable specific category
-     */
-    async disableCategory(category) {
-        if (!this.config) {
-            await this.initialize();
-        }
-        if (!this.config || !(category in this.config.categories)) {
-            throw new Error(`Invalid category: ${category}`);
-        }
-        this.config.categories[category] = false;
-        await this.saveConfig();
-    }
-    /**
-     * Get all categories with their status
-     */
-    getCategories() {
-        if (!this.config) {
-            return [];
-        }
-        const categoryInfo = {
-            reflections: "Anonymized reflection data for pattern learning",
-            logs: "Framework activity logs for performance analysis",
-            metrics: "Agent performance and routing metrics",
-            patterns: "P9 pattern learning data and insights"
-        };
-        return Object.entries(this.config.categories).map(([name, enabled]) => ({
-            name,
-            description: categoryInfo[name] || "",
-            enabled: enabled
-        }));
-    }
-    /**
-     * Generate anonymous project ID
-     */
-    generateProjectId() {
-        // Generate UUID-like identifier
-        const timestamp = Date.now().toString(36);
-        const random = Math.random().toString(36).substring(2, 8);
-        return `project-${timestamp}-${random}`;
-    }
-    /**
-     * Create default disabled configuration
-     */
-    createDefaultConfig() {
-        return {
-            analyticsEnabled: false,
-            consentDate: new Date(),
-            consentVersion: "1.0",
-            lastOptOut: undefined,
-            categories: {
-                reflections: false,
-                logs: false,
-                metrics: false,
-                patterns: false
-            },
-            projectId: this.generateProjectId()
-        };
-    }
-    /**
-     * Load configuration from file
-     */
-    async loadConfig() {
-        try {
-            const configData = await fs.readFile(this.configPath, "utf-8");
-            this.config = JSON.parse(configData);
-            // Convert date strings back to Date objects
-            if (this.config.consentDate) {
-                this.config.consentDate = new Date(this.config.consentDate);
-            }
-            if (this.config.lastOptOut) {
-                this.config.lastOptOut = new Date(this.config.lastOptOut);
-            }
-        }
-        catch (error) {
-            // Config doesn't exist or is invalid
-            this.config = null;
-        }
-    }
-    /**
-     * Save configuration to file
-     */
-    async saveConfig() {
-        if (!this.config) {
-            throw new Error("No configuration to save");
-        }
-        // Ensure directory exists
-        const configDir = path.dirname(this.configPath);
-        try {
-            await fs.mkdir(configDir, { recursive: true });
-        }
-        catch {
-            // Directory already exists
-        }
-        await fs.writeFile(this.configPath, JSON.stringify(this.config, null, 2), "utf-8");
-    }
-    /**
-     * Clear submission queue
-     */
-    async clearSubmissionQueue() {
-        const queuePath = path.join(path.dirname(this.configPath), "analytics", "submission-queue.json");
-        try {
-            await fs.writeFile(queuePath, "[]", "utf-8");
-            this.submissionQueue = [];
-        }
-        catch (error) {
-            // Queue directory doesn't exist yet, which is fine
-        }
-    }
-    /**
-     * Add item to submission queue
-     */
-    async queueSubmission(data) {
-        if (!this.canSubmit("all")) {
-            throw new Error("Analytics is disabled or category not enabled");
-        }
-        this.submissionQueue.push(data);
-        await this.saveSubmissionQueue();
-    }
-    /**
-     * Save submission queue to file
-     */
-    async saveSubmissionQueue() {
-        const queueDir = path.join(path.dirname(this.configPath), "analytics");
-        const queuePath = path.join(queueDir, "submission-queue.json");
-        try {
-            await fs.mkdir(queueDir, { recursive: true });
-            await fs.writeFile(queuePath, JSON.stringify(this.submissionQueue, null, 2), "utf-8");
-        }
-        catch (error) {
-            frameworkLogger.log("consent-manager", "save-queue-failed", "error", { error, message: "Failed to save submission queue" });
-        }
-    }
-}

package/dist/benchmark/performance-benchmark.d.ts

@@ -1,103 +0,0 @@
-export interface BenchmarkResult {
-    operation: string;
-    startTime: number;
-    endTime: number;
-    duration: number;
-    success: boolean;
-    metadata: Record<string, any>;
-    error?: string | undefined;
-}
-export interface PerformanceMetrics {
-    totalOperations: number;
-    successfulOperations: number;
-    failedOperations: number;
-    averageDuration: number;
-    medianDuration: number;
-    p95Duration: number;
-    p99Duration: number;
-    minDuration: number;
-    maxDuration: number;
-    throughput: number;
-}
-export interface BootBenchmarkResult {
-    totalBootTime: number;
-    phaseTimings: Record<string, number>;
-    componentLoadTimes: Record<string, number>;
-    memoryUsage: {
-        beforeBoot: number;
-        afterBoot: number;
-        peakDuringBoot: number;
-    };
-    success: boolean;
-    errors: string[];
-    orchestratorLoadTime?: number;
-    delegationInitTime?: number;
-    sessionManagementInitTime?: number;
-    processorActivationTime?: number;
-    agentLoadingTime?: number;
-    enforcementActivationTime?: number;
-    codexComplianceActivationTime?: number;
-}
-export interface OrchestratorBenchmarkResult {
-    taskExecutionTimes: number[];
-    delegationLatencies: number[];
-    conflictResolutionTimes: number[];
-    concurrentTaskThroughput: number;
-    dependencyResolutionTime: number;
-    overallSuccess: boolean;
-}
-export interface SessionBenchmarkResult {
-    stateShareLatencies: number[];
-    dependencyUpdateTimes: number[];
-    groupOperationTimes: number[];
-    migrationTimes: number[];
-    failoverTimes: number[];
-    concurrentSessionOperations: number;
-}
-export declare class XrayPerformanceBenchmark {
-    private results;
-    private activeBenchmarks;
-    /**
-     * Start a benchmark measurement
-     */
-    startBenchmark(operation: string, metadata?: Record<string, any>): string;
-    /**
-     * End a benchmark measurement
-     */
-    endBenchmark(benchmarkId: string, success?: boolean, error?: string): BenchmarkResult | null;
-    /**
-     * Benchmark boot sequence performance
-     */
-    benchmarkBootSequence(_bootOrchestrator: unknown): Promise<BootBenchmarkResult>;
-    /**
-     * Benchmark orchestrator task execution
-     */
-    benchmarkOrchestratorTasks(_orchestrator: unknown, taskCount?: number, concurrentTasks?: number): Promise<OrchestratorBenchmarkResult>;
-    /**
-     * Benchmark session management operations
-     */
-    benchmarkSessionOperations(_sessionStateManager: unknown, operationCount?: number): Promise<SessionBenchmarkResult>;
-    /**
-     * Calculate performance metrics from benchmark results
-     */
-    calculateMetrics(operationFilter?: string): PerformanceMetrics;
-    /**
-     * Generate comprehensive benchmark report
-     */
-    generateReport(): {
-        summary: PerformanceMetrics;
-        bootBenchmark?: BootBenchmarkResult;
-        orchestratorBenchmark?: OrchestratorBenchmarkResult;
-        sessionBenchmark?: SessionBenchmarkResult;
-        recommendations: string[];
-    };
-    /**
-     * Clear all benchmark results
-     */
-    clearResults(): void;
-    /**
-     * Export results for external analysis
-     */
-    exportResults(): BenchmarkResult[];
-}
-export declare const performanceBenchmark: XrayPerformanceBenchmark;