flowmind 1.5.1 → 1.5.3

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/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/tui/app.jsx

@@ -6,6 +6,7 @@ const StatusBar = require('./components/StatusBar.jsx');
 const { formatResultText } = require('./format-result');
 
 function App({ flowmind, asciiMode = false }) {
+  const MAX_MESSAGES = 60;
   const [messages, setMessages] = React.useState([]);
   const [isProcessing, setIsProcessing] = React.useState(false);
   const [focusPanel, setFocusPanel] = React.useState('chat'); // 'chat' | 'sidebar'
@@ -19,7 +20,7 @@ function App({ flowmind, asciiMode = false }) {
 
   const appendMessage = React.useCallback((role, text, metadata = {}) => {
     const id = ++messageIdRef.current;
-    setMessages(prev => [...prev, { id, role, text, metadata }]);
+    setMessages(prev => [...prev, { id, role, text, metadata }].slice(-MAX_MESSAGES));
   }, []);
 
   // Ctrl+C always exits; Tab switches focus between panels

package/tui/format-result.js

@@ -2,6 +2,12 @@ function isPlainObject(value) {
   return value && typeof value === 'object' && !Array.isArray(value);
 }
 
+const MAX_RENDER_LINES = 120;
+const MAX_LINE_LENGTH = 220;
+const MAX_RENDER_CHARS = 8000;
+const MAX_ARRAY_ITEMS = 20;
+const MAX_SCALAR_LENGTH = 160;
+
 function unwrapResultPayload(result) {
   let current = result;
 
@@ -58,11 +64,40 @@ function pruneDisplayValue(value) {
 }
 
 function formatScalar(value) {
-  if (typeof value === 'string') return value;
+  if (typeof value === 'string') {
+    if (value.length <= MAX_SCALAR_LENGTH) return value;
+    return `${value.slice(0, MAX_SCALAR_LENGTH - 1)}…`;
+  }
   if (typeof value === 'number' || typeof value === 'boolean') return String(value);
   return JSON.stringify(value);
 }
 
+function sanitizeForTerminal(text) {
+  return String(text)
+    .replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/g, ' ')
+    .replace(/\r\n/g, '\n');
+}
+
+function truncateRenderedText(text) {
+  const sanitized = sanitizeForTerminal(text);
+  const lines = sanitized.split('\n');
+  const clippedLines = lines.slice(0, MAX_RENDER_LINES).map((line) => {
+    if (line.length <= MAX_LINE_LENGTH) return line;
+    return `${line.slice(0, MAX_LINE_LENGTH - 1)}…`;
+  });
+
+  if (lines.length > MAX_RENDER_LINES) {
+    clippedLines.push(`… truncated ${lines.length - MAX_RENDER_LINES} line(s)`);
+  }
+
+  let output = clippedLines.join('\n');
+  if (output.length > MAX_RENDER_CHARS) {
+    output = `${output.slice(0, MAX_RENDER_CHARS - 1)}…`;
+  }
+
+  return output;
+}
+
 function renderValueLines(value, indent = '') {
   if (value === undefined) return [];
 
@@ -71,7 +106,11 @@ function renderValueLines(value, indent = '') {
 
     const allScalars = value.every((item) => !isPlainObject(item) && !Array.isArray(item));
     if (allScalars) {
-      return [indent + value.map(formatScalar).join(', ')];
+      const shown = value.slice(0, MAX_ARRAY_ITEMS).map(formatScalar);
+      if (value.length > MAX_ARRAY_ITEMS) {
+        shown.push(`… +${value.length - MAX_ARRAY_ITEMS} more`);
+      }
+      return [indent + shown.join(', ')];
     }
 
     const lines = [];
@@ -150,10 +189,10 @@ function formatResultText(result) {
   }
 
   if (detailLines.length > 0) {
-    return detailLines.join('\n');
+    return truncateRenderedText(detailLines.join('\n'));
   }
 
-  return JSON.stringify(payload, null, 2);
+  return truncateRenderedText(JSON.stringify(payload, null, 2));
 }
 
 module.exports = {