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

jarvis/jarvis_code_agent/code_analyzer/languages/go_language.py

@@ -0,0 +1,183 @@
+"""Go语言支持实现。"""
+
+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
+
+
+# --- Go Symbol Query ---
+
+GO_SYMBOL_QUERY = """
+(function_declaration
+  name: (identifier) @function.name)
+
+(method_declaration
+  name: (field_identifier) @method.name)
+
+(type_declaration
+  (type_spec
+    name: (type_identifier) @type.name))
+
+(interface_declaration
+  name: (type_identifier) @interface.name)
+"""
+
+# --- Go Language Setup ---
+
+try:
+    import tree_sitter_go
+    GO_LANGUAGE: Optional[Language] = tree_sitter_go.language()
+except (ImportError, Exception):
+    GO_LANGUAGE = None
+
+
+# --- Go Symbol Extractor ---
+
+class GoSymbolExtractor(TreeSitterExtractor):
+    """Extracts symbols from Go code using tree-sitter."""
+
+    def __init__(self):
+        if not GO_LANGUAGE:
+            raise RuntimeError("Go tree-sitter grammar not available.")
+        super().__init__(GO_LANGUAGE, GO_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",
+            "method.name": "method",
+            "type.name": "type",
+            "interface.name": "interface",
+        }
+        
+        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,
+        )
+
+
+# --- Go Dependency Analyzer ---
+
+class GoDependencyAnalyzer(DependencyAnalyzer):
+    """Analyzes Go import dependencies."""
+
+    def analyze_imports(self, file_path: str, content: str) -> List[Dependency]:
+        """Analyzes Go import statements."""
+        dependencies: List[Dependency] = []
+        
+        # Match import statements
+        # Format: import "package" or import ( "package1" "package2" )
+        # Also: import alias "package"
+        re.compile(
+            r'import\s+(?:\(([^)]+)\)|(?:"([^"]+)"|`([^`]+)`)|(\w+)\s+(?:"([^"]+)"|`([^`]+)`)))',
+            re.MULTILINE
+        )
+        
+        # Handle single import: import "package"
+        single_import = re.compile(r'import\s+(?:"([^"]+)"|`([^`]+)`|(\w+)\s+(?:"([^"]+)"|`([^`]+)`))')
+        
+        # Handle block import: import ( ... )
+        block_import = re.compile(r'import\s*\(([^)]+)\)', re.DOTALL)
+        
+        # Try block import first
+        block_match = block_import.search(content)
+        if block_match:
+            block_content = block_match.group(1)
+            for line in block_content.split('\n'):
+                line = line.strip()
+                if not line or line.startswith('//'):
+                    continue
+                # Extract package path
+                pkg_match = re.search(r'(?:"([^"]+)"|`([^`]+)`|(\w+)\s+(?:"([^"]+)"|`([^`]+)`))', line)
+                if pkg_match:
+                    pkg = pkg_match.group(1) or pkg_match.group(2) or pkg_match.group(4) or pkg_match.group(5)
+                    alias = pkg_match.group(3)
+                    line_num = content[:block_match.start()].count('\n') + line.split('\n')[0].count('\n') + 1
+                    dependencies.append(Dependency(
+                        from_module=pkg,
+                        imported_symbol=alias,
+                        file_path=file_path,
+                        line=line_num,
+                    ))
+        else:
+            # Try single import
+            for match in single_import.finditer(content):
+                pkg = match.group(1) or match.group(2) or match.group(4) or match.group(5)
+                alias = match.group(3)
+                line_num = content[:match.start()].count('\n') + 1
+                dependencies.append(Dependency(
+                    from_module=pkg,
+                    imported_symbol=alias,
+                    file_path=file_path,
+                    line=line_num,
+                ))
+        
+        return dependencies
+
+    def build_dependency_graph(self, project_root: str) -> DependencyGraph:
+        """Builds a dependency graph for a Go 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('.go'):
+                    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 Go, we can resolve to vendor or standard library
+                        # For now, just track the module name
+                        # In a real implementation, you'd resolve using go.mod
+                        pass
+                except Exception:
+                    continue
+        
+        return graph
+
+    def _is_source_file(self, file_path: str) -> bool:
+        """Check if a file is a Go source file."""
+        return file_path.endswith('.go')
+
+
+class GoLanguageSupport(BaseLanguageSupport):
+    """Go语言支持类。"""
+
+    @property
+    def language_name(self) -> str:
+        return 'go'
+
+    @property
+    def file_extensions(self) -> Set[str]:
+        return {'.go'}
+
+    def create_symbol_extractor(self) -> Optional[SymbolExtractor]:
+        try:
+            return GoSymbolExtractor()
+        except RuntimeError:
+            return None
+
+    def create_dependency_analyzer(self) -> Optional[DependencyAnalyzer]:
+        return GoDependencyAnalyzer()
+

jarvis/jarvis_code_agent/code_analyzer/languages/python_language.py

@@ -0,0 +1,219 @@
+"""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:
+            tree = ast.parse(content, filename=file_path)
+            self._traverse_node(tree, file_path, symbols, parent_name=None)
+        except SyntaxError as e:
+            print(f"Error parsing Python file {file_path}: {e}")
+        return symbols
+
+    def _traverse_node(self, node: ast.AST, file_path: str, symbols: List[Symbol], parent_name: Optional[str]):
+        if isinstance(node, ast.FunctionDef):
+            symbol = self._create_symbol_from_func(node, file_path, parent_name)
+            symbols.append(symbol)
+            parent_name = node.name
+        elif isinstance(node, ast.AsyncFunctionDef):
+            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):
+            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,209 @@
+"""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)
+"""
+
+# --- 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",
+        }
+        
+        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,
+        )
+
+
+# --- 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()
+