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

jarvis/jarvis_code_agent/code_analyzer/build_validator/python.py

@@ -1,6 +1,3 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
 """
 Python构建验证器模块
 
@@ -9,45 +6,76 @@ Python构建验证器模块
 
 import os
 import time
-from typing import List, Optional
+from typing import List
+
+from jarvis.jarvis_utils.output import PrettyOutput
+
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+from typing import Optional
 
-from .base import BuildValidatorBase, BuildResult, BuildSystem
+from .base import BuildResult
+from .base import BuildSystem
+from .base import BuildValidatorBase
 
 
 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"
-            ]):
+            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")):
+                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"]):
+                    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])
@@ -55,13 +83,13 @@ class PythonBuildValidator(BuildValidatorBase):
             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 = []
@@ -76,10 +104,10 @@ class PythonBuildValidator(BuildValidatorBase):
                         timeout=5,
                     )
                     if returncode != 0:
-                        error_msg = f"{file_path}: {stderr}".strip()
-                        errors.append(error_msg)
+                        file_error_msg = f"{file_path}: {stderr}".strip()
+                        errors.append(file_error_msg)
                         error_outputs.append(stdout + stderr)
-            
+
             if errors:
                 duration = time.time() - start_time
                 # 合并所有错误输出
@@ -91,8 +119,10 @@ 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}")
+                PrettyOutput.auto_print(
+                    f"❌ Python 构建验证失败（耗时 {duration:.2f} 秒）"
+                )
+                PrettyOutput.auto_print(f"错误信息：\n{error_message}")
                 return BuildResult(
                     success=False,
                     output=full_output,
@@ -100,7 +130,7 @@ class PythonBuildValidator(BuildValidatorBase):
                     build_system=BuildSystem.PYTHON,
                     duration=duration,
                 )
-        
+
         # 策略2: 尝试运行 pytest（会自动编译并运行测试，即使没有配置文件也会自动发现测试）
         # 首先尝试 pytest
         returncode, stdout, stderr = self._run_command(
@@ -114,19 +144,25 @@ class PythonBuildValidator(BuildValidatorBase):
                 ["python", "-m", "unittest", "discover", "-v"],
                 timeout=30,
             )
-        
+
         duration = time.time() - start_time
         success = returncode == 0
         output = stdout + stderr
-        
+
         # 如果失败，提取关键错误信息（包括编译错误和测试失败）
+        error_msg: Optional[str] = None
         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():
+                if (
+                    "no tests ran" in output.lower()
+                    or "no tests found" in output.lower()
+                ):
                     # 没有测试文件，但语法检查通过，视为成功
-                    print(f"✅ Python 构建验证成功（耗时 {duration:.2f} 秒，未发现测试文件）")
+                    PrettyOutput.auto_print(
+                        f"✅ Python 构建验证成功（耗时 {duration:.2f} 秒，未发现测试文件）"
+                    )
                     return BuildResult(
                         success=True,
                         output="Python语法检查通过（未发现测试文件）",
@@ -135,15 +171,14 @@ class PythonBuildValidator(BuildValidatorBase):
                         duration=duration,
                     )
                 error_msg = "Python项目验证失败（编译或测试失败）"
-            print(f"❌ Python 构建验证失败（耗时 {duration:.2f} 秒）")
+            PrettyOutput.auto_print(f"❌ Python 构建验证失败（耗时 {duration:.2f} 秒）")
             if error_msg:
-                print(f"错误信息：\n{error_msg}")
+                PrettyOutput.auto_print(f"错误信息：\n{error_msg}")
             else:
-                print(f"输出：\n{output[:500]}")
+                PrettyOutput.auto_print(f"输出：\n{output[:500]}")
         else:
-            error_msg = None
-            print(f"✅ Python 构建验证成功（耗时 {duration:.2f} 秒）")
-        
+            PrettyOutput.auto_print(f"✅ Python 构建验证成功（耗时 {duration:.2f} 秒）")
+
         return BuildResult(
             success=success,
             output=output,
@@ -151,4 +186,3 @@ class PythonBuildValidator(BuildValidatorBase):
             build_system=BuildSystem.PYTHON,
             duration=duration,
         )
-

jarvis/jarvis_code_agent/code_analyzer/build_validator/rust.py

@@ -1,6 +1,3 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
 """
 Rust构建验证器模块
 
@@ -10,25 +7,34 @@ Rust构建验证器模块
 import os
 import subprocess
 import time
-from typing import List, Optional
 
-from .base import BuildValidatorBase, BuildResult, BuildSystem
+from jarvis.jarvis_utils.output import PrettyOutput
+
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+from typing import List
+from typing import Optional
+
+from .base import BuildResult
+from .base import BuildSystem
+from .base import BuildValidatorBase
 
 
 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 进行构建和测试验证（会自动编译并运行测试）
+
+        # 使用 cargo test 进行构建和测试验证（会自动编译并运行测试，包括文档测试）
         # 设置 RUST_BACKTRACE=1 以启用调用链回溯
         # 设置 RUSTFLAGS="-A warnings" 以屏蔽警告，只显示错误
         cmd = ["cargo", "test", "--", "--nocapture"]
-        
+
         # 准备环境变量（继承当前环境并设置 RUST_BACKTRACE 和 RUSTFLAGS）
         env = os.environ.copy()
         env["RUST_BACKTRACE"] = "1"
@@ -37,7 +43,7 @@ class RustBuildValidator(BuildValidatorBase):
             env["RUSTFLAGS"] = env["RUSTFLAGS"] + " -A warnings"
         else:
             env["RUSTFLAGS"] = "-A warnings"
-        
+
         # 直接使用 subprocess.run 以支持环境变量
         try:
             result = subprocess.run(
@@ -65,24 +71,24 @@ class RustBuildValidator(BuildValidatorBase):
             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} 秒）")
+            PrettyOutput.auto_print(f"❌ Rust 构建验证失败（耗时 {duration:.2f} 秒）")
             if error_message:
-                print(f"错误信息：\n{error_message}")
+                PrettyOutput.auto_print(f"错误信息：\n{error_message}")
             else:
-                print(f"输出：\n{output[:500]}")
+                PrettyOutput.auto_print(f"输出：\n{output[:500]}")
         else:
             error_message = None
-            print(f"✅ Rust 构建验证成功（耗时 {duration:.2f} 秒）")
-        
+            PrettyOutput.auto_print(f"✅ Rust 构建验证成功（耗时 {duration:.2f} 秒）")
+
         return BuildResult(
             success=success,
             output=output,
@@ -90,21 +96,142 @@ class RustBuildValidator(BuildValidatorBase):
             build_system=BuildSystem.RUST,
             duration=duration,
         )
-    
-    def _parse_cargo_errors(self, output: str) -> str:
-        """解析cargo的错误输出（包括编译错误和测试失败）"""
-        # 简化处理：提取关键错误信息
+
+    def _parse_cargo_errors(self, output: str, context_lines: int = 20) -> str:
+        """解析cargo的错误输出（包括编译错误和测试失败）
+
+        Args:
+            output: cargo test 的完整输出
+            context_lines: 每个错误周围保留的上下文行数（默认20行）
+
+        Returns:
+            提取的错误信息，包含失败测试用例及其上下文
+        """
         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]  # 限制长度
+        error_sections = []
+
+        # 1. 查找失败的测试用例
+        failed_tests = []
+        for i, line in enumerate(lines):
+            # 匹配失败的测试用例行，如 "test tests::test_name ... FAILED"
+            if "test" in line and "FAILED" in line:
+                # 提取测试名称
+                if "test " in line:
+                    parts = line.split()
+                    for j, part in enumerate(parts):
+                        if part == "test" and j + 1 < len(parts):
+                            test_name = parts[j + 1]
+                            if "..." in test_name:
+                                test_name = test_name.replace("...", "")
+                            failed_tests.append((i, test_name, line))
+                            break
+
+        # 2. 为每个失败的测试提取完整输出块
+        if failed_tests:
+            for test_idx, (line_idx, test_name, test_line) in enumerate(failed_tests):
+                # 找到这个测试的开始位置（向上查找，找到 "running" 或测试名称）
+                start_idx = max(0, line_idx - 10)
+                # 向上查找，找到测试开始标记
+                for i in range(line_idx - 1, max(0, line_idx - 100), -1):
+                    # 查找 "running" 行，通常格式为 "running 1 test" 或包含测试名称
+                    if "running" in lines[i].lower():
+                        start_idx = i
+                        break
+                    # 或者找到前一个测试的结束标记
+                    if (
+                        i > 0
+                        and "test " in lines[i]
+                        and ("ok" in lines[i].lower() or "FAILED" in lines[i])
+                    ):
+                        start_idx = i + 1
+                        break
+
+                # 找到这个测试的结束位置（向下查找，找到下一个测试或测试总结）
+                end_idx = min(len(lines), line_idx + context_lines)
+                # 向下查找，找到测试块的结束
+                for i in range(line_idx + 1, min(len(lines), line_idx + 500)):
+                    # 遇到下一个测试用例行（格式：test xxx ... ok/FAILED）
+                    if "test " in lines[i] and "..." in lines[i]:
+                        end_idx = i
+                        break
+                    # 遇到测试总结行
+                    if "test result:" in lines[i].lower():
+                        end_idx = i
+                        break
+                    # 遇到新的 "running" 行，表示下一组测试开始
+                    if "running" in lines[i].lower() and i > line_idx + 5:
+                        end_idx = i
+                        break
 
+                # 提取这个测试的完整输出
+                test_output = "\n".join(lines[start_idx:end_idx])
+                if test_output.strip():
+                    error_sections.append(
+                        f"=== 失败的测试: {test_name} ===\n{test_output}"
+                    )
+
+        # 3. 如果没有找到失败的测试，查找编译错误
+        if not error_sections:
+            error_lines = []
+            in_error_block = False
+            error_start = -1
+
+            for i, line in enumerate(lines):
+                # 检测错误开始
+                if "error[" in line or (
+                    "error:" in line.lower() and "error[" not in line
+                ):
+                    if not in_error_block:
+                        error_start = max(0, i - 2)  # 包含错误前2行上下文
+                        in_error_block = True
+                elif in_error_block:
+                    # 错误块结束条件：空行后跟非错误行，或遇到新的错误
+                    if line.strip() == "":
+                        # 检查下一行是否是新的错误
+                        if i + 1 < len(lines) and (
+                            "error[" not in lines[i + 1]
+                            and "error:" not in lines[i + 1].lower()
+                        ):
+                            # 结束当前错误块
+                            error_lines.extend(lines[error_start : i + 1])
+                            in_error_block = False
+                    elif i - error_start > context_lines:
+                        # 错误块太长，截断
+                        error_lines.extend(lines[error_start:i])
+                        in_error_block = False
+                        if "error[" in line or "error:" in line.lower():
+                            error_start = max(0, i - 2)
+                            in_error_block = True
+
+            # 处理最后一个错误块
+            if in_error_block:
+                error_lines.extend(
+                    lines[error_start : min(len(lines), error_start + context_lines)]
+                )
+
+            if error_lines:
+                error_sections.append("\n".join(error_lines))
+
+        # 4. 如果仍然没有找到错误，查找其他错误模式
+        if not error_sections:
+            for i, line in enumerate(lines):
+                if (
+                    "panic" in line.lower()
+                    or ("assertion" in line.lower() and "failed" in line.lower())
+                    or "thread" in line.lower()
+                    and "panicked" in line.lower()
+                ):
+                    start = max(0, i - 3)
+                    end = min(len(lines), i + context_lines)
+                    error_sections.append("\n".join(lines[start:end]))
+                    break
+
+        # 5. 如果找到了错误信息，返回；否则返回原始输出的前500字符
+        if error_sections:
+            result = "\n\n".join(error_sections)
+            # 限制总长度，避免过长
+            if len(result) > 5000:
+                result = result[:5000] + "\n... (输出已截断)"
+            return result
+        else:
+            return output[:500]  # 如果没有找到特定错误，返回前500字符