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

jarvis/jarvis_agent/file_context_handler.py

@@ -1,8 +1,12 @@
 # -*- coding: utf-8 -*-
-import re
 import os
-from typing import Any, Tuple, List, Dict, Optional, Callable
-
+import re
+from typing import Any
+from typing import Callable
+from typing import Dict
+from typing import List
+from typing import Optional
+from typing import Tuple
 
 # 语言提取器注册表（导出供其他模块使用）
 _LANGUAGE_EXTRACTORS: Dict[str, Callable[[], Optional[Any]]] = {}
@@ -34,9 +38,9 @@ def count_lines(filepath: str) -> int:
 def register_language_extractor(extensions, extractor_factory=None):
     """
     Register a symbol extractor for one or more file extensions.
-    
+
     Can be used as a decorator or as a regular function.
-    
+
     Args:
         extensions: List of file extensions (e.g., ['.py', '.pyw']) or single extension string.
                    If used as decorator, this is the first argument.
@@ -44,19 +48,19 @@ def register_language_extractor(extensions, extractor_factory=None):
                           The extractor must have an extract_symbols(file_path: str, content: str) method
                           that returns a list of Symbol objects.
                           If used as decorator, this is the decorated function.
-    
+
     Examples:
         # As decorator:
         @register_language_extractor(['.py', '.pyw'])
         def create_python_extractor():
             from jarvis.jarvis_code_agent.code_analyzer.languages.python_language import PythonSymbolExtractor
             return PythonSymbolExtractor()
-        
+
         # As regular function:
         def create_java_extractor():
             # ... create extractor ...
             return JavaExtractor()
-        
+
         register_language_extractor('.java', create_java_extractor)
     """
     # Support both decorator and function call syntax
@@ -67,39 +71,39 @@ def register_language_extractor(extensions, extractor_factory=None):
                 exts = [extensions]
             else:
                 exts = extensions
-            
+
             for ext in exts:
                 ext_lower = ext.lower()
-                if not ext_lower.startswith('.'):
-                    ext_lower = '.' + ext_lower
+                if not ext_lower.startswith("."):
+                    ext_lower = "." + ext_lower
                 _LANGUAGE_EXTRACTORS[ext_lower] = func
-            
+
             return func
-        
+
         return decorator
     else:
         # Used as regular function: register_language_extractor(['.ext'], factory)
         if isinstance(extensions, str):
             extensions = [extensions]
-        
+
         for ext in extensions:
             ext_lower = ext.lower()
-            if not ext_lower.startswith('.'):
-                ext_lower = '.' + ext_lower
+            if not ext_lower.startswith("."):
+                ext_lower = "." + ext_lower
             _LANGUAGE_EXTRACTORS[ext_lower] = extractor_factory
 
 
 def _get_symbol_extractor(filepath: str) -> Optional[Any]:
     """Get appropriate symbol extractor for the file based on extension"""
     ext = os.path.splitext(filepath)[1].lower()
-    
+
     # Check registered extractors
     if ext in _LANGUAGE_EXTRACTORS:
         try:
             return _LANGUAGE_EXTRACTORS[ext]()
         except Exception:
             return None
-    
+
     return None
 
 
@@ -111,29 +115,30 @@ except (ImportError, Exception):
     pass
 
 
-
 def extract_symbols_from_file(filepath: str) -> List[Dict[str, Any]]:
     """Extract symbols from a file using tree-sitter or AST"""
     extractor = _get_symbol_extractor(filepath)
     if not extractor:
         return []
-    
+
     try:
         with open(filepath, "r", encoding="utf-8", errors="ignore") as f:
             content = f.read()
-        
+
         symbols = extractor.extract_symbols(filepath, content)
-        
+
         # Convert Symbol objects to dict format
         result = []
         for symbol in symbols:
-            result.append({
-                "name": symbol.name,
-                "type": symbol.kind,
-                "line": symbol.line_start,
-                "signature": symbol.signature or f"{symbol.kind} {symbol.name}",
-            })
-        
+            result.append(
+                {
+                    "name": symbol.name,
+                    "type": symbol.kind,
+                    "line": symbol.line_start,
+                    "signature": symbol.signature or f"{symbol.kind} {symbol.name}",
+                }
+            )
+
         return result
     except Exception:
         return []
@@ -143,7 +148,7 @@ def format_symbols_output(filepath: str, symbols: List[Dict[str, Any]]) -> str:
     """Format symbols list as output string"""
     if not symbols:
         return ""
-    
+
     # Group symbols by type
     by_type: Dict[str, List[Dict[str, Any]]] = {}
     for symbol in symbols:
@@ -151,14 +156,14 @@ def format_symbols_output(filepath: str, symbols: List[Dict[str, Any]]) -> str:
         if symbol_type not in by_type:
             by_type[symbol_type] = []
         by_type[symbol_type].append(symbol)
-    
+
     # Sort symbols within each type by line number
     for symbol_type in by_type:
         by_type[symbol_type].sort(key=lambda x: x["line"])
-    
+
     output_lines = [f"\n📋 文件符号: {filepath}"]
     output_lines.append("─" * 60)
-    
+
     # Type names in Chinese
     type_names = {
         "function": "函数",
@@ -171,22 +176,22 @@ def format_symbols_output(filepath: str, symbols: List[Dict[str, Any]]) -> str:
         "variable": "变量",
         "constant": "常量",
     }
-    
+
     for symbol_type, type_symbols in sorted(by_type.items()):
         type_name = type_names.get(symbol_type, symbol_type)
         output_lines.append(f"\n{type_name} ({len(type_symbols)} 个):")
         for symbol in type_symbols:
             line_info = f"  行 {symbol['line']:4d}: {symbol['name']}"
-            if 'signature' in symbol and symbol['signature']:
-                sig = symbol['signature'].strip()
+            if "signature" in symbol and symbol["signature"]:
+                sig = symbol["signature"].strip()
                 if len(sig) > 50:
                     sig = sig[:47] + "..."
                 line_info += f" - {sig}"
             output_lines.append(line_info)
-    
+
     output_lines.append("─" * 60)
     output_lines.append("")
-    
+
     return "\n".join(output_lines)
 
 
@@ -224,12 +229,10 @@ def file_context_handler(user_input: str, agent_: Any) -> Tuple[str, bool]:
         if os.path.isfile(abs_path) and is_text_file(abs_path):
             # Extract symbols from the file
             symbols = extract_symbols_from_file(abs_path)
-            
+
             if symbols:
-                # Remove all original path tokens that map to this absolute path to avoid redundancy
-                for _raw in abs_to_raws.get(abs_path, []):
-                    user_input = user_input.replace(f"'{_raw}'", "")
-                # Append the formatted symbols output
+                # Keep the original path tokens and append symbol information as supplementary context
+                # This preserves the user's original reference to the file while adding symbol details
                 added_context += format_symbols_output(abs_path, symbols)
 
     if added_context:
@@ -241,45 +244,45 @@ def file_context_handler(user_input: str, agent_: Any) -> Tuple[str, bool]:
 # ============================================================================
 # 如何添加新语言支持
 # ============================================================================
-# 
+#
 # 推荐方式：在 language_extractors/ 目录下创建新文件
-# 
+#
 # 1. 创建新文件：jarvis_agent/language_extractors/java_extractor.py
-# 
+#
 #    # -*- coding: utf-8 -*-
 #    """Java language symbol extractor."""
-#    
+#
 #    from typing import Optional, Any, List
 #    from jarvis.jarvis_agent.file_context_handler import register_language_extractor
 #    from jarvis.jarvis_code_agent.code_analyzer.symbol_extractor import Symbol
-#    
+#
 #    def create_java_extractor() -> Optional[Any]:
 #        try:
 #            from tree_sitter import Language, Parser
 #            import tree_sitter_java
-#            
+#
 #            JAVA_LANGUAGE = tree_sitter_java.language()
 #            JAVA_SYMBOL_QUERY = """
 #            (method_declaration
 #              name: (identifier) @method.name)
-#            
+#
 #            (class_declaration
 #              name: (identifier) @class.name)
 #            """
-#            
+#
 #            class JavaSymbolExtractor:
 #                def __init__(self):
 #                    self.language = JAVA_LANGUAGE
 #                    self.parser = Parser()
 #                    self.parser.set_language(self.language)
 #                    self.symbol_query = JAVA_SYMBOL_QUERY
-#                
+#
 #                def extract_symbols(self, file_path: str, content: str) -> List[Any]:
 #                    try:
 #                        tree = self.parser.parse(bytes(content, "utf8"))
 #                        query = self.language.query(self.symbol_query)
 #                        captures = query.captures(tree.root_node)
-#                        
+#
 #                        symbols = []
 #                        for node, name in captures:
 #                            kind_map = {
@@ -298,32 +301,32 @@ def file_context_handler(user_input: str, agent_: Any) -> Tuple[str, bool]:
 #                        return symbols
 #                    except Exception:
 #                        return []
-#            
+#
 #            return JavaSymbolExtractor()
 #        except (ImportError, Exception):
 #            return None
-#    
+#
 #    def register_java_extractor() -> None:
 #        register_language_extractor(['.java', '.jav'], create_java_extractor)
-# 
-# 
+#
+#
 # 2. 在 language_extractors/__init__.py 中添加导入和注册：
-# 
+#
 #    try:
 #        from .java_extractor import register_java_extractor
 #        register_java_extractor()
 #    except (ImportError, Exception):
 #        pass
-# 
-# 
+#
+#
 # 方法2: 在运行时动态注册（不推荐，但可用）
-# 
+#
 # from jarvis.jarvis_agent.file_context_handler import register_language_extractor
-# 
+#
 # def create_ruby_extractor():
 #     # ... 实现提取器 ...
 #     return RubyExtractor()
-# 
+#
 # register_language_extractor('.rb', create_ruby_extractor)
-# 
+#
 # ============================================================================

jarvis/jarvis_agent/file_methodology_manager.py

@@ -3,11 +3,16 @@
 文件和方法论管理器模块
 负责处理文件上传和方法论加载功能
 """
+
 import os
 import tempfile
 
-from jarvis.jarvis_utils.methodology import load_methodology, upload_methodology
 from jarvis.jarvis_agent.utils import join_prompts
+from jarvis.jarvis_utils.config import get_normal_model_name
+from jarvis.jarvis_utils.config import get_normal_platform_name
+from jarvis.jarvis_utils.methodology import load_methodology
+from jarvis.jarvis_utils.methodology import upload_methodology
+from jarvis.jarvis_utils.output import PrettyOutput
 
 
 class FileMethodologyManager:
@@ -38,39 +43,45 @@ class FileMethodologyManager:
 
     def _handle_methodology_upload(self):
         """处理方法论上传"""
-        if not upload_methodology(self.agent.model, other_files=self.agent.files):  # type: ignore
+        if not upload_methodology(self.agent.model, other_files=self.agent.files):
             if self.agent.files:
-                print("⚠️ 文件上传失败，将忽略文件列表")
+                PrettyOutput.auto_print("⚠️ 文件上传失败，将忽略文件列表")
             # 上传失败则回退到本地加载
             self._load_local_methodology()
         else:
             # 上传成功
 
             if self.agent.files:
-                self.agent.session.prompt = join_prompts([
-                    self.agent.session.prompt,
-                    "上传的文件包含历史对话信息和方法论文件，可以从中获取一些经验信息。"
-                ])
+                self.agent.session.prompt = join_prompts(
+                    [
+                        self.agent.session.prompt,
+                        "上传的文件包含历史对话信息和方法论文件，可以从中获取一些经验信息。",
+                    ]
+                )
             else:
-                self.agent.session.prompt = join_prompts([
-                    self.agent.session.prompt,
-                    "上传的文件包含历史对话信息，可以从中获取一些经验信息。"
-                ])
+                self.agent.session.prompt = join_prompts(
+                    [
+                        self.agent.session.prompt,
+                        "上传的文件包含历史对话信息，可以从中获取一些经验信息。",
+                    ]
+                )
 
     def _handle_files_upload(self):
         """处理普通文件上传"""
-        if not self.agent.model.upload_files(self.agent.files):  # type: ignore
-            print("⚠️ 文件上传失败，将忽略文件列表")
+        if not self.agent.model.upload_files(self.agent.files):
+            PrettyOutput.auto_print("⚠️ 文件上传失败，将忽略文件列表")
         else:
-            self.agent.session.prompt = join_prompts([
-                self.agent.session.prompt,
-                "上传的文件包含历史对话信息，可以从中获取一些经验信息。"
-            ])
+            self.agent.session.prompt = join_prompts(
+                [
+                    self.agent.session.prompt,
+                    "上传的文件包含历史对话信息，可以从中获取一些经验信息。",
+                ]
+            )
 
     def _handle_local_mode(self):
         """处理本地模式（不支持文件上传）"""
         if self.agent.files:
-            print("⚠️ 不支持上传文件，将忽略文件列表")
+            PrettyOutput.auto_print("⚠️ 不支持上传文件，将忽略文件列表")
         if self.agent.use_methodology:
             self._load_local_methodology()
 
@@ -83,16 +94,19 @@ class FileMethodologyManager:
         from jarvis.jarvis_agent.memory_manager import MemoryManager
 
         MemoryManager(self.agent)
+        # 使用normal模型加载方法论
         methodology = load_methodology(
             msg,
             self.agent.get_tool_registry(),
-            platform_name=self.agent.model.platform_name(),
-            model_name=self.agent.model.name(),
+            platform_name=get_normal_platform_name(None),
+            model_name=get_normal_model_name(None),
+        )
+        self.agent.session.prompt = join_prompts(
+            [
+                self.agent.session.prompt,
+                f"以下是历史类似问题的执行经验，可参考：\n{methodology}",
+            ]
         )
-        self.agent.session.prompt = join_prompts([
-            self.agent.session.prompt,
-            f"以下是历史类似问题的执行经验，可参考：\n{methodology}"
-        ])
 
     def handle_history_with_file_upload(self) -> str:
         """使用文件上传方式处理历史"""