0xray 2.0.0

package/dist/processors/implementations/inference-improvement-processor.js

@@ -0,0 +1,270 @@
+/**
+ * Inference Improvement Coordinator
+ *
+ * Lightweight processor that coordinates the agent-based inference workflow.
+ * The actual analysis is done by collaborating agents (researcher, code-analyzer,
+ * architect, code-reviewer, enforcer) - this processor prepares context and triggers.
+ *
+ * @module processors/implementations
+ */
+import * as fs from "fs";
+import * as path from "path";
+import { PostProcessor } from "../processor-interfaces.js";
+import { frameworkLogger } from "../../core/framework-logger.js";
+import { getConfigDir } from "../../core/config-paths.js";
+export class InferenceImprovementProcessor extends PostProcessor {
+    name = "inferenceImprovement";
+    priority = 5;
+    reflectionsDir = "docs/reflections";
+    logsDir = "logs/framework";
+    reportsDir;
+    workflowDir;
+    inferenceEnabled;
+    patternMatchingEnabled;
+    patternMatchingThreshold;
+    constructor() {
+        super();
+        const config = this.loadInferenceConfig();
+        this.inferenceEnabled = config?.enabled ?? true;
+        this.patternMatchingEnabled = config?.pattern_matching?.enabled ?? true;
+        this.patternMatchingThreshold = config?.pattern_matching?.confidence_threshold ?? 0.7;
+        this.reportsDir = config?.reports_dir
+            ? path.join(process.cwd(), config.reports_dir)
+            : path.join(getConfigDir(), "reports");
+        this.workflowDir = config?.workflow_dir
+            ? path.join(process.cwd(), config.workflow_dir)
+            : path.join(getConfigDir(), "inference");
+    }
+    loadInferenceConfig() {
+        try {
+            const configPaths = [
+                path.join(process.cwd(), ".strray", "features.json"),
+                path.join(process.cwd(), ".opencode", "strray", "features.json"),
+            ];
+            for (const configPath of configPaths) {
+                if (fs.existsSync(configPath)) {
+                    const config = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+                    return config.inference || config;
+                }
+            }
+        }
+        catch (e) {
+            // ignore - use defaults
+        }
+        return null;
+    }
+    async run(context) {
+        if (!this.inferenceEnabled) {
+            return { message: "Inference processor disabled", success: true };
+        }
+        const ctx = context;
+        const directory = ctx.directory || process.cwd();
+        await frameworkLogger.log("inference-improvement", "preparing_workflow_context", "info", { directory });
+        try {
+            const workflowContext = await this.prepareWorkflowContext(directory);
+            await this.saveWorkflowContext(directory, workflowContext);
+            await this.triggerAgentWorkflow(workflowContext);
+            await frameworkLogger.log("inference-improvement", "workflow_triggered", "info", {
+                dataFiles: workflowContext.dataLocations.reflections.length +
+                    workflowContext.dataLocations.logs.length +
+                    workflowContext.dataLocations.reports.length,
+                workflowPhase: workflowContext.workflow.phase
+            });
+            return {
+                success: true,
+                workflowTriggered: true,
+                context: workflowContext.workflow,
+                message: "Agent workflow triggered for inference improvement"
+            };
+        }
+        catch (error) {
+            await frameworkLogger.log("inference-improvement", "error", "error", { error: error instanceof Error ? error.message : String(error) });
+            return { success: false, error: String(error) };
+        }
+    }
+    async prepareWorkflowContext(directory) {
+        const reflections = this.findReflections(directory);
+        const logs = this.findLogs(directory);
+        const reports = this.findReports(directory);
+        return {
+            timestamp: new Date().toISOString(),
+            dataLocations: {
+                reflections,
+                logs,
+                reports
+            },
+            workflow: {
+                phase: "pending",
+                triggered: false
+            },
+            pendingAdjustments: []
+        };
+    }
+    findReflections(directory) {
+        const reflectionsPath = path.join(directory, this.reflectionsDir);
+        if (!fs.existsSync(reflectionsPath))
+            return [];
+        return fs.readdirSync(reflectionsPath)
+            .filter(f => f.endsWith(".md"))
+            .map(f => path.join(reflectionsPath, f));
+    }
+    findLogs(directory) {
+        const logsPath = path.join(directory, this.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));
+    }
+    findReports(directory) {
+        const reportsPath = path.join(directory, this.reportsDir);
+        if (!fs.existsSync(reportsPath))
+            return [];
+        return fs.readdirSync(reportsPath)
+            .filter(f => f.endsWith(".json") || f.endsWith(".md"))
+            .map(f => path.join(reportsPath, f));
+    }
+    async saveWorkflowContext(directory, context) {
+        const workflowPath = path.isAbsolute(this.workflowDir)
+            ? this.workflowDir
+            : path.join(directory, this.workflowDir);
+        if (!fs.existsSync(workflowPath)) {
+            fs.mkdirSync(workflowPath, { recursive: true });
+        }
+        const filename = `workflow-${Date.now()}.json`;
+        fs.writeFileSync(path.join(workflowPath, filename), JSON.stringify(context, null, 2));
+        fs.writeFileSync(path.join(workflowPath, "latest-workflow.json"), JSON.stringify(context, null, 2));
+        await this.generateAgentPrompts(directory, context);
+    }
+    async generateAgentPrompts(directory, context) {
+        const workflowBase = path.isAbsolute(this.workflowDir) ? this.workflowDir : path.join(directory, this.workflowDir);
+        const promptsDir = path.join(workflowBase, "prompts");
+        if (!fs.existsSync(promptsDir)) {
+            fs.mkdirSync(promptsDir, { recursive: true });
+        }
+        const prompts = {
+            "01-researcher.md": this.generateResearcherPrompt(context),
+            "02-code-analyzer.md": this.generateCodeAnalyzerPrompt(),
+            "03-architect.md": this.generateArchitectPrompt(),
+            "04-code-reviewer.md": this.generateCodeReviewerPrompt(),
+            "05-enforcer.md": this.generateEnforcerPrompt()
+        };
+        for (const [filename, content] of Object.entries(prompts)) {
+            fs.writeFileSync(path.join(promptsDir, filename), content);
+        }
+        await frameworkLogger.log("inference-improvement", "agent_prompts_generated", "info", { count: Object.keys(prompts).length });
+    }
+    generateResearcherPrompt(context) {
+        return `# Researcher: Data Gathering Phase
+
+## Task
+Analyze the following data sources to gather insights for inference improvement:
+
+### Data Locations
+${context.dataLocations.reflections.map(f => `- ${f}`).join('\n')}
+${context.dataLocations.logs.map(f => `- ${f}`).join('\n')}
+${context.dataLocations.reports.map(f => `- ${f}`).join('\n')}
+
+## Output Required
+1. Summary of key findings from each data source
+2. Identified routing patterns (success/failure)
+3. Emerging keyword trends
+4. Agent performance observations
+
+## Format
+Return your findings in a structured report.
+`;
+    }
+    generateCodeAnalyzerPrompt() {
+        return `# Code-Analyzer: Pattern Analysis Phase
+
+## Task
+Analyze the gathered data for patterns and metrics:
+
+1. Routing success/failure rates
+2. Confidence distribution
+3. Keyword effectiveness
+4. Complexity scoring accuracy
+
+## Output Required
+1. Pattern analysis report
+2. Metrics summary
+3. Identified issues
+4. Recommendations for improvement
+`;
+    }
+    generateArchitectPrompt() {
+        return `# Architect: Design Improvements Phase
+
+## Task
+Based on the analysis, design routing improvements:
+
+1. Propose new keyword mappings
+2. Suggest confidence adjustments
+3. Recommend complexity threshold changes
+4. Design new routing patterns
+
+## Output Required
+1. Proposed changes (structured)
+2. Implementation plan
+3. Risk assessment
+`;
+    }
+    generateCodeReviewerPrompt() {
+        return `# Code-Reviewer: Review & Refine Phase
+
+## Task
+Review proposed improvements for quality:
+
+1. Validate change quality
+2. Identify potential regressions
+3. Refine suggestions
+4. Prioritize changes
+
+## Output Required
+1. Approved changes
+2. Modified changes
+3. Rejected changes with reasons
+4. Final priority list
+`;
+    }
+    generateEnforcerPrompt() {
+        return `# Enforcer: Validate & Apply Phase
+
+## Task
+Final validation and application of approved changes:
+
+1. Codex compliance check
+2. Safety validation
+3. Apply approved changes to configuration
+4. Log all changes
+
+## Output Required
+1. Validation report
+2. Applied changes
+3. Compliance status
+`;
+    }
+    async triggerAgentWorkflow(context) {
+        const workflow = {
+            ...context.workflow,
+            phase: "data_gathering",
+            triggered: true,
+            triggeredAt: new Date().toISOString()
+        };
+        context.workflow = workflow;
+        await frameworkLogger.log("inference-improvement", "agent_workflow_initiated", "info", {
+            message: "Inference improvement workflow initiated. Next: @researcher analyze data",
+            phases: ["researcher", "code-analyzer", "architect", "code-reviewer"]
+        });
+        const workflowBase = path.isAbsolute(this.workflowDir) ? this.workflowDir : path.join(process.cwd(), this.workflowDir);
+        const outputPath = path.join(workflowBase, "workflow-status.json");
+        fs.writeFileSync(outputPath, JSON.stringify({
+            status: "in_progress",
+            phase: "data_gathering",
+            nextAgent: "researcher",
+            message: "Invoke @researcher to begin data gathering phase",
+            workflowId: `inference-${Date.now()}`
+        }, null, 2));
+    }
+}

package/dist/processors/implementations/log-protection-processor.js

@@ -0,0 +1,118 @@
+/**
+ * Log Protection Processor
+ *
+ * Prevents deletion of critical inference log files that are essential
+ * for the tuning engines and pattern learning system.
+ *
+ * Protected files:
+ * - routing-outcomes.json (routing analytics - NEVER delete)
+ * - activity.log (framework activity - NEVER delete)
+ * - strray-plugin-*.log (plugin logs)
+ *
+ * Archival flow is ALLOWED:
+ * - framework-activity-*.log.gz (archived/compressed logs)
+ * - Copy operations to create new archive files
+ *
+ * @module processors/implementations
+ * @version 1.1.0
+ */
+import { PreProcessor } from "../processor-interfaces.js";
+import { frameworkLogger } from "../../core/framework-logger.js";
+/**
+ * Files that are ACTIVE and MUST be protected (never delete)
+ */
+const ACTIVE_LOG_PATTERNS = [
+    /routing-outcomes\.json$/,
+    /activity\.log$/,
+    /activity\.log\.gz$/,
+];
+/**
+ * Archived log files that CAN be cleaned up (old rotations)
+ */
+const ARCHIVE_PATTERNS = [
+    /framework-activity-.+\.log\.gz$/,
+    /strray-plugin-.+\.log\.gz$/,
+];
+/**
+ * Directories/files that are protected
+ */
+const PROTECTED_PATH_PATTERNS = [
+    /\.opencode\/state\//,
+    /routing-outcomes\.json$/,
+];
+export class LogProtectionProcessor extends PreProcessor {
+    name = "logProtection";
+    priority = 10;
+    async run(context) {
+        const filePath = this.getFilePath(context);
+        const operation = this.getOperation(context);
+        if (!filePath) {
+            return { allowed: true, reason: "no file path specified" };
+        }
+        const normalizedPath = filePath.replace(/\\/g, "/");
+        const isDeleteOp = this.isDeleteOperation(operation);
+        if (!isDeleteOp) {
+            return { allowed: true, reason: "not a delete operation" };
+        }
+        // Check if this is an archive cleanup operation (allowed)
+        if (this.isArchiveCleanup(normalizedPath)) {
+            frameworkLogger.log("log-protection-processor", "archive-cleanup-allowed", "info", { filePath: normalizedPath, operation });
+            return { allowed: true, isArchiveCleanup: true };
+        }
+        // Check if trying to delete active log files
+        const activeFile = this.getActiveLogFile(normalizedPath);
+        if (activeFile) {
+            frameworkLogger.log("log-protection-processor", "deletion-blocked", "warning", {
+                filePath: normalizedPath,
+                operation,
+                reason: `Active log file '${activeFile}' - deletion prohibited`,
+            });
+            return {
+                allowed: false,
+                reason: `Deletion of active log file '${activeFile}' is prohibited. These files are essential for the inference engine and pattern learning system.`,
+                suggestion: "Use 'npx 0xray archive-logs' to safely archive and rotate logs.",
+                protectedFiles: [
+                    "routing-outcomes.json - routing analytics data (NEVER delete)",
+                    "activity.log - framework activity tracking (NEVER delete)",
+                ],
+            };
+        }
+        return { allowed: true };
+    }
+    isDeleteOperation(operation) {
+        if (!operation)
+            return false;
+        const deleteOps = ["delete", "remove", "rm", "unlink", "del", "erase", "clear"];
+        return deleteOps.some((op) => operation.toLowerCase().includes(op));
+    }
+    isArchiveCleanup(filePath) {
+        const fileName = filePath.split("/").pop() || "";
+        // Archived files (with timestamps) can be cleaned up
+        for (const pattern of ARCHIVE_PATTERNS) {
+            if (pattern.test(fileName) || pattern.test(filePath)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    getActiveLogFile(filePath) {
+        const fileName = filePath.split("/").pop() || "";
+        // Check for active log files
+        for (const pattern of ACTIVE_LOG_PATTERNS) {
+            if (pattern.test(fileName)) {
+                return fileName;
+            }
+        }
+        // Check protected paths
+        for (const pattern of PROTECTED_PATH_PATTERNS) {
+            if (pattern.test(filePath)) {
+                return filePath.split("/").pop() || filePath;
+            }
+        }
+        return null;
+    }
+    getOperation(context) {
+        return (context.operation || context.toolInput?.args?.operation);
+    }
+}
+export const logProtectionProcessor = new LogProtectionProcessor();

package/dist/processors/implementations/nudge-processor.js

@@ -0,0 +1,130 @@
+/**
+ * Nudge Processor - Integrates Nudge Watchdog with processor system
+ *
+ * Post-processor that monitors agent actions and triggers nudges
+ * when stuck patterns are detected.
+ *
+ * @module processors/implementations
+ * @version 1.0.0
+ */
+import { PostProcessor } from "../processor-interfaces.js";
+import { frameworkLogger } from "../../core/framework-logger.js";
+import { nudgeWatchdog, recordThinkTag, recordCodeChange, recordToolCall, recordFixAttempt, recordExplanation, getNudgeSuggestion, } from "../../monitoring/nudge-watchdog.js";
+import { featuresConfigLoader } from "../../core/features-config.js";
+export class NudgeProcessor extends PostProcessor {
+    name = "nudge";
+    priority = 100;
+    nudgeEnabled = true;
+    constructor() {
+        super();
+        this.loadConfig();
+    }
+    loadConfig() {
+        try {
+            const features = featuresConfigLoader.loadConfig();
+            const nudgeConfig = features?.nudge_watchdog;
+            if (nudgeConfig) {
+                this.nudgeEnabled = nudgeConfig.enabled !== false;
+            }
+        }
+        catch {
+            // Use defaults
+        }
+    }
+    async run(context) {
+        if (!this.nudgeEnabled) {
+            return { success: true, reason: "nudge processor disabled" };
+        }
+        const tool = context.tool;
+        const filePath = context.filePath;
+        const content = context.content;
+        const toolInput = context.toolInput;
+        if (toolInput?.tool) {
+            recordToolCall(toolInput.tool, JSON.stringify(toolInput.args || {}));
+        }
+        if (tool === "edit" || tool === "write") {
+            recordCodeChange();
+        }
+        if (tool === "read" || tool === "Glob") {
+            const args = toolInput?.args;
+            if (args?.operation === "read-multiple" || args?.filePath) {
+                recordFixAttempt(args.filePath, "repeated-read");
+            }
+        }
+        if (content) {
+            const hasThinkingTags = /<thinking>[\s\S]*?<\/thinking>/gi.test(content);
+            if (hasThinkingTags) {
+                const thinkingMatches = content.match(/<thinking>[\s\S]*?<\/thinking>/gi);
+                if (thinkingMatches) {
+                    for (let i = 0; i < thinkingMatches.length; i++) {
+                        recordThinkTag();
+                    }
+                }
+            }
+            const explanationPatterns = [
+                /(?:let me| i think| essentially| in other words| what i mean is)/gi,
+                /^\s*(Here's the|An|a) \w+:/gim,
+            ];
+            for (const pattern of explanationPatterns) {
+                const matches = content.match(pattern);
+                if (matches && matches.length > 2) {
+                    recordExplanation();
+                }
+            }
+        }
+        const stats = nudgeWatchdog.getStats();
+        if (stats.activePatterns > 0) {
+            const nudge = this.detectMostUrgentNudge(stats);
+            if (nudge) {
+                const suggestion = getNudgeSuggestion(nudge, { filePath });
+                frameworkLogger.log("nudge-processor", "stuck-pattern-detected", "warning", {
+                    pattern: nudge,
+                    stats,
+                    suggestion,
+                });
+                return {
+                    success: true,
+                    nudgeDetected: true,
+                    pattern: nudge,
+                    suggestion,
+                    stats,
+                };
+            }
+        }
+        return {
+            success: true,
+            nudgeDetected: false,
+            stats,
+        };
+    }
+    detectMostUrgentNudge(stats) {
+        const thresholds = {
+            "think-loop": stats.thinkTags,
+            "syntax-loop": stats.thinkTags,
+            "death-spiral": stats.explanations,
+            "tool-loop": stats.activePatterns,
+            "repair-failure": stats.activePatterns,
+        };
+        let maxType = null;
+        let maxCount = 0;
+        const priorities = [
+            "repair-failure",
+            "syntax-loop",
+            "think-loop",
+            "tool-loop",
+            "death-spiral",
+        ];
+        for (const type of priorities) {
+            const count = thresholds[type] || 0;
+            if (count > maxCount) {
+                maxCount = count;
+                maxType = type;
+            }
+        }
+        return maxType;
+    }
+}
+export const nudgeProcessor = new NudgeProcessor();
+export async function executeNudgeProcessor(context) {
+    return nudgeProcessor.execute(context);
+}