@hupan56/wlkj 2.6.0 → 2.7.1

package/templates/qoder/scripts/kg_duckdb.py

@@ -0,0 +1,549 @@
+# -*- coding: utf-8 -*-
+"""
+DuckDB knowledge graph store — replaces the JSON flat files with a single
+embedded database for fast incremental updates.
+
+Why DuckDB (not JSON):
+  - Weekly 1000+ commits need incremental UPSERT, not full rebuild
+  - Single-file storage (kg.duckdb) with ACID transactions
+  - Recursive CTE for multi-hop graph traversal (replaces Python BFS)
+  - pip install, no server, PM-friendly
+
+Schema:
+  entities(id TEXT PK, type TEXT, canonical TEXT, cn TEXT, props JSON)
+  aliases(alias TEXT PK, entity_id TEXT)
+  edges(from_id TEXT, to_id TEXT, edge_type TEXT, seq INT, props JSON)
+  build_meta(key TEXT PK, value TEXT)
+"""
+import json
+import os
+import sys
+
+import duckdb
+
+SCRIPTS = os.path.join(os.path.dirname(os.path.abspath(__file__)), '.qoder', 'scripts')
+sys.path.insert(0, SCRIPTS)
+from common.paths import DATA_INDEX_DIR
+
+DB_PATH = str(DATA_INDEX_DIR / 'kg.duckdb')
+
+
+def get_db():
+    """Open DuckDB connection (creates file if not exists)."""
+    os.makedirs(os.path.dirname(DB_PATH), exist_ok=True)
+    return duckdb.connect(DB_PATH)
+
+
+def init_schema(con):
+    """Create tables if not exist."""
+    con.execute("""
+        CREATE TABLE IF NOT EXISTS entities (
+            id TEXT PRIMARY KEY,
+            type TEXT NOT NULL,
+            canonical TEXT NOT NULL,
+            cn TEXT DEFAULT '',
+            props JSON
+        )
+    """)
+    con.execute("""
+        CREATE TABLE IF NOT EXISTS aliases (
+            alias TEXT PRIMARY KEY,
+            entity_id TEXT NOT NULL
+        )
+    """)
+    con.execute("""
+        CREATE TABLE IF NOT EXISTS edges (
+            from_id TEXT NOT NULL,
+            to_id TEXT NOT NULL,
+            edge_type TEXT NOT NULL,
+            seq INTEGER DEFAULT 0,
+            props JSON
+        )
+    """)
+    con.execute("""
+        CREATE TABLE IF NOT EXISTS build_meta (
+            key TEXT PRIMARY KEY,
+            value TEXT
+        )
+    """)
+    # ── 搜索层表 ──
+    con.execute("CREATE TABLE IF NOT EXISTS keywords(keyword TEXT, file_path TEXT)")
+    con.execute("CREATE TABLE IF NOT EXISTS endpoints(endpoint TEXT PRIMARY KEY, controller_file TEXT)")
+    con.execute("CREATE TABLE IF NOT EXISTS prds(file TEXT PRIMARY KEY, title TEXT, keywords JSON, features JSON, cn_terms JSON)")
+    con.execute("CREATE TABLE IF NOT EXISTS wiki(keyword TEXT, project TEXT, title TEXT, md_path TEXT, description TEXT)")
+    # ── UI层表 ──
+    con.execute("CREATE TABLE IF NOT EXISTS pages(file TEXT PRIMARY KEY, project TEXT, page_type TEXT, components JSON, table_columns JSON, form_fields JSON, layout JSON)")
+    con.execute("CREATE TABLE IF NOT EXISTS fields(field TEXT, title TEXT, count INTEGER, sample_files JSON)")
+    con.execute("CREATE TABLE IF NOT EXISTS modules(dir TEXT, cn TEXT, project TEXT, path TEXT)")
+    # ── trace层表 ──
+    con.execute("CREATE TABLE IF NOT EXISTS traces(vue_file TEXT, button TEXT, handler TEXT, api_fn TEXT, endpoint TEXT, verb TEXT, confidence TEXT)")
+    con.execute("CREATE TABLE IF NOT EXISTS api_functions(fn_name TEXT PRIMARY KEY, url TEXT, verb TEXT, source_file TEXT)")
+    # ── test层表 ──
+    con.execute("CREATE TABLE IF NOT EXISTS tests(class TEXT, method TEXT, package TEXT, display_name TEXT, injected_deps JSON, assertions JSON, is_integration BOOLEAN)")
+    # ── workflow层表 ──
+    con.execute("CREATE TABLE IF NOT EXISTS workflows(module TEXT, state TEXT, seq INTEGER, button TEXT, endpoint TEXT)")
+    # ── style层表 ──
+    con.execute("CREATE TABLE IF NOT EXISTS style_meta(project TEXT PRIMARY KEY, stack TEXT, layout TEXT, access_mode TEXT, sidebar_width INTEGER, color_primary TEXT, color_success TEXT, color_warning TEXT, color_destructive TEXT, radius TEXT, vue_files INTEGER, common_components JSON, form_components JSON)")
+    # ── learning层表 (团队学习聚合, 同构代码图谱) ──
+    # 埋点事件 (每人写 journal/feedback.jsonl, 管理员聚合到此)
+    con.execute("""CREATE TABLE IF NOT EXISTS learning_events (
+        id TEXT PRIMARY KEY,
+        ts TEXT NOT NULL,
+        dev TEXT NOT NULL,
+        event TEXT NOT NULL,
+        data JSON
+    )""")
+    # 提炼后的模式 (团队共享, learn_aggregate 生成)
+    con.execute("""CREATE TABLE IF NOT EXISTS learning_patterns (
+        category TEXT NOT NULL,
+        pattern TEXT NOT NULL,
+        frequency INTEGER DEFAULT 1,
+        first_seen TEXT,
+        last_seen TEXT,
+        source_devs JSON
+    )""")
+    # 开发者统计快照 (聚合时刷新)
+    con.execute("""CREATE TABLE IF NOT EXISTS learning_stats (
+        dev TEXT PRIMARY KEY,
+        prds_generated INTEGER DEFAULT 0,
+        rejections INTEGER DEFAULT 0,
+        reviews_done INTEGER DEFAULT 0,
+        tasks_completed INTEGER DEFAULT 0,
+        commits_done INTEGER DEFAULT 0,
+        updated_at TEXT
+    )""")
+    # 自动补列: events.py 注册的新统计列, 表里没有就加 (ALTER ... ADD COLUMN IF NOT EXISTS)
+    # 这样 events.py 加埋点不用手动改表结构。
+    try:
+        from common.events import event_to_sql_filter
+        existing = {r[0] for r in con.execute(
+            "SELECT column_name FROM information_schema.columns "
+            "WHERE table_name = 'learning_stats'"
+        ).fetchall()}
+        for stat_col in event_to_sql_filter().keys():
+            if stat_col not in existing:
+                con.execute(
+                    "ALTER TABLE learning_stats ADD COLUMN IF NOT EXISTS %s INTEGER DEFAULT 0"
+                    % stat_col
+                )
+    except Exception:
+        pass  # events.py 不可用 (循环导入等) = 退化为固定 5 列, 不影响
+    # Indexes
+    con.execute("CREATE INDEX IF NOT EXISTS idx_ent_type ON entities(type)")
+    con.execute("CREATE INDEX IF NOT EXISTS idx_alias ON aliases(alias)")
+    con.execute("CREATE INDEX IF NOT EXISTS idx_edge_from ON edges(from_id)")
+    con.execute("CREATE INDEX IF NOT EXISTS idx_edge_to ON edges(to_id)")
+    con.execute("CREATE INDEX IF NOT EXISTS idx_kw ON keywords(keyword)")
+    con.execute("CREATE INDEX IF NOT EXISTS idx_page_type ON pages(page_type)")
+    con.execute("CREATE INDEX IF NOT EXISTS idx_field ON fields(field)")
+    con.execute("CREATE INDEX IF NOT EXISTS idx_trace_ep ON traces(endpoint)")
+    con.execute("CREATE INDEX IF NOT EXISTS idx_trace_vue ON traces(vue_file)")
+    con.execute("CREATE INDEX IF NOT EXISTS idx_wiki_kw ON wiki(keyword)")
+    con.execute("CREATE INDEX IF NOT EXISTS idx_learn_event ON learning_events(event)")
+    con.execute("CREATE INDEX IF NOT EXISTS idx_learn_dev ON learning_events(dev)")
+    con.execute("CREATE INDEX IF NOT EXISTS idx_learn_pat_cat ON learning_patterns(category)")
+    con.execute("CREATE INDEX IF NOT EXISTS idx_wf_mod ON workflows(module)")
+
+
+def _sql_escape(val):
+    """Escape a value for SQL string literal."""
+    return str(val).replace("'", "''")
+
+
+def _batch_insert(con, table, rows, chunk_size=500, ignore=False):
+    """Batch insert rows using VALUES SQL. ignore=True for OR IGNORE (PK tables)."""
+    prefix = "INSERT OR IGNORE INTO " if ignore else "INSERT INTO "
+    for i in range(0, len(rows), chunk_size):
+        chunk = rows[i:i + chunk_size]
+        values_parts = []
+        for row in chunk:
+            escaped = ",".join("'" + _sql_escape(v) + "'" for v in row)
+            values_parts.append("(" + escaped + ")")
+        sql = prefix + table + " VALUES " + ",".join(values_parts)
+        con.execute(sql)
+
+
+def upsert_entity(con, eid, etype, canonical, cn='', props=None):
+    """Insert or replace an entity."""
+    con.execute(
+        "INSERT OR REPLACE INTO entities VALUES (?, ?, ?, ?, ?)",
+        [eid, etype, canonical, cn, json.dumps(props or {}, ensure_ascii=False)]
+    )
+
+
+def upsert_alias(con, alias, entity_id):
+    """Insert or replace an alias mapping."""
+    con.execute(
+        "INSERT OR REPLACE INTO aliases VALUES (?, ?)",
+        [alias.lower(), entity_id]
+    )
+
+
+def upsert_edge(con, from_id, to_id, edge_type, seq=0, props=None):
+    """Insert an edge."""
+    con.execute(
+        "INSERT INTO edges VALUES (?, ?, ?, ?, ?)",
+        [from_id, to_id, edge_type, seq, json.dumps(props or {}, ensure_ascii=False)]
+    )
+
+
+def delete_edges_from(con, from_id, edge_type=None):
+    """Delete all edges from a node (for incremental rebuild)."""
+    if edge_type:
+        con.execute("DELETE FROM edges WHERE from_id = ? AND edge_type = ?", [from_id, edge_type])
+    else:
+        con.execute("DELETE FROM edges WHERE from_id = ?", [from_id])
+
+
+def resolve_entity(con, alias):
+    """Resolve any alias to its canonical entity ID."""
+    row = con.execute(
+        "SELECT entity_id FROM aliases WHERE alias = ?", [alias.lower()]
+    ).fetchone()
+    return row[0] if row else None
+
+
+def get_neighbors(con, entity_id, edge_type=None, direction='out'):
+    """Get neighbors of an entity (one-hop)."""
+    if direction == 'out':
+        sql = "SELECT to_id FROM edges WHERE from_id = ?"
+    else:
+        sql = "SELECT from_id FROM edges WHERE to_id = ?"
+    params = [entity_id]
+    if edge_type:
+        sql += " AND edge_type = ?"
+        params.append(edge_type)
+    rows = con.execute(sql, params).fetchall()
+    return [r[0] for r in rows]
+
+
+def multi_hop(con, start_id, edge_types=None, max_depth=5):
+    """Multi-hop traversal using recursive CTE."""
+    type_filter = ""
+    if edge_types:
+        placeholders = ",".join("'%s'" % t for t in edge_types)
+        type_filter = "AND edge_type IN (%s)" % placeholders
+
+    sql = """
+        WITH RECURSIVE reach(id, depth) AS (
+            SELECT '%s', 0
+            UNION ALL
+            SELECT e.to_id, r.depth + 1
+            FROM edges e
+            JOIN reach r ON e.from_id = r.id
+            WHERE r.depth < %d %s
+        )
+        SELECT id, MAX(depth) as max_depth
+        FROM reach
+        GROUP BY id
+        ORDER BY max_depth
+    """ % (start_id, max_depth, type_filter)
+
+    rows = con.execute(sql).fetchall()
+    return [(r[0], r[1]) for r in rows]
+
+
+def bulk_import_from_json(con):
+    """One-time full import from existing JSON indexes into DuckDB."""
+    INDEX = str(DATA_INDEX_DIR / '_build_cache')
+
+    def load(name):
+        p = os.path.join(INDEX, name)
+        if os.path.isfile(p):
+            return json.load(open(p, encoding='utf-8'))
+        return {}
+
+    con.execute("DELETE FROM entities")
+    con.execute("DELETE FROM aliases")
+    con.execute("DELETE FROM edges")
+
+    er = load('entity-registry.json')
+    rel = load('relations.json')
+    edges_data = rel.get('edges', {})
+
+    entity_rows = []
+    alias_rows = []
+    edge_rows = []
+    ctrl_seen = set()
+
+    # Entities + aliases
+    for eid, ent in er.get('entities', {}).items():
+        props = ent.get('properties', {})
+        entity_rows.append((eid, ent['type'], ent['canonical'],
+                            ent.get('cn', ''), json.dumps(props, ensure_ascii=False)))
+        for alias in ent.get('aliases', []):
+            alias_rows.append((alias.lower(), eid))
+
+    # Edges: click_to_api
+    for click in edges_data.get('click_to_api', []):
+        vue = click.get('vue_file', '')
+        vue_short = vue.split('/views/')[-1] if '/views/' in vue else vue
+        from_eid = 'B:%s:%s' % (vue_short, click.get('handler', ''))
+        to_eid = 'E:%s' % click.get('endpoint', '')
+        edge_rows.append((from_eid, to_eid, 'clicks', 0,
+                          json.dumps({'button': click.get('button', ''),
+                                      'confidence': click.get('confidence', '')},
+                                     ensure_ascii=False)))
+
+    # Edges: api_to_controller
+    for ep, ctrl_file in edges_data.get('api_to_controller', {}).items():
+        from_eid = 'E:%s' % ep
+        ctrl_name = ctrl_file.split('/')[-1].replace('.java', '')
+        to_eid = 'C:%s' % ctrl_name
+        if ctrl_name not in ctrl_seen:
+            entity_rows.append((to_eid, 'CONTROLLER', ctrl_name, '', '{}'))
+            alias_rows.append((ctrl_name.lower(), to_eid))
+            ctrl_seen.add(ctrl_name)
+        edge_rows.append((from_eid, to_eid, 'handled_by', 0, '{}'))
+
+    # Edges: controller_to_tests
+    for ctrl, tests in edges_data.get('controller_to_tests', {}).items():
+        ctrl_eid = 'C:%s' % ctrl
+        for t in tests[:5]:
+            test_eid = 'T:%s' % t.get('test', '')
+            edge_rows.append((ctrl_eid, test_eid, 'tested_by', 0,
+                              json.dumps({'dep': t.get('dep', ''),
+                                          'assertions': t.get('assertions', [])},
+                                         ensure_ascii=False)))
+
+    # Edges: feature adjacency
+    for feat_id, adj in er.get('feature_adjacency', {}).items():
+        for ep_eid in adj.get('endpoints', []):
+            edge_rows.append((feat_id, ep_eid, 'has_endpoint', 0, '{}'))
+        for btn_eid in adj.get('buttons', []):
+            edge_rows.append((feat_id, btn_eid, 'has_button', 0, '{}'))
+        for test_eid in adj.get('tests', []):
+            edge_rows.append((feat_id, test_eid, 'has_test', 0, '{}'))
+
+    # Batch insert
+    _batch_insert(con, 'entities', entity_rows, ignore=True)
+    _batch_insert(con, 'aliases', alias_rows, ignore=True)
+    _batch_insert(con, 'edges', edge_rows, ignore=False)
+
+    # Meta
+    con.execute("INSERT OR REPLACE INTO build_meta VALUES ('version', '1.0')")
+    con.execute("INSERT OR REPLACE INTO build_meta VALUES ('entities', ?)", [str(len(entity_rows))])
+    con.execute("INSERT OR REPLACE INTO build_meta VALUES ('edges', ?)", [str(len(edge_rows))])
+
+    return len(entity_rows), len(edge_rows)
+
+
+def import_search_layer(con):
+    """导入搜索层: keywords/endpoints/prds/wiki → DuckDB 表。"""
+    INDEX = str(DATA_INDEX_DIR)
+    def load(name):
+        p = os.path.join(INDEX, name)
+        return json.load(open(p, encoding='utf-8')) if os.path.isfile(p) else {}
+
+    # keywords (code-keyword.json: {keyword: [files]})
+    kw = load('code-keyword.json')
+    kw_rows = [(k, f) for k, files in kw.items() for f in files]
+    con.execute("DELETE FROM keywords")
+    if kw_rows:
+        _batch_insert(con, 'keywords', kw_rows)
+
+    # endpoints (code-api.json: {endpoint: controller_file})
+    api = load('code-api.json')
+    con.execute("DELETE FROM endpoints")
+    ep_rows = [(ep, f) for ep, f in api.items()]
+    if ep_rows:
+        _batch_insert(con, 'endpoints', ep_rows, ignore=True)
+
+    # prds (prd-index.json)
+    prds = load('prd-index.json')
+    con.execute("DELETE FROM prds")
+    prd_rows = [(f, info.get('title', ''),
+                 json.dumps(info.get('keywords', []), ensure_ascii=False),
+                 json.dumps(info.get('features', []), ensure_ascii=False),
+                 json.dumps(info.get('cn_terms', []), ensure_ascii=False))
+                for f, info in prds.items()]
+    if prd_rows:
+        _batch_insert(con, 'prds', prd_rows, ignore=True)
+
+    # wiki (wiki-index.json)
+    wiki = load('wiki-index.json')
+    con.execute("DELETE FROM wiki")
+    wiki_rows = []
+    for kw, entries in (wiki.get('index', {}) if isinstance(wiki, dict) else {}).items():
+        for e in (entries if isinstance(entries, list) else []):
+            wiki_rows.append((kw, e.get('project', ''), e.get('title', ''),
+                              e.get('md_path', ''), e.get('description', '')))
+    if wiki_rows:
+        _batch_insert(con, 'wiki', wiki_rows)
+
+    return len(kw_rows), len(ep_rows), len(prd_rows), len(wiki_rows)
+
+
+def import_ui_layer(con):
+    """导入UI层: pages/fields/modules → DuckDB 表。"""
+    INDEX = str(DATA_INDEX_DIR)
+    def load(name):
+        p = os.path.join(INDEX, name)
+        return json.load(open(p, encoding='utf-8')) if os.path.isfile(p) else {}
+
+    si = load('ui-style.json')
+
+    # pages (from ui-style projects.page_examples + page_types)
+    con.execute("DELETE FROM pages")
+    page_rows = []
+    for proj, pdata in si.get('projects', {}).items():
+        for ptype, examples in (pdata.get('page_examples') or {}).items():
+            for ex in examples:
+                if isinstance(ex, dict):
+                    page_rows.append((ex.get('file', ''), proj, ptype,
+                                      json.dumps(ex.get('components', []), ensure_ascii=False),
+                                      json.dumps(ex.get('table_columns', []), ensure_ascii=False),
+                                      json.dumps(ex.get('form_fields', []), ensure_ascii=False),
+                                      json.dumps(ex.get('layout', {}), ensure_ascii=False)))
+    if page_rows:
+        _batch_insert(con, 'pages', page_rows, ignore=True)
+
+    # fields (from ui-style field_map)
+    con.execute("DELETE FROM fields")
+    fm = si.get('field_map', {})
+    field_rows = [(k, '/'.join(info.get('titles', [])[:2]), info.get('count', 1),
+                   json.dumps(info.get('sample_files', [])[:3], ensure_ascii=False))
+                  for k, info in fm.items()]
+    if field_rows:
+        _batch_insert(con, 'fields', field_rows)
+
+    # modules (from ui-modules.json)
+    mi = load('ui-modules.json')
+    con.execute("DELETE FROM modules")
+    mod_rows = [(m['dir'], m['cn'], proj, m['path'])
+                for proj, mods in mi.get('projects', {}).items() for m in mods]
+    if mod_rows:
+        _batch_insert(con, 'modules', mod_rows)
+
+    # style_meta (layout_fingerprint + component counts)
+    con.execute("DELETE FROM style_meta")
+    for proj, pdata in si.get('projects', {}).items():
+        fp = pdata.get('layout_fingerprint', {})
+        if fp:
+            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'),
+                pdata.get('vue_files', 0),
+                json.dumps(si.get('common_components', {}), ensure_ascii=False),
+                json.dumps(si.get('form_components', {}), ensure_ascii=False),
+            ])
+
+    return len(page_rows), len(field_rows), len(mod_rows)
+
+
+def import_trace_layer(con):
+    """导入trace层: traces/api_functions → DuckDB 表。"""
+    INDEX = str(DATA_INDEX_DIR)
+    tc = json.load(open(os.path.join(INDEX, 'trace-chain.json'), encoding='utf-8')) \
+        if os.path.isfile(os.path.join(INDEX, 'trace-chain.json')) else {}
+
+    con.execute("DELETE FROM traces")
+    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 tc.get('traces', [])]
+    if trace_rows:
+        _batch_insert(con, 'traces', trace_rows)
+
+    con.execute("DELETE FROM api_functions")
+    fn_rows = [(fn, info.get('url', ''), info.get('verb', ''), info.get('file', ''))
+               for fn, info in tc.get('api_functions', {}).items()]
+    if fn_rows:
+        _batch_insert(con, 'api_functions', fn_rows, ignore=True)
+
+    return len(trace_rows), len(fn_rows)
+
+
+def import_test_layer(con):
+    """导入test层: tests → DuckDB 表。"""
+    INDEX = str(DATA_INDEX_DIR)
+    ta = json.load(open(os.path.join(INDEX, 'test-assertions.json'), encoding='utf-8')) \
+        if os.path.isfile(os.path.join(INDEX, 'test-assertions.json')) else {}
+
+    con.execute("DELETE FROM tests")
+    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 ta.get('tests', [])]
+    if test_rows:
+        _batch_insert(con, 'tests', test_rows)
+
+    return len(test_rows)
+
+
+def import_workflow_layer(con):
+    """导入workflow层 → DuckDB 表。"""
+    INDEX = str(DATA_INDEX_DIR)
+    wf = json.load(open(os.path.join(INDEX, 'workflow-index.json'), encoding='utf-8')) \
+        if os.path.isfile(os.path.join(INDEX, 'workflow-index.json')) else {}
+
+    con.execute("DELETE FROM workflows")
+    wf_rows = []
+    for mod, mwf in wf.get('workflows', {}).items():
+        for seq, step in enumerate(mwf.get('chain', [])):
+            for op in step.get('operations', []):
+                wf_rows.append((mod, step['state'], seq,
+                                op.get('button', ''), op.get('endpoint', '')))
+    if wf_rows:
+        _batch_insert(con, 'workflows', wf_rows)
+
+    return len(wf_rows)
+
+
+def import_all(con):
+    """一键导入全部JSON数据到DuckDB (替代所有JSON索引)。"""
+    init_schema(con)
+    # 实体-关系层 (已有)
+    ent_n, edge_n = bulk_import_from_json(con)
+    # 搜索层
+    kw_n, ep_n, prd_n, wiki_n = import_search_layer(con)
+    # UI层
+    page_n, field_n, mod_n = import_ui_layer(con)
+    # trace层
+    trace_n, fn_n = import_trace_layer(con)
+    # test层
+    test_n = import_test_layer(con)
+    # workflow层
+    wf_n = import_workflow_layer(con)
+
+    return {
+        'entities': ent_n, 'edges': edge_n,
+        'keywords': kw_n, 'endpoints': ep_n, 'prds': prd_n, 'wiki': wiki_n,
+        'pages': page_n, 'fields': field_n, 'modules': mod_n,
+        'traces': trace_n, 'api_functions': fn_n,
+        'tests': test_n, 'workflows': wf_n,
+    }
+
+
+def get_stats(con):
+    """Get database statistics."""
+    ents = con.execute("SELECT COUNT(*) FROM entities").fetchone()[0]
+    aliases = con.execute("SELECT COUNT(*) FROM aliases").fetchone()[0]
+    edges = con.execute("SELECT COUNT(*) FROM edges").fetchone()[0]
+    by_type = con.execute(
+        "SELECT type, COUNT(*) FROM entities GROUP BY type ORDER BY COUNT(*) DESC"
+    ).fetchall()
+    return {
+        'entities': ents,
+        'aliases': aliases,
+        'edges': edges,
+        'by_type': dict(by_type),
+    }
+
+
+if __name__ == '__main__':
+    con = get_db()
+    print('Importing ALL JSON indexes to DuckDB...')
+    stats = import_all(con)
+    con.close()
+    print()
+    print('=== DuckDB Knowledge Graph (unified) ===')
+    for k, v in stats.items():
+        print('  %-16s: %d' % (k, v))
+    print('  file: %s (%.1f KB)' % (DB_PATH, os.path.getsize(DB_PATH) / 1024))
+    con.close()