autosnippet 3.2.7 → 3.2.9

package/lib/service/cursor/CursorDeliveryPipeline.js

@@ -35,11 +35,12 @@ export class CursorDeliveryPipeline {
    * @param {string} [options.projectName] - 项目名称
    * @param {Object} [options.logger] - 日志器
    */
-  constructor({ knowledgeService, projectRoot, projectName, logger }) {
+  constructor({ knowledgeService, projectRoot, projectName, logger, database }) {
     this.knowledgeService = knowledgeService;
     this.projectRoot = projectRoot;
     this.projectName = projectName || this._inferProjectName(projectRoot);
     this.logger = logger || console;
+    this.database = database || null;
 
     // 子模块
     this.compressor = new KnowledgeCompressor();
@@ -87,6 +88,18 @@ export class CursorDeliveryPipeline {
       const channelB = this._generateChannelB(patterns, facts);
       stats.channelB = channelB;
 
+      // ── Channel B+: Call Graph Architecture Rules (Phase 5.2) ──
+      const archResult = this._generateCallGraphArchitectureRules();
+      if (archResult) {
+        stats.channelB.topicCount++;
+        stats.channelB.totalTokens += archResult.tokensUsed;
+        stats.channelB.topics['call-architecture'] = {
+          patternsCount: archResult.insightsCount,
+          factsCount: 0,
+          tokensUsed: archResult.tokensUsed,
+        };
+      }
+
       // ── Channel C: Skills Sync ──
       const channelC = await this._generateChannelC();
       stats.channelC = channelC;
@@ -326,6 +339,159 @@ export class CursorDeliveryPipeline {
     return result;
   }
 
+  /**
+   * Channel B+ — Call Graph Architecture Rules (Phase 5.2)
+   * 从调用图拓扑分析架构分层，生成 architecture smart rule
+   * @private
+   * @returns {{ insightsCount: number, tokensUsed: number, filePath: string }|null}
+   */
+  _generateCallGraphArchitectureRules() {
+    if (!this.database) return null;
+
+    try {
+      const db = typeof this.database.getDb === 'function' ? this.database.getDb() : this.database;
+
+      // 查询调用边中的跨目录调用模式
+      const callEdges = db.prepare(
+        `SELECT from_id, to_id, metadata_json FROM knowledge_edges
+         WHERE relation = 'calls' AND metadata_json LIKE '%phase5%'`
+      ).all();
+
+      if (!callEdges || callEdges.length < 5) return null;
+
+      // 提取 caller/callee 对应的文件路径
+      const entityFiles = new Map();
+      const entities = db.prepare(
+        `SELECT entity_id, file_path FROM code_entities WHERE entity_type = 'method'`
+      ).all();
+      for (const e of entities) {
+        entityFiles.set(e.entity_id, e.file_path);
+      }
+
+      // 构建目录级调用矩阵
+      const dirCalls = new Map(); // 'src/controllers' → Map('src/services' → count)
+      for (const edge of callEdges) {
+        const callerFile = entityFiles.get(edge.from_id);
+        const calleeFile = entityFiles.get(edge.to_id);
+        if (!callerFile || !calleeFile || callerFile === calleeFile) continue;
+
+        const callerDir = this._extractLayerDir(callerFile);
+        const calleeDir = this._extractLayerDir(calleeFile);
+        if (!callerDir || !calleeDir || callerDir === calleeDir) continue;
+
+        if (!dirCalls.has(callerDir)) dirCalls.set(callerDir, new Map());
+        const targets = dirCalls.get(callerDir);
+        targets.set(calleeDir, (targets.get(calleeDir) || 0) + 1);
+      }
+
+      if (dirCalls.size === 0) return null;
+
+      // 检测架构层: 入度高(被调用多)的目录是底层服务, 出度高(调用多)的是上层
+      const dirInDegree = new Map();
+      const dirOutDegree = new Map();
+      for (const [from, targets] of dirCalls) {
+        for (const [to, count] of targets) {
+          dirOutDegree.set(from, (dirOutDegree.get(from) || 0) + count);
+          dirInDegree.set(to, (dirInDegree.get(to) || 0) + count);
+        }
+      }
+
+      // 生成架构洞察
+      const lines = [];
+      lines.push('## Call Graph Architecture');
+      lines.push('');
+
+      // 分层推断: 按 (inDegree - outDegree) 排序, 值越大 = 越底层
+      const allDirs = new Set([...dirInDegree.keys(), ...dirOutDegree.keys()]);
+      const layers = [...allDirs].map((dir) => ({
+        dir,
+        inDegree: dirInDegree.get(dir) || 0,
+        outDegree: dirOutDegree.get(dir) || 0,
+        layerScore: (dirInDegree.get(dir) || 0) - (dirOutDegree.get(dir) || 0),
+      })).sort((a, b) => b.layerScore - a.layerScore);
+
+      // 分层标签
+      const total = layers.length;
+      let insightsCount = 0;
+
+      if (total >= 2) {
+        lines.push('### Architecture Layers (inferred from call graph)');
+        lines.push('');
+
+        for (let i = 0; i < layers.length && i < 10; i++) {
+          const l = layers[i];
+          let layerLabel;
+          if (i < total * 0.33) layerLabel = '🔽 low-level (service/repository)';
+          else if (i < total * 0.66) layerLabel = '↔️ mid-level (business logic)';
+          else layerLabel = '🔼 high-level (controller/UI)';
+
+          lines.push(`- \`${l.dir}/\` — ${layerLabel} (in:${l.inDegree} out:${l.outDegree})`);
+          insightsCount++;
+        }
+        lines.push('');
+      }
+
+      // 核心调用链
+      const hotPaths = [...dirCalls.entries()]
+        .flatMap(([from, targets]) =>
+          [...targets.entries()].map(([to, count]) => ({ from, to, count }))
+        )
+        .sort((a, b) => b.count - a.count)
+        .slice(0, 8);
+
+      if (hotPaths.length > 0) {
+        lines.push('### Key Call Paths');
+        lines.push('');
+        for (const p of hotPaths) {
+          lines.push(`- \`${p.from}/\` → \`${p.to}/\` (${p.count} calls)`);
+          insightsCount++;
+        }
+        lines.push('');
+      }
+
+      if (insightsCount === 0) return null;
+
+      // 构建 description (用于 smart rule 关联性判断)
+      const dirList = layers.map((l) => l.dir).join(', ');
+      const description = `Architecture layer analysis for ${this.projectName}. ` +
+        `Relevant when editing files in: ${dirList}. ` +
+        `Call graph shows ${callEdges.length} cross-file call relationships.`;
+
+      const body = lines.join('\n');
+      const writeResult = this.rulesGenerator.writeSmartRules('call-architecture', body, description);
+
+      this.logger.info?.(
+        `[CursorDelivery] Channel B+: call-architecture — ${insightsCount} insights → ${writeResult.filePath}`
+      );
+
+      return {
+        insightsCount,
+        tokensUsed: writeResult.tokensUsed,
+        filePath: writeResult.filePath,
+      };
+    } catch (err) {
+      this.logger.warn?.(`[CursorDelivery] Call graph architecture rules failed: ${err.message}`);
+      return null;
+    }
+  }
+
+  /**
+   * 从文件路径中提取层级目录 (第一或第二级有意义的目录)
+   * @private
+   */
+  _extractLayerDir(filePath) {
+    if (!filePath) return null;
+    const parts = filePath.split('/').filter(Boolean);
+    // 跳过 src/ lib/ app/ 等通用前缀
+    const skipPrefixes = new Set(['src', 'lib', 'app', 'pkg', 'internal', 'cmd']);
+    let startIdx = 0;
+    if (parts.length > 1 && skipPrefixes.has(parts[0])) {
+      startIdx = 1;
+    }
+    // 取第一个有意义的目录
+    return parts[startIdx] || parts[0] || null;
+  }
+
   /**
    * Channel C 生成
    * @private

package/lib/service/knowledge/CodeEntityGraph.js

@@ -664,19 +664,281 @@ export class CodeEntityGraph {
       lines.push('');
     }
 
+    // 调用图热路径 (Phase 5)
+    try {
+      const hotCallees = 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 15`
+        )
+        .all();
+
+      if (hotCallees.length > 0) {
+        lines.push('### 调用图热路径 (Call Graph Hot Paths)');
+        for (const row of hotCallees) {
+          // 查找前几个调用者
+          const topCallers = this.db
+            .prepare(
+              `SELECT from_id FROM knowledge_edges
+               WHERE relation = 'calls' AND to_id = ?
+               LIMIT 3`
+            )
+            .all(row.to_id);
+          const callerNames = topCallers.map((c) => `\`${c.from_id}\``).join(', ');
+          lines.push(
+            `- \`${row.to_id}\` ← ${row.call_count} 次调用 (${callerNames}${topCallers.length < row.call_count ? '...' : ''})`
+          );
+        }
+        lines.push('');
+      }
+
+      // 数据流边摘要
+      const dataFlowCount = this.db
+        .prepare(
+          `SELECT COUNT(*) as cnt FROM knowledge_edges WHERE relation = 'data_flow'`
+        )
+        .get();
+
+      if (dataFlowCount?.cnt > 0) {
+        lines.push(`### 数据流`);
+        lines.push(`- 数据流边: ${dataFlowCount.cnt} 条`);
+        lines.push('');
+      }
+    } catch (_e) {
+      // 调用图数据可能尚未填充, 静默跳过
+    }
+
     return lines.join('\n');
   }
 
+  // ────────────────────────────────────────────
+  // Public API — Phase 5: 调用图
+  // ────────────────────────────────────────────
+
+  /**
+   * 从解析后的调用边填充图谱 (Phase 5)
+   *
+   * @param {Array<{ caller: string, callee: string, callType: string, resolveMethod: string, line: number, file: string, isAwait: boolean }>} callEdges
+   * @param {Array<{ from: string, to: string, flowType: string, direction: string }>} dataFlowEdges
+   * @returns {GraphPopulateResult}
+   */
+  populateCallGraph(callEdges, dataFlowEdges) {
+    const t0 = Date.now();
+    let edges = 0;
+    let entities = 0;
+
+    const run = this.db.transaction(() => {
+      // ── 注册方法实体 (确保 from/to 的 entity 存在) ──
+      const registeredMethods = new Set();
+      for (const edge of callEdges) {
+        for (const fqn of [edge.caller, edge.callee]) {
+          if (registeredMethods.has(fqn)) continue;
+          registeredMethods.add(fqn);
+
+          const entityId = this._extractEntityId(fqn);
+          const entityName = entityId; // 短名
+          const filePath = fqn.includes('::') ? fqn.split('::')[0] : null;
+
+          this.#upsertEntity({
+            entityId,
+            entityType: 'method',
+            name: entityName,
+            filePath,
+            metadata: { fqn, source: 'phase5-call-graph' },
+          });
+          entities++;
+        }
+      }
+
+      // ── 调用边 (聚合同一 caller-callee 对的多次调用，解决 Issue #4) ──
+      const aggregated = new Map(); // key = "callerId|calleeId" → aggregated metadata
+      for (const edge of callEdges) {
+        const callerId = this._extractEntityId(edge.caller);
+        const calleeId = this._extractEntityId(edge.callee);
+        const key = `${callerId}|${calleeId}`;
+
+        if (aggregated.has(key)) {
+          const agg = aggregated.get(key);
+          agg.callCount++;
+          agg.callSites.push({ line: edge.line, isAwait: edge.isAwait });
+          // 提升权重: direct 优先
+          if (edge.resolveMethod === 'direct') agg.resolveMethod = 'direct';
+          if (edge.isAwait) agg.hasAwait = true;
+        } else {
+          aggregated.set(key, {
+            callerId,
+            calleeId,
+            callType: edge.callType,
+            resolveMethod: edge.resolveMethod,
+            file: edge.file,
+            hasAwait: edge.isAwait,
+            callCount: 1,
+            callSites: [{ line: edge.line, isAwait: edge.isAwait }],
+          });
+        }
+      }
+
+      for (const agg of aggregated.values()) {
+        this.#addEdge(agg.callerId, 'method', agg.calleeId, 'method', 'calls', {
+          weight: agg.resolveMethod === 'direct' ? 1.0 : 0.6,
+          source: 'phase5-call-graph',
+          callType: agg.callType,
+          resolveMethod: agg.resolveMethod,
+          file: agg.file,
+          isAwait: agg.hasAwait,
+          callCount: agg.callCount,
+          callSites: agg.callSites.slice(0, 10), // 最多保留 10 个调用点
+        });
+        edges++;
+      }
+
+      // ── 数据流边 ──
+      for (const flow of dataFlowEdges) {
+        const fromId = this._extractEntityId(flow.from);
+        const toId = this._extractEntityId(flow.to);
+
+        this.#addEdge(fromId, 'method', toId, 'method', 'data_flow', {
+          weight: 0.5,
+          source: 'phase5-data-flow',
+          flowType: flow.flowType,
+          direction: flow.direction,
+        });
+        edges++;
+      }
+    });
+
+    run();
+
+    const result = { entitiesUpserted: entities, edgesCreated: edges, durationMs: Date.now() - t0 };
+    this.log.info(
+      `[CodeEntityGraph] Call graph: ${callEdges.length} call edges, ${dataFlowEdges.length} data flow edges, ${entities} method entities (${result.durationMs}ms)`
+    );
+    return result;
+  }
+
+  /**
+   * 获取调用者 — 谁调用了这个方法？
+   *
+   * @param {string} methodId — "ClassName.methodName" 或 FQN
+   * @param {number} [maxDepth=2]
+   * @returns {Array<{ caller: string, depth: number, callType: string }>}
+   */
+  getCallers(methodId, maxDepth = 2) {
+    const results = [];
+    const visited = new Set();
+    const queue = [{ id: methodId, depth: 0 }];
+
+    while (queue.length > 0) {
+      const { id, depth } = queue.shift();
+      if (depth >= maxDepth || visited.has(id)) continue;
+      visited.add(id);
+
+      const callers = this.stmts.getCallers.all(id);
+
+      for (const row of callers) {
+        const meta = JSON.parse(row.metadata_json || '{}');
+        results.push({
+          caller: row.from_id,
+          depth: depth + 1,
+          callType: meta.callType || 'unknown',
+        });
+        if (depth + 1 < maxDepth) {
+          queue.push({ id: row.from_id, depth: depth + 1 });
+        }
+      }
+    }
+
+    return results;
+  }
+
+  /**
+   * 获取被调用者 — 这个方法调用了谁？
+   *
+   * @param {string} methodId — "ClassName.methodName" 或 FQN
+   * @param {number} [maxDepth=2]
+   * @returns {Array<{ callee: string, depth: number, callType: string }>}
+   */
+  getCallees(methodId, maxDepth = 2) {
+    const results = [];
+    const visited = new Set();
+    const queue = [{ id: methodId, depth: 0 }];
+
+    while (queue.length > 0) {
+      const { id, depth } = queue.shift();
+      if (depth >= maxDepth || visited.has(id)) continue;
+      visited.add(id);
+
+      const callees = this.stmts.getCallees.all(id);
+
+      for (const row of callees) {
+        const meta = JSON.parse(row.metadata_json || '{}');
+        results.push({
+          callee: row.to_id,
+          depth: depth + 1,
+          callType: meta.callType || 'unknown',
+        });
+        if (depth + 1 < maxDepth) {
+          queue.push({ id: row.to_id, depth: depth + 1 });
+        }
+      }
+    }
+
+    return results;
+  }
+
+  /**
+   * 获取方法的 Impact Radius (基于调用图)
+   * — 修改此方法可能影响哪些上游方法？
+   *
+   * @param {string} methodId — "ClassName.methodName"
+   * @returns {{ directCallers: number, transitiveCallers: number, affectedFiles: string[] }}
+   */
+  getCallImpactRadius(methodId) {
+    const callers = this.getCallers(methodId, 3);
+    const affectedFiles = new Set();
+
+    for (const c of callers) {
+      const entity = this.getEntity(c.caller, 'method');
+      if (entity?.filePath) affectedFiles.add(entity.filePath);
+    }
+
+    return {
+      directCallers: callers.filter((c) => c.depth === 1).length,
+      transitiveCallers: callers.length,
+      affectedFiles: [...affectedFiles],
+    };
+  }
+
+  /**
+   * 从 FQN 中提取短 Entity ID
+   *
+   * "src/service/UserService.ts::UserService.getUser" → "UserService.getUser"
+   * "src/utils/helpers.ts::formatDate" → "formatDate"
+   *
+   * @param {string} fqn
+   * @returns {string}
+   */
+  _extractEntityId(fqn) {
+    if (fqn.includes('::')) {
+      return fqn.split('::')[1];
+    }
+    return fqn;
+  }
+
   /**
    * 清除项目的所有代码实体 (重新 populate 前调用)
    */
   clearProject() {
     const run = this.db.transaction(() => {
       this.stmts.clearEntities.run(this.projectRoot);
-      // 只清除 AST 产出的边 (保留 recipe/module 边)
+      // 清除 AST 产出的边 + Phase 5 调用图边 (保留 recipe/module 边)
       this.db
         .prepare(
-          `DELETE FROM knowledge_edges WHERE metadata_json LIKE '%ast-bootstrap%' OR metadata_json LIKE '%ast-pattern-detection%'`
+          `DELETE FROM knowledge_edges WHERE metadata_json LIKE '%ast-bootstrap%' OR metadata_json LIKE '%ast-pattern-detection%' OR metadata_json LIKE '%phase5-%'`
         )
         .run();
     });
@@ -684,6 +946,55 @@ export class CodeEntityGraph {
     this.log.info(`[CodeEntityGraph] Cleared entities for project: ${this.projectRoot}`);
   }
 
+  /**
+   * 增量清除 — 仅删除指定文件的 call graph 边和 method 实体
+   *
+   * @param {string[]} filePaths — 变更文件的相对路径列表
+   * @returns {{ deletedEdges: number, deletedEntities: number }}
+   */
+  clearCallGraphForFiles(filePaths) {
+    if (!filePaths?.length) return { deletedEdges: 0, deletedEntities: 0 };
+
+    let deletedEdges = 0;
+    let deletedEntities = 0;
+
+    const run = this.db.transaction(() => {
+      // 1. 删除相关 call edges (metadata_json 包含 file 字段)
+      const deleteEdgesStmt = this.db.prepare(
+        `DELETE FROM knowledge_edges 
+         WHERE metadata_json LIKE ? 
+         AND (relation = 'calls' OR relation = 'data_flow')
+         AND metadata_json LIKE '%phase5-%'`
+      );
+
+      for (const filePath of filePaths) {
+        // 匹配 metadata 中 "file":"xxx" 字段
+        const result = deleteEdgesStmt.run(`%"file":"${filePath}"%`);
+        deletedEdges += result.changes;
+      }
+
+      // 2. 删除相关 method 实体
+      const deleteEntitiesStmt = this.db.prepare(
+        `DELETE FROM code_entities 
+         WHERE file_path = ? AND entity_type = 'method' AND project_root = ?`
+      );
+
+      for (const filePath of filePaths) {
+        const result = deleteEntitiesStmt.run(filePath, this.projectRoot);
+        deletedEntities += result.changes;
+      }
+    });
+
+    run();
+
+    this.log.info(
+      `[CodeEntityGraph] Incremental clear: ${deletedEdges} edges, ${deletedEntities} entities ` +
+      `for ${filePaths.length} files`
+    );
+
+    return { deletedEdges, deletedEntities };
+  }
+
   // ────────────────────────────────────────────
   // Private — Schema & Statements
   // ────────────────────────────────────────────
@@ -738,6 +1049,19 @@ export class CodeEntityGraph {
         INSERT OR REPLACE INTO knowledge_edges (from_id, from_type, to_id, to_type, relation, weight, metadata_json, created_at, updated_at)
         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
       `),
+      // Phase 5: 调用图查询 (pre-prepared 避免每次调用都创建)
+      getCallers: this.db.prepare(
+        `SELECT from_id, from_type, metadata_json FROM knowledge_edges
+         WHERE to_id = ? AND relation = 'calls'`
+      ),
+      getCallees: this.db.prepare(
+        `SELECT to_id, to_type, metadata_json FROM knowledge_edges
+         WHERE from_id = ? AND relation = 'calls'`
+      ),
+      getEdge: this.db.prepare(
+        `SELECT metadata_json FROM knowledge_edges
+         WHERE from_id = ? AND from_type = ? AND to_id = ? AND to_type = ? AND relation = ?`
+      ),
     };
   }
 
@@ -788,6 +1112,7 @@ export class CodeEntityGraph {
    * 从 AST 数据推断实体类型
    */
   #inferEntityType(name, astSummary) {
+    if (!name) return 'class'; // guard against undefined
     if (astSummary.protocols?.some((p) => p.name === name)) {
       return 'protocol';
     }

package/lib/service/knowledge/KnowledgeService.js

@@ -75,7 +75,7 @@ export class KnowledgeService {
         }
       }
 
-      // ── ConfidenceRouter — 仅标记 auto_approvable，不改变 lifecycle ──
+      // ── ConfidenceRouter — 标记 auto_approvable ──
       if (this._confidenceRouter) {
         const route = await this._confidenceRouter.route(entry);
         if (route.action === 'auto_approve') {
@@ -84,6 +84,10 @@ export class KnowledgeService {
         // reject / pending 都保持 pending 状态，等待人工审核
       }
 
+      // 注意: Bootstrap 候选保持 pending 状态，由 Dashboard 审核后发布。
+      // autoApprovable 标记保留，供前端显示「推荐批准」徽章。
+      // CursorDelivery 已支持高置信度 pending 条目的交付。
+
       const saved = await this.repository.create(entry);
 
       // 同步 relations → knowledge_edges