jarvis-ai-assistant 0.2.8__py3-none-any.whl → 0.3.0__py3-none-any.whl

jarvis/jarvis_tools/registry.py

@@ -191,6 +191,8 @@ class ToolRegistry(OutputHandlerProtocol):
         self._load_builtin_tools()
         self._load_external_tools()
         self._load_mcp_tools()
+        # 应用工具配置组过滤
+        self._apply_tool_config_filter()
 
     def _get_tool_stats(self) -> Dict[str, int]:
         """从数据目录获取工具调用统计"""
@@ -258,6 +260,36 @@ class ToolRegistry(OutputHandlerProtocol):
             name: tool for name, tool in self.tools.items() if name not in names
         }
 
+    def _apply_tool_config_filter(self) -> None:
+        """应用工具配置组的过滤规则"""
+        from jarvis.jarvis_utils.config import get_tool_use_list, get_tool_dont_use_list
+
+        use_list = get_tool_use_list()
+        dont_use_list = get_tool_dont_use_list()
+
+        # 如果配置了 use 列表，只保留列表中的工具
+        if use_list:
+            filtered_tools = {}
+            for tool_name in use_list:
+                if tool_name in self.tools:
+                    filtered_tools[tool_name] = self.tools[tool_name]
+                else:
+                    PrettyOutput.print(
+                        f"警告: 配置的工具 '{tool_name}' 不存在",
+                        OutputType.WARNING,
+                    )
+            self.tools = filtered_tools
+
+        # 如果配置了 dont_use 列表，排除列表中的工具
+        if dont_use_list:
+            for tool_name in dont_use_list:
+                if tool_name in self.tools:
+                    del self.tools[tool_name]
+                    PrettyOutput.print(
+                        f"已排除工具: {tool_name}",
+                        OutputType.INFO,
+                    )
+
     def _load_mcp_tools(self) -> None:
         """加载MCP工具，优先从配置获取，其次从目录扫描"""
         from jarvis.jarvis_utils.config import get_mcp_config

jarvis/jarvis_tools/retrieve_memory.py

@@ -4,9 +4,10 @@ import random
 from pathlib import Path
 from typing import Any, Dict, List, Optional
 
-from jarvis.jarvis_utils.config import get_data_dir
+from jarvis.jarvis_utils.config import get_data_dir, get_max_input_token_count
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 from jarvis.jarvis_utils.globals import get_short_term_memories
+from jarvis.jarvis_utils.embedding import get_context_token_count
 
 
 class RetrieveMemoryTool:
@@ -131,14 +132,41 @@ class RetrieveMemoryTool:
             # 按创建时间排序（最新的在前）
             all_memories.sort(key=lambda x: x.get("created_at", ""), reverse=True)
 
-            # 限制最多返回50条记忆，随机选取
-            if len(all_memories) > 50:
-                all_memories = random.sample(all_memories, 50)
-                # 重新排序，保持时间顺序
-                all_memories.sort(key=lambda x: x.get("created_at", ""), reverse=True)
+            # 获取最大输入token数的2/3作为记忆的token限制
+            max_input_tokens = get_max_input_token_count()
+            memory_token_limit = int(max_input_tokens * 2 / 3)
 
-            # 如果指定了限制，只返回前N个
-            if limit:
+            # 基于token限制和条数限制筛选记忆
+            filtered_memories: List[Dict[str, Any]] = []
+            total_tokens = 0
+
+            for memory in all_memories:
+                # 计算当前记忆的token数量
+                memory_content = json.dumps(memory, ensure_ascii=False)
+                memory_tokens = get_context_token_count(memory_content)
+
+                # 检查是否超过token限制
+                if total_tokens + memory_tokens > memory_token_limit:
+                    PrettyOutput.print(
+                        f"达到token限制 ({total_tokens}/{memory_token_limit})，停止加载更多记忆",
+                        OutputType.INFO,
+                    )
+                    break
+
+                # 检查是否超过50条限制
+                if len(filtered_memories) >= 50:
+                    PrettyOutput.print(
+                        f"达到记忆条数限制 (50条)，停止加载更多记忆", OutputType.INFO
+                    )
+                    break
+
+                filtered_memories.append(memory)
+                total_tokens += memory_tokens
+
+            all_memories = filtered_memories
+
+            # 如果指定了额外的限制，只返回前N个
+            if limit and len(all_memories) > limit:
                 all_memories = all_memories[:limit]
 
             # 打印结果摘要

jarvis/jarvis_utils/clipboard.py

@@ -0,0 +1,90 @@
+# -*- coding: utf-8 -*-
+import platform
+import subprocess
+
+from jarvis.jarvis_utils.output import OutputType, PrettyOutput
+
+
+def copy_to_clipboard(text: str) -> None:
+    """将文本复制到剪贴板，支持Windows、macOS和Linux
+
+    参数:
+        text: 要复制的文本
+    """
+    print("--- 剪贴板内容开始 ---")
+    print(text)
+    print("--- 剪贴板内容结束 ---")
+
+    system = platform.system()
+
+    # Windows系统
+    if system == "Windows":
+        try:
+            # 使用Windows的clip命令
+            process = subprocess.Popen(
+                ["clip"],
+                stdin=subprocess.PIPE,
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+                shell=True,
+            )
+            if process.stdin:
+                process.stdin.write(text.encode("utf-8"))
+                process.stdin.close()
+            return
+        except Exception as e:
+            PrettyOutput.print(f"使用Windows clip命令时出错: {e}", OutputType.WARNING)
+
+    # macOS系统
+    elif system == "Darwin":
+        try:
+            process = subprocess.Popen(
+                ["pbcopy"],
+                stdin=subprocess.PIPE,
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+            )
+            if process.stdin:
+                process.stdin.write(text.encode("utf-8"))
+                process.stdin.close()
+            return
+        except Exception as e:
+            PrettyOutput.print(f"使用macOS pbcopy命令时出错: {e}", OutputType.WARNING)
+
+    # Linux系统
+    else:
+        # 尝试使用 xsel
+        try:
+            process = subprocess.Popen(
+                ["xsel", "-b", "-i"],
+                stdin=subprocess.PIPE,
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+            )
+            if process.stdin:
+                process.stdin.write(text.encode("utf-8"))
+                process.stdin.close()
+            return
+        except FileNotFoundError:
+            pass  # xsel 未安装，继续尝试下一个
+        except Exception as e:
+            PrettyOutput.print(f"使用xsel时出错: {e}", OutputType.WARNING)
+
+        # 尝试使用 xclip
+        try:
+            process = subprocess.Popen(
+                ["xclip", "-selection", "clipboard"],
+                stdin=subprocess.PIPE,
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+            )
+            if process.stdin:
+                process.stdin.write(text.encode("utf-8"))
+                process.stdin.close()
+            return
+        except FileNotFoundError:
+            PrettyOutput.print(
+                "xsel 和 xclip 均未安装, 无法复制到剪贴板", OutputType.WARNING
+            )
+        except Exception as e:
+            PrettyOutput.print(f"使用xclip时出错: {e}", OutputType.WARNING)

jarvis/jarvis_utils/config.py

@@ -487,3 +487,57 @@ def get_rag_use_rerank() -> bool:
     """
     config = _get_resolved_rag_config()
     return config.get("use_rerank", True) is True
+
+
+# ==============================================================================
+# Tool Configuration
+# ==============================================================================
+
+
+def _get_resolved_tool_config(
+    tool_group_override: Optional[str] = None,
+) -> Dict[str, Any]:
+    """
+    解析并合并工具配置，处理工具组。
+
+    优先级顺序:
+    1. JARVIS_TOOL_GROUP 中定义的组配置
+    2. 默认配置（所有工具都启用）
+
+    返回:
+        Dict[str, Any]: 解析后的工具配置字典，包含 'use' 和 'dont_use' 列表
+    """
+    group_config = {}
+    tool_group_name = tool_group_override or GLOBAL_CONFIG_DATA.get("JARVIS_TOOL_GROUP")
+    tool_groups = GLOBAL_CONFIG_DATA.get("JARVIS_TOOL_GROUPS", [])
+
+    if tool_group_name and isinstance(tool_groups, list):
+        for group_item in tool_groups:
+            if isinstance(group_item, dict) and tool_group_name in group_item:
+                group_config = group_item[tool_group_name]
+                break
+
+    # 如果没有找到配置组，返回默认配置（空列表表示使用所有工具）
+    return group_config.copy() if group_config else {"use": [], "dont_use": []}
+
+
+def get_tool_use_list() -> List[str]:
+    """
+    获取要使用的工具列表。
+
+    返回:
+        List[str]: 要使用的工具名称列表，空列表表示使用所有工具
+    """
+    config = _get_resolved_tool_config()
+    return config.get("use", [])
+
+
+def get_tool_dont_use_list() -> List[str]:
+    """
+    获取不使用的工具列表。
+
+    返回:
+        List[str]: 不使用的工具名称列表
+    """
+    config = _get_resolved_tool_config()
+    return config.get("dont_use", [])

jarvis/jarvis_utils/git_utils.py

@@ -214,7 +214,9 @@ def handle_commit_workflow() -> bool:
     Returns:
         bool: 提交是否成功
     """
-    if is_confirm_before_apply_patch() and not user_confirm("是否要提交代码？", default=True):
+    if is_confirm_before_apply_patch() and not user_confirm(
+        "是否要提交代码？", default=True
+    ):
         revert_change()
         return False
 
@@ -280,7 +282,7 @@ def get_latest_commit_hash() -> str:
         return ""
 
 
-def get_modified_line_ranges() -> Dict[str, Tuple[int, int]]:
+def get_modified_line_ranges() -> Dict[str, List[Tuple[int, int]]]:
     """从Git差异中获取所有更改文件的修改行范围
 
     返回：
@@ -291,7 +293,7 @@ def get_modified_line_ranges() -> Dict[str, Tuple[int, int]]:
     diff_output = os.popen("git show").read()
 
     # 解析差异以获取修改的文件及其行范围
-    result = {}
+    result: Dict[str, List[Tuple[int, int]]] = {}
     current_file = None
 
     for line in diff_output.splitlines():
@@ -427,7 +429,9 @@ def check_and_update_git_repo(repo_path: str) -> bool:
                 if not in_venv and (
                     "Permission denied" in error_msg or "not writeable" in error_msg
                 ):
-                    if user_confirm("检测到权限问题，是否尝试用户级安装(--user)？", True):
+                    if user_confirm(
+                        "检测到权限问题，是否尝试用户级安装(--user)？", True
+                    ):
                         user_result = subprocess.run(
                             install_cmd + ["--user"],
                             cwd=git_root,
@@ -442,7 +446,9 @@ def check_and_update_git_repo(repo_path: str) -> bool:
                 PrettyOutput.print(f"代码安装失败: {error_msg}", OutputType.ERROR)
                 return False
             except Exception as e:
-                PrettyOutput.print(f"安装过程中发生意外错误: {str(e)}", OutputType.ERROR)
+                PrettyOutput.print(
+                    f"安装过程中发生意外错误: {str(e)}", OutputType.ERROR
+                )
                 return False
         # 更新检查日期文件
         with open(last_check_file, "w") as f:
@@ -476,7 +482,9 @@ def get_diff_file_list() -> List[str]:
         subprocess.run(["git", "reset"], check=True)
 
         if result.returncode != 0:
-            PrettyOutput.print(f"获取差异文件列表失败: {result.stderr}", OutputType.ERROR)
+            PrettyOutput.print(
+                f"获取差异文件列表失败: {result.stderr}", OutputType.ERROR
+            )
             return []
 
         return [f for f in result.stdout.splitlines() if f]
@@ -626,7 +634,9 @@ def confirm_add_new_files() -> None:
             need_confirm = True
 
         if binary_files:
-            output_lines.append(f"检测到{len(binary_files)}个二进制文件(选择N将重新检测)")
+            output_lines.append(
+                f"检测到{len(binary_files)}个二进制文件(选择N将重新检测)"
+            )
             output_lines.append("二进制文件列表:")
             output_lines.extend(f"  - {file}" for file in binary_files)
             need_confirm = True

jarvis/jarvis_utils/globals.py

@@ -264,7 +264,7 @@ def get_all_memory_tags() -> Dict[str, List[str]]:
     """
     获取所有记忆类型中的标签集合。
     每个类型最多返回200个标签，超过时随机提取。
-    
+
     返回:
         Dict[str, List[str]]: 按记忆类型分组的标签列表
     """
@@ -272,25 +272,27 @@ def get_all_memory_tags() -> Dict[str, List[str]]:
     import json
     import random
     from jarvis.jarvis_utils.config import get_data_dir
-    
-    tags_by_type = {
+
+    tags_by_type: Dict[str, List[str]] = {
         "short_term": [],
         "project_long_term": [],
-        "global_long_term": []
+        "global_long_term": [],
     }
-    
+
     MAX_TAGS_PER_TYPE = 200
-    
+
     # 获取短期记忆标签
     short_term_tags = set()
     for memory in short_term_memories:
         short_term_tags.update(memory.get("tags", []))
     short_term_tags_list = sorted(list(short_term_tags))
     if len(short_term_tags_list) > MAX_TAGS_PER_TYPE:
-        tags_by_type["short_term"] = sorted(random.sample(short_term_tags_list, MAX_TAGS_PER_TYPE))
+        tags_by_type["short_term"] = sorted(
+            random.sample(short_term_tags_list, MAX_TAGS_PER_TYPE)
+        )
     else:
         tags_by_type["short_term"] = short_term_tags_list
-    
+
     # 获取项目长期记忆标签
     project_memory_dir = Path(".jarvis/memory")
     if project_memory_dir.exists():
@@ -304,10 +306,12 @@ def get_all_memory_tags() -> Dict[str, List[str]]:
                 pass
         project_tags_list = sorted(list(project_tags))
         if len(project_tags_list) > MAX_TAGS_PER_TYPE:
-            tags_by_type["project_long_term"] = sorted(random.sample(project_tags_list, MAX_TAGS_PER_TYPE))
+            tags_by_type["project_long_term"] = sorted(
+                random.sample(project_tags_list, MAX_TAGS_PER_TYPE)
+            )
         else:
             tags_by_type["project_long_term"] = project_tags_list
-    
+
     # 获取全局长期记忆标签
     global_memory_dir = Path(get_data_dir()) / "memory" / "global_long_term"
     if global_memory_dir.exists():
@@ -321,8 +325,10 @@ def get_all_memory_tags() -> Dict[str, List[str]]:
                 pass
         global_tags_list = sorted(list(global_tags))
         if len(global_tags_list) > MAX_TAGS_PER_TYPE:
-            tags_by_type["global_long_term"] = sorted(random.sample(global_tags_list, MAX_TAGS_PER_TYPE))
+            tags_by_type["global_long_term"] = sorted(
+                random.sample(global_tags_list, MAX_TAGS_PER_TYPE)
+            )
         else:
             tags_by_type["global_long_term"] = global_tags_list
-    
+
     return tags_by_type

jarvis/jarvis_utils/input.py

@@ -9,40 +9,141 @@
 - 用于输入控制的自定义键绑定
 """
 import os
-from typing import Iterable
+from typing import Iterable, List
 
 from colorama import Fore
-from colorama import Style as ColoramaStyle  # type: ignore
-from fuzzywuzzy import process  # type: ignore
-from prompt_toolkit import PromptSession  # type: ignore
-from prompt_toolkit.completion import CompleteEvent  # type: ignore
+from colorama import Style as ColoramaStyle
+from fuzzywuzzy import process
+from prompt_toolkit import PromptSession
+from prompt_toolkit.application import Application
+from prompt_toolkit.completion import CompleteEvent
 from prompt_toolkit.completion import (
     Completer,
     Completion,
     PathCompleter,
 )
-from prompt_toolkit.document import Document  # type: ignore
-from prompt_toolkit.formatted_text import FormattedText  # type: ignore
-from prompt_toolkit.history import FileHistory  # type: ignore
-from prompt_toolkit.key_binding import KeyBindings  # type: ignore
-from prompt_toolkit.styles import Style as PromptStyle  # type: ignore
-
+from prompt_toolkit.document import Document
+from prompt_toolkit.formatted_text import FormattedText
+from prompt_toolkit.history import FileHistory
+from prompt_toolkit.key_binding import KeyBindings
+from prompt_toolkit.layout.containers import Window
+from prompt_toolkit.layout.controls import FormattedTextControl
+from prompt_toolkit.layout.layout import Layout
+from prompt_toolkit.styles import Style as PromptStyle
+
+from jarvis.jarvis_utils.clipboard import copy_to_clipboard
 from jarvis.jarvis_utils.config import get_data_dir, get_replace_map
+from jarvis.jarvis_utils.globals import get_message_history
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 from jarvis.jarvis_utils.tag import ot
-from jarvis.jarvis_utils.utils import copy_to_clipboard
 
 # Sentinel value to indicate that Ctrl+O was pressed
 CTRL_O_SENTINEL = "__CTRL_O_PRESSED__"
 
 
-def get_single_line_input(tip: str) -> str:
+def get_single_line_input(tip: str, default: str = "") -> str:
     """
     获取支持历史记录的单行输入。
     """
     session: PromptSession = PromptSession(history=None)
     style = PromptStyle.from_dict({"prompt": "ansicyan"})
-    return session.prompt(f"{tip}", style=style)
+    return session.prompt(f"{tip}", default=default, style=style)
+
+
+def get_choice(tip: str, choices: List[str]) -> str:
+    """
+    提供一个可滚动的选择列表供用户选择。
+    """
+    if not choices:
+        raise ValueError("Choices cannot be empty.")
+
+    try:
+        terminal_height = os.get_terminal_size().lines
+    except OSError:
+        terminal_height = 25  # 如果无法确定终端大小，则使用默认高度
+
+    # 为提示和缓冲区保留行
+    max_visible_choices = max(5, terminal_height - 4)
+
+    bindings = KeyBindings()
+    selected_index = 0
+    start_index = 0
+
+    @bindings.add("up")
+    def _(event):
+        nonlocal selected_index, start_index
+        selected_index = (selected_index - 1 + len(choices)) % len(choices)
+        if selected_index < start_index:
+            start_index = selected_index
+        elif selected_index == len(choices) - 1:  # 支持从第一项上翻到最后一项时滚动
+            start_index = max(0, len(choices) - max_visible_choices)
+        event.app.invalidate()
+
+    @bindings.add("down")
+    def _(event):
+        nonlocal selected_index, start_index
+        selected_index = (selected_index + 1) % len(choices)
+        if selected_index >= start_index + max_visible_choices:
+            start_index = selected_index - max_visible_choices + 1
+        elif selected_index == 0:  # 支持从最后一项下翻到第一项时滚动
+            start_index = 0
+        event.app.invalidate()
+
+    @bindings.add("enter")
+    def _(event):
+        event.app.exit(result=choices[selected_index])
+
+    def get_prompt_tokens():
+        tokens = [("class:question", f"{tip} (使用上下箭头选择, Enter确认)\n")]
+
+        end_index = min(start_index + max_visible_choices, len(choices))
+        visible_choices_slice = choices[start_index:end_index]
+
+        if start_index > 0:
+            tokens.append(("class:indicator", "  ... (更多选项在上方) ...\n"))
+
+        for i, choice in enumerate(visible_choices_slice, start=start_index):
+            if i == selected_index:
+                tokens.append(("class:selected", f"> {choice}\n"))
+            else:
+                tokens.append(("", f"  {choice}\n"))
+
+        if end_index < len(choices):
+            tokens.append(("class:indicator", "  ... (更多选项在下方) ...\n"))
+
+        return FormattedText(tokens)
+
+    style = PromptStyle.from_dict(
+        {
+            "question": "bold",
+            "selected": "bg:#696969 #ffffff",
+            "indicator": "fg:gray",
+        }
+    )
+
+    layout = Layout(
+        container=Window(
+            content=FormattedTextControl(
+                text=get_prompt_tokens,
+                focusable=True,
+                key_bindings=bindings,
+            )
+        )
+    )
+
+    app: Application = Application(
+        layout=layout,
+        key_bindings=bindings,
+        style=style,
+        mouse_support=True,
+        full_screen=True,
+    )
+
+    try:
+        result = app.run()
+        return result if result is not None else ""
+    except (KeyboardInterrupt, EOFError):
+        return ""
 
 
 class FileCompleter(Completer):
@@ -160,7 +261,6 @@ def _show_history_and_copy():
     Displays message history and handles copying to clipboard.
     This function uses standard I/O and is safe to call outside a prompt session.
     """
-    from jarvis.jarvis_utils.globals import get_message_history
 
     history = get_message_history()
     if not history:
@@ -170,7 +270,9 @@ def _show_history_and_copy():
     print("\n" + "=" * 20 + " 消息历史记录 " + "=" * 20)
     for i, msg in enumerate(history):
         cleaned_msg = msg.replace("\n", r"\n")
-        display_msg = (cleaned_msg[:70] + "...") if len(cleaned_msg) > 70 else cleaned_msg
+        display_msg = (
+            (cleaned_msg[:70] + "...") if len(cleaned_msg) > 70 else cleaned_msg
+        )
         print(f"  {i + 1}: {display_msg.strip()}")
     print("=" * 58 + "\n")
 

jarvis/jarvis_utils/methodology.py

@@ -19,10 +19,12 @@ from jarvis.jarvis_utils.config import (
     get_data_dir,
     get_methodology_dirs,
     get_central_methodology_repo,
+    get_max_input_token_count,
 )
 from jarvis.jarvis_utils.globals import get_agent, current_agent_name
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 from jarvis.jarvis_utils.utils import is_context_overflow, daily_check_git_updates
+from jarvis.jarvis_utils.embedding import get_context_token_count
 
 
 def _get_methodology_directory() -> str:
@@ -273,14 +275,16 @@ def load_methodology(user_input: str, tool_registery: Optional[Any] = None) -> s
         if not selected_methodologies:
             return "没有历史方法论可参考"
 
+        # 获取最大输入token数的2/3作为方法论的token限制
+        max_input_tokens = get_max_input_token_count()
+        methodology_token_limit = int(max_input_tokens * 2 / 3)
+
         # 步骤3：将选择出来的方法论内容提供给大模型生成步骤
-        final_prompt = f"""以下是与用户需求相关的方法论内容：
+        # 首先构建基础提示词部分
+        base_prompt = f"""以下是与用户需求相关的方法论内容：
 
 """
-        for problem_type, content in selected_methodologies.items():
-            final_prompt += f"## {problem_type}\n\n{content}\n\n---\n\n"
-
-        final_prompt += f"""以下是所有可用的工具内容：
+        suffix_prompt = f"""以下是所有可用的工具内容：
 
 {prompt}
 
@@ -300,6 +304,45 @@ def load_methodology(user_input: str, tool_registery: Optional[Any] = None) -> s
 除以上要求外，不要输出任何内容
 """
 
+        # 计算基础部分的token数
+        base_tokens = get_context_token_count(base_prompt + suffix_prompt)
+        available_tokens = methodology_token_limit - base_tokens
+
+        # 基于token限制筛选方法论内容
+        final_prompt = base_prompt
+        selected_count = 0
+        total_methodology_tokens = 0
+
+        for problem_type, content in selected_methodologies.items():
+            methodology_text = f"## {problem_type}\n\n{content}\n\n---\n\n"
+            methodology_tokens = get_context_token_count(methodology_text)
+
+            # 检查是否会超过token限制
+            if total_methodology_tokens + methodology_tokens > available_tokens:
+                PrettyOutput.print(
+                    f"达到方法论token限制 ({total_methodology_tokens}/{available_tokens})，停止加载更多方法论",
+                    OutputType.INFO,
+                )
+                break
+
+            final_prompt += methodology_text
+            total_methodology_tokens += methodology_tokens
+            selected_count += 1
+
+        # 如果一个方法论都没有加载成功
+        if selected_count == 0:
+            PrettyOutput.print(
+                "警告：由于token限制，无法加载任何方法论内容", OutputType.WARNING
+            )
+            return "没有历史方法论可参考"
+
+        final_prompt += suffix_prompt
+
+        PrettyOutput.print(
+            f"成功加载 {selected_count} 个方法论，总token数: {total_methodology_tokens}",
+            OutputType.INFO,
+        )
+
         # 如果内容不大，直接使用chat_until_success
         return platform.chat_until_success(final_prompt)