llmz 0.2.1 → 0.2.3

package/dist/index.d.ts

@@ -22,6 +22,8 @@ export type { ExecutionProps, ExecutionHooks } from './runtime/types.js';
 export { type ValueOrGetter, getValue } from './getter.js';
 export * from './message-stream/index.js';
 export * from './custom-client.js';
+export { configureQuickJS } from './quickjs-variant.js';
+export { configureTokenizer } from './utils.js';
 export declare const utils: {
     toValidObjectName: (str: string) => string;
     toValidFunctionName: (str: string) => string;

package/dist/index.js

@@ -10,21 +10,28 @@ import {
   _CustomModelClient,
   getValue,
   parseExit
-} from "./chunk-ZWUWCRHG.js";
+} from "./chunk-XMFQVARN.js";
 import {
   MARKER,
   NAME_REGEX,
   StreamingMessageParser,
   generateInstructions,
   tryParseJson
-} from "./chunk-E5NHK3FS.js";
+} from "./chunk-OXEKAOVI.js";
+import {
+  configureQuickJS
+} from "./chunk-UGHFNCPD.js";
 import {
   Tool
-} from "./chunk-GC5IQDGV.js";
+} from "./chunk-TDALRNGL.js";
 import {
   formatTypings,
-  getTypings
-} from "./chunk-665O7CAN.js";
+  getTypings,
+  isGroup,
+  isPunct,
+  parse,
+  tokenize
+} from "./chunk-GDJTKI7J.js";
 import {
   CodeFormattingError,
   LoopExceededError,
@@ -34,7 +41,7 @@ import {
 import "./chunk-YEAWWJSJ.js";
 import {
   Exit
-} from "./chunk-XVVYNOTX.js";
+} from "./chunk-HB2G32AK.js";
 import {
   Component,
   assertValidComponent,
@@ -46,8 +53,9 @@ import {
   stripTruncationTags,
   truncateWrappedContent,
   wrapContent
-} from "./chunk-HM5H556L.js";
+} from "./chunk-72ZWBNZV.js";
 import {
+  configureTokenizer,
   escapeString,
   getMultilineComment,
   isJsonSchema,
@@ -55,238 +63,193 @@ import {
   isZuiSchema,
   toValidFunctionName,
   toValidObjectName
-} from "./chunk-YX27XM67.js";
+} from "./chunk-GLXADNTR.js";
 import {
-  cloneDeep_default,
   upperFirst_default
 } from "./chunk-34GJUS6U.js";
 
 // package.json
-var version = "0.2.1";
+var version = "0.2.3";
 
 // src/objects.ts
 import { z } from "@bpinternal/zui";
 
 // src/hoist.ts
-import { CodeGenerator } from "@babel/generator";
-import { parse } from "@babel/parser";
-import Traverse from "@babel/traverse";
-import * as t from "@babel/types";
-var traverse = Traverse;
-function getTypingsWithoutComments(type) {
-  const typeClone = cloneDeep_default(type);
-  removeBabelComments(typeClone);
-  return new CodeGenerator(typeClone, { comments: false }).generate().code;
+function printNodes(nodes) {
+  let out = "";
+  let afterLineComment = false;
+  const emit = (n) => {
+    const newlines = Math.min(n.nl ?? 0, 2);
+    if (newlines > 0) {
+      out += "\n".repeat(newlines);
+    } else if (afterLineComment) {
+      out += "\n";
+    } else if (out.length && !out.endsWith("\n")) {
+      out += " ";
+    }
+    afterLineComment = false;
+    if (isGroup(n)) {
+      out += n.open;
+      for (const child of n.children) {
+        emit(child);
+      }
+      if (afterLineComment) {
+        out += "\n";
+        afterLineComment = false;
+      }
+      out += n.close;
+    } else {
+      out += n.text;
+      afterLineComment = n.kind === "line-comment";
+    }
+  };
+  for (const n of nodes) {
+    emit(n);
+  }
+  return out;
 }
-function removeBabelComments(node) {
-  node.leadingComments = null;
-  node.trailingComments = null;
-  node.innerComments = null;
-  Object.keys(node).forEach((key) => {
-    const val = node[key];
-    if (Array.isArray(val)) {
-      val.forEach((child) => child && typeof child === "object" && removeBabelComments(child));
-    } else if (val && typeof val === "object" && val.type) {
-      removeBabelComments(val);
+function keyOf(group) {
+  const parts = [];
+  const visit = (n) => {
+    if (isGroup(n)) {
+      parts.push(n.open);
+      n.children.forEach(visit);
+      parts.push(n.close);
+    } else if (n.kind === "word" || n.kind === "string" || n.kind === "punct" && n.text !== ";" && n.text !== ",") {
+      parts.push(n.text);
     }
-  });
+  };
+  visit(group);
+  return parts.join(" ");
 }
-function extractAndHoistTypes(ast) {
-  const typeMap = /* @__PURE__ */ new Map();
-  const typeCounts = /* @__PURE__ */ new Map();
-  const hoistedTypes = [];
-  function addTypeToMap(typeNode) {
-    const typeString = getTypingsWithoutComments(typeNode.typeAnnotation);
-    if (!typeMap.has(typeString)) {
-      typeMap.set(typeString, typeNode);
+var prevMeaningful = (siblings, index) => {
+  for (let i = index - 1; i >= 0; i--) {
+    const n = siblings[i];
+    if (isGroup(n) || n.kind !== "block-comment" && n.kind !== "line-comment") {
+      return n;
     }
   }
-  function generateUniqueTypeName(baseName) {
-    let typeName = baseName;
-    let counter = 1;
-    while ([...typeMap.values()].some((typeNode) => typeNode.id.name === typeName)) {
-      typeName = `${baseName}${counter++}`;
-    }
-    return typeName;
-  }
-  function createTypeAlias(name, type) {
-    return t.tsTypeAliasDeclaration(t.identifier(name), null, type);
-  }
-  function getTypePaths(path) {
-    var _a, _b, _c;
-    let currPath = path;
-    const parts = /* @__PURE__ */ new Set();
-    while (currPath) {
-      const { node, parentPath } = currPath;
-      if (t.isIdentifier(node) && node.name) {
-        parts.add(node.name);
-      }
-      if (t.isTSMethodSignature(node) && currPath.key === "parameters") {
-        parts.add("Input");
-      }
-      if (currPath.key === "returnType") {
-        parts.add("Output");
-        const methodName = "id" in parentPath.node && "name" in parentPath.node.id && ((_b = (_a = parentPath == null ? void 0 : parentPath.node) == null ? void 0 : _a.id) == null ? void 0 : _b.name);
-        if (methodName) {
-          parts.add(methodName);
-        }
-      }
-      if (((_c = node == null ? void 0 : node.key) == null ? void 0 : _c.type) === "Identifier") {
-        parts.add(node.key.name);
-      }
-      if (t.isTSParameterProperty(node) || t.isTSFunctionType(node)) {
-        parts.add("Input");
-      }
-      if (t.isTSFunctionType(node)) {
-        parts.add("Output");
-      }
-      currPath = parentPath;
+  return void 0;
+};
+var asName = (text) => upperFirst_default(text.replace(/['"]/g, "").replace(/[^A-Za-z0-9_$]/g, ""));
+function segmentsAt(siblings, index) {
+  var _a;
+  const prev = prevMeaningful(siblings, index);
+  if (!prev || isGroup(prev)) {
+    return [];
+  }
+  if (isPunct(prev, "=>")) {
+    return ["Output"];
+  }
+  if (isPunct(prev, ":") || isPunct(prev, "<")) {
+    let i = siblings.indexOf(prev) - 1;
+    while (i >= 0 && !isGroup(siblings[i]) && ((_a = siblings[i].kind) == null ? void 0 : _a.includes("comment"))) {
+      i--;
     }
-    return parts.size ? Array.from(parts).reverse().map(upperFirst_default) : ["UnnamedType"];
-  }
-  function generateTypeName(path) {
-    return getTypePaths(path).join("");
-  }
-  function findNestedTypes(path) {
-    const node = path.node;
-    if (t.isTSTypeLiteral(node)) {
-      const typeString = getTypingsWithoutComments(node);
-      typeCounts.set(typeString, (typeCounts.get(typeString) || 0) + 1);
-      if (typeMap.has(typeString) && (typeCounts.get(typeString) || 0) > 1) {
-        path.replaceWith(t.tsTypeReference(typeMap.get(typeString).id));
-      } else if (!typeMap.has(typeString) && (typeCounts.get(typeString) || 0) > 1) {
-        const typeName = generateUniqueTypeName(generateTypeName(path));
-        const typeAlias = createTypeAlias(typeName, node);
-        addTypeToMap(typeAlias);
-        path.replaceWith(t.tsTypeReference(t.identifier(typeName)));
-      }
-      const members = path.get("members");
-      const memberPaths = Array.isArray(members) ? members : [members];
-      memberPaths.forEach((memberPath) => {
-        findNestedTypes(memberPath);
-      });
+    let q = siblings[i];
+    if (q && !isGroup(q) && q.kind === "punct" && q.text === "?") {
+      q = siblings[--i];
     }
-    if (t.isTSPropertySignature(node) && path.get("typeAnnotation")) {
-      const annPath = path.get("typeAnnotation.typeAnnotation");
-      if (annPath == null ? void 0 : annPath.node) {
-        findNestedTypes(annPath);
-      }
+    if (q && isGroup(q) && q.open === "(") {
+      const fnWord = prevMeaningful(siblings, i);
+      return fnWord && !isGroup(fnWord) && fnWord.kind === "word" ? [asName(fnWord.text), "Output"] : ["Output"];
     }
-    if (t.isTSArrayType(node)) {
-      findNestedTypes(path.get("elementType"));
+    if (q && !isGroup(q) && (q.kind === "word" || q.kind === "string")) {
+      return [asName(q.text)];
     }
-    if (t.isTSUnionType(node) || t.isTSIntersectionType(node)) {
-      ;
-      path.get("types").forEach((p) => findNestedTypes(p));
+  }
+  return [];
+}
+function walkLiterals(siblings, path, visit) {
+  var _a;
+  for (let i = 0; i < siblings.length; i++) {
+    const node = siblings[i];
+    if (!isGroup(node)) {
+      continue;
     }
-    if (t.isTSTypeReference(node) && node.typeParameters) {
-      ;
-      path.get("typeParameters.params").forEach((param) => findNestedTypes(param));
+    if (node.open === "(") {
+      const fnWord = prevMeaningful(siblings, i);
+      const fnName = fnWord && !isGroup(fnWord) && fnWord.kind === "word" ? [asName(fnWord.text)] : [];
+      walkLiterals(node.children, [...path, ...fnName], visit);
+      continue;
     }
-    if (t.isTSFunctionType(node)) {
-      const returnPath = path.get("typeAnnotation");
-      if (returnPath == null ? void 0 : returnPath.node)
-        findNestedTypes(returnPath);
-      const params = path.get("parameters");
-      params.forEach((paramPath) => {
-        const ta = paramPath.get("typeAnnotation.typeAnnotation");
-        if (ta == null ? void 0 : ta.node)
-          findNestedTypes(ta);
-      });
+    if (node.open === "<" || node.open === "[") {
+      walkLiterals(node.children, [...path, ...segmentsAt(siblings, i)], visit);
+      continue;
     }
-    if (t.isTSMethodSignature(node)) {
-      const returnPath = path.get("typeAnnotation");
-      if (returnPath == null ? void 0 : returnPath.node) {
-        findNestedTypes(returnPath);
+    const prev = prevMeaningful(siblings, i);
+    if (prev && isPunct(prev, "=")) {
+      const eqIdx = siblings.indexOf(prev);
+      const nameTok = siblings[eqIdx - 1];
+      const typeTok = siblings[eqIdx - 2];
+      const isAlias = nameTok && typeTok && !isGroup(nameTok) && !isGroup(typeTok) && nameTok.kind === "word" && typeTok.kind === "word" && typeTok.text === "type";
+      if (!isAlias) {
+        continue;
+      }
+      const aliasName = nameTok.text;
+      visit({ siblings, index: i, group: node, path: [aliasName], aliasName });
+      if (siblings[i] === node) {
+        walkLiterals(node.children, [aliasName], visit);
       }
-      const params = path.get("parameters");
-      params.forEach((paramPath) => {
-        const ta = paramPath.get("typeAnnotation.typeAnnotation");
-        if (ta == null ? void 0 : ta.node)
-          findNestedTypes(ta);
-      });
+      continue;
     }
-    if (t.isTSDeclareFunction(node)) {
-      const params = path.get("params");
-      params.forEach((p) => {
-        const ta = p.get("typeAnnotation.typeAnnotation");
-        if (ta == null ? void 0 : ta.node)
-          findNestedTypes(ta);
-      });
-      const returnType = path.get("returnType.typeAnnotation");
-      if (returnType == null ? void 0 : returnType.node)
-        findNestedTypes(returnType);
+    const prevIsNamespace = prev && !isGroup(prev) && prev.kind === "word" && ((_a = prevMeaningful(siblings, siblings.indexOf(prev))) == null ? void 0 : _a.kind) === "word";
+    const namespaceLike = prevIsNamespace && ["namespace", "module"].includes(prevMeaningful(siblings, siblings.indexOf(prev)).text);
+    const segments = segmentsAt(siblings, i);
+    const newPath = [...path, ...segments];
+    if (!namespaceLike) {
+      visit({ siblings, index: i, group: node, path: newPath });
+    }
+    if (siblings[i] === node) {
+      walkLiterals(node.children, namespaceLike ? [...path, asName(prev.text)] : newPath, visit);
     }
   }
-  traverse(ast, {
-    TSTypeAliasDeclaration(path) {
-      const typeString = getTypingsWithoutComments(path.node.typeAnnotation);
-      typeCounts.set(typeString, (typeCounts.get(typeString) || 0) + 1);
-      if (typeMap.has(typeString) && (typeCounts.get(typeString) || 0) > 1) {
-        const existing = typeMap.get(typeString);
-        path.replaceWith(
-          t.tsTypeAliasDeclaration(path.node.id, null, t.tsTypeReference(t.identifier(existing.id.name)))
-        );
-      } else {
-        addTypeToMap(path.node);
-      }
-    },
-    TSPropertySignature(path) {
-      const annPath = path.get("typeAnnotation.typeAnnotation");
-      if (annPath == null ? void 0 : annPath.node)
-        findNestedTypes(annPath);
-    },
-    TSFunctionType(path) {
-      const returnPath = path.get("typeAnnotation");
-      if (returnPath.node)
-        findNestedTypes(returnPath);
-      const params = path.get("parameters");
-      params.forEach((param) => {
-        const ta = param.get("typeAnnotation.typeAnnotation");
-        if (ta == null ? void 0 : ta.node)
-          findNestedTypes(ta);
-      });
-    },
-    TSMethodSignature(path) {
-      const returnPath = path.get("typeAnnotation.typeAnnotation");
-      if (returnPath == null ? void 0 : returnPath.node) {
-        findNestedTypes(returnPath);
-      }
-      const params = path.get("parameters");
-      params.forEach((param) => {
-        const ta = param.get("typeAnnotation.typeAnnotation");
-        if (ta == null ? void 0 : ta.node)
-          findNestedTypes(ta);
-      });
-    },
-    TSDeclareFunction(path) {
-      const params = path.get("params");
-      params.forEach((p) => {
-        const ta = p.get("typeAnnotation.typeAnnotation");
-        if (ta == null ? void 0 : ta.node)
-          findNestedTypes(ta);
-      });
-      const returnPath = path.get("returnType.typeAnnotation");
-      if (returnPath == null ? void 0 : returnPath.node)
-        findNestedTypes(returnPath);
+}
+function extractAndHoistTypes(code) {
+  const top = parse(tokenize(code));
+  const counts = /* @__PURE__ */ new Map();
+  const aliasByKey = /* @__PURE__ */ new Map();
+  const usedNames = /* @__PURE__ */ new Set();
+  walkLiterals(top, [], ({ group, path, aliasName }) => {
+    const key = keyOf(group);
+    counts.set(key, (counts.get(key) ?? 0) + 1);
+    if (aliasName && !aliasByKey.has(key)) {
+      aliasByKey.set(key, aliasName);
+    }
+    for (const segment of path) {
+      usedNames.add(segment);
+    }
+    if (aliasName) {
+      usedNames.add(aliasName);
     }
   });
-  typeMap.forEach((typeNode, typeString) => {
-    if ((typeCounts.get(typeString) || 0) > 1) {
-      if (!hoistedTypes.some((ht) => {
-        return getTypingsWithoutComments(ht.typeAnnotation) === getTypingsWithoutComments(typeNode.typeAnnotation);
-      })) {
-        hoistedTypes.push(typeNode);
-      }
+  const uniqueName = (base) => {
+    let name = base;
+    let counter = 1;
+    while (usedNames.has(name)) {
+      name = `${base}${counter++}`;
+    }
+    usedNames.add(name);
+    return name;
+  };
+  const newAliases = [];
+  walkLiterals(top, [], ({ siblings, index, group, aliasName, path }) => {
+    const key = keyOf(group);
+    if ((counts.get(key) ?? 0) < 2 || aliasName) {
+      return;
+    }
+    let name = aliasByKey.get(key);
+    if (!name) {
+      const deduped = [...new Set(path)];
+      name = uniqueName(deduped.length ? deduped.join("") : "UnnamedType");
+      aliasByKey.set(key, name);
+      newAliases.push(`type ${name} = ${printNodes([{ ...group, nl: 0 }])}`);
     }
+    siblings[index] = { kind: "word", text: name, nl: group.nl };
   });
-  ast.program.body = [
-    ...hoistedTypes,
-    ...ast.program.body.filter(
-      (node) => !hoistedTypes.some((ht) => t.isTSTypeAliasDeclaration(node) && node.id.name === ht.id.name)
-    )
-  ];
-  return ast;
+  const body = printNodes(top);
+  return newAliases.length ? `${newAliases.join("\n")}
+${body}` : body;
 }
 async function hoistTypings(code, formatOptions) {
   formatOptions ??= {};
@@ -294,15 +257,7 @@ async function hoistTypings(code, formatOptions) {
   for (let i = 1; i <= 5; i++) {
     try {
       const initialCode = code;
-      const ast = parse(code, {
-        sourceType: "module",
-        plugins: ["typescript"]
-      });
-      const transformedAst = extractAndHoistTypes(ast);
-      code = new CodeGenerator(transformedAst, {
-        // quotes: 'single',
-        compact: false
-      }).generate().code;
+      code = extractAndHoistTypes(code);
       if (initialCode === code) {
         break;
       }
@@ -1572,20 +1527,20 @@ var utils = {
   stripTruncationTags
 };
 var execute = async (props) => {
-  const { executeContext } = await import("./execute-LNUBLVMZ.js");
+  const { executeContext } = await import("./execute-DSGJ2UNL.js");
   return executeContext(props);
 };
 var init = async () => {
-  await import("./execute-LNUBLVMZ.js");
+  await import("./execute-DSGJ2UNL.js");
   await import("./component-ASNZHQUR.js");
-  await import("./tool-HTAYKIA2.js");
-  await import("./exit-VJATJTQI.js");
+  await import("./tool-KD7FL45V.js");
+  await import("./exit-UQ3EUX5D.js");
   await import("./jsx-DDZ63UUF.js");
-  await import("./vm-44H4UKI2.js");
-  await import("./utils-ZEZ66X6Q.js");
-  await import("./truncator-OZOBNYON.js");
-  await import("./typings-SCKZCAPN.js");
-  await import("./dual-modes-RMF7V7ZQ.js");
+  await import("./vm-QO5FSGPN.js");
+  await import("./utils-IATCUNKF.js");
+  await import("./truncator-73RCL52Y.js");
+  await import("./typings-E2RROCLT.js");
+  await import("./dual-modes-BYABHBDI.js");
 };
 export {
   BaseResponse,
@@ -1618,6 +1573,8 @@ export {
   _CustomModelClient,
   assertValidComponent,
   collectText,
+  configureQuickJS,
+  configureTokenizer,
   execute,
   generateInstructions,
   getValue,