jarvis-ai-assistant 0.1.128__py3-none-any.whl → 0.1.129__py3-none-any.whl

jarvis/jarvis_tools/read_code.py

@@ -0,0 +1,143 @@
+from typing import Dict, Any
+import os
+
+from yaspin import yaspin
+
+from jarvis.jarvis_utils.output import OutputType, PrettyOutput
+
+class ReadCodeTool:
+    name = "read_code"
+    description = "用于读取代码文件并在每行前添加行号的工具"
+    parameters = {
+        "type": "object",
+        "properties": {
+            "files": {
+                "type": "array",
+                "items": {
+                    "type": "object",
+                    "properties": {
+                        "path": {"type": "string"},
+                        "start_line": {"type": "number", "default": 1},
+                        "end_line": {"type": "number", "default": -1}
+                    },
+                    "required": ["path"]
+                },
+                "description": "要读取的文件列表"
+            }
+        },
+        "required": ["files"]
+    }
+
+    def _handle_single_file(self, filepath: str, start_line: int = 1, end_line: int = -1) -> Dict[str, Any]:
+        try:
+            abs_path = os.path.abspath(filepath)
+            with yaspin(text=f"正在读取文件: {abs_path}...", color="cyan") as spinner:
+                # 文件存在性检查
+                if not os.path.exists(abs_path):
+                    return {
+                        "success": False,
+                        "stdout": "",
+                        "stderr": f"文件不存在: {abs_path}"
+                    }
+                
+                # 文件大小限制检查（10MB）
+                if os.path.getsize(abs_path) > 10 * 1024 * 1024:
+                    return {
+                        "success": False,
+                        "stdout": "",
+                        "stderr": "文件过大 (>10MB)"
+                    }
+                
+                # 读取文件内容
+                with open(abs_path, 'r', encoding='utf-8') as f:
+                    lines = f.readlines()
+                
+                total_lines = len(lines)
+                
+                # 处理特殊值-1表示文件末尾
+                if end_line == -1:
+                    end_line = total_lines
+                else:
+                    end_line = max(1, min(end_line, total_lines)) if end_line >= 0 else total_lines + end_line + 1
+                
+                start_line = max(1, min(start_line, total_lines)) if start_line >= 0 else total_lines + start_line + 1
+                
+                if start_line > end_line:
+                    spinner.fail("❌")
+                    return {
+                        "success": False,
+                        "stdout": "",
+                        "stderr": f"无效的行范围 [{start_line}-{end_line}] (总行数: {total_lines})"
+                    }
+                
+                # 添加行号并构建输出内容
+                selected_lines = lines[start_line-1:end_line]
+                numbered_content = "".join(
+                    [f"{i:4d} | {line}" 
+                     for i, line in enumerate(selected_lines, start=start_line)]
+                )
+                
+                # 构建输出格式
+                output = (
+                    f"\n🔍 文件: {abs_path}\n"
+                    f"📄 原始行号: {start_line}-{end_line} (共{end_line - start_line + 1}行) | 显示行号: 1-{len(selected_lines)}\n\n"
+                    f"{numbered_content}\n"
+                    f"{'='*80}\n"
+                )
+                
+                spinner.ok("✅")
+                return {
+                    "success": True,
+                    "stdout": output,
+                    "stderr": ""
+                }
+                
+        except Exception as e:
+            PrettyOutput.print(str(e), OutputType.ERROR)
+            return {
+                "success": False,
+                "stdout": "",
+                "stderr": f"文件读取失败: {str(e)}"
+            }
+
+    def execute(self, args: Dict) -> Dict[str, Any]:
+        try:
+            if "files" not in args or not isinstance(args["files"], list):
+                return {
+                    "success": False,
+                    "stdout": "",
+                    "stderr": "参数中必须包含文件列表"
+                }
+            
+            all_outputs = []
+            overall_success = True
+            
+            for file_info in args["files"]:
+                if not isinstance(file_info, dict) or "path" not in file_info:
+                    continue
+                
+                result = self._handle_single_file(
+                    file_info["path"].strip(),
+                    file_info.get("start_line", 1),
+                    file_info.get("end_line", -1)
+                )
+                
+                if result["success"]:
+                    all_outputs.append(result["stdout"])
+                else:
+                    all_outputs.append(f"❌ {file_info['path']}: {result['stderr']}")
+                    overall_success = False
+                
+            return {
+                "success": overall_success,
+                "stdout": "\n".join(all_outputs),
+                "stderr": ""
+            }
+            
+        except Exception as e:
+            PrettyOutput.print(str(e), OutputType.ERROR)
+            return {
+                "success": False,
+                "stdout": "",
+                "stderr": f"代码读取失败: {str(e)}"
+            }

jarvis/jarvis_tools/registry.py

@@ -354,45 +354,41 @@ arguments:
             if result["success"]:
                 # If the output exceeds 4k characters, use a large model to summarize
                 if get_context_token_count(output) > self.max_token_count:
-                    with yaspin(text="正在总结输出...", color="yellow") as spinner:
-                        try:
-                            
-                            model = PlatformRegistry.get_global_platform_registry().get_normal_platform()
-                            
-                            # If the output exceeds the maximum context length, only take the last part
-                            max_count = self.max_token_count
-                            if get_context_token_count(output) > max_count:
-                                output_to_summarize = output[-max_count:]
-                                truncation_notice = f"\n(注意：由于输出过长，仅总结最后 {max_count} 个字符)"
-                            else:
-                                output_to_summarize = output
-                                truncation_notice = ""
-
-                            prompt = f"""请总结以下工具的执行结果，提取关键信息和重要结果。注意：
-    1. 保留所有重要的数值、路径、错误信息等
-    2. 保持结果的准确性
-    3. 用简洁的语言描述主要内容
-    4. 如果有错误信息，确保包含在总结中
-
-    工具名称: {name}
-    执行结果:
-    {output_to_summarize}
-
-    请提供总结:"""
-
-                            summary = model.chat_until_success(prompt)
-                            output = f"""--- 原始输出过长，以下是总结 ---{truncation_notice}
-
-    {summary}
-
-    --- 总结结束 ---"""
-                            spinner.text = "总结完成"
-                            spinner.ok("✅")
-                        except Exception as e:
-                            spinner.text = "总结失败"
-                            spinner.fail("❌")
-                            PrettyOutput.print(f"总结失败: {str(e)}", OutputType.ERROR)
-                            output = f"输出过长 ({len(output)} 字符)，建议查看原始输出。\n前300字符预览:\n{output[:300]}..."
+                    PrettyOutput.section("输出过长，正在总结...", OutputType.SYSTEM)
+                    try:
+                        
+                        model = PlatformRegistry.get_global_platform_registry().get_normal_platform()
+                        model.set_suppress_output(False)
+                        # If the output exceeds the maximum context length, only take the last part
+                        max_count = self.max_token_count
+                        if get_context_token_count(output) > max_count:
+                            output_to_summarize = output[-max_count:]
+                            truncation_notice = f"\n(注意：由于输出过长，仅总结最后 {max_count} 个字符)"
+                        else:
+                            output_to_summarize = output
+                            truncation_notice = ""
+
+                        prompt = f"""请总结以下工具的执行结果，提取关键信息和重要结果。注意：
+1. 保留所有重要的数值、路径、错误信息等
+2. 保持结果的准确性
+3. 用简洁的语言描述主要内容
+4. 如果有错误信息，确保包含在总结中
+
+工具名称: {name}
+执行结果:
+{output_to_summarize}
+
+请提供总结:"""
+
+                        summary = model.chat_until_success(prompt)
+                        output = f"""--- 原始输出过长，以下是总结 ---{truncation_notice}
+
+{summary}
+
+--- 总结结束 ---"""
+                    except Exception as e:
+                        PrettyOutput.print(f"总结失败: {str(e)}", OutputType.ERROR)
+                        output = f"输出过长 ({len(output)} 字符)，建议查看原始输出。\n前300字符预览:\n{output[:300]}..."
             return output
             
         except Exception as e:

jarvis/jarvis_tools/tool_generator.py

@@ -9,6 +9,8 @@ from yaspin import yaspin
 from jarvis.jarvis_platform.registry import PlatformRegistry
 
 class ToolGenerator:
+    """工具生成器类，用于自动创建与Jarvis系统集成的新工具"""
+    
     name = "tool_generator"
     description = "使用LLM自动生成与系统集成的新工具"
     parameters = {
@@ -31,8 +33,14 @@ class ToolGenerator:
     }
     
     def execute(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
-        """Generate and save a new tool using LLM"""
-        # Get fresh model instance for each execution
+        """
+        执行工具生成过程
+        Args:
+            arguments: 包含工具生成所需参数的字典
+        Returns:
+            包含执行结果的字典，包含success、stdout和stderr字段
+        """
+        # 获取代码生成平台实例
         model = PlatformRegistry.get_global_platform_registry().get_codegen_platform()
         
         try:
@@ -40,37 +48,37 @@ class ToolGenerator:
             description = arguments["description"]
             input_spec = arguments["input_spec"]
             
-            # Generate tool implementation using LLM
+            # 使用LLM生成工具实现代码
             with yaspin(text="正在生成工具...", color="cyan") as spinner:
                 prompt = self._create_prompt(tool_name, description, input_spec)
                 llm_response = model.chat_until_success(prompt)
                 spinner.text = "工具生成完成"
                 spinner.ok("✅")
             
-            # Extract implementation with more flexible parsing
+            # 从LLM响应中提取实现代码
             with yaspin(text="正在提取工具实现...", color="cyan") as spinner:
                 implementation = self._extract_code(llm_response)
                 if not implementation:
                     return {
                         "success": False,
                         "stdout": "",
-                        "stderr": "Could not extract valid Python code from LLM response"
+                        "stderr": "无法从LLM响应中提取有效的Python代码"
                     }
                 spinner.text = "工具实现提取完成"
                 spinner.ok("✅")
             
-            # Validate return value format
+            # 验证生成的工具代码是否符合返回值格式要求
             with yaspin(text="正在验证工具返回值格式...", color="cyan") as spinner:
                 if not self._validate_return_value_format(implementation):
                     return {
                         "success": False,
                         "stdout": "",
-                        "stderr": "Generated tool does not follow required return value format"
+                        "stderr": "生成的工具不符合要求的返回值格式"
                     }
                 spinner.text = "工具返回值格式验证完成"
                 spinner.ok("✅")
             
-            # Save the new tool
+            # 保存生成的新工具
             with yaspin(text="正在保存工具...", color="cyan") as spinner:
                 tools_dir = Path.home() / ".jarvis" / "tools"
                 tools_dir.mkdir(parents=True, exist_ok=True)
@@ -83,7 +91,7 @@ class ToolGenerator:
             
             return {
                 "success": True,
-                "stdout": f"Tool successfully generated at: {tool_file}",
+                "stdout": f"工具成功生成于: {tool_file}",
                 "stderr": ""
             }
             
@@ -91,11 +99,19 @@ class ToolGenerator:
             return {
                 "success": False,
                 "stdout": "",
-                "stderr": f"Tool generation failed: {str(e)}"
+                "stderr": f"工具生成失败: {str(e)}"
             }
     
     def _create_prompt(self, tool_name: str, description: str, input_spec: str) -> str:
-        """创建用于工具生成的LLM提示"""
+        """
+        创建用于工具生成的LLM提示
+        Args:
+            tool_name: 工具名称
+            description: 工具描述
+            input_spec: 输入规范
+        Returns:
+            格式化后的提示字符串
+        """
         example_code = '''
 <TOOL>
 from typing import Dict, Any
@@ -176,20 +192,32 @@ class CustomTool:
 '''
     
     def _extract_code(self, response: str) -> str:
-        """Flexibly extract Python code from LLM response"""
-        # Find the first occurrence of <TOOL> and </TOOL>
+        """
+        从LLM响应中提取Python代码
+        Args:
+            response: LLM的响应字符串
+        Returns:
+            提取到的Python代码字符串
+        """
+        # 查找第一个<TOOL>和</TOOL>标签之间的内容
         sm = re.search(r'<TOOL>(.*?)</TOOL>', response, re.DOTALL)
         if sm:
             return sm.group(1)
         return ""
     
     def _validate_return_value_format(self, code: str) -> bool:
-        """Validate that execute method returns correct format"""
+        """
+        验证execute方法的返回值格式是否正确
+        Args:
+            code: 要验证的代码字符串
+        Returns:
+            布尔值，表示格式是否正确
+        """
         required_fields = ["success", "stdout", "stderr"]
-        # Look for execute method
+        # 检查execute方法是否存在
         if "def execute(self, args: Dict) -> Dict:" not in code and \
            "def execute(self, args: Dict) -> Dict[str, Any]:" not in code:
             return False
         
-        # Check for required fields in return statement
-        return all(field in code for field in required_fields)
+        # 检查返回值中是否包含所有必需字段
+        return all(field in code for field in required_fields)

jarvis/jarvis_utils/__init__.py

@@ -1,24 +1,24 @@
 """
-Jarvis Utils Module
-This module provides utility functions and classes used throughout the Jarvis system.
-It includes various helper functions, configuration management, and common operations.
-The module is organized into several submodules:
-- config: Configuration management
-- embedding: Text embedding utilities
-- git_utils: Git repository operations
-- input: User input handling
-- methodology: Methodology management
-- output: Output formatting
-- utils: General utilities
+Jarvis工具模块
+该模块提供了Jarvis系统中使用的各种实用函数和类。
+包含多种辅助函数、配置管理和常见操作。
+该模块组织为以下几个子模块：
+- config: 配置管理
+- embedding: 文本嵌入工具
+- git_utils: Git仓库操作
+- input: 用户输入处理
+- methodology: 方法论管理
+- output: 输出格式化
+- utils: 通用工具
 """
 import os
 import colorama
 from rich.traceback import install as install_rich_traceback
-# Re-export from new modules
-# These imports are required for project functionality and may be used dynamically
-# Initialize colorama for cross-platform colored text
+# 从新模块重新导出
+# 这些导入是项目功能所必需的，可能会被动态使用
+# 初始化colorama以支持跨平台的彩色文本
 colorama.init()
-# Disable tokenizers parallelism to avoid issues with multiprocessing
+# 禁用tokenizers并行以避免多进程问题
 os.environ["TOKENIZERS_PARALLELISM"] = "false"
-# Install rich traceback handler for better error messages
-install_rich_traceback()
+# 安装rich traceback处理器以获得更好的错误信息
+install_rich_traceback()

jarvis/jarvis_utils/config.py

@@ -1,138 +1,174 @@
 import os
 """
-Configuration Management Module
-This module provides functions to retrieve various configuration settings for the Jarvis system.
-All configurations are read from environment variables with fallback default values.
-The module is organized into several categories:
-- System Configuration
-- Model Configuration
-- Execution Configuration
-- Text Processing Configuration
+配置管理模块
+该模块提供了获取Jarvis系统各种配置设置的函数。
+所有配置都从环境变量中读取，带有回退默认值。
+该模块组织为以下几个类别：
+- 系统配置
+- 模型配置
+- 执行配置
+- 文本处理配置
 """
 def get_max_token_count() -> int:
     """
-    Get the maximum token count for API requests.
+    获取API请求的最大token数量。
     
-    Returns:
-        int: Maximum token count, default is 131072 (128k)
+    返回：
+        int: 最大token数量，默认为131072（128k）
     """
     return int(os.getenv('JARVIS_MAX_TOKEN_COUNT', '131072'))  # 默认128k
     
 def get_thread_count() -> int:
     """
-    Get the number of threads to use for parallel processing.
+    获取用于并行处理的线程数。
     
-    Returns:
-        int: Thread count, default is 1
+    返回：
+        int: 线程数，默认为1
     """
     return int(os.getenv('JARVIS_THREAD_COUNT', '1'))  
 def dont_use_local_model() -> bool:
     """
-    Check if local models should be avoided.
+    检查是否应避免使用本地模型。
     
-    Returns:
-        bool: True if local models should not be used, default is False
+    返回：
+        bool: 如果不使用本地模型则返回True，默认为False
     """
     return os.getenv('JARVIS_DONT_USE_LOCAL_MODEL', 'false') == 'true'
     
 def is_auto_complete() -> bool:
     """
-    Check if auto-completion is enabled.
+    检查是否启用了自动补全功能。
     
-    Returns:
-        bool: True if auto-completion is enabled, default is False
+    返回：
+        bool: 如果启用了自动补全则返回True，默认为False
     """
     return os.getenv('JARVIS_AUTO_COMPLETE', 'false') == 'true'
     
 def is_use_methodology() -> bool:
     """
-    Check if methodology should be used.
+    检查是否应使用方法论。
     
-    Returns:
-        bool: True if methodology should be used, default is True
+    返回：
+        bool: 如果使用方法论则返回True，默认为True
     """
     return os.getenv('JARVIS_USE_METHODOLOGY', 'true') == 'true'
 def is_record_methodology() -> bool:
     """
-    Check if methodology should be recorded.
+    检查是否应记录方法论。
     
-    Returns:
-        bool: True if methodology should be recorded, default is True
+    返回：
+        bool: 如果记录方法论则返回True，默认为True
     """
     return os.getenv('JARVIS_RECORD_METHODOLOGY', 'true') == 'true'
 def is_need_summary() -> bool:
     """
-    Check if summary generation is required.
+    检查是否需要生成摘要。
     
-    Returns:
-        bool: True if summary is needed, default is True
+    返回：
+        bool: 如果需要摘要则返回True，默认为True
     """
     return os.getenv('JARVIS_NEED_SUMMARY', 'true') == 'true'
 def get_min_paragraph_length() -> int:
     """
-    Get the minimum paragraph length for text processing.
+    获取文本处理的最小段落长度。
     
-    Returns:
-        int: Minimum length in characters, default is 50
+    返回：
+        int: 最小字符长度，默认为50
     """
     return int(os.getenv('JARVIS_MIN_PARAGRAPH_LENGTH', '50'))
 def get_max_paragraph_length() -> int:
     """
-    Get the maximum paragraph length for text processing.
+    获取文本处理的最大段落长度。
     
-    Returns:
-        int: Maximum length in characters, default is 12800
+    返回：
+        int: 最大字符长度，默认为12800
     """
     return int(os.getenv('JARVIS_MAX_PARAGRAPH_LENGTH', '12800'))
 def get_shell_name() -> str:
     """
-    Get the system shell name.
+    获取系统shell名称。
     
-    Returns:
-        str: Shell name (e.g., bash, zsh), default is bash
+    返回：
+        str: Shell名称（例如bash, zsh），默认为bash
     """
     return os.getenv('SHELL', 'bash')
 def get_normal_platform_name() -> str:
     """
-    Get the platform name for normal operations.
+    获取正常操作的平台名称。
     
-    Returns:
-        str: Platform name, default is 'kimi'
+    返回：
+        str: 平台名称，默认为'kimi'
     """
     return os.getenv('JARVIS_PLATFORM', 'kimi')
 def get_normal_model_name() -> str:
     """
-    Get the model name for normal operations.
+    获取正常操作的模型名称。
     
-    Returns:
-        str: Model name, default is 'kimi'
+    返回：
+        str: 模型名称，默认为'kimi'
     """
     return os.getenv('JARVIS_MODEL', 'kimi')
 def get_codegen_platform_name() -> str:
+    """
+    获取代码生成的平台名称。
+    
+    返回：
+        str: 平台名称，默认为'kimi'
+    """
     return os.getenv('JARVIS_CODEGEN_PLATFORM', os.getenv('JARVIS_PLATFORM', 'kimi'))
 def get_codegen_model_name() -> str:
+    """
+    获取代码生成的模型名称。
+    
+    返回：
+        str: 模型名称，默认为'kimi'
+    """
     return os.getenv('JARVIS_CODEGEN_MODEL', os.getenv('JARVIS_MODEL', 'kimi'))
 def get_thinking_platform_name() -> str:
+    """
+    获取思考操作的平台名称。
+    
+    返回：
+        str: 平台名称，默认为'kimi'
+    """
     return os.getenv('JARVIS_THINKING_PLATFORM', os.getenv('JARVIS_PLATFORM', 'kimi'))
 def get_thinking_model_name() -> str:
+    """
+    获取思考操作的模型名称。
+    
+    返回：
+        str: 模型名称，默认为'kimi'
+    """
     return os.getenv('JARVIS_THINKING_MODEL', os.getenv('JARVIS_MODEL', 'kimi'))
 def get_cheap_platform_name() -> str:
+    """
+    获取低成本操作的平台名称。
+    
+    返回：
+        str: 平台名称，默认为'kimi'
+    """
     return os.getenv('JARVIS_CHEAP_PLATFORM', os.getenv('JARVIS_PLATFORM', 'kimi'))
 def get_cheap_model_name() -> str:
+    """
+    获取低成本操作的模型名称。
+    
+    返回：
+        str: 模型名称，默认为'kimi'
+    """
     return os.getenv('JARVIS_CHEAP_MODEL', os.getenv('JARVIS_MODEL', 'kimi'))
 def is_execute_tool_confirm() -> bool:
     """
-    Check if tool execution requires confirmation.
+    检查工具执行是否需要确认。
     
-    Returns:
-        bool: True if confirmation is required, default is False
+    返回：
+        bool: 如果需要确认则返回True，默认为False
     """
     return os.getenv('JARVIS_EXECUTE_TOOL_CONFIRM', 'false') == 'true'
 def is_confirm_before_apply_patch() -> bool:
     """
-    Check if patch application requires confirmation.
+    检查应用补丁前是否需要确认。
     
-    Returns:
-        bool: True if confirmation is required, default is False
+    返回：
+        bool: 如果需要确认则返回True，默认为False
     """
-    return os.getenv('JARVIS_CONFIRM_BEFORE_APPLY_PATCH', 'false') == 'true'
+    return os.getenv('JARVIS_CONFIRM_BEFORE_APPLY_PATCH', 'false') == 'true'