@bastani/atomic 0.9.16-alpha.6 → 0.9.16-alpha.8

package/dist/builtin/workflows/builtin/chunk-4febxsv4.js

@@ -0,0 +1,264 @@
+import"./chunk-5wgwscd0.js";
+
+// src/core/export-html/ansi-to-html.ts
+var ANSI_COLORS = [
+  "#000000",
+  "#800000",
+  "#008000",
+  "#808000",
+  "#000080",
+  "#800080",
+  "#008080",
+  "#c0c0c0",
+  "#808080",
+  "#ff0000",
+  "#00ff00",
+  "#ffff00",
+  "#0000ff",
+  "#ff00ff",
+  "#00ffff",
+  "#ffffff"
+];
+function color256ToHex(index) {
+  if (index < 16) {
+    return ANSI_COLORS[index];
+  }
+  if (index < 232) {
+    const cubeIndex = index - 16;
+    const r = Math.floor(cubeIndex / 36);
+    const g = Math.floor(cubeIndex % 36 / 6);
+    const b = cubeIndex % 6;
+    const toComponent = (n) => n === 0 ? 0 : 55 + n * 40;
+    const toHex = (n) => toComponent(n).toString(16).padStart(2, "0");
+    return `#${toHex(r)}${toHex(g)}${toHex(b)}`;
+  }
+  const gray = 8 + (index - 232) * 10;
+  const grayHex = gray.toString(16).padStart(2, "0");
+  return `#${grayHex}${grayHex}${grayHex}`;
+}
+function escapeHtml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
+}
+function createEmptyStyle() {
+  return {
+    fg: null,
+    bg: null,
+    bold: false,
+    dim: false,
+    italic: false,
+    underline: false
+  };
+}
+function styleToInlineCSS(style) {
+  const parts = [];
+  if (style.fg)
+    parts.push(`color:${style.fg}`);
+  if (style.bg)
+    parts.push(`background-color:${style.bg}`);
+  if (style.bold)
+    parts.push("font-weight:bold");
+  if (style.dim)
+    parts.push("opacity:0.6");
+  if (style.italic)
+    parts.push("font-style:italic");
+  if (style.underline)
+    parts.push("text-decoration:underline");
+  return parts.join(";");
+}
+function hasStyle(style) {
+  return style.fg !== null || style.bg !== null || style.bold || style.dim || style.italic || style.underline;
+}
+function applySgrCode(params, style) {
+  let i = 0;
+  while (i < params.length) {
+    const code = params[i];
+    if (code === 0) {
+      style.fg = null;
+      style.bg = null;
+      style.bold = false;
+      style.dim = false;
+      style.italic = false;
+      style.underline = false;
+    } else if (code === 1) {
+      style.bold = true;
+    } else if (code === 2) {
+      style.dim = true;
+    } else if (code === 3) {
+      style.italic = true;
+    } else if (code === 4) {
+      style.underline = true;
+    } else if (code === 22) {
+      style.bold = false;
+      style.dim = false;
+    } else if (code === 23) {
+      style.italic = false;
+    } else if (code === 24) {
+      style.underline = false;
+    } else if (code >= 30 && code <= 37) {
+      style.fg = ANSI_COLORS[code - 30];
+    } else if (code === 38) {
+      if (params[i + 1] === 5 && params.length > i + 2) {
+        style.fg = color256ToHex(params[i + 2]);
+        i += 2;
+      } else if (params[i + 1] === 2 && params.length > i + 4) {
+        const r = params[i + 2];
+        const g = params[i + 3];
+        const b = params[i + 4];
+        style.fg = `rgb(${r},${g},${b})`;
+        i += 4;
+      }
+    } else if (code === 39) {
+      style.fg = null;
+    } else if (code >= 40 && code <= 47) {
+      style.bg = ANSI_COLORS[code - 40];
+    } else if (code === 48) {
+      if (params[i + 1] === 5 && params.length > i + 2) {
+        style.bg = color256ToHex(params[i + 2]);
+        i += 2;
+      } else if (params[i + 1] === 2 && params.length > i + 4) {
+        const r = params[i + 2];
+        const g = params[i + 3];
+        const b = params[i + 4];
+        style.bg = `rgb(${r},${g},${b})`;
+        i += 4;
+      }
+    } else if (code === 49) {
+      style.bg = null;
+    } else if (code >= 90 && code <= 97) {
+      style.fg = ANSI_COLORS[code - 90 + 8];
+    } else if (code >= 100 && code <= 107) {
+      style.bg = ANSI_COLORS[code - 100 + 8];
+    }
+    i++;
+  }
+}
+var ANSI_REGEX = /\x1b\[([\d;]*)m/g;
+function ansiToHtml(text) {
+  const style = createEmptyStyle();
+  let result = "";
+  let lastIndex = 0;
+  let inSpan = false;
+  ANSI_REGEX.lastIndex = 0;
+  let match = ANSI_REGEX.exec(text);
+  while (match !== null) {
+    const beforeText = text.slice(lastIndex, match.index);
+    if (beforeText) {
+      result += escapeHtml(beforeText);
+    }
+    const paramStr = match[1];
+    const params = paramStr ? paramStr.split(";").map((p) => parseInt(p, 10) || 0) : [0];
+    if (inSpan) {
+      result += "</span>";
+      inSpan = false;
+    }
+    applySgrCode(params, style);
+    if (hasStyle(style)) {
+      result += `<span style="${styleToInlineCSS(style)}">`;
+      inSpan = true;
+    }
+    lastIndex = match.index + match[0].length;
+    match = ANSI_REGEX.exec(text);
+  }
+  const remainingText = text.slice(lastIndex);
+  if (remainingText) {
+    result += escapeHtml(remainingText);
+  }
+  if (inSpan) {
+    result += "</span>";
+  }
+  return result;
+}
+function ansiLinesToHtml(lines) {
+  return lines.map((line) => `<div class="ansi-line">${ansiToHtml(line) || "&nbsp;"}</div>`).join("");
+}
+
+// src/core/export-html/tool-renderer.ts
+var ANSI_ESCAPE_REGEX = /\x1b\[[\d;]*m/g;
+function isBlankRenderedLine(line) {
+  return line.replace(ANSI_ESCAPE_REGEX, "").trim().length === 0;
+}
+function trimRenderedResultLines(lines) {
+  let start = 0;
+  let end = lines.length;
+  while (start < end && isBlankRenderedLine(lines[start]))
+    start++;
+  while (end > start && isBlankRenderedLine(lines[end - 1]))
+    end--;
+  return lines.slice(start, end);
+}
+function createToolHtmlRenderer(deps) {
+  const { getToolDefinition, theme, cwd, width = 100 } = deps;
+  const renderedCallComponents = new Map;
+  const renderedResultComponents = new Map;
+  const renderedStates = new Map;
+  const renderedArgs = new Map;
+  const getState = (toolCallId) => {
+    let state = renderedStates.get(toolCallId);
+    if (!state) {
+      state = {};
+      renderedStates.set(toolCallId, state);
+    }
+    return state;
+  };
+  const createRenderContext = (toolCallId, lastComponent, expanded, isPartial, isError) => {
+    return {
+      args: renderedArgs.get(toolCallId),
+      toolCallId,
+      invalidate: () => {},
+      lastComponent,
+      state: getState(toolCallId),
+      cwd,
+      executionStarted: true,
+      argsComplete: true,
+      isPartial,
+      expanded,
+      showImages: false,
+      isError
+    };
+  };
+  return {
+    renderCall(toolCallId, toolName, args) {
+      try {
+        renderedArgs.set(toolCallId, args);
+        const toolDef = getToolDefinition(toolName);
+        if (!toolDef?.renderCall) {
+          return;
+        }
+        const component = toolDef.renderCall(args, theme, createRenderContext(toolCallId, renderedCallComponents.get(toolCallId), false, true, false));
+        renderedCallComponents.set(toolCallId, component);
+        const lines = component.render(width);
+        return ansiLinesToHtml(lines);
+      } catch {
+        return;
+      }
+    },
+    renderResult(toolCallId, toolName, result, details, isError) {
+      try {
+        const toolDef = getToolDefinition(toolName);
+        if (!toolDef?.renderResult) {
+          return;
+        }
+        const agentToolResult = {
+          content: result,
+          details,
+          isError
+        };
+        const collapsedComponent = toolDef.renderResult(agentToolResult, { expanded: false, isPartial: false }, theme, createRenderContext(toolCallId, renderedResultComponents.get(toolCallId), false, false, isError));
+        renderedResultComponents.set(toolCallId, collapsedComponent);
+        const collapsed = ansiLinesToHtml(trimRenderedResultLines(collapsedComponent.render(width)));
+        const expandedComponent = toolDef.renderResult(agentToolResult, { expanded: true, isPartial: false }, theme, createRenderContext(toolCallId, renderedResultComponents.get(toolCallId), true, false, isError));
+        renderedResultComponents.set(toolCallId, expandedComponent);
+        const expanded = ansiLinesToHtml(trimRenderedResultLines(expandedComponent.render(width)));
+        return {
+          ...collapsed && collapsed !== expanded ? { collapsed } : {},
+          expanded
+        };
+      } catch {
+        return;
+      }
+    }
+  };
+}
+export {
+  createToolHtmlRenderer
+};