jarvis-ai-assistant 0.1.168__py3-none-any.whl → 0.1.171__py3-none-any.whl

jarvis/__init__.py

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

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/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/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/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/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/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/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"),

jarvis/jarvis_tools/generate_new_tool.py

@@ -12,85 +12,6 @@ class generate_new_tool:
     生成并注册新的Jarvis工具。该工具会在用户数据目录下创建新的工具文件，
     并自动注册到当前的工具注册表中。适用场景：1. 需要创建新的自定义工具；
     2. 扩展Jarvis功能；3. 自动化重复性操作；4. 封装特定领域的功能。
-    
-    使用示例：
-    
-    ```
-    # 创建一个将文本转换为大写/小写的工具
-    name: generate_new_tool
-    arguments:
-        tool_name: text_transformer
-        tool_code: |
-            # -*- coding: utf-8 -*-
-            from typing import Dict, Any
-            
-            class text_transformer:
-                name = "text_transformer"
-                description = \"\"\"
-                文本转换工具，可以将输入的文本转换为大写、小写或首字母大写格式。
-                适用场景：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"]
-                        
-                        if transform_type == "upper":
-                            result = text.upper()
-                        elif transform_type == "lower":
-                            result = text.lower()
-                        elif transform_type == "title":
-                            result = text.title()
-                        else:
-                            return {
-                                "success": False,
-                                "stdout": "",
-                                "stderr": f"不支持的转换类型: {transform_type}"
-                            }
-                        
-                        return {
-                            "success": True,
-                            "stdout": result,
-                            "stderr": ""
-                        }
-                        
-                    except Exception as e:
-                        return {
-                            "success": False,
-                            "stdout": "",
-                            "stderr": f"转换失败: {str(e)}"
-                        }
-    ```
-    
-    创建完成后可以立即使用：
-    
-    ```
-    name: text_transformer
-    arguments:
-        text: hello world
-        transform_type: upper
-    ```
     """
     
     parameters = {
@@ -136,6 +57,7 @@ class generate_new_tool:
         返回:
             Dict: 包含生成结果的字典
         """
+        tool_file_path = None
         try:
             # 从参数中获取工具信息
             tool_name = args["tool_name"]
@@ -181,15 +103,30 @@ class generate_new_tool:
             # 注册新工具到当前的工具注册表
             success_message = f"工具 '{tool_name}' 已成功生成在 {tool_file_path}"
             
+            registration_successful = False
             if agent:
                 tool_registry = agent.get_tool_registry()
                 if tool_registry:
                     # 尝试加载并注册新工具
+                    PrettyOutput.print(f"正在注册工具 '{tool_name}'...", OutputType.INFO)
                     if tool_registry.register_tool_by_file(str(tool_file_path)):
                         success_message += f"\n已成功注册到当前会话的工具注册表中"
+                        registration_successful = True
+                    else:
+                        # 注册失败，删除已创建的文件
+                        PrettyOutput.print(f"注册工具 '{tool_name}' 失败，正在删除文件...", OutputType.WARNING)
+                        if tool_file_path.exists():
+                            tool_file_path.unlink()
+                        return {
+                            "success": False,
+                            "stdout": "",
+                            "stderr": f"工具文件已生成，但注册失败。文件已被删除。"
+                        }
                 else:
+                    PrettyOutput.print("未找到工具注册表，无法自动注册工具", OutputType.WARNING)
                     success_message += f"\n注册到当前会话失败，可能需要重新启动Jarvis"
             
+            PrettyOutput.print(f"工具 '{tool_name}' 创建" + ("并注册" if registration_successful else "") + "成功！", OutputType.SUCCESS)
             return {
                 "success": True,
                 "stdout": success_message,
@@ -197,11 +134,23 @@ class generate_new_tool:
             }
             
         except Exception as e:
-            # 如果发生异常，返回失败响应，包含错误信息
+            # 如果发生异常，删除已创建的文件并返回失败响应
+            error_msg = f"生成工具失败: {str(e)}"
+            PrettyOutput.print(error_msg, OutputType.ERROR)
+            
+            # 删除已创建的文件
+            if tool_file_path and tool_file_path.exists():
+                try:
+                    PrettyOutput.print(f"正在删除已创建的文件 {tool_file_path}...", OutputType.INFO)
+                    tool_file_path.unlink()
+                    PrettyOutput.print(f"文件已删除", OutputType.SUCCESS)
+                except Exception as delete_error:
+                    PrettyOutput.print(f"删除文件失败: {str(delete_error)}", OutputType.ERROR)
+            
             return {
                 "success": False,
                 "stdout": "",
-                "stderr": f"生成工具失败: {str(e)}"
+                "stderr": error_msg
             }
     
     def _validate_and_process_code(self, tool_name: str, tool_code: str) -> Tuple[str, str]:

jarvis/jarvis_tools/registry.py

@@ -636,12 +636,8 @@ class ToolRegistry(OutputHandler):
                             return f"""工具调用原始输出过长，以下是根据输出提出的信息：
 
 {platform.chat_until_success(prompt)}"""
-                        elif hasattr(platform, 'chat_big_content'):
-                            # 如果上传失败但支持大内容处理，使用chat_big_content
-                            prompt = f"以下内容为工具执行结果，请阅读内容，并根据内容提取出以下信息：{want}\n\n{output}"
-                            return f"""工具调用原始输出过长，以下是根据输出提出的信息：
-
-{platform.chat_big_content(output, prompt)}"""
+                        else:
+                            return self._truncate_output(output)
                     
                     # 如果都不支持，返回截断的输出
                     return self._truncate_output(output)

jarvis/jarvis_utils/config.py

@@ -151,4 +151,13 @@ def get_auto_update() -> bool:
     返回：
         bool: 如果需要自动更新则返回True，默认为True
     """
-    return os.getenv('JARVIS_AUTO_UPDATE', 'true') == 'true'
+    return os.getenv('JARVIS_AUTO_UPDATE', 'true') == 'true'
+
+def get_max_big_content_size() -> int:
+    """
+    获取最大大内容大小。
+
+    返回：
+        int: 最大大内容大小，默认为1MB
+    """
+    return int(os.getenv('JARVIS_MAX_BIG_CONTENT_SIZE', '163840'))

jarvis/jarvis_utils/methodology.py

@@ -125,6 +125,7 @@ def load_methodology(user_input: str, tool_registery: Optional[Any] = None) -> s
 
         # 获取当前平台
         platform = PlatformRegistry().get_normal_platform()
+        platform.set_suppress_output(False)
         if not platform:
             return ""
 
@@ -175,7 +176,6 @@ def load_methodology(user_input: str, tool_registery: Optional[Any] = None) -> s
 
                 # 尝试上传文件
                 if hasattr(platform, 'upload_files'):
-                    platform.set_suppress_output(False)
                     upload_success = platform.upload_files([temp_file_path])
                     
                     if upload_success:
@@ -195,24 +195,8 @@ def load_methodology(user_input: str, tool_registery: Optional[Any] = None) -> s
 如果没有匹配的方法论，请输出：没有历史方法论可参考
 除以上要求外，不要输出任何内容
 """)
-                    elif hasattr(platform, 'chat_big_content'):
-                        # 如果上传失败但支持大内容处理，使用chat_big_content
-                        return platform.chat_big_content(full_content, base_prompt + f"""
-请根据以上方法论和可调用的工具文件内容，规划/总结出以下用户需求的执行步骤: {user_input}
-
-请按以下格式回复：
-### 与该任务/需求相关的方法论
-1. [方法论名字]
-2. [方法论名字]
-### 根据以上方法论，规划/总结出执行步骤
-1. [步骤1]
-2. [步骤2]
-3. [步骤3]
-
-如果没有匹配的方法论，请输出：没有历史方法论可参考
-除以上要求外，不要输出任何内容
-""")
-            
+                    else:
+                        return "没有历史方法论可参考"
             # 如果内容不大或上传失败，直接使用chat_until_success
             return platform.chat_until_success(full_content)
         

jarvis/jarvis_utils/utils.py

@@ -1,12 +1,11 @@
 # -*- coding: utf-8 -*-
-from doctest import script_from_examples
 import os
 import time
 import hashlib
 import tarfile
 from pathlib import Path
-from typing import List, Any, Callable
-from jarvis.jarvis_utils.config import INPUT_WINDOW_REVERSE_SIZE, get_max_input_token_count, get_data_dir
+from typing import Any, Callable
+from jarvis.jarvis_utils.config import get_max_big_content_size, get_data_dir
 from jarvis.jarvis_utils.embedding import get_context_token_count
 from jarvis.jarvis_utils.input import get_single_line_input
 from jarvis.jarvis_utils.output import PrettyOutput, OutputType
@@ -125,37 +124,7 @@ def get_file_line_count(filename: str) -> int:
         return 0
 
 
-def is_long_context(files: List[str]) -> bool:
-    """检查文件列表是否属于长上下文
 
-    判断标准：
-    当总token数超过最大上下文长度的80%时视为长上下文
-
-    参数：
-    files -- 要检查的文件路径列表
-
-    返回：
-    布尔值表示是否属于长上下文
-    """
-    max_input_token_count = get_max_input_token_count()
-    threshold = max_input_token_count * 0.8
-    total_tokens = 0
-
-    for file_path in files:
-        try:
-            with open(file_path, 'r', encoding='utf-8', errors="ignore") as f:
-                content = f.read()
-                total_tokens += get_context_token_count(content)
-
-                if total_tokens > threshold:
-                    return True
-        except Exception as e:
-            PrettyOutput.print(f"读取文件 {file_path} 失败: {e}", OutputType.WARNING)
-            continue
-
-    return total_tokens > threshold
-
-
-def is_context_overflow(file_content: str) -> bool:
+def is_context_overflow(content: str) -> bool:
     """判断文件内容是否超出上下文限制"""
-    return get_context_token_count(file_content) > get_max_input_token_count() - INPUT_WINDOW_REVERSE_SIZE
+    return get_context_token_count(content) > get_max_big_content_size() 

{jarvis_ai_assistant-0.1.168.dist-info → jarvis_ai_assistant-0.1.171.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jarvis-ai-assistant
-Version: 0.1.168
+Version: 0.1.171
 Summary: Jarvis: An AI assistant that uses tools to interact with the system
 Home-page: https://github.com/skyfireitdiy/Jarvis
 Author: skyfire
@@ -213,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.168.dist-info → jarvis_ai_assistant-0.1.171.dist-info}/RECORD

@@ -1,14 +1,14 @@
-jarvis/__init__.py,sha256=Uwmd9fcZynaw-k5O40V5azBvvEzWHzlXM3_7vKFOYl4,74
-jarvis/jarvis_agent/__init__.py,sha256=uCyjBD1ib9ewmJ1RJVy6QrVWOxy_4oNVFjvggqMRYg0,25712
+jarvis/__init__.py,sha256=VnCd0RxDGsMy-0sOoD8gB7obLOpzOBEThebur7vlvxI,74
+jarvis/jarvis_agent/__init__.py,sha256=J3teZnIgaGqztT3qgtyZA-zYJHKzK6NsyMNDlCKKChU,31045
 jarvis/jarvis_agent/builtin_input_handler.py,sha256=KhvlV_QdB3P-M0TCkWvdxidNie1jU7KoMOqTIXCpwwA,1529
 jarvis/jarvis_agent/file_input_handler.py,sha256=EwaitWczbwLCKNpWU9C7m829_G5uLZ_hNcVXlX2ANes,3437
-jarvis/jarvis_agent/jarvis.py,sha256=rn0rLMGuVDyUa0_xdAmPV3M4yhIvE9ldSwD5DaJKo-8,5819
+jarvis/jarvis_agent/jarvis.py,sha256=IuM-A9KZd1jqOFszB2l-Ua1FE5uVGvvNia1SSgp7Jgg,5963
 jarvis/jarvis_agent/main.py,sha256=IAD59fEMWWSSAtHJhOQMPs_NMoKtcYjrxlTvhCHEVII,2626
 jarvis/jarvis_agent/output_handler.py,sha256=7qori-RGrQmdiFepoEe3oPPKJIvRt90l_JDmvCoa4zA,1219
 jarvis/jarvis_agent/shell_input_handler.py,sha256=pi3AtPKrkKc6K9e99S1djKXQ_XrxtP6FrSWebQmRT6E,1261
 jarvis/jarvis_code_agent/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-jarvis/jarvis_code_agent/code_agent.py,sha256=awCuRODHek434ixuG62PeAtFjQ7fQheJERJDpT4Bjuk,16859
-jarvis/jarvis_code_analysis/code_review.py,sha256=hVuKUfOKpgAyXG7pNKJG5SOcuGri8UcBza_W4fk34wY,30265
+jarvis/jarvis_code_agent/code_agent.py,sha256=vN-HZcwMnOfofq5JDjuVADQdBRdG1SuRv_-_BkKUUQI,16855
+jarvis/jarvis_code_analysis/code_review.py,sha256=68GCjxdg-n2hoMoCSGWpH_ZdQArc4G09E9Wwhypk4eY,30135
 jarvis/jarvis_code_analysis/checklists/__init__.py,sha256=cKQ_FOGy5TQgM-YkRCqORo-mUOZaPAJ9VDmZoFX58us,78
 jarvis/jarvis_code_analysis/checklists/c_cpp.py,sha256=SXPpYCNeCtU1PpKdKPiYDuOybfY9vaL0ejDn4imxDwA,1317
 jarvis/jarvis_code_analysis/checklists/csharp.py,sha256=vS-cu6RCGg5SyK9MJ3RE381gt3xYl-yea3Bj2UQEcwQ,2420
@@ -35,7 +35,7 @@ jarvis/jarvis_git_details/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJW
 jarvis/jarvis_git_details/main.py,sha256=l4Ol96DFISq2ctAgzmfUuS4i6JdWh0JAu_isY3iuzVo,8919
 jarvis/jarvis_git_squash/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 jarvis/jarvis_git_squash/main.py,sha256=uZf05Y7UN8kwlrfsSeX2NEGCaowwzZsm9LqjgmQxeic,2203
-jarvis/jarvis_git_utils/git_commiter.py,sha256=0ABGCpZUcJIDFiCi0naQeJ1oySeQ2MDmyMzI96oXD58,13006
+jarvis/jarvis_git_utils/git_commiter.py,sha256=B9qYArFdv6Vr82__Ji_USvXYhJgGsW2v0pkUoymiwHI,12943
 jarvis/jarvis_lsp/base.py,sha256=ZngrQ4NUy9iPrXORcw4QR-tWZi2G79nsfqeqqkaxSZ0,2054
 jarvis/jarvis_lsp/cpp.py,sha256=WL7rItrwFkYRSZzQHnoOoQ-EDho7Jd6BOaCn1UgsQ3A,3165
 jarvis/jarvis_lsp/go.py,sha256=FkBJAeJex8jamn44o_cpYCygSTGMnsykJGrnkVFlTww,3482
@@ -49,7 +49,7 @@ jarvis/jarvis_methodology/main.py,sha256=_KDGEQw6j_VZ9O8eDe-c8F84zl6JrKmsNRva9PG
 jarvis/jarvis_multi_agent/__init__.py,sha256=LEJofDjh80U34RyZv2ECAzpt2zkhA0Jn3KZh-ABoAKA,4343
 jarvis/jarvis_multi_agent/main.py,sha256=Z6N5VMjzaernnRjPkqgYRv09cIhWIFQ6a__AqHA8xrQ,1567
 jarvis/jarvis_platform/__init__.py,sha256=0YnsUoM4JkIBOtImFdjfuDbrqQZT3dEaAwSJ62DrpCc,104
-jarvis/jarvis_platform/base.py,sha256=Y5K0c6c6-74wFW38OWc7Boqtyfmf3sMZkR0S9rDSM8g,4588
+jarvis/jarvis_platform/base.py,sha256=cppBTsnQRppKRHdrwxoeiEXJYXdtsNnt4GjbF_kw-PM,5335
 jarvis/jarvis_platform/human.py,sha256=0sbEhST4rKKGGV45dAdJqvVBnRPPeCe6HqxR245S4Z8,2462
 jarvis/jarvis_platform/kimi.py,sha256=yz7OVT54YDSUVuFlijDB7VdsJmtqRgj-qYKPHy8f0WQ,16787
 jarvis/jarvis_platform/openai.py,sha256=8enxCISjHtCs0qoqEag68v68m_clKr7jgEpUA0CyUBo,4139
@@ -67,35 +67,35 @@ jarvis/jarvis_tools/chdir.py,sha256=wYVBqWF5kaUkKqH3cUAOKUsACzYsFtCCJJyd8UJsp4o,
 jarvis/jarvis_tools/code_plan.py,sha256=EzLdbJnVCkJ7lL8XIQyuDJdxU1i3CFiBpqyNG-GdJw8,7753
 jarvis/jarvis_tools/create_code_agent.py,sha256=cxYkjr4rhI2EWpK78psZSRB9mxiP1IUT0SEfFIqCJzY,3411
 jarvis/jarvis_tools/create_sub_agent.py,sha256=ppTOFRd0ygSJUFr3oQ8IrCLOqbZ7vwnbdadfTDjpDgs,3025
-jarvis/jarvis_tools/edit_file.py,sha256=1SllJmc-1gHf8h8xwQylJs84Ac0xowVpg0-X6yabwkM,13827
+jarvis/jarvis_tools/edit_file.py,sha256=8Yesy3MIPOIyz0GQph-x5G0P0hlsC-ds5T0eRPAHUQ4,14122
 jarvis/jarvis_tools/execute_script.py,sha256=cc0NlPwhkZinEexqT63d1ofEkzQddVWGsZOCVL1v_60,5739
 jarvis/jarvis_tools/file_analyzer.py,sha256=tzU1cPKyDa54hVZewP0bDzdsjvdjGQ1BRt5k8N4li3s,4868
 jarvis/jarvis_tools/file_operation.py,sha256=lP8EpsnSdA3FW8ofSAdoA8qPGMAG3UhYd6LFEzOFUVY,9044
 jarvis/jarvis_tools/find_methodology.py,sha256=FwGKSV4fHNkiAnaVUwP8GkqXl8PEqMPZBxAyvTSPFGA,2438
-jarvis/jarvis_tools/generate_new_tool.py,sha256=On4dXSmZZ_rVkNaZ151QE_3OWXXqtjs0lC-Dmxv9jSQ,11572
+jarvis/jarvis_tools/generate_new_tool.py,sha256=ctpkHBihsHhO6sLpF5lJue244EFJtdEQMuxR-_oV9r4,10282
 jarvis/jarvis_tools/lsp_get_diagnostics.py,sha256=paz1CVZ2Y8nk0U74n1QiG01oDINiZqpVlPc2f4_B150,5346
 jarvis/jarvis_tools/methodology.py,sha256=Md8W2et0xUiuTjUSRCdnlwEPYqah2dCAAkxW_95BXBY,5238
 jarvis/jarvis_tools/read_code.py,sha256=pgztSBRh8RORFalqwzzsLHQogooFvDm1ePBL0E5O1C4,5961
 jarvis/jarvis_tools/read_webpage.py,sha256=LLvAOvaQJodaeNJKQ6dU9MYEE227NMdHyLs7esluUQ4,2217
-jarvis/jarvis_tools/registry.py,sha256=rRdvLzsAkMPfRFZz9GfTP9K8mGedoDt8Pj9drRI_yL8,27133
+jarvis/jarvis_tools/registry.py,sha256=9Rr8F0lfsvSlFZ_X8yQ8XPohB_Jg7mYutTB1tq9TJHw,26750
 jarvis/jarvis_tools/rewrite_file.py,sha256=rEPPSNU7uF1iKfEW9npEpZJ2LSoQXjt2OC-_troBToE,7003
 jarvis/jarvis_tools/search_web.py,sha256=-h1WYOqTcYC_8fdkm-4RfwKpbtLTVxOfRROul51NgO0,951
 jarvis/jarvis_tools/virtual_tty.py,sha256=AKAaKY5KcPxifNQoXjzHaL4U6EUVA7irHLwVvz2wLVs,16396
 jarvis/jarvis_utils/__init__.py,sha256=l-fsyQ-KzyqAhrJYur8eZAqsgaifGzSm24R2qtRGJ0g,849
 jarvis/jarvis_utils/builtin_replace_map.py,sha256=A-cJ8deht2vDl2iKRhoZ7qECyJ6sboVH5Zx-L9vIBUs,4314
-jarvis/jarvis_utils/config.py,sha256=T7-RIPIZx6qehTFuu8AFZA-SVTDpsYUCopJ6KYZ8RAQ,4315
+jarvis/jarvis_utils/config.py,sha256=-x66P2PY8Ne02W1Yg0vofcMlErJq1Y99C5Sc6_n6Cv8,4538
 jarvis/jarvis_utils/embedding.py,sha256=05KvmZvtI2-7xxmj13kAknRezWuVeold-D68wyPvZSA,7015
 jarvis/jarvis_utils/file_processors.py,sha256=tSZSMJ4qCJ_lXI0dyLgJ0j5qEh6CDXDSVI7vQiFmcuQ,2976
 jarvis/jarvis_utils/git_utils.py,sha256=MxhUcQ_gFUFyBxBiorEJ1wUk9a2TerFdq3-Z11FB-AE,11324
 jarvis/jarvis_utils/globals.py,sha256=Zs0chxA_giYiolYvawFFpcnTWgCUnn6GEusAh42jbz8,2275
 jarvis/jarvis_utils/input.py,sha256=qGf2q-yWhgT-OX-j_WYi7aZ11jYmuFNiMz2_W1nUOiM,7432
-jarvis/jarvis_utils/methodology.py,sha256=d25o61UtnuwgIQBgnajxx9zPsxsVzv4Ptb9BGwC93Nk,8156
+jarvis/jarvis_utils/methodology.py,sha256=P1S_J9zxTed0Unpj0r-w14zpj8lEe_3bXgq1uvojjdQ,7512
 jarvis/jarvis_utils/output.py,sha256=PVG4fQ3P-eGOZUNZTowPtnjqq3GN91OE8fHa68lFOOg,8440
 jarvis/jarvis_utils/tag.py,sha256=YJHmuedLb7_AiqvKQetHr4R1FxyzIh7HN0RRkWMmYbU,429
-jarvis/jarvis_utils/utils.py,sha256=R3SS4v35HwgZxvQmCKrdUWdu4AeceRZ1gEHH8KK6ST8,5471
-jarvis_ai_assistant-0.1.168.dist-info/licenses/LICENSE,sha256=AGgVgQmTqFvaztRtCAXsAMryUymB18gZif7_l2e1XOg,1063
-jarvis_ai_assistant-0.1.168.dist-info/METADATA,sha256=WRoU1bmPCN83KHNzoSvU1sVfRsi1zDyS-hT46mvou6Q,14477
-jarvis_ai_assistant-0.1.168.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
-jarvis_ai_assistant-0.1.168.dist-info/entry_points.txt,sha256=cKz_9SEpOvElTubKPMZMAdskD4GHz-NyKWRNssIVAWE,973
-jarvis_ai_assistant-0.1.168.dist-info/top_level.txt,sha256=1BOxyWfzOP_ZXj8rVTDnNCJ92bBGB0rwq8N1PCpoMIs,7
-jarvis_ai_assistant-0.1.168.dist-info/RECORD,,
+jarvis/jarvis_utils/utils.py,sha256=iIcefLa1kvALkmQ19BLWDplmxrcOjtxWAgBIxrs8ytg,4439
+jarvis_ai_assistant-0.1.171.dist-info/licenses/LICENSE,sha256=AGgVgQmTqFvaztRtCAXsAMryUymB18gZif7_l2e1XOg,1063
+jarvis_ai_assistant-0.1.171.dist-info/METADATA,sha256=E1RImbgBwVokaITcf4AY5HxorOnwMihvWs063pBrorE,14546
+jarvis_ai_assistant-0.1.171.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
+jarvis_ai_assistant-0.1.171.dist-info/entry_points.txt,sha256=cKz_9SEpOvElTubKPMZMAdskD4GHz-NyKWRNssIVAWE,973
+jarvis_ai_assistant-0.1.171.dist-info/top_level.txt,sha256=1BOxyWfzOP_ZXj8rVTDnNCJ92bBGB0rwq8N1PCpoMIs,7
+jarvis_ai_assistant-0.1.171.dist-info/RECORD,,