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

jarvis/jarvis_tools/registry.py

@@ -107,17 +107,13 @@ arguments:
 
 
 class OutputHandlerProtocol(Protocol):
-    def name(self) -> str:
-        ...
+    def name(self) -> str: ...
 
-    def can_handle(self, response: str) -> bool:
-        ...
+    def can_handle(self, response: str) -> bool: ...
 
-    def prompt(self) -> str:
-        ...
+    def prompt(self) -> str: ...
 
-    def handle(self, response: str, agent: Any) -> Tuple[bool, Any]:
-        ...
+    def handle(self, response: str, agent: Any) -> Tuple[bool, Any]: ...
 
 
 class ToolRegistry(OutputHandlerProtocol):
@@ -138,9 +134,7 @@ class ToolRegistry(OutputHandlerProtocol):
                 try:
                     tools_prompt += "    <tool>\n"
                     tools_prompt += f"      <name>名称: {tool['name']}</name>\n"
-                    tools_prompt += (
-                        f"      <description>描述: {tool['description']}</description>\n"
-                    )
+                    tools_prompt += f"      <description>描述: {tool['description']}</description>\n"
                     tools_prompt += "      <parameters>\n"
                     tools_prompt += "        <yaml>|\n"
 
@@ -197,20 +191,22 @@ 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]:
         """从数据目录获取工具调用统计"""
         from jarvis.jarvis_stats.stats import StatsManager
         from datetime import datetime, timedelta
-        
+
         # 获取所有工具的统计数据
         tool_stats = {}
         tools = self.get_all_tools()
-        
+
         # 获取所有历史数据（从很早的时间开始）
         end_time = datetime.now()
         start_time = datetime(2000, 1, 1)  # 使用一个足够早的时间
-        
+
         for tool in tools:
             tool_name = tool["name"]
             # 获取该工具的统计数据
@@ -218,22 +214,22 @@ class ToolRegistry(OutputHandlerProtocol):
                 metric_name=tool_name,
                 start_time=start_time,
                 end_time=end_time,
-                tags={"group": "tool"}
+                tags={"group": "tool"},
             )
-            
+
             # 计算总调用次数
             if stats_data and "records" in stats_data:
                 total_count = sum(record["value"] for record in stats_data["records"])
                 tool_stats[tool_name] = int(total_count)
             else:
                 tool_stats[tool_name] = 0
-                
+
         return tool_stats
 
     def _update_tool_stats(self, name: str) -> None:
         """更新工具调用统计"""
         from jarvis.jarvis_stats.stats import StatsManager
-        
+
         StatsManager.increment(name, group="tool")
 
     def use_tools(self, name: List[str]) -> None:
@@ -264,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
@@ -292,7 +318,9 @@ class ToolRegistry(OutputHandlerProtocol):
                 config = yaml.safe_load(open(file_path, "r", encoding="utf-8"))
                 self.register_mcp_tool_by_config(config)
             except Exception as e:
-                PrettyOutput.print(f"文件 {file_path} 加载失败: {str(e)}", OutputType.WARNING)
+                PrettyOutput.print(
+                    f"文件 {file_path} 加载失败: {str(e)}", OutputType.WARNING
+                )
 
     def _load_builtin_tools(self) -> None:
         """从内置工具目录加载工具"""
@@ -308,8 +336,33 @@ class ToolRegistry(OutputHandlerProtocol):
 
     def _load_external_tools(self) -> None:
         """从jarvis_data/tools和配置的目录加载外部工具"""
+        from jarvis.jarvis_utils.config import get_central_tool_repo
+
         tool_dirs = [str(Path(get_data_dir()) / "tools")] + get_tool_load_dirs()
 
+        # 如果配置了中心工具仓库，将其添加到加载路径
+        central_repo = get_central_tool_repo()
+        if central_repo:
+            # 中心工具仓库存储在数据目录下的特定位置
+            central_repo_path = os.path.join(get_data_dir(), "central_tool_repo")
+            tool_dirs.append(central_repo_path)
+
+            # 确保中心工具仓库被克隆/更新
+            if not os.path.exists(central_repo_path):
+                try:
+                    import subprocess
+
+                    PrettyOutput.print(
+                        f"正在克隆中心工具仓库: {central_repo}", OutputType.INFO
+                    )
+                    subprocess.run(
+                        ["git", "clone", central_repo, central_repo_path], check=True
+                    )
+                except Exception as e:
+                    PrettyOutput.print(
+                        f"克隆中心工具仓库失败: {str(e)}", OutputType.ERROR
+                    )
+
         # --- 全局每日更新检查 ---
         daily_check_git_updates(tool_dirs, "tools")
 
@@ -662,6 +715,10 @@ class ToolRegistry(OutputHandlerProtocol):
             parameters: 工具参数定义
             func: 工具执行函数
         """
+        if name in self.tools:
+            PrettyOutput.print(
+                f"警告: 工具 '{name}' 已存在，将被覆盖", OutputType.WARNING
+            )
         self.tools[name] = Tool(name, description, parameters, func)
 
     def get_tool(self, name: str) -> Optional[Tool]:
@@ -735,7 +792,9 @@ class ToolRegistry(OutputHandlerProtocol):
         """
         if len(output.splitlines()) > 60:
             lines = output.splitlines()
-            return "\n".join(lines[:30] + ["\n...内容太长，已截取前后30行...\n"] + lines[-30:])
+            return "\n".join(
+                lines[:30] + ["\n...内容太长，已截取前后30行...\n"] + lines[-30:]
+            )
         return output
 
     def handle_tool_calls(self, tool_call: Dict[str, Any], agent: Any) -> str:

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

@@ -319,6 +319,16 @@ def get_central_methodology_repo() -> str:
     return GLOBAL_CONFIG_DATA.get("JARVIS_CENTRAL_METHODOLOGY_REPO", "")
 
 
+def get_central_tool_repo() -> str:
+    """
+    获取中心工具Git仓库地址。
+
+    返回:
+        str: 中心工具Git仓库地址，如果未配置则返回空字符串
+    """
+    return GLOBAL_CONFIG_DATA.get("JARVIS_CENTRAL_TOOL_REPO", "")
+
+
 def is_print_prompt() -> bool:
     """
     获取是否打印提示。
@@ -477,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