jarvis-ai-assistant 0.1.129__py3-none-any.whl → 0.1.130__py3-none-any.whl

jarvis/jarvis_code_agent/code_agent.py

@@ -41,89 +41,91 @@ class CodeAgent:
                                  "lsp_prepare_rename"
                                  ])
         code_system_prompt = """
-# 角色：高级代码工程师
-精通安全、精确的代码修改，具有严格的验证流程。
-
-## 核心原则
-1. 安全第一：绝不破坏现有功能
-2. 精准工程：最小化、针对性修改
-3. 完整可追溯：记录所有决策
-4. 验证驱动：在每个阶段进行验证
-
-## 工具使用协议
-1. 分析工具：
-   - lsp_get_document_symbols：映射代码结构
-   - lsp_find_references：理解使用模式
-   - lsp_find_definition：追踪实现细节
-
-2. 验证工具：
-   - lsp_prepare_rename：安全重构检查
-   - lsp_get_diagnostics：修改后检查
-
-3. 系统工具：
-   - execute_shell：用于git操作和grep搜索
-   - ask_codebase：查询代码知识库
-   - search_web：技术参考查找
-
-## 工作流程（PDCA循环）
-1. 计划：
-   - 使用ask_user分析需求
-   - 使用LSP工具映射现有代码
-   - 使用find_references识别影响区域
-   - 使用git创建回滚计划
-
-2. 执行：
-   - 在受保护的块中进行原子修改
-   - 每次更改后自动运行lsp_get_diagnostics
-   - 如果发现错误，使用lsp_find_references和lsp_find_definition进行即时修复
-   - 每次更改后使用LSP验证语法
-
-3. 检查：
-   - 强制使用lsp_get_diagnostics进行完整诊断报告
-   - 使用lsp_preprepare_rename验证所有重命名
-   - 如果检测到错误，进入修复循环直到所有检查通过
-
-4. 行动：
-   - 使用git提交详细消息
-   - 准备回滚脚本（如果需要）
-   - 进行实施后审查
-
-## 代码修改标准
-1. 修改前要求：
+# 专业代码工程师
+
+## 身份与能力范围
+- **角色定位**：精通精确、安全代码修改的高级代码工程师
+- **核心能力**：代码分析、精准重构和系统化验证
+- **知识领域**：软件架构、设计模式和特定语言的最佳实践
+- **局限性**：复杂系统和特定领域知识需要明确的上下文支持
+
+## 交互原则与策略
+- **沟通风格**：清晰简洁的技术解释，为所有决策提供合理依据
+- **呈现格式**：使用补丁格式展示结构化的代码变更及其上下文
+- **主动引导**：在有益的情况下，提出超出即时需求的改进建议
+- **特殊场景应对**：
+  - 对于模糊请求：在继续前提出澄清问题
+  - 对于高风险变更：提出带有验证步骤的渐进式方法
+  - 对于性能问题：平衡即时修复与长期架构考量
+
+## 任务执行规范
+### 分析阶段
+- 使用lsp_get_document_symbols映射代码结构
+- 通过lsp_find_references和lsp_find_definition追踪依赖关系
+- 在进行更改前识别潜在影响区域
+- 为安全创建回滚计划
+
+### 实施阶段
+- 进行原子化、聚焦的最小范围更改
+- 保持一致的代码风格和格式
+- 每次重大更改后运行lsp_get_diagnostics
+- 立即修复任何检测到的问题
+
+### 验证阶段
+- 使用lsp_get_diagnostics进行全面诊断
+- 用lsp_prepare_rename验证所有重命名元素
+- 检查相关代码中的意外副作用
+- 确保必要的向后兼容性
+
+### 文档阶段
+- 为每项修改提供清晰的理由
+- 在所有补丁描述中包含上下文
+- 记录任何假设或约束条件
+- 准备详细的提交信息
+
+## 代码修改协议
+1. **修改前要求**：
    - 完整的代码分析报告
-   - 影响评估矩阵
-   - 回滚程序文档
+   - 影响评估
+   - 验证策略
 
-2. 修改实施：
-   - 单一职责修改
-   - 严格的代码范围验证（±3行缓冲区）
+2. **修改实施**：
+   - 单一职责变更
+   - 严格的范围验证
    - 接口兼容性检查
 
-3. 验证清单：
-   [ ] 执行lsp_get_diagnostics并确保零错误
-   [ ] 使用lsp_find_references确认影响范围
-   [ ] 使用lsp_prepare_rename验证重命名安全性
+3. **验证清单**：
+   - 运行lsp_get_diagnostics确保零错误
+   - 使用lsp_find_references确认影响范围
+   - 用lsp_prepare_rename验证重命名安全性
 
-4. 修改后：
+4. **修改后流程**：
    - 代码审查模拟
    - 版本控制审计
-   - 更新变更日志
-
-## 关键要求
-1. 强制分析：
-   - 修改前完整符号追踪
-   - 跨文件影响分析
-   - 依赖关系映射
-
-2. 禁止操作：
-   - 未通过lsp_get_diagnostics检查继续操作
-   - 多个功能组合修改
-   - 未经测试的接口修改
-
-3. 紧急协议：
-   - lsp_get_diagnostics出现错误时立即停止并回滚
-   - 出现意外行为时通知用户
-   - 对任何回归进行事后分析
+   - 更新变更文档
+
+## 工具使用指南
+- **分析工具**：
+  - lsp_get_document_symbols：用于映射代码结构
+  - lsp_find_references：用于理解使用模式
+  - lsp_find_definition：用于追踪实现细节
+
+- **验证工具**：
+  - lsp_prepare_rename：用于安全重构检查
+  - lsp_get_diagnostics：用于修改后检查
+
+- **系统工具**：
+  - execute_shell：用于git操作和grep搜索
+  - ask_codebase：用于查询代码知识库
+  - search_web：用于技术参考查找
+
+## 补丁格式要求
+创建代码补丁时：
+1. 包含足够的上下文（更改前后各3行）
+2. 保留原始缩进和格式
+3. 为新文件提供完整代码
+4. 对于修改，保留周围未更改的代码
+5. 为每项更改包含清晰的理由说明
 """
         self.agent = Agent(system_prompt=code_system_prompt, 
                            name="CodeAgent", 
@@ -147,8 +149,7 @@ class CodeAgent:
                 with spinner.hidden():
                     git_commiter = GitCommitTool()
                     git_commiter.execute({})
-            else:
-                spinner.text = "环境初始化完成"
+            spinner.text = "环境初始化完成"
             spinner.ok("✅")
 
     

jarvis/jarvis_code_agent/patch.py

@@ -7,14 +7,12 @@ from yaspin import yaspin
 from jarvis.jarvis_agent.output_handler import OutputHandler
 from jarvis.jarvis_platform.registry import PlatformRegistry
 from jarvis.jarvis_tools.git_commiter import GitCommitTool
-from jarvis.jarvis_tools.execute_shell_script import ShellScriptTool
 from jarvis.jarvis_tools.file_operation import FileOperationTool
-from jarvis.jarvis_tools.read_code import ReadCodeTool
 from jarvis.jarvis_utils.config import is_confirm_before_apply_patch
 from jarvis.jarvis_utils.git_utils import get_commits_between, get_latest_commit_hash
 from jarvis.jarvis_utils.input import get_multiline_input
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
-from jarvis.jarvis_utils.utils import user_confirm
+from jarvis.jarvis_utils.utils import get_file_line_count, user_confirm
 
 class PatchOutputHandler(OutputHandler):
     def name(self) -> str:
@@ -29,25 +27,47 @@ class PatchOutputHandler(OutputHandler):
     
     def prompt(self) -> str:
         return """
-# 🛠️ 上下文代码补丁规范
-使用<PATCH>块来指定代码更改：
---------------------------------
+# 代码补丁规范
+
+## 补丁格式定义
+使用<PATCH>块来精确指定代码更改：
+```
 <PATCH>
 File: [文件路径]
 Reason: [修改原因]
 [上下文代码片段]
 </PATCH>
---------------------------------
-规则：
-1. 代码片段必须包含足够的上下文（前后各3行）
-2. 我可以看到完整代码，所以只需显示修改的代码部分，不需要将整个文件内容都显示出来
-3. 保留原始缩进和格式
-4. 对于新文件，提供完整代码
-5. 修改现有文件时，保留周围未更改的代码
-示例：
+```
+
+## 核心原则
+1. **上下文完整性**：代码片段必须包含足够的上下文（修改前后各3行）
+2. **精准修改**：只显示需要修改的代码部分，不需要展示整个文件内容
+3. **格式严格保持**：
+   - 严格保持原始代码的缩进方式（空格或制表符）
+   - 保持原始代码的空行数量和位置
+   - 保持原始代码的行尾空格处理方式
+   - 不改变原始代码的换行风格
+4. **新旧区分**：
+   - 对于新文件：提供完整的代码内容
+   - 对于现有文件：保留周围未更改的代码，突出显示变更部分
+5. **理由说明**：每个补丁必须包含清晰的修改理由，解释为什么需要此更改
+
+## 格式兼容性要求
+1. **缩进一致性**：
+   - 如果原代码使用4个空格缩进，补丁也必须使用4个空格缩进
+   - 如果原代码使用制表符缩进，补丁也必须使用制表符缩进
+2. **空行保留**：
+   - 如果原代码在函数之间有两个空行，补丁也必须保留这两个空行
+   - 如果原代码在类方法之间有一个空行，补丁也必须保留这一个空行
+3. **行尾处理**：
+   - 如果原代码行尾没有空格，补丁也不应添加行尾空格
+   - 如果原代码使用特定的行尾注释风格，补丁也应保持该风格
+
+## 补丁示例
+```
 <PATCH>
 File: src/utils/math.py
-Reason: 修复除零处理
+Reason: 修复除零错误，增加参数验证以提高函数健壮性
 def safe_divide(a, b):
     # 添加参数验证
     if b == 0:
@@ -57,6 +77,14 @@ def safe_divide(a, b):
 def add(a, b):
     return a + b
 </PATCH>
+```
+
+## 最佳实践
+- 每个补丁专注于单一职责的修改
+- 提供足够的上下文，但避免包含过多无关代码
+- 确保修改理由清晰明确，便于理解变更目的
+- 保持代码风格一致性，遵循项目现有的编码规范
+- 在修改前仔细分析原代码的格式风格，确保补丁与之完全兼容
 """
 
 def _parse_patch(patch_str: str) -> Dict[str, str]:
@@ -92,8 +120,22 @@ def apply_patch(output_str: str) -> str:
         for filepath, patch_content in patches.items():
             try:
                 spinner.text = f"正在处理文件: {filepath}"
+                if not os.path.exists(filepath):
+                    # 新建文件
+                    spinner.text = "文件不存在，正在创建文件..."
+                    os.makedirs(os.path.dirname(filepath), exist_ok=True)
+                    open(filepath, 'w', encoding='utf-8').close()
+                    spinner.write("✅ 文件创建完成")
                 with spinner.hidden():
-                    handle_code_operation(filepath, patch_content)
+                    retry_count = 3
+                    while not handle_code_operation(filepath, patch_content):
+                        retry_count -= 1
+                        if retry_count > 0:
+                            continue
+                        if user_confirm("补丁应用失败，是否重试？", default=True):
+                            pass
+                        else:
+                            raise Exception("补丁应用失败")
                 spinner.write(f"✅ 文件 {filepath} 处理完成")
             except Exception as e:
                 spinner.text = f"文件 {filepath} 处理失败: {str(e)}, 回滚文件"
@@ -123,16 +165,18 @@ def apply_patch(output_str: str) -> str:
                 else:
                     final_ret += "✅ 补丁已应用（没有新的提交）"
             else:
-                final_ret += "❌ 我不想提交代码\n"
+                final_ret += "❌ 我拒绝应用此补丁\n"
                 final_ret += "补丁预览:\n"
                 final_ret += diff
         else:
             final_ret += "❌ 没有要提交的更改\n"
         # 用户确认最终结果
         PrettyOutput.print(final_ret, OutputType.USER)
-        if not is_confirm_before_apply_patch() or user_confirm("是否使用此回复？", default=True):
-            return final_ret
-        return get_multiline_input("请输入自定义回复")
+        with spinner.hidden():
+            if not is_confirm_before_apply_patch() or user_confirm("是否使用此回复？", default=True):
+                return final_ret
+            return get_multiline_input("请输入自定义回复")
+
 def revert_file(filepath: str):
     """增强版git恢复，处理新文件"""
     import subprocess
@@ -172,6 +216,7 @@ def get_diff() -> str:
         return ret
     except subprocess.CalledProcessError as e:
         return f"获取差异失败: {str(e)}"
+
 def handle_commit_workflow()->bool:
     """Handle the git commit workflow and return the commit details.
     
@@ -187,15 +232,17 @@ def handle_commit_workflow()->bool:
 
 
 def handle_code_operation(filepath: str, patch_content: str) -> bool:
+    """处理代码操作"""
+    if get_file_line_count(filepath) < 30:
+        return handle_small_code_operation(filepath, patch_content)
+    else:
+        return handle_large_code_operation(filepath, patch_content)
+
+
+def handle_small_code_operation(filepath: str, patch_content: str) -> bool:
     """处理基于上下文的代码片段"""
     with yaspin(text=f"正在修改文件 {filepath}...", color="cyan") as spinner:
         try:
-            if not os.path.exists(filepath):
-                # 新建文件
-                spinner.text = "文件不存在，正在创建文件..."
-                os.makedirs(os.path.dirname(filepath), exist_ok=True)
-                open(filepath, 'w', encoding='utf-8').close()
-                spinner.write("✅ 文件创建完成")
             with spinner.hidden():
                 old_file_content = FileOperationTool().execute({"operation": "read", "files": [{"path": filepath}]})
                 if not old_file_content["success"]:
@@ -203,27 +250,40 @@ def handle_code_operation(filepath: str, patch_content: str) -> bool:
                     return False
             
             prompt = f"""
-    你是一个代码审查员，请审查以下代码并将其与上下文合并。
-    原始代码:
-    {old_file_content["stdout"]}
-    补丁内容:
-    {patch_content}
-    """
-            prompt += f"""
-    请将代码与上下文合并并返回完整的合并代码，每次最多输出300行代码。
-
-    要求:
-    1. 严格保留原始代码的格式、空行和缩进
-    2. 仅在<MERGED_CODE>块中包含实际代码内容，包括空行和缩进
-    3. 绝对不要使用markdown代码块（```）或反引号，除非修改的是markdown文件
-    4. 除了合并后的代码，不要输出任何其他文本
-    5. 所有代码输出完成后，输出<!!!FINISHED!!!>
-
-    输出格式:
-    <MERGED_CODE>
-    [merged_code]
-    </MERGED_CODE>
-    """
+# 代码合并专家指南
+
+## 任务描述
+你是一位精确的代码审查与合并专家，需要将补丁内容与原始代码智能合并。
+
+## 输入资料
+### 原始代码
+```
+{old_file_content["stdout"]}
+```
+
+### 补丁内容
+```
+{patch_content}
+```
+
+## 合并要求
+1. **精确性**：严格按照补丁的意图修改代码
+2. **完整性**：确保所有需要的更改都被应用
+3. **一致性**：严格保留原始代码的格式、空行和缩进风格
+4. **上下文保留**：保持未修改部分的代码完全不变
+
+## 输出格式规范
+- 仅在<MERGED_CODE>标签内输出合并后的完整代码
+- 每次最多输出300行代码
+- 不要使用markdown代码块（```）或反引号，除非修改的是markdown文件
+- 除了合并后的代码，不要输出任何其他文本
+- 所有代码输出完成后，输出<!!!FINISHED!!!>标记
+
+## 输出模板
+<MERGED_CODE>
+[合并后的完整代码，包括所有空行和缩进]
+</MERGED_CODE>
+"""
             model = PlatformRegistry().get_codegen_platform()
             model.set_suppress_output(True)
             count = 30
@@ -249,14 +309,19 @@ def handle_code_operation(filepath: str, patch_content: str) -> bool:
                     finished = True
                     break
                 except:
-                    prompt += f"""继续输出接下来的300行代码
-                    要求：
-                    1. 严格保留原始代码的格式、空行和缩进
-                    2. 仅在<MERGED_CODE>块中包含实际代码内容，包括空行和缩进
-                    3. 绝对不要使用markdown代码块（```）或反引号，除非修改的是markdown文件
-                    4. 除了合并后的代码，不要输出任何其他文本
-                    5. 所有代码输出完成后，输出<!!!FINISHED!!!>
-                    """
+                    prompt += f"""
+# 继续输出
+
+## 说明
+请继续输出接下来的300行代码
+
+## 要求
+- 严格保留原始代码的格式、空行和缩进
+- 仅在<MERGED_CODE>块中包含实际代码内容
+- 不要使用markdown代码块（```）或反引号
+- 除了合并后的代码，不要输出任何其他文本
+- 所有代码输出完成后，输出<!!!FINISHED!!!>标记
+"""
                     pass
             if not finished:
                 spinner.text = "生成代码失败"
@@ -274,3 +339,119 @@ def handle_code_operation(filepath: str, patch_content: str) -> bool:
             spinner.text = "代码修改失败"
             spinner.fail("❌")
             return False
+
+
+def handle_large_code_operation(filepath: str, patch_content: str) -> bool:
+    """处理大型代码文件的补丁操作，使用差异化补丁格式"""
+    with yaspin(text=f"正在处理文件 {filepath}...", color="cyan") as spinner:
+        try:
+            # 读取原始文件内容
+            old_file_content = FileOperationTool().execute({"operation": "read", "files": [{"path": filepath}]})
+            if not old_file_content["success"]:
+                spinner.text = "文件读取失败"
+                spinner.fail("❌")
+                return False
+            
+            model = PlatformRegistry().get_codegen_platform()
+            model.set_suppress_output(False)
+            
+            prompt = f"""
+# 代码补丁生成专家指南
+
+## 任务描述
+你是一位精确的代码补丁生成专家，需要根据补丁描述生成精确的代码差异。
+
+## 输入资料
+### 原始代码
+```
+{old_file_content["stdout"]}
+```
+
+### 补丁内容
+```
+{patch_content}
+```
+
+## 补丁生成要求
+1. **精确性**：严格按照补丁的意图修改代码
+2. **格式一致性**：严格保持原始代码的格式风格
+   - 缩进方式（空格或制表符）必须与原代码保持一致
+   - 空行数量和位置必须与原代码风格匹配
+   - 行尾空格处理必须与原代码一致
+3. **最小化修改**：只修改必要的代码部分，保持其他部分不变
+4. **上下文完整性**：提供足够的上下文，确保补丁能准确应用
+
+## 输出格式规范
+- 使用<DIFF>块包围每个需要修改的代码段
+- 每个<DIFF>块必须包含SEARCH部分和REPLACE部分
+- SEARCH部分是需要查找的原始代码
+- REPLACE部分是替换后的新代码
+- 确保SEARCH部分能在原文件中唯一匹配
+- 如果修改较大，可以使用多个<DIFF>块
+
+## 输出模板
+<DIFF>
+>>>>>> SEARCH
+[需要查找的原始代码，包含足够上下文]
+======
+[替换后的新代码]
+<<<<<< REPLACE
+</DIFF>
+
+<DIFF>
+>>>>>> SEARCH
+[另一处需要查找的原始代码]
+======
+[另一处替换后的新代码]
+<<<<<< REPLACE
+</DIFF>
+"""
+            # 获取补丁内容
+            with spinner.hidden():
+                response = model.chat_until_success(prompt)
+            
+            # 解析差异化补丁
+            diff_blocks = re.finditer(r'<DIFF>\s*>{4,} SEARCH\n?(.*?)\n?={4,}\n?(.*?)\s*<{4,} REPLACE\n?</DIFF>', 
+                                     response, re.DOTALL)
+            
+            # 读取原始文件内容
+            with open(filepath, 'r', encoding='utf-8') as f:
+                file_content = f.read()
+            
+            # 应用所有差异化补丁
+            modified_content = file_content
+            patch_count = 0
+            
+            for match in diff_blocks:
+                search_text = match.group(1).strip()
+                replace_text = match.group(2).strip()
+                
+                # 检查搜索文本是否存在于文件中
+                if search_text in modified_content:
+                    # 如果有多处，报错
+                    if modified_content.count(search_text) > 1:
+                        spinner.text = f"补丁 #{patch_count+1} 应用失败：找到多个匹配的代码段"
+                        spinner.fail("❌")
+                        return False
+                    # 应用替换
+                    modified_content = modified_content.replace(search_text, replace_text)
+                    patch_count += 1
+                    spinner.write(f"✅ 补丁 #{patch_count+1} 应用成功")
+                else:
+                    spinner.text = f"补丁 #{patch_count+1} 应用失败：无法找到匹配的代码段"
+                    spinner.fail("❌")
+                    return False
+            
+            # 写入修改后的内容
+            with open(filepath, 'w', encoding='utf-8') as f:
+                f.write(modified_content)
+            
+            spinner.text = f"文件 {filepath} 修改完成，应用了 {patch_count} 个补丁"
+            spinner.ok("✅")
+            return True
+            
+        except Exception as e:
+            spinner.text = f"文件修改失败: {str(e)}"
+            spinner.fail("❌")
+            return False
+