autosnippet 2.6.0 → 2.7.0

package/lib/external/ai/providers/OpenAiProvider.js

@@ -1,6 +1,10 @@
 /**
  * OpenAiProvider - OpenAI / DeepSeek / Ollama 兼容提供商
  * 使用标准 OpenAI Chat Completions API
+ *
+ * v2: 支持原生 Function Calling（结构化工具调用）
+ *     - 使用 Chat Completions API 的 tools + tool_choice 参数
+ *     - 兼容 DeepSeek / Ollama 等 OpenAI-compatible API
  */
 
 import { AiProvider } from '../AiProvider.js';
@@ -19,6 +23,14 @@ export class OpenAiProvider extends AiProvider {
     this.logger = Logger.getInstance();
   }
 
+  /**
+   * 是否支持原生结构化函数调用
+   * OpenAI / DeepSeek Chat Completions API 均支持
+   */
+  get supportsNativeToolCalling() {
+    return true;
+  }
+
   async chat(prompt, context = {}) {
     return this._withRetry(async () => {
       const { history = [], temperature = 0.7, maxTokens = 4096 } = context;
@@ -41,6 +53,125 @@ export class OpenAiProvider extends AiProvider {
     });
   }
 
+  /**
+   * 带工具声明的结构化对话 — OpenAI Chat Completions Function Calling
+   *
+   * 接受统一消息格式，内部转换为 OpenAI Chat Completions 消息格式。
+   * 兼容 DeepSeek / Ollama 等 OpenAI-Compatible API。
+   *
+   * @param {string} prompt — fallback prompt
+   * @param {object} opts — 统一参数
+   * @returns {Promise<{text: string|null, functionCalls: Array<{id, name, args}>|null}>}
+   */
+  async chatWithTools(prompt, opts = {}) {
+    return this._withRetry(async () => {
+      const {
+        messages: unifiedMessages,
+        toolSchemas,
+        toolChoice = 'auto',
+        systemPrompt,
+        temperature = 0.7,
+        maxTokens = 4096,
+      } = opts;
+
+      // 统一消息 → OpenAI Chat Completions messages
+      const messages = [];
+      if (systemPrompt) {
+        messages.push({ role: 'system', content: systemPrompt });
+      }
+
+      const srcMessages = unifiedMessages?.length > 0
+        ? unifiedMessages
+        : [{ role: 'user', content: prompt }];
+
+      for (const msg of srcMessages) {
+        if (msg.role === 'user') {
+          messages.push({ role: 'user', content: msg.content });
+        } else if (msg.role === 'assistant') {
+          const m = { role: 'assistant', content: msg.content || null };
+          if (msg.toolCalls?.length > 0) {
+            m.tool_calls = msg.toolCalls.map(tc => ({
+              id: tc.id,
+              type: 'function',
+              function: {
+                name: tc.name,
+                arguments: JSON.stringify(tc.args || {}),
+              },
+            }));
+          }
+          messages.push(m);
+        } else if (msg.role === 'tool') {
+          messages.push({
+            role: 'tool',
+            tool_call_id: msg.toolCallId,
+            content: msg.content || '',
+          });
+        }
+      }
+
+      const body = {
+        model: this.model,
+        messages,
+        temperature,
+        max_tokens: maxTokens,
+      };
+
+      // 标准 tool schemas → OpenAI tools format
+      if (toolSchemas?.length > 0) {
+        body.tools = toolSchemas.map(s => ({
+          type: 'function',
+          function: {
+            name: s.name,
+            description: s.description || '',
+            parameters: s.parameters || { type: 'object', properties: {} },
+          },
+        }));
+      }
+
+      // toolChoice → OpenAI tool_choice
+      if (toolChoice === 'required') body.tool_choice = 'required';
+      else if (toolChoice === 'none') body.tool_choice = 'none';
+      else body.tool_choice = 'auto';
+
+      const data = await this._post(`${this.baseUrl}/chat/completions`, body);
+      return this.#parseToolResponse(data);
+    });
+  }
+
+  /**
+   * 解析 OpenAI Chat Completions 响应 — 提取 tool_calls 或 text
+   *
+   * OpenAI 返回格式:
+   *   choices[0].message.tool_calls[]: { id, type: 'function', function: { name, arguments(JSON str) } }
+   */
+  #parseToolResponse(data) {
+    const choice = data?.choices?.[0];
+    if (!choice) return { text: '', functionCalls: null };
+
+    const message = choice.message;
+    const text = message?.content || null;
+
+    if (message?.tool_calls?.length > 0) {
+      const functionCalls = message.tool_calls
+        .filter(tc => tc.type === 'function')
+        .map(tc => ({
+          id: tc.id,
+          name: tc.function.name,
+          args: (() => {
+            try { return JSON.parse(tc.function.arguments || '{}'); }
+            catch { return {}; }
+          })(),
+        }));
+
+      if (functionCalls.length > 0) {
+        this.logger.debug(`[OpenAI] native function calls: ${functionCalls.map(fc => fc.name).join(', ')}`);
+        return { text, functionCalls };
+      }
+    }
+
+    return { text, functionCalls: null };
+  }
+
   async summarize(code) {
     const prompt = `请对以下代码生成结构化摘要，返回 JSON 格式 {title, description, language, patterns: [], keyAPIs: []}:\n\n${code}`;
     const text = await this.chat(prompt, { temperature: 0.3 });

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

@@ -0,0 +1,216 @@
+/**
+ * pipeline/dimension-context.js — 跨维度上下文管理 (v6)
+ *
+ * 在 ChatAgent 按维度分批生产候选时，维护跨维度的上下文:
+ *   - 项目基础信息 (不变)
+ *   - 已完成维度的 DimensionDigest (累积)
+ *   - 已提交候选的摘要列表 (累积)
+ *
+ * 确保每个维度的 ChatAgent 都能看到前序维度的分析结论，
+ * 实现跨维度透明互补。
+ *
+ * @module pipeline/dimension-context
+ */
+
+/**
+ * DimensionContext — 跨维度上下文容器
+ *
+ * 在单次 bootstrap 会话中创建一次，按维度累积上下文。
+ */
+export class DimensionContext {
+  /**
+   * @param {object} projectContext — 项目基础信息 (全程不变)
+   * @param {string} projectContext.projectName
+   * @param {string} projectContext.primaryLang
+   * @param {number} projectContext.fileCount
+   * @param {number} projectContext.targetCount
+   * @param {string[]} projectContext.modules
+   * @param {object} [projectContext.depGraph]
+   * @param {object} [projectContext.astMetrics]
+   * @param {object} [projectContext.guardSummary]
+   */
+  constructor(projectContext) {
+    /** @type {object} 项目基础信息 */
+    this.projectContext = projectContext;
+
+    /** @type {Map<string, DimensionDigest>} 已完成维度的摘要 */
+    this.completedDimensions = new Map();
+
+    /** @type {Array<CandidateSummary>} 已提交候选的摘要 */
+    this.submittedCandidates = [];
+  }
+
+  /**
+   * 维度完成后存储其摘要
+   *
+   * @param {string} dimId — 维度 ID
+   * @param {DimensionDigest} digest — 维度分析摘要
+   */
+  addDimensionDigest(dimId, digest) {
+    this.completedDimensions.set(dimId, {
+      ...digest,
+      dimId,
+      completedAt: Date.now(),
+    });
+  }
+
+  /**
+   * 记录已提交的候选
+   *
+   * @param {string} dimId
+   * @param {object} candidateInfo — { title, subTopic, summary }
+   */
+  addSubmittedCandidate(dimId, candidateInfo) {
+    this.submittedCandidates.push({
+      dimId,
+      title: candidateInfo.title || '',
+      subTopic: candidateInfo.subTopic || '',
+      summary: candidateInfo.summary || '',
+    });
+  }
+
+  /**
+   * 构建给 ChatAgent 的上下文快照
+   *
+   * @param {string} currentDimId — 当前维度 ID
+   * @returns {DimensionContextSnapshot}
+   */
+  buildContextForDimension(currentDimId) {
+    const previousDimensions = {};
+    for (const [id, digest] of this.completedDimensions) {
+      previousDimensions[id] = {
+        summary: digest.summary,
+        candidateCount: digest.candidateCount,
+        keyFindings: digest.keyFindings || [],
+        crossRefs: digest.crossRefs || {},
+        gaps: digest.gaps || [],
+        remainingTasks: digest.remainingTasks || [],
+      };
+    }
+
+    return {
+      project: this.projectContext,
+      previousDimensions,
+      existingCandidates: this.submittedCandidates.map(c => ({
+        dimId: c.dimId,
+        title: c.title,
+        subTopic: c.subTopic,
+      })),
+      currentDimension: currentDimId,
+    };
+  }
+
+  /**
+   * 重算某维度时，获取该维度已有候选
+   *
+   * @param {string} dimId
+   * @returns {Array<CandidateSummary>}
+   */
+  getExistingCandidatesForDimension(dimId) {
+    return this.submittedCandidates.filter(c => c.dimId === dimId);
+  }
+
+  /**
+   * 获取所有维度摘要的紧凑文本表示
+   * 用于 ChatAgent prompt 中注入
+   *
+   * @returns {string}
+   */
+  getDigestsSummaryText() {
+    if (this.completedDimensions.size === 0) return '(尚无已完成维度)';
+
+    const lines = [];
+    for (const [id, digest] of this.completedDimensions) {
+      lines.push(`### ${id}`);
+      lines.push(`- 摘要: ${digest.summary || '(无)'}`);
+      lines.push(`- 产出候选: ${digest.candidateCount || 0} 条`);
+      if (digest.keyFindings?.length) {
+        lines.push(`- 关键发现: ${digest.keyFindings.join('; ')}`);
+      }
+      if (digest.crossRefs && Object.keys(digest.crossRefs).length > 0) {
+        for (const [targetDim, suggestion] of Object.entries(digest.crossRefs)) {
+          lines.push(`- → ${targetDim}: ${suggestion}`);
+        }
+      }
+      if (digest.gaps?.length) {
+        lines.push(`- 缺口: ${digest.gaps.join('; ')}`);
+      }
+      if (digest.remainingTasks?.length) {
+        lines.push(`- 遗留任务: ${digest.remainingTasks.map(t => t.signal || t).join('; ')}`);
+      }
+      lines.push('');
+    }
+    return lines.join('\n');
+  }
+
+  /**
+   * 将完整上下文序列化为 JSON (用于断点恢复)
+   * @returns {object}
+   */
+  toJSON() {
+    return {
+      projectContext: this.projectContext,
+      completedDimensions: Object.fromEntries(this.completedDimensions),
+      submittedCandidates: this.submittedCandidates,
+    };
+  }
+
+  /**
+   * 从 JSON 恢复上下文 (断点恢复)
+   * @param {object} json
+   * @returns {DimensionContext}
+   */
+  static fromJSON(json) {
+    const ctx = new DimensionContext(json.projectContext);
+    for (const [id, digest] of Object.entries(json.completedDimensions || {})) {
+      ctx.completedDimensions.set(id, digest);
+    }
+    ctx.submittedCandidates = json.submittedCandidates || [];
+    return ctx;
+  }
+}
+
+/**
+ * 从 ChatAgent 的最终回复中解析 DimensionDigest
+ *
+ * ChatAgent 被要求在回复末尾包含 JSON 格式的 dimensionDigest。
+ * 此函数从自由格式文本中提取该 JSON 块。
+ *
+ * @param {string} reply — ChatAgent 的完整回复文本
+ * @returns {DimensionDigest|null}
+ */
+export function parseDimensionDigest(reply) {
+  if (!reply || typeof reply !== 'string') return null;
+
+  // 尝试匹配 {"dimensionDigest": {...}} 格式
+  const jsonBlockRe = /```(?:json)?\s*\n?\s*(\{[\s\S]*?"dimensionDigest"[\s\S]*?\})\s*\n?\s*```/;
+  let match = reply.match(jsonBlockRe);
+
+  // 备选: 没有 code fence 的裸 JSON
+  if (!match) {
+    const bareRe = /(\{"dimensionDigest"\s*:\s*\{[\s\S]*?\}\s*\})/;
+    match = reply.match(bareRe);
+  }
+
+  if (!match) return null;
+
+  try {
+    const parsed = JSON.parse(match[1]);
+    const digest = parsed.dimensionDigest || parsed;
+
+    // 验证必要字段
+    if (!digest.summary && !digest.candidateCount) return null;
+
+    return {
+      summary: digest.summary || '',
+      candidateCount: digest.candidateCount || 0,
+      candidateTitles: digest.candidateTitles || [],
+      keyFindings: digest.keyFindings || [],
+      crossRefs: digest.crossRefs || {},
+      gaps: digest.gaps || [],
+      remainingTasks: digest.remainingTasks || [],
+    };
+  } catch {
+    return null;
+  }
+}