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

jarvis/jarvis_code_agent/code_analyzer/language_registry.py

@@ -0,0 +1,185 @@
+"""语言注册表。
+
+管理所有语言支持的注册和发现机制。
+"""
+
+import os
+from typing import Dict, Optional, Set
+
+from .base_language import BaseLanguageSupport
+from .dependency_analyzer import DependencyAnalyzer
+from .symbol_extractor import SymbolExtractor
+
+
+class LanguageRegistry:
+    """语言支持注册表。
+    
+    负责管理所有已注册的语言支持，提供语言检测和工厂方法。
+    """
+
+    def __init__(self):
+        self._languages: Dict[str, BaseLanguageSupport] = {}
+        self._extension_map: Dict[str, str] = {}  # extension -> language_name
+
+    def register(self, language_support: BaseLanguageSupport) -> None:
+        """注册一个语言支持。
+        
+        Args:
+            language_support: 语言支持实例
+        """
+        lang_name = language_support.language_name
+        self._languages[lang_name] = language_support
+        
+        # 注册文件扩展名映射
+        for ext in language_support.file_extensions:
+            # 如果扩展名已存在，记录警告但不覆盖（保留第一个注册的）
+            if ext in self._extension_map and self._extension_map[ext] != lang_name:
+                print(f"Warning: Extension {ext} already registered for "
+                      f"{self._extension_map[ext]}, ignoring registration for {lang_name}")
+            else:
+                self._extension_map[ext] = lang_name
+
+    def unregister(self, language_name: str) -> None:
+        """取消注册一个语言支持。
+        
+        Args:
+            language_name: 语言名称
+        """
+        if language_name in self._languages:
+            self._languages.pop(language_name)
+            # 移除扩展名映射
+            extensions_to_remove = [
+                ext for ext, lang in self._extension_map.items()
+                if lang == language_name
+            ]
+            for ext in extensions_to_remove:
+                del self._extension_map[ext]
+
+    def detect_language(self, file_path: str) -> Optional[str]:
+        """根据文件路径检测编程语言。
+        
+        Args:
+            file_path: 文件路径
+            
+        Returns:
+            语言名称，如果无法检测则返回None
+        """
+        _, ext = os.path.splitext(file_path)
+        return self._extension_map.get(ext)
+
+    def get_language_support(self, language_name: str) -> Optional[BaseLanguageSupport]:
+        """获取指定语言的支持实例。
+        
+        Args:
+            language_name: 语言名称
+            
+        Returns:
+            语言支持实例，如果未注册则返回None
+        """
+        return self._languages.get(language_name)
+
+    def get_symbol_extractor(self, language_name: str) -> Optional[SymbolExtractor]:
+        """获取指定语言的符号提取器。
+        
+        Args:
+            language_name: 语言名称
+            
+        Returns:
+            SymbolExtractor实例，如果不支持则返回None
+        """
+        lang_support = self.get_language_support(language_name)
+        if lang_support:
+            return lang_support.create_symbol_extractor()
+        return None
+
+    def get_dependency_analyzer(self, language_name: str) -> Optional[DependencyAnalyzer]:
+        """获取指定语言的依赖分析器。
+        
+        Args:
+            language_name: 语言名称
+            
+        Returns:
+            DependencyAnalyzer实例，如果不支持则返回None
+        """
+        lang_support = self.get_language_support(language_name)
+        if lang_support:
+            return lang_support.create_dependency_analyzer()
+        return None
+
+    def get_supported_languages(self) -> Set[str]:
+        """获取所有已注册的语言名称集合。
+        
+        Returns:
+            语言名称集合
+        """
+        return set(self._languages.keys())
+
+    def is_supported(self, file_path: str) -> bool:
+        """检查文件是否被支持。
+        
+        Args:
+            file_path: 文件路径
+            
+        Returns:
+            如果文件被支持返回True，否则返回False
+        """
+        return self.detect_language(file_path) is not None
+
+
+# 全局注册表实例
+_registry = LanguageRegistry()
+
+
+def get_registry() -> LanguageRegistry:
+    """获取全局语言注册表实例。
+    
+    Returns:
+        全局LanguageRegistry实例
+    """
+    return _registry
+
+
+def register_language(language_support: BaseLanguageSupport) -> None:
+    """注册一个语言支持（便捷函数）。
+    
+    Args:
+        language_support: 语言支持实例
+    """
+    _registry.register(language_support)
+
+
+def detect_language(file_path: str) -> Optional[str]:
+    """检测文件的语言（便捷函数）。
+    
+    Args:
+        file_path: 文件路径
+        
+    Returns:
+        语言名称，如果无法检测则返回None
+    """
+    return _registry.detect_language(file_path)
+
+
+def get_symbol_extractor(language: str) -> Optional[SymbolExtractor]:
+    """获取指定语言的符号提取器（便捷函数）。
+    
+    Args:
+        language: 语言名称
+        
+    Returns:
+        SymbolExtractor实例，如果不支持则返回None
+    """
+    return _registry.get_symbol_extractor(language)
+
+
+def get_dependency_analyzer(language: str) -> Optional[DependencyAnalyzer]:
+    """获取指定语言的依赖分析器（便捷函数）。
+    
+    Args:
+        language: 语言名称
+        
+    Returns:
+        DependencyAnalyzer实例，如果不支持则返回None
+    """
+    return _registry.get_dependency_analyzer(language)
+

jarvis/jarvis_code_agent/code_analyzer/language_support.py

@@ -0,0 +1,110 @@
+"""语言支持模块。
+
+提供语言检测和工厂函数，使用语言注册表管理所有语言支持。
+"""
+
+from typing import Optional
+
+from .dependency_analyzer import DependencyAnalyzer
+from .language_registry import (
+    detect_language as _detect_language,
+    get_dependency_analyzer as _get_dependency_analyzer,
+    get_symbol_extractor as _get_symbol_extractor,
+    register_language,
+)
+from .symbol_extractor import SymbolExtractor
+
+# 自动注册所有语言支持
+# 使用try-except确保某个语言支持导入失败不影响其他语言
+
+# Python语言支持（必需，因为它是核心语言）
+try:
+    from .languages import PythonLanguageSupport
+    register_language(PythonLanguageSupport())
+except ImportError as e:
+    print(f"Warning: Failed to import PythonLanguageSupport: {e}")
+
+# Rust语言支持（可选，需要tree-sitter）
+try:
+    from .languages import RustLanguageSupport
+    register_language(RustLanguageSupport())
+except (ImportError, RuntimeError):
+    pass  # 静默失败，tree-sitter可能不可用
+
+# Go语言支持（可选，需要tree-sitter）
+try:
+    from .languages import GoLanguageSupport
+    register_language(GoLanguageSupport())
+except (ImportError, RuntimeError):
+    pass  # 静默失败，tree-sitter可能不可用
+
+# C语言支持（可选，需要tree-sitter）
+try:
+    from .languages import CLanguageSupport
+    register_language(CLanguageSupport())
+except (ImportError, RuntimeError):
+    pass  # 静默失败，tree-sitter可能不可用
+
+# C++语言支持（可选，需要tree-sitter）
+try:
+    from .languages import CppLanguageSupport
+    register_language(CppLanguageSupport())
+except (ImportError, RuntimeError):
+    pass  # 静默失败，tree-sitter可能不可用
+
+# JavaScript语言支持（可选，需要tree-sitter）
+try:
+    from .languages import JavaScriptLanguageSupport
+    register_language(JavaScriptLanguageSupport())
+except (ImportError, RuntimeError):
+    pass  # 静默失败，tree-sitter可能不可用
+
+# TypeScript语言支持（可选，需要tree-sitter）
+try:
+    from .languages import TypeScriptLanguageSupport
+    register_language(TypeScriptLanguageSupport())
+except (ImportError, RuntimeError):
+    pass  # 静默失败，tree-sitter可能不可用
+
+# Java语言支持（可选，需要tree-sitter）
+try:
+    from .languages import JavaLanguageSupport
+    register_language(JavaLanguageSupport())
+except (ImportError, RuntimeError):
+    pass  # 静默失败，tree-sitter可能不可用
+
+
+def detect_language(file_path: str) -> Optional[str]:
+    """检测文件的编程语言。
+    
+    Args:
+        file_path: 文件路径
+        
+    Returns:
+        语言名称，如果无法检测则返回None
+    """
+    return _detect_language(file_path)
+
+
+def get_symbol_extractor(language: str) -> Optional[SymbolExtractor]:
+    """获取指定语言的符号提取器。
+    
+    Args:
+        language: 语言名称
+        
+    Returns:
+        SymbolExtractor实例，如果不支持则返回None
+    """
+    return _get_symbol_extractor(language)
+
+
+def get_dependency_analyzer(language: str) -> Optional[DependencyAnalyzer]:
+    """获取指定语言的依赖分析器。
+    
+    Args:
+        language: 语言名称
+        
+    Returns:
+        DependencyAnalyzer实例，如果不支持则返回None
+    """
+    return _get_dependency_analyzer(language)

jarvis/jarvis_code_agent/code_analyzer/languages/__init__.py

@@ -0,0 +1,49 @@
+"""语言支持实现模块。
+
+包含各种编程语言的支持实现。
+"""
+
+# 导入所有语言支持类，以便自动注册
+# 使用try-except确保某个语言支持导入失败不影响其他语言
+
+from .python_language import PythonLanguageSupport
+
+__all__ = ['PythonLanguageSupport']
+
+# 尝试导入tree-sitter相关的语言支持
+try:
+    from .rust_language import RustLanguageSupport  # noqa: F401
+    __all__.append('RustLanguageSupport')
+except (ImportError, RuntimeError):
+    pass
+
+try:
+    from .go_language import GoLanguageSupport  # noqa: F401
+    __all__.append('GoLanguageSupport')
+except (ImportError, RuntimeError):
+    pass
+
+try:
+    from .c_cpp_language import CLanguageSupport, CppLanguageSupport  # noqa: F401
+    __all__.extend(['CLanguageSupport', 'CppLanguageSupport'])
+except (ImportError, RuntimeError):
+    pass
+
+try:
+    from .javascript_language import JavaScriptLanguageSupport  # noqa: F401
+    __all__.append('JavaScriptLanguageSupport')
+except (ImportError, RuntimeError):
+    pass
+
+try:
+    from .typescript_language import TypeScriptLanguageSupport  # noqa: F401
+    __all__.append('TypeScriptLanguageSupport')
+except (ImportError, RuntimeError):
+    pass
+
+try:
+    from .java_language import JavaLanguageSupport  # noqa: F401
+    __all__.append('JavaLanguageSupport')
+except (ImportError, RuntimeError):
+    pass
+

jarvis/jarvis_code_agent/code_analyzer/languages/c_cpp_language.py

@@ -0,0 +1,299 @@
+"""C/C++语言支持实现。"""
+
+import os
+import re
+from typing import List, Optional, Set
+
+from tree_sitter import Language, Node
+
+from ..base_language import BaseLanguageSupport
+from ..dependency_analyzer import Dependency, DependencyAnalyzer, DependencyGraph
+from ..file_ignore import filter_walk_dirs
+from ..symbol_extractor import Symbol, SymbolExtractor
+from ..tree_sitter_extractor import TreeSitterExtractor
+
+
+# --- C/C++ Symbol Query ---
+
+# C语言查询（不包含class_specifier，因为C不支持class）
+C_SYMBOL_QUERY = """
+(function_declarator
+  declarator: (identifier) @function.name)
+
+(struct_specifier
+  name: (type_identifier) @struct.name)
+  
+(union_specifier
+  name: (type_identifier) @union.name)
+  
+(enum_specifier
+  name: (type_identifier) @enum.name)
+
+(preproc_def
+  name: (identifier) @macro.name)
+
+(type_definition
+  declarator: (type_identifier) @typedef.name)
+"""
+
+# C++语言查询（包含class_specifier）
+CPP_SYMBOL_QUERY = """
+(function_declarator
+  declarator: (identifier) @function.name)
+
+(struct_specifier
+  name: (type_identifier) @struct.name)
+
+(class_specifier
+  name: (type_identifier) @class.name)
+  
+(union_specifier
+  name: (type_identifier) @union.name)
+  
+(enum_specifier
+  name: (type_identifier) @enum.name)
+
+(namespace_definition
+  name: (identifier)? @namespace.name)
+
+(preproc_def
+  name: (identifier) @macro.name)
+
+(type_definition
+  declarator: (type_identifier) @typedef.name)
+
+(template_declaration) @template
+"""
+
+# --- C/C++ Language Setup ---
+
+try:
+    import tree_sitter_c
+    C_LANGUAGE: Optional[Language] = tree_sitter_c.language()
+except (ImportError, Exception):
+    C_LANGUAGE = None
+
+try:
+    import tree_sitter_cpp
+    CPP_LANGUAGE: Optional[Language] = tree_sitter_cpp.language()
+except (ImportError, Exception):
+    CPP_LANGUAGE = None
+
+
+# --- C/C++ Symbol Extractors ---
+
+class CSymbolExtractor(TreeSitterExtractor):
+    """Extracts symbols from C code using tree-sitter."""
+
+    def __init__(self):
+        if not C_LANGUAGE:
+            raise RuntimeError("C tree-sitter grammar not available.")
+        super().__init__(C_LANGUAGE, C_SYMBOL_QUERY)
+
+    def _create_symbol_from_capture(self, node: Node, name: str, file_path: str) -> Optional[Symbol]:
+        kind_map = {
+            "function.name": "function",
+            "struct.name": "struct",
+            "union.name": "union",
+            "enum.name": "enum",
+            "macro.name": "macro",
+            "typedef.name": "typedef",
+        }
+        symbol_kind = kind_map.get(name)
+        if not symbol_kind:
+            return None
+
+        return Symbol(
+            name=node.text.decode('utf8'),
+            kind=symbol_kind,
+            file_path=file_path,
+            line_start=node.start_point[0] + 1,
+            line_end=node.end_point[0] + 1,
+        )
+
+
+class CppSymbolExtractor(TreeSitterExtractor):
+    """Extracts symbols from C++ code using tree-sitter."""
+
+    def __init__(self):
+        if not CPP_LANGUAGE:
+            raise RuntimeError("C++ tree-sitter grammar not available.")
+        super().__init__(CPP_LANGUAGE, CPP_SYMBOL_QUERY)
+
+    def _create_symbol_from_capture(self, node: Node, name: str, file_path: str) -> Optional[Symbol]:
+        kind_map = {
+            "function.name": "function",
+            "struct.name": "struct",
+            "class.name": "class",
+            "union.name": "union",
+            "enum.name": "enum",
+            "namespace.name": "namespace",
+            "macro.name": "macro",
+            "typedef.name": "typedef",
+            "template": "template",
+        }
+        symbol_kind = kind_map.get(name)
+        if not symbol_kind:
+            return None
+
+        # For anonymous namespaces, use a generated name
+        if name == "namespace.name":
+            symbol_name = node.text.decode('utf8') if node.text else "<anonymous_namespace>"
+        elif name == "template":
+            # For template declarations, extract the template name or use a generic name
+            # Try to find the function/class name after template
+            template_text = node.text.decode('utf8').strip()
+            # Extract template parameters and the following declaration
+            # This is a simplified extraction - in practice, you might want more sophisticated parsing
+            if 'template' in template_text:
+                # Try to extract the name after template<...>
+                parts = template_text.split('>', 1)
+                if len(parts) > 1:
+                    # Look for function/class name in the second part
+                    match = re.search(r'\b(function|class|struct)\s+(\w+)', parts[1])
+                    if match:
+                        symbol_name = f"template_{match.group(2)}"
+                    else:
+                        symbol_name = "template"
+                else:
+                    symbol_name = "template"
+            else:
+                symbol_name = "template"
+        else:
+            symbol_name = node.text.decode('utf8')
+        
+        if not symbol_name:
+            return None
+
+        return Symbol(
+            name=symbol_name,
+            kind=symbol_kind,
+            file_path=file_path,
+            line_start=node.start_point[0] + 1,
+            line_end=node.end_point[0] + 1,
+        )
+
+
+# --- C/C++ Dependency Analyzers ---
+
+class CDependencyAnalyzer(DependencyAnalyzer):
+    """Analyzes C include dependencies."""
+
+    def analyze_imports(self, file_path: str, content: str) -> List[Dependency]:
+        """Analyzes C #include statements."""
+        dependencies: List[Dependency] = []
+        
+        # Match #include directives
+        # Format: #include <header.h> or #include "header.h"
+        include_pattern = re.compile(r'#include\s+[<"]([^>"]+)[>"]')
+        
+        for line_num, line in enumerate(content.split('\n'), start=1):
+            match = include_pattern.search(line)
+            if match:
+                header = match.group(1)
+                dependencies.append(Dependency(
+                    from_module=header,
+                    imported_symbol=None,
+                    file_path=file_path,
+                    line=line_num,
+                ))
+        
+        return dependencies
+
+    def build_dependency_graph(self, project_root: str) -> DependencyGraph:
+        """Builds a dependency graph for a C project."""
+        graph = DependencyGraph()
+        extensions = {'.c', '.h'}
+        
+        for root, dirs, files in os.walk(project_root):
+            dirs[:] = filter_walk_dirs(dirs)
+            
+            for file in files:
+                if not any(file.endswith(ext) for ext in extensions):
+                    continue
+                
+                file_path = os.path.join(root, file)
+                try:
+                    with open(file_path, 'r', encoding='utf-8', errors='replace') as f:
+                        content = f.read()
+                    
+                    dependencies = self.analyze_imports(file_path, content)
+                    for dep in dependencies:
+                        dep_path = self._resolve_header_path(project_root, dep.from_module, file_path)
+                        if dep_path and dep_path != file_path:
+                            graph.add_dependency(file_path, dep_path)
+                except Exception:
+                    continue
+        
+        return graph
+
+    def _resolve_header_path(self, project_root: str, header_name: str, from_file: str) -> Optional[str]:
+        """Resolve a header name to a file path."""
+        # Try relative to current file
+        base_dir = os.path.dirname(from_file)
+        relative_path = os.path.join(base_dir, header_name)
+        if os.path.exists(relative_path):
+            return relative_path
+        
+        # Try in project root
+        for root, dirs, files in os.walk(project_root):
+            dirs[:] = filter_walk_dirs(dirs)
+            if header_name in files:
+                return os.path.join(root, header_name)
+        
+        return None
+
+    def _is_source_file(self, file_path: str) -> bool:
+        """Check if a file is a C source file."""
+        return file_path.endswith(('.c', '.h'))
+
+
+class CppDependencyAnalyzer(CDependencyAnalyzer):
+    """Analyzes C++ include dependencies (same as C)."""
+
+    def _is_source_file(self, file_path: str) -> bool:
+        """Check if a file is a C++ source file."""
+        return file_path.endswith(('.cpp', '.hpp', '.cc', '.cxx', '.hxx', '.h'))
+
+
+class CLanguageSupport(BaseLanguageSupport):
+    """C语言支持类。"""
+
+    @property
+    def language_name(self) -> str:
+        return 'c'
+
+    @property
+    def file_extensions(self) -> Set[str]:
+        return {'.c', '.h'}
+
+    def create_symbol_extractor(self) -> Optional[SymbolExtractor]:
+        try:
+            return CSymbolExtractor()
+        except RuntimeError:
+            return None
+
+    def create_dependency_analyzer(self) -> Optional[DependencyAnalyzer]:
+        return CDependencyAnalyzer()
+
+
+class CppLanguageSupport(BaseLanguageSupport):
+    """C++语言支持类。"""
+
+    @property
+    def language_name(self) -> str:
+        return 'cpp'
+
+    @property
+    def file_extensions(self) -> Set[str]:
+        return {'.cpp', '.hpp', '.cc', '.cxx', '.hxx'}
+
+    def create_symbol_extractor(self) -> Optional[SymbolExtractor]:
+        try:
+            return CppSymbolExtractor()
+        except RuntimeError:
+            return None
+
+    def create_dependency_analyzer(self) -> Optional[DependencyAnalyzer]:
+        return CppDependencyAnalyzer()
+