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

jarvis/jarvis_agent/language_support_info.py

@@ -0,0 +1,486 @@
+# -*- coding: utf-8 -*-
+"""语言功能支持信息模块
+
+提供语言功能支持情况的收集和展示功能。
+"""
+
+import subprocess
+from typing import Dict, Any, List
+
+
+def _collect_language_support_info() -> Dict[str, Dict[str, Any]]:
+    """收集所有语言的功能支持信息"""
+    info: Dict[str, Dict[str, Any]] = {}
+    
+    # 确保语言支持模块已加载（触发自动注册）
+    try:
+        import jarvis.jarvis_code_agent.code_analyzer.language_support  # noqa: F401
+    except Exception:
+        pass
+    
+    # 从 code_analyzer 获取语言支持
+    try:
+        from jarvis.jarvis_code_agent.code_analyzer.language_registry import get_registry
+        registry = get_registry()
+        
+        for lang_name in registry.get_supported_languages():
+            lang_support = registry.get_language_support(lang_name)
+            if lang_support:
+                if lang_name not in info:
+                    info[lang_name] = {}
+                
+                # 检查符号提取支持
+                try:
+                    extractor = lang_support.create_symbol_extractor()
+                    info[lang_name]['符号提取'] = extractor is not None
+                except Exception:
+                    # 如果创建失败，先标记为 False，后续会检查 file_context_handler 中的提取器
+                    info[lang_name]['符号提取'] = False
+                
+                # 检查依赖分析支持
+                try:
+                    analyzer = lang_support.create_dependency_analyzer()
+                    info[lang_name]['依赖分析'] = analyzer is not None
+                except Exception:
+                    info[lang_name]['依赖分析'] = False
+                
+                # 检查结构化编辑支持（基于符号提取器）
+                try:
+                    # 结构化编辑需要符号提取器支持
+                    extractor = lang_support.create_symbol_extractor()
+                    info[lang_name]['结构化编辑'] = extractor is not None
+                except Exception:
+                    info[lang_name]['结构化编辑'] = False
+    except Exception:
+        pass
+    
+    # 从 file_context_handler 获取上下文提取支持，同时也用于补充符号提取支持
+    try:
+        from jarvis.jarvis_agent.file_context_handler import _LANGUAGE_EXTRACTORS
+        
+        # 扩展名到语言名称的映射
+        lang_name_map = {
+            '.py': 'python', '.pyw': 'python',
+            '.rs': 'rust',
+            '.go': 'go',
+            '.c': 'c', '.h': 'c',
+            '.cpp': 'cpp', '.cc': 'cpp', '.cxx': 'cpp', '.hpp': 'cpp', '.hxx': 'cpp',
+            '.js': 'javascript', '.jsx': 'javascript',
+            '.ts': 'typescript', '.tsx': 'typescript',
+            '.java': 'java',
+        }
+        
+        for ext, factory in _LANGUAGE_EXTRACTORS.items():
+            try:
+                # 尝试创建提取器，只有成功创建才标记为支持
+                extractor = factory()
+                if extractor is not None:
+                    lang_name = lang_name_map.get(ext, ext[1:] if ext.startswith('.') else ext)
+                    
+                    if lang_name not in info:
+                        info[lang_name] = {}
+                    
+                    # 上下文提取支持（只有成功创建才支持）
+                    info[lang_name]['上下文提取'] = True
+                    
+                    # 如果 code_analyzer 中的符号提取不支持，但 file_context_handler 中能成功创建提取器，也标记为支持
+                    if '符号提取' not in info[lang_name] or not info[lang_name]['符号提取']:
+                        info[lang_name]['符号提取'] = True
+            except Exception:
+                # 静默失败，不记录错误（避免输出过多调试信息）
+                pass
+    except Exception:
+        pass
+    
+    # 检查构建验证支持（自动发现所有构建验证器）
+    try:
+        from jarvis.jarvis_code_agent.code_analyzer.build_validator import __all__
+        from jarvis.jarvis_code_agent.code_analyzer.build_validator.base import BuildValidatorBase
+        import jarvis.jarvis_code_agent.code_analyzer.build_validator as build_validator_module
+        
+        # 自动发现所有构建验证器类（排除基类和工具类）
+        validator_classes = []
+        exclude_classes = {'BuildValidatorBase', 'BuildSystemDetector', 'BuildValidator', 'BuildSystem', 'BuildResult'}
+        
+        for name in __all__:
+            if name not in exclude_classes and name.endswith('BuildValidator'):
+                try:
+                    validator_class = getattr(build_validator_module, name)
+                    # 检查是否是 BuildValidatorBase 的子类
+                    if issubclass(validator_class, BuildValidatorBase) and validator_class != BuildValidatorBase:
+                        validator_classes.append(validator_class)
+                except (AttributeError, TypeError, Exception):
+                    continue
+        
+        # 为每种语言收集支持的构建系统名称
+        lang_to_build_systems: Dict[str, List[str]] = {}
+        
+        for validator_class in validator_classes:
+            try:
+                # 检查类是否有 BUILD_SYSTEM_NAME 和 SUPPORTED_LANGUAGES
+                build_system_name = getattr(validator_class, 'BUILD_SYSTEM_NAME', '')
+                supported_languages = getattr(validator_class, 'SUPPORTED_LANGUAGES', [])
+                
+                if build_system_name and supported_languages:
+                    for lang in supported_languages:
+                        if lang not in lang_to_build_systems:
+                            lang_to_build_systems[lang] = []
+                        if build_system_name not in lang_to_build_systems[lang]:
+                            lang_to_build_systems[lang].append(build_system_name)
+            except (AttributeError, Exception):
+                continue
+        
+        # 将构建系统信息添加到 info 中
+        for lang_name, build_systems in lang_to_build_systems.items():
+            if lang_name not in info:
+                info[lang_name] = {}
+            if build_systems:
+                # 存储构建系统名称列表（用于显示）
+                info[lang_name]['构建验证'] = ', '.join(sorted(build_systems))
+            else:
+                info[lang_name]['构建验证'] = False
+                
+    except (ImportError, Exception):
+        pass
+    
+    # 检查静态检查支持（从 lint.py 获取）
+    try:
+        from jarvis.jarvis_code_agent.lint import LINT_TOOLS
+        
+        # 扩展名到语言名称的映射
+        ext_to_lang_for_lint = {
+            '.py': 'python', '.pyw': 'python', '.pyi': 'python',
+            '.rs': 'rust',
+            '.go': 'go',
+            '.c': 'c', '.h': 'c',
+            '.cpp': 'cpp', '.cc': 'cpp', '.cxx': 'cpp', '.hpp': 'cpp', '.hxx': 'cpp',
+            '.js': 'javascript', '.jsx': 'javascript', '.mjs': 'javascript', '.cjs': 'javascript',
+            '.ts': 'typescript', '.tsx': 'typescript', '.cts': 'typescript', '.mts': 'typescript',
+            '.java': 'java',
+        }
+        
+        # 检查每种语言是否有对应的 lint 工具
+        for ext, lang_name in ext_to_lang_for_lint.items():
+            if lang_name not in info:
+                info[lang_name] = {}
+            if ext in LINT_TOOLS and LINT_TOOLS[ext]:
+                info[lang_name]['静态检查'] = True
+    except Exception:
+        pass
+    
+    # 检查LSP支持（从 lsp_client.py 获取，并验证实际可用性）
+    from jarvis.jarvis_tools.lsp_client import LSP_SERVERS
+    
+    # LSP服务器配置中的语言名称到标准语言名称的映射
+    lsp_lang_map = {
+        'python': 'python',
+        'typescript': 'typescript',
+        'javascript': 'javascript',
+        'c': 'c',
+        'cpp': 'cpp',
+        'rust': 'rust',
+        'go': 'go',
+        'java': 'java',
+    }
+    
+    # 检查每种语言是否有对应的 LSP 服务器配置，并验证实际可用性
+    for lsp_lang, lang_name in lsp_lang_map.items():
+        if lang_name not in info:
+            info[lang_name] = {}
+        
+        if lsp_lang in LSP_SERVERS:
+            config = LSP_SERVERS[lsp_lang]
+            # 检查服务器是否实际可用
+            is_available = _check_lsp_server_available(config)
+            info[lang_name]['LSP支持'] = is_available
+    
+    # 确保所有已知语言都在 info 中（即使某些功能不支持）
+    # 这样表格会显示所有语言，即使某些功能不支持
+    known_languages = ['python', 'c', 'cpp', 'rust', 'go', 'javascript', 'typescript', 'java']
+    for lang_name in known_languages:
+        if lang_name not in info:
+            info[lang_name] = {}
+        # 确保所有功能字段都存在
+        for feature in ['符号提取', '依赖分析', '上下文提取', '构建验证', '静态检查', 'LSP支持', '结构化编辑']:
+            if feature not in info[lang_name]:
+                # 对于上下文提取，检查是否有对应的提取器
+                if feature == '上下文提取':
+                    try:
+                        from jarvis.jarvis_agent.file_context_handler import _LANGUAGE_EXTRACTORS
+                        ext_map = {
+                            'python': ['.py', '.pyw'],
+                            'rust': ['.rs'],
+                            'go': ['.go'],
+                            'c': ['.c', '.h'],
+                            'cpp': ['.cpp', '.cc', '.cxx', '.hpp', '.hxx'],
+                            'javascript': ['.js', '.jsx'],
+                            'typescript': ['.ts', '.tsx'],
+                            'java': ['.java'],
+                        }
+                        exts = ext_map.get(lang_name, [])
+                        # 尝试创建提取器，只有成功创建才认为支持（需要 tree-sitter 已安装）
+                        has_extractor = False
+                        for ext in exts:
+                            if ext in _LANGUAGE_EXTRACTORS:
+                                try:
+                                    factory = _LANGUAGE_EXTRACTORS[ext]
+                                    extractor = factory()
+                                    if extractor:
+                                        has_extractor = True
+                                        break
+                                except Exception:
+                                    continue
+                        info[lang_name][feature] = has_extractor
+                    except Exception:
+                        info[lang_name][feature] = False
+                elif feature == '符号提取':
+                    # 如果之前没有设置或为 False，再次检查 file_context_handler 中的提取器
+                    # 只有能成功创建提取器才标记为支持（需要 tree-sitter 已安装）
+                    if '符号提取' not in info[lang_name] or not info[lang_name]['符号提取']:
+                        try:
+                            from jarvis.jarvis_agent.file_context_handler import _LANGUAGE_EXTRACTORS
+                            ext_map = {
+                                'python': ['.py', '.pyw'],
+                                'rust': ['.rs'],
+                                'go': ['.go'],
+                                'c': ['.c', '.h'],
+                                'cpp': ['.cpp', '.cc', '.cxx', '.hpp', '.hxx'],
+                                'javascript': ['.js', '.jsx'],
+                                'typescript': ['.ts', '.tsx'],
+                            }
+                            exts = ext_map.get(lang_name, [])
+                            # 尝试创建提取器，只有成功创建才认为支持
+                            has_extractor = False
+                            for ext in exts:
+                                if ext in _LANGUAGE_EXTRACTORS:
+                                    try:
+                                        factory = _LANGUAGE_EXTRACTORS[ext]
+                                        extractor = factory()
+                                        if extractor:
+                                            has_extractor = True
+                                            break
+                                    except Exception:
+                                        continue
+                            info[lang_name][feature] = has_extractor
+                        except Exception:
+                            info[lang_name][feature] = False
+                elif feature == '构建验证':
+                    # 默认 False，已在上面检查过（可能是字符串或False）
+                    if feature not in info[lang_name]:
+                        info[lang_name][feature] = False
+                elif feature == '静态检查':
+                    # 默认 False，已在上面检查过
+                    info[lang_name][feature] = info[lang_name].get(feature, False)
+                elif feature == 'LSP支持':
+                    # 默认 False，已在上面检查过
+                    info[lang_name][feature] = info[lang_name].get(feature, False)
+                else:
+                    info[lang_name][feature] = False
+    
+    # 确保所有已知语言都在 info 中（即使某些功能不支持）
+    # 这样表格会显示所有语言，即使某些功能不支持
+    known_languages = ['python', 'c', 'cpp', 'rust', 'go', 'javascript', 'typescript', 'java']
+    for lang_name in known_languages:
+        if lang_name not in info:
+            info[lang_name] = {}
+        # 确保所有功能字段都存在
+        for feature in ['符号提取', '依赖分析', '上下文提取', '构建验证', '静态检查', 'LSP支持', '结构化编辑']:
+            if feature not in info[lang_name]:
+                # 对于上下文提取，检查是否有对应的提取器
+                if feature == '上下文提取':
+                    try:
+                        from jarvis.jarvis_agent.file_context_handler import _LANGUAGE_EXTRACTORS
+                        ext_map = {
+                            'python': ['.py', '.pyw'],
+                            'rust': ['.rs'],
+                            'go': ['.go'],
+                            'c': ['.c', '.h'],
+                            'cpp': ['.cpp', '.cc', '.cxx', '.hpp', '.hxx'],
+                            'javascript': ['.js', '.jsx'],
+                            'typescript': ['.ts', '.tsx'],
+                            'java': ['.java'],
+                        }
+                        exts = ext_map.get(lang_name, [])
+                        # 尝试创建提取器，只有成功创建才认为支持（需要 tree-sitter 已安装）
+                        has_extractor = False
+                        for ext in exts:
+                            if ext in _LANGUAGE_EXTRACTORS:
+                                try:
+                                    factory = _LANGUAGE_EXTRACTORS[ext]
+                                    extractor = factory()
+                                    if extractor:
+                                        has_extractor = True
+                                        break
+                                except Exception:
+                                    continue
+                        info[lang_name][feature] = has_extractor
+                    except Exception:
+                        info[lang_name][feature] = False
+                elif feature == '符号提取':
+                    # 如果之前没有设置或为 False，再次检查 file_context_handler 中的提取器
+                    # 只有能成功创建提取器才标记为支持（需要 tree-sitter 已安装）
+                    if '符号提取' not in info[lang_name] or not info[lang_name]['符号提取']:
+                        try:
+                            from jarvis.jarvis_agent.file_context_handler import _LANGUAGE_EXTRACTORS
+                            ext_map = {
+                                'python': ['.py', '.pyw'],
+                                'rust': ['.rs'],
+                                'go': ['.go'],
+                                'c': ['.c', '.h'],
+                                'cpp': ['.cpp', '.cc', '.cxx', '.hpp', '.hxx'],
+                                'javascript': ['.js', '.jsx'],
+                                'typescript': ['.ts', '.tsx'],
+                            }
+                            exts = ext_map.get(lang_name, [])
+                            # 尝试创建提取器，只有成功创建才认为支持
+                            has_extractor = False
+                            for ext in exts:
+                                if ext in _LANGUAGE_EXTRACTORS:
+                                    try:
+                                        factory = _LANGUAGE_EXTRACTORS[ext]
+                                        extractor = factory()
+                                        if extractor:
+                                            has_extractor = True
+                                            break
+                                    except Exception:
+                                        continue
+                            info[lang_name][feature] = has_extractor
+                        except Exception:
+                            info[lang_name][feature] = False
+                elif feature == '构建验证':
+                    # 默认 False，已在上面检查过（可能是字符串或False）
+                    if feature not in info[lang_name]:
+                        info[lang_name][feature] = False
+                elif feature == '静态检查':
+                    # 默认 False，已在上面检查过
+                    info[lang_name][feature] = info[lang_name].get(feature, False)
+                elif feature == 'LSP支持':
+                    # 默认 False，已在上面检查过
+                    info[lang_name][feature] = info[lang_name].get(feature, False)
+                else:
+                    info[lang_name][feature] = False
+    
+    return info
+
+
+def _check_lsp_server_available(config) -> bool:
+    """检查LSP服务器是否实际可用。
+    
+    Args:
+        config: LSPServerConfig 配置对象
+        
+    Returns:
+        bool: 如果服务器可用返回True，否则返回False
+    """
+    # 使用检测命令或主命令来验证
+    check_cmd = config.check_command or config.command
+    
+    try:
+        # 尝试运行检测命令
+        subprocess.run(
+            check_cmd,
+            capture_output=True,
+            text=True,
+            timeout=5,
+            check=False
+        )
+        
+        # 只要命令能执行（不是FileNotFoundError），就认为可用
+        # 某些LSP服务器即使返回非零退出码也可能可用
+        return True
+        
+    except FileNotFoundError:
+        return False
+    except subprocess.TimeoutExpired:
+        return False
+    except Exception:
+        return False
+
+
+def print_language_support_table() -> None:
+    """打印语言功能支持表格"""
+    from rich.console import Console
+    from rich.table import Table
+    from rich.align import Align
+    
+    info = _collect_language_support_info()
+    
+    if not info:
+        return
+    
+    # 定义功能列表
+    features = ['符号提取', '依赖分析', '上下文提取', '构建验证', '静态检查', 'LSP支持', '结构化编辑']
+    
+    # 定义语言显示名称映射
+    lang_display_names = {
+        'python': 'Python',
+        'rust': 'Rust',
+        'go': 'Go',
+        'c': 'C',
+        'cpp': 'C++',
+        'javascript': 'JavaScript',
+        'typescript': 'TypeScript',
+        'java': 'Java',
+    }
+    
+    # 获取所有语言（按固定顺序，优先显示 C, C++, Rust, Go）
+    priority_languages = ['c', 'cpp', 'rust', 'go']
+    other_languages = ['python', 'javascript', 'typescript', 'java']
+    all_languages = priority_languages + [lang for lang in other_languages if lang not in priority_languages]
+    # 显示所有已知语言，即使某些功能不支持（只要在 info 中有记录）
+    languages = [lang for lang in all_languages if lang in info]
+    
+    # 如果没有任何语言，尝试显示 info 中的所有语言
+    if not languages:
+        languages = list(info.keys())
+        # 按优先级排序
+        languages = sorted(languages, key=lambda x: (
+            0 if x in priority_languages else 1,
+            priority_languages.index(x) if x in priority_languages else 999,
+            x
+        ))
+    
+    if not languages:
+        return
+    
+    # 创建表格
+    table = Table(
+        title="[bold cyan]编程语言功能支持情况[/bold cyan]",
+        show_header=True,
+        header_style="bold magenta",
+        border_style="blue",
+        title_style="bold cyan",
+        show_lines=False,
+        padding=(0, 1),
+    )
+    
+    # 添加语言列（第一列）
+    table.add_column("语言", style="cyan", no_wrap=True, justify="left")
+    
+    # 添加功能列
+    for feature in features:
+        table.add_column(feature, justify="center", style="green", no_wrap=True)
+    
+    # 添加语言行
+    for lang in languages:
+        display_name = lang_display_names.get(lang, lang.capitalize())
+        row = [display_name]
+        for feature in features:
+            supported = info.get(lang, {}).get(feature, False)
+            if supported:
+                # 如果是构建验证，显示构建系统名称
+                if feature == '构建验证' and isinstance(supported, str):
+                    row.append(f"[bold green]{supported}[/bold green]")
+                else:
+                    row.append("[bold green]✓[/bold green]")
+            else:
+                row.append("[bold red]✗[/bold red]")
+        table.add_row(*row)
+    
+    console = Console()
+    console.print()
+    # 居中显示表格
+    aligned_table = Align.center(table)
+    console.print(aligned_table)
+    console.print()
+

jarvis/jarvis_agent/main.py

@@ -7,7 +7,6 @@ import yaml  # type: ignore[import-untyped]
 
 from jarvis.jarvis_agent import Agent
 from jarvis.jarvis_utils.input import get_multiline_input
-from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 from jarvis.jarvis_utils.utils import init_env
 from jarvis.jarvis_utils.config import set_config
 
@@ -24,9 +23,7 @@ def load_config(config_path: str) -> dict:
         dict: 配置字典
     """
     if not os.path.exists(config_path):
-        PrettyOutput.print(
-            f"配置文件 {config_path} 不存在，使用默认配置", OutputType.WARNING
-        )
+        print(f"⚠️ 配置文件 {config_path} 不存在，使用默认配置")
         return {}
 
     with open(config_path, "r", encoding="utf-8", errors="ignore") as f:
@@ -34,7 +31,7 @@ def load_config(config_path: str) -> dict:
             config = yaml.safe_load(f)
             return config if config else {}
         except yaml.YAMLError as e:
-            PrettyOutput.print(f"配置文件解析失败: {str(e)}", OutputType.ERROR)
+            print(f"❌ 配置文件解析失败: {str(e)}")
             return {}
 
 
@@ -68,10 +65,7 @@ def cli(
             pass
     # 非交互模式要求从命令行传入任务
     if non_interactive and not (task and str(task).strip()):
-        PrettyOutput.print(
-            "非交互模式已启用：必须使用 --task 传入任务内容，因多行输入不可用。",
-            OutputType.ERROR,
-        )
+        print("❌ 非交互模式已启用：必须使用 --task 传入任务内容，因多行输入不可用。")
         raise typer.Exit(code=2)
     # Initialize环境
     init_env(
@@ -101,7 +95,7 @@ def cli(
 
         # Run agent with initial task if specified
         if task:
-            PrettyOutput.print(f"执行初始任务: {task}", OutputType.INFO)
+            print(f"ℹ️ 执行初始任务: {task}")
             agent.run(task)
             return
 
@@ -120,12 +114,12 @@ def cli(
             # 来自输入流程的正常退出
             return
         except Exception as e:
-            PrettyOutput.print(f"错误: {str(e)}", OutputType.ERROR)
+            print(f"❌ 错误: {str(e)}")
 
     except typer.Exit:
         return
     except Exception as e:
-        PrettyOutput.print(f"初始化错误: {str(e)}", OutputType.ERROR)
+        print(f"❌ 初始化错误: {str(e)}")
         raise typer.Exit(code=1)
 
 

jarvis/jarvis_agent/memory_manager.py

@@ -5,7 +5,6 @@
 """
 
 from jarvis.jarvis_utils.globals import get_all_memory_tags
-from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 from jarvis.jarvis_agent.events import TASK_STARTED, BEFORE_HISTORY_CLEAR, TASK_COMPLETED
 
 
@@ -82,16 +81,10 @@ class MemoryManager:
             return
 
         # 构建提示词，让大模型自己判断并保存记忆
-        prompt = """请回顾本次任务的整个过程，判断是否有值得长期记忆或项目记忆的信息。
-
-如果有以下类型的信息，请使用 save_memory 工具保存：
-1. 解决问题的新方法或技巧（适合保存为 global_long_term）
-2. 项目相关的重要发现或配置（适合保存为 project_long_term）
-3. 用户的偏好或习惯（适合保存为 global_long_term）
-4. 重要的技术知识或经验（适合保存为 global_long_term）
-5. 项目特定的实现细节或约定（适合保存为 project_long_term）
-
-请分析并保存有价值的信息，选择合适的记忆类型和标签。如果没有值得记忆的信息，请直接说明。"""
+        prompt = """回顾本次任务，判断是否有值得记忆的信息。使用 save_memory 保存：
+- global_long_term: 新方法/技巧、用户偏好、技术知识
+- project_long_term: 项目发现/配置、实现细节/约定
+如无值得记忆的信息，直接说明。"""
 
         # 处理记忆保存
         try:
@@ -116,14 +109,12 @@ class MemoryManager:
                 saved = False
 
             if saved:
-                PrettyOutput.print(
-                    "已自动保存有价值的信息到记忆系统", OutputType.SUCCESS
-                )
+                print("✅ 已自动保存有价值的信息到记忆系统")
             else:
-                PrettyOutput.print("本次任务没有特别需要记忆的信息", OutputType.INFO)
+                print("ℹ️ 本次任务没有特别需要记忆的信息")
 
         except Exception as e:
-            PrettyOutput.print(f"记忆分析失败: {str(e)}", OutputType.ERROR)
+            print(f"❌ 记忆分析失败: {str(e)}")
         finally:
             # 设置记忆提示完成标记，避免事件触发造成重复处理
             self._memory_prompted = True

jarvis/jarvis_agent/methodology_share_manager.py

@@ -8,7 +8,7 @@ from typing import List, Dict, Any
 
 import typer
 
-from jarvis.jarvis_agent import OutputType, PrettyOutput, user_confirm
+from jarvis.jarvis_agent import user_confirm
 from jarvis.jarvis_agent.share_manager import ShareManager
 from jarvis.jarvis_utils.config import (
     get_central_methodology_repo,
@@ -22,13 +22,8 @@ class MethodologyShareManager(ShareManager):
     def __init__(self):
         central_repo = get_central_methodology_repo()
         if not central_repo:
-            PrettyOutput.print(
-                "错误：未配置中心方法论仓库（JARVIS_CENTRAL_METHODOLOGY_REPO）",
-                OutputType.ERROR,
-            )
-            PrettyOutput.print(
-                "请在配置文件中设置中心方法论仓库的Git地址", OutputType.INFO
-            )
+            print("❌ 错误：未配置中心方法论仓库（JARVIS_CENTRAL_METHODOLOGY_REPO）")
+            print("ℹ️ 请在配置文件中设置中心方法论仓库的Git地址")
             raise typer.Exit(code=1)
 
         super().__init__(central_repo, "central_methodology_repo")
@@ -123,7 +118,8 @@ class MethodologyShareManager(ShareManager):
         share_list = ["\n将要分享以下方法论到中心仓库："]
         for meth in resources:
             share_list.append(f"- {meth['problem_type']}")
-        PrettyOutput.print("\n".join(share_list), OutputType.INFO)
+        joined_list = '\n'.join(share_list)
+        print(f"ℹ️ {joined_list}")
 
         if not user_confirm("确认分享这些方法论吗？"):
             return []
@@ -147,10 +143,7 @@ class MethodologyShareManager(ShareManager):
             # 获取本地资源
             local_resources = self.get_local_resources()
             if not local_resources:
-                PrettyOutput.print(
-                    "没有找到新的方法论文件（所有方法论可能已存在于中心仓库）",
-                    OutputType.WARNING,
-                )
+                print("⚠️ 没有找到新的方法论文件（所有方法论可能已存在于中心仓库）")
                 return
 
             # 选择要分享的资源
@@ -162,13 +155,14 @@ class MethodologyShareManager(ShareManager):
             copied_list = self.share_resources(selected_resources)
             if copied_list:
                 # 一次性显示所有复制结果
-                PrettyOutput.print("\n".join(copied_list), OutputType.SUCCESS)
+                joined_copied = '\n'.join(copied_list)
+                print(f"✅ {joined_copied}")
 
                 # 提交并推送
                 self.commit_and_push(len(selected_resources))
 
-                PrettyOutput.print("\n方法论已成功分享到中心仓库！", OutputType.SUCCESS)
+                print("✅ 方法论已成功分享到中心仓库！")
 
         except Exception as e:
-            PrettyOutput.print(f"分享方法论时出错: {str(e)}", OutputType.ERROR)
+            print(f"❌ 分享方法论时出错: {str(e)}")
             raise typer.Exit(code=1)

jarvis/jarvis_agent/prompt_manager.py

@@ -73,7 +73,7 @@ class PromptManager:
     如果没有完成，请进行下一步操作：
     - 仅包含一个操作
     - 如果信息不明确，请请求用户补充
-    - 如果执行过程中连续失败5次，请使用ask_user询问用户操作
+    - 如果执行过程中连续失败5次，请请求用户操作
     - 操作列表：{action_handlers}{memory_prompts}
 </system_prompt>