autosnippet 3.3.6 → 3.3.8

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

@@ -13,96 +13,141 @@
  */
 import fs from 'node:fs';
 import path from 'node:path';
+import { LanguageProfiles } from '#shared/LanguageProfiles.js';
 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',
-]);
+// All language-specific constants are now in LanguageProfiles.
+// These aliases delegate to the unified registry for backward compat:
+const SOURCE_EXTS = LanguageProfiles.sourceExts;
+const SKIP_DIRS = LanguageProfiles.skipDirs;
+const HOST_SKIP_SUFFIXES = LanguageProfiles.artifactSuffixes;
+const HOST_VENDOR_DIRS = LanguageProfiles.vendorDirs;
 /* ═══ ModuleDiscoverer Class ══════════════════════════════ */
 export class ModuleDiscoverer {
-    #db;
+    #entityRepo;
+    #edgeRepo;
     #projectRoot;
-    constructor(db, projectRoot) {
-        this.#db = db;
+    constructor(entityRepo, edgeRepo, projectRoot) {
+        this.#entityRepo = entityRepo;
+        this.#edgeRepo = edgeRepo;
         this.#projectRoot = projectRoot;
     }
     /**
      * 从 DB 中读取已扫描的模块数据。
-     * 若无 module 实体，返回空数组（让调用侧决定是否重新扫描）。
+     * 若无 module 实体（含 host），返回空数组（让调用侧决定是否重新扫描）。
      */
-    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) {
+    async discover() {
+        // 从 code_entities 查 entity_type = 'module'（排除 external/host 节点）
+        const moduleEntities = await this.#entityRepo.findLocalModules(this.#projectRoot);
+        // 检查是否存在 host 模块（用于后续分解）
+        const hasHostModules = await this.#hasHostModules();
+        if (moduleEntities.length === 0 && !hasHostModules) {
             return [];
         }
         // 收集 is_part_of 边关联的文件
         const moduleFiles = new Map();
         for (const me of moduleEntities) {
-            const moduleName = me.entity_id;
+            const moduleName = me.entityId;
             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);
+            const parts = await this.#edgeRepo.findIncomingByRelation(moduleName, 'is_part_of');
             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);
+                const entity = await this.#entityRepo.findByEntityIdOnly(part.fromId, this.#projectRoot);
+                if (entity?.filePath) {
+                    moduleFiles.get(moduleName).add(entity.filePath);
                 }
             }
         }
         // 策略 1.5: module 实体有但文件为空（SPM 只建了模块节点）
         const totalFileCount = [...moduleFiles.values()].reduce((sum, s) => sum + s.size, 0);
         if (totalFileCount === 0) {
-            this.#enrichModuleFiles(moduleFiles);
+            await this.#enrichModuleFiles(moduleFiles);
         }
-        return [...moduleFiles.entries()].map(([name, files]) => ({
+        // 读取模块 metadata 中的 configLayer 信息
+        const moduleLayerMap = await this.#readModuleLayerMetadata(moduleEntities);
+        const regularModules = [...moduleFiles.entries()].map(([name, files]) => ({
             name,
             inferredRole: inferTargetRole(name),
             files: [...files],
+            configLayer: moduleLayerMap.get(name),
         }));
+        // 策略 2: 分解 host 模块（主工程目录）为子模块
+        const hostSubModules = await this.#decomposeHostModules(moduleFiles);
+        return [...regularModules, ...hostSubModules];
+    }
+    /**
+     * 读取 config layers 元数据（如果存在）
+     * @returns 从 `__config_layers__` 实体中恢复的层级定义
+     */
+    async readConfigLayers() {
+        try {
+            const entity = await this.#entityRepo.findByEntityIdOnly('__config_layers__', this.#projectRoot);
+            if (!entity?.metadata) {
+                return null;
+            }
+            const meta = entity.metadata;
+            if (Array.isArray(meta.layers) && meta.layers.length > 0) {
+                const layers = meta.layers;
+                // 当存在 host 模块时，注入 Application 层（位于所有配置层之上）
+                if (await this.#hasHostModules()) {
+                    const minOrder = Math.min(...layers.map((l) => l.order));
+                    const hasAppLayer = layers.some((l) => l.name.toLowerCase() === 'application' || l.name.toLowerCase() === 'app');
+                    if (!hasAppLayer) {
+                        layers.unshift({
+                            name: 'Application',
+                            order: minOrder - 1,
+                            accessibleLayers: layers.map((l) => l.name),
+                        });
+                    }
+                }
+                return layers;
+            }
+        }
+        catch {
+            /* skip parse error */
+        }
+        return null;
     }
     /* ─── 策略 1.5: 模块文件充填 ───────────────────── */
+    /**
+     * 从 code_entities metadata 中读取每个模块的 layer 信息
+     */
+    async #readModuleLayerMetadata(moduleEntities) {
+        const result = new Map();
+        for (const me of moduleEntities) {
+            const moduleName = me.entityId;
+            try {
+                const entity = await this.#entityRepo.findByEntityIdOnly(moduleName, this.#projectRoot);
+                if (entity?.metadata) {
+                    const meta = entity.metadata;
+                    if (meta.layer && typeof meta.layer === 'string') {
+                        result.set(moduleName, meta.layer);
+                    }
+                }
+            }
+            catch {
+                /* skip parse error */
+            }
+        }
+        return result;
+    }
+    /**
+     * 检查 DB 中是否存在 nodeType='host' 的模块实体
+     */
+    async #hasHostModules() {
+        try {
+            const cnt = await this.#entityRepo.countModulesByNodeType(this.#projectRoot, 'host');
+            return cnt > 0;
+        }
+        catch {
+            return false;
+        }
+    }
     /**
      * 为已知模块名填充文件路径：
      *   a. 文件系统扫描（递归 4 层找模块同名目录）
      *   b. DB code_entities.file_path 路径段匹配
      */
-    #enrichModuleFiles(moduleFiles) {
+    async #enrichModuleFiles(moduleFiles) {
         const moduleNames = [...moduleFiles.keys()];
         // a. 文件系统扫描
         for (const modName of moduleNames) {
@@ -118,14 +163,10 @@ export class ModuleDiscoverer {
         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 allFiles = await this.#entityRepo.findDistinctFilePaths(this.#projectRoot);
         // 长名优先，避免短名误匹配
         const sorted = [...moduleNames].sort((a, b) => b.length - a.length);
-        for (const row of allFiles) {
-            const filePath = row.file_path;
+        for (const filePath of allFiles) {
             if (!filePath) {
                 continue;
             }
@@ -182,4 +223,111 @@ export class ModuleDiscoverer {
         }
         return files;
     }
+    /* ─── 策略 2: Host 模块分解 ────────────────────── */
+    /**
+     * 分解 host 类型模块（主工程目录）为子模块。
+     *
+     * 适用场景：混合项目（如 Boxfile/EasyBox + 主工程未模块化代码）中，
+     * host 模块包含大量按文件夹组织但未声明为独立模块的业务代码。
+     *
+     * 策略：
+     *   1. 从 DB 查询 nodeType='host' 的模块实体
+     *   2. 扫描 host 目录的子文件夹，每个含 ≥2 个源文件的文件夹视为隐式子模块
+     *   3. 排除已被现有模块覆盖的文件（避免重复计数）
+     *   4. 跳过资源目录（.xcassets, .bundle, .lproj 等）和第三方代码目录
+     *   5. 当项目有 configLayers 时，为子模块分配 Application 层（host 在所有声明层之上）
+     */
+    async #decomposeHostModules(existingModuleFiles) {
+        const hostEntities = await this.#entityRepo.findModulesByNodeTypes(this.#projectRoot, ['host']);
+        if (hostEntities.length === 0) {
+            return [];
+        }
+        // 检查是否有 configLayers — 决定是否分配 Application 层
+        const hasConfigLayers = (await this.readConfigLayers()) !== null;
+        // 已有模块名 + 所有已归属文件（用于去重）
+        const existingNames = new Set(existingModuleFiles.keys());
+        const allExistingFiles = new Set();
+        for (const files of existingModuleFiles.values()) {
+            for (const f of files) {
+                allExistingFiles.add(f);
+            }
+        }
+        const result = [];
+        for (const host of hostEntities) {
+            let meta = {};
+            try {
+                meta = host.metadata ?? {};
+            }
+            catch {
+                /* skip parse error */
+            }
+            const hostName = host.name;
+            const hostDir = meta.fullPath || path.join(this.#projectRoot, hostName);
+            if (!this.#isDirectory(hostDir)) {
+                continue;
+            }
+            let entries;
+            try {
+                entries = fs.readdirSync(hostDir, { withFileTypes: true });
+            }
+            catch {
+                continue;
+            }
+            const rootFiles = [];
+            for (const entry of entries) {
+                if (entry.isDirectory()) {
+                    // 跳过隐藏目录、构建产物、资源目录
+                    if (SKIP_DIRS.has(entry.name) || entry.name.startsWith('.')) {
+                        continue;
+                    }
+                    if (HOST_SKIP_SUFFIXES.some((suffix) => entry.name.endsWith(suffix))) {
+                        continue;
+                    }
+                    // 跳过第三方/供应商代码目录
+                    if (HOST_VENDOR_DIRS.has(entry.name.toLowerCase())) {
+                        continue;
+                    }
+                    const dirPath = path.join(hostDir, entry.name);
+                    const files = this.#collectSourceFiles(dirPath).filter((f) => !allExistingFiles.has(f));
+                    if (files.length < 2) {
+                        continue;
+                    }
+                    // 名称冲突时加 host 前缀
+                    const moduleName = existingNames.has(entry.name)
+                        ? `${hostName}/${entry.name}`
+                        : entry.name;
+                    result.push({
+                        name: moduleName,
+                        inferredRole: inferTargetRole(entry.name),
+                        files,
+                        configLayer: hasConfigLayers ? 'Application' : undefined,
+                    });
+                }
+                else if (entry.isFile() && SOURCE_EXTS.has(path.extname(entry.name).toLowerCase())) {
+                    const fullPath = path.join(hostDir, entry.name);
+                    if (!allExistingFiles.has(fullPath)) {
+                        rootFiles.push(fullPath);
+                    }
+                }
+            }
+            // 主工程根级文件归入宿主模块本身
+            if (rootFiles.length > 0) {
+                result.push({
+                    name: hostName,
+                    inferredRole: 'app',
+                    files: rootFiles,
+                    configLayer: hasConfigLayers ? 'Application' : undefined,
+                });
+            }
+        }
+        return result;
+    }
+    #isDirectory(dirPath) {
+        try {
+            return fs.statSync(dirPath).isDirectory();
+        }
+        catch {
+            return false;
+        }
+    }
 }

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

@@ -6,16 +6,23 @@
  *
  * @module PanoramaAggregator
  */
+import type { BootstrapRepositoryImpl } from '../../repository/bootstrap/BootstrapRepository.js';
+import type { CodeEntityRepositoryImpl } from '../../repository/code/CodeEntityRepository.js';
+import type { KnowledgeEdgeRepositoryImpl } from '../../repository/knowledge/KnowledgeEdgeRepository.js';
+import type { KnowledgeRepositoryImpl } from '../../repository/knowledge/KnowledgeRepository.impl.js';
 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 { ConfigLayer, LayerInferrer } from './LayerInferrer.js';
+import type { PanoramaResult } from './PanoramaTypes.js';
 import type { ModuleCandidate, RoleRefiner } from './RoleRefiner.js';
 export interface PanoramaAggregatorOptions {
     roleRefiner: RoleRefiner;
     couplingAnalyzer: CouplingAnalyzer;
     layerInferrer: LayerInferrer;
-    db: CeDbLike;
+    bootstrapRepo: BootstrapRepositoryImpl;
+    entityRepo: CodeEntityRepositoryImpl;
+    edgeRepo: KnowledgeEdgeRepositoryImpl;
+    knowledgeRepo: KnowledgeRepositoryImpl;
     projectRoot: string;
     dimensionAnalyzer?: DimensionAnalyzer;
 }
@@ -24,6 +31,10 @@ export declare class PanoramaAggregator {
     constructor(opts: PanoramaAggregatorOptions);
     /**
      * 计算完整全景数据
+     * @param moduleCandidates 模块候选列表
+     * @param options.configLayers 来自配置文件的层级声明（如 Boxfile layer 定义）
      */
-    compute(moduleCandidates: ModuleCandidate[]): PanoramaResult;
+    compute(moduleCandidates: ModuleCandidate[], options?: {
+        configLayers?: ConfigLayer[] | null;
+    }): Promise<PanoramaResult>;
 }

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

@@ -8,38 +8,57 @@
  */
 var _a;
 import { DimensionAnalyzer } from './DimensionAnalyzer.js';
+import { profileTechStack } from './TechStackProfiler.js';
 /* ═══ PanoramaAggregator Class ════════════════════════════ */
 export class PanoramaAggregator {
     #roleRefiner;
     #couplingAnalyzer;
     #layerInferrer;
-    #db;
+    #entityRepo;
+    #edgeRepo;
+    #knowledgeRepo;
     #projectRoot;
     #dimensionAnalyzer;
     constructor(opts) {
         this.#roleRefiner = opts.roleRefiner;
         this.#couplingAnalyzer = opts.couplingAnalyzer;
         this.#layerInferrer = opts.layerInferrer;
-        this.#db = opts.db;
+        this.#entityRepo = opts.entityRepo;
+        this.#edgeRepo = opts.edgeRepo;
+        this.#knowledgeRepo = opts.knowledgeRepo;
         this.#projectRoot = opts.projectRoot;
-        this.#dimensionAnalyzer = opts.dimensionAnalyzer ?? new DimensionAnalyzer(opts.db);
+        this.#dimensionAnalyzer =
+            opts.dimensionAnalyzer ??
+                new DimensionAnalyzer(opts.bootstrapRepo, opts.entityRepo, opts.knowledgeRepo, opts.projectRoot);
     }
     /**
      * 计算完整全景数据
+     * @param moduleCandidates 模块候选列表
+     * @param options.configLayers 来自配置文件的层级声明（如 Boxfile layer 定义）
      */
-    compute(moduleCandidates) {
+    async compute(moduleCandidates, options) {
         // 1. RoleRefiner: 精化角色
-        const refinedRoles = this.#roleRefiner.refineAll(moduleCandidates);
+        const refinedRoles = await 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: 层级推断
+        // 3. CouplingAnalyzer: 耦合分析（含外部依赖 fan-in）
+        const externalModules = await this.#collectExternalModules();
+        const coupling = await this.#couplingAnalyzer.analyze(moduleFiles, externalModules);
+        // 4. LayerInferrer: 层级推断（优先使用配置层级）
         const modules = moduleCandidates.map((m) => m.name);
-        const layers = this.#layerInferrer.infer(coupling.edges, modules, coupling.cycles);
+        const configModuleLayerMap = new Map();
+        for (const mc of moduleCandidates) {
+            if (mc.configLayer) {
+                configModuleLayerMap.set(mc.name, mc.configLayer);
+            }
+        }
+        const layers = this.#layerInferrer.infer(coupling.edges, modules, coupling.cycles, {
+            configLayers: options?.configLayers,
+            moduleLayerMap: configModuleLayerMap.size > 0 ? configModuleLayerMap : undefined,
+        });
         // 5. 构建层级映射 (模块名 → 层级号)
         const moduleLayerMap = new Map();
         for (const level of layers.levels) {
@@ -48,7 +67,7 @@ export class PanoramaAggregator {
             }
         }
         // 6. 项目级 recipe 总数（recipe scope 通常为 universal，不做模块强关联）
-        const projectRecipeCount = this.#getProjectRecipeCount();
+        const projectRecipeCount = await this.#getProjectRecipeCount();
         // 7. 计算总文件数
         let totalFiles = 0;
         for (const mc of moduleCandidates) {
@@ -75,16 +94,21 @@ export class PanoramaAggregator {
                 coverageRatio: mc.files.length > 0 ? recipeCount / mc.files.length : 0,
             });
         }
-        // 8.5 基于模块角色重命名层级（比模块名 pattern 更准确）
-        this.#renameLayersByRole(layers, panoramaModules);
+        // 8.5 基于模块角色重命名层级（仅在拓扑推断模式下；配置层级保留原名）
+        if (!layers.configBased) {
+            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);
+        const { radar, gaps } = await this.#dimensionAnalyzer.analyze(moduleRoles);
         // 10. 调用流概要
-        const callFlowSummary = this.#computeCallFlowSummary();
+        const callFlowSummary = await this.#computeCallFlowSummary();
+        // 11. 外部依赖概况 + 技术栈画像
+        const externalDeps = await this.#buildExternalDepProfiles(coupling.externalDeps);
+        const techStack = externalDeps.length > 0 ? profileTechStack(externalDeps) : null;
         return {
             modules: panoramaModules,
             layers,
@@ -93,21 +117,72 @@ export class PanoramaAggregator {
             healthRadar: radar,
             callFlowSummary,
             projectRecipeCount,
+            externalDeps,
+            techStack,
             computedAt: Date.now(),
         };
     }
     /* ─── Project Recipe Count ──────────────────────── */
-    #getProjectRecipeCount() {
+    async #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);
+            return await this.#knowledgeRepo.countByCountableLifecycles();
         }
         catch {
             return 0;
         }
     }
+    /* ─── External Dependencies ─────────────────────── */
+    /**
+     * 从 code_entities 收集标记为 external 的模块名
+     */
+    async #collectExternalModules() {
+        try {
+            const rows = await this.#entityRepo.findModulesByNodeTypes(this.#projectRoot, [
+                'external',
+                'host',
+            ]);
+            return new Set(rows.map((r) => r.entityId));
+        }
+        catch {
+            return new Set();
+        }
+    }
+    /**
+     * 将 CouplingAnalyzer 的外部依赖统计转为 ExternalDepProfile
+     * 并从 code_entities 补充 layer/version 元数据
+     */
+    async #buildExternalDepProfiles(rawExternalDeps) {
+        if (rawExternalDeps.length === 0) {
+            return [];
+        }
+        // 查询外部依赖的元数据
+        const metadataMap = new Map();
+        try {
+            for (const dep of rawExternalDeps) {
+                const entity = await this.#entityRepo.findByEntityIdOnly(dep.name, this.#projectRoot);
+                if (entity?.metadata) {
+                    const meta = entity.metadata;
+                    metadataMap.set(dep.name, {
+                        layer: meta.layer,
+                        version: meta.version,
+                    });
+                }
+            }
+        }
+        catch {
+            /* skip metadata enrichment errors */
+        }
+        return rawExternalDeps.map((dep) => {
+            const meta = metadataMap.get(dep.name);
+            return {
+                name: dep.name,
+                fanIn: dep.fanIn,
+                dependedBy: dep.dependedBy,
+                layer: meta?.layer,
+                version: meta?.version,
+            };
+        });
+    }
     /* ─── Layer Naming (role-based) ─────────────────── */
     /** 角色 → 层级名映射 */
     static #ROLE_TO_LAYER = {
@@ -165,63 +240,54 @@ export class PanoramaAggregator {
                     layerName = 'Application';
                 }
             }
-            // 去重：已使用的名称追加 level 号
+            // 去重：优先尝试次高票角色名，仍冲突则追加位置描述
             if (usedNames.has(layerName)) {
-                layerName = `${layerName} ${level.level}`;
+                // 尝试次高票角色
+                let resolved = false;
+                if (roleVotes.size > 1) {
+                    const sortedRoles = [...roleVotes.entries()].sort((a, b) => b[1] - a[1]);
+                    for (let i = 1; i < sortedRoles.length; i++) {
+                        const altName = _a.#ROLE_TO_LAYER[sortedRoles[i][0]] ?? sortedRoles[i][0];
+                        if (!usedNames.has(altName)) {
+                            layerName = altName;
+                            resolved = true;
+                            break;
+                        }
+                    }
+                }
+                // 仍冲突：使用位置描述而非数字后缀
+                if (!resolved && usedNames.has(layerName)) {
+                    const pos = level.level <= maxLevel * 0.33
+                        ? 'Core'
+                        : level.level >= maxLevel * 0.67
+                            ? 'App'
+                            : 'Mid';
+                    const qualifiedName = `${pos} ${layerName}`;
+                    layerName = usedNames.has(qualifiedName) ? `${layerName} L${level.level}` : qualifiedName;
+                }
             }
             usedNames.add(layerName);
             level.name = layerName;
         }
     }
     /* ─── Call Flow Summary ─────────────────────────── */
-    #computeCallFlowSummary() {
+    async #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 topCalled = await this.#edgeRepo.findTopCalledNodes(10);
         // 入口点: 只有出度没有入度的方法
-        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();
+        const entryPoints = await this.#edgeRepo.findEntryPoints(20);
         // 数据生产者: 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();
+        const dataProducers = await this.#edgeRepo.findTopDataFlowSources(10, 3);
         // 数据消费者: 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();
+        const dataConsumers = await this.#edgeRepo.findTopDataFlowSinks(10, 3);
         return {
             topCalledMethods: topCalled.map((r) => ({
-                id: r.to_id,
-                callCount: Number(r.call_count),
+                id: r.toId,
+                callCount: r.callCount,
             })),
-            entryPoints: entryPoints.map((r) => r.from_id),
-            dataProducers: dataProducers.map((r) => r.from_id),
-            dataConsumers: dataConsumers.map((r) => r.to_id),
+            entryPoints,
+            dataProducers,
+            dataConsumers,
         };
     }
 }

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

@@ -11,9 +11,13 @@
  *
  * @module PanoramaScanner
  */
+import type { CodeEntityRepositoryImpl } from '../../repository/code/CodeEntityRepository.js';
+import type { KnowledgeEdgeRepositoryImpl } from '../../repository/knowledge/KnowledgeEdgeRepository.js';
 export interface PanoramaScannerOptions {
     projectRoot: string;
     container: ScannerContainer;
+    entityRepo: CodeEntityRepositoryImpl;
+    edgeRepo: KnowledgeEdgeRepositoryImpl;
     logger?: ScannerLogger;
 }
 export interface ScannerContainer {
@@ -35,7 +39,7 @@ export declare class PanoramaScanner {
     /**
      * 检测 DB 中是否已有该项目的 code_entities 数据
      */
-    hasData(): boolean;
+    hasData(): Promise<boolean>;
     /**
      * 确保全景数据存在。无数据时自动执行扫描。
      * 幂等：扫描过一次后不再重复（重启进程或手动 reset 可重新触发）。