jaitus 0.3.14 → 0.3.16

package/src/tui/ansi.js

@@ -188,6 +188,12 @@ export function truncateRow(row, width, ellipsis = '…') {
  * bullet or a wrapped tool row stay visually attached to its marker.
  */
 export function wrapRow(row, width, indent = '') {
+  // A newline inside a span is a line break, never a character to print: Ink would draw
+  // it as an extra screen line the layout never counted, and every row below it — and
+  // the selection — would be off by one. Pasted multi-line text arrives exactly so.
+  if (row.some((span) => typeof span.t === 'string' && span.t.includes('\n'))) {
+    return splitAtNewlines(row).flatMap((line) => wrapRow(line, width, indent));
+  }
   if (width < 4) return [row];
   if (rowWidth(row) <= width) return [row];
 
@@ -200,10 +206,15 @@ export function wrapRow(row, width, indent = '') {
   // Every line after the first opens with the hanging indent, so a wrapped bullet or a
   // wrapped tool row stays visually attached to its marker instead of resetting to
   // column zero and reading as a new item.
+  // A continuation line is the same line of text, so copying rejoins it (SOFT): the
+  // marker carries what the break swallowed — a space between words, nothing in a word
+  // cut mid-way. The hanging indent is layout, so it is never copied.
+  let breakJoin = ' ';
   const flush = () => {
     lines.push(current.length ? current : [{ t: '' }]);
-    current = indent ? [...indentSpan] : [];
+    current = [{ t: '', soft: breakJoin }, ...(indent ? [{ ...indentSpan[0], copy: '' }] : [])];
     used = indent ? indentWidth : 0;
+    breakJoin = ' ';
   };
 
   for (const span of row) {
@@ -228,6 +239,7 @@ export function wrapRow(row, width, indent = '') {
           // `cut` marks a word split mid-way, so a URL cut here can be rejoined when it is
           // clicked (the renderer ignores the field).
           current.push(piece ? { ...span, t: piece, cut: true } : { ...span, t: piece });
+          breakJoin = '';
           flush();
           piece = '';
           pieceWidth = 0;
@@ -255,6 +267,58 @@ export function wrapRows(rows, width, indent = '') {
 /** The plain text of a row of spans, for selection, search and the clipboard. */
 export const rowText = (row) => (row || []).map((span) => span.t).join('');
 
+/** One row with newlines in its spans → one row per line, styles kept. */
+export function splitAtNewlines(row) {
+  const lines = [[]];
+  for (const span of row) {
+    const parts = String(span.t ?? '').split('\n');
+    parts.forEach((part, i) => {
+      if (i > 0) lines.push([]);
+      if (part) lines[lines.length - 1].push({ ...span, t: part });
+    });
+  }
+  return lines.map((line) => (line.length ? line : [{ t: '' }]));
+}
+
+// ── Copying what is on screen ──────────────────────────────────────────────────
+//
+// A row on screen is source text plus decoration: the bar beside a message, a code
+// block's gutter and frame, a quote mark, a table's column rules, a bullet glyph, the
+// indent under a wrapped line. A span says what it contributes to a COPY with `copy`
+// (absent = its own text; '' = nothing; '- ' for a bullet), and a wrapped line says how
+// it rejoins the line above with a `soft` marker. Copying a command out of an answer
+// used to bring the gutter's ▐ (| in plain terminals) and the bullet with it.
+
+/** True for a row that is decoration only (a code block's frame, a rule). */
+export const isDecorationRow = (row) => (row || []).length > 0
+  && row.every((span) => span.copy === '' || !span.t)
+  && row.some((span) => span.t && span.copy === '');
+
+/** How a row joins the row above when both are copied: null = a new line. */
+export const softJoin = (row) => {
+  const marker = (row || []).find((span) => span.soft !== undefined);
+  return marker ? marker.soft : null;
+};
+
+/** The copy text of the cells [from, to) of a row (string offsets, as selection uses). */
+export function copyText(row, from = 0, to = Infinity) {
+  let at = 0;
+  let out = '';
+  for (const span of row || []) {
+    const t = String(span.t ?? '');
+    const start = at;
+    const end = at + t.length;
+    at = end;
+    if (end <= from || start >= to) {
+      // A zero-width marker inside the range still counts (it is how bullets survive).
+      if (!(t.length === 0 && start >= from && start < to)) continue;
+    }
+    if (span.copy !== undefined) { out += span.copy; continue; }
+    out += t.slice(Math.max(0, from - start), Math.min(t.length, to - start));
+  }
+  return out;
+}
+
 /**
  * Invert the cells between two columns of a row, splitting spans where the range falls
  * inside one. Used to show a drag selection: the terminal's own highlight is gone once

package/src/tui/entries.js

@@ -137,12 +137,18 @@ const BUILDERS = {
   // ── What the user said ───────────────────────────────────────────────────────
   user(data, width) {
     const p = palette();
-    const bar = { t: pick(['▌', '|']), color: p.brand };
+    // One mark beside the message, on its first row — not a bar on every row: a pasted
+    // command or log used to arrive striped with ▌ (| in plain terminals) down its whole
+    // length. Later rows sit under the text, indented. Neither is ever copied.
+    const bar = { t: pick(['▌', '|']), color: p.brand, copy: '' };
+    const gap = { t: ' ', copy: '' };
+    const indent = { t: '  ', copy: '' };
     const inner = Math.max(12, width - 2);
-    const body = wrapRow([{ t: String(data.text || ''), color: p.body, bold: true }], inner);
-    const rows = body.map((row) => [bar, { t: ' ' }, ...row]);
+    const text = String(data.text || '').replace(/\r\n?/g, '\n').replace(/\t/g, '    ');
+    const body = wrapRow([{ t: text, color: p.body, bold: true }], inner);
+    const rows = body.map((row, index) => (index === 0 ? [bar, gap, ...row] : [indent, ...row]));
     if (data.attachments?.length) {
-      rows.push([bar, { t: ' ' }, { t: data.attachments.map((a) => `⧉ ${a}`).join('  '), color: p.purple }]);
+      rows.push([indent, { t: data.attachments.map((a) => `⧉ ${a}`).join('  '), color: p.purple }]);
     }
     return rows;
   },
@@ -156,8 +162,8 @@ const BUILDERS = {
     // A lead mark on the first row only: it identifies the speaker without spending a
     // whole line on a name label, and the indent keeps the column under it aligned.
     return body.map((row, index) => (index === 0
-      ? [{ t: pick(['● ', '* ']), color: p.teal }, ...row]
-      : [{ t: '  ' }, ...row]));
+      ? [{ t: pick(['● ', '* ']), color: p.teal, copy: '' }, ...row]
+      : [{ t: '  ', copy: '' }, ...row]));
   },
 
   // ── A tool call ──────────────────────────────────────────────────────────────
@@ -197,11 +203,11 @@ const BUILDERS = {
         const tinted = highlightLine(line.replace(/\t/g, '  '), language, state);
         state = tinted.state;
         const spans = tinted.spans.length ? tinted.spans : [{ t: '' }];
-        rows.push([{ t: `    ${pick(['│', '|'])} `, color: p.lineSoft }, ...truncateRow(spans, Math.max(8, width - 6))]);
+        rows.push([{ t: `    ${pick(['│', '|'])} `, color: p.lineSoft, copy: '' }, ...truncateRow(spans, Math.max(8, width - 6))]);
       }
       if (preview.more > 0) {
         const hint = openable && !data.expanded ? ' — click the row to show all' : '';
-        rows.push([{ t: `    ${pick(['│', '|'])} `, color: p.lineSoft }, { t: `+${preview.more} more line${preview.more === 1 ? '' : 's'}${hint}`, color: p.faint, italic: true }]);
+        rows.push([{ t: `    ${pick(['│', '|'])} `, color: p.lineSoft, copy: '' }, { t: `+${preview.more} more line${preview.more === 1 ? '' : 's'}${hint}`, color: p.faint, italic: true }]);
       }
     }
     return rows;
@@ -262,7 +268,7 @@ const BUILDERS = {
   error(data, width) {
     const p = palette();
     const rows = [];
-    const bar = { t: pick(['▌', '|']), color: p.red };
+    const bar = { t: pick(['▌', '|']), color: p.red, copy: '' };
     const inner = Math.max(12, width - 2);
 
     rows.push([bar, { t: ' ' }, { t: `${pick(['✗', 'x'])} ${data.title || 'Error'}`, color: p.red, bold: true }]);

package/src/tui/markdown.js

@@ -122,14 +122,14 @@ export function renderMarkdown(text, width, { compact = false } = {}) {
       for (const row of wrapRow(content, w)) rows.push(row);
       if (level <= 2) {
         const ruleWidth = Math.min(w, Math.max(8, contentWidth(content)));
-        rows.push([{ t: (level === 1 ? g('━', '=') : g('─', '-')).repeat(ruleWidth), color: level === 1 ? p.brandDeep : p.line }]);
+        rows.push([{ t: (level === 1 ? g('━', '=') : g('─', '-')).repeat(ruleWidth), color: level === 1 ? p.brandDeep : p.line, copy: '' }]);
       }
       i += 1;
       continue;
     }
 
     // ── horizontal rule ────────────────────────────────────────────────────────
-    if (RULE.test(line)) { rows.push([{ t: g('─', '-').repeat(w), color: p.line }]); i += 1; continue; }
+    if (RULE.test(line)) { rows.push([{ t: g('─', '-').repeat(w), color: p.line, copy: '' }]); i += 1; continue; }
 
     // ── blockquote ─────────────────────────────────────────────────────────────
     const quote = QUOTE.exec(line);
@@ -138,7 +138,7 @@ export function renderMarkdown(text, width, { compact = false } = {}) {
       while (i < lines.length && QUOTE.test(lines[i])) { body.push(QUOTE.exec(lines[i])[1]); i += 1; }
       if (!compact) blank();
       for (const inner of renderMarkdown(body.join('\n'), w - 2, { compact: true })) {
-        rows.push([{ t: g('▏ ', '| '), color: p.teal }, ...inner]);
+        rows.push([{ t: g('▏ ', '| '), color: p.teal, copy: '> ' }, ...inner]);
       }
       if (!compact) rows.push([]);
       continue;
@@ -159,10 +159,10 @@ export function renderMarkdown(text, width, { compact = false } = {}) {
         const done = !!task && /[xX]/.test(task[1]);
         let marker;
         if (task) {
-          marker = { t: done ? g('✔ ', '[x] ') : g('○ ', '[ ] '), color: done ? p.green : p.dim };
+          marker = { t: done ? g('✔ ', '[x] ') : g('○ ', '[ ] '), color: done ? p.green : p.dim, copy: done ? '- [x] ' : '- [ ] ' };
           content = task[2];
         } else if (b) {
-          marker = { t: `${(ascii() ? ['-', '*', '+'] : ['•', '◦', '▪'])[depth % 3]} `, color: p.brand };
+          marker = { t: `${(ascii() ? ['-', '*', '+'] : ['•', '◦', '▪'])[depth % 3]} `, color: p.brand, copy: '- ' };
         } else {
           marker = { t: `${o[2]}. `, color: p.brand };
         }
@@ -206,6 +206,28 @@ export function renderMarkdown(text, width, { compact = false } = {}) {
 
 const contentWidth = (spans) => spans.reduce((sum, s) => sum + stringWidth(s.t), 0);
 
+/** Spans cut into rows of at most `width` cells, character by character, styles kept. */
+function hardWrap(spans, width) {
+  const rows = [[]];
+  let used = 0;
+  for (const span of spans) {
+    let piece = '';
+    for (const ch of String(span.t ?? '')) {
+      const cw = stringWidth(ch);
+      if (used + cw > width && used > 0) {
+        if (piece) rows[rows.length - 1].push({ ...span, t: piece });
+        rows.push([]);
+        piece = '';
+        used = 0;
+      }
+      piece += ch;
+      used += cw;
+    }
+    if (piece) rows[rows.length - 1].push({ ...span, t: piece });
+  }
+  return rows.map((r) => (r.length ? r : [{ t: '' }]));
+}
+
 /**
  * A fenced block: a language tag, a tinted body, and a left gutter that makes the code
  * a distinct object on the page without the cost of a full border (which would eat two
@@ -214,14 +236,14 @@ const contentWidth = (spans) => spans.reduce((sum, s) => sum + stringWidth(s.t),
 function codeBlock(body, language, width) {
   const p = palette();
   const rows = [];
-  const gutter = { t: g('▐ ', '| '), color: p.tealDeep };
+  const gutter = { t: g('▐ ', '| '), color: p.tealDeep, copy: '' };
   const label = language && isKnownLanguage(language) ? language : language || '';
   const inner = Math.max(8, width - 2);
 
   rows.push([
-    { t: g('▛', '+'), color: p.tealDeep },
-    { t: label ? `${g('─', '-')} ${label} ` : g('─', '-'), color: p.dim },
-    { t: g('─', '-').repeat(Math.max(0, width - 2 - (label ? label.length + 3 : 1))), color: p.lineSoft },
+    { t: g('▛', '+'), color: p.tealDeep, copy: '' },
+    { t: label ? `${g('─', '-')} ${label} ` : g('─', '-'), color: p.dim, copy: '' },
+    { t: g('─', '-').repeat(Math.max(0, width - 2 - (label ? label.length + 3 : 1))), color: p.lineSoft, copy: '' },
   ]);
 
   let state = {};
@@ -231,11 +253,13 @@ function codeBlock(body, language, width) {
     state = result.state;
     const spans = result.spans.length ? result.spans : [{ t: '' }];
     // Code is not prose: wrapping it on spaces would move a token onto a line where it
-    // does not belong. Long lines are cut with a marker instead, which is honest about
-    // there being more and keeps the block rectangular.
-    rows.push([gutter, ...truncateRow(spans, inner, g('›', '>'))]);
+    // does not belong — so a long line is cut at the edge, character by character, and
+    // carries on under a fainter gutter. It used to be cut off with › and the rest was
+    // gone: a long command copied out of an answer came back truncated.
+    const pieces = hardWrap(spans, inner);
+    pieces.forEach((piece, k) => rows.push(k === 0 ? [gutter, ...piece] : [{ ...gutter, t: g('┆ ', ': '), color: p.faint }, { t: '', soft: '' }, ...piece]));
   }
-  rows.push([{ t: g('▙', '+'), color: p.tealDeep }, { t: g('─', '-').repeat(Math.max(0, width - 2)), color: p.lineSoft }]);
+  rows.push([{ t: g('▙', '+'), color: p.tealDeep, copy: '' }, { t: g('─', '-').repeat(Math.max(0, width - 2)), color: p.lineSoft, copy: '' }]);
   return rows;
 }
 
@@ -265,7 +289,8 @@ function table(block, width) {
     const header = index === 0;
     const spans = [];
     for (let col = 0; col < columns; col++) {
-      if (col) spans.push({ t: g(' │ ', ' | '), color: p.line });
+      // Copied as a tab: a table pasted into a sheet lands in cells.
+      if (col) spans.push({ t: g(' │ ', ' | '), color: p.line, copy: '\t' });
       const content = truncateRow(inlineSpans(row[col] || '', header ? { bold: true, color: p.tealSoft } : {}), widths[col]);
       spans.push(...content);
       const gap = widths[col] - contentWidth(content);
@@ -273,7 +298,7 @@ function table(block, width) {
     }
     rows.push(spans);
     if (header) {
-      rows.push(widths.flatMap((w, col) => (col ? [{ t: g('─┼─', '-+-'), color: p.line }, { t: g('─', '-').repeat(w), color: p.line }] : [{ t: g('─', '-').repeat(w), color: p.line }])));
+      rows.push(widths.flatMap((w, col) => (col ? [{ t: g('─┼─', '-+-'), color: p.line, copy: '' }, { t: g('─', '-').repeat(w), color: p.line, copy: '' }] : [{ t: g('─', '-').repeat(w), color: p.line, copy: '' }])));
     }
   });
   return rows;