@huseynsnmz/pi-suite 0.0.0-stage → 0.2.0

package/packages/frame/src/render/glyphs.ts

@@ -0,0 +1,189 @@
+export type IconMode = "auto" | "nerd" | "unicode" | "ascii";
+export type IconSet = Exclude<IconMode, "auto">;
+
+export interface Glyphs {
+	set: IconSet;
+	folder: string;
+	branch: string;
+	host: string;
+	session: string;
+	board: string;
+	peers: string;
+	waiting: string;
+	queued: string;
+	version: string;
+	model: string;
+	effort: string;
+	context: string;
+	speed: string;
+	wait: string;
+	running: string;
+	done: string;
+	sent: string;
+	received: string;
+	cacheRead: string;
+	cacheWrite: string;
+	cost: string;
+	clock: string;
+	plug: string;
+	ahead: string;
+	behind: string;
+	staged: string;
+	modified: string;
+	untracked: string;
+	conflicted: string;
+	stashed: string;
+	fill: string;
+	empty: string;
+	ellipsis: string;
+	/** Between the folder's agents and each shared room's. */
+	apart: string;
+	/** How this session stands in a room, as the rooms panel marks it. */
+	roomIn: string;
+	roomListening: string;
+	roomOut: string;
+	/** An agent at work and one waiting for work, as the panel and the board mark them. */
+	agentWorking: string;
+	agentIdle: string;
+}
+
+const COMMON = {
+	ahead: "↑",
+	behind: "↓",
+	staged: "+",
+	modified: "~",
+	untracked: "?",
+	conflicted: "!",
+	sent: "↑",
+	received: "↓",
+	apart: "│",
+	roomIn: "●",
+	roomListening: "◐",
+	roomOut: "○",
+	agentWorking: "◆",
+	agentIdle: "◇",
+};
+
+export const NERD: Glyphs = {
+	...COMMON,
+	set: "nerd",
+	folder: "\u{f07c}", // nf-fa-folder_open
+	branch: "\u{e0a0}", // nf-pl-branch
+	host: "\u{f108}", // nf-fa-desktop
+	session: "\u{f02b}", // nf-fa-tag
+	board: "\u{f04fe}", // nf-md-target
+	peers: "\u{f0c0}", // nf-fa-users
+	waiting: "\u{f024}", // nf-fa-flag
+	queued: "\u{f051f}", // nf-md-timer_sand
+	version: "π",
+	model: "\u{f06a9}", // nf-md-robot
+	effort: "\u{f09d1}", // nf-md-brain
+	context: "\u{f035b}", // nf-md-memory
+	speed: "\u{f04c5}", // nf-md-speedometer
+	wait: "\u{f252}", // nf-fa-hourglass_half
+	running: "\u{f017}", // nf-fa-clock_o
+	done: "\u{f00c}", // nf-fa-check
+	cacheRead: "\u{f1c0}", // nf-fa-database
+	cacheWrite: "\u{f0c7}", // nf-fa-floppy_o
+	cost: "$",
+	clock: "\u{f017}", // nf-fa-clock_o
+	plug: "\u{f1e6}", // nf-fa-plug
+	stashed: "\u{f01c}", // nf-fa-inbox
+	fill: "█",
+	empty: "░",
+	ellipsis: "...",
+};
+
+export const UNICODE: Glyphs = {
+	...COMMON,
+	set: "unicode",
+	folder: "▸",
+	branch: "⎇",
+	host: "⌂",
+	session: "#",
+	board: "▸",
+	peers: "◆",
+	waiting: "⚑",
+	queued: "⧗",
+	version: "π",
+	model: "◆",
+	effort: "✦",
+	context: "◔",
+	speed: "»",
+	wait: "⧗",
+	running: "◷",
+	done: "✓",
+	cacheRead: "≋",
+	cacheWrite: "≈",
+	cost: "$",
+	clock: "◷",
+	plug: "≫",
+	stashed: "≡",
+	fill: "█",
+	empty: "░",
+	ellipsis: "...",
+};
+
+export const ASCII: Glyphs = {
+	set: "ascii",
+	apart: "|",
+	roomIn: "+",
+	roomListening: "~",
+	roomOut: "-",
+	agentWorking: ">",
+	agentIdle: "-",
+	folder: "",
+	branch: "",
+	host: "@",
+	session: "#",
+	board: ">",
+	peers: "@",
+	waiting: "",
+	queued: "",
+	version: "v",
+	model: "",
+	effort: "",
+	context: "ctx",
+	speed: "",
+	wait: "ttft",
+	running: "",
+	done: "",
+	sent: "^",
+	received: "v",
+	cacheRead: "R",
+	cacheWrite: "W",
+	cost: "$",
+	clock: "",
+	plug: ">>",
+	ahead: "^",
+	behind: "v",
+	staged: "+",
+	modified: "~",
+	untracked: "?",
+	conflicted: "!",
+	stashed: "s",
+	fill: "#",
+	empty: "-",
+	ellipsis: "...",
+};
+
+const SETS: Record<IconSet, Glyphs> = { nerd: NERD, unicode: UNICODE, ascii: ASCII };
+
+export function resolveIcons(mode: IconMode, env: NodeJS.ProcessEnv = process.env): Glyphs {
+	if (mode !== "auto") return SETS[mode];
+	if (env.TERM === "dumb") return ASCII;
+	const locale = env.LC_ALL ?? env.LC_CTYPE ?? env.LANG;
+	if (locale !== undefined && locale !== "" && !/utf-?8/i.test(locale)) return ASCII;
+	// Nothing can tell which font the terminal draws with, and a missing icon shows as a box or `[?]`.
+	return UNICODE;
+}
+
+/** Resolved again only when the setting changes; resolving per drawing was a fifth of typing's cost. */
+export function glyphsOf(modeOf: () => IconMode): () => Glyphs {
+	let known: { mode: IconMode; glyphs: Glyphs } | undefined;
+	return () => {
+		const mode = modeOf();
+		if (known?.mode !== mode) known = { mode, glyphs: resolveIcons(mode) };
+		return known.glyphs;
+	};
+}

package/packages/frame/src/render/keys.ts

@@ -0,0 +1,43 @@
+import { type KeyId, matchesKey } from "@earendil-works/pi-tui";
+
+/** Opens the settings. Alt+S belongs to pi-sandbox, which can't be rebound. */
+export const SETTINGS_KEY = "ctrl+s";
+
+/**
+ * Pi warns at every start about a shortcut on Ctrl+S, which its pickers use for themselves. So the
+ * shortcut sits here and the editor passes Ctrl+S on to it, which leaves the pickers their key.
+ */
+export const SETTINGS_SHORTCUT = "ctrl+alt+s";
+export const SETTINGS_SHORTCUT_INPUT = "\u001b[115;7u";
+
+/** Cmd reaches Pi only through the kitty keyboard protocol, and not every Cmd key: these are free. */
+const CMD_KEYS: Readonly<Record<string, { key: string; sends: string }>> = {
+	s: { key: SETTINGS_KEY, sends: "\u0013" },
+	o: { key: "alt+o", sends: "\u001b[111;3u" },
+};
+
+let reportsCmd: () => boolean = () => false;
+
+/** Called with the terminal once there is one. It answers after the first draw. */
+export function watchCmdKey(reports: () => boolean): void {
+	reportsCmd = reports;
+}
+
+/** A Mac has Option where others have Alt, and Cmd where the terminal can send it. */
+export function keyLabel(
+	key: string,
+	platform: string = process.platform,
+	cmd: boolean = reportsCmd(),
+): string {
+	if (platform !== "darwin") return key;
+	const letter = Object.keys(CMD_KEYS).find((name) => CMD_KEYS[name]?.key === key);
+	if (cmd && letter !== undefined) return `cmd+${letter}`;
+	return key.replace(/\balt\+/g, "option+");
+}
+
+/** A Cmd key as the key its shortcut listens for. Undefined for any other input. */
+export function cmdAsKey(data: string): string | undefined {
+	for (const [letter, { sends }] of Object.entries(CMD_KEYS))
+		if (matchesKey(data, `super+${letter}` as KeyId)) return sends;
+	return undefined;
+}

package/packages/frame/src/render/lead.ts

@@ -0,0 +1,37 @@
+/** How much of a prompt Pi will treat as a command: `/name` or `!command`, up to the first space. */
+export function promptLead(text: string): { kind: "command" | "bash"; length: number } | undefined {
+	const command = /^\/[\w:.-]+(?=\s|$)/.exec(text);
+	if (command) return { kind: "command", length: command[0].length };
+	const bash = /^!{1,2}\s*\S*/.exec(text);
+	return bash ? { kind: "bash", length: bash[0].length } : undefined;
+}
+
+// oxlint-disable-next-line no-control-regex -- a rendered line carries escapes between its characters
+const ESCAPE = /^\x1b(?:\[[0-9;?]*[ -/]*[@-~]|[_\]][^\x07\x1b]*(?:\x07|\x1b\\))/;
+
+/** Paints the first characters of a rendered line. Its escapes, like the cursor, stay where they are. */
+export function paintLead(line: string, length: number, paint: (text: string) => string): string {
+	let out = "";
+	let run = "";
+	let left = length;
+	let at = 0;
+	const flush = () => {
+		if (run) out += paint(run);
+		run = "";
+	};
+	while (at < line.length && left > 0) {
+		const escape = ESCAPE.exec(line.slice(at));
+		if (escape) {
+			flush();
+			out += escape[0];
+			at += escape[0].length;
+			continue;
+		}
+		const char = String.fromCodePoint(line.codePointAt(at) as number);
+		run += char;
+		at += char.length;
+		left--;
+	}
+	flush();
+	return out + line.slice(at);
+}

package/packages/frame/src/render/paint.ts

@@ -0,0 +1,135 @@
+import type { Theme, ThemeColor } from "@earendil-works/pi-coding-agent";
+
+export type Role =
+	| "path"
+	| "branch"
+	| "ahead"
+	| "behind"
+	| "staged"
+	| "modified"
+	| "untracked"
+	| "conflicted"
+	| "host"
+	| "session"
+	| "board"
+	| "waiting"
+	| "queued"
+	| "version"
+	| "provider"
+	| "model"
+	| "sent"
+	| "received"
+	| "cache"
+	| "speed"
+	| "wait"
+	| "running"
+	| "done"
+	| "cost"
+	| "clock"
+	| "brand";
+
+export const ROLE_TOKENS: Record<Role, ThemeColor> = {
+	path: "accent",
+	branch: "syntaxFunction",
+	ahead: "success",
+	behind: "warning",
+	staged: "success",
+	modified: "warning",
+	untracked: "muted",
+	conflicted: "error",
+	host: "syntaxType",
+	session: "mdHeading",
+	board: "accent",
+	waiting: "warning",
+	queued: "muted",
+	version: "muted",
+	provider: "syntaxKeyword",
+	model: "text",
+	sent: "mdLink",
+	received: "success",
+	cache: "syntaxType",
+	speed: "success",
+	wait: "syntaxNumber",
+	running: "accent",
+	done: "success",
+	cost: "syntaxNumber",
+	clock: "muted",
+	brand: "accent",
+};
+
+const EFFORT_TOKENS: Record<string, ThemeColor> = {
+	off: "thinkingOff",
+	minimal: "thinkingMinimal",
+	low: "thinkingLow",
+	medium: "thinkingMedium",
+	high: "thinkingHigh",
+	xhigh: "thinkingXhigh",
+	max: "thinkingMax",
+};
+
+export const EFFORT_LEVELS = ["minimal", "low", "medium", "high", "xhigh", "max"] as const;
+
+export interface Paint {
+	dim(text: string): string;
+	muted(text: string): string;
+	text(text: string): string;
+	bold(text: string): string;
+	italic(text: string): string;
+	role(role: Role, text: string): string;
+	effort(level: string, text: string): string;
+	stress(percent: number, text: string): string;
+	money(amount: number, text: string): string;
+	frame(text: string): string;
+	/** A theme color a package named in a contract, like a peer's. */
+	raw(color: string, text: string): string;
+}
+
+export function themePaint(theme: Theme, frame?: (text: string) => string): Paint {
+	return {
+		dim: (text) => theme.fg("dim", text),
+		muted: (text) => theme.fg("muted", text),
+		text: (text) => theme.fg("text", text),
+		bold: (text) => theme.bold(text),
+		italic: (text) => theme.italic(text),
+		role: (role, text) => theme.fg(ROLE_TOKENS[role], text),
+		effort: (level, text) => theme.fg(EFFORT_TOKENS[level] ?? "thinkingOff", text),
+		stress: (percent, text) => theme.fg(stressToken(percent), text),
+		money: (amount, text) => theme.fg(moneyToken(amount), text),
+		frame: frame ?? ((text) => theme.fg("border", text)),
+		raw: (color, text) =>
+			theme.fg(
+				theme.colors[color as ThemeColor] === undefined ? "muted" : (color as ThemeColor),
+				text,
+			),
+	};
+}
+
+function stressToken(percent: number): ThemeColor {
+	if (percent >= 90) return "error";
+	if (percent >= 70) return "warning";
+	return "success";
+}
+
+function moneyToken(amount: number): ThemeColor {
+	if (amount >= 10) return "error";
+	if (amount >= 1) return "warning";
+	return ROLE_TOKENS.cost;
+}
+
+export const PLAIN: Paint = {
+	dim: identity,
+	muted: identity,
+	text: identity,
+	bold: identity,
+	italic: identity,
+	role: (_role, text) => text,
+	effort: (_level, text) => text,
+	stress: (_percent, text) => text,
+	money: (_amount, text) => text,
+	frame: identity,
+	raw: (_color, text) => text,
+};
+
+function identity(text: string): string {
+	return text;
+}

package/packages/frame/src/render/safe.ts

@@ -0,0 +1,19 @@
+// Text from a model, a repository or another program must not drive the terminal: no clipboard
+// writes, no moved cursor, no command that reads differently from what runs.
+
+// oxlint-disable-next-line no-control-regex -- escape sequences are what this removes
+const ESCAPE = /\u001b(?:\[[0-?]*[ -/]*[@-~]?|[\]PX^_][^\u0007\u001b\n]*(?:\u0007|\u001b\\)?|[ -/]*[0-~]?)/g;
+// oxlint-disable-next-line no-control-regex -- color codes are escape sequences
+const COLOR = /^\u001b\[[0-9;:]*m$/;
+/** Keeps tabs and line breaks. ESCAPE has already taken every escape character. */
+// oxlint-disable-next-line no-control-regex -- control characters are what this removes
+const CONTROLS = /[\u0000-\u0008\u000b-\u001a\u001c-\u001f\u007f-\u009f‪-‮⁦-⁩]/g;
+
+export function plainText(text: string): string {
+	return text.replace(ESCAPE, "").replace(CONTROLS, "");
+}
+
+/** For lines already painted: keeps the colors and nothing else that talks to the terminal. */
+export function styledText(text: string): string {
+	return text.replace(ESCAPE, (found) => (COLOR.test(found) ? found : "")).replace(CONTROLS, "");
+}