jarvis-ai-assistant 0.5.1__py3-none-any.whl → 0.6.0__py3-none-any.whl

jarvis/__init__.py

@@ -1,4 +1,4 @@
 # -*- coding: utf-8 -*-
 """Jarvis AI Assistant"""
 
-__version__ = "0.5.1"
+__version__ = "0.6.0"

jarvis/jarvis_agent/__init__.py

@@ -77,6 +77,7 @@ from jarvis.jarvis_utils.config import (
     get_tool_filter_threshold,
     get_after_tool_call_cb_dirs,
     get_plan_max_depth,
+    is_plan_enabled,
 )
 from jarvis.jarvis_utils.embedding import get_context_token_count
 from jarvis.jarvis_utils.globals import (
@@ -317,11 +318,12 @@ class Agent:
         use_methodology: Optional[bool] = None,
         use_analysis: Optional[bool] = None,
         force_save_memory: Optional[bool] = None,
+        disable_file_edit: bool = False,
         files: Optional[List[str]] = None,
         confirm_callback: Optional[Callable[[str, bool], bool]] = None,
         non_interactive: Optional[bool] = None,
         in_multi_agent: Optional[bool] = None,
-        plan: bool = False,
+        plan: Optional[bool] = None,
         plan_max_depth: Optional[int] = None,
         plan_depth: int = 0,
         agent_type: str = "normal",
@@ -344,7 +346,7 @@ class Agent:
             force_save_memory: 是否强制保存记忆
             confirm_callback: 用户确认回调函数，签名为 (tip: str, default: bool) -> bool；默认使用CLI的user_confirm
             non_interactive: 是否以非交互模式运行（优先级最高，覆盖环境变量与配置）
-            plan: 是否启用任务规划与子任务拆分（默认 False；启用后在进入主循环前评估是否需要将任务拆分为 <SUB_TASK> 列表，逐一由子Agent执行并汇总结果）
+            plan: 是否启用任务规划与子任务拆分（默认从配置加载；启用后在进入主循环前评估是否需要将任务拆分为 <SUB_TASK> 列表，逐一由子Agent执行并汇总结果）
             plan_max_depth: 任务规划的最大层数（默认3，可通过配置 JARVIS_PLAN_MAX_DEPTH 或入参覆盖）
             plan_depth: 当前规划层数（内部用于递归控制，子Agent会在父基础上+1）
         """
@@ -363,6 +365,7 @@ class Agent:
         self.execute_tool_confirm = execute_tool_confirm
         self.summary_prompt = summary_prompt
         self.force_save_memory = force_save_memory
+        self.disable_file_edit = bool(disable_file_edit)
         # 资源与环境
         self.model_group = model_group
         self.files = files or []
@@ -370,7 +373,8 @@ class Agent:
         self.non_interactive = non_interactive
         # 多智能体运行标志：用于控制非交互模式下的自动完成行为
         self.in_multi_agent = bool(in_multi_agent)
-        self.plan = bool(plan)
+        # 任务规划：优先使用入参，否则回退到配置
+        self.plan = bool(plan) if plan is not None else is_plan_enabled()
         # 规划深度与上限
         try:
             self.plan_max_depth = (
@@ -511,7 +515,13 @@ class Agent:
         use_tools: List[str],
     ):
         """初始化各种处理器"""
-        self.output_handler = output_handler or [ToolRegistry(),  EditFileHandler(), RewriteFileHandler()]
+        default_handlers = [ToolRegistry()]
+        if not getattr(self, "disable_file_edit", False):
+            default_handlers.extend([EditFileHandler(), RewriteFileHandler()])
+        handlers = output_handler or default_handlers
+        if getattr(self, "disable_file_edit", False):
+            handlers = [h for h in handlers if not isinstance(h, (EditFileHandler, RewriteFileHandler))]
+        self.output_handler = handlers
         self.set_use_tools(use_tools)
         self.input_handler = [
             builtin_input_handler,
@@ -1238,6 +1248,7 @@ class Agent:
             "use_methodology": self.use_methodology,
             "use_analysis": self.use_analysis,
             "force_save_memory": self.force_save_memory,
+            "disable_file_edit": self.disable_file_edit,
             "files": self.files,
             "confirm_callback": self.confirm_callback,
             "non_interactive": True,

jarvis/jarvis_agent/agent_manager.py

@@ -32,6 +32,7 @@ class AgentManager:
         multiline_inputer: Optional[Callable[[str], str]] = None,
         confirm_callback: Optional[Callable[[str, bool], bool]] = None,
         non_interactive: Optional[bool] = None,
+        plan: Optional[bool] = None,
     ):
         self.model_group = model_group
         self.tool_group = tool_group
@@ -43,6 +44,7 @@ class AgentManager:
         self.multiline_inputer = multiline_inputer
         self.confirm_callback = confirm_callback
         self.non_interactive = non_interactive
+        self.plan = plan
 
     def initialize(self) -> Agent:
         """初始化Agent"""
@@ -61,6 +63,7 @@ class AgentManager:
             multiline_inputer=self.multiline_inputer,
             confirm_callback=self.confirm_callback,
             non_interactive=self.non_interactive,
+            plan=self.plan,
         )
 
         # 尝试恢复会话

jarvis/jarvis_agent/jarvis.py

@@ -370,10 +370,30 @@ def handle_builtin_config_selector(
     """在进入默认通用代理前，列出内置配置供选择（agent/multi_agent/roles）。"""
     if is_enable_builtin_config_selector():
         try:
-            # 优先使用项目内置目录，若不存在则回退到指定的绝对路径
-            builtin_root = Path(__file__).resolve().parents[3] / "builtin"
-            if not builtin_root.exists():
-                builtin_root = Path("/home/skyfire/code/Jarvis/builtin")
+            # 查找可用的 builtin 目录（支持多候选）
+            builtin_dirs: List[Path] = []
+            try:
+                ancestors = list(Path(__file__).resolve().parents)
+                for anc in ancestors[:8]:
+                    p = anc / "builtin"
+                    if p.exists():
+                        builtin_dirs.append(p)
+            except Exception:
+                pass
+            # 去重，保留顺序
+            _seen = set()
+            _unique: List[Path] = []
+            for d in builtin_dirs:
+                try:
+                    key = str(d.resolve())
+                except Exception:
+                    key = str(d)
+                if key not in _seen:
+                    _seen.add(key)
+                    _unique.append(d)
+            builtin_dirs = _unique
+            # 向后兼容：保留第一个候选作为 builtin_root
+            builtin_root = builtin_dirs[0] if builtin_dirs else None  # type: ignore[assignment]
 
             categories = [
                 ("agent", "jarvis-agent", "*.yaml"),
@@ -414,8 +434,14 @@ def handle_builtin_config_selector(
                     # 忽略配置读取异常
                     pass
 
-                # 追加内置目录
-                search_dirs.append(builtin_root / cat)
+                # 追加内置目录（支持多个候选）
+                try:
+                    candidates = builtin_dirs if isinstance(builtin_dirs, list) and builtin_dirs else ([builtin_root] if builtin_root else [])
+                except Exception:
+                    candidates = ([builtin_root] if builtin_root else [])
+                for _bd in candidates:
+                    if _bd:
+                        search_dirs.append(Path(_bd) / cat)
 
                 # 去重并保留顺序
                 unique_dirs = []
@@ -429,11 +455,14 @@ def handle_builtin_config_selector(
                         seen.add(key)
                         unique_dirs.append(Path(d))
 
-                # 每日自动更新配置目录（如目录为Git仓库则执行git pull，每日仅一次）
+                # 可选调试输出：查看每类的搜索目录
                 try:
-                    jutils.daily_check_git_updates([str(p) for p in unique_dirs], cat)
+                    if os.environ.get("JARVIS_DEBUG_BUILTIN_SELECTOR") == "1":
+                        PrettyOutput.print(
+                            f"DEBUG: category={cat} search_dirs=" + ", ".join(str(p) for p in unique_dirs),
+                            OutputType.INFO,
+                        )
                 except Exception:
-                    # 忽略更新过程中的所有异常，避免影响主流程
                     pass
 
                 for dir_path in unique_dirs:
@@ -681,7 +710,7 @@ def run_cli(
     non_interactive: bool = typer.Option(
         False, "-n", "--non-interactive", help="启用非交互模式：用户无法与命令交互，脚本执行超时限制为5分钟"
     ),
-    plan: bool = typer.Option(False, "--plan/--no-plan", help="启用或禁用任务规划（拆分子任务并汇总执行结果）"),
+    plan: Optional[bool] = typer.Option(None, "--plan/--no-plan", help="启用或禁用任务规划（不指定则从配置加载）"),
     web: bool = typer.Option(False, "--web", help="以 Web 模式启动，通过浏览器 WebSocket 交互"),
     web_host: str = typer.Option("127.0.0.1", "--web-host", help="Web 服务主机"),
     web_port: int = typer.Option(8765, "--web-port", help="Web 服务端口"),
@@ -1024,10 +1053,11 @@ def run_cli(
         )
         agent = agent_manager.initialize()
         # CLI 开关：启用/禁用规划（不依赖 AgentManager 支持，直接设置 Agent 属性）
-        try:
-            agent.plan = bool(plan)
-        except Exception:
-            pass
+        if plan is not None:
+            try:
+                agent.plan = bool(plan)
+            except Exception:
+                pass
 
         if web:
             try:

jarvis/jarvis_agent/run_loop.py

@@ -125,7 +125,12 @@ class AgentRunLoop:
 
                 # 检查自动完成
                 if ag.auto_complete and is_auto_complete(current_response):
-                    return ag._complete_task(auto_completed=True)
+                    # 先运行_complete_task，触发记忆整理/事件等副作用，再决定返回值
+                    result = ag._complete_task(auto_completed=True)
+                    # 若不需要summary，则将最后一条LLM输出作为返回值
+                    if not getattr(ag, "need_summary", True):
+                        return current_response
+                    return result
 
                 # 获取下一步用户输入
                 next_action = ag._get_next_user_action()

jarvis/jarvis_agent/task_planner.py

@@ -75,6 +75,7 @@ class TaskPlanner:
                 "<PLAN>\n- 子任务1\n- 子任务2\n</PLAN>\n"
                 "示例：\n"
                 "<PLAN>\n- 分析当前任务，提取需要修改的文件列表\n- 修改配置默认值并更新相关 schema\n- 更新文档中对该默认值的描述\n</PLAN>\n"
+                "注意：不要将步骤拆分太细，一般不要超过4个步骤。\n"
                 "要求：<PLAN> 内必须是有效 YAML 列表，仅包含字符串项；禁止输出任何额外解释。\n"
                 "当不需要拆分时，仅输出：\n<DONT_NEED/>\n"
                 "禁止输出任何额外解释。"

jarvis/jarvis_c2rust/__init__.py

@@ -0,0 +1,13 @@
+# -*- coding: utf-8 -*-
+"""
+Jarvis C2Rust 工具集。
+
+模块:
+- scanner: C/C++ 函数扫描器和调用图提取器，将结果存储在
+           <scan_root>/.jarvis/c2rust/functions.jsonl 和 types.jsonl 的 JSONL 文件中。
+
+用法:
+  python -m jarvis.jarvis_c2rust.scanner --root /path/to/src
+"""
+
+__all__ = ["scanner"]

jarvis/jarvis_c2rust/cli.py

@@ -0,0 +1,405 @@
+# -*- coding: utf-8 -*-
+"""
+C2Rust 独立命令行入口。
+
+提供分组式 CLI，将扫描能力作为子命令 scan 暴露：
+  - jarvis-c2rust scan --root <path> [--dot ...] [--only-dot] [--subgraphs-dir ...] [--only-subgraphs] [--png]
+
+实现策略：
+- 复用 scanner.cli 的核心逻辑，避免重复代码。
+- 使用 Typer 分组式结构，便于后续扩展更多子命令（如 analyze/export 等）。
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Optional, List
+
+import typer
+from jarvis.jarvis_c2rust.scanner import run_scan as _run_scan
+from jarvis.jarvis_c2rust.scanner import (
+    compute_translation_order_jsonl as _compute_order,
+)
+from jarvis.jarvis_c2rust.library_replacer import (
+    apply_library_replacement as _apply_library_replacement,
+)
+from jarvis.jarvis_utils.utils import init_env
+from jarvis.jarvis_c2rust.llm_module_agent import (
+    execute_llm_plan as _execute_llm_plan,
+    entries_to_yaml as _entries_to_yaml,
+)
+
+app = typer.Typer(help="C2Rust 命令行工具")
+
+# 显式定义根回调，确保为命令组而非单函数入口
+@app.callback()
+def _root():
+    """
+    C2Rust 命令行工具
+    """
+    # 不做任何处理，仅作为命令组的占位，使 'scan' 作为子命令出现
+    init_env("欢迎使用 Jarvis C2Rust 工具")
+    pass
+
+
+@app.command("scan")
+def scan(
+    dot: Optional[Path] = typer.Option(
+        None,
+        "--dot",
+        help="扫描后将引用依赖图写入 DOT 文件（或与 --only-dot 一起使用）",
+    ),
+    only_dot: bool = typer.Option(
+        False,
+        "--only-dot",
+        help="不重新扫描。读取现有数据 (JSONL) 并仅生成 DOT（需要 --dot）",
+    ),
+    subgraphs_dir: Optional[Path] = typer.Option(
+        None,
+        "--subgraphs-dir",
+        help="用于写入每个根函数引用子图 DOT 文件的目录（每个根函数一个文件）",
+    ),
+    only_subgraphs: bool = typer.Option(
+        False,
+        "--only-subgraphs",
+        help="不重新扫描。仅生成每个根函数的引用子图 DOT 文件（需要 --subgraphs-dir）",
+    ),
+) -> None:
+    """
+    进行 C/C++ 函数扫描并生成引用关系 DOT 图；PNG 渲染默认启用（无需参数）。
+    """
+    _run_scan(
+        dot=dot,
+        only_dot=only_dot,
+        subgraphs_dir=subgraphs_dir,
+        only_subgraphs=only_subgraphs,
+        png=True,
+    )
+
+@app.command("prepare")
+def prepare(
+    llm_group: Optional[str] = typer.Option(
+        None, "-g", "--llm-group", help="指定用于规划的 LLM 模型组（仅影响本次运行）"
+    ),
+) -> None:
+    """
+    使用 LLM Agent 基于根函数子图规划 Rust crate 模块结构并直接应用到磁盘。
+    需先执行: jarvis-c2rust scan 以生成数据文件（symbols.jsonl）
+    默认使用当前目录作为项目根，并从 <root>/.jarvis/c2rust/symbols.jsonl 读取数据
+    """
+    try:
+        _execute_llm_plan(apply=True, llm_group=llm_group)
+    except Exception as e:
+        typer.secho(f"[c2rust-llm-planner] 错误: {e}", fg=typer.colors.RED, err=True)
+        raise typer.Exit(code=1)
+
+
+@app.command("transpile")
+def transpile(
+    llm_group: Optional[str] = typer.Option(
+        None, "-g", "--llm-group", help="指定用于翻译的 LLM 模型组"
+    ),
+    only: Optional[str] = typer.Option(
+        None, "--only", help="仅翻译指定的函数（名称或限定名称），以逗号分隔"
+    ),
+) -> None:
+    """
+    使用转译器按扫描顺序逐个函数转译并构建修复。
+    需先执行: jarvis-c2rust scan 以生成数据文件（symbols.jsonl 与 translation_order.jsonl）
+    默认使用当前目录作为项目根，并从 <root>/.jarvis/c2rust/symbols.jsonl 读取数据。
+    未指定目标 crate 时，使用默认 <cwd>/<cwd.name>_rs。
+    """
+    try:
+        # Lazy import to avoid hard dependency if not used
+        from jarvis.jarvis_c2rust.transpiler import run_transpile as _run_transpile
+        only_list = [s.strip() for s in str(only).split(",") if s.strip()] if only else None
+        _run_transpile(
+            project_root=Path("."),
+            crate_dir=None,
+            llm_group=llm_group,
+            only=only_list,
+        )
+    except Exception as e:
+        typer.secho(f"[c2rust-transpiler] 错误: {e}", fg=typer.colors.RED, err=True)
+        raise typer.Exit(code=1)
+
+
+@app.command("lib-replace")
+def lib_replace(
+    llm_group: Optional[str] = typer.Option(
+        None, "-g", "--llm-group", help="用于评估的 LLM 模型组"
+    ),
+    root_list_file: Optional[Path] = typer.Option(
+        None, "--root-list-file", help="根列表文件：按行列出要参与评估的根符号名称或限定名（忽略空行与以#开头的注释）"
+    ),
+    root_list_syms: Optional[str] = typer.Option(
+        None, "--root-list-syms", help="根列表内联：以逗号分隔的符号名称或限定名（仅评估这些根）"
+    ),
+    disabled_libs: Optional[str] = typer.Option(
+        None, "--disabled-libs", help="禁用库列表：逗号分隔的库名（评估时禁止使用这些库）"
+    ),
+) -> None:
+    """
+    Root-list 评估模式（必须走 LLM 评估）：
+    - 必须提供根列表（--root-list-file 或 --root-list-syms，至少一种）
+    - 仅对根列表中的符号作为评估根执行 LLM 子树评估
+    - 若可替代：替换该根的 ref 为库占位，并剪除其所有子孙函数（根本身保留）
+    - 需先执行: jarvis-c2rust scan 以生成数据文件（symbols.jsonl）
+    - 默认库: std（仅用于对后续流程保持一致的默认上下文）
+    - 可选：--disabled-libs 指定评估时禁止使用的库列表（逗号分隔）
+    """
+    try:
+        data_dir = Path(".") / ".jarvis" / "c2rust"
+        curated_symbols = data_dir / "symbols.jsonl"
+        raw_symbols = data_dir / "symbols_raw.jsonl"
+        if not curated_symbols.exists() and not raw_symbols.exists():
+            typer.secho("[c2rust-lib-replace] 未找到符号数据（symbols.jsonl 或 symbols_raw.jsonl），正在执行扫描以生成数据...", fg=typer.colors.YELLOW)
+            _run_scan(dot=None, only_dot=False, subgraphs_dir=None, only_subgraphs=False, png=False)
+            if not curated_symbols.exists() and not raw_symbols.exists():
+                raise FileNotFoundError(f"未找到符号数据: {curated_symbols} 或 {raw_symbols}")
+
+        # 使用默认库: std
+        library = "std"
+
+        # 读取根列表（必填，至少提供一种来源）
+        root_names: List[str] = []
+        # 文件来源
+        if root_list_file is not None:
+            try:
+                txt = root_list_file.read_text(encoding="utf-8")
+                root_names.extend([ln.strip() for ln in txt.splitlines() if ln.strip() and not ln.strip().startswith("#")])
+            except Exception as _e:
+                typer.secho(f"[c2rust-lib-replace] 读取根列表失败: {root_list_file}: {_e}", fg=typer.colors.RED, err=True)
+                raise typer.Exit(code=1)
+        # 内联来源
+        if isinstance(root_list_syms, str) and root_list_syms.strip():
+            parts = [s.strip() for s in root_list_syms.replace("\n", ",").split(",") if s.strip()]
+            root_names.extend(parts)
+        # 去重
+        try:
+            root_names = list(dict.fromkeys(root_names))
+        except Exception:
+            root_names = sorted(list(set(root_names)))
+        if not root_names:
+            typer.secho("[c2rust-lib-replace] 错误：必须提供根列表（--root-list-file 或 --root-list-syms）。", fg=typer.colors.RED, err=True)
+            raise typer.Exit(code=2)
+
+        # 解析禁用库列表（可选）
+        disabled_list: Optional[List[str]] = None
+        if isinstance(disabled_libs, str) and disabled_libs.strip():
+            disabled_list = [s.strip() for s in disabled_libs.replace("\n", ",").split(",") if s.strip()]
+            if disabled_list:
+                typer.secho(f"[c2rust-lib-replace] 禁用库: {', '.join(disabled_list)}", fg=typer.colors.YELLOW)
+
+        # 必须走 LLM 评估：仅评估提供的根（candidates），不启用强制剪枝模式
+        ret = _apply_library_replacement(
+            db_path=Path("."),
+            library_name=library,
+            llm_group=llm_group,
+            candidates=root_names,          # 仅评估这些根
+            out_symbols_path=None,
+            out_mapping_path=None,
+            max_funcs=None,
+            disabled_libraries=disabled_list,
+        )
+        # 输出简要结果摘要（底层已写出新的符号表与可选转译顺序）
+        try:
+            order_msg = f"\n[c2rust-lib-replace] 转译顺序: {ret['order']}" if 'order' in ret else ""
+            typer.secho(
+                f"[c2rust-lib-replace] 替代映射: {ret['mapping']}\n"
+                f"[c2rust-lib-replace] 新符号表: {ret['symbols']}"
+                + order_msg,
+                fg=typer.colors.GREEN,
+            )
+        except Exception as _e:
+            typer.secho(f"[c2rust-lib-replace] 结果输出时发生非致命错误: {_e}", fg=typer.colors.YELLOW, err=True)
+    except Exception as e:
+        typer.secho(f"[c2rust-lib-replace] 错误: {e}", fg=typer.colors.RED, err=True)
+        raise typer.Exit(code=1)
+
+
+
+@app.command("collect")
+def collect(
+    files: List[Path] = typer.Argument(..., help="一个或多个 C/C++ 头文件路径（.h/.hh/.hpp/.hxx）"),
+    out: Path = typer.Option(..., "-o", "--out", help="输出文件路径（写入唯一函数名，每行一个）"),
+) -> None:
+    """
+    收集指定头文件中的函数名（使用 libclang 解析），并写入指定输出文件（每行一个）。
+    示例:
+      jarvis-c2rust collect a.h b.hpp -o funcs.txt
+    说明:
+      非头文件会被跳过（仅支持 .h/.hh/.hpp/.hxx）。
+    """
+    try:
+        from jarvis.jarvis_c2rust.collector import collect_function_names as _collect_fn_names
+        _collect_fn_names(files=files, out_path=out)
+        typer.secho(f"[c2rust-collect] 函数名已写入: {out}", fg=typer.colors.GREEN)
+    except Exception as e:
+        typer.secho(f"[c2rust-collect] 错误: {e}", fg=typer.colors.RED, err=True)
+        raise typer.Exit(code=1)
+
+@app.command("run")
+def run(
+    files: Optional[List[Path]] = typer.Option(
+        None,
+        "--files",
+        help="用于 collect 阶段的头文件列表（.h/.hh/.hpp/.hxx）；提供则先执行 collect",
+    ),
+    out: Optional[Path] = typer.Option(
+        None,
+        "-o",
+        "--out",
+        help="collect 输出函数名文件；若未提供且指定 --files 则默认为 <root>/.jarvis/c2rust/roots.txt",
+    ),
+    llm_group: Optional[str] = typer.Option(
+        None,
+        "-g",
+        "--llm-group",
+        help="用于 LLM 相关阶段（lib-replace/prepare/transpile）的模型组",
+    ),
+    root_list_file: Optional[Path] = typer.Option(
+        None,
+        "--root-list-file",
+        help="兼容占位：run 会使用 collect 的 --out 作为 lib-replace 的输入；当提供 --files 时本参数将被忽略；未提供 --files 时，本命令要求使用 --root-list-syms",
+    ),
+    root_list_syms: Optional[str] = typer.Option(
+        None,
+        "--root-list-syms",
+        help="lib-replace 的根列表内联（逗号分隔）。未提供 --files 时该参数为必填",
+    ),
+    disabled_libs: Optional[str] = typer.Option(
+        None,
+        "--disabled-libs",
+        help="lib-replace 禁用库列表（逗号分隔）",
+    ),
+) -> None:
+    """
+    依次执行流水线：collect -> scan -> lib-replace -> prepare -> transpile
+
+    约束:
+    - collect 的输出文件就是 lib-replace 的输入文件；
+      当提供 --files 时，lib-replace 将固定读取 --out（或默认值）作为根列表文件，忽略 --root-list-file
+    - 未提供 --files 时，必须通过 --root-list-syms 提供根列表
+    - scan 始终执行以确保数据完整
+    - prepare/transpile 会使用 --llm-group 指定的模型组
+    """
+    try:
+        data_dir = Path(".") / ".jarvis" / "c2rust"
+        default_roots = data_dir / "roots.txt"
+
+        # Step 1: collect（可选）
+        roots_path: Optional[Path] = None
+        if files:
+            try:
+                if out is None:
+                    out = default_roots
+                out.parent.mkdir(parents=True, exist_ok=True)
+                from jarvis.jarvis_c2rust.collector import (
+                    collect_function_names as _collect_fn_names,
+                )
+                _collect_fn_names(files=files, out_path=out)
+                typer.secho(f"[c2rust-run] collect: 函数名已写入: {out}", fg=typer.colors.GREEN)
+                roots_path = out
+            except Exception as _e:
+                typer.secho(f"[c2rust-run] collect: 错误: {_e}", fg=typer.colors.RED, err=True)
+                raise
+
+        # Step 2: scan（始终执行）
+        typer.secho("[c2rust-run] scan: 开始", fg=typer.colors.BLUE)
+        _run_scan(dot=None, only_dot=False, subgraphs_dir=None, only_subgraphs=False, png=False)
+        typer.secho("[c2rust-run] scan: 完成", fg=typer.colors.GREEN)
+
+        # Step 3: lib-replace（强制执行，依据约束获取根列表）
+        root_names: List[str] = []
+
+        if files:
+            # 约束：collect 的输出文件作为唯一文件来源
+            if not roots_path or not roots_path.exists():
+                typer.secho("[c2rust-run] lib-replace: 未找到 collect 输出文件，无法继续", fg=typer.colors.RED, err=True)
+                raise typer.Exit(code=2)
+            try:
+                txt = roots_path.read_text(encoding="utf-8")
+                root_names.extend([ln.strip() for ln in txt.splitlines() if ln.strip() and not ln.strip().startswith("#")])
+                typer.secho(f"[c2rust-run] lib-replace: 使用根列表文件: {roots_path}", fg=typer.colors.BLUE)
+            except Exception as _e:
+                typer.secho(f"[c2rust-run] lib-replace: 读取根列表失败: {roots_path}: {_e}", fg=typer.colors.RED, err=True)
+                raise
+            # 兼容参数提示
+            if root_list_file is not None:
+                typer.secho("[c2rust-run] 提示: --root-list-file 已被忽略（run 会固定使用 collect 的 --out 作为输入）", fg=typer.colors.YELLOW)
+        else:
+            # 约束：未传递 files 必须提供 --root-list-syms
+            if not (isinstance(root_list_syms, str) and root_list_syms.strip()):
+                typer.secho("[c2rust-run] 错误：未提供 --files 时，必须通过 --root-list-syms 指定根列表（逗号分隔）", fg=typer.colors.RED, err=True)
+                raise typer.Exit(code=2)
+            parts = [s.strip() for s in root_list_syms.replace("\n", ",").split(",") if s.strip()]
+            root_names.extend(parts)
+
+        # 去重并校验非空
+        try:
+            root_names = list(dict.fromkeys(root_names))
+        except Exception:
+            root_names = sorted(list(set(root_names)))
+        if not root_names:
+            typer.secho("[c2rust-run] lib-replace: 根列表为空，无法继续", fg=typer.colors.RED, err=True)
+            raise typer.Exit(code=2)
+
+        # 可选禁用库列表
+        disabled_list: Optional[List[str]] = None
+        if isinstance(disabled_libs, str) and disabled_libs.strip():
+            disabled_list = [s.strip() for s in disabled_libs.replace("\n", ",").split(",") if s.strip()]
+            if disabled_list:
+                typer.secho(f"[c2rust-run] lib-replace: 禁用库: {', '.join(disabled_list)}", fg=typer.colors.YELLOW)
+
+        # 执行 lib-replace（默认库 std）
+        library = "std"
+        typer.secho(f"[c2rust-run] lib-replace: 开始（库: {library}，根数: {len(root_names)}）", fg=typer.colors.BLUE)
+        ret = _apply_library_replacement(
+            db_path=Path("."),
+            library_name=library,
+            llm_group=llm_group,
+            candidates=root_names,
+            out_symbols_path=None,
+            out_mapping_path=None,
+            max_funcs=None,
+            disabled_libraries=disabled_list,
+        )
+        try:
+            order_msg = f"\n[c2rust-run] lib-replace: 转译顺序: {ret['order']}" if 'order' in ret else ""
+            typer.secho(
+                f"[c2rust-run] lib-replace: 替代映射: {ret['mapping']}\n"
+                f"[c2rust-run] lib-replace: 新符号表: {ret['symbols']}"
+                + order_msg,
+                fg=typer.colors.GREEN,
+            )
+        except Exception as _e:
+            typer.secho(f"[c2rust-run] lib-replace: 结果输出时发生非致命错误: {_e}", fg=typer.colors.YELLOW, err=True)
+
+        # Step 4: prepare
+        typer.secho("[c2rust-run] prepare: 开始", fg=typer.colors.BLUE)
+        _execute_llm_plan(apply=True, llm_group=llm_group)
+        typer.secho("[c2rust-run] prepare: 完成", fg=typer.colors.GREEN)
+
+        # Step 5: transpile
+        typer.secho("[c2rust-run] transpile: 开始", fg=typer.colors.BLUE)
+        from jarvis.jarvis_c2rust.transpiler import run_transpile as _run_transpile
+        _run_transpile(
+            project_root=Path("."),
+            crate_dir=None,
+            llm_group=llm_group,
+            only=None,
+        )
+        typer.secho("[c2rust-run] transpile: 完成", fg=typer.colors.GREEN)
+    except Exception as e:
+        typer.secho(f"[c2rust-run] 错误: {e}", fg=typer.colors.RED, err=True)
+        raise typer.Exit(code=1)
+
+
+def main() -> None:
+    """主入口"""
+    app()
+
+
+if __name__ == "__main__":
+    main()