@wrongstack/tools 0.313.0 → 0.316.1

package/dist/chunk-VB3MJGCV.js

@@ -0,0 +1,610 @@
+import {
+  capSubject,
+  compileUserRegex
+} from "./chunk-Q5JPPCZC.js";
+import {
+  safeResolveReal
+} from "./chunk-D33S4RQG.js";
+
+// src/json.ts
+import * as fs from "node:fs/promises";
+import { deepMerge as deepMergeCore } from "@wrongstack/core/utils";
+var MAX_JSON_FILE_BYTES = 16 * 1024 * 1024;
+var MAX_JSON_FILE_BYTES_HUMAN = "16 MiB";
+var JsonFileTooLargeError = class extends Error {
+  constructor(filePath, size) {
+    super(
+      `json: "${filePath}" is ${size} bytes \u2014 exceeds the ${MAX_JSON_FILE_BYTES_HUMAN} file-size limit. Extract the relevant portion into a smaller file first, or use a shell tool to query it directly.`
+    );
+    this.name = "JsonFileTooLargeError";
+  }
+};
+async function readJsonFileBounded(filePath, ctx) {
+  const resolved = await safeResolveReal(filePath, ctx);
+  const stat2 = await fs.stat(resolved);
+  if (stat2.size > MAX_JSON_FILE_BYTES) {
+    throw new JsonFileTooLargeError(filePath, stat2.size);
+  }
+  return fs.readFile(resolved, "utf8");
+}
+var jsonTool = {
+  name: "json",
+  category: "Data",
+  description: "Parse, pretty-print, query, validate, transform, and merge JSON/JSON5/YAML. Use `action` to select the operation: parse (default), query, validate, transform, or merge.",
+  usageHint: 'VERY USEFUL FOR DATA INSPECTION:\n\n- `action: "parse"` (default): read/pretty-print/convert JSON, JSON5, or YAML from `file` or `data`.\n- `action: "query"`: JMESPath-like query (`a.b[0].c`, `items[*].name`, filters, functions).\n- `action: "validate"`: validate data against a JSON Schema (`schema` param).\n- `action: "transform"`: chain multiple JMESPath transforms (`transforms` param).\n- `action: "merge"`: deep merge `base` and `patch` objects (`conflictResolution` param).\nPrefer this over raw `read` + manual parsing when dealing with configuration or data files.',
+  permission: "auto",
+  mutating: false,
+  maxOutputBytes: 262144,
+  timeoutMs: 5e3,
+  capabilities: ["fs.read"],
+  icon: "json",
+  inputSchema: {
+    type: "object",
+    properties: {
+      action: {
+        type: "string",
+        enum: ["parse", "query", "validate", "transform", "merge"],
+        description: "Operation (default: parse). parse=read/pretty-print, query=JMESPath, validate=schema, transform=chained queries, merge=deep merge."
+      },
+      file: { type: "string", description: "Path to JSON/JSON5/YAML file (parse/query/validate)" },
+      data: {
+        type: "string",
+        description: "JSON/JSON5/YAML string (parse/query/validate, alternative to file)"
+      },
+      format: {
+        type: "string",
+        enum: ["json", "json5", "yaml"],
+        description: "Output format for parse/query/transform (default: json)"
+      },
+      query: {
+        type: "string",
+        description: "JMESPath-like query expression (query action)"
+      },
+      transforms: {
+        type: "array",
+        items: { type: "string" },
+        description: "Ordered JMESPath query strings (transform action)"
+      },
+      schema: {
+        type: "object",
+        description: "JSON Schema to validate against (validate action)"
+      },
+      base: { description: "Base JSON object (merge action)" },
+      patch: { description: "Patch JSON object to merge in (merge action)" },
+      conflictResolution: {
+        type: "string",
+        enum: ["prefer-base", "prefer-patch"],
+        description: "Merge conflict resolution (default: prefer-patch)"
+      },
+      validate: {
+        type: "boolean",
+        description: "Validate syntax only, no output (parse action, default: false)"
+      }
+    }
+  },
+  async execute(input, ctx) {
+    const action = input.action ?? "parse";
+    switch (action) {
+      case "query":
+        return executeQuery(input, ctx);
+      case "validate":
+        return executeValidate(input, ctx);
+      case "transform":
+        return executeTransform(input, ctx);
+      case "merge":
+        return executeMerge(input);
+      default:
+        return executeParse(input, ctx);
+    }
+  }
+};
+async function executeParse(input, ctx) {
+  const format = input.format ?? "json";
+  let parsed;
+  let raw;
+  if (input.file) {
+    try {
+      raw = await readJsonFileBounded(input.file, ctx);
+    } catch (error) {
+      return {
+        data: null,
+        formatted: "",
+        type: "unknown",
+        action: "parse",
+        error: error instanceof JsonFileTooLargeError ? error.message : "Could not read file"
+      };
+    }
+  } else if (input.data) {
+    raw = input.data;
+  } else {
+    return {
+      data: null,
+      formatted: "",
+      type: "unknown",
+      action: "parse",
+      error: "Provide file or data"
+    };
+  }
+  try {
+    parsed = JSON.parse(raw);
+  } catch (e) {
+    return {
+      data: null,
+      formatted: "",
+      type: "unknown",
+      action: "parse",
+      /* v8 ignore next -- JSON.parse only throws SyntaxError (an Error); the String(e) side is defensive. */
+      error: `Parse failed: ${e instanceof Error ? e.message : String(e)}`
+    };
+  }
+  if (input.validate) {
+    return {
+      data: parsed,
+      formatted: "valid",
+      type: Array.isArray(parsed) ? "array" : typeof parsed,
+      action: "parse",
+      keys: typeof parsed === "object" && parsed !== null ? Object.keys(parsed) : void 0
+    };
+  }
+  if (input.query) {
+    const queryResult = simpleQuery(parsed, input.query);
+    const formatted2 = formatOutput(queryResult, format);
+    return {
+      data: parsed,
+      formatted: formatted2,
+      type: Array.isArray(parsed) ? "array" : typeof parsed,
+      action: "parse",
+      keys: typeof parsed === "object" && parsed !== null ? Object.keys(parsed) : void 0,
+      query_result: queryResult
+    };
+  }
+  const formatted = formatOutput(parsed, format);
+  return {
+    data: parsed,
+    formatted,
+    type: Array.isArray(parsed) ? "array" : typeof parsed,
+    action: "parse",
+    keys: typeof parsed === "object" && parsed !== null ? Object.keys(parsed) : void 0
+  };
+}
+async function executeQuery(input, ctx) {
+  if (!input.query) {
+    return {
+      data: null,
+      formatted: "",
+      type: "unknown",
+      action: "query",
+      error: "query is required for action: query"
+    };
+  }
+  let parsed;
+  if (input.file) {
+    try {
+      const raw = await readJsonFileBounded(input.file, ctx);
+      parsed = JSON.parse(raw);
+    } catch (error) {
+      return {
+        data: null,
+        formatted: "",
+        type: "unknown",
+        action: "query",
+        error: error instanceof JsonFileTooLargeError ? error.message : "Could not read/parse file"
+      };
+    }
+  } else if (input.data) {
+    try {
+      parsed = JSON.parse(input.data);
+    } catch {
+      return {
+        data: null,
+        formatted: "",
+        type: "unknown",
+        action: "query",
+        error: "Could not parse data string"
+      };
+    }
+  } else {
+    return {
+      data: null,
+      formatted: "",
+      type: "unknown",
+      action: "query",
+      error: "Provide file or data"
+    };
+  }
+  try {
+    const result = jmespathSearch(parsed, input.query);
+    const format = input.format ?? "json";
+    return {
+      data: parsed,
+      formatted: formatOutput(result, format),
+      type: result === null ? "null" : Array.isArray(result) ? "array" : typeof result,
+      action: "query",
+      query_result: result
+    };
+  } catch (e) {
+    return {
+      data: null,
+      formatted: "",
+      type: "unknown",
+      action: "query",
+      /* v8 ignore next -- defensive String(e) */
+      error: `Query failed: ${e instanceof Error ? e.message : String(e)}`
+    };
+  }
+}
+async function executeValidate(input, ctx) {
+  if (!input.schema) {
+    return {
+      data: null,
+      formatted: "",
+      type: "unknown",
+      action: "validate",
+      error: "schema is required for action: validate"
+    };
+  }
+  let parsed;
+  if (input.file) {
+    try {
+      const raw = await readJsonFileBounded(input.file, ctx);
+      parsed = JSON.parse(raw);
+    } catch (error) {
+      return {
+        data: null,
+        formatted: "",
+        type: "unknown",
+        action: "validate",
+        error: error instanceof JsonFileTooLargeError ? error.message : "Could not read/parse file"
+      };
+    }
+  } else if (input.data) {
+    try {
+      parsed = JSON.parse(input.data);
+    } catch {
+      return {
+        data: null,
+        formatted: "",
+        type: "unknown",
+        action: "validate",
+        error: "Could not parse data string"
+      };
+    }
+  } else {
+    return {
+      data: null,
+      formatted: "",
+      type: "unknown",
+      action: "validate",
+      error: "Provide file or data"
+    };
+  }
+  try {
+    const { valid, errors } = validateJsonSchema(parsed, input.schema);
+    return {
+      data: parsed,
+      formatted: valid ? "valid" : "invalid",
+      type: Array.isArray(parsed) ? "array" : typeof parsed,
+      action: "validate",
+      valid,
+      errors
+    };
+  } catch (e) {
+    return {
+      data: null,
+      formatted: "",
+      type: "unknown",
+      action: "validate",
+      /* v8 ignore next -- defensive String(e) */
+      error: `Validation failed: ${e instanceof Error ? e.message : String(e)}`
+    };
+  }
+}
+async function executeTransform(input, ctx) {
+  if (!input.transforms || input.transforms.length === 0) {
+    return {
+      data: null,
+      formatted: "",
+      type: "unknown",
+      action: "transform",
+      error: "transforms array is required for action: transform"
+    };
+  }
+  let parsed;
+  if (input.file) {
+    try {
+      const raw = await readJsonFileBounded(input.file, ctx);
+      parsed = JSON.parse(raw);
+    } catch (error) {
+      return {
+        data: null,
+        formatted: "",
+        type: "unknown",
+        action: "transform",
+        error: error instanceof JsonFileTooLargeError ? error.message : "Could not read/parse file"
+      };
+    }
+  } else if (input.data) {
+    try {
+      parsed = JSON.parse(input.data);
+    } catch {
+      return {
+        data: null,
+        formatted: "",
+        type: "unknown",
+        action: "transform",
+        error: "Could not parse data string"
+      };
+    }
+  } else {
+    return {
+      data: null,
+      formatted: "",
+      type: "unknown",
+      action: "transform",
+      error: "Provide file or data"
+    };
+  }
+  try {
+    let current = parsed;
+    const steps = [];
+    for (const t of input.transforms) {
+      current = jmespathSearch(current, t);
+      steps.push({ transform: t, result: current });
+    }
+    const format = input.format ?? "json";
+    return {
+      data: parsed,
+      formatted: formatOutput(current, format),
+      type: current === null ? "null" : Array.isArray(current) ? "array" : typeof current,
+      action: "transform",
+      result: current,
+      steps
+    };
+  } catch (e) {
+    return {
+      data: null,
+      formatted: "",
+      type: "unknown",
+      action: "transform",
+      /* v8 ignore next -- defensive String(e) */
+      error: `Transform failed: ${e instanceof Error ? e.message : String(e)}`
+    };
+  }
+}
+async function executeMerge(input) {
+  if (input.base === void 0 || input.patch === void 0) {
+    return {
+      data: null,
+      formatted: "",
+      type: "unknown",
+      action: "merge",
+      error: "base and patch are required for action: merge"
+    };
+  }
+  const conflictResolution = input.conflictResolution ?? "prefer-patch";
+  try {
+    const result = deepMergeCore(input.base, input.patch, { conflictResolution });
+    const format = input.format ?? "json";
+    return {
+      data: result,
+      formatted: formatOutput(result, format),
+      type: result === null ? "null" : Array.isArray(result) ? "array" : typeof result,
+      action: "merge",
+      result
+    };
+  } catch (e) {
+    return {
+      data: null,
+      formatted: "",
+      type: "unknown",
+      action: "merge",
+      /* v8 ignore next -- defensive String(e) */
+      error: `Merge failed: ${e instanceof Error ? e.message : String(e)}`
+    };
+  }
+}
+function jmespathSearch(data, query) {
+  if (!query || query === "@") return data;
+  if (query === "$") return data;
+  const dotMatch = query.match(/^([a-zA-Z_][a-zA-Z0-9_]*)(?:\.(.+))?$/);
+  if (dotMatch) {
+    const key = dotMatch[1];
+    const rest = dotMatch[2];
+    const val = data?.[key];
+    if (rest === void 0) return val;
+    return jmespathSearch(val, rest);
+  }
+  const arrMatch = query.match(/^\[(\d+)\](?:\.(.+))?$/);
+  if (arrMatch) {
+    const idx = Number.parseInt(arrMatch[1], 10);
+    const rest = arrMatch[2];
+    const arr = data;
+    const val = arr?.[idx];
+    if (rest === void 0) return val;
+    return jmespathSearch(val, rest);
+  }
+  if (query === "[*]") {
+    if (Array.isArray(data)) {
+      return data;
+    }
+    return data;
+  }
+  const multiMatch = query.match(/^([a-zA-Z_][a-zA-Z0-9_]*)\[\*\](?:\.(.+))?$/);
+  if (multiMatch) {
+    const key = multiMatch[1];
+    const rest = multiMatch[2];
+    const arr = data?.[key];
+    if (!Array.isArray(arr)) return [];
+    if (rest === void 0) return arr;
+    return arr.map((item) => jmespathSearch(item, rest));
+  }
+  const filterMatch = query.match(
+    /^\[\\?([a-zA-Z_][a-zA-Z0-9_]*)(==|!=|<|>|<=|>=)(`[^`]+`|'[^']*')\](?:\.(.+))?$/
+  );
+  if (filterMatch) {
+    const field = filterMatch[1];
+    const op = filterMatch[2];
+    const rawVal = filterMatch[3];
+    const rest = filterMatch[4];
+    const cmpVal = JSON.parse(rawVal.slice(1, -1));
+    const arr = data;
+    if (!Array.isArray(arr)) return [];
+    const filtered = arr.filter((item) => {
+      const itemVal = item[field];
+      switch (op) {
+        case "==":
+          return itemVal === cmpVal;
+        case "!=":
+          return itemVal !== cmpVal;
+        case ">":
+          return Number(itemVal) > Number(cmpVal);
+        case "<":
+          return Number(itemVal) < Number(cmpVal);
+        case ">=":
+          return Number(itemVal) >= Number(cmpVal);
+        case "<=":
+          return Number(itemVal) <= Number(cmpVal);
+        /* v8 ignore next -- op is constrained to the six operators by the filter regex; default is unreachable. */
+        default:
+          return true;
+      }
+    });
+    if (rest === void 0) return filtered;
+    return filtered.map((item) => jmespathSearch(item, rest));
+  }
+  const fnMatch = query.match(/^(length|keys|values|type)\(@\)$/);
+  if (fnMatch) {
+    const fn = fnMatch[1];
+    switch (fn) {
+      case "length":
+        if (Array.isArray(data)) return data.length;
+        if (typeof data === "string") return data.length;
+        if (typeof data === "object" && data !== null) return Object.keys(data).length;
+        return 0;
+      case "keys":
+        if (typeof data === "object" && data !== null && !Array.isArray(data))
+          return Object.keys(data);
+        return [];
+      case "values":
+        if (typeof data === "object" && data !== null && !Array.isArray(data))
+          return Object.values(data);
+        return [];
+      case "type":
+        if (data === null) return "null";
+        if (Array.isArray(data)) return "array";
+        return typeof data;
+      /* v8 ignore next 2 -- fn is constrained to the four names by the function regex; default is unreachable. */
+      default:
+        return null;
+    }
+  }
+  return null;
+}
+function validateJsonSchema(data, schema) {
+  const errors = [];
+  function check(value, s, path) {
+    if (s["type"]) {
+      const expectedType = s["type"];
+      const actualType = Array.isArray(value) ? "array" : value === null ? "null" : typeof value;
+      if (expectedType === "integer") {
+        if (!Number.isInteger(value)) errors.push(`${path}: expected integer, got ${actualType}`);
+      } else if (expectedType !== actualType) {
+        errors.push(`${path}: expected ${expectedType}, got ${actualType}`);
+      }
+    }
+    if (typeof value === "string" && s["format"] === "uri" && value) {
+      try {
+        new URL(value);
+      } catch {
+        errors.push(`${path}: not a valid URI`);
+      }
+    }
+    if (typeof value === "string" && s["pattern"]) {
+      const compiled = compileUserRegex(s["pattern"], "");
+      if (!compiled.ok) {
+        errors.push(`${path}: invalid schema pattern \u2014 ${compiled.reason}`);
+      } else if (!compiled.regex.test(capSubject(value))) {
+        errors.push(`${path}: does not match pattern ${s["pattern"]}`);
+      }
+    }
+    if (typeof value === "string" && s["minLength"] !== void 0 && value.length < s["minLength"]) {
+      errors.push(`${path}: string too short (min ${s["minLength"]})`);
+    }
+    if (typeof value === "string" && s["maxLength"] !== void 0 && value.length > s["maxLength"]) {
+      errors.push(`${path}: string too long (max ${s["maxLength"]})`);
+    }
+    if (typeof value === "number" && s["minimum"] !== void 0 && value < s["minimum"]) {
+      errors.push(`${path}: below minimum ${s["minimum"]}`);
+    }
+    if (typeof value === "number" && s["maximum"] !== void 0 && value > s["maximum"]) {
+      errors.push(`${path}: above maximum ${s["maximum"]}`);
+    }
+    if (Array.isArray(value) && s["items"] && Array.isArray(s["items"])) {
+      for (let i = 0; i < value.length; i++) {
+        check(value[i], s["items"], `${path}[${i}]`);
+      }
+    }
+    if (typeof value === "object" && value !== null && !Array.isArray(value) && s["properties"]) {
+      const props = s["properties"];
+      for (const [k, propSchema] of Object.entries(props)) {
+        check(value[k], propSchema, `${path}.${k}`);
+      }
+    }
+  }
+  check(data, schema, "$");
+  return { valid: errors.length === 0, errors };
+}
+function simpleQuery(data, path) {
+  const parts = path.replace(/\[(\d+)\]/g, ".$1").split(".").filter(Boolean);
+  let current = data;
+  for (const part of parts) {
+    if (current === null || current === void 0) return void 0;
+    const idx = Number(part);
+    if (!Number.isNaN(idx) && Array.isArray(current)) {
+      current = current[idx];
+    } else if (typeof current === "object" && current !== null) {
+      current = current[part];
+    } else {
+      return void 0;
+    }
+  }
+  return current;
+}
+function formatOutput(data, format) {
+  if (format === "json5") {
+    return JSON.stringify(data, null, 2).replace(/,\s*}/g, "}").replace(/,\s*\]/g, "]");
+  }
+  if (format === "yaml") {
+    return toYaml(data);
+  }
+  return JSON.stringify(data, null, 2);
+}
+function toYaml(data, indent = 0) {
+  if (data === null) return "null\n";
+  if (data === void 0) return "";
+  if (typeof data === "boolean") return String(data) + "\n";
+  if (typeof data === "number") return String(data) + "\n";
+  if (typeof data === "string") {
+    if (data.includes("\n") || data.includes(":") || data.includes("#")) {
+      return `"${data.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"
+`;
+    }
+    return data + "\n";
+  }
+  if (Array.isArray(data)) {
+    if (data.length === 0) return "[]\n";
+    const prefix = "  ".repeat(indent);
+    return data.map((item) => `${prefix}- ${toYaml(item, indent + 1).trimStart()}`).join("");
+  }
+  if (typeof data === "object") {
+    const prefix = "  ".repeat(indent);
+    const entries = Object.entries(data);
+    return entries.map(([k, v]) => `${prefix}${k}: ${toYaml(v, indent + 1)}`).join("");
+  }
+  return String(data) + "\n";
+}
+
+export {
+  jsonTool
+};
+//# sourceMappingURL=chunk-VB3MJGCV.js.map