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

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  # type: ignore[import-untyped]
+            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()
 
 

jarvis/jarvis_methodology/main.py

@@ -20,7 +20,6 @@ from jarvis.jarvis_utils.methodology import (
     _get_methodology_directory,
     _load_all_methodologies,
 )
-from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 
 app = typer.Typer(help="方法论管理工具")
 
@@ -55,12 +54,9 @@ def import_methodology(
                     indent=2,
                 )
 
-        PrettyOutput.print(
-            f"成功导入 {len(import_data)} 个方法论（总计 {len(merged_data)} 个）",
-            OutputType.SUCCESS,
-        )
-    except (json.JSONDecodeError, OSError) as e:
-        PrettyOutput.print(f"导入失败: {str(e)}", OutputType.ERROR)
+        print(f"✅ 成功导入 {len(import_data)} 个方法论（总计 {len(merged_data)} 个）")
+    except (ValueError, OSError) as e:
+        print(f"❌ 导入失败: {str(e)}")
         raise typer.Exit(code=1)
 
 
@@ -73,12 +69,9 @@ def export_methodology(output_file: str = typer.Argument(..., help="导出文件
         with open(output_file, "w", encoding="utf-8") as f:
             json.dump(methodologies, f, ensure_ascii=False, indent=2)
 
-        PrettyOutput.print(
-            f"成功导出 {len(methodologies)} 个方法论到 {output_file}",
-            OutputType.SUCCESS,
-        )
+        print(f"✅ 成功导出 {len(methodologies)} 个方法论到 {output_file}")
     except (OSError, TypeError) as e:
-        PrettyOutput.print(f"导出失败: {str(e)}", OutputType.ERROR)
+        print(f"❌ 导出失败: {str(e)}")
         raise typer.Exit(code=1)
 
 
@@ -89,16 +82,17 @@ def list_methodologies():
         methodologies = _load_all_methodologies()
 
         if not methodologies:
-            PrettyOutput.print("没有找到方法论", OutputType.INFO)
+            print("ℹ️ 没有找到方法论")
             return
 
         # 先拼接再统一打印，避免在循环中逐条输出造成信息稀疏
         lines = ["可用方法论:"]
         for i, (problem_type, _) in enumerate(methodologies.items(), 1):
             lines.append(f"{i}. {problem_type}")
-        PrettyOutput.print("\n".join(lines), OutputType.INFO)
-    except (OSError, json.JSONDecodeError) as e:
-        PrettyOutput.print(f"列出方法论失败: {str(e)}", OutputType.ERROR)
+        joined_lines = '\n'.join(lines)
+        print(f"ℹ️ {joined_lines}")
+    except (OSError, ValueError) as e:
+        print(f"❌ 列出方法论失败: {str(e)}")
         raise typer.Exit(code=1)
 
 
@@ -144,22 +138,20 @@ def extract_methodology(
 """
 
         # 调用大模型平台提取方法论
-        PrettyOutput.print("正在提取方法论...", OutputType.INFO)
+        print("ℹ️ 正在提取方法论...")
         try:
             response = platform.chat_until_success(prompt)
         except Exception as e:
-            PrettyOutput.print("提取失败", OutputType.ERROR)
-            PrettyOutput.print(f"提取方法论失败: {str(e)}", OutputType.ERROR)
+            print("❌ 提取失败")
+            print(f"❌ 提取方法论失败: {str(e)}")
             raise typer.Exit(code=1)
 
         # 提取YAML部分
         methodologies_start = response.find("<methodologies>") + len("<methodologies>")
         methodologies_end = response.find("</methodologies>")
         if methodologies_start == -1 or methodologies_end == -1:
-            PrettyOutput.print("响应格式无效", OutputType.ERROR)
-            PrettyOutput.print(
-                "大模型未返回有效的<methodologies>格式", OutputType.ERROR
-            )
+            print("❌ 响应格式无效")
+            print("❌ 大模型未返回有效的<methodologies>格式")
             raise typer.Exit(code=1)
 
         yaml_content = response[methodologies_start:methodologies_end].strip()
@@ -170,14 +162,14 @@ def extract_methodology(
                 item["problem_type"]: item["content"] for item in data
             }
         except (yaml.YAMLError, KeyError, TypeError) as e:
-            PrettyOutput.print("YAML解析失败", OutputType.ERROR)
-            PrettyOutput.print(f"YAML解析错误: {str(e)}", OutputType.ERROR)
+            print("❌ YAML解析失败")
+            print(f"❌ YAML解析错误: {str(e)}")
             raise typer.Exit(code=1)
 
         if not extracted_methodologies:
-            PrettyOutput.print("未提取到有效方法论", OutputType.WARNING)
+            print("⚠️ 未提取到有效方法论")
             return
-        PrettyOutput.print("提取到有效方法论", OutputType.SUCCESS)
+        print("✅ 提取到有效方法论")
 
         # 加载现有方法论
         existing_methodologies = _load_all_methodologies()
@@ -199,12 +191,9 @@ def extract_methodology(
                     indent=2,
                 )
 
-        PrettyOutput.print(
-            f"成功从文件提取 {len(extracted_methodologies)} 个方法论（总计 {len(merged_data)} 个）",
-            OutputType.SUCCESS,
-        )
+        print(f"✅ 成功从文件提取 {len(extracted_methodologies)} 个方法论（总计 {len(merged_data)} 个）")
     except Exception as e:
-        PrettyOutput.print(f"提取失败: {str(e)}", OutputType.ERROR)
+        print(f"❌ 提取失败: {str(e)}")
         raise typer.Exit(code=1)
 
 
@@ -247,22 +236,20 @@ def extract_methodology_from_url(
 6. 内容字段使用|保留多行格式
 """
         # 调用大模型平台提取方法论
-        PrettyOutput.print("正在从URL提取方法论...", OutputType.INFO)
+        print("ℹ️ 正在从URL提取方法论...")
         try:
             response = platform.chat_until_success(prompt)
         except Exception as e:
-            PrettyOutput.print("提取失败", OutputType.ERROR)
-            PrettyOutput.print(f"提取方法论失败: {str(e)}", OutputType.ERROR)
+            print("❌ 提取失败")
+            print(f"❌ 提取方法论失败: {str(e)}")
             raise typer.Exit(code=1)
 
         # 提取YAML部分
         methodologies_start = response.find("<methodologies>") + len("<methodologies>")
         methodologies_end = response.find("</methodologies>")
         if methodologies_start == -1 or methodologies_end == -1:
-            PrettyOutput.print("响应格式无效", OutputType.ERROR)
-            PrettyOutput.print(
-                "大模型未返回有效的<methodologies>格式", OutputType.ERROR
-            )
+            print("❌ 响应格式无效")
+            print("❌ 大模型未返回有效的<methodologies>格式")
             raise typer.Exit(code=1)
 
         yaml_content = response[methodologies_start:methodologies_end].strip()
@@ -273,14 +260,14 @@ def extract_methodology_from_url(
                 item["problem_type"]: item["content"] for item in data
             }
         except (yaml.YAMLError, KeyError, TypeError) as e:
-            PrettyOutput.print("YAML解析失败", OutputType.ERROR)
-            PrettyOutput.print(f"YAML解析错误: {str(e)}", OutputType.ERROR)
+            print("❌ YAML解析失败")
+            print(f"❌ YAML解析错误: {str(e)}")
             raise typer.Exit(code=1)
 
         if not extracted_methodologies:
-            PrettyOutput.print("未提取到有效方法论", OutputType.WARNING)
+            print("⚠️ 未提取到有效方法论")
             return
-        PrettyOutput.print("提取到有效方法论", OutputType.SUCCESS)
+        print("✅ 提取到有效方法论")
 
         # 加载现有方法论
         existing_methodologies = _load_all_methodologies()
@@ -302,12 +289,9 @@ def extract_methodology_from_url(
                     indent=2,
                 )
 
-        PrettyOutput.print(
-            f"成功从URL提取 {len(extracted_methodologies)} 个方法论（总计 {len(merged_data)} 个）",
-            OutputType.SUCCESS,
-        )
+        print(f"✅ 成功从URL提取 {len(extracted_methodologies)} 个方法论（总计 {len(merged_data)} 个）")
     except Exception as e:
-        PrettyOutput.print(f"从URL提取失败: {str(e)}", OutputType.ERROR)
+        print(f"❌ 从URL提取失败: {str(e)}")
         raise typer.Exit(code=1)