flowmind 1.5.1 → 1.5.3

package/core/sdd-agent-sync.js

@@ -2,10 +2,14 @@ const fs = require('fs-extra');
 const os = require('os');
 const path = require('path');
 
-const MCP_SERVER_ALIASES = Object.freeze({
-  'aomi-yapi-mcp': 'yapi-mcp',
-  'aomi-yuque-mcp': 'yuque-mcp'
-});
+const SDD_SOURCE_SYNC_FILES = Object.freeze([
+  'RESOURCE_INDEX.md',
+  'project-db-configs.json',
+  'project-git-map.json',
+  'feign-link-map.json',
+  'auto-flow-apis.md',
+  'auto-flow-pipeline-map.json'
+]);
 
 const RESOURCE_BINDING_SPECS = Object.freeze({
   yapi: { componentType: 'apiDoc', provider: 'yapi' },
@@ -23,7 +27,9 @@ function getHomeDir() {
 
 function normalizeMcpServer(name) {
   if (!name) return null;
-  return MCP_SERVER_ALIASES[name] || name;
+  if (/^[^-]+-yapi-mcp$/i.test(name)) return 'yapi-mcp';
+  if (/^[^-]+-yuque-mcp$/i.test(name)) return 'yuque-mcp';
+  return name;
 }
 
 function deepMerge(target, source) {
@@ -46,11 +52,19 @@ function isObject(value) {
   return value !== null && typeof value === 'object' && !Array.isArray(value);
 }
 
-function sanitizeResourceConfig(sddConfig) {
+function sanitizeResourceConfig(sddConfig, skillBindingData = {}) {
+  const resources = { ...(sddConfig.resources || {}) };
+  if (!resources.workflow) {
+    const workflowResource = buildWorkflowResource(skillBindingData);
+    if (workflowResource) {
+      resources.workflow = workflowResource;
+    }
+  }
+
   return {
     version: sddConfig.version || '1.0',
     lastUpdated: new Date().toISOString(),
-    resources: sddConfig.resources || {},
+    resources,
     mcpServers: sddConfig.mcpServers || {},
     aliases: sddConfig.aliases || {},
     metadata: {
@@ -171,7 +185,169 @@ function buildLogBindings(resourceConfig = {}) {
   }));
 }
 
-function convertResourceBindings(sddConfig) {
+function buildWorkflowResource(skillBindingData = {}) {
+  const workflowBinding = skillBindingData.bindings?.['auto-flow'];
+  if (!workflowBinding) return null;
+
+  const learningCount = workflowBinding.learningCount || (workflowBinding.records || []).length || (workflowBinding.rules || []).length;
+
+  return {
+    enabled: true,
+    mcpServer: 'friday-auto-flow',
+    bindings: {
+      'auto-flow': {
+        name: '自动部署',
+        skill: 'auto-flow',
+        provider: 'friday-flow',
+        mcpServer: 'friday-auto-flow',
+        learningCount,
+        lastLearning: workflowBinding.lastLearning || null,
+        records: workflowBinding.records || [],
+        rules: workflowBinding.rules || []
+      }
+    },
+    defaultBinding: 'auto-flow'
+  };
+}
+
+function normalizeWorkflowTransport(transport) {
+  if (!transport || !transport.url) return null;
+
+  const headers = transport.headers || {};
+  const normalizedHeaders = {};
+  for (const [key, value] of Object.entries(headers)) {
+    if (value === undefined || value === null || value === '') continue;
+    normalizedHeaders[key] = value;
+  }
+
+  return {
+    url: transport.url,
+    type: transport.type || 'http',
+    headers: normalizedHeaders,
+    description: transport.description || 'Workflow MCP server'
+  };
+}
+
+async function discoverWorkflowTransport(options = {}) {
+  const direct = normalizeWorkflowTransport(options.workflowTransport);
+  if (direct) return direct;
+
+  const envUrl = process.env.FLOWMIND_AUTO_FLOW_MCP_URL;
+  if (envUrl) {
+    return normalizeWorkflowTransport({
+      url: envUrl,
+      type: 'http',
+      headers: process.env.FLOWMIND_AUTO_FLOW_MCP_TOKEN
+        ? { mcp_token: process.env.FLOWMIND_AUTO_FLOW_MCP_TOKEN }
+        : {},
+      description: 'Workflow MCP server from environment'
+    });
+  }
+
+  const debugDir = path.join(os.homedir(), '.claude', 'debug');
+  if (!await fs.pathExists(debugDir)) return null;
+
+  const entries = await fs.readdir(debugDir);
+  const candidates = [];
+  for (const entry of entries) {
+    const filePath = path.join(debugDir, entry);
+    try {
+      const stat = await fs.stat(filePath);
+      if (stat.isFile()) {
+        candidates.push({ filePath, mtimeMs: stat.mtimeMs });
+      }
+    } catch (error) {
+      // skip unreadable files
+    }
+  }
+
+  candidates.sort((a, b) => b.mtimeMs - a.mtimeMs);
+
+  for (const { filePath } of candidates.slice(0, 10)) {
+    try {
+      const content = await fs.readFile(filePath, 'utf8');
+      const match = content.match(/MCP server "friday-auto-flow": HTTP transport options: (\{[^\n]+\})/);
+      if (!match) continue;
+
+      const parsed = JSON.parse(match[1]);
+      return normalizeWorkflowTransport({
+        url: parsed.url,
+        type: parsed.type || 'http',
+        headers: parsed.headers || {},
+        description: 'Workflow MCP server discovered from Claude debug logs'
+      });
+    } catch (error) {
+      // continue scanning other files
+    }
+  }
+
+  return null;
+}
+
+function buildWorkflowBindings(skillBindingData = {}, workflowTransport = null) {
+  const workflowBinding = skillBindingData.bindings?.['auto-flow'];
+  if (!workflowBinding) return [];
+
+  const ruleSummaries = (workflowBinding.records || []).map((record) => record.summary).filter(Boolean);
+  const ruleActions = (workflowBinding.rules || []).map((rule) => rule.action).filter(Boolean);
+  const keywords = [
+    'auto-flow',
+    'workflow',
+    'pipeline',
+    'deploy',
+    'deployment',
+    '部署',
+    '发布',
+    '上线',
+    '流水线',
+    ...ruleSummaries,
+    ...ruleActions
+  ];
+
+  return [{
+    id: 'sdd-workflow-auto-flow',
+    timestamp: new Date().toISOString(),
+    business: '自动部署',
+    aliases: [
+      'auto-flow',
+      'workflow',
+      'pipeline',
+      '飞流',
+      '飞流部署',
+      '部署',
+      '发布',
+      '上线',
+      '流水线'
+    ],
+    componentType: 'workflow',
+    provider: 'friday-flow',
+    mcpServer: 'friday-auto-flow',
+    source: 'sdd-agent-sync',
+    keywords: [...new Set(keywords.filter(Boolean))],
+    connection: {
+      skill: 'auto-flow',
+      learningCount: workflowBinding.learningCount || 0,
+      lastLearning: workflowBinding.lastLearning || null,
+      records: workflowBinding.records || [],
+      rules: workflowBinding.rules || [],
+      transport: workflowTransport ? {
+        url: workflowTransport.url,
+        type: workflowTransport.type
+      } : undefined
+    },
+    metadata: {
+      source: 'sdd-agent',
+      resourceType: 'workflow',
+      bindingKey: 'auto-flow'
+    },
+    stats: {
+      useCount: 0,
+      lastUsed: null
+    }
+  }];
+}
+
+function convertResourceBindings(sddConfig, skillBindingData = {}, workflowTransport = null) {
   const resources = sddConfig.resources || {};
   const aliasIndex = buildAliasIndex(sddConfig.aliases);
   const bindings = [];
@@ -189,6 +365,8 @@ function convertResourceBindings(sddConfig) {
     }
   }
 
+  bindings.push(...buildWorkflowBindings(skillBindingData, workflowTransport));
+
   return bindings;
 }
 
@@ -223,9 +401,13 @@ function convertSceneMappings(sceneData = {}) {
   }));
 }
 
-function buildComponentConfig(sddConfig) {
+function buildComponentConfig(sddConfig, skillBindingData = {}, workflowTransport = null) {
   const resources = sddConfig.resources || {};
+  const workflowResource = resources.workflow || buildWorkflowResource(skillBindingData);
   const components = {};
+  const directQueryServer = resources.database?.mcpServers?.directQuery
+    || resources.redis?.mcpServers?.directQuery
+    || null;
 
   if (resources.sls?.enabled) {
     const defaultEnv = resources.sls.defaultEnv || 'uat';
@@ -261,6 +443,18 @@ function buildComponentConfig(sddConfig) {
     };
   }
 
+  if ((resources.database?.enabled || resources.redis?.enabled) && directQueryServer) {
+    components.databaseQuery = {
+      default: 'aliyun-rds-query',
+      providers: {
+        'aliyun-rds-query': {
+          enabled: true,
+          mcpServer: normalizeMcpServer(directQueryServer)
+        }
+      }
+    };
+  }
+
   if (resources.redis?.enabled && resources.redis.mcpServers?.monitor) {
     components.redisMonitor = {
       default: 'aliyun-redis',
@@ -297,13 +491,14 @@ function buildComponentConfig(sddConfig) {
     };
   }
 
-  if (resources.workflow?.enabled && resources.workflow.mcpServer) {
+  if (workflowResource?.enabled && workflowResource.mcpServer) {
     components.workflow = {
       default: 'friday-flow',
       providers: {
         'friday-flow': {
           enabled: true,
-          mcpServer: normalizeMcpServer(resources.workflow.mcpServer)
+          mcpServer: normalizeMcpServer(workflowResource.mcpServer),
+          ...(workflowTransport ? { transport: workflowTransport } : {})
         }
       }
     };
@@ -388,11 +583,124 @@ async function readJsonIfExists(filePath, fallback) {
   return fs.readJson(filePath);
 }
 
+async function statIfExists(filePath) {
+  try {
+    return await fs.stat(filePath);
+  } catch (error) {
+    return null;
+  }
+}
+
+async function copySelectedSourceFiles(sourceDir, targetDir) {
+  const sourceRoot = path.join(sourceDir, 'source');
+  const copied = [];
+
+  if (!(await fs.pathExists(sourceRoot))) {
+    return copied;
+  }
+
+  await fs.ensureDir(targetDir);
+
+  for (const fileName of SDD_SOURCE_SYNC_FILES) {
+    const sourcePath = path.join(sourceRoot, fileName);
+    if (!(await fs.pathExists(sourcePath))) {
+      continue;
+    }
+
+    const targetPath = path.join(targetDir, fileName);
+    await fs.copy(sourcePath, targetPath, { overwrite: true, dereference: true });
+    copied.push({
+      name: fileName,
+      sourcePath,
+      targetPath
+    });
+  }
+
+  return copied;
+}
+
+async function buildSyncSignature(sourceDir) {
+  const trackedFiles = [
+    path.join(sourceDir, 'resource-config.json'),
+    path.join(sourceDir, 'learning', 'scene-mappings.json'),
+    path.join(sourceDir, 'learning', 'skill-bindings.json'),
+    ...SDD_SOURCE_SYNC_FILES.map((fileName) => path.join(sourceDir, 'source', fileName))
+  ];
+
+  const entries = [];
+  for (const filePath of trackedFiles) {
+    const stat = await statIfExists(filePath);
+    if (!stat) continue;
+    entries.push({
+      path: filePath,
+      size: stat.size,
+      mtimeMs: stat.mtimeMs
+    });
+  }
+
+  entries.sort((a, b) => a.path.localeCompare(b.path));
+  return JSON.stringify(entries);
+}
+
+async function autoSyncSddAgentToFlowMind(options = {}) {
+  if (process.env.FLOWMIND_DISABLE_SDD_AGENT_AUTO_SYNC === '1') {
+    return { synced: false, skipped: true, reason: 'disabled' };
+  }
+
+  const sourceDir = options.sourceDir || path.join(os.homedir(), '.sdd-agent');
+  const targetHome = options.targetHome || getHomeDir();
+  const sourceConfigPath = path.join(sourceDir, 'resource-config.json');
+
+  if (!(await fs.pathExists(sourceConfigPath))) {
+    return { synced: false, skipped: true, reason: 'missing-source-config' };
+  }
+
+  const targetDir = path.join(targetHome, '.flowmind');
+  const statePath = path.join(targetDir, 'sdd-agent-sync-state.json');
+  const signature = await buildSyncSignature(sourceDir);
+  const previousState = await readJsonIfExists(statePath, null);
+
+  if (previousState?.signature === signature) {
+    return {
+      synced: false,
+      skipped: true,
+      reason: 'up-to-date',
+      sourceDir,
+      targetDir,
+      statePath
+    };
+  }
+
+  const summary = await syncSddAgentToFlowMind({
+    ...options,
+    sourceDir,
+    targetHome
+  });
+
+  await fs.ensureDir(targetDir);
+  await fs.writeJson(statePath, {
+    sourceDir,
+    targetDir,
+    signature,
+    syncedAt: new Date().toISOString(),
+    files: summary.files,
+    counts: summary.counts
+  }, { spaces: 2 });
+
+  return {
+    synced: true,
+    skipped: false,
+    statePath,
+    ...summary
+  };
+}
+
 async function syncSddAgentToFlowMind(options = {}) {
   const sourceDir = options.sourceDir || path.join(os.homedir(), '.sdd-agent');
   const targetHome = options.targetHome || getHomeDir();
   const sourceConfigPath = path.join(sourceDir, 'resource-config.json');
   const sourceScenesPath = path.join(sourceDir, 'learning', 'scene-mappings.json');
+  const sourceSkillBindingsPath = path.join(sourceDir, 'learning', 'skill-bindings.json');
   const targetDir = path.join(targetHome, '.flowmind');
   const targetLearningDir = path.join(targetDir, 'learning');
 
@@ -402,20 +710,30 @@ async function syncSddAgentToFlowMind(options = {}) {
 
   const sddConfig = await fs.readJson(sourceConfigPath);
   const sddScenes = await readJsonIfExists(sourceScenesPath, { mappings: [] });
+  const sddSkillBindings = await readJsonIfExists(sourceSkillBindingsPath, { version: '1.0', bindings: {} });
+  sddConfig.skillBindings = sddSkillBindings;
+  const workflowTransport = await discoverWorkflowTransport(options);
+  if (workflowTransport) {
+    sddConfig.mcpServers = {
+      ...(sddConfig.mcpServers || {}),
+      'friday-auto-flow': workflowTransport
+    };
+  }
 
   const targetResourceConfigPath = path.join(targetDir, 'resource-config.json');
   const targetComponentConfigPath = path.join(targetDir, 'component-config.json');
   const targetBindingsPath = path.join(targetLearningDir, 'resource-bindings.json');
   const targetScenesPath = path.join(targetLearningDir, 'scenes.json');
+  const targetSourceDir = path.join(targetDir, 'source');
 
   const existingResourceConfig = await readJsonIfExists(targetResourceConfigPath, {});
   const existingComponentConfig = await readJsonIfExists(targetComponentConfigPath, { version: '1.0.0', components: {} });
   const existingBindings = await readJsonIfExists(targetBindingsPath, { version: '1.0', bindings: [] });
   const existingScenes = await readJsonIfExists(targetScenesPath, { version: '1.0', mappings: [] });
 
-  const nextResourceConfig = deepMerge(existingResourceConfig, sanitizeResourceConfig(sddConfig));
-  const nextComponentConfig = deepMerge(existingComponentConfig, buildComponentConfig(sddConfig));
-  const importedBindings = convertResourceBindings(sddConfig);
+  const nextResourceConfig = deepMerge(existingResourceConfig, sanitizeResourceConfig(sddConfig, sddSkillBindings));
+  const nextComponentConfig = deepMerge(existingComponentConfig, buildComponentConfig(sddConfig, sddSkillBindings, workflowTransport));
+  const importedBindings = convertResourceBindings(sddConfig, sddSkillBindings, workflowTransport);
   const nextBindings = {
     version: existingBindings.version || '1.0',
     lastUpdated: new Date().toISOString(),
@@ -433,6 +751,7 @@ async function syncSddAgentToFlowMind(options = {}) {
   await fs.writeJson(targetComponentConfigPath, nextComponentConfig, { spaces: 2 });
   await fs.writeJson(targetBindingsPath, nextBindings, { spaces: 2 });
   await fs.writeJson(targetScenesPath, nextScenes, { spaces: 2 });
+  const copiedSourceFiles = await copySelectedSourceFiles(sourceDir, targetSourceDir);
 
   return {
     sourceDir,
@@ -441,14 +760,16 @@ async function syncSddAgentToFlowMind(options = {}) {
       resourceConfig: targetResourceConfigPath,
       componentConfig: targetComponentConfigPath,
       resourceBindings: targetBindingsPath,
-      scenes: targetScenesPath
+      scenes: targetScenesPath,
+      sourceFiles: copiedSourceFiles.map((item) => item.targetPath)
     },
     counts: {
       importedBindings: importedBindings.length,
       totalBindings: nextBindings.bindings.length,
       importedScenes: importedScenes.length,
       totalScenes: nextScenes.mappings.length,
-      components: Object.keys(nextComponentConfig.components || {}).length
+      components: Object.keys(nextComponentConfig.components || {}).length,
+      copiedSourceFiles: copiedSourceFiles.length
     }
   };
 }
@@ -461,7 +782,10 @@ module.exports = {
   deepMerge,
   mergeBindings,
   mergeScenes,
+  buildWorkflowBindings,
+  buildWorkflowResource,
   normalizeMcpServer,
   sanitizeResourceConfig,
-  syncSddAgentToFlowMind
+  syncSddAgentToFlowMind,
+  autoSyncSddAgentToFlowMind
 };