jarvis-ai-assistant 0.1.200__py3-none-any.whl → 0.1.201__py3-none-any.whl

jarvis/__init__.py

@@ -1,4 +1,4 @@
 # -*- coding: utf-8 -*-
 """Jarvis AI Assistant"""
 
-__version__ = "0.1.200"
+__version__ = "0.1.201"

jarvis/jarvis_agent/edit_file_handler.py

@@ -0,0 +1,415 @@
+import os
+import re
+from abc import ABC, abstractmethod
+from typing import Any, Dict, List, Tuple
+
+from yaspin import yaspin
+from yaspin.core import Yaspin
+
+from jarvis.jarvis_agent.output_handler import OutputHandler
+from jarvis.jarvis_platform.registry import PlatformRegistry
+from jarvis.jarvis_tools.file_operation import FileOperationTool
+from jarvis.jarvis_utils.git_utils import revert_file
+from jarvis.jarvis_utils.output import OutputType, PrettyOutput
+from jarvis.jarvis_utils.tag import ct, ot
+from jarvis.jarvis_utils.utils import is_context_overflow
+
+
+class EditFileHandler(OutputHandler):
+    def __init__(self):
+        self.patch_pattern = re.compile(
+            ot("PATCH file=([^>]+)") + r"\s*"
+            r"(?:"
+            + ot("DIFF")
+            + r"\s*"
+            + ot("SEARCH")
+            + r"\s*(.*?)\s*"
+            + ct("SEARCH")
+            + r"\s*"
+            + ot("REPLACE")
+            + r"\s*(.*?)\s*"
+            + ct("REPLACE")
+            + r"\s*"
+            + ct("DIFF")
+            + r"\s*)+"
+            + ct("PATCH"),
+            re.DOTALL,
+        )
+        self.diff_pattern = re.compile(
+            ot("DIFF")
+            + r"\s*"
+            + ot("SEARCH")
+            + r"\s*(.*?)\s*"
+            + ct("SEARCH")
+            + r"\s*"
+            + ot("REPLACE")
+            + r"\s*(.*?)\s*"
+            + ct("REPLACE")
+            + r"\s*"
+            + ct("DIFF"),
+            re.DOTALL,
+        )
+
+    def handle(self, response: str, agent: Any) -> Tuple[bool, str]:
+        """处理文件编辑响应
+
+        Args:
+            response: 包含文件编辑指令的响应字符串
+            agent: 执行处理的agent实例
+
+        Returns:
+            Tuple[bool, str]: 返回处理结果元组，第一个元素表示是否处理成功，第二个元素为处理结果汇总字符串
+        """
+        patches = self._parse_patches(response)
+        if not patches:
+            return False, "未找到有效的文件编辑指令"
+
+        results = []
+        overall_success = True
+
+        for file_path, diffs in patches.items():
+            file_path = os.path.abspath(file_path)
+            file_patches = [
+                {"search": diff["search"], "replace": diff["replace"]} for diff in diffs
+            ]
+
+            with yaspin(text=f"正在处理文件 {file_path}...", color="cyan") as spinner:
+                # 首先尝试fast_edit模式
+                success, result = self._fast_edit(file_path, file_patches, spinner)
+                if not success:
+                    # 如果fast_edit失败，尝试slow_edit模式
+                    success, result = EditFileHandler._slow_edit(
+                        file_path, file_patches, spinner, agent
+                    )
+
+                if success:
+                    results.append(f"✅ 文件 {file_path} 修改成功")
+                else:
+                    results.append(f"❌ 文件 {file_path} 修改失败: {result}")
+
+        summary = "\n".join(results)
+        return False, summary
+
+    def can_handle(self, response: str) -> bool:
+        """判断是否能处理给定的响应
+
+        Args:
+            response: 需要判断的响应字符串
+
+        Returns:
+            bool: 返回是否能处理该响应
+        """
+        return bool(self.patch_pattern.search(response))
+
+    def prompt(self) -> str:
+        """获取处理器的提示信息
+
+        Returns:
+            str: 返回处理器的提示字符串
+        """
+        return f"""文件编辑指令格式：
+{ot("PATCH file=文件路径")}
+{ot("DIFF")}
+{ot("SEARCH")}
+原始代码
+{ct("SEARCH")}
+{ot("REPLACE")}
+新代码
+{ct("REPLACE")}
+{ct("DIFF")}
+{ct("PATCH")}
+
+每个PATCH块可以包含多个DIFF块，每个DIFF块包含一组搜索和替换内容。
+搜索文本必须能在文件中唯一匹配，否则编辑将失败。"""
+
+    def name(self) -> str:
+        """获取处理器的名称
+
+        Returns:
+            str: 返回处理器的名称字符串
+        """
+        return "PATCH"
+
+    def _parse_patches(self, response: str) -> Dict[str, List[Dict[str, str]]]:
+        """解析响应中的补丁信息
+
+        该方法使用正则表达式从响应文本中提取文件编辑指令(PATCH块)，
+        每个PATCH块可以包含多个DIFF块，每个DIFF块包含一组搜索和替换内容。
+        解析后会返回一个字典，键是文件路径，值是该文件对应的补丁列表。
+
+        Args:
+            response: 包含补丁信息的响应字符串，格式应符合PATCH指令规范
+
+        Returns:
+            Dict[str, List[Dict[str, str]]]:
+                返回解析后的补丁信息字典，结构为:
+                {
+                    "文件路径1": [
+                        {"search": "搜索文本1", "replace": "替换文本1"},
+                        {"search": "搜索文本2", "replace": "替换文本2"}
+                    ],
+                    "文件路径2": [...]
+                }
+        """
+        patches = {}
+        for match in self.patch_pattern.finditer(response):
+            file_path = match.group(1)
+            diffs = []
+            for diff_match in self.diff_pattern.finditer(match.group(0)):
+                diffs.append(
+                    {
+                        "search": diff_match.group(1).strip(),
+                        "replace": diff_match.group(2).strip(),
+                    }
+                )
+            if diffs:
+                patches[file_path] = diffs
+        return patches
+
+    @staticmethod
+    def _fast_edit(
+        file_path: str, patches: List[Dict[str, str]], spinner: Yaspin
+    ) -> Tuple[bool, str]:
+        """快速应用补丁到文件
+
+        该方法直接尝试将补丁应用到目标文件，适用于简单、明确的修改场景。
+        特点：
+        1. 直接进行字符串替换，效率高
+        2. 会自动处理缩进问题，尝试匹配不同缩进级别的代码
+        3. 确保搜索文本在文件中唯一匹配
+        4. 如果失败会自动回滚修改
+
+        Args:
+            file_path: 要修改的文件路径，支持绝对路径和相对路径
+            patches: 补丁列表，每个补丁包含search(搜索文本)和replace(替换文本)
+            spinner: 进度显示对象，用于显示处理状态和结果
+
+        Returns:
+            Tuple[bool, str]:
+                返回处理结果元组，第一个元素表示是否成功(True/False)，
+                第二个元素为结果信息，成功时为修改后的文件内容，失败时为错误信息
+        """
+        try:
+            # 确保目录存在
+            os.makedirs(os.path.dirname(file_path), exist_ok=True)
+
+            # 读取原始文件内容
+            file_content = ""
+            if os.path.exists(file_path):
+                with open(file_path, "r", encoding="utf-8") as f:
+                    file_content = f.read()
+
+            # 应用所有补丁
+            modified_content = file_content
+            patch_count = 0
+            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:
+                        return False, f"搜索文本在文件中存在多处匹配：\n{search_text}"
+                    modified_content = modified_content.replace(
+                        search_text, replace_text
+                    )
+                    spinner.write(f"✅ 补丁 #{patch_count} 应用成功")
+                else:
+                    # 尝试增加缩进重试
+                    found = False
+                    for space_count in range(1, 17):
+                        indented_search = "\n".join(
+                            " " * space_count + line if line.strip() else line
+                            for line in search_text.split("\n")
+                        )
+                        indented_replace = "\n".join(
+                            " " * space_count + line if line.strip() else line
+                            for line in replace_text.split("\n")
+                        )
+                        if indented_search in modified_content:
+                            if modified_content.count(indented_search) > 1:
+                                return (
+                                    False,
+                                    f"搜索文本在文件中存在多处匹配：\n{indented_search}",
+                                )
+                            modified_content = modified_content.replace(
+                                indented_search, indented_replace
+                            )
+                            spinner.write(
+                                f"✅ 补丁 #{patch_count} 应用成功 (自动增加 {space_count} 个空格缩进)"
+                            )
+                            found = True
+                            break
+
+                    if not found:
+                        return False, f"搜索文本在文件中不存在：\n{search_text}"
+
+            # 写入修改后的内容
+            with open(file_path, "w", encoding="utf-8") as f:
+                f.write(modified_content)
+
+            spinner.text = f"文件 {file_path} 修改完成，应用了 {patch_count} 个补丁"
+            spinner.ok("✅")
+            return True, modified_content
+
+        except Exception as e:
+            spinner.text = f"文件修改失败: {str(e)}"
+            spinner.fail("❌")
+            revert_file(file_path)
+            return False, f"文件修改失败: {str(e)}"
+
+    @staticmethod
+    def _slow_edit(
+        file_path: str, patches: List[Dict[str, str]], spinner: Yaspin, agent: Any
+    ) -> Tuple[bool, str]:
+        """使用AI模型生成补丁并应用到文件
+
+        当_fast_edit方法失败时调用此方法，使用AI模型生成更精确的补丁。
+        特点：
+        1. 适用于复杂修改场景或需要上下文理解的修改
+        2. 会自动处理大文件上传问题
+        3. 会尝试最多3次生成有效的补丁
+        4. 生成的补丁会再次通过_fast_edit方法应用
+        5. 如果失败会自动回滚修改
+
+        Args:
+            file_path: 要修改的文件路径，支持绝对路径和相对路径
+            patches: 补丁列表，每个补丁包含search(搜索文本)和replace(替换文本)
+            spinner: 进度显示对象，用于显示处理状态和结果
+            agent: 执行处理的agent实例，用于访问AI模型平台
+
+        Returns:
+            Tuple[bool, str]:
+                返回处理结果元组，第一个元素表示是否成功(True/False)，
+                第二个元素为结果信息，成功时为修改后的文件内容，失败时为错误信息
+        """
+        try:
+            model = PlatformRegistry().get_normal_platform()
+
+            # 读取原始文件内容
+            file_content = ""
+            if os.path.exists(file_path):
+                with open(file_path, "r", encoding="utf-8") as f:
+                    file_content = f.read()
+
+            is_large_context = is_context_overflow(file_content)
+            upload_success = False
+
+            # 如果是大文件，尝试上传到模型平台
+            with spinner.hidden():
+                if (
+                    is_large_context
+                    and model.support_upload_files()
+                    and model.upload_files([file_path])
+                ):
+                    upload_success = True
+
+            model.set_suppress_output(True)
+
+            # 构建补丁内容
+            patch_content = []
+            for patch in patches:
+                patch_content.append(
+                    {
+                        "reason": "根据用户指令修改代码",
+                        "search": patch["search"],
+                        "replace": patch["replace"],
+                    }
+                )
+
+            # 构建提示词
+            main_prompt = f"""
+# 代码补丁生成专家指南
+
+## 任务描述
+你是一位精确的代码补丁生成专家，需要根据补丁描述生成精确的代码差异。
+
+### 补丁内容
+```
+{str(patch_content)}
+```
+
+## 补丁生成要求
+1. **精确性**：严格按照补丁的意图修改代码
+2. **格式一致性**：严格保持原始代码的格式风格，如果补丁中缩进或者空行与原代码不一致，则需要修正补丁中的缩进或者空行
+3. **最小化修改**：只修改必要的代码部分，保持其他部分不变
+4. **上下文完整性**：提供足够的上下文，确保补丁能准确应用
+
+## 输出格式规范
+- 使用{ot("DIFF")}块包围每个需要修改的代码段
+- 每个{ot("DIFF")}块必须包含SEARCH部分和REPLACE部分
+- SEARCH部分是需要查找的原始代码
+- REPLACE部分是替换后的新代码
+- 确保SEARCH部分能在原文件中**唯一匹配**
+- 如果修改较大，可以使用多个{ot("DIFF")}块
+
+## 输出模板
+{ot("DIFF")}
+{">" * 5} SEARCH
+[需要查找的原始代码，包含足够上下文，避免出现可匹配多处的情况]
+{'='*5}
+[替换后的新代码]
+{"<" * 5} REPLACE
+{ct("DIFF")}
+
+{ot("DIFF")}
+{">" * 5} SEARCH
+[另一处需要查找的原始代码，包含足够上下文，避免出现可匹配多处的情况]
+{'='*5}
+[另一处替换后的新代码]
+{"<" * 5} REPLACE
+{ct("DIFF")}
+"""
+
+            # 尝试最多3次生成补丁
+            for _ in range(3):
+                if is_large_context:
+                    if upload_success:
+                        response = model.chat_until_success(main_prompt)
+                    else:
+                        file_prompt = f"""
+# 原始代码
+{file_content}
+"""
+                        response = model.chat_until_success(main_prompt + file_prompt)
+                else:
+                    file_prompt = f"""
+# 原始代码
+{file_content}
+"""
+                    response = model.chat_until_success(main_prompt + file_prompt)
+
+                # 解析生成的补丁
+                diff_blocks = re.finditer(
+                    ot("DIFF")
+                    + r"\s*"
+                    + r">{4,} SEARCH\n?(.*?)\n?={4,}\n?(.*?)\s*<{4,} REPLACE\n?"
+                    + ct("DIFF"),
+                    response,
+                    re.DOTALL,
+                )
+
+                generated_patches = []
+                for match in diff_blocks:
+                    generated_patches.append(
+                        {
+                            "search": match.group(1).strip(),
+                            "replace": match.group(2).strip(),
+                        }
+                    )
+
+                if generated_patches:
+                    # 尝试应用生成的补丁
+                    success, result = EditFileHandler._fast_edit(
+                        file_path, generated_patches, spinner
+                    )
+                    if success:
+                        return True, result
+
+            return False, "AI模型无法生成有效的补丁"
+
+        except Exception as e:
+            spinner.text = f"文件修改失败: {str(e)}"
+            spinner.fail("❌")
+            revert_file(file_path)
+            return False, f"文件修改失败: {str(e)}"

jarvis/jarvis_code_agent/code_agent.py

@@ -14,6 +14,7 @@ from yaspin import yaspin  # type: ignore
 
 from jarvis.jarvis_agent import Agent
 from jarvis.jarvis_agent.builtin_input_handler import builtin_input_handler
+from jarvis.jarvis_agent.edit_file_handler import EditFileHandler
 from jarvis.jarvis_agent.shell_input_handler import shell_input_handler
 # 忽略yaspin的类型检查
 from jarvis.jarvis_code_agent.lint import get_lint_tools
@@ -54,7 +55,7 @@ class CodeAgent:
                 "read_code",
                 "methodology",
                 "chdir",
-                "edit_file",
+                # "edit_file",
                 "rewrite_file",
             ]
         )
@@ -94,7 +95,7 @@ class CodeAgent:
 - 仅在命令行工具不足时使用专用工具
 
 ## 文件编辑工具使用规范
-- 对于部分文件内容修改，使用edit_file工具
+- 对于部分文件内容修改，使用PATCH
 - 对于需要重写整个文件内容，使用rewrite_file工具
 - 对于简单的修改，可以使用execute_script工具执行shell命令完成
 </code_engineer_guide>
@@ -112,7 +113,7 @@ class CodeAgent:
             system_prompt=code_system_prompt,
             name="CodeAgent",
             auto_complete=False,
-            output_handler=[tool_registry],
+            output_handler=[tool_registry, EditFileHandler()],
             platform=platform_instance,
             input_handler=[shell_input_handler, builtin_input_handler],
             need_summary=need_summary,

jarvis/jarvis_platform/base.py

@@ -149,6 +149,9 @@ class BasePlatform(ABC):
         response = re.sub(
             ot("think") + r".*?" + ct("think"), "", response, flags=re.DOTALL
         )
+        response = re.sub(
+            ot("thinking") + r".*?" + ct("thinking"), "", response, flags=re.DOTALL
+        )
         return response
 
     def chat_until_success(self, message: str) -> str:

jarvis/jarvis_platform/yuanbao.py

@@ -477,7 +477,6 @@ class YuanbaoPlatform(BasePlatform):
         if self.first_chat and self.system_message:
             payload["prompt"] = f"{self.system_message}\n\n{message}"
             payload["displayPrompt"] = payload["prompt"]
-            self.first_chat = False
 
         try:
             # 发送消息请求，获取流式响应
@@ -532,6 +531,7 @@ class YuanbaoPlatform(BasePlatform):
                 # 检测结束标志
                 elif line_str == "data: [DONE]":
                     return None
+            self.first_chat = False
             return None
 
         except Exception as e:

jarvis/jarvis_tools/edit_file.py

@@ -17,30 +17,21 @@
 - 支持大文件处理(自动上传到模型平台)
 - 提供3次重试机制确保操作可靠性
 """
-import re
-from typing import Any, Dict, List, Tuple
+from typing import Any, Dict
 
-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
-from jarvis.jarvis_utils.git_utils import revert_file
-from jarvis.jarvis_utils.output import OutputType, PrettyOutput
-from jarvis.jarvis_utils.tag import ct, ot
-from jarvis.jarvis_utils.utils import is_context_overflow
+from jarvis.jarvis_agent.edit_file_handler import EditFileHandler
 
 
 class FileSearchReplaceTool:
     name = "edit_file"
-    description = """代码编辑工具，用于精确修改单个文件
+    description = """代码编辑工具，用于精确修改一个或多个文件
 
 # 文件编辑工具使用指南
 
-
 ## 基本使用
-1. 指定需要修改的文件路径
+1. 指定需要修改的文件路径（单个或多个）
 2. 提供一组或多组修改，每个修改包含:
    - reason: 修改原因描述
    - search: 需要查找的原始代码(必须包含足够上下文)
@@ -52,59 +43,68 @@ class FileSearchReplaceTool:
 2. **最小补丁原则**: 生成最小范围的补丁，包含必要的上下文
 3. **唯一匹配**: 确保搜索文本在文件中唯一匹配
 4. **格式保持**: 严格保持原始代码的格式风格
-
+5. **部分成功**: 支持多个文件编辑，允许部分文件编辑成功
 
 """
     parameters = {
         "type": "object",
         "properties": {
-            "file": {"type": "string", "description": "需要修改的文件路径"},
-            "changes": {
+            "files": {
                 "type": "array",
-                "description": "一组或多组修改，每个修改必须包含1-2行上下文用于精确定位",
+                "description": "需要修改的文件路径列表",
                 "items": {
                     "type": "object",
                     "properties": {
-                        "reason": {"type": "string", "description": "修改的原因"},
-                        "search": {
-                            "type": "string",
-                            "description": "需要查找的原始代码",
+                        "path": {"type": "string", "description": "文件路径"},
+                        "changes": {
+                            "type": "array",
+                            "description": "一组或多组修改，每个修改必须包含1-2行上下文用于精确定位",
+                            "items": {
+                                "type": "object",
+                                "properties": {
+                                    "reason": {"type": "string", "description": "修改的原因"},
+                                    "search": {
+                                        "type": "string",
+                                        "description": "需要查找的原始代码",
+                                    },
+                                    "replace": {"type": "string", "description": "替换后的新代码"},
+                                },
+                            },
                         },
-                        "replace": {"type": "string", "description": "替换后的新代码"},
                     },
+                    "required": ["path", "changes"],
                 },
             },
         },
-        "required": ["file", "changes"],
+        "required": ["files"],
     }
 
-    def __init__(self):
-        """初始化文件搜索替换工具"""
-        pass
 
     def execute(self, args: Dict) -> Dict[str, Any]:
         """执行文件编辑操作，支持快速编辑和AI辅助编辑两种模式。
 
         主要功能:
-        1. 处理文件创建或修改，支持不存在的文件
-        2. 原子操作：所有修改要么全部成功，要么全部回滚
+        1. 处理多个文件的创建或修改，支持不存在的文件
+        2. 每个文件独立处理，允许部分文件编辑成功
         3. 自动选择编辑模式(fast_edit或slow_edit)
         4. 保存修改前后的文件状态以便回滚
         5. 提供详细的执行状态输出
 
         参数:
             args: 包含以下键的字典:
-                - file: 要修改的文件路径(必填)
-                - changes: 修改列表，每个修改包含(必填):
-                    - reason: 修改原因描述
-                    - search: 需要查找的原始代码(必须包含足够上下文)
-                    - replace: 替换后的新代码
+                - files: 文件列表，每个文件包含(必填):
+                    - path: 要修改的文件路径
+                    - changes: 修改列表，每个修改包含:
+                        - reason: 修改原因描述
+                        - search: 需要查找的原始代码(必须包含足够上下文)
+                        - replace: 替换后的新代码
 
         返回:
             Dict[str, Any] 包含:
-                - success: 操作是否成功(True/False)
+                - success: 是否至少有一个文件编辑成功(True/False)
                 - stdout: 成功时的输出消息
                 - stderr: 失败时的错误消息
+                - results: 每个文件的处理结果列表
 
         异常处理:
         1. 捕获并记录文件操作异常
@@ -125,365 +125,147 @@ class FileSearchReplaceTool:
 
         stdout_messages = []
         stderr_messages = []
-        success = True
-
-        file_path = os.path.abspath(args["file"])
-        changes = args["changes"]
-        agent = args.get("agent", None)
+        overall_success = False
+        file_results = []
 
-        # 创建已处理文件变量，用于失败时回滚
-        original_content = None
-        processed = False
+        for file_info in args["files"]:
+            file_path = os.path.abspath(file_info["path"])
+            changes = file_info["changes"]
+            agent = args.get("agent", None)
 
-        try:
-            file_exists = os.path.exists(file_path)
-            content = ""
+            # 创建已处理文件变量，用于失败时回滚
+            original_content = None
+            processed = False
+            file_success = True
 
             try:
-                # 如果文件存在，则读取内容
-                if file_exists:
-                    with open(file_path, "r", encoding="utf-8") as f:
-                        content = f.read()
-                        original_content = content
-
-                if file_exists and agent:
-                    files = agent.get_user_data("files")
-                    if not files or file_path not in files:
-                        return {
-                            "success": False,
-                            "stdout": "",
-                            "stderr": f"请先读取文件 {file_path} 的内容后再编辑",
-                        }
-
-                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, allow_unicode=True),
-                            spinner,
-                        )
-                        if not success:
-                            spinner.text = f"文件 {file_path} 处理失败"
-                            spinner.fail("❌")
-                            return {
+                file_exists = os.path.exists(file_path)
+                content = ""
+
+                try:
+                    # 如果文件存在，则读取内容
+                    if file_exists:
+                        with open(file_path, "r", encoding="utf-8") as f:
+                            content = f.read()
+                            original_content = content
+
+                    if file_exists and agent:
+                        files = agent.get_user_data("files")
+                        if not files or file_path not in files:
+                            file_results.append({
+                                "file": file_path,
                                 "success": False,
                                 "stdout": "",
-                                "stderr": temp_content,
-                            }
+                                "stderr": f"请先读取文件 {file_path} 的内容后再编辑"
+                            })
+                            continue
+
+                    with yaspin(
+                        text=f"正在处理文件 {file_path}...", color="cyan"
+                    ) as spinner:
+                        # 首先尝试fast_edit模式
+                        success, temp_content = EditFileHandler._fast_edit(file_path, changes, spinner)
+                        if not success:
+                            # 如果fast_edit失败，尝试slow_edit模式
+                            success, temp_content = EditFileHandler._slow_edit(
+                                file_path,
+                                changes,
+                                spinner,
+                                agent
+                            )
+                            if not success:
+                                spinner.text = f"文件 {file_path} 处理失败"
+                                spinner.fail("❌")
+                                file_results.append({
+                                    "file": file_path,
+                                    "success": False,
+                                    "stdout": "",
+                                    "stderr": temp_content
+                                })
+                                continue
+                            else:
+                                spinner.text = f"文件 {file_path} 内容生成完成"
+                                spinner.ok("✅")
                         else:
                             spinner.text = f"文件 {file_path} 内容生成完成"
                             spinner.ok("✅")
-                    else:
-                        spinner.text = f"文件 {file_path} 内容生成完成"
-                        spinner.ok("✅")
-
-                # 只有当所有替换操作都成功时，才写回文件
-                if success and (temp_content != original_content or not file_exists):
-                    # 确保目录存在
-                    os.makedirs(
-                        os.path.dirname(os.path.abspath(file_path)), exist_ok=True
-                    )
-
-                    with open(file_path, "w", encoding="utf-8") as f:
-                        f.write(temp_content)
 
-                    processed = True
-
-                    action = "创建并写入" if not file_exists else "成功修改"
-                    stdout_message = f"文件 {file_path} {action} 完成"
-                    stdout_messages.append(stdout_message)
-                    PrettyOutput.print(stdout_message, OutputType.SUCCESS)
-
-            except Exception as e:
-                stderr_message = f"处理文件 {file_path} 时出错: {str(e)}"
-                stderr_messages.append(stderr_message)
-                PrettyOutput.print(stderr_message, OutputType.WARNING)
-                success = False
-
-            return {
-                "success": success,
-                "stdout": "\n".join(stdout_messages) if success else "",
-                "stderr": "\n".join(stderr_messages) if not success else "",
-            }
-
-        except Exception as e:
-            error_msg = f"文件搜索替换操作失败: {str(e)}"
-            PrettyOutput.print(error_msg, OutputType.WARNING)
-
-            # 如果有已修改的文件，尝试回滚
-            if processed:
-                rollback_message = "操作失败，正在回滚修改..."
-                stderr_messages.append(rollback_message)
-                PrettyOutput.print(rollback_message, OutputType.WARNING)
+                    # 只有当所有替换操作都成功时，才写回文件
+                    if success and (temp_content != original_content or not file_exists):
+                        # 确保目录存在
+                        os.makedirs(
+                            os.path.dirname(os.path.abspath(file_path)), exist_ok=True
+                        )
 
-                try:
-                    if original_content is None:
-                        # 如果是新创建的文件，则删除
-                        if os.path.exists(file_path):
-                            os.remove(file_path)
-                        stderr_messages.append(f"已删除新创建的文件: {file_path}")
-                    else:
-                        # 如果是修改的文件，则恢复原内容
                         with open(file_path, "w", encoding="utf-8") as f:
-                            f.write(original_content)
-                        stderr_messages.append(f"已回滚文件: {file_path}")
-                except:
-                    stderr_messages.append(f"回滚文件失败: {file_path}")
-
-            return {
-                "success": False,
-                "stdout": "",
-                "stderr": error_msg + "\n" + "\n".join(stderr_messages),
-            }
-
-
-def slow_edit(filepath: str, patch_content: str, spinner: Yaspin) -> Tuple[bool, str]:
-    """执行精确的文件编辑操作，使用AI模型生成差异补丁并应用。
-
-    核心功能:
-    1. 使用AI模型分析补丁内容并生成精确的代码差异
-    2. 应用生成的差异补丁到目标文件
-    3. 提供3次重试机制确保操作可靠性
-    4. 支持大文件处理(自动上传到模型平台)
-    5. 严格的格式一致性检查
-
-    参数:
-        filepath: 要编辑的文件路径(绝对或相对路径)
-        patch_content: YAML格式的补丁内容，包含:
-            - reason: 修改原因描述
-            - search: 需要查找的原始代码(必须包含足够上下文)
-            - replace: 替换后的新代码
-        spinner: Yaspin实例，用于显示处理状态
-
-    返回值:
-        Tuple[bool, str]:
-            - 第一个元素表示操作是否成功(True/False)
-            - 第二个元素是修改后的文件内容(成功时)或空字符串(失败时)
-
-    异常处理:
-    1. 文件不存在或权限不足时会捕获异常并返回失败
-    2. 模型生成补丁失败时会自动重试最多3次
-    3. 补丁应用失败时会自动回滚文件修改
-
-    实现细节:
-    1. 检查文件是否在工作目录下(影响版本控制)
-    2. 根据文件大小决定是否上传到模型平台
-    3. 使用精确的DIFF格式解析模型生成的补丁
-    4. 确保补丁应用前进行唯一性匹配检查
-    """
-    import os
-
-    work_dir = os.path.abspath(os.curdir)
-    filepath = os.path.abspath(filepath)
-    if not filepath.startswith(work_dir):
-        PrettyOutput.print(
-            f"文件 {filepath} 不在工作目录 {work_dir} 下，不会进行版本控制管理",
-            OutputType.WARNING,
-        )
-    model = PlatformRegistry().get_normal_platform()
-    try:
-        file_content = FileOperationTool().execute(
-            {"operation": "read", "files": [{"path": filepath}]}
-        )["stdout"]
-        is_large_context = is_context_overflow(file_content)
-        upload_success = False
-        # 读取原始文件内容
-        with spinner.hidden():
-            if (
-                is_large_context
-                and model.support_upload_files()
-                and model.upload_files([filepath])
-            ):
-                upload_success = True
-
-        model.set_suppress_output(True)
-
-        main_prompt = f"""
-# 代码补丁生成专家指南
-
-## 任务描述
-你是一位精确的代码补丁生成专家，需要根据补丁描述生成精确的代码差异。
-
-### 补丁内容
-```
-{patch_content}
-```
-
-## 补丁生成要求
-1. **精确性**：严格按照补丁的意图修改代码
-2. **格式一致性**：严格保持原始代码的格式风格，如果补丁中缩进或者空行与原代码不一致，则需要修正补丁中的缩进或者空行
-3. **最小化修改**：只修改必要的代码部分，保持其他部分不变
-4. **上下文完整性**：提供足够的上下文，确保补丁能准确应用
-
-## 输出格式规范
-- 使用{ot("DIFF")}块包围每个需要修改的代码段
-- 每个{ot("DIFF")}块必须包含SEARCH部分和REPLACE部分
-- SEARCH部分是需要查找的原始代码
-- REPLACE部分是替换后的新代码
-- 确保SEARCH部分能在原文件中**唯一匹配**
-- 如果修改较大，可以使用多个{ot("DIFF")}块
-
-## 输出模板
-{ot("DIFF")}
-{">" * 5} SEARCH
-[需要查找的原始代码，包含足够上下文，避免出现可匹配多处的情况]
-{'='*5}
-[替换后的新代码]
-{"<" * 5} REPLACE
-{ct("DIFF")}
-
-{ot("DIFF")}
-{">" * 5} SEARCH
-[另一处需要查找的原始代码，包含足够上下文，避免出现可匹配多处的情况]
-{'='*5}
-[另一处替换后的新代码]
-{"<" * 5} REPLACE
-{ct("DIFF")}
-"""
+                            f.write(temp_content)
+
+                        processed = True
+
+                        action = "创建并写入" if not file_exists else "成功修改"
+                        stdout_message = f"文件 {file_path} {action} 完成"
+                        stdout_messages.append(stdout_message)
+                        PrettyOutput.print(stdout_message, OutputType.SUCCESS)
+                        overall_success = True
+
+                        file_results.append({
+                            "file": file_path,
+                            "success": True,
+                            "stdout": stdout_message,
+                            "stderr": ""
+                        })
+
+                except Exception as e:
+                    stderr_message = f"处理文件 {file_path} 时出错: {str(e)}"
+                    stderr_messages.append(stderr_message)
+                    PrettyOutput.print(stderr_message, OutputType.WARNING)
+                    file_success = False
+                    file_results.append({
+                        "file": file_path,
+                        "success": False,
+                        "stdout": "",
+                        "stderr": stderr_message
+                    })
 
-        for _ in range(3):
-            if is_large_context:
-                if upload_success:
-                    response = model.chat_until_success(main_prompt)
-                else:
-                    file_prompt = f"""
-# 原始代码
-{file_content}
-"""
-                    response = model.chat_until_success(main_prompt + file_prompt)
-            else:
-                file_prompt = f"""
-# 原始代码
-{file_content}
-"""
-                response = model.chat_until_success(main_prompt + file_prompt)
-
-            # 解析差异化补丁
-            diff_blocks = re.finditer(
-                ot("DIFF")
-                + r"\s*>{4,} SEARCH\n?(.*?)\n?={4,}\n?(.*?)\s*<{4,} REPLACE\n?"
-                + ct("DIFF"),
-                response,
-                re.DOTALL,
-            )
-
-            patches = []
-            for match in diff_blocks:
-                patches.append(
-                    {
-                        "search": match.group(1).strip(),
-                        "replace": match.group(2).strip(),
-                    }
-                )
-
-            success, modified_content_or_err = fast_edit(filepath, patches, spinner)
-            if success:
-                return True, modified_content_or_err
-        spinner.text = f"文件 {filepath} 修改失败"
-        spinner.fail("❌")
-        return False, f"文件修改失败: {modified_content_or_err}"
-
-    except Exception as e:
-        spinner.text = f"文件修改失败: {str(e)}"
-        spinner.fail("❌")
-        return False, f"文件修改失败: {str(e)}"
-
-
-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
-    err_msg = ""
-    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
-                err_msg = f"搜索文本 ```\n{search_text}\n``` 在文件中存在多处，请检查补丁内容"
-                break
-            # 应用替换
-            modified_content = modified_content.replace(search_text, replace_text)
-            spinner.write(f"✅ 补丁 #{patch_count} 应用成功")
-        else:
-            # 尝试增加缩进重试
-            found = False
-            for space_count in range(1, 17):
-                # 跳过空行不增加空格
-                indented_search = "\n".join(
-                    " " * space_count + line if line.strip() else line
-                    for line in search_text.split("\n")
-                )
-                indented_replace = "\n".join(
-                    " " * space_count + line if line.strip() else line
-                    for line in replace_text.split("\n")
-                )
-                if indented_search in modified_content:
-                    if modified_content.count(indented_search) > 1:
-                        success = False
-                        err_msg = f"搜索文本 ```\n{indented_search}\n``` 在文件中存在多处，请检查补丁内容"
-                        break
-                    modified_content = modified_content.replace(
-                        indented_search, indented_replace
-                    )
-                    spinner.write(
-                        f"✅ 补丁 #{patch_count} 应用成功 (自动增加 {space_count} 个空格缩进)"
-                    )
-                    found = True
-                    break
-
-            if not found:
-                success = False
-                err_msg = f"搜索文本 ```\n{search_text}\n``` 在文件中不存在，尝试增加1-16个空格缩进后仍未找到匹配"
-                break
-    if not success:
-        revert_file(filepath)
-        return False, err_msg
-
-    spinner.text = f"文件 {filepath} 修改完成，应用了 {patch_count} 个补丁"
-    spinner.ok("✅")
-    return True, modified_content
+            except Exception as e:
+                error_msg = f"文件搜索替换操作失败: {str(e)}"
+                PrettyOutput.print(error_msg, OutputType.WARNING)
+
+                # 如果有已修改的文件，尝试回滚
+                if processed:
+                    rollback_message = "操作失败，正在回滚修改..."
+                    stderr_messages.append(rollback_message)
+                    PrettyOutput.print(rollback_message, OutputType.WARNING)
+
+                    try:
+                        if original_content is None:
+                            # 如果是新创建的文件，则删除
+                            if os.path.exists(file_path):
+                                os.remove(file_path)
+                            stderr_messages.append(f"已删除新创建的文件: {file_path}")
+                        else:
+                            # 如果是修改的文件，则恢复原内容
+                            with open(file_path, "w", encoding="utf-8") as f:
+                                f.write(original_content)
+                            stderr_messages.append(f"已回滚文件: {file_path}")
+                    except:
+                        stderr_messages.append(f"回滚文件失败: {file_path}")
+
+                file_results.append({
+                    "file": file_path,
+                    "success": False,
+                    "stdout": "",
+                    "stderr": error_msg
+                })
+
+        # 整合所有错误信息到stderr
+        all_stderr = []
+        for result in file_results:
+            if not result["success"]:
+                all_stderr.append(f"文件 {result['file']} 处理失败: {result['stderr']}")
+
+        return {
+            "success": overall_success,
+            "stdout": "\n".join(stdout_messages) if overall_success else "",
+            "stderr": "\n".join(all_stderr) if not overall_success else ""
+        }

jarvis/jarvis_tools/registry.py

@@ -553,24 +553,24 @@ class ToolRegistry(OutputHandlerProtocol):
         for item in data:
             try:
                 msg = yaml.safe_load(item)
-                if "name" in msg and "arguments" in msg and "want" in msg:
-                    ret.append(msg)
-                else:
-                    return (
-                        {},
-                        f"""工具调用格式错误，请检查工具调用格式（缺少name、arguments、want字段）。
-
-                    {tool_call_help}""",
-                    )
             except Exception as e:
                 return (
                     {},
-                    f"""工具调用格式错误，请检查工具调用格式。
-
+                    f"""yaml 解析失败，请检查工具调用格式。
                     {e}
 
                 {tool_call_help}""",
                 )
+
+            if "name" in msg and "arguments" in msg and "want" in msg:
+                ret.append(msg)
+            else:
+                return (
+                    {},
+                    f"""工具调用格式错误，请检查工具调用格式（缺少name、arguments、want字段）。
+
+                {tool_call_help}""",
+                )
         if len(ret) > 1:
             return {}, "检测到多个工具调用，请一次只处理一个工具调用。"
         return ret[0] if ret else {}, ""

{jarvis_ai_assistant-0.1.200.dist-info → jarvis_ai_assistant-0.1.201.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jarvis-ai-assistant
-Version: 0.1.200
+Version: 0.1.201
 Summary: Jarvis: An AI assistant that uses tools to interact with the system
 Home-page: https://github.com/skyfireitdiy/Jarvis
 Author: skyfire

{jarvis_ai_assistant-0.1.200.dist-info → jarvis_ai_assistant-0.1.201.dist-info}/RECORD

@@ -1,12 +1,13 @@
-jarvis/__init__.py,sha256=ePqWF92FI0LF1Btg_GrnhZEoxtiseFY4-wiB5EEsh-U,75
+jarvis/__init__.py,sha256=XoMsxsLPrhfMd065rmFmYUdR1fphq5QSppiLCyiyHnU,75
 jarvis/jarvis_agent/__init__.py,sha256=X5BWIOzxXUWtCbpDkTFfUYskf6sbNzb1qQu8nQ4NN1k,34371
 jarvis/jarvis_agent/builtin_input_handler.py,sha256=1V7kV5Zhw2HE3Xgjs1R-43RZ2huq3Kg-32NCdNnyZmA,2216
+jarvis/jarvis_agent/edit_file_handler.py,sha256=Su25_idE9UCXn3uB2pJV4VisYcUTpeBtmkX9OI3tIIo,15336
 jarvis/jarvis_agent/jarvis.py,sha256=GH2zi8eXNpW8twiY3LKDEZgGmFC5geB0jlkwFrm7hOQ,6279
 jarvis/jarvis_agent/main.py,sha256=c6bQe-8LXvW2-NBn9Rn_yPYdrwnkJ8KQaSFY2cPvkxw,2775
 jarvis/jarvis_agent/output_handler.py,sha256=P7oWpXBGFfOsWq7cIhS_z9crkQ19ES7qU5pM92KKjAs,1172
 jarvis/jarvis_agent/shell_input_handler.py,sha256=zVaKNthIHJh1j4g8_-d3w5ahNH9aH-ZNRSOourQpHR4,1328
 jarvis/jarvis_code_agent/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-jarvis/jarvis_code_agent/code_agent.py,sha256=aNAjj7EqabaMQg8Ngf26TMLpQJpBVceE-_FPTpXbRs8,15389
+jarvis/jarvis_code_agent/code_agent.py,sha256=fr2_hqFuTyLqVB_huLgbz-UB0GIJM4YIQoi6s_X-WzE,15466
 jarvis/jarvis_code_agent/lint.py,sha256=j1kS-wFYigmkXyxOuUiaJ9cknYkraikQSSf51VWturE,4038
 jarvis/jarvis_code_analysis/code_review.py,sha256=jwvGYwwTM7UG6cESw6I7vCp6FimESKvowCbz6u28ikE,31439
 jarvis/jarvis_code_analysis/checklists/__init__.py,sha256=LIXAYa1sW3l7foP6kohLWnE98I_EQ0T7z5bYKHq6rJA,78
@@ -45,13 +46,13 @@ jarvis/jarvis_methodology/main.py,sha256=NMtd6DRn-Q8NcYtQ3qgTKUp9RW0cDGJod8ZXebl
 jarvis/jarvis_multi_agent/__init__.py,sha256=sDd3sK88dS7_qAz2ywIAaEWdQ4iRVCiuBu2rQQmrKbU,4512
 jarvis/jarvis_multi_agent/main.py,sha256=h7VUSwoPrES0XTK8z5kt3XLX1mmcm8UEuFEHQOUWPH4,1696
 jarvis/jarvis_platform/__init__.py,sha256=WLQHSiE87PPket2M50_hHzjdMIgPIBx2VF8JfB_NNRk,105
-jarvis/jarvis_platform/base.py,sha256=HsqEtgVF_ZUdXUgeod6IRDWPRggKkovkGCJxOwEtRe8,7759
+jarvis/jarvis_platform/base.py,sha256=69DFeYZjtyvOF12YReLZHQINcW-w-LseogwAYQRff7k,7880
 jarvis/jarvis_platform/human.py,sha256=r8Vlltp_LirJZeZh1Mmi30iJr9tl1JaNFoqthSRHF6o,2826
 jarvis/jarvis_platform/kimi.py,sha256=uIpSWQ3MqDBYYMROeXin_YqM2LFrovMICKpwLWO1ODo,12784
 jarvis/jarvis_platform/openai.py,sha256=uEjBikfFj7kp5wondLvOx4WdkmTX0aqF6kixxAufcHg,4806
 jarvis/jarvis_platform/registry.py,sha256=Sz4ADAaxuufpAQG0KSQZuL1yALzH-aF3FDapkNn5foE,8107
 jarvis/jarvis_platform/tongyi.py,sha256=zu1bE-LdF_Sohwb5FxoIkDOTI0Lv5G_XhuSOPI20Gf8,21190
-jarvis/jarvis_platform/yuanbao.py,sha256=nzdizTNM1d9OWfxkAZjBkhA_hllNPekpcv2vhJiPUB0,21446
+jarvis/jarvis_platform/yuanbao.py,sha256=_lJFnxu5ZK3ihtG8JW4bWDu2VGVCZPm19CdmU4vqAS8,21446
 jarvis/jarvis_platform_manager/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 jarvis/jarvis_platform_manager/main.py,sha256=BdBH2tPzq7p9Mvii7abu6M7uj4lfG05gwjYfMqU5HUA,29567
 jarvis/jarvis_smart_shell/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -63,7 +64,7 @@ jarvis/jarvis_tools/chdir.py,sha256=BlRvggcOeBM7UwHGL8U8hjuNm_WGkH5BdhxmPVJXejw,
 jarvis/jarvis_tools/code_plan.py,sha256=XRXHdkN4O1A4qbShLa4VBHFdRl6YdyMgZxbPPotrqNs,7358
 jarvis/jarvis_tools/create_code_agent.py,sha256=wls2B2iLrIEeG9kSWnJHv1wQ4TNqdD9T5OPoAyN53N0,3384
 jarvis/jarvis_tools/create_sub_agent.py,sha256=ilnApbz7ptNz5o3IrhBTTiNMJGtdeUmkpYL2BFqyI6c,2874
-jarvis/jarvis_tools/edit_file.py,sha256=Awe_2zZxRl_2u81pu4VKb9Rom4xzbYpZV07_s7BEhLM,18747
+jarvis/jarvis_tools/edit_file.py,sha256=lXF4fetuXtIoLfxQyxHR3QqxvNOVN4oEFbafxUvyZDw,11517
 jarvis/jarvis_tools/execute_script.py,sha256=gMarE5yCCSPU6Dp6HlcL2KT-2xCzR-1p-oQNlYOJK58,6157
 jarvis/jarvis_tools/file_analyzer.py,sha256=SvNLve5AL2d3oQsWSoHouIsAsYanksBnl5RCCsrw2PQ,4604
 jarvis/jarvis_tools/file_operation.py,sha256=b488jf0_l7aP0RkntaNE9WqZXtbdrQTJdmWawJbfC-A,9529
@@ -71,7 +72,7 @@ jarvis/jarvis_tools/generate_new_tool.py,sha256=2YAs8DC7fJnxOkjSmhmSAwqSpBlicVhY
 jarvis/jarvis_tools/methodology.py,sha256=_K4GIDUodGEma3SvNRo7Qs5rliijgNespVLyAPN35JU,5233
 jarvis/jarvis_tools/read_code.py,sha256=6mQ3KNGc43FTiLFxMbAN28FTSVhVfkFJ6mob4heXBNM,6663
 jarvis/jarvis_tools/read_webpage.py,sha256=NmDUboVZd4CGHBPRFK6dp3uqVhuGopW1bOi3TcaLDF4,2092
-jarvis/jarvis_tools/registry.py,sha256=ZuD6x4znAGwB-Z7-43f-SAlrFPIVaLiHqzpZp6zc5r4,25729
+jarvis/jarvis_tools/registry.py,sha256=0SdgBi-b1qnd3QX0VvQy7UVU7Pq9BZGYLiAe7t0DjpQ,25690
 jarvis/jarvis_tools/rewrite_file.py,sha256=eG_WKg6cVAXmuGwUqlWkcuyay5S8DOzEi8vZCmX3O8w,7255
 jarvis/jarvis_tools/search_web.py,sha256=C-TuBFy25WOSiwRCe7YiL0hnMx0DuHj6upHO5OtkHTA,925
 jarvis/jarvis_tools/virtual_tty.py,sha256=KKr3jpvQWWMPr2o40hlmN6fuXJCN8H4_ma5QU40Citc,16089
@@ -90,9 +91,9 @@ jarvis/jarvis_utils/methodology.py,sha256=MhPrMxMqElyAn54BDfpQdUqrRr7IbSlrLvAI39
 jarvis/jarvis_utils/output.py,sha256=PRCgudPOB8gMEP3u-g0FGD2c6tBgJhLXUMqNPglfjV8,10813
 jarvis/jarvis_utils/tag.py,sha256=f211opbbbTcSyzCDwuIK_oCnKhXPNK-RknYyGzY1yD0,431
 jarvis/jarvis_utils/utils.py,sha256=RYFQx7OkOu3fe_QhS-5jx7O06k_58X14S-9PFJgwOa4,12178
-jarvis_ai_assistant-0.1.200.dist-info/licenses/LICENSE,sha256=AGgVgQmTqFvaztRtCAXsAMryUymB18gZif7_l2e1XOg,1063
-jarvis_ai_assistant-0.1.200.dist-info/METADATA,sha256=ZCSRI6f3QMXnALhhPRM0ZjlnWQUYn0AhoqbtsA0xzRk,20215
-jarvis_ai_assistant-0.1.200.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-jarvis_ai_assistant-0.1.200.dist-info/entry_points.txt,sha256=Gy3DOP1PYLMK0GCj4rrP_9lkOyBQ39EK_lKGUSwn41E,869
-jarvis_ai_assistant-0.1.200.dist-info/top_level.txt,sha256=1BOxyWfzOP_ZXj8rVTDnNCJ92bBGB0rwq8N1PCpoMIs,7
-jarvis_ai_assistant-0.1.200.dist-info/RECORD,,
+jarvis_ai_assistant-0.1.201.dist-info/licenses/LICENSE,sha256=AGgVgQmTqFvaztRtCAXsAMryUymB18gZif7_l2e1XOg,1063
+jarvis_ai_assistant-0.1.201.dist-info/METADATA,sha256=EbsPZQI2mPfbeRv6WsJen2ky8nuzILlVZboR0ZaVWBU,20215
+jarvis_ai_assistant-0.1.201.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+jarvis_ai_assistant-0.1.201.dist-info/entry_points.txt,sha256=Gy3DOP1PYLMK0GCj4rrP_9lkOyBQ39EK_lKGUSwn41E,869
+jarvis_ai_assistant-0.1.201.dist-info/top_level.txt,sha256=1BOxyWfzOP_ZXj8rVTDnNCJ92bBGB0rwq8N1PCpoMIs,7
+jarvis_ai_assistant-0.1.201.dist-info/RECORD,,