llmz 0.0.2

package/dist/chunk-ENFB45AI.cjs

@@ -0,0 +1,220 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+
+
+
+
+
+var _chunk3CGLDS5Tcjs = require('./chunk-3CGLDS5T.cjs');
+
+// src/utils.ts
+var _thicktoken = require('@bpinternal/thicktoken');
+var _zui = require('@bpinternal/zui');
+var tokenizer = null;
+var init = async () => {
+  if (tokenizer) {
+    return;
+  }
+  while (typeof _thicktoken.getWasmTokenizer !== "function") {
+    await new Promise((resolve) => setTimeout(resolve, 50));
+  }
+  tokenizer = await _thicktoken.getWasmTokenizer.call(void 0, );
+};
+var getTokenizer = () => {
+  if (!tokenizer) {
+    throw new Error("Tokenizer not initialized, make sure to call init() first and await it");
+  }
+  return tokenizer;
+};
+var Tokens = (min, max) => {
+  return _zui.z.string().superRefine((value, ctx) => {
+    const tokens = tokenizer.count(value);
+    if (value.length < min) {
+      ctx.addIssue({
+        code: "too_small",
+        minimum: min,
+        type: "string",
+        message: `Text is ${tokens} but expected at least ${min} tokens`,
+        inclusive: true
+      });
+    }
+    if (value.length > max) {
+      ctx.addIssue({
+        code: "too_big",
+        maximum: max,
+        type: "string",
+        message: `Text is ${tokens} tokens but expected at most ${max} tokens`,
+        inclusive: true
+      });
+    }
+    return value;
+  });
+};
+var Identifier = _zui.z.string().min(1).max(100).regex(
+  /^([a-zA-Z_][a-zA-Z0-9_]*)$/,
+  "Identifiers must start with a letter and can only contain letters, numbers and underscores"
+);
+function escapeString(str) {
+  if (typeof str !== "string") {
+    return "";
+  }
+  const rawStr = String.raw`${str}`;
+  const escapedStr = rawStr.replace(/\\/g, "\\\\").replace(/\n/g, "\\n").replace(/"/g, '\\"').replace(/'/g, "\\'");
+  if (escapedStr.includes("`")) {
+    return `"${escapedStr}"`;
+  } else if (escapedStr.includes("'")) {
+    return `"${escapedStr}"`;
+  } else {
+    return `'${escapedStr}'`;
+  }
+}
+var toPropertyKey = (key) => {
+  if (/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key)) {
+    return key;
+  }
+  return escapeString(key);
+};
+var trimEmptyLines = (lines) => {
+  var _a;
+  while (lines.length && !((_a = lines[0]) == null ? void 0 : _a.trim())) {
+    lines.shift();
+  }
+  while (lines.length && !lines[lines.length - 1].trim()) {
+    lines.pop();
+  }
+};
+var getMultilineComment = (description) => {
+  description = description == null ? void 0 : description.replace(/(\n(\s*)?){3,}/g, "\n\n");
+  const ensureLineStartsWithAsterisk = (line) => line.startsWith("* ") ? ` ${line}` : ` * ${line}`;
+  const escapeCommentEnd = (line) => line.replace(/\*\//g, "*\\/");
+  const descLines = (_nullishCoalesce(description, () => ( ""))).split("\n").map((line) => line.trim());
+  trimEmptyLines(descLines);
+  if (descLines.length) {
+    descLines[0] = descLines[0].replace(/^\/\*\*?/, "");
+    descLines[descLines.length - 1] = descLines[descLines.length - 1].replace(/\*\/$/, "");
+  }
+  trimEmptyLines(descLines);
+  return descLines.length === 0 ? "" : descLines.length === 1 ? `/** ${escapeCommentEnd(descLines[0])} */` : `/**
+${descLines.map(ensureLineStartsWithAsterisk).map(escapeCommentEnd).join("\n")}
+ */`;
+};
+var toValidFunctionName = (str) => {
+  let name = _chunk3CGLDS5Tcjs.deburr_default.call(void 0, str);
+  name = name.replace(/[^a-zA-Z0-9_$]/g, "");
+  if (!/^[a-zA-Z_$]/.test(name)) {
+    name = `_${name}`;
+  }
+  return _chunk3CGLDS5Tcjs.camelCase_default.call(void 0, name);
+};
+var awaitObject = async (obj) => {
+  const newObj = { ...obj };
+  const promises = [];
+  const setProp = async (key, value) => {
+    newObj[key] = await value;
+  };
+  for (const [key, value] of Object.entries(obj)) {
+    if (value instanceof Promise) {
+      promises.push(setProp(key, value));
+    } else if (_chunk3CGLDS5Tcjs.isPlainObject_default.call(void 0, value)) {
+      promises.push(setProp(key, await awaitObject(value)));
+    }
+  }
+  await Promise.all(promises);
+  return newObj;
+};
+var toValidObjectName = (str) => {
+  let name = _chunk3CGLDS5Tcjs.deburr_default.call(void 0, str);
+  name = name.split(/[^a-zA-Z0-9_$]/g).map(_chunk3CGLDS5Tcjs.startCase_default).join("");
+  if (!/^[a-zA-Z_$]/.test(name)) {
+    name = `_${name}`;
+  }
+  return name.replaceAll(" ", "");
+};
+var stripInvalidIdentifiers = (object) => {
+  if (typeof object !== "object") {
+    return object;
+  }
+  if (Array.isArray(object)) {
+    return object.map(stripInvalidIdentifiers);
+  }
+  return _chunk3CGLDS5Tcjs.pickBy_default.call(void 0, object, (__, key) => Identifier.safeParse(key).success);
+};
+var convertObjectToZuiLiterals = (obj, nested = false) => {
+  if (typeof obj === "string") {
+    return _zui.z.literal(obj).catch(() => obj);
+  }
+  if (typeof obj === "number") {
+    return _zui.z.literal(obj).catch(() => obj);
+  }
+  if (typeof obj === "boolean") {
+    return _zui.z.literal(obj).catch(() => obj);
+  }
+  if (Array.isArray(obj)) {
+    if (obj.length === 0) {
+      return _zui.z.tuple([]).catch(() => obj);
+    }
+    return _zui.z.tuple([
+      // the tuple needs to have at least one element
+      convertObjectToZuiLiterals(obj[0]),
+      ...obj.slice(1).map((child) => convertObjectToZuiLiterals(child))
+    ]).catch(() => obj);
+  }
+  if (obj !== null && typeof obj === "object") {
+    const shape = {};
+    for (const key in obj) {
+      shape[key] = convertObjectToZuiLiterals(obj[key], true);
+    }
+    if (nested) {
+      return _zui.z.object(shape).catch(() => shape);
+    }
+    return shape;
+  }
+  if (obj === void 0) {
+    return _zui.z.undefined().catch(() => void 0);
+  }
+  if (obj === null) {
+    return _zui.z.null().catch(() => null);
+  }
+  throw new Error(`Unsupported object type ${typeof obj}, ${obj})`);
+};
+var isValidSchema = (schema) => {
+  try {
+    _zui.z.fromJsonSchema(schema);
+    return typeof schema.type === "string";
+  } catch (e) {
+    return false;
+  }
+};
+function isJsonSchema(schema) {
+  return !!schema && typeof schema === "object" && ("$schema" in schema || "type" in schema || "properties" in schema);
+}
+function isValidIdentifier(name) {
+  if (typeof name !== "string") {
+    return false;
+  }
+  return /^[A-Z]{1,}[A-Z0-9_]{0,50}$/i.test(name);
+}
+function isValidMessageName(name) {
+  if (typeof name !== "string") {
+    return false;
+  }
+  return /^[A-Z]{1,50}$/i.test(name);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.init = init; exports.getTokenizer = getTokenizer; exports.Tokens = Tokens; exports.Identifier = Identifier; exports.escapeString = escapeString; exports.toPropertyKey = toPropertyKey; exports.getMultilineComment = getMultilineComment; exports.toValidFunctionName = toValidFunctionName; exports.awaitObject = awaitObject; exports.toValidObjectName = toValidObjectName; exports.stripInvalidIdentifiers = stripInvalidIdentifiers; exports.convertObjectToZuiLiterals = convertObjectToZuiLiterals; exports.isValidSchema = isValidSchema; exports.isJsonSchema = isJsonSchema; exports.isValidIdentifier = isValidIdentifier; exports.isValidMessageName = isValidMessageName;

package/dist/chunk-MSTBEKOQ.js

@@ -0,0 +1,28 @@
+// src/stack-traces.ts
+var isInternalLine = (line) => {
+  return line.includes("llmz/src/") || line.includes("\\llmz\\src\\") || line.includes("node_modules");
+};
+function cleanStackTrace(stack, cleanInternal = true) {
+  const lines = stack.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    let llmzIndex = line.indexOf("llmz/src/");
+    if (llmzIndex === -1) {
+      llmzIndex = line.indexOf("\\llmz\\src\\");
+    }
+    if (llmzIndex === -1) {
+      continue;
+    }
+    let lastSpaceIndex = line.lastIndexOf(" ", llmzIndex);
+    if (lastSpaceIndex === -1) {
+      lastSpaceIndex = 0;
+    }
+    const maybeParen = line[lastSpaceIndex + 1] === "(" ? "(" : "";
+    lines[i] = line.slice(0, lastSpaceIndex + 1) + maybeParen + line.slice(llmzIndex);
+  }
+  return lines.filter((x) => !cleanInternal || !isInternalLine(x)).join("\n");
+}
+
+export {
+  cleanStackTrace
+};

package/dist/chunk-PQN6HW7A.cjs

@@ -0,0 +1,28 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/stack-traces.ts
+var isInternalLine = (line) => {
+  return line.includes("llmz/src/") || line.includes("\\llmz\\src\\") || line.includes("node_modules");
+};
+function cleanStackTrace(stack, cleanInternal = true) {
+  const lines = stack.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    let llmzIndex = line.indexOf("llmz/src/");
+    if (llmzIndex === -1) {
+      llmzIndex = line.indexOf("\\llmz\\src\\");
+    }
+    if (llmzIndex === -1) {
+      continue;
+    }
+    let lastSpaceIndex = line.lastIndexOf(" ", llmzIndex);
+    if (lastSpaceIndex === -1) {
+      lastSpaceIndex = 0;
+    }
+    const maybeParen = line[lastSpaceIndex + 1] === "(" ? "(" : "";
+    lines[i] = line.slice(0, lastSpaceIndex + 1) + maybeParen + line.slice(llmzIndex);
+  }
+  return lines.filter((x) => !cleanInternal || !isInternalLine(x)).join("\n");
+}
+
+
+
+exports.cleanStackTrace = cleanStackTrace;

package/dist/chunk-Q4DEJGXD.js

@@ -0,0 +1,344 @@
+import {
+  escapeString,
+  getTokenizer
+} from "./chunk-DFZ6GX5C.js";
+import {
+  chain_default,
+  countBy_default,
+  filter_default,
+  isEmpty_default,
+  isEqual_default,
+  isNil_default,
+  mapKeys_default,
+  orderBy_default,
+  uniqWith_default,
+  uniq_default
+} from "./chunk-7S3UY52U.js";
+
+// src/inspect.ts
+import bytes from "bytes";
+var SUBTITLE_LN = "--------------";
+var SECTION_SEP = "\n";
+var NUMBER_LOCALE = new Intl.NumberFormat("en-US");
+var LONG_TEXT_LENGTH = 4096;
+var DEFAULT_OPTIONS = {
+  tokens: 1e5
+};
+function printLimitedJson(obj, maxDepth, maxLength, maxKeys) {
+  const indent = 2;
+  let currentLength = 0;
+  let wasTruncated = false;
+  function recurse(currentObj, depth, currentIndent) {
+    if (depth > maxDepth || currentLength >= maxLength) {
+      wasTruncated = true;
+      return "...";
+    }
+    if (typeof currentObj === "object" && currentObj instanceof Date) {
+      currentIndent += 3;
+      try {
+        return currentObj.toISOString();
+      } catch (err) {
+        return `<Date: ${(err == null ? void 0 : err.message) ?? "Invalid Date"}>`;
+      }
+    }
+    if (typeof currentObj !== "object" || currentObj === null) {
+      const value = JSON.stringify(currentObj);
+      currentLength += getTokenizer().count(value);
+      return value;
+    }
+    const indentation = " ".repeat(currentIndent);
+    if (Array.isArray(currentObj)) {
+      let result = "[\n";
+      for (let i = 0; i < currentObj.length && currentLength < maxLength; i++) {
+        if (i > 0) {
+          result += ",\n";
+        }
+        result += indentation + " ".repeat(indent) + recurse(currentObj[i], depth + 1, currentIndent + indent);
+      }
+      result += "\n" + indentation + "]";
+      currentLength += getTokenizer().count(result);
+      return result;
+    } else {
+      let result = "{\n";
+      const keys = Object.keys(currentObj);
+      const numKeys = keys.length;
+      for (let i = 0; i < Math.min(numKeys, maxKeys) && currentLength < maxLength; i++) {
+        const key = keys[i];
+        if (i > 0) {
+          result += ",\n";
+        }
+        const value = recurse(currentObj[key], depth + 1, currentIndent + indent);
+        result += indentation + " ".repeat(indent) + `"${key}": ${value}`;
+      }
+      if (numKeys > maxKeys) {
+        wasTruncated = true;
+        result += ",\n" + indentation + `... (${numKeys - maxKeys} more keys)`;
+      }
+      result += "\n" + indentation + "}";
+      currentLength += getTokenizer().count(result);
+      return result;
+    }
+  }
+  const output = getTokenizer().truncate(recurse(obj, 0, 0), maxLength);
+  return { output, truncated: wasTruncated };
+}
+function extractType(value, generic = true) {
+  if (value === null) {
+    return "null";
+  }
+  if (value === void 0 || typeof value === "undefined") {
+    return "undefined";
+  }
+  if (typeof value === "object" && Array.isArray(value)) {
+    if (!generic) {
+      return "Array";
+    }
+    if (value.length === 0) {
+      return "Array (empty)";
+    }
+    if (value.length === 1) {
+      return `Array<${extractType(value[0])}>`;
+    }
+    const types = /* @__PURE__ */ new Map();
+    for (const element of value) {
+      const type = extractType(element, false);
+      types.set(type, (types.get(type) || 0) + 1);
+    }
+    if (types.size <= 3) {
+      return `Array<${Array.from(types.keys()).join(" | ")}>`;
+    }
+    return "Array";
+  }
+  if (typeof value === "number") {
+    return "number";
+  }
+  if (typeof value === "boolean") {
+    return "boolean";
+  }
+  if (typeof value === "bigint") {
+    return "bigint";
+  }
+  if (typeof value === "function") {
+    return "function";
+  }
+  if (typeof value === "object" && value instanceof Date) {
+    return "date";
+  }
+  if (typeof value === "object" && value instanceof RegExp) {
+    return "regexp";
+  }
+  if (value instanceof Error) {
+    return "error";
+  }
+  if (typeof value === "string" && value.trim().length === 0) {
+    return "<empty string>";
+  }
+  return typeof value;
+}
+function previewValue(value, length = LONG_TEXT_LENGTH) {
+  if (value === null) {
+    return "<nil>";
+  }
+  if (value === void 0) {
+    return "<undefined>";
+  }
+  const previewStr = (str) => {
+    if (str.length > length) {
+      return escapeString(str.slice(0, length)) + " ... <truncated>";
+    }
+    return escapeString(str);
+  };
+  const previewObj = (obj) => {
+    const mapped = mapKeys_default(obj, (_value, key) => previewStr(key));
+    return JSON.stringify(mapped);
+  };
+  if (typeof value === "string") {
+    return "<string> " + previewStr(value);
+  }
+  if (typeof value === "object" && Array.isArray(value)) {
+    return "<array> " + previewStr(JSON.stringify(value));
+  }
+  if (typeof value === "object" && value instanceof Date) {
+    return "<date> " + value.toISOString();
+  }
+  if (typeof value === "object" && value instanceof RegExp) {
+    return "<regexp> " + value.toString();
+  }
+  if (typeof value === "object") {
+    return "<object> " + previewObj(value);
+  }
+  if (typeof value === "bigint") {
+    return "<bigint> " + value.toString();
+  }
+  if (typeof value === "function") {
+    return "<function> " + value.toString();
+  }
+  if (typeof value === "boolean") {
+    return "<boolean> " + value.toString();
+  }
+  if (value instanceof Error) {
+    return "<error> " + previewError(value);
+  }
+  if (typeof value === "number") {
+    return "<number> " + value.toString();
+  }
+  if (typeof value === "symbol") {
+    return "<symbol> " + value.toString();
+  }
+  return `${typeof value} ` + ((value == null ? void 0 : value.toString()) ?? "<unknown>");
+}
+function previewError(err) {
+  const lines = [];
+  lines.push("Error: " + err.name);
+  lines.push(SUBTITLE_LN);
+  lines.push(previewValue(err.message));
+  lines.push(SECTION_SEP);
+  lines.push("Stack Trace:");
+  lines.push(SUBTITLE_LN);
+  lines.push(previewValue(err.stack ?? "<no stack trace>"));
+  return lines.join("\n");
+}
+function previewArray(arr) {
+  if (!Array.isArray(arr)) {
+    throw new Error("Expected an array");
+  }
+  const lines = [];
+  const getItemPreview = (value, index) => `[${index}]`.padEnd(15) + `  ${previewValue(value)}`;
+  if (arr.length === 0) {
+    lines.push("// Array Is Empty (0 element)");
+    return lines.join("\n").replace(/\n{2,}/g, SECTION_SEP);
+  }
+  if (arr.length <= 10) {
+    lines.push("// Full Array Preview");
+    lines.push(SUBTITLE_LN);
+    lines.push(...arr.map(getItemPreview));
+    return lines.join("\n").replace(/\n{2,}/g, SECTION_SEP);
+  }
+  lines.push("// Analysis Summary");
+  lines.push(SUBTITLE_LN);
+  const typesCount = countBy_default(arr, (item) => extractType(item, false));
+  const ordered = orderBy_default(
+    arr.filter((item) => !isNil_default(item) && JSON.stringify(item).length < 100),
+    (item) => JSON.stringify(item),
+    "asc"
+  );
+  const minValues = ordered.slice(0, 3).map((item) => previewValue(item, 10));
+  const maxValues = ordered.slice(-3).map((item) => previewValue(item, 10));
+  const uniqueItems = uniqWith_default(arr, isEqual_default);
+  const nullValues = filter_default(arr, isNil_default).length;
+  const memoryUsage = bytes(JSON.stringify(arr).length);
+  lines.push(`Total Items:     ${arr.length}`);
+  lines.push(`Unique Items:    ${uniqueItems.length}`);
+  lines.push(`Types:           ${JSON.stringify(typesCount)}`);
+  lines.push(`Minimum Values:  [${minValues.join(", ")}]`);
+  lines.push(`Maximum Values:  [${maxValues.join(", ")}]`);
+  lines.push(`Memory Usage:    ${memoryUsage}`);
+  lines.push(`Nil Values:      ${nullValues}`);
+  lines.push("// Array Preview (truncated)");
+  lines.push(SUBTITLE_LN);
+  lines.push(...arr.map(getItemPreview));
+  return lines.join("\n").replace(/\n{2,}/g, SECTION_SEP);
+}
+function previewObject(obj, options) {
+  if (typeof obj !== "object" || Array.isArray(obj) || obj === null) {
+    throw new Error("Expected an object");
+  }
+  const lines = [];
+  const { output, truncated } = printLimitedJson(obj, 10, options.tokens, 20);
+  if (truncated) {
+    lines.push(SECTION_SEP);
+    lines.push("// Analysis Summary");
+    lines.push(SUBTITLE_LN);
+    const entries = Object.entries(obj);
+    const typesCount = chain_default(entries).countBy(([, value]) => extractType(value, false)).entries().orderBy(1, "desc").filter(([, count]) => count > 1).slice(0, 3).fromPairs().value();
+    const keys = Object.keys(obj);
+    const uniqueEntries = uniq_default(Object.values(obj));
+    const nilValues = filter_default(entries, ([, value]) => isNil_default(value)).length;
+    const memoryUsage = bytes(JSON.stringify(obj).length);
+    lines.push(`Total Entries:   ${NUMBER_LOCALE.format(entries.length)}`);
+    lines.push(`Keys:            ${previewValue(keys)}`);
+    lines.push(`Popular Types:   ${previewValue(typesCount)}`);
+    lines.push(`Unique Values:   ${NUMBER_LOCALE.format(uniqueEntries.length)}`);
+    lines.push(`Nil Values:      ${NUMBER_LOCALE.format(nilValues)}`);
+    lines.push(`Memory Usage:    ${memoryUsage}`);
+  }
+  if (isEmpty_default(obj)) {
+    lines.push("// Empty Object {}");
+  } else {
+    lines.push(truncated ? "// Object Preview (truncated)" : "// Full Object Preview");
+    lines.push(SUBTITLE_LN);
+    lines.push(output);
+  }
+  return lines.join("\n").replace(/\n{2,}/g, SECTION_SEP);
+}
+function previewLongText(text, length = LONG_TEXT_LENGTH) {
+  const lines = [];
+  const urlPattern = /https?:\/\/[^\s]+/g;
+  const emailPattern = /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g;
+  lines.push("// The string is too long to fully display, here is a preview:");
+  const previewStr = (str) => {
+    if (str.length > length) {
+      return str.slice(0, length) + " ... <truncated>";
+    }
+    return str;
+  };
+  lines.push(previewStr(text));
+  lines.push(SUBTITLE_LN);
+  lines.push("// Analysis Summary");
+  lines.push(SUBTITLE_LN);
+  const words = text.split(/\s+/);
+  const wordCount = words.length;
+  const uniqueWords = uniq_default(words).length;
+  const wordFrequency = countBy_default(words);
+  const mostCommonWords = chain_default(wordFrequency).toPairs().orderBy(1, "desc").filter(([, count]) => count > 1).take(20).map(([word, count]) => `"${word}" ${count} times`).value().join("\n" + " ".repeat(22));
+  const urls = text.match(urlPattern) || [];
+  const emails = text.match(emailPattern) || [];
+  if (urls.length > 0) {
+    lines.push(`Found URLs:           ${urls.length}`);
+    lines.push(`URLs:                ${urls.join(", ")}`);
+  }
+  if (emails.length > 0) {
+    lines.push(`Found Emails:         ${emails.length}`);
+    lines.push(`Emails:              ${emails.join(", ")}`);
+  }
+  lines.push(`Length:               ${NUMBER_LOCALE.format(text.length)} chars`);
+  lines.push(`Word Count:           ${NUMBER_LOCALE.format(wordCount)} words`);
+  lines.push(`Unique Words:         ${NUMBER_LOCALE.format(uniqueWords)}`);
+  lines.push(`Most Common Words:    ${mostCommonWords}`);
+  return lines.join("\n").replace(/\n{2,}/g, SECTION_SEP);
+}
+var inspect = (value, name, options = DEFAULT_OPTIONS) => {
+  options ??= DEFAULT_OPTIONS;
+  options.tokens ??= DEFAULT_OPTIONS.tokens;
+  try {
+    const genericType = extractType(value, false);
+    let header = "";
+    if (name) {
+      header = `// const ${name}: ${genericType}
+`;
+    }
+    if (genericType === "Array") {
+      return header + previewArray(value);
+    } else if (genericType === "error") {
+      return header + previewError(value);
+    } else if (genericType === "object") {
+      return header + previewObject(value, options);
+    } else if (genericType === "boolean") {
+      return header + previewValue(value);
+    } else if (typeof value === "string") {
+      if (getTokenizer().count(value) < options.tokens) {
+        return header + previewValue(value);
+      } else {
+        return header + previewLongText(value);
+      }
+    }
+    return header + previewValue(value);
+  } catch (err) {
+    return `Error: ${(err == null ? void 0 : err.message) ?? "Unknown Error"}`;
+  }
+};
+
+export {
+  extractType,
+  inspect
+};