0xray 4.0.13 → 4.0.14

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

@@ -0,0 +1,87 @@
+/**
+ * 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
+ */
+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/nudge-watchdog.js

@@ -0,0 +1,355 @@
+/**
+ * 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
+ */
+import { EventEmitter } from "events";
+import { frameworkLogger } from "../core/framework-logger.js";
+import { featuresConfigLoader } from "../core/features-config.js";
+const DEFAULT_NUDGE_CONFIG = {
+    enabled: true,
+    think_loop_threshold: 3,
+    syntax_loop_threshold: 3,
+    tool_loop_threshold: 5,
+    death_spiral_threshold: 3,
+    cooldown_ms: 120000,
+};
+const NUDGE_MESSAGES = {
+    "think-loop": {
+        type: "think-loop",
+        message: "Detected excessive thinking without progress",
+        suggestion: "STOP THINKING. Write code now.",
+        priority: 1,
+    },
+    "syntax-loop": {
+        type: "syntax-loop",
+        message: "Detected repeated fix attempts on same error",
+        suggestion: "git checkout HEAD -- <file> && re-apply changes. Consider the root cause.",
+        priority: 2,
+    },
+    "death-spiral": {
+        type: "death-spiral",
+        message: "Detected repetitive explanations without fixes",
+        suggestion: "Delegate to a different agent or try a different approach.",
+        priority: 3,
+    },
+    "tool-loop": {
+        type: "tool-loop",
+        message: "Detected same tool called repeatedly",
+        suggestion: "Consider an alternative tool or approach.",
+        priority: 4,
+    },
+    "repair-failure": {
+        type: "repair-failure",
+        message: "Processor indicated fix but error persists",
+        suggestion: "Trigger different processor or agent.",
+        priority: 5,
+    },
+};
+class NudgeWatchdog extends EventEmitter {
+    config;
+    patterns = new Map();
+    lastNudgeTime = 0;
+    thinkTagCount = 0;
+    lastThinkTagTime = 0;
+    toolCallHistory = new Map();
+    fixAttempts = new Map();
+    explanationCount = 0;
+    codeChangeCount = 0;
+    listenersInitialized = false;
+    constructor(config = {}) {
+        super();
+        this.setMaxListeners(50);
+        this.config = { ...DEFAULT_NUDGE_CONFIG, ...config };
+        this.loadConfigFromFeatures();
+    }
+    loadConfigFromFeatures() {
+        try {
+            const features = featuresConfigLoader.loadConfig();
+            const nudgeConfig = features?.nudge_watchdog;
+            if (nudgeConfig) {
+                this.config = { ...this.config, ...nudgeConfig };
+            }
+        }
+        catch {
+            // Use defaults
+        }
+    }
+    start() {
+        if (!this.config.enabled) {
+            return;
+        }
+        this.log("nudge-watchdog", "started", "info", { config: this.config });
+    }
+    stop() {
+        this.log("nudge-watchdog", "stopped", "info");
+    }
+    recordThinkTag() {
+        const now = Date.now();
+        if (now - this.lastThinkTagTime < 5000) {
+            this.thinkTagCount++;
+        }
+        else {
+            this.thinkTagCount = 1;
+        }
+        this.lastThinkTagTime = now;
+        this.checkThinkLoop();
+    }
+    recordCodeChange() {
+        this.codeChangeCount++;
+        const now = Date.now();
+        if (now - this.lastThinkTagTime < 30000) {
+            this.thinkTagCount = Math.max(0, this.thinkTagCount - 1);
+        }
+    }
+    recordToolCall(tool, args) {
+        const key = `${tool}:${this.hashArgs(args)}`;
+        const existing = this.toolCallHistory.get(key);
+        if (existing) {
+            existing.count++;
+            existing.timestamp = Date.now();
+        }
+        else {
+            this.toolCallHistory.set(key, { count: 1, args, timestamp: Date.now() });
+        }
+        this.checkToolLoop();
+        this.cleanupOldToolCalls();
+    }
+    recordFixAttempt(filePath, error) {
+        const key = filePath;
+        const existing = this.fixAttempts.get(key);
+        if (existing && this.isSimilarError(existing.error, error)) {
+            existing.count++;
+            existing.timestamp = Date.now();
+        }
+        else {
+            this.fixAttempts.set(key, { count: 1, error, timestamp: Date.now() });
+        }
+        this.checkSyntaxLoop(filePath);
+    }
+    recordExplanation() {
+        this.explanationCount++;
+        this.checkDeathSpiral();
+    }
+    recordProcessorFix(filePath, fixed, errorPersisted) {
+        if (fixed && errorPersisted) {
+            const key = `fix:${filePath}`;
+            const existing = this.patterns.get(key);
+            if (existing) {
+                existing.count++;
+                existing.lastSeen = Date.now();
+            }
+            else {
+                this.patterns.set(key, {
+                    type: "repair-failure",
+                    count: 1,
+                    firstSeen: Date.now(),
+                    lastSeen: Date.now(),
+                    details: { filePath },
+                });
+            }
+            this.checkRepairFailure();
+        }
+    }
+    checkThinkLoop() {
+        const threshold = this.config.think_loop_threshold;
+        if (this.thinkTagCount >= threshold && this.codeChangeCount < threshold) {
+            const key = "think-loop";
+            const existing = this.patterns.get(key);
+            if (existing) {
+                existing.count++;
+                existing.lastSeen = Date.now();
+            }
+            else {
+                this.patterns.set(key, {
+                    type: "think-loop",
+                    count: 1,
+                    firstSeen: Date.now(),
+                    lastSeen: Date.now(),
+                    details: { thinkTags: this.thinkTagCount, codeChanges: this.codeChangeCount },
+                });
+            }
+            this.checkCooldownAndNudge("think-loop");
+        }
+    }
+    checkToolLoop() {
+        const threshold = this.config.tool_loop_threshold;
+        for (const [key, data] of this.toolCallHistory) {
+            if (data.count >= threshold) {
+                const existing = this.patterns.get(key);
+                const tool = key.split(":")[0];
+                if (existing) {
+                    existing.count++;
+                    existing.lastSeen = Date.now();
+                }
+                else {
+                    this.patterns.set(key, {
+                        type: "tool-loop",
+                        count: 1,
+                        firstSeen: Date.now(),
+                        lastSeen: Date.now(),
+                        details: { tool, args: data.args },
+                    });
+                }
+                this.checkCooldownAndNudge("tool-loop");
+                break;
+            }
+        }
+    }
+    checkSyntaxLoop(filePath) {
+        const entry = this.fixAttempts.get(filePath);
+        if (!entry)
+            return;
+        const threshold = this.config.syntax_loop_threshold;
+        if (entry.count >= threshold) {
+            this.checkCooldownAndNudge("syntax-loop");
+        }
+    }
+    checkDeathSpiral() {
+        const threshold = this.config.death_spiral_threshold;
+        if (this.explanationCount >= threshold && this.codeChangeCount < threshold) {
+            const key = "death-spiral";
+            const existing = this.patterns.get(key);
+            if (existing) {
+                existing.count++;
+                existing.lastSeen = Date.now();
+            }
+            else {
+                this.patterns.set(key, {
+                    type: "death-spiral",
+                    count: 1,
+                    firstSeen: Date.now(),
+                    lastSeen: Date.now(),
+                    details: { explanations: this.explanationCount, codeChanges: this.codeChangeCount },
+                });
+            }
+            this.checkCooldownAndNudge("death-spiral");
+        }
+    }
+    checkRepairFailure() {
+        for (const [key, pattern] of this.patterns) {
+            if (pattern.type === "repair-failure" && pattern.count >= 2) {
+                this.checkCooldownAndNudge("repair-failure");
+                break;
+            }
+        }
+    }
+    checkCooldownAndNudge(type) {
+        const now = Date.now();
+        if (now - this.lastNudgeTime < this.config.cooldown_ms) {
+            return;
+        }
+        const action = this.triggerNudge(type);
+        if (action) {
+            this.lastNudgeTime = now;
+        }
+    }
+    triggerNudge(type) {
+        const action = NUDGE_MESSAGES[type];
+        if (!action)
+            return null;
+        this.emit("nudge", action);
+        this.log("nudge-watchdog", "nudge-triggered", "warning", {
+            type: action.type,
+            message: action.message,
+            suggestion: action.suggestion,
+        });
+        return action;
+    }
+    getNudgeSuggestion(type, context) {
+        const action = NUDGE_MESSAGES[type];
+        if (!action)
+            return "";
+        let suggestion = action.suggestion;
+        if (context?.filePath && type === "syntax-loop") {
+            suggestion = suggestion.replace("<file>", context.filePath);
+        }
+        return suggestion;
+    }
+    hashArgs(args) {
+        let hash = 0;
+        for (let i = 0; i < args.length; i++) {
+            const char = args.charCodeAt(i);
+            hash = ((hash << 5) - hash) + char;
+            hash = hash & hash;
+        }
+        return Math.abs(hash).toString(36);
+    }
+    isSimilarError(error1, error2) {
+        if (!error1 || !error2)
+            return false;
+        return error1.substring(0, 100) === error2.substring(0, 100);
+    }
+    cleanupOldToolCalls() {
+        const now = Date.now();
+        const maxAge = 5 * 60 * 1000;
+        for (const [key, data] of this.toolCallHistory) {
+            if (now - data.timestamp > maxAge) {
+                this.toolCallHistory.delete(key);
+            }
+        }
+        for (const [key, data] of this.fixAttempts) {
+            if (now - data.timestamp > maxAge) {
+                this.fixAttempts.delete(key);
+            }
+        }
+    }
+    reset() {
+        this.thinkTagCount = 0;
+        this.codeChangeCount = 0;
+        this.explanationCount = 0;
+        this.toolCallHistory.clear();
+        this.fixAttempts.clear();
+        this.patterns.clear();
+        this.lastNudgeTime = 0;
+    }
+    getStats() {
+        return {
+            thinkTags: this.thinkTagCount,
+            codeChanges: this.codeChangeCount,
+            explanations: this.explanationCount,
+            activePatterns: this.patterns.size,
+            lastNudgeAgo: Date.now() - this.lastNudgeTime,
+        };
+    }
+    log(component, action, status, details) {
+        try {
+            frameworkLogger.log(component, action, status, details);
+        }
+        catch {
+            // Silent fail
+        }
+    }
+}
+export const nudgeWatchdog = new NudgeWatchdog();
+export function recordThinkTag() {
+    nudgeWatchdog.recordThinkTag();
+}
+export function recordCodeChange() {
+    nudgeWatchdog.recordCodeChange();
+}
+export function recordToolCall(tool, args) {
+    nudgeWatchdog.recordToolCall(tool, args);
+}
+export function recordFixAttempt(filePath, error) {
+    nudgeWatchdog.recordFixAttempt(filePath, error);
+}
+export function recordExplanation() {
+    nudgeWatchdog.recordExplanation();
+}
+export function getNudgeSuggestion(type, context) {
+    return nudgeWatchdog.getNudgeSuggestion(type, context);
+}
+export function getNudgeWatchdog() {
+    return nudgeWatchdog;
+}
+export function recordProcessorFix(filePath, fixed, errorPersisted) {
+    nudgeWatchdog.recordProcessorFix(filePath, fixed, errorPersisted);
+}

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/monitoring/test-auto-generation-monitor.js

@@ -0,0 +1,157 @@
+/**
+ * Test Auto-Generation Monitor
+ *
+ * Tracks and reports on test auto-generation activity.
+ * Provides metrics on test creation success/failure rates.
+ *
+ * @since 2026-02-22
+ */
+import * as fs from "fs";
+import * as path from "path";
+import { frameworkLogger } from "../core/framework-logger.js";
+class TestAutoGenerationMonitor {
+    metrics = {
+        totalFilesProcessed: 0,
+        testsGenerated: 0,
+        testsSkipped: 0,
+        testsFailed: 0,
+        startTime: Date.now(),
+        lastGenerationTime: null,
+    };
+    events = [];
+    maxEvents = 1000;
+    metricsFile;
+    constructor(metricsDir = "./logs") {
+        // Ensure metrics directory exists
+        if (!fs.existsSync(metricsDir)) {
+            fs.mkdirSync(metricsDir, { recursive: true });
+        }
+        this.metricsFile = path.join(metricsDir, "test-auto-generation-metrics.json");
+        this.loadMetrics();
+    }
+    /**
+     * Load metrics from disk if they exist
+     */
+    loadMetrics() {
+        try {
+            if (fs.existsSync(this.metricsFile)) {
+                const data = fs.readFileSync(this.metricsFile, "utf8");
+                const loaded = JSON.parse(data);
+                this.metrics = { ...this.metrics, ...loaded };
+                // Silent load - no console output during tests
+            }
+        }
+        catch (error) {
+            // Silent fail - no console output during tests
+        }
+    }
+    /**
+     * Save metrics to disk
+     */
+    saveMetrics() {
+        try {
+            fs.writeFileSync(this.metricsFile, JSON.stringify(this.metrics, null, 2));
+        }
+        catch (error) {
+            // Silent fail - no console output during tests
+        }
+    }
+    /**
+     * Record a test generation event
+     */
+    recordEvent(event) {
+        this.events.push(event);
+        // Keep only last maxEvents
+        if (this.events.length > this.maxEvents) {
+            this.events = this.events.slice(-this.maxEvents);
+        }
+        // Update metrics based on event type
+        this.metrics.totalFilesProcessed++;
+        switch (event.type) {
+            case "generated":
+                this.metrics.testsGenerated++;
+                this.metrics.lastGenerationTime = event.timestamp;
+                break;
+            case "skipped":
+                this.metrics.testsSkipped++;
+                break;
+            case "failed":
+                this.metrics.testsFailed++;
+                break;
+        }
+        this.saveMetrics();
+    }
+    /**
+     * Get current metrics
+     */
+    getMetrics() {
+        return { ...this.metrics };
+    }
+    /**
+     * Get recent events
+     */
+    getRecentEvents(count = 10) {
+        return this.events.slice(-count);
+    }
+    /**
+     * Get success rate as percentage
+     */
+    getSuccessRate() {
+        if (this.metrics.totalFilesProcessed === 0)
+            return 0;
+        return ((this.metrics.testsGenerated / this.metrics.totalFilesProcessed) * 100);
+    }
+    /**
+     * Generate a status report
+     */
+    generateReport() {
+        const { metrics } = this;
+        const successRate = this.getSuccessRate().toFixed(1);
+        const uptime = ((Date.now() - metrics.startTime) / 1000 / 60).toFixed(1); // minutes
+        return `
+╔══════════════════════════════════════════════════════════════╗
+║        TEST AUTO-GENERATION MONITOR REPORT                  ║
+╠══════════════════════════════════════════════════════════════╣
+║  Uptime: ${uptime} minutes                                      ║
+║                                                              ║
+║  📊 METRICS                                                 ║
+║  ─────────────────────────────────────────────────────────  ║
+║  Files Processed:  ${metrics.totalFilesProcessed.toString().padEnd(35)}║
+║  Tests Generated: ${metrics.testsGenerated.toString().padEnd(35)}║
+║  Tests Skipped:  ${metrics.testsSkipped.toString().padEnd(35)}║
+║  Tests Failed:   ${metrics.testsFailed.toString().padEnd(35)}║
+║                                                              ║
+║  ✅ Success Rate: ${successRate}%                                ║
+║                                                              ║
+║  🕐 Last Generation: ${metrics.lastGenerationTime
+            ? new Date(metrics.lastGenerationTime).toLocaleString()
+            : "Never".padEnd(33)}║
+╚══════════════════════════════════════════════════════════════╝
+`;
+    }
+    /**
+     * Reset metrics (for testing)
+     */
+    reset() {
+        this.metrics = {
+            totalFilesProcessed: 0,
+            testsGenerated: 0,
+            testsSkipped: 0,
+            testsFailed: 0,
+            startTime: Date.now(),
+            lastGenerationTime: null,
+        };
+        this.events = [];
+        this.saveMetrics();
+        // Silent reset - no console output during tests
+    }
+}
+// Singleton instance
+export const testAutoGenerationMonitor = new TestAutoGenerationMonitor();
+// CLI interface
+if (process.argv[1] &&
+    process.argv[1].includes("test-auto-generation-monitor")) {
+    frameworkLogger.log("test-auto-generation-monitor", "cli-report", "info", {
+        message: testAutoGenerationMonitor.generateReport(),
+    });
+}

package/dist/nucleus/aside-worktree.d.ts

@@ -0,0 +1,41 @@
+/**
+ * User-aside worktree path resolution, spawn cwd validation, optional git provision.
+ */
+/** Minimal spawn tool input for cwd extraction (avoids circular import with delegation-gate). */
+export interface SpawnCwdToolInput {
+    cwd?: string;
+    working_directory?: string;
+    workingDirectory?: string;
+    isolation?: string;
+    isolation_mode?: string;
+    worktree_path?: string;
+    worktreePath?: string;
+    worktree?: string;
+    [key: string]: unknown;
+}
+export interface AsideWorktreeCwdResult {
+    valid: boolean;
+    gate?: 'aside-worktree-cwd-missing' | 'aside-worktree-cwd-mismatch';
+    reason?: string;
+    hint?: Record<string, unknown>;
+}
+export interface WorktreeProvisionResult {
+    ok: boolean;
+    path: string;
+    created: boolean;
+    message: string;
+}
+export declare function normalizeWorktreePath(worktree: string, projectRoot: string): string;
+export declare function isAutoProvisionWorktreeEnabled(projectRoot?: string): boolean;
+/** Extract spawn cwd from host Task / spawn_subagent tool input. */
+export declare function extractSpawnCwd(toolInput: SpawnCwdToolInput, projectRoot: string): string | null;
+export declare function validateAsideWorktreeCwd(worktree: string | undefined, toolInput: SpawnCwdToolInput, projectRoot: string): AsideWorktreeCwdResult;
+/**
+ * Guarded `git worktree add` when auto_provision_worktree is enabled.
+ * Creates branch with -b when it does not exist locally.
+ */
+export declare function provisionGitWorktree(opts: {
+    projectRoot: string;
+    worktree: string;
+    branch: string;
+}): WorktreeProvisionResult;