pi-chassis 0.0.0-stage → 0.7.1

package/dist/chassis/icons.d.ts

@@ -0,0 +1,203 @@
+/**
+ * Icons: every glyph chassis draws from a Nerd Font lives here, each with a plain twin that needs
+ * no special font. The plain twin takes the same number of cells as the Nerd glyph (one, or none
+ * where the words beside it already say it), so no layout changes between the two sets.
+ *
+ * Which set is used, first match wins:
+ *   1. the PI_CHASSIS_ICONS environment variable ("nerd" or "plain")
+ *   2. the user's setting, `/chassis icons nerd|plain`, saved in chassis.json
+ *   3. the brand's default (`icons` in its spec: a brand that ships a font can ask for "nerd")
+ *   4. plain, so a terminal without a Nerd Font never shows empty boxes
+ *
+ * The plain glyphs are ASCII or characters that exist in the common monospace fonts (DejaVu Sans
+ * Mono, Noto Sans Mono, Consolas and Lucida Console were checked): • · ↑ ↓ → ● ○ ▲ × ▐ ▌.
+ *
+ * This file is the only place with Nerd Font code points. test/icons.test.ts fails on one anywhere else.
+ */
+export type IconSet = "nerd" | "plain";
+/** An icon a widget supplies: one string for both sets, or one per set. */
+export type IconLike = string | {
+    nerd: string;
+    plain?: string;
+};
+/** nf-md-* unless noted. "" means no icon in that set. */
+export declare const ICONS: {
+    readonly provider: {
+        readonly nerd: "󰚩";
+        readonly plain: "■";
+    };
+    readonly usage: {
+        readonly nerd: "󰝦";
+        readonly plain: " ";
+    };
+    readonly branch: {
+        readonly nerd: "";
+        readonly plain: "";
+    };
+    readonly worktree: {
+        readonly nerd: "󰓠";
+        readonly plain: "wt";
+    };
+    readonly cache: {
+        readonly nerd: "⟳";
+        readonly plain: "cache";
+    };
+    readonly resume: {
+        readonly nerd: "⟲";
+        readonly plain: "";
+    };
+    readonly levelOk: {
+        readonly nerd: "󰗡";
+        readonly plain: "●";
+    };
+    readonly levelWarn: {
+        readonly nerd: "󰀪";
+        readonly plain: "▲";
+    };
+    readonly levelError: {
+        readonly nerd: "󰅚";
+        readonly plain: "×";
+    };
+    readonly levelOff: {
+        readonly nerd: "󰍷";
+        readonly plain: "○";
+    };
+    readonly levelInfo: {
+        readonly nerd: "󰋽";
+        readonly plain: "•";
+    };
+    readonly statusLsp: {
+        readonly nerd: "󰅩";
+        readonly plain: "•";
+    };
+    readonly statusGraphify: {
+        readonly nerd: "󱁊";
+        readonly plain: "•";
+    };
+    readonly modeBuild: {
+        readonly nerd: "󰚩";
+        readonly plain: "";
+    };
+    readonly modePlan: {
+        readonly nerd: "󰈈";
+        readonly plain: "";
+    };
+    readonly capLeft: {
+        readonly nerd: "";
+        readonly plain: "▐";
+    };
+    readonly capRight: {
+        readonly nerd: "";
+        readonly plain: "▌";
+    };
+    readonly toolRead: {
+        readonly nerd: "󰧮";
+        readonly plain: "→";
+    };
+    readonly toolWrite: {
+        readonly nerd: "󰻭";
+        readonly plain: "+";
+    };
+    readonly toolEdit: {
+        readonly nerd: "󰏫";
+        readonly plain: "~";
+    };
+    readonly toolBash: {
+        readonly nerd: "󰆍";
+        readonly plain: "$";
+    };
+    readonly toolGrep: {
+        readonly nerd: "󰍉";
+        readonly plain: "?";
+    };
+    readonly toolFind: {
+        readonly nerd: "󰱽";
+        readonly plain: "*";
+    };
+    readonly toolLs: {
+        readonly nerd: "󰉖";
+        readonly plain: "/";
+    };
+    readonly toolOther: {
+        readonly nerd: "";
+        readonly plain: "•";
+    };
+    readonly telSpeed: {
+        readonly nerd: "󰓅";
+        readonly plain: "";
+    };
+    readonly telTtft: {
+        readonly nerd: "󰔟";
+        readonly plain: "";
+    };
+    readonly telTotal: {
+        readonly nerd: "󰅐";
+        readonly plain: "";
+    };
+    readonly telStall: {
+        readonly nerd: "󰀪";
+        readonly plain: "";
+    };
+    readonly diff: {
+        readonly nerd: "󰊢";
+        readonly plain: "";
+    };
+    readonly widgetContainer: {
+        readonly nerd: "󰡨";
+        readonly plain: "";
+    };
+    readonly widgetK8s: {
+        readonly nerd: "󱃾";
+        readonly plain: "";
+    };
+    readonly widgetMcp: {
+        readonly nerd: "󰚥";
+        readonly plain: "";
+    };
+    readonly widgetSessionTodos: {
+        readonly nerd: "󰢨";
+        readonly plain: "";
+    };
+    readonly widgetSubagents: {
+        readonly nerd: "󰭘";
+        readonly plain: "";
+    };
+    readonly widgetTodo: {
+        readonly nerd: "󰝖";
+        readonly plain: "";
+    };
+};
+export type IconName = keyof typeof ICONS;
+/** The saved setting from the state file (`icons`), or undefined. */
+export declare function loadIconSetting(path?: string): IconSet | undefined;
+/** Set the user's setting for this run (undefined forgets it). Saving to the file is `saveIconSetting`. */
+export declare function setIconSetting(set: IconSet | undefined): void;
+/** Forget what was read, so the next call reads the state file again (tests, and /reload). */
+export declare function resetIconSetting(): void;
+/** Where the current set comes from, for `/chassis icons`. */
+export declare function iconSource(): "env" | "setting" | "brand" | "default";
+/** The icon set in use. */
+export declare function iconSet(): IconSet;
+/** The glyph for `name` in the current set. May be "" (no icon). */
+export declare function icon(name: IconName): string;
+/** `glyph`, a space, then `text`; just `text` when there is no glyph. */
+export declare const withIcon: (glyph: string, text: string) => string;
+/** "<glyph> " painted with `paint`, or nothing when the set has no glyph here. */
+export declare const leadIcon: (glyph: string, paint: (s: string) => string) => string;
+export declare const hasPrivateUse: (s: string) => boolean;
+/**
+ * A widget's or brand's icon in the current set, or undefined when it has none there. An object
+ * gives its `nerd` or `plain` string. A bare string is used as given in the nerd set; in the plain
+ * set it loses any private-use characters (a font the terminal may not have), and is undefined if
+ * nothing but blanks is left.
+ */
+export declare function resolveIcon(like: IconLike | undefined): string | undefined;
+/**
+ * A single-cell mark that is safe to draw: in the plain set a private-use glyph (a brand's own
+ * font) is replaced by `fallback`.
+ */
+export declare function safeGlyph(glyph: string, fallback?: string): string;
+/** The usage circle for 0 to 100 percent, filled in eighths; a blank slot in the plain set. */
+export declare function usageIcon(percent: number | undefined): string;
+/** Save the user's setting into the state file, keeping its other keys. Best effort. */
+export declare function saveIconSetting(set: IconSet | undefined, path?: string): void;

package/dist/chassis/icons.js

@@ -0,0 +1,190 @@
+/**
+ * Icons: every glyph chassis draws from a Nerd Font lives here, each with a plain twin that needs
+ * no special font. The plain twin takes the same number of cells as the Nerd glyph (one, or none
+ * where the words beside it already say it), so no layout changes between the two sets.
+ *
+ * Which set is used, first match wins:
+ *   1. the PI_CHASSIS_ICONS environment variable ("nerd" or "plain")
+ *   2. the user's setting, `/chassis icons nerd|plain`, saved in chassis.json
+ *   3. the brand's default (`icons` in its spec: a brand that ships a font can ask for "nerd")
+ *   4. plain, so a terminal without a Nerd Font never shows empty boxes
+ *
+ * The plain glyphs are ASCII or characters that exist in the common monospace fonts (DejaVu Sans
+ * Mono, Noto Sans Mono, Consolas and Lucida Console were checked): • · ↑ ↓ → ● ○ ▲ × ▐ ▌.
+ *
+ * This file is the only place with Nerd Font code points. test/icons.test.ts fails on one anywhere else.
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { getBrand } from "./brand.js";
+import { statePath } from "./api.js";
+/** nf-md-* unless noted. "" means no icon in that set. */
+export const ICONS = {
+    // sidebar: provider section
+    provider: { nerd: "\u{F06A9}", plain: "\u25A0" }, // robot; a filled square
+    usage: { nerd: "\u{F0766}", plain: " " }, // circle-outline; the filled slices are computed from it
+    branch: { nerd: "\uF418", plain: "" }, // octicons git-branch
+    worktree: { nerd: "\u{F04E0}", plain: "wt" }, // source-fork: a linked git worktree
+    cache: { nerd: "\u27F3", plain: "cache" },
+    resume: { nerd: "\u27F2", plain: "" },
+    // a widget row's level marker
+    levelOk: { nerd: "\u{F05E1}", plain: "\u25CF" }, // check-circle-outline
+    levelWarn: { nerd: "\u{F002A}", plain: "\u25B2" }, // alert-outline
+    levelError: { nerd: "\u{F015A}", plain: "\u00D7" }, // close-circle-outline
+    levelOff: { nerd: "\u{F0377}", plain: "\u25CB" }, // minus-circle-outline
+    levelInfo: { nerd: "\u{F02FD}", plain: "\u2022" }, // information-outline
+    // marks for plain setStatus() lines
+    statusLsp: { nerd: "\u{F0169}", plain: "\u2022" }, // code-braces
+    statusGraphify: { nerd: "\u{F104A}", plain: "\u2022" }, // graph-outline
+    // prompt row
+    modeBuild: { nerd: "\u{F06A9}", plain: "" }, // robot
+    modePlan: { nerd: "\u{F0208}", plain: "" }, // eye
+    capLeft: { nerd: "\uE0B6", plain: "\u2590" }, // powerline round cap; right half block
+    capRight: { nerd: "\uE0B4", plain: "\u258C" }, // powerline round cap; left half block
+    // tool rows
+    toolRead: { nerd: "\u{F09EE}", plain: "\u2192" }, // file-document-outline
+    toolWrite: { nerd: "\u{F0EED}", plain: "+" }, // file-plus-outline
+    toolEdit: { nerd: "\u{F03EB}", plain: "~" }, // pencil
+    toolBash: { nerd: "\u{F018D}", plain: "$" }, // console
+    toolGrep: { nerd: "\u{F0349}", plain: "?" }, // magnify
+    toolFind: { nerd: "\u{F0C7D}", plain: "*" }, // file-search-outline
+    toolLs: { nerd: "\u{F0256}", plain: "/" }, // folder-outline
+    toolOther: { nerd: "\uF013", plain: "\u2022" }, // fontawesome cog: a tool with no spec of its own
+    // turn telemetry: the words beside them say it
+    telSpeed: { nerd: "\u{F04C5}", plain: "" }, // speedometer
+    telTtft: { nerd: "\u{F051F}", plain: "" }, // timer-sand
+    telTotal: { nerd: "\u{F0150}", plain: "" }, // clock-outline
+    telStall: { nerd: "\u{F002A}", plain: "" }, // alert-outline
+    // diff view
+    diff: { nerd: "\u{F02A2}", plain: "" }, // source-branch
+    // widgets. A section heading or a row marker with no plain glyph falls back to the row bullet.
+    widgetContainer: { nerd: "\u{F0868}", plain: "" }, // docker
+    widgetK8s: { nerd: "\u{F10FE}", plain: "" }, // kubernetes
+    widgetMcp: { nerd: "\u{F06A5}", plain: "" }, // server-network
+    widgetSessionTodos: { nerd: "\u{F08A8}", plain: "" }, // clipboard-check-outline
+    widgetSubagents: { nerd: "\u{F0B58}", plain: "" }, // account-group-outline
+    widgetTodo: { nerd: "\u{F0756}", plain: "" }, // format-list-checks
+};
+/** The slice glyphs of the usage circle come after this one: U+F0A9E is one eighth. */
+const USAGE_SLICE_BASE = 0xf0a9d;
+const KEY = Symbol.for("pi-chassis/icons");
+function slot() {
+    const g = globalThis;
+    g[KEY] ??= { loaded: false };
+    return g[KEY];
+}
+const asSet = (v) => (v === "nerd" || v === "plain" ? v : undefined);
+/** The saved setting from the state file (`icons`), or undefined. */
+export function loadIconSetting(path = statePath()) {
+    try {
+        return asSet(JSON.parse(readFileSync(path, "utf8"))?.icons);
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Set the user's setting for this run (undefined forgets it). Saving to the file is `saveIconSetting`. */
+export function setIconSetting(set) {
+    const s = slot();
+    s.setting = set;
+    s.loaded = true;
+}
+/** Forget what was read, so the next call reads the state file again (tests, and /reload). */
+export function resetIconSetting() {
+    const s = slot();
+    s.setting = undefined;
+    s.loaded = false;
+}
+/** Where the current set comes from, for `/chassis icons`. */
+export function iconSource() {
+    if (asSet(process.env.PI_CHASSIS_ICONS))
+        return "env";
+    const s = slot();
+    if (!s.loaded) {
+        s.setting = loadIconSetting();
+        s.loaded = true;
+    }
+    if (s.setting)
+        return "setting";
+    return asSet(getBrand().icons) ? "brand" : "default";
+}
+/** The icon set in use. */
+export function iconSet() {
+    const env = asSet(process.env.PI_CHASSIS_ICONS);
+    if (env)
+        return env;
+    const s = slot();
+    if (!s.loaded) {
+        s.setting = loadIconSetting();
+        s.loaded = true;
+    }
+    return s.setting ?? asSet(getBrand().icons) ?? "plain";
+}
+// ---- resolving --------------------------------------------------------------------------------
+/** The glyph for `name` in the current set. May be "" (no icon). */
+export function icon(name) {
+    return ICONS[name][iconSet()];
+}
+/** `glyph`, a space, then `text`; just `text` when there is no glyph. */
+export const withIcon = (glyph, text) => (glyph ? `${glyph} ${text}` : text);
+/** "<glyph> " painted with `paint`, or nothing when the set has no glyph here. */
+export const leadIcon = (glyph, paint) => (glyph ? `${paint(glyph)} ` : "");
+/** Private-use code points: where Nerd Font (and any custom icon font) glyphs live. */
+const PRIVATE_USE = /[\uE000-\uF8FF\u{F0000}-\u{FFFFD}\u{100000}-\u{10FFFD}]/gu;
+export const hasPrivateUse = (s) => new RegExp(PRIVATE_USE.source, "u").test(s);
+/**
+ * A widget's or brand's icon in the current set, or undefined when it has none there. An object
+ * gives its `nerd` or `plain` string. A bare string is used as given in the nerd set; in the plain
+ * set it loses any private-use characters (a font the terminal may not have), and is undefined if
+ * nothing but blanks is left.
+ */
+export function resolveIcon(like) {
+    if (like === undefined || like === "")
+        return undefined;
+    if (typeof like === "object") {
+        const s = iconSet() === "nerd" ? like.nerd : like.plain;
+        return s ? s : undefined;
+    }
+    if (iconSet() === "nerd")
+        return like;
+    const kept = like.replace(PRIVATE_USE, "");
+    return kept.trim() ? kept : undefined;
+}
+/**
+ * A single-cell mark that is safe to draw: in the plain set a private-use glyph (a brand's own
+ * font) is replaced by `fallback`.
+ */
+export function safeGlyph(glyph, fallback = "\u25CF") {
+    return iconSet() === "plain" && hasPrivateUse(glyph) ? fallback : glyph;
+}
+/** The usage circle for 0 to 100 percent, filled in eighths; a blank slot in the plain set. */
+export function usageIcon(percent) {
+    if (iconSet() === "plain")
+        return ICONS.usage.plain;
+    const eighths = percent === undefined || !Number.isFinite(percent) ? 0 : Math.round((Math.max(0, Math.min(100, percent)) / 100) * 8);
+    return eighths === 0 ? ICONS.usage.nerd : String.fromCodePoint(USAGE_SLICE_BASE + eighths);
+}
+// ---- saving -----------------------------------------------------------------------------------
+/** Save the user's setting into the state file, keeping its other keys. Best effort. */
+export function saveIconSetting(set, path = statePath()) {
+    try {
+        let data = {};
+        if (existsSync(path)) {
+            try {
+                data = JSON.parse(readFileSync(path, "utf8")) ?? {};
+            }
+            catch {
+                data = {};
+            }
+        }
+        if (set)
+            data.icons = set;
+        else
+            delete data.icons;
+        mkdirSync(dirname(path), { recursive: true });
+        writeFileSync(path, `${JSON.stringify(data, null, 2)}\n`);
+    }
+    catch {
+        // the in-memory setting still applies for this run
+    }
+}

package/dist/chassis/index.d.ts

@@ -0,0 +1,21 @@
+/**
+ * chassis: an OpenCode-style TUI for pi, with a brand that another package can replace (brand.ts).
+ *
+ * Pieces (each in its own file):
+ *   layout.ts    right sidebar (fullscreen split, overlay fallback)       ctrl+x b
+ *   home.ts      OpenCode-style home screen (logo, centred prompt, tip, bottom bar)
+ *   sidebar.ts   session title, context/cost, status widgets, files, todo
+ *   footer.ts    one-line status bar under the prompt
+ *   editor.ts    left-rail prompt with mode badge + model, leader key, Tab mode switch
+ *   commands.ts  ctrl+x leader actions and the ctrl+p command palette
+ *   modes.ts     Build / Plan (read-only) agent modes
+ *   tools.ts     one-line tool rows ("→ Read x.ts  120 lines")
+ *   messages.ts  user prompts with a coloured left bar
+ *   peek.ts      thinking peek in the hidden-thinking label
+ *   telemetry.ts per-run TPS/TTFT/tokens/cost summary
+ *   api.ts       the widget registry other extensions use (registerWidget)
+ *
+ * Commands: /chassis [on|off|sidebar|status]
+ */
+import { type ExtensionAPI } from "@earendil-works/pi-coding-agent";
+export default function (pi: ExtensionAPI): void;