0xray 2.0.0

package/dist/analytics/consent-manager.js

@@ -0,0 +1,258 @@
+/**
+ * Consent Manager for 0xRay Central Analytics
+ *
+ * Manages user consent for analytics data submission with granular
+ * control over what categories can be shared.
+ *
+ * @version 1.0.0
+ * @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/analytics/emerging-pattern-detector.js

@@ -0,0 +1,260 @@
+/**
+ * Emerging Pattern Detector for P9 - ADAPTIVE_PATTERN_LEARNING
+ *
+ * Discovers new routing patterns from recent task requests,
+ * identifies emergent behaviors, and suggests new pattern candidates.
+ *
+ * @version 1.0.0
+ * @since 2026-03-05
+ */
+import { frameworkLogger } from "../core/framework-logger.js";
+export class EmergingPatternDetector {
+    minFrequencyThreshold = 3;
+    minConfidenceThreshold = 0.6;
+    clusterSimilarityThreshold = 0.4;
+    maxClusters = 20;
+    stopWords = new Set([
+        'the', 'a', 'an', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 'for',
+        'of', 'with', 'as', 'is', 'are', 'was', 'were', 'be', 'been', 'being',
+        'have', 'has', 'had', 'do', 'does', 'did', 'will', 'would', 'could',
+        'should', 'may', 'might', 'must', 'can', 'this', 'that', 'these',
+        'those', 'i', 'you', 'he', 'she', 'it', 'we', 'they', 'what', 'which'
+    ]);
+    /**
+     * Extract meaningful keywords from task description
+     */
+    extractKeywords(text) {
+        const words = text.toLowerCase()
+            .replace(/[^\w\s]/g, ' ')
+            .split(/\s+/)
+            .filter(word => word.length > 2)
+            .filter(word => !this.stopWords.has(word));
+        return [...new Set(words)];
+    }
+    /**
+     * Calculate Jaccard similarity between two keyword sets
+     */
+    calculateSimilarity(keywords1, keywords2) {
+        if (keywords1.length === 0 || keywords2.length === 0)
+            return 0;
+        const set1 = new Set(keywords1);
+        const set2 = new Set(keywords2);
+        const intersection = new Set([...set1].filter(x => set2.has(x)));
+        const union = new Set([...set1, ...set2]);
+        return intersection.size / union.size;
+    }
+    /**
+     * Cluster similar task descriptions
+     */
+    clusterTasks(tasks) {
+        const clusters = [];
+        const assigned = new Set();
+        // Sort by frequency (most frequent first)
+        const sortedTasks = [...tasks].sort((a, b) => b.keywords.length - a.keywords.length);
+        for (const task of sortedTasks) {
+            if (assigned.has(task.id))
+                continue;
+            // Create new cluster
+            const clusterKeywords = new Set(task.keywords);
+            const clusterDescriptions = [task.description];
+            const clusterIds = [task.id];
+            let clusterFrequency = 1;
+            // Find similar tasks
+            for (const otherTask of sortedTasks) {
+                if (assigned.has(otherTask.id) || otherTask.id === task.id)
+                    continue;
+                const similarity = this.calculateSimilarity([...clusterKeywords], otherTask.keywords);
+                if (similarity >= this.clusterSimilarityThreshold) {
+                    otherTask.keywords.forEach(kw => clusterKeywords.add(kw));
+                    clusterDescriptions.push(otherTask.description);
+                    clusterIds.push(otherTask.id);
+                    clusterFrequency++;
+                    assigned.add(otherTask.id);
+                }
+            }
+            assigned.add(task.id);
+            // Extract unique keywords
+            const uniqueKeywords = [...clusterKeywords].slice(0, 10);
+            // Calculate confidence based on frequency and uniqueness
+            const confidence = Math.min(1, clusterFrequency * 0.15 + uniqueKeywords.length * 0.05);
+            clusters.push({
+                clusterId: `cluster_${clusters.length}`,
+                patterns: clusterDescriptions.slice(0, 5),
+                frequency: clusterFrequency,
+                keywords: uniqueKeywords,
+                suggestedAgents: [],
+                suggestedSkills: [],
+                confidence
+            });
+            if (clusters.length >= this.maxClusters)
+                break;
+        }
+        return clusters;
+    }
+    /**
+     * Detect emergent patterns from recent routing outcomes
+     */
+    detectEmergingPatterns(outcomes) {
+        if (outcomes.length < this.minFrequencyThreshold) {
+            return {
+                emergentPatterns: [],
+                clusters: [],
+                recommendations: ['Insufficient data for pattern detection']
+            };
+        }
+        // Extract keywords and group by outcome
+        const taskData = outcomes.map(outcome => {
+            const keywords = this.extractKeywords(outcome.taskDescription || '');
+            return {
+                id: outcome.taskId,
+                keywords,
+                description: outcome.taskDescription || '',
+                agent: outcome.routedAgent,
+                skill: outcome.routedSkill,
+                success: outcome.success,
+                confidence: outcome.confidence
+            };
+        });
+        // Cluster similar tasks
+        const clusters = this.clusterTasks(taskData);
+        // Analyze clusters for emergent patterns
+        const emergentPatterns = [];
+        const recommendations = [];
+        for (const cluster of clusters) {
+            if (cluster.frequency < this.minFrequencyThreshold)
+                continue;
+            if (cluster.confidence < this.minConfidenceThreshold)
+                continue;
+            // Get success metrics for this cluster
+            const clusterOutcomes = taskData.filter(t => cluster.patterns.includes(t.description));
+            const successCount = clusterOutcomes.filter(t => t.success).length;
+            const successRate = clusterOutcomes.length > 0 ? successCount / clusterOutcomes.length : 0;
+            const avgConfidence = clusterOutcomes.length > 0
+                ? clusterOutcomes.reduce((sum, t) => sum + t.confidence, 0) / clusterOutcomes.length
+                : 0;
+            // Determine suggested agent/skill based on most common
+            const agentCounts = new Map();
+            const skillCounts = new Map();
+            for (const task of clusterOutcomes) {
+                agentCounts.set(task.agent, (agentCounts.get(task.agent) || 0) + 1);
+                skillCounts.set(task.skill, (skillCounts.get(task.skill) || 0) + 1);
+            }
+            const suggestedAgent = [...agentCounts.entries()]
+                .sort((a, b) => b[1] - a[1])[0]?.[0] || 'unknown';
+            const suggestedSkill = [...skillCounts.entries()]
+                .sort((a, b) => b[1] - a[1])[0]?.[0] || 'unknown';
+            cluster.suggestedAgents = [suggestedAgent];
+            cluster.suggestedSkills = [suggestedSkill];
+            // Create emergent pattern
+            const emergentPattern = {
+                id: `emergent-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`,
+                pattern: cluster.keywords.join(' | '),
+                trigger: cluster.keywords,
+                action: successRate < 0.7
+                    ? 'Improve routing for this pattern'
+                    : successRate > 0.9
+                        ? 'Add as new keyword mapping'
+                        : 'Monitor pattern performance',
+                confidence: cluster.confidence,
+                category: 'PREVENTION',
+                frequency: cluster.frequency,
+                lastDetected: new Date(),
+                effectiveness: successRate,
+                firstSeen: clusterOutcomes[0]?.success ? new Date() : new Date(),
+                lastSeen: new Date(),
+                evidence: undefined,
+                stringEvidence: cluster.patterns.slice(0, 3),
+                suggestedAction: successRate < 0.7
+                    ? 'Improve routing for this pattern'
+                    : successRate > 0.9
+                        ? 'Add as new keyword mapping'
+                        : 'Monitor pattern performance'
+            };
+            // Determine if pattern is truly emergent (not in existing mappings)
+            const isNewPattern = successRate > 0.7 && cluster.frequency >= 5;
+            if (isNewPattern) {
+                emergentPatterns.push(emergentPattern);
+            }
+            // Generate recommendations
+            if (successRate > 0.9 && cluster.frequency >= 5) {
+                recommendations.push(`High-performing pattern "${cluster.keywords.slice(0, 3).join(', ')}" (${cluster.frequency} uses, ${(successRate * 100).toFixed(0)}% success) - Consider adding as new keyword mapping`);
+            }
+            else if (successRate < 0.6 && cluster.frequency >= 3) {
+                recommendations.push(`Underperforming pattern "${cluster.keywords.slice(0, 3).join(', ')}" (${cluster.frequency} uses, ${(successRate * 100).toFixed(0)}% success) - Review routing logic`);
+            }
+        }
+        // Sort emergent patterns by confidence
+        emergentPatterns.sort((a, b) => b.confidence - a.confidence);
+        if (recommendations.length === 0) {
+            recommendations.push('No significant emergent patterns detected');
+        }
+        frameworkLogger.log("emerging-pattern-detector", "analysis-complete", "info", {
+            emergentPatternsCount: emergentPatterns.length,
+            clustersCount: clusters.length,
+            recommendationsCount: recommendations.length
+        }, undefined);
+        return {
+            emergentPatterns,
+            clusters,
+            recommendations
+        };
+    }
+    /**
+     * Check if a specific pattern is emerging
+     */
+    isPatternEmerging(pattern, recentOutcomes, historicalBaseline) {
+        const keywords = this.extractKeywords(pattern);
+        const recentKeywords = recentOutcomes.slice(-20).map(o => this.extractKeywords(o.taskDescription || ''));
+        // Count matches in recent outcomes
+        let matches = 0;
+        for (const recentKw of recentKeywords) {
+            if (this.calculateSimilarity(keywords, recentKw) > this.clusterSimilarityThreshold) {
+                matches++;
+            }
+        }
+        const recentFrequency = matches / Math.max(recentKeywords.length, 1);
+        const baselineFrequency = historicalBaseline;
+        // Determine trend
+        let trend;
+        if (recentFrequency > baselineFrequency * 1.3) {
+            trend = 'increasing';
+        }
+        else if (recentFrequency < baselineFrequency * 0.7) {
+            trend = 'decreasing';
+        }
+        else {
+            trend = 'stable';
+        }
+        return {
+            emerging: trend === 'increasing' && recentFrequency > 0.1,
+            trend,
+            confidence: Math.min(1, recentFrequency * 2)
+        };
+    }
+    /**
+     * Get suggested keyword mappings from emergent patterns
+     */
+    suggestKeywordMappings(emergentPatterns) {
+        const suggestions = [];
+        for (const pattern of emergentPatterns) {
+            if (pattern.confidence < this.minConfidenceThreshold)
+                continue;
+            // Extract top keywords as potential mapping
+            const keywords = pattern.pattern.split(' | ').slice(0, 5);
+            // Extract agent/skill from evidence
+            // In real implementation, this would analyze the evidence
+            const suggestedAgent = 'orchestrator'; // Default fallback
+            const suggestedSkill = 'orchestrator';
+            suggestions.push({
+                keywords,
+                suggestedAgent,
+                suggestedSkill,
+                confidence: pattern.confidence,
+                reason: `Emerging pattern with ${pattern.frequency} occurrences`
+            });
+        }
+        return suggestions;
+    }
+}
+// Singleton instance
+export const emergingPatternDetector = new EmergingPatternDetector();