jarvis-ai-assistant 0.7.8__py3-none-any.whl → 1.0.2__py3-none-any.whl

jarvis/jarvis_code_agent/code_analyzer/languages/go_language.py

@@ -2,17 +2,23 @@
 
 import os
 import re
-from typing import List, Optional, Set
+from typing import List
+from typing import Optional
+from typing import Set
+from typing import cast
 
-from tree_sitter import Language, Node
+from tree_sitter import Language
+from tree_sitter import Node
 
 from ..base_language import BaseLanguageSupport
-from ..dependency_analyzer import Dependency, DependencyAnalyzer, DependencyGraph
+from ..dependency_analyzer import Dependency
+from ..dependency_analyzer import DependencyAnalyzer
+from ..dependency_analyzer import DependencyGraph
 from ..file_ignore import filter_walk_dirs
-from ..symbol_extractor import Symbol, SymbolExtractor
+from ..symbol_extractor import Symbol
+from ..symbol_extractor import SymbolExtractor
 from ..tree_sitter_extractor import TreeSitterExtractor
 
-
 # --- Go Symbol Query ---
 
 GO_SYMBOL_QUERY = """
@@ -42,13 +48,17 @@ GO_SYMBOL_QUERY = """
 
 try:
     import tree_sitter_go
-    GO_LANGUAGE: Optional[Language] = tree_sitter_go.language()
+
+    GO_LANGUAGE: Optional[Language] = cast(
+        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."""
 
@@ -57,7 +67,9 @@ class GoSymbolExtractor(TreeSitterExtractor):
             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]:
+    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",
@@ -68,7 +80,7 @@ class GoSymbolExtractor(TreeSitterExtractor):
             "var": "var",
             "struct": "struct",
         }
-        
+
         symbol_kind = kind_map.get(name)
         if not symbol_kind:
             return None
@@ -76,23 +88,27 @@ class GoSymbolExtractor(TreeSitterExtractor):
         # 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()
+            if node.text is None:
+                return None
+            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)
+                match = re.search(r"const\s+(\w+)", node_text)
             elif symbol_kind == "var":
-                match = re.search(r'var\s+(\w+)', node_text)
+                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)
-            
+                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')
+            if node.text is None:
+                return None
+            symbol_name = node.text.decode("utf8")
 
         return Symbol(
             name=symbol_name,
@@ -105,78 +121,98 @@ class GoSymbolExtractor(TreeSitterExtractor):
 
 # --- 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
+            re.MULTILINE,
         )
-        
+
         # Handle single import: import "package"
-        single_import = re.compile(r'import\s+(?:"([^"]+)"|`([^`]+)`|(\w+)\s+(?:"([^"]+)"|`([^`]+)`))')
-        
+        single_import = re.compile(
+            r'import\s+(?:"([^"]+)"|`([^`]+)`|(\w+)\s+(?:"([^"]+)"|`([^`]+)`))'
+        )
+
         # Handle block import: import ( ... )
-        block_import = re.compile(r'import\s*\(([^)]+)\)', re.DOTALL)
-        
+        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'):
+            for line in block_content.split("\n"):
                 line = line.strip()
-                if not line or line.startswith('//'):
+                if not line or line.startswith("//"):
                     continue
                 # Extract package path
-                pkg_match = re.search(r'(?:"([^"]+)"|`([^`]+)`|(\w+)\s+(?:"([^"]+)"|`([^`]+)`))', line)
+                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)
+                    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,
-                    ))
+                    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)
+                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,
-                ))
-        
+                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'):
+                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:
+                    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
@@ -185,12 +221,12 @@ class GoDependencyAnalyzer(DependencyAnalyzer):
                         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')
+        return file_path.endswith(".go")
 
 
 class GoLanguageSupport(BaseLanguageSupport):
@@ -198,11 +234,11 @@ class GoLanguageSupport(BaseLanguageSupport):
 
     @property
     def language_name(self) -> str:
-        return 'go'
+        return "go"
 
     @property
     def file_extensions(self) -> Set[str]:
-        return {'.go'}
+        return {".go"}
 
     def create_symbol_extractor(self) -> Optional[SymbolExtractor]:
         try:
@@ -212,4 +248,3 @@ class GoLanguageSupport(BaseLanguageSupport):
 
     def create_dependency_analyzer(self) -> Optional[DependencyAnalyzer]:
         return GoDependencyAnalyzer()
-

jarvis/jarvis_code_agent/code_analyzer/languages/java_language.py

@@ -2,18 +2,28 @@
 
 import os
 import re
-from typing import List, Optional, Set
+from typing import List
+from typing import Optional
+from typing import Set
+from typing import cast
 
 from ..base_language import BaseLanguageSupport
-from ..dependency_analyzer import Dependency, DependencyAnalyzer, DependencyGraph
+from ..dependency_analyzer import Dependency
+from ..dependency_analyzer import DependencyAnalyzer
+from ..dependency_analyzer import DependencyGraph
 from ..file_ignore import filter_walk_dirs
-from ..symbol_extractor import Symbol, SymbolExtractor
+from ..symbol_extractor import Symbol
+from ..symbol_extractor import 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()
+    from tree_sitter import Language
+    from tree_sitter import Node
+
+    JAVA_LANGUAGE: Optional[Language] = cast(
+        Optional[Language], tree_sitter_java.language()
+    )
 except (ImportError, Exception):
     JAVA_LANGUAGE = None
 
@@ -52,13 +62,12 @@ class JavaSymbolExtractor(TreeSitterExtractor):
         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
+        lang = Language(JAVA_LANGUAGE)
         super().__init__(lang, JAVA_SYMBOL_QUERY)
 
-    def _create_symbol_from_capture(self, node: Node, name: str, file_path: str) -> Optional[Symbol]:
+    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",
@@ -69,13 +78,16 @@ class JavaSymbolExtractor(TreeSitterExtractor):
             "field.name": "field",
             "constructor.name": "constructor",
         }
-        
+
         symbol_kind = kind_map.get(name)
         if not symbol_kind:
             return None
 
+        if node.text is None:
+            return None
+
         return Symbol(
-            name=node.text.decode('utf8'),
+            name=node.text.decode("utf8"),
             kind=symbol_kind,
             file_path=file_path,
             line_start=node.start_point[0] + 1,
@@ -85,109 +97,131 @@ class JavaSymbolExtractor(TreeSitterExtractor):
 
 # --- 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
+            r"import\s+(?:static\s+)?([\w.]+)(?:\.\*)?\s*;", re.MULTILINE
         )
-        
-        for line_num, line in enumerate(content.split('\n'), start=1):
+
+        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('.')
+                    parts = module_path.split(".")
                     imported_symbol = None
-                    if len(parts) > 1 and not line.strip().endswith('.*;'):
+                    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,
-                    ))
-        
+                        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'):
+                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:
+                    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 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]:
+    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)
-        
+        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))
+            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))
+            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))
+            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'):
+                    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语言支持。"""
 
@@ -197,7 +231,7 @@ class JavaLanguageSupport(BaseLanguageSupport):
 
     @property
     def file_extensions(self) -> Set[str]:
-        return {'.java'}
+        return {".java"}
 
     def create_symbol_extractor(self) -> Optional[SymbolExtractor]:
         if not JAVA_LANGUAGE:
@@ -209,4 +243,3 @@ class JavaLanguageSupport(BaseLanguageSupport):
 
     def create_dependency_analyzer(self) -> Optional[DependencyAnalyzer]:
         return JavaDependencyAnalyzer()
-