0xray 4.0.12 → 4.0.13

package/dist/orchestrator/self-direction-activation.d.ts

@@ -1,108 +0,0 @@
-/**
- * Self-Direction Activation System (Simplified)
- *
- * Commercial version with autonomous self-direction capabilities.
- * Activates the framework's dormant self-evolution systems for continuous improvement.
- * This version works without advanced-features dependencies for initial deployment.
- *
- * @since 2026-01-24
- */
-export interface SelfDirectionConfig {
-    monitoringInterval: number;
-    analyticsInterval: number;
-    learningCycleInterval: number;
-    autonomousReporting: boolean;
-    predictiveOptimization: boolean;
-    scalingAutonomy: boolean;
-    evolutionSafety: boolean;
-}
-export interface SelfAssessmentReport {
-    timestamp: number;
-    healthScore: number;
-    criticalIssues: CriticalIssue[];
-    improvementOpportunities: ImprovementOpportunity[];
-    predictions: SystemPrediction[];
-    recommendations: string[];
-}
-export interface CriticalIssue {
-    id: string;
-    severity: "low" | "medium" | "high" | "critical";
-    component: string;
-    description: string;
-    impact: string;
-    recommendedAction: string;
-}
-export interface ImprovementOpportunity {
-    id: string;
-    type: "performance" | "reliability" | "efficiency" | "capability";
-    description: string;
-    potentialBenefit: string;
-    implementationComplexity: "low" | "medium" | "high";
-    confidence: number;
-}
-export interface SystemPrediction {
-    type: "scaling" | "performance" | "reliability" | "resource";
-    prediction: string;
-    confidence: number;
-    timeHorizon: number;
-    recommendedAction?: string;
-}
-/**
- * Simplified Self-Direction Activation System
- *
- * Provides basic self-direction capabilities without advanced-features dependencies
- * for initial deployment and testing.
- */
-export declare class SelfDirectionSystem {
-    private config;
-    private activeMonitoring;
-    private activeLearning;
-    private monitoringIntervalId;
-    private learningIntervalId;
-    constructor(config?: Partial<SelfDirectionConfig>);
-    /**
-     * Phase 1: Activate Self-Monitoring Foundation
-     */
-    activateSelfMonitoring(): Promise<void>;
-    /**
-     * Setup autonomous critical issue reporting
-     */
-    private setupAutonomousReporting;
-    /**
-     * Start continuous self-assessment cycle
-     */
-    private startContinuousSelfAssessment;
-    /**
-     * Phase 2: Activate Self-Evolution Learning
-     */
-    activateSelfEvolution(): Promise<void>;
-    /**
-     * Start learning cycles
-     */
-    private startLearningCycles;
-    /**
-     * Core self-assessment method
-     */
-    performSelfAssessment(): Promise<SelfAssessmentReport>;
-    /**
-     * Process self-assessment results
-     */
-    private processSelfAssessmentResults;
-    /**
-     * Get current self-direction status
-     */
-    getStatus(): {
-        activeMonitoring: boolean;
-        activeLearning: boolean;
-        config: SelfDirectionConfig;
-        componentsHealth: Record<string, boolean>;
-    };
-    /**
-     * Shutdown self-direction system
-     */
-    shutdown(): Promise<void>;
-}
-/**
- * Export singleton instance
- */
-export declare const selfDirectionSystem: SelfDirectionSystem;

package/dist/orchestrator/self-direction-activation.js

@@ -1,244 +0,0 @@
-/**
- * Self-Direction Activation System (Simplified)
- *
- * Commercial version with autonomous self-direction capabilities.
- * Activates the framework's dormant self-evolution systems for continuous improvement.
- * This version works without advanced-features dependencies for initial deployment.
- *
- * @since 2026-01-24
- */
-// Framework core imports
-import { frameworkLogger, generateJobId } from "../core/framework-logger.js";
-/**
- * Simplified Self-Direction Activation System
- *
- * Provides basic self-direction capabilities without advanced-features dependencies
- * for initial deployment and testing.
- */
-export class SelfDirectionSystem {
-    config;
-    activeMonitoring = false;
-    activeLearning = false;
-    monitoringIntervalId;
-    learningIntervalId;
-    constructor(config = {}) {
-        this.config = {
-            monitoringInterval: 30000, // 30 seconds
-            analyticsInterval: 300000, // 5 minutes
-            learningCycleInterval: 3600000, // 1 hour
-            autonomousReporting: true,
-            predictiveOptimization: true,
-            scalingAutonomy: true,
-            evolutionSafety: true,
-            ...config,
-        };
-    }
-    /**
-     * Phase 1: Activate Self-Monitoring Foundation
-     */
-    async activateSelfMonitoring() {
-        frameworkLogger.log("self-direction-system", "activating-monitoring", "info", { message: "🤖 ACTIVATING SELF-MONITORING FOUNDATION" });
-        try {
-            // Setup autonomous critical issue reporting
-            this.setupAutonomousReporting();
-            frameworkLogger.log("self-direction-system", "reporting-activated", "info", { message: "✅ Autonomous critical issue reporting activated" });
-            // Start continuous self-assessment
-            this.startContinuousSelfAssessment();
-            this.activeMonitoring = true;
-            frameworkLogger.log("self-direction-system", "monitoring-activated", "info", { message: "🎉 Self-monitoring foundation activated" });
-            await frameworkLogger.log("self-direction-system", "monitoring-activated", "success", { phase: 1, componentsActivated: ["reporting", "assessment"] }, undefined, generateJobId("self-monitoring"));
-        }
-        catch (error) {
-            frameworkLogger.log("self-direction-system", "monitoring-activation-failed", "error", { error, message: "❌ Self-monitoring activation failed" });
-            await frameworkLogger.log("self-direction-system", "monitoring-activation-failed", "error", { error: error instanceof Error ? error.message : error }, undefined, generateJobId("self-monitoring-fail"));
-            throw error;
-        }
-    }
-    /**
-     * Setup autonomous critical issue reporting
-     */
-    setupAutonomousReporting() {
-        // Setup basic event listeners for critical issues
-        frameworkLogger.log("self-direction-system", "reporting-configured", "info", { message: "📊 Autonomous reporting configured" });
-    }
-    /**
-     * Start continuous self-assessment cycle
-     */
-    startContinuousSelfAssessment() {
-        // Clear any existing interval first to prevent duplicates
-        if (this.monitoringIntervalId) {
-            clearInterval(this.monitoringIntervalId);
-        }
-        this.monitoringIntervalId = setInterval(async () => {
-            try {
-                if (!this.activeMonitoring)
-                    return; // Don't run if stopped
-                const assessment = await this.performSelfAssessment();
-                await this.processSelfAssessmentResults(assessment);
-            }
-            catch (error) {
-                frameworkLogger.log("self-direction-system", "assessment-cycle-failed", "error", { error, message: "Self-assessment cycle failed" });
-            }
-        }, this.config.monitoringInterval);
-    }
-    /**
-     * Phase 2: Activate Self-Evolution Learning
-     */
-    async activateSelfEvolution() {
-        frameworkLogger.log("self-direction-system", "activating-evolution", "info", { message: "🧠 ACTIVATING SELF-EVOLUTION LEARNING" });
-        try {
-            // Start learning cycles
-            this.startLearningCycles();
-            frameworkLogger.log("self-direction-system", "learning-cycles-activated", "info", { message: "✅ Learning cycles activated" });
-            this.activeLearning = true;
-            frameworkLogger.log("self-direction-system", "evolution-activated", "info", { message: "🎉 Self-evolution learning activated" });
-            await frameworkLogger.log("self-direction-system", "evolution-activated", "success", { phase: 2, componentsActivated: ["learning-cycles"] }, undefined, generateJobId("self-evolution"));
-        }
-        catch (error) {
-            frameworkLogger.log("self-direction-system", "evolution-activation-failed", "error", { error, message: "❌ Self-evolution activation failed" });
-            await frameworkLogger.log("self-direction-system", "evolution-activation-failed", "error", { error: error instanceof Error ? error.message : error }, undefined, generateJobId("self-evolution-fail"));
-            throw error;
-        }
-    }
-    /**
-     * Start learning cycles
-     */
-    startLearningCycles() {
-        // Clear any existing interval first to prevent duplicates
-        if (this.learningIntervalId) {
-            clearInterval(this.learningIntervalId);
-        }
-        this.learningIntervalId = setInterval(async () => {
-            if (!this.activeLearning)
-                return; // Don't run if stopped
-            frameworkLogger.log("self-direction-system", "learning-cycle-executed", "info", { message: "🔄 Learning cycle executed" });
-            // Basic learning cycle - would be enhanced with advanced features
-        }, this.config.learningCycleInterval);
-    }
-    /**
-     * Core self-assessment method
-     */
-    async performSelfAssessment() {
-        const timestamp = Date.now();
-        // Basic health assessment
-        const healthScore = 0.75; // Placeholder
-        // Known critical issues
-        const criticalIssues = [
-            {
-                id: "memory-leak",
-                severity: "critical",
-                component: "memory-management",
-                description: "Memory leaks persist at 1.3GB+ usage",
-                impact: "System instability",
-                recommendedAction: "Deep profiling required",
-            },
-            {
-                id: "performance-budget",
-                severity: "critical",
-                component: "performance",
-                description: "Bundle size and response times exceed limits",
-                impact: "CI/CD deployment blocked",
-                recommendedAction: "Optimization required",
-            },
-        ];
-        // Basic improvement opportunities
-        const improvementOpportunities = [
-            {
-                id: "memory-optimization",
-                type: "performance",
-                description: "Implement comprehensive memory leak fixes",
-                potentialBenefit: "Reduce memory usage by 95%",
-                implementationComplexity: "high",
-                confidence: 0.8,
-            },
-        ];
-        // Basic predictions
-        const predictions = [
-            {
-                type: "performance",
-                prediction: "Performance budget violations will persist",
-                confidence: 0.9,
-                timeHorizon: 24,
-                recommendedAction: "Address bundle size and response times",
-            },
-        ];
-        // Recommendations
-        const recommendations = [
-            "Conduct comprehensive memory profiling",
-            "Fix concurrent spawn limit race condition",
-            "Resolve performance budget violations",
-        ];
-        return {
-            timestamp,
-            healthScore,
-            criticalIssues,
-            improvementOpportunities,
-            predictions,
-            recommendations,
-        };
-    }
-    /**
-     * Process self-assessment results
-     */
-    async processSelfAssessmentResults(assessment) {
-        if (assessment.criticalIssues.length > 0) {
-            frameworkLogger.log("self-direction-system", "critical-issues-detected", "warning", {
-                message: `🚨 ${assessment.criticalIssues.length} critical issues detected`,
-                issues: assessment.criticalIssues.map(i => `${i.severity.toUpperCase()}: ${i.description}`),
-            });
-        }
-        if (assessment.recommendations.length > 0) {
-            frameworkLogger.log("self-direction-system", "recommendations-generated", "info", {
-                message: `💡 ${assessment.recommendations.length} recommendations generated`,
-            });
-        }
-    }
-    /**
-     * Get current self-direction status
-     */
-    getStatus() {
-        return {
-            activeMonitoring: this.activeMonitoring,
-            activeLearning: this.activeLearning,
-            config: this.config,
-            componentsHealth: {
-                metricsCollector: true,
-                analytics: true,
-                streaming: true,
-                scaling: true,
-                loadBalancer: true,
-                metaAnalysis: true,
-                inference: true,
-                selfReflection: true,
-                learningLoops: true,
-                evolutionValidation: true,
-                monitoring: true,
-                reporting: true,
-                assessment: true,
-                learning: true,
-            },
-        };
-    }
-    /**
-     * Shutdown self-direction system
-     */
-    async shutdown() {
-        frameworkLogger.log("self-direction-system", "shutting-down", "info", { message: "🛑 Shutting down self-direction system..." });
-        // Clear all intervals to prevent memory leaks
-        if (this.monitoringIntervalId) {
-            clearInterval(this.monitoringIntervalId);
-            this.monitoringIntervalId = undefined;
-        }
-        if (this.learningIntervalId) {
-            clearInterval(this.learningIntervalId);
-            this.learningIntervalId = undefined;
-        }
-        this.activeMonitoring = false;
-        this.activeLearning = false;
-        frameworkLogger.log("self-direction-system", "shutdown-complete", "info", { message: "✅ Self-direction system shutdown complete" });
-    }
-}
-/**
- * Export singleton instance
- */
-export const selfDirectionSystem = new SelfDirectionSystem();

package/dist/orchestrator/universal-librarian-consultation.d.ts

@@ -1,98 +0,0 @@
-/**
- * Universal Librarian Consultation System
- * Ensures researcher is involved in all major system actions for documentation and versioning
- */
-import { RuleEnforcer } from "../enforcement/rule-enforcer.js";
-export interface SystemAction {
-    type: "code-change" | "rule-modification" | "architectural-change" | "configuration_update" | "documentation_update";
-    description: string;
-    scope: "framework" | "agent" | "tool" | "configuration" | "documentation";
-    complexity: "low" | "medium" | "high" | "critical";
-    files?: string[];
-    components?: string[];
-    metadata?: {
-        triggeredBy?: string;
-        [key: string]: unknown;
-    };
-}
-export interface LibrarianConsultationResult {
-    approved: boolean;
-    documentationImpact: "none" | "minor" | "major" | "critical";
-    versionUpdates: VersionUpdate[];
-    recommendations: string[];
-    pairProgrammingRequired: boolean;
-}
-export interface VersionUpdate {
-    file: string;
-    field: string;
-    oldVersion: string;
-    newVersion: string;
-    reason: string;
-}
-export interface ActionResult {
-    success: boolean;
-    [key: string]: unknown;
-}
-export interface LibrarianConsultationResult {
-    approved: boolean;
-    documentationImpact: "none" | "minor" | "major" | "critical";
-    versionUpdates: VersionUpdate[];
-    recommendations: string[];
-    pairProgrammingRequired: boolean;
-}
-export interface VersionUpdate {
-    file: string;
-    field: string;
-    oldVersion: string;
-    newVersion: string;
-    reason: string;
-}
-export declare class UniversalLibrarianConsultation {
-    private ruleEnforcer;
-    constructor(ruleEnforcer: RuleEnforcer);
-    /**
-     * Pre-action consultation - must be called before any major system action
-     */
-    consultBeforeAction(action: SystemAction): Promise<LibrarianConsultationResult>;
-    /**
-     * Post-action consultation - must be called after any major system action
-     */
-    consultAfterAction(action: SystemAction, result: ActionResult): Promise<void>;
-    /**
-     * Check if this action is related to researcher operations (to prevent recursion)
-     */
-    private isLibrarianOperation;
-    /**
-     * Assess documentation impact of the action
-     */
-    private assessDocumentationImpact;
-    /**
-     * Determine what version updates are needed
-     */
-    private determineVersionUpdates;
-    /**
-     * Check if pair programming with researcher is required
-     */
-    private requiresPairProgramming;
-    /**
-     * Generate recommendations for the action
-     */
-    private generateRecommendations;
-    /**
-     * Update documentation after action completion
-     */
-    private updateDocumentation;
-    /**
-     * Update versions after action completion
-     */
-    private updateVersions;
-    /**
-     * Validate documentation integrity
-     */
-    private validateDocumentationIntegrity;
-    /**
-     * Determine which documentation files need updating
-     */
-    private determineDocumentationFiles;
-}
-export declare const universalLibrarianConsultation: UniversalLibrarianConsultation;

package/dist/orchestrator/universal-librarian-consultation.js

@@ -1,216 +0,0 @@
-/**
- * Universal Librarian Consultation System
- * Ensures researcher is involved in all major system actions for documentation and versioning
- */
-import { frameworkLogger } from "../core/framework-logger.js";
-import { resolveConfigPath } from "../core/config-paths.js";
-export class UniversalLibrarianConsultation {
-    ruleEnforcer;
-    constructor(ruleEnforcer) {
-        this.ruleEnforcer = ruleEnforcer;
-    }
-    /**
-     * Pre-action consultation - must be called before any major system action
-     */
-    async consultBeforeAction(action) {
-        await frameworkLogger.log("universal-librarian-consultation", "pre-action-consultation-started", "info", {
-            actionType: action.type,
-            scope: action.scope,
-            complexity: action.complexity,
-        });
-        // Prevent recursive consultation loops (researcher operations triggering more researcher consultations)
-        if (this.isLibrarianOperation(action)) {
-            await frameworkLogger.log("universal-librarian-consultation", "pre-action-consultation-skipped", "info", {
-                reason: "researcher operation detected - skipping to prevent recursion",
-                actionType: action.type,
-                scope: action.scope,
-            });
-            return {
-                approved: true,
-                documentationImpact: "none",
-                versionUpdates: [],
-                recommendations: [],
-                pairProgrammingRequired: false,
-            };
-        }
-        const documentationImpact = this.assessDocumentationImpact(action);
-        const versionUpdates = await this.determineVersionUpdates(action);
-        const pairProgrammingRequired = this.requiresPairProgramming(action);
-        const recommendations = this.generateRecommendations(action, documentationImpact);
-        const approved = action.complexity !== "critical" || documentationImpact !== "critical";
-        const result = {
-            approved,
-            documentationImpact,
-            versionUpdates,
-            recommendations,
-            pairProgrammingRequired,
-        };
-        await frameworkLogger.log("universal-librarian-consultation", "pre-action-consultation-completed", approved ? "success" : "error", {
-            approved,
-            documentationImpact,
-            versionUpdatesCount: versionUpdates.length,
-            pairProgrammingRequired,
-        });
-        return result;
-    }
-    /**
-     * Post-action consultation - must be called after any major system action
-     */
-    async consultAfterAction(action, result) {
-        await frameworkLogger.log("universal-librarian-consultation", "post-action-consultation-started", "info", {
-            actionType: action.type,
-            scope: action.scope,
-            result: result ? "success" : "failure",
-        });
-        await this.updateDocumentation(action, result);
-        await this.updateVersions(action, result);
-        await this.validateDocumentationIntegrity(action);
-        await frameworkLogger.log("universal-librarian-consultation", "post-action-consultation-completed", "success", {
-            actionType: action.type,
-            scope: action.scope,
-            documentationUpdated: true,
-            versionsUpdated: true,
-        });
-    }
-    /**
-     * Check if this action is related to researcher operations (to prevent recursion)
-     */
-    isLibrarianOperation(action) {
-        return (action.scope === "documentation" ||
-            (action.type === "rule-modification" &&
-                action.description.includes("researcher")) ||
-            action.metadata?.triggeredBy === "researcher" ||
-            action.description.includes("researcher consultation"));
-    }
-    /**
-     * Assess documentation impact of the action
-     */
-    assessDocumentationImpact(action) {
-        if (action.scope === "documentation") {
-            return action.complexity === "critical" ? "critical" : "major";
-        }
-        if (action.scope === "framework" && action.complexity === "high") {
-            return "major";
-        }
-        if (action.scope === "agent" || action.scope === "tool") {
-            return action.complexity === "low" ? "minor" : "major";
-        }
-        if (action.scope === "configuration" && action.complexity === "high") {
-            return "major";
-        }
-        return "none";
-    }
-    /**
-     * Determine what version updates are needed
-     */
-    async determineVersionUpdates(action) {
-        const updates = [];
-        if (action.type === "rule-modification" || action.scope === "framework") {
-            const codexPath = resolveConfigPath("codex.json") || "codex.json";
-            updates.push({
-                file: codexPath,
-                field: "version",
-                oldVersion: "1.1.1",
-                newVersion: "1.1.2",
-                reason: `Updated for ${action.type}: ${action.description}`,
-            });
-        }
-        if (action.complexity === "critical") {
-            updates.push({
-                file: "package.json",
-                field: "version",
-                oldVersion: "1.1.1",
-                newVersion: "1.1.2",
-                reason: `Major ${action.scope} changes: ${action.description}`,
-            });
-        }
-        return updates;
-    }
-    /**
-     * Check if pair programming with researcher is required
-     */
-    requiresPairProgramming(action) {
-        return (action.complexity === "critical" ||
-            action.scope === "framework" ||
-            action.type === "architectural-change" ||
-            action.type === "rule-modification");
-    }
-    /**
-     * Generate recommendations for the action
-     */
-    generateRecommendations(action, documentationImpact) {
-        const recommendations = [];
-        if (documentationImpact === "major" || documentationImpact === "critical") {
-            recommendations.push("Update architecture documentation");
-            recommendations.push("Update API documentation if interfaces changed");
-            recommendations.push("Update README.md with new capabilities");
-        }
-        if (action.type === "rule-modification") {
-            recommendations.push("Ensure rule mappings are updated in agent-delegator");
-            recommendations.push("Update AGENTS.md with any new enforceable rules");
-        }
-        if (action.scope === "agent") {
-            recommendations.push("Update agent capability documentation");
-            recommendations.push("Verify agent tool mappings are complete");
-        }
-        if (action.complexity === "critical") {
-            recommendations.push("Consider updating version to indicate breaking changes");
-            recommendations.push("Update changelog with major changes");
-        }
-        return recommendations;
-    }
-    /**
-     * Update documentation after action completion
-     */
-    async updateDocumentation(action, _result) {
-        await frameworkLogger.log("universal-librarian-consultation", "documentation-update-triggered", "info", {
-            actionType: action.type,
-            scope: action.scope,
-            filesToUpdate: this.determineDocumentationFiles(action),
-        });
-    }
-    /**
-     * Update versions after action completion
-     */
-    async updateVersions(action, _result) {
-        await frameworkLogger.log("universal-librarian-consultation", "version-update-triggered", "info", {
-            actionType: action.type,
-            scope: action.scope,
-            versionUpdates: await this.determineVersionUpdates(action),
-        });
-    }
-    /**
-     * Validate documentation integrity
-     */
-    async validateDocumentationIntegrity(action) {
-        await frameworkLogger.log("universal-librarian-consultation", "documentation-integrity-validation", "info", {
-            actionType: action.type,
-            scope: action.scope,
-            validationPerformed: true,
-        });
-    }
-    /**
-     * Determine which documentation files need updating
-     */
-    determineDocumentationFiles(action) {
-        const files = [];
-        if (action.scope === "framework") {
-            files.push("README.md", "docs/ARCHITECTURE.md", "AGENTS.md");
-        }
-        if (action.scope === "agent") {
-            files.push("AGENTS.md", "docs/agent-capabilities.md");
-        }
-        if (action.scope === "tool") {
-            files.push("docs/tool-integration.md");
-        }
-        if (action.type === "rule-modification") {
-            files.push("AGENTS.md", "docs/rule-enforcement.md");
-        }
-        if (action.type === "architectural-change") {
-            files.push("docs/ARCHITECTURE.md", "docs/architectural-decisions.md");
-        }
-        return files;
-    }
-}
-// Export singleton instance
-export const universalLibrarianConsultation = new UniversalLibrarianConsultation(null);