0xray 2.0.0 → 2.0.1

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

@@ -0,0 +1,99 @@
+/**
+ * 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.
+ *
+ * @version 1.0.0
+ * @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,101 @@
+/**
+ * Routing Performance Analyzer for 0xRay
+ *
+ * Analyzes routing success rates, keyword effectiveness, and confidence thresholds.
+ * Integrates with RoutingOutcomeTracker to provide comprehensive routing metrics.
+ *
+ * @version 1.0.0
+ * @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,104 @@
+/**
+ * Routing Refiner for 0xRay
+ *
+ * Suggests new keyword mappings, optimizes existing mappings, and generates
+ * configuration updates based on analytics data from the routing system.
+ *
+ * @version 1.0.0
+ * @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 {
+    version: string;
+    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/routing-refiner.js

@@ -36,7 +36,7 @@ class RoutingRefiner {
         const optimizations = this.suggestMappingOptimizations(promptAnalysis, performanceReport);
         const warnings = this.generateWarnings(newMappings, optimizations);
         return {
-            version: "1.22.67",
+            version: "2.0.0",
             generatedAt: new Date(),
             summary: {
                 newMappings: newMappings.length,

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

@@ -0,0 +1,80 @@
+/**
+ * Simple Pattern Analyzer for 0xRay
+ *
+ * Reads activity log → Counts patterns → Generates insights
+ *
+ * This is the "learning" system - simple pattern matching, not ML.
+ *
+ * @version 1.0.0
+ */
+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>;

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

@@ -0,0 +1,103 @@
+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 StringRayPerformanceBenchmark {
+    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: StringRayPerformanceBenchmark;

package/dist/cli/commands/analytics-disable.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Analytics Disable CLI Command
+ *
+ * Disables 0xRay Central Analytics with immediate opt-out
+ *
+ * Usage: npx 0xray analytics disable
+ */
+export declare const analyticsDisableCommand: import("commander").Command;
+export default analyticsDisableCommand;

package/dist/cli/commands/analytics-enable-action.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Analytics Enable Action
+ *
+ * Enables 0xRay Central Analytics with opt-in consent
+ *
+ * Usage: npx 0xray analytics enable [--categories reflections,logs,metrics,patterns]
+ */
+export declare function analyticsEnableAction(options: any): Promise<void>;

package/dist/cli/commands/analytics-preview.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Analytics Preview CLI Command
+ *
+ * Shows what data would be submitted without actually submitting it
+ *
+ * Usage: npx 0xray analytics preview [--type reflections|logs|metrics|patterns] [--all]
+ */
+export declare const analyticsPreviewCommand: import("commander").Command;
+export default analyticsPreviewCommand;

package/dist/cli/commands/analytics-status.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Analytics Status CLI Command
+ *
+ * Shows current consent and analytics status
+ *
+ * Usage: npx 0xray analytics status
+ */
+export declare const analyticsStatusCommand: import("commander").Command;
+export default analyticsStatusCommand;

package/dist/cli/commands/antigravity-status.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Antigravity Status CLI Command
+ *
+ * Shows status of all installed skills.
+ *
+ * Usage: npx 0xray antigravity status
+ */
+export declare function antigravityStatusCommand(): Promise<void>;
+export default antigravityStatusCommand;

package/dist/cli/commands/archive-logs.d.ts

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+/**
+ * Standalone Log Archive CLI
+ *
+ * Archives log files without requiring framework boot.
+ * Used by git hooks to prevent log truncation.
+ *
+ * @version 1.0.0
+ */
+interface ArchiveResult {
+    archived: number;
+    errors: string[];
+}
+interface LogArchiveConfig {
+    maxFileSizeMB: number;
+    rotationIntervalHours: number;
+    compressionEnabled: boolean;
+    maxArchives: number;
+}
+/**
+ * Archive log files without framework dependencies
+ */
+export declare function archiveLogFiles(config?: LogArchiveConfig, jobId?: string): Promise<ArchiveResult>;
+export {};

package/dist/cli/commands/credible-init.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Credible Init CLI Command
+ *
+ * Initializes a Credible Pod - a self-contained agent environment.
+ *
+ * Usage: npx 0xray credible init [options]
+ *
+ * Status: PLANNED - Not yet implemented
+ */
+export declare function credibleInitCommand(): Promise<void>;
+export default credibleInitCommand;

package/dist/cli/commands/grok-install.d.ts

@@ -0,0 +1,7 @@
+/**
+ * CLI command: 0xray grok install
+ *
+ * Helps users register 0xRay MCP servers with the Grok CLI.
+ */
+import { Command } from 'commander';
+export declare function registerGrokCommands(grokCmd: Command): void;

package/dist/cli/commands/hermes-install.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerHermesCommands(hermesCmd: Command): void;