thatgfsj-code 0.2.1

package/src/mcp/client.ts

@@ -0,0 +1,330 @@
+/**
+ * S07: MCP Client (Model Context Protocol)
+ * Connect to MCP servers and expose their tools as agent tools
+ * 
+ * MCP turns the agent from a closed system into an open platform.
+ * Any server can expose tools via the MCP JSON-RPC 2.0 protocol.
+ */
+
+import { spawn, ChildProcess } from 'child_process';
+import { Tool, ToolResult } from '../core/types.js';
+
+// ==================== MCP Types ====================
+
+interface MCPJsonRPCRequest {
+  jsonrpc: '2.0';
+  id: number | string;
+  method: string;
+  params?: any;
+}
+
+interface MCPJsonRPCResponse {
+  jsonrpc: '2.0';
+  id: number | string;
+  result?: any;
+  error?: { code: number; message: string; data?: any };
+}
+
+interface MCPTool {
+  name: string;
+  description: string;
+  inputSchema: {
+    type: 'object';
+    properties: Record<string, any>;
+    required?: string[];
+  };
+}
+
+// ==================== MCP Client ====================
+
+export class MCPClient {
+  private process: ChildProcess | null = null;
+  private tools: Map<string, MCPTool> = new Map();
+  private requestId = 0;
+  private pendingRequests: Map<number | string, {
+    resolve: (value: any) => void;
+    reject: (reason: any) => void;
+  }> = new Map();
+  private name: string;
+  private connected = false;
+
+  constructor(name: string) {
+    this.name = name;
+  }
+
+  /**
+   * S07: Connect to an MCP server
+   * @param command Command to run (e.g., 'npx', 'node')
+   * @param args Arguments (e.g., ['-y', '@modelcontextprotocol/server-filesystem', '/path/to/dir'])
+   */
+  async connect(command: string, args: string[]): Promise<void> {
+    return new Promise((resolve, reject) => {
+      this.process = spawn(command, args, {
+        stdio: ['pipe', 'pipe', 'pipe']
+      });
+
+      let buffer = '';
+
+      this.process.stdout?.on('data', (data: Buffer) => {
+        buffer += data.toString();
+        const lines = buffer.split('\n');
+        buffer = lines.pop() || '';
+
+        for (const line of lines) {
+          if (line.trim()) {
+            this.handleMessage(line);
+          }
+        }
+      });
+
+      this.process.stderr?.on('data', (data: Buffer) => {
+        console.error(`[MCP ${this.name}] stderr:`, data.toString().trim());
+      });
+
+      this.process.on('error', (err) => {
+        reject(err);
+      });
+
+      this.process.on('close', (code) => {
+        this.connected = false;
+        console.log(`[MCP ${this.name}] exited with code ${code}`);
+      });
+
+      // Initialize MCP connection
+      this.sendRequest('initialize', {
+        protocolVersion: '2024-11-05',
+        capabilities: { tools: {} },
+        clientInfo: { name: 'thatgfsj-code', version: '1.0.0' }
+      }).then(() => {
+        this.connected = true;
+        // Send initialized notification
+        this.sendNotification('initialized', {});
+        // List available tools
+        return this.listTools();
+      }).then(() => {
+        resolve();
+      }).catch(reject);
+
+      // Timeout
+      setTimeout(() => reject(new Error('MCP connection timeout')), 30000);
+    });
+  }
+
+  /**
+   * S07: Handle incoming JSON-RPC message
+   */
+  private handleMessage(raw: string): void {
+    try {
+      const msg: MCPJsonRPCResponse = JSON.parse(raw);
+
+      // Handle response
+      const pending = this.pendingRequests.get(msg.id);
+      if (pending) {
+        this.pendingRequests.delete(msg.id);
+        if (msg.error) {
+          pending.reject(new Error(msg.error.message));
+        } else {
+          pending.resolve(msg.result);
+        }
+        return;
+      }
+    } catch {
+      // Not JSON, ignore
+    }
+  }
+
+  /**
+   * S07: Send a JSON-RPC request
+   */
+  private sendRequest(method: string, params: any): Promise<any> {
+    return new Promise((resolve, reject) => {
+      if (!this.process?.connected) {
+        reject(new Error('MCP process not connected'));
+        return;
+      }
+
+      const id = ++this.requestId;
+      this.pendingRequests.set(id, { resolve, reject });
+
+      const request: MCPJsonRPCRequest = {
+        jsonrpc: '2.0',
+        id,
+        method,
+        params
+      };
+
+      this.process.stdin?.write(JSON.stringify(request) + '\n');
+
+      // Timeout
+      setTimeout(() => {
+        if (this.pendingRequests.has(id)) {
+          this.pendingRequests.delete(id);
+          reject(new Error('MCP request timeout: ' + method));
+        }
+      }, 30000);
+    });
+  }
+
+  /**
+   * S07: Send a notification (no response expected)
+   */
+  private sendNotification(method: string, params: any): void {
+    if (!this.process?.connected) return;
+
+    const notification = {
+      jsonrpc: '2.0',
+      method,
+      params
+    };
+
+    this.process.stdin?.write(JSON.stringify(notification) + '\n');
+  }
+
+  /**
+   * S07: Call an MCP tool
+   */
+  async callTool(name: string, arguments_: Record<string, any>): Promise<ToolResult> {
+    try {
+      const result = await this.sendRequest('tools/call', {
+        name,
+        arguments: arguments_
+      });
+
+      return {
+        success: true,
+        output: typeof result === 'string' ? result : JSON.stringify(result)
+      };
+    } catch (error: any) {
+      return {
+        success: false,
+        error: error.message
+      };
+    }
+  }
+
+  /**
+   * S07: List tools from MCP server
+   */
+  private async listTools(): Promise<void> {
+    try {
+      const result = await this.sendRequest('tools/list', {});
+      const tools: MCPTool[] = result.tools || [];
+
+      this.tools.clear();
+      for (const tool of tools) {
+        this.tools.set(tool.name, tool);
+      }
+
+      console.log(`[MCP ${this.name}] Loaded ${tools.length} tools:`, [...this.tools.keys()].join(', '));
+    } catch (error: any) {
+      console.error(`[MCP ${this.name}] Failed to list tools:`, error.message);
+    }
+  }
+
+  /**
+   * S07: Get registered tools as agent Tool[]
+   */
+  getTools(): Tool[] {
+    return [...this.tools.values()].map(mcpTool => ({
+      name: this.name + ':' + mcpTool.name,
+      description: mcpTool.description,
+      parameters: Object.entries(mcpTool.inputSchema.properties || {}).map(([name, schema]: [string, any]) => ({
+        name,
+        type: schema.type || 'string',
+        description: schema.description || '',
+        required: (mcpTool.inputSchema.required || []).includes(name)
+      })),
+      execute: async (params: Record<string, any>): Promise<ToolResult> => {
+        return this.callTool(mcpTool.name, params);
+      }
+    }));
+  }
+
+  /**
+   * S07: Get tool names
+   */
+  getToolNames(): string[] {
+    return [...this.tools.keys()];
+  }
+
+  /**
+   * S07: Check if connected
+   */
+  isConnected(): boolean {
+    return this.connected;
+  }
+
+  /**
+   * S07: Disconnect from MCP server
+   */
+  disconnect(): void {
+    if (this.process) {
+      this.process.kill();
+      this.process = null;
+    }
+    this.connected = false;
+    this.tools.clear();
+    this.pendingRequests.clear();
+  }
+}
+
+// ==================== MCP Server Manager ====================
+
+export class MCPServerManager {
+  private clients: Map<string, MCPClient> = new Map();
+
+  /**
+   * S07: Add and connect an MCP server
+   */
+  async addServer(name: string, command: string, args: string[]): Promise<void> {
+    const client = new MCPClient(name);
+    await client.connect(command, args);
+    this.clients.set(name, client);
+  }
+
+  /**
+   * S07: Get all tools from all servers
+   */
+  getAllTools(): Tool[] {
+    const allTools: Tool[] = [];
+    for (const client of this.clients.values()) {
+      allTools.push(...client.getTools());
+    }
+    return allTools;
+  }
+
+  /**
+   * S07: Get tool names from all servers
+   */
+  getAllToolNames(): string[] {
+    const names: string[] = [];
+    for (const [serverName, client] of this.clients) {
+      for (const toolName of client.getToolNames()) {
+        names.push(serverName + ':' + toolName);
+      }
+    }
+    return names;
+  }
+
+  /**
+   * S07: Disconnect a server
+   */
+  removeServer(name: string): void {
+    const client = this.clients.get(name);
+    if (client) {
+      client.disconnect();
+      this.clients.delete(name);
+    }
+  }
+
+  /**
+   * S07: Get server status
+   */
+  getStatus(): Record<string, boolean> {
+    const status: Record<string, boolean> = {};
+    for (const [name, client] of this.clients) {
+      status[name] = client.isConnected();
+    }
+    return status;
+  }
+}

package/src/repl/index.ts

@@ -0,0 +1,8 @@
+/**
+ * REPL Module
+ * Interactive input/output handling
+ */
+
+export { REPLInput } from './input.js';
+export { REPLOutput } from './output.js';
+export { REPLLoop } from './loop.js';

package/src/repl/input.ts

@@ -0,0 +1,139 @@
+/**
+ * REPL Input Handler
+ *
+ * 基于 @inquirer/input 实现，支持：
+ *   - 方向键（含数字小键盘方向键）行内移动 / 跳转词首尾
+ *   - Home / End / Backspace / Delete 行内编辑
+ *   - Ctrl+A / Ctrl+E 跳到行首/行尾（emacs 风格）
+ *   - Ctrl+C 中断当前输入（不清空整个会话），连续按两次空输入退出
+ *   - 命令历史：本地维护 history 数组，通过 default 预填上一条
+ *
+ * 不再使用 Node 内置 readline 的 rl.question()——它在 Windows 终端下
+ * 对小键盘方向键的 ANSI 转义序列不友好，会导致光标无法移动 (Bug #1)。
+ */
+
+import input from '@inquirer/input';
+import chalk from 'chalk';
+
+const MAX_HISTORY = 200;
+
+export type PromptResult =
+  | { kind: 'value'; value: string }       // 用户正常输入并提交（Enter）
+  | { kind: 'cancelled' };                  // Ctrl+C 中断当前输入
+
+export class REPLInput {
+  private history: string[] = [];
+  private historyIndex: number = -1;        // -1 表示"未在历史中浏览"
+  private currentDraft: string = '';        // 离开历史时保留用户原始草稿
+  private defaultPrefix: string = chalk.green('\n> ');
+  private consecutiveCancels: number = 0;   // 连续空输入 + Ctrl+C 计数,达到阈值退出
+
+  /**
+   * Ask the user for input. Returns either a value or 'cancelled'.
+   * Loop decides what to do with cancellation (usually: continue session,
+   * unless user has cancelled an already-empty input twice in a row).
+   */
+  async prompt(prefix?: string, abortSignal?: AbortSignal): Promise<PromptResult> {
+    const prefill = this.computePrefill();
+    const previousDraft = prefill.kind === 'history' ? prefill.value : '';
+
+    // 用 abortSignal 绑到 inquirer:外面 Ctrl+C / 主进程事件可以取消
+    const value = await input({
+      message: prefix ?? this.defaultPrefix,
+      prefill: 'editable',                  // 关键:启用方向键 + 行内编辑,包括小键盘
+      default: previousDraft,               // 历史预填
+      // Ctrl+C 由 @inquirer/input 抛出一个 symbol-like 错误,我们捕获为 cancelled
+      validate: () => true,
+    }, abortSignal ? { signal: abortSignal } : undefined).catch((err: any) => {
+      // 区分真实错误与用户取消;inquirer 用 ExitPromptError (name: 'ExitPromptError')
+      if (err && (err.name === 'ExitPromptError' || err.message?.includes('User force closed'))) {
+        return null;
+      }
+      throw err;
+    });
+
+    if (value === null || value === undefined) {
+      this.consecutiveCancels++;
+      return { kind: 'cancelled' };
+    }
+
+    const trimmed = value.trim();
+    if (trimmed.length > 0) {
+      // 避免把连续重复的内容都压入历史
+      if (this.history[this.history.length - 1] !== trimmed) {
+        this.history.push(trimmed);
+        if (this.history.length > MAX_HISTORY) this.history.shift();
+      }
+    }
+
+    this.consecutiveCancels = 0;
+    return { kind: 'value', value: trimmed };
+  }
+
+  /**
+   * Should we ask the loop to exit? Two consecutive Ctrl+C on empty input => exit.
+   */
+  shouldExitOnCancel(): boolean {
+    return this.consecutiveCancels >= 2;
+  }
+
+  /**
+   * Reset consecutive-cancel counter when the loop has decided to keep running.
+   */
+  resetCancelCounter(): void {
+    this.consecutiveCancels = 0;
+  }
+
+  /**
+   * Decide what to prefill. Two modes:
+   *   - 'history': when user is navigating up/down with arrows
+   *   - 'draft':   when user has cleared the input — preserve their draft
+   */
+  private computePrefill(): { kind: 'history' | 'draft' | 'none'; value: string } {
+    if (this.historyIndex >= 0 && this.historyIndex < this.history.length) {
+      return { kind: 'history', value: this.history[this.historyIndex] };
+    }
+    if (this.currentDraft) return { kind: 'draft', value: this.currentDraft };
+    return { kind: 'none', value: '' };
+  }
+
+  /**
+   * Save the user's in-progress draft so ↑↓ preserves their unsent typing.
+   */
+  saveDraft(text: string): void {
+    this.currentDraft = text;
+  }
+
+  /**
+   * Navigate up in history (called from a global key listener, if needed).
+   */
+  historyUp(): string {
+    if (this.history.length === 0) return this.currentDraft;
+    if (this.historyIndex < 0) this.historyIndex = this.history.length;
+    if (this.historyIndex > 0) this.historyIndex--;
+    return this.history[this.historyIndex] ?? '';
+  }
+
+  /**
+   * Navigate down in history.
+   */
+  historyDown(): string {
+    if (this.history.length === 0) return this.currentDraft;
+    if (this.historyIndex >= this.history.length) return this.currentDraft;
+    this.historyIndex++;
+    if (this.historyIndex >= this.history.length) {
+      this.historyIndex = this.history.length;
+      return this.currentDraft;
+    }
+    return this.history[this.historyIndex] ?? '';
+  }
+
+  getHistory(): readonly string[] {
+    return this.history;
+  }
+
+  clearHistory(): void {
+    this.history = [];
+    this.historyIndex = -1;
+  }
+}