flowmind 1.0.0

package/core/adapters/database-query-adapter.js

@@ -0,0 +1,51 @@
+/**
+ * FlowMind Database Query Adapter Interface
+ * Abstract interface for direct database query services
+ */
+
+const McpAdapter = require('./mcp-adapter');
+const { ComponentType } = require('../component-types');
+
+class DatabaseQueryAdapter extends McpAdapter {
+  get componentType() {
+    return ComponentType.DATABASE_QUERY;
+  }
+
+  /**
+   * Get available data sources.
+   * @returns {Promise<object>}
+   */
+  async fetchSources() {
+    throw new Error('Subclasses must implement fetchSources()');
+  }
+
+  /**
+   * Get databases for a data source.
+   * @param {string} sourceId
+   * @returns {Promise<object>}
+   */
+  async fetchDatabases(sourceId) {
+    throw new Error('Subclasses must implement fetchDatabases()');
+  }
+
+  /**
+   * Get tables in a database.
+   * @param {string} sourceId
+   * @param {string} schema
+   * @returns {Promise<object>}
+   */
+  async fetchTables(sourceId, schema) {
+    throw new Error('Subclasses must implement fetchTables()');
+  }
+
+  /**
+   * Execute a SELECT query.
+   * @param {object} params - { source_id, schema, sql }
+   * @returns {Promise<object>}
+   */
+  async queryExec(params) {
+    throw new Error('Subclasses must implement queryExec()');
+  }
+}
+
+module.exports = DatabaseQueryAdapter;

package/core/adapters/knowledge-base-adapter.js

@@ -0,0 +1,75 @@
+/**
+ * FlowMind Knowledge Base Adapter Interface
+ * Abstract interface for knowledge base services (Yuque, Notion, Confluence, etc.)
+ */
+
+const McpAdapter = require('./mcp-adapter');
+const { ComponentType } = require('../component-types');
+
+class KnowledgeBaseAdapter extends McpAdapter {
+  get componentType() {
+    return ComponentType.KNOWLEDGE_BASE;
+  }
+
+  /**
+   * Get user's repositories/knowledge bases.
+   * @param {object} params
+   * @returns {Promise<object>}
+   */
+  async getRepos(params) {
+    throw new Error('Subclasses must implement getRepos()');
+  }
+
+  /**
+   * Get documents in a repository.
+   * @param {string} namespace
+   * @param {object} params
+   * @returns {Promise<object>}
+   */
+  async getDocs(namespace, params) {
+    throw new Error('Subclasses must implement getDocs()');
+  }
+
+  /**
+   * Get a specific document.
+   * @param {string} namespace
+   * @param {string} slug
+   * @returns {Promise<object>}
+   */
+  async getDoc(namespace, slug) {
+    throw new Error('Subclasses must implement getDoc()');
+  }
+
+  /**
+   * Create a new document.
+   * @param {string} namespace
+   * @param {object} docData - { slug, title, body, format }
+   * @returns {Promise<object>}
+   */
+  async createDoc(namespace, docData) {
+    throw new Error('Subclasses must implement createDoc()');
+  }
+
+  /**
+   * Update an existing document.
+   * @param {string} namespace
+   * @param {string} slug
+   * @param {object} docData
+   * @returns {Promise<object>}
+   */
+  async updateDoc(namespace, slug, docData) {
+    throw new Error('Subclasses must implement updateDoc()');
+  }
+
+  /**
+   * Search documents or repositories.
+   * @param {string} query
+   * @param {string} type - 'doc' or 'repo'
+   * @returns {Promise<object>}
+   */
+  async search(query, type) {
+    throw new Error('Subclasses must implement search()');
+  }
+}
+
+module.exports = KnowledgeBaseAdapter;

package/core/adapters/log-service-adapter.js

@@ -0,0 +1,41 @@
+/**
+ * FlowMind Log Service Adapter Interface
+ * Abstract interface for cloud log service providers (SLS, ELK, etc.)
+ */
+
+const McpAdapter = require('./mcp-adapter');
+const { ComponentType } = require('../component-types');
+
+class LogServiceAdapter extends McpAdapter {
+  get componentType() {
+    return ComponentType.LOG_SERVICE;
+  }
+
+  /**
+   * Get available log store endpoints.
+   * @returns {object} Map of environment to endpoint
+   */
+  getEndpoints() {
+    return this.config.endpoints || {};
+  }
+
+  /**
+   * Query logs with parameters.
+   * Subclasses must implement the actual MCP tool call.
+   * @param {object} params - { project, logstore, query, from, to, line }
+   * @returns {Promise<object>}
+   */
+  async queryLogs(params) {
+    throw new Error('Subclasses must implement queryLogs()');
+  }
+
+  /**
+   * List available projects.
+   * @returns {Promise<object>}
+   */
+  async listProjects() {
+    throw new Error('Subclasses must implement listProjects()');
+  }
+}
+
+module.exports = LogServiceAdapter;

package/core/adapters/mcp-adapter.js

@@ -0,0 +1,65 @@
+/**
+ * FlowMind MCP Adapter
+ * Base class for adapters that wrap MCP server tools
+ */
+
+const BaseAdapter = require('./base-adapter');
+
+class McpAdapter extends BaseAdapter {
+  constructor(providerName, config = {}) {
+    super(providerName, config);
+    this.mcpTools = new Map();
+  }
+
+  /**
+   * Register an MCP tool mapping.
+   * @param {string} localName - The abstract tool name used by skills
+   * @param {string} mcpToolName - The actual MCP tool name on the server
+   */
+  registerTool(localName, mcpToolName) {
+    this.mcpTools.set(localName, mcpToolName);
+  }
+
+  /**
+   * Get the actual MCP tool name for a local tool name.
+   * @param {string} localName
+   * @returns {string|null}
+   */
+  resolveTool(localName) {
+    return this.mcpTools.get(localName) || null;
+  }
+
+  /**
+   * Get all registered tool mappings.
+   * @returns {object}
+   */
+  getToolMappings() {
+    const mappings = {};
+    for (const [local, mcp] of this.mcpTools) {
+      mappings[local] = mcp;
+    }
+    return mappings;
+  }
+
+  /**
+   * Get the list of abstract tool names this adapter provides.
+   * @returns {string[]}
+   */
+  getProvidedTools() {
+    return Array.from(this.mcpTools.keys());
+  }
+
+  /**
+   * Get the MCP server name for tool invocation context.
+   * Skills use this to know which MCP server to call.
+   * @returns {string}
+   */
+  getMcpServerContext() {
+    return {
+      server: this.mcpServer,
+      tools: this.getToolMappings()
+    };
+  }
+}
+
+module.exports = McpAdapter;

package/core/adapters/report-adapter.js

@@ -0,0 +1,60 @@
+/**
+ * FlowMind Report Adapter Interface
+ * Abstract interface for automated reporting services
+ */
+
+const McpAdapter = require('./mcp-adapter');
+const { ComponentType } = require('../component-types');
+
+class ReportAdapter extends McpAdapter {
+  get componentType() {
+    return ComponentType.REPORT;
+  }
+
+  /**
+   * List Jenkins builds.
+   * @param {object} params
+   * @returns {Promise<object>}
+   */
+  async listBuilds(params) {
+    throw new Error('Subclasses must implement listBuilds()');
+  }
+
+  /**
+   * Get build details.
+   * @param {string} buildId
+   * @returns {Promise<object>}
+   */
+  async getBuildInfo(buildId) {
+    throw new Error('Subclasses must implement getBuildInfo()');
+  }
+
+  /**
+   * List Jacoco coverage reports.
+   * @param {object} params
+   * @returns {Promise<object>}
+   */
+  async listJacocoReports(params) {
+    throw new Error('Subclasses must implement listJacocoReports()');
+  }
+
+  /**
+   * List unit test reports.
+   * @param {object} params
+   * @returns {Promise<object>}
+   */
+  async listUnitReports(params) {
+    throw new Error('Subclasses must implement listUnitReports()');
+  }
+
+  /**
+   * Get Jenkins job details.
+   * @param {string} jobName
+   * @returns {Promise<object>}
+   */
+  async getJobDetails(jobName) {
+    throw new Error('Subclasses must implement getJobDetails()');
+  }
+}
+
+module.exports = ReportAdapter;

package/core/adapters/workflow-adapter.js

@@ -0,0 +1,62 @@
+/**
+ * FlowMind Workflow Adapter Interface
+ * Abstract interface for workflow/pipeline services
+ */
+
+const McpAdapter = require('./mcp-adapter');
+const { ComponentType } = require('../component-types');
+
+class WorkflowAdapter extends McpAdapter {
+  get componentType() {
+    return ComponentType.WORKFLOW;
+  }
+
+  /**
+   * List pipeline groups.
+   * @param {object} params
+   * @returns {Promise<object>}
+   */
+  async listPipelineGroups(params) {
+    throw new Error('Subclasses must implement listPipelineGroups()');
+  }
+
+  /**
+   * List pipelines.
+   * @param {object} params
+   * @returns {Promise<object>}
+   */
+  async listPipelines(params) {
+    throw new Error('Subclasses must implement listPipelines()');
+  }
+
+  /**
+   * Start a pipeline run.
+   * @param {string} pipelineId
+   * @returns {Promise<object>}
+   */
+  async startPipelineRun(pipelineId) {
+    throw new Error('Subclasses must implement startPipelineRun()');
+  }
+
+  /**
+   * Get pipeline run status.
+   * @param {string} pipelineId
+   * @param {string} runId
+   * @returns {Promise<object>}
+   */
+  async getPipelineRun(pipelineId, runId) {
+    throw new Error('Subclasses must implement getPipelineRun()');
+  }
+
+  /**
+   * List pipeline runs.
+   * @param {string} pipelineId
+   * @param {object} params
+   * @returns {Promise<object>}
+   */
+  async listPipelineRuns(pipelineId, params) {
+    throw new Error('Subclasses must implement listPipelineRuns()');
+  }
+}
+
+module.exports = WorkflowAdapter;

package/core/component-registry.js

@@ -0,0 +1,281 @@
+/**
+ * FlowMind Component Registry
+ * Central registry for pluggable component adapters.
+ * Manages component discovery, registration, and provider switching.
+ */
+
+const { ComponentType, ComponentTypeMeta } = require('./component-types');
+const McpCompatibility = require('./mcp-compatibility');
+
+class ComponentRegistry {
+  constructor(config) {
+    this.config = config;
+    // Map<ComponentType, Map<providerName, adapter>>
+    this.adapters = new Map();
+    // Map<ComponentType, providerName> - which provider is active for each type
+    this.activeProviders = new Map();
+    // Built-in provider factories
+    this.providerFactories = new Map();
+    this.initialized = false;
+  }
+
+  /**
+   * Initialize the registry: register built-in providers and load config.
+   */
+  async init() {
+    this.registerBuiltinProviders();
+    await this.loadFromConfig();
+    this.initialized = true;
+  }
+
+  /**
+   * Register built-in provider factories.
+   */
+  registerBuiltinProviders() {
+    // Aliyun providers
+    this.registerFactory('aliyun-sls', () => {
+      const AliyunSlsAdapter = require('./providers/aliyun/sls-adapter');
+      return new AliyunSlsAdapter(this.getProviderConfig('logService', 'aliyun-sls'));
+    });
+    this.registerFactory('aliyun-dms', () => {
+      const AliyunDmsAdapter = require('./providers/aliyun/dms-adapter');
+      return new AliyunDmsAdapter(this.getProviderConfig('databaseManager', 'aliyun-dms'));
+    });
+    this.registerFactory('aliyun-redis', () => {
+      const AliyunRedisAdapter = require('./providers/aliyun/redis-adapter');
+      return new AliyunRedisAdapter(this.getProviderConfig('redisMonitor', 'aliyun-redis'));
+    });
+
+    // YApi provider
+    this.registerFactory('yapi', () => {
+      const YapiAdapter = require('./providers/yapi/yapi-adapter');
+      return new YapiAdapter(this.getProviderConfig('apiDoc', 'yapi'));
+    });
+
+    // Yuque provider
+    this.registerFactory('yuque', () => {
+      const YuqueAdapter = require('./providers/yuque/yuque-adapter');
+      return new YuqueAdapter(this.getProviderConfig('knowledgeBase', 'yuque'));
+    });
+
+    // Friday providers
+    this.registerFactory('friday-flow', () => {
+      const FridayFlowAdapter = require('./providers/friday/flow-adapter');
+      return new FridayFlowAdapter(this.getProviderConfig('workflow', 'friday-flow'));
+    });
+    this.registerFactory('friday-report', () => {
+      const FridayReportAdapter = require('./providers/friday/report-adapter');
+      return new FridayReportAdapter(this.getProviderConfig('report', 'friday-report'));
+    });
+  }
+
+  /**
+   * Get provider config from the component config.
+   * @param {string} componentType
+   * @param {string} providerName
+   * @returns {object}
+   */
+  getProviderConfig(componentType, providerName) {
+    const components = this.config.get('components', {});
+    const typeConfig = components[componentType] || {};
+    const providers = typeConfig.providers || {};
+    return providers[providerName] || {};
+  }
+
+  /**
+   * Register a provider factory function.
+   * @param {string} providerName
+   * @param {function} factory - Function that returns an adapter instance
+   */
+  registerFactory(providerName, factory) {
+    this.providerFactories.set(providerName, factory);
+  }
+
+  /**
+   * Load and activate providers based on configuration.
+   */
+  async loadFromConfig() {
+    const components = this.config.get('components', {});
+
+    for (const type of Object.values(ComponentType)) {
+      const typeConfig = components[type];
+      if (!typeConfig) continue;
+
+      const defaultProvider = typeConfig.default;
+      const providers = typeConfig.providers || {};
+
+      for (const [providerName, providerConfig] of Object.entries(providers)) {
+        if (providerConfig.enabled === false) continue;
+
+        const adapter = this.createAdapter(providerName, providerConfig);
+        if (adapter) {
+          this.register(type, providerName, adapter);
+        }
+      }
+
+      // Set default provider
+      if (defaultProvider && this.adapters.get(type)?.has(defaultProvider)) {
+        this.activeProviders.set(type, defaultProvider);
+      }
+    }
+  }
+
+  /**
+   * Create an adapter instance from a provider name.
+   * @param {string} providerName
+   * @param {object} providerConfig
+   * @returns {BaseAdapter|null}
+   */
+  createAdapter(providerName, providerConfig) {
+    const factory = this.providerFactories.get(providerName);
+    if (!factory) {
+      console.warn(`No factory registered for provider: ${providerName}`);
+      return null;
+    }
+    try {
+      return factory();
+    } catch (error) {
+      console.warn(`Failed to create adapter for ${providerName}:`, error.message);
+      return null;
+    }
+  }
+
+  /**
+   * Register an adapter for a component type.
+   * @param {string} componentType - ComponentType value
+   * @param {string} providerName
+   * @param {BaseAdapter} adapter
+   */
+  register(componentType, providerName, adapter) {
+    if (!this.adapters.has(componentType)) {
+      this.adapters.set(componentType, new Map());
+    }
+    this.adapters.get(componentType).set(providerName, adapter);
+
+    // If this is the first provider for this type, make it active
+    if (!this.activeProviders.has(componentType)) {
+      this.activeProviders.set(componentType, providerName);
+    }
+  }
+
+  /**
+   * Get the active adapter for a component type.
+   * @param {string} componentType
+   * @returns {BaseAdapter|null}
+   */
+  getAdapter(componentType) {
+    const providerName = this.activeProviders.get(componentType);
+    if (!providerName) return null;
+    const typeAdapters = this.adapters.get(componentType);
+    return typeAdapters ? typeAdapters.get(providerName) || null : null;
+  }
+
+  /**
+   * Get a specific adapter by type and provider name.
+   * @param {string} componentType
+   * @param {string} providerName
+   * @returns {BaseAdapter|null}
+   */
+  getAdapterByProvider(componentType, providerName) {
+    const typeAdapters = this.adapters.get(componentType);
+    return typeAdapters ? typeAdapters.get(providerName) || null : null;
+  }
+
+  /**
+   * Set the active provider for a component type.
+   * @param {string} componentType
+   * @param {string} providerName
+   */
+  setActiveProvider(componentType, providerName) {
+    const typeAdapters = this.adapters.get(componentType);
+    if (!typeAdapters || !typeAdapters.has(providerName)) {
+      throw new Error(`Provider ${providerName} not registered for ${componentType}`);
+    }
+    this.activeProviders.set(componentType, providerName);
+  }
+
+  /**
+   * Get the MCP server name for a component type.
+   * @param {string} componentType
+   * @returns {string|null}
+   */
+  getMcpServer(componentType) {
+    const adapter = this.getAdapter(componentType);
+    return adapter ? adapter.mcpServer : null;
+  }
+
+  /**
+   * Get the MCP server name by looking up from MCP compatibility layer.
+   * Used for backward compatibility with existing MCP server names.
+   * @param {string} mcpServerName
+   * @returns {object|null} - { type, provider, adapter }
+   */
+  resolveMcpServer(mcpServerName) {
+    return McpCompatibility.resolve(mcpServerName);
+  }
+
+  /**
+   * Get all registered providers for a component type.
+   * @param {string} componentType
+   * @returns {object[]}
+   */
+  getProviders(componentType) {
+    const typeAdapters = this.adapters.get(componentType);
+    if (!typeAdapters) return [];
+    const result = [];
+    for (const [name, adapter] of typeAdapters) {
+      result.push({
+        name,
+        active: this.activeProviders.get(componentType) === name,
+        ...adapter.getStatus()
+      });
+    }
+    return result;
+  }
+
+  /**
+   * Get the active provider name for a component type.
+   * @param {string} componentType
+   * @returns {string|null}
+   */
+  getActiveProvider(componentType) {
+    return this.activeProviders.get(componentType) || null;
+  }
+
+  /**
+   * Get a summary of all component types and their status.
+   * @returns {object}
+   */
+  getStatus() {
+    const status = {};
+    for (const type of Object.values(ComponentType)) {
+      const adapter = this.getAdapter(type);
+      status[type] = {
+        active: this.activeProviders.get(type) || null,
+        providers: this.getProviders(type).map(p => ({
+          name: p.name,
+          enabled: p.enabled,
+          mcpServer: p.mcpServer
+        }))
+      };
+    }
+    return status;
+  }
+
+  /**
+   * Initialize all registered adapters.
+   */
+  async initAll() {
+    for (const [type, typeAdapters] of this.adapters) {
+      for (const [name, adapter] of typeAdapters) {
+        try {
+          await adapter.init();
+        } catch (error) {
+          console.warn(`Failed to init adapter ${name} for ${type}:`, error.message);
+        }
+      }
+    }
+  }
+}
+
+module.exports = ComponentRegistry;

package/core/component-types.js

@@ -0,0 +1,63 @@
+/**
+ * FlowMind Component Types
+ * Defines all pluggable component type constants
+ */
+
+const ComponentType = Object.freeze({
+  LOG_SERVICE: 'logService',
+  DATABASE_MANAGER: 'databaseManager',
+  DATABASE_QUERY: 'databaseQuery',
+  REDIS_MONITOR: 'redisMonitor',
+  API_DOC: 'apiDoc',
+  KNOWLEDGE_BASE: 'knowledgeBase',
+  WORKFLOW: 'workflow',
+  REPORT: 'report'
+});
+
+/**
+ * Component type metadata - describes each component type
+ */
+const ComponentTypeMeta = Object.freeze({
+  [ComponentType.LOG_SERVICE]: {
+    name: 'Log Service',
+    description: 'Cloud log querying and analysis',
+    requiredCapabilities: ['queryLogs', 'listProjects']
+  },
+  [ComponentType.DATABASE_MANAGER]: {
+    name: 'Database Manager',
+    description: 'Database instance management and DDL/DML execution',
+    requiredCapabilities: ['listInstances', 'executeScript', 'searchDatabase']
+  },
+  [ComponentType.DATABASE_QUERY]: {
+    name: 'Database Query',
+    description: 'Direct database querying via SQL',
+    requiredCapabilities: ['queryExec', 'fetchSource', 'fetchTables']
+  },
+  [ComponentType.REDIS_MONITOR]: {
+    name: 'Redis Monitor',
+    description: 'Redis monitoring and key inspection',
+    requiredCapabilities: ['query', 'queryRange', 'getLabelValues']
+  },
+  [ComponentType.API_DOC]: {
+    name: 'API Documentation',
+    description: 'API documentation management and sync',
+    requiredCapabilities: ['searchApis', 'saveApi', 'getCategories']
+  },
+  [ComponentType.KNOWLEDGE_BASE]: {
+    name: 'Knowledge Base',
+    description: 'Knowledge base and document management',
+    requiredCapabilities: ['getRepos', 'getDocs', 'createDoc', 'updateDoc']
+  },
+  [ComponentType.WORKFLOW]: {
+    name: 'Workflow',
+    description: 'Automated workflow and pipeline management',
+    requiredCapabilities: ['listPipelines', 'startPipelineRun']
+  },
+  [ComponentType.REPORT]: {
+    name: 'Report',
+    description: 'Automated test and coverage reporting',
+    requiredCapabilities: ['listBuilds', 'getBuildInfo']
+  }
+});
+
+module.exports = { ComponentType, ComponentTypeMeta };