0xray 4.0.12 → 4.0.13

package/dist/processors/implementations/agents-md-validation-processor.js

@@ -1,285 +0,0 @@
-/**
- * AGENTS.md Validation Processor
- *
- * Pre-processor that validates AGENTS.md exists and is up-to-date before
- * allowing commits. Integrates with 0xRay's processor pipeline.
- *
- * @processor_type pre
- * @priority 90 (high - runs early)
- * @blocking true (blocks commit if AGENTS.md is invalid)
- *
- * @framework 0xRay 1.3.5
- */
-import * as fs from "fs";
-import * as path from "path";
-import { frameworkLogger } from "../../core/framework-logger.js";
-import { DocWriteGuard } from "../doc-write-guard.js";
-export class AgentsMdValidationProcessor {
-    projectRoot;
-    agentsPath;
-    // Required sections that must exist in AGENTS.md (v1.7+ format)
-    REQUIRED_SECTIONS = [
-        "## Available Agents",
-        "## Available Skills",
-    ];
-    REQUIRED_AGENTS = [
-        "@architect",
-        "@security-auditor",
-        "@code-reviewer",
-        "@refactorer",
-        "@testing-lead",
-        "@bug-triage-specialist",
-        "@researcher",
-    ];
-    // Recommended sections that should exist
-    RECOMMENDED_SECTIONS = [
-        "## Codex",
-        "## CLI Commands",
-        "## Skills Registry",
-    ];
-    constructor(projectRoot = process.cwd()) {
-        this.projectRoot = projectRoot;
-        this.agentsPath = path.join(projectRoot, "AGENTS.md");
-    }
-    /**
-     * Main execution method - called by ProcessorManager
-     */
-    async execute(context) {
-        try {
-            // Only validate on write/edit operations
-            if (!["write", "edit", "multiedit"].includes(context.tool)) {
-                return {
-                    success: true,
-                    blocked: false,
-                    message: "AGENTS.md validation skipped (not a file modification)",
-                };
-            }
-            // Check if we're modifying AGENTS.md or any agent-related files
-            const isAgentRelated = this.isAgentRelatedChange(context);
-            // Validate AGENTS.md
-            const validation = await this.validateAgentsMd();
-            if (!validation.valid) {
-                await frameworkLogger.log("agents-md-validation-processor", "-agents-md-validation-failed-", "error", {
-                    errors: validation.errors,
-                    warnings: validation.warnings,
-                    filePath: this.agentsPath,
-                });
-                return {
-                    success: false,
-                    blocked: true,
-                    message: `AGENTS.md validation failed: ${validation.errors.join(", ")}`,
-                    result: validation,
-                };
-            }
-            // Log success
-            await frameworkLogger.log("agents-md-validation-processor", "-agents-md-validation-passed-", "info", {
-                warnings: validation.warnings,
-                isAgentRelated,
-            });
-            return {
-                success: true,
-                blocked: false,
-                message: validation.warnings.length > 0
-                    ? `AGENTS.md valid with ${validation.warnings.length} warnings`
-                    : "AGENTS.md validation passed",
-                result: validation,
-            };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            await frameworkLogger.log("agents-md-validation-processor", "-validation-error-", "error", { message: errorMessage });
-            return {
-                success: false,
-                blocked: true,
-                message: `AGENTS.md validation error: ${errorMessage}`,
-            };
-        }
-    }
-    /**
-     * Determine if the change is agent-related
-     */
-    isAgentRelatedChange(context) {
-        const filePath = context.args?.filePath || "";
-        const agentPatterns = [
-            "AGENTS.md",
-            "opencode.json",
-            ".opencode/agent",
-            "src/agents",
-            "docs/agent",
-        ];
-        return agentPatterns.some((pattern) => filePath.includes(pattern));
-    }
-    /**
-     * Validate AGENTS.md file
-     */
-    async validateAgentsMd() {
-        const result = {
-            valid: true,
-            errors: [],
-            warnings: [],
-            fixes: [],
-        };
-        // Check 1: File exists
-        if (!fs.existsSync(this.agentsPath)) {
-            result.valid = false;
-            result.errors.push("AGENTS.md not found in project root");
-            result.fixes = result.fixes || [];
-            result.fixes.push("Create AGENTS.md using template from docs/AGENTS_TEMPLATE.md");
-            return result;
-        }
-        const content = fs.readFileSync(this.agentsPath, "utf-8");
-        // Check 2: Not empty/minimal
-        if (content.length < 500) {
-            result.valid = false;
-            result.errors.push("AGENTS.md is too short (likely incomplete)");
-        }
-        // Check 3: Required sections
-        const missingSections = this.REQUIRED_SECTIONS.filter((section) => !content.includes(section));
-        if (missingSections.length > 0) {
-            result.valid = false;
-            result.errors.push(`Missing required sections: ${missingSections.join(", ")}`);
-        }
-        // Check 4: Required agents
-        const missingAgents = this.REQUIRED_AGENTS.filter((agent) => !content.includes(agent));
-        if (missingAgents.length > 0) {
-            result.valid = false;
-            result.errors.push(`Missing agent definitions: ${missingAgents.join(", ")}`);
-        }
-        // Check 5: Version header
-        const versionMatch = content.match(/\*\*Version\*\*:\s*(\d+\.\d+\.\d+)/);
-        if (!versionMatch) {
-            result.warnings.push("No version header found in AGENTS.md");
-        }
-        // Check 6: Date freshness
-        const dateMatch = content.match(/\*\*Updated\*\*:\s*(\d{4}-\d{2}-\d{2})/);
-        if (dateMatch && dateMatch[1]) {
-            const daysOld = this.calculateDaysOld(dateMatch[1]);
-            if (daysOld > 30) {
-                result.warnings.push(`AGENTS.md is ${daysOld} days old - consider review`);
-            }
-        }
-        else {
-            result.warnings.push("No date stamp found in AGENTS.md");
-        }
-        // Check 7: Agent count (should have active autonomous agents)
-        const agentCount = (content.match(/@\[?[a-z-]+\]?/gi) || []).length;
-        if (agentCount < 5) {
-            result.warnings.push(`Only ${agentCount} agents found - verify agents table is complete`);
-        }
-        return result;
-    }
-    /**
-     * Calculate days since date
-     */
-    calculateDaysOld(dateString) {
-        const date = new Date(dateString);
-        const now = new Date();
-        return Math.ceil((now.getTime() - date.getTime()) / (1000 * 60 * 60 * 24));
-    }
-    getPackageVersion() {
-        try {
-            const pkgPath = path.join(this.projectRoot, "package.json");
-            const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
-            return pkg.version || "0.0.0";
-        }
-        catch {
-            return "0.0.0";
-        }
-    }
-    getSectionTemplate(section) {
-        const version = this.getPackageVersion();
-        const now = new Date().toISOString().split("T")[0];
-        const templates = {
-            "## Available Agents": [
-                "",
-                "## Available Agents",
-                "",
-                "| Agent | Purpose | Invoke |",
-                "|-------|---------|--------|",
-                "| `@architect` | System design & technical decisions | `@architect design this API` |",
-                "| `@code-reviewer` | Code quality & compliance review | `@code-reviewer review this code` |",
-                "| `@architect` | System design & technical decisions | `@architect design API` |",
-                "| `@security-auditor` | Vulnerability detection | `@security-auditor scan` |",
-                "| `@code-reviewer` | Quality assessment | `@code-reviewer review PR` |",
-                "| `@refactorer` | Technical debt elimination | `@refactorer optimize code` |",
-                "| `@testing-lead` | Testing strategy | `@testing-lead plan tests` |",
-                "| `@bug-triage-specialist` | Error investigation | `@bug-triage-specialist debug error` |",
-                "| `@researcher` | Codebase exploration | `@researcher find implementation` |",
-                "",
-            ].join("\n"),
-            "## Available Skills": [
-                "",
-                "## Available Skills",
-                "",
-                "0xRay ships with 30 framework skills and provides a registry of 10 curated community sources.",
-                "",
-                "```bash",
-                "npx 0xray skill:install              # Show starter packs + available sources",
-                "npx 0xray skill:install <name>       # Install from registry",
-                "npx 0xray skill:registry list        # Show all registry sources",
-                "```",
-                "",
-            ].join("\n"),
-            "## Codex": [
-                "",
-                "## Codex",
-                "",
-                `0xRay enforces Universal Development Codex (60 terms) for systematic error prevention.`,
-                "",
-            ].join("\n"),
-            "## CLI Commands": [
-                "",
-                "## CLI Commands",
-                "",
-                "```bash",
-                "npx 0xray install       # Install and configure",
-                "npx 0xray status       # Check configuration",
-                "npx 0xray health        # Health check",
-                "npx 0xray validate      # Validate installation",
-                "```",
-                "",
-            ].join("\n"),
-        };
-        return templates[section] || `\n\n${section}\n\n*(Section added by agents-md-validation-processor — ${now})*\n`;
-    }
-    async appendMissing() {
-        try {
-            if (!fs.existsSync(this.agentsPath)) {
-                return {
-                    success: false,
-                    message: "AGENTS.md not found — cannot append to nonexistent file",
-                    added: [],
-                };
-            }
-            const content = fs.readFileSync(this.agentsPath, "utf-8");
-            const missingSections = this.REQUIRED_SECTIONS.filter((s) => !content.includes(s));
-            if (missingSections.length === 0) {
-                return {
-                    success: true,
-                    message: "All required sections present",
-                    added: [],
-                };
-            }
-            const additions = missingSections
-                .map((section) => this.getSectionTemplate(section))
-                .join("\n");
-            DocWriteGuard.append(this.agentsPath, additions);
-            await frameworkLogger.log("agents-md-validation-processor", "-agents-md-sections-appended-", "info", { added: missingSections, path: this.agentsPath });
-            return {
-                success: true,
-                message: `Appended ${missingSections.length} missing sections: ${missingSections.join(", ")}`,
-                added: missingSections,
-            };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            return {
-                success: false,
-                message: `Append failed: ${errorMessage}`,
-                added: [],
-            };
-        }
-    }
-}
-// Export singleton for processor registration
-export const agentsMdValidationProcessor = new AgentsMdValidationProcessor();

package/dist/processors/implementations/async-pattern-processor.d.ts

@@ -1,47 +0,0 @@
-/**
- * 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.
- *
- * @since 2026-03-28
- */
-import type { PreValidateContext, ProcessorExecutionResult } from "../processor-types.js";
-export type AsyncViolationType = "callbackPattern" | "longPromiseChain" | "missingAwait" | "mixedCallbackAsync";
-export interface AsyncViolation {
-    type: AsyncViolationType;
-    line?: number;
-    message: string;
-    snippet?: string;
-}
-export declare class AsyncPatternProcessor {
-    /**
-     * Run all async-pattern checks against `content`.
-     */
-    checkCode(content: string): AsyncViolation[];
-    /**
-     * Detect node-style callbacks: `function(err, ` or inline function callbacks.
-     */
-    hasCallbackPattern(content: string): boolean;
-    /**
-     * Detect promise chains with more than 3 .then() calls.
-     */
-    hasLongPromiseChain(content: string): boolean;
-    /**
-     * Detect async functions that contain .then() or `new Promise` without an
-     * accompanying await in the same scope.
-     */
-    hasMissingAwait(content: string): boolean;
-    /**
-     * Detect callbacks used inside async functions.
-     */
-    hasMixedCallbackAsync(content: string): boolean;
-    private countPromiseChains;
-    /**
-     * Within an async function body, check if .then() or new Promise is used
-     * without await. If so, return a marker string; otherwise return original.
-     */
-    private _checkAsyncBodyForMissingAwait;
-}
-export declare function runAsyncPatternCheck(context: PreValidateContext): Promise<ProcessorExecutionResult>;

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

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

@@ -1,7 +0,0 @@
-import { PreProcessor } from "../processor-interfaces.js";
-import type { ProcessorContext } from "../processor-types.js";
-export declare class CodexComplianceProcessor extends PreProcessor {
-    readonly name = "codexCompliance";
-    readonly priority = 2;
-    protected run(context: ProcessorContext): Promise<Record<string, unknown>>;
-}

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

@@ -1,57 +0,0 @@
-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.d.ts

@@ -1,13 +0,0 @@
-import { PostProcessor } from "../processor-interfaces.js";
-import type { ProcessorContext, ProcessorResult } from "../processor-types.js";
-import { IntelligentCommitBatcher } from "../../orchestrator/intelligent-commit-batcher.js";
-export declare class CommitBatcherProcessor extends PostProcessor {
-    readonly name = "commitBatcher";
-    readonly priority = 85;
-    private trackedCount;
-    private batcher;
-    constructor(batcher?: IntelligentCommitBatcher);
-    protected run(context: ProcessorContext): Promise<Record<string, unknown>>;
-    private inferChangeType;
-}
-export declare function executeCommitBatcherProcessor(context: ProcessorContext): Promise<ProcessorResult>;

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

@@ -1,71 +0,0 @@
-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.d.ts

@@ -1,32 +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 type { PreValidateContext, ProcessorExecutionResult } from "../processor-types.js";
-export interface ConsoleLogViolation {
-    line: number;
-    type: "log" | "warn" | "error" | "info" | "debug";
-    matched: string;
-}
-export declare class ConsoleLogGuardProcessor {
-    /**
-     * Scan code content for forbidden console method calls.
-     * Returns violations with line numbers.
-     */
-    checkCode(content: string, filePath?: string): ConsoleLogViolation[];
-    /**
-     * Determine if a file path points to a test file.
-     */
-    isTestFile(filePath: string): boolean;
-    /**
-     * Remove single-line (//) and multi-line comments from source code.
-     * Preserves line structure so line numbers remain valid.
-     */
-    stripComments(content: string): string;
-}
-export declare function runConsoleLogGuard(context: PreValidateContext): Promise<ProcessorExecutionResult>;