flowmind 1.0.0

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

@@ -0,0 +1,90 @@
+/**
+ * Yuque Knowledge Base Adapter
+ * Wraps the aomi-yuque-mcp MCP server for Yuque platform management
+ */
+
+const KnowledgeBaseAdapter = require('../../adapters/knowledge-base-adapter');
+
+class YuqueAdapter extends KnowledgeBaseAdapter {
+  constructor(config = {}) {
+    super('yuque', config);
+
+    // Register MCP tool mappings
+    this.registerTool('getRepos', 'get_user_repos');
+    this.registerTool('getDocs', 'get_repo_docs');
+    this.registerTool('getDoc', 'get_doc');
+    this.registerTool('createDoc', 'create_doc');
+    this.registerTool('updateDoc', 'update_doc');
+    this.registerTool('search', 'search');
+    this.registerTool('getCurrentUser', 'get_current_user');
+    this.registerTool('getUserDocs', 'get_user_docs');
+    this.registerTool('getGroupStatistics', 'get_group_statistics');
+    this.registerTool('getGroupMemberStatistics', 'get_group_member_statistics');
+  }
+
+  get mcpServer() {
+    return 'aomi-yuque-mcp';
+  }
+
+  async getRepos(params) {
+    return {
+      mcpServer: this.mcpServer,
+      tool: this.resolveTool('getRepos'),
+      params
+    };
+  }
+
+  async getDocs(namespace, params = {}) {
+    return {
+      mcpServer: this.mcpServer,
+      tool: this.resolveTool('getDocs'),
+      params: { namespace, ...params }
+    };
+  }
+
+  async getDoc(namespace, slug) {
+    return {
+      mcpServer: this.mcpServer,
+      tool: this.resolveTool('getDoc'),
+      params: { namespace, slug }
+    };
+  }
+
+  async createDoc(namespace, docData) {
+    return {
+      mcpServer: this.mcpServer,
+      tool: this.resolveTool('createDoc'),
+      params: { namespace, ...docData }
+    };
+  }
+
+  async updateDoc(namespace, slug, docData) {
+    return {
+      mcpServer: this.mcpServer,
+      tool: this.resolveTool('updateDoc'),
+      params: { namespace, slug, ...docData }
+    };
+  }
+
+  async search(query, type = 'doc') {
+    return {
+      mcpServer: this.mcpServer,
+      tool: this.resolveTool('search'),
+      params: { q: query, type }
+    };
+  }
+
+  /**
+   * Get current authenticated user info.
+   * @returns {Promise<object>}
+   */
+  async getCurrentUser() {
+    return {
+      mcpServer: this.mcpServer,
+      tool: this.resolveTool('getCurrentUser'),
+      params: {}
+    };
+  }
+}
+
+module.exports = YuqueAdapter;

package/core/scene-matcher.js

@@ -0,0 +1,326 @@
+/**
+ * FlowMind Scene Matcher
+ * Matches user input to scene workflows
+ */
+
+const fs = require('fs-extra');
+const path = require('path');
+
+class SceneMatcher {
+  constructor(config, learning) {
+    this.config = config;
+    this.learning = learning;
+    this.scenes = [];
+    this.initialized = false;
+  }
+
+  /**
+   * Load scenes from storage
+   */
+  async loadScenes() {
+    const learningPath = this.config.get('learning.storagePath', '~/.flowmind/learning');
+    const scenesPath = path.join(this.expandPath(learningPath), 'scenes.json');
+
+    if (await fs.pathExists(scenesPath)) {
+      const data = await fs.readJson(scenesPath);
+      this.scenes = data.mappings || [];
+    }
+
+    // Add built-in scenes
+    this.scenes.push(...this.getBuiltInScenes());
+
+    this.initialized = true;
+    return this.scenes;
+  }
+
+  /**
+   * Get built-in scene mappings
+   */
+  getBuiltInScenes() {
+    return [
+      {
+        id: 'builtin-log-trace',
+        name: 'Trace Log Query',
+        keywords: ['traceId', '链路', 'trace', '调用链', '日志'],
+        patterns: [
+          /查询.*traceId/i,
+          /查看.*链路/i,
+          /traceId.*分析/i,
+          /查询.*日志/i
+        ],
+        workflow: {
+          skills: [
+            { skill: 'log-audit', params: { action: 'query-trace' } }
+          ]
+        },
+        preferences: {
+          outputFormat: 'sequential-list'
+        },
+        stats: { useCount: 0, successRate: 1.0 }
+      },
+      {
+        id: 'builtin-log-error',
+        name: 'Error Log Query',
+        keywords: ['错误日志', '异常日志', 'error', 'exception'],
+        patterns: [
+          /查看.*错误日志/i,
+          /查询.*异常/i,
+          /error.*log/i
+        ],
+        workflow: {
+          skills: [
+            { skill: 'log-audit', params: { action: 'query-errors' } }
+          ]
+        },
+        preferences: {},
+        stats: { useCount: 0, successRate: 1.0 }
+      },
+      {
+        id: 'builtin-code-review',
+        name: 'Code Review',
+        keywords: ['代码审查', 'review', 'PR', '代码质量'],
+        patterns: [
+          /审查.*代码/i,
+          /review.*PR/i,
+          /代码.*检查/i
+        ],
+        workflow: {
+          skills: [
+            { skill: 'code-review', params: {} }
+          ]
+        },
+        preferences: {},
+        stats: { useCount: 0, successRate: 1.0 }
+      },
+      {
+        id: 'builtin-data-validation',
+        name: 'Data Validation',
+        keywords: ['数据验证', '数据检查', '验证', '逻辑验证'],
+        patterns: [
+          /验证.*数据/i,
+          /检查.*逻辑/i,
+          /数据.*正确/i
+        ],
+        workflow: {
+          skills: [
+            { skill: 'data-validation', params: {} }
+          ]
+        },
+        preferences: {},
+        stats: { useCount: 0, successRate: 1.0 }
+      }
+    ];
+  }
+
+  /**
+   * Match input to scenes
+   */
+  async match(input) {
+    if (!this.initialized) {
+      await this.loadScenes();
+    }
+
+    let bestMatch = null;
+    let bestScore = 0;
+
+    for (const scene of this.scenes) {
+      const score = this.calculateScore(input, scene);
+
+      if (score > bestScore) {
+        bestScore = score;
+        bestMatch = scene;
+      }
+    }
+
+    if (bestMatch && bestScore >= 0.5) {
+      return {
+        scene: bestMatch,
+        confidence: bestScore,
+        params: this.extractParams(input, bestMatch)
+      };
+    }
+
+    return null;
+  }
+
+  /**
+   * Calculate match score
+   */
+  calculateScore(input, scene) {
+    const weights = this.config.get('sceneMapping.weights', {
+      keywordMatch: 0.4,
+      patternMatch: 0.3,
+      historyScore: 0.2,
+      confidence: 0.1
+    });
+
+    // Keyword matching
+    const keywordScore = this.matchKeywords(input, scene.keywords) * weights.keywordMatch;
+
+    // Pattern matching
+    const patternScore = this.matchPatterns(input, scene.patterns) * weights.patternMatch;
+
+    // History score (based on usage)
+    const historyScore = Math.min((scene.stats?.useCount || 0) / 10, 1) * weights.historyScore;
+
+    // Confidence score (based on success rate)
+    const confidenceScore = (scene.stats?.successRate || 0.5) * weights.confidence;
+
+    return keywordScore + patternScore + historyScore + confidenceScore;
+  }
+
+  /**
+   * Match keywords
+   */
+  matchKeywords(input, keywords) {
+    if (!keywords || keywords.length === 0) return 0;
+
+    const inputLower = input.toLowerCase();
+    let matchCount = 0;
+
+    for (const keyword of keywords) {
+      if (inputLower.includes(keyword.toLowerCase())) {
+        matchCount++;
+      }
+    }
+
+    return matchCount / keywords.length;
+  }
+
+  /**
+   * Match patterns
+   */
+  matchPatterns(input, patterns) {
+    if (!patterns || patterns.length === 0) return 0;
+
+    let matchCount = 0;
+
+    for (const pattern of patterns) {
+      const regex = pattern instanceof RegExp ? pattern : new RegExp(pattern, 'i');
+      if (regex.test(input)) {
+        matchCount++;
+      }
+    }
+
+    return matchCount / patterns.length;
+  }
+
+  /**
+   * Extract parameters from input
+   */
+  extractParams(input, scene) {
+    const params = {};
+
+    // Extract trace ID
+    const traceMatch = input.match(/traceId\s*[:：]\s*(\w+)|traceId\s+(\w+)/i);
+    if (traceMatch) {
+      params.traceId = traceMatch[1] || traceMatch[2];
+    }
+
+    // Extract service name
+    const serviceMatch = input.match(/service\s*[:：]\s*(\w+)|(\w+)-service/i);
+    if (serviceMatch) {
+      params.service = serviceMatch[1] || serviceMatch[2];
+    }
+
+    // Extract time range
+    const timeMatch = input.match(/最近(\d+)(小时|天|分钟)/);
+    if (timeMatch) {
+      params.timeRange = {
+        value: parseInt(timeMatch[1]),
+        unit: timeMatch[2]
+      };
+    }
+
+    return params;
+  }
+
+  /**
+   * Update scene usage stats
+   */
+  async updateSceneStats(sceneId, success) {
+    const scene = this.scenes.find(s => s.id === sceneId);
+    if (!scene) return;
+
+    scene.stats.useCount++;
+    scene.stats.lastUsed = new Date().toISOString();
+
+    if (!success) {
+      const total = scene.stats.useCount;
+      const successes = total * scene.stats.successRate;
+      scene.stats.successRate = (successes) / total;
+    }
+
+    // Save updated scenes
+    await this.saveScenes();
+  }
+
+  /**
+   * Save scenes to storage
+   */
+  async saveScenes() {
+    const learningPath = this.config.get('learning.storagePath', '~/.flowmind/learning');
+    const scenesPath = path.join(this.expandPath(learningPath), 'scenes.json');
+
+    const data = {
+      version: '1.0',
+      lastUpdated: new Date().toISOString(),
+      mappings: this.scenes.filter(s => !s.id.startsWith('builtin-'))
+    };
+
+    await fs.writeJson(scenesPath, data, { spaces: 2 });
+  }
+
+  /**
+   * Add custom scene
+   */
+  async addScene(scene) {
+    const newScene = {
+      id: `scene-${Date.now()}`,
+      timestamp: new Date().toISOString(),
+      ...scene,
+      stats: {
+        useCount: 0,
+        lastUsed: null,
+        successRate: 1.0
+      }
+    };
+
+    this.scenes.push(newScene);
+    await this.saveScenes();
+
+    return newScene;
+  }
+
+  /**
+   * Remove scene
+   */
+  async removeScene(sceneId) {
+    this.scenes = this.scenes.filter(s => s.id !== sceneId);
+    await this.saveScenes();
+  }
+
+  /**
+   * List all scenes
+   */
+  listScenes() {
+    return this.scenes.map(s => ({
+      id: s.id,
+      name: s.name,
+      keywords: s.keywords,
+      useCount: s.stats?.useCount || 0
+    }));
+  }
+
+  /**
+   * Helper to expand path
+   */
+  expandPath(filePath) {
+    if (filePath.startsWith('~')) {
+      return path.join(process.env.HOME || process.env.USERPROFILE, filePath.slice(1));
+    }
+    return filePath;
+  }
+}
+
+module.exports = SceneMatcher;

package/core/skill-loader.js

@@ -0,0 +1,291 @@
+/**
+ * FlowMind Skill Loader
+ * Manages skill discovery, loading, and execution
+ */
+
+const fs = require('fs-extra');
+const path = require('path');
+
+class SkillLoader {
+  constructor(config, learning, componentRegistry = null) {
+    this.config = config;
+    this.learning = learning;
+    this.componentRegistry = componentRegistry;
+    this.skills = new Map();
+    this.skillPath = config.get('skills.path', path.join(__dirname, '..', 'skills'));
+  }
+
+  /**
+   * Load all skills
+   */
+  async loadAll() {
+    const skillsDir = this.skillPath;
+
+    if (!await fs.pathExists(skillsDir)) {
+      console.warn(`Skills directory not found: ${skillsDir}`);
+      return;
+    }
+
+    const entries = await fs.readdir(skillsDir);
+
+    for (const entry of entries) {
+      const skillDir = path.join(skillsDir, entry);
+      const stat = await fs.stat(skillDir);
+
+      if (stat.isDirectory()) {
+        await this.loadSkill(entry, skillDir);
+      }
+    }
+
+    return Array.from(this.skills.values());
+  }
+
+  /**
+   * Load a single skill
+   */
+  async loadSkill(name, skillDir) {
+    try {
+      // Load skill definition
+      const skillMdPath = path.join(skillDir, 'SKILL.md');
+      const definition = await this.loadSkillDefinition(skillMdPath);
+
+      // Load skill implementation
+      const indexPath = path.join(skillDir, 'index.js');
+      let implementation = {};
+
+      if (await fs.pathExists(indexPath)) {
+        implementation = require(indexPath);
+      }
+
+      // Create skill object
+      const skill = {
+        name: name,
+        path: skillDir,
+        definition: definition,
+        ...implementation,
+        canHandle: implementation.canHandle || this.createDefaultCanHandle(definition),
+        execute: implementation.execute || this.createDefaultExecute(definition)
+      };
+
+      this.skills.set(name, skill);
+      return skill;
+    } catch (error) {
+      console.error(`Failed to load skill ${name}:`, error.message);
+      return null;
+    }
+  }
+
+  /**
+   * Load skill definition from SKILL.md
+   */
+  async loadSkillDefinition(filePath) {
+    if (!await fs.pathExists(filePath)) {
+      return {};
+    }
+
+    const content = await fs.readFile(filePath, 'utf-8');
+
+    // Parse frontmatter
+    const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+    if (!frontmatterMatch) {
+      return { raw: content };
+    }
+
+    const frontmatter = frontmatterMatch[1];
+    const definition = {};
+
+    // Parse YAML-like frontmatter
+    const lines = frontmatter.split('\n');
+    for (const line of lines) {
+      const match = line.match(/^(\w+):\s*(.+)$/);
+      if (match) {
+        definition[match[1]] = match[2].replace(/^["']|["']$/g, '');
+      }
+    }
+
+    // Parse YAML list fields (componentDependencies, etc.)
+    const listFieldMatch = frontmatter.match(/componentDependencies:\s*\n((?:\s+-\s+.+\n?)*)/);
+    if (listFieldMatch) {
+      definition.componentDependencies = listFieldMatch[1]
+        .split('\n')
+        .map(line => line.match(/^\s+-\s+(.+)$/))
+        .filter(Boolean)
+        .map(m => m[1].trim());
+    }
+
+    // Extract trigger patterns
+    const triggerMatch = content.match(/## Trigger Conditions\n([\s\S]*?)(?=\n##|$)/);
+    if (triggerMatch) {
+      definition.triggers = this.extractTriggers(triggerMatch[1]);
+    }
+
+    return definition;
+  }
+
+  /**
+   * Extract trigger patterns from markdown
+   */
+  extractTriggers(section) {
+    const triggers = [];
+    const lines = section.split('\n');
+
+    for (const line of lines) {
+      // Match quoted strings
+      const matches = line.match(/"([^"]+)"|'([^']+)'|`([^`]+)`/g);
+      if (matches) {
+        triggers.push(...matches.map(m => m.replace(/["'`]/g, '')));
+      }
+    }
+
+    return triggers;
+  }
+
+  /**
+   * Create default canHandle function from definition
+   */
+  createDefaultCanHandle(definition) {
+    const triggers = definition.triggers || [];
+
+    return (input, context) => {
+      if (!input) return false;
+
+      const inputLower = input.toLowerCase();
+
+      for (const trigger of triggers) {
+        if (inputLower.includes(trigger.toLowerCase())) {
+          return true;
+        }
+      }
+
+      return false;
+    };
+  }
+
+  /**
+   * Create default execute function from definition
+   */
+  createDefaultExecute(definition) {
+    const registry = this.componentRegistry;
+    return async (input, context) => {
+      // Enrich context with component registry info
+      const enrichedContext = { ...context };
+      if (registry) {
+        enrichedContext.componentRegistry = registry;
+        // Add resolved MCP server info for skills that declare component dependencies
+        const componentDeps = definition.componentDependencies || [];
+        enrichedContext.resolvedComponents = {};
+        for (const dep of componentDeps) {
+          const adapter = registry.getAdapter(dep);
+          if (adapter) {
+            enrichedContext.resolvedComponents[dep] = {
+              provider: registry.getActiveProvider(dep),
+              mcpServer: adapter.mcpServer,
+              tools: adapter.getProvidedTools()
+            };
+          }
+        }
+      }
+
+      return {
+        skill: definition.name,
+        input: input,
+        context: enrichedContext,
+        message: `Executed skill: ${definition.name || 'unknown'}`,
+        timestamp: new Date().toISOString()
+      };
+    };
+  }
+
+  /**
+   * Select best skill for input
+   */
+  async select(input, context = {}) {
+    const candidates = [];
+
+    for (const [name, skill] of this.skills) {
+      try {
+        const canHandle = await skill.canHandle(input, context);
+        if (canHandle) {
+          candidates.push({
+            skill: skill,
+            score: this.calculateSkillScore(skill, input, context)
+          });
+        }
+      } catch (error) {
+        // Skip skills that error on canHandle
+      }
+    }
+
+    if (candidates.length === 0) {
+      return null;
+    }
+
+    // Sort by score (highest first)
+    candidates.sort((a, b) => b.score - a.score);
+
+    return candidates[0].skill;
+  }
+
+  /**
+   * Calculate skill score for selection
+   */
+  calculateSkillScore(skill, input, context) {
+    let score = 0;
+
+    // Base score for matching
+    score += 10;
+
+    // Bonus for trigger specificity
+    const triggers = skill.definition?.triggers || [];
+    for (const trigger of triggers) {
+      if (input.toLowerCase().includes(trigger.toLowerCase())) {
+        score += 5;
+      }
+    }
+
+    // Bonus for recent successful use
+    const bindings = this.learning?.skillBindings?.bindings?.[skill.name];
+    if (bindings) {
+      score += Math.min(bindings.learningCount, 10);
+    }
+
+    return score;
+  }
+
+  /**
+   * Get skill by name
+   */
+  get(name) {
+    return this.skills.get(name);
+  }
+
+  /**
+   * List all loaded skills
+   */
+  list() {
+    return Array.from(this.skills.values()).map(s => ({
+      name: s.name,
+      description: s.definition?.description,
+      category: s.definition?.category
+    }));
+  }
+
+  /**
+   * Reload a skill
+   */
+  async reload(name) {
+    const skill = this.skills.get(name);
+    if (!skill) return null;
+
+    return await this.loadSkill(name, skill.path);
+  }
+
+  /**
+   * Check if skill exists
+   */
+  has(name) {
+    return this.skills.has(name);
+  }
+}
+
+module.exports = SkillLoader;