flowmind 1.5.2 → 1.5.4

package/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 ## [Unreleased]
 
+## [1.5.4] - 2026-07-01
+
+### Added
+- FlowMind now resolves deferred MCP invocations from skill outputs and executes them through the registered adapter when available
+- Auto-flow, YApi, Yuque, and log audit skills now return concise execution summaries instead of raw MCP payload shapes
+
+### Fixed
+- Repeated TUI submissions are now serialized to avoid multi-input crashes during fast follow-up commands
+- CLI startup now falls back to ASCII-friendly banners in managed terminal environments that can crash on full graphics rendering
+
+### Changed
+- `resource-bind` and related learned bindings now surface clearer resource summaries for follow-up skill reuse
+- Result formatting now unwraps nested execution payloads so the TUI shows the actual output instead of intermediate envelopes
+
 ## [1.5.2] - 2026-07-01
 
 ### Added

package/bin/flowmind.js

@@ -75,7 +75,19 @@ async function initFlowMind(options = {}) {
 /**
  * Display banner
  */
-function showBanner() {
+function showBanner(asciiMode = false) {
+  if (asciiMode) {
+    console.log(chalk.cyan(`
+  +--------------------------------------------------+
+  |                                                  |
+  |   FlowMind                                       |
+  |   The AI Agent That Learns How You Work          |
+  |                                                  |
+  +--------------------------------------------------+
+  `));
+    return;
+  }
+
   console.log(chalk.cyan(`
   ╔══════════════════════════════════════════════════╗
   ║                                                ║
@@ -89,7 +101,71 @@ function showBanner() {
 /**
  * Dragon Totem ASCII Art by level - Chinese Dragon (中国龙)
  */
-function getDragonArt(level) {
+function getDragonArt(level, asciiMode = false) {
+  if (asciiMode) {
+    const asciiArts = {
+      0: [
+        '        /-----\\        ',
+        '       /  /-\\  \\       ',
+        '      |  | o |  |      ',
+        '      |  |   |  |      ',
+        '      |   \\_/   |      ',
+        '       \\       /       ',
+        '        \\-----/        ',
+        '        Dragon Egg     '
+      ],
+      1: [
+        '          /--\\          ',
+        '     /----/  \\---\\      ',
+        '    /  o    \\/    \\     ',
+        '    \\    /\\    /\\  /    ',
+        '     \\/\\/  \\/\\/  \\/     ',
+        '      Hatchling Dragon  '
+      ],
+      2: [
+        '       /-\\  /-\\         ',
+        '  /----/  \\/  \\---\\     ',
+        ' /  o      __      \\    ',
+        ' \\     /--------\\  /    ',
+        '  \\---/  //////  \\/     ',
+        '   \\_/          \\_/     ',
+        '      Juvenile Dragon   '
+      ],
+      3: [
+        '     /---\\  /---\\       ',
+        ' /---/   \\/   \\---\\     ',
+        '/  o       __      \\    ',
+        '|    /----------\\  |    ',
+        ' \\--/  ////////  \\-/    ',
+        '  \\/  //////////  \\/    ',
+        '   \\_/          \\_/     ',
+        '       Adult Dragon     '
+      ],
+      4: [
+        '   /---\\      /---\\     ',
+        '/---/   \\____/   \\---\\  ',
+        '| o        __        |  ',
+        '|   /------------\\   |  ',
+        ' \\-/  //////////// \\-/  ',
+        '  /  ////////////  \\    ',
+        ' /_/              \\_\\   ',
+        '       Elder Dragon     '
+      ],
+      5: [
+        ' * /---\\      /---\\ *   ',
+        '/-/   \\______/   \\-\\    ',
+        '| o        __        |  ',
+        '|   /--------------\\ |  ',
+        ' \\-/  /////**/////  \\-/ ',
+        '  /  /////    /////  \\  ',
+        ' /_/   **      **   \\_\\ ',
+        ' * \\______________/ *   ',
+        '     Ascended Dragon    '
+      ]
+    };
+    return asciiArts[level] || asciiArts[0];
+  }
+
   const arts = {
     0: [
       '        ╭─────╮        ',
@@ -192,11 +268,11 @@ function getHighlightColor(level) {
 /**
  * Render dragon totem with honor data
  */
-function renderDragonTotem(honorData) {
+function renderDragonTotem(honorData, asciiMode = false) {
   const info = getLevelInfo(honorData.points);
   const dragonColor = getDragonColor(info.level);
   const highlightColor = getHighlightColor(info.level);
-  const art = getDragonArt(info.level);
+  const art = getDragonArt(info.level, asciiMode);
 
   // Calculate max art line width for proper padding
   const maxArtWidth = Math.max(...art.map(l => l.length));
@@ -210,7 +286,8 @@ function renderDragonTotem(honorData) {
 
   console.log('');
   console.log(chalk.cyan('  ┌' + border + '┐'));
-  console.log(chalk.cyan('  │') + '  🐉 Dragon Totem of Honor  ' + padRight('  🐉 Dragon Totem of Honor  ', boxWidth - 2) + chalk.cyan('│'));
+  const title = asciiMode ? '  Dragon Totem of Honor  ' : '  🐉 Dragon Totem of Honor  ';
+  console.log(chalk.cyan('  │') + title + padRight(title, boxWidth - 2) + chalk.cyan('│'));
   console.log(chalk.cyan('  ├' + border + '┤'));
 
   for (const line of art) {
@@ -366,7 +443,7 @@ program
   .description('Initialize FlowMind in current directory')
   .option('--ai <provider>', 'Initialize with AI provider (openai/anthropic/glm/mimo/qwen/ernie/deepseek/ollama)')
   .action(async (options) => {
-    showBanner();
+    showBanner(options.ascii || shouldUseAsciiUi());
 
     const spinner = ora('Initializing FlowMind...').start();
 
@@ -836,7 +913,7 @@ program
       } else if (options.publish) {
         await publishHonor({ output: options.output, gist: options.gist });
       } else {
-        renderDragonTotem(honorData);
+        renderDragonTotem(honorData, shouldUseAsciiUi());
         console.log(chalk.gray(`  ${getNextLevelHint(honorData.points)}`));
       }
     } catch (error) {
@@ -959,7 +1036,7 @@ program
 
 // Interactive mode
 async function runInteractiveMode(fm) {
-  showBanner();
+  showBanner(shouldUseAsciiUi());
   console.log(chalk.cyan('Interactive mode started. Type "exit" to quit.\n'));
 
   try {

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,31 @@ class McpAdapter extends BaseAdapter {
       tools: this.getToolMappings()
     };
   }
+
+  getTransportConfig() {
+    return this.config.transport || this.config.mcpServerConfig || this.config.mcpTransport || {};
+  }
+
+  async callTool(tool, args = {}) {
+    const transport = this.getTransportConfig();
+    const serverName = this.mcpServer || this.providerName;
+    return callMcpTool({
+      url: transport.url || transport.endpoint || transport.baseUrl,
+      headers: transport.headers || {},
+      tool,
+      args,
+      timeoutMs: transport.timeoutMs || 60000,
+      serverName
+    });
+  }
+
+  async callMcpTool(localName, args = {}) {
+    const tool = this.resolveTool(localName);
+    if (!tool) {
+      throw new Error(`Unknown MCP tool mapping: ${localName}`);
+    }
+    return this.callTool(tool, args);
+  }
 }
 
 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/ai/providers/mimo.js

@@ -82,7 +82,7 @@ class MiMoProvider extends BaseModel {
       ...super.getInfo(),
       model: this.model,
       baseUrl: this.baseUrl,
-      provider: 'Xiaomi'
+      provider: 'MiMo'
     };
   }
 }

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,19 +194,30 @@ 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
     const result = await skill.execute(input, enhancedContext);
+    const resolvedResult = await this.resolveDeferredMcpResult(result, skill, enhancedContext);
 
     if (resourceBinding?.id) {
       await this.learning.markResourceBindingUsed(resourceBinding.id, {
@@ -226,7 +240,144 @@ class FlowMind {
     // Award honor point for skill use
     await this.honor.award('skill_use', `Used skill: ${skill.name}`);
 
-    return result;
+    return resolvedResult;
+  }
+
+  async resolveDeferredMcpResult(result, skill, context = {}) {
+    const invocation = this.extractMcpInvocation(result);
+    if (!invocation) {
+      return result;
+    }
+
+    const adapter = this.resolveDeferredAdapter(invocation, skill, context);
+    if (!adapter) {
+      return result;
+    }
+
+    const executor = typeof adapter.callTool === 'function'
+      ? adapter.callTool.bind(adapter)
+      : typeof adapter.callMcpTool === 'function'
+        ? adapter.callMcpTool.bind(adapter)
+        : null;
+
+    if (!executor) {
+      return result;
+    }
+
+    try {
+      const execution = await executor(invocation.tool, invocation.args || {});
+      const resultData = result && typeof result === 'object' && !Array.isArray(result) && result.data && typeof result.data === 'object'
+        ? result.data
+        : {};
+
+      return {
+        ...result,
+        data: {
+          ...resultData,
+          execution,
+          mcpTool: invocation.tool,
+          mcpExecuted: true,
+          mcpServer: invocation.mcpServer || adapter.mcpServer || adapter.providerName
+        }
+      };
+    } catch (error) {
+      return {
+        ...result,
+        type: result?.type || 'error',
+        success: false,
+        message: result?.message || error.message,
+        data: {
+          ...(result && typeof result === 'object' && result.data && typeof result.data === 'object' ? result.data : {}),
+          mcpTool: invocation.tool,
+          mcpExecuted: false,
+          mcpError: error.message
+        }
+      };
+    }
+  }
+
+  extractMcpInvocation(result) {
+    if (!result || typeof result !== 'object') {
+      return null;
+    }
+
+    const candidates = [
+      result.data,
+      result
+    ];
+
+    for (const candidate of candidates) {
+      if (!candidate || typeof candidate !== 'object' || Array.isArray(candidate)) {
+        continue;
+      }
+
+      const tool = candidate.mcpTool || candidate.tool;
+      if (!tool || typeof tool !== 'string') {
+        continue;
+      }
+
+      const args = candidate.args || candidate.params || {};
+      if (args && typeof args !== 'object') {
+        continue;
+      }
+
+      return {
+        tool,
+        args,
+        mcpServer: candidate.mcpServer || null
+      };
+    }
+
+    return null;
+  }
+
+  resolveDeferredAdapter(invocation, skill, context = {}) {
+    const registry = context.componentRegistry || this.components;
+    if (!registry) {
+      return null;
+    }
+
+    const bindingComponentType = context.resourceBinding?.componentType || context.resolvedBinding?.componentType || null;
+    const skillComponentType = this.inferSkillComponentType(skill, context);
+    const componentTypes = [
+      bindingComponentType,
+      skillComponentType,
+      invocation.componentType
+    ].filter(Boolean);
+
+    for (const componentType of componentTypes) {
+      const adapter = registry.getAdapter(componentType);
+      if (adapter) {
+        return adapter;
+      }
+    }
+
+    if (typeof registry.getAll === 'function') {
+      const allAdapters = registry.getAll();
+      for (const entry of allAdapters) {
+        const adapter = registry.getAdapterByProvider?.(entry.type, entry.provider) || null;
+        if (adapter && (adapter.mcpServer === invocation.mcpServer || adapter.providerName === invocation.provider)) {
+          return adapter;
+        }
+      }
+    }
+
+    return null;
+  }
+
+  inferSkillComponentType(skill, context = {}) {
+    const name = skill?.name || context.currentSkill || '';
+    const mapping = {
+      'log-audit': 'logService',
+      'sls-log-audit': 'logService',
+      'yapi-sync-interface': 'apiDoc',
+      'yuque-sync-design': 'knowledgeBase',
+      'data-logic-validation': 'databaseQuery',
+      'resource-bind': null,
+      'auto-flow': 'workflow'
+    };
+
+    return mapping[name] || null;
   }
 
   /**

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/dms-adapter.js

@@ -27,43 +27,23 @@ class AliyunDmsAdapter extends DatabaseManagerAdapter {
   }
 
   async listInstances(params) {
-    return {
-      mcpServer: this.mcpServer,
-      tool: this.resolveTool('listInstances'),
-      params: params || {}
-    };
+    return this.callMcpTool('listInstances', params || {});
   }
 
   async executeScript(params) {
-    return {
-      mcpServer: this.mcpServer,
-      tool: this.resolveTool('executeScript'),
-      params
-    };
+    return this.callMcpTool('executeScript', params);
   }
 
   async searchDatabase(searchKey) {
-    return {
-      mcpServer: this.mcpServer,
-      tool: this.resolveTool('searchDatabase'),
-      params: { search_key: searchKey }
-    };
+    return this.callMcpTool('searchDatabase', { search_key: searchKey });
   }
 
   async listTables(databaseId) {
-    return {
-      mcpServer: this.mcpServer,
-      tool: this.resolveTool('listTables'),
-      params: { database_id: databaseId }
-    };
+    return this.callMcpTool('listTables', { database_id: databaseId });
   }
 
   async getTableDetail(tableGuid) {
-    return {
-      mcpServer: this.mcpServer,
-      tool: this.resolveTool('getTableDetailInfo'),
-      params: { table_guid: tableGuid }
-    };
+    return this.callMcpTool('getTableDetailInfo', { table_guid: tableGuid });
   }
 
   /**
@@ -73,11 +53,7 @@ class AliyunDmsAdapter extends DatabaseManagerAdapter {
    * @returns {Promise<object>}
    */
   async generateSql(databaseId, question) {
-    return {
-      mcpServer: this.mcpServer,
-      tool: this.resolveTool('generateSql'),
-      params: { database_id: databaseId, question }
-    };
+    return this.callMcpTool('generateSql', { database_id: databaseId, question });
   }
 
   /**
@@ -87,11 +63,7 @@ class AliyunDmsAdapter extends DatabaseManagerAdapter {
    * @returns {Promise<object>}
    */
   async optimizeSql(databaseId, sql) {
-    return {
-      mcpServer: this.mcpServer,
-      tool: this.resolveTool('optimizeSql'),
-      params: { database_id: databaseId, sql }
-    };
+    return this.callMcpTool('optimizeSql', { database_id: databaseId, sql });
   }
 }