flowmind 1.0.1 → 1.2.2

package/core/ai/providers/qwen.js

@@ -0,0 +1,80 @@
+/**
+ * Qwen Provider - 阿里云通义千问模型接入
+ * 支持 Qwen-Turbo、Qwen-Plus、Qwen-Max 等模型
+ */
+
+const BaseModel = require('../base-model');
+
+class QwenProvider extends BaseModel {
+  constructor(config = {}) {
+    super('qwen', config);
+    this.apiKey = config.apiKey || process.env.DASHSCOPE_API_KEY;
+    this.model = config.model || 'qwen-turbo';
+    this.baseUrl = config.baseUrl || 'https://dashscope.aliyuncs.com/compatible-mode/v1';
+    this.temperature = config.temperature ?? 0.3;
+    this.maxTokens = config.maxTokens ?? 2000;
+  }
+
+  async init() {
+    if (!this.apiKey) {
+      throw new Error('DashScope API key is required. Set DASHSCOPE_API_KEY environment variable or provide in config.');
+    }
+    this.initialized = true;
+  }
+
+  validateConfig() {
+    return !!this.apiKey;
+  }
+
+  async chat(messages, options = {}) {
+    if (!this.initialized) {
+      await this.init();
+    }
+
+    const response = await fetch(`${this.baseUrl}/chat/completions`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${this.apiKey}`
+      },
+      body: JSON.stringify({
+        model: options.model || this.model,
+        messages: messages,
+        temperature: options.temperature ?? this.temperature,
+        max_tokens: options.maxTokens ?? this.maxTokens
+      })
+    });
+
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Qwen API error: ${response.status} - ${error}`);
+    }
+
+    const data = await response.json();
+    return data.choices[0].message.content;
+  }
+
+  async complete(prompt, options = {}) {
+    return this.chat([{ role: 'user', content: prompt }], options);
+  }
+
+  async isAvailable() {
+    try {
+      if (!this.apiKey) return false;
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  getInfo() {
+    return {
+      ...super.getInfo(),
+      model: this.model,
+      baseUrl: this.baseUrl,
+      provider: 'Alibaba Cloud'
+    };
+  }
+}
+
+module.exports = QwenProvider;

package/core/event-bus.js

@@ -0,0 +1,17 @@
+/**
+ * FlowMind Event Bus
+ * Shared singleton EventEmitter for cross-module event communication.
+ * Enables real-time monitoring (dashboard) and event-driven TUI updates.
+ */
+
+const EventEmitter = require('events');
+
+class FlowMindEventBus extends EventEmitter {
+  constructor() {
+    super();
+    this.setMaxListeners(50);
+  }
+}
+
+// Singleton — shared across all modules
+module.exports = new FlowMindEventBus();

package/core/honor-engine.js

@@ -0,0 +1,255 @@
+/**
+ * FlowMind Honor Engine
+ * Tracks honor points earned through usage and manages dragon totem levels
+ */
+
+const fs = require('fs-extra');
+const path = require('path');
+const eventBus = require('./event-bus');
+
+const HONOR_POINTS = {
+  init: 1,
+  skill_use: 1,
+  new_skill: 2,
+  learning: 3
+};
+
+const DRAGON_LEVELS = [
+  { level: 0, minPoints: 0,  name: 'Egg',       state: 'dormant' },
+  { level: 1, minPoints: 1,  name: 'Hatchling',  state: 'awakening' },
+  { level: 2, minPoints: 10, name: 'Juvenile',   state: 'growing' },
+  { level: 3, minPoints: 30, name: 'Adult',       state: 'soaring' },
+  { level: 4, minPoints: 60, name: 'Elder',       state: 'wise' },
+  { level: 5, minPoints: 100, name: 'Ascended',   state: 'transcendent' }
+];
+
+class HonorEngine {
+  constructor(config) {
+    this.config = config;
+    this.honorPath = path.join(
+      config.get('storagePath') || path.join(process.env.HOME || process.env.USERPROFILE, '.flowmind'),
+      'honor.json'
+    );
+    this.skillsPath = config.get('skills.path', path.join(__dirname, '..', 'skills'));
+    this.data = null;
+    this.initialized = false;
+  }
+
+  /**
+   * Initialize honor engine
+   */
+  async init() {
+    try {
+      if (await fs.pathExists(this.honorPath)) {
+        this.data = await fs.readJson(this.honorPath);
+      } else {
+        this.data = this.createDefaultData();
+        // Seed knownSkills by scanning skills/ directory
+        await this.seedKnownSkills();
+        await this.save();
+      }
+      this.initialized = true;
+    } catch (error) {
+      // Non-blocking: create default data in memory
+      this.data = this.createDefaultData();
+      this.initialized = true;
+    }
+  }
+
+  /**
+   * Create default honor data structure
+   */
+  createDefaultData() {
+    return {
+      version: '1.0',
+      points: 0,
+      level: 0,
+      history: [],
+      knownSkills: [],
+      stats: {
+        initCount: 0,
+        skillUseCount: 0,
+        newSkillCount: 0,
+        learningCount: 0
+      },
+      lastUpdated: new Date().toISOString()
+    };
+  }
+
+  /**
+   * Seed knownSkills by scanning skills/ directory
+   */
+  async seedKnownSkills() {
+    try {
+      if (await fs.pathExists(this.skillsPath)) {
+        const entries = await fs.readdir(this.skillsPath);
+        for (const entry of entries) {
+          const fullPath = path.join(this.skillsPath, entry);
+          const stat = await fs.stat(fullPath);
+          if (stat.isDirectory()) {
+            this.data.knownSkills.push(entry);
+          }
+        }
+      }
+    } catch (error) {
+      // Non-blocking
+    }
+  }
+
+  /**
+   * Award honor points for an action
+   */
+  async award(action, description) {
+    if (!this.initialized) await this.init();
+
+    try {
+      const points = HONOR_POINTS[action] || 0;
+      if (points === 0) return;
+
+      // Check init action: only award once
+      if (action === 'init' && this.data.stats.initCount > 0) {
+        return;
+      }
+
+      // Award points
+      this.data.points += points;
+      this.data.level = this.getLevel(this.data.points);
+
+      // Update stats
+      const statKey = `${action}Count`;
+      if (this.data.stats[statKey] !== undefined) {
+        this.data.stats[statKey]++;
+      }
+
+      // Add to history
+      this.data.history.push({
+        action,
+        points,
+        description,
+        timestamp: new Date().toISOString()
+      });
+
+      // Keep history to last 100 entries
+      if (this.data.history.length > 100) {
+        this.data.history = this.data.history.slice(-100);
+      }
+
+      this.data.lastUpdated = new Date().toISOString();
+      await this.save();
+
+      // Emit honor event for TUI/dashboard monitoring
+      eventBus.emit('honor:awarded', {
+        action,
+        points,
+        description,
+        level: this.data.level,
+        levelName: this.getLevelName(this.data.level),
+        total: this.data.points,
+        timestamp: this.data.lastUpdated
+      });
+    } catch (error) {
+      // Non-blocking
+    }
+  }
+
+  /**
+   * Check if a skill name is already known
+   */
+  isKnownSkill(name) {
+    return this.data && this.data.knownSkills.includes(name);
+  }
+
+  /**
+   * Add a skill to the known list
+   */
+  async addKnownSkill(name) {
+    if (!this.initialized) await this.init();
+    try {
+      if (!this.data.knownSkills.includes(name)) {
+        this.data.knownSkills.push(name);
+        await this.save();
+      }
+    } catch (error) {
+      // Non-blocking
+    }
+  }
+
+  /**
+   * Get the honor data
+   */
+  getData() {
+    return this.data || this.createDefaultData();
+  }
+
+  /**
+   * Get level for a given point total
+   */
+  getLevel(points) {
+    let level = 0;
+    for (const tier of DRAGON_LEVELS) {
+      if (points >= tier.minPoints) {
+        level = tier.level;
+      }
+    }
+    return level;
+  }
+
+  /**
+   * Get level name for a given level number
+   */
+  getLevelName(level) {
+    const tier = DRAGON_LEVELS.find(t => t.level === level);
+    return tier ? tier.name : 'Unknown';
+  }
+
+  /**
+   * Get level info including next level hint
+   */
+  getLevelInfo(points) {
+    const level = this.getLevel(points);
+    const currentTier = DRAGON_LEVELS.find(t => t.level === level);
+    const nextTier = DRAGON_LEVELS.find(t => t.level === level + 1);
+
+    return {
+      level,
+      name: currentTier.name,
+      state: currentTier.state,
+      points,
+      nextLevel: nextTier ? nextTier.level : null,
+      nextLevelName: nextTier ? nextTier.name : null,
+      pointsToNext: nextTier ? nextTier.minPoints - points : 0
+    };
+  }
+
+  /**
+   * Export honor data for publishing
+   */
+  exportForPublish() {
+    const info = this.getLevelInfo(this.data.points);
+    return {
+      version: this.data.version,
+      points: this.data.points,
+      level: info.level,
+      levelName: info.name,
+      state: info.state,
+      stats: this.data.stats,
+      knownSkillsCount: this.data.knownSkills.length,
+      recentHistory: this.data.history.slice(-20),
+      exportedAt: new Date().toISOString()
+    };
+  }
+
+  /**
+   * Save honor data to disk
+   */
+  async save() {
+    try {
+      await fs.ensureDir(path.dirname(this.honorPath));
+      await fs.writeJson(this.honorPath, this.data, { spaces: 2 });
+    } catch (error) {
+      // Non-blocking
+    }
+  }
+}
+
+module.exports = HonorEngine;

package/core/index.js

@@ -5,17 +5,22 @@
 
 const SkillLoader = require('./skill-loader');
 const LearningEngine = require('./learning-engine');
+const HonorEngine = require('./honor-engine');
 const SceneMatcher = require('./scene-matcher');
 const ConfigManager = require('./config-manager');
 const ComponentRegistry = require('./component-registry');
+const ModelManager = require('./ai/model-manager');
+const eventBus = require('./event-bus');
 
 class FlowMind {
   constructor(options = {}) {
     this.config = new ConfigManager(options.configPath);
-    this.learning = new LearningEngine(this.config);
+    this.honor = new HonorEngine(this.config);
+    this.learning = new LearningEngine(this.config, this.honor);
     this.matcher = new SceneMatcher(this.config, this.learning);
     this.components = new ComponentRegistry(this.config);
-    this.skills = new SkillLoader(this.config, this.learning, this.components);
+    this.skills = new SkillLoader(this.config, this.learning, this.components, this.honor);
+    this.ai = new ModelManager(options.ai || {});
     this.initialized = false;
   }
 
@@ -28,10 +33,18 @@ class FlowMind {
     await this.config.load();
     await this.components.init();
     await this.components.initAll();
+    await this.honor.init();
     await this.learning.init();
     await this.skills.loadAll();
     await this.matcher.loadScenes();
 
+    // Initialize AI model manager
+    try {
+      await this.ai.init();
+    } catch (error) {
+      console.warn(`AI model initialization failed: ${error.message}. Falling back to rule-based engine.`);
+    }
+
     this.initialized = true;
     return this;
   }
@@ -46,36 +59,87 @@ class FlowMind {
 
     const startTime = Date.now();
 
+    eventBus.emit('process:start', { input, timestamp: new Date().toISOString() });
+
     try {
-      // 1. Check for learning patterns (corrections, feedback)
-      const learningResult = await this.learning.detectLearning(input, context);
+      // 1. AI Intent Understanding (if available)
+      const intent = await this.ai.understandIntent(input, context);
+
+      // 2. Check for learning patterns (corrections, feedback)
+      // Use AI to analyze learning feedback if available
+      const aiLearningResult = await this.ai.analyzeLearningFeedback(input, context);
+      const learningResult = aiLearningResult?.isLearning
+        ? aiLearningResult
+        : await this.learning.detectLearning(input, context);
       if (learningResult) {
         return this.formatLearningResponse(learningResult);
       }
 
-      // 2. Check scene mappings
-      const sceneMatch = await this.matcher.match(input);
+      // 3. Check scene mappings (with AI intent if available)
+      const sceneMatch = await this.matcher.match(input, intent);
       if (sceneMatch && sceneMatch.confidence >= 0.7) {
         return this.executeSceneWorkflow(sceneMatch, input, context);
       }
 
-      // 3. Select and execute skill
-      const skill = await this.skills.select(input, context);
+      // 4. Select skill (AI-assisted if available)
+      let skill = null;
+      const candidates = await this.skills.getCandidates(input, context);
+
+      if (candidates.length > 0) {
+        // Use AI to select skill if available
+        const aiSelection = await this.ai.selectSkill(input, candidates);
+        if (aiSelection && aiSelection.selectedSkill) {
+          skill = this.skills.get(aiSelection.selectedSkill);
+        }
+      }
+
+      // Fallback to rule-based selection
+      if (!skill) {
+        skill = await this.skills.select(input, context);
+      }
+
       if (!skill) {
         return this.formatError('No matching skill found', input);
       }
 
-      // 4. Execute with learning applied
-      const result = await this.executeWithLearning(skill, input, context);
+      // 5. Extract parameters using AI (if available)
+      const extractedParams = await this.ai.extractParameters(input, skill.name);
+
+      // 6. Execute with learning applied
+      const enhancedContext = {
+        ...context,
+        ...extractedParams,
+        intent: intent
+      };
+      const result = await this.executeWithLearning(skill, input, enhancedContext);
+
+      // 7. Generate AI summary (if available)
+      const summary = await this.ai.summarizeResult(result, {
+        skill: skill.name,
+        intent: intent
+      });
 
-      // 5. Format and return
-      return this.formatResult(result, {
+      // 8. Format and return
+      const formatted = this.formatResult(summary || result, {
         skill: skill.name,
         duration: Date.now() - startTime,
-        sceneMatch: sceneMatch
+        sceneMatch: sceneMatch,
+        intent: intent,
+        aiEnhanced: !!summary
+      });
+
+      eventBus.emit('process:complete', {
+        input,
+        skill: skill.name,
+        duration: formatted.metadata.duration,
+        success: true,
+        timestamp: formatted.timestamp
       });
 
+      return formatted;
+
     } catch (error) {
+      eventBus.emit('process:error', { input, error: error.message, timestamp: new Date().toISOString() });
       return this.formatError(error.message, input);
     }
   }
@@ -84,6 +148,8 @@ class FlowMind {
    * Execute skill with learning applied
    */
   async executeWithLearning(skill, input, context) {
+    const skillStartTime = Date.now();
+
     // Get learning rules for this skill
     const learnings = await this.learning.getSkillLearnings(skill.name);
 
@@ -97,6 +163,19 @@ class FlowMind {
     // Execute skill
     const result = await skill.execute(input, enhancedContext);
 
+    const duration = Date.now() - skillStartTime;
+
+    // Emit skill execution event
+    eventBus.emit('skill:executed', {
+      name: skill.name,
+      duration,
+      success: true,
+      timestamp: new Date().toISOString()
+    });
+
+    // Award honor point for skill use
+    await this.honor.award('skill_use', `Used skill: ${skill.name}`);
+
     return result;
   }
 
@@ -180,6 +259,13 @@ class FlowMind {
     return this.learning.getStats();
   }
 
+  /**
+   * Get honor data
+   */
+  getHonorData() {
+    return this.honor.getData();
+  }
+
   /**
    * Get the component registry
    * @returns {ComponentRegistry}
@@ -205,6 +291,22 @@ class FlowMind {
     return this.components.getStatus();
   }
 
+  /**
+   * Get AI model status
+   * @returns {object}
+   */
+  getAIStatus() {
+    return this.ai.getStatus();
+  }
+
+  /**
+   * Check if AI is available
+   * @returns {boolean}
+   */
+  hasAI() {
+    return this.ai.hasAvailableProvider();
+  }
+
   /**
    * Export learnings
    */

package/core/learning-engine.js

@@ -6,10 +6,12 @@
 const fs = require('fs-extra');
 const path = require('path');
 const { v4: uuidv4 } = require('uuid');
+const eventBus = require('./event-bus');
 
 class LearningEngine {
-  constructor(config) {
+  constructor(config, honorEngine = null) {
     this.config = config;
+    this.honorEngine = honorEngine;
     this.learningPath = config.get('learning.storagePath', '~/.flowmind/learning');
     this.records = {};
     this.skillBindings = {};
@@ -170,6 +172,13 @@ class LearningEngine {
     // Update stats
     await this.updateStats('correction', record.skill);
 
+    eventBus.emit('learning:recorded', {
+      type: 'correction',
+      skill: record.skill,
+      recordId: record.id,
+      severity: record.severity
+    });
+
     return {
       type: 'correction',
       record: record,
@@ -204,6 +213,13 @@ class LearningEngine {
     // Update stats
     await this.updateStats('scene_mapping', 'global');
 
+    eventBus.emit('learning:recorded', {
+      type: 'scene_mapping',
+      skill: 'global',
+      recordId: record.id,
+      keywords: record.keywords
+    });
+
     return {
       type: 'scene_mapping',
       record: record,
@@ -232,6 +248,13 @@ class LearningEngine {
     // Update stats
     await this.updateStats('preference', record.skill);
 
+    eventBus.emit('learning:recorded', {
+      type: 'preference',
+      skill: record.skill,
+      recordId: record.id,
+      preferenceType: record.preferenceType
+    });
+
     return {
       type: 'preference',
       record: record,
@@ -398,6 +421,11 @@ class LearningEngine {
 
     const statsPath = path.join(this.expandPath(this.learningPath), 'stats.json');
     await fs.writeJson(statsPath, this.stats, { spaces: 2 });
+
+    // Award honor points for learning
+    if (this.honorEngine) {
+      await this.honorEngine.award('learning', `Learned: ${type} for ${skill}`);
+    }
   }
 
   /**

package/core/skill-loader.js

@@ -7,10 +7,11 @@ const fs = require('fs-extra');
 const path = require('path');
 
 class SkillLoader {
-  constructor(config, learning, componentRegistry = null) {
+  constructor(config, learning, componentRegistry = null, honorEngine = null) {
     this.config = config;
     this.learning = learning;
     this.componentRegistry = componentRegistry;
+    this.honorEngine = honorEngine;
     this.skills = new Map();
     this.skillPath = config.get('skills.path', path.join(__dirname, '..', 'skills'));
   }
@@ -68,6 +69,13 @@ class SkillLoader {
       };
 
       this.skills.set(name, skill);
+
+      // Award honor points for new (previously unknown) skills
+      if (this.honorEngine && !this.honorEngine.isKnownSkill(name)) {
+        await this.honorEngine.award('new_skill', `New skill loaded: ${name}`);
+        await this.honorEngine.addKnownSkill(name);
+      }
+
       return skill;
     } catch (error) {
       console.error(`Failed to load skill ${name}:`, error.message);
@@ -225,6 +233,23 @@ class SkillLoader {
    * Select best skill for input
    */
   async select(input, context = {}) {
+    const candidates = await this.getCandidates(input, context);
+
+    if (candidates.length === 0) {
+      return null;
+    }
+
+    // Sort by score (highest first)
+    candidates.sort((a, b) => b.score - a.score);
+
+    return candidates[0].skill;
+  }
+
+  /**
+   * Get candidate skills for input
+   * Returns skills that can handle the input with their scores
+   */
+  async getCandidates(input, context = {}) {
     const candidates = [];
 
     for (const [name, skill] of this.skills) {
@@ -232,7 +257,11 @@ class SkillLoader {
         const canHandle = await skill.canHandle(input, context);
         if (canHandle) {
           candidates.push({
+            name: skill.name,
             skill: skill,
+            description: skill.definition?.description || '',
+            triggers: skill.definition?.triggers || [],
+            category: skill.definition?.category || skill.definition?.metadata?.category || '',
             score: this.calculateSkillScore(skill, input, context)
           });
         }
@@ -241,14 +270,7 @@ class SkillLoader {
       }
     }
 
-    if (candidates.length === 0) {
-      return null;
-    }
-
-    // Sort by score (highest first)
-    candidates.sort((a, b) => b.score - a.score);
-
-    return candidates[0].skill;
+    return candidates;
   }
 
   /**