@lupaflow/tools 0.1.1 → 0.1.2

package/dist/index.cjs

@@ -0,0 +1,763 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  BaseTool: () => BaseTool,
+  CalculatorTool: () => CalculatorTool,
+  DeleteFileTool: () => DeleteFileTool,
+  EditFileTool: () => EditFileTool,
+  GlobTool: () => GlobTool,
+  GrepTool: () => GrepTool,
+  HTTPTool: () => HTTPTool,
+  ListDirectoryTool: () => ListDirectoryTool,
+  ReadFileTool: () => ReadFileTool,
+  SearchTool: () => SearchTool,
+  ShellTool: () => ShellTool,
+  WriteFileTool: () => WriteFileTool,
+  toolRegistry: () => toolRegistry
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/registry.ts
+var import_core = require("@lupaflow/core");
+var ToolRegistry = class {
+  tools = /* @__PURE__ */ new Map();
+  register(tool) {
+    this.tools.set(tool.definition.name, tool);
+  }
+  get(name) {
+    const tool = this.tools.get(name);
+    if (!tool) {
+      throw new import_core.ToolError(name, `Tool not found: "${name}"`);
+    }
+    return tool;
+  }
+  has(name) {
+    return this.tools.has(name);
+  }
+  list() {
+    return Array.from(this.tools.values());
+  }
+  remove(name) {
+    this.tools.delete(name);
+  }
+  clear() {
+    this.tools.clear();
+  }
+};
+var toolRegistry = new ToolRegistry();
+
+// src/interface.ts
+var BaseTool = class {
+  toJSON() {
+    return this.definition;
+  }
+};
+
+// src/builtins/calculator.ts
+var CalculatorTool = class extends BaseTool {
+  definition = {
+    name: "calculator",
+    description: "Evaluate mathematical expressions safely",
+    parameters: {
+      expression: {
+        type: "string",
+        description: "Mathematical expression to evaluate (e.g., '2 + 2 * 3')"
+      }
+    },
+    required: ["expression"]
+  };
+  async execute(args) {
+    const { expression } = args;
+    const sanitized = expression.replace(/[^0-9+\-*/.()^% ]/g, "");
+    try {
+      const result = Function(`"use strict"; return (${sanitized})`)();
+      return { result, expression };
+    } catch (err) {
+      return { error: err.message, expression };
+    }
+  }
+};
+
+// src/builtins/http.ts
+var HTTPTool = class extends BaseTool {
+  definition = {
+    name: "http",
+    description: "Make HTTP requests (GET, POST, PUT, DELETE)",
+    parameters: {
+      method: {
+        type: "string",
+        description: "HTTP method: GET, POST, PUT, DELETE"
+      },
+      url: {
+        type: "string",
+        description: "Request URL"
+      },
+      headers: {
+        type: "object",
+        description: "Request headers as key-value object"
+      },
+      body: {
+        type: "string",
+        description: "Request body (stringified JSON for POST/PUT)"
+      }
+    },
+    required: ["method", "url"]
+  };
+  async execute(args) {
+    const { method, url, headers, body } = args;
+    const response = await fetch(url, {
+      method: method.toUpperCase(),
+      headers: { "Content-Type": "application/json", ...headers },
+      body: body || void 0
+    });
+    const text = await response.text();
+    let data = text;
+    try {
+      data = JSON.parse(text);
+    } catch {
+    }
+    return {
+      status: response.status,
+      statusText: response.statusText,
+      headers: Object.fromEntries(response.headers.entries()),
+      data
+    };
+  }
+};
+
+// src/builtins/search.ts
+var SearchTool = class extends BaseTool {
+  definition = {
+    name: "search",
+    description: "Search the web for information",
+    parameters: {
+      query: {
+        type: "string",
+        description: "Search query"
+      },
+      maxResults: {
+        type: "number",
+        description: "Maximum number of results (default: 5)"
+      }
+    },
+    required: ["query"]
+  };
+  async execute(args) {
+    const { query, maxResults } = args;
+    const tavilyKey = process.env.TAVILY_API_KEY;
+    if (tavilyKey) {
+      return this.searchTavily(query, maxResults || 5, tavilyKey);
+    }
+    return this.searchDuckDuckGo(query, maxResults || 5);
+  }
+  async searchTavily(query, maxResults, apiKey) {
+    try {
+      const res = await fetch("https://api.tavily.com/search", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          api_key: apiKey,
+          query,
+          search_depth: "advanced",
+          include_answer: true,
+          max_results: maxResults
+        })
+      });
+      if (!res.ok) {
+        throw new Error(`Tavily API error: ${res.status} ${res.statusText}`);
+      }
+      const data = await res.json();
+      return {
+        query,
+        results: data.results.map((r) => ({
+          title: r.title,
+          url: r.url,
+          snippet: r.content
+        })),
+        answer: data.answer,
+        source: "tavily"
+      };
+    } catch (err) {
+      return { error: err.message, query, source: "tavily" };
+    }
+  }
+  async searchDuckDuckGo(query, maxResults) {
+    try {
+      const url = `https://html.duckduckgo.com/html/?q=${encodeURIComponent(query)}`;
+      const response = await fetch(url);
+      const html = await response.text();
+      const results = [];
+      const linkRegex = /<a[^>]+class="result__a"[^>]*href="([^"]*)"[^>]*>([\s\S]*?)<\/a>/g;
+      const snippetRegex = /<a[^>]+class="result__snippet"[^>]*>([\s\S]*?)<\/a>/g;
+      let count = 0;
+      let linkMatch;
+      while ((linkMatch = linkRegex.exec(html)) !== null && count < maxResults) {
+        const snippetMatch = snippetRegex.exec(html);
+        results.push({
+          link: linkMatch[1],
+          title: linkMatch[2].replace(/<[^>]*>/g, ""),
+          snippet: snippetMatch ? snippetMatch[1].replace(/<[^>]*>/g, "") : ""
+        });
+        count++;
+      }
+      return { query, results, source: "duckduckgo" };
+    } catch (err) {
+      return { error: err.message, query, source: "duckduckgo" };
+    }
+  }
+};
+
+// src/builtins/readFile.ts
+var import_promises = require("fs/promises");
+var import_path = require("path");
+var MAX_FILE_SIZE = 1e4;
+var ReadFileTool = class extends BaseTool {
+  definition = {
+    name: "readFile",
+    description: "Read the contents of a file",
+    parameters: {
+      path: {
+        type: "string",
+        description: "Relative path to the file to read"
+      }
+    },
+    required: ["path"]
+  };
+  async execute(args) {
+    const { path } = args;
+    const cwd = process.cwd();
+    const resolved = (0, import_path.resolve)(cwd, path);
+    const rel = (0, import_path.relative)(cwd, resolved);
+    if (rel.startsWith("..") || (0, import_path.isAbsolute)(rel)) {
+      return { error: "Path is outside the project directory" };
+    }
+    try {
+      const content = await (0, import_promises.readFile)(resolved, "utf-8");
+      if (content.length > MAX_FILE_SIZE) {
+        return {
+          content: content.slice(0, MAX_FILE_SIZE),
+          truncated: true,
+          totalLength: content.length
+        };
+      }
+      return { content };
+    } catch (err) {
+      const msg = err.message?.replace(/^ENOENT:\s*/, "") || String(err);
+      return { error: msg };
+    }
+  }
+};
+
+// src/builtins/writeFile.ts
+var import_promises2 = require("fs/promises");
+var import_path2 = require("path");
+var WriteFileTool = class extends BaseTool {
+  definition = {
+    name: "writeFile",
+    description: "Create a new file or overwrite an existing one",
+    parameters: {
+      path: {
+        type: "string",
+        description: "Relative path to write"
+      },
+      content: {
+        type: "string",
+        description: "File contents"
+      }
+    },
+    required: ["path", "content"]
+  };
+  async execute(args) {
+    const { path, content } = args;
+    const cwd = process.cwd();
+    const resolved = (0, import_path2.resolve)(cwd, path);
+    const rel = (0, import_path2.relative)(cwd, resolved);
+    if (rel.startsWith("..") || (0, import_path2.isAbsolute)(rel)) {
+      return { error: "Path is outside the project directory" };
+    }
+    try {
+      let oldContent = null;
+      try {
+        oldContent = await (0, import_promises2.readFile)(resolved, "utf-8");
+      } catch {
+      }
+      const backupDir = (0, import_path2.resolve)(cwd, ".lupaflow/backups");
+      if (oldContent !== null) {
+        const backupPath = (0, import_path2.resolve)(backupDir, rel);
+        await (0, import_promises2.mkdir)((0, import_path2.dirname)(backupPath), { recursive: true });
+        await (0, import_promises2.writeFile)(backupPath, oldContent, "utf-8");
+      }
+      await (0, import_promises2.mkdir)((0, import_path2.dirname)(resolved), { recursive: true });
+      await (0, import_promises2.writeFile)(resolved, content, "utf-8");
+      const result = {
+        success: true,
+        path: rel
+      };
+      if (oldContent !== null) {
+        result.diff = computeDiff(oldContent, content);
+      }
+      return result;
+    } catch (err) {
+      return { error: err.message };
+    }
+  }
+};
+function computeDiff(oldStr, newStr) {
+  const oldLines = oldStr.split("\n");
+  const newLines = newStr.split("\n");
+  const lines = [];
+  let i = 0, j = 0;
+  while (i < oldLines.length || j < newLines.length) {
+    if (i < oldLines.length && j < newLines.length && oldLines[i] === newLines[j]) {
+      lines.push(` ${oldLines[i]}`);
+      i++;
+      j++;
+    } else {
+      let found = false;
+      for (let k = 1; k <= 3; k++) {
+        if (i + k < oldLines.length && oldLines[i + k] === newLines[j]) {
+          for (let l = 0; l < k; l++) lines.push(`-${oldLines[i + l]}`);
+          i += k;
+          found = true;
+          break;
+        }
+        if (j + k < newLines.length && oldLines[i] === newLines[j + k]) {
+          for (let l = 0; l < k; l++) lines.push(`+${newLines[j + l]}`);
+          j += k;
+          found = true;
+          break;
+        }
+      }
+      if (!found) {
+        if (i < oldLines.length) lines.push(`-${oldLines[i]}`);
+        if (j < newLines.length) lines.push(`+${newLines[j]}`);
+        i++;
+        j++;
+      }
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/builtins/editFile.ts
+var import_promises3 = require("fs/promises");
+var import_path3 = require("path");
+var EditFileTool = class extends BaseTool {
+  definition = {
+    name: "editFile",
+    description: "Replace an exact string match in a file with new content",
+    parameters: {
+      path: {
+        type: "string",
+        description: "Relative path to edit"
+      },
+      oldString: {
+        type: "string",
+        description: "Exact text to replace; must be unique in the file"
+      },
+      newString: {
+        type: "string",
+        description: "Replacement text"
+      }
+    },
+    required: ["path", "oldString", "newString"]
+  };
+  async execute(args) {
+    const { path, oldString, newString } = args;
+    const cwd = process.cwd();
+    const resolved = (0, import_path3.resolve)(cwd, path);
+    const rel = (0, import_path3.relative)(cwd, resolved);
+    if (rel.startsWith("..") || (0, import_path3.isAbsolute)(rel)) {
+      return { error: "Path is outside the project directory" };
+    }
+    try {
+      const content = await (0, import_promises3.readFile)(resolved, "utf-8");
+      const occurrences = content.split(oldString).length - 1;
+      if (occurrences === 0) {
+        return { error: "oldString not found in file" };
+      }
+      if (occurrences > 1) {
+        return { error: `oldString is ambiguous; found ${occurrences} matches` };
+      }
+      const backupDir = (0, import_path3.resolve)(cwd, ".lupaflow/backups");
+      const backupPath = (0, import_path3.resolve)(backupDir, rel);
+      await (0, import_promises3.mkdir)((0, import_path3.dirname)(backupPath), { recursive: true });
+      await (0, import_promises3.writeFile)(backupPath, content, "utf-8");
+      const newContent = content.replace(oldString, newString);
+      await (0, import_promises3.writeFile)(resolved, newContent, "utf-8");
+      return {
+        success: true,
+        path: rel,
+        diff: computeDiff2(content, newContent)
+      };
+    } catch (err) {
+      return { error: err.message };
+    }
+  }
+};
+function computeDiff2(oldStr, newStr) {
+  const oldLines = oldStr.split("\n");
+  const newLines = newStr.split("\n");
+  const lines = [];
+  let i = 0, j = 0;
+  while (i < oldLines.length || j < newLines.length) {
+    if (i < oldLines.length && j < newLines.length && oldLines[i] === newLines[j]) {
+      lines.push(` ${oldLines[i]}`);
+      i++;
+      j++;
+    } else {
+      let found = false;
+      for (let k = 1; k <= 3; k++) {
+        if (i + k < oldLines.length && oldLines[i + k] === newLines[j]) {
+          for (let l = 0; l < k; l++) lines.push(`-${oldLines[i + l]}`);
+          i += k;
+          found = true;
+          break;
+        }
+        if (j + k < newLines.length && oldLines[i] === newLines[j + k]) {
+          for (let l = 0; l < k; l++) lines.push(`+${newLines[j + l]}`);
+          j += k;
+          found = true;
+          break;
+        }
+      }
+      if (!found) {
+        if (i < oldLines.length) lines.push(`-${oldLines[i]}`);
+        if (j < newLines.length) lines.push(`+${newLines[j]}`);
+        i++;
+        j++;
+      }
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/builtins/deleteFile.ts
+var import_promises4 = require("fs/promises");
+var import_path4 = require("path");
+var DeleteFileTool = class extends BaseTool {
+  definition = {
+    name: "deleteFile",
+    description: "Delete a file",
+    parameters: {
+      path: {
+        type: "string",
+        description: "Relative path to the file to delete"
+      }
+    },
+    required: ["path"]
+  };
+  async execute(args) {
+    const { path } = args;
+    const cwd = process.cwd();
+    const resolved = (0, import_path4.resolve)(cwd, path);
+    const rel = (0, import_path4.relative)(cwd, resolved);
+    if (rel.startsWith("..") || (0, import_path4.isAbsolute)(rel)) {
+      return { error: "Path is outside the project directory" };
+    }
+    try {
+      await (0, import_promises4.unlink)(resolved);
+      return { success: true, path: rel };
+    } catch (err) {
+      return { error: err.message };
+    }
+  }
+};
+
+// src/builtins/listDirectory.ts
+var import_promises5 = require("fs/promises");
+var import_path5 = require("path");
+var ListDirectoryTool = class extends BaseTool {
+  definition = {
+    name: "listDirectory",
+    description: "List entries in a directory",
+    parameters: {
+      path: {
+        type: "string",
+        description: "Relative directory path to list"
+      }
+    },
+    required: ["path"]
+  };
+  async execute(args) {
+    const { path } = args;
+    const cwd = process.cwd();
+    const resolved = (0, import_path5.resolve)(cwd, path);
+    const rel = (0, import_path5.relative)(cwd, resolved);
+    if (rel.startsWith("..") || (0, import_path5.isAbsolute)(rel)) {
+      return { error: "Path is outside the project directory" };
+    }
+    try {
+      const entries = await (0, import_promises5.readdir)(resolved);
+      const results = [];
+      for (const entry of entries) {
+        if (entry.startsWith(".") || entry === "node_modules") continue;
+        try {
+          const info = await (0, import_promises5.stat)((0, import_path5.join)(resolved, entry));
+          results.push({
+            name: entry,
+            type: info.isDirectory() ? "directory" : "file"
+          });
+        } catch {
+        }
+      }
+      results.sort(
+        (a, b) => a.type !== b.type ? a.type === "directory" ? -1 : 1 : a.name.localeCompare(b.name)
+      );
+      return { path: rel || ".", entries: results };
+    } catch (err) {
+      return { error: err.message };
+    }
+  }
+};
+
+// src/builtins/glob.ts
+var import_path6 = require("path");
+var MAX_RESULTS = 200;
+var GlobTool = class extends BaseTool {
+  definition = {
+    name: "glob",
+    description: "Find files matching a glob pattern",
+    parameters: {
+      pattern: {
+        type: "string",
+        description: "Glob pattern to match files"
+      },
+      path: {
+        type: "string",
+        description: "Directory to search from (default: .)"
+      }
+    },
+    required: ["pattern"]
+  };
+  async execute(args) {
+    const { pattern, path: dir = "." } = args;
+    const cwd = process.cwd();
+    const resolved = (0, import_path6.resolve)(cwd, dir);
+    const rel = (0, import_path6.relative)(cwd, resolved);
+    if (rel.startsWith("..") || (0, import_path6.isAbsolute)(rel)) {
+      return { error: "Path is outside the project directory" };
+    }
+    try {
+      const glob = new Bun.Glob(pattern);
+      const files = [];
+      let truncated = false;
+      for await (const match of glob.scan({ cwd: resolved, dot: false, onlyFiles: true })) {
+        if (match.includes("node_modules")) continue;
+        if (files.length >= MAX_RESULTS) {
+          truncated = true;
+          break;
+        }
+        files.push((0, import_path6.relative)(cwd, (0, import_path6.resolve)(resolved, match)));
+      }
+      files.sort();
+      const result = { files };
+      if (truncated) result.truncated = true;
+      return result;
+    } catch (err) {
+      return { error: err.message };
+    }
+  }
+};
+
+// src/builtins/grep.ts
+var import_path7 = require("path");
+var MAX_MATCHES = 50;
+var GrepTool = class extends BaseTool {
+  definition = {
+    name: "grep",
+    description: "Search file contents using a regex pattern",
+    parameters: {
+      pattern: {
+        type: "string",
+        description: "Regex pattern to search for"
+      },
+      path: {
+        type: "string",
+        description: "Directory to search from (default: .)"
+      },
+      include: {
+        type: "string",
+        description: "Optional glob for files to include (e.g. *.ts)"
+      }
+    },
+    required: ["pattern"]
+  };
+  async execute(args) {
+    const { pattern, path: dir = ".", include } = args;
+    const cwd = process.cwd();
+    const resolved = (0, import_path7.resolve)(cwd, dir);
+    const rel = (0, import_path7.relative)(cwd, resolved);
+    if (rel.startsWith("..") || (0, import_path7.isAbsolute)(rel)) {
+      return { error: "Path is outside the project directory" };
+    }
+    try {
+      const grepArgs = [
+        "-rn",
+        "--color=never",
+        "--exclude-dir=node_modules",
+        "--exclude-dir=.git",
+        "-E"
+      ];
+      if (include) grepArgs.push(`--include=${include}`);
+      grepArgs.push(pattern, resolved);
+      const proc = Bun.spawn(["grep", ...grepArgs], {
+        cwd,
+        stdout: "pipe",
+        stderr: "pipe"
+      });
+      const [stdout, stderr] = await Promise.all([
+        new Response(proc.stdout).text(),
+        new Response(proc.stderr).text()
+      ]);
+      const exitCode = await proc.exited;
+      if (exitCode !== 0 && exitCode !== 1) {
+        const msg = stderr.trim() || `grep exited with code ${exitCode}`;
+        return { error: msg };
+      }
+      const trimmed = stderr.trim();
+      if (trimmed) {
+        return { error: trimmed };
+      }
+      const lines = stdout.trim().split("\n");
+      if (!lines[0]) {
+        return { matches: [], message: "No matches found" };
+      }
+      const matches = [];
+      let truncated = false;
+      for (const line of lines) {
+        if (matches.length >= MAX_MATCHES) {
+          truncated = true;
+          break;
+        }
+        const match = line.match(/^(.+?):(\d+):(.*)$/);
+        if (match) {
+          matches.push({
+            file: (0, import_path7.relative)(cwd, match[1]),
+            line: Number(match[2]),
+            content: match[3]
+          });
+        }
+      }
+      const result = { matches };
+      if (truncated) {
+        result.truncated = true;
+        result.totalMatches = lines.length;
+      }
+      return result;
+    } catch (err) {
+      return { error: err.message || String(err) };
+    }
+  }
+};
+
+// src/builtins/shell.ts
+var MAX_OUTPUT = 2e4;
+var DEFAULT_TIMEOUT = 3e4;
+var ShellTool = class extends BaseTool {
+  definition = {
+    name: "shell",
+    description: "Execute a shell command",
+    parameters: {
+      command: {
+        type: "string",
+        description: "Shell command to run"
+      },
+      description: {
+        type: "string",
+        description: "Short description of what the command does"
+      },
+      timeout: {
+        type: "number",
+        description: "Timeout in milliseconds (default: 30000)"
+      }
+    },
+    required: ["command"]
+  };
+  async execute(args) {
+    const { command, timeout = DEFAULT_TIMEOUT } = args;
+    try {
+      const isWindows = process.platform === "win32";
+      const shell = isWindows ? "cmd.exe" : "bash";
+      const shellFlag = isWindows ? "/c" : "-c";
+      const env = isWindows ? { ...process.env } : { ...process.env, TERM: "dumb" };
+      const proc = Bun.spawn([shell, shellFlag, command], {
+        cwd: process.cwd(),
+        stdout: "pipe",
+        stderr: "pipe",
+        env
+      });
+      const timer = setTimeout(() => proc.kill(), timeout);
+      const [stdout, stderr] = await Promise.all([
+        new Response(proc.stdout).text(),
+        new Response(proc.stderr).text()
+      ]);
+      const exitCode = await proc.exited;
+      clearTimeout(timer);
+      return {
+        stdout: truncate(stdout, MAX_OUTPUT),
+        stderr: truncate(stderr, MAX_OUTPUT),
+        exitCode
+      };
+    } catch (err) {
+      return {
+        stdout: "",
+        stderr: err.message || String(err),
+        exitCode: 1
+      };
+    }
+  }
+};
+function truncate(value, limit) {
+  return value.length > limit ? `${value.slice(0, limit)}
+... (truncated, ${value.length} total chars)` : value;
+}
+
+// src/index.ts
+toolRegistry.register(new CalculatorTool());
+toolRegistry.register(new HTTPTool());
+toolRegistry.register(new SearchTool());
+toolRegistry.register(new ReadFileTool());
+toolRegistry.register(new WriteFileTool());
+toolRegistry.register(new EditFileTool());
+toolRegistry.register(new DeleteFileTool());
+toolRegistry.register(new ListDirectoryTool());
+toolRegistry.register(new GlobTool());
+toolRegistry.register(new GrepTool());
+toolRegistry.register(new ShellTool());
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BaseTool,
+  CalculatorTool,
+  DeleteFileTool,
+  EditFileTool,
+  GlobTool,
+  GrepTool,
+  HTTPTool,
+  ListDirectoryTool,
+  ReadFileTool,
+  SearchTool,
+  ShellTool,
+  WriteFileTool,
+  toolRegistry
+});
+//# sourceMappingURL=index.cjs.map