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

jarvis/jarvis_code_agent/code_analyzer/languages/javascript_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_javascript
-    JS_LANGUAGE: Optional[Language] = tree_sitter_javascript.language()
+    from tree_sitter import Language
+    from tree_sitter import Node
+
+    JS_LANGUAGE: Optional[Language] = cast(
+        Optional[Language], tree_sitter_javascript.language()
+    )
 except (ImportError, Exception):
     JS_LANGUAGE = None
 
@@ -57,13 +67,12 @@ class JavaScriptSymbolExtractor(TreeSitterExtractor):
         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
+        lang = Language(JS_LANGUAGE)
         super().__init__(lang, JS_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",
@@ -73,7 +82,7 @@ class JavaScriptSymbolExtractor(TreeSitterExtractor):
             "class.name": "class",
             "variable.name": "variable",
         }
-        
+
         symbol_kind = kind_map.get(name)
         if not symbol_kind:
             return None
@@ -83,10 +92,14 @@ class JavaScriptSymbolExtractor(TreeSitterExtractor):
             symbol_name = "<anonymous_arrow_function>"
         elif name == "generator.name":
             # Generator functions are also functions
-            symbol_name = node.text.decode('utf8')
+            if node.text is None:
+                return None
+            symbol_name = node.text.decode("utf8")
         else:
-            symbol_name = node.text.decode('utf8')
-        
+            if node.text is None:
+                return None
+            symbol_name = node.text.decode("utf8")
+
         if not symbol_name:
             return None
 
@@ -101,31 +114,32 @@ class JavaScriptSymbolExtractor(TreeSitterExtractor):
 
 # --- 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
+            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
+            re.MULTILINE,
         )
-        
-        for line_num, line in enumerate(content.split('\n'), start=1):
+
+        for line_num, line in enumerate(content.split("\n"), start=1):
             # Check for ES6 imports
             import_match = import_pattern.search(line)
             if import_match:
@@ -134,95 +148,111 @@ class JavaScriptDependencyAnalyzer(DependencyAnalyzer):
                     # 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('{'):
+                    if symbols_group and symbols_group.startswith("{"):
                         # Extract first symbol from { symbol1, symbol2 }
-                        symbol_match = re.search(r'\{([^}]+)\}', symbols_group)
+                        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,
-                    ))
-            
+                            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,
-                    ))
-        
+                    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')):
+                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:
+                    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.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]:
+    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('.'):
+        if module_name.startswith("."):
             base_dir = os.path.dirname(from_file)
             # Resolve relative path
-            if module_name.endswith('.js') or module_name.endswith('.jsx'):
+            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'))
+                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'))
+                    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'))
-            
+                    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 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
@@ -230,6 +260,7 @@ class JavaScriptDependencyAnalyzer(DependencyAnalyzer):
 
 # --- JavaScript Language Support ---
 
+
 class JavaScriptLanguageSupport(BaseLanguageSupport):
     """JavaScript语言支持。"""
 
@@ -239,7 +270,7 @@ class JavaScriptLanguageSupport(BaseLanguageSupport):
 
     @property
     def file_extensions(self) -> Set[str]:
-        return {'.js', '.jsx', '.mjs', '.cjs'}
+        return {".js", ".jsx", ".mjs", ".cjs"}
 
     def create_symbol_extractor(self) -> Optional[SymbolExtractor]:
         if not JS_LANGUAGE:
@@ -251,4 +282,3 @@ class JavaScriptLanguageSupport(BaseLanguageSupport):
 
     def create_dependency_analyzer(self) -> Optional[DependencyAnalyzer]:
         return JavaScriptDependencyAnalyzer()
-

jarvis/jarvis_code_agent/code_analyzer/languages/python_language.py

@@ -2,12 +2,18 @@
 
 import ast
 import os
-from typing import List, Optional, Set, Union
+from typing import List
+from typing import Optional
+from typing import Set
+from typing import Union
 
 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
 
 
 class PythonSymbolExtractor(SymbolExtractor):
@@ -19,10 +25,10 @@ class PythonSymbolExtractor(SymbolExtractor):
             # 对于超大文件，限制解析内容长度（避免内存和性能问题）
             # 只解析前 50000 行，通常足够提取主要符号
             max_lines = 50000
-            lines = content.split('\n')
+            lines = content.split("\n")
             if len(lines) > max_lines:
-                content = '\n'.join(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:
@@ -33,7 +39,13 @@ class PythonSymbolExtractor(SymbolExtractor):
             pass
         return symbols
 
-    def _traverse_node(self, node: ast.AST, file_path: str, symbols: List[Symbol], parent_name: Optional[str]):
+    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:
@@ -41,7 +53,7 @@ class PythonSymbolExtractor(SymbolExtractor):
                     if isinstance(decorator, ast.Name):
                         decorator_symbol = Symbol(
                             name=decorator.id,
-                            kind='decorator',
+                            kind="decorator",
                             file_path=file_path,
                             line_start=decorator.lineno,
                             line_end=decorator.lineno,
@@ -58,14 +70,16 @@ class PythonSymbolExtractor(SymbolExtractor):
                     if isinstance(decorator, ast.Name):
                         decorator_symbol = Symbol(
                             name=decorator.id,
-                            kind='decorator',
+                            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)
+            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):
@@ -75,7 +89,7 @@ class PythonSymbolExtractor(SymbolExtractor):
                     if isinstance(decorator, ast.Name):
                         decorator_symbol = Symbol(
                             name=decorator.id,
-                            kind='decorator',
+                            kind="decorator",
                             file_path=file_path,
                             line_start=decorator.lineno,
                             line_end=decorator.lineno,
@@ -86,16 +100,24 @@ class PythonSymbolExtractor(SymbolExtractor):
             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))
+            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:
+    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',
+            kind="function",
             file_path=file_path,
             line_start=node.lineno,
             line_end=node.end_lineno or node.lineno,
@@ -104,28 +126,37 @@ class PythonSymbolExtractor(SymbolExtractor):
             parent=parent,
         )
 
-    def _create_symbol_from_class(self, node: ast.ClassDef, file_path: str, parent: Optional[str]) -> Symbol:
+    def _create_symbol_from_class(
+        self, node: ast.ClassDef, file_path: str, parent: Optional[str]
+    ) -> Symbol:
         return Symbol(
             name=node.name,
-            kind='class',
+            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]:
+
+    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,
-            ))
+            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
 
 
@@ -135,119 +166,127 @@ class PythonDependencyAnalyzer(DependencyAnalyzer):
     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,
-                        ))
+                        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,
-                        ))
+                        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'):
+                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:
+                    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)
+                        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]:
+    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('.'):
+        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 == ''])
+            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')
+                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'
+            elif os.path.exists(module_path + ".py"):
+                return module_path + ".py"
         else:
             # Absolute import
-            parts = module_name.split('.')
-            
+            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')
+                        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'
+                    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')
+        return file_path.endswith(".py")
 
 
 class PythonLanguageSupport(BaseLanguageSupport):
@@ -255,15 +294,14 @@ class PythonLanguageSupport(BaseLanguageSupport):
 
     @property
     def language_name(self) -> str:
-        return 'python'
+        return "python"
 
     @property
     def file_extensions(self) -> Set[str]:
-        return {'.py', '.pyw', '.pyi'}
+        return {".py", ".pyw", ".pyi"}
 
     def create_symbol_extractor(self) -> Optional[SymbolExtractor]:
         return PythonSymbolExtractor()
 
     def create_dependency_analyzer(self) -> Optional[DependencyAnalyzer]:
         return PythonDependencyAnalyzer()
-