jarvis-ai-assistant 0.1.176__py3-none-any.whl → 0.1.178__py3-none-any.whl

jarvis/jarvis_smart_shell/main.py

@@ -5,6 +5,8 @@ import os
 import sys
 from typing import Optional
 
+from sympy import false
+
 from jarvis.jarvis_platform.registry import PlatformRegistry
 from jarvis.jarvis_utils.config import get_shell_name
 from jarvis.jarvis_utils.input import get_multiline_input
@@ -113,8 +115,8 @@ def process_request(request: str) -> Optional[str]:
         return None
 
 def main() -> int:
-    # 创建参数解析器
-    init_env()
+    # 创建参数解析器s
+    init_env("")
     parser = argparse.ArgumentParser(
         description="将自然语言要求转换为shell命令",
         formatter_class=argparse.RawDescriptionHelpFormatter,

jarvis/jarvis_tools/ask_codebase.py

@@ -96,7 +96,7 @@ class AskCodebaseTool:
                     name=f"CodebaseAnalyzer",
                     description=f"分析代码库中的功能实现和定位",
                     summary_prompt=summary_prompt,
-                    platform=PlatformRegistry().get_normal_platform(),
+                    platform=PlatformRegistry().get_thinking_platform(),
                     output_handler=[tool_registry],
                     execute_tool_confirm=False,
                     auto_complete=self.auto_complete
@@ -160,6 +160,7 @@ class AskCodebaseTool:
 5. 根据文件内容提供具体、准确的回答
 6. 确保分析的完整性，收集充分的信息后再得出结论，不要在只掌握部分信息就得出结论
 7. 优先查阅README文件、文档目录和项目文档
+8. 给出的任意结论都要有实际的代码支撑，不能假设和杜撰
 
 ## 分析步骤
 1. **确定项目的编程语言**:
@@ -259,7 +260,7 @@ def main():
     import sys
     from jarvis.jarvis_utils.input import get_multiline_input
 
-    init_env()
+    init_env("欢迎使用 Jarvis-AskCodebase，您的智能代码库查询工具已准备就绪！")
 
     # 创建命令行参数解析器
     parser = argparse.ArgumentParser(description="智能代码库查询工具")

jarvis/jarvis_tools/cli/main.py

@@ -29,7 +29,7 @@ def main() -> int:
     import argparse
     import json
 
-    init_env()
+    init_env("欢迎使用 Jarvis-Tools，您的工具系统已准备就绪！")
 
     parser = argparse.ArgumentParser(description="Jarvis 工具系统命令行界面")
     subparsers = parser.add_subparsers(dest="command", help="命令")
@@ -47,6 +47,10 @@ def main() -> int:
         "--args-file", type=str, help="从文件加载工具参数 (JSON格式)"
     )
 
+    # 统计子命令
+    stat_parser = subparsers.add_parser("stat", help="显示工具调用统计信息")
+    stat_parser.add_argument("--json", action="store_true", help="以JSON格式输出")
+
     args = parser.parse_args()
 
     # 初始化工具注册表
@@ -72,6 +76,29 @@ def main() -> int:
                     print(f"   参数:")
                     print(tool["parameters"])  # 显示详细参数信息
 
+    elif args.command == "stat":
+        from tabulate import tabulate
+        stats = registry._get_tool_stats()
+        tools = registry.get_all_tools()
+        
+        # 构建统计表格数据
+        table_data = []
+        for tool in tools:
+            name = tool["name"]
+            count = stats.get(name, 0)
+            table_data.append([name, count])
+        
+        # 按调用次数降序排序
+        table_data.sort(key=lambda x: x[1], reverse=True)
+        
+        if args.json:
+            print(json.dumps(dict(table_data), indent=2))
+        else:
+            PrettyOutput.section("工具调用统计", OutputType.SYSTEM)
+            print(tabulate(table_data, headers=["工具名称", "调用次数"], tablefmt="grid"))
+            
+        return 0
+
     elif args.command == "call":
         tool_name = args.tool_name
         tool_obj = registry.get_tool(tool_name)

jarvis/jarvis_tools/edit_file.py

@@ -1,24 +1,29 @@
 # -*- coding: utf-8 -*-
 """
-文件搜索替换工具类
+文件编辑工具类
 
 功能概述:
-1. 提供精确的文件内容搜索和替换功能
+1. 提供精确的文件内容搜索和替换功能，支持多组修改
 2. 支持单个文件的编辑操作，包括创建新文件
 3. 实现原子操作：所有修改要么全部成功，要么全部回滚
 4. 严格匹配控制：每个搜索文本必须且只能匹配一次
+5. 支持两种编辑模式：快速编辑(fast_edit)和AI辅助编辑(slow_edit)
 
 核心特性:
 - 支持不存在的文件和空文件处理
 - 自动创建所需目录结构
 - 完善的错误处理和回滚机制
 - 严格的格式保持要求
+- 支持大文件处理(自动上传到模型平台)
+- 提供3次重试机制确保操作可靠性
 """
+from typing import List
 import re
 from typing import Any, Dict, Tuple
 
 import yaml
 from yaspin import yaspin
+from yaspin.core import Yaspin
 
 from jarvis.jarvis_platform.registry import PlatformRegistry
 from jarvis.jarvis_tools.file_operation import FileOperationTool
@@ -30,32 +35,26 @@ from jarvis.jarvis_utils.utils import is_context_overflow
 
 class FileSearchReplaceTool:
     name = "edit_file"
-    description = """代码编辑工具，用于编辑单个文件
+    description = """代码编辑工具，用于精确修改单个文件
 
-# 代码编辑规范
+# 文件编辑工具使用指南
 
-## 重要提示
-此工具可以查看和修改单个文件的代码，只需提供要修改的代码片段即可。应尽量精简内容，只包含必要的上下文和修改部分。特别注意：不要提供完整文件内容，只提供需要修改的部分及其上下文！
 
 ## 基本使用
 1. 指定需要修改的文件路径
-2. 提供一组或多组"reason"和"patch"对
-3. 每个patch必须包含修改后的代码和1-2行上下文用于精确定位
+2. 提供一组或多组修改，每个修改包含:
+   - reason: 修改原因描述
+   - search: 需要查找的原始代码(必须包含足够上下文)
+   - replace: 替换后的新代码
+3. 工具会自动选择最适合的编辑模式
 
 ## 核心原则
-1. **精准修改**：只提供需要修改的代码部分及其上下文，不需要展示整个文件内容
-2. **最小补丁原则**：始终生成最小范围的补丁，只包含必要的上下文和实际修改
-3. **上下文定位**：确保提供的上下文能唯一标识修改位置
-
-## 最佳实践
-1. 每个修改应专注于单一职责，避免包含过多无关代码
-2. 不要出现未实现的代码，如：TODO
-3. 示例格式：
-  ```
-  # 原有上下文行
-  if condition:  # 修改这行
-      return new_value
-  ```
+1. **精准修改**: 只修改必要的代码部分，保持其他部分不变
+2. **最小补丁原则**: 生成最小范围的补丁，包含必要的上下文
+3. **唯一匹配**: 确保搜索文本在文件中唯一匹配
+4. **格式保持**: 严格保持原始代码的格式风格
+
+
 """
     parameters = {
         "type": "object",
@@ -74,12 +73,15 @@ class FileSearchReplaceTool:
                             "type": "string",
                             "description": "修改的原因"
                         },
-                        "patch": {
+                        "search": {
+                            "type": "string",
+                            "description": "需要查找的原始代码"
+                        },
+                        "replace": {
                             "type": "string",
-                            "description": "修改后的代码片段，必须包含1-2行上下文代码用于精确定位修改位置，不需要传入完整文件内容"
+                            "description": "替换后的新代码"
                         }
                     },
-                    "required": ["reason", "patch"]
                 }
             }
         },
@@ -91,24 +93,26 @@ class FileSearchReplaceTool:
         pass
 
     def execute(self, args: Dict) -> Dict[str, Any]:
-        """执行文件编辑操作，包含错误处理和回滚机制。
+        """执行文件编辑操作，支持快速编辑和AI辅助编辑两种模式。
 
         主要功能:
-        1. 处理文件创建或修改
+        1. 处理文件创建或修改，支持不存在的文件
         2. 原子操作：所有修改要么全部成功，要么全部回滚
-        3. 保存修改前后的文件状态以便回滚
-        4. 提供详细的执行状态输出
+        3. 自动选择编辑模式(fast_edit或slow_edit)
+        4. 保存修改前后的文件状态以便回滚
+        5. 提供详细的执行状态输出
 
         参数:
             args: 包含以下键的字典:
-                - file: 要修改的文件路径
-                - changes: 修改列表，每个修改包含:
+                - file: 要修改的文件路径(必填)
+                - changes: 修改列表，每个修改包含(必填):
                     - reason: 修改原因描述
-                    - patch: 修改后的代码片段
+                    - search: 需要查找的原始代码(必须包含足够上下文)
+                    - replace: 替换后的新代码
 
         返回:
             Dict[str, Any] 包含:
-                - success: 操作是否成功
+                - success: 操作是否成功(True/False)
                 - stdout: 成功时的输出消息
                 - stderr: 失败时的错误消息
 
@@ -116,6 +120,14 @@ class FileSearchReplaceTool:
         1. 捕获并记录文件操作异常
         2. 失败的修改尝试回滚到原始状态
         3. 新创建的文件在失败时会被删除
+        4. 提供3次重试机制确保操作可靠性
+        5. 支持大文件处理(自动上传到模型平台)
+
+        实现细节:
+        1. 优先尝试fast_edit模式
+        2. 如果fast_edit失败，则尝试slow_edit模式
+        3. 严格检查搜索文本的唯一匹配性
+        4. 保持原始代码的格式风格
         """
         import os
         from jarvis.jarvis_utils.output import PrettyOutput, OutputType
@@ -141,8 +153,10 @@ class FileSearchReplaceTool:
                     with open(file_path, 'r', encoding='utf-8') as f:
                         content = f.read()
                         original_content = content
-                
-                success, temp_content = patch_apply(file_path, yaml.safe_dump(changes))
+                with yaspin(text=f"正在处理文件 {file_path}...", color="cyan") as spinner:
+                    success, temp_content = fast_edit(file_path, changes, spinner)
+                    if not success:
+                        success, temp_content = slow_edit(file_path, yaml.safe_dump(changes), spinner)
 
                 # 只有当所有替换操作都成功时，才写回文件
                 if success and (temp_content != original_content or not file_exists):
@@ -207,29 +221,42 @@ class FileSearchReplaceTool:
                 "stdout": "",
                 "stderr": error_msg + "\n" + "\n".join(stderr_messages)
             }
+        
 
 
-def patch_apply(filepath: str, patch_content: str) -> Tuple[bool, str]:
+def slow_edit(filepath: str, patch_content: str, spinner: Yaspin) -> Tuple[bool, str]:
     """执行精确的文件编辑操作，使用AI模型生成差异补丁并应用。
-
-    功能概述:
+    
+    核心功能:
     1. 使用AI模型分析补丁内容并生成精确的代码差异
     2. 应用生成的差异补丁到目标文件
-    3. 提供重试机制确保操作可靠性
-
+    3. 提供3次重试机制确保操作可靠性
+    4. 支持大文件处理(自动上传到模型平台)
+    5. 严格的格式一致性检查
+    
     参数:
-        filepath: 要编辑的文件路径
-        patch_content: YAML格式的补丁内容，包含修改原因和代码片段
-
+        filepath: 要编辑的文件路径(绝对或相对路径)
+        patch_content: YAML格式的补丁内容，包含:
+            - reason: 修改原因描述
+            - search: 需要查找的原始代码(必须包含足够上下文)
+            - replace: 替换后的新代码
+        spinner: Yaspin实例，用于显示处理状态
+    
     返回值:
         Tuple[bool, str]: 
-            - 第一个元素表示操作是否成功
-            - 第二个元素是修改后的文件内容(成功时)或错误信息(失败时)
-
+            - 第一个元素表示操作是否成功(True/False)
+            - 第二个元素是修改后的文件内容(成功时)或空字符串(失败时)
+    
     异常处理:
-    1. 捕获并处理文件操作异常
-    2. 失败时自动回滚文件修改
-    3. 提供详细的执行状态输出
+    1. 文件不存在或权限不足时会捕获异常并返回失败
+    2. 模型生成补丁失败时会自动重试最多3次
+    3. 补丁应用失败时会自动回滚文件修改
+    
+    实现细节:
+    1. 检查文件是否在工作目录下(影响版本控制)
+    2. 根据文件大小决定是否上传到模型平台
+    3. 使用精确的DIFF格式解析模型生成的补丁
+    4. 确保补丁应用前进行唯一性匹配检查
     """
     import os
     work_dir = os.path.abspath(os.curdir)
@@ -237,20 +264,19 @@ def patch_apply(filepath: str, patch_content: str) -> Tuple[bool, str]:
     if not filepath.startswith(work_dir):
         PrettyOutput.print(f"文件 {filepath} 不在工作目录 {work_dir} 下，不会进行版本控制管理", OutputType.WARNING)
     model = PlatformRegistry().get_normal_platform()
-    with yaspin(text=f"正在处理文件 {filepath}...", color="cyan") as spinner:
-        try:
-            file_content = FileOperationTool().execute({"operation":"read", "files":[{"path":filepath}]})["stdout"]
-            need_upload_file = is_context_overflow(file_content)
-            upload_success = False
-            # 读取原始文件内容
-            with spinner.hidden():  
-                if need_upload_file and model.upload_files([filepath]):
-                    upload_success = True
+    try:
+        file_content = FileOperationTool().execute({"operation":"read", "files":[{"path":filepath}]})["stdout"]
+        need_upload_file = is_context_overflow(file_content)
+        upload_success = False
+        # 读取原始文件内容
+        with spinner.hidden():  
+            if need_upload_file and model.upload_files([filepath]):
+                upload_success = True
 
 
-            model.set_suppress_output(True)
+        model.set_suppress_output(True)
 
-            main_prompt = f"""
+        main_prompt = f"""
 # 代码补丁生成专家指南
 
 ## 任务描述
@@ -292,66 +318,108 @@ def patch_apply(filepath: str, patch_content: str) -> Tuple[bool, str]:
 {"<" * 5} REPLACE
 {ct("DIFF")}
 """
-            
-            for _ in range(3):
-                file_prompt = ""
-                if not need_upload_file:
-                    file_prompt = f"""
-    # 原始代码
-    {file_content}
-    """
-                    
-                    response = model.chat_until_success(main_prompt + file_prompt)
+        
+        for _ in range(3):
+            file_prompt = ""
+            if not need_upload_file:
+                file_prompt = f"""
+# 原始代码
+{file_content}
+"""
+                
+                response = model.chat_until_success(main_prompt + file_prompt)
+            else:
+                if upload_success:
+                    response = model.chat_until_success(main_prompt)
                 else:
-                    if upload_success:
-                        response = model.chat_until_success(main_prompt)
-                    else:
-                        return False, ""
-
-                # 解析差异化补丁
-                diff_blocks = re.finditer(ot("DIFF")+r'\s*>{4,} SEARCH\n?(.*?)\n?={4,}\n?(.*?)\s*<{4,} REPLACE\n?'+ct("DIFF"),
-                                        response, re.DOTALL)
-
-                # 读取原始文件内容
-                with open(filepath, 'r', encoding='utf-8', errors="ignore") as f:
-                    file_content = f.read()
-
-                # 应用所有差异化补丁
-                modified_content = file_content
-                patch_count = 0
-                success = True
-                for match in diff_blocks:
-                    search_text = match.group(1).strip()
-                    replace_text = match.group(2).strip()
-                    patch_count += 1
-                    # 检查搜索文本是否存在于文件中
-                    if search_text in modified_content:
-                        # 如果有多处，报错
-                        if modified_content.count(search_text) > 1:
-                            spinner.write(f"❌ 补丁 #{patch_count} 应用失败：找到多个匹配的代码段")
-                            success = False
-                            break
-                        # 应用替换
-                        modified_content = modified_content.replace(
-                            search_text, replace_text)
-                        spinner.write(f"✅ 补丁 #{patch_count} 应用成功")
-                    else:
-                        spinner.write(f"❌ 补丁 #{patch_count} 应用失败：无法找到匹配的代码段")
-                        success = False
-                        break
-                if not success:
-                    revert_file(filepath)
-                    continue
+                    return False, ""
 
+            # 解析差异化补丁
+            diff_blocks = re.finditer(ot("DIFF")+r'\s*>{4,} SEARCH\n?(.*?)\n?={4,}\n?(.*?)\s*<{4,} REPLACE\n?'+ct("DIFF"),
+                                    response, re.DOTALL)
 
-                spinner.text = f"文件 {filepath} 修改完成，应用了 {patch_count} 个补丁"
-                spinner.ok("✅")
-                return True, modified_content
-            spinner.text = f"文件 {filepath} 修改失败"
-            spinner.fail("❌")
-            return False, ""
+            patches = []
+            for match in diff_blocks:
+                patches.append({
+                    "search": match.group(1).strip(),
+                    "replace": match.group(2).strip()
+                })
 
-        except Exception as e:
-            spinner.text = f"文件修改失败: {str(e)}"
-            spinner.fail("❌")
-            return False, ""
+            success, modified_content = fast_edit(filepath, patches, spinner)
+            if success:
+                return True, modified_content
+        spinner.text = f"文件 {filepath} 修改失败"
+        spinner.fail("❌")
+        return False, ""
+
+    except Exception as e:
+        spinner.text = f"文件修改失败: {str(e)}"
+        spinner.fail("❌")
+        return False, ""
+
+
+def fast_edit(filepath: str, patches: List[Dict[str,str]], spinner: Yaspin) -> Tuple[bool, str]:
+    """快速应用预先生成的补丁到目标文件。
+    
+    核心功能:
+    1. 直接应用已生成的代码补丁
+    2. 执行严格的唯一匹配检查
+    3. 提供详细的补丁应用状态反馈
+    4. 失败时自动回滚文件修改
+    
+    参数:
+        filepath: 要编辑的文件路径(绝对或相对路径)
+        patches: 补丁列表，每个补丁包含:
+            - search: 需要查找的原始代码
+            - replace: 替换后的新代码
+        spinner: Yaspin实例，用于显示处理状态
+    
+    返回值:
+        Tuple[bool, str]: 
+            - 第一个元素表示操作是否成功(True/False)
+            - 第二个元素是修改后的文件内容(成功时)或空字符串(失败时)
+    
+    异常处理:
+    1. 文件不存在或权限不足时会捕获异常并返回失败
+    2. 补丁不匹配或有多处匹配时会返回失败
+    3. 失败时会自动回滚文件修改
+    
+    实现细节:
+    1. 读取文件内容到内存
+    2. 依次应用每个补丁，检查唯一匹配性
+    3. 记录每个补丁的应用状态
+    4. 所有补丁成功应用后才写入文件
+    """
+    # 读取原始文件内容
+    with open(filepath, 'r', encoding='utf-8', errors="ignore") as f:
+        file_content = f.read()
+
+    # 应用所有差异化补丁
+    modified_content = file_content
+    patch_count = 0
+    success = True
+    for patch in patches:
+        search_text = patch["search"]
+        replace_text = patch["replace"]
+        patch_count += 1
+        # 检查搜索文本是否存在于文件中
+        if search_text in modified_content:
+            # 如果有多处，报错
+            if modified_content.count(search_text) > 1:
+                success = False
+                break
+            # 应用替换
+            modified_content = modified_content.replace(
+                search_text, replace_text)
+            spinner.write(f"✅ 补丁 #{patch_count} 应用成功")
+        else:
+            success = False
+            break
+    if not success:
+        revert_file(filepath)
+        return False, ""
+
+
+    spinner.text = f"文件 {filepath} 修改完成，应用了 {patch_count} 个补丁"
+    spinner.ok("✅")
+    return True, modified_content

jarvis/jarvis_tools/read_code.py

@@ -98,8 +98,6 @@ class ReadCodeTool:
                 spinner.text = f"文件读取完成: {abs_path}"
                 spinner.ok("✅")
 
-                PrettyOutput.print(output, OutputType.SUCCESS)
-
                 return {
                     "success": True,
                     "stdout": output,

jarvis/jarvis_tools/registry.py

@@ -178,6 +178,32 @@ class ToolRegistry(OutputHandlerProtocol):
         self._load_external_tools()
         self._load_mcp_tools()
 
+    def _get_tool_stats(self) -> Dict[str, int]:
+        """从数据目录获取工具调用统计"""
+        stats_file = Path(get_data_dir()) / "tool_stat.yaml"
+        if stats_file.exists():
+            try:
+                with open(stats_file, "r", encoding="utf-8") as f:
+                    return yaml.safe_load(f) or {}
+            except Exception as e:
+                PrettyOutput.print(
+                    f"加载工具调用统计失败: {str(e)}", OutputType.WARNING
+                )
+        return {}
+
+    def _update_tool_stats(self, name: str) -> None:
+        """更新工具调用统计"""
+        stats = self._get_tool_stats()
+        stats[name] = stats.get(name, 0) + 1
+        stats_file = Path(get_data_dir()) / "tool_stat.yaml"
+        try:
+            with open(stats_file, "w", encoding="utf-8") as f:
+                yaml.safe_dump(stats, f)
+        except Exception as e:
+            PrettyOutput.print(
+                f"保存工具调用统计失败: {str(e)}", OutputType.WARNING
+            )
+
     def use_tools(self, name: List[str]) -> None:
         """使用指定工具
 
@@ -190,7 +216,7 @@ class ToolRegistry(OutputHandlerProtocol):
                 f"工具 {missing_tools} 不存在，可用的工具有: {', '.join(self.tools.keys())}",
                 OutputType.WARNING,
             )
-        self.tools = {tool_name: self.tools[tool_name] for tool_name in name}
+        self.tools = {tool_name: self.tools[tool_name] for tool_name in name if tool_name in self.tools}
 
     def dont_use_tools(self, names: List[str]) -> None:
         """从注册表中移除指定工具
@@ -559,6 +585,10 @@ class ToolRegistry(OutputHandlerProtocol):
                 "stderr": f"工具 {name} 不存在，可用的工具有: {', '.join(self.tools.keys())}",
                 "stdout": "",
             }
+        
+        # 更新工具调用统计
+        self._update_tool_stats(name)
+        
         return tool.execute(arguments)
 
     def _format_tool_output(self, stdout: str, stderr: str) -> str:

jarvis/jarvis_utils/config.py

@@ -38,7 +38,7 @@ def get_max_token_count() -> int:
     返回:
         int: 模型能处理的最大token数量。
     """
-    return int(os.getenv('JARVIS_MAX_TOKEN_COUNT', '102400000'))
+    return int(os.getenv('JARVIS_MAX_TOKEN_COUNT', '960000'))
 
 def get_max_input_token_count() -> int:
     """
@@ -158,9 +158,9 @@ def get_max_big_content_size() -> int:
     获取最大大内容大小。
 
     返回：
-        int: 最大大内容大小，默认为1MB
+        int: 最大大内容大小
     """
-    return int(os.getenv('JARVIS_MAX_BIG_CONTENT_SIZE', '96000'))
+    return int(os.getenv('JARVIS_MAX_BIG_CONTENT_SIZE', '1024000'))
 
 def get_pretty_output() -> bool:
     """
@@ -169,4 +169,13 @@ def get_pretty_output() -> bool:
     返回：
         bool: 如果启用PrettyOutput则返回True，默认为True
     """
-    return os.getenv('JARVIS_PRETTY_OUTPUT', 'false') == 'true'
+    return os.getenv('JARVIS_PRETTY_OUTPUT', 'false') == 'true'
+
+def is_use_methodology() -> bool:
+    """
+    获取是否启用方法论。
+
+    返回：
+        bool: 如果启用方法论则返回True，默认为True
+    """
+    return os.getenv('JARVIS_USE_METHODOLOGY', 'true') == 'true'