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

jarvis/jarvis_code_agent/code_agent.py

@@ -1,78 +1,64 @@
-# -*- coding: utf-8 -*-
 """Jarvis代码代理模块。
 
 该模块提供CodeAgent类，用于处理代码修改任务。
 """
 
+import hashlib
 import os
+
+from jarvis.jarvis_utils.output import PrettyOutput
+
+# -*- coding: utf-8 -*-
 import subprocess
 import sys
-import hashlib
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any, Optional
 
 import typer
-import yaml
 
 from jarvis.jarvis_agent import Agent
 from jarvis.jarvis_agent.events import AFTER_TOOL_CALL
-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
-from jarvis.jarvis_git_utils.git_commiter import GitCommitTool
+from jarvis.jarvis_code_agent.code_agent_build import BuildValidationManager
+from jarvis.jarvis_code_agent.code_agent_diff import DiffManager
+from jarvis.jarvis_code_agent.code_agent_git import GitManager
+from jarvis.jarvis_code_agent.code_agent_impact import ImpactManager
+from jarvis.jarvis_code_agent.code_agent_lint import LintManager
+from jarvis.jarvis_code_agent.code_agent_llm import LLMManager
+from jarvis.jarvis_code_agent.code_agent_postprocess import PostProcessManager
+from jarvis.jarvis_code_agent.code_agent_prompts import get_system_prompt
+from jarvis.jarvis_code_agent.code_agent_rules import RulesManager
 from jarvis.jarvis_code_agent.code_analyzer import ContextManager
-from jarvis.jarvis_code_agent.code_analyzer.llm_context_recommender import ContextRecommender
-from jarvis.jarvis_code_agent.code_analyzer import ImpactAnalyzer, parse_git_diff_to_edits
-from jarvis.jarvis_utils.config import (
-    is_confirm_before_apply_patch,
-    is_enable_static_analysis,
-    is_enable_build_validation,
-    get_build_validation_timeout,
-    get_git_check_mode,
-    set_config,
-    get_data_dir,
-    is_enable_intent_recognition,
-    is_enable_impact_analysis,
-    get_smart_platform_name,
-    get_smart_model_name,
+from jarvis.jarvis_code_agent.code_analyzer.llm_context_recommender import (
+    ContextRecommender,
 )
-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,
-    detect_large_code_deletion,
-    find_git_root_and_cd,
-    get_commits_between,
-    get_diff,
-    get_diff_file_list,
-    get_latest_commit_hash,
-    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.utils import init_env, _acquire_single_instance_lock
+from jarvis.jarvis_platform.registry import PlatformRegistry
+from jarvis.jarvis_utils.config import get_smart_model_name
+from jarvis.jarvis_utils.config import get_smart_platform_name
+from jarvis.jarvis_utils.config import is_confirm_before_apply_patch
+from jarvis.jarvis_utils.config import is_enable_intent_recognition
+from jarvis.jarvis_utils.config import set_config
+from jarvis.jarvis_utils.git_utils import detect_large_code_deletion
+from jarvis.jarvis_utils.git_utils import find_git_root_and_cd
+from jarvis.jarvis_utils.git_utils import get_commits_between
+from jarvis.jarvis_utils.git_utils import get_diff
+from jarvis.jarvis_utils.git_utils import get_diff_between_commits
+from jarvis.jarvis_utils.git_utils import get_diff_file_list
+from jarvis.jarvis_utils.git_utils import get_latest_commit_hash
+from jarvis.jarvis_utils.git_utils import handle_commit_workflow
+from jarvis.jarvis_utils.git_utils import revert_change
+from jarvis.jarvis_utils.input import get_multiline_input
+from jarvis.jarvis_utils.input import user_confirm
+from jarvis.jarvis_utils.output import OutputType  # 保留用于语法高亮
+from jarvis.jarvis_utils.utils import _acquire_single_instance_lock
+from jarvis.jarvis_utils.utils import init_env
+from jarvis.jarvis_utils.tag import ot
+from jarvis.jarvis_utils.globals import set_current_agent
+from jarvis.jarvis_utils.globals import clear_current_agent
 
 app = typer.Typer(help="Jarvis 代码助手")
 
 
-def _format_build_error(result: BuildResult, max_len: int = 2000) -> str:
-    """格式化构建错误信息，限制输出长度"""
-    error_msg = result.error_message or ""
-    output = result.output or ""
-
-    full_error = f"{error_msg}\n{output}".strip()
-
-    if len(full_error) > max_len:
-        return full_error[:max_len] + "\n... (输出已截断)"
-    return full_error
-
-
 class CodeAgent(Agent):
     """Jarvis系统的代码修改代理。
 
@@ -85,27 +71,48 @@ class CodeAgent(Agent):
         need_summary: bool = True,
         append_tools: Optional[str] = None,
         tool_group: Optional[str] = None,
-        non_interactive: Optional[bool] = None,
+        non_interactive: Optional[bool] = True,
         rule_names: Optional[str] = None,
-        **kwargs,
-    ):
+        disable_review: bool = False,
+        review_max_iterations: int = 0,
+        enable_task_list_manager: bool = True,
+        **kwargs: Any,
+    ) -> None:
         self.root_dir = os.getcwd()
         self.tool_group = tool_group
+        # 记录当前是否为非交互模式，便于在提示词/输入中动态调整行为说明
+        self.non_interactive: bool = bool(non_interactive)
+        # Review 相关配置
+        self.disable_review = disable_review
+        self.review_max_iterations = review_max_iterations
+
+        # 存储开始时的commit hash，用于后续git diff获取
+        self.start_commit: Optional[str] = None
 
         # 初始化上下文管理器
         self.context_manager = ContextManager(self.root_dir)
         # 上下文推荐器将在Agent创建后初始化（需要LLM模型）
         self.context_recommender: Optional[ContextRecommender] = None
 
+        # 初始化各个管理器
+        self.rules_manager = RulesManager(self.root_dir)
+        self.git_manager = GitManager(self.root_dir)
+        self.diff_manager = DiffManager(self.root_dir)
+        self.impact_manager = ImpactManager(self.root_dir, self.context_manager)
+        self.build_validation_manager = BuildValidationManager(self.root_dir)
+        self.lint_manager = LintManager(self.root_dir)
+        self.post_process_manager = PostProcessManager(self.root_dir)
+        # LLM管理器将在模型初始化后创建
+
         # 检测 git username 和 email 是否已设置
-        self._check_git_config()
+        self.git_manager.check_git_config()
         base_tools = [
             "execute_script",
             "read_code",
-            "edit_file",
-            "rewrite_file",
-            "lsp_client",  # LSP客户端工具，用于获取代码补全、悬停等信息
+            "edit_file",  # 普通 search/replace 编辑
         ]
+        if enable_task_list_manager:
+            base_tools.append("task_list_manager")  # 任务列表管理工具
 
         if append_tools:
             additional_tools = [
@@ -115,48 +122,15 @@ class CodeAgent(Agent):
             # 去重
             base_tools = list(dict.fromkeys(base_tools))
 
-        code_system_prompt = self._get_system_prompt()
-        # 先加载全局规则（数据目录 rules），再加载项目规则（.jarvis/rules），并拼接为单一规则块注入
-        global_rules = self._read_global_rules()
-        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)
-            code_system_prompt = (
-                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}")
-        
+        code_system_prompt = get_system_prompt()
+
         # 调用父类 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 = {
@@ -170,12 +144,12 @@ class CodeAgent(Agent):
             "non_interactive": non_interactive,
             "use_tools": base_tools,
         }
-        
+
         # 自动移除所有显式传递的参数，避免重复传递错误
         # 这样以后添加新参数时，只要在 explicit_params 中声明，就会自动处理
         for key in explicit_params:
             kwargs.pop(key, None)
-        
+
         super().__init__(
             **explicit_params,
             **kwargs,
@@ -192,32 +166,36 @@ class CodeAgent(Agent):
             parent_model = None
             if self.model:
                 parent_model = self.model
-            
+
             self.context_recommender = ContextRecommender(
-                self.context_manager,
-                parent_model=parent_model
+                self.context_manager, parent_model=parent_model
             )
         except Exception as e:
             # LLM推荐器初始化失败
-            print(f"⚠️ 上下文推荐器初始化失败: {e}，将跳过上下文推荐功能")
+            PrettyOutput.auto_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
+            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]):
+    def _init_model(self, model_group: Optional[str]) -> None:
         """初始化模型平台（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模型")
+            PrettyOutput.auto_print(f"⚠️ 平台 {platform_name} 不存在，将使用smart模型")
             maybe_model = PlatformRegistry().get_smart_platform()
 
         # 在此处收敛为非可选类型，确保后续赋值满足类型检查
@@ -229,690 +207,19 @@ class CodeAgent(Agent):
         self.model.set_model_group(model_group)
         self.model.set_suppress_output(False)
 
-    def _get_system_prompt(self) -> str:
-        """获取代码工程师的系统提示词"""
-        return """
-你是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"""
+        # 初始化LLM管理器（使用普通模型，不使用smart模型）
+        self.llm_manager = LLMManager(parent_model=self.model, model_group=model_group)
+        # 同步模型组到全局，便于后续工具（如提交信息生成）获取一致的模型配置
         try:
-            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()
-                return content if content else None
-        except Exception:
-            # 读取规则失败时忽略，不影响主流程
-            pass
-        return None
+            from jarvis.jarvis_utils.globals import set_global_model_group
 
-    def _read_global_rules(self) -> Optional[str]:
-        """读取数据目录 rules 内容，如果存在则返回字符串，否则返回 None"""
-        try:
-            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()
-                return content if content else None
+            set_global_model_group(model_group)
         except Exception:
-            # 读取规则失败时忽略，不影响主流程
+            # 若全局同步失败，不影响主流程
             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:
-            # 检查 git user.name
-            result = subprocess.run(
-                ["git", "config", "--get", "user.name"],
-                capture_output=True,
-                text=True,
-                check=False,
-            )
-            username = result.stdout.strip()
-
-            # 检查 git user.email
-            result = subprocess.run(
-                ["git", "config", "--get", "user.email"],
-                capture_output=True,
-                text=True,
-                check=False,
-            )
-            email = result.stdout.strip()
-
-            # 如果任一配置未设置，提示并退出
-            if not username or not email:
-                missing_configs = []
-                if not username:
-                    missing_configs.append(
-                        '  git config --global user.name "Your Name"'
-                    )
-                if not email:
-                    missing_configs.append(
-                        '  git config --global user.email "your.email@example.com"'
-                    )
-
-                message = "❌ Git 配置不完整\n\n请运行以下命令配置 Git：\n" + "\n".join(
-                    missing_configs
-                )
-                print(f"⚠️ {message}")
-                # 通过配置控制严格校验模式（JARVIS_GIT_CHECK_MODE）：
-                # - warn: 仅告警并继续，后续提交可能失败
-                # - strict: 严格模式（默认），直接退出
-                mode = get_git_check_mode().lower()
-                if mode == "warn":
-                    print("ℹ️ 已启用 Git 校验警告模式（JARVIS_GIT_CHECK_MODE=warn），将继续运行。"
-                        "注意：后续提交可能失败，请尽快配置 git user.name 与 user.email。")
-                    return
-                sys.exit(1)
-
-        except FileNotFoundError:
-            print("❌ 未找到 git 命令，请先安装 Git")
-            sys.exit(1)
-        except Exception as e:
-            print(f"❌ 检查 Git 配置时出错: {str(e)}")
-            sys.exit(1)
-
-    def _find_git_root(self) -> str:
-        """查找并切换到git根目录
-
-        返回:
-            str: git根目录路径
-        """
-
-        curr_dir = os.getcwd()
-        git_dir = find_git_root_and_cd(curr_dir)
-        self.root_dir = git_dir
-
-        return git_dir
-
-    def _update_gitignore(self, git_dir: str) -> None:
-        """检查并更新.gitignore文件，确保忽略.jarvis目录，并追加常用语言的忽略规则（若缺失）
-
-        参数:
-            git_dir: git根目录路径
-        """
-        gitignore_path = os.path.join(git_dir, ".gitignore")
-
-        # 常用忽略规则（按语言/场景分组）
-        sections = {
-            "General": [
-                ".jarvis",
-                ".DS_Store",
-                "Thumbs.db",
-                "*.log",
-                "*.tmp",
-                "*.swp",
-                "*.swo",
-                ".idea/",
-                ".vscode/",
-            ],
-            "Python": [
-                "__pycache__/",
-                "*.py[cod]",
-                "*$py.class",
-                ".Python",
-                "env/",
-                "venv/",
-                ".venv/",
-                "build/",
-                "dist/",
-                "develop-eggs/",
-                "downloads/",
-                "eggs/",
-                ".eggs/",
-                "lib/",
-                "lib64/",
-                "parts/",
-                "sdist/",
-                "var/",
-                "wheels/",
-                "pip-wheel-metadata/",
-                "share/python-wheels/",
-                "*.egg-info/",
-                ".installed.cfg",
-                "*.egg",
-                "MANIFEST",
-                ".mypy_cache/",
-                ".pytest_cache/",
-                ".ruff_cache/",
-                ".tox/",
-                ".coverage",
-                ".coverage.*",
-                "htmlcov/",
-                ".hypothesis/",
-                ".ipynb_checkpoints",
-                ".pyre/",
-                ".pytype/",
-            ],
-            "Rust": [
-                "target/",
-            ],
-            "Node": [
-                "node_modules/",
-                "npm-debug.log*",
-                "yarn-debug.log*",
-                "yarn-error.log*",
-                "pnpm-debug.log*",
-                "lerna-debug.log*",
-                "dist/",
-                "coverage/",
-                ".turbo/",
-                ".next/",
-                ".nuxt/",
-                "out/",
-            ],
-            "Go": [
-                "bin/",
-                "vendor/",
-                "coverage.out",
-            ],
-            "Java": [
-                "target/",
-                "*.class",
-                ".gradle/",
-                "build/",
-                "out/",
-            ],
-            "C/C++": [
-                "build/",
-                "cmake-build-*/",
-                "*.o",
-                "*.a",
-                "*.so",
-                "*.obj",
-                "*.dll",
-                "*.dylib",
-                "*.exe",
-                "*.pdb",
-            ],
-            ".NET": [
-                "bin/",
-                "obj/",
-            ],
-        }
-
-        existing_content = ""
-        if os.path.exists(gitignore_path):
-            with open(gitignore_path, "r", encoding="utf-8", errors="replace") as f:
-                existing_content = f.read()
-
-        # 已存在的忽略项（去除注释与空行）
-        existing_set = set(
-            ln.strip()
-            for ln in existing_content.splitlines()
-            if ln.strip() and not ln.strip().startswith("#")
-        )
-
-        # 计算缺失项并准备追加内容
-        new_lines: List[str] = []
-        for name, patterns in sections.items():
-            missing = [p for p in patterns if p not in existing_set]
-            if missing:
-                new_lines.append(f"# {name}")
-                new_lines.extend(missing)
-                new_lines.append("")  # 分组空行
-
-        if not os.path.exists(gitignore_path):
-            # 新建 .gitignore（仅包含缺失项；此处即为全部常用规则）
-            with open(gitignore_path, "w", encoding="utf-8", newline="\n") as f:
-                content_to_write = "\n".join(new_lines).rstrip()
-                if content_to_write:
-                    f.write(content_to_write + "\n")
-            print("✅ 已创建 .gitignore 并添加常用忽略规则")
-        else:
-            if new_lines:
-                # 追加缺失的规则
-                with open(gitignore_path, "a", encoding="utf-8", newline="\n") as f:
-                    # 若原文件不以换行结尾，先补一行
-                    if existing_content and not existing_content.endswith("\n"):
-                        f.write("\n")
-                    f.write("\n".join(new_lines).rstrip() + "\n")
-                print("✅ 已更新 .gitignore，追加常用忽略规则")
-
-    def _handle_git_changes(self, prefix: str, suffix: str) -> None:
-        """处理git仓库中的未提交修改"""
-
-        if has_uncommitted_changes():
-
-            git_commiter = GitCommitTool()
-            git_commiter.execute({"prefix": prefix, "suffix": suffix, "agent": self, "model_group": getattr(self.model, "model_group", None)})
-
-    def _init_env(self, prefix: str, suffix: str) -> None:
-        """初始化环境，组合以下功能：
-        1. 查找git根目录
-        2. 检查并更新.gitignore文件
-        3. 处理未提交的修改
-        4. 配置git对换行符变化不敏感
-        """
-
-        git_dir = self._find_git_root()
-        self._update_gitignore(git_dir)
-        self._handle_git_changes(prefix, suffix)
-        # 配置git对换行符变化不敏感
-        self._configure_line_ending_settings()
-
-    def _configure_line_ending_settings(self) -> None:
-        """配置git对换行符变化不敏感，只在当前设置与目标设置不一致时修改"""
-        target_settings = {
-            "core.autocrlf": "false",
-            "core.safecrlf": "false",
-            "core.whitespace": "cr-at-eol",  # 忽略行尾的CR
-        }
-
-        # 获取当前设置并检查是否需要修改
-        need_change = False
-        current_settings = {}
-        for key, target_value in target_settings.items():
-            result = subprocess.run(
-                ["git", "config", "--get", key],
-                capture_output=True,
-                text=True,
-                check=False,
-            )
-            current_value = result.stdout.strip()
-            current_settings[key] = current_value
-            if current_value != target_value:
-                need_change = True
-
-        if not need_change:
-
-            return
-
-        print("⚠️ 正在修改git换行符敏感设置，这会影响所有文件的换行符处理方式")
-        # 避免在循环中逐条打印，先拼接后统一打印
-        lines = ["将进行以下设置："]
-        for key, value in target_settings.items():
-            current = current_settings.get(key, "未设置")
-            lines.append(f"{key}: {current} -> {value}")
-        joined_lines = '\n'.join(lines)
-        print(f"ℹ️ {joined_lines}")
-
-        # 直接执行设置，不需要用户确认
-        for key, value in target_settings.items():
-            subprocess.run(["git", "config", key, value], check=True)
-
-        # 对于Windows系统，提示用户可以创建.gitattributes文件
-        if sys.platform.startswith("win"):
-            self._handle_windows_line_endings()
-
-        print("✅ git换行符敏感设置已更新")
-
-    def _handle_windows_line_endings(self) -> None:
-        """在Windows系统上处理换行符问题，提供建议而非强制修改"""
-        gitattributes_path = os.path.join(self.root_dir, ".gitattributes")
-
-        # 检查是否已存在.gitattributes文件
-        if os.path.exists(gitattributes_path):
-            with open(gitattributes_path, "r", encoding="utf-8") as f:
-                content = f.read()
-            # 如果已经有换行符相关配置，就不再提示
-            if any(keyword in content for keyword in ["text=", "eol=", "binary"]):
-                return
-
-        print("ℹ️ 提示：在Windows系统上，建议配置 .gitattributes 文件来避免换行符问题。")
-        print("ℹ️ 这可以防止仅因换行符不同而导致整个文件被标记为修改。")
-
-        if user_confirm("是否要创建一个最小化的.gitattributes文件？", False):
-            # 最小化的内容，只影响特定类型的文件
-            minimal_content = """# Jarvis建议的最小化换行符配置
-# 默认所有文本文件使用LF，只有Windows特定文件使用CRLF
-
-# 默认所有文本文件使用LF
-* text=auto eol=lf
-
-# Windows批处理文件需要CRLF
-*.bat text eol=crlf
-*.cmd text eol=crlf
-*.ps1 text eol=crlf
-"""
-
-            if not os.path.exists(gitattributes_path):
-                with open(gitattributes_path, "w", encoding="utf-8", newline="\n") as f:
-                    f.write(minimal_content)
-                print("✅ 已创建最小化的 .gitattributes 文件")
-            else:
-                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)
-                    print("✅ 已更新 .gitattributes 文件")
-        else:
-            print("ℹ️ 跳过 .gitattributes 文件创建。如遇换行符问题，可手动创建此文件。")
-
-    def _record_code_changes_stats(self, diff_text: str) -> None:
-        """记录代码变更的统计信息。
-
-        Args:
-            diff_text: git diff的文本输出
-        """
-        from jarvis.jarvis_stats.stats import StatsManager
-        import re
-
-        # 匹配插入行数
-        insertions_match = re.search(r"(\d+)\s+insertions?\(\+\)", diff_text)
-        if insertions_match:
-            insertions = int(insertions_match.group(1))
-            StatsManager.increment(
-                "code_lines_inserted", amount=insertions, group="code_agent"
-            )
-
-        # 匹配删除行数
-        deletions_match = re.search(r"(\d+)\s+deletions?\(\-\)", diff_text)
-        if deletions_match:
-            deletions = int(deletions_match.group(1))
-            StatsManager.increment(
-                "code_lines_deleted", amount=deletions, group="code_agent"
-            )
-
-    def _handle_uncommitted_changes(self) -> None:
-        """处理未提交的修改，包括：
-        1. 提示用户确认是否提交
-        2. 如果确认，则检查新增文件数量
-        3. 如果新增文件超过20个，让用户确认是否添加
-        4. 如果用户拒绝添加大量文件，提示修改.gitignore并重新检测
-        5. 暂存并提交所有修改
-        """
-        if has_uncommitted_changes():
-            # 获取代码变更统计
-            try:
-                diff_result = subprocess.run(
-                    ["git", "diff", "HEAD", "--shortstat"],
-                    capture_output=True,
-                    text=True,
-                    encoding="utf-8",
-                    errors="replace",
-                    check=True,
-                )
-                if diff_result.returncode == 0 and diff_result.stdout:
-                    self._record_code_changes_stats(diff_result.stdout)
-            except subprocess.CalledProcessError:
-                pass
-
-            print("⚠️ 检测到未提交的修改，是否要提交？")
-            if not user_confirm("是否要提交？", True):
-                return
-
-            try:
-                confirm_add_new_files()
-
-                if not has_uncommitted_changes():
-                    return
-
-                # 获取当前分支的提交总数
-                # 兼容空仓库或无 HEAD 的场景：失败时将提交计数视为 0，继续执行提交流程
-                commit_count = 0
-                try:
-                    commit_result = subprocess.run(
-                        ["git", "rev-list", "--count", "HEAD"],
-                        capture_output=True,
-                        text=True,
-                        encoding="utf-8",
-                        errors="replace",
-                        check=False,
-                    )
-                    if commit_result.returncode == 0:
-                        out = commit_result.stdout.strip()
-                        if out.isdigit():
-                            commit_count = int(out)
-                except Exception:
-                    commit_count = 0
-
-                # 暂存所有修改
-                subprocess.run(["git", "add", "."], check=True)
-
-                # 提交变更
-                subprocess.run(
-                    ["git", "commit", "-m", f"CheckPoint #{commit_count + 1}"],
-                    check=True,
-                )
-            except subprocess.CalledProcessError as e:
-                print(f"❌ 提交失败: {str(e)}")
-
-    def _show_commit_history(
-        self, start_commit: Optional[str], end_commit: Optional[str]
-    ) -> List[Tuple[str, str]]:
-        """显示两个提交之间的提交历史
-
-        参数:
-            start_commit: 起始提交hash
-            end_commit: 结束提交hash
-
-        返回:
-            包含(commit_hash, commit_message)的元组列表
-        """
-        if start_commit and end_commit:
-            commits = get_commits_between(start_commit, end_commit)
-        else:
-            commits = []
-
-        if commits:
-            # 统计生成的commit数量
-            from jarvis.jarvis_stats.stats import StatsManager
-
-            StatsManager.increment("commits_generated", group="code_agent")
-
-            commit_messages = "检测到以下提交记录:\n" + "\n".join(
-                f"- {commit_hash[:7]}: {message}" for commit_hash, message in commits
-            )
-            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]],
-        start_commit: Optional[str],
-        prefix: str,
-        suffix: str,
-    ) -> None:
-        """处理提交确认和可能的重置"""
-        if commits and user_confirm("是否接受以上提交记录？", True):
-            # 统计接受的commit数量
-            from jarvis.jarvis_stats.stats import StatsManager
-
-            StatsManager.increment("commits_accepted", group="code_agent")
-
-            subprocess.run(
-                ["git", "reset", "--mixed", str(start_commit)],
-                stdout=subprocess.DEVNULL,
-                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)})
-
-            # 在用户接受commit后，根据配置决定是否保存记忆
-            if self.force_save_memory:
-                self.memory_manager.prompt_memory_save()
-        elif start_commit:
-            if user_confirm("是否要重置到初始提交？", True):
-                os.system(f"git reset --hard {str(start_commit)}")  # 确保转换为字符串
-                print("ℹ️ 已重置到初始提交")
 
     def run(self, user_input: str, prefix: str = "", suffix: str = "") -> Optional[str]:
-        """使用给定的用户输入运行代码代理。
+        """使用给定的用户输入运行代码代理.
 
         参数:
             user_input: 用户的需求/请求
@@ -920,10 +227,42 @@ class CodeAgent(Agent):
         返回:
             str: 描述执行结果的输出，成功时返回None
         """
-        prev_dir = os.getcwd()
         try:
-            self._init_env(prefix, suffix)
+            set_current_agent(self.name, self)
+
+            # 根据当前模式生成额外说明，供 LLM 感知执行策略
+            prev_dir = os.getcwd()
+            non_interactive_note = ""
+            if getattr(self, "non_interactive", False):
+                non_interactive_note = (
+                    "\n\n[系统说明]\n"
+                    "本次会话处于**非交互模式**：\n"
+                    "- 在 PLAN 模式中给出清晰、可执行的详细计划后，应**自动进入 EXECUTE 模式执行计划**，不要等待用户额外确认；\n"
+                    "- 在 EXECUTE 模式中，保持一步一步的小步提交和可回退策略，但不需要向用户反复询问“是否继续”；\n"
+                    "- 如遇信息严重不足，可以在 RESEARCH 模式中自行补充必要分析，而不是卡在等待用户输入。\n"
+                )
+
+            self.git_manager.init_env(prefix, suffix, self)
             start_commit = get_latest_commit_hash()
+            self.start_commit = start_commit
+
+            # 将初始 commit 信息添加到 addon_prompt（安全回退点）
+            if start_commit:
+                initial_commit_prompt = f"""
+**🔖 初始 Git Commit（安全回退点）**：
+本次任务开始时的初始 commit 是：`{start_commit}`
+
+**⚠️ 重要提示**：如果文件被破坏得很严重无法恢复，可以使用以下命令重置到这个初始 commit：
+```bash
+git reset --hard {start_commit}
+```
+这将丢弃所有未提交的更改，将工作区恢复到任务开始时的状态。请谨慎使用此命令，确保这是你真正想要的操作。
+"""
+                # 将初始 commit 信息追加到现有的 addon_prompt
+                current_addon = self.session.addon_prompt or ""
+                self.set_addon_prompt(
+                    f"{current_addon}\n{initial_commit_prompt}".strip()
+                )
 
             # 获取项目概况信息
             project_overview = get_project_overview(self.root_dir)
@@ -932,9 +271,11 @@ class CodeAgent(Agent):
             1. 每次响应仅执行一步操作，先分析再修改，避免一步多改。
             2. 充分利用工具理解用户需求和现有代码，禁止凭空假设。
             3. 如果不清楚要修改的文件，必须先分析并找出需要修改的文件，明确目标后再进行编辑。
-            4. 代码编辑任务优先使用 PATCH 操作，确保搜索文本在目标文件中有且仅有一次精确匹配，保证修改的准确性和安全性。
-            5. 如需大范围重写，才可使用 REWRITE 操作。
-            6. 如遇信息不明，优先调用工具补充分析，不要主观臆断。
+            4. 对于简单的文本替换，推荐使用 edit_file 工具进行精确修改。避免使用 sed 命令，因为sed极易出错且可能产生不可预期的结果。对于复杂代码（超过50行或涉及多文件协调），禁止直接使用sed或python脚本编辑，必须使用task_list_manager创建任务列表进行安全拆分。
+            5. 代码编辑任务优先使用 PATCH 操作，确保搜索文本在目标文件中有且仅有一次精确匹配，保证修改的准确性和安全性。
+            6. 如需大范围重写（超过200行或涉及重构），请使用 edit_file 工具配合空search参数 ""，并提前备份原始文件。
+            7. 如遇信息不明，优先调用工具补充分析，不要主观臆断。
+            8. **重要：清理临时文件**：开发过程中产生的临时文件（如测试文件、调试脚本、备份文件、临时日志等）必须在提交前清理删除，否则会被自动提交到git仓库。如果创建了临时文件用于调试或测试，完成后必须立即删除。
             """
 
             # 智能上下文推荐：根据用户输入推荐相关上下文
@@ -943,25 +284,21 @@ class CodeAgent(Agent):
                 # 在意图识别和上下文推荐期间抑制模型输出
                 was_suppressed = False
                 if self.model:
-                    was_suppressed = getattr(self.model, '_suppress_output', False)
+                    was_suppressed = getattr(self.model, "_suppress_output", False)
                     self.model.set_suppress_output(True)
                 try:
-                    print("🔍 正在进行智能上下文推荐....")
-                    
                     # 生成上下文推荐（基于关键词和项目上下文）
                     recommendation = self.context_recommender.recommend_context(
                         user_input=user_input,
                     )
-                    
+
                     # 格式化推荐结果
-                    context_recommendation_text = self.context_recommender.format_recommendation(recommendation)
-                    
-                    # 打印推荐的上下文
-                    if context_recommendation_text:
-                        print(f"ℹ️ {context_recommendation_text}")
-                except Exception as e:
+                    context_recommendation_text = (
+                        self.context_recommender.format_recommendation(recommendation)
+                    )
+                except Exception:
                     # 上下文推荐失败不应该影响主流程
-                    print(f"⚠️ 上下文推荐失败: {e}")
+                    pass
                 finally:
                     # 恢复模型输出设置
                     if self.model:
@@ -972,553 +309,147 @@ class CodeAgent(Agent):
                     project_overview
                     + "\n\n"
                     + first_tip
+                    + non_interactive_note
                     + context_recommendation_text
                     + "\n\n任务描述：\n"
                     + user_input
                 )
             else:
-                enhanced_input = first_tip + context_recommendation_text + "\n\n任务描述：\n" + user_input
+                enhanced_input = (
+                    first_tip
+                    + non_interactive_note
+                    + context_recommendation_text
+                    + "\n\n任务描述：\n"
+                    + user_input
+                )
 
             try:
                 if self.model:
                     self.model.set_suppress_output(False)
-                super().run(enhanced_input)
+                result = super().run(enhanced_input)
+                # 确保返回值是 str 或 None
+                if result is None:
+                    result_str = None
+                else:
+                    result_str = str(result)
             except RuntimeError as e:
-                print(f"⚠️ 执行失败: {str(e)}")
+                PrettyOutput.auto_print(f"⚠️ 执行失败: {str(e)}")
                 return str(e)
 
+            # 处理未提交的更改（在 review 之前先提交）
+            self.git_manager.handle_uncommitted_changes()
+
+            # 如果启用了 review，执行 review 和修复循环
+            if not self.disable_review:
+                self._review_and_fix(
+                    user_input=user_input,
+                    enhanced_input=enhanced_input,
+                    prefix=prefix,
+                    suffix=suffix,
+                    code_generation_summary=result_str,
+                )
 
-
-            self._handle_uncommitted_changes()
             end_commit = get_latest_commit_hash()
-            commits = self._show_commit_history(start_commit, end_commit)
-            self._handle_commit_confirmation(commits, start_commit, prefix, suffix)
-            return None
+            commits = self.git_manager.show_commit_history(
+                self.start_commit, end_commit
+            )
+            self.git_manager.handle_commit_confirmation(
+                commits,
+                self.start_commit,
+                prefix,
+                suffix,
+                self,
+                self.post_process_manager.post_process_modified_files,
+            )
+            return result_str
 
         except RuntimeError as e:
             return f"Error during execution: {str(e)}"
         finally:
+            # 在run方法结束时反注册agent
+            clear_current_agent()
+
             # Ensure switching back to the original working directory after CodeAgent completes
             try:
                 os.chdir(prev_dir)
             except Exception:
                 pass
 
-    def _build_name_status_map(self) -> dict:
-        """构造按文件的状态映射与差异文本，删除文件不展示diff，仅提示删除"""
-        status_map = {}
-        try:
-            head_exists = bool(get_latest_commit_hash())
-            # 临时 -N 以包含未跟踪文件的差异检测
-            subprocess.run(["git", "add", "-N", "."], check=False, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
-            cmd = ["git", "diff", "--name-status"] + (["HEAD"] if head_exists else [])
-            res = subprocess.run(
-                cmd,
-                capture_output=True,
-                text=True,
-                encoding="utf-8",
-                errors="replace",
-                check=False,
-            )
-        finally:
-            subprocess.run(["git", "reset"], check=False, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
-
-        if res.returncode == 0 and res.stdout:
-            for line in res.stdout.splitlines():
-                if not line.strip():
-                    continue
-                parts = line.split("\t")
-                if not parts:
-                    continue
-                status = parts[0]
-                if status.startswith("R") or status.startswith("C"):
-                    # 重命名/复制：使用新路径作为键
-                    if len(parts) >= 3:
-                        old_path, new_path = parts[1], parts[2]
-                        status_map[new_path] = status
-                        # 也记录旧路径，便于匹配 name-only 的结果
-                        status_map[old_path] = status
-                    elif len(parts) >= 2:
-                        status_map[parts[-1]] = status
-                else:
-                    if len(parts) >= 2:
-                        status_map[parts[1]] = status
-        return status_map
+    def _on_after_tool_call(
+        self,
+        agent: Agent,
+        current_response: Optional[str] = None,
+        need_return: Optional[bool] = None,
+        tool_prompt: Optional[str] = None,
+        **kwargs: Any,
+    ) -> None:
+        """工具调用后回调函数。"""
 
-    def _get_file_diff(self, file_path: str) -> str:
-        """获取单文件的diff，包含新增文件内容；失败时返回空字符串"""
-        head_exists = bool(get_latest_commit_hash())
-        try:
-            # 为了让未跟踪文件也能展示diff，临时 -N 该文件
-            subprocess.run(["git", "add", "-N", "--", file_path], check=False, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
-            cmd = ["git", "diff"] + (["HEAD"] if head_exists else []) + ["--", file_path]
-            res = subprocess.run(
-                cmd,
-                capture_output=True,
-                text=True,
-                encoding="utf-8",
-                errors="replace",
-                check=False,
-            )
-            if res.returncode == 0:
-                return res.stdout or ""
-            return ""
-        finally:
-            subprocess.run(["git", "reset", "--", file_path], check=False, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+        final_ret = ""
+        diff = get_diff()
 
-    def _build_per_file_patch_preview(self, modified_files: List[str]) -> str:
-        """构建按文件的补丁预览"""
-        status_map = self._build_name_status_map()
-        lines: List[str] = []
+        if diff:
+            start_hash = get_latest_commit_hash()
+            modified_files = get_diff_file_list()
 
-        def _get_file_numstat(file_path: str) -> Tuple[int, int]:
-            """获取单文件的新增/删除行数，失败时返回(0,0)"""
-            head_exists = bool(get_latest_commit_hash())
+            # 使用增强的 diff 可视化（如果可用）
             try:
-                # 让未跟踪文件也能统计到新增行数
-                subprocess.run(["git", "add", "-N", "--", file_path], check=False, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
-                cmd = ["git", "diff", "--numstat"] + (["HEAD"] if head_exists else []) + ["--", file_path]
-                res = subprocess.run(
-                    cmd,
-                    capture_output=True,
-                    text=True,
-                    encoding="utf-8",
-                    errors="replace",
-                    check=False,
+                from jarvis.jarvis_code_agent.diff_visualizer import (
+                    visualize_diff_enhanced,
                 )
-                if res.returncode == 0 and res.stdout:
-                    for line in res.stdout.splitlines():
-                        parts = line.strip().split("\t")
-                        if len(parts) >= 3:
-                            add_s, del_s = parts[0], parts[1]
-
-                            def to_int(x: str) -> int:
-                                try:
-                                    return int(x)
-                                except Exception:
-                                    # 二进制或无法解析时显示为0
-                                    return 0
-
-                            return to_int(add_s), to_int(del_s)
-            finally:
-                subprocess.run(["git", "reset", "--", file_path], check=False, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
-            return (0, 0)
-
-        for f in modified_files:
-            status = status_map.get(f, "")
-            adds, dels = _get_file_numstat(f)
-            total_changes = adds + dels
-
-            # 删除文件：不展示diff，仅提示（附带删除行数信息如果可用）
-            if (status.startswith("D")) or (not os.path.exists(f)):
-                if dels > 0:
-                    lines.append(f"- {f} 文件被删除（删除{dels}行）")
-                else:
-                    lines.append(f"- {f} 文件被删除")
-                continue
-
-            # 变更过大：仅提示新增/删除行数，避免输出超长diff
-            if total_changes > 300:
-                lines.append(f"- {f} 新增{adds}行/删除{dels}行（变更过大，预览已省略）")
-                continue
+                from jarvis.jarvis_utils.config import get_diff_show_line_numbers
+                from jarvis.jarvis_utils.config import get_diff_visualization_mode
+
+                # 显示整体 diff（使用增强可视化）
+                visualization_mode = get_diff_visualization_mode()
+                show_line_numbers = get_diff_show_line_numbers()
+                # 构建文件路径显示（多文件时显示所有文件名）
+                file_path_display = ", ".join(modified_files) if modified_files else ""
+                visualize_diff_enhanced(
+                    diff,
+                    file_path=file_path_display,
+                    mode=visualization_mode,
+                    show_line_numbers=show_line_numbers,
+                )
+            except ImportError:
+                # 如果导入失败，回退到原有方式
+                PrettyOutput.print(diff, OutputType.CODE, lang="diff")
+            except Exception as e:
+                # 如果可视化失败，回退到原有方式
+                PrettyOutput.auto_print(f"⚠️ Diff 可视化失败，使用默认方式: {e}")
+                PrettyOutput.print(diff, OutputType.CODE, lang="diff")
 
-            # 其它情况：展示该文件的diff
-            file_diff = self._get_file_diff(f)
-            if file_diff.strip():
-                lines.append(f"文件: {f}\n```diff\n{file_diff}\n```")
-            else:
-                # 当无法获取到diff（例如重命名或特殊状态），避免空输出
-                lines.append(f"- {f} 变更已记录（无可展示的文本差异）")
-        return "\n".join(lines)
+            # 更新上下文管理器
+            self.impact_manager.update_context_for_modified_files(modified_files)
 
-    def _update_context_for_modified_files(self, modified_files: List[str]) -> None:
-        """更新上下文管理器：当文件被修改后，更新符号表和依赖图"""
-        if not modified_files:
-            return
-        print("🔄 正在更新代码上下文...")
-        for file_path in modified_files:
-            if os.path.exists(file_path):
-                try:
-                    with open(file_path, 'r', encoding='utf-8', errors='replace') as f:
-                        content = f.read()
-                    self.context_manager.update_context_for_file(file_path, content)
-                except Exception:
-                    # 如果读取文件失败，跳过更新
-                    pass
+            # 进行影响范围分析
+            impact_report = self.impact_manager.analyze_edit_impact(modified_files)
 
-    def _analyze_edit_impact(self, modified_files: List[str]) -> Optional[Any]:
-        """进行影响范围分析（如果启用）
-        
-        Returns:
-            ImpactReport: 影响分析报告，如果未启用或失败则返回None
-        """
-        if not is_enable_impact_analysis():
-            return None
-        
-        print("🔍 正在进行变更影响分析...")
-        try:
-            impact_analyzer = ImpactAnalyzer(self.context_manager)
-            all_edits = []
-            for file_path in modified_files:
-                if os.path.exists(file_path):
-                    edits = parse_git_diff_to_edits(file_path, self.root_dir)
-                    all_edits.extend(edits)
-            
-            if not all_edits:
-                return None
-            
-            # 按文件分组编辑
-            edits_by_file = {}
-            for edit in all_edits:
-                if edit.file_path not in edits_by_file:
-                    edits_by_file[edit.file_path] = []
-                edits_by_file[edit.file_path].append(edit)
-            
-            # 对每个文件进行影响分析
-            impact_report = None
-            for file_path, edits in edits_by_file.items():
-                report = impact_analyzer.analyze_edit_impact(file_path, edits)
-                if report:
-                    # 合并报告
-                    if impact_report is None:
-                        impact_report = report
-                    else:
-                        # 合并多个报告，去重
-                        impact_report.affected_files = list(set(impact_report.affected_files + report.affected_files))
-                        
-                        # 合并符号（基于文件路径和名称去重）
-                        symbol_map = {}
-                        for symbol in impact_report.affected_symbols + report.affected_symbols:
-                            key = (symbol.file_path, symbol.name, symbol.line_start)
-                            if key not in symbol_map:
-                                symbol_map[key] = symbol
-                        impact_report.affected_symbols = list(symbol_map.values())
-                        
-                        impact_report.affected_tests = list(set(impact_report.affected_tests + report.affected_tests))
-                        
-                        # 合并接口变更（基于符号名和文件路径去重）
-                        interface_map = {}
-                        for change in impact_report.interface_changes + report.interface_changes:
-                            key = (change.file_path, change.symbol_name, change.change_type)
-                            if key not in interface_map:
-                                interface_map[key] = change
-                        impact_report.interface_changes = list(interface_map.values())
-                        
-                        impact_report.impacts.extend(report.impacts)
-                        
-                        # 合并建议
-                        impact_report.recommendations = list(set(impact_report.recommendations + report.recommendations))
-                        
-                        # 使用更高的风险等级
-                        if report.risk_level.value == 'high' or impact_report.risk_level.value == 'high':
-                            impact_report.risk_level = report.risk_level if report.risk_level.value == 'high' else impact_report.risk_level
-                        elif report.risk_level.value == 'medium':
-                            impact_report.risk_level = report.risk_level
-            
-            return impact_report
-        except Exception as e:
-            # 影响分析失败不应该影响主流程，仅记录日志
-            print(f"⚠️ 影响范围分析失败: {e}")
-            return None
-
-    def _handle_impact_report(self, impact_report: Optional[Any], agent: Agent, final_ret: str) -> str:
-        """处理影响范围分析报告
-        
-        Args:
-            impact_report: 影响分析报告
-            agent: Agent实例
-            final_ret: 当前的结果字符串
-            
-        Returns:
-            更新后的结果字符串
-        """
-        if not impact_report:
-            return final_ret
-        
-        impact_summary = impact_report.to_string(self.root_dir)
-        final_ret += f"\n\n{impact_summary}\n"
-        
-        # 如果是高风险，在提示词中提醒
-        if impact_report.risk_level.value == 'high':
-            agent.set_addon_prompt(
-                f"{agent.get_addon_prompt() or ''}\n\n"
-                f"⚠️ 高风险编辑警告：\n"
-                f"检测到此编辑为高风险操作，请仔细检查以下内容：\n"
-                f"- 受影响文件: {len(impact_report.affected_files)} 个\n"
-                f"- 接口变更: {len(impact_report.interface_changes)} 个\n"
-                f"- 相关测试: {len(impact_report.affected_tests)} 个\n"
-                f"建议运行相关测试并检查所有受影响文件。"
-            )
-        
-        return final_ret
-
-    def _handle_build_validation_disabled(self, modified_files: List[str], config: Any, agent: Agent, final_ret: str) -> str:
-        """处理构建验证已禁用的情况
-        
-        Returns:
-            更新后的结果字符串
-        """
-        reason = config.get_disable_reason()
-        reason_text = f"（原因: {reason}）" if reason else ""
-        final_ret += f"\n\nℹ️ 构建验证已禁用{reason_text}，仅进行基础静态检查\n"
-        
-        # 输出基础静态检查日志
-        file_count = len(modified_files)
-        files_str = ", ".join(os.path.basename(f) for f in modified_files[:3])
-        if file_count > 3:
-            files_str += f" 等{file_count}个文件"
-        
-        # 使用兜底验证器进行基础静态检查
-        fallback_validator = FallbackBuildValidator(self.root_dir, timeout=get_build_validation_timeout())
-        static_check_result = fallback_validator.validate(modified_files)
-        if not static_check_result.success:
-            final_ret += f"\n⚠️ 基础静态检查失败:\n{static_check_result.error_message or static_check_result.output}\n"
-            agent.set_addon_prompt(
-                f"基础静态检查失败，请根据以下错误信息修复代码:\n{static_check_result.error_message or static_check_result.output}\n"
-            )
-        else:
-            final_ret += f"\n✅ 基础静态检查通过（耗时 {static_check_result.duration:.2f}秒）\n"
-        
-        return final_ret
-
-    def _handle_build_validation_failure(self, build_validation_result: Any, config: Any, modified_files: List[str], agent: Agent, final_ret: str) -> str:
-        """处理构建验证失败的情况
-        
-        Returns:
-            更新后的结果字符串
-        """
-        if not config.has_been_asked():
-            # 首次失败，询问用户
-            error_preview = _format_build_error(build_validation_result)
-            print(f"\n⚠️ 构建验证失败:\n{error_preview}\n")
-            print("ℹ️ 提示：如果此项目需要在特殊环境（如容器）中构建，或使用独立构建脚本，"
-                "可以选择禁用构建验证，后续将仅进行基础静态检查。")
-            
-            if user_confirm(
-                "是否要禁用构建验证，后续仅进行基础静态检查？",
-                default=False,
-            ):
-                # 用户选择禁用
-                config.disable_build_validation(
-                    reason="用户选择禁用（项目可能需要在特殊环境中构建）"
-                )
-                config.mark_as_asked()
-                final_ret += "\n\nℹ️ 已禁用构建验证，后续将仅进行基础静态检查\n"
-                
-                # 输出基础静态检查日志
-                file_count = len(modified_files)
-                files_str = ", ".join(os.path.basename(f) for f in modified_files[:3])
-                if file_count > 3:
-                    files_str += f" 等{file_count}个文件"
-                
-                # 立即进行基础静态检查
-                fallback_validator = FallbackBuildValidator(self.root_dir, timeout=get_build_validation_timeout())
-                static_check_result = fallback_validator.validate(modified_files)
-                if not static_check_result.success:
-                    final_ret += f"\n⚠️ 基础静态检查失败:\n{static_check_result.error_message or static_check_result.output}\n"
-                    agent.set_addon_prompt(
-                        f"基础静态检查失败，请根据以下错误信息修复代码:\n{static_check_result.error_message or static_check_result.output}\n"
-                    )
-                else:
-                    final_ret += f"\n✅ 基础静态检查通过（耗时 {static_check_result.duration:.2f}秒）\n"
-            else:
-                # 用户选择继续验证，标记为已询问
-                config.mark_as_asked()
-                final_ret += f"\n\n⚠️ 构建验证失败:\n{_format_build_error(build_validation_result)}\n"
-                # 如果构建失败，添加修复提示
-                agent.set_addon_prompt(
-                    f"构建验证失败，请根据以下错误信息修复代码:\n{_format_build_error(build_validation_result)}\n"
-                    "请仔细检查错误信息，修复编译/构建错误后重新提交。"
-                )
-        else:
-            # 已经询问过，直接显示错误
-            final_ret += f"\n\n⚠️ 构建验证失败:\n{_format_build_error(build_validation_result)}\n"
-            # 如果构建失败，添加修复提示
-            agent.set_addon_prompt(
-                f"构建验证失败，请根据以下错误信息修复代码:\n{_format_build_error(build_validation_result)}\n"
-                "请仔细检查错误信息，修复编译/构建错误后重新提交。"
+            per_file_preview = self.diff_manager.build_per_file_patch_preview(
+                modified_files, use_enhanced_visualization=False
             )
-        
-        return final_ret
-
-    def _handle_build_validation(self, modified_files: List[str], agent: Agent, final_ret: str) -> Tuple[Optional[Any], str]:
-        """处理构建验证
-        
-        Returns:
-            (build_validation_result, updated_final_ret)
-        """
-        if not is_enable_build_validation():
-            return None, final_ret
-        
-        config = BuildValidationConfig(self.root_dir)
-        
-        # 检查是否已禁用构建验证
-        if config.is_build_validation_disabled():
-            final_ret = self._handle_build_validation_disabled(modified_files, config, agent, final_ret)
-            return None, final_ret
-        
-        # 未禁用，进行构建验证
-        build_validation_result = self._validate_build_after_edit(modified_files)
-        if build_validation_result:
-            if not build_validation_result.success:
-                final_ret = self._handle_build_validation_failure(
-                    build_validation_result, config, modified_files, agent, final_ret
-                )
-            else:
-                build_system_info = f" ({build_validation_result.build_system.value})" if build_validation_result.build_system else ""
-                final_ret += f"\n\n✅ 构建验证通过{build_system_info}（耗时 {build_validation_result.duration:.2f}秒）\n"
-        
-        return build_validation_result, final_ret
-
-    def _handle_static_analysis(self, modified_files: List[str], build_validation_result: Optional[Any], config: Any, agent: Agent, final_ret: str) -> str:
-        """处理静态分析
-        
-        Returns:
-            更新后的结果字符串
-        """
-        # 检查是否启用静态分析
-        if not is_enable_static_analysis():
-            print("ℹ️ 静态分析已禁用，跳过静态检查")
-            return final_ret
-        
-        # 检查是否有可用的lint工具
-        lint_tools_info = "\n".join(
-            f"   - {file}: 使用 {'、'.join(get_lint_tools(file))}"
-            for file in modified_files
-            if get_lint_tools(file)
-        )
-        
-        if not lint_tools_info:
-            print("ℹ️ 未找到可用的静态检查工具，跳过静态检查")
-            return final_ret
-        
-        # 如果构建验证失败且未禁用，不进行静态分析（避免重复错误）
-        # 如果构建验证已禁用，则进行静态分析（因为只做了基础静态检查）
-        should_skip_static = (
-            build_validation_result 
-            and not build_validation_result.success 
-            and not config.is_build_validation_disabled()
-        )
-        
-        if should_skip_static:
-            print("ℹ️ 构建验证失败，跳过静态分析（避免重复错误）")
-            return final_ret
-        
-        # 直接执行静态扫描
-        lint_results = self._run_static_analysis(modified_files)
-        if lint_results:
-            # 有错误或警告，让大模型修复
-            errors_summary = self._format_lint_results(lint_results)
-            # 打印完整的检查结果
-            print(f"⚠️ 静态扫描发现问题:\n{errors_summary}")
-            addon_prompt = f"""
-静态扫描发现以下问题，请根据错误信息修复代码:
-
-{errors_summary}
-
-请仔细检查并修复所有问题。
-            """
-            agent.set_addon_prompt(addon_prompt)
-            final_ret += "\n\n⚠️ 静态扫描发现问题，已提示修复\n"
-        else:
-            final_ret += "\n\n✅ 静态扫描通过\n"
-        
-        return final_ret
 
-    def _ask_llm_about_large_deletion(self, detection_result: Dict[str, int], preview: str) -> bool:
-        """询问大模型大量代码删除是否合理
-        
-        参数:
-            detection_result: 检测结果字典，包含 'insertions', 'deletions', 'net_deletions'
-            preview: 补丁预览内容
-            
-        返回:
-            bool: 如果大模型认为合理返回True，否则返回False
-        """
-        if not self.model:
-            # 如果没有模型，默认认为合理
-            return True
-        
-        insertions = detection_result['insertions']
-        deletions = detection_result['deletions']
-        net_deletions = detection_result['net_deletions']
-        
-        prompt = f"""检测到大量代码删除，请判断是否合理：
-
-统计信息：
-- 新增行数: {insertions}
-- 删除行数: {deletions}
-- 净删除行数: {net_deletions}
-
-补丁预览：
-{preview}
-
-请仔细分析以上代码变更，判断这些大量代码删除是否合理。可能的情况包括：
-1. 重构代码，删除冗余或过时的代码
-2. 简化实现，用更简洁的代码替换复杂的实现
-3. 删除未使用的代码或功能
-4. 错误地删除了重要代码
-
-请使用以下协议回答（必须包含且仅包含以下标记之一）：
-- 如果认为这些删除是合理的，回答: <!!!YES!!!>
-- 如果认为这些删除不合理或存在风险，回答: <!!!NO!!!>
-
-请严格按照协议格式回答，不要添加其他内容。
-"""
-        
-        try:
-            print("🤖 正在询问大模型判断大量代码删除是否合理...")
-            response = self.model.chat_until_success(prompt)  # type: ignore
-            
-            # 使用确定的协议标记解析回答
-            if "<!!!YES!!!>" in response:
-                print("✅ 大模型确认：代码删除合理")
-                return True
-            elif "<!!!NO!!!>" in response:
-                print("⚠️ 大模型确认：代码删除不合理")
-                return False
-            else:
-                # 如果无法找到协议标记，默认认为不合理（保守策略）
-                print(f"⚠️ 无法找到协议标记，默认认为不合理。回答内容: {response[:200]}")
-                return False
-        except Exception as e:
-            # 如果询问失败，默认认为不合理（保守策略）
-            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:
-        """工具调用后回调函数。"""
-        final_ret = ""
-        diff = get_diff()
-
-        if diff:
-            start_hash = get_latest_commit_hash()
-            PrettyOutput.print(diff, OutputType.CODE, lang="diff")  # 保留语法高亮
-            modified_files = get_diff_file_list()
-            
-            # 更新上下文管理器
-            self._update_context_for_modified_files(modified_files)
-            
-            # 进行影响范围分析
-            impact_report = self._analyze_edit_impact(modified_files)
-            
-            per_file_preview = self._build_per_file_patch_preview(modified_files)
-            
             # 所有模式下，在提交前检测大量代码删除并询问大模型
             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)
+                is_reasonable = self.llm_manager.ask_llm_about_large_deletion(
+                    detection_result, per_file_preview
+                )
                 if not is_reasonable:
                     # 大模型认为不合理，撤销修改
-                    print("ℹ️ 已撤销修改（大模型认为代码删除不合理）")
+                    PrettyOutput.auto_print("ℹ️ 已撤销修改（大模型认为代码删除不合理）")
                     revert_change()
-                    final_ret += "\n\n修改被撤销（检测到大量代码删除且大模型判断不合理）\n"
+                    final_ret += (
+                        "\n\n修改被撤销（检测到大量代码删除且大模型判断不合理）\n"
+                    )
                     final_ret += f"# 补丁预览（按文件）:\n{per_file_preview}"
-                    PrettyOutput.print(final_ret, OutputType.USER, lang="markdown")  # 保留语法高亮
+                    PrettyOutput.print(
+                        final_ret, OutputType.USER, lang="markdown"
+                    )  # 保留语法高亮
                     self.session.prompt += final_ret
                     return
-            
+
             commited = handle_commit_workflow()
             if commited:
                 # 统计代码行数变化
@@ -1533,7 +464,7 @@ class CodeAgent(Agent):
                         check=True,
                     )
                     if diff_result.returncode == 0 and diff_result.stdout:
-                        self._record_code_changes_stats(diff_result.stdout)
+                        self.git_manager.record_code_changes_stats(diff_result.stdout)
                 except subprocess.CalledProcessError:
                     pass
 
@@ -1550,8 +481,12 @@ class CodeAgent(Agent):
                 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
-                    
+                    commit_short_hash = (
+                        latest_commit_hash[:7]
+                        if len(latest_commit_hash) >= 7
+                        else latest_commit_hash
+                    )
+
                     final_ret += (
                         f"\n\n代码已修改完成\n"
                         f"✅ 已自动提交\n"
@@ -1559,16 +494,25 @@ class CodeAgent(Agent):
                         f"   提交信息: {latest_commit_message}\n"
                         f"\n补丁内容（按文件）:\n{per_file_preview}\n"
                     )
-                    
+
                     # 添加影响范围分析报告
-                    final_ret = self._handle_impact_report(impact_report, self, final_ret)
-                    
+                    final_ret = self.impact_manager.handle_impact_report(
+                        impact_report, self, final_ret
+                    )
+
                     # 构建验证
                     config = BuildValidationConfig(self.root_dir)
-                    build_validation_result, final_ret = self._handle_build_validation(modified_files, self, final_ret)
-                    
+                    (
+                        build_validation_result,
+                        final_ret,
+                    ) = self.build_validation_manager.handle_build_validation(
+                        modified_files, self, final_ret
+                    )
+
                     # 静态分析
-                    final_ret = self._handle_static_analysis(modified_files, build_validation_result, config, self, final_ret)
+                    final_ret = self.lint_manager.handle_static_analysis(
+                        modified_files, build_validation_result, config, self, final_ret
+                    )
                 else:
                     # 如果没有获取到commits，尝试直接从end_hash获取commit信息
                     commit_info = ""
@@ -1582,9 +526,20 @@ class CodeAgent(Agent):
                                 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
+                            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"
@@ -1592,7 +547,7 @@ class CodeAgent(Agent):
                                 )
                         except Exception:
                             pass
-                    
+
                     if commit_info:
                         final_ret += f"\n\n代码已修改完成{commit_info}\n"
                     else:
@@ -1619,186 +574,487 @@ class CodeAgent(Agent):
         self.session.prompt += final_ret
         return
 
-    def _run_static_analysis(self, modified_files: List[str]) -> List[Tuple[str, str, str, int, str]]:
-        """执行静态分析
-        
-        Args:
-            modified_files: 修改的文件列表
-        
-        Returns:
-            [(tool_name, file_path, command, returncode, output), ...] 格式的结果列表
-            只返回有错误或警告的结果（returncode != 0）
+    def _truncate_diff_for_review(self, git_diff: str, token_ratio: float = 0.4) -> str:
+        """截断 git diff 以适应 token 限制（用于 review）
+
+        参数:
+            git_diff: 原始的 git diff 内容
+            token_ratio: token 使用比例（默认 0.4，即 40%，review 需要更多上下文）
+
+        返回:
+            str: 截断后的 git diff（如果超出限制则截断并添加提示、文件列表和起始 commit）
         """
-        if not modified_files:
-            return []
-        
-        # 获取所有lint命令
-        commands = get_lint_commands_for_files(modified_files, self.root_dir)
-        if not commands:
-            return []
-        
-        # 输出静态检查日志
-        file_count = len(modified_files)
-        files_str = ", ".join(os.path.basename(f) for f in modified_files[:3])
-        if file_count > 3:
-            files_str += f" 等{file_count}个文件"
-        tool_names = list(set(cmd[0] for cmd in commands))
-        tools_str = ", ".join(tool_names[:3])
-        if len(tool_names) > 3:
-            tools_str += f" 等{len(tool_names)}个工具"
-        print("🔍 静态检查中...")
-        
-        results = []
-        # 记录每个文件的检查结果
-        file_results = []  # [(file_path, tool_name, status, message), ...]
-        
-        # 按工具分组，相同工具可以批量执行
-        grouped = group_commands_by_tool(commands)
-        
-        for tool_name, file_commands in grouped.items():
-            for file_path, command in file_commands:
-                file_name = os.path.basename(file_path)
-                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):
-                        file_results.append((file_name, tool_name, "跳过", "文件不存在"))
-                        continue
-                    
-                    # 打印执行的命令
-                    print(f"ℹ️ 执行: {command}")
-                    
-                    # 执行命令
-                    result = subprocess.run(
-                        command,
-                        shell=True,
-                        cwd=self.root_dir,
-                        capture_output=True,
-                        text=True,
-                        encoding="utf-8",
-                        errors="replace",
-                        timeout=600,  # 600秒超时
+        if not git_diff or not git_diff.strip():
+            return git_diff
+
+        from jarvis.jarvis_utils.embedding import get_context_token_count
+        from jarvis.jarvis_utils.config import get_max_input_token_count
+
+        # 获取最大输入 token 数量
+        model_group = self.model.model_group if self.model else None
+        try:
+            max_input_tokens = get_max_input_token_count(model_group)
+        except Exception:
+            # 如果获取失败，使用默认值（约 100000 tokens）
+            max_input_tokens = 100000
+
+        # 使用指定比例作为 diff 的 token 限制
+        max_diff_tokens = int(max_input_tokens * token_ratio)
+
+        # 计算 diff 的 token 数量
+        diff_token_count = get_context_token_count(git_diff)
+
+        if diff_token_count <= max_diff_tokens:
+            return git_diff
+
+        # 如果 diff 内容太大，进行截断
+        # 先提取修改的文件列表和起始 commit
+        import re
+
+        files = set()
+        # 匹配 "diff --git a/path b/path" 格式
+        pattern = r"^diff --git a/([^\s]+) b/([^\s]+)$"
+        for line in git_diff.split("\n"):
+            match = re.match(pattern, line)
+            if match:
+                file_a = match.group(1)
+                file_b = match.group(2)
+                files.add(file_b)
+                if file_a != file_b:
+                    files.add(file_a)
+        modified_files = sorted(list(files))
+
+        # 获取起始 commit id
+        start_commit = self.start_commit if hasattr(self, "start_commit") else None
+
+        lines = git_diff.split("\n")
+        truncated_lines = []
+        current_tokens = 0
+
+        for line in lines:
+            line_tokens = get_context_token_count(line)
+            if current_tokens + line_tokens > max_diff_tokens:
+                # 添加截断提示
+                truncated_lines.append("")
+                truncated_lines.append(
+                    "# ⚠️ diff内容过大，已截断显示（review 需要更多上下文）"
+                )
+                truncated_lines.append(
+                    f"# 原始diff共 {len(lines)} 行，{diff_token_count} tokens"
+                )
+                truncated_lines.append(
+                    f"# 显示前 {len(truncated_lines) - 3} 行，约 {current_tokens} tokens"
+                )
+                truncated_lines.append(
+                    f"# 限制: {max_diff_tokens} tokens (输入窗口的 {token_ratio * 100:.0f}%)"
+                )
+
+                # 添加起始 commit id
+                if start_commit:
+                    truncated_lines.append("")
+                    truncated_lines.append(f"# 起始 Commit ID: {start_commit}")
+
+                # 添加完整修改文件列表
+                if modified_files:
+                    truncated_lines.append("")
+                    truncated_lines.append(
+                        f"# 完整修改文件列表（共 {len(modified_files)} 个文件）："
                     )
-                    
-                    # 只记录有错误或警告的结果
-                    if result.returncode != 0:
-                        output = result.stdout + result.stderr
-                        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, "执行超时（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:
-                    # 其他错误，记录但继续
-                    print(f"⚠️ 执行lint命令失败: {command}, 错误: {e}")
-                    file_results.append((file_name, tool_name, "失败", f"执行失败: {str(e)[:50]}"))
-                    continue
-        
-        # 一次性打印所有检查结果
-        if file_results:
-            total_files = len(file_results)
-            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 == "超时")
-            sum(1 for _, _, status, _ in file_results if status == "跳过")
-            
-            # 收缩为一行的结果摘要
-            summary = f"🔍 静态检查: {total_files}个文件"
-            if failed_count > 0:
-                summary += f", {failed_count}失败"
-            if timeout_count > 0:
-                summary += f", {timeout_count}超时"
-            if passed_count == total_files:
-                summary += " ✅全部通过"
-            
-            if failed_count > 0 or timeout_count > 0:
-                print(f"⚠️ {summary}")
+                    for file_path in modified_files:
+                        truncated_lines.append(f"#   - {file_path}")
+
+                break
+
+            truncated_lines.append(line)
+            current_tokens += line_tokens
+
+        return "\n".join(truncated_lines)
+
+    def _build_review_prompts(
+        self,
+        user_input: str,
+        git_diff: str,
+        code_generation_summary: Optional[str] = None,
+    ) -> tuple:
+        """构建 review Agent 的 prompts
+
+        参数:
+            user_input: 用户原始需求
+            git_diff: 代码修改的 git diff（会自动进行 token 限制处理）
+
+        返回:
+            tuple: (system_prompt, user_prompt, summary_prompt)
+        """
+        system_prompt = """你是代码审查专家。你的任务是审查代码修改是否正确完成了用户需求。
+
+审查标准：
+1. 功能完整性：代码修改是否完整实现了用户需求的所有功能点？
+2. 代码正确性：修改的代码逻辑是否正确，有无明显的 bug 或错误？
+3. 代码质量：代码是否符合最佳实践，有无明显的代码异味？
+4. 潜在风险：修改是否可能引入新的问题或破坏现有功能？
+
+审查要求：
+- 仔细阅读用户需求、代码生成总结（summary）和代码修改（git diff）
+- **对代码生成总结中的关键信息进行充分验证**：不能盲目信任总结，必须结合 git diff 和实际代码逐条核对
+- 如需了解更多上下文，必须使用 read_code 工具读取相关文件以验证总结中提到的行为/位置/文件是否真实存在并符合描述
+- 基于实际代码进行审查，不要凭空假设
+- 如果代码生成总结与实际代码不一致，应以实际代码为准，并将不一致情况作为问题记录
+- 只关注本次修改相关的问题，不要审查无关代码"""
+
+        user_prompt = f"""请审查以下代码修改是否正确完成了用户需求。
+
+【用户需求】
+{user_input}
+
+【代码生成总结】
+{code_generation_summary if code_generation_summary else "无代码生成总结信息（如为空，说明主 Agent 未生成总结，请完全依赖 git diff 和实际代码进行审查）"}
+
+【代码修改（Git Diff）】
+```diff
+{git_diff}
+
+```
+
+请仔细审查代码修改，并特别注意：
+- 不要直接相信代码生成总结中的描述，而是将其视为“待核实的说明”
+- 对总结中提到的每一个关键修改点（如函数/文件/行为变化），都应在 git diff 或实际代码中找到对应依据
+- 如发现总结与实际代码不一致，必须在审查结果中指出
+
+如需要可使用 read_code 工具查看更多上下文。
+
+如果审查完毕，直接输出 {ot("!!!COMPLETE!!!")}，不要输出其他任何内容。
+"""
+
+        summary_prompt = """请输出 JSON 格式的审查结果，格式如下：
+
+```json
+{
+  "ok": true/false,  // 审查是否通过
+  "issues": [        // 发现的问题列表（如果 ok 为 true，可以为空数组）
+    {
+      "type": "问题类型",  // 如：功能缺失、逻辑错误、代码质量、潜在风险
+      "description": "问题描述",
+      "location": "问题位置（文件:行号）",
+      "suggestion": "修复建议"
+    }
+  ],
+  "summary": "审查总结"  // 简要说明审查结论
+}
+```
+
+注意：
+- 如果代码修改完全满足用户需求且无明显问题，设置 ok 为 true
+- 如果存在需要修复的问题，设置 ok 为 false，并在 issues 中列出所有问题
+- 每个问题都要提供具体的修复建议"""
+
+        return system_prompt, user_prompt, summary_prompt
+
+    def _parse_review_result(
+        self, summary: str, review_agent: Optional[Any] = None, max_retries: int = 3
+    ) -> dict:
+        """解析 review 结果
+
+        参数:
+            summary: review Agent 的输出
+            review_agent: review Agent 实例，用于格式修复
+            max_retries: 最大重试次数
+
+        返回:
+            dict: 解析后的审查结果，包含 ok 和 issues 字段
+        """
+        import json
+        import re
+
+        def _try_parse_json(content: str) -> tuple[bool, dict | None, str | None]:
+            """尝试解析JSON，返回(成功, 结果, json字符串)"""
+            # 尝试从输出中提取 JSON
+            # 首先尝试匹配 ```json ... ``` 代码块
+            json_match = re.search(r"```json\s*([\s\S]*?)\s*```", content)
+            if json_match:
+                json_str = json_match.group(1).strip()
             else:
-                print(f"✅ {summary}")
-        else:
-            print("✅ 静态检查完成")
-        
-        return results
-    
-    def _format_lint_results(self, results: List[Tuple[str, str, str, int, str]]) -> str:
-        """格式化lint结果
-        
-        Args:
-            results: [(tool_name, file_path, command, returncode, output), ...]
-        
-        Returns:
-            格式化的错误信息字符串
+                # 尝试匹配裸 JSON 对象
+                json_match = re.search(r'\{[\s\S]*"ok"[\s\S]*\}', content)
+                if json_match:
+                    json_str = json_match.group(0)
+                else:
+                    return False, None, None
+
+            try:
+                result = json.loads(json_str)
+                if isinstance(result, dict):
+                    return True, result, json_str
+                else:
+                    return False, None, json_str
+            except json.JSONDecodeError:
+                return False, None, json_str
+
+        # 第一次尝试解析
+        success, result, json_str = _try_parse_json(summary)
+        if success and result is not None:
+            return {
+                "ok": result.get("ok", True),
+                "issues": result.get("issues", []),
+                "summary": result.get("summary", ""),
+            }
+
+        # 如果没有提供review_agent，无法修复，返回默认值
+        if review_agent is None:
+            PrettyOutput.auto_print("⚠️ 无法解析 review 结果，且无法修复格式")
+            return {"ok": True, "issues": [], "summary": "无法解析审查结果"}
+
+        # 尝试修复格式
+        for retry in range(max_retries):
+            PrettyOutput.auto_print(
+                f"🔧 第 {retry + 1}/{max_retries} 次尝试修复 JSON 格式..."
+            )
+
+            fix_prompt = f"""
+之前的review回复格式不正确，无法解析为有效的JSON格式。
+
+原始回复内容：
+```
+{summary}
+```
+
+请严格按照以下JSON格式重新组织你的回复：
+
+```json
+{{
+    "ok": true/false,  // 表示代码是否通过审查
+    "summary": "总体评价和建议",  // 简短总结
+    "issues": [  // 问题列表，如果没有问题则为空数组
+        {{
+            "type": "问题类型",  // 如: bug, style, performance, security等
+            "description": "问题描述",
+            "location": "问题位置",  // 文件名和行号
+            "suggestion": "修复建议"
+        }}
+    ]
+}}
+```
+
+确保回复只包含上述JSON格式，不要包含其他解释或文本。"""
+
+            try:
+                # 使用review_agent的底层model进行修复，保持review_agent的专用配置和系统prompt
+                fixed_summary = review_agent.model.chat_until_success(fix_prompt)
+                if fixed_summary:
+                    success, result, _ = _try_parse_json(str(fixed_summary))
+                    if success and result is not None:
+                        PrettyOutput.auto_print(
+                            f"✅ JSON格式修复成功（第 {retry + 1} 次）"
+                        )
+                        return {
+                            "ok": result.get("ok", True),
+                            "issues": result.get("issues", []),
+                            "summary": result.get("summary", ""),
+                        }
+                    else:
+                        PrettyOutput.auto_print("⚠️ 修复后的格式仍不正确，继续尝试...")
+                        summary = str(fixed_summary)  # 使用修复后的内容继续尝试
+                else:
+                    PrettyOutput.auto_print("⚠️ 修复请求无响应")
+
+            except Exception as e:
+                PrettyOutput.auto_print(f"⚠️ 修复过程中出错: {e}")
+
+        # 3次修复都失败，标记需要重新review
+        PrettyOutput.auto_print("❌ JSON格式修复失败，需要重新进行review")
+        return {
+            "ok": False,
+            "issues": [],
+            "summary": "JSON_FORMAT_ERROR",
+            "need_re_review": True,
+        }
+
+    def _review_and_fix(
+        self,
+        user_input: str,
+        enhanced_input: str,
+        prefix: str = "",
+        suffix: str = "",
+        code_generation_summary: Optional[str] = None,
+    ) -> None:
+        """执行 review 和修复循环
+
+        参数:
+            user_input: 用户原始需求
+            enhanced_input: 增强后的用户输入（用于修复）
+            prefix: 前缀
+            suffix: 后缀
         """
-        if not results:
-            return ""
-        
-        lines = []
-        for tool_name, file_path, command, returncode, output in results:
-            lines.append(f"工具: {tool_name}")
-            lines.append(f"文件: {file_path}")
-            lines.append(f"命令: {command}")
-            if returncode == -1:
-                lines.append(f"错误: {output}")
+        from jarvis.jarvis_agent import Agent
+
+        iteration = 0
+        max_iterations = self.review_max_iterations
+        # 如果 max_iterations 为 0，表示无限 review
+        is_infinite = max_iterations == 0
+
+        while is_infinite or iteration < max_iterations:
+            iteration += 1
+
+            # 获取从开始到当前的 git diff（提前检测是否有代码修改）
+            current_commit = get_latest_commit_hash()
+            if self.start_commit is None or current_commit == self.start_commit:
+                git_diff = get_diff()  # 获取未提交的更改
             else:
-                # 限制输出长度，避免过长
-                output_preview = output[:1000] if len(output) > 1000 else output
-                lines.append(f"输出:\n{output_preview}")
-                if len(output) > 1000:
-                    lines.append(f"... (输出已截断，共 {len(output)} 字符)")
-            lines.append("")  # 空行分隔
-        
-        return "\n".join(lines)
-
-    def _validate_build_after_edit(self, modified_files: List[str]) -> Optional[BuildResult]:
-        """编辑后验证构建
-        
-        Args:
-            modified_files: 修改的文件列表
-        
-        Returns:
-            BuildResult: 验证结果，如果验证被禁用或出错则返回None
+                git_diff = get_diff_between_commits(self.start_commit, current_commit)
+
+            if not git_diff or not git_diff.strip():
+                PrettyOutput.auto_print("ℹ️ 没有代码修改，跳过审查")
+                return
+
+            # 每轮审查开始前显示清晰的提示信息
+            if not self.non_interactive:
+                if is_infinite:
+                    PrettyOutput.auto_print(
+                        f"\n🔄 代码审查循环 - 第 {iteration} 轮（无限模式）"
+                    )
+                else:
+                    PrettyOutput.auto_print(
+                        f"\n🔄 代码审查循环 - 第 {iteration}/{max_iterations} 轮"
+                    )
+                if not user_confirm("是否开始本轮代码审查？", default=True):
+                    PrettyOutput.auto_print("ℹ️ 用户终止了代码审查")
+                    return
+            else:
+                if is_infinite:
+                    PrettyOutput.auto_print(
+                        f"\n🔍 开始第 {iteration} 轮代码审查...（无限模式）"
+                    )
+                else:
+                    PrettyOutput.auto_print(
+                        f"\n🔍 开始第 {iteration}/{max_iterations} 轮代码审查..."
+                    )
+
+            # 对 git diff 进行 token 限制处理（review 需要更多上下文，使用 40% 的 token 比例）
+            truncated_git_diff = self._truncate_diff_for_review(
+                git_diff, token_ratio=0.4
+            )
+            if truncated_git_diff != git_diff:
+                PrettyOutput.auto_print("⚠️ Git diff 内容过大，已截断以适应 token 限制")
+
+            # 构建 review prompts
+            sys_prompt, usr_prompt, sum_prompt = self._build_review_prompts(
+                user_input, truncated_git_diff, code_generation_summary
+            )
+
+            rules_prompt = self.rules_manager.load_all_rules(
+                ",".join(self.loaded_rule_names)
+            )
+
+            review_agent = Agent(
+                system_prompt=sys_prompt + f"\n\n<rules>\n{rules_prompt}\n</rules>",
+                name=f"CodeReview-Agent-{iteration}",
+                model_group=self.model.model_group if self.model else None,
+                summary_prompt=sum_prompt,
+                need_summary=True,
+                auto_complete=True,
+                use_tools=["execute_script", "read_code"],
+                non_interactive=self.non_interactive,
+                use_methodology=False,
+                use_analysis=False,
+            )
+
+            # 运行 review
+            summary = review_agent.run(usr_prompt)
+
+            # 解析审查结果，支持格式修复和重新review
+            result = self._parse_review_result(
+                str(summary) if summary else "", review_agent=review_agent
+            )
+
+            # 检查是否需要重新review（JSON格式错误3次修复失败）
+            if result.get("need_re_review", False):
+                PrettyOutput.auto_print(
+                    f"\n🔄 JSON格式修复失败，重新进行代码审查（第 {iteration} 轮）"
+                )
+                # 跳过当前迭代，重新开始review流程
+                continue
+
+            if result["ok"]:
+                PrettyOutput.auto_print(f"\n✅ 代码审查通过（第 {iteration} 轮）")
+                if result.get("summary"):
+                    PrettyOutput.auto_print(f"   {result['summary']}")
+                return
+
+            # 审查未通过，需要修复
+            PrettyOutput.auto_print(f"\n⚠️ 代码审查发现问题（第 {iteration} 轮）：")
+            for i, issue in enumerate(result.get("issues", []), 1):
+                issue_type = issue.get("type", "未知")
+                description = issue.get("description", "无描述")
+                location = issue.get("location", "未知位置")
+                suggestion = issue.get("suggestion", "无建议")
+                PrettyOutput.auto_print(f"   {i}. [{issue_type}] {description}")
+                PrettyOutput.auto_print(f"      位置: {location}")
+                PrettyOutput.auto_print(f"      建议: {suggestion}")
+
+            # 在每轮审查后给用户一个终止选择
+            if not self.non_interactive:
+                if not user_confirm("是否继续修复这些问题？", default=True):
+                    PrettyOutput.auto_print("ℹ️ 用户选择终止审查，保持当前代码状态")
+                    return
+
+            # 只有在非无限模式下才检查是否达到最大迭代次数
+            if not is_infinite and iteration >= max_iterations:
+                PrettyOutput.auto_print(
+                    f"\n⚠️ 已达到最大审查次数 ({max_iterations})，停止审查"
+                )
+                # 在非交互模式下直接返回，交互模式下询问用户
+                if not self.non_interactive:
+                    if not user_confirm("是否继续修复？", default=False):
+                        return
+                    # 用户选择继续，重置迭代次数
+                    iteration = 0
+                    max_iterations = self.review_max_iterations
+                    is_infinite = max_iterations == 0
+                else:
+                    return
+
+            # 构建修复 prompt
+            fix_prompt = f"""代码审查发现以下问题，请修复：
+
+【审查结果】
+{result.get("summary", "")}
+
+【问题列表】
+"""
+            for i, issue in enumerate(result.get("issues", []), 1):
+                fix_prompt += f"{i}. [{issue.get('type', '未知')}] {issue.get('description', '')}\n"
+                fix_prompt += f"   位置: {issue.get('location', '')}\n"
+                fix_prompt += f"   建议: {issue.get('suggestion', '')}\n\n"
+
+            fix_prompt += "\n请根据上述问题进行修复，确保代码正确实现用户需求。"
+
+            PrettyOutput.auto_print("\n🔧 开始修复问题...")
+
+            # 调用 super().run() 进行修复
+            try:
+                if self.model:
+                    self.model.set_suppress_output(False)
+                super().run(fix_prompt)
+            except RuntimeError as e:
+                PrettyOutput.auto_print(f"⚠️ 修复失败: {str(e)}")
+                return
+
+            # 处理未提交的更改
+            self.git_manager.handle_uncommitted_changes()
+
+    def add_runtime_rule(self, rule_name: str) -> None:
+        """添加运行时加载的规则到跟踪列表
+
+        用于记录通过builtin_input_handler等方式动态加载的规则，
+        确保这些规则能够被后续的子代理继承。
+
+        参数:
+            rule_name: 规则名称
         """
-        if not is_enable_build_validation():
-            return None
-        
-        # 检查项目配置，看是否已禁用构建验证
-        config = BuildValidationConfig(self.root_dir)
-        if config.is_build_validation_disabled():
-            # 已禁用，返回None，由调用方处理基础静态检查
-            return None
-        
-        # 输出编译检查日志
-        file_count = len(modified_files)
-        files_str = ", ".join(os.path.basename(f) for f in modified_files[:3])
-        if file_count > 3:
-            files_str += f" 等{file_count}个文件"
-        print(f"🔨 正在进行编译检查 ({files_str})...")
-        
-        try:
-            timeout = get_build_validation_timeout()
-            validator = BuildValidator(self.root_dir, timeout=timeout)
-            result = validator.validate(modified_files)
-            return result
-        except Exception as e:
-            # 构建验证失败不应该影响主流程，仅记录日志
-            print(f"⚠️ 构建验证执行失败: {e}")
-            return None
+        if not rule_name or not isinstance(rule_name, str):
+            return
+
+        # 同时更新完整规则集合（自动去重）
+        self.loaded_rule_names.add(rule_name)
 
 
 @app.command()
@@ -1834,23 +1090,33 @@ def cli(
         help="提交信息后缀（用换行分隔）",
     ),
     non_interactive: bool = typer.Option(
-        False, "-n", "--non-interactive", help="启用非交互模式：用户无法与命令交互，脚本执行超时限制为5分钟"
+        False,
+        "-n",
+        "--non-interactive",
+        help="启用非交互模式：用户无法与命令交互，脚本执行超时限制为5分钟",
     ),
     rule_names: Optional[str] = typer.Option(
-        None, "--rule-names", help="指定规则名称列表，用逗号分隔，从 rules.yaml 文件中读取对应的规则内容"
+        None,
+        "--rule-names",
+        help="指定规则名称列表，用逗号分隔，从 rules.yaml 文件中读取对应的规则内容",
+    ),
+    disable_review: bool = typer.Option(
+        False,
+        "--disable-review",
+        help="启用代码审查：在代码修改完成后自动进行代码审查，发现问题则自动修复",
+    ),
+    review_max_iterations: int = typer.Option(
+        0,
+        "--review-max-iterations",
+        help="代码审查最大迭代次数，达到上限后停止审查（默认3次）",
     ),
 ) -> None:
     """Jarvis主入口点。"""
-    # CLI 标志：非交互模式（不依赖配置文件）
-    if non_interactive:
-        try:
-            os.environ["JARVIS_NON_INTERACTIVE"] = "true"
-        except Exception:
-            pass
-        # 注意：全局配置同步放在 init_env 之后执行，避免被 init_env 覆盖
     # 非交互模式要求从命令行传入任务
     if non_interactive and not (requirement and str(requirement).strip()):
-        print("❌ 非交互模式已启用：必须使用 --requirement 传入任务内容，因多行输入不可用。")
+        PrettyOutput.auto_print(
+            "❌ 非交互模式已启用：必须使用 --requirement 传入任务内容，因多行输入不可用。"
+        )
         raise typer.Exit(code=2)
     init_env(
         "欢迎使用 Jarvis-CodeAgent，您的代码工程助手已准备就绪！",
@@ -1862,13 +1128,11 @@ def cli(
     # 在初始化环境后同步 CLI 选项到全局配置，避免被 init_env 覆盖
     try:
         if model_group:
-            set_config("JARVIS_LLM_GROUP", str(model_group))
+            set_config("llm_group", str(model_group))
         if tool_group:
-            set_config("JARVIS_TOOL_GROUP", str(tool_group))
+            set_config("tool_group", str(tool_group))
         if restore_session:
-            set_config("JARVIS_RESTORE_SESSION", True)
-        if non_interactive:
-            set_config("JARVIS_NON_INTERACTIVE", True)
+            set_config("restore_session", True)
     except Exception:
         # 静默忽略同步异常，不影响主流程
         pass
@@ -1882,9 +1146,13 @@ def cli(
         )
     except (subprocess.CalledProcessError, FileNotFoundError):
         curr_dir_path = os.getcwd()
-        print(f"⚠️ 警告：当前目录 '{curr_dir_path}' 不是一个git仓库。")
-        init_git = True if non_interactive else user_confirm(
-            f"是否要在 '{curr_dir_path}' 中初始化一个新的git仓库？", default=True
+        PrettyOutput.auto_print(f"⚠️ 警告：当前目录 '{curr_dir_path}' 不是一个git仓库。")
+        init_git = (
+            True
+            if non_interactive
+            else user_confirm(
+                f"是否要在 '{curr_dir_path}' 中初始化一个新的git仓库？", default=True
+            )
         )
         if init_git:
             try:
@@ -1896,12 +1164,12 @@ def cli(
                     encoding="utf-8",
                     errors="replace",
                 )
-                print("✅ 已成功初始化git仓库。")
+                PrettyOutput.auto_print("✅ 已成功初始化git仓库。")
             except (subprocess.CalledProcessError, FileNotFoundError) as e:
-                print(f"❌ 初始化git仓库失败: {e}")
+                PrettyOutput.auto_print(f"❌ 初始化git仓库失败: {e}")
                 sys.exit(1)
         else:
-            print("ℹ️ 操作已取消。Jarvis需要在git仓库中运行。")
+            PrettyOutput.auto_print("ℹ️ 操作已取消。Jarvis需要在git仓库中运行。")
             sys.exit(0)
 
     curr_dir = os.getcwd()
@@ -1909,13 +1177,14 @@ def cli(
     # 在定位到 git 根目录后，按仓库维度加锁，避免跨仓库互斥
     try:
         repo_root = os.getcwd()
-        lock_name = f"code_agent_{hashlib.md5(repo_root.encode('utf-8')).hexdigest()}.lock"
+        lock_name = (
+            f"code_agent_{hashlib.md5(repo_root.encode('utf-8')).hexdigest()}.lock"
+        )
         _acquire_single_instance_lock(lock_name=lock_name)
     except Exception:
         # 回退到全局锁，确保至少有互斥保护
         _acquire_single_instance_lock(lock_name="code_agent.lock")
     try:
-        
         agent = CodeAgent(
             model_group=model_group,
             need_summary=False,
@@ -1923,31 +1192,221 @@ def cli(
             tool_group=tool_group,
             non_interactive=non_interactive,
             rule_names=rule_names,
+            disable_review=disable_review,
+            review_max_iterations=review_max_iterations,
         )
 
+        # 显示可用的规则信息
+        _print_available_rules(agent.rules_manager, rule_names)
+
         # 尝试恢复会话
         if restore_session:
             if agent.restore_session():
-                print("✅ 已从 .jarvis/saved_session.json 恢复会话。")
+                PrettyOutput.auto_print("✅ 已从 .jarvis/saved_session.json 恢复会话。")
             else:
-                print("⚠️ 无法从 .jarvis/saved_session.json 恢复会话。")
+                PrettyOutput.auto_print(
+                    "⚠️ 无法从 .jarvis/saved_session.json 恢复会话。"
+                )
 
         if requirement:
             agent.run(requirement, prefix=prefix, suffix=suffix)
+            if agent.non_interactive:
+                raise typer.Exit(code=0)
         else:
             while True:
                 user_input = get_multiline_input("请输入你的需求（输入空行退出）:")
                 if not user_input:
                     raise typer.Exit(code=0)
                 agent.run(user_input, prefix=prefix, suffix=suffix)
+                if agent.non_interactive:
+                    raise typer.Exit(code=0)
 
     except typer.Exit:
         raise
     except RuntimeError as e:
-        print(f"❌ 错误: {str(e)}")
+        PrettyOutput.auto_print(f"❌ 错误: {str(e)}")
         sys.exit(1)
 
 
+def _print_available_rules(
+    rules_manager: RulesManager, rule_names: Optional[str] = None
+) -> None:
+    """打印可用的规则信息
+
+    参数:
+        rules_manager: 规则管理器实例
+        rule_names: 用户指定的规则名称列表（逗号分隔）
+    """
+    try:
+        from rich.console import Console
+        from rich.panel import Panel
+        from rich.text import Text
+
+        console = Console()
+
+        # 获取所有可用规则
+        all_rules = rules_manager.get_all_available_rule_names()
+        builtin_rules = all_rules.get("builtin", [])
+        file_rules = all_rules.get("files", [])
+        yaml_rules = all_rules.get("yaml", [])
+
+        # 获取已加载的规则
+        loaded_rules = []
+        if rule_names:
+            rule_list = [name.strip() for name in rule_names.split(",") if name.strip()]
+            for rule_name in rule_list:
+                if rules_manager.get_named_rule(rule_name):
+                    loaded_rules.append(rule_name)
+
+        # 检查项目规则和全局规则
+        has_project_rule = rules_manager.read_project_rule() is not None
+        has_global_rule = rules_manager.read_global_rules() is not None
+
+        # 构建规则信息内容
+        content_parts = []
+
+        # 显示所有规则（按来源分类）
+        has_any_rules = False
+
+        # 内置规则
+        if builtin_rules:
+            has_any_rules = True
+            builtin_text = Text()
+            builtin_text.append("📚 内置规则 ", style="bold cyan")
+            builtin_text.append(f"({len(builtin_rules)} 个): ", style="dim")
+            for i, rule in enumerate(builtin_rules):
+                if i > 0:
+                    builtin_text.append(", ", style="dim")
+                builtin_text.append(rule, style="yellow")
+            content_parts.append(builtin_text)
+
+        # 用户自定义规则
+        user_custom_rules = file_rules + yaml_rules
+        if user_custom_rules:
+            has_any_rules = True
+            user_text = Text()
+            user_text.append("👤 用户自定义规则 ", style="bold green")
+            user_text.append(f"({len(user_custom_rules)} 个): ", style="dim")
+
+            # 分别显示文件规则和YAML规则
+            custom_rules_parts = []
+            if file_rules:
+                file_part = Text()
+                file_part.append("文件规则: ", style="blue")
+                for i, rule in enumerate(file_rules):
+                    if i > 0:
+                        file_part.append(", ", style="dim")
+                    file_part.append(rule, style="cyan")
+                custom_rules_parts.append(file_part)
+
+            if yaml_rules:
+                yaml_part = Text()
+                yaml_part.append("YAML规则: ", style="magenta")
+                for i, rule in enumerate(yaml_rules):
+                    if i > 0:
+                        yaml_part.append(", ", style="dim")
+                    yaml_part.append(rule, style="magenta")
+                custom_rules_parts.append(yaml_part)
+
+            # 合并显示自定义规则
+            for i, part in enumerate(custom_rules_parts):
+                if i > 0:
+                    user_text.append(" | ", style="dim")
+                user_text.append(part)
+
+            content_parts.append(user_text)
+
+        # 分别显示详细的文件规则和YAML规则（保留原有详细信息）
+        if file_rules:
+            has_any_rules = True
+            file_text = Text()
+            file_text.append("📄 详细文件规则 ", style="bold blue")
+            file_text.append(f"({len(file_rules)} 个): ", style="dim")
+            for i, rule in enumerate(file_rules):
+                if i > 0:
+                    file_text.append(", ", style="dim")
+                file_text.append(rule, style="cyan")
+            content_parts.append(file_text)
+
+        if yaml_rules:
+            has_any_rules = True
+            yaml_text = Text()
+            yaml_text.append("📝 详细YAML规则 ", style="bold magenta")
+            yaml_text.append(f"({len(yaml_rules)} 个): ", style="dim")
+            for i, rule in enumerate(yaml_rules):
+                if i > 0:
+                    yaml_text.append(", ", style="dim")
+                yaml_text.append(rule, style="magenta")
+            content_parts.append(yaml_text)
+
+        # 如果没有规则，显示提示
+        if not has_any_rules:
+            no_rules_text = Text()
+            no_rules_text.append("ℹ️ 当前没有可用的规则", style="dim")
+            content_parts.append(no_rules_text)
+
+        # 提示信息
+        if has_any_rules:
+            tip_text = Text()
+            tip_text.append("💡 提示: ", style="bold green")
+            tip_text.append("使用 ", style="dim")
+            tip_text.append("--rule-names", style="bold yellow")
+            tip_text.append(" 参数加载规则，例如: ", style="dim")
+            tip_text.append("--rule-names tdd,clean_code", style="bold yellow")
+            tip_text.append("\n   或使用 ", style="dim")
+            tip_text.append("@", style="bold yellow")
+            tip_text.append(" 触发规则加载，例如: ", style="dim")
+            tip_text.append("@tdd @clean_code", style="bold yellow")
+            content_parts.append(tip_text)
+
+        # 显示已加载的规则
+        if loaded_rules:
+            loaded_text = Text()
+            loaded_text.append("✅ 已加载规则: ", style="bold green")
+            for i, rule in enumerate(loaded_rules):
+                if i > 0:
+                    loaded_text.append(", ", style="dim")
+                loaded_text.append(rule, style="bold yellow")
+            content_parts.append(loaded_text)
+
+        # 显示项目规则和全局规则
+        if has_project_rule or has_global_rule:
+            rule_files_text = Text()
+            if has_project_rule:
+                rule_files_text.append("📁 项目规则: ", style="bold blue")
+                rule_files_text.append(".jarvis/rule", style="dim")
+                if has_global_rule:
+                    rule_files_text.append(" | ", style="dim")
+            if has_global_rule:
+                rule_files_text.append("🌐 全局规则: ", style="bold magenta")
+                rule_files_text.append("~/.jarvis/rule", style="dim")
+            content_parts.append(rule_files_text)
+
+        # 如果有规则信息，使用 Panel 打印
+        if content_parts:
+            from rich.console import Group
+
+            # 创建内容组
+            content_group = Group(*content_parts)
+
+            # 创建 Panel
+            panel = Panel(
+                content_group,
+                title="📋 规则信息",
+                title_align="center",
+                border_style="cyan",
+                padding=(0, 1),
+            )
+
+            console.print(panel)
+    except Exception as e:
+        # 显示错误信息而不是静默失败
+        PrettyOutput.auto_print(f"⚠️ 规则信息显示失败: {e}")
+        import traceback
+
+        traceback.print_exc()
+
+
 def main() -> None:
     """Application entry point."""
     app()