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

jarvis/jarvis_code_agent/code_agent.py

@@ -11,6 +11,7 @@ import hashlib
 from typing import Any, Dict, List, Optional, Tuple
 
 import typer
+import yaml
 
 from jarvis.jarvis_agent import Agent
 from jarvis.jarvis_agent.events import AFTER_TOOL_CALL
@@ -18,6 +19,7 @@ from jarvis.jarvis_code_agent.lint import (
     get_lint_tools,
     get_lint_commands_for_files,
     group_commands_by_tool,
+    get_format_commands_for_files,
 )
 from jarvis.jarvis_code_agent.code_analyzer.build_validator import BuildValidator, BuildResult, FallbackBuildValidator
 from jarvis.jarvis_code_agent.build_validation_config import BuildValidationConfig
@@ -33,10 +35,12 @@ from jarvis.jarvis_utils.config import (
     get_git_check_mode,
     set_config,
     get_data_dir,
-    is_plan_enabled,
     is_enable_intent_recognition,
     is_enable_impact_analysis,
+    get_smart_platform_name,
+    get_smart_model_name,
 )
+from jarvis.jarvis_platform.registry import PlatformRegistry
 from jarvis.jarvis_code_agent.utils import get_project_overview
 from jarvis.jarvis_utils.git_utils import (
     confirm_add_new_files,
@@ -46,13 +50,12 @@ from jarvis.jarvis_utils.git_utils import (
     get_diff,
     get_diff_file_list,
     get_latest_commit_hash,
-    get_recent_commits_with_files,
     handle_commit_workflow,
     has_uncommitted_changes,
     revert_change,
 )
 from jarvis.jarvis_utils.input import get_multiline_input, user_confirm
-from jarvis.jarvis_utils.output import OutputType, PrettyOutput
+from jarvis.jarvis_utils.output import OutputType, PrettyOutput  # 保留用于语法高亮
 from jarvis.jarvis_utils.utils import init_env, _acquire_single_instance_lock
 
 app = typer.Typer(help="Jarvis 代码助手")
@@ -83,7 +86,7 @@ class CodeAgent(Agent):
         append_tools: Optional[str] = None,
         tool_group: Optional[str] = None,
         non_interactive: Optional[bool] = None,
-        plan: Optional[bool] = None,
+        rule_names: Optional[str] = None,
         **kwargs,
     ):
         self.root_dir = os.getcwd()
@@ -98,13 +101,10 @@ class CodeAgent(Agent):
         self._check_git_config()
         base_tools = [
             "execute_script",
-            "search_web",
-            "ask_user",
             "read_code",
-            "save_memory",
-            "retrieve_memory",
-            "clear_memory",
-            "sub_code_agent",
+            "edit_file",
+            "rewrite_file",
+            "lsp_client",  # LSP客户端工具，用于获取代码补全、悬停等信息
         ]
 
         if append_tools:
@@ -121,10 +121,23 @@ class CodeAgent(Agent):
         project_rules = self._read_project_rules()
 
         combined_parts: List[str] = []
+        loaded_rule_names: List[str] = []  # 记录加载的规则名称
+        
         if global_rules:
             combined_parts.append(global_rules)
+            loaded_rule_names.append("global_rule")
         if project_rules:
             combined_parts.append(project_rules)
+            loaded_rule_names.append("project_rule")
+        
+        # 如果指定了 rule_names，从 rules.yaml 文件中读取并添加多个规则
+        if rule_names:
+            rule_list = [name.strip() for name in rule_names.split(',') if name.strip()]
+            for rule_name in rule_list:
+                named_rule = self._get_named_rule(rule_name)
+                if named_rule:
+                    combined_parts.append(named_rule)
+                    loaded_rule_names.append(rule_name)
 
         if combined_parts:
             merged_rules = "\n\n".join(combined_parts)
@@ -132,25 +145,44 @@ class CodeAgent(Agent):
                 f"{code_system_prompt}\n\n"
                 f"<rules>\n{merged_rules}\n</rules>"
             )
+            # 显示加载的规则名称
+            if loaded_rule_names:
+                rules_display = ", ".join(loaded_rule_names)
+                print(f"ℹ️ 已加载规则: {rules_display}")
         
         # 调用父类 Agent 的初始化
         # 默认禁用方法论和分析，但允许通过 kwargs 覆盖
         use_methodology = kwargs.pop("use_methodology", False)
         use_analysis = kwargs.pop("use_analysis", False)
+        # name 使用传入的值，如果没有传入则使用默认值 "CodeAgent"
+        name = kwargs.pop("name", "CodeAgent")
+        
+        # 准备显式传递给 super().__init__ 的参数
+        # 注意：这些参数如果也在 kwargs 中，需要先移除，避免重复传递错误
+        explicit_params = {
+            "system_prompt": code_system_prompt,
+            "name": name,
+            "auto_complete": False,
+            "model_group": model_group,
+            "need_summary": need_summary,
+            "use_methodology": use_methodology,
+            "use_analysis": use_analysis,
+            "non_interactive": non_interactive,
+            "use_tools": base_tools,
+        }
+        
+        # 自动移除所有显式传递的参数，避免重复传递错误
+        # 这样以后添加新参数时，只要在 explicit_params 中声明，就会自动处理
+        for key in explicit_params:
+            kwargs.pop(key, None)
+        
         super().__init__(
-            system_prompt=code_system_prompt,
-            name="CodeAgent",
-            auto_complete=False,
-            model_group=model_group,
-            need_summary=need_summary,
-            use_methodology=use_methodology,
-            use_analysis=use_analysis,
-            non_interactive=non_interactive,
-            plan=bool(plan) if plan is not None else is_plan_enabled(),
-            use_tools=base_tools,  # 仅启用限定工具
+            **explicit_params,
             **kwargs,
         )
 
+        self._agent_type = "code_agent"
+
         # 建立CodeAgent与Agent的关联，便于工具获取上下文管理器
         self._code_agent = self
 
@@ -158,7 +190,7 @@ class CodeAgent(Agent):
         try:
             # 获取当前Agent的model实例
             parent_model = None
-            if hasattr(self, 'model') and self.model:
+            if self.model:
                 parent_model = self.model
             
             self.context_recommender = ContextRecommender(
@@ -167,82 +199,103 @@ class CodeAgent(Agent):
             )
         except Exception as e:
             # LLM推荐器初始化失败
-            import logging
-            logger = logging.getLogger(__name__)
-            logger.warning(f"上下文推荐器初始化失败: {e}，将跳过上下文推荐功能")
+            print(f"⚠️ 上下文推荐器初始化失败: {e}，将跳过上下文推荐功能")
 
         self.event_bus.subscribe(AFTER_TOOL_CALL, self._on_after_tool_call)
+        
+        # 打印语言功能支持表格
+        try:
+            from jarvis.jarvis_agent.language_support_info import print_language_support_table
+            print_language_support_table()
+        except Exception:
+            pass
+
+    def _init_model(self, model_group: Optional[str]):
+        """初始化模型平台（CodeAgent使用smart平台，适用于代码生成等复杂场景）"""
+        platform_name = get_smart_platform_name(model_group)
+        model_name = get_smart_model_name(model_group)
+
+        maybe_model = PlatformRegistry().create_platform(platform_name)
+        if maybe_model is None:
+            print(f"⚠️ 平台 {platform_name} 不存在，将使用smart模型")
+            maybe_model = PlatformRegistry().get_smart_platform()
+
+        # 在此处收敛为非可选类型，确保后续赋值满足类型检查
+        self.model = maybe_model
+
+        if model_name:
+            self.model.set_model_name(model_name)
+
+        self.model.set_model_group(model_group)
+        self.model.set_suppress_output(False)
 
     def _get_system_prompt(self) -> str:
         """获取代码工程师的系统提示词"""
         return """
-<code_engineer_guide>
-## 角色定位
-你是Jarvis系统的代码工程师，一个专业的代码分析和修改助手。你的职责是：
-- 理解用户的代码需求，并提供高质量的实现方案
-- 精确分析项目结构和代码，准确定位需要修改的位置
-- 编写符合项目风格和标准的代码
-- 在修改代码时保持谨慎，确保不破坏现有功能
-- 做出专业的技术决策，减少用户决策负担
-
-## 核心原则
-- 自主决策：基于专业判断做出决策，减少用户询问
-- 高效精准：提供完整解决方案，避免反复修改
-- 修改审慎：修改前充分分析影响范围，做到一次把事情做好
-- 工具精通：选择最高效工具路径解决问题
-
-## 工作流程
-1. **项目分析**：分析项目结构，确定需修改的文件
-2. **需求分析**：理解需求意图，选择影响最小的实现方案
-3. **代码分析**：详细分析目标文件，禁止虚构现有代码
-   - 结构分析：优先使用文件搜索工具快速定位文件和目录结构
-   - 内容搜索：优先使用全文搜索工具进行函数、类、变量等内容的搜索，避免遗漏
-   - 依赖关系：如需分析依赖、调用关系，可结合代码分析工具辅助
-   - 代码阅读：使用 read_code 工具获取目标文件的完整内容或指定范围内容，禁止凭空假设代码
-   - 变更影响：如需分析变更影响范围，可结合版本控制工具辅助判断
-   - 上下文理解：系统已维护项目的符号表和依赖关系图，可以帮助理解代码结构和依赖关系
-   - 工具优先级：优先使用自动化工具，减少人工推断，确保分析结果准确
-4. **方案设计**：确定最小变更方案，保持代码结构
-5. **实施修改**：遵循"先读后写"原则，保持代码风格一致性
-
-## 工具使用
-- 项目结构：优先使用文件搜索命令查找文件
-- 代码搜索：优先使用内容搜索工具
-- 代码阅读：优先使用read_code工具
-- 仅在命令行工具不足时使用专用工具
-
-## 文件编辑工具使用规范
-- 对于部分文件内容修改，使用edit_file工具
-- 对于需要重写整个文件内容，使用 REWRITE 操作
-- 对于简单的修改，可以使用execute_script工具执行shell命令完成
-
-## 子任务与子CodeAgent
-- 当出现以下情况时，优先使用 sub_code_agent 工具将子任务托管给子 CodeAgent（自动完成并生成总结）：
-  - 需要在当前任务下并行推进较大且相对独立的代码改造
-  - 涉及多文件/多模块的大范围变更，或需要较长的工具调用链
-  - 需要隔离上下文以避免污染当前对话（如探索性改动、PoC）
-  - 需要专注于单一子问题，阶段性产出可独立复用的结果
-- 其余常规、小粒度改动直接在当前 Agent 中完成即可
-</code_engineer_guide>
-
-<say_to_llm>
-1. 保持专注与耐心，先分析再行动；将复杂问题拆解为可执行的小步骤
-2. 以结果为导向，同时简明呈现关键推理依据，避免无关噪音
-3. 信息不足时，主动提出最少且关键的问题以澄清需求
-4. 输出前自检：一致性、边界条件、依赖关系、回滚与风险提示
-5. 选择对现有系统影响最小且可回退的方案，确保稳定性与可维护性
-6. 保持项目风格：结构、命名、工具使用与现有规范一致
-7. 工具优先：使用搜索、read_code、版本控制与静态分析验证结论，拒绝臆测
-8. 面对错误与不确定，给出修复计划与备选路径，持续迭代优于停滞
-9. 沟通清晰：用要点列出结论、变更范围、影响评估与下一步行动
-10. 持续改进：沉淀经验为可复用清单，下一次做得更快更稳
-</say_to_llm>
+你是Jarvis代码工程师，专注于**项目级代码分析、精准修改与问题排查**，核心原则：自主决策不犹豫、高效精准不冗余、修改审慎可回退、工具精通不臆测。
+
+工作流程（闭环执行，每步必落地）：
+1. 需求拆解与项目对齐：
+   - 先明确用户需求的核心目标（如“修复XX报错”“新增XX功能”“优化XX性能”），标注关键约束（如“兼容Python 3.8+”“不修改核心依赖”）；
+   - 快速定位项目核心目录（如src/、main/）、技术栈（语言/框架/版本）、代码风格规范（如PEP8、ESLint规则），避免无的放矢。
+
+2. 目标文件精准定位（工具优先，拒绝盲搜）：
+   - 优先通过 lsp_client 的 search_symbol（符号搜索）定位关联文件（如函数、类、变量所属文件）；
+   - 若符号不明确，用全文搜索工具按“关键词+文件类型过滤”（如“关键词：user_login + 后缀：.py”）缩小范围；
+   - 仅当工具无法定位时，才用 read_code 读取疑似目录下的核心文件（如入口文件、配置文件），避免无效读取。
+
+3. 代码深度分析（基于工具，禁止虚构）：
+   - 符号分析：用 lsp_client 的 document_symbols（文档符号）、get_symbol_info（符号详情）、definition（定义跳转）、references（引用查询），确认符号的作用域、依赖关系、调用链路；
+   - 内容分析：用 read_code 读取目标文件完整内容，重点关注“逻辑分支、异常处理、依赖引入、配置参数”，记录关键代码片段（如报错位置、待修改逻辑）；
+   - 影响范围评估：用 lsp_client 的 references 查询待修改符号的所有引用场景，预判修改可能波及的模块，避免“改一处崩一片”。
+
+4. 最小变更方案设计（可回退、易维护）：
+   - 优先选择“局部修改”（如修改函数内逻辑、补充条件判断），而非“重构”或“全文件重写”；
+   - 方案需满足：① 覆盖需求核心；② 不破坏现有功能；③ 符合项目代码风格；④ 便于后续回退（如仅修改必要行，不删无关代码）；
+   - 若需修改核心逻辑（如公共函数、配置文件），先记录原始代码片段（如用临时文件保存到 /tmp/backup_xxx.txt），再执行修改。
+
+5. 先读后写，精准执行（工具规范使用）：
+   - 必须先通过 read_code 读取目标文件完整内容，确认待修改位置的上下文（如前后代码逻辑、缩进格式），再调用编辑工具；
+   - 编辑工具选择：
+     - 局部修改（改少数行、补代码块）：用 edit_file，明确标注“修改范围（行号/代码片段）+ 修改内容”（如“替换第15-20行的循环逻辑为：xxx”）；
+     - 全文件重写（如格式统一、逻辑重构）：仅当局部修改无法满足需求时使用 rewrite_file，重写前必须备份原始文件到 /tmp/rewrite_backup_xxx.txt。
+
+6. 验证与兜底（避免无效交付）：
+   - 修改后优先通过 lsp_client 的语法检查功能（若支持）验证代码无语法错误；
+   - 若涉及功能变更，建议补充1-2行核心测试用例（或提示用户验证场景），确保修改生效；
+   - 记录修改日志（保存到 /tmp/modify_log_xxx.txt），内容包括：修改时间、目标文件、修改原因、原始代码片段、修改后代码片段，便于问题追溯。
+
+工具使用规范（精准调用，不浪费资源）：
+- lsp_client：仅传递有效参数（如符号名精准、文件路径明确），避免模糊查询（如无关键词的全局搜索）；
+- 全文搜索：必须添加“文件类型过滤”“目录过滤”，减少无效结果（如仅搜索 src/ 目录下的 .java 文件）；
+- read_code：仅读取目标文件和关联依赖文件，不读取日志、测试数据、第三方依赖包等无关文件；
+- edit_file/rewrite_file：修改后必须保持代码缩进、命名规范与原文件一致（如原文件用4空格缩进，不改为2空格），不引入多余空行、注释。
+
+代码质量约束（底线要求，不可突破）：
+1. 语法正确性：修改后代码无语法错误、无未定义变量/函数、无依赖缺失；
+2. 功能兼容性：不破坏现有正常功能，修改后的代码能适配项目已有的调用场景；
+3. 风格一致性：严格遵循项目既有风格（如命名规范、缩进、注释格式），不引入个人风格；
+4. 可维护性：修改逻辑清晰，关键改动可加简洁注释（如“// 修复XX报错：XX场景下变量未初始化”），不写“魔法值”“冗余代码”。
+
+调试指引（问题闭环，高效排查）：
+- 定位报错：优先用 lsp_client 定位报错位置，结合 read_code 查看上下文，确认报错类型（语法错/逻辑错/运行时错）；
+- 日志补充：若报错模糊，在关键位置（如函数入口、循环内、异常捕获前）增加打印日志，内容包括“变量值、执行步骤、时间戳”（如 print(f"[DEBUG] user_login: username={username}, status={status}")），日志输出到 /tmp/ 目录，不污染项目日志；
+- 中间结果保存：复杂逻辑修改时，用临时文件（/tmp/temp_result_xxx.txt）保存中间数据（如计算结果、接口返回值），便于验证逻辑正确性；
+- 回退机制：若修改后出现新问题，立即用备份文件回退，重新分析，不盲目叠加修改。
+
+禁止行为（红线不可碰）：
+1. 禁止虚构代码、依赖、文件路径，所有结论必须基于工具返回结果或实际读取的代码；
+2. 禁止无差别读取项目所有文件，避免浪费资源；
+3. 禁止大篇幅删除、重构未明确要求修改的代码；
+4. 禁止引入项目未依赖的第三方库（除非用户明确允许）；
+5. 禁止修改 /tmp/ 以外的非项目目录文件，避免污染环境。
+
 """
 
     def _read_project_rules(self) -> Optional[str]:
         """读取 .jarvis/rules 内容，如果存在则返回字符串，否则返回 None"""
         try:
-            rules_path = os.path.join(self.root_dir, ".jarvis", "rules")
+            rules_path = os.path.join(self.root_dir, ".jarvis", "rule")
             if os.path.exists(rules_path) and os.path.isfile(rules_path):
                 with open(rules_path, "r", encoding="utf-8", errors="replace") as f:
                     content = f.read().strip()
@@ -255,7 +308,7 @@ class CodeAgent(Agent):
     def _read_global_rules(self) -> Optional[str]:
         """读取数据目录 rules 内容，如果存在则返回字符串，否则返回 None"""
         try:
-            rules_path = os.path.join(get_data_dir(), "rules")
+            rules_path = os.path.join(get_data_dir(), "rule")
             if os.path.exists(rules_path) and os.path.isfile(rules_path):
                 with open(rules_path, "r", encoding="utf-8", errors="replace") as f:
                     content = f.read().strip()
@@ -265,6 +318,48 @@ class CodeAgent(Agent):
             pass
         return None
 
+    def _get_named_rule(self, rule_name: str) -> Optional[str]:
+        """从 rules.yaml 文件中获取指定名称的规则
+        
+        参数:
+            rule_name: 规则名称
+            
+        返回:
+            str: 规则内容，如果未找到则返回 None
+        """
+        try:
+            # 读取全局数据目录下的 rules.yaml
+            global_rules_yaml_path = os.path.join(get_data_dir(), "rules.yaml")
+            global_rules = {}
+            if os.path.exists(global_rules_yaml_path) and os.path.isfile(global_rules_yaml_path):
+                with open(global_rules_yaml_path, "r", encoding="utf-8", errors="replace") as f:
+                    global_rules = yaml.safe_load(f) or {}
+            
+            # 读取 git 根目录下的 rules.yaml
+            project_rules_yaml_path = os.path.join(self.root_dir, "rules.yaml")
+            project_rules = {}
+            if os.path.exists(project_rules_yaml_path) and os.path.isfile(project_rules_yaml_path):
+                with open(project_rules_yaml_path, "r", encoding="utf-8", errors="replace") as f:
+                    project_rules = yaml.safe_load(f) or {}
+            
+            # 合并配置：项目配置覆盖全局配置
+            merged_rules = {**global_rules, **project_rules}
+            
+            # 查找指定的规则
+            if rule_name in merged_rules:
+                rule_value = merged_rules[rule_name]
+                # 如果值是字符串，直接返回
+                if isinstance(rule_value, str):
+                    return rule_value.strip() if rule_value.strip() else None
+                # 如果值是其他类型，转换为字符串
+                return str(rule_value).strip() if str(rule_value).strip() else None
+            
+            return None
+        except Exception as e:
+            # 读取规则失败时忽略，不影响主流程
+            print(f"⚠️ 读取 rules.yaml 失败: {e}")
+            return None
+
     def _check_git_config(self) -> None:
         """检查 git username 和 email 是否已设置，如果没有则提示并退出"""
         try:
@@ -301,25 +396,22 @@ class CodeAgent(Agent):
                 message = "❌ Git 配置不完整\n\n请运行以下命令配置 Git：\n" + "\n".join(
                     missing_configs
                 )
-                PrettyOutput.print(message, OutputType.WARNING)
+                print(f"⚠️ {message}")
                 # 通过配置控制严格校验模式（JARVIS_GIT_CHECK_MODE）：
                 # - warn: 仅告警并继续，后续提交可能失败
                 # - strict: 严格模式（默认），直接退出
                 mode = get_git_check_mode().lower()
                 if mode == "warn":
-                    PrettyOutput.print(
-                        "已启用 Git 校验警告模式（JARVIS_GIT_CHECK_MODE=warn），将继续运行。"
-                        "注意：后续提交可能失败，请尽快配置 git user.name 与 user.email。",
-                        OutputType.INFO,
-                    )
+                    print("ℹ️ 已启用 Git 校验警告模式（JARVIS_GIT_CHECK_MODE=warn），将继续运行。"
+                        "注意：后续提交可能失败，请尽快配置 git user.name 与 user.email。")
                     return
                 sys.exit(1)
 
         except FileNotFoundError:
-            PrettyOutput.print("❌ 未找到 git 命令，请先安装 Git", OutputType.ERROR)
+            print("❌ 未找到 git 命令，请先安装 Git")
             sys.exit(1)
         except Exception as e:
-            PrettyOutput.print(f"❌ 检查 Git 配置时出错: {str(e)}", OutputType.ERROR)
+            print(f"❌ 检查 Git 配置时出错: {str(e)}")
             sys.exit(1)
 
     def _find_git_root(self) -> str:
@@ -468,7 +560,7 @@ class CodeAgent(Agent):
                 content_to_write = "\n".join(new_lines).rstrip()
                 if content_to_write:
                     f.write(content_to_write + "\n")
-            PrettyOutput.print("已创建 .gitignore 并添加常用忽略规则", OutputType.SUCCESS)
+            print("✅ 已创建 .gitignore 并添加常用忽略规则")
         else:
             if new_lines:
                 # 追加缺失的规则
@@ -477,7 +569,7 @@ class CodeAgent(Agent):
                     if existing_content and not existing_content.endswith("\n"):
                         f.write("\n")
                     f.write("\n".join(new_lines).rstrip() + "\n")
-                PrettyOutput.print("已更新 .gitignore，追加常用忽略规则", OutputType.SUCCESS)
+                print("✅ 已更新 .gitignore，追加常用忽略规则")
 
     def _handle_git_changes(self, prefix: str, suffix: str) -> None:
         """处理git仓库中的未提交修改"""
@@ -528,16 +620,14 @@ class CodeAgent(Agent):
 
             return
 
-        PrettyOutput.print(
-            "⚠️ 正在修改git换行符敏感设置，这会影响所有文件的换行符处理方式",
-            OutputType.WARNING,
-        )
+        print("⚠️ 正在修改git换行符敏感设置，这会影响所有文件的换行符处理方式")
         # 避免在循环中逐条打印，先拼接后统一打印
         lines = ["将进行以下设置："]
         for key, value in target_settings.items():
             current = current_settings.get(key, "未设置")
             lines.append(f"{key}: {current} -> {value}")
-        PrettyOutput.print("\n".join(lines), OutputType.INFO)
+        joined_lines = '\n'.join(lines)
+        print(f"ℹ️ {joined_lines}")
 
         # 直接执行设置，不需要用户确认
         for key, value in target_settings.items():
@@ -547,7 +637,7 @@ class CodeAgent(Agent):
         if sys.platform.startswith("win"):
             self._handle_windows_line_endings()
 
-        PrettyOutput.print("git换行符敏感设置已更新", OutputType.SUCCESS)
+        print("✅ git换行符敏感设置已更新")
 
     def _handle_windows_line_endings(self) -> None:
         """在Windows系统上处理换行符问题，提供建议而非强制修改"""
@@ -561,13 +651,8 @@ class CodeAgent(Agent):
             if any(keyword in content for keyword in ["text=", "eol=", "binary"]):
                 return
 
-        PrettyOutput.print(
-            "提示：在Windows系统上，建议配置 .gitattributes 文件来避免换行符问题。",
-            OutputType.INFO,
-        )
-        PrettyOutput.print(
-            "这可以防止仅因换行符不同而导致整个文件被标记为修改。", OutputType.INFO
-        )
+        print("ℹ️ 提示：在Windows系统上，建议配置 .gitattributes 文件来避免换行符问题。")
+        print("ℹ️ 这可以防止仅因换行符不同而导致整个文件被标记为修改。")
 
         if user_confirm("是否要创建一个最小化的.gitattributes文件？", False):
             # 最小化的内容，只影响特定类型的文件
@@ -586,25 +671,18 @@ class CodeAgent(Agent):
             if not os.path.exists(gitattributes_path):
                 with open(gitattributes_path, "w", encoding="utf-8", newline="\n") as f:
                     f.write(minimal_content)
-                PrettyOutput.print(
-                    "已创建最小化的 .gitattributes 文件", OutputType.SUCCESS
-                )
+                print("✅ 已创建最小化的 .gitattributes 文件")
             else:
-                PrettyOutput.print(
-                    "将以下内容追加到现有 .gitattributes 文件：", OutputType.INFO
-                )
-                PrettyOutput.print(minimal_content, OutputType.CODE, lang="text")
+                print("ℹ️ 将以下内容追加到现有 .gitattributes 文件：")
+                PrettyOutput.print(minimal_content, OutputType.CODE, lang="text")  # 保留语法高亮
                 if user_confirm("是否追加到现有文件？", True):
                     with open(
                         gitattributes_path, "a", encoding="utf-8", newline="\n"
                     ) as f:
                         f.write("\n" + minimal_content)
-                    PrettyOutput.print("已更新 .gitattributes 文件", OutputType.SUCCESS)
+                    print("✅ 已更新 .gitattributes 文件")
         else:
-            PrettyOutput.print(
-                "跳过 .gitattributes 文件创建。如遇换行符问题，可手动创建此文件。",
-                OutputType.INFO,
-            )
+            print("ℹ️ 跳过 .gitattributes 文件创建。如遇换行符问题，可手动创建此文件。")
 
     def _record_code_changes_stats(self, diff_text: str) -> None:
         """记录代码变更的统计信息。
@@ -655,7 +733,7 @@ class CodeAgent(Agent):
             except subprocess.CalledProcessError:
                 pass
 
-            PrettyOutput.print("检测到未提交的修改，是否要提交？", OutputType.WARNING)
+            print("⚠️ 检测到未提交的修改，是否要提交？")
             if not user_confirm("是否要提交？", True):
                 return
 
@@ -693,7 +771,7 @@ class CodeAgent(Agent):
                     check=True,
                 )
             except subprocess.CalledProcessError as e:
-                PrettyOutput.print(f"提交失败: {str(e)}", OutputType.ERROR)
+                print(f"❌ 提交失败: {str(e)}")
 
     def _show_commit_history(
         self, start_commit: Optional[str], end_commit: Optional[str]
@@ -721,9 +799,81 @@ class CodeAgent(Agent):
             commit_messages = "检测到以下提交记录:\n" + "\n".join(
                 f"- {commit_hash[:7]}: {message}" for commit_hash, message in commits
             )
-            PrettyOutput.print(commit_messages, OutputType.INFO)
+            print(f"ℹ️ {commit_messages}")
         return commits
 
+    def _format_modified_files(self, modified_files: List[str]) -> None:
+        """格式化修改的文件
+        
+        Args:
+            modified_files: 修改的文件列表
+        """
+        if not modified_files:
+            return
+        
+        # 获取格式化命令
+        format_commands = get_format_commands_for_files(modified_files, self.root_dir)
+        if not format_commands:
+            return
+        
+        print("🔧 正在格式化代码...")
+        
+        # 执行格式化命令
+        formatted_files = set()
+        for tool_name, file_path, command in format_commands:
+            try:
+                # 检查文件是否存在
+                abs_file_path = os.path.join(self.root_dir, file_path) if not os.path.isabs(file_path) else file_path
+                if not os.path.exists(abs_file_path):
+                    continue
+                
+                # 执行格式化命令
+                result = subprocess.run(
+                    command,
+                    shell=True,
+                    cwd=self.root_dir,
+                    capture_output=True,
+                    text=True,
+                    encoding="utf-8",
+                    errors="replace",
+                    timeout=300,  # 300秒超时
+                )
+                
+                if result.returncode == 0:
+                    formatted_files.add(file_path)
+                    print(f"✅ 已格式化: {os.path.basename(file_path)} ({tool_name})")
+                else:
+                    # 格式化失败，记录但不中断流程
+                    error_msg = (result.stderr or result.stdout or "").strip()
+                    if error_msg:
+                        print(f"⚠️ 格式化失败 ({os.path.basename(file_path)}, {tool_name}): {error_msg[:200]}")
+            except subprocess.TimeoutExpired:
+                print(f"⚠️ 格式化超时: {os.path.basename(file_path)} ({tool_name})")
+            except FileNotFoundError:
+                # 工具未安装，跳过
+                continue
+            except Exception as e:
+                # 其他错误，记录但继续
+                print(f"⚠️ 格式化失败 ({os.path.basename(file_path)}, {tool_name}): {str(e)[:100]}")
+                continue
+        
+        if formatted_files:
+            print(f"✅ 已格式化 {len(formatted_files)} 个文件")
+            # 暂存格式化后的文件
+            try:
+                for file_path in formatted_files:
+                    abs_file_path = os.path.join(self.root_dir, file_path) if not os.path.isabs(file_path) else file_path
+                    if os.path.exists(abs_file_path):
+                        subprocess.run(
+                            ["git", "add", file_path],
+                            cwd=self.root_dir,
+                            check=False,
+                            stdout=subprocess.DEVNULL,
+                            stderr=subprocess.DEVNULL,
+                        )
+            except Exception:
+                pass
+
     def _handle_commit_confirmation(
         self,
         commits: List[Tuple[str, str]],
@@ -744,6 +894,12 @@ class CodeAgent(Agent):
                 stderr=subprocess.DEVNULL,
                 check=True,
             )
+            
+            # 检测变更文件并格式化
+            modified_files = get_diff_file_list()
+            if modified_files:
+                self._format_modified_files(modified_files)
+            
             git_commiter = GitCommitTool()
             git_commiter.execute({"prefix": prefix, "suffix": suffix, "agent": self, "model_group": getattr(self.model, "model_group", None)})
 
@@ -753,7 +909,7 @@ class CodeAgent(Agent):
         elif start_commit:
             if user_confirm("是否要重置到初始提交？", True):
                 os.system(f"git reset --hard {str(start_commit)}")  # 确保转换为字符串
-                PrettyOutput.print("已重置到初始提交", OutputType.INFO)
+                print("ℹ️ 已重置到初始提交")
 
     def run(self, user_input: str, prefix: str = "", suffix: str = "") -> Optional[str]:
         """使用给定的用户输入运行代码代理。
@@ -790,7 +946,7 @@ class CodeAgent(Agent):
                     was_suppressed = getattr(self.model, '_suppress_output', False)
                     self.model.set_suppress_output(True)
                 try:
-                    PrettyOutput.print("🔍 正在进行智能上下文推荐....", OutputType.INFO)
+                    print("🔍 正在进行智能上下文推荐....")
                     
                     # 生成上下文推荐（基于关键词和项目上下文）
                     recommendation = self.context_recommender.recommend_context(
@@ -802,12 +958,10 @@ class CodeAgent(Agent):
                     
                     # 打印推荐的上下文
                     if context_recommendation_text:
-                        PrettyOutput.print(context_recommendation_text, OutputType.INFO)
+                        print(f"ℹ️ {context_recommendation_text}")
                 except Exception as e:
                     # 上下文推荐失败不应该影响主流程
-                    import logging
-                    logger = logging.getLogger(__name__)
-                    logger.debug(f"上下文推荐失败: {e}", exc_info=True)
+                    print(f"⚠️ 上下文推荐失败: {e}")
                 finally:
                     # 恢复模型输出设置
                     if self.model:
@@ -830,7 +984,7 @@ class CodeAgent(Agent):
                     self.model.set_suppress_output(False)
                 super().run(enhanced_input)
             except RuntimeError as e:
-                PrettyOutput.print(f"执行失败: {str(e)}", OutputType.WARNING)
+                print(f"⚠️ 执行失败: {str(e)}")
                 return str(e)
 
 
@@ -981,7 +1135,7 @@ class CodeAgent(Agent):
         """更新上下文管理器：当文件被修改后，更新符号表和依赖图"""
         if not modified_files:
             return
-        PrettyOutput.print("🔄 正在更新代码上下文...", OutputType.INFO)
+        print("🔄 正在更新代码上下文...")
         for file_path in modified_files:
             if os.path.exists(file_path):
                 try:
@@ -1001,7 +1155,7 @@ class CodeAgent(Agent):
         if not is_enable_impact_analysis():
             return None
         
-        PrettyOutput.print("🔍 正在进行变更影响分析...", OutputType.INFO)
+        print("🔍 正在进行变更影响分析...")
         try:
             impact_analyzer = ImpactAnalyzer(self.context_manager)
             all_edits = []
@@ -1064,9 +1218,7 @@ class CodeAgent(Agent):
             return impact_report
         except Exception as e:
             # 影响分析失败不应该影响主流程，仅记录日志
-            import logging
-            logger = logging.getLogger(__name__)
-            logger.warning(f"影响范围分析失败: {e}", exc_info=True)
+            print(f"⚠️ 影响范围分析失败: {e}")
             return None
 
     def _handle_impact_report(self, impact_report: Optional[Any], agent: Agent, final_ret: str) -> str:
@@ -1115,7 +1267,6 @@ class CodeAgent(Agent):
         files_str = ", ".join(os.path.basename(f) for f in modified_files[:3])
         if file_count > 3:
             files_str += f" 等{file_count}个文件"
-        PrettyOutput.print(f"🔍 正在进行基础静态检查 ({files_str})...", OutputType.INFO)
         
         # 使用兜底验证器进行基础静态检查
         fallback_validator = FallbackBuildValidator(self.root_dir, timeout=get_build_validation_timeout())
@@ -1139,15 +1290,9 @@ class CodeAgent(Agent):
         if not config.has_been_asked():
             # 首次失败，询问用户
             error_preview = _format_build_error(build_validation_result)
-            PrettyOutput.print(
-                f"\n⚠️ 构建验证失败:\n{error_preview}\n",
-                OutputType.WARNING,
-            )
-            PrettyOutput.print(
-                "提示：如果此项目需要在特殊环境（如容器）中构建，或使用独立构建脚本，"
-                "可以选择禁用构建验证，后续将仅进行基础静态检查。",
-                OutputType.INFO,
-            )
+            print(f"\n⚠️ 构建验证失败:\n{error_preview}\n")
+            print("ℹ️ 提示：如果此项目需要在特殊环境（如容器）中构建，或使用独立构建脚本，"
+                "可以选择禁用构建验证，后续将仅进行基础静态检查。")
             
             if user_confirm(
                 "是否要禁用构建验证，后续仅进行基础静态检查？",
@@ -1165,7 +1310,6 @@ class CodeAgent(Agent):
                 files_str = ", ".join(os.path.basename(f) for f in modified_files[:3])
                 if file_count > 3:
                     files_str += f" 等{file_count}个文件"
-                PrettyOutput.print(f"🔍 正在进行基础静态检查 ({files_str})...", OutputType.INFO)
                 
                 # 立即进行基础静态检查
                 fallback_validator = FallbackBuildValidator(self.root_dir, timeout=get_build_validation_timeout())
@@ -1234,7 +1378,7 @@ class CodeAgent(Agent):
         """
         # 检查是否启用静态分析
         if not is_enable_static_analysis():
-            PrettyOutput.print("ℹ️  静态分析已禁用，跳过静态检查", OutputType.INFO)
+            print("ℹ️ 静态分析已禁用，跳过静态检查")
             return final_ret
         
         # 检查是否有可用的lint工具
@@ -1245,7 +1389,7 @@ class CodeAgent(Agent):
         )
         
         if not lint_tools_info:
-            PrettyOutput.print("ℹ️  未找到可用的静态检查工具，跳过静态检查", OutputType.INFO)
+            print("ℹ️ 未找到可用的静态检查工具，跳过静态检查")
             return final_ret
         
         # 如果构建验证失败且未禁用，不进行静态分析（避免重复错误）
@@ -1257,7 +1401,7 @@ class CodeAgent(Agent):
         )
         
         if should_skip_static:
-            PrettyOutput.print("ℹ️  构建验证失败，跳过静态分析（避免重复错误）", OutputType.INFO)
+            print("ℹ️ 构建验证失败，跳过静态分析（避免重复错误）")
             return final_ret
         
         # 直接执行静态扫描
@@ -1265,6 +1409,8 @@ class CodeAgent(Agent):
         if lint_results:
             # 有错误或警告，让大模型修复
             errors_summary = self._format_lint_results(lint_results)
+            # 打印完整的检查结果
+            print(f"⚠️ 静态扫描发现问题:\n{errors_summary}")
             addon_prompt = f"""
 静态扫描发现以下问题，请根据错误信息修复代码:
 
@@ -1321,29 +1467,23 @@ class CodeAgent(Agent):
 """
         
         try:
-            PrettyOutput.print("🤖 正在询问大模型判断大量代码删除是否合理...", OutputType.INFO)
+            print("🤖 正在询问大模型判断大量代码删除是否合理...")
             response = self.model.chat_until_success(prompt)  # type: ignore
             
             # 使用确定的协议标记解析回答
             if "<!!!YES!!!>" in response:
-                PrettyOutput.print("✅ 大模型确认：代码删除合理", OutputType.SUCCESS)
+                print("✅ 大模型确认：代码删除合理")
                 return True
             elif "<!!!NO!!!>" in response:
-                PrettyOutput.print("❌ 大模型确认：代码删除不合理", OutputType.WARNING)
+                print("⚠️ 大模型确认：代码删除不合理")
                 return False
             else:
                 # 如果无法找到协议标记，默认认为不合理（保守策略）
-                PrettyOutput.print(
-                    f"⚠️ 无法找到协议标记，默认认为不合理。回答内容: {response[:200]}",
-                    OutputType.WARNING
-                )
+                print(f"⚠️ 无法找到协议标记，默认认为不合理。回答内容: {response[:200]}")
                 return False
         except Exception as e:
             # 如果询问失败，默认认为不合理（保守策略）
-            PrettyOutput.print(
-                f"⚠️ 询问大模型失败: {str(e)}，默认认为不合理",
-                OutputType.WARNING
-            )
+            print(f"⚠️ 询问大模型失败: {str(e)}，默认认为不合理")
             return False
 
     def _on_after_tool_call(self, agent: Agent, current_response=None, need_return=None, tool_prompt=None, **kwargs) -> None:
@@ -1353,7 +1493,7 @@ class CodeAgent(Agent):
 
         if diff:
             start_hash = get_latest_commit_hash()
-            PrettyOutput.print(diff, OutputType.CODE, lang="diff")
+            PrettyOutput.print(diff, OutputType.CODE, lang="diff")  # 保留语法高亮
             modified_files = get_diff_file_list()
             
             # 更新上下文管理器
@@ -1364,21 +1504,20 @@ class CodeAgent(Agent):
             
             per_file_preview = self._build_per_file_patch_preview(modified_files)
             
-            # 非交互模式下，在提交前检测大量代码删除
-            if self.non_interactive:
-                detection_result = detect_large_code_deletion()
-                if detection_result is not None:
-                    # 检测到大量代码删除，询问大模型是否合理
-                    is_reasonable = self._ask_llm_about_large_deletion(detection_result, per_file_preview)
-                    if not is_reasonable:
-                        # 大模型认为不合理，撤销修改
-                        PrettyOutput.print("已撤销修改（大模型认为代码删除不合理）", OutputType.INFO)
-                        revert_change()
-                        final_ret += "\n\n修改被撤销（检测到大量代码删除且大模型判断不合理）\n"
-                        final_ret += f"# 补丁预览（按文件）:\n{per_file_preview}"
-                        PrettyOutput.print(final_ret, OutputType.USER, lang="markdown")
-                        self.session.prompt += final_ret
-                        return
+            # 所有模式下，在提交前检测大量代码删除并询问大模型
+            detection_result = detect_large_code_deletion()
+            if detection_result is not None:
+                # 检测到大量代码删除，询问大模型是否合理
+                is_reasonable = self._ask_llm_about_large_deletion(detection_result, per_file_preview)
+                if not is_reasonable:
+                    # 大模型认为不合理，撤销修改
+                    print("ℹ️ 已撤销修改（大模型认为代码删除不合理）")
+                    revert_change()
+                    final_ret += "\n\n修改被撤销（检测到大量代码删除且大模型判断不合理）\n"
+                    final_ret += f"# 补丁预览（按文件）:\n{per_file_preview}"
+                    PrettyOutput.print(final_ret, OutputType.USER, lang="markdown")  # 保留语法高亮
+                    self.session.prompt += final_ret
+                    return
             
             commited = handle_commit_workflow()
             if commited:
@@ -1409,8 +1548,16 @@ class CodeAgent(Agent):
 
                 # 添加提交信息到final_ret（按文件展示diff；删除文件仅提示）
                 if commits:
+                    # 获取最新的提交信息（commits列表按时间倒序，第一个是最新的）
+                    latest_commit_hash, latest_commit_message = commits[0]
+                    commit_short_hash = latest_commit_hash[:7] if len(latest_commit_hash) >= 7 else latest_commit_hash
+                    
                     final_ret += (
-                        f"\n\n代码已修改完成\n补丁内容（按文件）:\n{per_file_preview}\n"
+                        f"\n\n代码已修改完成\n"
+                        f"✅ 已自动提交\n"
+                        f"   Commit ID: {commit_short_hash} ({latest_commit_hash})\n"
+                        f"   提交信息: {latest_commit_message}\n"
+                        f"\n补丁内容（按文件）:\n{per_file_preview}\n"
                     )
                     
                     # 添加影响范围分析报告
@@ -1423,7 +1570,33 @@ class CodeAgent(Agent):
                     # 静态分析
                     final_ret = self._handle_static_analysis(modified_files, build_validation_result, config, self, final_ret)
                 else:
-                    final_ret += "\n\n修改没有生效\n"
+                    # 如果没有获取到commits，尝试直接从end_hash获取commit信息
+                    commit_info = ""
+                    if end_hash:
+                        try:
+                            result = subprocess.run(
+                                ["git", "log", "-1", "--pretty=format:%H|%s", end_hash],
+                                capture_output=True,
+                                text=True,
+                                encoding="utf-8",
+                                errors="replace",
+                                check=False,
+                            )
+                            if result.returncode == 0 and result.stdout and "|" in result.stdout:
+                                commit_hash, commit_message = result.stdout.strip().split("|", 1)
+                                commit_short_hash = commit_hash[:7] if len(commit_hash) >= 7 else commit_hash
+                                commit_info = (
+                                    f"\n✅ 已自动提交\n"
+                                    f"   Commit ID: {commit_short_hash} ({commit_hash})\n"
+                                    f"   提交信息: {commit_message}\n"
+                                )
+                        except Exception:
+                            pass
+                    
+                    if commit_info:
+                        final_ret += f"\n\n代码已修改完成{commit_info}\n"
+                    else:
+                        final_ret += "\n\n修改没有生效\n"
             else:
                 final_ret += "\n修改被拒绝\n"
                 final_ret += f"# 补丁预览（按文件）:\n{per_file_preview}"
@@ -1433,7 +1606,7 @@ class CodeAgent(Agent):
         if commited:
             self.session.prompt += final_ret
             return
-        PrettyOutput.print(final_ret, OutputType.USER, lang="markdown")
+        PrettyOutput.print(final_ret, OutputType.USER, lang="markdown")  # 保留语法高亮
         if not is_confirm_before_apply_patch() or user_confirm(
             "是否使用此回复？", default=True
         ):
@@ -1473,7 +1646,7 @@ class CodeAgent(Agent):
         tools_str = ", ".join(tool_names[:3])
         if len(tool_names) > 3:
             tools_str += f" 等{len(tool_names)}个工具"
-        PrettyOutput.print(f"🔍 正在进行静态检查 ({files_str}, 使用 {tools_str})...", OutputType.INFO)
+        print("🔍 静态检查中...")
         
         results = []
         # 记录每个文件的检查结果
@@ -1492,6 +1665,9 @@ class CodeAgent(Agent):
                         file_results.append((file_name, tool_name, "跳过", "文件不存在"))
                         continue
                     
+                    # 打印执行的命令
+                    print(f"ℹ️ 执行: {command}")
+                    
                     # 执行命令
                     result = subprocess.run(
                         command,
@@ -1501,7 +1677,7 @@ class CodeAgent(Agent):
                         text=True,
                         encoding="utf-8",
                         errors="replace",
-                        timeout=30,  # 30秒超时
+                        timeout=600,  # 600秒超时
                     )
                     
                     # 只记录有错误或警告的结果
@@ -1510,23 +1686,27 @@ class CodeAgent(Agent):
                         if output.strip():  # 有输出才记录
                             results.append((tool_name, file_path, command, result.returncode, output))
                             file_results.append((file_name, tool_name, "失败", "发现问题"))
+                            # 失败时打印检查结果
+                            output_preview = output[:2000] if len(output) > 2000 else output
+                            print(f"⚠️ 检查失败 ({file_name}):\n{output_preview}")
+                            if len(output) > 2000:
+                                print(f"⚠️ ... (输出已截断，共 {len(output)} 字符)")
                         else:
                             file_results.append((file_name, tool_name, "通过", ""))
                     else:
                         file_results.append((file_name, tool_name, "通过", ""))
                 
                 except subprocess.TimeoutExpired:
-                    results.append((tool_name, file_path, command, -1, "执行超时（30秒）"))
-                    file_results.append((file_name, tool_name, "超时", "执行超时（30秒）"))
+                    results.append((tool_name, file_path, command, -1, "执行超时（600秒）"))
+                    file_results.append((file_name, tool_name, "超时", "执行超时（600秒）"))
+                    print(f"⚠️ 检查超时 ({file_name}): 执行超时（600秒）")
                 except FileNotFoundError:
                     # 工具未安装，跳过
                     file_results.append((file_name, tool_name, "跳过", "工具未安装"))
                     continue
                 except Exception as e:
                     # 其他错误，记录但继续
-                    import logging
-                    logger = logging.getLogger(__name__)
-                    logger.warning(f"执行lint命令失败: {command}, 错误: {e}")
+                    print(f"⚠️ 执行lint命令失败: {command}, 错误: {e}")
                     file_results.append((file_name, tool_name, "失败", f"执行失败: {str(e)[:50]}"))
                     continue
         
@@ -1536,38 +1716,23 @@ class CodeAgent(Agent):
             passed_count = sum(1 for _, _, status, _ in file_results if status == "通过")
             failed_count = sum(1 for _, _, status, _ in file_results if status == "失败")
             timeout_count = sum(1 for _, _, status, _ in file_results if status == "超时")
-            skipped_count = sum(1 for _, _, status, _ in file_results if status == "跳过")
+            sum(1 for _, _, status, _ in file_results if status == "跳过")
             
-            # 构建结果摘要
-            summary_lines = [f"🔍 静态检查完成: 共检查 {total_files} 个文件"]
-            if passed_count > 0:
-                summary_lines.append(f"  ✅ 通过: {passed_count}")
+            # 收缩为一行的结果摘要
+            summary = f"🔍 静态检查: {total_files}个文件"
             if failed_count > 0:
-                summary_lines.append(f"  ❌ 失败: {failed_count}")
+                summary += f", {failed_count}失败"
             if timeout_count > 0:
-                summary_lines.append(f"  ⏱️  超时: {timeout_count}")
-            if skipped_count > 0:
-                summary_lines.append(f"  ⚠️  跳过: {skipped_count}")
+                summary += f", {timeout_count}超时"
+            if passed_count == total_files:
+                summary += " ✅全部通过"
             
-            # 添加详细结果（只显示失败和超时的文件）
             if failed_count > 0 or timeout_count > 0:
-                summary_lines.append("\n详细结果:")
-                for file_name, tool_name, status, message in file_results:
-                    if status not in ("失败", "超时"):
-                        continue  # 只显示失败和超时的文件
-                    status_icon = {
-                        "失败": "❌",
-                        "超时": "⏱️"
-                    }.get(status, "•")
-                    if message:
-                        summary_lines.append(f"  {status_icon} {file_name} ({tool_name}): {message}")
-                    else:
-                        summary_lines.append(f"  {status_icon} {file_name} ({tool_name})")
-            
-            output_type = OutputType.WARNING if (failed_count > 0 or timeout_count > 0) else OutputType.SUCCESS
-            PrettyOutput.print("\n".join(summary_lines), output_type)
+                print(f"⚠️ {summary}")
+            else:
+                print(f"✅ {summary}")
         else:
-            PrettyOutput.print("🔍 静态检查完成: 全部通过", OutputType.SUCCESS)
+            print("✅ 静态检查完成")
         
         return results
     
@@ -1599,87 +1764,6 @@ class CodeAgent(Agent):
             lines.append("")  # 空行分隔
         
         return "\n".join(lines)
-    
-    def _extract_file_paths_from_input(self, user_input: str) -> List[str]:
-        """从用户输入中提取文件路径
-        
-        Args:
-            user_input: 用户输入文本
-            
-        Returns:
-            文件路径列表
-        """
-        import re
-        file_paths = []
-        
-        # 匹配常见的文件路径模式
-        # 1. 引号中的路径: "path/to/file.py" 或 'path/to/file.py'
-        quoted_paths = re.findall(r'["\']([^"\']+\.(?:py|js|ts|rs|go|java|cpp|c|h|hpp))["\']', user_input)
-        file_paths.extend(quoted_paths)
-        
-        # 2. 相对路径: ./path/to/file.py 或 path/to/file.py
-        relative_paths = re.findall(r'(?:\./)?[\w/]+\.(?:py|js|ts|rs|go|java|cpp|c|h|hpp)', user_input)
-        file_paths.extend(relative_paths)
-        
-        # 3. 绝对路径（简化匹配）
-        absolute_paths = re.findall(r'/(?:[\w\-\.]+/)+[\w\-\.]+\.(?:py|js|ts|rs|go|java|cpp|c|h|hpp)', user_input)
-        file_paths.extend(absolute_paths)
-        
-        # 转换为绝对路径并去重
-        unique_paths = []
-        seen = set()
-        for path in file_paths:
-            abs_path = os.path.abspath(path) if not os.path.isabs(path) else path
-            if abs_path not in seen and os.path.exists(abs_path):
-                seen.add(abs_path)
-                unique_paths.append(abs_path)
-        
-        return unique_paths
-
-    def _extract_symbols_from_input(self, user_input: str) -> List[str]:
-        """从用户输入中提取符号名称（函数名、类名等）
-        
-        Args:
-            user_input: 用户输入文本
-            
-        Returns:
-            符号名称列表
-        """
-        import re
-        symbols = []
-        
-        # 匹配常见的符号命名模式
-        # 1. 驼峰命名（类名）: MyClass, ProcessData
-        camel_case = re.findall(r'\b[A-Z][a-zA-Z0-9]+\b', user_input)
-        symbols.extend(camel_case)
-        
-        # 2. 下划线命名（函数名、变量名）: process_data, get_user_info
-        snake_case = re.findall(r'\b[a-z][a-z0-9_]+[a-z0-9]\b', user_input)
-        symbols.extend(snake_case)
-        
-        # 3. 在引号中的符号名: "function_name" 或 'ClassName'
-        quoted_symbols = re.findall(r'["\']([A-Za-z][A-Za-z0-9_]*?)["\']', user_input)
-        symbols.extend(quoted_symbols)
-        
-        # 过滤常见停用词和过短的符号
-        stop_words = {
-            'the', 'and', 'for', 'are', 'but', 'not', 'you', 'all', 'can', 'her', 'was', 'one',
-            'our', 'out', 'day', 'get', 'has', 'him', 'his', 'how', 'its', 'may', 'new', 'now',
-            'old', 'see', 'two', 'way', 'who', 'boy', 'did', 'its', 'let', 'put', 'say', 'she',
-            'too', 'use', '添加', '修改', '实现', '修复', '更新', '删除', '创建', '文件', '代码',
-        }
-        
-        unique_symbols = []
-        seen = set()
-        for symbol in symbols:
-            symbol_lower = symbol.lower()
-            if (symbol_lower not in stop_words and 
-                len(symbol) > 2 and 
-                symbol_lower not in seen):
-                seen.add(symbol_lower)
-                unique_symbols.append(symbol)
-        
-        return unique_symbols[:10]  # 限制数量
 
     def _validate_build_after_edit(self, modified_files: List[str]) -> Optional[BuildResult]:
         """编辑后验证构建
@@ -1704,7 +1788,7 @@ class CodeAgent(Agent):
         files_str = ", ".join(os.path.basename(f) for f in modified_files[:3])
         if file_count > 3:
             files_str += f" 等{file_count}个文件"
-        PrettyOutput.print(f"🔨 正在进行编译检查 ({files_str})...", OutputType.INFO)
+        print(f"🔨 正在进行编译检查 ({files_str})...")
         
         try:
             timeout = get_build_validation_timeout()
@@ -1713,9 +1797,7 @@ class CodeAgent(Agent):
             return result
         except Exception as e:
             # 构建验证失败不应该影响主流程，仅记录日志
-            import logging
-            logger = logging.getLogger(__name__)
-            logger.warning(f"构建验证执行失败: {e}", exc_info=True)
+            print(f"⚠️ 构建验证执行失败: {e}")
             return None
 
 
@@ -1754,7 +1836,9 @@ def cli(
     non_interactive: bool = typer.Option(
         False, "-n", "--non-interactive", help="启用非交互模式：用户无法与命令交互，脚本执行超时限制为5分钟"
     ),
-    plan: bool = typer.Option(False, "--plan/--no-plan", help="启用或禁用任务规划（子任务拆分与汇总执行）"),
+    rule_names: Optional[str] = typer.Option(
+        None, "--rule-names", help="指定规则名称列表，用逗号分隔，从 rules.yaml 文件中读取对应的规则内容"
+    ),
 ) -> None:
     """Jarvis主入口点。"""
     # CLI 标志：非交互模式（不依赖配置文件）
@@ -1766,10 +1850,7 @@ def cli(
         # 注意：全局配置同步放在 init_env 之后执行，避免被 init_env 覆盖
     # 非交互模式要求从命令行传入任务
     if non_interactive and not (requirement and str(requirement).strip()):
-        PrettyOutput.print(
-            "非交互模式已启用：必须使用 --requirement 传入任务内容，因多行输入不可用。",
-            OutputType.ERROR,
-        )
+        print("❌ 非交互模式已启用：必须使用 --requirement 传入任务内容，因多行输入不可用。")
         raise typer.Exit(code=2)
     init_env(
         "欢迎使用 Jarvis-CodeAgent，您的代码工程助手已准备就绪！",
@@ -1801,9 +1882,7 @@ def cli(
         )
     except (subprocess.CalledProcessError, FileNotFoundError):
         curr_dir_path = os.getcwd()
-        PrettyOutput.print(
-            f"警告：当前目录 '{curr_dir_path}' 不是一个git仓库。", OutputType.WARNING
-        )
+        print(f"⚠️ 警告：当前目录 '{curr_dir_path}' 不是一个git仓库。")
         init_git = True if non_interactive else user_confirm(
             f"是否要在 '{curr_dir_path}' 中初始化一个新的git仓库？", default=True
         )
@@ -1817,14 +1896,12 @@ def cli(
                     encoding="utf-8",
                     errors="replace",
                 )
-                PrettyOutput.print("✅ 已成功初始化git仓库。", OutputType.SUCCESS)
+                print("✅ 已成功初始化git仓库。")
             except (subprocess.CalledProcessError, FileNotFoundError) as e:
-                PrettyOutput.print(f"❌ 初始化git仓库失败: {e}", OutputType.ERROR)
+                print(f"❌ 初始化git仓库失败: {e}")
                 sys.exit(1)
         else:
-            PrettyOutput.print(
-                "操作已取消。Jarvis需要在git仓库中运行。", OutputType.INFO
-            )
+            print("ℹ️ 操作已取消。Jarvis需要在git仓库中运行。")
             sys.exit(0)
 
     curr_dir = os.getcwd()
@@ -1838,25 +1915,22 @@ def cli(
         # 回退到全局锁，确保至少有互斥保护
         _acquire_single_instance_lock(lock_name="code_agent.lock")
     try:
+        
         agent = CodeAgent(
             model_group=model_group,
             need_summary=False,
             append_tools=append_tools,
             tool_group=tool_group,
             non_interactive=non_interactive,
-            plan=plan,
+            rule_names=rule_names,
         )
 
         # 尝试恢复会话
         if restore_session:
             if agent.restore_session():
-                PrettyOutput.print(
-                    "已从 .jarvis/saved_session.json 恢复会话。", OutputType.SUCCESS
-                )
+                print("✅ 已从 .jarvis/saved_session.json 恢复会话。")
             else:
-                PrettyOutput.print(
-                    "无法从 .jarvis/saved_session.json 恢复会话。", OutputType.WARNING
-                )
+                print("⚠️ 无法从 .jarvis/saved_session.json 恢复会话。")
 
         if requirement:
             agent.run(requirement, prefix=prefix, suffix=suffix)
@@ -1870,7 +1944,7 @@ def cli(
     except typer.Exit:
         raise
     except RuntimeError as e:
-        PrettyOutput.print(f"错误: {str(e)}", OutputType.ERROR)
+        print(f"❌ 错误: {str(e)}")
         sys.exit(1)