jarvis-ai-assistant 0.2.4__py3-none-any.whl → 0.2.6__py3-none-any.whl

jarvis/jarvis_stats/visualizer.py

@@ -5,9 +5,10 @@
 """
 
 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
@@ -51,106 +52,50 @@ class StatsVisualizer:
         show_values: bool = True,
     ) -> str:
         """
-        绘制折线图
-
-        Args:
-            data: 数据字典，键为时间标签，值为数值
-            title: 图表标题
-            unit: 单位
-            show_values: 是否显示数值
-
-        Returns:
-            图表字符串
+        使用 plotext 绘制折线图
         """
         if not data:
             return "无数据可显示"
 
-        # 排序数据
         sorted_data = OrderedDict(sorted(data.items()))
-
-        # 提取值和标签
         labels = list(sorted_data.keys())
         values = list(sorted_data.values())
 
-        # 计算数值范围
-        min_val = min(values)
-        max_val = max(values)
-
-        # 如果所有值相同，调整范围
-        if min_val == max_val:
-            if min_val == 0:
-                min_val = -1
-                max_val = 1
-            else:
-                min_val = min_val * 0.9
-                max_val = max_val * 1.1
-
-        # 创建图表画布
-        chart_width = self.width - 10  # 留出y轴标签空间
-        chart_height = self.height - 5  # 留出x轴标签空间
-
-        # 初始化画布
-        canvas = [[" " for _ in range(chart_width)] for _ in range(chart_height)]
-
-        # 计算缩放因子
-        x_scale = (chart_width - 1) / max(len(values) - 1, 1)
-        y_scale = (chart_height - 1) / (max_val - min_val)
-
-        # 绘制坐标轴
-        for i in range(chart_height):
-            canvas[i][0] = "│"
-        for j in range(chart_width):
-            canvas[chart_height - 1][j] = "─"
-        canvas[chart_height - 1][0] = "└"
-
-        # 绘制数据点和连线
-        points = []
-        for i, value in enumerate(values):
-            x = int(i * x_scale) + 1
-            y = chart_height - 1 - int((value - min_val) * y_scale)
-            y = max(0, min(chart_height - 1, y))  # 确保在范围内
-
-            if 0 <= x < chart_width and 0 <= y < chart_height:
-                points.append((x, y, value))
-                canvas[y][x] = "●"
-
-        # 连接数据点
-        for i in range(len(points) - 1):
-            x1, y1, _ = points[i]
-            x2, y2, _ = points[i + 1]
-            self._draw_line(canvas, x1, y1, x2, y2)
-
-        # 构建输出
-        output = []
-
-        # 标题
+        plt.clf()
+        plt.plotsize(self.width, self.height)
+        plt.plot(values)
+        plt.xticks(range(len(labels)), labels)
         if title:
-            output.append(f"\n{title.center(self.width)}")
-            output.append("=" * self.width)
-
-        # Y轴标签和图表
-        y_labels = self._generate_y_labels(min_val, max_val, chart_height)
-
-        for i, row in enumerate(canvas):
-            label = y_labels.get(i, "")
-            line = f"{label:>8} " + "".join(row)
-            output.append(line)
+            plt.title(title)
+        if unit:
+            plt.ylabel(unit)
 
-        # X轴标签
-        x_labels = self._generate_x_labels(labels, chart_width)
-        output.append(" " * 9 + x_labels)
+        chart = plt.build()
 
-        # 单位
-        if unit:
-            output.append(f"\n单位: {unit}")
+        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}"
+            )
 
-        # 统计信息
-        if show_values:
-            output.append(
-                f"\n最小值: {min_val:.2f}, 最大值: {max_val:.2f}, 平均值: {sum(values)/len(values):.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 "\n".join(output)
+            return chart + "\n" + stats_panel_str.strip()
+        return chart
 
     def plot_bar_chart(
         self,
@@ -160,75 +105,27 @@ class StatsVisualizer:
         horizontal: bool = False,
     ) -> str:
         """
-        绘制柱状图
-
-        Args:
-            data: 数据字典
-            title: 图表标题
-            unit: 单位
-            horizontal: 是否横向
-
-        Returns:
-            图表字符串
+        使用 plotext 绘制柱状图
         """
         if not data:
             return "无数据可显示"
 
-        output = []
-
-        # 标题
-        if title:
-            output.append(f"\n{title.center(self.width)}")
-            output.append("=" * self.width)
+        labels = list(data.keys())
+        values = list(data.values())
 
-        # 找出最大值用于缩放
-        max_value = max(data.values()) if data.values() else 1
+        plt.clf()
+        plt.plotsize(self.width, self.height)
 
         if horizontal:
-            # 横向柱状图
-            max_label_len = max(len(str(k)) for k in data.keys())
-            bar_width = self.width - max_label_len - 15
-
-            for label, value in data.items():
-                bar_len = int((value / max_value) * bar_width)
-                bar = "█" * bar_len
-                output.append(f"{str(label):>{max_label_len}} │{bar} {value:.2f}")
+            plt.bar(labels, values, orientation="horizontal")
         else:
-            # 纵向柱状图
-            bar_height = self.height - 5
-            labels = list(data.keys())
-            values = list(data.values())
-
-            # 创建画布
-            canvas = [[" " for _ in range(len(labels) * 4)] for _ in range(bar_height)]
-
-            # 绘制柱子
-            for i, (label, value) in enumerate(zip(labels, values)):
-                height = int((value / max_value) * bar_height)
-                x = i * 4 + 1
-
-                for y in range(bar_height - height, bar_height):
-                    if y >= 0 and x < len(canvas[0]):
-                        canvas[y][x] = "█"
-                        if x + 1 < len(canvas[0]):
-                            canvas[y][x + 1] = "█"
-
-            # 输出画布
-            for row in canvas:
-                output.append("".join(row))
-
-            # X轴标签
-            label_line = ""
-            for i, label in enumerate(labels):
-                x = i * 4
-                label_line += f"{label[:3]:>4}"
-            output.append(label_line)
-
-        # 单位
+            plt.bar(labels, values)
+        if title:
+            plt.title(title)
         if unit:
-            output.append(f"\n单位: {unit}")
+            plt.ylabel(unit)
 
-        return "\n".join(output)
+        return plt.build()
 
     def show_summary(
         self,
@@ -346,98 +243,40 @@ class StatsVisualizer:
         if unit:
             info_items.append(f"单位: {unit}")
         if start_time and end_time:
-            info_items.append(f"时间范围: {start_time} ~ {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), style="dim"))
+            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 = (
+            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(f"\n[dim]{stats_info}[/dim]")
+            self.console.print(
+                Panel(
+                    stats_info_text,
+                    title="[bold]数据统计[/bold]",
+                    expand=False,
+                    style="dim",
+                    border_style="blue",
+                )
+            )
 
         return ""
-
-    def _draw_line(self, canvas: List[List[str]], x1: int, y1: int, x2: int, y2: int):
-        """在画布上绘制线条"""
-        # 使用Bresenham算法绘制线条
-        dx = abs(x2 - x1)
-        dy = abs(y2 - y1)
-        sx = 1 if x1 < x2 else -1
-        sy = 1 if y1 < y2 else -1
-        err = dx - dy
-
-        x, y = x1, y1
-
-        while True:
-            if 0 <= x < len(canvas[0]) and 0 <= y < len(canvas):
-                if canvas[y][x] == " ":
-                    if dx > dy:
-                        canvas[y][x] = "─"
-                    else:
-                        canvas[y][x] = "│"
-
-            if x == x2 and y == y2:
-                break
-
-            e2 = 2 * err
-            if e2 > -dy:
-                err -= dy
-                x += sx
-            if e2 < dx:
-                err += dx
-                y += sy
-
-    def _generate_y_labels(
-        self, min_val: float, max_val: float, height: int
-    ) -> Dict[int, str]:
-        """生成Y轴标签"""
-        labels = {}
-
-        # 在顶部、中部和底部放置标签
-        positions = [0, height // 2, height - 1]
-        values = [max_val, (max_val + min_val) / 2, min_val]
-
-        for pos, val in zip(positions, values):
-            labels[pos] = f"{val:.1f}"
-
-        return labels
-
-    def _generate_x_labels(self, labels: List[str], width: int) -> str:
-        """生成X轴标签"""
-        if not labels:
-            return ""
-
-        # 简化标签（如果是时间格式）
-        simplified_labels = []
-        for label in labels:
-            if len(label) > 10:
-                # 尝试提取时间部分
-                parts = label.split()
-                if len(parts) >= 2:
-                    simplified_labels.append(parts[1][:5])  # 只取时间
-                else:
-                    simplified_labels.append(label[:8])
-            else:
-                simplified_labels.append(label)
-
-        # 根据空间决定显示多少标签
-        max_labels = width // 10
-        step = max(1, len(simplified_labels) // max_labels)
-
-        label_line = ""
-        for i in range(0, len(simplified_labels), step):
-            if i < len(simplified_labels):
-                label_line += f"{simplified_labels[i]:>10}"
-
-        return label_line

jarvis/jarvis_tools/cli/main.py

@@ -48,8 +48,6 @@ def stat_tools(
     """显示工具调用统计信息"""
     from jarvis.jarvis_stats.stats import StatsManager
     
-    stats_manager = StatsManager()
-    
     if format == "table":
         registry = ToolRegistry()
         stats = registry._get_tool_stats()
@@ -78,13 +76,13 @@ def stat_tools(
         # 使用 stats 系统的高级功能
         PrettyOutput.section("工具组统计", OutputType.SYSTEM)
         # 显示所有标记为 tool 组的指标
-        metrics = stats_manager.list_metrics()
+        metrics = StatsManager.list_metrics()
         tool_metrics = []
         
         for metric in metrics:
             # 检查是否是工具组的指标
             if last_days:
-                stats_data = stats_manager.get_stats(
+                stats_data = StatsManager.get_stats(
                     metric_name=metric,
                     last_days=last_days,
                     tags={"group": "tool"}
@@ -92,7 +90,7 @@ def stat_tools(
             else:
                 # 获取所有历史数据
                 from datetime import datetime
-                stats_data = stats_manager.get_stats(
+                stats_data = StatsManager.get_stats(
                     metric_name=metric,
                     start_time=datetime(2000, 1, 1),
                     end_time=datetime.now(),
@@ -105,10 +103,10 @@ def stat_tools(
             for metric in tool_metrics:
                 if format == "chart":
                     if last_days:
-                        stats_manager.plot(metric, last_days=last_days, tags={"group": "tool"})
+                        StatsManager.plot(metric, last_days=last_days, tags={"group": "tool"})
                     else:
                         from datetime import datetime
-                        stats_manager.plot(
+                        StatsManager.plot(
                             metric, 
                             start_time=datetime(2000, 1, 1), 
                             end_time=datetime.now(), 
@@ -116,10 +114,10 @@ def stat_tools(
                         )
                 elif format == "summary":
                     if last_days:
-                        stats_manager.show(metric, last_days=last_days, format="summary", tags={"group": "tool"})
+                        StatsManager.show(metric, last_days=last_days, format="summary", tags={"group": "tool"})
                     else:
                         from datetime import datetime
-                        stats_manager.show(
+                        StatsManager.show(
                             metric, 
                             start_time=datetime(2000, 1, 1), 
                             end_time=datetime.now(), 

jarvis/jarvis_tools/registry.py

@@ -203,8 +203,6 @@ class ToolRegistry(OutputHandlerProtocol):
         from jarvis.jarvis_stats.stats import StatsManager
         from datetime import datetime, timedelta
         
-        stats_manager = StatsManager()
-        
         # 获取所有工具的统计数据
         tool_stats = {}
         tools = self.get_all_tools()
@@ -216,7 +214,7 @@ class ToolRegistry(OutputHandlerProtocol):
         for tool in tools:
             tool_name = tool["name"]
             # 获取该工具的统计数据
-            stats_data = stats_manager.get_stats(
+            stats_data = StatsManager.get_stats(
                 metric_name=tool_name,
                 start_time=start_time,
                 end_time=end_time,
@@ -236,8 +234,7 @@ class ToolRegistry(OutputHandlerProtocol):
         """更新工具调用统计"""
         from jarvis.jarvis_stats.stats import StatsManager
         
-        stats_manager = StatsManager()
-        stats_manager.increment(name, group="tool")
+        StatsManager.increment(name, group="tool")
 
     def use_tools(self, name: List[str]) -> None:
         """使用指定工具

jarvis/jarvis_tools/retrieve_memory.py

@@ -0,0 +1,206 @@
+# -*- coding: utf-8 -*-
+import json
+import random
+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 get_short_term_memories
+
+
+class RetrieveMemoryTool:
+    """检索记忆工具，用于从长短期记忆系统中检索信息"""
+
+    name = "retrieve_memory"
+    description = """从长短期记忆系统中检索信息。
+    
+    支持的记忆类型：
+    - 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": "要检索的记忆类型列表，如果包含'all'则检索所有类型",
+            },
+            "tags": {
+                "type": "array",
+                "items": {"type": "string"},
+                "description": "用于过滤的标签列表（可选）",
+            },
+            "limit": {
+                "type": "integer",
+                "description": "返回结果的最大数量（可选，默认返回所有）",
+                "minimum": 1,
+            },
+        },
+        "required": ["memory_types"],
+    }
+
+    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 _retrieve_from_type(
+        self, memory_type: str, tags: Optional[List[str]] = None
+    ) -> List[Dict[str, Any]]:
+        """从指定类型中检索记忆"""
+        memories: List[Dict[str, Any]] = []
+
+        if memory_type == "short_term":
+            # 从全局变量获取短期记忆
+            memories = get_short_term_memories(tags)
+        else:
+            # 从文件系统获取长期记忆
+            memory_dir = self._get_memory_dir(memory_type)
+
+            if not memory_dir.exists():
+                return memories
+
+            # 遍历记忆文件
+            for memory_file in memory_dir.glob("*.json"):
+                try:
+                    with open(memory_file, "r", encoding="utf-8") as f:
+                        memory_data = json.load(f)
+
+                    # 如果指定了标签，检查是否匹配
+                    if tags:
+                        memory_tags = memory_data.get("tags", [])
+                        if not any(tag in memory_tags for tag in tags):
+                            continue
+
+                    memories.append(memory_data)
+                except Exception as e:
+                    PrettyOutput.print(
+                        f"读取记忆文件 {memory_file} 失败: {str(e)}", OutputType.WARNING
+                    )
+
+        return memories
+
+    def execute(self, args: Dict[str, Any]) -> Dict[str, Any]:
+        """执行检索记忆操作"""
+        try:
+            memory_types = args.get("memory_types", [])
+            tags = args.get("tags", [])
+            limit = args.get("limit", None)
+
+            # 确定要检索的记忆类型
+            if "all" in memory_types:
+                types_to_search = [
+                    "project_long_term",
+                    "global_long_term",
+                    "short_term",
+                ]
+            else:
+                types_to_search = memory_types
+
+            # 从各个类型中检索记忆
+            all_memories = []
+            for memory_type in types_to_search:
+                memories = self._retrieve_from_type(memory_type, tags)
+                all_memories.extend(memories)
+
+            # 按创建时间排序（最新的在前）
+            all_memories.sort(key=lambda x: x.get("created_at", ""), reverse=True)
+
+            # 限制最多返回50条记忆，随机选取
+            if len(all_memories) > 50:
+                all_memories = random.sample(all_memories, 50)
+                # 重新排序，保持时间顺序
+                all_memories.sort(key=lambda x: x.get("created_at", ""), reverse=True)
+
+            # 如果指定了限制，只返回前N个
+            if limit:
+                all_memories = all_memories[:limit]
+
+            # 打印结果摘要
+            PrettyOutput.print(f"检索到 {len(all_memories)} 条记忆", OutputType.INFO)
+
+            if tags:
+                PrettyOutput.print(f"使用标签过滤: {', '.join(tags)}", OutputType.INFO)
+
+            # 格式化为Markdown输出
+            markdown_output = f"# 记忆检索结果\n\n"
+            markdown_output += f"**检索到 {len(all_memories)} 条记忆**\n\n"
+            
+            if tags:
+                markdown_output += f"**使用标签过滤**: {', '.join(tags)}\n\n"
+            
+            markdown_output += f"**记忆类型**: {', '.join(types_to_search)}\n\n"
+            
+            markdown_output += "---\n\n"
+            
+            # 输出所有记忆
+            for i, memory in enumerate(all_memories):
+                markdown_output += f"## {i+1}. {memory.get('id', '未知ID')}\n\n"
+                markdown_output += f"**类型**: {memory.get('type', '未知类型')}\n\n"
+                markdown_output += f"**标签**: {', '.join(memory.get('tags', []))}\n\n"
+                markdown_output += f"**创建时间**: {memory.get('created_at', '未知时间')}\n\n"
+                
+                # 内容部分
+                content = memory.get('content', '')
+                if content:
+                    markdown_output += f"**内容**:\n\n{content}\n\n"
+                
+                # 如果有额外的元数据
+                metadata = {k: v for k, v in memory.items() 
+                           if k not in ['id', 'type', 'tags', 'created_at', 'content']}
+                if metadata:
+                    markdown_output += f"**其他信息**:\n"
+                    for key, value in metadata.items():
+                        markdown_output += f"- {key}: {value}\n"
+                    markdown_output += "\n"
+                
+                markdown_output += "---\n\n"
+
+            # 如果记忆较多，在终端显示摘要
+            if len(all_memories) > 5:
+                PrettyOutput.print(f"记忆较多，仅显示前5条摘要：", OutputType.INFO)
+                for i, memory in enumerate(all_memories[:5]):
+                    content_preview = memory.get("content", "")[:100]
+                    if len(memory.get("content", "")) > 100:
+                        content_preview += "..."
+                    PrettyOutput.print(
+                        f"{i+1}. [{memory.get('type')}] {memory.get('id')}\n"
+                        f"   标签: {', '.join(memory.get('tags', []))}\n"
+                        f"   内容: {content_preview}",
+                        OutputType.INFO,
+                    )
+
+            return {
+                "success": True,
+                "stdout": markdown_output,
+                "stderr": "",
+            }
+
+        except Exception as e:
+            error_msg = f"检索记忆失败: {str(e)}"
+            PrettyOutput.print(error_msg, OutputType.ERROR)
+            return {"success": False, "stdout": "", "stderr": error_msg}