flowmind 1.0.1 → 1.1.0

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/skill-loader.js

@@ -225,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) {
@@ -232,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)
           });
         }
@@ -241,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;
   }
 
   /**

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);

package/package.json

@@ -1,13 +1,15 @@
 {
   "name": "flowmind",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "description": "The AI Agent That Learns How You Work - Stop repeating yourself, FlowMind learns your workflows and applies them automatically.",
   "main": "core/index.js",
   "bin": {
-    "flowmind": "./bin/flowmind.js"
+    "flowmind": "./bin/flowmind.js",
+    "flowmind-mcp": "./mcp/server.js"
   },
   "scripts": {
     "start": "node core/index.js",
+    "mcp": "node mcp/server.js",
     "test": "jest",
     "test:coverage": "jest --coverage",
     "lint": "eslint .",
@@ -21,7 +23,10 @@
     "learning-system",
     "code-review",
     "log-analysis",
-    "devops"
+    "devops",
+    "mcp-server",
+    "claude-integration",
+    "codex-integration"
   ],
   "author": "FlowMind Technologies",
   "license": "MIT",
@@ -36,6 +41,7 @@
   "files": [
     "bin/",
     "core/",
+    "mcp/",
     "skills/",
     "scripts/",
     "templates/",