flowmind 1.5.2 → 1.5.4

package/skills/data-logic-validation/index.js

@@ -3,6 +3,8 @@
  * Verify SQL queries, Redis operations, and data processing logic against real data via MCP
  */
 
+const { inferSourceContext } = require('../../core/source-inference');
+
 module.exports = {
   canHandle(input, context) {
     if (!input) return false;
@@ -13,6 +15,7 @@ module.exports = {
     const registry = context.componentRegistry;
     const params = parseValidationParams(input);
     const learnedBinding = context.resourceBinding;
+    const sourceInference = context.sourceInference || await safeInferSourceContext(input);
 
     // Check MCP component availability
     const dbManager = registry?.getAdapter('databaseManager');
@@ -26,7 +29,7 @@ module.exports = {
     };
 
     if (params.action === 'sql') {
-      if (!dbQuery && !learnedBinding) {
+      if (!dbQuery) {
         return {
           type: 'result',
           skill: 'data-logic-validation',
@@ -37,16 +40,22 @@ module.exports = {
         };
       }
 
+      const target = resolveDatabaseTarget(params, learnedBinding, sourceInference);
+      const sql = params.query || 'SELECT 1';
+      const execution = await dbQuery.queryExec(buildSqlExecutionParams(target, sql));
+
       return {
         type: 'result',
         skill: 'data-logic-validation',
-        message: `SQL validation ready for: ${params.query || 'provided query'}`,
+        message: `SQL validation executed for: ${target.project || target.database || 'resolved target'}`,
         data: {
           action: 'validate_sql',
-          query: params.query,
-          mcpTool: 'mcpQueryExec',
+          query: sql,
+          target,
+          execution,
           availableComponents,
-          binding: learnedBinding
+          binding: learnedBinding,
+          inferredSource: summarizeSourceInference(sourceInference)
         },
         input,
         timestamp: new Date().toISOString()
@@ -54,27 +63,33 @@ module.exports = {
     }
 
     if (params.action === 'redis') {
-      if (!redisMonitor && !learnedBinding) {
+      if (!dbQuery) {
         return {
           type: 'result',
           skill: 'data-logic-validation',
-          message: 'Redis monitor not configured (need friday-aliyun-sz-rds-redis MCP)',
-          data: { availableComponents, hint: 'Configure Redis monitor MCP server first' },
+          message: 'Redis direct query service not configured (need friday-rds-redis-query MCP)',
+          data: { availableComponents, hint: 'Configure database query MCP server first' },
           input,
           timestamp: new Date().toISOString()
         };
       }
 
+      const target = resolveRedisTarget(params, learnedBinding, sourceInference);
+      const execution = await executeRedisAction(dbQuery, params, target);
+
       return {
         type: 'result',
         skill: 'data-logic-validation',
-        message: `Redis validation ready for key: ${params.key || 'provided key'}`,
+        message: `Redis validation executed for: ${target.project || target.host || 'resolved target'}`,
         data: {
           action: 'validate_redis',
           key: params.key,
-          mcpTools: ['mcpRedisKeyGet', 'mcpRedisKeyInfo', 'mcpRedisKeys'],
+          target,
+          execution,
           availableComponents,
-          binding: learnedBinding
+          binding: learnedBinding,
+          inferredSource: summarizeSourceInference(sourceInference),
+          monitorProvider: redisMonitor?.providerName || null
         },
         input,
         timestamp: new Date().toISOString()
@@ -89,7 +104,8 @@ module.exports = {
         actions: ['sql - Validate SQL queries', 'redis - Validate Redis operations'],
         availableComponents,
         requiredMCP: ['databaseManager', 'databaseQuery', 'redisMonitor'],
-        binding: learnedBinding
+        binding: learnedBinding,
+        inferredSource: summarizeSourceInference(sourceInference)
       },
       input,
       timestamp: new Date().toISOString()
@@ -108,5 +124,110 @@ function parseValidationParams(input) {
   const keyMatch = input.match(/(?:key|键)\s*[:=]?\s*(\S+)/i);
   if (keyMatch) params.key = keyMatch[1];
 
+  const projectMatch = input.match(/(?:project|项目)\s*[:=]?\s*([\u4e00-\u9fa5A-Za-z0-9._-]+)/i);
+  if (projectMatch) params.project = projectMatch[1];
+
+  const envMatch = input.match(/(?:env|环境)\s*[:=]?\s*([A-Za-z_-]+)/i);
+  if (envMatch) params.env = envMatch[1].toLowerCase();
+
   return params;
 }
+
+async function safeInferSourceContext(input) {
+  try {
+    return await inferSourceContext(input);
+  } catch (error) {
+    return null;
+  }
+}
+
+function resolveDatabaseTarget(params, learnedBinding, sourceInference) {
+  const bindingConnection = learnedBinding?.connection || {};
+  const inferredDatabase = sourceInference?.database || {};
+
+  return compactObject({
+    project: params.project || sourceInference?.project || bindingConnection.project || null,
+    environment: params.env || sourceInference?.environment || bindingConnection.env || inferredDatabase.envType || null,
+    sourceId: bindingConnection.sourceId || inferredDatabase.sourceId || null,
+    databaseId: bindingConnection.databaseId || inferredDatabase.databaseId || null,
+    database: inferredDatabase.database || bindingConnection.database || null,
+    host: bindingConnection.host || inferredDatabase.host || null,
+    port: bindingConnection.port || inferredDatabase.port || null,
+    username: bindingConnection.username || bindingConnection.dbUser || inferredDatabase.username || inferredDatabase.dbUser || null,
+    password: bindingConnection.password || bindingConnection.dbPassword || inferredDatabase.password || inferredDatabase.dbPassword || null
+  });
+}
+
+function resolveRedisTarget(params, learnedBinding, sourceInference) {
+  const bindingConnection = learnedBinding?.connection || {};
+  const inferredRedis = sourceInference?.redis || {};
+
+  return compactObject({
+    project: params.project || sourceInference?.project || bindingConnection.project || null,
+    environment: params.env || sourceInference?.environment || bindingConnection.env || inferredRedis.envType || null,
+    sourceId: bindingConnection.sourceId || inferredRedis.sourceId || null,
+    host: bindingConnection.host || inferredRedis.host || null,
+    port: bindingConnection.port || inferredRedis.port || null,
+    password: bindingConnection.password || inferredRedis.password || null,
+    database: inferredRedis.database ?? bindingConnection.database ?? 1
+  });
+}
+
+function buildSqlExecutionParams(target, sql) {
+  return compactObject({
+    source_id: target.sourceId || null,
+    database_id: target.databaseId || null,
+    schema: target.database || null,
+    sql,
+    env: target.environment || null,
+    host: target.host || null,
+    port: target.port || null,
+    username: target.username || null,
+    password: target.password || null
+  });
+}
+
+async function executeRedisAction(dbQuery, params, target) {
+  const baseParams = compactObject({
+    source_id: target.sourceId || null,
+    env: target.environment || null,
+    host: target.host || null,
+    port: target.port || null,
+    password: target.password || null,
+    database: target.database ?? 1
+  });
+
+  if (params.key && !/[*?]/.test(params.key)) {
+    return dbQuery.redisKeyGet({
+      ...baseParams,
+      key: params.key
+    });
+  }
+
+  return dbQuery.redisScan({
+    ...baseParams,
+    pattern: params.key || '*',
+    count: 50
+  });
+}
+
+function summarizeSourceInference(sourceInference) {
+  if (!sourceInference?.matched) {
+    return sourceInference?.environment
+      ? { matched: false, environment: sourceInference.environment }
+      : null;
+  }
+
+  return {
+    matched: true,
+    project: sourceInference.project,
+    environment: sourceInference.environment,
+    database: sourceInference.database?.database || null,
+    redisDatabase: sourceInference.redis?.database ?? null,
+    matchedEntries: sourceInference.matchedEntries?.map((entry) => entry.title) || []
+  };
+}
+
+function compactObject(value) {
+  return Object.fromEntries(Object.entries(value).filter(([, fieldValue]) => fieldValue !== null && fieldValue !== undefined && fieldValue !== ''));
+}

package/skills/log-audit/index.js

@@ -29,6 +29,7 @@ module.exports = {
       ? logService.buildQueryParams(queryInput)
       : queryInput;
     const execution = await logService.queryLogs(queryParams);
+    const summary = summarizeLogExecution(execution);
 
     return {
       type: 'result',
@@ -40,7 +41,7 @@ module.exports = {
         action: params.traceId ? 'trace' : 'query',
         provider: logService.providerName,
         queryParams,
-        execution
+        execution: summary
       },
       input,
       timestamp: new Date().toISOString()
@@ -87,3 +88,95 @@ function buildLogQueryInput(params) {
     line: params.limit || 100
   };
 }
+
+function summarizeLogExecution(execution) {
+  const payload = unwrapPayload(execution);
+  const data = payload && typeof payload === 'object' ? payload : {};
+  const records = extractRecords(data);
+
+  return {
+    status: extractStatus(data) || 'ok',
+    total: extractTotal(data, records),
+    records: records.slice(0, 5).map(summarizeRecord),
+    requestId: data.requestId || data.traceId || data.id || null
+  };
+}
+
+function unwrapPayload(payload) {
+  if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
+    return payload;
+  }
+
+  const textPayload = extractContentText(payload);
+  if (textPayload) {
+    return parseMaybeJson(textPayload);
+  }
+
+  if (payload.data && typeof payload.data === 'object' && !Array.isArray(payload.data)) {
+    return payload.data;
+  }
+
+  return payload;
+}
+
+function extractRecords(data) {
+  const candidates = [data.logs, data.records, data.items, data.result, data.data];
+  for (const candidate of candidates) {
+    if (Array.isArray(candidate)) {
+      return candidate;
+    }
+  }
+
+  return [];
+}
+
+function extractStatus(data) {
+  if (!data || typeof data !== 'object') {
+    return null;
+  }
+
+  if (typeof data.status === 'string') {
+    return data.status;
+  }
+
+  if (data.success === false) {
+    return 'error';
+  }
+
+  return null;
+}
+
+function extractTotal(data, records) {
+  return data.total || data.count || records.length || null;
+}
+
+function summarizeRecord(record) {
+  if (!record || typeof record !== 'object') {
+    return record;
+  }
+
+  return {
+    time: record.time || record.timestamp || record.__time__ || null,
+    level: record.level || record.severity || null,
+    message: record.message || record.content || record.msg || null,
+    traceId: record.traceId || record.trace_id || null
+  };
+}
+
+function extractContentText(payload) {
+  const content = Array.isArray(payload.content) ? payload.content : [];
+  const textItem = content.find((item) => item && typeof item.text === 'string');
+  return textItem ? textItem.text : null;
+}
+
+function parseMaybeJson(value) {
+  if (typeof value !== 'string') {
+    return value;
+  }
+
+  try {
+    return JSON.parse(value);
+  } catch (error) {
+    return { text: value };
+  }
+}

package/skills/resource-bind/index.js

@@ -3,6 +3,8 @@
  * Manage database, Redis, API, and other external resource connections
  */
 
+const { inferSourceContext } = require('../../core/source-inference');
+
 const PROVIDER_MAP = {
   'yapi-mcp': { componentType: 'apiDoc', provider: 'yapi', mcpServer: 'yapi-mcp' },
   yapi: { componentType: 'apiDoc', provider: 'yapi', mcpServer: 'yapi-mcp' },
@@ -27,9 +29,10 @@ module.exports = {
   async execute(input, context) {
     const registry = context.componentRegistry;
     const params = parseResourceParams(input);
+    const sourceInference = context.sourceInference || await safeInferSourceContext(input);
 
     if (params.action === 'bind') {
-      return bindResource(input, context, params);
+      return bindResource(input, context, params, sourceInference);
     }
 
     if (params.action === 'list') {
@@ -48,7 +51,8 @@ module.exports = {
             initialized: c.initialized,
             mcpServer: c.mcpServer
           })),
-          bindings
+          bindings,
+          inferredSource: summarizeSourceInference(sourceInference)
         },
         input,
         timestamp: new Date().toISOString()
@@ -69,7 +73,8 @@ module.exports = {
           : 'Resource connection status',
         data: {
           status,
-          matchedBinding
+          matchedBinding,
+          inferredSource: summarizeSourceInference(sourceInference)
         },
         input,
         timestamp: new Date().toISOString()
@@ -87,7 +92,8 @@ module.exports = {
           'status - Show connection status and matched binding',
           'use - Resolve a learned binding for the current business'
         ],
-        supportedTypes: ['MySQL', 'PostgreSQL', 'Redis', 'REST API', 'YApi', 'Yuque', 'Workflow']
+        supportedTypes: ['MySQL', 'PostgreSQL', 'Redis', 'REST API', 'YApi', 'Yuque', 'Workflow'],
+        inferredSource: summarizeSourceInference(sourceInference)
       },
       input,
       timestamp: new Date().toISOString()
@@ -95,7 +101,7 @@ module.exports = {
   }
 };
 
-async function bindResource(input, context, params) {
+async function bindResource(input, context, params, sourceInference) {
   const learning = context.flowmind?.learning;
   if (!learning?.saveResourceBinding) {
     return {
@@ -107,7 +113,7 @@ async function bindResource(input, context, params) {
     };
   }
 
-  const binding = buildBinding(input, params, context);
+  const binding = buildBinding(input, params, context, sourceInference);
   const saved = await learning.saveResourceBinding(binding, {
     currentSkill: 'resource-bind'
   });
@@ -126,10 +132,20 @@ async function bindResource(input, context, params) {
   };
 }
 
-function buildBinding(input, params, context) {
+function buildBinding(input, params, context, sourceInference) {
   const inferred = resolveProviderInfo(params);
-  const business = inferBusiness(input, params, inferred);
-  const aliases = [business, params.project, params.namespace, params.alias, params.env].filter(Boolean);
+  const inferredDatabase = sourceInference?.database || null;
+  const inferredRedis = sourceInference?.redis || null;
+  const business = inferBusiness(input, params, inferred, sourceInference);
+  const aliases = [
+    business,
+    params.project,
+    sourceInference?.project,
+    params.namespace,
+    params.alias,
+    params.env,
+    sourceInference?.environment
+  ].filter(Boolean);
   const keywords = extractKeywords(input, aliases);
 
   return {
@@ -140,18 +156,20 @@ function buildBinding(input, params, context) {
     mcpServer: params.mcpServer || inferred.mcpServer || null,
     connection: {
       address: params.address || params.url || params.endpoint || null,
-      host: params.host || null,
-      port: params.port || null,
+      host: params.host || inferredDatabase?.host || inferredRedis?.host || null,
+      port: params.port || inferredDatabase?.port || inferredRedis?.port || null,
       token: params.token || null,
       apiKey: params.apiKey || null,
       namespace: params.namespace || null,
-      project: params.project || null,
-      sourceId: params.sourceId || null,
-      databaseId: params.databaseId || null,
-      env: params.env || null
+      project: params.project || sourceInference?.project || null,
+      database: inferredDatabase?.database || null,
+      sourceId: params.sourceId || inferredDatabase?.sourceId || inferredRedis?.sourceId || null,
+      databaseId: params.databaseId || inferredDatabase?.databaseId || null,
+      env: params.env || sourceInference?.environment || null
     },
     metadata: {
-      input
+      input,
+      sourceInference: summarizeSourceInference(sourceInference)
     },
     keywords
   };
@@ -231,8 +249,8 @@ function resolveProviderInfo(params) {
   return {};
 }
 
-function inferBusiness(input, params, inferred = {}) {
-  const explicit = params.business || params.project || params.namespace;
+function inferBusiness(input, params, inferred = {}, sourceInference = null) {
+  const explicit = params.business || params.project || sourceInference?.project || params.namespace;
   if (explicit) return explicit;
 
   const keywordMatch = String(input || '').match(/(?:绑定|bind)\s*([\u4e00-\u9fa5A-Za-z0-9._-]+?)\s*(平台|服务|环境|工程|项目)/i);
@@ -259,3 +277,28 @@ function extractKeywords(input, aliases = []) {
 function escapeRegex(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
+
+async function safeInferSourceContext(input) {
+  try {
+    return await inferSourceContext(input);
+  } catch (error) {
+    return null;
+  }
+}
+
+function summarizeSourceInference(sourceInference) {
+  if (!sourceInference?.matched) {
+    return sourceInference?.environment
+      ? { matched: false, environment: sourceInference.environment }
+      : null;
+  }
+
+  return {
+    matched: true,
+    project: sourceInference.project,
+    environment: sourceInference.environment,
+    database: sourceInference.database?.database || null,
+    redisDatabase: sourceInference.redis?.database ?? null,
+    matchedEntries: sourceInference.matchedEntries?.map((entry) => entry.title) || []
+  };
+}

package/skills/yapi-sync-interface/index.js

@@ -10,7 +10,9 @@ module.exports = {
   },
 
   async execute(input, context) {
-    const apiDoc = context.componentRegistry?.getAdapter('apiDoc');
+    const apiDoc = context.componentRegistry?.getAdapter('apiDoc')
+      || context.componentRegistry?.getAdapterByProvider?.('apiDoc', 'yapi')
+      || null;
     const learnedBinding = context.resourceBinding?.componentType === 'apiDoc'
       ? context.resourceBinding
       : null;
@@ -26,17 +28,38 @@ module.exports = {
       };
     }
 
+    if (!apiDoc) {
+      return {
+        type: 'result',
+        skill: 'yapi-sync-interface',
+        message: 'YApi adapter is not available in the current registry.',
+        data: {
+          hint: 'Make sure the apiDoc component is configured and loaded',
+          binding: learnedBinding
+        },
+        input,
+        timestamp: new Date().toISOString()
+      };
+    }
+
     const params = parseYApiParams(input);
 
     if (params.action === 'search') {
+      const args = {
+        projectKeyword: params.project || learnedBinding?.connection?.project,
+        nameKeyword: params.keyword,
+        limit: 20
+      };
+      const execution = await apiDoc.searchApis(args);
       return {
         type: 'result',
         skill: 'yapi-sync-interface',
         message: `Searching YApi for: ${params.keyword || 'all'}`,
         data: {
-          mcpTool: 'yapi_search_apis',
-          args: { projectKeyword: params.project || learnedBinding?.connection?.project, nameKeyword: params.keyword, limit: 20 },
-          binding: learnedBinding
+          action: 'search',
+          args,
+          binding: learnedBinding,
+          execution: summarizeYApiExecution('search', execution)
         },
         input,
         timestamp: new Date().toISOString()
@@ -44,14 +67,17 @@ module.exports = {
     }
 
     if (params.action === 'list') {
+      const projectId = params.project || learnedBinding?.connection?.project;
+      const execution = await apiDoc.getCategories(projectId);
       return {
         type: 'result',
         skill: 'yapi-sync-interface',
-        message: `Listing YApi categories for project: ${params.project || learnedBinding?.connection?.project || 'default'}`,
+        message: `Listing YApi categories for project: ${projectId || 'default'}`,
         data: {
-          mcpTool: 'yapi_get_categories',
-          args: { projectId: params.project || learnedBinding?.connection?.project },
-          binding: learnedBinding
+          action: 'list',
+          args: { projectId },
+          binding: learnedBinding,
+          execution: summarizeYApiExecution('list', execution)
         },
         input,
         timestamp: new Date().toISOString()
@@ -59,14 +85,17 @@ module.exports = {
     }
 
     if (params.action === 'export') {
+      const projectId = params.project || learnedBinding?.connection?.project;
+      const execution = await apiDoc.exportProject(projectId, params.format || 'swagger');
       return {
         type: 'result',
         skill: 'yapi-sync-interface',
-        message: `Exporting YApi project: ${params.project || learnedBinding?.connection?.project || 'default'}`,
+        message: `Exporting YApi project: ${projectId || 'default'}`,
         data: {
-          mcpTool: 'yapi_export_project',
-          args: { projectId: params.project || learnedBinding?.connection?.project, type: params.format || 'swagger' },
-          binding: learnedBinding
+          action: 'export',
+          args: { projectId, type: params.format || 'swagger' },
+          binding: learnedBinding,
+          execution: summarizeYApiExecution('export', execution)
         },
         input,
         timestamp: new Date().toISOString()
@@ -98,7 +127,7 @@ function parseYApiParams(input) {
   const projectMatch = input.match(/(?:项目|project)\s*[:=]?\s*(\S+)/i);
   if (projectMatch) params.project = projectMatch[1];
 
-  const keywordMatch = input.match(/(?:关键词|keyword|搜索|名称|name)\s*[:=]?\s*(.+?)(?:\s*$)/i);
+  const keywordMatch = input.match(/(?:关键词|keyword|名称|name)\s*[:=]?\s*(.+?)(?=\s+(?:项目|project|格式|format)\s*[:=]|\s*$)/i);
   if (keywordMatch) params.keyword = keywordMatch[1].trim();
 
   const formatMatch = input.match(/(?:格式|format)\s*[:=]?\s*(json|markdown|swagger)/i);
@@ -106,3 +135,107 @@ function parseYApiParams(input) {
 
   return params;
 }
+
+function summarizeYApiExecution(action, execution) {
+  const payload = unwrapPayload(execution);
+  const data = getPayloadData(payload);
+  const items = extractListItems(data);
+
+  return {
+    action,
+    status: extractStatus(data) || extractStatus(payload) || 'ok',
+    total: extractTotal(data, payload, items),
+    items: items.slice(0, 5).map(summarizeItem),
+    runId: extractRunId(data) || extractRunId(payload) || null
+  };
+}
+
+function unwrapPayload(payload) {
+  if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
+    return payload;
+  }
+
+  const textPayload = extractContentText(payload);
+  if (textPayload) {
+    return parseMaybeJson(textPayload);
+  }
+
+  if ('data' in payload && payload.data && typeof payload.data === 'object' && !Array.isArray(payload.data)) {
+    return payload.data;
+  }
+
+  return payload;
+}
+
+function getPayloadData(payload) {
+  return payload && typeof payload === 'object' && !Array.isArray(payload) ? payload : {};
+}
+
+function extractListItems(data) {
+  const candidates = [data.list, data.items, data.records, data.result, data.data];
+  for (const candidate of candidates) {
+    if (Array.isArray(candidate)) {
+      return candidate;
+    }
+  }
+
+  return [];
+}
+
+function extractStatus(payload) {
+  if (!payload || typeof payload !== 'object') {
+    return null;
+  }
+
+  if (typeof payload.status === 'string') {
+    return payload.status;
+  }
+
+  if (payload.success === false) {
+    return 'error';
+  }
+
+  return typeof payload.code === 'string' ? payload.code : null;
+}
+
+function extractTotal(data, payload, items) {
+  return data.total || payload.total || items.length || null;
+}
+
+function extractRunId(payload) {
+  if (!payload || typeof payload !== 'object') {
+    return null;
+  }
+
+  return payload.runId || payload.id || payload.requestId || null;
+}
+
+function summarizeItem(item) {
+  if (!item || typeof item !== 'object') {
+    return item;
+  }
+
+  return {
+    id: item._id || item.id || item.api_id || item.catid || null,
+    name: item.name || item.title || item.path || item.url || null,
+    method: item.method || item.req_method || null
+  };
+}
+
+function extractContentText(payload) {
+  const content = Array.isArray(payload.content) ? payload.content : [];
+  const textItem = content.find((item) => item && typeof item.text === 'string');
+  return textItem ? textItem.text : null;
+}
+
+function parseMaybeJson(value) {
+  if (typeof value !== 'string') {
+    return value;
+  }
+
+  try {
+    return JSON.parse(value);
+  } catch (error) {
+    return { text: value };
+  }
+}