@hupan56/wlkj 3.0.0 → 3.1.2

package/templates/qoder/scripts/{common → domain/kg/extract}/ts_extract.py

@@ -1,536 +1,614 @@
-# -*- coding: utf-8 -*-
-"""
-Tree-sitter based extraction for the call-chain index (E2).
-
-Replaces the regex-based function-body extraction in common/extract.py with
-AST parsing. Tree-sitter gives us:
-  - Exact function boundaries (brace matching is never wrong)
-  - All call expressions inside a function (not just requestClient.*)
-  - Import resolution (named imports from api modules)
-
-This module provides:
-  - ts_build_api_fn_table(api_dir) — same output schema as build_api_fn_table,
-    but uses AST for precise body boundaries
-  - ts_extract_clicks(vue_path, content, api_table) — same schema as trace_clicks,
-    but uses AST for function body + call detection
-
-Fallback: if tree-sitter is not installed, falls back to the regex version.
-"""
-import os
-import re
-
-try:
-    from tree_sitter import Language, Parser
-    import tree_sitter_typescript as tst
-    _TS_AVAILABLE = True
-    _TS_LANG = Language(tst.language_typescript())
-    _PARSER = Parser(_TS_LANG)
-except Exception:
-    _TS_AVAILABLE = False
-    _PARSER = None
-
-from common.extract import (
-    build_api_fn_table as regex_build_api_fn_table,
-    trace_clicks as regex_trace_clicks,
-    parse_api_enum_block, _resolve_url_expr, _find_api_calls_in_text,
-    RE_API_IMPORT, RE_CLICK, RE_BTN_TEXT_AFTER_CLICK, RE_COMMON_DOWNLOAD,
-    RE_DRAWER_OPEN, RE_MODAL_CONFIRM, RE_ROUTER_PUSH, RE_LOCAL_VUE_IMPORT,
-    _resolve_drawer_api as _regex_resolve_drawer,
-)
-
-
-def _node_text(node, source_bytes):
-    """Get text of a tree-sitter node."""
-    return source_bytes[node.start_byte:node.end_byte].decode('utf-8', errors='replace')
-
-
-def _find_calls_in_function_ast(func_node, source_bytes):
-    """Find all call_expression nodes inside a function body via AST.
-
-    Returns list of (callee_text, full_call_text).
-    """
-    calls = []
-    cursor = func_node.walk()
-    cursor.goto_first_child()
-    # Descend into body
-    def visit(node):
-        if node.type == 'call_expression':
-            callee = node.child_by_field_name('function')
-            if callee:
-                calls.append((_node_text(callee, source_bytes), _node_text(node, source_bytes)))
-        for child in node.children:
-            visit(child)
-    visit(func_node)
-    return calls
-
-
-def ts_build_api_fn_table(api_dir):
-    """Tree-sitter version: build {fnName: {url, verb, file}} from api/*.ts.
-
-    Uses AST for exact function boundaries + call detection. Falls back to
-    regex version if tree-sitter unavailable.
-    """
-    if not _TS_AVAILABLE:
-        return regex_build_api_fn_table(api_dir)
-
-    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:
-                source = open(fpath, 'rb').read()
-            except Exception:
-                continue
-            urls = parse_api_enum_block(source.decode('utf-8', errors='replace'))
-
-            try:
-                tree = _PARSER.parse(source)
-            except Exception:
-                # Fallback to regex for this file
-                continue
-
-            # Walk AST to find export function / export const = () => {}
-            def visit(node):
-                if node.type == 'export_statement':
-                    for child in node.children:
-                        if child.type == 'function_declaration':
-                            _process_fn(child, source, urls, fpath, table)
-                        elif child.type == 'lexical_declaration':
-                            # export const fnName = (...) => { ... }
-                            _process_const_fn(child, source, urls, fpath, table)
-                elif node.type == 'function_declaration':
-                    # Non-exported but still processable
-                    pass
-                for child in node.children:
-                    visit(child)
-
-            visit(tree.root_node)
-
-    # Merge with regex results (regex catches some TS-sitter misses)
-    regex_table = regex_build_api_fn_table(api_dir)
-    for k, v in regex_table.items():
-        if k not in table:
-            table[k] = v
-
-    return table
-
-
-def _process_fn(fn_node, source, urls, fpath, table):
-    """Process a function_declaration node."""
-    name_node = fn_node.child_by_field_name('name')
-    if not name_node:
-        return
-    fn_name = _node_text(name_node, source)
-    body = fn_node.child_by_field_name('body')
-    if not body:
-        return
-    _extract_api_call(fn_name, body, source, urls, fpath, table)
-
-
-def _process_const_fn(decl_node, source, urls, fpath, table):
-    """Process: export const fnName = (params) => { ... } or async."""
-    # Find the variable declarator
-    for child in decl_node.children:
-        if child.type == 'variable_declarator':
-            name_node = child.child_by_field_name('name')
-            value_node = child.child_by_field_name('value')
-            if not name_node or not value_node:
-                continue
-            fn_name = _node_text(name_node, source)
-            # Arrow function body
-            body = None
-            if value_node.type == 'arrow_function':
-                body = value_node.child_by_field_name('body')
-            elif value_node.type == 'function':
-                body = value_node.child_by_field_name('body')
-            if body:
-                _extract_api_call(fn_name, body, source, urls, fpath, table)
-
-
-def _extract_api_call(fn_name, body_node, source, urls, fpath, table):
-    """Find requestClient calls inside a function body via AST."""
-    calls = _find_calls_in_function_ast(body_node, source)
-    entry = None
-    for callee, full_call in calls:
-        # requestClient.post<...>(Api.key, ...) or requestClient.get(...)
-        if callee.startswith('requestClient.'):
-            verb = callee.split('.')[-1]
-            # Extract first argument (Api.key or string literal)
-            m = re.search(r'requestClient\.\w+(?:<[^)]*?>)?\s*\(\s*(Api\.\w+|`[^`]*`|\'[^\']*\'|"[^"]*")', full_call)
-            if m:
-                url = _resolve_url_expr(m.group(1), urls)
-                if url:
-                    entry = {'url': url, 'verb': verb, 'file': fpath.replace('\\', '/')}
-                    break
-        # commonExport(Api.key, ...)
-        elif callee == 'commonExport':
-            m = re.search(r'commonExport\s*\(\s*(Api\.\w+)', full_call)
-            if m:
-                url = _resolve_url_expr(m.group(1), urls)
-                if url:
-                    entry = {'url': url, 'verb': 'post', 'file': fpath.replace('\\', '/')}
-                    break
-    if entry:
-        table[fn_name] = entry
-
-
-def ts_get_fn_body_ast(content, fn_name):
-    """Get function body text via tree-sitter AST (exact boundaries).
-
-    More reliable than _get_fn_body's brace-counting for complex code.
-    """
-    if not _TS_AVAILABLE:
-        from common.extract import _get_fn_body
-        return _get_fn_body(content, fn_name)
-
-    source = content.encode('utf-8')
-    try:
-        tree = _PARSER.parse(source)
-    except Exception:
-        from common.extract import _get_fn_body
-        return _get_fn_body(content, fn_name)
-
-    root = tree.root_node
-
-    def find_fn(node):
-        if node.type in ('function_declaration', 'method_definition'):
-            name = node.child_by_field_name('name')
-            if name and _node_text(name, source) == fn_name:
-                body = node.child_by_field_name('body')
-                if body:
-                    return _node_text(body, source)
-        for child in node.children:
-            result = find_fn(child)
-            if result:
-                return result
-        return None
-
-    body = find_fn(root)
-    if body:
-        return body
-    # Fallback: arrow function const
-    from common.extract import _get_fn_body
-    return _get_fn_body(content, fn_name)
-
-
-def _resolve_props_api_from_parent(parent_content, parent_path, drawer_map, drawer_var, api_table):
-    """Resolve props.api() by looking at the PARENT template.
-
-    When a drawer component's handler calls props.api(), the actual API
-    function was passed by the parent via :api="someFn" in the template.
-    This finds that binding and checks if someFn is a known api import.
-
-    Returns the api function name if found, else None.
-    """
-    # The drawer component tag name in template is the FIRST element of the
-    # destructured useVbenDrawer: const [CompTag, drawerVar] = useVbenDrawer(...)
-    # Find it: const [<CompTag>, drawerVar] = useVbenDrawer
-    comp_tag_m = re.search(
-        r"const\s+\[\s*(\w+)\s*,\s*" + re.escape(drawer_var) + r"\s*\]\s*=",
-        parent_content)
-    if not comp_tag_m:
-        return None
-    comp_tag = comp_tag_m.group(1)
-
-    # Find <CompTag ... :api="fnName" ... /> in the template
-    # Match :api="xxx" or :api="xxx" within a tag that starts with comp_tag
-    tag_pattern = re.compile(
-        r'<' + re.escape(comp_tag) + r'\b[^>]*?:api\s*=\s*["\'](\w+)["\']',
-        re.S)
-    m = tag_pattern.search(parent_content)
-    if not m:
-        # Also try kebab-case tag name (PascalCase → kebab-case)
-        kebab = re.sub(r'([A-Z])', r'-\1', comp_tag).lower().lstrip('-')
-        tag_pattern2 = re.compile(
-            r'<' + re.escape(kebab) + r'\b[^>]*?:api\s*=\s*["\'](\w+)["\']',
-            re.S)
-        m = tag_pattern2.search(parent_content)
-    if not m:
-        return None
-
-    api_fn_name = m.group(1)
-    if api_fn_name in api_table:
-        return api_fn_name
-
-    # Maybe it's a wrapped call like :api="(data) => someFn(data)"
-    # Try to extract the function name from arrow expressions
-    inner_fn = re.search(r'\b(\w+)\s*\(', api_fn_name)
-    if inner_fn and inner_fn.group(1) in api_table:
-        return inner_fn.group(1)
-
-    return None
-
-
-def _resolve_composable_handler(vue_content, vue_path, handler_name, api_table):
-    """Resolve a handler that comes from a composable (useXxx()).
-
-    Pattern: const { handleAdd } = useLeftBoxUser()
-    → find the composable import path → open it → find handleAdd's definition.
-    Returns the function body text, or '' if not found.
-    """
-    # Find: const { ... handlerName ... } = useXxx()
-    m = re.search(
-        r'const\s*\{([^}]*\b' + re.escape(handler_name) + r'\b[^}]*)\}\s*=\s*use(\w+)\s*\(',
-        vue_content)
-    if not m:
-        return ''
-    composable_fn = 'use' + m.group(2)  # e.g. useLeftBoxUser
-
-    # Find import of useXxx from '...'
-    imp_m = re.search(
-        r'import\s+\{[^}]*\b' + re.escape(composable_fn) + r'\b[^}]*\}\s+from\s+[\'"]([^\'"]+)[\'"]',
-        vue_content)
-    if not imp_m:
-        return ''
-    import_path = imp_m.group(1)
-
-    # Resolve import path to file
-    dirname = os.path.dirname(vue_path)
-    if import_path.startswith('#/'):
-        # Alias: #/ = src/
-        src_base = vue_path.replace('\\', '/').split('/src/')[0] + '/src/'
-        comp_path = os.path.normpath(os.path.join(src_base, import_path.replace('#/', '')))
-    elif import_path.startswith('./') or import_path.startswith('../'):
-        comp_path = os.path.normpath(os.path.join(dirname, import_path))
-    else:
-        return ''
-
-    # Try .ts extension if not present
-    if not os.path.isfile(comp_path):
-        for ext in ('.ts', '.vue'):
-            if os.path.isfile(comp_path + ext):
-                comp_path += ext
-                break
-
-    if not os.path.isfile(comp_path):
-        return ''
-
-    try:
-        comp_content = open(comp_path, encoding='utf-8', errors='ignore').read()
-    except Exception:
-        return ''
-
-    # Find handler_name's definition in composable (function or const arrow)
-    return ts_get_fn_body_ast(comp_content, handler_name) or _regex_fn_body(comp_content, handler_name)
-
-
-def _regex_fn_body(content, fn_name, max_len=500):
-    """Regex fallback for function body (for composable files tree-sitter may miss)."""
-    from common.extract import _get_fn_body
-    return _get_fn_body(content, fn_name, max_len)
-
-
-def ts_trace_clicks(vue_path, vue_content, api_table):
-    """Tree-sitter enhanced click tracing.
-
-    Uses AST for function body extraction (more precise than regex).
-    The drawer/modal/router logic stays as regex (it's application-level,
-    not parse-level). Only the fn_body extraction is upgraded.
-    """
-    if not _TS_AVAILABLE:
-        return regex_trace_clicks(vue_path, vue_content, api_table)
-
-    dirname = os.path.dirname(vue_path)
-
-    # 1. Collect api imports (same as regex)
-    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 + button text (same as regex)
-    clicks = list(RE_CLICK.finditer(vue_content))
-    if not clicks:
-        return []
-
-    # 3. Build drawer map (E2 fix: also resolve #/ and @/ alias imports,
-    #    not just local ./xxx.vue — many ICS drawers are imported via
-    #    #/views/... alias paths which the original RE_LOCAL_VUE_IMPORT missed)
-    drawer_map = {}
-    # Collect ALL vue imports (local + alias + defineAsyncComponent) into a name→path map
-    all_vue_imports = {}  # {import_name: import_path}
-    for im in RE_LOCAL_VUE_IMPORT.finditer(vue_content):
-        all_vue_imports[im.group(1)] = im.group(2)
-    # Also match alias imports: import xxx from '#/views/....vue' or '@/views/....vue'
-    for im in re.finditer(
-            r"import\s+(\w+)\s+from\s+['\"](?:#|@)/views/([^'\"]+\.vue)['\"]",
-            vue_content):
-        all_vue_imports[im.group(1)] = '#/views/' + im.group(2)
-    # Also match: const xxx = defineAsyncComponent(() => import('./xxx.vue'))
-    # — ICS uses this pattern extensively for drawer components
-    for im in re.finditer(
-            r"(?:const|let)\s+(\w+)\s*=\s*defineAsyncComponent\s*\(\s*\(\)\s*=>\s*import\s*\(\s*['\"]([^'\"]+\.vue)['\"]\s*\)\s*\)",
-            vue_content):
-        all_vue_imports[im.group(1)] = im.group(2)
-
-    for dm in re.finditer(
-            r"const\s+\[\s*\w+\s*,\s*(\w+)\s*\]\s*=\s*useVben(?:Drawer|Modal)\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)
-        if comp_import_name in all_vue_imports:
-            drawer_map[drawer_var] = all_vue_imports[comp_import_name]
-
-    traces = []
-
-    for cm in clicks:
-        handler_expr = cm.group(1).strip()
-        btn_text = ''
-        tm = RE_BTN_TEXT_AFTER_CLICK.search(vue_content, cm.start())
-        if tm:
-            btn_text = re.sub(r'\{\{[^}]*\}\}', '', tm.group(1).strip())[:12]
-
-        if handler_expr.startswith('$') or '.splice(' in handler_expr or '.push(' in handler_expr:
-            continue
-
-        handler_name = handler_expr.split('(')[0].split('.')[0].strip()
-        if not handler_name or handler_name in ('undefined', '', 'true', 'false'):
-            continue
-        if handler_name in ('item', 'emit', 'row', 'data') and '.' not in handler_expr:
-            continue
-
-        # ★ Use tree-sitter for function body (the E2 upgrade)
-        fn_body = ts_get_fn_body_ast(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
-        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 open
-        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:
-                # Resolve component path: local ./xxx.vue, alias #/views/..., or #/components/...
-                vue_path_norm = vue_path.replace('\\', '/')  # normalize for split
-                if comp_rel.startswith('#/views/'):
-                    alias_path = comp_rel.replace('#/views/', '')
-                    src_base = vue_path_norm.split('/src/views/')[0] + '/src/views/'
-                    comp_path = os.path.normpath(os.path.join(src_base, alias_path))
-                elif comp_rel.startswith('#/components/') or comp_rel.startswith('@/components/'):
-                    alias_path = comp_rel.replace('#/components/', '').replace('@/components/', '')
-                    src_base = vue_path_norm.split('/src/')[0] + '/src/components/'
-                    comp_path = os.path.normpath(os.path.join(src_base, alias_path))
-                else:
-                    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)
-                        resolved = False
-                        # First try: find a confirm handler that directly calls api
-                        for confirm_name in ('handleConfirm', 'onConfirm', 'handleSubmit', 'onOk'):
-                            cbody = ts_get_fn_body_ast(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')
-                                    resolved = True
-                                    break
-
-                        # Second try: if component uses props.api ANYWHERE (not just
-                        # in confirm handler — could be in grid query, watch, etc.),
-                        # resolve via parent template :api="xxx" binding.
-                        # This is the key insight: don't search for WHICH handler calls
-                        # props.api — just check IF props.api exists, then find the API
-                        # from the parent. Humans do exactly this.
-                        if not resolved and 'props.' in comp_content and re.search(
-                                r'props\.\w+\s*\(', comp_content):
-                            parent_api_fn = _resolve_props_api_from_parent(
-                                vue_content, vue_path, drawer_map, drawer_var, api_table)
-                            if parent_api_fn:
-                                info = api_table[parent_api_fn]
-                                trace.update(api_fn=parent_api_fn, endpoint=info['url'],
-                                             verb=info.get('verb', '?'), confidence='medium')
-                                resolved = True
-
-                        # Third try: component imports API functions directly (no
-                        # props.api) — e.g. a selector drawer that calls getList in
-                        # its grid query. Take the first imported api fn as the
-                        # associated endpoint (lower confidence — we know the drawer
-                        # USES this API but can't pinpoint which button triggers it).
-                        if not resolved and comp_api_imports:
-                            first_fn = sorted(comp_api_imports)[0]
-                            info = api_table[first_fn]
-                            trace.update(api_fn=first_fn, endpoint=info['url'],
-                                         verb=info.get('verb', '?'), confidence='low')
-                            resolved = True
-                    except Exception:
-                        pass
-            if trace['endpoint']:
-                traces.append(trace)
-                continue
-
-        # Modal.confirm
-        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
-        if fn_body and RE_ROUTER_PUSH.search(fn_body):
-            trace['confidence'] = 'deferred'
-            traces.append(trace)
-            continue
-
-        # Pattern E: imported function used directly as @click handler
-        # (e.g. @click="toContract" where toContract is an imported api fn)
-        if not fn_body and handler_name in api_table:
-            info = api_table[handler_name]
-            trace.update(api_fn=handler_name, endpoint=info['url'],
-                         verb=info.get('verb', '?'), confidence='high')
-            traces.append(trace)
-            continue
-
-        # Pattern F: composable-returned method
-        # (e.g. const { handleAdd } = useLeftBoxUser())
-        if not fn_body:
-            comp_body = _resolve_composable_handler(vue_content, vue_path, handler_name, api_table)
-            if comp_body:
-                hits = _find_api_calls_in_text(comp_body, api_table, set(api_table.keys()))
-                if hits:
-                    fn, url, verb = hits[0]
-                    trace.update(api_fn=fn, endpoint=url, verb=verb, confidence='medium')
-                    traces.append(trace)
-                    continue
-
-        trace['confidence'] = 'unresolved'
-        traces.append(trace)
-
-    return traces
+# -*- coding: utf-8 -*-
+"""
+Tree-sitter based extraction for the call-chain index (E2).
+
+Replaces the regex-based function-body extraction in common/extract.py with
+AST parsing. Tree-sitter gives us:
+  - Exact function boundaries (brace matching is never wrong)
+  - All call expressions inside a function (not just requestClient.*)
+  - Import resolution (named imports from api modules)
+
+This module provides:
+  - ts_build_api_fn_table(api_dir) — same output schema as build_api_fn_table,
+    but uses AST for precise body boundaries
+  - ts_extract_clicks(vue_path, content, api_table) — same schema as trace_clicks,
+    but uses AST for function body + call detection
+
+Fallback: if tree-sitter is not installed, falls back to the regex version.
+"""
+import os
+import re
+
+try:
+    from tree_sitter import Language, Parser
+    import tree_sitter_typescript as tst
+    _TS_AVAILABLE = True
+    _TS_LANG = Language(tst.language_typescript())
+    _PARSER = Parser(_TS_LANG)
+except Exception:
+    _TS_AVAILABLE = False
+    _PARSER = None
+
+from domain.kg.extract.extract import (
+    build_api_fn_table as regex_build_api_fn_table,
+    trace_clicks as regex_trace_clicks,
+    parse_api_enum_block, _resolve_url_expr, _find_api_calls_in_text,
+    RE_API_IMPORT, RE_CLICK, RE_BTN_TEXT_AFTER_CLICK, RE_COMMON_DOWNLOAD,
+    RE_DRAWER_OPEN, RE_MODAL_CONFIRM, RE_ROUTER_PUSH, RE_LOCAL_VUE_IMPORT,
+    RE_PROXY_AJAX,
+    _resolve_drawer_api as _regex_resolve_drawer,
+)
+
+
+def _node_text(node, source_bytes):
+    """Get text of a tree-sitter node."""
+    return source_bytes[node.start_byte:node.end_byte].decode('utf-8', errors='replace')
+
+
+def _find_calls_in_function_ast(func_node, source_bytes):
+    """Find all call_expression nodes inside a function body via AST.
+
+    Returns list of (callee_text, full_call_text).
+    """
+    calls = []
+    cursor = func_node.walk()
+    cursor.goto_first_child()
+    # Descend into body
+    def visit(node):
+        if node.type == 'call_expression':
+            callee = node.child_by_field_name('function')
+            if callee:
+                calls.append((_node_text(callee, source_bytes), _node_text(node, source_bytes)))
+        for child in node.children:
+            visit(child)
+    visit(func_node)
+    return calls
+
+
+def ts_build_api_fn_table(api_dir):
+    """Tree-sitter version: build {fnName: {url, verb, file}} from api/*.ts.
+
+    Uses AST for exact function boundaries + call detection. Falls back to
+    regex version if tree-sitter unavailable.
+    """
+    if not _TS_AVAILABLE:
+        return regex_build_api_fn_table(api_dir)
+
+    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:
+                source = open(fpath, 'rb').read()
+            except Exception:
+                continue
+            urls = parse_api_enum_block(source.decode('utf-8', errors='replace'))
+
+            try:
+                tree = _PARSER.parse(source)
+            except Exception:
+                # Fallback to regex for this file
+                continue
+
+            # Walk AST to find export function / export const = () => {}
+            def visit(node):
+                if node.type == 'export_statement':
+                    for child in node.children:
+                        if child.type == 'function_declaration':
+                            _process_fn(child, source, urls, fpath, table)
+                        elif child.type == 'lexical_declaration':
+                            # export const fnName = (...) => { ... }
+                            _process_const_fn(child, source, urls, fpath, table)
+                elif node.type == 'function_declaration':
+                    # Non-exported but still processable
+                    pass
+                for child in node.children:
+                    visit(child)
+
+            visit(tree.root_node)
+
+    # Merge with regex results (regex catches some TS-sitter misses)
+    regex_table = regex_build_api_fn_table(api_dir)
+    for k, v in regex_table.items():
+        if k not in table:
+            table[k] = v
+
+    return table
+
+
+def _process_fn(fn_node, source, urls, fpath, table):
+    """Process a function_declaration node."""
+    name_node = fn_node.child_by_field_name('name')
+    if not name_node:
+        return
+    fn_name = _node_text(name_node, source)
+    body = fn_node.child_by_field_name('body')
+    if not body:
+        return
+    _extract_api_call(fn_name, body, source, urls, fpath, table)
+
+
+def _process_const_fn(decl_node, source, urls, fpath, table):
+    """Process: export const fnName = (params) => { ... } or async."""
+    # Find the variable declarator
+    for child in decl_node.children:
+        if child.type == 'variable_declarator':
+            name_node = child.child_by_field_name('name')
+            value_node = child.child_by_field_name('value')
+            if not name_node or not value_node:
+                continue
+            fn_name = _node_text(name_node, source)
+            # Arrow function body
+            body = None
+            if value_node.type == 'arrow_function':
+                body = value_node.child_by_field_name('body')
+            elif value_node.type == 'function':
+                body = value_node.child_by_field_name('body')
+            if body:
+                _extract_api_call(fn_name, body, source, urls, fpath, table)
+
+
+def _extract_api_call(fn_name, body_node, source, urls, fpath, table):
+    """Find requestClient calls inside a function body via AST."""
+    calls = _find_calls_in_function_ast(body_node, source)
+    entry = None
+    for callee, full_call in calls:
+        # requestClient.post<...>(Api.key, ...) or requestClient.get(...)
+        if callee.startswith('requestClient.'):
+            verb = callee.split('.')[-1]
+            # Extract first argument (Api.key or string literal)
+            m = re.search(r'requestClient\.\w+(?:<[^)]*?>)?\s*\(\s*(Api\.\w+|`[^`]*`|\'[^\']*\'|"[^"]*")', full_call)
+            if m:
+                url = _resolve_url_expr(m.group(1), urls)
+                if url:
+                    entry = {'url': url, 'verb': verb, 'file': fpath.replace('\\', '/')}
+                    break
+        # commonExport(Api.key, ...)
+        elif callee == 'commonExport':
+            m = re.search(r'commonExport\s*\(\s*(Api\.\w+)', full_call)
+            if m:
+                url = _resolve_url_expr(m.group(1), urls)
+                if url:
+                    entry = {'url': url, 'verb': 'post', 'file': fpath.replace('\\', '/')}
+                    break
+    if entry:
+        table[fn_name] = entry
+
+
+def ts_get_fn_body_ast(content, fn_name):
+    """Get function body text via tree-sitter AST (exact boundaries).
+
+    More reliable than _get_fn_body's brace-counting for complex code.
+    """
+    if not _TS_AVAILABLE:
+        from domain.kg.extract.extract import _get_fn_body
+        return _get_fn_body(content, fn_name)
+
+    source = content.encode('utf-8')
+    try:
+        tree = _PARSER.parse(source)
+    except Exception:
+        from domain.kg.extract.extract import _get_fn_body
+        return _get_fn_body(content, fn_name)
+
+    root = tree.root_node
+
+    def find_fn(node):
+        if node.type in ('function_declaration', 'method_definition'):
+            name = node.child_by_field_name('name')
+            if name and _node_text(name, source) == fn_name:
+                body = node.child_by_field_name('body')
+                if body:
+                    return _node_text(body, source)
+        for child in node.children:
+            result = find_fn(child)
+            if result:
+                return result
+        return None
+
+    body = find_fn(root)
+    if body:
+        return body
+    # Fallback: arrow function const
+    from domain.kg.extract.extract import _get_fn_body
+    return _get_fn_body(content, fn_name)
+
+
+def _resolve_props_api_from_parent(parent_content, parent_path, drawer_map, drawer_var, api_table):
+    """Resolve props.api() by looking at the PARENT template.
+
+    When a drawer component's handler calls props.api(), the actual API
+    function was passed by the parent via :api="someFn" in the template.
+    This finds that binding and checks if someFn is a known api import.
+
+    Returns the api function name if found, else None.
+    """
+    # The drawer component tag name in template is the FIRST element of the
+    # destructured useVbenDrawer: const [CompTag, drawerVar] = useVbenDrawer(...)
+    # Find it: const [<CompTag>, drawerVar] = useVbenDrawer
+    comp_tag_m = re.search(
+        r"const\s+\[\s*(\w+)\s*,\s*" + re.escape(drawer_var) + r"\s*\]\s*=",
+        parent_content)
+    if not comp_tag_m:
+        return None
+    comp_tag = comp_tag_m.group(1)
+
+    # Find <CompTag ... :api="fnName" ... /> in the template
+    # Match :api="xxx" or :api="xxx" within a tag that starts with comp_tag
+    tag_pattern = re.compile(
+        r'<' + re.escape(comp_tag) + r'\b[^>]*?:api\s*=\s*["\'](\w+)["\']',
+        re.S)
+    m = tag_pattern.search(parent_content)
+    if not m:
+        # Also try kebab-case tag name (PascalCase → kebab-case)
+        kebab = re.sub(r'([A-Z])', r'-\1', comp_tag).lower().lstrip('-')
+        tag_pattern2 = re.compile(
+            r'<' + re.escape(kebab) + r'\b[^>]*?:api\s*=\s*["\'](\w+)["\']',
+            re.S)
+        m = tag_pattern2.search(parent_content)
+    if not m:
+        return None
+
+    api_fn_name = m.group(1)
+    if api_fn_name in api_table:
+        return api_fn_name
+
+    # Maybe it's a wrapped call like :api="(data) => someFn(data)"
+    # Try to extract the function name from arrow expressions
+    inner_fn = re.search(r'\b(\w+)\s*\(', api_fn_name)
+    if inner_fn and inner_fn.group(1) in api_table:
+        return inner_fn.group(1)
+
+    return None
+
+
+def _resolve_composable_handler(vue_content, vue_path, handler_name, api_table):
+    """Resolve a handler that comes from a composable (useXxx()).
+
+    Pattern: const { handleAdd } = useLeftBoxUser()
+    → find the composable import path → open it → find handleAdd's definition.
+    Returns the function body text, or '' if not found.
+    """
+    # Find: const { ... handlerName ... } = useXxx()
+    m = re.search(
+        r'const\s*\{([^}]*\b' + re.escape(handler_name) + r'\b[^}]*)\}\s*=\s*use(\w+)\s*\(',
+        vue_content)
+    if not m:
+        return ''
+    composable_fn = 'use' + m.group(2)  # e.g. useLeftBoxUser
+
+    # Find import of useXxx from '...'
+    imp_m = re.search(
+        r'import\s+\{[^}]*\b' + re.escape(composable_fn) + r'\b[^}]*\}\s+from\s+[\'"]([^\'"]+)[\'"]',
+        vue_content)
+    if not imp_m:
+        return ''
+    import_path = imp_m.group(1)
+
+    # Resolve import path to file
+    dirname = os.path.dirname(vue_path)
+    if import_path.startswith('#/'):
+        # Alias: #/ = src/
+        src_base = vue_path.replace('\\', '/').split('/src/')[0] + '/src/'
+        comp_path = os.path.normpath(os.path.join(src_base, import_path.replace('#/', '')))
+    elif import_path.startswith('./') or import_path.startswith('../'):
+        comp_path = os.path.normpath(os.path.join(dirname, import_path))
+    else:
+        return ''
+
+    # Try .ts extension if not present
+    if not os.path.isfile(comp_path):
+        for ext in ('.ts', '.vue'):
+            if os.path.isfile(comp_path + ext):
+                comp_path += ext
+                break
+
+    if not os.path.isfile(comp_path):
+        return ''
+
+    try:
+        comp_content = open(comp_path, encoding='utf-8', errors='ignore').read()
+    except Exception:
+        return ''
+
+    # Find handler_name's definition in composable (function or const arrow)
+    return ts_get_fn_body_ast(comp_content, handler_name) or _regex_fn_body(comp_content, handler_name)
+
+
+def _regex_fn_body(content, fn_name, max_len=500):
+    """Regex fallback for function body (for composable files tree-sitter may miss)."""
+    from domain.kg.extract.extract import _get_fn_body
+    return _get_fn_body(content, fn_name, max_len)
+
+
+def ts_trace_clicks(vue_path, vue_content, api_table):
+    """Tree-sitter enhanced click tracing.
+
+    Uses AST for function body extraction (more precise than regex).
+    The drawer/modal/router logic stays as regex (it's application-level,
+    not parse-level). Only the fn_body extraction is upgraded.
+    """
+    if not _TS_AVAILABLE:
+        return regex_trace_clicks(vue_path, vue_content, api_table)
+
+    dirname = os.path.dirname(vue_path)
+
+    # 1. Collect api imports (same as regex)
+    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 + button text (same as regex)
+    clicks = list(RE_CLICK.finditer(vue_content))
+    if not clicks:
+        return []
+
+    # 3. Build drawer map (E2 fix: also resolve #/ and @/ alias imports,
+    #    not just local ./xxx.vue — many ICS drawers are imported via
+    #    #/views/... alias paths which the original RE_LOCAL_VUE_IMPORT missed)
+    drawer_map = {}
+    # Collect ALL vue imports (local + alias + defineAsyncComponent) into a name→path map
+    all_vue_imports = {}  # {import_name: import_path}
+    for im in RE_LOCAL_VUE_IMPORT.finditer(vue_content):
+        all_vue_imports[im.group(1)] = im.group(2)
+    # Also match alias imports: import xxx from '#/views/....vue' or '@/views/....vue'
+    for im in re.finditer(
+            r"import\s+(\w+)\s+from\s+['\"](?:#|@)/views/([^'\"]+\.vue)['\"]",
+            vue_content):
+        all_vue_imports[im.group(1)] = '#/views/' + im.group(2)
+    # Also match: const xxx = defineAsyncComponent(() => import('./xxx.vue'))
+    # — ICS uses this pattern extensively for drawer components
+    for im in re.finditer(
+            r"(?:const|let)\s+(\w+)\s*=\s*defineAsyncComponent\s*\(\s*\(\)\s*=>\s*import\s*\(\s*['\"]([^'\"]+\.vue)['\"]\s*\)\s*\)",
+            vue_content):
+        all_vue_imports[im.group(1)] = im.group(2)
+
+    for dm in re.finditer(
+            r"const\s+\[\s*\w+\s*,\s*(\w+)\s*\]\s*=\s*useVben(?:Drawer|Modal)\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)
+        if comp_import_name in all_vue_imports:
+            drawer_map[drawer_var] = all_vue_imports[comp_import_name]
+
+    traces = []
+
+    for cm in clicks:
+        handler_expr = cm.group(1).strip()
+        btn_text = ''
+        tm = RE_BTN_TEXT_AFTER_CLICK.search(vue_content, cm.start())
+        if tm:
+            btn_text = re.sub(r'\{\{[^}]*\}\}', '', tm.group(1).strip())[:12]
+
+        if handler_expr.startswith('$') or '.splice(' in handler_expr or '.push(' in handler_expr:
+            continue
+
+        handler_name = handler_expr.split('(')[0].split('.')[0].strip()
+        if not handler_name or handler_name in ('undefined', '', 'true', 'false'):
+            continue
+        if handler_name in ('item', 'emit', 'row', 'data') and '.' not in handler_expr:
+            continue
+
+        # ★ Use tree-sitter for function body (the E2 upgrade)
+        fn_body = ts_get_fn_body_ast(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
+        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 G: proxyConfig.ajax({ url: '...' }) — ICS 标准 VxeGrid 代理模式
+        # 很多 ICS 表格页查询不走 requestClient, 而是直接在 proxyConfig.ajax 里
+        # 写 url。handler 可能是 reload/query 调用 grid 刷新, 触发 proxyConfig。
+        # 也匹配整个文件级别的 proxyConfig (handler 间接触发)。
+        proxy_hit = _match_proxy_ajax(fn_body, vue_content, api_table)
+        if proxy_hit:
+            fn, url, verb = proxy_hit
+            trace.update(api_fn=fn, endpoint=url, verb=verb, confidence='medium')
+            traces.append(trace)
+            continue
+
+        # Pattern D: drawer open
+        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:
+                # Resolve component path: local ./xxx.vue, alias #/views/..., or #/components/...
+                vue_path_norm = vue_path.replace('\\', '/')  # normalize for split
+                if comp_rel.startswith('#/views/'):
+                    alias_path = comp_rel.replace('#/views/', '')
+                    src_base = vue_path_norm.split('/src/views/')[0] + '/src/views/'
+                    comp_path = os.path.normpath(os.path.join(src_base, alias_path))
+                elif comp_rel.startswith('#/components/') or comp_rel.startswith('@/components/'):
+                    alias_path = comp_rel.replace('#/components/', '').replace('@/components/', '')
+                    src_base = vue_path_norm.split('/src/')[0] + '/src/components/'
+                    comp_path = os.path.normpath(os.path.join(src_base, alias_path))
+                else:
+                    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)
+                        resolved = False
+                        # First try: find a confirm handler that directly calls api
+                        for confirm_name in ('handleConfirm', 'onConfirm', 'handleSubmit', 'onOk'):
+                            cbody = ts_get_fn_body_ast(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')
+                                    resolved = True
+                                    break
+
+                        # Second try: if component uses props.api ANYWHERE (not just
+                        # in confirm handler — could be in grid query, watch, etc.),
+                        # resolve via parent template :api="xxx" binding.
+                        # This is the key insight: don't search for WHICH handler calls
+                        # props.api — just check IF props.api exists, then find the API
+                        # from the parent. Humans do exactly this.
+                        if not resolved and 'props.' in comp_content and re.search(
+                                r'props\.\w+\s*\(', comp_content):
+                            parent_api_fn = _resolve_props_api_from_parent(
+                                vue_content, vue_path, drawer_map, drawer_var, api_table)
+                            if parent_api_fn:
+                                info = api_table[parent_api_fn]
+                                trace.update(api_fn=parent_api_fn, endpoint=info['url'],
+                                             verb=info.get('verb', '?'), confidence='medium')
+                                resolved = True
+
+                        # Third try: component imports API functions directly (no
+                        # props.api) — e.g. a selector drawer that calls getList in
+                        # its grid query. Take the first imported api fn as the
+                        # associated endpoint (lower confidence — we know the drawer
+                        # USES this API but can't pinpoint which button triggers it).
+                        if not resolved and comp_api_imports:
+                            first_fn = sorted(comp_api_imports)[0]
+                            info = api_table[first_fn]
+                            trace.update(api_fn=first_fn, endpoint=info['url'],
+                                         verb=info.get('verb', '?'), confidence='low')
+                            resolved = True
+                    except Exception:
+                        pass
+            if trace['endpoint']:
+                traces.append(trace)
+                continue
+
+        # Modal.confirm
+        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
+        if fn_body and RE_ROUTER_PUSH.search(fn_body):
+            trace['confidence'] = 'deferred'
+            traces.append(trace)
+            continue
+
+        # Pattern E: imported function used directly as @click handler
+        # (e.g. @click="toContract" where toContract is an imported api fn)
+        if not fn_body and handler_name in api_table:
+            info = api_table[handler_name]
+            trace.update(api_fn=handler_name, endpoint=info['url'],
+                         verb=info.get('verb', '?'), confidence='high')
+            traces.append(trace)
+            continue
+
+        # Pattern F: composable-returned method
+        # (e.g. const { handleAdd } = useLeftBoxUser())
+        if not fn_body:
+            comp_body = _resolve_composable_handler(vue_content, vue_path, handler_name, api_table)
+            if comp_body:
+                hits = _find_api_calls_in_text(comp_body, api_table, set(api_table.keys()))
+                if hits:
+                    fn, url, verb = hits[0]
+                    trace.update(api_fn=fn, endpoint=url, verb=verb, confidence='medium')
+                    traces.append(trace)
+                    continue
+
+        # Pattern H: workflow_submit — ICS 标准审批流提交组合式函数
+        # handler 调用 workflow_submit/submitWorkflow/workflowSubmit 时, 它内部
+        # 会发 POST 到审批流后端。静态无法解析具体 URL, 但标记为提交流程,
+        # confidence=medium, 避免这些 handler 被误判为"无 API 调用"。
+        if fn_body and re.search(
+                r'\b(?:workflow[_-]?submit|submit[_-]?workflow|workflowSubmit|submitWorkflow)\s*\(',
+                fn_body):
+            trace.update(endpoint='[workflow-submit]', verb='POST',
+                         api_fn='workflow_submit', confidence='medium')
+            traces.append(trace)
+            continue
+
+        trace['confidence'] = 'unresolved'
+        traces.append(trace)
+
+    return traces
+
+
+def _match_proxy_ajax(fn_body, vue_content, api_table):
+    """Pattern G: 从 proxyConfig.ajax.query 函数体中提取 API 调用。
+
+    ICS 真实写法 (审核 601 个文件确认):
+        proxyConfig: { ajax: { query: async ({page}, formValues) => {
+            return await getUnconventionalDetailList({...})  ← 导入的 api 函数
+        }}}
+    query 函数体里调用的是已导入的 api 函数 (在 api_table 里),
+    用 _find_api_calls_in_text 匹配即可。这是页面级数据加载入口,
+    不属于某个按钮 handler, 但任何触发表格 reload 的按钮都间接走它。
+
+    Returns:
+        (api_fn, url, verb) 或 None
+    """
+    # proxyConfig 在 <script setup> 顶层, 不在 handler 函数体内 → 扫整个文件
+    text = vue_content
+    if not text or not api_table:
+        return None
+    # 收集该文件所有导入的 api 函数名 (proxyConfig 里的 query 可能用任意导入的 fn)
+    all_imports = set(api_table.keys())
+    for im in RE_API_IMPORT.finditer(text):
+        for name in im.group(1).split(','):
+            name = name.strip().split(' as ')[0].strip()
+            if name and name in api_table:
+                all_imports.add(name)
+    for pm in RE_PROXY_AJAX.finditer(text):
+        # 提取 query 函数体: 从 'async (' 后做花括号匹配
+        start = pm.end() - 1  # 回到 '(' 位置
+        # 找到 '=>' 后的第一个 '{'
+        arrow_idx = text.find('=>', pm.end())
+        if arrow_idx < 0:
+            continue
+        brace_idx = text.find('{', arrow_idx)
+        if brace_idx < 0:
+            continue
+        # 花括号深度匹配提取函数体
+        depth = 1
+        i = brace_idx + 1
+        end = min(len(text), brace_idx + 800)  # 最多取 800 字符
+        while i < end and depth > 0:
+            if text[i] == '{':
+                depth += 1
+            elif text[i] == '}':
+                depth -= 1
+            i += 1
+        query_body = text[brace_idx + 1:i]
+        # 在 query 函数体里找 api 调用
+        hits = _find_api_calls_in_text(query_body, api_table, all_imports)
+        if hits:
+            fn, url, verb = hits[0]
+            return (fn, url, verb or 'GET')
+    return None