0xray 2.0.0

package/dist/processors/implementations/refactoring-logging-processor.js

@@ -0,0 +1,96 @@
+import { frameworkLogger } from "../../core/framework-logger.js";
+import * as fs from "fs";
+import * as path from "path";
+export class RefactoringLoggingProcessor {
+    logPath;
+    constructor() {
+        this.logPath = path.join(process.cwd(), "logs", "agents", "refactoring-log.md");
+        this.ensureLogDirectory();
+    }
+    ensureLogDirectory() {
+        const logDir = path.dirname(this.logPath);
+        if (!fs.existsSync(logDir)) {
+            fs.mkdirSync(logDir, { recursive: true });
+        }
+    }
+    async execute(context) {
+        try {
+            if (context.agentName &&
+                context.task &&
+                typeof context.startTime === "number") {
+                const logEntry = this.createLogEntry(context);
+                await this.appendToLog(logEntry);
+                return {
+                    logged: true,
+                    success: true,
+                    message: "Agent refactoring completion logged successfully",
+                };
+            }
+            return {
+                logged: false,
+                success: true,
+                message: "Not an agent task completion context",
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            await frameworkLogger.log("refactoring-logging-processor", "-refactoring-logging-failed-error-instanceof-error-", "error", { message: `Refactoring logging failed: ${errorMessage}` });
+            return {
+                logged: false,
+                success: false,
+                message: `Refactoring logging failed: ${errorMessage}`,
+                error: errorMessage,
+            };
+        }
+    }
+    createLogEntry(context) {
+        const timestamp = new Date().toISOString();
+        const duration = Date.now() - context.startTime;
+        let logEntry = `## Refactoring Operation - ${timestamp}\n\n`;
+        logEntry += `**Agent:** ${context.agentName}\n`;
+        logEntry += `**Task:** ${context.task.description || context.task.id || "Unknown"}\n`;
+        logEntry += `**Duration:** ${duration}ms\n`;
+        logEntry += `**Operation Type:** ${context.task.operationType || context.operationType || "refactor"}\n`;
+        if (context.complexityScore) {
+            logEntry += `**Complexity Score:** ${context.complexityScore}\n`;
+        }
+        if (context.changes && Array.isArray(context.changes)) {
+            logEntry += `\n**Changes Made:**\n`;
+            context.changes.forEach((change, index) => {
+                logEntry += `${index + 1}. ${change.description || change.type || "Unknown change"}\n`;
+            });
+        }
+        if (context.files && Array.isArray(context.files)) {
+            logEntry += `\n**Files Modified:**\n`;
+            context.files.forEach((file) => {
+                logEntry += `- ${file}\n`;
+            });
+        }
+        if (context.metrics) {
+            logEntry += `\n**Metrics:**\n`;
+            Object.entries(context.metrics).forEach(([key, value]) => {
+                logEntry += `- ${key}: ${value}\n`;
+            });
+        }
+        logEntry += `\n---\n\n`;
+        return logEntry;
+    }
+    async appendToLog(entry) {
+        try {
+            if (!fs.existsSync(this.logPath)) {
+                let header = `# 0xRay Framework Refactoring Log\n\n`;
+                header += `This log tracks all refactoring operations performed by 0xRay agents.\n\n`;
+                header += `Generated on: ${new Date().toISOString()}\n\n`;
+                header += `---\n\n`;
+                fs.writeFileSync(this.logPath, header, "utf8");
+            }
+            fs.appendFileSync(this.logPath, entry, "utf8");
+            await frameworkLogger.log("refactoring-logging-processor", "-refactoring-operation-logged-successfully-", "info", { message: "Refactoring operation logged successfully" });
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            await frameworkLogger.log("refactoring-logging-processor", "-failed-to-append-to-refactoring-log-error-instanceof-", "error", { message: `Failed to append to refactoring log: ${errorMessage}` });
+            throw error;
+        }
+    }
+}

package/dist/processors/implementations/regression-testing-processor.js

@@ -0,0 +1,59 @@
+import * as fs from "fs";
+import * as path from "path";
+import { PostProcessor } from "../processor-interfaces.js";
+import { frameworkLogger } from "../../core/framework-logger.js";
+export class RegressionTestingProcessor extends PostProcessor {
+    name = "regressionTesting";
+    priority = 15;
+    async run(context) {
+        const result = {
+            regressions: 0,
+            issues: [],
+            baseline: null,
+            current: null,
+        };
+        try {
+            const projectRoot = process.cwd();
+            const testCountPath = path.join(projectRoot, ".opencode", "strray", "test-count.json");
+            if (!fs.existsSync(testCountPath)) {
+                frameworkLogger.log("regression-testing-processor", "no-baseline", "info", { message: "No test-count.json baseline found" });
+                return result;
+            }
+            const baseline = JSON.parse(fs.readFileSync(testCountPath, "utf-8"));
+            result.baseline = `${baseline.totalTests ?? "unknown"} tests`;
+            const currentCount = this.getCurrentTestCount(projectRoot);
+            result.current = `${currentCount} tests`;
+            if (baseline.totalTests &&
+                currentCount > 0 &&
+                currentCount < baseline.totalTests * 0.9) {
+                result.regressions += 1;
+                result.issues.push({
+                    type: "new_failure",
+                    description: `Test count dropped from ${baseline.totalTests} to ${currentCount} (>10% regression)`,
+                });
+            }
+            if (result.regressions > 0) {
+                frameworkLogger.log("regression-testing-processor", "regressions-detected", "warning", { regressions: result.regressions, issues: result.issues });
+            }
+            else {
+                frameworkLogger.log("regression-testing-processor", "no-regressions", "info", { baseline: result.baseline, current: result.current });
+            }
+        }
+        catch (error) {
+            frameworkLogger.log("regression-testing-processor", "error", "error", { error: error instanceof Error ? error.message : String(error) });
+        }
+        return result;
+    }
+    getCurrentTestCount(projectRoot) {
+        try {
+            const testCountPath = path.join(projectRoot, ".opencode", "strray", "test-count.json");
+            if (!fs.existsSync(testCountPath))
+                return 0;
+            const data = JSON.parse(fs.readFileSync(testCountPath, "utf-8"));
+            return data.totalTests ?? 0;
+        }
+        catch {
+            return 0;
+        }
+    }
+}

package/dist/processors/implementations/session-capture-processor.js

@@ -0,0 +1,37 @@
+/**
+ * Session Capture Processor
+ *
+ * Extracted from InferenceImprovementProcessor - handles discovery of
+ * session data sources (reflections, logs, reports) for inference workflows.
+ *
+ * @module processors/implementations
+ */
+import * as fs from "fs";
+import * as path from "path";
+export class SessionCapture {
+    static findReflections(directory, reflectionsDir) {
+        const reflectionsPath = path.join(directory, reflectionsDir);
+        if (!fs.existsSync(reflectionsPath))
+            return [];
+        return fs.readdirSync(reflectionsPath)
+            .filter(f => f.endsWith(".md"))
+            .map(f => path.join(reflectionsPath, f));
+    }
+    static findLogs(directory, logsDir) {
+        const logsPath = path.join(directory, logsDir);
+        if (!fs.existsSync(logsPath))
+            return [];
+        return fs.readdirSync(logsPath)
+            .filter(f => f.includes("routing") || f.includes("activity") || f.includes("session"))
+            .map(f => path.join(logsPath, f));
+    }
+    static findReports(directory, reportsDir) {
+        const reportsPath = path.join(directory, reportsDir);
+        if (!fs.existsSync(reportsPath))
+            return [];
+        return fs.readdirSync(reportsPath)
+            .filter(f => f.endsWith(".json") || f.endsWith(".md"))
+            .map(f => path.join(reportsPath, f));
+    }
+}
+export default SessionCapture;

package/dist/processors/implementations/session-summary-processor.js

@@ -0,0 +1,130 @@
+/**
+ * Session Summary Post-Processor
+ *
+ * Generates emoji-formatted session summaries after tool execution.
+ * Uses features.json -> auto_reporting config for control.
+ *
+ * @version 1.0.0
+ * @since 2026-04-04
+ */
+import { PostProcessor } from "../processor-interfaces.js";
+import { frameworkLogger } from "../../core/framework-logger.js";
+import * as path from "path";
+import * as fs from "fs";
+export class SessionSummaryProcessor extends PostProcessor {
+    name = "sessionSummary";
+    priority = 15;
+    config = {
+        enabled: true,
+        include_emojis: true,
+        include_recommendations: true,
+        include_agent_activities: true,
+    };
+    sessionStartTime = Date.now();
+    agentActivities = new Map();
+    toolCalls = new Map();
+    operations = [];
+    constructor() {
+        super();
+        this.loadConfig();
+    }
+    loadConfig() {
+        try {
+            const featuresPath = path.join(process.cwd(), ".opencode", "strray", "features.json");
+            const altPath = path.join(process.cwd(), ".strray", "features.json");
+            const configPath = fs.existsSync(featuresPath) ? featuresPath :
+                fs.existsSync(altPath) ? altPath : null;
+            if (configPath) {
+                const configData = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+                const autoReporting = configData.auto_reporting;
+                if (autoReporting) {
+                    this.config.enabled = autoReporting.mode !== "off";
+                    this.config.include_emojis = autoReporting.display?.indicators?.emojis !== false;
+                    this.config.include_recommendations = autoReporting.report_types?.session_summary?.include_recommendations !== false;
+                    this.config.include_agent_activities = autoReporting.report_types?.session_summary?.include_agent_activities !== false;
+                }
+            }
+        }
+        catch (error) {
+            // Silent fail - use defaults
+        }
+    }
+    async run(context) {
+        if (!this.config.enabled) {
+            return { summaryGenerated: false, reason: "disabled in features.json" };
+        }
+        // Track operation
+        const operation = context.operation || context.data || "unknown";
+        this.operations.push(operation);
+        // Track tool calls
+        const tool = context.operation || "unknown";
+        this.toolCalls.set(tool, (this.toolCalls.get(tool) || 0) + 1);
+        // Track agent if available
+        const agentName = context.agentName;
+        if (agentName) {
+            this.agentActivities.set(agentName, (this.agentActivities.get(agentName) || 0) + 1);
+        }
+        // Generate summary on triggers
+        const shouldSummarize = this.shouldGenerateSummary(context);
+        if (shouldSummarize) {
+            const summary = this.generateEmojiSummary(context);
+            frameworkLogger.log("sessionSummary", "session-summary-output", "info", { summary });
+            frameworkLogger.log("sessionSummary", "session-summary-generated", "info", { summary: this.stripEmojis(summary), operationCount: this.operations.length });
+            return { summaryGenerated: true, summary };
+        }
+        return { summaryGenerated: false };
+    }
+    shouldGenerateSummary(context) {
+        const isPublish = context.metadata?.isPublishing;
+        const operationCount = this.operations.length;
+        const isError = !context.success;
+        return isPublish || (operationCount > 0 && operationCount % 5 === 0) || isError;
+    }
+    generateEmojiSummary(context) {
+        const emojis = this.config.include_emojis;
+        const ops = this.operations.length;
+        const duration = Date.now() - this.sessionStartTime;
+        const prefix = emojis ? "🎯" : ">";
+        const separator = emojis ? "━━━━━━━━━━━━━━━━━━" : "===============";
+        const toolIcon = emojis ? "🛠️" : "Tools:";
+        const agentIcon = emojis ? "🤖" : "Agents:";
+        const recIcon = emojis ? "📝" : "Note:";
+        let summary = `\n${prefix} Session Summary (${ops} ops, ${(duration / 1000).toFixed(1)}s)\n${separator}\n`;
+        // Top tools
+        if (this.toolCalls.size > 0) {
+            const topTools = Array.from(this.toolCalls.entries())
+                .sort((a, b) => b[1] - a[1])
+                .slice(0, 5)
+                .map(([t, c]) => `${t}(${c})`)
+                .join(", ");
+            summary += `${toolIcon} ${topTools}\n`;
+        }
+        // Agents
+        if (this.config.include_agent_activities && this.agentActivities.size > 0) {
+            summary += `${agentIcon} ${Array.from(this.agentActivities.keys()).join(", ")}\n`;
+        }
+        // Last operation status
+        const lastOp = this.operations[this.operations.length - 1] || "unknown";
+        const status = context.success !== false ? "✅" : "❌";
+        summary += `${status} Last: ${lastOp}\n`;
+        // Recommendation
+        if (this.config.include_recommendations && ops >= 3) {
+            summary += `${recIcon} ${this.generateRecommendation()}\n`;
+        }
+        summary += `${separator}\n`;
+        return summary;
+    }
+    generateRecommendation() {
+        const editCount = this.toolCalls.get("edit") || 0;
+        const writeCount = this.toolCalls.get("write") || 0;
+        if (editCount > 5)
+            return "Heavy edits - consider running tests";
+        if (writeCount > 10)
+            return "Many writes - good time for a commit";
+        return "Session progressing well";
+    }
+    stripEmojis(text) {
+        return text.replace(/🎯|🛠️|🤖|✅|❌|📝|━━━━━━━━━━━━━━━━━━|===============/g, "").trim();
+    }
+}
+export default SessionSummaryProcessor;

package/dist/processors/implementations/spawn-governance-processor.js

@@ -0,0 +1,219 @@
+/**
+ * Spawn Governance Processor
+ *
+ * Enforces codex terms #52-57:
+ *  - #52 Agent Spawn Governance
+ *  - #53 Subagent Spawning Prevention
+ *  - #54 Concurrent Agent Limits
+ *  - #55 Emergency Memory Cleanup
+ *  - #56 Infinite Spawn Pattern Detection
+ *  - #57 Spawn Rate Limiting
+ *
+ * @version 1.0.0
+ * @since 2026-03-28
+ */
+import { frameworkLogger } from "../../core/framework-logger.js";
+// ---------------------------------------------------------------------------
+// Processor
+// ---------------------------------------------------------------------------
+export class SpawnGovernanceProcessor {
+    static DEFAULT_MAX_CONCURRENT = 5;
+    static DEFAULT_RATE_LIMIT_WINDOW_MS = 10000;
+    static DEFAULT_MAX_SPAWNS_PER_WINDOW = 10;
+    static DEFAULT_MEMORY_THRESHOLD = 0.8;
+    config;
+    activeSpawns = new Set();
+    spawnTimestamps = [];
+    agentSpawnTimestamps = new Map();
+    blockedCount = 0;
+    subagentDepth = new Map();
+    constructor(config) {
+        this.config = {
+            maxConcurrent: config?.maxConcurrent ?? SpawnGovernanceProcessor.DEFAULT_MAX_CONCURRENT,
+            rateLimitWindowMs: config?.rateLimitWindowMs ?? SpawnGovernanceProcessor.DEFAULT_RATE_LIMIT_WINDOW_MS,
+            maxSpawnsPerWindow: config?.maxSpawnsPerWindow ?? SpawnGovernanceProcessor.DEFAULT_MAX_SPAWNS_PER_WINDOW,
+            memoryThreshold: config?.memoryThreshold ?? SpawnGovernanceProcessor.DEFAULT_MEMORY_THRESHOLD,
+            infiniteSpawnThreshold: config?.infiniteSpawnThreshold ?? 3,
+            infiniteSpawnWindowMs: config?.infiniteSpawnWindowMs ?? 10000,
+        };
+    }
+    // -----------------------------------------------------------------------
+    // Core API
+    // -----------------------------------------------------------------------
+    checkSpawnAllowed(agentName) {
+        const now = Date.now();
+        // 1. Concurrent agent limit (#54)
+        if (this.activeSpawns.size >= this.config.maxConcurrent) {
+            this.blockedCount++;
+            frameworkLogger.log("spawn-governance", "concurrent-limit-exceeded", "warning", {
+                agentName,
+                activeSpawns: this.activeSpawns.size,
+                maxConcurrent: this.config.maxConcurrent,
+            });
+            return { allowed: false, reason: `Concurrent agent limit exceeded (${this.activeSpawns.size}/${this.config.maxConcurrent})` };
+        }
+        // 2. Recursive subagent spawning prevention (#53)
+        const depth = this.subagentDepth.get(agentName) ?? 0;
+        if (depth > 0) {
+            this.blockedCount++;
+            frameworkLogger.log("spawn-governance", "recursive-subagent-blocked", "warning", { agentName, depth });
+            return { allowed: false, reason: `Recursive subagent spawning blocked for "${agentName}" (depth ${depth})` };
+        }
+        // 3. Infinite spawn pattern detection (#56)
+        const agentTimes = this.agentSpawnTimestamps.get(agentName) ?? [];
+        const recentAgentSpawns = agentTimes.filter((t) => now - t < this.config.infiniteSpawnWindowMs);
+        if (recentAgentSpawns.length >= this.config.infiniteSpawnThreshold) {
+            this.blockedCount++;
+            frameworkLogger.log("spawn-governance", "infinite-spawn-pattern-detected", "warning", {
+                agentName,
+                recentCount: recentAgentSpawns.length,
+                threshold: this.config.infiniteSpawnThreshold,
+                windowMs: this.config.infiniteSpawnWindowMs,
+            });
+            return {
+                allowed: false,
+                reason: `Infinite spawn pattern detected for "${agentName}" (${recentAgentSpawns.length} spawns in ${this.config.infiniteSpawnWindowMs}ms)`,
+            };
+        }
+        // 4. Spawn rate limiting (#57)
+        this.purgeOldTimestamps(now);
+        if (this.spawnTimestamps.length >= this.config.maxSpawnsPerWindow) {
+            this.blockedCount++;
+            frameworkLogger.log("spawn-governance", "rate-limit-exceeded", "warning", {
+                agentName,
+                recentSpawns: this.spawnTimestamps.length,
+                maxSpawns: this.config.maxSpawnsPerWindow,
+                windowMs: this.config.rateLimitWindowMs,
+            });
+            return {
+                allowed: false,
+                reason: `Spawn rate limit exceeded (${this.spawnTimestamps.length}/${this.config.maxSpawnsPerWindow} in ${this.config.rateLimitWindowMs}ms)`,
+            };
+        }
+        // 5. Emergency memory check (#55)
+        const memRatio = this.getMemoryUsageRatio();
+        if (memRatio > this.config.memoryThreshold) {
+            frameworkLogger.log("spawn-governance", "memory-threshold-exceeded", "warning", {
+                agentName,
+                memoryUsage: memRatio,
+                threshold: this.config.memoryThreshold,
+            });
+            this.emergencyCleanup();
+            return { allowed: false, reason: `Emergency memory cleanup triggered (heap usage ${(memRatio * 100).toFixed(1)}% > ${(this.config.memoryThreshold * 100).toFixed(0)}%)` };
+        }
+        return { allowed: true };
+    }
+    recordSpawn(agentName) {
+        const now = Date.now();
+        this.activeSpawns.add(agentName);
+        this.spawnTimestamps.push(now);
+        const agentTimes = this.agentSpawnTimestamps.get(agentName) ?? [];
+        agentTimes.push(now);
+        this.agentSpawnTimestamps.set(agentName, agentTimes);
+        // Track subagent depth: increment parent depth for new subagent
+        const currentDepth = this.subagentDepth.get(agentName) ?? 0;
+        this.subagentDepth.set(agentName, currentDepth);
+        frameworkLogger.log("spawn-governance", "spawn-recorded", "info", { agentName, activeSpawns: this.activeSpawns.size });
+    }
+    recordSpawnComplete(agentName) {
+        this.activeSpawns.delete(agentName);
+        this.subagentDepth.delete(agentName);
+        frameworkLogger.log("spawn-governance", "spawn-completed", "info", { agentName, activeSpawns: this.activeSpawns.size });
+    }
+    // -----------------------------------------------------------------------
+    // Metrics
+    // -----------------------------------------------------------------------
+    getMetrics() {
+        this.purgeOldTimestamps(Date.now());
+        return {
+            activeSpawns: this.activeSpawns.size,
+            recentSpawns: this.spawnTimestamps.length,
+            blockedSpawns: this.blockedCount,
+            memoryUsage: this.getMemoryUsageRatio(),
+        };
+    }
+    // -----------------------------------------------------------------------
+    // Emergency cleanup
+    // -----------------------------------------------------------------------
+    emergencyCleanup() {
+        frameworkLogger.log("spawn-governance", "emergency-cleanup-started", "warning", { activeSpawns: this.activeSpawns.size, recentSpawns: this.spawnTimestamps.length });
+        this.activeSpawns.clear();
+        this.spawnTimestamps = [];
+        this.agentSpawnTimestamps.clear();
+        this.subagentDepth.clear();
+        if (global.gc) {
+            global.gc();
+        }
+        frameworkLogger.log("spawn-governance", "emergency-cleanup-completed", "info", {});
+    }
+    // -----------------------------------------------------------------------
+    // Subagent depth management (for recursive prevention)
+    // -----------------------------------------------------------------------
+    setSubagentDepth(agentName, depth) {
+        this.subagentDepth.set(agentName, depth);
+    }
+    // -----------------------------------------------------------------------
+    // Internal helpers
+    // -----------------------------------------------------------------------
+    purgeOldTimestamps(now) {
+        const cutoff = now - this.config.rateLimitWindowMs;
+        this.spawnTimestamps = this.spawnTimestamps.filter((t) => t > cutoff);
+        // Also purge agent-specific timestamps
+        this.agentSpawnTimestamps.forEach((times, agent) => {
+            const filtered = times.filter((t) => t > cutoff);
+            if (filtered.length === 0) {
+                this.agentSpawnTimestamps.delete(agent);
+            }
+            else {
+                this.agentSpawnTimestamps.set(agent, filtered);
+            }
+        });
+    }
+    getMemoryUsageRatio() {
+        try {
+            const mem = process.memoryUsage();
+            return mem.heapUsed / mem.heapTotal;
+        }
+        catch {
+            return 0;
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// Singleton instance for persistent governance state across processor calls
+// ---------------------------------------------------------------------------
+let governanceProcessor = null;
+function getGovernanceProcessor(config) {
+    if (!governanceProcessor) {
+        governanceProcessor = new SpawnGovernanceProcessor(config);
+    }
+    return governanceProcessor;
+}
+export function resetGovernanceProcessor() {
+    governanceProcessor = null;
+}
+// ---------------------------------------------------------------------------
+// Standalone runner for processor-manager integration
+// ---------------------------------------------------------------------------
+export async function runSpawnGovernance(context) {
+    const processor = getGovernanceProcessor(context.config);
+    const agentName = context.agentName;
+    if (!agentName) {
+        return {
+            success: false,
+            allowed: false,
+            reason: "Missing agentName in context",
+            metrics: processor.getMetrics(),
+        };
+    }
+    const check = processor.checkSpawnAllowed(agentName);
+    if (check.allowed) {
+        processor.recordSpawn(agentName);
+    }
+    return {
+        success: true,
+        allowed: check.allowed,
+        ...(check.reason ? { reason: check.reason } : {}),
+        metrics: processor.getMetrics(),
+    };
+}

package/dist/processors/implementations/state-validation-processor.js

@@ -0,0 +1,15 @@
+import { PostProcessor } from "../processor-interfaces.js";
+export class StateValidationProcessor extends PostProcessor {
+    name = "stateValidation";
+    priority = 12;
+    static dependencies = ["stateManager"];
+    stateManager;
+    constructor(stateManager) {
+        super();
+        this.stateManager = stateManager;
+    }
+    async run(_context) {
+        const currentState = this.stateManager.get("session:active");
+        return { stateValid: !!currentState };
+    }
+}