wispy-cli 0.3.1 → 0.4.0

package/lib/wispy-repl.mjs

@@ -15,6 +15,8 @@ import os from "node:os";
 import path from "node:path";
 import { createInterface } from "node:readline";
 import { appendFile, mkdir, readFile, writeFile } from "node:fs/promises";
+import { fileURLToPath as _fileURLToPath } from "node:url";
+import { MCPManager, ensureDefaultMcpConfig } from "./mcp-client.mjs";
 
 // ---------------------------------------------------------------------------
 // Config
@@ -22,6 +24,10 @@ import { appendFile, mkdir, readFile, writeFile } from "node:fs/promises";
 
 const WISPY_DIR = path.join(os.homedir(), ".wispy");
 const MEMORY_DIR = path.join(WISPY_DIR, "memory");
+const MCP_CONFIG_PATH = path.join(WISPY_DIR, "mcp.json");
+
+// Global MCP manager — initialized at startup
+const mcpManager = new MCPManager(MCP_CONFIG_PATH);
 
 // Workstream-aware conversation storage
 // wispy -w "project-name" → separate conversation per workstream
@@ -619,6 +625,11 @@ function optimizeContext(messages, maxTokens = 30_000) {
 // Tool definitions (Gemini function calling format)
 // ---------------------------------------------------------------------------
 
+// Returns merged static + dynamically registered MCP tool definitions
+function getAllToolDefinitions() {
+  return [...TOOL_DEFINITIONS, ...mcpManager.getToolDefinitions()];
+}
+
 const TOOL_DEFINITIONS = [
   {
     name: "read_file",
@@ -1464,8 +1475,36 @@ Be concise. Your output feeds into the next stage.`;
         return { success: true, iterations: MAX_ITERATIONS, result: lastResult, verified: false, message: "Max iterations reached" };
       }
 
-      default:
-        return { success: false, error: `Unknown tool: ${name}` };
+      default: {
+        // Check MCP tools first
+        if (mcpManager.hasTool(name)) {
+          try {
+            const result = await mcpManager.callTool(name, args);
+            // MCP tools/call returns { content: [{type, text}], isError? }
+            if (result?.isError) {
+              const errText = result.content?.map(c => c.text ?? "").join("") ?? "MCP tool error";
+              return { success: false, error: errText };
+            }
+            const output = result?.content?.map(c => c.text ?? c.data ?? JSON.stringify(c)).join("\n") ?? JSON.stringify(result);
+            return { success: true, output };
+          } catch (err) {
+            return { success: false, error: `MCP tool error: ${err.message}` };
+          }
+        }
+
+        // Unknown tool — try to execute as a skill via run_command
+        // This handles cases where the AI hallucinates tools from skill descriptions
+        const skills = await loadSkills();
+        const matchedSkill = skills.find(s => s.name.toLowerCase() === name.toLowerCase());
+        if (matchedSkill) {
+          return {
+            success: false,
+            error: `"${name}" is a skill, not a tool. Use run_command to execute commands from the ${name} skill guide. Example from the skill: look for curl/bash commands in the skill description.`,
+            skill_hint: matchedSkill.body.slice(0, 500),
+          };
+        }
+        return { success: false, error: `Unknown tool: ${name}. Available: read_file, write_file, file_edit, file_search, run_command, list_directory, git, web_search, web_fetch, keychain, clipboard, spawn_agent, spawn_async_agent, pipeline, ralph_loop, update_plan, list_agents, get_agent_result, and MCP tools (see /mcp list)` };
+      }
     }
   } catch (err) {
     return { success: false, error: err.message };
@@ -1493,6 +1532,69 @@ async function loadWorkMd() {
   return null;
 }
 
+// ---------------------------------------------------------------------------
+// Skill loader — loads SKILL.md files from multiple sources
+// Compatible with OpenClaw and Claude Code skill formats
+// ---------------------------------------------------------------------------
+
+async function loadSkills() {
+  const skillDirs = [
+    // OpenClaw built-in skills
+    "/opt/homebrew/lib/node_modules/openclaw/skills",
+    // OpenClaw user skills
+    path.join(os.homedir(), ".openclaw", "workspace", "skills"),
+    // Wispy skills
+    path.join(WISPY_DIR, "skills"),
+    // Project-local skills
+    path.resolve(".wispy", "skills"),
+    // Claude Code skills (if installed)
+    path.join(os.homedir(), ".claude", "skills"),
+  ];
+
+  const skills = [];
+  const { readdir: rd, stat: st } = await import("node:fs/promises");
+
+  for (const dir of skillDirs) {
+    try {
+      const entries = await rd(dir);
+      for (const entry of entries) {
+        const skillMdPath = path.join(dir, entry, "SKILL.md");
+        try {
+          const content = await readFile(skillMdPath, "utf8");
+          // Parse frontmatter
+          const fmMatch = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+          let name = entry;
+          let description = "";
+          let body = content;
+
+          if (fmMatch) {
+            const fm = fmMatch[1];
+            body = fmMatch[2];
+            const nameMatch = fm.match(/name:\s*["']?(.+?)["']?\s*$/m);
+            const descMatch = fm.match(/description:\s*["'](.+?)["']\s*$/m);
+            if (nameMatch) name = nameMatch[1].trim();
+            if (descMatch) description = descMatch[1].trim();
+          }
+
+          skills.push({ name, description, body: body.trim(), path: skillMdPath, source: dir });
+        } catch { /* no SKILL.md */ }
+      }
+    } catch { /* dir doesn't exist */ }
+  }
+
+  return skills;
+}
+
+function matchSkills(prompt, skills) {
+  const lower = prompt.toLowerCase();
+  return skills.filter(skill => {
+    const nameMatch = lower.includes(skill.name.toLowerCase());
+    const descWords = skill.description.toLowerCase().split(/\s+/);
+    const descMatch = descWords.some(w => w.length > 4 && lower.includes(w));
+    return nameMatch || descMatch;
+  });
+}
+
 async function buildSystemPrompt(messages = []) {
   // Detect user's language from last message for system prompt hint
   const lastUserMsg = messages?.find ? [...messages].reverse().find(m => m.role === "user")?.content ?? "" : "";
@@ -1524,7 +1626,7 @@ async function buildSystemPrompt(messages = []) {
     "  - NEVER reply in Korean when the user wrote in English.",
     "",
     "## Tools",
-    "You have 18 tools: read_file, write_file, file_edit, file_search, run_command, list_directory, git, web_search, web_fetch, keychain, clipboard, spawn_agent, spawn_async_agent, pipeline, ralph_loop, update_plan, list_agents, get_agent_result.",
+    `You have ${18 + mcpManager.getAllTools().length} tools: read_file, write_file, file_edit, file_search, run_command, list_directory, git, web_search, web_fetch, keychain, clipboard, spawn_agent, spawn_async_agent, pipeline, ralph_loop, update_plan, list_agents, get_agent_result${mcpManager.getAllTools().length > 0 ? ", and MCP tools: " + mcpManager.getAllTools().map(t => t.wispyName).join(", ") : ""}.`,
     "- file_edit: for targeted text replacement (prefer over write_file for edits)",
     "- file_search: grep across codebase",
     "- git: any git command",
@@ -1558,6 +1660,25 @@ async function buildSystemPrompt(messages = []) {
     parts.push("");
   }
 
+  // Load and inject matching skills
+  const allSkills = await loadSkills();
+  if (allSkills.length > 0 && lastUserMsg) {
+    const matched = matchSkills(lastUserMsg, allSkills);
+    if (matched.length > 0) {
+      parts.push("## Active Skills (instructions — use run_command/web_fetch to execute)");
+    parts.push("Skills are NOT tools — they are guides. Use run_command to execute the commands described in them.");
+      for (const skill of matched.slice(0, 3)) { // Max 3 skills per turn
+        parts.push(`### ${skill.name}`);
+        parts.push(skill.body.slice(0, 5000));
+        parts.push("");
+      }
+    }
+    // Always list available skills
+    parts.push(`## Available Skills (${allSkills.length} installed)`);
+    parts.push(allSkills.map(s => `- ${s.name}: ${s.description.slice(0, 60)}`).join("\n"));
+    parts.push("");
+  }
+
   return parts.join("\n");
 }
 
@@ -1617,7 +1738,7 @@ async function chatGeminiWithTools(messages, onChunk) {
   sessionTokens.input += estimateTokens(systemInstruction + inputText);
 
   const geminiTools = [{
-    functionDeclarations: TOOL_DEFINITIONS.map(t => ({
+    functionDeclarations: getAllToolDefinitions().map(t => ({
       name: t.name,
       description: t.description,
       parameters: t.parameters,
@@ -1707,7 +1828,7 @@ async function chatOpenAIWithTools(messages, onChunk) {
     return { role: m.role === "assistant" ? "assistant" : m.role, content: m.content };
   });
 
-  const openaiTools = TOOL_DEFINITIONS.map(t => ({
+  const openaiTools = getAllToolDefinitions().map(t => ({
     type: "function",
     function: { name: t.name, description: t.description, parameters: t.parameters },
   }));
@@ -1785,7 +1906,7 @@ async function chatAnthropicWithTools(messages, onChunk) {
   const inputText = anthropicMessages.map(m => typeof m.content === "string" ? m.content : JSON.stringify(m.content)).join("");
   sessionTokens.input += estimateTokens(systemPrompt + inputText);
 
-  const anthropicTools = TOOL_DEFINITIONS.map(t => ({
+  const anthropicTools = getAllToolDefinitions().map(t => ({
     name: t.name,
     description: t.description,
     input_schema: t.parameters,
@@ -2131,6 +2252,30 @@ ${bold("Wispy Commands:")}
     return true;
   }
 
+  if (cmd === "/skills") {
+    const skills = await loadSkills();
+    if (skills.length === 0) {
+      console.log(dim("No skills installed."));
+      console.log(dim("Add skills to ~/.wispy/skills/ or install OpenClaw skills."));
+    } else {
+      console.log(bold(`\n🧩 Skills (${skills.length} installed):\n`));
+      const bySource = {};
+      for (const s of skills) {
+        const src = s.source.includes("openclaw") ? "OpenClaw" : s.source.includes(".wispy") ? "Wispy" : s.source.includes(".claude") ? "Claude" : "Project";
+        if (!bySource[src]) bySource[src] = [];
+        bySource[src].push(s);
+      }
+      for (const [src, sks] of Object.entries(bySource)) {
+        console.log(`  ${bold(src)} (${sks.length}):`);
+        for (const s of sks) {
+          console.log(`    ${green(s.name.padEnd(20))} ${dim(s.description.slice(0, 50))}`);
+        }
+        console.log("");
+      }
+    }
+    return true;
+  }
+
   if (cmd === "/sessions" || cmd === "/ls") {
     const wsList = await listWorkstreams();
     if (wsList.length === 0) {
@@ -2203,6 +2348,119 @@ ${bold("Wispy Commands:")}
     process.exit(0);
   }
 
+  // ---------------------------------------------------------------------------
+  // /mcp — MCP server management
+  // ---------------------------------------------------------------------------
+  if (cmd === "/mcp") {
+    const sub = parts[1] ?? "list";
+
+    if (sub === "list") {
+      const status = mcpManager.getStatus();
+      const allTools = mcpManager.getAllTools();
+      if (status.length === 0) {
+        console.log(dim("No MCP servers connected."));
+        console.log(dim(`Config: ${MCP_CONFIG_PATH}`));
+        console.log(dim("Use /mcp connect <name> to connect a server."));
+      } else {
+        console.log(bold(`\n🔌 MCP Servers (${status.length}):\n`));
+        for (const s of status) {
+          const icon = s.connected ? green("●") : red("○");
+          const toolList = s.tools.length > 0
+            ? dim(` [${s.tools.slice(0, 5).join(", ")}${s.tools.length > 5 ? "..." : ""}]`)
+            : "";
+          console.log(`  ${icon} ${bold(s.name.padEnd(18))} ${s.toolCount} tools${toolList}`);
+          if (s.serverInfo?.name) console.log(dim(`      server: ${s.serverInfo.name} v${s.serverInfo.version ?? "?"}`));
+        }
+      }
+      if (allTools.length > 0) {
+        console.log(bold(`\n🧰 MCP Tools (${allTools.length} total):\n`));
+        for (const t of allTools) {
+          console.log(`  ${cyan(t.wispyName.padEnd(30))} ${dim(t.description.slice(0, 60))}`);
+        }
+      }
+      console.log("");
+      return true;
+    }
+
+    if (sub === "connect") {
+      const serverName = parts[2];
+      if (!serverName) {
+        console.log(yellow("Usage: /mcp connect <server-name>"));
+        return true;
+      }
+      const config = await mcpManager.loadConfig();
+      const serverConfig = config.mcpServers?.[serverName];
+      if (!serverConfig) {
+        console.log(red(`Server "${serverName}" not found in ${MCP_CONFIG_PATH}`));
+        console.log(dim(`Available: ${Object.keys(config.mcpServers ?? {}).join(", ") || "none"}`));
+        return true;
+      }
+      process.stdout.write(dim(`  Connecting to "${serverName}"...`));
+      try {
+        const client = await mcpManager.connect(serverName, serverConfig);
+        console.log(green(` ✓ connected (${client.tools.length} tools)`));
+        if (client.tools.length > 0) {
+          console.log(dim(`  Tools: ${client.tools.map(t => t.name).join(", ")}`));
+        }
+      } catch (err) {
+        console.log(red(` ✗ failed: ${err.message.slice(0, 120)}`));
+      }
+      return true;
+    }
+
+    if (sub === "disconnect") {
+      const serverName = parts[2];
+      if (!serverName) {
+        console.log(yellow("Usage: /mcp disconnect <server-name>"));
+        return true;
+      }
+      const ok = mcpManager.disconnect(serverName);
+      console.log(ok ? green(`✓ Disconnected "${serverName}"`) : yellow(`"${serverName}" was not connected`));
+      return true;
+    }
+
+    if (sub === "config") {
+      console.log(dim(`Config file: ${MCP_CONFIG_PATH}`));
+      try {
+        const cfg = await mcpManager.loadConfig();
+        const servers = cfg.mcpServers ?? {};
+        console.log(bold(`\nDefined servers (${Object.keys(servers).length}):\n`));
+        for (const [name, s] of Object.entries(servers)) {
+          const status = s.disabled ? dim("disabled") : green("enabled");
+          console.log(`  ${name.padEnd(20)} ${status}`);
+          console.log(dim(`    cmd: ${s.command} ${(s.args ?? []).join(" ")}`));
+        }
+      } catch {
+        console.log(dim("No config found."));
+      }
+      return true;
+    }
+
+    if (sub === "reload") {
+      console.log(dim("Reloading MCP servers..."));
+      mcpManager.disconnectAll();
+      const results = await mcpManager.autoConnect();
+      for (const r of results) {
+        if (r.status === "connected") console.log(green(`  ✓ ${r.name} (${r.tools} tools)`));
+        else if (r.status === "disabled") console.log(dim(`  ○ ${r.name} (disabled)`));
+        else console.log(red(`  ✗ ${r.name}: ${r.error?.slice(0, 80)}`));
+      }
+      return true;
+    }
+
+    // Unknown subcommand
+    console.log(`
+${bold("/mcp commands:")}
+  ${cyan("/mcp list")}                  List connected servers and tools
+  ${cyan("/mcp connect <name>")}        Connect a server from config
+  ${cyan("/mcp disconnect <name>")}     Disconnect a server
+  ${cyan("/mcp config")}               Show mcp.json config
+  ${cyan("/mcp reload")}               Reconnect all servers
+  ${dim(`Config: ${MCP_CONFIG_PATH}`)}
+`);
+    return true;
+  }
+
   return false;
 }
 
@@ -2500,6 +2758,28 @@ if (!API_KEY && PROVIDER !== "ollama") {
   }
 }
 
+// Auto-connect MCP servers from ~/.wispy/mcp.json
+await ensureDefaultMcpConfig(MCP_CONFIG_PATH);
+{
+  const mcpResults = await mcpManager.autoConnect();
+  const connected = mcpResults.filter(r => r.status === "connected");
+  const failed = mcpResults.filter(r => r.status === "failed");
+  if (connected.length > 0) {
+    // Quiet success — only show if verbose
+    // console.log(dim(`🔌 MCP: ${connected.map(r => `${r.name}(${r.tools})`).join(", ")}`));
+  }
+  if (failed.length > 0 && process.env.WISPY_DEBUG) {
+    for (const r of failed) {
+      console.error(dim(`⚠ MCP "${r.name}" failed: ${r.error?.slice(0, 80)}`));
+    }
+  }
+}
+
+// Graceful MCP cleanup on exit
+process.on("exit", () => { try { mcpManager.disconnectAll(); } catch {} });
+process.on("SIGINT", () => { mcpManager.disconnectAll(); process.exit(0); });
+process.on("SIGTERM", () => { mcpManager.disconnectAll(); process.exit(0); });
+
 // Auto-start server before entering REPL or one-shot
 const serverStatus = await startServerIfNeeded();
 if (serverStatus.started) {
@@ -2585,6 +2865,7 @@ ${bold("In-session commands:")}
   /workstreams              List all workstreams
   /overview                 Director view — all workstreams at a glance
   /search <keyword>         Search across all workstreams
+  /skills                   List installed skills (OpenClaw/Claude compatible)
   /sessions                 List all sessions
   /delete <name>            Delete a session
   /export [md|clipboard]    Export conversation