xshat-lite 1.0.0

package/src/modules/ui.mjs

@@ -0,0 +1,2204 @@
+import ora from 'ora';
+import { Marked } from 'marked';
+import { markedTerminal } from 'marked-terminal';
+import stringWidth from 'string-width';
+import * as color from 'yoctocolors';
+
+const COLORS = {
+  user: color.blueBright,
+  ai: color.greenBright,
+  time: color.gray,
+  text: color.whiteBright,
+  spin: color.yellowBright,
+  error: color.redBright,
+  border: color.gray,
+  reset: (text) => text
+};
+
+const ANSI_PATTERN = /\x1B\[[0-9;]*m/g;
+
+export function stripAnsi(text) {
+  return String(text ?? '').replace(ANSI_PATTERN, '');
+}
+
+export function truncateText(text, width) {
+  const plain = stripAnsi(text);
+  if (stringWidth(plain) <= width) {
+    return plain;
+  }
+
+  if (width <= 1) {
+    return plain.slice(0, 1);
+  }
+
+  let output = '';
+  for (const char of plain) {
+    if (stringWidth(output + char) > width - 1) {
+      break;
+    }
+    output += char;
+  }
+
+  return `${output}…`;
+}
+
+export function wrapText(text, width) {
+  const normalized = String(text ?? '').replace(/\r/g, '');
+
+  if (width <= 0) {
+    return [normalized];
+  }
+
+  const lines = [];
+
+  for (const block of normalized.split('\n')) {
+    if (!block) {
+      lines.push('');
+      continue;
+    }
+
+    let rest = block;
+    while (stringWidth(stripAnsi(rest)) > width) {
+      let slice = '';
+      for (const char of rest) {
+        if (stringWidth(stripAnsi(slice + char)) > width) {
+          break;
+        }
+        slice += char;
+      }
+      const breakpoint = slice.lastIndexOf(' ');
+      if (breakpoint > Math.floor(width / 2)) {
+        slice = slice.slice(0, breakpoint);
+      }
+      lines.push(slice.trimEnd());
+      rest = rest.slice(slice.length).trimStart();
+    }
+    lines.push(rest);
+  }
+
+  return lines;
+}
+
+function measureText(text) {
+  return stringWidth(stripAnsi(text));
+}
+
+export function formatKeyValueRows(rows, totalWidth = 72) {
+  const safeRows = rows.filter((row) => row && row.label);
+  const contentWidth = Math.max(36, totalWidth - 4);
+  const labelWidth = Math.min(
+    14,
+    Math.max(6, ...safeRows.map((row) => measureText(row.label)))
+  );
+  const valueWidth = Math.max(10, contentWidth - labelWidth - 3);
+  const lines = [];
+
+  for (const row of safeRows) {
+    const wrapped = wrapText(row.value || '', valueWidth);
+    wrapped.forEach((line, index) => {
+      const label = index === 0 ? truncateText(row.label, labelWidth) : '';
+      const left = label.padEnd(labelWidth, ' ');
+      const right = truncateText(line, valueWidth).padEnd(valueWidth, ' ');
+      lines.push(` ${left} │ ${right} `);
+    });
+  }
+
+  return {
+    labelWidth,
+    valueWidth,
+    lines
+  };
+}
+
+function isMarkdownTableLine(line) {
+  const trimmed = String(line ?? '').trim();
+  return trimmed.startsWith('|') && trimmed.endsWith('|') && trimmed.includes('|');
+}
+
+function isMarkdownTableSeparator(line) {
+  return /^\|\s*:?-{3,}:?\s*(\|\s*:?-{3,}:?\s*)+\|$/.test(
+    String(line ?? '').trim()
+  );
+}
+
+function splitMarkdownRow(line) {
+  return String(line ?? '')
+    .trim()
+    .slice(1, -1)
+    .split('|')
+    .map((cell) => cell.trim());
+}
+
+export function parseMarkdownTable(lines = []) {
+  if (!Array.isArray(lines) || lines.length < 2) {
+    return null;
+  }
+
+  const header = splitMarkdownRow(lines[0]);
+  const bodyLines = isMarkdownTableSeparator(lines[1]) ? lines.slice(2) : lines.slice(1);
+  const rows = bodyLines
+    .filter((line) => isMarkdownTableLine(line))
+    .map((line) => splitMarkdownRow(line));
+
+  if (header.length === 0 || rows.length === 0) {
+    return null;
+  }
+
+  return { header, rows };
+}
+
+export function formatMarkdownTable(lines = [], totalWidth = 88) {
+  const parsed = parseMarkdownTable(lines);
+  if (!parsed) {
+    return [];
+  }
+
+  const columns = parsed.header.length;
+  const availableWidth = Math.max(48, totalWidth - 4);
+  const frameWidth = 2 + columns * 3 + widthsPlaceholder(columns);
+  const minColumnWidth = columns <= 3 ? 12 : columns <= 5 ? 10 : 8;
+  const maxColumnWidth = columns <= 3 ? 36 : columns <= 5 ? 28 : 20;
+
+  const preferredWidths = parsed.header.map((cell, index) => {
+    const candidates = [cell, ...parsed.rows.map((row) => row[index] || '')];
+    return Math.min(
+      maxColumnWidth,
+      Math.max(minColumnWidth, ...candidates.map((item) => measureText(item)))
+    );
+  });
+
+  const borderWidth = 1 + columns + columns * 2;
+  const widthBudget = Math.max(columns * minColumnWidth, availableWidth - borderWidth);
+  const widths = fitColumnWidths(preferredWidths, widthBudget, minColumnWidth);
+  const preferredTotalWidth = preferredWidths.reduce((sum, width) => sum + width, 0) + borderWidth;
+
+  if (
+    (columns >= 5 && (widths.some((width) => width <= 10) || preferredTotalWidth > availableWidth)) ||
+    (columns === 4 && (widths.some((width) => width <= 9) || preferredTotalWidth > availableWidth + 4)) ||
+    (columns >= 4 && totalWidth < 96)
+  ) {
+    return formatMarkdownTableAsCards(parsed, totalWidth);
+  }
+
+  const border = `  ├${widths.map((width) => '─'.repeat(width + 2)).join('┼')}┤`;
+  const top = `  ┌${widths.map((width) => '─'.repeat(width + 2)).join('┬')}┐`;
+  const bottom = `  └${widths.map((width) => '─'.repeat(width + 2)).join('┴')}┘`;
+  const renderRow = (cells) => renderWrappedTableRow(cells, widths);
+
+  return [
+    top,
+    ...renderRow(parsed.header),
+    border,
+    ...parsed.rows.flatMap((row, index) => {
+      const rendered = renderRow(row);
+      if (index === parsed.rows.length - 1) {
+        return rendered;
+      }
+      return [...rendered, border];
+    }),
+    bottom
+  ];
+}
+
+function widthsPlaceholder(columns) {
+  return columns * 8;
+}
+
+function fitColumnWidths(preferredWidths, totalBudget, minColumnWidth) {
+  const widths = preferredWidths.map((width) => Math.max(minColumnWidth, width));
+  let total = widths.reduce((sum, width) => sum + width, 0);
+
+  while (total > totalBudget) {
+    let changed = false;
+
+    for (let index = 0; index < widths.length && total > totalBudget; index++) {
+      if (widths[index] > minColumnWidth) {
+        widths[index] -= 1;
+        total -= 1;
+        changed = true;
+      }
+    }
+
+    if (!changed) {
+      break;
+    }
+  }
+
+  return widths;
+}
+
+function renderWrappedTableRow(cells, widths) {
+  const wrappedCells = cells.map((cell, index) => {
+    const lines = wrapText(cell || '', widths[index]).map((line) => line.trimEnd());
+    return lines.length > 0 ? lines : [''];
+  });
+  const height = Math.max(...wrappedCells.map((lines) => lines.length));
+  const output = [];
+
+  for (let rowIndex = 0; rowIndex < height; rowIndex++) {
+    const line = wrappedCells.map((lines, index) => {
+      const cell = lines[rowIndex] || '';
+      const width = widths[index];
+      return padDisplay(cell, width);
+    });
+    output.push(`  │ ${line.join(' │ ')} │`);
+  }
+
+  return output;
+}
+
+function padDisplay(text, width) {
+  const plain = String(text ?? '');
+  const padding = Math.max(0, width - measureText(plain));
+  return `${plain}${' '.repeat(padding)}`;
+}
+
+function formatMarkdownTableAsCards(parsed, totalWidth = 88) {
+  const output = [];
+
+  parsed.rows.forEach((row, index) => {
+    output.push(`  [${String(index + 1).padStart(2, '0')}]`);
+    parsed.header.forEach((label, cellIndex) => {
+      const lines = wrapText(row[cellIndex] || '', Math.max(18, totalWidth - 22));
+      lines.forEach((line, lineIndex) => {
+        const left = lineIndex === 0 ? truncateText(label, 12).padEnd(12, ' ') : ' '.repeat(12);
+        output.push(`   ${left} : ${line}`);
+      });
+    });
+    if (index < parsed.rows.length - 1) {
+      output.push(`  ${'─'.repeat(Math.max(20, totalWidth - 4))}`);
+    }
+  });
+
+  return output;
+}
+
+function parseChartRows(text = '') {
+  const trimmed = String(text ?? '').trim();
+  if (!trimmed) {
+    return [];
+  }
+
+  if (trimmed.startsWith('[')) {
+    try {
+      const value = JSON.parse(trimmed);
+      if (Array.isArray(value)) {
+        return value
+          .map((item) => ({
+            label: String(item.label ?? item.name ?? '').trim(),
+            value: Number(item.value ?? item.count ?? item.score)
+          }))
+          .filter((item) => item.label && Number.isFinite(item.value));
+      }
+    } catch {
+      // ignore and continue with line-based parsing
+    }
+  }
+
+  return trimmed
+    .split('\n')
+    .map((line) => line.trim())
+    .filter(Boolean)
+    .map((line) => {
+      const match = line.match(/^(.+?)(?:\s*[,|:]\s*|\s{2,})(-?\d+(?:\.\d+)?)$/);
+      if (!match) {
+        return null;
+      }
+      return {
+        label: match[1].trim(),
+        value: Number(match[2])
+      };
+    })
+    .filter((item) => item && item.label && Number.isFinite(item.value));
+}
+
+function formatChartBlock(text = '', totalWidth = 88) {
+  const rows = parseChartRows(text);
+  if (!rows.length) {
+    return null;
+  }
+
+  const labelWidth = Math.min(
+    18,
+    Math.max(6, ...rows.map((row) => measureText(row.label)))
+  );
+  const valueWidth = Math.max(6, ...rows.map((row) => String(row.value).length));
+  const barWidth = Math.max(10, totalWidth - labelWidth - valueWidth - 12);
+  const maxValue = Math.max(...rows.map((row) => Math.abs(row.value)), 1);
+
+  return rows.map((row) => {
+    const normalized = Math.abs(row.value) / maxValue;
+    const filled = Math.max(1, Math.round(normalized * barWidth));
+    return `  ${padDisplay(truncateText(row.label, labelWidth), labelWidth)} │ ${'█'.repeat(filled).padEnd(barWidth, ' ')} │ ${String(row.value).padStart(valueWidth, ' ')}`;
+  });
+}
+
+function normalizeKeyValueLabel(label = '') {
+  return String(label ?? '')
+    .replace(/^[-*•]\s+/, '')
+    .replace(/^\d+\.\s+/, '')
+    .trim();
+}
+
+function parseKeyValueRows(lines = []) {
+  const rows = lines
+    .map((line) => {
+      const match = line.match(/^[-*•]?\s*\d*\.?\s*([^:：\n]{1,48})\s*(?:[:：]|[-—]\s+)\s*(.+)$/);
+      if (!match) {
+        return null;
+      }
+      return {
+        label: normalizeKeyValueLabel(match[1]),
+        value: String(match[2] ?? '').trim()
+      };
+    })
+    .filter((row) => row?.label && row?.value);
+
+  return rows.length >= 2 ? rows : null;
+}
+
+function parseKeyValueBlock(text = '') {
+  const normalized = String(text ?? '').replace(/\r/g, '').trim();
+  if (!normalized) {
+    return null;
+  }
+
+  const lines = normalized
+    .split('\n')
+    .map((line) => line.trim())
+    .filter(Boolean);
+
+  if (lines.length >= 2 && lines.length <= 14) {
+    const directRows = parseKeyValueRows(lines);
+    if (directRows) {
+      return directRows;
+    }
+  }
+
+  if (!normalized.includes('\n')) {
+    const segments = normalized
+      .split(/[；;]/)
+      .map((item) => item.trim())
+      .filter(Boolean);
+
+    if (segments.length >= 3 && segments.length <= 8) {
+      return parseKeyValueRows(segments);
+    }
+  }
+
+  return null;
+}
+
+export function formatAgentStepRows({
+  step,
+  maxSteps,
+  command,
+  phase = 'plan',
+  agentLabel = '',
+  multiAgent = false
+} = {}) {
+  const rows = [];
+
+  if (Number.isFinite(step) && Number.isFinite(maxSteps)) {
+    rows.push({
+      label: '步骤',
+      value: `${step}/${maxSteps}`
+    });
+  }
+
+  if (phase) {
+    rows.push({
+      label: '阶段',
+      value:
+        phase === 'plan'
+          ? '规划下一步'
+          : phase === 'execute'
+            ? '执行命令'
+            : phase === 'observe'
+              ? '读取结果'
+              : String(phase)
+    });
+  }
+
+  if (multiAgent) {
+    rows.push({
+      label: '协作',
+      value: '多 Agent'
+    });
+  }
+
+  if (agentLabel) {
+    rows.push({
+      label: '角色',
+      value: agentLabel
+    });
+  }
+
+  if (command?.name) {
+    rows.push({
+      label: '命令',
+      value: command.name
+    });
+  }
+
+  if (command?.args && Object.keys(command.args).length > 0) {
+    rows.push({
+      label: '参数',
+      value: JSON.stringify(command.args)
+    });
+  }
+
+  return rows;
+}
+
+export function summarizeAgentCommand(command = null) {
+  if (!command?.name) {
+    return '(无命令)';
+  }
+
+  const selector = command.args?.selector;
+  const text = command.args?.text;
+  const url = command.args?.url;
+  const path = command.args?.path;
+
+  if (url) {
+    return `${command.name} · ${truncateText(url, 42)}`;
+  }
+
+  if (selector && text) {
+    return `${command.name} · ${truncateText(selector, 20)} <= ${truncateText(text, 18)}`;
+  }
+
+  if (selector) {
+    return `${command.name} · ${truncateText(selector, 42)}`;
+  }
+
+  if (path) {
+    return `${command.name} · ${truncateText(path, 42)}`;
+  }
+
+  return command.name;
+}
+
+export function summarizeMessage(message = '', maxWidth = 48) {
+  const compact = String(message ?? '')
+    .replace(/\s+/g, ' ')
+    .trim();
+  if (!compact) {
+    return '(空)';
+  }
+  return truncateText(compact, maxWidth);
+}
+
+export function formatStatusBar(state = {}, totalWidth = 88) {
+  const segments = [
+    `Provider ${state.provider || '-'}`,
+    `Mode ${state.mode || '-'}`,
+    `Browser ${state.browser || '-'}`,
+    state.channel ? `Channel ${state.channel}` : '',
+    `Tasks ${state.tasks || '0'}`,
+    `Session ${state.session || '-'}`
+  ].filter(Boolean);
+
+  return truncateText(segments.join(' │ '), totalWidth - 4);
+}
+
+function isAnsiToken(token = '') {
+  return /^\x1B\[[0-9;]*m$/.test(token);
+}
+
+function clipStyledText(text, width) {
+  const value = String(text ?? '');
+  const plainWidth = stringWidth(stripAnsi(value));
+
+  if (plainWidth <= width) {
+    return value;
+  }
+
+  if (width <= 1) {
+    return '…';
+  }
+
+  const tokens = value.match(/\x1B\[[0-9;]*m|./gu) || [];
+  let output = '';
+  let visibleWidth = 0;
+
+  for (const token of tokens) {
+    if (isAnsiToken(token)) {
+      output += token;
+      continue;
+    }
+
+    const tokenWidth = stringWidth(token);
+    if (visibleWidth + tokenWidth > width - 1) {
+      break;
+    }
+
+    output += token;
+    visibleWidth += tokenWidth;
+  }
+
+  return `${output}\x1b[0m…`;
+}
+
+function padStyledText(text, width) {
+  const clipped = clipStyledText(text, width);
+  const padding = Math.max(0, width - stringWidth(stripAnsi(clipped)));
+  return `${clipped}${' '.repeat(padding)}`;
+}
+
+function wrapStyledText(text, width) {
+  const value = String(text ?? '');
+  if (width <= 0) {
+    return [value];
+  }
+
+  if (stringWidth(stripAnsi(value)) <= width) {
+    return [value];
+  }
+
+  const tokens = value.match(/\x1B\[[0-9;]*m|./gu) || [];
+  const lines = [];
+  let current = '';
+  let visibleWidth = 0;
+
+  for (const token of tokens) {
+    if (isAnsiToken(token)) {
+      current += token;
+      continue;
+    }
+
+    const tokenWidth = stringWidth(token);
+    if (visibleWidth > 0 && visibleWidth + tokenWidth > width) {
+      lines.push(current);
+      current = '';
+      visibleWidth = 0;
+    }
+
+    current += token;
+    visibleWidth += tokenWidth;
+  }
+
+  if (current || lines.length === 0) {
+    lines.push(current);
+  }
+
+  return lines;
+}
+
+function renderWorkspaceLogLine(line, width) {
+  const value = String(line ?? '');
+  const plain = stripAnsi(value);
+
+  if (!plain) {
+    return [''];
+  }
+
+  if (stringWidth(plain) <= width) {
+    return [value];
+  }
+
+  if (/^[\s]*[╭╰├┌└┐┘┬┴┼│]/u.test(plain)) {
+    return [clipStyledText(value, width)];
+  }
+
+  return wrapStyledText(value, width);
+}
+
+function buildWorkspaceInputLine({
+  prefix = 'YOU > ',
+  value = '',
+  placeholder = '',
+  cursor = 0,
+  width = 40
+} = {}) {
+  const safeWidth = Math.max(8, width);
+  const safePrefix = String(prefix ?? '');
+  const textValue = String(value ?? '');
+  const prefixWidth = stringWidth(stripAnsi(safePrefix));
+  const available = Math.max(4, safeWidth - prefixWidth);
+
+  if (!textValue) {
+    const hint = placeholder ? color.gray(truncateText(placeholder, Math.max(1, available - 1))) : '';
+    return `${safePrefix}${hint}${color.cyan('\x1b[7m \x1b[0m')}`;
+  }
+
+  const chars = Array.from(textValue);
+  const safeCursor = Math.max(0, Math.min(Number(cursor) || 0, chars.length));
+  const measureSegment = (segment) => stringWidth(segment.join(''));
+  let start = 0;
+  let end = chars.length;
+
+  while (measureSegment(chars.slice(start, end)) > available - 1 && start < safeCursor) {
+    start++;
+  }
+  while (measureSegment(chars.slice(start, end)) > available - 1 && end > safeCursor) {
+    end--;
+  }
+
+  if (start > 0) {
+    while (start > 0 && measureSegment(['…', ...chars.slice(start - 1, end)]) <= available - 1) {
+      start--;
+    }
+  }
+  if (end < chars.length) {
+    while (end < chars.length && measureSegment([...chars.slice(start, end + 1), '…']) <= available - 1) {
+      end++;
+    }
+  }
+
+  const visibleChars = chars.slice(start, end);
+  const leftEllipsis = start > 0 ? '…' : '';
+  const rightEllipsis = end < chars.length ? '…' : '';
+  const cursorInside = safeCursor >= start && safeCursor <= end;
+  const cursorOffset = cursorInside ? safeCursor - start : visibleChars.length;
+  const beforeCursor = visibleChars.slice(0, cursorOffset).join('');
+  const cursorChar = visibleChars[cursorOffset] ?? ' ';
+  const afterCursor = visibleChars.slice(cursorOffset + (cursorOffset < visibleChars.length ? 1 : 0)).join('');
+
+  return `${safePrefix}${leftEllipsis}${beforeCursor}\x1b[7m${cursorChar}\x1b[0m${afterCursor}${rightEllipsis}`;
+}
+
+function formatInlineMarkdownText(text = '') {
+  return String(text ?? '')
+    .replace(/!\[([^\]]*)\]\(([^)]+)\)/g, '$1')
+    .replace(/\[([^\]]+)\]\(([^)]+)\)/g, (_, label, href) => `${color.cyan(label)} ${color.gray(`<${href}>`)}`)
+    .replace(/`([^`]+)`/g, (_, value) => color.yellowBright(value))
+    .replace(/\*\*([^*]+)\*\*/g, (_, value) => color.whiteBright(value))
+    .replace(/__([^_]+)__/g, (_, value) => color.whiteBright(value))
+    .replace(/(?<!\*)\*([^*]+)\*(?!\*)/g, (_, value) => color.white(value))
+    .replace(/(?<!_)_([^_]+)_(?!_)/g, (_, value) => color.white(value))
+    .replace(/~~([^~]+)~~/g, (_, value) => color.gray(value));
+}
+
+function shouldRenderTextAsMarkdown(text = '') {
+  const value = String(text ?? '');
+  if (!value.trim()) {
+    return false;
+  }
+
+  return (
+    /(^|\n)```/.test(value) ||
+    /(^|\n)#{1,6}\s+/.test(value) ||
+    /(^|\n)>\s+/.test(value) ||
+    /(^|\n)[*-]\s+/.test(value) ||
+    /(^|\n)\d+\.\s+/.test(value) ||
+    /(^|\n)\|.+\|/.test(value) ||
+    /(^|\n)-{3,}($|\n)/.test(value) ||
+    /`[^`\n]+`/.test(value) ||
+    /\*\*[^*\n]+\*\*/.test(value) ||
+    /__[^_\n]+__/.test(value) ||
+    /~~[^~\n]+~~/.test(value) ||
+    /\[[^\]]+\]\([^)]+\)/.test(value) ||
+    /(?<!\*)\*[^*\n]+\*(?!\*)/.test(value) ||
+    /(?<!_)_[^_\n]+_(?!_)/.test(value)
+  );
+}
+
+function buildPanelLines(title, lines = [], width) {
+  const safeWidth = Math.max(24, width);
+  const innerWidth = safeWidth - 4;
+  const top = `╭${'─'.repeat(safeWidth - 2)}╮`;
+  const bottom = `╰${'─'.repeat(safeWidth - 2)}╯`;
+  const titleLine = ` ${truncateText(title, innerWidth - 1)}`;
+  const body = [titleLine, ...lines]
+    .flatMap((line) => wrapText(String(line ?? ''), innerWidth).map((part) => ` ${formatInlineMarkdownText(part)}`))
+    .map((line) => `│${line}${' '.repeat(Math.max(0, innerWidth - measureText(line)))} │`);
+
+  return [top, ...body, bottom];
+}
+
+function buildKeyValueTableLines(title, rows = [], width) {
+  const safeWidth = Math.max(28, width);
+  const top = `╭${'─'.repeat(safeWidth - 2)}╮`;
+  const divider = `├${'─'.repeat(safeWidth - 2)}┤`;
+  const bottom = `╰${'─'.repeat(safeWidth - 2)}╯`;
+  const titleLine = ` ${truncateText(title, safeWidth - 4)}`;
+  const titleRow = `│${titleLine}${' '.repeat(Math.max(0, safeWidth - 3 - measureText(titleLine)))}│`;
+  const formatted = formatKeyValueRows(rows, safeWidth);
+  const body = formatted.lines.map((line) => `│${line}│`);
+  return [top, titleRow, divider, ...body, bottom];
+}
+
+function buildCompactSectionLines(title, {
+  rows = [],
+  lines = []
+} = {}, width) {
+  const safeWidth = Math.max(18, width);
+  const output = [];
+  const header = color.greenBright(truncateText(title, safeWidth));
+  output.push(header);
+  output.push(color.gray('─'.repeat(Math.max(6, Math.min(safeWidth, 14)))));
+
+  if (Array.isArray(rows) && rows.length > 0) {
+    for (const row of rows) {
+      if (!row?.label) {
+        continue;
+      }
+      const label = color.gray(truncateText(`${row.label}`, safeWidth));
+      const wrapped = wrapText(String(row.value ?? ''), Math.max(10, safeWidth - 2));
+      if (wrapped.length === 0) {
+        output.push(`${label}`);
+        continue;
+      }
+      output.push(`${label}`);
+      wrapped.forEach((line) => {
+        output.push(`  ${formatInlineMarkdownText(line.trimEnd())}`);
+      });
+    }
+  } else if (Array.isArray(lines) && lines.length > 0) {
+    for (const line of lines) {
+      const wrapped = wrapText(String(line ?? ''), Math.max(10, safeWidth));
+      output.push(...wrapped.map((item) => formatInlineMarkdownText(item.trimEnd())));
+    }
+  }
+
+  return output;
+}
+
+function buildLightSectionLines(title, lines = [], width = 72) {
+  const safeWidth = Math.max(24, width);
+  const output = [
+    color.greenBright(title),
+    color.gray('─'.repeat(Math.max(8, Math.min(safeWidth, Math.max(12, measureText(title) + 2)))))
+  ];
+
+  for (const rawLine of lines) {
+    const wrapped = wrapText(String(rawLine ?? ''), Math.max(20, safeWidth - 2));
+    output.push(...wrapped.map((line) => `  ${formatInlineMarkdownText(line)}`));
+  }
+
+  return output;
+}
+
+function buildLightKeyValueLines(title, rows = [], width = 72) {
+  const safeRows = Array.isArray(rows) ? rows.filter((row) => row && row.label) : [];
+  const safeWidth = Math.max(28, width);
+  const labelWidth = Math.min(
+    14,
+    Math.max(6, ...safeRows.map((row) => measureText(row.label)))
+  );
+  const inlineValueWidth = Math.max(16, safeWidth - labelWidth - 8);
+  const preferStackedByWidth = safeWidth < 76 || safeRows.length >= 5;
+  const useStackedLayout = safeRows.some((row) => {
+    const value = String(row.value ?? '');
+    return (
+      preferStackedByWidth ||
+      value.includes('\n') ||
+      /^https?:\/\//i.test(value) ||
+      measureText(value) > Math.max(24, inlineValueWidth + 4)
+    );
+  });
+  const output = [
+    color.greenBright(title),
+    color.gray('─'.repeat(Math.max(8, Math.min(safeWidth, Math.max(12, measureText(title) + 2)))))
+  ];
+
+  if (useStackedLayout) {
+    safeRows.forEach((row, rowIndex) => {
+      const label = color.gray(truncateText(row.label, safeWidth - 2));
+      output.push(`  ${label}`);
+
+      const wrapped = wrapText(
+        String(row.value ?? ''),
+        Math.max(20, safeWidth - 4)
+      );
+
+      wrapped.forEach((line) => {
+        output.push(`    ${formatInlineMarkdownText(line)}`);
+      });
+
+      if (rowIndex < safeRows.length - 1) {
+        output.push('');
+      }
+    });
+
+    return output;
+  }
+
+  for (const row of safeRows) {
+    const wrapped = wrapText(String(row.value ?? ''), inlineValueWidth);
+    wrapped.forEach((line, index) => {
+      const label = index === 0
+        ? color.gray(padDisplay(truncateText(row.label, labelWidth), labelWidth))
+        : ' '.repeat(labelWidth);
+      const separator = index === 0 ? color.gray(' │ ') : '   ';
+      output.push(`  ${label}${separator}${formatInlineMarkdownText(line)}`);
+    });
+  }
+
+  return output;
+}
+
+function wrapCodeLine(text, width) {
+  const value = String(text ?? '').replace(/\r/g, '');
+  if (width <= 0) {
+    return [value];
+  }
+
+  if (measureText(value) <= width) {
+    return [value];
+  }
+
+  const lines = [];
+  let rest = value;
+
+  while (measureText(rest) > width) {
+    let slice = '';
+    for (const char of rest) {
+      if (measureText(slice + char) > width) {
+        break;
+      }
+      slice += char;
+    }
+    lines.push(slice);
+    rest = rest.slice(slice.length);
+  }
+
+  lines.push(rest);
+  return lines;
+}
+
+function buildCodeBlockLines(lines = [], width = 72, language = '') {
+  const safeWidth = Math.max(24, width);
+  const title = language ? `Code · ${language}` : 'Code';
+  const output = [
+    color.yellowBright(title),
+    color.gray('─'.repeat(Math.max(8, Math.min(safeWidth, Math.max(12, measureText(title) + 2)))))
+  ];
+
+  const contentWidth = Math.max(16, safeWidth - 6);
+  const safeLines = Array.isArray(lines) && lines.length > 0 ? lines : [''];
+
+  for (const rawLine of safeLines) {
+    const wrapped = wrapCodeLine(rawLine, contentWidth);
+    if (!wrapped.length) {
+      output.push(`${color.gray('  ▏')}`);
+      continue;
+    }
+
+    wrapped.forEach((line) => {
+      output.push(`${color.gray('  ▏')} ${color.white(line)}`);
+    });
+  }
+
+  return output;
+}
+
+function buildNoticeLines(kind = 'info', message = '', width = 72) {
+  const safeWidth = Math.max(24, width);
+  const normalized = String(message ?? '').replace(/\r/g, '').trim();
+  const theme = {
+    info: {
+      badge: color.cyan('i'),
+      text: color.cyan
+    },
+    muted: {
+      badge: color.gray('·'),
+      text: color.gray
+    },
+    success: {
+      badge: color.greenBright('✓'),
+      text: color.greenBright
+    },
+    warning: {
+      badge: color.yellowBright('!'),
+      text: color.yellowBright
+    },
+    error: {
+      badge: color.redBright('×'),
+      text: color.redBright
+    }
+  }[kind] || {
+    badge: color.cyan('i'),
+    text: color.cyan
+  };
+
+  const prefix = `  ${theme.badge} `;
+  const continuation = '    ';
+  const contentWidth = Math.max(18, safeWidth - measureText(prefix) - 1);
+  const wrapped = wrapText(normalized || '', contentWidth);
+
+  return wrapped.map((line, index) => {
+    const currentPrefix = index === 0 ? prefix : continuation;
+    return `${currentPrefix}${theme.text(line)}`;
+  });
+}
+
+function buildQuoteBlockLines(lines = [], width = 72) {
+  const safeWidth = Math.max(24, width);
+  const contentWidth = Math.max(16, safeWidth - 6);
+  const safeLines = Array.isArray(lines) ? lines.filter(Boolean) : [];
+  const output = [];
+
+  for (const rawLine of safeLines) {
+    const plain = String(rawLine ?? '').replace(/^>\s*/, '').trim();
+    if (!plain) {
+      output.push(color.gray('  ▎'));
+      continue;
+    }
+
+    const wrapped = wrapText(plain, contentWidth);
+    wrapped.forEach((line, index) => {
+      const prefix = index === 0 ? '  ▎ ' : '    ';
+      const painter =
+        /^(注意|提示|说明|建议|结论)[:：]?/i.test(plain)
+          ? color.yellowBright
+          : color.gray;
+      output.push(`${color.gray(prefix)}${painter(formatInlineMarkdownText(line))}`);
+    });
+  }
+
+  return output;
+}
+
+function detectSemanticLead(text = '') {
+  const value = String(text ?? '').trim();
+  const match = value.match(/^(结论|建议|注意|提示|说明|风险|原因|观察|下一步|重点)[:：]\s*(.+)$/);
+  if (!match) {
+    return null;
+  }
+
+  const label = match[1];
+  const content = match[2];
+  const kind =
+    label === '注意' || label === '风险'
+      ? 'warning'
+      : label === '结论' || label === '重点'
+        ? 'success'
+        : 'info';
+
+  return {
+    label,
+    content,
+    kind
+  };
+}
+
+function buildListBlockLines(lines = [], width = 72, ordered = false) {
+  const safeWidth = Math.max(24, width);
+  const output = [];
+
+  lines.forEach((rawLine, itemIndex) => {
+    const trimmed = String(rawLine ?? '').trim();
+    const match = ordered
+      ? trimmed.match(/^(\d+\.)\s+(.*)$/)
+      : trimmed.match(/^[-*]\s+(.*)$/);
+    const bullet = ordered
+      ? `${match?.[1] || `${itemIndex + 1}.`} `
+      : '• ';
+    const content = ordered
+      ? match?.[2] || trimmed
+      : match?.[1] || trimmed.replace(/^[-*]\s+/, '');
+    const wrapped = wrapText(content, Math.max(20, safeWidth - 4));
+
+    wrapped.forEach((line, lineIndex) => {
+      const prefix = lineIndex === 0 ? `  ${bullet}` : `  ${' '.repeat(bullet.length)}`;
+      output.push(`${prefix}${formatInlineMarkdownText(line)}`);
+    });
+
+    if (itemIndex < lines.length - 1) {
+      output.push('');
+    }
+  });
+
+  return output;
+}
+
+function buildMarkdownLines(text = '', width = 72) {
+  const normalized = String(text ?? '').replace(/\r/g, '');
+  const chartBlock = formatChartBlock(normalized, width);
+  if (chartBlock) {
+    return chartBlock;
+  }
+
+  const keyValueBlock = parseKeyValueBlock(normalized);
+  if (keyValueBlock) {
+    return buildLightKeyValueLines('结果', keyValueBlock, width);
+  }
+
+  const lines = normalized.split('\n');
+  const output = [];
+  let index = 0;
+
+  while (index < lines.length) {
+    const line = lines[index];
+    const trimmed = line.trim();
+
+    if (!trimmed) {
+      output.push('');
+      index++;
+      continue;
+    }
+
+    if (isMarkdownTableLine(trimmed)) {
+      const tableLines = [];
+      while (index < lines.length && isMarkdownTableLine(lines[index].trim())) {
+        tableLines.push(lines[index].trim());
+        index++;
+      }
+      output.push(...formatMarkdownTable(tableLines, width));
+      output.push('');
+      continue;
+    }
+
+    if (/^```/.test(trimmed)) {
+      const language = trimmed.replace(/^```/, '').trim();
+      const codeLines = [];
+      index++;
+      while (index < lines.length && !/^```/.test(lines[index].trim())) {
+        codeLines.push(lines[index]);
+        index++;
+      }
+      if (index < lines.length && /^```/.test(lines[index].trim())) {
+        index++;
+      }
+      output.push(...buildCodeBlockLines(codeLines, width, language));
+      output.push('');
+      continue;
+    }
+
+    if (/^-{3,}$/.test(trimmed)) {
+      output.push(color.gray('─'.repeat(Math.max(8, Math.min(width, 24)))));
+      output.push('');
+      index++;
+      continue;
+    }
+
+    if (/^>\s+/.test(trimmed)) {
+      const quoteLines = [];
+      while (index < lines.length && /^>\s+/.test(lines[index].trim())) {
+        quoteLines.push(lines[index].trim());
+        index++;
+      }
+      output.push(...buildQuoteBlockLines(quoteLines, width));
+      output.push('');
+      continue;
+    }
+
+    if (/^[-*]\s+/.test(trimmed)) {
+      const listLines = [];
+      while (index < lines.length && /^[-*]\s+/.test(lines[index].trim())) {
+        listLines.push(lines[index].trim());
+        index++;
+      }
+      output.push(...buildListBlockLines(listLines, width, false));
+      output.push('');
+      continue;
+    }
+
+    if (/^\d+\.\s+/.test(trimmed)) {
+      const listLines = [];
+      while (index < lines.length && /^\d+\.\s+/.test(lines[index].trim())) {
+        listLines.push(lines[index].trim());
+        index++;
+      }
+      output.push(...buildListBlockLines(listLines, width, true));
+      output.push('');
+      continue;
+    }
+
+    if (/^#{1,6}\s+/.test(trimmed)) {
+      output.push(color.greenBright(formatInlineMarkdownText(trimmed.replace(/^#{1,6}\s+/, ''))));
+      output.push('');
+      index++;
+      continue;
+    }
+
+    const semanticLead = detectSemanticLead(trimmed);
+    if (semanticLead) {
+      output.push(...buildNoticeLines(semanticLead.kind, `${semanticLead.label}: ${semanticLead.content}`, width));
+      output.push('');
+      index++;
+      continue;
+    }
+
+    const paragraph = [];
+    while (
+      index < lines.length &&
+      lines[index].trim() &&
+      !isMarkdownTableLine(lines[index].trim()) &&
+      !/^```/.test(lines[index].trim()) &&
+      !/^-{3,}$/.test(lines[index].trim()) &&
+      !/^>\s+/.test(lines[index].trim()) &&
+      !/^[-*]\s+/.test(lines[index].trim()) &&
+      !/^\d+\.\s+/.test(lines[index].trim()) &&
+      !/^#{1,6}\s+/.test(lines[index].trim()) &&
+      !detectSemanticLead(lines[index].trim())
+    ) {
+      paragraph.push(lines[index].trim());
+      index++;
+    }
+    output.push(...wrapText(paragraph.join(' '), Math.max(20, width)).map((line) => formatInlineMarkdownText(line)));
+    output.push('');
+  }
+
+  while (output.length > 0 && !output.at(-1)) {
+    output.pop();
+  }
+
+  return output;
+}
+
+class UI {
+  constructor() {
+    this.spinner = null;
+    this.stdoutLineOpen = false;
+    this.lastTimelineSignature = '';
+    this.lastStatusSignature = '';
+    this.pinnedHeaderActive = false;
+    this.pinnedHeaderHeight = 0;
+    this.lastPinnedHeaderSignature = '';
+    this.workspace = {
+      active: false,
+      title: 'XShat Workspace',
+      status: '',
+      hints: [],
+      leftSections: [],
+      rightSections: [],
+      logLines: [],
+      footer: '',
+      inputLabel: 'YOU > ',
+      inputPlaceholder: '输入消息后回车发送',
+      inputValue: '',
+      inputCursor: 0
+    };
+  }
+
+  getTime() {
+    return new Date().toLocaleTimeString('zh-CN', { hour12: false });
+  }
+
+  clear() {
+    this.clearPinnedHeader();
+    if (this.workspace.active) {
+      this.workspace.logLines = [];
+      this.renderWorkspace();
+      return;
+    }
+    console.clear();
+  }
+
+  getWidth() {
+    return Math.min(Math.max(process.stdout.columns || 88, 60), 120);
+  }
+
+  getWorkspaceDimensions() {
+    const totalWidth = Math.max(96, process.stdout.columns || 120);
+
+    if (totalWidth >= 180) {
+      return {
+        totalWidth,
+        leftWidth: 24,
+        rightWidth: 26,
+        showLeft: true,
+        showRight: true,
+        gapWidth: 2
+      };
+    }
+
+    if (totalWidth >= 150) {
+      return {
+        totalWidth,
+        leftWidth: 22,
+        rightWidth: 24,
+        showLeft: true,
+        showRight: true,
+        gapWidth: 2
+      };
+    }
+
+    if (totalWidth >= 130) {
+      return {
+        totalWidth,
+        leftWidth: 20,
+        rightWidth: 18,
+        showLeft: true,
+        showRight: true,
+        gapWidth: 2
+      };
+    }
+
+    if (totalWidth >= 112) {
+      return {
+        totalWidth,
+        leftWidth: 18,
+        rightWidth: 0,
+        showLeft: true,
+        showRight: false,
+        gapWidth: 2
+      };
+    }
+
+    return {
+      totalWidth,
+      leftWidth: 0,
+      rightWidth: 0,
+      showLeft: false,
+      showRight: false,
+      gapWidth: 1
+    };
+  }
+
+  colorize(color, text) {
+    const formatter = COLORS[color] || COLORS.reset;
+    return formatter(String(text ?? ''));
+  }
+
+  markLineStateFromText(text) {
+    const value = String(text ?? '');
+    if (!value) {
+      return;
+    }
+    this.stdoutLineOpen = !value.endsWith('\n');
+  }
+
+  ensureTrailingNewline() {
+    if (this.workspace.active) {
+      return;
+    }
+
+    if (this.stdoutLineOpen) {
+      process.stdout.write('\n');
+      this.stdoutLineOpen = false;
+    }
+  }
+
+  printPrompt() {
+    if (this.workspace.active) {
+      const totalRows = Math.max(20, process.stdout.rows || 30);
+      const row = Math.max(3, totalRows);
+      const prefix = `${this.colorize('time', `[${this.getTime()}]`)} ${this.colorize('user', this.workspace.inputLabel || 'YOU > ')}`;
+      return `\x1b[2K\x1b[${row};2H${prefix}`;
+    }
+    const timeStr = this.colorize('time', `[${this.getTime()}]`);
+    const userStr = this.colorize('user', 'YOU > ');
+    return `${timeStr} ${userStr}`;
+  }
+
+  printUserMessage(message) {
+    const value = String(message ?? '');
+
+    if (this.workspace.active) {
+      this.appendWorkspaceLines(buildPanelLines('YOU', value.split('\n'), this.getWorkspaceMainWidth()));
+      return;
+    }
+
+    if (value.includes('\n')) {
+      this.printNewline();
+      this.printPanel('YOU', value.split('\n'));
+      return;
+    }
+
+    process.stdout.moveCursor(0, -1);
+    process.stdout.clearLine(0);
+    const timeStr = this.colorize('time', `[${this.getTime()}]`);
+    const userStr = this.colorize('user', `YOU > ${value}`);
+    process.stdout.write(`${timeStr} ${userStr}\n`);
+    this.stdoutLineOpen = false;
+  }
+
+  printAIPrefix() {
+    if (this.workspace.active) {
+      return;
+    }
+    const timeStr = this.colorize('time', `[${this.getTime()}]`);
+    const aiStr = this.colorize('ai', 'AI  > ');
+    process.stdout.write(`${timeStr} ${aiStr}`);
+    this.stdoutLineOpen = true;
+  }
+
+  startSpinner() {
+    if (this.workspace.active) {
+      this.workspace.footer = 'AI 正在思考中...';
+      this.renderWorkspace();
+      return;
+    }
+    this.stopSpinner();
+    this.spinner = ora({
+      text: `${this.colorize('time', `[${this.getTime()}]`)} ${this.colorize('ai', 'AI  >')} ${this.colorize('spin', '思考中...')}`,
+      stream: process.stdout,
+      discardStdin: false
+    }).start();
+  }
+
+  stopSpinner() {
+    if (this.workspace.active) {
+      this.workspace.footer = '';
+      this.renderWorkspace();
+      return;
+    }
+    if (this.spinner) {
+      this.spinner.stop();
+      this.spinner = null;
+      process.stdout.cursorTo(0);
+      process.stdout.clearLine(0);
+      this.stdoutLineOpen = false;
+    }
+  }
+
+  printText(text) {
+    if (this.workspace.active) {
+      this.appendWorkspaceLines([String(text ?? '')]);
+      return;
+    }
+    const rendered = this.colorize('text', text);
+    process.stdout.write(rendered);
+    this.markLineStateFromText(rendered);
+  }
+
+  printInlineMarkdown(text, options = {}) {
+    const streaming = Boolean(options.streaming);
+    const normalized = String(text ?? '')
+      .replace(/\r/g, '')
+      .replace(/^#{1,6}\s+/gm, '')
+      .replace(/^>\s+/gm, '')
+      .replace(/^[-*]\s+/gm, '• ')
+      .replace(/^(\d+)\.\s+/gm, '$1. ')
+      .replace(/\n+/g, ' ');
+    const value = streaming
+      ? normalized
+        .replace(/[`*_~]+/g, '')
+      : formatInlineMarkdownText(normalized);
+    this.printText(value);
+  }
+
+  writeWrappedText(text, {
+    indent = '  ',
+    bullet = '',
+    color = 'text'
+  } = {}) {
+    const width = this.getWidth() - stripAnsi(indent).length - stripAnsi(bullet).length;
+    const lines = wrapText(text, Math.max(20, width));
+
+    lines.forEach((line, index) => {
+      const prefix = index === 0 ? `${indent}${bullet}` : `${indent}${' '.repeat(stripAnsi(bullet).length)}`;
+      process.stdout.write(
+        `${this.colorize(color, `${prefix}${line}`)}\n`
+      );
+    });
+  }
+
+  printNewline() {
+    if (this.workspace.active) {
+      this.appendWorkspaceLines(['']);
+      return;
+    }
+    process.stdout.write('\n');
+    this.stdoutLineOpen = false;
+  }
+
+  printError(message) {
+    if (this.workspace.active) {
+      this.appendWorkspaceLines([`ERROR: ${message}`]);
+      return;
+    }
+    const lines = buildNoticeLines('error', message, this.getWidth() - 2);
+    process.stdout.write(`\r${lines.join('\n')}\n`);
+    this.stdoutLineOpen = false;
+  }
+
+  printWarning(message) {
+    if (this.workspace.active) {
+      this.appendWorkspaceLines([`⚠ ${message}`]);
+      return;
+    }
+    const lines = buildNoticeLines('warning', message, this.getWidth() - 2);
+    process.stdout.write(`\r${lines.join('\n')}\n`);
+    this.stdoutLineOpen = false;
+  }
+
+  printTitle(title) {
+    if (this.workspace.active) {
+      this.appendWorkspaceLines([`== ${title} ==`]);
+      return;
+    }
+    const width = this.getWidth();
+    const plain = truncateText(title, width - 6);
+    const rule = '─'.repeat(Math.max(8, width - stripAnsi(plain).length - 4));
+    process.stdout.write(
+      `\n${this.colorize('ai', `╭─ ${plain} `)}${this.colorize('border', rule)}\n`
+    );
+    this.stdoutLineOpen = false;
+  }
+
+  printSeparator() {
+    if (this.workspace.active) {
+      this.appendWorkspaceLines(['─'.repeat(this.getWorkspaceMainWidth())]);
+      return;
+    }
+    process.stdout.write(`${this.colorize('border', '─'.repeat(this.getWidth()))}\n`);
+    this.stdoutLineOpen = false;
+  }
+
+  printMenuItem(key, label, hint = '') {
+    const keyStr = this.colorize('spin', `[${key}]`);
+    const labelStr = this.colorize('text', label);
+    const hintStr = hint ? ` ${this.colorize('time', hint)}` : '';
+    process.stdout.write(`  ${keyStr} ${labelStr}${hintStr}\n`);
+    this.stdoutLineOpen = false;
+  }
+
+  printInfo(message) {
+    if (this.workspace.active) {
+      this.appendWorkspaceLines([String(message ?? '')]);
+      return;
+    }
+    const lines = buildNoticeLines('info', String(message ?? ''), this.getWidth() - 2);
+    process.stdout.write(`${lines.join('\n')}\n`);
+    this.stdoutLineOpen = false;
+  }
+
+  printMuted(message) {
+    if (this.workspace.active) {
+      this.appendWorkspaceLines([String(message ?? '')]);
+      return;
+    }
+    const lines = buildNoticeLines('muted', String(message ?? ''), this.getWidth() - 2);
+    process.stdout.write(`${lines.join('\n')}\n`);
+    this.stdoutLineOpen = false;
+  }
+
+  printSuccess(message) {
+    if (this.workspace.active) {
+      this.appendWorkspaceLines([`✓ ${message}`]);
+      return;
+    }
+    const lines = buildNoticeLines('success', String(message ?? ''), this.getWidth() - 2);
+    process.stdout.write(`${lines.join('\n')}\n`);
+    this.stdoutLineOpen = false;
+  }
+
+  printPromptLine() {
+    process.stdout.write(this.colorize('spin', '❯ '));
+    this.stdoutLineOpen = true;
+  }
+
+  supportsPinnedHeader() {
+    return Boolean(
+      process.stdout.isTTY &&
+      Number.isFinite(process.stdout.rows) &&
+      process.stdout.rows >= 8
+    );
+  }
+
+  moveCursorTo(row = 1, column = 1) {
+    process.stdout.write(`\x1b[${Math.max(1, row)};${Math.max(1, column)}H`);
+  }
+
+  resetScrollRegion() {
+    if (!process.stdout.isTTY) {
+      return;
+    }
+    process.stdout.write('\x1b[r');
+  }
+
+  clearPinnedHeader() {
+    if (!this.pinnedHeaderActive && !this.lastPinnedHeaderSignature) {
+      return;
+    }
+
+    this.resetScrollRegion();
+    this.pinnedHeaderActive = false;
+    this.pinnedHeaderHeight = 0;
+    this.lastPinnedHeaderSignature = '';
+  }
+
+  renderPinnedHeader(lines = []) {
+    if (!this.supportsPinnedHeader() || !Array.isArray(lines) || lines.length === 0) {
+      return false;
+    }
+
+    const terminalRows = process.stdout.rows || 0;
+    const normalized = lines
+      .map((line) => truncateText(String(line ?? '').replace(/\r?\n/g, ' '), this.getWidth() - 2))
+      .filter(Boolean);
+
+    if (!normalized.length || terminalRows <= normalized.length + 1) {
+      return false;
+    }
+
+    const signature = JSON.stringify(normalized);
+    const bodyTop = normalized.length + 1;
+
+    if (this.pinnedHeaderActive && signature === this.lastPinnedHeaderSignature) {
+      return true;
+    }
+
+    this.stopSpinner();
+    process.stdout.write('\x1b7');
+    this.resetScrollRegion();
+
+    const rowsToRender = Math.max(this.pinnedHeaderHeight, normalized.length);
+    for (let index = 0; index < rowsToRender; index++) {
+      this.moveCursorTo(index + 1, 1);
+      process.stdout.clearLine(0);
+      if (index < normalized.length) {
+        process.stdout.write(this.colorize('time', `  ${normalized[index]}`));
+      }
+    }
+
+    process.stdout.write(`\x1b[${bodyTop};${terminalRows}r`);
+    process.stdout.write('\x1b8');
+
+    this.pinnedHeaderActive = true;
+    this.pinnedHeaderHeight = normalized.length;
+    this.lastPinnedHeaderSignature = signature;
+    return true;
+  }
+
+  renderChatChrome(state = {}, hints = []) {
+    const lines = [formatStatusBar(state, this.getWidth())];
+    if (Array.isArray(hints) && hints.length > 0) {
+      lines.push(hints.filter(Boolean).join('  ·  '));
+    }
+
+    return this.renderPinnedHeader(lines);
+  }
+
+  printStatusBar(state = {}) {
+    const line = formatStatusBar(state, this.getWidth());
+    process.stdout.write(`${this.colorize('time', `  ${line}`)}\n`);
+  }
+
+  printInputHints(hints = []) {
+    if (this.workspace.active) {
+      this.workspace.hints = Array.isArray(hints) ? hints.filter(Boolean) : [];
+      this.renderWorkspace();
+      return;
+    }
+    if (!Array.isArray(hints) || hints.length === 0) {
+      return;
+    }
+
+    const line = hints
+      .filter(Boolean)
+      .map((item) => this.colorize('time', item))
+      .join(this.colorize('border', '  ·  '));
+    process.stdout.write(`  ${line}\n`);
+  }
+
+  printSelectableList(title, items = [], selectedIndex = 0) {
+    if (!Array.isArray(items) || items.length === 0) {
+      this.printInfo('(暂无条目)');
+      return;
+    }
+
+    const lines = items.map((item, index) => {
+      const marker = index === selectedIndex
+        ? this.colorize('ai', '›')
+        : this.colorize('time', ' ');
+      return `${marker} ${item}`;
+    });
+
+    this.printPanel(title, lines);
+  }
+
+  printChatHelp(agentMode = false) {
+    const rows = [
+      { label: '/h', value: '等价于 /help' },
+      { label: '/s', value: '等价于 /status' },
+      { label: '/t', value: '等价于 /task' },
+      { label: '/m', value: '等价于 /menu' },
+      { label: '/paste', value: '进入多行粘贴模式' },
+      { label: '/status', value: '打开运行状态与推荐操作' },
+      { label: '/memory', value: '查看当前会话记忆' },
+      { label: '/pin', value: '把一条信息固定到会话记忆' },
+      { label: '/retry-last', value: '重试上一条已发送消息' },
+      { label: '/plan', value: '查看当前提炼出的轻量计划' },
+      { label: '/sessions', value: '打开历史会话浏览器' },
+      { label: '/resume', value: '恢复最近一条历史会话' },
+      { label: '/switch-provider', value: '切换当前会话使用的提供方' },
+      { label: '/model', value: '切换当前会话提供方或打开默认提供方设置' },
+      { label: '/rename-session', value: '修改当前会话标题' },
+      { label: '/delete-session', value: '删除当前会话' },
+      { label: '/task', value: '打开任务面板' },
+      { label: '/mode', value: '切换普通模式 / Agent 模式' },
+      { label: '/inspect', value: '检查当前网页适配状态' },
+      { label: '/config', value: '打开系统设置并调整默认提供方' },
+      { label: '/doc', value: '查看简要文档' },
+      { label: '/menu', value: '返回主菜单' },
+      { label: '/quit', value: '退出程序'}
+    ];
+
+    if (agentMode) {
+      rows.splice(4, 0, { label: '/agent', value: '需要登录或验证时人工接管' });
+    }
+
+    this.printKeyValueTable('聊天命令', rows);
+  }
+
+  printMarkdown(text) {
+    if (this.workspace.active) {
+      this.appendWorkspaceLines(buildMarkdownLines(text, this.getWorkspaceMainWidth()));
+      return;
+    }
+
+    for (const line of buildMarkdownLines(text, this.getWidth() - 2)) {
+      process.stdout.write(`${this.colorize('text', line)}\n`);
+    }
+    this.stdoutLineOpen = false;
+  }
+
+  printMarkdownRich(text) {
+    this.printMarkdown(text);
+  }
+
+  printPanel(title, lines = []) {
+    if (this.workspace.active) {
+      this.appendWorkspaceLines(buildPanelLines(title, lines, this.getWorkspaceMainWidth()));
+      return;
+    }
+    const rendered = buildLightSectionLines(title, lines, this.getWidth() - 2)
+      .map((line) => this.colorize('text', line))
+      .join('\n');
+    process.stdout.write(`${rendered}\n`);
+    this.stdoutLineOpen = false;
+  }
+
+  printKeyValueTable(title, rows = []) {
+    if (this.workspace.active) {
+      this.appendWorkspaceLines(buildKeyValueTableLines(title, rows, this.getWorkspaceMainWidth()));
+      return;
+    }
+    const rendered = buildLightKeyValueLines(title, rows, this.getWidth() - 2)
+      .join('\n');
+    process.stdout.write(`${rendered}\n`);
+    this.stdoutLineOpen = false;
+  }
+
+  printAgentStep({
+    step,
+    maxSteps,
+    command,
+    phase = 'plan',
+    agentLabel = '',
+    multiAgent = false
+  } = {}) {
+    const title =
+      phase === 'execute'
+        ? 'Agent 执行中'
+        : phase === 'observe'
+          ? 'Agent 读取结果'
+          : 'Agent 下一步';
+
+    this.printKeyValueTable(title, formatAgentStepRows({
+      step,
+      maxSteps,
+      command,
+      phase,
+      agentLabel,
+      multiAgent
+    }));
+  }
+
+  printSessionList(sessions, page = 1, pageSize = 10) {
+    if (sessions.length === 0) {
+      this.printInfo('(没有匹配的聊天记录)');
+      return { hasMore: false, totalPages: 0 };
+    }
+
+    const start = (page - 1) * pageSize;
+    const end = start + pageSize;
+    const pageSessions = sessions.slice(start, end);
+    const totalPages = Math.ceil(sessions.length / pageSize);
+    const width = this.getWidth();
+    const titleWidth = Math.max(16, width - 34);
+
+    this.printKeyValueTable('会话列表', pageSessions.map((s, i) => {
+      const globalIndex = start + i + 1;
+      const date = new Date(s.updatedAt).toLocaleString('zh-CN', {
+        month: '2-digit',
+        day: '2-digit',
+        hour: '2-digit',
+        minute: '2-digit',
+        hour12: false
+      });
+
+      return {
+        label: `[${String(globalIndex).padStart(2)}]`,
+        value: `${truncateText(s.title, titleWidth)} | ${s.provider} | ${s.messageCount}条 | ${date}`
+      };
+    }));
+
+    if (totalPages > 1) {
+      this.printNewline();
+      this.printInfo(`第 ${page}/${totalPages} 页（共 ${sessions.length} 条）`);
+    }
+
+    return { hasMore: end < sessions.length, totalPages };
+  }
+
+  printSessionPreview(session, details = null) {
+    if (!session) {
+      return;
+    }
+
+    const rows = [
+      { label: '提供方', value: session.provider || '(未知)' },
+      Array.isArray(session.providerHistory) && session.providerHistory.length > 1
+        ? {
+          label: '切换轨迹',
+          value: session.providerHistory.map((item) => item.provider).join(' -> ')
+        }
+        : null,
+      {
+        label: '最后更新',
+        value: session.updatedAt
+          ? new Date(session.updatedAt).toLocaleString('zh-CN', { hour12: false })
+          : '(未知)'
+      },
+      { label: '消息数', value: String(session.messageCount ?? details?.messages?.length ?? 0) }
+    ];
+
+    const lastUserMessage = details?.messages
+      ?.filter((item) => item.role === 'user')
+      ?.at(-1)?.content;
+
+    if (lastUserMessage) {
+      rows.push({
+        label: '最后用户消息',
+        value: summarizeMessage(lastUserMessage, this.getWidth() - 24)
+      });
+    }
+
+    if (session.url || details?.url) {
+      rows.push({
+        label: '会话 URL',
+        value: session.url || details.url
+      });
+    }
+
+    this.printKeyValueTable(
+      `会话预览 · ${session.title || '(无标题)'}`,
+      rows.filter(Boolean)
+    );
+  }
+
+  printTimeline(title = 'Agent 时间线', events = []) {
+    if (!events.length) {
+      return;
+    }
+
+    const signature = JSON.stringify({
+      title,
+      events: events.map((event) => ({
+        label: event.label || '',
+        detail: event.detail || '',
+        agentLabel: event.agentLabel || ''
+      }))
+    });
+
+    if (signature === this.lastTimelineSignature) {
+      return;
+    }
+    this.lastTimelineSignature = signature;
+
+    const rows = events.map((event, index) => {
+      const prefix = event.time ? `[${event.time}] ` : '';
+      const rolePrefix = event.agentLabel ? `${event.agentLabel} · ` : '';
+      const description = [rolePrefix + event.label, event.detail].filter(Boolean).join(' · ');
+      return {
+        label: `#${String(index + 1).padStart(2, '0')}`,
+        value: `${prefix}${description}`
+      };
+    });
+
+    this.printKeyValueTable(title, rows);
+  }
+
+  printAgentStatus({
+    stage = '等待',
+    summary = '',
+    detail = '',
+    command = null,
+    agentLabel = ''
+  } = {}) {
+    const signature = JSON.stringify({
+      stage,
+      summary,
+      detail,
+      command: summarizeAgentCommand(command),
+      agentLabel
+    });
+
+    if (signature === this.lastStatusSignature) {
+      return;
+    }
+    this.lastStatusSignature = signature;
+
+    const rows = [
+      { label: '状态', value: stage },
+      agentLabel ? { label: '角色', value: agentLabel } : null,
+      summary ? { label: '摘要', value: summary } : null,
+      detail ? { label: '细节', value: detail } : null,
+      command ? { label: '命令概览', value: summarizeAgentCommand(command) } : null
+    ].filter(Boolean);
+
+    this.printKeyValueTable('Agent 状态', rows);
+  }
+
+  printActionPanel(title = '行动面板', rows = []) {
+    this.printKeyValueTable(title, rows);
+  }
+
+  printSuggestedActions(actions = [], title = '推荐操作') {
+    if (!actions.length) {
+      return;
+    }
+
+    this.printKeyValueTable(title, actions.map((action, index) => ({
+      label: `[${String(index + 1).padStart(2, '0')}]`,
+      value: `${action.label}${action.hint ? ` | ${action.hint}` : ''}`
+    })));
+  }
+
+  printTaskList(tasks = []) {
+    if (!tasks.length) {
+      this.printInfo('(暂无任务)');
+      return;
+    }
+
+    this.printKeyValueTable('任务列表', tasks.map((task, index) => ({
+      label: `[${String(index + 1).padStart(2, '0')}]`,
+      value: `${task.title} | ${task.status} | ${task.provider || '-'} | ${task.mode || 'once'} | ${task.goal || ''}`
+    })));
+  }
+
+  printTaskRuntime(snapshot = null) {
+    if (!snapshot) {
+      return;
+    }
+
+    this.printKeyValueTable('任务运行状态', [
+      { label: '运行中', value: String(snapshot.running ?? 0) },
+      { label: '排队中', value: String(snapshot.queued ?? 0) },
+      { label: '待接管', value: String(snapshot.handoff ?? 0) },
+      { label: '失败', value: String(snapshot.failed ?? 0) },
+      {
+        label: '活跃任务',
+        value: Array.isArray(snapshot.activeTaskIds) && snapshot.activeTaskIds.length > 0
+          ? snapshot.activeTaskIds.join(', ')
+          : '(无)'
+      }
+    ]);
+  }
+
+  printTaskDetails(task) {
+    if (!task) {
+      return;
+    }
+
+    this.printKeyValueTable(`任务详情 · ${task.title}`, [
+      { label: '状态', value: task.status },
+      { label: '提供方', value: task.provider || '(未指定)' },
+      { label: '模式', value: task.mode || 'once' },
+      {
+        label: '间隔',
+        value:
+          task.intervalMs && Number(task.intervalMs) > 0
+            ? `${task.intervalMs} ms`
+            : '(无)'
+      },
+      { label: '运行次数', value: String(task.runCount || 0) },
+      { label: '重试次数', value: String(task.retryCount || 0) },
+      { label: '最后执行', value: task.lastRunAt || '(暂无)' },
+      { label: '下次执行', value: task.nextRunAt || '(无)' },
+      { label: '最后结果', value: task.lastResult || '(暂无)' },
+      { label: '错误', value: task.lastError || '(无)' },
+      task.handoffUrl ? { label: '接管页面', value: task.handoffUrl } : null,
+      { label: '目标', value: task.goal || '(无)' }
+    ].filter(Boolean));
+
+    if (Array.isArray(task.history) && task.history.length > 0) {
+      this.printNewline();
+      this.printTimeline('任务时间线', task.history.slice(-10).map((item) => ({
+        time: item.time,
+        label: item.label || item.type,
+        detail: item.detail || '',
+        agentLabel: item.agentLabel || ''
+      })));
+    }
+  }
+
+  printHistory(messages) {
+    this.printSeparator();
+    for (const m of messages) {
+      const title = m.role === 'user' ? 'YOU' : 'AI';
+      if (shouldRenderTextAsMarkdown(m.content)) {
+        this.printTitle(title);
+        this.printMarkdown(m.content);
+      } else {
+        this.printPanel(title, wrapText(m.content, this.getWidth() - 6));
+      }
+    }
+    this.printSeparator();
+  }
+
+  printRenderedHistory(messages, {
+    renderMessage
+  } = {}) {
+    this.printSeparator();
+
+    for (const message of messages) {
+      if (message.role === 'user') {
+        if (shouldRenderTextAsMarkdown(message.content)) {
+          this.printTitle('YOU');
+          this.printMarkdown(message.content);
+        } else {
+          this.printPanel('YOU', wrapText(message.content, this.getWidth() - 6));
+        }
+        continue;
+      }
+
+      const rendered = typeof renderMessage === 'function'
+        ? renderMessage(message)
+        : null;
+      const title = rendered?.title || 'AI';
+      const badges = Array.isArray(rendered?.badges) ? rendered.badges.filter(Boolean) : [];
+      const titleWithBadges = badges.length > 0
+        ? `${title} · ${badges.join(' · ')}`
+        : title;
+
+      if ((rendered?.renderAs === 'markdown' || shouldRenderTextAsMarkdown(rendered?.text)) && rendered?.text) {
+        this.printTitle(titleWithBadges);
+        this.printMarkdown(rendered.text);
+        continue;
+      }
+
+      const plainText = rendered?.text || message.content || '';
+      this.printPanel(titleWithBadges, wrapText(plainText, this.getWidth() - 6));
+    }
+
+    this.printSeparator();
+  }
+
+  enterWorkspace({
+    title = 'XShat Workspace',
+    status = '',
+    hints = [],
+    leftSections = [],
+    rightSections = []
+  } = {}) {
+    this.clearPinnedHeader();
+    this.workspace.active = true;
+    this.workspace.title = title;
+    this.workspace.status = status;
+    this.workspace.hints = hints;
+    this.workspace.leftSections = leftSections;
+    this.workspace.rightSections = rightSections;
+    this.workspace.footer = '';
+    this.workspace.logLines = [];
+    this.workspace.inputLabel = 'YOU > ';
+    this.workspace.inputPlaceholder = '输入消息后回车发送';
+    this.workspace.inputValue = '';
+    this.workspace.inputCursor = 0;
+    process.stdout.write('\x1b[?1049h\x1b[?25h');
+    this.renderWorkspace();
+  }
+
+  exitWorkspace() {
+    if (!this.workspace.active) {
+      return;
+    }
+    this.workspace.active = false;
+    this.workspace.logLines = [];
+    process.stdout.write('\x1b[?1049l\x1b[?25h');
+  }
+
+  isWorkspaceActive() {
+    return Boolean(this.workspace.active);
+  }
+
+  resetWorkspaceLog() {
+    if (!this.workspace.active) {
+      return;
+    }
+    this.workspace.logLines = [];
+    this.renderWorkspace();
+  }
+
+  setWorkspaceLayout({
+    title,
+    status,
+    hints,
+    leftSections,
+    rightSections,
+    footer,
+    inputLabel,
+    inputPlaceholder,
+    inputValue,
+    inputCursor
+  } = {}) {
+    if (title !== undefined) {
+      this.workspace.title = title;
+    }
+    if (status !== undefined) {
+      this.workspace.status = status;
+    }
+    if (hints !== undefined) {
+      this.workspace.hints = Array.isArray(hints) ? hints.filter(Boolean) : [];
+    }
+    if (leftSections !== undefined) {
+      this.workspace.leftSections = Array.isArray(leftSections) ? leftSections : [];
+    }
+    if (rightSections !== undefined) {
+      this.workspace.rightSections = Array.isArray(rightSections) ? rightSections : [];
+    }
+    if (footer !== undefined) {
+      this.workspace.footer = footer;
+    }
+    if (inputLabel !== undefined) {
+      this.workspace.inputLabel = inputLabel;
+    }
+    if (inputPlaceholder !== undefined) {
+      this.workspace.inputPlaceholder = inputPlaceholder;
+    }
+    if (inputValue !== undefined) {
+      this.workspace.inputValue = String(inputValue ?? '');
+    }
+    if (inputCursor !== undefined) {
+      this.workspace.inputCursor = Math.max(0, Number(inputCursor) || 0);
+    }
+    if (this.workspace.active) {
+      this.renderWorkspace();
+    }
+  }
+
+  setWorkspaceInput(value = '', cursor = null) {
+    this.workspace.inputValue = String(value ?? '');
+    this.workspace.inputCursor = cursor === null
+      ? this.workspace.inputValue.length
+      : Math.max(0, Math.min(Number(cursor) || 0, this.workspace.inputValue.length));
+    if (this.workspace.active) {
+      this.renderWorkspace();
+    }
+  }
+
+  getWorkspaceMainWidth() {
+    const {
+      totalWidth,
+      leftWidth,
+      rightWidth,
+      showLeft,
+      showRight,
+      gapWidth
+    } = this.getWorkspaceDimensions();
+    const left = showLeft ? leftWidth : 0;
+    const right = showRight ? rightWidth : 0;
+    const gaps = (showLeft ? gapWidth : 0) + (showRight ? gapWidth : 0);
+    return Math.max(40, totalWidth - left - right - gaps - 2);
+  }
+
+  appendWorkspaceLines(lines = []) {
+    if (!this.workspace.active) {
+      return;
+    }
+    const safeLines = Array.isArray(lines) ? lines.map((line) => String(line ?? '')) : [];
+    this.workspace.logLines.push(...safeLines);
+    this.workspace.logLines = this.workspace.logLines.slice(-600);
+    this.renderWorkspace();
+  }
+
+  renderWorkspaceSections(sections = [], width, maxHeight) {
+    const output = [];
+    for (const section of sections) {
+      if (!section) {
+        continue;
+      }
+
+      const sectionLines = buildCompactSectionLines(
+        section.title || 'Section',
+        {
+          rows: Array.isArray(section.rows) ? section.rows : [],
+          lines: Array.isArray(section.lines) ? section.lines : []
+        },
+        width
+      );
+
+      if (output.length > 0) {
+        output.push('');
+      }
+      output.push(...sectionLines);
+      if (output.length >= maxHeight) {
+        break;
+      }
+    }
+    return output.slice(0, maxHeight);
+  }
+
+  renderWorkspace() {
+    if (!this.workspace.active) {
+      return;
+    }
+
+    const {
+      totalWidth,
+      leftWidth,
+      rightWidth,
+      showLeft,
+      showRight,
+      gapWidth
+    } = this.getWorkspaceDimensions();
+    const totalRows = Math.max(20, process.stdout.rows || 30);
+    const visibleLeftWidth = showLeft ? leftWidth : 0;
+    const visibleRightWidth = showRight ? rightWidth : 0;
+    const gutterWidth = (showLeft ? gapWidth : 0) + (showRight ? gapWidth : 0);
+    const mainWidth = Math.max(40, totalWidth - visibleLeftWidth - visibleRightWidth - gutterWidth - 2);
+    const bodyHeight = Math.max(6, totalRows - 6);
+    const statusLine = truncateText(
+      [this.workspace.title, this.workspace.status].filter(Boolean).join('  ·  '),
+      totalWidth - 2
+    );
+    const hintsLine = truncateText(
+      (this.workspace.hints || []).join('   ') || (this.workspace.footer || ''),
+      totalWidth - 2
+    );
+
+    const leftLines = showLeft
+      ? this.renderWorkspaceSections(this.workspace.leftSections, leftWidth, bodyHeight)
+      : [];
+    const rightLines = showRight
+      ? this.renderWorkspaceSections(this.workspace.rightSections, rightWidth, bodyHeight)
+      : [];
+    const mainWrappedLines = this.workspace.logLines.flatMap((line) => renderWorkspaceLogLine(line, mainWidth));
+    const mainLines = mainWrappedLines.slice(-bodyHeight);
+
+    const output = [];
+    output.push(this.colorize('ai', ` ${statusLine}`.padEnd(totalWidth, ' ')));
+    output.push(this.colorize('time', ` ${hintsLine}`.padEnd(totalWidth, ' ')));
+
+    for (let index = 0; index < bodyHeight; index++) {
+      const segments = [];
+      if (showLeft) {
+        segments.push(padStyledText(leftLines[index] || '', leftWidth));
+      }
+      segments.push(padStyledText(mainLines[index] || '', mainWidth));
+      if (showRight) {
+        segments.push(padStyledText(rightLines[index] || '', rightWidth));
+      }
+      output.push(segments.join(' '.repeat(gapWidth || 1)));
+    }
+
+    const footer = truncateText(this.workspace.footer || '输入消息，/cmd 打开命令面板，/menu 返回主菜单。', totalWidth - 2);
+    const inputPrefix = this.workspace.inputLabel || 'YOU > ';
+    const inputLine = buildWorkspaceInputLine({
+      prefix: inputPrefix,
+      value: this.workspace.inputValue,
+      placeholder: this.workspace.inputPlaceholder,
+      cursor: this.workspace.inputCursor,
+      width: totalWidth - 4
+    });
+    const inputStrip = `${this.colorize('border', '▏')} ${padStyledText(inputLine, totalWidth - 4)}`;
+
+    output.push(this.colorize('border', '─'.repeat(totalWidth)));
+    output.push(this.colorize('time', ` ${footer}`.padEnd(totalWidth, ' ')));
+    output.push(inputStrip);
+
+    process.stdout.write('\x1b[2J\x1b[H');
+    process.stdout.write(output.join('\n'));
+  }
+}
+
+export { UI };
+export default new UI();