autosnippet 3.2.7 → 3.2.8

package/lib/core/ast/lang-typescript.js

@@ -4,8 +4,13 @@
  *
  * 提取: class, interface, type alias, enum, function, method, property, import, export
  * 模式检测: Singleton, Factory, Observer, React Hook/Component, Middleware, Decorator
+ *
+ * Phase 5: 新增 ImportRecord 结构化导入 + extractCallSites 调用点提取
  */
 
+import { ImportRecord } from '../analysis/ImportRecord.js';
+import { extractCallSitesTS } from '../analysis/CallSiteExtractor.js';
+
 function walkTypeScript(root, ctx) {
   _walkTSNode(root, ctx, null);
 }
@@ -20,7 +25,9 @@ function _walkTSNode(node, ctx, parentClassName) {
           (c) => c.type === 'string' || c.type === 'string_fragment'
         );
         if (source) {
-          ctx.imports.push(source.text.replace(/^['"]|['"]$/g, ''));
+          const importPath = source.text.replace(/^['"]|['"]$/g, '');
+          const importMeta = _parseImportClause(child);
+          ctx.imports.push(new ImportRecord(importPath, importMeta));
         }
         break;
       }
@@ -123,6 +130,12 @@ function _walkTSClassBody(body, ctx, className) {
       case 'method_definition': {
         const m = _parseTSMethod(child, className);
         ctx.methods.push(m);
+
+        // Phase 5.3: Extract constructor parameter properties (DI pattern)
+        if (m.name === 'constructor') {
+          const constructorProps = _extractTSConstructorProperties(child, className);
+          ctx.properties.push(...constructorProps);
+        }
         break;
       }
 
@@ -287,15 +300,111 @@ function _parseTSProperty(node, className) {
   const isStatic = node.text.trimStart().startsWith('static');
   const isReadonly = node.text.includes('readonly');
 
+  // Phase 5.3: Extract type annotation for DI/RTA resolution
+  const typeAnnotation = _extractTypeAnnotation(node);
+
+  // Phase 5.3: Extract decorators on properties (e.g. @Inject)
+  const decorators = [];
+  for (const child of node.namedChildren) {
+    if (child.type === 'decorator') {
+      decorators.push(child.text);
+    }
+  }
+
   return {
     name,
     className,
     isStatic,
     isReadonly,
+    typeAnnotation,
+    decorators: decorators.length > 0 ? decorators : undefined,
     line: node.startPosition.row + 1,
   };
 }
 
+/**
+ * Phase 5.3: Extract type name from a type_annotation node
+ * Handles: type_identifier, generic_type, nested_type_identifier, union_type
+ * Strips generics: UserRepo<T> → UserRepo
+ *
+ * @param {object} parentNode — AST node that may contain a type_annotation child
+ * @returns {string|null}
+ */
+function _extractTypeAnnotation(parentNode) {
+  const typeAnnotNode = parentNode.namedChildren.find((c) => c.type === 'type_annotation');
+  if (!typeAnnotNode) return null;
+
+  const typeNode = typeAnnotNode.namedChildren.find(
+    (c) =>
+      c.type === 'type_identifier' ||
+      c.type === 'generic_type' ||
+      c.type === 'nested_type_identifier'
+  );
+  if (!typeNode) return null;
+
+  // Strip generics: Repository<User> → Repository
+  const text = typeNode.text;
+  const bracketIdx = text.indexOf('<');
+  return bracketIdx > 0 ? text.slice(0, bracketIdx) : text;
+}
+
+/**
+ * Phase 5.3: Extract constructor parameter properties (TypeScript DI pattern)
+ *
+ * TypeScript shorthand: constructor(private userRepo: UserRepo)
+ * creates a class property `userRepo` with type `UserRepo`
+ *
+ * @param {object} constructorNode — method_definition node with name "constructor"
+ * @param {string} className
+ * @returns {Array} — property objects
+ */
+function _extractTSConstructorProperties(constructorNode, className) {
+  const properties = [];
+  const params = constructorNode.namedChildren.find((c) => c.type === 'formal_parameters');
+  if (!params) return properties;
+
+  for (const param of params.namedChildren) {
+    if (param.type !== 'required_parameter' && param.type !== 'optional_parameter') continue;
+
+    // Check for accessibility modifier (public, private, protected) or readonly
+    // These turn constructor params into class properties
+    const hasAccessibility = param.namedChildren.some(
+      (c) => c.type === 'accessibility_modifier' || c.type === 'override_modifier'
+    );
+    const hasReadonly = param.text.includes('readonly');
+
+    if (!hasAccessibility && !hasReadonly) continue; // Not a property declaration
+
+    const nameNode = param.namedChildren.find((c) => c.type === 'identifier');
+    const name = nameNode?.text;
+    if (!name) continue;
+
+    // Extract type annotation
+    const typeAnnotation = _extractTypeAnnotation(param);
+
+    // Extract decorators on parameter (e.g. @Inject)
+    const decorators = [];
+    for (const child of param.namedChildren) {
+      if (child.type === 'decorator') {
+        decorators.push(child.text);
+      }
+    }
+
+    properties.push({
+      name,
+      className,
+      isStatic: false,
+      isReadonly: hasReadonly,
+      typeAnnotation,
+      isConstructorParam: true,
+      decorators: decorators.length > 0 ? decorators : undefined,
+      line: param.startPosition.row + 1,
+    });
+  }
+
+  return properties;
+}
+
 function _parseTSVariableDecl(node, ctx, parentClassName) {
   for (const child of node.namedChildren) {
     if (child.type === 'variable_declarator') {
@@ -315,9 +424,187 @@ function _parseTSVariableDecl(node, ctx, parentClassName) {
           line: child.startPosition.row + 1,
           kind: 'definition',
         });
+        continue;
+      }
+
+      // CJS require(): const x = require('path') / const { a, b } = require('path')
+      // Dynamic import(): const mod = await import('./module')
+      const callNode = child.namedChildren.find((c) => c.type === 'call_expression');
+      if (callNode) {
+        const requireImport = _parseCJSRequire(callNode, child);
+        if (requireImport) {
+          ctx.imports.push(requireImport);
+          continue;
+        }
+        const dynamicImport = _parseDynamicImport(callNode, child);
+        if (dynamicImport) {
+          ctx.imports.push(dynamicImport);
+          continue;
+        }
+      }
+      // await import() — await wraps the call_expression
+      const awaitNode = child.namedChildren.find((c) => c.type === 'await_expression');
+      if (awaitNode) {
+        const awaitedCall = awaitNode.namedChildren.find((c) => c.type === 'call_expression');
+        if (awaitedCall) {
+          const dynamicImport = _parseDynamicImport(awaitedCall, child);
+          if (dynamicImport) {
+            ctx.imports.push(dynamicImport);
+          }
+        }
+      }
+    }
+  }
+}
+
+// ── TS/JS Import 解析 ──
+
+/**
+ * 从 import_statement 节点解析导入子句的结构化信息
+ *
+ * @param {TreeSitterNode} importNode — import_statement 节点
+ * @returns {{ symbols: string[], kind: string, alias: string|null, isTypeOnly: boolean }}
+ */
+function _parseImportClause(importNode) {
+  const symbols = [];
+  let kind = 'side-effect';
+  let alias = null;
+  let isTypeOnly = false;
+
+  // 检查 type-only import: import type { ... }
+  if (importNode.text.trimStart().startsWith('import type')) {
+    isTypeOnly = true;
+  }
+
+  for (const child of importNode.namedChildren) {
+    if (child.type === 'import_clause') {
+      for (const clauseChild of child.namedChildren) {
+        if (clauseChild.type === 'identifier') {
+          // default import: import Foo from '...'
+          symbols.push(clauseChild.text);
+          kind = 'default';
+        } else if (clauseChild.type === 'named_imports') {
+          // named imports: import { A, B as C } from '...'
+          kind = 'named';
+          for (const specifier of clauseChild.namedChildren) {
+            if (specifier.type === 'import_specifier') {
+              // 收集 specifier 中的所有 identifier / type_identifier
+              const identifiers = specifier.namedChildren.filter(
+                (c) => c.type === 'identifier' || c.type === 'type_identifier'
+              );
+              // import { A as B } → identifiers = [A, B] → push B (本地名)
+              // import { A }     → identifiers = [A]     → push A
+              if (identifiers.length > 0) {
+                symbols.push(identifiers[identifiers.length - 1].text);
+              }
+            }
+          }
+        } else if (clauseChild.type === 'namespace_import') {
+          // namespace import: import * as M from '...'
+          kind = 'namespace';
+          symbols.push('*');
+          const aliasNode = clauseChild.namedChildren.find((c) => c.type === 'identifier');
+          if (aliasNode) {
+            alias = aliasNode.text;
+          }
+        }
+      }
+    }
+  }
+
+  return { symbols, kind, alias, isTypeOnly };
+}
+
+/**
+ * 解析 CJS require() 调用: const x = require('path') / const { a, b } = require('path')
+ *
+ * @param {TreeSitterNode} callNode — call_expression 节点
+ * @param {TreeSitterNode} declaratorNode — variable_declarator 节点 (包含 lhs 绑定)
+ * @returns {ImportRecord|null}
+ */
+function _parseCJSRequire(callNode, declaratorNode) {
+  // 检查 callee 是否为 'require'
+  const callee = callNode.namedChildren[0];
+  if (!callee || callee.type !== 'identifier' || callee.text !== 'require') return null;
+
+  // 提取 require 参数中的路径字符串
+  const args = callNode.namedChildren.find((c) => c.type === 'arguments');
+  if (!args || args.namedChildCount === 0) return null;
+
+  const firstArg = args.namedChildren[0];
+  if (!firstArg || (firstArg.type !== 'string' && firstArg.type !== 'template_string')) return null;
+
+  const importPath = firstArg.text.replace(/^['"`]|['"`]$/g, '');
+  if (!importPath) return null;
+
+  // 解析 lhs 绑定模式
+  const lhs = declaratorNode.namedChildren[0]; // identifier or object_pattern
+  if (!lhs) return new ImportRecord(importPath, { symbols: [], kind: 'side-effect' });
+
+  if (lhs.type === 'identifier') {
+    // const express = require('express') → namespace import
+    return new ImportRecord(importPath, {
+      symbols: ['*'],
+      kind: 'namespace',
+      alias: lhs.text,
+    });
+  }
+
+  if (lhs.type === 'object_pattern') {
+    // const { readFile, writeFile } = require('fs')
+    const symbols = [];
+    for (const prop of lhs.namedChildren) {
+      if (prop.type === 'shorthand_property_identifier_pattern' || prop.type === 'shorthand_property_identifier') {
+        symbols.push(prop.text);
+      } else if (prop.type === 'pair_pattern' || prop.type === 'pair') {
+        // { readFile: rf } → 使用本地名 rf
+        const identifiers = prop.namedChildren.filter((c) => c.type === 'identifier');
+        if (identifiers.length > 0) {
+          symbols.push(identifiers[identifiers.length - 1].text);
+        }
       }
     }
+    return new ImportRecord(importPath, {
+      symbols: symbols.length > 0 ? symbols : ['*'],
+      kind: symbols.length > 0 ? 'named' : 'namespace',
+    });
   }
+
+  // 其他 lhs 模式 (如数组解构), 作为 side-effect 处理
+  return new ImportRecord(importPath, { symbols: [], kind: 'side-effect' });
+}
+
+/**
+ * 解析动态 import() 表达式: const mod = await import('./module')
+ *
+ * @param {TreeSitterNode} callNode — call_expression 节点
+ * @param {TreeSitterNode} declaratorNode — variable_declarator 节点
+ * @returns {ImportRecord|null}
+ */
+function _parseDynamicImport(callNode, declaratorNode) {
+  // 动态 import() 在 tree-sitter 中解析为 call_expression, callee 是 'import'
+  const callee = callNode.namedChildren[0];
+  if (!callee) return null;
+  // tree-sitter 可能将 import() 解析为 identifier('import') 或 special node
+  if (callee.text !== 'import') return null;
+
+  const args = callNode.namedChildren.find((c) => c.type === 'arguments');
+  if (!args || args.namedChildCount === 0) return null;
+
+  const firstArg = args.namedChildren[0];
+  if (!firstArg || (firstArg.type !== 'string' && firstArg.type !== 'template_string')) return null;
+
+  const importPath = firstArg.text.replace(/^['"`]|['"`]$/g, '');
+  if (!importPath) return null;
+
+  const lhs = declaratorNode?.namedChildren?.[0];
+  const alias = lhs?.type === 'identifier' ? lhs.text : null;
+
+  return new ImportRecord(importPath, {
+    symbols: ['*'],
+    kind: 'dynamic',
+    alias,
+  });
 }
 
 // ── TS/JS 模式检测 ──
@@ -477,6 +764,7 @@ export const plugin = {
   getGrammar,
   walk: walkTypeScript,
   detectPatterns: detectTSPatterns,
+  extractCallSites: extractCallSitesTS,
   extensions: ['.ts'],
 };
 
@@ -493,5 +781,6 @@ export const tsxPlugin = {
   getGrammar: getTsxGrammar,
   walk: walkTypeScript,
   detectPatterns: detectTSPatterns,
+  extractCallSites: extractCallSitesTS,
   extensions: ['.tsx'],
 };

package/lib/external/mcp/McpServer.js

@@ -353,6 +353,7 @@ export class McpServer {
       autosnippet_search: (ctx, args) => consolidated.consolidatedSearch(ctx, args),
       autosnippet_knowledge: (ctx, args) => consolidated.consolidatedKnowledge(ctx, args),
       autosnippet_structure: (ctx, args) => consolidated.consolidatedStructure(ctx, args),
+      autosnippet_call_context: (ctx, args) => consolidated.consolidatedCallContext(ctx, args),
       autosnippet_graph: (ctx, args) => consolidated.consolidatedGraph(ctx, args),
       autosnippet_guard: (ctx, args) => consolidated.consolidatedGuard(ctx, args),
       autosnippet_submit_knowledge: (ctx, args) => consolidated.enhancedSubmitKnowledge(ctx, args),

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

@@ -551,6 +551,20 @@ function summarizeEntityGraph(codeEntityResult) {
   };
 }
 
+/**
+ * 压缩 Call Graph 结果
+ * @param {object|null} callGraphResult — CodeEntityGraph.populateCallGraph() 返回值
+ * @returns {object|null}
+ */
+function summarizeCallGraph(callGraphResult) {
+  if (!callGraphResult) return null;
+  return {
+    methodEntities: callGraphResult.entitiesUpserted || 0,
+    callEdges: callGraphResult.edgesCreated || 0,
+    durationMs: callGraphResult.durationMs || 0,
+  };
+}
+
 /**
  * 压缩 Guard 审计结果
  */
@@ -673,6 +687,7 @@ export function buildMissionBriefing({
   projectMeta,
   astData,
   codeEntityResult,
+  callGraphResult,
   depGraphData,
   guardAudit,
   targets,
@@ -680,6 +695,7 @@ export function buildMissionBriefing({
   session,
   languageExtension,  // §7.1: 语言扩展（反模式、Guard 规则、Agent 注意事项）
   incrementalPlan,    // §7.3: 增量 Bootstrap 评估结果
+  languageStats,      // §7.4: 完整语言分布统计
 }) {
   const scheduler = new TierScheduler();
 
@@ -720,6 +736,8 @@ export function buildMissionBriefing({
 
     codeEntityGraph: summarizeEntityGraph(codeEntityResult),
 
+    callGraph: summarizeCallGraph(callGraphResult),
+
     dependencyGraph: depGraphData
       ? {
           nodes: (depGraphData.nodes || []).map((n) => ({
@@ -750,6 +768,9 @@ export function buildMissionBriefing({
       example,
     },
 
+    // 完整语言统计（按文件扩展名计数）
+    languageStats: languageStats || null,
+
     executionPlan: buildExecutionPlan(activeDimensions),
 
     session: session.toJSON(),

package/lib/external/mcp/handlers/bootstrap/pipeline/EpisodicMemory.js

@@ -133,10 +133,10 @@ export class EpisodicMemory {
    */
   storeDimensionReport(dimId, report) {
     // findings 统一形状: { finding: string, evidence: string, importance: number }
-    // 源头 buildAnalysisArtifact() 和 ActiveContext.distill() 已保证一致
+    // P0 Fix: evidence 可能是 array/object，强制 string
     const findings = (report.findings || []).map((f) => ({
       finding: f.finding || '',
-      evidence: f.evidence || '',
+      evidence: typeof f.evidence === 'string' ? f.evidence : Array.isArray(f.evidence) ? f.evidence.join(', ') : f.evidence ? String(f.evidence) : '',
       importance: f.importance || 5,
     }));
 
@@ -154,7 +154,8 @@ export class EpisodicMemory {
     // 自动提取文件级 Evidence
     for (const f of findings) {
       if (f.evidence) {
-        const filePath = f.evidence.split(':')[0]; // "file.m:123" → "file.m"
+        const ev = typeof f.evidence === 'string' ? f.evidence : String(f.evidence);
+        const filePath = ev.split(':')[0]; // "file.m:123" → "file.m"
         this.addEvidence(filePath, {
           dimId,
           finding: f.finding,
@@ -418,7 +419,7 @@ export class EpisodicMemory {
       if ((!findings || findings.length === 0) && report.workingMemoryDistilled?.keyFindings) {
         findings = report.workingMemoryDistilled.keyFindings.map((f) => ({
           finding: f.finding || '',
-          evidence: f.evidence || '',
+          evidence: typeof f.evidence === 'string' ? f.evidence : Array.isArray(f.evidence) ? f.evidence.join(', ') : f.evidence ? String(f.evidence) : '',
           importance: f.importance || 5,
         }));
       }

package/lib/external/mcp/handlers/bootstrap/pipeline/dimension-configs.js

@@ -115,7 +115,8 @@ export function buildTierReflection(tierIndex, tierResults, sessionStore) {
   for (const f of allFindings) {
     // 统计文件引用频率
     if (f.evidence) {
-      const file = f.evidence.split(':')[0];
+      const ev = typeof f.evidence === 'string' ? f.evidence : String(f.evidence);
+      const file = ev.split(':')[0];
       if (file) {
         fileMentions[file] = (fileMentions[file] || 0) + 1;
       }

package/lib/external/mcp/handlers/bootstrap/pipeline/orchestrator.js

@@ -594,17 +594,55 @@ export async function fillDimensionsV3(fillContext) {
         producerResult,
       };
 
+      // v5.1: 当 analysisText 过短（force-exit 时 AI 仅输出 digest 被清洗后仅剩 50-80 chars）
+      // 但有足够的结构化发现时，从 findings 合成补充文本，避免 Producer 被 100 char 门控拦截
+      if (needsCandidates && analysisReport.analysisText.length < 100) {
+        const findings = analysisReport.findings || [];
+        if (findings.length >= 3) {
+          const dimLabel = dimConfig.label || dimId;
+          const synthesized = [
+            `## ${dimLabel}`,
+            '',
+            analysisReport.analysisText.trim(),
+            '',
+            '### 关键发现',
+            '',
+            ...findings.slice(0, 10).map((f, i) => {
+              const text = typeof f === 'string' ? f : f.finding;
+              return `${i + 1}. ${text}`;
+            }),
+          ];
+          // 追加探索记录 (如果有)
+          const dimReport = sessionStore.getDimensionReport(dimId);
+          const memDistilled = dimReport?.workingMemoryDistilled;
+          if (memDistilled?.toolCallSummary?.length > 0) {
+            synthesized.push('', '### 探索记录', '');
+            for (const s of memDistilled.toolCallSummary.slice(0, 10)) {
+              synthesized.push(`- ${s}`);
+            }
+          }
+          const originalLen = analysisReport.analysisText.length;
+          analysisReport.analysisText = synthesized.join('\n');
+          logger.info(
+            `[Bootstrap-v3] analysisText 补强 "${dimId}": ${originalLen} → ${analysisReport.analysisText.length} chars ` +
+            `(from ${findings.length} findings)`
+          );
+        }
+      }
+
       if (needsCandidates && analysisReport.analysisText.length >= 100) {
         try {
           // v5.0: 为 Producer 创建独立作用域
           const producerScopeId = `${dimId}:producer`;
           memoryCoordinator.createDimensionScope(producerScopeId);
 
+          const producerPromise = producerAgent.produce(analysisReport, dimConfig, projectInfo, {
+            sessionId,
+            memoryCoordinator,
+          });
+
           producerResult = await Promise.race([
-            producerAgent.produce(analysisReport, dimConfig, projectInfo, {
-              sessionId,
-              memoryCoordinator,
-            }),
+            producerPromise,
             new Promise((_, reject) =>
               setTimeout(() => reject(new Error(`Producer timeout for "${dimId}"`)), 180_000)
             ),
@@ -621,6 +659,32 @@ export async function fillDimensionsV3(fillContext) {
             `[Bootstrap-v3] Producer "${dimId}" failed: ${producerErr.message} — Analyst result preserved for Skill generation`
           );
           candidateResults.errors.push({ dimId, error: `Producer: ${producerErr.message}` });
+
+          // v5.1: 超时后异步监听实际结果，避免 ghost candidates 永远不被计数
+          if (producerErr.message.includes('timeout')) {
+            const dimIdRef = dimId;
+            // producerPromise 仍在后台执行 — 监听完成后更新统计
+            // biome-ignore lint: 故意 fire-and-forget
+            producerPromise
+              ?.then((actualResult) => {
+                const count = actualResult?.candidateCount || 0;
+                if (count > 0) {
+                  logger.info(
+                    `[Bootstrap-v3] Producer "${dimIdRef}" completed post-timeout: ${count} candidates (ghost → reconciled)`
+                  );
+                  if (dimensionStats[dimIdRef]) {
+                    dimensionStats[dimIdRef].candidateCount = count;
+                  }
+                  candidateResults.created += count;
+                  dimensionCandidates[dimIdRef].producerResult = actualResult;
+                }
+              })
+              .catch((finalErr) => {
+                logger.warn(
+                  `[Bootstrap-v3] Producer "${dimIdRef}" also failed post-timeout: ${finalErr.message}`
+                );
+              });
+          }
         }
       }
 
@@ -656,6 +720,8 @@ export async function fillDimensionsV3(fillContext) {
         type: needsCandidates ? 'candidate' : 'skill',
         extracted: producerResult.candidateCount,
         created: producerResult.candidateCount,
+        // v5.1: 标记 Skill 待生成，Dashboard 可据此避免显示 "无匹配内容"
+        skillPending: dimConfig.skillWorthy && producerResult.candidateCount === 0,
         status: 'v3-complete',
         durationMs: Date.now() - dimStartTime,
         toolCallCount:

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

@@ -271,6 +271,91 @@ export async function runPhase1_6_EntityGraph(astProjectSummary, projectRoot, co
 
 // ── Phase 2: 依赖关系 ──────────────────────────────────────
 
+/**
+ * Phase 1.7: 跨文件调用图分析 (Phase 5)
+ *
+ * 从 AST 的 callSites 构建全局调用图并写入 CodeEntityGraph。
+ *
+ * @param {object|null} astProjectSummary — AST 分析结果 (含 fileSummaries[].callSites)
+ * @param {string} projectRoot
+ * @param {object} container — ServiceContainer
+ * @param {object} logger
+ * @param {object} [incrementalOpts] — 增量分析选项
+ * @param {string[]} [incrementalOpts.changedFiles] — 变更文件的相对路径
+ * @returns {Promise<{ callGraphResult: object|null, warnings: string[] }>}
+ */
+export async function runPhase1_7_CallGraph(astProjectSummary, projectRoot, container, logger, incrementalOpts = null) {
+  const warnings = [];
+  let callGraphResult = null;
+
+  if (!astProjectSummary?.fileSummaries?.length) {
+    return { callGraphResult, warnings };
+  }
+
+  // 检查是否有 callSites 数据 (Phase 5 提取)
+  const hasCallSites = astProjectSummary.fileSummaries.some(
+    (f) => f.callSites && f.callSites.length > 0
+  );
+  if (!hasCallSites) {
+    logger.info('[Bootstrap] Call Graph skipped: no call sites extracted');
+    return { callGraphResult, warnings };
+  }
+
+  try {
+    const { CallGraphAnalyzer } = await import('../../../../../core/analysis/CallGraphAnalyzer.js');
+    const { CodeEntityGraph } = await import('../../../../../service/knowledge/CodeEntityGraph.js');
+
+    const analyzer = new CallGraphAnalyzer(projectRoot);
+    const changedFiles = incrementalOpts?.changedFiles;
+    const isIncremental = changedFiles?.length > 0 && changedFiles.length <= 10;
+
+    // Phase 5 分析 (带超时保护 + 渐进式 partial result)
+    const result = isIncremental
+      ? await analyzer.analyzeIncremental(astProjectSummary, changedFiles, {
+          timeout: 15_000,
+          maxCallSitesPerFile: 500,
+          minConfidence: 0.5,
+        })
+      : await analyzer.analyze(astProjectSummary, {
+          timeout: 15_000,
+          maxCallSitesPerFile: 500,
+          minConfidence: 0.5,
+        });
+
+    // 写入 CodeEntityGraph
+    const db = container.get('database');
+    if (db && result && result.callEdges.length > 0) {
+      const ceg = new CodeEntityGraph(db, { projectRoot });
+
+      // 增量模式: 先删除变更文件的旧边
+      if (isIncremental) {
+        ceg.clearCallGraphForFiles(changedFiles);
+      }
+
+      callGraphResult = ceg.populateCallGraph(result.callEdges, result.dataFlowEdges);
+
+      const partialTag = result.stats.partial ? ' [partial]' : '';
+      const incrTag = isIncremental ? ' [incremental]' : '';
+      logger.info(
+        `[Bootstrap] Call Graph${incrTag}${partialTag}: ${result.callEdges.length} call edges, ` +
+        `${result.dataFlowEdges.length} data flow edges, ` +
+        `resolution rate: ${(result.stats.resolvedRate * 100).toFixed(1)}%`
+      );
+    } else if (result) {
+      logger.info(
+        `[Bootstrap] Call Graph: ${result.stats.totalCallSites} call sites, 0 resolved edges`
+      );
+    }
+  } catch (e) {
+    logger.warn(`[Bootstrap] Call Graph failed (degraded): ${e.message}`);
+    warnings.push(`Call Graph failed: ${e.message}`);
+  }
+
+  return { callGraphResult, warnings };
+}
+
+// ── Phase 2: 依赖关系 ──────────────────────────────────────
+
 /**
  * Phase 2: 获取依赖图并写入 knowledge_edges
  *
@@ -598,7 +683,15 @@ export async function runAllPhases(projectRoot, ctx, options = {}) {
     phase1_5.astProjectSummary, projectRoot, ctx.container, ctx.logger
   );
   warnings.push(...phase1_6.warnings);
-  if (report) report.phases.entityGraph = { entityCount: phase1_6.codeEntityResult?.entities?.length || 0, ms: Date.now() - p16Start };
+  if (report) report.phases.entityGraph = { entityCount: phase1_6.codeEntityResult?.entitiesUpserted || 0, edgeCount: phase1_6.codeEntityResult?.edgesCreated || 0, ms: Date.now() - p16Start };
+
+  // ── Phase 1.7: Call Graph (Phase 5) ──
+  const p17Start = Date.now();
+  const phase1_7 = await runPhase1_7_CallGraph(
+    phase1_5.astProjectSummary, projectRoot, ctx.container, ctx.logger
+  );
+  warnings.push(...phase1_7.warnings);
+  if (report) report.phases.callGraph = { result: phase1_7.callGraphResult, ms: Date.now() - p17Start };
 
   // ── Phase 2: 依赖图 ──
   const p2Start = Date.now();
@@ -659,6 +752,7 @@ export async function runAllPhases(projectRoot, ctx, options = {}) {
     astProjectSummary: phase1_5.astProjectSummary,
     astContext: phase1_5.astContext,
     codeEntityResult: phase1_6.codeEntityResult,
+    callGraphResult: phase1_7.callGraphResult,
     depGraphData: phase2.depGraphData,
     depEdgesWritten: phase2.depEdgesWritten,
     guardAudit: finalGuardAudit,