llmz 0.0.30 → 0.0.31

package/dist/{chunk-R3LXNE5N.cjs → chunk-CA7FRCZT.cjs}

@@ -2101,6 +2101,207 @@ var JSXMarkdown = {
   }
 };
 
+// src/compiler/plugins/html-to-markdown.ts
+var _core = require('@babel/core');
+function htmlToMarkdownPlugin() {
+  return {
+    name: "html-to-markdown",
+    visitor: {
+      JSXElement(path) {
+        const { openingElement } = path.node;
+        const tagName = _core.types.isJSXIdentifier(openingElement.name) ? openingElement.name.name : null;
+        if (!tagName)
+          return;
+        const lowerTagName = tagName.toLowerCase();
+        if (lowerTagName === "strong" || lowerTagName === "b") {
+          convertToMarkdown(path, "**", "**");
+        } else if (lowerTagName === "em" || lowerTagName === "i") {
+          convertToMarkdown(path, "*", "*");
+        } else if (lowerTagName === "u") {
+          convertToMarkdown(path, "__", "__");
+        } else if (lowerTagName === "a") {
+          convertLinkToMarkdown(path);
+        } else if (lowerTagName === "br") {
+          convertBrToNewline(path);
+        } else if (lowerTagName === "p") {
+          convertParagraphToMarkdown(path);
+        } else if (lowerTagName === "ul") {
+          convertUnorderedListToMarkdown(path);
+        } else if (lowerTagName === "ol") {
+          convertOrderedListToMarkdown(path);
+        }
+      }
+    }
+  };
+}
+function hasOnlyTextChildren(children) {
+  return children.every(
+    (child) => _core.types.isJSXText(child) || _core.types.isJSXExpressionContainer(child) && !_core.types.isJSXElement(child.expression) || _core.types.isJSXElement(child) && canConvertToMarkdown(child)
+  );
+}
+function canConvertToMarkdown(element) {
+  const { openingElement } = element;
+  const tagName = _core.types.isJSXIdentifier(openingElement.name) ? openingElement.name.name.toLowerCase() : null;
+  if (!tagName)
+    return false;
+  const allowedTags = ["strong", "b", "em", "i", "u", "br", "p", "a", "li", "ul", "ol"];
+  if (!allowedTags.includes(tagName))
+    return false;
+  if (tagName === "a") {
+    return openingElement.attributes.length === 1 && _core.types.isJSXAttribute(openingElement.attributes[0]) && _core.types.isJSXIdentifier(openingElement.attributes[0].name) && openingElement.attributes[0].name.name === "href";
+  }
+  if (tagName === "br") {
+    return openingElement.attributes.length === 0;
+  }
+  return openingElement.attributes.length === 0;
+}
+function convertToMarkdown(path, prefix, suffix) {
+  const element = path.node;
+  if (!canConvertToMarkdown(element))
+    return;
+  const children = element.children;
+  if (!hasOnlyTextChildren(children))
+    return;
+  const textContent = extractTextContent(children);
+  if (!textContent)
+    return;
+  const markdownText = `${prefix}${textContent}${suffix}`;
+  path.replaceWith(_core.types.jsxText(markdownText));
+}
+function convertLinkToMarkdown(path) {
+  const element = path.node;
+  if (!canConvertToMarkdown(element))
+    return;
+  const children = element.children;
+  if (!hasOnlyTextChildren(children))
+    return;
+  const hrefAttr = element.openingElement.attributes.find(
+    (attr) => _core.types.isJSXAttribute(attr) && _core.types.isJSXIdentifier(attr.name) && attr.name.name === "href"
+  );
+  if (!hrefAttr || !_core.types.isJSXAttribute(hrefAttr))
+    return;
+  let href = "";
+  if (_core.types.isStringLiteral(hrefAttr.value)) {
+    href = hrefAttr.value.value;
+  } else if (_core.types.isJSXExpressionContainer(hrefAttr.value) && _core.types.isStringLiteral(hrefAttr.value.expression)) {
+    href = hrefAttr.value.expression.value;
+  } else {
+    return;
+  }
+  const textContent = extractTextContent(children);
+  if (!textContent)
+    return;
+  const markdownText = `[${textContent}](${href})`;
+  path.replaceWith(_core.types.jsxText(markdownText));
+}
+function convertBrToNewline(path) {
+  const element = path.node;
+  if (!canConvertToMarkdown(element))
+    return;
+  path.replaceWith(_core.types.jsxText("\n"));
+}
+function convertParagraphToMarkdown(path) {
+  const element = path.node;
+  if (!canConvertToMarkdown(element))
+    return;
+  const children = element.children;
+  if (!hasOnlyTextChildren(children))
+    return;
+  const textContent = extractTextContent(children);
+  if (!textContent)
+    return;
+  const markdownText = `${textContent}
+
+`;
+  path.replaceWith(_core.types.jsxText(markdownText));
+}
+function convertUnorderedListToMarkdown(path) {
+  const element = path.node;
+  if (element.openingElement.attributes.length > 0)
+    return;
+  const children = element.children;
+  const listItems = [];
+  for (const child of children) {
+    if (_core.types.isJSXElement(child)) {
+      const tagName = _core.types.isJSXIdentifier(child.openingElement.name) ? child.openingElement.name.name : null;
+      if ((tagName == null ? void 0 : tagName.toLowerCase()) === "li" && canConvertToMarkdown(child)) {
+        const itemText = extractTextContent(child.children);
+        if (itemText) {
+          listItems.push(`- ${itemText}`);
+        }
+      } else {
+        return;
+      }
+    } else if (_core.types.isJSXText(child) && child.value.trim()) {
+      return;
+    }
+  }
+  if (listItems.length === 0)
+    return;
+  const markdownText = listItems.join("\n") + "\n";
+  path.replaceWith(_core.types.jsxText(markdownText));
+}
+function convertOrderedListToMarkdown(path) {
+  const element = path.node;
+  if (element.openingElement.attributes.length > 0)
+    return;
+  const children = element.children;
+  const listItems = [];
+  for (const child of children) {
+    if (_core.types.isJSXElement(child)) {
+      const tagName = _core.types.isJSXIdentifier(child.openingElement.name) ? child.openingElement.name.name : null;
+      if ((tagName == null ? void 0 : tagName.toLowerCase()) === "li" && canConvertToMarkdown(child)) {
+        const itemText = extractTextContent(child.children);
+        if (itemText) {
+          listItems.push(`${listItems.length + 1}. ${itemText}`);
+        }
+      } else {
+        return;
+      }
+    } else if (_core.types.isJSXText(child) && child.value.trim()) {
+      return;
+    }
+  }
+  if (listItems.length === 0)
+    return;
+  const markdownText = listItems.join("\n") + "\n";
+  path.replaceWith(_core.types.jsxText(markdownText));
+}
+function extractTextContent(children) {
+  let text = "";
+  for (const child of children) {
+    if (_core.types.isJSXText(child)) {
+      text += child.value;
+    } else if (_core.types.isJSXExpressionContainer(child)) {
+      return "";
+    } else if (_core.types.isJSXElement(child)) {
+      const nestedText = extractTextContent(child.children);
+      if (!nestedText)
+        return "";
+      const tagName = _core.types.isJSXIdentifier(child.openingElement.name) ? child.openingElement.name.name.toLowerCase() : null;
+      switch (tagName) {
+        case "strong":
+        case "b":
+          text += `**${nestedText}**`;
+          break;
+        case "em":
+        case "i":
+          text += `*${nestedText}*`;
+          break;
+        case "u":
+          text += `__${nestedText}__`;
+          break;
+        case "br":
+          text += "\n";
+          break;
+        default:
+          return "";
+      }
+    }
+  }
+  return text;
+}
+
 // src/compiler/plugins/jsx-preserve-newlines.ts
 
 
@@ -2137,10 +2338,71 @@ var JSXNewLines = {
   postProcessing
 };
 
+// src/compiler/plugins/jsx-undefined-vars.ts
+
+function jsxUndefinedVarsPlugin() {
+  return {
+    name: "jsx-undefined-vars",
+    visitor: {
+      JSXExpressionContainer(path) {
+        const expression = path.node.expression;
+        if (_core.types.isJSXEmptyExpression(expression)) {
+          return;
+        }
+        if (!_core.types.isIdentifier(expression)) {
+          return;
+        }
+        const varName = expression.name;
+        const knownGlobals = /* @__PURE__ */ new Set([
+          "undefined",
+          "null",
+          "true",
+          "false",
+          "NaN",
+          "Infinity",
+          "console",
+          "Math",
+          "JSON",
+          "Object",
+          "Array",
+          "String",
+          "Number",
+          "Boolean",
+          "Date",
+          "RegExp",
+          "Error",
+          "Promise",
+          "Symbol"
+        ]);
+        if (knownGlobals.has(varName)) {
+          return;
+        }
+        const iife = _core.types.callExpression(
+          _core.types.arrowFunctionExpression(
+            [],
+            _core.types.blockStatement([
+              _core.types.tryStatement(
+                _core.types.blockStatement([_core.types.returnStatement(_core.types.identifier(varName))]),
+                _core.types.catchClause(
+                  null,
+                  // no error binding needed
+                  _core.types.blockStatement([_core.types.returnStatement(_core.types.stringLiteral(varName))])
+                )
+              )
+            ])
+          ),
+          []
+        );
+        path.node.expression = iife;
+      }
+    }
+  };
+}
+
 // src/compiler/plugins/line-tracking.ts
 
 var LineTrackingFnIdentifier = "__track__";
-var lineTrackingBabelPlugin = function({ types: t }) {
+var lineTrackingBabelPlugin = function({ types: t3 }) {
   return {
     visitor: {
       Program(path) {
@@ -2161,8 +2423,8 @@ var lineTrackingBabelPlugin = function({ types: t }) {
                   console.error(e);
                 }
               };
-              if (t.isFunctionDeclaration(node) || t.isClassMethod(node) || t.isReturnStatement(node) || t.isAwaitExpression(node) || t.isForOfStatement(node) || t.isCallExpression(node) || t.isUnaryExpression(node) || t.isVariableDeclaration(node) || t.isBlockStatement(path2.parent) || t.isAssignmentExpression(node)) {
-                if (!trackedLines.has(startLine) && !t.isArrowFunctionExpression(path2.parent) && !t.isObjectProperty(path2.parent) && !t.isAwaitExpression(path2.parent) && !t.isUnaryExpression(path2.parent) && !t.isReturnStatement(path2.parent) && !t.isForOfStatement(path2.parent) && !t.isForStatement(path2.parent) && !t.isForInStatement(path2.parent) && !t.isVariableDeclaration(path2.parent) && !t.isBinaryExpression(path2.parent) && !t.isLogicalExpression(path2.parent)) {
+              if (t3.isFunctionDeclaration(node) || t3.isClassMethod(node) || t3.isReturnStatement(node) || t3.isAwaitExpression(node) || t3.isForOfStatement(node) || t3.isCallExpression(node) || t3.isUnaryExpression(node) || t3.isVariableDeclaration(node) || t3.isBlockStatement(path2.parent) || t3.isAssignmentExpression(node)) {
+                if (!trackedLines.has(startLine) && !t3.isArrowFunctionExpression(path2.parent) && !t3.isObjectProperty(path2.parent) && !t3.isAwaitExpression(path2.parent) && !t3.isUnaryExpression(path2.parent) && !t3.isReturnStatement(path2.parent) && !t3.isForOfStatement(path2.parent) && !t3.isForStatement(path2.parent) && !t3.isForInStatement(path2.parent) && !t3.isVariableDeclaration(path2.parent) && !t3.isBinaryExpression(path2.parent) && !t3.isLogicalExpression(path2.parent)) {
                   track();
                 }
               }
@@ -2177,7 +2439,7 @@ var lineTrackingBabelPlugin = function({ types: t }) {
 // src/compiler/plugins/replace-comment.ts
 var CommentFnIdentifier = "__comment__";
 var replaceCommentBabelPlugin = function({
-  types: t
+  types: t3
 }) {
   return {
     visitor: {
@@ -2196,13 +2458,13 @@ var replaceCommentBabelPlugin = function({
                   return;
                 }
                 processed.add(comment.loc);
-                const commentCall = t.expressionStatement(
-                  t.callExpression(t.identifier(CommentFnIdentifier), [
-                    t.stringLiteral(comment.value.trim()),
-                    t.numericLiteral(_nullishCoalesce(((_a = comment.loc) == null ? void 0 : _a.start.line), () => ( 0)))
+                const commentCall = t3.expressionStatement(
+                  t3.callExpression(t3.identifier(CommentFnIdentifier), [
+                    t3.stringLiteral(comment.value.trim()),
+                    t3.numericLiteral(_nullishCoalesce(((_a = comment.loc) == null ? void 0 : _a.start.line), () => ( 0)))
                   ])
                 );
-                const isInsideObjectProperty = t.isObjectProperty(node) || path2.findParent((path3) => t.isObjectProperty(path3.node));
+                const isInsideObjectProperty = t3.isObjectProperty(node) || path2.findParent((path3) => t3.isObjectProperty(path3.node));
                 if (!isInsideObjectProperty) {
                   insertMethod(commentCall);
                 }
@@ -2221,7 +2483,7 @@ var replaceCommentBabelPlugin = function({
 
 // src/compiler/plugins/return-async.ts
 var instrumentLastLinePlugin = function({
-  types: t
+  types: t3
 }) {
   return {
     visitor: {
@@ -2235,14 +2497,14 @@ var instrumentLastLinePlugin = function({
           return;
         }
         const lastStatement = statements[statements.length - 1];
-        if (t.isReturnStatement(lastStatement)) {
-          if (t.isExpression(lastStatement.argument)) {
-            lastStatement.argument = t.awaitExpression(lastStatement.argument);
+        if (t3.isReturnStatement(lastStatement)) {
+          if (t3.isExpression(lastStatement.argument)) {
+            lastStatement.argument = t3.awaitExpression(lastStatement.argument);
           }
           return;
         }
-        if (t.isExpressionStatement(lastStatement) && (t.isCallExpression(lastStatement.expression) || t.isAwaitExpression(lastStatement.expression))) {
-          const returnStatement3 = t.returnStatement(t.awaitExpression(lastStatement.expression));
+        if (t3.isExpressionStatement(lastStatement) && (t3.isCallExpression(lastStatement.expression) || t3.isAwaitExpression(lastStatement.expression))) {
+          const returnStatement3 = t3.returnStatement(t3.awaitExpression(lastStatement.expression));
           (_b = path.get("body").get("body")[statements.length - 1]) == null ? void 0 : _b.replaceWith(returnStatement3);
         }
       }
@@ -2460,7 +2722,7 @@ var toolCallTrackingPlugin = (calls = /* @__PURE__ */ new Map()) => function({})
 
 
 var VariableTrackingFnIdentifier = "__var__";
-var variableTrackingPlugin = (variables = /* @__PURE__ */ new Set()) => function({ types: t }) {
+var variableTrackingPlugin = (variables = /* @__PURE__ */ new Set()) => function({ types: t3 }) {
   let trackingStatements = [];
   const trackVariable = (variableName) => {
     if (variableName.startsWith("__")) {
@@ -2480,19 +2742,19 @@ var variableTrackingPlugin = (variables = /* @__PURE__ */ new Set()) => function
     visitor: {
       FunctionDeclaration(path) {
         path.node.params.forEach((param) => {
-          if (t.isIdentifier(param)) {
+          if (t3.isIdentifier(param)) {
             trackVariable(param.name);
-          } else if (t.isAssignmentPattern(param) && t.isIdentifier(param.left)) {
+          } else if (t3.isAssignmentPattern(param) && t3.isIdentifier(param.left)) {
             trackVariable(param.left.name);
-          } else if (t.isObjectPattern(param)) {
+          } else if (t3.isObjectPattern(param)) {
             param.properties.forEach((prop) => {
-              if (t.isObjectProperty(prop) && t.isIdentifier(prop.value)) {
+              if (t3.isObjectProperty(prop) && t3.isIdentifier(prop.value)) {
                 trackVariable(prop.value.name);
               }
             });
-          } else if (t.isArrayPattern(param)) {
+          } else if (t3.isArrayPattern(param)) {
             param.elements.forEach((element) => {
-              if (t.isIdentifier(element)) {
+              if (t3.isIdentifier(element)) {
                 trackVariable(element.name);
               }
             });
@@ -2505,19 +2767,19 @@ var variableTrackingPlugin = (variables = /* @__PURE__ */ new Set()) => function
       },
       ArrowFunctionExpression(path) {
         path.node.params.forEach((param) => {
-          if (t.isIdentifier(param)) {
+          if (t3.isIdentifier(param)) {
             trackVariable(param.name);
-          } else if (t.isAssignmentPattern(param) && t.isIdentifier(param.left)) {
+          } else if (t3.isAssignmentPattern(param) && t3.isIdentifier(param.left)) {
             trackVariable(param.left.name);
-          } else if (t.isObjectPattern(param)) {
+          } else if (t3.isObjectPattern(param)) {
             param.properties.forEach((prop) => {
-              if (t.isObjectProperty(prop) && t.isIdentifier(prop.value)) {
+              if (t3.isObjectProperty(prop) && t3.isIdentifier(prop.value)) {
                 trackVariable(prop.value.name);
               }
             });
-          } else if (t.isArrayPattern(param)) {
+          } else if (t3.isArrayPattern(param)) {
             param.elements.forEach((element) => {
-              if (t.isIdentifier(element)) {
+              if (t3.isIdentifier(element)) {
                 trackVariable(element.name);
               }
             });
@@ -2538,11 +2800,11 @@ var variableTrackingPlugin = (variables = /* @__PURE__ */ new Set()) => function
         const parent = path.parentPath;
         const handleObjectPattern = (pattern) => {
           pattern.properties.forEach((prop) => {
-            if (t.isObjectProperty(prop) && t.isIdentifier(prop.value)) {
+            if (t3.isObjectProperty(prop) && t3.isIdentifier(prop.value)) {
               trackVariable(prop.value.name);
-            } else if (t.isObjectProperty(prop) && t.isObjectPattern(prop.value)) {
+            } else if (t3.isObjectProperty(prop) && t3.isObjectPattern(prop.value)) {
               handleObjectPattern(prop.value);
-            } else if (t.isObjectProperty(prop) && t.isAssignmentPattern(prop.value) && t.isIdentifier(prop.value.left)) {
+            } else if (t3.isObjectProperty(prop) && t3.isAssignmentPattern(prop.value) && t3.isIdentifier(prop.value.left)) {
               trackVariable(prop.value.left.name);
             }
           });
@@ -2551,19 +2813,19 @@ var variableTrackingPlugin = (variables = /* @__PURE__ */ new Set()) => function
           if (parent.isForXStatement() || parent.isForStatement()) {
             return;
           }
-          if (t.isIdentifier(declarator.id)) {
+          if (t3.isIdentifier(declarator.id)) {
             trackVariable(declarator.id.name);
           }
-          if (t.isObjectPattern(declarator.id)) {
+          if (t3.isObjectPattern(declarator.id)) {
             handleObjectPattern(declarator.id);
           }
-          if (t.isArrayPattern(declarator.id)) {
+          if (t3.isArrayPattern(declarator.id)) {
             declarator.id.elements.forEach((element) => {
-              if (t.isIdentifier(element)) {
+              if (t3.isIdentifier(element)) {
                 trackVariable(element.name);
-              } else if (t.isRestElement(element) && t.isIdentifier(element.argument)) {
+              } else if (t3.isRestElement(element) && t3.isIdentifier(element.argument)) {
                 trackVariable(element.argument.name);
-              } else if (t.isAssignmentPattern(element) && t.isIdentifier(element.left)) {
+              } else if (t3.isAssignmentPattern(element) && t3.isIdentifier(element.left)) {
                 trackVariable(element.left.name);
               }
             });
@@ -2612,6 +2874,10 @@ function compile(code) {
     presets: ["typescript"],
     plugins: [
       JSXNewLines.babelPlugin,
+      htmlToMarkdownPlugin,
+      // Convert simple HTML to markdown first
+      jsxUndefinedVarsPlugin,
+      // Must run BEFORE JSX transform
       [
         _plugintransformreactjsx2.default,
         {
@@ -2801,7 +3067,6 @@ async function runAsyncFunction(context, code, traces = [], signal = null, timeo
       };
       const QuickJS = await _quickjsemscriptencore.newQuickJSWASMModuleFromVariant.call(void 0, BundledReleaseSyncVariant);
       const runtime = QuickJS.newRuntime();
-      runtime.setDebugMode(true);
       runtime.setMemoryLimit(128 * 1024 * 1024);
       const startTime = Date.now();
       const timeoutHandler = _quickjsemscriptencore.shouldInterruptAfterDeadline.call(void 0, startTime + timeout);