@hupan56/wlkj 2.5.0 → 2.7.0

package/templates/qoder/scripts/kg_build.py

@@ -0,0 +1,612 @@
+# -*- coding: utf-8 -*-
+"""
+Unified knowledge graph builder — code → DuckDB directly, no JSON.
+PROJECT-AGNOSTIC: auto-discovers project structure, no hardcoded names.
+
+Discovers for each project under data/code/:
+  - Language/framework (Vue/React/Vant/Element/Ant/jQuery...)
+  - Module directories (apps/*/src/api, src/modules, src/views, pages/, ...)
+  - API definition patterns (requestClient, axios, fetch, @RequestMapping...)
+  - Test files (*Test.java, *.test.ts, *.spec.js...)
+  - Layout config (preferences.ts, vue.config.js, package.json...)
+"""
+import json
+import os
+import re
+import sys
+import time
+
+SCRIPTS = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, SCRIPTS)
+
+from common.paths import DATA_INDEX_DIR, PROJECT_ROOT
+from kg_duckdb import get_db, init_schema, _batch_insert
+
+CODE_DIR = str(PROJECT_ROOT / 'data' / 'code')
+DB_PATH = str(DATA_INDEX_DIR / 'kg.duckdb')
+
+
+# ── Project Discovery (zero hardcoded assumptions) ──────────────────
+
+def discover_projects():
+    """Scan data/code/ and discover each project's structure dynamically.
+
+    Returns list of ProjectConfig dicts:
+      {name, path, framework, lang, api_dirs, view_dirs, module_dirs,
+       test_globs, layout_file, has_vue, has_java}
+    """
+    projects = []
+    if not os.path.isdir(CODE_DIR):
+        return projects
+
+    for name in sorted(os.listdir(CODE_DIR)):
+        path = os.path.join(CODE_DIR, name)
+        if not os.path.isdir(path):
+            continue
+
+        cfg = {'name': name, 'path': path}
+        _discover_structure(cfg)
+        if cfg.get('framework') or cfg.get('has_vue') or cfg.get('has_java'):
+            projects.append(cfg)
+
+    return projects
+
+
+def _discover_structure(cfg):
+    """Auto-detect project framework, directories, patterns."""
+    path = cfg['path']
+    cfg['has_vue'] = False
+    cfg['has_java'] = False
+    cfg['has_ts'] = False
+    cfg['framework'] = 'unknown'
+    cfg['api_dirs'] = []      # directories containing API definitions
+    cfg['view_dirs'] = []     # directories containing page components
+    cfg['module_dirs'] = []   # directories representing business modules
+    cfg['test_globs'] = []    # patterns for test files
+    cfg['layout_file'] = None # preferences.ts / vue.config.js / etc
+    cfg['package_json'] = None
+
+    # Scan for markers (limit depth for speed)
+    vue_count = 0
+    java_count = 0
+    ts_count = 0
+    found_dirs = {'src/views': [], 'src/api': [], 'src/modules': [],
+                  'pages': [], 'app': [], 'src/components': []}
+
+    for root, dirs, files in os.walk(path):
+        dirs[:] = [d for d in dirs if d not in ('node_modules', '.git', 'dist',
+                                                  '__pycache__', '.svn', 'target', 'build')]
+        # Limit depth
+        depth = root[len(path):].count(os.sep)
+        if depth > 6:
+            dirs[:] = []
+            continue
+
+        rel_root = os.path.relpath(root, path).replace('\\', '/')
+
+        # Detect framework from package.json
+        for f in files:
+            if f == 'package.json':
+                cfg['package_json'] = os.path.join(root, f)
+                _detect_framework_from_pkgjson(cfg)
+            if f == 'preferences.ts':
+                cfg['layout_file'] = os.path.join(root, f)
+            if f == 'vue.config.js':
+                if not cfg['layout_file']:
+                    cfg['layout_file'] = os.path.join(root, f)
+
+        # Count file types
+        for f in files:
+            if f.endswith('.vue'):
+                vue_count += 1
+            elif f.endswith('.java'):
+                java_count += 1
+            elif f.endswith('.ts') or f.endswith('.tsx'):
+                ts_count += 1
+
+        # Detect known directory patterns (relative to project root)
+        for pattern in list(found_dirs.keys()):
+            if rel_root.endswith(pattern) or rel_root == pattern:
+                found_dirs[pattern].append(root)
+            # Also check monorepo: apps/*/src/views
+            if '/apps/' in rel_root:
+                for sub_pat in ['src/views', 'src/api']:
+                    if rel_root.endswith(sub_pat):
+                        found_dirs[sub_pat].append(root)
+
+    cfg['has_vue'] = vue_count > 0
+    cfg['has_java'] = java_count > 0
+    cfg['has_ts'] = ts_count > 0
+
+    # Assign discovered dirs
+    cfg['view_dirs'] = found_dirs['src/views'] + found_dirs['pages']
+    cfg['api_dirs'] = found_dirs['src/api']
+    cfg['module_dirs'] = found_dirs['src/modules'] + found_dirs['src/api']
+
+    # Test file patterns (auto-detect)
+    if cfg['has_java']:
+        cfg['test_globs'].append('*Test.java')
+    if cfg['has_ts'] or cfg['has_vue']:
+        cfg['test_globs'].extend(['*.test.ts', '*.spec.ts', '*.test.js'])
+
+    # If no framework detected from package.json, infer from file types
+    if cfg['framework'] == 'unknown':
+        if vue_count > 10:
+            cfg['framework'] = 'vue'
+        elif java_count > 10:
+            cfg['framework'] = 'java'
+        elif ts_count > 10:
+            cfg['framework'] = 'typescript'
+
+
+def _detect_framework_from_pkgjson(cfg):
+    """Detect UI framework from package.json dependencies."""
+    try:
+        pkg = json.load(open(cfg['package_json'], encoding='utf-8'))
+    except:
+        return
+    deps = set((pkg.get('dependencies') or {}).keys())
+    deps |= set((pkg.get('devDependencies') or {}).keys())
+    if not deps:
+        return
+
+    # Also check monorepo apps/*/package.json
+    apps_dir = os.path.join(os.path.dirname(cfg['package_json']), 'apps')
+    if os.path.isdir(apps_dir):
+        for app in os.listdir(apps_dir):
+            app_pkg = os.path.join(apps_dir, app, 'package.json')
+            if os.path.isfile(app_pkg):
+                try:
+                    ap = json.load(open(app_pkg, encoding='utf-8'))
+                    deps |= set((ap.get('dependencies') or {}).keys())
+                    deps |= set((ap.get('devDependencies') or {}).keys())
+                except:
+                    pass
+
+    if any(d.startswith('@vben/') for d in deps):
+        cfg['framework'] = 'vben-admin'
+    elif 'vant' in deps:
+        cfg['framework'] = 'vant-mobile'
+    elif 'react' in deps and 'react-dom' in deps:
+        cfg['framework'] = 'react'
+    elif 'ant-design-vue' in deps:
+        cfg['framework'] = 'ant-design-vue'
+    elif 'element-plus' in deps:
+        cfg['framework'] = 'element-plus'
+    elif 'vue' in deps:
+        cfg['framework'] = 'vue'
+
+
+# ── Extractors (work on any project, parameterized by ProjectConfig) ──
+
+def extract_keywords_and_apis(cfg):
+    """Extract keyword→file index + API endpoints for one project."""
+    kw_index = {}
+    api_index = {}
+    file_count = 0
+
+    exts = ['.vue', '.js', '.ts', '.jsx', '.tsx', '.java', '.xml', '.yml', '.yaml', '.properties']
+    for root, dirs, files in os.walk(cfg['path']):
+        dirs[:] = [d for d in dirs if d not in ('node_modules', '.git', 'dist', '__pycache__', '.svn', 'target', 'build')]
+        for f in files:
+            if not any(f.endswith(e) for e in exts):
+                continue
+            filepath = os.path.join(root, f)
+            rel = cfg['name'] + '/' + os.path.relpath(filepath, cfg['path']).replace('\\', '/')
+            file_count += 1
+            try:
+                content = open(filepath, encoding='utf-8', errors='ignore').read()
+            except:
+                continue
+
+            if f.endswith('.java'):
+                for m in re.finditer(r'(?:class|interface|enum)\s+(\w+)', content):
+                    for kw in [m.group(1).lower()] + re.findall(r'[A-Z]?[a-z]+', m.group(1)):
+                        kw_index.setdefault(kw.lower(), []).append(rel)
+                for m in re.finditer(r'@(?:Get|Post|Put|Delete|Request)Mapping\s*\(?["\']([^"\']+)["\']', content):
+                    api_index[m.group(1)] = rel
+            else:
+                name_m = re.search(r'name:\s*["\'](\w+)["\']', content)
+                if name_m:
+                    kw_index.setdefault(name_m.group(1).lower(), []).append(rel)
+                for pat in [r'requestClient\.\w+\s*\(?["\']([^"\']+)',
+                            r'(?:axios|request|fetch|http)\.\w+\s*\(?["\']([^"\']+)',
+                            r'path:\s*["\']([^"\']+)["\']']:
+                    for m in re.finditer(pat, content):
+                        kw_index.setdefault('api:' + m.group(1), []).append(rel)
+            for m in re.finditer(r'[A-Z]?[a-z]+', f.rsplit('.', 1)[0]):
+                kw = m.group().lower()
+                if len(kw) >= 3:
+                    kw_index.setdefault(kw, []).append(rel)
+
+    return kw_index, api_index, file_count
+
+
+def extract_ui_layer(cfg):
+    """Extract pages + fields + modules for one project (framework-aware)."""
+    pages = []
+    field_map = {}
+    modules = []
+
+    # Modules: auto-discover from api_dirs and module_dirs
+    seen_mods = set()
+    for d in cfg.get('module_dirs', []):
+        try:
+            for sub in sorted(os.listdir(d)):
+                if sub.startswith('.') or sub.startswith('_'):
+                    continue
+                sub_path = os.path.join(d, sub)
+                if os.path.isdir(sub_path):
+                    mod_key = sub.lower()
+                    if mod_key not in seen_mods:
+                        seen_mods.add(mod_key)
+                        rel = os.path.relpath(sub_path, cfg['path']).replace('\\', '/')
+                        modules.append({'dir': sub, 'cn': sub, 'project': cfg['name'], 'path': rel})
+        except:
+            pass
+
+    # Pages: scan view_dirs
+    table_marks = {
+        'vben-admin': ['VxeGrid', 'useVbenVxeGrid', '<a-table'],
+        'ant-design-vue': ['<a-table', 'a-table'],
+        'element-plus': ['<el-table', 'el-table'],
+        'vant-mobile': ['<van-list', 'van-list'],
+        'vue': ['<a-table', '<el-table', '<vxe-table'],
+    }.get(cfg.get('framework', ''), ['<table'])
+    table_marks_lower = [m.lower() for m in table_marks]
+
+    form_marks = {
+        'vben-admin': ['useVbenForm', '<a-form'],
+        'ant-design-vue': ['<a-form', 'a-form'],
+        'element-plus': ['<el-form', 'el-form'],
+        'vant-mobile': ['<van-form', 'van-form'],
+        'vue': ['<a-form', '<el-form'],
+    }.get(cfg.get('framework', ''), ['<form'])
+
+    for view_dir in cfg.get('view_dirs', []):
+        for root, dirs, files in os.walk(view_dir):
+            dirs[:] = [d for d in dirs if d not in ('node_modules', 'dist', '.git')]
+            for f in files:
+                if not f.endswith('.vue') and not f.endswith('.tsx') and not f.endswith('.jsx'):
+                    continue
+                filepath = os.path.join(root, f)
+                try:
+                    content = open(filepath, encoding='utf-8', errors='ignore').read()
+                except:
+                    continue
+
+                # Page type detection
+                ptype = 'unknown'
+                if any(m.lower() in content.lower() for m in table_marks_lower):
+                    ptype = 'table-page'
+                elif any(m in content for m in form_marks):
+                    ptype = 'form-page'
+                elif 'detail' in filepath.lower() or 'info' in filepath.lower():
+                    ptype = 'detail-page'
+                if ptype == 'unknown':
+                    continue
+
+                # Fields (generic patterns, framework-agnostic)
+                for m in re.finditer(r"title:\s*['\"]([^'\"]+)['\"]\s*,\s*field:\s*['\"]([^'\"]+)['\"]", content):
+                    field_map.setdefault(m.group(2), {'titles': set(), 'files': []})
+                    field_map[m.group(2)]['titles'].add(m.group(1))
+                    field_map[m.group(2)]['files'].append(filepath)
+                for m in re.finditer(r"fieldName:\s*['\"]([^'\"]+)['\"]\s*,\s*label:\s*['\"]([^'\"]+)['\"]", content):
+                    field_map.setdefault(m.group(1), {'titles': set(), 'files': []})
+                    field_map[m.group(1)]['titles'].add(m.group(2))
+                    field_map[m.group(1)]['files'].append(filepath)
+
+                rel = filepath.replace('\\', '/')
+                file_key = rel.split('/views/')[-1] if '/views/' in rel else \
+                           rel.split('/pages/')[-1] if '/pages/' in rel else os.path.basename(rel)
+                pages.append({'file': file_key, 'project': cfg['name'], 'page_type': ptype})
+
+    return pages, field_map, modules
+
+
+def extract_traces(cfg, api_table):
+    """Extract button→API traces for one Vue project."""
+    traces = []
+    if not cfg.get('has_vue') or not api_table:
+        return traces
+    try:
+        from common.ts_extract import ts_trace_clicks
+    except:
+        return traces
+
+    for view_dir in cfg.get('view_dirs', []):
+        for root, dirs, files in os.walk(view_dir):
+            dirs[:] = [d for d in dirs if d not in ('node_modules', 'dist', '.git')]
+            for f in files:
+                if not f.endswith('.vue'):
+                    continue
+                filepath = os.path.join(root, f)
+                try:
+                    content = open(filepath, encoding='utf-8', errors='ignore').read()
+                except:
+                    continue
+                if '@click' not in content:
+                    continue
+                traces.extend(ts_trace_clicks(filepath, content, api_table))
+    return traces
+
+
+def extract_tests(cfg):
+    """Extract test assertions for one project."""
+    results = []
+    try:
+        from common.test_extract import extract_test_assertions
+        results = extract_test_assertions(cfg['path'])
+    except:
+        pass
+    return results
+
+
+def extract_layout_fingerprint(cfg):
+    """Extract layout/design fingerprint from project config."""
+    fp = {}
+    layout_file = cfg.get('layout_file')
+    if layout_file and layout_file.endswith('preferences.ts'):
+        try:
+            from build_style_index import extract_layout_fingerprint as _elf
+            fp = _elf(cfg['path'])
+        except:
+            pass
+    elif cfg.get('package_json'):
+        # Infer from package.json
+        fp['stack'] = cfg.get('framework', 'unknown')
+    fp['stack'] = fp.get('stack', cfg.get('framework', 'unknown'))
+    return fp
+
+
+# ── Main build (project-agnostic) ───────────────────────────────────
+
+def build_all():
+    """Full rebuild: discover projects → extract → DuckDB. Zero hardcoded names."""
+    t0 = time.time()
+    con = get_db()
+    init_schema(con)
+
+    # Clear all
+    for table in ['entities', 'aliases', 'edges', 'keywords', 'endpoints', 'prds',
+                  'wiki', 'pages', 'fields', 'modules', 'traces', 'api_functions',
+                  'tests', 'workflows', 'style_meta', 'build_meta']:
+        con.execute('DELETE FROM %s' % table)
+
+    # 1. Discover projects
+    print('  [0/7] Discovering projects...')
+    projects = discover_projects()
+    print('    Found %d projects:' % len(projects))
+    for p in projects:
+        print('      %s: %s (%s, %d api_dirs, %d view_dirs)' % (
+            p['name'], p['framework'], 'vue' if p['has_vue'] else 'java' if p['has_java'] else '?',
+            len(p['api_dirs']), len(p['view_dirs'])))
+
+    stats = {}
+
+    # 2. Keywords + APIs (all projects)
+    print('  [1/7] keywords + APIs...')
+    all_kw_rows = []
+    all_ep_rows = []
+    for cfg in projects:
+        kw_idx, api_idx, fc = extract_keywords_and_apis(cfg)
+        for k, files in kw_idx.items():
+            for f in files:
+                all_kw_rows.append((k, f))
+        for ep, f in api_idx.items():
+            all_ep_rows.append((ep, f))
+    _batch_insert(con, 'keywords', all_kw_rows)
+    _batch_insert(con, 'endpoints', all_ep_rows, ignore=True)
+    stats['keywords'] = len(all_kw_rows)
+    stats['endpoints'] = len(all_ep_rows)
+
+    # 3. UI layer (Vue/React projects only)
+    print('  [2/7] UI pages + fields + modules...')
+    all_pages = []
+    all_fields = []
+    all_modules = []
+    style_meta = {}
+    for cfg in projects:
+        if not cfg.get('has_vue') and cfg['framework'] not in ('react',):
+            continue
+        pages, field_map, modules = extract_ui_layer(cfg)
+        all_pages.extend(pages)
+        for k, info in field_map.items():
+            all_fields.append((k, '/'.join(sorted(info['titles'])[:2]), len(info['files']), '[]'))
+        all_modules.extend(modules)
+        fp = extract_layout_fingerprint(cfg)
+        if fp:
+            style_meta[cfg['name']] = fp
+    page_rows = [(p['file'], p['project'], p['page_type'], '[]', '[]', '[]', '{}') for p in all_pages]
+    _batch_insert(con, 'pages', page_rows, ignore=True)
+    _batch_insert(con, 'fields', all_fields)
+    mod_rows = [(m['dir'], m['cn'], m['project'], m['path']) for m in all_modules]
+    _batch_insert(con, 'modules', mod_rows)
+    for proj, fp in style_meta.items():
+        con.execute("INSERT OR REPLACE INTO style_meta VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?)", [
+            proj, fp.get('stack', ''), fp.get('layout', ''), fp.get('access_mode', ''),
+            fp.get('sidebar_width'), fp.get('color_primary'), fp.get('color_success'),
+            fp.get('color_warning'), fp.get('color_destructive'), fp.get('radius'), 0, '{}', '{}'])
+    stats['pages'] = len(page_rows)
+    stats['fields'] = len(all_fields)
+    stats['modules'] = len(all_modules)
+
+    # 4. API functions + traces (Vue projects with api_dirs)
+    print('  [3/7] API functions...')
+    api_table = {}
+    for cfg in projects:
+        for api_dir in cfg.get('api_dirs', []):
+            try:
+                from common.ts_extract import ts_build_api_fn_table
+                t = ts_build_api_fn_table(api_dir)
+                api_table.update(t)
+            except:
+                pass
+    fn_rows = [(fn, info.get('url', ''), info.get('verb', ''), info.get('file', ''))
+               for fn, info in api_table.items()]
+    _batch_insert(con, 'api_functions', fn_rows, ignore=True)
+    stats['api_functions'] = len(fn_rows)
+
+    print('  [4/7] trace chain...')
+    all_traces = []
+    for cfg in projects:
+        all_traces.extend(extract_traces(cfg, api_table))
+    trace_rows = [(t.get('vue_file', '').replace('\\', '/'), t.get('button', ''),
+                   t.get('handler', ''), t.get('api_fn', ''), t.get('endpoint', ''),
+                   t.get('verb', ''), t.get('confidence', ''))
+                  for t in all_traces]
+    _batch_insert(con, 'traces', trace_rows)
+    stats['traces'] = len(trace_rows)
+
+    # 5. Tests
+    print('  [5/7] test assertions...')
+    all_tests = []
+    for cfg in projects:
+        all_tests.extend(extract_tests(cfg))
+    test_rows = [(t.get('class', ''), t.get('method', ''), t.get('package', ''),
+                  t.get('display_name', ''),
+                  json.dumps(t.get('injected_deps', []), ensure_ascii=False),
+                  json.dumps(t.get('assertions', []), ensure_ascii=False),
+                  t.get('is_integration', False))
+                 for t in all_tests]
+    _batch_insert(con, 'tests', test_rows)
+    stats['tests'] = len(test_rows)
+
+    # 6. Entities + edges
+    print('  [6/7] entity resolution + edges...')
+    _build_entities_and_edges(con, all_modules, dict(all_ep_rows and [(r[0], r[1]) for r in all_ep_rows] or []),
+                              all_traces, all_tests)
+    stats['entities'] = con.execute("SELECT COUNT(*) FROM entities").fetchone()[0]
+    stats['edges'] = con.execute("SELECT COUNT(*) FROM edges").fetchone()[0]
+
+    # 7. Workflows
+    print('  [7/7] workflows...')
+    wf_count = _build_workflows(con, all_traces)
+    stats['workflows'] = wf_count
+
+    con.execute("INSERT OR REPLACE INTO build_meta VALUES ('version', '2.0')")
+    con.execute("INSERT OR REPLACE INTO build_meta VALUES ('built_at', ?)", [str(int(time.time()))])
+    con.close()
+
+    stats['elapsed'] = '%.1fs' % (time.time() - t0)
+    return stats
+
+
+def _build_entities_and_edges(con, modules, api_idx, traces, tests):
+    """Build entities + edges (project-agnostic)."""
+    entity_rows = []
+    alias_rows = []
+    edge_rows = []
+
+    # FEATURE entities
+    feature_dirs = {}
+    for m in modules:
+        eid = 'F:%s:%s' % (m['project'], m['dir'])
+        entity_rows.append((eid, 'FEATURE', m['dir'], m['cn'], '{}'))
+        alias_rows.append((m['dir'].lower(), eid))
+        alias_rows.append((m['cn'].lower(), eid))
+        feature_dirs[m['dir'].lower()] = eid
+
+    # ENDPOINT + CONTROLLER entities + edges
+    seen_ctrl = set()
+    for ep, ctrl_file in api_idx.items():
+        eid = 'E:%s' % ep
+        entity_rows.append((eid, 'ENDPOINT', ep, '', '{}'))
+        ctrl_name = ctrl_file.split('/')[-1].replace('.java', '')
+        ctrl_eid = 'C:%s' % ctrl_name
+        if ctrl_name not in seen_ctrl:
+            entity_rows.append((ctrl_eid, 'CONTROLLER', ctrl_name, '', '{}'))
+            alias_rows.append((ctrl_name.lower(), ctrl_eid))
+            seen_ctrl.add(ctrl_name)
+        edge_rows.append((eid, ctrl_eid, 'handled_by', 0, '{}'))
+
+    # BUTTON entities + click edges
+    for t in traces:
+        vue = (t.get('vue_file') or '').replace('\\', '/')
+        handler = t.get('handler', '')
+        vue_short = vue.split('/views/')[-1] if '/views/' in vue else vue.split('/pages/')[-1] if '/pages/' in vue else vue
+        eid = 'B:%s:%s' % (vue_short, handler)
+        entity_rows.append((eid, 'BUTTON', handler, '',
+                            json.dumps({'button_text': t.get('button', ''),
+                                        'confidence': t.get('confidence', '')}, ensure_ascii=False)))
+        ep = t.get('endpoint')
+        if ep and ep != 'None':
+            edge_rows.append((eid, 'E:%s' % ep, 'clicks', 0,
+                              json.dumps({'button': t.get('button', ''),
+                                          'confidence': t.get('confidence', '')}, ensure_ascii=False)))
+
+    # TEST entities + controller→test edges
+    for t in tests:
+        name = '%s.%s' % (t.get('class', ''), t.get('method', ''))
+        eid = 'T:%s' % name
+        entity_rows.append((eid, 'TEST', name, '',
+                            json.dumps({'deps': t.get('injected_deps', []),
+                                        'assertions': t.get('assertions', [])}, ensure_ascii=False)))
+        for dep in t.get('injected_deps', []):
+            dep_base = dep.replace('I', '', 1).replace('Impl', '').replace('Service', '')
+            for ctrl_name in seen_ctrl:
+                if dep_base.lower() in ctrl_name.lower():
+                    edge_rows.append(('C:%s' % ctrl_name, eid, 'tested_by', 0, '{}'))
+
+    # FEATURE → endpoints/buttons edges
+    for m in modules:
+        feat_eid = 'F:%s:%s' % (m['project'], m['dir'])
+        mdir = m['dir'].lower()
+        for ep in api_idx:
+            if mdir in ep.lower():
+                edge_rows.append((feat_eid, 'E:%s' % ep, 'has_endpoint', 0, '{}'))
+        for t in traces:
+            vue = (t.get('vue_file') or '').lower()
+            if mdir in vue:
+                vue_short = vue.split('/views/')[-1] if '/views/' in vue else vue
+                btn_eid = 'B:%s:%s' % (vue_short, t.get('handler', ''))
+                edge_rows.append((feat_eid, btn_eid, 'has_button', 0, '{}'))
+
+    _batch_insert(con, 'entities', entity_rows, ignore=True)
+    _batch_insert(con, 'aliases', alias_rows, ignore=True)
+    _batch_insert(con, 'edges', edge_rows)
+
+
+def _build_workflows(con, traces):
+    """Build workflow chains (project-agnostic)."""
+    STATE_KW = {
+        'create': ['add', 'create', 'save', 'insert'],
+        'submit': ['submit', 'commit', 'apply'],
+        'execute': ['execute', 'start', 'begin'],
+        'complete': ['complete', 'finish', 'done', 'end'],
+        'archive': ['archive', 'close', 'settle'],
+        'delete': ['delete', 'remove', 'destroy'],
+        'export': ['export', 'download'],
+        'query': ['list', 'get', 'query', 'page', 'detail'],
+    }
+    from collections import defaultdict
+    mod_ops = defaultdict(list)
+    for t in traces:
+        vue = (t.get('vue_file') or '').replace('\\', '/')
+        mod = vue.split('/views/')[-1].split('/')[0] if '/views/' in vue else \
+              vue.split('/pages/')[-1].split('/')[0] if '/pages/' in vue else 'unknown'
+        text = ((t.get('button') or '') + ' ' + (t.get('endpoint') or '')).lower()
+        for state, kws in STATE_KW.items():
+            if any(k in text for k in kws):
+                mod_ops[mod].append((state, t.get('button', ''), t.get('endpoint', '')))
+                break
+
+    chain_order = ['query', 'create', 'submit', 'execute', 'complete', 'archive', 'export', 'delete']
+    wf_rows = []
+    for mod, ops in mod_ops.items():
+        for state in chain_order:
+            matching = [o for o in ops if o[0] == state]
+            for op in matching[:3]:
+                wf_rows.append((mod, state, chain_order.index(state), op[1], op[2]))
+    _batch_insert(con, 'workflows', wf_rows)
+    return len(wf_rows)
+
+
+if __name__ == '__main__':
+    print('=== kg_build.py: auto-discover → DuckDB (no JSON, no hardcode) ===')
+    stats = build_all()
+    print()
+    print('Done in %s' % stats.pop('elapsed', '?'))
+    for k, v in sorted(stats.items()):
+        print('  %-16s: %s' % (k, v))
+    print('  file: %s (%.1f KB)' % (DB_PATH, os.path.getsize(DB_PATH) / 1024))