0xray 4.0.12 → 4.0.13

package/dist/processors/implementations/console-log-guard-processor.js

@@ -1,162 +0,0 @@
-/**
- * Console Log Guard Processor
- *
- * Enforces codex term #33: Console Log Guard.
- * Scans code for forbidden console.log/warn/error/info/debug usage,
- * ensuring all logging goes through frameworkLogger instead.
- *
- * @since 2026-03-28
- */
-import { frameworkLogger } from "../../core/framework-logger.js";
-// ---------------------------------------------------------------------------
-// Processor
-// ---------------------------------------------------------------------------
-const CONSOLE_METHODS = ["log", "warn", "error", "info", "debug"];
-const TEST_FILE_PATTERN = /\.(test|spec)\.ts$/;
-export class ConsoleLogGuardProcessor {
-    /**
-     * Scan code content for forbidden console method calls.
-     * Returns violations with line numbers.
-     */
-    checkCode(content, filePath) {
-        if (!content || !content.trim()) {
-            return [];
-        }
-        // Skip test files entirely
-        if (filePath && this.isTestFile(filePath)) {
-            return [];
-        }
-        const stripped = this.stripComments(content);
-        const lines = stripped.split("\n");
-        const violations = [];
-        for (let i = 0; i < lines.length; i++) {
-            const lineNum = i + 1;
-            const line = lines[i];
-            if (!line)
-                continue;
-            for (const method of CONSOLE_METHODS) {
-                const pattern = new RegExp(`\\bconsole\\.${method}\\s*\\(`, "g");
-                if (pattern.test(line)) {
-                    violations.push({
-                        line: lineNum,
-                        type: method,
-                        matched: line.trim(),
-                    });
-                }
-            }
-        }
-        return violations;
-    }
-    /**
-     * Determine if a file path points to a test file.
-     */
-    isTestFile(filePath) {
-        return TEST_FILE_PATTERN.test(filePath);
-    }
-    /**
-     * Remove single-line (//) and multi-line comments from source code.
-     * Preserves line structure so line numbers remain valid.
-     */
-    stripComments(content) {
-        let result = "";
-        let i = 0;
-        const len = content.length;
-        while (i < len) {
-            // Single-line comment: // ... newline
-            if (content[i] === "/" && i + 1 < len && content[i + 1] === "/") {
-                // Skip until end of line
-                while (i < len && content[i] !== "\n") {
-                    i++;
-                }
-                // Keep the newline character to preserve line numbers
-                if (i < len && content[i] === "\n") {
-                    result += "\n";
-                    i++;
-                }
-            }
-            // Multi-line comment: /* ... */
-            else if (content[i] === "/" && i + 1 < len && content[i + 1] === "*") {
-                i += 2; // skip /*
-                while (i < len) {
-                    if (content[i] === "*" && i + 1 < len && content[i + 1] === "/") {
-                        i += 2; // skip */
-                        break;
-                    }
-                    if (content[i] === "\n") {
-                        result += "\n"; // preserve line numbers
-                    }
-                    i++;
-                }
-            }
-            // String literal — skip over to avoid matching // inside strings
-            else if (content[i] === '"' || content[i] === "'" || content[i] === "`") {
-                const quote = content[i];
-                result += content[i];
-                i++;
-                while (i < len && content[i] !== quote) {
-                    if (content[i] === "\\" && i + 1 < len) {
-                        result += content[i];
-                        i++;
-                        result += content[i];
-                        i++;
-                    }
-                    else {
-                        if (content[i] === "\n") {
-                            result += "\n";
-                        }
-                        else {
-                            result += content[i];
-                        }
-                        i++;
-                    }
-                }
-                if (i < len) {
-                    result += content[i]; // closing quote
-                    i++;
-                }
-            }
-            // Regular character
-            else {
-                if (content[i] === "\n") {
-                    result += "\n";
-                }
-                else {
-                    result += content[i];
-                }
-                i++;
-            }
-        }
-        return result;
-    }
-}
-// ---------------------------------------------------------------------------
-// Standalone runner for processor-manager integration
-// ---------------------------------------------------------------------------
-export async function runConsoleLogGuard(context) {
-    const start = performance.now();
-    try {
-        const content = context.data ?? "";
-        const filePath = context.filesChanged?.[0];
-        const processor = new ConsoleLogGuardProcessor();
-        const violations = processor.checkCode(content, filePath);
-        const hasViolations = violations.length > 0;
-        if (hasViolations) {
-            frameworkLogger.log("console-log-guard-processor", "violations_found", "warning", { violations, filePath });
-        }
-        return {
-            success: !hasViolations,
-            processorName: "console-log-guard-processor",
-            duration: performance.now() - start,
-            result: { violations },
-        };
-    }
-    catch (error) {
-        frameworkLogger.log("console-log-guard-processor", "check_failed", "error", { error: error.message });
-        return {
-            success: false,
-            processorName: "console-log-guard-processor",
-            duration: performance.now() - start,
-            error: error.message,
-        };
-    }
-}

package/dist/processors/implementations/coverage-analysis-processor.d.ts

@@ -1,19 +0,0 @@
-/**
- * Coverage Analysis Processor
- *
- * Analyzes test coverage for modified files and reports coverage gaps.
- *
- * @module processors/implementations
- */
-import { PostProcessor } from "../processor-interfaces.js";
-import { ProcessorContext } from "../processor-types.js";
-export declare class CoverageAnalysisProcessor extends PostProcessor {
-    readonly name = "coverageAnalysis";
-    readonly priority = 45;
-    protected run(context: ProcessorContext): Promise<unknown>;
-    private analyzeCoverage;
-    private findRelatedTestFiles;
-    private countSourceLines;
-    private countTestLines;
-}
-export declare const coverageAnalysisProcessor: CoverageAnalysisProcessor;

package/dist/processors/implementations/coverage-analysis-processor.js

@@ -1,137 +0,0 @@
-/**
- * Coverage Analysis Processor
- *
- * Analyzes test coverage for modified files and reports coverage gaps.
- *
- * @module processors/implementations
- */
-import { PostProcessor } from "../processor-interfaces.js";
-import { frameworkLogger } from "../../core/framework-logger.js";
-import { existsSync, readFileSync } from "fs";
-export class CoverageAnalysisProcessor extends PostProcessor {
-    name = "coverageAnalysis";
-    priority = 45;
-    async run(context) {
-        const filePath = context.filePath || context.toolInput?.args?.filePath;
-        const operation = context.operation || context.toolInput?.args?.operation;
-        if (!filePath) {
-            return { success: true, message: "no file path specified" };
-        }
-        frameworkLogger.log("coverage-analysis-processor", "execution-started", "info", { filePath, operation });
-        const coverage = await this.analyzeCoverage(filePath);
-        if (coverage.coveragePercentage >= 80) {
-            frameworkLogger.log("coverage-analysis-processor", "coverage-good", "info", { filePath, coverage: coverage.coveragePercentage });
-            return {
-                success: true,
-                duration: 0,
-                processorName: this.name,
-                data: {
-                    coverage: coverage.coveragePercentage,
-                    message: `Coverage: ${coverage.coveragePercentage}% (${coverage.coverage.linesCovered}/${coverage.coverage.linesTotal} lines)`,
-                },
-            };
-        }
-        else {
-            frameworkLogger.log("coverage-analysis-processor", "coverage-low", "warning", { filePath, coverage: coverage.coveragePercentage });
-            return {
-                success: true,
-                duration: 0,
-                processorName: this.name,
-                data: {
-                    coverage: coverage.coveragePercentage,
-                    uncoveredLines: coverage.uncoveredLines,
-                    message: `Low coverage: ${coverage.coveragePercentage}% - consider adding tests`,
-                },
-            };
-        }
-    }
-    async analyzeCoverage(filePath) {
-        const testFiles = this.findRelatedTestFiles(filePath);
-        if (testFiles.length === 0) {
-            return {
-                filePath,
-                coverage: {
-                    linesCovered: 0,
-                    linesTotal: 0,
-                    branchesCovered: 0,
-                    branchesTotal: 0,
-                    functionsCovered: 0,
-                    functionsTotal: 0,
-                },
-                uncoveredLines: [],
-                coveragePercentage: 0,
-            };
-        }
-        const sourceLines = await this.countSourceLines(filePath);
-        const testLines = await this.countTestLines(testFiles);
-        const coverage = {
-            linesCovered: Math.min(testLines, sourceLines),
-            linesTotal: sourceLines,
-            branchesCovered: Math.floor(testLines / 10),
-            branchesTotal: Math.floor(sourceLines / 10),
-            functionsCovered: Math.floor(testLines / 20),
-            functionsTotal: Math.floor(sourceLines / 20),
-        };
-        const percentage = sourceLines > 0 ? Math.round((coverage.linesCovered / sourceLines) * 100) : 0;
-        const uncoveredLines = [];
-        if (percentage < 100) {
-            for (let i = 1; i <= sourceLines; i++) {
-                if (Math.random() > (percentage / 100)) {
-                    uncoveredLines.push(i);
-                    if (uncoveredLines.length >= 10)
-                        break;
-                }
-            }
-        }
-        return {
-            filePath,
-            coverage,
-            uncoveredLines,
-            coveragePercentage: percentage,
-        };
-    }
-    findRelatedTestFiles(filePath) {
-        const testPatterns = [".test.ts", ".spec.ts", ".test.js", ".spec.js"];
-        const baseName = filePath.replace(/\.(ts|js)$/, "");
-        const testFiles = [];
-        for (const pattern of testPatterns) {
-            testFiles.push(`${baseName}${pattern}`);
-        }
-        return testFiles.filter((f) => {
-            try {
-                return existsSync(f);
-            }
-            catch {
-                return false;
-            }
-        });
-    }
-    async countSourceLines(filePath) {
-        try {
-            const content = readFileSync(filePath, "utf-8");
-            return content.split("\n").filter((line) => {
-                const trimmed = line.trim();
-                return trimmed.length > 0 && !trimmed.startsWith("//") && !trimmed.startsWith("/*");
-            }).length;
-        }
-        catch {
-            return 0;
-        }
-    }
-    async countTestLines(testFiles) {
-        let total = 0;
-        try {
-            for (const testFile of testFiles) {
-                if (existsSync(testFile)) {
-                    const content = readFileSync(testFile, "utf-8");
-                    total += content.split("\n").length;
-                }
-            }
-        }
-        catch {
-            // ignore
-        }
-        return total;
-    }
-}
-export const coverageAnalysisProcessor = new CoverageAnalysisProcessor();

package/dist/processors/implementations/error-boundary-processor.d.ts

@@ -1,7 +0,0 @@
-import { PreProcessor } from "../processor-interfaces.js";
-import type { ProcessorContext, ProcessorResult } from "../processor-types.js";
-export declare class ErrorBoundaryProcessor extends PreProcessor {
-    readonly name = "errorBoundary";
-    readonly priority = 5;
-    protected run(context: ProcessorContext): Promise<ProcessorResult>;
-}

package/dist/processors/implementations/error-boundary-processor.js

@@ -1,44 +0,0 @@
-import { PreProcessor } from "../processor-interfaces.js";
-import { frameworkLogger } from "../../core/framework-logger.js";
-export class ErrorBoundaryProcessor extends PreProcessor {
-    name = "errorBoundary";
-    priority = 5;
-    async run(context) {
-        const startTime = Date.now();
-        const errors = [];
-        try {
-            const priorResults = context
-                .priorResults;
-            if (priorResults) {
-                for (const result of priorResults) {
-                    if (!result.success && result.error) {
-                        errors.push(result.error);
-                        frameworkLogger.log("error-boundary-processor", "caught-prior-error", "warning", { error: result.error, processor: result.processorName });
-                    }
-                }
-            }
-            if (errors.length > 0) {
-                frameworkLogger.log("error-boundary-processor", "errors-bounded", "warning", { errorCount: errors.length });
-            }
-            return {
-                success: errors.length === 0,
-                data: {
-                    boundaries: true,
-                    errorsBounded: errors.length,
-                    errors,
-                },
-                duration: Date.now() - startTime,
-                processorName: this.name,
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: `Error boundary failed: ${error instanceof Error ? error.message : String(error)}`,
-                data: { boundaries: false, errorsBounded: 0, errors: [] },
-                duration: Date.now() - startTime,
-                processorName: this.name,
-            };
-        }
-    }
-}

package/dist/processors/implementations/inference-improvement-processor.d.ts

@@ -1,36 +0,0 @@
-/**
- * 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 { PostProcessor } from "../processor-interfaces.js";
-export declare class InferenceImprovementProcessor extends PostProcessor {
-    readonly name = "inferenceImprovement";
-    readonly priority = 5;
-    private readonly reflectionsDir;
-    private readonly logsDir;
-    private readonly reportsDir;
-    private readonly workflowDir;
-    private readonly inferenceEnabled;
-    private readonly patternMatchingEnabled;
-    private readonly patternMatchingThreshold;
-    constructor();
-    private loadInferenceConfig;
-    protected run(context: unknown): Promise<unknown>;
-    private prepareWorkflowContext;
-    private findReflections;
-    private findLogs;
-    private findReports;
-    private saveWorkflowContext;
-    private generateAgentPrompts;
-    private generateResearcherPrompt;
-    private generateCodeAnalyzerPrompt;
-    private generateArchitectPrompt;
-    private generateCodeReviewerPrompt;
-    private generateEnforcerPrompt;
-    private triggerAgentWorkflow;
-}

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

@@ -1,262 +0,0 @@
-/**
- * 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";
-import { featuresConfigLoader } from "../../core/features-config.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 {
-            return featuresConfigLoader.loadConfig().inference ?? null;
-        }
-        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));
-    }
-}