jarvis-ai-assistant 0.3.30__py3-none-any.whl → 0.7.6__py3-none-any.whl

jarvis/jarvis_code_agent/code_analyzer/build_validator/java_maven.py

@@ -0,0 +1,47 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+Java Maven构建验证器模块
+
+提供Java Maven项目的构建验证功能。
+"""
+
+import time
+from typing import List, Optional
+
+from .base import BuildValidatorBase, BuildResult, BuildSystem
+
+
+class JavaMavenBuildValidator(BuildValidatorBase):
+    """Java Maven构建验证器"""
+    
+    BUILD_SYSTEM_NAME = "Maven"
+    SUPPORTED_LANGUAGES = ["java"]
+    
+    def validate(self, modified_files: Optional[List[str]] = None) -> BuildResult:
+        start_time = time.time()
+        
+        # 使用 mvn compile 进行编译验证
+        cmd = ["mvn", "compile", "-q"]  # -q 静默模式
+        
+        returncode, stdout, stderr = self._run_command(cmd, timeout=60)
+        duration = time.time() - start_time
+        
+        success = returncode == 0
+        output = stdout + stderr
+        
+        if success:
+            print(f"✅ Maven 构建验证成功（耗时 {duration:.2f} 秒）")
+        else:
+            print(f"❌ Maven 构建验证失败（耗时 {duration:.2f} 秒）")
+            print(f"错误信息：Maven编译失败\n{output[:500]}")
+        
+        return BuildResult(
+            success=success,
+            output=output,
+            error_message=None if success else "Maven编译失败",
+            build_system=BuildSystem.JAVA_MAVEN,
+            duration=duration,
+        )
+

jarvis/jarvis_code_agent/code_analyzer/build_validator/makefile.py

@@ -0,0 +1,61 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+Makefile构建验证器模块
+
+提供Makefile项目的构建验证功能。
+"""
+
+import os
+import time
+from typing import List, Optional
+
+from .base import BuildValidatorBase, BuildResult, BuildSystem
+
+
+class MakefileBuildValidator(BuildValidatorBase):
+    """Makefile构建验证器"""
+    
+    BUILD_SYSTEM_NAME = "Makefile"
+    SUPPORTED_LANGUAGES = ["c", "cpp"]
+    
+    def validate(self, modified_files: Optional[List[str]] = None) -> BuildResult:
+        start_time = time.time()
+        
+        # 尝试运行 make（如果存在Makefile）
+        makefile = os.path.join(self.project_root, "Makefile")
+        if not os.path.exists(makefile):
+            duration = time.time() - start_time
+            print(f"❌ Makefile 构建验证失败（耗时 {duration:.2f} 秒）")
+            print("错误信息：Makefile不存在")
+            return BuildResult(
+                success=False,
+                output="Makefile不存在",
+                error_message="Makefile不存在",
+                build_system=BuildSystem.C_MAKEFILE,
+                duration=duration,
+            )
+        
+        # 尝试 make -n（dry-run）来验证语法
+        returncode, stdout, stderr = self._run_command(
+            ["make", "-n"],
+            timeout=10,
+        )
+        duration = time.time() - start_time
+        
+        success = returncode == 0
+        output = stdout + stderr
+        if success:
+            print(f"✅ Makefile 构建验证成功（耗时 {duration:.2f} 秒）")
+        else:
+            print(f"❌ Makefile 构建验证失败（耗时 {duration:.2f} 秒）")
+            print(f"错误信息：Makefile语法检查失败\n{output[:500]}")
+        return BuildResult(
+            success=success,
+            output=output,
+            error_message=None if success else "Makefile语法检查失败",
+            build_system=BuildSystem.C_MAKEFILE,
+            duration=duration,
+        )
+

jarvis/jarvis_code_agent/code_analyzer/build_validator/nodejs.py

@@ -0,0 +1,110 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+Node.js构建验证器模块
+
+提供Node.js项目的构建验证功能。
+"""
+
+import json
+import os
+import time
+from typing import List, Optional
+
+from .base import BuildValidatorBase, BuildResult, BuildSystem
+
+
+class NodeJSBuildValidator(BuildValidatorBase):
+    """Node.js构建验证器"""
+    
+    BUILD_SYSTEM_NAME = "npm/Node.js"
+    SUPPORTED_LANGUAGES = ["javascript", "typescript"]
+    
+    def validate(self, modified_files: Optional[List[str]] = None) -> BuildResult:
+        start_time = time.time()
+        
+        # 策略1: 尝试使用 tsc --noEmit（如果存在TypeScript）
+        tsconfig = os.path.join(self.project_root, "tsconfig.json")
+        if os.path.exists(tsconfig):
+            returncode, stdout, stderr = self._run_command(
+                ["npx", "tsc", "--noEmit"],
+                timeout=20,
+            )
+            duration = time.time() - start_time
+            success = returncode == 0
+            output = stdout + stderr
+            if success:
+                print(f"✅ Node.js (TypeScript) 构建验证成功（耗时 {duration:.2f} 秒）")
+            else:
+                print(f"❌ Node.js (TypeScript) 构建验证失败（耗时 {duration:.2f} 秒）")
+                print(f"错误信息：TypeScript类型检查失败\n{output[:500]}")
+            return BuildResult(
+                success=success,
+                output=output,
+                error_message=None if success else "TypeScript类型检查失败",
+                build_system=BuildSystem.NODEJS,
+                duration=duration,
+            )
+        
+        # 策略2: 尝试运行 npm run build（如果存在build脚本）
+        package_json = os.path.join(self.project_root, "package.json")
+        if os.path.exists(package_json):
+            try:
+                with open(package_json, "r", encoding="utf-8") as f:
+                    package_data = json.load(f)
+                    scripts = package_data.get("scripts", {})
+                    if "build" in scripts:
+                        returncode, stdout, stderr = self._run_command(
+                            ["npm", "run", "build"],
+                            timeout=30,
+                        )
+                        duration = time.time() - start_time
+                        success = returncode == 0
+                        output = stdout + stderr
+                        if success:
+                            print(f"✅ Node.js (npm build) 构建验证成功（耗时 {duration:.2f} 秒）")
+                        else:
+                            print(f"❌ Node.js (npm build) 构建验证失败（耗时 {duration:.2f} 秒）")
+                            print(f"错误信息：npm build失败\n{output[:500]}")
+                        return BuildResult(
+                            success=success,
+                            output=output,
+                            error_message=None if success else "npm build失败",
+                            build_system=BuildSystem.NODEJS,
+                            duration=duration,
+                        )
+            except Exception as e:
+                print(f"⚠️ 读取package.json失败: {e}")
+        
+        # 策略3: 使用 eslint 进行语法检查（如果存在）
+        if modified_files:
+            js_files = [f for f in modified_files if f.endswith((".js", ".jsx", ".ts", ".tsx"))]
+            if js_files:
+                # 尝试使用 eslint
+                returncode, stdout, stderr = self._run_command(
+                    ["npx", "eslint", "--max-warnings=0"] + js_files[:5],  # 限制文件数量
+                    timeout=15,
+                )
+                duration = time.time() - start_time
+                output = stdout + stderr
+                # eslint返回非0可能是警告，不算失败
+                print(f"✅ Node.js (eslint) 构建验证成功（耗时 {duration:.2f} 秒）")
+                return BuildResult(
+                    success=True,  # 仅检查语法，警告不算失败
+                    output=output,
+                    error_message=None,
+                    build_system=BuildSystem.NODEJS,
+                    duration=duration,
+                )
+        
+        duration = time.time() - start_time
+        print(f"✅ Node.js 构建验证成功（耗时 {duration:.2f} 秒，无构建脚本）")
+        return BuildResult(
+            success=True,
+            output="Node.js项目验证通过（无构建脚本）",
+            error_message=None,
+            build_system=BuildSystem.NODEJS,
+            duration=duration,
+        )
+

jarvis/jarvis_code_agent/code_analyzer/build_validator/python.py

@@ -0,0 +1,154 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+Python构建验证器模块
+
+提供Python项目的构建验证功能。
+"""
+
+import os
+import time
+from typing import List, Optional
+
+from .base import BuildValidatorBase, BuildResult, BuildSystem
+
+
+class PythonBuildValidator(BuildValidatorBase):
+    """Python构建验证器（包括编译和测试）"""
+    
+    BUILD_SYSTEM_NAME = "Python"
+    SUPPORTED_LANGUAGES = ["python"]
+    
+    def _extract_python_errors(self, output: str) -> str:
+        """提取Python错误信息（包括编译错误和测试失败）"""
+        if not output:
+            return ""
+        
+        lines = output.split("\n")
+        errors = []
+        in_error = False
+        
+        for line in lines:
+            line_lower = line.lower()
+            # 检测错误关键词（包括编译错误和测试失败）
+            if any(keyword in line_lower for keyword in [
+                "error", "failed", "exception", "traceback", 
+                "syntaxerror", "indentationerror", "assertionerror",
+                "failed:", "failures:", "test", "assert"
+            ]):
+                in_error = True
+                errors.append(line.strip())
+            elif in_error and line.strip():
+                # 继续收集错误相关的行
+                if line.strip().startswith(("File", "  File", "    ", "E ", "FAILED", "FAILURES", "assert")):
+                    errors.append(line.strip())
+                elif not line.strip().startswith("="):
+                    # 如果遇到非错误相关的行，停止收集
+                    if len(errors) > 0 and not any(keyword in line_lower for keyword in ["error", "failed", "exception", "assert", "test"]):
+                        break
+        
+        # 如果收集到错误，返回前20行（限制长度）
+        if errors:
+            error_text = "\n".join(errors[:20])
+            # 如果太长，截断
+            if len(error_text) > 1000:
+                error_text = error_text[:1000] + "\n... (错误信息已截断)"
+            return error_text
+        
+        # 如果没有提取到结构化错误，返回原始输出的前500字符
+        return output[:500] if output else ""
+    
+    def validate(self, modified_files: Optional[List[str]] = None) -> BuildResult:
+        start_time = time.time()
+        
+        # 策略1: 尝试使用 py_compile 编译修改的文件
+        if modified_files:
+            errors = []
+            error_outputs = []
+            for file_path in modified_files:
+                if not file_path.endswith(".py"):
+                    continue
+                full_path = os.path.join(self.project_root, file_path)
+                if os.path.exists(full_path):
+                    returncode, stdout, stderr = self._run_command(
+                        ["python", "-m", "py_compile", full_path],
+                        timeout=5,
+                    )
+                    if returncode != 0:
+                        error_msg = f"{file_path}: {stderr}".strip()
+                        errors.append(error_msg)
+                        error_outputs.append(stdout + stderr)
+            
+            if errors:
+                duration = time.time() - start_time
+                # 合并所有错误输出
+                full_output = "\n".join(error_outputs)
+                # 提取关键错误信息
+                error_message = self._extract_python_errors(full_output)
+                if not error_message:
+                    # 如果没有提取到结构化错误，使用简化的错误列表
+                    error_message = "\n".join(errors[:5])  # 最多显示5个文件的错误
+                    if len(errors) > 5:
+                        error_message += f"\n... 还有 {len(errors) - 5} 个文件存在错误"
+                print(f"❌ Python 构建验证失败（耗时 {duration:.2f} 秒）")
+                print(f"错误信息：\n{error_message}")
+                return BuildResult(
+                    success=False,
+                    output=full_output,
+                    error_message=error_message,
+                    build_system=BuildSystem.PYTHON,
+                    duration=duration,
+                )
+        
+        # 策略2: 尝试运行 pytest（会自动编译并运行测试，即使没有配置文件也会自动发现测试）
+        # 首先尝试 pytest
+        returncode, stdout, stderr = self._run_command(
+            ["python", "-m", "pytest", "-v"],
+            timeout=30,
+        )
+        # 如果 pytest 命令本身失败（如未安装），尝试 unittest
+        if returncode == 1 and "No module named pytest" in stderr:
+            # pytest 未安装，尝试使用 unittest
+            returncode, stdout, stderr = self._run_command(
+                ["python", "-m", "unittest", "discover", "-v"],
+                timeout=30,
+            )
+        
+        duration = time.time() - start_time
+        success = returncode == 0
+        output = stdout + stderr
+        
+        # 如果失败，提取关键错误信息（包括编译错误和测试失败）
+        if not success:
+            error_msg = self._extract_python_errors(output)
+            if not error_msg:
+                # 检查是否是"没有找到测试"的情况（这不算失败）
+                if "no tests ran" in output.lower() or "no tests found" in output.lower():
+                    # 没有测试文件，但语法检查通过，视为成功
+                    print(f"✅ Python 构建验证成功（耗时 {duration:.2f} 秒，未发现测试文件）")
+                    return BuildResult(
+                        success=True,
+                        output="Python语法检查通过（未发现测试文件）",
+                        error_message=None,
+                        build_system=BuildSystem.PYTHON,
+                        duration=duration,
+                    )
+                error_msg = "Python项目验证失败（编译或测试失败）"
+            print(f"❌ Python 构建验证失败（耗时 {duration:.2f} 秒）")
+            if error_msg:
+                print(f"错误信息：\n{error_msg}")
+            else:
+                print(f"输出：\n{output[:500]}")
+        else:
+            error_msg = None
+            print(f"✅ Python 构建验证成功（耗时 {duration:.2f} 秒）")
+        
+        return BuildResult(
+            success=success,
+            output=output,
+            error_message=error_msg,
+            build_system=BuildSystem.PYTHON,
+            duration=duration,
+        )
+

jarvis/jarvis_code_agent/code_analyzer/build_validator/rust.py

@@ -0,0 +1,110 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+Rust构建验证器模块
+
+提供Rust项目的构建验证功能。
+"""
+
+import os
+import subprocess
+import time
+from typing import List, Optional
+
+from .base import BuildValidatorBase, BuildResult, BuildSystem
+
+
+class RustBuildValidator(BuildValidatorBase):
+    """Rust构建验证器（使用cargo test，包括编译和测试）"""
+    
+    BUILD_SYSTEM_NAME = "Cargo"
+    SUPPORTED_LANGUAGES = ["rust"]
+    
+    def validate(self, modified_files: Optional[List[str]] = None) -> BuildResult:
+        start_time = time.time()
+        
+        # 使用 cargo test 进行构建和测试验证（会自动编译并运行测试）
+        # 设置 RUST_BACKTRACE=1 以启用调用链回溯
+        # 设置 RUSTFLAGS="-A warnings" 以屏蔽警告，只显示错误
+        cmd = ["cargo", "test", "--", "--nocapture"]
+        
+        # 准备环境变量（继承当前环境并设置 RUST_BACKTRACE 和 RUSTFLAGS）
+        env = os.environ.copy()
+        env["RUST_BACKTRACE"] = "1"
+        # 如果已存在 RUSTFLAGS，则追加；否则新建
+        if "RUSTFLAGS" in env:
+            env["RUSTFLAGS"] = env["RUSTFLAGS"] + " -A warnings"
+        else:
+            env["RUSTFLAGS"] = "-A warnings"
+        
+        # 直接使用 subprocess.run 以支持环境变量
+        try:
+            result = subprocess.run(
+                cmd,
+                cwd=self.project_root,
+                timeout=self.timeout,
+                capture_output=True,
+                text=True,
+                encoding="utf-8",
+                errors="replace",
+                env=env,
+            )
+            returncode = result.returncode
+            stdout = result.stdout
+            stderr = result.stderr
+        except subprocess.TimeoutExpired:
+            returncode = -1
+            stdout = ""
+            stderr = f"命令执行超时（{self.timeout}秒）"
+        except FileNotFoundError:
+            returncode = -1
+            stdout = ""
+            stderr = f"命令未找到: {cmd[0]}"
+        except Exception as e:
+            returncode = -1
+            stdout = ""
+            stderr = f"执行命令时出错: {str(e)}"
+        
+        duration = time.time() - start_time
+        
+        success = returncode == 0
+        output = stdout + stderr
+        
+        if not success:
+            # 尝试解析错误信息（包括编译错误和测试失败）
+            error_message = self._parse_cargo_errors(output)
+            print(f"❌ Rust 构建验证失败（耗时 {duration:.2f} 秒）")
+            if error_message:
+                print(f"错误信息：\n{error_message}")
+            else:
+                print(f"输出：\n{output[:500]}")
+        else:
+            error_message = None
+            print(f"✅ Rust 构建验证成功（耗时 {duration:.2f} 秒）")
+        
+        return BuildResult(
+            success=success,
+            output=output,
+            error_message=error_message,
+            build_system=BuildSystem.RUST,
+            duration=duration,
+        )
+    
+    def _parse_cargo_errors(self, output: str) -> str:
+        """解析cargo的错误输出（包括编译错误和测试失败）"""
+        # 简化处理：提取关键错误信息
+        lines = output.split("\n")
+        errors = []
+        for line in lines:
+            # 匹配编译错误
+            if "error[" in line or "error:" in line.lower():
+                errors.append(line.strip())
+            # 匹配测试失败
+            elif "test" in line.lower() and ("failed" in line.lower() or "panic" in line.lower()):
+                errors.append(line.strip())
+            # 匹配断言失败
+            elif "assertion" in line.lower() and "failed" in line.lower():
+                errors.append(line.strip())
+        return "\n".join(errors[:10]) if errors else output[:500]  # 限制长度
+

jarvis/jarvis_code_agent/code_analyzer/build_validator/validator.py

@@ -0,0 +1,153 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+构建验证器主模块
+
+提供构建验证器的主类，负责协调各个语言的验证器。
+"""
+
+from typing import Dict, List, Optional
+
+
+from .base import BuildSystem, BuildValidatorBase, BuildResult
+from .detector import BuildSystemDetector
+from .rust import RustBuildValidator
+from .python import PythonBuildValidator
+from .nodejs import NodeJSBuildValidator
+from .java_maven import JavaMavenBuildValidator
+from .java_gradle import JavaGradleBuildValidator
+from .go import GoBuildValidator
+from .cmake import CMakeBuildValidator
+from .makefile import MakefileBuildValidator
+from .fallback import FallbackBuildValidator
+
+
+class BuildValidator:
+    """构建验证器主类"""
+    
+    def __init__(self, project_root: str, timeout: int = 30):
+        self.project_root = project_root
+        self.timeout = timeout
+        self.detector = BuildSystemDetector(project_root)
+        
+        # 导入配置管理器
+        from jarvis.jarvis_code_agent.build_validation_config import BuildValidationConfig
+        self.config = BuildValidationConfig(project_root)
+        
+        # 注册构建系统验证器
+        self._validators: Dict[BuildSystem, BuildValidatorBase] = {
+            BuildSystem.RUST: RustBuildValidator(project_root, timeout),
+            BuildSystem.PYTHON: PythonBuildValidator(project_root, timeout),
+            BuildSystem.NODEJS: NodeJSBuildValidator(project_root, timeout),
+            BuildSystem.JAVA_MAVEN: JavaMavenBuildValidator(project_root, timeout),
+            BuildSystem.JAVA_GRADLE: JavaGradleBuildValidator(project_root, timeout),
+            BuildSystem.GO: GoBuildValidator(project_root, timeout),
+            BuildSystem.C_CMAKE: CMakeBuildValidator(project_root, timeout),
+            BuildSystem.C_MAKEFILE: MakefileBuildValidator(project_root, timeout),
+            BuildSystem.C_MAKEFILE_CMAKE: CMakeBuildValidator(project_root, timeout),
+        }
+        
+        # 兜底验证器
+        self._fallback_validator = FallbackBuildValidator(project_root, timeout)
+    
+    def _select_build_system(self, detected_systems: List[BuildSystem]) -> Optional[BuildSystem]:
+        """让用户选择构建系统
+        
+        Args:
+            detected_systems: 检测到的所有构建系统列表
+        
+        Returns:
+            用户选择的构建系统，如果用户取消则返回None
+        """
+        if not detected_systems:
+            return None
+        
+        if len(detected_systems) == 1:
+            # 只有一个构建系统，直接返回
+            return detected_systems[0]
+        
+        # 检查配置文件中是否已有选择
+        saved_system = self.config.get_selected_build_system()
+        if saved_system:
+            try:
+                saved_enum = BuildSystem(saved_system)
+                if saved_enum in detected_systems:
+                    print(f"ℹ️ 使用配置文件中保存的构建系统: {saved_system}")
+                    return saved_enum
+            except ValueError:
+                # 配置文件中保存的构建系统无效，忽略
+                pass
+        
+        # 多个构建系统，需要用户选择
+        print("\n检测到多个构建系统，请选择要使用的构建系统：")
+        for idx, system in enumerate(detected_systems, start=1):
+            print(f"  {idx}. {system.value}")
+        print(f"  {len(detected_systems) + 1}. 取消（使用兜底验证器）")
+        
+        while True:
+            try:
+                choice = input(f"\n请选择 (1-{len(detected_systems) + 1}): ").strip()
+                choice_num = int(choice)
+                
+                if 1 <= choice_num <= len(detected_systems):
+                    selected = detected_systems[choice_num - 1]
+                    # 保存用户选择
+                    self.config.set_selected_build_system(selected.value)
+                    print(f"ℹ️ 用户选择构建系统: {selected.value}")
+                    return selected
+                elif choice_num == len(detected_systems) + 1:
+                    print("ℹ️ 用户取消选择，使用兜底验证器")
+                    return None
+                else:
+                    print(f"无效选择，请输入 1-{len(detected_systems) + 1}")
+            except ValueError:
+                print("请输入有效的数字")
+            except (KeyboardInterrupt, EOFError):
+                print("\n用户取消，使用兜底验证器")
+                return None
+    
+    def validate(self, modified_files: Optional[List[str]] = None) -> BuildResult:
+        """验证构建
+        
+        Args:
+            modified_files: 修改的文件列表（可选，用于增量验证）
+        
+        Returns:
+            BuildResult: 验证结果
+        """
+        # 检测所有可能的构建系统
+        detected_systems = self.detector.detect_all()
+        
+        if not detected_systems:
+            # 未检测到构建系统，使用兜底验证器
+            print("ℹ️ 未检测到构建系统，使用兜底验证器")
+            return self._fallback_validator.validate(modified_files)
+        
+        # 让用户选择构建系统（如果多个）
+        build_system = self._select_build_system(detected_systems)
+        
+        if build_system and build_system in self._validators:
+            validator = self._validators[build_system]
+            print(f"ℹ️ 使用构建系统: {build_system.value}, 验证器: {validator.__class__.__name__}")
+            try:
+                return validator.validate(modified_files)
+            except Exception as e:
+                print(f"⚠️ 验证器 {validator.__class__.__name__} 执行失败: {e}, 使用兜底验证器")
+                # 验证器执行失败时，使用兜底验证器
+                return self._fallback_validator.validate(modified_files)
+        else:
+            # 用户取消或未选择，使用兜底验证器
+            print("ℹ️ 使用兜底验证器")
+            return self._fallback_validator.validate(modified_files)
+    
+    def register_validator(self, build_system: BuildSystem, validator: BuildValidatorBase):
+        """注册自定义验证器（扩展点）
+        
+        Args:
+            build_system: 构建系统类型
+            validator: 验证器实例
+        """
+        self._validators[build_system] = validator
+        print(f"ℹ️ 注册自定义验证器: {build_system.value} -> {validator.__class__.__name__}")
+

jarvis/jarvis_code_agent/code_analyzer/build_validator.py

@@ -0,0 +1,43 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+构建验证模块（向后兼容导入）
+
+此文件保持向后兼容，实际实现已迁移到 build_validator 包中。
+"""
+
+# 从新模块导入所有内容，保持向后兼容
+from jarvis.jarvis_code_agent.code_analyzer.build_validator import (
+    BuildSystem,
+    BuildResult,
+    BuildValidatorBase,
+    BuildSystemDetector,
+    BuildValidator,
+    RustBuildValidator,
+    PythonBuildValidator,
+    NodeJSBuildValidator,
+    JavaMavenBuildValidator,
+    JavaGradleBuildValidator,
+    GoBuildValidator,
+    CMakeBuildValidator,
+    MakefileBuildValidator,
+    FallbackBuildValidator,
+)
+
+__all__ = [
+    "BuildSystem",
+    "BuildResult",
+    "BuildValidatorBase",
+    "BuildSystemDetector",
+    "BuildValidator",
+    "RustBuildValidator",
+    "PythonBuildValidator",
+    "NodeJSBuildValidator",
+    "JavaMavenBuildValidator",
+    "JavaGradleBuildValidator",
+    "GoBuildValidator",
+    "CMakeBuildValidator",
+    "MakefileBuildValidator",
+    "FallbackBuildValidator",
+]