tools.js

/**
 * MERV Tool System
 *
 * Real, functional tools that MERV can invoke during conversations.
 * Each tool has a name, description, parameter schema, and execute function.
 */

import { execSync, spawn } from "child_process";
import { readFileSync, writeFileSync, existsSync, readdirSync, statSync, mkdirSync, unlinkSync } from "fs";
import { join, dirname } from "path";
import { fileURLToPath } from "url";
import { request as httpRequest } from "http";
import { request as httpsRequest } from "https";

const __dirname = dirname(fileURLToPath(import.meta.url));
const MEMORY_PATH = join(__dirname, "memory.json");
const SCRATCH_DIR = join(__dirname, "scratch");

// Ensure scratch dir exists
if (!existsSync(SCRATCH_DIR)) mkdirSync(SCRATCH_DIR, { recursive: true });

// ─────────────────────────────────────────────
// TOOL DEFINITIONS
// ─────────────────────────────────────────────

export const TOOLS = [
  {
    name: "web_search",
    description: "Search the web for current information. Use when the user asks about current events, facts you're unsure about, or anything requiring up-to-date data.",
    parameters: { query: "The search query string" },
  },
  {
    name: "fetch_url",
    description: "Fetch and read the content of a web page. Use when the user provides a URL or you need to read a specific webpage.",
    parameters: { url: "The URL to fetch" },
  },
  {
    name: "run_code",
    description: "Execute JavaScript or Python code and return the output. Use for calculations, data processing, or when the user asks you to run code.",
    parameters: { language: "js or python", code: "The code to execute" },
  },
  {
    name: "read_file",
    description: "Read a file from the local filesystem. Use when the user asks about a file's contents.",
    parameters: { path: "Absolute path to the file" },
  },
  {
    name: "write_file",
    description: "Write content to a file on the local filesystem. Use when asked to create or save files.",
    parameters: { path: "Absolute path to the file", content: "The content to write" },
  },
  {
    name: "list_directory",
    description: "List files and directories at a given path.",
    parameters: { path: "Absolute path to the directory" },
  },
  {
    name: "run_command",
    description: "Run a shell command and return output. Use for system tasks, git, npm, etc.",
    parameters: { command: "The shell command to execute" },
  },
  {
    name: "memory_save",
    description: "Save a fact or piece of information to persistent memory. Use when the user says to remember something or when you learn important context.",
    parameters: { key: "A short label for this memory", value: "The information to remember" },
  },
  {
    name: "memory_recall",
    description: "Search persistent memory for previously saved information. Use when the user references something discussed before or asks 'do you remember'.",
    parameters: { query: "What to search for in memory" },
  },
  {
    name: "memory_list",
    description: "List all saved memories.",
    parameters: {},
  },
  {
    name: "get_datetime",
    description: "Get the current date, time, and timezone.",
    parameters: {},
  },
  {
    name: "calculator",
    description: "Evaluate a mathematical expression. Use for any math calculations.",
    parameters: { expression: "The math expression to evaluate (e.g. '2 * 3.14 * 5')" },
  },
];

// ─────────────────────────────────────────────
// TOOL EXECUTOR
// ─────────────────────────────────────────────

export async function executeTool(name, params) {
  const start = Date.now();
  let result;

  try {
    switch (name) {
      case "web_search":
        result = await webSearch(params.query);
        break;
      case "fetch_url":
        result = await fetchUrl(params.url);
        break;
      case "run_code":
        result = await runCode(params.language, params.code);
        break;
      case "read_file":
        result = readFile(params.path);
        break;
      case "write_file":
        result = writeFile(params.path, params.content);
        break;
      case "list_directory":
        result = listDirectory(params.path);
        break;
      case "run_command":
        result = runCommand(params.command);
        break;
      case "memory_save":
        result = memorySave(params.key, params.value);
        break;
      case "memory_recall":
        result = memoryRecall(params.query);
        break;
      case "memory_list":
        result = memoryList();
        break;
      case "get_datetime":
        result = getDatetime();
        break;
      case "calculator":
        result = calculator(params.expression);
        break;
      default:
        result = { error: `Unknown tool: ${name}` };
    }
  } catch (err) {
    result = { error: err.message };
  }

  return { tool: name, result, duration_ms: Date.now() - start };
}

// ─────────────────────────────────────────────
// TOOL IMPLEMENTATIONS
// ─────────────────────────────────────────────

async function webSearch(query) {
  if (!query) return { error: "No query provided" };

  // Use DuckDuckGo HTML search (no API key needed)
  const encoded = encodeURIComponent(query);
  const url = `https://html.duckduckgo.com/html/?q=${encoded}`;

  try {
    const html = await httpsFetch(url, {
      "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36",
      Accept: "text/html",
    });

    // Parse results from DDG HTML
    const results = [];
    const resultRegex = /<a[^>]*class="result__a"[^>]*href="([^"]*)"[^>]*>([\s\S]*?)<\/a>/gi;
    const snippetRegex = /<a[^>]*class="result__snippet"[^>]*>([\s\S]*?)<\/a>/gi;

    let match;
    while ((match = resultRegex.exec(html)) !== null && results.length < 8) {
      const title = match[2].replace(/<[^>]*>/g, "").trim();
      let link = match[1];
      // DDG wraps links in a redirect
      const uddg = link.match(/uddg=([^&]*)/);
      if (uddg) link = decodeURIComponent(uddg[1]);
      results.push({ title, url: link, snippet: "" });
    }

    let i = 0;
    while ((match = snippetRegex.exec(html)) !== null && i < results.length) {
      results[i].snippet = match[1].replace(/<[^>]*>/g, "").trim();
      i++;
    }

    if (results.length === 0) {
      // Fallback: try to extract any useful text
      const textContent = html.replace(/<[^>]*>/g, " ").replace(/\s+/g, " ").trim();
      return { query, results: [], raw_excerpt: textContent.slice(0, 2000) };
    }

    return { query, results };
  } catch (err) {
    return { error: `Search failed: ${err.message}`, query };
  }
}

function httpsFetch(url, headers = {}) {
  return new Promise((resolve, reject) => {
    const parsedUrl = new URL(url);
    const options = {
      hostname: parsedUrl.hostname,
      port: parsedUrl.port || 443,
      path: parsedUrl.pathname + parsedUrl.search,
      method: "GET",
      headers: {
        "User-Agent": "MERV/1.0",
        ...headers,
      },
    };

    const reqFn = parsedUrl.protocol === "https:" ? httpsRequest : httpRequest;
    const req = reqFn(options, (res) => {
      // Follow redirects
      if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
        httpsFetch(res.headers.location, headers).then(resolve).catch(reject);
        return;
      }

      let data = "";
      res.on("data", (chunk) => (data += chunk));
      res.on("end", () => resolve(data));
    });
    req.on("error", reject);
    req.setTimeout(15000, () => { req.destroy(); reject(new Error("Request timeout")); });
    req.end();
  });
}

async function fetchUrl(url) {
  if (!url) return { error: "No URL provided" };
  try {
    const html = await httpsFetch(url);
    // Strip HTML tags, keep text
    const text = html
      .replace(/<script[\s\S]*?<\/script>/gi, "")
      .replace(/<style[\s\S]*?<\/style>/gi, "")
      .replace(/<[^>]*>/g, " ")
      .replace(/\s+/g, " ")
      .trim();
    return { url, content: text.slice(0, 8000), length: text.length };
  } catch (err) {
    return { error: `Fetch failed: ${err.message}`, url };
  }
}

async function runCode(language, code) {
  if (!code) return { error: "No code provided" };

  const lang = (language || "js").toLowerCase();
  const timeout = 10000; // 10s max

  try {
    if (lang === "js" || lang === "javascript" || lang === "node") {
      const filePath = join(SCRATCH_DIR, `run_${Date.now()}.js`);
      writeFileSync(filePath, code);
      try {
        const output = execSync(`node "${filePath}"`, {
          timeout,
          maxBuffer: 1024 * 1024,
          cwd: SCRATCH_DIR,
          encoding: "utf-8",
        });
        return { language: "javascript", output: output.trim(), exitCode: 0 };
      } finally {
        try { unlinkSync(filePath); } catch {}
      }
    } else if (lang === "python" || lang === "py") {
      const filePath = join(SCRATCH_DIR, `run_${Date.now()}.py`);
      writeFileSync(filePath, code);
      try {
        const output = execSync(`python3 "${filePath}"`, {
          timeout,
          maxBuffer: 1024 * 1024,
          cwd: SCRATCH_DIR,
          encoding: "utf-8",
        });
        return { language: "python", output: output.trim(), exitCode: 0 };
      } finally {
        try { unlinkSync(filePath); } catch {}
      }
    } else {
      return { error: `Unsupported language: ${lang}. Use 'js' or 'python'.` };
    }
  } catch (err) {
    return {
      language: lang,
      error: err.stderr?.toString()?.trim() || err.message,
      exitCode: err.status || 1,
      output: err.stdout?.toString()?.trim() || "",
    };
  }
}

function readFile(path) {
  if (!path) return { error: "No path provided" };
  try {
    if (!existsSync(path)) return { error: `File not found: ${path}` };
    const stat = statSync(path);
    if (stat.isDirectory()) return { error: `Path is a directory, use list_directory instead: ${path}` };
    if (stat.size > 1024 * 1024) return { error: `File too large (${(stat.size / 1024 / 1024).toFixed(1)} MB). Max 1MB.` };
    const content = readFileSync(path, "utf-8");
    return { path, content, size: stat.size, lines: content.split("\n").length };
  } catch (err) {
    return { error: err.message };
  }
}

function writeFile(path, content) {
  if (!path || content === undefined) return { error: "Missing path or content" };
  try {
    const dir = dirname(path);
    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
    writeFileSync(path, content, "utf-8");
    return { path, written: true, bytes: Buffer.byteLength(content) };
  } catch (err) {
    return { error: err.message };
  }
}

function listDirectory(path) {
  if (!path) return { error: "No path provided" };
  try {
    if (!existsSync(path)) return { error: `Directory not found: ${path}` };
    const entries = readdirSync(path).map((name) => {
      try {
        const s = statSync(join(path, name));
        return { name, type: s.isDirectory() ? "dir" : "file", size: s.size };
      } catch {
        return { name, type: "unknown" };
      }
    });
    return { path, entries: entries.slice(0, 100), total: entries.length };
  } catch (err) {
    return { error: err.message };
  }
}

function runCommand(command) {
  if (!command) return { error: "No command provided" };
  // Block dangerous commands
  const blocked = ["rm -rf /", "mkfs", "dd if=", "> /dev/sd", ":(){ :|:& };:"];
  for (const b of blocked) {
    if (command.includes(b)) return { error: "Blocked: potentially destructive command." };
  }
  try {
    const output = execSync(command, {
      timeout: 15000,
      maxBuffer: 1024 * 1024,
      encoding: "utf-8",
      shell: "/bin/zsh",
    });
    return { command, output: output.trim(), exitCode: 0 };
  } catch (err) {
    return {
      command,
      error: err.stderr?.toString()?.trim() || err.message,
      output: err.stdout?.toString()?.trim() || "",
      exitCode: err.status || 1,
    };
  }
}

// ─── Memory ───
function loadMemory() {
  try {
    if (existsSync(MEMORY_PATH)) return JSON.parse(readFileSync(MEMORY_PATH, "utf-8"));
  } catch {}
  return {};
}

function saveMemory(mem) {
  writeFileSync(MEMORY_PATH, JSON.stringify(mem, null, 2));
}

function memorySave(key, value) {
  if (!key || !value) return { error: "Missing key or value" };
  const mem = loadMemory();
  mem[key] = { value, saved: new Date().toISOString() };
  saveMemory(mem);
  return { saved: true, key, totalMemories: Object.keys(mem).length };
}

function memoryRecall(query) {
  if (!query) return { error: "No query provided" };
  const mem = loadMemory();
  const q = query.toLowerCase();
  const matches = Object.entries(mem)
    .filter(([k, v]) => k.toLowerCase().includes(q) || v.value.toLowerCase().includes(q))
    .map(([k, v]) => ({ key: k, value: v.value, saved: v.saved }));
  return { query, matches, totalMemories: Object.keys(mem).length };
}

function memoryList() {
  const mem = loadMemory();
  return {
    memories: Object.entries(mem).map(([k, v]) => ({ key: k, value: v.value, saved: v.saved })),
    total: Object.keys(mem).length,
  };
}

function getDatetime() {
  const now = new Date();
  return {
    iso: now.toISOString(),
    local: now.toLocaleString(),
    date: now.toLocaleDateString(),
    time: now.toLocaleTimeString(),
    timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
    unix: Math.floor(now.getTime() / 1000),
  };
}

function calculator(expression) {
  if (!expression) return { error: "No expression provided" };
  // Safe math eval — only allow numbers, operators, parens, math functions
  const safe = expression.replace(/[^0-9+\-*/().,%^ sincotalogqrtbexpMPI\s]/g, "");
  try {
    // Replace common math functions
    const prepared = safe
      .replace(/\bsqrt\b/g, "Math.sqrt")
      .replace(/\bsin\b/g, "Math.sin")
      .replace(/\bcos\b/g, "Math.cos")
      .replace(/\btan\b/g, "Math.tan")
      .replace(/\blog\b/g, "Math.log10")
      .replace(/\bln\b/g, "Math.log")
      .replace(/\babs\b/g, "Math.abs")
      .replace(/\bexp\b/g, "Math.exp")
      .replace(/\bPI\b/g, "Math.PI")
      .replace(/\^/g, "**");

    // eslint-disable-next-line no-eval
    const result = Function(`"use strict"; return (${prepared})`)();
    return { expression, result, type: typeof result };
  } catch (err) {
    return { expression, error: err.message };
  }
}

// ─────────────────────────────────────────────
// TOOL PROMPT BUILDER
// ─────────────────────────────────────────────

export function buildToolPrompt() {
  return `You have access to the following tools. To use a tool, output a JSON block with this exact format on its own line:

[TOOL_CALL]
{"tool": "tool_name", "params": {"param1": "value1"}}
[/TOOL_CALL]

You may call multiple tools by using multiple [TOOL_CALL] blocks. After the tool results are returned, synthesize them into your final response.

IMPORTANT: Only use tools when genuinely needed. For general conversation, knowledge questions you can answer, or creative tasks, respond directly without tools.

Available tools:

${TOOLS.map((t) => `- **${t.name}**: ${t.description}\n  Parameters: ${JSON.stringify(t.parameters)}`).join("\n\n")}

When you use a tool, you will receive the results in a [TOOL_RESULT] block and should incorporate them into your response.`;
}

// ─────────────────────────────────────────────
// PARSE TOOL CALLS FROM MODEL OUTPUT
// ─────────────────────────────────────────────

export function parseToolCalls(text) {
  const calls = [];
  const regex = /\[TOOL_CALL\]\s*\n?([\s\S]*?)\n?\[\/TOOL_CALL\]/g;
  let match;
  while ((match = regex.exec(text)) !== null) {
    try {
      const parsed = JSON.parse(match[1].trim());
      if (parsed.tool) calls.push(parsed);
    } catch {}
  }
  return calls;
}

/**
 * Get the text content that isn't part of a tool call
 */
export function getTextWithoutToolCalls(text) {
  return text.replace(/\[TOOL_CALL\][\s\S]*?\[\/TOOL_CALL\]/g, "").trim();
}