autosnippet 3.3.6 → 3.3.8

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

@@ -6,22 +6,33 @@
  *
  * @module CouplingAnalyzer
  */
-import type { CeDbLike, CyclicDependency, Edge } from './PanoramaTypes.js';
+import type { CodeEntityRepositoryImpl } from '../../repository/code/CodeEntityRepository.js';
+import type { KnowledgeEdgeRepositoryImpl } from '../../repository/knowledge/KnowledgeEdgeRepository.js';
+import type { CyclicDependency, Edge } from './PanoramaTypes.js';
 export interface CouplingMetrics {
     fanIn: number;
     fanOut: number;
 }
+export interface ExternalDepMetrics {
+    name: string;
+    fanIn: number;
+    /** 依赖此外部库的本地模块列表 */
+    dependedBy: string[];
+}
 export interface CouplingResult {
     cycles: CyclicDependency[];
     metrics: Map<string, CouplingMetrics>;
     edges: Edge[];
+    /** 外部依赖 fan-in 统计（按 fan-in 降序排列） */
+    externalDeps: ExternalDepMetrics[];
 }
 export declare class CouplingAnalyzer {
     #private;
-    constructor(db: CeDbLike, projectRoot: string);
+    constructor(edgeRepo: KnowledgeEdgeRepositoryImpl, entityRepo: CodeEntityRepositoryImpl, projectRoot: string);
     /**
      * 分析模块间耦合关系
      * @param moduleFiles - Map<moduleName, filePaths[]>
+     * @param externalModules - 外部模块名集合（无源码但参与依赖图）
      */
-    analyze(moduleFiles: Map<string, string[]>): CouplingResult;
+    analyze(moduleFiles: Map<string, string[]>, externalModules?: Set<string>): Promise<CouplingResult>;
 }

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

@@ -6,6 +6,8 @@
  *
  * @module CouplingAnalyzer
  */
+import { readFileSync } from 'node:fs';
+import { LanguageProfiles } from '#shared/LanguageProfiles.js';
 /* ═══ Edge Weights ════════════════════════════════════════ */
 const EDGE_WEIGHTS = {
     depends_on: 0.5,
@@ -14,17 +16,20 @@ const EDGE_WEIGHTS = {
 };
 /* ═══ CouplingAnalyzer Class ══════════════════════════════ */
 export class CouplingAnalyzer {
-    #db;
+    #edgeRepo;
+    #entityRepo;
     #projectRoot;
-    constructor(db, projectRoot) {
-        this.#db = db;
+    constructor(edgeRepo, entityRepo, projectRoot) {
+        this.#edgeRepo = edgeRepo;
+        this.#entityRepo = entityRepo;
         this.#projectRoot = projectRoot;
     }
     /**
      * 分析模块间耦合关系
      * @param moduleFiles - Map<moduleName, filePaths[]>
+     * @param externalModules - 外部模块名集合（无源码但参与依赖图）
      */
-    analyze(moduleFiles) {
+    async analyze(moduleFiles, externalModules) {
         // 1. 构建 file → module 反向索引
         const fileToModule = new Map();
         for (const [mod, files] of moduleFiles) {
@@ -33,7 +38,7 @@ export class CouplingAnalyzer {
             }
         }
         // 2. 从 knowledge_edges 聚合模块间边
-        const edges = this.#buildModuleEdges(moduleFiles, fileToModule);
+        const edges = await this.#buildModuleEdges(moduleFiles, fileToModule);
         // 3. 建图
         const adjacency = new Map();
         const allModules = new Set(moduleFiles.keys());
@@ -66,61 +71,56 @@ export class CouplingAnalyzer {
                 toM.fanIn++;
             }
         }
+        // 5.5 外部依赖 fan-in 统计
+        const externalDeps = await this.#computeExternalFanIn(moduleFiles, externalModules);
         // 去重边 (同 from→to 聚合)
         const dedupEdges = this.#deduplicateEdges(edges);
-        return { cycles, metrics, edges: dedupEdges };
+        return { cycles, metrics, edges: dedupEdges, externalDeps };
     }
     /* ─── Internal helpers ──────────────────────────── */
-    #buildModuleEdges(moduleFiles, fileToModule) {
+    async #buildModuleEdges(moduleFiles, fileToModule) {
         const edges = [];
         const relations = ['depends_on', 'calls', 'data_flow'];
+        // 跟踪哪些模块有 DB 边（用于判断是否需要 import 推断）
+        const modulesWithDbEdges = new Set();
         for (const relation of relations) {
             const weight = EDGE_WEIGHTS[relation] ?? 0.5;
             // 查询该类型的边（仅限当前项目：至少 from 侧实体属于本项目）
-            const rows = this.#db
-                .prepare(`SELECT ke.from_id, ke.from_type, ke.to_id, ke.to_type
-           FROM knowledge_edges ke
-           WHERE ke.relation = ?
-           AND (
-             ke.from_type = 'module'
-             OR EXISTS (
-               SELECT 1 FROM code_entities ce
-               WHERE ce.entity_id = ke.from_id AND ce.project_root = ?
-             )
-           )`)
-                .all(relation, this.#projectRoot);
+            const rows = await this.#edgeRepo.findEdgesFilteredByEntityExistence(relation, this.#projectRoot);
             for (const row of rows) {
-                const fromId = row.from_id;
-                const toId = row.to_id;
-                const fromType = row.from_type;
-                const toType = row.to_type;
+                const fromId = row.fromId;
+                const toId = row.toId;
+                const fromType = row.fromType;
+                const toType = row.toType;
                 // module-to-module 直接边 (depends_on)
                 if (fromType === 'module' && toType === 'module') {
                     if (fromId !== toId && moduleFiles.has(fromId) && moduleFiles.has(toId)) {
                         edges.push({ from: fromId, to: toId, weight, relation });
+                        modulesWithDbEdges.add(fromId);
                     }
                     continue;
                 }
                 // entity-to-entity 边 → 解析 file → module
-                const fromModule = this.#resolveEntityModule(fromId, fromType, fileToModule);
-                const toModule = this.#resolveEntityModule(toId, toType, fileToModule);
+                const fromModule = await this.#resolveEntityModule(fromId, fromType, fileToModule);
+                const toModule = await this.#resolveEntityModule(toId, toType, fileToModule);
                 if (fromModule && toModule && fromModule !== toModule) {
                     edges.push({ from: fromModule, to: toModule, weight, relation });
+                    modulesWithDbEdges.add(fromModule);
                 }
             }
         }
+        // 对没有 DB 边的模块，通过 import 扫描推断依赖
+        const importEdges = this.#inferEdgesFromImports(moduleFiles, modulesWithDbEdges);
+        edges.push(...importEdges);
         return edges;
     }
-    #resolveEntityModule(entityId, _entityType, fileToModule) {
+    async #resolveEntityModule(entityId, _entityType, fileToModule) {
         // 先查实体所在文件
-        const row = this.#db
-            .prepare(`SELECT file_path FROM code_entities
-         WHERE entity_id = ? AND project_root = ? LIMIT 1`)
-            .get(entityId, this.#projectRoot);
-        if (!row?.file_path) {
+        const entity = await this.#entityRepo.findByEntityIdOnly(entityId, this.#projectRoot);
+        if (!entity?.filePath) {
             return null;
         }
-        return fileToModule.get(row.file_path) ?? null;
+        return fileToModule.get(entity.filePath) ?? null;
     }
     /**
      * Tarjan 强连通分量算法
@@ -174,6 +174,111 @@ export class CouplingAnalyzer {
             severity: cycle.length > 3 ? 'error' : 'warning',
         }));
     }
+    /**
+     * 统计外部依赖的 fan-in（被多少本地模块依赖）
+     * 数据来源：knowledge_edges 中 from_type='module' AND to_type='module' 且 to 不在 moduleFiles 中
+     */
+    async #computeExternalFanIn(moduleFiles, externalModules) {
+        const fanInMap = new Map();
+        // 从 DB 查询 module-to-module depends_on 边
+        const rows = await this.#edgeRepo.findModuleDependencyPairs();
+        for (const row of rows) {
+            const fromId = row.fromId;
+            const toId = row.toId;
+            // from 必须是本地模块, to 必须是外部模块
+            if (!moduleFiles.has(fromId)) {
+                continue;
+            }
+            if (moduleFiles.has(toId)) {
+                continue;
+            }
+            // 如果提供了 externalModules 集合，检查 toId 是否在其中
+            if (externalModules && !externalModules.has(toId)) {
+                continue;
+            }
+            if (!fanInMap.has(toId)) {
+                fanInMap.set(toId, new Set());
+            }
+            fanInMap.get(toId).add(fromId);
+        }
+        // 转换为排序数组（按 fan-in 降序）
+        return [...fanInMap.entries()]
+            .map(([name, deps]) => ({
+            name,
+            fanIn: deps.size,
+            dependedBy: [...deps].sort(),
+        }))
+            .sort((a, b) => b.fanIn - a.fanIn);
+    }
+    /**
+     * 对无 DB 边的模块，扫描源文件 import 语句推断依赖。
+     * 典型场景：iOS 宿主应用中未声明在 Boxfile 的子模块。
+     */
+    #inferEdgesFromImports(moduleFiles, modulesWithDbEdges) {
+        const sourceExts = LanguageProfiles.sourceExts;
+        const importPatterns = LanguageProfiles.importPatterns;
+        const MAX_READ_BYTES = 8192; // 只读文件前 8KB（import 几乎总在文件头部）
+        const edges = [];
+        // 建立已知模块名集合（用于快速匹配 import 目标）
+        const knownModules = new Set(moduleFiles.keys());
+        for (const [modName, files] of moduleFiles) {
+            // 跳过已有 DB 边的模块——它们的依赖已由 Boxfile/配置声明
+            if (modulesWithDbEdges.has(modName)) {
+                continue;
+            }
+            const importedModules = new Set();
+            for (const filePath of files) {
+                // 只扫描源码文件
+                const dotIdx = filePath.lastIndexOf('.');
+                if (dotIdx < 0) {
+                    continue;
+                }
+                const ext = filePath.slice(dotIdx).toLowerCase();
+                if (!sourceExts.has(ext)) {
+                    continue;
+                }
+                let content;
+                try {
+                    const fd = readFileSync(filePath, { flag: 'r' });
+                    content =
+                        fd.length > MAX_READ_BYTES
+                            ? fd.subarray(0, MAX_READ_BYTES).toString('utf8')
+                            : fd.toString('utf8');
+                }
+                catch {
+                    continue; // 文件不可读则跳过
+                }
+                // 逐行匹配 import 模式
+                const lines = content.split('\n');
+                for (const line of lines) {
+                    const trimmed = line.trim();
+                    for (const pattern of importPatterns) {
+                        const m = pattern.regex.exec(trimmed);
+                        if (m) {
+                            const candidates = pattern.extract(m);
+                            for (const c of candidates) {
+                                if (c) {
+                                    importedModules.add(c);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            // 生成边：仅在目标是已知模块且非自身时
+            for (const imported of importedModules) {
+                if (imported !== modName && knownModules.has(imported)) {
+                    edges.push({
+                        from: modName,
+                        to: imported,
+                        weight: EDGE_WEIGHTS.depends_on,
+                        relation: 'depends_on',
+                    });
+                }
+            }
+        }
+        return edges;
+    }
     #deduplicateEdges(edges) {
         const key = (e) => `${e.from}→${e.to}`;
         const map = new Map();

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

@@ -13,17 +13,20 @@
  *
  * @module DimensionAnalyzer
  */
-import type { CeDbLike, HealthRadar, KnowledgeGap } from './PanoramaTypes.js';
+import type { BootstrapRepositoryImpl } from '../../repository/bootstrap/BootstrapRepository.js';
+import type { CodeEntityRepositoryImpl } from '../../repository/code/CodeEntityRepository.js';
+import type { KnowledgeRepositoryImpl } from '../../repository/knowledge/KnowledgeRepository.impl.js';
+import type { HealthRadar, KnowledgeGap } from './PanoramaTypes.js';
 export declare class DimensionAnalyzer {
     #private;
-    constructor(db: CeDbLike);
+    constructor(bootstrapRepo: BootstrapRepositoryImpl, entityRepo: CodeEntityRepositoryImpl, knowledgeRepo: KnowledgeRepositoryImpl, projectRoot: string);
     /**
      * 分析项目知识健康雷达
      *
      * @param moduleRoles — 项目中存在的模块角色 (用于 gap 优先级推断)
      */
-    analyze(moduleRoles: string[]): {
+    analyze(moduleRoles: string[]): Promise<{
         radar: HealthRadar;
         gaps: KnowledgeGap[];
-    };
+    }>;
 }

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

@@ -13,31 +13,34 @@
  *
  * @module DimensionAnalyzer
  */
-import { classifyRecipeToDimension, DIMENSION_REGISTRY } from '#domain/dimension/index.js';
-/* ═══ 维度定义 — 从统一注册表派生 ═══════════════════════ */
-/**
- * Panorama 使用全量维度注册表进行健康评估。
- * 所有维度（含语言/框架条件维度）都参与评估 —
- * 若该语言未激活但有 Recipe → 仍计入(只是不生成 gap 建议)。
- */
-const DIMENSION_DEFS = DIMENSION_REGISTRY;
+import { classifyRecipeToDimension, DIMENSION_REGISTRY, resolveActiveDimensions, } from '#domain/dimension/index.js';
+import { LanguageService } from '#shared/LanguageService.js';
+import { COUNTABLE_LIFECYCLES } from '../../domain/knowledge/Lifecycle.js';
 /* ═══ DimensionAnalyzer Class ═════════════════════════════ */
 export class DimensionAnalyzer {
-    #db;
-    constructor(db) {
-        this.#db = db;
+    #bootstrapRepo;
+    #entityRepo;
+    #knowledgeRepo;
+    #projectRoot;
+    constructor(bootstrapRepo, entityRepo, knowledgeRepo, projectRoot) {
+        this.#bootstrapRepo = bootstrapRepo;
+        this.#entityRepo = entityRepo;
+        this.#knowledgeRepo = knowledgeRepo;
+        this.#projectRoot = projectRoot;
     }
     /**
      * 分析项目知识健康雷达
      *
      * @param moduleRoles — 项目中存在的模块角色 (用于 gap 优先级推断)
      */
-    analyze(moduleRoles) {
+    async analyze(moduleRoles) {
+        // 0. 按项目语言过滤活跃维度（排除无关语言/框架维度）
+        const activeDims = await this.#resolveActiveDims();
         // 1. 从 DB 获取所有活跃 recipe 的维度分类信息
-        const recipes = this.#fetchRecipeMetadata();
+        const recipes = await this.#fetchRecipeMetadata();
         // 2. 将每条 recipe 映射到维度
         const dimensionCounts = new Map();
-        for (const def of DIMENSION_DEFS) {
+        for (const def of activeDims) {
             dimensionCounts.set(def.id, { count: 0, titles: [] });
         }
         let totalRecipes = 0;
@@ -53,16 +56,16 @@ export class DimensionAnalyzer {
             }
         }
         // 3. 计算各维度得分与状态
-        const dimensions = DIMENSION_DEFS.map((def) => {
+        const dimensions = activeDims.map((def) => {
             const entry = dimensionCounts.get(def.id);
             return this.#scoreDimension(def, entry.count, entry.titles);
         });
         // 4. 加权平均健康分
         let weightedSum = 0;
         let weightTotal = 0;
-        for (let i = 0; i < DIMENSION_DEFS.length; i++) {
-            weightedSum += dimensions[i].score * DIMENSION_DEFS[i].weight;
-            weightTotal += DIMENSION_DEFS[i].weight;
+        for (let i = 0; i < activeDims.length; i++) {
+            weightedSum += dimensions[i].score * activeDims[i].weight;
+            weightTotal += activeDims[i].weight;
         }
         const overallScore = weightTotal > 0 ? Math.round(weightedSum / weightTotal) : 0;
         // 5. 统计覆盖
@@ -78,23 +81,81 @@ export class DimensionAnalyzer {
         };
         // 6. 生成维度空白 (gaps)
         const roleSet = new Set(moduleRoles);
-        const gaps = this.#detectDimensionGaps(dimensions, roleSet);
+        const gaps = this.#detectDimensionGaps(dimensions, activeDims, roleSet);
         return { radar, gaps };
     }
+    /* ─── 按项目语言解析活跃维度 ───────────────────── */
+    async #resolveActiveDims() {
+        // 1. 优先从 bootstrap_snapshots 获取 primary_lang
+        try {
+            const primaryLang = await this.#bootstrapRepo.getLatestPrimaryLang(this.#projectRoot);
+            if (primaryLang) {
+                return resolveActiveDimensions(primaryLang);
+            }
+        }
+        catch {
+            // 无 bootstrap 数据 → 继续尝试从 code_entities 推断
+        }
+        // 2. 从 code_entities 文件扩展名推断主语言
+        const inferredLang = await this.#inferLanguageFromEntities();
+        if (inferredLang) {
+            return resolveActiveDimensions(inferredLang);
+        }
+        return DIMENSION_REGISTRY;
+    }
+    /**
+     * 从 code_entities 文件扩展名统计推断项目主语言
+     *
+     * 当无 bootstrap_snapshots 时使用（如仅执行了 scan 但未 bootstrap 的项目）
+     */
+    async #inferLanguageFromEntities() {
+        try {
+            const filePaths = await this.#entityRepo.findDistinctFilePaths(this.#projectRoot, 2000);
+            if (filePaths.length === 0) {
+                return null;
+            }
+            const langCounts = new Map();
+            for (const fp of filePaths) {
+                if (!fp) {
+                    continue;
+                }
+                const dotIdx = fp.lastIndexOf('.');
+                if (dotIdx < 0) {
+                    continue;
+                }
+                const ext = fp.slice(dotIdx).toLowerCase();
+                const lang = LanguageService.langFromExt(ext);
+                if (lang !== 'unknown') {
+                    langCounts.set(lang, (langCounts.get(lang) ?? 0) + 1);
+                }
+            }
+            // .h 文件可能属于 Swift/ObjC 项目 — 如果同时存在 .swift 文件则优先 swift
+            if (langCounts.has('swift') && langCounts.has('objectivec')) {
+                const swiftCount = langCounts.get('swift');
+                const objcCount = langCounts.get('objectivec');
+                if (swiftCount >= objcCount * 0.2) {
+                    return 'swift';
+                }
+            }
+            // 选最多的语言
+            let bestLang = '';
+            let bestCount = 0;
+            for (const [lang, _count] of langCounts) {
+                if (_count > bestCount) {
+                    bestLang = lang;
+                    bestCount = _count;
+                }
+            }
+            return bestLang || null;
+        }
+        catch {
+            return null;
+        }
+    }
     /* ─── 从 DB 获取 recipe 元数据 ─────────────────── */
-    #fetchRecipeMetadata() {
+    async #fetchRecipeMetadata() {
         try {
-            const rows = this.#db
-                .prepare(`SELECT title, category, topicHint, kind
-           FROM knowledge_entries
-           WHERE lifecycle IN ('active', 'pending')`)
-                .all();
-            return rows.map((r) => ({
-                title: String(r.title ?? ''),
-                category: String(r.category ?? ''),
-                topicHint: String(r.topicHint ?? ''),
-                kind: String(r.kind ?? ''),
-            }));
+            return await this.#knowledgeRepo.findRecipeMetadata(COUNTABLE_LIFECYCLES);
         }
         catch {
             return [];
@@ -153,11 +214,11 @@ export class DimensionAnalyzer {
         };
     }
     /* ─── 维度空白检测 ─────────────────────────────── */
-    #detectDimensionGaps(dimensions, moduleRoles) {
+    #detectDimensionGaps(dimensions, activeDims, moduleRoles) {
         const gaps = [];
         for (let i = 0; i < dimensions.length; i++) {
             const dim = dimensions[i];
-            const def = DIMENSION_DEFS[i];
+            const def = activeDims[i];
             if (dim.status !== 'missing' && dim.status !== 'weak') {
                 continue;
             }

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

@@ -4,9 +4,23 @@
  * 基于模块依赖图，通过去环 + 拓扑排序 + 最长路径法推断架构层级 (L0-Ln)。
  * 底层 (L0) = Foundation/Core，顶层 = App/UI。
  *
+ * 当配置文件声明了明确的层级结构时（如 Boxfile 的 layer 定义），
+ * 优先使用配置层级，仅对未覆盖的模块做拓扑推断。
+ *
  * @module LayerInferrer
  */
 import type { CyclicDependency, Edge, LayerHierarchy } from './PanoramaTypes.js';
+export interface ConfigLayer {
+    name: string;
+    order: number;
+    accessibleLayers: string[];
+}
+export interface InferOptions {
+    /** 来自配置文件的层级定义（如 Boxfile、Project.swift 等） */
+    configLayers?: ConfigLayer[] | null;
+    /** 模块 → 配置层级名映射 */
+    moduleLayerMap?: Map<string, string>;
+}
 export declare class LayerInferrer {
     #private;
     /**
@@ -14,6 +28,7 @@ export declare class LayerInferrer {
      * @param edges - 模块间依赖边 (from depends_on/calls/data_flow to)
      * @param modules - 所有模块名
      * @param cycles - 已检测到的循环依赖
+     * @param options - 可选配置：configLayers（配置声明的层级）和 moduleLayerMap（模块→层级映射）
      */
-    infer(edges: Edge[], modules: string[], cycles: CyclicDependency[]): LayerHierarchy;
+    infer(edges: Edge[], modules: string[], cycles: CyclicDependency[], options?: InferOptions): LayerHierarchy;
 }

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

@@ -4,6 +4,9 @@
  * 基于模块依赖图，通过去环 + 拓扑排序 + 最长路径法推断架构层级 (L0-Ln)。
  * 底层 (L0) = Foundation/Core，顶层 = App/UI。
  *
+ * 当配置文件声明了明确的层级结构时（如 Boxfile 的 layer 定义），
+ * 优先使用配置层级，仅对未覆盖的模块做拓扑推断。
+ *
  * @module LayerInferrer
  */
 /* ═══ Constants ═══════════════════════════════════════════ */
@@ -26,8 +29,122 @@ export class LayerInferrer {
      * @param edges - 模块间依赖边 (from depends_on/calls/data_flow to)
      * @param modules - 所有模块名
      * @param cycles - 已检测到的循环依赖
+     * @param options - 可选配置：configLayers（配置声明的层级）和 moduleLayerMap（模块→层级映射）
+     */
+    infer(edges, modules, cycles, options) {
+        // 如果有配置文件声明的层级且覆盖了大部分模块，优先使用
+        if (options?.configLayers?.length && options.moduleLayerMap?.size) {
+            const coverage = this.#computeConfigCoverage(modules, options.moduleLayerMap);
+            if (coverage >= 0.5) {
+                return this.#inferFromConfig(edges, modules, options.configLayers, options.moduleLayerMap);
+            }
+        }
+        return this.#inferFromTopology(edges, modules, cycles);
+    }
+    /* ─── Config-based layer inference ──────────────── */
+    /**
+     * 基于配置文件声明的层级直接分配
+     * 未被配置覆盖的模块附加到最近匹配的层级
      */
-    infer(edges, modules, cycles) {
+    #inferFromConfig(edges, modules, configLayers, moduleLayerMap) {
+        // 按 order 排序层级
+        const sortedLayers = [...configLayers].sort((a, b) => a.order - b.order);
+        // 构建层级名 → level 映射 (底层 = L0, 反序: order 最大的是底层)
+        // 配置中 order=0 是最高层 (如 Accessories), order=N 是最底层 (如 Vendors)
+        const maxOrder = sortedLayers.length > 0 ? sortedLayers[sortedLayers.length - 1].order : 0;
+        const layerNameToLevel = new Map();
+        for (const cl of sortedLayers) {
+            // 反转: 配置中 order 越大越底层 → level 越小
+            layerNameToLevel.set(cl.name, maxOrder - cl.order);
+        }
+        // 分配每个模块到层级
+        const moduleLevels = new Map();
+        const uncovered = [];
+        for (const mod of modules) {
+            const layerName = moduleLayerMap.get(mod);
+            if (layerName && layerNameToLevel.has(layerName)) {
+                moduleLevels.set(mod, layerNameToLevel.get(layerName));
+            }
+            else {
+                uncovered.push(mod);
+            }
+        }
+        // 未覆盖的模块: 基于依赖关系推断最可能的层级
+        for (const mod of uncovered) {
+            const depEdges = edges.filter((e) => e.from === mod);
+            let bestLevel = maxOrder + 1; // 默认最高层
+            for (const e of depEdges) {
+                const targetLevel = moduleLevels.get(e.to);
+                if (targetLevel !== undefined) {
+                    bestLevel = Math.min(bestLevel, targetLevel + 1);
+                }
+            }
+            // 如果没有依赖线索, 查看谁依赖它
+            if (bestLevel > maxOrder) {
+                const reverseEdges = edges.filter((e) => e.to === mod);
+                for (const e of reverseEdges) {
+                    const sourceLevel = moduleLevels.get(e.from);
+                    if (sourceLevel !== undefined) {
+                        bestLevel = Math.min(bestLevel, Math.max(0, sourceLevel - 1));
+                    }
+                }
+            }
+            // 兜底: 放到最高层
+            if (bestLevel > maxOrder) {
+                bestLevel = maxOrder;
+            }
+            moduleLevels.set(mod, bestLevel);
+        }
+        // 聚合: 同层模块分组
+        const layerGroups = new Map();
+        for (const [mod, level] of moduleLevels) {
+            if (!layerGroups.has(level)) {
+                layerGroups.set(level, []);
+            }
+            layerGroups.get(level).push(mod);
+        }
+        // 构建 levelEntries, 使用配置中的层级名
+        const levelToConfigName = new Map();
+        for (const cl of sortedLayers) {
+            levelToConfigName.set(maxOrder - cl.order, cl.name);
+        }
+        const sortedLevels = [...layerGroups.entries()].sort((a, b) => a[0] - b[0]);
+        const levelEntries = sortedLevels.map(([level, mods]) => ({
+            level,
+            name: levelToConfigName.get(level) ?? this.#inferLayerName(mods, level, sortedLevels.length),
+            modules: mods.sort(),
+        }));
+        // 检测层级违规（基于 access 规则）
+        const violations = [];
+        for (const edge of edges) {
+            const fromLevel = moduleLevels.get(edge.from);
+            const toLevel = moduleLevels.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, configBased: true };
+    }
+    #computeConfigCoverage(modules, moduleLayerMap) {
+        if (modules.length === 0) {
+            return 0;
+        }
+        let covered = 0;
+        for (const mod of modules) {
+            if (moduleLayerMap.has(mod)) {
+                covered++;
+            }
+        }
+        return covered / modules.length;
+    }
+    /* ─── Topology-based layer inference ────────────── */
+    #inferFromTopology(edges, modules, cycles) {
         // 1. 建图 (邻接表: from → to[])
         const adjacency = new Map();
         const reverseAdj = new Map();

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

@@ -11,14 +11,24 @@
  *
  * @module ModuleDiscoverer
  */
-import type { CeDbLike } from './PanoramaTypes.js';
+import type { CodeEntityRepositoryImpl } from '../../repository/code/CodeEntityRepository.js';
+import type { KnowledgeEdgeRepositoryImpl } from '../../repository/knowledge/KnowledgeEdgeRepository.js';
 import type { ModuleCandidate } from './RoleRefiner.js';
 export declare class ModuleDiscoverer {
     #private;
-    constructor(db: CeDbLike, projectRoot: string);
+    constructor(entityRepo: CodeEntityRepositoryImpl, edgeRepo: KnowledgeEdgeRepositoryImpl, projectRoot: string);
     /**
      * 从 DB 中读取已扫描的模块数据。
-     * 若无 module 实体，返回空数组（让调用侧决定是否重新扫描）。
+     * 若无 module 实体（含 host），返回空数组（让调用侧决定是否重新扫描）。
      */
-    discover(): ModuleCandidate[];
+    discover(): Promise<ModuleCandidate[]>;
+    /**
+     * 读取 config layers 元数据（如果存在）
+     * @returns 从 `__config_layers__` 实体中恢复的层级定义
+     */
+    readConfigLayers(): Promise<Array<{
+        name: string;
+        order: number;
+        accessibleLayers: string[];
+    }> | null>;
 }