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

jarvis/jarvis_code_agent/code_analyzer/context_manager.py

@@ -1,7 +1,7 @@
 import os
 import re
 from dataclasses import dataclass, field
-from typing import List, Optional, Set
+from typing import Any, List, Optional, Set
 
 from .dependency_analyzer import DependencyGraph
 from .file_ignore import filter_walk_dirs
@@ -36,7 +36,9 @@ class ContextManager:
 
     def __init__(self, project_root: str):
         self.project_root = project_root
-        self.symbol_table = SymbolTable()
+        # Create cache directory path relative to project root
+        cache_dir = os.path.join(project_root, ".jarvis", "symbol_cache")
+        self.symbol_table = SymbolTable(cache_dir)
         self.dependency_graph = DependencyGraph()
         self._file_cache: dict[str, str] = {}  # Cache file contents
 
@@ -94,6 +96,10 @@ class ContextManager:
         """
         references: List[Reference] = []
         
+        # Check if file is stale and update if needed
+        if file_path and self.symbol_table.is_file_stale(file_path):
+            self._refresh_file_symbols(file_path)
+        
         # Find symbol definitions
         symbols = self.symbol_table.find_symbol(symbol_name, file_path)
         if not symbols:
@@ -114,6 +120,10 @@ class ContextManager:
         
         # Search for references in each file
         for file_path_to_search in search_files:
+            # Check if file is stale and update if needed
+            if self.symbol_table.is_file_stale(file_path_to_search):
+                self._refresh_file_symbols(file_path_to_search)
+            
             content = self._get_file_content(file_path_to_search)
             if not content:
                 continue
@@ -158,6 +168,10 @@ class ContextManager:
         Returns:
             Symbol object if found, None otherwise
         """
+        # Check if file is stale and update if needed
+        if file_path and self.symbol_table.is_file_stale(file_path):
+            self._refresh_file_symbols(file_path)
+        
         symbols = self.symbol_table.find_symbol(symbol_name, file_path)
         if symbols:
             # Return the first definition (could be enhanced to find the most relevant one)
@@ -186,6 +200,13 @@ class ContextManager:
             symbols = extractor.extract_symbols(file_path, content)
             for symbol in symbols:
                 self.symbol_table.add_symbol(symbol)
+            
+            # Update file modification time after extracting symbols
+            if os.path.exists(file_path):
+                try:
+                    self.symbol_table._file_mtimes[file_path] = os.path.getmtime(file_path)
+                except Exception:
+                    pass
 
         # 5. Analyze dependencies
         analyzer = get_dependency_analyzer(language)
@@ -196,6 +217,26 @@ class ContextManager:
                 dep_path = self._resolve_dependency_path(file_path, dep.from_module)
                 if dep_path:
                     self.dependency_graph.add_dependency(file_path, dep_path)
+        
+        # 6. Save updated symbols to cache
+        self.symbol_table.save_cache()
+    
+    def _refresh_file_symbols(self, file_path: str):
+        """Refresh symbols for a file that has been modified externally.
+        
+        This method is called when a file is detected to be stale (modified
+        outside of Jarvis's control).
+        """
+        if not os.path.exists(file_path):
+            return
+        
+        try:
+            with open(file_path, 'r', encoding='utf-8', errors='replace') as f:
+                content = f.read()
+            self.update_context_for_file(file_path, content)
+        except Exception:
+            # If we can't read the file, skip refresh
+            pass
 
     def _get_file_content(self, file_path: str) -> Optional[str]:
         """Get file content, using cache if available."""
@@ -215,6 +256,9 @@ class ContextManager:
 
     def _find_current_scope(self, file_path: str, line_num: int) -> Optional[Symbol]:
         """Find the function or class that contains the given line."""
+        # Check if file is stale and update if needed
+        if self.symbol_table.is_file_stale(file_path):
+            self._refresh_file_symbols(file_path)
         symbols = self.symbol_table.get_file_symbols(file_path)
         
         # Find the innermost scope containing the line
@@ -232,7 +276,17 @@ class ContextManager:
         return current_scope
 
     def _find_used_symbols(self, file_path: str, content: str, line_start: int, line_end: int) -> List[Symbol]:
-        """Find symbols used in the specified line range."""
+        """Find symbols used in the specified line range.
+        
+        改进版本：
+        1. 区分定义和调用：检查符号是否在当前行范围内定义
+        2. 获取定义位置：优先使用 LSP，如果不支持则使用 tree-sitter
+        3. 为每个使用的符号添加定义位置信息
+        """
+        # Check if file is stale and update if needed
+        if self.symbol_table.is_file_stale(file_path):
+            self._refresh_file_symbols(file_path)
+        
         # Extract the code in the range
         lines = content.split('\n')
         region_content = '\n'.join(lines[line_start-1:line_end])
@@ -240,19 +294,250 @@ class ContextManager:
         used_symbols: List[Symbol] = []
         all_symbols = self.symbol_table.get_file_symbols(file_path)
         
+        # 尝试获取 LSP 客户端（优先使用）
+        lsp_client = None
+        try:
+            from jarvis.jarvis_tools.lsp_client import LSPClientTool
+            lsp_client = LSPClientTool.get_client_for_file(file_path, self.project_root)
+        except Exception:
+            pass
+        
+        # 尝试获取 tree-sitter 提取器（作为后备）
+        treesitter_extractor = None
+        try:
+            from jarvis.jarvis_code_agent.code_analyzer.language_support import (
+                detect_language,
+                get_symbol_extractor,
+            )
+            language = detect_language(file_path)
+            if language:
+                treesitter_extractor = get_symbol_extractor(language)
+        except Exception:
+            pass
+        
+        # 用于跟踪已处理的符号，避免重复
+        processed_symbols = {}  # {symbol_name: (symbol, is_definition, definition_location)}
+        
         # Simple pattern matching to find symbol usage
         for symbol in all_symbols:
             if symbol.kind == 'import':
                 continue
             
             pattern = r'\b' + re.escape(symbol.name) + r'\b'
-            if re.search(pattern, region_content):
-                used_symbols.append(symbol)
+            matches = list(re.finditer(pattern, region_content))
+            if not matches:
+                continue
+            
+            # 检查符号是否在当前行范围内定义
+            is_definition_in_range = (
+                symbol.file_path == file_path and
+                symbol.line_start >= line_start and
+                symbol.line_start <= line_end
+            )
+            
+            # 检查是否有调用（不在定义行的使用）
+            has_calls = False
+            call_line = None
+            call_column = None
+            for match in matches:
+                match_start = match.start()
+                match_line_in_region = region_content[:match_start].count('\n') + 1
+                match_line = line_start + match_line_in_region - 1
+                
+                # 如果使用位置不在定义行，则认为是调用
+                if not is_definition_in_range or match_line != symbol.line_start:
+                    has_calls = True
+                    call_line = match_line
+                    # 计算列号
+                    line_start_pos = region_content[:match_start].rfind('\n') + 1
+                    call_column = match_start - line_start_pos
+                    break
+            
+            # 处理定义
+            if is_definition_in_range:
+                symbol.is_definition = True
+                if symbol.name not in processed_symbols:
+                    processed_symbols[symbol.name] = (symbol, True, None)
+            
+            # 处理调用
+            if has_calls or not is_definition_in_range:
+                # 创建或更新引用符号
+                if symbol.name in processed_symbols:
+                    existing_symbol, existing_is_def, existing_def_loc = processed_symbols[symbol.name]
+                    # 如果已有定义，跳过；否则更新定义位置
+                    if not existing_is_def and not existing_def_loc:
+                        # 尝试获取定义位置
+                        definition_location = self._find_definition_location(
+                            symbol.name,
+                            file_path,
+                            call_line or line_start,
+                            call_column or 0,
+                            lsp_client,
+                            treesitter_extractor,
+                            content,
+                        )
+                        
+                        if definition_location:
+                            processed_symbols[symbol.name] = (existing_symbol, False, definition_location)
+                        else:
+                            # 从符号表中查找
+                            definition_symbols = self.symbol_table.find_symbol(symbol.name)
+                            if definition_symbols:
+                                def_symbol = definition_symbols[0]
+                                definition_location = Symbol(
+                                    name=def_symbol.name,
+                                    kind=def_symbol.kind,
+                                    file_path=def_symbol.file_path,
+                                    line_start=def_symbol.line_start,
+                                    line_end=def_symbol.line_end,
+                                    signature=def_symbol.signature,
+                                )
+                                processed_symbols[symbol.name] = (existing_symbol, False, definition_location)
+                else:
+                    # 创建新的引用符号
+                    reference_symbol = Symbol(
+                        name=symbol.name,
+                        kind=symbol.kind,
+                        file_path=file_path,
+                        line_start=call_line or line_start,
+                        line_end=call_line or line_start,
+                        signature=symbol.signature,
+                        docstring=symbol.docstring,
+                        parent=symbol.parent,
+                        is_definition=False,
+                    )
+                    
+                    # 尝试获取定义位置
+                    definition_location = self._find_definition_location(
+                        symbol.name,
+                        file_path,
+                        call_line or line_start,
+                        call_column or 0,
+                        lsp_client,
+                        treesitter_extractor,
+                        content,
+                    )
+                    
+                    if definition_location:
+                        reference_symbol.definition_location = definition_location
+                    else:
+                        # 从符号表中查找
+                        definition_symbols = self.symbol_table.find_symbol(symbol.name)
+                        if definition_symbols:
+                            def_symbol = definition_symbols[0]
+                            reference_symbol.definition_location = Symbol(
+                                name=def_symbol.name,
+                                kind=def_symbol.kind,
+                                file_path=def_symbol.file_path,
+                                line_start=def_symbol.line_start,
+                                line_end=def_symbol.line_end,
+                                signature=def_symbol.signature,
+                            )
+                    
+                    processed_symbols[symbol.name] = (reference_symbol, False, reference_symbol.definition_location)
+        
+        # 将处理后的符号添加到结果列表
+        for symbol, is_def, def_loc in processed_symbols.values():
+            if is_def:
+                symbol.is_definition = True
+            if def_loc:
+                symbol.definition_location = def_loc
+            used_symbols.append(symbol)
         
         return used_symbols
+    
+    def _find_definition_location(
+        self,
+        symbol_name: str,
+        file_path: str,
+        line: int,
+        column: int,
+        lsp_client: Optional[Any],
+        treesitter_extractor: Optional[Any],
+        content: str,
+    ) -> Optional[Symbol]:
+        """查找符号的定义位置。
+        
+        优先使用 LSP，如果不支持则使用 tree-sitter。
+        
+        Args:
+            symbol_name: 符号名称
+            file_path: 文件路径
+            line: 行号（1-based）
+            column: 列号（0-based）
+            lsp_client: LSP 客户端（可选）
+            treesitter_extractor: tree-sitter 提取器（可选）
+            content: 文件内容
+            
+        Returns:
+            定义位置的 Symbol 对象，如果找不到则返回 None
+        """
+        # 优先使用 LSP
+        if lsp_client:
+            try:
+                # LSP 使用 0-based 行号
+                definition = lsp_client.get_definition(file_path, line - 1, column)
+                if definition:
+                    # 处理 LSP 返回的定义（可能是单个对象或列表）
+                    if isinstance(definition, list):
+                        if definition:
+                            definition = definition[0]
+                        else:
+                            return None
+                    
+                    # 解析 LSP 返回的定义位置
+                    uri = definition.get("uri", "")
+                    if uri.startswith("file://"):
+                        def_file_path = uri[7:]  # 移除 "file://" 前缀
+                    else:
+                        def_file_path = uri
+                    
+                    range_info = definition.get("range", {})
+                    start = range_info.get("start", {})
+                    end = range_info.get("end", {})
+                    
+                    # LSP 使用 0-based 行号，转换为 1-based
+                    def_line_start = start.get("line", 0) + 1
+                    def_line_end = end.get("line", 0) + 1
+                    
+                    return Symbol(
+                        name=symbol_name,
+                        kind="",  # LSP 可能不提供类型信息
+                        file_path=def_file_path,
+                        line_start=def_line_start,
+                        line_end=def_line_end,
+                    )
+            except Exception:
+                # LSP 失败，继续尝试 tree-sitter
+                pass
+        
+        # 后备：使用 tree-sitter
+        if treesitter_extractor:
+            try:
+                # 从符号表中查找定义（tree-sitter 已经提取了符号）
+                definition_symbols = self.symbol_table.find_symbol(symbol_name)
+                if definition_symbols:
+                    # 选择第一个定义（可以改进为选择最相关的）
+                    def_symbol = definition_symbols[0]
+                    return Symbol(
+                        name=def_symbol.name,
+                        kind=def_symbol.kind,
+                        file_path=def_symbol.file_path,
+                        line_start=def_symbol.line_start,
+                        line_end=def_symbol.line_end,
+                        signature=def_symbol.signature,
+                    )
+            except Exception:
+                pass
+        
+        return None
 
     def _find_imported_symbols(self, file_path: str) -> List[Symbol]:
         """Find all imported symbols in a file."""
+        # Check if file is stale and update if needed
+        if self.symbol_table.is_file_stale(file_path):
+            self._refresh_file_symbols(file_path)
+        
         symbols = self.symbol_table.get_file_symbols(file_path)
         return [s for s in symbols if s.kind == 'import']
 

jarvis/jarvis_code_agent/code_analyzer/language_support.py

@@ -52,6 +52,27 @@ try:
 except (ImportError, RuntimeError):
     pass  # 静默失败，tree-sitter可能不可用
 
+# JavaScript语言支持（可选，需要tree-sitter）
+try:
+    from .languages import JavaScriptLanguageSupport
+    register_language(JavaScriptLanguageSupport())
+except (ImportError, RuntimeError):
+    pass  # 静默失败，tree-sitter可能不可用
+
+# TypeScript语言支持（可选，需要tree-sitter）
+try:
+    from .languages import TypeScriptLanguageSupport
+    register_language(TypeScriptLanguageSupport())
+except (ImportError, RuntimeError):
+    pass  # 静默失败，tree-sitter可能不可用
+
+# Java语言支持（可选，需要tree-sitter）
+try:
+    from .languages import JavaLanguageSupport
+    register_language(JavaLanguageSupport())
+except (ImportError, RuntimeError):
+    pass  # 静默失败，tree-sitter可能不可用
+
 
 def detect_language(file_path: str) -> Optional[str]:
     """检测文件的编程语言。

jarvis/jarvis_code_agent/code_analyzer/languages/__init__.py

@@ -12,20 +12,38 @@ __all__ = ['PythonLanguageSupport']
 
 # 尝试导入tree-sitter相关的语言支持
 try:
-    from .rust_language import RustLanguageSupport
+    from .rust_language import RustLanguageSupport  # noqa: F401
     __all__.append('RustLanguageSupport')
 except (ImportError, RuntimeError):
     pass
 
 try:
-    from .go_language import GoLanguageSupport
+    from .go_language import GoLanguageSupport  # noqa: F401
     __all__.append('GoLanguageSupport')
 except (ImportError, RuntimeError):
     pass
 
 try:
-    from .c_cpp_language import CLanguageSupport, CppLanguageSupport
+    from .c_cpp_language import CLanguageSupport, CppLanguageSupport  # noqa: F401
     __all__.extend(['CLanguageSupport', 'CppLanguageSupport'])
 except (ImportError, RuntimeError):
     pass
 
+try:
+    from .javascript_language import JavaScriptLanguageSupport  # noqa: F401
+    __all__.append('JavaScriptLanguageSupport')
+except (ImportError, RuntimeError):
+    pass
+
+try:
+    from .typescript_language import TypeScriptLanguageSupport  # noqa: F401
+    __all__.append('TypeScriptLanguageSupport')
+except (ImportError, RuntimeError):
+    pass
+
+try:
+    from .java_language import JavaLanguageSupport  # noqa: F401
+    __all__.append('JavaLanguageSupport')
+except (ImportError, RuntimeError):
+    pass
+

jarvis/jarvis_code_agent/code_analyzer/languages/c_cpp_language.py

@@ -15,7 +15,29 @@ from ..tree_sitter_extractor import TreeSitterExtractor
 
 # --- C/C++ Symbol Query ---
 
-C_CPP_SYMBOL_QUERY = """
+# C语言查询（不包含class_specifier，因为C不支持class）
+C_SYMBOL_QUERY = """
+(function_declarator
+  declarator: (identifier) @function.name)
+
+(struct_specifier
+  name: (type_identifier) @struct.name)
+  
+(union_specifier
+  name: (type_identifier) @union.name)
+  
+(enum_specifier
+  name: (type_identifier) @enum.name)
+
+(preproc_def
+  name: (identifier) @macro.name)
+
+(type_definition
+  declarator: (type_identifier) @typedef.name)
+"""
+
+# C++语言查询（包含class_specifier）
+CPP_SYMBOL_QUERY = """
 (function_declarator
   declarator: (identifier) @function.name)
 
@@ -30,6 +52,17 @@ C_CPP_SYMBOL_QUERY = """
   
 (enum_specifier
   name: (type_identifier) @enum.name)
+
+(namespace_definition
+  name: (identifier)? @namespace.name)
+
+(preproc_def
+  name: (identifier) @macro.name)
+
+(type_definition
+  declarator: (type_identifier) @typedef.name)
+
+(template_declaration) @template
 """
 
 # --- C/C++ Language Setup ---
@@ -55,7 +88,7 @@ class CSymbolExtractor(TreeSitterExtractor):
     def __init__(self):
         if not C_LANGUAGE:
             raise RuntimeError("C tree-sitter grammar not available.")
-        super().__init__(C_LANGUAGE, C_CPP_SYMBOL_QUERY)
+        super().__init__(C_LANGUAGE, C_SYMBOL_QUERY)
 
     def _create_symbol_from_capture(self, node: Node, name: str, file_path: str) -> Optional[Symbol]:
         kind_map = {
@@ -63,6 +96,8 @@ class CSymbolExtractor(TreeSitterExtractor):
             "struct.name": "struct",
             "union.name": "union",
             "enum.name": "enum",
+            "macro.name": "macro",
+            "typedef.name": "typedef",
         }
         symbol_kind = kind_map.get(name)
         if not symbol_kind:
@@ -83,7 +118,7 @@ class CppSymbolExtractor(TreeSitterExtractor):
     def __init__(self):
         if not CPP_LANGUAGE:
             raise RuntimeError("C++ tree-sitter grammar not available.")
-        super().__init__(CPP_LANGUAGE, C_CPP_SYMBOL_QUERY)
+        super().__init__(CPP_LANGUAGE, CPP_SYMBOL_QUERY)
 
     def _create_symbol_from_capture(self, node: Node, name: str, file_path: str) -> Optional[Symbol]:
         kind_map = {
@@ -92,13 +127,46 @@ class CppSymbolExtractor(TreeSitterExtractor):
             "class.name": "class",
             "union.name": "union",
             "enum.name": "enum",
+            "namespace.name": "namespace",
+            "macro.name": "macro",
+            "typedef.name": "typedef",
+            "template": "template",
         }
         symbol_kind = kind_map.get(name)
         if not symbol_kind:
             return None
 
+        # For anonymous namespaces, use a generated name
+        if name == "namespace.name":
+            symbol_name = node.text.decode('utf8') if node.text else "<anonymous_namespace>"
+        elif name == "template":
+            # For template declarations, extract the template name or use a generic name
+            # Try to find the function/class name after template
+            template_text = node.text.decode('utf8').strip()
+            # Extract template parameters and the following declaration
+            # This is a simplified extraction - in practice, you might want more sophisticated parsing
+            if 'template' in template_text:
+                # Try to extract the name after template<...>
+                parts = template_text.split('>', 1)
+                if len(parts) > 1:
+                    # Look for function/class name in the second part
+                    match = re.search(r'\b(function|class|struct)\s+(\w+)', parts[1])
+                    if match:
+                        symbol_name = f"template_{match.group(2)}"
+                    else:
+                        symbol_name = "template"
+                else:
+                    symbol_name = "template"
+            else:
+                symbol_name = "template"
+        else:
+            symbol_name = node.text.decode('utf8')
+        
+        if not symbol_name:
+            return None
+
         return Symbol(
-            name=node.text.decode('utf8'),
+            name=symbol_name,
             kind=symbol_kind,
             file_path=file_path,
             line_start=node.start_point[0] + 1,

jarvis/jarvis_code_agent/code_analyzer/languages/go_language.py

@@ -26,8 +26,16 @@ GO_SYMBOL_QUERY = """
   (type_spec
     name: (type_identifier) @type.name))
 
-(interface_declaration
-  name: (type_identifier) @interface.name)
+(type_declaration
+  (type_spec
+    name: (type_identifier) @interface.name
+    type: (interface_type)))
+
+(const_declaration) @const
+
+(var_declaration) @var
+
+(struct_type) @struct
 """
 
 # --- Go Language Setup ---
@@ -56,14 +64,38 @@ class GoSymbolExtractor(TreeSitterExtractor):
             "method.name": "method",
             "type.name": "type",
             "interface.name": "interface",
+            "const": "const",
+            "var": "var",
+            "struct": "struct",
         }
         
         symbol_kind = kind_map.get(name)
         if not symbol_kind:
             return None
 
+        # 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()
+            # Extract first identifier after const/var/struct keyword
+            if symbol_kind == "const":
+                match = re.search(r'const\s+(\w+)', node_text)
+            elif symbol_kind == "var":
+                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)
+            
+            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')
+
         return Symbol(
-            name=node.text.decode('utf8'),
+            name=symbol_name,
             kind=symbol_kind,
             file_path=file_path,
             line_start=node.start_point[0] + 1,