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

jarvis/jarvis_rag/cli.py

@@ -20,7 +20,6 @@ from jarvis.jarvis_utils.config import (
     get_rag_use_bm25,
     get_rag_use_rerank,
 )
-from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 
 
 def is_likely_text_file(file_path: Path) -> bool:
@@ -54,10 +53,10 @@ _project_root = os.path.abspath(
 if _project_root not in sys.path:
     sys.path.insert(0, _project_root)
 
-from jarvis.jarvis_platform.base import BasePlatform
-from jarvis.jarvis_platform.registry import PlatformRegistry
-from jarvis.jarvis_rag.llm_interface import LLMInterface
-from jarvis.jarvis_rag.rag_pipeline import JarvisRAGPipeline
+from jarvis.jarvis_platform.base import BasePlatform  # noqa: E402
+from jarvis.jarvis_platform.registry import PlatformRegistry  # noqa: E402
+from jarvis.jarvis_rag.llm_interface import LLMInterface  # noqa: E402
+from jarvis.jarvis_rag.rag_pipeline import JarvisRAGPipeline  # noqa: E402
 
 app = typer.Typer(
     name="jarvis-rag",
@@ -71,9 +70,8 @@ class _CustomPlatformLLM(LLMInterface):
 
     def __init__(self, platform: BasePlatform):
         self.platform = platform
-        PrettyOutput.print(
-            f"使用自定义LLM: 平台='{platform.platform_name()}', 模型='{platform.name()}'",
-            OutputType.INFO,
+        print(
+            f"ℹ️ 使用自定义LLM: 平台='{platform.platform_name()}', 模型='{platform.name()}'"
         )
 
     def generate(self, prompt: str, **kwargs) -> str:
@@ -88,15 +86,15 @@ def _create_custom_llm(platform_name: str, model_name: str) -> Optional[LLMInter
         registry = PlatformRegistry.get_global_platform_registry()
         platform_instance = registry.create_platform(platform_name)
         if not platform_instance:
-            PrettyOutput.print(
-                f"错误: 平台 '{platform_name}' 未找到。", OutputType.ERROR
+            print(
+                f"❌ 错误: 平台 '{platform_name}' 未找到。"
             )
             return None
         platform_instance.set_model_name(model_name)
         platform_instance.set_suppress_output(True)
         return _CustomPlatformLLM(platform_instance)
     except Exception as e:
-        PrettyOutput.print(f"创建自定义LLM时出错: {e}", OutputType.ERROR)
+        print(f"❌ 创建自定义LLM时出错: {e}")
         return None
 
 
@@ -120,13 +118,13 @@ def _load_ragignore_spec() -> Tuple[Optional[pathspec.PathSpec], Optional[Path]]
             with open(ignore_file_to_use, "r", encoding="utf-8") as f:
                 patterns = f.read().splitlines()
             spec = pathspec.PathSpec.from_lines("gitwildmatch", patterns)
-            PrettyOutput.print(
-                f"加载忽略规则: {ignore_file_to_use}", OutputType.SUCCESS
+            print(
+                f"✅ 加载忽略规则: {ignore_file_to_use}"
             )
             return spec, project_root_path
         except Exception as e:
-            PrettyOutput.print(
-                f"加载 {ignore_file_to_use.name} 文件失败: {e}", OutputType.WARNING
+            print(
+                f"⚠️ 加载 {ignore_file_to_use.name} 文件失败: {e}"
             )
 
     return None, None
@@ -178,7 +176,7 @@ def add_documents(
                 continue
 
             if path.is_dir():
-                PrettyOutput.print(f"正在扫描目录: {path}", OutputType.INFO)
+                print(f"ℹ️ 正在扫描目录: {path}")
                 for item in path.rglob("*"):
                     if item.is_file() and is_likely_text_file(item):
                         files_to_process.add(item)
@@ -186,12 +184,12 @@ def add_documents(
                 if is_likely_text_file(path):
                     files_to_process.add(path)
                 else:
-                    PrettyOutput.print(
-                        f"跳过可能的二进制文件: {path}", OutputType.WARNING
+                    print(
+                        f"⚠️ 跳过可能的二进制文件: {path}"
                     )
 
     if not files_to_process:
-        PrettyOutput.print("在指定路径中未找到任何文本文件。", OutputType.WARNING)
+        print("⚠️ 在指定路径中未找到任何文本文件。")
         return
 
     # 使用 .ragignore 过滤文件
@@ -212,19 +210,19 @@ def add_documents(
 
         ignored_count = initial_count - len(retained_files)
         if ignored_count > 0:
-            PrettyOutput.print(
-                f"根据 .ragignore 规则过滤掉 {ignored_count} 个文件。", OutputType.INFO
+            print(
+                f"ℹ️ 根据 .ragignore 规则过滤掉 {ignored_count} 个文件。"
             )
         files_to_process = retained_files
 
     if not files_to_process:
-        PrettyOutput.print(
-            "所有找到的文本文件都被忽略规则过滤掉了。", OutputType.WARNING
+        print(
+            "⚠️ 所有找到的文本文件都被忽略规则过滤掉了。"
         )
         return
 
-    PrettyOutput.print(
-        f"发现 {len(files_to_process)} 个独立文件待处理。", OutputType.INFO
+    print(
+        f"ℹ️ 发现 {len(files_to_process)} 个独立文件待处理。"
     )
 
     try:
@@ -252,38 +250,38 @@ def add_documents(
                 docs_batch.extend(loader.load())
                 loaded_msgs.append(f"已加载: {file_path} (文件 {i + 1}/{total_files})")
             except Exception as e:
-                PrettyOutput.print(f"加载失败 {file_path}: {e}", OutputType.WARNING)
+                print(f"⚠️ 加载失败 {file_path}: {e}")
 
             # 当批处理已满或是最后一个文件时处理批处理
             if docs_batch and (len(docs_batch) >= batch_size or (i + 1) == total_files):
                 if loaded_msgs:
-                    PrettyOutput.print("\n".join(loaded_msgs), OutputType.INFO)
+                    joined_msgs = '\n'.join(loaded_msgs)
+                    print(f"ℹ️ {joined_msgs}")
                     loaded_msgs = []
-                PrettyOutput.print(
-                    f"正在处理批次，包含 {len(docs_batch)} 个文档...", OutputType.INFO
+                print(
+                    f"ℹ️ 正在处理批次，包含 {len(docs_batch)} 个文档..."
                 )
                 pipeline.add_documents(docs_batch)
                 total_docs_added += len(docs_batch)
-                PrettyOutput.print(
-                    f"成功添加 {len(docs_batch)} 个文档。", OutputType.SUCCESS
+                print(
+                    f"✅ 成功添加 {len(docs_batch)} 个文档。"
                 )
                 docs_batch = []  # 清空批处理
 
-        # 最后统一打印可能残留的“已加载”信息
+        # 最后统一打印可能残留的"已加载"信息
         if loaded_msgs:
-            PrettyOutput.print("\n".join(loaded_msgs), OutputType.INFO)
+            print(f"ℹ️ {chr(10).join(loaded_msgs)}")
             loaded_msgs = []
         if total_docs_added == 0:
-            PrettyOutput.print("未能成功加载任何文档。", OutputType.ERROR)
+            print("❌ 未能成功加载任何文档。")
             raise typer.Exit(code=1)
 
-        PrettyOutput.print(
-            f"成功将 {total_docs_added} 个文档的内容添加至集合 '{collection_name}'。",
-            OutputType.SUCCESS,
+        print(
+            f"✅ 成功将 {total_docs_added} 个文档的内容添加至集合 '{collection_name}'。"
         )
 
     except Exception as e:
-        PrettyOutput.print(f"发生严重错误: {e}", OutputType.ERROR)
+        print(f"❌ 发生严重错误: {e}")
         raise typer.Exit(code=1)
 
 
@@ -310,7 +308,7 @@ def list_documents(
         results = collection.get()  # 获取集合中的所有项目
 
         if not results or not results["metadatas"]:
-            PrettyOutput.print("知识库中没有找到任何文档。", OutputType.INFO)
+            print("ℹ️ 知识库中没有找到任何文档。")
             return
 
         # 从元数据中提取唯一的源文件路径
@@ -322,8 +320,8 @@ def list_documents(
                     sources.add(source)
 
         if not sources:
-            PrettyOutput.print(
-                "知识库中没有找到任何带有源信息的文档。", OutputType.INFO
+            print(
+                "ℹ️ 知识库中没有找到任何带有源信息的文档。"
             )
             return
 
@@ -331,10 +329,11 @@ def list_documents(
         lines = [f"知识库 '{collection_name}' 中共有 {len(sources)} 个独立文档:"]
         for i, source in enumerate(sorted(list(sources)), 1):
             lines.append(f"  {i}. {source}")
-        PrettyOutput.print("\n".join(lines), OutputType.INFO)
+        joined_lines = '\n'.join(lines)
+        print(f"ℹ️ {joined_lines}")
 
     except Exception as e:
-        PrettyOutput.print(f"发生错误: {e}", OutputType.ERROR)
+        print(f"❌ 发生错误: {e}")
         raise typer.Exit(code=1)
 
 
@@ -380,15 +379,15 @@ def retrieve(
             use_query_rewrite=rewrite,
         )
 
-        PrettyOutput.print(f"正在为问题检索文档: '{question}'", OutputType.INFO)
+        print(f"ℹ️ 正在为问题检索文档: '{question}'")
         retrieved_docs = pipeline.retrieve_only(question, n_results=n_results)
 
         if not retrieved_docs:
-            PrettyOutput.print("未找到相关文档。", OutputType.INFO)
+            print("ℹ️ 未找到相关文档。")
             return
 
-        PrettyOutput.print(
-            f"成功检索到 {len(retrieved_docs)} 个文档:", OutputType.SUCCESS
+        print(
+            f"✅ 成功检索到 {len(retrieved_docs)} 个文档:"
         )
         from jarvis.jarvis_utils.globals import console
 
@@ -400,7 +399,7 @@ def retrieve(
             console.print(Markdown(f"```\n{content}\n```"))
 
     except Exception as e:
-        PrettyOutput.print(f"发生错误: {e}", OutputType.ERROR)
+        print(f"❌ 发生错误: {e}")
         raise typer.Exit(code=1)
 
 
@@ -437,7 +436,7 @@ def query(
 ):
     """查询RAG知识库并打印答案。"""
     if model and not platform:
-        PrettyOutput.print("错误: --model 需要指定 --platform。", OutputType.ERROR)
+        print("❌ 错误: --model 需要指定 --platform。")
         raise typer.Exit(code=1)
 
     try:
@@ -459,13 +458,13 @@ def query(
             use_rerank=use_rerank,
         )
 
-        PrettyOutput.print(f"正在查询: '{question}'", OutputType.INFO)
+        print(f"ℹ️ 正在查询: '{question}'")
         answer = pipeline.query(question)
 
-        PrettyOutput.print(answer, OutputType.SUCCESS)
+        print(f"✅ {answer}")
 
     except Exception as e:
-        PrettyOutput.print(f"发生错误: {e}", OutputType.ERROR)
+        print(f"❌ 发生错误: {e}")
         raise typer.Exit(code=1)
 
 
@@ -476,9 +475,8 @@ def _check_rag_dependencies():
     if not is_rag_installed():
         missing = get_missing_rag_modules()
         missing_str = f"缺少依赖: {', '.join(missing)}。" if missing else ""
-        PrettyOutput.print(
-            f"RAG依赖项未安装或不完整。{missing_str}请运行 'pip install \"jarvis-ai-assistant[rag]\"' 后重试。",
-            OutputType.ERROR,
+        print(
+            f"❌ RAG依赖项未安装或不完整。{missing_str}请运行 'pip install \"jarvis-ai-assistant[rag]\"' 后重试。"
         )
         raise typer.Exit(code=1)
 

jarvis/jarvis_rag/embedding_manager.py

@@ -6,7 +6,6 @@ from huggingface_hub import snapshot_download
 
 
 from .cache import EmbeddingCache
-from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 
 
 class EmbeddingManager:
@@ -27,8 +26,8 @@ class EmbeddingManager:
         """
         self.model_name = model_name
 
-        PrettyOutput.print(
-            f"初始化嵌入管理器, 模型: '{self.model_name}'...", OutputType.INFO
+        print(
+            f"ℹ️ 初始化嵌入管理器, 模型: '{self.model_name}'..."
         )
 
         # 缓存的salt是模型名称，以防止冲突
@@ -160,11 +159,10 @@ class EmbeddingManager:
                     pass
 
                 if had_local_candidate:
-                    PrettyOutput.print(
-                        "检测到本地模型路径但加载失败。为避免触发网络访问，已中止远程回退。\n"
+                    print(
+                        "❌ 检测到本地模型路径但加载失败。为避免触发网络访问，已中止远程回退。\n"
                         "请确认本地目录包含完整的 Transformers/Tokenizer 文件（如 config.json、model.safetensors、tokenizer.json/merges.txt 等），\n"
-                        "或在配置中将 embedding_model 设置为该本地目录，或将模型放置到默认的 Hugging Face 缓存目录（例如 ~/.cache/huggingface/hub）。",
-                        OutputType.ERROR,
+                        "或在配置中将 embedding_model 设置为该本地目录，或将模型放置到默认的 Hugging Face 缓存目录（例如 ~/.cache/huggingface/hub）。"
                     )
                     raise
 
@@ -176,12 +174,11 @@ class EmbeddingManager:
                     show_progress=True,
                 )
         except Exception as e:
-            PrettyOutput.print(
-                f"加载嵌入模型 '{self.model_name}' 时出错: {e}", OutputType.ERROR
+            print(
+                f"❌ 加载嵌入模型 '{self.model_name}' 时出错: {e}"
             )
-            PrettyOutput.print(
-                "请确保您已安装 'sentence_transformers' 和 'torch'。",
-                OutputType.WARNING,
+            print(
+                "⚠️ 请确保您已安装 'sentence_transformers' 和 'torch'。"
             )
             raise
 
@@ -210,9 +207,8 @@ class EmbeddingManager:
 
         # 为不在缓存中的文本计算嵌入
         if texts_to_embed:
-            PrettyOutput.print(
-                f"缓存未命中。正在为 {len(texts_to_embed)}/{len(texts)} 个文档计算嵌入。",
-                OutputType.INFO,
+            print(
+                f"ℹ️ 缓存未命中。正在为 {len(texts_to_embed)}/{len(texts)} 个文档计算嵌入。"
             )
             new_embeddings = self.model.embed_documents(texts_to_embed)
 
@@ -223,9 +219,8 @@ class EmbeddingManager:
             for i, embedding in zip(indices_to_embed, new_embeddings):
                 cached_embeddings[i] = embedding
         else:
-            PrettyOutput.print(
-                f"缓存命中。所有 {len(texts)} 个文档的嵌入均从缓存中检索。",
-                OutputType.SUCCESS,
+            print(
+                f"✅ 缓存命中。所有 {len(texts)} 个文档的嵌入均从缓存中检索。"
             )
 
         return cast(List[List[float]], cached_embeddings)

jarvis/jarvis_rag/llm_interface.py

@@ -3,7 +3,6 @@ from abc import ABC, abstractmethod
 from jarvis.jarvis_agent import Agent as JarvisAgent
 from jarvis.jarvis_platform.base import BasePlatform
 from jarvis.jarvis_platform.registry import PlatformRegistry
-from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 
 
 class LLMInterface(ABC):
@@ -39,7 +38,7 @@ class ToolAgent_LLM(LLMInterface):
         """
         初始化工具-代理 LLM 包装器。
         """
-        PrettyOutput.print("已初始化工具 Agent 作为最终应答者。", OutputType.INFO)
+        print("ℹ️ 已初始化工具 Agent 作为最终应答者。")
         self.allowed_tools = ["read_code", "execute_script"]
         # 为代理提供一个通用的系统提示
         self.system_prompt = "You are a helpful assistant. Please answer the user's question based on the provided context. You can use tools to find more information if needed."
@@ -79,7 +78,7 @@ class ToolAgent_LLM(LLMInterface):
             return str(final_answer)
 
         except Exception as e:
-            PrettyOutput.print(f"Agent 在执行过程中发生错误: {e}", OutputType.ERROR)
+            print(f"❌ Agent 在执行过程中发生错误: {e}")
             return "错误: Agent 未能成功生成回答。"
 
 
@@ -93,17 +92,17 @@ class JarvisPlatform_LLM(LLMInterface):
     def __init__(self):
         """
         初始化Jarvis平台LLM客户端。
+        使用cheap平台，适用于查询重写、相关性评估等对模型能力要求一般的任务。
         """
         try:
             self.registry = PlatformRegistry.get_global_platform_registry()
-            self.platform: BasePlatform = self.registry.get_normal_platform()
+            self.platform: BasePlatform = self.registry.get_cheap_platform()
             self.platform.set_suppress_output(False)  # 确保模型没有控制台输出
-            PrettyOutput.print(
-                f"已初始化 Jarvis 平台 LLM，模型: {self.platform.name()}",
-                OutputType.INFO,
+            print(
+                f"ℹ️ 已初始化 Jarvis 平台 LLM（cheap），模型: {self.platform.name()}"
             )
         except Exception as e:
-            PrettyOutput.print(f"初始化 Jarvis 平台 LLM 失败: {e}", OutputType.ERROR)
+            print(f"❌ 初始化 Jarvis 平台 LLM 失败: {e}")
             raise
 
     def generate(self, prompt: str, **kwargs) -> str:
@@ -121,5 +120,5 @@ class JarvisPlatform_LLM(LLMInterface):
             # 使用健壮的chat_until_success方法
             return self.platform.chat_until_success(prompt)
         except Exception as e:
-            PrettyOutput.print(f"调用 Jarvis 平台模型时发生错误: {e}", OutputType.ERROR)
+            print(f"❌ 调用 Jarvis 平台模型时发生错误: {e}")
             return "错误: 无法从本地LLM获取响应。"

jarvis/jarvis_rag/query_rewriter.py

@@ -1,6 +1,5 @@
 from typing import List
 from .llm_interface import LLMInterface
-from jarvis.jarvis_utils.output import PrettyOutput, OutputType
 
 
 class QueryRewriter:
@@ -57,10 +56,8 @@ English version of the query
             一个经过重写、搜索优化的查询列表。
         """
         prompt = self.rewrite_prompt_template.format(query=query)
-        PrettyOutput.print(
-            "正在将原始查询重写为多个搜索查询...",
-            output_type=OutputType.INFO,
-            timestamp=False,
+        print(
+            "ℹ️ 正在将原始查询重写为多个搜索查询..."
         )
 
         import re
@@ -80,34 +77,26 @@ English version of the query
                 rewritten_queries = [
                     line.strip() for line in content.split("\n") if line.strip()
                 ]
-                PrettyOutput.print(
-                    f"成功从LLM响应中提取到内容 (尝试 {attempts}/{max_retries})。",
-                    output_type=OutputType.SUCCESS,
-                    timestamp=False,
+                print(
+                    f"✅ 成功从LLM响应中提取到内容 (尝试 {attempts}/{max_retries})。"
                 )
                 break  # 提取成功，退出循环
             else:
-                PrettyOutput.print(
-                    f"未能从LLM响应中提取内容。正在重试... ({attempts}/{max_retries})",
-                    output_type=OutputType.WARNING,
-                    timestamp=False,
+                print(
+                    f"⚠️ 未能从LLM响应中提取内容。正在重试... ({attempts}/{max_retries})"
                 )
 
         # 如果所有重试都失败，则跳过重写步骤
         if not rewritten_queries:
-            PrettyOutput.print(
-                "所有重试均失败。跳过查询重写，将仅使用原始查询。",
-                output_type=OutputType.ERROR,
-                timestamp=False,
+            print(
+                "❌ 所有重试均失败。跳过查询重写，将仅使用原始查询。"
             )
 
         # 同时包含原始查询以保证鲁棒性
         if query not in rewritten_queries:
             rewritten_queries.insert(0, query)
 
-        PrettyOutput.print(
-            f"生成了 {len(rewritten_queries)} 个查询变体。",
-            output_type=OutputType.SUCCESS,
-            timestamp=False,
+        print(
+            f"✅ 生成了 {len(rewritten_queries)} 个查询变体。"
         )
         return rewritten_queries

jarvis/jarvis_rag/rag_pipeline.py

@@ -8,7 +8,6 @@ from .llm_interface import JarvisPlatform_LLM, LLMInterface, ToolAgent_LLM
 from .query_rewriter import QueryRewriter
 from .reranker import Reranker
 from .retriever import ChromaRetriever
-from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 from jarvis.jarvis_utils.config import (
     get_rag_embedding_model,
     get_rag_rerank_model,
@@ -79,8 +78,8 @@ class JarvisRAGPipeline:
         self._reranker: Optional[Reranker] = None
         self._query_rewriter: Optional[QueryRewriter] = None
 
-        PrettyOutput.print(
-            "JarvisRAGPipeline 初始化成功 (模型按需加载).", OutputType.SUCCESS
+        print(
+            "✅ JarvisRAGPipeline 初始化成功 (模型按需加载)."
         )
 
     def _get_embedding_manager(self) -> EmbeddingManager:
@@ -172,18 +171,19 @@ class JarvisRAGPipeline:
                 lines.extend([f"  变更: {p}" for p in changed[:3]])
             if deleted:
                 lines.extend([f"  删除: {p}" for p in deleted[:3]])
-            PrettyOutput.print("\n".join(lines), OutputType.WARNING)
+            joined_lines = '\n'.join(lines)
+            print(f"⚠️ {joined_lines}")
             # 询问用户
             if get_yes_no(
                 "检测到索引变更，是否现在更新索引后再开始检索？", default=True
             ):
                 retriever.update_index_for_changes(changed, deleted)
             else:
-                PrettyOutput.print(
-                    "已跳过索引更新，将直接使用当前索引进行检索。", OutputType.INFO
+                print(
+                    "ℹ️ 已跳过索引更新，将直接使用当前索引进行检索。"
                 )
         except Exception as e:
-            PrettyOutput.print(f"检索前索引检查失败：{e}", OutputType.WARNING)
+            print(f"⚠️ 检索前索引检查失败：{e}")
 
     def add_documents(self, documents: List[Document]):
         """
@@ -236,16 +236,15 @@ class JarvisRAGPipeline:
         if self.use_query_rewrite:
             rewritten_queries = self._get_query_rewriter().rewrite(query_text)
         else:
-            PrettyOutput.print(
-                "已关闭查询重写，将直接使用原始查询进行检索。",
-                OutputType.INFO,
+            print(
+                "ℹ️ 已关闭查询重写，将直接使用原始查询进行检索。"
             )
             rewritten_queries = [query_text]
 
         # 2. 为每个重写的查询检索初始候选文档
-        PrettyOutput.print(
-            "将为以下查询变体进行混合检索:\n" + "\n".join([f"  - {q}" for q in rewritten_queries]),
-            OutputType.INFO,
+        query_lines = '\n'.join([f'  - {q}' for q in rewritten_queries])
+        print(
+            f"ℹ️ 将为以下查询变体进行混合检索:\n{query_lines}"
         )
         all_candidate_docs = []
         for q in rewritten_queries:
@@ -263,9 +262,8 @@ class JarvisRAGPipeline:
 
         # 3. 根据*原始*查询对统一的候选池进行重排
         if self.use_rerank:
-            PrettyOutput.print(
-                f"正在对 {len(unique_candidate_docs)} 个候选文档进行重排（基于原始问题）...",
-                OutputType.INFO,
+            print(
+                f"ℹ️ 正在对 {len(unique_candidate_docs)} 个候选文档进行重排（基于原始问题）..."
             )
             retrieved_docs = self._get_reranker().rerank(
                 query_text, unique_candidate_docs, top_n=n_results
@@ -289,13 +287,14 @@ class JarvisRAGPipeline:
         if sources:
             # 合并来源列表后一次性打印，避免多次加框
             lines = ["根据以下文档回答:"] + [f"  - {source}" for source in sources]
-            PrettyOutput.print("\n".join(lines), OutputType.INFO)
+            joined_lines = '\n'.join(lines)
+            print(f"ℹ️ {joined_lines}")
 
         # 4. 创建最终提示并生成答案
         # 我们使用原始的query_text作为给LLM的最终提示
         prompt = self._create_prompt(query_text, retrieved_docs)
 
-        PrettyOutput.print("正在从LLM生成答案...", OutputType.INFO)
+        print("ℹ️ 正在从LLM生成答案...")
         answer = self.llm.generate(prompt)
 
         return answer
@@ -317,16 +316,15 @@ class JarvisRAGPipeline:
         if self.use_query_rewrite:
             rewritten_queries = self._get_query_rewriter().rewrite(query_text)
         else:
-            PrettyOutput.print(
-                "已关闭查询重写，将直接使用原始查询进行检索。",
-                OutputType.INFO,
+            print(
+                "ℹ️ 已关闭查询重写，将直接使用原始查询进行检索。"
             )
             rewritten_queries = [query_text]
 
         # 2. 检索候选文档
-        PrettyOutput.print(
-            "将为以下查询变体进行混合检索:\n" + "\n".join([f"  - {q}" for q in rewritten_queries]),
-            OutputType.INFO,
+        query_lines = '\n'.join([f'  - {q}' for q in rewritten_queries])
+        print(
+            f"ℹ️ 将为以下查询变体进行混合检索:\n{query_lines}"
         )
         all_candidate_docs = []
         for q in rewritten_queries:
@@ -343,9 +341,8 @@ class JarvisRAGPipeline:
 
         # 3. 重排
         if self.use_rerank:
-            PrettyOutput.print(
-                f"正在对 {len(unique_candidate_docs)} 个候选文档进行重排...",
-                OutputType.INFO,
+            print(
+                f"ℹ️ 正在对 {len(unique_candidate_docs)} 个候选文档进行重排..."
             )
             retrieved_docs = self._get_reranker().rerank(
                 query_text, unique_candidate_docs, top_n=n_results

jarvis/jarvis_rag/reranker.py

@@ -6,7 +6,6 @@ from sentence_transformers.cross_encoder import (  # type: ignore
     CrossEncoder,
 )
 from huggingface_hub import snapshot_download
-from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 
 
 class Reranker:
@@ -22,13 +21,13 @@ class Reranker:
         参数:
             model_name (str): 要使用的Cross-Encoder模型的名称。
         """
-        PrettyOutput.print(f"正在初始化重排模型: {model_name}...", OutputType.INFO)
+        print(f"ℹ️ 正在初始化重排模型: {model_name}...")
         try:
             local_dir = None
 
             if os.path.isdir(model_name):
                 self.model = CrossEncoder(model_name)
-                PrettyOutput.print("重排模型初始化成功。", OutputType.SUCCESS)
+                print("✅ 重排模型初始化成功。")
                 return
             try:
                 # Prefer local cache; avoid any network access
@@ -41,9 +40,9 @@ class Reranker:
             else:
                 self.model = CrossEncoder(model_name)
 
-            PrettyOutput.print("重排模型初始化成功。", OutputType.SUCCESS)
+            print("✅ 重排模型初始化成功。")
         except Exception as e:
-            PrettyOutput.print(f"初始化重排模型失败: {e}", OutputType.ERROR)
+            print(f"❌ 初始化重排模型失败: {e}")
             raise
 
     def rerank(