distill-mcp 0.6.0-beta

package/dist/parsers/eslint.js

@@ -0,0 +1,132 @@
+/**
+ * ESLint Error Parser
+ *
+ * Parses ESLint output in various formats (default, stylish, compact).
+ */
+// Default/stylish format: /path/file.js
+//   12:5  error  'foo' is not defined  no-undef
+const ESLINT_DEFAULT_PATTERN = /^\s*(\d+):(\d+)\s+(error|warning)\s+(.+?)\s{2,}(\S+)\s*$/;
+// File header pattern
+const FILE_HEADER_PATTERN = /^([^\s].*\.(js|jsx|ts|tsx|mjs|cjs|vue|svelte))$/;
+// Compact format: /path/file.js: line 12, col 5, Error - 'foo' is not defined (no-undef)
+const ESLINT_COMPACT_PATTERN = /^(.+?):\s*line\s+(\d+),\s*col\s+(\d+),\s*(Error|Warning)\s+-\s+(.+?)\s*\((\S+)\)\s*$/;
+// Summary pattern
+const SUMMARY_PATTERN = /(\d+)\s+problems?\s*\((\d+)\s+errors?,\s*(\d+)\s+warnings?\)/;
+/**
+ * Get suggestion based on ESLint rule
+ */
+function getSuggestion(rule, message) {
+    switch (rule) {
+        case "no-undef": {
+            const undefMatch = message.match(/'(\w+)' is not defined/);
+            if (undefMatch?.[1]) {
+                return `Import or declare '${undefMatch[1]}' before using it.`;
+            }
+            break;
+        }
+        case "no-unused-vars":
+            return "Remove the unused variable or use it in your code.";
+        case "no-console":
+            return "Remove console statements or disable the rule for development.";
+        case "semi":
+            return "Add or remove semicolons consistently.";
+        case "quotes":
+            return "Use consistent quote style (single or double).";
+        case "indent":
+            return "Fix indentation to match the configured style.";
+        case "@typescript-eslint/no-explicit-any":
+            return "Replace 'any' with a more specific type.";
+        case "@typescript-eslint/no-unused-vars":
+            return "Remove the unused variable or prefix with underscore.";
+        case "react-hooks/rules-of-hooks":
+            return "Hooks can only be called at the top level of a function component.";
+        case "react-hooks/exhaustive-deps":
+            return "Add missing dependencies to the dependency array.";
+        case "import/no-unresolved":
+            return "Check if the module exists and is properly installed.";
+    }
+    return undefined;
+}
+/**
+ * Create error signature for grouping
+ */
+function createSignature(rule, message) {
+    const normalizedMessage = message
+        .replace(/'[^']+'/g, "'X'")
+        .replace(/"[^"]+"/g, '"X"')
+        .replace(/\d+/g, "N")
+        .replace(/\s+/g, " ")
+        .trim();
+    return `${rule}:${normalizedMessage}`;
+}
+export const eslintParser = {
+    name: "eslint",
+    supportedTools: ["eslint"],
+    canParse(output) {
+        return (ESLINT_DEFAULT_PATTERN.test(output) ||
+            ESLINT_COMPACT_PATTERN.test(output) ||
+            SUMMARY_PATTERN.test(output) ||
+            (output.includes("error") && output.includes("warning") && /\d+:\d+/.test(output)));
+    },
+    parse(output) {
+        const errors = [];
+        const lines = output.split("\n");
+        let currentFile = "";
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            // Check for file header
+            const fileMatch = line.match(FILE_HEADER_PATTERN);
+            if (fileMatch?.[1]) {
+                currentFile = fileMatch[1];
+                continue;
+            }
+            // Try default/stylish format
+            const defaultMatch = trimmed.match(ESLINT_DEFAULT_PATTERN);
+            if (defaultMatch && currentFile) {
+                const lineNum = defaultMatch[1] ?? "0";
+                const colNum = defaultMatch[2] ?? "0";
+                const severityStr = defaultMatch[3] ?? "error";
+                const message = defaultMatch[4] ?? "Unknown error";
+                const rule = defaultMatch[5] ?? "unknown-rule";
+                const severity = severityStr === "warning" ? "warning" : "error";
+                errors.push({
+                    signature: createSignature(rule, message),
+                    code: rule,
+                    message,
+                    file: currentFile,
+                    line: parseInt(lineNum, 10),
+                    column: parseInt(colNum, 10),
+                    severity,
+                    raw: `${currentFile}: ${trimmed}`,
+                    context: getSuggestion(rule, message),
+                });
+                continue;
+            }
+            // Try compact format
+            const compactMatch = trimmed.match(ESLINT_COMPACT_PATTERN);
+            if (compactMatch) {
+                const file = compactMatch[1] ?? "unknown";
+                const lineNum = compactMatch[2] ?? "0";
+                const colNum = compactMatch[3] ?? "0";
+                const severityStr = compactMatch[4] ?? "Error";
+                const message = compactMatch[5] ?? "Unknown error";
+                const rule = compactMatch[6] ?? "unknown-rule";
+                const severity = severityStr.toLowerCase() === "warning" ? "warning" : "error";
+                errors.push({
+                    signature: createSignature(rule, message),
+                    code: rule,
+                    message,
+                    file,
+                    line: parseInt(lineNum, 10),
+                    column: parseInt(colNum, 10),
+                    severity,
+                    raw: trimmed,
+                    context: getSuggestion(rule, message),
+                });
+            }
+        }
+        return errors;
+    },
+};

package/dist/parsers/generic.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Generic Build Error Parser
+ *
+ * Handles various build tools: Webpack, Vite, esbuild, Rust, Go, etc.
+ */
+import type { BuildParser } from "./types.js";
+export declare const genericParser: BuildParser;
+//# sourceMappingURL=generic.d.ts.map

package/dist/parsers/generic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generic.d.ts","sourceRoot":"","sources":["../../src/parsers/generic.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAoC,MAAM,YAAY,CAAC;AAkPhF,eAAO,MAAM,aAAa,EAAE,WAwB3B,CAAC"}

package/dist/parsers/generic.js

@@ -0,0 +1,234 @@
+/**
+ * Generic Build Error Parser
+ *
+ * Handles various build tools: Webpack, Vite, esbuild, Rust, Go, etc.
+ */
+// Webpack error patterns
+const WEBPACK_ERROR_PATTERN = /^ERROR in (.+?)(?::(\d+):(\d+))?$/;
+const WEBPACK_MODULE_ERROR = /Module (?:build )?failed.+?:\s*(.+)/;
+// Rust/Cargo error patterns
+const RUST_ERROR_PATTERN = /^error\[E(\d+)\]: (.+)/;
+const RUST_LOCATION_PATTERN = /^\s+--> (.+?):(\d+):(\d+)/;
+// Go error patterns
+const GO_ERROR_PATTERN = /^(.+?):(\d+):(\d+):\s*(.+)/;
+// Generic error/warning patterns (fallback)
+const GENERIC_ERROR_LINE = /^(?:error|Error|ERROR)(?:\[([^\]]+)\])?[:\s]+(.+)/i;
+const GENERIC_WARNING_LINE = /^(?:warning|Warning|WARNING)(?:\[([^\]]+)\])?[:\s]+(.+)/i;
+const GENERIC_LOCATION = /^(?:\s*(?:at|in|-->)\s+)?(.+?):(\d+)(?::(\d+))?/;
+/**
+ * Detect build tool from output
+ */
+function detectToolFromOutput(output) {
+    if (output.includes("ERROR in") || output.includes("webpack")) {
+        return "webpack";
+    }
+    if (output.includes("[vite]") || output.includes("vite")) {
+        return "vite";
+    }
+    if (output.includes("✘ [ERROR]") || output.includes("esbuild")) {
+        return "esbuild";
+    }
+    if (output.includes("error[E") || output.includes("cargo") || output.includes("rustc")) {
+        return "rust";
+    }
+    if (GO_ERROR_PATTERN.test(output)) {
+        return "go";
+    }
+    return "generic";
+}
+/**
+ * Create signature from code and message
+ */
+function createSignature(code, message) {
+    const normalizedMessage = message
+        .replace(/'[^']+'/g, "'X'")
+        .replace(/"[^"]+"/g, '"X"')
+        .replace(/`[^`]+`/g, "`X`")
+        .replace(/\d+/g, "N")
+        .replace(/\s+/g, " ")
+        .slice(0, 100)
+        .trim();
+    return `${code}:${normalizedMessage}`;
+}
+/**
+ * Parse Webpack output
+ */
+function parseWebpack(output) {
+    const errors = [];
+    const lines = output.split("\n");
+    let currentError = null;
+    for (const line of lines) {
+        const errorMatch = line.match(WEBPACK_ERROR_PATTERN);
+        if (errorMatch) {
+            if (currentError?.message) {
+                errors.push(currentError);
+            }
+            const file = errorMatch[1] ?? "unknown";
+            const lineNum = errorMatch[2] ?? "0";
+            const colNum = errorMatch[3] ?? "0";
+            currentError = {
+                file,
+                line: parseInt(lineNum, 10),
+                column: parseInt(colNum, 10),
+                severity: "error",
+                code: "WEBPACK",
+                message: "",
+                raw: line,
+                signature: "",
+            };
+            continue;
+        }
+        const moduleError = line.match(WEBPACK_MODULE_ERROR);
+        if (moduleError?.[1] && currentError) {
+            currentError.message = moduleError[1];
+            currentError.signature = createSignature("WEBPACK", moduleError[1]);
+        }
+    }
+    if (currentError?.message) {
+        errors.push(currentError);
+    }
+    return errors;
+}
+/**
+ * Parse Rust/Cargo output
+ */
+function parseRust(output) {
+    const errors = [];
+    const lines = output.split("\n");
+    let currentError = null;
+    for (const line of lines) {
+        const errorMatch = line.match(RUST_ERROR_PATTERN);
+        if (errorMatch) {
+            if (currentError?.message) {
+                errors.push(currentError);
+            }
+            const code = `E${errorMatch[1] ?? "0000"}`;
+            const message = errorMatch[2] ?? "Unknown error";
+            currentError = {
+                code,
+                message,
+                severity: "error",
+                file: "unknown",
+                line: 0,
+                column: 0,
+                raw: line,
+                signature: createSignature(code, message),
+            };
+            continue;
+        }
+        const locationMatch = line.match(RUST_LOCATION_PATTERN);
+        if (locationMatch && currentError) {
+            currentError.file = locationMatch[1] ?? "unknown";
+            currentError.line = parseInt(locationMatch[2] ?? "0", 10);
+            currentError.column = parseInt(locationMatch[3] ?? "0", 10);
+        }
+    }
+    if (currentError?.message) {
+        errors.push(currentError);
+    }
+    return errors;
+}
+/**
+ * Parse Go output
+ */
+function parseGo(output) {
+    const errors = [];
+    const lines = output.split("\n");
+    for (const line of lines) {
+        const match = line.match(GO_ERROR_PATTERN);
+        if (match) {
+            const file = match[1] ?? "unknown";
+            const lineNum = match[2] ?? "0";
+            const colNum = match[3] ?? "0";
+            const message = match[4] ?? "Unknown error";
+            errors.push({
+                signature: createSignature("GO", message),
+                code: "GO",
+                message,
+                file,
+                line: parseInt(lineNum, 10),
+                column: parseInt(colNum, 10),
+                severity: "error",
+                raw: line,
+            });
+        }
+    }
+    return errors;
+}
+/**
+ * Parse generic output (fallback)
+ */
+function parseGeneric(output) {
+    const errors = [];
+    const lines = output.split("\n");
+    let lastLocation = null;
+    for (const line of lines) {
+        // Check for location
+        const locationMatch = line.match(GENERIC_LOCATION);
+        if (locationMatch) {
+            lastLocation = {
+                file: locationMatch[1] ?? "unknown",
+                line: parseInt(locationMatch[2] ?? "0", 10),
+                column: locationMatch[3] ? parseInt(locationMatch[3], 10) : 0,
+            };
+        }
+        // Check for error
+        const errorMatch = line.match(GENERIC_ERROR_LINE);
+        if (errorMatch) {
+            const code = errorMatch[1] ?? "ERROR";
+            const message = errorMatch[2] ?? "Unknown error";
+            errors.push({
+                signature: createSignature(code, message),
+                code,
+                message,
+                file: lastLocation?.file ?? "unknown",
+                line: lastLocation?.line ?? 0,
+                column: lastLocation?.column ?? 0,
+                severity: "error",
+                raw: line,
+            });
+            lastLocation = null;
+            continue;
+        }
+        // Check for warning
+        const warningMatch = line.match(GENERIC_WARNING_LINE);
+        if (warningMatch) {
+            const code = warningMatch[1] ?? "WARNING";
+            const message = warningMatch[2] ?? "Unknown warning";
+            errors.push({
+                signature: createSignature(code, message),
+                code,
+                message,
+                file: lastLocation?.file ?? "unknown",
+                line: lastLocation?.line ?? 0,
+                column: lastLocation?.column ?? 0,
+                severity: "warning",
+                raw: line,
+            });
+            lastLocation = null;
+        }
+    }
+    return errors;
+}
+export const genericParser = {
+    name: "generic",
+    supportedTools: ["webpack", "vite", "esbuild", "rust", "go", "generic"],
+    canParse(_output) {
+        return true;
+    },
+    parse(output) {
+        const tool = detectToolFromOutput(output);
+        switch (tool) {
+            case "webpack":
+            case "vite":
+            case "esbuild":
+                return parseWebpack(output);
+            case "rust":
+                return parseRust(output);
+            case "go":
+                return parseGo(output);
+            default:
+                return parseGeneric(output);
+        }
+    },
+};

package/dist/parsers/index.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Build Output Parsers
+ *
+ * Auto-detection and routing for various build tool outputs.
+ */
+import type { ParsedError, ErrorGroup, BuildAnalysisResult, BuildTool } from "./types.js";
+export * from "./types.js";
+/**
+ * Detect the build tool from output
+ */
+export declare function detectBuildTool(output: string): BuildTool;
+/**
+ * Parse build output using the appropriate parser
+ */
+export declare function parseOutput(output: string): {
+    tool: BuildTool;
+    errors: ParsedError[];
+};
+/**
+ * Group errors by signature
+ */
+export declare function groupErrors(errors: ParsedError[]): ErrorGroup[];
+/**
+ * Generate a compressed summary from error groups
+ */
+export declare function generateSummary(groups: ErrorGroup[], buildTool: BuildTool, verbosity?: "minimal" | "normal" | "detailed"): string;
+/**
+ * Analyze build output and return compressed result
+ */
+export declare function analyzeBuildOutput(output: string, options?: {
+    buildTool?: BuildTool;
+    verbosity?: "minimal" | "normal" | "detailed";
+}): BuildAnalysisResult;
+//# sourceMappingURL=index.d.ts.map

package/dist/parsers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/parsers/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,KAAK,EAAe,WAAW,EAAE,UAAU,EAAE,mBAAmB,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAKvG,cAAc,YAAY,CAAC;AAe3B;;GAEG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAwCzD;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,MAAM,EAAE,WAAW,EAAE,CAAA;CAAE,CAYtF;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,WAAW,EAAE,GAAG,UAAU,EAAE,CAmC/D;AAED;;GAEG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,UAAU,EAAE,EACpB,SAAS,EAAE,SAAS,EACpB,SAAS,GAAE,SAAS,GAAG,QAAQ,GAAG,UAAqB,GACtD,MAAM,CA+FR;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,MAAM,EACd,OAAO,GAAE;IACP,SAAS,CAAC,EAAE,SAAS,CAAC;IACtB,SAAS,CAAC,EAAE,SAAS,GAAG,QAAQ,GAAG,UAAU,CAAC;CAC1C,GACL,mBAAmB,CAoCrB"}

package/dist/parsers/index.js

@@ -0,0 +1,216 @@
+/**
+ * Build Output Parsers
+ *
+ * Auto-detection and routing for various build tool outputs.
+ */
+import { encodingForModel } from "js-tiktoken";
+import { typescriptParser } from "./typescript.js";
+import { eslintParser } from "./eslint.js";
+import { genericParser } from "./generic.js";
+export * from "./types.js";
+// All available parsers (order matters for detection priority)
+const parsers = [typescriptParser, eslintParser, genericParser];
+// Token encoder
+const encoding = encodingForModel("gpt-4");
+/**
+ * Count tokens in a string
+ */
+function countTokens(text) {
+    return encoding.encode(text).length;
+}
+/**
+ * Detect the build tool from output
+ */
+export function detectBuildTool(output) {
+    // TypeScript
+    if (output.includes("error TS") || output.includes("warning TS")) {
+        return "tsc";
+    }
+    // ESLint
+    if ((output.includes("error") && output.includes("warning") && /\d+:\d+/.test(output)) ||
+        output.includes("eslint")) {
+        return "eslint";
+    }
+    // Webpack
+    if (output.includes("ERROR in") || output.includes("webpack")) {
+        return "webpack";
+    }
+    // Vite
+    if (output.includes("[vite]")) {
+        return "vite";
+    }
+    // esbuild
+    if (output.includes("✘ [ERROR]")) {
+        return "esbuild";
+    }
+    // Rust
+    if (output.includes("error[E") || output.includes("rustc")) {
+        return "rust";
+    }
+    // Go
+    if (/\.go:\d+:\d+:/.test(output)) {
+        return "go";
+    }
+    return "generic";
+}
+/**
+ * Parse build output using the appropriate parser
+ */
+export function parseOutput(output) {
+    const tool = detectBuildTool(output);
+    // Find the best parser
+    for (const parser of parsers) {
+        if (parser.canParse(output)) {
+            return { tool, errors: parser.parse(output) };
+        }
+    }
+    // Fallback to generic
+    return { tool, errors: genericParser.parse(output) };
+}
+/**
+ * Group errors by signature
+ */
+export function groupErrors(errors) {
+    const groups = new Map();
+    for (const error of errors) {
+        const existing = groups.get(error.signature);
+        if (existing) {
+            existing.count++;
+            if (!existing.affectedFiles.includes(error.file)) {
+                existing.affectedFiles.push(error.file);
+            }
+            if (existing.samples.length < 3) {
+                existing.samples.push(error.raw);
+            }
+        }
+        else {
+            groups.set(error.signature, {
+                signature: error.signature,
+                code: error.code,
+                message: error.message,
+                severity: error.severity,
+                count: 1,
+                firstOccurrence: {
+                    file: error.file,
+                    line: error.line,
+                    column: error.column,
+                },
+                affectedFiles: [error.file],
+                samples: [error.raw],
+                suggestion: error.context,
+            });
+        }
+    }
+    // Sort by count (most frequent first)
+    return Array.from(groups.values()).sort((a, b) => b.count - a.count);
+}
+/**
+ * Generate a compressed summary from error groups
+ */
+export function generateSummary(groups, buildTool, verbosity = "normal") {
+    const errorGroups = groups.filter((g) => g.severity === "error");
+    const warningGroups = groups.filter((g) => g.severity === "warning");
+    const totalErrors = errorGroups.reduce((sum, g) => sum + g.count, 0);
+    const totalWarnings = warningGroups.reduce((sum, g) => sum + g.count, 0);
+    const parts = [];
+    // Header
+    if (totalErrors > 0) {
+        parts.push(`**Build failed** with ${totalErrors} error${totalErrors > 1 ? "s" : ""} (${errorGroups.length} unique type${errorGroups.length > 1 ? "s" : ""})${totalWarnings > 0 ? ` and ${totalWarnings} warning${totalWarnings > 1 ? "s" : ""}` : ""}`);
+    }
+    else if (totalWarnings > 0) {
+        parts.push(`**Build succeeded** with ${totalWarnings} warning${totalWarnings > 1 ? "s" : ""} (${warningGroups.length} unique type${warningGroups.length > 1 ? "s" : ""})`);
+    }
+    else {
+        parts.push("**Build succeeded** with no errors or warnings.");
+        return parts.join("\n");
+    }
+    parts.push("");
+    // Error groups
+    if (errorGroups.length > 0) {
+        parts.push("### Errors\n");
+        const maxGroups = verbosity === "minimal" ? 3 : verbosity === "normal" ? 5 : 10;
+        const displayGroups = errorGroups.slice(0, maxGroups);
+        for (let i = 0; i < displayGroups.length; i++) {
+            const group = displayGroups[i];
+            if (!group)
+                continue;
+            parts.push(`**${i + 1}. ${group.code}**: ${group.message}`);
+            parts.push(`   - Occurrences: ${group.count}`);
+            parts.push(`   - First: \`${group.firstOccurrence.file}:${group.firstOccurrence.line}\``);
+            if (group.affectedFiles.length > 1) {
+                const fileList = group.affectedFiles.length <= 3
+                    ? group.affectedFiles.join(", ")
+                    : `${group.affectedFiles.slice(0, 3).join(", ")}, +${group.affectedFiles.length - 3} more`;
+                parts.push(`   - Files: ${fileList}`);
+            }
+            if (group.suggestion && verbosity !== "minimal") {
+                parts.push(`   - 💡 ${group.suggestion}`);
+            }
+            parts.push("");
+        }
+        if (errorGroups.length > maxGroups) {
+            parts.push(`*...and ${errorGroups.length - maxGroups} more error types*\n`);
+        }
+    }
+    // Warning groups (only in normal/detailed)
+    if (warningGroups.length > 0 && verbosity !== "minimal") {
+        parts.push("### Warnings\n");
+        const maxWarnings = verbosity === "normal" ? 3 : 5;
+        const displayWarnings = warningGroups.slice(0, maxWarnings);
+        for (const group of displayWarnings) {
+            parts.push(`- **${group.code}**: ${group.message} (${group.count}x)`);
+        }
+        if (warningGroups.length > maxWarnings) {
+            parts.push(`- *...and ${warningGroups.length - maxWarnings} more warning types*`);
+        }
+        parts.push("");
+    }
+    // Quick fix suggestion
+    if (errorGroups.length > 0 && errorGroups.length <= 3) {
+        const suggestions = errorGroups
+            .filter((g) => g.suggestion)
+            .map((g) => g.suggestion)
+            .slice(0, 2);
+        if (suggestions.length > 0) {
+            parts.push("### Quick Fix");
+            parts.push(suggestions.join(" "));
+            parts.push("");
+        }
+    }
+    parts.push(`*Analyzed by CtxOpt (${buildTool})*`);
+    return parts.join("\n");
+}
+/**
+ * Analyze build output and return compressed result
+ */
+export function analyzeBuildOutput(output, options = {}) {
+    const tokensOriginal = countTokens(output);
+    // Parse output
+    const { tool, errors } = parseOutput(output);
+    const buildTool = options.buildTool || tool;
+    // Group errors
+    const allGroups = groupErrors(errors);
+    const errorGroups = allGroups.filter((g) => g.severity === "error");
+    const warningGroups = allGroups.filter((g) => g.severity === "warning");
+    // Generate summary
+    const summary = generateSummary(allGroups, buildTool, options.verbosity || "normal");
+    const tokensCompressed = countTokens(summary);
+    const totalErrors = errorGroups.reduce((sum, g) => sum + g.count, 0);
+    const totalWarnings = warningGroups.reduce((sum, g) => sum + g.count, 0);
+    return {
+        buildTool,
+        success: totalErrors === 0,
+        summary,
+        stats: {
+            totalErrors,
+            totalWarnings,
+            uniqueErrorTypes: errorGroups.length,
+            uniqueWarningTypes: warningGroups.length,
+            tokensOriginal,
+            tokensCompressed,
+            reductionPercent: tokensOriginal > 0 ? Math.round((1 - tokensCompressed / tokensOriginal) * 100) : 0,
+        },
+        errorGroups,
+        warningGroups,
+    };
+}