@hupan56/wlkj 2.6.0 → 2.7.0

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

@@ -25,6 +25,12 @@ CN_MAP = {
     '油耗': 'fuel oil', '里程': 'mileage distance', '行驶': 'drive travel',
     '驾驶员': 'driver', '车队': 'fleet', '违章': 'violation traffic',
     '事故': 'accident', 'GPS': 'gps location track',
+    # 能源/加油/充电卡
+    '加油': 'refueling fuel', '加油卡': 'powerCard vehicleCard fuelCard',
+    '油卡': 'powerCard vehicleCard fuelCard', '充值': 'recharge topup',
+    '加油站': 'gasStation', '能源': 'energy power fuel electricity',
+    '充电': 'recharge electricity power', '电卡': 'energyCard powerCard',
+    '能耗': 'energy fuel electricity power',
     # 品质/巡查
     '品质': 'quality', '巡查': 'inspection patrol', '巡检': 'inspection patrol',
     '检查': 'check inspect', '隐患': 'hazard risk', '整改': 'rectify fix',
@@ -116,6 +122,12 @@ BUSINESS_PATH_MAP = {
     '在线率': ['online', 'Online', 'onlineRate', 'OnlineRate'],
     '告警': ['alarm', 'Alarm', 'alert', 'Alert'],
     '油耗': ['fuel', 'Fuel', 'oil', 'Oil', 'oilConsumption'],
+    '加油': ['refueling', 'Refueling', 'fuel', 'Fuel', 'gasStation', 'topup'],
+    '加油卡': ['powerCard', 'PowerCard', 'vehicleCard', 'VehicleCard', 'fuelCard', 'energyCard'],
+    '油卡': ['powerCard', 'PowerCard', 'vehicleCard', 'VehicleCard', 'fuelCard'],
+    '能源': ['energy', 'Energy', 'refueling', 'electricity', 'powerCard'],
+    '充电': ['recharge', 'Recharge', 'electricity', 'powerStation'],
+    '能耗': ['energy', 'fuel', 'electricity', 'power'],
     '里程': ['mileage', 'Mileage', 'distance', 'Distance'],
     '薪资': ['salary', 'Salary', 'wage', 'Wage', 'pay', 'Pay'],
     '报表': ['report', 'Report', 'statistics', 'Statistics'],
@@ -211,6 +223,51 @@ def get_cn_map_with_auto():
     merged.update(auto_expand_from_prds())
     return merged
 
+
+def expand_chinese_query(query):
+    """把中文查询拆成英文搜索词 (单一数据源, search_index + context_pack 共用)。
+
+    三级匹配:
+      1. 精确匹配: "异常" 在 CN_MAP → 直接扩展
+      2. 分词匹配: "异常记录" → 拆成 "异常" + "记录", 各自扩展
+         (贪心最长匹配: 从长到短扫 CN_MAP 的 key)
+      3. 兜底: 拆不出来的部分, 原样小写 (让英文子串索引做匹配)
+
+    同时合并 BUSINESS_PATH_MAP 的路径模式。
+
+    例: "营业外合同" 不在 CN_MAP, 但分词能拆出 "合同" → "contract"。
+    """
+    words = []
+    cn_map = get_cn_map_with_auto()
+
+    # 1. 精确匹配
+    if query in cn_map:
+        words.extend(cn_map[query].split())
+    if query in BUSINESS_PATH_MAP:
+        words.extend(p.strip('/-').lower() for p in BUSINESS_PATH_MAP[query])
+
+    # 2. 分词匹配 (查询比单个 CN_MAP key 长 → 需要拆词)
+    if not words and len(query) >= 3:
+        # 贪心最长匹配: 把 CN_MAP keys 按长度降序排, 逐个从 query 里找
+        remaining = query
+        matched_segments = []
+        for cn in sorted(cn_map.keys(), key=len, reverse=True):
+            if cn in remaining:
+                matched_segments.append(cn)
+                remaining = remaining.replace(cn, ' ')
+        if matched_segments:
+            for seg in matched_segments:
+                words.extend(cn_map[seg].split())
+                if seg in BUSINESS_PATH_MAP:
+                    words.extend(p.strip('/-').lower() for p in BUSINESS_PATH_MAP[seg])
+            # 剩余的英文/数字片段也加进去 (兜底)
+            for frag in remaining.split():
+                if frag and frag.isascii():
+                    words.append(frag.lower())
+
+    return words
+
+
 # Stop words filtered out when extracting business terms from PRD text.
 # (Union of the lists previously duplicated in git_sync.py / parse_prds.py)
 PRD_STOP_WORDS = {

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

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