flowmind 1.4.8 → 1.5.1

package/core/learning-engine.js

@@ -36,6 +36,7 @@ class LearningEngine {
     this.writeQueue = new WriteQueue();
     this.records = {};
     this.skillBindings = {};
+    this.resourceBindings = {};
     this.stats = {};
     this.initialized = false;
   }
@@ -55,6 +56,7 @@ class LearningEngine {
 
     // Load existing data
     await this.loadSkillBindings();
+    await this.loadResourceBindings();
     await this.loadStats();
 
     this.initialized = true;
@@ -309,6 +311,172 @@ class LearningEngine {
     return {};
   }
 
+  /**
+   * Save a business/resource binding for later reuse.
+   */
+  async saveResourceBinding(binding, context = {}) {
+    const normalized = {
+      id: binding.id || `bind-${Date.now()}-${uuidv4().slice(0, 8)}`,
+      timestamp: binding.timestamp || new Date().toISOString(),
+      business: binding.business || 'default',
+      aliases: [...new Set([binding.business, ...(binding.aliases || [])].filter(Boolean))],
+      componentType: binding.componentType || null,
+      provider: binding.provider || null,
+      mcpServer: binding.mcpServer || null,
+      skill: binding.skill || context.currentSkill || 'resource-bind',
+      source: binding.source || 'manual',
+      keywords: [...new Set(binding.keywords || this.extractKeywords(binding.business || ''))],
+      connection: { ...(binding.connection || {}) },
+      metadata: { ...(binding.metadata || {}) },
+      stats: {
+        useCount: binding.stats?.useCount || 0,
+        lastUsed: binding.stats?.lastUsed || null
+      }
+    };
+
+    await this.writeQueue.run('resource-bindings', async () => {
+      this.resourceBindings.bindings = this.resourceBindings.bindings || [];
+      const index = this.resourceBindings.bindings.findIndex((item) => item.id === normalized.id
+        || (item.business === normalized.business
+          && item.componentType === normalized.componentType
+          && item.provider === normalized.provider));
+
+      if (index >= 0) {
+        const previous = this.resourceBindings.bindings[index];
+        this.resourceBindings.bindings[index] = {
+          ...previous,
+          ...normalized,
+          aliases: [...new Set([...(previous.aliases || []), ...normalized.aliases])],
+          keywords: [...new Set([...(previous.keywords || []), ...normalized.keywords])],
+          connection: { ...(previous.connection || {}), ...(normalized.connection || {}) },
+          metadata: { ...(previous.metadata || {}), ...(normalized.metadata || {}) },
+          timestamp: normalized.timestamp
+        };
+        normalized.id = this.resourceBindings.bindings[index].id;
+      } else {
+        this.resourceBindings.bindings.push(normalized);
+      }
+
+      this.resourceBindings.lastUpdated = new Date().toISOString();
+      await this.saveResourceBindings();
+    });
+
+    await this.updateStats('resource_binding', normalized.skill);
+
+    eventBus.emit('learning:recorded', {
+      type: 'resource_binding',
+      skill: normalized.skill,
+      recordId: normalized.id,
+      business: normalized.business,
+      componentType: normalized.componentType,
+      provider: normalized.provider
+    });
+
+    return normalized;
+  }
+
+  /**
+   * Return all stored resource bindings.
+   */
+  async listResourceBindings() {
+    return this.resourceBindings.bindings || [];
+  }
+
+  /**
+   * Find the best-matching binding for an input and skill context.
+   */
+  async matchResourceBinding(input, skillName = null) {
+    const bindings = this.resourceBindings.bindings || [];
+    if (!bindings.length) return null;
+
+    const componentType = this.inferComponentType(input, skillName);
+    const normalized = String(input || '').toLowerCase();
+    const preferredBindingId = componentType
+      ? this.skillBindings.bindings?.[skillName]?.preferredResourceBindings?.[componentType] || null
+      : null;
+
+    let best = null;
+    let bestScore = 0;
+
+    for (const binding of bindings) {
+      let score = 0;
+
+      if (componentType && binding.componentType === componentType) {
+        score += 4;
+      }
+
+      if (binding.provider && normalized.includes(String(binding.provider).toLowerCase())) {
+        score += 3;
+      }
+
+      if (binding.mcpServer && normalized.includes(String(binding.mcpServer).toLowerCase())) {
+        score += 3;
+      }
+
+      if (preferredBindingId && binding.id === preferredBindingId) {
+        score += 8;
+      }
+
+      for (const alias of binding.aliases || []) {
+        if (alias && normalized.includes(String(alias).toLowerCase())) {
+          score += 6;
+        }
+      }
+
+      for (const keyword of binding.keywords || []) {
+        if (keyword && normalized.includes(String(keyword).toLowerCase())) {
+          score += 1;
+        }
+      }
+
+      if (!best || score > bestScore) {
+        best = binding;
+        bestScore = score;
+      }
+    }
+
+    if (!best) return null;
+
+    if (bestScore === 0) {
+      const sameComponent = componentType
+        ? bindings.filter((binding) => binding.componentType === componentType)
+        : [];
+      return sameComponent.length === 1 ? sameComponent[0] : null;
+    }
+
+    return best;
+  }
+
+  /**
+   * Mark a binding as used.
+   */
+  async markResourceBindingUsed(bindingId, context = {}) {
+    if (!bindingId) return;
+
+    let updatedBinding = null;
+    await this.writeQueue.run('resource-bindings', async () => {
+      const bindings = this.resourceBindings.bindings || [];
+      const index = bindings.findIndex((binding) => binding.id === bindingId);
+      if (index < 0) return;
+
+      const current = bindings[index];
+      updatedBinding = {
+        ...current,
+        stats: {
+          useCount: (current.stats?.useCount || 0) + 1,
+          lastUsed: new Date().toISOString()
+        }
+      };
+      bindings[index] = updatedBinding;
+      this.resourceBindings.lastUpdated = new Date().toISOString();
+      await this.saveResourceBindings();
+    });
+
+    if (updatedBinding) {
+      await this.promoteResourceBindingPreference(updatedBinding, context);
+    }
+  }
+
   /**
    * Save learning record
    */
@@ -373,6 +541,191 @@ class LearningEngine {
     });
   }
 
+  async saveAutoGeneratedRecord(record, skill = record.skill || '_global') {
+    const recordPath = path.join(
+      this.expandPath(this.learningPath),
+      'records',
+      skill,
+      `${record.id}.json`
+    );
+
+    const existed = await fs.pathExists(recordPath);
+    await fs.ensureDir(path.dirname(recordPath));
+    await fs.writeJson(recordPath, record, { spaces: 2 });
+
+    if (!this.records[skill]) {
+      this.records[skill] = [];
+    }
+    const index = this.records[skill].findIndex((item) => item.id === record.id);
+    if (index >= 0) {
+      this.records[skill][index] = record;
+    } else {
+      this.records[skill].push(record);
+    }
+
+    return { created: !existed, path: recordPath };
+  }
+
+  async savePassivePreferences(skillName, updates) {
+    const prefsPath = path.join(
+      this.expandPath(this.learningPath),
+      'records',
+      skillName,
+      'preferences.json'
+    );
+    const queueKey = `prefs:${skillName}`;
+    await this.writeQueue.run(queueKey, async () => {
+      let prefs = {};
+      if (await fs.pathExists(prefsPath)) {
+        prefs = await fs.readJson(prefsPath);
+      }
+
+      const next = typeof updates === 'function' ? updates(prefs) : { ...prefs, ...updates };
+      next.lastUpdated = new Date().toISOString();
+
+      await fs.ensureDir(path.dirname(prefsPath));
+      await fs.writeJson(prefsPath, next, { spaces: 2 });
+    });
+  }
+
+  getAutoPromoteConfig() {
+    return this.config.get('learning.autoPromote', {
+      enabled: true,
+      resourceBindingMinUses: 3,
+      sceneMinUses: 2
+    });
+  }
+
+  async promoteResourceBindingPreference(binding, context = {}) {
+    const config = this.getAutoPromoteConfig();
+    const skillName = context.skillName || context.currentSkill || binding.skill || null;
+    if (!config.enabled || !skillName || !binding.componentType) {
+      return false;
+    }
+
+    if ((binding.stats?.useCount || 0) < config.resourceBindingMinUses) {
+      return false;
+    }
+
+    this.skillBindings.bindings = this.skillBindings.bindings || {};
+    const skillBinding = this.skillBindings.bindings[skillName] || {
+      learningCount: 0,
+      records: [],
+      rules: [],
+      preferredResourceBindings: {}
+    };
+    skillBinding.preferredResourceBindings = skillBinding.preferredResourceBindings || {};
+
+    const existingPreferred = skillBinding.preferredResourceBindings[binding.componentType];
+    const changed = existingPreferred !== binding.id;
+    if (changed) {
+      skillBinding.preferredResourceBindings[binding.componentType] = binding.id;
+      skillBinding.lastLearning = new Date().toISOString();
+      this.skillBindings.bindings[skillName] = skillBinding;
+      await this.saveSkillBindings();
+    }
+
+    await this.savePassivePreferences(skillName, (prefs) => ({
+      ...prefs,
+      preferredResourceBindings: {
+        ...(prefs.preferredResourceBindings || {}),
+        [binding.componentType]: {
+          bindingId: binding.id,
+          business: binding.business,
+          provider: binding.provider,
+          componentType: binding.componentType,
+          useCount: binding.stats?.useCount || 0,
+          lastUsed: binding.stats?.lastUsed || null
+        }
+      }
+    }));
+
+    const record = {
+      id: `auto-resource-${skillName}-${binding.componentType}`,
+      timestamp: new Date().toISOString(),
+      type: 'resource_preference',
+      source: 'passive',
+      autoGenerated: true,
+      input: context.input || binding.metadata?.input || binding.business,
+      skill: skillName,
+      componentType: binding.componentType,
+      business: binding.business,
+      provider: binding.provider,
+      bindingId: binding.id,
+      useCount: binding.stats?.useCount || 0,
+      lastUsed: binding.stats?.lastUsed || null,
+      application: {
+        condition: `When ${skillName} resolves ${binding.componentType}`,
+        action: `Prefer resource binding ${binding.business}`,
+        priority: 'medium'
+      }
+    };
+    const saved = await this.saveAutoGeneratedRecord(record, skillName);
+    if (saved.created) {
+      await this.updateStats('resource_preference', skillName);
+    }
+
+    return changed || saved.created;
+  }
+
+  async promoteSceneUsage(scene, context = {}) {
+    const config = this.getAutoPromoteConfig();
+    if (!config.enabled || !scene?.id) {
+      return false;
+    }
+
+    if ((scene.stats?.useCount || 0) < config.sceneMinUses) {
+      return false;
+    }
+
+    const primarySkill = scene.workflow?.skills?.[0]?.skill || 'global';
+    const record = {
+      id: `auto-scene-${scene.id}`,
+      timestamp: new Date().toISOString(),
+      type: 'scene_preference',
+      source: 'passive',
+      autoGenerated: true,
+      input: context.input || scene.name,
+      skill: '_global',
+      sceneId: scene.id,
+      sceneName: scene.name,
+      primarySkill,
+      keywords: scene.keywords || [],
+      workflow: scene.workflow || {},
+      preferences: scene.preferences || {},
+      stats: {
+        useCount: scene.stats?.useCount || 0,
+        lastUsed: scene.stats?.lastUsed || null,
+        successRate: scene.stats?.successRate || 1.0
+      },
+      application: {
+        condition: `When request matches scene ${scene.name}`,
+        action: `Apply workflow starting with ${primarySkill}`,
+        priority: 'medium'
+      }
+    };
+
+    const saved = await this.saveAutoGeneratedRecord(record, '_global');
+    if (saved.created) {
+      await this.updateStats('scene_preference', 'global');
+    }
+
+    await this.savePassivePreferences('_global', (prefs) => ({
+      ...prefs,
+      preferredScenes: {
+        ...(prefs.preferredScenes || {}),
+        [scene.id]: {
+          name: scene.name,
+          primarySkill,
+          useCount: scene.stats?.useCount || 0,
+          successRate: scene.stats?.successRate || 1.0
+        }
+      }
+    }));
+
+    return saved.created;
+  }
+
   /**
    * Update skill bindings
    */
@@ -415,6 +768,20 @@ class LearningEngine {
     }
   }
 
+  /**
+   * Load resource bindings
+   */
+  async loadResourceBindings() {
+    const bindingsPath = path.join(this.expandPath(this.learningPath), 'resource-bindings.json');
+
+    if (await fs.pathExists(bindingsPath)) {
+      this.resourceBindings = await fs.readJson(bindingsPath);
+      this.resourceBindings.bindings = this.resourceBindings.bindings || [];
+    } else {
+      this.resourceBindings = { version: '1.0', bindings: [] };
+    }
+  }
+
   /**
    * Save skill bindings
    */
@@ -426,6 +793,15 @@ class LearningEngine {
     });
   }
 
+  /**
+   * Save resource bindings
+   */
+  async saveResourceBindings() {
+    const bindingsPath = path.join(this.expandPath(this.learningPath), 'resource-bindings.json');
+    this.resourceBindings.lastUpdated = new Date().toISOString();
+    await fs.writeJson(bindingsPath, this.resourceBindings, { spaces: 2 });
+  }
+
   /**
    * Load stats
    */
@@ -480,6 +856,7 @@ class LearningEngine {
       exportedAt: new Date().toISOString(),
       stats: this.stats,
       skillBindings: this.skillBindings,
+      resourceBindings: this.resourceBindings,
       records: this.records
     };
 
@@ -513,8 +890,23 @@ class LearningEngine {
       }
     }
 
+    // Merge resource bindings
+    const existing = this.resourceBindings.bindings || [];
+    const incoming = data.resourceBindings?.bindings || [];
+    for (const binding of incoming) {
+      const match = existing.find((item) => item.id === binding.id
+        || (item.business === binding.business
+          && item.componentType === binding.componentType
+          && item.provider === binding.provider));
+      if (!match) {
+        existing.push(binding);
+      }
+    }
+    this.resourceBindings.bindings = existing;
+
     // Save
     await this.saveSkillBindings();
+    await this.saveResourceBindings();
     await this.saveStats();
 
     return { success: true, imported: data.stats.totalRecords };
@@ -619,6 +1011,20 @@ class LearningEngine {
     return [...new Set(words)].slice(0, 10);
   }
 
+  inferComponentType(input, skillName = null) {
+    const normalized = `${skillName || ''} ${input || ''}`.toLowerCase();
+
+    if (/yapi|api 文档|api doc|swagger|接口/.test(normalized)) return 'apiDoc';
+    if (/yuque|语雀|knowledge base|知识库|design/.test(normalized)) return 'knowledgeBase';
+    if (/redis|缓存|cache/.test(normalized)) return 'redisMonitor';
+    if (/sql|数据库|database|rds|dms/.test(normalized)) return 'databaseQuery';
+    if (/log|日志|trace|sls/.test(normalized)) return 'logService';
+    if (/pipeline|workflow|部署|流水线/.test(normalized)) return 'workflow';
+    if (/report|coverage|报告/.test(normalized)) return 'report';
+
+    return null;
+  }
+
   extractWorkflow(input) {
     // Extract workflow steps
     return {

package/core/providers/friday/flow-adapter.js

@@ -65,6 +65,14 @@ class FridayFlowAdapter extends WorkflowAdapter {
     };
   }
 
+  async startBatchPipelineRun(params) {
+    return {
+      mcpServer: this.mcpServer,
+      tool: this.resolveTool('startBatchPipelineRun'),
+      params: params || {}
+    };
+  }
+
   async getPipelineRun(pipelineId, runId) {
     return {
       mcpServer: this.mcpServer,

package/core/scene-matcher.js

@@ -239,7 +239,7 @@ class SceneMatcher {
   /**
    * Update scene usage stats
    */
-  async updateSceneStats(sceneId, success) {
+  async updateSceneStats(sceneId, success, context = {}) {
     const scene = this.scenes.find(s => s.id === sceneId);
     if (!scene) return;
 
@@ -254,6 +254,10 @@ class SceneMatcher {
 
     // Save updated scenes
     await this.saveScenes();
+
+    if (success && this.learning?.promoteSceneUsage) {
+      await this.learning.promoteSceneUsage(scene, context);
+    }
   }
 
   /**