flowmind 1.0.1 → 1.1.0

package/README_CN.md

@@ -94,7 +94,13 @@ npm install -g flowmind
 ### 初始化
 
 ```bash
+# 基础初始化
 flowmind init
+
+# 带 AI 模型初始化 (推荐)
+flowmind init --ai openai
+flowmind init --ai anthropic
+flowmind init --ai ollama
 ```
 
 > 一次配置，永久生效。配置资源连接、学习偏好、输出格式，无需每次重复设置。
@@ -113,6 +119,248 @@ FlowMind: [自动使用顺序列表格式] ✓
 
 ---
 
+## 📖 使用方式
+
+FlowMind 支持 4 种使用方式，满足不同场景需求：
+
+### 方式1: CLI 独立使用
+
+最简单的使用方式，无需 AI 模型，直接通过命令行调用。
+
+```bash
+# 单次执行
+flowmind "查询 traceId abc123 的日志"
+flowmind "审查代码质量"
+flowmind "验证订单数据"
+
+# 交互模式
+flowmind
+
+# 指定技能执行
+flowmind process --skill log-audit "查询最近1小时的错误日志"
+```
+
+**特点：**
+- ✅ 无需 AI 模型
+- ✅ 基于规则引擎匹配
+- ✅ 支持学习和记忆
+- ✅ 离线可用
+
+---
+
+### 方式2: AI 模型直接接入
+
+FlowMind 内置 AI 模型接入层，可直接调用 OpenAI、Anthropic、Ollama 等模型。
+
+#### 配置 AI 模型
+
+**方式 A：通过 CLI 初始化（推荐）**
+
+```bash
+# 配置 OpenAI
+flowmind init --ai openai
+# 会提示输入 API Key
+
+# 配置 Anthropic
+flowmind init --ai anthropic
+
+# 配置 Ollama (本地模型)
+flowmind init --ai ollama
+```
+
+**方式 B：手动配置**
+
+创建 `~/.flowmind/ai-config.json`：
+
+```json
+{
+  "ai": {
+    "enabled": true,
+    "defaultProvider": "openai",
+    "fallbackToRules": true,
+    "providers": {
+      "openai": {
+        "apiKey": "sk-your-api-key",
+        "model": "gpt-4",
+        "temperature": 0.3
+      },
+      "anthropic": {
+        "apiKey": "sk-ant-your-api-key",
+        "model": "claude-3-sonnet-20240229"
+      },
+      "ollama": {
+        "baseUrl": "http://localhost:11434",
+        "model": "llama2"
+      }
+    },
+    "features": {
+      "intentUnderstanding": true,
+      "parameterExtraction": true,
+      "skillSelection": true,
+      "resultSummary": true,
+      "learningFeedback": true
+    }
+  }
+}
+```
+
+**方式 C：环境变量**
+
+```bash
+export OPENAI_API_KEY=sk-your-api-key
+export ANTHROPIC_API_KEY=sk-ant-your-api-key
+```
+
+#### 测试 AI 连接
+
+```bash
+# 测试默认 Provider
+flowmind ai --test
+
+# 测试指定 Provider
+flowmind ai --test openai
+flowmind ai --test anthropic
+```
+
+#### 使用 AI 增强功能
+
+```bash
+# AI 会理解意图、提取参数、选择技能、生成摘要
+flowmind "帮我查一下最近1小时用户服务的错误日志"
+
+# AI 会分析复杂的多步骤任务
+flowmind "排查线上问题：用户下单失败，需要查看日志、检查数据库、分析原因"
+```
+
+**特点：**
+- ✅ 自然语言理解
+- ✅ 智能参数提取
+- ✅ 结果摘要生成
+- ✅ 降级到规则引擎
+
+---
+
+### 方式3: Claude Code 集成（MCP Server）
+
+让 Claude Code 直接调用 FlowMind 的内部流程。
+
+#### 步骤 1：安装 FlowMind
+
+```bash
+npm install -g flowmind
+```
+
+#### 步骤 2：配置 MCP Server
+
+在项目根目录创建 `.claude/settings.local.json`：
+
+```json
+{
+  "mcpServers": {
+    "flowmind": {
+      "command": "flowmind-mcp",
+      "args": [],
+      "env": {
+        "OPENAI_API_KEY": "${OPENAI_API_KEY}"
+      }
+    }
+  }
+}
+```
+
+或者使用完整路径：
+
+```json
+{
+  "mcpServers": {
+    "flowmind": {
+      "command": "node",
+      "args": ["/path/to/flowmind/mcp/server.js"]
+    }
+  }
+}
+```
+
+#### 步骤 3：在 Claude Code 中使用
+
+```
+你：帮我查询最近1小时的错误日志
+
+Claude：我来调用 FlowMind 帮你查询...
+[调用 flowmind_process 工具]
+
+你：审查一下这个项目的代码质量
+
+Claude：我来使用 FlowMind 的代码审查技能...
+[调用 flowmind_skill_code-review 工具]
+```
+
+#### 可用的 MCP 工具
+
+| 工具名称 | 描述 |
+|---------|------|
+| `flowmind_process` | 处理请求的主入口 |
+| `flowmind_list_skills` | 列出所有可用技能 |
+| `flowmind_get_skill` | 获取技能详情 |
+| `flowmind_ai_status` | 查看 AI 状态 |
+| `flowmind_learning_stats` | 查看学习统计 |
+| `flowmind_skill_<name>` | 执行特定技能 |
+
+**特点：**
+- ✅ Claude Code 直接调用
+- ✅ 无需额外配置 MCP Server
+- ✅ 保留学习和记忆功能
+- ✅ 支持所有 FlowMind 技能
+
+---
+
+### 方式4: Codex 集成（JSON 输出）
+
+通过 JSON 输出与 Codex 集成。
+
+```bash
+# 获取技能列表 (JSON 格式)
+flowmind skills --json
+
+# 获取技能详情
+flowmind skill log-audit --json
+
+# 执行并输出 JSON
+flowmind process --json "查询日志"
+```
+
+**Codex 脚本示例：**
+
+```python
+import subprocess
+import json
+
+def flowmind_query(query):
+    result = subprocess.run(
+        ['flowmind', 'process', '--json', query],
+        capture_output=True,
+        text=True
+    )
+    return json.loads(result.stdout)
+
+# 使用
+result = flowmind_query("查询 traceId abc123 的日志")
+print(result)
+```
+
+---
+
+### 使用方式对比
+
+| 方式 | 适用场景 | 需要 AI | 需要 MCP | 特点 |
+|------|---------|---------|----------|------|
+| CLI 独立使用 | 快速执行、脚本集成 | ❌ | ❌ | 简单直接 |
+| AI 模型接入 | 智能理解、复杂任务 | ✅ | ❌ | 自然语言 |
+| Claude Code | 智能对话、多步骤 | ✅ | ✅ | 深度集成 |
+| Codex 集成 | 自动化、CI/CD | ❌ | ❌ | 程序化调用 |
+
+---
+
 ## 🧠 工作原理
 
 ### 1. 多源代码定位

package/bin/flowmind.js

@@ -52,7 +52,8 @@ program
 program
   .command('init')
   .description('Initialize FlowMind in current directory')
-  .action(async () => {
+  .option('--ai <provider>', 'Initialize with AI provider (openai/anthropic/glm/mimo/qwen/ernie/deepseek/ollama)')
+  .action(async (options) => {
     showBanner();
 
     const spinner = ora('Initializing FlowMind...').start();
@@ -68,7 +69,7 @@ program
       const configPath = path.join(configDir, 'config.json');
       if (!await fs.pathExists(configPath)) {
         const defaultConfig = {
-          version: '1.0.0',
+          version: '1.1.0',
           learning: {
             enabled: true,
             autoApply: true,
@@ -89,17 +90,89 @@ program
         await fs.writeJson(configPath, defaultConfig, { spaces: 2 });
       }
 
+      // Initialize AI if requested
+      if (options.ai) {
+        spinner.text = 'Configuring AI provider...';
+        const aiConfigPath = path.join(configDir, 'ai-config.json');
+
+        let aiConfig = {};
+        if (await fs.pathExists(aiConfigPath)) {
+          aiConfig = await fs.readJson(aiConfigPath);
+        }
+
+        // Set default provider
+        aiConfig.ai = aiConfig.ai || {};
+        aiConfig.ai.defaultProvider = options.ai;
+        aiConfig.ai.enabled = true;
+
+        // Prompt for API key based on provider
+        const apiKeyProviders = {
+          'openai': { key: 'apiKey', message: 'Enter OpenAI API key:', env: 'OPENAI_API_KEY' },
+          'anthropic': { key: 'apiKey', message: 'Enter Anthropic API key:', env: 'ANTHROPIC_API_KEY' },
+          'glm': { key: 'apiKey', message: 'Enter Zhipu AI API key:', env: 'ZHIPU_API_KEY' },
+          'mimo': { key: 'apiKey', message: 'Enter MiMo API key:', env: 'MIMO_API_KEY' },
+          'qwen': { key: 'apiKey', message: 'Enter DashScope API key:', env: 'DASHSCOPE_API_KEY' },
+          'ernie': { key: 'apiKey', message: 'Enter Baidu API key:', env: 'BAIDU_API_KEY' },
+          'deepseek': { key: 'apiKey', message: 'Enter DeepSeek API key:', env: 'DEEPSEEK_API_KEY' }
+        };
+
+        const providerConfig = apiKeyProviders[options.ai];
+        if (providerConfig) {
+          const { apiKey } = await inquirer.prompt([
+            {
+              type: 'password',
+              name: 'apiKey',
+              message: providerConfig.message,
+              mask: '*'
+            }
+          ]);
+
+          aiConfig.ai.providers = aiConfig.ai.providers || {};
+          aiConfig.ai.providers[options.ai] = {
+            ...aiConfig.ai.providers[options.ai],
+            apiKey: apiKey,
+            enabled: true
+          };
+
+          // For ERNIE, also prompt for secret key
+          if (options.ai === 'ernie') {
+            const { secretKey } = await inquirer.prompt([
+              {
+                type: 'password',
+                name: 'secretKey',
+                message: 'Enter Baidu Secret key:',
+                mask: '*'
+              }
+            ]);
+            aiConfig.ai.providers[options.ai].secretKey = secretKey;
+          }
+        }
+
+        await fs.writeJson(aiConfigPath, aiConfig, { spaces: 2 });
+        console.log(chalk.green(`\n✓ AI provider configured: ${options.ai}`));
+      }
+
       spinner.succeed('FlowMind initialized successfully!');
 
       console.log(chalk.green('\n✓ Configuration created at:'), configDir);
       console.log(chalk.green('✓ Learning system ready'));
       console.log(chalk.green('✓ Scene mapping ready'));
 
+      if (options.ai) {
+        console.log(chalk.green(`✓ AI provider configured: ${options.ai}`));
+      }
+
       console.log(chalk.cyan('\nNext steps:'));
       console.log('  1. Run', chalk.yellow('flowmind'), 'to start interactive mode');
       console.log('  2. Or use', chalk.yellow('flowmind "your request"'), 'for single commands');
       console.log('  3. FlowMind will learn from your corrections automatically');
 
+      if (!options.ai) {
+        console.log(chalk.cyan('\nTo enable AI features:'));
+        console.log('  Run', chalk.yellow('flowmind init --ai openai'), 'or', chalk.yellow('flowmind init --ai anthropic'));
+        console.log('  Or configure manually:', chalk.yellow('~/.flowmind/ai-config.json'));
+      }
+
     } catch (error) {
       spinner.fail('Failed to initialize FlowMind');
       console.error(chalk.red(error.message));
@@ -404,6 +477,82 @@ program
     }
   });
 
+// AI command
+program
+  .command('ai')
+  .description('Manage AI model configuration')
+  .option('-s, --status', 'Show AI model status')
+  .option('-l, --list', 'List available providers')
+  .option('-c, --config', 'Show AI configuration')
+  .option('-t, --test [provider]', 'Test AI provider connection')
+  .option('-j, --json', 'Output as JSON')
+  .action(async (options) => {
+    try {
+      const fm = await initFlowMind();
+
+      if (options.status) {
+        const status = fm.getAIStatus();
+        if (options.json) {
+          console.log(JSON.stringify(status, null, 2));
+        } else {
+          displayAIStatus(status);
+        }
+      } else if (options.list) {
+        const status = fm.getAIStatus();
+        const providers = Object.entries(status.providers).map(([name, info]) => ({
+          name,
+          ...info
+        }));
+        if (options.json) {
+          console.log(JSON.stringify({ providers }, null, 2));
+        } else {
+          console.log(chalk.cyan('\nAI Providers:'));
+          for (const provider of providers) {
+            const status = provider.initialized ? chalk.green('✓') : chalk.red('✗');
+            console.log(`  ${status} ${provider.name}`);
+            if (provider.info?.model) {
+              console.log(`    Model: ${provider.info.model}`);
+            }
+          }
+        }
+      } else if (options.config) {
+        const config = fm.config.get('ai', {});
+        if (options.json) {
+          console.log(JSON.stringify({ ai: config }, null, 2));
+        } else {
+          console.log(chalk.cyan('\nAI Configuration:'));
+          console.log(JSON.stringify(config, null, 2));
+        }
+      } else if (options.test !== undefined) {
+        const providerName = options.test || fm.ai.defaultProvider;
+        const provider = fm.ai.getProvider(providerName);
+        if (!provider) {
+          console.error(chalk.red(`Provider not found: ${providerName}`));
+          return;
+        }
+        console.log(chalk.cyan(`\nTesting ${providerName}...`));
+        try {
+          const result = await provider.complete('Hello, this is a test.', { maxTokens: 50 });
+          console.log(chalk.green('✓ Connection successful'));
+          console.log(chalk.white('Response:'), result.substring(0, 100) + '...');
+        } catch (error) {
+          console.log(chalk.red('✗ Connection failed'));
+          console.error(chalk.red(error.message));
+        }
+      } else {
+        // Default to status
+        const status = fm.getAIStatus();
+        if (options.json) {
+          console.log(JSON.stringify(status, null, 2));
+        } else {
+          displayAIStatus(status);
+        }
+      }
+    } catch (error) {
+      console.error(chalk.red('Error:'), error.message);
+    }
+  });
+
 // Interactive mode
 async function runInteractiveMode(fm) {
   showBanner();
@@ -802,6 +951,39 @@ function displayResourceConfig(config) {
   console.log(chalk.cyan('└─────────────────────────────────────────────────────┘'));
 }
 
+function displayAIStatus(status) {
+  console.log(chalk.cyan('\n┌─────────────────────────────────────────────────────┐'));
+  console.log(chalk.cyan('│ AI Model Status                                     │'));
+  console.log(chalk.cyan('├─────────────────────────────────────────────────────┤'));
+
+  const initialized = status.initialized ? chalk.green('✓') : chalk.red('✗');
+  console.log(chalk.cyan(`│ Initialized: ${initialized}`));
+  console.log(chalk.cyan(`│ Default Provider: ${status.defaultProvider || 'None'}`));
+
+  console.log(chalk.cyan('├─────────────────────────────────────────────────────┤'));
+  console.log(chalk.cyan('│ Features:'));
+
+  const features = status.features || {};
+  for (const [feature, enabled] of Object.entries(features)) {
+    const statusIcon = enabled ? chalk.green('✓') : chalk.red('✗');
+    console.log(chalk.cyan(`│   ${statusIcon} ${feature}`));
+  }
+
+  console.log(chalk.cyan('├─────────────────────────────────────────────────────┤'));
+  console.log(chalk.cyan('│ Providers:'));
+
+  const providers = status.providers || {};
+  for (const [name, info] of Object.entries(providers)) {
+    const statusIcon = info.initialized ? chalk.green('✓') : chalk.red('✗');
+    console.log(chalk.cyan(`│   ${statusIcon} ${name}`));
+    if (info.info?.model) {
+      console.log(chalk.cyan(`│     Model: ${info.info.model}`));
+    }
+  }
+
+  console.log(chalk.cyan('└─────────────────────────────────────────────────────┘'));
+}
+
 function formatFileSize(bytes) {
   if (bytes === 0) return '0 B';
   const k = 1024;

package/config/ai-config.example.json

@@ -0,0 +1,64 @@
+{
+  "ai": {
+    "enabled": true,
+    "defaultProvider": "glm",
+    "fallbackToRules": true,
+    "providers": {
+      "openai": {
+        "apiKey": "${OPENAI_API_KEY}",
+        "model": "gpt-4",
+        "temperature": 0.3,
+        "maxTokens": 2000
+      },
+      "anthropic": {
+        "apiKey": "${ANTHROPIC_API_KEY}",
+        "model": "claude-3-sonnet-20240229",
+        "maxTokens": 2000,
+        "temperature": 0.3
+      },
+      "glm": {
+        "apiKey": "${ZHIPU_API_KEY}",
+        "model": "glm-4-flash",
+        "temperature": 0.3,
+        "maxTokens": 2000
+      },
+      "mimo": {
+        "apiKey": "${MIMO_API_KEY}",
+        "model": "mimo-7b",
+        "temperature": 0.3,
+        "maxTokens": 2000
+      },
+      "qwen": {
+        "apiKey": "${DASHSCOPE_API_KEY}",
+        "model": "qwen-turbo",
+        "temperature": 0.3,
+        "maxTokens": 2000
+      },
+      "ernie": {
+        "apiKey": "${BAIDU_API_KEY}",
+        "secretKey": "${BAIDU_SECRET_KEY}",
+        "model": "ernie-4.0-turbo-8k",
+        "temperature": 0.3,
+        "maxTokens": 2000
+      },
+      "deepseek": {
+        "apiKey": "${DEEPSEEK_API_KEY}",
+        "model": "deepseek-chat",
+        "temperature": 0.3,
+        "maxTokens": 2000
+      },
+      "ollama": {
+        "baseUrl": "http://localhost:11434",
+        "model": "llama2",
+        "temperature": 0.3
+      }
+    },
+    "features": {
+      "intentUnderstanding": true,
+      "parameterExtraction": true,
+      "skillSelection": true,
+      "resultSummary": true,
+      "learningFeedback": true
+    }
+  }
+}

package/config/claude-mcp-config.example.json

@@ -0,0 +1,12 @@
+{
+  "mcpServers": {
+    "flowmind": {
+      "command": "node",
+      "args": ["/path/to/flowmind/mcp/server.js"],
+      "env": {
+        "OPENAI_API_KEY": "${OPENAI_API_KEY}",
+        "ANTHROPIC_API_KEY": "${ANTHROPIC_API_KEY}"
+      }
+    }
+  }
+}

package/core/ai/base-model.js

@@ -0,0 +1,70 @@
+/**
+ * Base Model - AI 模型抽象基类
+ * 所有模型 Provider 必须继承此类并实现抽象方法
+ */
+
+class BaseModel {
+  constructor(name, config = {}) {
+    this.name = name;
+    this.config = config;
+    this.initialized = false;
+  }
+
+  /**
+   * 初始化模型
+   * @returns {Promise<void>}
+   */
+  async init() {
+    throw new Error('init() must be implemented by subclass');
+  }
+
+  /**
+   * 发送聊天请求
+   * @param {Array} messages - 消息数组 [{role, content}]
+   * @param {Object} options - 请求选项
+   * @returns {Promise<string>} 模型响应
+   */
+  async chat(messages, options = {}) {
+    throw new Error('chat() must be implemented by subclass');
+  }
+
+  /**
+   * 发送补全请求
+   * @param {string} prompt - 提示词
+   * @param {Object} options - 请求选项
+   * @returns {Promise<string>} 模型响应
+   */
+  async complete(prompt, options = {}) {
+    throw new Error('complete() must be implemented by subclass');
+  }
+
+  /**
+   * 检查模型是否可用
+   * @returns {Promise<boolean>}
+   */
+  async isAvailable() {
+    throw new Error('isAvailable() must be implemented by subclass');
+  }
+
+  /**
+   * 获取模型信息
+   * @returns {Object}
+   */
+  getInfo() {
+    return {
+      name: this.name,
+      provider: this.constructor.name,
+      initialized: this.initialized
+    };
+  }
+
+  /**
+   * 验证配置
+   * @returns {boolean}
+   */
+  validateConfig() {
+    return true;
+  }
+}
+
+module.exports = BaseModel;

package/core/ai/index.js

@@ -0,0 +1,29 @@
+/**
+ * AI Module - AI 模型接入层入口
+ */
+
+const ModelManager = require('./model-manager');
+const BaseModel = require('./base-model');
+const OpenAIProvider = require('./providers/openai');
+const AnthropicProvider = require('./providers/anthropic');
+const OllamaProvider = require('./providers/ollama');
+const GLMProvider = require('./providers/glm');
+const MiMoProvider = require('./providers/mimo');
+const QwenProvider = require('./providers/qwen');
+const ERNIEProvider = require('./providers/ernie');
+const DeepSeekProvider = require('./providers/deepseek');
+const prompts = require('./prompts');
+
+module.exports = {
+  ModelManager,
+  BaseModel,
+  OpenAIProvider,
+  AnthropicProvider,
+  OllamaProvider,
+  GLMProvider,
+  MiMoProvider,
+  QwenProvider,
+  ERNIEProvider,
+  DeepSeekProvider,
+  prompts
+};