jarvis-ai-assistant 0.2.4__py3-none-any.whl → 0.2.5__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_utils/config.py

@@ -81,10 +81,10 @@ def get_max_token_count(model_group_override: Optional[str] = None) -> int:
     获取模型允许的最大token数量。
 
     返回:
-        int: 模型能处理的最大token数量。
+        int: 模型能处理的最大token数量，为最大输入token数量的100倍。
     """
-    config = _get_resolved_model_config(model_group_override)
-    return int(config.get("JARVIS_MAX_TOKEN_COUNT", "960000"))
+    max_input_tokens = get_max_input_token_count(model_group_override)
+    return max_input_tokens * 100
 
 
 def get_max_input_token_count(model_group_override: Optional[str] = None) -> int:
@@ -151,9 +151,7 @@ def _get_resolved_model_config(
         "JARVIS_MODEL",
         "JARVIS_THINKING_PLATFORM",
         "JARVIS_THINKING_MODEL",
-        "JARVIS_MAX_TOKEN_COUNT",
         "JARVIS_MAX_INPUT_TOKEN_COUNT",
-        "JARVIS_MAX_BIG_CONTENT_SIZE",
     ]:
         if key in GLOBAL_CONFIG_DATA:
             resolved_config[key] = GLOBAL_CONFIG_DATA[key]
@@ -249,10 +247,10 @@ def get_max_big_content_size(model_group_override: Optional[str] = None) -> int:
     获取最大大内容大小。
 
     返回：
-        int: 最大大内容大小
+        int: 最大大内容大小，为最大输入token数量的5倍
     """
-    config = _get_resolved_model_config(model_group_override)
-    return int(config.get("JARVIS_MAX_BIG_CONTENT_SIZE", "160000"))
+    max_input_tokens = get_max_input_token_count(model_group_override)
+    return max_input_tokens * 5
 
 
 def get_pretty_output() -> bool:

jarvis/jarvis_utils/methodology.py

@@ -149,6 +149,7 @@ def load_methodology(user_input: str, tool_registery: Optional[Any] = None) -> s
 
     参数：
         user_input: 用户输入文本，用于提示大模型
+        tool_registery: 工具注册表，用于获取工具列表
 
     返回：
         str: 相关的方法论提示，如果未找到方法论则返回空字符串
@@ -170,70 +171,87 @@ def load_methodology(user_input: str, tool_registery: Optional[Any] = None) -> s
             return ""
         print(f"✅ 加载方法论文件完成 (共 {len(methodologies)} 个)")
 
-        # 获取当前平台
-        agent = get_agent(current_agent_name)
-        if agent:
-            platform = agent.model
-            model_group = agent.model.model_group
-        else:
-            platform = PlatformRegistry().get_normal_platform()
-            model_group = None
-        platform.set_suppress_output(False)
-        if not platform:
-            return ""
+        platform = PlatformRegistry().get_normal_platform()
+        platform.set_suppress_output(True)
+
+        # 步骤1：获取所有方法论的标题
+        methodology_titles = list(methodologies.keys())
 
-        # 构建基础提示信息
-        base_prompt = f"""以下是所有可用的方法论内容：
+        # 步骤2：让大模型选择相关性高的方法论
+        selection_prompt = f"""以下是所有可用的方法论标题：
 
 """
-        # 构建完整内容
-        full_content = base_prompt
-        for problem_type, content in methodologies.items():
-            full_content += f"## {problem_type}\n\n{content}\n\n---\n\n"
+        for i, title in enumerate(methodology_titles, 1):
+            selection_prompt += f"{i}. {title}\n"
 
-        full_content += f"以下是所有可用的工具内容：\n\n"
-        full_content += prompt
+        selection_prompt += f"""
+以下是可用的工具列表：
+{prompt}
 
-        # 添加用户输入和输出要求
-        full_content += f"""
-请根据以上方法论和可调用的工具内容，规划/总结出以下用户需求的执行步骤: {user_input}
+用户需求：{user_input}
 
-请按以下格式回复：
-### 与该任务/需求相关的方法论
-1. [方法论名字]
-2. [方法论名字]
-### 根据以上方法论，规划/总结出执行步骤
-1. [步骤1]
-2. [步骤2]
-3. [步骤3]
+请分析用户需求，从上述方法论中选择出与需求相关性较高的方法论（可以选择多个）。
 
-如果没有匹配的方法论，请输出：没有历史方法论可参考
-除以上要求外，不要输出任何内容
+请严格按照以下格式返回序号：
+<NUM>序号1,序号2,序号3</NUM>
+
+例如：<NUM>1,3,5</NUM>
+
+如果没有相关的方法论，请返回：<NUM>none</NUM>
+
+注意：只返回<NUM>标签内的内容，不要有其他任何输出。
 """
 
-        # 检查内容是否过大
-        is_large_content = is_context_overflow(full_content, model_group)
-        temp_file_path = None
+        # 获取大模型选择的方法论序号
+        response = platform.chat_until_success(selection_prompt).strip()
+
+        # 重置平台，恢复输出
+        platform.reset()
+        platform.set_suppress_output(False)
+
+        # 从响应中提取<NUM>标签内的内容
+        import re
+        num_match = re.search(r'<NUM>(.*?)</NUM>', response, re.DOTALL)
+        
+        if not num_match:
+            # 如果没有找到<NUM>标签，尝试直接解析响应
+            selected_indices_str = response
+        else:
+            selected_indices_str = num_match.group(1).strip()
+
+        if selected_indices_str.lower() == "none":
+            return "没有历史方法论可参考"
 
+        # 解析选择的序号
+        selected_methodologies = {}
         try:
-            if is_large_content:
-                # 创建临时文件
-                print(f"📝 创建方法论临时文件...")
-                temp_file_path = _create_methodology_temp_file(methodologies)
-                if not temp_file_path:
-                    print(f"❌ 创建方法论临时文件失败")
-                    return ""
-                print(f"✅ 创建方法论临时文件完成")
-
-                # 尝试上传文件
-                upload_success = platform.upload_files([temp_file_path])
-
-                if upload_success:
-                    # 使用上传的文件生成摘要
-                    return platform.chat_until_success(
-                        base_prompt
-                        + f"""
-请根据已上传的方法论和可调用的工具文件内容，规划/总结出以下用户需求的执行步骤: {user_input}
+            if selected_indices_str:
+                indices = [int(idx.strip()) for idx in selected_indices_str.split(",") if idx.strip().isdigit()]
+                for idx in indices:
+                    if 1 <= idx <= len(methodology_titles):
+                        title = methodology_titles[idx - 1]
+                        selected_methodologies[title] = methodologies[title]
+        except Exception:
+            # 如果解析失败，返回空结果
+            return "没有历史方法论可参考"
+
+        if not selected_methodologies:
+            return "没有历史方法论可参考"
+
+        # 步骤3：将选择出来的方法论内容提供给大模型生成步骤
+        final_prompt = f"""以下是与用户需求相关的方法论内容：
+
+"""
+        for problem_type, content in selected_methodologies.items():
+            final_prompt += f"## {problem_type}\n\n{content}\n\n---\n\n"
+
+        final_prompt += f"""以下是所有可用的工具内容：
+
+{prompt}
+
+用户需求：{user_input}
+
+请根据以上方法论和可调用的工具内容，规划/总结出执行步骤。
 
 请按以下格式回复：
 ### 与该任务/需求相关的方法论
@@ -244,22 +262,11 @@ def load_methodology(user_input: str, tool_registery: Optional[Any] = None) -> s
 2. [步骤2]
 3. [步骤3]
 
-如果没有匹配的方法论，请输出：没有历史方法论可参考
 除以上要求外，不要输出任何内容
 """
-                    )
-                else:
-                    return "没有历史方法论可参考"
-            # 如果内容不大或上传失败，直接使用chat_until_success
-            return platform.chat_until_success(full_content)
-
-        finally:
-            # 清理临时文件
-            if temp_file_path and os.path.exists(temp_file_path):
-                try:
-                    os.remove(temp_file_path)
-                except Exception:
-                    pass
+
+        # 如果内容不大，直接使用chat_until_success
+        return platform.chat_until_success(final_prompt)
 
     except Exception as e:
         PrettyOutput.print(f"加载方法论失败: {str(e)}", OutputType.ERROR)