jarvis-ai-assistant 0.3.30__py3-none-any.whl → 0.7.6__py3-none-any.whl

jarvis/jarvis_mcp/stdio_mcp_client.py

@@ -5,7 +5,6 @@ import subprocess
 from typing import Any, Dict, List, Optional
 
 from jarvis.jarvis_mcp import McpClient
-from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 
 
 class StdioMcpClient(McpClient):
@@ -50,7 +49,7 @@ class StdioMcpClient(McpClient):
             )
 
         except Exception as e:
-            PrettyOutput.print(f"启动MCP进程失败: {str(e)}", OutputType.ERROR)
+            print(f"❌ 启动MCP进程失败: {str(e)}")
             raise
 
     def _initialize(self) -> None:
@@ -79,7 +78,7 @@ class StdioMcpClient(McpClient):
             self._send_notification("notifications/initialized", {})
 
         except Exception as e:
-            PrettyOutput.print(f"MCP初始化失败: {str(e)}", OutputType.ERROR)
+            print(f"❌ MCP初始化失败: {str(e)}")
             raise
 
     def _send_request(self, method: str, params: Dict[str, Any]) -> Dict[str, Any]:
@@ -108,7 +107,7 @@ class StdioMcpClient(McpClient):
             return json.loads(response)
 
         except Exception as e:
-            PrettyOutput.print(f"发送请求失败: {str(e)}", OutputType.ERROR)
+            print(f"❌ 发送请求失败: {str(e)}")
             raise
 
     def _send_notification(self, method: str, params: Dict[str, Any]) -> None:
@@ -129,7 +128,7 @@ class StdioMcpClient(McpClient):
             self.process.stdin.flush()  # type: ignore
 
         except Exception as e:
-            PrettyOutput.print(f"发送通知失败: {str(e)}", OutputType.ERROR)
+            print(f"❌ 发送通知失败: {str(e)}")
             raise
 
     def get_tool_list(self) -> List[Dict[str, Any]]:
@@ -172,10 +171,10 @@ class StdioMcpClient(McpClient):
                 else:
                     error_msg += ": 未知错误"
 
-                PrettyOutput.print(error_msg, OutputType.ERROR)
+                print(f"❌ {error_msg}")
                 return []
         except Exception as e:
-            PrettyOutput.print(f"获取工具列表失败: {str(e)}", OutputType.ERROR)
+            print(f"❌ 获取工具列表失败: {str(e)}")
             return []
 
     def execute(self, tool_name: str, arguments: Dict[str, Any]) -> Dict[str, Any]:
@@ -214,7 +213,7 @@ class StdioMcpClient(McpClient):
                     "stderr": response.get("error", "Unknown error"),
                 }
         except Exception as e:
-            PrettyOutput.print(f"执行工具失败: {str(e)}", OutputType.ERROR)
+            print(f"❌ 执行工具失败: {str(e)}")
             return {"success": False, "stdout": "", "stderr": str(e)}
 
     def get_resource_list(self) -> List[Dict[str, Any]]:
@@ -237,10 +236,10 @@ class StdioMcpClient(McpClient):
                     error_msg += f": {response['error']}"
                 else:
                     error_msg += ": 未知错误"
-                PrettyOutput.print(error_msg, OutputType.ERROR)
+                print(f"❌ {error_msg}")
                 return []
         except Exception as e:
-            PrettyOutput.print(f"获取资源列表失败: {str(e)}", OutputType.ERROR)
+            print(f"❌ 获取资源列表失败: {str(e)}")
             return []
 
     def get_resource(self, uri: str) -> Dict[str, Any]:
@@ -281,11 +280,11 @@ class StdioMcpClient(McpClient):
                     error_msg += f": {response['error']}"
                 else:
                     error_msg += ": 未知错误"
-                PrettyOutput.print(error_msg, OutputType.ERROR)
+                print(f"❌ {error_msg}")
                 return {"success": False, "stdout": "", "stderr": error_msg}
         except Exception as e:
             error_msg = f"获取资源内容失败: {str(e)}"
-            PrettyOutput.print(error_msg, OutputType.ERROR)
+            print(f"❌ {error_msg}")
             return {"success": False, "stdout": "", "stderr": error_msg}
 
     def __del__(self):
@@ -296,6 +295,6 @@ class StdioMcpClient(McpClient):
                 self._send_notification("notifications/exit", {})
                 # 等待进程结束
                 self.process.wait(timeout=1)
-            except:
+            except Exception:
                 # 如果进程没有正常退出，强制终止
                 self.process.kill()

jarvis/jarvis_mcp/streamable_mcp_client.py

@@ -7,7 +7,6 @@ from urllib.parse import urljoin
 import requests  # type: ignore[import-untyped]
 
 from jarvis.jarvis_mcp import McpClient
-from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 
 
 class StreamableMcpClient(McpClient):
@@ -86,7 +85,7 @@ class StreamableMcpClient(McpClient):
             self._send_notification("notifications/initialized", {})
 
         except Exception as e:
-            PrettyOutput.print(f"MCP初始化失败: {str(e)}", OutputType.ERROR)
+            print(f"❌ MCP初始化失败: {str(e)}")
             raise
 
     def register_notification_handler(self, method: str, handler: Callable) -> None:
@@ -182,14 +181,16 @@ class StreamableMcpClient(McpClient):
                                         handler(params)
                                     except Exception as e:
                                         error_lines.append(f"处理通知时出错 ({notify_method}): {e}")
-                    except json.JSONDecodeError:
+                    except Exception:
                         warning_lines.append(f"无法解析响应: {line}")
                         continue
 
             if warning_lines:
-                PrettyOutput.print("\n".join(warning_lines), OutputType.WARNING)
+                joined_warnings = '\n'.join(warning_lines)
+                print(f"⚠️ {joined_warnings}")
             if error_lines:
-                PrettyOutput.print("\n".join(error_lines), OutputType.ERROR)
+                joined_errors = '\n'.join(error_lines)
+                print(f"❌ {joined_errors}")
             # Ensure response is closed after streaming
             response.close()
             if result is None:
@@ -198,7 +199,7 @@ class StreamableMcpClient(McpClient):
             return result
 
         except Exception as e:
-            PrettyOutput.print(f"发送请求失败: {str(e)}", OutputType.ERROR)
+            print(f"❌ 发送请求失败: {str(e)}")
             raise
         finally:
             # 清理请求状态
@@ -226,7 +227,7 @@ class StreamableMcpClient(McpClient):
             response.close()
 
         except Exception as e:
-            PrettyOutput.print(f"发送通知失败: {str(e)}", OutputType.ERROR)
+            print(f"❌ 发送通知失败: {str(e)}")
             raise
 
     def get_tool_list(self) -> List[Dict[str, Any]]:
@@ -269,10 +270,10 @@ class StreamableMcpClient(McpClient):
                 else:
                     error_msg += ": 未知错误"
 
-                PrettyOutput.print(error_msg, OutputType.ERROR)
+                print(f"❌ {error_msg}")
                 return []
         except Exception as e:
-            PrettyOutput.print(f"获取工具列表失败: {str(e)}", OutputType.ERROR)
+            print(f"❌ 获取工具列表失败: {str(e)}")
             return []
 
     def execute(self, tool_name: str, arguments: Dict[str, Any]) -> Dict[str, Any]:
@@ -311,7 +312,7 @@ class StreamableMcpClient(McpClient):
                     "stderr": response.get("error", "Unknown error"),
                 }
         except Exception as e:
-            PrettyOutput.print(f"执行工具失败: {str(e)}", OutputType.ERROR)
+            print(f"❌ 执行工具失败: {str(e)}")
             return {"success": False, "stdout": "", "stderr": str(e)}
 
     def get_resource_list(self) -> List[Dict[str, Any]]:
@@ -334,10 +335,10 @@ class StreamableMcpClient(McpClient):
                     error_msg += f": {response['error']}"
                 else:
                     error_msg += ": 未知错误"
-                PrettyOutput.print(error_msg, OutputType.ERROR)
+                print(f"❌ {error_msg}")
                 return []
         except Exception as e:
-            PrettyOutput.print(f"获取资源列表失败: {str(e)}", OutputType.ERROR)
+            print(f"❌ 获取资源列表失败: {str(e)}")
             return []
 
     def get_resource(self, uri: str) -> Dict[str, Any]:
@@ -378,11 +379,11 @@ class StreamableMcpClient(McpClient):
                     error_msg += f": {response['error']}"
                 else:
                     error_msg += ": 未知错误"
-                PrettyOutput.print(error_msg, OutputType.ERROR)
+                print(f"❌ {error_msg}")
                 return {"success": False, "stdout": "", "stderr": error_msg}
         except Exception as e:
             error_msg = f"获取资源内容失败: {str(e)}"
-            PrettyOutput.print(error_msg, OutputType.ERROR)
+            print(f"❌ {error_msg}")
             return {"success": False, "stdout": "", "stderr": error_msg}
 
     def __del__(self):

jarvis/jarvis_memory_organizer/memory_organizer.py

@@ -18,7 +18,6 @@ from jarvis.jarvis_utils.config import (
     get_normal_platform_name,
     get_normal_model_name,
 )
-from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 from jarvis.jarvis_platform.registry import PlatformRegistry
 from jarvis.jarvis_utils.utils import init_env
 
@@ -75,7 +74,8 @@ class MemoryOrganizer:
                 error_lines.append(f"读取记忆文件 {memory_file} 失败: {str(e)}")
 
         if error_lines:
-            PrettyOutput.print("\n".join(error_lines), OutputType.WARNING)
+            joined_errors = '\n'.join(error_lines)
+            print(f"⚠️ {joined_errors}")
 
         return memories
 
@@ -174,16 +174,13 @@ class MemoryOrganizer:
 4. 确保合并后的记忆保留了所有重要信息
 5. **重要**：越近期的记忆权重越高，优先保留最新记忆中的信息
 
-请将合并结果放在 <merged_memory> 标签内，使用YAML格式：
+请将合并结果放在 <merged_memory> 标签内，使用JSON格式：
 
 <merged_memory>
-content: |
-  合并后的记忆内容
-  可以是多行文本
-tags:
-  - 标签1
-  - 标签2
-  - 标签3
+{{
+  "content": "合并后的记忆内容，可以是多行文本",
+  "tags": ["标签1", "标签2", "标签3"]
+}}
 </merged_memory>
 
 注意：
@@ -192,6 +189,7 @@ tags:
 - 保持专业和客观的语气
 - 最近的记忆信息优先级更高
 - 只输出 <merged_memory> 标签内的内容，不要有其他说明
+- JSON格式必须有效，字符串中的换行符使用 \\n 表示
 """
 
         try:
@@ -203,32 +201,32 @@ tags:
 
             # 解析响应
             import re
-            import yaml
+            from jarvis.jarvis_utils.jsonnet_compat import loads as json5_loads
 
             # 提取 <merged_memory> 标签内的内容
-            yaml_match = re.search(
+            json_match = re.search(
                 r"<merged_memory>(.*?)</merged_memory>",
                 response,
                 re.DOTALL | re.IGNORECASE,
             )
 
-            if yaml_match:
-                yaml_content = yaml_match.group(1).strip()
+            if json_match:
+                json_content = json_match.group(1).strip()
                 try:
-                    result = yaml.safe_load(yaml_content)
+                    result = json5_loads(json_content)
                     return {
                         "content": result.get("content", ""),
                         "tags": result.get("tags", []),
                         "type": memories[0].get("type", "unknown"),
                         "merged_from": [m.get("id", "") for m in memories],
                     }
-                except yaml.YAMLError as e:
-                    raise ValueError(f"无法解析YAML内容: {str(e)}")
+                except (ValueError, Exception) as e:
+                    raise ValueError(f"无法解析JSON内容: {str(e)}")
             else:
                 raise ValueError("无法从模型响应中提取 <merged_memory> 标签内容")
 
         except Exception as e:
-            PrettyOutput.print(f"调用大模型合并记忆失败: {str(e)}", OutputType.WARNING)
+            print(f"⚠️ 调用大模型合并记忆失败: {str(e)}")
             # 返回 None 表示合并失败，跳过这组记忆
             return None
 
@@ -249,18 +247,15 @@ tags:
         返回：
             整理结果统计
         """
-        PrettyOutput.print(
-            f"开始整理{memory_type}类型的记忆，最小重叠标签数: {min_overlap}",
-            OutputType.INFO,
-        )
+        print(f"ℹ️ 开始整理{memory_type}类型的记忆，最小重叠标签数: {min_overlap}")
 
         # 加载记忆
         memories = self._load_memories(memory_type)
         if not memories:
-            PrettyOutput.print("没有找到需要整理的记忆", OutputType.INFO)
+            print("ℹ️ 没有找到需要整理的记忆")
             return {"processed": 0, "merged": 0}
 
-        PrettyOutput.print(f"加载了 {len(memories)} 个记忆", OutputType.INFO)
+        print(f"ℹ️ 加载了 {len(memories)} 个记忆")
 
         # 统计信息
         stats = {
@@ -293,10 +288,7 @@ tags:
 
             if overlap_count in overlap_groups:
                 groups = overlap_groups[overlap_count]
-                PrettyOutput.print(
-                    f"\n发现 {len(groups)} 个具有 {overlap_count} 个重叠标签的记忆组",
-                    OutputType.INFO,
-                )
+                print(f"\nℹ️ 发现 {len(groups)} 个具有 {overlap_count} 个重叠标签的记忆组")
 
                 for group in groups:
                     # 将活跃索引转换回原始索引
@@ -314,7 +306,8 @@ tags:
                             f"  - ID: {mem.get('id', '未知')}, "
                             f"标签: {', '.join(mem.get('tags', []))[:50]}..."
                         )
-                    PrettyOutput.print("\n".join(lines), OutputType.INFO)
+                    joined_lines = '\n'.join(lines)
+                    print(f"ℹ️ {joined_lines}")
 
                     if not dry_run:
                         # 合并记忆
@@ -322,9 +315,7 @@ tags:
 
                         # 如果合并失败，跳过这组
                         if merged_memory is None:
-                            PrettyOutput.print(
-                                "  跳过这组记忆的合并", OutputType.WARNING
-                            )
+                            print("  ⚠️ 跳过这组记忆的合并")
                             continue
 
                         # 保存新记忆
@@ -341,16 +332,14 @@ tags:
                         # 标记这些记忆已被删除
                         deleted_indices.update(original_indices)
                     else:
-                        PrettyOutput.print("  [模拟运行] 跳过实际合并", OutputType.INFO)
+                        print("  ℹ️ [模拟运行] 跳过实际合并")
 
         # 显示统计信息
-        PrettyOutput.print("\n整理完成！", OutputType.SUCCESS)
-        PrettyOutput.print(f"总记忆数: {stats['total_memories']}", OutputType.INFO)
-        PrettyOutput.print(f"处理的组数: {stats['processed_groups']}", OutputType.INFO)
-        PrettyOutput.print(f"合并的记忆数: {stats['merged_memories']}", OutputType.INFO)
-        PrettyOutput.print(
-            f"创建的新记忆数: {stats['created_memories']}", OutputType.INFO
-        )
+        print("\n✅ 整理完成！")
+        print(f"ℹ️ 总记忆数: {stats['total_memories']}")
+        print(f"ℹ️ 处理的组数: {stats['processed_groups']}")
+        print(f"ℹ️ 合并的记忆数: {stats['merged_memories']}")
+        print(f"ℹ️ 创建的新记忆数: {stats['created_memories']}")
 
         return stats
 
@@ -382,10 +371,7 @@ tags:
         with open(new_file, "w", encoding="utf-8") as f:
             json.dump(memory, f, ensure_ascii=False, indent=2)
 
-        PrettyOutput.print(
-            f"创建新记忆: {memory['id']} (标签: {', '.join(memory['tags'][:3])}...)",
-            OutputType.SUCCESS,
-        )
+        print(f"✅ 创建新记忆: {memory['id']} (标签: {', '.join(memory['tags'][:3])}...)")
 
         # 删除原始记忆文件（先汇总日志，最后统一打印）
         info_lines: List[str] = []
@@ -406,9 +392,11 @@ tags:
                         f"删除记忆文件失败 {orig_memory.get('file_path', '')}: {str(e)}"
                     )
         if info_lines:
-            PrettyOutput.print("\n".join(info_lines), OutputType.INFO)
+            joined_info = '\n'.join(info_lines)
+            print(f"ℹ️ {joined_info}")
         if warn_lines:
-            PrettyOutput.print("\n".join(warn_lines), OutputType.WARNING)
+            joined_warn = '\n'.join(warn_lines)
+            print(f"⚠️ {joined_warn}")
 
     def export_memories(
         self,
@@ -453,16 +441,15 @@ tags:
 
         # 统一展示导出进度日志
         if progress_lines:
-            PrettyOutput.print("\n".join(progress_lines), OutputType.INFO)
+            joined_progress = '\n'.join(progress_lines)
+            print(f"ℹ️ {joined_progress}")
 
         # 保存到文件
         output_file.parent.mkdir(parents=True, exist_ok=True)
         with open(output_file, "w", encoding="utf-8") as f:
             json.dump(all_memories, f, ensure_ascii=False, indent=2)
 
-        PrettyOutput.print(
-            f"成功导出 {len(all_memories)} 个记忆到 {output_file}", OutputType.SUCCESS
-        )
+        print(f"✅ 成功导出 {len(all_memories)} 个记忆到 {output_file}")
 
         return len(all_memories)
 
@@ -491,7 +478,7 @@ tags:
         if not isinstance(memories, list):
             raise ValueError("导入文件格式错误，应为记忆列表")
 
-        PrettyOutput.print(f"准备导入 {len(memories)} 个记忆", OutputType.INFO)
+        print(f"ℹ️ 准备导入 {len(memories)} 个记忆")
 
         # 统计导入结果
         import_stats: Dict[str, int] = defaultdict(int)
@@ -509,9 +496,7 @@ tags:
             elif memory_type == "global_long_term":
                 memory_dir = self.global_memory_dir / memory_type
             else:
-                PrettyOutput.print(
-                    f"跳过不支持的记忆类型: {memory_type}", OutputType.WARNING
-                )
+                print(f"⚠️ 跳过不支持的记忆类型: {memory_type}")
                 skipped_count += 1
                 continue
 
@@ -528,7 +513,7 @@ tags:
             memory_file = memory_dir / f"{memory_id}.json"
 
             if memory_file.exists() and not overwrite:
-                PrettyOutput.print(f"跳过已存在的记忆: {memory_id}", OutputType.INFO)
+                print(f"ℹ️ 跳过已存在的记忆: {memory_id}")
                 skipped_count += 1
                 continue
 
@@ -550,13 +535,14 @@ tags:
             import_stats[memory_type] += 1
 
         # 显示导入结果
-        PrettyOutput.print("\n导入完成！", OutputType.SUCCESS)
+        print("\n✅ 导入完成！")
         if import_stats:
             lines = [f"{memory_type}: 导入了 {count} 个记忆" for memory_type, count in import_stats.items()]
-            PrettyOutput.print("\n".join(lines), OutputType.INFO)
+            joined_lines = '\n'.join(lines)
+            print(f"ℹ️ {joined_lines}")
 
         if skipped_count > 0:
-            PrettyOutput.print(f"跳过了 {skipped_count} 个记忆", OutputType.WARNING)
+            print(f"⚠️ 跳过了 {skipped_count} 个记忆")
 
         return dict(import_stats)
 
@@ -602,14 +588,11 @@ def organize(
     """
     # 验证参数
     if memory_type not in ["project_long_term", "global_long_term"]:
-        PrettyOutput.print(
-            f"错误：不支持的记忆类型 '{memory_type}'，请选择 'project_long_term' 或 'global_long_term'",
-            OutputType.ERROR,
-        )
+        print(f"❌ 错误：不支持的记忆类型 '{memory_type}'，请选择 'project_long_term' 或 'global_long_term'")
         raise typer.Exit(1)
 
     if min_overlap < 2:
-        PrettyOutput.print("错误：最小重叠数必须大于等于2", OutputType.ERROR)
+        print("❌ 错误：最小重叠数必须大于等于2")
         raise typer.Exit(1)
 
     # 创建整理器并执行
@@ -629,7 +612,7 @@ def organize(
         # typer.Exit 是正常的退出方式，直接传播
         raise
     except Exception as e:
-        PrettyOutput.print(f"记忆整理失败: {str(e)}", OutputType.ERROR)
+        print(f"❌ 记忆整理失败: {str(e)}")
         raise typer.Exit(1)
 
 
@@ -672,10 +655,8 @@ def export(
         valid_types = ["project_long_term", "global_long_term"]
         invalid_types = [mt for mt in memory_types if mt not in valid_types]
         if invalid_types:
-            PrettyOutput.print(
-                "错误：不支持的记忆类型: " + ", ".join(f"'{mt}'" for mt in invalid_types),
-                OutputType.ERROR,
-            )
+            invalid_str = ", ".join(f"'{mt}'" for mt in invalid_types)
+            print(f"❌ 错误：不支持的记忆类型: {invalid_str}")
             raise typer.Exit(1)
 
         count = organizer.export_memories(
@@ -687,11 +668,11 @@ def export(
         if count > 0:
             raise typer.Exit(0)
         else:
-            PrettyOutput.print("没有找到要导出的记忆", OutputType.WARNING)
+            print("⚠️ 没有找到要导出的记忆")
             raise typer.Exit(0)
 
     except Exception as e:
-        PrettyOutput.print(f"导出失败: {str(e)}", OutputType.ERROR)
+        print(f"❌ 导出失败: {str(e)}")
         raise typer.Exit(1)
 
 
@@ -731,21 +712,21 @@ def import_memories(
         if total_imported > 0:
             raise typer.Exit(0)
         else:
-            PrettyOutput.print("没有导入任何记忆", OutputType.WARNING)
+            print("⚠️ 没有导入任何记忆")
             raise typer.Exit(0)
 
     except FileNotFoundError as e:
-        PrettyOutput.print(str(e), OutputType.ERROR)
+        print(f"❌ {str(e)}")
         raise typer.Exit(1)
     except Exception as e:
-        PrettyOutput.print(f"导入失败: {str(e)}", OutputType.ERROR)
+        print(f"❌ 导入失败: {str(e)}")
         raise typer.Exit(1)
 
 
 def main():
     """Application entry point"""
     # 统一初始化环境
-    init_env("欢迎使用记忆整理工具！")
+    init_env()
     app()