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

jarvis/jarvis_c2rust/transpiler_codegen.py

@@ -0,0 +1,204 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import List
+from typing import cast
+
+
+from jarvis.jarvis_c2rust.models import FnRecord
+
+
+def build_generate_impl_prompt(
+    self,
+    rec: FnRecord,
+    c_code: str,
+    module: str,
+    rust_sig: str,
+    unresolved: List[str],
+) -> str:
+    """
+    从 Transpiler._build_generate_impl_prompt 提取出的实现，保持签名与逻辑完全一致。
+    """
+    symbols_path = str((self.data_dir / "symbols.jsonl").resolve())
+    is_root = self._is_root_symbol(rec)
+    requirement_lines = [
+        f"目标：在 {module} 中，使用 TDD 方法为 C 函数 {rec.qname or rec.name} 生成 Rust 实现。",
+        f"函数签名：{rust_sig}",
+        f"crate 目录：{self.crate_dir.resolve()}",
+        f"C 工程目录：{self.project_root.resolve()}",
+        *(
+            ["根符号要求：必须使用 `pub` 关键字，模块必须在 src/lib.rs 中导出"]
+            if is_root
+            else []
+        ),
+        "",
+        "【TDD 流程】",
+        "1. Red：先写测试（#[cfg(test)] mod tests），基于 C 函数行为设计测试用例",
+        "2. Green：编写实现使测试通过，确保与 C 语义等价",
+        "3. Refactor：优化代码，保持测试通过",
+        "",
+        "【核心要求】",
+        "- 先写测试再写实现，测试必须可编译通过",
+        "- 禁止使用 todo!/unimplemented!，必须实现完整功能",
+        "- 使用 Rust 原生类型（i32/u32、&str/String、&[T]/&mut [T]、Result<T,E>），避免 C 风格类型",
+        '- 禁止使用 extern "C"，使用标准 Rust 调用约定',
+        "- 保持最小变更，避免无关重构",
+        "- 注释使用中文，禁止 use ...::* 通配导入",
+        "- 资源释放类函数（fclose/free 等）可通过 RAII 自动管理，提供空实现并在文档中说明",
+        *(
+            [f"- 禁用库：{', '.join(self.disabled_libraries)}"]
+            if self.disabled_libraries
+            else []
+        ),
+        "",
+        "【依赖处理】",
+        "- 检查依赖函数是否已实现，未实现的需一并补齐（遵循 TDD：先测试后实现）",
+        "- 使用 read_symbols/read_code 获取 C 源码",
+        "- 优先处理底层依赖，确保所有测试通过",
+        "",
+        "【工具】",
+        f'- read_symbols: {{"symbols_file": "{symbols_path}", "symbols": [...]}}',
+        "- read_code: 读取 C 源码或 Rust 模块",
+        "",
+        *([f"未转换符号：{', '.join(unresolved)}"] if unresolved else []),
+        "",
+        "C 源码：",
+        "<C_SOURCE>",
+        c_code,
+        "</C_SOURCE>",
+        "",
+        "签名参考：",
+        json.dumps(
+            {
+                "signature": getattr(rec, "signature", ""),
+                "params": getattr(rec, "params", None),
+            },
+            ensure_ascii=False,
+            indent=2,
+        ),
+        "",
+        "仅输出补丁，不要解释。",
+    ]
+    # 若存在库替代上下文，则附加到实现提示中，便于生成器参考（多库组合、参考API、备注等）
+    librep_ctx = None
+    try:
+        librep_ctx = getattr(rec, "lib_replacement", None)
+    except Exception:
+        librep_ctx = None
+    if isinstance(librep_ctx, dict) and librep_ctx:
+        requirement_lines.extend(
+            [
+                "",
+                "库替代上下文（若存在）：",
+                json.dumps(librep_ctx, ensure_ascii=False, indent=2),
+                "",
+            ]
+        )
+    # 添加编译参数（如果存在）
+    compile_flags = self._extract_compile_flags(rec.file)
+    if compile_flags:
+        requirement_lines.extend(
+            [
+                "",
+                "C文件编译参数（来自 compile_commands.json）：",
+                compile_flags,
+                "",
+            ]
+        )
+    prompt = "\n".join(requirement_lines)
+    return cast(str, self._append_additional_notes(prompt))
+
+
+def codeagent_generate_impl(
+    self,
+    rec: FnRecord,
+    c_code: str,
+    module: str,
+    rust_sig: str,
+    unresolved: List[str],
+) -> None:
+    """
+    从 Transpiler._codeagent_generate_impl 提取出的实现，保持逻辑一致。
+    """
+    # 构建提示词
+    prompt = build_generate_impl_prompt(self, rec, c_code, module, rust_sig, unresolved)
+
+    # 确保目标模块文件存在（提高补丁应用与实现落盘的确定性）
+    try:
+        mp = Path(module)
+        if not mp.is_absolute():
+            mp = (self.crate_dir / module).resolve()
+        mp.parent.mkdir(parents=True, exist_ok=True)
+        if not mp.exists():
+            try:
+                mp.write_text(
+                    "// Auto-created by c2rust transpiler\n", encoding="utf-8"
+                )
+                from jarvis.jarvis_utils.output import PrettyOutput
+
+                PrettyOutput.auto_print(
+                    f"✅ [c2rust-transpiler][gen] auto-created module file: {mp}",
+                )
+            except Exception:
+                pass
+    except Exception:
+        pass
+
+    # 由于 transpile() 开始时已切换到 crate 目录，此处无需再次切换
+    # 记录运行前的 commit
+    before_commit = self._get_crate_commit_hash()
+    agent = self._get_code_agent()
+    agent.run(
+        self._compose_prompt_with_context(prompt),
+        prefix="[c2rust-transpiler][gen]",
+        suffix="",
+    )
+
+    # 检测并处理测试代码删除
+    if self._check_and_handle_test_deletion(before_commit, agent):
+        # 如果回退了，需要重新运行 agent
+        from jarvis.jarvis_utils.output import PrettyOutput
+
+        PrettyOutput.auto_print(
+            "⚠️ [c2rust-transpiler][gen] 检测到测试代码删除问题，已回退，重新运行 agent",
+        )
+        before_commit = self._get_crate_commit_hash()
+        agent.run(
+            self._compose_prompt_with_context(prompt),
+            prefix="[c2rust-transpiler][gen][retry]",
+            suffix="",
+        )
+        # 再次检测
+        if self._check_and_handle_test_deletion(before_commit, agent):
+            PrettyOutput.auto_print(
+                "❌ [c2rust-transpiler][gen] 再次检测到测试代码删除问题，已回退",
+            )
+
+    # 如果是根符号，确保其模块在 lib.rs 中被暴露
+    if self._is_root_symbol(rec):
+        try:
+            mp = Path(module)
+            crate_root = self.crate_dir.resolve()
+            rel = (
+                mp.resolve().relative_to(crate_root)
+                if mp.is_absolute()
+                else Path(module)
+            )
+            rel_s = str(rel).replace("\\", "/")
+            if rel_s.startswith("./"):
+                rel_s = rel_s[2:]
+            if rel_s.startswith("src/"):
+                parts = rel_s[len("src/") :].strip("/").split("/")
+                if parts and parts[0]:
+                    top_mod = parts[0]
+                    # 过滤掉 "mod" 关键字和 .rs 文件
+                    if top_mod != "mod" and not top_mod.endswith(".rs"):
+                        self._ensure_top_level_pub_mod(top_mod)
+                        from jarvis.jarvis_utils.output import PrettyOutput
+
+                        PrettyOutput.auto_print(
+                            f"📋 [c2rust-transpiler][gen] 根符号 {rec.qname or rec.name} 的模块 {top_mod} 已在 lib.rs 中暴露",
+                        )
+        except Exception:
+            pass

jarvis/jarvis_c2rust/transpiler_compile.py

@@ -0,0 +1,146 @@
+# -*- coding: utf-8 -*-
+"""
+编译命令处理模块
+"""
+
+import json
+from pathlib import Path
+from typing import Any
+from typing import Dict
+from typing import List
+from typing import Optional
+from typing import Union
+
+from jarvis.jarvis_utils.output import PrettyOutput
+
+
+class CompileCommandsManager:
+    """编译命令管理器"""
+
+    def __init__(self, project_root: Path) -> None:
+        self.project_root = project_root
+        self._compile_commands_cache: Optional[List[Dict[str, Any]]] = None
+        self._compile_commands_path: Optional[Path] = None
+
+    def _find_compile_commands(self) -> Optional[Path]:
+        """
+        查找 compile_commands.json 文件。
+        搜索顺序：
+        1. project_root / compile_commands.json
+        2. project_root / build / compile_commands.json
+        3. project_root 的父目录及向上查找（最多向上3层）
+        """
+        # 首先在 project_root 下查找
+        candidates = [
+            self.project_root / "compile_commands.json",
+            self.project_root / "build" / "compile_commands.json",
+        ]
+        # 向上查找（最多3层）
+        current = self.project_root.parent
+        for _ in range(3):
+            if current and current.exists():
+                candidates.append(current / "compile_commands.json")
+                current = current.parent
+            else:
+                break
+
+        for path in candidates:
+            if path.exists() and path.is_file():
+                return path.resolve()
+        return None
+
+    def load_compile_commands(self) -> Optional[List[Dict[str, Any]]]:
+        """
+        加载 compile_commands.json 文件。
+        如果已缓存，直接返回缓存结果。
+        """
+        if self._compile_commands_cache is not None:
+            return self._compile_commands_cache
+
+        compile_commands_path = self._find_compile_commands()
+        if compile_commands_path is None:
+            self._compile_commands_cache = []
+            self._compile_commands_path = None
+            return None
+
+        try:
+            with compile_commands_path.open("r", encoding="utf-8") as f:
+                data = json.load(f)
+                if isinstance(data, list):
+                    self._compile_commands_cache = data
+                    self._compile_commands_path = compile_commands_path
+                    PrettyOutput.auto_print(
+                        f"📋 [c2rust-transpiler][compile_commands] 已加载: {compile_commands_path} ({len(data)} 条记录)"
+                    )
+                    return data
+        except Exception as e:
+            PrettyOutput.auto_print(
+                f"❌ [c2rust-transpiler][compile_commands] 加载失败: {compile_commands_path}: {e}"
+            )
+            self._compile_commands_cache = []
+            self._compile_commands_path = None
+            return None
+
+        self._compile_commands_cache = []
+        self._compile_commands_path = None
+        return None
+
+    def extract_compile_flags(self, c_file_path: Union[str, Path]) -> Optional[str]:
+        """
+        从 compile_commands.json 中提取指定 C 文件的编译参数。
+
+        如果 compile_commands.json 中存在 arguments 字段，则用空格连接该数组并返回。
+        如果只有 command 字段，则直接返回 command 字符串。
+
+        返回格式：
+        - 如果存在 arguments：用空格连接的参数字符串，例如 "-I/usr/include -DDEBUG"
+        - 如果只有 command：完整的编译命令字符串，例如 "gcc -I/usr/include -DDEBUG file.c"
+
+        如果未找到或解析失败，返回 None。
+        """
+        compile_commands = self.load_compile_commands()
+        if not compile_commands:
+            return None
+
+        # 规范化目标文件路径
+        try:
+            target_path = Path(c_file_path)
+            if not target_path.is_absolute():
+                target_path = (self.project_root / target_path).resolve()
+            target_path = target_path.resolve()
+        except Exception:
+            return None
+
+        # 查找匹配的编译命令
+        for entry in compile_commands:
+            if not isinstance(entry, dict):
+                continue  # type: ignore
+
+            entry_file = entry.get("file")
+            if not entry_file:
+                continue
+
+            try:
+                entry_path = Path(entry_file)
+                if not entry_path.is_absolute() and entry.get("directory"):
+                    directory = entry.get("directory")
+                    if directory is not None:
+                        entry_path = (Path(directory) / entry_path).resolve()
+                entry_path = entry_path.resolve()
+
+                # 路径匹配（支持相对路径和绝对路径）
+                if entry_path == target_path:
+                    # 如果存在 arguments，用空格连接并返回
+                    arguments = entry.get("arguments")
+                    if isinstance(arguments, list):
+                        # 过滤掉空字符串，然后用空格连接
+                        args = [str(arg) for arg in arguments if arg]
+                        return " ".join(args) if args else None
+                    # 如果只有 command，直接返回 command 字符串
+                    elif entry.get("command"):
+                        command = entry.get("command", "")
+                        return command if command else None
+            except Exception:
+                continue
+
+        return None

jarvis/jarvis_c2rust/transpiler_config.py

@@ -0,0 +1,178 @@
+# -*- coding: utf-8 -*-
+"""
+配置和进度管理模块
+"""
+
+import json
+from pathlib import Path
+from typing import Any
+from typing import Dict
+
+from jarvis.jarvis_utils.output import PrettyOutput
+from jarvis.jarvis_c2rust.constants import CONFIG_JSON
+from jarvis.jarvis_c2rust.models import FnRecord
+from jarvis.jarvis_c2rust.utils import read_json
+from jarvis.jarvis_c2rust.utils import write_json
+
+
+class ConfigManager:
+    """配置和进度管理器"""
+
+    def __init__(self, data_dir: Path, progress_path: Path) -> None:
+        self.data_dir = data_dir
+        self.progress_path = progress_path
+        self.progress: Dict[str, Any] = read_json(
+            self.progress_path, {"current": None, "converted": []}
+        )
+
+    def save_progress(self) -> None:
+        """保存进度，使用原子性写入"""
+        write_json(self.progress_path, self.progress)
+
+    def load_config(self) -> Dict[str, Any]:
+        """
+        从独立的配置文件加载配置。
+        如果配置文件不存在，尝试从 progress.json 迁移配置（向后兼容）。
+        """
+        config_path = self.data_dir / CONFIG_JSON
+        default_config = {
+            "root_symbols": [],
+            "disabled_libraries": [],
+            "additional_notes": "",
+        }
+
+        # 尝试从配置文件读取
+        if config_path.exists():
+            config = read_json(config_path, default_config)
+            if isinstance(config, dict):
+                # 确保包含所有必需的键（向后兼容）
+                if "additional_notes" not in config:
+                    config["additional_notes"] = ""
+                return config
+
+        # 向后兼容：如果配置文件不存在，尝试从 progress.json 迁移
+        progress_config = self.progress.get("config", {})
+        if progress_config:
+            # 迁移配置到独立文件
+            migrated_config = {
+                "root_symbols": progress_config.get("root_symbols", []),
+                "disabled_libraries": progress_config.get("disabled_libraries", []),
+                "additional_notes": progress_config.get("additional_notes", ""),
+            }
+            write_json(config_path, migrated_config)
+            PrettyOutput.auto_print(
+                f"⚠️ [c2rust-transpiler][config] 已从 progress.json 迁移配置到 {config_path}"
+            )
+            return migrated_config
+
+        return default_config
+
+    def save_config(
+        self,
+        root_symbols: list,
+        disabled_libraries: list,
+        additional_notes: str,
+    ) -> None:
+        """保存配置到独立的配置文件"""
+        config_path = self.data_dir / CONFIG_JSON
+        config = {
+            "root_symbols": root_symbols,
+            "disabled_libraries": disabled_libraries,
+            "additional_notes": additional_notes,
+        }
+        write_json(config_path, config)
+
+    def load_order_index(
+        self,
+        order_jsonl: Path,
+        fn_index_by_id: Dict[int, FnRecord],
+        fn_name_to_id: Dict[str, int],
+    ) -> None:
+        """
+        从自包含的 order.jsonl 中加载所有 records，建立：
+        - fn_index_by_id: id -> FnRecord
+        - fn_name_to_id: name/qname -> id
+        若同一 id 多次出现，首次记录为准。
+        """
+        fn_index_by_id.clear()
+        fn_name_to_id.clear()
+        PrettyOutput.auto_print(
+            f"📊 [c2rust-transpiler][index] 正在加载翻译顺序索引: {order_jsonl}"
+        )
+        try:
+            with order_jsonl.open("r", encoding="utf-8") as f:
+                for ln in f:
+                    ln = ln.strip()
+                    if not ln:
+                        continue
+                    try:
+                        obj = json.loads(ln)
+                    except Exception:
+                        continue
+                    # 仅支持新格式：items
+                    recs = obj.get("items")
+                    if not isinstance(recs, list):
+                        continue
+                    for r in recs:
+                        if not isinstance(r, dict):
+                            continue
+                        # 构建 FnRecord
+                        try:
+                            rec_id = r.get("id")
+                            if rec_id is None:
+                                continue
+                            fid = int(rec_id)
+                        except Exception:
+                            continue
+                        if fid in fn_index_by_id:
+                            # 已收录
+                            continue
+                        nm = r.get("name") or ""
+                        qn = r.get("qualified_name") or ""
+                        fp = r.get("file") or ""
+                        refs = r.get("ref")
+                        if not isinstance(refs, list):
+                            refs = []
+                        refs = [c for c in refs if isinstance(c, str) and c]
+                        sr = int(r.get("start_line") or 0)
+                        sc = int(r.get("start_col") or 0)
+                        er = int(r.get("end_line") or 0)
+                        ec = int(r.get("end_col") or 0)
+                        sg = r.get("signature") or ""
+                        rt = r.get("return_type") or ""
+                        pr = (
+                            r.get("params")
+                            if isinstance(r.get("params"), list)
+                            else None
+                        )
+                        lr = (
+                            r.get("lib_replacement")
+                            if isinstance(r.get("lib_replacement"), dict)
+                            else None
+                        )
+                        rec = FnRecord(
+                            id=fid,
+                            name=nm,
+                            qname=qn,
+                            file=fp,
+                            start_line=sr,
+                            start_col=sc,
+                            end_line=er,
+                            end_col=ec,
+                            refs=refs,
+                            signature=str(sg or ""),
+                            return_type=str(rt or ""),
+                            params=pr,
+                            lib_replacement=lr,
+                        )
+                        fn_index_by_id[fid] = rec
+                        if nm:
+                            fn_name_to_id.setdefault(nm, fid)
+                        if qn:
+                            fn_name_to_id.setdefault(qn, fid)
+        except Exception:
+            # 若索引构建失败，保持为空，后续流程将跳过
+            pass
+        PrettyOutput.auto_print(
+            f"✅ [c2rust-transpiler][index] 索引构建完成: ids={len(fn_index_by_id)} names={len(fn_name_to_id)}"
+        )

jarvis/jarvis_c2rust/transpiler_context.py

@@ -0,0 +1,122 @@
+# -*- coding: utf-8 -*-
+"""
+上下文收集模块
+"""
+
+from pathlib import Path
+from typing import Any
+from typing import Dict
+from typing import List
+
+from jarvis.jarvis_c2rust.models import FnRecord
+
+
+class ContextCollector:
+    """上下文收集器"""
+
+    def __init__(
+        self,
+        project_root: Path,
+        fn_index_by_id: Dict[int, FnRecord],
+        fn_name_to_id: Dict[str, int],
+        symbol_map: Any,  # _SymbolMapJsonl
+    ) -> None:
+        self.project_root = project_root
+        self.fn_index_by_id = fn_index_by_id
+        self.fn_name_to_id = fn_name_to_id
+        self.symbol_map = symbol_map
+
+    def read_source_span(self, rec: FnRecord) -> str:
+        """按起止行读取源码片段（忽略列边界，尽量完整）"""
+        try:
+            p = Path(rec.file)
+            if not p.is_absolute():
+                p = (self.project_root / p).resolve()
+            if not p.exists():
+                return ""
+            lines = p.read_text(encoding="utf-8", errors="replace").splitlines()
+            s = max(1, int(rec.start_line or 1))
+            e = min(len(lines), max(int(rec.end_line or s), s))
+            chunk = "\n".join(lines[s - 1 : e])
+            return chunk
+        except Exception:
+            return ""
+
+    def collect_callees_context(self, rec: FnRecord) -> List[Dict[str, Any]]:
+        """
+        生成被引用符号上下文列表（不区分函数与类型）：
+        - 若已转译：提供 {name, qname, translated: true, rust_module, rust_symbol, ambiguous?}
+        - 若未转译但存在扫描记录：提供 {name, qname, translated: false, file, start_line, end_line}
+        - 若仅名称：提供 {name, qname, translated: false}
+        注：若存在同名映射多条记录（重载/同名符号），此处标记 ambiguous=true，并选择最近一条作为提示。
+        """
+        ctx: List[Dict[str, Any]] = []
+        for callee in rec.refs or []:
+            entry: Dict[str, Any] = {"name": callee, "qname": callee}
+            # 已转译映射
+            if self.symbol_map.has_symbol(callee):
+                recs = self.symbol_map.get(callee)
+                m = recs[-1] if recs else None
+                entry.update(
+                    {
+                        "translated": True,
+                        "rust_module": (m or {}).get("module"),
+                        "rust_symbol": (m or {}).get("rust_symbol"),
+                    }
+                )
+                if len(recs) > 1:
+                    entry["ambiguous"] = True
+                ctx.append(entry)
+                continue
+            # 使用 order 索引按名称解析ID（函数或类型）
+            cid = self.fn_name_to_id.get(callee)
+            if cid:
+                crec = self.fn_index_by_id.get(cid)
+                if crec:
+                    entry.update(
+                        {
+                            "translated": False,
+                            "file": crec.file,
+                            "start_line": crec.start_line,
+                            "end_line": crec.end_line,
+                        }
+                    )
+            else:
+                entry.update({"translated": False})
+            ctx.append(entry)
+        return ctx
+
+    def untranslated_callee_symbols(self, rec: FnRecord) -> List[str]:
+        """
+        返回尚未转换的被调函数符号（使用扫描记录中的名称/限定名作为键）
+        """
+        syms: List[str] = []
+        for callee in rec.refs or []:
+            if not self.symbol_map.has_symbol(callee):
+                syms.append(callee)
+        # 去重
+        try:
+            syms = list(dict.fromkeys(syms))
+        except Exception:
+            syms = sorted(list(set(syms)))
+        return syms
+
+    def append_additional_notes(self, prompt: str, additional_notes: str) -> str:
+        """
+        在提示词末尾追加附加说明（如果存在）。
+
+        Args:
+            prompt: 原始提示词
+            additional_notes: 附加说明
+
+        Returns:
+            追加了附加说明的提示词
+        """
+        if additional_notes and additional_notes.strip():
+            return (
+                prompt
+                + "\n\n"
+                + "【附加说明（用户自定义）】\n"
+                + additional_notes.strip()
+            )
+        return prompt