@vigent/cli 0.0.0-stage → 0.2.1

package/dist/theme-new.js

@@ -0,0 +1,49 @@
+/** `vigent theme new`: a commented theme file, pre-filled with the colors of the theme it starts from. */
+import { extractPalette, loadTheme } from "./theme.js";
+/** A commented theme file: start from a theme, and recolor it from a palette pre-filled with that theme's colors. */
+export function themeNewTemplate(name, from, opts = {}) {
+    const base = loadTheme(from);
+    const p = extractPalette(base);
+    const transparent = opts.transparent ?? Boolean(base.transparent);
+    const row = (key, note = "") => `${opts.palette ? "" : "# "}${`${key} = "${p[key]}"`.padEnd(24)}${note ? `# ${note}` : ""}`.trimEnd();
+    return `# ${name}: a vigent theme. Edit, then :colorscheme ${name} to see it (the picker previews live).
+# Docs: https://github.com/farming-labs/vigent/blob/main/docs/themes.md
+name = "${name}"
+${opts.palette ? `# made from ${from}'s colors` : `\n# Start from any built-in or installed theme, then change what you like.\nextends = "${from}"`}
+
+# Draw on the terminal's own background (its blur, opacity or wallpaper shows
+# through). Selections, the cursorline and mode badges keep their colors.
+transparent = ${transparent}
+
+# ${opts.palette ? "The whole theme comes from these colors" : "Uncomment [palette] to recolor the whole theme from these colors"}
+# (${from}'s, read from its highlight groups). Only bg, fg and the six accents
+# are required; leave out the rest and vigent derives them.
+${opts.palette ? "" : "# "}[palette]
+${row("bg", "background")}
+${row("fg", "text")}
+${row("red")}
+${row("yellow")}
+${row("green")}
+${row("cyan")}
+${row("blue")}
+${row("magenta")}
+${row("bg_dark", "sidebar, floats")}
+${row("bg_alt", "cursorline, statusline")}
+${row("selection", "visual selection")}
+${row("muted", "comments")}
+${row("subtle", "line numbers, separators")}
+${row("orange")}
+${row("accent", "current line number")}
+
+# Any highlight group, by its Neovim name: a table, a :hi string, or a group to link to.
+# These win over extends and [palette]. Tweak live with :hi, then :theme save ${name}!
+[groups]
+# Normal = { fg = "${p.fg}", bg = "${p.bg}" }
+# Comment = "guifg=${p.muted} gui=italic"
+# VigentSidebar = { bg = "${p.bg_dark}" }
+# VigentModeNormal = { fg = "${p.bg}", bg = "${p.blue}", bold = true }
+# VigentModeInsert = { fg = "${p.bg}", bg = "${p.green}", bold = true }
+# FloatBorder = { fg = "${p.blue}" }
+# CursorLineNr = "Title"
+`;
+}

package/dist/theme.js

@@ -0,0 +1,487 @@
+/**
+ * Vigent theme engine.
+ *
+ * Themes are keyed by Neovim highlight group names (Normal, StatusLine,
+ * Visual, Comment, DiffAdd, ...), so any vim/nvim colorscheme maps on
+ * directly. A group is resolved in this order:
+ *
+ *   1. user overrides (config [highlights] and live `:hi`) and the theme's
+ *      own definition, following `link`s
+ *   2. colors derived from the theme for vigent's own groups the theme does
+ *      not define (mode badges, sidebar background)
+ *   3. vim-style fallback links, ending at Normal
+ *
+ * A group with no foreground uses Normal's foreground, like nvim.
+ */
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { parse as parseToml } from "smol-toml";
+import { BUILTIN_THEMES } from "./builtin-themes.js";
+import { isLight, mix, nearest256, parseHex } from "./color.js";
+import { fromPalette } from "./palette.js";
+import { didYouMean } from "./suggest.js";
+import { parseHighlightCommand, parseVimColorscheme } from "./vimcolors.js";
+/**
+ * Groups that paint a background behind text. A transparent theme drops their
+ * background so the terminal's (and its blur or wallpaper) shows through;
+ * selections, the cursorline, popup menus and mode badges keep theirs.
+ */
+export const TRANSPARENT_GROUPS = new Set([
+    "Normal",
+    "NormalNC",
+    "NormalFloat",
+    "FloatBorder",
+    "FloatTitle",
+    "MsgArea",
+    "StatusLine",
+    "StatusLineNC",
+    "WinBar",
+    "WinBarNC",
+    "WinSeparator",
+    "LineNr",
+    "CursorLineNr",
+    "SignColumn",
+    "EndOfBuffer",
+    "VigentSidebar",
+    "NeoTreeNormal",
+    "NvimTreeNormal",
+]);
+export const RESET = "\x1b[0m";
+/** Build an SGR escape sequence for an attribute set (24-bit color, or the nearest of 256). */
+export function sgr(attr, mode = "truecolor") {
+    const parts = [];
+    if (attr.bold)
+        parts.push("1");
+    if (attr.italic)
+        parts.push("3");
+    if (attr.underline)
+        parts.push("4");
+    if (attr.reverse)
+        parts.push("7");
+    const fg = parseHex(attr.fg);
+    if (fg)
+        parts.push(mode === "256" ? `38;5;${nearest256(attr.fg)}` : `38;2;${fg[0]};${fg[1]};${fg[2]}`);
+    else if (attr.fg === "NONE")
+        parts.push("39"); // the terminal's own color, replacing whatever came before
+    const bg = parseHex(attr.bg);
+    if (bg)
+        parts.push(mode === "256" ? `48;5;${nearest256(attr.bg)}` : `48;2;${bg[0]};${bg[1]};${bg[2]}`);
+    else if (attr.bg === "NONE")
+        parts.push("49"); // transparent: the terminal's own background
+    return parts.length === 0 ? "" : `\x1b[${parts.join(";")}m`;
+}
+/** Fallback links, mirroring how nvim links its default groups. */
+const LINKS = {
+    NormalNC: "Normal",
+    NormalFloat: "Pmenu",
+    FloatBorder: "NormalFloat",
+    FloatTitle: "Title",
+    WinSeparator: "VertSplit",
+    VertSplit: "NonText",
+    EndOfBuffer: "NonText",
+    CursorLineNr: "LineNr",
+    LineNr: "NonText",
+    StatusLineNC: "StatusLine",
+    WinBar: "Title",
+    TabLine: "StatusLineNC",
+    TabLineSel: "StatusLine",
+    Directory: "Identifier",
+    Function: "Identifier",
+    Keyword: "Statement",
+    Title: "Normal",
+    MsgArea: "Normal",
+    PmenuSel: "Visual",
+    CurSearch: "Search",
+    IncSearch: "Search",
+    Added: "DiffAdd",
+    Removed: "DiffDelete",
+    Changed: "DiffChange",
+    // tree plugins: imported themes keep their sidebar colors
+    NeoTreeNormal: "NvimTreeNormal",
+    NeoTreeIndentMarker: "NvimTreeIndentMarker",
+    NvimTreeIndentMarker: "NonText",
+    // vigent groups
+    VigentSidebar: "NeoTreeNormal",
+    VigentIndent: "NeoTreeIndentMarker",
+    VigentUser: "Title",
+    VigentTool: "Function",
+    VigentToolOutput: "Comment",
+    VigentSpinner: "WarningMsg",
+    VigentCode: "String",
+    Question: "MoreMsg",
+    MoreMsg: "String",
+};
+function hasStyle(a) {
+    if (!a)
+        return false;
+    return Object.entries(a).some(([k, v]) => k !== "link" && v !== undefined);
+}
+/** Colors computed from the theme when it does not define a group itself. */
+const DERIVED = {
+    VigentModeNormal: (p) => p.badge(["Function", "Directory", "Identifier"]),
+    VigentModeInsert: (p) => p.badge(["String", "MoreMsg", "Added"]),
+    VigentModeVisual: (p) => p.badge(["Statement", "Constant", "Special"]),
+    VigentModeCommand: (p) => p.badge(["WarningMsg", "Type", "Todo"]),
+    // last link in the sidebar chain: shade Normal's background
+    NvimTreeNormal: (p) => {
+        const n = p.normal();
+        if (!parseHex(n.bg))
+            return undefined;
+        return { fg: n.fg, bg: mix(n.bg, "#000000", isLight(n.bg) ? 0.05 : 0.22) };
+    },
+};
+export class Painter {
+    theme;
+    sgrCache = new Map();
+    attrCache = new Map();
+    overrides;
+    /** bumped whenever colors change, so renderers can drop cached output */
+    generation = 0;
+    /** 24-bit color, or the nearest of 256 for terminals without it (vim's 'termguicolors') */
+    colorMode = "truecolor";
+    /** `:set transparent` / `notransparent`; "auto" follows the theme */
+    transparency = "auto";
+    setTransparency(t) {
+        if (t === this.transparency)
+            return;
+        this.transparency = t;
+        this.flush();
+    }
+    /** Is the terminal's background showing through right now? */
+    get transparent() {
+        return this.transparency === "auto" ? Boolean(this.theme.transparent) : this.transparency;
+    }
+    setColorMode(mode) {
+        if (mode === this.colorMode)
+            return;
+        this.colorMode = mode;
+        this.flush();
+    }
+    constructor(theme, overrides = {}) {
+        this.theme = theme;
+        this.overrides = { ...overrides };
+    }
+    /** Theme definition with user overrides merged on top. */
+    explicit(group) {
+        const o = this.overrides[group];
+        const t = this.theme.groups[group];
+        if (!o)
+            return t;
+        if (o.link)
+            return { link: o.link };
+        const base = t && !t.link ? t : {};
+        return { ...base, ...o };
+    }
+    normal() {
+        const n = this.explicit("Normal");
+        return n && !n.link ? n : {};
+    }
+    /** Resolve a group without filling in Normal's foreground. */
+    resolve(group) {
+        const seen = new Set();
+        let g = group;
+        while (g && !seen.has(g)) {
+            seen.add(g);
+            const e = this.explicit(g);
+            if (e?.link) {
+                g = e.link;
+                continue;
+            }
+            if (hasStyle(e))
+                return e;
+            const derived = DERIVED[g]?.(this);
+            if (derived)
+                return derived;
+            g = LINKS[g];
+        }
+        return this.normal();
+    }
+    attr(group) {
+        let a = this.attrCache.get(group);
+        if (!a) {
+            const { link: _link, ...r } = this.resolve(group);
+            a = r;
+            if (group !== "Normal" && a.fg === undefined && !a.reverse) {
+                const fg = this.normal().fg;
+                if (fg)
+                    a = { ...a, fg };
+            }
+            // transparent: background groups, and anything painted on Normal's background, use the terminal's
+            if (this.transparent && a.bg !== undefined && a.bg !== "NONE") {
+                const normalBg = this.normal().bg;
+                if (TRANSPARENT_GROUPS.has(group) || (normalBg && a.bg.toLowerCase() === normalBg.toLowerCase())) {
+                    a = { ...a, bg: "NONE" };
+                }
+            }
+            this.attrCache.set(group, a);
+        }
+        return a;
+    }
+    /** A mode badge colored from the first candidate group with a usable foreground. */
+    badge(candidates) {
+        const n = this.normal();
+        for (const c of candidates) {
+            const color = this.resolve(c).fg;
+            if (!parseHex(color) || color === n.fg)
+                continue;
+            const text = parseHex(n.bg) ? n.bg : isLight(color) ? "#111111" : "#eeeeee";
+            return { fg: text, bg: color, bold: true };
+        }
+        const s = this.resolve("StatusLine");
+        return hasStyle(s) ? { ...s, bold: true } : undefined;
+    }
+    /** SGR prefix for a group (cached). */
+    s(group) {
+        let v = this.sgrCache.get(group);
+        if (v === undefined) {
+            v = sgr(this.attr(group), this.colorMode);
+            this.sgrCache.set(group, v);
+        }
+        return v;
+    }
+    /** SGR prefix for a group drawn on an explicit background (cached). */
+    on(group, bg, extra) {
+        const key = `${group}|${bg ?? ""}|${extra ? JSON.stringify(extra) : ""}`;
+        let v = this.sgrCache.get(key);
+        if (v === undefined) {
+            v = sgr({ ...this.attr(group), ...extra, bg }, this.colorMode);
+            this.sgrCache.set(key, v);
+        }
+        return v;
+    }
+    /** Paint text with a group, resetting afterwards. */
+    p(group, text) {
+        return this.s(group) + text + RESET;
+    }
+    setTheme(theme) {
+        this.theme = theme;
+        this.flush();
+    }
+    setOverrides(overrides) {
+        this.overrides = { ...overrides };
+        this.flush();
+    }
+    /** `:hi Group ...`: merge into the group, like vim. */
+    highlight(group, attr) {
+        const current = this.overrides[group];
+        this.overrides[group] = current && !current.link ? { ...current, ...attr } : { ...attr };
+        this.flush();
+    }
+    /** `:hi link From To` */
+    link(from, to) {
+        this.overrides[from] = { link: to };
+        this.flush();
+    }
+    /** `:hi clear [Group]`: drop overrides, back to the theme's colors. */
+    clear(group) {
+        if (group)
+            delete this.overrides[group];
+        else
+            this.overrides = {};
+        this.flush();
+    }
+    flush() {
+        this.sgrCache.clear();
+        this.attrCache.clear();
+        this.generation++;
+    }
+}
+// ---------------------------------------------------------------------------
+// Loading themes from files
+// ---------------------------------------------------------------------------
+export function configDir() {
+    const xdg = process.env.XDG_CONFIG_HOME;
+    return path.join(xdg && xdg.length > 0 ? xdg : path.join(os.homedir(), ".config"), "vigent");
+}
+export function themesDir() {
+    return path.join(configDir(), "themes");
+}
+const THEME_EXTS = [".toml", ".json", ".vim"];
+const SPEC_KEYS = ["name", "background", "extends", "transparent", "palette", "groups", "highlights"];
+/**
+ * Normalize user-written group values. Each value may be:
+ *   { fg = "#..", bg = "NONE", bold = true }   table / object
+ *   { link = "Visual" }                         link
+ *   "guifg=#.. guibg=#.. gui=bold"              vim :hi syntax
+ *   "Visual"                                    shorthand for a link
+ */
+export function normalizeGroups(input) {
+    const out = {};
+    if (!input)
+        return out;
+    for (const [group, value] of Object.entries(input)) {
+        if (typeof value === "string") {
+            if (/=/.test(value) || /^(bold|italic|underline|reverse|NONE)\b/i.test(value)) {
+                const cmd = parseHighlightCommand(`${group} ${value}`);
+                if (cmd?.kind === "set")
+                    out[group] = cmd.attr;
+            }
+            else {
+                out[group] = { link: value };
+            }
+            continue;
+        }
+        if (value && typeof value === "object") {
+            const v = value;
+            const attr = {};
+            for (const key of ["fg", "bg", "link"]) {
+                if (typeof v[key] === "string")
+                    attr[key] = v[key];
+            }
+            for (const key of ["bold", "italic", "underline", "reverse"]) {
+                if (typeof v[key] === "boolean")
+                    attr[key] = v[key];
+            }
+            out[group] = attr;
+        }
+    }
+    return out;
+}
+function readSpec(file) {
+    const text = fs.readFileSync(file, "utf8");
+    if (file.endsWith(".vim")) {
+        const parsed = parseVimColorscheme(text);
+        return { name: parsed.name, background: parsed.background, groups: parsed.groups };
+    }
+    const raw = (file.endsWith(".toml") ? parseToml(text) : JSON.parse(text));
+    if (!Object.keys(raw).some((k) => SPEC_KEYS.includes(k)))
+        return { groups: raw };
+    return raw;
+}
+function findThemeFile(name) {
+    if (/[/\\]/.test(name) || THEME_EXTS.some((e) => name.endsWith(e))) {
+        const p = path.resolve(name.replace(/^~(?=\/)/, os.homedir()));
+        return fs.existsSync(p) ? p : undefined;
+    }
+    for (const ext of THEME_EXTS) {
+        const p = path.join(themesDir(), name + ext);
+        if (fs.existsSync(p))
+            return p;
+    }
+    return undefined;
+}
+export function buildTheme(spec, fallbackName, seen = new Set()) {
+    const name = spec.name ?? fallbackName;
+    let groups = {};
+    let background = spec.background;
+    let transparent = typeof spec.transparent === "boolean" ? spec.transparent : undefined;
+    let palette;
+    if (spec.extends) {
+        if (seen.has(spec.extends))
+            throw new Error(`theme '${name}' extends itself through '${spec.extends}'`);
+        const base = loadTheme(spec.extends, new Set([...seen, name]));
+        groups = { ...base.groups };
+        background ??= base.background;
+        transparent ??= base.transparent;
+        palette = base.palette;
+    }
+    if (spec.palette) {
+        const missing = ["bg", "fg", "red", "yellow", "green", "cyan", "blue", "magenta"].filter((k) => !spec.palette?.[k]);
+        if (missing.length > 0)
+            throw new Error(`theme '${name}': palette is missing ${missing.join(", ")}`);
+        const t = fromPalette(name, spec.palette);
+        groups = { ...groups, ...t.groups };
+        background ??= t.background;
+        palette = t.palette;
+    }
+    groups = { ...groups, ...normalizeGroups(spec.groups), ...normalizeGroups(spec.highlights) };
+    // groups set after the palette may have changed its colors; only keep it when they didn't
+    const exactPalette = palette && !spec.groups && !spec.highlights ? palette : undefined;
+    return { name, background, groups, ...(transparent ? { transparent } : {}), ...(exactPalette ? { palette: exactPalette } : {}) };
+}
+/** Load a built-in theme, a theme file from ~/.config/vigent/themes, or a path. */
+export function loadTheme(nameOrPath, seen = new Set()) {
+    const builtin = BUILTIN_THEMES[nameOrPath];
+    if (builtin)
+        return builtin;
+    const file = findThemeFile(nameOrPath);
+    if (!file)
+        throw new Error(`E185: Cannot find color scheme '${nameOrPath}'${didYouMean(nameOrPath, listThemes())}`);
+    const fallbackName = path.basename(file).replace(/\.(toml|json|vim)$/, "");
+    return buildTheme(readSpec(file), fallbackName, seen);
+}
+export function listThemes() {
+    const names = new Set(Object.keys(BUILTIN_THEMES));
+    try {
+        for (const f of fs.readdirSync(themesDir())) {
+            const ext = THEME_EXTS.find((e) => f.endsWith(e));
+            if (ext)
+                names.add(f.slice(0, -ext.length));
+        }
+    }
+    catch {
+        // no user themes dir yet
+    }
+    return [...names].sort((a, b) => (a === "default" ? -1 : b === "default" ? 1 : a.localeCompare(b)));
+}
+/** The palette a theme's colors come from, read back from its groups (for `vigent theme new`). */
+export function extractPalette(theme) {
+    if (theme.palette)
+        return { ...theme.palette };
+    const p = new Painter({ ...theme, transparent: false });
+    const fg = (...groups) => {
+        for (const g of groups) {
+            const c = p.attr(g).fg;
+            if (parseHex(c))
+                return c;
+        }
+        return p.attr("Normal").fg ?? "#c0c0c0";
+    };
+    const bg = (fallback, ...groups) => {
+        for (const g of groups) {
+            const c = p.attr(g).bg;
+            if (parseHex(c))
+                return c;
+        }
+        return fallback;
+    };
+    const base = bg("#1a1b26", "Normal");
+    return {
+        bg: base,
+        fg: fg("Normal"),
+        red: fg("ErrorMsg", "DiagnosticError", "Removed"),
+        yellow: fg("WarningMsg", "Type"),
+        green: fg("String", "Added"),
+        cyan: fg("Special", "Function"),
+        blue: fg("Function", "Directory", "Title"),
+        magenta: fg("Statement", "Keyword", "Identifier"),
+        bg_dark: bg(base, "VigentSidebar", "NormalFloat"),
+        bg_alt: bg(base, "CursorLine", "StatusLine"),
+        selection: bg(base, "Visual"),
+        muted: fg("Comment"),
+        subtle: fg("LineNr", "NonText"),
+        orange: fg("Constant", "WarningMsg"),
+        accent: fg("CursorLineNr", "Title"),
+    };
+}
+/** A theme file (TOML) for `:theme save`: what's on screen, as small as it can be. */
+export function themeFileFor(name, painter, builtinBase) {
+    const lines = [`# ${name}: saved from vigent with :theme save. Edit freely; reload with :colorscheme ${name}`, `name = "${name}"`];
+    const groups = builtinBase ? { ...painter.overrides } : { ...painter.theme.groups, ...painter.overrides };
+    if (builtinBase)
+        lines.push(`extends = "${painter.theme.name}"`);
+    else if (painter.theme.background)
+        lines.push(`background = "${painter.theme.background}"`);
+    if (painter.transparent !== Boolean(builtinBase && painter.theme.transparent) || (!builtinBase && painter.transparent)) {
+        lines.push(`transparent = ${painter.transparent}`);
+    }
+    lines.push("", "[groups]");
+    for (const [group, attr] of Object.entries(groups).sort(([a], [b]) => a.localeCompare(b))) {
+        lines.push(`${/^[A-Za-z0-9_-]+$/.test(group) ? group : JSON.stringify(group)} = ${tomlAttr(attr)}`);
+    }
+    return `${lines.join("\n")}\n`;
+}
+function tomlAttr(a) {
+    if (a.link)
+        return JSON.stringify(a.link);
+    const parts = [];
+    for (const k of ["fg", "bg"])
+        if (a[k])
+            parts.push(`${k} = ${JSON.stringify(a[k])}`);
+    for (const k of ["bold", "italic", "underline", "reverse"])
+        if (a[k] !== undefined)
+            parts.push(`${k} = ${a[k]}`);
+    return `{ ${parts.join(", ")} }`;
+}
+export { BUILTIN_THEMES };

package/dist/tree.js

@@ -0,0 +1,115 @@
+/**
+ * `:tree` — the agent's conversation as a tree (pi keeps every branch).
+ *
+ * Flattens pi's session tree into rows for a floating list: a straight run of
+ * messages stays at one level, and only where the conversation branched do
+ * the alternatives get ├─ / └─ guides. Tool results are folded into the
+ * reply that called them; bookkeeping entries (model changes, labels...) are
+ * skipped.
+ */
+export const TREE_GLYPHS = {
+    unicode: { tee: "├─ ", last: "└─ ", pipe: "│  ", blank: "   " },
+    ascii: { tee: "|- ", last: "`- ", pipe: "|  ", blank: "   " },
+};
+function textOf(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .filter((b) => b?.type === "text" && typeof b.text === "string")
+        .map((b) => b.text)
+        .join(" ");
+}
+function oneLine(s) {
+    return s.replace(/```[\s\S]*?```/g, "[code]").replace(/\s+/g, " ").trim();
+}
+/** What a tree entry shows as, or undefined to skip it. */
+function describe(entry) {
+    if (entry.type === "message") {
+        const m = entry.message ?? {};
+        if (m.role === "user")
+            return { kind: "user", text: oneLine(textOf(m.content)) || "(empty prompt)" };
+        if (m.role === "assistant") {
+            const text = oneLine(textOf(m.content));
+            if (text)
+                return { kind: "agent", text };
+            const calls = (Array.isArray(m.content) ? m.content : []).filter((b) => b?.type === "toolCall");
+            if (calls.length === 0)
+                return undefined;
+            const names = calls.map((c) => {
+                const a = c.arguments ?? {};
+                const arg = a.command ?? a.path ?? a.file_path ?? "";
+                return `${c.name}${arg ? ` ${String(arg).slice(0, 40)}` : ""}`;
+            });
+            return { kind: "tool", text: names.join(", ") };
+        }
+        return undefined; // tool results belong to the call above them
+    }
+    if (entry.type === "branch_summary")
+        return { kind: "summary", text: `summary of another branch: ${oneLine(entry.summary ?? "")}` };
+    if (entry.type === "compaction")
+        return { kind: "note", text: "earlier messages compacted" };
+    return undefined;
+}
+/** Flatten pi's session tree into list rows. */
+export function flattenTree(roots, leafId, glyphs = TREE_GLYPHS.unicode) {
+    // the current branch: walk up from the leaf
+    const parents = new Map();
+    const index = (nodes) => {
+        for (const n of nodes) {
+            parents.set(n.entry.id, n.entry.parentId);
+            index(n.children);
+        }
+    };
+    index(roots);
+    const onPath = new Set();
+    for (let id = leafId; id; id = parents.get(id) ?? null)
+        onPath.add(id);
+    // skipped entries hand their children to the nearest shown ancestor
+    const visibleChildren = (nodes) => nodes.flatMap((n) => (describe(n.entry) ? [n] : visibleChildren(n.children)));
+    // the current position, mapped to the nearest shown entry at or above the leaf
+    let current = null;
+    for (let id = leafId; id && current === null; id = parents.get(id) ?? null) {
+        const n = find(roots, id);
+        if (n && describe(n.entry))
+            current = id;
+    }
+    const rows = [];
+    const emit = (n, guide) => {
+        const d = describe(n.entry);
+        rows.push({
+            id: n.entry.id,
+            guide,
+            kind: d.kind,
+            text: d.text,
+            onPath: onPath.has(n.entry.id),
+            current: n.entry.id === current,
+            label: n.label,
+        });
+    };
+    const walk = (nodes, prefix) => {
+        if (nodes.length === 1) {
+            emit(nodes[0], prefix);
+            walk(visibleChildren(nodes[0].children), prefix);
+            return;
+        }
+        nodes.forEach((n, i) => {
+            const last = i === nodes.length - 1;
+            emit(n, prefix + (last ? glyphs.last : glyphs.tee));
+            walk(visibleChildren(n.children), prefix + (last ? glyphs.blank : glyphs.pipe));
+        });
+    };
+    walk(visibleChildren(roots), "");
+    return rows;
+}
+function find(nodes, id) {
+    for (const n of nodes) {
+        if (n.entry.id === id)
+            return n;
+        const hit = find(n.children, id);
+        if (hit)
+            return hit;
+    }
+    return undefined;
+}