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

jarvis/jarvis_code_agent/code_analyzer/languages/go_language.py

@@ -0,0 +1,215 @@
+"""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))
+
+(type_declaration
+  (type_spec
+    name: (type_identifier) @interface.name
+    type: (interface_type)))
+
+(const_declaration) @const
+
+(var_declaration) @var
+
+(struct_type) @struct
+"""
+
+# --- 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",
+            "const": "const",
+            "var": "var",
+            "struct": "struct",
+        }
+        
+        symbol_kind = kind_map.get(name)
+        if not symbol_kind:
+            return None
+
+        # For const/var/struct, extract the first identifier as name
+        if symbol_kind in ("const", "var", "struct"):
+            # Try to find the first identifier in the declaration
+            node_text = node.text.decode('utf8').strip()
+            # Extract first identifier after const/var/struct keyword
+            if symbol_kind == "const":
+                match = re.search(r'const\s+(\w+)', node_text)
+            elif symbol_kind == "var":
+                match = re.search(r'var\s+(\w+)', node_text)
+            else:  # struct
+                # For struct, try to find struct name or use a generic name
+                match = re.search(r'struct\s+(\w+)', node_text)
+            
+            if match:
+                symbol_name = match.group(1)
+            else:
+                # Fallback: use the kind as name
+                symbol_name = symbol_kind
+        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,
+        )
+
+
+# --- 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/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()
+