jarvis-ai-assistant 0.1.193__py3-none-any.whl → 0.1.195__py3-none-any.whl

jarvis/jarvis_tools/file_analyzer.py

@@ -11,23 +11,23 @@ from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 
 class FileAnalyzerTool:
     name = "file_analyzer"
-    description = """分析文件内容并提取关键信息。支持的文件：文本文件、word文档、pdf文件、图片"""
+    description = (
+        """分析文件内容并提取关键信息。支持的文件：文本文件、word文档、pdf文件、图片"""
+    )
     parameters = {
         "type": "object",
         "properties": {
             "file_paths": {
                 "type": "array",
-                "items": {
-                    "type": "string"
-                },
-                "description": "要分析的文件路径列表"
+                "items": {"type": "string"},
+                "description": "要分析的文件路径列表",
             },
             "prompt": {
                 "type": "string",
-                "description": "分析文件的提示词，指导模型提取什么样的信息"
-            }
+                "description": "分析文件的提示词，指导模型提取什么样的信息",
+            },
         },
-        "required": ["file_paths", "prompt"]
+        "required": ["file_paths", "prompt"],
     }
 
     @staticmethod
@@ -46,7 +46,7 @@ class FileAnalyzerTool:
         try:
             file_paths = args["file_paths"]
             prompt = args["prompt"]
-            
+
             agent = args["agent"]
             agent.reset_tool_call_count()
 
@@ -57,30 +57,26 @@ class FileAnalyzerTool:
                     valid_files.append(file_path)
                 else:
                     PrettyOutput.print(f"文件不存在: {file_path}", OutputType.WARNING)
-            
+
             if not valid_files:
-                return {
-                    "success": False,
-                    "stdout": "",
-                    "stderr": "没有找到有效的文件"
-                }
+                return {"success": False, "stdout": "", "stderr": "没有找到有效的文件"}
 
             # 创建thinking平台实例
             platform = PlatformRegistry().get_thinking_platform()
-            
+
             if not platform:
                 return {
                     "success": False,
                     "stdout": "",
-                    "stderr": "无法创建thinking平台实例"
+                    "stderr": "无法创建thinking平台实例",
                 }
-            
+
             # 设置系统消息
             system_message = """你是一个文件分析助手。你的任务是分析提供的文件内容，并根据用户的提示提取关键信息。
 请保持客观，只关注文件中实际存在的内容。如果无法确定某些信息，请明确指出。
 请以结构化的方式组织你的回答，使用标题、列表和代码块等格式来提高可读性。"""
             platform.set_system_prompt(system_message)
-            
+
             # 上传文件
             with yaspin(Spinners.dots, text="正在上传文件...") as spinner:
                 try:
@@ -92,7 +88,7 @@ class FileAnalyzerTool:
                         return {
                             "success": False,
                             "stdout": "",
-                            "stderr": "文件上传失败"
+                            "stderr": "文件上传失败",
                         }
                     spinner.text = "文件上传成功"
                     spinner.ok("✅")
@@ -102,11 +98,11 @@ class FileAnalyzerTool:
                     return {
                         "success": False,
                         "stdout": "",
-                        "stderr": f"文件上传失败: {str(e)}"
+                        "stderr": f"文件上传失败: {str(e)}",
                     }
 
             platform.set_suppress_output(False)
-            
+
             # 构建分析请求
             analysis_request = f"""
 请根据以下提示分析这些文件。
@@ -120,19 +116,11 @@ class FileAnalyzerTool:
                     analysis_result = platform.chat_until_success(analysis_request)
                 spinner.text = "分析完成"
                 spinner.ok("✅")
-            
+
             # 清理会话
             platform.delete_chat()
-            
-            return {
-                "success": True,
-                "stdout": analysis_result,
-                "stderr": ""
-            }
+
+            return {"success": True, "stdout": analysis_result, "stderr": ""}
 
         except Exception as e:
-            return {
-                "success": False,
-                "stdout": "",
-                "stderr": f"文件分析失败: {str(e)}"
-            }
+            return {"success": False, "stdout": "", "stderr": f"文件分析失败: {str(e)}"}

jarvis/jarvis_tools/file_operation.py

@@ -19,7 +19,7 @@ class FileOperationTool:
             "operation": {
                 "type": "string",
                 "enum": ["read", "write"],
-                "description": "要执行的文件操作类型（读取或写入多个文件）"
+                "description": "要执行的文件操作类型（读取或写入多个文件）",
             },
             "files": {
                 "type": "array",
@@ -27,41 +27,48 @@ class FileOperationTool:
                     "type": "object",
                     "properties": {
                         "path": {"type": "string"},
-                        "content": {"type": "string"}
+                        "content": {"type": "string"},
                     },
-                    "required": ["path"]
+                    "required": ["path"],
                 },
-                "description": "要操作的文件列表"
-            }
+                "description": "要操作的文件列表",
+            },
         },
-        "required": ["operation", "files"]
+        "required": ["operation", "files"],
     }
 
     def _get_file_processor(self, file_path: str):
         """获取适合处理指定文件的处理器"""
-        processors = [
-            TextFileProcessor  # 文本文件处理器(放在最后作为兜底)
-        ]
-        
+        processors = [TextFileProcessor]  # 文本文件处理器(放在最后作为兜底)
+
         for processor in processors:
             if processor.can_handle(file_path):
                 return processor
-        
+
         return None  # 如果没有合适的处理器，返回None
-    
-    def _handle_single_file(self, operation: str, filepath: str, content: str = "",
-                          start_line: int = 1, end_line: int = -1, agent: Any = None) -> Dict[str, Any]:
+
+    def _handle_single_file(
+        self,
+        operation: str,
+        filepath: str,
+        content: str = "",
+        start_line: int = 1,
+        end_line: int = -1,
+        agent: Any = None,
+    ) -> Dict[str, Any]:
         """Handle operations for a single file"""
         try:
             abs_path = os.path.abspath(filepath)
-            
+
             if operation == "read":
-                with yaspin(text=f"正在读取文件: {abs_path}...", color="cyan") as spinner:
+                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}"
+                            "stderr": f"文件不存在: {abs_path}",
                         }
 
                     # 检查文件大小
@@ -69,30 +76,40 @@ class FileOperationTool:
                         return {
                             "success": False,
                             "stdout": "",
-                            "stderr": "文件过大 (>30MB)，无法处理"
+                            "stderr": "文件过大 (>30MB)，无法处理",
                         }
-                    
+
                     file_extension = Path(abs_path).suffix.lower()
-                    
+
                     # 获取文件处理器
                     processor = self._get_file_processor(abs_path)
-                    
+
                     if processor is None:
                         return {
                             "success": False,
                             "stdout": "",
-                            "stderr": f"不支持的文件类型: {file_extension}"
+                            "stderr": f"不支持的文件类型: {file_extension}",
                         }
-                    
+
                     # 特殊处理纯文本文件，支持行范围选择
                     if processor == TextFileProcessor:
                         try:
-                            with open(abs_path, 'r', encoding='utf-8', errors="ignore") as f:
+                            with open(
+                                abs_path, "r", encoding="utf-8", errors="ignore"
+                            ) as f:
                                 lines = f.readlines()
 
                             total_lines = len(lines)
-                            start_line = start_line if start_line >= 0 else total_lines + start_line + 1
-                            end_line = end_line if end_line >= 0 else total_lines + end_line + 1
+                            start_line = (
+                                start_line
+                                if start_line >= 0
+                                else total_lines + start_line + 1
+                            )
+                            end_line = (
+                                end_line
+                                if end_line >= 0
+                                else total_lines + end_line + 1
+                            )
                             start_line = max(1, min(start_line, total_lines))
                             end_line = max(1, min(end_line, total_lines))
                             if end_line == -1:
@@ -105,27 +122,27 @@ class FileOperationTool:
                                 return {
                                     "success": False,
                                     "stdout": "",
-                                    "stderr": error_msg
+                                    "stderr": error_msg,
                                 }
 
-                            content = "".join(lines[start_line - 1:end_line])
+                            content = "".join(lines[start_line - 1 : end_line])
                             file_info = f"\n文件: {abs_path} (文本文件)\n行: [{start_line}-{end_line}]/{total_lines}"
                         except Exception as e:
                             return {
                                 "success": False,
                                 "stdout": "",
-                                "stderr": f"读取文本文件失败: {str(e)}"
+                                "stderr": f"读取文本文件失败: {str(e)}",
                             }
                     else:
                         return {
                             "success": False,
                             "stdout": "",
-                            "stderr": f"不支持的文件类型: {file_extension}"
+                            "stderr": f"不支持的文件类型: {file_extension}",
                         }
-                    
+
                     # 构建输出信息
                     output = f"{file_info}\n{content}" + "\n\n"
-                    
+
                     spinner.text = f"文件读取完成: {abs_path}"
                     spinner.ok("✅")
 
@@ -136,36 +153,32 @@ class FileOperationTool:
                         else:
                             files = [abs_path]
                         agent.set_user_data("files", files)
-                        
-                    return {
-                        "success": True,
-                        "stdout": output,
-                        "stderr": ""
-                    }
+
+                    return {"success": True, "stdout": output, "stderr": ""}
             elif operation == "write":
-                with yaspin(text=f"正在写入文件: {abs_path}...", color="cyan") as spinner:
-                    os.makedirs(os.path.dirname(os.path.abspath(abs_path)), exist_ok=True)
-                    with open(abs_path, 'w', encoding='utf-8', errors="ignore") as f:
+                with yaspin(
+                    text=f"正在写入文件: {abs_path}...", color="cyan"
+                ) as spinner:
+                    os.makedirs(
+                        os.path.dirname(os.path.abspath(abs_path)), exist_ok=True
+                    )
+                    with open(abs_path, "w", encoding="utf-8", errors="ignore") as f:
                         f.write(content)
                     spinner.text = f"文件写入完成: {abs_path}"
                     spinner.ok("✅")
                     return {
                         "success": True,
                         "stdout": f"文件写入成功: {abs_path}",
-                        "stderr": ""
+                        "stderr": "",
                     }
-            return {
-                "success": False,
-                "stdout": "",
-                "stderr": f"未知操作: {operation}"
-            }
+            return {"success": False, "stdout": "", "stderr": f"未知操作: {operation}"}
 
         except Exception as e:
             PrettyOutput.print(str(e), OutputType.ERROR)
             return {
                 "success": False,
                 "stdout": "",
-                "stderr": f"文件操作失败 {abs_path}: {str(e)}"
+                "stderr": f"文件操作失败 {abs_path}: {str(e)}",
             }
 
     def execute(self, args: Dict) -> Dict[str, Any]:
@@ -187,7 +200,7 @@ class FileOperationTool:
                 return {
                     "success": False,
                     "stdout": "",
-                    "stderr": "files参数是必需的，且必须是一个列表"
+                    "stderr": "files参数是必需的，且必须是一个列表",
                 }
 
             all_outputs = []
@@ -204,28 +217,22 @@ class FileOperationTool:
                     content,
                     file_info.get("start_line", 1),
                     file_info.get("end_line", -1),
-                    agent
+                    agent,
                 )
 
                 if result["success"]:
                     all_outputs.append(result["stdout"])
                 else:
-                    all_outputs.append(f"处理文件 {file_info['path']} 时出错: {result['stderr']}")
+                    all_outputs.append(
+                        f"处理文件 {file_info['path']} 时出错: {result['stderr']}"
+                    )
                 success = success and result["success"]
 
             # Combine all outputs with separators
-            combined_output = "\n\n" + "="*80 + "\n\n".join(all_outputs)
+            combined_output = "\n\n" + "=" * 80 + "\n\n".join(all_outputs)
 
-            return {
-                "success": success,
-                "stdout": combined_output,
-                "stderr": ""
-            }
+            return {"success": success, "stdout": combined_output, "stderr": ""}
 
         except Exception as e:
             PrettyOutput.print(str(e), OutputType.ERROR)
-            return {
-                "success": False,
-                "stdout": "",
-                "stderr": f"文件操作失败: {str(e)}"
-            }
+            return {"success": False, "stdout": "", "stderr": f"文件操作失败: {str(e)}"}

jarvis/jarvis_tools/generate_new_tool.py

@@ -135,8 +135,6 @@ class generate_new_tool:
 
             # 检查并安装缺失的依赖
             try:
-                import re
-
                 required_packages = set()
 
                 # 从代码中提取import语句

jarvis/jarvis_tools/methodology.py

@@ -19,19 +19,19 @@ class MethodologyTool:
             "operation": {
                 "type": "string",
                 "description": "操作类型（delete/update/add）",
-                "enum": ["delete", "update", "add"]
+                "enum": ["delete", "update", "add"],
             },
             "problem_type": {
                 "type": "string",
-                "description": "问题类型，例如：部署开源项目、生成提交信息"
+                "description": "问题类型，例如：部署开源项目、生成提交信息",
             },
             "content": {
                 "type": "string",
                 "description": "方法论内容（更新和添加时必填）",
-                "optional": True
-            }
+                "optional": True,
+            },
         },
-        "required": ["operation", "problem_type"]
+        "required": ["operation", "problem_type"],
     }
 
     def __init__(self):
@@ -58,10 +58,9 @@ class MethodologyTool:
             str: 方法论文件路径
         """
         # 使用MD5哈希作为文件名，避免文件名中的特殊字符
-        safe_filename = hashlib.md5(problem_type.encode('utf-8')).hexdigest()
+        safe_filename = hashlib.md5(problem_type.encode("utf-8")).hexdigest()
         return os.path.join(self.methodology_dir, f"{safe_filename}.json")
 
-
     def execute(self, args: Dict[str, Any]) -> Dict[str, Any]:
         """执行管理方法论的操作
 
@@ -82,7 +81,7 @@ class MethodologyTool:
             return {
                 "success": False,
                 "stdout": "",
-                "stderr": "缺少必要参数: operation和problem_type"
+                "stderr": "缺少必要参数: operation和problem_type",
             }
 
         try:
@@ -96,13 +95,13 @@ class MethodologyTool:
                     return {
                         "success": True,
                         "stdout": f"已删除问题类型'{problem_type}'对应的方法论",
-                        "stderr": ""
+                        "stderr": "",
                     }
                 else:
                     return {
                         "success": False,
                         "stdout": "",
-                        "stderr": f"未找到问题类型'{problem_type}'对应的方法论"
+                        "stderr": f"未找到问题类型'{problem_type}'对应的方法论",
                     }
 
             elif operation in ["update", "add"]:
@@ -110,7 +109,7 @@ class MethodologyTool:
                     return {
                         "success": False,
                         "stdout": "",
-                        "stderr": "需要提供方法论内容"
+                        "stderr": "需要提供方法论内容",
                     }
 
                 # 确保目录存在
@@ -121,10 +120,12 @@ class MethodologyTool:
 
                 # 保存方法论到单独的文件
                 with open(file_path, "w", encoding="utf-8", errors="ignore") as f:
-                    json.dump({
-                        "problem_type": problem_type,
-                        "content": content
-                    }, f, ensure_ascii=False, indent=2)
+                    json.dump(
+                        {"problem_type": problem_type, "content": content},
+                        f,
+                        ensure_ascii=False,
+                        indent=2,
+                    )
 
                 PrettyOutput.print(f"方法论已保存到 {file_path}", OutputType.INFO)
 
@@ -132,20 +133,15 @@ class MethodologyTool:
                 return {
                     "success": True,
                     "stdout": f"{action}了问题类型'{problem_type}'对应的方法论",
-                    "stderr": ""
+                    "stderr": "",
                 }
 
             else:
                 return {
                     "success": False,
                     "stdout": "",
-                    "stderr": f"不支持的操作类型: {operation}"
+                    "stderr": f"不支持的操作类型: {operation}",
                 }
 
         except Exception as e:
-            return {
-                "success": False,
-                "stdout": "",
-                "stderr": f"执行失败: {str(e)}"
-            }
-
+            return {"success": False, "stdout": "", "stderr": f"执行失败: {str(e)}"}

jarvis/jarvis_tools/read_code.py

@@ -21,17 +21,19 @@ class ReadCodeTool:
                     "properties": {
                         "path": {"type": "string"},
                         "start_line": {"type": "number", "default": 1},
-                        "end_line": {"type": "number", "default": -1}
+                        "end_line": {"type": "number", "default": -1},
                     },
-                    "required": ["path"]
+                    "required": ["path"],
                 },
-                "description": "要读取的文件列表"
+                "description": "要读取的文件列表",
             }
         },
-        "required": ["files"]
+        "required": ["files"],
     }
 
-    def _handle_single_file(self, filepath: str, start_line: int = 1, end_line: int = -1, agent: Any = None) -> Dict[str, Any]:
+    def _handle_single_file(
+        self, filepath: str, start_line: int = 1, end_line: int = -1, agent: Any = None
+    ) -> Dict[str, Any]:
         """处理单个文件的读取操作
 
         Args:
@@ -50,7 +52,7 @@ class ReadCodeTool:
                     return {
                         "success": False,
                         "stdout": "",
-                        "stderr": f"文件不存在: {abs_path}"
+                        "stderr": f"文件不存在: {abs_path}",
                     }
 
                 # 文件大小限制检查（10MB）
@@ -58,45 +60,55 @@ class ReadCodeTool:
                     return {
                         "success": False,
                         "stdout": "",
-                        "stderr": "文件过大 (>10MB)"
+                        "stderr": "文件过大 (>10MB)",
                     }
 
                 # 读取文件内容
-                with open(abs_path, 'r', encoding='utf-8', errors="ignore") as f:
+                with open(abs_path, "r", encoding="utf-8", errors="ignore") as f:
                     lines = f.readlines()
 
                 total_lines = len(lines)
-                
+
                 # 处理空文件情况
                 if total_lines == 0:
                     spinner.ok("✅")
                     return {
                         "success": True,
                         "stdout": f"\n🔍 文件: {abs_path}\n📄 文件为空 (0行)\n",
-                        "stderr": ""
+                        "stderr": "",
                     }
 
                 # 处理特殊值-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
+                    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})"
+                        "stderr": f"无效的行范围 [{start_line}-{end_line}] (总行数: {total_lines})",
                     }
 
                 # 添加行号并构建输出内容
-                selected_lines = lines[start_line-1:end_line]
+                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)]
+                    [
+                        f"{i:4d}:{line}"
+                        for i, line in enumerate(selected_lines, start=start_line)
+                    ]
                 )
 
                 # 构建输出格式
@@ -116,19 +128,11 @@ class ReadCodeTool:
                         files = [abs_path]
                     agent.set_user_data("files", files)
 
-                return {
-                    "success": True,
-                    "stdout": output,
-                    "stderr": ""
-                }
+                return {"success": True, "stdout": output, "stderr": ""}
 
         except Exception as e:
             PrettyOutput.print(str(e), OutputType.ERROR)
-            return {
-                "success": False,
-                "stdout": "",
-                "stderr": f"文件读取失败: {str(e)}"
-            }
+            return {"success": False, "stdout": "", "stderr": f"文件读取失败: {str(e)}"}
 
     def execute(self, args: Dict) -> Dict[str, Any]:
         """执行代码读取操作
@@ -145,7 +149,7 @@ class ReadCodeTool:
                 return {
                     "success": False,
                     "stdout": "",
-                    "stderr": "参数中必须包含文件列表"
+                    "stderr": "参数中必须包含文件列表",
                 }
 
             all_outputs = []
@@ -159,7 +163,7 @@ class ReadCodeTool:
                     file_info["path"].strip(),
                     file_info.get("start_line", 1),
                     file_info.get("end_line", -1),
-                    agent
+                    agent,
                 )
 
                 if result["success"]:
@@ -171,13 +175,9 @@ class ReadCodeTool:
             return {
                 "success": overall_success,
                 "stdout": "\n".join(all_outputs),
-                "stderr": ""
+                "stderr": "",
             }
 
         except Exception as e:
             PrettyOutput.print(str(e), OutputType.ERROR)
-            return {
-                "success": False,
-                "stdout": "",
-                "stderr": f"代码读取失败: {str(e)}"
-            }
+            return {"success": False, "stdout": "", "stderr": f"代码读取失败: {str(e)}"}