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

jarvis/jarvis_code_agent/code_analyzer/language_registry.py

@@ -3,8 +3,12 @@
 管理所有语言支持的注册和发现机制。
 """
 
+from jarvis.jarvis_utils.output import PrettyOutput
+
 import os
-from typing import Dict, Optional, Set
+from typing import Dict
+from typing import Optional
+from typing import Set
 
 from .base_language import BaseLanguageSupport
 from .dependency_analyzer import DependencyAnalyzer
@@ -13,7 +17,7 @@ from .symbol_extractor import SymbolExtractor
 
 class LanguageRegistry:
     """语言支持注册表。
-    
+
     负责管理所有已注册的语言支持，提供语言检测和工厂方法。
     """
 
@@ -23,25 +27,27 @@ class LanguageRegistry:
 
     def register(self, language_support: BaseLanguageSupport) -> None:
         """注册一个语言支持。
-        
+
         Args:
             language_support: 语言支持实例
         """
         lang_name = language_support.language_name
         self._languages[lang_name] = language_support
-        
+
         # 注册文件扩展名映射
         for ext in language_support.file_extensions:
             # 如果扩展名已存在，记录警告但不覆盖（保留第一个注册的）
             if ext in self._extension_map and self._extension_map[ext] != lang_name:
-                print(f"Warning: Extension {ext} already registered for "
-                      f"{self._extension_map[ext]}, ignoring registration for {lang_name}")
+                PrettyOutput.auto_print(
+                    f"Warning: Extension {ext} already registered for "
+                    f"{self._extension_map[ext]}, ignoring registration for {lang_name}"
+                )
             else:
                 self._extension_map[ext] = lang_name
 
     def unregister(self, language_name: str) -> None:
         """取消注册一个语言支持。
-        
+
         Args:
             language_name: 语言名称
         """
@@ -49,7 +55,8 @@ class LanguageRegistry:
             self._languages.pop(language_name)
             # 移除扩展名映射
             extensions_to_remove = [
-                ext for ext, lang in self._extension_map.items()
+                ext
+                for ext, lang in self._extension_map.items()
                 if lang == language_name
             ]
             for ext in extensions_to_remove:
@@ -57,10 +64,10 @@ class LanguageRegistry:
 
     def detect_language(self, file_path: str) -> Optional[str]:
         """根据文件路径检测编程语言。
-        
+
         Args:
             file_path: 文件路径
-            
+
         Returns:
             语言名称，如果无法检测则返回None
         """
@@ -69,10 +76,10 @@ class LanguageRegistry:
 
     def get_language_support(self, language_name: str) -> Optional[BaseLanguageSupport]:
         """获取指定语言的支持实例。
-        
+
         Args:
             language_name: 语言名称
-            
+
         Returns:
             语言支持实例，如果未注册则返回None
         """
@@ -80,10 +87,10 @@ class LanguageRegistry:
 
     def get_symbol_extractor(self, language_name: str) -> Optional[SymbolExtractor]:
         """获取指定语言的符号提取器。
-        
+
         Args:
             language_name: 语言名称
-            
+
         Returns:
             SymbolExtractor实例，如果不支持则返回None
         """
@@ -92,12 +99,14 @@ class LanguageRegistry:
             return lang_support.create_symbol_extractor()
         return None
 
-    def get_dependency_analyzer(self, language_name: str) -> Optional[DependencyAnalyzer]:
+    def get_dependency_analyzer(
+        self, language_name: str
+    ) -> Optional[DependencyAnalyzer]:
         """获取指定语言的依赖分析器。
-        
+
         Args:
             language_name: 语言名称
-            
+
         Returns:
             DependencyAnalyzer实例，如果不支持则返回None
         """
@@ -108,7 +117,7 @@ class LanguageRegistry:
 
     def get_supported_languages(self) -> Set[str]:
         """获取所有已注册的语言名称集合。
-        
+
         Returns:
             语言名称集合
         """
@@ -116,10 +125,10 @@ class LanguageRegistry:
 
     def is_supported(self, file_path: str) -> bool:
         """检查文件是否被支持。
-        
+
         Args:
             file_path: 文件路径
-            
+
         Returns:
             如果文件被支持返回True，否则返回False
         """
@@ -132,7 +141,7 @@ _registry = LanguageRegistry()
 
 def get_registry() -> LanguageRegistry:
     """获取全局语言注册表实例。
-    
+
     Returns:
         全局LanguageRegistry实例
     """
@@ -141,7 +150,7 @@ def get_registry() -> LanguageRegistry:
 
 def register_language(language_support: BaseLanguageSupport) -> None:
     """注册一个语言支持（便捷函数）。
-    
+
     Args:
         language_support: 语言支持实例
     """
@@ -150,10 +159,10 @@ def register_language(language_support: BaseLanguageSupport) -> None:
 
 def detect_language(file_path: str) -> Optional[str]:
     """检测文件的语言（便捷函数）。
-    
+
     Args:
         file_path: 文件路径
-        
+
     Returns:
         语言名称，如果无法检测则返回None
     """
@@ -162,10 +171,10 @@ def detect_language(file_path: str) -> Optional[str]:
 
 def get_symbol_extractor(language: str) -> Optional[SymbolExtractor]:
     """获取指定语言的符号提取器（便捷函数）。
-    
+
     Args:
         language: 语言名称
-        
+
     Returns:
         SymbolExtractor实例，如果不支持则返回None
     """
@@ -174,12 +183,11 @@ def get_symbol_extractor(language: str) -> Optional[SymbolExtractor]:
 
 def get_dependency_analyzer(language: str) -> Optional[DependencyAnalyzer]:
     """获取指定语言的依赖分析器（便捷函数）。
-    
+
     Args:
         language: 语言名称
-        
+
     Returns:
         DependencyAnalyzer实例，如果不支持则返回None
     """
     return _registry.get_dependency_analyzer(language)
-

jarvis/jarvis_code_agent/code_analyzer/language_support.py

@@ -3,15 +3,15 @@
 提供语言检测和工厂函数，使用语言注册表管理所有语言支持。
 """
 
+from jarvis.jarvis_utils.output import PrettyOutput
+
 from typing import Optional
 
 from .dependency_analyzer import DependencyAnalyzer
-from .language_registry import (
-    detect_language as _detect_language,
-    get_dependency_analyzer as _get_dependency_analyzer,
-    get_symbol_extractor as _get_symbol_extractor,
-    register_language,
-)
+from .language_registry import detect_language as _detect_language
+from .language_registry import get_dependency_analyzer as _get_dependency_analyzer
+from .language_registry import get_symbol_extractor as _get_symbol_extractor
+from .language_registry import register_language
 from .symbol_extractor import SymbolExtractor
 
 # 自动注册所有语言支持
@@ -20,13 +20,15 @@ from .symbol_extractor import SymbolExtractor
 # Python语言支持（必需，因为它是核心语言）
 try:
     from .languages import PythonLanguageSupport
+
     register_language(PythonLanguageSupport())
 except ImportError as e:
-    print(f"Warning: Failed to import PythonLanguageSupport: {e}")
+    PrettyOutput.auto_print(f"⚠️ Warning: Failed to import PythonLanguageSupport: {e}")
 
 # Rust语言支持（可选，需要tree-sitter）
 try:
     from .languages import RustLanguageSupport
+
     register_language(RustLanguageSupport())
 except (ImportError, RuntimeError):
     pass  # 静默失败，tree-sitter可能不可用
@@ -34,6 +36,7 @@ except (ImportError, RuntimeError):
 # Go语言支持（可选，需要tree-sitter）
 try:
     from .languages import GoLanguageSupport
+
     register_language(GoLanguageSupport())
 except (ImportError, RuntimeError):
     pass  # 静默失败，tree-sitter可能不可用
@@ -41,6 +44,7 @@ except (ImportError, RuntimeError):
 # C语言支持（可选，需要tree-sitter）
 try:
     from .languages import CLanguageSupport
+
     register_language(CLanguageSupport())
 except (ImportError, RuntimeError):
     pass  # 静默失败，tree-sitter可能不可用
@@ -48,6 +52,7 @@ except (ImportError, RuntimeError):
 # C++语言支持（可选，需要tree-sitter）
 try:
     from .languages import CppLanguageSupport
+
     register_language(CppLanguageSupport())
 except (ImportError, RuntimeError):
     pass  # 静默失败，tree-sitter可能不可用
@@ -55,6 +60,7 @@ except (ImportError, RuntimeError):
 # JavaScript语言支持（可选，需要tree-sitter）
 try:
     from .languages import JavaScriptLanguageSupport
+
     register_language(JavaScriptLanguageSupport())
 except (ImportError, RuntimeError):
     pass  # 静默失败，tree-sitter可能不可用
@@ -62,6 +68,7 @@ except (ImportError, RuntimeError):
 # TypeScript语言支持（可选，需要tree-sitter）
 try:
     from .languages import TypeScriptLanguageSupport
+
     register_language(TypeScriptLanguageSupport())
 except (ImportError, RuntimeError):
     pass  # 静默失败，tree-sitter可能不可用
@@ -69,6 +76,7 @@ except (ImportError, RuntimeError):
 # Java语言支持（可选，需要tree-sitter）
 try:
     from .languages import JavaLanguageSupport
+
     register_language(JavaLanguageSupport())
 except (ImportError, RuntimeError):
     pass  # 静默失败，tree-sitter可能不可用
@@ -76,10 +84,10 @@ except (ImportError, RuntimeError):
 
 def detect_language(file_path: str) -> Optional[str]:
     """检测文件的编程语言。
-    
+
     Args:
         file_path: 文件路径
-        
+
     Returns:
         语言名称，如果无法检测则返回None
     """
@@ -88,10 +96,10 @@ def detect_language(file_path: str) -> Optional[str]:
 
 def get_symbol_extractor(language: str) -> Optional[SymbolExtractor]:
     """获取指定语言的符号提取器。
-    
+
     Args:
         language: 语言名称
-        
+
     Returns:
         SymbolExtractor实例，如果不支持则返回None
     """
@@ -100,10 +108,10 @@ def get_symbol_extractor(language: str) -> Optional[SymbolExtractor]:
 
 def get_dependency_analyzer(language: str) -> Optional[DependencyAnalyzer]:
     """获取指定语言的依赖分析器。
-    
+
     Args:
         language: 语言名称
-        
+
     Returns:
         DependencyAnalyzer实例，如果不支持则返回None
     """

jarvis/jarvis_code_agent/code_analyzer/languages/__init__.py

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

jarvis/jarvis_code_agent/code_analyzer/languages/c_cpp_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
 
-
 # --- C/C++ Symbol Query ---
 
 # C语言查询（不包含class_specifier，因为C不支持class）
@@ -69,19 +75,24 @@ CPP_SYMBOL_QUERY = """
 
 try:
     import tree_sitter_c
-    C_LANGUAGE: Optional[Language] = tree_sitter_c.language()
+
+    C_LANGUAGE: Optional[Language] = cast(Optional[Language], tree_sitter_c.language())
 except (ImportError, Exception):
     C_LANGUAGE = None
 
 try:
     import tree_sitter_cpp
-    CPP_LANGUAGE: Optional[Language] = tree_sitter_cpp.language()
+
+    CPP_LANGUAGE: Optional[Language] = cast(
+        Optional[Language], tree_sitter_cpp.language()
+    )
 except (ImportError, Exception):
     CPP_LANGUAGE = None
 
 
 # --- C/C++ Symbol Extractors ---
 
+
 class CSymbolExtractor(TreeSitterExtractor):
     """Extracts symbols from C code using tree-sitter."""
 
@@ -90,7 +101,9 @@ class CSymbolExtractor(TreeSitterExtractor):
             raise RuntimeError("C tree-sitter grammar not available.")
         super().__init__(C_LANGUAGE, C_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]:
         kind_map = {
             "function.name": "function",
             "struct.name": "struct",
@@ -103,8 +116,11 @@ class CSymbolExtractor(TreeSitterExtractor):
         if not symbol_kind:
             return None
 
+        if node.text is None:
+            return None
+
         return Symbol(
-            name=node.text.decode('utf8'),
+            name=node.text.decode("utf8"),
             kind=symbol_kind,
             file_path=file_path,
             line_start=node.start_point[0] + 1,
@@ -120,7 +136,9 @@ class CppSymbolExtractor(TreeSitterExtractor):
             raise RuntimeError("C++ tree-sitter grammar not available.")
         super().__init__(CPP_LANGUAGE, CPP_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]:
         kind_map = {
             "function.name": "function",
             "struct.name": "struct",
@@ -138,19 +156,23 @@ class CppSymbolExtractor(TreeSitterExtractor):
 
         # For anonymous namespaces, use a generated name
         if name == "namespace.name":
-            symbol_name = node.text.decode('utf8') if node.text else "<anonymous_namespace>"
+            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()
+            if node.text is None:
+                return None
+            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:
+            if "template" in template_text:
                 # Try to extract the name after template<...>
-                parts = template_text.split('>', 1)
+                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])
+                    match = re.search(r"\b(function|class|struct)\s+(\w+)", parts[1])
                     if match:
                         symbol_name = f"template_{match.group(2)}"
                     else:
@@ -160,8 +182,10 @@ class CppSymbolExtractor(TreeSitterExtractor):
             else:
                 symbol_name = "template"
         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
 
@@ -176,76 +200,83 @@ class CppSymbolExtractor(TreeSitterExtractor):
 
 # --- C/C++ Dependency Analyzers ---
 
+
 class CDependencyAnalyzer(DependencyAnalyzer):
     """Analyzes C include dependencies."""
 
     def analyze_imports(self, file_path: str, content: str) -> List[Dependency]:
         """Analyzes C #include statements."""
         dependencies: List[Dependency] = []
-        
+
         # Match #include directives
         # Format: #include <header.h> or #include "header.h"
         include_pattern = re.compile(r'#include\s+[<"]([^>"]+)[>"]')
-        
-        for line_num, line in enumerate(content.split('\n'), start=1):
+
+        for line_num, line in enumerate(content.split("\n"), start=1):
             match = include_pattern.search(line)
             if match:
                 header = match.group(1)
-                dependencies.append(Dependency(
-                    from_module=header,
-                    imported_symbol=None,
-                    file_path=file_path,
-                    line=line_num,
-                ))
-        
+                dependencies.append(
+                    Dependency(
+                        from_module=header,
+                        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 C project."""
         graph = DependencyGraph()
-        extensions = {'.c', '.h'}
-        
+        extensions = {".c", ".h"}
+
         for root, dirs, files in os.walk(project_root):
             dirs[:] = filter_walk_dirs(dirs)
-            
+
             for file in files:
                 if not any(file.endswith(ext) for ext in extensions):
                     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:
-                        dep_path = self._resolve_header_path(project_root, dep.from_module, file_path)
+                        dep_path = self._resolve_header_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_header_path(self, project_root: str, header_name: str, from_file: str) -> Optional[str]:
+    def _resolve_header_path(
+        self, project_root: str, header_name: str, from_file: str
+    ) -> Optional[str]:
         """Resolve a header name to a file path."""
         # Try relative to current file
         base_dir = os.path.dirname(from_file)
         relative_path = os.path.join(base_dir, header_name)
         if os.path.exists(relative_path):
             return relative_path
-        
+
         # Try in project root
         for root, dirs, files in os.walk(project_root):
             dirs[:] = filter_walk_dirs(dirs)
             if header_name in files:
                 return os.path.join(root, header_name)
-        
+
         return None
 
     def _is_source_file(self, file_path: str) -> bool:
         """Check if a file is a C source file."""
-        return file_path.endswith(('.c', '.h'))
+        return file_path.endswith((".c", ".h"))
 
 
 class CppDependencyAnalyzer(CDependencyAnalyzer):
@@ -253,7 +284,7 @@ class CppDependencyAnalyzer(CDependencyAnalyzer):
 
     def _is_source_file(self, file_path: str) -> bool:
         """Check if a file is a C++ source file."""
-        return file_path.endswith(('.cpp', '.hpp', '.cc', '.cxx', '.hxx', '.h'))
+        return file_path.endswith((".cpp", ".hpp", ".cc", ".cxx", ".hxx", ".h"))
 
 
 class CLanguageSupport(BaseLanguageSupport):
@@ -261,11 +292,11 @@ class CLanguageSupport(BaseLanguageSupport):
 
     @property
     def language_name(self) -> str:
-        return 'c'
+        return "c"
 
     @property
     def file_extensions(self) -> Set[str]:
-        return {'.c', '.h'}
+        return {".c", ".h"}
 
     def create_symbol_extractor(self) -> Optional[SymbolExtractor]:
         try:
@@ -282,11 +313,11 @@ class CppLanguageSupport(BaseLanguageSupport):
 
     @property
     def language_name(self) -> str:
-        return 'cpp'
+        return "cpp"
 
     @property
     def file_extensions(self) -> Set[str]:
-        return {'.cpp', '.hpp', '.cc', '.cxx', '.hxx'}
+        return {".cpp", ".hpp", ".cc", ".cxx", ".hxx"}
 
     def create_symbol_extractor(self) -> Optional[SymbolExtractor]:
         try:
@@ -296,4 +327,3 @@ class CppLanguageSupport(BaseLanguageSupport):
 
     def create_dependency_analyzer(self) -> Optional[DependencyAnalyzer]:
         return CppDependencyAnalyzer()
-