@dexto/tui 1.15.0-beta.0 → 1.15.0-beta.1

package/dist/utils/messageFormatting.test.js

@@ -1,5 +1,6 @@
 import { describe, expect, it } from "vitest";
-import { formatToolHeader } from "./messageFormatting.js";
+import { convertHistoryToUIMessages, formatToolHeader } from "./messageFormatting.js";
+import { toolOutput, toolStep } from "./tool-step.js";
 describe("formatToolHeader fallback args", () => {
   it("truncates from the start (not mid-string)", () => {
     const long = "with base path set to packages/server (or absolute if needed). Summarize key directories and notable config/source files.";
@@ -13,3 +14,36 @@ describe("formatToolHeader fallback args", () => {
     expect(header).toContain("...");
   });
 });
+describe("convertHistoryToUIMessages for a background command read back", () => {
+  function resumed(text) {
+    const history = [
+      {
+        role: "tool",
+        name: "bash_output",
+        toolCallId: "c1",
+        success: true,
+        content: [{ type: "text", text }],
+        timestamp: 1
+      }
+    ];
+    const message = convertHistoryToUIMessages(history, "s1")[0];
+    if (message === void 0) throw new Error("expected a tool message");
+    return message;
+  }
+  it("shows a failed command as failed, with its output", () => {
+    const message = resumed(
+      JSON.stringify({ status: "failed", stderr: "boom", stdout: "", exit_code: 2 })
+    );
+    expect(toolStep(message).state).toBe("fail");
+    expect(toolOutput(message)).toEqual(["boom"]);
+  });
+  it("leaves a completed command as it was", () => {
+    const message = resumed(JSON.stringify({ status: "completed", stdout: "done" }));
+    expect(toolStep(message).state).toBe("ok");
+  });
+  it("leaves a row as it was when the stored text cannot be parsed", () => {
+    const message = resumed('{"status":"failed","stderr":"bo\n\n[Output truncated: ...]');
+    expect(toolStep(message).state).toBe("ok");
+    expect(message.toolOutcome).toBeUndefined();
+  });
+});

package/dist/utils/reasoning-variant.cjs

@@ -0,0 +1,35 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var reasoning_variant_exports = {};
+__export(reasoning_variant_exports, {
+  displayedReasoningVariant: () => displayedReasoningVariant
+});
+module.exports = __toCommonJS(reasoning_variant_exports);
+var import_llm = require("@dexto/llm");
+function displayedReasoningVariant(llmConfig) {
+  if (llmConfig === null) return null;
+  const profile = (0, import_llm.getReasoningProfile)(llmConfig.provider, llmConfig.model);
+  if (profile.capable !== true) return null;
+  const variant = llmConfig.reasoning?.variant ?? profile.defaultVariant;
+  return typeof variant === "string" ? variant : null;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  displayedReasoningVariant
+});

package/dist/utils/reasoning-variant.d.ts

@@ -0,0 +1,13 @@
+import { getReasoningProfile } from '@dexto/llm';
+/**
+ * The reasoning variant to show beside the model: the one picked for the session, else the
+ * model's default. Null when the model doesn't reason or has no variant.
+ */
+export declare function displayedReasoningVariant(llmConfig: {
+    provider: Parameters<typeof getReasoningProfile>[0];
+    model: string;
+    reasoning?: {
+        variant?: string | undefined;
+    } | undefined;
+} | null): string | null;
+//# sourceMappingURL=reasoning-variant.d.ts.map

package/dist/utils/reasoning-variant.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reasoning-variant.d.ts","sourceRoot":"","sources":["../../src/utils/reasoning-variant.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAEjD;;;GAGG;AACH,wBAAgB,yBAAyB,CACrC,SAAS,EAAE;IACP,QAAQ,EAAE,UAAU,CAAC,OAAO,mBAAmB,CAAC,CAAC,CAAC,CAAC,CAAC;IACpD,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE;QAAE,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;KAAE,GAAG,SAAS,CAAC;CAC5D,GAAG,IAAI,GACT,MAAM,GAAG,IAAI,CAMf"}

package/dist/utils/reasoning-variant.js

@@ -0,0 +1,11 @@
+import { getReasoningProfile } from "@dexto/llm";
+function displayedReasoningVariant(llmConfig) {
+  if (llmConfig === null) return null;
+  const profile = getReasoningProfile(llmConfig.provider, llmConfig.model);
+  if (profile.capable !== true) return null;
+  const variant = llmConfig.reasoning?.variant ?? profile.defaultVariant;
+  return typeof variant === "string" ? variant : null;
+}
+export {
+  displayedReasoningVariant
+};

package/dist/utils/resize-reflow.cjs

@@ -0,0 +1,119 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var resize_reflow_exports = {};
+__export(resize_reflow_exports, {
+  keepScrollbackOnResize: () => keepScrollbackOnResize,
+  reflowedRows: () => reflowedRows,
+  shrinkRepair: () => shrinkRepair
+});
+module.exports = __toCommonJS(resize_reflow_exports);
+var import_string_width = __toESM(require("string-width"), 1);
+var import_strip_ansi = __toESM(require("strip-ansi"), 1);
+const CSI = "\x1B[";
+const ERASE_LINE = `${CSI}2K`;
+const CURSOR_UP = `${CSI}1A`;
+const CURSOR_LEFT = `${CSI}G`;
+const ERASE_PARTS = [ERASE_LINE, CURSOR_UP, CURSOR_LEFT];
+function stripLeadingErase(chunk) {
+  let rest = chunk;
+  for (; ; ) {
+    const part = ERASE_PARTS.find((p) => rest.startsWith(p));
+    if (part === void 0) return rest;
+    rest = rest.slice(part.length);
+  }
+}
+function eraseLines(count) {
+  let out = "";
+  for (let i = 0; i < count; i++) out += ERASE_LINE + (i < count - 1 ? CURSOR_UP : "");
+  return count > 0 ? out + CURSOR_LEFT : "";
+}
+const graphemes = new Intl.Segmenter(void 0, { granularity: "grapheme" });
+function lineRows(line, columns) {
+  let rows = 1;
+  let col = 0;
+  for (const { segment } of graphemes.segment((0, import_strip_ansi.default)(line))) {
+    const width = (0, import_string_width.default)(segment);
+    if (width === 0) continue;
+    if (col + width > columns) {
+      rows++;
+      col = 0;
+    }
+    col += width;
+  }
+  return rows;
+}
+function reflowedRows(frame, columns) {
+  const cols = Math.max(1, columns);
+  return frame.split("\n").reduce((rows, line) => rows + lineRows(line, cols), 0);
+}
+function shrinkRepair(frame, columns) {
+  const inkRows = frame.split("\n").length;
+  const rows = reflowedRows(frame, columns);
+  if (rows <= inkRows) return "";
+  return eraseLines(rows) + (inkRows > 1 ? `${CSI}${inkRows - 1}B` : "");
+}
+function keepScrollbackOnResize(real) {
+  let lastFrame = "";
+  let columns = real.columns || 80;
+  const write = (chunk, ...rest) => {
+    if (typeof chunk === "string" && chunk !== "") lastFrame = stripLeadingErase(chunk);
+    return real.write(chunk, ...rest);
+  };
+  const onResize = () => {
+    const next = real.columns || 80;
+    if (next < columns && lastFrame !== "") {
+      const repair = shrinkRepair(lastFrame, next);
+      if (repair !== "") {
+        real.write(repair);
+        lastFrame = "";
+      }
+    }
+    columns = next;
+  };
+  real.prependListener("resize", onResize);
+  const stdout = new Proxy(real, {
+    get(target, prop, receiver) {
+      if (prop === "write") return write;
+      const value = Reflect.get(target, prop, receiver);
+      return typeof value === "function" ? value.bind(target) : value;
+    }
+  });
+  return {
+    stdout,
+    dispose: () => {
+      real.off("resize", onResize);
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  keepScrollbackOnResize,
+  reflowedRows,
+  shrinkRepair
+});

package/dist/utils/resize-reflow.d.ts

@@ -0,0 +1,18 @@
+/** Rows `frame` (ending in a newline, as Ink writes it) takes at `columns` once rewrapped. */
+export declare function reflowedRows(frame: string, columns: number): number;
+/**
+ * Escape sequence that clears `frame` after a shrink to `columns`, leaving the cursor where
+ * Ink's next erase of the frame's own row count ends on the frame's top row. '' if nothing wraps.
+ */
+export declare function shrinkRepair(frame: string, columns: number): string;
+export interface KeptScrollback {
+    /** Hand this to Ink's render() as `stdout`. */
+    stdout: NodeJS.WriteStream;
+    dispose: () => void;
+}
+/**
+ * Wrap `real` so the last frame written through it is remembered, and repair shrinks before
+ * any other resize listener (Ink's) runs.
+ */
+export declare function keepScrollbackOnResize(real: NodeJS.WriteStream): KeptScrollback;
+//# sourceMappingURL=resize-reflow.d.ts.map

package/dist/utils/resize-reflow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resize-reflow.d.ts","sourceRoot":"","sources":["../../src/utils/resize-reflow.ts"],"names":[],"mappings":"AA8DA,8FAA8F;AAC9F,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAGnE;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAKnE;AAED,MAAM,WAAW,cAAc;IAC3B,+CAA+C;IAC/C,MAAM,EAAE,MAAM,CAAC,WAAW,CAAC;IAC3B,OAAO,EAAE,MAAM,IAAI,CAAC;CACvB;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,CAAC,WAAW,GAAG,cAAc,CAqC/E"}

package/dist/utils/resize-reflow.js

@@ -0,0 +1,83 @@
+import stringWidth from "string-width";
+import stripAnsi from "strip-ansi";
+const CSI = "\x1B[";
+const ERASE_LINE = `${CSI}2K`;
+const CURSOR_UP = `${CSI}1A`;
+const CURSOR_LEFT = `${CSI}G`;
+const ERASE_PARTS = [ERASE_LINE, CURSOR_UP, CURSOR_LEFT];
+function stripLeadingErase(chunk) {
+  let rest = chunk;
+  for (; ; ) {
+    const part = ERASE_PARTS.find((p) => rest.startsWith(p));
+    if (part === void 0) return rest;
+    rest = rest.slice(part.length);
+  }
+}
+function eraseLines(count) {
+  let out = "";
+  for (let i = 0; i < count; i++) out += ERASE_LINE + (i < count - 1 ? CURSOR_UP : "");
+  return count > 0 ? out + CURSOR_LEFT : "";
+}
+const graphemes = new Intl.Segmenter(void 0, { granularity: "grapheme" });
+function lineRows(line, columns) {
+  let rows = 1;
+  let col = 0;
+  for (const { segment } of graphemes.segment(stripAnsi(line))) {
+    const width = stringWidth(segment);
+    if (width === 0) continue;
+    if (col + width > columns) {
+      rows++;
+      col = 0;
+    }
+    col += width;
+  }
+  return rows;
+}
+function reflowedRows(frame, columns) {
+  const cols = Math.max(1, columns);
+  return frame.split("\n").reduce((rows, line) => rows + lineRows(line, cols), 0);
+}
+function shrinkRepair(frame, columns) {
+  const inkRows = frame.split("\n").length;
+  const rows = reflowedRows(frame, columns);
+  if (rows <= inkRows) return "";
+  return eraseLines(rows) + (inkRows > 1 ? `${CSI}${inkRows - 1}B` : "");
+}
+function keepScrollbackOnResize(real) {
+  let lastFrame = "";
+  let columns = real.columns || 80;
+  const write = (chunk, ...rest) => {
+    if (typeof chunk === "string" && chunk !== "") lastFrame = stripLeadingErase(chunk);
+    return real.write(chunk, ...rest);
+  };
+  const onResize = () => {
+    const next = real.columns || 80;
+    if (next < columns && lastFrame !== "") {
+      const repair = shrinkRepair(lastFrame, next);
+      if (repair !== "") {
+        real.write(repair);
+        lastFrame = "";
+      }
+    }
+    columns = next;
+  };
+  real.prependListener("resize", onResize);
+  const stdout = new Proxy(real, {
+    get(target, prop, receiver) {
+      if (prop === "write") return write;
+      const value = Reflect.get(target, prop, receiver);
+      return typeof value === "function" ? value.bind(target) : value;
+    }
+  });
+  return {
+    stdout,
+    dispose: () => {
+      real.off("resize", onResize);
+    }
+  };
+}
+export {
+  keepScrollbackOnResize,
+  reflowedRows,
+  shrinkRepair
+};

package/dist/utils/resize-reflow.test.cjs

@@ -0,0 +1,100 @@
+"use strict";
+var import_node_events = require("node:events");
+var import_vitest = require("vitest");
+var import_resize_reflow = require("./resize-reflow.js");
+const ESC = "\x1B[";
+(0, import_vitest.describe)("reflowedRows", () => {
+  (0, import_vitest.it)("counts the rows a frame takes once the terminal rewraps it", () => {
+    (0, import_vitest.expect)((0, import_resize_reflow.reflowedRows)(`${"a".repeat(100)}
+
+bb
+`, 40)).toBe(3 + 1 + 1 + 1);
+  });
+  (0, import_vitest.it)("wraps a wide character that would straddle the right margin", () => {
+    (0, import_vitest.expect)((0, import_resize_reflow.reflowedRows)(`${"\u754C".repeat(49)}
+`, 49)).toBe(3 + 1);
+  });
+  (0, import_vitest.it)("ignores colour codes when measuring", () => {
+    (0, import_vitest.expect)((0, import_resize_reflow.reflowedRows)(`${ESC}31m${"a".repeat(40)}${ESC}39m
+`, 40)).toBe(1 + 1);
+  });
+});
+(0, import_vitest.describe)("shrinkRepair", () => {
+  (0, import_vitest.it)("does nothing when no line wraps", () => {
+    (0, import_vitest.expect)((0, import_resize_reflow.shrinkRepair)("short\nlines\n", 40)).toBe("");
+  });
+  (0, import_vitest.it)("erases the rewrapped frame and leaves the cursor where the next erase expects it", () => {
+    const repair = (0, import_resize_reflow.shrinkRepair)(`${"a".repeat(60)}
+b
+`, 40);
+    (0, import_vitest.expect)(repair).toBe(`${ESC}2K${ESC}1A`.repeat(3) + `${ESC}2K${ESC}G${ESC}2B`);
+  });
+});
+class FakeStdout extends import_node_events.EventEmitter {
+  columns = 80;
+  rows = 24;
+  isTTY = true;
+  written = [];
+  write(chunk) {
+    this.written.push(chunk);
+    return true;
+  }
+}
+(0, import_vitest.describe)("keepScrollbackOnResize", () => {
+  (0, import_vitest.it)("remembers the last frame Ink wrote and repairs it before Ink redraws", () => {
+    const real = new FakeStdout();
+    const order = [];
+    const kept = (0, import_resize_reflow.keepScrollbackOnResize)(real);
+    const stdout = kept.stdout;
+    stdout.on("resize", () => order.push("ink"));
+    stdout.write(`${ESC}2K${ESC}G${"x".repeat(70)}
+ok
+`);
+    real.written = [];
+    real.columns = 40;
+    real.emit("resize");
+    (0, import_vitest.expect)(real.written).toHaveLength(1);
+    (0, import_vitest.expect)(real.written[0]).toContain(`${ESC}2K`);
+    (0, import_vitest.expect)(order).toEqual(["ink"]);
+    kept.dispose();
+  });
+  (0, import_vitest.it)("repairs a frame only once when two shrinks arrive before Ink redraws", () => {
+    const real = new FakeStdout();
+    const kept = (0, import_resize_reflow.keepScrollbackOnResize)(real);
+    kept.stdout.write(`${"x".repeat(70)}
+ok
+`);
+    real.written = [];
+    real.columns = 60;
+    real.emit("resize");
+    real.columns = 40;
+    real.emit("resize");
+    (0, import_vitest.expect)(real.written).toHaveLength(1);
+    kept.stdout.write(`${"y".repeat(70)}
+ok
+`);
+    real.written = [];
+    real.columns = 30;
+    real.emit("resize");
+    (0, import_vitest.expect)(real.written).toHaveLength(1);
+    kept.dispose();
+  });
+  (0, import_vitest.it)("leaves a growing terminal alone", () => {
+    const real = new FakeStdout();
+    const kept = (0, import_resize_reflow.keepScrollbackOnResize)(real);
+    kept.stdout.write(`${"x".repeat(70)}
+`);
+    real.written = [];
+    real.columns = 120;
+    real.emit("resize");
+    (0, import_vitest.expect)(real.written).toEqual([]);
+    kept.dispose();
+  });
+  (0, import_vitest.it)("passes everything else through to the real stream", () => {
+    const real = new FakeStdout();
+    const kept = (0, import_resize_reflow.keepScrollbackOnResize)(real);
+    (0, import_vitest.expect)(kept.stdout.columns).toBe(80);
+    (0, import_vitest.expect)(kept.stdout.isTTY).toBe(true);
+    kept.dispose();
+  });
+});

package/dist/utils/resize-reflow.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=resize-reflow.test.d.ts.map

package/dist/utils/resize-reflow.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resize-reflow.test.d.ts","sourceRoot":"","sources":["../../src/utils/resize-reflow.test.ts"],"names":[],"mappings":""}

package/dist/utils/resize-reflow.test.js

@@ -0,0 +1,99 @@
+import { EventEmitter } from "node:events";
+import { describe, expect, it } from "vitest";
+import { keepScrollbackOnResize, reflowedRows, shrinkRepair } from "./resize-reflow.js";
+const ESC = "\x1B[";
+describe("reflowedRows", () => {
+  it("counts the rows a frame takes once the terminal rewraps it", () => {
+    expect(reflowedRows(`${"a".repeat(100)}
+
+bb
+`, 40)).toBe(3 + 1 + 1 + 1);
+  });
+  it("wraps a wide character that would straddle the right margin", () => {
+    expect(reflowedRows(`${"\u754C".repeat(49)}
+`, 49)).toBe(3 + 1);
+  });
+  it("ignores colour codes when measuring", () => {
+    expect(reflowedRows(`${ESC}31m${"a".repeat(40)}${ESC}39m
+`, 40)).toBe(1 + 1);
+  });
+});
+describe("shrinkRepair", () => {
+  it("does nothing when no line wraps", () => {
+    expect(shrinkRepair("short\nlines\n", 40)).toBe("");
+  });
+  it("erases the rewrapped frame and leaves the cursor where the next erase expects it", () => {
+    const repair = shrinkRepair(`${"a".repeat(60)}
+b
+`, 40);
+    expect(repair).toBe(`${ESC}2K${ESC}1A`.repeat(3) + `${ESC}2K${ESC}G${ESC}2B`);
+  });
+});
+class FakeStdout extends EventEmitter {
+  columns = 80;
+  rows = 24;
+  isTTY = true;
+  written = [];
+  write(chunk) {
+    this.written.push(chunk);
+    return true;
+  }
+}
+describe("keepScrollbackOnResize", () => {
+  it("remembers the last frame Ink wrote and repairs it before Ink redraws", () => {
+    const real = new FakeStdout();
+    const order = [];
+    const kept = keepScrollbackOnResize(real);
+    const stdout = kept.stdout;
+    stdout.on("resize", () => order.push("ink"));
+    stdout.write(`${ESC}2K${ESC}G${"x".repeat(70)}
+ok
+`);
+    real.written = [];
+    real.columns = 40;
+    real.emit("resize");
+    expect(real.written).toHaveLength(1);
+    expect(real.written[0]).toContain(`${ESC}2K`);
+    expect(order).toEqual(["ink"]);
+    kept.dispose();
+  });
+  it("repairs a frame only once when two shrinks arrive before Ink redraws", () => {
+    const real = new FakeStdout();
+    const kept = keepScrollbackOnResize(real);
+    kept.stdout.write(`${"x".repeat(70)}
+ok
+`);
+    real.written = [];
+    real.columns = 60;
+    real.emit("resize");
+    real.columns = 40;
+    real.emit("resize");
+    expect(real.written).toHaveLength(1);
+    kept.stdout.write(`${"y".repeat(70)}
+ok
+`);
+    real.written = [];
+    real.columns = 30;
+    real.emit("resize");
+    expect(real.written).toHaveLength(1);
+    kept.dispose();
+  });
+  it("leaves a growing terminal alone", () => {
+    const real = new FakeStdout();
+    const kept = keepScrollbackOnResize(real);
+    kept.stdout.write(`${"x".repeat(70)}
+`);
+    real.written = [];
+    real.columns = 120;
+    real.emit("resize");
+    expect(real.written).toEqual([]);
+    kept.dispose();
+  });
+  it("passes everything else through to the real stream", () => {
+    const real = new FakeStdout();
+    const kept = keepScrollbackOnResize(real);
+    expect(kept.stdout.columns).toBe(80);
+    expect(kept.stdout.isTTY).toBe(true);
+    kept.dispose();
+  });
+});