flowmind 1.5.3 → 1.5.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flowmind",
-  "version": "1.5.3",
+  "version": "1.5.4",
   "description": "Memory and workflow automation for MCP, Codex, and Claude Code. Reuse repeatable developer operations through skills and explicit feedback.",
   "main": "core/index.js",
   "bin": {

package/skills/auto-flow/index.js

@@ -6,6 +6,7 @@
 const fs = require('fs');
 const os = require('os');
 const path = require('path');
+const { callMcpTool } = require('../../core/mcp-http-client');
 
 const BUILTIN_WORKFLOWS = {
   'dev-workflow': {
@@ -72,19 +73,14 @@ module.exports = {
     const workflow = createWorkflowClient(context);
 
     if (params.action === 'define') {
+      const definition = buildWorkflowDefinitionSummary();
       return {
         type: 'result',
         skill: 'auto-flow',
         message: 'Define a workflow in YAML format',
         data: {
           format: 'YAML workflow definition',
-          example: {
-            name: 'My Workflow',
-            steps: [
-              { id: 'step1', action: 'run-command', command: 'echo hello' },
-              { id: 'step2', skill: 'code-review', depends_on: ['step1'] }
-            ]
-          }
+          execution: definition
         },
         input,
         timestamp: new Date().toISOString()
@@ -96,7 +92,7 @@ module.exports = {
     }
 
     if (params.action === 'status') {
-      await executeStatus(workflow, params, input);
+      const execution = await executeStatus(workflow, params, input);
       return {
         type: 'result',
         skill: 'auto-flow',
@@ -106,7 +102,8 @@ module.exports = {
           provider: workflow.provider,
           binding: workflow.binding,
           status: 'completed',
-          mcpServer: getWorkflowMcpServer(workflow)
+          mcpServer: getWorkflowMcpServer(workflow),
+          execution: summarizeWorkflowExecution('status', params, execution)
         },
         input,
         timestamp: new Date().toISOString()
@@ -118,7 +115,7 @@ module.exports = {
     }
 
     if (params.action === 'list' || params.serviceNames.length > 0) {
-      await workflow.client.listPipelines(buildListPipelineParams(params));
+      const execution = await workflow.client.listPipelines(buildListPipelineParams(params));
       return {
         type: 'result',
         skill: 'auto-flow',
@@ -128,7 +125,8 @@ module.exports = {
           provider: workflow.provider,
           binding: workflow.binding,
           status: 'completed',
-          mcpServer: getWorkflowMcpServer(workflow)
+          mcpServer: getWorkflowMcpServer(workflow),
+          execution: summarizeWorkflowExecution('list', params, execution)
         },
         input,
         timestamp: new Date().toISOString()
@@ -143,7 +141,7 @@ module.exports = {
         message: `Workflow ready: ${workflowDef.name}`,
         data: {
           workflow: params.workflow,
-          steps: workflowDef.steps,
+          execution: buildBuiltinWorkflowSummary(params.workflow, workflowDef),
           provider: workflow.provider
         },
         input,
@@ -164,7 +162,8 @@ module.exports = {
         ],
         builtinWorkflows: Object.keys(BUILTIN_WORKFLOWS),
         provider: workflow.provider,
-        binding: workflow.binding
+        binding: workflow.binding,
+        execution: buildAutoFlowHintSummary(workflow)
       },
       input,
       timestamp: new Date().toISOString()
@@ -191,40 +190,391 @@ function createWorkflowClient(context) {
     return { client: null, provider: null, binding: null, transportBacked: false };
   }
 
+  const transport = buildWorkflowTransport(binding);
+  if (!transport.url) {
+    return { client: null, provider: binding.provider || null, binding, transportBacked: false };
+  }
+
   return {
     client: {
       providerName: binding.provider || 'workflow-binding',
       async listPipelines(params) {
-        return { mcpServer: binding.mcpServer, tool: TOOL_NAMES.listPipelines, params };
+        return callWorkflowMcp(binding, transport, TOOL_NAMES.listPipelines, params);
       },
       async getCurrentIterate() {
-        return { mcpServer: binding.mcpServer, tool: 'getCurrentIterate', params: {} };
+        return callWorkflowMcp(binding, transport, 'getCurrentIterate', {});
       },
       async listDeployChecklists(params) {
-        return { mcpServer: binding.mcpServer, tool: 'listDeployChecklists', params };
+        return callWorkflowMcp(binding, transport, 'listDeployChecklists', params);
       },
       async orderList(params) {
-        return { mcpServer: binding.mcpServer, tool: 'orderList', params };
+        return callWorkflowMcp(binding, transport, 'orderList', params);
       },
       async startPipelineRun(pipelineId) {
-        return { mcpServer: binding.mcpServer, tool: TOOL_NAMES.startPipelineRun, params: { pipelineId } };
+        return callWorkflowMcp(binding, transport, TOOL_NAMES.startPipelineRun, { pipelineId });
       },
       async startBatchPipelineRun(params) {
-        return { mcpServer: binding.mcpServer, tool: TOOL_NAMES.startBatchPipelineRun, params };
+        return callWorkflowMcp(binding, transport, TOOL_NAMES.startBatchPipelineRun, params);
       },
       async getPipelineRun(pipelineId, runId) {
-        return { mcpServer: binding.mcpServer, tool: TOOL_NAMES.getPipelineRun, params: { pipelineId, pipelineRunId: runId } };
+        return callWorkflowMcp(binding, transport, TOOL_NAMES.getPipelineRun, { pipelineId, pipelineRunId: runId });
       },
       async listPipelineRuns(pipelineId, params) {
-        return { mcpServer: binding.mcpServer, tool: TOOL_NAMES.listPipelineRuns, params: { pipelineId, ...(params || {}) } };
+        return callWorkflowMcp(binding, transport, TOOL_NAMES.listPipelineRuns, { pipelineId, ...(params || {}) });
       }
     },
     provider: binding.provider || 'workflow-binding',
     binding,
-    transportBacked: false
+    transportBacked: true
+  };
+}
+
+function buildWorkflowTransport(binding) {
+  const connection = binding?.connection || {};
+  const headers = {};
+
+  if (connection.token) {
+    headers.Authorization = `Bearer ${connection.token}`;
+  }
+  if (connection.apiKey) {
+    headers['X-API-Key'] = connection.apiKey;
+  }
+
+  return {
+    url: connection.url || connection.address || connection.endpoint || null,
+    headers,
+    timeoutMs: connection.timeoutMs || 60000
   };
 }
 
+function callWorkflowMcp(binding, transport, tool, params) {
+  return callMcpTool({
+    url: transport.url,
+    headers: transport.headers,
+    tool,
+    args: params || {},
+    timeoutMs: transport.timeoutMs || 60000,
+    serverName: binding.mcpServer || binding.provider || 'workflow'
+  });
+}
+
+function summarizeWorkflowExecution(action, params, execution) {
+  const payload = unwrapMcpResult(execution);
+  const records = extractRecords(payload);
+  const total = extractTotalCount(payload, records);
+
+  return compactObject({
+    action,
+    summary: buildWorkflowSummaryText(action, params, total, records),
+    total,
+    status: extractWorkflowStatus(payload, action),
+    target: buildWorkflowTargetLabel(params),
+    environment: params.environment || null,
+    items: records.slice(0, 5).map((record) => summarizeWorkflowRecord(record))
+  });
+}
+
+function summarizeDeployExecution(params, execution, context = {}) {
+  const payload = unwrapMcpResult(execution);
+  const payloadList = Array.isArray(payload) ? payload : [payload];
+  const primary = payloadList.find((item) => item !== null && item !== undefined) || null;
+  const summaryTarget = buildWorkflowTargetLabel(params) || buildDeployTargetLabel(context) || 'deployment';
+
+  return compactObject({
+    action: 'deploy',
+    summary: buildDeploySummaryText(summaryTarget, primary, context, payloadList.length),
+    status: extractDeployStatus(primary),
+    target: summaryTarget,
+    pipelineId: context.pipelineId || params.pipelineId || (Array.isArray(context.pipelineIds) && context.pipelineIds.length === 1 ? context.pipelineIds[0] : null),
+    pipelineIds: Array.isArray(context.pipelineIds) && context.pipelineIds.length > 0 ? context.pipelineIds : null,
+    source: context.source || null,
+    runId: extractDeployRunId(primary),
+    count: payloadList.length > 1 ? payloadList.length : null,
+    details: summarizeDeployDetails(primary)
+  });
+}
+
+function buildWorkflowDefinitionSummary() {
+  return {
+    action: 'define',
+    summary: 'Prepared a YAML workflow template',
+    format: 'YAML workflow definition',
+    example: {
+      name: 'My Workflow',
+      steps: [
+        { id: 'step1', action: 'run-command', command: 'echo hello' },
+        { id: 'step2', skill: 'code-review', depends_on: ['step1'] }
+      ]
+    }
+  };
+}
+
+function buildBuiltinWorkflowSummary(workflowName, workflowDef) {
+  return {
+    action: 'workflow',
+    summary: `Workflow ready: ${workflowDef.name}`,
+    workflow: workflowName,
+    name: workflowDef.name,
+    stepCount: Array.isArray(workflowDef.steps) ? workflowDef.steps.length : 0,
+    steps: (workflowDef.steps || []).map((step) => compactObject({
+      id: step.id,
+      skill: step.skill || null,
+      action: step.action || null,
+      name: step.name || null,
+      depends_on: Array.isArray(step.depends_on) ? step.depends_on : null
+    }))
+  };
+}
+
+function buildAutoFlowHintSummary(workflow) {
+  return {
+    action: 'hint',
+    summary: workflow?.binding
+      ? `Workflow service bound to ${workflow.binding.mcpServer}`
+      : 'Workflow service not configured',
+    provider: workflow?.provider || null,
+    binding: workflow?.binding || null,
+    configured: !!workflow?.client
+  };
+}
+
+function buildWorkflowSummaryText(action, params, total, records) {
+  const target = buildWorkflowTargetLabel(params) || 'all workflows';
+  const count = typeof total === 'number' ? total : records.length;
+
+  if (action === 'status') {
+    return `Checked ${target}${count !== null ? `, ${count} record(s) found` : ''}`;
+  }
+
+  if (action === 'list') {
+    return `Listed workflows for ${target}${count !== null ? `, ${count} pipeline(s) found` : ''}`;
+  }
+
+  return `Workflow ${action} completed`;
+}
+
+function buildWorkflowTargetLabel(params) {
+  if (params.pipelineId && params.runId) {
+    return `pipeline ${params.pipelineId} / run ${params.runId}`;
+  }
+  if (params.pipelineId) {
+    return `pipeline ${params.pipelineId}`;
+  }
+  if (params.serviceNames?.length > 0) {
+    return params.serviceNames.join(', ');
+  }
+  if (params.workflow) {
+    return params.workflow;
+  }
+  return params.environment || null;
+}
+
+function buildDeployTargetLabel(context) {
+  if (Array.isArray(context.pipelineIds) && context.pipelineIds.length > 0) {
+    return `pipeline ${context.pipelineIds.join(', ')}`;
+  }
+  if (context.pipelineId) {
+    return `pipeline ${context.pipelineId}`;
+  }
+  if (Array.isArray(context.services) && context.services.length > 0) {
+    return context.services.map((item) => item.serviceName || item.service || item.pipelineName || item.pipelineId).filter(Boolean).join(', ');
+  }
+  return null;
+}
+
+function buildDeploySummaryText(target, payload, context, count = 1) {
+  const status = extractDeployStatus(payload) || 'submitted';
+  const runId = extractDeployRunId(payload);
+  const source = context.source ? ` via ${context.source}` : '';
+  const countSuffix = count > 1 ? ` (${count} items)` : '';
+
+  if (runId) {
+    return `Deployment ${status} for ${target}${source}, run ${runId}${countSuffix}`;
+  }
+
+  return `Deployment ${status} for ${target}${source}${countSuffix}`;
+}
+
+function extractDeployStatus(payload) {
+  if (payload && typeof payload === 'object') {
+    const candidates = [
+      payload.status,
+      payload.state,
+      payload.result?.status,
+      payload.result?.state
+    ].filter(Boolean);
+    if (candidates.length > 0) {
+      return String(candidates[0]);
+    }
+
+    if (payload.submitted === true) {
+      return 'submitted';
+    }
+  }
+
+  return null;
+}
+
+function extractDeployRunId(payload) {
+  if (!payload || typeof payload !== 'object') {
+    return null;
+  }
+
+  const candidates = [
+    payload.pipelineRunId,
+    payload.pipeline_run_id,
+    payload.runId,
+    payload.run_id,
+    payload.result?.pipelineRunId,
+    payload.result?.pipeline_run_id,
+    payload.result?.runId,
+    payload.result?.run_id
+  ];
+
+  for (const candidate of candidates) {
+    if (candidate === null || candidate === undefined || candidate === '') continue;
+    return String(candidate);
+  }
+
+  return null;
+}
+
+function summarizeDeployDetails(payload) {
+  if (!payload || typeof payload !== 'object') {
+    return null;
+  }
+
+  const details = compactObject({
+    submitted: typeof payload.submitted === 'boolean' ? payload.submitted : null,
+    pipelineRunId: payload.pipelineRunId || payload.pipeline_run_id || null,
+    pipelineId: payload.pipelineId || payload.pipeline_id || null,
+    message: payload.message || payload.result?.message || null
+  });
+
+  return Object.keys(details).length > 0 ? details : null;
+}
+
+function unwrapMcpResult(payload) {
+  if (!payload || typeof payload !== 'object') {
+    return payload;
+  }
+
+  const textContent = Array.isArray(payload.content) ? payload.content : payload.result?.content;
+  if (Array.isArray(textContent)) {
+    const textItem = textContent.find((item) => item?.type === 'text' && typeof item.text === 'string');
+    if (textItem?.text) {
+      try {
+        return JSON.parse(textItem.text);
+      } catch (error) {
+        return payload;
+      }
+    }
+  }
+
+  return payload;
+}
+
+function extractRecords(payload) {
+  const normalized = unwrapMcpResult(payload);
+  if (!normalized) return [];
+  if (Array.isArray(normalized)) return normalized;
+
+  const candidates = [
+    normalized.data,
+    normalized.rows,
+    normalized.list,
+    normalized.records,
+    normalized.result?.data,
+    normalized.result?.rows,
+    normalized.result?.list,
+    normalized.result?.records
+  ];
+
+  for (const candidate of candidates) {
+    if (Array.isArray(candidate)) {
+      return candidate;
+    }
+  }
+
+  return [];
+}
+
+function extractTotalCount(payload, records) {
+  if (payload && typeof payload === 'object') {
+    const candidates = [payload.total, payload.count, payload.result?.total, payload.result?.count];
+    for (const candidate of candidates) {
+      if (typeof candidate === 'number' && Number.isFinite(candidate)) {
+        return candidate;
+      }
+      if (typeof candidate === 'string' && candidate.trim() !== '' && !Number.isNaN(Number(candidate))) {
+        return Number(candidate);
+      }
+    }
+  }
+
+  return records.length;
+}
+
+function extractWorkflowStatus(payload, action) {
+  if (payload && typeof payload === 'object') {
+    const candidates = [
+      payload.status,
+      payload.state,
+      payload.result?.status,
+      payload.result?.state
+    ].filter(Boolean);
+    if (candidates.length > 0) {
+      return String(candidates[0]);
+    }
+  }
+
+  return action === 'status' ? 'completed' : 'completed';
+}
+
+function summarizeWorkflowRecord(record) {
+  const fields = parseWorkflowFields(record?.fields);
+  return compactObject({
+    pipelineName: record?.pipelineName || record?.name || fields?.pipelineName || fields?.name || null,
+    pipelineId: record?.pipelineId || fields?.pipelineId || extractIdFromFields(fields) || null,
+    service: extractWorkflowService(fields),
+    status: record?.status || fields?.status || fields?.state || null,
+    env: record?.env || fields?.env || fields?.environment || null
+  });
+}
+
+function parseWorkflowFields(fields) {
+  if (!fields) return null;
+  if (typeof fields === 'object') return fields;
+  if (typeof fields !== 'string') return null;
+
+  try {
+    return JSON.parse(fields);
+  } catch (error) {
+    return null;
+  }
+}
+
+function extractWorkflowService(fields) {
+  if (!fields) return null;
+  if (Array.isArray(fields.service) && fields.service.length > 0) {
+    return fields.service[0];
+  }
+  if (typeof fields.service === 'string') {
+    return fields.service;
+  }
+  return fields.serviceName || fields.service_name || null;
+}
+
+function extractIdFromFields(fields) {
+  if (!fields || typeof fields !== 'object') return null;
+  const candidates = [fields.pipelineId, fields.pipeline_id, fields.id];
+  for (const candidate of candidates) {
+    if (candidate === null || candidate === undefined || candidate === '') continue;
+    return String(candidate);
+  }
+  return null;
+}
+
 function buildNoAdapterResult(input, params) {
   if (params.workflow && BUILTIN_WORKFLOWS[params.workflow]) {
     const workflow = BUILTIN_WORKFLOWS[params.workflow];
@@ -234,7 +584,7 @@ function buildNoAdapterResult(input, params) {
       message: `Workflow ready: ${workflow.name}`,
       data: {
         workflow: params.workflow,
-        steps: workflow.steps
+        execution: buildBuiltinWorkflowSummary(params.workflow, workflow)
       },
       input,
       timestamp: new Date().toISOString()
@@ -247,7 +597,12 @@ function buildNoAdapterResult(input, params) {
     message: 'Workflow service not configured. Connect friday-auto-flow first.',
     data: {
       status: 'not_configured',
-      hint: 'Run `flowmind resource` to review current bindings, then save one like: `flowmind "绑定发布业务 mcp=friday-auto-flow token=xxx env=uat"`'
+      hint: 'Run `flowmind resource` to review current bindings, then save one like: `flowmind "绑定发布业务 mcp=friday-auto-flow token=xxx env=uat"`',
+      execution: buildAutoFlowHintSummary({
+        client: null,
+        provider: null,
+        binding: null
+      })
     },
     input,
     timestamp: new Date().toISOString()
@@ -267,7 +622,10 @@ async function executeDeploy(workflow, params, input, context) {
         binding: workflow.binding,
         status: 'submitted',
         mcpServer: getWorkflowMcpServer(workflow),
-        execution,
+        execution: summarizeDeployExecution(params, execution, {
+          source: 'direct-input',
+          pipelineId: params.pipelineId
+        }),
         resolution: {
           source: 'direct-input',
           pipelineId: params.pipelineId
@@ -295,7 +653,11 @@ async function executeDeploy(workflow, params, input, context) {
         binding: workflow.binding,
         status: 'submitted',
         mcpServer: getWorkflowMcpServer(workflow),
-        execution: executions.length === 1 ? executions[0] : executions,
+        execution: summarizeDeployExecution(params, executions.length === 1 ? executions[0] : executions, {
+          source: resolvedTargets.source,
+          pipelineIds: resolvedTargets.pipelineIds,
+          services: resolvedTargets.resolutions
+        }),
         resolution: {
           source: resolvedTargets.source,
           pipelineIds: resolvedTargets.pipelineIds,
@@ -322,7 +684,10 @@ async function executeDeploy(workflow, params, input, context) {
         binding: workflow.binding,
         status: 'submitted',
         mcpServer: getWorkflowMcpServer(workflow),
-        execution,
+        execution: summarizeDeployExecution(params, execution, {
+          source: 'batch-fallback',
+          lookup
+        }),
         resolution: {
           source: 'batch-fallback',
           lookup
@@ -334,30 +699,18 @@ async function executeDeploy(workflow, params, input, context) {
   }
 
 async function executeStatus(workflow, params, input) {
+  let execution;
   if (params.pipelineId && params.runId) {
-    await workflow.client.getPipelineRun(params.pipelineId, params.runId);
+    execution = await workflow.client.getPipelineRun(params.pipelineId, params.runId);
   } else if (params.pipelineId) {
-    await workflow.client.listPipelineRuns(params.pipelineId, {
+    execution = await workflow.client.listPipelineRuns(params.pipelineId, {
       env: params.environment
     });
   } else {
-    await workflow.client.listPipelines(buildListPipelineParams(params));
+    execution = await workflow.client.listPipelines(buildListPipelineParams(params));
   }
 
-  return {
-    type: 'result',
-    skill: 'auto-flow',
-    message: 'Workflow status: query completed',
-    data: {
-      action: 'status',
-      provider: workflow.provider,
-      binding: workflow.binding,
-      status: 'completed',
-      mcpServer: workflow.binding?.mcpServer || workflow.provider
-    },
-    input,
-    timestamp: new Date().toISOString()
-  };
+  return execution;
 }
 
 function parseFlowParams(input) {

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 };
+  }
+}