wispy-cli 0.6.1 → 0.7.0

package/core/tools.mjs

@@ -0,0 +1,526 @@
+/**
+ * core/tools.mjs — Tool registry for Wispy
+ *
+ * Class ToolRegistry:
+ *   - registerBuiltin() — read_file, write_file, run_command, list_directory, git, web_search, etc.
+ *   - registerMCP(mcpManager) — merge MCP tools
+ *   - getDefinitions() → tool definitions array
+ *   - execute(name, args) → result
+ *   - hasTool(name) → boolean
+ */
+
+import os from "node:os";
+import path from "node:path";
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+
+// Default server port for optional sandboxed server
+const DEFAULT_SERVER_PORT = process.env.AWOS_PORT ?? "8090";
+
+export class ToolRegistry {
+  constructor() {
+    this._definitions = new Map(); // name → definition
+    this._mcpManager = null;
+  }
+
+  /**
+   * Register all built-in tools.
+   */
+  registerBuiltin() {
+    const builtins = [
+      {
+        name: "read_file",
+        description: "Read the contents of a file at the given path",
+        parameters: {
+          type: "object",
+          properties: { path: { type: "string", description: "File path to read" } },
+          required: ["path"],
+        },
+      },
+      {
+        name: "write_file",
+        description: "Write content to a file, creating it if it doesn't exist",
+        parameters: {
+          type: "object",
+          properties: {
+            path: { type: "string", description: "File path to write" },
+            content: { type: "string", description: "Content to write" },
+          },
+          required: ["path", "content"],
+        },
+      },
+      {
+        name: "run_command",
+        description: "Execute a shell command and return stdout/stderr",
+        parameters: {
+          type: "object",
+          properties: { command: { type: "string", description: "Shell command to execute" } },
+          required: ["command"],
+        },
+      },
+      {
+        name: "list_directory",
+        description: "List files and directories at the given path",
+        parameters: {
+          type: "object",
+          properties: { path: { type: "string", description: "Directory path (default: current dir)" } },
+          required: [],
+        },
+      },
+      {
+        name: "web_search",
+        description: "Search the web and return results",
+        parameters: {
+          type: "object",
+          properties: { query: { type: "string", description: "Search query" } },
+          required: ["query"],
+        },
+      },
+      {
+        name: "file_edit",
+        description: "Edit a file by replacing specific text. More precise than write_file — use this for targeted changes.",
+        parameters: {
+          type: "object",
+          properties: {
+            path: { type: "string", description: "File path" },
+            old_text: { type: "string", description: "Exact text to find and replace" },
+            new_text: { type: "string", description: "Replacement text" },
+          },
+          required: ["path", "old_text", "new_text"],
+        },
+      },
+      {
+        name: "file_search",
+        description: "Search for text patterns in files recursively (like grep).",
+        parameters: {
+          type: "object",
+          properties: {
+            pattern: { type: "string", description: "Text or regex pattern to search for" },
+            path: { type: "string", description: "Directory to search in (default: current dir)" },
+            file_glob: { type: "string", description: "File glob filter (e.g., '*.ts', '*.py')" },
+          },
+          required: ["pattern"],
+        },
+      },
+      {
+        name: "git",
+        description: "Run git operations: status, diff, log, branch, add, commit, stash, checkout.",
+        parameters: {
+          type: "object",
+          properties: { command: { type: "string", description: "Git subcommand and args" } },
+          required: ["command"],
+        },
+      },
+      {
+        name: "web_fetch",
+        description: "Fetch content from a URL and return it as text/markdown.",
+        parameters: {
+          type: "object",
+          properties: { url: { type: "string", description: "URL to fetch" } },
+          required: ["url"],
+        },
+      },
+      {
+        name: "keychain",
+        description: "Manage macOS Keychain secrets.",
+        parameters: {
+          type: "object",
+          properties: {
+            action: { type: "string", enum: ["get", "set", "delete", "list"] },
+            service: { type: "string" },
+            account: { type: "string" },
+            value: { type: "string" },
+          },
+          required: ["action", "service"],
+        },
+      },
+      {
+        name: "clipboard",
+        description: "Copy text to clipboard or read current clipboard contents.",
+        parameters: {
+          type: "object",
+          properties: {
+            action: { type: "string", enum: ["copy", "paste"] },
+            text: { type: "string" },
+          },
+          required: ["action"],
+        },
+      },
+      {
+        name: "spawn_agent",
+        description: "Spawn a sub-agent for a well-scoped task.",
+        parameters: {
+          type: "object",
+          properties: {
+            task: { type: "string" },
+            role: { type: "string", enum: ["explorer", "planner", "worker", "reviewer"] },
+            model_tier: { type: "string", enum: ["cheap", "mid", "expensive"] },
+            fork_context: { type: "boolean" },
+          },
+          required: ["task", "role"],
+        },
+      },
+      {
+        name: "list_agents",
+        description: "List all running/completed sub-agents and their status",
+        parameters: { type: "object", properties: {}, required: [] },
+      },
+      {
+        name: "get_agent_result",
+        description: "Get the result from a completed sub-agent",
+        parameters: {
+          type: "object",
+          properties: { agent_id: { type: "string" } },
+          required: ["agent_id"],
+        },
+      },
+      {
+        name: "update_plan",
+        description: "Create or update a step-by-step plan for the current task.",
+        parameters: {
+          type: "object",
+          properties: {
+            explanation: { type: "string" },
+            steps: { type: "array", items: { type: "object", properties: { step: { type: "string" }, status: { type: "string" } } } },
+          },
+          required: ["steps"],
+        },
+      },
+      {
+        name: "pipeline",
+        description: "Run a sequential pipeline of agent roles.",
+        parameters: {
+          type: "object",
+          properties: {
+            task: { type: "string" },
+            stages: { type: "array", items: { type: "string", enum: ["explorer", "planner", "worker", "reviewer"] } },
+          },
+          required: ["task", "stages"],
+        },
+      },
+      {
+        name: "spawn_async_agent",
+        description: "Spawn a sub-agent that runs in the background.",
+        parameters: {
+          type: "object",
+          properties: {
+            task: { type: "string" },
+            role: { type: "string", enum: ["explorer", "planner", "worker", "reviewer"] },
+          },
+          required: ["task", "role"],
+        },
+      },
+      {
+        name: "ralph_loop",
+        description: "Persistence mode — keep retrying a task until it's verified complete.",
+        parameters: {
+          type: "object",
+          properties: {
+            task: { type: "string" },
+            success_criteria: { type: "string" },
+          },
+          required: ["task"],
+        },
+      },
+    ];
+
+    for (const def of builtins) {
+      this._definitions.set(def.name, def);
+    }
+  }
+
+  /**
+   * Register MCP tools from an MCPManager instance.
+   */
+  registerMCP(mcpManager) {
+    this._mcpManager = mcpManager;
+  }
+
+  /**
+   * Get all tool definitions (builtin + MCP).
+   */
+  getDefinitions() {
+    const defs = Array.from(this._definitions.values());
+    if (this._mcpManager) {
+      defs.push(...this._mcpManager.getToolDefinitions());
+    }
+    return defs;
+  }
+
+  hasTool(name) {
+    if (this._definitions.has(name)) return true;
+    if (this._mcpManager?.hasTool(name)) return true;
+    return false;
+  }
+
+  /**
+   * Execute a tool by name with args.
+   */
+  async execute(name, args) {
+    // Try server-based execution first for file ops
+    const serverResult = await this._executeViaServer(name, args);
+    if (serverResult) return serverResult;
+
+    // MCP tools
+    if (this._mcpManager?.hasTool(name)) {
+      try {
+        const result = await this._mcpManager.callTool(name, args);
+        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}` };
+      }
+    }
+
+    // Built-in tools
+    return this._executeBuiltin(name, args);
+  }
+
+  async _executeViaServer(name, args) {
+    try {
+      const serverUrl = `http://127.0.0.1:${DEFAULT_SERVER_PORT}`;
+      if (name === "read_file") {
+        const resp = await fetch(`${serverUrl}/api/node-filesystem-actions`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ subAction: "read_file", path: args.path }),
+          signal: AbortSignal.timeout(10_000),
+        });
+        const data = await resp.json();
+        if (data.success) return { success: true, content: data.data?.slice(0, 10_000) ?? "" };
+        return null;
+      }
+      if (name === "write_file") {
+        const resp = await fetch(`${serverUrl}/api/node-filesystem-actions`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ subAction: "write_file", path: args.path, content: args.content }),
+          signal: AbortSignal.timeout(10_000),
+        });
+        const data = await resp.json();
+        if (data.success) return { success: true, message: `Written to ${args.path} (via server)` };
+        return null;
+      }
+      if (name === "list_directory") {
+        const resp = await fetch(`${serverUrl}/api/node-filesystem-actions`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ subAction: "list_dir", path: args.path || "." }),
+          signal: AbortSignal.timeout(10_000),
+        });
+        const data = await resp.json();
+        if (data.success && data.entries) {
+          const listing = data.entries.map(e => `${e.isDir ? "📁" : "📄"} ${e.name}`).join("\n");
+          return { success: true, listing };
+        }
+        return null;
+      }
+    } catch {
+      return null;
+    }
+    return null;
+  }
+
+  async _executeBuiltin(name, args) {
+    const { execFile } = await import("node:child_process");
+    const { promisify } = await import("node:util");
+    const execAsync = promisify(execFile);
+
+    try {
+      switch (name) {
+        case "read_file": {
+          const filePath = args.path.replace(/^~/, os.homedir());
+          const content = await readFile(filePath, "utf8");
+          const truncated = content.length > 10_000
+            ? content.slice(0, 10_000) + `\n\n... (truncated, ${content.length} chars total)`
+            : content;
+          return { success: true, content: truncated };
+        }
+
+        case "write_file": {
+          const filePath = args.path.replace(/^~/, os.homedir());
+          const dir = path.dirname(filePath);
+          await mkdir(dir, { recursive: true });
+          await writeFile(filePath, args.content, "utf8");
+          return { success: true, message: `Written ${args.content.length} chars to ${filePath}` };
+        }
+
+        case "run_command": {
+          if (/security\s+find-generic-password.*-w/i.test(args.command)) {
+            return { success: false, error: "Use the 'keychain' tool instead of run_command for secrets." };
+          }
+          const { stdout, stderr } = await execAsync("/bin/bash", ["-c", args.command], {
+            timeout: 30_000,
+            maxBuffer: 1024 * 1024,
+            cwd: process.cwd(),
+          });
+          const result = (stdout + (stderr ? `\nSTDERR: ${stderr}` : "")).trim();
+          const truncated = result.length > 5_000 ? result.slice(0, 5_000) + "\n... (truncated)" : result;
+          return { success: true, output: truncated };
+        }
+
+        case "list_directory": {
+          const { readdir } = await import("node:fs/promises");
+          const targetPath = (args.path || ".").replace(/^~/, os.homedir());
+          const entries = await readdir(targetPath, { withFileTypes: true });
+          const list = entries.map(e => `${e.isDirectory() ? "📁" : "📄"} ${e.name}`).join("\n");
+          return { success: true, listing: list };
+        }
+
+        case "web_search": {
+          const encoded = encodeURIComponent(args.query);
+          try {
+            const { stdout: html } = await execAsync("/usr/bin/curl", [
+              "-sL", "--max-time", "10",
+              "-H", "User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7)",
+              `https://lite.duckduckgo.com/lite/?q=${encoded}`,
+            ], { timeout: 15_000 });
+
+            const snippets = [];
+            const linkRegex = /<a[^>]*class="result-link"[^>]*>(.*?)<\/a>/gs;
+            const snippetRegex = /<td class="result-snippet">(.*?)<\/td>/gs;
+
+            const links = [];
+            let m;
+            while ((m = linkRegex.exec(html)) !== null) links.push(m[1].replace(/<[^>]+>/g, "").trim());
+            const snips = [];
+            while ((m = snippetRegex.exec(html)) !== null) snips.push(m[1].replace(/<[^>]+>/g, "").trim());
+
+            for (let i = 0; i < Math.min(links.length, 5); i++) {
+              const snippet = snips[i] ? `${links[i]}\n${snips[i]}` : links[i];
+              if (snippet) snippets.push(snippet);
+            }
+            if (snippets.length > 0) return { success: true, results: snippets.join("\n\n") };
+          } catch { /* fallback */ }
+          return { success: true, results: `Search for "${args.query}" — try using run_command with curl` };
+        }
+
+        case "file_edit": {
+          const filePath = args.path.replace(/^~/, os.homedir());
+          const content = await readFile(filePath, "utf8");
+          if (!content.includes(args.old_text)) {
+            return { success: false, error: `Text not found in ${filePath}` };
+          }
+          const newContent = content.replace(args.old_text, args.new_text);
+          await writeFile(filePath, newContent, "utf8");
+          return { success: true, message: `Edited ${filePath}` };
+        }
+
+        case "file_search": {
+          const searchPath = (args.path || ".").replace(/^~/, os.homedir());
+          const glob = args.file_glob ? `--include="${args.file_glob}"` : "";
+          try {
+            const { stdout } = await execAsync("/bin/bash", ["-c",
+              `grep -rn ${glob} "${args.pattern}" "${searchPath}" 2>/dev/null | head -30`
+            ], { timeout: 10_000 });
+            return { success: true, matches: stdout.trim().split("\n").filter(Boolean).length, results: stdout.trim().slice(0, 5000) };
+          } catch {
+            return { success: true, matches: 0, results: "No matches found." };
+          }
+        }
+
+        case "git": {
+          try {
+            const { stdout, stderr } = await execAsync("/bin/bash", ["-c", `git ${args.command}`], {
+              timeout: 15_000, cwd: process.cwd(),
+            });
+            return { success: true, output: (stdout + (stderr ? `\n${stderr}` : "")).trim().slice(0, 5000) };
+          } catch (err) {
+            return { success: false, error: err.stderr?.trim() || err.message };
+          }
+        }
+
+        case "web_fetch": {
+          const resp = await fetch(args.url, {
+            headers: { "User-Agent": "Wispy/0.7" },
+            signal: AbortSignal.timeout(15_000),
+          });
+          const contentType = resp.headers.get("content-type") ?? "";
+          const text = await resp.text();
+          const cleaned = contentType.includes("html")
+            ? text.replace(/<script[\s\S]*?<\/script>/gi, "")
+                  .replace(/<style[\s\S]*?<\/style>/gi, "")
+                  .replace(/<[^>]+>/g, " ")
+                  .replace(/\s+/g, " ").trim()
+            : text;
+          return { success: true, content: cleaned.slice(0, 10_000), contentType, status: resp.status };
+        }
+
+        case "keychain": {
+          const account = args.account ?? "wispy";
+          if (process.platform !== "darwin") return { success: false, error: "Keychain is only supported on macOS" };
+
+          if (args.action === "get") {
+            try {
+              const { stdout } = await execAsync("security", ["find-generic-password", "-s", args.service, "-a", account, "-w"], { timeout: 5000 });
+              const val = stdout.trim();
+              const masked = val.length > 8 ? `${val.slice(0, 4)}${"*".repeat(Math.min(val.length - 8, 20))}${val.slice(-4)}` : "****";
+              return { success: true, service: args.service, account, value_masked: masked, length: val.length };
+            } catch {
+              return { success: false, error: `No keychain entry for service="${args.service}"` };
+            }
+          }
+          if (args.action === "set") {
+            if (!args.value) return { success: false, error: "value is required for set action" };
+            await execAsync("security", ["delete-generic-password", "-s", args.service, "-a", account]).catch(() => {});
+            await execAsync("security", ["add-generic-password", "-s", args.service, "-a", account, "-w", args.value], { timeout: 5000 });
+            return { success: true, message: `Stored secret for service="${args.service}"` };
+          }
+          if (args.action === "delete") {
+            try {
+              await execAsync("security", ["delete-generic-password", "-s", args.service, "-a", account], { timeout: 5000 });
+              return { success: true, message: `Deleted keychain entry for service="${args.service}"` };
+            } catch {
+              return { success: false, error: `No entry found for service="${args.service}"` };
+            }
+          }
+          if (args.action === "list") {
+            try {
+              const { stdout } = await execAsync("/bin/bash", ["-c",
+                `security dump-keychain 2>/dev/null | grep -A 4 '"svce"' | grep -E "svce|acct" | head -20`
+              ], { timeout: 5000 });
+              return { success: true, entries: stdout.trim() || "No entries found" };
+            } catch {
+              return { success: true, entries: "No entries found" };
+            }
+          }
+          return { success: false, error: "action must be get, set, delete, or list" };
+        }
+
+        case "clipboard": {
+          if (args.action === "copy") {
+            const { exec: execCb } = await import("node:child_process");
+            const execP = promisify(execCb);
+            const copyCmd = process.platform === "darwin" ? "pbcopy" : "xclip -selection clipboard";
+            await execP(`echo "${args.text.replace(/"/g, '\\"')}" | ${copyCmd}`);
+            return { success: true, message: `Copied ${args.text.length} chars to clipboard` };
+          }
+          if (args.action === "paste") {
+            const pasteCmd = process.platform === "darwin" ? "pbpaste" : "xclip -selection clipboard -o";
+            const { stdout } = await execAsync("/bin/bash", ["-c", pasteCmd], { timeout: 3000 });
+            return { success: true, content: stdout.slice(0, 5000) };
+          }
+          return { success: false, error: "action must be 'copy' or 'paste'" };
+        }
+
+        // Agent tools — these are handled by the engine level
+        case "spawn_agent":
+        case "list_agents":
+        case "get_agent_result":
+        case "update_plan":
+        case "pipeline":
+        case "spawn_async_agent":
+        case "ralph_loop":
+          return { success: false, error: `Tool "${name}" requires engine context. Call via WispyEngine.processMessage().` };
+
+        default:
+          return { success: false, error: `Unknown tool: ${name}. Available built-in tools: read_file, write_file, file_edit, file_search, run_command, list_directory, git, web_search, web_fetch, keychain, clipboard` };
+      }
+    } catch (err) {
+      return { success: false, error: err.message };
+    }
+  }
+}