jarvis-ai-assistant 0.1.167__tar.gz → 0.1.170__tar.gz

{jarvis_ai_assistant-0.1.167/src/jarvis_ai_assistant.egg-info → jarvis_ai_assistant-0.1.170}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: jarvis-ai-assistant
-Version: 0.1.167
+Version: 0.1.170
 Summary: Jarvis: An AI assistant that uses tools to interact with the system
 Home-page: https://github.com/skyfireitdiy/Jarvis
 Author: skyfire
@@ -65,6 +65,7 @@ Requires-Dist: build; extra == "dev"
 Requires-Dist: twine; extra == "dev"
 Dynamic: author
 Dynamic: home-page
+Dynamic: license-file
 Dynamic: requires-python
 
 # 🤖 Jarvis AI 助手
@@ -212,6 +213,7 @@ OPENAI_API_BASE=https://api.openai.com/v1  # 可选，默认为官方API地址
 | `JARVIS_CONFIRM_BEFORE_APPLY_PATCH` | true | 应用补丁前是否需要确认 |
 | `JARVIS_MAX_TOOL_CALL_COUNT` | 20 | 最大连续工具调用次数 |
 | `JARVIS_AUTO_UPDATE` | true | 是否自动更新Jarvis（仅在以git仓库方式安装时有效） |
+| `JARVIS_MAX_BIG_CONTENT_SIZE` | 10485760 | 最大大内容大小 |
 
 所有配置编写到`~/.jarvis/env`文件中即可生效。
 

{jarvis_ai_assistant-0.1.167 → jarvis_ai_assistant-0.1.170}/README.md

@@ -143,6 +143,7 @@ OPENAI_API_BASE=https://api.openai.com/v1  # 可选，默认为官方API地址
 | `JARVIS_CONFIRM_BEFORE_APPLY_PATCH` | true | 应用补丁前是否需要确认 |
 | `JARVIS_MAX_TOOL_CALL_COUNT` | 20 | 最大连续工具调用次数 |
 | `JARVIS_AUTO_UPDATE` | true | 是否自动更新Jarvis（仅在以git仓库方式安装时有效） |
+| `JARVIS_MAX_BIG_CONTENT_SIZE` | 10485760 | 最大大内容大小 |
 
 所有配置编写到`~/.jarvis/env`文件中即可生效。
 

{jarvis_ai_assistant-0.1.167 → jarvis_ai_assistant-0.1.170}/pyproject.toml

@@ -8,7 +8,7 @@ default = true
 
 [project]
 name = "jarvis-ai-assistant"
-version = "0.1.167"
+version = "0.1.170"
 description = "Jarvis: An AI assistant that uses tools to interact with the system"
 readme = "README.md"
 authors = [{ name = "skyfire", email = "skyfireitdiy@hotmail.com" }]

{jarvis_ai_assistant-0.1.167 → jarvis_ai_assistant-0.1.170}/setup.py

@@ -3,7 +3,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="jarvis-ai-assistant",
-    version="0.1.167",
+    version="0.1.170",
     author="skyfire",
     author_email="skyfireitdiy@hotmail.com",
     description="An AI assistant that uses various tools to interact with the system",

{jarvis_ai_assistant-0.1.167 → jarvis_ai_assistant-0.1.170}/src/jarvis/__init__.py

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

{jarvis_ai_assistant-0.1.167 → jarvis_ai_assistant-0.1.170}/src/jarvis/jarvis_agent/__init__.py

@@ -421,56 +421,27 @@ class Agent:
 
         with yaspin(text="正在总结对话历史...", color="cyan") as spinner:
 
-            summary_prompt = """<methodology_analysis>
-<request>
-当前任务已结束，请分析是否需要生成方法论。基于本次对话的内容和结果:
-
-如果你认为需要生成方法论，请先确定是创建新方法论还是更新现有方法论。如果是更新现有方法论，请使用'update'，否则使用'add'。
-如果你认为不需要方法论，请解释原因。
-</request>
-
-<evaluation_criteria>
-方法论评估标准:
-1. 方法论应聚焦于通用且可重复的解决方案流程
-2. 方法论应该具备足够的通用性，可应用于同类问题
-3. 特别注意用户在执行过程中提供的修正、反馈和改进建议
-4. 如果用户明确指出了某个解决步骤的优化方向，这应该被纳入方法论
-5. 如果用户在解决过程中发现了更高效的方法，这应被记录并优先使用
-</evaluation_criteria>
-
-<format_requirements>
-方法论格式要求:
-1. 问题重述: 简明扼要的问题归纳，不含特定细节
-2. 最优解决方案: 经过用户验证的、最终有效的解决方案（将每个步骤要使用的工具也列举出来）
-3. 注意事项: 执行中可能遇到的常见问题和注意点，尤其是用户指出的问题
-4. 可选步骤: 对于有多种解决路径的问题，标注出可选步骤和适用场景
-</format_requirements>
-
-<quality_control>
-方法论质量控制:
-1. 只记录有实际意义的流程，不记录执行过程中的错误或无效尝试
-2. 保留最终有效的解决步骤和用户认可的解决方案
-3. 不要包含特定代码片段、文件路径或其他特定于单一任务的细节
-4. 确保方法论遵循用户认可的执行路径，尤其是用户指出的改进点
-</quality_control>
-
-<output_requirements>
-只输出方法论工具调用指令，或不生成方法论的解释。不要输出其他内容。
-</output_requirements>
+            summary_prompt = """
+<summary_request>
+<objective>
+请对当前对话历史进行简明扼要的总结，提取关键信息和重要决策点。这个总结将作为上下文继续任务，因此需要保留对后续对话至关重要的内容。
+</objective>
+
+<guidelines>
+1. 提取关键信息：任务目标、已确定的事实、重要决策、达成的共识
+2. 保留技术细节：命令、代码片段、文件路径、配置设置等技术细节
+3. 记录任务进展：已完成的步骤、当前所处阶段、待解决的问题
+4. 包含用户偏好：用户表达的明确偏好、限制条件或特殊要求
+5. 省略冗余内容：问候语、重复信息、不相关的讨论
+</guidelines>
 
-<template>
-方法论格式：
-{ot("TOOL_CALL")}
-want: 添加/更新xxxx的方法论
-name: methodology
-arguments:
-  operation: add/update
-  problem_type: 方法论类型，不要过于细节，也不要过于泛化
-  content: |
-    方法论内容
-{ct("TOOL_CALL")}
-</template>
-</methodology_analysis>
+<format>
+- 使用简洁、客观的语言
+- 按时间顺序或主题组织信息
+- 使用要点列表增强可读性
+- 总结应控制在500词以内
+</format>
+</summary_request>
 """
 
             try:
@@ -559,58 +530,162 @@ arguments:
             2. 对于子Agent: 可能会生成总结(如果启用)
             3. 使用spinner显示生成状态
         """
-        """Complete the current task and generate summary if needed.
-
-        Returns:
-            str: Task summary or completion status
-
-        Note:
-            - For main agent: May generate methodology if enabled
-            - For sub-agent: May generate summary if enabled
-        """
-        with yaspin(text="正在生成方法论...", color="cyan") as spinner:
+        with yaspin(text="正在分析任务...", color="cyan") as spinner:
             try:
-
                 # 让模型判断是否需要生成方法论
-                analysis_prompt = f"""<methodology_analysis>
+                analysis_prompt = f"""<task_analysis>
 <request>
-当前任务已结束，请分析是否需要生成方法论。基于本次对话的内容和结果:
+当前任务已结束，请分析该任务的解决方案：
 
-如果你认为需要生成方法论，请先确定是创建新方法论还是更新现有方法论。如果是更新现有方法论，请使用'update'，否则使用'add'。
-如果你认为不需要方法论，请解释原因。
+1. 首先检查现有工具或方法论是否已经可以完成该任务，如果可以，直接说明即可，无需生成新内容
+2. 如果现有工具/方法论不足，评估当前任务是否可以通过编写新工具来自动化解决
+3. 如果可以通过工具解决，请设计并提供工具代码
+4. 如果无法通过编写通用工具完成，评估是否可以总结为通用方法论
+5. 如果以上都不可行，给出详细理由
+
+请根据分析结果采取相应行动：说明现有工具/方法论、创建新工具、生成新方法论或说明原因。
 </request>
 
 <evaluation_criteria>
+现有资源评估:
+1. 现有工具 - 检查系统中是否已有可以完成该任务的工具
+2. 现有方法论 - 检查是否已有适用于该任务的方法论
+3. 组合使用 - 评估现有工具和方法论组合使用是否可以解决问题
+
+工具评估标准:
+1. 通用性 - 该工具是否可以解决一类问题，而不仅仅是当前特定问题
+2. 自动化 - 该工具是否可以减少人工干预，提高效率
+3. 可靠性 - 该工具是否可以在不同场景下稳定工作
+4. 简单性 - 该工具是否易于使用，参数设计是否合理
+
 方法论评估标准:
 1. 方法论应聚焦于通用且可重复的解决方案流程
 2. 方法论应该具备足够的通用性，可应用于同类问题
 3. 特别注意用户在执行过程中提供的修正、反馈和改进建议
 4. 如果用户明确指出了某个解决步骤的优化方向，这应该被纳入方法论
-5. 如果用户在解决过程中发现了更高效的方法，这应被记录并优先使用
 </evaluation_criteria>
 
-<format_requirements>
+<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. 可选步骤: 对于有多种解决路径的问题，标注出可选步骤和适用场景
-</format_requirements>
-
-<quality_control>
-方法论质量控制:
-1. 只记录有实际意义的流程，不记录执行过程中的错误或无效尝试
-2. 保留最终有效的解决步骤和用户认可的解决方案
-3. 不要包含特定代码片段、文件路径或其他特定于单一任务的细节
-4. 确保方法论遵循用户认可的执行路径，尤其是用户指出的改进点
-</quality_control>
+</methodology_requirements>
 
 <output_requirements>
-只输出方法论工具调用指令，或不生成方法论的解释。不要输出其他内容。
-</output_requirements>
+根据分析结果，输出以下三种情况之一：
+
+1. 如果现有工具/方法论可以解决，直接输出说明：
+已有工具/方法论可以解决该问题，无需创建新内容。
+可用的工具/方法论：[列出工具名称或方法论名称]
+使用方法：[简要说明如何使用]
+
+2. 工具创建（如果需要创建新工具）:
+{ot("TOOL_CALL")}
+want: 创建新工具来解决XXX问题
+name: generate_new_tool
+arguments:
+  tool_name: 工具名称
+  tool_code: |
+    # -*- 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")}
 
-<template>
-方法论格式：
+3. 方法论创建（如果需要创建新方法论）:
 {ot("TOOL_CALL")}
 want: 添加/更新xxxx的方法论
 name: methodology
@@ -620,19 +695,105 @@ arguments:
   content: |
     方法论内容
 {ct("TOOL_CALL")}
-</template>
-</methodology_analysis>
-"""
+
+如果以上三种情况都不适用，则直接输出原因分析，不要使用工具调用格式。
+</output_requirements>
+
+<tool_example>
+以下是一个完整的工具示例，供参考：
+
+```python
+# -*- coding: utf-8 -*-
+from typing import Dict, Any
+from jarvis.jarvis_utils.output import PrettyOutput, OutputType
+
+class text_transformer:
+    name = "text_transformer"
+    description = "Tool for text transformation"
+    Tool description for text transformation
+    适用场景：1. 格式化文本; 2. 处理标题; 3. 标准化输出
+    \"\"\"
+    
+    parameters = {{
+        "type": "object",
+        "properties": {{
+            "text": {{
+                "type": "string",
+                "description": "需要转换格式的文本"
+            }},
+            "transform_type": {{
+                "type": "string",
+                "description": "转换类型，可选值为 upper（大写）、lower（小写）或 title（首字母大写）",
+                "enum": ["upper", "lower", "title"]
+            }}
+        }},
+        "required": ["text", "transform_type"]
+    }}
+    
+    @staticmethod
+    def check() -> bool:
+        return True
+    
+    def execute(self, args: Dict[str, Any]) -> Dict[str, Any]:
+        try:
+            text = args["text"]
+            transform_type = args["transform_type"]
+            
+            # 使用PrettyOutput显示执行过程
+            PrettyOutput.print(f"正在将文本转换为 {{transform_type}} 格式...", OutputType.INFO)
+            
+            if transform_type == "upper":
+                result = text.upper()
+                PrettyOutput.print("文本已转换为大写", OutputType.SUCCESS)
+            elif transform_type == "lower":
+                result = text.lower()
+                PrettyOutput.print("文本已转换为小写", OutputType.SUCCESS)
+            elif transform_type == "title":
+                result = text.title()
+                PrettyOutput.print("文本已转换为首字母大写", OutputType.SUCCESS)
+            else:
+                PrettyOutput.print(f"不支持的转换类型: {{transform_type}}", OutputType.ERROR)
+                return {{
+                    "success": False,
+                    "stdout": "",
+                    "stderr": f"不支持的转换类型: {{transform_type}}"
+                }}
+            
+            return {{
+                "success": True,
+                "stdout": result,
+                "stderr": ""
+            }}
+            
+        except Exception as e:
+            PrettyOutput.print(f"转换失败: {{str(e)}}", OutputType.ERROR)
+            return {{
+                "success": False,
+                "stdout": "",
+                "stderr": f"转换失败: {{str(e)}}"
+            }}
+```
+
+使用方法：
+```
+name: text_transformer
+arguments:
+    text: hello world
+    transform_type: upper
+```
+</tool_example>
+</task_analysis>"""
+
                 self.prompt = analysis_prompt
                 with spinner.hidden():
                     response = self.model.chat_until_success(self.prompt) # type: ignore
 
                 with spinner.hidden():
                     self._call_tools(response)
-                spinner.text = "方法论生成完成"
+                spinner.text = "分析完成"
                 spinner.ok("✅")
             except Exception as e:
-                spinner.text = "方法论生成失败"
+                spinner.text = "分析失败"
                 spinner.fail("❌")
         if self.need_summary:
             with yaspin(text="正在生成总结...", color="cyan") as spinner:
@@ -689,7 +850,7 @@ arguments:
                     if self.after_tool_call_cb:
                         self.after_tool_call_cb(self)
 
-                    if self.prompt:
+                    if self.prompt or self.addon_prompt:
                         continue
 
                     if self.auto_complete and ot("!!!COMPLETE!!!") in current_response:

{jarvis_ai_assistant-0.1.167 → jarvis_ai_assistant-0.1.170}/src/jarvis/jarvis_agent/jarvis.py

@@ -127,6 +127,8 @@ def main() -> None:
             need_summary=False
         )
 
+        agent.set_addon_prompt(agent.make_default_addon_prompt(False) + "\n如果使用脚本可以完成任务，优先execute_script工具")
+
         # 优先处理命令行直接传入的任务
         if args.task:
             agent.run(args.task)

{jarvis_ai_assistant-0.1.167 → jarvis_ai_assistant-0.1.170}/src/jarvis/jarvis_code_agent/code_agent.py

@@ -395,10 +395,10 @@ class CodeAgent:
         if not is_confirm_before_apply_patch() or user_confirm("是否使用此回复？", default=True):
             agent.prompt += final_ret
             return
+        agent.prompt += final_ret
         custom_reply = get_multiline_input("请输入自定义回复")
-        if not custom_reply.strip():  # 如果自定义回复为空，返回空字符串
-            agent.prompt += final_ret
-        agent.set_addon_prompt(custom_reply)
+        if custom_reply.strip():  # 如果自定义回复为空，返回空字符串
+            agent.set_addon_prompt(custom_reply)
         agent.prompt += final_ret
 
 

{jarvis_ai_assistant-0.1.167 → jarvis_ai_assistant-0.1.170}/src/jarvis/jarvis_code_analysis/code_review.py

@@ -591,8 +591,8 @@ class CodeReviewTool:
                     is_large_content = is_context_overflow(diff_output)
                     
                     # Upload the file to the agent's model
-                    with yaspin(text="正在上传代码差异文件...", color="cyan") as spinner:
-                        if is_large_content and agent.model and hasattr(agent.model, 'upload_files'):
+                    if is_large_content and agent.model and hasattr(agent.model, 'upload_files'):
+                        with yaspin(text="正在上传代码差异文件...", color="cyan") as spinner:
                             upload_success = agent.model.upload_files([temp_file_path])
                             if upload_success:
                                 spinner.ok("✅")
@@ -600,8 +600,8 @@ class CodeReviewTool:
                             else:
                                 spinner.fail("❌")
                                 PrettyOutput.print(f"上传代码差异文件失败，将使用分块处理", OutputType.WARNING)
-                        else:
-                            upload_success = False
+                    else:
+                        upload_success = False
                     
                     # Prepare the prompt based on upload status
                     if upload_success:
@@ -617,14 +617,15 @@ class CodeReviewTool:
                         # Run the agent with the prompt
                         result = agent.run(complete_prompt)
                     else:
-                        # If upload failed or not needed, handle based on context size
-                        if is_large_content and agent.model and hasattr(agent.model, 'chat_big_content'):
-                            # Use chat_big_content for large content when upload fails
-                            result = agent.model.chat_big_content(diff_output, user_prompt)
-                        else:
-                            # Include the diff directly in the prompt for smaller content
-                            complete_prompt = user_prompt + "\n\n代码差异内容:\n```diff\n" + diff_output + "\n```"
-                            result = agent.run(complete_prompt)
+                        if is_large_content:
+                            return {
+                                "success": False,
+                                "stdout": "",
+                                "stderr": "错误：上传代码差异文件失败"
+                            }
+                        # Include the diff directly in the prompt for smaller content
+                        complete_prompt = user_prompt + "\n\n代码差异内容:\n```diff\n" + diff_output + "\n```"
+                        result = agent.run(complete_prompt)
                 finally:
                     # Clean up the temporary file
                     if os.path.exists(temp_file_path):

{jarvis_ai_assistant-0.1.167 → jarvis_ai_assistant-0.1.170}/src/jarvis/jarvis_git_utils/git_commiter.py

@@ -180,11 +180,12 @@ class GitCommitTool:
     '''
                             commit_message = platform.chat_until_success(prompt)
                         else:
-                            # 如果上传失败但内容较大，使用chat_big_content
-                            if is_large_content and hasattr(platform, 'chat_big_content'):
-                                spinner.text = "正在使用分块处理生成提交信息..."
-                                commit_message = platform.chat_big_content(diff, base_prompt)
-                            else:
+                                if is_large_content:
+                                    return {
+                                        "success": False,
+                                        "stdout": "",
+                                        "stderr": "错误：上传代码差异文件失败"
+                                    }
                                 # 直接在提示中包含差异内容
                                 prompt = base_prompt + f'''
     # 分析材料

{jarvis_ai_assistant-0.1.167 → jarvis_ai_assistant-0.1.170}/src/jarvis/jarvis_platform/base.py

@@ -2,10 +2,12 @@
 from abc import ABC, abstractmethod
 import re
 from typing import List, Tuple
+
+from yaspin import yaspin
 from jarvis.jarvis_utils.config import get_max_input_token_count
 from jarvis.jarvis_utils.embedding import split_text_into_chunks
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
-from jarvis.jarvis_utils.utils import get_context_token_count, while_success, while_true
+from jarvis.jarvis_utils.utils import get_context_token_count, is_context_overflow, while_success, while_true
 from jarvis.jarvis_utils.tag import ot, ct
 
 
@@ -38,29 +40,40 @@ class BasePlatform(ABC):
     @abstractmethod
     def upload_files(self, file_list: List[str]) -> bool:
         raise NotImplementedError("upload_files is not implemented")
-    
-    def chat_big_content(self, content: str, prompt: str) -> str:
-        # 检查content大小不超过10MB
-        if len(content.encode('utf-8')) > 10 * 1024 * 1024:
-            return "Error: Content size exceeds 10MB limit"
-        
-        prefix_prompt = f"""
-        我将分多次提供大量的上下文内容，在我明确告诉你内容已经全部提供完毕之前，每次仅需要输出“已收到”。
-        """
-        self.chat_until_success(prefix_prompt)
-        split_content = split_text_into_chunks(content, get_max_input_token_count() - 1024, get_max_input_token_count() - 2048)
-        submit_count = 0
-        for chunk in split_content:
-            submit_count += 1
-            PrettyOutput.print(f"已提交{submit_count}次（总{len(split_content)}次）", OutputType.INFO)
-            self.chat_until_success(f"<part_content>{chunk}</part_content>请返回已收到")
-        return self.chat_until_success(f"内容已经全部提供完毕\n\n{prompt}")
+
 
     
     def _chat(self, message: str):
         import time
         start_time = time.time()
-        response = self.chat(message)
+
+        input_token_count = get_context_token_count(message)
+
+        if is_context_overflow(message):
+            PrettyOutput.print("错误：输入内容超过最大限制", OutputType.WARNING)
+            return "错误：输入内容超过最大限制"
+
+        if input_token_count > get_max_input_token_count():
+            current_suppress_output = self.suppress_output
+            self.set_suppress_output(True)
+            inputs = split_text_into_chunks(message, get_max_input_token_count() - 1024, get_max_input_token_count() - 2048)
+            with yaspin(text="正在提交长上下文...", color="cyan") as spinner:
+                prefix_prompt = f"""
+                我将分多次提供大量内容，在我明确告诉你内容已经全部提供完毕之前，每次仅需要输出“已收到”，明白请输出“开始接收输入”。
+                """
+                while_true(lambda: while_success(lambda: self.chat(prefix_prompt), 5), 5)
+                submit_count = 0
+                for input in inputs:
+                    submit_count += 1
+                    spinner.text = f"正在提交第{submit_count}部分（共{len(inputs)}部分）"
+                    while_true(lambda: while_success(lambda: self.chat(f"<part_content>{input}</part_content>请返回已收到"), 5), 5)
+                spinner.text = "提交完成"
+                spinner.ok("✅")
+            self.set_suppress_output(current_suppress_output)
+            response = while_true(lambda: while_success(lambda: self.chat("内容已经全部提供完毕，请继续"), 5), 5)
+            
+        else:
+            response = self.chat(message)
 
         end_time = time.time()
         duration = end_time - start_time
@@ -78,7 +91,7 @@ class BasePlatform(ABC):
         # Print statistics
         if not self.suppress_output:
             PrettyOutput.print(
-                f"对话完成 - 耗时: {duration:.2f}秒, 输出字符数: {char_count}, 输出Token数量: {token_count}, 每秒Token数量: {tokens_per_second:.2f}",
+                f"对话完成 - 耗时: {duration:.2f}秒, 输入字符数: {len(message)}, 输入Token数量: {input_token_count}, 输出字符数: {char_count}, 输出Token数量: {token_count}, 每秒Token数量: {tokens_per_second:.2f}",
                 OutputType.INFO,
             )
 

{jarvis_ai_assistant-0.1.167 → jarvis_ai_assistant-0.1.170}/src/jarvis/jarvis_tools/edit_file.py

@@ -23,6 +23,7 @@ from yaspin import yaspin
 from jarvis.jarvis_platform.registry import PlatformRegistry
 from jarvis.jarvis_tools.file_operation import FileOperationTool
 from jarvis.jarvis_utils.git_utils import revert_file
+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
 
@@ -230,6 +231,11 @@ def patch_apply(filepath: str, patch_content: str) -> Tuple[bool, str]:
     2. 失败时自动回滚文件修改
     3. 提供详细的执行状态输出
     """
+    import os
+    work_dir = os.path.abspath(os.curdir)
+    filepath = os.path.abspath(filepath)
+    if not filepath.startswith(work_dir):
+        PrettyOutput.print(f"文件 {filepath} 不在工作目录 {work_dir} 下，不会进行版本控制管理", OutputType.WARNING)
     model = PlatformRegistry().get_normal_platform()
     with yaspin(text=f"正在处理文件 {filepath}...", color="cyan") as spinner:
         try:
@@ -300,7 +306,7 @@ def patch_apply(filepath: str, patch_content: str) -> Tuple[bool, str]:
                     if upload_success:
                         response = model.chat_until_success(main_prompt)
                     else:
-                        response = model.chat_big_content(file_content, main_prompt)
+                        return False, ""
 
                 # 解析差异化补丁
                 diff_blocks = re.finditer(ot("DIFF")+r'\s*>{4,} SEARCH\n?(.*?)\n?={4,}\n?(.*?)\s*<{4,} REPLACE\n?'+ct("DIFF"),