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

jarvis/jarvis_code_agent/code_analyzer/languages/python_language.py

@@ -0,0 +1,269 @@
+"""Python语言支持实现。"""
+
+import ast
+import os
+from typing import List, Optional, Set, Union
+
+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
+
+
+class PythonSymbolExtractor(SymbolExtractor):
+    """Extracts symbols from Python code using the AST module."""
+
+    def extract_symbols(self, file_path: str, content: str) -> List[Symbol]:
+        symbols: List[Symbol] = []
+        try:
+            # 对于超大文件，限制解析内容长度（避免内存和性能问题）
+            # 只解析前 50000 行，通常足够提取主要符号
+            max_lines = 50000
+            lines = content.split('\n')
+            if len(lines) > max_lines:
+                content = '\n'.join(lines[:max_lines])
+            
+            tree = ast.parse(content, filename=file_path)
+            self._traverse_node(tree, file_path, symbols, parent_name=None)
+        except SyntaxError:
+            # 静默跳过语法错误文件（可能是部分代码片段或测试文件）
+            pass
+        except Exception:
+            # 静默跳过其他解析错误（如内存不足等）
+            pass
+        return symbols
+
+    def _traverse_node(self, node: ast.AST, file_path: str, symbols: List[Symbol], parent_name: Optional[str]):
+        if isinstance(node, ast.FunctionDef):
+            # Extract decorators before the function
+            if node.decorator_list:
+                for decorator in node.decorator_list:
+                    if isinstance(decorator, ast.Name):
+                        decorator_symbol = Symbol(
+                            name=decorator.id,
+                            kind='decorator',
+                            file_path=file_path,
+                            line_start=decorator.lineno,
+                            line_end=decorator.lineno,
+                            parent=parent_name,
+                        )
+                        symbols.append(decorator_symbol)
+            symbol = self._create_symbol_from_func(node, file_path, parent_name)
+            symbols.append(symbol)
+            parent_name = node.name
+        elif isinstance(node, ast.AsyncFunctionDef):
+            # Extract decorators before the async function
+            if node.decorator_list:
+                for decorator in node.decorator_list:
+                    if isinstance(decorator, ast.Name):
+                        decorator_symbol = Symbol(
+                            name=decorator.id,
+                            kind='decorator',
+                            file_path=file_path,
+                            line_start=decorator.lineno,
+                            line_end=decorator.lineno,
+                            parent=parent_name,
+                        )
+                        symbols.append(decorator_symbol)
+            symbol = self._create_symbol_from_func(node, file_path, parent_name, is_async=True)
+            symbols.append(symbol)
+            parent_name = node.name
+        elif isinstance(node, ast.ClassDef):
+            # Extract decorators before the class
+            if node.decorator_list:
+                for decorator in node.decorator_list:
+                    if isinstance(decorator, ast.Name):
+                        decorator_symbol = Symbol(
+                            name=decorator.id,
+                            kind='decorator',
+                            file_path=file_path,
+                            line_start=decorator.lineno,
+                            line_end=decorator.lineno,
+                            parent=parent_name,
+                        )
+                        symbols.append(decorator_symbol)
+            symbol = self._create_symbol_from_class(node, file_path, parent_name)
+            symbols.append(symbol)
+            parent_name = node.name
+        elif isinstance(node, (ast.Import, ast.ImportFrom)):
+             symbols.extend(self._create_symbols_from_import(node, file_path, parent_name))
+
+        for child in ast.iter_child_nodes(node):
+            self._traverse_node(child, file_path, symbols, parent_name=parent_name)
+
+    def _create_symbol_from_func(self, node: Union[ast.FunctionDef, ast.AsyncFunctionDef], file_path: str, parent: Optional[str], is_async: bool = False) -> Symbol:
+        signature = f"{'async ' if is_async else ''}def {node.name}(...)"
+        return Symbol(
+            name=node.name,
+            kind='function',
+            file_path=file_path,
+            line_start=node.lineno,
+            line_end=node.end_lineno or node.lineno,
+            signature=signature,
+            docstring=ast.get_docstring(node),
+            parent=parent,
+        )
+
+    def _create_symbol_from_class(self, node: ast.ClassDef, file_path: str, parent: Optional[str]) -> Symbol:
+        return Symbol(
+            name=node.name,
+            kind='class',
+            file_path=file_path,
+            line_start=node.lineno,
+            line_end=node.end_lineno or node.lineno,
+            docstring=ast.get_docstring(node),
+            parent=parent,
+        )
+    
+    def _create_symbols_from_import(self, node: Union[ast.Import, ast.ImportFrom], file_path: str, parent: Optional[str]) -> List[Symbol]:
+        symbols = []
+        for alias in node.names:
+            symbols.append(Symbol(
+                name=alias.asname or alias.name,
+                kind='import',
+                file_path=file_path,
+                line_start=node.lineno,
+                line_end=node.end_lineno or node.lineno,
+                parent=parent,
+            ))
+        return symbols
+
+
+class PythonDependencyAnalyzer(DependencyAnalyzer):
+    """Analyzes Python import dependencies using AST."""
+
+    def analyze_imports(self, file_path: str, content: str) -> List[Dependency]:
+        """Analyzes Python import statements."""
+        dependencies: List[Dependency] = []
+        
+        try:
+            tree = ast.parse(content, filename=file_path)
+            for node in ast.walk(tree):
+                if isinstance(node, ast.Import):
+                    # import module
+                    for alias in node.names:
+                        dependencies.append(Dependency(
+                            from_module=alias.name,
+                            imported_symbol=None,
+                            file_path=file_path,
+                            line=node.lineno,
+                        ))
+                elif isinstance(node, ast.ImportFrom):
+                    # from module import symbol
+                    module = node.module or ""
+                    for alias in node.names:
+                        dependencies.append(Dependency(
+                            from_module=module,
+                            imported_symbol=alias.name,
+                            file_path=file_path,
+                            line=node.lineno,
+                        ))
+        except SyntaxError:
+            # Skip files with syntax errors
+            pass
+        
+        return dependencies
+
+    def build_dependency_graph(self, project_root: str) -> DependencyGraph:
+        """Builds a dependency graph for a Python project."""
+        graph = DependencyGraph()
+        
+        # Walk through all Python files
+        for root, dirs, files in os.walk(project_root):
+            # Skip hidden directories and common ignore patterns
+            dirs[:] = filter_walk_dirs(dirs)
+            
+            for file in files:
+                if not file.endswith('.py'):
+                    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:
+                        # Resolve module to file path
+                        dep_path = self._resolve_module_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_module_path(self, project_root: str, module_name: str, from_file: str) -> Optional[str]:
+        """Resolve a Python module name to a file path."""
+        if not module_name:
+            return None
+        
+        # Handle relative imports
+        if module_name.startswith('.'):
+            # Relative import - resolve from the importing file's directory
+            base_dir = os.path.dirname(from_file)
+            parts = module_name.split('.')
+            depth = len([p for p in parts if p == ''])
+            module_parts = [p for p in parts if p]
+            
+            # Navigate up directories
+            current_dir = base_dir
+            for _ in range(depth - 1):
+                current_dir = os.path.dirname(current_dir)
+            
+            if module_parts:
+                module_path = os.path.join(current_dir, *module_parts)
+            else:
+                module_path = current_dir
+            
+            # Try to find the module file
+            if os.path.isdir(module_path):
+                init_path = os.path.join(module_path, '__init__.py')
+                if os.path.exists(init_path):
+                    return init_path
+            elif os.path.exists(module_path + '.py'):
+                return module_path + '.py'
+        else:
+            # Absolute import
+            parts = module_name.split('.')
+            
+            # Search in project root
+            for root, dirs, files in os.walk(project_root):
+                # Skip hidden directories and common ignore patterns
+                dirs[:] = filter_walk_dirs(dirs)
+                
+                if parts[0] in dirs or f"{parts[0]}.py" in files:
+                    module_path = os.path.join(root, *parts)
+                    
+                    if os.path.isdir(module_path):
+                        init_path = os.path.join(module_path, '__init__.py')
+                        if os.path.exists(init_path):
+                            return init_path
+                    elif os.path.exists(module_path + '.py'):
+                        return module_path + '.py'
+                    break
+        
+        return None
+
+    def _is_source_file(self, file_path: str) -> bool:
+        """Check if a file is a Python source file."""
+        return file_path.endswith('.py')
+
+
+class PythonLanguageSupport(BaseLanguageSupport):
+    """Python语言支持类。"""
+
+    @property
+    def language_name(self) -> str:
+        return 'python'
+
+    @property
+    def file_extensions(self) -> Set[str]:
+        return {'.py', '.pyw', '.pyi'}
+
+    def create_symbol_extractor(self) -> Optional[SymbolExtractor]:
+        return PythonSymbolExtractor()
+
+    def create_dependency_analyzer(self) -> Optional[DependencyAnalyzer]:
+        return PythonDependencyAnalyzer()
+

jarvis/jarvis_code_agent/code_analyzer/languages/rust_language.py

@@ -0,0 +1,281 @@
+"""Rust语言支持实现。"""
+
+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
+
+
+# --- Rust Symbol Query ---
+
+RUST_SYMBOL_QUERY = """
+(function_item
+  name: (identifier) @function.name)
+
+(struct_item
+  name: (type_identifier) @struct.name)
+  
+(trait_item
+  name: (type_identifier) @trait.name)
+
+(impl_item
+  type: (type_identifier) @impl.name)
+
+(mod_item
+  name: (identifier) @module.name)
+
+(enum_item
+  name: (type_identifier) @enum.name)
+
+(union_item
+  name: (type_identifier) @union.name)
+
+(macro_definition
+  name: (identifier) @macro.name)
+
+(const_item
+  name: (identifier) @const.name)
+
+(static_item
+  name: (identifier) @static.name)
+
+(type_item
+  name: (type_identifier) @type.name)
+
+(extern_block) @extern
+
+(attribute_item) @attribute
+"""
+
+# --- Rust Language Setup ---
+
+try:
+    import tree_sitter_rust
+    RUST_LANGUAGE: Optional[Language] = tree_sitter_rust.language()
+except (ImportError, Exception):
+    RUST_LANGUAGE = None
+
+
+# --- Rust Symbol Extractor ---
+
+class RustSymbolExtractor(TreeSitterExtractor):
+    """Extracts symbols from Rust code using tree-sitter."""
+
+    def __init__(self):
+        if not RUST_LANGUAGE:
+            raise RuntimeError("Rust tree-sitter grammar not available.")
+        super().__init__(RUST_LANGUAGE, RUST_SYMBOL_QUERY)
+
+    def _create_symbol_from_capture(self, node: Node, name: str, file_path: str) -> Optional[Symbol]:
+        """Maps a tree-sitter capture to a Symbol object."""
+        kind_map = {
+            "function.name": "function",
+            "struct.name": "struct",
+            "trait.name": "trait",
+            "impl.name": "impl",
+            "module.name": "module",
+            "enum.name": "enum",
+            "union.name": "union",
+            "macro.name": "macro",
+            "const.name": "const",
+            "static.name": "static",
+            "type.name": "type",
+            "extern": "extern",
+            "attribute": "attribute",
+        }
+        
+        symbol_kind = kind_map.get(name)
+        if not symbol_kind:
+            return None
+
+        # 对于 attribute，提取属性内容作为名称
+        if symbol_kind == "attribute":
+            # 提取属性文本
+            attr_text = node.text.decode('utf8').strip()
+            # 移除开头的 # 或 #!
+            if attr_text.startswith('#!'):
+                attr_text = attr_text[2:].strip()
+            elif attr_text.startswith('#'):
+                attr_text = attr_text[1:].strip()
+            # 移除外层的 []
+            if attr_text.startswith('[') and attr_text.endswith(']'):
+                attr_text = attr_text[1:-1].strip()
+            
+            # 提取属性名称（可能是 test, derive(Debug), cfg(test) 等）
+            # 对于简单属性如 #[test]，直接使用 test
+            # 对于复杂属性如 #[derive(Debug)]，使用 derive
+            # 对于路径属性如 #[cfg(test)]，使用 cfg
+            attr_name = attr_text.split('(')[0].split('[')[0].split('=')[0].split(',')[0].strip()
+            
+            # 如果属性名称为空或只包含空白，使用整个属性文本（去掉括号）
+            if not attr_name or attr_name == '':
+                symbol_name = attr_text if attr_text else "attribute"
+            else:
+                # 使用属性名称，但保留完整文本用于显示
+                symbol_name = attr_name
+        elif symbol_kind == "extern":
+            # 对于 extern 块，提取 extern 关键字后的内容作为名称
+            extern_text = node.text.decode('utf8').strip()
+            # 提取 extern "C" 或 extern "Rust" 等
+            if '"' in extern_text:
+                # 提取引号中的内容
+                start = extern_text.find('"')
+                end = extern_text.find('"', start + 1)
+                if end > start:
+                    symbol_name = f"extern_{extern_text[start+1:end]}"
+                else:
+                    symbol_name = "extern"
+            else:
+                symbol_name = "extern"
+        else:
+            symbol_name = node.text.decode('utf8')
+
+        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,
+        )
+
+
+# --- Rust Dependency Analyzer ---
+
+class RustDependencyAnalyzer(DependencyAnalyzer):
+    """Analyzes Rust use and mod dependencies."""
+
+    def analyze_imports(self, file_path: str, content: str) -> List[Dependency]:
+        """Analyzes Rust use and mod statements."""
+        dependencies: List[Dependency] = []
+        
+        # Match use statements: use crate::module or use std::collections
+        use_pattern = re.compile(r'use\s+([^;]+);')
+        
+        # Match mod declarations: mod module_name;
+        mod_pattern = re.compile(r'mod\s+(\w+)\s*;')
+        
+        for line_num, line in enumerate(content.split('\n'), start=1):
+            # Check for use statements
+            use_match = use_pattern.search(line)
+            if use_match:
+                use_path = use_match.group(1).strip()
+                # Extract the crate/module name
+                parts = use_path.split('::')
+                if parts:
+                    crate_name = parts[0]
+                    symbol = '::'.join(parts[1:]) if len(parts) > 1 else None
+                    dependencies.append(Dependency(
+                        from_module=crate_name,
+                        imported_symbol=symbol,
+                        file_path=file_path,
+                        line=line_num,
+                    ))
+            
+            # Check for mod declarations
+            mod_match = mod_pattern.search(line)
+            if mod_match:
+                mod_name = mod_match.group(1)
+                dependencies.append(Dependency(
+                    from_module=mod_name,
+                    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 Rust project."""
+        graph = DependencyGraph()
+        
+        for root, dirs, files in os.walk(project_root):
+            dirs[:] = filter_walk_dirs(dirs)
+            
+            for file in files:
+                if not file.endswith('.rs'):
+                    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:
+                        # For Rust, resolve mod declarations to file paths
+                        if not dep.from_module.startswith(('std', 'core', 'alloc', 'proc_macro')):
+                            # Try to resolve local modules
+                            dep_path = self._resolve_module_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_module_path(self, project_root: str, module_name: str, from_file: str) -> Optional[str]:
+        """Resolve a Rust module name to a file path."""
+        # Rust modules can be:
+        # 1. mod.rs in a directory
+        # 2. module_name.rs in the same directory
+        # 3. module_name/mod.rs
+        
+        base_dir = os.path.dirname(from_file)
+        
+        # Try module_name.rs in same directory
+        module_file = os.path.join(base_dir, f"{module_name}.rs")
+        if os.path.exists(module_file):
+            return module_file
+        
+        # Try module_name/mod.rs
+        module_dir = os.path.join(base_dir, module_name)
+        mod_rs = os.path.join(module_dir, "mod.rs")
+        if os.path.exists(mod_rs):
+            return mod_rs
+        
+        # Try in parent directories (for nested modules)
+        current_dir = base_dir
+        while current_dir != project_root and current_dir != os.path.dirname(current_dir):
+            module_file = os.path.join(current_dir, f"{module_name}.rs")
+            if os.path.exists(module_file):
+                return module_file
+            module_dir = os.path.join(current_dir, module_name)
+            mod_rs = os.path.join(module_dir, "mod.rs")
+            if os.path.exists(mod_rs):
+                return mod_rs
+            current_dir = os.path.dirname(current_dir)
+        
+        return None
+
+    def _is_source_file(self, file_path: str) -> bool:
+        """Check if a file is a Rust source file."""
+        return file_path.endswith('.rs')
+
+
+class RustLanguageSupport(BaseLanguageSupport):
+    """Rust语言支持类。"""
+
+    @property
+    def language_name(self) -> str:
+        return 'rust'
+
+    @property
+    def file_extensions(self) -> Set[str]:
+        return {'.rs'}
+
+    def create_symbol_extractor(self) -> Optional[SymbolExtractor]:
+        try:
+            return RustSymbolExtractor()
+        except RuntimeError:
+            return None
+
+    def create_dependency_analyzer(self) -> Optional[DependencyAnalyzer]:
+        return RustDependencyAnalyzer()
+