flowmind 1.2.3 → 1.4.0

package/core/ai/providers/glm.js

@@ -31,7 +31,7 @@ class GLMProvider extends BaseModel {
       await this.init();
     }
 
-    const response = await fetch(`${this.baseUrl}/chat/completions`, {
+    const response = await this.fetchWithRetry(`${this.baseUrl}/chat/completions`, {
       method: 'POST',
       headers: {
         'Content-Type': 'application/json',
@@ -61,7 +61,17 @@ class GLMProvider extends BaseModel {
   async isAvailable() {
     try {
       if (!this.apiKey) return false;
-      return true;
+      const response = await this.fetchWithRetry(`${this.baseUrl}/chat/completions`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${this.apiKey}`
+        },
+        body: JSON.stringify({ model: this.model, messages: [{ role: 'user', content: 'hi' }], max_tokens: 1 }),
+        retries: 1,
+        timeout: 10000
+      });
+      return response.ok || response.status === 400;
     } catch {
       return false;
     }

package/core/ai/providers/mimo.js

@@ -31,7 +31,7 @@ class MiMoProvider extends BaseModel {
       await this.init();
     }
 
-    const response = await fetch(`${this.baseUrl}/chat/completions`, {
+    const response = await this.fetchWithRetry(`${this.baseUrl}/chat/completions`, {
       method: 'POST',
       headers: {
         'Content-Type': 'application/json',
@@ -61,7 +61,17 @@ class MiMoProvider extends BaseModel {
   async isAvailable() {
     try {
       if (!this.apiKey) return false;
-      return true;
+      const response = await this.fetchWithRetry(`${this.baseUrl}/chat/completions`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${this.apiKey}`
+        },
+        body: JSON.stringify({ model: this.model, messages: [{ role: 'user', content: 'hi' }], max_tokens: 1 }),
+        retries: 1,
+        timeout: 10000
+      });
+      return response.ok || response.status === 400;
     } catch {
       return false;
     }

package/core/ai/providers/ollama.js

@@ -34,7 +34,7 @@ class OllamaProvider extends BaseModel {
     // 转换消息格式为 Ollama 格式
     const prompt = this._convertMessagesToPrompt(messages);
 
-    const response = await fetch(`${this.baseUrl}/api/generate`, {
+    const response = await this.fetchWithRetry(`${this.baseUrl}/api/generate`, {
       method: 'POST',
       headers: {
         'Content-Type': 'application/json'
@@ -64,7 +64,7 @@ class OllamaProvider extends BaseModel {
       await this.init();
     }
 
-    const response = await fetch(`${this.baseUrl}/api/generate`, {
+    const response = await this.fetchWithRetry(`${this.baseUrl}/api/generate`, {
       method: 'POST',
       headers: {
         'Content-Type': 'application/json'
@@ -91,9 +91,10 @@ class OllamaProvider extends BaseModel {
 
   async isAvailable() {
     try {
-      const response = await fetch(`${this.baseUrl}/api/tags`, {
+      const response = await this.fetchWithRetry(`${this.baseUrl}/api/tags`, {
         method: 'GET',
-        signal: AbortSignal.timeout(5000) // 5秒超时
+        retries: 1,
+        timeout: 5000
       });
       return response.ok;
     } catch {

package/core/ai/providers/openai.js

@@ -8,7 +8,7 @@ class OpenAIProvider extends BaseModel {
   constructor(config = {}) {
     super('openai', config);
     this.apiKey = config.apiKey || process.env.OPENAI_API_KEY;
-    this.model = config.model || 'gpt-4';
+    this.model = config.model || 'gpt-4o';
     this.baseUrl = config.baseUrl || 'https://api.openai.com/v1';
     this.temperature = config.temperature ?? 0.3;
     this.maxTokens = config.maxTokens ?? 2000;
@@ -26,11 +26,9 @@ class OpenAIProvider extends BaseModel {
   }
 
   async chat(messages, options = {}) {
-    if (!this.initialized) {
-      await this.init();
-    }
+    if (!this.initialized) await this.init();
 
-    const response = await fetch(`${this.baseUrl}/chat/completions`, {
+    const response = await this.fetchWithRetry(`${this.baseUrl}/chat/completions`, {
       method: 'POST',
       headers: {
         'Content-Type': 'application/json',
@@ -61,8 +59,10 @@ class OpenAIProvider extends BaseModel {
   async isAvailable() {
     try {
       if (!this.apiKey) return false;
-      const response = await fetch(`${this.baseUrl}/models`, {
-        headers: { 'Authorization': `Bearer ${this.apiKey}` }
+      const response = await this.fetchWithRetry(`${this.baseUrl}/models`, {
+        headers: { 'Authorization': `Bearer ${this.apiKey}` },
+        retries: 1,
+        timeout: 10000
       });
       return response.ok;
     } catch {
@@ -71,11 +71,7 @@ class OpenAIProvider extends BaseModel {
   }
 
   getInfo() {
-    return {
-      ...super.getInfo(),
-      model: this.model,
-      baseUrl: this.baseUrl
-    };
+    return { ...super.getInfo(), model: this.model, baseUrl: this.baseUrl };
   }
 }
 

package/core/ai/providers/qwen.js

@@ -31,7 +31,7 @@ class QwenProvider extends BaseModel {
       await this.init();
     }
 
-    const response = await fetch(`${this.baseUrl}/chat/completions`, {
+    const response = await this.fetchWithRetry(`${this.baseUrl}/chat/completions`, {
       method: 'POST',
       headers: {
         'Content-Type': 'application/json',
@@ -61,7 +61,17 @@ class QwenProvider extends BaseModel {
   async isAvailable() {
     try {
       if (!this.apiKey) return false;
-      return true;
+      const response = await this.fetchWithRetry(`${this.baseUrl}/chat/completions`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${this.apiKey}`
+        },
+        body: JSON.stringify({ model: this.model, messages: [{ role: 'user', content: 'hi' }], max_tokens: 1 }),
+        retries: 1,
+        timeout: 10000
+      });
+      return response.ok || response.status === 400;
     } catch {
       return false;
     }

package/core/config-manager.js

@@ -5,6 +5,7 @@
 
 const fs = require('fs-extra');
 const path = require('path');
+const os = require('os');
 
 class ConfigManager {
   constructor(configPath = null) {

package/core/index.js

@@ -22,6 +22,8 @@ class FlowMind {
     this.skills = new SkillLoader(this.config, this.learning, this.components, this.honor);
     this.ai = new ModelManager(options.ai || {});
     this.initialized = false;
+    this.conversationHistory = [];
+    this.maxHistoryLength = options.maxHistoryLength || 50;
   }
 
   /**
@@ -49,6 +51,19 @@ class FlowMind {
     return this;
   }
 
+  /**
+   * Process a user request with streaming support
+   * Yields progress updates as an async generator
+   */
+  async *processStream(input, context = {}) {
+    yield { type: 'start', input, timestamp: new Date().toISOString() };
+
+    const result = await this.process(input, context);
+
+    yield { type: 'progress', message: `Skill: ${result.metadata?.skill || 'unknown'}`, timestamp: new Date().toISOString() };
+    yield { type: 'result', data: result, timestamp: new Date().toISOString() };
+  }
+
   /**
    * Process a user request
    */
@@ -57,20 +72,31 @@ class FlowMind {
       await this.init();
     }
 
+    if (!input || typeof input !== 'string') {
+      return this.formatError('Invalid input: expected a non-empty string', input);
+    }
+
     const startTime = Date.now();
 
+    // Build context with conversation history
+    const enhancedContext = {
+      ...context,
+      conversationHistory: this.conversationHistory.slice(-10),
+      sessionId: context.sessionId || 'default'
+    };
+
     eventBus.emit('process:start', { input, timestamp: new Date().toISOString() });
 
     try {
       // 1. AI Intent Understanding (if available)
-      const intent = await this.ai.understandIntent(input, context);
+      const intent = await this.ai.understandIntent(input, enhancedContext);
 
       // 2. Check for learning patterns (corrections, feedback)
       // Use AI to analyze learning feedback if available
-      const aiLearningResult = await this.ai.analyzeLearningFeedback(input, context);
+      const aiLearningResult = await this.ai.analyzeLearningFeedback(input, enhancedContext);
       const learningResult = aiLearningResult?.isLearning
         ? aiLearningResult
-        : await this.learning.detectLearning(input, context);
+        : await this.learning.detectLearning(input, enhancedContext);
       if (learningResult) {
         return this.formatLearningResponse(learningResult);
       }
@@ -106,12 +132,12 @@ class FlowMind {
       const extractedParams = await this.ai.extractParameters(input, skill.name);
 
       // 6. Execute with learning applied
-      const enhancedContext = {
-        ...context,
+      const executeContext = {
+        ...enhancedContext,
         ...extractedParams,
         intent: intent
       };
-      const result = await this.executeWithLearning(skill, input, enhancedContext);
+      const result = await this.executeWithLearning(skill, input, executeContext);
 
       // 7. Generate AI summary (if available)
       const summary = await this.ai.summarizeResult(result, {
@@ -128,6 +154,17 @@ class FlowMind {
         aiEnhanced: !!summary
       });
 
+      // Save to conversation history
+      this.conversationHistory.push({
+        input,
+        output: formatted,
+        skill: skill.name,
+        timestamp: new Date().toISOString()
+      });
+      if (this.conversationHistory.length > this.maxHistoryLength) {
+        this.conversationHistory.shift();
+      }
+
       eventBus.emit('process:complete', {
         input,
         skill: skill.name,
@@ -320,6 +357,146 @@ class FlowMind {
   async importLearnings(data) {
     return this.learning.import(data);
   }
+
+  /**
+   * Get conversation history
+   */
+  getConversationHistory(sessionId) {
+    if (sessionId) {
+      return this.conversationHistory.filter(h => h.sessionId === sessionId);
+    }
+    return this.conversationHistory;
+  }
+
+  /**
+   * Clear conversation history
+   */
+  clearHistory() {
+    this.conversationHistory = [];
+  }
+
+  /**
+   * Graceful shutdown - flush pending data and clean up
+   */
+  async shutdown() {
+    eventBus.emit('shutdown:start', { timestamp: new Date().toISOString() });
+
+    // Save learning data
+    try {
+      if (this.learning?.skillBindings) {
+        await this.learning.saveSkillBindings();
+      }
+      if (this.learning?.stats) {
+        await this.learning.saveStats();
+      }
+    } catch (e) {
+      console.warn('Failed to save learning data during shutdown:', e.message);
+    }
+
+    // Save honor data
+    try {
+      if (this.honor?.save) {
+        await this.honor.save();
+      }
+    } catch (e) {
+      console.warn('Failed to save honor data during shutdown:', e.message);
+    }
+
+    // Clear conversation history
+    this.conversationHistory = [];
+
+    this.initialized = false;
+    eventBus.emit('shutdown:complete', { timestamp: new Date().toISOString() });
+  }
+
+  /**
+   * Run system health checks (doctor)
+   */
+  async doctor() {
+    const checks = [];
+
+    // 1. Config check
+    try {
+      await this.config.load();
+      checks.push({ name: 'Configuration', status: 'ok', message: 'Config loaded successfully' });
+    } catch (e) {
+      checks.push({ name: 'Configuration', status: 'error', message: e.message });
+    }
+
+    // 2. Skills check
+    try {
+      const skills = this.skills.list();
+      checks.push({ name: 'Skills', status: 'ok', message: `${skills.length} skill(s) loaded` });
+    } catch (e) {
+      checks.push({ name: 'Skills', status: 'error', message: e.message });
+    }
+
+    // 3. Learning engine check
+    try {
+      const stats = await this.learning.getStats();
+      checks.push({ name: 'Learning Engine', status: 'ok', message: `${stats.totalRecords || 0} records` });
+    } catch (e) {
+      checks.push({ name: 'Learning Engine', status: 'error', message: e.message });
+    }
+
+    // 4. Honor engine check
+    try {
+      const honor = this.honor.getData();
+      checks.push({ name: 'Honor Engine', status: 'ok', message: `Level ${honor.level}, ${honor.points} pts` });
+    } catch (e) {
+      checks.push({ name: 'Honor Engine', status: 'error', message: e.message });
+    }
+
+    // 5. AI providers check
+    try {
+      const aiStatus = this.ai.getStatus();
+      const providerCount = Object.keys(aiStatus.providers || {}).length;
+      const activeCount = Object.values(aiStatus.providers || {}).filter(p => p.initialized).length;
+      checks.push({ name: 'AI Providers', status: activeCount > 0 ? 'ok' : 'warning', message: `${activeCount}/${providerCount} active` });
+    } catch (e) {
+      checks.push({ name: 'AI Providers', status: 'warning', message: e.message });
+    }
+
+    // 6. Components check
+    try {
+      const compStatus = this.components.getStatus();
+      const compCount = Object.keys(compStatus).length;
+      checks.push({ name: 'Components', status: 'ok', message: `${compCount} registered` });
+    } catch (e) {
+      checks.push({ name: 'Components', status: 'warning', message: e.message });
+    }
+
+    // 7. Node.js version check
+    const nodeVersion = process.version;
+    const major = parseInt(nodeVersion.slice(1));
+    checks.push({
+      name: 'Node.js',
+      status: major >= 18 ? 'ok' : 'warning',
+      message: `${nodeVersion} ${major < 18 ? '(recommend >= 18)' : ''}`
+    });
+
+    // 8. Disk space for learning data
+    try {
+      const fs = require('fs-extra');
+      const learningPath = this.learning.expandPath(this.learning.learningPath);
+      if (await fs.pathExists(learningPath)) {
+        checks.push({ name: 'Learning Storage', status: 'ok', message: learningPath });
+      } else {
+        checks.push({ name: 'Learning Storage', status: 'warning', message: 'Directory not yet created' });
+      }
+    } catch (e) {
+      checks.push({ name: 'Learning Storage', status: 'warning', message: e.message });
+    }
+
+    const errors = checks.filter(c => c.status === 'error').length;
+    const warnings = checks.filter(c => c.status === 'warning').length;
+
+    return {
+      healthy: errors === 0,
+      checks,
+      summary: { total: checks.length, ok: checks.filter(c => c.status === 'ok').length, warnings, errors }
+    };
+  }
 }
 
 module.exports = FlowMind;

package/core/learning-engine.js

@@ -8,11 +8,31 @@ const path = require('path');
 const { v4: uuidv4 } = require('uuid');
 const eventBus = require('./event-bus');
 
+/**
+ * Per-key write queue to prevent concurrent read-modify-write races
+ */
+class WriteQueue {
+  constructor() {
+    this.queues = new Map();
+  }
+
+  async run(key, fn) {
+    if (!this.queues.has(key)) {
+      this.queues.set(key, Promise.resolve());
+    }
+    const prev = this.queues.get(key);
+    const next = prev.then(fn, fn);
+    this.queues.set(key, next);
+    return next;
+  }
+}
+
 class LearningEngine {
   constructor(config, honorEngine = null) {
     this.config = config;
     this.honorEngine = honorEngine;
     this.learningPath = config.get('learning.storagePath', '~/.flowmind/learning');
+    this.writeQueue = new WriteQueue();
     this.records = {};
     this.skillBindings = {};
     this.stats = {};
@@ -144,7 +164,7 @@ class LearningEngine {
    */
   async recordCorrection(correction, context) {
     const record = {
-      id: `learn-${Date.now()}-${uuidv4().substr(0, 8)}`,
+      id: `learn-${Date.now()}-${uuidv4().slice(0, 8)}`,
       timestamp: new Date().toISOString(),
       type: correction.type,
       severity: correction.severity,
@@ -191,7 +211,7 @@ class LearningEngine {
    */
   async recordSceneMapping(sceneMapping, context) {
     const record = {
-      id: `scene-${Date.now()}-${uuidv4().substr(0, 8)}`,
+      id: `scene-${Date.now()}-${uuidv4().slice(0, 8)}`,
       timestamp: new Date().toISOString(),
       type: 'scene_mapping',
       input: sceneMapping.input,
@@ -232,7 +252,7 @@ class LearningEngine {
    */
   async recordPreference(preference, context) {
     const record = {
-      id: `pref-${Date.now()}-${uuidv4().substr(0, 8)}`,
+      id: `pref-${Date.now()}-${uuidv4().slice(0, 8)}`,
       timestamp: new Date().toISOString(),
       type: 'preference',
       preferenceType: preference.preferenceType,
@@ -309,16 +329,17 @@ class LearningEngine {
    */
   async saveSceneMapping(record) {
     const scenesPath = path.join(this.expandPath(this.learningPath), 'scenes.json');
+    await this.writeQueue.run('scenes.json', async () => {
+      let scenes = { version: '1.0', mappings: [] };
+      if (await fs.pathExists(scenesPath)) {
+        scenes = await fs.readJson(scenesPath);
+      }
 
-    let scenes = { version: '1.0', mappings: [] };
-    if (await fs.pathExists(scenesPath)) {
-      scenes = await fs.readJson(scenesPath);
-    }
-
-    scenes.mappings.push(record);
-    scenes.lastUpdated = new Date().toISOString();
+      scenes.mappings.push(record);
+      scenes.lastUpdated = new Date().toISOString();
 
-    await fs.writeJson(scenesPath, scenes, { spaces: 2 });
+      await fs.writeJson(scenesPath, scenes, { spaces: 2 });
+    });
   }
 
   /**
@@ -331,17 +352,19 @@ class LearningEngine {
       record.skill,
       'preferences.json'
     );
+    const queueKey = `prefs:${record.skill}`;
+    await this.writeQueue.run(queueKey, async () => {
+      let prefs = {};
+      if (await fs.pathExists(prefsPath)) {
+        prefs = await fs.readJson(prefsPath);
+      }
 
-    let prefs = {};
-    if (await fs.pathExists(prefsPath)) {
-      prefs = await fs.readJson(prefsPath);
-    }
-
-    prefs[record.preferenceType] = record.value;
-    prefs.lastUpdated = new Date().toISOString();
+      prefs[record.preferenceType] = record.value;
+      prefs.lastUpdated = new Date().toISOString();
 
-    await fs.ensureDir(path.dirname(prefsPath));
-    await fs.writeJson(prefsPath, prefs, { spaces: 2 });
+      await fs.ensureDir(path.dirname(prefsPath));
+      await fs.writeJson(prefsPath, prefs, { spaces: 2 });
+    });
   }
 
   /**
@@ -387,9 +410,11 @@ class LearningEngine {
    * Save skill bindings
    */
   async saveSkillBindings() {
-    const bindingsPath = path.join(this.expandPath(this.learningPath), 'skill-bindings.json');
-    this.skillBindings.lastUpdated = new Date().toISOString();
-    await fs.writeJson(bindingsPath, this.skillBindings, { spaces: 2 });
+    await this.writeQueue.run('bindings', async () => {
+      const bindingsPath = path.join(this.expandPath(this.learningPath), 'skill-bindings.json');
+      this.skillBindings.lastUpdated = new Date().toISOString();
+      await fs.writeJson(bindingsPath, this.skillBindings, { spaces: 2 });
+    });
   }
 
   /**
@@ -414,13 +439,15 @@ class LearningEngine {
    * Update stats
    */
   async updateStats(type, skill) {
-    this.stats.totalRecords++;
-    this.stats.byType[type] = (this.stats.byType[type] || 0) + 1;
-    this.stats.bySkill[skill] = (this.stats.bySkill[skill] || 0) + 1;
-    this.stats.lastLearning = new Date().toISOString();
-
-    const statsPath = path.join(this.expandPath(this.learningPath), 'stats.json');
-    await fs.writeJson(statsPath, this.stats, { spaces: 2 });
+    await this.writeQueue.run('stats', async () => {
+      this.stats.totalRecords++;
+      this.stats.byType[type] = (this.stats.byType[type] || 0) + 1;
+      this.stats.bySkill[skill] = (this.stats.bySkill[skill] || 0) + 1;
+      this.stats.lastLearning = new Date().toISOString();
+
+      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) {
@@ -484,6 +511,71 @@ class LearningEngine {
     return { success: true, imported: data.stats.totalRecords };
   }
 
+  /**
+   * Reset all learnings for a specific skill
+   */
+  async resetSkill(skillName) {
+    const basePath = this.expandPath(this.learningPath);
+
+    // Delete records directory for this skill
+    const recordsDir = path.join(basePath, 'records', skillName);
+    if (await fs.pathExists(recordsDir)) {
+      await fs.remove(recordsDir);
+    }
+
+    // Remove from skill bindings
+    if (this.skillBindings.bindings && this.skillBindings.bindings[skillName]) {
+      delete this.skillBindings.bindings[skillName];
+      await this.saveSkillBindings();
+    }
+
+    // Update stats
+    const count = (this.records[skillName] || []).length;
+    if (count > 0 && this.stats.totalRecords) {
+      this.stats.totalRecords = Math.max(0, this.stats.totalRecords - count);
+    }
+    if (this.stats.bySkill && this.stats.bySkill[skillName]) {
+      delete this.stats.bySkill[skillName];
+    }
+    await this.saveStats();
+    delete this.records[skillName];
+
+    return count;
+  }
+
+  /**
+   * Delete a specific learning record by ID
+   */
+  async deleteRecord(recordId) {
+    const basePath = path.join(this.expandPath(this.learningPath), 'records');
+    if (!(await fs.pathExists(basePath))) return false;
+
+    const skillDirs = await fs.readdir(basePath);
+    for (const skill of skillDirs) {
+      const recordPath = path.join(basePath, skill, `${recordId}.json`);
+      if (await fs.pathExists(recordPath)) {
+        await fs.remove(recordPath);
+        // Remove from memory cache
+        if (this.records[skill]) {
+          this.records[skill] = this.records[skill].filter(r => r.id !== recordId);
+        }
+        // Update stats
+        if (this.stats.totalRecords) this.stats.totalRecords--;
+        await this.saveStats();
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Save stats to disk
+   */
+  async saveStats() {
+    const statsPath = path.join(this.expandPath(this.learningPath), 'stats.json');
+    await fs.writeJson(statsPath, this.stats, { spaces: 2 });
+  }
+
   /**
    * Helper methods
    */

package/mcp/server.js

@@ -7,6 +7,7 @@
 
 const FlowMind = require('../core');
 const eventBus = require('../core/event-bus');
+const { version } = require('../package.json');
 
 // MCP Server 实现
 class FlowMindMCPServer {
@@ -276,7 +277,7 @@ async function main() {
             },
             serverInfo: {
               name: 'flowmind',
-              version: '1.0.1'
+              version: version
             }
           }
         };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flowmind",
-  "version": "1.2.3",
+  "version": "1.4.0",
   "description": "The AI Agent That Learns How You Work - Stop repeating yourself, FlowMind learns your workflows and applies them automatically.",
   "main": "core/index.js",
   "bin": {