@hupan56/wlkj 3.2.0 → 3.3.0

package/templates/qoder/scripts/domain/kg/extract/db/fk_extractor.py

@@ -0,0 +1,55 @@
+# -*- coding: utf-8 -*-
+"""外键关系提取器: KEY_COLUMN_USAGE → references 边。
+
+让 table_impact 真正能做"改表影响谁"的跨表追溯。
+"""
+from __future__ import annotations
+from . import schema_extractor as _se
+
+
+def extract_foreign_keys(repo_id: str = 'fywl-ics', logger=print):
+    """连 MySQL → 提取外键关系 → references 边。
+
+    Returns: [{from_id, to_id, edge_type:'references', ...}] 连不上返回 []
+    """
+    if not _se._can_connect():
+        return []
+    try:
+        import pymysql
+    except ImportError:
+        return []
+
+    conn = pymysql.connect(host=_se.MYSQL_HOST, port=_se.MYSQL_PORT, user=_se.MYSQL_USER,
+                           password=_se.MYSQL_PASSWORD, charset='utf8mb4',
+                           cursorclass=pymysql.cursors.DictCursor,
+                           connect_timeout=5, read_timeout=30)
+    edges = []
+    try:
+        cur = conn.cursor()
+        cur.execute("SELECT schema_name FROM information_schema.schemata "
+                    "WHERE schema_name LIKE %s", (_se.DB_NAME_PREFIX + '%',))
+        dbs = [r['schema_name'] for r in cur.fetchall()]
+        for db in dbs:
+            # 外键关系
+            cur.execute("""
+                SELECT TABLE_NAME, COLUMN_NAME, REFERENCED_TABLE_NAME, REFERENCED_COLUMN_NAME
+                FROM information_schema.KEY_COLUMN_USAGE
+                WHERE TABLE_SCHEMA=%s AND REFERENCED_TABLE_NAME IS NOT NULL
+            """, (db,))
+            for r in cur.fetchall():
+                from_tbl = r['TABLE_NAME'].lower()
+                to_tbl = r['REFERENCED_TABLE_NAME'].lower()
+                edges.append({
+                    'from_id': 'TBL:%s:%s' % (repo_id, from_tbl),
+                    'to_id': 'TBL:%s:%s' % (repo_id, to_tbl),
+                    'edge_type': 'references',
+                    'from_repo': repo_id, 'to_repo': repo_id,
+                    'confidence': 1.0, 'source': 'db_fk',
+                    'props': {'column': r['COLUMN_NAME'],
+                              'ref_column': r['REFERENCED_COLUMN_NAME'],
+                              'schema': db},
+                })
+        logger('  [db-fk] %d 条外键关系' % len(edges))
+    finally:
+        conn.close()
+    return edges

package/templates/qoder/scripts/domain/kg/extract/db/schema_extractor.py

@@ -0,0 +1,90 @@
+# -*- coding: utf-8 -*-
+"""连 MySQL information_schema → 灌 db_tables / db_columns。
+
+复用 kg_build_db.py 的 MySQL 连接配置 (内网 10.54.6.9, fywl_ics_* 库)。
+连不上内网时 best-effort 返回空, 不阻塞 (GOAL 3 主链路是 mapper XML)。
+"""
+from __future__ import annotations
+import os
+import sys
+import socket
+
+_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
+
+# 复用 kg_build_db 的配置
+MYSQL_HOST = os.environ.get('MYSQL_HOST', '10.54.6.9')
+MYSQL_PORT = int(os.environ.get('MYSQL_PORT', '3306'))
+MYSQL_USER = os.environ.get('MYSQL_USER', 'fywl_ics_test')
+MYSQL_PASSWORD = os.environ.get('MYSQL_PASSWORD', 'Fywl_ics_test56476')
+DB_NAME_PREFIX = os.environ.get('DB_NAME_PREFIX', 'fywl_ics_')
+
+
+def _can_connect(timeout=3):
+    """探测内网 MySQL 是否可达。"""
+    try:
+        with socket.create_connection((MYSQL_HOST, MYSQL_PORT), timeout=timeout):
+            return True
+    except Exception:
+        return False
+
+
+def extract_all_schema(repo_id: str = 'fywl-ics', logger=print):
+    """连 MySQL → 灌 db_tables + db_columns。
+
+    Returns: (tables: list[dict], columns: list[dict]) 连不上返回 ([], [])
+    """
+    if not _can_connect():
+        logger('  [db] ⚠️ 内网 MySQL 不可达 (%s:%s), 跳过 schema 提取' % (MYSQL_HOST, MYSQL_PORT))
+        return [], []
+    try:
+        import pymysql
+    except ImportError:
+        logger('  [db] pymysql 未装, 跳过')
+        return [], []
+
+    logger('  [db] 连接 MySQL %s:%s ...' % (MYSQL_HOST, MYSQL_PORT))
+    conn = pymysql.connect(host=MYSQL_HOST, port=MYSQL_PORT, user=MYSQL_USER,
+                           password=MYSQL_PASSWORD, charset='utf8mb4',
+                           cursorclass=pymysql.cursors.DictCursor,
+                           connect_timeout=5, read_timeout=30)
+    tables, columns = [], []
+    try:
+        cur = conn.cursor()
+        cur.execute("SELECT schema_name FROM information_schema.schemata "
+                    "WHERE schema_name LIKE %s ORDER BY schema_name",
+                    (DB_NAME_PREFIX + '%'))
+        dbs = [r['schema_name'] for r in cur.fetchall()]
+        logger('  [db] 发现 %d 个业务库: %s' % (len(dbs), dbs[:3]))
+
+        for db in dbs:
+            # 表
+            cur.execute("SELECT table_name, table_comment, table_rows "
+                        "FROM information_schema.tables WHERE table_schema=%s", (db,))
+            for r in cur.fetchall():
+                tables.append({
+                    'repo_id': repo_id, 'schema_name': db,
+                    'table_name': r['table_name'], 'table_comment': r.get('table_comment') or '',
+                    'rows_count': r.get('table_rows'),
+                })
+            # 列
+            cur.execute("SELECT table_name, column_name, data_type, is_nullable, "
+                        "column_comment, ordinal_position "
+                        "FROM information_schema.columns WHERE table_schema=%s "
+                        "ORDER BY table_name, ordinal_position", (db,))
+            for r in cur.fetchall():
+                columns.append({
+                    'repo_id': repo_id, 'schema_name': db,
+                    'table_name': r['table_name'], 'column_name': r['column_name'],
+                    'data_type': r['data_type'], 'is_nullable': r['is_nullable'],
+                    'column_comment': r.get('column_comment') or '',
+                    'ordinal_position': r.get('ordinal_position'),
+                })
+        logger('  [db] 完成: %d 表 / %d 列' % (len(tables), len(columns)))
+    finally:
+        conn.close()
+    return tables, columns

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

@@ -428,3 +428,87 @@ def trace_clicks(vue_path, vue_content, api_table):
         traces.append(trace)
 
     return traces
+
+
+# ============================================================
+# GOAL 3 泛化: Carmg-H5 (Vant/H5) 风格 API + 调用提取
+# ============================================================
+# Carmg-H5 的 API 定义方式和 fywl-ui 不同:
+#   fywl-ui:    enum Api { X='/url' } + requestClient.post(Api.X)
+#   Carmg-H5:   export function fn(data){ const params={url:'/x',method:'post'}; return fetch(params) }
+# 以及 van-button 的 @click/@tap 事件。
+# 下面两个函数让 extract.py 能同时处理两种风格。
+
+# Carmg-H5 API: export function fnName(...) { ... url: '/xxx' ... method: 'post' ... }
+RE_H5_API_FN = re.compile(
+    r"export\s+function\s+(\w+)\s*\([^)]*\)\s*\{(?:(?!\}).)*?"
+    r"url:\s*['\"]([^'\"]+)['\"](?:(?!\}).)*?"
+    r"(?:method:\s*['\"](\w+)['\"])?",
+    re.DOTALL
+)
+
+
+def build_api_fn_table_h5(api_dir):
+    """扫 src/api/**/*.js (Carmg-H5 风格) → {fnName: {url, verb, file}}。
+
+    识别 export function + url: 字面量模式。
+    """
+    table = {}
+    if 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 ('dist', 'node_modules', '__pycache__')]
+        for f in files:
+            if not (f.endswith('.js') or f.endswith('.ts')):
+                continue
+            fp = os.path.join(root, f)
+            try:
+                content = open(fp, encoding='utf-8', errors='ignore').read()
+            except Exception:
+                continue
+            for m in RE_H5_API_FN.finditer(content):
+                fn_name, url, verb = m.group(1), m.group(2), m.group(3) or 'get'
+                table[fn_name] = {'url': url, 'verb': verb.lower(), 'file': fp}
+    return table
+
+
+def trace_clicks_h5(vue_path, vue_content, api_table):
+    """Vant/H5 风格的 click→api 追踪。
+
+    和 trace_clicks 区别:
+      - 同时认 @click 和 @tap (Vant 用 @tap)
+      - API 调用是 import { fn } from '@/api/xx' + fn(args) (不是 requestClient.xx)
+    """
+    if not api_table:
+        return []
+    traces = []
+    # 收集 @click / @tap
+    clicks = list(re.finditer(r"@(?:click|tap)(?:\.\w+)?\s*=\s*['\"]([^'\"]+)['\"]", vue_content))
+    if not clicks:
+        return []
+    # 收集 import { fn1, fn2 } from '@/api/...'
+    imported = set()
+    for m in re.finditer(r"import\s*\{([^}]+)\}\s*from\s*['\"][^'\"]*api[^'\"]*['\"]", vue_content):
+        for n in re.split(r'[,\s]+', m.group(1)):
+            n = n.strip()
+            if n:
+                imported.add(n)
+    # script 里直接调用的 api 函数 (imported 集合内的)
+    for click in clicks:
+        handler = click.group(1).split('(')[0].strip()
+        if not handler:
+            continue
+        # 在 script 里找 handler 函数体, 看它调了哪些 imported api
+        handler_body = _get_fn_body(vue_content, handler)
+        if not handler_body:
+            continue
+        for api_fn in imported:
+            if api_fn in api_table and re.search(r'\b' + re.escape(api_fn) + r'\s*\(', handler_body):
+                info = api_table[api_fn]
+                traces.append({
+                    'vue_file': vue_path, 'button_text': handler,
+                    'handler': handler, 'api_fn': api_fn,
+                    'endpoint': info['url'], 'verb': info['verb'],
+                    'api_file': info['file'], 'confidence': 'high',
+                })
+    return traces

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       弱边升格 (出现强关联时弱边删除)
+"""