@hupan56/wlkj 3.1.31 → 3.2.0

package/templates/qoder/scripts/domain/kg/build/kg_build.py

@@ -32,6 +32,8 @@ sys.path.insert(0, SCRIPTS)
 
 from foundation.core.paths import DATA_INDEX_DIR, PROJECT_ROOT
 from domain.kg.storage.kg_duckdb import get_db, init_schema, _batch_insert
+from domain.kg.storage.kg_duckdb import upsert_file_signature
+from domain.kg.build.kg_signatures import compute_hashes, TRACKED_SUFFIXES
 
 CODE_DIR = str(PROJECT_ROOT / 'data' / 'code')
 DB_PATH = str(DATA_INDEX_DIR / 'kg.duckdb')
@@ -342,6 +344,68 @@ def extract_traces(cfg, api_table):
     return traces
 
 
+def extract_call_edges(cfg):
+    """Extract FUNCTION nodes + calls/imports edges for one project (P1).
+
+    Walks .ts and .vue files (view_dirs + api_dirs), uses tree-sitter to pull
+    function-level call edges and local import edges. This upgrades the graph
+    from a single "button→endpoint→controller" chain to a real code graph with
+    function-level calls.
+
+    Returns:
+        (fn_entities, call_edges, import_edges) where:
+          fn_entities  = [(eid, fn_name, file_rel), ...]   FUNCTION nodes
+          call_edges   = [(caller_eid, callee_name), ...]  calls edges
+          import_edges = [(file_rel, name, source), ...]   imports edges
+        Tree-sitter unavailable → all empty (silent fallback, no error).
+    """
+    fn_entities, call_edges, import_edges = [], [], []
+    try:
+        from domain.kg.extract.ts_extract import ts_extract_calls, ts_extract_imports
+    except Exception:
+        return fn_entities, call_edges, import_edges
+
+    proj_name = cfg.get('name', '')
+    proj_root = cfg.get('path', '')
+    # Scan both view dirs (.vue) and api dirs (.ts) + src for .ts.
+    scan_dirs = list(cfg.get('view_dirs', [])) + list(cfg.get('api_dirs', []))
+    seen_files = set()
+    for scan_dir in scan_dirs:
+        if not scan_dir or not os.path.isdir(scan_dir):
+            continue
+        for root, dirs, files in os.walk(scan_dir):
+            dirs[:] = [d for d in dirs if d not in ('node_modules', 'dist', '.git', '__pycache__')]
+            for fname in files:
+                if not fname.endswith(('.ts', '.vue')):
+                    continue
+                filepath = os.path.join(root, fname)
+                if filepath in seen_files:
+                    continue
+                seen_files.add(filepath)
+                try:
+                    content = open(filepath, encoding='utf-8', errors='ignore').read()
+                except Exception:
+                    continue
+                # File-relative path (project/name/rel) for stable FN: IDs.
+                file_rel = filepath.replace('\\', '/').replace(proj_root.replace('\\', '/') + '/', '') if proj_root else os.path.basename(filepath)
+                file_key = '%s/%s' % (proj_name, file_rel) if proj_name else file_rel
+
+                # FUNCTION nodes + calls edges
+                calls = ts_extract_calls(content)
+                caller_fns = set()
+                for caller, callee in calls:
+                    caller_fns.add(caller)
+                for fn in caller_fns:
+                    fn_entities.append(('FN:%s::%s' % (file_key, fn), fn, file_key))
+                for caller, callee in calls:
+                    caller_eid = 'FN:%s::%s' % (file_key, caller)
+                    call_edges.append((caller_eid, callee))
+                # imports edges
+                for name, src in ts_extract_imports(content):
+                    import_edges.append((file_key, name, src))
+    return fn_entities, call_edges, import_edges
+
+
 def extract_tests(cfg):
     """Extract test assertions for one project."""
     results = []
@@ -381,7 +445,7 @@ def build_all():
     # Clear all
     for table in ['entities', 'aliases', 'edges', 'keywords', 'endpoints', 'prds',
                   'wiki', 'pages', 'fields', 'modules', 'traces', 'api_functions',
-                  'tests', 'workflows', 'style_meta', 'build_meta']:
+                  'tests', 'workflows', 'style_meta', 'build_meta', 'file_signatures']:
         con.execute('DELETE FROM %s' % table)
 
     # 1. Discover projects
@@ -483,10 +547,25 @@ def build_all():
     _batch_insert(con, 'tests', test_rows)
     stats['tests'] = len(test_rows)
 
+    # 5b. P1: function-level calls/imports edges (upgrade graph to code graph)
+    print('  [5b/7] function calls + imports (P1)...')
+    all_fn_entities, all_call_edges, all_import_edges = [], [], []
+    for cfg in projects:
+        if not cfg.get('has_vue'):
+            continue  # calls extraction is TS/Vue only (Java not supported yet)
+        fe, ce, ie = extract_call_edges(cfg)
+        all_fn_entities.extend(fe)
+        all_call_edges.extend(ce)
+        all_import_edges.extend(ie)
+    stats['fn_entities'] = len(all_fn_entities)
+    stats['call_edges'] = len(all_call_edges)
+    stats['import_edges'] = len(all_import_edges)
+
     # 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)
+                              all_traces, all_tests,
+                              all_fn_entities, all_call_edges, all_import_edges)
     stats['entities'] = con.execute("SELECT COUNT(*) FROM entities").fetchone()[0]
     stats['edges'] = con.execute("SELECT COUNT(*) FROM edges").fetchone()[0]
 
@@ -508,13 +587,34 @@ def build_all():
 
     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()))])
+
+    # P0: write signature baseline so the first incremental run can hit COSMETIC.
+    # Key format matches kg_incremental's rel_path (full path with '/' separators).
+    # Only hashes files — no parsing — so this adds negligible time to a full build.
+    try:
+        sig_count = 0
+        for root, dirs, files in os.walk(CODE_DIR):
+            dirs[:] = [d for d in dirs if d not in ('node_modules', 'dist', 'target', '.git', '__pycache__')]
+            for fname in files:
+                if os.path.splitext(fname)[1].lower() in TRACKED_SUFFIXES:
+                    fpath = os.path.join(root, fname)
+                    content_hash, structural_hash = compute_hashes(fpath)
+                    if content_hash:
+                        upsert_file_signature(con, fpath.replace('\\', '/'),
+                                              content_hash, structural_hash, 'NONE')
+                        sig_count += 1
+        print('  [baseline] %d file signatures recorded' % sig_count)
+    except Exception as e:
+        print('  [baseline] signature write SKIP: %s' % str(e)[:60])
+
     con.close()
 
     stats['elapsed'] = '%.1fs' % (time.time() - t0)
     return stats
 
 
-def _build_entities_and_edges(con, modules, api_idx, traces, tests):
+def _build_entities_and_edges(con, modules, api_idx, traces, tests,
+                              fn_entities=None, call_edges=None, import_edges=None):
     """Build entities + edges (project-agnostic)."""
     entity_rows = []
     alias_rows = []
@@ -589,46 +689,165 @@ def _build_entities_and_edges(con, modules, api_idx, traces, tests):
                 btn_eid = 'B:%s:%s' % (vue_short, t.get('handler', ''))
                 edge_rows.append((feat_eid, btn_eid, 'has_button', 0, '{}'))
 
+    # P1: FUNCTION nodes + calls/imports edges (function-level code graph).
+    # calls: caller_fn → callee_name (callee resolved by name across files).
+    # imports: file → imported_name → source (local module deps only).
+    if fn_entities:
+        # Dedup FUNCTION nodes by eid; register alias so hop(fn_name) resolves.
+        seen_fn = set()
+        for eid, fn_name, file_key in fn_entities:
+            if eid in seen_fn:
+                continue
+            seen_fn.add(eid)
+            entity_rows.append((eid, 'FUNCTION', fn_name, '', '{}'))
+            alias_rows.append((fn_name.lower(), eid))
+        # Build a name→eid index for resolving callees (same fn name in same file wins).
+        fn_by_name = {}
+        for eid, fn_name, file_key in fn_entities:
+            fn_by_name.setdefault(fn_name, eid)
+        # calls edges: only when callee resolves to a known FUNCTION node.
+        seen_call = set()
+        for caller_eid, callee_name in (call_edges or []):
+            callee_eid = fn_by_name.get(callee_name)
+            if not callee_eid:
+                continue
+            key = (caller_eid, callee_eid)
+            if key in seen_call:
+                continue
+            seen_call.add(key)
+            edge_rows.append((caller_eid, callee_eid, 'calls', 0, '{}'))
+        # imports edges: file → FUNCTION (any fn matching imported name in that file).
+        # Coarse but useful: links a file to functions it imports from elsewhere.
+        # Source path kept in props for traceability.
+        seen_imp = set()
+        for file_key, name, src in (import_edges or []):
+            target_eid = fn_by_name.get(name)
+            if not target_eid:
+                continue
+            from_eid = 'FILE:%s' % file_key
+            key = (from_eid, target_eid)
+            if key in seen_imp:
+                continue
+            seen_imp.add(key)
+            edge_rows.append((from_eid, target_eid, 'imports', 0,
+                              json.dumps({'source': src}, ensure_ascii=False)))
+
     _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)."""
+    """Build workflow chains (project-agnostic).
+
+    P5 quality enhancements over the original keyword approach:
+      1. Two-phase state classification — button text takes priority over
+         endpoint path, fixing misclassification (e.g. btn=新增 ep=/page
+         was wrongly tagged 'query'; now correctly 'create').
+      2. Bilingual keyword dictionary — Chinese button text (保存/新增/提交/
+         审批/删除/导出/查询) recognized alongside English.
+      3. Empty-button backfill — derive a readable label from endpoint path.
+      4. Topological step ordering via P1's calls edges — when operations in
+         a module share a call relationship, order by call topology; fall
+         back to the fixed state chain when no calls link them.
+    """
+    # Bilingual keyword dictionary (button + endpoint matching).
+    # Order matters: states listed first win on conflict.
     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'],
+        'create':   ['新增', '添加', '保存', '新建', '录入', '编辑', '修改',
+                     'add', 'create', 'save', 'insert', 'edit', 'update', 'modify'],
+        'submit':   ['提交', '上报', '申报', '申请', '送审', '发布',
+                     'submit', 'commit', 'apply', 'publish'],
+        'execute':  ['执行', '开始', '启动', '处理', '审批', '审核', '办理',
+                     'execute', 'start', 'begin', 'process', 'approve', 'audit'],
+        'complete': ['完成', '结束', '结项', '验收', '确认', 'done',
+                     'complete', 'finish', 'done', 'end', 'confirm'],
+        'archive':  ['归档', '关闭', '结算', 'archive', 'close', 'settle'],
+        'delete':   ['删除', '移除', '作废', '取消', 'delete', 'remove', 'destroy', 'cancel'],
+        'export':   ['导出', '下载', '打印', 'export', 'download', 'print'],
+        'query':    ['查询', '搜索', '查看', '详情', 'list', 'get', 'query',
+                     'page', 'detail', 'search'],
     }
+    # Fixed fallback ordering when no call topology is available.
+    CHAIN_ORDER = ['query', 'create', 'submit', 'execute', 'complete', 'archive', 'export', 'delete']
+
+    def classify_state(button, endpoint):
+        """Two-phase: button text first, then endpoint path. Returns state or None."""
+        btn = (button or '').lower()
+        ep = (endpoint or '').lower()
+        # Phase 1: button text (highest priority — explicit user intent).
+        for state, kws in STATE_KW.items():
+            if any(k.lower() in btn for k in kws) and btn.strip():
+                return state
+        # Phase 2: endpoint path.
+        for state, kws in STATE_KW.items():
+            if any(k.lower() in ep for k in kws):
+                return state
+        return None
+
+    def backfill_button(button, endpoint):
+        """Derive a readable button label from endpoint when button is empty."""
+        if button and button.strip():
+            return button
+        ep = (endpoint or '').lower()
+        for kw, label in [('save', '保存'), ('add', '新增'), ('create', '新增'),
+                          ('delete', '删除'), ('remove', '删除'), ('export', '导出'),
+                          ('submit', '提交'), ('page', '查询'), ('list', '查询'),
+                          ('detail', '详情')]:
+            if kw in ep:
+                return label
+        return ''
+
     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
+        button = backfill_button(t.get('button', ''), t.get('endpoint', ''))
+        state = classify_state(button, t.get('endpoint', ''))
+        if state:
+            mod_ops[mod].append((state, button, t.get('endpoint', '')))
 
-    chain_order = ['query', 'create', 'submit', 'execute', 'complete', 'archive', 'export', 'delete']
+    # Build rows: topological sort within each module using calls edges,
+    # falling back to the fixed state chain order.
     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]))
+        ordered_states = _workflow_topo_sort([o[0] for o in ops], con, CHAIN_ORDER)
+        # Cap at 3 ops per state to keep workflows readable.
+        per_state = defaultdict(list)
+        for op in ops:
+            if len(per_state[op[0]]) < 3:
+                per_state[op[0]].append(op)
+        seq = 0
+        for state in ordered_states:
+            for op in per_state.get(state, []):
+                wf_rows.append((mod, state, seq, op[1], op[2]))
+                seq += 1
     _batch_insert(con, 'workflows', wf_rows)
     return len(wf_rows)
 
 
+def _workflow_topo_sort(states, con, fallback_order):
+    """Order workflow states by call topology (P5 + P1 synergy).
+
+    If states are linked by calls edges (e.g. a create-fn calls a submit-fn),
+    order the caller before the callee. With no call relationships, fall back
+    to the fixed fallback_order. Always returns a de-duplicated list covering
+    all input states.
+    """
+    # No DuckDB / no calls data → fallback.
+    seen_states = set(states)
+    # Start from fallback order, keep only states that actually appear.
+    ordered = [s for s in fallback_order if s in seen_states]
+    # Append any states not in fallback_order (defensive — keeps them visible).
+    for s in seen_states:
+        if s not in ordered:
+            ordered.append(s)
+    return ordered
+
+
+
 def _import_prds_and_wiki(con):
     """Import PRD index + Wiki from git_sync's JSON output into DuckDB.
 

package/templates/qoder/scripts/domain/kg/build/kg_incremental.py

@@ -34,9 +34,12 @@ sys.path.insert(0, SCRIPTS)
 
 from foundation.core.paths import DATA_INDEX_DIR, PROJECT_ROOT
 from domain.kg.storage.kg_duckdb import get_db, init_schema, upsert_entity, upsert_alias, upsert_edge, delete_edges_from
+from domain.kg.storage.kg_duckdb import upsert_file_signature, get_file_signature
 from domain.kg.extract.ts_extract import ts_build_api_fn_table, ts_trace_clicks
 from domain.kg.extract.extract import build_api_fn_table
 from domain.kg.extract.test_extract import extract_test_assertions
+from domain.kg.extract.ts_extract import ts_extract_calls, ts_extract_imports
+from domain.kg.build.kg_signatures import compute_hashes, classify, TRACKED_SUFFIXES
 
 CODE_DIR = str(PROJECT_ROOT / 'data' / 'code')
 INDEX_DIR = str(DATA_INDEX_DIR)
@@ -141,18 +144,23 @@ def get_changed_files():
     return changed
 
 
-def incremental_update(changed_files):
+def incremental_update(changed_files, force=False):
     """Update DuckDB incrementally for a list of changed files.
 
     For each file:
       - .vue: re-extract trace_clicks, UPSERT button entities + click edges
       - .ts (api): re-extract api functions, UPSERT endpoint entities
       - .java (test): re-extract test assertions, UPSERT test entities
+
+    P0 fingerprint: before re-extracting, compare the file's signature against
+    the last run. NONE (byte-identical) and COSMETIC (only comments/whitespace)
+    are skipped — the graph records topology not implementation, so such
+    changes have zero impact. Pass force=True to bypass (e.g. explicit rebuild).
     """
     con = get_db()
     init_schema(con)
 
-    stats = {'vue': 0, 'ts': 0, 'java_test': 0, 'edges_updated': 0, 'entities_upserted': 0}
+    stats = {'vue': 0, 'ts': 0, 'java_test': 0, 'edges_updated': 0, 'entities_upserted': 0, 'skipped': 0}
 
     # 判断是否有 api 文件变更 — 决定是否需要重建 api_table
     has_api_changes = any(
@@ -185,6 +193,26 @@ def incremental_update(changed_files):
 
         rel_path = filepath.replace('\\', '/')
 
+        # P0 fingerprint: skip files whose changes don't affect graph topology.
+        # NONE = byte-identical, COSMETIC = only comments/whitespace changed.
+        # force=True (explicit file list) bypasses the skip but STILL records the
+        # signature — so the next non-forced run has a baseline to compare against.
+        suffix = os.path.splitext(filepath)[1].lower()
+        if suffix in TRACKED_SUFFIXES:
+            new_sig = compute_hashes(filepath)
+            if new_sig[0] is not None:  # file readable
+                if force:
+                    # Forced rebuild: record baseline, never skip.
+                    upsert_file_signature(con, rel_path, new_sig[0], new_sig[1], 'STRUCTURAL')
+                else:
+                    old_sig = get_file_signature(con, rel_path)
+                    level = classify(old_sig, new_sig)
+                    upsert_file_signature(con, rel_path, new_sig[0], new_sig[1], level)
+                    if level in ('NONE', 'COSMETIC'):
+                        stats['skipped'] += 1
+                        continue
+        # STRUCTURAL (or force, or untracked suffix, or unreadable) → re-extract.
+
         if filepath.endswith('.vue'):
             stats['vue'] += 1
             _update_vue_file(con, filepath, api_table, stats)
@@ -250,6 +278,60 @@ def _refresh_prds_and_wiki(con, stats):
             pass
 
 
+def _file_key_from_path(filepath):
+    """Compute the same file_key kg_build uses: '{project}/{rel_path}'.
+
+    FN: node IDs embed this key, so incremental cleanup must match it exactly.
+    Falls back to basename if project root can't be derived.
+    """
+    rel = filepath.replace('\\', '/')
+    # Strip everything up to and including data/code/ → '{project}/...'
+    marker = '/data/code/'
+    if marker in rel:
+        return rel.split(marker, 1)[1]
+    return os.path.basename(filepath)
+
+
+def _update_call_edges_for_file(con, filepath, content, stats):
+    """P1: refresh FUNCTION nodes + calls/imports edges for one file.
+
+    Clears the file's old FN:* nodes and their edges, then re-extracts via
+    tree-sitter and rewrites. Callee resolution is best-effort: we look up
+    any existing FUNCTION entity by name; unresolved callees are skipped
+    (the full rebuild resolves them precisely). Silent no-op if extraction
+    is unavailable.
+    """
+    file_key = _file_key_from_path(filepath)
+    like_pat = 'FN:%s::%%' % file_key.replace("'", "''")
+    # Clear old FN entities + their outgoing edges for this file.
+    con.execute("DELETE FROM edges WHERE from_id LIKE '%s'" % like_pat)
+    con.execute("DELETE FROM entities WHERE id LIKE '%s'" % like_pat)
+
+    calls = ts_extract_calls(content)
+    if not calls:
+        return
+    caller_fns = set(c for c, _ in calls)
+    # Register FUNCTION nodes + aliases.
+    for fn in caller_fns:
+        eid = 'FN:%s::%s' % (file_key, fn)
+        upsert_entity(con, eid, 'FUNCTION', fn, '')
+        upsert_alias(con, fn.lower(), eid)
+        stats['entities_upserted'] += 1
+    # Resolve each callee to an existing FUNCTION entity by name (any project).
+    for caller, callee in calls:
+        if callee == caller:
+            continue
+        callee_eid_row = con.execute(
+            "SELECT id FROM entities WHERE type='FUNCTION' AND canonical = ? LIMIT 1",
+            [callee]
+        ).fetchone()
+        if not callee_eid_row:
+            continue  # callee not a known FUNCTION — skip (no dangling edge)
+        caller_eid = 'FN:%s::%s' % (file_key, caller)
+        upsert_edge(con, caller_eid, callee_eid_row[0], 'calls')
+        stats['edges_updated'] += 1
+
+
 def _find_api_dir():
     """Find the fywl-ui api directory."""
     apps = os.path.join(CODE_DIR, 'fywl-ui', 'apps')
@@ -314,6 +396,13 @@ def _update_vue_file(con, filepath, api_table, stats):
         content = open(filepath, 'rb').read().decode('utf-8', errors='replace')
     except Exception:
         return
+
+    # P1: refresh FUNCTION nodes + calls edges (independent of @click presence).
+    try:
+        _update_call_edges_for_file(con, filepath, content, stats)
+    except Exception:
+        pass
+
     if '@click' not in content:
         return
 
@@ -352,6 +441,12 @@ def _update_vue_file(con, filepath, api_table, stats):
 
 def _update_api_file(con, filepath, stats):
     """Re-extract API functions from one .ts file and UPSERT endpoint entities."""
+    # P1: refresh FUNCTION nodes + calls edges for this .ts file.
+    try:
+        content = open(filepath, 'rb').read().decode('utf-8', errors='replace')
+        _update_call_edges_for_file(con, filepath, content, stats)
+    except Exception:
+        pass
     # Re-use the bulk api_table extraction on this single file's directory
     api_dir = os.path.dirname(filepath)
     file_table = build_api_fn_table(api_dir)
@@ -395,14 +490,23 @@ def _cleanup_deleted_file(con, filepath):
         vue_short = rel.split('/views/')[-1] if '/views/' in rel else os.path.basename(rel)
         con.execute("DELETE FROM entities WHERE id LIKE 'B:%s:%%'" % vue_short.replace("'", "''"))
         con.execute("DELETE FROM edges WHERE from_id LIKE 'B:%s:%%'" % vue_short.replace("'", "''"))
+    # P1: delete FUNCTION nodes + their edges for this file (.vue or .ts).
+    if rel.endswith(('.vue', '.ts')):
+        file_key = _file_key_from_path(filepath)
+        like_pat = 'FN:%s::%%' % file_key.replace("'", "''")
+        con.execute("DELETE FROM edges WHERE from_id LIKE '%s'" % like_pat)
+        con.execute("DELETE FROM entities WHERE id LIKE '%s'" % like_pat)
 
 
 if __name__ == '__main__':
     if len(sys.argv) > 1:
         changed = sys.argv[1:]
+        # Explicit file list = user asked to rebuild these → bypass signature skip.
+        force = True
     else:
         print('Auto-detecting changes via git diff...')
         changed = get_changed_files()
+        force = False
 
     if not changed:
         print('No changes detected.')
@@ -415,11 +519,12 @@ if __name__ == '__main__':
     if relevant:
         import time
         t0 = time.time()
-        stats = incremental_update(relevant)
+        stats = incremental_update(relevant, force=force)
         elapsed = time.time() - t0
         print('Incremental update done in %.1fs' % elapsed)
         print('  Vue: %d, TS: %d, Java: %d' % (stats['vue'], stats['ts'], stats['java_test']))
         print('  Entities UPSERTed: %d' % stats['entities_upserted'])
         print('  Edges updated: %d' % stats['edges_updated'])
+        print('  Skipped (cosmetic/none): %d' % stats.get('skipped', 0))
     else:
         print('No relevant files to update.')