MCP Starter Kit

Instructions

Implementation Reference

• src/tools/data-transformer.ts:172-272 (handler)

  The main handler function for the `transform_data` tool, which manages input parsing, normalization, and formatting.

  export async function transformData(
    input: TransformDataInput
  ): Promise<ToolResult<TransformDataResult>> {
    const { from_format, to_format } = input;
    const options = input.options ?? {};
    const pretty = options.pretty ?? true;
    const include_header = options.include_header ?? true;
    const delimiter = options.delimiter;
  
    if (input.input.length > config.transformerMaxInput) {
      return {
        ok: false,
        error: `Input exceeds maximum size of ${config.transformerMaxInput} characters`,
        code: "INPUT_TOO_LARGE",
      };
    }
  
    logger.debug("Transforming data", { from_format, to_format });
  
    // Determine actual delimiters
    const inputDelimiter = delimiter ?? (from_format === "tsv" ? "\t" : ",");
    const outputDelimiter = to_format === "tsv" ? "\t" : ",";
  
    let parsed: unknown;
    try {
      if (from_format === "json") {
        parsed = parseJson(input.input);
      } else if (from_format === "csv" || from_format === "tsv") {
        parsed = parseCsvOrTsv(input.input, inputDelimiter);
      } else {
        parsed = parseText(input.input);
      }
    } catch (err) {
      return {
        ok: false,
        error: `Failed to parse input as ${from_format}: ${(err as Error).message}`,
        code: "PARSE_ERROR",
      };
    }
  
    let normalised: { headers: string[]; rows: string[][] };
    try {
      normalised = normalise(parsed, from_format);
    } catch (err) {
      return {
        ok: false,
        error: `Failed to normalise data: ${(err as Error).message}`,
        code: "NORMALISE_ERROR",
      };
    }
  
    let output: string;
    try {
      switch (to_format) {
        case "json":
          output = toJson(normalised, pretty);
          break;
        case "csv":
          output = toCsvOrTsv(normalised, ",", include_header);
          break;
        case "tsv":
          output = toCsvOrTsv(normalised, outputDelimiter, include_header);
          break;
        case "markdown_table":
          output = toMarkdownTable(normalised);
          break;
        case "text_summary":
          output = toTextSummary(normalised);
          break;
        default:
          return {
            ok: false,
            error: `Unknown to_format: ${to_format as string}`,
            code: "UNKNOWN_FORMAT",
          };
      }
    } catch (err) {
      return {
        ok: false,
        error: `Failed to format output as ${to_format}: ${(err as Error).message}`,
        code: "FORMAT_ERROR",
      };
    }
  
    logger.info("Transform complete", {
      from_format,
      to_format,
      rows: normalised.rows.length,
    });
  
    return {
      ok: true,
      data: {
        input_format: from_format,
        output_format: to_format,
        output,
        rows_processed: normalised.rows.length,
        transformed_at: new Date().toISOString(),
      },
    };
  }