jarvis-ai-assistant 0.1.220__py3-none-any.whl → 0.1.222__py3-none-any.whl

jarvis/jarvis_agent/edit_file_handler.py

@@ -3,12 +3,8 @@ import re
 from typing import Any, Dict, List, Tuple
 
 from jarvis.jarvis_agent.output_handler import OutputHandler
-from jarvis.jarvis_platform.registry import PlatformRegistry
-from jarvis.jarvis_utils.git_utils import revert_file
-from jarvis.jarvis_utils.globals import get_interrupt, set_interrupt
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 from jarvis.jarvis_utils.tag import ct, ot
-from jarvis.jarvis_utils.utils import is_context_overflow
 
 
 class EditFileHandler(OutputHandler):
@@ -69,13 +65,7 @@ class EditFileHandler(OutputHandler):
             ]
 
             print(f"📝 正在处理文件 {file_path}...")
-            # 首先尝试fast_edit模式
             success, result = self._fast_edit(file_path, file_patches)
-            if not success:
-                # 如果fast_edit失败，尝试slow_edit模式
-                success, result = EditFileHandler._slow_edit(
-                    file_path, file_patches, agent
-                )
 
             if success:
                 results.append(f"✅ 文件 {file_path} 修改成功")
@@ -173,7 +163,7 @@ class EditFileHandler(OutputHandler):
         1. 直接进行字符串替换，效率高
         2. 会自动处理缩进问题，尝试匹配不同缩进级别的代码
         3. 确保搜索文本在文件中唯一匹配
-        4. 如果失败会自动回滚修改
+        4. 如果部分补丁失败，会继续应用剩余补丁，并报告失败信息
 
         Args:
             file_path: 要修改的文件路径，支持绝对路径和相对路径
@@ -181,8 +171,8 @@ class EditFileHandler(OutputHandler):
 
         Returns:
             Tuple[bool, str]:
-                返回处理结果元组，第一个元素表示是否成功(True/False)，
-                第二个元素为结果信息，成功时为修改后的文件内容，失败时为错误信息
+                返回处理结果元组，第一个元素表示是否所有补丁都成功应用，
+                第二个元素为结果信息，全部成功时为修改后的文件内容，部分或全部失败时为错误信息
         """
         try:
             # 确保目录存在
@@ -197,13 +187,17 @@ class EditFileHandler(OutputHandler):
             # 应用所有补丁
             modified_content = file_content
             patch_count = 0
+            failed_patches: List[Dict[str, Any]] = []
+            successful_patches = 0
+
             for patch in patches:
+                patch_count += 1
                 search_text = patch["SEARCH"]
                 replace_text = patch["REPLACE"]
-                patch_count += 1
 
                 # 精确匹配搜索文本（保留原始换行和空格）
                 exact_search = search_text
+                found = False
 
                 if exact_search in modified_content:
                     # 直接执行替换（保留所有原始格式）
@@ -211,8 +205,8 @@ class EditFileHandler(OutputHandler):
                         exact_search, replace_text
                     )
                     print(f"✅ 补丁 #{patch_count} 应用成功")
+                    found = True
                 else:
-                    found = False
                     # 如果匹配不到，并且search与replace块的首尾都是换行，尝试去掉第一个和最后一个换行
                     if (
                         search_text.startswith("\n")
@@ -261,184 +255,37 @@ class EditFileHandler(OutputHandler):
                                 found = True
                                 break
 
-                    if not found:
-                        PrettyOutput.print(
-                            f"搜索文本在文件中不存在：\n{search_text}",
-                            output_type=OutputType.WARNING,
-                        )
-                        return False, f"搜索文本在文件中不存在：\n{search_text}"
+                if found:
+                    successful_patches += 1
+                else:
+                    error_msg = "搜索文本在文件中不存在"
+                    PrettyOutput.print(
+                        f"{error_msg}：\n{search_text}",
+                        output_type=OutputType.WARNING,
+                    )
+                    failed_patches.append({"patch": patch, "error": error_msg})
 
             # 写入修改后的内容
             with open(file_path, "w", encoding="utf-8") as f:
                 f.write(modified_content)
 
-            print(f"✅ 文件 {file_path} 修改完成，应用了 {patch_count} 个补丁")
-            return True, modified_content
-
-        except Exception as e:
-            print(f"❌ 文件修改失败: {str(e)}")
-            revert_file(file_path)
-            return False, f"文件修改失败: {str(e)}"
-
-    @staticmethod
-    def _slow_edit(
-        file_path: str, patches: List[Dict[str, str]], agent: Any
-    ) -> Tuple[bool, str]:
-        """使用AI模型生成补丁并应用到文件
-
-        当_fast_edit方法失败时调用此方法，使用AI模型生成更精确的补丁。
-        特点：
-        1. 适用于复杂修改场景或需要上下文理解的修改
-        2. 会自动处理大文件上传问题
-        3. 会尝试最多3次生成有效的补丁
-        4. 生成的补丁会再次通过_fast_edit方法应用
-        5. 如果失败会自动回滚修改
-
-        Args:
-            file_path: 要修改的文件路径，支持绝对路径和相对路径
-            patches: 补丁列表，每个补丁包含search(搜索文本)和replace(替换文本)
-            agent: 执行处理的agent实例，用于访问AI模型平台
-
-        Returns:
-            Tuple[bool, str]:
-                返回处理结果元组，第一个元素表示是否成功(True/False)，
-                第二个元素为结果信息，成功时为修改后的文件内容，失败时为错误信息
-        """
-        try:
-            model = PlatformRegistry().get_normal_platform()
-
-            # 读取原始文件内容
-            file_content = ""
-            if os.path.exists(file_path):
-                with open(file_path, "r", encoding="utf-8") as f:
-                    file_content = f.read()
-
-            is_large_context = is_context_overflow(file_content)
-            upload_success = False
-
-            # 如果是大文件，尝试上传到模型平台
-            if (
-                is_large_context
-                and model.support_upload_files()
-                and model.upload_files([file_path])
-            ):
-                upload_success = True
-
-            model.set_suppress_output(False)
-
-            # 构建补丁内容
-            patch_content = []
-            for patch in patches:
-                patch_content.append(
-                    {
-                        "SEARCH": patch["SEARCH"],
-                        "REPLACE": patch["REPLACE"],
-                    }
+            if failed_patches:
+                error_details = [
+                    f"  - 失败的补丁: \n{p['patch']['SEARCH']}\n    错误: {p['error']}"
+                    for p in failed_patches
+                ]
+                summary = (
+                    f"文件 {file_path} 修改部分成功。\n"
+                    f"成功: {successful_patches}/{patch_count}, "
+                    f"失败: {len(failed_patches)}/{patch_count}.\n"
+                    f"失败详情:\n" + "\n".join(error_details)
                 )
+                print(f"❌ {summary}")
+                return False, summary
 
-            # 构建提示词
-            main_prompt = f"""
-# 代码补丁生成专家指南
-
-## 任务描述
-你是一位精确的代码补丁生成专家，需要根据补丁描述生成精确的代码差异。
-
-### 补丁内容
-```
-{str(patch_content)}
-```
-
-## 补丁生成要求
-1. **精确性**：严格按照补丁的意图修改代码
-2. **格式一致性**：严格保持原始代码的格式风格，如果补丁中缩进或者空行与原代码不一致，则需要修正补丁中的缩进或者空行
-3. **最小化修改**：只修改必要的代码部分，保持其他部分不变
-4. **上下文完整性**：提供足够的上下文，确保补丁能准确应用
-
-## 输出格式规范
-- 使用{ot("DIFF")}块包围每个需要修改的代码段
-- 每个{ot("DIFF")}块必须包含SEARCH部分和REPLACE部分
-- SEARCH部分是需要查找的原始代码
-- REPLACE部分是替换后的新代码
-- 确保SEARCH部分能在原文件中**唯一匹配**
-- 如果修改较大，可以使用多个{ot("DIFF")}块
-
-## 输出模板
-{ot("DIFF")}
-{ot("SEARCH")}[需要查找的原始代码，包含足够上下文，避免出现可匹配多处的情况]{ct("SEARCH")}
-{ot("REPLACE")}[替换后的新代码]{ct("REPLACE")}
-{ct("DIFF")}
-
-{ot("DIFF")}
-{ot("SEARCH")}[另一处需要查找的原始代码，包含足够上下文，避免出现可匹配多处的情况]{ct("SEARCH")}
-{ot("REPLACE")}[另一处替换后的新代码]{ct("REPLACE")}
-{ct("DIFF")}
-"""
-
-            # 尝试最多3次生成补丁
-            for _ in range(3):
-                if is_large_context:
-                    if upload_success:
-                        response = model.chat_until_success(main_prompt)
-                    else:
-                        file_prompt = f"""
-# 原始代码
-{file_content}
-"""
-                        response = model.chat_until_success(main_prompt + file_prompt)
-                else:
-                    file_prompt = f"""
-# 原始代码
-{file_content}
-"""
-                    response = model.chat_until_success(main_prompt + file_prompt)
-
-                # 检查是否被中断
-                if get_interrupt():
-                    set_interrupt(False)
-                    user_input = agent.multiline_inputer(
-                        "补丁应用被中断，请输入补充信息:"
-                    )
-                    if not user_input.strip():
-                        return False, "用户中断了补丁应用"
-                    return False, f"用户中断了补丁应用并提供了补充信息: {user_input}"
-
-                # 解析生成的补丁
-                diff_blocks = re.finditer(
-                    ot("DIFF")
-                    + r"\s*"
-                    + ot("SEARCH")
-                    + r"(.*?)"
-                    + ct("SEARCH")
-                    + r"\s*"
-                    + ot("REPLACE")
-                    + r"(.*?)"
-                    + ct("REPLACE")
-                    + r"\s*"
-                    + ct("DIFF"),
-                    response,
-                    re.DOTALL,
-                )
-
-                generated_patches = []
-                for match in diff_blocks:
-                    generated_patches.append(
-                        {
-                            "SEARCH": match.group(1).strip(),
-                            "REPLACE": match.group(2).strip(),
-                        }
-                    )
-
-                if generated_patches:
-                    # 尝试应用生成的补丁
-                    success, result = EditFileHandler._fast_edit(
-                        file_path, generated_patches
-                    )
-                    if success:
-                        return True, result
-
-            return False, "AI模型无法生成有效的补丁"
+            print(f"✅ 文件 {file_path} 修改完成，应用了 {patch_count} 个补丁")
+            return True, modified_content
 
         except Exception as e:
             print(f"❌ 文件修改失败: {str(e)}")
-            revert_file(file_path)
             return False, f"文件修改失败: {str(e)}"

jarvis/jarvis_agent/jarvis.py

@@ -109,8 +109,13 @@ def _select_task(tasks: Dict[str, str]) -> str:
 def main() -> None:
 
     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")
+    parser.add_argument(
+        "--llm_type",
+        type=str,
+        default="normal",
+        choices=["normal", "thinking"],
+        help="LLM type to use",
+    )
     parser.add_argument(
         "-t",
         "--task",
@@ -132,8 +137,7 @@ def main() -> None:
     try:
         agent = Agent(
             system_prompt=origin_agent_system_prompt,
-            platform=args.platform,
-            model_name=args.model,
+            llm_type=args.llm_type,
             input_handler=[shell_input_handler, builtin_input_handler],
             output_handler=[ToolRegistry()],
             need_summary=False,
@@ -151,11 +155,12 @@ def main() -> None:
             agent.run(args.task)
             sys.exit(0)
 
-        tasks = _load_tasks()
-        if tasks and (selected_task := _select_task(tasks)):
-            PrettyOutput.print(f"开始执行任务: \n{selected_task}", OutputType.INFO)
-            agent.run(selected_task)
-            sys.exit(0)
+        if agent.first:
+            tasks = _load_tasks()
+            if tasks and (selected_task := _select_task(tasks)):
+                PrettyOutput.print(f"开始执行任务: \n{selected_task}", OutputType.INFO)
+                agent.run(selected_task)
+                sys.exit(0)
 
         user_input = get_multiline_input("请输入你的任务（输入空行退出）:")
         if user_input:

jarvis/jarvis_agent/main.py

@@ -20,9 +20,7 @@ def load_config(config_path: str) -> dict:
         dict: 配置字典
     """
     if not os.path.exists(config_path):
-        PrettyOutput.print(
-            f"配置文件 {config_path} 不存在，使用默认配置", OutputType.WARNING
-        )
+        PrettyOutput.print(f"配置文件 {config_path} 不存在，使用默认配置", OutputType.WARNING)
         return {}
 
     with open(config_path, "r", encoding="utf-8", errors="ignore") as f:
@@ -45,16 +43,25 @@ def main():
         "-c", "--agent_definition", type=str, help="Path to agent definition file"
     )
     parser.add_argument("-t", "--task", type=str, help="Initial task to execute")
+    parser.add_argument(
+        "--llm_type",
+        type=str,
+        default="normal",
+        choices=["normal", "thinking"],
+        help="LLM type to use, overriding config",
+    )
     args = parser.parse_args()
 
     # Initialize environment
-    init_env(
-        "欢迎使用 Jarvis AI 助手，您的智能助理已准备就绪！", config_file=args.config
-    )
+    init_env("欢迎使用 Jarvis AI 助手，您的智能助理已准备就绪！", config_file=args.config)
 
     # Load configuration
     config = load_config(args.agent_definition) if args.agent_definition else {}
 
+    # Override config with command-line arguments if provided
+    if args.llm_type:
+        config["llm_type"] = args.llm_type
+
     # Create and run agent
     try:
         agent = Agent(**config)

jarvis/jarvis_agent/prompt_builder.py

@@ -0,0 +1,57 @@
+# -*- coding: utf-8 -*-
+from typing import List
+
+from jarvis.jarvis_agent.protocols import OutputHandlerProtocol
+
+
+def build_action_prompt(output_handlers: List[OutputHandlerProtocol]) -> str:
+    """
+    Builds the action prompt string from a list of output handlers.
+
+    Args:
+        output_handlers: A list of output handler instances.
+
+    Returns:
+        A formatted string containing the action prompt.
+    """
+    action_prompt = """
+<actions>
+# 🧰 可用操作
+以下是您可以使用的操作：
+"""
+
+    # Add tool list overview
+    action_prompt += "\n<overview>\n## Action List\n"
+    action_prompt += (
+        "[" + ", ".join([handler.name() for handler in output_handlers]) + "]"
+    )
+    action_prompt += "\n</overview>"
+
+    # Add details for each tool
+    action_prompt += "\n\n<details>\n# 📝 Action Details\n"
+    for handler in output_handlers:
+        action_prompt += f"\n<tool>\n## {handler.name()}\n"
+        # Get the handler's prompt and ensure correct formatting
+        handler_prompt = handler.prompt().strip()
+        # Adjust indentation to maintain hierarchy
+        handler_prompt = "\n".join(
+            "   " + line if line.strip() else line
+            for line in handler_prompt.split("\n")
+        )
+        action_prompt += handler_prompt + "\n</tool>\n"
+
+    # Add tool usage summary
+    action_prompt += """
+</details>
+
+<rules>
+# ❗ 重要操作使用规则
+1. 一次对话只能使用一个操作，否则会出错
+2. 严格按照每个操作的格式执行
+3. 等待操作结果后再进行下一个操作
+4. 处理完结果后再调用新的操作
+5. 如果对操作使用不清楚，请请求帮助
+</rules>
+</actions>
+"""
+    return action_prompt

jarvis/jarvis_agent/prompts.py

@@ -0,0 +1,188 @@
+# -*- coding: utf-8 -*-
+from jarvis.jarvis_utils.tag import ct, ot
+
+DEFAULT_SUMMARY_PROMPT = """<report>
+请生成任务执行的简明总结报告，包括：
+
+<content>
+1. 任务目标：任务重述
+2. 执行结果：成功/失败
+3. 关键信息：执行过程中提取的重要信息
+4. 重要发现：任何值得注意的发现
+5. 后续建议：如果有的话
+</content>
+
+<format>
+请使用简洁的要点描述，突出重要信息。
+</format>
+</report>
+"""
+
+SUMMARY_REQUEST_PROMPT = """<summary_request>
+<objective>
+请对当前对话历史进行简明扼要的总结，提取关键信息和重要决策点。这个总结将作为上下文继续任务，因此需要保留对后续对话至关重要的内容。
+</objective>
+
+<guidelines>
+1. 提取关键信息：任务目标、已确定的事实、重要决策、达成的共识
+2. 保留技术细节：命令、代码片段、文件路径、配置设置等技术细节
+3. 记录任务进展：已完成的步骤、当前所处阶段、待解决的问题
+4. 包含用户偏好：用户表达的明确偏好、限制条件或特殊要求
+5. 省略冗余内容：问候语、重复信息、不相关的讨论
+</guidelines>
+
+<format>
+- 使用简洁、客观的语言
+- 按时间顺序或主题组织信息
+- 使用要点列表增强可读性
+- 总结应控制在500词以内
+</format>
+</summary_request>
+"""
+
+
+TASK_ANALYSIS_PROMPT = f"""<task_analysis>
+<request>
+当前任务已结束，请分析该任务的解决方案：
+1. 首先检查现有工具或方法论是否已经可以完成该任务，如果可以，直接说明即可，无需生成新内容
+2. 如果现有工具/方法论不足，评估当前任务是否可以通过编写新工具来自动化解决
+3. 如果可以通过工具解决，请设计并提供工具代码
+4. 如果无法通过编写通用工具完成，评估当前的执行流程是否可以总结为通用方法论
+5. 如果以上都不可行，给出详细理由
+请根据分析结果采取相应行动：说明现有工具/方法论、创建新工具、生成新方法论或说明原因。
+</request>
+<evaluation_criteria>
+现有资源评估:
+1. 现有工具 - 检查系统中是否已有可以完成该任务的工具
+2. 现有方法论 - 检查是否已有适用于该任务的方法论
+3. 组合使用 - 评估现有工具和方法论组合使用是否可以解决问题
+工具评估标准:
+1. 通用性 - 该工具是否可以解决一类问题，而不仅仅是当前特定问题
+2. 自动化 - 该工具是否可以减少人工干预，提高效率
+3. 可靠性 - 该工具是否可以在不同场景下稳定工作
+4. 简单性 - 该工具是否易于使用，参数设计是否合理
+方法论评估标准:
+1. 方法论应聚焦于通用且可重复的解决方案流程
+2. 方法论应该具备足够的通用性，可应用于同类问题
+3. 特别注意用户在执行过程中提供的修正、反馈和改进建议
+4. 如果用户明确指出了某个解决步骤的优化方向，这应该被纳入方法论
+5. 方法论要严格按照实际的执行流程来总结，不要遗漏或增加任何步骤
+</evaluation_criteria>
+<tool_requirements>
+工具代码要求:
+1. 工具类名应与工具名称保持一致
+2. 必须包含name、description、parameters属性
+3. 必须实现execute方法处理输入参数
+4. 可选实现check方法验证环境
+5. 工具描述应详细说明用途、适用场景和使用示例
+6. 参数定义应遵循JSON Schema格式
+7. 不要包含特定任务的细节，保持通用性
+工具设计关键点:
+1. **使用PrettyOutput打印执行过程**：强烈建议在工具中使用PrettyOutput显示执行过程，
+   这样用户可以了解工具在做什么，提升用户体验。示例：
+   ```python
+   from jarvis.jarvis_utils.output import PrettyOutput, OutputType
+   # 执行中打印信息
+   PrettyOutput.print("正在处理数据...", OutputType.INFO)
+   # 成功信息
+   PrettyOutput.print("操作成功完成", OutputType.SUCCESS)
+   # 警告信息
+   PrettyOutput.print("发现潜在问题", OutputType.WARNING)
+   # 错误信息
+   PrettyOutput.print("操作失败", OutputType.ERROR)
+   ```
+2. **结构化返回结果**：工具应该始终返回结构化的结果字典，包含以下字段：
+   - success: 布尔值，表示操作是否成功
+   - stdout: 字符串，包含工具的主要输出内容
+   - stderr: 字符串，包含错误信息（如果有）
+3. **异常处理**：工具应该妥善处理可能发生的异常，并在失败时清理已创建的资源
+   ```python
+   try:
+       # 执行逻辑
+       return {{
+           "success": True,
+           "stdout": "成功结果",
+           "stderr": ""
+       }}
+   except Exception as e:
+       PrettyOutput.print(f"操作失败: {{str(e)}}", OutputType.ERROR)
+       # 清理资源（如果有创建）
+       return {{
+           "success": False,
+           "stdout": "",
+           "stderr": f"操作失败: {{str(e)}}"
+       }}
+   ```
+</tool_requirements>
+<methodology_requirements>
+方法论格式要求:
+1. 问题重述: 简明扼要的问题归纳，不含特定细节
+2. 最优解决方案: 经过用户验证的、最终有效的解决方案（将每个步骤要使用的工具也列举出来）
+3. 注意事项: 执行中可能遇到的常见问题和注意点，尤其是用户指出的问题
+4. 可选步骤: 对于有多种解决路径的问题，标注出可选步骤和适用场景
+</methodology_requirements>
+<output_requirements>
+根据分析结果，输出以下三种情况之一：
+1. 如果现有工具/方法论可以解决，直接输出说明：
+已有工具/方法论可以解决该问题，无需创建新内容。
+可用的工具/方法论：[列出工具名称或方法论名称]
+使用方法：[简要说明如何使用]
+2. 工具创建（如果需要创建新工具）:
+{ot("TOOL_CALL")}
+want: 创建新工具来解决XXX问题
+name: generate_new_tool
+arguments:
+  tool_name: 工具名称
+  tool_code: |2
+    # -*- coding: utf-8 -*-
+    from typing import Dict, Any
+    from jarvis.jarvis_utils.output import PrettyOutput, OutputType
+    class 工具名称:
+        name = "工具名称"
+        description = "Tool for text transformation"
+                Tool description
+        适用场景：1. 格式化文本; 2. 处理标题; 3. 标准化输出
+        \"\"\"
+        parameters = {{
+            "type": "object",
+            "properties": {{
+                # 参数定义
+            }},
+            "required": []
+        }}
+        @staticmethod
+        def check() -> bool:
+            return True
+        def execute(self, args: Dict[str, Any]) -> Dict[str, Any]:
+            try:
+                # 使用PrettyOutput显示执行过程
+                PrettyOutput.print("开始执行操作...", OutputType.INFO)
+                # 实现逻辑
+                # ...
+        PrettyOutput.print("操作已完成", OutputType.SUCCESS)
+        return {{
+            "success": True,
+            "stdout": "结果输出",
+            "stderr": ""
+        }}
+    except Exception as e:
+        PrettyOutput.print(f"操作失败: {{str(e)}}", OutputType.ERROR)
+        return {{
+            "success": False,
+            "stdout": "",
+            "stderr": f"操作失败: {{str(e)}}"
+        }}
+{ct("TOOL_CALL")}
+3. 方法论创建（如果需要创建新方法论）:
+{ot("TOOL_CALL")}
+want: 添加/更新xxxx的方法论
+name: methodology
+arguments:
+  operation: add/update
+  problem_type: 方法论类型，不要过于细节，也不要过于泛化
+  content: |2
+    方法论内容
+{ct("TOOL_CALL")}
+如果以上三种情况都不适用，则直接输出原因分析，不要使用工具调用格式。
+</output_requirements>
+</task_analysis>"""

jarvis/jarvis_agent/protocols.py

@@ -0,0 +1,30 @@
+# -*- coding: utf-8 -*-
+from typing import Any, Protocol, Tuple
+
+
+class OutputHandlerProtocol(Protocol):
+    """
+    Defines the interface for an output handler, which is responsible for
+    processing the model's response, typically to execute a tool.
+    """
+
+    def name(self) -> str:
+        """Returns the name of the handler."""
+        ...
+
+    def can_handle(self, response: str) -> bool:
+        """Determines if this handler can process the given response."""
+        ...
+
+    def prompt(self) -> str:
+        """Returns the prompt snippet that describes the handler's functionality."""
+        ...
+
+    def handle(self, response: str, agent: Any) -> Tuple[bool, Any]:
+        """
+        Handles the response, executing the associated logic.
+
+        Returns:
+            A tuple containing a boolean (whether to return) and the result.
+        """
+        ...