0xray 2.0.0

package/dist/processors/implementations/async-pattern-processor.js

@@ -0,0 +1,158 @@
+/**
+ * Async Pattern Processor
+ *
+ * Enforces codex term #31: Async Pattern Detection.
+ * Detects anti-patterns in async code: callback patterns, long promise chains,
+ * missing await inside async functions, and mixed callback/promise styles.
+ *
+ * @version 1.0.0
+ * @since 2026-03-28
+ */
+import { frameworkLogger } from "../../core/framework-logger.js";
+// ---------------------------------------------------------------------------
+// Processor
+// ---------------------------------------------------------------------------
+export class AsyncPatternProcessor {
+    /**
+     * Run all async-pattern checks against `content`.
+     */
+    checkCode(content) {
+        const violations = [];
+        if (this.hasCallbackPattern(content)) {
+            violations.push({
+                type: "callbackPattern",
+                message: "Callback pattern detected (node-style err-first callback or inline function callbacks)",
+            });
+        }
+        if (this.hasLongPromiseChain(content)) {
+            const count = this.countPromiseChains(content);
+            violations.push({
+                type: "longPromiseChain",
+                message: `Promise chain has ${count} .then() calls (max 3)`,
+            });
+        }
+        if (this.hasMissingAwait(content)) {
+            violations.push({
+                type: "missingAwait",
+                message: "Async function contains un-awaited promise-returning calls (.then() or new Promise without await)",
+            });
+        }
+        if (this.hasMixedCallbackAsync(content)) {
+            violations.push({
+                type: "mixedCallbackAsync",
+                message: "Async function mixes callback patterns with async/await",
+            });
+        }
+        return violations;
+    }
+    /**
+     * Detect node-style callbacks: `function(err, ` or inline function callbacks.
+     */
+    hasCallbackPattern(content) {
+        const errFirstCallback = /function\s*\(\s*err\s*,/g.test(content);
+        const inlineCallback = /\(\s*function\s*\(/g.test(content);
+        return errFirstCallback || inlineCallback;
+    }
+    /**
+     * Detect promise chains with more than 3 .then() calls.
+     */
+    hasLongPromiseChain(content) {
+        return this.countPromiseChains(content) > 3;
+    }
+    /**
+     * Detect async functions that contain .then() or `new Promise` without an
+     * accompanying await in the same scope.
+     */
+    hasMissingAwait(content) {
+        // Find async function bodies
+        const asyncFnRegex = /async\s+function\s*\w*[^{]*\{[\s\S]*?\n\}/g;
+        const asyncArrowRegex = /async\s+(?:\([^)]*\)|[a-zA-Z_]\w*)\s*=>\s*\{[\s\S]*?\n\}/g;
+        const combined = content.replace(asyncFnRegex, (match) => {
+            return this._checkAsyncBodyForMissingAwait(match);
+        });
+        const combined2 = combined.replace(asyncArrowRegex, (match) => {
+            return this._checkAsyncBodyForMissingAwait(match);
+        });
+        // If any replacement introduced a marker, violation found
+        return combined2.includes("__MISSING_AWAIT_DETECTED__");
+    }
+    /**
+     * Detect callbacks used inside async functions.
+     */
+    hasMixedCallbackAsync(content) {
+        const asyncFnRegex = /async\s+function\s*\w*[^{]*\{([\s\S]*?)\n\}/g;
+        const asyncArrowRegex = /async\s+(?:\([^)]*\)|[a-zA-Z_]\w*)\s*=>\s*\{([\s\S]*?)\n\}/g;
+        const checkBody = (body) => {
+            return (/function\s*\(\s*err\s*,/g.test(body) ||
+                /\(\s*function\s*\(/g.test(body));
+        };
+        let match;
+        asyncFnRegex.lastIndex = 0;
+        while ((match = asyncFnRegex.exec(content)) !== null) {
+            if (checkBody(match[0]))
+                return true;
+        }
+        asyncArrowRegex.lastIndex = 0;
+        while ((match = asyncArrowRegex.exec(content)) !== null) {
+            if (checkBody(match[0]))
+                return true;
+        }
+        return false;
+    }
+    // -----------------------------------------------------------------------
+    // Internal helpers
+    // -----------------------------------------------------------------------
+    countPromiseChains(content) {
+        const matches = content.match(/\.then\s*\(/g);
+        return matches ? matches.length : 0;
+    }
+    /**
+     * Within an async function body, check if .then() or new Promise is used
+     * without await. If so, return a marker string; otherwise return original.
+     */
+    _checkAsyncBodyForMissingAwait(asyncBody) {
+        // Check for .then( that is not on the same line as an await
+        const lines = asyncBody.split("\n");
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (/\.then\s*\(/.test(trimmed) && !/\bawait\b/.test(trimmed)) {
+                return "__MISSING_AWAIT_DETECTED__";
+            }
+            // new Promise without await on the same line or preceding
+            if (/new\s+Promise\b/.test(trimmed) && !/\bawait\b/.test(trimmed)) {
+                return "__MISSING_AWAIT_DETECTED__";
+            }
+        }
+        return asyncBody;
+    }
+}
+// ---------------------------------------------------------------------------
+// Standalone runner for processor-manager integration
+// ---------------------------------------------------------------------------
+export async function runAsyncPatternCheck(context) {
+    const start = performance.now();
+    try {
+        const content = context.data ?? "";
+        const processor = new AsyncPatternProcessor();
+        const violations = processor.checkCode(content);
+        const hasViolations = violations.length > 0;
+        if (hasViolations) {
+            frameworkLogger.log("async-pattern-processor", "violations_found", "warning", { violations });
+        }
+        return {
+            success: !hasViolations,
+            processorName: "async-pattern-processor",
+            duration: performance.now() - start,
+            result: { violations },
+        };
+    }
+    catch (error) {
+        frameworkLogger.log("async-pattern-processor", "check_failed", "error", { error: error.message });
+        return {
+            success: false,
+            processorName: "async-pattern-processor",
+            duration: performance.now() - start,
+            error: error.message,
+        };
+    }
+}

package/dist/processors/implementations/codex-compliance-processor.js

@@ -0,0 +1,57 @@
+import { PreProcessor } from "../processor-interfaces.js";
+import { frameworkLogger } from "../../core/framework-logger.js";
+export class CodexComplianceProcessor extends PreProcessor {
+    name = "codexCompliance";
+    priority = 2;
+    async run(context) {
+        const { operation } = context;
+        try {
+            const { RuleEnforcer } = await import("../../enforcement/rule-enforcer.js");
+            const ruleEnforcer = new RuleEnforcer();
+            const validationContext = {
+                files: context.files || [],
+                newCode: context.newCode || "",
+                existingCode: context.existingCode || new Map(),
+                tests: context.tests || [],
+                dependencies: context.dependencies || [],
+                operation: context.operation || "unknown",
+            };
+            const result = await ruleEnforcer.validateOperation(operation || "unknown", validationContext);
+            if (!result.passed && result.errors.length > 0) {
+                const violations = result.errors.map((msg) => {
+                    const colonIndex = msg.indexOf(':');
+                    const rule = colonIndex > 0 ? msg.substring(0, colonIndex).trim() : "unknown";
+                    return {
+                        rule,
+                        message: colonIndex > 0 ? msg.substring(colonIndex + 1).trim() : msg,
+                    };
+                });
+                if (violations.length > 0) {
+                    await ruleEnforcer.attemptRuleViolationFixes(violations, validationContext);
+                }
+            }
+            return {
+                compliant: result.passed,
+                violations: result.errors,
+                warnings: result.warnings,
+                termsChecked: result.results.length,
+                operation: operation,
+                timestamp: new Date().toISOString(),
+            };
+        }
+        catch (error) {
+            frameworkLogger.log("codex-compliance-processor", "check-failed", "warning", {
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return {
+                compliant: true,
+                violations: [`Compliance check error: ${error instanceof Error ? error.message : String(error)}`],
+                warnings: [],
+                termsChecked: 0,
+                operation: operation,
+                error: true,
+                timestamp: new Date().toISOString(),
+            };
+        }
+    }
+}

package/dist/processors/implementations/commit-batcher-processor.js

@@ -0,0 +1,71 @@
+import { PostProcessor } from "../processor-interfaces.js";
+import { frameworkLogger } from "../../core/framework-logger.js";
+import { IntelligentCommitBatcher, } from "../../orchestrator/intelligent-commit-batcher.js";
+let batcherSingleton = null;
+function getBatcher() {
+    if (!batcherSingleton) {
+        batcherSingleton = new IntelligentCommitBatcher();
+    }
+    return batcherSingleton;
+}
+export class CommitBatcherProcessor extends PostProcessor {
+    name = "commitBatcher";
+    priority = 85;
+    trackedCount = 0;
+    batcher;
+    constructor(batcher) {
+        super();
+        this.batcher = batcher ?? getBatcher();
+    }
+    async run(context) {
+        try {
+            const tool = context.tool;
+            const filePath = context.filePath;
+            const operation = context.operation;
+            if (!tool || !["edit", "write", "apply", "create", "delete", "rename"].includes(tool)) {
+                return { success: true, batched: false, reason: "Not a file-modifying tool" };
+            }
+            if (!filePath) {
+                return { success: true, batched: false, reason: "No file path" };
+            }
+            const change = {
+                filePath,
+                operation: tool,
+                changeType: this.inferChangeType(tool, filePath),
+                riskLevel: "low",
+                linesChanged: 0,
+                timestamp: Date.now(),
+            };
+            const shouldCommit = this.batcher.addChange(change);
+            this.trackedCount += 1;
+            if (shouldCommit) {
+                const committed = await this.batcher.commitBatch();
+                this.trackedCount = 0;
+                frameworkLogger.log("commit-batcher-processor", "commit-triggered", "info", { committed, filePath, tool });
+                return { success: true, batched: true, committed };
+            }
+            return { success: true, batched: false, pendingCount: this.trackedCount };
+        }
+        catch (error) {
+            frameworkLogger.log("commit-batcher-processor", "error", "error", { error: error instanceof Error ? error.message : String(error) });
+            return { success: false, batched: false, error: String(error) };
+        }
+    }
+    inferChangeType(tool, filePath) {
+        if (filePath.includes("test"))
+            return "test";
+        if (filePath.includes("config"))
+            return "config";
+        if (["edit", "write", "apply"].includes(tool))
+            return "refactor";
+        if (tool === "create")
+            return "feature";
+        if (tool === "delete")
+            return "refactor";
+        return "refactor";
+    }
+}
+export async function executeCommitBatcherProcessor(context) {
+    const processor = new CommitBatcherProcessor();
+    return processor.execute(context);
+}

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

@@ -0,0 +1,163 @@
+/**
+ * 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.
+ *
+ * @version 1.0.0
+ * @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.js

@@ -0,0 +1,138 @@
+/**
+ * Coverage Analysis Processor
+ *
+ * Analyzes test coverage for modified files and reports coverage gaps.
+ *
+ * @module processors/implementations
+ * @version 1.0.0
+ */
+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.js

@@ -0,0 +1,44 @@
+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,
+            };
+        }
+    }
+}