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

jarvis/{jarvis_code_agent → jarvis_agent}/patch.py

@@ -12,7 +12,7 @@ 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 get_file_line_count, user_confirm
+from jarvis.jarvis_utils.utils import ct, ot, get_file_line_count, user_confirm
 
 class PatchOutputHandler(OutputHandler):
     def name(self) -> str:
@@ -26,31 +26,35 @@ class PatchOutputHandler(OutputHandler):
         return False
     
     def prompt(self) -> str:
-        return """
+        return f"""
 # 代码补丁规范
 
+## 重要提示
+我可以看到完整的代码，所以不需要生成完整的代码，只需要提供修改的代码片段即可。请尽量精简补丁内容，只包含必要的上下文和修改部分。
+
 ## 补丁格式定义
-使用<PATCH>块来精确指定代码更改：
+使用{ot("PATCH")}块来精确指定代码更改：
 ```
-<PATCH>
+{ot("PATCH")}
 File: [文件路径]
 Reason: [修改原因]
 [上下文代码片段]
-</PATCH>
+{ct("PATCH")}
 ```
 
 ## 核心原则
 1. **上下文完整性**：代码片段必须包含足够的上下文（修改前后各3行）
 2. **精准修改**：只显示需要修改的代码部分，不需要展示整个文件内容
-3. **格式严格保持**：
+3. **最小补丁原则**：始终生成最小范围的补丁，只包含必要的上下文和实际修改
+4. **格式严格保持**：
    - 严格保持原始代码的缩进方式（空格或制表符）
    - 保持原始代码的空行数量和位置
    - 保持原始代码的行尾空格处理方式
    - 不改变原始代码的换行风格
-4. **新旧区分**：
+5. **新旧区分**：
    - 对于新文件：提供完整的代码内容
-   - 对于现有文件：保留周围未更改的代码，突出显示变更部分
-5. **理由说明**：每个补丁必须包含清晰的修改理由，解释为什么需要此更改
+   - 对于现有文件：只提供修改部分及必要上下文，不要提供整个文件
+6. **理由说明**：每个补丁必须包含清晰的修改理由，解释为什么需要此更改
 
 ## 格式兼容性要求
 1. **缩进一致性**：
@@ -65,7 +69,7 @@ Reason: [修改原因]
 
 ## 补丁示例
 ```
-<PATCH>
+{ot("PATCH")}
 File: src/utils/math.py
 Reason: 修复除零错误，增加参数验证以提高函数健壮性
 def safe_divide(a, b):
@@ -76,7 +80,7 @@ def safe_divide(a, b):
 # 现有代码 ...
 def add(a, b):
     return a + b
-</PATCH>
+{ct("PATCH")}
 ```
 
 ## 最佳实践
@@ -85,12 +89,13 @@ def add(a, b):
 - 确保修改理由清晰明确，便于理解变更目的
 - 保持代码风格一致性，遵循项目现有的编码规范
 - 在修改前仔细分析原代码的格式风格，确保补丁与之完全兼容
+- 绝不提供完整文件内容，除非是新建文件
 """
 
 def _parse_patch(patch_str: str) -> Dict[str, str]:
     """解析新的上下文补丁格式"""
     result = {}
-    patches = re.findall(r'<PATCH>\n?(.*?)\n?</PATCH>', patch_str, re.DOTALL)
+    patches = re.findall(ot("PATCH")+r'\n?(.*?)\n?'+ct("PATCH"), patch_str, re.DOTALL)
     if patches:
         for patch in patches:
             first_line = patch.splitlines()[0]
@@ -99,7 +104,10 @@ def _parse_patch(patch_str: str) -> Dict[str, str]:
                 PrettyOutput.print("无效的补丁格式", OutputType.WARNING)
                 continue
             filepath = sm.group(1).strip()
-            result[filepath] = patch
+            if filepath not in result:
+                result[filepath] = patch
+            else:
+                result[filepath] += "\n\n" + patch
     return result
 
 def apply_patch(output_str: str) -> str:
@@ -127,11 +135,7 @@ def apply_patch(output_str: str) -> str:
                     open(filepath, 'w', encoding='utf-8').close()
                     spinner.write("✅ 文件创建完成")
                 with spinner.hidden():
-                    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:
@@ -156,26 +160,41 @@ def apply_patch(output_str: str) -> str:
                 # 添加提交信息到final_ret
                 if commits:
                     final_ret += "✅ 补丁已应用\n"
-                    final_ret += "提交信息:\n"
+                    final_ret += "# 提交信息:\n"
                     for commit_hash, commit_message in commits:
                         final_ret += f"- {commit_hash[:7]}: {commit_message}\n"
                     
-                    final_ret += f"应用补丁:\n{diff}"
+                    final_ret += f"# 应用补丁:\n```diff\n{diff}\n```"
+                    
+                    # 增加代码变更分析和错误提示
+                    final_ret += "\n\n# 代码变更分析：\n"
+                    final_ret += "1. 请仔细检查以上变更是否引入了潜在错误\n"
+                    final_ret += "2. 如果发现代码错误，请立即提出修复方案\n"
+                    final_ret += "3. 修复代码错误的优先级高于继续实现功能\n"
+                    final_ret += "4. 常见错误类型：语法错误、逻辑错误、命名错误、路径错误等\n"
+                    final_ret += "5. 确保修改后代码的一致性和完整性\n"
+                    final_ret += "\n\n"
+                    final_ret += "如果没有问题，请继续进行下一步修改，如果所有修改都已经完成，请终止"
                     
                 else:
                     final_ret += "✅ 补丁已应用（没有新的提交）"
             else:
-                final_ret += "❌ 我拒绝应用此补丁\n"
-                final_ret += "补丁预览:\n"
-                final_ret += diff
+                final_ret += "❌ 补丁应用被拒绝\n"
+                final_ret += f"# 补丁预览:\n```diff\n{diff}\n```"
         else:
             final_ret += "❌ 没有要提交的更改\n"
         # 用户确认最终结果
-        PrettyOutput.print(final_ret, OutputType.USER)
         with spinner.hidden():
+            PrettyOutput.print(final_ret, OutputType.USER, lang="markdown")
             if not is_confirm_before_apply_patch() or user_confirm("是否使用此回复？", default=True):
                 return final_ret
-            return get_multiline_input("请输入自定义回复")
+            custom_reply = get_multiline_input("请输入自定义回复")
+            if not custom_reply.strip():  # 如果自定义回复为空，返回空字符串
+                return ""
+            if not commited:
+                return final_ret + "\n\n" + custom_reply
+            else:
+                return custom_reply
 
 def revert_file(filepath: str):
     """增强版git恢复，处理新文件"""
@@ -212,7 +231,7 @@ def get_diff() -> str:
             check=True
         )
         ret = result.stdout
-        subprocess.run(['git', "reset", "--soft", "HEAD"], check=True)
+        subprocess.run(['git', "reset", "--mixed", "HEAD"], check=True)
         return ret
     except subprocess.CalledProcessError as e:
         return f"获取差异失败: {str(e)}"
@@ -233,10 +252,15 @@ def handle_commit_workflow()->bool:
 
 def handle_code_operation(filepath: str, patch_content: str) -> bool:
     """处理代码操作"""
-    if get_file_line_count(filepath) < 30:
+    if get_file_line_count(filepath) < 100:
         return handle_small_code_operation(filepath, patch_content)
     else:
-        return handle_large_code_operation(filepath, patch_content)
+        retry_count = 5
+        while retry_count > 0:
+            retry_count -= 1
+            if handle_large_code_operation(filepath, patch_content):
+                return True
+        return handle_small_code_operation(filepath, patch_content)
 
 
 def handle_small_code_operation(filepath: str, patch_content: str) -> bool:
@@ -273,16 +297,16 @@ def handle_small_code_operation(filepath: str, patch_content: str) -> bool:
 4. **上下文保留**：保持未修改部分的代码完全不变
 
 ## 输出格式规范
-- 仅在<MERGED_CODE>标签内输出合并后的完整代码
+- 仅在{ot("MERGED_CODE")}标签内输出合并后的完整代码
 - 每次最多输出300行代码
 - 不要使用markdown代码块（```）或反引号，除非修改的是markdown文件
 - 除了合并后的代码，不要输出任何其他文本
-- 所有代码输出完成后，输出<!!!FINISHED!!!>标记
+- 所有代码输出完成后，输出{ot("!!!FINISHED!!!")}标记
 
 ## 输出模板
-<MERGED_CODE>
+{ot("MERGED_CODE")}
 [合并后的完整代码，包括所有空行和缩进]
-</MERGED_CODE>
+{ct("MERGED_CODE")}
 """
             model = PlatformRegistry().get_codegen_platform()
             model.set_suppress_output(True)
@@ -295,9 +319,9 @@ def handle_small_code_operation(filepath: str, patch_content: str) -> bool:
                 count -= 1
                 response = model.chat_until_success(prompt).splitlines()
                 try:
-                    start_line = response.index("<MERGED_CODE>") + 1
+                    start_line = response.index(ot("MERGED_CODE")) + 1
                     try:
-                        end_line = response.index("</MERGED_CODE>")
+                        end_line = response.index(ct("MERGED_CODE"))
                         code = response[start_line:end_line]
                     except:
                         pass
@@ -305,7 +329,7 @@ def handle_small_code_operation(filepath: str, patch_content: str) -> bool:
                     pass
 
                 try: 
-                    response.index("<!!!FINISHED!!!>")
+                    response.index(ot("!!!FINISHED!!!"))
                     finished = True
                     break
                 except:
@@ -317,10 +341,10 @@ def handle_small_code_operation(filepath: str, patch_content: str) -> bool:
 
 ## 要求
 - 严格保留原始代码的格式、空行和缩进
-- 仅在<MERGED_CODE>块中包含实际代码内容
+- 仅在{ot("MERGED_CODE")}块中包含实际代码内容
 - 不要使用markdown代码块（```）或反引号
 - 除了合并后的代码，不要输出任何其他文本
-- 所有代码输出完成后，输出<!!!FINISHED!!!>标记
+- 所有代码输出完成后，输出{ot("!!!FINISHED!!!")}标记
 """
                     pass
             if not finished:
@@ -329,7 +353,7 @@ def handle_small_code_operation(filepath: str, patch_content: str) -> bool:
                 return False
             # 写入合并后的代码
             spinner.text = "写入合并后的代码..."
-            with open(filepath, 'w', encoding='utf-8') as f:
+            with open(filepath, 'w', encoding='utf-8', errors="ignore") as f:
                 f.write("\n".join(code)+"\n")
             spinner.write("✅ 合并后的代码写入完成")
             spinner.text = "代码修改完成"
@@ -353,7 +377,7 @@ def handle_large_code_operation(filepath: str, patch_content: str) -> bool:
                 return False
             
             model = PlatformRegistry().get_codegen_platform()
-            model.set_suppress_output(False)
+            model.set_suppress_output(True)
             
             prompt = f"""
 # 代码补丁生成专家指南
@@ -382,40 +406,39 @@ def handle_large_code_operation(filepath: str, patch_content: str) -> bool:
 4. **上下文完整性**：提供足够的上下文，确保补丁能准确应用
 
 ## 输出格式规范
-- 使用<DIFF>块包围每个需要修改的代码段
-- 每个<DIFF>块必须包含SEARCH部分和REPLACE部分
+- 使用{ot("DIFF")}块包围每个需要修改的代码段
+- 每个{ot("DIFF")}块必须包含SEARCH部分和REPLACE部分
 - SEARCH部分是需要查找的原始代码
 - REPLACE部分是替换后的新代码
 - 确保SEARCH部分能在原文件中唯一匹配
-- 如果修改较大，可以使用多个<DIFF>块
+- 如果修改较大，可以使用多个{ot("DIFF")}块
 
 ## 输出模板
-<DIFF>
+{ot("DIFF")}
 >>>>>> SEARCH
 [需要查找的原始代码，包含足够上下文]
 ======
 [替换后的新代码]
 <<<<<< REPLACE
-</DIFF>
+{ct("DIFF")}
 
-<DIFF>
+{ot("DIFF")}
 >>>>>> SEARCH
 [另一处需要查找的原始代码]
 ======
 [另一处替换后的新代码]
 <<<<<< REPLACE
-</DIFF>
+{ct("DIFF")}
 """
             # 获取补丁内容
-            with spinner.hidden():
-                response = model.chat_until_success(prompt)
+            response = model.chat_until_success(prompt)
             
             # 解析差异化补丁
-            diff_blocks = re.finditer(r'<DIFF>\s*>{4,} SEARCH\n?(.*?)\n?={4,}\n?(.*?)\s*<{4,} REPLACE\n?</DIFF>', 
+            diff_blocks = re.finditer(ot("DIFF")+r'\s*>{4,} SEARCH\n?(.*?)\n?={4,}\n?(.*?)\s*<{4,} REPLACE\n?'+ct("DIFF"), 
                                      response, re.DOTALL)
             
             # 读取原始文件内容
-            with open(filepath, 'r', encoding='utf-8') as f:
+            with open(filepath, 'r', encoding='utf-8', errors="ignore") as f:
                 file_content = f.read()
             
             # 应用所有差异化补丁
@@ -425,25 +448,24 @@ def handle_large_code_operation(filepath: str, patch_content: str) -> bool:
             for match in diff_blocks:
                 search_text = match.group(1).strip()
                 replace_text = match.group(2).strip()
-                
+                patch_count += 1
                 # 检查搜索文本是否存在于文件中
                 if search_text in modified_content:
                     # 如果有多处，报错
                     if modified_content.count(search_text) > 1:
-                        spinner.text = f"补丁 #{patch_count+1} 应用失败：找到多个匹配的代码段"
+                        spinner.text = f"补丁 #{patch_count} 应用失败：找到多个匹配的代码段"
                         spinner.fail("❌")
                         return False
                     # 应用替换
                     modified_content = modified_content.replace(search_text, replace_text)
-                    patch_count += 1
-                    spinner.write(f"✅ 补丁 #{patch_count+1} 应用成功")
+                    spinner.write(f"✅ 补丁 #{patch_count} 应用成功")
                 else:
-                    spinner.text = f"补丁 #{patch_count+1} 应用失败：无法找到匹配的代码段"
+                    spinner.text = f"补丁 #{patch_count} 应用失败：无法找到匹配的代码段"
                     spinner.fail("❌")
                     return False
             
             # 写入修改后的内容
-            with open(filepath, 'w', encoding='utf-8') as f:
+            with open(filepath, 'w', encoding='utf-8', errors="ignore") as f:
                 f.write(modified_content)
             
             spinner.text = f"文件 {filepath} 修改完成，应用了 {patch_count} 个补丁"

jarvis/{jarvis_code_agent → jarvis_agent}/shell_input_handler.py

@@ -2,8 +2,6 @@
 
 from typing import Any, Tuple
 
-from jarvis.jarvis_tools.execute_shell_script import ShellScriptTool
-from jarvis.jarvis_tools.registry import ToolRegistry
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 from jarvis.jarvis_utils.utils import user_confirm
 
@@ -17,6 +15,7 @@ def shell_input_handler(user_input: str, agent: Any) -> Tuple[str, bool]:
         script = '\n'.join([c[1:] for c in cmdline])
         PrettyOutput.print(script, OutputType.CODE, lang="bash")
         if user_confirm(f"是否要执行以上shell脚本？", default=True):
+            from jarvis.jarvis_tools.registry import ToolRegistry
             output = ToolRegistry().handle_tool_calls({
                 "name": "execute_shell_script",
                 "arguments": {

jarvis/jarvis_code_agent/code_agent.py

@@ -1,17 +1,14 @@
-import re
 import subprocess
 import os
-from typing import Any, Tuple
 
 from yaspin import yaspin
 
 from jarvis.jarvis_agent import Agent
-from jarvis.jarvis_code_agent.builtin_input_handler import builtin_input_handler
-from jarvis.jarvis_code_agent.file_input_handler import file_input_handler
-from jarvis.jarvis_code_agent.shell_input_handler import shell_input_handler
-from jarvis.jarvis_code_agent.patch import PatchOutputHandler
+from jarvis.jarvis_agent.builtin_input_handler import builtin_input_handler
+from jarvis.jarvis_agent.file_input_handler import file_input_handler
+from jarvis.jarvis_agent.shell_input_handler import shell_input_handler
+from jarvis.jarvis_agent.patch import PatchOutputHandler
 from jarvis.jarvis_platform.registry import PlatformRegistry
-from jarvis.jarvis_tools.file_operation import FileOperationTool
 from jarvis.jarvis_tools.git_commiter import GitCommitTool
 
 from jarvis.jarvis_tools.registry import ToolRegistry
@@ -31,102 +28,112 @@ class CodeAgent:
         tool_registry.use_tools(["execute_shell", 
                                  "execute_shell_script",
                                  "search_web", 
-                                 "create_code_agent",
                                  "ask_user",  
                                  "ask_codebase",
-                                 "lsp_get_document_symbols", 
                                  "lsp_get_diagnostics", 
                                  "lsp_find_references", 
-                                 "lsp_find_definition", 
-                                 "lsp_prepare_rename"
+                                 "lsp_find_definition",
+                                 "code_review",  # 代码审查工具
+                                 "find_symbol",  # 添加符号查找工具
+                                 "find_caller",  # 添加函数调用者查找工具
+                                 "function_analyzer",  # 添加函数分析工具
+                                 "project_analyzer",  # 添加项目分析工具
+                                 "file_analyzer"  # 添加单文件分析工具
                                  ])
         code_system_prompt = """
 # 专业代码工程师
 
-## 身份与能力范围
-- **角色定位**：精通精确、安全代码修改的高级代码工程师
-- **核心能力**：代码分析、精准重构和系统化验证
-- **知识领域**：软件架构、设计模式和特定语言的最佳实践
-- **局限性**：复杂系统和特定领域知识需要明确的上下文支持
-
-## 交互原则与策略
-- **沟通风格**：清晰简洁的技术解释，为所有决策提供合理依据
-- **呈现格式**：使用补丁格式展示结构化的代码变更及其上下文
-- **主动引导**：在有益的情况下，提出超出即时需求的改进建议
-- **特殊场景应对**：
-  - 对于模糊请求：在继续前提出澄清问题
-  - 对于高风险变更：提出带有验证步骤的渐进式方法
-  - 对于性能问题：平衡即时修复与长期架构考量
-
-## 任务执行规范
+## 身份与职责
+- **角色**：精通代码修改的高级工程师
+- **能力**：代码分析、精准重构和系统化验证
+- **知识**：软件架构、设计模式和编程最佳实践
+
+## 工作原则
+- **准备工作**：在修改任何代码之前，必须已经阅读并充分理解相关代码
+- **分析范围判断**：首先评估当前文件内容是否足够完成修改，避免不必要的项目分析
+- **沟通**：清晰简洁的技术解释，提供决策依据
+- **代码修改**：结构化展示变更及其上下文
+- **问题处理**：遇到模糊请求时提出澄清问题，高风险变更时提出渐进式方法
+- **修改效率**：对于变更不超过50行的代码，应一次性完成修改，避免分段处理
+
+## 任务执行流程
 ### 分析阶段
-- 使用lsp_get_document_symbols映射代码结构
-- 通过lsp_find_references和lsp_find_definition追踪依赖关系
-- 在进行更改前识别潜在影响区域
-- 为安全创建回滚计划
+- **范围确定**：首先判断是否仅需当前文件内容即可完成任务，避免不必要的分析
+- 评估任务复杂度，只在必要时进行全面分析
+- 简单修改可直接进行，无需复杂分析
+- 使用代码分析工具理解依赖关系
+- 识别潜在影响区域
+- 确保在开始修改前，已经完全阅读和理解相关代码文件
 
 ### 实施阶段
-- 进行原子化、聚焦的最小范围更改
+- 进行最小范围更改，保持代码完整性
+- 对于不超过50行的代码变更，应一次性完成修改
+- 大型文件分段修改，确保每段修改后代码功能完整
 - 保持一致的代码风格和格式
-- 每次重大更改后运行lsp_get_diagnostics
-- 立即修复任何检测到的问题
+- 修改后立即验证，优先修复错误
 
 ### 验证阶段
-- 使用lsp_get_diagnostics进行全面诊断
-- 用lsp_prepare_rename验证所有重命名元素
+- 确认已充分理解所修改代码及其上下文
+- 使用诊断工具检查问题
 - 检查相关代码中的意外副作用
-- 确保必要的向后兼容性
+- 确保兼容性和功能正确性
+- 验证修改是否符合原始设计意图和代码结构
 
 ### 文档阶段
-- 为每项修改提供清晰的理由
-- 在所有补丁描述中包含上下文
-- 记录任何假设或约束条件
+- 提供清晰的修改理由和上下文
+- 记录假设和约束条件
 - 准备详细的提交信息
 
-## 代码修改协议
-1. **修改前要求**：
-   - 完整的代码分析报告
-   - 影响评估
-   - 验证策略
-
-2. **修改实施**：
-   - 单一职责变更
-   - 严格的范围验证
-   - 接口兼容性检查
-
-3. **验证清单**：
-   - 运行lsp_get_diagnostics确保零错误
-   - 使用lsp_find_references确认影响范围
-   - 用lsp_prepare_rename验证重命名安全性
+## 工具使用指南
+- **范围决策**：
+  - 先阅读当前文件，判断是否包含足够信息完成任务
+  - 只有在确认需要更多上下文时才扩展分析范围
+  - 明确告知用户当前文件是否足够，避免不必要分析
 
-4. **修改后流程**：
-   - 代码审查模拟
-   - 版本控制审计
-   - 更新变更文档
+- **代码阅读与理解**：
+  - 在使用任何分析工具前，应首先完整阅读相关代码
+  - 使用分析工具补充而非替代直接阅读和理解代码
+  - 如有必要，可以使用`ask_codebase`工具来帮助理解复杂部分
 
-## 工具使用指南
 - **分析工具**：
-  - lsp_get_document_symbols：用于映射代码结构
-  - lsp_find_references：用于理解使用模式
-  - lsp_find_definition：用于追踪实现细节
+  - lsp_find_references：理解使用模式
+  - lsp_find_definition：追踪实现细节
+  - find_symbol：查找代码符号位置
+  - find_caller：查找函数调用位置
+  - function_analyzer：分析函数实现
+  - project_analyzer：分析项目架构（仅复杂任务使用）
+  - file_analyzer：分析单文件结构
 
 - **验证工具**：
-  - lsp_prepare_rename：用于安全重构检查
-  - lsp_get_diagnostics：用于修改后检查
+  - lsp_get_diagnostics：检查修改问题
+  - code_review：代码审查
 
 - **系统工具**：
-  - execute_shell：用于git操作和grep搜索
-  - ask_codebase：用于查询代码知识库
-  - search_web：用于技术参考查找
-
-## 补丁格式要求
-创建代码补丁时：
-1. 包含足够的上下文（更改前后各3行）
-2. 保留原始缩进和格式
-3. 为新文件提供完整代码
-4. 对于修改，保留周围未更改的代码
-5. 为每项更改包含清晰的理由说明
+  - execute_shell：执行系统命令
+  - search_web：查找技术参考
+  - ask_codebase：补充分析（优先使用直接分析工具）
+
+## 代码分析策略
+- **阅读优先**：在提出任何修改前，必须先阅读和理解相关代码
+- **避免过度分析**：只分析与任务直接相关的代码
+- **单文件优先**：优先考虑当前文件是否含有足够信息完成任务
+  - 当任务仅涉及语法、文本修改、逻辑优化等当前文件内部变更时，无需分析项目
+  - 当当前文件包含完整的模块/类/功能实现，且修改不影响外部接口时，无需额外分析
+  - 当用户明确指示仅修改当前文件时，无需扩大分析范围
+- **任务分级**：
+  - 简单任务：先阅读相关代码，然后直接执行，尽量减少不必要的分析
+  - 中等任务：全面阅读相关文件并分析直接依赖，确保理解上下文
+  - 复杂任务：彻底阅读并进行全面项目分析，确保理解代码交互方式
+- **长文件处理**：
+  - 完整阅读后再分段理解和修改
+  - 先处理核心部分，再扩展到相关代码
+  - 优先修改相对独立的部分
+- **修改规模策略**：
+  - 对于不超过50行的代码变更，应尽量一次性完成
+  - 将相关逻辑变更放在同一个修改中，保持功能完整性
+  - 无需为小规模修改（≤50行）拆分多次提交，除非跨多个不相关模块
 """
+        # Dynamically add ask_codebase based on task complexity if really needed
         self.agent = Agent(system_prompt=code_system_prompt, 
                            name="CodeAgent", 
                            auto_complete=False,
@@ -187,7 +194,7 @@ class CodeAgent:
             if commits and user_confirm("是否接受以上提交记录？", True):
                 if len(commits) > 1 and user_confirm("是否要合并为一个更清晰的提交记录？", True):
                     # Reset to start commit
-                    subprocess.run(["git", "reset", "--soft", start_commit], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+                    subprocess.run(["git", "reset", "--mixed", start_commit], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
                     # Create new commit
                     git_commiter = GitCommitTool()
                     git_commiter.execute({})
@@ -210,17 +217,15 @@ def main():
     PrettyOutput.print(f"当前目录: {git_dir}", OutputType.INFO)
 
     try:
-        # Interactive mode
-        while True:
-            try:
-                user_input = get_multiline_input("请输入你的需求（输入空行退出）:")
-                if not user_input:
-                    break
-                agent = CodeAgent()
-                agent.run(user_input)
-                
-            except Exception as e:
-                PrettyOutput.print(f"错误: {str(e)}", OutputType.ERROR)
+        try:
+            user_input = get_multiline_input("请输入你的需求（输入空行退出）:")
+            if not user_input:
+                return 0
+            agent = CodeAgent()
+            agent.run(user_input)
+            
+        except Exception as e:
+            PrettyOutput.print(f"错误: {str(e)}", OutputType.ERROR)
 
     except Exception as e:
         PrettyOutput.print(f"初始化错误: {str(e)}", OutputType.ERROR)