@rog0x/mcp-json-tools 1.0.0

package/src/tools/json-to-csv.ts

@@ -0,0 +1,116 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+
+function escapeCell(value: string, delimiter: string): string {
+  if (
+    value.includes(delimiter) ||
+    value.includes('"') ||
+    value.includes("\n") ||
+    value.includes("\r")
+  ) {
+    return `"${value.replace(/"/g, '""')}"`;
+  }
+  return value;
+}
+
+function toCsvValue(value: unknown): string {
+  if (value === null || value === undefined) {
+    return "";
+  }
+  if (typeof value === "object") {
+    return JSON.stringify(value);
+  }
+  return String(value);
+}
+
+export function registerJsonToCsv(server: McpServer): void {
+  server.tool(
+    "json_to_csv",
+    "Convert a JSON array of objects to CSV text. Automatically extracts headers from object keys.",
+    {
+      data: z
+        .string()
+        .describe("The JSON array to convert (as a JSON string)"),
+      delimiter: z
+        .string()
+        .optional()
+        .describe("Column delimiter character (default: ',')"),
+      includeHeaders: z
+        .boolean()
+        .optional()
+        .describe("Whether to include a header row (default: true)"),
+    },
+    async ({ data, delimiter, includeHeaders }) => {
+      try {
+        const parsed = JSON.parse(data);
+
+        if (!Array.isArray(parsed)) {
+          throw new Error("Input must be a JSON array");
+        }
+
+        if (parsed.length === 0) {
+          return {
+            content: [
+              {
+                type: "text" as const,
+                text: "",
+              },
+            ],
+          };
+        }
+
+        const delim = delimiter || ",";
+        const withHeaders = includeHeaders !== false;
+
+        const headerSet = new Set<string>();
+        for (const row of parsed) {
+          if (typeof row === "object" && row !== null && !Array.isArray(row)) {
+            for (const key of Object.keys(row as Record<string, unknown>)) {
+              headerSet.add(key);
+            }
+          }
+        }
+        const headers = Array.from(headerSet);
+
+        const lines: string[] = [];
+
+        if (withHeaders) {
+          lines.push(
+            headers.map((h) => escapeCell(h, delim)).join(delim)
+          );
+        }
+
+        for (const row of parsed) {
+          if (typeof row === "object" && row !== null && !Array.isArray(row)) {
+            const record = row as Record<string, unknown>;
+            const cells = headers.map((h) =>
+              escapeCell(toCsvValue(record[h]), delim)
+            );
+            lines.push(cells.join(delim));
+          }
+        }
+
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: lines.join("\n"),
+            },
+          ],
+        };
+      } catch (error) {
+        const message =
+          error instanceof Error ? error.message : String(error);
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: `Error converting JSON to CSV: ${message}`,
+            },
+          ],
+          isError: true,
+        };
+      }
+    }
+  );
+}

package/src/tools/json-transform.ts

@@ -0,0 +1,223 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+
+function getNestedValue(obj: unknown, path: string): unknown {
+  const parts = path.split(".");
+  let current: unknown = obj;
+  for (const part of parts) {
+    if (current === null || current === undefined || typeof current !== "object") {
+      return undefined;
+    }
+    current = (current as Record<string, unknown>)[part];
+  }
+  return current;
+}
+
+function setNestedValue(
+  obj: Record<string, unknown>,
+  path: string,
+  value: unknown
+): void {
+  const parts = path.split(".");
+  let current: Record<string, unknown> = obj;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const part = parts[i];
+    if (!(part in current) || typeof current[part] !== "object" || current[part] === null) {
+      current[part] = {};
+    }
+    current = current[part] as Record<string, unknown>;
+  }
+  current[parts[parts.length - 1]] = value;
+}
+
+function pickFields(
+  data: unknown,
+  fields: string[]
+): Record<string, unknown> {
+  const result: Record<string, unknown> = {};
+  for (const field of fields) {
+    const value = getNestedValue(data, field);
+    if (value !== undefined) {
+      result[field] = value;
+    }
+  }
+  return result;
+}
+
+function renameFields(
+  data: Record<string, unknown>,
+  mapping: Readonly<Record<string, string>>
+): Record<string, unknown> {
+  const result: Record<string, unknown> = {};
+  for (const [key, value] of Object.entries(data)) {
+    const newKey = mapping[key] || key;
+    result[newKey] = value;
+  }
+  return result;
+}
+
+function flattenObject(
+  obj: unknown,
+  prefix: string = "",
+  separator: string = "."
+): Record<string, unknown> {
+  const result: Record<string, unknown> = {};
+
+  if (obj === null || obj === undefined || typeof obj !== "object") {
+    return result;
+  }
+
+  if (Array.isArray(obj)) {
+    for (let i = 0; i < obj.length; i++) {
+      const newKey = prefix ? `${prefix}${separator}${i}` : String(i);
+      const val = obj[i];
+      if (typeof val === "object" && val !== null) {
+        Object.assign(result, flattenObject(val, newKey, separator));
+      } else {
+        result[newKey] = val;
+      }
+    }
+    return result;
+  }
+
+  for (const [key, value] of Object.entries(obj as Record<string, unknown>)) {
+    const newKey = prefix ? `${prefix}${separator}${key}` : key;
+    if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+      Object.assign(result, flattenObject(value, newKey, separator));
+    } else if (Array.isArray(value)) {
+      Object.assign(result, flattenObject(value, newKey, separator));
+    } else {
+      result[newKey] = value;
+    }
+  }
+
+  return result;
+}
+
+function unflattenObject(
+  obj: Record<string, unknown>,
+  separator: string = "."
+): Record<string, unknown> {
+  const result: Record<string, unknown> = {};
+  for (const [key, value] of Object.entries(obj)) {
+    const parts = key.split(separator);
+    setNestedValue(result, parts.join("."), value);
+  }
+  return result;
+}
+
+export function registerJsonTransform(server: McpServer): void {
+  server.tool(
+    "json_transform",
+    "Apply transformations to a JSON object: pick specific fields, rename keys, flatten nested objects, or unflatten dot-notation keys.",
+    {
+      data: z.string().describe("The JSON data to transform (as a JSON string)"),
+      operation: z
+        .enum(["pick", "rename", "flatten", "unflatten"])
+        .describe("The transformation operation to apply"),
+      fields: z
+        .array(z.string())
+        .optional()
+        .describe(
+          "For 'pick': array of field paths to extract (supports dot notation like 'user.name')"
+        ),
+      mapping: z
+        .record(z.string(), z.string())
+        .optional()
+        .describe(
+          "For 'rename': object mapping old key names to new key names"
+        ),
+      separator: z
+        .string()
+        .optional()
+        .describe(
+          "For 'flatten'/'unflatten': separator character (default: '.')"
+        ),
+    },
+    async ({ data, operation, fields, mapping, separator }) => {
+      try {
+        const parsed = JSON.parse(data);
+        let result: unknown;
+        const sep = separator || ".";
+
+        switch (operation) {
+          case "pick": {
+            if (!fields || fields.length === 0) {
+              throw new Error(
+                "The 'fields' parameter is required for the 'pick' operation"
+              );
+            }
+            if (Array.isArray(parsed)) {
+              result = parsed.map((item: unknown) => pickFields(item, fields));
+            } else {
+              result = pickFields(parsed, fields);
+            }
+            break;
+          }
+          case "rename": {
+            if (!mapping || Object.keys(mapping).length === 0) {
+              throw new Error(
+                "The 'mapping' parameter is required for the 'rename' operation"
+              );
+            }
+            if (Array.isArray(parsed)) {
+              result = parsed.map((item: unknown) =>
+                renameFields(item as Record<string, unknown>, mapping)
+              );
+            } else {
+              result = renameFields(
+                parsed as Record<string, unknown>,
+                mapping
+              );
+            }
+            break;
+          }
+          case "flatten": {
+            if (Array.isArray(parsed)) {
+              result = parsed.map((item: unknown) =>
+                flattenObject(item, "", sep)
+              );
+            } else {
+              result = flattenObject(parsed, "", sep);
+            }
+            break;
+          }
+          case "unflatten": {
+            if (Array.isArray(parsed)) {
+              result = parsed.map((item: unknown) =>
+                unflattenObject(item as Record<string, unknown>, sep)
+              );
+            } else {
+              result = unflattenObject(
+                parsed as Record<string, unknown>,
+                sep
+              );
+            }
+            break;
+          }
+        }
+
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: JSON.stringify(result, null, 2),
+            },
+          ],
+        };
+      } catch (error) {
+        const message =
+          error instanceof Error ? error.message : String(error);
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: `Error transforming JSON: ${message}`,
+            },
+          ],
+          isError: true,
+        };
+      }
+    }
+  );
+}

package/src/tools/json-validator.ts

@@ -0,0 +1,91 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import Ajv, { ErrorObject } from "ajv";
+
+interface ValidationResult {
+  valid: boolean;
+  errors: Array<{
+    path: string;
+    message: string;
+    keyword: string;
+    params: Record<string, unknown>;
+  }>;
+}
+
+function validateJsonAgainstSchema(
+  data: unknown,
+  schema: Record<string, unknown>
+): ValidationResult {
+  const ajv = new Ajv({ allErrors: true, verbose: true });
+  const validate = ajv.compile(schema);
+  const valid = validate(data);
+
+  if (valid) {
+    return { valid: true, errors: [] };
+  }
+
+  const errors = (validate.errors || []).map((err: ErrorObject) => ({
+    path: err.instancePath || "/",
+    message: err.message || "Unknown validation error",
+    keyword: err.keyword,
+    params: err.params as Record<string, unknown>,
+  }));
+
+  return { valid: false, errors };
+}
+
+export function registerJsonValidator(server: McpServer): void {
+  server.tool(
+    "json_validate",
+    "Validate a JSON object against a JSON Schema. Returns whether the data is valid and a list of errors with their paths.",
+    {
+      data: z.string().describe("The JSON data to validate (as a JSON string)"),
+      schema: z
+        .string()
+        .describe("The JSON Schema to validate against (as a JSON string)"),
+    },
+    async ({ data, schema }) => {
+      try {
+        const parsedData = JSON.parse(data);
+        const parsedSchema = JSON.parse(schema);
+
+        const result = validateJsonAgainstSchema(parsedData, parsedSchema);
+
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: JSON.stringify(result, null, 2),
+            },
+          ],
+        };
+      } catch (error) {
+        const message =
+          error instanceof Error ? error.message : String(error);
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: JSON.stringify(
+                {
+                  valid: false,
+                  errors: [
+                    {
+                      path: "/",
+                      message: `Parse error: ${message}`,
+                      keyword: "parse",
+                      params: {},
+                    },
+                  ],
+                },
+                null,
+                2
+              ),
+            },
+          ],
+          isError: true,
+        };
+      }
+    }
+  );
+}

package/src/tools/yaml-json.ts

@@ -0,0 +1,83 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import YAML from "yaml";
+
+export function registerYamlJson(server: McpServer): void {
+  server.tool(
+    "yaml_to_json",
+    "Convert YAML text to a JSON string.",
+    {
+      yamlText: z.string().describe("The YAML text to convert to JSON"),
+      indent: z
+        .number()
+        .optional()
+        .describe("JSON indentation spaces (default: 2)"),
+    },
+    async ({ yamlText, indent }) => {
+      try {
+        const parsed = YAML.parse(yamlText);
+        const spaces = indent ?? 2;
+
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: JSON.stringify(parsed, null, spaces),
+            },
+          ],
+        };
+      } catch (error) {
+        const message =
+          error instanceof Error ? error.message : String(error);
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: `Error converting YAML to JSON: ${message}`,
+            },
+          ],
+          isError: true,
+        };
+      }
+    }
+  );
+
+  server.tool(
+    "json_to_yaml",
+    "Convert a JSON string to YAML text.",
+    {
+      jsonText: z.string().describe("The JSON text to convert to YAML"),
+      indent: z
+        .number()
+        .optional()
+        .describe("YAML indentation spaces (default: 2)"),
+    },
+    async ({ jsonText, indent }) => {
+      try {
+        const parsed = JSON.parse(jsonText);
+        const spaces = indent ?? 2;
+
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: YAML.stringify(parsed, { indent: spaces }),
+            },
+          ],
+        };
+      } catch (error) {
+        const message =
+          error instanceof Error ? error.message : String(error);
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: `Error converting JSON to YAML: ${message}`,
+            },
+          ],
+          isError: true,
+        };
+      }
+    }
+  );
+}

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "Node16",
+    "moduleResolution": "Node16",
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}