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

jarvis/jarvis_code_agent/code_analyzer/__init__.py

@@ -0,0 +1,65 @@
+"""Jarvis代码分析器模块。
+
+提供符号提取、依赖分析和上下文管理功能。
+"""
+
+from .symbol_extractor import Symbol, SymbolTable, SymbolExtractor
+from .dependency_analyzer import Dependency, DependencyGraph, DependencyAnalyzer
+from .context_manager import ContextManager, EditContext, Reference
+from .context_recommender import ContextRecommendation
+from .llm_context_recommender import ContextRecommender
+from .language_support import detect_language, get_symbol_extractor, get_dependency_analyzer
+from .base_language import BaseLanguageSupport
+from .language_registry import LanguageRegistry, get_registry, register_language
+from .impact_analyzer import (
+    ImpactAnalyzer,
+    Impact,
+    ImpactReport,
+    ImpactType,
+    RiskLevel,
+    InterfaceChange,
+    Edit,
+    TestDiscoverer,
+    parse_git_diff_to_edits,
+)
+from .structured_code import StructuredCodeExtractor
+
+__all__ = [
+    # Symbol extraction
+    'Symbol',
+    'SymbolTable',
+    'SymbolExtractor',
+    # Dependency analysis
+    'Dependency',
+    'DependencyGraph',
+    'DependencyAnalyzer',
+    # Context management
+    'ContextManager',
+    'EditContext',
+    'Reference',
+    # Context recommendation
+    'ContextRecommender',
+    'ContextRecommendation',
+    # Language support
+    'detect_language',
+    'get_symbol_extractor',
+    'get_dependency_analyzer',
+    # Language registry
+    'BaseLanguageSupport',
+    'LanguageRegistry',
+    'get_registry',
+    'register_language',
+    # Impact analysis
+    'ImpactAnalyzer',
+    'Impact',
+    'ImpactReport',
+    'ImpactType',
+    'RiskLevel',
+    'InterfaceChange',
+    'Edit',
+    'TestDiscoverer',
+    'parse_git_diff_to_edits',
+    # Structured code extraction
+    'StructuredCodeExtractor',
+]
+

jarvis/jarvis_code_agent/code_analyzer/base_language.py

@@ -0,0 +1,74 @@
+"""基础语言支持抽象类。
+
+定义所有语言支持需要实现的接口，便于扩展新的语言支持。
+"""
+
+from abc import ABC, abstractmethod
+from typing import Optional, Set
+
+from .dependency_analyzer import DependencyAnalyzer
+from .symbol_extractor import SymbolExtractor
+
+
+class BaseLanguageSupport(ABC):
+    """语言支持的基础抽象类。
+    
+    所有语言支持类都应该继承此类并实现所需的方法。
+    """
+
+    @property
+    @abstractmethod
+    def language_name(self) -> str:
+        """返回语言名称（如 'python', 'rust', 'go'）。"""
+        pass
+
+    @property
+    @abstractmethod
+    def file_extensions(self) -> Set[str]:
+        """返回该语言支持的文件扩展名集合（如 {'.py', '.pyw'}）。"""
+        pass
+
+    @abstractmethod
+    def create_symbol_extractor(self) -> Optional[SymbolExtractor]:
+        """创建并返回该语言的符号提取器实例。
+        
+        Returns:
+            SymbolExtractor实例，如果不支持符号提取则返回None
+        """
+        pass
+
+    @abstractmethod
+    def create_dependency_analyzer(self) -> Optional[DependencyAnalyzer]:
+        """创建并返回该语言的依赖分析器实例。
+        
+        Returns:
+            DependencyAnalyzer实例，如果不支持依赖分析则返回None
+        """
+        pass
+
+    def is_source_file(self, file_path: str) -> bool:
+        """检查文件是否为该语言的源文件。
+        
+        Args:
+            file_path: 文件路径
+            
+        Returns:
+            如果是该语言的源文件返回True，否则返回False
+        """
+        import os
+        _, ext = os.path.splitext(file_path)
+        return ext in self.file_extensions
+
+    def detect_language(self, file_path: str) -> Optional[str]:
+        """检测文件是否属于该语言。
+        
+        Args:
+            file_path: 文件路径
+            
+        Returns:
+            如果属于该语言返回language_name，否则返回None
+        """
+        if self.is_source_file(file_path):
+            return self.language_name
+        return None
+

jarvis/jarvis_code_agent/code_analyzer/build_validator/__init__.py

@@ -0,0 +1,44 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+构建验证模块
+
+提供编辑后编译/构建验证功能，支持多种构建系统，具有易扩展性和兜底机制。
+"""
+
+# 导出主要接口
+from .base import BuildSystem, BuildResult, BuildValidatorBase
+from .detector import BuildSystemDetector
+from .validator import BuildValidator
+
+# 导出各语言验证器（便于扩展）
+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
+
+__all__ = [
+    # 主要接口
+    "BuildSystem",
+    "BuildResult",
+    "BuildValidatorBase",
+    "BuildSystemDetector",
+    "BuildValidator",
+    # 各语言验证器
+    "RustBuildValidator",
+    "PythonBuildValidator",
+    "NodeJSBuildValidator",
+    "JavaMavenBuildValidator",
+    "JavaGradleBuildValidator",
+    "GoBuildValidator",
+    "CMakeBuildValidator",
+    "MakefileBuildValidator",
+    "FallbackBuildValidator",
+]
+

jarvis/jarvis_code_agent/code_analyzer/build_validator/base.py

@@ -0,0 +1,106 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+构建验证器基础模块
+
+提供基础类和枚举定义。
+"""
+
+import subprocess
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from typing import List, Optional, Tuple
+from enum import Enum
+
+
+class BuildSystem(Enum):
+    """支持的构建系统类型"""
+    UNKNOWN = "unknown"
+    PYTHON = "python"
+    NODEJS = "nodejs"
+    RUST = "rust"
+    JAVA_MAVEN = "java_maven"
+    JAVA_GRADLE = "java_gradle"
+    GO = "go"
+    C_MAKEFILE = "c_makefile"
+    C_CMAKE = "c_cmake"
+    C_MAKEFILE_CMAKE = "c_makefile_cmake"  # 同时存在Makefile和CMakeLists.txt
+
+
+@dataclass
+class BuildResult:
+    """构建验证结果"""
+    success: bool
+    output: str
+    error_message: Optional[str] = None
+    build_system: Optional[BuildSystem] = None
+    duration: float = 0.0  # 验证耗时（秒）
+
+
+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
+    
+    @abstractmethod
+    def validate(self, modified_files: Optional[List[str]] = None) -> BuildResult:
+        """验证构建
+        
+        Args:
+            modified_files: 修改的文件列表（可选，用于增量验证）
+        
+        Returns:
+            BuildResult: 验证结果
+        """
+        pass
+    
+    def _run_command(
+        self,
+        cmd: List[str],
+        cwd: Optional[str] = None,
+        timeout: Optional[int] = None,
+        capture_output: bool = True,
+    ) -> Tuple[int, str, str]:
+        """运行命令
+        
+        Args:
+            cmd: 命令列表
+            cwd: 工作目录
+            timeout: 超时时间（秒）
+            capture_output: 是否捕获输出
+        
+        Returns:
+            (返回码, stdout, stderr)
+        """
+        if cwd is None:
+            cwd = self.project_root
+        if timeout is None:
+            timeout = self.timeout
+        
+        try:
+            result = subprocess.run(
+                cmd,
+                cwd=cwd,
+                timeout=timeout,
+                capture_output=capture_output,
+                text=True,
+                encoding="utf-8",
+                errors="replace",
+            )
+            stdout = result.stdout if capture_output else ""
+            stderr = result.stderr if capture_output else ""
+            return result.returncode, stdout, stderr
+        except subprocess.TimeoutExpired:
+            return -1, "", f"命令执行超时（{timeout}秒）"
+        except FileNotFoundError:
+            return -1, "", f"命令未找到: {cmd[0]}"
+        except Exception as e:
+            return -1, "", f"执行命令时出错: {str(e)}"
+

jarvis/jarvis_code_agent/code_analyzer/build_validator/cmake.py

@@ -0,0 +1,74 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+CMake构建验证器模块
+
+提供CMake项目的构建验证功能。
+"""
+
+import os
+import tempfile
+import time
+from typing import List, Optional
+
+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()
+        
+        # 策略1: 尝试使用 cmake --build（如果已有构建目录）
+        build_dirs = ["build", "cmake-build-debug", "cmake-build-release"]
+        for build_dir in build_dirs:
+            build_path = os.path.join(self.project_root, build_dir)
+            if os.path.exists(build_path):
+                returncode, stdout, stderr = self._run_command(
+                    ["cmake", "--build", build_path],
+                    timeout=60,
+                )
+                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=output,
+                    error_message=None if success else "CMake构建失败",
+                    build_system=BuildSystem.C_CMAKE,
+                    duration=duration,
+                )
+        
+        # 策略2: 仅验证CMakeLists.txt语法
+        with tempfile.TemporaryDirectory(prefix="cmake_check_") as tmpdir:
+            returncode, stdout, stderr = self._run_command(
+                ["cmake", "-S", ".", "-B", tmpdir],
+                timeout=10,
+            )
+        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=output,
+            error_message=None if success else "CMake配置失败",
+            build_system=BuildSystem.C_CMAKE,
+            duration=duration,
+        )
+

jarvis/jarvis_code_agent/code_analyzer/build_validator/detector.py

@@ -0,0 +1,125 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+构建系统检测器模块
+
+提供构建系统自动检测功能。
+"""
+
+import os
+from typing import List, Optional
+
+from .base import BuildSystem
+
+
+class BuildSystemDetector:
+    """构建系统检测器"""
+    
+    def __init__(self, project_root: str):
+        self.project_root = project_root
+    
+    def detect(self) -> Optional[BuildSystem]:
+        """检测项目使用的构建系统（兼容旧接口，返回第一个检测到的）
+        
+        Returns:
+            检测到的构建系统，如果无法检测则返回None
+        """
+        all_systems = self.detect_all()
+        return all_systems[0] if all_systems else None
+    
+    def detect_all(self) -> List[BuildSystem]:
+        """检测所有可能的构建系统
+        
+        Returns:
+            检测到的所有构建系统列表（按优先级排序）
+        """
+        detected = []
+        # 按优先级检测（从最具体到最通用）
+        detectors = [
+            self._detect_rust,
+            self._detect_go,
+            self._detect_java_maven,
+            self._detect_java_gradle,
+            self._detect_nodejs,
+            self._detect_python,
+            self._detect_c_cmake,
+            self._detect_c_makefile,
+        ]
+        
+        for detector in detectors:
+            result = detector()
+            if result and result not in detected:
+                detected.append(result)
+        
+        return detected
+    
+    def _detect_rust(self) -> Optional[BuildSystem]:
+        """检测Rust项目（Cargo.toml）"""
+        cargo_toml = os.path.join(self.project_root, "Cargo.toml")
+        if os.path.exists(cargo_toml):
+            return BuildSystem.RUST
+        return None
+    
+    def _detect_go(self) -> Optional[BuildSystem]:
+        """检测Go项目（go.mod）"""
+        go_mod = os.path.join(self.project_root, "go.mod")
+        if os.path.exists(go_mod):
+            return BuildSystem.GO
+        return None
+    
+    def _detect_java_maven(self) -> Optional[BuildSystem]:
+        """检测Maven项目（pom.xml）"""
+        pom_xml = os.path.join(self.project_root, "pom.xml")
+        if os.path.exists(pom_xml):
+            return BuildSystem.JAVA_MAVEN
+        return None
+    
+    def _detect_java_gradle(self) -> Optional[BuildSystem]:
+        """检测Gradle项目（build.gradle或build.gradle.kts）"""
+        build_gradle = os.path.join(self.project_root, "build.gradle")
+        build_gradle_kts = os.path.join(self.project_root, "build.gradle.kts")
+        if os.path.exists(build_gradle) or os.path.exists(build_gradle_kts):
+            return BuildSystem.JAVA_GRADLE
+        return None
+    
+    def _detect_nodejs(self) -> Optional[BuildSystem]:
+        """检测Node.js项目（package.json）"""
+        package_json = os.path.join(self.project_root, "package.json")
+        if os.path.exists(package_json):
+            return BuildSystem.NODEJS
+        return None
+    
+    def _detect_python(self) -> Optional[BuildSystem]:
+        """检测Python项目（setup.py, pyproject.toml, requirements.txt等）"""
+        indicators = [
+            "setup.py",
+            "pyproject.toml",
+            "requirements.txt",
+            "setup.cfg",
+            "Pipfile",
+            "poetry.lock",
+        ]
+        for indicator in indicators:
+            if os.path.exists(os.path.join(self.project_root, indicator)):
+                return BuildSystem.PYTHON
+        return None
+    
+    def _detect_c_cmake(self) -> Optional[BuildSystem]:
+        """检测CMake项目（CMakeLists.txt）"""
+        cmake_lists = os.path.join(self.project_root, "CMakeLists.txt")
+        if os.path.exists(cmake_lists):
+            # 检查是否同时存在Makefile
+            makefile = os.path.join(self.project_root, "Makefile")
+            if os.path.exists(makefile):
+                return BuildSystem.C_MAKEFILE_CMAKE
+            return BuildSystem.C_CMAKE
+        return None
+    
+    def _detect_c_makefile(self) -> Optional[BuildSystem]:
+        """检测Makefile项目"""
+        makefile = os.path.join(self.project_root, "Makefile")
+        if os.path.exists(makefile):
+            return BuildSystem.C_MAKEFILE
+        return None
+

jarvis/jarvis_code_agent/code_analyzer/build_validator/fallback.py

@@ -0,0 +1,72 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+兜底构建验证器模块
+
+当无法检测构建系统时使用的兜底验证器。
+"""
+
+import os
+import time
+from typing import List, Optional
+
+from .base import BuildValidatorBase, BuildResult, BuildSystem
+
+
+class FallbackBuildValidator(BuildValidatorBase):
+    """兜底验证器：当无法检测构建系统时使用"""
+    
+    def validate(self, modified_files: Optional[List[str]] = None) -> BuildResult:
+        start_time = time.time()
+        
+        # 策略1: 根据文件扩展名进行基本的语法检查
+        if modified_files:
+            errors = []
+            for file_path in modified_files:
+                ext = os.path.splitext(file_path)[1].lower()
+                full_path = os.path.join(self.project_root, file_path)
+                
+                if not os.path.exists(full_path):
+                    continue
+                
+                # Python文件：使用py_compile
+                if ext == ".py":
+                    returncode, _, stderr = self._run_command(
+                        ["python", "-m", "py_compile", full_path],
+                        timeout=5,
+                    )
+                    if returncode != 0:
+                        errors.append(f"{file_path}: {stderr}")
+                
+                # JavaScript文件：尝试使用node检查语法
+                elif ext in (".js", ".mjs", ".cjs"):
+                    returncode, _, stderr = self._run_command(
+                        ["node", "--check", full_path],
+                        timeout=5,
+                    )
+                    if returncode != 0:
+                        errors.append(f"{file_path}: {stderr}")
+            
+            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),
+                    error_message="语法检查失败",
+                    build_system=BuildSystem.UNKNOWN,
+                    duration=duration,
+                )
+        
+        duration = time.time() - start_time
+        print(f"✅ 基础语法检查通过（耗时 {duration:.2f} 秒，未检测到构建系统）")
+        return BuildResult(
+            success=True,
+            output="基础语法检查通过（未检测到构建系统）",
+            error_message=None,
+            build_system=BuildSystem.UNKNOWN,
+            duration=duration,
+        )
+

jarvis/jarvis_code_agent/code_analyzer/build_validator/go.py

@@ -0,0 +1,70 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+Go构建验证器模块
+
+提供Go项目的构建验证功能。
+"""
+
+import time
+from typing import List, Optional
+
+from .base import BuildValidatorBase, BuildResult, BuildSystem
+
+
+class GoBuildValidator(BuildValidatorBase):
+    """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 test 进行构建和测试验证（会自动编译并运行测试）
+        cmd = ["go", "test", "./..."]
+        
+        returncode, stdout, stderr = self._run_command(cmd, timeout=30)
+        duration = time.time() - start_time
+        
+        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=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

@@ -0,0 +1,53 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+Java Gradle构建验证器模块
+
+提供Java Gradle项目的构建验证功能。
+"""
+
+import os
+import time
+from typing import List, Optional
+
+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()
+        
+        # 使用 gradle compileJava 进行编译验证
+        # 优先使用 gradlew（如果存在）
+        gradlew = os.path.join(self.project_root, "gradlew")
+        if os.path.exists(gradlew):
+            cmd = ["./gradlew", "compileJava", "--quiet"]
+        else:
+            cmd = ["gradle", "compileJava", "--quiet"]
+        
+        returncode, stdout, stderr = self._run_command(cmd, timeout=60)
+        duration = time.time() - start_time
+        
+        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,
+            error_message=None if success else "Gradle编译失败",
+            build_system=BuildSystem.JAVA_GRADLE,
+            duration=duration,
+        )
+