wispy-cli 0.3.1 → 0.4.0

package/bin/wispy-tui.mjs

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+
+/**
+ * wispy-tui — Ink-based TUI entry point
+ * Delegates to lib/wispy-tui.mjs
+ */
+
+import { fileURLToPath } from "node:url";
+import path from "node:path";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const tuiScript = path.join(__dirname, "..", "lib", "wispy-tui.mjs");
+
+await import(tuiScript);

package/bin/wispy.mjs

@@ -1,11 +1,29 @@
 #!/usr/bin/env node
 
-// Wispy CLI entry point — delegates to the main REPL
+/**
+ * Wispy CLI entry point
+ *
+ * Flags:
+ *   --tui    Launch Ink-based TUI mode
+ *   (default) Launch interactive REPL
+ */
+
 import { fileURLToPath } from "node:url";
 import path from "node:path";
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const mainScript = path.join(__dirname, "..", "lib", "wispy-repl.mjs");
 
-// Dynamic import of the main module
-await import(mainScript);
+// Check for --tui flag
+const args = process.argv.slice(2);
+const tuiMode = args.includes("--tui");
+
+if (tuiMode) {
+  // Remove --tui from args so wispy-tui doesn't see it
+  const newArgs = args.filter(a => a !== "--tui");
+  process.argv = [process.argv[0], process.argv[1], ...newArgs];
+  const tuiScript = path.join(__dirname, "..", "lib", "wispy-tui.mjs");
+  await import(tuiScript);
+} else {
+  const mainScript = path.join(__dirname, "..", "lib", "wispy-repl.mjs");
+  await import(mainScript);
+}

package/lib/mcp-client.mjs

@@ -0,0 +1,381 @@
+#!/usr/bin/env node
+/**
+ * mcp-client.mjs — MCP (Model Context Protocol) client for Wispy
+ *
+ * Implements:
+ *   - stdio transport (spawn server process, communicate over stdin/stdout)
+ *   - JSON-RPC 2.0 framing (newline-delimited)
+ *   - initialize / tools/list / tools/call
+ *   - MCPManager: manages multiple named server connections
+ */
+
+import { spawn } from "node:child_process";
+import { EventEmitter } from "node:events";
+import readline from "node:readline";
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+
+// ---------------------------------------------------------------------------
+// MCPClient — single server connection
+// ---------------------------------------------------------------------------
+
+export class MCPClient extends EventEmitter {
+  constructor(name, config) {
+    super();
+    this.name = name;
+    this.config = config; // { command, args?, env?, cwd? }
+    this.process = null;
+    this.rl = null;
+    this._requestId = 0;
+    this._pending = new Map(); // id → { resolve, reject, timer }
+    this.tools = [];
+    this.connected = false;
+    this.initialized = false;
+    this.serverInfo = null;
+  }
+
+  async connect() {
+    const { command, args = [], env = {}, cwd } = this.config;
+
+    this.process = spawn(command, args, {
+      stdio: ["pipe", "pipe", "pipe"],
+      env: { ...process.env, ...env },
+      cwd: cwd ?? undefined,
+    });
+
+    this.process.on("error", (err) => {
+      this.connected = false;
+      this.emit("error", err);
+      this._rejectAll(err);
+    });
+
+    this.process.on("exit", (code) => {
+      this.connected = false;
+      this.initialized = false;
+      this.emit("disconnect", code);
+      this._rejectAll(new Error(`MCP server "${this.name}" exited with code ${code}`));
+    });
+
+    // Read JSON-RPC messages from stdout (newline-delimited)
+    this.rl = readline.createInterface({
+      input: this.process.stdout,
+      crlfDelay: Infinity,
+    });
+    this.rl.on("line", (line) => this._handleLine(line.trim()));
+
+    // Collect stderr for debugging
+    this._stderrBuf = "";
+    this.process.stderr.on("data", (data) => {
+      this._stderrBuf += data.toString();
+      this.emit("stderr", data.toString());
+    });
+
+    this.connected = true;
+
+    // Run MCP handshake
+    await this._initialize();
+    return this;
+  }
+
+  async _initialize() {
+    const result = await this._request("initialize", {
+      protocolVersion: "2024-11-05",
+      capabilities: {
+        roots: { listChanged: false },
+        sampling: {},
+      },
+      clientInfo: {
+        name: "wispy",
+        version: "0.5.0",
+      },
+    });
+
+    this.serverInfo = result?.serverInfo ?? null;
+
+    // Send initialized notification (required by spec)
+    this._notify("notifications/initialized", {});
+    this.initialized = true;
+    this.emit("ready", result);
+    return result;
+  }
+
+  async listTools() {
+    const result = await this._request("tools/list", {});
+    this.tools = result?.tools ?? [];
+    return this.tools;
+  }
+
+  async callTool(name, args = {}) {
+    const result = await this._request("tools/call", {
+      name,
+      arguments: args,
+    });
+    return result;
+  }
+
+  disconnect() {
+    if (this.rl) {
+      this.rl.close();
+      this.rl = null;
+    }
+    if (this.process) {
+      try { this.process.stdin.end(); } catch {}
+      try { this.process.kill("SIGTERM"); } catch {}
+      this.process = null;
+    }
+    this.connected = false;
+    this.initialized = false;
+  }
+
+  // ---------------------------------------------------------------------------
+  // Internal JSON-RPC helpers
+  // ---------------------------------------------------------------------------
+
+  _handleLine(line) {
+    if (!line) return;
+    try {
+      const msg = JSON.parse(line);
+      // Response to a pending request
+      if (msg.id !== undefined && this._pending.has(msg.id)) {
+        const { resolve, reject } = this._pending.get(msg.id);
+        this._pending.delete(msg.id);
+        if (msg.error) {
+          reject(new Error(msg.error.message ?? JSON.stringify(msg.error)));
+        } else {
+          resolve(msg.result);
+        }
+      } else if (msg.method) {
+        // Server-initiated notification or request
+        this.emit("notification", msg);
+      }
+    } catch {
+      // Non-JSON line (server logs etc.) — ignore
+    }
+  }
+
+  _request(method, params, timeoutMs = 30_000) {
+    return new Promise((resolve, reject) => {
+      if (!this.connected || !this.process) {
+        return reject(new Error(`MCP server "${this.name}" is not connected`));
+      }
+
+      const id = ++this._requestId;
+      const msg = JSON.stringify({ jsonrpc: "2.0", id, method, params });
+
+      const timer = setTimeout(() => {
+        this._pending.delete(id);
+        reject(new Error(`MCP request "${method}" timed out after ${timeoutMs}ms`));
+      }, timeoutMs);
+
+      this._pending.set(id, {
+        resolve: (val) => { clearTimeout(timer); resolve(val); },
+        reject: (err) => { clearTimeout(timer); reject(err); },
+      });
+
+      try {
+        this.process.stdin.write(msg + "\n");
+      } catch (err) {
+        this._pending.delete(id);
+        clearTimeout(timer);
+        reject(err);
+      }
+    });
+  }
+
+  _notify(method, params) {
+    if (!this.connected || !this.process) return;
+    const msg = JSON.stringify({ jsonrpc: "2.0", method, params });
+    try {
+      this.process.stdin.write(msg + "\n");
+    } catch { /* ignore */ }
+  }
+
+  _rejectAll(err) {
+    for (const { reject } of this._pending.values()) {
+      reject(err);
+    }
+    this._pending.clear();
+  }
+}
+
+// ---------------------------------------------------------------------------
+// MCPManager — manages multiple named server connections
+// ---------------------------------------------------------------------------
+
+export class MCPManager {
+  constructor(configPath) {
+    this.configPath = configPath;
+    this.clients = new Map(); // name → MCPClient
+    this._toolIndex = new Map(); // wispyName → { serverName, mcpName, inputSchema, description }
+  }
+
+  // Load ~/.wispy/mcp.json (creates default if missing)
+  async loadConfig() {
+    try {
+      const raw = await readFile(this.configPath, "utf8");
+      return JSON.parse(raw);
+    } catch {
+      return { mcpServers: {} };
+    }
+  }
+
+  // Save updated config
+  async saveConfig(config) {
+    await mkdir(path.dirname(this.configPath), { recursive: true });
+    await writeFile(this.configPath, JSON.stringify(config, null, 2) + "\n", "utf8");
+  }
+
+  // Auto-connect all non-disabled servers from config
+  async autoConnect() {
+    const config = await this.loadConfig();
+    const servers = config.mcpServers ?? {};
+    const results = [];
+
+    for (const [name, serverConfig] of Object.entries(servers)) {
+      if (serverConfig.disabled) {
+        results.push({ name, status: "disabled" });
+        continue;
+      }
+      try {
+        const client = await this.connect(name, serverConfig);
+        results.push({ name, status: "connected", tools: client.tools.length });
+      } catch (err) {
+        results.push({ name, status: "failed", error: err.message.slice(0, 200) });
+      }
+    }
+
+    return results;
+  }
+
+  // Connect a single server by name + config
+  async connect(name, serverConfig) {
+    // Disconnect existing connection if any
+    if (this.clients.has(name)) {
+      this.clients.get(name).disconnect();
+      this.clients.delete(name);
+    }
+
+    const client = new MCPClient(name, serverConfig);
+    await client.connect();
+    await client.listTools();
+
+    this.clients.set(name, client);
+    this._rebuildToolIndex();
+
+    return client;
+  }
+
+  // Disconnect a single server by name
+  disconnect(name) {
+    const client = this.clients.get(name);
+    if (client) {
+      client.disconnect();
+      this.clients.delete(name);
+      this._rebuildToolIndex();
+      return true;
+    }
+    return false;
+  }
+
+  // Disconnect all servers
+  disconnectAll() {
+    for (const client of this.clients.values()) {
+      try { client.disconnect(); } catch {}
+    }
+    this.clients.clear();
+    this._toolIndex.clear();
+  }
+
+  // Rebuild the flat tool index after connections change
+  _rebuildToolIndex() {
+    this._toolIndex.clear();
+    for (const [serverName, client] of this.clients.entries()) {
+      for (const tool of client.tools) {
+        // Prefix to avoid name collisions: mcp_<server>_<tool>
+        const wispyName = `mcp_${serverName}_${tool.name}`.replace(/[^a-zA-Z0-9_]/g, "_");
+        this._toolIndex.set(wispyName, {
+          wispyName,
+          serverName,
+          mcpName: tool.name,
+          description: `[MCP:${serverName}] ${tool.description ?? tool.name}`,
+          inputSchema: tool.inputSchema ?? { type: "object", properties: {}, required: [] },
+        });
+      }
+    }
+  }
+
+  // Execute an MCP tool call by its wispy name
+  async callTool(wispyName, args) {
+    const toolInfo = this._toolIndex.get(wispyName);
+    if (!toolInfo) throw new Error(`MCP tool not found: ${wispyName}`);
+
+    const client = this.clients.get(toolInfo.serverName);
+    if (!client?.connected) throw new Error(`MCP server not connected: ${toolInfo.serverName}`);
+
+    return client.callTool(toolInfo.mcpName, args);
+  }
+
+  // Returns tool definitions in Wispy TOOL_DEFINITIONS format
+  getToolDefinitions() {
+    return Array.from(this._toolIndex.values()).map(t => ({
+      name: t.wispyName,
+      description: t.description,
+      parameters: t.inputSchema,
+    }));
+  }
+
+  // Check if a tool name is an MCP tool
+  hasTool(wispyName) {
+    return this._toolIndex.has(wispyName);
+  }
+
+  // Get all tools as a flat array
+  getAllTools() {
+    return Array.from(this._toolIndex.values());
+  }
+
+  // Get connection status for all known servers
+  getStatus() {
+    return Array.from(this.clients.entries()).map(([name, client]) => ({
+      name,
+      connected: client.connected,
+      initialized: client.initialized,
+      toolCount: client.tools.length,
+      tools: client.tools.map(t => t.name),
+      serverInfo: client.serverInfo,
+    }));
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Default MCP config writer (call once at first run)
+// ---------------------------------------------------------------------------
+
+export async function ensureDefaultMcpConfig(configPath) {
+  try {
+    await readFile(configPath, "utf8");
+    // Already exists — don't overwrite
+  } catch {
+    const defaultConfig = {
+      mcpServers: {
+        // Example: filesystem server (disabled by default)
+        filesystem: {
+          command: "npx",
+          args: ["-y", "@modelcontextprotocol/server-filesystem", os.homedir()],
+          disabled: true,
+          description: "MCP filesystem server — access files via MCP protocol",
+        },
+        // Example: fetch server (disabled by default)
+        fetch: {
+          command: "npx",
+          args: ["-y", "@modelcontextprotocol/server-fetch"],
+          disabled: true,
+          description: "MCP fetch server — HTTP fetch via MCP protocol",
+        },
+      },
+    };
+    await mkdir(path.dirname(configPath), { recursive: true });
+    await writeFile(configPath, JSON.stringify(defaultConfig, null, 2) + "\n", "utf8");
+  }
+}