0xray 3.4.2 → 3.4.3

package/dist/analytics/pattern-learning-engine.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Pattern Learning Engine for P9 - ADAPTIVE_PATTERN_LEARNING
+ *
+ * Learns from performance data, generates adaptive modifications,
+ * and creates self-improving pattern definitions.
+ *
+ * @since 2026-03-05
+ */
+import type { PatternUpdate } from "../core/kernel-patterns.js";
+export interface LearningResult {
+    newPatterns: PatternUpdate[];
+    modifiedPatterns: PatternUpdate[];
+    removedPatterns: PatternUpdate[];
+    thresholdUpdates: PatternUpdate[];
+    recommendations: string[];
+}
+export interface AdaptiveLearningConfig {
+    enableAutoAddition: boolean;
+    enableAutoRemoval: boolean;
+    enableThresholdCalibration: boolean;
+    minConfidenceForAddition: number;
+    minSuccessRateForAddition: number;
+    maxPatterns: number;
+}
+export declare class PatternLearningEngine {
+    private config;
+    private learningHistory;
+    private readonly maxHistory;
+    constructor(config?: Partial<AdaptiveLearningConfig>);
+    /**
+     * Main learning function - analyzes data and generates adaptive modifications
+     */
+    learnFromData(outcomes: Array<{
+        taskId: string;
+        taskDescription: string;
+        routedAgent: string;
+        routedSkill: string;
+        confidence: number;
+        success: boolean;
+    }>, existingMappings: Array<{
+        keywords: string[];
+        skill: string;
+        agent: string;
+        confidence: number;
+    }>): LearningResult;
+    /**
+     * Generate pattern modifications based on performance
+     */
+    private generatePatternModifications;
+    /**
+     * Generate patterns for removal based on poor performance
+     */
+    private generatePatternRemovals;
+    /**
+     * Generate adaptive threshold updates
+     */
+    private generateThresholdUpdates;
+    /**
+     * Generate new pattern suggestions from emergent patterns
+     */
+    private generateNewPatterns;
+    /**
+     * Generate recommendations based on learning results
+     */
+    private generateRecommendations;
+    /**
+     * Get learning history
+     */
+    getLearningHistory(): LearningResult[];
+    /**
+     * Update configuration
+     */
+    updateConfig(newConfig: Partial<AdaptiveLearningConfig>): void;
+    /**
+     * Get current configuration
+     */
+    getConfig(): AdaptiveLearningConfig;
+}
+export declare const patternLearningEngine: PatternLearningEngine;

package/dist/analytics/pattern-performance-tracker.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Pattern Performance Tracker for P9 - ADAPTIVE_PATTERN_LEARNING
+ *
+ * Monitors pattern effectiveness over time, detects pattern drift,
+ * and provides metrics for adaptive kernel modifications.
+ *
+ * @since 2026-03-05
+ */
+import type { AdaptiveThresholds } from "../core/kernel-patterns.js";
+export interface PatternMetrics {
+    patternId: string;
+    totalUsages: number;
+    successfulUsages: number;
+    failedUsages: number;
+    successRate: number;
+    avgConfidence: number;
+    avgResponseTime: number;
+    lastUpdated: Date;
+    timeSeries: Array<{
+        timestamp: Date;
+        successRate: number;
+        avgConfidence: number;
+        usageCount: number;
+    }>;
+}
+export interface PatternDriftAnalysis {
+    drifted: boolean;
+    patternId: string;
+    currentMetrics: PatternMetrics;
+    historicalBaseline: PatternMetrics;
+    driftMagnitude: number;
+    driftDirection: 'increasing' | 'decreasing' | 'unstable';
+    confidence: number;
+    recommendedAction: string;
+}
+export interface SystemPerformanceSummary {
+    overallSuccessRate: number;
+    overallAvgConfidence: number;
+    totalPatternsTracked: number;
+    patternsWithDrift: string[];
+    patternsNeedingAttention: string[];
+    recommendations: string[];
+}
+export declare class PatternPerformanceTracker {
+    private patternMetrics;
+    private readonly maxTimeSeriesPoints;
+    private readonly driftThreshold;
+    private readonly minSamplesForDrift;
+    private readonly baselineWindowSize;
+    /**
+     * Track performance metrics for a pattern
+     */
+    trackPatternPerformance(patternId: string, outcome: {
+        success: boolean;
+        confidence: number;
+        responseTime?: number;
+        complexity?: number;
+    }): void;
+    /**
+     * Detect if a pattern has drifted from its historical baseline
+     */
+    detectPatternDrift(patternId: string): PatternDriftAnalysis | null;
+    /**
+     * Get all pattern drift analyses
+     */
+    getAllDriftAnalyses(): PatternDriftAnalysis[];
+    /**
+     * Calculate adaptive confidence thresholds based on performance
+     */
+    calculateAdaptiveThresholds(): AdaptiveThresholds;
+    /**
+     * Get system performance summary
+     */
+    getSystemPerformanceSummary(): SystemPerformanceSummary;
+    /**
+     * Get metrics for a specific pattern
+     */
+    getPatternMetrics(patternId: string): PatternMetrics | null;
+    /**
+     * Get all tracked patterns
+     */
+    getAllPatternMetrics(): PatternMetrics[];
+    /**
+     * Clear all metrics (for testing or reset)
+     */
+    clear(): void;
+    /**
+     * Save metrics to disk for persistence
+     */
+    saveToDisk(): void;
+    /**
+     * Load metrics from disk
+     */
+    loadFromDisk(): void;
+}
+export declare const patternPerformanceTracker: PatternPerformanceTracker;

package/dist/analytics/predictive-analytics.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Predictive Analytics for Optimal Agent Routing
+ *
+ * Predicts the best agent to route a task to based on historical
+ * success rates using simple keyword overlap scoring.
+ *
+ */
+export interface RoutingPrediction {
+    agent: string;
+    confidence: number;
+    historicalSuccessRate: number;
+    sampleSize: number;
+    /** Risk level based on confidence and success probability */
+    riskLevel?: "low" | "medium" | "high";
+    /** Estimated task duration in milliseconds */
+    estimatedDuration?: number;
+    /** Agent performance metrics used for prediction */
+    agentMetrics?: AgentPerformanceSummary;
+}
+export interface AgentPerformanceSummary {
+    totalTasks: number;
+    successfulTasks: number;
+    failedTasks: number;
+    averageExecutionTime: number;
+    successRate: number;
+    recentPerformance: number[];
+    taskTypeBreakdown: Record<string, {
+        count: number;
+        successRate: number;
+    }>;
+}
+export type RiskLevel = "low" | "medium" | "high";
+export interface PredictiveAnalytics {
+    predict(taskDescription: string): Promise<RoutingPrediction | null>;
+    predictOptimalAgent(): Promise<RoutingPrediction | null>;
+    /** Synchronous prediction using in-memory data (no disk reload). */
+    predictSync(taskDescription: string): RoutingPrediction | null;
+    [key: string]: any;
+}
+export declare const predictiveAnalytics: PredictiveAnalytics;

package/dist/analytics/prompt-pattern-analyzer.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Prompt Pattern Analyzer for 0xRay
+ *
+ * Analyzes actual vs. template prompts to detect gaps and emerging patterns.
+ * Integrates with RoutingOutcomeTracker to provide insights for template optimization.
+ *
+ * @since 2026-03-05
+ */
+export interface TemplateGap {
+    gapType: "missing_template" | "pattern_mismatch" | "emerging_pattern";
+    userRequest: string;
+    generatedPrompt: string;
+    suggestedAgent: string;
+    suggestedSkill: string;
+    frequency: number;
+    lastSeen: Date;
+    confidence: number;
+}
+export interface EmergingPattern {
+    patternId: string;
+    keywords: string[];
+    sampleRequests: string[];
+    suggestedAgent: string;
+    suggestedSkill: string;
+    confidence: number;
+    frequency: number;
+    avgConfidence: number;
+    successRate: number;
+}
+export interface PromptComparisonResult {
+    totalPrompts: number;
+    templateMatches: number;
+    nonTemplatePrompts: number;
+    templateMatchRate: number;
+    gaps: TemplateGap[];
+    emergingPatterns: EmergingPattern[];
+    topMissedKeywords: Array<{
+        keyword: string;
+        count: number;
+        suggestedMappings: string[];
+    }>;
+    agentCoverage: Map<string, {
+        total: number;
+        withTemplate: number;
+        withoutTemplate: number;
+    }>;
+}
+export interface TemplateOptimizationSuggestion {
+    suggestionType: "add_template" | "update_keywords" | "merge_patterns" | "remove_template";
+    templateName?: string;
+    keywords: string[];
+    targetAgent: string;
+    targetSkill: string;
+    confidence: number;
+    expectedImpact: string;
+    reasoning: string;
+}
+declare class PromptPatternAnalyzer {
+    private readonly minFrequencyThreshold;
+    private readonly confidenceThreshold;
+    private readonly emergingPatternMinSamples;
+    /**
+     * Analyze prompt patterns and compare against templates
+     */
+    analyzePromptPatterns(): PromptComparisonResult;
+    /**
+     * Detect gaps where templates don't match user requests
+     */
+    private detectTemplateGaps;
+    /**
+     * Identify emerging patterns from real usage
+     */
+    private identifyEmergingPatterns;
+    /**
+     * Analyze frequently missed keywords
+     */
+    private analyzeMissedKeywords;
+    /**
+     * Calculate agent coverage metrics
+     */
+    private calculateAgentCoverage;
+    /**
+     * Generate template optimization suggestions
+     */
+    generateOptimizationSuggestions(comparisonResult: PromptComparisonResult): TemplateOptimizationSuggestion[];
+    /**
+     * Get analytics summary as formatted report
+     */
+    generateReport(comparisonResult: PromptComparisonResult): string;
+    private classifyGapType;
+    private normalizeRequest;
+    private extractKeywords;
+    private generatePatternId;
+    private selectBestAgent;
+    private emptyComparisonResult;
+}
+export declare const promptPatternAnalyzer: PromptPatternAnalyzer;
+export {};

package/dist/analytics/routing-performance-analyzer.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Routing Performance Analyzer for 0xRay
+ *
+ * Analyzes routing success rates, keyword effectiveness, and confidence thresholds.
+ * Integrates with RoutingOutcomeTracker to provide comprehensive routing metrics.
+ *
+ * @since 2026-03-05
+ */
+export interface AgentPerformanceMetrics {
+    agent: string;
+    skill: string;
+    totalRoutings: number;
+    successfulRoutings: number;
+    failedRoutings: number;
+    escalatedRoutings: number;
+    successRate: number;
+    avgConfidence: number;
+    avgExecutionTime: number;
+    confidenceDistribution: {
+        high: number;
+        medium: number;
+        low: number;
+    };
+    timeRange: {
+        earliest: Date;
+        latest: Date;
+    };
+}
+export interface KeywordEffectiveness {
+    keyword: string;
+    totalMatches: number;
+    successfulMatches: number;
+    failedMatches: number;
+    successRate: number;
+    avgConfidence: number;
+    routedAgent: string;
+    routedSkill: string;
+    lastUsed: Date;
+}
+export interface ConfidenceThresholdMetrics {
+    threshold: number;
+    totalRoutings: number;
+    successfulRoutings: number;
+    successRate: number;
+    escalatedCount: number;
+    recommendation: string;
+}
+export interface RoutingPerformanceReport {
+    totalRoutings: number;
+    overallSuccessRate: number;
+    avgConfidence: number;
+    agentMetrics: AgentPerformanceMetrics[];
+    keywordEffectiveness: KeywordEffectiveness[];
+    confidenceMetrics: ConfidenceThresholdMetrics[];
+    timeRange: {
+        start: Date;
+        end: Date;
+    };
+    recommendations: string[];
+}
+declare class RoutingPerformanceAnalyzer {
+    private readonly lowConfidenceThreshold;
+    private readonly mediumConfidenceThreshold;
+    private readonly minSamplesForMetrics;
+    /**
+     * Generate comprehensive routing performance report
+     */
+    generatePerformanceReport(): RoutingPerformanceReport;
+    /**
+     * Calculate performance metrics for each agent
+     */
+    private calculateAgentMetrics;
+    /**
+     * Analyze effectiveness of keywords
+     */
+    private analyzeKeywordEffectiveness;
+    /**
+     * Analyze confidence threshold performance
+     */
+    private analyzeConfidenceThresholds;
+    /**
+     * Calculate overall routing statistics
+     */
+    private calculateOverallStats;
+    /**
+     * Calculate time range for routing data
+     */
+    private calculateTimeRange;
+    /**
+     * Generate recommendations based on analysis
+     */
+    private generateRecommendations;
+    /**
+     * Get performance report as formatted string
+     */
+    generateFormattedReport(): string;
+    private emptyPerformanceReport;
+}
+export declare const routingPerformanceAnalyzer: RoutingPerformanceAnalyzer;
+export {};

package/dist/analytics/routing-refiner.d.ts

@@ -0,0 +1,102 @@
+/**
+ * Routing Refiner for 0xRay
+ *
+ * Suggests new keyword mappings, optimizes existing mappings, and generates
+ * configuration updates based on analytics data from the routing system.
+ *
+ * @since 2026-03-05
+ */
+import { type PromptComparisonResult } from "./prompt-pattern-analyzer.js";
+import { routingPerformanceAnalyzer } from "./routing-performance-analyzer.js";
+export interface KeywordMappingSuggestion {
+    keyword: string;
+    targetAgent: string;
+    targetSkill: string;
+    suggestedConfidence: number;
+    reason: string;
+    evidence: {
+        frequency: number;
+        successRate: number;
+        avgConfidence: number;
+        sampleRequests: string[];
+    };
+    priority: "high" | "medium" | "low";
+}
+export interface MappingOptimization {
+    mappingId: string;
+    currentKeywords: string[];
+    currentAgent: string;
+    currentSkill: string;
+    optimizationType: "add_keywords" | "remove_keywords" | "adjust_confidence" | "reassign_agent";
+    suggestedChanges: {
+        keywordsToAdd?: string[];
+        keywordsToRemove?: string[];
+        newConfidence?: number;
+        newAgent?: string;
+    };
+    reason: string;
+    expectedImpact: string;
+}
+export interface ConfigurationUpdate {
+    generatedAt: Date;
+    summary: {
+        newMappings: number;
+        optimizedMappings: number;
+        removedMappings: number;
+        estimatedImprovement: string;
+    };
+    newMappings: KeywordMappingSuggestion[];
+    optimizations: MappingOptimization[];
+    warnings: string[];
+}
+export interface RefinementReport {
+    promptAnalysis: PromptComparisonResult;
+    performanceReport: ReturnType<typeof routingPerformanceAnalyzer.generatePerformanceReport>;
+    configurationUpdate: ConfigurationUpdate;
+    implementationSteps: string[];
+}
+declare class RoutingRefiner {
+    private readonly minSamplesForSuggestion;
+    private readonly minSuccessRateForSuggestion;
+    private readonly minConfidenceForSuggestion;
+    /**
+     * Generate comprehensive routing refinement recommendations
+     */
+    generateRefinementReport(): RefinementReport;
+    /**
+     * Generate configuration update suggestions
+     */
+    private generateConfigurationUpdate;
+    /**
+     * Suggest new keyword mappings based on analysis
+     */
+    private suggestNewKeywordMappings;
+    /**
+     * Suggest optimizations for existing mappings
+     */
+    private suggestMappingOptimizations;
+    /**
+     * Generate warnings for configuration updates
+     */
+    private generateWarnings;
+    /**
+     * Generate implementation steps
+     */
+    private generateImplementationSteps;
+    /**
+     * Get formatted refinement report
+     */
+    generateFormattedReport(): string;
+    /**
+     * Export configuration update as JSON
+     */
+    exportConfigurationUpdate(): string;
+    private calculatePriority;
+    private extractKeywords;
+    private selectBestAgentForMapping;
+    private deduplicateSuggestions;
+    private calculateRemovals;
+    private estimateImprovement;
+}
+export declare const routingRefiner: RoutingRefiner;
+export {};

package/dist/analytics/simple-pattern-analyzer.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Simple Pattern Analyzer for 0xRay
+ *
+ * Reads activity log → Counts patterns → Generates insights
+ *
+ * This is the "learning" system - simple pattern matching, not ML.
+ *
+ */
+import type { Outcome, ComplexityAccuracy } from "../core/framework-logger.js";
+export interface ParsedLogEntry {
+    timestamp: string;
+    jobId: string;
+    component: string;
+    action: string;
+    status: string;
+    duration?: number;
+    complexityScore?: number;
+    agentUsed?: string;
+    operationType?: string;
+    outcome?: Outcome;
+    complexityAccuracy?: ComplexityAccuracy;
+}
+export interface AgentStats {
+    attempts: number;
+    successes: number;
+    failures: number;
+    escalated: number;
+    autoFixed: number;
+    avgDuration: number;
+    totalDuration: number;
+}
+export interface TaskTypeStats {
+    count: number;
+    successRate: number;
+    avgComplexity: number;
+}
+export interface ComplexityStats {
+    underestimated: number;
+    accurate: number;
+    overestimated: number;
+    total: number;
+}
+export interface PatternInsights {
+    agentStats: Map<string, AgentStats>;
+    taskTypeStats: Map<string, TaskTypeStats>;
+    complexityStats: ComplexityStats;
+    totalEntries: number;
+    dateRange: {
+        start: string;
+        end: string;
+    };
+}
+export declare class SimplePatternAnalyzer {
+    private logPath;
+    private outcomesPath;
+    constructor(logPath?: string);
+    /**
+     * Main analysis method - reads log and returns insights
+     */
+    analyze(limit?: number): Promise<PatternInsights>;
+    /**
+     * Parse a single log line
+     */
+    private parseLine;
+    /**
+     * Calculate statistics from parsed entries
+     */
+    private calculateStats;
+    /**
+     * Generate human-readable insights
+     */
+    generateInsights(insights: PatternInsights): string[];
+    /**
+     * Generate insights as a formatted report
+     */
+    generateReport(): Promise<string>;
+    private emptyInsights;
+}
+export declare const patternAnalyzer: SimplePatternAnalyzer;

package/dist/architect/architect-tools.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Architect Tools - Integration layer between architect agent and contextual analysis system
+ * Provides tools for codebase intelligence, architectural assessment, and design planning
+ */
+import { CodebaseStructure } from "../delegation/codebase-context-analyzer.js";
+import { DependencyNode } from "../delegation/dependency-graph-builder.js";
+export interface CodebaseComplexityInfo {
+    averageComplexity: number;
+    highComplexityFiles: string[];
+    complexityDistribution: "low" | "medium" | "high" | "critical";
+    recommendations: string[];
+}
+export interface ContextAnalysisResult {
+    codebaseStructure: CodebaseStructure;
+    architecturalPatterns: string[];
+    dependencyIssues: string[];
+    scalabilityAssessment: {
+        score: number;
+        recommendations: string[];
+    };
+    maintainabilityIndex: number;
+    complexityAnalysis: CodebaseComplexityInfo;
+}
+export interface ArchitectureAssessment {
+    overallHealth: "excellent" | "good" | "fair" | "poor" | "critical";
+    scores: {
+        modularity: number;
+        coupling: number;
+        cohesion: number;
+        testability: number;
+        scalability: number;
+    };
+    issues: Array<{
+        type: "critical" | "major" | "minor";
+        description: string;
+        impact: string;
+        recommendation: string;
+    }>;
+    recommendations: string[];
+}
+export interface DependencyAnalysis {
+    graph: Map<string, DependencyNode>;
+    circularDependencies: string[];
+    tightlyCoupledModules: string[];
+    orphanModules: string[];
+    healthScore: number;
+    recommendations: string[];
+}
+/**
+ * Context Analysis Tool - Comprehensive codebase intelligence gathering
+ */
+export declare function contextAnalysis(projectRoot: string, files?: string[], depth?: "overview" | "detailed" | "comprehensive"): Promise<ContextAnalysisResult>;
+/**
+ * Codebase Structure Tool - File organization and module analysis
+ */
+export declare function codebaseStructure(projectRoot: string, includeMetrics?: boolean): Promise<any>;
+/**
+ * Dependency Analysis Tool - Component relationship and coupling analysis
+ */
+export declare function dependencyAnalysis(projectRoot: string, focusAreas?: string[]): Promise<DependencyAnalysis>;
+/**
+ * Architecture Assessment Tool - Overall architectural health evaluation
+ */
+export declare function architectureAssessment(projectRoot: string, assessmentType?: "quick" | "comprehensive"): Promise<ArchitectureAssessment>;
+export declare const architectTools: {
+    contextAnalysis: typeof contextAnalysis;
+    codebaseStructure: typeof codebaseStructure;
+    dependencyAnalysis: typeof dependencyAnalysis;
+    architectureAssessment: typeof architectureAssessment;
+};

package/dist/architect/architectural-integrity.d.ts

@@ -0,0 +1,20 @@
+/**
+ * ARCHITECTURAL INTEGRITY ENFORCEMENT
+ *
+ * This module ensures that critical framework components are always active
+ * and integrated, preventing the staged initialization issues that broke
+ * the post-processor and rules engine enforcement.
+ */
+/**
+ * Verify all critical components are active and integrated
+ */
+export declare function verifyArchitecturalIntegrity(): Promise<{
+    allActive: boolean;
+    issues: string[];
+    recommendations: string[];
+}>;
+/**
+ * Force activation of critical components if missing
+ * This prevents staged initialization from breaking the framework
+ */
+export declare function ensureCriticalComponents(): Promise<void>;