@tiagojct/subsub 0.21.0 → 0.22.0

package/dist/tui-view.js

@@ -0,0 +1,228 @@
+/**
+ * The screen of `subsub tui`, in parts that know nothing about processes: the colours (read from the themes in themes/, since a client of pi's RPC
+ * mode has no pi theme), the transcript, the side panel and the footer. The controller in src/tui.ts feeds them.
+ */
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { getTerminalColorMode, wrapTextWithAnsi } from "@earendil-works/pi-tui";
+import { cut, evidenceLine, rule, toolDetail, toolLine } from "./chrome.js";
+import { headerLines } from "./look.js";
+import { UNICODE } from "./skin.js";
+// ---------------------------------------------------------------- colours
+/** A Sub-Sub theme file, read as a table of foreground colours. */
+export class Palette {
+    vars;
+    colors;
+    mode;
+    name;
+    constructor(file, mode) {
+        this.name = file.name ?? "";
+        this.vars = file.vars ?? {};
+        this.colors = file.colors;
+        this.mode = mode;
+    }
+    /** The colour of a theme role (accent, text, muted, dim, success, warning, mdLink, ...) as an SGR foreground sequence, or "" for the terminal's own. */
+    ansi(role) {
+        let v = this.colors[role];
+        if (typeof v === "string" && v in this.vars)
+            v = this.vars[v];
+        if (v === undefined || v === "")
+            return "";
+        if (typeof v === "number")
+            return `\x1b[38;5;${v}m`;
+        const [r, g, b] = [1, 3, 5].map((i) => parseInt(v.slice(i, i + 2), 16));
+        return this.mode === "truecolor" ? `\x1b[38;2;${r};${g};${b}m` : `\x1b[38;5;${rgbTo256(r, g, b)}m`;
+    }
+    fg(role, text) {
+        const on = this.ansi(role);
+        return on ? `${on}${text}\x1b[39m` : text;
+    }
+    bold = (t) => `\x1b[1m${t}\x1b[22m`;
+    italic = (t) => `\x1b[3m${t}\x1b[23m`;
+    underline = (t) => `\x1b[4m${t}\x1b[24m`;
+    strikethrough = (t) => `\x1b[9m${t}\x1b[29m`;
+    /** The paint roles of the screens (see Paint in look.ts). */
+    paint() {
+        return {
+            mark: (x) => this.fg("accent", x),
+            text: (x) => this.fg("text", x),
+            muted: (x) => this.fg("muted", x),
+            dim: (x) => this.fg("dim", x),
+            ok: (x) => this.fg("success", x),
+            pend: (x) => this.fg("warning", x),
+            strike: (x) => this.strikethrough(this.fg("muted", x)),
+        };
+    }
+    /** For pi-tui's Markdown component. */
+    markdownTheme() {
+        return {
+            heading: (t) => this.bold(this.fg("mdHeading", t)),
+            link: (t) => this.underline(this.fg("mdLink", t)),
+            linkUrl: (t) => this.fg("mdLinkUrl", t),
+            code: (t) => this.fg("mdCode", t),
+            codeBlock: (t) => this.fg("mdCodeBlock", t),
+            codeBlockBorder: (t) => this.fg("mdCodeBlockBorder", t),
+            quote: (t) => this.italic(this.fg("mdQuote", t)),
+            quoteBorder: (t) => this.fg("mdQuoteBorder", t),
+            hr: (t) => this.fg("mdHr", t),
+            listBullet: (t) => this.fg("mdListBullet", t),
+            bold: this.bold,
+            italic: this.italic,
+            strikethrough: this.strikethrough,
+            underline: this.underline,
+        };
+    }
+    /** For pi-tui's Editor. */
+    editorTheme() {
+        return {
+            borderColor: (t) => this.fg("borderMuted", t),
+            selectList: {
+                selectedPrefix: (t) => this.fg("accent", t),
+                selectedText: (t) => this.fg("text", t),
+                description: (t) => this.fg("muted", t),
+                scrollInfo: (t) => this.fg("dim", t),
+                noMatch: (t) => this.fg("muted", t),
+            },
+        };
+    }
+}
+/** The nearest xterm-256 index of an RGB colour (cube or grey ramp). */
+function rgbTo256(r, g, b) {
+    const cube = [0, 95, 135, 175, 215, 255];
+    const near = (v) => cube.reduce((best, c, i) => (Math.abs(c - v) < Math.abs(cube[best] - v) ? i : best), 0);
+    const [ri, gi, bi] = [near(r), near(g), near(b)];
+    const grey = Math.round((r + g + b) / 3);
+    const greyIndex = Math.min(255, Math.max(232, 232 + Math.round((grey - 8) / 10)));
+    const cubeDist = (cube[ri] - r) ** 2 + (cube[gi] - g) ** 2 + (cube[bi] - b) ** 2;
+    const greyValue = 8 + (greyIndex - 232) * 10;
+    const greyDist = (greyValue - r) ** 2 + (greyValue - g) ** 2 + (greyValue - b) ** 2;
+    return greyDist < cubeDist ? greyIndex : 16 + 36 * ri + 6 * gi + bi;
+}
+/** Dark or light terminal: from COLORFGBG ("15;0" is light text on black), else dark. */
+export function schemeFromEnv(env = process.env) {
+    const bg = Number((env.COLORFGBG ?? "").split(";").at(-1));
+    if (!Number.isFinite(bg) || (env.COLORFGBG ?? "") === "")
+        return "dark";
+    return bg === 7 || bg >= 9 ? "light" : "dark";
+}
+/** The palette of a theme (glauca for the Researcher, try-works for the Librarian) in the colour mode of the terminal. */
+export function loadPalette(themesDir, base, scheme, mode = getTerminalColorMode() === "256color" ? "256color" : "truecolor") {
+    const name = `${base}-${scheme}${mode === "256color" ? "-256" : ""}`;
+    return new Palette(JSON.parse(readFileSync(join(themesDir, `${name}.json`), "utf8")), mode);
+}
+/** The text of a message's content: a string, or the text blocks of a list. */
+export function messageText(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content.filter((b) => b?.type === "text").map((b) => b.text ?? "").join("\n\n");
+}
+const toolWordOf = (w, lang, name) => {
+    const short = name.replace(/^(zotero|scholar)_/, "");
+    return w ? (w.TOOLS[lang][short] ?? w.TOOLS.en[short] ?? name) : name;
+};
+/** One entry as lines, without the empty line that separates entries. */
+export function entryLines(e, width, c) {
+    const g = c.glyphs ?? UNICODE;
+    const p = c.paint;
+    const w = Math.max(10, width);
+    switch (e.kind) {
+        case "user": {
+            const lines = wrapTextWithAnsi(e.text, w - 2);
+            return lines.map((l, i) => `${i === 0 ? p.mark(g.pointer) : " "} ${p.text(l)}`);
+        }
+        case "assistant":
+            return c.markdown(e.text, w);
+        case "tool": {
+            const head = toolLine({ state: e.state, word: toolWordOf(c.words, c.lang, e.name), detail: toolDetail(e.args), error: e.error, lang: c.lang, width: w }, p, g);
+            if (!c.expanded || !e.output?.trim())
+                return [head];
+            return [head, ...e.output.split("\n").slice(0, 40).map((l) => p.muted(cut(`  ${l}`, w)))];
+        }
+        case "notice": {
+            const text = e.level === "info" ? p.muted(cut(e.text, w)) : p.text(cut(`${g.hollow} ${e.text}`, w));
+            return [text];
+        }
+        case "evidence":
+            return [evidenceLine(e.text, c.lang, w, p, g)];
+    }
+}
+/** The whole transcript: the entries one after another, an empty line between them. */
+export function transcriptLines(entries, width, c) {
+    const out = [];
+    let previous;
+    for (const e of entries) {
+        const lines = entryLines(e, width, c);
+        if (!lines.length)
+            continue;
+        // Tool rows and notices belong together; every other change of speaker gets an empty line.
+        if (out.length && !(previous?.kind === "tool" && e.kind === "tool"))
+            out.push("");
+        out.push(...lines);
+        previous = e;
+    }
+    return out;
+}
+/** The messages of an earlier conversation (get_messages) as entries. */
+export function entriesFromMessages(messages) {
+    const out = [];
+    const tools = new Map();
+    for (const m of messages) {
+        if (m.role === "user") {
+            const text = messageText(m.content).trim();
+            if (text && !text.startsWith("/subsub-"))
+                out.push({ kind: "user", text });
+        }
+        else if (m.role === "assistant") {
+            for (const b of Array.isArray(m.content) ? m.content : []) {
+                if (b.type === "text" && b.text?.trim())
+                    out.push({ kind: "assistant", text: b.text });
+                else if (b.type === "toolCall") {
+                    const t = { kind: "tool", id: b.id, name: b.name, args: b.arguments, state: "done" };
+                    tools.set(b.id, t);
+                    out.push(t);
+                }
+            }
+        }
+        else if (m.role === "toolResult") {
+            const t = tools.get(m.toolCallId);
+            if (t) {
+                t.output = messageText(m.content);
+                if (m.isError) {
+                    t.state = "failed";
+                    t.error = t.output.trim().split("\n")[0];
+                }
+            }
+        }
+    }
+    return out;
+}
+export const SIDE_WIDTH = 30;
+const SIDE_WORDS = {
+    en: { notes: "notes", library: "library", actions: "actions", mode: "mode", conversations: "Conversations", none: "none yet" },
+    pt: { notes: "notas", library: "biblioteca", actions: "ações", mode: "modo", conversations: "Conversas", none: "ainda não há" },
+};
+/** The side panel as lines of exactly `width` visible columns are not needed: the layout pads them. */
+export function sideLines(s, width, rows, p, g = UNICODE) {
+    const w = Math.max(16, width);
+    const words = SIDE_WORDS[s.lang];
+    const mode = s.mode === "librarian" ? "Librarian" : "Researcher";
+    const lib = s.library.zotero === "reachable" ? `${s.library.items ?? "?"} ${s.lang === "pt" ? "itens" : "items"}` : s.library.zotero === "down" ? `${g.hollow} Zotero` : "Zotero...";
+    const lines = [p.mark(cut(` Sub-Sub ${s.version}`, w)), p.text(cut(` ${mode}`, w)), p.muted(cut(` ${lib}`, w)), p.dim(cut(` ${s.model}`, w)), rule(w, "solid", p.muted, g)];
+    for (const [key, word] of [["F2", words.notes], ["F3", words.library], ["F4", words.actions], ["F5", words.mode]])
+        lines.push(p.muted(cut(` ${key.padEnd(4)}${word}`, w)));
+    lines.push(rule(w, "solid", p.muted, g), p.text(cut(` ${words.conversations}`, w)));
+    if (!s.conversations.length)
+        lines.push(p.dim(cut(`  ${words.none}`, w)));
+    for (const c of s.conversations) {
+        if (lines.length >= rows)
+            break;
+        lines.push(c.open ? `${p.mark(g.pointer)}${p.text(cut(` ${c.title}`, w - 1))}` : ` ${p.muted(cut(` ${c.title}`, w - 1))}`);
+    }
+    return lines.slice(0, Math.max(rows, 1));
+}
+/** The top of the transcript at the start: the banner and the quote (the same as the header of `subsub`). */
+export function bannerLines(o) {
+    return headerLines({ ...o, quote: o.quote });
+}