jarvis-ai-assistant 0.1.131__py3-none-any.whl → 0.1.134__py3-none-any.whl

jarvis/jarvis_agent/jarvis.py

@@ -0,0 +1,143 @@
+import argparse
+import os
+
+from prompt_toolkit import prompt
+import yaml
+from yaspin import yaspin
+from jarvis.jarvis_agent import (
+     PrettyOutput, OutputType,
+     get_multiline_input,
+     Agent,  # 显式导入关键组件
+     origin_agent_system_prompt
+)
+from jarvis.jarvis_agent.patch import PatchOutputHandler
+from jarvis.jarvis_tools.registry import ToolRegistry
+from jarvis.jarvis_utils.utils import init_env
+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.builtin_input_handler import builtin_input_handler
+
+
+def _load_tasks() -> dict:
+    """Load tasks from .jarvis files in user home and current directory."""
+    tasks = {}
+
+    # Check .jarvis/pre-command in user directory
+    user_jarvis = os.path.expanduser("~/.jarvis/pre-command")
+    if os.path.exists(user_jarvis):
+        with yaspin(text=f"从{user_jarvis}加载预定义任务...", color="cyan") as spinner:
+            try:
+                with open(user_jarvis, "r", encoding="utf-8", errors="ignore") as f:
+                    user_tasks = yaml.safe_load(f)
+                    
+                if isinstance(user_tasks, dict):
+                    # Validate and add user directory tasks
+                    for name, desc in user_tasks.items():
+                        if desc:  # Ensure description is not empty
+                            tasks[str(name)] = str(desc)
+                spinner.text = "预定义任务加载完成"
+                spinner.ok("✅")
+            except Exception as e:
+                spinner.text = "预定义任务加载失败"
+                spinner.fail("❌")
+        
+    # Check .jarvis/pre-command in current directory
+    if os.path.exists(".jarvis/pre-command"):
+        with yaspin(text=f"从{os.path.abspath('.jarvis/pre-command')}加载预定义任务...", color="cyan") as spinner:
+            try:
+                with open(".jarvis/pre-command", "r", encoding="utf-8", errors="ignore") as f:
+                    local_tasks = yaml.safe_load(f)
+                    
+                if isinstance(local_tasks, dict):
+                    # Validate and add current directory tasks, overwrite user directory tasks if there is a name conflict
+                    for name, desc in local_tasks.items():
+                        if desc:  # Ensure description is not empty
+                            tasks[str(name)] = str(desc)
+                spinner.text = "预定义任务加载完成"
+                spinner.ok("✅")
+            except Exception as e:
+                spinner.text = "预定义任务加载失败"
+                spinner.fail("❌")
+
+    return tasks
+
+def _select_task(tasks: dict) -> str:
+    """Let user select a task from the list or skip. Returns task description if selected."""
+    if not tasks:
+        return ""
+    # Convert tasks to list for ordered display
+    task_names = list(tasks.keys())
+    
+    task_list = ["可用任务:"]
+    for i, name in enumerate(task_names, 1):
+        task_list.append(f"[{i}] {name}")
+    task_list.append("[0] 跳过预定义任务")
+    PrettyOutput.print("\n".join(task_list), OutputType.INFO)
+    
+    
+    while True:
+        try:
+            choice = prompt(
+                "\n请选择一个任务编号（0 跳过预定义任务）：",
+            ).strip()
+            
+            if not choice:
+                return ""
+            
+            choice = int(choice)
+            if choice == 0:
+                return ""
+            elif 1 <= choice <= len(task_names):
+                selected_name = task_names[choice - 1]
+                return tasks[selected_name]  # Return the task description
+            else:
+                PrettyOutput.print("无效的选择。请选择列表中的一个号码。", OutputType.WARNING)
+                
+        except KeyboardInterrupt:
+            return ""  # Return empty on Ctrl+C
+        except EOFError:
+            return ""  # Return empty on Ctrl+D
+        except Exception as e:
+            PrettyOutput.print(f"选择任务失败: {str(e)}", OutputType.ERROR)
+            continue
+
+
+
+
+def main() -> int:
+    """Jarvis main entry point"""
+    init_env()
+    parser = argparse.ArgumentParser(description='Jarvis AI assistant')
+    parser.add_argument('-p', '--platform', type=str, help='Platform to use')
+    parser.add_argument('-m', '--model', type=str, help='Model to use')
+    args = parser.parse_args()
+
+    try:
+        agent = Agent(
+            system_prompt=origin_agent_system_prompt,
+            platform=args.platform,
+            model_name=args.model,
+            input_handler=[file_input_handler, shell_input_handler, builtin_input_handler], # type: ignore
+            output_handler=[ToolRegistry(), PatchOutputHandler()],
+            need_summary=False
+        )
+
+        tasks = _load_tasks()
+        if tasks:
+            selected_task = _select_task(tasks)
+            if selected_task:
+                PrettyOutput.print(f"执行任务: {selected_task}", OutputType.INFO)
+                agent.run(selected_task)
+                return 0
+        
+        user_input = get_multiline_input("请输入你的任务（输入空行退出）:")
+        if user_input:
+            agent.run(user_input)
+        return 0
+
+    except Exception as e:
+        PrettyOutput.print(f"初始化错误: {str(e)}", OutputType.ERROR)
+        return 1
+
+if __name__ == "__main__":
+    exit(main())

jarvis/jarvis_agent/main.py

@@ -7,8 +7,6 @@ from jarvis.jarvis_utils.input import get_multiline_input
 from jarvis.jarvis_utils.output import PrettyOutput, OutputType
 from jarvis.jarvis_utils.utils import init_env
 
-# 从__init__.py导入系统提示
-from jarvis.jarvis_agent import origin_agent_system_prompt
 
 def load_config(config_path: str) -> dict:
     """Load configuration from YAML file

jarvis/jarvis_agent/patch.py

@@ -5,6 +5,7 @@ import os
 from yaspin import yaspin
 
 from jarvis.jarvis_agent.output_handler import OutputHandler
+from jarvis.jarvis_platform.base import BasePlatform
 from jarvis.jarvis_platform.registry import PlatformRegistry
 from jarvis.jarvis_tools.git_commiter import GitCommitTool
 from jarvis.jarvis_tools.file_operation import FileOperationTool
@@ -12,7 +13,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 +27,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 +70,7 @@ Reason: [修改原因]
 
 ## 补丁示例
 ```
-<PATCH>
+{ot("PATCH")}
 File: src/utils/math.py
 Reason: 修复除零错误，增加参数验证以提高函数健壮性
 def safe_divide(a, b):
@@ -76,7 +81,7 @@ def safe_divide(a, b):
 # 现有代码 ...
 def add(a, b):
     return a + b
-</PATCH>
+{ct("PATCH")}
 ```
 
 ## 最佳实践
@@ -85,12 +90,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]
@@ -155,27 +161,46 @@ 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"
+                    final_ret += "   - 所有需要更新的函数\n"
+                    final_ret += "   - 所有需要调整的依赖关系\n"
+                    final_ret += "   - 所有需要同步的文档\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:
+            commited = False
             final_ret += "❌ 没有要提交的更改\n"
         # 用户确认最终结果
         with spinner.hidden():
-            PrettyOutput.print(final_ret, OutputType.USER)
+            if commited:
+                return final_ret
+            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 ""
+            return final_ret + "\n\n" + custom_reply
+            
 def revert_file(filepath: str):
     """增强版git恢复，处理新文件"""
     import subprocess
@@ -235,10 +260,10 @@ def handle_code_operation(filepath: str, patch_content: str) -> bool:
     if get_file_line_count(filepath) < 100:
         return handle_small_code_operation(filepath, patch_content)
     else:
-        retry_count = 3
+        retry_count = 5
         while retry_count > 0:
             retry_count -= 1
-            if handle_large_code_operation(filepath, patch_content):
+            if handle_large_code_operation(filepath, patch_content, PlatformRegistry().get_normal_platform() if retry_count > 2 else PlatformRegistry().get_thinking_platform()):
                 return True
         return handle_small_code_operation(filepath, patch_content)
 
@@ -277,19 +302,19 @@ 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(False)
+            model = PlatformRegistry().get_normal_platform()
+            model.set_suppress_output(True)
             count = 30
             start_line = -1
             end_line = -1
@@ -297,12 +322,11 @@ def handle_small_code_operation(filepath: str, patch_content: str) -> bool:
             finished = False
             while count>0:
                 count -= 1
-                with spinner.hidden():
-                    response = model.chat_until_success(prompt).splitlines()
+                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
@@ -310,7 +334,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:
@@ -322,10 +346,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:
@@ -346,7 +370,7 @@ def handle_small_code_operation(filepath: str, patch_content: str) -> bool:
             return False
 
 
-def handle_large_code_operation(filepath: str, patch_content: str) -> bool:
+def handle_large_code_operation(filepath: str, patch_content: str, model: BasePlatform) -> bool:
     """处理大型代码文件的补丁操作，使用差异化补丁格式"""
     with yaspin(text=f"正在处理文件 {filepath}...", color="cyan") as spinner:
         try:
@@ -357,8 +381,7 @@ def handle_large_code_operation(filepath: str, patch_content: str) -> bool:
                 spinner.fail("❌")
                 return False
             
-            model = PlatformRegistry().get_codegen_platform()
-            model.set_suppress_output(False)
+            model.set_suppress_output(True)
             
             prompt = f"""
 # 代码补丁生成专家指南
@@ -387,36 +410,35 @@ 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)
             
             # 读取原始文件内容

jarvis/jarvis_agent/shell_input_handler.py

@@ -2,7 +2,6 @@
 
 from typing import Any, Tuple
 
-from jarvis.jarvis_tools.registry import ToolRegistry
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 from jarvis.jarvis_utils.utils import user_confirm
 
@@ -16,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": {