@hupan56/wlkj 2.5.0 → 2.7.0

package/templates/qoder/scripts/common/extract.py

@@ -0,0 +1,419 @@
+# -*- 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*\(")
+
+
+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