@kaiord/mcp 4.3.0

package/dist/index.js

@@ -0,0 +1,724 @@
+// src/adapters/stderr-logger.ts
+var createStderrLogger = () => ({
+  debug: (message, context) => console.error(`[DEBUG] ${message}`, context ?? ""),
+  info: (message, context) => console.error(`[INFO] ${message}`, context ?? ""),
+  warn: (message, context) => console.error(`[WARN] ${message}`, context ?? ""),
+  error: (message, context) => console.error(`[ERROR] ${message}`, context ?? "")
+});
+
+// src/server/create-server.ts
+import { readFileSync as readFileSync3 } from "fs";
+import { dirname as dirname2, join } from "path";
+import { fileURLToPath } from "url";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+// src/prompts/analyze-workout.ts
+import { z } from "zod";
+var promptArgs = {
+  file_path: z.string().describe("Path to the fitness file to analyze")
+};
+var registerAnalyzeWorkoutPrompt = (server) => {
+  server.prompt(
+    "analyze_workout",
+    "Guide analysis of a structured workout file",
+    promptArgs,
+    (args) => ({
+      messages: [
+        {
+          role: "user",
+          content: {
+            type: "text",
+            text: [
+              `Analyze the workout in the file at "${args.file_path}".`,
+              "",
+              "Steps:",
+              "1. Use kaiord_inspect to get an overview of the file.",
+              "2. Use kaiord_extract_workout to get the structured workout.",
+              "3. Summarize: sport, total steps, intensity distribution,",
+              "   duration breakdown, and target zones.",
+              "4. Provide training recommendations if applicable."
+            ].join("\n")
+          }
+        }
+      ]
+    })
+  );
+};
+
+// src/prompts/convert-file.ts
+import { z as z3 } from "zod";
+
+// src/types/tool-schemas.ts
+import { z as z2 } from "zod";
+var formatSchema = z2.enum(["fit", "tcx", "zwo", "gcn", "krd"]);
+var BINARY_FORMATS = /* @__PURE__ */ new Set(["fit"]);
+var isBinaryFormat = (format) => BINARY_FORMATS.has(format);
+
+// src/prompts/convert-file.ts
+var promptArgs2 = {
+  file_path: z3.string().describe("Path to the fitness file to convert"),
+  target_format: formatSchema.describe("Target output format")
+};
+var registerConvertFilePrompt = (server) => {
+  server.prompt(
+    "convert_file",
+    "Guide conversion of a fitness file to another format",
+    promptArgs2,
+    (args) => ({
+      messages: [
+        {
+          role: "user",
+          content: {
+            type: "text",
+            text: [
+              `Convert the fitness file at "${args.file_path}" to ${args.target_format} format.`,
+              "",
+              "Steps:",
+              "1. Use kaiord_inspect to examine the file first.",
+              "2. Use kaiord_convert with the file path and target format.",
+              "3. Report the result and any issues."
+            ].join("\n")
+          }
+        }
+      ]
+    })
+  );
+};
+
+// src/resources/krd-format-spec.ts
+import { existsSync, readFileSync } from "fs";
+import { resolve } from "path";
+var SPEC_URI = "kaiord://docs/krd-format";
+var DOCS_URL = "https://github.com/pablo-albaladejo/kaiord/blob/main/docs/krd-format.md";
+var findSpecFile = () => {
+  const candidates = [
+    resolve(process.cwd(), "docs/krd-format.md"),
+    resolve(process.cwd(), "packages/mcp/docs/krd-format.md")
+  ];
+  for (const path of candidates) {
+    if (existsSync(path)) {
+      return readFileSync(path, "utf-8");
+    }
+  }
+  return `KRD format specification not found locally. See: ${DOCS_URL}`;
+};
+var registerKrdFormatSpecResource = (server) => {
+  const spec = findSpecFile();
+  server.resource(
+    "krd-format-spec",
+    SPEC_URI,
+    { description: "KRD format specification document" },
+    async () => ({
+      contents: [{ uri: SPEC_URI, mimeType: "text/markdown", text: spec }]
+    })
+  );
+};
+
+// src/resources/krd-schema.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { resolve as resolve2 } from "path";
+var SCHEMA_URI = "kaiord://schema/krd";
+var FALLBACK_URL = "https://github.com/pablo-albaladejo/kaiord";
+var findSchemaFile = () => {
+  const candidates = [
+    resolve2(process.cwd(), "packages/core/schema/krd.json"),
+    resolve2(process.cwd(), "node_modules/@kaiord/core/schema/krd.json")
+  ];
+  for (const path of candidates) {
+    if (existsSync2(path)) {
+      return readFileSync2(path, "utf-8");
+    }
+  }
+  return JSON.stringify({
+    error: `KRD schema file not found. See ${FALLBACK_URL}`
+  });
+};
+var registerKrdSchemaResource = (server) => {
+  const schema = findSchemaFile();
+  server.resource(
+    "krd-schema",
+    SCHEMA_URI,
+    {
+      description: "JSON Schema for the KRD canonical format",
+      mimeType: "application/schema+json"
+    },
+    async () => ({
+      contents: [
+        {
+          uri: SCHEMA_URI,
+          mimeType: "application/schema+json",
+          text: schema
+        }
+      ]
+    })
+  );
+};
+
+// src/utils/format-registry.ts
+import { validateKrd } from "@kaiord/core";
+import { createFitReader, createFitWriter } from "@kaiord/fit";
+import { createGarminReader, createGarminWriter } from "@kaiord/garmin";
+import { createTcxReader, createTcxWriter } from "@kaiord/tcx";
+import { createZwiftReader, createZwiftWriter } from "@kaiord/zwo";
+import { extname } from "path";
+var createKrdReader = () => async (text) => validateKrd(JSON.parse(text));
+var createKrdWriter = () => async (krd) => {
+  validateKrd(krd);
+  return JSON.stringify(krd, null, 2);
+};
+var FORMAT_REGISTRY = {
+  fit: {
+    name: "FIT",
+    extension: ".fit",
+    description: "Garmin FIT binary protocol",
+    binary: true,
+    createReader: (l) => createFitReader(l),
+    createWriter: (l) => createFitWriter(l)
+  },
+  tcx: {
+    name: "TCX",
+    extension: ".tcx",
+    description: "Training Center XML",
+    binary: false,
+    createReader: (l) => createTcxReader(l),
+    createWriter: (l) => createTcxWriter(l)
+  },
+  zwo: {
+    name: "ZWO",
+    extension: ".zwo",
+    description: "Zwift workout XML",
+    binary: false,
+    createReader: (l) => createZwiftReader(l),
+    createWriter: (l) => createZwiftWriter(l)
+  },
+  gcn: {
+    name: "GCN",
+    extension: ".gcn",
+    description: "Garmin Connect workout JSON",
+    binary: false,
+    createReader: (l) => createGarminReader(l),
+    createWriter: (l) => createGarminWriter(l)
+  },
+  krd: {
+    name: "KRD",
+    extension: ".krd",
+    description: "Kaiord canonical JSON format",
+    binary: false,
+    createReader: () => createKrdReader(),
+    createWriter: () => createKrdWriter()
+  }
+};
+var detectFormatFromPath = (filePath) => {
+  const ext = extname(filePath).toLowerCase();
+  if (!ext) return null;
+  const entry = Object.entries(FORMAT_REGISTRY).find(
+    ([, desc]) => desc.extension === ext
+  );
+  return entry ? entry[0] : null;
+};
+
+// src/resources/supported-formats.ts
+var FORMATS_URI = "kaiord://formats";
+var registerSupportedFormatsResource = (server) => {
+  const data = Object.entries(FORMAT_REGISTRY).map(([key, desc]) => ({
+    format: key,
+    name: desc.name,
+    extension: desc.extension,
+    description: desc.description,
+    binary: desc.binary
+  }));
+  const text = JSON.stringify(data, null, 2);
+  server.resource(
+    "supported-formats",
+    FORMATS_URI,
+    { description: "All supported fitness data formats and capabilities" },
+    async () => ({
+      contents: [{ uri: FORMATS_URI, mimeType: "application/json", text }]
+    })
+  );
+};
+
+// src/tools/kaiord-convert.ts
+import { z as z4 } from "zod";
+
+// src/utils/error-formatter.ts
+var formatSuccess = (text) => ({
+  content: [{ type: "text", text }]
+});
+var formatError = (error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  return {
+    content: [{ type: "text", text: `Error: ${message}` }],
+    isError: true
+  };
+};
+
+// src/utils/file-io.ts
+import {
+  mkdir,
+  readFile as fsReadFile,
+  writeFile as fsWriteFile
+} from "fs/promises";
+import { dirname } from "path";
+var DANGEROUS_CHARS = /[\0|;&`$(){}!\n\r]/;
+var PATH_TRAVERSAL = /(?:^|[/\\])\.\.(?:[/\\]|$)/;
+var validatePathSecurity = (inputPath) => {
+  if (DANGEROUS_CHARS.test(inputPath)) {
+    throw new Error(
+      `Invalid path: dangerous characters detected in ${inputPath}`
+    );
+  }
+  if (PATH_TRAVERSAL.test(inputPath)) {
+    throw new Error(
+      `Invalid path: directory traversal detected in ${inputPath}`
+    );
+  }
+};
+var readFileAsBuffer = async (path) => {
+  validatePathSecurity(path);
+  try {
+    const buffer = await fsReadFile(path);
+    return new Uint8Array(buffer);
+  } catch (error) {
+    throw createFileError(path, error);
+  }
+};
+var readFileAsText = async (path) => {
+  validatePathSecurity(path);
+  try {
+    return await fsReadFile(path, "utf-8");
+  } catch (error) {
+    throw createFileError(path, error);
+  }
+};
+var writeOutputFile = async (path, data) => {
+  validatePathSecurity(path);
+  await mkdir(dirname(path), { recursive: true });
+  if (data instanceof Uint8Array) {
+    await fsWriteFile(path, data);
+  } else {
+    await fsWriteFile(path, data, "utf-8");
+  }
+};
+var isNodeError = (e) => e instanceof Error && "code" in e;
+var createFileError = (path, error) => {
+  if (isNodeError(error)) {
+    if (error.code === "ENOENT") return new Error(`File not found: ${path}`);
+    if (error.code === "EACCES") return new Error(`Permission denied: ${path}`);
+  }
+  return new Error(`Failed to read file: ${path}`);
+};
+
+// src/utils/resolve-input.ts
+var validateExclusiveInput = (inputFile, inputContent) => {
+  if (inputFile === void 0 && inputContent === void 0) {
+    throw new Error("Provide either input_file or input_content");
+  }
+  if (inputFile && inputContent) {
+    throw new Error("Provide only one of input_file or input_content");
+  }
+};
+var resolveTextInput = async (inputFile, inputContent) => {
+  validateExclusiveInput(inputFile, inputContent);
+  if (inputFile) {
+    return readFileAsText(inputFile);
+  }
+  return inputContent;
+};
+
+// src/tools/convert-from-krd.ts
+import { toBinary, toText } from "@kaiord/core";
+var convertFromKrd = async (krd, outputFormat, outputFile, logger) => {
+  if (isBinaryFormat(outputFormat)) {
+    return writeBinaryOutput(krd, outputFormat, outputFile, logger);
+  }
+  return writeTextOutput(krd, outputFormat, outputFile, logger);
+};
+var writeBinaryOutput = async (krd, format, outputFile, logger) => {
+  if (!outputFile) {
+    throw new Error("output_file is required for binary format (FIT)");
+  }
+  const writer = FORMAT_REGISTRY[format].createWriter(logger);
+  const buffer = await toBinary(krd, writer, logger);
+  await writeOutputFile(outputFile, buffer);
+  return {
+    content: `Binary file written (${buffer.length} bytes)`,
+    writtenTo: outputFile
+  };
+};
+var writeTextOutput = async (krd, format, outputFile, logger) => {
+  const writer = FORMAT_REGISTRY[format].createWriter(logger);
+  const text = await toText(krd, writer, logger);
+  if (outputFile) {
+    await writeOutputFile(outputFile, text);
+  }
+  return { content: text, writtenTo: outputFile ?? null };
+};
+
+// src/tools/convert-to-krd.ts
+import { fromBinary, fromText } from "@kaiord/core";
+
+// src/utils/base64.ts
+var BASE64_PATTERN = /^[A-Za-z0-9+/]*={0,2}$/;
+var decodeBase64 = (input) => {
+  const trimmed = input.replace(/\s/g, "");
+  if (!BASE64_PATTERN.test(trimmed)) {
+    throw new Error(
+      "Invalid base64 content. Ensure binary file data is base64-encoded."
+    );
+  }
+  const buffer = Buffer.from(trimmed, "base64");
+  if (buffer.length === 0 && trimmed.length > 0) {
+    throw new Error("Base64 decoding produced empty buffer.");
+  }
+  return new Uint8Array(buffer);
+};
+
+// src/tools/convert-to-krd.ts
+var convertToKrd = async (inputFile, inputContent, inputFormat, logger) => {
+  const format = resolveInputFormat(inputFile, inputContent, inputFormat);
+  if (isBinaryFormat(format)) {
+    return readBinaryInput(inputFile, inputContent, format, logger);
+  }
+  return readTextInput(inputFile, inputContent, format, logger);
+};
+var resolveInputFormat = (inputFile, inputContent, inputFormat) => {
+  if (inputFormat) return inputFormat;
+  if (inputFile) {
+    const detected = detectFormatFromPath(inputFile);
+    if (detected) return detected;
+  }
+  throw new Error("Cannot detect format. Provide input_format explicitly.");
+};
+var readBinaryInput = async (inputFile, inputContent, format, logger) => {
+  const reader = FORMAT_REGISTRY[format].createReader(logger);
+  if (!inputFile && inputContent === void 0) {
+    throw new Error("Provide either input_file or input_content");
+  }
+  const buffer = inputFile ? await readFileAsBuffer(inputFile) : decodeBase64(inputContent);
+  return fromBinary(buffer, reader, logger);
+};
+var readTextInput = async (inputFile, inputContent, format, logger) => {
+  const reader = FORMAT_REGISTRY[format].createReader(logger);
+  if (!inputFile && inputContent === void 0) {
+    throw new Error("Provide either input_file or input_content");
+  }
+  const text = inputFile ? await readFileAsText(inputFile) : inputContent;
+  return fromText(text, reader, logger);
+};
+
+// src/tools/kaiord-convert.ts
+var convertSchema = {
+  input_file: z4.string().optional().describe("Path to input file"),
+  input_content: z4.string().optional().describe("Inline content (text or base64 for binary)"),
+  input_format: formatSchema.optional().describe("Input format (auto-detected from extension)"),
+  output_format: formatSchema.describe("Target output format"),
+  output_file: z4.string().optional().describe("Path to write output (required for FIT)")
+};
+var registerConvertTool = (server, logger) => {
+  server.tool(
+    "kaiord_convert",
+    "Convert between fitness data formats (FIT, TCX, ZWO, GCN, KRD)",
+    convertSchema,
+    async (args) => {
+      try {
+        validateExclusiveInput(args.input_file, args.input_content);
+        const krd = await convertToKrd(
+          args.input_file,
+          args.input_content,
+          args.input_format,
+          logger
+        );
+        const result = await convertFromKrd(
+          krd,
+          args.output_format,
+          args.output_file,
+          logger
+        );
+        const message = result.writtenTo ? `Converted to ${args.output_format}. Written to: ${result.writtenTo}
+
+${result.content}` : result.content;
+        return formatSuccess(message);
+      } catch (error) {
+        return formatError(error);
+      }
+    }
+  );
+};
+
+// src/tools/kaiord-diff.ts
+import { z as z5 } from "zod";
+
+// src/tools/diff-compare.ts
+var METADATA_FIELDS = [
+  "created",
+  "manufacturer",
+  "product",
+  "sport",
+  "subSport",
+  "serialNumber"
+];
+var compareKrdFiles = (krd1, krd2) => ({
+  metadata: compareMetadata(krd1, krd2),
+  steps: compareSteps(krd1, krd2),
+  extensions: compareExtensions(krd1, krd2)
+});
+var isDifferent = (a, b) => {
+  if (a === b) return false;
+  if (a == null || b == null) return true;
+  if (typeof a === "object" && typeof b === "object") {
+    return JSON.stringify(a) !== JSON.stringify(b);
+  }
+  return true;
+};
+var compareMetadata = (krd1, krd2) => {
+  const diffs = [];
+  for (const field of METADATA_FIELDS) {
+    const v1 = krd1.metadata[field];
+    const v2 = krd2.metadata[field];
+    if (isDifferent(v1, v2)) {
+      diffs.push({ field, file1: v1, file2: v2 });
+    }
+  }
+  return diffs;
+};
+var getWorkoutSteps = (krd) => {
+  const ext = krd.extensions?.structured_workout;
+  if (!ext || typeof ext !== "object" || Array.isArray(ext)) return [];
+  const w = ext;
+  return Array.isArray(w.steps) ? w.steps : [];
+};
+var compareSteps = (krd1, krd2) => {
+  const s1 = getWorkoutSteps(krd1);
+  const s2 = getWorkoutSteps(krd2);
+  const diffs = [];
+  const max = Math.max(s1.length, s2.length);
+  for (let i = 0; i < max; i++) {
+    if (isDifferent(s1[i], s2[i])) {
+      diffs.push({ field: `step[${i}]`, file1: s1[i], file2: s2[i] });
+    }
+  }
+  return { file1Count: s1.length, file2Count: s2.length, diffs };
+};
+var compareExtensions = (krd1, krd2) => {
+  const e1 = krd1.extensions ?? {};
+  const e2 = krd2.extensions ?? {};
+  const keys1 = Object.keys(e1);
+  const keys2 = Object.keys(e2);
+  const allKeys = /* @__PURE__ */ new Set([...keys1, ...keys2]);
+  const diffs = [];
+  for (const key of allKeys) {
+    if (isDifferent(e1[key], e2[key])) {
+      diffs.push({ field: key, file1: e1[key], file2: e2[key] });
+    }
+  }
+  return { file1Keys: keys1, file2Keys: keys2, diffs };
+};
+
+// src/tools/kaiord-diff.ts
+var diffSchema = {
+  file1: z5.string().describe("Path to the first fitness data file"),
+  file2: z5.string().describe("Path to the second fitness data file"),
+  format1: formatSchema.optional().describe("Format of file1 (auto-detected from extension)"),
+  format2: formatSchema.optional().describe("Format of file2 (auto-detected from extension)")
+};
+var registerDiffTool = (server, logger) => {
+  server.tool(
+    "kaiord_diff",
+    "Compare two fitness files and show differences",
+    diffSchema,
+    async (args) => {
+      try {
+        const [krd1, krd2] = await Promise.all([
+          convertToKrd(args.file1, void 0, args.format1, logger),
+          convertToKrd(args.file2, void 0, args.format2, logger)
+        ]);
+        const diff = compareKrdFiles(krd1, krd2);
+        return formatSuccess(JSON.stringify(diff, null, 2));
+      } catch (error) {
+        return formatError(error);
+      }
+    }
+  );
+};
+
+// src/tools/kaiord-extract-workout.ts
+import { z as z6 } from "zod";
+import { extractWorkout } from "@kaiord/core";
+var extractWorkoutSchema = {
+  input_file: z6.string().optional().describe("Path to the fitness data file"),
+  input_content: z6.string().optional().describe("Inline content (text or base64 for binary)"),
+  input_format: formatSchema.optional().describe("Input format (auto-detected from extension)")
+};
+var registerExtractWorkoutTool = (server, logger) => {
+  server.tool(
+    "kaiord_extract_workout",
+    "Extract the structured workout from a fitness file as JSON",
+    extractWorkoutSchema,
+    async (args) => {
+      try {
+        validateExclusiveInput(args.input_file, args.input_content);
+        const krd = await convertToKrd(
+          args.input_file,
+          args.input_content,
+          args.input_format,
+          logger
+        );
+        const workout = extractWorkout(krd);
+        return formatSuccess(JSON.stringify(workout, null, 2));
+      } catch (error) {
+        return formatError(error);
+      }
+    }
+  );
+};
+
+// src/tools/kaiord-inspect.ts
+import { z as z7 } from "zod";
+
+// src/tools/build-inspect-summary.ts
+var buildInspectSummary = (krd) => {
+  const lines = [
+    `Type: ${krd.type}`,
+    `Sport: ${krd.metadata.sport}`,
+    `Sub-sport: ${krd.metadata.subSport ?? "N/A"}`,
+    "",
+    "--- Metadata ---",
+    `Created: ${krd.metadata.created}`,
+    `Manufacturer: ${krd.metadata.manufacturer ?? "N/A"}`,
+    `Product: ${krd.metadata.product ?? "N/A"}`,
+    `Serial: ${krd.metadata.serialNumber ?? "N/A"}`,
+    "",
+    "--- Data ---",
+    `Sessions: ${krd.sessions?.length ?? 0}`,
+    `Laps: ${krd.laps?.length ?? 0}`,
+    `Records: ${krd.records?.length ?? 0}`,
+    `Events: ${krd.events?.length ?? 0}`
+  ];
+  const workout = extractWorkoutInfo(krd);
+  lines.push("");
+  lines.push("--- Workout ---");
+  if (workout) {
+    lines.push(`Name: ${workout.name}`);
+    lines.push(`Steps: ${workout.stepCount}`);
+  } else {
+    lines.push("No structured workout found.");
+  }
+  return lines.join("\n");
+};
+var extractWorkoutInfo = (krd) => {
+  const ext = krd.extensions?.structured_workout;
+  if (!ext || typeof ext !== "object" || Array.isArray(ext)) return null;
+  const w = ext;
+  const steps = Array.isArray(w.steps) ? w.steps : [];
+  return { name: String(w.name ?? "Unnamed"), stepCount: steps.length };
+};
+
+// src/tools/kaiord-inspect.ts
+var inspectSchema = {
+  input_file: z7.string().describe("Path to the fitness data file"),
+  input_format: formatSchema.optional().describe("Input format (auto-detected from extension)")
+};
+var registerInspectTool = (server, logger) => {
+  server.tool(
+    "kaiord_inspect",
+    "Inspect a fitness file and return a human-readable summary",
+    inspectSchema,
+    async (args) => {
+      try {
+        const krd = await convertToKrd(
+          args.input_file,
+          void 0,
+          args.input_format,
+          logger
+        );
+        return formatSuccess(buildInspectSummary(krd));
+      } catch (error) {
+        return formatError(error);
+      }
+    }
+  );
+};
+
+// src/tools/kaiord-list-formats.ts
+var registerListFormatsTool = (server) => {
+  server.tool(
+    "kaiord_list_formats",
+    "List all supported fitness data formats with capabilities",
+    {},
+    async () => {
+      const formats = Object.entries(FORMAT_REGISTRY).map(([key, desc]) => ({
+        format: key,
+        name: desc.name,
+        extension: desc.extension,
+        description: desc.description,
+        binary: desc.binary
+      }));
+      return formatSuccess(JSON.stringify(formats, null, 2));
+    }
+  );
+};
+
+// src/tools/kaiord-validate.ts
+import { z as z8 } from "zod";
+import { validateKrd as validateKrd2 } from "@kaiord/core";
+var validateSchema = {
+  input_file: z8.string().optional().describe("Path to KRD JSON file"),
+  input_content: z8.string().optional().describe("Inline KRD JSON content")
+};
+var registerValidateTool = (server, logger) => {
+  server.tool(
+    "kaiord_validate",
+    "Validate a KRD JSON document against the schema",
+    validateSchema,
+    async (args) => {
+      try {
+        logger.debug("Validating KRD document");
+        const text = await resolveTextInput(
+          args.input_file,
+          args.input_content
+        );
+        const parsed = JSON.parse(text);
+        validateKrd2(parsed);
+        return formatSuccess("Valid KRD document.");
+      } catch (error) {
+        return formatError(error);
+      }
+    }
+  );
+};
+
+// src/server/create-server.ts
+var SERVER_NAME = "kaiord-mcp";
+var __dirname2 = dirname2(fileURLToPath(import.meta.url));
+var pkg = JSON.parse(
+  readFileSync3(join(__dirname2, "../../package.json"), "utf-8")
+);
+var createServer = () => {
+  const server = new McpServer({
+    name: SERVER_NAME,
+    version: pkg.version
+  });
+  const logger = createStderrLogger();
+  registerListFormatsTool(server);
+  registerConvertTool(server, logger);
+  registerValidateTool(server, logger);
+  registerInspectTool(server, logger);
+  registerExtractWorkoutTool(server, logger);
+  registerDiffTool(server, logger);
+  registerKrdSchemaResource(server);
+  registerSupportedFormatsResource(server);
+  registerKrdFormatSpecResource(server);
+  registerConvertFilePrompt(server);
+  registerAnalyzeWorkoutPrompt(server);
+  return server;
+};
+export {
+  FORMAT_REGISTRY,
+  createServer,
+  createStderrLogger,
+  detectFormatFromPath,
+  formatError,
+  formatSchema,
+  formatSuccess
+};