lastgen-cli 1.0.0

package/dist/chunk-ESFGGWR6.js

@@ -0,0 +1,799 @@
+#!/usr/bin/env node
+
+// src/ui.ts
+import * as readline from "readline";
+import { stdin, stdout } from "process";
+import chalk from "chalk";
+var colors = {
+  brand: chalk.hex("#e6007e").bold,
+  // Türk Telekom magenta
+  border: chalk.hex("#1577d4"),
+  // kurumsal mavi, ince
+  logo: chalk.hex("#1577d4").bold,
+  user: chalk.cyan.bold,
+  assistant: chalk.green.bold,
+  dim: chalk.gray,
+  error: chalk.red.bold,
+  info: chalk.yellow,
+  ok: chalk.green,
+  white: chalk.whiteBright
+};
+var INNER = 82;
+var _lMain = chalk.hex("#1577d4").bold;
+var _lShadow = chalk.hex("#0b2d5e");
+var BM_L = ["10000", "10000", "10000", "10000", "11111"];
+var BM_A = ["01110", "10001", "11111", "10001", "10001"];
+var BM_S = ["11111", "10000", "01110", "00001", "11111"];
+var BM_T = ["11111", "00100", "00100", "00100", "00100"];
+var BM_G = ["01110", "10000", "10011", "10001", "01110"];
+var BM_E = ["11111", "10000", "11110", "10000", "11111"];
+var BM_N = ["10001", "11001", "10101", "10011", "10001"];
+var _BMS = [BM_L, BM_A, BM_S, BM_T, BM_G, BM_E, BM_N];
+function pxRaw(row) {
+  return [...row].map((c) => c === "1" ? "\u2588\u2591" : "  ").join("");
+}
+function pxCol(row) {
+  return [...row].map((c) => c === "1" ? _lMain("\u2593") + _lShadow("\u2591") : "  ").join("");
+}
+var LOGO_RAW = [0, 1, 2, 3, 4].map((r) => _BMS.map((bm) => pxRaw(bm[r])).join(" "));
+var LOGO_COL = [0, 1, 2, 3, 4].map((r) => _BMS.map((bm) => pxCol(bm[r])).join(" "));
+var LOGO_GRID = [0, 1, 2, 3, 4].map(
+  (r) => _BMS.flatMap((bm) => [...bm[r]])
+);
+var LOGO_COLS = LOGO_GRID[0]?.length ?? 0;
+var LOGO_ROWS = LOGO_GRID.length;
+function buildLogoSettle(totalFrames) {
+  return Array.from(
+    { length: LOGO_ROWS },
+    () => Array.from({ length: LOGO_COLS }, () => Math.floor(Math.random() * totalFrames))
+  );
+}
+function logoDecodeLines(frame, totalFrames, settle = buildLogoSettle(totalFrames)) {
+  const lines = [];
+  for (let r = 0; r < LOGO_ROWS; r++) {
+    let line = "";
+    for (let c = 0; c < LOGO_COLS; c++) {
+      if (c > 0 && c % 5 === 0) line += " ";
+      const on = LOGO_GRID[r][c] === "1";
+      if (!on) {
+        line += "  ";
+      } else if (frame >= settle[r][c]) {
+        line += _lMain("\u2593") + _lShadow("\u2591");
+      } else {
+        const g = randomGlitchChar();
+        line += turquoiseDim(g) + turquoiseDim(g);
+      }
+    }
+    lines.push(line);
+  }
+  return lines;
+}
+var LOGO_LINE_COUNT = LOGO_ROWS;
+function boxRow(plain, color = (s) => s) {
+  const vis = [...plain].length;
+  const pad = Math.max(0, INNER - vis);
+  return colors.border("\u2502 ") + color(plain) + " ".repeat(pad) + colors.border(" \u2502");
+}
+function boxTop() {
+  return colors.border("\u256D" + "\u2500".repeat(INNER + 2) + "\u256E");
+}
+function boxBottom() {
+  return colors.border("\u2570" + "\u2500".repeat(INNER + 2) + "\u256F");
+}
+function boxBlank() {
+  return boxRow("");
+}
+function bannerLines(model, logoLines) {
+  const logo = logoLines ?? LOGO_COL;
+  const lines = [];
+  const logoMaxW = Math.max(...LOGO_RAW.map((r) => [...r].length));
+  const logoIndent = " ".repeat(Math.max(0, Math.floor((INNER - logoMaxW) / 2)));
+  lines.push(boxTop());
+  lines.push(boxBlank());
+  lines.push(boxBlank());
+  for (let i = 0; i < logo.length; i++) {
+    const raw = logoIndent + (logoLines ? logoLines[i] : LOGO_COL[i]);
+    const vis = visibleLength(raw);
+    const pad = Math.max(0, INNER - vis);
+    lines.push(colors.border("\u2502 ") + raw + " ".repeat(pad) + colors.border(" \u2502"));
+  }
+  lines.push(boxBlank());
+  lines.push(boxBlank());
+  lines.push(boxRow("     Lastgen CLI  \xB7  Global | Enterprise AI Terminal Assistant", colors.white));
+  lines.push(boxRow("     Lastgen Software CLI Project", colors.dim));
+  lines.push(boxBlank());
+  lines.push(boxRow(`     Aktif model: ${model ?? "(giri\u015F bekleniyor)"}`, colors.dim));
+  lines.push(boxRow("     OpenAI uyumlu  \xB7  Streaming yan\u0131t  \xB7  /help \xB7 /exit", colors.dim));
+  lines.push(boxBlank());
+  lines.push(boxBottom());
+  return lines;
+}
+function banner(model) {
+  stdout.write("\n" + bannerLines(model).join("\n") + "\n\n");
+}
+async function bannerDecode(model) {
+  if (!stdout.isTTY) {
+    banner(model);
+    return;
+  }
+  const TOTAL_FRAMES = 16;
+  const settle = buildLogoSettle(TOTAL_FRAMES);
+  const initialLogo = logoDecodeLines(0, TOTAL_FRAMES, settle);
+  const initialBanner = bannerLines(model, initialLogo);
+  const bannerLineCount = initialBanner.length;
+  stdout.write("\n" + initialBanner.join("\n") + "\n");
+  const moveUp = `\x1B[${bannerLineCount + 1}A`;
+  for (let frame = 1; frame <= TOTAL_FRAMES; frame++) {
+    const logoLines = logoDecodeLines(frame, TOTAL_FRAMES, settle);
+    const banner2 = bannerLines(model, logoLines);
+    stdout.write(moveUp + "\r\x1B[J" + banner2.join("\n") + "\n");
+    await new Promise((r) => setTimeout(r, 70));
+  }
+  stdout.write("\n");
+}
+var outputSink = null;
+function setOutputSink(fn) {
+  outputSink = fn;
+}
+function out(s) {
+  const safe = typeof s === "string" ? s : String(s ?? "");
+  if (outputSink) outputSink(safe);
+  else stdout.write(safe);
+}
+function info(msg) {
+  out(colors.info("\u2022 ") + msg + "\n");
+}
+function ok(msg) {
+  out(colors.ok("\u2713 ") + msg + "\n");
+}
+function goodbye() {
+  stdout.write("\n" + colors.brand("\u{1F44B} G\xF6r\xFC\u015F\xFCr\xFCz! ") + colors.dim("QAI kapan\u0131yor.") + "\n");
+}
+function error(msg) {
+  out(colors.error("\u2717 ") + msg + "\n");
+}
+function write(text) {
+  out(typeof text === "string" ? text : String(text ?? ""));
+}
+function newline() {
+  out("\n");
+}
+function promptExtraContext(taskTitle, taskDesc) {
+  return new Promise((resolve) => {
+    const W = Math.min(stdout.columns && stdout.columns > 8 ? stdout.columns : 68, 68);
+    const inner = W - 4;
+    const wrapWords = (text, width) => {
+      const words = text.split(/\s+/).filter(Boolean);
+      if (words.length === 0) return [""];
+      const lines = [];
+      let cur = "";
+      for (const word of words) {
+        if ([...cur].length + ([...cur].length > 0 ? 1 : 0) + [...word].length > width) {
+          if (cur) lines.push(cur);
+          if ([...word].length > width) {
+            const chars = [...word];
+            for (let i = 0; i < chars.length; i += width) {
+              lines.push(chars.slice(i, i + width).join(""));
+            }
+            cur = "";
+          } else {
+            cur = word;
+          }
+        } else {
+          cur = cur ? cur + " " + word : word;
+        }
+      }
+      if (cur) lines.push(cur);
+      return lines;
+    };
+    const titleLines = wrapWords(taskTitle, inner - 2);
+    const descLines = taskDesc?.trim() ? wrapWords(taskDesc.trim(), inner) : [];
+    const boxLine = (content, color) => {
+      const colored = color ? color(content) : content;
+      const vis = visibleLength(colored);
+      const pad = Math.max(0, inner - vis);
+      return colors.border("\u2502 ") + colored + " ".repeat(pad) + colors.border(" \u2502");
+    };
+    stdout.write("\n");
+    stdout.write(colors.border("\u256D" + "\u2500".repeat(inner + 2) + "\u256E") + "\n");
+    stdout.write(boxLine("Se\xE7ilen Task", colors.brand) + "\n");
+    stdout.write(colors.border("\u251C" + "\u2500".repeat(inner + 2) + "\u2524") + "\n");
+    for (const line of titleLines) {
+      stdout.write(boxLine("\u25B8 " + line, colors.white) + "\n");
+    }
+    if (descLines.length > 0) {
+      stdout.write(boxLine("") + "\n");
+      stdout.write(boxLine("A\xE7\u0131klama:", colors.dim) + "\n");
+      for (const line of descLines.slice(0, 6)) {
+        stdout.write(boxLine(line, colors.dim) + "\n");
+      }
+      if (descLines.length > 6) {
+        stdout.write(boxLine("\u2026", colors.dim) + "\n");
+      }
+    }
+    stdout.write(colors.border("\u2570" + "\u2500".repeat(inner + 2) + "\u256F") + "\n");
+    const query = colors.dim("  Ekstra bilgi (opsiyonel, bo\u015F Enter = ge\xE7): ");
+    if (!stdin.isTTY) {
+      const rl = readline.createInterface({ input: stdin, output: stdout, terminal: false });
+      rl.question(query, (answer) => {
+        rl.close();
+        stdout.write("\n");
+        resolve(answer.trim());
+      });
+      return;
+    }
+    const wasRaw = Boolean(stdin.isRaw);
+    stdout.write(query);
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding("utf8");
+    let value = "";
+    function cleanup() {
+      stdin.removeListener("data", onData);
+      stdin.setRawMode(wasRaw);
+      stdin.pause();
+    }
+    function redraw() {
+      stdout.write(`\r\x1B[2K${query}${value}`);
+    }
+    function onData(chunk) {
+      for (const ch of chunk) {
+        const code = ch.charCodeAt(0);
+        if (ch === "\r" || ch === "\n") {
+          cleanup();
+          stdout.write("\n");
+          resolve(value.trim());
+          return;
+        } else if (code === 27 || chunk === "\x1B") {
+          cleanup();
+          stdout.write("\n");
+          resolve("");
+          return;
+        } else if (code === CTRL_C) {
+          cleanup();
+          goodbye();
+          process.exit(0);
+        } else if (code === BACKSPACE || code === DEL) {
+          if (value.length > 0) {
+            value = [...value].slice(0, -1).join("");
+            redraw();
+          }
+        } else if (code >= 32) {
+          value += ch;
+          stdout.write(ch);
+        }
+      }
+    }
+    stdin.on("data", onData);
+  });
+}
+var GUTTER = "  ";
+var PROMPT_LABEL = " siz \u203A ";
+function userPromptLabel() {
+  return colors.user(PROMPT_LABEL);
+}
+function ruleWidth() {
+  const cols = stdout.columns && stdout.columns > 8 ? stdout.columns : 60;
+  return Math.min(cols, 68);
+}
+function renderUserBubble(input) {
+  stdout.write(`${GUTTER}${colors.user("\u25E4 siz")}
+`);
+  for (const ln of input.split("\n")) {
+    stdout.write(`${GUTTER}${colors.white(ln)}
+`);
+  }
+}
+function assistantHeader(model) {
+  const badge = colors.assistant("\u25E2 lastgen");
+  const m = model ? colors.dim(" \xB7 " + model) : "";
+  stdout.write(`
+${GUTTER}${badge}${m}
+`);
+}
+function turnSeparator() {
+  stdout.write(colors.dim("\u2500".repeat(ruleWidth())) + "\n");
+}
+var THINKING_PHRASES = [
+  "D\xFC\u015F\xFCn\xFCl\xFCyor...",
+  "Analiz ediliyor...",
+  "\u0130\u015Fleniyor...",
+  "Sentezleniyor...",
+  "Muhakeme ediliyor...",
+  "D\xFC\u015F\xFCnceler aras\u0131nda geziniyor...",
+  "Derinlere iniliyor...",
+  "Tart\u0131p bi\xE7iyor...",
+  "Zihin labirentinde dola\u015F\u0131yor...",
+  "\u0130nce elenip s\u0131k dokunuyor...",
+  "Geziniyor...",
+  "\u0130htimaller taran\u0131yor...",
+  "\xC7arklar d\xF6n\xFCyor...",
+  "N\xF6ronlar ate\u015Fleniyor...",
+  "Par\xE7alar birle\u015Ftiriliyor...",
+  "Veri havuzunda kula\xE7 at\u0131l\u0131yor..."
+];
+function pickThinkingPhrase() {
+  return THINKING_PHRASES[Math.floor(Math.random() * THINKING_PHRASES.length)];
+}
+var turquoise = chalk.hex("#1577d4").bold;
+var turquoiseDim = chalk.hex("#0a3d6e");
+var GLITCH_CHARS = "01abcdef#$@!*&%<>/{}[]~^?+=".split("");
+function randomGlitchChar() {
+  return GLITCH_CHARS[Math.floor(Math.random() * GLITCH_CHARS.length)];
+}
+function decodeFrame(target, settleAt, frame, glitch = randomGlitchChar) {
+  let out2 = "";
+  for (let i = 0; i < target.length; i++) {
+    const ch = target[i];
+    if (ch === " ") {
+      out2 += " ";
+      continue;
+    }
+    out2 += frame >= settleAt[i] ? ch : glitch();
+  }
+  return out2;
+}
+function buildSettle(len, frames) {
+  return Array.from({ length: len }, () => Math.floor(Math.random() * frames));
+}
+var SCRAMBLE_FRAMES = 12;
+var HOLD_FRAMES = 22;
+var FRAME_MS = 45;
+function formatTokens(n) {
+  if (n >= 1e3) return (n / 1e3).toFixed(1) + "k";
+  return String(n);
+}
+function startThinking(indent = "", rightInfo) {
+  if (!stdout.isTTY) {
+    stdout.write(indent + turquoise("\u2022 " + pickThinkingPhrase()));
+    return { stop: () => stdout.write("\r\x1B[K") };
+  }
+  let target = pickThinkingPhrase();
+  let settleAt = buildSettle(target.length, SCRAMBLE_FRAMES);
+  let frame = 0;
+  let holding = 0;
+  const draw = (text) => {
+    const info2 = rightInfo ? colors.dim("   " + rightInfo()) : "";
+    stdout.write("\r\x1B[K" + indent + turquoise("\u2022 ") + text + info2);
+  };
+  const tick = () => {
+    if (holding > 0) {
+      draw(turquoise(target));
+      holding--;
+      return;
+    }
+    const maxSettle = SCRAMBLE_FRAMES;
+    if (frame <= maxSettle) {
+      let out2 = "";
+      for (let i = 0; i < target.length; i++) {
+        const ch = target[i];
+        if (ch === " ") {
+          out2 += " ";
+        } else if (frame >= settleAt[i]) {
+          out2 += turquoise(ch);
+        } else {
+          out2 += turquoiseDim(randomGlitchChar());
+        }
+      }
+      draw(out2);
+      frame++;
+    } else {
+      holding = HOLD_FRAMES;
+      let next = pickThinkingPhrase();
+      while (next === target && THINKING_PHRASES.length > 1) next = pickThinkingPhrase();
+      target = next;
+      settleAt = buildSettle(target.length, SCRAMBLE_FRAMES);
+      frame = 0;
+    }
+  };
+  tick();
+  const timer = setInterval(tick, FRAME_MS);
+  timer.unref?.();
+  return {
+    stop: () => {
+      clearInterval(timer);
+      stdout.write("\r\x1B[K");
+    }
+  };
+}
+var CTRL_C = 3;
+var BACKSPACE = 8;
+var DEL = 127;
+function prompt(query) {
+  return new Promise((resolve) => {
+    if (!stdin.isTTY) {
+      const rl = readline.createInterface({ input: stdin, output: stdout, terminal: false });
+      rl.question(query, (answer) => {
+        rl.close();
+        resolve(answer.trim());
+      });
+      return;
+    }
+    const wasRaw = Boolean(stdin.isRaw);
+    stdout.write(query);
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding("utf8");
+    let value = "";
+    function cleanup() {
+      stdin.removeListener("data", onData);
+      stdin.setRawMode(wasRaw);
+      stdin.pause();
+    }
+    function redraw() {
+      stdout.write(`\r\x1B[2K${query}${value}`);
+    }
+    function onData(chunk) {
+      for (const ch of chunk) {
+        const code = ch.charCodeAt(0);
+        if (ch === "\r" || ch === "\n") {
+          cleanup();
+          stdout.write("\n");
+          resolve(value.trim());
+          return;
+        } else if (code === 27 || chunk === "\x1B") {
+          cleanup();
+          stdout.write("\n");
+          resolve(null);
+          return;
+        } else if (code === CTRL_C) {
+          cleanup();
+          goodbye();
+          process.exit(0);
+        } else if (code === BACKSPACE || code === DEL) {
+          if (value.length > 0) {
+            value = [...value].slice(0, -1).join("");
+            redraw();
+          }
+        } else if (code >= 32) {
+          value += ch;
+          stdout.write(ch);
+        }
+      }
+    }
+    stdin.on("data", onData);
+  });
+}
+function promptHidden(query) {
+  return new Promise((resolve) => {
+    stdout.write(query);
+    if (!stdin.isTTY) {
+      const rl = readline.createInterface({ input: stdin });
+      rl.question("", (answer) => {
+        rl.close();
+        stdout.write("\n");
+        resolve(answer.trim());
+      });
+      return;
+    }
+    const wasRaw = Boolean(stdin.isRaw);
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding("utf8");
+    let value = "";
+    function cleanup() {
+      stdin.removeListener("data", onData);
+      stdin.setRawMode(wasRaw);
+      stdin.pause();
+    }
+    function onData(chunk) {
+      for (const ch of chunk) {
+        const code = ch.charCodeAt(0);
+        if (ch === "\r" || ch === "\n") {
+          cleanup();
+          stdout.write("\n");
+          resolve(value.trim());
+          return;
+        } else if (code === 27 || chunk === "\x1B") {
+          cleanup();
+          stdout.write("\n");
+          resolve(null);
+          return;
+        } else if (code === CTRL_C) {
+          cleanup();
+          goodbye();
+          process.exit(0);
+        } else if (code === BACKSPACE || code === DEL) {
+          if (value.length > 0) {
+            value = value.slice(0, -1);
+            stdout.write("\b \b");
+          }
+        } else if (code >= 32) {
+          value += ch;
+          stdout.write("*");
+        }
+      }
+    }
+    stdin.on("data", onData);
+  });
+}
+function pick(items, defaultIndex = 0) {
+  return new Promise((resolve) => {
+    if (!stdin.isTTY || items.length === 0) {
+      resolve(0);
+      return;
+    }
+    let sel = Math.max(0, Math.min(defaultIndex, items.length - 1));
+    const wasRaw = Boolean(stdin.isRaw);
+    function draw() {
+      if (items.length > 0) stdout.write(`\x1B[${items.length * 2}A`);
+      items.forEach((item, i) => {
+        const active = i === sel;
+        const prefix = active ? colors.ok("  \u276F ") : "    ";
+        const label = active ? chalk.whiteBright.bold(item.label) : colors.dim(item.label);
+        stdout.write(`\x1B[2K${prefix}${label}
+`);
+        const desc = item.description ?? "";
+        stdout.write(`\x1B[2K    ${colors.dim(desc)}
+`);
+      });
+    }
+    items.forEach((item) => {
+      stdout.write(`    ${colors.dim(item.label)}
+`);
+      stdout.write(`    ${colors.dim(item.description ?? "")}
+`);
+    });
+    draw();
+    function cleanup(result) {
+      stdin.setRawMode(wasRaw);
+      stdin.removeListener("data", onData);
+      if (!wasRaw) stdin.pause();
+      resolve(result);
+    }
+    function onData(chunk) {
+      const code = chunk.charCodeAt(0);
+      if (code === 3) {
+        cleanup(null);
+        return;
+      }
+      if (chunk === "\x1B" || chunk === "\x1B\x1B") {
+        cleanup(null);
+        return;
+      }
+      if (chunk === "\x1B[A") {
+        sel = sel > 0 ? sel - 1 : items.length - 1;
+        draw();
+        return;
+      }
+      if (chunk === "\x1B[B") {
+        sel = sel < items.length - 1 ? sel + 1 : 0;
+        draw();
+        return;
+      }
+      if (chunk === "\r" || chunk === "\n") {
+        cleanup(sel);
+        return;
+      }
+    }
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding("utf8");
+    stdin.on("data", onData);
+  });
+}
+var ANSI_RE = /\x1B\[[0-9;]*m/g;
+function visibleLength(s) {
+  return [...s.replace(ANSI_RE, "")].length;
+}
+function wrapAnsi(s, width) {
+  if (width <= 0) return [s];
+  const out2 = [];
+  let cur = "";
+  let curVis = 0;
+  let i = 0;
+  while (i < s.length) {
+    const m = s.slice(i).match(/^\x1B\[[0-9;]*m/);
+    if (m) {
+      cur += m[0];
+      i += m[0].length;
+      continue;
+    }
+    cur += s[i];
+    curVis += 1;
+    i += 1;
+    if (curVis >= width) {
+      out2.push(cur);
+      cur = "";
+      curVis = 0;
+    }
+  }
+  if (cur !== "") {
+    if (curVis === 0 && out2.length > 0) out2[out2.length - 1] += cur;
+    else out2.push(cur);
+  }
+  if (out2.length === 0) out2.push("");
+  return out2;
+}
+function tokenLabel(totalTokens) {
+  return totalTokens > 0 ? ` total token: ${formatTokens(totalTokens)} ` : "";
+}
+function buildInputRule(totalTokens, width) {
+  const label = tokenLabel(totalTokens);
+  const dashes = Math.max(0, width - [...label].length);
+  return "\u2500".repeat(dashes) + label;
+}
+async function promptBoxed(totalTokens = 0) {
+  if (stdout.isTTY) {
+    const cols = stdout.columns && stdout.columns > 0 ? stdout.columns : 80;
+    const w = Math.min(cols, 80);
+    const label = tokenLabel(totalTokens);
+    const dashes = Math.max(0, w - [...label].length);
+    stdout.write(
+      "\n" + colors.border("\u2500".repeat(dashes)) + colors.dim(label) + "\n"
+    );
+  }
+  return await prompt(colors.user(" \u25E4 siz \u203A ")) ?? "";
+}
+function closeInput() {
+}
+var PIN_RESERVED = 3;
+function startPinnedChat(opts) {
+  if (!stdin.isTTY || !stdout.isTTY || !stdout.rows) return null;
+  const wasRaw = Boolean(stdin.isRaw);
+  let boxText = "";
+  let busy = false;
+  let suspended = false;
+  const queue = [];
+  const rows = () => stdout.rows || 24;
+  const cols = () => stdout.columns || 80;
+  function setRegion() {
+    stdout.write("\x1B7");
+    stdout.write(`\x1B[1;${Math.max(1, rows() - PIN_RESERVED)}r`);
+    stdout.write("\x1B8");
+  }
+  function drawBox() {
+    if (suspended) return;
+    const C = cols();
+    const R = rows();
+    const w = C;
+    const topDashes = Math.max(0, w - 2 - "\u2500 siz ".length);
+    const top = colors.border("\u256D\u2500") + colors.user(" siz ") + colors.border("\u2500".repeat(topDashes)) + colors.border("\u256E");
+    const contentW = w - 4;
+    const textArea = Math.max(1, contentW - 2);
+    const chars = [...boxText];
+    const shown = chars.length > textArea - 1 ? chars.slice(chars.length - (textArea - 1)).join("") : boxText;
+    const caret = chalk.inverse(" ");
+    const vis = 2 + [...shown].length + 1;
+    const pad = Math.max(0, contentW - vis);
+    const line = colors.border("\u2502 ") + colors.user("\u203A ") + colors.white(shown) + caret + " ".repeat(pad) + colors.border(" \u2502");
+    const tot = opts.totalTokens();
+    const label = tot > 0 ? ` \u03A3 ${formatTokens(tot)} tok ` : "";
+    const dash = Math.max(0, w - 2 - label.length);
+    const bottom = colors.border("\u2570" + "\u2500".repeat(dash)) + colors.dim(label) + colors.border("\u256F");
+    stdout.write("\x1B7");
+    stdout.write(`\x1B[${R - 2};1H\x1B[2K` + top);
+    stdout.write(`\x1B[${R - 1};1H\x1B[2K` + line);
+    stdout.write(`\x1B[${R};1H\x1B[2K` + bottom);
+    stdout.write("\x1B8");
+  }
+  function run(text) {
+    busy = true;
+    Promise.resolve(opts.onSubmit(text)).finally(() => {
+      busy = false;
+      if (queue.length > 0) run(queue.shift());
+    });
+  }
+  function onData(chunk) {
+    if (suspended) return;
+    if (chunk.charCodeAt(0) === 27) return;
+    let submit = false;
+    for (const ch of chunk) {
+      const code = ch.charCodeAt(0);
+      if (ch === "\r" || ch === "\n") {
+        submit = true;
+        break;
+      } else if (code === CTRL_C) {
+        opts.onExit();
+        return;
+      } else if (code === BACKSPACE || code === DEL) {
+        boxText = [...boxText].slice(0, -1).join("");
+      } else if (code >= 32) {
+        boxText += ch;
+      }
+    }
+    if (submit) {
+      const t = boxText.trim();
+      boxText = "";
+      drawBox();
+      if (t.length > 0) {
+        if (busy) queue.push(t);
+        else run(t);
+      }
+      return;
+    }
+    drawBox();
+  }
+  let resizeTimer;
+  function onResize() {
+    if (resizeTimer) clearTimeout(resizeTimer);
+    resizeTimer = setTimeout(() => {
+      resizeTimer = void 0;
+      setRegion();
+      drawBox();
+    }, 120);
+  }
+  stdin.setRawMode(true);
+  stdin.resume();
+  stdin.setEncoding("utf8");
+  stdout.write("\x1B[?25l");
+  setRegion();
+  drawBox();
+  stdin.on("data", onData);
+  stdout.on("resize", onResize);
+  return {
+    refresh: () => drawBox(),
+    suspend: () => {
+      suspended = true;
+      stdin.removeListener("data", onData);
+      stdin.setRawMode(wasRaw);
+      stdout.write("\x1B[r");
+      stdout.write("\x1B[?25h");
+      stdout.write(`\x1B[${rows()};1H
+`);
+    },
+    resume: () => {
+      suspended = false;
+      stdin.setRawMode(true);
+      stdin.resume();
+      stdin.setEncoding("utf8");
+      stdout.write("\x1B[?25l");
+      setRegion();
+      drawBox();
+      stdin.on("data", onData);
+    },
+    reinit: () => {
+      setRegion();
+      drawBox();
+    },
+    destroy: () => {
+      stdin.removeListener("data", onData);
+      stdout.removeListener("resize", onResize);
+      if (resizeTimer) clearTimeout(resizeTimer);
+      stdin.setRawMode(wasRaw);
+      stdin.pause();
+      stdout.write("\x1B[r");
+      stdout.write("\x1B[?25h");
+      stdout.write(`\x1B[${rows()};1H
+`);
+    }
+  };
+}
+
+export {
+  colors,
+  buildLogoSettle,
+  logoDecodeLines,
+  LOGO_LINE_COUNT,
+  bannerLines,
+  banner,
+  bannerDecode,
+  setOutputSink,
+  info,
+  ok,
+  goodbye,
+  error,
+  write,
+  newline,
+  promptExtraContext,
+  GUTTER,
+  userPromptLabel,
+  renderUserBubble,
+  assistantHeader,
+  turnSeparator,
+  pickThinkingPhrase,
+  randomGlitchChar,
+  decodeFrame,
+  formatTokens,
+  startThinking,
+  prompt,
+  promptHidden,
+  pick,
+  visibleLength,
+  wrapAnsi,
+  tokenLabel,
+  buildInputRule,
+  promptBoxed,
+  closeInput,
+  startPinnedChat
+};