@cosyte/cli 0.0.1

package/dist/mcp.cjs

@@ -0,0 +1,1161 @@
+'use strict';
+
+var index_js = require('@modelcontextprotocol/sdk/server/index.js');
+var stdio_js = require('@modelcontextprotocol/sdk/server/stdio.js');
+var types_js = require('@modelcontextprotocol/sdk/types.js');
+var util = require('util');
+
+// src/mcp/server.ts
+
+// src/core/version.ts
+var VERSION = "0.0.0";
+
+// src/core/exit-codes.ts
+var EXIT = {
+  /** Success: the operation completed; `validate` found the input **valid**. */
+  OK: 0,
+  /** Operation-level failure: `validate` found the input **invalid** (parseable but non-conformant):
+   * a real, expected CI signal that the message is bad and the tool worked. Never emitted for
+   * unparseable input (that is `DATAERR`). */
+  INVALID: 1,
+  /** Usage error: unknown command, bad flag, missing argument (`EX_USAGE`). */
+  USAGE: 2,
+  /** Data error: input could not be parsed or its format could not be detected (`EX_DATAERR`). */
+  DATAERR: 65,
+  /** No input: the named file does not exist or is unreadable (`EX_NOINPUT`). */
+  NOINPUT: 66,
+  /** Unavailable: a required capability is not yet built (e.g. `redact` before `@cosyte/deid`), a
+   * distinct non-zero signal that is never a fake success (`EX_UNAVAILABLE`). */
+  UNAVAILABLE: 69,
+  /** Internal error: an unexpected exception (a bug), distinct from a handled bad input (`EX_SOFTWARE`). */
+  SOFTWARE: 70
+};
+
+// src/core/diagnostics.ts
+var CLI_CODES = {
+  /** A required argument was missing or a flag was invalid. Exit `2`. */
+  CLI_USAGE: "CLI_USAGE",
+  /** The named file does not exist or could not be read. Exit `66`. */
+  CLI_NO_INPUT: "CLI_NO_INPUT",
+  /** The input was empty, no bytes to detect or parse. Exit `65`. */
+  CLI_EMPTY_INPUT: "CLI_EMPTY_INPUT",
+  /** No format signature matched; the CLI will not guess. Names the candidates, never the bytes. Exit `65`. */
+  CLI_FORMAT_UNDETECTED: "CLI_FORMAT_UNDETECTED",
+  /** More than one format signature matched; the CLI will not guess. Names the candidates, never the bytes. Exit `65`. */
+  CLI_FORMAT_AMBIGUOUS: "CLI_FORMAT_AMBIGUOUS",
+  /** A recognised format whose parser does not support the requested operation (e.g. `parse` on a
+   * format wired only for `inspect`). Names the format + operation, never the bytes. Exit `65`. */
+  CLI_FORMAT_UNSUPPORTED: "CLI_FORMAT_UNSUPPORTED",
+  /** The optional parser package for a recognised format is not installed. The six breadth parsers
+   * (dicom/x12/ccda/ncpdp/astm/mllp) are `optionalDependencies`: normally installed, but if
+   * one is absent the CLI degrades to this value-free signal rather than crashing. Exit `69`. */
+  CLI_PARSER_UNAVAILABLE: "CLI_PARSER_UNAVAILABLE",
+  /** The wrapped parser rejected the input. Positional context only, never the offending bytes. Exit `65`. */
+  CLI_PARSE_FAILED: "CLI_PARSE_FAILED",
+  /** A command whose ground-layer library is not yet built (e.g. `redact` before `@cosyte/deid`
+   * ships). Never a fake success: a distinct, value-free "unavailable" signal. Exit `69`. */
+  CLI_NOT_IMPLEMENTED: "CLI_NOT_IMPLEMENTED",
+  /** An unexpected internal error (a bug). Exit `70`. */
+  CLI_INTERNAL: "CLI_INTERNAL"
+};
+var CliError = class extends Error {
+  /** The stable diagnostic code. */
+  code;
+  /** The exit code this error resolves the invocation to. */
+  exit;
+  /**
+   * @param code - A stable {@link CliCode}.
+   * @param exit - The {@link ExitCode} to resolve to.
+   * @param message - A **value-free** explanation (positional/structural context only, never PHI).
+   */
+  constructor(code, exit, message) {
+    super(message);
+    this.name = "CliError";
+    this.code = code;
+    this.exit = exit;
+  }
+};
+function formatDiagnostic(err) {
+  return `cosyte: ${err.code}: ${err.message}`;
+}
+function errorResult(err) {
+  return { stdout: "", stderr: `${formatDiagnostic(err)}
+`, exit: err.exit };
+}
+function toCliError(err) {
+  if (err instanceof CliError) return err;
+  return new CliError(
+    CLI_CODES.CLI_INTERNAL,
+    EXIT.SOFTWARE,
+    "an unexpected internal error occurred (no input is echoed)"
+  );
+}
+
+// src/core/format.ts
+var SNIFF_BYTES = 512;
+function leadingText(bytes) {
+  const slice = bytes.subarray(0, SNIFF_BYTES);
+  let text = new TextDecoder("utf-8", { fatal: false }).decode(slice);
+  if (text.charCodeAt(0) === 65279) text = text.slice(1);
+  return text;
+}
+function trimLeading(prefix) {
+  return prefix.replace(/^[ \t\r\n\f]+/, "");
+}
+function isDelimiter(ch) {
+  if (ch === void 0) return false;
+  const code = ch.charCodeAt(0);
+  return code > 32 && code < 127 && !/[A-Za-z0-9]/.test(ch);
+}
+function looksLikeHl7(prefix) {
+  const s = trimLeading(prefix);
+  return s.startsWith("MSH") && isDelimiter(s[3]);
+}
+function looksLikeMllp(_prefix, bytes) {
+  return bytes[0] === 11;
+}
+function looksLikeFhir(prefix) {
+  const s = trimLeading(prefix);
+  if (!s.startsWith("{")) return false;
+  return /"resourceType"\s*:\s*"/.test(s);
+}
+function looksLikeX12(prefix) {
+  const s = trimLeading(prefix);
+  return s.startsWith("ISA") && isDelimiter(s[3]);
+}
+function looksLikeAstm(prefix) {
+  const s = trimLeading(prefix);
+  if (!s.startsWith("H") || s.length < 5) return false;
+  return isDelimiter(s[1]) && isDelimiter(s[2]) && isDelimiter(s[3]) && isDelimiter(s[4]);
+}
+function looksLikeCcda(prefix) {
+  return /<ClinicalDocument[\s>]/.test(prefix);
+}
+function looksLikeNcpdp(prefix) {
+  return /<Message[\s>]/.test(prefix) && /ncpdp/i.test(prefix);
+}
+function looksLikeDicom(_prefix, bytes) {
+  if (bytes.length < 132) return false;
+  return bytes[128] === 68 && bytes[129] === 73 && bytes[130] === 67 && bytes[131] === 77;
+}
+var SIGNATURES = [
+  { format: "hl7", match: (prefix) => looksLikeHl7(prefix) },
+  { format: "mllp", match: (prefix, bytes) => looksLikeMllp(prefix, bytes) },
+  { format: "fhir", match: (prefix) => looksLikeFhir(prefix) },
+  { format: "x12", match: (prefix) => looksLikeX12(prefix) },
+  { format: "astm", match: (prefix) => looksLikeAstm(prefix) },
+  { format: "ccda", match: (prefix) => looksLikeCcda(prefix) },
+  { format: "ncpdp", match: (prefix) => looksLikeNcpdp(prefix) },
+  { format: "dicom", match: (prefix, bytes) => looksLikeDicom(prefix, bytes) }
+];
+var DETECTABLE_FORMATS = SIGNATURES.map((s) => s.format);
+function detectFormat(bytes) {
+  if (bytes.length === 0) return classifyCandidates([]);
+  const prefix = leadingText(bytes);
+  const candidates = SIGNATURES.filter((sig) => sig.match(prefix, bytes)).map((sig) => sig.format);
+  return classifyCandidates(candidates);
+}
+function classifyCandidates(candidates) {
+  const [first, second] = candidates;
+  if (second !== void 0) return { format: null, confidence: "ambiguous", candidates };
+  if (first !== void 0) return { format: first, confidence: "certain", candidates };
+  return { format: null, confidence: "none", candidates: [] };
+}
+function detectionError(detected) {
+  if (detected.confidence === "ambiguous") {
+    return new CliError(
+      CLI_CODES.CLI_FORMAT_AMBIGUOUS,
+      EXIT.DATAERR,
+      `input matched multiple formats (${detected.candidates.join(", ")}); disambiguate with --format`
+    );
+  }
+  return new CliError(
+    CLI_CODES.CLI_FORMAT_UNDETECTED,
+    EXIT.DATAERR,
+    `could not detect the input format; re-run with --format (detectable: ${DETECTABLE_FORMATS.join(", ")})`
+  );
+}
+var KNOWN_FORMATS = [
+  "hl7",
+  "fhir",
+  "dicom",
+  "x12",
+  "ccda",
+  "ncpdp",
+  "astm",
+  "mllp"
+];
+function asCosyteFormat(value) {
+  return KNOWN_FORMATS.includes(value) ? value : null;
+}
+
+// src/core/findings.ts
+function formatHl7Position(pos) {
+  let out = `seg[${String(pos.segmentIndex)}]`;
+  if (pos.fieldIndex !== void 0) out += `.field[${String(pos.fieldIndex)}]`;
+  if (pos.repetitionIndex !== void 0) out += `.rep[${String(pos.repetitionIndex)}]`;
+  if (pos.componentIndex !== void 0) out += `.comp[${String(pos.componentIndex)}]`;
+  if (pos.subcomponentIndex !== void 0) out += `.sub[${String(pos.subcomponentIndex)}]`;
+  return out;
+}
+
+// src/core/parsers.ts
+var OP_SUPPORT = {
+  hl7: /* @__PURE__ */ new Set(["parse", "inspect", "fmt", "validate"]),
+  fhir: /* @__PURE__ */ new Set(["parse", "inspect", "fmt", "validate"]),
+  x12: /* @__PURE__ */ new Set(["parse", "inspect", "fmt", "validate"]),
+  astm: /* @__PURE__ */ new Set(["parse", "inspect", "fmt", "validate"]),
+  ncpdp: /* @__PURE__ */ new Set(["parse", "inspect", "fmt", "validate"]),
+  ccda: /* @__PURE__ */ new Set(["inspect", "fmt", "validate"]),
+  dicom: /* @__PURE__ */ new Set(["inspect", "validate"]),
+  mllp: /* @__PURE__ */ new Set(["parse", "inspect"])
+};
+function supportsOp(format, op) {
+  return OP_SUPPORT[format].has(op);
+}
+function formatsSupporting(op) {
+  return Object.keys(OP_SUPPORT).filter((f) => OP_SUPPORT[f].has(op)).sort();
+}
+function valueFreeLocator(pos) {
+  if (typeof pos !== "object" || pos === null) return "?";
+  const parts = [];
+  for (const [k, v] of Object.entries(pos)) {
+    if (typeof v === "number") parts.push(`${k}[${String(v)}]`);
+  }
+  return parts.length > 0 ? parts.join(".") : "?";
+}
+var ERROR_SEVERITIES = /* @__PURE__ */ new Set(["error", "fatal"]);
+function anyError(findings) {
+  return findings.some((f) => ERROR_SEVERITIES.has(f.severity));
+}
+async function loadOptional(format, load) {
+  try {
+    return await load();
+  } catch (e) {
+    if (isModuleNotFound(e)) {
+      throw new CliError(
+        CLI_CODES.CLI_PARSER_UNAVAILABLE,
+        EXIT.UNAVAILABLE,
+        `the @cosyte/${format} parser is not installed; install it to use this format (it is an optional dependency)`
+      );
+    }
+    throw e;
+  }
+}
+function isModuleNotFound(e) {
+  if (typeof e !== "object" || e === null) return false;
+  const code = "code" in e ? e.code : void 0;
+  if (code === "ERR_MODULE_NOT_FOUND" || code === "MODULE_NOT_FOUND") return true;
+  const message = "message" in e && typeof e.message === "string" ? e.message : "";
+  return /Cannot find (package|module)|Failed to (load|resolve)/i.test(message);
+}
+async function parseFormat(format, bytes) {
+  switch (format) {
+    case "hl7": {
+      const { parseHL7 } = await import('@cosyte/hl7');
+      const msg = parseHL7(Buffer.from(bytes));
+      return {
+        model: msg.toJSON(),
+        warnings: msg.warnings.map((w) => ({ code: w.code, position: w.position }))
+      };
+    }
+    case "fhir": {
+      const { parseResource, serializeResource } = await import('@cosyte/fhir');
+      const text = decode(bytes);
+      const { resource, issues } = parseResource(text);
+      const model = JSON.parse(serializeResource(resource));
+      return {
+        model,
+        warnings: issues.map((i) => ({
+          code: i.code,
+          severity: i.severity,
+          expression: i.expression
+        }))
+      };
+    }
+    case "x12": {
+      const { parseX12 } = await loadOptional("x12", () => import('@cosyte/x12'));
+      const ix = parseX12(Buffer.from(bytes));
+      return {
+        model: ix,
+        warnings: ix.warnings.map((w) => ({ code: w.code, position: w.position }))
+      };
+    }
+    case "astm": {
+      const { parseAstmRecords } = await loadOptional("astm", () => import('@cosyte/astm'));
+      const msg = parseAstmRecords(decode(bytes));
+      return {
+        model: msg,
+        warnings: msg.warnings.map((w) => ({ code: w.code, position: w.position }))
+      };
+    }
+    case "ncpdp": {
+      const { parseScript } = await loadOptional("ncpdp", () => import('@cosyte/ncpdp'));
+      const msg = parseScript(decode(bytes));
+      return {
+        model: msg,
+        warnings: msg.warnings.map((w) => ({ code: w.code, position: w.position }))
+      };
+    }
+    case "dicom":
+    case "ccda":
+    case "mllp":
+      throw unsupportedInternal(format, "parse");
+  }
+}
+async function inspectFormat(format, bytes) {
+  switch (format) {
+    case "hl7": {
+      const { parseHL7 } = await import('@cosyte/hl7');
+      const msg = parseHL7(Buffer.from(bytes));
+      const segments = {};
+      const all = msg.allSegments();
+      for (const seg of all) segments[seg.type] = (segments[seg.type] ?? 0) + 1;
+      return {
+        format: "hl7",
+        messageType: msg.meta.type ?? null,
+        version: msg.meta.version ?? null,
+        segmentCount: all.length,
+        segments,
+        warningCount: msg.warnings.length
+      };
+    }
+    case "fhir": {
+      const { parseResource, resourceType, readBundle } = await import('@cosyte/fhir');
+      const { resource, issues } = parseResource(decode(bytes));
+      const rt = resourceType(resource) ?? null;
+      if (rt === "Bundle") {
+        const bundle = readBundle(resource);
+        const entryResourceTypes = {};
+        for (const e of bundle.entries) {
+          const t = e.resourceType ?? "(none)";
+          entryResourceTypes[t] = (entryResourceTypes[t] ?? 0) + 1;
+        }
+        return {
+          format: "fhir",
+          resourceType: rt,
+          bundleType: bundle.type ?? null,
+          entryCount: bundle.entries.length,
+          entryResourceTypes,
+          issueCount: issues.length
+        };
+      }
+      return { format: "fhir", resourceType: rt, issueCount: issues.length };
+    }
+    case "x12": {
+      const { parseX12 } = await loadOptional("x12", () => import('@cosyte/x12'));
+      const ix = parseX12(Buffer.from(bytes));
+      const transactionSetIds = {};
+      let transactionCount = 0;
+      let segmentCount = 0;
+      for (const g of ix.groups) {
+        for (const t of g.transactions) {
+          transactionCount += 1;
+          segmentCount += t.segments.length;
+          const id = t.st.elements[1] ?? "(unknown)";
+          transactionSetIds[id] = (transactionSetIds[id] ?? 0) + 1;
+        }
+      }
+      return {
+        format: "x12",
+        groupCount: ix.groups.length,
+        transactionCount,
+        transactionSetIds,
+        segmentCount,
+        warningCount: ix.warnings.length
+      };
+    }
+    case "astm": {
+      const { parseAstmRecords } = await loadOptional("astm", () => import('@cosyte/astm'));
+      const msg = parseAstmRecords(decode(bytes));
+      const recordTypes = {};
+      for (const r of msg.records) recordTypes[r.type] = (recordTypes[r.type] ?? 0) + 1;
+      return {
+        format: "astm",
+        messageKind: msg.classification.kind,
+        recordCount: msg.records.length,
+        recordTypes,
+        warningCount: msg.warnings.length
+      };
+    }
+    case "ccda": {
+      const { parseCcda } = await loadOptional("ccda", () => import('@cosyte/ccda'));
+      const doc = parseCcda(decode(bytes));
+      const sectionCodes = [];
+      for (const s of doc.sections) {
+        const code = s.code?.code;
+        if (typeof code === "string") sectionCodes.push(code);
+      }
+      return {
+        format: "ccda",
+        documentType: doc.documentType ?? null,
+        sectionCount: doc.sections.length,
+        sectionCodes,
+        warningCount: doc.warnings.length
+      };
+    }
+    case "dicom": {
+      const { parseDicom } = await loadOptional("dicom", () => import('@cosyte/dicom'));
+      let warningCount = 0;
+      const ds = parseDicom(Buffer.from(bytes), { onWarning: () => warningCount += 1 });
+      return {
+        format: "dicom",
+        sopClassUid: ds.fileMeta?.mediaStorageSOPClassUID ?? null,
+        transferSyntaxUid: ds.fileMeta?.transferSyntaxUID ?? null,
+        elementCount: ds.elements().length,
+        warningCount
+      };
+    }
+    case "ncpdp": {
+      const { parseScript } = await loadOptional("ncpdp", () => import('@cosyte/ncpdp'));
+      const msg = parseScript(decode(bytes));
+      return {
+        format: "ncpdp",
+        standard: "SCRIPT",
+        messageType: msg.body.kind ?? null,
+        version: msg.header.version ?? null,
+        warningCount: msg.warnings.length
+      };
+    }
+    case "mllp": {
+      const { payloads, warningCount } = await deframeMllp(bytes);
+      return { format: "mllp", frameCount: payloads.length, warningCount };
+    }
+  }
+}
+async function validateFormat(format, bytes) {
+  switch (format) {
+    case "fhir": {
+      const { parseResource, validateResource } = await import('@cosyte/fhir');
+      const { resource, issues } = parseResource(decode(bytes));
+      const validation = validateResource(resource);
+      const findings = [
+        ...issues.map((i) => finding(i.code, i.severity, i.expression)),
+        ...validation.issues.map((i) => finding(i.code, i.severity, i.expression, i.constraint))
+      ];
+      return { findings, valid: !anyError(findings) };
+    }
+    case "hl7": {
+      const { parseHL7 } = await import('@cosyte/hl7');
+      const msg = parseHL7(Buffer.from(bytes));
+      const findings = msg.warnings.map(
+        (w) => finding(w.code, "warning", formatHl7Position(w.position))
+      );
+      return { findings, valid: !anyError(findings) };
+    }
+    case "x12": {
+      const { parseX12 } = await loadOptional("x12", () => import('@cosyte/x12'));
+      const ix = parseX12(Buffer.from(bytes));
+      const findings = ix.warnings.map(
+        (w) => finding(w.code, "warning", valueFreeLocator(w.position))
+      );
+      return { findings, valid: !anyError(findings) };
+    }
+    case "astm": {
+      const { parseAstmRecords } = await loadOptional("astm", () => import('@cosyte/astm'));
+      const msg = parseAstmRecords(decode(bytes));
+      const findings = msg.warnings.map(
+        (w) => finding(w.code, "warning", valueFreeLocator(w.position))
+      );
+      return { findings, valid: !anyError(findings) };
+    }
+    case "ccda": {
+      const { parseCcda } = await loadOptional("ccda", () => import('@cosyte/ccda'));
+      const doc = parseCcda(decode(bytes));
+      const findings = doc.warnings.map(
+        (w) => finding(w.code, "warning", valueFreeLocator(w.position))
+      );
+      return { findings, valid: !anyError(findings) };
+    }
+    case "dicom": {
+      const { parseDicom } = await loadOptional("dicom", () => import('@cosyte/dicom'));
+      const findings = [];
+      parseDicom(Buffer.from(bytes), {
+        onWarning: (w) => findings.push(finding(w.code, "warning", valueFreeLocator(w.position)))
+      });
+      return { findings, valid: !anyError(findings) };
+    }
+    case "ncpdp": {
+      const { parseScript } = await loadOptional("ncpdp", () => import('@cosyte/ncpdp'));
+      const msg = parseScript(decode(bytes));
+      const findings = msg.warnings.map(
+        (w) => finding(w.code, "warning", valueFreeLocator(w.position))
+      );
+      return { findings, valid: !anyError(findings) };
+    }
+    case "mllp":
+      throw unsupportedInternal(format, "validate");
+  }
+}
+async function deframeMllp(bytes) {
+  if (bytes.lastIndexOf(11) > bytes.lastIndexOf(28)) {
+    throw new CliError(
+      CLI_CODES.CLI_PARSE_FAILED,
+      EXIT.DATAERR,
+      "truncated MLLP stream: an unterminated frame at the end of input (no closing FS/CR)"
+    );
+  }
+  const { FrameReader } = await loadOptional("mllp", () => import('@cosyte/mllp'));
+  const payloads = [];
+  let warningCount = 0;
+  const reader = new FrameReader({
+    onFrame: (payload) => payloads.push(Buffer.from(payload)),
+    onWarning: () => warningCount += 1
+  });
+  reader.push(Buffer.from(bytes));
+  return { payloads, warningCount };
+}
+function decode(bytes) {
+  return new TextDecoder("utf-8", { fatal: false }).decode(bytes);
+}
+function finding(code, severity, location, constraint) {
+  const loc = constraint !== void 0 ? `${location} (${constraint})` : location;
+  return { code, severity, location: loc };
+}
+function unsupportedInternal(format, op) {
+  return new CliError(
+    CLI_CODES.CLI_FORMAT_UNSUPPORTED,
+    EXIT.DATAERR,
+    `format '${format}' does not support \`${op}\``
+  );
+}
+
+// src/core/input.ts
+async function resolveInput(source, formatOverride, deps, op) {
+  if (source === void 0) {
+    return fail(
+      new CliError(
+        CLI_CODES.CLI_USAGE,
+        EXIT.USAGE,
+        "missing <file> argument; pass a path or `-` to read stdin"
+      )
+    );
+  }
+  let bytes;
+  try {
+    bytes = source === "-" ? await deps.readStdin() : await deps.readFile(source);
+  } catch (e) {
+    if (e instanceof CliError) return fail(e);
+    throw e;
+  }
+  if (bytes.length === 0) {
+    return fail(new CliError(CLI_CODES.CLI_EMPTY_INPUT, EXIT.DATAERR, "input is empty"));
+  }
+  let format;
+  if (formatOverride !== void 0) {
+    const narrowed = asCosyteFormat(formatOverride);
+    if (narrowed === null) {
+      return fail(
+        new CliError(
+          CLI_CODES.CLI_USAGE,
+          EXIT.USAGE,
+          "unknown --format value; expected one of hl7, fhir, dicom, x12, ccda, ncpdp, astm, mllp"
+        )
+      );
+    }
+    format = narrowed;
+  } else {
+    const detected = detectFormat(bytes);
+    if (detected.format === null) return fail(detectionError(detected));
+    format = detected.format;
+  }
+  if (!supportsOp(format, op)) {
+    return fail(
+      new CliError(
+        CLI_CODES.CLI_FORMAT_UNSUPPORTED,
+        EXIT.DATAERR,
+        `format '${format}' does not support \`${op}\` in this CLI build (${op} supports: ${formatsSupporting(op).join(", ")})`
+      )
+    );
+  }
+  return { ok: true, input: { format, bytes } };
+}
+function fail(e) {
+  return { ok: false, result: errorResult(e) };
+}
+
+// src/core/phi.ts
+var VALUE_FREE = { showValues: false };
+var UNSAFE_EXCERPT_MAX = 200;
+function unsafeInputSuffix(bytes, posture) {
+  if (!posture.showValues) return "";
+  const text = new TextDecoder("utf-8", { fatal: false }).decode(bytes.subarray(0, UNSAFE_EXCERPT_MAX)).replace(/[\r\n\t]+/g, " ").trim();
+  if (text.length === 0) return "";
+  return ` [unsafe-show-values] offending input (first ${String(UNSAFE_EXCERPT_MAX)} bytes): ${text}`;
+}
+
+// src/core/wrap.ts
+function extractStableCode(e) {
+  if (typeof e === "object" && e !== null && "code" in e) {
+    const raw = e.code;
+    if (typeof raw === "string" && /^[A-Z][A-Z0-9_]*$/.test(raw)) return raw;
+  }
+  return null;
+}
+function parseFailureResult(format, bytes, posture, e) {
+  const code = extractStableCode(e);
+  const detail = code === null ? "" : ` (${code})`;
+  const suffix = unsafeInputSuffix(bytes, posture);
+  return {
+    stdout: "",
+    stderr: `cosyte: ${CLI_CODES.CLI_PARSE_FAILED}: the ${format} parser rejected the input${detail}${suffix}
+`,
+    exit: EXIT.DATAERR
+  };
+}
+
+// src/commands/convert.ts
+var CONVERT_OPTIONS = {
+  to: { type: "string" },
+  format: { type: "string" },
+  json: { type: "boolean", default: false },
+  quiet: { type: "boolean", default: false },
+  "no-color": { type: "boolean", default: false }
+};
+var SUPPORTED_TARGET = "fhir";
+var ERROR_SEVERITIES2 = /* @__PURE__ */ new Set(["error", "fatal"]);
+async function convertCommand(args, deps, posture = VALUE_FREE) {
+  let values;
+  let positionals;
+  try {
+    const parsed = util.parseArgs({ args, options: CONVERT_OPTIONS, allowPositionals: true });
+    values = parsed.values;
+    positionals = parsed.positionals;
+  } catch {
+    return errorResult(
+      new CliError(
+        CLI_CODES.CLI_USAGE,
+        EXIT.USAGE,
+        "invalid arguments to `convert` (see `cosyte convert --help`)"
+      )
+    );
+  }
+  if (values.to === void 0) {
+    return errorResult(
+      new CliError(CLI_CODES.CLI_USAGE, EXIT.USAGE, "convert requires --to fhir (the only target)")
+    );
+  }
+  if (values.to !== SUPPORTED_TARGET) {
+    return errorResult(
+      new CliError(
+        CLI_CODES.CLI_USAGE,
+        EXIT.USAGE,
+        `unsupported --to '${values.to}'; only --to fhir is supported (HL7 v2 \u2192 FHIR R4)`
+      )
+    );
+  }
+  const resolved = await resolveInput(positionals[0], values.format, deps, "parse");
+  if (!resolved.ok) return resolved.result;
+  const { format, bytes } = resolved.input;
+  if (format !== "hl7") {
+    return errorResult(
+      new CliError(
+        CLI_CODES.CLI_FORMAT_UNSUPPORTED,
+        EXIT.DATAERR,
+        `convert reads HL7 v2 and writes FHIR R4; the input is '${format}', not an HL7 v2 source`
+      )
+    );
+  }
+  const outcome = await runConvert(bytes, posture);
+  if (!outcome.ok) return outcome.result;
+  const conversion = outcome.conversion;
+  const { hasError, report } = convertOutcome(conversion.findings);
+  const exit = hasError ? EXIT.INVALID : EXIT.OK;
+  if (values.json === true) {
+    const body = {
+      format: SUPPORTED_TARGET,
+      bundle: JSON.parse(conversion.bundleText),
+      findings: conversion.findings
+    };
+    return { stdout: `${JSON.stringify(body)}
+`, stderr: "", exit };
+  }
+  const stderr = values.quiet === true ? "" : report;
+  return { stdout: `${conversion.bundleText}
+`, stderr, exit };
+}
+async function runConvert(bytes, posture) {
+  const [{ parseHL7 }, { toFhir }, { serializeResource }] = await Promise.all([
+    import('@cosyte/hl7'),
+    import('@cosyte/transform'),
+    import('@cosyte/fhir')
+  ]);
+  let msg;
+  try {
+    msg = parseHL7(Buffer.from(bytes));
+  } catch (e) {
+    return { ok: false, result: parseFailureResult("hl7", bytes, posture, e) };
+  }
+  const { bundle, issues } = toFhir(msg);
+  return {
+    ok: true,
+    conversion: {
+      bundleText: serializeResource(bundle),
+      findings: issues.map((i) => toFinding(i.code, i.severity, i.v2Location, i.fhirPath))
+    }
+  };
+}
+function toFinding(code, severity, v2Location, fhirPath) {
+  const location = fhirPath !== void 0 ? `${v2Location} \u2192 ${fhirPath}` : v2Location;
+  return { code, severity, location };
+}
+function convertOutcome(findings) {
+  const lines = findings.map((f) => `cosyte: convert: ${f.severity} ${f.code} at ${f.location}
+`);
+  const errors = findings.filter((f) => ERROR_SEVERITIES2.has(f.severity)).length;
+  const others = findings.length - errors;
+  const summary = errors > 0 ? `cosyte: convert: hl7 \u2192 fhir produced ${String(errors)} error(s), ${String(others)} other finding(s)
+` : `cosyte: convert: hl7 \u2192 fhir OK (${String(findings.length)} finding(s))
+`;
+  return { hasError: errors > 0, report: lines.join("") + summary };
+}
+var INSPECT_OPTIONS = {
+  format: { type: "string" },
+  json: { type: "boolean", default: false },
+  quiet: { type: "boolean", default: false },
+  "no-color": { type: "boolean", default: false }
+};
+async function inspectCommand(args, deps, posture = VALUE_FREE) {
+  let values;
+  let positionals;
+  try {
+    const parsed = util.parseArgs({ args, options: INSPECT_OPTIONS, allowPositionals: true });
+    values = parsed.values;
+    positionals = parsed.positionals;
+  } catch {
+    return errorResult(
+      new CliError(
+        CLI_CODES.CLI_USAGE,
+        EXIT.USAGE,
+        "invalid arguments to `inspect` (see `cosyte inspect --help`)"
+      )
+    );
+  }
+  const resolved = await resolveInput(positionals[0], values.format, deps, "inspect");
+  if (!resolved.ok) return resolved.result;
+  const { format, bytes } = resolved.input;
+  let summary;
+  try {
+    summary = await inspectFormat(format, bytes);
+  } catch (e) {
+    if (e instanceof CliError) return errorResult(e);
+    return parseFailureResult(format, bytes, posture, e);
+  }
+  const stdout = values.json === true ? `${JSON.stringify(summary)}
+` : renderSummary(summary);
+  return { stdout, stderr: "", exit: EXIT.OK };
+}
+function renderSummary(summary) {
+  const lines = [];
+  const countLines = (label, counts) => {
+    if (label.length > 0) lines.push(label);
+    for (const key of Object.keys(counts).sort()) lines.push(`  ${key}: ${String(counts[key])}`);
+  };
+  switch (summary.format) {
+    case "hl7":
+      lines.push(`format:       hl7`);
+      lines.push(`message type: ${summary.messageType ?? "(unknown)"}`);
+      lines.push(`version:      ${summary.version ?? "(unknown)"}`);
+      lines.push(`segments:     ${String(summary.segmentCount)}`);
+      countLines("", summary.segments);
+      lines.push(`warnings:     ${String(summary.warningCount)}`);
+      break;
+    case "fhir":
+      lines.push(`format:        fhir`);
+      lines.push(`resource type: ${summary.resourceType ?? "(unknown)"}`);
+      if (summary.entryCount !== void 0) {
+        lines.push(`bundle type:   ${summary.bundleType ?? "(unknown)"}`);
+        lines.push(`entries:       ${String(summary.entryCount)}`);
+        countLines("", summary.entryResourceTypes ?? {});
+      }
+      lines.push(`issues:        ${String(summary.issueCount)}`);
+      break;
+    case "x12":
+      lines.push(`format:       x12`);
+      lines.push(`groups:       ${String(summary.groupCount)}`);
+      lines.push(`transactions: ${String(summary.transactionCount)}`);
+      countLines("transaction sets:", summary.transactionSetIds);
+      lines.push(`segments:     ${String(summary.segmentCount)}`);
+      lines.push(`warnings:     ${String(summary.warningCount)}`);
+      break;
+    case "astm":
+      lines.push(`format:       astm`);
+      lines.push(`message kind: ${summary.messageKind}`);
+      lines.push(`records:      ${String(summary.recordCount)}`);
+      countLines("", summary.recordTypes);
+      lines.push(`warnings:     ${String(summary.warningCount)}`);
+      break;
+    case "ccda":
+      lines.push(`format:        ccda`);
+      lines.push(`document type: ${summary.documentType ?? "(unknown)"}`);
+      lines.push(`sections:      ${String(summary.sectionCount)}`);
+      if (summary.sectionCodes.length > 0) {
+        lines.push(`section codes: ${summary.sectionCodes.join(", ")}`);
+      }
+      lines.push(`warnings:      ${String(summary.warningCount)}`);
+      break;
+    case "dicom":
+      lines.push(`format:         dicom`);
+      lines.push(`sop class uid:  ${summary.sopClassUid ?? "(unknown)"}`);
+      lines.push(`transfer syntax:${summary.transferSyntaxUid ?? " (unknown)"}`);
+      lines.push(`elements:       ${String(summary.elementCount)}`);
+      lines.push(`warnings:       ${String(summary.warningCount)}`);
+      break;
+    case "ncpdp":
+      lines.push(`format:       ncpdp`);
+      lines.push(`standard:     SCRIPT`);
+      lines.push(`message type: ${summary.messageType ?? "(unknown)"}`);
+      lines.push(`version:      ${summary.version ?? "(unknown)"}`);
+      lines.push(`warnings:     ${String(summary.warningCount)}`);
+      break;
+    case "mllp":
+      lines.push(`format:  mllp`);
+      lines.push(`frames:  ${String(summary.frameCount)}`);
+      lines.push(`warnings:${String(summary.warningCount)}`);
+      break;
+  }
+  return lines.join("\n") + "\n";
+}
+var PARSE_OPTIONS = {
+  format: { type: "string" },
+  ndjson: { type: "boolean", default: false },
+  json: { type: "boolean", default: false },
+  quiet: { type: "boolean", default: false },
+  "no-color": { type: "boolean", default: false }
+};
+async function parseCommand(args, deps, posture = VALUE_FREE) {
+  let values;
+  let positionals;
+  try {
+    const parsed = util.parseArgs({ args, options: PARSE_OPTIONS, allowPositionals: true });
+    values = parsed.values;
+    positionals = parsed.positionals;
+  } catch {
+    return errorResult(
+      new CliError(
+        CLI_CODES.CLI_USAGE,
+        EXIT.USAGE,
+        "invalid arguments to `parse` (see `cosyte parse --help`)"
+      )
+    );
+  }
+  const resolved = await resolveInput(positionals[0], values.format, deps, "parse");
+  if (!resolved.ok) return resolved.result;
+  const { format, bytes } = resolved.input;
+  if (format === "mllp" || values.ndjson === true) {
+    return await parseMulti(format, bytes, values.ndjson === true, values.quiet === true);
+  }
+  return await parseSingle(format, bytes, values.json === true, values.quiet === true, posture);
+}
+async function parseSingle(format, bytes, json, quiet, posture) {
+  let result;
+  try {
+    result = await parseFormat(format, bytes);
+  } catch (e) {
+    if (e instanceof CliError) return errorResult(e);
+    return parseFailureResult(format, bytes, posture, e);
+  }
+  const envelope = { format, model: result.model, warnings: result.warnings };
+  const stdout = (json ? JSON.stringify(envelope) : JSON.stringify(envelope, null, 2)) + "\n";
+  const n = envelope.warnings.length;
+  const stderr = n > 0 && !quiet ? `cosyte: parsed ${format} with ${String(n)} warning(s) (see .warnings in output)
+` : "";
+  return { stdout, stderr, exit: EXIT.OK };
+}
+async function parseMulti(format, bytes, ndjson, quiet) {
+  let records;
+  let recordFormat;
+  try {
+    if (format === "mllp") {
+      const { payloads } = await deframeMllp(bytes);
+      records = payloads;
+      recordFormat = "hl7";
+    } else {
+      records = splitLines(bytes);
+      recordFormat = format;
+    }
+  } catch (e) {
+    if (e instanceof CliError) return errorResult(e);
+    return parseFailureResult(format, bytes, VALUE_FREE, e);
+  }
+  if (records.length === 0) {
+    return errorResult(
+      new CliError(
+        CLI_CODES.CLI_PARSE_FAILED,
+        EXIT.DATAERR,
+        `no ${format === "mllp" ? "MLLP frame" : "record"} found in the input`
+      )
+    );
+  }
+  const lines = [];
+  let failed = 0;
+  let warnings = 0;
+  for (let i = 0; i < records.length; i += 1) {
+    const rec = records[i];
+    try {
+      const { model, warnings: ws } = await parseFormat(recordFormat, rec);
+      warnings += ws.length;
+      lines.push({ record: i, format: recordFormat, model, warnings: ws });
+    } catch (e) {
+      if (e instanceof CliError) return errorResult(e);
+      failed += 1;
+      lines.push({
+        record: i,
+        format: recordFormat,
+        error: extractStableCode(e) ?? "CLI_PARSE_FAILED"
+      });
+    }
+  }
+  const stdout = lines.map((l) => JSON.stringify(l)).join("\n") + "\n";
+  const exit = failed > 0 ? EXIT.DATAERR : EXIT.OK;
+  const stderr = quiet ? "" : `cosyte: parsed ${String(records.length)} ${recordFormat} record(s) (${String(warnings)} warning(s), ${String(failed)} failed)` + (ndjson ? " [ndjson]" : format === "mllp" ? " [mllp]" : "") + "\n";
+  return { stdout, stderr, exit };
+}
+function splitLines(bytes) {
+  const text = new TextDecoder("utf-8", { fatal: false }).decode(bytes);
+  const enc = new TextEncoder();
+  return text.split(/\r?\n/).filter((line) => line.trim().length > 0).map((line) => enc.encode(line));
+}
+var VALIDATE_OPTIONS = {
+  format: { type: "string" },
+  profile: { type: "string" },
+  json: { type: "boolean", default: false },
+  quiet: { type: "boolean", default: false },
+  "no-color": { type: "boolean", default: false }
+};
+var ERROR_SEVERITIES3 = /* @__PURE__ */ new Set(["error", "fatal"]);
+async function validateCommand(args, deps, posture = VALUE_FREE) {
+  let values;
+  let positionals;
+  try {
+    const parsed = util.parseArgs({ args, options: VALIDATE_OPTIONS, allowPositionals: true });
+    values = parsed.values;
+    positionals = parsed.positionals;
+  } catch {
+    return errorResult(
+      new CliError(
+        CLI_CODES.CLI_USAGE,
+        EXIT.USAGE,
+        "invalid arguments to `validate` (see `cosyte validate --help`)"
+      )
+    );
+  }
+  if (values.profile !== void 0) {
+    return errorResult(
+      new CliError(
+        CLI_CODES.CLI_NOT_IMPLEMENTED,
+        EXIT.UNAVAILABLE,
+        "profile-based validation is not yet available: the CLI bundles no profiles and cannot yet load one; validating against `--profile` is gated on that surface. Re-run without --profile for base validation."
+      )
+    );
+  }
+  const resolved = await resolveInput(positionals[0], values.format, deps, "validate");
+  if (!resolved.ok) return resolved.result;
+  const { format, bytes } = resolved.input;
+  let verdict;
+  try {
+    verdict = await validateFormat(format, bytes);
+  } catch (e) {
+    if (e instanceof CliError) return errorResult(e);
+    return parseFailureResult(format, bytes, posture, e);
+  }
+  const exit = verdict.valid ? EXIT.OK : EXIT.INVALID;
+  if (values.json === true) {
+    const body = { format, valid: verdict.valid, findings: verdict.findings };
+    return { stdout: `${JSON.stringify(body)}
+`, stderr: "", exit };
+  }
+  if (values.quiet === true) {
+    return { stdout: "", stderr: "", exit };
+  }
+  return { stdout: "", stderr: renderReport(format, verdict), exit };
+}
+function renderReport(format, verdict) {
+  const lines = verdict.findings.map(
+    (f) => `cosyte: validate: ${f.severity} ${f.code} at ${f.location}
+`
+  );
+  const errors = verdict.findings.filter((f) => ERROR_SEVERITIES3.has(f.severity)).length;
+  const others = verdict.findings.length - errors;
+  const summary = verdict.valid ? `cosyte: validate: ${format} is valid (${String(verdict.findings.length)} finding(s))
+` : `cosyte: validate: ${format} is INVALID (${String(errors)} error(s), ${String(others)} other finding(s))
+`;
+  return lines.join("") + summary;
+}
+
+// src/mcp/tools.ts
+var CONTENT_PROP = {
+  content: {
+    type: "string",
+    description: "The raw healthcare message to operate on (as text; e.g. an HL7 v2 message or a FHIR JSON resource)."
+  }
+};
+var FORMAT_PROP = {
+  format: {
+    type: "string",
+    enum: ["hl7", "fhir", "dicom", "x12", "ccda", "ncpdp", "astm", "mllp"],
+    description: "Optional format override; omit to autodetect by content. A format whose parser does not support the requested operation returns a value-free CLI_FORMAT_UNSUPPORTED (never a fake)."
+  }
+};
+var TOOL_DEFS = [
+  {
+    name: "parse",
+    description: "Parse a healthcare message (HL7 v2 or FHIR R4) to typed JSON. Format is autodetected by content. Returns the parsed model plus value-free warnings.",
+    inputSchema: {
+      type: "object",
+      properties: { ...CONTENT_PROP, ...FORMAT_PROP },
+      required: ["content"],
+      additionalProperties: false
+    }
+  },
+  {
+    name: "validate",
+    description: "Validate a message and carry the verdict: ok=true with a valid result, or a result reporting value-free findings. The parsed-but-invalid verdict is a successful call (not a tool error).",
+    inputSchema: {
+      type: "object",
+      properties: { ...CONTENT_PROP, ...FORMAT_PROP },
+      required: ["content"],
+      additionalProperties: false
+    }
+  },
+  {
+    name: "inspect",
+    description: "Return a value-free structural summary of a message: its type, segment/entry counts, and a warning/issue count. Never includes a field value.",
+    inputSchema: {
+      type: "object",
+      properties: { ...CONTENT_PROP, ...FORMAT_PROP },
+      required: ["content"],
+      additionalProperties: false
+    }
+  },
+  {
+    name: "convert",
+    description: "Convert an HL7 v2 message to a FHIR R4 Bundle via @cosyte/transform. Returns the converted Bundle; an error-severity conversion issue is reported with ok=false.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        ...CONTENT_PROP,
+        to: {
+          type: "string",
+          enum: ["fhir"],
+          description: "The conversion target (only FHIR R4 is supported today)."
+        }
+      },
+      required: ["content"],
+      additionalProperties: false
+    }
+  }
+];
+function inlineDeps(content) {
+  const bytes = new TextEncoder().encode(content);
+  const noFile = new CliError(
+    CLI_CODES.CLI_NO_INPUT,
+    EXIT.NOINPUT,
+    "the MCP tools operate on inline content, not a file path"
+  );
+  return {
+    readStdin: () => Promise.resolve(bytes),
+    // The MCP tools always feed inline content via stdin (`-`); a file read is defensive and unreachable.
+    /* v8 ignore next -- unreachable: no MCP tool passes a file path, only inline `-` stdin content */
+    readFile: () => Promise.reject(noFile)
+  };
+}
+function stringArg(args, key) {
+  const v = args[key];
+  return typeof v === "string" ? v : null;
+}
+function toToolResult(result) {
+  const hardError = result.stdout === "";
+  const text = hardError ? result.stderr.trim() : result.stdout.trim();
+  return {
+    content: [
+      { type: "text", text: text.length > 0 ? text : `cosyte: exit ${String(result.exit)}` }
+    ],
+    isError: hardError,
+    structuredContent: { exit: result.exit, ok: !hardError }
+  };
+}
+function usageError(message) {
+  return {
+    content: [{ type: "text", text: `cosyte: ${CLI_CODES.CLI_USAGE}: ${message}` }],
+    isError: true,
+    structuredContent: { exit: EXIT.USAGE, ok: false }
+  };
+}
+function internalError(e) {
+  const err = toCliError(e);
+  return {
+    content: [{ type: "text", text: `cosyte: ${err.code}: ${err.message}` }],
+    isError: true,
+    structuredContent: { exit: err.exit, ok: false }
+  };
+}
+async function dispatchTool(name, args, deps) {
+  const content = stringArg(args, "content");
+  if (content === null) {
+    return usageError("missing required 'content' argument (the message text to operate on)");
+  }
+  const runDeps = deps ?? inlineDeps(content);
+  const format = stringArg(args, "format");
+  const fmtFlag = format !== null ? ["--format", format] : [];
+  try {
+    switch (name) {
+      case "parse":
+        return toToolResult(await parseCommand(["-", "--json", ...fmtFlag], runDeps, VALUE_FREE));
+      case "validate":
+        return toToolResult(
+          await validateCommand(["-", "--json", ...fmtFlag], runDeps, VALUE_FREE)
+        );
+      case "inspect":
+        return toToolResult(await inspectCommand(["-", "--json", ...fmtFlag], runDeps, VALUE_FREE));
+      case "convert": {
+        const to = stringArg(args, "to") ?? "fhir";
+        return toToolResult(await convertCommand(["-", "--to", to, "--json"], runDeps, VALUE_FREE));
+      }
+      default:
+        return usageError(`unknown tool '${name}'`);
+    }
+  } catch (e) {
+    return internalError(e);
+  }
+}
+
+// src/mcp/server.ts
+var SERVER_INFO = { name: "cosyte", version: VERSION };
+function createMcpServer() {
+  const server = new index_js.Server(SERVER_INFO, { capabilities: { tools: {} } });
+  server.setRequestHandler(types_js.ListToolsRequestSchema, () => ({
+    tools: TOOL_DEFS.map((t) => ({
+      name: t.name,
+      description: t.description,
+      inputSchema: {
+        type: t.inputSchema.type,
+        properties: { ...t.inputSchema.properties },
+        ...t.inputSchema.required !== void 0 ? { required: [...t.inputSchema.required] } : {},
+        ...t.inputSchema.additionalProperties !== void 0 ? { additionalProperties: t.inputSchema.additionalProperties } : {}
+      }
+    }))
+  }));
+  server.setRequestHandler(types_js.CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    const result = await dispatchTool(name, args ?? {});
+    return {
+      content: result.content.map((c) => ({ type: c.type, text: c.text })),
+      isError: result.isError,
+      structuredContent: { exit: result.structuredContent.exit, ok: result.structuredContent.ok }
+    };
+  });
+  return server;
+}
+async function startStdioServer() {
+  const server = createMcpServer();
+  await server.connect(new stdio_js.StdioServerTransport());
+}
+
+exports.SERVER_INFO = SERVER_INFO;
+exports.TOOL_DEFS = TOOL_DEFS;
+exports.createMcpServer = createMcpServer;
+exports.dispatchTool = dispatchTool;
+exports.startStdioServer = startStdioServer;
+//# sourceMappingURL=mcp.cjs.map
+//# sourceMappingURL=mcp.cjs.map