@hupan56/wlkj 3.3.14 → 3.3.15

package/templates/qoder/scripts/domain/kg/extract/inference/naming_matcher.py

@@ -1,80 +0,0 @@
-# -*- coding: utf-8 -*-
-"""命名同源匹配: 不依赖 embedding, 用命名规则建弱关联。
-
-AssetController ↔ asset 表 ↔ 资产管理 PRD → 词干相同 → 弱边。
-这是 embedding 不可用时的主路径, 也是 embedding 的补充 (硬规则置信度高)。
-"""
-from __future__ import annotations
-import re
-
-
-def extract_stem(name: str) -> str:
-    """提取名称的词干 (去掉类型后缀 + 小写 + 驼峰拆词)。
-
-    AssetController → 'asset'
-    EmployeeOnline → 'employee online' → 'employee'
-    IQrCodeLoginService → 'qr code login'
-    test_demo → 'test demo'
-    资产管理 → '资产管理'
-    """
-    if not name:
-        return ''
-    s = name.strip()
-    # 去掉常见类型后缀
-    for suffix in ['Controller', 'ServiceImpl', 'Service', 'Mapper',
-                   'Repository', 'Entity', 'Vo', 'BO', 'Bo', 'Dto', 'DTO',
-                   'Form', 'Body', 'Request', 'Response', 'Result']:
-        if s.endswith(suffix) and len(s) > len(suffix):
-            s = s[:-len(suffix)]
-            break
-    # 去掉接口前缀 I
-    if s.startswith('I') and len(s) > 1 and s[1].isupper():
-        s = s[1:]
-    # 驼峰拆词
-    words = re.findall(r'[A-Z]?[a-z]+|[A-Z]+(?=[A-Z]|$)|[\u4e00-\u9fff]+', s)
-    if not words:
-        return s.lower()
-    # 中文直接返回, 英文取第一个词 (主词)
-    if any('\u4e00' <= c <= '\u9fff' for c in s):
-        return ''.join(w for w in words if '\u4e00' <= w[0] <= '\u9fff')[:6]
-    return words[0].lower() if words else s.lower()
-
-
-def naming_similarity(name_a: str, name_b: str) -> float:
-    """两个名称的命名同源相似度 → [0, 1]。
-
-    词干相同 → 0.8
-    词干包含关系 → 0.6
-    无关 → 0
-    """
-    stem_a = extract_stem(name_a)
-    stem_b = extract_stem(name_b)
-    if not stem_a or not stem_b:
-        return 0.0
-    if stem_a == stem_b:
-        return 0.8
-    if stem_a in stem_b or stem_b in stem_a:
-        return 0.6
-    # 词重叠 (多词情况)
-    words_a = set(stem_a.split())
-    words_b = set(stem_b.split())
-    if words_a and words_b:
-        overlap = len(words_a & words_b)
-        if overlap > 0:
-            return 0.5 * overlap / max(len(words_a), len(words_b))
-    return 0.0
-
-
-def match_to_anchors(entity_canonical: str, anchors: list) -> list:
-    """把实体和 anchors 做命名匹配 → [(anchor_id, score)]。
-
-    anchors: [{'id':..., 'title':..., 'kind':...}]
-    Returns: 按相似度降序, score >= 0.6 的
-    """
-    out = []
-    for a in anchors:
-        score = naming_similarity(entity_canonical, a.get('title', '') or a.get('id', ''))
-        if score >= 0.6:
-            out.append((a['id'], score))
-    out.sort(key=lambda x: x[1], reverse=True)
-    return out

package/templates/qoder/scripts/domain/kg/extract/inference/promote.py

@@ -1,59 +0,0 @@
-# -*- coding: utf-8 -*-
-"""弱边升格: 出现强关联时, 对应弱边自动删除。
-
-避免同一对 (entity, anchor) 既有强边又有弱边, 强边优先。
-"""
-from __future__ import annotations
-import os
-import sys
-
-_THIS = os.path.dirname(os.path.abspath(__file__))
-for _i in range(8):
-    _p = os.path.dirname(_THIS)
-    if os.path.isfile(os.path.join(_p, 'foundation', 'bootstrap.py')):
-        sys.path.insert(0, _p); break
-    _THIS = _p
-
-
-def _get_engine():
-    from domain.kg.extract.java import pg_upsert
-    return pg_upsert._get_pg_engine()
-
-
-def promote_strong_over_weak(logger=print):
-    """删除有强关联的实体的弱边。
-
-    逻辑: entity 如果有 source='explicit'/'commit' 的 implements_req 边,
-    则该 entity 的所有 source='inferred' 的 relates_to 边删除 (被强边替代)。
-
-    Returns: {deleted}
-    """
-    engine, _ = _get_engine()
-    if engine is None:
-        return {'deleted': 0}
-    from sqlalchemy import text
-
-    deleted = 0
-    with engine.begin() as conn:
-        # 找有强关联的实体
-        strong_entities = conn.execute(text("""
-            SELECT DISTINCT from_id FROM edges
-            WHERE source IN ('explicit', 'commit')
-              AND edge_type IN ('implements_req', 'anchors')
-        """)).all()
-        strong_ids = [r[0] for r in strong_entities]
-        # 也包括 prd: 锚点本身 (它们的实体不该有弱边)
-        if strong_ids:
-            # 删除这些实体的弱边
-            result = conn.execute(text("""
-                DELETE FROM edges
-                WHERE source='inferred' AND from_id = ANY(:ids)
-            """), {'ids': strong_ids})
-            deleted = result.rowcount or 0
-
-    logger('  [promote] 删除 %d 条冗余弱边 (升格到强关联)' % deleted)
-    return {'deleted': deleted}
-
-
-if __name__ == '__main__':
-    print(promote_strong_over_weak())

package/templates/qoder/scripts/domain/kg/extract/inference/recompute.py

@@ -1,93 +0,0 @@
-# -*- coding: utf-8 -*-
-"""C 方案指纹重算: 过期弱边对比指纹 → 续期/重推理/删除。
-
-每天 celery 定时跑:
-  1. 找 expires_at < now 的弱边
-  2. 对比 fingerprint: 没变 → 续期; 变了 → 删除重推理
-  3. 升格: 弱边的 from 出现强关联 → 弱边删除 (在 promote.py)
-"""
-from __future__ import annotations
-import os
-import sys
-from datetime import datetime
-
-_THIS = os.path.dirname(os.path.abspath(__file__))
-for _i in range(8):
-    _p = os.path.dirname(_THIS)
-    if os.path.isfile(os.path.join(_p, 'foundation', 'bootstrap.py')):
-        sys.path.insert(0, _p); break
-    _THIS = _p
-
-
-def _get_engine():
-    from domain.kg.extract.java import pg_upsert
-    return pg_upsert._get_pg_engine()
-
-
-def recompute_expired(logger=print):
-    """重算所有过期弱边 (C 方案主入口)。
-
-    Returns: {expired, renewed, deleted, errors}
-    """
-    engine, _ = _get_engine()
-    if engine is None:
-        return {'error': 'PG 不可用'}
-    from sqlalchemy import text
-
-    now = datetime.utcnow().isoformat()
-    stats = {'expired': 0, 'renewed': 0, 'deleted': 0, 'errors': 0}
-
-    with engine.begin() as conn:
-        # 找过期弱边
-        rows = conn.execute(text("""
-            SELECT from_id, to_id, fingerprint FROM edges
-            WHERE source='inferred' AND expires_at IS NOT NULL
-              AND expires_at < CAST(:now AS TIMESTAMPTZ)
-            LIMIT 200
-        """), {'now': now}).all()
-        stats['expired'] = len(rows)
-        logger('  [recompute] %d 条过期弱边' % len(rows))
-
-        for from_id, to_id, fingerprint in rows:
-            try:
-                # 对比当前指纹: 用和建边时相同的 _get_file_fingerprint 函数算
-                # (保证一致性: file_signatures 真实 hash 优先, 无 file 时 canonical hash 兜底)
-                ent_row = conn.execute(text("""
-                    SELECT id, repo_id, canonical, cn, props FROM entities WHERE id=:id
-                """), {'id': from_id}).first()
-                if not ent_row:
-                    # 实体已删 → 删弱边
-                    conn.execute(text("DELETE FROM edges WHERE from_id=:f AND to_id=:t AND source='inferred'"),
-                                 {'f': from_id, 't': to_id})
-                    stats['deleted'] += 1
-                    continue
-                ent = {'id': ent_row[0], 'repo_id': ent_row[1], 'canonical': ent_row[2],
-                       'cn': ent_row[3], 'props': ent_row[4] or {}}
-                # 用 weak_link 的统一 fingerprint 函数 (和建边时一致)
-                from domain.kg.extract.inference.weak_link import _get_file_fingerprint
-                cur_fp = _get_file_fingerprint(ent)
-
-                if cur_fp and fingerprint and str(cur_fp)[:16] == str(fingerprint)[:16]:
-                    # ★ 指纹没变 → 续期 30 天
-                    conn.execute(text("""
-                        UPDATE edges SET expires_at = now() + interval '30 days'
-                        WHERE from_id=:f AND to_id=:t AND source='inferred'
-                    """), {'f': from_id, 't': to_id})
-                    stats['renewed'] += 1
-                else:
-                    # ★ 指纹变了 → 删除旧弱边 (下次全量推理重建)
-                    conn.execute(text("""
-                        DELETE FROM edges WHERE from_id=:f AND to_id=:t AND source='inferred'
-                    """), {'f': from_id, 't': to_id})
-                    stats['deleted'] += 1
-            except Exception:
-                stats['errors'] += 1
-
-    logger('  [recompute] 续期%d 删除%d 错%d' % (
-        stats['renewed'], stats['deleted'], stats['errors']))
-    return stats
-
-
-if __name__ == '__main__':
-    r = recompute_expired()
-    print(r)

package/templates/qoder/scripts/domain/kg/extract/inference/weak_link.py

@@ -1,421 +0,0 @@
-# -*- coding: utf-8 -*-
-"""embedding 弱关联推理 (L3 核心)。
-
-对没有 REQ-ID 标注的老代码:
-  1. 算实体 embedding (DashScope text-embedding-v3)
-  2. 向量召回最近 anchor (pgvector HNSW; 不可用降级命名匹配)
-  3. 按相似度建弱边:
-     > 0.85 → confidence=0.9, expires_at=now+30天
-     0.6-0.85 → confidence=0.7, expires_at=now+14天
-  4. 绑 fingerprint (C方案重算依赖)
-
-embedding 成本高 (37515 实体), 用 llm_limit 限量 + 增量。
-"""
-from __future__ import annotations
-import os
-import sys
-import time
-import json
-import urllib.request
-from datetime import datetime, timedelta
-
-_THIS = os.path.dirname(os.path.abspath(__file__))
-for _i in range(8):
-    _p = os.path.dirname(_THIS)
-    if os.path.isfile(os.path.join(_p, 'foundation', 'bootstrap.py')):
-        sys.path.insert(0, _p); break
-    _THIS = _p
-
-from domain.kg.extract.inference import naming_matcher
-
-
-def embed_one(text: str) -> list:
-    """调 DashScope text-embedding-v3 算单个向量 (1024维)。失败返回 []。"""
-    key = os.environ.get('DASHSCOPE_API_KEY', '')
-    if not key or not text:
-        return []
-    payload = json.dumps({
-        'model': 'text-embedding-v3',
-        'input': [text[:500]],
-        'dimensions': 1024,
-    }).encode('utf-8')
-    req = urllib.request.Request(
-        'https://dashscope.aliyuncs.com/compatible-mode/v1/embeddings',
-        data=payload,
-        headers={'Authorization': 'Bearer ' + key, 'Content-Type': 'application/json'},
-    )
-    try:
-        with urllib.request.urlopen(req, timeout=15) as resp:
-            r = json.loads(resp.read())
-        return r['data'][0]['embedding']
-    except Exception:
-        return []
-
-
-def cosine_sim(a: list, b: list) -> float:
-    """余弦相似度 (纯 Python, 不依赖 numpy)。"""
-    if not a or not b or len(a) != len(b):
-        return 0.0
-    dot = sum(x * y for x, y in zip(a, b))
-    na = sum(x * x for x in a) ** 0.5
-    nb = sum(y * y for y in b) ** 0.5
-    if na == 0 or nb == 0:
-        return 0.0
-    return dot / (na * nb)
-
-
-def infer_one(entity: dict, anchors: list, anchor_vecs: dict = None,
-              vec_matrix=None, vec_ids=None, preset_vec=None):
-    """对单个实体推理弱关联 → edges 列表。
-
-    Args:
-        entity: {id, canonical, cn, type, props}
-        anchors: [{id, title, kind}] 全部锚点
-        anchor_vecs: {anchor_id: vec} 锚点向量缓存 (可选, 没有则用命名匹配)
-        vec_matrix: numpy 矩阵 (N, 1024) 持久化向量 (GOAL A 矩阵召回)
-        vec_ids: 矩阵对应的 entity_id 列表 (长度 N)
-        preset_vec: 预计算的实体向量 (GOAL A 批量 embed, 避免逐个调 API)
-    Returns: [{from_id, to_id, edge_type, confidence, source, expires_at, fingerprint, props}]
-    """
-    eid = entity['id']
-    desc = (entity.get('canonical', '') + ' ' + entity.get('cn', '')).strip() or entity['id']
-
-    # 路1: numpy 矩阵召回 (GOAL A, 最快) — 一次矩阵乘算 top-K
-    if vec_matrix is not None and vec_ids is not None:
-        # ★ 优先用预计算向量 (GOAL A 批量 embed), 没有才逐个 embed
-        ent_vec = preset_vec or embed_one(desc)
-        if ent_vec:
-            scored = _numpy_recall(ent_vec, vec_matrix, vec_ids, top_k=5, min_score=0.6)
-            if scored:
-                return _build_edges(eid, scored, entity, anchors, via='embedding')
-
-    # 路2: 逐个 cosine_sim 召回 (有 anchor_vecs 时, 旧逻辑)
-    if anchor_vecs:
-        ent_vec = preset_vec or embed_one(desc)
-        if ent_vec:
-            scored = []
-            for aid, avec in anchor_vecs.items():
-                s = cosine_sim(ent_vec, avec)
-                if s >= 0.6:
-                    scored.append((aid, s))
-            scored.sort(key=lambda x: x[1], reverse=True)
-            if scored:
-                return _build_edges(eid, scored, entity, anchors, via='embedding')
-    # 路3: 命名匹配降级 (embedding 不可用或没 anchor_vecs 或 embedding 0命中)
-    matches = naming_matcher.match_to_anchors(entity.get('canonical', ''), anchors)
-    return _build_edges(eid, matches, entity, anchors, via='naming')
-
-
-def _numpy_recall(query_vec: list, matrix, ids: list, top_k: int = 5,
-                  min_score: float = 0.6) -> list:
-    """numpy 矩阵召回 top-K (GOAL A 核心, 替代逐个 cosine_sim)。
-
-    query_vec × matrix 一次矩阵乘 → 全量相似度 → top-K。
-    比逐个 Python cosine_sim 快 100x。
-    Returns: [(id, score)] 按 score 降序
-    """
-    try:
-        import numpy as np
-        q = np.array(query_vec, dtype=np.float32)
-        # 归一化 (余弦相似度 = 点积/模长)
-        q_norm = q / (np.linalg.norm(q) + 1e-8)
-        m = matrix  # 已归一化的矩阵 (N, dim)
-        # 一次矩阵乘: (1, dim) × (dim, N) → (1, N)
-        scores = m @ q_norm  # m 已归一化, q 已归一化 → 点积=余弦
-        # top-K
-        top_idx = np.argsort(scores)[::-1][:top_k]
-        out = []
-        for idx in top_idx:
-            s = float(scores[idx])
-            if s >= min_score:
-                out.append((ids[idx], round(s, 4)))
-        return out
-    except Exception:
-        return []
-
-
-def _load_vec_matrix(engine, kinds=None) -> tuple:
-    """从持久化向量加载到 numpy 矩阵 (GOAL A)。
-
-    优先读 embeddings_ali (rag.py 的 19093 条, 已有), 兜底读 embeddings (GOAL A 新建)。
-    Returns: (matrix_normalized, id_list)  matrix 是 (N, 1024) 已归一化矩阵
-    """
-    import numpy as np
-    from sqlalchemy import text
-    import json
-    # 路1: embeddings_ali (rag.py 的向量源, 数据最多)
-    try:
-        with engine.connect() as conn:
-            rows = conn.execute(text("""
-                SELECT entity_id, vec FROM embeddings_ali
-                WHERE vec IS NOT NULL AND array_length(vec, 1) > 0
-                LIMIT 5000
-            """)).all()
-        if rows:
-            ids, vecs = [], []
-            for eid, v in rows:
-                if isinstance(v, list) and len(v) > 0:
-                    ids.append(eid)
-                    vecs.append(v)
-            if vecs:
-                matrix = np.array(vecs, dtype=np.float32)
-                norms = np.linalg.norm(matrix, axis=1, keepdims=True) + 1e-8
-                return matrix / norms, ids
-    except Exception:
-        pass
-    # 路2: embeddings (GOAL A 新建, vec_json JSONB)
-    try:
-        with engine.connect() as conn:
-            rows = conn.execute(text("""
-                SELECT entity_id, vec_json FROM embeddings
-                WHERE vec_json IS NOT NULL
-            """)).all()
-    except Exception:
-        return None, None
-    if not rows:
-        return None, None
-    ids, vecs = [], []
-    for eid, vj in rows:
-        try:
-            v = vj if isinstance(vj, list) else json.loads(vj)
-            if isinstance(v, list) and len(v) > 0:
-                ids.append(eid)
-                vecs.append(v)
-        except Exception:
-            continue
-    if not vecs:
-        return None, None
-    matrix = np.array(vecs, dtype=np.float32)
-    norms = np.linalg.norm(matrix, axis=1, keepdims=True) + 1e-8
-    matrix_norm = matrix / norms
-    return matrix_norm, ids
-
-
-def _build_edges(entity_id: str, scored: list, entity: dict, anchors: list, via: str = 'naming'):
-    """按相似度分档建弱边。
-
-    via: 'embedding' 或 'naming' (影响 props 标注)
-    fingerprint: 从 file_signatures 表读 content_hash (C方案重算依赖真实文件指纹)
-    """
-    edges = []
-    repo_id = entity.get('repo_id', '')
-    # fingerprint: 优先从 file_signatures 表读真实 content_hash
-    fp = _get_file_fingerprint(entity)
-    now = datetime.utcnow()
-
-    for anchor_id, score in scored[:3]:  # 最多建3条弱边
-        if score > 0.85:
-            conf, days = 0.9, 30
-        elif score >= 0.6:
-            conf, days = 0.7, 14
-        else:
-            continue
-        edges.append({
-            'from_id': entity_id, 'to_id': anchor_id,
-            'edge_type': 'relates_to', 'from_repo': repo_id, 'to_repo': repo_id,
-            'confidence': conf, 'source': 'inferred',
-            'expires_at': now + timedelta(days=days),
-            'fingerprint': fp,
-            'props': {'score': round(score, 3), 'via': via},
-        })
-    return edges
-
-
-def _get_file_fingerprint(entity: dict) -> str:
-    """从 file_signatures 表读实体文件的 content_hash。
-
-    entity.props.file 是相对路径 (data/code/fywl-ics\...),
-    file_signatures.file_path 是绝对路径, 用路径段末尾匹配。
-    读不到时降级用 canonical hash (best-effort)。
-    """
-    import hashlib
-    props = entity.get('props') or {}
-    if isinstance(props, str):
-        try:
-            import json
-            props = json.loads(props)
-        except Exception:
-            props = {}
-    file_path = props.get('file', '') if isinstance(props, dict) else ''
-    if not file_path:
-        # 无文件信息 → 用 canonical hash 兜底
-        return hashlib.md5((entity.get('canonical', '') + entity.get('cn', '')).encode()).hexdigest()[:16]
-    # 从 file_signatures 查 content_hash (路径末尾段匹配)
-    try:
-        from domain.kg.extract.java import pg_upsert
-        engine, _ = pg_upsert._get_pg_engine()
-        if engine is None:
-            return hashlib.md5(file_path.encode()).hexdigest()[:16]
-        from sqlalchemy import text
-        # 标准化路径: 取最后两段做 LIKE 匹配 (跨绝对/相对路径)
-        norm = file_path.replace('\\', '/').split('/')
-        tail = '/'.join(norm[-3:]) if len(norm) >= 3 else file_path.replace('\\', '/')
-        with engine.connect() as conn:
-            row = conn.execute(text("""
-                SELECT content_hash FROM file_signatures
-                WHERE file_path ILIKE :tail LIMIT 1
-            """), {'tail': '%' + tail}).first()
-            if row and row[0]:
-                return row[0][:16]
-    except Exception:
-        pass
-    return hashlib.md5(file_path.encode()).hexdigest()[:16]
-
-
-def build_anchor_vectors(anchors: list, logger=print) -> dict:
-    """批量 embed anchors 算向量缓存 → {anchor_id: vec}。
-
-    让 weak_link 的向量召回主路径真正跑通 (不依赖 pgvector, 用 Python cosine_sim)。
-    anchors 多时只 embed 前 N 个 (限量, 避免全量 154 个 anchors 调 154 次 API)。
-    """
-    out = {}
-    if not anchors:
-        return out
-    # 只 embed 前 30 个 anchors (够召回, 控成本)
-    for a in anchors[:30]:
-        desc = (a.get('title') or a.get('id', '')).strip()
-        if not desc:
-            continue
-        vec = embed_one(desc)
-        if vec:
-            out[a['id']] = vec
-    logger('  [infer] anchor 向量缓存: %d/%d' % (len(out), len(anchors)))
-    return out
-
-
-def infer_batch(entities: list, anchors: list, use_embedding: bool = True, logger=print):
-    """批量推理弱关联 (GOAL A 升级: numpy 矩阵召回)。
-
-    Args:
-        entities: 待推理实体 (无强关联的)
-        anchors: 锚点列表
-        use_embedding: True 走向量主路径; False 只命名匹配
-    Returns: (edges, stats)
-
-    GOAL A 升级: 优先从 embeddings 表加载持久化向量到 numpy 矩阵,
-    每个实体只 embed 一次自己, 用矩阵乘召回 top-K (不再每个 anchor 都 embed)。
-    """
-    t0 = time.time()
-    all_edges = []
-    matched = 0
-
-    # ★ GOAL A: 优先用持久化向量矩阵 (最快)
-    vec_matrix, vec_ids = None, None
-    if use_embedding:
-        try:
-            from domain.kg.extract.java import pg_upsert
-            engine, _ = pg_upsert._get_pg_engine()
-            if engine:
-                vec_matrix, vec_ids = _load_vec_matrix(engine)
-                if vec_matrix is not None:
-                    logger('  [infer] 加载持久化向量矩阵: %d × %d' % vec_matrix.shape)
-        except Exception as e:
-            logger('  [infer] 矩阵加载失败, 降级: %s' % str(e)[:50])
-
-    # 矩阵不可用 → 降级到 build_anchor_vectors (旧路径)
-    anchor_vecs = None
-    if vec_matrix is None and use_embedding:
-        anchor_vecs = build_anchor_vectors(anchors, logger=logger)
-
-    # ★ GOAL A: 优先复用持久化向量, 缺的才批量 embed
-    entity_vecs = {}
-    if vec_matrix is not None and use_embedding:
-        from domain.kg.extract.inference.embed_builder import embed_batch as _embed_batch
-        from domain.kg.extract.java import pg_upsert as _pg
-        _engine, _ = _pg._get_pg_engine()
-        # ① 先从 embeddings_ali 批量读已有向量 (免 API 调用, 分chunk避免参数过多)
-        all_ids = [e['id'] for e in entities]
-        if _engine and all_ids:
-            try:
-                # 分 chunk 查 (每 chunk 100 个 id, 避免 PG 参数上限)
-                import json as _json
-                for ci in range(0, len(all_ids), 100):
-                    chunk_ids = all_ids[ci:ci+100]
-                    # 用 ANY(ARRAY[...]) 避免构造大量 :params
-                    arr = "ARRAY[" + ','.join("'" + eid.replace("'", "''") + "'" for eid in chunk_ids) + "]"
-                    from sqlalchemy import text as _text_fn
-                    with _engine.connect() as conn:
-                        rows = conn.execute(_text_fn(
-                            f"SELECT entity_id, vec FROM embeddings_ali WHERE entity_id = ANY({arr}) AND vec IS NOT NULL"
-                        )).all()
-                    for eid, v in rows:
-                        if isinstance(v, list) and len(v) > 0:
-                            entity_vecs[eid] = v
-                logger('  [infer] 复用 embeddings_ali 已有向量: %d/%d' % (len(entity_vecs), len(all_ids)))
-            except Exception as _e:
-                logger('  [infer] 复用查询异常: %s' % str(_e)[:50])
-        # ② 缺的才并发批量 embed (4线程并行, 破10秒关键)
-        missing = [e for e in entities if e['id'] not in entity_vecs]
-        if missing:
-            from domain.kg.extract.inference.embed_builder import embed_batch as _embed2
-            from concurrent.futures import ThreadPoolExecutor
-            descs = [((e.get('canonical', '') + ' ' + e.get('cn', '')).strip() or e['id'])[:200] for e in missing]
-            logger('  [infer] 并发 embed %d 缺失实体 (4线程)...' % len(missing))
-            try:
-                # 分 4 块并发, 每块调 embed_batch (内含 10条/批)
-                chunk = max(50, len(descs) // 4)
-                chunks = [descs[i:i+chunk] for i in range(0, len(descs), chunk)]
-                with ThreadPoolExecutor(max_workers=4) as ex:
-                    results = list(ex.map(_embed2, chunks))
-                vecs = [v for cv in results for v in cv]
-                for ent, v in zip(missing, vecs):
-                    if v:
-                        entity_vecs[ent['id']] = v
-                logger('  [infer] 实体向量就绪: %d/%d' % (len(entity_vecs), len(entities)))
-            except Exception as e:
-                logger('  [infer] 并发 embed 失败: %s' % str(e)[:50])
-
-    for i, ent in enumerate(entities):
-        try:
-            eds = infer_one(ent, anchors, anchor_vecs=anchor_vecs,
-                            vec_matrix=vec_matrix, vec_ids=vec_ids,
-                            preset_vec=entity_vecs.get(ent['id']))
-            all_edges += eds
-            if eds:
-                matched += 1
-        except Exception:
-            pass
-        if (i + 1) % 100 == 0:
-            logger('  [infer] %d/%d (匹配%d, 边%d)' % (i + 1, len(entities), matched, len(all_edges)))
-    dt = time.time() - t0
-    logger('  [infer] 完成: %d 实体 → %d 匹配 → %d 弱边 / %.1fs' % (
-        len(entities), matched, len(all_edges), dt))
-
-    # ★ GOAL A: 把新 embed 的实体向量持久化 (下次跑免 API 调用)
-    if entity_vecs and vec_matrix is not None:
-        try:
-            _persist_entity_vecs(entity_vecs, entities)
-        except Exception:
-            pass
-
-    return all_edges, {'entities': len(entities), 'matched': matched,
-                       'edges': len(all_edges), 'seconds': round(dt, 1)}
-
-
-def _persist_entity_vecs(vecs: dict, entities: list, logger=print):
-    """把推理时计算的实体向量存回 embeddings_ali (下次复用, 免 API)。"""
-    from domain.kg.extract.java import pg_upsert
-    from sqlalchemy import text
-    import json
-    engine, _ = pg_upsert._get_pg_engine()
-    if engine is None:
-        return
-    ent_map = {e['id']: e for e in entities}
-    ok = 0
-    with engine.begin() as conn:
-        for eid, vec in vecs.items():
-            ent = ent_map.get(eid, {})
-            try:
-                # embeddings_ali 表 vec 是 ARRAY 类型
-                arr_str = '{' + ','.join(str(float(v)) for v in vec[:1024]) + '}'
-                conn.execute(text("""
-                    INSERT INTO embeddings_ali (entity_id, kind, text, vec, model, embedded_at)
-                    VALUES (:id, :kind, :txt, CAST(:vec AS FLOAT[]), 'text-embedding-v3', now())
-                    ON CONFLICT (entity_id) DO NOTHING
-                """), {'id': eid, 'kind': ent.get('type', 'entity'),
-                       'txt': (ent.get('canonical', '') or eid)[:200], 'vec': arr_str})
-                ok += 1
-            except Exception:
-                pass
-    if ok:
-        logger('  [infer] 持久化 %d 条实体向量 (下次复用)' % ok)

package/templates/qoder/scripts/domain/kg/extract/mybatis/__init__.py

@@ -1,9 +0,0 @@
-# -*- coding: utf-8 -*-
-"""MyBatis mapper XML 提取器 (GOAL 3)。
-
-子模块:
-  mapper_parser    XML namespace + resultMap + 方法→SQL
-  sql_extractor    SQL 文本 → 表名 + 列引用
-  relation_builder Mapper ↔ Entity ↔ Table 三向关联
-  all              协调器: 扫所有 mapper XML → 提取 → 返回 (entities, edges)
-"""