flowmind 1.0.1 → 1.2.2

package/config/ai-config.example.json

@@ -0,0 +1,64 @@
+{
+  "ai": {
+    "enabled": true,
+    "defaultProvider": "glm",
+    "fallbackToRules": true,
+    "providers": {
+      "openai": {
+        "apiKey": "${OPENAI_API_KEY}",
+        "model": "gpt-4",
+        "temperature": 0.3,
+        "maxTokens": 2000
+      },
+      "anthropic": {
+        "apiKey": "${ANTHROPIC_API_KEY}",
+        "model": "claude-3-sonnet-20240229",
+        "maxTokens": 2000,
+        "temperature": 0.3
+      },
+      "glm": {
+        "apiKey": "${ZHIPU_API_KEY}",
+        "model": "glm-4-flash",
+        "temperature": 0.3,
+        "maxTokens": 2000
+      },
+      "mimo": {
+        "apiKey": "${MIMO_API_KEY}",
+        "model": "mimo-7b",
+        "temperature": 0.3,
+        "maxTokens": 2000
+      },
+      "qwen": {
+        "apiKey": "${DASHSCOPE_API_KEY}",
+        "model": "qwen-turbo",
+        "temperature": 0.3,
+        "maxTokens": 2000
+      },
+      "ernie": {
+        "apiKey": "${BAIDU_API_KEY}",
+        "secretKey": "${BAIDU_SECRET_KEY}",
+        "model": "ernie-4.0-turbo-8k",
+        "temperature": 0.3,
+        "maxTokens": 2000
+      },
+      "deepseek": {
+        "apiKey": "${DEEPSEEK_API_KEY}",
+        "model": "deepseek-chat",
+        "temperature": 0.3,
+        "maxTokens": 2000
+      },
+      "ollama": {
+        "baseUrl": "http://localhost:11434",
+        "model": "llama2",
+        "temperature": 0.3
+      }
+    },
+    "features": {
+      "intentUnderstanding": true,
+      "parameterExtraction": true,
+      "skillSelection": true,
+      "resultSummary": true,
+      "learningFeedback": true
+    }
+  }
+}

package/config/claude-mcp-config.example.json

@@ -0,0 +1,12 @@
+{
+  "mcpServers": {
+    "flowmind": {
+      "command": "node",
+      "args": ["/path/to/flowmind/mcp/server.js"],
+      "env": {
+        "OPENAI_API_KEY": "${OPENAI_API_KEY}",
+        "ANTHROPIC_API_KEY": "${ANTHROPIC_API_KEY}"
+      }
+    }
+  }
+}

package/core/ai/base-model.js

@@ -0,0 +1,70 @@
+/**
+ * Base Model - AI 模型抽象基类
+ * 所有模型 Provider 必须继承此类并实现抽象方法
+ */
+
+class BaseModel {
+  constructor(name, config = {}) {
+    this.name = name;
+    this.config = config;
+    this.initialized = false;
+  }
+
+  /**
+   * 初始化模型
+   * @returns {Promise<void>}
+   */
+  async init() {
+    throw new Error('init() must be implemented by subclass');
+  }
+
+  /**
+   * 发送聊天请求
+   * @param {Array} messages - 消息数组 [{role, content}]
+   * @param {Object} options - 请求选项
+   * @returns {Promise<string>} 模型响应
+   */
+  async chat(messages, options = {}) {
+    throw new Error('chat() must be implemented by subclass');
+  }
+
+  /**
+   * 发送补全请求
+   * @param {string} prompt - 提示词
+   * @param {Object} options - 请求选项
+   * @returns {Promise<string>} 模型响应
+   */
+  async complete(prompt, options = {}) {
+    throw new Error('complete() must be implemented by subclass');
+  }
+
+  /**
+   * 检查模型是否可用
+   * @returns {Promise<boolean>}
+   */
+  async isAvailable() {
+    throw new Error('isAvailable() must be implemented by subclass');
+  }
+
+  /**
+   * 获取模型信息
+   * @returns {Object}
+   */
+  getInfo() {
+    return {
+      name: this.name,
+      provider: this.constructor.name,
+      initialized: this.initialized
+    };
+  }
+
+  /**
+   * 验证配置
+   * @returns {boolean}
+   */
+  validateConfig() {
+    return true;
+  }
+}
+
+module.exports = BaseModel;

package/core/ai/index.js

@@ -0,0 +1,29 @@
+/**
+ * AI Module - AI 模型接入层入口
+ */
+
+const ModelManager = require('./model-manager');
+const BaseModel = require('./base-model');
+const OpenAIProvider = require('./providers/openai');
+const AnthropicProvider = require('./providers/anthropic');
+const OllamaProvider = require('./providers/ollama');
+const GLMProvider = require('./providers/glm');
+const MiMoProvider = require('./providers/mimo');
+const QwenProvider = require('./providers/qwen');
+const ERNIEProvider = require('./providers/ernie');
+const DeepSeekProvider = require('./providers/deepseek');
+const prompts = require('./prompts');
+
+module.exports = {
+  ModelManager,
+  BaseModel,
+  OpenAIProvider,
+  AnthropicProvider,
+  OllamaProvider,
+  GLMProvider,
+  MiMoProvider,
+  QwenProvider,
+  ERNIEProvider,
+  DeepSeekProvider,
+  prompts
+};

package/core/ai/model-manager.js

@@ -0,0 +1,320 @@
+/**
+ * Model Manager - AI 模型管理器
+ * 管理多个模型 Provider，提供统一的调用接口
+ */
+
+const OpenAIProvider = require('./providers/openai');
+const AnthropicProvider = require('./providers/anthropic');
+const OllamaProvider = require('./providers/ollama');
+const GLMProvider = require('./providers/glm');
+const MiMoProvider = require('./providers/mimo');
+const QwenProvider = require('./providers/qwen');
+const ERNIEProvider = require('./providers/ernie');
+const DeepSeekProvider = require('./providers/deepseek');
+const prompts = require('./prompts');
+
+class ModelManager {
+  constructor(config = {}) {
+    this.config = config;
+    this.providers = new Map();
+    this.defaultProvider = config.defaultProvider || 'openai';
+    this.features = {
+      intentUnderstanding: true,
+      parameterExtraction: true,
+      skillSelection: true,
+      resultSummary: true,
+      learningFeedback: true,
+      ...config.features
+    };
+    this.fallbackToRules = config.fallbackToRules !== false;
+    this.initialized = false;
+  }
+
+  /**
+   * 初始化模型管理器
+   */
+  async init() {
+    // 注册内置 Provider
+    this._registerBuiltinProviders();
+
+    // 初始化配置的 Provider
+    const providersConfig = this.config.providers || {};
+    for (const [name, providerConfig] of Object.entries(providersConfig)) {
+      try {
+        await this.initProvider(name, providerConfig);
+      } catch (error) {
+        console.warn(`Failed to initialize provider ${name}: ${error.message}`);
+      }
+    }
+
+    this.initialized = true;
+    return this;
+  }
+
+  /**
+   * 注册内置 Provider
+   * @private
+   */
+  _registerBuiltinProviders() {
+    this.providerFactories = {
+      openai: (config) => new OpenAIProvider(config),
+      anthropic: (config) => new AnthropicProvider(config),
+      ollama: (config) => new OllamaProvider(config),
+      glm: (config) => new GLMProvider(config),
+      mimo: (config) => new MiMoProvider(config),
+      qwen: (config) => new QwenProvider(config),
+      ernie: (config) => new ERNIEProvider(config),
+      deepseek: (config) => new DeepSeekProvider(config)
+    };
+  }
+
+  /**
+   * 初始化指定 Provider
+   */
+  async initProvider(name, config = {}) {
+    const factory = this.providerFactories[name];
+    if (!factory) {
+      throw new Error(`Unknown provider: ${name}`);
+    }
+
+    const provider = factory(config);
+    await provider.init();
+    this.providers.set(name, provider);
+    return provider;
+  }
+
+  /**
+   * 注册自定义 Provider
+   */
+  registerProvider(name, provider) {
+    this.providers.set(name, provider);
+  }
+
+  /**
+   * 获取 Provider
+   */
+  getProvider(name) {
+    return this.providers.get(name || this.defaultProvider);
+  }
+
+  /**
+   * 获取默认 Provider
+   */
+  getDefaultProvider() {
+    const provider = this.getProvider(this.defaultProvider);
+    if (!provider) {
+      // 尝试获取任意可用的 Provider
+      for (const [name, p] of this.providers) {
+        if (p.initialized) return p;
+      }
+      return null;
+    }
+    return provider;
+  }
+
+  /**
+   * 理解用户意图
+   * @param {string} input - 用户输入
+   * @param {Object} context - 上下文
+   * @returns {Promise<Object>} 意图分析结果
+   */
+  async understandIntent(input, context = {}) {
+    if (!this.features.intentUnderstanding) {
+      return null;
+    }
+
+    const provider = this.getDefaultProvider();
+    if (!provider) {
+      return this._fallback('intentUnderstanding', input, context);
+    }
+
+    try {
+      const messages = [
+        { role: 'system', content: prompts.intent.system },
+        { role: 'user', content: prompts.intent.user(input, context) }
+      ];
+
+      const response = await provider.chat(messages, {
+        responseFormat: { type: 'json_object' }
+      });
+
+      return JSON.parse(response);
+    } catch (error) {
+      console.warn(`AI intent understanding failed: ${error.message}`);
+      return this._fallback('intentUnderstanding', input, context);
+    }
+  }
+
+  /**
+   * 提取参数
+   * @param {string} input - 用户输入
+   * @param {string} skillName - 技能名称
+   * @param {Object} skillSchema - 参数 schema
+   * @returns {Promise<Object>} 提取的参数
+   */
+  async extractParameters(input, skillName, skillSchema = {}) {
+    if (!this.features.parameterExtraction) {
+      return {};
+    }
+
+    const provider = this.getDefaultProvider();
+    if (!provider) {
+      return this._fallback('parameterExtraction', input, { skillName });
+    }
+
+    try {
+      const messages = [
+        { role: 'system', content: prompts.extraction.system },
+        { role: 'user', content: prompts.extraction.user(input, skillName, skillSchema) }
+      ];
+
+      const response = await provider.chat(messages, {
+        responseFormat: { type: 'json_object' }
+      });
+
+      return JSON.parse(response);
+    } catch (error) {
+      console.warn(`AI parameter extraction failed: ${error.message}`);
+      return this._fallback('parameterExtraction', input, { skillName });
+    }
+  }
+
+  /**
+   * 选择技能
+   * @param {string} input - 用户输入
+   * @param {Array} candidates - 候选技能列表
+   * @returns {Promise<Object>} 选择的技能
+   */
+  async selectSkill(input, candidates) {
+    if (!this.features.skillSelection) {
+      return null;
+    }
+
+    const provider = this.getDefaultProvider();
+    if (!provider) {
+      return this._fallback('skillSelection', input, { candidates });
+    }
+
+    try {
+      const messages = [
+        { role: 'system', content: prompts.selection.system },
+        { role: 'user', content: prompts.selection.user(input, candidates) }
+      ];
+
+      const response = await provider.chat(messages, {
+        responseFormat: { type: 'json_object' }
+      });
+
+      return JSON.parse(response);
+    } catch (error) {
+      console.warn(`AI skill selection failed: ${error.message}`);
+      return this._fallback('skillSelection', input, { candidates });
+    }
+  }
+
+  /**
+   * 生成结果摘要
+   * @param {Object} result - 执行结果
+   * @param {Object} context - 上下文
+   * @returns {Promise<string>} 摘要文本
+   */
+  async summarizeResult(result, context = {}) {
+    if (!this.features.resultSummary) {
+      return null;
+    }
+
+    const provider = this.getDefaultProvider();
+    if (!provider) {
+      return this._fallback('resultSummary', result, context);
+    }
+
+    try {
+      const messages = [
+        { role: 'system', content: prompts.summary.system },
+        { role: 'user', content: prompts.summary.user(result, context) }
+      ];
+
+      return await provider.chat(messages);
+    } catch (error) {
+      console.warn(`AI result summary failed: ${error.message}`);
+      return this._fallback('resultSummary', result, context);
+    }
+  }
+
+  /**
+   * 分析学习反馈
+   * @param {string} input - 用户输入
+   * @param {Object} context - 上下文
+   * @returns {Promise<Object>} 学习分析结果
+   */
+  async analyzeLearningFeedback(input, context = {}) {
+    if (!this.features.learningFeedback) {
+      return null;
+    }
+
+    const provider = this.getDefaultProvider();
+    if (!provider) {
+      return this._fallback('learningFeedback', input, context);
+    }
+
+    try {
+      const messages = [
+        { role: 'system', content: prompts.learning.system },
+        { role: 'user', content: prompts.learning.user(input, context) }
+      ];
+
+      const response = await provider.chat(messages, {
+        responseFormat: { type: 'json_object' }
+      });
+
+      return JSON.parse(response);
+    } catch (error) {
+      console.warn(`AI learning feedback analysis failed: ${error.message}`);
+      return this._fallback('learningFeedback', input, context);
+    }
+  }
+
+  /**
+   * 降级处理
+   * @private
+   */
+  _fallback(feature, input, context) {
+    if (!this.fallbackToRules) {
+      return null;
+    }
+    // 返回 null，让调用方使用规则引擎
+    return null;
+  }
+
+  /**
+   * 检查是否有可用的 Provider
+   */
+  hasAvailableProvider() {
+    for (const [name, provider] of this.providers) {
+      if (provider.initialized) return true;
+    }
+    return false;
+  }
+
+  /**
+   * 获取状态信息
+   */
+  getStatus() {
+    const providers = {};
+    for (const [name, provider] of this.providers) {
+      providers[name] = {
+        initialized: provider.initialized,
+        info: provider.getInfo()
+      };
+    }
+
+    return {
+      initialized: this.initialized,
+      defaultProvider: this.defaultProvider,
+      features: this.features,
+      providers: providers
+    };
+  }
+}
+
+module.exports = ModelManager;

package/core/ai/prompts/extraction.js

@@ -0,0 +1,38 @@
+/**
+ * 参数提取提示词
+ */
+
+module.exports = {
+  system: `你是一个参数提取专家。你的任务是从用户的自然语言输入中提取结构化参数。
+
+你需要返回一个 JSON 对象，包含提取的参数。
+
+常见参数类型：
+- traceId: 链路追踪ID，通常为字母数字组合
+- timeRange: 时间范围，如"最近1小时"、"今天"、"2024-01-01到2024-01-02"
+- keywords: 关键词列表
+- filters: 过滤条件
+- format: 输出格式（table/list/json/detail）
+- limit: 数量限制
+- database: 数据库名称
+- table: 表名
+- sql: SQL语句
+- apiPath: API路径
+- repository: 仓库名称
+- branch: 分支名称
+- filePath: 文件路径
+- serviceName: 服务名称
+- logLevel: 日志级别（error/warn/info/debug）
+
+请只返回 JSON，不要返回其他内容。如果没有找到参数，返回空对象 {}。`,
+
+  user: (input, skillName, skillSchema) => {
+    let prompt = `请从以下输入中提取参数：\n\n输入: "${input}"\n\n技能: ${skillName}`;
+
+    if (skillSchema && Object.keys(skillSchema).length > 0) {
+      prompt += `\n\n参数 Schema:\n${JSON.stringify(skillSchema, null, 2)}`;
+    }
+
+    return prompt;
+  }
+};

package/core/ai/prompts/index.js

@@ -0,0 +1,11 @@
+/**
+ * AI 提示词模板
+ */
+
+module.exports = {
+  intent: require('./intent'),
+  extraction: require('./extraction'),
+  selection: require('./selection'),
+  summary: require('./summary'),
+  learning: require('./learning')
+};

package/core/ai/prompts/intent.js

@@ -0,0 +1,43 @@
+/**
+ * 意图理解提示词
+ */
+
+module.exports = {
+  system: `你是一个意图理解专家。你的任务是分析用户的输入，理解他们的真实意图。
+
+你需要返回一个 JSON 对象，包含以下字段：
+{
+  "intent": "主要意图类型",
+  "action": "具体操作",
+  "entities": ["提取的实体列表"],
+  "confidence": 0.0-1.0,
+  "language": "zh/en"
+}
+
+意图类型包括：
+- query: 查询操作（查询日志、查询数据、查询状态等）
+- analyze: 分析操作（分析日志、分析性能、分析代码等）
+- create: 创建操作（创建文档、创建任务、创建流程等）
+- update: 更新操作（更新配置、更新文档、更新状态等）
+- delete: 删除操作（删除资源、删除配置等）
+- review: 审查操作（代码审查、PR审查、项目审查等）
+- validate: 验证操作（数据验证、逻辑验证、配置验证等）
+- sync: 同步操作（同步文档、同步接口、同步配置等）
+- deploy: 部署操作（部署应用、部署配置等）
+- learn: 学习操作（记住偏好、记录纠正等）
+- help: 帮助操作（查看帮助、查看文档等）
+- unknown: 无法识别的意图
+
+请只返回 JSON，不要返回其他内容。`,
+
+  user: (input, context) => {
+    let prompt = `用户输入: "${input}"`;
+    if (context.previousIntent) {
+      prompt += `\n之前的意图: ${context.previousIntent}`;
+    }
+    if (context.currentSkill) {
+      prompt += `\n当前正在使用的技能: ${context.currentSkill}`;
+    }
+    return prompt;
+  }
+};

package/core/ai/prompts/learning.js

@@ -0,0 +1,46 @@
+/**
+ * 学习反馈提示词
+ */
+
+module.exports = {
+  system: `你是一个学习反馈分析专家。你的任务是分析用户的反馈，提取学习点。
+
+你需要返回一个 JSON 对象：
+{
+  "isLearning": true/false,
+  "learningType": "correction/preference/scene_mapping",
+  "originalInput": "原始输入",
+  "correction": "纠正内容",
+  "preference": "偏好设置",
+  "sceneMapping": {
+    "trigger": "触发条件",
+    "workflow": "工作流步骤"
+  },
+  "confidence": 0.0-1.0
+}
+
+学习类型：
+- correction: 纠正之前的错误（如"不对，应该用表格格式"）
+- preference: 记录用户偏好（如"以后都用中文回复"）
+- scene_mapping: 记录场景到工作流的映射（如"排查问题先查错误日志再查链路"）
+
+识别模式：
+- 纠正模式: "不对"、"错了"、"应该是"、"不要"、"改为"
+- 偏好模式: "以后"、"都用"、"总是"、"默认"
+- 场景模式: "先...再..."、"首先...然后..."、"...的时候...就..."
+
+请只返回 JSON，不要返回其他内容。`,
+
+  user: (input, context) => {
+    let prompt = `用户输入: "${input}"`;
+
+    if (context.previousInteraction) {
+      prompt += `\n之前的交互: ${JSON.stringify(context.previousInteraction)}`;
+    }
+    if (context.currentSkill) {
+      prompt += `\n当前技能: ${context.currentSkill}`;
+    }
+
+    return prompt;
+  }
+};

package/core/ai/prompts/selection.js

@@ -0,0 +1,38 @@
+/**
+ * 技能选择提示词
+ */
+
+module.exports = {
+  system: `你是一个技能选择专家。你的任务是根据用户的输入，从候选技能列表中选择最合适的技能。
+
+你需要返回一个 JSON 对象：
+{
+  "selectedSkill": "选中的技能名称",
+  "confidence": 0.0-1.0,
+  "reason": "选择原因"
+}
+
+选择标准：
+1. 技能的触发词是否匹配用户输入
+2. 技能的描述是否符合用户意图
+3. 技能的参数是否能满足用户需求
+4. 优先选择更具体的技能（如"sls-log-audit"优于"log-audit"）
+
+请只返回 JSON，不要返回其他内容。`,
+
+  user: (input, candidates) => {
+    const candidateList = candidates.map(c => ({
+      name: c.name,
+      description: c.description,
+      triggers: c.triggers,
+      category: c.category
+    }));
+
+    return `用户输入: "${input}"
+
+候选技能列表:
+${JSON.stringify(candidateList, null, 2)}
+
+请选择最合适的技能。`;
+  }
+};