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

jarvis/jarvis_c2rust/llm_module_agent_prompts.py

@@ -0,0 +1,268 @@
+# -*- coding: utf-8 -*-
+"""LLM 模块规划 Agent 的提示词构建逻辑。"""
+
+import json
+from pathlib import Path
+from typing import Any
+from typing import Callable
+from typing import Dict
+from typing import List
+
+from jarvis.jarvis_c2rust.llm_module_agent_utils import resolve_created_dir
+from jarvis.jarvis_utils.jsonnet_compat import loads as json_loads
+from jarvis.jarvis_utils.tag import ot
+
+
+class PromptBuilder:
+    """提示词构建器。"""
+
+    def __init__(
+        self,
+        project_root: Path,
+        loader: Any,  # GraphLoader
+        crate_name_func: Callable[[], str],
+        has_original_main_func: Callable[[], bool],
+        append_additional_notes_func: Callable[[str], str],
+    ):
+        self.project_root = project_root
+        self.loader = loader
+        self.crate_name_func = crate_name_func
+        self.has_original_main_func = has_original_main_func
+        self.append_additional_notes = append_additional_notes_func
+
+    def build_roots_context_from_order(self) -> List[Dict[str, Any]]:
+        """
+        基于 translation_order.jsonl 生成用于规划的上下文：
+        - 以每个 step 的 roots 标签为分组键（通常每步一个 root 标签）
+        - 函数列表来自每步的 items 中的符号 'name' 字段，按 root 聚合去重
+        - 跳过无 roots 标签的 residual 步骤（仅保留明确 root 的上下文）
+        - 若最终未收集到任何 root 组，则回退为单组 'project'，包含所有 items 的函数名集合
+        """
+        order_path = (
+            self.project_root / ".jarvis" / "c2rust" / "translation_order.jsonl"
+        )
+        if not order_path.exists():
+            raise FileNotFoundError(f"未找到 translation_order.jsonl: {order_path}")
+
+        def _deduplicate_names(names: List[str]) -> List[str]:
+            """去重并排序函数名列表"""
+            try:
+                return sorted(list(dict.fromkeys(names)))
+            except (TypeError, ValueError):
+                return sorted(list(set(names)))
+
+        def _extract_names_from_items(items: List[Any]) -> List[str]:
+            """从 items 中提取函数名"""
+            names: List[str] = []
+            for it in items:
+                if isinstance(it, dict):
+                    nm = it.get("name") or ""
+                    if isinstance(nm, str) and nm.strip():
+                        names.append(str(nm).strip())
+            return names
+
+        groups: Dict[str, List[str]] = {}
+        all_names_fallback: List[str] = []  # 用于回退场景
+
+        try:
+            with order_path.open("r", encoding="utf-8") as f:
+                for line in f:
+                    line = line.strip()
+                    if not line:
+                        continue
+                    try:
+                        obj = json_loads(line)
+                    except Exception:
+                        continue
+
+                    roots = obj.get("roots") or []
+                    items = obj.get("items") or []
+                    if not isinstance(items, list) or not items:
+                        continue
+
+                    # 提取所有函数名（用于回退场景）
+                    item_names = _extract_names_from_items(items)
+                    all_names_fallback.extend(item_names)
+
+                    # 提取 root 标签
+                    root_labels = [
+                        str(r).strip()
+                        for r in roots
+                        if isinstance(r, str) and str(r).strip()
+                    ]
+                    if not root_labels:
+                        continue
+
+                    # 去重 step_names
+                    step_names = _deduplicate_names(item_names)
+                    if not step_names:
+                        continue
+
+                    # 按 root 聚合
+                    for r in root_labels:
+                        groups.setdefault(r, []).extend(step_names)
+        except (OSError, IOError) as e:
+            raise RuntimeError(f"读取 translation_order.jsonl 时发生错误: {e}") from e
+
+        contexts: List[Dict[str, Any]] = []
+        for root_label, names in groups.items():
+            names = _deduplicate_names(names)
+            contexts.append({"root_function": root_label, "functions": sorted(names)})
+
+        # 回退：如果没有任何 root 组，使用所有 items 作为单组 'project'
+        if not contexts:
+            all_names = _deduplicate_names(all_names_fallback)
+            if all_names:
+                contexts.append(
+                    {"root_function": "project", "functions": sorted(all_names)}
+                )
+
+        return contexts
+
+    def build_user_prompt(self, roots_context: List[Dict[str, Any]]) -> str:
+        """
+        主对话阶段：传入上下文，不给出输出要求，仅用于让模型获取信息并触发进入总结阶段。
+        请模型仅输出 {ot('!!!COMPLETE!!!')} 以进入总结（summary）阶段。不要输出其他任何内容，任务总结将会在后面的交互中被询问。
+        """
+        crate_name = self.crate_name_func()
+        has_main = self.has_original_main_func()
+        created_dir = resolve_created_dir(self.project_root)
+        context_json = json.dumps(
+            {
+                "meta": {
+                    "crate_name": crate_name,
+                    "main_present": has_main,
+                    "crate_dir": str(created_dir),
+                },
+                "roots": roots_context,
+            },
+            ensure_ascii=False,
+            indent=2,
+        )
+        prompt = f"""
+下面提供了项目的调用图上下文（JSON），请先通读理解，不要输出任何规划或JSON内容：
+<context>
+{context_json}
+</context>
+
+如果已准备好进入总结阶段以生成完整输出，请仅输出：{ot("!!!COMPLETE!!!")}，不要输出其他任何内容。任务总结将会在后面的交互中被询问。
+""".strip()
+        return self.append_additional_notes(prompt)
+
+    def build_system_prompt(self) -> str:
+        """
+        系统提示：描述如何基于依赖关系进行 crate 规划的原则（不涉及对话流程或输出方式）
+        """
+        crate_name = self.crate_name_func()
+        prompt = (
+            "你是资深 Rust 架构师。任务：根据给定的函数级调用关系（仅包含 root_function 及其可达的函数名列表），为目标项目规划合理的 Rust crate 结构。\n"
+            "\n"
+            "规划原则：\n"
+            "- 根导向：以每个 root_function 为边界组织顶层模块，形成清晰的入口与责任范围。\n"
+            "- 内聚优先：按调用内聚性拆分子模块，使强相关函数位于同一子模块，减少跨模块耦合。\n"
+            "- 去环与分层：尽量消除循环依赖；遵循由上到下的调用方向，保持稳定依赖方向与层次清晰。\n"
+            "- 共享抽取：被多个 root 使用的通用能力抽取到 common/ 或 shared/ 模块，避免重复与交叉依赖。\n"
+            "- 边界隔离：将平台/IO/外设等边界能力独立到 adapter/ 或 ffi/ 等模块（如存在）。\n"
+            "- 命名规范：目录/文件采用小写下划线；模块名简洁可读，避免特殊字符与过长名称。\n"
+            "- 可演进性：模块粒度适中，保留扩展点，便于后续重构与逐步替换遗留代码。\n"
+            "- 模块组织：每个目录的 mod.rs 声明其子目录与 .rs 子模块；顶层 lib.rs 汇聚导出主要模块与公共能力。\n"
+            "- 入口策略（务必遵循，bin 仅做入口，功能尽量在 lib 中实现）：\n"
+            "  * 若原始项目包含 main 函数：不要生成 src/main.rs；使用 src/bin/"
+            + crate_name
+            + ".rs 作为唯一可执行入口，并在其中仅保留最小入口逻辑（调用库层）；共享代码放在 src/lib.rs；\n"
+            "  * 若原始项目不包含 main 函数：不要生成任何二进制入口（不创建 src/main.rs 或 src/bin/），仅生成 src/lib.rs；\n"
+            "  * 多可执行仅在确有多个清晰入口时才使用 src/bin/<name>.rs；每个 bin 文件仅做入口，尽量调用库；\n"
+            "  * 二进制命名：<name> 使用小写下划线，体现入口意图，避免与模块/文件重名。\n"
+        )
+        return self.append_additional_notes(prompt)
+
+    def build_summary_prompt(self, roots_context: List[Dict[str, Any]]) -> str:
+        """
+        总结阶段：只输出目录结构的 JSON。
+        要求：
+        - 仅输出一个 <PROJECT> 块
+        - <PROJECT> 与 </PROJECT> 之间必须是可解析的 JSON 数组
+        - 目录以对象表示，键为 '目录名/'，值为子项数组；文件为字符串
+        - 块外不得有任何字符（包括空行、注释、Markdown、解释文字、schema等）
+        - 不要输出 crate 名称或其他多余字段
+        """
+        has_main = self.has_original_main_func()
+        crate_name = self.crate_name_func()
+        guidance_common = """
+输出规范：
+- 只输出一个 <PROJECT> 块
+- 块外不得有任何字符（包括空行、注释、Markdown 等）
+- 块内必须是 JSON 数组：
+  - 目录项使用对象表示，键为 '<name>/'，值为子项数组
+  - 文件为字符串项（例如 "lib.rs"）
+- 不要创建与入口无关的占位文件
+- 支持jsonnet语法（如尾随逗号、注释、||| 或 ``` 分隔符多行字符串等）
+""".strip()
+        if has_main:
+            entry_rule = f"""
+入口约定（基于原始项目存在 main）：
+- 必须包含 src/lib.rs；
+- 不要包含 src/main.rs；
+- 必须包含 src/bin/{crate_name}.rs，作为唯一可执行入口（仅做入口，调用库逻辑）；
+- 如无明确多个入口，不要创建额外 bin 文件。
+正确示例（JSON格式）：
+<PROJECT>
+[
+  "Cargo.toml",
+  {{
+    "src/": [
+      "lib.rs",
+      {{
+        "bin/": [
+          "{crate_name}.rs"
+        ]
+      }}
+    ]
+  }}
+]
+</PROJECT>
+""".strip()
+        else:
+            entry_rule = """
+入口约定（基于原始项目不存在 main）：
+- 必须包含 src/lib.rs；
+- 不要包含 src/main.rs；
+- 不要包含 src/bin/ 目录。
+正确示例（JSON格式）：
+<PROJECT>
+[
+  "Cargo.toml",
+  {
+    "src/": [
+      "lib.rs"
+    ]
+  }
+]
+</PROJECT>
+""".strip()
+        guidance = f"{guidance_common}\n{entry_rule}"
+        prompt = f"""
+请基于之前对话中已提供的<context>信息，生成总结输出（项目目录结构的 JSON）。严格遵循以下要求：
+
+{guidance}
+
+你的输出必须仅包含以下单个块（用项目的真实目录结构替换块内内容）：
+<PROJECT>
+[...]
+</PROJECT>
+""".strip()
+        return self.append_additional_notes(prompt)
+
+    def build_retry_summary_prompt(
+        self, base_summary_prompt: str, error_reason: str
+    ) -> str:
+        """
+        在原始 summary_prompt 基础上，附加错误反馈，要求严格重试。
+        """
+        feedback = (
+            "\n\n[格式校验失败，必须重试]\n"
+            f"- 失败原因：{error_reason}\n"
+            '- 请严格遵循上述"输出规范"与"入口约定"，重新输出；\n'
+            "- 仅输出一个 <PROJECT> 块，块内为可解析的 JSON 数组；块外不得有任何字符。\n"
+        )
+        return base_summary_prompt + feedback

jarvis/jarvis_c2rust/llm_module_agent_types.py

@@ -0,0 +1,57 @@
+# -*- coding: utf-8 -*-
+"""LLM 模块规划 Agent 的数据类型和工具函数。"""
+
+from dataclasses import dataclass
+from typing import List
+
+
+@dataclass
+class FnMeta:
+    """函数元数据。"""
+
+    id: int
+    name: str
+    qname: str
+    signature: str
+    file: str
+    refs: List[str]
+
+    @property
+    def label(self) -> str:
+        """返回函数的标签（用于显示）。"""
+        base = self.qname or self.name or f"fn_{self.id}"
+        if self.signature and self.signature != base:
+            return f"{base}\n{self.signature}"
+        return base
+
+    @property
+    def top_namespace(self) -> str:
+        """
+        提取顶层命名空间/类名:
+        - qualified_name 形如 ns1::ns2::Class::method -> 返回 ns1
+        - C 函数或无命名空间 -> 返回 "c"
+        """
+        if self.qname and "::" in self.qname:
+            return self.qname.split("::", 1)[0] or "c"
+        return "c"
+
+
+def sanitize_mod_name(s: str) -> str:
+    """
+    清理模块名称，使其符合 Rust 模块命名规范。
+
+    Args:
+        s: 原始名称
+
+    Returns:
+        清理后的模块名称
+    """
+    s = (s or "").replace("::", "__")
+    safe = []
+    for ch in s:
+        if ch.isalnum() or ch == "_":
+            safe.append(ch.lower())
+        else:
+            safe.append("_")
+    out = "".join(safe).strip("_")
+    return out[:80] or "mod"

jarvis/jarvis_c2rust/llm_module_agent_utils.py

@@ -0,0 +1,150 @@
+"""LLM 模块规划 Agent 的工具函数。"""
+
+import json
+import shutil
+
+from jarvis.jarvis_utils.output import PrettyOutput
+
+# -*- coding: utf-8 -*-
+import sys
+from pathlib import Path
+from typing import Any
+from typing import List
+from typing import Optional
+from typing import Tuple
+from typing import Union
+
+from jarvis.jarvis_utils.input import user_confirm
+from jarvis.jarvis_utils.jsonnet_compat import loads as json_loads
+
+
+def perform_pre_cleanup_for_planner(project_root: Union[Path, str]) -> None:
+    """
+    预清理：如存在将删除将要生成的 crate 目录、当前目录的 workspace 文件 Cargo.toml、
+    以及 project_root/.jarvis/c2rust 下的 progress.json 与 symbol_map.jsonl。
+    用户不同意则直接退出。
+    """
+    try:
+        cwd = Path(".").resolve()
+    except (OSError, ValueError) as e:
+        raise RuntimeError(f"无法解析当前工作目录: {e}") from e
+
+    try:
+        requested_root = Path(project_root).resolve()
+    except (OSError, ValueError):
+        requested_root = Path(project_root)
+
+    created_dir = (
+        cwd.parent / f"{cwd.name}_rs" if requested_root == cwd else requested_root
+    )
+
+    cargo_path = cwd / "Cargo.toml"
+    data_dir = requested_root / ".jarvis" / "c2rust"
+    progress_path = data_dir / "progress.json"
+    symbol_map_jsonl_path = data_dir / "symbol_map.jsonl"
+
+    targets: List[str] = []
+    if created_dir.exists():
+        targets.append(f"- 删除 crate 目录（如存在）：{created_dir}")
+    if cargo_path.exists():
+        targets.append(f"- 删除工作区文件：{cargo_path}")
+    if progress_path.exists():
+        targets.append(f"- 删除进度文件：{progress_path}")
+    if symbol_map_jsonl_path.exists():
+        targets.append(f"- 删除符号映射文件：{symbol_map_jsonl_path}")
+
+    if not targets:
+        return
+
+    tip_lines = ["将执行以下清理操作："] + targets + ["", "是否继续？"]
+    if not user_confirm("\n".join(tip_lines), default=False):
+        PrettyOutput.auto_print("[c2rust-llm-planner] 用户取消清理操作，退出。")
+        sys.exit(0)
+
+    # 执行清理操作
+    try:
+        if created_dir.exists():
+            shutil.rmtree(created_dir, ignore_errors=True)
+        if cargo_path.exists():
+            cargo_path.unlink()
+        if progress_path.exists():
+            progress_path.unlink()
+        if symbol_map_jsonl_path.exists():
+            symbol_map_jsonl_path.unlink()
+    except (OSError, PermissionError) as e:
+        raise RuntimeError(f"清理操作失败: {e}") from e
+
+
+def resolve_created_dir(target_root: Union[Path, str]) -> Path:
+    """
+    解析 crate 目录路径：
+    - 若 target_root 为 "." 或解析后等于当前工作目录，则返回 "<cwd.name>_rs" 目录；
+    - 否则返回解析后的目标路径；
+    - 解析失败则回退到 Path(target_root)。
+    """
+    try:
+        cwd = Path(".").resolve()
+        try:
+            resolved_target = Path(target_root).resolve()
+        except Exception:
+            resolved_target = Path(target_root)
+        if target_root == "." or resolved_target == cwd:
+            return cwd.parent / f"{cwd.name}_rs"
+        return resolved_target
+    except Exception:
+        return Path(target_root)
+
+
+def parse_project_json_entries_fallback(json_text: str) -> List[Any]:
+    """
+    Fallback 解析器：当 jsonnet 解析失败时，尝试使用标准 json 解析。
+    注意：此函数主要用于兼容性，正常情况下应使用 jsonnet 解析。
+    """
+    try:
+        import json as std_json
+
+        data = std_json.loads(json_text)
+        if isinstance(data, list):
+            return data
+        return []
+    except Exception:
+        return []
+
+
+def parse_project_json_entries(json_text: str) -> Tuple[List[Any], Optional[str]]:
+    """
+    使用 jsonnet 解析 <PROJECT> 块中的目录结构 JSON 为列表结构:
+    - 文件项: 字符串，如 "lib.rs"
+    - 目录项: 字典，形如 {"src/": [ ... ]} 或 {"src": [ ... ]}
+    返回(解析结果, 错误信息)
+    如果解析成功，返回(data, None)
+    如果解析失败，返回([], 错误信息)
+    使用 jsonnet 解析，支持更宽松的 JSON 语法（如尾随逗号、注释等）。
+    """
+    try:
+        try:
+            data = json_loads(json_text)
+            if isinstance(data, list):
+                return data, None
+            # 如果解析结果不是列表
+            return [], f"JSON 解析结果不是数组，而是 {type(data).__name__}"
+        except Exception as json_err:
+            # JSON 解析错误
+            error_msg = f"JSON 解析失败: {str(json_err)}"
+            return [], error_msg
+    except Exception as e:
+        # 其他未知错误
+        return [], f"解析过程发生异常: {str(e)}"
+
+
+def entries_to_json(entries: List[Any]) -> str:
+    """
+    将解析后的 entries 列表序列化为 JSON 文本（目录使用对象表示，文件为字符串）
+
+    Args:
+        entries: 解析后的目录结构列表
+
+    Returns:
+        JSON 文本
+    """
+    return json.dumps(entries, ensure_ascii=False, indent=2)

jarvis/jarvis_c2rust/llm_module_agent_validator.py

@@ -0,0 +1,119 @@
+# -*- coding: utf-8 -*-
+"""LLM 模块规划 Agent 的验证器。"""
+
+import re
+from typing import Any
+from typing import Callable
+from typing import List
+from typing import Optional
+from typing import Tuple
+
+
+class ProjectValidator:
+    """项目结构验证器。"""
+
+    def __init__(
+        self,
+        crate_name_func: Callable[[], str],
+        has_original_main_func: Callable[[], bool],
+    ):
+        self.crate_name_func = crate_name_func
+        self.has_original_main_func = has_original_main_func
+
+    def extract_json_from_project(self, text: str) -> str:
+        """
+        从 <PROJECT> 块中提取内容作为最终 JSON；若未匹配，返回原文本（兜底）。
+
+        Args:
+            text: 包含 <PROJECT> 块的文本
+
+        Returns:
+            提取的 JSON 文本
+        """
+        if not isinstance(text, str) or not text:
+            return ""
+        m_proj = re.search(r"<PROJECT>([\s\S]*?)</PROJECT>", text, flags=re.IGNORECASE)
+        if m_proj:
+            return m_proj.group(1).strip()
+        return text.strip()
+
+    def validate_project_entries(self, entries: List[Any]) -> Tuple[bool, str]:
+        """
+        校验目录结构是否满足强约束：
+        - 必须存在 src/lib.rs
+        - 若原始项目包含 main：
+          * 不允许 src/main.rs
+          * 必须包含 src/bin/<crate_name>.rs
+        - 若原始项目不包含 main：
+          * 不允许 src/main.rs
+          * 不允许存在 src/bin/ 目录
+        返回 (是否通过, 错误原因)
+        """
+        if not isinstance(entries, list) or not entries:
+            return False, "JSON 不可解析或为空数组"
+
+        # 提取 src 目录子项
+        src_children: Optional[List[Any]] = None
+        for it in entries:
+            if isinstance(it, dict) and len(it) == 1:
+                k, v = next(iter(it.items()))
+                kk = str(k).rstrip("/").strip().lower()
+                if kk == "src":
+                    if isinstance(v, list):
+                        src_children = v
+                    else:
+                        src_children = []
+                    break
+        if src_children is None:
+            return False, "缺少 src 目录"
+
+        # 建立便捷索引
+        def has_file(name: str) -> bool:
+            for ch in src_children or []:
+                if isinstance(ch, str) and ch.strip().lower() == name.lower():
+                    return True
+            return False
+
+        def find_dir(name: str) -> Optional[List[Any]]:
+            for ch in src_children or []:
+                if isinstance(ch, dict) and len(ch) == 1:
+                    k, v = next(iter(ch.items()))
+                    kk = str(k).rstrip("/").strip().lower()
+                    if kk == name.lower():
+                        return v if isinstance(v, list) else []
+            return None
+
+        # 1) 必须包含 lib.rs
+        if not has_file("lib.rs"):
+            return False, "src 目录下必须包含 lib.rs"
+
+        has_main = self.has_original_main_func()
+        crate_name = self.crate_name_func()
+
+        # 2) 入口约束
+        if has_main:
+            # 不允许 src/main.rs
+            if has_file("main.rs"):
+                return (
+                    False,
+                    "原始项目包含 main：不应生成 src/main.rs，请使用 src/bin/<crate>.rs",
+                )
+            # 必须包含 src/bin/<crate_name>.rs
+            bin_children = find_dir("bin")
+            if bin_children is None:
+                return False, f"原始项目包含 main：必须包含 src/bin/{crate_name}.rs"
+            expect_bin = f"{crate_name}.rs".lower()
+            if not any(
+                isinstance(ch, str) and ch.strip().lower() == expect_bin
+                for ch in bin_children
+            ):
+                return False, f"原始项目包含 main：必须包含 src/bin/{crate_name}.rs"
+        else:
+            # 不允许 src/main.rs
+            if has_file("main.rs"):
+                return False, "原始项目不包含 main：不应生成 src/main.rs"
+            # 不允许有 bin 目录
+            if find_dir("bin") is not None:
+                return False, "原始项目不包含 main：不应生成 src/bin/ 目录"
+
+        return True, ""

jarvis/jarvis_c2rust/loaders.py

@@ -2,14 +2,20 @@
 """
 C2Rust 转译器数据加载器
 """
+
 from __future__ import annotations
 
 import json
 import time
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Tuple
-
-from jarvis.jarvis_c2rust.constants import C2RUST_DIRNAME, SYMBOLS_JSONL
+from typing import Any
+from typing import Dict
+from typing import List
+from typing import Optional
+from typing import Tuple
+
+from jarvis.jarvis_c2rust.constants import C2RUST_DIRNAME
+from jarvis.jarvis_c2rust.constants import SYMBOLS_JSONL
 from jarvis.jarvis_c2rust.models import FnRecord
 
 
@@ -23,9 +29,7 @@ class _DbLoader:
         self.symbols_path = self.data_dir / SYMBOLS_JSONL
         # 统一流程：仅使用 symbols.jsonl，不再兼容 functions.jsonl
         if not self.symbols_path.exists():
-            raise FileNotFoundError(
-                f"在目录下未找到 symbols.jsonl: {self.data_dir}"
-            )
+            raise FileNotFoundError(f"在目录下未找到 symbols.jsonl: {self.data_dir}")
 
         self.fn_by_id: Dict[int, FnRecord] = {}
         self.name_to_id: Dict[str, int] = {}
@@ -36,6 +40,7 @@ class _DbLoader:
         读取统一的 symbols.jsonl。
         不区分函数与类型定义，均加载为通用记录（位置与引用信息）。
         """
+
         def _iter_records_from_file(path: Path):
             try:
                 with path.open("r", encoding="utf-8") as f:
@@ -68,7 +73,11 @@ class _DbLoader:
             sc = int(obj.get("start_col") or 0)
             er = int(obj.get("end_line") or 0)
             ec = int(obj.get("end_col") or 0)
-            lr = obj.get("lib_replacement") if isinstance(obj.get("lib_replacement"), dict) else None
+            lr = (
+                obj.get("lib_replacement")
+                if isinstance(obj.get("lib_replacement"), dict)
+                else None
+            )
             rec = FnRecord(
                 id=fid,
                 name=nm,
@@ -167,7 +176,12 @@ class _SymbolMapJsonl:
             if not k:
                 continue
             self.by_key.setdefault(k, []).append(idx)
-        pos_key = (str(rec.get("c_file") or ""), int(rec.get("start_line") or 0), int(rec.get("end_line") or 0), str(rec.get("c_qname") or rec.get("c_name") or ""))
+        pos_key = (
+            str(rec.get("c_file") or ""),
+            int(rec.get("start_line") or 0),
+            int(rec.get("end_line") or 0),
+            str(rec.get("c_qname") or rec.get("c_name") or ""),
+        )
         self.by_pos.setdefault(pos_key, []).append(idx)
 
     def has_symbol(self, sym: str) -> bool:
@@ -182,7 +196,12 @@ class _SymbolMapJsonl:
         return recs[-1] if recs else None
 
     def has_rec(self, rec: FnRecord) -> bool:
-        key = (str(rec.file or ""), int(rec.start_line or 0), int(rec.end_line or 0), str(rec.qname or rec.name or ""))
+        key = (
+            str(rec.file or ""),
+            int(rec.start_line or 0),
+            int(rec.end_line or 0),
+            str(rec.qname or rec.name or ""),
+        )
         return bool(self.by_pos.get(key))
 
     def add(self, rec: FnRecord, module: str, rust_symbol: str) -> None:
@@ -204,4 +223,3 @@ class _SymbolMapJsonl:
         except Exception:
             pass
         self._add_record_in_memory(obj)
-