@nhtio/adk 0.1.0-master-f0aa531d

package/batteries/tools/string_processing.cjs

@@ -0,0 +1,154 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("../../chunk-KmRHZBOW.js");
+const require_tool_registry = require("../../tool_registry-Dkfprsck.js");
+require("../../common-Od8edUXU.js");
+const require_tool = require("../../tool-COSeH8I6.js");
+require("../../guards.cjs");
+let _nhtio_validation = require("@nhtio/validation");
+let case_anything = require("case-anything");
+//#region src/batteries/tools/string_processing/index.ts
+/**
+* Pre-constructed tools for casing, trimming, normalizing, and transforming strings.
+*
+* @module @nhtio/adk/batteries/tools/string_processing
+*
+* @remarks
+* Pre-constructed bundled tools for the `string_processing` category. Import individually, the whole
+* category, or import every tool via `@nhtio/adk/batteries`.
+*/
+function applyStringOp(text, op) {
+	switch (op.op) {
+		case "uppercase": return text.toUpperCase();
+		case "lowercase": return text.toLowerCase();
+		case "capitalize": return text.charAt(0).toUpperCase() + text.slice(1);
+		case "titlecase": return (0, case_anything.capitalCase)(text);
+		case "sentence_case": return text.charAt(0).toUpperCase() + text.slice(1).toLowerCase();
+		case "camel_case": return (0, case_anything.camelCase)(text);
+		case "pascal_case": return (0, case_anything.pascalCase)(text);
+		case "snake_case": return (0, case_anything.snakeCase)(text);
+		case "kebab_case": return (0, case_anything.kebabCase)(text);
+		case "train_case": return (0, case_anything.trainCase)(text);
+		case "constant_case": return (0, case_anything.snakeCase)(text).toUpperCase();
+		case "trim": return text.trim();
+		case "trim_start": return text.trimStart();
+		case "trim_end": return text.trimEnd();
+		case "normalize_whitespace": return text.replace(/\s+/g, " ").trim();
+		case "reverse": return text.split("").reverse().join("");
+		case "slug": return text.toLowerCase().normalize("NFD").replace(/[\u0300-\u036f]/g, "").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+		case "strip_html": return text.replace(/<[^>]*>/g, "");
+		case "count_words": return text.trim() === "" ? 0 : text.trim().split(/\s+/).length;
+		case "count_chars": return text.length;
+		case "count_lines": return text === "" ? 0 : text.split("\n").length;
+		case "repeat": return text.repeat(Math.max(0, Math.min(100, Math.floor(op.count))));
+		case "pad_start": return text.padStart(op.length, op.char ?? " ");
+		case "pad_end": return text.padEnd(op.length, op.char ?? " ");
+		case "slice": return text.slice(op.start, op.end);
+		case "truncate": {
+			const suffix = op.suffix ?? "…";
+			if (text.length <= op.length) return text;
+			return text.slice(0, Math.max(0, op.length - suffix.length)) + suffix;
+		}
+		case "replace": return text.replace(op.from, op.to);
+		case "replace_all": return text.split(op.from).join(op.to);
+		case "regex_replace": {
+			const flags = (op.flags ?? "g").replace(/[^gimsuy]/g, "");
+			let re;
+			try {
+				re = new RegExp(op.pattern, flags);
+			} catch (e) {
+				throw new Error(`Invalid regex: ${require_tool_registry.isError(e) ? e.message : String(e)}`);
+			}
+			return text.replace(re, op.replacement);
+		}
+		case "split": return text.split(op.delimiter);
+		case "indent": {
+			const size = op.size ?? 2;
+			const pad = (op.char ?? " ").repeat(size);
+			return text.split("\n").map((l) => l === "" ? l : pad + l).join("\n");
+		}
+		case "dedent": {
+			const lines = text.split("\n");
+			const nonEmpty = lines.filter((l) => l.trim() !== "");
+			if (nonEmpty.length === 0) return text;
+			const minIndent = Math.min(...nonEmpty.map((l) => l.match(/^(\s*)/)?.[1].length ?? 0));
+			return lines.map((l) => l.slice(minIndent)).join("\n");
+		}
+		default: throw new Error(`Unknown operation: ${op.op}`);
+	}
+}
+/**
+* Apply an ordered pipeline of string transformations.
+*
+* @remarks
+* Each operation reads the previous step's output. Most operations return strings; `count_*`
+* return numbers and `split` returns an array — once a non-string flows through, subsequent
+* operations report an error rather than coercing. The result is always serialised to a string
+* (arrays become JSON; numbers/booleans are stringified).
+*/
+var stringTransformTool = new require_tool.Tool({
+	name: "string_transform",
+	description: "Apply one or more string transformations in sequence. Supports case conversion (camelCase, snake_case, kebab-case, etc.), trimming, truncation, replacement, splitting, indentation, and more.",
+	inputSchema: _nhtio_validation.validator.object({
+		text: _nhtio_validation.validator.string().required().allow("").description("Input string to transform"),
+		operations: _nhtio_validation.validator.array().items(_nhtio_validation.validator.object().unknown(true)).required().description("Ordered list of operations to apply. Each operation has an \"op\" field.")
+	}),
+	handler: async (args) => {
+		const { text, operations } = args;
+		let current = text;
+		for (const [i, op] of operations.entries()) {
+			if (typeof current !== "string") return `Error: Operation ${i + 1} ("${op.op}") requires a string input, but the previous operation returned ${Array.isArray(current) ? "an array" : typeof current}.`;
+			try {
+				current = applyStringOp(current, op);
+			} catch (err) {
+				return `Error in operation ${i + 1} ("${op.op}"): ${require_tool_registry.isError(err) ? err.message : String(err)}`;
+			}
+		}
+		if (Array.isArray(current)) return JSON.stringify(current);
+		return String(current);
+	}
+});
+/**
+* Extract all matches of a regular expression from a string.
+*
+* @remarks
+* The `g` flag is always enabled. `group` selects which capture group to return per match (0 =
+* full match). Output is at most 500 matches; if truncated, the suffix `(truncated at 500)` is
+* appended.
+*/
+var stringExtractTool = new require_tool.Tool({
+	name: "string_extract",
+	description: "Extract all matches of a regex pattern from text. Returns a JSON array of matched strings. Use capture groups to pull out specific parts.",
+	inputSchema: _nhtio_validation.validator.object({
+		text: _nhtio_validation.validator.string().required().allow("").description("Input text to search"),
+		pattern: _nhtio_validation.validator.string().required().description("Regular expression pattern (no surrounding slashes)"),
+		flags: _nhtio_validation.validator.string().default("g").description("Regex flags (default: \"g\"). \"g\" is always included."),
+		group: _nhtio_validation.validator.number().default(0).description("Capture group index to return (0 = full match, 1 = first group). Default: 0.")
+	}),
+	handler: async (args) => {
+		const { text, pattern, flags: rawFlags, group } = args;
+		const flags = rawFlags.replace(/[^gimsuy]/g, "");
+		const flagsWithG = flags.includes("g") ? flags : flags + "g";
+		let regex;
+		try {
+			regex = new RegExp(pattern, flagsWithG);
+		} catch (err) {
+			return `Error: Invalid regex — ${require_tool_registry.isError(err) ? err.message : String(err)}`;
+		}
+		const matches = [];
+		let match;
+		const MAX_MATCHES = 500;
+		while ((match = regex.exec(text)) !== null && matches.length < MAX_MATCHES) {
+			const value = match[group];
+			if (value !== void 0) matches.push(value);
+			if (match.index === regex.lastIndex) regex.lastIndex++;
+		}
+		if (matches.length === 0) return "No matches found.";
+		const truncated = matches.length === MAX_MATCHES ? " (truncated at 500)" : "";
+		return JSON.stringify(matches) + truncated;
+	}
+});
+//#endregion
+exports.stringExtractTool = stringExtractTool;
+exports.stringTransformTool = stringTransformTool;
+
+//# sourceMappingURL=string_processing.cjs.map

package/batteries/tools/string_processing.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"string_processing.cjs","names":[],"sources":["../../../src/batteries/tools/string_processing/index.ts"],"sourcesContent":["/**\n * Pre-constructed tools for casing, trimming, normalizing, and transforming strings.\n *\n * @module @nhtio/adk/batteries/tools/string_processing\n *\n * @remarks\n * Pre-constructed bundled tools for the `string_processing` category. Import individually, the whole\n * category, or import every tool via `@nhtio/adk/batteries`.\n */\n\nimport { Tool } from '@nhtio/adk/common'\nimport { isError } from '@nhtio/adk/guards'\nimport { validator } from '@nhtio/validation'\nimport { camelCase, capitalCase, kebabCase, pascalCase, snakeCase, trainCase } from 'case-anything'\n\ntype StringOp =\n  | { op: 'uppercase' }\n  | { op: 'lowercase' }\n  | { op: 'titlecase' }\n  | { op: 'sentence_case' }\n  | { op: 'capitalize' }\n  | { op: 'camel_case' }\n  | { op: 'pascal_case' }\n  | { op: 'snake_case' }\n  | { op: 'kebab_case' }\n  | { op: 'train_case' }\n  | { op: 'constant_case' }\n  | { op: 'trim' }\n  | { op: 'trim_start' }\n  | { op: 'trim_end' }\n  | { op: 'normalize_whitespace' }\n  | { op: 'reverse' }\n  | { op: 'slug' }\n  | { op: 'strip_html' }\n  | { op: 'count_words' }\n  | { op: 'count_chars' }\n  | { op: 'count_lines' }\n  | { op: 'repeat'; count: number }\n  | { op: 'pad_start'; length: number; char?: string }\n  | { op: 'pad_end'; length: number; char?: string }\n  | { op: 'slice'; start: number; end?: number }\n  | { op: 'truncate'; length: number; suffix?: string }\n  | { op: 'replace'; from: string; to: string }\n  | { op: 'replace_all'; from: string; to: string }\n  | { op: 'regex_replace'; pattern: string; replacement: string; flags?: string }\n  | { op: 'split'; delimiter: string }\n  | { op: 'indent'; size?: number; char?: string }\n  | { op: 'dedent' }\n\nfunction applyStringOp(text: string, op: StringOp): string | number | string[] {\n  switch (op.op) {\n    case 'uppercase':\n      return text.toUpperCase()\n    case 'lowercase':\n      return text.toLowerCase()\n    case 'capitalize':\n      return text.charAt(0).toUpperCase() + text.slice(1)\n    case 'titlecase':\n      return capitalCase(text)\n    case 'sentence_case':\n      return text.charAt(0).toUpperCase() + text.slice(1).toLowerCase()\n    case 'camel_case':\n      return camelCase(text)\n    case 'pascal_case':\n      return pascalCase(text)\n    case 'snake_case':\n      return snakeCase(text)\n    case 'kebab_case':\n      return kebabCase(text)\n    case 'train_case':\n      return trainCase(text)\n    case 'constant_case':\n      return snakeCase(text).toUpperCase()\n    case 'trim':\n      return text.trim()\n    case 'trim_start':\n      return text.trimStart()\n    case 'trim_end':\n      return text.trimEnd()\n    case 'normalize_whitespace':\n      return text.replace(/\\s+/g, ' ').trim()\n    case 'reverse':\n      return text.split('').reverse().join('')\n    case 'slug':\n      return text\n        .toLowerCase()\n        .normalize('NFD')\n        .replace(/[\\u0300-\\u036f]/g, '')\n        .replace(/[^a-z0-9]+/g, '-')\n        .replace(/^-+|-+$/g, '')\n    case 'strip_html':\n      return text.replace(/<[^>]*>/g, '')\n    case 'count_words':\n      return text.trim() === '' ? 0 : text.trim().split(/\\s+/).length\n    case 'count_chars':\n      return text.length\n    case 'count_lines':\n      return text === '' ? 0 : text.split('\\n').length\n    case 'repeat':\n      return text.repeat(Math.max(0, Math.min(100, Math.floor(op.count))))\n    case 'pad_start':\n      return text.padStart(op.length, op.char ?? ' ')\n    case 'pad_end':\n      return text.padEnd(op.length, op.char ?? ' ')\n    case 'slice':\n      return text.slice(op.start, op.end)\n    case 'truncate': {\n      const suffix = op.suffix ?? '…'\n      if (text.length <= op.length) return text\n      return text.slice(0, Math.max(0, op.length - suffix.length)) + suffix\n    }\n    case 'replace':\n      return text.replace(op.from, op.to)\n    case 'replace_all':\n      return text.split(op.from).join(op.to)\n    case 'regex_replace': {\n      const flags = (op.flags ?? 'g').replace(/[^gimsuy]/g, '')\n      let re: RegExp\n      try {\n        re = new RegExp(op.pattern, flags)\n      } catch (e) {\n        throw new Error(`Invalid regex: ${isError(e) ? e.message : String(e)}`)\n      }\n      return text.replace(re, op.replacement)\n    }\n    case 'split':\n      return text.split(op.delimiter)\n    case 'indent': {\n      const size = op.size ?? 2\n      const ch = op.char ?? ' '\n      const pad = ch.repeat(size)\n      return text\n        .split('\\n')\n        .map((l) => (l === '' ? l : pad + l))\n        .join('\\n')\n    }\n    case 'dedent': {\n      const lines = text.split('\\n')\n      const nonEmpty = lines.filter((l) => l.trim() !== '')\n      if (nonEmpty.length === 0) return text\n      const minIndent = Math.min(...nonEmpty.map((l) => l.match(/^(\\s*)/)?.[1].length ?? 0))\n      return lines.map((l) => l.slice(minIndent)).join('\\n')\n    }\n    default:\n      throw new Error(`Unknown operation: ${(op as { op: string }).op}`)\n  }\n}\n\n/**\n * Apply an ordered pipeline of string transformations.\n *\n * @remarks\n * Each operation reads the previous step's output. Most operations return strings; `count_*`\n * return numbers and `split` returns an array — once a non-string flows through, subsequent\n * operations report an error rather than coercing. The result is always serialised to a string\n * (arrays become JSON; numbers/booleans are stringified).\n */\nexport const stringTransformTool = new Tool({\n  name: 'string_transform',\n  description:\n    'Apply one or more string transformations in sequence. Supports case conversion (camelCase, snake_case, kebab-case, etc.), trimming, truncation, replacement, splitting, indentation, and more.',\n  inputSchema: validator.object({\n    text: validator.string().required().allow('').description('Input string to transform'),\n    operations: validator\n      .array()\n      .items(validator.object().unknown(true))\n      .required()\n      .description('Ordered list of operations to apply. Each operation has an \"op\" field.'),\n  }),\n  handler: async (args) => {\n    const { text, operations } = args as { text: string; operations: StringOp[] }\n    let current: string | number | string[] = text\n\n    for (const [i, op] of operations.entries()) {\n      if (typeof current !== 'string') {\n        return `Error: Operation ${i + 1} (\"${op.op}\") requires a string input, but the previous operation returned ${Array.isArray(current) ? 'an array' : typeof current}.`\n      }\n      try {\n        current = applyStringOp(current, op)\n      } catch (err) {\n        return `Error in operation ${i + 1} (\"${op.op}\"): ${isError(err) ? err.message : String(err)}`\n      }\n    }\n\n    if (Array.isArray(current)) return JSON.stringify(current)\n    return String(current)\n  },\n})\n\n/**\n * Extract all matches of a regular expression from a string.\n *\n * @remarks\n * The `g` flag is always enabled. `group` selects which capture group to return per match (0 =\n * full match). Output is at most 500 matches; if truncated, the suffix `(truncated at 500)` is\n * appended.\n */\nexport const stringExtractTool = new Tool({\n  name: 'string_extract',\n  description:\n    'Extract all matches of a regex pattern from text. Returns a JSON array of matched strings. Use capture groups to pull out specific parts.',\n  inputSchema: validator.object({\n    text: validator.string().required().allow('').description('Input text to search'),\n    pattern: validator\n      .string()\n      .required()\n      .description('Regular expression pattern (no surrounding slashes)'),\n    flags: validator\n      .string()\n      .default('g')\n      .description('Regex flags (default: \"g\"). \"g\" is always included.'),\n    group: validator\n      .number()\n      .default(0)\n      .description('Capture group index to return (0 = full match, 1 = first group). Default: 0.'),\n  }),\n  handler: async (args) => {\n    const {\n      text,\n      pattern,\n      flags: rawFlags,\n      group,\n    } = args as {\n      text: string\n      pattern: string\n      flags: string\n      group: number\n    }\n    const flags = rawFlags.replace(/[^gimsuy]/g, '')\n    const flagsWithG = flags.includes('g') ? flags : flags + 'g'\n\n    let regex: RegExp\n    try {\n      regex = new RegExp(pattern, flagsWithG)\n    } catch (err) {\n      return `Error: Invalid regex — ${isError(err) ? err.message : String(err)}`\n    }\n\n    const matches: string[] = []\n    let match: RegExpExecArray | null\n    const MAX_MATCHES = 500\n\n    while ((match = regex.exec(text)) !== null && matches.length < MAX_MATCHES) {\n      const value = match[group]\n      if (value !== undefined) matches.push(value)\n      if (match.index === regex.lastIndex) regex.lastIndex++\n    }\n\n    if (matches.length === 0) return 'No matches found.'\n    const truncated = matches.length === MAX_MATCHES ? ' (truncated at 500)' : ''\n    return JSON.stringify(matches) + truncated\n  },\n})\n"],"mappings":"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"}

package/batteries/tools/string_processing.mjs

@@ -0,0 +1,151 @@
+import { o as isError } from "../../tool_registry-DqLOyGyG.mjs";
+import "../../common-DeZaonK1.mjs";
+import { t as Tool } from "../../tool-D2WB1EA1.mjs";
+import "../../guards.mjs";
+import { validator } from "@nhtio/validation";
+import { camelCase, capitalCase, kebabCase, pascalCase, snakeCase, trainCase } from "case-anything";
+//#region src/batteries/tools/string_processing/index.ts
+/**
+* Pre-constructed tools for casing, trimming, normalizing, and transforming strings.
+*
+* @module @nhtio/adk/batteries/tools/string_processing
+*
+* @remarks
+* Pre-constructed bundled tools for the `string_processing` category. Import individually, the whole
+* category, or import every tool via `@nhtio/adk/batteries`.
+*/
+function applyStringOp(text, op) {
+	switch (op.op) {
+		case "uppercase": return text.toUpperCase();
+		case "lowercase": return text.toLowerCase();
+		case "capitalize": return text.charAt(0).toUpperCase() + text.slice(1);
+		case "titlecase": return capitalCase(text);
+		case "sentence_case": return text.charAt(0).toUpperCase() + text.slice(1).toLowerCase();
+		case "camel_case": return camelCase(text);
+		case "pascal_case": return pascalCase(text);
+		case "snake_case": return snakeCase(text);
+		case "kebab_case": return kebabCase(text);
+		case "train_case": return trainCase(text);
+		case "constant_case": return snakeCase(text).toUpperCase();
+		case "trim": return text.trim();
+		case "trim_start": return text.trimStart();
+		case "trim_end": return text.trimEnd();
+		case "normalize_whitespace": return text.replace(/\s+/g, " ").trim();
+		case "reverse": return text.split("").reverse().join("");
+		case "slug": return text.toLowerCase().normalize("NFD").replace(/[\u0300-\u036f]/g, "").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+		case "strip_html": return text.replace(/<[^>]*>/g, "");
+		case "count_words": return text.trim() === "" ? 0 : text.trim().split(/\s+/).length;
+		case "count_chars": return text.length;
+		case "count_lines": return text === "" ? 0 : text.split("\n").length;
+		case "repeat": return text.repeat(Math.max(0, Math.min(100, Math.floor(op.count))));
+		case "pad_start": return text.padStart(op.length, op.char ?? " ");
+		case "pad_end": return text.padEnd(op.length, op.char ?? " ");
+		case "slice": return text.slice(op.start, op.end);
+		case "truncate": {
+			const suffix = op.suffix ?? "…";
+			if (text.length <= op.length) return text;
+			return text.slice(0, Math.max(0, op.length - suffix.length)) + suffix;
+		}
+		case "replace": return text.replace(op.from, op.to);
+		case "replace_all": return text.split(op.from).join(op.to);
+		case "regex_replace": {
+			const flags = (op.flags ?? "g").replace(/[^gimsuy]/g, "");
+			let re;
+			try {
+				re = new RegExp(op.pattern, flags);
+			} catch (e) {
+				throw new Error(`Invalid regex: ${isError(e) ? e.message : String(e)}`);
+			}
+			return text.replace(re, op.replacement);
+		}
+		case "split": return text.split(op.delimiter);
+		case "indent": {
+			const size = op.size ?? 2;
+			const pad = (op.char ?? " ").repeat(size);
+			return text.split("\n").map((l) => l === "" ? l : pad + l).join("\n");
+		}
+		case "dedent": {
+			const lines = text.split("\n");
+			const nonEmpty = lines.filter((l) => l.trim() !== "");
+			if (nonEmpty.length === 0) return text;
+			const minIndent = Math.min(...nonEmpty.map((l) => l.match(/^(\s*)/)?.[1].length ?? 0));
+			return lines.map((l) => l.slice(minIndent)).join("\n");
+		}
+		default: throw new Error(`Unknown operation: ${op.op}`);
+	}
+}
+/**
+* Apply an ordered pipeline of string transformations.
+*
+* @remarks
+* Each operation reads the previous step's output. Most operations return strings; `count_*`
+* return numbers and `split` returns an array — once a non-string flows through, subsequent
+* operations report an error rather than coercing. The result is always serialised to a string
+* (arrays become JSON; numbers/booleans are stringified).
+*/
+var stringTransformTool = new Tool({
+	name: "string_transform",
+	description: "Apply one or more string transformations in sequence. Supports case conversion (camelCase, snake_case, kebab-case, etc.), trimming, truncation, replacement, splitting, indentation, and more.",
+	inputSchema: validator.object({
+		text: validator.string().required().allow("").description("Input string to transform"),
+		operations: validator.array().items(validator.object().unknown(true)).required().description("Ordered list of operations to apply. Each operation has an \"op\" field.")
+	}),
+	handler: async (args) => {
+		const { text, operations } = args;
+		let current = text;
+		for (const [i, op] of operations.entries()) {
+			if (typeof current !== "string") return `Error: Operation ${i + 1} ("${op.op}") requires a string input, but the previous operation returned ${Array.isArray(current) ? "an array" : typeof current}.`;
+			try {
+				current = applyStringOp(current, op);
+			} catch (err) {
+				return `Error in operation ${i + 1} ("${op.op}"): ${isError(err) ? err.message : String(err)}`;
+			}
+		}
+		if (Array.isArray(current)) return JSON.stringify(current);
+		return String(current);
+	}
+});
+/**
+* Extract all matches of a regular expression from a string.
+*
+* @remarks
+* The `g` flag is always enabled. `group` selects which capture group to return per match (0 =
+* full match). Output is at most 500 matches; if truncated, the suffix `(truncated at 500)` is
+* appended.
+*/
+var stringExtractTool = new Tool({
+	name: "string_extract",
+	description: "Extract all matches of a regex pattern from text. Returns a JSON array of matched strings. Use capture groups to pull out specific parts.",
+	inputSchema: validator.object({
+		text: validator.string().required().allow("").description("Input text to search"),
+		pattern: validator.string().required().description("Regular expression pattern (no surrounding slashes)"),
+		flags: validator.string().default("g").description("Regex flags (default: \"g\"). \"g\" is always included."),
+		group: validator.number().default(0).description("Capture group index to return (0 = full match, 1 = first group). Default: 0.")
+	}),
+	handler: async (args) => {
+		const { text, pattern, flags: rawFlags, group } = args;
+		const flags = rawFlags.replace(/[^gimsuy]/g, "");
+		const flagsWithG = flags.includes("g") ? flags : flags + "g";
+		let regex;
+		try {
+			regex = new RegExp(pattern, flagsWithG);
+		} catch (err) {
+			return `Error: Invalid regex — ${isError(err) ? err.message : String(err)}`;
+		}
+		const matches = [];
+		let match;
+		const MAX_MATCHES = 500;
+		while ((match = regex.exec(text)) !== null && matches.length < MAX_MATCHES) {
+			const value = match[group];
+			if (value !== void 0) matches.push(value);
+			if (match.index === regex.lastIndex) regex.lastIndex++;
+		}
+		if (matches.length === 0) return "No matches found.";
+		const truncated = matches.length === MAX_MATCHES ? " (truncated at 500)" : "";
+		return JSON.stringify(matches) + truncated;
+	}
+});
+//#endregion
+export { stringExtractTool, stringTransformTool };
+
+//# sourceMappingURL=string_processing.mjs.map

package/batteries/tools/string_processing.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"string_processing.mjs","names":[],"sources":["../../../src/batteries/tools/string_processing/index.ts"],"sourcesContent":["/**\n * Pre-constructed tools for casing, trimming, normalizing, and transforming strings.\n *\n * @module @nhtio/adk/batteries/tools/string_processing\n *\n * @remarks\n * Pre-constructed bundled tools for the `string_processing` category. Import individually, the whole\n * category, or import every tool via `@nhtio/adk/batteries`.\n */\n\nimport { Tool } from '@nhtio/adk/common'\nimport { isError } from '@nhtio/adk/guards'\nimport { validator } from '@nhtio/validation'\nimport { camelCase, capitalCase, kebabCase, pascalCase, snakeCase, trainCase } from 'case-anything'\n\ntype StringOp =\n  | { op: 'uppercase' }\n  | { op: 'lowercase' }\n  | { op: 'titlecase' }\n  | { op: 'sentence_case' }\n  | { op: 'capitalize' }\n  | { op: 'camel_case' }\n  | { op: 'pascal_case' }\n  | { op: 'snake_case' }\n  | { op: 'kebab_case' }\n  | { op: 'train_case' }\n  | { op: 'constant_case' }\n  | { op: 'trim' }\n  | { op: 'trim_start' }\n  | { op: 'trim_end' }\n  | { op: 'normalize_whitespace' }\n  | { op: 'reverse' }\n  | { op: 'slug' }\n  | { op: 'strip_html' }\n  | { op: 'count_words' }\n  | { op: 'count_chars' }\n  | { op: 'count_lines' }\n  | { op: 'repeat'; count: number }\n  | { op: 'pad_start'; length: number; char?: string }\n  | { op: 'pad_end'; length: number; char?: string }\n  | { op: 'slice'; start: number; end?: number }\n  | { op: 'truncate'; length: number; suffix?: string }\n  | { op: 'replace'; from: string; to: string }\n  | { op: 'replace_all'; from: string; to: string }\n  | { op: 'regex_replace'; pattern: string; replacement: string; flags?: string }\n  | { op: 'split'; delimiter: string }\n  | { op: 'indent'; size?: number; char?: string }\n  | { op: 'dedent' }\n\nfunction applyStringOp(text: string, op: StringOp): string | number | string[] {\n  switch (op.op) {\n    case 'uppercase':\n      return text.toUpperCase()\n    case 'lowercase':\n      return text.toLowerCase()\n    case 'capitalize':\n      return text.charAt(0).toUpperCase() + text.slice(1)\n    case 'titlecase':\n      return capitalCase(text)\n    case 'sentence_case':\n      return text.charAt(0).toUpperCase() + text.slice(1).toLowerCase()\n    case 'camel_case':\n      return camelCase(text)\n    case 'pascal_case':\n      return pascalCase(text)\n    case 'snake_case':\n      return snakeCase(text)\n    case 'kebab_case':\n      return kebabCase(text)\n    case 'train_case':\n      return trainCase(text)\n    case 'constant_case':\n      return snakeCase(text).toUpperCase()\n    case 'trim':\n      return text.trim()\n    case 'trim_start':\n      return text.trimStart()\n    case 'trim_end':\n      return text.trimEnd()\n    case 'normalize_whitespace':\n      return text.replace(/\\s+/g, ' ').trim()\n    case 'reverse':\n      return text.split('').reverse().join('')\n    case 'slug':\n      return text\n        .toLowerCase()\n        .normalize('NFD')\n        .replace(/[\\u0300-\\u036f]/g, '')\n        .replace(/[^a-z0-9]+/g, '-')\n        .replace(/^-+|-+$/g, '')\n    case 'strip_html':\n      return text.replace(/<[^>]*>/g, '')\n    case 'count_words':\n      return text.trim() === '' ? 0 : text.trim().split(/\\s+/).length\n    case 'count_chars':\n      return text.length\n    case 'count_lines':\n      return text === '' ? 0 : text.split('\\n').length\n    case 'repeat':\n      return text.repeat(Math.max(0, Math.min(100, Math.floor(op.count))))\n    case 'pad_start':\n      return text.padStart(op.length, op.char ?? ' ')\n    case 'pad_end':\n      return text.padEnd(op.length, op.char ?? ' ')\n    case 'slice':\n      return text.slice(op.start, op.end)\n    case 'truncate': {\n      const suffix = op.suffix ?? '…'\n      if (text.length <= op.length) return text\n      return text.slice(0, Math.max(0, op.length - suffix.length)) + suffix\n    }\n    case 'replace':\n      return text.replace(op.from, op.to)\n    case 'replace_all':\n      return text.split(op.from).join(op.to)\n    case 'regex_replace': {\n      const flags = (op.flags ?? 'g').replace(/[^gimsuy]/g, '')\n      let re: RegExp\n      try {\n        re = new RegExp(op.pattern, flags)\n      } catch (e) {\n        throw new Error(`Invalid regex: ${isError(e) ? e.message : String(e)}`)\n      }\n      return text.replace(re, op.replacement)\n    }\n    case 'split':\n      return text.split(op.delimiter)\n    case 'indent': {\n      const size = op.size ?? 2\n      const ch = op.char ?? ' '\n      const pad = ch.repeat(size)\n      return text\n        .split('\\n')\n        .map((l) => (l === '' ? l : pad + l))\n        .join('\\n')\n    }\n    case 'dedent': {\n      const lines = text.split('\\n')\n      const nonEmpty = lines.filter((l) => l.trim() !== '')\n      if (nonEmpty.length === 0) return text\n      const minIndent = Math.min(...nonEmpty.map((l) => l.match(/^(\\s*)/)?.[1].length ?? 0))\n      return lines.map((l) => l.slice(minIndent)).join('\\n')\n    }\n    default:\n      throw new Error(`Unknown operation: ${(op as { op: string }).op}`)\n  }\n}\n\n/**\n * Apply an ordered pipeline of string transformations.\n *\n * @remarks\n * Each operation reads the previous step's output. Most operations return strings; `count_*`\n * return numbers and `split` returns an array — once a non-string flows through, subsequent\n * operations report an error rather than coercing. The result is always serialised to a string\n * (arrays become JSON; numbers/booleans are stringified).\n */\nexport const stringTransformTool = new Tool({\n  name: 'string_transform',\n  description:\n    'Apply one or more string transformations in sequence. Supports case conversion (camelCase, snake_case, kebab-case, etc.), trimming, truncation, replacement, splitting, indentation, and more.',\n  inputSchema: validator.object({\n    text: validator.string().required().allow('').description('Input string to transform'),\n    operations: validator\n      .array()\n      .items(validator.object().unknown(true))\n      .required()\n      .description('Ordered list of operations to apply. Each operation has an \"op\" field.'),\n  }),\n  handler: async (args) => {\n    const { text, operations } = args as { text: string; operations: StringOp[] }\n    let current: string | number | string[] = text\n\n    for (const [i, op] of operations.entries()) {\n      if (typeof current !== 'string') {\n        return `Error: Operation ${i + 1} (\"${op.op}\") requires a string input, but the previous operation returned ${Array.isArray(current) ? 'an array' : typeof current}.`\n      }\n      try {\n        current = applyStringOp(current, op)\n      } catch (err) {\n        return `Error in operation ${i + 1} (\"${op.op}\"): ${isError(err) ? err.message : String(err)}`\n      }\n    }\n\n    if (Array.isArray(current)) return JSON.stringify(current)\n    return String(current)\n  },\n})\n\n/**\n * Extract all matches of a regular expression from a string.\n *\n * @remarks\n * The `g` flag is always enabled. `group` selects which capture group to return per match (0 =\n * full match). Output is at most 500 matches; if truncated, the suffix `(truncated at 500)` is\n * appended.\n */\nexport const stringExtractTool = new Tool({\n  name: 'string_extract',\n  description:\n    'Extract all matches of a regex pattern from text. Returns a JSON array of matched strings. Use capture groups to pull out specific parts.',\n  inputSchema: validator.object({\n    text: validator.string().required().allow('').description('Input text to search'),\n    pattern: validator\n      .string()\n      .required()\n      .description('Regular expression pattern (no surrounding slashes)'),\n    flags: validator\n      .string()\n      .default('g')\n      .description('Regex flags (default: \"g\"). \"g\" is always included.'),\n    group: validator\n      .number()\n      .default(0)\n      .description('Capture group index to return (0 = full match, 1 = first group). Default: 0.'),\n  }),\n  handler: async (args) => {\n    const {\n      text,\n      pattern,\n      flags: rawFlags,\n      group,\n    } = args as {\n      text: string\n      pattern: string\n      flags: string\n      group: number\n    }\n    const flags = rawFlags.replace(/[^gimsuy]/g, '')\n    const flagsWithG = flags.includes('g') ? flags : flags + 'g'\n\n    let regex: RegExp\n    try {\n      regex = new RegExp(pattern, flagsWithG)\n    } catch (err) {\n      return `Error: Invalid regex — ${isError(err) ? err.message : String(err)}`\n    }\n\n    const matches: string[] = []\n    let match: RegExpExecArray | null\n    const MAX_MATCHES = 500\n\n    while ((match = regex.exec(text)) !== null && matches.length < MAX_MATCHES) {\n      const value = match[group]\n      if (value !== undefined) matches.push(value)\n      if (match.index === regex.lastIndex) regex.lastIndex++\n    }\n\n    if (matches.length === 0) return 'No matches found.'\n    const truncated = matches.length === MAX_MATCHES ? ' (truncated at 500)' : ''\n    return JSON.stringify(matches) + truncated\n  },\n})\n"],"mappings":"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"}

package/batteries/tools/structured_data/index.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Pre-constructed tools for transforming arrays and objects into tables and tabular text.
+ *
+ * @module @nhtio/adk/batteries/tools/structured_data
+ *
+ * @remarks
+ * Pre-constructed bundled tools for the `structured_data` category. Import individually, the whole
+ * category, or import every tool via `@nhtio/adk/batteries`.
+ */
+import { Tool } from "../../../common";
+/**
+ * Convert a JSON array of objects into a formatted table.
+ *
+ * @remarks
+ * Supports `markdown`, `csv`, and `tsv` output. Columns default to the keys of the first row;
+ * supply `columns` to control which keys appear and in what order.
+ */
+export declare const formatTableTool: Tool<import("../../../common").SpooledArtifact>;
+/**
+ * Pretty-print or minify a JSON string.
+ *
+ * @remarks
+ * Validates the input as JSON, then re-serialises it with the requested indentation. `indent` is
+ * clamped to the range [0, 8]; `0` produces minified output.
+ */
+export declare const jsonFormatTool: Tool<import("../../../common").SpooledArtifact>;
+/**
+ * Check whether a string matches a known format.
+ *
+ * @remarks
+ * Supported formats: `email`, `uuid` (v1–v5), `ipv4`, `iso_date`, `iso_datetime`, `hex_color`,
+ * `phone_e164`, `semver`, `integer`, `decimal`, `alphanumeric`, `slug`, `hex`, `base64`.
+ */
+export declare const validateFormatTool: Tool<import("../../../common").SpooledArtifact>;

package/batteries/tools/structured_data.cjs

@@ -0,0 +1,189 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("../../chunk-KmRHZBOW.js");
+const require_tool_registry = require("../../tool_registry-Dkfprsck.js");
+require("../../common-Od8edUXU.js");
+const require_tool = require("../../tool-COSeH8I6.js");
+require("../../guards.cjs");
+let _nhtio_validation = require("@nhtio/validation");
+//#region src/batteries/tools/structured_data/index.ts
+/**
+* Pre-constructed tools for transforming arrays and objects into tables and tabular text.
+*
+* @module @nhtio/adk/batteries/tools/structured_data
+*
+* @remarks
+* Pre-constructed bundled tools for the `structured_data` category. Import individually, the whole
+* category, or import every tool via `@nhtio/adk/batteries`.
+*/
+function csvEscape(value) {
+	const str = value === null || value === void 0 ? "" : String(value);
+	if (str.includes(",") || str.includes("\"") || str.includes("\n") || str.includes("\r")) return "\"" + str.replace(/"/g, "\"\"") + "\"";
+	return str;
+}
+function tsvEscape(value) {
+	return (value === null || value === void 0 ? "" : String(value)).replace(/\t/g, " ").replace(/\r?\n/g, " ");
+}
+function mdEscape(value) {
+	return String(value === null || value === void 0 ? "" : value).replace(/\|/g, "\\|").replace(/\r?\n/g, " ");
+}
+/**
+* Convert a JSON array of objects into a formatted table.
+*
+* @remarks
+* Supports `markdown`, `csv`, and `tsv` output. Columns default to the keys of the first row;
+* supply `columns` to control which keys appear and in what order.
+*/
+var formatTableTool = new require_tool.Tool({
+	name: "format_table",
+	description: "Convert a JSON array of objects into a formatted table. Supports Markdown, CSV, and TSV output.",
+	inputSchema: _nhtio_validation.validator.object({
+		data: _nhtio_validation.validator.string().required().description("JSON array of objects as a string"),
+		format: _nhtio_validation.validator.string().valid("markdown", "csv", "tsv").required().description("Output format"),
+		columns: _nhtio_validation.validator.array().items(_nhtio_validation.validator.string()).optional().description("Column keys to include, in order. If omitted, all keys from the first row are used.")
+	}),
+	handler: async (args) => {
+		const { data, format, columns: explicitColumns } = args;
+		let rows;
+		try {
+			rows = JSON.parse(data);
+		} catch {
+			return "Error: Invalid JSON input.";
+		}
+		if (!Array.isArray(rows)) return "Error: Input must be a JSON array.";
+		if (rows.length === 0) return "Empty array — no data to display.";
+		const columns = explicitColumns ?? Object.keys(rows[0]);
+		if (format === "csv") {
+			const lines = [columns.map(csvEscape).join(",")];
+			for (const row of rows) {
+				const obj = row;
+				lines.push(columns.map((col) => csvEscape(obj[col])).join(","));
+			}
+			return lines.join("\n");
+		}
+		if (format === "tsv") {
+			const lines = [columns.map(tsvEscape).join("	")];
+			for (const row of rows) {
+				const obj = row;
+				lines.push(columns.map((col) => tsvEscape(obj[col])).join("	"));
+			}
+			return lines.join("\n");
+		}
+		return [
+			"| " + columns.map(mdEscape).join(" | ") + " |",
+			"| " + columns.map(() => "---").join(" | ") + " |",
+			...rows.map((row) => {
+				const obj = row;
+				return "| " + columns.map((col) => mdEscape(obj[col])).join(" | ") + " |";
+			})
+		].join("\n");
+	}
+});
+/**
+* Pretty-print or minify a JSON string.
+*
+* @remarks
+* Validates the input as JSON, then re-serialises it with the requested indentation. `indent` is
+* clamped to the range [0, 8]; `0` produces minified output.
+*/
+var jsonFormatTool = new require_tool.Tool({
+	name: "json_format",
+	description: "Pretty-print or minify a JSON string. Validates JSON and normalises whitespace.",
+	inputSchema: _nhtio_validation.validator.object({
+		data: _nhtio_validation.validator.string().required().description("JSON string to format"),
+		indent: _nhtio_validation.validator.number().default(2).description("Indentation spaces (0 = minify, default: 2). Max: 8.")
+	}),
+	handler: async (args) => {
+		const { data, indent } = args;
+		try {
+			const parsed = JSON.parse(data);
+			return JSON.stringify(parsed, null, Math.max(0, Math.min(8, Math.floor(indent))));
+		} catch (err) {
+			return `Error: Invalid JSON — ${require_tool_registry.isError(err) ? err.message : String(err)}`;
+		}
+	}
+});
+var FORMAT_PATTERNS = {
+	email: {
+		pattern: /^[^\s@]+@[^\s@]+\.[^\s@]+$/,
+		label: "email address"
+	},
+	uuid: {
+		pattern: /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,
+		label: "UUID (v1–v5)"
+	},
+	ipv4: {
+		pattern: /^((25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(25[0-5]|2[0-4]\d|[01]?\d\d?)$/,
+		label: "IPv4 address"
+	},
+	iso_date: {
+		pattern: /^\d{4}-\d{2}-\d{2}$/,
+		label: "ISO 8601 date (YYYY-MM-DD)"
+	},
+	iso_datetime: {
+		pattern: /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(:\d{2}(\.\d+)?)?(Z|[+-]\d{2}:\d{2})?$/,
+		label: "ISO 8601 datetime"
+	},
+	hex_color: {
+		pattern: /^#([0-9a-fA-F]{3}|[0-9a-fA-F]{4}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/,
+		label: "CSS hex color"
+	},
+	phone_e164: {
+		pattern: /^\+[1-9]\d{1,14}$/,
+		label: "E.164 phone number"
+	},
+	semver: {
+		pattern: /^\d+\.\d+\.\d+(-[0-9A-Za-z-.]+)?(\+[0-9A-Za-z-.]+)?$/,
+		label: "Semantic Version (SemVer)"
+	},
+	integer: {
+		pattern: /^-?\d+$/,
+		label: "integer"
+	},
+	decimal: {
+		pattern: /^-?\d+(\.\d+)?$/,
+		label: "decimal number"
+	},
+	alphanumeric: {
+		pattern: /^[a-zA-Z0-9]+$/,
+		label: "alphanumeric string"
+	},
+	slug: {
+		pattern: /^[a-z0-9]+(-[a-z0-9]+)*$/,
+		label: "URL slug"
+	},
+	hex: {
+		pattern: /^(0x)?[0-9a-fA-F]+$/,
+		label: "hexadecimal string"
+	},
+	base64: {
+		pattern: /^[A-Za-z0-9+/]*={0,2}$/,
+		label: "base64-encoded string"
+	}
+};
+/**
+* Check whether a string matches a known format.
+*
+* @remarks
+* Supported formats: `email`, `uuid` (v1–v5), `ipv4`, `iso_date`, `iso_datetime`, `hex_color`,
+* `phone_e164`, `semver`, `integer`, `decimal`, `alphanumeric`, `slug`, `hex`, `base64`.
+*/
+var validateFormatTool = new require_tool.Tool({
+	name: "validate_format",
+	description: "Check whether a string matches a known format (email, UUID, ISO date, hex colour, phone number, semver, slug, etc.).",
+	inputSchema: _nhtio_validation.validator.object({
+		value: _nhtio_validation.validator.string().required().description("The string to validate"),
+		format: _nhtio_validation.validator.string().valid(...Object.keys(FORMAT_PATTERNS)).required().description(`Format to validate against. One of: ${Object.keys(FORMAT_PATTERNS).join(", ")}`)
+	}),
+	handler: async (args) => {
+		const { value, format } = args;
+		const def = FORMAT_PATTERNS[format];
+		if (!def) return `Error: Unknown format "${format}". Supported: ${Object.keys(FORMAT_PATTERNS).join(", ")}`;
+		return def.pattern.test(value) ? `Valid: "${value}" is a valid ${def.label}.` : `Invalid: "${value}" is not a valid ${def.label}.`;
+	}
+});
+//#endregion
+exports.formatTableTool = formatTableTool;
+exports.jsonFormatTool = jsonFormatTool;
+exports.validateFormatTool = validateFormatTool;
+
+//# sourceMappingURL=structured_data.cjs.map

package/batteries/tools/structured_data.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"structured_data.cjs","names":[],"sources":["../../../src/batteries/tools/structured_data/index.ts"],"sourcesContent":["/**\n * Pre-constructed tools for transforming arrays and objects into tables and tabular text.\n *\n * @module @nhtio/adk/batteries/tools/structured_data\n *\n * @remarks\n * Pre-constructed bundled tools for the `structured_data` category. Import individually, the whole\n * category, or import every tool via `@nhtio/adk/batteries`.\n */\n\nimport { Tool } from '@nhtio/adk/common'\nimport { isError } from '@nhtio/adk/guards'\nimport { validator } from '@nhtio/validation'\n\nfunction csvEscape(value: unknown): string {\n  const str = value === null || value === undefined ? '' : String(value)\n  if (str.includes(',') || str.includes('\"') || str.includes('\\n') || str.includes('\\r')) {\n    return '\"' + str.replace(/\"/g, '\"\"') + '\"'\n  }\n  return str\n}\n\nfunction tsvEscape(value: unknown): string {\n  const str = value === null || value === undefined ? '' : String(value)\n  return str.replace(/\\t/g, ' ').replace(/\\r?\\n/g, ' ')\n}\n\nfunction mdEscape(value: unknown): string {\n  return String(value === null || value === undefined ? '' : value)\n    .replace(/\\|/g, '\\\\|')\n    .replace(/\\r?\\n/g, ' ')\n}\n\n/**\n * Convert a JSON array of objects into a formatted table.\n *\n * @remarks\n * Supports `markdown`, `csv`, and `tsv` output. Columns default to the keys of the first row;\n * supply `columns` to control which keys appear and in what order.\n */\nexport const formatTableTool = new Tool({\n  name: 'format_table',\n  description:\n    'Convert a JSON array of objects into a formatted table. Supports Markdown, CSV, and TSV output.',\n  inputSchema: validator.object({\n    data: validator.string().required().description('JSON array of objects as a string'),\n    format: validator\n      .string()\n      .valid('markdown', 'csv', 'tsv')\n      .required()\n      .description('Output format'),\n    columns: validator\n      .array()\n      .items(validator.string())\n      .optional()\n      .description(\n        'Column keys to include, in order. If omitted, all keys from the first row are used.'\n      ),\n  }),\n  handler: async (args) => {\n    const {\n      data,\n      format,\n      columns: explicitColumns,\n    } = args as {\n      data: string\n      format: 'markdown' | 'csv' | 'tsv'\n      columns?: string[]\n    }\n\n    let rows: unknown[]\n    try {\n      rows = JSON.parse(data)\n    } catch {\n      return 'Error: Invalid JSON input.'\n    }\n\n    if (!Array.isArray(rows)) return 'Error: Input must be a JSON array.'\n    if (rows.length === 0) return 'Empty array — no data to display.'\n\n    const columns = explicitColumns ?? Object.keys(rows[0] as Record<string, unknown>)\n\n    if (format === 'csv') {\n      const lines = [columns.map(csvEscape).join(',')]\n      for (const row of rows) {\n        const obj = row as Record<string, unknown>\n        lines.push(columns.map((col) => csvEscape(obj[col])).join(','))\n      }\n      return lines.join('\\n')\n    }\n\n    if (format === 'tsv') {\n      const lines = [columns.map(tsvEscape).join('\\t')]\n      for (const row of rows) {\n        const obj = row as Record<string, unknown>\n        lines.push(columns.map((col) => tsvEscape(obj[col])).join('\\t'))\n      }\n      return lines.join('\\n')\n    }\n\n    const header = '| ' + columns.map(mdEscape).join(' | ') + ' |'\n    const separator = '| ' + columns.map(() => '---').join(' | ') + ' |'\n    const dataRows = rows.map((row) => {\n      const obj = row as Record<string, unknown>\n      return '| ' + columns.map((col) => mdEscape(obj[col])).join(' | ') + ' |'\n    })\n    return [header, separator, ...dataRows].join('\\n')\n  },\n})\n\n/**\n * Pretty-print or minify a JSON string.\n *\n * @remarks\n * Validates the input as JSON, then re-serialises it with the requested indentation. `indent` is\n * clamped to the range [0, 8]; `0` produces minified output.\n */\nexport const jsonFormatTool = new Tool({\n  name: 'json_format',\n  description: 'Pretty-print or minify a JSON string. Validates JSON and normalises whitespace.',\n  inputSchema: validator.object({\n    data: validator.string().required().description('JSON string to format'),\n    indent: validator\n      .number()\n      .default(2)\n      .description('Indentation spaces (0 = minify, default: 2). Max: 8.'),\n  }),\n  handler: async (args) => {\n    const { data, indent } = args as { data: string; indent: number }\n    try {\n      const parsed = JSON.parse(data)\n      return JSON.stringify(parsed, null, Math.max(0, Math.min(8, Math.floor(indent))))\n    } catch (err) {\n      return `Error: Invalid JSON — ${isError(err) ? err.message : String(err)}`\n    }\n  },\n})\n\nconst FORMAT_PATTERNS: Record<string, { pattern: RegExp; label: string }> = {\n  email: {\n    pattern: /^[^\\s@]+@[^\\s@]+\\.[^\\s@]+$/,\n    label: 'email address',\n  },\n  uuid: {\n    pattern: /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,\n    label: 'UUID (v1–v5)',\n  },\n  ipv4: {\n    pattern: /^((25[0-5]|2[0-4]\\d|[01]?\\d\\d?)\\.){3}(25[0-5]|2[0-4]\\d|[01]?\\d\\d?)$/,\n    label: 'IPv4 address',\n  },\n  iso_date: {\n    pattern: /^\\d{4}-\\d{2}-\\d{2}$/,\n    label: 'ISO 8601 date (YYYY-MM-DD)',\n  },\n  iso_datetime: {\n    pattern: /^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}(:\\d{2}(\\.\\d+)?)?(Z|[+-]\\d{2}:\\d{2})?$/,\n    label: 'ISO 8601 datetime',\n  },\n  hex_color: {\n    pattern: /^#([0-9a-fA-F]{3}|[0-9a-fA-F]{4}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/,\n    label: 'CSS hex color',\n  },\n  phone_e164: {\n    pattern: /^\\+[1-9]\\d{1,14}$/,\n    label: 'E.164 phone number',\n  },\n  semver: {\n    pattern: /^\\d+\\.\\d+\\.\\d+(-[0-9A-Za-z-.]+)?(\\+[0-9A-Za-z-.]+)?$/,\n    label: 'Semantic Version (SemVer)',\n  },\n  integer: {\n    pattern: /^-?\\d+$/,\n    label: 'integer',\n  },\n  decimal: {\n    pattern: /^-?\\d+(\\.\\d+)?$/,\n    label: 'decimal number',\n  },\n  alphanumeric: {\n    pattern: /^[a-zA-Z0-9]+$/,\n    label: 'alphanumeric string',\n  },\n  slug: {\n    pattern: /^[a-z0-9]+(-[a-z0-9]+)*$/,\n    label: 'URL slug',\n  },\n  hex: {\n    pattern: /^(0x)?[0-9a-fA-F]+$/,\n    label: 'hexadecimal string',\n  },\n  base64: {\n    pattern: /^[A-Za-z0-9+/]*={0,2}$/,\n    label: 'base64-encoded string',\n  },\n}\n\n/**\n * Check whether a string matches a known format.\n *\n * @remarks\n * Supported formats: `email`, `uuid` (v1–v5), `ipv4`, `iso_date`, `iso_datetime`, `hex_color`,\n * `phone_e164`, `semver`, `integer`, `decimal`, `alphanumeric`, `slug`, `hex`, `base64`.\n */\nexport const validateFormatTool = new Tool({\n  name: 'validate_format',\n  description:\n    'Check whether a string matches a known format (email, UUID, ISO date, hex colour, phone number, semver, slug, etc.).',\n  inputSchema: validator.object({\n    value: validator.string().required().description('The string to validate'),\n    format: validator\n      .string()\n      .valid(...Object.keys(FORMAT_PATTERNS))\n      .required()\n      .description(\n        `Format to validate against. One of: ${Object.keys(FORMAT_PATTERNS).join(', ')}`\n      ),\n  }),\n  handler: async (args) => {\n    const { value, format } = args as { value: string; format: string }\n    const def = FORMAT_PATTERNS[format]\n    if (!def) {\n      return `Error: Unknown format \"${format}\". Supported: ${Object.keys(FORMAT_PATTERNS).join(', ')}`\n    }\n    const valid = def.pattern.test(value)\n    return valid\n      ? `Valid: \"${value}\" is a valid ${def.label}.`\n      : `Invalid: \"${value}\" is not a valid ${def.label}.`\n  },\n})\n"],"mappings":"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"}