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

jarvis/jarvis_c2rust/optimizer_utils.py

@@ -0,0 +1,469 @@
+# -*- coding: utf-8 -*-
+"""优化器工具函数。"""
+
+import json
+import os
+import shutil
+import subprocess
+from pathlib import Path
+from typing import Dict
+from typing import Iterable
+from typing import List
+from typing import Optional
+from typing import Set
+from typing import Tuple
+
+from jarvis.jarvis_utils.output import PrettyOutput
+from jarvis.jarvis_c2rust.optimizer_options import OptimizeOptions
+from jarvis.jarvis_c2rust.optimizer_options import OptimizeStats
+
+
+def run_cmd(
+    cmd: List[str],
+    cwd: Path,
+    env: Optional[Dict[str, str]] = None,
+    timeout: Optional[int] = None,
+) -> Tuple[int, str, str]:
+    """执行命令并返回结果。"""
+    p = subprocess.Popen(
+        cmd,
+        cwd=str(cwd),
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        text=True,
+        env=dict(os.environ, **(env or {})),
+    )
+    try:
+        out, err = p.communicate(timeout=timeout if timeout and timeout > 0 else None)
+        return p.returncode, out, err
+    except subprocess.TimeoutExpired:
+        p.kill()
+        out, err = p.communicate()
+        err_msg = f"Command '{' '.join(cmd)}' timed out after {timeout} seconds."
+        if err:
+            err_msg += f"\n{err}"
+        return -1, out, err_msg
+
+
+def cargo_check(
+    crate_dir: Path,
+    stats: OptimizeStats,
+    max_checks: int,
+    timeout: Optional[int] = None,
+) -> Tuple[bool, str]:
+    """执行 cargo test 并返回结果摘要。"""
+    # 统一使用 cargo test 作为验证手段
+    if max_checks and stats.cargo_checks >= max_checks:
+        return False, "cargo test budget exhausted"
+    code, out, err = run_cmd(["cargo", "test", "-q"], crate_dir, timeout=timeout)
+    stats.cargo_checks += 1
+    ok = code == 0
+    diag = err.strip() or out.strip()
+    # 取首行作为摘要
+    first_line = next((ln for ln in diag.splitlines() if ln.strip()), "")
+    return ok, first_line
+
+
+def run_cargo_fmt(crate_dir: Path) -> None:
+    """执行 cargo fmt 格式化代码。fmt 失败不影响主流程，只记录警告。"""
+    try:
+        res = subprocess.run(
+            ["cargo", "fmt"],
+            capture_output=True,
+            text=True,
+            check=False,
+            cwd=str(crate_dir),
+        )
+        if res.returncode == 0:
+            PrettyOutput.auto_print("✅ [c2rust-optimizer][fmt] 代码格式化完成")
+        else:
+            # fmt 失败不影响主流程，只记录警告
+            PrettyOutput.auto_print(
+                f"⚠️ [c2rust-optimizer][fmt] 代码格式化失败（非致命）: {res.stderr or res.stdout}"
+            )
+    except Exception as e:
+        # fmt 失败不影响主流程，只记录警告
+        PrettyOutput.auto_print(
+            f"⚠️ [c2rust-optimizer][fmt] 代码格式化异常（非致命）: {e}"
+        )
+
+
+def check_clippy_warnings(crate_dir: Path) -> Tuple[bool, str]:
+    """
+    检查是否有 clippy 告警。
+    使用 JSON 格式输出，便于精确解析和指定警告。
+    返回 (has_warnings, json_output)，has_warnings 为 True 表示有告警，json_output 为 JSON 格式的输出。
+    """
+    try:
+        res = subprocess.run(
+            ["cargo", "clippy", "--message-format=json", "--", "-W", "clippy::all"],
+            capture_output=True,
+            text=True,
+            check=False,
+            cwd=str(crate_dir),
+        )
+        # clippy 的 JSON 输出通常在 stdout
+        stdout_output = (res.stdout or "").strip()
+        stderr_output = (res.stderr or "").strip()
+
+        # 解析 JSON 输出，提取警告信息
+        warnings = []
+        if stdout_output:
+            for line in stdout_output.splitlines():
+                line = line.strip()
+                if not line:
+                    continue
+                try:
+                    msg = json.loads(line)
+                    # 只处理 warning 类型的消息
+                    if (
+                        msg.get("reason") == "compiler-message"
+                        and msg.get("message", {}).get("level") == "warning"
+                    ):
+                        warnings.append(msg)
+                except (json.JSONDecodeError, KeyError, TypeError):
+                    # 忽略无法解析的行（可能是其他输出）
+                    continue
+
+        has_warnings = len(warnings) > 0
+
+        # 调试输出
+        if has_warnings:
+            PrettyOutput.auto_print(
+                f"⚠️ [c2rust-optimizer][clippy-check] 检测到 {len(warnings)} 个 Clippy 告警"
+            )
+        elif res.returncode != 0:
+            # 如果返回码非零但没有警告，可能是编译错误
+            PrettyOutput.auto_print(
+                f"📊 [c2rust-optimizer][clippy-check] Clippy 返回非零退出码（{res.returncode}），但未检测到告警，可能是编译错误"
+            )
+            if stderr_output:
+                PrettyOutput.auto_print(
+                    f"📊 [c2rust-optimizer][clippy-check] 错误输出预览（前200字符）: {stderr_output[:200]}"
+                )
+
+        # 返回 JSON 格式的输出（用于后续解析）
+        return has_warnings, stdout_output
+    except Exception as e:
+        # 检查失败时假设没有告警，避免阻塞流程
+        PrettyOutput.auto_print(
+            f"⚠️ [c2rust-optimizer][clippy-check] 检查 Clippy 告警异常（非致命）: {e}"
+        )
+        return False, ""
+
+
+def check_missing_safety_doc_warnings(crate_dir: Path) -> Tuple[bool, str]:
+    """
+    检查是否有 missing_safety_doc 告警。
+    使用 JSON 格式输出，便于精确解析和指定警告。
+    返回 (has_warnings, json_output)，has_warnings 为 True 表示有告警，json_output 为 JSON 格式的输出。
+    """
+    try:
+        res = subprocess.run(
+            [
+                "cargo",
+                "clippy",
+                "--message-format=json",
+                "--",
+                "-W",
+                "clippy::missing_safety_doc",
+            ],
+            capture_output=True,
+            text=True,
+            check=False,
+            cwd=str(crate_dir),
+        )
+        # clippy 的 JSON 输出通常在 stdout
+        stdout_output = (res.stdout or "").strip()
+        stderr_output = (res.stderr or "").strip()
+
+        # 解析 JSON 输出，提取警告信息
+        warnings = []
+        if stdout_output:
+            for line in stdout_output.splitlines():
+                line = line.strip()
+                if not line:
+                    continue
+                try:
+                    msg = json.loads(line)
+                    # 只处理 warning 类型的消息，且是 missing_safety_doc
+                    if msg.get("reason") == "compiler-message":
+                        message = msg.get("message", {})
+                        if message.get("level") == "warning":
+                            code = message.get("code", {})
+                            code_str = code.get("code", "") if code else ""
+                            if "missing_safety_doc" in code_str:
+                                warnings.append(msg)
+                except (json.JSONDecodeError, KeyError, TypeError):
+                    # 忽略无法解析的行（可能是其他输出）
+                    continue
+
+        has_warnings = len(warnings) > 0
+
+        # 调试输出
+        if has_warnings:
+            PrettyOutput.auto_print(
+                f"⚠️ [c2rust-optimizer][missing-safety-doc-check] 检测到 {len(warnings)} 个 missing_safety_doc 告警"
+            )
+        elif res.returncode != 0:
+            # 如果返回码非零但没有警告，可能是编译错误
+            PrettyOutput.auto_print(
+                f"📊 [c2rust-optimizer][missing-safety-doc-check] Clippy 返回非零退出码（{res.returncode}），但未检测到告警，可能是编译错误"
+            )
+            if stderr_output:
+                PrettyOutput.auto_print(
+                    f"📊 [c2rust-optimizer][missing-safety-doc-check] 错误输出预览（前200字符）: {stderr_output[:200]}"
+                )
+
+        # 返回 JSON 格式的输出（用于后续解析）
+        return has_warnings, stdout_output
+    except Exception as e:
+        # 检查失败时假设没有告警，避免阻塞流程
+        PrettyOutput.auto_print(
+            f"⚠️ [c2rust-optimizer][missing-safety-doc-check] 检查 missing_safety_doc 告警异常（非致命）: {e}"
+        )
+        return False, ""
+
+
+def cargo_check_full(
+    crate_dir: Path,
+    stats: OptimizeStats,
+    max_checks: int,
+    timeout: Optional[int] = None,
+) -> Tuple[bool, str]:
+    """
+    执行 cargo test，返回是否成功与完整输出（stdout+stderr）。
+    会计入 stats.cargo_checks，并受 max_checks 预算限制。
+    """
+    if max_checks and stats.cargo_checks >= max_checks:
+        return False, "cargo test budget exhausted"
+    try:
+        res = subprocess.run(
+            ["cargo", "test", "-q"],
+            capture_output=True,
+            text=True,
+            check=False,
+            cwd=str(crate_dir),
+            timeout=timeout if timeout and timeout > 0 else None,
+        )
+        stats.cargo_checks += 1
+        ok = res.returncode == 0
+        out = res.stdout or ""
+        err = res.stderr or ""
+        msg = (out + ("\n" + err if err else "")).strip()
+        return ok, msg
+    except subprocess.TimeoutExpired as e:
+        stats.cargo_checks += 1
+        out_s = e.stdout.decode("utf-8", errors="ignore") if e.stdout else ""
+        err_s = e.stderr.decode("utf-8", errors="ignore") if e.stderr else ""
+        msg = f"cargo test timed out after {timeout} seconds"
+        full_output = (out_s + ("\n" + err_s if err_s else "")).strip()
+        if full_output:
+            msg += f"\nOutput:\n{full_output}"
+        return False, msg
+    except Exception as e:
+        stats.cargo_checks += 1
+        return False, f"cargo test exception: {e}"
+
+
+def git_toplevel(start: Path) -> Optional[Path]:
+    """返回包含 start 的 Git 仓库根目录（--show-toplevel）。若不在仓库中则返回 None。"""
+    try:
+        code, out, err = run_cmd(["git", "rev-parse", "--show-toplevel"], start)
+        if code == 0:
+            p = (out or "").strip()
+            if p:
+                return Path(p)
+        return None
+    except Exception:
+        return None
+
+
+def git_head_commit(root: Path) -> Optional[str]:
+    """获取 Git HEAD commit hash。"""
+    try:
+        code, out, err = run_cmd(["git", "rev-parse", "--verify", "HEAD"], root)
+        if code == 0:
+            return out.strip()
+        return None
+    except Exception:
+        return None
+
+
+def git_reset_hard(root: Path, commit: str) -> bool:
+    """执行 git reset --hard 到指定 commit。"""
+    try:
+        code, _, _ = run_cmd(["git", "reset", "--hard", commit], root)
+        if code != 0:
+            return False
+        return True
+    except Exception:
+        return False
+
+
+def iter_rust_files(crate_dir: Path) -> Iterable[Path]:
+    """遍历 crate 目录下的所有 Rust 文件。"""
+    src = crate_dir / "src"
+    if not src.exists():
+        # 仍尝试遍历整个 crate 目录，但优先 src
+        yield from crate_dir.rglob("*.rs")
+        return
+    # 遍历 src 优先
+    yield from src.rglob("*.rs")
+
+
+def read_file(path: Path) -> str:
+    """读取文件内容。"""
+    return path.read_text(encoding="utf-8")
+
+
+def write_file(path: Path, content: str) -> None:
+    """写入文件内容。"""
+    path.write_text(content, encoding="utf-8")
+
+
+def backup_file(path: Path) -> Path:
+    """备份文件。"""
+    bak = path.with_suffix(path.suffix + ".bak_opt")
+    shutil.copy2(path, bak)
+    return bak
+
+
+def restore_file_from_backup(path: Path, backup: Path) -> None:
+    """从备份恢复文件。"""
+    shutil.move(str(backup), str(path))
+
+
+def remove_backup(backup: Path) -> None:
+    """删除备份文件。"""
+    if backup.exists():
+        backup.unlink(missing_ok=True)
+
+
+def ensure_report_dir(crate_dir: Path) -> Path:
+    """确保报告目录存在。"""
+    report_dir = crate_dir / ".jarvis" / "c2rust"
+    report_dir.mkdir(parents=True, exist_ok=True)
+    return report_dir
+
+
+def find_project_root() -> Optional[Path]:
+    """
+    查找项目根目录（包含 .jarvis/c2rust 的目录）。
+    从当前目录向上查找，最多向上查找 5 层。
+    """
+    from jarvis.jarvis_c2rust.constants import C2RUST_DIRNAME
+
+    cwd = Path(".").resolve()
+    current = cwd
+    for _ in range(5):
+        if current and current.exists():
+            jarvis_dir = current / C2RUST_DIRNAME
+            if jarvis_dir.exists() and jarvis_dir.is_dir():
+                return current
+            parent = current.parent
+            if parent == current:  # 已到达根目录
+                break
+            current = parent
+    return None
+
+
+def parse_patterns(s: Optional[str]) -> List[str]:
+    """解析逗号分隔的模式字符串。"""
+    if not s or not isinstance(s, str):
+        return []
+    parts = [x.strip() for x in s.replace("\n", ",").split(",")]
+    return [x for x in parts if x]
+
+
+def match_any_pattern(rel: str, patterns: List[str]) -> bool:
+    """检查相对路径是否匹配任一模式。"""
+    if not patterns:
+        return False
+    import fnmatch
+
+    return any(fnmatch.fnmatch(rel, pat) for pat in patterns)
+
+
+def compute_target_files(
+    crate_dir: Path,
+    options: OptimizeOptions,
+    processed: Set[str],
+) -> List[Path]:
+    """
+    计算目标文件列表（按 include/exclude/resume/max_files 过滤）。
+
+    Args:
+        crate_dir: crate 根目录
+        options: 优化选项
+        processed: 已处理的文件集合
+
+    Returns:
+        目标文件列表
+    """
+    include = parse_patterns(options.include_patterns)
+    exclude = parse_patterns(options.exclude_patterns)
+    maxn = int(options.max_files or 0)
+    take: List[Path] = []
+    for p in sorted(iter_rust_files(crate_dir), key=lambda x: x.as_posix()):
+        try:
+            rel = p.resolve().relative_to(crate_dir.resolve()).as_posix()
+        except Exception:
+            rel = p.as_posix()
+        # include 过滤（若提供，则必须命中其一）
+        if include and not match_any_pattern(rel, include):
+            continue
+        # exclude 过滤
+        if exclude and match_any_pattern(rel, exclude):
+            continue
+        # resume：跳过已处理文件
+        if options.resume and rel in processed:
+            continue
+        take.append(p)
+        if maxn > 0 and len(take) >= maxn:
+            break
+    return take
+
+
+def detect_crate_dir(preferred: Optional[Path]) -> Path:
+    """
+    选择 crate 目录策略：
+    - 若提供 preferred 且包含 Cargo.toml，则使用
+    - 否则：尝试从项目根目录推断（查找包含 .jarvis/c2rust 的目录）
+    - 否则：优先 <cwd>/<cwd.name>_rs；若存在 Cargo.toml 则用之
+    - 否则：在当前目录下递归寻找第一个包含 Cargo.toml 的目录
+    - 若失败：若当前目录有 Cargo.toml 则返回当前目录，否则抛错
+    """
+    if preferred:
+        preferred = preferred.resolve()
+        if (preferred / "Cargo.toml").exists():
+            return preferred
+
+    # 尝试从项目根目录推断 crate 目录
+    project_root = find_project_root()
+    if project_root:
+        # 策略1: project_root 的父目录下的 <project_root.name>_rs
+        candidate1 = project_root.parent / f"{project_root.name}_rs"
+        if (candidate1 / "Cargo.toml").exists():
+            return candidate1
+        # 策略2: project_root 本身（如果包含 Cargo.toml）
+        if (project_root / "Cargo.toml").exists():
+            return project_root
+        # 策略3: project_root 下的子目录中包含 Cargo.toml 的
+        for d in project_root.iterdir():
+            if d.is_dir() and (d / "Cargo.toml").exists():
+                return d
+
+    cwd = Path(".").resolve()
+    candidate = cwd / f"{cwd.name}_rs"
+    if (candidate / "Cargo.toml").exists():
+        return candidate
+
+    # 搜索第一个包含 Cargo.toml 的目录（限制深度2以避免过慢）
+    for p in [cwd] + [d for d in cwd.iterdir() if d.is_dir()]:
+        if (p / "Cargo.toml").exists():
+            return p
+
+    if (cwd / "Cargo.toml").exists():
+        return cwd
+    raise FileNotFoundError("未找到 Cargo.toml，对应 crate 目录无法确定。")

jarvis/jarvis_c2rust/optimizer_visibility.py

@@ -0,0 +1,185 @@
+# -*- coding: utf-8 -*-
+"""可见性优化模块。"""
+
+import os
+from pathlib import Path
+from typing import Callable
+from typing import List
+
+from jarvis.jarvis_utils.output import PrettyOutput
+
+from jarvis.jarvis_agent.events import AFTER_TOOL_CALL
+from jarvis.jarvis_agent.events import BEFORE_TOOL_CALL
+from jarvis.jarvis_c2rust.optimizer_options import OptimizeOptions
+from jarvis.jarvis_c2rust.optimizer_options import OptimizeStats
+from jarvis.jarvis_c2rust.optimizer_progress import ProgressManager
+from jarvis.jarvis_c2rust.optimizer_utils import cargo_check_full
+from jarvis.jarvis_c2rust.optimizer_utils import run_cargo_fmt
+from jarvis.jarvis_code_agent.code_agent import CodeAgent
+
+
+class VisibilityOptimizer:
+    """可见性优化器。"""
+
+    def __init__(
+        self,
+        crate_dir: Path,
+        options: OptimizeOptions,
+        stats: OptimizeStats,
+        progress_manager: ProgressManager,
+        append_additional_notes_func: Callable[[str], str],
+    ):
+        self.crate_dir = crate_dir
+        self.options = options
+        self.stats = stats
+        self.progress_manager = progress_manager
+        self.append_additional_notes = append_additional_notes_func
+
+    def codeagent_opt_visibility(self, target_files: List[Path]) -> None:
+        """
+        使用 CodeAgent 进行可见性优化。
+
+        注意：CodeAgent 必须在 crate 目录下创建和执行，以确保所有文件操作和命令执行都在正确的上下文中进行。
+        """
+        crate = self.crate_dir.resolve()
+        file_list: List[str] = []
+        for p in target_files:
+            try:
+                rel = p.resolve().relative_to(crate).as_posix()
+            except Exception:
+                rel = p.as_posix()
+            file_list.append(rel)
+            self.stats.files_scanned += 1
+
+        prompt_lines: List[str] = [
+            "你是资深 Rust 代码工程师。请在当前 crate 下执行可见性优化，并以补丁形式输出修改：",
+            f"- crate 根目录：{crate}",
+            "",
+            "本次优化仅允许修改以下文件范围（严格限制）：",
+            *[f"- {rel}" for rel in file_list],
+            "",
+            "优化目标：",
+            "1) 可见性最小化：",
+            "   - 优先将 `pub fn` 降为 `pub(crate) fn`（如果函数仅在 crate 内部使用）；",
+            "   - 保持对外接口（跨 crate 使用的接口，如 lib.rs 中的顶层导出）为 `pub`；",
+            "   - 在 lib.rs 中的顶层导出保持现状，不要修改。",
+            "",
+            "2) 修复已有实现的问题：",
+            "   - 如果在进行可见性优化的过程中，发现代码已有的实现有问题（如逻辑错误、潜在 bug、性能问题、内存安全问题等），也需要一并修复；",
+            "   - 这些问题可能包括但不限于：不正确的可见性设计、未检查的边界条件、资源泄漏、竞态条件等；",
+            "   - 修复时应该保持最小改动原则，优先修复最严重的问题。",
+            "",
+            "约束与范围：",
+            "- 仅修改上述列出的文件；除非必须（如修复引用路径），否则不要修改其他文件。",
+            "- 保持最小改动，不要进行与可见性优化无关的重构或格式化。",
+            "- 修改后需保证 `cargo test` 可以通过；如需引入少量配套改动，请一并包含在补丁中以确保通过。",
+            "- 输出仅为补丁，不要输出解释或多余文本。",
+            "",
+            "优先级说明：",
+            "- **如果优化过程中出现了测试不通过或编译错误，必须优先解决这些问题**；",
+            "- 在进行可见性优化之前，先确保代码能够正常编译和通过测试；",
+            "- 如果可见性优化导致了编译错误或测试失败，必须立即修复这些错误，然后再继续优化。",
+            "",
+            "自检要求：在每次输出补丁后，请使用 execute_script 工具在 crate 根目录执行 `cargo test -q` 进行验证；",
+            "若出现编译错误或测试失败，请优先修复这些问题，然后再继续可见性优化；",
+            "若未通过，请继续输出新的补丁进行最小修复并再次自检，直至 `cargo test` 通过为止。",
+        ]
+        prompt = "\n".join(prompt_lines)
+        prompt = self.append_additional_notes(prompt)
+        # 切换到 crate 目录，确保 CodeAgent 在正确的上下文中创建和执行
+        prev_cwd = os.getcwd()
+        PrettyOutput.auto_print(
+            "[c2rust-optimizer][codeagent][visibility] 正在调用 CodeAgent 进行可见性优化..."
+        )
+        try:
+            os.chdir(str(crate))
+            # 修复前执行 cargo fmt
+            run_cargo_fmt(crate)
+
+            # 记录运行前的 commit id
+            commit_before = self.progress_manager.get_crate_commit_hash()
+
+            # CodeAgent 在 crate 目录下创建和执行
+            agent = CodeAgent(
+                name="VisibilityOptimizer",
+                need_summary=False,
+                non_interactive=self.options.non_interactive,
+                model_group=self.options.llm_group,
+                enable_task_list_manager=False,
+                disable_review=True,
+            )
+            # 订阅 BEFORE_TOOL_CALL 和 AFTER_TOOL_CALL 事件，用于细粒度检测测试代码删除
+            agent.event_bus.subscribe(
+                BEFORE_TOOL_CALL, self.progress_manager.on_before_tool_call
+            )
+            agent.event_bus.subscribe(
+                AFTER_TOOL_CALL, self.progress_manager.on_after_tool_call
+            )
+            # 记录 Agent 创建时的 commit id（作为初始值）
+            agent_id = id(agent)
+            agent_key = f"agent_{agent_id}"
+            initial_commit = self.progress_manager.get_crate_commit_hash()
+            if initial_commit:
+                self.progress_manager._agent_before_commits[agent_key] = initial_commit
+            agent.run(
+                prompt, prefix="[c2rust-optimizer][codeagent][visibility]", suffix=""
+            )
+
+            # 检测并处理测试代码删除
+            if self.progress_manager.check_and_handle_test_deletion(
+                commit_before, agent
+            ):
+                # 如果回退了，需要重新运行 agent
+                PrettyOutput.auto_print(
+                    "[c2rust-optimizer][codeagent][visibility] 检测到测试代码删除问题，已回退，重新运行 agent"
+                )
+                commit_before = self.progress_manager.get_crate_commit_hash()
+                agent.run(
+                    prompt,
+                    prefix="[c2rust-optimizer][codeagent][visibility][retry]",
+                    suffix="",
+                )
+                # 再次检测
+                if self.progress_manager.check_and_handle_test_deletion(
+                    commit_before, agent
+                ):
+                    PrettyOutput.auto_print(
+                        "[c2rust-optimizer][codeagent][visibility] 再次检测到测试代码删除问题，已回退"
+                    )
+
+            # 验证修复是否成功（通过 cargo test）
+            ok, _ = cargo_check_full(
+                crate,
+                self.stats,
+                self.options.max_checks,
+                timeout=self.options.cargo_test_timeout,
+            )
+            if ok:
+                # 修复成功，保存进度和 commit id
+                file_paths = [crate / f for f in file_list if (crate / f).exists()]
+                self.progress_manager.save_fix_progress(
+                    "visibility_opt", "batch", file_paths if file_paths else None
+                )
+                PrettyOutput.auto_print(
+                    "[c2rust-optimizer][codeagent][visibility] 可见性优化成功，已保存进度"
+                )
+            else:
+                # 测试失败，回退到运行前的 commit
+                if commit_before:
+                    PrettyOutput.auto_print(
+                        f"[c2rust-optimizer][codeagent][visibility] 可见性优化后测试失败，回退到运行前的 commit: {commit_before[:8]}"
+                    )
+                    if self.progress_manager.reset_to_commit(commit_before):
+                        PrettyOutput.auto_print(
+                            f"[c2rust-optimizer][codeagent][visibility] 已成功回退到 commit: {commit_before[:8]}"
+                        )
+                    else:
+                        PrettyOutput.auto_print(
+                            "[c2rust-optimizer][codeagent][visibility] 回退失败，请手动检查代码状态"
+                        )
+                else:
+                    PrettyOutput.auto_print(
+                        "[c2rust-optimizer][codeagent][visibility] 可见性优化后测试失败，但无法获取运行前的 commit"
+                    )
+        finally:
+            os.chdir(prev_cwd)