autosnippet 3.2.7 → 3.2.8

package/lib/external/mcp/handlers/bootstrap-external.js

@@ -75,6 +75,9 @@ export async function bootstrapExternal(ctx) {
     contentMaxLines: 120,
     sourceTag: 'bootstrap-external',
     summaryPrefix: 'Bootstrap-external scan',
+    clearOldData: true,
+    generateReport: true,
+    incremental: true,
   });
 
   // 空项目 fast-path
@@ -88,9 +91,9 @@ export async function bootstrapExternal(ctx) {
 
   const {
     allFiles, primaryLang, depGraphData, langStats,
-    astProjectSummary, codeEntityResult, guardAudit,
+    astProjectSummary, codeEntityResult, callGraphResult, guardAudit,
     activeDimensions: dimensions, targetsSummary,
-    langProfile,
+    langProfile, incrementalPlan,
   } = phaseResults;
 
   // ═══════════════════════════════════════════════════════════
@@ -115,6 +118,7 @@ export async function bootstrapExternal(ctx) {
     allFiles,
     astProjectSummary,
     codeEntityResult,
+    callGraphResult,
     depGraphData,
     guardAudit,
     langStats,
@@ -138,12 +142,15 @@ export async function bootstrapExternal(ctx) {
     projectMeta,
     astData: astProjectSummary,
     codeEntityResult,
+    callGraphResult,
     depGraphData,
     guardAudit,
     targets: targetsSummary,
     activeDimensions: dimensions,
     session,
     languageExtension: buildLanguageExtension(primaryLang),  // §7.1
+    incrementalPlan,
+    languageStats: langStats,
   });
 
   // 附加 warnings

package/lib/external/mcp/handlers/bootstrap-internal.js

@@ -87,6 +87,7 @@ export async function bootstrapKnowledge(ctx, args) {
   const maxFiles = args.maxFiles || 500;
   const skipGuard = args.skipGuard || false;
   const contentMaxLines = args.contentMaxLines || 120;
+  const skipAsyncFill = args.skipAsyncFill || false;
 
   // ═══════════════════════════════════════════════════════════
   // Phase 1-4: 共享管线（文件收集→AST→依赖→Guard→维度解析）
@@ -149,7 +150,12 @@ export async function bootstrapKnowledge(ctx, args) {
         categories: astProjectSummary?.categories?.length || 0,
         patterns: Object.keys(astProjectSummary?.patternStats || {}),
       },
-      codeEntityGraph: phaseReport?.phases?.entityGraph || { entities: 0, edges: 0, durationMs: 0 },
+      codeEntityGraph: phaseReport?.phases?.entityGraph || { entityCount: 0, edgeCount: 0, ms: 0 },
+      callGraph: phaseReport?.phases?.callGraph ? {
+        entities: phaseReport.phases.callGraph.result?.entitiesUpserted || 0,
+        edges: phaseReport.phases.callGraph.result?.edgesCreated || 0,
+        ms: phaseReport.phases.callGraph.ms || 0,
+      } : { entities: 0, edges: 0, ms: 0 },
       dependencyGraph: { edgesWritten: depEdgesWritten || 0 },
       enhancementPacks: {
         matched: enhancementPackInfo,
@@ -371,12 +377,17 @@ export async function bootstrapKnowledge(ctx, args) {
   };
 
   // 使用 setImmediate 避免阻塞 HTTP 响应
-  setImmediate(() => {
-    ctx.logger.info(`[Bootstrap] Dispatching v3 AI-First pipeline`);
-    fillDimensionsV3(fillContext).catch((e) => {
-      ctx.logger.error(`[Bootstrap] Async fill (v3) failed: ${e.message}`);
+  // skipAsyncFill: CLI 非 --wait 模式跳过异步填充，避免进程退出后 DB 断连
+  if (!skipAsyncFill) {
+    setImmediate(() => {
+      ctx.logger.info(`[Bootstrap] Dispatching v3 AI-First pipeline`);
+      fillDimensionsV3(fillContext).catch((e) => {
+        ctx.logger.error(`[Bootstrap] Async fill (v3) failed: ${e.message}`);
+      });
     });
-  });
+  } else {
+    ctx.logger.info(`[Bootstrap] Async fill skipped (skipAsyncFill=true)`);
+  }
 
   // ── SkillHooks: onBootstrapStarted (fire-and-forget) ──
   try {

package/lib/external/mcp/handlers/consolidated.js

@@ -99,6 +99,15 @@ export async function consolidatedStructure(ctx, args) {
   }
 }
 
+// ─── autosnippet_call_context (Phase 5) ─────────────────────
+
+/**
+ * 调用链上下文查询：直接转发到 structure.callContext
+ */
+export async function consolidatedCallContext(ctx, args) {
+  return structureHandlers.callContext(ctx, args);
+}
+
 // ─── autosnippet_graph (整合 4 → 1) ─────────────────────────
 
 /**

package/lib/external/mcp/handlers/guard.js

@@ -416,14 +416,14 @@ export async function scanProject(ctx, args) {
 
   const projectRoot = process.env.ASD_PROJECT_DIR || process.cwd();
 
-  // 优先使用 ModuleService（多语言统一入口），回退到 SpmService
+  // 优先使用 ModuleService（多语言统一入口），回退到 SpmHelper
   let service;
   try {
     const { ModuleService } = await import('../../../service/module/ModuleService.js');
     service = new ModuleService(projectRoot);
   } catch {
-    const { SpmService } = await import('../../../platform/ios/spm/SpmService.js');
-    service = new SpmService(projectRoot);
+    const { SpmHelper } = await import('../../../platform/ios/spm/SpmHelper.js');
+    service = new SpmHelper(projectRoot);
   }
   await service.load();
   const allTargets = await service.listTargets();

package/lib/external/mcp/handlers/structure.js

@@ -527,6 +527,68 @@ async function _fallbackPathFromRecipe(ctx, fromId, toId) {
   }
 }
 
+// ─── call_context — 调用链上下文 (Phase 5) ──────────────────
+
+/**
+ * autosnippet_call_context handler
+ * 查询方法的调用者、被调用者、影响半径
+ */
+export async function callContext(ctx, args) {
+  if (!args.methodName) {
+    throw new Error('Missing required parameter: methodName');
+  }
+
+  const ceg = ctx.container.get('codeEntityGraph');
+  if (!ceg) {
+    return envelope({
+      success: false,
+      message: 'CodeEntityGraph not available — 请先运行 bootstrap',
+      meta: { tool: 'autosnippet_call_context' },
+    });
+  }
+
+  const direction = args.direction || 'both';
+  const maxDepth = Math.min(Math.max(args.maxDepth ?? 2, 1), 5);
+  const result = {};
+
+  try {
+    if (direction === 'callers' || direction === 'both') {
+      result.callers = ceg.getCallers(args.methodName, maxDepth);
+    }
+    if (direction === 'callees' || direction === 'both') {
+      result.callees = ceg.getCallees(args.methodName, maxDepth);
+    }
+    if (direction === 'impact') {
+      result.impact = ceg.getCallImpactRadius(args.methodName);
+    }
+  } catch (err) {
+    if (err.message?.includes('no such table')) {
+      return envelope({
+        success: true,
+        data: {
+          methodName: args.methodName,
+          callers: [],
+          callees: [],
+          note: 'knowledge_edges 表不存在，请运行 bootstrap 后再查询',
+        },
+        meta: { tool: 'autosnippet_call_context' },
+      });
+    }
+    throw err;
+  }
+
+  return envelope({
+    success: true,
+    data: {
+      methodName: args.methodName,
+      direction,
+      maxDepth,
+      ...result,
+    },
+    meta: { tool: 'autosnippet_call_context' },
+  });
+}
+
 // ─── graph_stats — 图谱统计 ────────────────────────────────
 
 export async function graphStats(ctx) {

package/lib/external/mcp/handlers/wiki-external.js

@@ -60,10 +60,73 @@ export async function wikiPlan(ctx, args) {
   const session = getActiveSession(container, args.sessionId);
   const cachedData = session?.phaseCache;
 
-  if (cachedData?.projectInfo && cachedData?.astInfo) {
-    ({ projectInfo, astInfo, moduleInfo, knowledgeInfo } = cachedData);
+  if (cachedData?.astProjectSummary) {
+    // Bootstrap phase cache → WikiGenerator-compatible format 转换
+    const allFiles = cachedData.allFiles || [];
+    const ast = cachedData.astProjectSummary;
+
+    // projectInfo: 从 bootstrap 文件列表和语言统计构建
+    const filesByModule = {};
+    for (const f of allFiles) {
+      const mod = f.targetName || '_default';
+      if (!filesByModule[mod]) filesByModule[mod] = [];
+      filesByModule[mod].push(f.relativePath);
+    }
+    projectInfo = {
+      name: path.basename(projectRoot),
+      root: projectRoot,
+      sourceFiles: allFiles.map(f => f.relativePath),
+      languages: cachedData.langStats || {},
+      primaryLanguage: cachedData.primaryLang || 'unknown',
+      sourceFilesByModule: filesByModule,
+      buildSystems: [],
+    };
+
+    // astInfo: 从 AstAnalyzer 结果构建
+    const classesByModule = {};
+    const protocolsByModule = {};
+    for (const cls of ast.classes || []) {
+      const mod = cls.targetName || '_default';
+      if (!classesByModule[mod]) classesByModule[mod] = [];
+      classesByModule[mod].push(cls.name);
+    }
+    for (const p of ast.protocols || []) {
+      const mod = p.targetName || '_default';
+      if (!protocolsByModule[mod]) protocolsByModule[mod] = [];
+      protocolsByModule[mod].push(p.name);
+    }
+    astInfo = {
+      classes: (ast.classes || []).map(c => c.name),
+      protocols: (ast.protocols || []).map(p => p.name),
+      overview: ast.projectMetrics || null,
+      classNamesByModule: classesByModule,
+      protocolNamesByModule: protocolsByModule,
+    };
+
+    // moduleInfo: 从依赖图和 targets 构建
+    moduleInfo = {
+      targets: (cachedData.targetsSummary || []).map(t => ({
+        name: t.name, type: t.type, fileCount: t.fileCount,
+      })),
+      depGraph: cachedData.depGraphData || null,
+    };
+
+    // knowledgeInfo: 始终从 DB 获取最新（bootstrap 期间可能已写入知识）
+    try {
+      const ks = tryGet(container, 'knowledgeService');
+      if (ks) {
+        const items = await ks.list({ limit: 200 });
+        const stats = typeof ks.getStats === 'function' ? await ks.getStats() : null;
+        knowledgeInfo = { recipes: items?.items || items || [], stats };
+      } else {
+        knowledgeInfo = { recipes: [], stats: null };
+      }
+    } catch {
+      knowledgeInfo = { recipes: [], stats: null };
+    }
+
     cacheHit = true;
-    logger.info('[wiki-plan] Reusing bootstrap phase cache');
+    logger.info('[wiki-plan] Reusing bootstrap phase cache (converted to WikiGenerator format)');
   } else {
     // 无缓存（独立调用 wiki_plan 或进程已重启）→ 重新扫描
     logger.info('[wiki-plan] No bootstrap cache, running fresh scan...');

package/lib/external/mcp/tools.js

@@ -210,7 +210,42 @@ export const TOOLS = [
     },
   },
 
-  // 6. Guard 检查（统一入口）
+  // 6. 调用链上下文 (Phase 5)
+  {
+    name: 'autosnippet_call_context',
+    tier: 'agent',
+    description:
+      '查询方法的调用链上下文。\n' +
+      '• callers: 谁调用了这个方法？（调用者链）\n' +
+      '• callees: 这个方法调用了谁？（依赖链）\n' +
+      '• impact: 修改此方法的影响半径分析\n' +
+      '• both: 同时获取调用者和被调用者',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        methodName: {
+          type: 'string',
+          description: '方法名 (e.g. "UserService.getUser" 或 "getUser")',
+        },
+        direction: {
+          type: 'string',
+          enum: ['callers', 'callees', 'both', 'impact'],
+          default: 'both',
+          description: 'callers=调用者 | callees=被调用者 | both=双向 | impact=影响分析',
+        },
+        maxDepth: {
+          type: 'number',
+          default: 2,
+          minimum: 1,
+          maximum: 5,
+          description: '最大遍历深度',
+        },
+      },
+      required: ['methodName'],
+    },
+  },
+
+  // 7. Guard 检查（统一入口）
   {
     name: 'autosnippet_guard',
     tier: 'agent',

package/lib/http/routes/remote.js

@@ -120,7 +120,7 @@ let _larkClient = null;
 let _wsConnected = false;
 let _wsStarting = false;
 
-async function startLarkWS() {
+async function startLarkWS({ silent = false } = {}) {
   // 如果已连接且对象存在 → 直接返回
   if (_wsClient && _wsConnected) return { success: true, message: 'Already connected' };
   if (_wsStarting) return { success: true, message: 'Connection in progress' };
@@ -173,16 +173,18 @@ async function startLarkWS() {
 
     logger.info('[Remote/Lark] ✅ WebSocket long connection established');
 
-    // 向飞书发送上线通知（延迟 1 秒确保 chatId 已恢复）
-    setTimeout(() => {
-      sendLarkNotification([
-        '🟢 IDE 桥接已上线',
-        `时间: ${new Date().toLocaleString('zh-CN')}`,
-        `平台: macOS | Node ${process.version}`,
-        '',
-        '发送任意文字即可远程编程，/help 查看命令。',
-      ].join('\n')).catch(() => {});
-    }, 1000);
+    // 向飞书发送上线通知（仅首次启动，重连时静默）
+    if (!silent) {
+      setTimeout(() => {
+        sendLarkNotification([
+          '🟢 IDE 桥接已上线',
+          `时间: ${new Date().toLocaleString('zh-CN')}`,
+          `平台: macOS | Node ${process.version}`,
+          '',
+          '发送任意文字即可远程编程，/help 查看命令。',
+        ].join('\n')).catch(() => {});
+      }, 1000);
+    }
 
     return { success: true, message: 'Connected via WebSocket' };
   } catch (err) {
@@ -246,14 +248,12 @@ setInterval(async () => {
     }
   }
 
-  // WSClient 不存在或已标记断开 → 自动重连
+  // WSClient 不存在或已标记断开 → 自动重连（静默，不打扰用户）
   if (!_wsClient && !_wsStarting) {
     logger.info('[Remote/Lark] Connection lost, auto-reconnecting...');
-    const result = await startLarkWS();
+    const result = await startLarkWS({ silent: true });
     if (result.success) {
       logger.info('[Remote/Lark] ✅ Auto-reconnected successfully');
-      // 重连成功通知
-      sendLarkNotification('🔄 IDE 桥接重连成功').catch(() => {});
     } else {
       logger.warn(`[Remote/Lark] Auto-reconnect failed: ${result.message}`);
     }

package/lib/injection/ServiceContainer.js

@@ -18,7 +18,7 @@ import { IndexingPipeline } from '../infrastructure/vector/IndexingPipeline.js';
 // ─── P0: Vector Storage ──────────────────────────────
 import { JsonVectorAdapter } from '../infrastructure/vector/JsonVectorAdapter.js';
 // ─── P2: SPM ──────────────────────────────────────────
-import { SpmService } from '../platform/ios/spm/SpmService.js';
+import { SpmHelper } from '../platform/ios/spm/SpmHelper.js';
 import { KnowledgeRepositoryImpl } from '../repository/knowledge/KnowledgeRepository.impl.js';
 // ─── P1: Token Usage Tracking ─────────────────────────
 import { TokenUsageStore } from '../repository/token/TokenUsageStore.js';
@@ -121,7 +121,7 @@ export class ServiceContainer {
         this.singletons.skillHooks = bootstrapComponents.skillHooks;
       }
 
-      // AiFactory 模块引用（用于 SpmService AI 扫描）
+      // AiFactory 模块引用（用于 SpmHelper AI 扫描）
       try {
         this.singletons._aiFactory = await import('../external/ai/AiFactory.js');
       } catch {
@@ -658,18 +658,11 @@ export class ServiceContainer {
       return this.singletons.feedbackCollector;
     });
 
-    // SpmService (with AI + tool injection)
+    // SpmHelper (SPM 包结构解析与依赖操作辅助)
     this.register('spmService', () => {
       if (!this.singletons.spmService) {
         const projectRoot = this.singletons._projectRoot || process.cwd();
-        this.singletons.spmService = new SpmService(projectRoot, {
-          aiFactory: this.singletons._aiFactory || null,
-          chatAgent: this.singletons.chatAgent || null,
-          qualityScorer: this.get('qualityScorer'),
-          recipeExtractor: this.singletons._recipeExtractor || null,
-          guardCheckEngine: this.get('guardCheckEngine'),
-          violationsStore: this.get('violationsStore'),
-        });
+        this.singletons.spmService = new SpmHelper(projectRoot);
       }
       return this.singletons.spmService;
     });
@@ -766,9 +759,11 @@ export class ServiceContainer {
       if (!this.singletons.cursorDeliveryPipeline) {
         const knowledgeService = this.get('knowledgeService');
         const projectRoot = this.singletons._projectRoot || process.cwd();
+        const database = this.get('database');
         this.singletons.cursorDeliveryPipeline = new CursorDeliveryPipeline({
           knowledgeService,
           projectRoot,
+          database,
           logger: this.logger,
         });
       }

package/lib/platform/ios/index.js

@@ -14,7 +14,7 @@
  *     PlaceholderConverter.js — Xcode <#…#> ↔ VSCode ${N:…} 占位符转换
  *
  *   spm/
- *     SpmService.js          — Swift Package Manager 服务（Target / 依赖 / 策略）
+ *     SpmHelper.js           — SPM 包结构解析与依赖操作辅助工具
  *     SpmDiscoverer.js       — SPM 项目自动发现（ProjectDiscoverer 接口）
  *     PackageSwiftParser.js  — Package.swift 解析器
  *     DependencyGraph.js     — SPM Target 依赖图
@@ -36,7 +36,7 @@ export { PackageSwiftParser } from './spm/PackageSwiftParser.js';
 export { PolicyEngine } from './spm/PolicyEngine.js';
 export { SpmDiscoverer } from './spm/SpmDiscoverer.js';
 // ── Swift Package Manager ──
-export { SpmService } from './spm/SpmService.js';
+export { SpmHelper } from './spm/SpmHelper.js';
 export { saveEventFilter } from './xcode/SaveEventFilter.js';
 // ── Xcode IDE 自动化 ──
 export {

package/lib/platform/ios/spm/PackageSwiftParser.js

@@ -218,10 +218,11 @@ export class PackageSwiftParser {
 
   #extractDependencies(content) {
     const deps = [];
-    const re = /\.package\s*\(\s*url\s*:\s*"([^"]+)"[^)]*\)/g;
+
+    // 1. URL 依赖: .package(url: "...", ...)
+    const urlRe = /\.package\s*\(\s*url\s*:\s*"([^"]+)"[^)]*\)/g;
     let m;
-    while ((m = re.exec(content)) !== null) {
-      // 提取版本约束
+    while ((m = urlRe.exec(content)) !== null) {
       const block = m[0];
       const fromMatch = block.match(/from\s*:\s*"([^"]+)"/);
       const exactMatch = block.match(/exact\s*:\s*"([^"]+)"/);
@@ -231,6 +232,16 @@ export class PackageSwiftParser {
         type: 'package',
       });
     }
+
+    // 2. Local path 依赖: .package(path: "...")
+    const pathRe = /\.package\s*\(\s*path\s*:\s*"([^"]+)"\s*\)/g;
+    while ((m = pathRe.exec(content)) !== null) {
+      deps.push({
+        path: m[1],
+        type: 'local',
+      });
+    }
+
     return deps;
   }
 

package/lib/platform/ios/spm/SpmDiscoverer.js

@@ -1,17 +1,18 @@
 /**
  * @module SpmDiscoverer
- * @description 包装现有 SpmService，适配 ProjectDiscoverer 接口
+ * @description 包装现有 SpmHelper，适配 ProjectDiscoverer 接口
  *
  * 检测: 项目根或子目录存在 Package.swift
  */
 
 import { existsSync, readdirSync } from 'node:fs';
-import { basename, join, relative } from 'node:path';
+import { basename, dirname, join, relative } from 'node:path';
 import { ProjectDiscoverer } from '../../../core/discovery/ProjectDiscoverer.js';
 import { LanguageService } from '../../../shared/LanguageService.js';
+import { PackageSwiftParser } from './PackageSwiftParser.js';
 
 export class SpmDiscoverer extends ProjectDiscoverer {
-  /** @type {import('./SpmService.js').SpmService|null} */
+  /** @type {import('./SpmHelper.js').SpmHelper|null} */
   #spm = null;
   #projectRoot = null;
 
@@ -52,9 +53,9 @@ export class SpmDiscoverer extends ProjectDiscoverer {
 
   async load(projectRoot) {
     this.#projectRoot = projectRoot;
-    // 动态加载 SpmService（避免循环导入）
-    const { SpmService } = await import('./SpmService.js');
-    this.#spm = new SpmService(projectRoot);
+    // 动态加载 SpmHelper（避免循环导入）
+    const { SpmHelper } = await import('./SpmHelper.js');
+    this.#spm = new SpmHelper(projectRoot);
     await this.#spm.load();
   }
 
@@ -97,21 +98,126 @@ export class SpmDiscoverer extends ProjectDiscoverer {
   }
 
   async getDependencyGraph() {
-    if (!this.#spm) {
+    if (!this.#projectRoot) {
+      return { nodes: [], edges: [] };
+    }
+
+    // 直接用 PackageSwiftParser 构建依赖图，不依赖 SpmHelper
+    const parser = new PackageSwiftParser(this.#projectRoot);
+    const allPkgPaths = parser.findAllPackageSwifts(this.#projectRoot);
+
+    if (allPkgPaths.length === 0) {
       return { nodes: [], edges: [] };
     }
-    const raw = await this.#spm.getDependencyGraph();
-    return {
-      nodes: (raw.nodes || []).map((n) => (typeof n === 'string' ? n : n.id || n.name)),
-      edges: (raw.edges || []).map((e) => ({
-        from: e.from,
-        to: e.to,
-        type: 'depends_on',
-      })),
-    };
+
+    const nodes = [];
+    const edges = [];
+    const pkgNameSet = new Set();
+    // targetName → 所属 packageName 映射（用于跨包 target 依赖解析）
+    const targetToPkg = new Map();
+
+    // ── 第一遍：收集所有 package + target 节点 ──
+    const allParsed = [];
+    // 记录 umbrella 包名（无 targets 且无 products 的纯组织性入口包），不作为图节点
+    const umbrellaNames = new Set();
+    for (const pkgPath of allPkgPaths) {
+      try {
+        const parsed = parser.parse(pkgPath);
+        if (pkgNameSet.has(parsed.name)) continue;
+        pkgNameSet.add(parsed.name);
+        allParsed.push({ ...parsed, _dir: dirname(pkgPath) });
+
+        // 跳过 umbrella 包（无 targets + 无 products）——它只是组织子包的入口
+        const hasTargets = parsed.targets && parsed.targets.length > 0;
+        const hasProducts = parsed.products && parsed.products.length > 0;
+        if (!hasTargets && !hasProducts) {
+          umbrellaNames.add(parsed.name);
+          continue;
+        }
+
+        // package 节点
+        nodes.push({
+          id: parsed.name,
+          label: parsed.name,
+          type: 'package',
+          fullPath: dirname(pkgPath),
+          targetCount: parsed.targets.length,
+        });
+
+        // target 节点
+        for (const t of parsed.targets) {
+          nodes.push({
+            id: t.name,
+            label: t.name,
+            type: 'target',
+            parent: parsed.name,
+            targetType: t.type,
+          });
+          targetToPkg.set(t.name, parsed.name);
+        }
+
+        // product name → package（product 名可能和 target 名不同）
+        for (const prod of parsed.products || []) {
+          if (!targetToPkg.has(prod.name)) {
+            targetToPkg.set(prod.name, parsed.name);
+          }
+        }
+      } catch {
+        // 解析失败，跳过
+      }
+    }
+
+    // ── 第二遍：构建 edges ──
+    for (const parsed of allParsed) {
+      // 跳过 umbrella 包的边
+      if (umbrellaNames.has(parsed.name)) continue;
+
+      // 包级 local path 依赖
+      for (const dep of parsed.dependencies || []) {
+        if (dep.type === 'local' && dep.path) {
+          const depPkgSwift = join(parsed._dir, dep.path, 'Package.swift');
+          if (existsSync(depPkgSwift)) {
+            try {
+              const depParsed = parser.parse(depPkgSwift);
+              // 跳过指向 umbrella 包的边
+              if (!umbrellaNames.has(depParsed.name)) {
+                edges.push({ from: parsed.name, to: depParsed.name, type: 'depends_on' });
+              }
+            } catch {
+              const targetName = basename(dep.path);
+              if (!umbrellaNames.has(targetName)) {
+                edges.push({ from: parsed.name, to: targetName, type: 'depends_on' });
+              }
+            }
+          }
+        } else if (dep.url) {
+          const remoteName = basename(dep.url).replace(/\.git$/, '');
+          if (!pkgNameSet.has(remoteName)) {
+            pkgNameSet.add(remoteName);
+            nodes.push({ id: remoteName, label: remoteName, type: 'remote', indirect: true });
+          }
+          edges.push({ from: parsed.name, to: remoteName, type: 'depends_on' });
+        }
+      }
+
+      // target 级依赖
+      for (const t of parsed.targets || []) {
+        // target → parent package (contains)
+        edges.push({ from: parsed.name, to: t.name, type: 'contains' });
+
+        for (const depName of t.dependencies || []) {
+          // target → target 依赖（跳过指向 umbrella 包的）
+          if (!umbrellaNames.has(depName)) {
+            edges.push({ from: t.name, to: depName, type: 'depends_on' });
+          }
+        }
+      }
+    }
+
+    return { nodes, edges };
   }
 
-  /** 获取底层 SpmService（向后兼容） */
+  /** 获取底层 SpmHelper（向后兼容） */
   getSpmService() {
     return this.#spm;
   }