@agentforge/tools 0.6.3 → 0.7.0

package/dist/index.js

@@ -235,26 +235,18 @@ var extractImages = toolBuilder().name("extract-images").description("Extract al
 }).build();
 var urlValidator = toolBuilder().name("url-validator").description("Validate and parse URLs. Returns detailed information about the URL structure including protocol, hostname, path, query parameters, and hash.").category(ToolCategory.WEB).tags(["url", "validator", "parse", "validate"]).schema(z.object({
   url: z.string().describe("The URL to validate and parse")
-})).implement(async (input) => {
-  try {
-    const parsed = new URL(input.url);
-    return {
-      valid: true,
-      url: parsed.href,
-      protocol: parsed.protocol,
-      hostname: parsed.hostname,
-      port: parsed.port,
-      pathname: parsed.pathname,
-      search: parsed.search,
-      hash: parsed.hash,
-      origin: parsed.origin
-    };
-  } catch (error) {
-    return {
-      valid: false,
-      error: error instanceof Error ? error.message : "Invalid URL"
-    };
-  }
+})).implementSafe(async (input) => {
+  const parsed = new URL(input.url);
+  return {
+    url: parsed.href,
+    protocol: parsed.protocol,
+    hostname: parsed.hostname,
+    port: parsed.port,
+    pathname: parsed.pathname,
+    search: parsed.search,
+    hash: parsed.hash,
+    origin: parsed.origin
+  };
 }).build();
 var urlBuilder = toolBuilder().name("url-builder").description("Build a URL from components (protocol, hostname, path, query parameters, hash).").category(ToolCategory.WEB).tags(["url", "builder", "construct"]).schema(z.object({
   protocol: z.string().default("https").describe("Protocol (http, https, etc.)"),
@@ -667,89 +659,55 @@ var webSearch = toolBuilder().name("web-search").description(
 var jsonParser = toolBuilder().name("json-parser").description("Parse JSON string into an object. Validates JSON syntax and returns parsed data or error details.").category(ToolCategory.UTILITY).tags(["json", "parse", "data"]).schema(z.object({
   json: z.string().describe("JSON string to parse"),
   strict: z.boolean().default(true).describe("Use strict JSON parsing (no trailing commas, etc.)")
-})).implement(async (input) => {
-  try {
-    const parsed = JSON.parse(input.json);
-    return {
-      success: true,
-      data: parsed,
-      type: Array.isArray(parsed) ? "array" : typeof parsed
-    };
-  } catch (error) {
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : "Failed to parse JSON"
-    };
-  }
+})).implementSafe(async (input) => {
+  const parsed = JSON.parse(input.json);
+  return {
+    data: parsed,
+    type: Array.isArray(parsed) ? "array" : typeof parsed
+  };
 }).build();
 var jsonStringify = toolBuilder().name("json-stringify").description("Convert an object to a JSON string with optional formatting (pretty print).").category(ToolCategory.UTILITY).tags(["json", "stringify", "format", "data"]).schema(z.object({
   data: z.any().describe("Data to convert to JSON string"),
   pretty: z.boolean().default(false).describe("Format with indentation for readability"),
   indent: z.number().default(2).describe("Number of spaces for indentation (when pretty is true)")
-})).implement(async (input) => {
-  try {
-    const json = input.pretty ? JSON.stringify(input.data, null, input.indent) : JSON.stringify(input.data);
-    return {
-      success: true,
-      json,
-      length: json.length
-    };
-  } catch (error) {
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : "Failed to stringify data"
-    };
-  }
+})).implementSafe(async (input) => {
+  const json = input.pretty ? JSON.stringify(input.data, null, input.indent) : JSON.stringify(input.data);
+  return {
+    json,
+    length: json.length
+  };
 }).build();
 var jsonQuery = toolBuilder().name("json-query").description('Query JSON data using dot notation path (e.g., "user.address.city"). Supports array indexing.').category(ToolCategory.UTILITY).tags(["json", "query", "path", "data"]).schema(z.object({
   data: z.any().describe("JSON data to query"),
   path: z.string().describe('Dot notation path to query (e.g., "user.name" or "items[0].id")')
-})).implement(async (input) => {
-  try {
-    const parts = input.path.split(".");
-    let current = input.data;
-    for (const part of parts) {
-      const arrayMatch = part.match(/^(\w+)\[(\d+)\]$/);
-      if (arrayMatch) {
-        const [, key, index] = arrayMatch;
-        current = current[key][parseInt(index, 10)];
-      } else {
-        current = current[part];
-      }
-      if (current === void 0) {
-        return {
-          success: false,
-          error: `Path not found: ${input.path}`
-        };
-      }
+})).implementSafe(async (input) => {
+  const parts = input.path.split(".");
+  let current = input.data;
+  for (const part of parts) {
+    const arrayMatch = part.match(/^(\w+)\[(\d+)\]$/);
+    if (arrayMatch) {
+      const [, key, index] = arrayMatch;
+      current = current[key][parseInt(index, 10)];
+    } else {
+      current = current[part];
+    }
+    if (current === void 0) {
+      throw new Error(`Path not found: ${input.path}`);
     }
-    return {
-      success: true,
-      value: current,
-      type: Array.isArray(current) ? "array" : typeof current
-    };
-  } catch (error) {
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : "Failed to query JSON"
-    };
   }
+  return {
+    value: current,
+    type: Array.isArray(current) ? "array" : typeof current
+  };
 }).build();
 var jsonValidator = toolBuilder().name("json-validator").description("Validate JSON string syntax without parsing. Returns whether the JSON is valid and any error details.").category(ToolCategory.UTILITY).tags(["json", "validate", "check", "data"]).schema(z.object({
   json: z.string().describe("JSON string to validate")
-})).implement(async (input) => {
-  try {
-    JSON.parse(input.json);
-    return {
-      valid: true,
-      message: "Valid JSON"
-    };
-  } catch (error) {
-    return {
-      valid: false,
-      error: error instanceof Error ? error.message : "Invalid JSON"
-    };
-  }
+})).implementSafe(async (input) => {
+  JSON.parse(input.json);
+  return {
+    valid: true,
+    message: "Valid JSON"
+  };
 }).build();
 var jsonMerge = toolBuilder().name("json-merge").description("Merge two or more JSON objects. Later objects override earlier ones for conflicting keys.").category(ToolCategory.UTILITY).tags(["json", "merge", "combine", "data"]).schema(z.object({
   objects: z.array(z.any().describe("Object to merge")).describe("Array of objects to merge"),
@@ -1095,90 +1053,54 @@ var objectOmit = toolBuilder().name("object-omit").description("Create a new obj
 var fileReader = toolBuilder().name("file-reader").description("Read the contents of a file from the file system. Supports text and binary files with various encodings.").category(ToolCategory.FILE_SYSTEM).tags(["file", "read", "io", "filesystem"]).schema(z.object({
   path: z.string().describe("Path to the file to read"),
   encoding: z.enum(["utf8", "utf-8", "ascii", "base64", "hex", "binary"]).default("utf8").describe("File encoding")
-})).implement(async (input) => {
-  try {
-    const content = await promises.readFile(input.path, input.encoding);
-    const stats = await promises.stat(input.path);
-    return {
-      success: true,
-      content,
-      size: stats.size,
-      path: input.path,
-      encoding: input.encoding
-    };
-  } catch (error) {
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : "Failed to read file",
-      path: input.path
-    };
-  }
+})).implementSafe(async (input) => {
+  const content = await promises.readFile(input.path, input.encoding);
+  const stats = await promises.stat(input.path);
+  return {
+    content,
+    size: stats.size,
+    path: input.path,
+    encoding: input.encoding
+  };
 }).build();
 var fileWriter = toolBuilder().name("file-writer").description("Write content to a file. Creates the file if it doesn't exist, or overwrites it if it does.").category(ToolCategory.FILE_SYSTEM).tags(["file", "write", "io", "filesystem"]).schema(z.object({
   path: z.string().describe("Path to the file to write"),
   content: z.string().describe("Content to write to the file"),
   encoding: z.enum(["utf8", "utf-8", "ascii", "base64", "hex"]).default("utf8").describe("File encoding"),
   createDirs: z.boolean().default(false).describe("Create parent directories if they don't exist")
-})).implement(async (input) => {
-  try {
-    if (input.createDirs) {
-      const dir = path3.dirname(input.path);
-      await promises.mkdir(dir, { recursive: true });
-    }
-    await promises.writeFile(input.path, input.content, input.encoding);
-    const stats = await promises.stat(input.path);
-    return {
-      success: true,
-      path: input.path,
-      size: stats.size,
-      encoding: input.encoding
-    };
-  } catch (error) {
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : "Failed to write file",
-      path: input.path
-    };
+})).implementSafe(async (input) => {
+  if (input.createDirs) {
+    const dir = path3.dirname(input.path);
+    await promises.mkdir(dir, { recursive: true });
   }
+  await promises.writeFile(input.path, input.content, input.encoding);
+  const stats = await promises.stat(input.path);
+  return {
+    path: input.path,
+    size: stats.size,
+    encoding: input.encoding
+  };
 }).build();
 var fileAppend = toolBuilder().name("file-append").description("Append content to the end of a file. Creates the file if it doesn't exist.").category(ToolCategory.FILE_SYSTEM).tags(["file", "append", "io", "filesystem"]).schema(z.object({
   path: z.string().describe("Path to the file to append to"),
   content: z.string().describe("Content to append to the file"),
   encoding: z.enum(["utf8", "utf-8", "ascii"]).default("utf8").describe("File encoding")
-})).implement(async (input) => {
-  try {
-    await promises.appendFile(input.path, input.content, input.encoding);
-    const stats = await promises.stat(input.path);
-    return {
-      success: true,
-      path: input.path,
-      size: stats.size
-    };
-  } catch (error) {
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : "Failed to append to file",
-      path: input.path
-    };
-  }
+})).implementSafe(async (input) => {
+  await promises.appendFile(input.path, input.content, input.encoding);
+  const stats = await promises.stat(input.path);
+  return {
+    path: input.path,
+    size: stats.size
+  };
 }).build();
 var fileDelete = toolBuilder().name("file-delete").description("Delete a file from the file system. Returns an error if the file doesn't exist.").category(ToolCategory.FILE_SYSTEM).tags(["file", "delete", "remove", "filesystem"]).schema(z.object({
   path: z.string().describe("Path to the file to delete")
-})).implement(async (input) => {
-  try {
-    await promises.unlink(input.path);
-    return {
-      success: true,
-      path: input.path,
-      message: "File deleted successfully"
-    };
-  } catch (error) {
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : "Failed to delete file",
-      path: input.path
-    };
-  }
+})).implementSafe(async (input) => {
+  await promises.unlink(input.path);
+  return {
+    path: input.path,
+    message: "File deleted successfully"
+  };
 }).build();
 var fileExists = toolBuilder().name("file-exists").description("Check if a file or directory exists at the specified path.").category(ToolCategory.FILE_SYSTEM).tags(["file", "exists", "check", "filesystem"]).schema(z.object({
   path: z.string().describe("Path to check")
@@ -1206,137 +1128,101 @@ var directoryList = toolBuilder().name("directory-list").description("List all f
   recursive: z.boolean().default(false).describe("List files recursively in subdirectories"),
   includeDetails: z.boolean().default(false).describe("Include file size, type, and modification date"),
   extension: z.string().optional().describe('Optional file extension filter (e.g., ".txt", ".js")')
-})).implement(async (input) => {
-  try {
-    const listFiles = async (dir, recursive) => {
-      const entries = await promises.readdir(dir, { withFileTypes: true });
-      const files2 = [];
-      for (const entry of entries) {
-        const fullPath = path3.join(dir, entry.name);
-        const relativePath = path3.relative(input.path, fullPath);
-        if (input.extension && !entry.name.endsWith(input.extension)) {
-          if (!entry.isDirectory() || !recursive) {
-            continue;
-          }
-        }
-        if (input.includeDetails) {
-          const stats = await promises.stat(fullPath);
-          files2.push({
-            name: entry.name,
-            path: relativePath,
-            fullPath,
-            isFile: entry.isFile(),
-            isDirectory: entry.isDirectory(),
-            size: stats.size,
-            modified: stats.mtime.toISOString()
-          });
-        } else {
-          files2.push({
-            name: entry.name,
-            path: relativePath,
-            isFile: entry.isFile(),
-            isDirectory: entry.isDirectory()
-          });
-        }
-        if (recursive && entry.isDirectory()) {
-          const subFiles = await listFiles(fullPath, true);
-          files2.push(...subFiles);
+})).implementSafe(async (input) => {
+  const listFiles = async (dir, recursive) => {
+    const entries = await promises.readdir(dir, { withFileTypes: true });
+    const files2 = [];
+    for (const entry of entries) {
+      const fullPath = path3.join(dir, entry.name);
+      const relativePath = path3.relative(input.path, fullPath);
+      if (input.extension && !entry.name.endsWith(input.extension)) {
+        if (!entry.isDirectory() || !recursive) {
+          continue;
         }
       }
-      return files2;
-    };
-    const files = await listFiles(input.path, input.recursive ?? false);
-    return {
-      success: true,
-      path: input.path,
-      files,
-      count: files.length
-    };
-  } catch (error) {
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : "Failed to list directory",
-      path: input.path
-    };
-  }
+      if (input.includeDetails) {
+        const stats = await promises.stat(fullPath);
+        files2.push({
+          name: entry.name,
+          path: relativePath,
+          fullPath,
+          isFile: entry.isFile(),
+          isDirectory: entry.isDirectory(),
+          size: stats.size,
+          modified: stats.mtime.toISOString()
+        });
+      } else {
+        files2.push({
+          name: entry.name,
+          path: relativePath,
+          isFile: entry.isFile(),
+          isDirectory: entry.isDirectory()
+        });
+      }
+      if (recursive && entry.isDirectory()) {
+        const subFiles = await listFiles(fullPath, true);
+        files2.push(...subFiles);
+      }
+    }
+    return files2;
+  };
+  const files = await listFiles(input.path, input.recursive ?? false);
+  return {
+    path: input.path,
+    files,
+    count: files.length
+  };
 }).build();
 var directoryCreate = toolBuilder().name("directory-create").description("Create a new directory. Can optionally create parent directories if they don't exist.").category(ToolCategory.FILE_SYSTEM).tags(["directory", "create", "mkdir", "filesystem"]).schema(z.object({
   path: z.string().describe("Path to the directory to create"),
   recursive: z.boolean().default(true).describe("Create parent directories if they don't exist")
-})).implement(async (input) => {
-  try {
-    await promises.mkdir(input.path, { recursive: input.recursive });
-    return {
-      success: true,
-      path: input.path,
-      message: "Directory created successfully"
-    };
-  } catch (error) {
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : "Failed to create directory",
-      path: input.path
-    };
-  }
+})).implementSafe(async (input) => {
+  await promises.mkdir(input.path, { recursive: input.recursive });
+  return {
+    path: input.path,
+    message: "Directory created successfully"
+  };
 }).build();
 var directoryDelete = toolBuilder().name("directory-delete").description("Delete a directory. Can optionally delete non-empty directories recursively.").category(ToolCategory.FILE_SYSTEM).tags(["directory", "delete", "remove", "filesystem"]).schema(z.object({
   path: z.string().describe("Path to the directory to delete"),
   recursive: z.boolean().default(false).describe("Delete directory and all its contents")
-})).implement(async (input) => {
-  try {
-    await promises.rm(input.path, { recursive: input.recursive, force: false });
-    return {
-      success: true,
-      path: input.path,
-      message: "Directory deleted successfully"
-    };
-  } catch (error) {
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : "Failed to delete directory",
-      path: input.path
-    };
-  }
+})).implementSafe(async (input) => {
+  await promises.rm(input.path, { recursive: input.recursive, force: false });
+  return {
+    path: input.path,
+    message: "Directory deleted successfully"
+  };
 }).build();
 var fileSearch = toolBuilder().name("file-search").description("Search for files by name pattern in a directory. Supports wildcards and recursive search.").category(ToolCategory.FILE_SYSTEM).tags(["file", "search", "find", "filesystem"]).schema(z.object({
   directory: z.string().describe("Directory to search in"),
   pattern: z.string().describe("File name pattern to search for (supports * wildcard)"),
   recursive: z.boolean().default(true).describe("Search in subdirectories"),
   caseSensitive: z.boolean().default(false).describe("Case-sensitive pattern matching")
-})).implement(async (input) => {
-  try {
-    const searchFiles = async (dir) => {
-      const entries = await promises.readdir(dir, { withFileTypes: true });
-      const matches2 = [];
-      const regexPattern = input.pattern.replace(/\./g, "\\.").replace(/\*/g, ".*");
-      const regex = new RegExp(`^${regexPattern}$`, input.caseSensitive ? "" : "i");
-      for (const entry of entries) {
-        const fullPath = path3.join(dir, entry.name);
-        if (entry.isFile() && regex.test(entry.name)) {
-          matches2.push(fullPath);
-        }
-        if (input.recursive && entry.isDirectory()) {
-          const subMatches = await searchFiles(fullPath);
-          matches2.push(...subMatches);
-        }
+})).implementSafe(async (input) => {
+  const searchFiles = async (dir) => {
+    const entries = await promises.readdir(dir, { withFileTypes: true });
+    const matches2 = [];
+    const regexPattern = input.pattern.replace(/\./g, "\\.").replace(/\*/g, ".*");
+    const regex = new RegExp(`^${regexPattern}$`, input.caseSensitive ? "" : "i");
+    for (const entry of entries) {
+      const fullPath = path3.join(dir, entry.name);
+      if (entry.isFile() && regex.test(entry.name)) {
+        matches2.push(fullPath);
       }
-      return matches2;
-    };
-    const matches = await searchFiles(input.directory);
-    return {
-      success: true,
-      directory: input.directory,
-      pattern: input.pattern,
-      matches,
-      count: matches.length
-    };
-  } catch (error) {
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : "Failed to search files",
-      directory: input.directory
-    };
-  }
+      if (input.recursive && entry.isDirectory()) {
+        const subMatches = await searchFiles(fullPath);
+        matches2.push(...subMatches);
+      }
+    }
+    return matches2;
+  };
+  const matches = await searchFiles(input.directory);
+  return {
+    directory: input.directory,
+    pattern: input.pattern,
+    matches,
+    count: matches.length
+  };
 }).build();
 var pathJoin = toolBuilder().name("path-join").description("Join multiple path segments into a single path. Handles platform-specific separators.").category(ToolCategory.FILE_SYSTEM).tags(["path", "join", "filesystem"]).schema(z.object({
   segments: z.array(z.string().describe("String value")).describe("Path segments to join")