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

jarvis/jarvis_agent/agent_manager.py

@@ -1,20 +1,16 @@
 # -*- coding: utf-8 -*-
 """Agent管理器模块，负责Agent的初始化和任务执行"""
-from typing import Optional
+from typing import Optional, Callable
 
 import typer
 
 from jarvis.jarvis_agent import (
     Agent,
-    OutputType,
-    PrettyOutput,
     get_multiline_input,
     origin_agent_system_prompt,
 )
-from jarvis.jarvis_agent.builtin_input_handler import builtin_input_handler
-from jarvis.jarvis_agent.shell_input_handler import shell_input_handler
 from jarvis.jarvis_agent.task_manager import TaskManager
-from jarvis.jarvis_tools.registry import ToolRegistry
+from jarvis.jarvis_utils.config import is_non_interactive, is_skip_predefined_tasks
 
 
 class AgentManager:
@@ -27,6 +23,9 @@ class AgentManager:
         restore_session: bool = False,
         use_methodology: Optional[bool] = None,
         use_analysis: Optional[bool] = None,
+        multiline_inputer: Optional[Callable[[str], str]] = None,
+        confirm_callback: Optional[Callable[[str, bool], bool]] = None,
+        non_interactive: Optional[bool] = None,
     ):
         self.model_group = model_group
         self.tool_group = tool_group
@@ -34,6 +33,10 @@ class AgentManager:
         self.use_methodology = use_methodology
         self.use_analysis = use_analysis
         self.agent: Optional[Agent] = None
+        # 可选：注入输入与确认回调，用于Web模式等前端替代交互
+        self.multiline_inputer = multiline_inputer
+        self.confirm_callback = confirm_callback
+        self.non_interactive = non_interactive
 
     def initialize(self) -> Agent:
         """初始化Agent"""
@@ -46,19 +49,20 @@ class AgentManager:
         self.agent = Agent(
             system_prompt=origin_agent_system_prompt,
             model_group=self.model_group,
-            input_handler=[shell_input_handler, builtin_input_handler],
-            output_handler=[ToolRegistry()],  # type: ignore
             need_summary=False,
             use_methodology=self.use_methodology,
             use_analysis=self.use_analysis,
+            multiline_inputer=self.multiline_inputer,
+            confirm_callback=self.confirm_callback,
+            non_interactive=self.non_interactive,
         )
 
         # 尝试恢复会话
         if self.restore_session:
             if self.agent.restore_session():
-                PrettyOutput.print("会话已成功恢复。", OutputType.SUCCESS)
+                print("✅ 会话已成功恢复。")
             else:
-                PrettyOutput.print("无法恢复会话。", OutputType.WARNING)
+                print("⚠️ 无法恢复会话。")
 
         return self.agent
 
@@ -72,12 +76,12 @@ class AgentManager:
             self.agent.run(task_content)
             raise typer.Exit(code=0)
 
-        # 处理预定义任务
-        if self.agent.first:
+        # 处理预定义任务（非交互模式下跳过；支持配置跳过加载；命令行指定任务时跳过）
+        if not is_non_interactive() and not is_skip_predefined_tasks() and not task_content and self.agent.first:
             task_manager = TaskManager()
             tasks = task_manager.load_tasks()
             if tasks and (selected_task := task_manager.select_task(tasks)):
-                PrettyOutput.print(f"开始执行任务: \n{selected_task}", OutputType.INFO)
+                print(f"ℹ️ 开始执行任务: \n{selected_task}")
                 self.agent.run(selected_task)
                 raise typer.Exit(code=0)
 

jarvis/jarvis_agent/builtin_input_handler.py

@@ -55,14 +55,10 @@ def builtin_input_handler(user_input: str, agent_: Any) -> Tuple[str, bool]:
             return "", True
         elif tag == "SaveSession":
             if agent.save_session():
-                from jarvis.jarvis_utils.output import OutputType, PrettyOutput
-
-                PrettyOutput.print("会话已成功保存。正在退出...", OutputType.SUCCESS)
+                print("✅ 会话已成功保存。正在退出...")
                 sys.exit(0)
             else:
-                from jarvis.jarvis_utils.output import OutputType, PrettyOutput
-
-                PrettyOutput.print("保存会话失败。", OutputType.ERROR)
+                print("❌ 保存会话失败。")
             return "", True
 
         processed_tag = set()

jarvis/jarvis_agent/config_editor.py

@@ -9,8 +9,6 @@ from typing import Optional
 
 import typer
 
-from jarvis.jarvis_agent import OutputType, PrettyOutput
-
 
 class ConfigEditor:
     """配置文件编辑器"""
@@ -47,11 +45,8 @@ class ConfigEditor:
                 )
                 raise typer.Exit(code=0)
             except (subprocess.CalledProcessError, FileNotFoundError) as e:
-                PrettyOutput.print(f"Failed to open editor: {e}", OutputType.ERROR)
+                print(f"❌ Failed to open editor: {e}")
                 raise typer.Exit(code=1)
         else:
-            PrettyOutput.print(
-                "No suitable editor found. Please install one of: vim, nano, emacs, code",
-                OutputType.ERROR,
-            )
+            print("❌ No suitable editor found. Please install one of: vim, nano, emacs, code")
             raise typer.Exit(code=1)

jarvis/jarvis_agent/event_bus.py

@@ -6,41 +6,111 @@
 - 提供简单可靠的发布/订阅机制
 - 回调异常隔离，避免影响主流程
 - 不引入额外依赖，便于在 Agent 中渐进集成
+- 支持优先级排序，优先级数字越小，执行越早
 """
 from collections import defaultdict
-from typing import Callable, DefaultDict, Dict, List, Any
-
+from typing import Callable, DefaultDict, List, Any, Tuple
 
 
 class EventBus:
     """
     简单的同步事件总线。
-    - subscribe(event, callback): 订阅事件
-    - emit(event, **kwargs): 广播事件
+    - subscribe(event, callback, priority=100): 订阅事件，支持优先级
+    - emit(event, **kwargs): 广播事件，按优先级顺序执行回调
     - unsubscribe(event, callback): 取消订阅
+    
+    优先级说明：
+    - 数字越小，优先级越高，执行越早
+    - 默认优先级为 100（中等优先级）
+    - 建议优先级范围：0-200
+    - 相同优先级时，按注册顺序执行（先注册的先执行）
     """
 
     def __init__(self) -> None:
-        self._listeners: DefaultDict[str, List[Callable[..., None]]] = defaultdict(list)
+        # 存储 (priority, order, callback) 元组列表，按优先级和注册顺序排序
+        # order 用于相同优先级时保持注册顺序
+        self._listeners: DefaultDict[str, List[Tuple[int, int, Callable[..., None]]]] = defaultdict(list)
+        # 注册顺序计数器（每个事件独立计数）
+        self._order_counter: DefaultDict[str, int] = defaultdict(int)
+        # 缓存排序后的回调列表，避免每次emit都排序
+        self._sorted_cache: DefaultDict[str, List[Callable[..., None]]] = defaultdict(list)
+        # 标记是否需要重新排序
+        self._dirty: DefaultDict[str, bool] = defaultdict(lambda: False)
 
-    def subscribe(self, event: str, callback: Callable[..., None]) -> None:
+    def subscribe(self, event: str, callback: Callable[..., None], priority: int = 100) -> None:
+        """
+        订阅事件。
+        
+        参数:
+            event: 事件名称
+            callback: 回调函数
+            priority: 优先级，数字越小优先级越高（默认100）
+                     相同优先级时，按注册顺序执行（先注册的先执行）
+        """
         if not callable(callback):
             raise TypeError("callback must be callable")
-        self._listeners[event].append(callback)
+        # 获取当前注册顺序
+        order = self._order_counter[event]
+        self._order_counter[event] += 1
+        # 添加 (priority, order, callback) 元组
+        self._listeners[event].append((priority, order, callback))
+        # 标记需要重新排序
+        self._dirty[event] = True
 
     def unsubscribe(self, event: str, callback: Callable[..., None]) -> None:
+        """
+        取消订阅事件。
+        
+        参数:
+            event: 事件名称
+            callback: 要取消的回调函数
+        """
         if event not in self._listeners:
             return
-        try:
-            self._listeners[event].remove(callback)
-        except ValueError:
-            pass
+        # 查找并移除匹配的回调
+        listeners = self._listeners[event]
+        for i, (_, _, cb) in enumerate(listeners):
+            if cb == callback:
+                listeners.pop(i)
+                self._dirty[event] = True
+                break
+
+    def _get_sorted_callbacks(self, event: str) -> List[Callable[..., None]]:
+        """
+        获取排序后的回调列表（带缓存）。
+        
+        参数:
+            event: 事件名称
+            
+        返回:
+            按优先级排序的回调函数列表（相同优先级时按注册顺序）
+        """
+        # 如果缓存有效，直接返回
+        if not self._dirty[event] and event in self._sorted_cache:
+            return self._sorted_cache[event]
+        
+        # 按优先级排序（数字越小优先级越高），相同优先级时按注册顺序（order）
+        listeners = self._listeners[event]
+        sorted_listeners = sorted(listeners, key=lambda x: (x[0], x[1]))
+        callbacks = [cb for _, _, cb in sorted_listeners]
+        
+        # 更新缓存
+        self._sorted_cache[event] = callbacks
+        self._dirty[event] = False
+        
+        return callbacks
 
     def emit(self, event: str, **payload: Any) -> None:
         """
         广播事件。回调中的异常将被捕获并忽略，以保证主流程稳定。
+        回调按优先级顺序执行（优先级数字越小，执行越早）。
+        
+        参数:
+            event: 事件名称
+            **payload: 事件负载数据
         """
-        for cb in list(self._listeners.get(event, [])):
+        callbacks = self._get_sorted_callbacks(event)
+        for cb in callbacks:
             try:
                 cb(**payload)
             except Exception:

jarvis/jarvis_agent/file_context_handler.py

@@ -0,0 +1,329 @@
+# -*- coding: utf-8 -*-
+import re
+import os
+from typing import Any, Tuple, List, Dict, Optional, Callable
+
+
+# 语言提取器注册表（导出供其他模块使用）
+_LANGUAGE_EXTRACTORS: Dict[str, Callable[[], Optional[Any]]] = {}
+
+
+def is_text_file(filepath: str) -> bool:
+    """
+    Check if a file is a text file.
+    """
+    try:
+        with open(filepath, "r", encoding="utf-8") as f:
+            f.read(1024)  # Try to read a small chunk
+        return True
+    except (UnicodeDecodeError, IOError):
+        return False
+
+
+def count_lines(filepath: str) -> int:
+    """
+    Count the number of lines in a file.
+    """
+    try:
+        with open(filepath, "r", encoding="utf-8", errors="ignore") as f:
+            return sum(1 for _ in f)
+    except IOError:
+        return 0
+
+
+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.
+        extractor_factory: A callable that returns an extractor instance or None if unavailable.
+                          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
+    if extractor_factory is None:
+        # Used as decorator: @register_language_extractor(['.ext'])
+        def decorator(func: Callable[[], Optional[Any]]) -> Callable[[], Optional[Any]]:
+            if isinstance(extensions, str):
+                exts = [extensions]
+            else:
+                exts = extensions
+            
+            for ext in exts:
+                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
+            _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
+
+
+# Initialize built-in extractors on module load
+# Import language_extractors module to trigger automatic registration
+try:
+    import jarvis.jarvis_agent.language_extractors  # noqa: F401
+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}",
+            })
+        
+        return result
+    except Exception:
+        return []
+
+
+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:
+        symbol_type = symbol["type"]
+        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": "函数",
+        "async_function": "异步函数",
+        "class": "类",
+        "struct": "结构体",
+        "enum": "枚举",
+        "interface": "接口",
+        "trait": "特征",
+        "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 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)
+
+
+def file_context_handler(user_input: str, agent_: Any) -> Tuple[str, bool]:
+    """
+    Extracts file paths from the input, extracts symbols from those files,
+    and appends the symbol list to the input.
+
+    Args:
+        user_input: The user's input string.
+        agent_: The agent instance.
+
+    Returns:
+        A tuple containing the modified user input and a boolean indicating if
+        further processing should be skipped.
+    """
+    # Regex to find paths in single quotes
+    raw_paths = re.findall(r"'([^']+)'", user_input)
+    # Convert to absolute paths and de-duplicate by absolute path while preserving order
+    abs_to_raws: dict[str, list[str]] = {}
+    file_paths = []
+    for _raw in raw_paths:
+        abs_path = os.path.abspath(_raw)
+        if abs_path not in abs_to_raws:
+            abs_to_raws[abs_path] = []
+            file_paths.append(abs_path)
+        abs_to_raws[abs_path].append(_raw)
+
+    if not file_paths:
+        return user_input, False
+
+    added_context = ""
+
+    for abs_path in file_paths:
+        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
+                added_context += format_symbols_output(abs_path, symbols)
+
+    if added_context:
+        user_input = user_input.strip() + added_context
+
+    return user_input, False
+
+
+# ============================================================================
+# 如何添加新语言支持
+# ============================================================================
+# 
+# 推荐方式：在 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 = {
+#                                "method.name": "method",
+#                                "class.name": "class",
+#                            }
+#                            symbol_kind = kind_map.get(name)
+#                            if symbol_kind:
+#                                symbols.append(Symbol(
+#                                    name=node.text.decode('utf8'),
+#                                    kind=symbol_kind,
+#                                    file_path=file_path,
+#                                    line_start=node.start_point[0] + 1,
+#                                    line_end=node.end_point[0] + 1,
+#                                ))
+#                        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

@@ -7,7 +7,6 @@ import os
 import tempfile
 
 from jarvis.jarvis_utils.methodology import load_methodology, upload_methodology
-from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 from jarvis.jarvis_agent.utils import join_prompts
 
 
@@ -41,7 +40,7 @@ class FileMethodologyManager:
         """处理方法论上传"""
         if not upload_methodology(self.agent.model, other_files=self.agent.files):  # type: ignore
             if self.agent.files:
-                PrettyOutput.print("文件上传失败，将忽略文件列表", OutputType.WARNING)
+                print("⚠️ 文件上传失败，将忽略文件列表")
             # 上传失败则回退到本地加载
             self._load_local_methodology()
         else:
@@ -61,7 +60,7 @@ class FileMethodologyManager:
     def _handle_files_upload(self):
         """处理普通文件上传"""
         if not self.agent.model.upload_files(self.agent.files):  # type: ignore
-            PrettyOutput.print("文件上传失败，将忽略文件列表", OutputType.WARNING)
+            print("⚠️ 文件上传失败，将忽略文件列表")
         else:
             self.agent.session.prompt = join_prompts([
                 self.agent.session.prompt,
@@ -71,7 +70,7 @@ class FileMethodologyManager:
     def _handle_local_mode(self):
         """处理本地模式（不支持文件上传）"""
         if self.agent.files:
-            PrettyOutput.print("不支持上传文件，将忽略文件列表", OutputType.WARNING)
+            print("⚠️ 不支持上传文件，将忽略文件列表")
         if self.agent.use_methodology:
             self._load_local_methodology()