@hupan56/wlkj 3.1.32 → 3.3.0

package/templates/qoder/scripts/domain/kg/extract/extract.py.bak

@@ -0,0 +1,430 @@
+# -*- coding: utf-8 -*-
+"""
+Shared extraction utilities for the QODER knowledge graph.
+
+Centralizes regex-based extraction that was previously copy-pasted across
+build_style_index.py and git_sync.py. The headline feature is the **call-chain
+extractor**: given a project's source tree, it builds a table mapping each
+clickable UI element (button @click + label) to the backend API endpoint it
+triggers, so test automation and impact analysis can answer:
+
+  - "点击'新增'按钮会调哪个接口?"  (test automation / QoderWork)
+  - "改这个接口会影响哪些页面/按钮?"  (dev impact analysis)
+
+Two passes:
+  1. ``build_api_fn_table``  — scan ``src/api/**/*.ts``, parse ``enum Api``
+     + ``export function`` → {fnName: {url, verb, file}}. ~100% reliable.
+  2. ``trace_clicks``       — scan ``src/views/**/*.vue``, resolve each
+     ``@click="handleX"`` to an api function via 4 patterns (direct / drawer
+     onConfirm / Modal.confirm onOk / router.push deferred).
+
+Confidence is tagged per edge (high/medium/low/deferred) so consumers know
+which traces are statically certain vs need runtime confirmation.
+"""
+import os
+import re
+
+
+# ── Reusable extraction regexes (previously duplicated) ──────────────
+
+# Table column: title + field (VxeGrid/Vben schema). Used by build_style_index.
+RE_TABLE_COL_TF = re.compile(
+    r"title:\s*['\"]([^'\"]+)['\"]\s*,\s*field:\s*['\"]([^'\"]+)['\"]")
+RE_TABLE_COL_FT = re.compile(
+    r"field:\s*['\"]([^'\"]+)['\"]\s*,\s*title:\s*['\"]([^'\"]+)['\"]")
+
+# Form field: fieldName + label
+RE_FORM_FIELD = re.compile(
+    r"fieldName:\s*['\"]([^'\"]+)['\"]\s*,\s*label:\s*['\"]([^'\"]+)['\"]")
+
+# Ant Design Vue component imports
+RE_ANT_IMPORTS = re.compile(
+    r"import\s+\{([^}]+)\}\s+from\s+['\"]ant-design-vue['\"]")
+
+
+# ── Call-chain extraction ────────────────────────────────────────────
+
+# enum Api { key = '/url', ... }  — the URL constant block
+RE_ENUM_API = re.compile(r"enum\s+Api\s*\{([^}]*)\}", re.S)
+RE_ENUM_ENTRY = re.compile(r"(\w+)\s*=\s*['\"`]([^'\"`]+)['\"`]")
+
+# export function fnName(...) { return requestClient.<verb>(<urlExpr>, ...) }
+# urlExpr can be Api.key (symbolic) or a template literal `${Api.key}/...`
+# export function fnName(...) { ... }
+# Also matches: export const fnName = (async)? (...) => {  (arrow function consts,
+# used for commonExport wrappers like `export const exportFactoryList = async (p) => ...`)
+RE_EXPORT_FN = re.compile(
+    r"(?:export\s+(?:async\s+)?function\s+(\w+)\s*\(|"
+    r"export\s+const\s+(\w+)\s*=\s*(?:async\s*)?\([^)]*\)\s*=>\s*\{?)", re.M)
+RE_REQUEST_CALL = re.compile(
+    r"requestClient\.(\w+)(?:<[^)]*?>)?\s*\(\s*(Api\.\w+|`[^`]*`|'[^']*'|\"[^\"]*\")")
+
+# commonExport(Api.key, ...) / commonDownloadExcel(fn, ...) — wrapper that
+# delegates to requestClient. commonExport takes a URL; commonDownloadExcel
+# takes an api *function* as first arg.
+RE_COMMON_EXPORT = re.compile(r"commonExport\s*\(\s*(Api\.\w+)")
+RE_COMMON_DOWNLOAD = re.compile(r"commonDownloadExcel\s*\(\s*(\w+)")
+
+# Vue template: @click="handler" or @click.stop="handler(...)"
+RE_CLICK = re.compile(r"@click(?:\.\w+)?\s*=\s*['\"]([^'\"]+)['\"]")
+
+# Button text between tags (after @click line, take nearest text node)
+# We grab the text right after the clickable element opening tag.
+RE_BTN_TEXT_AFTER_CLICK = re.compile(
+    r"@click(?:\.\w+)?\s*=\s*['\"][^'\"]*['\"][^>]*>\s*([^\n<]{1,20})", re.S)
+
+# import { fn1, fn2 } from '#/api/...'  — api imports in a Vue SFC
+RE_API_IMPORT = re.compile(
+    r"import\s+\{([^}]+)\}\s+from\s+['\"](?:#|@)/(?:api|@/api)/([^'\"]+)['\"]")
+
+# connectedComponent: localImport  (drawer/modal wiring)
+RE_CONNECTED_COMP = re.compile(r"connectedComponent:\s*(\w+)")
+
+# import localName from './xxx.vue'  (local default import for drawer)
+RE_LOCAL_VUE_IMPORT = re.compile(
+    r"import\s+(\w+)\s+from\s+['\"]([^'\"]+\.vue)['\"]")
+
+# function handlerName(...) { ... }  — capture full function body (greedy to next function/export/</script)
+RE_FN_BODY = re.compile(
+    r"(?:async\s+)?function\s+(\w+)\s*\([^)]*\)\s*\{", re.M)
+
+# modalApi.open() / drawerApi.open() — drawer trigger
+RE_DRAWER_OPEN = re.compile(r"(\w*[Aa]pi)\??\.open\s*\(\s*\)")
+
+# Modal.confirm({ onOk: ... })  — delete confirmation
+RE_MODAL_CONFIRM = re.compile(r"Modal\.confirm\s*\(\s*\{", re.S)
+
+# useVbenDrawer({ connectedComponent: X })  — drawer declaration
+RE_USE_DRAWER = re.compile(
+    r"useVbenDrawer\s*\(\s*\{[^}]*connectedComponent:\s*(\w+)", re.S)
+
+# router.push({ path: '...' })
+RE_ROUTER_PUSH = re.compile(r"router\.push\s*\(")
+
+# Pattern G: proxyConfig.ajax.query 函数 — ICS VxeGrid 表格数据加载入口
+# 真实写法 (审核 601 个文件确认):
+#   proxyConfig: { ajax: { query: async ({page}, formValues) => {
+#     return await getUnconventionalDetailList({...})  ← 导入的 api 函数
+#   }}}
+# 这不是 proxyConfig.ajax({url}) 内联 url, 而是在 query 函数体里调用已导入的 api 函数。
+# 提取 query 函数体, 交给 _find_api_calls_in_text 匹配。
+RE_PROXY_AJAX = re.compile(
+    r"proxyConfig\s*:\s*\{\s*ajax\s*:\s*\{\s*"
+    r"(?:query|queryAll|queryPage)\s*:\s*async\s*\(", re.S)
+
+
+def parse_api_enum_block(content):
+    """Extract {enumKey: '/url'} from an ``enum Api { ... }`` block.
+
+    Handles enum values containing template literals with ${VAR} — the nested
+    braces would break a naive [^}]* regex, so we use brace-depth matching.
+    """
+    urls = {}
+    # Find "enum Api {" then manually match braces to find the closing }
+    for m in re.finditer(r'enum\s+Api\s*\{', content):
+        start = m.end()
+        depth = 1
+        i = start
+        while i < len(content) and depth > 0:
+            if content[i] == '{':
+                depth += 1
+            elif content[i] == '}':
+                depth -= 1
+            i += 1
+        block = content[start:i-1] if depth == 0 else content[start:]
+        for em in RE_ENUM_ENTRY.finditer(block):
+            urls[em.group(1)] = em.group(2)
+    return urls
+
+
+def build_api_fn_table(api_dir):
+    """Scan ``src/api/**/*.ts`` and build {fnName: {url, verb, file}}.
+
+    Resolves symbolic ``Api.key`` references via the file's ``enum Api`` block.
+    Handles ``commonExport(Api.key)`` wrappers. Returns dict + the enum map
+    per file (for cross-file resolution).
+    """
+    table = {}
+    if not api_dir or not os.path.isdir(api_dir):
+        return table
+
+    for root, dirs, files in os.walk(api_dir):
+        dirs[:] = [d for d in dirs if d not in ('node_modules', 'dist', '__pycache__')]
+        for f in files:
+            if not f.endswith('.ts'):
+                continue
+            fpath = os.path.join(root, f)
+            try:
+                content = open(fpath, encoding='utf-8', errors='ignore').read()
+            except Exception:
+                continue
+            urls = parse_api_enum_block(content)
+
+            # For each exported function, find requestClient call inside its
+            # EXACT body (brace-matched, not a fixed-length snippet — a snippet
+            # would bleed into the next function and mis-resolve the Api key).
+            for fm in RE_EXPORT_FN.finditer(content):
+                fn_name = fm.group(1) or fm.group(2)  # function name or const name
+                if not fn_name:
+                    continue
+                body = _get_fn_body(content, fn_name, max_len=500)
+                if not body:
+                    continue
+                entry = None
+                # Direct requestClient.<verb>(Api.key or 'literal')
+                rm = RE_REQUEST_CALL.search(body)
+                if rm:
+                    verb = rm.group(1)
+                    url_expr = rm.group(2)
+                    url = _resolve_url_expr(url_expr, urls)
+                    if url:
+                        entry = {'url': url, 'verb': verb, 'file': fpath.replace('\\', '/')}
+                # commonExport(Api.key) wrapper
+                if not entry:
+                    cm = RE_COMMON_EXPORT.search(body)
+                    if cm:
+                        url = _resolve_url_expr(cm.group(1), urls)
+                        if url:
+                            entry = {'url': url, 'verb': 'post', 'file': fpath.replace('\\', '/')}
+                if entry:
+                    table[fn_name] = entry
+    return table
+
+
+def _resolve_url_expr(expr, urls):
+    """Resolve ``Api.key`` or template literal to a concrete URL string."""
+    expr = expr.strip()
+    if expr.startswith('Api.'):
+        key = expr[4:]
+        return urls.get(key)
+    # Template literal `${Api.key}/xxx` or plain string
+    if expr.startswith('`') or expr.startswith("'") or expr.startswith('"'):
+        inner = expr.strip('`\'"')
+        # Replace ${Api.key} placeholders
+        def repl(m):
+            return urls.get(m.group(1), m.group(0))
+        inner = re.sub(r"\$\{Api\.(\w+)\}", repl, inner)
+        # If still has Api. references, try direct
+        inner = re.sub(r"Api\.(\w+)", lambda m: urls.get(m.group(1), m.group(0)), inner)
+        return inner if '/' in inner else None
+    return None
+
+
+def _get_fn_body(content, fn_name, max_len=800):
+    """Get the body text of a named function (best-effort, ~max_len chars).
+
+    Handles both ``function fnName() {`` and ``const fnName = () => {`` forms.
+    """
+    # Try: function fnName(  OR  const fnName = (async) (...) => {
+    for pat in [
+        re.compile(r"(?:async\s+)?function\s+" + re.escape(fn_name) + r"\s*\([^)]*\)\s*\{"),
+        re.compile(r"const\s+" + re.escape(fn_name) + r"\s*=\s*(?:async\s*)?\([^)]*\)\s*=>\s*\{?"),
+    ]:
+        m = pat.search(content)
+        if m:
+            break
+    else:
+        return ''
+    start = m.end()
+    # If arrow fn without explicit {, grab the expression line instead
+    if '=>' in m.group(0) and '{' not in m.group(0):
+        return content[start:start + max_len]
+    # Simple brace matching
+    depth = 1
+    i = start
+    end = min(len(content), start + max_len)
+    while i < end and depth > 0:
+        if content[i] == '{':
+            depth += 1
+        elif content[i] == '}':
+            depth -= 1
+        i += 1
+    return content[start:i]
+
+
+def _find_api_calls_in_text(text, api_table, api_imports):
+    """Return list of (api_fn, endpoint, verb) found in a text snippet."""
+    hits = []
+    for fn in api_imports:
+        if fn in api_table and re.search(r'\b' + re.escape(fn) + r'\b', text):
+            info = api_table[fn]
+            hits.append((fn, info['url'], info.get('verb', '?')))
+    # commonDownloadExcel(fnName, ...) — first arg is an api function
+    for dm in RE_COMMON_DOWNLOAD.finditer(text):
+        fn = dm.group(1)
+        if fn in api_table:
+            info = api_table[fn]
+            hits.append((fn, info['url'], info.get('verb', '?')))
+    return hits
+
+
+def _resolve_drawer_api(content, drawer_var):
+    """Given a drawer/modal api var name, find its connectedComponent import path."""
+    # useVbenDrawer({ connectedComponent: CompName })  declared as [CompName, drawerVar]
+    # Pattern: const [CompName, drawerVar] = useVbenDrawer({ connectedComponent: compImport })
+    pat = re.compile(
+        r"const\s+\[\s*(\w+)\s*,\s*" + re.escape(drawer_var) + r"\s*\]\s*=\s*useVbenDrawer",
+        re.S)
+    m = pat.search(content)
+    if not m:
+        # Fallback: find connectedComponent near the drawer var
+        for cm in RE_CONNECTED_COMP.finditer(content):
+            comp = cm.group(1)
+            # Verify this comp's drawer var matches by proximity (within 200 chars)
+            if drawer_var in content[max(0, cm.start()-200):cm.start()+200]:
+                m = type('x', (), {'group': lambda self, i: comp})()
+                break
+    if not m:
+        return None
+    comp_name = m.group(1) if hasattr(m, 'group') else None
+    if not comp_name:
+        return None
+    # Find import localName from './xxx.vue' matching comp_name
+    for im in RE_LOCAL_VUE_IMPORT.finditer(content):
+        if im.group(1) == comp_name:
+            return im.group(2)
+    return None
+
+
+def trace_clicks(vue_path, vue_content, api_table):
+    """Extract click→api traces from a single Vue SFC.
+
+    Returns list of trace dicts:
+      {vue_file, button, handler, api_fn, endpoint, verb, confidence}
+    confidence: 'high' (direct), 'medium' (drawer 1-hop), 'low' (modal confirm),
+                'deferred' (router.push).
+    """
+    traces = []
+    dirname = os.path.dirname(vue_path)
+
+    # 1. Collect api imports in this SFC
+    api_imports = set()
+    for im in RE_API_IMPORT.finditer(vue_content):
+        for name in im.group(1).split(','):
+            name = name.strip().split(' as ')[0].strip()
+            if name and name in api_table:
+                api_imports.add(name)
+
+    # 2. Find all @click handlers + nearest button text
+    clicks = list(RE_CLICK.finditer(vue_content))
+    if not clicks:
+        return traces
+
+    # Build drawer map: drawerVar → connected component .vue path.
+    # Pattern: const [Comp, drawerVar] = useVbenDrawer({ connectedComponent: compImport })
+    # Note: Comp name may differ from compImport (e.g. [FactoryModal, modalApi] with
+    # connectedComponent: factoryModal). So we link drawerVar → compImport → import path.
+    drawer_map = {}
+    # Find all useVbenDrawer declarations and capture the drawer var + connectedComponent
+    for dm in re.finditer(
+            r"const\s+\[\s*\w+\s*,\s*(\w+)\s*\]\s*=\s*useVbenDrawer\s*\(\s*\{([^}]*)\}",
+            vue_content, re.S):
+        drawer_var = dm.group(1)
+        decl_body = dm.group(2)
+        cm = re.search(r"connectedComponent:\s*(\w+)", decl_body)
+        if not cm:
+            continue
+        comp_import_name = cm.group(1)
+        # Resolve comp_import_name → './xxx.vue' via local imports
+        for im in RE_LOCAL_VUE_IMPORT.finditer(vue_content):
+            if im.group(1) == comp_import_name:
+                drawer_map[drawer_var] = im.group(2)
+                break
+
+    # 3. For each click, resolve to api
+    for i, cm in enumerate(clicks):
+        handler_expr = cm.group(1).strip()
+        # Button text: text right after the element, or previous text node
+        btn_text = ''
+        tm = RE_BTN_TEXT_AFTER_CLICK.search(vue_content, cm.start())
+        if tm:
+            btn_text = tm.group(1).strip()[:12]
+        # Strip Vue interpolation {{ }} from button text (e.g. "{{ item.name }}")
+        btn_text = re.sub(r'\{\{[^}]*\}\}', '', btn_text).strip()[:12]
+
+        # Skip inline expressions that aren't function calls:
+        # $emit, item.remove(), splice, push — pure frontend, no API
+        if handler_expr.startswith('$') or '.splice(' in handler_expr or '.push(' in handler_expr:
+            continue
+
+        # Get handler function name (strip args/calls)
+        handler_name = handler_expr.split('(')[0].split('.')[0].strip()
+        if not handler_name or handler_name in ('undefined', '', 'true', 'false'):
+            continue
+        # Skip single-word inline handlers (add, remove, item, emit) that are
+        # likely data/methods shorthand, not named handler functions
+        if handler_name in ('item', 'emit', 'row', 'data') and '.' not in handler_expr:
+            continue
+
+        fn_body = _get_fn_body(vue_content, handler_name)
+
+        trace = {
+            'vue_file': vue_path.replace('\\', '/'),
+            'button': btn_text,
+            'handler': handler_name,
+            'api_fn': None, 'endpoint': None, 'verb': None,
+            'confidence': None,
+        }
+
+        # Pattern B: direct api call in handler body
+        hits = _find_api_calls_in_text(fn_body, api_table, api_imports)
+        if hits:
+            fn, url, verb = hits[0]
+            trace.update(api_fn=fn, endpoint=url, verb=verb, confidence='high')
+            traces.append(trace)
+            continue
+
+        # Pattern D: drawer/modal open → resolve connected component
+        open_m = RE_DRAWER_OPEN.search(fn_body)
+        if open_m:
+            drawer_var = open_m.group(1)
+            comp_rel = drawer_map.get(drawer_var)
+            if comp_rel:
+                comp_path = os.path.normpath(os.path.join(dirname, comp_rel))
+                if os.path.isfile(comp_path):
+                    try:
+                        comp_content = open(comp_path, encoding='utf-8', errors='ignore').read()
+                        comp_api_imports = set()
+                        for im in RE_API_IMPORT.finditer(comp_content):
+                            for name in im.group(1).split(','):
+                                name = name.strip().split(' as ')[0].strip()
+                                if name in api_table:
+                                    comp_api_imports.add(name)
+                        # Find onConfirm/handleConfirm body in the component
+                        for confirm_name in ('handleConfirm', 'onConfirm', 'handleSubmit', 'onOk'):
+                            cbody = _get_fn_body(comp_content, confirm_name)
+                            if cbody:
+                                chits = _find_api_calls_in_text(cbody, api_table, comp_api_imports)
+                                if chits:
+                                    fn, url, verb = chits[0]
+                                    trace.update(api_fn=fn, endpoint=url, verb=verb,
+                                                 confidence='medium')
+                                    break
+                    except Exception:
+                        pass
+            if trace['endpoint']:
+                traces.append(trace)
+                continue
+
+        # Modal.confirm({ onOk }) pattern
+        mc_m = RE_MODAL_CONFIRM.search(fn_body)
+        if mc_m:
+            onok_body = fn_body[mc_m.end():]
+            hits = _find_api_calls_in_text(onok_body[:400], api_table, api_imports)
+            if hits:
+                fn, url, verb = hits[0]
+                trace.update(api_fn=fn, endpoint=url, verb=verb, confidence='low')
+                traces.append(trace)
+                continue
+
+        # router.push — deferred
+        if RE_ROUTER_PUSH.search(fn_body):
+            trace['confidence'] = 'deferred'
+            traces.append(trace)
+            continue
+
+        # Unresolved — record as low confidence (handler exists but no api found)
+        trace['confidence'] = 'unresolved'
+        traces.append(trace)
+
+    return traces

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

@@ -0,0 +1,9 @@
+# -*- coding: utf-8 -*-
+"""L3 推断层 (GOAL 5): 跨源锚点关联。
+
+子模块:
+  weak_link     embedding 弱关联推理 (向量召回, 需 pgvector; 不可用时降级命名匹配)
+  naming_matcher 命名同源匹配 (AssetController ↔ asset ↔ 资产管理)
+  recompute     C 方案指纹重算 (30天过期弱边对比指纹)
+  promote       弱边升格 (出现强关联时弱边删除)
+"""

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

@@ -0,0 +1,206 @@
+# -*- coding: utf-8 -*-
+"""D2: 补社区摘要 + 摘要向量。
+
+对 graph_communities 表里 summary 为空的社区:
+  ① 读 member_ids → 取成员的 canonical+cn → LLM 生成摘要
+  ② 对摘要算 embedding → summary_vec
+
+独立于现有 summarize_communities (不改动它), 直接补 PG。
+"""
+from __future__ import annotations
+import os
+import sys
+import json
+import time
+import urllib.request
+from concurrent.futures import ThreadPoolExecutor
+
+_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
+
+_SUMMARY_PROMPT = """你是软件架构师。下面是一个代码社区(聚类在一起的相关功能)的成员列表。
+请用1-2句话概括这个社区负责什么业务功能。
+
+成员列表(类名/端点/按钮, 括号内是中文含义):
+%s
+
+只返回摘要文本, 不要解释。"""
+
+
+def _call_qwen(prompt: str, timeout: int = 20) -> str:
+    key = os.environ.get('DASHSCOPE_API_KEY', '')
+    base = os.environ.get('ALI_CHAT_BASE', '').rstrip('/')
+    model = os.environ.get('ALI_CHAT_MODEL', 'qwen-plus')
+    if not key or not base:
+        return ''
+    req = urllib.request.Request(
+        base + '/chat/completions',
+        data=json.dumps({'model': model, 'messages': [{'role': 'user', 'content': prompt}],
+                         'max_tokens': 200, 'temperature': 0.2}).encode('utf-8'),
+        headers={'Authorization': 'Bearer ' + key, 'Content-Type': 'application/json'},
+    )
+    try:
+        with urllib.request.urlopen(req, timeout=timeout) as resp:
+            return json.loads(resp.read())['choices'][0]['message']['content'].strip()
+    except Exception:
+        return ''
+
+
+def _embed(text: str) -> list:
+    """调 DashScope embedding, 返回 1024 维向量。"""
+    key = os.environ.get('DASHSCOPE_API_KEY', '')
+    if not key or not text:
+        return []
+    req = urllib.request.Request(
+        'https://dashscope.aliyuncs.com/compatible-mode/v1/embeddings',
+        data=json.dumps({'model': 'text-embedding-v3', 'input': [text[:500]], 'dimensions': 1024}).encode('utf-8'),
+        headers={'Authorization': 'Bearer ' + key, 'Content-Type': 'application/json'},
+    )
+    try:
+        with urllib.request.urlopen(req, timeout=15) as resp:
+            return json.loads(resp.read())['data'][0]['embedding']
+    except Exception:
+        return []
+
+
+def summarize_missing(limit: int = 2500, do_embed: bool = True, logger=print):
+    """补全缺摘要的社区。
+
+    Args:
+        limit: 上限 (默认 2500, 覆盖全部 2206 个缺的)
+        do_embed: True 同时补 summary_vec
+    """
+    from sqlalchemy import text
+    from domain.kg.extract.java import pg_upsert
+
+    engine, _ = pg_upsert._get_pg_engine()
+    if engine is None:
+        return {'error': 'PG 不可用'}
+
+    # 取缺摘要的社区
+    with engine.connect() as conn:
+        rows = conn.execute(text("""
+            SELECT id, level, size, member_ids FROM graph_communities
+            WHERE summary IS NULL OR summary = ''
+            LIMIT :lim
+        """), {'lim': limit}).all()
+    logger('  [d2] %d 个社区待补摘要' % len(rows))
+    if not rows:
+        return {'summarized': 0}
+
+    # 批量取成员的 canonical+cn (一次查)
+    all_member_ids = set()
+    for r in rows:
+        try:
+            mids = json.loads(r[3]) if isinstance(r[3], str) else (r[3] or [])
+            all_member_ids.update(mids[:20])  # 每社区最多取20个成员
+        except Exception:
+            pass
+
+    member_info = {}  # {entity_id: "canonical(cn)"}
+    if all_member_ids:
+        member_list = list(all_member_ids)[:5000]  # 限 5000 避免查询太大
+        # 分 chunk 查
+        for ci in range(0, len(member_list), 200):
+            chunk = member_list[ci:ci+200]
+            arr = "ARRAY[" + ','.join("'" + eid.replace("'", "''") + "'" for eid in chunk) + "]"
+            with engine.connect() as conn:
+                mrows = conn.execute(text(
+                    f"SELECT id, canonical, cn FROM entities WHERE id = ANY({arr})"
+                )).all()
+            for eid, canonical, cn in mrows:
+                desc = canonical or eid
+                if cn:
+                    desc += '(' + cn[:20] + ')'
+                member_info[eid] = desc[:50]
+
+    logger('  [d2] 成员信息: %d 条' % len(member_info))
+
+    # 批量生成摘要 (4线程并发)
+    def make_summary(row):
+        cid, level, size, member_ids_raw = row
+        try:
+            mids = json.loads(member_ids_raw) if isinstance(member_ids_raw, str) else (member_ids_raw or [])
+        except Exception:
+            mids = []
+        members_desc = [member_info.get(mid, mid) for mid in mids[:15]]
+        if not members_desc:
+            members_desc = [mid for mid in mids[:15]]
+        if not members_desc:
+            return (cid, '空社区')
+        prompt = _SUMMARY_PROMPT % '\n'.join(members_desc)
+        summary = _call_qwen(prompt)
+        if not summary:
+            # 兜底: 实体名拼接
+            summary = '、'.join(members_desc[:5]) + '等相关功能'
+        return (cid, summary[:200])
+
+    # 并发跑
+    t0 = time.time()
+    batches = [rows[i:i+10] for i in range(0, len(rows), 10)]
+    all_summaries = []
+    for bi in range(0, len(batches), 5):
+        chunk = batches[bi:bi+5]
+        with ThreadPoolExecutor(max_workers=4) as ex:
+            results = list(ex.map(make_summary, [r for b in chunk for r in b]))
+        all_summaries += results
+        if (bi//5+1) % 10 == 0:
+            logger('  [d2] %d/%d 社区摘要生成 (%d)' % (len(all_summaries), len(rows), len(all_summaries)))
+
+    logger('  [d2] 摘要生成完成: %d / %.1fs' % (len(all_summaries), time.time()-t0))
+
+    # 写 PG (分块提交)
+    ok = 0
+    vec_ok = 0
+    for i in range(0, len(all_summaries), 100):
+        chunk = all_summaries[i:i+100]
+        with engine.begin() as conn:
+            for cid, summary in chunk:
+                try:
+                    # 算摘要向量 (可选)
+                    vec_str = ''
+                    if do_embed:
+                        vec = _embed(summary)
+                        if vec:
+                            # summary_vec 存成 JSONB (兼容无 pgvector)
+                            vec_str = json.dumps(vec)
+                    if vec_str:
+                        # summary_vec 是 ARRAY 类型, 用 FLOAT[] 写入
+                        arr_str = '{' + ','.join(str(float(v)) for v in vec[:1024]) + '}'
+                        conn.execute(text("""
+                            UPDATE graph_communities SET summary=:s, summary_vec=CAST(:arr AS FLOAT[])
+                            WHERE id=:id
+                        """), {'s': summary, 'arr': arr_str, 'id': cid})
+                        vec_ok += 1
+                    else:
+                        conn.execute(text("""
+                            UPDATE graph_communities SET summary=:s WHERE id=:id
+                        """), {'s': summary, 'id': cid})
+                    ok += 1
+                except Exception:
+                    pass
+        if (i//100+1) % 5 == 0:
+            logger('  [d2] 写入 %d/%d (vec=%d)' % (ok, len(all_summaries), vec_ok))
+
+    dt = time.time() - t0
+    logger('  [d2] 完成: %d 摘要 / %d 向量 / %.1fs' % (ok, vec_ok, dt))
+    return {'summarized': ok, 'vectorized': vec_ok, 'seconds': round(dt, 1)}
+
+
+if __name__ == '__main__':
+    import argparse
+    ap = argparse.ArgumentParser()
+    ap.add_argument('--limit', type=int, default=2500)
+    ap.add_argument('--no-embed', action='store_true')
+    args = ap.parse_args()
+    try:
+        from dotenv import load_dotenv
+        for p in ['wlinkj-workspace/backend/.env', '.env']:
+            if os.path.isfile(p): load_dotenv(p); break
+    except: pass
+    r = summarize_missing(limit=args.limit, do_embed=not args.no_embed)
+    print(json.dumps(r, ensure_ascii=False, indent=2))