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

jarvis/jarvis_code_agent/code_analyzer/symbol_extractor.py

@@ -1,12 +1,15 @@
 import json
 import os
 from dataclasses import dataclass
-from typing import Dict, List, Optional
+from typing import Dict
+from typing import List
+from typing import Optional
 
 
 @dataclass
 class Symbol:
     """表示代码中的单个符号。"""
+
     name: str
     kind: str  # 例如：'function'(函数)、'class'(类)、'variable'(变量)、'import'(导入)
     file_path: str
@@ -17,7 +20,7 @@ class Symbol:
     # 根据需要添加更多字段，例如父作用域
     parent: Optional[str] = None
     # 定义位置（对于引用/调用，指向符号定义的位置）
-    definition_location: Optional['Symbol'] = None  # 指向定义Symbol的引用
+    definition_location: Optional["Symbol"] = None  # 指向定义Symbol的引用
     is_definition: bool = False  # 如果此符号是定义则为True，如果是引用/调用则为False
 
 
@@ -46,13 +49,17 @@ class SymbolTable:
         cache_file = self._get_cache_file()
         if os.path.exists(cache_file):
             try:
-                with open(cache_file, 'r', encoding='utf-8') as f:
+                with open(cache_file, "r", encoding="utf-8") as f:
                     data = json.load(f)
                 # 将JSON数据转换回Symbol对象
-                self.symbols_by_name = self._deserialize_symbols(data.get('symbols_by_name', {}))
-                self.symbols_by_file = self._deserialize_symbols(data.get('symbols_by_file', {}))
+                self.symbols_by_name = self._deserialize_symbols(
+                    data.get("symbols_by_name", {})
+                )
+                self.symbols_by_file = self._deserialize_symbols(
+                    data.get("symbols_by_file", {})
+                )
                 # 加载文件修改时间
-                self._file_mtimes = data.get('file_mtimes', {})
+                self._file_mtimes = data.get("file_mtimes", {})
             except Exception:
                 # 如果缓存加载失败，则从空表开始
                 pass
@@ -63,88 +70,94 @@ class SymbolTable:
             # 确保缓存目录存在
             os.makedirs(self.cache_dir, exist_ok=True)
             cache_file = self._get_cache_file()
-            
+
             # 保存前更新文件修改时间
             self._update_file_mtimes()
-            
+
             # 序列化符号以便JSON存储
             data = {
-                'symbols_by_name': self._serialize_symbols(self.symbols_by_name),
-                'symbols_by_file': self._serialize_symbols(self.symbols_by_file),
-                'file_mtimes': self._file_mtimes
+                "symbols_by_name": self._serialize_symbols(self.symbols_by_name),
+                "symbols_by_file": self._serialize_symbols(self.symbols_by_file),
+                "file_mtimes": self._file_mtimes,
             }
-            
-            with open(cache_file, 'w', encoding='utf-8') as f:
+
+            with open(cache_file, "w", encoding="utf-8") as f:
                 json.dump(data, f, indent=2, ensure_ascii=False)
         except Exception:
             # 如果缓存保存失败，则继续而不缓存
             pass
 
-    def _serialize_symbols(self, symbol_dict: Dict[str, List[Symbol]]) -> Dict[str, List[dict]]:
+    def _serialize_symbols(
+        self, symbol_dict: Dict[str, List[Symbol]]
+    ) -> Dict[str, List[dict]]:
         """将Symbol对象转换为可序列化的字典。"""
         serialized = {}
         for key, symbols in symbol_dict.items():
             serialized[key] = [self._symbol_to_dict(symbol) for symbol in symbols]
         return serialized
 
-    def _deserialize_symbols(self, symbol_dict: Dict[str, List[dict]]) -> Dict[str, List[Symbol]]:
+    def _deserialize_symbols(
+        self, symbol_dict: Dict[str, List[dict]]
+    ) -> Dict[str, List[Symbol]]:
         """将序列化的字典转换回Symbol对象。"""
         deserialized = {}
         for key, symbol_data_list in symbol_dict.items():
-            deserialized[key] = [self._dict_to_symbol(data) for data in symbol_data_list]
+            deserialized[key] = [
+                self._dict_to_symbol(data) for data in symbol_data_list
+            ]
         return deserialized
 
     def _symbol_to_dict(self, symbol: Symbol) -> dict:
         """将Symbol对象转换为字典。"""
         result = {
-            'name': symbol.name,
-            'kind': symbol.kind,
-            'file_path': symbol.file_path,
-            'line_start': symbol.line_start,
-            'line_end': symbol.line_end,
-            'signature': symbol.signature,
-            'docstring': symbol.docstring,
-            'parent': symbol.parent,
-            'is_definition': getattr(symbol, 'is_definition', False),
+            "name": symbol.name,
+            "kind": symbol.kind,
+            "file_path": symbol.file_path,
+            "line_start": symbol.line_start,
+            "line_end": symbol.line_end,
+            "signature": symbol.signature,
+            "docstring": symbol.docstring,
+            "parent": symbol.parent,
+            "is_definition": getattr(symbol, "is_definition", False),
         }
         # 序列化定义位置（只保存基本信息，避免循环引用）
-        if hasattr(symbol, 'definition_location') and symbol.definition_location:
-            result['definition_location'] = {
-                'file_path': symbol.definition_location.file_path,
-                'line_start': symbol.definition_location.line_start,
-                'line_end': symbol.definition_location.line_end,
-                'name': symbol.definition_location.name,
+        if hasattr(symbol, "definition_location") and symbol.definition_location:
+            result["definition_location"] = {
+                "file_path": symbol.definition_location.file_path,
+                "line_start": symbol.definition_location.line_start,
+                "line_end": symbol.definition_location.line_end,
+                "name": symbol.definition_location.name,
             }
         return result
 
     def _dict_to_symbol(self, data: dict) -> Symbol:
         """将字典转换回Symbol对象。"""
         symbol = Symbol(
-            name=data['name'],
-            kind=data['kind'],
-            file_path=data['file_path'],
-            line_start=data['line_start'],
-            line_end=data['line_end'],
-            signature=data.get('signature'),
-            docstring=data.get('docstring'),
-            parent=data.get('parent'),
-            is_definition=data.get('is_definition', False),
+            name=data["name"],
+            kind=data["kind"],
+            file_path=data["file_path"],
+            line_start=data["line_start"],
+            line_end=data["line_end"],
+            signature=data.get("signature"),
+            docstring=data.get("docstring"),
+            parent=data.get("parent"),
+            is_definition=data.get("is_definition", False),
         )
         # 恢复定义位置（创建临时 Symbol 对象）
-        if 'definition_location' in data and data['definition_location']:
-            def_loc = data['definition_location']
+        if "definition_location" in data and data["definition_location"]:
+            def_loc = data["definition_location"]
             symbol.definition_location = Symbol(
-                name=def_loc['name'],
-                kind='',  # 未知类型
-                file_path=def_loc['file_path'],
-                line_start=def_loc['line_start'],
-                line_end=def_loc['line_end'],
+                name=def_loc["name"],
+                kind="",  # 未知类型
+                file_path=def_loc["file_path"],
+                line_start=def_loc["line_start"],
+                line_end=def_loc["line_end"],
             )
         return symbol
 
     def add_symbol(self, symbol: Symbol, save_to_cache: bool = False):
         """向表中添加符号。
-        
+
         参数:
             symbol: 要添加的符号
             save_to_cache: 如果为True，立即保存到缓存。默认为False以提高性能。
@@ -157,11 +170,11 @@ class SymbolTable:
         if symbol.file_path not in self.symbols_by_file:
             self.symbols_by_file[symbol.file_path] = []
         self.symbols_by_file[symbol.file_path].append(symbol)
-        
+
         # 仅在明确请求时保存到缓存（出于性能考虑）
         if save_to_cache:
             self._save_to_cache()
-    
+
     def save_cache(self):
         """将整个符号表保存到缓存。批量操作后调用此方法。"""
         self._save_to_cache()
@@ -172,9 +185,7 @@ class SymbolTable:
         如果提供了file_path，则搜索仅限于该文件。
         """
         if file_path:
-            return [
-                s for s in self.get_file_symbols(file_path) if s.name == name
-            ]
+            return [s for s in self.get_file_symbols(file_path) if s.name == name]
         return self.symbols_by_name.get(name, [])
 
     def get_file_symbols(self, file_path: str) -> List[Symbol]:
@@ -188,19 +199,20 @@ class SymbolTable:
             for symbol in symbols_to_remove:
                 if symbol.name in self.symbols_by_name:
                     self.symbols_by_name[symbol.name] = [
-                        s for s in self.symbols_by_name[symbol.name]
+                        s
+                        for s in self.symbols_by_name[symbol.name]
                         if s.file_path != file_path
                     ]
                     if not self.symbols_by_name[symbol.name]:
                         del self.symbols_by_name[symbol.name]
-            
+
             # 移除文件修改时间跟踪
             if file_path in self._file_mtimes:
                 del self._file_mtimes[file_path]
-            
+
             # 清除后保存到缓存
             self._save_to_cache()
-    
+
     def _update_file_mtimes(self):
         """更新所有跟踪文件的修改时间。"""
         for file_path in list(self.symbols_by_file.keys()):
@@ -210,28 +222,28 @@ class SymbolTable:
                 except Exception:
                     # 如果无法获取修改时间，则从跟踪中移除
                     self._file_mtimes.pop(file_path, None)
-    
+
     def is_file_stale(self, file_path: str) -> bool:
         """检查文件自缓存后是否已被修改。
-        
+
         参数:
             file_path: 要检查的文件路径
-            
+
         返回:
             如果文件比缓存新则为True，否则为False
         """
         if file_path not in self.symbols_by_file:
             # 文件不在缓存中，视为已过期（需要加载）
             return True
-        
+
         if file_path not in self._file_mtimes:
             # 没有记录修改时间，视为已过期
             return True
-        
+
         if not os.path.exists(file_path):
             # 文件不存在，不算过期（将由clear_file_symbols处理）
             return False
-        
+
         try:
             current_mtime = os.path.getmtime(file_path)
             cached_mtime = self._file_mtimes.get(file_path, 0)
@@ -249,4 +261,4 @@ class SymbolExtractor:
         从代码中提取符号（函数、类、变量等）。
         此方法应由特定语言的子类实现。
         """
-        raise NotImplementedError("Subclasses must implement this method.")
+        raise NotImplementedError("Subclasses must implement this method.")

jarvis/jarvis_code_agent/code_analyzer/tree_sitter_extractor.py

@@ -1,9 +1,17 @@
 from abc import abstractmethod
-from typing import List, Optional
+from typing import List
+from typing import Optional
 
-from tree_sitter import Language, Parser, Node, Query, QueryCursor
+from tree_sitter import Language
+from tree_sitter import Node
+from tree_sitter import Parser
+from tree_sitter import Query
+from tree_sitter import QueryCursor
 
-from .symbol_extractor import Symbol, SymbolExtractor
+from jarvis.jarvis_utils.output import PrettyOutput
+
+from .symbol_extractor import Symbol
+from .symbol_extractor import SymbolExtractor
 
 
 class TreeSitterExtractor(SymbolExtractor):
@@ -14,45 +22,110 @@ class TreeSitterExtractor(SymbolExtractor):
     """
 
     def __init__(self, language: Language, symbol_query: str):
-        # 如果传入的是 PyCapsule，需要转换为 Language 对象
-        if not isinstance(language, Language):
-            language = Language(language)
         self.language = language
         self.parser = Parser()
-        # 使用 language 属性而不是 set_language 方法
-        self.parser.language = self.language
+        # 设置language（tree-sitter的Parser需要Language对象）
+        try:
+            # 尝试使用set_language方法（如果可用）
+            if hasattr(self.parser, "set_language"):
+                self.parser.set_language(self.language)
+            else:
+                # 否则直接赋值language属性
+                self.parser.language = self.language
+        except (AttributeError, TypeError):
+            # 如果都失败，尝试创建Language对象
+            try:
+                from tree_sitter import Language as LangClass
+
+                try:
+                    lang_obj = LangClass(language)
+                    self.parser.language = lang_obj
+                    self.language = lang_obj
+                except Exception:
+                    self.parser.language = language
+            except Exception:
+                # 最后的fallback：直接赋值
+                self.parser.language = language
         self.symbol_query = symbol_query
 
     def extract_symbols(self, file_path: str, content: str) -> List[Symbol]:
         """
         Parses the code with tree-sitter and extracts symbols based on the query.
         """
+        # 检查内容是否为空或只包含空白
+        if not content or not content.strip():
+            return []
+
+        symbols = []
+
         try:
+            # 解析代码（即使有语法错误，tree-sitter也能部分解析）
             tree = self.parser.parse(bytes(content, "utf8"))
-            # 使用 Query 构造函数（新 API）
-            query = Query(self.language, self.symbol_query)
+
+            # 检查解析是否成功（tree.root_node 应该存在）
+            if tree is None or tree.root_node is None:
+                return []
+
+            # 尝试构造查询
+            query = None
+            try:
+                query = Query(self.language, self.symbol_query)
+            except Exception as query_error:
+                # Query 构造失败（可能是查询语法问题），静默返回空列表
+                import os
+
+                if os.getenv("DEBUG_TREE_SITTER", "").lower() in ("1", "true", "yes"):
+                    PrettyOutput.auto_print(
+                        f"Error creating query for {file_path}: {query_error}"
+                    )
+                return []
+
             # 使用 QueryCursor 执行查询
+            # 即使有语法错误，tree-sitter也能部分解析，所以可以提取部分符号
             cursor = QueryCursor(query)
             matches = cursor.matches(tree.root_node)
-            
-            symbols = []
+
             # matches 返回格式: [(pattern_index, {capture_name: [nodes]})]
             for pattern_index, captures_dict in matches:
                 for capture_name, nodes in captures_dict.items():
                     for node in nodes:
-                        symbol = self._create_symbol_from_capture(node, capture_name, file_path)
-                        if symbol:
-                            symbols.append(symbol)
+                        try:
+                            # 跳过错误节点（tree-sitter会用ERROR节点标记语法错误）
+                            # 错误节点通常没有有效的文本内容或位置信息
+                            if node.type == "ERROR":
+                                continue
+
+                            symbol = self._create_symbol_from_capture(
+                                node, capture_name, file_path
+                            )
+                            if symbol:
+                                symbols.append(symbol)
+                        except Exception:
+                            # 单个符号提取失败，继续处理其他符号
+                            # 这样可以确保即使部分符号提取失败，也能返回已成功提取的符号
+                            continue
+
+            # 即使有语法错误，也返回已成功提取的符号
             return symbols
         except Exception as e:
-            print(f"Error extracting symbols from {file_path} with tree-sitter: {e}")
-            return []
+            # 如果解析完全失败（不是语法错误，而是其他严重错误），返回空列表
+            # 只在调试模式下打印错误信息
+            import os
+
+            if os.getenv("DEBUG_TREE_SITTER", "").lower() in ("1", "true", "yes"):
+                PrettyOutput.auto_print(
+                    f"Error extracting symbols from {file_path} with tree-sitter: {e}"
+                )
+            # 即使解析失败，也返回已提取的符号（如果有的话）
+            return symbols
 
     @abstractmethod
-    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]:
         """
         Creates a Symbol object from a tree-sitter query capture.
         This method must be implemented by subclasses to map capture names
         (e.g., "function.name") to Symbol attributes.
         """
-        raise NotImplementedError
+        raise NotImplementedError