@agentforge/tools 0.10.0 → 0.10.2

package/dist/index.cjs

@@ -1,15 +1,15 @@
 'use strict';
 
 var core = require('@agentforge/core');
+var axios12 = require('axios');
 var zod = require('zod');
-var axios = require('axios');
-var cheerio2 = require('cheerio');
+var cheerio = require('cheerio');
 var webApi = require('@slack/web-api');
 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 path7 = require('path');
 var dateFns = require('date-fns');
 var crypto = require('crypto');
 
@@ -33,11 +33,11 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
-var axios__default = /*#__PURE__*/_interopDefault(axios);
-var cheerio2__namespace = /*#__PURE__*/_interopNamespace(cheerio2);
-var path3__namespace = /*#__PURE__*/_interopNamespace(path3);
+var axios12__default = /*#__PURE__*/_interopDefault(axios12);
+var cheerio__namespace = /*#__PURE__*/_interopNamespace(cheerio);
+var path7__namespace = /*#__PURE__*/_interopNamespace(path7);
 
-// src/web/http-client.ts
+// src/web/http/tools/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"),
@@ -47,54 +47,79 @@ var httpRequestSchema = zod.z.object({
   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({
+var httpGetSchema = 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({
+});
+var httpPostSchema = 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({
+});
+
+// src/web/http/tools/http-client.ts
+function createHttpClientTool(defaultTimeout = 3e4, defaultHeaders = {}) {
+  return 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: { ...defaultHeaders, ...input.headers },
+      data: input.body,
+      timeout: input.timeout ?? defaultTimeout,
+      params: input.params,
+      validateStatus: () => true
+      // Don't throw on any status code
+    };
+    const response = await axios12__default.default(config);
+    return {
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers,
+      data: response.data,
+      url: input.url,
+      method: input.method ?? "GET"
+    };
+  }).build();
+}
+function createHttpGetTool(defaultTimeout = 3e4, defaultHeaders = {}) {
+  return 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(httpGetSchema).implement(async (input) => {
+    const response = await axios12__default.default.get(input.url, {
+      headers: { ...defaultHeaders, ...input.headers },
+      params: input.params,
+      timeout: defaultTimeout
+    });
+    return response.data;
+  }).build();
+}
+function createHttpPostTool(defaultTimeout = 3e4, defaultHeaders = {}) {
+  return 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(httpPostSchema).implement(async (input) => {
+    const response = await axios12__default.default.post(input.url, input.body, {
+      headers: {
+        "Content-Type": "application/json",
+        ...defaultHeaders,
+        ...input.headers
+      },
+      timeout: defaultTimeout
+    });
+    return response.data;
+  }).build();
+}
+
+// src/web/http/index.ts
+var httpClient = createHttpClientTool();
+var httpGet = createHttpGetTool();
+var httpPost = createHttpPostTool();
+var httpTools = [httpClient, httpGet, httpPost];
+function createHttpTools(config = {}) {
+  const { defaultTimeout = 3e4, defaultHeaders = {} } = config;
+  return [
+    createHttpClientTool(defaultTimeout, defaultHeaders),
+    createHttpGetTool(defaultTimeout, defaultHeaders),
+    createHttpPostTool(defaultTimeout, defaultHeaders)
+  ];
+}
+var webScraperSchema = 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"),
@@ -103,240 +128,295 @@ var webScraper = core.toolBuilder().name("web-scraper").description("Scrape and
   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);
-        }
+});
+function createWebScraperTool(defaultTimeout = 3e4, userAgent = "Mozilla/5.0 (compatible; AgentForge/1.0; +https://agentforge.dev)") {
+  return 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(webScraperSchema).implement(async (input) => {
+    const response = await axios12__default.default.get(input.url, {
+      timeout: input.timeout || defaultTimeout,
+      headers: {
+        "User-Agent": userAgent
       }
     });
-  }
-  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);
+    const html = response.data;
+    const $ = cheerio__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.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({
+      });
+    }
+    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();
+}
+
+// src/web/scraper/index.ts
+var webScraper = createWebScraperTool();
+var scraperTools = [webScraper];
+function createScraperTools(config = {}) {
+  const { defaultTimeout = 3e4, userAgent = "Mozilla/5.0 (compatible; AgentForge/1.0; +https://agentforge.dev)" } = config;
+  return [createWebScraperTool(defaultTimeout, userAgent)];
+}
+var htmlParserSchema = 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({
+});
+var extractLinksSchema = 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({
+});
+var extractImagesSchema = 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 {
+});
+function createHtmlParserTool() {
+  return 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(htmlParserSchema).implement(async (input) => {
+    const $ = cheerio__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();
       }
-    }
-    images.push({
-      src,
-      alt: $el.attr("alt"),
-      title: $el.attr("title"),
-      width: $el.attr("width"),
-      height: $el.attr("height")
+      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();
+}
+function createExtractLinksTool() {
+  return 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(extractLinksSchema).implement(async (input) => {
+    const $ = cheerio__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: 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({
+    return {
+      count: links.length,
+      links
+    };
+  }).build();
+}
+function createExtractImagesTool() {
+  return 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(extractImagesSchema).implement(async (input) => {
+    const $ = cheerio__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();
+}
+
+// src/web/html-parser/index.ts
+var htmlParser = createHtmlParserTool();
+var extractLinks = createExtractLinksTool();
+var extractImages = createExtractImagesTool();
+var htmlParserTools = [htmlParser, extractLinks, extractImages];
+function createHtmlParserTools(config = {}) {
+  return [
+    createHtmlParserTool(),
+    createExtractLinksTool(),
+    createExtractImagesTool()
+  ];
+}
+var urlValidatorSchema = zod.z.object({
   url: zod.z.string().describe("The URL to validate and parse")
-})).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 = 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({
+});
+var urlBuilderSchema = 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({
+});
+var urlQueryParserSchema = 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];
+});
+function createUrlValidatorTool() {
+  return 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(urlValidatorSchema).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();
+}
+function createUrlBuilderTool() {
+  return 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(urlBuilderSchema).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
       }
-    } else {
-      params[key] = value;
+    };
+  }).build();
+}
+function createUrlQueryParserTool() {
+  return 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(urlQueryParserSchema).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);
     }
-  });
-  return {
-    params,
-    count: Object.keys(params).length
-  };
-}).build();
+    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();
+}
+
+// src/web/url-validator/index.ts
+var urlValidator = createUrlValidatorTool();
+var urlBuilder = createUrlBuilderTool();
+var urlQueryParser = createUrlQueryParserTool();
+var urlValidatorTools = [urlValidator, urlBuilder, urlQueryParser];
+function createUrlValidatorTools(config = {}) {
+  return [
+    createUrlValidatorTool(),
+    createUrlBuilderTool(),
+    createUrlQueryParserTool()
+  ];
+}
 var webSearchSchema = zod.z.object({
   query: zod.z.string().min(1).describe("The search query"),
   maxResults: zod.z.number().min(1).max(50).default(10).describe("Maximum number of results to return (1-50)"),
@@ -441,7 +521,7 @@ var DuckDuckGoProvider = class {
   async search(query, maxResults, timeout = DEFAULT_TIMEOUT) {
     return retryWithBackoff(async () => {
       try {
-        const response = await axios__default.default.get(
+        const response = await axios12__default.default.get(
           "https://api.duckduckgo.com/",
           {
             params: {
@@ -545,7 +625,7 @@ var SerperProvider = class {
     }
     return retryWithBackoff(async () => {
       try {
-        const response = await axios__default.default.post(
+        const response = await axios12__default.default.post(
           "https://google.serper.dev/search",
           {
             q: query,
@@ -683,8 +763,28 @@ var webSearch = core.toolBuilder().name("web-search").description(
     };
   }
 }).build();
-var logLevel = process.env.LOG_LEVEL?.toLowerCase() || core.LogLevel.INFO;
-var logger = core.createLogger("tools:slack", { level: logLevel });
+function createGetConfiguredSlackClient(token, botName = "AgentForge Bot", botIcon = ":robot_face:") {
+  let configuredClient = null;
+  return function getConfiguredSlackClient() {
+    if (!configuredClient) {
+      const slackToken = token || process.env.SLACK_USER_TOKEN || process.env.SLACK_BOT_TOKEN;
+      if (!slackToken) {
+        throw new Error(
+          "Slack token not configured. Please provide a token in config or set SLACK_USER_TOKEN or SLACK_BOT_TOKEN environment variable."
+        );
+      }
+      configuredClient = new webApi.WebClient(slackToken);
+    }
+    return {
+      client: configuredClient,
+      config: {
+        token: token || process.env.SLACK_USER_TOKEN || process.env.SLACK_BOT_TOKEN || "",
+        botName,
+        botIcon
+      }
+    };
+  };
+}
 var defaultSlackClient = null;
 function getDefaultSlackClient() {
   if (!defaultSlackClient) {
@@ -696,196 +796,17 @@ function getDefaultSlackClient() {
     }
     defaultSlackClient = new webApi.WebClient(token);
   }
-  return defaultSlackClient;
-}
-var sendSlackMessage = core.toolBuilder().name("send-slack-message").description("Send a message to a Slack channel for team communication and notifications").category(core.ToolCategory.WEB).tags(["slack", "messaging", "communication"]).usageNotes(
-  "Use this for general team communication. For notifications with @mentions, consider using notify-slack instead. Use get-slack-channels first if you need to find the right channel."
-).suggests(["get-slack-channels"]).schema(
-  zod.z.object({
-    channel: zod.z.string().describe("Channel name (e.g., 'general') or ID (e.g., 'C123456')"),
-    message: zod.z.string().describe("Message content to send")
-  })
-).implementSafe(async ({ channel, message }) => {
-  logger.info("send-slack-message called", { channel, messageLength: message.length });
-  try {
-    const slack = getDefaultSlackClient();
-    const result = await slack.chat.postMessage({
-      channel,
-      text: message,
-      username: "AgentForge Bot",
-      icon_emoji: ":robot_face:"
-    });
-    logger.info("send-slack-message result", {
-      channel: result.channel,
-      timestamp: result.ts,
-      messageLength: message.length,
-      success: true
-    });
-    return {
-      channel: result.channel,
-      message,
-      timestamp: result.ts,
-      message_id: result.ts
-    };
-  } catch (error) {
-    logger.error("send-slack-message failed", {
-      channel,
-      error: error.message,
-      data: error.data
-    });
-    throw error;
-  }
-}).build();
-var notifySlack = core.toolBuilder().name("notify-slack").description("Send a notification to a Slack channel with optional @mentions for urgent alerts").category(core.ToolCategory.WEB).tags(["slack", "notification", "alert"]).usageNotes(
-  "Use this for urgent notifications that require @mentions. For general messages without mentions, use send-slack-message instead."
-).suggests(["get-slack-channels"]).schema(
-  zod.z.object({
-    channel: zod.z.string().describe("Channel name or ID"),
-    message: zod.z.string().describe("Notification message"),
-    mentions: zod.z.array(zod.z.string()).optional().describe("List of usernames to mention (without @)")
-  })
-).implementSafe(async ({ channel, message, mentions = [] }) => {
-  logger.info("notify-slack called", {
-    channel,
-    messageLength: message.length,
-    mentionCount: mentions.length
-  });
-  const slack = getDefaultSlackClient();
-  const mentionText = mentions.length > 0 ? mentions.map((m) => `<@${m}>`).join(" ") + " " : "";
-  const fullMessage = `${mentionText}${message}`;
-  const result = await slack.chat.postMessage({
-    channel,
-    text: fullMessage,
-    username: "AgentForge Bot",
-    icon_emoji: ":robot_face:"
-  });
-  logger.info("notify-slack result", {
-    channel: result.channel,
-    timestamp: result.ts,
-    mentions: mentions.length
-  });
-  return {
-    channel: result.channel,
-    message: fullMessage,
-    mentions,
-    timestamp: result.ts,
-    notification_id: result.ts
-  };
-}).build();
-var getSlackChannels = core.toolBuilder().name("get-slack-channels").description("Get a list of available Slack channels to find the right channel for messaging").category(core.ToolCategory.WEB).tags(["slack", "channels", "list"]).usageNotes(
-  "Use this first to discover available channels before sending messages. Helps ensure you are sending to the correct channel."
-).follows(["send-slack-message", "notify-slack"]).schema(
-  zod.z.object({
-    include_private: zod.z.boolean().optional().describe("Include private channels (default: false)")
-  })
-).implementSafe(async ({ include_private = false }) => {
-  logger.info("get-slack-channels called", { include_private });
-  const slack = getDefaultSlackClient();
-  const publicChannels = await slack.conversations.list({
-    types: "public_channel",
-    exclude_archived: true
-  });
-  let allChannels = publicChannels.channels || [];
-  if (include_private) {
-    const privateChannels = await slack.conversations.list({
-      types: "private_channel",
-      exclude_archived: true
-    });
-    allChannels = [...allChannels, ...privateChannels.channels || []];
-  }
-  logger.info("get-slack-channels result", {
-    channelCount: allChannels.length,
-    includePrivate: include_private
-  });
   return {
-    count: allChannels.length,
-    channels: allChannels.map((c) => ({
-      id: c.id,
-      name: c.name,
-      is_private: c.is_private || false,
-      num_members: c.num_members || 0
-    }))
-  };
-}).build();
-var getSlackMessages = core.toolBuilder().name("get-slack-messages").description("Retrieve message history from a Slack channel to read recent conversations").category(core.ToolCategory.WEB).tags(["slack", "messages", "history", "read"]).usageNotes(
-  "Use this to read recent messages from a channel. Use get-slack-channels first if you need to find the channel ID. Returns messages in reverse chronological order (newest first)."
-).suggests(["get-slack-channels"]).schema(
-  zod.z.object({
-    channel: zod.z.string().describe("Channel name (e.g., 'general') or ID (e.g., 'C123456')"),
-    limit: zod.z.number().int().min(1).max(100).optional().describe("Number of messages to retrieve (default: 20, max: 100)")
-  })
-).implementSafe(async ({ channel, limit = 20 }) => {
-  logger.info("get-slack-messages called", { channel, limit });
-  try {
-    const slack = getDefaultSlackClient();
-    let channelId = channel;
-    if (!channel.startsWith("C") && !channel.startsWith("D")) {
-      const channels = await slack.conversations.list({
-        types: "public_channel,private_channel",
-        exclude_archived: true
-      });
-      const found = channels.channels?.find((c) => c.name === channel);
-      if (!found) {
-        logger.error("get-slack-messages: channel not found", { channel });
-        throw new Error(
-          `Channel '${channel}' not found. Use get-slack-channels to see available channels.`
-        );
-      }
-      channelId = found.id;
-    }
-    const result = await slack.conversations.history({
-      channel: channelId,
-      limit: Math.min(limit, 100)
-      // Cap at 100 for performance
-    });
-    logger.info("get-slack-messages result", {
-      channel: channelId,
-      messageCount: result.messages?.length || 0,
-      limit
-    });
-    return {
-      channel: channelId,
-      count: result.messages?.length || 0,
-      messages: result.messages?.map((m) => ({
-        user: m.user || "unknown",
-        text: m.text || "",
-        timestamp: m.ts,
-        thread_ts: m.thread_ts,
-        type: m.type,
-        subtype: m.subtype
-      })) || []
-    };
-  } catch (error) {
-    logger.error("get-slack-messages failed", {
-      channel,
-      error: error.message,
-      data: error.data
-    });
-    throw error;
-  }
-}).build();
-function createSlackTools(config = {}) {
-  const {
-    token,
-    botName = "AgentForge Bot",
-    botIcon = ":robot_face:",
-    logLevel: customLogLevel
-  } = config;
-  let configuredClient = null;
-  function getConfiguredSlackClient() {
-    if (!configuredClient) {
-      const slackToken = token || process.env.SLACK_USER_TOKEN || process.env.SLACK_BOT_TOKEN;
-      if (!slackToken) {
-        throw new Error(
-          "Slack token not configured. Please provide a token in config or set SLACK_USER_TOKEN or SLACK_BOT_TOKEN environment variable."
-        );
-      }
-      configuredClient = new webApi.WebClient(slackToken);
+    client: defaultSlackClient,
+    config: {
+      token: process.env.SLACK_USER_TOKEN || process.env.SLACK_BOT_TOKEN || "",
+      botName: "AgentForge Bot",
+      botIcon: ":robot_face:"
     }
-    return configuredClient;
-  }
-  const toolLogger = customLogLevel ? core.createLogger("tools:slack", { level: customLogLevel }) : logger;
-  const sendMessage = core.toolBuilder().name("send-slack-message").description("Send a message to a Slack channel for team communication and notifications").category(core.ToolCategory.WEB).tags(["slack", "messaging", "communication"]).usageNotes(
+  };
+}
+function createSendSlackMessageTool(getSlackClient, logger4) {
+  return core.toolBuilder().name("send-slack-message").description("Send a message to a Slack channel for team communication and notifications").category(core.ToolCategory.WEB).tags(["slack", "messaging", "communication"]).usageNotes(
     "Use this for general team communication. For notifications with @mentions, consider using notify-slack instead. Use get-slack-channels first if you need to find the right channel."
   ).suggests(["get-slack-channels"]).schema(
     zod.z.object({
@@ -893,16 +814,16 @@ function createSlackTools(config = {}) {
       message: zod.z.string().describe("Message content to send")
     })
   ).implementSafe(async ({ channel, message }) => {
-    toolLogger.info("send-slack-message called", { channel, messageLength: message.length });
+    logger4.info("send-slack-message called", { channel, messageLength: message.length });
     try {
-      const slack = getConfiguredSlackClient();
+      const { client: slack, config } = getSlackClient();
       const result = await slack.chat.postMessage({
         channel,
         text: message,
-        username: botName,
-        icon_emoji: botIcon
+        username: config.botName,
+        icon_emoji: config.botIcon
       });
-      toolLogger.info("send-slack-message result", {
+      logger4.info("send-slack-message result", {
         channel: result.channel,
         timestamp: result.ts,
         messageLength: message.length,
@@ -915,7 +836,7 @@ function createSlackTools(config = {}) {
         message_id: result.ts
       };
     } catch (error) {
-      toolLogger.error("send-slack-message failed", {
+      logger4.error("send-slack-message failed", {
         channel,
         error: error.message,
         data: error.data
@@ -923,7 +844,9 @@ function createSlackTools(config = {}) {
       throw error;
     }
   }).build();
-  const notify = core.toolBuilder().name("notify-slack").description("Send a notification to a Slack channel with optional @mentions for urgent alerts").category(core.ToolCategory.WEB).tags(["slack", "notification", "alert"]).usageNotes(
+}
+function createNotifySlackTool(getSlackClient, logger4) {
+  return core.toolBuilder().name("notify-slack").description("Send a notification to a Slack channel with optional @mentions for urgent alerts").category(core.ToolCategory.WEB).tags(["slack", "notification", "alert"]).usageNotes(
     "Use this for urgent notifications that require @mentions. For general messages without mentions, use send-slack-message instead."
   ).suggests(["get-slack-channels"]).schema(
     zod.z.object({
@@ -932,21 +855,21 @@ function createSlackTools(config = {}) {
       mentions: zod.z.array(zod.z.string()).optional().describe("List of usernames to mention (without @)")
     })
   ).implementSafe(async ({ channel, message, mentions = [] }) => {
-    toolLogger.info("notify-slack called", {
+    logger4.info("notify-slack called", {
       channel,
       messageLength: message.length,
       mentionCount: mentions.length
     });
-    const slack = getConfiguredSlackClient();
+    const { client: slack, config } = getSlackClient();
     const mentionText = mentions.length > 0 ? mentions.map((m) => `<@${m}>`).join(" ") + " " : "";
     const fullMessage = `${mentionText}${message}`;
     const result = await slack.chat.postMessage({
       channel,
       text: fullMessage,
-      username: botName,
-      icon_emoji: botIcon
+      username: config.botName,
+      icon_emoji: config.botIcon
     });
-    toolLogger.info("notify-slack result", {
+    logger4.info("notify-slack result", {
       channel: result.channel,
       timestamp: result.ts,
       mentions: mentions.length
@@ -959,15 +882,17 @@ function createSlackTools(config = {}) {
       notification_id: result.ts
     };
   }).build();
-  const getChannels = core.toolBuilder().name("get-slack-channels").description("Get a list of available Slack channels to find the right channel for messaging").category(core.ToolCategory.WEB).tags(["slack", "channels", "list"]).usageNotes(
+}
+function createGetSlackChannelsTool(getSlackClient, logger4) {
+  return core.toolBuilder().name("get-slack-channels").description("Get a list of available Slack channels to find the right channel for messaging").category(core.ToolCategory.WEB).tags(["slack", "channels", "list"]).usageNotes(
     "Use this first to discover available channels before sending messages. Helps ensure you are sending to the correct channel."
   ).follows(["send-slack-message", "notify-slack"]).schema(
     zod.z.object({
       include_private: zod.z.boolean().optional().describe("Include private channels (default: false)")
     })
   ).implementSafe(async ({ include_private = false }) => {
-    toolLogger.info("get-slack-channels called", { include_private });
-    const slack = getConfiguredSlackClient();
+    logger4.info("get-slack-channels called", { include_private });
+    const { client: slack } = getSlackClient();
     const publicChannels = await slack.conversations.list({
       types: "public_channel",
       exclude_archived: true
@@ -980,7 +905,7 @@ function createSlackTools(config = {}) {
       });
       allChannels = [...allChannels, ...privateChannels.channels || []];
     }
-    toolLogger.info("get-slack-channels result", {
+    logger4.info("get-slack-channels result", {
       channelCount: allChannels.length,
       includePrivate: include_private
     });
@@ -994,7 +919,9 @@ function createSlackTools(config = {}) {
       }))
     };
   }).build();
-  const getMessages = core.toolBuilder().name("get-slack-messages").description("Retrieve message history from a Slack channel to read recent conversations").category(core.ToolCategory.WEB).tags(["slack", "messages", "history", "read"]).usageNotes(
+}
+function createGetSlackMessagesTool(getSlackClient, logger4) {
+  return core.toolBuilder().name("get-slack-messages").description("Retrieve message history from a Slack channel to read recent conversations").category(core.ToolCategory.WEB).tags(["slack", "messages", "history", "read"]).usageNotes(
     "Use this to read recent messages from a channel. Use get-slack-channels first if you need to find the channel ID. Returns messages in reverse chronological order (newest first)."
   ).suggests(["get-slack-channels"]).schema(
     zod.z.object({
@@ -1002,9 +929,9 @@ function createSlackTools(config = {}) {
       limit: zod.z.number().int().min(1).max(100).optional().describe("Number of messages to retrieve (default: 20, max: 100)")
     })
   ).implementSafe(async ({ channel, limit = 20 }) => {
-    toolLogger.info("get-slack-messages called", { channel, limit });
+    logger4.info("get-slack-messages called", { channel, limit });
     try {
-      const slack = getConfiguredSlackClient();
+      const { client: slack } = getSlackClient();
       let channelId = channel;
       if (!channel.startsWith("C") && !channel.startsWith("D")) {
         const channels = await slack.conversations.list({
@@ -1013,7 +940,7 @@ function createSlackTools(config = {}) {
         });
         const found = channels.channels?.find((c) => c.name === channel);
         if (!found) {
-          toolLogger.error("get-slack-messages: channel not found", { channel });
+          logger4.error("get-slack-messages: channel not found", { channel });
           throw new Error(
             `Channel '${channel}' not found. Use get-slack-channels to see available channels.`
           );
@@ -1023,8 +950,9 @@ function createSlackTools(config = {}) {
       const result = await slack.conversations.history({
         channel: channelId,
         limit: Math.min(limit, 100)
+        // Cap at 100 for performance
       });
-      toolLogger.info("get-slack-messages result", {
+      logger4.info("get-slack-messages result", {
         channel: channelId,
         messageCount: result.messages?.length || 0,
         limit
@@ -1042,7 +970,7 @@ function createSlackTools(config = {}) {
         })) || []
       };
     } catch (error) {
-      toolLogger.error("get-slack-messages failed", {
+      logger4.error("get-slack-messages failed", {
         channel,
         error: error.message,
         data: error.data
@@ -1050,21 +978,50 @@ function createSlackTools(config = {}) {
       throw error;
     }
   }).build();
-  return {
-    sendMessage,
-    notify,
-    getChannels,
-    getMessages
-  };
 }
-var slackTools = [sendSlackMessage, notifySlack, getSlackChannels, getSlackMessages];
 
-// src/web/confluence/auth.ts
-function createGetConfiguredAuth(apiKey, email, siteUrl) {
-  return function getConfiguredAuth() {
-    const ATLASSIAN_API_KEY = apiKey || process.env.ATLASSIAN_API_KEY || "";
-    const ATLASSIAN_EMAIL = email || process.env.ATLASSIAN_EMAIL || "";
-    const ATLASSIAN_SITE_URL = (siteUrl || process.env.ATLASSIAN_SITE_URL || "").replace(/\/$/, "");
+// src/web/slack/index.ts
+var logLevel = process.env.LOG_LEVEL?.toLowerCase() || core.LogLevel.INFO;
+var logger = core.createLogger("[tools:slack]", { level: logLevel });
+var sendSlackMessage = createSendSlackMessageTool(getDefaultSlackClient, logger);
+var notifySlack = createNotifySlackTool(getDefaultSlackClient, logger);
+var getSlackChannels = createGetSlackChannelsTool(getDefaultSlackClient, logger);
+var getSlackMessages = createGetSlackMessagesTool(getDefaultSlackClient, logger);
+var slackTools = [
+  // Write tools
+  sendSlackMessage,
+  notifySlack,
+  // Read tools
+  getSlackChannels,
+  getSlackMessages
+];
+function createSlackTools(config = {}) {
+  const {
+    token,
+    botName = "AgentForge Bot",
+    botIcon = ":robot_face:",
+    logLevel: customLogLevel
+  } = config;
+  const getConfiguredSlackClient = createGetConfiguredSlackClient(token, botName, botIcon);
+  const toolLogger = customLogLevel ? core.createLogger("[tools:slack]", { level: customLogLevel }) : logger;
+  const sendMessage = createSendSlackMessageTool(getConfiguredSlackClient, toolLogger);
+  const notify = createNotifySlackTool(getConfiguredSlackClient, toolLogger);
+  const getChannels = createGetSlackChannelsTool(getConfiguredSlackClient, toolLogger);
+  const getMessages = createGetSlackMessagesTool(getConfiguredSlackClient, toolLogger);
+  return {
+    sendMessage,
+    notify,
+    getChannels,
+    getMessages
+  };
+}
+
+// src/web/confluence/auth.ts
+function createGetConfiguredAuth(apiKey, email, siteUrl) {
+  return function getConfiguredAuth() {
+    const ATLASSIAN_API_KEY = apiKey || process.env.ATLASSIAN_API_KEY || "";
+    const ATLASSIAN_EMAIL = email || process.env.ATLASSIAN_EMAIL || "";
+    const ATLASSIAN_SITE_URL = (siteUrl || process.env.ATLASSIAN_SITE_URL || "").replace(/\/$/, "");
     if (!ATLASSIAN_API_KEY || !ATLASSIAN_EMAIL || !ATLASSIAN_SITE_URL) {
       throw new Error(
         "Confluence credentials not configured. Set ATLASSIAN_API_KEY, ATLASSIAN_EMAIL, and ATLASSIAN_SITE_URL in config or environment variables."
@@ -1102,7 +1059,7 @@ function createSearchConfluenceTool(getAuth, getAuthHeader2, logger4) {
     logger4.info("search-confluence called", { query, limit });
     try {
       const { ATLASSIAN_SITE_URL } = getAuth();
-      const response = await axios__default.default.get(`${ATLASSIAN_SITE_URL}/wiki/rest/api/content/search`, {
+      const response = await axios12__default.default.get(`${ATLASSIAN_SITE_URL}/wiki/rest/api/content/search`, {
         headers: {
           Authorization: getAuthHeader2(),
           Accept: "application/json"
@@ -1164,7 +1121,7 @@ function createGetConfluencePageTool(getAuth, getAuthHeader2, logger4) {
     logger4.info("get-confluence-page called", { page_id });
     try {
       const { ATLASSIAN_SITE_URL } = getAuth();
-      const response = await axios__default.default.get(`${ATLASSIAN_SITE_URL}/wiki/rest/api/content/${page_id}`, {
+      const response = await axios12__default.default.get(`${ATLASSIAN_SITE_URL}/wiki/rest/api/content/${page_id}`, {
         headers: {
           Authorization: getAuthHeader2(),
           Accept: "application/json"
@@ -1215,7 +1172,7 @@ function createListConfluenceSpacesTool(getAuth, getAuthHeader2, logger4) {
     logger4.info("list-confluence-spaces called", { limit });
     try {
       const { ATLASSIAN_SITE_URL } = getAuth();
-      const response = await axios__default.default.get(`${ATLASSIAN_SITE_URL}/wiki/rest/api/space`, {
+      const response = await axios12__default.default.get(`${ATLASSIAN_SITE_URL}/wiki/rest/api/space`, {
         headers: {
           Authorization: getAuthHeader2(),
           Accept: "application/json"
@@ -1261,7 +1218,7 @@ function createGetSpacePagesTool(getAuth, getAuthHeader2, logger4) {
     logger4.info("get-space-pages called", { space_key, limit });
     try {
       const { ATLASSIAN_SITE_URL } = getAuth();
-      const response = await axios__default.default.get(`${ATLASSIAN_SITE_URL}/wiki/rest/api/content`, {
+      const response = await axios12__default.default.get(`${ATLASSIAN_SITE_URL}/wiki/rest/api/content`, {
         headers: {
           Authorization: getAuthHeader2(),
           Accept: "application/json"
@@ -1335,7 +1292,7 @@ function createCreateConfluencePageTool(getAuth, getAuthHeader2, logger4) {
       if (parent_page_id) {
         pageData.ancestors = [{ id: parent_page_id }];
       }
-      const response = await axios__default.default.post(
+      const response = await axios12__default.default.post(
         `${ATLASSIAN_SITE_URL}/wiki/rest/api/content`,
         pageData,
         {
@@ -1383,7 +1340,7 @@ function createUpdateConfluencePageTool(getAuth, getAuthHeader2, logger4) {
     logger4.info("update-confluence-page called", { page_id, title });
     try {
       const { ATLASSIAN_SITE_URL } = getAuth();
-      const getResponse = await axios__default.default.get(
+      const getResponse = await axios12__default.default.get(
         `${ATLASSIAN_SITE_URL}/wiki/rest/api/content/${page_id}`,
         {
           headers: {
@@ -1393,7 +1350,7 @@ function createUpdateConfluencePageTool(getAuth, getAuthHeader2, logger4) {
         }
       );
       const currentVersion = getResponse.data.version.number;
-      const updateResponse = await axios__default.default.put(
+      const updateResponse = await axios12__default.default.put(
         `${ATLASSIAN_SITE_URL}/wiki/rest/api/content/${page_id}`,
         {
           type: "page",
@@ -1451,7 +1408,7 @@ function createArchiveConfluencePageTool(getAuth, getAuthHeader2, logger4) {
     logger4.info("archive-confluence-page called", { page_id, reason });
     try {
       const { ATLASSIAN_SITE_URL } = getAuth();
-      const getResponse = await axios__default.default.get(
+      const getResponse = await axios12__default.default.get(
         `${ATLASSIAN_SITE_URL}/wiki/rest/api/content/${page_id}`,
         {
           headers: {
@@ -1462,7 +1419,7 @@ function createArchiveConfluencePageTool(getAuth, getAuthHeader2, logger4) {
       );
       const currentVersion = getResponse.data.version.number;
       const pageData = getResponse.data;
-      await axios__default.default.put(
+      await axios12__default.default.put(
         `${ATLASSIAN_SITE_URL}/wiki/rest/api/content/${page_id}`,
         {
           version: { number: currentVersion + 1 },
@@ -1558,1204 +1515,1664 @@ function createConfluenceTools(config = {}) {
     archiveConfluencePage: archiveConfluencePage2
   };
 }
-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.)")
-})).implementSafe(async (input) => {
-  const parsed = JSON.parse(input.json);
-  return {
-    data: parsed,
-    type: Array.isArray(parsed) ? "array" : typeof parsed
-  };
-}).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)")
-})).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 = 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")')
-})).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 {
-    value: current,
-    type: Array.isArray(current) ? "array" : typeof current
-  };
-}).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")
-})).implementSafe(async (input) => {
-  JSON.parse(input.json);
-  return {
-    valid: true,
-    message: "Valid 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({
+var csvParserSchema = 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({
+});
+var csvGeneratorSchema = 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({
+});
+var csvToJsonSchema = 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({
+});
+var jsonToCsvSchema = 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)) {
+});
+function createCsvParserTool(defaultDelimiter = ",", defaultHasHeaders = true, defaultSkipEmptyLines = true, defaultTrim = true) {
+  return 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(csvParserSchema).implement(async (input) => {
+    try {
+      const records = sync.parse(input.csv, {
+        delimiter: input.delimiter ?? defaultDelimiter,
+        columns: input.hasHeaders ?? defaultHasHeaders,
+        skip_empty_lines: input.skipEmptyLines ?? defaultSkipEmptyLines,
+        trim: input.trim ?? defaultTrim,
+        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: "Input must be a JSON array"
+        error: error instanceof Error ? error.message : "Failed to parse CSV"
       };
     }
-    const csv = sync$1.stringify(data, {
-      delimiter: input.delimiter,
-      header: true
-    });
+  }).build();
+}
+function createCsvGeneratorTool(defaultDelimiter = ",") {
+  return 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(csvGeneratorSchema).implement(async (input) => {
+    try {
+      const csv = sync$1.stringify(input.data, {
+        delimiter: input.delimiter ?? defaultDelimiter,
+        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();
+}
+function createCsvToJsonTool(defaultDelimiter = ",") {
+  return 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(csvToJsonSchema).implement(async (input) => {
+    try {
+      const records = sync.parse(input.csv, {
+        delimiter: input.delimiter ?? defaultDelimiter,
+        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();
+}
+function createJsonToCsvTool(defaultDelimiter = ",") {
+  return 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(jsonToCsvSchema).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 ?? defaultDelimiter,
+        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();
+}
+
+// src/data/csv/index.ts
+var csvParser = createCsvParserTool();
+var csvGenerator = createCsvGeneratorTool();
+var csvToJson = createCsvToJsonTool();
+var jsonToCsv = createJsonToCsvTool();
+var csvTools = [csvParser, csvGenerator, csvToJson, jsonToCsv];
+function createCsvTools(config = {}) {
+  const {
+    defaultDelimiter = ",",
+    defaultHasHeaders = true,
+    defaultSkipEmptyLines = true,
+    defaultTrim = true
+  } = config;
+  return [
+    createCsvParserTool(defaultDelimiter, defaultHasHeaders, defaultSkipEmptyLines, defaultTrim),
+    createCsvGeneratorTool(defaultDelimiter),
+    createCsvToJsonTool(defaultDelimiter),
+    createJsonToCsvTool(defaultDelimiter)
+  ];
+}
+var jsonParserSchema = 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.)")
+});
+var jsonStringifySchema = 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)")
+});
+var jsonQuerySchema = 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")')
+});
+var jsonValidatorSchema = zod.z.object({
+  json: zod.z.string().describe("JSON string to validate")
+});
+var jsonMergeSchema = 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)")
+});
+function createJsonParserTool() {
+  return 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(jsonParserSchema).implementSafe(async (input) => {
+    const parsed = JSON.parse(input.json);
     return {
-      success: true,
-      csv,
-      rowCount: data.length
+      data: parsed,
+      type: Array.isArray(parsed) ? "array" : typeof parsed
     };
-  } catch (error) {
+  }).build();
+}
+function createJsonStringifyTool(defaultIndent = 2, defaultPretty = false) {
+  return 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(jsonStringifySchema).implementSafe(async (input) => {
+    const pretty = input.pretty ?? defaultPretty;
+    const indent = input.indent ?? defaultIndent;
+    const json = pretty ? JSON.stringify(input.data, null, indent) : JSON.stringify(input.data);
     return {
-      success: false,
-      error: error instanceof Error ? error.message : "Failed to convert JSON to CSV"
+      json,
+      length: json.length
     };
-  }
-}).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);
+  }).build();
+}
+function createJsonQueryTool() {
+  return 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(jsonQuerySchema).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,
-      data: result
+      value: current,
+      type: Array.isArray(current) ? "array" : typeof current
     };
-  } catch (error) {
+  }).build();
+}
+function createJsonValidatorTool() {
+  return 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(jsonValidatorSchema).implementSafe(async (input) => {
+    JSON.parse(input.json);
     return {
-      success: false,
-      error: error instanceof Error ? error.message : "Failed to parse XML"
+      valid: true,
+      message: "Valid JSON"
     };
-  }
-}).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({
+  }).build();
+}
+function createJsonMergeTool() {
+  return 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(jsonMergeSchema).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();
+}
+
+// src/data/json/index.ts
+var jsonParser = createJsonParserTool();
+var jsonStringify = createJsonStringifyTool();
+var jsonQuery = createJsonQueryTool();
+var jsonValidator = createJsonValidatorTool();
+var jsonMerge = createJsonMergeTool();
+var jsonTools = [jsonParser, jsonStringify, jsonQuery, jsonValidator, jsonMerge];
+function createJsonTools(config = {}) {
+  const {
+    defaultIndent = 2,
+    defaultPretty = false
+  } = config;
+  return [
+    createJsonParserTool(),
+    createJsonStringifyTool(defaultIndent, defaultPretty),
+    createJsonQueryTool(),
+    createJsonValidatorTool(),
+    createJsonMergeTool()
+  ];
+}
+var xmlParserSchema = 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")
+});
+var xmlGeneratorSchema = 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({
+});
+var xmlToJsonSchema = 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({
+});
+var jsonToXmlSchema = 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({
+});
+function createXmlParserTool() {
+  return 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(xmlParserSchema).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();
+}
+function createXmlGeneratorTool(defaultRootName = "root", defaultFormat = false, defaultIndentSize = 2) {
+  return 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(xmlGeneratorSchema).implement(async (input) => {
+    try {
+      const indentSize = input.indentSize ?? defaultIndentSize;
+      const rootName = input.rootName ?? defaultRootName;
+      const format3 = input.format ?? defaultFormat;
+      const builder = new fastXmlParser.XMLBuilder({
+        format: format3,
+        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();
+}
+function createXmlToJsonTool() {
+  return 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(xmlToJsonSchema).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();
+}
+function createJsonToXmlTool(defaultRootName = "root", defaultFormat = false) {
+  return 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(jsonToXmlSchema).implement(async (input) => {
+    try {
+      const data = JSON.parse(input.json);
+      const rootName = input.rootName ?? defaultRootName;
+      const format3 = input.format ?? defaultFormat;
+      const builder = new fastXmlParser.XMLBuilder({
+        format: format3,
+        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();
+}
+
+// src/data/xml/index.ts
+var xmlParser = createXmlParserTool();
+var xmlGenerator = createXmlGeneratorTool();
+var xmlToJson = createXmlToJsonTool();
+var jsonToXml = createJsonToXmlTool();
+var xmlTools = [xmlParser, xmlGenerator, xmlToJson, jsonToXml];
+function createXmlTools(config = {}) {
+  const {
+    defaultRootName = "root",
+    defaultFormat = false,
+    defaultIndentSize = 2
+  } = config;
+  return [
+    createXmlParserTool(),
+    createXmlGeneratorTool(defaultRootName, defaultFormat, defaultIndentSize),
+    createXmlToJsonTool(),
+    createJsonToXmlTool(defaultRootName, defaultFormat)
+  ];
+}
+var arrayFilterSchema = 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")
+});
+var arrayMapSchema = 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({
+});
+var arraySortSchema = 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({
+});
+var arrayGroupBySchema = 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({
+});
+var objectPickSchema = 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({
+});
+var objectOmitSchema = 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({
+});
+function createArrayFilterTool() {
+  return 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(arrayFilterSchema).implement(async (input) => {
+    const getNestedValue = (obj, path12) => {
+      return path12.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();
+}
+function createArrayMapTool() {
+  return 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(arrayMapSchema).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();
+}
+function createArraySortTool() {
+  return 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(arraySortSchema).implement(async (input) => {
+    const getNestedValue = (obj, path12) => {
+      return path12.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();
+}
+function createArrayGroupByTool() {
+  return 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(arrayGroupBySchema).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();
+}
+function createObjectPickTool() {
+  return 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(objectPickSchema).implement(async (input) => {
+    const picked = {};
+    for (const prop of input.properties) {
+      if (prop in input.object) {
+        picked[prop] = input.object[prop];
+      }
+    }
+    return picked;
+  }).build();
+}
+function createObjectOmitTool() {
+  return 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(objectOmitSchema).implement(async (input) => {
+    const omitted = { ...input.object };
+    for (const prop of input.properties) {
+      delete omitted[prop];
+    }
+    return omitted;
+  }).build();
+}
+
+// src/data/transformer/index.ts
+var arrayFilter = createArrayFilterTool();
+var arrayMap = createArrayMapTool();
+var arraySort = createArraySortTool();
+var arrayGroupBy = createArrayGroupByTool();
+var objectPick = createObjectPickTool();
+var objectOmit = createObjectOmitTool();
+var transformerTools = [arrayFilter, arrayMap, arraySort, arrayGroupBy, objectPick, objectOmit];
+function createTransformerTools(config = {}) {
+  return [
+    createArrayFilterTool(),
+    createArrayMapTool(),
+    createArraySortTool(),
+    createArrayGroupByTool(),
+    createObjectPickTool(),
+    createObjectOmitTool()
+  ];
+}
+var fileReaderSchema = 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")
-})).implementSafe(async (input) => {
-  const content = await fs.promises.readFile(input.path, input.encoding);
-  const stats = await fs.promises.stat(input.path);
-  return {
-    content,
-    size: stats.size,
-    path: input.path,
-    encoding: input.encoding
-  };
-}).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({
+});
+var fileWriterSchema = 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")
-})).implementSafe(async (input) => {
-  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 {
-    path: input.path,
-    size: stats.size,
-    encoding: input.encoding
-  };
-}).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({
+});
+var fileAppendSchema = 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")
-})).implementSafe(async (input) => {
-  await fs.promises.appendFile(input.path, input.content, input.encoding);
-  const stats = await fs.promises.stat(input.path);
-  return {
-    path: input.path,
-    size: stats.size
-  };
-}).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({
+});
+var fileDeleteSchema = zod.z.object({
   path: zod.z.string().describe("Path to the file to delete")
-})).implementSafe(async (input) => {
-  await fs.promises.unlink(input.path);
-  return {
-    path: input.path,
-    message: "File deleted successfully"
-  };
-}).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({
+});
+var fileExistsSchema = zod.z.object({
   path: zod.z.string().describe("Path to check")
-})).implement(async (input) => {
-  try {
-    await fs.promises.access(input.path);
+});
+function createFileReaderTool(defaultEncoding = "utf8") {
+  return 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(fileReaderSchema).implementSafe(async (input) => {
+    const encoding = input.encoding || defaultEncoding;
+    const content = await fs.promises.readFile(input.path, encoding);
+    const stats = await fs.promises.stat(input.path);
+    return {
+      content,
+      size: stats.size,
+      path: input.path,
+      encoding
+    };
+  }).build();
+}
+function createFileWriterTool(defaultEncoding = "utf8", createDirsDefault = false) {
+  return 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(fileWriterSchema).implementSafe(async (input) => {
+    const encoding = input.encoding || defaultEncoding;
+    const createDirs = input.createDirs ?? createDirsDefault;
+    if (createDirs) {
+      const dir = path7__namespace.dirname(input.path);
+      await fs.promises.mkdir(dir, { recursive: true });
+    }
+    await fs.promises.writeFile(input.path, input.content, encoding);
     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()
+      encoding
     };
-  } catch {
+  }).build();
+}
+function createFileAppendTool(defaultEncoding = "utf8") {
+  return 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(fileAppendSchema).implementSafe(async (input) => {
+    const encoding = input.encoding || defaultEncoding;
+    await fs.promises.appendFile(input.path, input.content, encoding);
+    const stats = await fs.promises.stat(input.path);
     return {
-      exists: false,
-      path: input.path
+      path: input.path,
+      size: stats.size
     };
-  }
-}).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({
+  }).build();
+}
+function createFileDeleteTool() {
+  return 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(fileDeleteSchema).implementSafe(async (input) => {
+    await fs.promises.unlink(input.path);
+    return {
+      path: input.path,
+      message: "File deleted successfully"
+    };
+  }).build();
+}
+function createFileExistsTool() {
+  return 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(fileExistsSchema).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();
+}
+
+// src/file/operations/index.ts
+var fileReader = createFileReaderTool();
+var fileWriter = createFileWriterTool();
+var fileAppend = createFileAppendTool();
+var fileDelete = createFileDeleteTool();
+var fileExists = createFileExistsTool();
+var fileOperationTools = [
+  fileReader,
+  fileWriter,
+  fileAppend,
+  fileDelete,
+  fileExists
+];
+function createFileOperationTools(config = {}) {
+  const {
+    defaultEncoding = "utf8",
+    createDirsDefault = false
+  } = config;
+  return [
+    createFileReaderTool(defaultEncoding),
+    createFileWriterTool(defaultEncoding, createDirsDefault),
+    createFileAppendTool(defaultEncoding),
+    createFileDeleteTool(),
+    createFileExistsTool()
+  ];
+}
+var directoryListSchema = 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")')
-})).implementSafe(async (input) => {
-  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 {
-    path: input.path,
-    files,
-    count: files.length
-  };
-}).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({
+});
+var directoryCreateSchema = 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")
-})).implementSafe(async (input) => {
-  await fs.promises.mkdir(input.path, { recursive: input.recursive });
-  return {
-    path: input.path,
-    message: "Directory created successfully"
-  };
-}).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({
+});
+var directoryDeleteSchema = 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")
-})).implementSafe(async (input) => {
-  await fs.promises.rm(input.path, { recursive: input.recursive, force: false });
-  return {
-    path: input.path,
-    message: "Directory deleted successfully"
-  };
-}).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({
+});
+var fileSearchSchema = 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")
-})).implementSafe(async (input) => {
-  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);
+});
+function createDirectoryListTool(defaultRecursive = false, defaultIncludeDetails = false) {
+  return 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(directoryListSchema).implementSafe(async (input) => {
+    const listFiles = async (dir, recursive2) => {
+      const entries = await fs.promises.readdir(dir, { withFileTypes: true });
+      const files2 = [];
+      for (const entry of entries) {
+        const fullPath = path7__namespace.join(dir, entry.name);
+        const relativePath = path7__namespace.relative(input.path, fullPath);
+        if (input.extension && !entry.name.endsWith(input.extension)) {
+          if (!entry.isDirectory() || !recursive2) {
+            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 (recursive2 && entry.isDirectory()) {
+          const subFiles = await listFiles(fullPath, true);
+          files2.push(...subFiles);
+        }
       }
-      if (input.recursive && entry.isDirectory()) {
-        const subMatches = await searchFiles(fullPath);
-        matches2.push(...subMatches);
+      return files2;
+    };
+    const recursive = input.recursive ?? defaultRecursive;
+    const files = await listFiles(input.path, recursive);
+    return {
+      path: input.path,
+      files,
+      count: files.length
+    };
+  }).build();
+}
+function createDirectoryCreateTool(defaultRecursive = true) {
+  return 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(directoryCreateSchema).implementSafe(async (input) => {
+    const recursive = input.recursive ?? defaultRecursive;
+    await fs.promises.mkdir(input.path, { recursive });
+    return {
+      path: input.path,
+      message: "Directory created successfully"
+    };
+  }).build();
+}
+function createDirectoryDeleteTool(defaultRecursive = false) {
+  return 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(directoryDeleteSchema).implementSafe(async (input) => {
+    const recursive = input.recursive ?? defaultRecursive;
+    await fs.promises.rm(input.path, { recursive, force: false });
+    return {
+      path: input.path,
+      message: "Directory deleted successfully"
+    };
+  }).build();
+}
+function createFileSearchTool(defaultRecursive = true, defaultCaseSensitive = false) {
+  return 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(fileSearchSchema).implementSafe(async (input) => {
+    const recursive = input.recursive ?? defaultRecursive;
+    const caseSensitive = input.caseSensitive ?? defaultCaseSensitive;
+    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}$`, caseSensitive ? "" : "i");
+      for (const entry of entries) {
+        const fullPath = path7__namespace.join(dir, entry.name);
+        if (entry.isFile() && regex.test(entry.name)) {
+          matches2.push(fullPath);
+        }
+        if (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 = 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({
+      return matches2;
+    };
+    const matches = await searchFiles(input.directory);
+    return {
+      directory: input.directory,
+      pattern: input.pattern,
+      matches,
+      count: matches.length
+    };
+  }).build();
+}
+
+// src/file/directory/index.ts
+var directoryList = createDirectoryListTool();
+var directoryCreate = createDirectoryCreateTool();
+var directoryDelete = createDirectoryDeleteTool();
+var fileSearch = createFileSearchTool();
+var directoryOperationTools = [
+  directoryList,
+  directoryCreate,
+  directoryDelete,
+  fileSearch
+];
+function createDirectoryOperationTools(config = {}) {
+  const {
+    defaultRecursive = false,
+    defaultIncludeDetails = false,
+    defaultCaseSensitive = false
+  } = config;
+  return [
+    createDirectoryListTool(defaultRecursive, defaultIncludeDetails),
+    createDirectoryCreateTool(true),
+    // Always default to true for create
+    createDirectoryDeleteTool(false),
+    // Always default to false for delete (safety)
+    createFileSearchTool(defaultRecursive, defaultCaseSensitive)
+  ];
+}
+var pathJoinSchema = 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({
+});
+var pathResolveSchema = 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({
+});
+var pathParseSchema = 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({
+});
+var pathBasenameSchema = 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({
+});
+var pathDirnameSchema = 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({
+});
+var pathExtensionSchema = 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({
+});
+var pathRelativeSchema = 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({
+});
+var pathNormalizeSchema = 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({
+});
+function createPathJoinTool() {
+  return 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(pathJoinSchema).implement(async (input) => {
+    const joined = path7__namespace.join(...input.segments);
+    return {
+      path: joined,
+      segments: input.segments
+    };
+  }).build();
+}
+function createPathResolveTool() {
+  return 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(pathResolveSchema).implement(async (input) => {
+    const resolved = path7__namespace.resolve(...input.paths);
+    return {
+      path: resolved,
+      isAbsolute: path7__namespace.isAbsolute(resolved)
+    };
+  }).build();
+}
+function createPathParseTool() {
+  return 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(pathParseSchema).implement(async (input) => {
+    const parsed = path7__namespace.parse(input.path);
+    return {
+      root: parsed.root,
+      dir: parsed.dir,
+      base: parsed.base,
+      name: parsed.name,
+      ext: parsed.ext,
+      isAbsolute: path7__namespace.isAbsolute(input.path)
+    };
+  }).build();
+}
+function createPathBasenameTool() {
+  return 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(pathBasenameSchema).implement(async (input) => {
+    const basename4 = input.removeExtension ? path7__namespace.basename(input.path, path7__namespace.extname(input.path)) : path7__namespace.basename(input.path);
+    return {
+      basename: basename4,
+      extension: path7__namespace.extname(input.path)
+    };
+  }).build();
+}
+function createPathDirnameTool() {
+  return 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(pathDirnameSchema).implement(async (input) => {
+    const dirname3 = path7__namespace.dirname(input.path);
+    return {
+      dirname: dirname3,
+      basename: path7__namespace.basename(input.path)
+    };
+  }).build();
+}
+function createPathExtensionTool() {
+  return 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(pathExtensionSchema).implement(async (input) => {
+    const ext = path7__namespace.extname(input.path);
+    return {
+      extension: ext,
+      hasExtension: ext.length > 0,
+      filename: path7__namespace.basename(input.path, ext)
+    };
+  }).build();
+}
+function createPathRelativeTool() {
+  return 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(pathRelativeSchema).implement(async (input) => {
+    const relative3 = path7__namespace.relative(input.from, input.to);
+    return {
+      relativePath: relative3,
+      from: input.from,
+      to: input.to
+    };
+  }).build();
+}
+function createPathNormalizeTool() {
+  return 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(pathNormalizeSchema).implement(async (input) => {
+    const normalized = path7__namespace.normalize(input.path);
+    return {
+      normalized,
+      original: input.path
+    };
+  }).build();
+}
+
+// src/file/path/index.ts
+var pathJoin = createPathJoinTool();
+var pathResolve = createPathResolveTool();
+var pathParse = createPathParseTool();
+var pathBasename = createPathBasenameTool();
+var pathDirname = createPathDirnameTool();
+var pathExtension = createPathExtensionTool();
+var pathRelative = createPathRelativeTool();
+var pathNormalize = createPathNormalizeTool();
+var pathUtilityTools = [
+  pathJoin,
+  pathResolve,
+  pathParse,
+  pathBasename,
+  pathDirname,
+  pathExtension,
+  pathRelative,
+  pathNormalize
+];
+function createPathUtilityTools(config = {}) {
+  return [
+    createPathJoinTool(),
+    createPathResolveTool(),
+    createPathParseTool(),
+    createPathBasenameTool(),
+    createPathDirnameTool(),
+    createPathExtensionTool(),
+    createPathRelativeTool(),
+    createPathNormalizeTool()
+  ];
+}
+var CurrentDateTimeSchema = 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({
+});
+var DateFormatterSchema = 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);
+});
+var DateArithmeticSchema = 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")
+});
+var DateDifferenceSchema = 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")
+});
+var DateComparisonSchema = zod.z.object({
+  date1: zod.z.string().describe("First date to compare"),
+  date2: zod.z.string().describe("Second date to compare")
+});
+
+// src/utility/date-time/tools/current-date-time.ts
+function createCurrentDateTimeTool() {
+  return 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(CurrentDateTimeSchema).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 {
-      date = new Date(input.date);
+      formatted = now.toISOString();
     }
-    if (!dateFns.isValid(date)) {
-      return {
-        success: false,
-        error: "Invalid date"
-      };
-    }
-    const formatted = dateFns.format(date, input.outputFormat);
     return {
-      success: true,
       formatted,
-      iso: date.toISOString()
+      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()
     };
-  } 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)) {
+  }).build();
+}
+function createDateFormatterTool() {
+  return 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(DateFormatterSchema).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: "Invalid date"
+        error: error instanceof Error ? error.message : "Failed to format 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)) {
+  }).build();
+}
+function createDateArithmeticTool() {
+  return 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(DateArithmeticSchema).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: "Invalid date(s)"
+        error: error instanceof Error ? error.message : "Failed to perform date arithmetic"
       };
     }
-    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);
+  }).build();
+}
+function createDateDifferenceTool() {
+  return 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(DateDifferenceSchema).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"
+      };
     }
-    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)) {
+  }).build();
+}
+function createDateComparisonTool() {
+  return 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(DateComparisonSchema).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: "Invalid date(s)"
+        error: error instanceof Error ? error.message : "Failed to compare dates"
       };
     }
-    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({
+  }).build();
+}
+
+// src/utility/date-time/index.ts
+var currentDateTime = createCurrentDateTimeTool();
+var dateFormatter = createDateFormatterTool();
+var dateArithmetic = createDateArithmeticTool();
+var dateDifference = createDateDifferenceTool();
+var dateComparison = createDateComparisonTool();
+var dateTimeTools = [
+  currentDateTime,
+  dateFormatter,
+  dateArithmetic,
+  dateDifference,
+  dateComparison
+];
+function createDateTimeTools(config = {}) {
+  return [
+    createCurrentDateTimeTool(),
+    createDateFormatterTool(),
+    createDateArithmeticTool(),
+    createDateDifferenceTool(),
+    createDateComparisonTool()
+  ];
+}
+var StringCaseConverterSchema = 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({
+});
+var StringTrimSchema = 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({
+});
+var StringReplaceSchema = 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({
+});
+var StringSplitSchema = 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({
+});
+var StringJoinSchema = 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({
+});
+var StringSubstringSchema = 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({
+});
+var StringLengthSchema = 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({
+});
+
+// src/utility/string/tools/string-case-converter.ts
+function createStringCaseConverterTool() {
+  return 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(StringCaseConverterSchema).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();
+}
+function createStringTrimTool() {
+  return 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(StringTrimSchema).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();
+}
+function createStringReplaceTool() {
+  return 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(StringReplaceSchema).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();
+}
+function createStringSplitTool() {
+  return 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(StringSplitSchema).implement(async (input) => {
+    const parts = input.text.split(input.delimiter, input.limit);
+    return {
+      parts,
+      count: parts.length
+    };
+  }).build();
+}
+function createStringJoinTool() {
+  return 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(StringJoinSchema).implement(async (input) => {
+    const result = input.parts.join(input.separator);
+    return {
+      result,
+      partCount: input.parts.length,
+      length: result.length
+    };
+  }).build();
+}
+function createStringSubstringTool() {
+  return 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(StringSubstringSchema).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();
+}
+function createStringLengthTool() {
+  return 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(StringLengthSchema).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();
+}
+
+// src/utility/string/index.ts
+var stringCaseConverter = createStringCaseConverterTool();
+var stringTrim = createStringTrimTool();
+var stringReplace = createStringReplaceTool();
+var stringSplit = createStringSplitTool();
+var stringJoin = createStringJoinTool();
+var stringSubstring = createStringSubstringTool();
+var stringLength = createStringLengthTool();
+var stringUtilityTools = [
+  stringCaseConverter,
+  stringTrim,
+  stringReplace,
+  stringSplit,
+  stringJoin,
+  stringSubstring,
+  stringLength
+];
+function createStringUtilityTools(config = {}) {
+  return [
+    createStringCaseConverterTool(),
+    createStringTrimTool(),
+    createStringReplaceTool(),
+    createStringSplitTool(),
+    createStringJoinTool(),
+    createStringSubstringTool(),
+    createStringLengthTool()
+  ];
+}
+var CalculatorSchema = 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({
+});
+var MathFunctionsSchema = 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);
+});
+var RandomNumberSchema = 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)")
+});
+var StatisticsSchema = zod.z.object({
+  numbers: zod.z.array(zod.z.number().describe("Number value")).describe("Array of numbers to analyze")
+});
+
+// src/utility/math/tools/calculator.ts
+function createCalculatorTool() {
+  return core.toolBuilder().name("calculator").description("Perform basic arithmetic operations: add, subtract, multiply, divide, power, modulo.").category(core.ToolCategory.UTILITY).tags(["math", "calculator", "arithmetic"]).schema(CalculatorSchema).implement(async (input) => {
+    let result;
+    switch (input.operation) {
+      case "add":
+        result = input.a + input.b;
         break;
-      case "sin":
-        result = Math.sin(input.value);
+      case "subtract":
+        result = input.a - input.b;
         break;
-      case "cos":
-        result = Math.cos(input.value);
+      case "multiply":
+        result = input.a * input.b;
         break;
-      case "tan":
-        result = Math.tan(input.value);
+      case "divide":
+        if (input.b === 0) {
+          return {
+            success: false,
+            error: "Division by zero"
+          };
+        }
+        result = input.a / input.b;
         break;
-      case "log":
-        result = Math.log(input.value);
+      case "power":
+        result = Math.pow(input.a, input.b);
         break;
-      case "exp":
-        result = Math.exp(input.value);
+      case "modulo":
+        result = input.a % input.b;
         break;
       default:
         return {
           success: false,
-          error: "Unknown function"
+          error: "Unknown operation"
         };
     }
-    if (isNaN(result) || !isFinite(result)) {
+    return {
+      success: true,
+      result,
+      operation: input.operation,
+      a: input.a,
+      b: input.b
+    };
+  }).build();
+}
+function createMathFunctionsTool() {
+  return 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(MathFunctionsSchema).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: "Invalid result (NaN or Infinity)"
+        error: error instanceof Error ? error.message : "Math operation failed"
       };
     }
+  }).build();
+}
+function createRandomNumberTool() {
+  return 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(RandomNumberSchema).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 {
-      success: true,
       result,
-      function: input.function,
-      input: input.value
-    };
-  } catch (error) {
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : "Math operation failed"
+      min,
+      max,
+      integer
     };
-  }
-}).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) {
+  }).build();
+}
+function createStatisticsTool() {
+  return 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(StatisticsSchema).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: false,
-      error: "Empty array"
+      success: true,
+      count: input.numbers.length,
+      sum,
+      average,
+      min,
+      max,
+      median,
+      standardDeviation: stdDev,
+      variance
     };
-  }
-  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({
+  }).build();
+}
+
+// src/utility/math/index.ts
+var calculator = createCalculatorTool();
+var mathFunctions = createMathFunctionsTool();
+var randomNumber = createRandomNumberTool();
+var statistics = createStatisticsTool();
+var mathOperationTools = [
+  calculator,
+  mathFunctions,
+  randomNumber,
+  statistics
+];
+function createMathOperationTools(config = {}) {
+  return [
+    createCalculatorTool(),
+    createMathFunctionsTool(),
+    createRandomNumberTool(),
+    createStatisticsTool()
+  ];
+}
+var EmailValidatorSchema = 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({
+});
+var UrlValidatorSimpleSchema = zod.z.object({
   url: zod.z.string().describe("URL to validate")
-})).implement(async (input) => {
-  try {
-    new URL(input.url);
+});
+var PhoneValidatorSchema = 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)")
+});
+var CreditCardValidatorSchema = zod.z.object({
+  cardNumber: zod.z.string().describe("Credit card number to validate")
+});
+var IpValidatorSchema = 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")
+});
+var UuidValidatorSchema = zod.z.object({
+  uuid: zod.z.string().describe("UUID to validate")
+});
+
+// src/utility/validation/tools/email-validator.ts
+function createEmailValidatorTool() {
+  return 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(EmailValidatorSchema).implement(async (input) => {
+    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    const valid = emailRegex.test(input.email);
     return {
-      valid: true,
-      url: input.url,
-      message: "Valid URL"
+      valid,
+      email: input.email,
+      message: valid ? "Valid email address" : "Invalid email address format"
     };
-  } catch {
+  }).build();
+}
+function createUrlValidatorSimpleTool() {
+  return 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(UrlValidatorSimpleSchema).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();
+}
+function createPhoneValidatorTool() {
+  return 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(PhoneValidatorSchema).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: false,
-      url: input.url,
-      message: "Invalid URL format"
+      valid,
+      phone: input.phone,
+      message: valid ? "Valid phone number format" : "Invalid phone number 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)) {
+  }).build();
+}
+function createCreditCardValidatorTool() {
+  return 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(CreditCardValidatorSchema).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: false,
-      message: "Card number must contain only digits"
+      valid,
+      cardNumber: input.cardNumber,
+      message: valid ? "Valid credit card number" : "Invalid credit card number (failed Luhn check)"
     };
-  }
-  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;
+  }).build();
+}
+function createIpValidatorTool() {
+  return 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(IpValidatorSchema).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";
       }
     }
-    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";
+      }
     }
-  }
-  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();
+}
+function createUuidValidatorTool() {
+  return 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(UuidValidatorSchema).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,
-    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();
+    return {
+      valid,
+      uuid: input.uuid,
+      version,
+      message: valid ? `Valid UUID v${version}` : "Invalid UUID format"
+    };
+  }).build();
+}
+
+// src/utility/validation/index.ts
+var emailValidator = createEmailValidatorTool();
+var urlValidatorSimple = createUrlValidatorSimpleTool();
+var phoneValidator = createPhoneValidatorTool();
+var creditCardValidator = createCreditCardValidatorTool();
+var ipValidator = createIpValidatorTool();
+var uuidValidator = createUuidValidatorTool();
+var validationTools = [
+  emailValidator,
+  urlValidatorSimple,
+  phoneValidator,
+  creditCardValidator,
+  ipValidator,
+  uuidValidator
+];
+function createValidationTools(config = {}) {
+  return [
+    createEmailValidatorTool(),
+    createUrlValidatorSimpleTool(),
+    createPhoneValidatorTool(),
+    createCreditCardValidatorTool(),
+    createIpValidatorTool(),
+    createUuidValidatorTool()
+  ];
+}
 var AskHumanInputSchema = zod.z.object({
   /**
    * The question to ask the human
@@ -2848,74 +3265,226 @@ function createAskHumanTool() {
 var askHumanTool = createAskHumanTool();
 
 exports.AskHumanInputSchema = AskHumanInputSchema;
+exports.CalculatorSchema = CalculatorSchema;
+exports.CreditCardValidatorSchema = CreditCardValidatorSchema;
+exports.CurrentDateTimeSchema = CurrentDateTimeSchema;
+exports.DateArithmeticSchema = DateArithmeticSchema;
+exports.DateComparisonSchema = DateComparisonSchema;
+exports.DateDifferenceSchema = DateDifferenceSchema;
+exports.DateFormatterSchema = DateFormatterSchema;
 exports.DuckDuckGoProvider = DuckDuckGoProvider;
+exports.EmailValidatorSchema = EmailValidatorSchema;
+exports.HttpMethod = HttpMethod;
+exports.IpValidatorSchema = IpValidatorSchema;
+exports.MathFunctionsSchema = MathFunctionsSchema;
+exports.PhoneValidatorSchema = PhoneValidatorSchema;
+exports.RandomNumberSchema = RandomNumberSchema;
 exports.SerperProvider = SerperProvider;
+exports.StatisticsSchema = StatisticsSchema;
+exports.StringCaseConverterSchema = StringCaseConverterSchema;
+exports.StringJoinSchema = StringJoinSchema;
+exports.StringLengthSchema = StringLengthSchema;
+exports.StringReplaceSchema = StringReplaceSchema;
+exports.StringSplitSchema = StringSplitSchema;
+exports.StringSubstringSchema = StringSubstringSchema;
+exports.StringTrimSchema = StringTrimSchema;
+exports.UrlValidatorSimpleSchema = UrlValidatorSimpleSchema;
+exports.UuidValidatorSchema = UuidValidatorSchema;
 exports.archiveConfluencePage = archiveConfluencePage;
 exports.arrayFilter = arrayFilter;
+exports.arrayFilterSchema = arrayFilterSchema;
 exports.arrayGroupBy = arrayGroupBy;
+exports.arrayGroupBySchema = arrayGroupBySchema;
 exports.arrayMap = arrayMap;
+exports.arrayMapSchema = arrayMapSchema;
 exports.arraySort = arraySort;
+exports.arraySortSchema = arraySortSchema;
 exports.askHumanTool = askHumanTool;
 exports.calculator = calculator;
 exports.confluenceTools = confluenceTools;
+exports.createArrayFilterTool = createArrayFilterTool;
+exports.createArrayGroupByTool = createArrayGroupByTool;
+exports.createArrayMapTool = createArrayMapTool;
+exports.createArraySortTool = createArraySortTool;
 exports.createAskHumanTool = createAskHumanTool;
+exports.createCalculatorTool = createCalculatorTool;
 exports.createConfluencePage = createConfluencePage;
 exports.createConfluenceTools = createConfluenceTools;
+exports.createCreditCardValidatorTool = createCreditCardValidatorTool;
+exports.createCsvGeneratorTool = createCsvGeneratorTool;
+exports.createCsvParserTool = createCsvParserTool;
+exports.createCsvToJsonTool = createCsvToJsonTool;
+exports.createCsvTools = createCsvTools;
+exports.createCurrentDateTimeTool = createCurrentDateTimeTool;
+exports.createDateArithmeticTool = createDateArithmeticTool;
+exports.createDateComparisonTool = createDateComparisonTool;
+exports.createDateDifferenceTool = createDateDifferenceTool;
+exports.createDateFormatterTool = createDateFormatterTool;
+exports.createDateTimeTools = createDateTimeTools;
+exports.createDirectoryCreateTool = createDirectoryCreateTool;
+exports.createDirectoryDeleteTool = createDirectoryDeleteTool;
+exports.createDirectoryListTool = createDirectoryListTool;
+exports.createDirectoryOperationTools = createDirectoryOperationTools;
 exports.createDuckDuckGoProvider = createDuckDuckGoProvider;
+exports.createEmailValidatorTool = createEmailValidatorTool;
+exports.createExtractImagesTool = createExtractImagesTool;
+exports.createExtractLinksTool = createExtractLinksTool;
+exports.createFileAppendTool = createFileAppendTool;
+exports.createFileDeleteTool = createFileDeleteTool;
+exports.createFileExistsTool = createFileExistsTool;
+exports.createFileOperationTools = createFileOperationTools;
+exports.createFileReaderTool = createFileReaderTool;
+exports.createFileSearchTool = createFileSearchTool;
+exports.createFileWriterTool = createFileWriterTool;
+exports.createHtmlParserTool = createHtmlParserTool;
+exports.createHtmlParserTools = createHtmlParserTools;
+exports.createHttpTools = createHttpTools;
+exports.createIpValidatorTool = createIpValidatorTool;
+exports.createJsonMergeTool = createJsonMergeTool;
+exports.createJsonParserTool = createJsonParserTool;
+exports.createJsonQueryTool = createJsonQueryTool;
+exports.createJsonStringifyTool = createJsonStringifyTool;
+exports.createJsonToCsvTool = createJsonToCsvTool;
+exports.createJsonToXmlTool = createJsonToXmlTool;
+exports.createJsonTools = createJsonTools;
+exports.createJsonValidatorTool = createJsonValidatorTool;
+exports.createMathFunctionsTool = createMathFunctionsTool;
+exports.createMathOperationTools = createMathOperationTools;
+exports.createObjectOmitTool = createObjectOmitTool;
+exports.createObjectPickTool = createObjectPickTool;
+exports.createPathBasenameTool = createPathBasenameTool;
+exports.createPathDirnameTool = createPathDirnameTool;
+exports.createPathExtensionTool = createPathExtensionTool;
+exports.createPathJoinTool = createPathJoinTool;
+exports.createPathNormalizeTool = createPathNormalizeTool;
+exports.createPathParseTool = createPathParseTool;
+exports.createPathRelativeTool = createPathRelativeTool;
+exports.createPathResolveTool = createPathResolveTool;
+exports.createPathUtilityTools = createPathUtilityTools;
+exports.createPhoneValidatorTool = createPhoneValidatorTool;
+exports.createRandomNumberTool = createRandomNumberTool;
+exports.createScraperTools = createScraperTools;
 exports.createSerperProvider = createSerperProvider;
 exports.createSlackTools = createSlackTools;
+exports.createStatisticsTool = createStatisticsTool;
+exports.createStringCaseConverterTool = createStringCaseConverterTool;
+exports.createStringJoinTool = createStringJoinTool;
+exports.createStringLengthTool = createStringLengthTool;
+exports.createStringReplaceTool = createStringReplaceTool;
+exports.createStringSplitTool = createStringSplitTool;
+exports.createStringSubstringTool = createStringSubstringTool;
+exports.createStringTrimTool = createStringTrimTool;
+exports.createStringUtilityTools = createStringUtilityTools;
+exports.createTransformerTools = createTransformerTools;
+exports.createUrlBuilderTool = createUrlBuilderTool;
+exports.createUrlQueryParserTool = createUrlQueryParserTool;
+exports.createUrlValidatorSimpleTool = createUrlValidatorSimpleTool;
+exports.createUrlValidatorTool = createUrlValidatorTool;
+exports.createUrlValidatorTools = createUrlValidatorTools;
+exports.createUuidValidatorTool = createUuidValidatorTool;
+exports.createValidationTools = createValidationTools;
+exports.createWebScraperTool = createWebScraperTool;
+exports.createXmlGeneratorTool = createXmlGeneratorTool;
+exports.createXmlParserTool = createXmlParserTool;
+exports.createXmlToJsonTool = createXmlToJsonTool;
+exports.createXmlTools = createXmlTools;
 exports.creditCardValidator = creditCardValidator;
 exports.csvGenerator = csvGenerator;
+exports.csvGeneratorSchema = csvGeneratorSchema;
 exports.csvParser = csvParser;
+exports.csvParserSchema = csvParserSchema;
 exports.csvToJson = csvToJson;
+exports.csvToJsonSchema = csvToJsonSchema;
+exports.csvTools = csvTools;
 exports.currentDateTime = currentDateTime;
 exports.dateArithmetic = dateArithmetic;
 exports.dateComparison = dateComparison;
 exports.dateDifference = dateDifference;
 exports.dateFormatter = dateFormatter;
+exports.dateTimeTools = dateTimeTools;
 exports.directoryCreate = directoryCreate;
+exports.directoryCreateSchema = directoryCreateSchema;
 exports.directoryDelete = directoryDelete;
+exports.directoryDeleteSchema = directoryDeleteSchema;
 exports.directoryList = directoryList;
+exports.directoryListSchema = directoryListSchema;
+exports.directoryOperationTools = directoryOperationTools;
 exports.emailValidator = emailValidator;
 exports.extractImages = extractImages;
+exports.extractImagesSchema = extractImagesSchema;
 exports.extractLinks = extractLinks;
+exports.extractLinksSchema = extractLinksSchema;
 exports.fileAppend = fileAppend;
+exports.fileAppendSchema = fileAppendSchema;
 exports.fileDelete = fileDelete;
+exports.fileDeleteSchema = fileDeleteSchema;
 exports.fileExists = fileExists;
+exports.fileExistsSchema = fileExistsSchema;
+exports.fileOperationTools = fileOperationTools;
 exports.fileReader = fileReader;
+exports.fileReaderSchema = fileReaderSchema;
 exports.fileSearch = fileSearch;
+exports.fileSearchSchema = fileSearchSchema;
 exports.fileWriter = fileWriter;
+exports.fileWriterSchema = fileWriterSchema;
 exports.getConfluencePage = getConfluencePage;
 exports.getSlackChannels = getSlackChannels;
 exports.getSlackMessages = getSlackMessages;
 exports.getSpacePages = getSpacePages;
 exports.htmlParser = htmlParser;
+exports.htmlParserSchema = htmlParserSchema;
+exports.htmlParserTools = htmlParserTools;
 exports.httpClient = httpClient;
 exports.httpGet = httpGet;
+exports.httpGetSchema = httpGetSchema;
 exports.httpPost = httpPost;
+exports.httpPostSchema = httpPostSchema;
+exports.httpRequestSchema = httpRequestSchema;
+exports.httpTools = httpTools;
 exports.ipValidator = ipValidator;
 exports.jsonMerge = jsonMerge;
+exports.jsonMergeSchema = jsonMergeSchema;
 exports.jsonParser = jsonParser;
+exports.jsonParserSchema = jsonParserSchema;
 exports.jsonQuery = jsonQuery;
+exports.jsonQuerySchema = jsonQuerySchema;
 exports.jsonStringify = jsonStringify;
+exports.jsonStringifySchema = jsonStringifySchema;
 exports.jsonToCsv = jsonToCsv;
+exports.jsonToCsvSchema = jsonToCsvSchema;
 exports.jsonToXml = jsonToXml;
+exports.jsonToXmlSchema = jsonToXmlSchema;
+exports.jsonTools = jsonTools;
 exports.jsonValidator = jsonValidator;
+exports.jsonValidatorSchema = jsonValidatorSchema;
 exports.listConfluenceSpaces = listConfluenceSpaces;
 exports.mathFunctions = mathFunctions;
+exports.mathOperationTools = mathOperationTools;
 exports.notifySlack = notifySlack;
 exports.objectOmit = objectOmit;
+exports.objectOmitSchema = objectOmitSchema;
 exports.objectPick = objectPick;
+exports.objectPickSchema = objectPickSchema;
 exports.pathBasename = pathBasename;
+exports.pathBasenameSchema = pathBasenameSchema;
 exports.pathDirname = pathDirname;
+exports.pathDirnameSchema = pathDirnameSchema;
 exports.pathExtension = pathExtension;
+exports.pathExtensionSchema = pathExtensionSchema;
 exports.pathJoin = pathJoin;
+exports.pathJoinSchema = pathJoinSchema;
 exports.pathNormalize = pathNormalize;
+exports.pathNormalizeSchema = pathNormalizeSchema;
 exports.pathParse = pathParse;
+exports.pathParseSchema = pathParseSchema;
 exports.pathRelative = pathRelative;
+exports.pathRelativeSchema = pathRelativeSchema;
 exports.pathResolve = pathResolve;
+exports.pathResolveSchema = pathResolveSchema;
+exports.pathUtilityTools = pathUtilityTools;
 exports.phoneValidator = phoneValidator;
 exports.randomNumber = randomNumber;
+exports.scraperTools = scraperTools;
 exports.searchConfluence = searchConfluence;
 exports.searchResultSchema = searchResultSchema;
 exports.sendSlackMessage = sendSlackMessage;
@@ -2928,18 +3497,30 @@ exports.stringReplace = stringReplace;
 exports.stringSplit = stringSplit;
 exports.stringSubstring = stringSubstring;
 exports.stringTrim = stringTrim;
+exports.stringUtilityTools = stringUtilityTools;
+exports.transformerTools = transformerTools;
 exports.updateConfluencePage = updateConfluencePage;
 exports.urlBuilder = urlBuilder;
+exports.urlBuilderSchema = urlBuilderSchema;
 exports.urlQueryParser = urlQueryParser;
+exports.urlQueryParserSchema = urlQueryParserSchema;
 exports.urlValidator = urlValidator;
+exports.urlValidatorSchema = urlValidatorSchema;
 exports.urlValidatorSimple = urlValidatorSimple;
+exports.urlValidatorTools = urlValidatorTools;
 exports.uuidValidator = uuidValidator;
+exports.validationTools = validationTools;
 exports.webScraper = webScraper;
+exports.webScraperSchema = webScraperSchema;
 exports.webSearch = webSearch;
 exports.webSearchOutputSchema = webSearchOutputSchema;
 exports.webSearchSchema = webSearchSchema;
 exports.xmlGenerator = xmlGenerator;
+exports.xmlGeneratorSchema = xmlGeneratorSchema;
 exports.xmlParser = xmlParser;
+exports.xmlParserSchema = xmlParserSchema;
 exports.xmlToJson = xmlToJson;
+exports.xmlToJsonSchema = xmlToJsonSchema;
+exports.xmlTools = xmlTools;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map