0xray 2.0.0 → 2.0.1

package/dist/services/inference-tuner.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Inference Tuner - Autonomous Learning Service
+ *
+ * Implements the autonomous inference improvement loop:
+ * 1. Collects routing outcomes and pattern metrics
+ * 2. Analyzes performance and detects drift
+ * 3. Generates refinement reports
+ * 4. Updates configuration automatically
+ *
+ * @module services
+ * @version 1.0.0
+ */
+export interface TuningConfig {
+    autoUpdateMappings: boolean;
+    autoUpdateThresholds: boolean;
+    minConfidenceThreshold: number;
+    minSuccessRateForAutoAdd: number;
+    learningIntervalMs: number;
+    maxMappingsToAdd: number;
+}
+export declare class InferenceTuner {
+    private config;
+    private lastTuningTime;
+    private tuningInProgress;
+    private tuningInterval;
+    constructor(config?: Partial<TuningConfig>);
+    /**
+     * Start autonomous tuning
+     */
+    start(): void;
+    /**
+     * Stop autonomous tuning
+     */
+    stop(): void;
+    /**
+     * Run a single tuning cycle
+     */
+    runTuningCycle(): Promise<void>;
+    /**
+     * Perform the actual tuning work
+     */
+    private performTuning;
+    /**
+     * Suggest new mappings based on patterns and outcomes
+     */
+    private suggestMappingsFromPatterns;
+    /**
+     * Resolve the path to the routing-mappings.json file.
+     * Checks multiple known locations and returns the first one found.
+     */
+    private resolveMappingsPath;
+    /**
+     * Load current routing mappings from disk.
+     */
+    private loadMappings;
+    /**
+     * Save routing mappings to disk.
+     */
+    private saveMappings;
+    /**
+     * Add a keyword mapping to the routing-mappings.json file.
+     *
+     * Checks for conflicts (keyword already mapped to a different agent)
+     * before adding. If the keyword already exists for the same agent,
+     * updates the confidence if the new value is higher.
+     */
+    private addKeywordMapping;
+    /**
+     * Get tuning status
+     */
+    getStatus(): {
+        running: boolean;
+        lastTuningTime: number;
+        config: TuningConfig;
+    };
+}
+export declare const inferenceTuner: InferenceTuner;

package/dist/session/index.d.ts

@@ -0,0 +1,3 @@
+export { SessionCleanupManager, createSessionCleanupManager } from "./session-cleanup-manager.js";
+export { SessionMonitor, createSessionMonitor } from "./session-monitor.js";
+export { SessionStateManager, createSessionStateManager } from "./session-state-manager.js";

package/dist/session/session-cleanup-manager.d.ts

@@ -0,0 +1,118 @@
+/**
+ * Session Cleanup Manager
+ *
+ * Manages automatic cleanup of sessions with TTL-based expiration,
+ * idle session detection, and manual cleanup utilities.
+ *
+ * @version 1.0.0
+ * @since 2026-01-07
+ */
+import { StringRayStateManager } from "../state/state-manager.js";
+import { SessionMonitor } from "./session-monitor.js";
+export interface SessionMetadata {
+    sessionId: string;
+    createdAt: number;
+    lastActivity: number;
+    ttlMs: number;
+    isActive: boolean;
+    agentCount: number;
+    memoryUsage: number;
+    cleanupReason?: string;
+}
+export interface CleanupConfig {
+    ttlMs: number;
+    idleTimeoutMs: number;
+    maxSessions: number;
+    cleanupIntervalMs: number;
+    enableAutoCleanup: boolean;
+}
+export interface CleanupResult {
+    sessionsCleaned: number;
+    sessionsExpired: number;
+    sessionsIdle: number;
+    errors: string[];
+}
+export declare class SessionCleanupManager {
+    private stateManager;
+    private config;
+    private cleanupInterval?;
+    private _sessionMetadata?;
+    private _metadataLoaded;
+    private sessionMonitor;
+    constructor(stateManager: StringRayStateManager, config?: Partial<CleanupConfig>, sessionMonitor?: SessionMonitor);
+    /**
+     * Lazy-loaded session metadata - loads from state manager on first access
+     */
+    private get sessionMetadata();
+    private set sessionMetadata(value);
+    /**
+     * Initialize cleanup manager and start auto-cleanup if enabled
+     */
+    private initialize;
+    start(): void;
+    /**
+     * Register a new session for cleanup tracking
+     */
+    registerSession(sessionId: string, ttlMs?: number): void;
+    updateActivity(sessionId: string): void;
+    updateMetadata(sessionId: string, updates: Partial<SessionMetadata>): void;
+    /**
+     * Check if session should be cleaned up
+     */
+    shouldCleanup(sessionId: string): boolean;
+    /**
+     * Perform cleanup of expired/idle sessions
+     */
+    performCleanup(): Promise<CleanupResult>;
+    /**
+     * Manually cleanup a specific session
+     */
+    manualCleanup(sessionId: string, reason?: string): Promise<boolean>;
+    /**
+     * Cleanup all sessions (emergency cleanup)
+     */
+    emergencyCleanup(): Promise<CleanupResult>;
+    /**
+     * Get cleanup statistics
+     */
+    getCleanupStats(): {
+        totalSessions: number;
+        activeSessions: number;
+        expiredSessions: number;
+        idleSessions: number;
+        nextCleanup: number;
+    };
+    /**
+     * Get session metadata
+     */
+    getSessionMetadata(sessionId: string): SessionMetadata | undefined;
+    /**
+     * List all sessions with metadata
+     */
+    listSessions(): SessionMetadata[];
+    /**
+     * Start automatic cleanup interval
+     */
+    private startAutoCleanup;
+    /**
+     * Stop automatic cleanup
+     */
+    stopAutoCleanup(): void;
+    /**
+     * Load session metadata from state manager (lazy loading)
+     */
+    private loadSessionMetadata;
+    /**
+     * Persist session metadata to state manager
+     */
+    private persistSessionMetadata;
+    /**
+     * Cleanup a specific session
+     */
+    private cleanupSession;
+    /**
+     * Shutdown cleanup manager
+     */
+    shutdown(): void;
+}
+export declare const createSessionCleanupManager: (stateManager: StringRayStateManager, config?: Partial<CleanupConfig>, sessionMonitor?: SessionMonitor) => SessionCleanupManager;

package/dist/session/session-monitor.d.ts

@@ -0,0 +1,133 @@
+/**
+ * Session Monitor
+ *
+ * Provides real-time monitoring of sessions with health checks,
+ * performance tracking, and alerting capabilities.
+ *
+ * @version 1.0.0
+ * @since 2026-01-07
+ */
+import { StringRayStateManager } from "../state/state-manager.js";
+import { SessionCoordinator } from "../delegation/session-coordinator.js";
+import { SessionCleanupManager } from "./session-cleanup-manager.js";
+export interface SessionHealth {
+    sessionId: string;
+    status: "healthy" | "degraded" | "critical" | "unknown";
+    lastCheck: number;
+    responseTime: number;
+    errorCount: number;
+    activeAgents: number;
+    memoryUsage: number;
+    issues: string[];
+}
+export interface SessionMetrics {
+    sessionId: string;
+    timestamp: number;
+    totalInteractions: number;
+    successfulInteractions: number;
+    failedInteractions: number;
+    averageResponseTime: number;
+    conflictResolutionRate: number;
+    coordinationEfficiency: number;
+    memoryUsage: number;
+    agentCount: number;
+}
+export interface InteractionRecord {
+    timestamp: number;
+    duration: number;
+    success: boolean;
+    agentId?: string;
+    operation?: string;
+}
+export interface MonitorConfig {
+    healthCheckIntervalMs: number;
+    metricsCollectionIntervalMs: number;
+    alertThresholds: {
+        maxResponseTime: number;
+        maxErrorRate: number;
+        maxMemoryUsage: number;
+        minCoordinationEfficiency: number;
+        maxConflicts: number;
+    };
+    enableAlerts: boolean;
+    enableMetrics: boolean;
+}
+export interface Alert {
+    id: string;
+    sessionId: string;
+    type: "health" | "performance" | "resource" | "coordination";
+    severity: "low" | "medium" | "high" | "critical";
+    message: string;
+    timestamp: number;
+    resolved: boolean;
+    resolvedAt?: number;
+}
+export declare class SessionMonitor {
+    private stateManager;
+    private sessionCoordinator;
+    private cleanupManager;
+    private config;
+    private healthChecks;
+    private metricsHistory;
+    private activeAlerts;
+    private healthCheckInterval?;
+    private metricsInterval?;
+    private interactionHistory;
+    private sessionResponseTimes;
+    private sessionErrors;
+    constructor(stateManager: StringRayStateManager, sessionCoordinator: SessionCoordinator, cleanupManager: SessionCleanupManager, config?: Partial<MonitorConfig>);
+    start(): void;
+    registerSession(sessionId: string): void;
+    unregisterSession(sessionId: string): void;
+    performHealthCheck(sessionId: string): Promise<SessionHealth>;
+    collectMetrics(sessionId: string): SessionMetrics | null;
+    getHealthStatus(sessionId: string): SessionHealth | null;
+    getMetricsHistory(sessionId: string, limit?: number): SessionMetrics[];
+    getActiveAlerts(sessionId?: string): Alert[];
+    resolveAlert(alertId: string): boolean;
+    getMonitoringStats(): {
+        totalSessions: number;
+        healthySessions: number;
+        degradedSessions: number;
+        criticalSessions: number;
+        activeAlerts: number;
+        totalMetricsPoints: number;
+    };
+    private startHealthChecks;
+    private startMetricsCollection;
+    private generateAlerts;
+    private loadPersistedData;
+    private persistHealthData;
+    private persistMetricsData;
+    private persistAlertData;
+    shutdown(): void;
+    /**
+     * Record an interaction for tracking
+     */
+    recordInteraction(sessionId: string, interaction: InteractionRecord): void;
+    /**
+     * Get interaction history for a session
+     */
+    getInteractionHistory(sessionId: string, limit?: number): InteractionRecord[];
+    /**
+     * Perform comprehensive health checks on a session
+     */
+    private performComprehensiveHealthChecks;
+    /**
+     * Calculate failure ratio from interactions
+     */
+    private calculateFailureRatio;
+    /**
+     * Calculate conflict resolution rate from interactions
+     */
+    private calculateConflictResolutionRate;
+    /**
+     * Calculate coordination efficiency from interactions
+     */
+    private calculateCoordinationEfficiency;
+    private persistInteractionData;
+    private calculateSessionMemoryUsage;
+    private countSessionConflicts;
+    private calculateAverageResponseTime;
+}
+export declare const createSessionMonitor: (stateManager: StringRayStateManager, sessionCoordinator: SessionCoordinator, cleanupManager: SessionCleanupManager, config?: Partial<MonitorConfig>) => SessionMonitor;

package/dist/session/session-state-manager.d.ts

@@ -0,0 +1,145 @@
+/**
+ * Session State Manager
+ *
+ * Manages cross-session state sharing, dependency tracking,
+ * and coordination for complex workflows.
+ *
+ * @version 1.0.0
+ * @since 2026-01-07
+ */
+import { StringRayStateManager } from "../state/state-manager.js";
+import { SessionCoordinator } from "../delegation/session-coordinator.js";
+export interface SessionDependency {
+    sessionId: string;
+    dependsOn: string[];
+    dependedBy: string[];
+    state: "pending" | "active" | "completed" | "failed";
+    priority: number;
+    metadata: Record<string, unknown>;
+}
+export interface SessionGroup {
+    groupId: string;
+    sessionIds: string[];
+    coordinatorSession: string;
+    state: "forming" | "active" | "completing" | "completed" | "failed";
+    sharedState: Map<string, {
+        value: unknown;
+        fromSessionId: string;
+        timestamp: number;
+    }>;
+    createdAt: number;
+    completedAt?: number;
+}
+export interface MigrationPlan {
+    sessionId: string;
+    targetCoordinator: string;
+    stateTransfer: Map<string, unknown>;
+    migrationSteps: string[];
+    rollbackSteps: string[];
+}
+export interface FailoverConfig {
+    sessionId: string;
+    backupCoordinators: string[];
+    failoverThreshold: number;
+    autoFailover: boolean;
+}
+export declare class SessionStateManager {
+    private stateManager;
+    private sessionCoordinator;
+    private dependencies;
+    private sessionGroups;
+    private failoverConfigs;
+    constructor(stateManager: StringRayStateManager, sessionCoordinator: SessionCoordinator);
+    /**
+     * Share state between sessions
+     */
+    shareState(fromSessionId: string, toSessionId: string, key: string, value: unknown): boolean;
+    /**
+     * Broadcast state to multiple sessions
+     */
+    broadcastState(fromSessionId: string, targetSessionIds: string[], key: string, value: unknown): number;
+    /**
+     * Register session dependency
+     */
+    registerDependency(sessionId: string, dependsOn: string[], metadata?: Record<string, unknown>): void;
+    /**
+     * Update dependency state
+     */
+    updateDependencyState(sessionId: string, state: SessionDependency["state"]): void;
+    /**
+     * Get dependency chain for a session
+     */
+    getDependencyChain(sessionId: string): {
+        dependencies: string[];
+        dependents: string[];
+        canStart: boolean;
+    };
+    /**
+     * Create session group for complex workflows
+     */
+    createSessionGroup(groupId: string, sessionIds: string[], coordinatorSession: string): SessionGroup;
+    /**
+     * Update session group state
+     */
+    updateSessionGroupState(groupId: string, state: SessionGroup["state"]): void;
+    /**
+     * Share state within a session group
+     */
+    shareGroupState(groupId: string, key: string, value: unknown, fromSessionId: string): boolean;
+    /**
+     * Get session group state
+     */
+    getGroupState(groupId: string, key: string): unknown;
+    /**
+     * Plan session migration
+     */
+    planMigration(sessionId: string, targetCoordinator: string): MigrationPlan;
+    /**
+     * Validate migration plan before execution
+     */
+    validateMigrationPlan(plan: MigrationPlan): Promise<{
+        valid: boolean;
+        errors: string[];
+        warnings: string[];
+    }>;
+    /**
+     * Validate rollback capability for a migration plan
+     */
+    validateRollbackCapability(plan: MigrationPlan): {
+        canRollback: boolean;
+        reason?: string;
+    };
+    /**
+     * Find orphaned agents in dependency graph
+     */
+    findOrphanedAgents(allAgents: string[], dependencies: Record<string, string[]>): string[];
+    /**
+     * Execute session migration
+     */
+    executeMigration(plan: MigrationPlan): Promise<boolean>;
+    /**
+     * Configure failover for a session
+     */
+    configureFailover(sessionId: string, backupCoordinators: string[], failoverThreshold: number, autoFailover: boolean): void;
+    /**
+     * Execute failover for a session
+     */
+    executeFailover(sessionId: string): Promise<boolean>;
+    /**
+     * Get coordination statistics
+     */
+    getCoordinationStats(): {
+        totalDependencies: number;
+        activeDependencies: number;
+        totalGroups: number;
+        activeGroups: number;
+        failoverConfigs: number;
+    };
+    private propagateDependencyUpdate;
+    private rollbackMigration;
+    private persistDependencies;
+    private persistSessionGroups;
+    private persistFailoverConfigs;
+    shutdown(): void;
+}
+export declare const createSessionStateManager: (stateManager: StringRayStateManager, sessionCoordinator: SessionCoordinator) => SessionStateManager;

package/dist/skills/registry.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.22.67",
+  "version": "2.0.0",
   "description": "0xRay Skills Registry - recommended skill sources for consumers",
   "sources": [
     {

package/dist/state/context-providers.d.ts

@@ -0,0 +1,4 @@
+export interface ContextProviders {
+    createProvider: <T>(value: T) => unknown;
+    useContext: <T>() => T;
+}

package/dist/state/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./state-manager.js";
+export * from "./context-providers.js";
+export * from "./state-types.js";
+export { StringRayStateManager } from "./state-manager.js";

package/dist/state/state-manager.d.ts

@@ -0,0 +1,42 @@
+export interface StateManager {
+    get: <T>(key: string) => T | undefined;
+    set: <T>(key: string, value: T) => void;
+    clear: (key: string) => void;
+}
+export declare class StringRayStateManager implements StateManager {
+    private store;
+    private persistencePath;
+    private persistenceEnabled;
+    private writeQueue;
+    private initialized;
+    private earlyOperationsQueue;
+    static readonly VERSION = "1.5.2";
+    constructor(persistencePath?: string | undefined, persistenceEnabled?: boolean);
+    private initializePersistence;
+    private persistToDisk;
+    private isSerializable;
+    private schedulePersistence;
+    get<T>(key: string): T | undefined;
+    set<T>(key: string, value: T): void;
+    clear(key: string): void;
+    clearAll(): void;
+    isPersistenceEnabled(): boolean;
+    getPersistenceStats(): {
+        enabled: boolean;
+        initialized: boolean;
+        keysInMemory: number;
+        pendingWrites: number;
+    };
+    getStateVersion(): string;
+    getAuditLog(): Array<{
+        timestamp: Date;
+        operation: string;
+        key: string;
+    }>;
+    resolveConflict(conflict: {
+        key: string;
+        value1: unknown;
+        value2: unknown;
+    }): unknown;
+}
+export { StringRayStateManager as StrRayStateManager };

package/dist/state/state-types.d.ts

@@ -0,0 +1,5 @@
+export type StateValue = string | number | boolean | object | null;
+export interface StateTypes {
+    value: StateValue;
+    timestamp: number;
+}

package/dist/testing/memory-regression-suite.d.ts

@@ -0,0 +1,105 @@
+import { EventEmitter } from "events";
+/**
+ * Memory Regression Testing Suite
+ * Automated testing for memory usage patterns and leak detection
+ */
+export interface MemoryRegressionTest {
+    name: string;
+    description: string;
+    setup?: (() => Promise<void> | void) | undefined;
+    execute: () => Promise<any> | any;
+    cleanup?: (() => Promise<void> | void) | undefined;
+    expectedMemoryDelta: {
+        maxIncrease: number;
+        acceptableLeak: number;
+    };
+}
+export interface MemoryRegressionResult {
+    testName: string;
+    passed: boolean;
+    memoryDelta: number;
+    leakRate: number;
+    duration: number;
+    error?: string;
+    recommendations: string[];
+}
+export interface RegressionSuiteConfig {
+    testTimeout: number;
+    memorySamplingInterval: number;
+    acceptableMemoryGrowth: number;
+    leakDetectionThreshold: number;
+}
+export declare class MemoryRegressionTester extends EventEmitter {
+    private config;
+    private tests;
+    constructor(config?: Partial<RegressionSuiteConfig>);
+    /**
+     * Add a regression test
+     */
+    addTest(test: MemoryRegressionTest): void;
+    /**
+     * Run all regression tests
+     */
+    runAllTests(): Promise<MemoryRegressionResult[]>;
+    /**
+     * Run a single regression test
+     */
+    private runTest;
+    /**
+     * Create a standard memory regression test
+     */
+    createStandardTest(name: string, description: string, testFunction: () => Promise<any> | any, options?: {
+        maxMemoryIncrease?: number;
+        acceptableLeakRate?: number;
+        setup?: () => Promise<void> | void;
+        cleanup?: () => Promise<void> | void;
+    }): MemoryRegressionTest;
+    /**
+     * Generate test report
+     */
+    generateReport(results: MemoryRegressionResult[]): string;
+    /**
+     * Calculate variance of memory samples
+     */
+    private calculateVariance;
+}
+export declare const memoryTestTemplates: {
+    sessionOperations: (sessionCount?: number) => {
+        name: string;
+        description: string;
+        setup: () => Promise<void>;
+        execute: () => Promise<{
+            id: string;
+            data: {
+                userId: number;
+                metadata: {
+                    created: number;
+                    active: boolean;
+                };
+            };
+        }[]>;
+        cleanup: () => Promise<void>;
+        expectedMemoryDelta: {
+            maxIncrease: number;
+            acceptableLeak: number;
+        };
+    };
+    cacheOperations: (cacheSize?: number) => {
+        name: string;
+        description: string;
+        execute: () => Promise<number>;
+        expectedMemoryDelta: {
+            maxIncrease: number;
+            acceptableLeak: number;
+        };
+    };
+    streamingOperations: (messageCount?: number) => {
+        name: string;
+        description: string;
+        execute: () => Promise<number>;
+        expectedMemoryDelta: {
+            maxIncrease: number;
+            acceptableLeak: number;
+        };
+    };
+};

package/dist/utils/batch-operations.d.ts

@@ -0,0 +1,25 @@
+export interface ReplacementOperation {
+    pattern: string;
+    replacement: string;
+    isRegex?: boolean;
+    caseSensitive?: boolean;
+}
+export interface BatchResult {
+    success: boolean;
+    filesModified: number;
+    errors: Array<{
+        file: string;
+        error: string;
+    }>;
+    duration: number;
+}
+export interface FileOperation {
+    filePath: string;
+    operation: "replace" | "append" | "prepend" | "delete";
+    content?: string;
+    pattern?: string;
+}
+export declare function batchReplace(files: string[], operations: ReplacementOperation[]): Promise<BatchResult>;
+export declare function batchFileOperations(operations: FileOperation[]): Promise<BatchResult>;
+export declare function findFilesWithPattern(directory: string, pattern: string, extensions?: string[]): string[];
+export declare function bulkRename(directory: string, oldName: string, newName: string, extensions?: string[]): Promise<BatchResult>;