0xray 4.0.12 → 4.0.13

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

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

@@ -1,355 +0,0 @@
-/**
- * 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

@@ -1,64 +0,0 @@
-/**
- * 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

@@ -1,157 +0,0 @@
-/**
- * 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

@@ -1,41 +0,0 @@
-/**
- * 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;