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

jarvis/jarvis_code_agent/code_analyzer/languages/rust_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
 
-
 # --- Rust Symbol Query ---
 
 RUST_SYMBOL_QUERY = """
@@ -49,8 +55,6 @@ RUST_SYMBOL_QUERY = """
 (type_item
   name: (type_identifier) @type.name)
 
-(extern_block) @extern
-
 (attribute_item) @attribute
 """
 
@@ -58,13 +62,17 @@ RUST_SYMBOL_QUERY = """
 
 try:
     import tree_sitter_rust
-    RUST_LANGUAGE: Optional[Language] = tree_sitter_rust.language()
+
+    RUST_LANGUAGE: Optional[Language] = cast(
+        Optional[Language], tree_sitter_rust.language()
+    )
 except (ImportError, Exception):
     RUST_LANGUAGE = None
 
 
 # --- Rust Symbol Extractor ---
 
+
 class RustSymbolExtractor(TreeSitterExtractor):
     """Extracts symbols from Rust code using tree-sitter."""
 
@@ -73,7 +81,9 @@ class RustSymbolExtractor(TreeSitterExtractor):
             raise RuntimeError("Rust tree-sitter grammar not available.")
         super().__init__(RUST_LANGUAGE, RUST_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",
@@ -90,7 +100,7 @@ class RustSymbolExtractor(TreeSitterExtractor):
             "extern": "extern",
             "attribute": "attribute",
         }
-        
+
         symbol_kind = kind_map.get(name)
         if not symbol_kind:
             return None
@@ -98,44 +108,56 @@ class RustSymbolExtractor(TreeSitterExtractor):
         # 对于 attribute，提取属性内容作为名称
         if symbol_kind == "attribute":
             # 提取属性文本
-            attr_text = node.text.decode('utf8').strip()
+            if node.text is None:
+                return None
+            attr_text = node.text.decode("utf8").strip()
             # 移除开头的 # 或 #!
-            if attr_text.startswith('#!'):
+            if attr_text.startswith("#!"):
                 attr_text = attr_text[2:].strip()
-            elif attr_text.startswith('#'):
+            elif attr_text.startswith("#"):
                 attr_text = attr_text[1:].strip()
             # 移除外层的 []
-            if attr_text.startswith('[') and attr_text.endswith(']'):
+            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()
-            
+            attr_name = (
+                attr_text.split("(")[0]
+                .split("[")[0]
+                .split("=")[0]
+                .split(",")[0]
+                .strip()
+            )
+
             # 如果属性名称为空或只包含空白，使用整个属性文本（去掉括号）
-            if not attr_name or attr_name == '':
+            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()
+            if node.text is None:
+                return None
+            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]}"
+                    symbol_name = f"extern_{extern_text[start + 1 : end]}"
                 else:
                     symbol_name = "extern"
             else:
                 symbol_name = "extern"
         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,
@@ -148,101 +170,114 @@ class RustSymbolExtractor(TreeSitterExtractor):
 
 # --- Rust Dependency Analyzer ---
 
+
 class RustDependencyAnalyzer(DependencyAnalyzer):
     """Analyzes Rust use and mod dependencies."""
 
     def analyze_imports(self, file_path: str, content: str) -> List[Dependency]:
         """Analyzes Rust use and mod statements."""
         dependencies: List[Dependency] = []
-        
+
         # Match use statements: use crate::module or use std::collections
-        use_pattern = re.compile(r'use\s+([^;]+);')
-        
+        use_pattern = re.compile(r"use\s+([^;]+);")
+
         # Match mod declarations: mod module_name;
-        mod_pattern = re.compile(r'mod\s+(\w+)\s*;')
-        
-        for line_num, line in enumerate(content.split('\n'), start=1):
+        mod_pattern = re.compile(r"mod\s+(\w+)\s*;")
+
+        for line_num, line in enumerate(content.split("\n"), start=1):
             # Check for use statements
             use_match = use_pattern.search(line)
             if use_match:
                 use_path = use_match.group(1).strip()
                 # Extract the crate/module name
-                parts = use_path.split('::')
+                parts = use_path.split("::")
                 if parts:
                     crate_name = parts[0]
-                    symbol = '::'.join(parts[1:]) if len(parts) > 1 else None
-                    dependencies.append(Dependency(
-                        from_module=crate_name,
-                        imported_symbol=symbol,
-                        file_path=file_path,
-                        line=line_num,
-                    ))
-            
+                    symbol = "::".join(parts[1:]) if len(parts) > 1 else None
+                    dependencies.append(
+                        Dependency(
+                            from_module=crate_name,
+                            imported_symbol=symbol,
+                            file_path=file_path,
+                            line=line_num,
+                        )
+                    )
+
             # Check for mod declarations
             mod_match = mod_pattern.search(line)
             if mod_match:
                 mod_name = mod_match.group(1)
-                dependencies.append(Dependency(
-                    from_module=mod_name,
-                    imported_symbol=None,
-                    file_path=file_path,
-                    line=line_num,
-                ))
-        
+                dependencies.append(
+                    Dependency(
+                        from_module=mod_name,
+                        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 Rust 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('.rs'):
+                if not file.endswith(".rs"):
                     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 Rust, resolve mod declarations to file paths
-                        if not dep.from_module.startswith(('std', 'core', 'alloc', 'proc_macro')):
+                        if not dep.from_module.startswith(
+                            ("std", "core", "alloc", "proc_macro")
+                        ):
                             # Try to resolve local modules
-                            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 Rust module name to a file path."""
         # Rust modules can be:
         # 1. mod.rs in a directory
         # 2. module_name.rs in the same directory
         # 3. module_name/mod.rs
-        
+
         base_dir = os.path.dirname(from_file)
-        
+
         # Try module_name.rs in same directory
         module_file = os.path.join(base_dir, f"{module_name}.rs")
         if os.path.exists(module_file):
             return module_file
-        
+
         # Try module_name/mod.rs
         module_dir = os.path.join(base_dir, module_name)
         mod_rs = os.path.join(module_dir, "mod.rs")
         if os.path.exists(mod_rs):
             return mod_rs
-        
+
         # Try in parent directories (for nested modules)
         current_dir = base_dir
-        while current_dir != project_root and current_dir != os.path.dirname(current_dir):
+        while current_dir != project_root and current_dir != os.path.dirname(
+            current_dir
+        ):
             module_file = os.path.join(current_dir, f"{module_name}.rs")
             if os.path.exists(module_file):
                 return module_file
@@ -251,12 +286,12 @@ class RustDependencyAnalyzer(DependencyAnalyzer):
             if os.path.exists(mod_rs):
                 return mod_rs
             current_dir = os.path.dirname(current_dir)
-        
+
         return None
 
     def _is_source_file(self, file_path: str) -> bool:
         """Check if a file is a Rust source file."""
-        return file_path.endswith('.rs')
+        return file_path.endswith(".rs")
 
 
 class RustLanguageSupport(BaseLanguageSupport):
@@ -264,11 +299,11 @@ class RustLanguageSupport(BaseLanguageSupport):
 
     @property
     def language_name(self) -> str:
-        return 'rust'
+        return "rust"
 
     @property
     def file_extensions(self) -> Set[str]:
-        return {'.rs'}
+        return {".rs"}
 
     def create_symbol_extractor(self) -> Optional[SymbolExtractor]:
         try:
@@ -278,4 +313,3 @@ class RustLanguageSupport(BaseLanguageSupport):
 
     def create_dependency_analyzer(self) -> Optional[DependencyAnalyzer]:
         return RustDependencyAnalyzer()
-

jarvis/jarvis_code_agent/code_analyzer/languages/typescript_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_typescript
-    TS_LANGUAGE: Optional[Language] = tree_sitter_typescript.language_typescript()
+    from tree_sitter import Language
+    from tree_sitter import Node
+
+    TS_LANGUAGE: Optional[Language] = cast(
+        Optional[Language], tree_sitter_typescript.language_typescript()
+    )
 except (ImportError, Exception):
     TS_LANGUAGE = None
 
@@ -71,13 +81,12 @@ class TypeScriptSymbolExtractor(TreeSitterExtractor):
         if not TS_LANGUAGE:
             raise RuntimeError("TypeScript tree-sitter grammar not available.")
         # 如果传入的是 PyCapsule，需要转换为 Language 对象
-        if not isinstance(TS_LANGUAGE, Language):
-            lang = Language(TS_LANGUAGE)
-        else:
-            lang = TS_LANGUAGE
+        lang = Language(TS_LANGUAGE)
         super().__init__(lang, TS_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",
@@ -92,7 +101,7 @@ class TypeScriptSymbolExtractor(TreeSitterExtractor):
             "variable.name": "variable",
             "decorator": "decorator",
         }
-        
+
         symbol_kind = kind_map.get(name)
         if not symbol_kind:
             return None
@@ -102,16 +111,22 @@ class TypeScriptSymbolExtractor(TreeSitterExtractor):
             symbol_name = "<anonymous_arrow_function>"
         elif name == "decorator":
             # Extract decorator name (e.g., @Component -> Component)
-            decorator_text = node.text.decode('utf8').strip()
-            if decorator_text.startswith('@'):
-                symbol_name = decorator_text[1:].split('(')[0].strip()
+            if node.text is None:
+                return None
+            decorator_text = node.text.decode("utf8").strip()
+            if decorator_text.startswith("@"):
+                symbol_name = decorator_text[1:].split("(")[0].strip()
             else:
-                symbol_name = decorator_text.split('(')[0].strip()
+                symbol_name = decorator_text.split("(")[0].strip()
         elif name == "generator.name":
-            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
 
@@ -126,13 +141,14 @@ class TypeScriptSymbolExtractor(TreeSitterExtractor):
 
 # --- TypeScript Dependency Analyzer ---
 
+
 class TypeScriptDependencyAnalyzer(DependencyAnalyzer):
     """Analyzes TypeScript import dependencies."""
 
     def analyze_imports(self, file_path: str, content: str) -> List[Dependency]:
         """Analyzes TypeScript import statements."""
         dependencies: List[Dependency] = []
-        
+
         # ES6 import statements (same as JavaScript)
         # import module from 'path'
         # import { symbol } from 'path'
@@ -140,16 +156,16 @@ class TypeScriptDependencyAnalyzer(DependencyAnalyzer):
         # import type { Type } from 'path'
         import_pattern = re.compile(
             r'import\s+(?:type\s+)?(?:(?:\*\s+as\s+(\w+)|(\{[^}]*\})|(\w+))\s+from\s+)?["\']([^"\']+)["\']',
-            re.MULTILINE
+            re.MULTILINE,
         )
-        
+
         # CommonJS require statements
         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:
@@ -158,97 +174,115 @@ class TypeScriptDependencyAnalyzer(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 TypeScript 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(('.ts', '.tsx', '.cts', '.mts')):
+                if not file.endswith((".ts", ".tsx", ".cts", ".mts")):
                     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 TypeScript 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(('.ts', '.tsx')):
+            if module_name.endswith((".ts", ".tsx")):
                 # Direct file reference
                 resolved = os.path.normpath(os.path.join(base_dir, module_name))
             else:
                 # Try with .ts extension
-                resolved = os.path.normpath(os.path.join(base_dir, module_name + '.ts'))
+                resolved = os.path.normpath(os.path.join(base_dir, module_name + ".ts"))
                 if not os.path.exists(resolved):
                     # Try with .tsx extension
-                    resolved = os.path.normpath(os.path.join(base_dir, module_name + '.tsx'))
+                    resolved = os.path.normpath(
+                        os.path.join(base_dir, module_name + ".tsx")
+                    )
                 if not os.path.exists(resolved):
                     # Try index.ts
-                    resolved = os.path.normpath(os.path.join(base_dir, module_name, 'index.ts'))
+                    resolved = os.path.normpath(
+                        os.path.join(base_dir, module_name, "index.ts")
+                    )
                     if not os.path.exists(resolved):
-                        resolved = os.path.normpath(os.path.join(base_dir, module_name, 'index.tsx'))
-            
+                        resolved = os.path.normpath(
+                            os.path.join(base_dir, module_name, "index.tsx")
+                        )
+
             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(('.ts', '.tsx')):
-                resolved += '.ts'
+        if module_name.startswith("/"):
+            resolved = os.path.normpath(
+                os.path.join(project_root, module_name.lstrip("/"))
+            )
+            if not resolved.endswith((".ts", ".tsx")):
+                resolved += ".ts"
             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
@@ -256,6 +290,7 @@ class TypeScriptDependencyAnalyzer(DependencyAnalyzer):
 
 # --- TypeScript Language Support ---
 
+
 class TypeScriptLanguageSupport(BaseLanguageSupport):
     """TypeScript语言支持。"""
 
@@ -265,7 +300,7 @@ class TypeScriptLanguageSupport(BaseLanguageSupport):
 
     @property
     def file_extensions(self) -> Set[str]:
-        return {'.ts', '.tsx', '.cts', '.mts'}
+        return {".ts", ".tsx", ".cts", ".mts"}
 
     def create_symbol_extractor(self) -> Optional[SymbolExtractor]:
         if not TS_LANGUAGE:
@@ -277,4 +312,3 @@ class TypeScriptLanguageSupport(BaseLanguageSupport):
 
     def create_dependency_analyzer(self) -> Optional[DependencyAnalyzer]:
         return TypeScriptDependencyAnalyzer()
-