kiku-agent 1.2.0 → 1.3.1

package/server/agent/ui.js

@@ -821,45 +821,131 @@ export function printRichStatusCard({ status, title, lines = [], footer = '', wi
 }
 
 export function cleanTableCell(raw) {
-  if (!raw) return '';
+  if (!raw && raw !== 0) return '';
   return String(raw)
     .replace(/\[([^\]]+)\]\((https?:\/\/[^\s)]+)\)/g, (m, text, url) => {
       const t = text.trim();
       const u = url.trim();
       return t === u ? u : `${t} (${u})`;
     })
+    .replace(/<br\s*\/?>/gi, '\n')
+    .replace(/<[^>]+>/g, '')
     .replace(/\*\*/g, '')
     .replace(/`/g, '')
-    .replace(/\s+/g, ' ')
-    .trim();
+    .replace(/\r/g, '')
+    .split('\n')
+    .map(line => line.replace(/[^\S\n]+/g, ' ').trim())
+    .filter(Boolean)
+    .join('\n');
+}
+
+export function wrapTableCell(text, colWidth) {
+  if (!text && text !== 0) return [''];
+  const safeWidth = Math.max(2, colWidth);
+  const rawLines = String(text).split('\n');
+  const wrappedLines = [];
+
+  for (const rawLine of rawLines) {
+    const trimmed = rawLine.trim();
+    if (!trimmed) {
+      wrappedLines.push('');
+      continue;
+    }
+
+    const words = trimmed.split(/\s+/).filter(Boolean);
+    let currentLine = '';
+
+    for (const word of words) {
+      const testLine = currentLine ? `${currentLine} ${word}` : word;
+      if (getStringDisplayWidth(testLine) <= safeWidth) {
+        currentLine = testLine;
+      } else {
+        if (currentLine) {
+          wrappedLines.push(currentLine);
+          currentLine = '';
+        }
+        if (getStringDisplayWidth(word) > safeWidth) {
+          let chunk = '';
+          for (const item of getGraphemeSegments(word)) {
+            const itemWidth = getGraphemeDisplayWidth(item.segment);
+            if (getStringDisplayWidth(chunk) + itemWidth > safeWidth) {
+              if (chunk) wrappedLines.push(chunk);
+              chunk = item.segment;
+            } else {
+              chunk += item.segment;
+            }
+          }
+          if (chunk) {
+            currentLine = chunk;
+          }
+        } else {
+          currentLine = word;
+        }
+      }
+    }
+    if (currentLine) {
+      wrappedLines.push(currentLine);
+    }
+  }
+
+  return wrappedLines.length > 0 ? wrappedLines : [''];
 }
 
 export function formatRichTable(headers = [], rows = [], maxWidth = getFullWidth() - 4) {
   if (!headers.length && !rows.length) return [];
   const colCount = Math.max(headers.length, ...rows.map(r => r.length));
-  const colWidths = new Array(colCount).fill(4);
 
   const cleanHeaders = headers.map(cleanTableCell);
   const cleanRows = rows.map(r => r.map(cleanTableCell));
 
+  const headerWidths = new Array(colCount).fill(0);
+  const naturalWidths = new Array(colCount).fill(4);
+
   for (let c = 0; c < colCount; c++) {
-    const headerLen = getStringDisplayWidth(cleanHeaders[c] || '');
-    colWidths[c] = Math.max(colWidths[c], headerLen);
+    const hLines = (cleanHeaders[c] || '').split('\n');
+    const hMax = Math.max(...hLines.map(l => getStringDisplayWidth(l)), 0);
+    headerWidths[c] = Math.max(hMax, 4);
+    naturalWidths[c] = headerWidths[c];
+
     for (const row of cleanRows) {
-      const cellLen = getStringDisplayWidth(row[c] || '');
-      colWidths[c] = Math.max(colWidths[c], cellLen);
+      const cellLines = (row[c] || '').split('\n');
+      for (const line of cellLines) {
+        naturalWidths[c] = Math.max(naturalWidths[c], getStringDisplayWidth(line));
+      }
     }
   }
 
-  const totalVisualWidth = colWidths.reduce((sum, w) => sum + w + 3, 1);
-  if (totalVisualWidth > maxWidth) {
-    const available = Math.max(20, maxWidth - colCount * 3 - 1);
-    const sumWidths = colWidths.reduce((a, b) => a + b, 0);
-    for (let c = 0; c < colCount; c++) {
-      colWidths[c] = Math.max(6, Math.floor((colWidths[c] / sumWidths) * available));
+  const borderOverhead = 3 * colCount + 3;
+  const availableWidth = Math.max(colCount * 6, maxWidth - borderOverhead);
+
+  const colWidths = [...naturalWidths];
+  const totalNatural = colWidths.reduce((a, b) => a + b, 0);
+
+  if (totalNatural > availableWidth) {
+    const isCompact = colWidths.map(w => w <= 14);
+    const compactSum = colWidths.reduce((sum, w, i) => isCompact[i] ? sum + w : sum, 0);
+    const wideCount = isCompact.filter(c => !c).length;
+
+    if (wideCount > 0 && availableWidth > compactSum + wideCount * 8) {
+      const wideAvailable = availableWidth - compactSum;
+      const wideNaturalSum = colWidths.reduce((sum, w, i) => !isCompact[i] ? sum + w : sum, 0);
+      for (let c = 0; c < colCount; c++) {
+        if (!isCompact[c]) {
+          colWidths[c] = Math.max(headerWidths[c], Math.max(8, Math.floor((colWidths[c] / wideNaturalSum) * wideAvailable)));
+        }
+      }
+    } else {
+      for (let c = 0; c < colCount; c++) {
+        colWidths[c] = Math.max(4, Math.floor((colWidths[c] / totalNatural) * availableWidth));
+      }
     }
   }
 
+  const cleanRowsWrapped = cleanRows.map(row => {
+    return Array.from({ length: colCount }, (_, c) => wrapTableCell(row[c] || '—', colWidths[c]));
+  });
+  const hasMultiLine = cleanRowsWrapped.some(rowLines => rowLines.some(lines => lines.length > 1));
+
   const output = [];
   const topBorder = `  ┌─${colWidths.map(w => '─'.repeat(w)).join('─┬─')}─┐`;
   const midBorder = `  ├─${colWidths.map(w => '─'.repeat(w)).join('─┼─')}─┤`;
@@ -868,40 +954,47 @@ export function formatRichTable(headers = [], rows = [], maxWidth = getFullWidth
   output.push(`${C.slate}${topBorder}${C.reset}`);
 
   if (cleanHeaders.length > 0) {
-    const headerCells = [];
-    for (let c = 0; c < colCount; c++) {
-      const rawText = cleanHeaders[c] || '';
-      const textLen = getStringDisplayWidth(rawText);
-      const text = textLen > colWidths[c] && colWidths[c] > 3
-        ? fitStyledText(rawText, colWidths[c] - 1) + '…'
-        : fitStyledText(rawText, colWidths[c]);
-      const pad = Math.max(0, colWidths[c] - getStringDisplayWidth(text));
-      headerCells.push(`${C.bold}${C.gold}${text}${C.reset}${' '.repeat(pad)}`);
+    const headerLinesPerCol = Array.from({ length: colCount }, (_, c) => wrapTableCell(cleanHeaders[c] || '', colWidths[c]));
+    const maxHeaderLines = Math.max(...headerLinesPerCol.map(l => l.length), 1);
+
+    for (let lineIdx = 0; lineIdx < maxHeaderLines; lineIdx++) {
+      const headerCells = [];
+      for (let c = 0; c < colCount; c++) {
+        const text = headerLinesPerCol[c]?.[lineIdx] || '';
+        const pad = Math.max(0, colWidths[c] - getStringDisplayWidth(text));
+        headerCells.push(`${C.bold}${C.gold}${text}${C.reset}${' '.repeat(pad)}`);
+      }
+      output.push(`  ${C.slate}│${C.reset} ${headerCells.join(` ${C.slate}│${C.reset} `)} ${C.slate}│${C.reset}`);
     }
-    output.push(`  ${C.slate}│${C.reset} ${headerCells.join(` ${C.slate}│${C.reset} `)} ${C.slate}│${C.reset}`);
     output.push(`${C.slate}${midBorder}${C.reset}`);
   }
 
-  for (const row of cleanRows) {
-    const rowCells = [];
-    for (let c = 0; c < colCount; c++) {
-      const cellRaw = row[c] || '—';
-      const cellLen = getStringDisplayWidth(cellRaw);
-      const text = cellLen > colWidths[c] && colWidths[c] > 3
-        ? fitStyledText(cellRaw, colWidths[c] - 1) + '…'
-        : fitStyledText(cellRaw, colWidths[c]);
-      const pad = Math.max(0, colWidths[c] - getStringDisplayWidth(text));
-      rowCells.push(`${C.white}${text}${C.reset}${' '.repeat(pad)}`);
+  for (let rIdx = 0; rIdx < cleanRowsWrapped.length; rIdx++) {
+    const rowLinesPerCol = cleanRowsWrapped[rIdx];
+    const maxRowLines = Math.max(...rowLinesPerCol.map(l => l.length), 1);
+
+    for (let lineIdx = 0; lineIdx < maxRowLines; lineIdx++) {
+      const rowCells = [];
+      for (let c = 0; c < colCount; c++) {
+        const text = rowLinesPerCol[c]?.[lineIdx] || '';
+        const pad = Math.max(0, colWidths[c] - getStringDisplayWidth(text));
+        rowCells.push(`${C.white}${text}${C.reset}${' '.repeat(pad)}`);
+      }
+      output.push(`  ${C.slate}│${C.reset} ${rowCells.join(` ${C.slate}│${C.reset} `)} ${C.slate}│${C.reset}`);
+    }
+
+    if (hasMultiLine && rIdx < cleanRowsWrapped.length - 1) {
+      output.push(`${C.slate}${midBorder}${C.reset}`);
     }
-    output.push(`  ${C.slate}│${C.reset} ${rowCells.join(` ${C.slate}│${C.reset} `)} ${C.slate}│${C.reset}`);
   }
 
   output.push(`${C.slate}${botBorder}${C.reset}`);
   return output;
 }
 
-export function formatTerminalMarkdown(text) {
+export function formatTerminalMarkdown(text, maxWidth = getFullWidth() - 8) {
   if (!text) return '';
+  const dividerWidth = Math.max(16, Math.min(Number(maxWidth) || (getFullWidth() - 12), getFullWidth() - 12));
   return text
     .replace(/^#####?\s*(.+)$/gm, `  ${C.bold}${C.lavender}• $1${C.reset}`)
     .replace(/^####\s*(.+)$/gm, `${C.bold}${C.cyberCyan}▸ $1${C.reset}`)
@@ -916,13 +1009,17 @@ export function formatTerminalMarkdown(text) {
     .replace(/`([^`]+)`/g, `${C.cyberCyan}$1${C.reset}`)
     .replace(/^(\s*)(\d+)\.\s+/gm, `$1  ${C.gold}$2.${C.reset} `)
     .replace(/^(\s*)[*•+-]\s+/gm, `$1  ${C.sakura}•${C.reset} `)
-    .replace(/^\s*[-*_]{3,}\s*$/gm, `  ${C.slate}${'─'.repeat(Math.max(20, getFullWidth() - 6))}${C.reset}`);
+    .replace(/^\s*[-*_]{3,}\s*$/gm, `  ${C.slate}${'─'.repeat(dividerWidth)}${C.reset}`);
 }
 
 export function parseMarkdownTableRow(text) {
   const trimmed = String(text || '').trim();
   if (!trimmed.includes('|')) return null;
 
+  if (/^(\s*)[*•+->#]/.test(trimmed) || /^(\s*)\d+\.\s/.test(trimmed)) {
+    return null;
+  }
+
   const content = trimmed
     .replace(/^\|/, '')
     .replace(/\|$/, '');
@@ -959,7 +1056,7 @@ export function formatMarkdownLines(text, maxWidth = getFullWidth() - 8) {
         const rendered = formatRichTable(tableHeaders, tableRows, maxWidth);
         result.push(...rendered);
       } else {
-        result.push(formatTerminalMarkdown(`| ${tableHeaders.join(' | ')} |`));
+        result.push(formatTerminalMarkdown(expandMarkdownLinks(pendingHeaderRawLine || `| ${tableHeaders.join(' | ')} |`), maxWidth));
       }
       tableHeaders = null;
       tableRows = [];
@@ -967,6 +1064,7 @@ export function formatMarkdownLines(text, maxWidth = getFullWidth() - 8) {
   };
 
   let pendingHeader = null;
+  let pendingHeaderRawLine = null;
 
   for (let i = 0; i < lines.length; i++) {
     const rawLine = lines[i];
@@ -976,11 +1074,13 @@ export function formatMarkdownLines(text, maxWidth = getFullWidth() - 8) {
       if (cells && isMarkdownTableSeparator(cells)) {
         tableHeaders = pendingHeader.map(cleanTableCell);
         pendingHeader = null;
+        pendingHeaderRawLine = null;
         tableRows = [];
         continue;
       } else {
-        result.push(formatTerminalMarkdown(expandMarkdownLinks(`| ${pendingHeader.join(' | ')} |`)));
+        result.push(formatTerminalMarkdown(expandMarkdownLinks(pendingHeaderRawLine), maxWidth));
         pendingHeader = null;
+        pendingHeaderRawLine = null;
       }
     }
 
@@ -999,15 +1099,18 @@ export function formatMarkdownLines(text, maxWidth = getFullWidth() - 8) {
 
     if (cells && !isMarkdownTableSeparator(cells)) {
       pendingHeader = cells;
+      pendingHeaderRawLine = rawLine;
       continue;
     }
 
-    const formatted = formatTerminalMarkdown(expandMarkdownLinks(rawLine));
+    const formatted = formatTerminalMarkdown(expandMarkdownLinks(rawLine), maxWidth);
     result.push(formatted);
   }
 
   if (pendingHeader) {
-    result.push(formatTerminalMarkdown(expandMarkdownLinks(`| ${pendingHeader.join(' | ')} |`)));
+    result.push(formatTerminalMarkdown(expandMarkdownLinks(pendingHeaderRawLine), maxWidth));
+    pendingHeader = null;
+    pendingHeaderRawLine = null;
   }
   flushTable();