@mcpc-tech/cli 0.1.43 → 0.1.45

package/bin/mcpc.mjs

@@ -56,15 +56,15 @@ var require_windows = __commonJS({
       }
       return false;
     }
-    function checkStat(stat, path, options) {
-      if (!stat.isSymbolicLink() && !stat.isFile()) {
+    function checkStat(stat2, path, options) {
+      if (!stat2.isSymbolicLink() && !stat2.isFile()) {
         return false;
       }
       return checkPathExt(path, options);
     }
     function isexe(path, options, cb) {
-      fs.stat(path, function(er, stat) {
-        cb(er, er ? false : checkStat(stat, path, options));
+      fs.stat(path, function(er, stat2) {
+        cb(er, er ? false : checkStat(stat2, path, options));
       });
     }
     function sync(path, options) {
@@ -80,20 +80,20 @@ var require_mode = __commonJS({
     isexe.sync = sync;
     var fs = __require("fs");
     function isexe(path, options, cb) {
-      fs.stat(path, function(er, stat) {
-        cb(er, er ? false : checkStat(stat, options));
+      fs.stat(path, function(er, stat2) {
+        cb(er, er ? false : checkStat(stat2, options));
       });
     }
     function sync(path, options) {
       return checkStat(fs.statSync(path), options);
     }
-    function checkStat(stat, options) {
-      return stat.isFile() && checkMode(stat, options);
+    function checkStat(stat2, options) {
+      return stat2.isFile() && checkMode(stat2, options);
     }
-    function checkMode(stat, options) {
-      var mod = stat.mode;
-      var uid = stat.uid;
-      var gid = stat.gid;
+    function checkMode(stat2, options) {
+      var mod = stat2.mode;
+      var uid = stat2.uid;
+      var gid = stat2.gid;
       var myUid = options.uid !== void 0 ? options.uid : process.getuid && process.getuid();
       var myGid = options.gid !== void 0 ? options.gid : process.getgid && process.getgid();
       var u = parseInt("100", 8);
@@ -166,11 +166,11 @@ var require_which = __commonJS({
   "__mcpc__cli_latest/node_modules/which/which.js"(exports, module) {
     var isWindows = process.platform === "win32" || process.env.OSTYPE === "cygwin" || process.env.OSTYPE === "msys";
     var path = __require("path");
-    var COLON = isWindows ? ";" : ":";
+    var COLON2 = isWindows ? ";" : ":";
     var isexe = require_isexe();
     var getNotFoundError = (cmd) => Object.assign(new Error(`not found: ${cmd}`), { code: "ENOENT" });
     var getPathInfo = (cmd, opt) => {
-      const colon = opt.colon || COLON;
+      const colon = opt.colon || COLON2;
       const pathEnv = cmd.match(/\//) || isWindows && cmd.match(/\\/) ? [""] : [
         // windows always checks the cwd first
         ...isWindows ? [process.cwd()] : [],
@@ -360,11 +360,11 @@ var require_shebang_command = __commonJS({
         return null;
       }
       const [path, argument] = match[0].replace(/#! ?/, "").split(" ");
-      const binary = path.split("/").pop();
-      if (binary === "env") {
+      const binary2 = path.split("/").pop();
+      if (binary2 === "env") {
         return argument;
       }
-      return argument ? `${binary} ${argument}` : binary;
+      return argument ? `${binary2} ${argument}` : binary2;
     };
   }
 });
@@ -430,7 +430,7 @@ var require_parse = __commonJS({
       }
       return parsed;
     }
-    function parse(command, args, options) {
+    function parse2(command, args, options) {
       if (args && !Array.isArray(args)) {
         options = args;
         args = null;
@@ -449,7 +449,7 @@ var require_parse = __commonJS({
       };
       return options.shell ? parsed : parseNonShell(parsed);
     }
-    module.exports = parse;
+    module.exports = parse2;
   }
 });
 
@@ -508,16 +508,16 @@ var require_cross_spawn = __commonJS({
   "__mcpc__cli_latest/node_modules/cross-spawn/index.js"(exports, module) {
     "use strict";
     var cp = __require("child_process");
-    var parse = require_parse();
+    var parse2 = require_parse();
     var enoent = require_enoent();
     function spawn2(command, args, options) {
-      const parsed = parse(command, args, options);
+      const parsed = parse2(command, args, options);
       const spawned = cp.spawn(parsed.command, parsed.args, parsed.options);
       enoent.hookChildProcess(spawned, parsed);
       return spawned;
     }
     function spawnSync(command, args, options) {
-      const parsed = parse(command, args, options);
+      const parsed = parse2(command, args, options);
       const result = cp.spawnSync(parsed.command, parsed.args, parsed.options);
       result.error = result.error || enoent.verifyENOENTSync(result.status, parsed);
       return result;
@@ -525,7 +525,7 @@ var require_cross_spawn = __commonJS({
     module.exports = spawn2;
     module.exports.spawn = spawn2;
     module.exports.sync = spawnSync;
-    module.exports._parse = parse;
+    module.exports._parse = parse2;
     module.exports._enoent = enoent;
   }
 });
@@ -2385,11 +2385,269 @@ if (typeof global.crypto === "undefined") {
 }
 var outgoingEnded = Symbol("outgoingEnded");
 
+// __mcpc__cli_latest/node_modules/@jsr/std__cli/parse_args.js
+var FLAG_REGEXP = /^(?:-(?:(?<doubleDash>-)(?<negated>no-)?)?)(?<key>.+?)(?:=(?<value>.+?))?$/s;
+var LETTER_REGEXP = /[A-Za-z]/;
+var NUMBER_REGEXP = /-?\d+(\.\d*)?(e-?\d+)?$/;
+var HYPHEN_REGEXP = /^(-|--)[^-]/;
+var VALUE_REGEXP = /=(?<value>.+)/;
+var FLAG_NAME_REGEXP = /^--[^=]+$/;
+var SPECIAL_CHAR_REGEXP = /\W/;
+var NON_WHITESPACE_REGEXP = /\S/;
+function isNumber(string3) {
+  return NON_WHITESPACE_REGEXP.test(string3) && Number.isFinite(Number(string3));
+}
+function setNested(object5, keys, value, collect = false) {
+  keys = [
+    ...keys
+  ];
+  const key = keys.pop();
+  keys.forEach((key2) => object5 = object5[key2] ??= {});
+  if (collect) {
+    const v = object5[key];
+    if (Array.isArray(v)) {
+      v.push(value);
+      return;
+    }
+    value = v ? [
+      v,
+      value
+    ] : [
+      value
+    ];
+  }
+  object5[key] = value;
+}
+function hasNested(object5, keys) {
+  for (const key of keys) {
+    const value = object5[key];
+    if (!Object.hasOwn(object5, key)) return false;
+    object5 = value;
+  }
+  return true;
+}
+function aliasIsBoolean(aliasMap, booleanSet, key) {
+  const set2 = aliasMap.get(key);
+  if (set2 === void 0) return false;
+  for (const alias of set2) if (booleanSet.has(alias)) return true;
+  return false;
+}
+function isBooleanString(value) {
+  return value === "true" || value === "false";
+}
+function parseBooleanString(value) {
+  return value !== "false";
+}
+function parseArgs(args, options) {
+  const { "--": doubleDash = false, alias = {}, boolean: boolean3 = false, default: defaults = {}, stopEarly = false, string: string3 = [], collect = [], negatable = [], unknown: unknownFn = (i) => i } = options ?? {};
+  const aliasMap = /* @__PURE__ */ new Map();
+  const booleanSet = /* @__PURE__ */ new Set();
+  const stringSet = /* @__PURE__ */ new Set();
+  const collectSet = /* @__PURE__ */ new Set();
+  const negatableSet = /* @__PURE__ */ new Set();
+  let allBools = false;
+  if (alias) {
+    for (const [key, value] of Object.entries(alias)) {
+      if (value === void 0) {
+        throw new TypeError("Alias value must be defined");
+      }
+      const aliases = Array.isArray(value) ? value : [
+        value
+      ];
+      aliasMap.set(key, new Set(aliases));
+      aliases.forEach((alias2) => aliasMap.set(alias2, /* @__PURE__ */ new Set([
+        key,
+        ...aliases.filter((it) => it !== alias2)
+      ])));
+    }
+  }
+  if (boolean3) {
+    if (typeof boolean3 === "boolean") {
+      allBools = boolean3;
+    } else {
+      const booleanArgs = Array.isArray(boolean3) ? boolean3 : [
+        boolean3
+      ];
+      for (const key of booleanArgs.filter(Boolean)) {
+        booleanSet.add(key);
+        aliasMap.get(key)?.forEach((al) => {
+          booleanSet.add(al);
+        });
+      }
+    }
+  }
+  if (string3) {
+    const stringArgs = Array.isArray(string3) ? string3 : [
+      string3
+    ];
+    for (const key of stringArgs.filter(Boolean)) {
+      stringSet.add(key);
+      aliasMap.get(key)?.forEach((al) => stringSet.add(al));
+    }
+  }
+  if (collect) {
+    const collectArgs = Array.isArray(collect) ? collect : [
+      collect
+    ];
+    for (const key of collectArgs.filter(Boolean)) {
+      collectSet.add(key);
+      aliasMap.get(key)?.forEach((al) => collectSet.add(al));
+    }
+  }
+  if (negatable) {
+    const negatableArgs = Array.isArray(negatable) ? negatable : [
+      negatable
+    ];
+    for (const key of negatableArgs.filter(Boolean)) {
+      negatableSet.add(key);
+      aliasMap.get(key)?.forEach((alias2) => negatableSet.add(alias2));
+    }
+  }
+  const argv = {
+    _: []
+  };
+  function setArgument(key, value, arg, collect2) {
+    if (!booleanSet.has(key) && !stringSet.has(key) && !aliasMap.has(key) && !collectSet.has(key) && !(allBools && FLAG_NAME_REGEXP.test(arg)) && unknownFn?.(arg, key, value) === false) {
+      return;
+    }
+    if (typeof value === "string" && !stringSet.has(key)) {
+      value = isNumber(value) ? Number(value) : value;
+    }
+    const collectable = collect2 && collectSet.has(key);
+    setNested(argv, key.split("."), value, collectable);
+    aliasMap.get(key)?.forEach((key2) => {
+      setNested(argv, key2.split("."), value, collectable);
+    });
+  }
+  let notFlags = [];
+  const index = args.indexOf("--");
+  if (index !== -1) {
+    notFlags = args.slice(index + 1);
+    args = args.slice(0, index);
+  }
+  argsLoop: for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    const groups = arg.match(FLAG_REGEXP)?.groups;
+    if (groups) {
+      const { doubleDash: doubleDash2, negated } = groups;
+      let key = groups.key;
+      let value = groups.value;
+      if (doubleDash2) {
+        if (value) {
+          if (booleanSet.has(key)) value = parseBooleanString(value);
+          setArgument(key, value, arg, true);
+          continue;
+        }
+        if (negated) {
+          if (negatableSet.has(key)) {
+            setArgument(key, false, arg, false);
+            continue;
+          }
+          key = `no-${key}`;
+        }
+        const next = args[i + 1];
+        if (next) {
+          if (!booleanSet.has(key) && !allBools && !next.startsWith("-") && (!aliasMap.has(key) || !aliasIsBoolean(aliasMap, booleanSet, key))) {
+            value = next;
+            i++;
+            setArgument(key, value, arg, true);
+            continue;
+          }
+          if (isBooleanString(next)) {
+            value = parseBooleanString(next);
+            i++;
+            setArgument(key, value, arg, true);
+            continue;
+          }
+        }
+        value = stringSet.has(key) ? "" : true;
+        setArgument(key, value, arg, true);
+        continue;
+      }
+      const letters = arg.slice(1, -1).split("");
+      for (const [j, letter] of letters.entries()) {
+        const next = arg.slice(j + 2);
+        if (next === "-") {
+          setArgument(letter, next, arg, true);
+          continue;
+        }
+        if (LETTER_REGEXP.test(letter)) {
+          const groups2 = VALUE_REGEXP.exec(next)?.groups;
+          if (groups2) {
+            setArgument(letter, groups2.value, arg, true);
+            continue argsLoop;
+          }
+          if (NUMBER_REGEXP.test(next)) {
+            setArgument(letter, next, arg, true);
+            continue argsLoop;
+          }
+        }
+        if (letters[j + 1]?.match(SPECIAL_CHAR_REGEXP)) {
+          setArgument(letter, arg.slice(j + 2), arg, true);
+          continue argsLoop;
+        }
+        setArgument(letter, stringSet.has(letter) ? "" : true, arg, true);
+      }
+      key = arg.slice(-1);
+      if (key === "-") continue;
+      const nextArg = args[i + 1];
+      if (nextArg) {
+        if (!HYPHEN_REGEXP.test(nextArg) && !booleanSet.has(key) && (!aliasMap.has(key) || !aliasIsBoolean(aliasMap, booleanSet, key))) {
+          setArgument(key, nextArg, arg, true);
+          i++;
+          continue;
+        }
+        if (isBooleanString(nextArg)) {
+          const value2 = parseBooleanString(nextArg);
+          setArgument(key, value2, arg, true);
+          i++;
+          continue;
+        }
+      }
+      setArgument(key, stringSet.has(key) ? "" : true, arg, true);
+      continue;
+    }
+    if (unknownFn?.(arg) !== false) {
+      argv._.push(stringSet.has("_") || !isNumber(arg) ? arg : Number(arg));
+    }
+    if (stopEarly) {
+      argv._.push(...args.slice(i + 1));
+      break;
+    }
+  }
+  for (const [key, value] of Object.entries(defaults)) {
+    const keys = key.split(".");
+    if (!hasNested(argv, keys)) {
+      setNested(argv, keys, value);
+      aliasMap.get(key)?.forEach((key2) => setNested(argv, key2.split("."), value));
+    }
+  }
+  for (const key of booleanSet.keys()) {
+    const keys = key.split(".");
+    if (!hasNested(argv, keys)) {
+      const value = collectSet.has(key) ? [] : false;
+      setNested(argv, keys, value);
+    }
+  }
+  for (const key of stringSet.keys()) {
+    const keys = key.split(".");
+    if (!hasNested(argv, keys) && collectSet.has(key)) {
+      setNested(argv, keys, []);
+    }
+  }
+  if (doubleDash) {
+    argv["--"] = notFlags;
+  } else {
+    argv._.push(...notFlags);
+  }
+  return argv;
+}
+
 // __mcpc__cli_latest/node_modules/@mcpc/cli/src/config/loader.js
-import { mkdir, readFile as readFile2, writeFile as writeFile2 } from "node:fs/promises";
+import { mkdir, readFile as readFile3, writeFile as writeFile2 } from "node:fs/promises";
 import { homedir } from "node:os";
 import { dirname, join as join3, resolve as resolve4 } from "node:path";
-import process4 from "node:process";
+import process5 from "node:process";
 
 // __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/plugins/large-result.js
 import { mkdtemp, writeFile } from "node:fs/promises";
@@ -2865,98 +3123,2139 @@ Available skills: ${available.join(", ")}` : "\n\nNo skills available.";
               isError: true
             };
           }
-          if (args.ref) {
-            const refPath = resolve2(meta.basePath, args.ref);
-            const relPath = relative2(meta.basePath, refPath);
-            if (relPath.startsWith("..")) {
-              return {
-                content: [
-                  {
-                    type: "text",
-                    text: `Invalid path: ${args.ref}`
-                  }
-                ],
-                isError: true
-              };
-            }
-            const dir = relPath.split(/[/\\]/)[0];
-            if (dir === "scripts" || dir === "assets") {
-              return {
-                content: [
-                  {
-                    type: "text",
-                    text: `Path: ${refPath}`
-                  }
-                ]
-              };
+          if (args.ref) {
+            const refPath = resolve2(meta.basePath, args.ref);
+            const relPath = relative2(meta.basePath, refPath);
+            if (relPath.startsWith("..")) {
+              return {
+                content: [
+                  {
+                    type: "text",
+                    text: `Invalid path: ${args.ref}`
+                  }
+                ],
+                isError: true
+              };
+            }
+            const dir = relPath.split(/[/\\]/)[0];
+            if (dir === "scripts" || dir === "assets") {
+              return {
+                content: [
+                  {
+                    type: "text",
+                    text: `Path: ${refPath}`
+                  }
+                ]
+              };
+            }
+            try {
+              const content = await readFile(refPath, "utf-8");
+              return {
+                content: [
+                  {
+                    type: "text",
+                    text: content
+                  }
+                ]
+              };
+            } catch {
+              return {
+                content: [
+                  {
+                    type: "text",
+                    text: `File not found: ${args.ref}`
+                  }
+                ],
+                isError: true
+              };
+            }
+          }
+          try {
+            const content = await readFile(join2(meta.basePath, "SKILL.md"), "utf-8");
+            const body = extractBody(content);
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: body
+                }
+              ]
+            };
+          } catch {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Failed to load skill: ${args.skill}`
+                }
+              ],
+              isError: true
+            };
+          }
+        }, {
+          internal: true
+        });
+      }
+    },
+    dispose: () => {
+      skillsMap.clear();
+      serverRef = null;
+    }
+  };
+}
+
+// __mcpc__cli_latest/node_modules/@mcpc/cli/src/defaults.js
+import { createCodeExecutionPlugin } from "@mcpc-tech/plugin-code-execution";
+
+// __mcpc__cli_latest/node_modules/@jsr/mcpc__plugin-markdown-loader/src/markdown-loader.js
+import { readdir as readdir2, readFile as readFile2, stat } from "node:fs/promises";
+
+// __mcpc__cli_latest/node_modules/@jsr/std__yaml/_chars.js
+var TAB = 9;
+var LINE_FEED = 10;
+var CARRIAGE_RETURN = 13;
+var SPACE = 32;
+var EXCLAMATION = 33;
+var DOUBLE_QUOTE = 34;
+var SHARP = 35;
+var PERCENT = 37;
+var AMPERSAND = 38;
+var SINGLE_QUOTE = 39;
+var ASTERISK = 42;
+var PLUS = 43;
+var COMMA = 44;
+var MINUS = 45;
+var DOT = 46;
+var COLON = 58;
+var SMALLER_THAN = 60;
+var GREATER_THAN = 62;
+var QUESTION = 63;
+var COMMERCIAL_AT = 64;
+var LEFT_SQUARE_BRACKET = 91;
+var BACKSLASH = 92;
+var RIGHT_SQUARE_BRACKET = 93;
+var GRAVE_ACCENT = 96;
+var LEFT_CURLY_BRACKET = 123;
+var VERTICAL_LINE = 124;
+var RIGHT_CURLY_BRACKET = 125;
+function isEOL(c) {
+  return c === LINE_FEED || c === CARRIAGE_RETURN;
+}
+function isWhiteSpace(c) {
+  return c === TAB || c === SPACE;
+}
+function isWhiteSpaceOrEOL(c) {
+  return isWhiteSpace(c) || isEOL(c);
+}
+function isFlowIndicator(c) {
+  return c === COMMA || c === LEFT_SQUARE_BRACKET || c === RIGHT_SQUARE_BRACKET || c === LEFT_CURLY_BRACKET || c === RIGHT_CURLY_BRACKET;
+}
+
+// __mcpc__cli_latest/node_modules/@jsr/std__yaml/_type/binary.js
+var BASE64_MAP = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=\n\r";
+function resolveYamlBinary(data) {
+  if (data === null) return false;
+  let code;
+  let bitlen = 0;
+  const max = data.length;
+  const map2 = BASE64_MAP;
+  for (let idx = 0; idx < max; idx++) {
+    code = map2.indexOf(data.charAt(idx));
+    if (code > 64) continue;
+    if (code < 0) return false;
+    bitlen += 6;
+  }
+  return bitlen % 8 === 0;
+}
+function constructYamlBinary(data) {
+  const input = data.replace(/[\r\n=]/g, "");
+  const max = input.length;
+  const map2 = BASE64_MAP;
+  const result = [];
+  let bits = 0;
+  for (let idx = 0; idx < max; idx++) {
+    if (idx % 4 === 0 && idx) {
+      result.push(bits >> 16 & 255);
+      result.push(bits >> 8 & 255);
+      result.push(bits & 255);
+    }
+    bits = bits << 6 | map2.indexOf(input.charAt(idx));
+  }
+  const tailbits = max % 4 * 6;
+  if (tailbits === 0) {
+    result.push(bits >> 16 & 255);
+    result.push(bits >> 8 & 255);
+    result.push(bits & 255);
+  } else if (tailbits === 18) {
+    result.push(bits >> 10 & 255);
+    result.push(bits >> 2 & 255);
+  } else if (tailbits === 12) {
+    result.push(bits >> 4 & 255);
+  }
+  return new Uint8Array(result);
+}
+function representYamlBinary(object5) {
+  const max = object5.length;
+  const map2 = BASE64_MAP;
+  let result = "";
+  let bits = 0;
+  for (let idx = 0; idx < max; idx++) {
+    if (idx % 3 === 0 && idx) {
+      result += map2[bits >> 18 & 63];
+      result += map2[bits >> 12 & 63];
+      result += map2[bits >> 6 & 63];
+      result += map2[bits & 63];
+    }
+    bits = (bits << 8) + object5[idx];
+  }
+  const tail = max % 3;
+  if (tail === 0) {
+    result += map2[bits >> 18 & 63];
+    result += map2[bits >> 12 & 63];
+    result += map2[bits >> 6 & 63];
+    result += map2[bits & 63];
+  } else if (tail === 2) {
+    result += map2[bits >> 10 & 63];
+    result += map2[bits >> 4 & 63];
+    result += map2[bits << 2 & 63];
+    result += map2[64];
+  } else if (tail === 1) {
+    result += map2[bits >> 2 & 63];
+    result += map2[bits << 4 & 63];
+    result += map2[64];
+    result += map2[64];
+  }
+  return result;
+}
+function isBinary(obj) {
+  return obj instanceof Uint8Array;
+}
+var binary = {
+  tag: "tag:yaml.org,2002:binary",
+  construct: constructYamlBinary,
+  kind: "scalar",
+  predicate: isBinary,
+  represent: representYamlBinary,
+  resolve: resolveYamlBinary
+};
+
+// __mcpc__cli_latest/node_modules/@jsr/std__yaml/_type/bool.js
+var YAML_TRUE_BOOLEANS = [
+  "true",
+  "True",
+  "TRUE"
+];
+var YAML_FALSE_BOOLEANS = [
+  "false",
+  "False",
+  "FALSE"
+];
+var YAML_BOOLEANS = [
+  ...YAML_TRUE_BOOLEANS,
+  ...YAML_FALSE_BOOLEANS
+];
+var bool = {
+  tag: "tag:yaml.org,2002:bool",
+  kind: "scalar",
+  defaultStyle: "lowercase",
+  predicate: (value) => typeof value === "boolean" || value instanceof Boolean,
+  construct: (data) => YAML_TRUE_BOOLEANS.includes(data),
+  resolve: (data) => YAML_BOOLEANS.includes(data),
+  represent: {
+    // deno-lint-ignore ban-types
+    lowercase: (object5) => {
+      const value = object5 instanceof Boolean ? object5.valueOf() : object5;
+      return value ? "true" : "false";
+    },
+    // deno-lint-ignore ban-types
+    uppercase: (object5) => {
+      const value = object5 instanceof Boolean ? object5.valueOf() : object5;
+      return value ? "TRUE" : "FALSE";
+    },
+    // deno-lint-ignore ban-types
+    camelcase: (object5) => {
+      const value = object5 instanceof Boolean ? object5.valueOf() : object5;
+      return value ? "True" : "False";
+    }
+  }
+};
+
+// __mcpc__cli_latest/node_modules/@jsr/std__yaml/_utils.js
+function isObject(value) {
+  return value !== null && typeof value === "object";
+}
+function isNegativeZero(i) {
+  return i === 0 && Number.NEGATIVE_INFINITY === 1 / i;
+}
+function isPlainObject(object5) {
+  return Object.prototype.toString.call(object5) === "[object Object]";
+}
+
+// __mcpc__cli_latest/node_modules/@jsr/std__yaml/_type/float.js
+var YAML_FLOAT_PATTERN = new RegExp(
+  // 2.5e4, 2.5 and integers
+  "^(?:[-+]?(?:0|[1-9][0-9_]*)(?:\\.[0-9_]*)?(?:[eE][-+]?[0-9]+)?|\\.[0-9_]+(?:[eE][-+]?[0-9]+)?|[-+]?\\.(?:inf|Inf|INF)|\\.(?:nan|NaN|NAN))$"
+);
+function resolveYamlFloat(data) {
+  if (!YAML_FLOAT_PATTERN.test(data) || // Quick hack to not allow integers end with `_`
+  // Probably should update regexp & check speed
+  data[data.length - 1] === "_") {
+    return false;
+  }
+  return true;
+}
+function constructYamlFloat(data) {
+  let value = data.replace(/_/g, "").toLowerCase();
+  const sign = value[0] === "-" ? -1 : 1;
+  if (value[0] && "+-".includes(value[0])) {
+    value = value.slice(1);
+  }
+  if (value === ".inf") {
+    return sign === 1 ? Number.POSITIVE_INFINITY : Number.NEGATIVE_INFINITY;
+  }
+  if (value === ".nan") {
+    return NaN;
+  }
+  return sign * parseFloat(value);
+}
+var SCIENTIFIC_WITHOUT_DOT = /^[-+]?[0-9]+e/;
+function representYamlFloat(object5, style) {
+  const value = object5 instanceof Number ? object5.valueOf() : object5;
+  if (isNaN(value)) {
+    switch (style) {
+      case "lowercase":
+        return ".nan";
+      case "uppercase":
+        return ".NAN";
+      case "camelcase":
+        return ".NaN";
+    }
+  } else if (Number.POSITIVE_INFINITY === value) {
+    switch (style) {
+      case "lowercase":
+        return ".inf";
+      case "uppercase":
+        return ".INF";
+      case "camelcase":
+        return ".Inf";
+    }
+  } else if (Number.NEGATIVE_INFINITY === value) {
+    switch (style) {
+      case "lowercase":
+        return "-.inf";
+      case "uppercase":
+        return "-.INF";
+      case "camelcase":
+        return "-.Inf";
+    }
+  } else if (isNegativeZero(value)) {
+    return "-0.0";
+  }
+  const res = value.toString(10);
+  return SCIENTIFIC_WITHOUT_DOT.test(res) ? res.replace("e", ".e") : res;
+}
+function isFloat(object5) {
+  if (object5 instanceof Number) object5 = object5.valueOf();
+  return typeof object5 === "number" && (object5 % 1 !== 0 || isNegativeZero(object5));
+}
+var float = {
+  tag: "tag:yaml.org,2002:float",
+  construct: constructYamlFloat,
+  defaultStyle: "lowercase",
+  kind: "scalar",
+  predicate: isFloat,
+  represent: representYamlFloat,
+  resolve: resolveYamlFloat
+};
+
+// __mcpc__cli_latest/node_modules/@jsr/std__yaml/_type/int.js
+function isCharCodeInRange(c, lower, upper) {
+  return lower <= c && c <= upper;
+}
+function isHexCode(c) {
+  return isCharCodeInRange(c, 48, 57) || // 0-9
+  isCharCodeInRange(c, 65, 70) || // A-F
+  isCharCodeInRange(c, 97, 102);
+}
+function isOctCode(c) {
+  return isCharCodeInRange(c, 48, 55);
+}
+function isDecCode(c) {
+  return isCharCodeInRange(c, 48, 57);
+}
+function resolveYamlInteger(data) {
+  const max = data.length;
+  let index = 0;
+  let hasDigits = false;
+  if (!max) return false;
+  let ch = data[index];
+  if (ch === "-" || ch === "+") {
+    ch = data[++index];
+  }
+  if (ch === "0") {
+    if (index + 1 === max) return true;
+    ch = data[++index];
+    if (ch === "b") {
+      index++;
+      for (; index < max; index++) {
+        ch = data[index];
+        if (ch === "_") continue;
+        if (ch !== "0" && ch !== "1") return false;
+        hasDigits = true;
+      }
+      return hasDigits && ch !== "_";
+    }
+    if (ch === "x") {
+      index++;
+      for (; index < max; index++) {
+        ch = data[index];
+        if (ch === "_") continue;
+        if (!isHexCode(data.charCodeAt(index))) return false;
+        hasDigits = true;
+      }
+      return hasDigits && ch !== "_";
+    }
+    for (; index < max; index++) {
+      ch = data[index];
+      if (ch === "_") continue;
+      if (!isOctCode(data.charCodeAt(index))) return false;
+      hasDigits = true;
+    }
+    return hasDigits && ch !== "_";
+  }
+  if (ch === "_") return false;
+  for (; index < max; index++) {
+    ch = data[index];
+    if (ch === "_") continue;
+    if (!isDecCode(data.charCodeAt(index))) {
+      return false;
+    }
+    hasDigits = true;
+  }
+  if (!hasDigits || ch === "_") return false;
+  return /^(:[0-5]?[0-9])+$/.test(data.slice(index));
+}
+function constructYamlInteger(data) {
+  let value = data;
+  if (value.includes("_")) {
+    value = value.replace(/_/g, "");
+  }
+  let sign = 1;
+  let ch = value[0];
+  if (ch === "-" || ch === "+") {
+    if (ch === "-") sign = -1;
+    value = value.slice(1);
+    ch = value[0];
+  }
+  if (value === "0") return 0;
+  if (ch === "0") {
+    if (value[1] === "b") return sign * parseInt(value.slice(2), 2);
+    if (value[1] === "x") return sign * parseInt(value, 16);
+    return sign * parseInt(value, 8);
+  }
+  return sign * parseInt(value, 10);
+}
+function isInteger(object5) {
+  if (object5 instanceof Number) object5 = object5.valueOf();
+  return typeof object5 === "number" && object5 % 1 === 0 && !isNegativeZero(object5);
+}
+var int = {
+  tag: "tag:yaml.org,2002:int",
+  construct: constructYamlInteger,
+  defaultStyle: "decimal",
+  kind: "scalar",
+  predicate: isInteger,
+  represent: {
+    // deno-lint-ignore ban-types
+    binary(object5) {
+      const value = object5 instanceof Number ? object5.valueOf() : object5;
+      return value >= 0 ? `0b${value.toString(2)}` : `-0b${value.toString(2).slice(1)}`;
+    },
+    // deno-lint-ignore ban-types
+    octal(object5) {
+      const value = object5 instanceof Number ? object5.valueOf() : object5;
+      return value >= 0 ? `0${value.toString(8)}` : `-0${value.toString(8).slice(1)}`;
+    },
+    // deno-lint-ignore ban-types
+    decimal(object5) {
+      const value = object5 instanceof Number ? object5.valueOf() : object5;
+      return value.toString(10);
+    },
+    // deno-lint-ignore ban-types
+    hexadecimal(object5) {
+      const value = object5 instanceof Number ? object5.valueOf() : object5;
+      return value >= 0 ? `0x${value.toString(16).toUpperCase()}` : `-0x${value.toString(16).toUpperCase().slice(1)}`;
+    }
+  },
+  resolve: resolveYamlInteger
+};
+
+// __mcpc__cli_latest/node_modules/@jsr/std__yaml/_type/map.js
+var map = {
+  tag: "tag:yaml.org,2002:map",
+  resolve() {
+    return true;
+  },
+  construct(data) {
+    return data !== null ? data : {};
+  },
+  kind: "mapping"
+};
+
+// __mcpc__cli_latest/node_modules/@jsr/std__yaml/_type/merge.js
+var merge = {
+  tag: "tag:yaml.org,2002:merge",
+  kind: "scalar",
+  resolve: (data) => data === "<<" || data === null,
+  construct: (data) => data
+};
+
+// __mcpc__cli_latest/node_modules/@jsr/std__yaml/_type/nil.js
+var nil = {
+  tag: "tag:yaml.org,2002:null",
+  kind: "scalar",
+  defaultStyle: "lowercase",
+  predicate: (object5) => object5 === null,
+  construct: () => null,
+  resolve: (data) => {
+    return data === "~" || data === "null" || data === "Null" || data === "NULL";
+  },
+  represent: {
+    lowercase: () => "null",
+    uppercase: () => "NULL",
+    camelcase: () => "Null"
+  }
+};
+
+// __mcpc__cli_latest/node_modules/@jsr/std__yaml/_type/omap.js
+function resolveYamlOmap(data) {
+  const objectKeys = /* @__PURE__ */ new Set();
+  for (const object5 of data) {
+    if (!isPlainObject(object5)) return false;
+    const keys = Object.keys(object5);
+    if (keys.length !== 1) return false;
+    for (const key of keys) {
+      if (objectKeys.has(key)) return false;
+      objectKeys.add(key);
+    }
+  }
+  return true;
+}
+var omap = {
+  tag: "tag:yaml.org,2002:omap",
+  kind: "sequence",
+  resolve: resolveYamlOmap,
+  construct(data) {
+    return data;
+  }
+};
+
+// __mcpc__cli_latest/node_modules/@jsr/std__yaml/_type/pairs.js
+function resolveYamlPairs(data) {
+  if (data === null) return true;
+  return data.every((it) => isPlainObject(it) && Object.keys(it).length === 1);
+}
+var pairs = {
+  tag: "tag:yaml.org,2002:pairs",
+  construct(data) {
+    return data?.flatMap(Object.entries) ?? [];
+  },
+  kind: "sequence",
+  resolve: resolveYamlPairs
+};
+
+// __mcpc__cli_latest/node_modules/@jsr/std__yaml/_type/regexp.js
+var REGEXP = /^\/(?<regexp>[\s\S]+)\/(?<modifiers>[gismuy]*)$/;
+var regexp = {
+  tag: "tag:yaml.org,2002:js/regexp",
+  kind: "scalar",
+  resolve(data) {
+    if (data === null || !data.length) return false;
+    if (data.charAt(0) === "/") {
+      const groups = data.match(REGEXP)?.groups;
+      if (!groups) return false;
+      const modifiers = groups.modifiers ?? "";
+      if (new Set(modifiers).size < modifiers.length) return false;
+    }
+    return true;
+  },
+  construct(data) {
+    const { regexp: regexp2 = data, modifiers = "" } = data.match(REGEXP)?.groups ?? {};
+    return new RegExp(regexp2, modifiers);
+  },
+  predicate: (object5) => object5 instanceof RegExp,
+  represent: (object5) => object5.toString()
+};
+
+// __mcpc__cli_latest/node_modules/@jsr/std__yaml/_type/seq.js
+var seq = {
+  tag: "tag:yaml.org,2002:seq",
+  kind: "sequence",
+  resolve: () => true,
+  construct: (data) => data !== null ? data : []
+};
+
+// __mcpc__cli_latest/node_modules/@jsr/std__yaml/_type/set.js
+var set = {
+  tag: "tag:yaml.org,2002:set",
+  kind: "mapping",
+  construct: (data) => data !== null ? data : {},
+  resolve: (data) => {
+    if (data === null) return true;
+    return Object.values(data).every((it) => it === null);
+  }
+};
+
+// __mcpc__cli_latest/node_modules/@jsr/std__yaml/_type/str.js
+var str = {
+  tag: "tag:yaml.org,2002:str",
+  kind: "scalar",
+  resolve: () => true,
+  construct: (data) => data !== null ? data : ""
+};
+
+// __mcpc__cli_latest/node_modules/@jsr/std__yaml/_type/timestamp.js
+var YAML_DATE_REGEXP = new RegExp("^([0-9][0-9][0-9][0-9])-([0-9][0-9])-([0-9][0-9])$");
+var YAML_TIMESTAMP_REGEXP = new RegExp("^([0-9][0-9][0-9][0-9])-([0-9][0-9]?)-([0-9][0-9]?)(?:[Tt]|[ \\t]+)([0-9][0-9]?):([0-9][0-9]):([0-9][0-9])(?:\\.([0-9]*))?(?:[ \\t]*(Z|([-+])([0-9][0-9]?)(?::([0-9][0-9]))?))?$");
+function resolveYamlTimestamp(data) {
+  if (data === null) return false;
+  if (YAML_DATE_REGEXP.exec(data) !== null) return true;
+  if (YAML_TIMESTAMP_REGEXP.exec(data) !== null) return true;
+  return false;
+}
+function constructYamlTimestamp(data) {
+  let match = YAML_DATE_REGEXP.exec(data);
+  if (match === null) match = YAML_TIMESTAMP_REGEXP.exec(data);
+  if (match === null) {
+    throw new Error("Cannot construct YAML timestamp: date resolve error");
+  }
+  const year = +match[1];
+  const month = +match[2] - 1;
+  const day = +match[3];
+  if (!match[4]) {
+    return new Date(Date.UTC(year, month, day));
+  }
+  const hour = +match[4];
+  const minute = +match[5];
+  const second = +match[6];
+  let fraction = 0;
+  if (match[7]) {
+    let partFraction = match[7].slice(0, 3);
+    while (partFraction.length < 3) {
+      partFraction += "0";
+    }
+    fraction = +partFraction;
+  }
+  let delta = null;
+  if (match[9] && match[10]) {
+    const tzHour = +match[10];
+    const tzMinute = +(match[11] || 0);
+    delta = (tzHour * 60 + tzMinute) * 6e4;
+    if (match[9] === "-") delta = -delta;
+  }
+  const date = new Date(Date.UTC(year, month, day, hour, minute, second, fraction));
+  if (delta) date.setTime(date.getTime() - delta);
+  return date;
+}
+function representYamlTimestamp(date) {
+  return date.toISOString();
+}
+var timestamp = {
+  tag: "tag:yaml.org,2002:timestamp",
+  construct: constructYamlTimestamp,
+  predicate(object5) {
+    return object5 instanceof Date;
+  },
+  kind: "scalar",
+  represent: representYamlTimestamp,
+  resolve: resolveYamlTimestamp
+};
+
+// __mcpc__cli_latest/node_modules/@jsr/std__yaml/_type/undefined.js
+var undefinedType = {
+  tag: "tag:yaml.org,2002:js/undefined",
+  kind: "scalar",
+  resolve() {
+    return true;
+  },
+  construct() {
+    return void 0;
+  },
+  predicate(object5) {
+    return typeof object5 === "undefined";
+  },
+  represent() {
+    return "";
+  }
+};
+
+// __mcpc__cli_latest/node_modules/@jsr/std__yaml/_schema.js
+function createTypeMap(implicitTypes, explicitTypes) {
+  const result = {
+    fallback: /* @__PURE__ */ new Map(),
+    mapping: /* @__PURE__ */ new Map(),
+    scalar: /* @__PURE__ */ new Map(),
+    sequence: /* @__PURE__ */ new Map()
+  };
+  const fallbackMap = result.fallback;
+  for (const type of [
+    ...implicitTypes,
+    ...explicitTypes
+  ]) {
+    const map2 = result[type.kind];
+    map2.set(type.tag, type);
+    fallbackMap.set(type.tag, type);
+  }
+  return result;
+}
+function createSchema({ explicitTypes = [], implicitTypes = [], include }) {
+  if (include) {
+    implicitTypes.push(...include.implicitTypes);
+    explicitTypes.push(...include.explicitTypes);
+  }
+  const typeMap = createTypeMap(implicitTypes, explicitTypes);
+  return {
+    implicitTypes,
+    explicitTypes,
+    typeMap
+  };
+}
+var FAILSAFE_SCHEMA = createSchema({
+  explicitTypes: [
+    str,
+    seq,
+    map
+  ]
+});
+var JSON_SCHEMA = createSchema({
+  implicitTypes: [
+    nil,
+    bool,
+    int,
+    float
+  ],
+  include: FAILSAFE_SCHEMA
+});
+var CORE_SCHEMA = createSchema({
+  include: JSON_SCHEMA
+});
+var DEFAULT_SCHEMA = createSchema({
+  explicitTypes: [
+    binary,
+    omap,
+    pairs,
+    set
+  ],
+  implicitTypes: [
+    timestamp,
+    merge
+  ],
+  include: CORE_SCHEMA
+});
+var EXTENDED_SCHEMA = createSchema({
+  explicitTypes: [
+    regexp,
+    undefinedType
+  ],
+  include: DEFAULT_SCHEMA
+});
+var SCHEMA_MAP = /* @__PURE__ */ new Map([
+  [
+    "core",
+    CORE_SCHEMA
+  ],
+  [
+    "default",
+    DEFAULT_SCHEMA
+  ],
+  [
+    "failsafe",
+    FAILSAFE_SCHEMA
+  ],
+  [
+    "json",
+    JSON_SCHEMA
+  ],
+  [
+    "extended",
+    EXTENDED_SCHEMA
+  ]
+]);
+
+// __mcpc__cli_latest/node_modules/@jsr/std__yaml/_loader_state.js
+var CONTEXT_FLOW_IN = 1;
+var CONTEXT_FLOW_OUT = 2;
+var CONTEXT_BLOCK_IN = 3;
+var CONTEXT_BLOCK_OUT = 4;
+var CHOMPING_CLIP = 1;
+var CHOMPING_STRIP = 2;
+var CHOMPING_KEEP = 3;
+var PATTERN_NON_PRINTABLE = (
+  // deno-lint-ignore no-control-regex
+  /[\x00-\x08\x0B\x0C\x0E-\x1F\x7F-\x84\x86-\x9F\uFFFE\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/
+);
+var PATTERN_NON_ASCII_LINE_BREAKS = /[\x85\u2028\u2029]/;
+var PATTERN_FLOW_INDICATORS = /[,\[\]\{\}]/;
+var PATTERN_TAG_HANDLE = /^(?:!|!!|![a-z\-]+!)$/i;
+var PATTERN_TAG_URI = /^(?:!|[^,\[\]\{\}])(?:%[0-9a-f]{2}|[0-9a-z\-#;\/\?:@&=\+\$,_\.!~\*'\(\)\[\]])*$/i;
+var ESCAPED_HEX_LENGTHS = /* @__PURE__ */ new Map([
+  [
+    120,
+    2
+  ],
+  [
+    117,
+    4
+  ],
+  [
+    85,
+    8
+  ]
+]);
+var SIMPLE_ESCAPE_SEQUENCES = /* @__PURE__ */ new Map([
+  [
+    48,
+    "\0"
+  ],
+  [
+    97,
+    "\x07"
+  ],
+  [
+    98,
+    "\b"
+  ],
+  [
+    116,
+    "	"
+  ],
+  [
+    9,
+    "	"
+  ],
+  [
+    110,
+    "\n"
+  ],
+  [
+    118,
+    "\v"
+  ],
+  [
+    102,
+    "\f"
+  ],
+  [
+    114,
+    "\r"
+  ],
+  [
+    101,
+    "\x1B"
+  ],
+  [
+    32,
+    " "
+  ],
+  [
+    34,
+    '"'
+  ],
+  [
+    47,
+    "/"
+  ],
+  [
+    92,
+    "\\"
+  ],
+  [
+    78,
+    "\x85"
+  ],
+  [
+    95,
+    "\xA0"
+  ],
+  [
+    76,
+    "\u2028"
+  ],
+  [
+    80,
+    "\u2029"
+  ]
+]);
+function hexCharCodeToNumber(charCode) {
+  if (48 <= charCode && charCode <= 57) return charCode - 48;
+  const lc = charCode | 32;
+  if (97 <= lc && lc <= 102) return lc - 97 + 10;
+  return -1;
+}
+function decimalCharCodeToNumber(charCode) {
+  if (48 <= charCode && charCode <= 57) return charCode - 48;
+  return -1;
+}
+function codepointToChar(codepoint) {
+  if (codepoint <= 65535) return String.fromCharCode(codepoint);
+  return String.fromCharCode((codepoint - 65536 >> 10) + 55296, (codepoint - 65536 & 1023) + 56320);
+}
+var INDENT = 4;
+var MAX_LENGTH = 75;
+var DELIMITERS = "\0\r\n\x85\u2028\u2029";
+function getSnippet(buffer, position) {
+  if (!buffer) return null;
+  let start = position;
+  let end = position;
+  let head = "";
+  let tail = "";
+  while (start > 0 && !DELIMITERS.includes(buffer.charAt(start - 1))) {
+    start--;
+    if (position - start > MAX_LENGTH / 2 - 1) {
+      head = " ... ";
+      start += 5;
+      break;
+    }
+  }
+  while (end < buffer.length && !DELIMITERS.includes(buffer.charAt(end))) {
+    end++;
+    if (end - position > MAX_LENGTH / 2 - 1) {
+      tail = " ... ";
+      end -= 5;
+      break;
+    }
+  }
+  const snippet = buffer.slice(start, end);
+  const indent = " ".repeat(INDENT);
+  const caretIndent = " ".repeat(INDENT + position - start + head.length);
+  return `${indent + head + snippet + tail}
+${caretIndent}^`;
+}
+function markToString(buffer, position, line, column) {
+  let where = `at line ${line + 1}, column ${column + 1}`;
+  const snippet = getSnippet(buffer, position);
+  if (snippet) where += `:
+${snippet}`;
+  return where;
+}
+function getIndentStatus(lineIndent, parentIndent) {
+  if (lineIndent > parentIndent) return 1;
+  if (lineIndent < parentIndent) return -1;
+  return 0;
+}
+function writeFoldedLines(count) {
+  if (count === 1) return " ";
+  if (count > 1) return "\n".repeat(count - 1);
+  return "";
+}
+var LoaderState = class {
+  input;
+  length;
+  lineIndent = 0;
+  lineStart = 0;
+  position = 0;
+  line = 0;
+  onWarning;
+  allowDuplicateKeys;
+  implicitTypes;
+  typeMap;
+  checkLineBreaks = false;
+  tagMap = /* @__PURE__ */ new Map();
+  anchorMap = /* @__PURE__ */ new Map();
+  constructor(input, { schema = DEFAULT_SCHEMA, onWarning, allowDuplicateKeys = false }) {
+    this.input = input;
+    this.onWarning = onWarning;
+    this.allowDuplicateKeys = allowDuplicateKeys;
+    this.implicitTypes = schema.implicitTypes;
+    this.typeMap = schema.typeMap;
+    this.length = input.length;
+    this.readIndent();
+  }
+  skipWhitespaces() {
+    let ch = this.peek();
+    while (isWhiteSpace(ch)) {
+      ch = this.next();
+    }
+  }
+  skipComment() {
+    let ch = this.peek();
+    if (ch !== SHARP) return;
+    ch = this.next();
+    while (ch !== 0 && !isEOL(ch)) {
+      ch = this.next();
+    }
+  }
+  readIndent() {
+    let char = this.peek();
+    while (char === SPACE) {
+      this.lineIndent += 1;
+      char = this.next();
+    }
+  }
+  peek(offset = 0) {
+    return this.input.charCodeAt(this.position + offset);
+  }
+  next() {
+    this.position += 1;
+    return this.peek();
+  }
+  #createError(message) {
+    const mark = markToString(this.input, this.position, this.line, this.position - this.lineStart);
+    return new SyntaxError(`${message} ${mark}`);
+  }
+  dispatchWarning(message) {
+    const error = this.#createError(message);
+    this.onWarning?.(error);
+  }
+  yamlDirectiveHandler(args) {
+    if (args.length !== 1) {
+      throw this.#createError("Cannot handle YAML directive: YAML directive accepts exactly one argument");
+    }
+    const match = /^([0-9]+)\.([0-9]+)$/.exec(args[0]);
+    if (match === null) {
+      throw this.#createError("Cannot handle YAML directive: ill-formed argument");
+    }
+    const major = parseInt(match[1], 10);
+    const minor = parseInt(match[2], 10);
+    if (major !== 1) {
+      throw this.#createError("Cannot handle YAML directive: unacceptable YAML version");
+    }
+    this.checkLineBreaks = minor < 2;
+    if (minor !== 1 && minor !== 2) {
+      this.dispatchWarning("Cannot handle YAML directive: unsupported YAML version");
+    }
+    return args[0] ?? null;
+  }
+  tagDirectiveHandler(args) {
+    if (args.length !== 2) {
+      throw this.#createError(`Cannot handle tag directive: directive accepts exactly two arguments, received ${args.length}`);
+    }
+    const handle = args[0];
+    const prefix = args[1];
+    if (!PATTERN_TAG_HANDLE.test(handle)) {
+      throw this.#createError(`Cannot handle tag directive: ill-formed handle (first argument) in "${handle}"`);
+    }
+    if (this.tagMap.has(handle)) {
+      throw this.#createError(`Cannot handle tag directive: previously declared suffix for "${handle}" tag handle`);
+    }
+    if (!PATTERN_TAG_URI.test(prefix)) {
+      throw this.#createError("Cannot handle tag directive: ill-formed tag prefix (second argument) of the TAG directive");
+    }
+    this.tagMap.set(handle, prefix);
+  }
+  captureSegment(start, end, checkJson) {
+    if (start < end) {
+      const result = this.input.slice(start, end);
+      if (checkJson) {
+        for (let position = 0; position < result.length; position++) {
+          const character = result.charCodeAt(position);
+          if (!(character === 9 || 32 <= character && character <= 1114111)) {
+            throw this.#createError(`Expected valid JSON character: received "${character}"`);
+          }
+        }
+      } else if (PATTERN_NON_PRINTABLE.test(result)) {
+        throw this.#createError("Stream contains non-printable characters");
+      }
+      return result;
+    }
+  }
+  readBlockSequence(tag, anchor, nodeIndent) {
+    let detected = false;
+    const result = [];
+    if (anchor !== null) this.anchorMap.set(anchor, result);
+    let ch = this.peek();
+    while (ch !== 0) {
+      if (ch !== MINUS) {
+        break;
+      }
+      const following = this.peek(1);
+      if (!isWhiteSpaceOrEOL(following)) {
+        break;
+      }
+      detected = true;
+      this.position++;
+      if (this.skipSeparationSpace(true, -1)) {
+        if (this.lineIndent <= nodeIndent) {
+          result.push(null);
+          ch = this.peek();
+          continue;
+        }
+      }
+      const line = this.line;
+      const newState = this.composeNode({
+        parentIndent: nodeIndent,
+        nodeContext: CONTEXT_BLOCK_IN,
+        allowToSeek: false,
+        allowCompact: true
+      });
+      if (newState) result.push(newState.result);
+      this.skipSeparationSpace(true, -1);
+      ch = this.peek();
+      if ((this.line === line || this.lineIndent > nodeIndent) && ch !== 0) {
+        throw this.#createError("Cannot read block sequence: bad indentation of a sequence entry");
+      } else if (this.lineIndent < nodeIndent) {
+        break;
+      }
+    }
+    if (detected) return {
+      tag,
+      anchor,
+      kind: "sequence",
+      result
+    };
+  }
+  mergeMappings(destination, source, overridableKeys) {
+    if (!isObject(source)) {
+      throw this.#createError("Cannot merge mappings: the provided source object is unacceptable");
+    }
+    for (const [key, value] of Object.entries(source)) {
+      if (Object.hasOwn(destination, key)) continue;
+      Object.defineProperty(destination, key, {
+        value,
+        writable: true,
+        enumerable: true,
+        configurable: true
+      });
+      overridableKeys.add(key);
+    }
+  }
+  storeMappingPair(result, overridableKeys, keyTag, keyNode, valueNode, startLine, startPos) {
+    if (Array.isArray(keyNode)) {
+      keyNode = Array.prototype.slice.call(keyNode);
+      for (let index = 0; index < keyNode.length; index++) {
+        if (Array.isArray(keyNode[index])) {
+          throw this.#createError("Cannot store mapping pair: nested arrays are not supported inside keys");
+        }
+        if (typeof keyNode === "object" && isPlainObject(keyNode[index])) {
+          keyNode[index] = "[object Object]";
+        }
+      }
+    }
+    if (typeof keyNode === "object" && isPlainObject(keyNode)) {
+      keyNode = "[object Object]";
+    }
+    keyNode = String(keyNode);
+    if (keyTag === "tag:yaml.org,2002:merge") {
+      if (Array.isArray(valueNode)) {
+        for (let index = 0; index < valueNode.length; index++) {
+          this.mergeMappings(result, valueNode[index], overridableKeys);
+        }
+      } else {
+        this.mergeMappings(result, valueNode, overridableKeys);
+      }
+    } else {
+      if (!this.allowDuplicateKeys && !overridableKeys.has(keyNode) && Object.hasOwn(result, keyNode)) {
+        this.line = startLine || this.line;
+        this.position = startPos || this.position;
+        throw this.#createError("Cannot store mapping pair: duplicated key");
+      }
+      Object.defineProperty(result, keyNode, {
+        value: valueNode,
+        writable: true,
+        enumerable: true,
+        configurable: true
+      });
+      overridableKeys.delete(keyNode);
+    }
+    return result;
+  }
+  readLineBreak() {
+    const ch = this.peek();
+    if (ch === LINE_FEED) {
+      this.position++;
+    } else if (ch === CARRIAGE_RETURN) {
+      this.position++;
+      if (this.peek() === LINE_FEED) {
+        this.position++;
+      }
+    } else {
+      throw this.#createError("Cannot read line: line break not found");
+    }
+    this.line += 1;
+    this.lineStart = this.position;
+  }
+  skipSeparationSpace(allowComments, checkIndent) {
+    let lineBreaks = 0;
+    let ch = this.peek();
+    while (ch !== 0) {
+      this.skipWhitespaces();
+      ch = this.peek();
+      if (allowComments) {
+        this.skipComment();
+        ch = this.peek();
+      }
+      if (isEOL(ch)) {
+        this.readLineBreak();
+        ch = this.peek();
+        lineBreaks++;
+        this.lineIndent = 0;
+        this.readIndent();
+        ch = this.peek();
+      } else {
+        break;
+      }
+    }
+    if (checkIndent !== -1 && lineBreaks !== 0 && this.lineIndent < checkIndent) {
+      this.dispatchWarning("deficient indentation");
+    }
+    return lineBreaks;
+  }
+  testDocumentSeparator() {
+    let ch = this.peek();
+    if ((ch === MINUS || ch === DOT) && ch === this.peek(1) && ch === this.peek(2)) {
+      ch = this.peek(3);
+      if (ch === 0 || isWhiteSpaceOrEOL(ch)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  readPlainScalar(tag, anchor, nodeIndent, withinFlowCollection) {
+    let ch = this.peek();
+    if (isWhiteSpaceOrEOL(ch) || isFlowIndicator(ch) || ch === SHARP || ch === AMPERSAND || ch === ASTERISK || ch === EXCLAMATION || ch === VERTICAL_LINE || ch === GREATER_THAN || ch === SINGLE_QUOTE || ch === DOUBLE_QUOTE || ch === PERCENT || ch === COMMERCIAL_AT || ch === GRAVE_ACCENT) {
+      return;
+    }
+    let following;
+    if (ch === QUESTION || ch === MINUS) {
+      following = this.peek(1);
+      if (isWhiteSpaceOrEOL(following) || withinFlowCollection && isFlowIndicator(following)) {
+        return;
+      }
+    }
+    let result = "";
+    let captureEnd = this.position;
+    let captureStart = this.position;
+    let hasPendingContent = false;
+    let line = 0;
+    while (ch !== 0) {
+      if (ch === COLON) {
+        following = this.peek(1);
+        if (isWhiteSpaceOrEOL(following) || withinFlowCollection && isFlowIndicator(following)) {
+          break;
+        }
+      } else if (ch === SHARP) {
+        const preceding = this.peek(-1);
+        if (isWhiteSpaceOrEOL(preceding)) {
+          break;
+        }
+      } else if (this.position === this.lineStart && this.testDocumentSeparator() || withinFlowCollection && isFlowIndicator(ch)) {
+        break;
+      } else if (isEOL(ch)) {
+        line = this.line;
+        const lineStart = this.lineStart;
+        const lineIndent = this.lineIndent;
+        this.skipSeparationSpace(false, -1);
+        if (this.lineIndent >= nodeIndent) {
+          hasPendingContent = true;
+          ch = this.peek();
+          continue;
+        } else {
+          this.position = captureEnd;
+          this.line = line;
+          this.lineStart = lineStart;
+          this.lineIndent = lineIndent;
+          break;
+        }
+      }
+      if (hasPendingContent) {
+        const segment2 = this.captureSegment(captureStart, captureEnd, false);
+        if (segment2) result += segment2;
+        result += writeFoldedLines(this.line - line);
+        captureStart = captureEnd = this.position;
+        hasPendingContent = false;
+      }
+      if (!isWhiteSpace(ch)) {
+        captureEnd = this.position + 1;
+      }
+      ch = this.next();
+    }
+    const segment = this.captureSegment(captureStart, captureEnd, false);
+    if (segment) result += segment;
+    if (anchor !== null) this.anchorMap.set(anchor, result);
+    if (result) return {
+      tag,
+      anchor,
+      kind: "scalar",
+      result
+    };
+  }
+  readSingleQuotedScalar(tag, anchor, nodeIndent) {
+    let ch = this.peek();
+    if (ch !== SINGLE_QUOTE) return;
+    let result = "";
+    this.position++;
+    let captureStart = this.position;
+    let captureEnd = this.position;
+    ch = this.peek();
+    while (ch !== 0) {
+      if (ch === SINGLE_QUOTE) {
+        const segment = this.captureSegment(captureStart, this.position, true);
+        if (segment) result += segment;
+        ch = this.next();
+        if (ch === SINGLE_QUOTE) {
+          captureStart = this.position;
+          this.position++;
+          captureEnd = this.position;
+        } else {
+          if (anchor !== null) this.anchorMap.set(anchor, result);
+          return {
+            tag,
+            anchor,
+            kind: "scalar",
+            result
+          };
+        }
+      } else if (isEOL(ch)) {
+        const segment = this.captureSegment(captureStart, captureEnd, true);
+        if (segment) result += segment;
+        result += writeFoldedLines(this.skipSeparationSpace(false, nodeIndent));
+        captureStart = captureEnd = this.position;
+      } else if (this.position === this.lineStart && this.testDocumentSeparator()) {
+        throw this.#createError("Unexpected end of the document within a single quoted scalar");
+      } else {
+        this.position++;
+        captureEnd = this.position;
+      }
+      ch = this.peek();
+    }
+    throw this.#createError("Unexpected end of the stream within a single quoted scalar");
+  }
+  readDoubleQuotedScalar(tag, anchor, nodeIndent) {
+    let ch = this.peek();
+    if (ch !== DOUBLE_QUOTE) return;
+    let result = "";
+    this.position++;
+    let captureEnd = this.position;
+    let captureStart = this.position;
+    let tmp;
+    ch = this.peek();
+    while (ch !== 0) {
+      if (ch === DOUBLE_QUOTE) {
+        const segment = this.captureSegment(captureStart, this.position, true);
+        if (segment) result += segment;
+        this.position++;
+        if (anchor !== null) this.anchorMap.set(anchor, result);
+        return {
+          tag,
+          anchor,
+          kind: "scalar",
+          result
+        };
+      }
+      if (ch === BACKSLASH) {
+        const segment = this.captureSegment(captureStart, this.position, true);
+        if (segment) result += segment;
+        ch = this.next();
+        if (isEOL(ch)) {
+          this.skipSeparationSpace(false, nodeIndent);
+        } else if (ch < 256 && SIMPLE_ESCAPE_SEQUENCES.has(ch)) {
+          result += SIMPLE_ESCAPE_SEQUENCES.get(ch);
+          this.position++;
+        } else if ((tmp = ESCAPED_HEX_LENGTHS.get(ch) ?? 0) > 0) {
+          let hexLength = tmp;
+          let hexResult = 0;
+          for (; hexLength > 0; hexLength--) {
+            ch = this.next();
+            if ((tmp = hexCharCodeToNumber(ch)) >= 0) {
+              hexResult = (hexResult << 4) + tmp;
+            } else {
+              throw this.#createError("Cannot read double quoted scalar: expected hexadecimal character");
+            }
+          }
+          result += codepointToChar(hexResult);
+          this.position++;
+        } else {
+          throw this.#createError("Cannot read double quoted scalar: unknown escape sequence");
+        }
+        captureStart = captureEnd = this.position;
+      } else if (isEOL(ch)) {
+        const segment = this.captureSegment(captureStart, captureEnd, true);
+        if (segment) result += segment;
+        result += writeFoldedLines(this.skipSeparationSpace(false, nodeIndent));
+        captureStart = captureEnd = this.position;
+      } else if (this.position === this.lineStart && this.testDocumentSeparator()) {
+        throw this.#createError("Unexpected end of the document within a double quoted scalar");
+      } else {
+        this.position++;
+        captureEnd = this.position;
+      }
+      ch = this.peek();
+    }
+    throw this.#createError("Unexpected end of the stream within a double quoted scalar");
+  }
+  readFlowCollection(tag, anchor, nodeIndent) {
+    let ch = this.peek();
+    let terminator;
+    let isMapping = true;
+    let result = {};
+    if (ch === LEFT_SQUARE_BRACKET) {
+      terminator = RIGHT_SQUARE_BRACKET;
+      isMapping = false;
+      result = [];
+    } else if (ch === LEFT_CURLY_BRACKET) {
+      terminator = RIGHT_CURLY_BRACKET;
+    } else {
+      return;
+    }
+    if (anchor !== null) this.anchorMap.set(anchor, result);
+    ch = this.next();
+    let readNext = true;
+    let valueNode = null;
+    let keyNode = null;
+    let keyTag = null;
+    let isExplicitPair = false;
+    let isPair = false;
+    let following = 0;
+    let line = 0;
+    const overridableKeys = /* @__PURE__ */ new Set();
+    while (ch !== 0) {
+      this.skipSeparationSpace(true, nodeIndent);
+      ch = this.peek();
+      if (ch === terminator) {
+        this.position++;
+        const kind = isMapping ? "mapping" : "sequence";
+        return {
+          tag,
+          anchor,
+          kind,
+          result
+        };
+      }
+      if (!readNext) {
+        throw this.#createError("Cannot read flow collection: missing comma between flow collection entries");
+      }
+      keyTag = keyNode = valueNode = null;
+      isPair = isExplicitPair = false;
+      if (ch === QUESTION) {
+        following = this.peek(1);
+        if (isWhiteSpaceOrEOL(following)) {
+          isPair = isExplicitPair = true;
+          this.position++;
+          this.skipSeparationSpace(true, nodeIndent);
+        }
+      }
+      line = this.line;
+      const newState = this.composeNode({
+        parentIndent: nodeIndent,
+        nodeContext: CONTEXT_FLOW_IN,
+        allowToSeek: false,
+        allowCompact: true
+      });
+      if (newState) {
+        keyTag = newState.tag || null;
+        keyNode = newState.result;
+      }
+      this.skipSeparationSpace(true, nodeIndent);
+      ch = this.peek();
+      if ((isExplicitPair || this.line === line) && ch === COLON) {
+        isPair = true;
+        ch = this.next();
+        this.skipSeparationSpace(true, nodeIndent);
+        const newState2 = this.composeNode({
+          parentIndent: nodeIndent,
+          nodeContext: CONTEXT_FLOW_IN,
+          allowToSeek: false,
+          allowCompact: true
+        });
+        if (newState2) valueNode = newState2.result;
+      }
+      if (isMapping) {
+        this.storeMappingPair(result, overridableKeys, keyTag, keyNode, valueNode);
+      } else if (isPair) {
+        result.push(this.storeMappingPair({}, overridableKeys, keyTag, keyNode, valueNode));
+      } else {
+        result.push(keyNode);
+      }
+      this.skipSeparationSpace(true, nodeIndent);
+      ch = this.peek();
+      if (ch === COMMA) {
+        readNext = true;
+        ch = this.next();
+      } else {
+        readNext = false;
+      }
+    }
+    throw this.#createError("Cannot read flow collection: unexpected end of the stream within a flow collection");
+  }
+  // Handles block scaler styles: e.g. '|', '>', '|-' and '>-'.
+  // https://yaml.org/spec/1.2.2/#81-block-scalar-styles
+  readBlockScalar(tag, anchor, nodeIndent) {
+    let chomping = CHOMPING_CLIP;
+    let didReadContent = false;
+    let detectedIndent = false;
+    let textIndent = nodeIndent;
+    let emptyLines = 0;
+    let atMoreIndented = false;
+    let ch = this.peek();
+    let folding = false;
+    if (ch === VERTICAL_LINE) {
+      folding = false;
+    } else if (ch === GREATER_THAN) {
+      folding = true;
+    } else {
+      return;
+    }
+    let result = "";
+    let tmp = 0;
+    while (ch !== 0) {
+      ch = this.next();
+      if (ch === PLUS || ch === MINUS) {
+        if (CHOMPING_CLIP === chomping) {
+          chomping = ch === PLUS ? CHOMPING_KEEP : CHOMPING_STRIP;
+        } else {
+          throw this.#createError("Cannot read block: chomping mode identifier repeated");
+        }
+      } else if ((tmp = decimalCharCodeToNumber(ch)) >= 0) {
+        if (tmp === 0) {
+          throw this.#createError("Cannot read block: indentation width must be greater than 0");
+        } else if (!detectedIndent) {
+          textIndent = nodeIndent + tmp - 1;
+          detectedIndent = true;
+        } else {
+          throw this.#createError("Cannot read block: indentation width identifier repeated");
+        }
+      } else {
+        break;
+      }
+    }
+    if (isWhiteSpace(ch)) {
+      this.skipWhitespaces();
+      this.skipComment();
+      ch = this.peek();
+    }
+    while (ch !== 0) {
+      this.readLineBreak();
+      this.lineIndent = 0;
+      ch = this.peek();
+      while ((!detectedIndent || this.lineIndent < textIndent) && ch === SPACE) {
+        this.lineIndent++;
+        ch = this.next();
+      }
+      if (!detectedIndent && this.lineIndent > textIndent) {
+        textIndent = this.lineIndent;
+      }
+      if (isEOL(ch)) {
+        emptyLines++;
+        continue;
+      }
+      if (this.lineIndent < textIndent) {
+        if (chomping === CHOMPING_KEEP) {
+          result += "\n".repeat(didReadContent ? 1 + emptyLines : emptyLines);
+        } else if (chomping === CHOMPING_CLIP) {
+          if (didReadContent) {
+            result += "\n";
+          }
+        }
+        break;
+      }
+      if (folding) {
+        if (isWhiteSpace(ch)) {
+          atMoreIndented = true;
+          result += "\n".repeat(didReadContent ? 1 + emptyLines : emptyLines);
+        } else if (atMoreIndented) {
+          atMoreIndented = false;
+          result += "\n".repeat(emptyLines + 1);
+        } else if (emptyLines === 0) {
+          if (didReadContent) {
+            result += " ";
+          }
+        } else {
+          result += "\n".repeat(emptyLines);
+        }
+      } else {
+        result += "\n".repeat(didReadContent ? 1 + emptyLines : emptyLines);
+      }
+      didReadContent = true;
+      detectedIndent = true;
+      emptyLines = 0;
+      const captureStart = this.position;
+      while (!isEOL(ch) && ch !== 0) {
+        ch = this.next();
+      }
+      const segment = this.captureSegment(captureStart, this.position, false);
+      if (segment) result += segment;
+    }
+    if (anchor !== null) this.anchorMap.set(anchor, result);
+    return {
+      tag,
+      anchor,
+      kind: "scalar",
+      result
+    };
+  }
+  readBlockMapping(tag, anchor, nodeIndent, flowIndent) {
+    const result = {};
+    const overridableKeys = /* @__PURE__ */ new Set();
+    let allowCompact = false;
+    let line;
+    let pos;
+    let keyTag = null;
+    let keyNode = null;
+    let valueNode = null;
+    let atExplicitKey = false;
+    let detected = false;
+    if (anchor !== null) this.anchorMap.set(anchor, result);
+    let ch = this.peek();
+    while (ch !== 0) {
+      const following = this.peek(1);
+      line = this.line;
+      pos = this.position;
+      if ((ch === QUESTION || ch === COLON) && isWhiteSpaceOrEOL(following)) {
+        if (ch === QUESTION) {
+          if (atExplicitKey) {
+            this.storeMappingPair(result, overridableKeys, keyTag, keyNode, null);
+            keyTag = null;
+            keyNode = null;
+            valueNode = null;
+          }
+          detected = true;
+          atExplicitKey = true;
+          allowCompact = true;
+        } else if (atExplicitKey) {
+          atExplicitKey = false;
+          allowCompact = true;
+        } else {
+          throw this.#createError("Cannot read block as explicit mapping pair is incomplete: a key node is missed or followed by a non-tabulated empty line");
+        }
+        this.position += 1;
+        ch = following;
+      } else {
+        const newState = this.composeNode({
+          parentIndent: flowIndent,
+          nodeContext: CONTEXT_FLOW_OUT,
+          allowToSeek: false,
+          allowCompact: true
+        });
+        if (!newState) break;
+        if (this.line === line) {
+          ch = this.peek();
+          this.skipWhitespaces();
+          ch = this.peek();
+          if (ch === COLON) {
+            ch = this.next();
+            if (!isWhiteSpaceOrEOL(ch)) {
+              throw this.#createError("Cannot read block: a whitespace character is expected after the key-value separator within a block mapping");
             }
-            try {
-              const content = await readFile(refPath, "utf-8");
-              return {
-                content: [
-                  {
-                    type: "text",
-                    text: content
-                  }
-                ]
-              };
-            } catch {
-              return {
-                content: [
-                  {
-                    type: "text",
-                    text: `File not found: ${args.ref}`
-                  }
-                ],
-                isError: true
-              };
+            if (atExplicitKey) {
+              this.storeMappingPair(result, overridableKeys, keyTag, keyNode, null);
+              keyTag = null;
+              keyNode = null;
+              valueNode = null;
             }
-          }
-          try {
-            const content = await readFile(join2(meta.basePath, "SKILL.md"), "utf-8");
-            const body = extractBody(content);
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: body
-                }
-              ]
-            };
-          } catch {
+            detected = true;
+            atExplicitKey = false;
+            allowCompact = false;
+            keyTag = newState.tag;
+            keyNode = newState.result;
+          } else if (detected) {
+            throw this.#createError("Cannot read an implicit mapping pair: missing colon");
+          } else {
+            const { kind, result: result2 } = newState;
             return {
-              content: [
-                {
-                  type: "text",
-                  text: `Failed to load skill: ${args.skill}`
-                }
-              ],
-              isError: true
+              tag,
+              anchor,
+              kind,
+              result: result2
             };
           }
-        }, {
-          internal: true
+        } else if (detected) {
+          throw this.#createError("Cannot read a block mapping entry: a multiline key may not be an implicit key");
+        } else {
+          const { kind, result: result2 } = newState;
+          return {
+            tag,
+            anchor,
+            kind,
+            result: result2
+          };
+        }
+      }
+      if (this.line === line || this.lineIndent > nodeIndent) {
+        const newState = this.composeNode({
+          parentIndent: nodeIndent,
+          nodeContext: CONTEXT_BLOCK_OUT,
+          allowToSeek: true,
+          allowCompact
         });
+        if (newState) {
+          if (atExplicitKey) {
+            keyNode = newState.result;
+          } else {
+            valueNode = newState.result;
+          }
+        }
+        if (!atExplicitKey) {
+          this.storeMappingPair(result, overridableKeys, keyTag, keyNode, valueNode, line, pos);
+          keyTag = keyNode = valueNode = null;
+        }
+        this.skipSeparationSpace(true, -1);
+        ch = this.peek();
       }
-    },
-    dispose: () => {
-      skillsMap.clear();
-      serverRef = null;
+      if (this.lineIndent > nodeIndent && ch !== 0) {
+        throw this.#createError("Cannot read block: bad indentation of a mapping entry");
+      } else if (this.lineIndent < nodeIndent) {
+        break;
+      }
+    }
+    if (atExplicitKey) {
+      this.storeMappingPair(result, overridableKeys, keyTag, keyNode, null);
+    }
+    if (detected) return {
+      tag,
+      anchor,
+      kind: "mapping",
+      result
+    };
+  }
+  readTagProperty(tag) {
+    let isVerbatim = false;
+    let isNamed = false;
+    let tagHandle = "";
+    let tagName;
+    let ch = this.peek();
+    if (ch !== EXCLAMATION) return;
+    if (tag !== null) {
+      throw this.#createError("Cannot read tag property: duplication of a tag property");
+    }
+    ch = this.next();
+    if (ch === SMALLER_THAN) {
+      isVerbatim = true;
+      ch = this.next();
+    } else if (ch === EXCLAMATION) {
+      isNamed = true;
+      tagHandle = "!!";
+      ch = this.next();
+    } else {
+      tagHandle = "!";
+    }
+    let position = this.position;
+    if (isVerbatim) {
+      do {
+        ch = this.next();
+      } while (ch !== 0 && ch !== GREATER_THAN);
+      if (this.position < this.length) {
+        tagName = this.input.slice(position, this.position);
+        ch = this.next();
+      } else {
+        throw this.#createError("Cannot read tag property: unexpected end of stream");
+      }
+    } else {
+      while (ch !== 0 && !isWhiteSpaceOrEOL(ch)) {
+        if (ch === EXCLAMATION) {
+          if (!isNamed) {
+            tagHandle = this.input.slice(position - 1, this.position + 1);
+            if (!PATTERN_TAG_HANDLE.test(tagHandle)) {
+              throw this.#createError("Cannot read tag property: named tag handle contains invalid characters");
+            }
+            isNamed = true;
+            position = this.position + 1;
+          } else {
+            throw this.#createError("Cannot read tag property: tag suffix cannot contain an exclamation mark");
+          }
+        }
+        ch = this.next();
+      }
+      tagName = this.input.slice(position, this.position);
+      if (PATTERN_FLOW_INDICATORS.test(tagName)) {
+        throw this.#createError("Cannot read tag property: tag suffix cannot contain flow indicator characters");
+      }
+    }
+    if (tagName && !PATTERN_TAG_URI.test(tagName)) {
+      throw this.#createError(`Cannot read tag property: invalid characters in tag name "${tagName}"`);
+    }
+    if (isVerbatim) {
+      return tagName;
+    } else if (this.tagMap.has(tagHandle)) {
+      return this.tagMap.get(tagHandle) + tagName;
+    } else if (tagHandle === "!") {
+      return `!${tagName}`;
+    } else if (tagHandle === "!!") {
+      return `tag:yaml.org,2002:${tagName}`;
+    }
+    throw this.#createError(`Cannot read tag property: undeclared tag handle "${tagHandle}"`);
+  }
+  readAnchorProperty(anchor) {
+    let ch = this.peek();
+    if (ch !== AMPERSAND) return;
+    if (anchor !== null) {
+      throw this.#createError("Cannot read anchor property: duplicate anchor property");
+    }
+    ch = this.next();
+    const position = this.position;
+    while (ch !== 0 && !isWhiteSpaceOrEOL(ch) && !isFlowIndicator(ch)) {
+      ch = this.next();
+    }
+    if (this.position === position) {
+      throw this.#createError("Cannot read anchor property: name of an anchor node must contain at least one character");
+    }
+    return this.input.slice(position, this.position);
+  }
+  readAlias() {
+    if (this.peek() !== ASTERISK) return;
+    let ch = this.next();
+    const position = this.position;
+    while (ch !== 0 && !isWhiteSpaceOrEOL(ch) && !isFlowIndicator(ch)) {
+      ch = this.next();
+    }
+    if (this.position === position) {
+      throw this.#createError("Cannot read alias: alias name must contain at least one character");
+    }
+    const alias = this.input.slice(position, this.position);
+    if (!this.anchorMap.has(alias)) {
+      throw this.#createError(`Cannot read alias: unidentified alias "${alias}"`);
+    }
+    this.skipSeparationSpace(true, -1);
+    return this.anchorMap.get(alias);
+  }
+  resolveTag(state) {
+    switch (state.tag) {
+      case null:
+      case "!":
+        return state;
+      case "?": {
+        for (const type2 of this.implicitTypes) {
+          if (!type2.resolve(state.result)) continue;
+          const result2 = type2.construct(state.result);
+          state.result = result2;
+          state.tag = type2.tag;
+          const { anchor: anchor2 } = state;
+          if (anchor2 !== null) this.anchorMap.set(anchor2, result2);
+          return state;
+        }
+        return state;
+      }
+    }
+    const kind = state.kind ?? "fallback";
+    const map2 = this.typeMap[kind];
+    const type = map2.get(state.tag);
+    if (!type) {
+      throw this.#createError(`Cannot resolve unknown tag !<${state.tag}>`);
+    }
+    if (state.result !== null && type.kind !== state.kind) {
+      throw this.#createError(`Unacceptable node kind for !<${state.tag}> tag: it should be "${type.kind}", not "${state.kind}"`);
+    }
+    if (!type.resolve(state.result)) {
+      throw this.#createError(`Cannot resolve a node with !<${state.tag}> explicit tag`);
+    }
+    const result = type.construct(state.result);
+    state.result = result;
+    const { anchor } = state;
+    if (anchor !== null) this.anchorMap.set(anchor, result);
+    return state;
+  }
+  composeNode({ parentIndent, nodeContext, allowToSeek, allowCompact }) {
+    let indentStatus = 1;
+    let atNewLine = false;
+    const allowBlockScalars = CONTEXT_BLOCK_OUT === nodeContext || CONTEXT_BLOCK_IN === nodeContext;
+    let allowBlockCollections = allowBlockScalars;
+    const allowBlockStyles = allowBlockScalars;
+    if (allowToSeek) {
+      if (this.skipSeparationSpace(true, -1)) {
+        atNewLine = true;
+        indentStatus = getIndentStatus(this.lineIndent, parentIndent);
+      }
+    }
+    let tag = null;
+    let anchor = null;
+    if (indentStatus === 1) {
+      while (true) {
+        const newTag = this.readTagProperty(tag);
+        if (newTag) {
+          tag = newTag;
+        } else {
+          const newAnchor = this.readAnchorProperty(anchor);
+          if (!newAnchor) break;
+          anchor = newAnchor;
+        }
+        if (this.skipSeparationSpace(true, -1)) {
+          atNewLine = true;
+          allowBlockCollections = allowBlockStyles;
+          indentStatus = getIndentStatus(this.lineIndent, parentIndent);
+        } else {
+          allowBlockCollections = false;
+        }
+      }
+    }
+    if (allowBlockCollections) {
+      allowBlockCollections = atNewLine || allowCompact;
+    }
+    if (indentStatus === 1) {
+      const cond = CONTEXT_FLOW_IN === nodeContext || CONTEXT_FLOW_OUT === nodeContext;
+      const flowIndent = cond ? parentIndent : parentIndent + 1;
+      if (allowBlockCollections) {
+        const blockIndent = this.position - this.lineStart;
+        const blockSequenceState = this.readBlockSequence(tag, anchor, blockIndent);
+        if (blockSequenceState) return this.resolveTag(blockSequenceState);
+        const blockMappingState = this.readBlockMapping(tag, anchor, blockIndent, flowIndent);
+        if (blockMappingState) return this.resolveTag(blockMappingState);
+      }
+      const flowCollectionState = this.readFlowCollection(tag, anchor, flowIndent);
+      if (flowCollectionState) return this.resolveTag(flowCollectionState);
+      if (allowBlockScalars) {
+        const blockScalarState = this.readBlockScalar(tag, anchor, flowIndent);
+        if (blockScalarState) return this.resolveTag(blockScalarState);
+      }
+      const singleQuoteState = this.readSingleQuotedScalar(tag, anchor, flowIndent);
+      if (singleQuoteState) return this.resolveTag(singleQuoteState);
+      const doubleQuoteState = this.readDoubleQuotedScalar(tag, anchor, flowIndent);
+      if (doubleQuoteState) return this.resolveTag(doubleQuoteState);
+      const alias = this.readAlias();
+      if (alias) {
+        if (tag !== null || anchor !== null) {
+          throw this.#createError("Cannot compose node: alias node should not have any properties");
+        }
+        return this.resolveTag({
+          tag,
+          anchor,
+          kind: null,
+          result: alias
+        });
+      }
+      const plainScalarState = this.readPlainScalar(tag, anchor, flowIndent, CONTEXT_FLOW_IN === nodeContext);
+      if (plainScalarState) {
+        plainScalarState.tag ??= "?";
+        return this.resolveTag(plainScalarState);
+      }
+    } else if (indentStatus === 0 && CONTEXT_BLOCK_OUT === nodeContext && allowBlockCollections) {
+      const blockIndent = this.position - this.lineStart;
+      const newState2 = this.readBlockSequence(tag, anchor, blockIndent);
+      if (newState2) return this.resolveTag(newState2);
+    }
+    const newState = this.resolveTag({
+      tag,
+      anchor,
+      kind: null,
+      result: null
+    });
+    if (newState.tag !== null || newState.anchor !== null) return newState;
+  }
+  readDirectives() {
+    let hasDirectives = false;
+    let version = null;
+    let ch = this.peek();
+    while (ch !== 0) {
+      this.skipSeparationSpace(true, -1);
+      ch = this.peek();
+      if (this.lineIndent > 0 || ch !== PERCENT) {
+        break;
+      }
+      hasDirectives = true;
+      ch = this.next();
+      let position = this.position;
+      while (ch !== 0 && !isWhiteSpaceOrEOL(ch)) {
+        ch = this.next();
+      }
+      const directiveName = this.input.slice(position, this.position);
+      const directiveArgs = [];
+      if (directiveName.length < 1) {
+        throw this.#createError("Cannot read document: directive name length must be greater than zero");
+      }
+      while (ch !== 0) {
+        this.skipWhitespaces();
+        this.skipComment();
+        ch = this.peek();
+        if (isEOL(ch)) break;
+        position = this.position;
+        while (ch !== 0 && !isWhiteSpaceOrEOL(ch)) {
+          ch = this.next();
+        }
+        directiveArgs.push(this.input.slice(position, this.position));
+      }
+      if (ch !== 0) this.readLineBreak();
+      switch (directiveName) {
+        case "YAML":
+          if (version !== null) {
+            throw this.#createError("Cannot handle YAML directive: duplication of %YAML directive");
+          }
+          version = this.yamlDirectiveHandler(directiveArgs);
+          break;
+        case "TAG":
+          this.tagDirectiveHandler(directiveArgs);
+          break;
+        default:
+          this.dispatchWarning(`unknown document directive "${directiveName}"`);
+          break;
+      }
+      ch = this.peek();
+    }
+    return hasDirectives;
+  }
+  readDocument() {
+    const documentStart = this.position;
+    this.checkLineBreaks = false;
+    this.tagMap = /* @__PURE__ */ new Map();
+    this.anchorMap = /* @__PURE__ */ new Map();
+    const hasDirectives = this.readDirectives();
+    this.skipSeparationSpace(true, -1);
+    let result = null;
+    if (this.lineIndent === 0 && this.peek() === MINUS && this.peek(1) === MINUS && this.peek(2) === MINUS) {
+      this.position += 3;
+      this.skipSeparationSpace(true, -1);
+    } else if (hasDirectives) {
+      throw this.#createError("Cannot read document: directives end mark is expected");
+    }
+    const newState = this.composeNode({
+      parentIndent: this.lineIndent - 1,
+      nodeContext: CONTEXT_BLOCK_OUT,
+      allowToSeek: false,
+      allowCompact: true
+    });
+    if (newState) result = newState.result;
+    this.skipSeparationSpace(true, -1);
+    if (this.checkLineBreaks && PATTERN_NON_ASCII_LINE_BREAKS.test(this.input.slice(documentStart, this.position))) {
+      this.dispatchWarning("non-ASCII line breaks are interpreted as content");
+    }
+    if (this.position === this.lineStart && this.testDocumentSeparator()) {
+      if (this.peek() === DOT) {
+        this.position += 3;
+        this.skipSeparationSpace(true, -1);
+      }
+    } else if (this.position < this.length - 1) {
+      throw this.#createError("Cannot read document: end of the stream or a document separator is expected");
+    }
+    return result;
+  }
+  *readDocuments() {
+    while (this.position < this.length - 1) {
+      yield this.readDocument();
+    }
+  }
+};
+
+// __mcpc__cli_latest/node_modules/@jsr/std__yaml/parse.js
+function sanitizeInput(input) {
+  input = String(input);
+  if (input.length > 0) {
+    if (!isEOL(input.charCodeAt(input.length - 1))) input += "\n";
+    if (input.charCodeAt(0) === 65279) input = input.slice(1);
+  }
+  input += "\0";
+  return input;
+}
+function parse(content, options = {}) {
+  content = sanitizeInput(content);
+  const state = new LoaderState(content, {
+    ...options,
+    schema: SCHEMA_MAP.get(options.schema)
+  });
+  const documentGenerator = state.readDocuments();
+  const document = documentGenerator.next().value;
+  if (!documentGenerator.next().done) {
+    throw new SyntaxError("Found more than 1 document in the stream: expected a single document");
+  }
+  return document ?? null;
+}
+
+// __mcpc__cli_latest/node_modules/@jsr/mcpc__plugin-markdown-loader/src/markdown-loader.js
+import process3 from "node:process";
+function replaceEnvVars(str2) {
+  return str2.replace(/\$([A-Za-z_][A-Za-z0-9_]*)(?!\s*\()/g, (match, varName) => {
+    const value = process3.env[varName];
+    if (value !== void 0) {
+      return value;
+    }
+    return match;
+  });
+}
+function replaceEnvVarsInObject(obj) {
+  if (typeof obj === "string") {
+    return replaceEnvVars(obj);
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((item) => replaceEnvVarsInObject(item));
+  }
+  if (obj && typeof obj === "object") {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      result[key] = replaceEnvVarsInObject(value);
+    }
+    return result;
+  }
+  return obj;
+}
+function parseMarkdownAgent(content) {
+  const frontMatterRegex = /^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/;
+  const match = content.match(frontMatterRegex);
+  if (!match) {
+    throw new Error("Invalid Markdown agent file: missing YAML front matter. Expected format:\n---\nname: agent-name\n---\n\n# Description...");
+  }
+  const [, yamlContent, markdownContent] = match;
+  let frontMatter;
+  try {
+    frontMatter = parse(yamlContent);
+  } catch (error) {
+    throw new Error(`Failed to parse YAML front matter: ${error}`);
+  }
+  if (!frontMatter.name) {
+    throw new Error("Invalid Markdown agent file: 'name' is required in front matter");
+  }
+  return {
+    frontMatter,
+    body: markdownContent.trim()
+  };
+}
+var OPTION_KEYS = [
+  "mode",
+  "maxSteps",
+  "maxTokens",
+  "tracingEnabled",
+  "refs",
+  "samplingConfig",
+  "providerOptions",
+  "acpSettings"
+];
+function markdownAgentToComposeDefinition(parsed) {
+  const frontMatter = replaceEnvVarsInObject(parsed.frontMatter);
+  const body = replaceEnvVars(parsed.body);
+  const options = {};
+  for (const key of OPTION_KEYS) {
+    if (frontMatter[key] !== void 0) {
+      options[key] = frontMatter[key];
+    }
+  }
+  const hasDescription = frontMatter.description !== void 0 && frontMatter.description !== "";
+  return {
+    name: frontMatter.name,
+    description: hasDescription ? frontMatter.description : body,
+    ...hasDescription && body ? {
+      manual: body
+    } : {},
+    deps: frontMatter.deps,
+    plugins: frontMatter.plugins,
+    ...Object.keys(options).length > 0 ? {
+      options
+    } : {}
+  };
+}
+async function loadMarkdownAgentFile(filePath) {
+  const content = await readFile2(filePath, "utf-8");
+  const parsed = parseMarkdownAgent(content);
+  return markdownAgentToComposeDefinition(parsed);
+}
+
+// __mcpc__cli_latest/node_modules/@jsr/mcpc__plugin-markdown-loader/mod.js
+function markdownLoaderPlugin() {
+  return {
+    name: "markdown-loader",
+    version: "1.0.0",
+    enforce: "pre",
+    configureServer: (server) => {
+      server.registerFileLoader(".md", loadMarkdownAgentFile);
+      server.registerFileLoader(".markdown", loadMarkdownAgentFile);
     }
   };
 }
+var defaultPlugin = markdownLoaderPlugin();
 
 // __mcpc__cli_latest/node_modules/@mcpc/cli/src/defaults.js
-import { createCodeExecutionPlugin } from "@mcpc-tech/plugin-code-execution";
-import { markdownLoaderPlugin } from "@mcpc-tech/plugin-markdown-loader";
 import { resolve as resolve3 } from "node:path";
-import process3 from "node:process";
+import process4 from "node:process";
 var DEFAULT_SKILLS_PATHS = [
   ".claude/skills"
 ];
 var DEFAULT_CODE_EXECUTION_TIMEOUT = 3e5;
 function getGlobalPlugins(skillsPaths) {
-  const resolvedPaths = skillsPaths.map((p2) => resolve3(process3.cwd(), p2));
+  const resolvedPaths = skillsPaths.map((p2) => resolve3(process4.cwd(), p2));
   return [
     markdownLoaderPlugin(),
     createSkillsPlugin({
@@ -2990,6 +5289,7 @@ function getDefaultAgents() {
 }
 
 // __mcpc__cli_latest/node_modules/@mcpc/cli/src/config/loader.js
+var CLI_VERSION = "0.1.44";
 function extractServerName(command, commandArgs) {
   for (const arg of commandArgs) {
     if (!arg.startsWith("-")) {
@@ -3012,7 +5312,7 @@ async function saveUserConfig(config, newAgentName) {
   try {
     let existingConfig = null;
     try {
-      const content = await readFile2(configPath, "utf-8");
+      const content = await readFile3(configPath, "utf-8");
       existingConfig = JSON.parse(content);
     } catch {
     }
@@ -3049,7 +5349,7 @@ async function saveUserConfig(config, newAgentName) {
 async function createWrapConfig(args) {
   if (!args.mcpServers || args.mcpServers.length === 0) {
     console.error("Error: --wrap/--add requires at least one MCP server\nExample: mcpc --wrap --mcp-stdio 'npx -y @wonderwhy-er/desktop-commander'\nMultiple: mcpc --add --mcp-stdio 'npx -y server1' --mcp-http 'https://api.example.com'");
-    process4.exit(1);
+    process5.exit(1);
   }
   const mcpServers = {};
   const serverNames = [];
@@ -3097,97 +5397,50 @@ Created configuration for ${serverNames.length} MCP server(s)${modeInfo}`);
   }
   return config;
 }
+function printVersion() {
+  console.log(`mcpc ${CLI_VERSION}`);
+}
 function printHelp() {
   console.log(`
-MCPC CLI - Model Context Protocol Composer
+mcpc ${CLI_VERSION} - Model Context Protocol Composer
 
 USAGE:
     mcpc [OPTIONS]
 
 OPTIONS:
-    --help, -h              Show this help message
+    -h, --help              Show this help message
+    -v, --version           Show version information
     --cwd <path>            Change working directory before loading config
-                           Useful when running from MCP Inspector or other tools
     --config <json>         Inline JSON configuration string
     --config-url <url>      Fetch configuration from URL
     --config-file <path>    Load configuration from file path
-    --skills <dirs>         Skills directories (comma-separated), default: .claude/skills
-                           Example: --skills ./skills,./more-skills
-    --request-headers <header>, -H <header>
-                           Add custom HTTP header for URL fetching
-                           Format: "Key: Value" or "Key=Value"
-                           Can be used multiple times
-    --mode <mode>           Set execution mode for JSON/object agents (does not
-                           affect Markdown agent files which define mode in frontmatter)
-                           Supported modes:
-                           - agentic: Fully autonomous agent mode (default)
-                           - ai_sampling: AI SDK sampling mode for autonomous execution
-                           - ai_acp: AI SDK ACP mode for coding agents
-                           - code_execution: Code execution mode (requires @mcpc-tech/plugin-code-execution)
+    --skills <dirs>         Skills directories (comma-separated)
+    -H, --request-headers <header>
+                            Add custom HTTP header for URL fetching
+                            Format: "Key: Value" or "Key=Value"
+    --mode <mode>           Set execution mode for agents
+                            Modes: agentic, ai_sampling, ai_acp, code_execution
     --add                   Add MCP servers to ~/.mcpc/config.json and exit
-                           Then run 'mcpc' to start the server with saved config
-                           Use --mcp-stdio, --mcp-http, or --mcp-sse to specify servers
-    --wrap                  Wrap and run MCP servers immediately without saving config
-                           Use --mcp-stdio, --mcp-http, or --mcp-sse to specify servers
+    --wrap                  Wrap and run MCP servers immediately
     --mcp-stdio <cmd>       Add an MCP server with stdio transport
-                           Example: --mcp-stdio "npx -y @wonderwhy-er/desktop-commander"
     --mcp-http <url>        Add an MCP server with streamable-http transport
-                           Example: --mcp-http "https://api.github.com/mcp"
     --mcp-sse <url>         Add an MCP server with SSE transport
-                           Example: --mcp-sse "https://api.example.com/sse"
-    --name <name>           Custom agent name for wrap mode (overrides auto-detection)
+    --name <name>           Custom agent name for wrap mode
 
 ENVIRONMENT VARIABLES:
-    MCPC_CONFIG            Inline JSON configuration (same as --config)
-    MCPC_CONFIG_URL        URL to fetch config from (same as --config-url)
-    MCPC_CONFIG_FILE       Path to config file (same as --config-file)
+    MCPC_CONFIG             Inline JSON configuration
+    MCPC_CONFIG_URL         URL to fetch config from
+    MCPC_CONFIG_FILE        Path to config file
 
 EXAMPLES:
-    # Show help
     mcpc --help
-
-    # Add MCP servers to config and save to ~/.mcpc/config.json
+    mcpc --version
     mcpc --add --mcp-stdio "npx -y @wonderwhy-er/desktop-commander"
-    # Edit ~/.mcpc/config.json if needed (add headers, etc.)
-    mcpc  # Loads config from ~/.mcpc/config.json automatically
-
-    # Wrap and run immediately (one-time use, no config saved)
     mcpc --wrap --mcp-stdio "npx -y @wonderwhy-er/desktop-commander"
-
-    # Multiple servers with different transports
-    mcpc --add       --mcp-stdio "npx -y @wonderwhy-er/desktop-commander"       --mcp-http "https://api.github.com/mcp"       --mcp-sse "https://api.example.com/sse"
-
-    # Custom agent name
-    mcpc --add --name my-agent --mcp-stdio "npx shadcn@latest mcp"
-    mcpc --wrap --name my-agent --mcp-stdio "npx shadcn@latest mcp"
-
-    # Load from URL
-    mcpc --config-url \\
-      "https://raw.githubusercontent.com/mcpc-tech/mcpc/main/packages/cli/examples/configs/codex-fork.json"
-
-    # Load from URL with custom headers
-    mcpc \\
-      --config-url "https://api.example.com/config.json" \\
-      -H "Authorization: Bearer token123" \\
-      -H "X-Custom-Header: value"
-
-    # Load from file
+    mcpc --config-url "https://example.com/config.json"
     mcpc --config-file ./my-config.json
 
-    # Override execution mode for all agents
-    mcpc --config-file ./my-config.json --mode ai_sampling
-
-    # Using environment variable
-    export MCPC_CONFIG='[{"name":"agent","description":"..."}]'
-    mcpc
-
-    # Use default configuration (./mcpc.config.json)
-    mcpc
-
-CONFIGURATION:
-    Configuration files support environment variable substitution using $VAR_NAME syntax.
-    
-    Priority order:
+CONFIG PRIORITY:
     1. --config (inline JSON)
     2. MCPC_CONFIG environment variable
     3. --config-url or MCPC_CONFIG_URL
@@ -3195,93 +5448,140 @@ CONFIGURATION:
     5. ~/.mcpc/config.json (user config)
     6. ./mcpc.config.json (local config)
 
-For more information, visit: https://github.com/mcpc-tech/mcpc
+For more information: https://github.com/mcpc-tech/mcpc
 `);
 }
-function parseArgs() {
-  const args = process4.argv.slice(2);
-  const result = {};
-  for (let i = 0; i < args.length; i++) {
-    const arg = args[i];
-    if (arg === "--cwd" && i + 1 < args.length) {
-      result.cwd = args[++i];
-    } else if (arg === "--config" && i + 1 < args.length) {
-      result.config = args[++i];
-    } else if (arg === "--config-url" && i + 1 < args.length) {
-      result.configUrl = args[++i];
-    } else if (arg === "--config-file" && i + 1 < args.length) {
-      result.configFile = args[++i];
-    } else if ((arg === "--request-headers" || arg === "-H") && i + 1 < args.length) {
-      const headerStr = args[++i];
-      const colonIdx = headerStr.indexOf(":");
-      const equalIdx = headerStr.indexOf("=");
-      const separatorIdx = colonIdx !== -1 ? equalIdx !== -1 ? Math.min(colonIdx, equalIdx) : colonIdx : equalIdx;
-      if (separatorIdx !== -1) {
-        const key = headerStr.substring(0, separatorIdx).trim();
-        const value = headerStr.substring(separatorIdx + 1).trim();
-        if (!result.requestHeaders) {
-          result.requestHeaders = {};
-        }
-        result.requestHeaders[key] = value;
-      }
-    } else if (arg === "--help" || arg === "-h") {
-      result.help = true;
-    } else if (arg === "--add") {
-      result.add = true;
-    } else if (arg === "--wrap") {
-      result.wrap = true;
-    } else if ((arg === "--mcp-stdio" || arg === "--mcp-http" || arg === "--mcp-sse") && i + 1 < args.length) {
-      const cmdString = args[++i];
-      const cmdParts = cmdString.split(/\s+/);
-      const command = cmdParts[0];
-      const cmdArgs = cmdParts.slice(1);
-      let transportType;
-      if (arg === "--mcp-stdio") {
-        transportType = "stdio";
-      } else if (arg === "--mcp-http") {
-        transportType = "streamable-http";
-      } else {
-        transportType = "sse";
+function parseHeader(headerStr) {
+  const colonIdx = headerStr.indexOf(":");
+  const equalIdx = headerStr.indexOf("=");
+  const separatorIdx = colonIdx !== -1 ? equalIdx !== -1 ? Math.min(colonIdx, equalIdx) : colonIdx : equalIdx;
+  if (separatorIdx !== -1) {
+    return {
+      key: headerStr.substring(0, separatorIdx).trim(),
+      value: headerStr.substring(separatorIdx + 1).trim()
+    };
+  }
+  return null;
+}
+function parseMcpServer(cmdString, transportType) {
+  const cmdParts = cmdString.split(/\s+/);
+  return {
+    command: cmdParts[0],
+    args: cmdParts.slice(1),
+    transportType
+  };
+}
+function parseCLIArgs() {
+  const args = parseArgs(process5.argv.slice(2), {
+    boolean: [
+      "help",
+      "version",
+      "add",
+      "wrap"
+    ],
+    string: [
+      "cwd",
+      "config",
+      "config-url",
+      "config-file",
+      "mode",
+      "name",
+      "skills",
+      "mcp-stdio",
+      "mcp-http",
+      "mcp-sse"
+    ],
+    collect: [
+      "request-headers",
+      "mcp-stdio",
+      "mcp-http",
+      "mcp-sse"
+    ],
+    alias: {
+      h: "help",
+      v: "version",
+      H: "request-headers"
+    },
+    default: {
+      help: false,
+      version: false,
+      add: false,
+      wrap: false
+    }
+  });
+  const result = {
+    help: args.help,
+    version: args.version,
+    add: args.add,
+    wrap: args.wrap,
+    cwd: args.cwd,
+    config: args.config,
+    configUrl: args["config-url"],
+    configFile: args["config-file"],
+    mode: args.mode,
+    name: args.name
+  };
+  if (args.skills) {
+    result.skills = args.skills.split(",").map((s) => s.trim()).filter(Boolean);
+  }
+  const headers = args["request-headers"];
+  if (headers && headers.length > 0) {
+    result.requestHeaders = {};
+    for (const h of headers) {
+      const parsed = parseHeader(h);
+      if (parsed) {
+        result.requestHeaders[parsed.key] = parsed.value;
       }
-      if (!result.mcpServers) {
-        result.mcpServers = [];
+    }
+  }
+  const mcpStdio = args["mcp-stdio"];
+  const mcpHttp = args["mcp-http"];
+  const mcpSse = args["mcp-sse"];
+  if (mcpStdio && mcpStdio.length > 0 || mcpHttp && mcpHttp.length > 0 || mcpSse && mcpSse.length > 0) {
+    result.mcpServers = [];
+    if (mcpStdio) {
+      for (const cmd of mcpStdio) {
+        result.mcpServers.push(parseMcpServer(cmd, "stdio"));
+      }
+    }
+    if (mcpHttp) {
+      for (const url2 of mcpHttp) {
+        result.mcpServers.push(parseMcpServer(url2, "streamable-http"));
+      }
+    }
+    if (mcpSse) {
+      for (const url2 of mcpSse) {
+        result.mcpServers.push(parseMcpServer(url2, "sse"));
       }
-      result.mcpServers.push({
-        command,
-        args: cmdArgs,
-        transportType
-      });
-    } else if (arg === "--mode" && i + 1 < args.length) {
-      result.mode = args[++i];
-    } else if (arg === "--name" && i + 1 < args.length) {
-      result.name = args[++i];
-    } else if (arg === "--skills" && i + 1 < args.length) {
-      result.skills = args[++i].split(",").map((s) => s.trim()).filter(Boolean);
     }
   }
   return result;
 }
 async function loadConfig() {
-  const args = parseArgs();
+  const args = parseCLIArgs();
+  if (args.version) {
+    printVersion();
+    process5.exit(0);
+  }
+  if (args.help) {
+    printHelp();
+    process5.exit(0);
+  }
   if (args.cwd) {
-    const targetCwd = resolve4(process4.cwd(), args.cwd);
-    process4.chdir(targetCwd);
+    const targetCwd = resolve4(process5.cwd(), args.cwd);
+    process5.chdir(targetCwd);
     console.error(`Changed working directory to: ${targetCwd}`);
   }
   const mergeSkills = (config) => {
     config.skills = args.skills || config.skills || DEFAULT_SKILLS_PATHS;
     return config;
   };
-  if (args.help) {
-    printHelp();
-    process4.exit(0);
-  }
   if (args.add) {
     await createWrapConfig({
       ...args,
       saveConfig: true
     });
-    process4.exit(0);
+    process5.exit(0);
   }
   if (args.wrap) {
     return mergeSkills(await createWrapConfig({
@@ -3298,16 +5598,16 @@ async function loadConfig() {
       throw error;
     }
   }
-  if (process4.env.MCPC_CONFIG) {
+  if (process5.env.MCPC_CONFIG) {
     try {
-      const parsed = JSON.parse(process4.env.MCPC_CONFIG);
+      const parsed = JSON.parse(process5.env.MCPC_CONFIG);
       return mergeSkills(applyModeOverride(normalizeConfig(parsed), args.mode));
     } catch (error) {
       console.error("Failed to parse MCPC_CONFIG environment variable:", error);
       throw error;
     }
   }
-  const configUrl = args.configUrl || process4.env.MCPC_CONFIG_URL;
+  const configUrl = args.configUrl || process5.env.MCPC_CONFIG_URL;
   if (configUrl) {
     try {
       const headers = {
@@ -3328,7 +5628,7 @@ async function loadConfig() {
       throw error;
     }
   }
-  const configFile = args.configFile || process4.env.MCPC_CONFIG_FILE;
+  const configFile = args.configFile || process5.env.MCPC_CONFIG_FILE;
   if (configFile) {
     try {
       const config = await loadConfigFromFile(configFile);
@@ -3353,7 +5653,7 @@ async function loadConfig() {
       throw error;
     }
   }
-  const defaultJsonConfigPath = resolve4(process4.cwd(), "mcpc.config.json");
+  const defaultJsonConfigPath = resolve4(process5.cwd(), "mcpc.config.json");
   try {
     const config = await loadConfigFromFile(defaultJsonConfigPath);
     return mergeSkills(applyModeOverride(config, args.mode));
@@ -3366,16 +5666,16 @@ async function loadConfig() {
     }
   }
 }
-function replaceEnvVars(str) {
-  return str.replace(/\$([A-Z_][A-Z0-9_]*)/g, (_match, varName) => {
-    return process4.env[varName] || "";
+function replaceEnvVars2(str2) {
+  return str2.replace(/\$([A-Z_][A-Z0-9_]*)/g, (_match, varName) => {
+    return process5.env[varName] || "";
   });
 }
-function isMarkdownFile(path) {
+function isMarkdownFile2(path) {
   return path.endsWith(".md") || path.endsWith(".markdown");
 }
 async function loadConfigFromFile(filePath) {
-  if (isMarkdownFile(filePath)) {
+  if (isMarkdownFile2(filePath)) {
     return {
       name: "mcpc-server",
       version: "0.1.0",
@@ -3384,13 +5684,13 @@ async function loadConfigFromFile(filePath) {
       ]
     };
   }
-  const content = await readFile2(filePath, "utf-8");
+  const content = await readFile3(filePath, "utf-8");
   const parsed = JSON.parse(content);
   return normalizeConfig(parsed);
 }
 function replaceEnvVarsInConfig(obj) {
   if (typeof obj === "string") {
-    return replaceEnvVars(obj);
+    return replaceEnvVars2(obj);
   }
   if (Array.isArray(obj)) {
     return obj.map((item) => replaceEnvVarsInConfig(item));
@@ -4476,7 +6776,7 @@ var Protocol = class {
     };
   }
 };
-function isPlainObject(value) {
+function isPlainObject2(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 function mergeCapabilities(base, additional) {
@@ -4487,7 +6787,7 @@ function mergeCapabilities(base, additional) {
     if (addValue === void 0)
       continue;
     const baseValue = result[k];
-    if (isPlainObject(baseValue) && isPlainObject(addValue)) {
+    if (isPlainObject2(baseValue) && isPlainObject2(addValue)) {
       result[k] = { ...baseValue, ...addValue };
     } else {
       result[k] = addValue;
@@ -5785,9 +8085,9 @@ var Client = class extends Protocol {
 
 // __mcpc__cli_latest/node_modules/@modelcontextprotocol/sdk/dist/esm/client/stdio.js
 var import_cross_spawn = __toESM(require_cross_spawn(), 1);
-import process5 from "node:process";
+import process6 from "node:process";
 import { PassThrough } from "node:stream";
-var DEFAULT_INHERITED_ENV_VARS = process5.platform === "win32" ? [
+var DEFAULT_INHERITED_ENV_VARS = process6.platform === "win32" ? [
   "APPDATA",
   "HOMEDRIVE",
   "HOMEPATH",
@@ -5807,7 +8107,7 @@ var DEFAULT_INHERITED_ENV_VARS = process5.platform === "win32" ? [
 function getDefaultEnvironment() {
   const env = {};
   for (const key of DEFAULT_INHERITED_ENV_VARS) {
-    const value = process5.env[key];
+    const value = process6.env[key];
     if (value === void 0) {
       continue;
     }
@@ -5843,7 +8143,7 @@ var StdioClientTransport = class {
         },
         stdio: ["pipe", "pipe", this._serverParams.stderr ?? "inherit"],
         shell: false,
-        windowsHide: process5.platform === "win32" && isElectron(),
+        windowsHide: process6.platform === "win32" && isElectron(),
         cwd: this._serverParams.cwd
       });
       this._process.on("error", (error) => {
@@ -5951,7 +8251,7 @@ var StdioClientTransport = class {
   }
 };
 function isElectron() {
-  return "type" in process5;
+  return "type" in process6;
 }
 
 // __mcpc__cli_latest/node_modules/eventsource-parser/dist/index.js
@@ -7832,8 +10132,8 @@ var InMemoryTransport = class _InMemoryTransport {
 };
 
 // __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/common/config.js
-import process6 from "node:process";
-var GEMINI_PREFERRED_FORMAT = process6.env.GEMINI_PREFERRED_FORMAT === "0" ? false : true;
+import process7 from "node:process";
+var GEMINI_PREFERRED_FORMAT = process7.env.GEMINI_PREFERRED_FORMAT === "0" ? false : true;
 
 // __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/common/json.js
 import { jsonrepair as jsonrepair2 } from "jsonrepair";
@@ -7906,7 +10206,7 @@ var cleanToolSchema = (schema) => {
 
 // __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/common/mcp.js
 import { cwd } from "node:process";
-import process7 from "node:process";
+import process8 from "node:process";
 import { createHash } from "node:crypto";
 var mcpClientPool = /* @__PURE__ */ new Map();
 var mcpClientConnecting = /* @__PURE__ */ new Map();
@@ -7959,7 +10259,7 @@ function createTransport(def) {
       command: defAny.command,
       args: defAny.args,
       env: {
-        ...process7.env,
+        ...process8.env,
         ...defAny.env ?? {}
       },
       cwd: cwd()
@@ -8027,11 +10327,11 @@ var cleanupAllPooledClients = async () => {
     }
   }));
 };
-process7.once?.("exit", () => {
+process8.once?.("exit", () => {
   cleanupAllPooledClients();
 });
-process7.once?.("SIGINT", () => {
-  cleanupAllPooledClients().finally(() => process7.exit(0));
+process8.once?.("SIGINT", () => {
+  cleanupAllPooledClients().finally(() => process8.exit(0));
 });
 async function composeMcpDepTools(mcpConfig, filterIn) {
   const allTools = {};
@@ -8653,7 +10953,7 @@ function endSpan(span, error) {
 }
 
 // __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/executors/agentic/agentic-executor.js
-import process8 from "node:process";
+import process9 from "node:process";
 var AgenticExecutor = class {
   name;
   allToolNames;
@@ -8673,13 +10973,13 @@ var AgenticExecutor = class {
     this.logger = createLogger(`mcpc.agentic.${name}`, server);
     this.toolSchemaMap = new Map(toolNameToDetailList);
     try {
-      this.tracingEnabled = process8.env.MCPC_TRACING_ENABLED === "true";
+      this.tracingEnabled = process9.env.MCPC_TRACING_ENABLED === "true";
       if (this.tracingEnabled) {
         initializeTracing({
           enabled: true,
           serviceName: `mcpc-agentic-${name}`,
-          exportTo: process8.env.MCPC_TRACING_EXPORT ?? "otlp",
-          otlpEndpoint: process8.env.MCPC_TRACING_OTLP_ENDPOINT ?? "http://localhost:4318/v1/traces"
+          exportTo: process9.env.MCPC_TRACING_EXPORT ?? "otlp",
+          otlpEndpoint: process9.env.MCPC_TRACING_OTLP_ENDPOINT ?? "http://localhost:4318/v1/traces"
         });
       }
     } catch {
@@ -10004,7 +12304,7 @@ async function loadPlugin(pluginPath, options = {
     const importPath = typeof resolveFn === "function" ? resolveFn(rawPath) : new URL(rawPath, import.meta.url).href;
     const pluginModule = await import(importPath);
     const pluginFactory = pluginModule.createPlugin;
-    const defaultPlugin = pluginModule.default;
+    const defaultPlugin2 = pluginModule.default;
     let plugin;
     if (Object.keys(params).length > 0) {
       if (typeof pluginFactory !== "function") {
@@ -10013,8 +12313,8 @@ async function loadPlugin(pluginPath, options = {
       const typedParams = parseQueryParams(params);
       plugin = pluginFactory(typedParams);
     } else {
-      if (defaultPlugin) {
-        plugin = defaultPlugin;
+      if (defaultPlugin2) {
+        plugin = defaultPlugin2;
       } else if (typeof pluginFactory === "function") {
         plugin = pluginFactory();
       } else {
@@ -10715,6 +13015,7 @@ var ComposableMCPServer = class extends Server {
   pluginManager;
   toolManager;
   logger = createLogger("mcpc.compose");
+  fileLoaders = /* @__PURE__ */ new Map();
   // Legacy property for backward compatibility
   get toolNameMapping() {
     return this.toolManager.getToolNameMapping();
@@ -10733,6 +13034,58 @@ var ComposableMCPServer = class extends Server {
     this.pluginManager = new PluginManager(this);
     this.toolManager = new ToolManager();
   }
+  /**
+   * Register a file loader for a specific extension.
+   * Plugins can use this to add support for different file formats.
+   *
+   * @param extension - File extension including the dot (e.g., ".md", ".yaml")
+   * @param loader - Function that loads a file and returns a ComposeDefinition
+   *
+   * @example
+   * ```typescript
+   * // In a plugin's configureServer hook:
+   * configureServer: (server) => {
+   *   server.registerFileLoader(".md", loadMarkdownAgentFile);
+   *   server.registerFileLoader(".yaml", loadYamlAgentFile);
+   * }
+   * ```
+   */
+  registerFileLoader(extension, loader) {
+    this.fileLoaders.set(extension.toLowerCase(), loader);
+  }
+  /**
+   * Get the file loader for a specific extension.
+   */
+  getFileLoader(extension) {
+    return this.fileLoaders.get(extension.toLowerCase());
+  }
+  /**
+   * Check if a file extension has a registered loader.
+   */
+  hasFileLoader(extension) {
+    return this.fileLoaders.has(extension.toLowerCase());
+  }
+  /**
+   * Get all registered file extensions.
+   */
+  getRegisteredExtensions() {
+    return Array.from(this.fileLoaders.keys());
+  }
+  /**
+   * Resolve a file path to a ComposeDefinition using registered loaders.
+   * @internal
+   */
+  async resolveFilePath(filePath) {
+    const lastDot = filePath.lastIndexOf(".");
+    const extension = lastDot === -1 ? "" : filePath.slice(lastDot).toLowerCase();
+    const loader = this.fileLoaders.get(extension);
+    if (!loader) {
+      const supportedExtensions = this.getRegisteredExtensions().join(", ");
+      const hint = supportedExtensions ? ` Supported extensions: ${supportedExtensions}.` : ' No file loaders registered. Use a loader plugin (e.g., markdownLoaderPlugin from "@mcpc/plugin-markdown-loader").';
+      throw new Error(`Cannot load file "${filePath}": No loader registered for "${extension}" extension.${hint}`);
+    }
+    return await loader(filePath);
+  }
   /**
    * Initialize built-in plugins - called during setup
    */
@@ -11277,32 +13630,16 @@ var ComposableMCPServer = class extends Server {
 };
 
 // __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/common/env.js
-import process9 from "node:process";
-var isSCF = () => Boolean(process9.env.SCF_RUNTIME || process9.env.PROD_SCF);
+import process10 from "node:process";
+var isSCF = () => Boolean(process10.env.SCF_RUNTIME || process10.env.PROD_SCF);
 if (isSCF()) {
   console.log({
     isSCF: isSCF(),
-    SCF_RUNTIME: process9.env.SCF_RUNTIME
+    SCF_RUNTIME: process10.env.SCF_RUNTIME
   });
 }
 
 // __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/set-up-mcp-compose.js
-var markdownAgentLoader = null;
-function isMarkdownFile2(path) {
-  return path.endsWith(".md") || path.endsWith(".markdown");
-}
-async function resolveComposeInput(input) {
-  if (typeof input !== "string") {
-    return input;
-  }
-  if (!isMarkdownFile2(input)) {
-    throw new Error(`Invalid compose input: "${input}". Expected a Markdown file path (.md) or a ComposeDefinition object.`);
-  }
-  if (!markdownAgentLoader) {
-    throw new Error(`Cannot load Markdown agent file "${input}": Markdown loader not available. Use markdownLoaderPlugin() from "@mcpc/plugin-markdown-loader", or use inline ComposeDefinition objects.`);
-  }
-  return await markdownAgentLoader(input);
-}
 function parseMcpcConfigs(conf) {
   return conf ?? [];
 }
@@ -11320,7 +13657,13 @@ async function mcpc(serverConf, composeConf, optionsOrSetup) {
       }
     }
   }
-  const resolvedConfigs = composeConf ? await Promise.all(composeConf.map(resolveComposeInput)) : [];
+  const resolveInput = (input) => {
+    if (typeof input !== "string") {
+      return Promise.resolve(input);
+    }
+    return server.resolveFilePath(input);
+  };
+  const resolvedConfigs = composeConf ? await Promise.all(composeConf.map(resolveInput)) : [];
   const parsed = parseMcpcConfigs(resolvedConfigs);
   await server.initBuiltInPlugins();
   for (const mcpcConfig of parsed) {