0xray 2.0.0 → 2.1.0

package/dist/monitoring/memory-monitor.d.ts

@@ -0,0 +1,113 @@
+import { EventEmitter } from "events";
+export interface MemoryStats {
+    heapUsed: number;
+    heapTotal: number;
+    external: number;
+    rss: number;
+    timestamp: number;
+    sessionId?: string;
+}
+export interface MemoryLeakAlert {
+    type: "leak_detected" | "high_usage" | "spike_detected";
+    severity: "low" | "medium" | "high" | "critical";
+    message: string;
+    details: {
+        currentUsage: number;
+        threshold: number;
+        trend: "increasing" | "stable" | "decreasing";
+        recommendations: string[];
+    };
+}
+export interface MemoryMonitorConfig {
+    checkInterval: number;
+    alertThresholds: {
+        warning: number;
+        critical: number;
+        leakDetection: {
+            growthRate: number;
+            sustainedPeriod: number;
+        };
+    };
+    enableFrameworkLogging: boolean;
+    sessionTracking: boolean;
+}
+export interface MemorySummary {
+    current: MemoryStats;
+    peak: MemoryStats;
+    average: number;
+    trend: "increasing" | "stable" | "decreasing";
+}
+export declare class MemoryMonitor extends EventEmitter {
+    private config;
+    private monitoringInterval;
+    private statsHistory;
+    private maxHistorySize;
+    private leakDetectionEnabled;
+    private lastLeakCheck;
+    private leakCheckInterval;
+    private listenersInitialized;
+    constructor(config?: Partial<MemoryMonitorConfig>);
+    /**
+     * Start memory monitoring
+     */
+    start(): void;
+    /**
+     * Stop memory monitoring
+     */
+    stop(): void;
+    /**
+     * Get current memory statistics
+     */
+    getCurrentStats(): MemoryStats;
+    /**
+     * Check memory usage and detect issues
+     */
+    private checkMemory;
+    /**
+     * Check memory usage against thresholds
+     */
+    private checkThresholds;
+    /**
+     * Detect potential memory leaks
+     */
+    private detectMemoryLeaks;
+    /**
+     * Calculate memory usage trend
+     */
+    private calculateTrend;
+    /**
+     * Emit memory alert
+     */
+    private emitAlert;
+    /**
+     * Log memory stats to framework log
+     */
+    private logFrameworkMemory;
+    /**
+     * Get memory usage history
+     */
+    getHistory(hours?: number): MemoryStats[];
+    /**
+     * Get memory usage summary
+     */
+    getSummary(): MemorySummary;
+    /**
+     * Force garbage collection (if available)
+     */
+    forceGC(): boolean;
+    /**
+     * Internal logging method - writes to framework log only
+     */
+    private log;
+    /**
+     * Safely add an alert listener, preventing duplicates
+     */
+    addAlertListener(callback: (alert: MemoryLeakAlert) => void): void;
+}
+export declare const memoryMonitor: MemoryMonitor;
+export declare function getMemoryUsage(): MemoryStats;
+export declare function logMemoryUsage(): MemoryStats;
+export declare function checkMemoryHealth(): {
+    healthy: boolean;
+    issues: string[];
+};

package/dist/monitoring/nudge-watchdog.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Nudge Watchdog - Detects and breaks stuck AI patterns
+ *
+ * Monitors agent actions and detects common failure patterns:
+ * - think-loop: AI keeps outputting thinking tags but no progress
+ * - syntax-loop: AI keeps trying to fix same file/error multiple times
+ * - death-spiral: AI re-explains instead of fixing
+ * - tool-loop: Same tool called with similar args repeatedly
+ * - repair-failure: Processor indicates fix but error persists
+ *
+ * @module monitoring/nudge-watchdog
+ * @version 1.0.0
+ */
+import { EventEmitter } from "events";
+export interface NudgeConfig {
+    enabled: boolean;
+    think_loop_threshold: number;
+    syntax_loop_threshold: number;
+    tool_loop_threshold: number;
+    death_spiral_threshold: number;
+    cooldown_ms: number;
+}
+export type NudgeType = "think-loop" | "syntax-loop" | "death-spiral" | "tool-loop" | "repair-failure";
+export interface StuckPattern {
+    type: NudgeType;
+    count: number;
+    firstSeen: number;
+    lastSeen: number;
+    details: Record<string, unknown>;
+}
+export interface NudgeAction {
+    type: NudgeType;
+    message: string;
+    suggestion: string;
+    priority: number;
+}
+declare class NudgeWatchdog extends EventEmitter {
+    private config;
+    private patterns;
+    private lastNudgeTime;
+    private thinkTagCount;
+    private lastThinkTagTime;
+    private toolCallHistory;
+    private fixAttempts;
+    private explanationCount;
+    private codeChangeCount;
+    private listenersInitialized;
+    constructor(config?: Partial<NudgeConfig>);
+    private loadConfigFromFeatures;
+    start(): void;
+    stop(): void;
+    recordThinkTag(): void;
+    recordCodeChange(): void;
+    recordToolCall(tool: string, args: string): void;
+    recordFixAttempt(filePath: string, error: string): void;
+    recordExplanation(): void;
+    recordProcessorFix(filePath: string, fixed: boolean, errorPersisted: boolean): void;
+    private checkThinkLoop;
+    private checkToolLoop;
+    private checkSyntaxLoop;
+    private checkDeathSpiral;
+    private checkRepairFailure;
+    private checkCooldownAndNudge;
+    private triggerNudge;
+    getNudgeSuggestion(type: NudgeType, context?: Record<string, unknown>): string;
+    private hashArgs;
+    private isSimilarError;
+    private cleanupOldToolCalls;
+    reset(): void;
+    getStats(): {
+        thinkTags: number;
+        codeChanges: number;
+        explanations: number;
+        activePatterns: number;
+        lastNudgeAgo: number;
+    };
+    private log;
+}
+export declare const nudgeWatchdog: NudgeWatchdog;
+export declare function recordThinkTag(): void;
+export declare function recordCodeChange(): void;
+export declare function recordToolCall(tool: string, args: string): void;
+export declare function recordFixAttempt(filePath: string, error: string): void;
+export declare function recordExplanation(): void;
+export declare function getNudgeSuggestion(type: NudgeType, context?: Record<string, unknown>): string;
+export declare function getNudgeWatchdog(): NudgeWatchdog;
+export declare function recordProcessorFix(filePath: string, fixed: boolean, errorPersisted: boolean): void;
+export {};

package/dist/monitoring/test-auto-generation-monitor.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Test Auto-Generation Monitor
+ *
+ * Tracks and reports on test auto-generation activity.
+ * Provides metrics on test creation success/failure rates.
+ *
+ * @since 2026-02-22
+ */
+export interface TestGenerationMetrics {
+    totalFilesProcessed: number;
+    testsGenerated: number;
+    testsSkipped: number;
+    testsFailed: number;
+    startTime: number;
+    lastGenerationTime: number | null;
+}
+export interface TestGenerationEvent {
+    type: "generated" | "skipped" | "failed";
+    filePath: string;
+    testFile: string | null;
+    timestamp: number;
+    reason?: string;
+}
+declare class TestAutoGenerationMonitor {
+    private metrics;
+    private events;
+    private maxEvents;
+    private metricsFile;
+    constructor(metricsDir?: string);
+    /**
+     * Load metrics from disk if they exist
+     */
+    private loadMetrics;
+    /**
+     * Save metrics to disk
+     */
+    private saveMetrics;
+    /**
+     * Record a test generation event
+     */
+    recordEvent(event: TestGenerationEvent): void;
+    /**
+     * Get current metrics
+     */
+    getMetrics(): TestGenerationMetrics;
+    /**
+     * Get recent events
+     */
+    getRecentEvents(count?: number): TestGenerationEvent[];
+    /**
+     * Get success rate as percentage
+     */
+    getSuccessRate(): number;
+    /**
+     * Generate a status report
+     */
+    generateReport(): string;
+    /**
+     * Reset metrics (for testing)
+     */
+    reset(): void;
+}
+export declare const testAutoGenerationMonitor: TestAutoGenerationMonitor;
+export {};

package/dist/orchestrator/agent-spawn-governor.d.ts

@@ -0,0 +1,127 @@
+/**
+ * Agent Spawn Governor
+ *
+ * Critical governance component that prevents infinite agent spawning
+ * and enforces spawn limits across the multi-agent orchestration system.
+ *
+ * @version 1.0.0
+ * @since 2026-01-23
+ */
+export interface SpawnContext {
+    agentType: string;
+    parentAgent?: string;
+    operation?: string;
+    triggeredBy?: string;
+    sessionId?: string;
+    priority?: "high" | "medium" | "low";
+}
+export interface SpawnRecord {
+    id: string;
+    agentType: string;
+    parentAgent?: string | undefined;
+    timestamp: number;
+    status: "active" | "completed" | "failed" | "terminated";
+    context: SpawnContext;
+}
+export interface SpawnLimits {
+    perAgentType: Record<string, number>;
+    totalConcurrent: number;
+    spawnRateLimit: {
+        maxPerMinute: number;
+        windowMs: number;
+    };
+    memoryLimit: {
+        maxMemoryMB: number;
+        emergencyThresholdMB: number;
+        cleanupIntervalMs: number;
+    };
+}
+export interface SpawnAuthorization {
+    authorized: boolean;
+    trackingId?: string;
+    reason?: string;
+    warnings?: string[];
+}
+export declare class AgentSpawnGovernor {
+    private limits;
+    private activeAgents;
+    private spawnHistory;
+    private readonly maxHistorySize;
+    private readonly cleanupInterval;
+    private readonly persistenceTimeout;
+    private readonly maxRetries;
+    private readonly retryDelay;
+    private cleanupTimer?;
+    private memoryMonitorInterval?;
+    private authorizationQueue;
+    private isProcessingAuthorization;
+    private getDefaultLimits;
+    private readonly defaultLimits;
+    constructor(limits?: Partial<SpawnLimits>, autoStart?: boolean);
+    private startPeriodicCleanup;
+    private startMemoryMonitoring;
+    private checkMemoryBudget;
+    private emergencyMemoryCleanup;
+    private aggressiveCleanup;
+    private deepCleanupContexts;
+    private sanitizeContext;
+    /**
+     * Authorize a new agent spawn
+     */
+    authorizeSpawn(context: SpawnContext): Promise<SpawnAuthorization>;
+    private processNextAuthorization;
+    private performAuthorization;
+    private checkAgentLimitsWithRetry;
+    private getTotalActiveWithRetry;
+    private registerSpawnWithRetry;
+    private handleAuthorizationError;
+    private categorizeError;
+    private emergencyCleanup;
+    /**
+     * Complete an agent spawn (mark as completed)
+     */
+    completeSpawn(trackingId: string, result?: boolean): Promise<void>;
+    /**
+     * Fail an agent spawn
+     */
+    failSpawn(trackingId: string, error?: Error): Promise<void>;
+    /**
+     * Terminate an agent spawn (force stop)
+     */
+    terminateSpawn(trackingId: string, reason?: string): Promise<void>;
+    /**
+     * Get current active count for agent type
+     */
+    getActiveCount(agentType: string): number;
+    /**
+     * Get total active agents system-wide
+     */
+    getTotalActive(): number;
+    /**
+     * Get spawn statistics
+     */
+    getSpawnStats(): {
+        perAgentType: Record<string, {
+            active: number;
+            total: number;
+        }>;
+        totalActive: number;
+        totalHistory: number;
+    };
+    /**
+     * Emergency: Terminate all active agents
+     */
+    emergencyShutdown(reason?: string): Promise<void>;
+    private registerSpawn;
+    private checkSpawnRateLimit;
+    private detectInfiniteSpawn;
+    private getRecentSpawns;
+    private findRecord;
+    private generateTrackingId;
+    private cleanupOldRecords;
+    private withTimeout;
+    private withRetry;
+    start(): void;
+    destroy(): void;
+}
+export declare const agentSpawnGovernor: AgentSpawnGovernor;

package/dist/orchestrator/enhanced-multi-agent-orchestrator.d.ts

@@ -0,0 +1,156 @@
+/**
+ * Enhanced Multi-Agent Orchestration with Clickable Monitoring
+ * Integrates subagent spawning visibility and lifecycle management
+ */
+import { XrayStateManager } from "../state/state-manager.js";
+export interface AgentSpawnRequest {
+    agentType: string;
+    task: string;
+    context?: Record<string, unknown>;
+    priority?: "low" | "medium" | "high" | "critical";
+    timeout?: number;
+    dependencies?: string[];
+}
+export interface AgentExecutionResult {
+    success: boolean;
+    agentType: string;
+    task: string;
+    executionTime?: number;
+    complexity?: number;
+    result?: unknown;
+    delegationResult?: unknown;
+}
+export interface SpawnedAgent {
+    id: string;
+    agentType: string;
+    task: string;
+    status: "spawning" | "active" | "completed" | "failed" | "cancelled";
+    startTime: number;
+    endTime?: number;
+    result?: AgentExecutionResult;
+    error?: string;
+    progress: number;
+    clickable: boolean;
+    monitorable: boolean;
+    cleanupRequired: boolean;
+    spawnTrackingId: string | undefined;
+}
+export interface AgentOrchestrationState {
+    activeAgents: Map<string, SpawnedAgent>;
+    pendingSpawns: AgentSpawnRequest[];
+    completedAgents: Map<string, SpawnedAgent>;
+    failedAgents: Map<string, SpawnedAgent>;
+    agentDependencies: Map<string, string[]>;
+    monitoringEnabled: boolean;
+    cleanupInterval: number;
+    isMainOrchestrator: boolean;
+}
+export interface ExecutionContext {
+    isExecutingAsSubagent: boolean;
+    currentAgentId: string | null;
+    spawnStack: string[];
+}
+export interface OrchestrationDelegationRequest {
+    operation: string;
+    description: string;
+    context?: Record<string, unknown>;
+}
+export interface OrchestrationDelegationResult {
+    success: boolean;
+    results?: Array<{
+        agent: string;
+        output: unknown;
+        executionTime: number;
+    }>;
+    totalTime: number;
+    errors?: string[];
+    agents?: string[];
+}
+export declare class EnhancedMultiAgentOrchestrator {
+    private state;
+    private stateManager;
+    private complexityAnalyzer;
+    private agentDelegator;
+    private executionContext;
+    private cleanupTimer;
+    constructor(stateManager?: XrayStateManager, isMainOrchestrator?: boolean);
+    /**
+     * 🚨 SECURITY: Check if currently executing as a subagent
+     * Prevents subagents from spawning other subagents (infinite loops, resource exhaustion)
+     */
+    private isCurrentlyExecutingAsSubagent;
+    /**
+     * Enhanced agent spawning with clickable monitoring integration
+     */
+    spawnAgent(request: AgentSpawnRequest): Promise<SpawnedAgent>;
+    /**
+     * Execute agent with monitoring and cleanup
+     */
+    private executeAgent;
+    /**
+     * Execute agent using the agent delegator system
+     */
+    private executeAgentWithDelegator;
+    /**
+     * Simulate agent execution (FALLBACK - used when plugin not loaded)
+     *
+     * NOTE: The primary execution path is through the OpenCode plugin:
+     * - .opencode/plugin/xray-codex-injection.js intercepts prompts
+     * - Routes to agents via .opencode/agents/*.yml configs
+     * - OpenCode spawns actual agent processes
+     * - Hermes Agent handles MCP server execution
+     *
+     * This simulation is a fallback for:
+     * - Testing without real agent execution
+     * - When plugin fails to load
+     * - Documentation of what the framework orchestrates
+     *
+     * For production use, ensure the plugin is loaded in OpenCode.
+     */
+    private simulateAgentExecution;
+    /**
+     * Get estimated execution time for agent type
+     */
+    private getAgentExecutionTime;
+    /**
+     * Update agent monitoring (integrates with clickable interface)
+     */
+    private updateAgentMonitoring;
+    /**
+     * Check for pending spawns that can now execute
+     */
+    private checkPendingSpawns;
+    /**
+     * Get clickable agent monitoring interface
+     */
+    getMonitoringInterface(): Record<string, SpawnedAgent>;
+    /**
+     * Cancel agent execution
+     */
+    cancelAgent(agentId: string): Promise<boolean>;
+    /**
+     * Initialize cleanup system for completed agents
+     */
+    private initializeCleanupSystem;
+    /**
+     * Perform cleanup of completed/failed agents
+     */
+    private performCleanup;
+    /**
+     * Get orchestration statistics
+     */
+    getStatistics(): {
+        activeAgents: number;
+        completedAgents: number;
+        failedAgents: number;
+        pendingSpawns: number;
+        totalSpawned: number;
+    };
+    /**
+     * Shutdown orchestration system
+     */
+    shutdown(): Promise<void>;
+    start(): void;
+    stop(): void;
+}
+export declare const enhancedMultiAgentOrchestrator: EnhancedMultiAgentOrchestrator;

package/dist/orchestrator/enhanced-multi-agent-orchestrator.js

@@ -2,7 +2,7 @@
  * Enhanced Multi-Agent Orchestration with Clickable Monitoring
  * Integrates subagent spawning visibility and lifecycle management
  */
-import { StringRayStateManager } from "../state/state-manager.js";
+import { XrayStateManager } from "../state/state-manager.js";
 import { frameworkLogger } from "../core/framework-logger.js";
 import { ComplexityAnalyzer, } from "../delegation/complexity-analyzer.js";
 import { createAgentDelegator, } from "../delegation/agent-delegator.js";
@@ -17,7 +17,7 @@ export class EnhancedMultiAgentOrchestrator {
     executionContext;
     cleanupTimer = null;
     constructor(stateManager, isMainOrchestrator = false) {
-        this.stateManager = stateManager || new StringRayStateManager();
+        this.stateManager = stateManager || new XrayStateManager();
         this.complexityAnalyzer = new ComplexityAnalyzer();
         this.agentDelegator = createAgentDelegator(this.stateManager, strRayConfigLoader);
         this.state = {

package/dist/orchestrator/intelligent-commit-batcher.d.ts

@@ -0,0 +1,114 @@
+/**
+ * Intelligent Commit Batcher - Batches related changes for optimal commit history
+ * Implements configurable thresholds for file count, time windows, and risk levels
+ *
+ * Configuration is read from .xray/features.json -> commit_cycle
+ */
+export interface PendingChange {
+    filePath: string;
+    operation: string;
+    changeType: string;
+    riskLevel: "low" | "medium" | "high" | "critical";
+    linesChanged: number;
+    timestamp: number;
+    relatedFiles?: string[];
+    commitMessage?: string;
+    author?: string;
+}
+export interface CommitBatchingConfig {
+    maxFilesPerCommit: number;
+    minFilesPerCommit: number;
+    maxTimeBetweenCommits: number;
+    minTimeBetweenCommits: number;
+    forceCommitAfter: number;
+    batchRelatedOperations: boolean;
+    maxOperationsPerBatch: number;
+    batchLowRiskChanges: boolean;
+    separateHighRiskChanges: boolean;
+    batchByComponent: boolean;
+    maxComponentsPerCommit: number;
+    autoCommit: boolean;
+    generateCommitMessages: boolean;
+    amendLastCommit: boolean;
+}
+export interface BatchMetrics {
+    fileCount: number;
+    operationCount: number;
+    componentCount: number;
+    totalLinesChanged: number;
+    timeSinceLastCommit: number;
+    averageRiskLevel: number;
+    oldestChangeTime: number;
+    newestChangeTime: number;
+}
+export declare class IntelligentCommitBatcher {
+    private pendingChanges;
+    private lastCommitTime;
+    private config;
+    constructor(config?: Partial<CommitBatchingConfig>);
+    private loadFeaturesConfig;
+    /**
+     * Add a change to the pending batch
+     */
+    addChange(change: PendingChange): boolean;
+    /**
+     * Add multiple changes to the batch
+     */
+    addChanges(changes: PendingChange[]): boolean;
+    /**
+     * Check if the current batch should be committed
+     */
+    shouldCommitBatch(): boolean;
+    /**
+     * Commit the current batch of changes
+     */
+    commitBatch(commitMessage?: string): Promise<boolean>;
+    /**
+     * Force commit current batch regardless of thresholds
+     */
+    forceCommitBatch(commitMessage?: string): Promise<boolean>;
+    /**
+     * Get current batch status and metrics
+     */
+    getBatchStatus(): {
+        pendingChanges: number;
+        metrics: BatchMetrics;
+        shouldCommit: boolean;
+        estimatedCommitMessage: string;
+    };
+    /**
+     * Calculate metrics for the current batch
+     */
+    private calculateBatchMetrics;
+    /**
+     * Check if batch has mixed risk levels that should be separated
+     */
+    private hasMixedRiskLevels;
+    /**
+     * Generate intelligent commit message
+     */
+    private generateCommitMessage;
+    /**
+     * Get files that should be staged for this commit
+     */
+    private getFilesToStage;
+    /**
+     * Stage files for commit
+     */
+    private stageFiles;
+    /**
+     * Perform the actual git commit
+     */
+    private performGitCommit;
+    /**
+     * Get summary of operations in this batch
+     */
+    private getOperationSummary;
+    private riskLevelToNumber;
+    private detectComponent;
+    private extractComponentName;
+    private getPrimaryOperation;
+    private getActionVerb;
+}
+export declare const createIntelligentCommitBatcher: (config?: Partial<CommitBatchingConfig>) => IntelligentCommitBatcher;
+export declare const intelligentCommitBatcher: IntelligentCommitBatcher;

package/dist/orchestrator/intelligent-commit-batcher.js

@@ -2,7 +2,7 @@
  * Intelligent Commit Batcher - Batches related changes for optimal commit history
  * Implements configurable thresholds for file count, time windows, and risk levels
  *
- * Configuration is read from .strray/features.json -> commit_cycle
+ * Configuration is read from .xray/features.json -> commit_cycle
  */
 import * as fs from "fs";
 import * as path from "path";
@@ -36,8 +36,8 @@ export class IntelligentCommitBatcher {
     loadFeaturesConfig() {
         try {
             const configPaths = [
-                path.join(process.cwd(), ".strray", "features.json"),
-                path.join(process.cwd(), ".opencode", "strray", "features.json"),
+                path.join(process.cwd(), ".xray", "features.json"),
+                path.join(process.cwd(), ".opencode", "xray", "features.json"),
             ];
             for (const configPath of configPaths) {
                 if (fs.existsSync(configPath)) {