@agentforge/tools 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1720 @@
+'use strict';
+
+var core = require('@agentforge/core');
+var zod = require('zod');
+var axios = require('axios');
+var cheerio2 = require('cheerio');
+var sync = require('csv-parse/sync');
+var sync$1 = require('csv-stringify/sync');
+var fastXmlParser = require('fast-xml-parser');
+var fs = require('fs');
+var path3 = require('path');
+var dateFns = require('date-fns');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var axios__default = /*#__PURE__*/_interopDefault(axios);
+var cheerio2__namespace = /*#__PURE__*/_interopNamespace(cheerio2);
+var path3__namespace = /*#__PURE__*/_interopNamespace(path3);
+
+// src/web/http-client.ts
+var HttpMethod = zod.z.enum(["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"]);
+var httpRequestSchema = zod.z.object({
+  url: zod.z.string().url().describe("The URL to make the request to"),
+  method: HttpMethod.default("GET").describe("HTTP method to use"),
+  headers: zod.z.record(zod.z.string()).optional().describe("Optional HTTP headers"),
+  body: zod.z.any().optional().describe("Optional request body (for POST, PUT, PATCH)"),
+  timeout: zod.z.number().default(3e4).describe("Request timeout in milliseconds"),
+  params: zod.z.record(zod.z.string()).optional().describe("Optional URL query parameters")
+});
+var httpClient = core.toolBuilder().name("http-client").description("Make HTTP requests to web APIs and services. Supports GET, POST, PUT, DELETE, PATCH methods with custom headers and body.").category(core.ToolCategory.WEB).tags(["http", "api", "request", "web"]).schema(httpRequestSchema).implement(async (input) => {
+  const config = {
+    method: input.method,
+    url: input.url,
+    headers: input.headers,
+    data: input.body,
+    timeout: input.timeout,
+    params: input.params,
+    validateStatus: () => true
+    // Don't throw on any status code
+  };
+  const response = await axios__default.default(config);
+  return {
+    status: response.status,
+    statusText: response.statusText,
+    headers: response.headers,
+    data: response.data,
+    url: input.url,
+    method: input.method ?? "GET"
+  };
+}).build();
+var httpGet = core.toolBuilder().name("http-get").description("Make a simple HTTP GET request to a URL and return the response data.").category(core.ToolCategory.WEB).tags(["http", "get", "fetch", "web"]).schema(zod.z.object({
+  url: zod.z.string().url().describe("The URL to fetch"),
+  headers: zod.z.record(zod.z.string()).optional().describe("Optional HTTP headers"),
+  params: zod.z.record(zod.z.string()).optional().describe("Optional URL query parameters")
+})).implement(async (input) => {
+  const response = await axios__default.default.get(input.url, {
+    headers: input.headers,
+    params: input.params,
+    timeout: 3e4
+  });
+  return response.data;
+}).build();
+var httpPost = core.toolBuilder().name("http-post").description("Make a simple HTTP POST request with JSON body and return the response data.").category(core.ToolCategory.WEB).tags(["http", "post", "api", "web"]).schema(zod.z.object({
+  url: zod.z.string().url().describe("The URL to post to"),
+  body: zod.z.any().describe("The request body (will be sent as JSON)"),
+  headers: zod.z.record(zod.z.string()).optional().describe("Optional HTTP headers")
+})).implement(async (input) => {
+  const response = await axios__default.default.post(input.url, input.body, {
+    headers: {
+      "Content-Type": "application/json",
+      ...input.headers
+    },
+    timeout: 3e4
+  });
+  return response.data;
+}).build();
+var webScraper = core.toolBuilder().name("web-scraper").description("Scrape and extract data from web pages. Can extract text, HTML, links, images, and use CSS selectors to target specific elements.").category(core.ToolCategory.WEB).tags(["scraper", "web", "html", "extract", "parse"]).schema(zod.z.object({
+  url: zod.z.string().url().describe("The URL of the web page to scrape"),
+  selector: zod.z.string().optional().describe("Optional CSS selector to extract specific elements"),
+  extractText: zod.z.boolean().default(true).describe("Extract text content from the page"),
+  extractHtml: zod.z.boolean().default(false).describe("Extract raw HTML content"),
+  extractLinks: zod.z.boolean().default(false).describe("Extract all links from the page"),
+  extractImages: zod.z.boolean().default(false).describe("Extract all image URLs from the page"),
+  extractMetadata: zod.z.boolean().default(false).describe("Extract meta tags (title, description, etc.)"),
+  timeout: zod.z.number().default(3e4).describe("Request timeout in milliseconds")
+})).implement(async (input) => {
+  const response = await axios__default.default.get(input.url, {
+    timeout: input.timeout,
+    headers: {
+      "User-Agent": "Mozilla/5.0 (compatible; AgentForge/1.0; +https://agentforge.dev)"
+    }
+  });
+  const html = response.data;
+  const $ = cheerio2__namespace.load(html);
+  const result = {
+    url: input.url
+  };
+  const $selected = input.selector ? $(input.selector) : $("body");
+  if (input.extractText) {
+    result.text = $selected.text().trim();
+  }
+  if (input.extractHtml) {
+    result.html = $selected.html() || "";
+  }
+  if (input.extractLinks) {
+    result.links = [];
+    $("a[href]").each((_, el) => {
+      const href = $(el).attr("href");
+      if (href) {
+        try {
+          const absoluteUrl = new URL(href, input.url).href;
+          result.links.push(absoluteUrl);
+        } catch {
+          result.links.push(href);
+        }
+      }
+    });
+  }
+  if (input.extractImages) {
+    result.images = [];
+    $("img[src]").each((_, el) => {
+      const src = $(el).attr("src");
+      if (src) {
+        try {
+          const absoluteUrl = new URL(src, input.url).href;
+          result.images.push(absoluteUrl);
+        } catch {
+          result.images.push(src);
+        }
+      }
+    });
+  }
+  if (input.extractMetadata) {
+    result.metadata = {};
+    const title = $("title").text() || $('meta[property="og:title"]').attr("content");
+    if (title) result.metadata.title = title;
+    const description = $('meta[name="description"]').attr("content") || $('meta[property="og:description"]').attr("content");
+    if (description) result.metadata.description = description;
+    $("meta[name], meta[property]").each((_, el) => {
+      const name = $(el).attr("name") || $(el).attr("property");
+      const content = $(el).attr("content");
+      if (name && content) {
+        result.metadata[name] = content;
+      }
+    });
+  }
+  if (input.selector) {
+    result.selected = $selected.map((_, el) => ({
+      text: $(el).text().trim(),
+      html: $(el).html()
+    })).get();
+  }
+  return result;
+}).build();
+var htmlParser = core.toolBuilder().name("html-parser").description("Parse HTML content and extract data using CSS selectors. Returns text, attributes, and structure of selected elements.").category(core.ToolCategory.WEB).tags(["html", "parser", "css", "selector", "extract"]).schema(zod.z.object({
+  html: zod.z.string().describe("The HTML content to parse"),
+  selector: zod.z.string().describe("CSS selector to find elements"),
+  extractText: zod.z.boolean().default(true).describe("Extract text content from selected elements"),
+  extractHtml: zod.z.boolean().default(false).describe("Extract inner HTML of selected elements"),
+  extractAttributes: zod.z.array(zod.z.string().describe("String value")).optional().describe('List of attributes to extract (e.g., ["href", "src", "class"])')
+})).implement(async (input) => {
+  const $ = cheerio2__namespace.load(input.html);
+  const $selected = $(input.selector);
+  const results = $selected.map((_, el) => {
+    const $el = $(el);
+    const item = {};
+    if (input.extractText) {
+      item.text = $el.text().trim();
+    }
+    if (input.extractHtml) {
+      item.html = $el.html();
+    }
+    if (input.extractAttributes && input.extractAttributes.length > 0) {
+      item.attributes = {};
+      for (const attr of input.extractAttributes) {
+        const value = $el.attr(attr);
+        if (value !== void 0) {
+          item.attributes[attr] = value;
+        }
+      }
+    }
+    return item;
+  }).get();
+  return {
+    count: results.length,
+    results
+  };
+}).build();
+var extractLinks = core.toolBuilder().name("extract-links").description("Extract all links (anchor tags) from HTML content with their text and href attributes.").category(core.ToolCategory.WEB).tags(["html", "links", "extract", "anchor"]).schema(zod.z.object({
+  html: zod.z.string().describe("The HTML content to extract links from"),
+  baseUrl: zod.z.string().url().optional().describe("Optional base URL to resolve relative links")
+})).implement(async (input) => {
+  const $ = cheerio2__namespace.load(input.html);
+  const links = [];
+  $("a[href]").each((_, el) => {
+    const $el = $(el);
+    let href = $el.attr("href") || "";
+    if (input.baseUrl && href) {
+      try {
+        href = new URL(href, input.baseUrl).href;
+      } catch {
+      }
+    }
+    links.push({
+      text: $el.text().trim(),
+      href,
+      title: $el.attr("title")
+    });
+  });
+  return {
+    count: links.length,
+    links
+  };
+}).build();
+var extractImages = core.toolBuilder().name("extract-images").description("Extract all images from HTML content with their src, alt, and other attributes.").category(core.ToolCategory.WEB).tags(["html", "images", "extract", "img"]).schema(zod.z.object({
+  html: zod.z.string().describe("The HTML content to extract images from"),
+  baseUrl: zod.z.string().url().optional().describe("Optional base URL to resolve relative image URLs")
+})).implement(async (input) => {
+  const $ = cheerio2__namespace.load(input.html);
+  const images = [];
+  $("img[src]").each((_, el) => {
+    const $el = $(el);
+    let src = $el.attr("src") || "";
+    if (input.baseUrl && src) {
+      try {
+        src = new URL(src, input.baseUrl).href;
+      } catch {
+      }
+    }
+    images.push({
+      src,
+      alt: $el.attr("alt"),
+      title: $el.attr("title"),
+      width: $el.attr("width"),
+      height: $el.attr("height")
+    });
+  });
+  return {
+    count: images.length,
+    images
+  };
+}).build();
+var urlValidator = core.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(core.ToolCategory.WEB).tags(["url", "validator", "parse", "validate"]).schema(zod.z.object({
+  url: zod.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"
+    };
+  }
+}).build();
+var urlBuilder = core.toolBuilder().name("url-builder").description("Build a URL from components (protocol, hostname, path, query parameters, hash).").category(core.ToolCategory.WEB).tags(["url", "builder", "construct"]).schema(zod.z.object({
+  protocol: zod.z.string().default("https").describe("Protocol (http, https, etc.)"),
+  hostname: zod.z.string().describe("Hostname or domain name"),
+  port: zod.z.string().optional().describe("Optional port number"),
+  pathname: zod.z.string().default("/").describe("URL path"),
+  query: zod.z.record(zod.z.string()).optional().describe("Query parameters as key-value pairs"),
+  hash: zod.z.string().optional().describe("URL hash/fragment")
+})).implement(async (input) => {
+  const url = new URL(`${input.protocol}://${input.hostname}`);
+  if (input.port) {
+    url.port = input.port;
+  }
+  url.pathname = input.pathname ?? "/";
+  if (input.query) {
+    Object.entries(input.query).forEach(([key, value]) => {
+      url.searchParams.append(key, value);
+    });
+  }
+  if (input.hash) {
+    url.hash = input.hash;
+  }
+  return {
+    url: url.href,
+    components: {
+      protocol: url.protocol,
+      hostname: url.hostname,
+      port: url.port,
+      pathname: url.pathname,
+      search: url.search,
+      hash: url.hash,
+      origin: url.origin
+    }
+  };
+}).build();
+var urlQueryParser = core.toolBuilder().name("url-query-parser").description("Parse query parameters from a URL or query string into a key-value object.").category(core.ToolCategory.WEB).tags(["url", "query", "parse", "params"]).schema(zod.z.object({
+  input: zod.z.string().describe('URL or query string to parse (e.g., "?foo=bar&baz=qux" or full URL)')
+})).implement(async (input) => {
+  let searchParams;
+  try {
+    const url = new URL(input.input);
+    searchParams = url.searchParams;
+  } catch {
+    const queryString = input.input.startsWith("?") ? input.input.slice(1) : input.input;
+    searchParams = new URLSearchParams(queryString);
+  }
+  const params = {};
+  searchParams.forEach((value, key) => {
+    if (params[key]) {
+      if (Array.isArray(params[key])) {
+        params[key].push(value);
+      } else {
+        params[key] = [params[key], value];
+      }
+    } else {
+      params[key] = value;
+    }
+  });
+  return {
+    params,
+    count: Object.keys(params).length
+  };
+}).build();
+var jsonParser = core.toolBuilder().name("json-parser").description("Parse JSON string into an object. Validates JSON syntax and returns parsed data or error details.").category(core.ToolCategory.UTILITY).tags(["json", "parse", "data"]).schema(zod.z.object({
+  json: zod.z.string().describe("JSON string to parse"),
+  strict: zod.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"
+    };
+  }
+}).build();
+var jsonStringify = core.toolBuilder().name("json-stringify").description("Convert an object to a JSON string with optional formatting (pretty print).").category(core.ToolCategory.UTILITY).tags(["json", "stringify", "format", "data"]).schema(zod.z.object({
+  data: zod.z.any().describe("Data to convert to JSON string"),
+  pretty: zod.z.boolean().default(false).describe("Format with indentation for readability"),
+  indent: zod.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"
+    };
+  }
+}).build();
+var jsonQuery = core.toolBuilder().name("json-query").description('Query JSON data using dot notation path (e.g., "user.address.city"). Supports array indexing.').category(core.ToolCategory.UTILITY).tags(["json", "query", "path", "data"]).schema(zod.z.object({
+  data: zod.z.any().describe("JSON data to query"),
+  path: zod.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}`
+        };
+      }
+    }
+    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"
+    };
+  }
+}).build();
+var jsonValidator = core.toolBuilder().name("json-validator").description("Validate JSON string syntax without parsing. Returns whether the JSON is valid and any error details.").category(core.ToolCategory.UTILITY).tags(["json", "validate", "check", "data"]).schema(zod.z.object({
+  json: zod.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"
+    };
+  }
+}).build();
+var jsonMerge = core.toolBuilder().name("json-merge").description("Merge two or more JSON objects. Later objects override earlier ones for conflicting keys.").category(core.ToolCategory.UTILITY).tags(["json", "merge", "combine", "data"]).schema(zod.z.object({
+  objects: zod.z.array(zod.z.any().describe("Object to merge")).describe("Array of objects to merge"),
+  deep: zod.z.boolean().default(false).describe("Perform deep merge (nested objects)")
+})).implement(async (input) => {
+  if (input.deep) {
+    const deepMerge = (target, source) => {
+      const output = { ...target };
+      for (const key in source) {
+        if (source[key] && typeof source[key] === "object" && !Array.isArray(source[key])) {
+          output[key] = deepMerge(output[key] || {}, source[key]);
+        } else {
+          output[key] = source[key];
+        }
+      }
+      return output;
+    };
+    return input.objects.reduce((acc, obj) => deepMerge(acc, obj), {});
+  } else {
+    return Object.assign({}, ...input.objects);
+  }
+}).build();
+var csvParser = core.toolBuilder().name("csv-parser").description("Parse CSV string into an array of objects. Supports custom delimiters, headers, and options.").category(core.ToolCategory.UTILITY).tags(["csv", "parse", "data", "table"]).schema(zod.z.object({
+  csv: zod.z.string().describe("CSV string to parse"),
+  delimiter: zod.z.string().default(",").describe("Column delimiter character"),
+  hasHeaders: zod.z.boolean().default(true).describe("First row contains column headers"),
+  skipEmptyLines: zod.z.boolean().default(true).describe("Skip empty lines in the CSV"),
+  trim: zod.z.boolean().default(true).describe("Trim whitespace from values")
+})).implement(async (input) => {
+  try {
+    const records = sync.parse(input.csv, {
+      delimiter: input.delimiter,
+      columns: input.hasHeaders,
+      skip_empty_lines: input.skipEmptyLines,
+      trim: input.trim,
+      relax_column_count: true
+    });
+    return {
+      success: true,
+      data: records,
+      rowCount: records.length,
+      columnCount: records.length > 0 ? Object.keys(records[0]).length : 0
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Failed to parse CSV"
+    };
+  }
+}).build();
+var csvGenerator = core.toolBuilder().name("csv-generator").description("Convert an array of objects to CSV string. Automatically extracts headers from object keys.").category(core.ToolCategory.UTILITY).tags(["csv", "generate", "stringify", "data"]).schema(zod.z.object({
+  data: zod.z.array(zod.z.record(zod.z.any().describe("Column value"))).describe("Array of objects to convert to CSV"),
+  delimiter: zod.z.string().default(",").describe("Column delimiter character"),
+  includeHeaders: zod.z.boolean().default(true).describe("Include header row with column names"),
+  columns: zod.z.array(zod.z.string().describe("String value")).optional().describe("Optional list of columns to include (in order)")
+})).implement(async (input) => {
+  try {
+    const csv = sync$1.stringify(input.data, {
+      delimiter: input.delimiter,
+      header: input.includeHeaders,
+      columns: input.columns
+    });
+    return {
+      success: true,
+      csv,
+      rowCount: input.data.length
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Failed to generate CSV"
+    };
+  }
+}).build();
+var csvToJson = core.toolBuilder().name("csv-to-json").description("Convert CSV string to JSON array. Each row becomes an object with column headers as keys.").category(core.ToolCategory.UTILITY).tags(["csv", "json", "convert", "data"]).schema(zod.z.object({
+  csv: zod.z.string().describe("CSV string to convert"),
+  delimiter: zod.z.string().default(",").describe("Column delimiter character"),
+  pretty: zod.z.boolean().default(false).describe("Format JSON with indentation")
+})).implement(async (input) => {
+  try {
+    const records = sync.parse(input.csv, {
+      delimiter: input.delimiter,
+      columns: true,
+      skip_empty_lines: true,
+      trim: true
+    });
+    const json = input.pretty ? JSON.stringify(records, null, 2) : JSON.stringify(records);
+    return {
+      success: true,
+      json,
+      recordCount: records.length
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Failed to convert CSV to JSON"
+    };
+  }
+}).build();
+var jsonToCsv = core.toolBuilder().name("json-to-csv").description("Convert JSON array to CSV string. Each object becomes a row with keys as column headers.").category(core.ToolCategory.UTILITY).tags(["json", "csv", "convert", "data"]).schema(zod.z.object({
+  json: zod.z.string().describe("JSON array string to convert"),
+  delimiter: zod.z.string().default(",").describe("Column delimiter character")
+})).implement(async (input) => {
+  try {
+    const data = JSON.parse(input.json);
+    if (!Array.isArray(data)) {
+      return {
+        success: false,
+        error: "Input must be a JSON array"
+      };
+    }
+    const csv = sync$1.stringify(data, {
+      delimiter: input.delimiter,
+      header: true
+    });
+    return {
+      success: true,
+      csv,
+      rowCount: data.length
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Failed to convert JSON to CSV"
+    };
+  }
+}).build();
+var xmlParser = core.toolBuilder().name("xml-parser").description("Parse XML string into a JavaScript object. Supports attributes, CDATA, and nested elements.").category(core.ToolCategory.UTILITY).tags(["xml", "parse", "data"]).schema(zod.z.object({
+  xml: zod.z.string().describe("XML string to parse"),
+  ignoreAttributes: zod.z.boolean().default(false).describe("Ignore XML attributes"),
+  parseAttributeValue: zod.z.boolean().default(true).describe("Parse attribute values (numbers, booleans)"),
+  trimValues: zod.z.boolean().default(true).describe("Trim whitespace from text values")
+})).implement(async (input) => {
+  try {
+    const parser = new fastXmlParser.XMLParser({
+      ignoreAttributes: input.ignoreAttributes,
+      parseAttributeValue: input.parseAttributeValue,
+      trimValues: input.trimValues,
+      parseTagValue: true
+    });
+    const result = parser.parse(input.xml);
+    return {
+      success: true,
+      data: result
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Failed to parse XML"
+    };
+  }
+}).build();
+var xmlGenerator = core.toolBuilder().name("xml-generator").description("Convert a JavaScript object to XML string. Supports attributes, CDATA, and nested elements.").category(core.ToolCategory.UTILITY).tags(["xml", "generate", "stringify", "data"]).schema(zod.z.object({
+  data: zod.z.any().describe("Object to convert to XML"),
+  rootName: zod.z.string().default("root").describe("Name of the root XML element"),
+  format: zod.z.boolean().default(false).describe("Format XML with indentation"),
+  indentSize: zod.z.number().default(2).describe("Number of spaces for indentation (when format is true)")
+})).implement(async (input) => {
+  try {
+    const indentSize = input.indentSize ?? 2;
+    const rootName = input.rootName ?? "root";
+    const builder = new fastXmlParser.XMLBuilder({
+      format: input.format ?? false,
+      indentBy: " ".repeat(indentSize),
+      ignoreAttributes: false
+    });
+    const dataToConvert = input.data[rootName] ? input.data : { [rootName]: input.data };
+    const xml = builder.build(dataToConvert);
+    return {
+      success: true,
+      xml
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Failed to generate XML"
+    };
+  }
+}).build();
+var xmlToJson = core.toolBuilder().name("xml-to-json").description("Convert XML string to JSON. Preserves structure and can include or exclude attributes.").category(core.ToolCategory.UTILITY).tags(["xml", "json", "convert", "data"]).schema(zod.z.object({
+  xml: zod.z.string().describe("XML string to convert"),
+  ignoreAttributes: zod.z.boolean().default(false).describe("Ignore XML attributes in conversion"),
+  pretty: zod.z.boolean().default(false).describe("Format JSON with indentation")
+})).implement(async (input) => {
+  try {
+    const parser = new fastXmlParser.XMLParser({
+      ignoreAttributes: input.ignoreAttributes,
+      parseAttributeValue: true,
+      trimValues: true
+    });
+    const result = parser.parse(input.xml);
+    const json = input.pretty ? JSON.stringify(result, null, 2) : JSON.stringify(result);
+    return {
+      success: true,
+      json
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Failed to convert XML to JSON"
+    };
+  }
+}).build();
+var jsonToXml = core.toolBuilder().name("json-to-xml").description("Convert JSON string to XML. Each object key becomes an XML element.").category(core.ToolCategory.UTILITY).tags(["json", "xml", "convert", "data"]).schema(zod.z.object({
+  json: zod.z.string().describe("JSON string to convert"),
+  rootName: zod.z.string().default("root").describe("Name of the root XML element"),
+  format: zod.z.boolean().default(false).describe("Format XML with indentation")
+})).implement(async (input) => {
+  try {
+    const data = JSON.parse(input.json);
+    const rootName = input.rootName ?? "root";
+    const builder = new fastXmlParser.XMLBuilder({
+      format: input.format ?? false,
+      indentBy: "  ",
+      ignoreAttributes: false
+    });
+    const dataToConvert = data[rootName] ? data : { [rootName]: data };
+    const xml = builder.build(dataToConvert);
+    return {
+      success: true,
+      xml
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Failed to convert JSON to XML"
+    };
+  }
+}).build();
+var arrayFilter = core.toolBuilder().name("array-filter").description("Filter an array based on a property value. Supports equality, comparison, and contains operations.").category(core.ToolCategory.UTILITY).tags(["array", "filter", "data", "transform"]).schema(zod.z.object({
+  array: zod.z.array(zod.z.any().describe("Array element")).describe("Array to filter"),
+  property: zod.z.string().describe("Property name to filter by (use dot notation for nested properties)"),
+  operator: zod.z.enum(["equals", "not-equals", "greater-than", "less-than", "contains", "starts-with", "ends-with"]).describe("Comparison operator"),
+  value: zod.z.any().describe("Value to compare against")
+})).implement(async (input) => {
+  const getNestedValue = (obj, path4) => {
+    return path4.split(".").reduce((current, key) => current?.[key], obj);
+  };
+  const filtered = input.array.filter((item) => {
+    const itemValue = getNestedValue(item, input.property);
+    switch (input.operator) {
+      case "equals":
+        return itemValue === input.value;
+      case "not-equals":
+        return itemValue !== input.value;
+      case "greater-than":
+        return itemValue > input.value;
+      case "less-than":
+        return itemValue < input.value;
+      case "contains":
+        return String(itemValue).includes(String(input.value));
+      case "starts-with":
+        return String(itemValue).startsWith(String(input.value));
+      case "ends-with":
+        return String(itemValue).endsWith(String(input.value));
+      default:
+        return false;
+    }
+  });
+  return {
+    filtered,
+    originalCount: input.array.length,
+    filteredCount: filtered.length
+  };
+}).build();
+var arrayMap = core.toolBuilder().name("array-map").description("Extract specific properties from each object in an array. Creates a new array with only the selected properties.").category(core.ToolCategory.UTILITY).tags(["array", "map", "data", "transform"]).schema(zod.z.object({
+  array: zod.z.array(zod.z.any().describe("Array element")).describe("Array to map"),
+  properties: zod.z.array(zod.z.string().describe("String value")).describe("List of property names to extract from each object")
+})).implement(async (input) => {
+  const mapped = input.array.map((item) => {
+    const result = {};
+    for (const prop of input.properties) {
+      const value = prop.split(".").reduce((current, key) => current?.[key], item);
+      result[prop] = value;
+    }
+    return result;
+  });
+  return {
+    mapped,
+    count: mapped.length
+  };
+}).build();
+var arraySort = core.toolBuilder().name("array-sort").description("Sort an array by a property value. Supports ascending and descending order.").category(core.ToolCategory.UTILITY).tags(["array", "sort", "data", "transform"]).schema(zod.z.object({
+  array: zod.z.array(zod.z.any().describe("Array element")).describe("Array to sort"),
+  property: zod.z.string().describe("Property name to sort by (use dot notation for nested properties)"),
+  order: zod.z.enum(["asc", "desc"]).default("asc").describe("Sort order: ascending or descending")
+})).implement(async (input) => {
+  const getNestedValue = (obj, path4) => {
+    return path4.split(".").reduce((current, key) => current?.[key], obj);
+  };
+  const sorted = [...input.array].sort((a, b) => {
+    const aValue = getNestedValue(a, input.property);
+    const bValue = getNestedValue(b, input.property);
+    if (aValue < bValue) return input.order === "asc" ? -1 : 1;
+    if (aValue > bValue) return input.order === "asc" ? 1 : -1;
+    return 0;
+  });
+  return {
+    sorted,
+    count: sorted.length
+  };
+}).build();
+var arrayGroupBy = core.toolBuilder().name("array-group-by").description("Group an array of objects by a property value. Returns an object with groups as keys.").category(core.ToolCategory.UTILITY).tags(["array", "group", "data", "transform"]).schema(zod.z.object({
+  array: zod.z.array(zod.z.any().describe("Array element")).describe("Array to group"),
+  property: zod.z.string().describe("Property name to group by")
+})).implement(async (input) => {
+  const groups = {};
+  for (const item of input.array) {
+    const key = String(item[input.property]);
+    if (!groups[key]) {
+      groups[key] = [];
+    }
+    groups[key].push(item);
+  }
+  return {
+    groups,
+    groupCount: Object.keys(groups).length,
+    totalItems: input.array.length
+  };
+}).build();
+var objectPick = core.toolBuilder().name("object-pick").description("Create a new object with only the specified properties from the source object.").category(core.ToolCategory.UTILITY).tags(["object", "pick", "data", "transform"]).schema(zod.z.object({
+  object: zod.z.record(zod.z.any().describe("Property value")).describe("Source object"),
+  properties: zod.z.array(zod.z.string().describe("String value")).describe("List of property names to pick")
+})).implement(async (input) => {
+  const picked = {};
+  for (const prop of input.properties) {
+    if (prop in input.object) {
+      picked[prop] = input.object[prop];
+    }
+  }
+  return picked;
+}).build();
+var objectOmit = core.toolBuilder().name("object-omit").description("Create a new object excluding the specified properties from the source object.").category(core.ToolCategory.UTILITY).tags(["object", "omit", "data", "transform"]).schema(zod.z.object({
+  object: zod.z.record(zod.z.any().describe("Property value")).describe("Source object"),
+  properties: zod.z.array(zod.z.string().describe("String value")).describe("List of property names to omit")
+})).implement(async (input) => {
+  const omitted = { ...input.object };
+  for (const prop of input.properties) {
+    delete omitted[prop];
+  }
+  return omitted;
+}).build();
+var fileReader = core.toolBuilder().name("file-reader").description("Read the contents of a file from the file system. Supports text and binary files with various encodings.").category(core.ToolCategory.FILE_SYSTEM).tags(["file", "read", "io", "filesystem"]).schema(zod.z.object({
+  path: zod.z.string().describe("Path to the file to read"),
+  encoding: zod.z.enum(["utf8", "utf-8", "ascii", "base64", "hex", "binary"]).default("utf8").describe("File encoding")
+})).implement(async (input) => {
+  try {
+    const content = await fs.promises.readFile(input.path, input.encoding);
+    const stats = await fs.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
+    };
+  }
+}).build();
+var fileWriter = core.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(core.ToolCategory.FILE_SYSTEM).tags(["file", "write", "io", "filesystem"]).schema(zod.z.object({
+  path: zod.z.string().describe("Path to the file to write"),
+  content: zod.z.string().describe("Content to write to the file"),
+  encoding: zod.z.enum(["utf8", "utf-8", "ascii", "base64", "hex"]).default("utf8").describe("File encoding"),
+  createDirs: zod.z.boolean().default(false).describe("Create parent directories if they don't exist")
+})).implement(async (input) => {
+  try {
+    if (input.createDirs) {
+      const dir = path3__namespace.dirname(input.path);
+      await fs.promises.mkdir(dir, { recursive: true });
+    }
+    await fs.promises.writeFile(input.path, input.content, input.encoding);
+    const stats = await fs.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
+    };
+  }
+}).build();
+var fileAppend = core.toolBuilder().name("file-append").description("Append content to the end of a file. Creates the file if it doesn't exist.").category(core.ToolCategory.FILE_SYSTEM).tags(["file", "append", "io", "filesystem"]).schema(zod.z.object({
+  path: zod.z.string().describe("Path to the file to append to"),
+  content: zod.z.string().describe("Content to append to the file"),
+  encoding: zod.z.enum(["utf8", "utf-8", "ascii"]).default("utf8").describe("File encoding")
+})).implement(async (input) => {
+  try {
+    await fs.promises.appendFile(input.path, input.content, input.encoding);
+    const stats = await fs.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
+    };
+  }
+}).build();
+var fileDelete = core.toolBuilder().name("file-delete").description("Delete a file from the file system. Returns an error if the file doesn't exist.").category(core.ToolCategory.FILE_SYSTEM).tags(["file", "delete", "remove", "filesystem"]).schema(zod.z.object({
+  path: zod.z.string().describe("Path to the file to delete")
+})).implement(async (input) => {
+  try {
+    await fs.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
+    };
+  }
+}).build();
+var fileExists = core.toolBuilder().name("file-exists").description("Check if a file or directory exists at the specified path.").category(core.ToolCategory.FILE_SYSTEM).tags(["file", "exists", "check", "filesystem"]).schema(zod.z.object({
+  path: zod.z.string().describe("Path to check")
+})).implement(async (input) => {
+  try {
+    await fs.promises.access(input.path);
+    const stats = await fs.promises.stat(input.path);
+    return {
+      exists: true,
+      path: input.path,
+      isFile: stats.isFile(),
+      isDirectory: stats.isDirectory(),
+      size: stats.size,
+      modified: stats.mtime.toISOString()
+    };
+  } catch {
+    return {
+      exists: false,
+      path: input.path
+    };
+  }
+}).build();
+var directoryList = core.toolBuilder().name("directory-list").description("List all files and directories in a directory. Can optionally include file details and filter by extension.").category(core.ToolCategory.FILE_SYSTEM).tags(["directory", "list", "files", "filesystem"]).schema(zod.z.object({
+  path: zod.z.string().describe("Path to the directory to list"),
+  recursive: zod.z.boolean().default(false).describe("List files recursively in subdirectories"),
+  includeDetails: zod.z.boolean().default(false).describe("Include file size, type, and modification date"),
+  extension: zod.z.string().optional().describe('Optional file extension filter (e.g., ".txt", ".js")')
+})).implement(async (input) => {
+  try {
+    const listFiles = async (dir, recursive) => {
+      const entries = await fs.promises.readdir(dir, { withFileTypes: true });
+      const files2 = [];
+      for (const entry of entries) {
+        const fullPath = path3__namespace.join(dir, entry.name);
+        const relativePath = path3__namespace.relative(input.path, fullPath);
+        if (input.extension && !entry.name.endsWith(input.extension)) {
+          if (!entry.isDirectory() || !recursive) {
+            continue;
+          }
+        }
+        if (input.includeDetails) {
+          const stats = await fs.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 {
+      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
+    };
+  }
+}).build();
+var directoryCreate = core.toolBuilder().name("directory-create").description("Create a new directory. Can optionally create parent directories if they don't exist.").category(core.ToolCategory.FILE_SYSTEM).tags(["directory", "create", "mkdir", "filesystem"]).schema(zod.z.object({
+  path: zod.z.string().describe("Path to the directory to create"),
+  recursive: zod.z.boolean().default(true).describe("Create parent directories if they don't exist")
+})).implement(async (input) => {
+  try {
+    await fs.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
+    };
+  }
+}).build();
+var directoryDelete = core.toolBuilder().name("directory-delete").description("Delete a directory. Can optionally delete non-empty directories recursively.").category(core.ToolCategory.FILE_SYSTEM).tags(["directory", "delete", "remove", "filesystem"]).schema(zod.z.object({
+  path: zod.z.string().describe("Path to the directory to delete"),
+  recursive: zod.z.boolean().default(false).describe("Delete directory and all its contents")
+})).implement(async (input) => {
+  try {
+    await fs.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
+    };
+  }
+}).build();
+var fileSearch = core.toolBuilder().name("file-search").description("Search for files by name pattern in a directory. Supports wildcards and recursive search.").category(core.ToolCategory.FILE_SYSTEM).tags(["file", "search", "find", "filesystem"]).schema(zod.z.object({
+  directory: zod.z.string().describe("Directory to search in"),
+  pattern: zod.z.string().describe("File name pattern to search for (supports * wildcard)"),
+  recursive: zod.z.boolean().default(true).describe("Search in subdirectories"),
+  caseSensitive: zod.z.boolean().default(false).describe("Case-sensitive pattern matching")
+})).implement(async (input) => {
+  try {
+    const searchFiles = async (dir) => {
+      const entries = await fs.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__namespace.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);
+        }
+      }
+      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
+    };
+  }
+}).build();
+var pathJoin = core.toolBuilder().name("path-join").description("Join multiple path segments into a single path. Handles platform-specific separators.").category(core.ToolCategory.FILE_SYSTEM).tags(["path", "join", "filesystem"]).schema(zod.z.object({
+  segments: zod.z.array(zod.z.string().describe("String value")).describe("Path segments to join")
+})).implement(async (input) => {
+  const joined = path3__namespace.join(...input.segments);
+  return {
+    path: joined,
+    segments: input.segments
+  };
+}).build();
+var pathResolve = core.toolBuilder().name("path-resolve").description("Resolve a sequence of paths into an absolute path. Resolves relative paths from the current working directory.").category(core.ToolCategory.FILE_SYSTEM).tags(["path", "resolve", "absolute", "filesystem"]).schema(zod.z.object({
+  paths: zod.z.array(zod.z.string().describe("String value")).describe("Paths to resolve")
+})).implement(async (input) => {
+  const resolved = path3__namespace.resolve(...input.paths);
+  return {
+    path: resolved,
+    isAbsolute: path3__namespace.isAbsolute(resolved)
+  };
+}).build();
+var pathParse = core.toolBuilder().name("path-parse").description("Parse a file path into its components (directory, filename, extension, etc.).").category(core.ToolCategory.FILE_SYSTEM).tags(["path", "parse", "filesystem"]).schema(zod.z.object({
+  path: zod.z.string().describe("File path to parse")
+})).implement(async (input) => {
+  const parsed = path3__namespace.parse(input.path);
+  return {
+    root: parsed.root,
+    dir: parsed.dir,
+    base: parsed.base,
+    name: parsed.name,
+    ext: parsed.ext,
+    isAbsolute: path3__namespace.isAbsolute(input.path)
+  };
+}).build();
+var pathBasename = core.toolBuilder().name("path-basename").description("Get the last portion of a path (filename with extension). Optionally remove the extension.").category(core.ToolCategory.FILE_SYSTEM).tags(["path", "basename", "filename", "filesystem"]).schema(zod.z.object({
+  path: zod.z.string().describe("File path"),
+  removeExtension: zod.z.boolean().default(false).describe("Remove the file extension")
+})).implement(async (input) => {
+  const basename2 = input.removeExtension ? path3__namespace.basename(input.path, path3__namespace.extname(input.path)) : path3__namespace.basename(input.path);
+  return {
+    basename: basename2,
+    extension: path3__namespace.extname(input.path)
+  };
+}).build();
+var pathDirname = core.toolBuilder().name("path-dirname").description("Get the directory name of a path (everything except the last portion).").category(core.ToolCategory.FILE_SYSTEM).tags(["path", "dirname", "directory", "filesystem"]).schema(zod.z.object({
+  path: zod.z.string().describe("File path")
+})).implement(async (input) => {
+  const dirname3 = path3__namespace.dirname(input.path);
+  return {
+    dirname: dirname3,
+    basename: path3__namespace.basename(input.path)
+  };
+}).build();
+var pathExtension = core.toolBuilder().name("path-extension").description('Get the file extension from a path (including the dot, e.g., ".txt").').category(core.ToolCategory.FILE_SYSTEM).tags(["path", "extension", "ext", "filesystem"]).schema(zod.z.object({
+  path: zod.z.string().describe("File path")
+})).implement(async (input) => {
+  const ext = path3__namespace.extname(input.path);
+  return {
+    extension: ext,
+    hasExtension: ext.length > 0,
+    filename: path3__namespace.basename(input.path, ext)
+  };
+}).build();
+var pathRelative = core.toolBuilder().name("path-relative").description("Get the relative path from one path to another.").category(core.ToolCategory.FILE_SYSTEM).tags(["path", "relative", "filesystem"]).schema(zod.z.object({
+  from: zod.z.string().describe("Source path"),
+  to: zod.z.string().describe("Destination path")
+})).implement(async (input) => {
+  const relative3 = path3__namespace.relative(input.from, input.to);
+  return {
+    relativePath: relative3,
+    from: input.from,
+    to: input.to
+  };
+}).build();
+var pathNormalize = core.toolBuilder().name("path-normalize").description('Normalize a path by resolving ".." and "." segments and removing duplicate separators.').category(core.ToolCategory.FILE_SYSTEM).tags(["path", "normalize", "filesystem"]).schema(zod.z.object({
+  path: zod.z.string().describe("Path to normalize")
+})).implement(async (input) => {
+  const normalized = path3__namespace.normalize(input.path);
+  return {
+    normalized,
+    original: input.path
+  };
+}).build();
+var currentDateTime = core.toolBuilder().name("current-date-time").description("Get the current date and time in various formats (ISO, Unix timestamp, formatted string).").category(core.ToolCategory.UTILITY).tags(["date", "time", "now", "current"]).schema(zod.z.object({
+  format: zod.z.enum(["iso", "unix", "custom"]).default("iso").describe("Output format"),
+  customFormat: zod.z.string().optional().describe('Custom format string (e.g., "yyyy-MM-dd HH:mm:ss") when format is "custom"'),
+  timezone: zod.z.string().optional().describe('Timezone (e.g., "America/New_York")')
+})).implement(async (input) => {
+  const now = /* @__PURE__ */ new Date();
+  let formatted;
+  if (input.format === "iso") {
+    formatted = now.toISOString();
+  } else if (input.format === "unix") {
+    formatted = Math.floor(now.getTime() / 1e3);
+  } else if (input.format === "custom" && input.customFormat) {
+    formatted = dateFns.format(now, input.customFormat);
+  } else {
+    formatted = now.toISOString();
+  }
+  return {
+    formatted,
+    iso: now.toISOString(),
+    unix: Math.floor(now.getTime() / 1e3),
+    year: now.getFullYear(),
+    month: now.getMonth() + 1,
+    day: now.getDate(),
+    hour: now.getHours(),
+    minute: now.getMinutes(),
+    second: now.getSeconds()
+  };
+}).build();
+var dateFormatter = core.toolBuilder().name("date-formatter").description("Format a date string or timestamp into a different format. Supports ISO, Unix timestamps, and custom formats.").category(core.ToolCategory.UTILITY).tags(["date", "format", "time"]).schema(zod.z.object({
+  date: zod.z.string().describe("Date string or Unix timestamp to format"),
+  outputFormat: zod.z.string().describe('Output format string (e.g., "yyyy-MM-dd", "MMM dd, yyyy")'),
+  inputFormat: zod.z.string().optional().describe("Input format string (optional, auto-detected if not provided)")
+})).implement(async (input) => {
+  try {
+    let date;
+    if (input.inputFormat) {
+      date = dateFns.parse(input.date, input.inputFormat, /* @__PURE__ */ new Date());
+    } else if (!isNaN(Number(input.date))) {
+      date = new Date(Number(input.date) * 1e3);
+    } else {
+      date = new Date(input.date);
+    }
+    if (!dateFns.isValid(date)) {
+      return {
+        success: false,
+        error: "Invalid date"
+      };
+    }
+    const formatted = dateFns.format(date, input.outputFormat);
+    return {
+      success: true,
+      formatted,
+      iso: date.toISOString()
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Failed to format date"
+    };
+  }
+}).build();
+var dateArithmetic = core.toolBuilder().name("date-arithmetic").description("Add or subtract time from a date. Supports years, months, weeks, days, hours, minutes, and seconds.").category(core.ToolCategory.UTILITY).tags(["date", "time", "add", "subtract", "arithmetic"]).schema(zod.z.object({
+  date: zod.z.string().describe("Starting date (ISO string or Unix timestamp)"),
+  operation: zod.z.enum(["add", "subtract"]).describe("Operation to perform"),
+  amount: zod.z.number().describe("Amount to add or subtract"),
+  unit: zod.z.enum(["years", "months", "weeks", "days", "hours", "minutes", "seconds"]).describe("Time unit")
+})).implement(async (input) => {
+  try {
+    const date = new Date(input.date);
+    if (!dateFns.isValid(date)) {
+      return {
+        success: false,
+        error: "Invalid date"
+      };
+    }
+    const duration = { [input.unit]: input.amount };
+    const result = input.operation === "add" ? dateFns.add(date, duration) : dateFns.sub(date, duration);
+    return {
+      success: true,
+      result: result.toISOString(),
+      unix: Math.floor(result.getTime() / 1e3)
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Failed to perform date arithmetic"
+    };
+  }
+}).build();
+var dateDifference = core.toolBuilder().name("date-difference").description("Calculate the difference between two dates in various units (days, hours, minutes).").category(core.ToolCategory.UTILITY).tags(["date", "time", "difference", "duration"]).schema(zod.z.object({
+  startDate: zod.z.string().describe("Start date (ISO string or Unix timestamp)"),
+  endDate: zod.z.string().describe("End date (ISO string or Unix timestamp)"),
+  unit: zod.z.enum(["days", "hours", "minutes"]).default("days").describe("Unit for the difference")
+})).implement(async (input) => {
+  try {
+    const start = new Date(input.startDate);
+    const end = new Date(input.endDate);
+    if (!dateFns.isValid(start) || !dateFns.isValid(end)) {
+      return {
+        success: false,
+        error: "Invalid date(s)"
+      };
+    }
+    let difference;
+    if (input.unit === "days") {
+      difference = dateFns.differenceInDays(end, start);
+    } else if (input.unit === "hours") {
+      difference = dateFns.differenceInHours(end, start);
+    } else {
+      difference = dateFns.differenceInMinutes(end, start);
+    }
+    return {
+      success: true,
+      difference,
+      unit: input.unit,
+      startDate: start.toISOString(),
+      endDate: end.toISOString()
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Failed to calculate date difference"
+    };
+  }
+}).build();
+var dateComparison = core.toolBuilder().name("date-comparison").description("Compare two dates to determine if one is before, after, or equal to the other.").category(core.ToolCategory.UTILITY).tags(["date", "time", "compare", "comparison"]).schema(zod.z.object({
+  date1: zod.z.string().describe("First date to compare"),
+  date2: zod.z.string().describe("Second date to compare")
+})).implement(async (input) => {
+  try {
+    const d1 = new Date(input.date1);
+    const d2 = new Date(input.date2);
+    if (!dateFns.isValid(d1) || !dateFns.isValid(d2)) {
+      return {
+        success: false,
+        error: "Invalid date(s)"
+      };
+    }
+    return {
+      success: true,
+      date1IsBefore: dateFns.isBefore(d1, d2),
+      date1IsAfter: dateFns.isAfter(d1, d2),
+      datesAreEqual: d1.getTime() === d2.getTime(),
+      date1: d1.toISOString(),
+      date2: d2.toISOString()
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Failed to compare dates"
+    };
+  }
+}).build();
+var stringCaseConverter = core.toolBuilder().name("string-case-converter").description("Convert string to different cases: lowercase, uppercase, title case, camel case, snake case, kebab case.").category(core.ToolCategory.UTILITY).tags(["string", "case", "convert", "transform"]).schema(zod.z.object({
+  text: zod.z.string().describe("Text to convert"),
+  targetCase: zod.z.enum(["lowercase", "uppercase", "title", "camel", "snake", "kebab", "pascal"]).describe("Target case format")
+})).implement(async (input) => {
+  let result;
+  switch (input.targetCase) {
+    case "lowercase":
+      result = input.text.toLowerCase();
+      break;
+    case "uppercase":
+      result = input.text.toUpperCase();
+      break;
+    case "title":
+      result = input.text.toLowerCase().replace(/\b\w/g, (char) => char.toUpperCase());
+      break;
+    case "camel":
+      result = input.text.toLowerCase().replace(/[^a-zA-Z0-9]+(.)/g, (_, char) => char.toUpperCase());
+      break;
+    case "snake":
+      result = input.text.replace(/([A-Z])/g, "_$1").toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_|_$/g, "");
+      break;
+    case "kebab":
+      result = input.text.replace(/([A-Z])/g, "-$1").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+      break;
+    case "pascal":
+      result = input.text.toLowerCase().replace(/[^a-zA-Z0-9]+(.)/g, (_, char) => char.toUpperCase()).replace(/^./, (char) => char.toUpperCase());
+      break;
+    default:
+      result = input.text;
+  }
+  return {
+    original: input.text,
+    converted: result,
+    targetCase: input.targetCase
+  };
+}).build();
+var stringTrim = core.toolBuilder().name("string-trim").description("Remove whitespace from the beginning and/or end of a string. Supports trim, trim start, and trim end.").category(core.ToolCategory.UTILITY).tags(["string", "trim", "whitespace"]).schema(zod.z.object({
+  text: zod.z.string().describe("Text to trim"),
+  mode: zod.z.enum(["both", "start", "end"]).default("both").describe("Which side to trim"),
+  characters: zod.z.string().optional().describe("Optional custom characters to trim (default: whitespace)")
+})).implement(async (input) => {
+  let result;
+  if (input.characters) {
+    const chars = input.characters.split("").map((c) => c.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("");
+    const regex = input.mode === "both" ? new RegExp(`^[${chars}]+|[${chars}]+$`, "g") : input.mode === "start" ? new RegExp(`^[${chars}]+`, "g") : new RegExp(`[${chars}]+$`, "g");
+    result = input.text.replace(regex, "");
+  } else {
+    result = input.mode === "both" ? input.text.trim() : input.mode === "start" ? input.text.trimStart() : input.text.trimEnd();
+  }
+  return {
+    original: input.text,
+    trimmed: result,
+    removed: input.text.length - result.length
+  };
+}).build();
+var stringReplace = core.toolBuilder().name("string-replace").description("Replace occurrences of a substring or pattern in a string. Supports regex patterns and global replacement.").category(core.ToolCategory.UTILITY).tags(["string", "replace", "substitute"]).schema(zod.z.object({
+  text: zod.z.string().describe("Text to search in"),
+  search: zod.z.string().describe("String or regex pattern to search for"),
+  replace: zod.z.string().describe("Replacement string"),
+  global: zod.z.boolean().default(true).describe("Replace all occurrences (true) or just the first (false)"),
+  caseInsensitive: zod.z.boolean().default(false).describe("Case-insensitive search")
+})).implement(async (input) => {
+  const flags = (input.global ? "g" : "") + (input.caseInsensitive ? "i" : "");
+  const regex = new RegExp(input.search, flags);
+  const result = input.text.replace(regex, input.replace);
+  const matches = input.text.match(regex);
+  const count = matches ? matches.length : 0;
+  return {
+    original: input.text,
+    result,
+    replacements: count
+  };
+}).build();
+var stringSplit = core.toolBuilder().name("string-split").description("Split a string into an array of substrings using a delimiter. Supports regex delimiters and limit.").category(core.ToolCategory.UTILITY).tags(["string", "split", "array"]).schema(zod.z.object({
+  text: zod.z.string().describe("Text to split"),
+  delimiter: zod.z.string().describe("Delimiter to split on (can be a regex pattern)"),
+  limit: zod.z.number().optional().describe("Maximum number of splits")
+})).implement(async (input) => {
+  const parts = input.text.split(input.delimiter, input.limit);
+  return {
+    parts,
+    count: parts.length
+  };
+}).build();
+var stringJoin = core.toolBuilder().name("string-join").description("Join an array of strings into a single string with a separator.").category(core.ToolCategory.UTILITY).tags(["string", "join", "array"]).schema(zod.z.object({
+  parts: zod.z.array(zod.z.string().describe("String value")).describe("Array of strings to join"),
+  separator: zod.z.string().default("").describe("Separator to use between parts")
+})).implement(async (input) => {
+  const result = input.parts.join(input.separator);
+  return {
+    result,
+    partCount: input.parts.length,
+    length: result.length
+  };
+}).build();
+var stringSubstring = core.toolBuilder().name("string-substring").description("Extract a substring from a string using start and end positions.").category(core.ToolCategory.UTILITY).tags(["string", "substring", "slice"]).schema(zod.z.object({
+  text: zod.z.string().describe("Source text"),
+  start: zod.z.number().describe("Start position (0-based)"),
+  end: zod.z.number().optional().describe("End position (optional, defaults to end of string)")
+})).implement(async (input) => {
+  const result = input.text.substring(input.start, input.end);
+  return {
+    result,
+    length: result.length,
+    start: input.start,
+    end: input.end ?? input.text.length
+  };
+}).build();
+var stringLength = core.toolBuilder().name("string-length").description("Get the length of a string in characters, words, or lines.").category(core.ToolCategory.UTILITY).tags(["string", "length", "count"]).schema(zod.z.object({
+  text: zod.z.string().describe("Text to measure")
+})).implement(async (input) => {
+  const words = input.text.trim().split(/\s+/).filter((w) => w.length > 0);
+  const lines = input.text.split("\n");
+  return {
+    characters: input.text.length,
+    words: words.length,
+    lines: lines.length
+  };
+}).build();
+var calculator = core.toolBuilder().name("calculator").description("Perform basic arithmetic operations: add, subtract, multiply, divide, power, modulo.").category(core.ToolCategory.UTILITY).tags(["math", "calculator", "arithmetic"]).schema(zod.z.object({
+  operation: zod.z.enum(["add", "subtract", "multiply", "divide", "power", "modulo"]).describe("Mathematical operation to perform"),
+  a: zod.z.number().describe("First number"),
+  b: zod.z.number().describe("Second number")
+})).implement(async (input) => {
+  let result;
+  switch (input.operation) {
+    case "add":
+      result = input.a + input.b;
+      break;
+    case "subtract":
+      result = input.a - input.b;
+      break;
+    case "multiply":
+      result = input.a * input.b;
+      break;
+    case "divide":
+      if (input.b === 0) {
+        return {
+          success: false,
+          error: "Division by zero"
+        };
+      }
+      result = input.a / input.b;
+      break;
+    case "power":
+      result = Math.pow(input.a, input.b);
+      break;
+    case "modulo":
+      result = input.a % input.b;
+      break;
+    default:
+      return {
+        success: false,
+        error: "Unknown operation"
+      };
+  }
+  return {
+    success: true,
+    result,
+    operation: input.operation,
+    a: input.a,
+    b: input.b
+  };
+}).build();
+var mathFunctions = core.toolBuilder().name("math-functions").description("Apply mathematical functions: sqrt, abs, round, floor, ceil, sin, cos, tan, log, exp.").category(core.ToolCategory.UTILITY).tags(["math", "functions", "trigonometry"]).schema(zod.z.object({
+  function: zod.z.enum(["sqrt", "abs", "round", "floor", "ceil", "sin", "cos", "tan", "log", "exp"]).describe("Mathematical function to apply"),
+  value: zod.z.number().describe("Input value")
+})).implement(async (input) => {
+  let result;
+  try {
+    switch (input.function) {
+      case "sqrt":
+        result = Math.sqrt(input.value);
+        break;
+      case "abs":
+        result = Math.abs(input.value);
+        break;
+      case "round":
+        result = Math.round(input.value);
+        break;
+      case "floor":
+        result = Math.floor(input.value);
+        break;
+      case "ceil":
+        result = Math.ceil(input.value);
+        break;
+      case "sin":
+        result = Math.sin(input.value);
+        break;
+      case "cos":
+        result = Math.cos(input.value);
+        break;
+      case "tan":
+        result = Math.tan(input.value);
+        break;
+      case "log":
+        result = Math.log(input.value);
+        break;
+      case "exp":
+        result = Math.exp(input.value);
+        break;
+      default:
+        return {
+          success: false,
+          error: "Unknown function"
+        };
+    }
+    if (isNaN(result) || !isFinite(result)) {
+      return {
+        success: false,
+        error: "Invalid result (NaN or Infinity)"
+      };
+    }
+    return {
+      success: true,
+      result,
+      function: input.function,
+      input: input.value
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Math operation failed"
+    };
+  }
+}).build();
+var randomNumber = core.toolBuilder().name("random-number").description("Generate a random number within a specified range. Supports integers and decimals.").category(core.ToolCategory.UTILITY).tags(["random", "number", "generator"]).schema(zod.z.object({
+  min: zod.z.number().default(0).describe("Minimum value (inclusive)"),
+  max: zod.z.number().default(1).describe("Maximum value (exclusive for decimals, inclusive for integers)"),
+  integer: zod.z.boolean().default(false).describe("Generate an integer (true) or decimal (false)")
+})).implement(async (input) => {
+  const min = input.min ?? 0;
+  const max = input.max ?? 1;
+  const integer = input.integer ?? false;
+  let result;
+  if (integer) {
+    result = Math.floor(Math.random() * (max - min + 1)) + min;
+  } else {
+    result = Math.random() * (max - min) + min;
+  }
+  return {
+    result,
+    min,
+    max,
+    integer
+  };
+}).build();
+var statistics = core.toolBuilder().name("statistics").description("Calculate statistics for an array of numbers: sum, average, min, max, median, standard deviation.").category(core.ToolCategory.UTILITY).tags(["math", "statistics", "average", "sum"]).schema(zod.z.object({
+  numbers: zod.z.array(zod.z.number().describe("Number value")).describe("Array of numbers to analyze")
+})).implement(async (input) => {
+  if (input.numbers.length === 0) {
+    return {
+      success: false,
+      error: "Empty array"
+    };
+  }
+  const sorted = [...input.numbers].sort((a, b) => a - b);
+  const sum = input.numbers.reduce((acc, n) => acc + n, 0);
+  const average = sum / input.numbers.length;
+  const min = sorted[0];
+  const max = sorted[sorted.length - 1];
+  const mid = Math.floor(sorted.length / 2);
+  const median = sorted.length % 2 === 0 ? (sorted[mid - 1] + sorted[mid]) / 2 : sorted[mid];
+  const variance = input.numbers.reduce((acc, n) => acc + Math.pow(n - average, 2), 0) / input.numbers.length;
+  const stdDev = Math.sqrt(variance);
+  return {
+    success: true,
+    count: input.numbers.length,
+    sum,
+    average,
+    min,
+    max,
+    median,
+    standardDeviation: stdDev,
+    variance
+  };
+}).build();
+var emailValidator = core.toolBuilder().name("email-validator").description("Validate if a string is a valid email address format.").category(core.ToolCategory.UTILITY).tags(["validation", "email", "validate"]).schema(zod.z.object({
+  email: zod.z.string().describe("Email address to validate")
+})).implement(async (input) => {
+  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+  const valid = emailRegex.test(input.email);
+  return {
+    valid,
+    email: input.email,
+    message: valid ? "Valid email address" : "Invalid email address format"
+  };
+}).build();
+var urlValidatorSimple = core.toolBuilder().name("url-validator-simple").description("Validate if a string is a valid URL format.").category(core.ToolCategory.UTILITY).tags(["validation", "url", "validate"]).schema(zod.z.object({
+  url: zod.z.string().describe("URL to validate")
+})).implement(async (input) => {
+  try {
+    new URL(input.url);
+    return {
+      valid: true,
+      url: input.url,
+      message: "Valid URL"
+    };
+  } catch {
+    return {
+      valid: false,
+      url: input.url,
+      message: "Invalid URL format"
+    };
+  }
+}).build();
+var phoneValidator = core.toolBuilder().name("phone-validator").description("Validate if a string is a valid phone number format. Supports various international formats.").category(core.ToolCategory.UTILITY).tags(["validation", "phone", "validate"]).schema(zod.z.object({
+  phone: zod.z.string().describe("Phone number to validate"),
+  strict: zod.z.boolean().default(false).describe("Use strict validation (requires country code)")
+})).implement(async (input) => {
+  const basicRegex = /^[\d\s\-\+\(\)]+$/;
+  const strictRegex = /^\+?[1-9]\d{1,14}$/;
+  const regex = input.strict ? strictRegex : basicRegex;
+  const valid = regex.test(input.phone.replace(/\s/g, ""));
+  return {
+    valid,
+    phone: input.phone,
+    message: valid ? "Valid phone number format" : "Invalid phone number format"
+  };
+}).build();
+var creditCardValidator = core.toolBuilder().name("credit-card-validator").description("Validate if a string is a valid credit card number using the Luhn algorithm.").category(core.ToolCategory.UTILITY).tags(["validation", "credit-card", "validate", "luhn"]).schema(zod.z.object({
+  cardNumber: zod.z.string().describe("Credit card number to validate")
+})).implement(async (input) => {
+  const cleaned = input.cardNumber.replace(/[\s\-]/g, "");
+  if (!/^\d+$/.test(cleaned)) {
+    return {
+      valid: false,
+      message: "Card number must contain only digits"
+    };
+  }
+  let sum = 0;
+  let isEven = false;
+  for (let i = cleaned.length - 1; i >= 0; i--) {
+    let digit = parseInt(cleaned[i], 10);
+    if (isEven) {
+      digit *= 2;
+      if (digit > 9) {
+        digit -= 9;
+      }
+    }
+    sum += digit;
+    isEven = !isEven;
+  }
+  const valid = sum % 10 === 0;
+  return {
+    valid,
+    cardNumber: input.cardNumber,
+    message: valid ? "Valid credit card number" : "Invalid credit card number (failed Luhn check)"
+  };
+}).build();
+var ipValidator = core.toolBuilder().name("ip-validator").description("Validate if a string is a valid IPv4 or IPv6 address.").category(core.ToolCategory.UTILITY).tags(["validation", "ip", "validate", "network"]).schema(zod.z.object({
+  ip: zod.z.string().describe("IP address to validate"),
+  version: zod.z.enum(["v4", "v6", "any"]).default("any").describe("IP version to validate against")
+})).implement(async (input) => {
+  const ipv4Regex = /^(\d{1,3}\.){3}\d{1,3}$/;
+  const ipv6Regex = /^([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$/;
+  let valid = false;
+  let detectedVersion;
+  if (input.version === "v4" || input.version === "any") {
+    if (ipv4Regex.test(input.ip)) {
+      const parts = input.ip.split(".");
+      valid = parts.every((part) => {
+        const num = parseInt(part, 10);
+        return num >= 0 && num <= 255;
+      });
+      if (valid) detectedVersion = "IPv4";
+    }
+  }
+  if (!valid && (input.version === "v6" || input.version === "any")) {
+    if (ipv6Regex.test(input.ip)) {
+      valid = true;
+      detectedVersion = "IPv6";
+    }
+  }
+  return {
+    valid,
+    ip: input.ip,
+    version: detectedVersion,
+    message: valid ? `Valid ${detectedVersion} address` : "Invalid IP address format"
+  };
+}).build();
+var uuidValidator = core.toolBuilder().name("uuid-validator").description("Validate if a string is a valid UUID (v1, v3, v4, or v5).").category(core.ToolCategory.UTILITY).tags(["validation", "uuid", "validate", "guid"]).schema(zod.z.object({
+  uuid: zod.z.string().describe("UUID to validate")
+})).implement(async (input) => {
+  const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+  const valid = uuidRegex.test(input.uuid);
+  let version;
+  if (valid) {
+    version = parseInt(input.uuid[14], 10);
+  }
+  return {
+    valid,
+    uuid: input.uuid,
+    version,
+    message: valid ? `Valid UUID v${version}` : "Invalid UUID format"
+  };
+}).build();
+
+exports.arrayFilter = arrayFilter;
+exports.arrayGroupBy = arrayGroupBy;
+exports.arrayMap = arrayMap;
+exports.arraySort = arraySort;
+exports.calculator = calculator;
+exports.creditCardValidator = creditCardValidator;
+exports.csvGenerator = csvGenerator;
+exports.csvParser = csvParser;
+exports.csvToJson = csvToJson;
+exports.currentDateTime = currentDateTime;
+exports.dateArithmetic = dateArithmetic;
+exports.dateComparison = dateComparison;
+exports.dateDifference = dateDifference;
+exports.dateFormatter = dateFormatter;
+exports.directoryCreate = directoryCreate;
+exports.directoryDelete = directoryDelete;
+exports.directoryList = directoryList;
+exports.emailValidator = emailValidator;
+exports.extractImages = extractImages;
+exports.extractLinks = extractLinks;
+exports.fileAppend = fileAppend;
+exports.fileDelete = fileDelete;
+exports.fileExists = fileExists;
+exports.fileReader = fileReader;
+exports.fileSearch = fileSearch;
+exports.fileWriter = fileWriter;
+exports.htmlParser = htmlParser;
+exports.httpClient = httpClient;
+exports.httpGet = httpGet;
+exports.httpPost = httpPost;
+exports.ipValidator = ipValidator;
+exports.jsonMerge = jsonMerge;
+exports.jsonParser = jsonParser;
+exports.jsonQuery = jsonQuery;
+exports.jsonStringify = jsonStringify;
+exports.jsonToCsv = jsonToCsv;
+exports.jsonToXml = jsonToXml;
+exports.jsonValidator = jsonValidator;
+exports.mathFunctions = mathFunctions;
+exports.objectOmit = objectOmit;
+exports.objectPick = objectPick;
+exports.pathBasename = pathBasename;
+exports.pathDirname = pathDirname;
+exports.pathExtension = pathExtension;
+exports.pathJoin = pathJoin;
+exports.pathNormalize = pathNormalize;
+exports.pathParse = pathParse;
+exports.pathRelative = pathRelative;
+exports.pathResolve = pathResolve;
+exports.phoneValidator = phoneValidator;
+exports.randomNumber = randomNumber;
+exports.statistics = statistics;
+exports.stringCaseConverter = stringCaseConverter;
+exports.stringJoin = stringJoin;
+exports.stringLength = stringLength;
+exports.stringReplace = stringReplace;
+exports.stringSplit = stringSplit;
+exports.stringSubstring = stringSubstring;
+exports.stringTrim = stringTrim;
+exports.urlBuilder = urlBuilder;
+exports.urlQueryParser = urlQueryParser;
+exports.urlValidator = urlValidator;
+exports.urlValidatorSimple = urlValidatorSimple;
+exports.uuidValidator = uuidValidator;
+exports.webScraper = webScraper;
+exports.xmlGenerator = xmlGenerator;
+exports.xmlParser = xmlParser;
+exports.xmlToJson = xmlToJson;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map