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

jarvis/jarvis_rag/embedding_manager.py

@@ -3,6 +3,7 @@ from typing import List, cast
 from langchain_huggingface import HuggingFaceEmbeddings
 
 from .cache import EmbeddingCache
+from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 
 
 class EmbeddingManager:
@@ -23,7 +24,7 @@ class EmbeddingManager:
         """
         self.model_name = model_name
 
-        print(f"🚀 初始化嵌入管理器, 模型: '{self.model_name}'...")
+        PrettyOutput.print(f"初始化嵌入管理器, 模型: '{self.model_name}'...", OutputType.INFO)
 
         # 缓存的salt是模型名称，以防止冲突
         self.cache = EmbeddingCache(cache_dir=cache_dir, salt=self.model_name)
@@ -42,8 +43,8 @@ class EmbeddingManager:
                 show_progress=True,
             )
         except Exception as e:
-            print(f"❌ 加载嵌入模型 '{self.model_name}' 时出错: {e}")
-            print("请确保您已安装 'sentence_transformers' 和 'torch'。")
+            PrettyOutput.print(f"加载嵌入模型 '{self.model_name}' 时出错: {e}", OutputType.ERROR)
+            PrettyOutput.print("请确保您已安装 'sentence_transformers' 和 'torch'。", OutputType.WARNING)
             raise
 
     def embed_documents(self, texts: List[str]) -> List[List[float]]:
@@ -71,8 +72,9 @@ class EmbeddingManager:
 
         # 为不在缓存中的文本计算嵌入
         if texts_to_embed:
-            print(
-                f"🔎 缓存未命中。正在为 {len(texts_to_embed)}/{len(texts)} 个文档计算嵌入。"
+            PrettyOutput.print(
+                f"缓存未命中。正在为 {len(texts_to_embed)}/{len(texts)} 个文档计算嵌入。",
+                OutputType.INFO,
             )
             new_embeddings = self.model.embed_documents(texts_to_embed)
 
@@ -83,7 +85,10 @@ class EmbeddingManager:
             for i, embedding in zip(indices_to_embed, new_embeddings):
                 cached_embeddings[i] = embedding
         else:
-            print(f"✅ 缓存命中。所有 {len(texts)} 个文档的嵌入均从缓存中检索。")
+            PrettyOutput.print(
+                f"缓存命中。所有 {len(texts)} 个文档的嵌入均从缓存中检索。",
+                OutputType.SUCCESS,
+            )
 
         return cast(List[List[float]], cached_embeddings)
 

jarvis/jarvis_rag/llm_interface.py

@@ -6,6 +6,7 @@ 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):
@@ -41,7 +42,7 @@ class ToolAgent_LLM(LLMInterface):
         """
         初始化工具-代理 LLM 包装器。
         """
-        print("🤖 已初始化工具 Agent 作为最终应答者。")
+        PrettyOutput.print("已初始化工具 Agent 作为最终应答者。", OutputType.INFO)
         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."
@@ -83,7 +84,7 @@ class ToolAgent_LLM(LLMInterface):
             return str(final_answer)
 
         except Exception as e:
-            print(f"❌ Agent 在执行过程中发生错误: {e}")
+            PrettyOutput.print(f"Agent 在执行过程中发生错误: {e}", OutputType.ERROR)
             return "错误: Agent 未能成功生成回答。"
 
 
@@ -102,9 +103,9 @@ class JarvisPlatform_LLM(LLMInterface):
             self.registry = PlatformRegistry.get_global_platform_registry()
             self.platform: BasePlatform = self.registry.get_normal_platform()
             self.platform.set_suppress_output(False)  # 确保模型没有控制台输出
-            print(f"🚀 已初始化 Jarvis 平台 LLM，模型: {self.platform.name()}")
+            PrettyOutput.print(f"已初始化 Jarvis 平台 LLM，模型: {self.platform.name()}", OutputType.INFO)
         except Exception as e:
-            print(f"❌ 初始化 Jarvis 平台 LLM 失败: {e}")
+            PrettyOutput.print(f"初始化 Jarvis 平台 LLM 失败: {e}", OutputType.ERROR)
             raise
 
     def generate(self, prompt: str, **kwargs) -> str:
@@ -122,5 +123,5 @@ class JarvisPlatform_LLM(LLMInterface):
             # 使用健壮的chat_until_success方法
             return self.platform.chat_until_success(prompt)
         except Exception as e:
-            print(f"❌ 调用 Jarvis 平台模型时发生错误: {e}")
+            PrettyOutput.print(f"调用 Jarvis 平台模型时发生错误: {e}", OutputType.ERROR)
             return "错误: 无法从本地LLM获取响应。"

jarvis/jarvis_rag/rag_pipeline.py

@@ -8,6 +8,7 @@ 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,
@@ -74,7 +75,7 @@ class JarvisRAGPipeline:
         self._reranker: Optional[Reranker] = None
         self._query_rewriter: Optional[QueryRewriter] = None
 
-        print("✅ JarvisRAGPipeline 初始化成功 (模型按需加载).")
+        PrettyOutput.print("JarvisRAGPipeline 初始化成功 (模型按需加载).", OutputType.SUCCESS)
 
     def _get_embedding_manager(self) -> EmbeddingManager:
         if self._embedding_manager is None:
@@ -193,7 +194,7 @@ class JarvisRAGPipeline:
         # 2. 为每个重写的查询检索初始候选文档
         all_candidate_docs = []
         for q in rewritten_queries:
-            print(f"🔍 正在为查询变体 '{q}' 进行混合检索...")
+            PrettyOutput.print(f"正在为查询变体 '{q}' 进行混合检索...", OutputType.INFO)
             candidates = self._get_retriever().retrieve(
                 q, n_results=n_results * 2, use_bm25=self.use_bm25
             )
@@ -208,7 +209,7 @@ class JarvisRAGPipeline:
 
         # 3. 根据*原始*查询对统一的候选池进行重排
         if self.use_rerank:
-            print(f"🔍 正在对 {len(unique_candidate_docs)} 个候选文档进行重排（基于原始问题）...")
+            PrettyOutput.print(f"正在对 {len(unique_candidate_docs)} 个候选文档进行重排（基于原始问题）...", OutputType.INFO)
             retrieved_docs = self._get_reranker().rerank(
                 query_text, unique_candidate_docs, top_n=n_results
             )
@@ -229,15 +230,15 @@ class JarvisRAGPipeline:
             )
         )
         if sources:
-            print(f"📚 根据以下文档回答:")
+            PrettyOutput.print("根据以下文档回答:", OutputType.INFO)
             for source in sources:
-                print(f"  - {source}")
+                PrettyOutput.print(f"  - {source}", OutputType.INFO)
 
         # 4. 创建最终提示并生成答案
         # 我们使用原始的query_text作为给LLM的最终提示
         prompt = self._create_prompt(query_text, retrieved_docs)
 
-        print("🤖 正在从LLM生成答案...")
+        PrettyOutput.print("正在从LLM生成答案...", OutputType.INFO)
         answer = self.llm.generate(prompt)
 
         return answer
@@ -259,7 +260,7 @@ class JarvisRAGPipeline:
         # 2. 检索候选文档
         all_candidate_docs = []
         for q in rewritten_queries:
-            print(f"🔍 正在为查询变体 '{q}' 进行混合检索...")
+            PrettyOutput.print(f"正在为查询变体 '{q}' 进行混合检索...", OutputType.INFO)
             candidates = self._get_retriever().retrieve(
                 q, n_results=n_results * 2, use_bm25=self.use_bm25
             )
@@ -273,7 +274,7 @@ class JarvisRAGPipeline:
 
         # 3. 重排
         if self.use_rerank:
-            print(f"🔍 正在对 {len(unique_candidate_docs)} 个候选文档进行重排...")
+            PrettyOutput.print(f"正在对 {len(unique_candidate_docs)} 个候选文档进行重排...", OutputType.INFO)
             retrieved_docs = self._get_reranker().rerank(
                 query_text, unique_candidate_docs, top_n=n_results
             )

jarvis/jarvis_rag/reranker.py

@@ -4,6 +4,7 @@ from langchain.docstore.document import Document
 from sentence_transformers.cross_encoder import (  # type: ignore
     CrossEncoder,
 )
+from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 
 
 class Reranker:
@@ -19,9 +20,9 @@ class Reranker:
         参数:
             model_name (str): 要使用的Cross-Encoder模型的名称。
         """
-        print(f"🔍 正在初始化重排模型: {model_name}...")
+        PrettyOutput.print(f"正在初始化重排模型: {model_name}...", OutputType.INFO)
         self.model = CrossEncoder(model_name)
-        print("✅ 重排模型初始化成功。")
+        PrettyOutput.print("重排模型初始化成功。", OutputType.SUCCESS)
 
     def rerank(
         self, query: str, documents: List[Document], top_n: int = 5

jarvis/jarvis_rag/retriever.py

@@ -8,6 +8,7 @@ from langchain.text_splitter import RecursiveCharacterTextSplitter
 from rank_bm25 import BM25Okapi  # type: ignore
 
 from .embedding_manager import EmbeddingManager
+from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 
 
 class ChromaRetriever:
@@ -39,7 +40,10 @@ class ChromaRetriever:
         self.collection = self.client.get_or_create_collection(
             name=self.collection_name
         )
-        print(f"✅ ChromaDB 客户端已在 '{db_path}' 初始化，集合为 '{collection_name}'。")
+        PrettyOutput.print(
+            f"ChromaDB 客户端已在 '{db_path}' 初始化，集合为 '{collection_name}'。",
+            OutputType.SUCCESS,
+        )
 
         # BM25索引设置
         self.bm25_index_path = os.path.join(self.db_path, f"{collection_name}_bm25.pkl")
@@ -48,24 +52,24 @@ class ChromaRetriever:
     def _load_or_initialize_bm25(self):
         """从磁盘加载BM25索引或初始化一个新索引。"""
         if os.path.exists(self.bm25_index_path):
-            print("🔍 正在加载现有的 BM25 索引...")
+            PrettyOutput.print("正在加载现有的 BM25 索引...", OutputType.INFO)
             with open(self.bm25_index_path, "rb") as f:
                 data = pickle.load(f)
                 self.bm25_corpus = data["corpus"]
                 self.bm25_index = BM25Okapi(self.bm25_corpus)
-            print("✅ BM25 索引加载成功。")
+            PrettyOutput.print("BM25 索引加载成功。", OutputType.SUCCESS)
         else:
-            print("⚠️ 未找到 BM25 索引，将初始化一个新的。")
+            PrettyOutput.print("未找到 BM25 索引，将初始化一个新的。", OutputType.WARNING)
             self.bm25_corpus = []
             self.bm25_index = None
 
     def _save_bm25_index(self):
         """将BM25索引保存到磁盘。"""
         if self.bm25_index:
-            print("💾 正在保存 BM25 索引...")
+            PrettyOutput.print("正在保存 BM25 索引...", OutputType.INFO)
             with open(self.bm25_index_path, "wb") as f:
                 pickle.dump({"corpus": self.bm25_corpus, "index": self.bm25_index}, f)
-            print("✅ BM25 索引保存成功。")
+            PrettyOutput.print("BM25 索引保存成功。", OutputType.SUCCESS)
 
     def add_documents(
         self, documents: List[Document], chunk_size=1000, chunk_overlap=100
@@ -78,7 +82,10 @@ class ChromaRetriever:
         )
         chunks = text_splitter.split_documents(documents)
 
-        print(f"📄 已将 {len(documents)} 个文档拆分为 {len(chunks)} 个块。")
+        PrettyOutput.print(
+            f"已将 {len(documents)} 个文档拆分为 {len(chunks)} 个块。",
+            OutputType.INFO,
+        )
 
         if not chunks:
             return
@@ -97,7 +104,10 @@ class ChromaRetriever:
             documents=chunk_texts,
             metadatas=cast(Any, metadatas),
         )
-        print(f"✅ 成功将 {len(chunks)} 个块添加到 ChromaDB 集合中。")
+        PrettyOutput.print(
+            f"成功将 {len(chunks)} 个块添加到 ChromaDB 集合中。",
+            OutputType.SUCCESS,
+        )
 
         # 更新并保存BM25索引
         tokenized_chunks = [doc.split() for doc in chunk_texts]

jarvis/jarvis_smart_shell/main.py

@@ -10,6 +10,7 @@ from jarvis.jarvis_platform.registry import PlatformRegistry
 from jarvis.jarvis_utils.config import get_shell_name, set_config
 from jarvis.jarvis_utils.input import get_multiline_input
 from jarvis.jarvis_utils.utils import init_env
+from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 
 app = typer.Typer(
     help="将自然语言要求转换为shell命令",
@@ -23,7 +24,7 @@ Example:
 
 def execute_command(command: str, should_run: bool) -> None:
     """Print command without execution"""
-    print(command)
+    PrettyOutput.print(command, OutputType.CODE, lang="bash")
     if should_run:
         os.system(command)
 
@@ -58,38 +59,95 @@ def _get_markers() -> Tuple[str, str]:
     )
 
 
+def _check_bash_shell() -> bool:
+    """Check if current shell is bash
+
+    Returns:
+        bool: True if bash shell, False otherwise
+    """
+    return get_shell_name() == "bash"
+
+
+def _get_bash_config_file() -> str:
+    """Get bash config file path
+
+    Returns:
+        str: Path to bash config file (~/.bashrc)
+    """
+    return os.path.expanduser("~/.bashrc")
+
+
+def _get_bash_markers() -> Tuple[str, str]:
+    """Get start and end markers for JSS completion in bash
+
+    Returns:
+        Tuple[str, str]: (start_marker, end_marker)
+    """
+    return (
+        "# ===== JARVIS JSS BASH COMPLETION START =====",
+        "# ===== JARVIS JSS BASH COMPLETION END =====",
+    )
+
+
+def _check_zsh_shell() -> bool:
+    """Check if current shell is zsh
+
+    Returns:
+        bool: True if zsh shell, False otherwise
+    """
+    return get_shell_name() == "zsh"
+
+
+def _get_zsh_config_file() -> str:
+    """Get zsh config file path
+
+    Returns:
+        str: Path to zsh config file (~/.zshrc)
+    """
+    return os.path.expanduser("~/.zshrc")
+
+
+def _get_zsh_markers() -> Tuple[str, str]:
+    """Get start and end markers for JSS completion in zsh
+
+    Returns:
+        Tuple[str, str]: (start_marker, end_marker)
+    """
+    return (
+        "# ===== JARVIS JSS ZSH COMPLETION START =====",
+        "# ===== JARVIS JSS ZSH COMPLETION END =====",
+    )
+
+
 @app.command("install")
 def install_jss_completion(
-    shell: str = typer.Option("fish", help="指定shell类型(仅支持fish)"),
+    shell: str = typer.Option("fish", help="指定shell类型(支持fish, bash, zsh)"),
 ) -> None:
-    """为fish shell安装'命令未找到'处理器，实现自然语言命令执行"""
-    if shell != "fish":
-        print(f"错误: 不支持的shell类型: {shell}, 仅支持fish")
+    """为指定的shell安装'命令未找到'处理器，实现自然语言命令建议"""
+    if shell not in ("fish", "bash", "zsh"):
+        PrettyOutput.print(f"错误: 不支持的shell类型: {shell}, 仅支持fish, bash, zsh", OutputType.ERROR)
         raise typer.Exit(code=1)
 
-    if not _check_fish_shell():
-        print("当前不是fish shell，无需安装")
-        return
+    if shell == "fish":
+        config_file = _get_config_file()
+        start_marker, end_marker = _get_markers()
 
-    config_file = _get_config_file()
-    start_marker, end_marker = _get_markers()
+        if not os.path.exists(config_file):
+            PrettyOutput.print("未找到 config.fish 文件，将创建新文件", OutputType.INFO)
+            os.makedirs(os.path.dirname(config_file), exist_ok=True)
+            with open(config_file, "w") as f:
+                f.write("")
 
-    if not os.path.exists(config_file):
-        print("未找到config.fish文件，将创建新文件")
-        os.makedirs(os.path.dirname(config_file), exist_ok=True)
-        with open(config_file, "w") as f:
-            f.write("")
+        with open(config_file, "r") as f:
+            content = f.read()
 
-    with open(config_file, "r") as f:
-        content = f.read()
+        if start_marker in content:
+            PrettyOutput.print("JSS fish completion 已安装，请执行: source ~/.config/fish/config.fish", OutputType.SUCCESS)
+            return
 
-    if start_marker in content:
-        print("JSS fish completion已安装，请执行: source ~/.config/fish/config.fish")
-        return
-
-    with open(config_file, "a") as f:
-        f.write(
-            f"""
+        with open(config_file, "a") as f:
+            f.write(
+                f"""
 {start_marker}
 function fish_command_not_found
     if test (string length "$argv") -lt 10
@@ -103,43 +161,245 @@ function __fish_command_not_found_handler --on-event fish_command_not_found
 end
 {end_marker}
 """
-        )
-    print("JSS fish completion已安装，请执行: source ~/.config/fish/config.fish")
+            )
+        PrettyOutput.print("JSS fish completion 已安装，请执行: source ~/.config/fish/config.fish", OutputType.SUCCESS)
+    elif shell == "bash":
+        config_file = _get_bash_config_file()
+        start_marker, end_marker = _get_bash_markers()
+
+        if not os.path.exists(config_file):
+            PrettyOutput.print("未找到 ~/.bashrc 文件，将创建新文件", OutputType.INFO)
+            os.makedirs(os.path.dirname(config_file), exist_ok=True)
+            with open(config_file, "w") as f:
+                f.write("")
+
+        with open(config_file, "r") as f:
+            content = f.read()
+
+        if start_marker in content:
+            PrettyOutput.print("JSS bash completion 已安装，请执行: source ~/.bashrc", OutputType.SUCCESS)
+            return
+        else:
+            with open(config_file, "a") as f:
+                f.write(
+                    f"""
+{start_marker}
+# Bash 'command not found' handler for JSS
+# 行为：
+# - 生成可编辑的建议命令，用户可直接编辑后回车执行
+# - 非交互模式下仅打印建议
+command_not_found_handle() {{
+    local cmd="$1"
+    shift || true
+    local text="$cmd $*"
+
+    # 与 fish 行为保持一致：对过短输入不处理
+    if [ ${{#text}} -lt 10 ]; then
+        return 127
+    fi
+
+    local suggestion edited
+    suggestion=$(jss request "$text")
+    if [ -n "$suggestion" ]; then
+        # 交互式：用 readline 预填命令，用户可直接回车执行或编辑
+        if [[ $- == *i* ]]; then
+            edited="$suggestion"
+            # -e 启用 readline；-i 预填默认值；无提示前缀，使体验更接近 fish 的“替换命令行”
+            read -e -i "$edited" edited
+            if [ -n "$edited" ]; then
+                eval "$edited"
+                return $?
+            fi
+        else
+            # 非交互：仅打印建议
+            printf '%s\n' "$suggestion"
+        fi
+    fi
+    return 127
+}}
+{end_marker}
+"""
+                )
+            PrettyOutput.print("JSS bash completion 已安装，请执行: source ~/.bashrc", OutputType.SUCCESS)
+    elif shell == "zsh":
+        config_file = _get_zsh_config_file()
+        start_marker, end_marker = _get_zsh_markers()
+
+        if not os.path.exists(config_file):
+            PrettyOutput.print("未找到 ~/.zshrc 文件，将创建新文件", OutputType.INFO)
+            os.makedirs(os.path.dirname(config_file), exist_ok=True)
+            with open(config_file, "w") as f:
+                f.write("")
+
+        with open(config_file, "r") as f:
+            content = f.read()
+
+        if start_marker in content:
+            PrettyOutput.print("JSS zsh completion 已安装，请执行: source ~/.zshrc", OutputType.SUCCESS)
+            return
+
+        with open(config_file, "a") as f:
+            f.write(
+                f"""
+{start_marker}
+# Zsh 'command not found' handler for JSS
+# 行为：
+# - 生成可编辑的建议命令，用户可直接编辑后回车执行
+# - 非交互模式下仅打印建议
+command_not_found_handler() {{
+    local cmd="$1"
+    shift || true
+    local text="$cmd $*"
+
+    # 与 fish 行为保持一致：对过短输入不处理
+    if [ ${{#text}} -lt 10 ]; then
+        return 127
+    fi
+
+    local suggestion edited
+    suggestion=$(jss request "$text")
+    if [ -n "$suggestion" ]; then
+        if [[ -o interactive ]]; then
+            local editor="${{VISUAL:-${{EDITOR:-vi}}}}"
+            local tmpfile edited
+            tmpfile="$(mktemp -t jss-edit-XXXXXX)"
+            printf '%s\n' "$suggestion" > "$tmpfile"
+            "$editor" "$tmpfile"
+            edited="$(sed -n '/./{{p;q;}}' "$tmpfile" | tr -d '\r')"
+            rm -f "$tmpfile"
+            if [ -z "$edited" ]; then
+                edited="$suggestion"
+            fi
+            eval "$edited"
+            return $?
+        else
+            # 非交互：仅打印建议
+            print -r -- "$suggestion"
+        fi
+    fi
+    return 127
+}}
+{end_marker}
+"""
+            )
+        PrettyOutput.print("JSS zsh completion 已安装，请执行: source ~/.zshrc", OutputType.SUCCESS)
+        return
+
+        with open(config_file, "a") as f:
+            f.write(
+                f"""
+{start_marker}
+# Bash 'command not found' handler for JSS
+# 行为：
+# - 生成可编辑的建议命令，用户可直接编辑后回车执行
+# - 非交互模式下仅打印建议
+command_not_found_handle() {{
+    local cmd="$1"
+    shift || true
+    local text="$cmd $*"
+
+    # 与 fish 行为保持一致：对过短输入不处理
+    if [ ${{#text}} -lt 10 ]; then
+        return 127
+    fi
+
+    local suggestion edited
+    suggestion=$(jss request "$text")
+    if [ -n "$suggestion" ]; then
+        # 交互式：用 readline 预填命令，用户可直接回车执行或编辑
+        if [[ $- == *i* ]]; then
+            edited="$suggestion"
+            # -e 启用 readline；-i 预填默认值；无提示前缀，使体验更接近 fish 的“替换命令行”
+            read -e -i "$edited" edited
+            if [ -n "$edited" ]; then
+                eval "$edited"
+                return $?
+            fi
+        else
+            # 非交互：仅打印建议
+            printf '%s\n' "$suggestion"
+        fi
+    fi
+    return 127
+}}
+{end_marker}
+"""
+            )
+        PrettyOutput.print("JSS bash completion 已安装，请执行: source ~/.bashrc", OutputType.SUCCESS)
 
 
 @app.command("uninstall")
 def uninstall_jss_completion(
-    shell: str = typer.Option("fish", help="指定shell类型(仅支持fish)"),
+    shell: str = typer.Option("fish", help="指定shell类型(支持fish, bash, zsh)"),
 ) -> None:
-    """卸载JSS fish shell'命令未找到'处理器"""
-    if shell != "fish":
-        print(f"错误: 不支持的shell类型: {shell}, 仅支持fish")
+    """卸载JSS shell'命令未找到'处理器"""
+    if shell not in ("fish", "bash", "zsh"):
+        PrettyOutput.print(f"错误: 不支持的shell类型: {shell}, 仅支持fish, bash, zsh", OutputType.ERROR)
         raise typer.Exit(code=1)
 
-    if not _check_fish_shell():
-        print("当前不是fish shell，无需卸载")
-        return
+    if shell == "fish":
+        config_file = _get_config_file()
+        start_marker, end_marker = _get_markers()
 
-    config_file = _get_config_file()
-    start_marker, end_marker = _get_markers()
+        if not os.path.exists(config_file):
+            PrettyOutput.print("未找到 JSS fish completion 配置，无需卸载", OutputType.INFO)
+            return
 
-    if not os.path.exists(config_file):
-        print("未找到JSS fish completion配置，无需卸载")
-        return
+        with open(config_file, "r") as f:
+            content = f.read()
 
-    with open(config_file, "r") as f:
-        content = f.read()
+        if start_marker not in content:
+            PrettyOutput.print("未找到 JSS fish completion 配置，无需卸载", OutputType.INFO)
+            return
 
-    if start_marker not in content:
-        print("未找到JSS fish completion配置，无需卸载")
-        return
+        new_content = content.split(start_marker)[0] + content.split(end_marker)[-1]
+
+        with open(config_file, "w") as f:
+            f.write(new_content)
+
+        PrettyOutput.print("JSS fish completion 已卸载，请执行: source ~/.config/fish/config.fish", OutputType.SUCCESS)
+    elif shell == "bash":
+        config_file = _get_bash_config_file()
+        start_marker, end_marker = _get_bash_markers()
+
+        if not os.path.exists(config_file):
+            PrettyOutput.print("未找到 JSS bash completion 配置，无需卸载", OutputType.INFO)
+            return
+
+        with open(config_file, "r") as f:
+            content = f.read()
+
+        if start_marker not in content:
+            PrettyOutput.print("未找到 JSS bash completion 配置，无需卸载", OutputType.INFO)
+            return
 
-    new_content = content.split(start_marker)[0] + content.split(end_marker)[-1]
+        new_content = content.split(start_marker)[0] + content.split(end_marker)[-1]
 
-    with open(config_file, "w") as f:
-        f.write(new_content)
+        with open(config_file, "w") as f:
+            f.write(new_content)
+
+        PrettyOutput.print("JSS bash completion 已卸载，请执行: source ~/.bashrc", OutputType.SUCCESS)
+    elif shell == "zsh":
+        config_file = _get_zsh_config_file()
+        start_marker, end_marker = _get_zsh_markers()
+
+        if not os.path.exists(config_file):
+            PrettyOutput.print("未找到 JSS zsh completion 配置，无需卸载", OutputType.INFO)
+            return
+
+        with open(config_file, "r") as f:
+            content = f.read()
+
+        if start_marker not in content:
+            PrettyOutput.print("未找到 JSS zsh completion 配置，无需卸载", OutputType.INFO)
+            return
+
+        new_content = content.split(start_marker)[0] + content.split(end_marker)[-1]
+
+        with open(config_file, "w") as f:
+            f.write(new_content)
 
-    print("JSS fish completion已卸载，请执行: source ~/.config/fish/config.fish")
+        PrettyOutput.print("JSS zsh completion 已卸载，请执行: source ~/.zshrc", OutputType.SUCCESS)
 
 
 def process_request(request: str) -> Optional[str]: