fm-bench 0.4.2 → 0.4.4

package/README.md

@@ -149,7 +149,7 @@ Token counts come from `fm token-count --quiet`. If `fm` cannot count a response
 
 Measured runs stream by default so `fm-bench` can capture TTFT and streaming smoothness. Use `--no-stream` if you need buffered `fm respond` behavior; TTFT, TPOT, second-chunk, and chunk-gap fields that depend on streaming will be blank.
 
-Terminal output is responsive. Wide terminals show full scoreboard and detail tables, medium terminals show a tighter operating-point table, and narrow terminals switch to compact model cards. Use `--width` to preview a layout and `--ascii` for log systems that do not render Unicode borders well.
+Terminal output is responsive. Wide terminals show full scoreboard and detail tables, medium terminals show a tighter operating-point table, and narrow terminals switch to compact model cards. Long `NOTE`, `DESCRIPTION`, and model quota cells wrap so error context stays visible instead of being hidden behind ellipses. Use `--width` to preview a layout and `--ascii` for log systems that do not render Unicode borders well.
 
 ## Table Legend
 
@@ -161,6 +161,8 @@ fm-bench legend --json
 fm-bench legend --csv
 ```
 
+The legend wraps long definitions and rules to fit the terminal width instead of hiding text behind ellipses.
+
 ## Live Progress
 
 Interactive terminal runs show a single-line status indicator on stderr while prompts are loaded, models are inspected, tokens are counted, warmups run, and benchmark jobs complete. The final report still prints to stdout, so `--json`, `--csv`, and `--out` remain automation-friendly.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fm-bench",
-  "version": "0.4.2",
+  "version": "0.4.4",
   "description": "Dynamic benchmark CLI for Apple's fm command on macOS 27+.",
   "type": "module",
   "bin": {

package/src/table.js

@@ -3,24 +3,30 @@ import { stripAnsi } from './ansi.js';
 export function renderTable(headers, rows, options = {}) {
   const ascii = Boolean(options.ascii);
   const maxCellWidth = options.maxCellWidth || 60;
-  const normalizedRows = rows.map((row) => row.map((cell) => {
+  const wrapColumns = normalizeWrapColumns(headers, options.wrapColumns);
+  const normalizedRows = rows.map((row) => row.map((cell, index) => {
     const normalized = normalizeCell(cell);
     return {
       ...normalized,
-      text: truncate(normalized.text, maxCellWidth)
+      text: wrapColumns.has(index) ? normalized.text : truncate(normalized.text, maxCellWidth)
     };
   }));
-  const widths = headers.map((header, index) => {
+  const widths = fitTableWidths(headers, headers.map((header, index) => {
     const values = [truncate(header, maxCellWidth), ...normalizedRows.map((row) => row[index]?.text ?? '')];
+    if (wrapColumns.has(index)) {
+      return Math.max(...values.map((value) => Math.min(maxCellWidth, visibleLength(value))));
+    }
     return Math.max(...values.map(visibleLength));
-  });
+  }), wrapColumns, terminalWidth(options));
   const style = ascii ? ASCII_TABLE : UNICODE_TABLE;
 
   const top = rule(style.topLeft, style.topJoin, style.topRight, style.horizontal, widths);
   const middle = rule(style.midLeft, style.midJoin, style.midRight, style.horizontal, widths);
   const bottom = rule(style.bottomLeft, style.bottomJoin, style.bottomRight, style.horizontal, widths);
   const headerLine = rowLine(headers.map((header) => truncate(header, maxCellWidth)), widths, style, true, options);
-  const bodyLines = normalizedRows.map((row) => rowLine(row, widths, style, false, options));
+  const bodyLines = wrapColumns.size > 0
+    ? normalizedRows.flatMap((row) => wrappedRowLines(row, widths, style, wrapColumns, options))
+    : normalizedRows.map((row) => rowLine(row, widths, style, false, options));
 
   return [top, headerLine, middle, ...bodyLines, bottom].join('\n');
 }
@@ -109,16 +115,10 @@ export function renderLegend(options = {}) {
   ]);
 
   if (options.compact || width < 88) {
-    return legendEntries().map((item) => {
-      const suffix = item.rule ? ` Rule: ${item.rule}` : '';
-      return truncate(`${item.table.toUpperCase()} ${item.column}: ${item.definition}${suffix}`, width);
-    }).join('\n');
+    return renderCompactLegend(width);
   }
 
-  return renderTable(['table', 'column', 'definition', 'rule'], rows, {
-    ...options,
-    maxCellWidth: Math.max(20, Math.floor((width - 48) / 2))
-  });
+  return renderWrappedTable(['table', 'column', 'definition', 'rule'], rows, legendColumnWidths(width), options);
 }
 
 export function formatMs(value) {
@@ -161,7 +161,7 @@ export function renderSummaryTable(summary, options = {}) {
       cell(formatNumber(item.outputTokenThroughput), tones.systemTps),
       cell(formatNumber(item.rps), tones.rps),
       cell(formatPercent(item.latency.cv), cvTone(item.latency.cv)),
-      cell(item.available ? '' : compactReason(item.skippedReason), item.available ? null : 'yellow')
+      cell(item.available ? '' : cleanReason(item.skippedReason), item.available ? null : 'yellow')
     ];
 
     if (mode === 'medium') {
@@ -200,7 +200,7 @@ export function renderSummaryTable(summary, options = {}) {
     ? (hasGoodput ? mediumHeaders : mediumHeaders.filter((header) => header !== 'good' && header !== 'good rps'))
     : (hasGoodput ? wideHeaders : wideHeaders.filter((header) => header !== 'good' && header !== 'good rps'));
 
-  return renderTable(headers, rows, { ...options, maxCellWidth: mode === 'medium' ? 24 : 52 });
+  return renderTable(headers, rows, { ...options, maxCellWidth: mode === 'medium' ? 24 : 52, wrapColumns: ['note'] });
 }
 
 export function renderDetailTable(summary, options = {}) {
@@ -247,7 +247,7 @@ export function renderDetailTable(summary, options = {}) {
       'description'
     ];
 
-  return renderTable(headers, rows, { ...options, maxCellWidth: mode === 'medium' ? 34 : 52 });
+  return renderTable(headers, rows, { ...options, maxCellWidth: mode === 'medium' ? 34 : 52, wrapColumns: ['description'] });
 }
 
 export function renderCompactSummary(summary, options = {}) {
@@ -292,8 +292,8 @@ export function renderModelsTable(models, options = {}) {
     cell(model.name),
     cell(model.available ? 'yes' : 'no', model.available ? 'green' : 'yellow'),
     model.description || '-',
-    compactReason(model.quota || model.reason || '-')
-  ]), options);
+    cleanReason(model.quota || model.reason || '-')
+  ]), { ...options, wrapColumns: ['description', 'quota'] });
 }
 
 function formatRangeMs(low, high) {
@@ -358,6 +358,89 @@ function rule(left, join, right, horizontal, widths) {
   return `${left}${widths.map((width) => horizontal.repeat(width + 2)).join(join)}${right}`;
 }
 
+function renderWrappedTable(headers, rows, widths, options = {}) {
+  const ascii = Boolean(options.ascii);
+  const style = ascii ? ASCII_TABLE : UNICODE_TABLE;
+  const top = rule(style.topLeft, style.topJoin, style.topRight, style.horizontal, widths);
+  const middle = rule(style.midLeft, style.midJoin, style.midRight, style.horizontal, widths);
+  const bottom = rule(style.bottomLeft, style.bottomJoin, style.bottomRight, style.horizontal, widths);
+  const headerLine = rowLine(headers.map((header) => truncate(header, widths[headers.indexOf(header)])), widths, style, true, options);
+  const bodyLines = [];
+
+  for (const row of rows) {
+    const wrappedCells = row.map((value, index) => wrapText(formatCell(value), widths[index]));
+    const height = Math.max(...wrappedCells.map((lines) => lines.length));
+    for (let lineIndex = 0; lineIndex < height; lineIndex += 1) {
+      bodyLines.push(rowLine(wrappedCells.map((lines) => lines[lineIndex] ?? ''), widths, style, false, options));
+    }
+  }
+
+  return [top, headerLine, middle, ...bodyLines, bottom].join('\n');
+}
+
+function normalizeWrapColumns(headers, wrapColumns = []) {
+  const normalized = new Set();
+  for (const column of wrapColumns || []) {
+    if (Number.isInteger(column)) {
+      if (column >= 0 && column < headers.length) normalized.add(column);
+      continue;
+    }
+
+    const index = headers.findIndex((header) => String(header).toLowerCase() === String(column).toLowerCase());
+    if (index >= 0) normalized.add(index);
+  }
+  return normalized;
+}
+
+function fitTableWidths(headers, widths, wrapColumns, targetWidth) {
+  if (!targetWidth || wrapColumns.size === 0 || renderedTableWidth(widths) <= targetWidth) return widths;
+
+  const fitted = [...widths];
+  const minimums = fitted.map((width, index) => (
+    wrapColumns.has(index)
+      ? Math.max(visibleLength(String(headers[index]).toUpperCase()), Math.min(12, width))
+      : width
+  ));
+  let excess = renderedTableWidth(fitted) - targetWidth;
+
+  while (excess > 0) {
+    const candidates = [...wrapColumns]
+      .filter((index) => fitted[index] > minimums[index])
+      .sort((a, b) => fitted[b] - fitted[a]);
+    if (candidates.length === 0) break;
+
+    for (const index of candidates) {
+      if (excess <= 0) break;
+      fitted[index] -= 1;
+      excess -= 1;
+    }
+  }
+
+  return fitted;
+}
+
+function renderedTableWidth(widths) {
+  return widths.reduce((sum, width) => sum + width, 0) + (widths.length * 3) + 1;
+}
+
+function wrappedRowLines(row, widths, style, wrapColumns, options = {}) {
+  const wrappedCells = row.map((value, index) => {
+    const normalized = normalizeCell(value);
+    return {
+      tone: normalized.tone,
+      lines: wrapColumns.has(index) ? wrapText(normalized.text, widths[index]) : [normalized.text]
+    };
+  });
+  const height = Math.max(...wrappedCells.map((item) => item.lines.length));
+  const lines = [];
+
+  for (let lineIndex = 0; lineIndex < height; lineIndex += 1) {
+    lines.push(rowLine(wrappedCells.map((item) => cell(item.lines[lineIndex] ?? '', item.tone)), widths, style, false, options));
+  }
+
+  return lines;
+}
+
 function rowLine(row, widths, style, header = false, options = {}) {
   return `${style.vertical}${row.map((cell, index) => {
     const normalized = header ? { text: String(cell).toUpperCase(), tone: 'header' } : normalizeCell(cell);
@@ -403,12 +486,73 @@ function visibleLength(value) {
   return stripAnsi(value).length;
 }
 
+function cleanReason(value) {
+  return String(value || '').replace(/\s+/g, ' ').trim();
+}
+
 function compactReason(value) {
-  const clean = String(value || '').replace(/\s+/g, ' ').trim();
+  const clean = cleanReason(value);
   if (clean.length <= 58) return clean;
   return `${clean.slice(0, 55)}...`;
 }
 
+function renderCompactLegend(width) {
+  const lines = [];
+  for (const item of legendEntries()) {
+    lines.push(...wrapText(`${item.table.toUpperCase()} ${item.column}`, width));
+    lines.push(...wrapText(`  Definition: ${item.definition}`, width));
+    if (item.rule) {
+      lines.push(...wrapText(`  Rule: ${item.rule}`, width));
+    }
+    lines.push('');
+  }
+  if (lines.at(-1) === '') lines.pop();
+  return lines.join('\n');
+}
+
+function legendColumnWidths(width) {
+  const available = Math.max(40, width - 13);
+  const tableWidth = 7;
+  const columnWidth = Math.min(25, Math.max(18, Math.floor(available * 0.28)));
+  const remaining = Math.max(36, available - tableWidth - columnWidth);
+  const definitionWidth = Math.max(18, Math.floor(remaining * 0.52));
+  const ruleWidth = Math.max(18, remaining - definitionWidth);
+  return [tableWidth, columnWidth, definitionWidth, ruleWidth];
+}
+
+function wrapText(value, width) {
+  const text = String(value ?? '').replace(/\s+/g, ' ').trim();
+  if (!text) return [''];
+  if (width <= 1) return [text];
+
+  const lines = [];
+  let current = '';
+  for (const rawWord of text.split(' ')) {
+    const pieces = splitLongWord(rawWord, width);
+    for (const word of pieces) {
+      if (!current) {
+        current = word;
+      } else if (visibleLength(`${current} ${word}`) <= width) {
+        current = `${current} ${word}`;
+      } else {
+        lines.push(current);
+        current = word;
+      }
+    }
+  }
+  if (current) lines.push(current);
+  return lines.length ? lines : [''];
+}
+
+function splitLongWord(word, width) {
+  if (visibleLength(word) <= width) return [word];
+  const pieces = [];
+  for (let index = 0; index < word.length; index += width) {
+    pieces.push(word.slice(index, index + width));
+  }
+  return pieces;
+}
+
 function truncate(value, width) {
   const text = String(value ?? '');
   if (visibleLength(text) <= width) return text;