autosnippet 3.3.0 → 3.3.3

package/dist/lib/service/panorama/LayerInferrer.js

@@ -0,0 +1,182 @@
+/**
+ * LayerInferrer — 拓扑排序层级推断
+ *
+ * 基于模块依赖图，通过去环 + 拓扑排序 + 最长路径法推断架构层级 (L0-Ln)。
+ * 底层 (L0) = Foundation/Core，顶层 = App/UI。
+ *
+ * @module LayerInferrer
+ */
+/* ═══ Constants ═══════════════════════════════════════════ */
+/** 层级命名启发式 — 按优先级排列，匹配模块名（边界安全） */
+const LAYER_NAME_HINTS = [
+    { pattern: /^(foundation|core|base|shared|common)$/i, name: 'Foundation', bias: -2 },
+    { pattern: /foundation/i, name: 'Foundation', bias: -2 },
+    { pattern: /^(model|entity|dto)$/i, name: 'Model', bias: -1 },
+    { pattern: /service|repository|manager|provider|store/i, name: 'Service', bias: 0 },
+    { pattern: /network|api|http/i, name: 'Networking', bias: 0 },
+    { pattern: /(?:^ui$|^ui[A-Z]|view|screen|component|widget)/i, name: 'UI', bias: 1 },
+    { pattern: /router|coordinator|navigation/i, name: 'Routing', bias: 1 },
+    { pattern: /^(app|main|launch|entry)$/i, name: 'Application', bias: 2 },
+    { pattern: /test|spec|mock/i, name: 'Test', bias: 3 },
+];
+/* ═══ LayerInferrer Class ═════════════════════════════════ */
+export class LayerInferrer {
+    /**
+     * 从模块依赖边推断架构层级
+     * @param edges - 模块间依赖边 (from depends_on/calls/data_flow to)
+     * @param modules - 所有模块名
+     * @param cycles - 已检测到的循环依赖
+     */
+    infer(edges, modules, cycles) {
+        // 1. 建图 (邻接表: from → to[])
+        const adjacency = new Map();
+        const reverseAdj = new Map();
+        const allModules = new Set(modules);
+        for (const mod of allModules) {
+            adjacency.set(mod, new Set());
+            reverseAdj.set(mod, new Set());
+        }
+        // 收集环中的节点
+        const cycleEdges = new Set();
+        for (const c of cycles) {
+            for (let i = 0; i < c.cycle.length; i++) {
+                const from = c.cycle[i];
+                const to = c.cycle[(i + 1) % c.cycle.length];
+                cycleEdges.add(`${from}→${to}`);
+            }
+        }
+        // 2. 添加边 (跳过环边)
+        const violations = [];
+        for (const edge of edges) {
+            if (!allModules.has(edge.from) || !allModules.has(edge.to) || edge.from === edge.to) {
+                continue;
+            }
+            const edgeKey = `${edge.from}→${edge.to}`;
+            if (cycleEdges.has(edgeKey)) {
+                // 环边作为违规记录，不加入 DAG
+                continue;
+            }
+            adjacency.get(edge.from).add(edge.to);
+            reverseAdj.get(edge.to).add(edge.from);
+        }
+        // 3. 拓扑排序 (Kahn's algorithm)
+        const inDegree = new Map();
+        for (const mod of allModules) {
+            inDegree.set(mod, reverseAdj.get(mod)?.size ?? 0);
+        }
+        const queue = [];
+        for (const [mod, deg] of inDegree) {
+            if (deg === 0) {
+                queue.push(mod);
+            }
+        }
+        const order = [];
+        while (queue.length > 0) {
+            const node = queue.shift();
+            order.push(node);
+            for (const neighbor of adjacency.get(node) ?? []) {
+                const newDeg = (inDegree.get(neighbor) ?? 1) - 1;
+                inDegree.set(neighbor, newDeg);
+                if (newDeg === 0) {
+                    queue.push(neighbor);
+                }
+            }
+        }
+        // 未排入的节点 (仍在环中) 追加到末尾
+        for (const mod of allModules) {
+            if (!order.includes(mod)) {
+                order.push(mod);
+            }
+        }
+        // 4. 分配层级: 最长路径法
+        // A 依赖 B → A 的 level ≥ B 的 level + 1
+        // reverseAdj: "B 被 A 依赖" → predecessors 是 reverseAdj(node) = {A}
+        // 但我们要的是 "A 依赖 B" → A 的 predecessors = adjacency(A) 出度目标的 level
+        // 换言之: level(A) = max(level(dep) for dep in adjacency(A)) + 1
+        // 底层 (无出度) = L0
+        const levels = new Map();
+        // 反向遍历: 从源头 (无出度) 开始
+        const reverseOrder = [...order].reverse();
+        for (const node of reverseOrder) {
+            const deps = adjacency.get(node) ?? new Set();
+            if (deps.size === 0) {
+                levels.set(node, 0);
+            }
+            else {
+                let maxDepLevel = 0;
+                for (const dep of deps) {
+                    maxDepLevel = Math.max(maxDepLevel, levels.get(dep) ?? 0);
+                }
+                levels.set(node, maxDepLevel + 1);
+            }
+        }
+        // 5. 聚合: 同层模块分组
+        const layerGroups = new Map();
+        for (const [mod, level] of levels) {
+            if (!layerGroups.has(level)) {
+                layerGroups.set(level, []);
+            }
+            layerGroups.get(level).push(mod);
+        }
+        // 按 level 排序
+        const sortedLevels = [...layerGroups.entries()].sort((a, b) => a[0] - b[0]);
+        // 6. 推断层级名
+        const levelEntries = sortedLevels.map(([level, mods]) => ({
+            level,
+            name: this.#inferLayerName(mods, level, sortedLevels.length),
+            modules: mods.sort(),
+        }));
+        // 7. 检测层级违规 (高层 → 低层调用正常；低层 → 高层调用为违规)
+        for (const edge of edges) {
+            const fromLevel = levels.get(edge.from);
+            const toLevel = levels.get(edge.to);
+            if (fromLevel !== undefined && toLevel !== undefined && fromLevel < toLevel) {
+                violations.push({
+                    from: edge.from,
+                    to: edge.to,
+                    fromLayer: fromLevel,
+                    toLayer: toLevel,
+                    relation: edge.relation,
+                });
+            }
+        }
+        return { levels: levelEntries, violations };
+    }
+    /* ─── Layer Naming ──────────────────────────────── */
+    #inferLayerName(modules, level, totalLevels) {
+        // 投票: 每个匹配的 hint 累加权重，取最高分的名称
+        const votes = new Map();
+        for (const mod of modules) {
+            for (const hint of LAYER_NAME_HINTS) {
+                if (hint.pattern.test(mod)) {
+                    votes.set(hint.name, (votes.get(hint.name) ?? 0) + 1);
+                    break; // 每个模块只投一票（匹配第一个 hint）
+                }
+            }
+        }
+        if (votes.size > 0) {
+            // 选最高票
+            let best = '';
+            let bestCount = 0;
+            for (const [name, count] of votes) {
+                if (count > bestCount) {
+                    best = name;
+                    bestCount = count;
+                }
+            }
+            return best;
+        }
+        // 基于层级位置推断
+        const position = totalLevels > 1 ? level / (totalLevels - 1) : 0.5;
+        if (position <= 0.2) {
+            return 'Foundation';
+        }
+        if (position <= 0.5) {
+            return 'Service';
+        }
+        if (position <= 0.8) {
+            return 'Feature';
+        }
+        return 'Application';
+    }
+}

package/dist/lib/service/panorama/ModuleDiscoverer.d.ts

@@ -0,0 +1,24 @@
+/**
+ * ModuleDiscoverer — 模块发现与文件归属
+ *
+ * 从 DB（code_entities / knowledge_edges）读取已扫描的模块数据。
+ * 前提：PanoramaScanner.ensureData() 保证 DB 中已有结构数据。
+ *
+ *   策略 1:   code_entities entity_type='module' + is_part_of 边 → 完整数据
+ *   策略 1.5: module 实体存在但无 is_part_of 边 → 文件系统 + DB 路径补全
+ *
+ * 若 DB 中无 module 实体，返回空数组（由 PanoramaScanner 负责兜底扫描）。
+ *
+ * @module ModuleDiscoverer
+ */
+import type { CeDbLike } from './PanoramaTypes.js';
+import type { ModuleCandidate } from './RoleRefiner.js';
+export declare class ModuleDiscoverer {
+    #private;
+    constructor(db: CeDbLike, projectRoot: string);
+    /**
+     * 从 DB 中读取已扫描的模块数据。
+     * 若无 module 实体，返回空数组（让调用侧决定是否重新扫描）。
+     */
+    discover(): ModuleCandidate[];
+}

package/dist/lib/service/panorama/ModuleDiscoverer.js

@@ -0,0 +1,185 @@
+/**
+ * ModuleDiscoverer — 模块发现与文件归属
+ *
+ * 从 DB（code_entities / knowledge_edges）读取已扫描的模块数据。
+ * 前提：PanoramaScanner.ensureData() 保证 DB 中已有结构数据。
+ *
+ *   策略 1:   code_entities entity_type='module' + is_part_of 边 → 完整数据
+ *   策略 1.5: module 实体存在但无 is_part_of 边 → 文件系统 + DB 路径补全
+ *
+ * 若 DB 中无 module 实体，返回空数组（由 PanoramaScanner 负责兜底扫描）。
+ *
+ * @module ModuleDiscoverer
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { inferTargetRole } from '../../external/mcp/handlers/TargetClassifier.js';
+/* ═══ Constants ═══════════════════════════════════════════ */
+const SOURCE_EXTS = new Set([
+    '.swift',
+    '.ts',
+    '.tsx',
+    '.js',
+    '.jsx',
+    '.m',
+    '.mm',
+    '.h',
+    '.c',
+    '.cpp',
+    '.kt',
+    '.java',
+    '.py',
+    '.rb',
+    '.go',
+    '.rs',
+]);
+const SKIP_DIRS = new Set([
+    '.git',
+    '.build',
+    '.autosnippet',
+    'node_modules',
+    'build',
+    'Pods',
+    'DerivedData',
+    '.swiftpm',
+    '__pycache__',
+    'dist',
+]);
+/* ═══ ModuleDiscoverer Class ══════════════════════════════ */
+export class ModuleDiscoverer {
+    #db;
+    #projectRoot;
+    constructor(db, projectRoot) {
+        this.#db = db;
+        this.#projectRoot = projectRoot;
+    }
+    /**
+     * 从 DB 中读取已扫描的模块数据。
+     * 若无 module 实体，返回空数组（让调用侧决定是否重新扫描）。
+     */
+    discover() {
+        // 从 code_entities 查 entity_type = 'module'
+        const moduleEntities = this.#db
+            .prepare(`SELECT DISTINCT entity_id, name FROM code_entities
+         WHERE entity_type = 'module' AND project_root = ?`)
+            .all(this.#projectRoot);
+        if (moduleEntities.length === 0) {
+            return [];
+        }
+        // 收集 is_part_of 边关联的文件
+        const moduleFiles = new Map();
+        for (const me of moduleEntities) {
+            const moduleName = me.entity_id;
+            moduleFiles.set(moduleName, new Set());
+            const parts = this.#db
+                .prepare(`SELECT ke.from_id FROM knowledge_edges ke
+           WHERE ke.to_id = ? AND ke.to_type = 'module' AND ke.relation = 'is_part_of'`)
+                .all(moduleName);
+            for (const part of parts) {
+                const entity = this.#db
+                    .prepare(`SELECT file_path FROM code_entities
+             WHERE entity_id = ? AND project_root = ? LIMIT 1`)
+                    .get(part.from_id, this.#projectRoot);
+                if (entity?.file_path) {
+                    moduleFiles.get(moduleName).add(entity.file_path);
+                }
+            }
+        }
+        // 策略 1.5: module 实体有但文件为空（SPM 只建了模块节点）
+        const totalFileCount = [...moduleFiles.values()].reduce((sum, s) => sum + s.size, 0);
+        if (totalFileCount === 0) {
+            this.#enrichModuleFiles(moduleFiles);
+        }
+        return [...moduleFiles.entries()].map(([name, files]) => ({
+            name,
+            inferredRole: inferTargetRole(name),
+            files: [...files],
+        }));
+    }
+    /* ─── 策略 1.5: 模块文件充填 ───────────────────── */
+    /**
+     * 为已知模块名填充文件路径：
+     *   a. 文件系统扫描（递归 4 层找模块同名目录）
+     *   b. DB code_entities.file_path 路径段匹配
+     */
+    #enrichModuleFiles(moduleFiles) {
+        const moduleNames = [...moduleFiles.keys()];
+        // a. 文件系统扫描
+        for (const modName of moduleNames) {
+            const dir = this.#findModuleDir(this.#projectRoot, modName, 4);
+            if (dir) {
+                for (const f of this.#collectSourceFiles(dir)) {
+                    moduleFiles.get(modName).add(f);
+                }
+            }
+        }
+        // b. 如果 FS 扫描仍为空 → DB 路径匹配
+        const totalAfterFs = [...moduleFiles.values()].reduce((sum, s) => sum + s.size, 0);
+        if (totalAfterFs > 0) {
+            return;
+        }
+        const allFiles = this.#db
+            .prepare(`SELECT DISTINCT file_path FROM code_entities
+         WHERE project_root = ? AND file_path IS NOT NULL AND entity_type != 'module'`)
+            .all(this.#projectRoot);
+        // 长名优先，避免短名误匹配
+        const sorted = [...moduleNames].sort((a, b) => b.length - a.length);
+        for (const row of allFiles) {
+            const filePath = row.file_path;
+            if (!filePath) {
+                continue;
+            }
+            for (const modName of sorted) {
+                if (filePath.includes(`/${modName}/`) || filePath.startsWith(`${modName}/`)) {
+                    moduleFiles.get(modName).add(filePath);
+                    break; // 一个文件只属于一个模块
+                }
+            }
+        }
+    }
+    /* ─── 文件系统辅助 ────────────────────────────── */
+    #findModuleDir(rootDir, targetName, maxDepth) {
+        if (maxDepth <= 0) {
+            return null;
+        }
+        try {
+            const entries = fs.readdirSync(rootDir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (!entry.isDirectory() || SKIP_DIRS.has(entry.name) || entry.name.startsWith('.')) {
+                    continue;
+                }
+                const fullPath = path.join(rootDir, entry.name);
+                if (entry.name === targetName) {
+                    return fullPath;
+                }
+                const found = this.#findModuleDir(fullPath, targetName, maxDepth - 1);
+                if (found) {
+                    return found;
+                }
+            }
+        }
+        catch {
+            // 无法读取目录
+        }
+        return null;
+    }
+    #collectSourceFiles(dir) {
+        const files = [];
+        try {
+            const entries = fs.readdirSync(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = path.join(dir, entry.name);
+                if (entry.isDirectory() && !entry.name.startsWith('.') && !SKIP_DIRS.has(entry.name)) {
+                    files.push(...this.#collectSourceFiles(fullPath));
+                }
+                else if (entry.isFile() && SOURCE_EXTS.has(path.extname(entry.name).toLowerCase())) {
+                    files.push(fullPath);
+                }
+            }
+        }
+        catch {
+            // 无法读取
+        }
+        return files;
+    }
+}

package/dist/lib/service/panorama/PanoramaAggregator.d.ts

@@ -0,0 +1,29 @@
+/**
+ * PanoramaAggregator — 全景数据汇总
+ *
+ * 编排 RoleRefiner → CouplingAnalyzer → LayerInferrer，
+ * 汇总为统一的 PanoramaResult，附加知识覆盖率和空白区检测。
+ *
+ * @module PanoramaAggregator
+ */
+import type { CouplingAnalyzer } from './CouplingAnalyzer.js';
+import { DimensionAnalyzer } from './DimensionAnalyzer.js';
+import type { LayerInferrer } from './LayerInferrer.js';
+import type { CeDbLike, PanoramaResult } from './PanoramaTypes.js';
+import type { ModuleCandidate, RoleRefiner } from './RoleRefiner.js';
+export interface PanoramaAggregatorOptions {
+    roleRefiner: RoleRefiner;
+    couplingAnalyzer: CouplingAnalyzer;
+    layerInferrer: LayerInferrer;
+    db: CeDbLike;
+    projectRoot: string;
+    dimensionAnalyzer?: DimensionAnalyzer;
+}
+export declare class PanoramaAggregator {
+    #private;
+    constructor(opts: PanoramaAggregatorOptions);
+    /**
+     * 计算完整全景数据
+     */
+    compute(moduleCandidates: ModuleCandidate[]): PanoramaResult;
+}

package/dist/lib/service/panorama/PanoramaAggregator.js

@@ -0,0 +1,228 @@
+/**
+ * PanoramaAggregator — 全景数据汇总
+ *
+ * 编排 RoleRefiner → CouplingAnalyzer → LayerInferrer，
+ * 汇总为统一的 PanoramaResult，附加知识覆盖率和空白区检测。
+ *
+ * @module PanoramaAggregator
+ */
+var _a;
+import { DimensionAnalyzer } from './DimensionAnalyzer.js';
+/* ═══ PanoramaAggregator Class ════════════════════════════ */
+export class PanoramaAggregator {
+    #roleRefiner;
+    #couplingAnalyzer;
+    #layerInferrer;
+    #db;
+    #projectRoot;
+    #dimensionAnalyzer;
+    constructor(opts) {
+        this.#roleRefiner = opts.roleRefiner;
+        this.#couplingAnalyzer = opts.couplingAnalyzer;
+        this.#layerInferrer = opts.layerInferrer;
+        this.#db = opts.db;
+        this.#projectRoot = opts.projectRoot;
+        this.#dimensionAnalyzer = opts.dimensionAnalyzer ?? new DimensionAnalyzer(opts.db);
+    }
+    /**
+     * 计算完整全景数据
+     */
+    compute(moduleCandidates) {
+        // 1. RoleRefiner: 精化角色
+        const refinedRoles = this.#roleRefiner.refineAll(moduleCandidates);
+        // 2. 构建模块-文件映射
+        const moduleFiles = new Map();
+        for (const mc of moduleCandidates) {
+            moduleFiles.set(mc.name, mc.files);
+        }
+        // 3. CouplingAnalyzer: 耦合分析
+        const coupling = this.#couplingAnalyzer.analyze(moduleFiles);
+        // 4. LayerInferrer: 层级推断
+        const modules = moduleCandidates.map((m) => m.name);
+        const layers = this.#layerInferrer.infer(coupling.edges, modules, coupling.cycles);
+        // 5. 构建层级映射 (模块名 → 层级号)
+        const moduleLayerMap = new Map();
+        for (const level of layers.levels) {
+            for (const mod of level.modules) {
+                moduleLayerMap.set(mod, level.level);
+            }
+        }
+        // 6. 项目级 recipe 总数（recipe scope 通常为 universal，不做模块强关联）
+        const projectRecipeCount = this.#getProjectRecipeCount();
+        // 7. 计算总文件数
+        let totalFiles = 0;
+        for (const mc of moduleCandidates) {
+            totalFiles += mc.files.length;
+        }
+        // 8. 汇总 PanoramaModule
+        // 模块 recipeCount 按文件数等比分配项目级 recipe（反映覆盖贡献度）
+        const panoramaModules = new Map();
+        for (const mc of moduleCandidates) {
+            const refined = refinedRoles.get(mc.name);
+            const metrics = coupling.metrics.get(mc.name);
+            const recipeCount = totalFiles > 0 ? Math.round((projectRecipeCount * mc.files.length) / totalFiles) : 0;
+            panoramaModules.set(mc.name, {
+                name: mc.name,
+                inferredRole: mc.inferredRole,
+                refinedRole: refined?.refinedRole ?? mc.inferredRole,
+                roleConfidence: refined?.confidence ?? 0,
+                layer: moduleLayerMap.get(mc.name) ?? 0,
+                fanIn: metrics?.fanIn ?? 0,
+                fanOut: metrics?.fanOut ?? 0,
+                files: mc.files,
+                fileCount: mc.files.length,
+                recipeCount,
+                coverageRatio: mc.files.length > 0 ? recipeCount / mc.files.length : 0,
+            });
+        }
+        // 8.5 基于模块角色重命名层级（比模块名 pattern 更准确）
+        this.#renameLayersByRole(layers, panoramaModules);
+        // 9. 多维度知识健康分析 (替代旧的基于模块文件数的覆盖率模型)
+        const moduleRoles = moduleCandidates.map((m) => {
+            const pm = panoramaModules.get(m.name);
+            return pm?.refinedRole ?? m.inferredRole;
+        });
+        const { radar, gaps } = this.#dimensionAnalyzer.analyze(moduleRoles);
+        // 10. 调用流概要
+        const callFlowSummary = this.#computeCallFlowSummary();
+        return {
+            modules: panoramaModules,
+            layers,
+            cycles: coupling.cycles,
+            gaps,
+            healthRadar: radar,
+            callFlowSummary,
+            projectRecipeCount,
+            computedAt: Date.now(),
+        };
+    }
+    /* ─── Project Recipe Count ──────────────────────── */
+    #getProjectRecipeCount() {
+        try {
+            const row = this.#db
+                .prepare(`SELECT COUNT(*) as cnt FROM knowledge_entries WHERE lifecycle IN ('active', 'pending')`)
+                .get();
+            return Number(row?.cnt ?? 0);
+        }
+        catch {
+            return 0;
+        }
+    }
+    /* ─── Layer Naming (role-based) ─────────────────── */
+    /** 角色 → 层级名映射 */
+    static #ROLE_TO_LAYER = {
+        core: 'Foundation',
+        foundation: 'Foundation',
+        model: 'Model',
+        service: 'Service',
+        networking: 'Infrastructure',
+        storage: 'Infrastructure',
+        ui: 'UI',
+        feature: 'Feature',
+        config: 'Configuration',
+        test: 'Test',
+        app: 'Application',
+    };
+    /**
+     * 基于模块 refinedRole 投票重命名层级
+     * 比模块名 pattern 匹配更准确（避免 BDUIKit 被误匹配为 Foundation 等问题）
+     */
+    #renameLayersByRole(layers, panoramaModules) {
+        const usedNames = new Set();
+        const maxLevel = Math.max(...layers.levels.map((l) => l.level), 0);
+        for (const level of layers.levels) {
+            // 只统计有文件的模块（排除 0 文件的第三方依赖干扰）
+            const roleVotes = new Map();
+            for (const modName of level.modules) {
+                const mod = panoramaModules.get(modName);
+                if (mod && mod.fileCount > 0) {
+                    const role = mod.refinedRole || mod.inferredRole;
+                    roleVotes.set(role, (roleVotes.get(role) ?? 0) + 1);
+                }
+            }
+            let layerName;
+            if (roleVotes.size === 0) {
+                // 全部是 0 文件模块 → 用位置推断
+                layerName =
+                    level.level === 0 ? 'Foundation' : level.level === maxLevel ? 'Application' : 'Feature';
+            }
+            else {
+                // 选最高票角色
+                let bestRole = '';
+                let bestCount = 0;
+                for (const [role, count] of roleVotes) {
+                    if (count > bestCount) {
+                        bestRole = role;
+                        bestCount = count;
+                    }
+                }
+                layerName = _a.#ROLE_TO_LAYER[bestRole] ?? 'Feature';
+                // 位置修正：最底层优先 Foundation，最顶层优先 Application
+                if (level.level === 0 && roleVotes.has('core')) {
+                    layerName = 'Foundation';
+                }
+                else if (level.level === maxLevel && layers.levels.length > 1) {
+                    layerName = 'Application';
+                }
+            }
+            // 去重：已使用的名称追加 level 号
+            if (usedNames.has(layerName)) {
+                layerName = `${layerName} ${level.level}`;
+            }
+            usedNames.add(layerName);
+            level.name = layerName;
+        }
+    }
+    /* ─── Call Flow Summary ─────────────────────────── */
+    #computeCallFlowSummary() {
+        // 最频繁被调用的方法
+        const topCalled = this.#db
+            .prepare(`SELECT to_id, COUNT(*) as call_count
+         FROM knowledge_edges
+         WHERE relation = 'calls'
+         GROUP BY to_id
+         ORDER BY call_count DESC
+         LIMIT 10`)
+            .all();
+        // 入口点: 只有出度没有入度的方法
+        const entryPoints = this.#db
+            .prepare(`SELECT DISTINCT ke.from_id
+         FROM knowledge_edges ke
+         WHERE ke.relation = 'calls'
+         AND ke.from_id NOT IN (
+           SELECT to_id FROM knowledge_edges WHERE relation = 'calls'
+         )
+         LIMIT 20`)
+            .all();
+        // 数据生产者: data_flow outFlow >> inFlow
+        const dataProducers = this.#db
+            .prepare(`SELECT from_id, COUNT(*) as out_cnt
+         FROM knowledge_edges
+         WHERE relation = 'data_flow'
+         GROUP BY from_id
+         HAVING out_cnt > 3
+         ORDER BY out_cnt DESC
+         LIMIT 10`)
+            .all();
+        // 数据消费者: data_flow inFlow >> outFlow
+        const dataConsumers = this.#db
+            .prepare(`SELECT to_id, COUNT(*) as in_cnt
+         FROM knowledge_edges
+         WHERE relation = 'data_flow'
+         GROUP BY to_id
+         HAVING in_cnt > 3
+         ORDER BY in_cnt DESC
+         LIMIT 10`)
+            .all();
+        return {
+            topCalledMethods: topCalled.map((r) => ({
+                id: r.to_id,
+                callCount: Number(r.call_count),
+            })),
+            entryPoints: entryPoints.map((r) => r.from_id),
+            dataProducers: dataProducers.map((r) => r.from_id),
+            dataConsumers: dataConsumers.map((r) => r.to_id),
+        };
+    }
+}
+_a = PanoramaAggregator;