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

jarvis/jarvis_agent/language_extractors/__init__.py

@@ -0,0 +1,57 @@
+# -*- coding: utf-8 -*-
+"""Language extractors for file context handler.
+
+This module automatically registers all language extractors.
+"""
+
+# Import all language extractors to trigger registration
+try:
+    from .python_extractor import register_python_extractor
+    register_python_extractor()
+except (ImportError, Exception):
+    pass
+
+try:
+    from .rust_extractor import register_rust_extractor
+    register_rust_extractor()
+except (ImportError, Exception):
+    pass
+
+try:
+    from .go_extractor import register_go_extractor
+    register_go_extractor()
+except (ImportError, Exception):
+    pass
+
+try:
+    from .c_extractor import register_c_extractor
+    register_c_extractor()
+except (ImportError, Exception):
+    pass
+
+try:
+    from .cpp_extractor import register_cpp_extractor
+    register_cpp_extractor()
+except (ImportError, Exception):
+    pass
+
+try:
+    from .javascript_extractor import register_javascript_extractor
+    register_javascript_extractor()
+except (ImportError, Exception):
+    pass
+
+try:
+    from .typescript_extractor import register_typescript_extractor
+    register_typescript_extractor()
+except (ImportError, Exception):
+    pass
+
+try:
+    from .java_extractor import register_java_extractor
+    register_java_extractor()
+except (ImportError, Exception):
+    pass
+
+__all__ = []
+

jarvis/jarvis_agent/language_extractors/c_extractor.py

@@ -0,0 +1,21 @@
+# -*- coding: utf-8 -*-
+"""C language symbol extractor."""
+
+from typing import Optional, Any
+
+from jarvis.jarvis_agent.file_context_handler import register_language_extractor
+
+
+def create_c_extractor() -> Optional[Any]:
+    """Create C symbol extractor using tree-sitter."""
+    try:
+        from jarvis.jarvis_code_agent.code_analyzer.languages.c_cpp_language import CSymbolExtractor
+        return CSymbolExtractor()
+    except (ImportError, RuntimeError, Exception):
+        return None
+
+
+def register_c_extractor() -> None:
+    """Register C extractor for .c and .h files."""
+    register_language_extractor(['.c', '.h'], create_c_extractor)
+

jarvis/jarvis_agent/language_extractors/cpp_extractor.py

@@ -0,0 +1,21 @@
+# -*- coding: utf-8 -*-
+"""C++ language symbol extractor."""
+
+from typing import Optional, Any
+
+from jarvis.jarvis_agent.file_context_handler import register_language_extractor
+
+
+def create_cpp_extractor() -> Optional[Any]:
+    """Create C++ symbol extractor using tree-sitter."""
+    try:
+        from jarvis.jarvis_code_agent.code_analyzer.languages.c_cpp_language import CppSymbolExtractor
+        return CppSymbolExtractor()
+    except (ImportError, RuntimeError, Exception):
+        return None
+
+
+def register_cpp_extractor() -> None:
+    """Register C++ extractor for .cpp, .cc, .cxx, .hpp, .hxx files."""
+    register_language_extractor(['.cpp', '.cc', '.cxx', '.hpp', '.hxx'], create_cpp_extractor)
+

jarvis/jarvis_agent/language_extractors/go_extractor.py

@@ -0,0 +1,21 @@
+# -*- coding: utf-8 -*-
+"""Go language symbol extractor."""
+
+from typing import Optional, Any
+
+from jarvis.jarvis_agent.file_context_handler import register_language_extractor
+
+
+def create_go_extractor() -> Optional[Any]:
+    """Create Go symbol extractor using tree-sitter."""
+    try:
+        from jarvis.jarvis_code_agent.code_analyzer.languages.go_language import GoSymbolExtractor
+        return GoSymbolExtractor()
+    except (ImportError, RuntimeError, Exception):
+        return None
+
+
+def register_go_extractor() -> None:
+    """Register Go extractor for .go files."""
+    register_language_extractor('.go', create_go_extractor)
+

jarvis/jarvis_agent/language_extractors/java_extractor.py

@@ -0,0 +1,84 @@
+# -*- coding: utf-8 -*-
+"""Java language symbol extractor."""
+
+from typing import Optional, Any
+
+from jarvis.jarvis_agent.file_context_handler import register_language_extractor
+
+
+def create_java_extractor() -> Optional[Any]:
+    """Create Java symbol extractor using tree-sitter."""
+    try:
+        from jarvis.jarvis_code_agent.code_analyzer.languages.java_language import JavaSymbolExtractor
+        return JavaSymbolExtractor()
+    except (ImportError, RuntimeError, Exception):
+        # 如果 code_analyzer 中没有 Java 支持，尝试直接使用 tree-sitter
+        try:
+            from tree_sitter import Language, Parser
+            import tree_sitter_java
+            from jarvis.jarvis_code_agent.code_analyzer.symbol_extractor import Symbol
+            
+            JAVA_LANGUAGE = tree_sitter_java.language()
+            JAVA_SYMBOL_QUERY = """
+            (method_declaration
+              name: (identifier) @method.name)
+            
+            (class_declaration
+              name: (identifier) @class.name)
+            
+            (interface_declaration
+              name: (identifier) @interface.name)
+            
+            (field_declaration
+              (variable_declarator
+                name: (identifier) @field.name))
+            """
+            
+            class JavaSymbolExtractor:
+                def __init__(self):
+                    # 如果传入的是 PyCapsule，需要转换为 Language 对象
+                    if not isinstance(JAVA_LANGUAGE, Language):
+                        self.language = Language(JAVA_LANGUAGE)
+                    else:
+                        self.language = JAVA_LANGUAGE
+                    self.parser = Parser()
+                    # 使用 language 属性而不是 set_language 方法
+                    self.parser.language = self.language
+                    self.symbol_query = JAVA_SYMBOL_QUERY
+                
+                def extract_symbols(self, file_path: str, content: str) -> list:
+                    try:
+                        tree = self.parser.parse(bytes(content, "utf8"))
+                        query = self.language.query(self.symbol_query)
+                        captures = query.captures(tree.root_node)
+                        
+                        symbols = []
+                        for node, name in captures:
+                            kind_map = {
+                                "method.name": "method",
+                                "class.name": "class",
+                                "interface.name": "interface",
+                                "field.name": "field",
+                            }
+                            symbol_kind = kind_map.get(name)
+                            if symbol_kind:
+                                symbols.append(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,
+                                ))
+                        return symbols
+                    except Exception:
+                        return []
+            
+            return JavaSymbolExtractor()
+        except (ImportError, Exception):
+            return None
+
+
+def register_java_extractor() -> None:
+    """Register Java extractor for .java files."""
+    register_language_extractor('.java', create_java_extractor)
+

jarvis/jarvis_agent/language_extractors/javascript_extractor.py

@@ -0,0 +1,79 @@
+# -*- coding: utf-8 -*-
+"""JavaScript language symbol extractor."""
+
+from typing import Optional, Any, List
+
+from jarvis.jarvis_agent.file_context_handler import register_language_extractor
+
+
+def create_javascript_extractor() -> Optional[Any]:
+    """Create JavaScript symbol extractor using tree-sitter."""
+    try:
+        from tree_sitter import Language, Parser
+        import tree_sitter_javascript
+        from jarvis.jarvis_code_agent.code_analyzer.symbol_extractor import Symbol
+        
+        JS_LANGUAGE = tree_sitter_javascript.language()
+        JS_SYMBOL_QUERY = """
+        (function_declaration
+          name: (identifier) @function.name)
+        
+        (method_definition
+          name: (property_identifier) @method.name)
+        
+        (class_declaration
+          name: (identifier) @class.name)
+        
+        (variable_declaration
+          (variable_declarator
+            name: (identifier) @variable.name))
+        """
+        
+        class JSSymbolExtractor:
+            def __init__(self):
+                # 如果传入的是 PyCapsule，需要转换为 Language 对象
+                if not isinstance(JS_LANGUAGE, Language):
+                    self.language = Language(JS_LANGUAGE)
+                else:
+                    self.language = JS_LANGUAGE
+                self.parser = Parser()
+                # 使用 language 属性而不是 set_language 方法
+                self.parser.language = self.language
+                self.symbol_query = JS_SYMBOL_QUERY
+            
+            def extract_symbols(self, file_path: str, content: str) -> List[Any]:
+                try:
+                    tree = self.parser.parse(bytes(content, "utf8"))
+                    query = self.language.query(self.symbol_query)
+                    captures = query.captures(tree.root_node)
+                    
+                    symbols = []
+                    for node, name in captures:
+                        kind_map = {
+                            "function.name": "function",
+                            "method.name": "method",
+                            "class.name": "class",
+                            "variable.name": "variable",
+                        }
+                        symbol_kind = kind_map.get(name)
+                        if symbol_kind:
+                            symbols.append(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,
+                            ))
+                    return symbols
+                except Exception:
+                    return []
+        
+        return JSSymbolExtractor()
+    except (ImportError, Exception):
+        return None
+
+
+def register_javascript_extractor() -> None:
+    """Register JavaScript extractor for .js and .jsx files."""
+    register_language_extractor(['.js', '.jsx'], create_javascript_extractor)
+

jarvis/jarvis_agent/language_extractors/python_extractor.py

@@ -0,0 +1,21 @@
+# -*- coding: utf-8 -*-
+"""Python language symbol extractor."""
+
+from typing import Optional, Any
+
+from jarvis.jarvis_agent.file_context_handler import register_language_extractor
+
+
+def create_python_extractor() -> Optional[Any]:
+    """Create Python symbol extractor using AST."""
+    try:
+        from jarvis.jarvis_code_agent.code_analyzer.languages.python_language import PythonSymbolExtractor
+        return PythonSymbolExtractor()
+    except (ImportError, Exception):
+        return None
+
+
+def register_python_extractor() -> None:
+    """Register Python extractor for .py and .pyw files."""
+    register_language_extractor(['.py', '.pyw'], create_python_extractor)
+

jarvis/jarvis_agent/language_extractors/rust_extractor.py

@@ -0,0 +1,21 @@
+# -*- coding: utf-8 -*-
+"""Rust language symbol extractor."""
+
+from typing import Optional, Any
+
+from jarvis.jarvis_agent.file_context_handler import register_language_extractor
+
+
+def create_rust_extractor() -> Optional[Any]:
+    """Create Rust symbol extractor using tree-sitter."""
+    try:
+        from jarvis.jarvis_code_agent.code_analyzer.languages.rust_language import RustSymbolExtractor
+        return RustSymbolExtractor()
+    except (ImportError, RuntimeError, Exception):
+        return None
+
+
+def register_rust_extractor() -> None:
+    """Register Rust extractor for .rs files."""
+    register_language_extractor('.rs', create_rust_extractor)
+

jarvis/jarvis_agent/language_extractors/typescript_extractor.py

@@ -0,0 +1,84 @@
+# -*- coding: utf-8 -*-
+"""TypeScript language symbol extractor."""
+
+from typing import Optional, Any, List
+
+from jarvis.jarvis_agent.file_context_handler import register_language_extractor
+
+
+def create_typescript_extractor() -> Optional[Any]:
+    """Create TypeScript symbol extractor using tree-sitter."""
+    try:
+        from tree_sitter import Language, Parser
+        import tree_sitter_typescript
+        from jarvis.jarvis_code_agent.code_analyzer.symbol_extractor import Symbol
+        
+        # tree-sitter-typescript 使用 language_typescript() 和 language_tsx()
+        TS_LANGUAGE = tree_sitter_typescript.language_typescript()
+        TS_SYMBOL_QUERY = """
+        (function_declaration
+          name: (identifier) @function.name)
+        
+        (method_definition
+          name: (property_identifier) @method.name)
+        
+        (class_declaration
+          name: (type_identifier) @class.name)
+        
+        (interface_declaration
+          name: (type_identifier) @interface.name)
+        
+        (variable_declaration
+          (variable_declarator
+            name: (identifier) @variable.name))
+        """
+        
+        class TSSymbolExtractor:
+            def __init__(self):
+                # 如果传入的是 PyCapsule，需要转换为 Language 对象
+                if not isinstance(TS_LANGUAGE, Language):
+                    self.language = Language(TS_LANGUAGE)
+                else:
+                    self.language = TS_LANGUAGE
+                self.parser = Parser()
+                # 使用 language 属性而不是 set_language 方法
+                self.parser.language = self.language
+                self.symbol_query = TS_SYMBOL_QUERY
+            
+            def extract_symbols(self, file_path: str, content: str) -> List[Any]:
+                try:
+                    tree = self.parser.parse(bytes(content, "utf8"))
+                    query = self.language.query(self.symbol_query)
+                    captures = query.captures(tree.root_node)
+                    
+                    symbols = []
+                    for node, name in captures:
+                        kind_map = {
+                            "function.name": "function",
+                            "method.name": "method",
+                            "class.name": "class",
+                            "interface.name": "interface",
+                            "variable.name": "variable",
+                        }
+                        symbol_kind = kind_map.get(name)
+                        if symbol_kind:
+                            symbols.append(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,
+                            ))
+                    return symbols
+                except Exception:
+                    return []
+        
+        return TSSymbolExtractor()
+    except (ImportError, Exception):
+        return None
+
+
+def register_typescript_extractor() -> None:
+    """Register TypeScript extractor for .ts and .tsx files."""
+    register_language_extractor(['.ts', '.tsx'], create_typescript_extractor)
+