flowmind 1.5.1 → 1.5.3

package/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 ## [Unreleased]
 
+## [1.5.2] - 2026-07-01
+
+### Added
+- `sdd-agent-sync` now imports workflow resources from local `auto-flow` learning data into FlowMind
+- Workflow sync now writes a local `workflow` resource, a `workflow` component config, and a reusable `workflow` binding for `friday-auto-flow`
+
+### Changed
+- `flowmind resource --sync-sdd-agent` can now seed the workflow MCP path automatically, so `auto-flow` no longer depends on a manual local binding
+
 ## [1.5.1] - 2026-07-01
 
 ### Added

package/core/adapters/mcp-adapter.js

@@ -4,6 +4,7 @@
  */
 
 const BaseAdapter = require('./base-adapter');
+const { callMcpTool } = require('../mcp-http-client');
 
 class McpAdapter extends BaseAdapter {
   constructor(providerName, config = {}) {
@@ -60,6 +61,30 @@ class McpAdapter extends BaseAdapter {
       tools: this.getToolMappings()
     };
   }
+
+  getTransportConfig() {
+    return this.config.transport || this.config.mcpServerConfig || this.config.mcpTransport || {};
+  }
+
+  async callMcpTool(localName, args = {}) {
+    const tool = this.resolveTool(localName);
+    if (!tool) {
+      throw new Error(`Unknown MCP tool mapping: ${localName}`);
+    }
+
+    const transport = this.getTransportConfig();
+    const serverName = this.mcpServer || this.providerName;
+    const response = await callMcpTool({
+      url: transport.url || transport.endpoint || transport.baseUrl,
+      headers: transport.headers || {},
+      tool,
+      args,
+      timeoutMs: transport.timeoutMs || 60000,
+      serverName
+    });
+
+    return response;
+  }
 }
 
 module.exports = McpAdapter;

package/core/adapters/workflow-adapter.js

@@ -29,6 +29,32 @@ class WorkflowAdapter extends McpAdapter {
     throw new Error('Subclasses must implement listPipelines()');
   }
 
+  /**
+   * Query the current iterate metadata used by workflow lookup flows.
+   * @returns {Promise<object>}
+   */
+  async getCurrentIterate() {
+    throw new Error('Subclasses must implement getCurrentIterate()');
+  }
+
+  /**
+   * List deploy checklist records that contain service-to-pipeline mappings.
+   * @param {object} params
+   * @returns {Promise<object>}
+   */
+  async listDeployChecklists(params) {
+    throw new Error('Subclasses must implement listDeployChecklists()');
+  }
+
+  /**
+   * Query historical flow orders that can be used as a fallback pipeline source.
+   * @param {object} params
+   * @returns {Promise<object>}
+   */
+  async orderList(params) {
+    throw new Error('Subclasses must implement orderList()');
+  }
+
   /**
    * Start a pipeline run.
    * @param {string} pipelineId

package/core/component-registry.js

@@ -41,6 +41,10 @@ class ComponentRegistry {
       const AliyunDmsAdapter = require('./providers/aliyun/dms-adapter');
       return new AliyunDmsAdapter(this.getProviderConfig('databaseManager', 'aliyun-dms'));
     });
+    this.registerFactory('aliyun-rds-query', () => {
+      const AliyunRdsQueryAdapter = require('./providers/aliyun/rds-query-adapter');
+      return new AliyunRdsQueryAdapter(this.getProviderConfig('databaseQuery', 'aliyun-rds-query'));
+    });
     this.registerFactory('aliyun-redis', () => {
       const AliyunRedisAdapter = require('./providers/aliyun/redis-adapter');
       return new AliyunRedisAdapter(this.getProviderConfig('redisMonitor', 'aliyun-redis'));
@@ -79,7 +83,21 @@ class ComponentRegistry {
     const components = this.config.get('components', {});
     const typeConfig = components[componentType] || {};
     const providers = typeConfig.providers || {};
-    return providers[providerName] || {};
+    const baseConfig = providers[providerName] || {};
+    const mcpServerName = McpCompatibility.getMcpServer(componentType, providerName);
+    const mcpServers = this.config.get('mcpServers', {});
+    const transport = mcpServerName ? mcpServers[mcpServerName] : null;
+
+    if (!transport) {
+      return baseConfig;
+    }
+
+    return {
+      ...baseConfig,
+      transport: {
+        ...transport
+      }
+    };
   }
 
   /**

package/core/config-manager.js

@@ -82,7 +82,10 @@ class ConfigManager {
     if (await fs.pathExists(resourceConfigPath)) {
       try {
         const resourceConfig = await fs.readJson(resourceConfigPath);
-        this.mergeConfig({ resources: resourceConfig.resources || {} });
+        this.mergeConfig({
+          resources: resourceConfig.resources || {},
+          mcpServers: resourceConfig.mcpServers || {}
+        });
       } catch (error) {
         console.warn('Failed to load resource config:', error.message);
       }
@@ -216,7 +219,9 @@ class ConfigManager {
         redis: { enabled: false },
         logs: { enabled: false },
         apiDocs: { enabled: false }
-      }
+      },
+
+      mcpServers: {}
     };
   }
 

package/core/index.js

@@ -11,6 +11,8 @@ const ConfigManager = require('./config-manager');
 const ComponentRegistry = require('./component-registry');
 const ModelManager = require('./ai/model-manager');
 const eventBus = require('./event-bus');
+const { autoSyncSddAgentToFlowMind } = require('./sdd-agent-sync');
+const { inferSourceContext } = require('./source-inference');
 
 class FlowMind {
   constructor(options = {}) {
@@ -32,6 +34,7 @@ class FlowMind {
   async init() {
     if (this.initialized) return this;
 
+    await autoSyncSddAgentToFlowMind();
     await this.config.load();
 
     // Validate configuration
@@ -191,15 +194,25 @@ class FlowMind {
     // Get learning rules for this skill
     const learnings = await this.learning.getSkillLearnings(skill.name);
     const resourceBinding = await this.learning.matchResourceBinding(input, skill.name);
+    let sourceInference = context.sourceInference || null;
+    if (!sourceInference) {
+      try {
+        sourceInference = await inferSourceContext(input);
+      } catch (error) {
+        sourceInference = null;
+      }
+    }
 
     // Apply learning rules to context
     const enhancedContext = {
       ...context,
       flowmind: context.flowmind || this,
+      componentRegistry: context.componentRegistry || this.components,
       currentSkill: context.currentSkill || skill.name,
       learnings: learnings,
       preferences: await this.learning.getPreferences(skill.name),
-      resourceBinding
+      resourceBinding,
+      sourceInference
     };
 
     // Execute skill

package/core/mcp-http-client.js

@@ -0,0 +1,63 @@
+/**
+ * Minimal JSON-RPC MCP HTTP client.
+ * Sends tools/call requests to an MCP gateway over HTTP.
+ */
+
+async function callMcpTool({ url, headers = {}, tool, args = {}, timeoutMs = 60000, serverName = 'mcp' }) {
+  if (!url) {
+    throw new Error(`MCP transport URL not configured for ${serverName}`);
+  }
+
+  const requestId = Date.now();
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), timeoutMs);
+
+  try {
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'User-Agent': 'flowmind',
+        ...headers
+      },
+      body: JSON.stringify({
+        jsonrpc: '2.0',
+        id: requestId,
+        method: 'tools/call',
+        params: {
+          name: tool,
+          arguments: args
+        }
+      }),
+      signal: controller.signal
+    });
+
+    const text = await response.text();
+    let payload = null;
+
+    if (text) {
+      try {
+        payload = JSON.parse(text);
+      } catch (parseError) {
+        throw new Error(`Invalid MCP response from ${serverName}: ${text.slice(0, 200)}`);
+      }
+    }
+
+    if (!response.ok) {
+      const errorMessage = payload?.error?.message || payload?.message || response.statusText;
+      throw new Error(`MCP request failed for ${serverName}: ${errorMessage}`);
+    }
+
+    if (payload?.error) {
+      throw new Error(payload.error.message || `MCP tool call failed for ${serverName}`);
+    }
+
+    return payload?.result ?? payload ?? null;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+module.exports = {
+  callMcpTool
+};

package/core/providers/aliyun/rds-query-adapter.js

@@ -0,0 +1,70 @@
+/**
+ * Aliyun RDS Direct Query Adapter
+ * Wraps the friday-rds-redis-query MCP server for SQL and Redis reads.
+ */
+
+const DatabaseQueryAdapter = require('../../adapters/database-query-adapter');
+
+class AliyunRdsQueryAdapter extends DatabaseQueryAdapter {
+  constructor(config = {}) {
+    super('aliyun-rds-query', config);
+
+    this.registerTool('fetchSources', 'mcpFetchSource');
+    this.registerTool('fetchDatabases', 'mcpFetchBase');
+    this.registerTool('fetchTables', 'mcpFetchTables');
+    this.registerTool('fetchFields', 'mcpFetchFields');
+    this.registerTool('queryExec', 'mcpQueryExec');
+    this.registerTool('redisSources', 'mcpRedisSource');
+    this.registerTool('redisKeys', 'mcpRedisKeys');
+    this.registerTool('redisKeyGet', 'mcpRedisKeyGet');
+    this.registerTool('redisScan', 'mcpRedisScan');
+  }
+
+  get mcpServer() {
+    return 'friday-rds-redis-query';
+  }
+
+  async fetchSources(params) {
+    return this.callMcpTool('fetchSources', params || {});
+  }
+
+  async fetchDatabases(sourceIdOrParams) {
+    const params = typeof sourceIdOrParams === 'object'
+      ? sourceIdOrParams
+      : { source_id: sourceIdOrParams };
+    return this.callMcpTool('fetchDatabases', params || {});
+  }
+
+  async fetchTables(sourceIdOrParams, schema) {
+    const params = typeof sourceIdOrParams === 'object'
+      ? sourceIdOrParams
+      : { source_id: sourceIdOrParams, schema };
+    return this.callMcpTool('fetchTables', params || {});
+  }
+
+  async fetchFields(params) {
+    return this.callMcpTool('fetchFields', params || {});
+  }
+
+  async queryExec(params) {
+    return this.callMcpTool('queryExec', params || {});
+  }
+
+  async redisSources(params) {
+    return this.callMcpTool('redisSources', params || {});
+  }
+
+  async redisKeys(params) {
+    return this.callMcpTool('redisKeys', params || {});
+  }
+
+  async redisKeyGet(params) {
+    return this.callMcpTool('redisKeyGet', params || {});
+  }
+
+  async redisScan(params) {
+    return this.callMcpTool('redisScan', params || {});
+  }
+}
+
+module.exports = AliyunRdsQueryAdapter;

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

@@ -26,6 +26,7 @@ class FridayFlowAdapter extends WorkflowAdapter {
     this.registerTool('logPipelineJobRun', 'flowLogPipelineJobRun');
     this.registerTool('passPipelineValidate', 'flowPassPipelineValidate');
     this.registerTool('refusePipelineValidate', 'flowRefusePipelineValidate');
+    this.registerTool('listDeployChecklists', 'listDeployChecklists');
 
     // Order/task tools
     this.registerTool('orderList', 'orderList');
@@ -42,51 +43,39 @@ class FridayFlowAdapter extends WorkflowAdapter {
   }
 
   async listPipelineGroups(params) {
-    return {
-      mcpServer: this.mcpServer,
-      tool: this.resolveTool('listPipelineGroups'),
-      params: params || { perPage: '20', page: '1' }
-    };
+    return this.callMcpTool('listPipelineGroups', params || { perPage: '20', page: '1' });
   }
 
   async listPipelines(params) {
-    return {
-      mcpServer: this.mcpServer,
-      tool: this.resolveTool('listPipelines'),
-      params: params || {}
-    };
+    return this.callMcpTool('listPipelines', params || {});
+  }
+
+  async getCurrentIterate() {
+    return this.callMcpTool('getCurrentIterate', {});
+  }
+
+  async listDeployChecklists(params) {
+    return this.callMcpTool('listDeployChecklists', params || {});
+  }
+
+  async orderList(params) {
+    return this.callMcpTool('orderList', params || {});
   }
 
   async startPipelineRun(pipelineId) {
-    return {
-      mcpServer: this.mcpServer,
-      tool: this.resolveTool('startPipelineRun'),
-      params: { pipelineId }
-    };
+    return this.callMcpTool('startPipelineRun', { pipelineId });
   }
 
   async startBatchPipelineRun(params) {
-    return {
-      mcpServer: this.mcpServer,
-      tool: this.resolveTool('startBatchPipelineRun'),
-      params: params || {}
-    };
+    return this.callMcpTool('startBatchPipelineRun', params || {});
   }
 
   async getPipelineRun(pipelineId, runId) {
-    return {
-      mcpServer: this.mcpServer,
-      tool: this.resolveTool('getPipelineRun'),
-      params: { pipelineId, pipelineRunId: runId }
-    };
+    return this.callMcpTool('getPipelineRun', { pipelineId, pipelineRunId: runId });
   }
 
   async listPipelineRuns(pipelineId, params) {
-    return {
-      mcpServer: this.mcpServer,
-      tool: this.resolveTool('listPipelineRuns'),
-      params: { pipelineId, ...(params || {}) }
-    };
+    return this.callMcpTool('listPipelineRuns', { pipelineId, ...(params || {}) });
   }
 }