jarvis-ai-assistant 0.1.207__py3-none-any.whl → 0.1.209__py3-none-any.whl

jarvis/jarvis_tools/file_operation.py

@@ -1,238 +0,0 @@
-# -*- coding: utf-8 -*-
-import os
-from pathlib import Path
-from typing import Any, Dict
-
-from yaspin import yaspin  # type: ignore
-
-# 导入文件处理器
-from jarvis.jarvis_utils.file_processors import TextFileProcessor
-from jarvis.jarvis_utils.output import OutputType, PrettyOutput
-
-
-class FileOperationTool:
-    name = "file_operation"
-    description = "文件批量操作工具，可批量读写多个文件，仅支持文本文件，适用于需要同时处理多个文件的场景（读取配置文件、保存生成内容等）"
-    parameters = {
-        "type": "object",
-        "properties": {
-            "operation": {
-                "type": "string",
-                "enum": ["read", "write"],
-                "description": "要执行的文件操作类型（读取或写入多个文件）",
-            },
-            "files": {
-                "type": "array",
-                "items": {
-                    "type": "object",
-                    "properties": {
-                        "path": {"type": "string"},
-                        "content": {"type": "string"},
-                    },
-                    "required": ["path"],
-                },
-                "description": "要操作的文件列表",
-            },
-        },
-        "required": ["operation", "files"],
-    }
-
-    def _get_file_processor(self, file_path: str):
-        """获取适合处理指定文件的处理器"""
-        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]:
-        """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:
-                    if not os.path.exists(abs_path):
-                        return {
-                            "success": False,
-                            "stdout": "",
-                            "stderr": f"文件不存在: {abs_path}",
-                        }
-
-                    # 检查文件大小
-                    if os.path.getsize(abs_path) > 30 * 1024 * 1024:  # 30MB
-                        return {
-                            "success": False,
-                            "stdout": "",
-                            "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}",
-                        }
-
-                    # 特殊处理纯文本文件，支持行范围选择
-                    if processor == TextFileProcessor:
-                        try:
-                            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 = max(1, min(start_line, total_lines))
-                            end_line = max(1, min(end_line, total_lines))
-                            if end_line == -1:
-                                end_line = total_lines
-
-                            if start_line > end_line:
-                                spinner.text = "无效的行范围"
-                                spinner.fail("❌")
-                                error_msg = f"无效的行范围 [{start_line, end_line}] (文件总行数: {total_lines})"
-                                return {
-                                    "success": False,
-                                    "stdout": "",
-                                    "stderr": error_msg,
-                                }
-
-                            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)}",
-                            }
-                    else:
-                        return {
-                            "success": False,
-                            "stdout": "",
-                            "stderr": f"不支持的文件类型: {file_extension}",
-                        }
-
-                    # 构建输出信息
-                    output = f"{file_info}\n{content}" + "\n\n"
-
-                    spinner.text = f"文件读取完成: {abs_path}"
-                    spinner.ok("✅")
-
-                    if agent:
-                        files = agent.get_user_data("files")
-                        if files:
-                            files.append(abs_path)
-                        else:
-                            files = [abs_path]
-                        agent.set_user_data("files", files)
-
-                    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:
-                        f.write(content)
-                    spinner.text = f"文件写入完成: {abs_path}"
-                    spinner.ok("✅")
-                    return {
-                        "success": True,
-                        "stdout": f"文件写入成功: {abs_path}",
-                        "stderr": "",
-                    }
-            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)}",
-            }
-
-    def execute(self, args: Dict) -> Dict[str, Any]:
-        """Execute file operations for multiple files
-
-        Args:
-            args: Dictionary containing operation and files list
-
-        Returns:
-            Dict containing:
-                - success: Boolean indicating overall success
-                - stdout: Combined output of all operations as string
-                - stderr: Error message if any
-        """
-        try:
-            operation = args["operation"].strip()
-            agent = args.get("agent", None)
-            if "files" not in args or not isinstance(args["files"], list):
-                return {
-                    "success": False,
-                    "stdout": "",
-                    "stderr": "files参数是必需的，且必须是一个列表",
-                }
-
-            all_outputs = []
-            success = True
-
-            for file_info in args["files"]:
-                if not isinstance(file_info, dict) or "path" not in file_info:
-                    continue
-
-                content = file_info.get("content", "") if operation == "write" else ""
-                result = self._handle_single_file(
-                    operation,
-                    file_info["path"].strip(),
-                    content,
-                    file_info.get("start_line", 1),
-                    file_info.get("end_line", -1),
-                    agent,
-                )
-
-                if result["success"]:
-                    all_outputs.append(result["stdout"])
-                else:
-                    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)
-
-            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)}"}

jarvis/jarvis_utils/jarvis_history.py

@@ -1,98 +0,0 @@
-import glob
-import os
-from datetime import datetime
-from typing import Dict, List, Optional, Union
-
-import yaml
-
-
-class JarvisHistory:
-    def __init__(self):
-        self.records: List[Dict[str, str]] = []
-        self.current_file: Optional[str] = None
-
-    def start_record(self, data_dir: str) -> None:
-        """Start a new recording session with timestamped filename"""
-        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-        self.current_file = os.path.join(data_dir, f"history_{timestamp}.yaml")
-        self.records = []
-
-    def append_msg(self, role: str, msg: str) -> None:
-        """Append a message to current recording session"""
-        if not self.current_file:
-            raise RuntimeError("Recording not started. Call start_record first.")
-        self.records.append({"role": role, "message": msg})
-
-    def save_history(self, filename: str) -> None:
-        """Save recorded messages to YAML file"""
-
-        # Skip saving if records is empty
-        if not self.records:
-            return
-
-        # Ensure directory exists
-        os.makedirs(os.path.dirname(filename), exist_ok=True)
-
-        with open(filename, "w") as f:
-            yaml.safe_dump({"conversation": self.records}, f, allow_unicode=True)
-
-    def stop_record(self) -> None:
-        """Stop recording session and save messages"""
-        if not self.current_file:
-            raise RuntimeError("No recording session to stop.")
-
-        self.save_history(self.current_file)
-        self.current_file = None
-        self.records = []
-
-    @staticmethod
-    def export_history_to_markdown(
-        input_dir: str, output_file: str, max_files: Optional[int] = None
-    ) -> None:
-        """
-        Export all history files in the directory to a single markdown file
-
-        Args:
-            input_dir: Directory containing history YAML files
-            output_file: Path to output markdown file
-            max_files: Maximum number of history files to export (None for all)
-        """
-        # Find all history files in the directory
-        history_files = glob.glob(os.path.join(input_dir, "history_*.yaml"))
-
-        if not history_files:
-            raise FileNotFoundError(f"No history files found in {input_dir}")
-
-        # Sort files by modification time (newest first) and limit to max_files
-        history_files.sort(key=os.path.getmtime, reverse=True)
-        if max_files is not None:
-            history_files = history_files[:max_files]
-
-        # Ensure output directory exists
-        os.makedirs(os.path.dirname(output_file), exist_ok=True)
-
-        with open(output_file, "w", encoding="utf-8") as md_file:
-            md_file.write("# Jarvis Conversation History\n\n")
-
-            for history_file in sorted(history_files):
-                # Read YAML file
-                with open(history_file, "r", encoding="utf-8") as f:
-                    data = yaml.safe_load(f)
-
-                if not data or "conversation" not in data:
-                    continue
-
-                # Write file header with timestamp from filename
-                timestamp = os.path.basename(history_file)[
-                    8:-5
-                ]  # Extract timestamp from "history_YYYYMMDD_HHMMSS.yaml"
-                md_file.write(
-                    f"## Conversation at {timestamp[:4]}-{timestamp[4:6]}-{timestamp[6:8]} "
-                    f"{timestamp[9:11]}:{timestamp[11:13]}:{timestamp[13:15]}\n\n"
-                )
-
-                # Write conversation messages
-                for msg in data["conversation"]:
-                    md_file.write(f"**{msg['role']}**: {msg['message']}\n\n")
-
-                md_file.write("\n---\n\n")