jarvis-ai-assistant 0.1.222__py3-none-any.whl → 0.7.0__py3-none-any.whl

jarvis/jarvis_stats/visualizer.py

@@ -0,0 +1,282 @@
+"""
+统计数据可视化模块
+
+提供终端图形化展示功能
+"""
+
+import os
+import io
+from typing import Dict, List, Optional, Any
+from collections import OrderedDict
+import plotext as plt
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+from rich import box
+
+
+class StatsVisualizer:
+    """统计数据可视化类"""
+
+    def __init__(self, width: Optional[int] = None, height: Optional[int] = None):
+        """
+        初始化可视化器
+
+        Args:
+            width: 图表宽度，默认为终端宽度-10
+            height: 图表高度，默认为20
+        """
+        self.width = width or self._get_terminal_width() - 10
+        self.height = height or 20
+
+        # 确保最小尺寸
+        self.width = max(self.width, 40)
+        self.height = max(self.height, 10)
+
+        # 初始化Rich Console
+        self.console = Console()
+
+    def _get_terminal_width(self) -> int:
+        """获取终端宽度"""
+        try:
+            columns = os.get_terminal_size().columns
+            return columns
+        except Exception:
+            return 80
+
+    def plot_line_chart(
+        self,
+        data: Dict[str, float],
+        title: str = "",
+        unit: Optional[str] = None,
+        show_values: bool = True,
+    ) -> str:
+        """
+        使用 plotext 绘制折线图
+        """
+        if not data:
+            return "无数据可显示"
+
+        sorted_data = OrderedDict(sorted(data.items()))
+        labels = list(sorted_data.keys())
+        values = list(sorted_data.values())
+
+        plt.clf()
+        plt.plotsize(self.width, self.height)
+        plt.plot(values)
+        plt.xticks(range(len(labels)), labels)
+        if title:
+            plt.title(title)
+        if unit:
+            plt.ylabel(unit)
+
+        chart = plt.build()
+
+        if show_values and values:
+            min_val = min(values)
+            max_val = max(values)
+            avg_val = sum(values) / len(values)
+            stats_info_text = (
+                f"最小值: {min_val:.2f}, 最大值: {max_val:.2f}, 平均值: {avg_val:.2f}"
+            )
+
+            # 使用StringIO捕获Panel输出
+            string_io = io.StringIO()
+            temp_console = Console(file=string_io, width=self.width)
+            temp_console.print(
+                Panel(
+                    stats_info_text,
+                    title="[bold]数据统计[/bold]",
+                    expand=False,
+                    style="dim",
+                    border_style="blue",
+                )
+            )
+            stats_panel_str = string_io.getvalue()
+
+            return chart + "\n" + stats_panel_str.strip()
+        return chart
+
+    def plot_bar_chart(
+        self,
+        data: Dict[str, float],
+        title: str = "",
+        unit: Optional[str] = None,
+        horizontal: bool = False,
+    ) -> str:
+        """
+        使用 plotext 绘制柱状图
+        """
+        if not data:
+            return "无数据可显示"
+
+        labels = list(data.keys())
+        values = list(data.values())
+
+        plt.clf()
+        plt.plotsize(self.width, self.height)
+
+        if horizontal:
+            plt.bar(labels, values, orientation="horizontal")
+        else:
+            plt.bar(labels, values)
+        if title:
+            plt.title(title)
+        if unit:
+            plt.ylabel(unit)
+
+        return plt.build()
+
+    def show_summary(
+        self,
+        aggregated_data: Dict[str, Dict[str, Any]],
+        metric_name: str,
+        unit: Optional[str] = None,
+        tags_filter: Optional[Dict[str, str]] = None,
+    ) -> str:
+        """
+        显示数据摘要
+
+        Args:
+            aggregated_data: 聚合后的数据
+            metric_name: 指标名称
+            unit: 单位
+            tags_filter: 标签过滤条件
+
+        Returns:
+            摘要字符串（用于兼容性，实际会直接打印）
+        """
+        if not aggregated_data:
+            self.console.print("[yellow]无数据可显示[/yellow]")
+            return "无数据可显示"
+
+        # 创建表格
+        table = Table(title=f"{metric_name} 统计摘要", box=box.ROUNDED)
+
+        # 添加列
+        table.add_column("时间", justify="center", style="cyan")
+        table.add_column("计数", justify="right", style="green")
+        table.add_column("总和", justify="right", style="yellow")
+        table.add_column("平均", justify="right", style="yellow")
+        table.add_column("最小", justify="right", style="blue")
+        table.add_column("最大", justify="right", style="red")
+
+        # 添加数据行
+        for time_key, stats in sorted(aggregated_data.items()):
+            table.add_row(
+                time_key,
+                str(stats["count"]),
+                f"{stats['sum']:.2f}",
+                f"{stats['avg']:.2f}",
+                f"{stats['min']:.2f}",
+                f"{stats['max']:.2f}",
+            )
+
+        # 显示表格
+        self.console.print(table)
+
+        # 显示单位信息
+        if unit:
+            self.console.print(f"\n[dim]单位: {unit}[/dim]")
+
+        # 显示过滤条件
+        if tags_filter:
+            filter_str = ", ".join([f"{k}={v}" for k, v in tags_filter.items()])
+            self.console.print(f"[dim]过滤条件: {filter_str}[/dim]")
+
+        return ""  # 返回空字符串，实际输出已经通过console打印
+
+    def show_table(
+        self,
+        records: List[Dict[str, Any]],
+        metric_name: str,
+        unit: Optional[str] = None,
+        start_time: Optional[str] = None,
+        end_time: Optional[str] = None,
+        tags_filter: Optional[Dict[str, str]] = None,
+    ) -> str:
+        """
+        使用Rich Table显示数据记录
+
+        Args:
+            records: 数据记录列表
+            metric_name: 指标名称
+            unit: 单位
+            start_time: 开始时间
+            end_time: 结束时间
+            tags_filter: 标签过滤条件
+
+        Returns:
+            空字符串（实际通过console打印）
+        """
+        if not records:
+            self.console.print(f"[yellow]没有找到指标 '{metric_name}' 的数据[/yellow]")
+            return ""
+
+        # 创建表格
+        table = Table(title=f"指标: {metric_name}", box=box.ROUNDED)
+
+        # 添加列
+        table.add_column("时间", style="cyan", no_wrap=True)
+        table.add_column("值", justify="right", style="yellow")
+        table.add_column("标签", style="dim")
+
+        # 只显示最近的20条记录
+        display_records = records[-20:] if len(records) > 20 else records
+
+        # 添加数据行
+        from datetime import datetime
+
+        for record in display_records:
+            timestamp = datetime.fromisoformat(record["timestamp"])
+            time_str = timestamp.strftime("%Y-%m-%d %H:%M:%S")
+            value = f"{record['value']:.2f}"
+            tags_str = ", ".join(f"{k}={v}" for k, v in record.get("tags", {}).items())
+
+            table.add_row(time_str, value, tags_str)
+
+        # 显示表格
+        self.console.print(table)
+
+        # 显示元信息
+        info_items = []
+        if unit:
+            info_items.append(f"单位: {unit}")
+        if start_time and end_time:
+            info_items.append(f"时间范围: [cyan]{start_time}[/] ~ [cyan]{end_time}[/]")
+        if tags_filter:
+            filter_str = ", ".join([f"{k}={v}" for k, v in tags_filter.items()])
+            info_items.append(f"过滤条件: {filter_str}")
+
+        if info_items:
+            self.console.print(
+                Panel(
+                    " | ".join(info_items),
+                    title="[bold]查询详情[/bold]",
+                    expand=False,
+                    style="dim",
+                    border_style="green",
+                )
+            )
+
+        # 统计信息
+        if len(records) > 0:
+            values = [r["value"] for r in records]
+            stats_info_text = (
+                f"总记录数: {len(records)} | "
+                f"显示: {len(display_records)} | "
+                f"最小值: {min(values):.2f} | "
+                f"最大值: {max(values):.2f} | "
+                f"平均值: {sum(values)/len(values):.2f}"
+            )
+            self.console.print(
+                Panel(
+                    stats_info_text,
+                    title="[bold]数据统计[/bold]",
+                    expand=False,
+                    style="dim",
+                    border_style="blue",
+                )
+            )
+
+        return ""

jarvis/jarvis_tools/ask_user.py

@@ -34,6 +34,7 @@ class AskUserTool:
 
             # 获取agent对象并重置工具调用计数
             agent = args["agent"]
+            agent.set_run_input_handlers_next_turn(True)
 
             # 显示问题给用户
             PrettyOutput.print(f"问题: {question}", OutputType.SYSTEM)

jarvis/jarvis_tools/base.py

@@ -6,7 +6,14 @@ from typing import Any, Callable, Dict
 class Tool:
     """工具类，用于封装工具的基本信息和执行方法"""
 
-    def __init__(self, name: str, description: str, parameters: Dict, func: Callable):
+    def __init__(
+        self,
+        name: str,
+        description: str,
+        parameters: Dict,
+        func: Callable,
+        protocol_version: str = "1.0",
+    ):
         """
         初始化工具对象
 
@@ -15,11 +22,13 @@ class Tool:
             description (str): 工具描述
             parameters (Dict): 工具参数定义
             func (Callable): 工具执行函数
+            protocol_version (str): 工具协议版本，默认"1.0"；支持"1.0"或"2.0"
         """
         self.name = name
         self.description = description
         self.parameters = parameters
         self.func = func
+        self.protocol_version = protocol_version
 
     def to_dict(self) -> Dict:
         """将工具对象转换为字典格式，主要用于序列化"""
@@ -39,4 +48,11 @@ class Tool:
         返回:
             Dict[str, Any]: 工具执行结果
         """
-        return self.func(arguments)
+        try:
+            return self.func(arguments)
+        except Exception as e:
+            return {
+                "success": False,
+                "stderr": f"工具 {self.name} 执行失败: {str(e)}",
+                "stdout": "",
+            }

jarvis/jarvis_tools/clear_memory.py

@@ -0,0 +1,239 @@
+# -*- coding: utf-8 -*-
+import json
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from jarvis.jarvis_utils.config import get_data_dir
+from jarvis.jarvis_utils.output import OutputType, PrettyOutput
+from jarvis.jarvis_utils.globals import (
+    clear_short_term_memories,
+    short_term_memories,
+)
+
+
+class ClearMemoryTool:
+    """清除记忆工具，用于批量清除指定的记忆"""
+
+    name = "clear_memory"
+    description = """批量清除指定的记忆。
+    
+    支持的清除方式：
+    1. 按记忆类型清除所有记忆
+    2. 按标签清除特定记忆
+    3. 按记忆ID清除单个记忆
+    
+    支持的记忆类型：
+    - project_long_term: 项目长期记忆
+    - global_long_term: 全局长期记忆
+    - short_term: 短期记忆
+    - all: 所有类型的记忆
+    
+    注意：清除操作不可恢复，请谨慎使用
+    """
+
+    parameters = {
+        "type": "object",
+        "properties": {
+            "memory_types": {
+                "type": "array",
+                "items": {
+                    "type": "string",
+                    "enum": [
+                        "project_long_term",
+                        "global_long_term",
+                        "short_term",
+                        "all",
+                    ],
+                },
+                "description": "要清除的记忆类型列表",
+            },
+            "tags": {
+                "type": "array",
+                "items": {"type": "string"},
+                "description": "要清除的记忆标签列表（可选，如果指定则只清除带有这些标签的记忆）",
+            },
+            "memory_ids": {
+                "type": "array",
+                "items": {"type": "string"},
+                "description": "要清除的具体记忆ID列表（可选）",
+            },
+            "confirm": {
+                "type": "boolean",
+                "description": "确认清除操作（必须为true才会执行清除）",
+                "default": False,
+            },
+        },
+        "required": ["memory_types", "confirm"],
+    }
+
+    def __init__(self):
+        """初始化清除记忆工具"""
+        self.project_memory_dir = Path(".jarvis/memory")
+        self.global_memory_dir = Path(get_data_dir()) / "memory"
+
+    def _get_memory_dir(self, memory_type: str) -> Path:
+        """根据记忆类型获取存储目录"""
+        if memory_type == "project_long_term":
+            return self.project_memory_dir
+        elif memory_type in ["global_long_term", "short_term"]:
+            return self.global_memory_dir / memory_type
+        else:
+            raise ValueError(f"未知的记忆类型: {memory_type}")
+
+    def _clear_short_term_memories(
+        self, tags: Optional[List[str]] = None, memory_ids: Optional[List[str]] = None
+    ) -> Dict[str, int]:
+        """清除短期记忆"""
+        global short_term_memories
+
+        initial_count = len(short_term_memories)
+        removed_count = 0
+
+        if memory_ids:
+            # 按ID清除
+            new_memories = []
+            for memory in short_term_memories:
+                if memory.get("id") not in memory_ids:
+                    new_memories.append(memory)
+                else:
+                    removed_count += 1
+            short_term_memories[:] = new_memories
+        elif tags:
+            # 按标签清除
+            new_memories = []
+            for memory in short_term_memories:
+                memory_tags = memory.get("tags", [])
+                if not any(tag in memory_tags for tag in tags):
+                    new_memories.append(memory)
+                else:
+                    removed_count += 1
+            short_term_memories[:] = new_memories
+        else:
+            # 清除所有
+            clear_short_term_memories()
+            removed_count = initial_count
+
+        return {"total": initial_count, "removed": removed_count}
+
+    def _clear_long_term_memories(
+        self,
+        memory_type: str,
+        tags: Optional[List[str]] = None,
+        memory_ids: Optional[List[str]] = None,
+    ) -> Dict[str, int]:
+        """清除长期记忆"""
+        memory_dir = self._get_memory_dir(memory_type)
+
+        if not memory_dir.exists():
+            return {"total": 0, "removed": 0}
+
+        total_count = 0
+        removed_count = 0
+
+        # 获取所有记忆文件
+        memory_files = list(memory_dir.glob("*.json"))
+        total_count = len(memory_files)
+
+        for memory_file in memory_files:
+            try:
+                # 读取记忆内容
+                with open(memory_file, "r", encoding="utf-8") as f:
+                    memory_data = json.load(f)
+
+                should_remove = False
+
+                if memory_ids:
+                    # 按ID判断
+                    if memory_data.get("id") in memory_ids:
+                        should_remove = True
+                elif tags:
+                    # 按标签判断
+                    memory_tags = memory_data.get("tags", [])
+                    if any(tag in memory_tags for tag in tags):
+                        should_remove = True
+                else:
+                    # 清除所有
+                    should_remove = True
+
+                if should_remove:
+                    memory_file.unlink()
+                    removed_count += 1
+
+            except Exception as e:
+                PrettyOutput.print(
+                    f"处理记忆文件 {memory_file} 时出错: {str(e)}", OutputType.WARNING
+                )
+
+        # 如果目录为空，可以删除目录
+        if not any(memory_dir.iterdir()) and memory_dir != self.project_memory_dir:
+            memory_dir.rmdir()
+
+        return {"total": total_count, "removed": removed_count}
+
+    def execute(self, args: Dict[str, Any]) -> Dict[str, Any]:
+        """执行清除记忆操作"""
+        try:
+            memory_types = args.get("memory_types", [])
+            tags = args.get("tags", [])
+            memory_ids = args.get("memory_ids", [])
+            confirm = args.get("confirm", False)
+
+            if not confirm:
+                return {
+                    "success": False,
+                    "stdout": "",
+                    "stderr": "必须设置 confirm=true 才能执行清除操作",
+                }
+
+            # 确定要清除的记忆类型
+            if "all" in memory_types:
+                types_to_clear = ["project_long_term", "global_long_term", "short_term"]
+            else:
+                types_to_clear = memory_types
+
+            # 统计结果
+            results = {}
+            total_removed = 0
+
+            # 清除各类型的记忆
+            for memory_type in types_to_clear:
+                if memory_type == "short_term":
+                    result = self._clear_short_term_memories(tags, memory_ids)
+                else:
+                    result = self._clear_long_term_memories(
+                        memory_type, tags, memory_ids
+                    )
+
+                results[memory_type] = result
+                total_removed += result["removed"]
+
+            # 生成结果报告
+
+            # 详细报告
+            report = "# 记忆清除报告\n\n"
+            report += f"**总计清除**: {total_removed} 条记忆\n\n"
+
+            if tags:
+                report += f"**使用标签过滤**: {', '.join(tags)}\n\n"
+
+            if memory_ids:
+                report += f"**指定记忆ID**: {', '.join(memory_ids)}\n\n"
+
+            report += "## 详细结果\n\n"
+
+            for memory_type, result in results.items():
+                report += f"### {memory_type}\n"
+                report += f"- 原有记忆: {result['total']} 条\n"
+                report += f"- 已清除: {result['removed']} 条\n"
+                report += f"- 剩余: {result['total'] - result['removed']} 条\n\n"
+
+            return {
+                "success": True,
+                "stdout": report,
+                "stderr": "",
+            }
+
+        except Exception as e:
+            error_msg = f"清除记忆失败: {str(e)}"
+            PrettyOutput.print(error_msg, OutputType.ERROR)
+            return {"success": False, "stdout": "", "stderr": error_msg}