jarvis-ai-assistant 0.3.18__py3-none-any.whl → 0.3.19__py3-none-any.whl

jarvis/jarvis_stats/storage.py

@@ -35,6 +35,10 @@ class StatsStorage:
         self.data_dir = self.storage_dir / "data"
         self.data_dir.mkdir(exist_ok=True)
 
+        # 统计总量缓存目录（每个指标一个文件，内容为统计总量）
+        self.totals_dir = self.storage_dir / "totals"
+        self.totals_dir.mkdir(exist_ok=True)
+
         # 元数据文件路径
         self.meta_file = self.storage_dir / "stats_meta.json"
 
@@ -108,6 +112,31 @@ class StatsStorage:
                         pass
                 raise RuntimeError(f"保存数据失败: {e}") from e
 
+    def _save_text_atomic(self, filepath: Path, text: str):
+        """原子性地保存纯文本内容"""
+        temp_suffix = f".tmp.{uuid.uuid4().hex[:8]}"
+        temp_filepath = filepath.with_suffix(temp_suffix)
+        max_retries = 3
+        for attempt in range(max_retries):
+            try:
+                with open(temp_filepath, "w", encoding="utf-8") as f:
+                    f.write(text)
+
+                if sys.platform == "win32" and filepath.exists():
+                    filepath.unlink()
+                temp_filepath.rename(filepath)
+                return
+            except Exception:
+                if attempt < max_retries - 1:
+                    time.sleep(0.1 * (attempt + 1))
+                    continue
+                if temp_filepath.exists():
+                    try:
+                        temp_filepath.unlink()
+                    except OSError:
+                        pass
+                raise
+
     def add_metric(
         self,
         metric_name: str,
@@ -141,6 +170,13 @@ class StatsStorage:
             meta["metrics"][metric_name]["last_updated"] = timestamp.isoformat()
             if unit and not meta["metrics"][metric_name].get("unit"):
                 meta["metrics"][metric_name]["unit"] = unit
+
+        # 记录分组信息（如果提供）
+        if tags and isinstance(tags, dict):
+            group = tags.get("group")
+            if group:
+                meta["metrics"][metric_name]["group"] = group
+
         self._save_json(self.meta_file, meta)
 
         # 获取日期对应的数据文件
@@ -169,6 +205,26 @@ class StatsStorage:
         # 保存数据到日期文件
         self._save_json(date_file, data)
 
+        # 更新总量缓存文件（每个指标一个文件，内容为累计统计值）
+        try:
+            total_file = self._get_total_file(metric_name)
+            if total_file.exists():
+                # 正常累加
+                try:
+                    with open(total_file, "r", encoding="utf-8") as tf:
+                        current_total = float(tf.read().strip() or "0")
+                except Exception:
+                    current_total = 0.0
+                new_total = current_total + float(value)
+                self._save_text_atomic(total_file, str(new_total))
+            else:
+                # 首次生成：扫描历史数据（包含刚写入的这条记录）并写入
+                # 注意：get_metric_total 内部会完成扫描并写入 totals 文件，这里无需再额外写入或累加
+                _ = self.get_metric_total(metric_name)
+        except Exception:
+            # 静默失败，不影响主流程
+            pass
+
     def get_metrics(
         self,
         metric_name: str,
@@ -236,6 +292,144 @@ class StatsStorage:
 
         return results
 
+    def _get_total_file(self, metric_name: str) -> Path:
+        """获取某个指标的总量文件路径"""
+        return self.totals_dir / metric_name
+
+    def get_metric_total(self, metric_name: str) -> float:
+        """
+        获取某个指标的累计总量。
+        - 如果总量缓存文件存在，直接读取
+        - 如果不存在，则扫描历史数据计算一次并写入缓存
+        """
+        total_file = self._get_total_file(metric_name)
+        # 优先读取缓存
+        if total_file.exists():
+            try:
+                with open(total_file, "r", encoding="utf-8") as f:
+                    return float((f.read() or "0").strip() or "0")
+            except Exception:
+                # 读取失败则重建
+                pass
+
+        # 扫描历史数据进行一次性计算，并尽可能推断分组信息
+        total = 0.0
+        group_counts: Dict[str, int] = {}
+        try:
+            for data_file in self.data_dir.glob("stats_*.json"):
+                data = self._load_json(data_file)
+                metric_data = data.get(metric_name) or {}
+                # metric_data: {hour_key: [records]}
+                for hour_records in metric_data.values():
+                    for record in hour_records:
+                        # 累加数值
+                        try:
+                            total += float(record.get("value", 0))
+                        except Exception:
+                            pass
+                        # 统计历史记录中的分组标签
+                        try:
+                            tags = record.get("tags", {})
+                            grp = tags.get("group")
+                            if grp:
+                                group_counts[grp] = group_counts.get(grp, 0) + 1
+                        except Exception:
+                            pass
+
+            # 写入缓存
+            self._save_text_atomic(total_file, str(total))
+
+            # 如果元数据中没有该指标或缺少分组，则根据历史数据推断一次
+            try:
+                meta = self._load_json(self.meta_file)
+                if "metrics" not in meta or not isinstance(meta.get("metrics"), dict):
+                    meta["metrics"] = {}
+                info = meta["metrics"].get(metric_name)
+                now_iso = datetime.now().isoformat()
+                if info is None:
+                    info = {"unit": None, "created_at": now_iso, "last_updated": now_iso}
+                    meta["metrics"][metric_name] = info
+                if not info.get("group"):
+                    inferred_group = None
+                    if group_counts:
+                        inferred_group = max(group_counts.items(), key=lambda kv: kv[1])[0]
+                    # 名称启发式作为补充
+                    if not inferred_group:
+                        if metric_name.startswith("code_lines_") or "commit" in metric_name:
+                            inferred_group = "code_agent"
+                    if inferred_group:
+                        info["group"] = inferred_group
+                # 保存元数据
+                self._save_json(self.meta_file, meta)
+            except Exception:
+                # 分组推断失败不影响总量结果
+                pass
+
+        except Exception:
+            # 失败则返回0
+            return 0.0
+        return total
+
+    def resolve_metric_group(self, metric_name: str) -> Optional[str]:
+        """
+        解析并确保写回某个指标的分组信息：
+        - 若元数据已存在group则直接返回
+        - 否则扫描历史记录中的tags['group']做多数投票推断
+        - 若仍无法得到，则用名称启发式(code_lines_*或包含commit -> code_agent)
+        - 推断出group后会写回到元数据，返回推断值；否则返回None
+        """
+        try:
+            # 优先从元数据读取
+            meta = self._load_json(self.meta_file)
+            metrics_meta = meta.get("metrics", {}) if isinstance(meta.get("metrics"), dict) else {}
+            info = metrics_meta.get(metric_name)
+            if info and isinstance(info, dict):
+                grp = info.get("group")
+                if grp:
+                    return grp
+
+            # 扫描历史记录以推断
+            group_counts: Dict[str, int] = {}
+            for data_file in self.data_dir.glob("stats_*.json"):
+                data = self._load_json(data_file)
+                metric_data = data.get(metric_name) or {}
+                for hour_records in metric_data.values():
+                    for record in hour_records:
+                        try:
+                            tags = record.get("tags", {})
+                            grp = tags.get("group")
+                            if grp:
+                                group_counts[grp] = group_counts.get(grp, 0) + 1
+                        except Exception:
+                            continue
+
+            inferred_group: Optional[str] = None
+            if group_counts:
+                inferred_group = max(group_counts.items(), key=lambda kv: kv[1])[0]
+
+            # 名称启发式补充
+            if not inferred_group:
+                name = metric_name or ""
+                if name.startswith("code_lines_") or ("commit" in name):
+                    inferred_group = "code_agent"
+
+            # 如果推断出了分组，写回元数据
+            if inferred_group:
+                if not isinstance(metrics_meta, dict):
+                    meta["metrics"] = {}
+                    metrics_meta = meta["metrics"]
+                if info is None:
+                    now_iso = datetime.now().isoformat()
+                    info = {"unit": None, "created_at": now_iso, "last_updated": now_iso}
+                    metrics_meta[metric_name] = info
+                info["group"] = inferred_group
+                self._save_json(self.meta_file, meta)
+                return inferred_group
+
+            return None
+        except Exception:
+            return None
+
     def get_metric_info(self, metric_name: str) -> Optional[Dict]:
         """获取指标元信息"""
         meta = self._load_json(self.meta_file)
@@ -246,7 +440,7 @@ class StatsStorage:
         # 从元数据文件获取指标
         meta = self._load_json(self.meta_file)
         metrics_from_meta = set(meta.get("metrics", {}).keys())
-        
+
         # 扫描所有数据文件获取实际存在的指标
         metrics_from_data: set[str] = set()
         for data_file in self.data_dir.glob("stats_*.json"):
@@ -256,9 +450,18 @@ class StatsStorage:
             except (json.JSONDecodeError, OSError):
                 # 忽略无法读取的文件
                 continue
-        
-        # 合并两个来源的指标并返回排序后的列表
-        all_metrics = metrics_from_meta.union(metrics_from_data)
+
+        # 扫描总量缓存目录中已有的指标文件
+        metrics_from_totals: set[str] = set()
+        try:
+            for f in self.totals_dir.glob("*"):
+                if f.is_file():
+                    metrics_from_totals.add(f.name)
+        except Exception:
+            pass
+
+        # 合并三个来源的指标并返回排序后的列表
+        all_metrics = metrics_from_meta.union(metrics_from_data).union(metrics_from_totals)
         return sorted(list(all_metrics))
 
     def aggregate_metrics(
@@ -331,10 +534,10 @@ class StatsStorage:
     def delete_metric(self, metric_name: str) -> bool:
         """
         删除指定的指标及其所有数据
-        
+
         Args:
             metric_name: 要删除的指标名称
-            
+
         Returns:
             True 如果成功删除，False 如果指标不存在
         """
@@ -342,11 +545,11 @@ class StatsStorage:
         meta = self._load_json(self.meta_file)
         if metric_name not in meta.get("metrics", {}):
             return False
-            
+
         # 从元数据中删除指标
         del meta["metrics"][metric_name]
         self._save_json(self.meta_file, meta)
-        
+
         # 遍历所有数据文件，删除该指标的数据
         for data_file in self.data_dir.glob("stats_*.json"):
             try:
@@ -362,7 +565,15 @@ class StatsStorage:
             except Exception:
                 # 忽略单个文件的错误，继续处理其他文件
                 pass
-                
+
+        # 删除总量缓存文件
+        try:
+            total_file = self._get_total_file(metric_name)
+            if total_file.exists():
+                total_file.unlink()
+        except Exception:
+            pass
+
         return True
 
     def delete_old_data(self, days_to_keep: int = 30):

jarvis/jarvis_tools/clear_memory.py

@@ -210,9 +210,6 @@ class ClearMemoryTool:
                 total_removed += result["removed"]
 
             # 生成结果报告
-            PrettyOutput.print(
-                f"记忆清除完成，共清除 {total_removed} 条记忆", OutputType.SUCCESS
-            )
 
             # 详细报告
             report = f"# 记忆清除报告\n\n"
@@ -232,14 +229,6 @@ class ClearMemoryTool:
                 report += f"- 已清除: {result['removed']} 条\n"
                 report += f"- 剩余: {result['total'] - result['removed']} 条\n\n"
 
-            # 在终端显示摘要
-            for memory_type, result in results.items():
-                if result["removed"] > 0:
-                    PrettyOutput.print(
-                        f"{memory_type}: 清除了 {result['removed']}/{result['total']} 条记忆",
-                        OutputType.INFO,
-                    )
-
             return {
                 "success": True,
                 "stdout": report,

jarvis/jarvis_tools/cli/main.py

@@ -23,20 +23,21 @@ def list_tools(
 
     if as_json:
         if detailed:
-            print(json.dumps(tools, indent=2, ensure_ascii=False))
+            PrettyOutput.print(json.dumps(tools, indent=2, ensure_ascii=False), OutputType.CODE, lang="json")
         else:
             simple_tools = [
                 {"name": t["name"], "description": t["description"]} for t in tools
             ]
-            print(json.dumps(simple_tools, indent=2, ensure_ascii=False))
+            PrettyOutput.print(json.dumps(simple_tools, indent=2, ensure_ascii=False), OutputType.CODE, lang="json")
     else:
         PrettyOutput.section("可用工具列表", OutputType.SYSTEM)
         for tool in tools:
-            print(f"\n✅ {tool['name']}")
-            print(f"   描述: {tool['description']}")
+            PrettyOutput.print(f"\n{tool['name']}", OutputType.SUCCESS)
+            PrettyOutput.print(f"   描述: {tool['description']}", OutputType.INFO)
             if detailed:
-                print("   参数:")
-                print(tool["parameters"])
+                PrettyOutput.print("   参数:", OutputType.INFO)
+                import json as _json  # local import to ensure available
+                PrettyOutput.print(_json.dumps(tool["parameters"], ensure_ascii=False, indent=2), OutputType.CODE, lang="json")
 
 
 @app.command("stat")
@@ -63,15 +64,15 @@ def stat_tools(
         table_data.sort(key=lambda x: x[1], reverse=True)
 
         if as_json:
-            print(json.dumps(dict(table_data), indent=2))
+            PrettyOutput.print(json.dumps(dict(table_data), indent=2), OutputType.CODE, lang="json")
         else:
             time_desc = f"最近{last_days}天" if last_days else "所有历史"
             PrettyOutput.section(f"工具调用统计 ({time_desc})", OutputType.SYSTEM)
             if table_data:
-                print(tabulate(table_data, headers=["工具名称", "调用次数"], tablefmt="grid"))
-                print(f"\n总计: {len(table_data)} 个工具被使用，共 {sum(x[1] for x in table_data)} 次调用")
+                PrettyOutput.print(tabulate(table_data, headers=["工具名称", "调用次数"], tablefmt="grid"), OutputType.CODE, lang="text")
+                PrettyOutput.print(f"\n总计: {len(table_data)} 个工具被使用，共 {sum(x[1] for x in table_data)} 次调用", OutputType.INFO)
             else:
-                print("暂无工具调用记录")
+                PrettyOutput.print("暂无工具调用记录", OutputType.INFO)
     else:
         # 使用 stats 系统的高级功能
         PrettyOutput.section("工具组统计", OutputType.SYSTEM)
@@ -125,7 +126,7 @@ def stat_tools(
                             tags={"group": "tool"}
                         )
         else:
-            print("暂无工具调用记录")
+            PrettyOutput.print("暂无工具调用记录", OutputType.INFO)
 
 
 @app.command("call")
@@ -143,7 +144,7 @@ def call_tool(
     if not tool_obj:
         PrettyOutput.print(f"错误: 工具 '{tool_name}' 不存在", OutputType.ERROR)
         available_tools = ", ".join([t["name"] for t in registry.get_all_tools()])
-        print(f"可用工具: {available_tools}")
+        PrettyOutput.print(f"可用工具: {available_tools}", OutputType.INFO)
         raise typer.Exit(code=1)
 
     tool_args = {}
@@ -170,12 +171,12 @@ def call_tool(
         PrettyOutput.print(
             f"错误: 缺少必需参数: {', '.join(missing_params)}", OutputType.ERROR
         )
-        print("\n参数说明:")
+        PrettyOutput.print("\n参数说明:", OutputType.INFO)
         params = tool_obj.parameters.get("properties", {})
         for param_name in required_params:
             param_info = params.get(param_name, {})
             desc = param_info.get("description", "无描述")
-            print(f"  - {param_name}: {desc}")
+            PrettyOutput.print(f"  - {param_name}: {desc}", OutputType.INFO)
         raise typer.Exit(code=1)
 
     result = registry.execute_tool(tool_name, tool_args)
@@ -186,12 +187,12 @@ def call_tool(
         PrettyOutput.section(f"工具 {tool_name} 执行失败", OutputType.ERROR)
 
     if result.get("stdout"):
-        print("\n输出:")
-        print(result["stdout"])
+        PrettyOutput.print("\n输出:", OutputType.INFO)
+        PrettyOutput.print(result["stdout"], OutputType.CODE, lang="text")
 
     if result.get("stderr"):
         PrettyOutput.print("\n错误:", OutputType.ERROR)
-        print(result["stderr"])
+        PrettyOutput.print(result["stderr"], OutputType.ERROR, lang="text")
 
     if not result["success"]:
         raise typer.Exit(code=1)

jarvis/jarvis_tools/edit_file.py

@@ -148,12 +148,12 @@ class FileSearchReplaceTool:
                             content = f.read()
                             original_content = content
 
-                    print(f"⚙️ 正在处理文件 {file_path}...")
+
                     success, temp_content = EditFileHandler._fast_edit(
                         file_path, changes
                     )
                     if not success:
-                        print(f"❌ 文件 {file_path} 处理失败")
+                        PrettyOutput.print(f"文件 {file_path} 处理失败", OutputType.ERROR)
                         file_results.append(
                             {
                                 "file": file_path,
@@ -164,7 +164,7 @@ class FileSearchReplaceTool:
                         )
                         continue
 
-                    print(f"✅ 文件 {file_path} 内容生成完成")
+
 
                     # 只有当所有替换操作都成功时，才写回文件
                     if success and (
@@ -183,7 +183,7 @@ class FileSearchReplaceTool:
                         action = "创建并写入" if not file_exists else "成功修改"
                         stdout_message = f"文件 {file_path} {action} 完成"
                         stdout_messages.append(stdout_message)
-                        PrettyOutput.print(stdout_message, OutputType.SUCCESS)
+
                         overall_success = True
 
                         file_results.append(

jarvis/jarvis_tools/execute_script.py

@@ -173,4 +173,8 @@ class ScriptTool:
 
 if __name__ == "__main__":
     script_tool = ScriptTool()
-    print(script_tool.get_display_output("/home/wangmaobin/code/Jarvis/a.txt"))
+    PrettyOutput.print(
+        script_tool.get_display_output("/home/wangmaobin/code/Jarvis/a.txt"),
+        OutputType.CODE,
+        lang="text",
+    )

jarvis/jarvis_tools/file_analyzer.py

@@ -73,19 +73,19 @@ class FileAnalyzerTool:
             platform.set_system_prompt(system_message)
 
             # 上传文件
-            print(f"📤 正在上传文件...")
+
             try:
                 upload_result = platform.upload_files(valid_files)
                 if not upload_result:
-                    print(f"❌ 文件上传失败")
+                    PrettyOutput.print("文件上传失败", OutputType.ERROR)
                     return {
                         "success": False,
                         "stdout": "",
                         "stderr": "文件上传失败",
                     }
-                print(f"✅ 文件上传成功")
+
             except Exception as e:
-                print(f"❌ 文件上传失败: {str(e)}")
+                PrettyOutput.print(f"文件上传失败: {str(e)}", OutputType.ERROR)
                 return {
                     "success": False,
                     "stdout": "",
@@ -102,9 +102,9 @@ class FileAnalyzerTool:
 请提供详细的分析结果和理由。"""
 
             # 发送请求并获取分析结果
-            print(f"🔍 正在分析文件...")
+
             analysis_result = platform.chat_until_success(analysis_request)
-            print(f"✅ 分析完成")
+
 
             # 清理会话
             platform.delete_chat()

jarvis/jarvis_tools/generate_new_tool.py

@@ -123,9 +123,7 @@ class generate_new_tool:
                 tool_registry = agent.get_tool_registry()
                 if tool_registry:
                     # 尝试加载并注册新工具
-                    PrettyOutput.print(
-                        f"正在注册工具 '{tool_name}'...", OutputType.INFO
-                    )
+
                     if tool_registry.register_tool_by_file(str(tool_file_path)):
                         success_message += f"\n已成功注册到当前会话的工具注册表中"
                         registration_successful = True
@@ -148,12 +146,7 @@ class generate_new_tool:
                     )
                     success_message += f"\n注册到当前会话失败，可能需要重新启动Jarvis"
 
-            PrettyOutput.print(
-                f"工具 '{tool_name}' 创建"
-                + ("并注册" if registration_successful else "")
-                + "成功！",
-                OutputType.SUCCESS,
-            )
+
 
             # 检查并安装缺失的依赖
             try:
@@ -181,13 +174,11 @@ class generate_new_tool:
                     try:
                         __import__(pkg)
                     except ImportError:
-                        PrettyOutput.print(
-                            f"检测到缺失依赖: {pkg}, 正在尝试安装...", OutputType.INFO
-                        )
+
                         import subprocess
 
                         subprocess.run(["pip", "install", pkg], check=True)
-                        PrettyOutput.print(f"成功安装依赖: {pkg}", OutputType.SUCCESS)
+
             except Exception as e:
                 PrettyOutput.print(f"依赖检查/安装失败: {str(e)}", OutputType.WARNING)
 
@@ -201,11 +192,9 @@ class generate_new_tool:
             # 删除已创建的文件
             if tool_file_path and tool_file_path.exists():
                 try:
-                    PrettyOutput.print(
-                        f"正在删除已创建的文件 {tool_file_path}...", OutputType.INFO
-                    )
+
                     tool_file_path.unlink()
-                    PrettyOutput.print(f"文件已删除", OutputType.SUCCESS)
+
                 except Exception as delete_error:
                     PrettyOutput.print(
                         f"删除文件失败: {str(delete_error)}", OutputType.ERROR

jarvis/jarvis_tools/read_code.py

@@ -44,7 +44,7 @@ class ReadCodeTool:
         """
         try:
             abs_path = os.path.abspath(filepath)
-            print(f"📖 正在读取文件: {abs_path}...")
+
             # 文件存在性检查
             if not os.path.exists(abs_path):
                 return {
@@ -69,7 +69,6 @@ class ReadCodeTool:
 
             # 处理空文件情况
             if total_lines == 0:
-                print(f"✅ 文件读取完成: {abs_path}")
                 return {
                     "success": True,
                     "stdout": f"\n🔍 文件: {abs_path}\n📄 文件为空 (0行)\n",
@@ -93,9 +92,7 @@ class ReadCodeTool:
             )
 
             if start_line > end_line:
-                print(
-                    f"❌ 无效的行范围 [{start_line}-{end_line}] (总行数: {total_lines})"
-                )
+
                 return {
                     "success": False,
                     "stdout": "",
@@ -117,7 +114,7 @@ class ReadCodeTool:
                 f"📄 原始行号: {start_line}-{end_line} (共{total_lines}行) \n\n"
                 f"{numbered_content}\n\n"
             )
-            print(f"✅ 文件读取完成: {abs_path}")
+
 
             if agent:
                 files = agent.get_user_data("files")

jarvis/jarvis_tools/read_webpage.py

@@ -48,7 +48,7 @@ class WebpageTool:
                 if model:
                     model.set_model_name(web_search_model)
                     if model.support_web():
-                        PrettyOutput.print("▶️ 使用配置的 Web 搜索平台读取网页...", OutputType.INFO)
+
                         model.set_web(True)
                         model.set_suppress_output(False)  # type: ignore
                         prompt = f"""请帮我处理这个网页：{url}
@@ -63,7 +63,7 @@ class WebpageTool:
             # 2) 然后尝试使用默认平台（normal）的 web 能力
             model = PlatformRegistry().get_normal_platform()
             if model.support_web():
-                PrettyOutput.print("▶️ 使用默认平台的 Web 能力读取网页...", OutputType.INFO)
+
                 model.set_web(True)
                 model.set_suppress_output(False)  # type: ignore
                 prompt = f"""请帮我处理这个网页：{url}
@@ -76,7 +76,7 @@ class WebpageTool:
                 return {"success": True, "stdout": response, "stderr": ""}
 
             # 3) 回退：使用 requests 抓取网页，再用模型分析
-            PrettyOutput.print("ℹ️ 当前模型不支持Web，使用requests抓取网页并进行分析。", OutputType.INFO)
+
             try:
                 resp = http_get(url, timeout=10.0, allow_redirects=True)
                 content_md = md(resp.text, strip=["script", "style"])
@@ -90,7 +90,7 @@ class WebpageTool:
             if not content_md or not content_md.strip():
                 return {"success": False, "stdout": "", "stderr": "无法从网页抓取有效内容。"}
 
-            PrettyOutput.print("🧠 正在分析抓取到的网页内容...", OutputType.INFO)
+
             summary_prompt = f"""以下是网页 {url} 的内容（已转换为Markdown）：
 ----------------
 {content_md}