flowmind 1.0.0

package/core/mcp-compatibility.js

@@ -0,0 +1,150 @@
+/**
+ * FlowMind MCP Compatibility Layer
+ * Maps existing MCP server names to component types and providers.
+ * Ensures backward compatibility with existing configurations.
+ */
+
+const { ComponentType } = require('./component-types');
+
+/**
+ * Mapping from MCP server names to their component type and provider.
+ * This allows skills that reference MCP servers directly to work
+ * with the new component architecture.
+ */
+const McpServerMapping = Object.freeze({
+  // Log Service
+  'friday-sls-logs': {
+    type: ComponentType.LOG_SERVICE,
+    provider: 'aliyun-sls',
+    description: 'Alibaba Cloud SLS log queries'
+  },
+
+  // Database Manager
+  'aliyun-dms-mcp-server': {
+    type: ComponentType.DATABASE_MANAGER,
+    provider: 'aliyun-dms',
+    description: 'Alibaba Cloud DMS database management'
+  },
+
+  // Database Query
+  'friday-rds-redis-query': {
+    type: ComponentType.DATABASE_QUERY,
+    provider: 'aliyun-rds-query',
+    description: 'Direct database and Redis querying'
+  },
+
+  // Redis Monitor
+  'friday-aliyun-sz-rds-redis': {
+    type: ComponentType.REDIS_MONITOR,
+    provider: 'aliyun-redis',
+    description: 'Alibaba Cloud Redis monitoring via Prometheus'
+  },
+
+  // API Documentation
+  'aomi-yapi-mcp': {
+    type: ComponentType.API_DOC,
+    provider: 'yapi',
+    description: 'YApi API documentation management'
+  },
+
+  // Knowledge Base
+  'aomi-yuque-mcp': {
+    type: ComponentType.KNOWLEDGE_BASE,
+    provider: 'yuque',
+    description: 'Yuque knowledge base management'
+  },
+
+  // Workflow
+  'friday-auto-flow': {
+    type: ComponentType.WORKFLOW,
+    provider: 'friday-flow',
+    description: 'Friday automated workflow and pipeline management'
+  },
+
+  // Report
+  'friday-auto-report': {
+    type: ComponentType.REPORT,
+    provider: 'friday-report',
+    description: 'Friday automated test and coverage reporting'
+  }
+});
+
+/**
+ * Reverse mapping: from (componentType, provider) to MCP server name.
+ */
+const ProviderToMcp = Object.freeze({
+  'logService:aliyun-sls': 'friday-sls-logs',
+  'databaseManager:aliyun-dms': 'aliyun-dms-mcp-server',
+  'databaseQuery:aliyun-rds-query': 'friday-rds-redis-query',
+  'redisMonitor:aliyun-redis': 'friday-aliyun-sz-rds-redis',
+  'apiDoc:yapi': 'aomi-yapi-mcp',
+  'knowledgeBase:yuque': 'aomi-yuque-mcp',
+  'workflow:friday-flow': 'friday-auto-flow',
+  'report:friday-report': 'friday-auto-report'
+});
+
+class McpCompatibility {
+  /**
+   * Resolve an MCP server name to its component type and provider.
+   * @param {string} mcpServerName
+   * @returns {object|null} - { type, provider, description }
+   */
+  static resolve(mcpServerName) {
+    return McpServerMapping[mcpServerName] || null;
+  }
+
+  /**
+   * Get the MCP server name for a component type and provider.
+   * @param {string} componentType
+   * @param {string} provider
+   * @returns {string|null}
+   */
+  static getMcpServer(componentType, provider) {
+    const key = `${componentType}:${provider}`;
+    return ProviderToMcp[key] || null;
+  }
+
+  /**
+   * Get all known MCP server names.
+   * @returns {string[]}
+   */
+  static getAllMcpServers() {
+    return Object.keys(McpServerMapping);
+  }
+
+  /**
+   * Check if an MCP server name is known.
+   * @param {string} mcpServerName
+   * @returns {boolean}
+   */
+  static isKnown(mcpServerName) {
+    return mcpServerName in McpServerMapping;
+  }
+
+  /**
+   * Get the component type for an MCP server.
+   * @param {string} mcpServerName
+   * @returns {string|null}
+   */
+  static getType(mcpServerName) {
+    const mapping = McpServerMapping[mcpServerName];
+    return mapping ? mapping.type : null;
+  }
+
+  /**
+   * Get all mappings for a given component type.
+   * @param {string} componentType
+   * @returns {object[]}
+   */
+  static getByType(componentType) {
+    const results = [];
+    for (const [server, mapping] of Object.entries(McpServerMapping)) {
+      if (mapping.type === componentType) {
+        results.push({ mcpServer: server, ...mapping });
+      }
+    }
+    return results;
+  }
+}
+
+module.exports = McpCompatibility;

package/core/providers/aliyun/dms-adapter.js

@@ -0,0 +1,98 @@
+/**
+ * Aliyun DMS Database Manager Adapter
+ * Wraps the aliyun-dms-mcp-server MCP server for database management
+ */
+
+const DatabaseManagerAdapter = require('../../adapters/database-manager-adapter');
+
+class AliyunDmsAdapter extends DatabaseManagerAdapter {
+  constructor(config = {}) {
+    super('aliyun-dms', config);
+
+    // Register MCP tool mappings
+    this.registerTool('listInstances', 'listInstances');
+    this.registerTool('searchDatabase', 'searchDatabase');
+    this.registerTool('getDatabase', 'getDatabase');
+    this.registerTool('listTables', 'listTables');
+    this.registerTool('getTableDetailInfo', 'getTableDetailInfo');
+    this.registerTool('executeScript', 'executeScript');
+    this.registerTool('createDataChangeOrder', 'createDataChangeOrder');
+    this.registerTool('generateSql', 'generateSql');
+    this.registerTool('optimizeSql', 'optimizeSql');
+    this.registerTool('fixSql', 'fixSql');
+  }
+
+  get mcpServer() {
+    return 'aliyun-dms-mcp-server';
+  }
+
+  async listInstances(params) {
+    return {
+      mcpServer: this.mcpServer,
+      tool: this.resolveTool('listInstances'),
+      params: params || {}
+    };
+  }
+
+  async executeScript(params) {
+    return {
+      mcpServer: this.mcpServer,
+      tool: this.resolveTool('executeScript'),
+      params
+    };
+  }
+
+  async searchDatabase(searchKey) {
+    return {
+      mcpServer: this.mcpServer,
+      tool: this.resolveTool('searchDatabase'),
+      params: { search_key: searchKey }
+    };
+  }
+
+  async listTables(databaseId) {
+    return {
+      mcpServer: this.mcpServer,
+      tool: this.resolveTool('listTables'),
+      params: { database_id: databaseId }
+    };
+  }
+
+  async getTableDetail(tableGuid) {
+    return {
+      mcpServer: this.mcpServer,
+      tool: this.resolveTool('getTableDetailInfo'),
+      params: { table_guid: tableGuid }
+    };
+  }
+
+  /**
+   * Generate SQL from natural language.
+   * @param {string} databaseId
+   * @param {string} question
+   * @returns {Promise<object>}
+   */
+  async generateSql(databaseId, question) {
+    return {
+      mcpServer: this.mcpServer,
+      tool: this.resolveTool('generateSql'),
+      params: { database_id: databaseId, question }
+    };
+  }
+
+  /**
+   * Optimize a SQL statement.
+   * @param {string} databaseId
+   * @param {string} sql
+   * @returns {Promise<object>}
+   */
+  async optimizeSql(databaseId, sql) {
+    return {
+      mcpServer: this.mcpServer,
+      tool: this.resolveTool('optimizeSql'),
+      params: { database_id: databaseId, sql }
+    };
+  }
+}
+
+module.exports = AliyunDmsAdapter;

package/core/providers/aliyun/redis-adapter.js

@@ -0,0 +1,88 @@
+/**
+ * Aliyun Redis Monitor Adapter
+ * Wraps the friday-aliyun-sz-rds-redis MCP server for Redis monitoring via Prometheus
+ */
+
+const McpAdapter = require('../../adapters/mcp-adapter');
+const { ComponentType } = require('../../component-types');
+
+class AliyunRedisAdapter extends McpAdapter {
+  constructor(config = {}) {
+    super('aliyun-redis', config);
+
+    // Register MCP tool mappings
+    this.registerTool('query', 'query');
+    this.registerTool('queryRange', 'queryRange');
+    this.registerTool('getLabelNames', 'getLabelNames');
+    this.registerTool('getLabelValues', 'getLabelValues');
+    this.registerTool('getSeries', 'getSeries');
+    this.registerTool('getMetadata', 'getMetadata');
+  }
+
+  get componentType() {
+    return ComponentType.REDIS_MONITOR;
+  }
+
+  get mcpServer() {
+    return 'friday-aliyun-sz-rds-redis';
+  }
+
+  /**
+   * Query Prometheus metrics at a point in time.
+   * @param {string} query - PromQL expression
+   * @param {string} time - Optional evaluation timestamp
+   * @returns {Promise<object>}
+   */
+  async query(query, time) {
+    return {
+      mcpServer: this.mcpServer,
+      tool: this.resolveTool('query'),
+      params: { query, time }
+    };
+  }
+
+  /**
+   * Query Prometheus metrics over a time range.
+   * @param {string} query - PromQL expression
+   * @param {string} start
+   * @param {string} end
+   * @param {string} step
+   * @returns {Promise<object>}
+   */
+  async queryRange(query, start, end, step) {
+    return {
+      mcpServer: this.mcpServer,
+      tool: this.resolveTool('queryRange'),
+      params: { query, start, end, step }
+    };
+  }
+
+  /**
+   * Get available label names.
+   * @param {object} params
+   * @returns {Promise<object>}
+   */
+  async getLabelNames(params) {
+    return {
+      mcpServer: this.mcpServer,
+      tool: this.resolveTool('getLabelNames'),
+      params: params || {}
+    };
+  }
+
+  /**
+   * Get values for a specific label.
+   * @param {string} name - Label name
+   * @param {object} params
+   * @returns {Promise<object>}
+   */
+  async getLabelValues(name, params) {
+    return {
+      mcpServer: this.mcpServer,
+      tool: this.resolveTool('getLabelValues'),
+      params: { name, ...(params || {}) }
+    };
+  }
+}
+
+module.exports = AliyunRedisAdapter;

package/core/providers/aliyun/sls-adapter.js

@@ -0,0 +1,86 @@
+/**
+ * Aliyun SLS Log Service Adapter
+ * Wraps the friday-sls-logs MCP server for Alibaba Cloud SLS queries
+ */
+
+const LogServiceAdapter = require('../../adapters/log-service-adapter');
+
+class AliyunSlsAdapter extends LogServiceAdapter {
+  constructor(config = {}) {
+    super('aliyun-sls', config);
+
+    // Register MCP tool mappings
+    this.registerTool('queryLogs', 'queryLogs');
+    this.registerTool('listProject', 'listProject');
+  }
+
+  get mcpServer() {
+    return 'friday-sls-logs';
+  }
+
+  /**
+   * Get SLS endpoints from config.
+   * Falls back to default endpoints if not configured.
+   */
+  getEndpoints() {
+    if (this.config.config && this.config.config.endpoints) {
+      return this.config.config.endpoints;
+    }
+    return {
+      test: 'cn-shenzhen.log.aliyuncs.com',
+      prod: 'cn-hongkong.log.aliyuncs.com'
+    };
+  }
+
+  /**
+   * Get the endpoint for a given environment.
+   * @param {string} env - 'test', 'uat', 'gray', 'prod'
+   * @returns {string}
+   */
+  getEndpoint(env) {
+    const endpoints = this.getEndpoints();
+    // uat maps to test, gray maps to prod
+    const envMap = { uat: 'test', gray: 'prod' };
+    const mappedEnv = envMap[env] || env;
+    return endpoints[mappedEnv] || endpoints.test;
+  }
+
+  async queryLogs(params) {
+    return {
+      mcpServer: this.mcpServer,
+      tool: this.resolveTool('queryLogs'),
+      params
+    };
+  }
+
+  async listProjects() {
+    return {
+      mcpServer: this.mcpServer,
+      tool: this.resolveTool('listProject'),
+      params: {}
+    };
+  }
+
+  /**
+   * Build query parameters for SLS log query.
+   * @param {object} params
+   * @returns {object} MCP-compatible parameters
+   */
+  buildQueryParams(params) {
+    const { project, logstore, query, from, to, line = 100, env } = params;
+    const endpoint = this.getEndpoint(env || 'test');
+
+    return {
+      endpoint,
+      project: project || this.config.config?.defaultProject,
+      logstore: logstore || this.config.config?.defaultLogstore,
+      query: query || '',
+      from,
+      to,
+      line,
+      reverse: true
+    };
+  }
+}
+
+module.exports = AliyunSlsAdapter;

package/core/providers/friday/flow-adapter.js

@@ -0,0 +1,85 @@
+/**
+ * Friday Workflow Adapter
+ * Wraps the friday-auto-flow MCP server for workflow and pipeline management
+ */
+
+const WorkflowAdapter = require('../../adapters/workflow-adapter');
+
+class FridayFlowAdapter extends WorkflowAdapter {
+  constructor(config = {}) {
+    super('friday-flow', config);
+
+    // Register MCP tool mappings
+    this.registerTool('listPipelineGroups', 'flowListPipelineGroups');
+    this.registerTool('getPipelineGroup', 'flowGetPipelineGroup');
+    this.registerTool('listPipelineGroupPipelines', 'flowListPipelineGroupPipelines');
+    this.registerTool('listPipelines', 'flowListPipelines');
+    this.registerTool('getPipeline', 'flowGetPipeline');
+    this.registerTool('startPipelineRun', 'flowStartPipelineRun');
+    this.registerTool('startBatchPipelineRun', 'flowStartBatchPipelineRun');
+    this.registerTool('getPipelineRun', 'flowGetPipelineRun');
+    this.registerTool('listPipelineRuns', 'flowListPipelineRuns');
+    this.registerTool('stopPipelineRun', 'flowStopPipelineRun');
+    this.registerTool('retryPipelineJobRun', 'flowRetryPipelineJobRun');
+    this.registerTool('stopPipelineJobRun', 'flowStopPipelineJobRun');
+    this.registerTool('skipPipelineJobRun', 'flowSkipPipelineJobRun');
+    this.registerTool('logPipelineJobRun', 'flowLogPipelineJobRun');
+    this.registerTool('passPipelineValidate', 'flowPassPipelineValidate');
+    this.registerTool('refusePipelineValidate', 'flowRefusePipelineValidate');
+
+    // Order/task tools
+    this.registerTool('orderList', 'orderList');
+    this.registerTool('getOrderInfo', 'getOrderInfoByOrderId');
+    this.registerTool('getProcessJson', 'getProcessJson');
+    this.registerTool('demandPoolList', 'demandPoolList');
+    this.registerTool('getAllTaskList', 'getAllTaskList');
+    this.registerTool('getCurrentIterate', 'getCurrentIterate');
+    this.registerTool('iterateList', 'iterateList');
+  }
+
+  get mcpServer() {
+    return 'friday-auto-flow';
+  }
+
+  async listPipelineGroups(params) {
+    return {
+      mcpServer: this.mcpServer,
+      tool: this.resolveTool('listPipelineGroups'),
+      params: params || { perPage: '20', page: '1' }
+    };
+  }
+
+  async listPipelines(params) {
+    return {
+      mcpServer: this.mcpServer,
+      tool: this.resolveTool('listPipelines'),
+      params: params || {}
+    };
+  }
+
+  async startPipelineRun(pipelineId) {
+    return {
+      mcpServer: this.mcpServer,
+      tool: this.resolveTool('startPipelineRun'),
+      params: { pipelineId }
+    };
+  }
+
+  async getPipelineRun(pipelineId, runId) {
+    return {
+      mcpServer: this.mcpServer,
+      tool: this.resolveTool('getPipelineRun'),
+      params: { pipelineId, pipelineRunId: runId }
+    };
+  }
+
+  async listPipelineRuns(pipelineId, params) {
+    return {
+      mcpServer: this.mcpServer,
+      tool: this.resolveTool('listPipelineRuns'),
+      params: { pipelineId, ...(params || {}) }
+    };
+  }
+}
+
+module.exports = FridayFlowAdapter;

package/core/providers/friday/report-adapter.js

@@ -0,0 +1,83 @@
+/**
+ * Friday Report Adapter
+ * Wraps the friday-auto-report MCP server for Jenkins builds and test reports
+ */
+
+const ReportAdapter = require('../../adapters/report-adapter');
+
+class FridayReportAdapter extends ReportAdapter {
+  constructor(config = {}) {
+    super('friday-report', config);
+
+    // Register MCP tool mappings
+    this.registerTool('listBuilds', 'listJenkinsBuilds');
+    this.registerTool('getBuildInfo', 'getJenkinsBuild');
+    this.registerTool('getBuildText', 'getJenkinsBuildText');
+    this.registerTool('replayBuild', 'replayJenkinsBuild');
+    this.registerTool('stopBuild', 'stopJenkinsBuild');
+    this.registerTool('listJobs', 'listJenkinsJobs');
+    this.registerTool('getJobDetails', 'getJenkinsJobDetails');
+    this.registerTool('getJobNames', 'getJenkinsJobNames');
+    this.registerTool('getViews', 'getJenkinsView');
+    this.registerTool('buildCounts', 'getJenkinsBuildCounts');
+    this.registerTool('getLastJobBuild', 'getLastJobBuild');
+    this.registerTool('buildJenkinsJob', 'buildJenkinsJob');
+
+    // Jacoco coverage tools
+    this.registerTool('listJacoco', 'listJacoco');
+    this.registerTool('listJacocoUnit', 'listJacocoUnit');
+    this.registerTool('createJacocoReport', 'creatJacocoReport');
+    this.registerTool('createUnitReport', 'creatUnitReport');
+
+    // Git tools
+    this.registerTool('getBranches', 'getBranches');
+    this.registerTool('getCommits', 'getCommits');
+    this.registerTool('getSingleCommits', 'getSingleCommits');
+  }
+
+  get mcpServer() {
+    return 'friday-auto-report';
+  }
+
+  async listBuilds(params) {
+    return {
+      mcpServer: this.mcpServer,
+      tool: this.resolveTool('listBuilds'),
+      params: params || {}
+    };
+  }
+
+  async getBuildInfo(buildId) {
+    return {
+      mcpServer: this.mcpServer,
+      tool: this.resolveTool('getBuildInfo'),
+      params: { id: buildId }
+    };
+  }
+
+  async listJacocoReports(params) {
+    return {
+      mcpServer: this.mcpServer,
+      tool: this.resolveTool('listJacoco'),
+      params: params || {}
+    };
+  }
+
+  async listUnitReports(params) {
+    return {
+      mcpServer: this.mcpServer,
+      tool: this.resolveTool('listJacocoUnit'),
+      params: params || {}
+    };
+  }
+
+  async getJobDetails(jobName) {
+    return {
+      mcpServer: this.mcpServer,
+      tool: this.resolveTool('getJobDetails'),
+      params: { jobName }
+    };
+  }
+}
+
+module.exports = FridayReportAdapter;

package/core/providers/yapi/yapi-adapter.js

@@ -0,0 +1,79 @@
+/**
+ * YApi API Documentation Adapter
+ * Wraps the aomi-yapi-mcp MCP server for YApi platform management
+ */
+
+const ApiDocAdapter = require('../../adapters/api-doc-adapter');
+
+class YapiAdapter extends ApiDocAdapter {
+  constructor(config = {}) {
+    super('yapi', config);
+
+    // Register MCP tool mappings
+    this.registerTool('searchApis', 'yapi_search_apis');
+    this.registerTool('getCategories', 'yapi_get_categories');
+    this.registerTool('saveApi', 'yapi_save_api');
+    this.registerTool('getApiDesc', 'yapi_get_api_desc');
+    this.registerTool('importSwagger', 'yapi_import_swagger');
+    this.registerTool('exportProject', 'yapi_export_project');
+    this.registerTool('listProjects', 'yapi_list_projects');
+    this.registerTool('createCategory', 'yapi_create_category');
+    this.registerTool('deleteInterface', 'yapi_delete_interface');
+    this.registerTool('copyInterface', 'yapi_copy_interface');
+    this.registerTool('refreshCache', 'yapi_refresh_cache');
+  }
+
+  get mcpServer() {
+    return 'aomi-yapi-mcp';
+  }
+
+  async searchApis(params) {
+    return {
+      mcpServer: this.mcpServer,
+      tool: this.resolveTool('searchApis'),
+      params
+    };
+  }
+
+  async getCategories(projectId) {
+    return {
+      mcpServer: this.mcpServer,
+      tool: this.resolveTool('getCategories'),
+      params: { projectId }
+    };
+  }
+
+  async saveApi(apiData) {
+    return {
+      mcpServer: this.mcpServer,
+      tool: this.resolveTool('saveApi'),
+      params: apiData
+    };
+  }
+
+  async importSwagger(projectId, catId, swaggerData) {
+    return {
+      mcpServer: this.mcpServer,
+      tool: this.resolveTool('importSwagger'),
+      params: { projectId, catId, swaggerData }
+    };
+  }
+
+  async exportProject(projectId, type = 'swagger') {
+    return {
+      mcpServer: this.mcpServer,
+      tool: this.resolveTool('exportProject'),
+      params: { projectId, type }
+    };
+  }
+
+  async listProjects() {
+    return {
+      mcpServer: this.mcpServer,
+      tool: this.resolveTool('listProjects'),
+      params: {}
+    };
+  }
+}
+
+module.exports = YapiAdapter;