flowmind 1.0.0 → 1.1.0

package/core/ai/providers/qwen.js

@@ -0,0 +1,80 @@
+/**
+ * Qwen Provider - 阿里云通义千问模型接入
+ * 支持 Qwen-Turbo、Qwen-Plus、Qwen-Max 等模型
+ */
+
+const BaseModel = require('../base-model');
+
+class QwenProvider extends BaseModel {
+  constructor(config = {}) {
+    super('qwen', config);
+    this.apiKey = config.apiKey || process.env.DASHSCOPE_API_KEY;
+    this.model = config.model || 'qwen-turbo';
+    this.baseUrl = config.baseUrl || 'https://dashscope.aliyuncs.com/compatible-mode/v1';
+    this.temperature = config.temperature ?? 0.3;
+    this.maxTokens = config.maxTokens ?? 2000;
+  }
+
+  async init() {
+    if (!this.apiKey) {
+      throw new Error('DashScope API key is required. Set DASHSCOPE_API_KEY environment variable or provide in config.');
+    }
+    this.initialized = true;
+  }
+
+  validateConfig() {
+    return !!this.apiKey;
+  }
+
+  async chat(messages, options = {}) {
+    if (!this.initialized) {
+      await this.init();
+    }
+
+    const response = await fetch(`${this.baseUrl}/chat/completions`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${this.apiKey}`
+      },
+      body: JSON.stringify({
+        model: options.model || this.model,
+        messages: messages,
+        temperature: options.temperature ?? this.temperature,
+        max_tokens: options.maxTokens ?? this.maxTokens
+      })
+    });
+
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Qwen API error: ${response.status} - ${error}`);
+    }
+
+    const data = await response.json();
+    return data.choices[0].message.content;
+  }
+
+  async complete(prompt, options = {}) {
+    return this.chat([{ role: 'user', content: prompt }], options);
+  }
+
+  async isAvailable() {
+    try {
+      if (!this.apiKey) return false;
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  getInfo() {
+    return {
+      ...super.getInfo(),
+      model: this.model,
+      baseUrl: this.baseUrl,
+      provider: 'Alibaba Cloud'
+    };
+  }
+}
+
+module.exports = QwenProvider;

package/core/index.js

@@ -8,6 +8,7 @@ const LearningEngine = require('./learning-engine');
 const SceneMatcher = require('./scene-matcher');
 const ConfigManager = require('./config-manager');
 const ComponentRegistry = require('./component-registry');
+const ModelManager = require('./ai/model-manager');
 
 class FlowMind {
   constructor(options = {}) {
@@ -16,6 +17,7 @@ class FlowMind {
     this.matcher = new SceneMatcher(this.config, this.learning);
     this.components = new ComponentRegistry(this.config);
     this.skills = new SkillLoader(this.config, this.learning, this.components);
+    this.ai = new ModelManager(options.ai || {});
     this.initialized = false;
   }
 
@@ -32,6 +34,13 @@ class FlowMind {
     await this.skills.loadAll();
     await this.matcher.loadScenes();
 
+    // Initialize AI model manager
+    try {
+      await this.ai.init();
+    } catch (error) {
+      console.warn(`AI model initialization failed: ${error.message}. Falling back to rule-based engine.`);
+    }
+
     this.initialized = true;
     return this;
   }
@@ -47,32 +56,70 @@ class FlowMind {
     const startTime = Date.now();
 
     try {
-      // 1. Check for learning patterns (corrections, feedback)
-      const learningResult = await this.learning.detectLearning(input, context);
+      // 1. AI Intent Understanding (if available)
+      const intent = await this.ai.understandIntent(input, context);
+
+      // 2. Check for learning patterns (corrections, feedback)
+      // Use AI to analyze learning feedback if available
+      const aiLearningResult = await this.ai.analyzeLearningFeedback(input, context);
+      const learningResult = aiLearningResult?.isLearning
+        ? aiLearningResult
+        : await this.learning.detectLearning(input, context);
       if (learningResult) {
         return this.formatLearningResponse(learningResult);
       }
 
-      // 2. Check scene mappings
-      const sceneMatch = await this.matcher.match(input);
+      // 3. Check scene mappings (with AI intent if available)
+      const sceneMatch = await this.matcher.match(input, intent);
       if (sceneMatch && sceneMatch.confidence >= 0.7) {
         return this.executeSceneWorkflow(sceneMatch, input, context);
       }
 
-      // 3. Select and execute skill
-      const skill = await this.skills.select(input, context);
+      // 4. Select skill (AI-assisted if available)
+      let skill = null;
+      const candidates = await this.skills.getCandidates(input, context);
+
+      if (candidates.length > 0) {
+        // Use AI to select skill if available
+        const aiSelection = await this.ai.selectSkill(input, candidates);
+        if (aiSelection && aiSelection.selectedSkill) {
+          skill = this.skills.get(aiSelection.selectedSkill);
+        }
+      }
+
+      // Fallback to rule-based selection
+      if (!skill) {
+        skill = await this.skills.select(input, context);
+      }
+
       if (!skill) {
         return this.formatError('No matching skill found', input);
       }
 
-      // 4. Execute with learning applied
-      const result = await this.executeWithLearning(skill, input, context);
+      // 5. Extract parameters using AI (if available)
+      const extractedParams = await this.ai.extractParameters(input, skill.name);
+
+      // 6. Execute with learning applied
+      const enhancedContext = {
+        ...context,
+        ...extractedParams,
+        intent: intent
+      };
+      const result = await this.executeWithLearning(skill, input, enhancedContext);
 
-      // 5. Format and return
-      return this.formatResult(result, {
+      // 7. Generate AI summary (if available)
+      const summary = await this.ai.summarizeResult(result, {
+        skill: skill.name,
+        intent: intent
+      });
+
+      // 8. Format and return
+      return this.formatResult(summary || result, {
         skill: skill.name,
         duration: Date.now() - startTime,
-        sceneMatch: sceneMatch
+        sceneMatch: sceneMatch,
+        intent: intent,
+        aiEnhanced: !!summary
       });
 
     } catch (error) {
@@ -205,6 +252,22 @@ class FlowMind {
     return this.components.getStatus();
   }
 
+  /**
+   * Get AI model status
+   * @returns {object}
+   */
+  getAIStatus() {
+    return this.ai.getStatus();
+  }
+
+  /**
+   * Check if AI is available
+   * @returns {boolean}
+   */
+  hasAI() {
+    return this.ai.hasAvailableProvider();
+  }
+
   /**
    * Export learnings
    */

package/core/mcp-compatibility.js

@@ -41,14 +41,14 @@ const McpServerMapping = Object.freeze({
   },
 
   // API Documentation
-  'aomi-yapi-mcp': {
+  'yapi-mcp': {
     type: ComponentType.API_DOC,
     provider: 'yapi',
     description: 'YApi API documentation management'
   },
 
   // Knowledge Base
-  'aomi-yuque-mcp': {
+  'yuque-mcp': {
     type: ComponentType.KNOWLEDGE_BASE,
     provider: 'yuque',
     description: 'Yuque knowledge base management'
@@ -77,8 +77,8 @@ const ProviderToMcp = Object.freeze({
   'databaseManager:aliyun-dms': 'aliyun-dms-mcp-server',
   'databaseQuery:aliyun-rds-query': 'friday-rds-redis-query',
   'redisMonitor:aliyun-redis': 'friday-aliyun-sz-rds-redis',
-  'apiDoc:yapi': 'aomi-yapi-mcp',
-  'knowledgeBase:yuque': 'aomi-yuque-mcp',
+  'apiDoc:yapi': 'yapi-mcp',
+  'knowledgeBase:yuque': 'yuque-mcp',
   'workflow:friday-flow': 'friday-auto-flow',
   'report:friday-report': 'friday-auto-report'
 });

package/core/providers/yapi/yapi-adapter.js

@@ -1,6 +1,6 @@
 /**
  * YApi API Documentation Adapter
- * Wraps the aomi-yapi-mcp MCP server for YApi platform management
+ * Wraps the yapi-mcp MCP server for YApi platform management
  */
 
 const ApiDocAdapter = require('../../adapters/api-doc-adapter');
@@ -24,7 +24,7 @@ class YapiAdapter extends ApiDocAdapter {
   }
 
   get mcpServer() {
-    return 'aomi-yapi-mcp';
+    return 'yapi-mcp';
   }
 
   async searchApis(params) {

package/core/providers/yuque/yuque-adapter.js

@@ -1,6 +1,6 @@
 /**
  * Yuque Knowledge Base Adapter
- * Wraps the aomi-yuque-mcp MCP server for Yuque platform management
+ * Wraps the yuque-mcp MCP server for Yuque platform management
  */
 
 const KnowledgeBaseAdapter = require('../../adapters/knowledge-base-adapter');
@@ -23,7 +23,7 @@ class YuqueAdapter extends KnowledgeBaseAdapter {
   }
 
   get mcpServer() {
-    return 'aomi-yuque-mcp';
+    return 'yuque-mcp';
   }
 
   async getRepos(params) {

package/core/skill-loader.js

@@ -96,10 +96,35 @@ class SkillLoader {
 
     // Parse YAML-like frontmatter
     const lines = frontmatter.split('\n');
+    let currentKey = null;
+    let currentObj = null;
+
     for (const line of lines) {
+      // Top-level key: value
       const match = line.match(/^(\w+):\s*(.+)$/);
       if (match) {
-        definition[match[1]] = match[2].replace(/^["']|["']$/g, '');
+        const key = match[1];
+        const value = match[2].replace(/^["']|["']$/g, '');
+        definition[key] = value;
+        currentKey = key;
+        currentObj = null;
+        continue;
+      }
+
+      // Nested object (e.g., metadata:)
+      const nestedMatch = line.match(/^(\w+):\s*$/);
+      if (nestedMatch) {
+        currentKey = nestedMatch[1];
+        definition[currentKey] = {};
+        currentObj = definition[currentKey];
+        continue;
+      }
+
+      // Nested key: value (indented)
+      const nestedValueMatch = line.match(/^\s+(\w+):\s*(.+)$/);
+      if (nestedValueMatch && currentObj) {
+        currentObj[nestedValueMatch[1]] = nestedValueMatch[2].replace(/^["']|["']$/g, '');
+        continue;
       }
     }
 
@@ -114,7 +139,7 @@ class SkillLoader {
     }
 
     // Extract trigger patterns
-    const triggerMatch = content.match(/## Trigger Conditions\n([\s\S]*?)(?=\n##|$)/);
+    const triggerMatch = content.match(/## Trigger Patterns\n([\s\S]*?)(?=\n##|$)/);
     if (triggerMatch) {
       definition.triggers = this.extractTriggers(triggerMatch[1]);
     }
@@ -200,6 +225,23 @@ class SkillLoader {
    * Select best skill for input
    */
   async select(input, context = {}) {
+    const candidates = await this.getCandidates(input, context);
+
+    if (candidates.length === 0) {
+      return null;
+    }
+
+    // Sort by score (highest first)
+    candidates.sort((a, b) => b.score - a.score);
+
+    return candidates[0].skill;
+  }
+
+  /**
+   * Get candidate skills for input
+   * Returns skills that can handle the input with their scores
+   */
+  async getCandidates(input, context = {}) {
     const candidates = [];
 
     for (const [name, skill] of this.skills) {
@@ -207,7 +249,11 @@ class SkillLoader {
         const canHandle = await skill.canHandle(input, context);
         if (canHandle) {
           candidates.push({
+            name: skill.name,
             skill: skill,
+            description: skill.definition?.description || '',
+            triggers: skill.definition?.triggers || [],
+            category: skill.definition?.category || skill.definition?.metadata?.category || '',
             score: this.calculateSkillScore(skill, input, context)
           });
         }
@@ -216,14 +262,7 @@ class SkillLoader {
       }
     }
 
-    if (candidates.length === 0) {
-      return null;
-    }
-
-    // Sort by score (highest first)
-    candidates.sort((a, b) => b.score - a.score);
-
-    return candidates[0].skill;
+    return candidates;
   }
 
   /**
@@ -266,7 +305,10 @@ class SkillLoader {
     return Array.from(this.skills.values()).map(s => ({
       name: s.name,
       description: s.definition?.description,
-      category: s.definition?.category
+      category: s.definition?.category || s.definition?.metadata?.category,
+      version: s.definition?.version || s.definition?.metadata?.version,
+      author: s.definition?.author || s.definition?.metadata?.author,
+      path: s.path
     }));
   }
 

package/mcp/server.js

@@ -0,0 +1,313 @@
+#!/usr/bin/env node
+
+/**
+ * FlowMind MCP Server
+ * 让 Claude/Codex 可以直接调用 FlowMind 内部流程
+ */
+
+const FlowMind = require('../core');
+
+// MCP Server 实现
+class FlowMindMCPServer {
+  constructor() {
+    this.flowmind = null;
+    this.initialized = false;
+  }
+
+  async init() {
+    if (this.initialized) return;
+
+    this.flowmind = new FlowMind();
+    await this.flowmind.init();
+    this.initialized = true;
+  }
+
+  /**
+   * 获取所有可用工具
+   */
+  getTools() {
+    const skills = this.flowmind.skills.list();
+    const tools = [];
+
+    // 添加核心工具
+    tools.push({
+      name: 'flowmind_process',
+      description: 'Process a request using FlowMind AI agent. This is the main entry point for using FlowMind.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          input: {
+            type: 'string',
+            description: 'The request to process'
+          },
+          context: {
+            type: 'object',
+            description: 'Optional context for the request'
+          }
+        },
+        required: ['input']
+      }
+    });
+
+    tools.push({
+      name: 'flowmind_list_skills',
+      description: 'List all available FlowMind skills',
+      inputSchema: {
+        type: 'object',
+        properties: {}
+      }
+    });
+
+    tools.push({
+      name: 'flowmind_get_skill',
+      description: 'Get detailed information about a specific skill',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          name: {
+            type: 'string',
+            description: 'Skill name'
+          }
+        },
+        required: ['name']
+      }
+    });
+
+    tools.push({
+      name: 'flowmind_ai_status',
+      description: 'Get AI model status and configuration',
+      inputSchema: {
+        type: 'object',
+        properties: {}
+      }
+    });
+
+    tools.push({
+      name: 'flowmind_learning_stats',
+      description: 'Get learning statistics',
+      inputSchema: {
+        type: 'object',
+        properties: {}
+      }
+    });
+
+    // 添加每个技能作为独立工具
+    for (const skill of skills) {
+      tools.push({
+        name: `flowmind_skill_${skill.name}`,
+        description: skill.description || `Execute ${skill.name} skill`,
+        inputSchema: {
+          type: 'object',
+          properties: {
+            input: {
+              type: 'string',
+              description: 'Input for the skill'
+            },
+            context: {
+              type: 'object',
+              description: 'Optional context'
+            }
+          },
+          required: ['input']
+        }
+      });
+    }
+
+    return tools;
+  }
+
+  /**
+   * 调用工具
+   */
+  async callTool(name, args) {
+    await this.init();
+
+    try {
+      // 核心工具
+      if (name === 'flowmind_process') {
+        const result = await this.flowmind.process(args.input, args.context || {});
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify(result, null, 2)
+          }]
+        };
+      }
+
+      if (name === 'flowmind_list_skills') {
+        const skills = this.flowmind.skills.list();
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify({ skills }, null, 2)
+          }]
+        };
+      }
+
+      if (name === 'flowmind_get_skill') {
+        const skill = this.flowmind.skills.get(args.name);
+        if (!skill) {
+          return {
+            content: [{
+              type: 'text',
+              text: JSON.stringify({ error: `Skill not found: ${args.name}` })
+            }],
+            isError: true
+          };
+        }
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify({
+              name: skill.name,
+              description: skill.definition?.description,
+              category: skill.definition?.category,
+              triggers: skill.definition?.triggers,
+              componentDependencies: skill.definition?.componentDependencies
+            }, null, 2)
+          }]
+        };
+      }
+
+      if (name === 'flowmind_ai_status') {
+        const status = this.flowmind.getAIStatus();
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify(status, null, 2)
+          }]
+        };
+      }
+
+      if (name === 'flowmind_learning_stats') {
+        const stats = await this.flowmind.getStats();
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify(stats, null, 2)
+          }]
+        };
+      }
+
+      // 技能工具
+      if (name.startsWith('flowmind_skill_')) {
+        const skillName = name.replace('flowmind_skill_', '');
+        const skill = this.flowmind.skills.get(skillName);
+
+        if (!skill) {
+          return {
+            content: [{
+              type: 'text',
+              text: JSON.stringify({ error: `Skill not found: ${skillName}` })
+            }],
+            isError: true
+          };
+        }
+
+        const result = await this.flowmind.executeWithLearning(skill, args.input, args.context || {});
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify(result, null, 2)
+          }]
+        };
+      }
+
+      return {
+        content: [{
+          type: 'text',
+          text: JSON.stringify({ error: `Unknown tool: ${name}` })
+        }],
+        isError: true
+      };
+
+    } catch (error) {
+      return {
+        content: [{
+          type: 'text',
+          text: JSON.stringify({ error: error.message })
+        }],
+        isError: true
+      };
+    }
+  }
+}
+
+// 启动 MCP Server
+async function main() {
+  const server = new FlowMindMCPServer();
+
+  // 读取 stdin，写入 stdout
+  const readline = require('readline');
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    terminal: false
+  });
+
+  rl.on('line', async (line) => {
+    try {
+      const request = JSON.parse(line);
+      let response;
+
+      if (request.method === 'initialize') {
+        response = {
+          jsonrpc: '2.0',
+          id: request.id,
+          result: {
+            protocolVersion: '2024-11-05',
+            capabilities: {
+              tools: {}
+            },
+            serverInfo: {
+              name: 'flowmind',
+              version: '1.0.1'
+            }
+          }
+        };
+      } else if (request.method === 'tools/list') {
+        await server.init();
+        const tools = server.getTools();
+        response = {
+          jsonrpc: '2.0',
+          id: request.id,
+          result: { tools }
+        };
+      } else if (request.method === 'tools/call') {
+        const result = await server.callTool(request.params.name, request.params.arguments || {});
+        response = {
+          jsonrpc: '2.0',
+          id: request.id,
+          result
+        };
+      } else {
+        response = {
+          jsonrpc: '2.0',
+          id: request.id,
+          error: {
+            code: -32601,
+            message: `Method not found: ${request.method}`
+          }
+        };
+      }
+
+      process.stdout.write(JSON.stringify(response) + '\n');
+    } catch (error) {
+      const response = {
+        jsonrpc: '2.0',
+        id: null,
+        error: {
+          code: -32700,
+          message: 'Parse error'
+        }
+      };
+      process.stdout.write(JSON.stringify(response) + '\n');
+    }
+  });
+
+  // 初始化
+  await server.init();
+  console.error('FlowMind MCP Server started');
+}
+
+main().catch(console.error);