@agentforge/tools 0.9.1 → 0.10.1

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,6 +978,36 @@ function createSlackTools(config = {}) {
       throw error;
     }
   }).build();
+}
+
+// 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,
@@ -1057,1205 +1015,2164 @@ function createSlackTools(config = {}) {
     getMessages
   };
 }
-var slackTools = [sendSlackMessage, notifySlack, getSlackChannels, getSlackMessages];
-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
+
+// 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."
+      );
+    }
+    return { ATLASSIAN_API_KEY, ATLASSIAN_EMAIL, ATLASSIAN_SITE_URL };
   };
-}).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
+}
+function createGetConfiguredAuthHeader(getConfiguredAuth) {
+  return function getConfiguredAuthHeader() {
+    const { ATLASSIAN_API_KEY, ATLASSIAN_EMAIL } = getConfiguredAuth();
+    const auth = Buffer.from(`${ATLASSIAN_EMAIL}:${ATLASSIAN_API_KEY}`).toString("base64");
+    return `Basic ${auth}`;
   };
-}).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];
+}
+function getConfig() {
+  const ATLASSIAN_API_KEY = process.env.ATLASSIAN_API_KEY || "";
+  const ATLASSIAN_EMAIL = process.env.ATLASSIAN_EMAIL || "";
+  const ATLASSIAN_SITE_URL = (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 .env");
+  }
+  return { ATLASSIAN_API_KEY, ATLASSIAN_EMAIL, ATLASSIAN_SITE_URL };
+}
+function getAuthHeader() {
+  const { ATLASSIAN_API_KEY, ATLASSIAN_EMAIL } = getConfig();
+  const auth = Buffer.from(`${ATLASSIAN_EMAIL}:${ATLASSIAN_API_KEY}`).toString("base64");
+  return `Basic ${auth}`;
+}
+function createSearchConfluenceTool(getAuth, getAuthHeader2, logger4) {
+  return core.toolBuilder().name("search-confluence").description("Search for pages in Confluence using keywords or CQL (Confluence Query Language). Returns matching pages with titles, IDs, and excerpts.").category(core.ToolCategory.WEB).tag("confluence").tag("search").tag("knowledge-base").usageNotes("Use this to find relevant documentation, policies, or information in Confluence. You can search by keywords or use CQL for advanced queries (e.g., 'space=AI AND type=page'). Use get-confluence-page to retrieve full content of specific pages.").suggests(["get-confluence-page"]).schema(zod.z.object({
+    query: zod.z.string().describe("Search query or CQL expression (e.g., 'payment processing' or 'space=BL3 AND title~payment')"),
+    limit: zod.z.number().optional().describe("Maximum number of results to return (default: 10, max: 25)")
+  })).implement(async ({ query, limit = 10 }) => {
+    logger4.info("search-confluence called", { query, limit });
+    try {
+      const { ATLASSIAN_SITE_URL } = getAuth();
+      const response = await axios12__default.default.get(`${ATLASSIAN_SITE_URL}/wiki/rest/api/content/search`, {
+        headers: {
+          Authorization: getAuthHeader2(),
+          Accept: "application/json"
+        },
+        params: {
+          cql: query,
+          limit: Math.min(limit, 25),
+          expand: "space,version"
+        }
+      });
+      const { ATLASSIAN_SITE_URL: siteUrl } = getAuth();
+      const results = response.data.results.map((page) => ({
+        id: page.id,
+        title: page.title,
+        type: page.type,
+        space: page.space?.name || "Unknown",
+        spaceKey: page.space?.key || "",
+        url: `${siteUrl}/wiki${page._links.webui}`,
+        lastModified: page.version?.when || ""
+      }));
+      if (results.length === 0) {
+        logger4.warn("search-confluence returned NO RESULTS - this is a valid outcome, agent should not retry", {
+          query,
+          limit,
+          totalSize: response.data.totalSize
+        });
+      } else {
+        logger4.info("search-confluence result", {
+          query,
+          resultCount: results.length,
+          totalSize: response.data.totalSize,
+          titles: results.map((r) => r.title).slice(0, 3)
+          // Log first 3 titles
+        });
+      }
+      return JSON.stringify({
+        success: true,
+        count: results.length,
+        total: response.data.totalSize,
+        results
+      });
+    } catch (error) {
+      logger4.error("search-confluence error", {
+        query,
+        error: error.response?.data?.message || error.message,
+        status: error.response?.status
+      });
+      return JSON.stringify({
+        success: false,
+        error: error.response?.data?.message || error.message
+      });
     }
-    if (current === void 0) {
-      throw new Error(`Path not found: ${input.path}`);
+  }).build();
+}
+function createGetConfluencePageTool(getAuth, getAuthHeader2, logger4) {
+  return core.toolBuilder().name("get-confluence-page").description("Get the full content of a specific Confluence page by its ID. Returns the page title, content (in storage format), space, and metadata.").category(core.ToolCategory.WEB).tag("confluence").tag("page").tag("content").usageNotes("Use this after search-confluence to retrieve the full content of a specific page. The page ID can be found in search results.").requires(["search-confluence"]).schema(zod.z.object({
+    page_id: zod.z.string().describe("The Confluence page ID (from search results)")
+  })).implement(async ({ page_id }) => {
+    logger4.info("get-confluence-page called", { page_id });
+    try {
+      const { ATLASSIAN_SITE_URL } = getAuth();
+      const response = await axios12__default.default.get(`${ATLASSIAN_SITE_URL}/wiki/rest/api/content/${page_id}`, {
+        headers: {
+          Authorization: getAuthHeader2(),
+          Accept: "application/json"
+        },
+        params: {
+          expand: "body.storage,space,version,history"
+        }
+      });
+      const page = response.data;
+      logger4.info("get-confluence-page result", {
+        page_id,
+        title: page.title,
+        space: page.space?.name,
+        contentLength: page.body?.storage?.value?.length || 0
+      });
+      return JSON.stringify({
+        success: true,
+        page: {
+          id: page.id,
+          title: page.title,
+          type: page.type,
+          space: page.space?.name || "Unknown",
+          spaceKey: page.space?.key || "",
+          content: page.body?.storage?.value || "",
+          url: `${ATLASSIAN_SITE_URL}/wiki${page._links.webui}`,
+          created: page.history?.createdDate || "",
+          lastModified: page.version?.when || "",
+          version: page.version?.number || 1
+        }
+      });
+    } catch (error) {
+      logger4.error("get-confluence-page error", {
+        page_id,
+        error: error.response?.data?.message || error.message,
+        status: error.response?.status
+      });
+      return JSON.stringify({
+        success: false,
+        error: error.response?.data?.message || error.message
+      });
     }
-  }
-  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];
+  }).build();
+}
+function createListConfluenceSpacesTool(getAuth, getAuthHeader2, logger4) {
+  return core.toolBuilder().name("list-confluence-spaces").description("List all available Confluence spaces. Returns space names, keys, types, and descriptions to help identify where to search for information.").category(core.ToolCategory.WEB).tag("confluence").tag("spaces").tag("list").usageNotes("Use this first to discover available spaces before searching. Helps narrow down searches to specific areas (e.g., 'AI', 'BL3', 'Finance').").follows(["search-confluence"]).schema(zod.z.object({
+    limit: zod.z.number().optional().describe("Maximum number of spaces to return (default: 25)")
+  })).implement(async ({ limit = 25 }) => {
+    logger4.info("list-confluence-spaces called", { limit });
+    try {
+      const { ATLASSIAN_SITE_URL } = getAuth();
+      const response = await axios12__default.default.get(`${ATLASSIAN_SITE_URL}/wiki/rest/api/space`, {
+        headers: {
+          Authorization: getAuthHeader2(),
+          Accept: "application/json"
+        },
+        params: {
+          limit
+        }
+      });
+      const spaces = response.data.results.map((space) => ({
+        key: space.key,
+        name: space.name,
+        type: space.type,
+        description: space.description?.plain?.value || "",
+        url: `${ATLASSIAN_SITE_URL}/wiki${space._links.webui}`
+      }));
+      logger4.info("list-confluence-spaces result", {
+        spaceCount: spaces.length,
+        spaceKeys: spaces.map((s) => s.key).slice(0, 5)
+        // Log first 5 space keys
+      });
+      return JSON.stringify({
+        success: true,
+        count: spaces.length,
+        spaces
+      });
+    } catch (error) {
+      logger4.error("list-confluence-spaces error", {
+        error: error.response?.data?.message || error.message,
+        status: error.response?.status
+      });
+      return JSON.stringify({
+        success: false,
+        error: error.response?.data?.message || error.message
+      });
+    }
+  }).build();
+}
+function createGetSpacePagesTool(getAuth, getAuthHeader2, logger4) {
+  return core.toolBuilder().name("get-space-pages").description("Get all pages from a specific Confluence space by space key. Useful for browsing content in a particular area.").category(core.ToolCategory.WEB).tag("confluence").tag("space").tag("pages").usageNotes("Use this to explore all pages in a specific space. Get the space key from list-confluence-spaces first.").requires(["list-confluence-spaces"]).schema(zod.z.object({
+    space_key: zod.z.string().describe("The space key (e.g., 'AI', 'BL3', 'FIN')"),
+    limit: zod.z.number().optional().describe("Maximum number of pages to return (default: 25)")
+  })).implement(async ({ space_key, limit = 25 }) => {
+    logger4.info("get-space-pages called", { space_key, limit });
+    try {
+      const { ATLASSIAN_SITE_URL } = getAuth();
+      const response = await axios12__default.default.get(`${ATLASSIAN_SITE_URL}/wiki/rest/api/content`, {
+        headers: {
+          Authorization: getAuthHeader2(),
+          Accept: "application/json"
+        },
+        params: {
+          spaceKey: space_key,
+          type: "page",
+          limit,
+          expand: "version"
         }
+      });
+      const pages = response.data.results.map((page) => ({
+        id: page.id,
+        title: page.title,
+        url: `${ATLASSIAN_SITE_URL}/wiki${page._links.webui}`,
+        lastModified: page.version?.when || ""
+      }));
+      if (pages.length === 0) {
+        logger4.warn("get-space-pages returned NO PAGES - this is a valid outcome, agent should not retry", {
+          space_key,
+          limit
+        });
+      } else {
+        logger4.info("get-space-pages result", {
+          space_key,
+          pageCount: pages.length,
+          titles: pages.map((p) => p.title).slice(0, 3)
+          // Log first 3 titles
+        });
       }
-      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({
+      return JSON.stringify({
+        success: true,
+        space: space_key,
+        count: pages.length,
+        pages
+      });
+    } catch (error) {
+      logger4.error("get-space-pages error", {
+        space_key,
+        error: error.response?.data?.message || error.message,
+        status: error.response?.status
+      });
+      return JSON.stringify({
+        success: false,
+        error: error.response?.data?.message || error.message
+      });
+    }
+  }).build();
+}
+function createCreateConfluencePageTool(getAuth, getAuthHeader2, logger4) {
+  return core.toolBuilder().name("create-confluence-page").description("Create a new page in a Confluence space. Requires space key, page title, and content (in HTML storage format).").category(core.ToolCategory.WEB).tag("confluence").tag("create").tag("write").usageNotes("Use this to create new documentation pages. Content should be in Confluence storage format (HTML). Get the space key from list-confluence-spaces first. Be mindful of creating duplicate pages.").requires(["list-confluence-spaces"]).schema(zod.z.object({
+    space_key: zod.z.string().describe("The space key where the page will be created (e.g., 'AI', 'BL3')"),
+    title: zod.z.string().describe("The title of the new page"),
+    content: zod.z.string().describe("The page content in HTML format (Confluence storage format)"),
+    parent_page_id: zod.z.string().optional().describe("Optional parent page ID to create this as a child page")
+  })).implement(async ({ space_key, title, content, parent_page_id }) => {
+    logger4.info("create-confluence-page called", { space_key, title, hasParent: !!parent_page_id });
+    try {
+      const { ATLASSIAN_SITE_URL } = getAuth();
+      const pageData = {
+        type: "page",
+        title,
+        space: { key: space_key },
+        body: {
+          storage: {
+            value: content,
+            representation: "storage"
+          }
+        }
+      };
+      if (parent_page_id) {
+        pageData.ancestors = [{ id: parent_page_id }];
+      }
+      const response = await axios12__default.default.post(
+        `${ATLASSIAN_SITE_URL}/wiki/rest/api/content`,
+        pageData,
+        {
+          headers: {
+            Authorization: getAuthHeader2(),
+            "Content-Type": "application/json"
+          }
+        }
+      );
+      logger4.info("create-confluence-page result", {
+        page_id: response.data.id,
+        title: response.data.title,
+        space: space_key
+      });
+      return JSON.stringify({
+        success: true,
+        page: {
+          id: response.data.id,
+          title: response.data.title,
+          space: space_key,
+          url: `${ATLASSIAN_SITE_URL}/wiki${response.data._links.webui}`,
+          version: response.data.version?.number || 1
+        }
+      });
+    } catch (error) {
+      logger4.error("create-confluence-page error", {
+        space_key,
+        title,
+        error: error.response?.data?.message || error.message,
+        status: error.response?.status
+      });
+      return JSON.stringify({
+        success: false,
+        error: error.response?.data?.message || error.message
+      });
+    }
+  }).build();
+}
+function createUpdateConfluencePageTool(getAuth, getAuthHeader2, logger4) {
+  return core.toolBuilder().name("update-confluence-page").description("Update an existing Confluence page's content. Requires page ID, new title, and new content.").category(core.ToolCategory.WEB).tag("confluence").tag("update").tag("write").usageNotes("Use this to update existing documentation. You must provide the page ID (from search results). The tool will automatically handle version incrementing. Always get the current page content first to avoid overwriting important information.").requires(["get-confluence-page"]).schema(zod.z.object({
+    page_id: zod.z.string().describe("The ID of the page to update"),
+    title: zod.z.string().describe("The new title for the page"),
+    content: zod.z.string().describe("The new content in HTML format (Confluence storage format)")
+  })).implement(async ({ page_id, title, content }) => {
+    logger4.info("update-confluence-page called", { page_id, title });
+    try {
+      const { ATLASSIAN_SITE_URL } = getAuth();
+      const getResponse = await axios12__default.default.get(
+        `${ATLASSIAN_SITE_URL}/wiki/rest/api/content/${page_id}`,
+        {
+          headers: {
+            Authorization: getAuthHeader2()
+          },
+          params: { expand: "version" }
+        }
+      );
+      const currentVersion = getResponse.data.version.number;
+      const updateResponse = await axios12__default.default.put(
+        `${ATLASSIAN_SITE_URL}/wiki/rest/api/content/${page_id}`,
+        {
+          type: "page",
+          title,
+          version: { number: currentVersion + 1 },
+          body: {
+            storage: {
+              value: content,
+              representation: "storage"
+            }
+          }
+        },
+        {
+          headers: {
+            Authorization: getAuthHeader2(),
+            "Content-Type": "application/json"
+          }
+        }
+      );
+      logger4.info("update-confluence-page result", {
+        page_id,
+        title: updateResponse.data.title,
+        previousVersion: currentVersion,
+        newVersion: updateResponse.data.version.number
+      });
+      return JSON.stringify({
+        success: true,
+        page: {
+          id: updateResponse.data.id,
+          title: updateResponse.data.title,
+          url: `${ATLASSIAN_SITE_URL}/wiki${updateResponse.data._links.webui}`,
+          version: updateResponse.data.version.number,
+          previousVersion: currentVersion
+        }
+      });
+    } catch (error) {
+      logger4.error("update-confluence-page error", {
+        page_id,
+        title,
+        error: error.response?.data?.message || error.message,
+        status: error.response?.status
+      });
+      return JSON.stringify({
+        success: false,
+        error: error.response?.data?.message || error.message
+      });
+    }
+  }).build();
+}
+function createArchiveConfluencePageTool(getAuth, getAuthHeader2, logger4) {
+  return core.toolBuilder().name("archive-confluence-page").description("Archive a Confluence page by moving it to trash. The page can be restored by space admins. Note: UI may require a note explaining why the page was archived.").category(core.ToolCategory.WEB).tag("confluence").tag("archive").tag("delete").usageNotes("Use this to archive outdated or obsolete documentation. The page is moved to trash, not permanently deleted. Space admins can restore it if needed. Be very careful - only archive pages that are truly obsolete.").conflicts(["create-confluence-page"]).schema(zod.z.object({
+    page_id: zod.z.string().describe("The ID of the page to archive"),
+    reason: zod.z.string().optional().describe("Optional reason for archiving (for audit trail)")
+  })).implement(async ({ page_id, reason }) => {
+    logger4.info("archive-confluence-page called", { page_id, reason });
+    try {
+      const { ATLASSIAN_SITE_URL } = getAuth();
+      const getResponse = await axios12__default.default.get(
+        `${ATLASSIAN_SITE_URL}/wiki/rest/api/content/${page_id}`,
+        {
+          headers: {
+            Authorization: getAuthHeader2()
+          },
+          params: { expand: "version,body.storage,space" }
+        }
+      );
+      const currentVersion = getResponse.data.version.number;
+      const pageData = getResponse.data;
+      await axios12__default.default.put(
+        `${ATLASSIAN_SITE_URL}/wiki/rest/api/content/${page_id}`,
+        {
+          version: { number: currentVersion + 1 },
+          title: pageData.title,
+          type: "page",
+          status: "trashed",
+          body: pageData.body,
+          space: { key: pageData.space.key }
+        },
+        {
+          headers: {
+            Authorization: getAuthHeader2(),
+            "Content-Type": "application/json"
+          }
+        }
+      );
+      logger4.info("archive-confluence-page result", {
+        page_id,
+        title: pageData.title,
+        previousVersion: currentVersion,
+        newVersion: currentVersion + 1
+      });
+      return JSON.stringify({
+        success: true,
+        archived: {
+          id: page_id,
+          title: pageData.title,
+          previousVersion: currentVersion,
+          newVersion: currentVersion + 1,
+          reason: reason || "Archived via API",
+          note: "Page moved to trash. Space admins can restore it from the Confluence UI."
+        }
+      });
+    } catch (error) {
+      logger4.error("archive-confluence-page error", {
+        page_id,
+        error: error.response?.data?.message || error.message,
+        status: error.response?.status
+      });
+      return JSON.stringify({
+        success: false,
+        error: error.response?.data?.message || error.message
+      });
+    }
+  }).build();
+}
+
+// src/web/confluence/index.ts
+var logLevel2 = process.env.LOG_LEVEL?.toLowerCase() || core.LogLevel.INFO;
+var logger2 = core.createLogger("[tools:confluence]", { level: logLevel2 });
+var searchConfluence = createSearchConfluenceTool(getConfig, getAuthHeader, logger2);
+var getConfluencePage = createGetConfluencePageTool(getConfig, getAuthHeader, logger2);
+var listConfluenceSpaces = createListConfluenceSpacesTool(getConfig, getAuthHeader, logger2);
+var getSpacePages = createGetSpacePagesTool(getConfig, getAuthHeader, logger2);
+var createConfluencePage = createCreateConfluencePageTool(getConfig, getAuthHeader, logger2);
+var updateConfluencePage = createUpdateConfluencePageTool(getConfig, getAuthHeader, logger2);
+var archiveConfluencePage = createArchiveConfluencePageTool(getConfig, getAuthHeader, logger2);
+var confluenceTools = [
+  // Read tools
+  searchConfluence,
+  getConfluencePage,
+  listConfluenceSpaces,
+  getSpacePages,
+  // Write tools
+  createConfluencePage,
+  updateConfluencePage,
+  archiveConfluencePage
+];
+function createConfluenceTools(config = {}) {
+  const {
+    apiKey,
+    email,
+    siteUrl,
+    logLevel: customLogLevel
+  } = config;
+  const getConfiguredAuth = createGetConfiguredAuth(apiKey, email, siteUrl);
+  const getConfiguredAuthHeader = createGetConfiguredAuthHeader(getConfiguredAuth);
+  const toolLogger = customLogLevel ? core.createLogger("tools:confluence", { level: customLogLevel }) : logger2;
+  const searchConfluence2 = createSearchConfluenceTool(getConfiguredAuth, getConfiguredAuthHeader, toolLogger);
+  const getConfluencePage2 = createGetConfluencePageTool(getConfiguredAuth, getConfiguredAuthHeader, toolLogger);
+  const listConfluenceSpaces2 = createListConfluenceSpacesTool(getConfiguredAuth, getConfiguredAuthHeader, toolLogger);
+  const getSpacePages2 = createGetSpacePagesTool(getConfiguredAuth, getConfiguredAuthHeader, toolLogger);
+  const createConfluencePage2 = createCreateConfluencePageTool(getConfiguredAuth, getConfiguredAuthHeader, toolLogger);
+  const updateConfluencePage2 = createUpdateConfluencePageTool(getConfiguredAuth, getConfiguredAuthHeader, toolLogger);
+  const archiveConfluencePage2 = createArchiveConfluencePageTool(getConfiguredAuth, getConfiguredAuthHeader, toolLogger);
+  return {
+    searchConfluence: searchConfluence2,
+    getConfluencePage: getConfluencePage2,
+    listConfluenceSpaces: listConfluenceSpaces2,
+    getSpacePages: getSpacePages2,
+    createConfluencePage: createConfluencePage2,
+    updateConfluencePage: updateConfluencePage2,
+    archiveConfluencePage: archiveConfluencePage2
+  };
+}
+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({
+});
+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")
-})).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({
+});
+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);
-    }
-    if (!dateFns.isValid(date)) {
-      return {
-        success: false,
-        error: "Invalid date"
-      };
+      formatted = now.toISOString();
     }
-    const formatted = dateFns.format(date, input.outputFormat);
     return {
-      success: true,
       formatted,
-      iso: date.toISOString()
-    };
-  } catch (error) {
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : "Failed to format date"
+      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 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
@@ -2282,8 +3199,8 @@ var AskHumanInputSchema = zod.z.object({
    */
   suggestions: zod.z.array(zod.z.string()).optional().describe("Suggested responses for the human")
 });
-var logLevel2 = process.env.LOG_LEVEL?.toLowerCase() || core.LogLevel.INFO;
-var logger2 = core.createLogger("askHuman", { level: logLevel2 });
+var logLevel3 = process.env.LOG_LEVEL?.toLowerCase() || core.LogLevel.INFO;
+var logger3 = core.createLogger("askHuman", { level: logLevel3 });
 function createAskHumanTool() {
   return core.toolBuilder().name("ask-human").description(
     "Ask a human for input or approval. Use this when you need human guidance, approval for a critical action, or clarification on ambiguous requirements. The agent execution will pause until the human responds."
@@ -2316,13 +3233,13 @@ function createAskHumanTool() {
       suggestions: validatedInput.suggestions,
       status: "pending"
     };
-    logger2.debug("About to call interrupt()", { humanRequest });
+    logger3.debug("About to call interrupt()", { humanRequest });
     let response;
     try {
       response = interrupt(humanRequest);
-      logger2.debug("interrupt() returned successfully", { response, responseType: typeof response });
+      logger3.debug("interrupt() returned successfully", { response, responseType: typeof response });
     } catch (error) {
-      logger2.debug("interrupt() threw error (expected for GraphInterrupt)", {
+      logger3.debug("interrupt() threw error (expected for GraphInterrupt)", {
         errorType: error?.constructor?.name,
         error: error instanceof Error ? error.message : String(error)
       });
@@ -2348,67 +3265,227 @@ 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;
 exports.slackTools = slackTools;
@@ -2420,17 +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