autosnippet 3.2.6 → 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/task.js

@@ -19,27 +19,35 @@ import { envelope } from '../envelope.js';
 export async function taskHandler(ctx, args) {
   const taskService = ctx.container.get('taskGraphService');
 
+  let result;
   switch (args.operation) {
     // ── Session ──
     case 'prime':
       return _prime(taskService, args);
     // ── Task CRUD ──
     case 'create':
-      return _create(taskService, args);
+      result = await _create(taskService, args);
+      break;
     case 'ready':
       return _ready(taskService, args);
     case 'claim':
-      return _claim(taskService, args);
+      result = await _claim(taskService, args);
+      break;
     case 'close':
-      return _close(ctx, taskService, args);
+      result = await _close(ctx, taskService, args);
+      break;
     case 'fail':
-      return _fail(taskService, args);
+      result = await _fail(taskService, args);
+      break;
     case 'defer':
-      return _defer(taskService, args);
+      result = await _defer(taskService, args);
+      break;
     case 'progress':
-      return _progress(taskService, args);
+      result = await _progress(taskService, args);
+      break;
     case 'decompose':
-      return _decompose(taskService, args);
+      result = await _decompose(taskService, args);
+      break;
     case 'show':
       return _show(taskService, args);
     case 'list':
@@ -54,11 +62,14 @@ export async function taskHandler(ctx, args) {
       return _stats(taskService);
     // ── Decisions ──
     case 'record_decision':
-      return _recordDecision(taskService, args);
+      result = await _recordDecision(taskService, args);
+      break;
     case 'revise_decision':
-      return _reviseDecision(taskService, args);
+      result = await _reviseDecision(taskService, args);
+      break;
     case 'unpin_decision':
-      return _unpinDecision(taskService, args);
+      result = await _unpinDecision(taskService, args);
+      break;
     case 'list_decisions':
       return _listDecisions(taskService);
     default:
@@ -68,6 +79,13 @@ export async function taskHandler(ctx, args) {
         meta: { tool: 'autosnippet_task' },
       });
   }
+
+  // ── 飞书任务进度通知（异步非阻塞）──
+  _notifyTaskProgress(args.operation, args, result).catch((err) => {
+    process.stderr.write(`[MCP/Task] Notify error: ${err?.message}\n`);
+  });
+
+  return result;
 }
 
 // ── create ──
@@ -455,3 +473,157 @@ async function _listDecisions(svc) {
     meta: { tool: 'autosnippet_task' },
   });
 }
+
+// ═══ 飞书任务进度通知（通过 API Server 中转）═══════════════
+//
+// MCP Server 与 API Server 是独立进程。
+// 飞书 WSClient 连接在 API Server 中，因此通知需 HTTP 中转。
+// ═══════════════════════════════════════════════════════════
+
+const PRIORITY_LABELS = ['P0 紧急', 'P1 高', 'P2 中', 'P3 低', 'P4 微'];
+
+/**
+ * 通过 API Server 的 /api/v1/remote/notify 发送飞书通知
+ * @param {string} text
+ * @returns {Promise<boolean>}
+ */
+async function _sendLarkViaApi(text) {
+  try {
+    const port = process.env.PORT || 3000;
+    const resp = await fetch(`http://localhost:${port}/api/v1/remote/notify`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ text }),
+      signal: AbortSignal.timeout(5000),
+    });
+    if (!resp.ok) {
+      process.stderr.write(`[MCP/Task] Lark notify HTTP ${resp.status}\n`);
+      return false;
+    }
+    const body = await resp.json();
+    return body.success === true;
+  } catch (err) {
+    process.stderr.write(`[MCP/Task] Lark notify failed: ${err?.message}\n`);
+    return false;
+  }
+}
+
+/**
+ * 通过 API Server 截取 IDE 窗口截图并发送到飞书
+ * @param {string} [caption] — 可选文字说明
+ * @returns {Promise<boolean>}
+ */
+async function _sendScreenshotViaApi(caption = '') {
+  try {
+    const port = process.env.PORT || 3000;
+    const resp = await fetch(`http://localhost:${port}/api/v1/remote/screenshot`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ caption }),
+      signal: AbortSignal.timeout(15000),
+    });
+    if (!resp.ok) {
+      process.stderr.write(`[MCP/Task] Screenshot HTTP ${resp.status}\n`);
+      return false;
+    }
+    const body = await resp.json();
+    return body.success === true;
+  } catch (err) {
+    process.stderr.write(`[MCP/Task] Screenshot failed: ${err?.message}\n`);
+    return false;
+  }
+}
+
+/**
+ * 根据任务操作向飞书发送进度通知（异步非阻塞）
+ * result 是 envelope() 返回的 { success, data, message, meta }
+ */
+async function _notifyTaskProgress(operation, args, result) {
+  if (!result || result.success === false) return;
+
+  const data = result.data;
+  let text = '';
+
+  switch (operation) {
+    case 'create': {
+      const title = data?.title || args.title || '';
+      const id = data?.id || '';
+      const type = data?.taskType || args.taskType || 'task';
+      const pri = PRIORITY_LABELS[data?.priority ?? args.priority ?? 2] || 'P2';
+      const dup = result.message?.includes('Duplicate') || result.message?.startsWith('⚠') ? ' (重复)' : '';
+      text = `📋 新任务${dup}: ${id}\n${title}\n类型: ${type} | ${pri}`;
+      break;
+    }
+    case 'claim': {
+      const id = data?.id || args.id;
+      const title = data?.title || '';
+      text = `🔨 开始执行: ${id}\n${title}`;
+      break;
+    }
+    case 'close': {
+      const closed = data?.closed || data;
+      const title = closed?.title || '';
+      const id = closed?.id || args.id;
+      const reason = closed?.closeReason || args.reason || '';
+      const readyCount = data?.newlyReady?.length || 0;
+      const readyInfo = readyCount > 0 ? `\n→ ${readyCount} 个任务新就绪` : '';
+      text = `✅ 完成: ${id}\n${title}\n原因: ${reason}${readyInfo}`;
+      break;
+    }
+    case 'fail': {
+      const title = data?.title || '';
+      const id = data?.id || args.id;
+      const reason = data?.lastFailReason || args.reason || '未知';
+      const count = data?.failCount || 0;
+      text = `❌ 失败: ${id}\n${title}\n原因: ${reason}${count > 1 ? ` (第${count}次)` : ''}`;
+      break;
+    }
+    case 'defer': {
+      const id = data?.id || args.id;
+      const title = data?.title || '';
+      text = `⏸️ 暂缓: ${id} — ${title}`;
+      break;
+    }
+    case 'progress': {
+      const id = data?.id || args.id;
+      const note = args.reason || args.description || '';
+      text = note
+        ? `📝 进度: ${id}\n${note.slice(0, 200)}`
+        : `📝 进度: ${id}`;
+      break;
+    }
+    case 'decompose': {
+      const epicId = args.id;
+      const count = Array.isArray(data) ? data.length : 0;
+      const subTitles = Array.isArray(data)
+        ? data.slice(0, 5).map((t, i) => `  ${i + 1}. ${t.title || t.id}`).join('\n')
+        : '';
+      text = `📂 拆解: ${epicId} → ${count} 个子任务${subTitles ? '\n' + subTitles : ''}`;
+      break;
+    }
+    case 'record_decision': {
+      const title = data?.title || args.title || '';
+      text = `📌 决策: ${title}`;
+      break;
+    }
+    case 'revise_decision': {
+      const oldId = data?.superseded || args.id;
+      const newTitle = data?.newDecision?.title || args.title;
+      text = `🔄 决策更新: ${oldId} → ${newTitle}`;
+      break;
+    }
+    case 'unpin_decision': {
+      const id = data?.id || args.id;
+      text = `🔓 决策取消: ${id}`;
+      break;
+    }
+    default:
+      return;
+  }
+
+  if (text) {
+    await _sendLarkViaApi(text);
+    // 发送文字通知后，附带 IDE 窗口截图
+    await _sendScreenshotViaApi();
+  }
+}

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/HttpServer.js

@@ -38,6 +38,7 @@ import skillsRouter from './routes/skills.js';
 import snippetRouter from './routes/snippets.js';
 import spmRouter from './routes/spm.js';
 import taskRouter from './routes/task.js';
+import remoteRouter from './routes/remote.js';
 import violationsRouter from './routes/violations.js';
 import wikiRouter from './routes/wiki.js';
 
@@ -302,6 +303,9 @@ export class HttpServer {
     // Wiki 路由
     this.app.use(`${apiPrefix}/wiki`, wikiRouter);
 
+    // Remote 路由（飞书 Bot → IDE 远程指令桥接）
+    this.app.use(`${apiPrefix}/remote`, remoteRouter);
+
     // 根路径 — 返回 API 元信息（避免外部探测产生无意义 404）
     this.app.all('/', (req, res) => {
       res.json({