jarvis-ai-assistant 0.1.175__py3-none-any.whl → 0.1.177__py3-none-any.whl

jarvis/jarvis_tools/edit_file.py

@@ -14,11 +14,13 @@
 - 完善的错误处理和回滚机制
 - 严格的格式保持要求
 """
+from typing import List
 import re
 from typing import Any, Dict, Tuple
 
 import yaml
 from yaspin import yaspin
+from yaspin.core import Yaspin
 
 from jarvis.jarvis_platform.registry import PlatformRegistry
 from jarvis.jarvis_tools.file_operation import FileOperationTool
@@ -32,30 +34,27 @@ class FileSearchReplaceTool:
     name = "edit_file"
     description = """代码编辑工具，用于编辑单个文件
 
-# 代码编辑规范
+# 代码补丁生成指南
 
 ## 重要提示
 此工具可以查看和修改单个文件的代码，只需提供要修改的代码片段即可。应尽量精简内容，只包含必要的上下文和修改部分。特别注意：不要提供完整文件内容，只提供需要修改的部分及其上下文！
 
 ## 基本使用
 1. 指定需要修改的文件路径
-2. 提供一组或多组"reason"和"patch"对
-3. 每个patch必须包含修改后的代码和1-2行上下文用于精确定位
+2. 提供一组或多组修改，每个修改包含"reason"、"search"和"replace"
+3. 每个修改中，"search"必须包含足够的上下文确保能在文件中**唯一匹配**
 
 ## 核心原则
 1. **精准修改**：只提供需要修改的代码部分及其上下文，不需要展示整个文件内容
 2. **最小补丁原则**：始终生成最小范围的补丁，只包含必要的上下文和实际修改
-3. **上下文定位**：确保提供的上下文能唯一标识修改位置
-
-## 最佳实践
-1. 每个修改应专注于单一职责，避免包含过多无关代码
-2. 不要出现未实现的代码，如：TODO
-3. 示例格式：
-  ```
-  # 原有上下文行
-  if condition:  # 修改这行
-      return new_value
-  ```
+3. **上下文完整性**：确保提供的上下文能唯一标识修改位置，避免匹配到多处
+
+## 输出格式规范
+- 每个修改必须包含SEARCH部分和REPLACE部分
+- SEARCH部分是需要查找的原始代码，必须能在原文件中**唯一匹配**
+- REPLACE部分是替换后的新代码
+- 如果修改较大，可以使用多个修改块
+
 """
     parameters = {
         "type": "object",
@@ -74,12 +73,15 @@ class FileSearchReplaceTool:
                             "type": "string",
                             "description": "修改的原因"
                         },
-                        "patch": {
+                        "search": {
                             "type": "string",
-                            "description": "修改后的代码片段，必须包含1-2行上下文代码用于精确定位修改位置，不需要传入完整文件内容"
+                            "description": "需要查找的原始代码"
+                        },
+                        "replace": {
+                            "type": "string",
+                            "description": "替换后的新代码"
                         }
                     },
-                    "required": ["reason", "patch"]
                 }
             }
         },
@@ -141,8 +143,10 @@ class FileSearchReplaceTool:
                     with open(file_path, 'r', encoding='utf-8') as f:
                         content = f.read()
                         original_content = content
-                
-                success, temp_content = patch_apply(file_path, yaml.safe_dump(changes))
+                with yaspin(text=f"正在处理文件 {file_path}...", color="cyan") as spinner:
+                    success, temp_content = fast_edit(file_path, changes, spinner)
+                    if not success:
+                        success, temp_content = slow_edit(file_path, yaml.safe_dump(changes), spinner)
 
                 # 只有当所有替换操作都成功时，才写回文件
                 if success and (temp_content != original_content or not file_exists):
@@ -207,29 +211,42 @@ class FileSearchReplaceTool:
                 "stdout": "",
                 "stderr": error_msg + "\n" + "\n".join(stderr_messages)
             }
+        
 
 
-def patch_apply(filepath: str, patch_content: str) -> Tuple[bool, str]:
+def slow_edit(filepath: str, patch_content: str, spinner: Yaspin) -> Tuple[bool, str]:
     """执行精确的文件编辑操作，使用AI模型生成差异补丁并应用。
-
-    功能概述:
+    
+    核心功能:
     1. 使用AI模型分析补丁内容并生成精确的代码差异
     2. 应用生成的差异补丁到目标文件
-    3. 提供重试机制确保操作可靠性
-
+    3. 提供3次重试机制确保操作可靠性
+    4. 支持大文件处理(自动上传到模型平台)
+    5. 严格的格式一致性检查
+    
     参数:
-        filepath: 要编辑的文件路径
-        patch_content: YAML格式的补丁内容，包含修改原因和代码片段
-
+        filepath: 要编辑的文件路径(绝对或相对路径)
+        patch_content: YAML格式的补丁内容，包含:
+            - reason: 修改原因描述
+            - search: 需要查找的原始代码(必须包含足够上下文)
+            - replace: 替换后的新代码
+        spinner: Yaspin实例，用于显示处理状态
+    
     返回值:
         Tuple[bool, str]: 
-            - 第一个元素表示操作是否成功
-            - 第二个元素是修改后的文件内容(成功时)或错误信息(失败时)
-
+            - 第一个元素表示操作是否成功(True/False)
+            - 第二个元素是修改后的文件内容(成功时)或空字符串(失败时)
+    
     异常处理:
-    1. 捕获并处理文件操作异常
-    2. 失败时自动回滚文件修改
-    3. 提供详细的执行状态输出
+    1. 文件不存在或权限不足时会捕获异常并返回失败
+    2. 模型生成补丁失败时会自动重试最多3次
+    3. 补丁应用失败时会自动回滚文件修改
+    
+    实现细节:
+    1. 检查文件是否在工作目录下(影响版本控制)
+    2. 根据文件大小决定是否上传到模型平台
+    3. 使用精确的DIFF格式解析模型生成的补丁
+    4. 确保补丁应用前进行唯一性匹配检查
     """
     import os
     work_dir = os.path.abspath(os.curdir)
@@ -237,20 +254,19 @@ def patch_apply(filepath: str, patch_content: str) -> Tuple[bool, str]:
     if not filepath.startswith(work_dir):
         PrettyOutput.print(f"文件 {filepath} 不在工作目录 {work_dir} 下，不会进行版本控制管理", OutputType.WARNING)
     model = PlatformRegistry().get_normal_platform()
-    with yaspin(text=f"正在处理文件 {filepath}...", color="cyan") as spinner:
-        try:
-            file_content = FileOperationTool().execute({"operation":"read", "files":[{"path":filepath}]})["stdout"]
-            need_upload_file = is_context_overflow(file_content)
-            upload_success = False
-            # 读取原始文件内容
-            with spinner.hidden():  
-                if need_upload_file and model.upload_files([filepath]):
-                    upload_success = True
+    try:
+        file_content = FileOperationTool().execute({"operation":"read", "files":[{"path":filepath}]})["stdout"]
+        need_upload_file = is_context_overflow(file_content)
+        upload_success = False
+        # 读取原始文件内容
+        with spinner.hidden():  
+            if need_upload_file and model.upload_files([filepath]):
+                upload_success = True
 
 
-            model.set_suppress_output(True)
+        model.set_suppress_output(True)
 
-            main_prompt = f"""
+        main_prompt = f"""
 # 代码补丁生成专家指南
 
 ## 任务描述
@@ -292,66 +308,110 @@ def patch_apply(filepath: str, patch_content: str) -> Tuple[bool, str]:
 {"<" * 5} REPLACE
 {ct("DIFF")}
 """
-            
-            for _ in range(3):
-                file_prompt = ""
-                if not need_upload_file:
-                    file_prompt = f"""
-    # 原始代码
-    {file_content}
-    """
-                    
-                    response = model.chat_until_success(main_prompt + file_prompt)
+        
+        for _ in range(3):
+            file_prompt = ""
+            if not need_upload_file:
+                file_prompt = f"""
+# 原始代码
+{file_content}
+"""
+                
+                response = model.chat_until_success(main_prompt + file_prompt)
+            else:
+                if upload_success:
+                    response = model.chat_until_success(main_prompt)
                 else:
-                    if upload_success:
-                        response = model.chat_until_success(main_prompt)
-                    else:
-                        return False, ""
-
-                # 解析差异化补丁
-                diff_blocks = re.finditer(ot("DIFF")+r'\s*>{4,} SEARCH\n?(.*?)\n?={4,}\n?(.*?)\s*<{4,} REPLACE\n?'+ct("DIFF"),
-                                        response, re.DOTALL)
-
-                # 读取原始文件内容
-                with open(filepath, 'r', encoding='utf-8', errors="ignore") as f:
-                    file_content = f.read()
-
-                # 应用所有差异化补丁
-                modified_content = file_content
-                patch_count = 0
-                success = True
-                for match in diff_blocks:
-                    search_text = match.group(1).strip()
-                    replace_text = match.group(2).strip()
-                    patch_count += 1
-                    # 检查搜索文本是否存在于文件中
-                    if search_text in modified_content:
-                        # 如果有多处，报错
-                        if modified_content.count(search_text) > 1:
-                            spinner.write(f"❌ 补丁 #{patch_count} 应用失败：找到多个匹配的代码段")
-                            success = False
-                            break
-                        # 应用替换
-                        modified_content = modified_content.replace(
-                            search_text, replace_text)
-                        spinner.write(f"✅ 补丁 #{patch_count} 应用成功")
-                    else:
-                        spinner.write(f"❌ 补丁 #{patch_count} 应用失败：无法找到匹配的代码段")
-                        success = False
-                        break
-                if not success:
-                    revert_file(filepath)
-                    continue
+                    return False, ""
 
+            # 解析差异化补丁
+            diff_blocks = re.finditer(ot("DIFF")+r'\s*>{4,} SEARCH\n?(.*?)\n?={4,}\n?(.*?)\s*<{4,} REPLACE\n?'+ct("DIFF"),
+                                    response, re.DOTALL)
 
-                spinner.text = f"文件 {filepath} 修改完成，应用了 {patch_count} 个补丁"
-                spinner.ok("✅")
-                return True, modified_content
-            spinner.text = f"文件 {filepath} 修改失败"
-            spinner.fail("❌")
-            return False, ""
+            patches = []
+            for match in diff_blocks:
+                patches.append({
+                    "search": match.group(1).strip(),
+                    "replace": match.group(2).strip()
+                })
 
-        except Exception as e:
-            spinner.text = f"文件修改失败: {str(e)}"
-            spinner.fail("❌")
-            return False, ""
+            success, modified_content = fast_edit(filepath, patches, spinner)
+            if success:
+                return True, modified_content
+        spinner.text = f"文件 {filepath} 修改失败"
+        spinner.fail("❌")
+        return False, ""
+
+    except Exception as e:
+        spinner.text = f"文件修改失败: {str(e)}"
+        spinner.fail("❌")
+        return False, ""
+
+
+def fast_edit(filepath: str, patches: List[Dict[str,str]], spinner: Yaspin) -> Tuple[bool, str]:
+    """快速应用预先生成的补丁到目标文件。
+    
+    核心功能:
+    1. 直接应用已生成的代码补丁
+    2. 执行严格的唯一匹配检查
+    3. 提供详细的补丁应用状态反馈
+    4. 失败时自动回滚文件修改
+    
+    参数:
+        filepath: 要编辑的文件路径(绝对或相对路径)
+        patches: 补丁列表，每个补丁包含:
+            - search: 需要查找的原始代码
+            - replace: 替换后的新代码
+        spinner: Yaspin实例，用于显示处理状态
+    
+    返回值:
+        Tuple[bool, str]: 
+            - 第一个元素表示操作是否成功(True/False)
+            - 第二个元素是修改后的文件内容(成功时)或空字符串(失败时)
+    
+    异常处理:
+    1. 文件不存在或权限不足时会捕获异常并返回失败
+    2. 补丁不匹配或有多处匹配时会返回失败
+    3. 失败时会自动回滚文件修改
+    
+    实现细节:
+    1. 读取文件内容到内存
+    2. 依次应用每个补丁，检查唯一匹配性
+    3. 记录每个补丁的应用状态
+    4. 所有补丁成功应用后才写入文件
+    """
+    # 读取原始文件内容
+    with open(filepath, 'r', encoding='utf-8', errors="ignore") as f:
+        file_content = f.read()
+
+    # 应用所有差异化补丁
+    modified_content = file_content
+    patch_count = 0
+    success = True
+    for patch in patches:
+        search_text = patch["search"]
+        replace_text = patch["replace"]
+        patch_count += 1
+        # 检查搜索文本是否存在于文件中
+        if search_text in modified_content:
+            # 如果有多处，报错
+            if modified_content.count(search_text) > 1:
+                spinner.write(f"❌ 补丁 #{patch_count} 应用失败：找到多个匹配的代码段")
+                success = False
+                break
+            # 应用替换
+            modified_content = modified_content.replace(
+                search_text, replace_text)
+            spinner.write(f"✅ 补丁 #{patch_count} 应用成功")
+        else:
+            spinner.write(f"❌ 补丁 #{patch_count} 应用失败：无法找到匹配的代码段")
+            success = False
+            break
+    if not success:
+        revert_file(filepath)
+        return False, ""
+
+
+    spinner.text = f"文件 {filepath} 修改完成，应用了 {patch_count} 个补丁"
+    spinner.ok("✅")
+    return True, modified_content

jarvis/jarvis_tools/read_code.py

@@ -98,8 +98,6 @@ class ReadCodeTool:
                 spinner.text = f"文件读取完成: {abs_path}"
                 spinner.ok("✅")
 
-                PrettyOutput.print(output, OutputType.SUCCESS)
-
                 return {
                     "success": True,
                     "stdout": output,

jarvis/jarvis_tools/registry.py

@@ -178,6 +178,32 @@ class ToolRegistry(OutputHandlerProtocol):
         self._load_external_tools()
         self._load_mcp_tools()
 
+    def _get_tool_stats(self) -> Dict[str, int]:
+        """从数据目录获取工具调用统计"""
+        stats_file = Path(get_data_dir()) / "tool_stat.yaml"
+        if stats_file.exists():
+            try:
+                with open(stats_file, "r", encoding="utf-8") as f:
+                    return yaml.safe_load(f) or {}
+            except Exception as e:
+                PrettyOutput.print(
+                    f"加载工具调用统计失败: {str(e)}", OutputType.WARNING
+                )
+        return {}
+
+    def _update_tool_stats(self, name: str) -> None:
+        """更新工具调用统计"""
+        stats = self._get_tool_stats()
+        stats[name] = stats.get(name, 0) + 1
+        stats_file = Path(get_data_dir()) / "tool_stat.yaml"
+        try:
+            with open(stats_file, "w", encoding="utf-8") as f:
+                yaml.safe_dump(stats, f)
+        except Exception as e:
+            PrettyOutput.print(
+                f"保存工具调用统计失败: {str(e)}", OutputType.WARNING
+            )
+
     def use_tools(self, name: List[str]) -> None:
         """使用指定工具
 
@@ -559,6 +585,10 @@ class ToolRegistry(OutputHandlerProtocol):
                 "stderr": f"工具 {name} 不存在，可用的工具有: {', '.join(self.tools.keys())}",
                 "stdout": "",
             }
+        
+        # 更新工具调用统计
+        self._update_tool_stats(name)
+        
         return tool.execute(arguments)
 
     def _format_tool_output(self, stdout: str, stderr: str) -> str:

jarvis/jarvis_utils/config.py

@@ -38,7 +38,7 @@ def get_max_token_count() -> int:
     返回:
         int: 模型能处理的最大token数量。
     """
-    return int(os.getenv('JARVIS_MAX_TOKEN_COUNT', '102400000'))
+    return int(os.getenv('JARVIS_MAX_TOKEN_COUNT', '960000'))
 
 def get_max_input_token_count() -> int:
     """
@@ -158,6 +158,15 @@ def get_max_big_content_size() -> int:
     获取最大大内容大小。
 
     返回：
-        int: 最大大内容大小，默认为1MB
+        int: 最大大内容大小
     """
-    return int(os.getenv('JARVIS_MAX_BIG_CONTENT_SIZE', '96000'))
+    return int(os.getenv('JARVIS_MAX_BIG_CONTENT_SIZE', '1024000'))
+
+def get_pretty_output() -> bool:
+    """
+    获取是否启用PrettyOutput。
+
+    返回：
+        bool: 如果启用PrettyOutput则返回True，默认为True
+    """
+    return os.getenv('JARVIS_PRETTY_OUTPUT', 'false') == 'true'

jarvis/jarvis_utils/embedding.py

@@ -69,16 +69,7 @@ def split_text_into_chunks(text: str, max_length: int = 512, min_length: int = 5
 
         # 处理最后一个块
         if current_chunk:
-            if current_tokens >= min_length:
-                chunks.append(current_chunk)
-            elif chunks:  # 如果最后一个块太短，尝试与前面的块合并
-                last_chunk = chunks[-1]
-                combined = last_chunk + current_chunk
-                combined_tokens = get_context_token_count(combined)
-                if combined_tokens <= max_length:
-                    chunks[-1] = combined
-                else:
-                    chunks.append(current_chunk)
+            chunks.append(current_chunk)  # 直接添加最后一个块，无论长度如何
 
         return chunks
 

jarvis/jarvis_utils/output.py

@@ -10,14 +10,16 @@
 """
 from enum import Enum
 from datetime import datetime
-from typing import Optional
+from typing import Optional, Tuple
 from rich.panel import Panel
 from rich.text import Text
 from rich.syntax import Syntax
 from rich.style import Style as RichStyle
 from pygments.lexers import guess_lexer
 from pygments.util import ClassNotFound
+from jarvis.jarvis_utils.config import get_pretty_output
 from jarvis.jarvis_utils.globals import console, get_agent_list
+from rich.box import SIMPLE
 class OutputType(Enum):
     """
     输出类型枚举，用于分类和样式化不同类型的消息。
@@ -125,7 +127,7 @@ class PrettyOutput:
         except (ClassNotFound, Exception):
             return default_lang
     @staticmethod
-    def _format(output_type: OutputType, timestamp: bool = True) -> Text:
+    def _format(output_type: OutputType, timestamp: bool = True) -> str:
         """
         使用时间戳和图标格式化输出头。
 
@@ -136,14 +138,13 @@ class PrettyOutput:
         返回：
             Text: 格式化后的rich Text对象
         """
-        formatted = Text()
+        icon = PrettyOutput._ICONS.get(output_type, "")
+        formatted = f"{icon}  "
         if timestamp:
-            formatted.append(f"[{datetime.now().strftime('%H:%M:%S')}][{output_type.value}]", style=output_type.value)
+            formatted+=f"[{datetime.now().strftime('%H:%M:%S')}][{output_type.value}]"
         agent_info = get_agent_list()
         if agent_info:
-            formatted.append(f"[{agent_info}]", style="blue")
-        icon = PrettyOutput._ICONS.get(output_type, "")
-        formatted.append(f" {icon} ", style=output_type.value)
+            formatted+=f"[{agent_info}]"
         return formatted
     @staticmethod
     def print(text: str, output_type: OutputType, timestamp: bool = True, lang: Optional[str] = None, traceback: bool = False):
@@ -158,35 +159,55 @@ class PrettyOutput:
             traceback: 是否显示错误的回溯信息
         """
         styles = {
-            OutputType.SYSTEM: RichStyle(color="bright_cyan", bgcolor="#1a1a1a", frame=True, meta={"icon": "🤖"}),
-            OutputType.CODE: RichStyle(color="green", bgcolor="#1a1a1a", frame=True, meta={"icon": "📝"}),
-            OutputType.RESULT: RichStyle(color="bright_blue", bgcolor="#1a1a1a", frame=True, meta={"icon": "✨"}),
-            OutputType.ERROR: RichStyle(color="red", frame=True, bgcolor="dark_red", meta={"icon": "❌"}),
-            OutputType.INFO: RichStyle(color="gold1", frame=True, bgcolor="grey11", meta={"icon": "ℹ️"}),
-            OutputType.PLANNING: RichStyle(color="purple", bold=True, frame=True, meta={"icon": "📋"}),
-            OutputType.PROGRESS: RichStyle(color="white", encircle=True, frame=True, meta={"icon": "⏳"}),
-            OutputType.SUCCESS: RichStyle(color="bright_green", bold=True, strike=False, meta={"icon": "✅"}),
-            OutputType.WARNING: RichStyle(color="yellow", bold=True, blink2=True, bgcolor="dark_orange", meta={"icon": "⚠️"}),
-            OutputType.DEBUG: RichStyle(color="grey58", dim=True, conceal=True, meta={"icon": "🔍"}),
-            OutputType.USER: RichStyle(color="spring_green2", frame=True, meta={"icon": "👤"}),
-            OutputType.TOOL: RichStyle(color="dark_sea_green4", bgcolor="grey19", frame=True, meta={"icon": "🔧"}),
+            OutputType.SYSTEM: dict( bgcolor="#1e2b3c"),
+            OutputType.CODE: dict( bgcolor="#1c2b1c"),
+            OutputType.RESULT: dict( bgcolor="#1c1c2b"),
+            OutputType.ERROR: dict( bgcolor="#2b1c1c"),
+            OutputType.INFO: dict( bgcolor="#2b2b1c", meta={"icon": "ℹ️"}),
+            OutputType.PLANNING: dict(  bgcolor="#2b1c2b"),
+            OutputType.PROGRESS: dict(  bgcolor="#1c1c1c"),
+            OutputType.SUCCESS: dict( bgcolor="#1c2b1c"),
+            OutputType.WARNING: dict( bgcolor="#2b2b1c"),
+            OutputType.DEBUG: dict(  bgcolor="#1c1c1c"),
+            OutputType.USER: dict( bgcolor="#1c2b2b"),
+            OutputType.TOOL: dict( bgcolor="#1c2b2b"),
+        }
+
+        header_styles = {
+            OutputType.SYSTEM: RichStyle(color="bright_cyan", bgcolor="#1e2b3c", frame=True, meta={"icon": "🤖"}),
+            OutputType.CODE: RichStyle(color="green", bgcolor="#1c2b1c", frame=True, meta={"icon": "📝"}),
+            OutputType.RESULT: RichStyle(color="bright_blue", bgcolor="#1c1c2b", frame=True, meta={"icon": "✨"}),
+            OutputType.ERROR: RichStyle(color="red", frame=True, bgcolor="#2b1c1c", meta={"icon": "❌"}),
+            OutputType.INFO: RichStyle(color="gold1", frame=True, bgcolor="#2b2b1c", meta={"icon": "ℹ️"}),
+            OutputType.PLANNING: RichStyle(color="purple", bold=True, frame=True, bgcolor="#2b1c2b", meta={"icon": "📋"}),
+            OutputType.PROGRESS: RichStyle(color="white", encircle=True, frame=True, bgcolor="#1c1c1c", meta={"icon": "⏳"}),
+            OutputType.SUCCESS: RichStyle(color="bright_green", bold=True, strike=False, bgcolor="#1c2b1c", meta={"icon": "✅"}),
+            OutputType.WARNING: RichStyle(color="yellow", bold=True, blink2=True, bgcolor="#2b2b1c", meta={"icon": "⚠️"}),
+            OutputType.DEBUG: RichStyle(color="grey58", dim=True, conceal=True, bgcolor="#1c1c1c", meta={"icon": "🔍"}),
+            OutputType.USER: RichStyle(color="spring_green2", frame=True, bgcolor="#1c2b2b", meta={"icon": "👤"}),
+            OutputType.TOOL: RichStyle(color="dark_sea_green4", bgcolor="#1c2b2b", frame=True, meta={"icon": "🔧"}),
         }
+
         lang = lang if lang is not None else PrettyOutput._detect_language(text, default_lang='markdown')
-        header = PrettyOutput._format(output_type, timestamp)
-        content = Syntax(text, lang, theme="monokai", word_wrap=True)
+        header = Text(PrettyOutput._format(output_type, timestamp), style=header_styles[output_type])
+        content = Syntax(text, lang, theme="monokai", word_wrap=True, background_color=styles[output_type]["bgcolor"])
         panel = Panel(
             content,
-            style=styles[output_type],
-            border_style=styles[output_type],
+            border_style=header_styles[output_type],
             title=header,
             title_align="left",
             padding=(0, 0),
             highlight=True,
-            # box=HEAVY,
         )
-        console.print()
-        console.print(panel)
-        if traceback or output_type == OutputType.ERROR:
+        if get_pretty_output():
+            console.print(panel)
+        else:
+            if len(text.strip().splitlines()) > 1:
+                console.print(header)
+                console.print(content)
+            else:
+                console.print(header, content)
+        if traceback:
             console.print_exception()
     @staticmethod
     def section(title: str, output_type: OutputType = OutputType.INFO):
@@ -197,23 +218,39 @@ class PrettyOutput:
             title: 章节标题文本
             output_type: 输出类型（影响样式）
         """
+        text = Text(title, style=output_type.value, justify="center")
         panel = Panel(
-            Text(title, style=output_type.value, justify="center"),
+            text,
             border_style=output_type.value
         )
-        console.print()
-        console.print(panel)
-        console.print()
+        if get_pretty_output():
+            console.print(panel)
+        else:
+            console.print(text)
     
     @staticmethod
-    def _get_style(output_type: OutputType) -> RichStyle:
-        """
-        获取预定义的RichStyle用于输出类型。
-
-        参数：
-            output_type: 要获取样式的输出类型
-
-        返回：
-            RichStyle: 对应的样式
+    def print_gradient_text(text: str, start_color: Tuple[int, int, int], end_color: Tuple[int, int, int]) -> None:
+        """打印带有渐变色彩的文本。
+        
+        Args:
+            text: 要打印的文本
+            start_color: 起始RGB颜色元组 (r, g, b)
+            end_color: 结束RGB颜色元组 (r, g, b)
         """
-        return console.get_style(output_type.value)
+        lines = text.strip('\n').split('\n')
+        total_lines = len(lines)
+        colored_lines = []
+        for i, line in enumerate(lines):
+            # 计算当前行的渐变颜色
+            r = int(start_color[0] + (end_color[0] - start_color[0]) * i / (total_lines - 1))
+            g = int(start_color[1] + (end_color[1] - start_color[1]) * i / (total_lines - 1))
+            b = int(start_color[2] + (end_color[2] - start_color[2]) * i / (total_lines - 1))
+            
+            # 使用ANSI转义序列设置颜色
+            colored_lines.append(f"\033[38;2;{r};{g};{b}m{line}\033[0m")
+        colored_text = Text('\n'.join(colored_lines), style=OutputType.TOOL.value, justify="center")
+        panel = Panel(
+            colored_text,
+            box=SIMPLE
+        )
+        console.print(panel)

jarvis/jarvis_utils/utils.py

@@ -5,11 +5,13 @@ import hashlib
 import tarfile
 from pathlib import Path
 from typing import Any, Callable
+
+from jarvis import __version__
 from jarvis.jarvis_utils.config import get_max_big_content_size, get_data_dir
 from jarvis.jarvis_utils.embedding import get_context_token_count
 from jarvis.jarvis_utils.input import get_single_line_input
 from jarvis.jarvis_utils.output import PrettyOutput, OutputType
-def init_env() -> None:
+def init_env(welcome_str: str) -> None:
     """初始化环境变量从jarvis_data/env文件
 
     功能：
@@ -18,6 +20,22 @@ def init_env() -> None:
     3. 处理文件读取异常
     4. 检查git仓库状态并在落后时更新
     """
+
+    jarvis_ascii_art = f"""
+   ██╗ █████╗ ██████╗ ██╗   ██╗██╗███████╗
+   ██║██╔══██╗██╔══██╗██║   ██║██║██╔════╝
+   ██║███████║██████╔╝██║   ██║██║███████╗
+██╗██║██╔══██║██╔══██╗╚██╗ ██╔╝██║╚════██║
+╚████║██║  ██║██║  ██║ ╚████╔╝ ██║███████║
+ ╚═══╝╚═╝  ╚═╝╚═╝  ╚═╝  ╚═══╝  ╚═╝╚══════╝
+ {welcome_str}
+
+ https://github.com/skyfireitdiy/Jarvis
+ v{__version__}
+"""
+    if welcome_str:
+        PrettyOutput.print_gradient_text(jarvis_ascii_art, (0, 120, 255), (0, 255, 200))
+
     jarvis_dir = Path(get_data_dir())
     env_file = jarvis_dir / "env"