0xray 4.0.13 → 4.0.14

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

@@ -0,0 +1,285 @@
+/**
+ * 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

@@ -0,0 +1,47 @@
+/**
+ * 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

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

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

@@ -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.d.ts

@@ -0,0 +1,13 @@
+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

@@ -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.d.ts

@@ -0,0 +1,32 @@
+/**
+ * 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>;