flowmind 1.2.3 → 1.3.0

package/bin/flowmind.js

@@ -536,11 +536,15 @@ program
         await fm.importLearnings(data);
         console.log(chalk.green('✓ Learnings imported successfully'));
       } else if (options.reset) {
-        console.log(chalk.yellow('Resetting learnings for:'), options.reset);
-        // Implementation would go here
+        const count = await fm.learning.resetSkill(options.reset);
+        console.log(chalk.green(`✓ Reset ${count} learning(s) for skill: ${options.reset}`));
       } else if (options.delete) {
-        console.log(chalk.yellow('Deleting learning:'), options.delete);
-        // Implementation would go here
+        const deleted = await fm.learning.deleteRecord(options.delete);
+        if (deleted) {
+          console.log(chalk.green(`✓ Deleted learning record: ${options.delete}`));
+        } else {
+          console.log(chalk.yellow(`Record not found: ${options.delete}`));
+        }
       } else {
         // Default to list
         const stats = await fm.getStats();
@@ -620,7 +624,7 @@ program
   .description('View or modify skill configuration')
   .option('-i, --info', 'Show skill info (default)')
   .option('-c, --config', 'Show/edit skill configuration')
-  .option('-s, --set <key> <value>', 'Set config value')
+  .option('-s, --set <key>', 'Set config value (value as next argument)')
   .option('-r, --read', 'Read SKILL.md content')
   .option('-e, --edit', 'Open SKILL.md in editor')
   .option('-j, --json', 'Output as JSON (for tool integration)')
@@ -650,13 +654,10 @@ program
       } else if (options.config) {
         await showSkillConfig(skill, fm, options.json);
       } else if (options.set) {
-        // options.set is the key, need value from next arg
-        const value = options.set;
-        const key = options.set;
-        // Get key and value from command line
         const args = process.argv.slice(3);
-        if (args.length >= 2) {
-          await setSkillConfig(skill, fm, args[0], args[1]);
+        const value = args.find(a => !a.startsWith('-'));
+        if (value) {
+          await setSkillConfig(skill, fm, options.set, value);
         } else {
           console.error(chalk.red('Usage: flowmind skill <name> --set <key> <value>'));
         }
@@ -775,7 +776,7 @@ program
   .command('config')
   .description('Manage configuration')
   .option('-l, --list', 'List configuration')
-  .option('-s, --set <key> <value>', 'Set configuration value')
+  .option('-s, --set <key>', 'Set configuration value (value as next argument)')
   .option('-g, --get <key>', 'Get configuration value')
   .action(async (options) => {
     try {
@@ -785,10 +786,16 @@ program
         const config = fm.config.getAll();
         console.log(chalk.cyan('\nFlowMind Configuration:'));
         console.log(JSON.stringify(config, null, 2));
-      } else if (options.set && options.value) {
-        fm.config.set(options.set, options.value);
-        await fm.config.save();
-        console.log(chalk.green('✓ Configuration updated'));
+      } else if (options.set) {
+        const args = process.argv.slice(3);
+        const value = args.find(a => !a.startsWith('-'));
+        if (value) {
+          fm.config.set(options.set, value);
+          await fm.config.save();
+          console.log(chalk.green('✓ Configuration updated'));
+        } else {
+          console.error(chalk.red('Usage: flowmind config --set <key> <value>'));
+        }
       } else if (options.get) {
         const value = fm.config.get(options.get);
         console.log(value);

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/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.3.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": {

package/skills/api-sync/index.js

@@ -0,0 +1,130 @@
+/**
+ * API Sync Skill
+ * Sync API definitions, generate documentation, maintain API consistency
+ */
+
+const fs = require('fs-extra');
+const path = require('path');
+
+module.exports = {
+  canHandle(input, context) {
+    if (!input) return false;
+    return /api.*sync|同步.*api|api.*文档|swagger.*sync|接口.*同步/i.test(input);
+  },
+
+  async execute(input, context) {
+    const params = parseApiSyncParams(input);
+
+    if (params.action === 'generate') {
+      return generateDocs(params, input);
+    }
+
+    if (params.action === 'sync') {
+      return syncToYApi(params, input, context);
+    }
+
+    return {
+      type: 'result',
+      skill: 'api-sync',
+      message: 'API sync. Available actions: generate (from code), sync (to platform)',
+      data: {
+        actions: ['generate - Generate API docs from code', 'sync - Sync to YApi/Swagger Hub'],
+        params
+      },
+      input,
+      timestamp: new Date().toISOString()
+    };
+  }
+};
+
+function parseApiSyncParams(input) {
+  const params = {};
+  if (/生成|generate|导出/i.test(input)) params.action = 'generate';
+  if (/同步|sync|上传|push/i.test(input)) params.action = 'sync';
+
+  const pathMatch = input.match(/(?:路径|path|目录|dir)\s*[:=]?\s*(\S+)/i);
+  if (pathMatch) params.path = pathMatch[1];
+
+  const platformMatch = input.match(/(?:平台|platform)\s*[:=]?\s*(yapi|swagger|postman)/i);
+  if (platformMatch) params.platform = platformMatch[1].toLowerCase();
+
+  const projectMatch = input.match(/(?:项目|project)\s*[:=]?\s*(\S+)/i);
+  if (projectMatch) params.project = projectMatch[1];
+
+  return params;
+}
+
+async function generateDocs(params, input) {
+  const dirPath = params.path || '.';
+  if (!(await fs.pathExists(dirPath))) {
+    return {
+      type: 'error', skill: 'api-sync',
+      message: `Path not found: ${dirPath}`,
+      input, timestamp: new Date().toISOString()
+    };
+  }
+
+  const apis = [];
+  const files = await findApiFiles(dirPath);
+
+  for (const file of files.slice(0, 20)) {
+    const content = await fs.readFile(file, 'utf-8');
+    const endpoints = extractEndpoints(content);
+    apis.push(...endpoints.map(e => ({ ...e, file: path.relative(dirPath, file) })));
+  }
+
+  return {
+    type: 'result',
+    skill: 'api-sync',
+    message: `Found ${apis.length} API endpoint(s) in ${files.length} file(s)`,
+    data: { apis, totalEndpoints: apis.length, totalFiles: files.length },
+    input,
+    timestamp: new Date().toISOString()
+  };
+}
+
+function syncToYApi(params, input, context) {
+  return {
+    type: 'result',
+    skill: 'api-sync',
+    message: 'API sync to platform (use yapi-sync-interface skill for YApi-specific operations)',
+    data: { platform: params.platform || 'yapi', hint: 'Use yapi-sync-interface skill for direct YApi integration' },
+    input,
+    timestamp: new Date().toISOString()
+  };
+}
+
+async function findApiFiles(dir) {
+  const results = [];
+  const entries = await fs.readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.name.startsWith('.') || entry.name === 'node_modules') continue;
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      results.push(...await findApiFiles(fullPath));
+    } else if (/\.(js|ts|java|py)$/.test(entry.name)) {
+      results.push(fullPath);
+    }
+  }
+  return results;
+}
+
+function extractEndpoints(content) {
+  const endpoints = [];
+  const patterns = [
+    /@(?:GET|POST|PUT|DELETE|PATCH)Mapping\s*\(\s*["']([^"']+)["']/gi,
+    /(?:app|router)\.(get|post|put|delete|patch)\s*\(\s*["']([^"']+)["']/gi,
+    /@(?:Get|Post|Put|Delete|Patch)\s*\(\s*["']([^"']+)["']/gi,
+  ];
+
+  for (const pattern of patterns) {
+    let match;
+    while ((match = pattern.exec(content)) !== null) {
+      const method = match[1]?.toUpperCase() || 'GET';
+      const urlPath = match[2] || match[1];
+      endpoints.push({ method, path: urlPath });
+    }
+  }
+
+  return endpoints;
+}

package/skills/archive-change/index.js

@@ -0,0 +1,104 @@
+/**
+ * Archive Change Skill
+ * Archive completed changes and maintain project history
+ */
+
+const fs = require('fs-extra');
+const path = require('path');
+
+module.exports = {
+  canHandle(input, context) {
+    if (!input) return false;
+    return /归档|archive|完成.*存档|change.*archive|整理.*完成/i.test(input);
+  },
+
+  async execute(input, context) {
+    const params = parseArchiveParams(input);
+
+    if (params.action === 'check') {
+      const checklist = await checkArchiveReadiness(params.path || '.');
+      return {
+        type: 'result',
+        skill: 'archive-change',
+        message: `Archive readiness: ${checklist.passed}/${checklist.total} checks passed`,
+        data: { checklist },
+        input,
+        timestamp: new Date().toISOString()
+      };
+    }
+
+    if (params.action === 'archive') {
+      const archiveDir = params.archiveDir || '.archive';
+      const changeName = params.name || `change-${Date.now()}`;
+
+      return {
+        type: 'result',
+        skill: 'archive-change',
+        message: `Archiving change: ${changeName}`,
+        data: {
+          changeName,
+          archiveDir: path.join(archiveDir, changeName),
+          structure: ['SUMMARY.md', 'PROPOSAL.md', 'SPECS.md', 'DESIGN.md', 'TASKS.md', 'CHANGELOG.md', 'TESTS.md', 'artifacts/'],
+          preCheck: await checkArchiveReadiness(params.path || '.')
+        },
+        input,
+        timestamp: new Date().toISOString()
+      };
+    }
+
+    return {
+      type: 'result',
+      skill: 'archive-change',
+      message: 'Archive change. Available actions: check, archive',
+      data: {
+        actions: ['check - Check readiness', 'archive - Archive change'],
+        archiveStructure: ['SUMMARY.md', 'PROPOSAL.md', 'SPECS.md', 'DESIGN.md', 'TASKS.md', 'CHANGELOG.md', 'TESTS.md']
+      },
+      input,
+      timestamp: new Date().toISOString()
+    };
+  }
+};
+
+function parseArchiveParams(input) {
+  const params = {};
+  if (/检查|check|就绪|ready/i.test(input)) params.action = 'check';
+  if (/归档|archive|执行/i.test(input)) params.action = 'archive';
+
+  const nameMatch = input.match(/(?:名称|name)\s*[:=]?\s*(\S+)/i);
+  if (nameMatch) params.name = nameMatch[1];
+
+  const pathMatch = input.match(/(?:路径|path|目录|dir)\s*[:=]?\s*(\S+)/i);
+  if (pathMatch) params.path = pathMatch[1];
+
+  return params;
+}
+
+async function checkArchiveReadiness(dir) {
+  const checks = [
+    { name: 'README exists', check: () => fs.pathExists(path.join(dir, 'README.md')) },
+    { name: 'Has git history', check: () => fs.pathExists(path.join(dir, '.git')) },
+    { name: 'Has package.json or similar', check: async () =>
+      await fs.pathExists(path.join(dir, 'package.json')) ||
+      await fs.pathExists(path.join(dir, 'pom.xml')) ||
+      await fs.pathExists(path.join(dir, 'Cargo.toml'))
+    },
+  ];
+
+  const results = [];
+  for (const c of checks) {
+    try {
+      const passed = await c.check();
+      results.push({ name: c.name, passed });
+    } catch {
+      results.push({ name: c.name, passed: false });
+    }
+  }
+
+  return {
+    checks: results,
+    passed: results.filter(r => r.passed).length,
+    total: results.length,
+    ready: results.every(r => r.passed)
+  };
+}

package/skills/auto-flow/index.js

@@ -0,0 +1,124 @@
+/**
+ * Auto Flow Skill
+ * Define, execute, and manage complex multi-step workflows
+ */
+
+const fs = require('fs-extra');
+const path = require('path');
+
+const BUILTIN_WORKFLOWS = {
+  'dev-workflow': {
+    name: 'Development Workflow',
+    steps: [
+      { id: 'review', skill: 'code-review', name: 'Code Review' },
+      { id: 'test', action: 'run-command', command: 'npm test', depends_on: ['review'] },
+      { id: 'docs', action: 'run-command', command: 'npm run docs', depends_on: ['test'] },
+      { id: 'archive', skill: 'archive-change', name: 'Archive', depends_on: ['docs'] }
+    ]
+  },
+  'deploy-workflow': {
+    name: 'Deploy Workflow',
+    steps: [
+      { id: 'validate', action: 'run-command', command: 'npm run validate' },
+      { id: 'build', action: 'run-command', command: 'npm run build', depends_on: ['validate'] },
+      { id: 'deploy', action: 'deploy', depends_on: ['build'] },
+      { id: 'verify', action: 'run-command', command: 'npm run verify', depends_on: ['deploy'] },
+      { id: 'notify', action: 'notify', depends_on: ['verify'] }
+    ]
+  }
+};
+
+module.exports = {
+  canHandle(input, context) {
+    if (!input) return false;
+    return /自动流程|auto.*flow|工作流|workflow|执行流程|run.*flow/i.test(input);
+  },
+
+  async execute(input, context) {
+    const params = parseFlowParams(input);
+
+    if (params.action === 'list') {
+      return {
+        type: 'result',
+        skill: 'auto-flow',
+        message: `Available workflows: ${Object.keys(BUILTIN_WORKFLOWS).join(', ')}`,
+        data: { workflows: Object.entries(BUILTIN_WORKFLOWS).map(([k, v]) => ({ id: k, name: v.name, steps: v.steps.length })) },
+        input,
+        timestamp: new Date().toISOString()
+      };
+    }
+
+    if (params.action === 'run') {
+      const workflow = BUILTIN_WORKFLOWS[params.workflow];
+      if (!workflow) {
+        return {
+          type: 'error', skill: 'auto-flow',
+          message: `Workflow not found: ${params.workflow}. Available: ${Object.keys(BUILTIN_WORKFLOWS).join(', ')}`,
+          input, timestamp: new Date().toISOString()
+        };
+      }
+
+      return {
+        type: 'result',
+        skill: 'auto-flow',
+        message: `Starting workflow: ${workflow.name} (${workflow.steps.length} steps)`,
+        data: {
+          workflow: params.workflow,
+          steps: workflow.steps.map(s => ({
+            id: s.id,
+            name: s.name || s.action || s.skill,
+            depends_on: s.depends_on || [],
+            status: 'pending'
+          })),
+          status: 'started'
+        },
+        input,
+        timestamp: new Date().toISOString()
+      };
+    }
+
+    if (params.action === 'define') {
+      return {
+        type: 'result',
+        skill: 'auto-flow',
+        message: 'Define a workflow in YAML format',
+        data: {
+          format: 'YAML workflow definition',
+          example: {
+            name: 'My Workflow',
+            steps: [
+              { id: 'step1', action: 'run-command', command: 'echo hello' },
+              { id: 'step2', skill: 'code-review', depends_on: ['step1'] }
+            ]
+          }
+        },
+        input,
+        timestamp: new Date().toISOString()
+      };
+    }
+
+    return {
+      type: 'result',
+      skill: 'auto-flow',
+      message: 'Auto Flow. Available actions: list, run, define',
+      data: {
+        actions: ['list - List workflows', 'run <name> - Run workflow', 'define - Define new workflow'],
+        builtinWorkflows: Object.keys(BUILTIN_WORKFLOWS)
+      },
+      input,
+      timestamp: new Date().toISOString()
+    };
+  }
+};
+
+function parseFlowParams(input) {
+  const params = {};
+  if (/列表|list/i.test(input)) params.action = 'list';
+  if (/执行|run|start|运行/i.test(input)) params.action = 'run';
+  if (/定义|define|创建|create/i.test(input)) params.action = 'define';
+
+  const workflowMatch = input.match(/(?:workflow|流程|工作流)\s*[:=]?\s*(\S+)/i);
+  if (workflowMatch) params.workflow = workflowMatch[1];
+
+  return params;
+}