@akanjs/cli 3.0.0-beta.14 → 3.0.0-beta.15

package/index-sxg87a8f.js

@@ -0,0 +1,727 @@
+// @bun
+// pkgs/@akanjs/cli/code/CodeTuiClipboard.ts
+import { existsSync } from "fs";
+import { tmpdir } from "os";
+import path from "path";
+
+class CodeTuiClipboard2 {
+  static imageTypes = [".png", ".jpg", ".jpeg", ".gif", ".webp"];
+  static imagePathsIn(text) {
+    const pieces = text.split(`
+`).flatMap((line) => line.split(/ (?=\/)/));
+    const images = [];
+    const rest = [];
+    for (const piece of pieces) {
+      const file = CodeTuiClipboard2.imagePathIn(piece);
+      if (file)
+        images.push(file);
+      else if (piece.trim())
+        rest.push(piece);
+    }
+    return { images, rest: rest.join(" ") };
+  }
+  static imagePathIn(text) {
+    const file = text.trim().replace(/^['"]|['"]$/g, "").replace(/\\ /g, " ");
+    if (!file || file.includes(`
+`))
+      return;
+    const lower = file.toLowerCase();
+    if (!CodeTuiClipboard2.imageTypes.some((ext) => lower.endsWith(ext)))
+      return;
+    return existsSync(file) ? file : undefined;
+  }
+  static async image() {
+    const png = await CodeTuiClipboard2.#read();
+    if (!png?.length)
+      return;
+    const file = path.join(tmpdir(), `akan-code-${Date.now()}.png`);
+    await Bun.write(file, png);
+    return file;
+  }
+  static has() {
+    try {
+      return Bun.Image.hasClipboardImage();
+    } catch {
+      return false;
+    }
+  }
+  static async#read() {
+    try {
+      const image = Bun.Image.fromClipboard();
+      if (image)
+        return new Uint8Array(await image.png().toBuffer());
+    } catch {}
+    if (process.platform === "darwin")
+      return await CodeTuiClipboard2.#darwin();
+    for (const command of [
+      ["wl-paste", "--no-newline", "--type", "image/png"],
+      ["xclip", "-selection", "clipboard", "-t", "image/png", "-o"]
+    ]) {
+      const bytes = await CodeTuiClipboard2.#bytes(command);
+      if (bytes?.length)
+        return bytes;
+    }
+    return;
+  }
+  static async#darwin() {
+    return CodeTuiClipboard2.fromAppleScript(await CodeTuiClipboard2.#text(["osascript", "-e", CodeTuiClipboard2.ask]));
+  }
+  static ask = "the clipboard as \xABclass PNGf\xBB";
+  static fromAppleScript(out) {
+    const hex = /\u00ABdata PNGf([0-9A-Fa-f]*)\u00BB/.exec(out ?? "")?.[1];
+    if (!hex || hex.length % 2)
+      return;
+    return Uint8Array.from((hex.match(/../g) ?? []).map((byte) => Number.parseInt(byte, 16)));
+  }
+  static async#bytes(command) {
+    try {
+      const proc = Bun.spawn(command, { stdout: "pipe", stderr: "ignore" });
+      const bytes = new Uint8Array(await new Response(proc.stdout).arrayBuffer());
+      return await proc.exited === 0 ? bytes : undefined;
+    } catch {
+      return;
+    }
+  }
+  static async#text(command) {
+    const bytes = await CodeTuiClipboard2.#bytes(command);
+    return bytes ? new TextDecoder().decode(bytes) : undefined;
+  }
+}
+
+// pkgs/@akanjs/cli/code/CodeTuiCommands.ts
+class CodeTuiCommands2 {
+  static all = [
+    { name: "help", desc: "list these commands and the keys" },
+    { name: "tools", desc: "what this session can call" },
+    { name: "model", desc: "switch model", arg: "<provider>/<id>" },
+    { name: "effort", desc: "how hard the model thinks before it answers", arg: "<level>" },
+    { name: "thinking", desc: "show the model's reasoning, or fold it away again" },
+    { name: "compact", desc: "summarise the conversation to free the window", arg: "[notes]" },
+    { name: "abort", desc: "stop the running turn" },
+    { name: "clear", desc: "wipe the screen; the model keeps the conversation" },
+    { name: "name", desc: "name this session", arg: "<text>" },
+    { name: "fork", desc: "continue this conversation twice; the copy takes over here", arg: "[name]" },
+    { name: "agents", desc: "what a sub-agent may be, and what one may spend" },
+    { name: "peers", desc: "the other akan code sessions running here" },
+    { name: "msg", desc: "hand a message to another session", arg: "<peer> <text>" },
+    { name: "quit", desc: "leave the session" }
+  ];
+  static prefixOf(text, caret) {
+    if (!text.startsWith("/"))
+      return;
+    const head = text.slice(0, caret);
+    if (/\s/.test(head) || head.includes(`
+`))
+      return;
+    return head.slice(1);
+  }
+  static matches(prefix) {
+    const needle = prefix.toLowerCase();
+    return CodeTuiCommands2.all.filter((command) => command.name.startsWith(needle));
+  }
+  static help() {
+    const usage = (command) => `/${command.name}${command.arg ? ` ${command.arg}` : ""}`;
+    const column = Math.max(...CodeTuiCommands2.all.map((command) => usage(command).length)) + 2;
+    const list = CodeTuiCommands2.all.map((command) => `${usage(command).padEnd(column)}${command.desc}`).join(`
+`);
+    return [
+      list,
+      "",
+      "Keys: enter send \xB7 shift+enter newline \xB7 \u2191\u2193 move (history at the edges) \xB7 \u2190\u2192 move",
+      "esc interrupt \xB7 pgup/pgdn scroll \xB7 ^c quit",
+      "@ completes a file in this repo \xB7 \u2190 at the start of the prompt lists past sessions",
+      "",
+      "Images: cmd+v attaches what is on the clipboard \xB7 ^v does too, without the terminal in the way",
+      "",
+      'shift+enter needs a terminal that reports it \u2014 in VS Code bind it to send "\\u001b\\r".'
+    ].join(`
+`);
+  }
+}
+
+// pkgs/@akanjs/cli/code/CodeTuiLines.ts
+import stringWidth from "string-width";
+
+class CodeTuiLines2 {
+  static width(text) {
+    return stringWidth(text);
+  }
+  static rows(rows, width, keyBase) {
+    const lines = [];
+    rows.forEach((row, idx) => {
+      for (const line of CodeTuiLines2.#row(row, Math.max(8, width), `${keyBase}:${idx}`))
+        lines.push(line);
+    });
+    return lines;
+  }
+  static #row(row, width, key) {
+    const prefix = row.prefix;
+    const head = prefix ? CodeTuiLines2.width(prefix.text) : 0;
+    const hang = row.hang ?? " ".repeat(head);
+    const body = width - Math.max(head, CodeTuiLines2.width(hang));
+    const wrapped = CodeTuiLines2.#wrap(row.spans, Math.max(4, body));
+    if (!wrapped.length)
+      wrapped.push([]);
+    return wrapped.map((spans, at) => ({
+      key: `${key}:${at}`,
+      spans: [...at === 0 ? prefix ? [prefix] : [] : hang ? [{ text: hang }] : [], ...spans]
+    }));
+  }
+  static #wrap(spans, width) {
+    const lines = [];
+    let line = [];
+    let used = 0;
+    let soft = false;
+    const push = (fromWrap) => {
+      lines.push(line);
+      line = [];
+      used = 0;
+      soft = fromWrap;
+    };
+    for (const span of spans) {
+      const { text, ...style } = span;
+      for (const piece of text.split(`
+`).flatMap((part, at) => at ? [null, part] : [part])) {
+        if (piece === null) {
+          push(false);
+          continue;
+        }
+        for (const word of CodeTuiLines2.#words(piece)) {
+          const size = CodeTuiLines2.width(word);
+          if (!word.trim() && !used && soft)
+            continue;
+          if (used && used + size > width)
+            push(true);
+          if (size > width) {
+            for (const chunk of CodeTuiLines2.#chunks(word, width)) {
+              if (used)
+                push(true);
+              line.push({ ...style, text: chunk });
+              used = CodeTuiLines2.width(chunk);
+              if (used >= width)
+                push(true);
+            }
+            continue;
+          }
+          line.push({ ...style, text: word });
+          used += size;
+        }
+      }
+    }
+    if (line.length)
+      lines.push(line);
+    return lines;
+  }
+  static #words(text) {
+    return text.match(/\S+\s*|\s+/g) ?? [];
+  }
+  static #chunks(word, width) {
+    const chunks = [];
+    let chunk = "";
+    for (const char of word) {
+      if (CodeTuiLines2.width(chunk + char) > width) {
+        chunks.push(chunk);
+        chunk = char;
+      } else
+        chunk += char;
+    }
+    if (chunk)
+      chunks.push(chunk);
+    return chunks;
+  }
+  static text(line) {
+    return line.spans.map((span) => span.text).join("");
+  }
+}
+
+// pkgs/@akanjs/cli/code/CodeTuiEditor.ts
+class CodeTuiEditor2 {
+  #text = "";
+  #caret = 0;
+  get text() {
+    return this.#text;
+  }
+  get caret() {
+    return this.#caret;
+  }
+  get isEmpty() {
+    return !this.#text.length;
+  }
+  set(text, caret = text.length) {
+    this.#text = text;
+    this.#caret = Math.max(0, Math.min(caret, text.length));
+  }
+  clear() {
+    this.set("");
+  }
+  replace(from, to, text) {
+    this.set(this.#text.slice(0, from) + text + this.#text.slice(to), from + text.length);
+  }
+  token() {
+    const before = this.#text.slice(0, this.#caret);
+    const from = Math.max(before.lastIndexOf(" "), before.lastIndexOf(`
+`)) + 1;
+    const after = /\s/.exec(this.#text.slice(this.#caret));
+    const to = after ? this.#caret + (after.index ?? 0) : this.#text.length;
+    return { from, to, text: this.#text.slice(from, to) };
+  }
+  insert(text) {
+    const clean = text.replace(/\r\n?/g, `
+`);
+    this.set(this.#text.slice(0, this.#caret) + clean + this.#text.slice(this.#caret), this.#caret + clean.length);
+  }
+  newline() {
+    this.insert(`
+`);
+  }
+  backspace() {
+    if (!this.#caret)
+      return;
+    const at = CodeTuiEditor2.#prev(this.#text, this.#caret);
+    this.set(this.#text.slice(0, at) + this.#text.slice(this.#caret), at);
+  }
+  deleteForward() {
+    if (this.#caret >= this.#text.length)
+      return;
+    const at = CodeTuiEditor2.#next(this.#text, this.#caret);
+    this.set(this.#text.slice(0, this.#caret) + this.#text.slice(at), this.#caret);
+  }
+  deleteWord() {
+    const before = this.#text.slice(0, this.#caret);
+    const at = before.replace(/\s*\S*$/, "").length;
+    this.set(before.slice(0, at) + this.#text.slice(this.#caret), at);
+  }
+  deleteToLineStart() {
+    const at = this.#text.lastIndexOf(`
+`, Math.max(0, this.#caret - 1)) + 1;
+    this.set(this.#text.slice(0, at) + this.#text.slice(this.#caret), at);
+  }
+  left() {
+    this.#caret = CodeTuiEditor2.#prev(this.#text, this.#caret);
+  }
+  right() {
+    this.#caret = CodeTuiEditor2.#next(this.#text, this.#caret);
+  }
+  wordLeft() {
+    this.#caret = this.#text.slice(0, this.#caret).replace(/\s*\S*$/, "").length;
+  }
+  wordRight() {
+    const rest = /^\s*\S*/.exec(this.#text.slice(this.#caret))?.[0] ?? "";
+    this.#caret = Math.min(this.#text.length, this.#caret + rest.length);
+  }
+  move(direction, width) {
+    const { rows, row, col } = this.layout(width);
+    const target = rows[row + direction];
+    if (!target)
+      return false;
+    this.#caret = target.at + CodeTuiEditor2.#indexAt(target.text, col);
+    return true;
+  }
+  homeOfRow(width) {
+    const { rows, row } = this.layout(width);
+    this.#caret = rows[row]?.at ?? 0;
+  }
+  endOfRow(width) {
+    const { rows, row } = this.layout(width);
+    const current = rows[row];
+    this.#caret = current ? current.at + current.text.length : this.#text.length;
+  }
+  layout(width) {
+    const room = Math.max(4, width);
+    const rows = [];
+    let at = 0;
+    for (const line of this.#text.split(`
+`)) {
+      for (const text of CodeTuiEditor2.#wrap(line, room)) {
+        rows.push({ text, at });
+        at += text.length;
+      }
+      at += 1;
+    }
+    if (!rows.length)
+      rows.push({ text: "", at: 0 });
+    let row = 0;
+    for (let index = 0;index < rows.length; index += 1)
+      if ((rows[index]?.at ?? 0) <= this.#caret)
+        row = index;
+    const current = rows[row] ?? { text: "", at: 0 };
+    return { rows, row, col: CodeTuiLines2.width(current.text.slice(0, Math.max(0, this.#caret - current.at))) };
+  }
+  static #indexAt(row, col) {
+    let at = 0;
+    for (const char of row) {
+      if (CodeTuiLines2.width(row.slice(0, at + char.length)) > col)
+        break;
+      at += char.length;
+    }
+    return at;
+  }
+  static #wrap(line, width) {
+    if (!line.length)
+      return [""];
+    const rows = [];
+    let row = "";
+    for (const char of line) {
+      if (row && CodeTuiLines2.width(row + char) > width) {
+        rows.push(row);
+        row = "";
+      }
+      row += char;
+    }
+    if (row)
+      rows.push(row);
+    return rows;
+  }
+  static #prev(text, at) {
+    if (at <= 0)
+      return 0;
+    return at - ([...text.slice(0, at)].at(-1)?.length ?? 1);
+  }
+  static #next(text, at) {
+    if (at >= text.length)
+      return text.length;
+    return at + ([...text.slice(at)][0]?.length ?? 1);
+  }
+}
+
+// pkgs/@akanjs/cli/code/CodeTuiFiles.ts
+class CodeTuiFiles2 {
+  static limit = 8;
+  #root;
+  #all = [];
+  #loaded = false;
+  constructor(root) {
+    this.#root = root;
+  }
+  get ready() {
+    return this.#loaded;
+  }
+  async load() {
+    this.#all = await CodeTuiFiles2.#list(this.#root);
+    this.#loaded = true;
+  }
+  match(query, limit = CodeTuiFiles2.limit) {
+    const needle = query.toLowerCase();
+    if (!needle)
+      return this.#all.slice(0, limit);
+    const hits = this.#all.filter((file) => file.toLowerCase().includes(needle));
+    return hits.sort((left, right) => left.length - right.length).slice(0, limit);
+  }
+  static async#list(root) {
+    try {
+      const proc = Bun.spawn(["git", "ls-files", "--cached", "--others", "--exclude-standard"], {
+        cwd: root,
+        stdout: "pipe",
+        stderr: "ignore"
+      });
+      const text = await new Response(proc.stdout).text();
+      if (await proc.exited !== 0)
+        return [];
+      return text.split(`
+`).filter((line) => !!line.trim());
+    } catch {
+      return [];
+    }
+  }
+}
+
+// pkgs/@akanjs/cli/code/CodeTuiMarkdown.ts
+import { MarkdownBlocks, MarkdownSpans } from "akanjs/common";
+class CodeTuiMarkdown2 {
+  static bullet = "\u2022";
+  static minColumn = 6;
+  static rows(source, width = 80) {
+    const rows = [];
+    const blocks = MarkdownBlocks.of(source);
+    blocks.forEach((block, at) => {
+      if (at)
+        rows.push({ spans: [] });
+      for (const row of CodeTuiMarkdown2.#block(block, width))
+        rows.push(row);
+    });
+    return rows;
+  }
+  static #block(block, width) {
+    switch (block.kind) {
+      case "heading":
+        return [
+          {
+            spans: CodeTuiMarkdown2.spans(block.text, { bold: true, ...block.level <= 2 ? { color: "cyan" } : {} })
+          }
+        ];
+      case "code":
+        return CodeTuiMarkdown2.#code(block.lang, block.text);
+      case "quote":
+        return block.text.split(`
+`).map((line) => ({
+          prefix: { text: "\u258C ", dim: true },
+          spans: CodeTuiMarkdown2.spans(line, { dim: true })
+        }));
+      case "rule":
+        return [{ spans: [{ text: "\u2500".repeat(24), dim: true }] }];
+      case "list":
+        return block.items.map((item) => {
+          const indent = "  ".repeat(item.depth);
+          const marker = item.ordered ? `${item.num}. ` : `${CodeTuiMarkdown2.bullet} `;
+          return {
+            prefix: { text: `${indent}${marker}`, dim: true },
+            spans: CodeTuiMarkdown2.spans(item.text)
+          };
+        });
+      case "table":
+        return CodeTuiMarkdown2.#table(block, width);
+      default:
+        return [{ spans: CodeTuiMarkdown2.spans(block.text) }];
+    }
+  }
+  static #code(lang, text) {
+    const label = lang?.trim();
+    const bar = { text: "\u2502 ", dim: true };
+    return [
+      ...label ? [{ spans: [{ text: label, dim: true, italic: true }] }] : [],
+      ...text.split(`
+`).map((line) => ({ prefix: bar, hang: "\u2502 ", spans: [{ text: line, color: "green" }] }))
+    ];
+  }
+  static #table(block, width) {
+    const columns = block.head.length;
+    const grid = [block.head, ...block.rows].map((row) => Array.from({ length: columns }, (_, col) => MarkdownSpans.plain(row[col] ?? "")));
+    const widths = CodeTuiMarkdown2.#columns(grid, columns, width);
+    const rule = { spans: [{ text: widths.map((size) => "\u2500".repeat(size)).join("  "), dim: true }] };
+    const [head, ...body] = grid;
+    return [
+      ...CodeTuiMarkdown2.#gridRow(head ?? [], widths, block.aligns, { bold: true }),
+      rule,
+      ...body.flatMap((row) => CodeTuiMarkdown2.#gridRow(row, widths, block.aligns, {}))
+    ];
+  }
+  static #columns(grid, columns, width) {
+    const natural = Array.from({ length: columns }, (_, col) => Math.max(1, ...grid.map((row) => CodeTuiLines2.width(row[col] ?? ""))));
+    const gaps = 2 * Math.max(0, columns - 1);
+    const room = Math.max(columns * CodeTuiMarkdown2.minColumn, width - gaps);
+    const total = natural.reduce((sum, size) => sum + size, 0);
+    if (total <= width - gaps)
+      return natural;
+    const floors = natural.map((size, col) => Math.min(size, Math.max(CodeTuiMarkdown2.minColumn, CodeTuiMarkdown2.#longestWord(grid, col))));
+    const held = floors.reduce((sum, size) => sum + size, 0);
+    if (held > room)
+      return natural.map((size) => Math.max(1, Math.floor(size * room / total)));
+    const want = natural.map((size, col) => size - (floors[col] ?? 0));
+    const wanted = want.reduce((sum, size) => sum + size, 0) || 1;
+    const slack = room - held;
+    return floors.map((size, col) => size + Math.floor(slack * (want[col] ?? 0) / wanted));
+  }
+  static #longestWord(grid, col) {
+    return Math.max(1, ...grid.flatMap((row) => (row[col] ?? "").split(/\s+/).map((word) => CodeTuiLines2.width(word))));
+  }
+  static #gridRow(cells, widths, aligns, style) {
+    const wrapped = widths.map((size, col) => CodeTuiMarkdown2.#cell(cells[col] ?? "", size));
+    const height = Math.max(1, ...wrapped.map((lines) => lines.length));
+    return Array.from({ length: height }, (_, line) => ({
+      spans: widths.flatMap((size, col) => {
+        const text = wrapped[col]?.[line] ?? "";
+        const fill = " ".repeat(Math.max(0, size - CodeTuiLines2.width(text)));
+        const align = aligns[col];
+        const lead = align === "right" ? fill : align === "center" ? " ".repeat(Math.floor(fill.length / 2)) : "";
+        const tail = fill.slice(lead.length);
+        return [{ text: lead }, { ...style, text }, { text: `${tail}${col === widths.length - 1 ? "" : "  "}` }];
+      })
+    }));
+  }
+  static #cell(text, width) {
+    const lines = [];
+    let line = "";
+    for (const word of text.split(/(\s+)/)) {
+      if (!word)
+        continue;
+      if (line && CodeTuiLines2.width(line + word) > width) {
+        lines.push(line.trimEnd());
+        line = word.trim() ? word : "";
+        continue;
+      }
+      line += word;
+    }
+    if (line.trim() || !lines.length)
+      lines.push(line.trimEnd());
+    return lines.flatMap((entry) => CodeTuiLines2.width(entry) <= width ? [entry] : CodeTuiMarkdown2.#hardSplit(entry, width));
+  }
+  static #hardSplit(text, width) {
+    const chunks = [];
+    let chunk = "";
+    for (const char of text) {
+      if (CodeTuiLines2.width(chunk + char) > width) {
+        chunks.push(chunk);
+        chunk = "";
+      }
+      chunk += char;
+    }
+    if (chunk)
+      chunks.push(chunk);
+    return chunks;
+  }
+  static spans(text, base = {}) {
+    return MarkdownSpans.of(text).flatMap((span) => {
+      if (span.kind === "link")
+        return [
+          { ...base, underline: true, text: span.text },
+          { ...base, dim: true, text: ` (${span.href})` }
+        ];
+      return [{ ...base, ...CodeTuiMarkdown2.#span(span), text: span.text }];
+    });
+  }
+  static #span(span) {
+    switch (span.kind) {
+      case "code":
+        return { color: "yellow" };
+      case "strong":
+        return { bold: true };
+      case "em":
+        return { italic: true };
+      case "del":
+        return { strikethrough: true };
+      default:
+        return {};
+    }
+  }
+}
+
+// pkgs/@akanjs/cli/code/CodeTuiParts.ts
+import { codeAgentClip } from "akanjs/common";
+class CodeTuiParts2 {
+  static thinkingLines = 6;
+  static outputLines = 4;
+  static lines(parts, width, options = {}) {
+    const lines = [];
+    parts.forEach((part, at) => {
+      const rows = CodeTuiParts2.rows(part, width, options);
+      for (const line of CodeTuiLines2.rows(rows, width, `${part.id}:${at}`))
+        lines.push(line);
+    });
+    return lines;
+  }
+  static rows(part, width = 80, options = {}) {
+    switch (part.kind) {
+      case "user":
+        return [
+          { prefix: { text: "\u203A ", color: "cyan", bold: true }, spans: [{ text: part.text, color: "cyan" }] },
+          ...part.images ? [
+            {
+              prefix: { text: "  ", dim: true },
+              spans: [{ text: `\u29C9 ${part.images} image${part.images > 1 ? "s" : ""}`, dim: true }]
+            }
+          ] : []
+        ];
+      case "assistant":
+        return CodeTuiParts2.#assistant(part, width);
+      case "thinking":
+        return options.thinking ? CodeTuiParts2.#thinking(part.text) : CodeTuiParts2.#folded(part.text);
+      case "tool":
+        return CodeTuiParts2.#tool(part);
+      case "notice":
+        return part.text.split(`
+`).map((line, at) => ({
+          prefix: { text: at === 0 && part.level !== "info" ? "! " : "  ", ...CodeTuiParts2.#noticeStyle(part.level) },
+          spans: CodeTuiMarkdown2.spans(line, CodeTuiParts2.#noticeStyle(part.level))
+        }));
+      case "question":
+        return CodeTuiParts2.#question(part);
+      case "approval":
+        return [
+          { prefix: { text: "? ", color: "yellow" }, spans: [{ text: part.request.summary, color: "yellow" }] },
+          ...part.approved === undefined ? [] : [{ prefix: { text: "  " }, spans: [{ text: part.approved ? "approved" : "denied", dim: true }] }]
+        ];
+      case "host":
+        return [{ prefix: { text: "  ", dim: true }, spans: [{ text: `${part.hostKind} ${part.text}`, dim: true }] }];
+      default:
+        return [];
+    }
+  }
+  static #assistant(part, width) {
+    const rows = CodeTuiMarkdown2.rows(part.text, width);
+    if (!part.truncated)
+      return rows;
+    return [
+      ...rows,
+      { spans: [{ text: "\u2026 the answer stopped at the model's output limit \u2014 ask it to continue", color: "yellow" }] }
+    ];
+  }
+  static #folded(text) {
+    const count = text.split(`
+`).filter((line) => line.trim()).length;
+    return [
+      {
+        prefix: { text: "\u273B ", dim: true },
+        spans: [{ text: `thinking \xB7 ${count} line${count === 1 ? "" : "s"} \xB7 /thinking to show`, dim: true }]
+      }
+    ];
+  }
+  static #thinking(text) {
+    const all = text.split(`
+`).filter((line) => line.trim());
+    const shown = all.slice(-CodeTuiParts2.thinkingLines);
+    const hidden = all.length - shown.length;
+    return [
+      ...hidden ? [{ prefix: { text: "\xB7 ", dim: true }, spans: [{ text: `(${hidden} earlier lines)`, dim: true }] }] : [],
+      ...shown.map((line) => ({
+        prefix: { text: "\xB7 ", dim: true },
+        spans: [{ text: line, dim: true, italic: true }]
+      }))
+    ];
+  }
+  static #tool(part) {
+    const running = part.outcome === undefined;
+    const mark = running ? "\u25D0" : part.outcome === "ok" ? "\u23FA" : part.outcome === "blocked" ? "\u29B8" : "\u23FA";
+    const color = running ? "cyan" : part.outcome === "ok" ? "green" : part.outcome === "blocked" ? "yellow" : "red";
+    const head = {
+      prefix: { text: `${mark} `, color },
+      hang: "  ",
+      spans: CodeTuiParts2.#title(part.tool.name, part.tool.title)
+    };
+    const detail = CodeTuiParts2.#detail(part);
+    if (!detail.length)
+      return [head];
+    return [
+      head,
+      ...detail.map((line, at) => ({
+        prefix: { text: at === 0 ? "  \u23BF " : "    ", dim: true },
+        hang: "    ",
+        spans: [{ text: line, dim: true }]
+      }))
+    ];
+  }
+  static #title(name, title) {
+    if (!title.startsWith(name))
+      return [{ text: title, bold: true }];
+    return [
+      { text: name, bold: true },
+      { text: title.slice(name.length), dim: true }
+    ];
+  }
+  static #detail(part) {
+    if (part.outcome === undefined)
+      return part.progress ? [part.progress] : [];
+    if (part.outcome === "ok")
+      return [];
+    return (part.output ?? "").split(`
+`).filter((line) => line.trim()).slice(0, CodeTuiParts2.outputLines).map((line) => codeAgentClip(line.trim(), 200));
+  }
+  static #question(part) {
+    return [
+      { prefix: { text: "? ", color: "yellow" }, spans: [{ text: part.question.prompt, color: "yellow" }] },
+      ...(part.question.options ?? []).map((option) => ({
+        prefix: { text: "  \xB7 ", dim: true },
+        spans: [{ text: `${option.label}${option.recommended ? " (recommended)" : ""}`, dim: true }]
+      })),
+      ...part.rendered === undefined ? [] : [{ prefix: { text: "  = ", color: "green" }, spans: [{ text: part.rendered, color: "green" }] }]
+    ];
+  }
+  static #noticeStyle(level) {
+    if (level === "error")
+      return { color: "red" };
+    if (level === "warning")
+      return { color: "yellow" };
+    return { dim: true };
+  }
+}
+
+export { CodeTuiClipboard2, CodeTuiCommands2, CodeTuiLines2, CodeTuiEditor2, CodeTuiFiles2, CodeTuiMarkdown2, CodeTuiParts2 };