midou 0.1.0

package/src/llm.js

@@ -0,0 +1,239 @@
+/**
+ * LLM 适配器 — 连接任何模型，灵魂始终是 midou 自己
+ *
+ * 支持的提供商（provider）：
+ *   openai    → OpenAI / DeepSeek / Moonshot / 智谱 / Ollama / vLLM …
+ *   anthropic → Anthropic Claude / MiniMax（推荐）…
+ *
+ * 通过 MIDOU_PROVIDER 环境变量切换，默认 'anthropic'
+ */
+
+import OpenAI from 'openai';
+import Anthropic from '@anthropic-ai/sdk';
+import config from '../midou.config.js';
+
+// ────────────────────── 内部状态 ──────────────────────
+
+let provider = null;   // 'openai' | 'anthropic'
+let openaiClient = null;
+let anthropicClient = null;
+
+// ────────────────────── 初始化 ──────────────────────
+
+export function initLLM() {
+  provider = config.llm.provider;
+
+  if (provider === 'anthropic') {
+    if (!config.llm.anthropic.apiKey) {
+      throw new Error(
+        '🐱 midou 需要一个 API Key 才能思考！\n' +
+        '请设置环境变量 MIDOU_API_KEY 或在 .env 文件中配置'
+      );
+    }
+    anthropicClient = new Anthropic({
+      baseURL: config.llm.anthropic.baseURL,
+      apiKey: config.llm.anthropic.apiKey,
+    });
+  } else {
+    // openai 或其他兼容
+    if (!config.llm.openai.apiKey) {
+      throw new Error(
+        '🐱 midou 需要一个 API Key 才能思考！\n' +
+        '请设置环境变量 MIDOU_API_KEY 或在 .env 文件中配置'
+      );
+    }
+    openaiClient = new OpenAI({
+      baseURL: config.llm.openai.baseURL,
+      apiKey: config.llm.openai.apiKey,
+    });
+  }
+}
+
+// ────────────────────── 工具：Anthropic ↔ OpenAI 消息格式转换 ──────────────────────
+
+/**
+ * 从标准 messages 数组中提取 system 消息（Anthropic 需要单独传）
+ */
+function extractSystem(messages) {
+  const system = messages.filter(m => m.role === 'system').map(m => m.content).join('\n\n');
+  const rest = messages.filter(m => m.role !== 'system');
+  return { system, rest };
+}
+
+/**
+ * 将 OpenAI 风格的 tool 定义转换为 Anthropic 格式
+ */
+function toAnthropicTools(openaiTools) {
+  if (!openaiTools?.length) return undefined;
+  return openaiTools.map(t => ({
+    name: t.function.name,
+    description: t.function.description,
+    input_schema: t.function.parameters,
+  }));
+}
+
+/**
+ * 将 Anthropic 的 tool_use 响应转成 OpenAI message 格式（让上层代码统一处理）
+ */
+function anthropicMsgToOpenAI(msg) {
+  const toolCalls = [];
+  let textContent = '';
+
+  for (const block of msg.content) {
+    if (block.type === 'text') {
+      textContent += block.text;
+    } else if (block.type === 'thinking') {
+      // thinking 块也当文本输出——让 midou 可以展示思考过程
+      // 不做处理，避免干扰最终回复
+    } else if (block.type === 'tool_use') {
+      toolCalls.push({
+        id: block.id,
+        type: 'function',
+        function: {
+          name: block.name,
+          arguments: JSON.stringify(block.input),
+        },
+      });
+    }
+  }
+
+  return {
+    role: 'assistant',
+    content: textContent || null,
+    tool_calls: toolCalls.length ? toolCalls : undefined,
+  };
+}
+
+// ────────────────────── 公开 API ──────────────────────
+
+/**
+ * 流式对话
+ */
+export async function* chat(messages, options = {}) {
+  if (!provider) initLLM();
+  const { getModeMaxTokens, getModeTemperature } = await import('./mode.js');
+  const model = options.model || config.llm.model;
+  const temperature = options.temperature ?? getModeTemperature();
+  const maxTokens = options.maxTokens || getModeMaxTokens();
+
+  if (provider === 'anthropic') {
+    const { system, rest } = extractSystem(messages);
+    const stream = anthropicClient.messages.stream({
+      model,
+      system: system || undefined,
+      messages: rest,
+      max_tokens: maxTokens,
+      temperature,
+    });
+    for await (const event of stream) {
+      if (event.type === 'content_block_delta' && event.delta?.type === 'text_delta') {
+        yield event.delta.text;
+      }
+    }
+  } else {
+    const stream = await openaiClient.chat.completions.create({
+      model, messages, temperature, max_tokens: maxTokens, stream: true,
+    });
+    for await (const chunk of stream) {
+      const content = chunk.choices[0]?.delta?.content;
+      if (content) yield content;
+    }
+  }
+}
+
+/**
+ * 非流式回复（心跳 / 后台任务）
+ * options.maxTokens 可由调用方（如心跳）单独指定以节省 token
+ */
+export async function chatSync(messages, options = {}) {
+  if (!provider) initLLM();
+  const { getModeMaxTokens, getModeTemperature } = await import('./mode.js');
+  const model = options.model || config.llm.model;
+  const temperature = options.temperature ?? getModeTemperature();
+  const maxTokens = options.maxTokens || getModeMaxTokens();
+
+  if (provider === 'anthropic') {
+    const { system, rest } = extractSystem(messages);
+    const res = await anthropicClient.messages.create({
+      model, system: system || undefined, messages: rest,
+      max_tokens: maxTokens, temperature,
+    });
+    // 拼接 text 块
+    return res.content
+      .filter(b => b.type === 'text')
+      .map(b => b.text)
+      .join('') || '';
+  } else {
+    const res = await openaiClient.chat.completions.create({
+      model, messages, temperature, max_tokens: maxTokens, stream: false,
+    });
+    return res.choices[0]?.message?.content || '';
+  }
+}
+
+/**
+ * 带工具调用的对话（返回统一的 OpenAI message 格式）
+ */
+export async function chatWithTools(messages, tools, options = {}) {
+  if (!provider) initLLM();
+  const { getModeMaxTokens, getModeTemperature } = await import('./mode.js');
+  const model = options.model || config.llm.model;
+  const temperature = options.temperature ?? getModeTemperature();
+  const maxTokens = options.maxTokens || getModeMaxTokens();
+
+  if (provider === 'anthropic') {
+    const { system, rest } = extractSystem(messages);
+
+    // 把 OpenAI 格式的 tool_result 转换为 Anthropic 格式
+    const anthropicMessages = rest.map(m => {
+      if (m.role === 'tool') {
+        return {
+          role: 'user',
+          content: [{
+            type: 'tool_result',
+            tool_use_id: m.tool_call_id,
+            content: m.content,
+          }],
+        };
+      }
+      // 如果 assistant 消息包含 tool_calls，转换回 Anthropic 格式
+      if (m.role === 'assistant' && m.tool_calls) {
+        const content = [];
+        if (m.content) content.push({ type: 'text', text: m.content });
+        for (const tc of m.tool_calls) {
+          content.push({
+            type: 'tool_use',
+            id: tc.id,
+            name: tc.function.name,
+            input: JSON.parse(tc.function.arguments),
+          });
+        }
+        return { role: 'assistant', content };
+      }
+      return m;
+    });
+
+    const res = await anthropicClient.messages.create({
+      model, system: system || undefined,
+      messages: anthropicMessages,
+      max_tokens: maxTokens, temperature,
+      tools: toAnthropicTools(tools),
+    });
+
+    // 统一转成 OpenAI 格式返回
+    return anthropicMsgToOpenAI(res);
+  } else {
+    const res = await openaiClient.chat.completions.create({
+      model, messages, temperature, max_tokens: maxTokens,
+      tools, tool_choice: 'auto', stream: false,
+    });
+    return res.choices[0]?.message;
+  }
+}
+
+/**
+ * 获取当前提供商名称
+ */
+export function getProvider() {
+  return provider || config.llm.provider;
+}

package/src/mcp.js

@@ -0,0 +1,376 @@
+/**
+ * MCP 客户端管理器 — midou 的扩展触手
+ * 
+ * 连接外部 MCP 服务器，让 midou 获得更多能力。
+ * 就像猫咪伸出爪子探索新事物。
+ * 
+ * 配置文件: ~/.midou/mcp.json
+ * 格式:
+ * {
+ *   "mcpServers": {
+ *     "server-name": {
+ *       "command": "npx",
+ *       "args": ["-y", "@modelcontextprotocol/server-filesystem", "/home/user"],
+ *       "env": { "KEY": "value" }
+ *     }
+ *   }
+ * }
+ */
+
+import { spawn } from 'child_process';
+import fs from 'fs/promises';
+import path from 'path';
+import config from '../midou.config.js';
+
+const MCP_CONFIG_FILE = path.join(config.workspace.root, 'mcp.json');
+
+/**
+ * MCP 服务器连接
+ */
+class MCPConnection {
+  constructor(name, serverConfig) {
+    this.name = name;
+    this.config = serverConfig;
+    this.process = null;
+    this.tools = [];
+    this.connected = false;
+    this._requestId = 0;
+    this._pendingRequests = new Map();
+    this._buffer = '';
+  }
+
+  /**
+   * 连接到 MCP 服务器
+   */
+  async connect() {
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        reject(new Error(`MCP 服务器 ${this.name} 连接超时`));
+      }, 15000);
+
+      try {
+        const env = { ...process.env, ...(this.config.env || {}) };
+        this.process = spawn(this.config.command, this.config.args || [], {
+          stdio: ['pipe', 'pipe', 'pipe'],
+          env,
+          cwd: this.config.cwd || undefined,
+        });
+
+        this.process.stdout.on('data', (data) => {
+          this._handleData(data.toString());
+        });
+
+        this.process.stderr.on('data', (data) => {
+          // MCP 服务器的 stderr 通常是日志
+          // 不做处理，避免干扰
+        });
+
+        this.process.on('error', (err) => {
+          clearTimeout(timeout);
+          this.connected = false;
+          reject(new Error(`MCP 服务器 ${this.name} 启动失败: ${err.message}`));
+        });
+
+        this.process.on('close', () => {
+          this.connected = false;
+        });
+
+        // 发送 initialize 请求
+        this._sendRequest('initialize', {
+          protocolVersion: '2024-11-05',
+          capabilities: {},
+          clientInfo: { name: 'midou', version: '0.1.0' },
+        }).then(async (result) => {
+          clearTimeout(timeout);
+          this.connected = true;
+
+          // 发送 initialized 通知
+          this._sendNotification('notifications/initialized', {});
+
+          // 获取工具列表
+          await this._discoverTools();
+
+          resolve(result);
+        }).catch((err) => {
+          clearTimeout(timeout);
+          reject(err);
+        });
+      } catch (err) {
+        clearTimeout(timeout);
+        reject(err);
+      }
+    });
+  }
+
+  /**
+   * 处理从服务器收到的数据
+   */
+  _handleData(data) {
+    this._buffer += data;
+
+    // JSON-RPC 消息以换行分隔
+    const lines = this._buffer.split('\n');
+    this._buffer = lines.pop() || '';
+
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+
+      try {
+        const msg = JSON.parse(trimmed);
+
+        // 响应消息
+        if (msg.id !== undefined && this._pendingRequests.has(msg.id)) {
+          const { resolve, reject } = this._pendingRequests.get(msg.id);
+          this._pendingRequests.delete(msg.id);
+
+          if (msg.error) {
+            reject(new Error(`MCP Error: ${msg.error.message}`));
+          } else {
+            resolve(msg.result);
+          }
+        }
+        // 通知消息忽略
+      } catch {
+        // 解析失败，忽略
+      }
+    }
+  }
+
+  /**
+   * 发送 JSON-RPC 请求
+   */
+  _sendRequest(method, params = {}) {
+    return new Promise((resolve, reject) => {
+      const id = ++this._requestId;
+      this._pendingRequests.set(id, { resolve, reject });
+
+      const msg = JSON.stringify({
+        jsonrpc: '2.0',
+        id,
+        method,
+        params,
+      });
+
+      this.process.stdin.write(msg + '\n');
+    });
+  }
+
+  /**
+   * 发送 JSON-RPC 通知（无需响应）
+   */
+  _sendNotification(method, params = {}) {
+    const msg = JSON.stringify({
+      jsonrpc: '2.0',
+      method,
+      params,
+    });
+    this.process.stdin.write(msg + '\n');
+  }
+
+  /**
+   * 发现服务器提供的工具
+   */
+  async _discoverTools() {
+    try {
+      const result = await this._sendRequest('tools/list', {});
+      this.tools = (result.tools || []).map(tool => ({
+        ...tool,
+        _mcpServer: this.name,
+      }));
+    } catch {
+      this.tools = [];
+    }
+  }
+
+  /**
+   * 调用一个工具
+   */
+  async callTool(toolName, args) {
+    if (!this.connected) {
+      throw new Error(`MCP 服务器 ${this.name} 未连接`);
+    }
+
+    const result = await this._sendRequest('tools/call', {
+      name: toolName,
+      arguments: args,
+    });
+
+    // 提取文本内容
+    if (result.content && Array.isArray(result.content)) {
+      return result.content
+        .filter(c => c.type === 'text')
+        .map(c => c.text)
+        .join('\n');
+    }
+
+    return JSON.stringify(result);
+  }
+
+  /**
+   * 断开连接
+   */
+  disconnect() {
+    if (this.process) {
+      this.process.stdin.end();
+      this.process.kill();
+      this.process = null;
+    }
+    this.connected = false;
+    this._pendingRequests.clear();
+  }
+}
+
+// ────────────────────── MCP 管理器 ──────────────────────
+
+let connections = new Map();
+
+/**
+ * 加载 MCP 配置
+ */
+async function loadMCPConfig() {
+  try {
+    const data = await fs.readFile(MCP_CONFIG_FILE, 'utf-8');
+    return JSON.parse(data);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * 连接所有配置的 MCP 服务器
+ */
+export async function connectMCPServers() {
+  const mcpConfig = await loadMCPConfig();
+  if (!mcpConfig?.mcpServers) return [];
+
+  const results = [];
+
+  for (const [name, serverConfig] of Object.entries(mcpConfig.mcpServers)) {
+    const conn = new MCPConnection(name, serverConfig);
+    try {
+      await conn.connect();
+      connections.set(name, conn);
+      results.push({
+        name,
+        status: 'connected',
+        tools: conn.tools.map(t => t.name),
+      });
+    } catch (err) {
+      results.push({
+        name,
+        status: 'failed',
+        error: err.message,
+      });
+    }
+  }
+
+  return results;
+}
+
+/**
+ * 获取所有已连接服务器的工具列表
+ * 返回 OpenAI function calling 格式的工具定义
+ */
+export function getMCPToolDefinitions() {
+  const tools = [];
+
+  for (const [serverName, conn] of connections) {
+    if (!conn.connected) continue;
+
+    for (const tool of conn.tools) {
+      tools.push({
+        type: 'function',
+        function: {
+          name: `mcp_${serverName}_${tool.name}`,
+          description: `[MCP: ${serverName}] ${tool.description || tool.name}`,
+          parameters: tool.inputSchema || { type: 'object', properties: {} },
+        },
+        _mcpServer: serverName,
+        _mcpToolName: tool.name,
+      });
+    }
+  }
+
+  return tools;
+}
+
+/**
+ * 判断一个工具名称是否是 MCP 工具
+ */
+export function isMCPTool(toolName) {
+  return toolName.startsWith('mcp_');
+}
+
+/**
+ * 执行 MCP 工具调用
+ */
+export async function executeMCPTool(toolName, args) {
+  // 解析：mcp_{serverName}_{toolName}
+  const parts = toolName.replace(/^mcp_/, '').split('_');
+
+  // 找到匹配的服务器
+  for (const [serverName, conn] of connections) {
+    if (toolName.startsWith(`mcp_${serverName}_`)) {
+      const actualToolName = toolName.replace(`mcp_${serverName}_`, '');
+      return await conn.callTool(actualToolName, args);
+    }
+  }
+
+  throw new Error(`未找到 MCP 工具: ${toolName}`);
+}
+
+/**
+ * 断开所有 MCP 连接
+ */
+export function disconnectAll() {
+  for (const conn of connections.values()) {
+    conn.disconnect();
+  }
+  connections.clear();
+}
+
+/**
+ * 获取 MCP 连接状态
+ */
+export function getMCPStatus() {
+  const status = [];
+  for (const [name, conn] of connections) {
+    status.push({
+      name,
+      connected: conn.connected,
+      toolCount: conn.tools.length,
+      tools: conn.tools.map(t => t.name),
+    });
+  }
+  return status;
+}
+
+/**
+ * 检查是否有 MCP 配置
+ */
+export async function hasMCPConfig() {
+  try {
+    await fs.access(MCP_CONFIG_FILE);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * 构建 MCP 状态提示词
+ */
+export function buildMCPPrompt() {
+  const status = getMCPStatus();
+  if (status.length === 0) return '';
+
+  const lines = ['你已连接以下 MCP 扩展服务器：\n'];
+  for (const s of status) {
+    const state = s.connected ? '✅' : '❌';
+    lines.push(`- ${state} **${s.name}** (${s.toolCount} 个工具): ${s.tools.join(', ')}`);
+  }
+  lines.push('\n使用 MCP 工具时，工具名格式为 `mcp_{服务器名}_{工具名}`。');
+
+  return lines.join('\n');
+}