pi-maestro-teammate 2.6.2 → 2.7.1

package/node_modules/pi-maestro-settings-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-maestro-settings-core",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "description": "Versioned Settings and i18n contracts shared by Pi Maestro plugins.",
   "type": "module",
   "engines": {
@@ -17,7 +17,8 @@
     "./v1/events": "./src/public/v1/events.ts",
     "./v1/provider": "./src/public/v1/provider.ts",
     "./v1/schema": "./src/public/v1/schema.ts",
-    "./v1/i18n": "./src/public/v1/i18n.ts"
+    "./v1/i18n": "./src/public/v1/i18n.ts",
+    "./ui": "./src/ui/index.ts"
   },
   "files": [
     "src/**/*.ts"

package/node_modules/pi-maestro-settings-core/src/index.ts

@@ -1 +1,2 @@
-export * from "./public/v1/index.ts";
+export * from "./public/v1/index.ts";
+export * from "./ui/index.ts";

package/node_modules/pi-maestro-settings-core/src/public/v1/index.ts

@@ -1,4 +1,32 @@
-export * from "./events.ts";
-export * from "./i18n.ts";
-export * from "./provider.ts";
-export * from "./schema.ts";
+export * from "./events.ts";
+export * from "./provider.ts";
+export * from "./schema.ts";
+
+// The keyboard-shortcut helpers live in the shared UI primitives module so
+// Cockpit, Flow, and Teammate all import the same implementation. Keep the
+// rest of the i18n surface unchanged.
+export {
+	SUPPORTED_SETTINGS_LOCALES,
+	checkCatalogCompleteness,
+	createSettingsTranslator,
+	detectSystemSettingsLocale,
+	interpolateTranslation,
+	mergeTranslationCatalogs,
+	normalizeSettingsLocale,
+	resolveSettingsLocale,
+	translateSettings,
+	type CatalogCompletenessIssue,
+	type CatalogCompletenessIssueKind,
+	type CatalogCompletenessResult,
+	type MissingTranslation,
+	type MissingTranslationCallback,
+	type SettingsTranslator,
+	type SettingsTranslatorOptions,
+	type SupportedSettingsLocale,
+	type SystemSettingsLocaleOptions,
+	type TranslationCatalog,
+	type TranslationCatalogs,
+	type TranslationParams,
+} from "./i18n.ts";
+
+export { altKey, altLabel } from "../../ui/key-labels.ts";

package/node_modules/pi-maestro-settings-core/src/ui/ansi-bridge.ts

@@ -0,0 +1,102 @@
+// ANSI → Span bridge (transitional).
+//
+// Lets a legacy `render(width): string[]` body feed the Frame model without a
+// rewrite: SGR color/style codes are folded onto the closed Role vocabulary,
+// every other escape sequence is stripped. Raw ANSI never crosses the wire —
+// the RPC backend only sees roles, and the TTY backend re-emits them through
+// the theme, which also normalizes plugin styling onto theme slots.
+//
+// Deliberate limits (transitional bridge, not a terminal emulator):
+// - Extended colors (38;5;N / 38;2;R;G;B / bg variants) cannot map to a Role
+//   and are dropped — migrate hot paths to Span roles directly.
+// - Italic/underline/blink have no Role and are dropped.
+// - Inverse video (SGR 7) maps to "selected"; a row containing it gets the
+//   selected-row background in renderChrome — avoid for in-row cursor cells.
+
+import { type Role, type Span } from "./overlay-spec.ts";
+
+/** SGR parameter → Role. Bright variants (90-97) share the base-color role. */
+const SGR_ROLE: Record<number, Role> = {
+	2: "dim",
+	7: "selected",
+	30: "muted",
+	31: "error",
+	32: "success",
+	33: "warning",
+	34: "muted",
+	35: "accent",
+	36: "accent",
+	37: "text",
+	90: "dim",
+	91: "error",
+	92: "success",
+	93: "warning",
+	94: "muted",
+	95: "accent",
+	96: "accent",
+	97: "text",
+};
+
+/** Parse one rendered line into styled spans. */
+export function ansiToSpans(line: string): Span[] {
+	const spans: Span[] = [];
+	let role: Role = "text";
+	let bold = false;
+	let buf = "";
+	const flush = (): void => {
+		if (!buf) return;
+		const s: Span = { text: buf };
+		if (role !== "text") s.role = role;
+		if (bold) s.bold = true;
+		spans.push(s);
+		buf = "";
+	};
+
+	let i = 0;
+	while (i < line.length) {
+		const ch = line[i];
+		if (ch === "\x1b") {
+			if (line[i + 1] === "]") {
+				// OSC: ESC ] … (BEL | ESC \) — strip entirely.
+				let j = i + 2;
+				while (j < line.length && line[j] !== "\x07" && !(line[j] === "\x1b" && line[j + 1] === "\\")) j++;
+				i = line[j] === "\x07" ? j + 1 : j + 2;
+				continue;
+			}
+			if (line[i + 1] === "[") {
+				// CSI: ESC [ params final-byte.
+				let j = i + 2;
+				while (j < line.length && !/[@-~]/.test(line[j])) j++;
+				const final = line[j];
+				const params = line.slice(i + 2, j);
+				i = j + 1;
+				if (final !== "m") continue; // non-SGR CSI: strip
+				flush();
+				for (const p of params.split(";")) {
+					const n = p === "" ? 0 : Number.parseInt(p, 10);
+					if (!Number.isFinite(n)) continue;
+					if (n === 0) { role = "text"; bold = false; }
+					else if (n === 1) bold = true;
+					else if (n === 22) bold = false;
+					else if (n === 39) role = "text";
+					else if (n === 27 && role === "selected") role = "text";
+					else if (SGR_ROLE[n] !== undefined) role = SGR_ROLE[n];
+					// 38/48 extended colors, 40-47/49/100-107 bg, 3/4/5/9 styles: drop.
+				}
+				continue;
+			}
+			i++; // lone ESC / other escape introducer: skip the byte.
+			continue;
+		}
+		if (ch < " " && ch !== "\t") { i++; continue; } // C0 controls: strip.
+		buf += ch;
+		i++;
+	}
+	flush();
+	return spans;
+}
+
+/** Convert a whole legacy render output into a Frame. */
+export function ansiToFrame(lines: readonly string[]): Span[][] {
+	return lines.map(ansiToSpans);
+}

package/node_modules/pi-maestro-settings-core/src/ui/icons.ts

@@ -0,0 +1,168 @@
+export type IconMode = "auto" | "nerd" | "ascii";
+
+export interface IconGlyphs {
+	spinFrames: string;
+	dotRunning: string;
+	dotIdle: string;
+	check: string;
+	cross: string;
+	pending: string;
+	blocked: string;
+	barDone: string;
+	barActive: string;
+	barPending: string;
+	arrow: string;
+	/** Points at a dependency/upstream ("blocked by", "waits on"). */
+	depArrow: string;
+	/** Creator-to-assignee transfer indicator in actor labels. */
+	transferArrow: string;
+	/** Tree connectors. Routed through the glyph set so ascii mode stays ascii. */
+	treeBranch: string;
+	treeLast: string;
+	treeVertical: string;
+	treeSpace: string;
+	ellipsis: string;
+	separator: string;
+	/** Overlay chrome. Kept in the glyph table so ascii mode draws a real ascii box. */
+	box: {
+		topLeft: string;
+		topRight: string;
+		bottomLeft: string;
+		bottomRight: string;
+		horizontal: string;
+		vertical: string;
+	};
+	/** Marks the focused row. Must survive without the selected background colour. */
+	selectMarker: string;
+	/** Marks an empty collection. */
+	emptyMark: string;
+	/** Vertical navigation affordance shown in help lines. */
+	upDown: string;
+	model: string;
+	workspace: string;
+	git: string;
+	tokensIn: string;
+	tokensOut: string;
+	cost: string;
+	cacheHit: string;
+}
+
+const NERD_GLYPHS: IconGlyphs = {
+	spinFrames: "⠋⠙⠹⠴⠦⠇",
+	dotRunning: "●",
+	dotIdle: "·",
+	check: "✓",
+	cross: "✕",
+	// A hollow ring, not the idle dot: "waiting to start" and "running but quiet"
+	// are different states and must not share a glyph.
+	pending: "○",
+	blocked: "!",
+	barDone: "█",
+	barActive: "▓",
+	barPending: "░",
+	arrow: "»",
+	depArrow: "←",
+	transferArrow: "→",
+	treeBranch: "├─",
+	treeLast: "└─",
+	treeVertical: "│ ",
+	treeSpace: "  ",
+	ellipsis: "…",
+	separator: " · ",
+	box: { topLeft: "╭", topRight: "╮", bottomLeft: "╰", bottomRight: "╯", horizontal: "─", vertical: "│" },
+	selectMarker: "›",
+	emptyMark: "○",
+	upDown: "↑↓",
+	model: "⚡",
+	workspace: "",
+	git: "",
+	tokensIn: "↑",
+	tokensOut: "↓",
+	cost: "$",
+	cacheHit: "⚡",
+};
+
+const ASCII_GLYPHS: IconGlyphs = {
+	spinFrames: "|/-\\",
+	dotRunning: "*",
+	dotIdle: ".",
+	check: "+",
+	cross: "x",
+	pending: "o",
+	blocked: "!",
+	barDone: "#",
+	barActive: "+",
+	barPending: "-",
+	arrow: ">",
+	depArrow: "<-",
+	transferArrow: "->",
+	treeBranch: "|",
+	treeLast: "`-",
+	treeVertical: "| ",
+	treeSpace: "  ",
+	ellipsis: "...",
+	separator: " | ",
+	box: { topLeft: "+", topRight: "+", bottomLeft: "+", bottomRight: "+", horizontal: "-", vertical: "|" },
+	selectMarker: ">",
+	emptyMark: "o",
+	upDown: "up/dn",
+	model: "~",
+	workspace: "[]",
+	git: "git",
+	tokensIn: "^",
+	tokensOut: "v",
+	cost: "$",
+	cacheHit: "c",
+};
+
+const NERD_FONT_TERMINALS = new Set([
+	"iTerm.app",
+	"Ghostty",
+	"WezTerm",
+	"kitty",
+	"rio",
+	"tabby",
+	"WindowsTerminal",
+	"vscode",
+]);
+
+export function detectNerdFont(): boolean {
+	const termProgram = process.env.TERM_PROGRAM;
+	if (termProgram && NERD_FONT_TERMINALS.has(termProgram)) return true;
+	const lcTerminal = process.env.LC_TERMINAL;
+	if (lcTerminal && NERD_FONT_TERMINALS.has(lcTerminal)) return true;
+	if (process.env.TERM === "xterm-kitty") return true;
+	if (process.env.WT_SESSION) return true;
+	return false;
+}
+
+export function resolveIconMode(mode: IconMode): "nerd" | "ascii" {
+	if (mode === "nerd") return "nerd";
+	if (mode === "ascii") return "ascii";
+	return detectNerdFont() ? "nerd" : "ascii";
+}
+
+export function resolveGlyphs(mode: IconMode): IconGlyphs {
+	return resolveIconMode(mode) === "nerd" ? NERD_GLYPHS : ASCII_GLYPHS;
+}
+
+/**
+ * One source of truth for animation cadence.
+ *
+ * The frame clock and redraw tick stay aligned so terminal animation advances
+ * one frame per paint. A half-second cadence remains legible without keeping
+ * the terminal renderer busy during long-running work.
+ */
+export const ANIMATION_PERIOD_MS = 500;
+
+/**
+ * The frame to draw at `now`, or a stable glyph when nothing is driving redraws.
+ *
+ * A frozen mid-cycle spinner claims "busy" while the UI has actually stopped
+ * repainting, so an idle surface gets a static marker instead.
+ */
+export function spinFrame(glyphs: IconGlyphs, now: number, animating = true): string {
+	if (!animating) return glyphs.dotRunning;
+	const frames = glyphs.spinFrames;
+	return frames[Math.floor(now / ANIMATION_PERIOD_MS) % frames.length];
+}

package/node_modules/pi-maestro-settings-core/src/ui/index.ts

@@ -0,0 +1,11 @@
+export * from "./ansi-bridge.ts";
+export * from "./icons.ts";
+export * from "./key-labels.ts";
+export * from "./layout.ts";
+export * from "./overlay.ts";
+export * from "./overlay-host.ts";
+export * from "./overlay-keys.ts";
+export * from "./overlay-render.ts";
+export * from "./overlay-spec.ts";
+export * from "./primitives.ts";
+export * from "./quiet-state.ts";

package/node_modules/pi-maestro-settings-core/src/ui/key-labels.ts

@@ -0,0 +1,10 @@
+import { platform } from "node:os";
+
+// Display only: the key-matching token stays "alt" on every platform.
+export function altLabel(): string {
+	return platform() === "darwin" ? "Option" : "Alt";
+}
+
+export function altKey(letter: string): string {
+	return `${altLabel()}+${letter}`;
+}

package/node_modules/pi-maestro-settings-core/src/ui/layout.ts

@@ -0,0 +1,181 @@
+// Shared line-fitting primitives.
+//
+// Every cockpit surface renders "a list of segments on one terminal line". The
+// footer already degraded segment-by-segment while the widgets blind-clipped the
+// whole joined line, which meant the trailing segments (duration, the Alt+J hint,
+// the next-task label) were always the first casualties — exactly the tokens the
+// non-color-accessibility spec says must survive. This module is the single
+// implementation both sides use.
+
+// Width helpers are injected so these stay pure and hermetic in unit tests; the
+// real widgets pass pi-tui's visibleWidth / truncateToWidth so east-asian widths
+// are correct on a terminal.
+export interface WidthUtils {
+	measure: (text: string) => number;
+	clip: (text: string, width: number, ellipsis: string) => string;
+}
+
+export interface PrioritizedSegment {
+	text: string;
+	/** Higher survives longer. The lowest-priority segment is sacrificed first. */
+	priority: number;
+	/**
+	 * When false the segment is dropped outright rather than ellipsized, so a
+	 * segment can never degrade into a bare "…" that occupies space and says
+	 * nothing. Defaults to true.
+	 */
+	clippable?: boolean;
+	/**
+	 * Narrowest width at which this segment still carries meaning. Below it the
+	 * segment is dropped instead of clipped. Segments that carry a glyph prefix
+	 * need this: clipping "{icon} ~/work/project" to two columns leaves the icon
+	 * and an ellipsis — decoration with the content eaten out of it.
+	 */
+	minWidth?: number;
+}
+
+/**
+ * Drop and clip segments by ascending priority until the joined line fits.
+ *
+ * A segment is only ellipsized when the remaining room still leaves visible
+ * characters beyond the ellipsis itself; otherwise it is dropped, because a
+ * lone "…" costs a column and carries no information.
+ */
+export function fitSegmentsByPriority(
+	segs: readonly PrioritizedSegment[],
+	maxW: number,
+	measure: WidthUtils["measure"],
+	clip: WidthUtils["clip"],
+	ellipsis = "...",
+	separatorWidth = 1,
+): string[] {
+	const ellipsisW = measure(ellipsis);
+	const items = segs.map((s) => ({
+		text: s.text,
+		priority: s.priority,
+		clippable: s.clippable !== false,
+		minWidth: Math.max(s.minWidth ?? 0, ellipsisW + 1),
+		w: measure(s.text),
+	}));
+	const totalW = (): number => {
+		const active = items.filter((it) => it.text !== "");
+		return active.reduce((a, it) => a + it.w, 0) + Math.max(0, active.length - 1) * separatorWidth;
+	};
+	while (totalW() > maxW) {
+		let target = -1;
+		for (let i = 0; i < items.length; i++) {
+			if (items[i].text !== "" && (target === -1 || items[i].priority < items[target].priority)) {
+				target = i;
+			}
+		}
+		if (target === -1) break;
+		const others = items.filter((_, i) => i !== target && items[i].text !== "");
+		const otherW = others.reduce((a, it) => a + it.w, 0) + Math.max(0, others.length - 1) * separatorWidth;
+		const avail = maxW - otherW - (others.length > 0 ? separatorWidth : 0);
+		// Ellipsizing down to decoration-plus-ellipsis wastes columns and says
+		// nothing, so a segment must clear its minWidth to survive the clip.
+		const drop = (): void => {
+			items[target].text = "";
+			items[target].w = 0;
+		};
+		if (!items[target].clippable || avail < items[target].minWidth) {
+			drop();
+		} else if (avail < items[target].w) {
+			const clipped = clip(items[target].text, avail, ellipsis);
+			const clippedW = measure(clipped);
+			if (clippedW < items[target].minWidth) drop();
+			else {
+				items[target].text = clipped;
+				items[target].w = clippedW;
+			}
+		} else {
+			break;
+		}
+	}
+	return items.filter((it) => it.text !== "").map((it) => it.text);
+}
+
+/**
+ * Join prioritized segments into a single line that fits `width`.
+ *
+ * The common case at every call site: build segments, fit them, join with the
+ * separator. Returns "" when nothing survives.
+ */
+export function fitLineByPriority(
+	segs: readonly PrioritizedSegment[],
+	width: number,
+	utils: WidthUtils,
+	separator: string,
+	ellipsis: string,
+): string {
+	if (width <= 0) return "";
+	const fitted = fitSegmentsByPriority(
+		segs,
+		width,
+		utils.measure,
+		utils.clip,
+		ellipsis,
+		utils.measure(separator),
+	);
+	return fitted.join(separator);
+}
+
+/**
+ * First visible index of a scrolling window that keeps `selected` centred where
+ * it can, and flush against either end where it cannot.
+ */
+export function visibleStart(selected: number, length: number, size: number): number {
+	return Math.max(0, Math.min(selected - Math.floor(size / 2), Math.max(0, length - size)));
+}
+
+// --- Vertical-axis priority composition ---
+//
+// fitSegmentsByPriority handles the horizontal axis (segments on one line).
+// composeByPriority handles the vertical axis (rows across a panel).  Both
+// share the same greedy-drop-lowest-first strategy; the vertical variant
+// operates on multi-row groups and accepts a pluggable cost function so
+// callers can account for section headers, separators, or other overhead.
+
+/**
+ * A prioritized group of rows for vertical budget composition.
+ * Lower dropRank = dropped first when the budget is insufficient.
+ * required groups are never dropped.
+ */
+export interface PriorityGroup {
+	name: string;
+	rows: string[];
+	required: boolean;
+	dropRank: number;
+}
+
+const defaultCost = (groups: readonly PriorityGroup[]): number =>
+	groups.reduce((sum, g) => sum + g.rows.length, 0);
+
+/**
+ * Iteratively drop lowest-priority groups until the cost fits the budget.
+ * Vertical-axis counterpart of fitSegmentsByPriority.
+ *
+ * @param groups  Candidate groups (empty-row groups are pre-filtered).
+ * @param budget  Maximum allowed cost (e.g. terminal rows).
+ * @param cost    Optional cost function; defaults to total row count.
+ */
+export function composeByPriority(
+	groups: PriorityGroup[],
+	budget: number,
+	cost: (groups: readonly PriorityGroup[]) => number = defaultCost,
+): PriorityGroup[] {
+	let candidate = groups.filter((g) => g.rows.length > 0);
+	while (cost(candidate) > budget) {
+		let dropIndex = -1;
+		let dropRank = Number.POSITIVE_INFINITY;
+		for (let i = 0; i < candidate.length; i++) {
+			const g = candidate[i];
+			if (!g || g.required || g.dropRank >= dropRank) continue;
+			dropRank = g.dropRank;
+			dropIndex = i;
+		}
+		if (dropIndex === -1) break;
+		candidate = candidate.filter((_, i) => i !== dropIndex);
+	}
+	return candidate;
+}