@hupan56/wlkj 3.3.0 → 3.3.1

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

@@ -1,430 +0,0 @@
-# -*- 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