llm-usage-metrics 0.1.9 → 0.1.10

package/dist/index.js

@@ -2766,7 +2766,6 @@ function renderReportHeader(options) {
 
 // src/render/terminal-table.ts
 import pc4 from "picocolors";
-import { table } from "table";
 
 // src/render/terminal-style-policy.ts
 import pc3 from "picocolors";
@@ -2781,6 +2780,9 @@ var defaultTerminalStylePalette = {
   dim: pc3.dim
 };
 var passthroughStyler = (text) => text;
+function styleCellLines(cell, styler) {
+  return cell.split("\n").map((line) => line.length === 0 ? "" : styler(line)).join("\n");
+}
 var sourceStylePolicies = /* @__PURE__ */ new Map([
   ["pi", (palette) => palette.cyan],
   ["codex", (palette) => palette.magenta],
@@ -2797,23 +2799,23 @@ var rowTypeStylePolicies = {
   period_source: (cells, palette) => {
     const styledCells = [...cells];
     const costColumnIndex = styledCells.length - 1;
-    styledCells[costColumnIndex] = palette.yellow(styledCells[costColumnIndex]);
+    styledCells[costColumnIndex] = styleCellLines(styledCells[costColumnIndex], palette.yellow);
     return styledCells;
   },
   period_combined: (cells, palette) => cells.map((cell, cellIndex) => {
     if (cellIndex === 1) {
-      return palette.bold(palette.yellow(cell));
+      return styleCellLines(cell, (line) => palette.bold(palette.yellow(line)));
     }
-    return palette.dim(cell);
+    return styleCellLines(cell, palette.dim);
   }),
   grand_total: (cells, palette) => cells.map((cell, cellIndex) => {
     if (cellIndex === 0) {
-      return palette.bold(palette.white(cell));
+      return styleCellLines(cell, (line) => palette.bold(palette.white(line)));
     }
     if (cellIndex === 1) {
-      return palette.bold(palette.green(cell));
+      return styleCellLines(cell, (line) => palette.bold(palette.green(line)));
     }
-    return palette.bold(cell);
+    return styleCellLines(cell, palette.bold);
   })
 };
 function applyRowTypeStyle(rowType, cells, palette = defaultTerminalStylePalette) {
@@ -2824,8 +2826,8 @@ function applyBaseCellStyle(cells, palette, sourceStyler) {
     return [...cells];
   }
   const styledCells = [...cells];
-  styledCells[0] = palette.white(styledCells[0]);
-  styledCells[1] = sourceStyler(styledCells[1]);
+  styledCells[0] = styleCellLines(styledCells[0], palette.white);
+  styledCells[1] = styleCellLines(styledCells[1], sourceStyler);
   return styledCells;
 }
 function colorizeUsageBodyRows(bodyRows, rows, options) {
@@ -2840,66 +2842,291 @@ function colorizeUsageBodyRows(bodyRows, rows, options) {
   });
 }
 
-// src/render/terminal-table.ts
-var modelsColumnIndex = 2;
-var roundedBorders = {
-  topBody: "\u2500",
-  topJoin: "\u252C",
-  topLeft: "\u256D",
-  topRight: "\u256E",
-  bottomBody: "\u2500",
-  bottomJoin: "\u2534",
-  bottomLeft: "\u2570",
-  bottomRight: "\u256F",
-  bodyLeft: "\u2502",
-  bodyRight: "\u2502",
-  bodyJoin: "\u2502",
-  headerJoin: "\u252C",
-  joinBody: "\u2500",
-  joinLeft: "\u251C",
-  joinRight: "\u2524",
-  joinJoin: "\u253C",
-  joinMiddleDown: "\u252C",
-  joinMiddleUp: "\u2534",
-  joinMiddleLeft: "\u2524",
-  joinMiddleRight: "\u251C"
-};
-function shouldDrawHorizontalLine(index, rowCount, usageRows) {
-  if (index === 0 || index === 1 || index === rowCount) {
+// src/render/table-text-layout.ts
+var ansiEscapePattern = new RegExp(String.raw`\u001B\[[0-9;]*m`, "gu");
+var combiningMarkPattern = /\p{Mark}/u;
+var extendedPictographicPattern = /\p{Extended_Pictographic}/u;
+var emojiPresentationPattern = /\p{Emoji_Presentation}/u;
+var regionalIndicatorPattern = /\p{Regional_Indicator}/u;
+var graphemeSegmenter = new Intl.Segmenter("en", { granularity: "grapheme" });
+function normalizeLineBreaks(value) {
+  return value.replace(/\r\n?/gu, "\n");
+}
+function stripAnsi(value) {
+  return value.replaceAll(ansiEscapePattern, "");
+}
+function isControlCodePoint(codePoint) {
+  return codePoint <= 31 || codePoint >= 127 && codePoint <= 159;
+}
+function isZeroWidthCodePoint(codePoint) {
+  return codePoint === 8203 || codePoint === 8205 || codePoint === 8288 || codePoint === 65279 || codePoint >= 65024 && codePoint <= 65039;
+}
+function isFullWidthCodePoint(codePoint) {
+  if (Number.isNaN(codePoint)) {
+    return false;
+  }
+  if (codePoint >= 4352 && (codePoint <= 4447 || codePoint === 9001 || codePoint === 9002 || codePoint >= 11904 && codePoint <= 12871 && codePoint !== 12351 || codePoint >= 12880 && codePoint <= 19903 || codePoint >= 19968 && codePoint <= 42182 || codePoint >= 43360 && codePoint <= 43388 || codePoint >= 44032 && codePoint <= 55203 || codePoint >= 63744 && codePoint <= 64255 || codePoint >= 65040 && codePoint <= 65049 || codePoint >= 65072 && codePoint <= 65131 || codePoint >= 65281 && codePoint <= 65376 || codePoint >= 65504 && codePoint <= 65510 || codePoint >= 110592 && codePoint <= 110593 || codePoint >= 127488 && codePoint <= 127569 || codePoint >= 131072 && codePoint <= 262141)) {
+    return true;
+  }
+  return false;
+}
+function codePointDisplayWidth(character) {
+  const codePoint = character.codePointAt(0);
+  if (codePoint === void 0) {
+    return 0;
+  }
+  if (isControlCodePoint(codePoint) || isZeroWidthCodePoint(codePoint)) {
+    return 0;
+  }
+  if (combiningMarkPattern.test(character)) {
+    return 0;
+  }
+  if (isFullWidthCodePoint(codePoint)) {
+    return 2;
+  }
+  return 1;
+}
+function segmentGraphemes(value) {
+  return Array.from(graphemeSegmenter.segment(value), (segment) => segment.segment);
+}
+function isEmojiGrapheme(grapheme) {
+  if (emojiPresentationPattern.test(grapheme)) {
+    return true;
+  }
+  if (regionalIndicatorPattern.test(grapheme)) {
+    return true;
+  }
+  if (grapheme.includes("\u20E3")) {
     return true;
   }
-  const previousRow = usageRows[index - 2];
-  const nextRow = usageRows[index - 1];
+  if (grapheme.includes("\uFE0F")) {
+    return true;
+  }
+  return grapheme.includes("\u200D") && extendedPictographicPattern.test(grapheme);
+}
+function graphemeDisplayWidth(grapheme) {
+  if (isEmojiGrapheme(grapheme)) {
+    return 2;
+  }
+  let width = 0;
+  for (const character of grapheme) {
+    width = Math.max(width, codePointDisplayWidth(character));
+  }
+  return width;
+}
+function visibleWidth(value) {
+  let width = 0;
+  for (const grapheme of segmentGraphemes(stripAnsi(value))) {
+    width += graphemeDisplayWidth(grapheme);
+  }
+  return width;
+}
+function splitCellLines(value) {
+  return normalizeLineBreaks(value).split("\n");
+}
+function sliceByVisibleWidth(value, maxWidth) {
+  if (maxWidth <= 0) {
+    return "";
+  }
+  let width = 0;
+  let endOffset = 0;
+  for (const grapheme of segmentGraphemes(value)) {
+    const graphemeWidth = graphemeDisplayWidth(grapheme);
+    if (width + graphemeWidth > maxWidth) {
+      break;
+    }
+    width += graphemeWidth;
+    endOffset += grapheme.length;
+  }
+  return value.slice(0, endOffset);
+}
+function getFirstGrapheme(value) {
+  for (const grapheme of segmentGraphemes(value)) {
+    return grapheme;
+  }
+  return "";
+}
+function wrapPlainLine(line, width) {
+  if (visibleWidth(line) <= width) {
+    return [line];
+  }
+  const wrappedLines = [];
+  let remaining = line;
+  while (visibleWidth(remaining) > width) {
+    const slice = sliceByVisibleWidth(remaining, width + 1);
+    const breakIndex = slice.lastIndexOf(" ");
+    if (breakIndex > 0) {
+      wrappedLines.push(remaining.slice(0, breakIndex));
+      remaining = remaining.slice(breakIndex + 1);
+      continue;
+    }
+    const chunk = sliceByVisibleWidth(remaining, width);
+    if (chunk.length > 0) {
+      wrappedLines.push(chunk);
+      remaining = remaining.slice(chunk.length);
+      continue;
+    }
+    const firstCharacter = getFirstGrapheme(remaining);
+    wrappedLines.push(firstCharacter);
+    remaining = remaining.slice(firstCharacter.length);
+  }
+  wrappedLines.push(remaining);
+  return wrappedLines;
+}
+function wrapTableColumn(rows, options) {
+  if (options.width <= 0) {
+    throw new RangeError("wrapTableColumn width must be greater than 0");
+  }
+  return rows.map((row) => {
+    const wrappedRow = [...row];
+    const cell = wrappedRow[options.columnIndex] ?? "";
+    const wrappedLines = splitCellLines(cell).flatMap((line) => wrapPlainLine(line, options.width));
+    wrappedRow[options.columnIndex] = wrappedLines.join("\n");
+    return wrappedRow;
+  });
+}
+
+// src/render/unicode-table.ts
+function getColumnAlignment(columnIndex, modelsColumnIndex2) {
+  if (columnIndex <= modelsColumnIndex2) {
+    return "left";
+  }
+  return "right";
+}
+function getVerticalAlignment(columnIndex, tableLayout, modelsColumnIndex2) {
+  if (columnIndex === modelsColumnIndex2) {
+    return "top";
+  }
+  return tableLayout === "per_model_columns" ? "top" : "middle";
+}
+function alignCellLine(value, width, alignment2) {
+  const padding = Math.max(0, width - visibleWidth(value));
+  if (alignment2 === "right") {
+    return `${" ".repeat(padding)}${value}`;
+  }
+  return `${value}${" ".repeat(padding)}`;
+}
+function padCellLines(lines, rowHeight, verticalAlignment) {
+  const missingLineCount = rowHeight - lines.length;
+  if (missingLineCount <= 0) {
+    return lines;
+  }
+  if (verticalAlignment === "top") {
+    return [...lines, ...Array.from({ length: missingLineCount }, () => "")];
+  }
+  const topPadding = Math.floor(missingLineCount / 2);
+  const bottomPadding = missingLineCount - topPadding;
+  return [
+    ...Array.from({ length: topPadding }, () => ""),
+    ...lines,
+    ...Array.from({ length: bottomPadding }, () => "")
+  ];
+}
+function toRenderableRowLines(row, options) {
+  const cellLines = row.map((cell) => splitCellLines(cell));
+  const rowHeight = cellLines.reduce((max, lines) => Math.max(max, lines.length), 1);
+  const paddedAlignedColumns = cellLines.map((lines, columnIndex) => {
+    const verticalAlignment = getVerticalAlignment(
+      columnIndex,
+      options.tableLayout,
+      options.modelsColumnIndex
+    );
+    const alignedLines = padCellLines(lines, rowHeight, verticalAlignment);
+    const horizontalAlignment = getColumnAlignment(columnIndex, options.modelsColumnIndex);
+    return alignedLines.map(
+      (line) => alignCellLine(line, options.widths[columnIndex], horizontalAlignment)
+    );
+  });
+  return Array.from({ length: rowHeight }, (_, lineIndex) => {
+    const lineCells = paddedAlignedColumns.map((columnLines) => columnLines[lineIndex]);
+    return `\u2502 ${lineCells.join(" \u2502 ")} \u2502`;
+  });
+}
+function buildBorderLine(widths, chars) {
+  const segments = widths.map((width) => "\u2500".repeat(width + 2));
+  return `${chars.left}${segments.join(chars.join)}${chars.right}`;
+}
+function shouldDrawBodySeparator(index, usageRows) {
+  if (index < 0 || index >= usageRows.length - 1) {
+    return false;
+  }
+  const previousRow = usageRows[index];
+  const nextRow = usageRows[index + 1];
   return previousRow.rowType === "period_combined" || nextRow.rowType === "grand_total" || previousRow.periodKey !== nextRow.periodKey;
 }
-function createTableConfig(tableLayout, usageRows) {
-  const rowVerticalAlignment = tableLayout === "per_model_columns" ? "top" : "middle";
-  return {
-    border: roundedBorders,
-    drawHorizontalLine: (index, rowCount) => shouldDrawHorizontalLine(index, rowCount, usageRows),
-    columnDefault: {
-      paddingLeft: 1,
-      paddingRight: 1,
-      verticalAlignment: "top"
-    },
-    columns: {
-      0: { alignment: "left", verticalAlignment: rowVerticalAlignment },
-      1: { alignment: "left", verticalAlignment: rowVerticalAlignment },
-      [modelsColumnIndex]: {
-        alignment: "left",
-        width: 32,
-        wrapWord: true
-      },
-      3: { alignment: "right", verticalAlignment: rowVerticalAlignment },
-      4: { alignment: "right", verticalAlignment: rowVerticalAlignment },
-      5: { alignment: "right", verticalAlignment: rowVerticalAlignment },
-      6: { alignment: "right", verticalAlignment: rowVerticalAlignment },
-      7: { alignment: "right", verticalAlignment: rowVerticalAlignment },
-      8: { alignment: "right", verticalAlignment: rowVerticalAlignment },
-      9: { alignment: "right", verticalAlignment: rowVerticalAlignment }
+function computeColumnWidths(measureRows, options) {
+  const columnCount = measureRows[0]?.length ?? 0;
+  const widths = Array.from({ length: columnCount }, () => 0);
+  for (const row of measureRows) {
+    for (let columnIndex = 0; columnIndex < columnCount; columnIndex += 1) {
+      for (const line of splitCellLines(row[columnIndex])) {
+        widths[columnIndex] = Math.max(widths[columnIndex], visibleWidth(line));
+      }
     }
-  };
+  }
+  widths[options.modelsColumnIndex] = options.modelsColumnWidth;
+  return widths;
+}
+function renderUnicodeTable(options) {
+  const measureRows = [options.measureHeaderCells, ...options.measureBodyRows];
+  const widths = computeColumnWidths(measureRows, {
+    modelsColumnIndex: options.modelsColumnIndex,
+    modelsColumnWidth: options.modelsColumnWidth
+  });
+  const renderedLines = [];
+  renderedLines.push(
+    buildBorderLine(widths, {
+      left: "\u256D",
+      join: "\u252C",
+      right: "\u256E"
+    })
+  );
+  renderedLines.push(
+    ...toRenderableRowLines(options.headerCells, {
+      widths,
+      tableLayout: "per_model_columns",
+      modelsColumnIndex: options.modelsColumnIndex
+    })
+  );
+  renderedLines.push(
+    buildBorderLine(widths, {
+      left: "\u251C",
+      join: "\u253C",
+      right: "\u2524"
+    })
+  );
+  options.bodyRows.forEach((row, rowIndex) => {
+    renderedLines.push(
+      ...toRenderableRowLines(row, {
+        widths,
+        tableLayout: options.tableLayout,
+        modelsColumnIndex: options.modelsColumnIndex
+      })
+    );
+    if (rowIndex < options.bodyRows.length - 1 && shouldDrawBodySeparator(rowIndex, options.usageRows)) {
+      renderedLines.push(
+        buildBorderLine(widths, {
+          left: "\u251C",
+          join: "\u253C",
+          right: "\u2524"
+        })
+      );
+    }
+  });
+  renderedLines.push(
+    buildBorderLine(widths, {
+      left: "\u2570",
+      join: "\u2534",
+      right: "\u256F"
+    })
+  );
+  return `${renderedLines.join("\n")}
+`;
 }
+
+// src/render/terminal-table.ts
+var modelsColumnIndex = 2;
+var modelsColumnWidth = 32;
 function shouldUseColorByDefault() {
   if (process.env.NO_COLOR !== void 0) {
     return false;
@@ -2921,9 +3148,21 @@ function renderTerminalTable(rows, options = {}) {
   const useColor = options.useColor ?? shouldUseColorByDefault();
   const tableLayout = options.tableLayout ?? "compact";
   const uncoloredBodyRows = toUsageTableCells(rows, { layout: tableLayout });
-  const bodyRows = colorizeUsageBodyRows(uncoloredBodyRows, rows, { useColor });
-  const displayRows = [colorizeHeader(useColor), ...bodyRows];
-  return table(displayRows, createTableConfig(tableLayout, rows));
+  const wrappedBodyRows = wrapTableColumn(uncoloredBodyRows, {
+    columnIndex: modelsColumnIndex,
+    width: modelsColumnWidth
+  });
+  const bodyRows = colorizeUsageBodyRows(wrappedBodyRows, rows, { useColor });
+  return renderUnicodeTable({
+    headerCells: colorizeHeader(useColor),
+    bodyRows,
+    measureHeaderCells: usageTableHeaders,
+    measureBodyRows: wrappedBodyRows,
+    usageRows: rows,
+    tableLayout,
+    modelsColumnIndex,
+    modelsColumnWidth
+  });
 }
 
 // src/render/render-usage-report.ts