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

jarvis/jarvis_code_agent/code_analyzer/languages/java_language.py

@@ -0,0 +1,212 @@
+"""Java语言支持实现。"""
+
+import os
+import re
+from typing import List, Optional, Set
+
+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
+
+try:
+    from tree_sitter import Language, Node
+    import tree_sitter_java
+    JAVA_LANGUAGE: Optional[Language] = tree_sitter_java.language()
+except (ImportError, Exception):
+    JAVA_LANGUAGE = None
+
+
+# --- Java Symbol Extractor ---
+
+JAVA_SYMBOL_QUERY = """
+(method_declaration
+  name: (identifier) @method.name)
+
+(class_declaration
+  name: (identifier) @class.name)
+
+(interface_declaration
+  name: (identifier) @interface.name)
+
+(enum_declaration
+  name: (identifier) @enum.name)
+
+(annotation_type_declaration
+  name: (identifier) @annotation.name)
+
+(field_declaration
+  (variable_declarator
+    name: (identifier) @field.name))
+
+(constructor_declaration
+  name: (identifier) @constructor.name)
+"""
+
+
+class JavaSymbolExtractor(TreeSitterExtractor):
+    """Extracts symbols from Java code using tree-sitter."""
+
+    def __init__(self):
+        if not JAVA_LANGUAGE:
+            raise RuntimeError("Java tree-sitter grammar not available.")
+        # 如果传入的是 PyCapsule，需要转换为 Language 对象
+        if not isinstance(JAVA_LANGUAGE, Language):
+            lang = Language(JAVA_LANGUAGE)
+        else:
+            lang = JAVA_LANGUAGE
+        super().__init__(lang, JAVA_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 = {
+            "method.name": "method",
+            "class.name": "class",
+            "interface.name": "interface",
+            "enum.name": "enum",
+            "annotation.name": "annotation",
+            "field.name": "field",
+            "constructor.name": "constructor",
+        }
+        
+        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,
+        )
+
+
+# --- Java Dependency Analyzer ---
+
+class JavaDependencyAnalyzer(DependencyAnalyzer):
+    """Analyzes Java import dependencies."""
+
+    def analyze_imports(self, file_path: str, content: str) -> List[Dependency]:
+        """Analyzes Java import statements."""
+        dependencies: List[Dependency] = []
+        
+        # Java import statements
+        # import package.Class;
+        # import package.*;
+        # import static package.Class.method;
+        import_pattern = re.compile(
+            r'import\s+(?:static\s+)?([\w.]+)(?:\.\*)?\s*;',
+            re.MULTILINE
+        )
+        
+        for line_num, line in enumerate(content.split('\n'), start=1):
+            import_match = import_pattern.search(line)
+            if import_match:
+                module_path = import_match.group(1)
+                if module_path:
+                    # Extract class name if it's a specific import
+                    parts = module_path.split('.')
+                    imported_symbol = None
+                    if len(parts) > 1 and not line.strip().endswith('.*;'):
+                        # Specific class import
+                        imported_symbol = parts[-1]
+                        module_path = '.'.join(parts[:-1])
+                    
+                    dependencies.append(Dependency(
+                        from_module=module_path,
+                        imported_symbol=imported_symbol,
+                        file_path=file_path,
+                        line=line_num,
+                    ))
+        
+        return dependencies
+
+    def build_dependency_graph(self, project_root: str) -> DependencyGraph:
+        """Builds a dependency graph for a Java 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('.java'):
+                    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:
+                        # Skip java.* and javax.* standard library packages
+                        if not dep.from_module.startswith(('java.', 'javax.')):
+                            dep_path = self._resolve_module_path(project_root, dep.from_module, dep.imported_symbol, 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, package_name: str, class_name: Optional[str], from_file: str) -> Optional[str]:
+        """Resolve a Java package name to a file path."""
+        if not package_name:
+            return None
+        
+        # Convert package name to directory path
+        package_path = package_name.replace('.', os.sep)
+        
+        # Try to find the class file
+        if class_name:
+            # Specific class import
+            class_file = class_name + '.java'
+            resolved = os.path.normpath(os.path.join(project_root, 'src', 'main', 'java', package_path, class_file))
+            if os.path.exists(resolved) and os.path.isfile(resolved):
+                return resolved
+            
+            # Try alternative source directories
+            for src_dir in ['src', 'source', 'java']:
+                resolved = os.path.normpath(os.path.join(project_root, src_dir, package_path, class_file))
+                if os.path.exists(resolved) and os.path.isfile(resolved):
+                    return resolved
+        else:
+            # Wildcard import - try to find package-info.java or any class in the package
+            package_dir = os.path.normpath(os.path.join(project_root, 'src', 'main', 'java', package_path))
+            if os.path.exists(package_dir) and os.path.isdir(package_dir):
+                # Return the first .java file found (or package-info.java if exists)
+                for file in os.listdir(package_dir):
+                    if file.endswith('.java'):
+                        resolved = os.path.join(package_dir, file)
+                        if os.path.isfile(resolved):
+                            return resolved
+        
+        return None
+
+
+# --- Java Language Support ---
+
+class JavaLanguageSupport(BaseLanguageSupport):
+    """Java语言支持。"""
+
+    @property
+    def language_name(self) -> str:
+        return "java"
+
+    @property
+    def file_extensions(self) -> Set[str]:
+        return {'.java'}
+
+    def create_symbol_extractor(self) -> Optional[SymbolExtractor]:
+        if not JAVA_LANGUAGE:
+            return None
+        try:
+            return JavaSymbolExtractor()
+        except Exception:
+            return None
+
+    def create_dependency_analyzer(self) -> Optional[DependencyAnalyzer]:
+        return JavaDependencyAnalyzer()
+

jarvis/jarvis_code_agent/code_analyzer/languages/javascript_language.py

@@ -0,0 +1,254 @@
+"""JavaScript语言支持实现。"""
+
+import os
+import re
+from typing import List, Optional, Set
+
+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
+
+try:
+    from tree_sitter import Language, Node
+    import tree_sitter_javascript
+    JS_LANGUAGE: Optional[Language] = tree_sitter_javascript.language()
+except (ImportError, Exception):
+    JS_LANGUAGE = None
+
+
+# --- JavaScript Symbol Extractor ---
+
+JS_SYMBOL_QUERY = """
+(function_declaration
+  name: (identifier) @function.name)
+
+(function_expression
+  name: (identifier) @function.name)
+
+(generator_function_declaration
+  name: (identifier) @generator.name)
+
+(generator_function
+  name: (identifier) @generator.name)
+
+(arrow_function) @arrow.function
+
+(method_definition
+  name: (property_identifier) @method.name)
+
+(class_declaration
+  name: (identifier) @class.name)
+
+(class_expression
+  name: (identifier) @class.name)
+
+(variable_declaration
+  (variable_declarator
+    name: (identifier) @variable.name))
+"""
+
+
+class JavaScriptSymbolExtractor(TreeSitterExtractor):
+    """Extracts symbols from JavaScript code using tree-sitter."""
+
+    def __init__(self):
+        if not JS_LANGUAGE:
+            raise RuntimeError("JavaScript tree-sitter grammar not available.")
+        # 如果传入的是 PyCapsule，需要转换为 Language 对象
+        if not isinstance(JS_LANGUAGE, Language):
+            lang = Language(JS_LANGUAGE)
+        else:
+            lang = JS_LANGUAGE
+        super().__init__(lang, JS_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",
+            "arrow.function": "function",
+            "generator.name": "function",
+            "method.name": "method",
+            "class.name": "class",
+            "variable.name": "variable",
+        }
+        
+        symbol_kind = kind_map.get(name)
+        if not symbol_kind:
+            return None
+
+        # For arrow functions without names, use a generated name
+        if name == "arrow.function":
+            symbol_name = "<anonymous_arrow_function>"
+        elif name == "generator.name":
+            # Generator functions are also functions
+            symbol_name = node.text.decode('utf8')
+        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,
+        )
+
+
+# --- JavaScript Dependency Analyzer ---
+
+class JavaScriptDependencyAnalyzer(DependencyAnalyzer):
+    """Analyzes JavaScript import/require dependencies."""
+
+    def analyze_imports(self, file_path: str, content: str) -> List[Dependency]:
+        """Analyzes JavaScript import and require statements."""
+        dependencies: List[Dependency] = []
+        
+        # ES6 import statements
+        # import module from 'path'
+        # import { symbol } from 'path'
+        # import * as alias from 'path'
+        import_pattern = re.compile(
+            r'import\s+(?:(?:\*\s+as\s+(\w+)|(\{[^}]*\})|(\w+))\s+from\s+)?["\']([^"\']+)["\']',
+            re.MULTILINE
+        )
+        
+        # CommonJS require statements
+        # const module = require('path')
+        # require('path')
+        require_pattern = re.compile(
+            r'(?:const|let|var)\s+\w+\s*=\s*require\(["\']([^"\']+)["\']\)|require\(["\']([^"\']+)["\']\)',
+            re.MULTILINE
+        )
+        
+        for line_num, line in enumerate(content.split('\n'), start=1):
+            # Check for ES6 imports
+            import_match = import_pattern.search(line)
+            if import_match:
+                module_path = import_match.group(4) or import_match.group(5)
+                if module_path:
+                    # Extract imported symbols if any
+                    symbols_group = import_match.group(2) or import_match.group(1)
+                    imported_symbol = None
+                    if symbols_group and symbols_group.startswith('{'):
+                        # Extract first symbol from { symbol1, symbol2 }
+                        symbol_match = re.search(r'\{([^}]+)\}', symbols_group)
+                        if symbol_match:
+                            first_symbol = symbol_match.group(1).split(',')[0].strip()
+                            imported_symbol = first_symbol.split(' as ')[0].strip()
+                    
+                    dependencies.append(Dependency(
+                        from_module=module_path,
+                        imported_symbol=imported_symbol,
+                        file_path=file_path,
+                        line=line_num,
+                    ))
+            
+            # Check for require statements
+            require_match = require_pattern.search(line)
+            if require_match:
+                module_path = require_match.group(1) or require_match.group(2)
+                if module_path:
+                    dependencies.append(Dependency(
+                        from_module=module_path,
+                        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 JavaScript 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(('.js', '.jsx', '.mjs', '.cjs')):
+                    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:
+                        # Skip node_modules and external packages
+                        if dep.from_module.startswith(('.', '/')) or not dep.from_module.startswith('http'):
+                            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 JavaScript module name to a file path."""
+        if not module_name:
+            return None
+        
+        # Handle relative imports
+        if module_name.startswith('.'):
+            base_dir = os.path.dirname(from_file)
+            # Resolve relative path
+            if module_name.endswith('.js') or module_name.endswith('.jsx'):
+                # Direct file reference
+                resolved = os.path.normpath(os.path.join(base_dir, module_name))
+            else:
+                # Try with .js extension
+                resolved = os.path.normpath(os.path.join(base_dir, module_name + '.js'))
+                if not os.path.exists(resolved):
+                    # Try with .jsx extension
+                    resolved = os.path.normpath(os.path.join(base_dir, module_name + '.jsx'))
+                if not os.path.exists(resolved):
+                    # Try index.js
+                    resolved = os.path.normpath(os.path.join(base_dir, module_name, 'index.js'))
+            
+            if os.path.exists(resolved) and os.path.isfile(resolved):
+                return resolved
+        
+        # Handle absolute imports (from project root)
+        if module_name.startswith('/'):
+            resolved = os.path.normpath(os.path.join(project_root, module_name.lstrip('/')))
+            if not resolved.endswith(('.js', '.jsx')):
+                resolved += '.js'
+            if os.path.exists(resolved) and os.path.isfile(resolved):
+                return resolved
+        
+        # For node_modules and external packages, we can't resolve without package.json
+        # Return None to skip them
+        return None
+
+
+# --- JavaScript Language Support ---
+
+class JavaScriptLanguageSupport(BaseLanguageSupport):
+    """JavaScript语言支持。"""
+
+    @property
+    def language_name(self) -> str:
+        return "javascript"
+
+    @property
+    def file_extensions(self) -> Set[str]:
+        return {'.js', '.jsx', '.mjs', '.cjs'}
+
+    def create_symbol_extractor(self) -> Optional[SymbolExtractor]:
+        if not JS_LANGUAGE:
+            return None
+        try:
+            return JavaScriptSymbolExtractor()
+        except Exception:
+            return None
+
+    def create_dependency_analyzer(self) -> Optional[DependencyAnalyzer]:
+        return JavaScriptDependencyAnalyzer()
+

jarvis/jarvis_code_agent/code_analyzer/languages/python_language.py

@@ -16,22 +16,72 @@ class PythonSymbolExtractor(SymbolExtractor):
     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 as e:
-            print(f"Error parsing Python file {file_path}: {e}")
+        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

jarvis/jarvis_code_agent/code_analyzer/languages/rust_language.py

@@ -30,6 +30,28 @@ RUST_SYMBOL_QUERY = """
 
 (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 ---
@@ -59,14 +81,64 @@ class RustSymbolExtractor(TreeSitterExtractor):
             "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=node.text.decode('utf8'),
+            name=symbol_name,
             kind=symbol_kind,
             file_path=file_path,
             line_start=node.start_point[0] + 1,