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

jarvis/jarvis_c2rust/library_replacer_output.py

@@ -0,0 +1,134 @@
+# -*- coding: utf-8 -*-
+"""库替换器的输出写入模块。"""
+
+import json
+import time
+from pathlib import Path
+from typing import Any, Dict, List, Set, Tuple
+
+
+def write_output_symbols(
+    all_records: List[Dict[str, Any]],
+    pruned_funcs: Set[int],
+    selected_roots: List[Tuple[int, Dict[str, Any]]],
+    out_symbols_path: Path,
+    out_symbols_prune_path: Path,
+) -> List[Dict[str, Any]]:
+    """写出新符号表，返回替代映射列表"""
+    now_ts = time.strftime("%Y-%m-%dT%H:%M:%S", time.localtime())
+    kept_ids: Set[int] = set()
+    for rec in all_records:
+        rec_id = rec.get("id")
+        if rec_id is None:
+            continue
+        fid = int(rec_id)
+        cat = rec.get("category") or ""
+        if cat == "function":
+            if fid in pruned_funcs:
+                continue
+            kept_ids.add(fid)
+        else:
+            kept_ids.add(fid)
+
+    sel_root_ids = set(fid for fid, _ in selected_roots)
+    replacements: List[Dict[str, Any]] = []
+
+    with (
+        open(out_symbols_path, "w", encoding="utf-8") as fo,
+        open(out_symbols_prune_path, "w", encoding="utf-8") as fo2,
+    ):
+        for rec in all_records:
+            rec_id = rec.get("id")
+            if rec_id is None:
+                continue
+            fid = int(rec_id)
+            if fid not in kept_ids:
+                continue
+
+            rec_out = dict(rec)
+            if (rec.get("category") or "") == "function" and fid in sel_root_ids:
+                # 以库级替代为语义：不要求具体 API；将根 ref 设置为库占位符（支持多库组合）
+                conf = 0.0
+                api = ""
+                apis = None
+                libraries_out: List[str] = []
+                notes_out: str = ""
+                lib_single: str = ""
+                is_entry = False
+                for rf, rres in selected_roots:
+                    if rf == fid:
+                        api = str(rres.get("api") or rres.get("function") or "")
+                        apis = rres.get("apis")
+                        libs_val = rres.get("libraries")
+                        if isinstance(libs_val, list):
+                            libraries_out = [str(x) for x in libs_val if str(x)]
+                        lib_single = str(rres.get("library") or "").strip()
+                        try:
+                            conf = float(rres.get("confidence") or 0.0)
+                        except Exception:
+                            conf = 0.0
+                        notes_val = rres.get("notes")
+                        if isinstance(notes_val, str):
+                            notes_out = notes_val
+                        is_entry = bool(rres.get("is_entry_function", False))
+                        break
+                # 入口函数保护：不修改 ref 字段（保留原值，需要转译），但保留替代信息供转译参考
+                if not is_entry:
+                    # 非入口函数：修改 ref 为库占位符
+                    if libraries_out:
+                        lib_markers = [f"lib::{lb}" for lb in libraries_out]
+                    elif lib_single:
+                        lib_markers = [f"lib::{lib_single}"]
+                    else:
+                        lib_markers = []
+                    rec_out["ref"] = lib_markers
+                # 入口函数：保持 ref 不变（不修改），但后续仍会保存 lib_replacement 元数据
+                try:
+                    rec_out["updated_at"] = now_ts
+                except Exception:
+                    pass
+                # 保存库替代元数据到符号表，供后续转译阶段作为上下文使用
+                try:
+                    meta_apis = (
+                        apis if isinstance(apis, list) else ([api] if api else [])
+                    )
+                    lib_primary = libraries_out[0] if libraries_out else lib_single
+                    rec_out["lib_replacement"] = {
+                        "libraries": libraries_out,
+                        "library": lib_primary or "",
+                        "apis": meta_apis,
+                        "api": api,
+                        "confidence": float(conf)
+                        if isinstance(conf, (int, float))
+                        else 0.0,
+                        "notes": notes_out,
+                        "mode": "llm",
+                        "is_entry_function": is_entry,
+                        "updated_at": now_ts,
+                    }
+                except Exception:
+                    # 忽略写入元数据失败，不阻塞主流程
+                    pass
+                rep_obj: Dict[str, Any] = {
+                    "id": fid,
+                    "name": rec.get("name") or "",
+                    "qualified_name": rec.get("qualified_name") or "",
+                    "library": (libraries_out[0] if libraries_out else lib_single),
+                    "libraries": libraries_out,
+                    "function": api,
+                    "confidence": conf,
+                    "mode": "llm",
+                    "is_entry_function": is_entry,
+                }
+                if isinstance(apis, list):
+                    rep_obj["apis"] = apis
+                if notes_out:
+                    rep_obj["notes"] = notes_out
+                replacements.append(rep_obj)
+
+            line = json.dumps(rec_out, ensure_ascii=False) + "\n"
+            fo.write(line)
+            fo2.write(line)
+            # 不覆写 symbols.jsonl（保留原始扫描/整理结果作为基线）
+
+    return replacements

jarvis/jarvis_c2rust/library_replacer_prompts.py

@@ -0,0 +1,124 @@
+# -*- coding: utf-8 -*-
+"""库替换器的提示词构建模块。"""
+
+from typing import Any
+from typing import Dict
+from typing import List
+from typing import Set
+
+from jarvis.jarvis_c2rust.constants import MAX_CHILD_SAMPLES
+from jarvis.jarvis_c2rust.constants import MAX_DOT_EDGES
+from jarvis.jarvis_c2rust.constants import MAX_SUBTREE_EDGES
+from jarvis.jarvis_c2rust.constants import MAX_SUBTREE_NODES_META
+from jarvis.jarvis_c2rust.constants import SUBTREE_SOURCE_SNIPPET_MAX_LINES
+from jarvis.jarvis_c2rust.library_replacer_utils import read_source_snippet
+
+
+def build_subtree_prompt(
+    fid: int,
+    desc: Set[int],
+    by_id: Dict[int, Dict[str, Any]],
+    adj_func: Dict[int, List[int]],
+    disabled_display: str,
+    additional_notes: str = "",
+) -> str:
+    """构建子树评估提示词"""
+    root_rec = by_id.get(fid, {})
+    root_name = root_rec.get("qualified_name") or root_rec.get("name") or f"sym_{fid}"
+    root_sig = root_rec.get("signature") or ""
+    root_lang = root_rec.get("language") or ""
+    root_src = read_source_snippet(root_rec)
+
+    # 子树摘要（限制长度，避免超长）
+    nodes_meta: List[str] = []
+    for nid in sorted(desc):
+        r = by_id.get(nid, {})
+        nm = r.get("qualified_name") or r.get("name") or f"sym_{nid}"
+        sg = r.get("signature") or ""
+        if sg and sg != nm:
+            nodes_meta.append(f"- {nm} | {sg}")
+        else:
+            nodes_meta.append(f"- {nm}")
+    if len(nodes_meta) > MAX_SUBTREE_NODES_META:
+        nodes_meta = nodes_meta[:MAX_SUBTREE_NODES_META] + [
+            f"...({len(desc) - MAX_SUBTREE_NODES_META} more)"
+        ]
+
+    # 选取部分代表性叶子/内部节点源码（最多 MAX_SOURCE_SAMPLES 个）
+    samples: List[str] = []
+    sample_ids: List[int] = [fid]
+    for ch in adj_func.get(fid, [])[:MAX_CHILD_SAMPLES]:
+        sample_ids.append(ch)
+    for sid in sample_ids:
+        rec = by_id.get(sid, {})
+        nm = rec.get("qualified_name") or rec.get("name") or f"sym_{sid}"
+        sg = rec.get("signature") or ""
+        src = read_source_snippet(rec, max_lines=SUBTREE_SOURCE_SNIPPET_MAX_LINES)
+        samples.append(f"--- BEGIN {nm} ---\n{sg}\n{src}\n--- END {nm} ---")
+
+    # 构建依赖图（子树内的调用有向边）
+    def _label(nid: int) -> str:
+        r = by_id.get(nid, {})
+        return r.get("qualified_name") or r.get("name") or f"sym_{nid}"
+
+    edges_list: List[str] = []
+    for u in sorted(desc):
+        for v in adj_func.get(u, []):
+            if v in desc:
+                edges_list.append(f"{_label(u)} -> {_label(v)}")
+    edges_text: str
+    if len(edges_list) > MAX_SUBTREE_EDGES:
+        edges_text = "\n".join(
+            edges_list[:MAX_SUBTREE_EDGES]
+            + [f"...({len(edges_list) - MAX_SUBTREE_EDGES} more edges)"]
+        )
+    else:
+        edges_text = "\n".join(edges_list)
+
+    # 适度提供 DOT（边数不大时），便于大模型直观看图
+    dot_text = ""
+    if len(edges_list) <= MAX_DOT_EDGES:
+        dot_lines: List[str] = ["digraph subtree {", "  rankdir=LR;"]
+        for u in sorted(desc):
+            for v in adj_func.get(u, []):
+                if v in desc:
+                    dot_lines.append(f'  "{_label(u)}" -> "{_label(v)}";')
+        dot_lines.append("}")
+        dot_text = "\n".join(dot_lines)
+
+    disabled_hint = (
+        f"重要约束：禁止使用以下库（若这些库为唯一可行选项则判定为不可替代）：{disabled_display}\n"
+        if disabled_display
+        else ""
+    )
+
+    return (
+        "请评估以下 C/C++ 函数子树是否可以由一个或多个成熟的 Rust 库整体替代（语义等价或更强）。"
+        "允许库内多个 API 协同，允许多个库组合；如果必须依赖尚不成熟/冷门库或非 Rust 库，则判定为不可替代。"
+        "如果当前调用的函数无法使用 crate 直接提供的功能而需要封装或者改造，则认为不可替代。\n"
+        f"{disabled_hint}"
+        "输出格式：仅输出一个 <SUMMARY> 块，块内直接包含 JSON 对象（不需要额外的标签），字段: replaceable(bool), libraries(list[str]), confidence(float 0..1)，"
+        "可选字段: library(str,首选主库), api(str) 或 apis(list), notes(str: 简述如何由这些库协作实现的思路)。\n\n"
+        f"根函数(被评估子树的根): {root_name}\n"
+        f"签名: {root_sig}\n"
+        f"语言: {root_lang}\n"
+        "根函数源码片段（可能截断）:\n"
+        f"{root_src}\n\n"
+        f"子树规模: {len(desc)} 个函数\n"
+        "子树函数列表（名称|签名）:\n" + "\n".join(nodes_meta) + "\n\n"
+        "依赖图（调用边，caller -> callee）:\n"
+        f"{edges_text}\n\n"
+        + (
+            f"DOT 表示（边数较少时提供）:\n```dot\n{dot_text}\n```\n\n"
+            if dot_text
+            else ""
+        )
+        + "代表性源码样本（部分节点，可能截断，仅供辅助判断）:\n"
+        + "\n".join(samples)
+        + "\n"
+        + (
+            f"\n【附加说明（用户自定义）】\n{additional_notes}\n"
+            if additional_notes
+            else ""
+        )
+    )

jarvis/jarvis_c2rust/library_replacer_utils.py

@@ -0,0 +1,188 @@
+# -*- coding: utf-8 -*-
+"""库替换器的工具函数。"""
+
+import json
+import os
+import re
+from pathlib import Path
+from typing import List
+from typing import Optional
+
+from jarvis.jarvis_c2rust.constants import CONFIG_JSON
+from jarvis.jarvis_c2rust.constants import DEFAULT_MAPPING_OUTPUT
+from jarvis.jarvis_c2rust.constants import DEFAULT_SOURCE_SNIPPET_MAX_LINES
+from jarvis.jarvis_c2rust.constants import DEFAULT_SYMBOLS_OUTPUT
+from jarvis.jarvis_c2rust.constants import ORDER_ALIAS_OUTPUT
+from jarvis.jarvis_c2rust.constants import ORDER_PRUNE_OUTPUT
+from jarvis.jarvis_c2rust.constants import SYMBOLS_PRUNE_OUTPUT
+
+
+def resolve_symbols_jsonl_path(hint: Path) -> Path:
+    """解析symbols.jsonl路径"""
+    p = Path(hint)
+    if p.is_file() and p.suffix.lower() == ".jsonl":
+        return p
+    if p.is_dir():
+        return p / ".jarvis" / "c2rust" / "symbols.jsonl"
+    return Path(".") / ".jarvis" / "c2rust" / "symbols.jsonl"
+
+
+def setup_output_paths(
+    data_dir: Path,
+    out_symbols_path: Optional[Path],
+    out_mapping_path: Optional[Path],
+) -> tuple[Path, Path, Path, Path, Path]:
+    """设置输出路径，返回(符号表路径, 映射路径, 兼容符号表路径, 顺序路径, 别名顺序路径)"""
+    if out_symbols_path is None:
+        out_symbols_path = data_dir / DEFAULT_SYMBOLS_OUTPUT
+    else:
+        out_symbols_path = Path(out_symbols_path)
+    if out_mapping_path is None:
+        out_mapping_path = data_dir / DEFAULT_MAPPING_OUTPUT
+    else:
+        out_mapping_path = Path(out_mapping_path)
+
+    # 兼容输出
+    out_symbols_prune_path = data_dir / SYMBOLS_PRUNE_OUTPUT
+    order_prune_path = data_dir / ORDER_PRUNE_OUTPUT
+    alias_order_path = data_dir / ORDER_ALIAS_OUTPUT
+
+    return (
+        out_symbols_path,
+        out_mapping_path,
+        out_symbols_prune_path,
+        order_prune_path,
+        alias_order_path,
+    )
+
+
+def read_source_snippet(
+    rec: dict, max_lines: int = DEFAULT_SOURCE_SNIPPET_MAX_LINES
+) -> str:
+    """读取源码片段"""
+    path = rec.get("file") or ""
+    try:
+        if not path:
+            return ""
+        p = Path(path)
+        if not p.exists():
+            return ""
+        sl = int(rec.get("start_line") or 1)
+        el = int(rec.get("end_line") or sl)
+        if el < sl:
+            el = sl
+        lines = p.read_text(encoding="utf-8", errors="replace").splitlines()
+        start_idx = max(sl - 1, 0)
+        end_idx = min(el, len(lines))
+        snippet_lines = lines[start_idx:end_idx]
+        if len(snippet_lines) > max_lines:
+            snippet_lines = snippet_lines[:max_lines]
+        return "\n".join(snippet_lines)
+    except Exception:
+        return ""
+
+
+def normalize_disabled_libraries(
+    disabled_libraries: Optional[List[str]],
+) -> tuple[List[str], str]:
+    """规范化禁用库列表，返回(规范化列表, 显示字符串)"""
+    disabled_norm: List[str] = []
+    disabled_display: str = ""
+    if isinstance(disabled_libraries, list):
+        disabled_norm = [
+            str(x).strip().lower() for x in disabled_libraries if str(x).strip()
+        ]
+        disabled_display = ", ".join(
+            [str(x).strip() for x in disabled_libraries if str(x).strip()]
+        )
+    return disabled_norm, disabled_display
+
+
+def load_additional_notes(data_dir: Path) -> str:
+    """从配置文件加载附加说明"""
+    try:
+        config_path = data_dir / CONFIG_JSON
+        if config_path.exists():
+            with config_path.open("r", encoding="utf-8") as f:
+                config = json.load(f)
+                if isinstance(config, dict):
+                    return str(config.get("additional_notes", "") or "").strip()
+    except Exception:
+        pass
+    return ""
+
+
+def normalize_list(items: Optional[List[str]]) -> List[str]:
+    """规范化列表，去重并排序"""
+    if not isinstance(items, list):
+        return []
+    vals: List[str] = []
+    for x in items:
+        try:
+            s = str(x).strip()
+        except Exception:
+            continue
+        if s:
+            vals.append(s)
+    # 去重并排序
+    try:
+        vals = sorted(set(vals))
+    except Exception:
+        # 如果排序失败，至少去重（保留顺序）
+        vals = list(dict.fromkeys(vals))
+    return vals
+
+
+def normalize_list_lower(items: Optional[List[str]]) -> List[str]:
+    """规范化列表并转为小写（先转小写，再去重并排序）"""
+    if not isinstance(items, list):
+        return []
+    # 先转小写，然后规范化
+    lower_items = []
+    for x in items:
+        try:
+            s = str(x).strip().lower()
+        except Exception:
+            continue
+        if s:
+            lower_items.append(s)
+    # 去重并排序
+    try:
+        return sorted(set(lower_items))
+    except Exception:
+        # 如果排序失败，至少去重（保留顺序）
+        return list(dict.fromkeys(lower_items))
+
+
+def is_entry_function(rec_meta: dict) -> bool:
+    """判断是否为入口函数"""
+    nm = str(rec_meta.get("name") or "")
+    qn = str(rec_meta.get("qualified_name") or "")
+    # Configurable entry detection (avoid hard-coding 'main'):
+    # Honor env vars: c2rust_delay_entry_symbols / c2rust_delay_entries / C2RUST_DELAY_ENTRIES
+    entries_env = (
+        os.environ.get("c2rust_delay_entry_symbols")
+        or os.environ.get("c2rust_delay_entries")
+        or os.environ.get("C2RUST_DELAY_ENTRIES")
+        or ""
+    )
+    entries_set = set()
+    if entries_env:
+        try:
+            parts = re.split(r"[,\s;]+", entries_env.strip())
+        except Exception:
+            parts = [p.strip() for p in entries_env.replace(";", ",").split(",")]
+        entries_set = {p.strip().lower() for p in parts if p and p.strip()}
+    if entries_set:
+        is_entry = (
+            (nm.lower() in entries_set)
+            or (qn.lower() in entries_set)
+            or any(qn.lower().endswith(f"::{e}") for e in entries_set)
+        )
+    else:
+        is_entry = (
+            (nm.lower() == "main")
+            or (qn.lower() == "main")
+            or qn.lower().endswith("::main")
+        )
+    return is_entry