@hupan56/wlkj 2.6.0 → 2.7.1

package/templates/qoder/scripts/check_qoderwork_consistency.py

@@ -0,0 +1,166 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+check_qoderwork_consistency.py — 防退化检查：命令/skills 文件不得用裸相对路径调脚本。
+
+背景：
+  QoderWork 桌面端工作目录是临时会话目录(workspace/xxx), 不是仓库根。
+  命令/技能文件里写 `python .qoder/scripts/xxx.py` → 在 QoderWork 下找不到脚本 →
+  Shell 直接报错, Python 根本没启动。这就是"ZCode 行、QoderWork 不行"的根因。
+
+  统一规约: 所有脚本调用必须用仓库根定位, 二选一:
+    ① python "$R/.qoder/scripts/xxx.py" ...    (R = repo_root.py 输出)
+    ② cd "$R" && python .qoder/scripts/xxx.py ...  (cd 到仓库根后相对路径)
+
+  本脚本扫 .qoder/commands/**/*.md 和 .qoder/skills/**/SKILL.md,
+  找出违反规约的裸相对路径调用, 退出码非 0 表示有退化。
+  可挂 pre-commit / CI。
+
+Usage:
+    python .qoder/scripts/check_qoderwork_consistency.py
+    python .qoder/scripts/check_qoderwork_consistency.py --strict   # 警告也算失败
+Exit:
+    0 = 通过(无裸相对路径调用, 或仅有 --strict 才算失败的警告)
+    1 = 发现裸相对路径调用(退化)
+"""
+import argparse
+import os
+import re
+import sys
+
+if sys.platform == 'win32':
+    try:
+        sys.stdout.reconfigure(encoding='utf-8')
+    except (AttributeError, IOError):
+        pass
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from common.paths import get_repo_root  # noqa: E402
+
+# 扫描目标: commands 全部 .md + skills 的 SKILL.md
+SCAN_GLOBS = [
+    ('commands', '.qoder/commands', '*.md'),
+    ('skills', '.qoder/skills', 'SKILL.md'),
+]
+
+# 裸相对路径调用: `python .qoder/scripts/xxx` 但前面没有 cd "$R" 或 "$R/ 前缀
+# 匹配 `python .qoder/scripts/` 或 `python3 .qoder/scripts/`, 不带 $R 引号包裹
+BARE_PAT = re.compile(r'(?<![\"\$])\bpython3?\s+\.qoder/scripts/([A-Za-z0-9_./-]+)')
+
+# 已安全模式: cd "$R" && python .qoder/scripts/...
+SAFE_CD_PAT = re.compile(r'cd\s+["\']?\$R["\']?\s*&&\s*python3?\s+\.qoder/scripts/')
+
+# 仓库根定位块存在的标志
+ROOT_LOCATOR_PAT = re.compile(r'repo_root\.py|R=\$\(python.*repo_root')
+
+# 在 install_qoderwork.py 提示行里的相对路径(说明性文字, 非真实调用), 豁免
+HINT_CTX = 'install_qoderwork.py'
+
+
+def scan_file(path, strict):
+    """扫一个文件, 返回 (errors, warnings, root_block_present)。
+    errors = 裸相对路径真实调用(必修); warnings = 无 R 块等(建议修)。
+    """
+    errors = []
+    warnings = []
+    try:
+        with open(path, encoding='utf-8') as f:
+            lines = f.readlines()
+    except (OSError, IOError):
+        return errors, warnings, True
+
+    root_block = bool(ROOT_LOCATOR_PAT.search(''.join(lines)))
+
+    for i, line in enumerate(lines, 1):
+        # 豁免: 说明性文字里提到 install_qoderwork.py 的相对路径(这是"找不到时跑这个"的指引)
+        if HINT_CTX in line:
+            continue
+        # 豁免: 已安全的 cd "$R" && python 模式
+        if SAFE_CD_PAT.search(line):
+            continue
+        # 找裸相对路径
+        for m in BARE_PAT.finditer(line):
+            script = m.group(1)
+            # 过滤掉明显是文字描述(行里既无 bash 代码块上下文也无命令感)
+            # 简化: 只要匹配到就算(宁可误报让 reviewer 看一眼)
+            errors.append((i, line.rstrip(), script))
+
+    # 无 R 块但文件里有 $R 引用 → 警告
+    if not root_block and '$R' in ''.join(lines):
+        warnings.append((0, '(无 R 定位块, 但文件里用了 $R)', ''))
+
+    return errors, warnings, root_block
+
+
+def main():
+    ap = argparse.ArgumentParser(description='检查命令/skills 是否含裸相对路径(防 ZCode/QoderWork 割裂)')
+    ap.add_argument('--strict', action='store_true', help='警告也算失败')
+    args = ap.parse_args()
+
+    repo = get_repo_root()
+    total_errors = 0
+    total_warnings = 0
+    files_with_errors = []
+    files_with_warnings = []
+
+    for label, rel_dir, pattern in SCAN_GLOBS:
+        scan_dir = repo / rel_dir
+        if not scan_dir.is_dir():
+            continue
+        for dirpath, dirnames, filenames in os.walk(str(scan_dir)):
+            for fn in filenames:
+                import fnmatch
+                if not fnmatch.fnmatch(fn, pattern):
+                    continue
+                path = os.path.join(dirpath, fn)
+                errors, warnings, root_block = scan_file(path, args.strict)
+                rel = os.path.relpath(path, str(repo))
+                if errors:
+                    files_with_errors.append((rel, errors))
+                    total_errors += len(errors)
+                if warnings:
+                    files_with_warnings.append((rel, warnings))
+                    total_warnings += len(warnings)
+
+    # 输出
+    print('=' * 64)
+    print('QoderWork 一致性检查 (防 ZCode 行 / QoderWork 挂 的割裂)')
+    print('=' * 64)
+
+    if files_with_errors:
+        print()
+        print('🔴 裸相对路径调用 (QoderWork 必挂, 必修):')
+        for rel, errs in files_with_errors:
+            print('  ' + rel)
+            for lineno, line, script in errs:
+                snippet = line.strip()[:80]
+                print('    L%d: %s' % (lineno, snippet))
+
+    if files_with_warnings:
+        print()
+        print('🟡 警告 (建议修, --strict 才算失败):')
+        for rel, ws in files_with_warnings:
+            print('  ' + rel)
+            for lineno, line, script in ws:
+                print('    %s' % line)
+
+    if not files_with_errors and not files_with_warnings:
+        print('✅ 全部通过: 命令/skills 无裸相对路径调用, ZCode ≡ QoderWork 一致。')
+
+    print('-' * 64)
+    print('统计: 错误 %d (文件 %d) / 警告 %d (文件 %d)'
+          % (total_errors, len(files_with_errors), total_warnings, len(files_with_warnings)))
+    print()
+    print('规约: 脚本调用必须二选一:')
+    print('  ① python "$R/.qoder/scripts/xxx.py" ...    (R = repo_root.py 输出)')
+    print('  ② cd "$R" && python .qoder/scripts/xxx.py ...')
+
+    if total_errors > 0:
+        return 1
+    if args.strict and total_warnings > 0:
+        return 1
+    return 0
+
+
+if __name__ == '__main__':
+    sys.exit(main())

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

@@ -0,0 +1,46 @@
+# -*- coding: utf-8 -*-
+"""events.py - 流水线事件字典 (Single Source of Truth)
+
+为什么需要它:
+  之前 learn.py 的 stats_map 和 learn_aggregate.py 的 SQL FILTER 各自硬编码
+  事件名, 两边漂移 → learning_stats 表的 reviews/commits 永远是 0 (没人埋点)。
+  统一到这里, 任何 skill 加埋点只需在此声明, 两端自动对齐。
+
+事件 → 统计列 → 归属 skill 的映射是 SSOT:
+  EVENT_TYPES[event] = {
+      'stat':   该事件累加到 learning.yaml / learning_stats 的哪一列 (None=不计数)
+      'skill':  归属哪个 skill (用于「埋点覆盖率」自检)
+      'label':  人类可读名 (/wl-status 展示用)
+  }
+"""
+
+# 事件类型注册表 —— 唯一事实源
+# 新增埋点: 在这里加一行 → learn.py 计数 + learn_aggregate.py SQL 自动生效
+EVENT_TYPES = {
+    # PRD 链路
+    'prd_accepted':   {'stat': 'prds_generated',  'skill': 'wl-prd-full',   'label': 'PRD 发布'},
+    'prd_rejected':   {'stat': 'rejections',      'skill': 'wl-prd-full',   'label': 'PRD 打回'},
+    'review_done':    {'stat': 'reviews_done',    'skill': 'prd-review',    'label': 'PRD 评审'},
+    # 设计链路
+    'design_import':  {'stat': 'designs_imported','skill': 'design-import', 'label': '设计录入'},
+    # 任务链路
+    'task_completed': {'stat': 'tasks_completed', 'skill': 'wl-task',       'label': '任务完成'},
+    # 提交链路
+    'commit_done':    {'stat': 'commits_done',    'skill': 'wl-commit',     'label': '代码提交'},
+    # 流水线自检事件 (不计入正向统计, 用于健康度看板)
+    'rule_violation': {'stat': None,             'skill': None,            'label': '规则违规'},
+}
+
+
+def stats_event_map():
+    """返回 {event: stat_column} (只含需要计数的, None 的过滤掉)。
+    learn.py 用它驱动 _update_stats。
+    """
+    return {ev: meta['stat'] for ev, meta in EVENT_TYPES.items() if meta['stat']}
+
+
+def event_to_sql_filter():
+    """返回 {stat_column: event} (反向映射)。
+    learn_aggregate.py 用它生成 SQL FILTER 子句, 不再硬编码。
+    """
+    return {meta['stat']: ev for ev, meta in EVENT_TYPES.items() if meta['stat']}

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