@fro.bot/systematic 2.3.1 → 2.3.2

package/dist/index-3h7kpmfa.js

@@ -0,0 +1,1480 @@
+// @bun
+// src/lib/config.ts
+import fs from "fs";
+import os from "os";
+import path from "path";
+
+// node_modules/.bun/jsonc-parser@3.3.1/node_modules/jsonc-parser/lib/esm/impl/scanner.js
+function createScanner(text, ignoreTrivia = false) {
+  const len = text.length;
+  let pos = 0, value = "", tokenOffset = 0, token = 16, lineNumber = 0, lineStartOffset = 0, tokenLineStartOffset = 0, prevTokenLineStartOffset = 0, scanError = 0;
+  function scanHexDigits(count, exact) {
+    let digits = 0;
+    let value2 = 0;
+    while (digits < count || !exact) {
+      let ch = text.charCodeAt(pos);
+      if (ch >= 48 && ch <= 57) {
+        value2 = value2 * 16 + ch - 48;
+      } else if (ch >= 65 && ch <= 70) {
+        value2 = value2 * 16 + ch - 65 + 10;
+      } else if (ch >= 97 && ch <= 102) {
+        value2 = value2 * 16 + ch - 97 + 10;
+      } else {
+        break;
+      }
+      pos++;
+      digits++;
+    }
+    if (digits < count) {
+      value2 = -1;
+    }
+    return value2;
+  }
+  function setPosition(newPosition) {
+    pos = newPosition;
+    value = "";
+    tokenOffset = 0;
+    token = 16;
+    scanError = 0;
+  }
+  function scanNumber() {
+    let start = pos;
+    if (text.charCodeAt(pos) === 48) {
+      pos++;
+    } else {
+      pos++;
+      while (pos < text.length && isDigit(text.charCodeAt(pos))) {
+        pos++;
+      }
+    }
+    if (pos < text.length && text.charCodeAt(pos) === 46) {
+      pos++;
+      if (pos < text.length && isDigit(text.charCodeAt(pos))) {
+        pos++;
+        while (pos < text.length && isDigit(text.charCodeAt(pos))) {
+          pos++;
+        }
+      } else {
+        scanError = 3;
+        return text.substring(start, pos);
+      }
+    }
+    let end = pos;
+    if (pos < text.length && (text.charCodeAt(pos) === 69 || text.charCodeAt(pos) === 101)) {
+      pos++;
+      if (pos < text.length && text.charCodeAt(pos) === 43 || text.charCodeAt(pos) === 45) {
+        pos++;
+      }
+      if (pos < text.length && isDigit(text.charCodeAt(pos))) {
+        pos++;
+        while (pos < text.length && isDigit(text.charCodeAt(pos))) {
+          pos++;
+        }
+        end = pos;
+      } else {
+        scanError = 3;
+      }
+    }
+    return text.substring(start, end);
+  }
+  function scanString() {
+    let result = "", start = pos;
+    while (true) {
+      if (pos >= len) {
+        result += text.substring(start, pos);
+        scanError = 2;
+        break;
+      }
+      const ch = text.charCodeAt(pos);
+      if (ch === 34) {
+        result += text.substring(start, pos);
+        pos++;
+        break;
+      }
+      if (ch === 92) {
+        result += text.substring(start, pos);
+        pos++;
+        if (pos >= len) {
+          scanError = 2;
+          break;
+        }
+        const ch2 = text.charCodeAt(pos++);
+        switch (ch2) {
+          case 34:
+            result += '"';
+            break;
+          case 92:
+            result += "\\";
+            break;
+          case 47:
+            result += "/";
+            break;
+          case 98:
+            result += "\b";
+            break;
+          case 102:
+            result += "\f";
+            break;
+          case 110:
+            result += `
+`;
+            break;
+          case 114:
+            result += "\r";
+            break;
+          case 116:
+            result += "\t";
+            break;
+          case 117:
+            const ch3 = scanHexDigits(4, true);
+            if (ch3 >= 0) {
+              result += String.fromCharCode(ch3);
+            } else {
+              scanError = 4;
+            }
+            break;
+          default:
+            scanError = 5;
+        }
+        start = pos;
+        continue;
+      }
+      if (ch >= 0 && ch <= 31) {
+        if (isLineBreak(ch)) {
+          result += text.substring(start, pos);
+          scanError = 2;
+          break;
+        } else {
+          scanError = 6;
+        }
+      }
+      pos++;
+    }
+    return result;
+  }
+  function scanNext() {
+    value = "";
+    scanError = 0;
+    tokenOffset = pos;
+    lineStartOffset = lineNumber;
+    prevTokenLineStartOffset = tokenLineStartOffset;
+    if (pos >= len) {
+      tokenOffset = len;
+      return token = 17;
+    }
+    let code = text.charCodeAt(pos);
+    if (isWhiteSpace(code)) {
+      do {
+        pos++;
+        value += String.fromCharCode(code);
+        code = text.charCodeAt(pos);
+      } while (isWhiteSpace(code));
+      return token = 15;
+    }
+    if (isLineBreak(code)) {
+      pos++;
+      value += String.fromCharCode(code);
+      if (code === 13 && text.charCodeAt(pos) === 10) {
+        pos++;
+        value += `
+`;
+      }
+      lineNumber++;
+      tokenLineStartOffset = pos;
+      return token = 14;
+    }
+    switch (code) {
+      case 123:
+        pos++;
+        return token = 1;
+      case 125:
+        pos++;
+        return token = 2;
+      case 91:
+        pos++;
+        return token = 3;
+      case 93:
+        pos++;
+        return token = 4;
+      case 58:
+        pos++;
+        return token = 6;
+      case 44:
+        pos++;
+        return token = 5;
+      case 34:
+        pos++;
+        value = scanString();
+        return token = 10;
+      case 47:
+        const start = pos - 1;
+        if (text.charCodeAt(pos + 1) === 47) {
+          pos += 2;
+          while (pos < len) {
+            if (isLineBreak(text.charCodeAt(pos))) {
+              break;
+            }
+            pos++;
+          }
+          value = text.substring(start, pos);
+          return token = 12;
+        }
+        if (text.charCodeAt(pos + 1) === 42) {
+          pos += 2;
+          const safeLength = len - 1;
+          let commentClosed = false;
+          while (pos < safeLength) {
+            const ch = text.charCodeAt(pos);
+            if (ch === 42 && text.charCodeAt(pos + 1) === 47) {
+              pos += 2;
+              commentClosed = true;
+              break;
+            }
+            pos++;
+            if (isLineBreak(ch)) {
+              if (ch === 13 && text.charCodeAt(pos) === 10) {
+                pos++;
+              }
+              lineNumber++;
+              tokenLineStartOffset = pos;
+            }
+          }
+          if (!commentClosed) {
+            pos++;
+            scanError = 1;
+          }
+          value = text.substring(start, pos);
+          return token = 13;
+        }
+        value += String.fromCharCode(code);
+        pos++;
+        return token = 16;
+      case 45:
+        value += String.fromCharCode(code);
+        pos++;
+        if (pos === len || !isDigit(text.charCodeAt(pos))) {
+          return token = 16;
+        }
+      case 48:
+      case 49:
+      case 50:
+      case 51:
+      case 52:
+      case 53:
+      case 54:
+      case 55:
+      case 56:
+      case 57:
+        value += scanNumber();
+        return token = 11;
+      default:
+        while (pos < len && isUnknownContentCharacter(code)) {
+          pos++;
+          code = text.charCodeAt(pos);
+        }
+        if (tokenOffset !== pos) {
+          value = text.substring(tokenOffset, pos);
+          switch (value) {
+            case "true":
+              return token = 8;
+            case "false":
+              return token = 9;
+            case "null":
+              return token = 7;
+          }
+          return token = 16;
+        }
+        value += String.fromCharCode(code);
+        pos++;
+        return token = 16;
+    }
+  }
+  function isUnknownContentCharacter(code) {
+    if (isWhiteSpace(code) || isLineBreak(code)) {
+      return false;
+    }
+    switch (code) {
+      case 125:
+      case 93:
+      case 123:
+      case 91:
+      case 34:
+      case 58:
+      case 44:
+      case 47:
+        return false;
+    }
+    return true;
+  }
+  function scanNextNonTrivia() {
+    let result;
+    do {
+      result = scanNext();
+    } while (result >= 12 && result <= 15);
+    return result;
+  }
+  return {
+    setPosition,
+    getPosition: () => pos,
+    scan: ignoreTrivia ? scanNextNonTrivia : scanNext,
+    getToken: () => token,
+    getTokenValue: () => value,
+    getTokenOffset: () => tokenOffset,
+    getTokenLength: () => pos - tokenOffset,
+    getTokenStartLine: () => lineStartOffset,
+    getTokenStartCharacter: () => tokenOffset - prevTokenLineStartOffset,
+    getTokenError: () => scanError
+  };
+}
+function isWhiteSpace(ch) {
+  return ch === 32 || ch === 9;
+}
+function isLineBreak(ch) {
+  return ch === 10 || ch === 13;
+}
+function isDigit(ch) {
+  return ch >= 48 && ch <= 57;
+}
+var CharacterCodes;
+(function(CharacterCodes2) {
+  CharacterCodes2[CharacterCodes2["lineFeed"] = 10] = "lineFeed";
+  CharacterCodes2[CharacterCodes2["carriageReturn"] = 13] = "carriageReturn";
+  CharacterCodes2[CharacterCodes2["space"] = 32] = "space";
+  CharacterCodes2[CharacterCodes2["_0"] = 48] = "_0";
+  CharacterCodes2[CharacterCodes2["_1"] = 49] = "_1";
+  CharacterCodes2[CharacterCodes2["_2"] = 50] = "_2";
+  CharacterCodes2[CharacterCodes2["_3"] = 51] = "_3";
+  CharacterCodes2[CharacterCodes2["_4"] = 52] = "_4";
+  CharacterCodes2[CharacterCodes2["_5"] = 53] = "_5";
+  CharacterCodes2[CharacterCodes2["_6"] = 54] = "_6";
+  CharacterCodes2[CharacterCodes2["_7"] = 55] = "_7";
+  CharacterCodes2[CharacterCodes2["_8"] = 56] = "_8";
+  CharacterCodes2[CharacterCodes2["_9"] = 57] = "_9";
+  CharacterCodes2[CharacterCodes2["a"] = 97] = "a";
+  CharacterCodes2[CharacterCodes2["b"] = 98] = "b";
+  CharacterCodes2[CharacterCodes2["c"] = 99] = "c";
+  CharacterCodes2[CharacterCodes2["d"] = 100] = "d";
+  CharacterCodes2[CharacterCodes2["e"] = 101] = "e";
+  CharacterCodes2[CharacterCodes2["f"] = 102] = "f";
+  CharacterCodes2[CharacterCodes2["g"] = 103] = "g";
+  CharacterCodes2[CharacterCodes2["h"] = 104] = "h";
+  CharacterCodes2[CharacterCodes2["i"] = 105] = "i";
+  CharacterCodes2[CharacterCodes2["j"] = 106] = "j";
+  CharacterCodes2[CharacterCodes2["k"] = 107] = "k";
+  CharacterCodes2[CharacterCodes2["l"] = 108] = "l";
+  CharacterCodes2[CharacterCodes2["m"] = 109] = "m";
+  CharacterCodes2[CharacterCodes2["n"] = 110] = "n";
+  CharacterCodes2[CharacterCodes2["o"] = 111] = "o";
+  CharacterCodes2[CharacterCodes2["p"] = 112] = "p";
+  CharacterCodes2[CharacterCodes2["q"] = 113] = "q";
+  CharacterCodes2[CharacterCodes2["r"] = 114] = "r";
+  CharacterCodes2[CharacterCodes2["s"] = 115] = "s";
+  CharacterCodes2[CharacterCodes2["t"] = 116] = "t";
+  CharacterCodes2[CharacterCodes2["u"] = 117] = "u";
+  CharacterCodes2[CharacterCodes2["v"] = 118] = "v";
+  CharacterCodes2[CharacterCodes2["w"] = 119] = "w";
+  CharacterCodes2[CharacterCodes2["x"] = 120] = "x";
+  CharacterCodes2[CharacterCodes2["y"] = 121] = "y";
+  CharacterCodes2[CharacterCodes2["z"] = 122] = "z";
+  CharacterCodes2[CharacterCodes2["A"] = 65] = "A";
+  CharacterCodes2[CharacterCodes2["B"] = 66] = "B";
+  CharacterCodes2[CharacterCodes2["C"] = 67] = "C";
+  CharacterCodes2[CharacterCodes2["D"] = 68] = "D";
+  CharacterCodes2[CharacterCodes2["E"] = 69] = "E";
+  CharacterCodes2[CharacterCodes2["F"] = 70] = "F";
+  CharacterCodes2[CharacterCodes2["G"] = 71] = "G";
+  CharacterCodes2[CharacterCodes2["H"] = 72] = "H";
+  CharacterCodes2[CharacterCodes2["I"] = 73] = "I";
+  CharacterCodes2[CharacterCodes2["J"] = 74] = "J";
+  CharacterCodes2[CharacterCodes2["K"] = 75] = "K";
+  CharacterCodes2[CharacterCodes2["L"] = 76] = "L";
+  CharacterCodes2[CharacterCodes2["M"] = 77] = "M";
+  CharacterCodes2[CharacterCodes2["N"] = 78] = "N";
+  CharacterCodes2[CharacterCodes2["O"] = 79] = "O";
+  CharacterCodes2[CharacterCodes2["P"] = 80] = "P";
+  CharacterCodes2[CharacterCodes2["Q"] = 81] = "Q";
+  CharacterCodes2[CharacterCodes2["R"] = 82] = "R";
+  CharacterCodes2[CharacterCodes2["S"] = 83] = "S";
+  CharacterCodes2[CharacterCodes2["T"] = 84] = "T";
+  CharacterCodes2[CharacterCodes2["U"] = 85] = "U";
+  CharacterCodes2[CharacterCodes2["V"] = 86] = "V";
+  CharacterCodes2[CharacterCodes2["W"] = 87] = "W";
+  CharacterCodes2[CharacterCodes2["X"] = 88] = "X";
+  CharacterCodes2[CharacterCodes2["Y"] = 89] = "Y";
+  CharacterCodes2[CharacterCodes2["Z"] = 90] = "Z";
+  CharacterCodes2[CharacterCodes2["asterisk"] = 42] = "asterisk";
+  CharacterCodes2[CharacterCodes2["backslash"] = 92] = "backslash";
+  CharacterCodes2[CharacterCodes2["closeBrace"] = 125] = "closeBrace";
+  CharacterCodes2[CharacterCodes2["closeBracket"] = 93] = "closeBracket";
+  CharacterCodes2[CharacterCodes2["colon"] = 58] = "colon";
+  CharacterCodes2[CharacterCodes2["comma"] = 44] = "comma";
+  CharacterCodes2[CharacterCodes2["dot"] = 46] = "dot";
+  CharacterCodes2[CharacterCodes2["doubleQuote"] = 34] = "doubleQuote";
+  CharacterCodes2[CharacterCodes2["minus"] = 45] = "minus";
+  CharacterCodes2[CharacterCodes2["openBrace"] = 123] = "openBrace";
+  CharacterCodes2[CharacterCodes2["openBracket"] = 91] = "openBracket";
+  CharacterCodes2[CharacterCodes2["plus"] = 43] = "plus";
+  CharacterCodes2[CharacterCodes2["slash"] = 47] = "slash";
+  CharacterCodes2[CharacterCodes2["formFeed"] = 12] = "formFeed";
+  CharacterCodes2[CharacterCodes2["tab"] = 9] = "tab";
+})(CharacterCodes || (CharacterCodes = {}));
+
+// node_modules/.bun/jsonc-parser@3.3.1/node_modules/jsonc-parser/lib/esm/impl/string-intern.js
+var cachedSpaces = new Array(20).fill(0).map((_, index) => {
+  return " ".repeat(index);
+});
+var maxCachedValues = 200;
+var cachedBreakLinesWithSpaces = {
+  " ": {
+    "\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return `
+` + " ".repeat(index);
+    }),
+    "\r": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return "\r" + " ".repeat(index);
+    }),
+    "\r\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return `\r
+` + " ".repeat(index);
+    })
+  },
+  "\t": {
+    "\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return `
+` + "\t".repeat(index);
+    }),
+    "\r": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return "\r" + "\t".repeat(index);
+    }),
+    "\r\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return `\r
+` + "\t".repeat(index);
+    })
+  }
+};
+
+// node_modules/.bun/jsonc-parser@3.3.1/node_modules/jsonc-parser/lib/esm/impl/parser.js
+var ParseOptions;
+(function(ParseOptions2) {
+  ParseOptions2.DEFAULT = {
+    allowTrailingComma: false
+  };
+})(ParseOptions || (ParseOptions = {}));
+function parse(text, errors = [], options = ParseOptions.DEFAULT) {
+  let currentProperty = null;
+  let currentParent = [];
+  const previousParents = [];
+  function onValue(value) {
+    if (Array.isArray(currentParent)) {
+      currentParent.push(value);
+    } else if (currentProperty !== null) {
+      currentParent[currentProperty] = value;
+    }
+  }
+  const visitor = {
+    onObjectBegin: () => {
+      const object = {};
+      onValue(object);
+      previousParents.push(currentParent);
+      currentParent = object;
+      currentProperty = null;
+    },
+    onObjectProperty: (name) => {
+      currentProperty = name;
+    },
+    onObjectEnd: () => {
+      currentParent = previousParents.pop();
+    },
+    onArrayBegin: () => {
+      const array = [];
+      onValue(array);
+      previousParents.push(currentParent);
+      currentParent = array;
+      currentProperty = null;
+    },
+    onArrayEnd: () => {
+      currentParent = previousParents.pop();
+    },
+    onLiteralValue: onValue,
+    onError: (error, offset, length) => {
+      errors.push({ error, offset, length });
+    }
+  };
+  visit(text, visitor, options);
+  return currentParent[0];
+}
+function visit(text, visitor, options = ParseOptions.DEFAULT) {
+  const _scanner = createScanner(text, false);
+  const _jsonPath = [];
+  let suppressedCallbacks = 0;
+  function toNoArgVisit(visitFunction) {
+    return visitFunction ? () => suppressedCallbacks === 0 && visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : () => true;
+  }
+  function toOneArgVisit(visitFunction) {
+    return visitFunction ? (arg) => suppressedCallbacks === 0 && visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : () => true;
+  }
+  function toOneArgVisitWithPath(visitFunction) {
+    return visitFunction ? (arg) => suppressedCallbacks === 0 && visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), () => _jsonPath.slice()) : () => true;
+  }
+  function toBeginVisit(visitFunction) {
+    return visitFunction ? () => {
+      if (suppressedCallbacks > 0) {
+        suppressedCallbacks++;
+      } else {
+        let cbReturn = visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), () => _jsonPath.slice());
+        if (cbReturn === false) {
+          suppressedCallbacks = 1;
+        }
+      }
+    } : () => true;
+  }
+  function toEndVisit(visitFunction) {
+    return visitFunction ? () => {
+      if (suppressedCallbacks > 0) {
+        suppressedCallbacks--;
+      }
+      if (suppressedCallbacks === 0) {
+        visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter());
+      }
+    } : () => true;
+  }
+  const onObjectBegin = toBeginVisit(visitor.onObjectBegin), onObjectProperty = toOneArgVisitWithPath(visitor.onObjectProperty), onObjectEnd = toEndVisit(visitor.onObjectEnd), onArrayBegin = toBeginVisit(visitor.onArrayBegin), onArrayEnd = toEndVisit(visitor.onArrayEnd), onLiteralValue = toOneArgVisitWithPath(visitor.onLiteralValue), onSeparator = toOneArgVisit(visitor.onSeparator), onComment = toNoArgVisit(visitor.onComment), onError = toOneArgVisit(visitor.onError);
+  const disallowComments = options && options.disallowComments;
+  const allowTrailingComma = options && options.allowTrailingComma;
+  function scanNext() {
+    while (true) {
+      const token = _scanner.scan();
+      switch (_scanner.getTokenError()) {
+        case 4:
+          handleError(14);
+          break;
+        case 5:
+          handleError(15);
+          break;
+        case 3:
+          handleError(13);
+          break;
+        case 1:
+          if (!disallowComments) {
+            handleError(11);
+          }
+          break;
+        case 2:
+          handleError(12);
+          break;
+        case 6:
+          handleError(16);
+          break;
+      }
+      switch (token) {
+        case 12:
+        case 13:
+          if (disallowComments) {
+            handleError(10);
+          } else {
+            onComment();
+          }
+          break;
+        case 16:
+          handleError(1);
+          break;
+        case 15:
+        case 14:
+          break;
+        default:
+          return token;
+      }
+    }
+  }
+  function handleError(error, skipUntilAfter = [], skipUntil = []) {
+    onError(error);
+    if (skipUntilAfter.length + skipUntil.length > 0) {
+      let token = _scanner.getToken();
+      while (token !== 17) {
+        if (skipUntilAfter.indexOf(token) !== -1) {
+          scanNext();
+          break;
+        } else if (skipUntil.indexOf(token) !== -1) {
+          break;
+        }
+        token = scanNext();
+      }
+    }
+  }
+  function parseString(isValue) {
+    const value = _scanner.getTokenValue();
+    if (isValue) {
+      onLiteralValue(value);
+    } else {
+      onObjectProperty(value);
+      _jsonPath.push(value);
+    }
+    scanNext();
+    return true;
+  }
+  function parseLiteral() {
+    switch (_scanner.getToken()) {
+      case 11:
+        const tokenValue = _scanner.getTokenValue();
+        let value = Number(tokenValue);
+        if (isNaN(value)) {
+          handleError(2);
+          value = 0;
+        }
+        onLiteralValue(value);
+        break;
+      case 7:
+        onLiteralValue(null);
+        break;
+      case 8:
+        onLiteralValue(true);
+        break;
+      case 9:
+        onLiteralValue(false);
+        break;
+      default:
+        return false;
+    }
+    scanNext();
+    return true;
+  }
+  function parseProperty() {
+    if (_scanner.getToken() !== 10) {
+      handleError(3, [], [2, 5]);
+      return false;
+    }
+    parseString(false);
+    if (_scanner.getToken() === 6) {
+      onSeparator(":");
+      scanNext();
+      if (!parseValue()) {
+        handleError(4, [], [2, 5]);
+      }
+    } else {
+      handleError(5, [], [2, 5]);
+    }
+    _jsonPath.pop();
+    return true;
+  }
+  function parseObject() {
+    onObjectBegin();
+    scanNext();
+    let needsComma = false;
+    while (_scanner.getToken() !== 2 && _scanner.getToken() !== 17) {
+      if (_scanner.getToken() === 5) {
+        if (!needsComma) {
+          handleError(4, [], []);
+        }
+        onSeparator(",");
+        scanNext();
+        if (_scanner.getToken() === 2 && allowTrailingComma) {
+          break;
+        }
+      } else if (needsComma) {
+        handleError(6, [], []);
+      }
+      if (!parseProperty()) {
+        handleError(4, [], [2, 5]);
+      }
+      needsComma = true;
+    }
+    onObjectEnd();
+    if (_scanner.getToken() !== 2) {
+      handleError(7, [2], []);
+    } else {
+      scanNext();
+    }
+    return true;
+  }
+  function parseArray() {
+    onArrayBegin();
+    scanNext();
+    let isFirstElement = true;
+    let needsComma = false;
+    while (_scanner.getToken() !== 4 && _scanner.getToken() !== 17) {
+      if (_scanner.getToken() === 5) {
+        if (!needsComma) {
+          handleError(4, [], []);
+        }
+        onSeparator(",");
+        scanNext();
+        if (_scanner.getToken() === 4 && allowTrailingComma) {
+          break;
+        }
+      } else if (needsComma) {
+        handleError(6, [], []);
+      }
+      if (isFirstElement) {
+        _jsonPath.push(0);
+        isFirstElement = false;
+      } else {
+        _jsonPath[_jsonPath.length - 1]++;
+      }
+      if (!parseValue()) {
+        handleError(4, [], [4, 5]);
+      }
+      needsComma = true;
+    }
+    onArrayEnd();
+    if (!isFirstElement) {
+      _jsonPath.pop();
+    }
+    if (_scanner.getToken() !== 4) {
+      handleError(8, [4], []);
+    } else {
+      scanNext();
+    }
+    return true;
+  }
+  function parseValue() {
+    switch (_scanner.getToken()) {
+      case 3:
+        return parseArray();
+      case 1:
+        return parseObject();
+      case 10:
+        return parseString(true);
+      default:
+        return parseLiteral();
+    }
+  }
+  scanNext();
+  if (_scanner.getToken() === 17) {
+    if (options.allowEmptyContent) {
+      return true;
+    }
+    handleError(4, [], []);
+    return false;
+  }
+  if (!parseValue()) {
+    handleError(4, [], []);
+    return false;
+  }
+  if (_scanner.getToken() !== 17) {
+    handleError(9, [], []);
+  }
+  return true;
+}
+
+// node_modules/.bun/jsonc-parser@3.3.1/node_modules/jsonc-parser/lib/esm/main.js
+var ScanError;
+(function(ScanError2) {
+  ScanError2[ScanError2["None"] = 0] = "None";
+  ScanError2[ScanError2["UnexpectedEndOfComment"] = 1] = "UnexpectedEndOfComment";
+  ScanError2[ScanError2["UnexpectedEndOfString"] = 2] = "UnexpectedEndOfString";
+  ScanError2[ScanError2["UnexpectedEndOfNumber"] = 3] = "UnexpectedEndOfNumber";
+  ScanError2[ScanError2["InvalidUnicode"] = 4] = "InvalidUnicode";
+  ScanError2[ScanError2["InvalidEscapeCharacter"] = 5] = "InvalidEscapeCharacter";
+  ScanError2[ScanError2["InvalidCharacter"] = 6] = "InvalidCharacter";
+})(ScanError || (ScanError = {}));
+var SyntaxKind;
+(function(SyntaxKind2) {
+  SyntaxKind2[SyntaxKind2["OpenBraceToken"] = 1] = "OpenBraceToken";
+  SyntaxKind2[SyntaxKind2["CloseBraceToken"] = 2] = "CloseBraceToken";
+  SyntaxKind2[SyntaxKind2["OpenBracketToken"] = 3] = "OpenBracketToken";
+  SyntaxKind2[SyntaxKind2["CloseBracketToken"] = 4] = "CloseBracketToken";
+  SyntaxKind2[SyntaxKind2["CommaToken"] = 5] = "CommaToken";
+  SyntaxKind2[SyntaxKind2["ColonToken"] = 6] = "ColonToken";
+  SyntaxKind2[SyntaxKind2["NullKeyword"] = 7] = "NullKeyword";
+  SyntaxKind2[SyntaxKind2["TrueKeyword"] = 8] = "TrueKeyword";
+  SyntaxKind2[SyntaxKind2["FalseKeyword"] = 9] = "FalseKeyword";
+  SyntaxKind2[SyntaxKind2["StringLiteral"] = 10] = "StringLiteral";
+  SyntaxKind2[SyntaxKind2["NumericLiteral"] = 11] = "NumericLiteral";
+  SyntaxKind2[SyntaxKind2["LineCommentTrivia"] = 12] = "LineCommentTrivia";
+  SyntaxKind2[SyntaxKind2["BlockCommentTrivia"] = 13] = "BlockCommentTrivia";
+  SyntaxKind2[SyntaxKind2["LineBreakTrivia"] = 14] = "LineBreakTrivia";
+  SyntaxKind2[SyntaxKind2["Trivia"] = 15] = "Trivia";
+  SyntaxKind2[SyntaxKind2["Unknown"] = 16] = "Unknown";
+  SyntaxKind2[SyntaxKind2["EOF"] = 17] = "EOF";
+})(SyntaxKind || (SyntaxKind = {}));
+var parse2 = parse;
+var ParseErrorCode;
+(function(ParseErrorCode2) {
+  ParseErrorCode2[ParseErrorCode2["InvalidSymbol"] = 1] = "InvalidSymbol";
+  ParseErrorCode2[ParseErrorCode2["InvalidNumberFormat"] = 2] = "InvalidNumberFormat";
+  ParseErrorCode2[ParseErrorCode2["PropertyNameExpected"] = 3] = "PropertyNameExpected";
+  ParseErrorCode2[ParseErrorCode2["ValueExpected"] = 4] = "ValueExpected";
+  ParseErrorCode2[ParseErrorCode2["ColonExpected"] = 5] = "ColonExpected";
+  ParseErrorCode2[ParseErrorCode2["CommaExpected"] = 6] = "CommaExpected";
+  ParseErrorCode2[ParseErrorCode2["CloseBraceExpected"] = 7] = "CloseBraceExpected";
+  ParseErrorCode2[ParseErrorCode2["CloseBracketExpected"] = 8] = "CloseBracketExpected";
+  ParseErrorCode2[ParseErrorCode2["EndOfFileExpected"] = 9] = "EndOfFileExpected";
+  ParseErrorCode2[ParseErrorCode2["InvalidCommentToken"] = 10] = "InvalidCommentToken";
+  ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfComment"] = 11] = "UnexpectedEndOfComment";
+  ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfString"] = 12] = "UnexpectedEndOfString";
+  ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfNumber"] = 13] = "UnexpectedEndOfNumber";
+  ParseErrorCode2[ParseErrorCode2["InvalidUnicode"] = 14] = "InvalidUnicode";
+  ParseErrorCode2[ParseErrorCode2["InvalidEscapeCharacter"] = 15] = "InvalidEscapeCharacter";
+  ParseErrorCode2[ParseErrorCode2["InvalidCharacter"] = 16] = "InvalidCharacter";
+})(ParseErrorCode || (ParseErrorCode = {}));
+
+// src/lib/config.ts
+var DEFAULT_CONFIG = {
+  disabled_skills: [],
+  disabled_agents: [],
+  disabled_commands: [],
+  bootstrap: {
+    enabled: true
+  }
+};
+function loadJsoncFile(filePath) {
+  try {
+    if (!fs.existsSync(filePath))
+      return null;
+    const content = fs.readFileSync(filePath, "utf-8");
+    return parse2(content);
+  } catch {
+    return null;
+  }
+}
+function mergeArraysUnique(arr1, arr2) {
+  const set = new Set;
+  if (arr1)
+    for (const item of arr1)
+      set.add(item);
+  if (arr2)
+    for (const item of arr2)
+      set.add(item);
+  return Array.from(set);
+}
+function loadConfig(projectDir) {
+  const paths = getConfigPaths(projectDir);
+  const userConfig = loadJsoncFile(paths.userConfig);
+  const projectConfig = loadJsoncFile(paths.projectConfig);
+  const customConfig = paths.customConfig ? loadJsoncFile(paths.customConfig) : null;
+  const result = {
+    disabled_skills: mergeArraysUnique(mergeArraysUnique(mergeArraysUnique(DEFAULT_CONFIG.disabled_skills, userConfig?.disabled_skills), projectConfig?.disabled_skills), customConfig?.disabled_skills),
+    disabled_agents: mergeArraysUnique(mergeArraysUnique(mergeArraysUnique(DEFAULT_CONFIG.disabled_agents, userConfig?.disabled_agents), projectConfig?.disabled_agents), customConfig?.disabled_agents),
+    disabled_commands: mergeArraysUnique(mergeArraysUnique(mergeArraysUnique(DEFAULT_CONFIG.disabled_commands, userConfig?.disabled_commands), projectConfig?.disabled_commands), customConfig?.disabled_commands),
+    bootstrap: {
+      ...DEFAULT_CONFIG.bootstrap,
+      ...userConfig?.bootstrap,
+      ...projectConfig?.bootstrap,
+      ...customConfig?.bootstrap
+    }
+  };
+  return result;
+}
+function getConfigPaths(projectDir) {
+  const homeDir = os.homedir();
+  const customConfigDir = process.env.OPENCODE_CONFIG_DIR?.trim();
+  const result = {
+    userConfig: path.join(homeDir, ".config/opencode/systematic.json"),
+    projectConfig: path.join(projectDir, ".opencode/systematic.json"),
+    userDir: path.join(homeDir, ".config/opencode/systematic"),
+    projectDir: path.join(projectDir, ".opencode/systematic"),
+    ...customConfigDir && {
+      customConfig: path.join(customConfigDir, "systematic.json"),
+      customDir: path.join(customConfigDir, "systematic")
+    }
+  };
+  return result;
+}
+
+// src/lib/frontmatter.ts
+import yaml from "js-yaml";
+function parseFrontmatter(content) {
+  const frontmatterRegex = /^---\r?\n([\s\S]*?)\r?\n?---\r?\n([\s\S]*)$/;
+  const match = content.match(frontmatterRegex);
+  if (!match) {
+    return {
+      data: {},
+      body: content,
+      hadFrontmatter: false,
+      parseError: false
+    };
+  }
+  const yamlContent = match[1];
+  const body = match[2];
+  try {
+    const parsed = yaml.load(yamlContent, { schema: yaml.JSON_SCHEMA });
+    const data = parsed ?? {};
+    return { data, body, hadFrontmatter: true, parseError: false };
+  } catch {
+    return { data: {}, body, hadFrontmatter: true, parseError: true };
+  }
+}
+function formatFrontmatter(data) {
+  if (Object.keys(data).length === 0) {
+    return ["---", "---"].join(`
+`);
+  }
+  const yamlContent = yaml.dump(data, {
+    schema: yaml.JSON_SCHEMA,
+    lineWidth: -1,
+    noRefs: true
+  }).trimEnd();
+  return ["---", yamlContent, "---"].join(`
+`);
+}
+
+// src/lib/validation.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isPermissionSetting(value) {
+  return value === "ask" || value === "allow" || value === "deny";
+}
+function isToolsMap(value) {
+  if (!isRecord(value))
+    return false;
+  return Object.values(value).every((entry) => typeof entry === "boolean");
+}
+function isAgentMode(value) {
+  return value === "subagent" || value === "primary" || value === "all";
+}
+function extractSimplePermission(data, key) {
+  if (!(key in data))
+    return;
+  const value = data[key];
+  return isPermissionSetting(value) ? value : null;
+}
+function extractBashPermission(data) {
+  if (!("bash" in data))
+    return;
+  const bash = data.bash;
+  if (isPermissionSetting(bash))
+    return bash;
+  if (isRecord(bash)) {
+    const entries = Object.entries(bash);
+    if (entries.every(([, setting]) => isPermissionSetting(setting))) {
+      return Object.fromEntries(entries);
+    }
+  }
+  return null;
+}
+function buildPermissionObject(edit, bash, webfetch, doom_loop, external_directory, task, skill) {
+  const permission = {};
+  if (edit)
+    permission.edit = edit;
+  if (bash)
+    permission.bash = bash;
+  if (webfetch)
+    permission.webfetch = webfetch;
+  if (doom_loop)
+    permission.doom_loop = doom_loop;
+  if (external_directory)
+    permission.external_directory = external_directory;
+  if (task)
+    permission.task = task;
+  if (skill)
+    permission.skill = skill;
+  return Object.keys(permission).length > 0 ? permission : undefined;
+}
+function normalizePermission(value) {
+  if (!isRecord(value))
+    return;
+  const bash = extractBashPermission(value);
+  if (bash === null)
+    return;
+  const edit = extractSimplePermission(value, "edit");
+  if (edit === null)
+    return;
+  const webfetch = extractSimplePermission(value, "webfetch");
+  if (webfetch === null)
+    return;
+  const doom_loop = extractSimplePermission(value, "doom_loop");
+  if (doom_loop === null)
+    return;
+  const external_directory = extractSimplePermission(value, "external_directory");
+  if (external_directory === null)
+    return;
+  const task = extractSimplePermission(value, "task");
+  if (task === null)
+    return;
+  const skill = extractSimplePermission(value, "skill");
+  if (skill === null)
+    return;
+  return buildPermissionObject(edit, bash, webfetch, doom_loop, external_directory, task, skill);
+}
+function extractString(data, key, fallback = "") {
+  const value = data[key];
+  return typeof value === "string" ? value : fallback;
+}
+function extractNonEmptyString(data, key) {
+  const value = data[key];
+  if (typeof value !== "string")
+    return;
+  const trimmed = value.trim();
+  return trimmed !== "" ? trimmed : undefined;
+}
+function extractNumber(data, key) {
+  const value = data[key];
+  return typeof value === "number" ? value : undefined;
+}
+function extractBoolean(data, key) {
+  const value = data[key];
+  if (typeof value === "boolean")
+    return value;
+  if (typeof value === "string") {
+    const normalized = value.trim().toLowerCase();
+    if (normalized === "true")
+      return true;
+    if (normalized === "false")
+      return false;
+  }
+  return;
+}
+
+// src/lib/walk-dir.ts
+import fs2 from "fs";
+import path2 from "path";
+function walkDir(rootDir, options = {}) {
+  const { maxDepth = 3, filter } = options;
+  const results = [];
+  if (!fs2.existsSync(rootDir))
+    return results;
+  function recurse(currentDir, depth, category) {
+    if (depth > maxDepth)
+      return;
+    const entries = fs2.readdirSync(currentDir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path2.join(currentDir, entry.name);
+      const walkEntry = {
+        path: fullPath,
+        name: entry.name,
+        isDirectory: entry.isDirectory(),
+        depth,
+        category
+      };
+      if (!filter || filter(walkEntry)) {
+        results.push(walkEntry);
+      }
+      if (entry.isDirectory()) {
+        recurse(fullPath, depth + 1, entry.name);
+      }
+    }
+  }
+  recurse(rootDir, 0);
+  return results;
+}
+
+// src/lib/agents.ts
+function findAgentsInDir(dir, maxDepth = 2) {
+  const entries = walkDir(dir, {
+    maxDepth,
+    filter: (e) => !e.isDirectory && e.name.endsWith(".md")
+  });
+  return entries.map((entry) => ({
+    name: entry.name.replace(/\.md$/, ""),
+    file: entry.path,
+    category: entry.category
+  }));
+}
+function extractAgentFrontmatter(content) {
+  const { data, parseError, body } = parseFrontmatter(content);
+  if (parseError) {
+    return { name: "", description: "", prompt: body.trim() };
+  }
+  return {
+    name: extractString(data, "name"),
+    description: extractString(data, "description"),
+    prompt: body.trim(),
+    model: extractNonEmptyString(data, "model"),
+    temperature: extractNumber(data, "temperature"),
+    top_p: extractNumber(data, "top_p"),
+    tools: isToolsMap(data.tools) ? data.tools : undefined,
+    disable: extractBoolean(data, "disable"),
+    mode: isAgentMode(data.mode) ? data.mode : undefined,
+    color: extractNonEmptyString(data, "color"),
+    steps: extractNumber(data, "steps"),
+    hidden: extractBoolean(data, "hidden") ?? undefined,
+    permission: normalizePermission(data.permission)
+  };
+}
+
+// src/lib/commands.ts
+function findCommandsInDir(dir, maxDepth = 2) {
+  const entries = walkDir(dir, {
+    maxDepth,
+    filter: (e) => !e.isDirectory && e.name.endsWith(".md")
+  });
+  return entries.map((entry) => {
+    const baseName = entry.name.replace(/\.md$/, "");
+    const commandName = entry.category ? `/${entry.category}:${baseName}` : `/${baseName}`;
+    return {
+      name: commandName,
+      file: entry.path,
+      category: entry.category
+    };
+  });
+}
+function extractCommandFrontmatter(content) {
+  const { data, parseError } = parseFrontmatter(content);
+  if (parseError) {
+    return {
+      name: "",
+      description: "",
+      argumentHint: "",
+      agent: undefined,
+      model: undefined,
+      subtask: undefined
+    };
+  }
+  const argumentHintRaw = extractString(data, "argument-hint");
+  return {
+    name: extractString(data, "name"),
+    description: extractString(data, "description"),
+    argumentHint: argumentHintRaw.replace(/^["']|["']$/g, ""),
+    agent: extractNonEmptyString(data, "agent"),
+    model: extractNonEmptyString(data, "model"),
+    subtask: extractBoolean(data, "subtask")
+  };
+}
+
+// src/lib/converter.ts
+import fs3 from "fs";
+var CONVERTER_VERSION = 2;
+var cache = new Map;
+var TOOL_MAPPINGS = [
+  [/\bTask\s+tool\b/gi, "task tool"],
+  [/\bTask\s+([\w-]+)\s*:/g, "task $1:"],
+  [/\bTask\s+([\w-]+)\s*\(/g, "task $1("],
+  [/\bTask\s*\(/g, "task("],
+  [/\bTask\b(?=\s+to\s+\w)/g, "task"],
+  [/\bTodoWrite\b/g, "todowrite"],
+  [/\bAskUserQuestion\b/g, "question"],
+  [/\bWebSearch\b/g, "google_search"],
+  [/\bRead\b(?=\s+tool|\s+to\s+|\()/g, "read"],
+  [/\bWrite\b(?=\s+tool|\s+to\s+|\()/g, "write"],
+  [/\bEdit\b(?=\s+tool|\s+to\s+|\()/g, "edit"],
+  [/\bBash\b(?=\s+tool|\s+to\s+|\()/g, "bash"],
+  [/\bGrep\b(?=\s+tool|\s+to\s+|\()/g, "grep"],
+  [/\bGlob\b(?=\s+tool|\s+to\s+|\()/g, "glob"],
+  [/\bWebFetch\b/g, "webfetch"],
+  [/\bSkill\b(?=\s+tool|\s*\()/g, "skill"]
+];
+var PATH_REPLACEMENTS = [
+  [/\.claude\/skills\//g, ".opencode/skills/"],
+  [/\.claude\/commands\//g, ".opencode/commands/"],
+  [/\.claude\/agents\//g, ".opencode/agents/"],
+  [/~\/\.claude\//g, "~/.config/opencode/"],
+  [/CLAUDE\.md/g, "AGENTS.md"],
+  [/\/compound-engineering:/g, "/systematic:"],
+  [/compound-engineering:/g, "systematic:"]
+];
+var TOOL_NAME_MAP = {
+  task: "task",
+  todowrite: "todowrite",
+  askuserquestion: "question",
+  websearch: "google_search",
+  webfetch: "webfetch",
+  skill: "skill",
+  read: "read",
+  write: "write",
+  edit: "edit",
+  bash: "bash",
+  grep: "grep",
+  glob: "glob"
+};
+var PERMISSION_MODE_MAP = {
+  full: {
+    edit: "allow",
+    bash: "allow",
+    webfetch: "allow"
+  },
+  default: {
+    edit: "ask",
+    bash: "ask",
+    webfetch: "ask"
+  },
+  plan: {
+    edit: "deny",
+    bash: "deny",
+    webfetch: "ask"
+  },
+  bypassPermissions: {
+    edit: "allow",
+    bash: "allow",
+    webfetch: "allow"
+  }
+};
+function inferTemperature(name, description) {
+  const sample = `${name} ${description ?? ""}`.toLowerCase();
+  if (/(review|audit|security|sentinel|oracle|lint|verification|guardian)/.test(sample)) {
+    return 0.1;
+  }
+  if (/(plan|planning|architecture|strategist|analysis|research)/.test(sample)) {
+    return 0.2;
+  }
+  if (/(doc|readme|changelog|editor|writer)/.test(sample)) {
+    return 0.3;
+  }
+  if (/(brainstorm|creative|ideate|design|concept)/.test(sample)) {
+    return 0.6;
+  }
+  return 0.3;
+}
+var CODE_BLOCK_PATTERN = /```[\s\S]*?```|`[^`\n]+`/g;
+function transformBody(body) {
+  const codeBlocks = [];
+  let placeholderIndex = 0;
+  const withPlaceholders = body.replace(CODE_BLOCK_PATTERN, (match) => {
+    codeBlocks.push(match);
+    return `__CODE_BLOCK_${placeholderIndex++}__`;
+  });
+  let result = withPlaceholders;
+  for (const [pattern, replacement] of TOOL_MAPPINGS) {
+    result = result.replace(pattern, replacement);
+  }
+  for (const [pattern, replacement] of PATH_REPLACEMENTS) {
+    result = result.replace(pattern, replacement);
+  }
+  for (let i = 0;i < codeBlocks.length; i++) {
+    result = result.replace(`__CODE_BLOCK_${i}__`, codeBlocks[i]);
+  }
+  return result;
+}
+function normalizeModel(model) {
+  if (model.includes("/"))
+    return model;
+  if (model === "inherit")
+    return model;
+  if (/^claude-/.test(model))
+    return `anthropic/${model}`;
+  if (/^(gpt-|o1-|o3-)/.test(model))
+    return `openai/${model}`;
+  if (/^gemini-/.test(model))
+    return `google/${model}`;
+  return `anthropic/${model}`;
+}
+function canonicalizeToolName(name) {
+  const lower = name.trim().toLowerCase();
+  return TOOL_NAME_MAP[lower] ?? lower;
+}
+function isValidSteps(value) {
+  return typeof value === "number" && Number.isFinite(value) && Number.isInteger(value) && value > 0;
+}
+function mapStepsField(data) {
+  if (data.steps !== undefined) {
+    if (isValidSteps(data.steps)) {
+      delete data.maxTurns;
+      delete data.maxSteps;
+    }
+    return;
+  }
+  const candidates = [];
+  if (isValidSteps(data.maxTurns))
+    candidates.push(data.maxTurns);
+  if (isValidSteps(data.maxSteps))
+    candidates.push(data.maxSteps);
+  if (candidates.length > 0) {
+    data.steps = Math.min(...candidates);
+    delete data.maxTurns;
+    delete data.maxSteps;
+  }
+}
+function mapToolsField(data) {
+  if (data.tools !== undefined && !Array.isArray(data.tools)) {
+    if (isToolsMap(data.tools)) {
+      mergeDisallowedTools(data);
+    }
+    return;
+  }
+  if (Array.isArray(data.tools)) {
+    const toolsMap = {};
+    for (const tool of data.tools) {
+      if (typeof tool === "string") {
+        toolsMap[canonicalizeToolName(tool)] = true;
+      }
+    }
+    if (Object.keys(toolsMap).length > 0) {
+      data.tools = toolsMap;
+    } else {
+      delete data.tools;
+    }
+  }
+  mergeDisallowedTools(data);
+}
+function mergeDisallowedTools(data) {
+  if (!Array.isArray(data.disallowedTools))
+    return;
+  const existing = isToolsMap(data.tools) ? data.tools : {};
+  for (const tool of data.disallowedTools) {
+    if (typeof tool === "string") {
+      existing[canonicalizeToolName(tool)] = false;
+    }
+  }
+  if (Object.keys(existing).length > 0) {
+    data.tools = existing;
+  }
+  delete data.disallowedTools;
+}
+function mapPermissionMode(data) {
+  if (data.permission !== undefined) {
+    const normalized = normalizePermission(data.permission);
+    if (normalized) {
+      data.permission = normalized;
+      delete data.permissionMode;
+      return;
+    }
+  }
+  if (typeof data.permissionMode !== "string")
+    return;
+  const mapped = PERMISSION_MODE_MAP[data.permissionMode];
+  data.permission = mapped ?? { edit: "ask", bash: "ask", webfetch: "ask" };
+  delete data.permissionMode;
+}
+function mapHiddenField(data) {
+  if (data["disable-model-invocation"] === true || data.disableModelInvocation === true) {
+    data.hidden = true;
+    delete data["disable-model-invocation"];
+    delete data.disableModelInvocation;
+  }
+}
+function normalizeModelField(data) {
+  if (typeof data.model === "string" && data.model !== "inherit") {
+    data.model = normalizeModel(data.model);
+  } else if (data.model === "inherit") {
+    delete data.model;
+  }
+}
+function transformAgentFrontmatter(data, agentMode) {
+  const result = { ...data };
+  result.mode = isAgentMode(data.mode) ? data.mode : agentMode;
+  const name = typeof data.name === "string" ? data.name : "";
+  const description = typeof data.description === "string" ? data.description : "";
+  if (description) {
+    result.description = description;
+  } else if (name) {
+    result.description = `${name} agent`;
+  }
+  normalizeModelField(result);
+  result.temperature = typeof data.temperature === "number" ? data.temperature : inferTemperature(name, description);
+  mapStepsField(result);
+  mapToolsField(result);
+  mapPermissionMode(result);
+  mapHiddenField(result);
+  return result;
+}
+function transformSkillFrontmatter(data) {
+  const result = { ...data };
+  normalizeModelField(result);
+  if (result.context === "fork") {
+    result.subtask = true;
+  }
+  return result;
+}
+function transformCommandFrontmatter(data) {
+  const result = { ...data };
+  normalizeModelField(result);
+  return result;
+}
+function convertContent(content, type, options = {}) {
+  if (content === "")
+    return "";
+  const { data, body, hadFrontmatter, parseError } = parseFrontmatter(content);
+  if (!hadFrontmatter) {
+    return options.skipBodyTransform ? content : transformBody(content);
+  }
+  if (parseError) {
+    return options.skipBodyTransform ? content : transformBody(content);
+  }
+  const shouldTransformBody = !options.skipBodyTransform;
+  const transformedBody = shouldTransformBody ? transformBody(body) : body;
+  if (type === "agent") {
+    const agentMode = options.agentMode ?? "subagent";
+    const transformedData = transformAgentFrontmatter(data, agentMode);
+    return `${formatFrontmatter(transformedData)}
+${transformedBody}`;
+  }
+  if (type === "skill") {
+    const transformedData = transformSkillFrontmatter(data);
+    return `${formatFrontmatter(transformedData)}
+${transformedBody}`;
+  }
+  if (type === "command") {
+    const transformedData = transformCommandFrontmatter(data);
+    return `${formatFrontmatter(transformedData)}
+${transformedBody}`;
+  }
+  return content;
+}
+function convertFileWithCache(filePath, type, options = {}) {
+  const fd = fs3.openSync(filePath, "r");
+  try {
+    const stats = fs3.fstatSync(fd);
+    const cacheKey = `${CONVERTER_VERSION}:${filePath}:${type}:${options.source ?? "bundled"}:${options.agentMode ?? "subagent"}:${options.skipBodyTransform ?? false}`;
+    const cached = cache.get(cacheKey);
+    if (cached != null && cached.mtimeMs === stats.mtimeMs) {
+      return cached.converted;
+    }
+    const content = fs3.readFileSync(fd, "utf8");
+    const converted = convertContent(content, type, options);
+    cache.set(cacheKey, { mtimeMs: stats.mtimeMs, converted });
+    return converted;
+  } finally {
+    fs3.closeSync(fd);
+  }
+}
+
+// src/lib/skills.ts
+import fs4 from "fs";
+import path3 from "path";
+function extractFrontmatter(filePath) {
+  try {
+    const content = fs4.readFileSync(filePath, "utf8");
+    const { data, parseError } = parseFrontmatter(content);
+    if (parseError) {
+      return { name: "", description: "" };
+    }
+    const metadataRaw = data.metadata;
+    let metadata;
+    if (isRecord(metadataRaw)) {
+      const entries = Object.entries(metadataRaw);
+      if (entries.every(([, v]) => typeof v === "string")) {
+        metadata = Object.fromEntries(entries);
+      }
+    }
+    const argumentHintRaw = extractNonEmptyString(data, "argument-hint");
+    const argumentHint = argumentHintRaw?.replace(/^["']|["']$/g, "") || undefined;
+    return {
+      name: extractString(data, "name"),
+      description: extractString(data, "description"),
+      license: extractNonEmptyString(data, "license"),
+      compatibility: extractNonEmptyString(data, "compatibility"),
+      metadata,
+      disableModelInvocation: extractBoolean(data, "disable-model-invocation"),
+      userInvocable: extractBoolean(data, "user-invocable"),
+      subtask: data.context === "fork" ? true : undefined,
+      agent: extractNonEmptyString(data, "agent"),
+      model: extractNonEmptyString(data, "model"),
+      argumentHint: argumentHint !== "" ? argumentHint : undefined,
+      allowedTools: extractNonEmptyString(data, "allowed-tools")
+    };
+  } catch {
+    return { name: "", description: "" };
+  }
+}
+function findSkillsInDir(dir, maxDepth = 3) {
+  const skills = [];
+  const entries = walkDir(dir, {
+    maxDepth,
+    filter: (e) => e.isDirectory
+  });
+  for (const entry of entries) {
+    const skillFile = path3.join(entry.path, "SKILL.md");
+    if (fs4.existsSync(skillFile)) {
+      const frontmatter = extractFrontmatter(skillFile);
+      skills.push({
+        path: entry.path,
+        skillFile,
+        name: frontmatter.name || entry.name,
+        description: frontmatter.description || "",
+        license: frontmatter.license,
+        compatibility: frontmatter.compatibility,
+        metadata: frontmatter.metadata,
+        disableModelInvocation: frontmatter.disableModelInvocation,
+        userInvocable: frontmatter.userInvocable,
+        subtask: frontmatter.subtask,
+        agent: frontmatter.agent,
+        model: frontmatter.model,
+        argumentHint: frontmatter.argumentHint,
+        allowedTools: frontmatter.allowedTools
+      });
+    }
+  }
+  return skills;
+}
+
+export { parseFrontmatter, loadConfig, getConfigPaths, findAgentsInDir, extractAgentFrontmatter, findCommandsInDir, extractCommandFrontmatter, convertContent, convertFileWithCache, findSkillsInDir };