jarvis-ai-assistant 0.7.0__py3-none-any.whl → 0.7.8__py3-none-any.whl

jarvis/jarvis_code_agent/code_analyzer/__init__.py

@@ -22,6 +22,7 @@ from .impact_analyzer import (
     TestDiscoverer,
     parse_git_diff_to_edits,
 )
+from .structured_code import StructuredCodeExtractor
 
 __all__ = [
     # Symbol extraction
@@ -58,5 +59,7 @@ __all__ = [
     'Edit',
     'TestDiscoverer',
     'parse_git_diff_to_edits',
+    # Structured code extraction
+    'StructuredCodeExtractor',
 ]
 

jarvis/jarvis_code_agent/code_analyzer/build_validator/base.py

@@ -41,6 +41,10 @@ class BuildResult:
 class BuildValidatorBase(ABC):
     """构建验证器基类"""
     
+    # 子类需要定义的类变量
+    BUILD_SYSTEM_NAME: str = ""  # 构建系统名称，如 "CMake", "Makefile", "Cargo"
+    SUPPORTED_LANGUAGES: List[str] = []  # 支持的语言列表，如 ["c", "cpp"]
+    
     def __init__(self, project_root: str, timeout: int = 30):
         self.project_root = project_root
         self.timeout = timeout

jarvis/jarvis_code_agent/code_analyzer/build_validator/cmake.py

@@ -18,6 +18,9 @@ from .base import BuildValidatorBase, BuildResult, BuildSystem
 class CMakeBuildValidator(BuildValidatorBase):
     """CMake构建验证器"""
     
+    BUILD_SYSTEM_NAME = "CMake"
+    SUPPORTED_LANGUAGES = ["c", "cpp"]
+    
     def validate(self, modified_files: Optional[List[str]] = None) -> BuildResult:
         start_time = time.time()
         
@@ -32,9 +35,15 @@ class CMakeBuildValidator(BuildValidatorBase):
                 )
                 duration = time.time() - start_time
                 success = returncode == 0
+                output = stdout + stderr
+                if success:
+                    print(f"✅ CMake 构建验证成功（耗时 {duration:.2f} 秒）")
+                else:
+                    print(f"❌ CMake 构建验证失败（耗时 {duration:.2f} 秒）")
+                    print(f"错误信息：CMake构建失败\n{output[:500]}")
                 return BuildResult(
                     success=success,
-                    output=stdout + stderr,
+                    output=output,
                     error_message=None if success else "CMake构建失败",
                     build_system=BuildSystem.C_CMAKE,
                     duration=duration,
@@ -49,9 +58,15 @@ class CMakeBuildValidator(BuildValidatorBase):
         duration = time.time() - start_time
         
         success = returncode == 0
+        output = stdout + stderr
+        if success:
+            print(f"✅ CMake 配置验证成功（耗时 {duration:.2f} 秒）")
+        else:
+            print(f"❌ CMake 配置验证失败（耗时 {duration:.2f} 秒）")
+            print(f"错误信息：CMake配置失败\n{output[:500]}")
         return BuildResult(
             success=success,
-            output=stdout + stderr,
+            output=output,
             error_message=None if success else "CMake配置失败",
             build_system=BuildSystem.C_CMAKE,
             duration=duration,

jarvis/jarvis_code_agent/code_analyzer/build_validator/fallback.py

@@ -50,6 +50,8 @@ class FallbackBuildValidator(BuildValidatorBase):
             
             if errors:
                 duration = time.time() - start_time
+                print(f"❌ 基础语法检查失败（耗时 {duration:.2f} 秒）")
+                print(f"错误信息：语法检查失败\n{chr(10).join(errors[:5])}")
                 return BuildResult(
                     success=False,
                     output="\n".join(errors),
@@ -59,6 +61,7 @@ class FallbackBuildValidator(BuildValidatorBase):
                 )
         
         duration = time.time() - start_time
+        print(f"✅ 基础语法检查通过（耗时 {duration:.2f} 秒，未检测到构建系统）")
         return BuildResult(
             success=True,
             output="基础语法检查通过（未检测到构建系统）",

jarvis/jarvis_code_agent/code_analyzer/build_validator/go.py

@@ -14,13 +14,16 @@ from .base import BuildValidatorBase, BuildResult, BuildSystem
 
 
 class GoBuildValidator(BuildValidatorBase):
-    """Go构建验证器"""
+    """Go构建验证器（使用go test，包括编译和测试）"""
+    
+    BUILD_SYSTEM_NAME = "Go Build"
+    SUPPORTED_LANGUAGES = ["go"]
     
     def validate(self, modified_files: Optional[List[str]] = None) -> BuildResult:
         start_time = time.time()
         
-        # 使用 go build 进行构建验证
-        cmd = ["go", "build", "./..."]
+        # 使用 go test 进行构建和测试验证（会自动编译并运行测试）
+        cmd = ["go", "test", "./..."]
         
         returncode, stdout, stderr = self._run_command(cmd, timeout=30)
         duration = time.time() - start_time
@@ -28,11 +31,40 @@ class GoBuildValidator(BuildValidatorBase):
         success = returncode == 0
         output = stdout + stderr
         
+        if not success:
+            # 尝试解析错误信息（包括编译错误和测试失败）
+            error_message = self._parse_go_errors(output)
+            print(f"❌ Go 构建验证失败（耗时 {duration:.2f} 秒）")
+            if error_message:
+                print(f"错误信息：\n{error_message}")
+            else:
+                print(f"输出：\n{output[:500]}")
+        else:
+            error_message = None
+            print(f"✅ Go 构建验证成功（耗时 {duration:.2f} 秒）")
+        
         return BuildResult(
             success=success,
             output=output,
-            error_message=None if success else "Go构建失败",
+            error_message=error_message,
             build_system=BuildSystem.GO,
             duration=duration,
         )
+    
+    def _parse_go_errors(self, output: str) -> str:
+        """解析Go的错误输出（包括编译错误和测试失败）"""
+        # 简化处理：提取关键错误信息
+        lines = output.split("\n")
+        errors = []
+        for line in lines:
+            # 匹配编译错误
+            if "error:" in line.lower() or "cannot" in line.lower():
+                errors.append(line.strip())
+            # 匹配测试失败
+            elif "--- FAIL:" in line or "FAIL" in line:
+                errors.append(line.strip())
+            # 匹配断言失败
+            elif "got" in line.lower() and "want" 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/java_gradle.py

@@ -17,6 +17,9 @@ from .base import BuildValidatorBase, BuildResult, BuildSystem
 class JavaGradleBuildValidator(BuildValidatorBase):
     """Java Gradle构建验证器"""
     
+    BUILD_SYSTEM_NAME = "Gradle"
+    SUPPORTED_LANGUAGES = ["java"]
+    
     def validate(self, modified_files: Optional[List[str]] = None) -> BuildResult:
         start_time = time.time()
         
@@ -34,6 +37,12 @@ class JavaGradleBuildValidator(BuildValidatorBase):
         success = returncode == 0
         output = stdout + stderr
         
+        if success:
+            print(f"✅ Gradle 构建验证成功（耗时 {duration:.2f} 秒）")
+        else:
+            print(f"❌ Gradle 构建验证失败（耗时 {duration:.2f} 秒）")
+            print(f"错误信息：Gradle编译失败\n{output[:500]}")
+        
         return BuildResult(
             success=success,
             output=output,

jarvis/jarvis_code_agent/code_analyzer/build_validator/java_maven.py

@@ -16,6 +16,9 @@ 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()
         
@@ -28,6 +31,12 @@ class JavaMavenBuildValidator(BuildValidatorBase):
         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,

jarvis/jarvis_code_agent/code_analyzer/build_validator/makefile.py

@@ -17,6 +17,9 @@ 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()
         
@@ -24,6 +27,8 @@ class MakefileBuildValidator(BuildValidatorBase):
         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不存在",
@@ -40,9 +45,15 @@ class MakefileBuildValidator(BuildValidatorBase):
         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=stdout + stderr,
+            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

@@ -12,13 +12,15 @@ import os
 import time
 from typing import List, Optional
 
-from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 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()
         
@@ -31,9 +33,15 @@ class NodeJSBuildValidator(BuildValidatorBase):
             )
             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=stdout + stderr,
+                output=output,
                 error_message=None if success else "TypeScript类型检查失败",
                 build_system=BuildSystem.NODEJS,
                 duration=duration,
@@ -53,15 +61,21 @@ class NodeJSBuildValidator(BuildValidatorBase):
                         )
                         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=stdout + stderr,
+                            output=output,
                             error_message=None if success else "npm build失败",
                             build_system=BuildSystem.NODEJS,
                             duration=duration,
                         )
             except Exception as e:
-                PrettyOutput.print(f"读取package.json失败: {e}", OutputType.WARNING)
+                print(f"⚠️ 读取package.json失败: {e}")
         
         # 策略3: 使用 eslint 进行语法检查（如果存在）
         if modified_files:
@@ -73,16 +87,19 @@ class NodeJSBuildValidator(BuildValidatorBase):
                     timeout=15,
                 )
                 duration = time.time() - start_time
+                output = stdout + stderr
                 # eslint返回非0可能是警告，不算失败
+                print(f"✅ Node.js (eslint) 构建验证成功（耗时 {duration:.2f} 秒）")
                 return BuildResult(
                     success=True,  # 仅检查语法，警告不算失败
-                    output=stdout + stderr,
+                    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项目验证通过（无构建脚本）",

jarvis/jarvis_code_agent/code_analyzer/build_validator/python.py

@@ -15,10 +15,13 @@ from .base import BuildValidatorBase, BuildResult, BuildSystem
 
 
 class PythonBuildValidator(BuildValidatorBase):
-    """Python构建验证器"""
+    """Python构建验证器（包括编译和测试）"""
+    
+    BUILD_SYSTEM_NAME = "Python"
+    SUPPORTED_LANGUAGES = ["python"]
     
     def _extract_python_errors(self, output: str) -> str:
-        """提取Python错误信息"""
+        """提取Python错误信息（包括编译错误和测试失败）"""
         if not output:
             return ""
         
@@ -28,17 +31,21 @@ class PythonBuildValidator(BuildValidatorBase):
         
         for line in lines:
             line_lower = line.lower()
-            # 检测错误关键词
-            if any(keyword in line_lower for keyword in ["error", "failed", "exception", "traceback", "syntaxerror", "indentationerror"]):
+            # 检测错误关键词（包括编译错误和测试失败）
+            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")):
+                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"]):
+                    if len(errors) > 0 and not any(keyword in line_lower for keyword in ["error", "failed", "exception", "assert", "test"]):
                         break
         
         # 如果收集到错误，返回前20行（限制长度）
@@ -84,6 +91,8 @@ class PythonBuildValidator(BuildValidatorBase):
                     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,
@@ -92,37 +101,53 @@ class PythonBuildValidator(BuildValidatorBase):
                     duration=duration,
                 )
         
-        # 策略2: 尝试运行 pytest --collect-only（如果存在）
-        if os.path.exists(os.path.join(self.project_root, "pytest.ini")) or \
-           os.path.exists(os.path.join(self.project_root, "setup.py")):
+        # 策略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", "pytest", "--collect-only", "-q"],
-                timeout=10,
-            )
-            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:
-                    error_msg = "Python项目验证失败"
-            else:
-                error_msg = None
-            return BuildResult(
-                success=success,
-                output=output,
-                error_message=error_msg,
-                build_system=BuildSystem.PYTHON,
-                duration=duration,
+                ["python", "-m", "unittest", "discover", "-v"],
+                timeout=30,
             )
         
-        # 策略3: 如果没有测试框架，仅验证语法（已在上面的策略1中完成）
         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=True,
-            output="Python语法检查通过",
-            error_message=None,
+            success=success,
+            output=output,
+            error_message=error_msg,
             build_system=BuildSystem.PYTHON,
             duration=duration,
         )

jarvis/jarvis_code_agent/code_analyzer/build_validator/rust.py

@@ -7,6 +7,8 @@ Rust构建验证器模块
 提供Rust项目的构建验证功能。
 """
 
+import os
+import subprocess
 import time
 from typing import List, Optional
 
@@ -14,25 +16,72 @@ from .base import BuildValidatorBase, BuildResult, BuildSystem
 
 
 class RustBuildValidator(BuildValidatorBase):
-    """Rust构建验证器（使用cargo check）"""
+    """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 check 进行增量检查（比 cargo build 更快）
-        cmd = ["cargo", "check", "--message-format=json"]
+        # 使用 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)}"
         
-        returncode, stdout, stderr = self._run_command(cmd)
         duration = time.time() - start_time
         
         success = returncode == 0
         output = stdout + stderr
         
         if not success:
-            # 尝试解析JSON格式的错误信息
+            # 尝试解析错误信息（包括编译错误和测试失败）
             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,
@@ -43,12 +92,19 @@ class RustBuildValidator(BuildValidatorBase):
         )
     
     def _parse_cargo_errors(self, output: str) -> str:
-        """解析cargo的错误输出"""
+        """解析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

@@ -9,7 +9,6 @@
 
 from typing import Dict, List, Optional
 
-from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 
 from .base import BuildSystem, BuildValidatorBase, BuildResult
 from .detector import BuildSystemDetector
@@ -74,7 +73,7 @@ class BuildValidator:
             try:
                 saved_enum = BuildSystem(saved_system)
                 if saved_enum in detected_systems:
-                    PrettyOutput.print(f"使用配置文件中保存的构建系统: {saved_system}", OutputType.INFO)
+                    print(f"ℹ️ 使用配置文件中保存的构建系统: {saved_system}")
                     return saved_enum
             except ValueError:
                 # 配置文件中保存的构建系统无效，忽略
@@ -95,10 +94,10 @@ class BuildValidator:
                     selected = detected_systems[choice_num - 1]
                     # 保存用户选择
                     self.config.set_selected_build_system(selected.value)
-                    PrettyOutput.print(f"用户选择构建系统: {selected.value}", OutputType.INFO)
+                    print(f"ℹ️ 用户选择构建系统: {selected.value}")
                     return selected
                 elif choice_num == len(detected_systems) + 1:
-                    PrettyOutput.print("用户取消选择，使用兜底验证器", OutputType.INFO)
+                    print("ℹ️ 用户取消选择，使用兜底验证器")
                     return None
                 else:
                     print(f"无效选择，请输入 1-{len(detected_systems) + 1}")
@@ -122,7 +121,7 @@ class BuildValidator:
         
         if not detected_systems:
             # 未检测到构建系统，使用兜底验证器
-            PrettyOutput.print("未检测到构建系统，使用兜底验证器", OutputType.INFO)
+            print("ℹ️ 未检测到构建系统，使用兜底验证器")
             return self._fallback_validator.validate(modified_files)
         
         # 让用户选择构建系统（如果多个）
@@ -130,16 +129,16 @@ class BuildValidator:
         
         if build_system and build_system in self._validators:
             validator = self._validators[build_system]
-            PrettyOutput.print(f"使用构建系统: {build_system.value}, 验证器: {validator.__class__.__name__}", OutputType.INFO)
+            print(f"ℹ️ 使用构建系统: {build_system.value}, 验证器: {validator.__class__.__name__}")
             try:
                 return validator.validate(modified_files)
             except Exception as e:
-                PrettyOutput.print(f"验证器 {validator.__class__.__name__} 执行失败: {e}, 使用兜底验证器", OutputType.WARNING)
+                print(f"⚠️ 验证器 {validator.__class__.__name__} 执行失败: {e}, 使用兜底验证器")
                 # 验证器执行失败时，使用兜底验证器
                 return self._fallback_validator.validate(modified_files)
         else:
             # 用户取消或未选择，使用兜底验证器
-            PrettyOutput.print("使用兜底验证器", OutputType.INFO)
+            print("ℹ️ 使用兜底验证器")
             return self._fallback_validator.validate(modified_files)
     
     def register_validator(self, build_system: BuildSystem, validator: BuildValidatorBase):
@@ -150,5 +149,5 @@ class BuildValidator:
             validator: 验证器实例
         """
         self._validators[build_system] = validator
-        PrettyOutput.print(f"注册自定义验证器: {build_system.value} -> {validator.__class__.__name__}", OutputType.INFO)
+        print(f"ℹ️ 注册自定义验证器: {build_system.value} -> {validator.__class__.__name__}")