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

jarvis/__init__.py

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

jarvis/jarvis_agent/__init__.py

@@ -729,7 +729,14 @@ class Agent:
             pass
 
         response = self.model.chat_until_success(message)  # type: ignore
-
+        # 防御: 模型可能返回空响应(None或空字符串)，统一为空字符串并告警
+        if not response:
+            try:
+                PrettyOutput.print("模型返回空响应，已使用空字符串回退。", OutputType.WARNING)
+            except Exception:
+                pass
+            response = ""
+        
         # 事件：模型调用后
         try:
             self.event_bus.emit(
@@ -761,7 +768,13 @@ class Agent:
             summary = self.model.chat_until_success(
                 self.session.prompt + "\n" + SUMMARY_REQUEST_PROMPT
             )  # type: ignore
-
+            # 防御: 可能返回空响应(None或空字符串)，统一为空字符串并告警
+            if not summary:
+                try:
+                    PrettyOutput.print("总结模型返回空响应，已使用空字符串回退。", OutputType.WARNING)
+                except Exception:
+                    pass
+                summary = ""
             return summary
         except Exception:
             PrettyOutput.print("总结对话历史失败", OutputType.ERROR)
@@ -898,6 +911,13 @@ class Agent:
             if not self.model:
                 raise RuntimeError("Model not initialized")
             ret = self.model.chat_until_success(self.session.prompt)  # type: ignore
+            # 防御: 总结阶段模型可能返回空响应(None或空字符串)，统一为空字符串并告警
+            if not ret:
+                try:
+                    PrettyOutput.print("总结阶段模型返回空响应，已使用空字符串回退。", OutputType.WARNING)
+                except Exception:
+                    pass
+                ret = ""
             result = ret
 
             # 广播完成总结事件

jarvis/jarvis_agent/edit_file_handler.py

@@ -13,7 +13,11 @@ class EditFileHandler(OutputHandler):
             ot("PATCH file=(?:'([^']+)'|\"([^\"]+)\"|([^>]+))") + r"\s*"
             r"(?:"
             + ot("DIFF")
-            + r"\s*"
+            + r"\s*(?:"
+            # 可选的RANGE标签，限制替换行号范围
+            + r"(?:" + ot("RANGE") + r"(.*?)" + ct("RANGE") + r"\s*)?"
+            + r"(?:"
+            # 单点替换（SEARCH/REPLACE）
             + ot("SEARCH")
             + r"(.*?)"
             + ct("SEARCH")
@@ -21,15 +25,29 @@ class EditFileHandler(OutputHandler):
             + ot("REPLACE")
             + r"(.*?)"
             + ct("REPLACE")
+            + r"|"
+            # 区间替换（SEARCH_START/SEARCH_END/REPLACE）
+            + ot("SEARCH_START")
+            + r"(.*?)"
+            + ct("SEARCH_START")
+            + r"\s*"
+            + ot("SEARCH_END")
+            + r"(.*?)"
+            + ct("SEARCH_END")
             + r"\s*"
+            + ot("REPLACE")
+            + r"(.*?)"
+            + ct("REPLACE")
+            + r")"
+            + r")\s*"
             + ct("DIFF")
             + r"\s*)+"
-            + ct("PATCH"),
-            re.DOTALL,
+            + r"^" + ct("PATCH"),
+            re.DOTALL | re.MULTILINE,
         )
         self.diff_pattern = re.compile(
             ot("DIFF")
-            + r"\s*"
+            + r"\s*(?:" + ot("RANGE") + r"(.*?)" + ct("RANGE") + r"\s*)?"
             + ot("SEARCH")
             + r"(.*?)"
             + ct("SEARCH")
@@ -41,6 +59,24 @@ class EditFileHandler(OutputHandler):
             + ct("DIFF"),
             re.DOTALL,
         )
+        self.diff_range_pattern = re.compile(
+            ot("DIFF")
+            + r"\s*(?:" + ot("RANGE") + r"(.*?)" + ct("RANGE") + r"\s*)?"
+            + ot("SEARCH_START")
+            + r"(.*?)"
+            + ct("SEARCH_START")
+            + r"\s*"
+            + ot("SEARCH_END")
+            + r"(.*?)"
+            + ct("SEARCH_END")
+            + r"\s*"
+            + ot("REPLACE")
+            + r"(.*?)"
+            + ct("REPLACE")
+            + r"\s*"
+            + ct("DIFF"),
+            re.DOTALL,
+        )
 
     def handle(self, response: str, agent: Any) -> Tuple[bool, str]:
         """处理文件编辑响应
@@ -65,9 +101,7 @@ class EditFileHandler(OutputHandler):
 
         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
-            ]
+            file_patches = diffs
 
             success, result = self._fast_edit(file_path, file_patches)
 
@@ -96,17 +130,44 @@ class EditFileHandler(OutputHandler):
         Returns:
             str: 返回处理器的提示字符串
         """
-        return f"""文件编辑指令格式：
-{ot("PATCH file=文件路径")}
-{ot("DIFF")}
+        from jarvis.jarvis_utils.config import get_patch_format
+
+        patch_format = get_patch_format()
+
+        search_prompt = f"""{ot("DIFF")}
 {ot("SEARCH")}原始代码{ct("SEARCH")}
 {ot("REPLACE")}新代码{ct("REPLACE")}
-{ct("DIFF")}
+{ct("DIFF")}"""
+
+        search_range_prompt = f"""{ot("DIFF")}
+{ot("RANGE")}起止行号(如: 10-50)，可选{ct("RANGE")}
+{ot("SEARCH_START")}起始标记{ct("SEARCH_START")}
+{ot("SEARCH_END")}结束标记{ct("SEARCH_END")}
+{ot("REPLACE")}替换内容{ct("REPLACE")}
+{ct("DIFF")}"""
+
+        if patch_format == "search":
+            formats = search_prompt
+            supported_formats = "仅支持单点替换（SEARCH/REPLACE）"
+        elif patch_format == "search_range":
+            formats = search_range_prompt
+            supported_formats = "仅支持区间替换（SEARCH_START/SEARCH_END/REPLACE），可选RANGE限定行号范围"
+        else:  # all
+            formats = f"{search_prompt}\n或\n{search_range_prompt}"
+            supported_formats = "支持两种DIFF块：单点替换（SEARCH/REPLACE）与区间替换（SEARCH_START/SEARCH_END/REPLACE）"
+
+        return f"""文件编辑指令格式：
+{ot("PATCH file=文件路径")}
+{formats}
 {ct("PATCH")}
 
-可以返回多个PATCH块用于同时修改多个文件
-每个PATCH块可以包含多个DIFF块，每个DIFF块包含一组搜索和替换内容。
-搜索文本必须能在文件中唯一匹配，否则编辑将失败。"""
+注意：
+- {ot("PATCH")} 和 {ct("PATCH")} 必须出现在行首，否则不生效（会被忽略）
+- {supported_formats}
+- {ot("RANGE")}start-end{ct("RANGE")} 仅用于区间替换模式（SEARCH_START/SEARCH_END），表示只在指定行号范围内进行匹配与替换（1-based，闭区间）；省略则在整个文件范围内处理
+- 单点替换要求 SEARCH 在有效范围内唯一匹配（仅替换第一个匹配）
+- 区间替换命中有效范围内的第一个 {ot("SEARCH_START")} 及其后的第一个 {ot("SEARCH_END")}
+否则编辑将失败。"""
 
     def name(self) -> str:
         """获取处理器的名称
@@ -139,18 +200,75 @@ class EditFileHandler(OutputHandler):
                 }
         """
         patches: Dict[str, List[Dict[str, str]]] = {}
+
         for match in self.patch_pattern.finditer(response):
             # Get the file path from the appropriate capture group
             file_path = match.group(1) or match.group(2) or match.group(3)
-            diffs = []
-            for diff_match in self.diff_pattern.finditer(match.group(0)):
-                # 完全保留原始格式（包括所有空白和换行）
-                diffs.append(
-                    {
-                        "SEARCH": diff_match.group(1),  # 原始SEARCH内容
-                        "REPLACE": diff_match.group(2),  # 原始REPLACE内容
+            diffs: List[Dict[str, str]] = []
+
+            # 逐块解析，保持 DIFF 顺序
+            diff_block_pattern = re.compile(ot("DIFF") + r"(.*?)" + ct("DIFF"), re.DOTALL)
+            for block_match in diff_block_pattern.finditer(match.group(0)):
+                block_text = block_match.group(1)
+
+                # 提取可选的行号范围
+                range_scope = None
+                range_scope_match = re.match(
+                    r"^\s*" + ot("RANGE") + r"(.*?)" + ct("RANGE") + r"\s*",
+                    block_text,
+                    re.DOTALL,
+                )
+                if range_scope_match:
+                    range_scope = range_scope_match.group(1).strip()
+                    # 仅移除块首部的RANGE标签，避免误删内容中的同名标记
+                    block_text = block_text[range_scope_match.end():]
+                # 统一按 all 解析：无视配置，始终尝试区间替换
+                range_match = re.search(
+                    ot("SEARCH_START")
+                    + r"(.*?)"
+                    + ct("SEARCH_START")
+                    + r"\s*"
+                    + ot("SEARCH_END")
+                    + r"(.*?)"
+                    + ct("SEARCH_END")
+                    + r"\s*"
+                    + ot("REPLACE")
+                    + r"(.*?)"
+                    + ct("REPLACE"),
+                    block_text,
+                    re.DOTALL,
+                )
+                if range_match:
+                    diff_item: Dict[str, str] = {
+                        "SEARCH_START": range_match.group(1),  # 原始SEARCH_START内容
+                        "SEARCH_END": range_match.group(2),  # 原始SEARCH_END内容
+                        "REPLACE": range_match.group(3),  # 原始REPLACE内容
                     }
+                    if range_scope:
+                        diff_item["RANGE"] = range_scope
+                    diffs.append(diff_item)
+                    continue
+
+                # 解析单点替换（统一按 all 解析：无视配置，始终尝试单点替换）
+                single_match = re.search(
+                    ot("SEARCH")
+                    + r"(.*?)"
+                    + ct("SEARCH")
+                    + r"\s*"
+                    + ot("REPLACE")
+                    + r"(.*?)"
+                    + ct("REPLACE"),
+                    block_text,
+                    re.DOTALL,
                 )
+                if single_match:
+                    diff_item = {
+                        "SEARCH": single_match.group(1),  # 原始SEARCH内容
+                        "REPLACE": single_match.group(2),  # 原始REPLACE内容
+                    }
+                    # SEARCH 模式不支持 RANGE，直接忽略
+                    diffs.append(diff_item)
+
             if diffs:
                 if file_path in patches:
                     patches[file_path].extend(diffs)
@@ -194,85 +312,214 @@ class EditFileHandler(OutputHandler):
             failed_patches: List[Dict[str, Any]] = []
             successful_patches = 0
 
-            for patch in patches:
-                patch_count += 1
-                search_text = patch["SEARCH"]
-                replace_text = patch["REPLACE"]
-
-                # 精确匹配搜索文本（保留原始换行和空格）
-                exact_search = search_text
+            # 当存在RANGE时，确保按行号从后往前应用补丁，避免前面补丁影响后续RANGE的行号
+            ordered_patches: List[Dict[str, str]] = []
+            range_items: List[Tuple[int, int, int, Dict[str, str]]] = []
+            non_range_items: List[Tuple[int, Dict[str, str]]] = []
+            for idx, p in enumerate(patches):
+                r = p.get("RANGE")
+                if r and str(r).strip():
+                    m = re.match(r"\s*(\d+)\s*-\s*(\d+)\s*$", str(r))
+                    if m:
+                        start_line = int(m.group(1))
+                        end_line = int(m.group(2))
+                        range_items.append((start_line, end_line, idx, p))
+                    else:
+                        # RANGE格式无效的补丁保持原有顺序
+                        non_range_items.append((idx, p))
+                else:
+                    # 无RANGE的补丁保持原有顺序
+                    non_range_items.append((idx, p))
+            # 先应用RANGE补丁：按start_line、end_line、原始索引逆序
+            range_items.sort(key=lambda x: (x[0], x[1], x[2]), reverse=True)
+            ordered_patches = [item[3] for item in range_items] + [item[1] for item in non_range_items]
+
+            patch_count = len(ordered_patches)
+            for patch in ordered_patches:
                 found = False
 
-                if exact_search in modified_content:
-                    # 直接执行替换（保留所有原始格式），只替换第一个匹配
-                    modified_content = modified_content.replace(
-                        exact_search, replace_text, 1
-                    )
-
-                    found = True
-                else:
-                    # 如果匹配不到，并且search与replace块的首尾都是换行，尝试去掉第一个和最后一个换行
+                # 处理可选的RANGE范围：格式 "start-end"（1-based, 闭区间）
+                scoped = False
+                prefix = suffix = ""
+                base_content = modified_content
+                if "RANGE" in patch and str(patch["RANGE"]).strip():
+                    m = re.match(r"\s*(\d+)\s*-\s*(\d+)\s*$", str(patch["RANGE"]))
+                    if not m:
+                        error_msg = "RANGE格式无效，应为 'start-end' 的行号范围（1-based, 闭区间）"
+                        failed_patches.append({"patch": patch, "error": error_msg})
+                        # 不进行本补丁其它处理
+                        continue
+                    start_line = int(m.group(1))
+                    end_line = int(m.group(2))
+
+                    # 拆分为三段
+                    lines = modified_content.splitlines(keepends=True)
+                    total_lines = len(lines)
                     if (
-                        search_text.startswith("\n")
-                        and search_text.endswith("\n")
-                        and replace_text.startswith("\n")
-                        and replace_text.endswith("\n")
+                        start_line < 1
+                        or end_line < 1
+                        or start_line > end_line
+                        or start_line > total_lines
                     ):
-                        stripped_search = search_text[1:-1]
-                        stripped_replace = replace_text[1:-1]
-                        if stripped_search in modified_content:
-                            modified_content = modified_content.replace(
-                                stripped_search, stripped_replace, 1
-                            )
-
-                            found = True
-
-                    if not found:
-                        # 尝试增加缩进重试
-                        current_search = search_text
-                        current_replace = replace_text
+                        error_msg = f"RANGE行号无效（文件共有{total_lines}行）"
+                        failed_patches.append({"patch": patch, "error": error_msg})
+                        continue
+                    # 截断end_line不超过总行数
+                    end_line = min(end_line, total_lines)
+
+                    prefix = "".join(lines[: start_line - 1])
+                    base_content = "".join(lines[start_line - 1 : end_line])
+                    suffix = "".join(lines[end_line:])
+                    scoped = True
+
+                # 单点替换
+                if "SEARCH" in patch:
+                    search_text = patch["SEARCH"]
+                    replace_text = patch["REPLACE"]
+
+                    # 精确匹配搜索文本（保留原始换行和空格）
+                    exact_search = search_text
+
+                    def _count_occurrences(haystack: str, needle: str) -> int:
+                        if not needle:
+                            return 0
+                        return haystack.count(needle)
+
+                    # 1) 精确匹配，要求唯一
+                    cnt = _count_occurrences(base_content, exact_search)
+                    if cnt == 1:
+                        base_content = base_content.replace(exact_search, replace_text, 1)
+                        found = True
+                    elif cnt > 1:
+                        error_msg = "SEARCH 在指定范围内出现多次，要求唯一匹配"
+                        failed_patches.append({"patch": patch, "error": error_msg})
+                        # 不继续尝试其它变体
+                        continue
+                    else:
+                        # 2) 若首尾均为换行，尝试去掉首尾换行后匹配，要求唯一
                         if (
-                            current_search.startswith("\n")
-                            and current_search.endswith("\n")
-                            and current_replace.startswith("\n")
-                            and current_replace.endswith("\n")
+                            search_text.startswith("\n")
+                            and search_text.endswith("\n")
+                            and replace_text.startswith("\n")
+                            and replace_text.endswith("\n")
                         ):
-                            current_search = current_search[1:-1]
-                            current_replace = current_replace[1:-1]
-
-                        for space_count in range(1, 17):
-                            indented_search = "\n".join(
-                                " " * space_count + line if line.strip() else line
-                                for line in current_search.split("\n")
-                            )
-                            indented_replace = "\n".join(
-                                " " * space_count + line if line.strip() else line
-                                for line in current_replace.split("\n")
-                            )
-                            if indented_search in modified_content:
-                                modified_content = modified_content.replace(
-                                    indented_search, indented_replace, 1
+                            stripped_search = search_text[1:-1]
+                            stripped_replace = replace_text[1:-1]
+                            cnt2 = _count_occurrences(base_content, stripped_search)
+                            if cnt2 == 1:
+                                base_content = base_content.replace(
+                                    stripped_search, stripped_replace, 1
                                 )
-
                                 found = True
-                                break
+                            elif cnt2 > 1:
+                                error_msg = "SEARCH 在指定范围内出现多次（去掉首尾换行后），要求唯一匹配"
+                                failed_patches.append({"patch": patch, "error": error_msg})
+                                continue
+
+                        # 3) 尝试缩进适配（1..16个空格），要求唯一
+                        if not found:
+                            current_search = search_text
+                            current_replace = replace_text
+                            if (
+                                current_search.startswith("\n")
+                                and current_search.endswith("\n")
+                                and current_replace.startswith("\n")
+                                and current_replace.endswith("\n")
+                            ):
+                                current_search = current_search[1:-1]
+                                current_replace = current_replace[1:-1]
+
+                            for space_count in range(1, 17):
+                                indented_search = "\n".join(
+                                    " " * space_count + line if line.strip() else line
+                                    for line in current_search.split("\n")
+                                )
+                                indented_replace = "\n".join(
+                                    " " * space_count + line if line.strip() else line
+                                    for line in current_replace.split("\n")
+                                )
+                                cnt3 = _count_occurrences(base_content, indented_search)
+                                if cnt3 == 1:
+                                    base_content = base_content.replace(
+                                        indented_search, indented_replace, 1
+                                    )
+                                    found = True
+                                    break
+                                elif cnt3 > 1:
+                                    error_msg = "SEARCH 在指定范围内出现多次（缩进适配后），要求唯一匹配"
+                                    failed_patches.append({"patch": patch, "error": error_msg})
+                                    # 多匹配直接失败，不再继续尝试其它缩进
+                                    found = False
+                                    break
+
+                        if not found:
+                            # 未找到任何可用的唯一匹配
+                            failed_patches.append({"patch": patch, "error": "未找到唯一匹配的SEARCH"})
+
+                # 区间替换
+                elif "SEARCH_START" in patch and "SEARCH_END" in patch:
+                    search_start = patch["SEARCH_START"]
+                    search_end = patch["SEARCH_END"]
+                    replace_text = patch["REPLACE"]
+
+                    # 范围替换（包含边界），命中第一个起始标记及其后的第一个结束标记
+                    start_idx = base_content.find(search_start)
+                    if start_idx == -1:
+                        error_msg = "未找到SEARCH_START"
+                        failed_patches.append({"patch": patch, "error": error_msg})
+                    else:
+                        end_idx = base_content.find(search_end, start_idx)
+                        if end_idx == -1:
+                            error_msg = "在SEARCH_START之后未找到SEARCH_END"
+                            failed_patches.append({"patch": patch, "error": error_msg})
+                        else:
+                            # 避免额外空行:
+                            # 若 REPLACE 以换行结尾且 SEARCH_END 后紧跟换行符，
+                            # 则将该换行并入替换范围，防止出现双重换行导致“多一行”
+                            end_of_range = end_idx + len(search_end)
+                            if (
+                                end_of_range < len(base_content)
+                                and base_content[end_of_range] == "\n"
+                                and replace_text.endswith("\n")
+                            ):
+                                end_of_range += 1
+                            base_content = (
+                                base_content[:start_idx]
+                                + replace_text
+                                + base_content[end_of_range:]
+                            )
+                            found = True
 
-                if found:
-                    successful_patches += 1
                 else:
-                    error_msg = "搜索文本在文件中不存在"
-
+                    error_msg = "不支持的补丁格式"
                     failed_patches.append({"patch": patch, "error": error_msg})
 
+                # 若使用了RANGE，则将局部修改写回整体内容
+                if found:
+                    if scoped:
+                        modified_content = prefix + base_content + suffix
+                    else:
+                        modified_content = base_content
+                    successful_patches += 1
+
             # 写入修改后的内容
             with open(file_path, "w", encoding="utf-8") as f:
                 f.write(modified_content)
 
             if failed_patches:
-                error_details = [
-                    f"  - 失败的补丁: \n{p['patch']['SEARCH']}\n    错误: {p['error']}"
-                    for p in failed_patches
-                ]
+                error_details = []
+                for p in failed_patches:
+                    patch = p["patch"]
+                    if "SEARCH" in patch:
+                        patch_desc = patch["SEARCH"]
+                    else:
+                        patch_desc = (
+                            "SEARCH_START:\n"
+                            + (patch.get("SEARCH_START", ""))
+                            + "\nSEARCH_END:\n"
+                            + (patch.get("SEARCH_END", ""))
+                        )
+                    error_details.append(f"  - 失败的补丁: \n{patch_desc}\n    错误: {p['error']}")
                 if successful_patches == 0:
                     summary = (
                         f"文件 {file_path} 修改失败（全部失败）。\n"

jarvis/jarvis_code_agent/code_agent.py

@@ -529,8 +529,9 @@ class CodeAgent:
             if self.agent.force_save_memory:
                 self.agent.memory_manager.prompt_memory_save()
         elif start_commit:
-            os.system(f"git reset --hard {str(start_commit)}")  # 确保转换为字符串
-            PrettyOutput.print("已重置到初始提交", OutputType.INFO)
+            if user_confirm("是否要重置到初始提交？", True):
+                os.system(f"git reset --hard {str(start_commit)}")  # 确保转换为字符串
+                PrettyOutput.print("已重置到初始提交", OutputType.INFO)
 
     def run(self, user_input: str, prefix: str = "", suffix: str = "") -> Optional[str]:
         """使用给定的用户输入运行代码代理。
@@ -603,10 +604,92 @@ class CodeAgent:
         """工具调用后回调函数。"""
         final_ret = ""
         diff = get_diff()
+
+        # 构造按文件的状态映射与差异文本，删除文件不展示diff，仅提示删除
+        def _build_name_status_map() -> dict:
+            status_map = {}
+            try:
+                head_exists = bool(get_latest_commit_hash())
+                # 临时 -N 以包含未跟踪文件的差异检测
+                subprocess.run(["git", "add", "-N", "."], check=False, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+                cmd = ["git", "diff", "--name-status"] + (["HEAD"] if head_exists else [])
+                res = subprocess.run(
+                    cmd,
+                    capture_output=True,
+                    text=True,
+                    encoding="utf-8",
+                    errors="replace",
+                    check=False,
+                )
+            finally:
+                subprocess.run(["git", "reset"], check=False, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+
+            if res.returncode == 0 and res.stdout:
+                for line in res.stdout.splitlines():
+                    if not line.strip():
+                        continue
+                    parts = line.split("\t")
+                    if not parts:
+                        continue
+                    status = parts[0]
+                    if status.startswith("R") or status.startswith("C"):
+                        # 重命名/复制：使用新路径作为键
+                        if len(parts) >= 3:
+                            old_path, new_path = parts[1], parts[2]
+                            status_map[new_path] = status
+                            # 也记录旧路径，便于匹配 name-only 的结果
+                            status_map[old_path] = status
+                        elif len(parts) >= 2:
+                            status_map[parts[-1]] = status
+                    else:
+                        if len(parts) >= 2:
+                            status_map[parts[1]] = status
+            return status_map
+
+        def _get_file_diff(file_path: str) -> str:
+            """获取单文件的diff，包含新增文件内容；失败时返回空字符串"""
+            head_exists = bool(get_latest_commit_hash())
+            try:
+                # 为了让未跟踪文件也能展示diff，临时 -N 该文件
+                subprocess.run(["git", "add", "-N", "--", file_path], check=False, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+                cmd = ["git", "diff"] + (["HEAD"] if head_exists else []) + ["--", file_path]
+                res = subprocess.run(
+                    cmd,
+                    capture_output=True,
+                    text=True,
+                    encoding="utf-8",
+                    errors="replace",
+                    check=False,
+                )
+                if res.returncode == 0:
+                    return res.stdout or ""
+                return ""
+            finally:
+                subprocess.run(["git", "reset", "--", file_path], check=False, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+
+        def _build_per_file_patch_preview(modified_files: List[str]) -> str:
+            status_map = _build_name_status_map()
+            lines: List[str] = []
+            for f in modified_files:
+                status = status_map.get(f, "")
+                # 删除文件：不展示diff，仅提示
+                if (status.startswith("D")) or (not os.path.exists(f)):
+                    lines.append(f"- {f} 文件被删除")
+                    continue
+                # 其它情况：展示该文件的diff
+                file_diff = _get_file_diff(f)
+                if file_diff.strip():
+                    lines.append(f"文件: {f}\n```diff\n{file_diff}\n```")
+                else:
+                    # 当无法获取到diff（例如重命名或特殊状态），避免空输出
+                    lines.append(f"- {f} 变更已记录（无可展示的文本差异）")
+            return "\n".join(lines)
+
         if diff:
             start_hash = get_latest_commit_hash()
             PrettyOutput.print(diff, OutputType.CODE, lang="diff")
             modified_files = get_diff_file_list()
+            per_file_preview = _build_per_file_patch_preview(modified_files)
             commited = handle_commit_workflow()
             if commited:
                 # 统计代码行数变化
@@ -630,15 +713,14 @@ class CodeAgent:
 
                 StatsManager.increment("code_modifications", group="code_agent")
 
-
                 # 获取提交信息
                 end_hash = get_latest_commit_hash()
                 commits = get_commits_between(start_hash, end_hash)
 
-                # 添加提交信息到final_ret
+                # 添加提交信息到final_ret（按文件展示diff；删除文件仅提示）
                 if commits:
                     final_ret += (
-                        f"\n\n代码已修改完成\n补丁内容:\n```diff\n{diff}\n```\n"
+                        f"\n\n代码已修改完成\n补丁内容（按文件）:\n{per_file_preview}\n"
                     )
                     # 修改后的提示逻辑
                     lint_tools_info = "\n".join(
@@ -665,7 +747,7 @@ class CodeAgent:
                     final_ret += "\n\n修改没有生效\n"
             else:
                 final_ret += "\n修改被拒绝\n"
-                final_ret += f"# 补丁预览:\n```diff\n{diff}\n```"
+                final_ret += f"# 补丁预览（按文件）:\n{per_file_preview}"
         else:
             return
         # 用户确认最终结果

jarvis/jarvis_data/config_schema.json

@@ -7,6 +7,7 @@
     "JARVIS_MCP": {
       "type": "array",
       "description": "MCP工具配置列表",
+      "default": [],
       "items": {
         "type": "object",
         "oneOf": [
@@ -182,11 +183,22 @@
       "description": "执行工具前是否需要确认",
       "default": false
     },
+    "JARVIS_TOOL_FILTER_THRESHOLD": {
+      "type": "number",
+      "description": "AI工具筛选阈值：当可用工具数量超过此值时触发AI筛选",
+      "default": 30
+    },
     "JARVIS_CONFIRM_BEFORE_APPLY_PATCH": {
       "type": "boolean",
       "description": "应用补丁前是否需要确认",
       "default": false
     },
+    "JARVIS_PATCH_FORMAT": {
+      "type": "string",
+      "enum": ["all", "search", "search_range"],
+      "description": "补丁格式处理模式：all 同时支持 SEARCH 与 SEARCH_START/SEARCH_END；search 仅允许精确片段匹配；search_range 仅允许范围匹配。",
+      "default": "all"
+    },
     "JARVIS_DATA_PATH": {
       "type": "string",
       "description": "Jarvis数据存储目录路径",
@@ -195,7 +207,7 @@
     "JARVIS_PRETTY_OUTPUT": {
       "type": "boolean",
       "description": "是否启用美化输出",
-      "default": false
+      "default": true
     },
     "JARVIS_USE_METHODOLOGY": {
       "type": "boolean",
@@ -270,6 +282,11 @@
       "description": "是否打印提示",
       "default": false
     },
+    "JARVIS_PRINT_ERROR_TRACEBACK": {
+      "type": "boolean",
+      "description": "是否在错误输出时打印回溯调用链",
+      "default": false
+    },
     "JARVIS_ENABLE_STATIC_ANALYSIS": {
       "type": "boolean",
       "description": "是否启用静态代码分析",
@@ -278,7 +295,7 @@
     "JARVIS_FORCE_SAVE_MEMORY": {
       "type": "boolean",
       "description": "是否强制保存记忆",
-      "default": true
+      "default": false
     },
     "JARVIS_ENABLE_GIT_JCA_SWITCH": {
       "type": "boolean",
@@ -341,7 +358,23 @@
     "JARVIS_RAG_GROUPS": {
       "type": "array",
       "description": "预定义的RAG配置组",
-      "default": [],
+      "default": [
+        {
+          "text": {
+            "embedding_model": "BAAI/bge-m3",
+            "rerank_model": "BAAI/bge-reranker-v2-m3",
+            "use_bm25": true,
+            "use_rerank": true
+          }
+        },
+        {
+          "code": {
+            "embedding_model": "Qodo/Qodo-Embed-1-1.5B",
+            "use_bm25": false,
+            "use_rerank": false
+          }
+        }
+      ],
       "items": {
         "type": "object",
         "additionalProperties": {
@@ -421,7 +454,8 @@
         "required": [
           "template"
         ]
-      }
+      },
+      "default": {}
     },
     "OPENAI_API_KEY": {
       "type": "string",

jarvis/jarvis_tools/edit_file.py

@@ -27,15 +27,24 @@ class FileSearchReplaceTool:
 
 ## 基本使用
 1. 指定需要修改的文件路径（单个或多个）
-2. 提供一组或多组修改，每个修改包含:
-   - reason: 修改原因描述
-   - SEARCH: 需要查找的原始代码(必须包含足够上下文)
-   - REPLACE: 替换后的新代码
+2. 提供一组或多组修改，每个修改支持两种格式:
+   - 单点替换：
+     - reason: 修改原因描述
+     - SEARCH: 需要查找的原始代码(必须包含足够上下文)
+     - REPLACE: 替换后的新代码
+   - 区间替换：
+     - reason: 修改原因描述
+     - SEARCH_START: 起始标记（包含在替换范围内）
+     - SEARCH_END: 结束标记（包含在替换范围内）
+     - REPLACE: 替换后的新代码
+     - RANGE: 可选的行号范围 'start-end' (1-based, 闭区间), 用于限定匹配范围
 
 ## 核心原则
 1. **精准修改**: 只修改必要的代码部分，保持其他部分不变
 2. **最小补丁原则**: 生成最小范围的补丁，包含必要的上下文
-3. **唯一匹配**: 确保搜索文本在文件中唯一匹配
+3. **唯一匹配**:
+   - 单点替换：确保 SEARCH 在文件中唯一匹配
+   - 区间替换：确保 SEARCH_START 在文件中唯一匹配，且在其后 SEARCH_END 也唯一匹配
 4. **格式保持**: 严格保持原始代码的格式风格
 5. **部分成功**: 支持多个文件编辑，允许部分文件编辑成功
 
@@ -62,12 +71,24 @@ class FileSearchReplaceTool:
                                     },
                                     "SEARCH": {
                                         "type": "string",
-                                        "description": "需要查找的原始代码",
+                                        "description": "需要查找的原始代码（单点替换模式）",
+                                    },
+                                    "SEARCH_START": {
+                                        "type": "string",
+                                        "description": "区间替换的起始标记（包含在替换范围内）",
+                                    },
+                                    "SEARCH_END": {
+                                        "type": "string",
+                                        "description": "区间替换的结束标记（包含在替换范围内）",
                                     },
                                     "REPLACE": {
                                         "type": "string",
                                         "description": "替换后的新代码",
                                     },
+                                    "RANGE": {
+                                        "type": "string",
+                                        "description": "行号范围 'start-end'（1-based，闭区间），可选，仅用于区间替换模式，用于限定匹配与替换的行号范围",
+                                    },
                                 },
                             },
                         },
@@ -93,10 +114,18 @@ class FileSearchReplaceTool:
             args: 包含以下键的字典:
                 - files: 文件列表，每个文件包含(必填):
                     - path: 要修改的文件路径
-                    - changes: 修改列表，每个修改包含:
-                        - reason: 修改原因描述
-                        - SEARCH: 需要查找的原始代码(必须包含足够上下文)
-                        - REPLACE: 替换后的新代码
+                    - changes: 修改列表，每个修改支持两种格式:
+                        1) 单点替换：
+                            - reason: 修改原因描述
+                            - SEARCH: 需要查找的原始代码(必须包含足够上下文)
+                            - REPLACE: 替换后的新代码
+                        2) 区间替换：
+                            - reason: 修改原因描述
+                            - SEARCH_START: 起始标记（包含在替换范围内）
+                            - SEARCH_END: 结束标记（包含在替换范围内）
+                            - REPLACE: 替换后的新代码
+                        通用可选项：
+                            - RANGE: 形如 'start-end'（1-based，闭区间），仅用于区间替换模式。当提供时仅在该行号范围内执行匹配与替换；省略则在整个文件范围内处理
 
         返回:
             Dict[str, Any] 包含:

jarvis/jarvis_tools/read_code.py

@@ -62,10 +62,9 @@ class ReadCodeTool:
                 }
 
             # 读取文件内容
+            # 第一遍流式读取，仅统计总行数，避免一次性读入内存
             with open(abs_path, "r", encoding="utf-8", errors="ignore") as f:
-                lines = f.readlines()
-
-            total_lines = len(lines)
+                total_lines = sum(1 for _ in f)
 
             # 处理空文件情况
             if total_lines == 0:
@@ -99,14 +98,16 @@ class ReadCodeTool:
                     "stderr": f"无效的行范围 [{start_line}-{end_line}] (总行数: {total_lines})",
                 }
 
-            # 添加行号并构建输出内容
-            selected_lines = lines[start_line - 1 : end_line]
-            numbered_content = "".join(
-                [
-                    f"{i:4d}:{line}"
-                    for i, line in enumerate(selected_lines, start=start_line)
-                ]
-            )
+            # 添加行号并构建输出内容（第二遍流式读取，仅提取范围行）
+            selected_items = []
+            with open(abs_path, "r", encoding="utf-8", errors="ignore") as f:
+                for i, line in enumerate(f, start=1):
+                    if i < start_line:
+                        continue
+                    if i > end_line:
+                        break
+                    selected_items.append((i, line))
+            numbered_content = "".join(f"{i:4d}:{line}" for i, line in selected_items)
 
             # 构建输出格式
             output = (

jarvis/jarvis_tools/registry.py

@@ -51,6 +51,7 @@ arguments:
 - 完全按照上述格式
 - 使用正确的YAML格式，2个空格作为缩进
 - 包含所有必需参数
+- {ot("TOOL_CALL")} 和 {ct("TOOL_CALL")} 必须出现在行首
 </rule>
 
 <rule>
@@ -101,6 +102,7 @@ arguments:
 - 创建虚构对话
 - 在没有所需信息的情况下继续
 - yaml 格式错误
+- {ot("TOOL_CALL")} 和 {ct("TOOL_CALL")} 没有出现在行首
 </common_errors>
 </tool_system_guide>
 """
@@ -121,7 +123,8 @@ class ToolRegistry(OutputHandlerProtocol):
         return "TOOL_CALL"
 
     def can_handle(self, response: str) -> bool:
-        return ot("TOOL_CALL") in response
+        # 仅当 {ot("TOOL_CALL")} 出现在行首时才认为可以处理
+        return re.search(rf'(?m){re.escape(ot("TOOL_CALL"))}', response) is not None
 
     def prompt(self) -> str:
         """加载工具"""
@@ -608,11 +611,9 @@ class ToolRegistry(OutputHandlerProtocol):
 
     @staticmethod
     def _has_tool_calls_block(content: str) -> bool:
-        """从内容中提取工具调用块"""
-        return (
-            re.search(ot("TOOL_CALL") + r"(.*?)" + ct("TOOL_CALL"), content, re.DOTALL)
-            is not None
-        )
+        """从内容中提取工具调用块（仅匹配行首标签）"""
+        pattern = rf'(?ms){re.escape(ot("TOOL_CALL"))}(.*?)^{re.escape(ct("TOOL_CALL"))}'
+        return re.search(pattern, content) is not None
 
     @staticmethod
     def _extract_tool_calls(
@@ -633,22 +634,22 @@ class ToolRegistry(OutputHandlerProtocol):
             Exception: 如果工具调用缺少必要字段
         """
         # 将内容拆分为行
-        data = re.findall(
-            ot("TOOL_CALL") + r"(.*?)" + ct("TOOL_CALL"), content, re.DOTALL
-        )
+        pattern = rf'(?ms){re.escape(ot("TOOL_CALL"))}(.*?)^{re.escape(ct("TOOL_CALL"))}'
+        data = re.findall(pattern, content)
         auto_completed = False
         if not data:
-            # can_handle 确保 ot("TOOL_CALL") 在内容中。
-            # 如果数据为空，则表示 ct("TOOL_CALL") 可能丢失。
-            if ot("TOOL_CALL") in content and ct("TOOL_CALL") not in content:
-                # 尝试通过附加结束标签来修复它
+            # can_handle 确保 ot("TOOL_CALL") 在内容中（行首）。
+            # 如果数据为空，则表示行首的 ct("TOOL_CALL") 可能丢失。
+            has_open_at_bol = re.search(rf'(?m){re.escape(ot("TOOL_CALL"))}', content) is not None
+            has_close_at_bol = re.search(rf'(?m)^{re.escape(ct("TOOL_CALL"))}', content) is not None
+            if has_open_at_bol and not has_close_at_bol:
+                # 尝试通过附加结束标签来修复它（确保结束标签位于行首）
                 fixed_content = content.strip() + f"\n{ct('TOOL_CALL')}"
 
                 # 再次提取，并检查YAML是否有效
                 temp_data = re.findall(
-                    ot("TOOL_CALL") + r"(.*?)" + ct("TOOL_CALL"),
+                    pattern,
                     fixed_content,
-                    re.DOTALL,
                 )
 
                 if temp_data:

jarvis/jarvis_utils/config.py

@@ -248,6 +248,23 @@ def is_confirm_before_apply_patch() -> bool:
     return GLOBAL_CONFIG_DATA.get("JARVIS_CONFIRM_BEFORE_APPLY_PATCH", False)
 
 
+def get_patch_format() -> str:
+    """
+    获取补丁格式。
+
+    - "search": 仅使用精确匹配的 `SEARCH` 模式。此模式对能力较弱的模型更稳定，因为它要求代码片段完全匹配。
+    - "search_range": 仅使用 `SEARCH_START` 和 `SEARCH_END` 的范围匹配模式。此模式对能力较强的模型更灵活，因为它允许在代码块内部进行修改，而不要求整个块完全匹配。
+    - "all": 同时支持以上两种模式（默认）。
+
+    返回:
+        str: "all", "search", or "search_range"
+    """
+    mode = GLOBAL_CONFIG_DATA.get("JARVIS_PATCH_FORMAT", "all")
+    if mode in ["all", "search", "search_range"]:
+        return mode
+    return "all"
+
+
 def get_data_dir() -> str:
     """
     获取Jarvis数据存储目录路径。

jarvis/jarvis_utils/embedding.py

@@ -21,6 +21,9 @@ def get_context_token_count(text: str) -> int:
     返回：
         int: 文本中的token数量
     """
+    # 防御性检查：入参为 None 或空字符串时直接返回 0
+    if text is None or text == "":
+        return 0
     try:
         import tiktoken
 

jarvis/jarvis_utils/git_utils.py

@@ -34,7 +34,13 @@ def find_git_root_and_cd(start_dir: str = ".") -> str:
     """
     os.chdir(start_dir)
     try:
-        git_root = os.popen("git rev-parse --show-toplevel").read().strip()
+        result = subprocess.run(
+            ["git", "rev-parse", "--show-toplevel"],
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        git_root = result.stdout.strip()
         if not git_root:
             subprocess.run(["git", "init"], check=True)
             git_root = os.path.abspath(".")
@@ -291,7 +297,13 @@ def get_modified_line_ranges() -> Dict[str, List[Tuple[int, int]]]:
         行号从1开始。
     """
     # 获取所有文件的Git差异
-    diff_output = os.popen("git show").read()
+    # 仅用于解析修改行范围，减少上下文以降低输出体积和解析成本
+    result = subprocess.run(
+        ["git", "show", "-U0", "--no-color"],
+        capture_output=True,
+        text=True,
+    )
+    diff_output = result.stdout
 
     # 解析差异以获取修改的文件及其行范围
     result: Dict[str, List[Tuple[int, int]]] = {}

jarvis/jarvis_utils/utils.py

@@ -679,7 +679,7 @@ def _show_usage_stats(welcome_str: str) -> None:
 
             # 愿景 Panel
             vision_text = Text(
-                "重新定义开发者体验，打破人与工具的界限，构建开发者与AI之间真正的共生伙伴关系。",
+                "让开发者与AI成为共生伙伴",
                 justify="center",
                 style="italic",
             )
@@ -694,7 +694,7 @@ def _show_usage_stats(welcome_str: str) -> None:
 
             # 使命 Panel
             mission_text = Text(
-                "通过深度人机协作，将开发者的灵感（Vibe）高效落地为代码与行动，释放创造之力。",
+                "让灵感高效落地为代码与行动",
                 justify="center",
                 style="italic",
             )
@@ -1142,11 +1142,17 @@ def _collect_optional_config_interactively(
     )
 
     # 新增的配置项交互（通用体验相关）
+    # 根据平台统一默认值：Windows下为False，其它平台为True（与config.get_pretty_output一致）
+    try:
+        import platform as _platform_mod
+        _default_pretty = False if _platform_mod.system() == "Windows" else True
+    except Exception:
+        _default_pretty = True
     changed = (
         _ask_and_set(
             "JARVIS_PRETTY_OUTPUT",
             "是否启用更美观的终端输出（Pretty Output）？",
-            False,
+            _default_pretty,
             "bool",
         )
         or changed
@@ -1200,7 +1206,7 @@ def _collect_optional_config_interactively(
         _ask_and_set(
             "JARVIS_FORCE_SAVE_MEMORY",
             "是否强制保存会话记忆？",
-            True,
+            False,
             "bool",
         )
         or changed
@@ -1330,6 +1336,38 @@ def _collect_optional_config_interactively(
 
 
 
+            new_mode = get_choice(
+                tip,
+                choices,
+            )
+
+            if new_mode == current_mode:
+                return False
+
+            config_data[_key] = new_mode
+            return True
+        except Exception:
+            return False
+
+    def _ask_patch_format_mode() -> bool:
+        try:
+            _key = "JARVIS_PATCH_FORMAT"
+            if not ask_all and _key in config_data:
+                return False
+
+            from jarvis.jarvis_utils.input import get_choice
+            from jarvis.jarvis_utils.config import get_patch_format
+
+            current_mode = config_data.get(_key, get_patch_format())
+            choices = ["all", "search", "search_range"]
+            tip = (
+                "请选择补丁格式处理模式 (JARVIS_PATCH_FORMAT):\n"
+                "该设置影响 edit_file_handler 在处理补丁时允许的匹配方式。\n"
+                "  - all: 同时支持 SEARCH 与 SEARCH_START/SEARCH_END 两种模式（默认）。\n"
+                "  - search: 仅允许精确片段匹配（SEARCH）。更稳定，适合较弱模型或严格控制改动。\n"
+                "  - search_range: 仅允许范围匹配（SEARCH_START/SEARCH_END）。更灵活，适合较强模型和块内细粒度修改。"
+            )
+
             new_mode = get_choice(
                 tip,
                 choices,
@@ -1344,6 +1382,7 @@ def _collect_optional_config_interactively(
             return False
 
     changed = _ask_git_check_mode() or changed
+    changed = _ask_patch_format_mode() or changed
 
     # Git 提交提示词（可选）
     changed = (
@@ -1730,9 +1769,22 @@ def get_file_md5(filepath: str) -> str:
         filepath: 要计算哈希的文件路径
 
     返回:
-        str: 文件内容的MD5哈希值
+        str: 文件内容的MD5哈希值（为降低内存占用，仅读取前100MB进行计算）
     """
-    return hashlib.md5(open(filepath, "rb").read(100 * 1024 * 1024)).hexdigest()
+    # 采用流式读取，避免一次性加载100MB到内存
+    h = hashlib.md5()
+    max_bytes = 100 * 1024 * 1024  # 与原实现保持一致：仅读取前100MB
+    buf_size = 8 * 1024 * 1024     # 8MB缓冲
+    read_bytes = 0
+    with open(filepath, "rb") as f:
+        while read_bytes < max_bytes:
+            to_read = min(buf_size, max_bytes - read_bytes)
+            chunk = f.read(to_read)
+            if not chunk:
+                break
+            h.update(chunk)
+            read_bytes += len(chunk)
+    return h.hexdigest()
 
 
 def get_file_line_count(filename: str) -> int:
@@ -1745,7 +1797,9 @@ def get_file_line_count(filename: str) -> int:
         int: 文件中的行数，如果文件无法读取则返回0
     """
     try:
-        return len(open(filename, "r", encoding="utf-8", errors="ignore").readlines())
+        # 使用流式逐行计数，避免将整个文件读入内存
+        with open(filename, "r", encoding="utf-8", errors="ignore") as f:
+            return sum(1 for _ in f)
     except Exception:
         return 0
 

{jarvis_ai_assistant-0.3.30.dist-info → jarvis_ai_assistant-0.3.31.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jarvis-ai-assistant
-Version: 0.3.30
+Version: 0.3.31
 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.3.30.dist-info → jarvis_ai_assistant-0.3.31.dist-info}/RECORD

@@ -1,10 +1,10 @@
-jarvis/__init__.py,sha256=UpbmB-TeVTIG-j9qC27w2Pdl9nDtcZc6sO3wyLbGRJ8,74
-jarvis/jarvis_agent/__init__.py,sha256=BmIyS7P47Z9Ora2YfywMhvp1G2CYyU2WAzuOM1YgnuU,47962
+jarvis/__init__.py,sha256=ty3_Sg4Xh7MccnSdYA1axmu51agflxzcbgAXl0e21-s,74
+jarvis/jarvis_agent/__init__.py,sha256=Mp0lcivL99cL2eIjHz-D1C86XMOhJkFYtnQcJoflfH4,49033
 jarvis/jarvis_agent/agent_manager.py,sha256=qNcMy5Xc5ZT26JfczBg4b4D5udKVHSFsCFjlpbIdmPo,3076
 jarvis/jarvis_agent/builtin_input_handler.py,sha256=wS-FqpT3pIXwHn1dfL3SpXonUKWgVThbQueUIeyRc2U,2917
 jarvis/jarvis_agent/config.py,sha256=Ni1aTVzmdERJ89A1jsC21Tsys_9MM-TTx1w5XwxyEwA,3130
 jarvis/jarvis_agent/config_editor.py,sha256=hlb9EYxKWcR_qdW2O89CgNDdciR9Isi743JU_1gD8j4,1927
-jarvis/jarvis_agent/edit_file_handler.py,sha256=5sFz84jqy2gpc0aLOre2bvz8_DitlBoWZs_cQwftWLw,11570
+jarvis/jarvis_agent/edit_file_handler.py,sha256=liPsL133PvgiTywesqVulfJdhaw6PIq4HXVCFstjFJg,23786
 jarvis/jarvis_agent/event_bus.py,sha256=pRdfk7d0OG18K6yNfWlCvAh_dW5p9sBtT2Yc3jGmzgo,1519
 jarvis/jarvis_agent/events.py,sha256=rmFQ37PasImCh7OCdCzNBvubk-kHwcUiYLgzmL0t0_4,3689
 jarvis/jarvis_agent/file_methodology_manager.py,sha256=LnhgTx5xQXCBK8esjCkFbgFm9iEyFX7TryUlC40Kzpw,4428
@@ -28,7 +28,7 @@ jarvis/jarvis_agent/tool_share_manager.py,sha256=Do08FRxis0ynwR2a6iRoa6Yq0qCP8Nk
 jarvis/jarvis_agent/user_interaction.py,sha256=tifFN49GkO_Q80sqOTVmhxwbNWTazF3K0cr8AnnvzdU,1453
 jarvis/jarvis_agent/utils.py,sha256=ldgfuNTNu4JU7Y1LtystBl85OC6H3A4OMycg0XBt_Cs,1615
 jarvis/jarvis_code_agent/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-jarvis/jarvis_code_agent/code_agent.py,sha256=0DjuaKSCz3vnS82EsjU9XB2Dc4si7Ryhbne9kL7IS14,32367
+jarvis/jarvis_code_agent/code_agent.py,sha256=nCe0GP6mIzAjJBn2aFqVrDRSjMHnenkDrSoaM0VY87U,36576
 jarvis/jarvis_code_agent/lint.py,sha256=_qLJB_bC3PuoHG-j4EGOnYzNGO26jHlKLbkysfyQW1c,3954
 jarvis/jarvis_code_analysis/code_review.py,sha256=Z0JsvyVPPHPm6rfo4fqaQr7CdZKIllo9jqStzV0i_-o,34470
 jarvis/jarvis_code_analysis/checklists/__init__.py,sha256=LIXAYa1sW3l7foP6kohLWnE98I_EQ0T7z5bYKHq6rJA,78
@@ -51,7 +51,7 @@ jarvis/jarvis_code_analysis/checklists/shell.py,sha256=aRFYhQQvTgbYd-uY5pc8UHIUA
 jarvis/jarvis_code_analysis/checklists/sql.py,sha256=vR0T6qC7b4dURjJVAd7kSVxyvZEQXPG1Jqc2sNTGp5c,2355
 jarvis/jarvis_code_analysis/checklists/swift.py,sha256=TPx4I6Gupvs6tSerRKmTSKEPQpOLEbH2Y7LXg1uBgxc,2566
 jarvis/jarvis_code_analysis/checklists/web.py,sha256=25gGD7pDadZQybNFvALYxWvK0VRjGQb1NVJQElwjyk0,3943
-jarvis/jarvis_data/config_schema.json,sha256=GIzimcbNNedR3Fy_WwVdWAOgi-ODVerpWX83kYHF0NM,13068
+jarvis/jarvis_data/config_schema.json,sha256=q5kXr067yPYcebEWyhqFBmfX1KgyjTAr_hCku__zSZ4,14166
 jarvis/jarvis_data/tiktoken/9b5ad71b2ce5302211f9c61530b329a4922fc6a4,sha256=Ijkht27pm96ZW3_3OFE-7xAPtR0YyTWXoRO8_-hlsqc,1681126
 jarvis/jarvis_git_squash/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 jarvis/jarvis_git_squash/main.py,sha256=BRbsEQVXwseVFKliVqV8_JPh1om6QT6dLTHw0jQ7OE0,2474
@@ -97,14 +97,14 @@ jarvis/jarvis_tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSu
 jarvis/jarvis_tools/ask_user.py,sha256=M6DdLNryCE8y1JcdZHEifUgZkPUEPNKc-zDW5p0Mb1k,2029
 jarvis/jarvis_tools/base.py,sha256=tFZkRlbV_a-pbjM-ci9AYmXVJm__FXuzVWKbQEyz4Ao,1639
 jarvis/jarvis_tools/clear_memory.py,sha256=8DOq6dHLemfKTJqu227PWBIp8Iu5K7EXwINzL8DYk8M,8205
-jarvis/jarvis_tools/edit_file.py,sha256=a6iyeH2MroejGCoaNDkXwGbSfqFikKbh6tG6Woljvi8,7105
+jarvis/jarvis_tools/edit_file.py,sha256=HYUk31ehf2pKB7nY3nm_ahcqUv9bigaHSUc-f5e_0LQ,9129
 jarvis/jarvis_tools/execute_script.py,sha256=oDOMn8GcV6qKP4d0RFT6xbHGTazRmaOlp-h_e_Wj80c,6227
 jarvis/jarvis_tools/file_analyzer.py,sha256=jzVb8fAJn3dWwpCiYH-Wuxva4kpHqBB2_V3x3mzY0Gs,4158
 jarvis/jarvis_tools/generate_new_tool.py,sha256=tJz0YtfDwyH9y00VEWw3Btqr9JCNhvtI8BN9i5hYk_M,8560
 jarvis/jarvis_tools/methodology.py,sha256=_K4GIDUodGEma3SvNRo7Qs5rliijgNespVLyAPN35JU,5233
-jarvis/jarvis_tools/read_code.py,sha256=qeQZ_emyPI5RTFx4HSgLBtWSwh8V5chqMjxu2uKzmfY,6100
+jarvis/jarvis_tools/read_code.py,sha256=F1RuO0c69t0h7CvrUGqrTyNcOCcUrFQPACc61O_YSso,6382
 jarvis/jarvis_tools/read_webpage.py,sha256=YTmoalY8y-jdQuoj9IL6ZjXPOevUj2P_9arJngPhbUY,5317
-jarvis/jarvis_tools/registry.py,sha256=iUzHEia3ufWqfLqlBRJl5KwKCU_0EvqEEiO136NHvRs,32846
+jarvis/jarvis_tools/registry.py,sha256=yVXBrJ7plyn7Dr3dD6mPmgd6eiBftmd19Cc84-PwVN8,33312
 jarvis/jarvis_tools/retrieve_memory.py,sha256=hhhGSr7jebPHICY9oEKICyI8mfqsRtKjh58qZNZApKc,8624
 jarvis/jarvis_tools/rewrite_file.py,sha256=CuvjWPTbUaPbex9FKSmw_Ru4r6R-CX_3vqTqCTp8nHA,6959
 jarvis/jarvis_tools/save_memory.py,sha256=RQtNxcpU53FFv_EBjH0i0oyQ7jWubm-trD1BHuqaGjI,6985
@@ -117,21 +117,21 @@ jarvis/jarvis_tools/cli/main.py,sha256=WL2GNV7WqYl7G1-btRGvCkzDCMk4fPfNvzCrnUFVP
 jarvis/jarvis_utils/__init__.py,sha256=67h0ldisGlh3oK4DAeNEL2Bl_VsI3tSmfclasyVlueM,850
 jarvis/jarvis_utils/builtin_replace_map.py,sha256=z8iAqsbZUiGFaozxG1xSu128op8udqHOeEw-GxNt4bU,1708
 jarvis/jarvis_utils/clipboard.py,sha256=D3wzQeqg_yiH7Axs4d6MRxyNa9XxdnenH-ND2uj2WVQ,2967
-jarvis/jarvis_utils/config.py,sha256=YpIwuRxLhChe0XYoh7nVK0peEILo1NCBvAnxzouHRag,20407
-jarvis/jarvis_utils/embedding.py,sha256=oEOEM2qf16DMYwPsQe6srET9BknyjOdY2ef0jsp3Or8,2714
+jarvis/jarvis_utils/config.py,sha256=AbDfL6hBpD6G_cRlr_bOAXECsj_vIq9tHXgkbsBIv5E,21119
+jarvis/jarvis_utils/embedding.py,sha256=x6mrkL7Bc3qgfuBDsjc4fg4nKG8ofGxVLVVydbsb8PY,2838
 jarvis/jarvis_utils/file_processors.py,sha256=XiM248SHS7lLgQDCbORVFWqinbVDUawYxWDOsLXDxP8,3043
 jarvis/jarvis_utils/fzf.py,sha256=vCs0Uh5dUqGbWzXn2JCtLLCOYE2B39ZNdNveR9PK4DA,1681
-jarvis/jarvis_utils/git_utils.py,sha256=vclHYC2LzyyyHQCMaYENGUwfr7NoajpG8aJ_qr3LgJo,23731
+jarvis/jarvis_utils/git_utils.py,sha256=Wz0oTOsqdQ0JWl69pj02PTI0jrdC6VOizd1uw0QXw_U,24078
 jarvis/jarvis_utils/globals.py,sha256=7Xvf9HY6jYJL4vSD1F1WCoxHkHCAyltJUYt4V9gGVU4,8865
 jarvis/jarvis_utils/http.py,sha256=eRhV3-GYuWmQ0ogq9di9WMlQkFcVb1zGCrySnOgT1x0,4392
 jarvis/jarvis_utils/input.py,sha256=EBdjPopkxVpG4JsnP9gtTSJ10u_scagujyKyOMhatLQ,36524
 jarvis/jarvis_utils/methodology.py,sha256=z_renvRGgHiC-XTQPuN6rvrJ_ffHlwxK_b1BU_jmNAQ,12800
 jarvis/jarvis_utils/output.py,sha256=y2fVcao_2ZowFl0IxUrJZCi8T6ZM0z-iPzpk8T8eLxc,13623
 jarvis/jarvis_utils/tag.py,sha256=f211opbbbTcSyzCDwuIK_oCnKhXPNK-RknYyGzY1yD0,431
-jarvis/jarvis_utils/utils.py,sha256=U3B_uz0-iZa4412krx37AsB6PXBJAvVyxOSlsLjPbRM,70590
-jarvis_ai_assistant-0.3.30.dist-info/licenses/LICENSE,sha256=AGgVgQmTqFvaztRtCAXsAMryUymB18gZif7_l2e1XOg,1063
-jarvis_ai_assistant-0.3.30.dist-info/METADATA,sha256=VnXgGix74c52WCbc-y1dLDDxayj4RK2zCZBVokpw4PQ,18752
-jarvis_ai_assistant-0.3.30.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-jarvis_ai_assistant-0.3.30.dist-info/entry_points.txt,sha256=4GcWKFxRJD-QU14gw_3ZaW4KuEVxOcZK9i270rwPdjA,1395
-jarvis_ai_assistant-0.3.30.dist-info/top_level.txt,sha256=1BOxyWfzOP_ZXj8rVTDnNCJ92bBGB0rwq8N1PCpoMIs,7
-jarvis_ai_assistant-0.3.30.dist-info/RECORD,,
+jarvis/jarvis_utils/utils.py,sha256=1rfnpFXeCp-6dL9_4eNOXnFvxZduTCoMWBdfDx7AMrE,72718
+jarvis_ai_assistant-0.3.31.dist-info/licenses/LICENSE,sha256=AGgVgQmTqFvaztRtCAXsAMryUymB18gZif7_l2e1XOg,1063
+jarvis_ai_assistant-0.3.31.dist-info/METADATA,sha256=JdHbYQDNFNAhhuk5lxOvFXNRvVRDx8y7nA6_pzMSVbM,18752
+jarvis_ai_assistant-0.3.31.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+jarvis_ai_assistant-0.3.31.dist-info/entry_points.txt,sha256=4GcWKFxRJD-QU14gw_3ZaW4KuEVxOcZK9i270rwPdjA,1395
+jarvis_ai_assistant-0.3.31.dist-info/top_level.txt,sha256=1BOxyWfzOP_ZXj8rVTDnNCJ92bBGB0rwq8N1PCpoMIs,7
+jarvis_ai_assistant-0.3.31.dist-info/RECORD,,