@narumitw/pi-statusline 0.23.0 → 0.28.0

package/src/settings.ts

@@ -10,50 +10,58 @@ import {
 } from "node:fs";
 import { dirname, join } from "node:path";
 import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import { INFORMATION_PROFILES } from "./information-profiles.js";
+import { segmentPaletteForPreset } from "./presets/index.js";
 import {
 	type ConfigSegmentName,
 	DENSITIES,
 	LINE_BREAK_SEGMENT_NAME,
 	PALETTE_NAMES,
+	PALETTE_PRESET_NAMES,
+	type PaletteName,
 	SEGMENT_NAMES,
 	SEPARATOR_NAMES,
 	type SegmentName,
+	type SegmentPalette,
 	type StatuslineConfig,
 } from "./types.js";
 
 export const SETTINGS_FILE_NAME = "pi-statusline.json";
 const LEGACY_SETTINGS_FILE_NAME = "pi-statusline-settings.json";
 
-export const DEFAULT_EXTENSION_STATUS_ICONS: Record<string, string> = {
-	"chrome-devtools": "🌐",
-	"codex-usage": "📊",
+const DEFAULT_DOCUMENT_EXTENSION_STATUS_ICONS: Record<string, string> = {
+	accounts: "👤",
 	caffeinate: "💊",
+	"chrome-devtools": "🌐",
 	firecrawl: "🔥",
 	"github-pr": "🔎",
 	goal: "🎯",
+	"google-genai": "✨",
 	lsp: "🧰",
 	"plan-mode": "📝",
-	pisync: "🔄",
+	retry: "🔁",
 	subagents: "🧑‍🤝‍🧑",
+	sync: "🔄",
+	usage: "📊",
+};
+
+export const DEFAULT_EXTENSION_STATUS_ICONS: Record<string, string> = {
+	...DEFAULT_DOCUMENT_EXTENSION_STATUS_ICONS,
+	"codex-usage": "📊",
+	pisync: "🔄",
 	"unknown-error-retry": "🔁",
 };
 
-const DEFAULT_SEGMENTS: SegmentName[] = [
-	"brand",
-	"provider",
-	"model",
-	"thinking",
-	"cwd",
-	"branch",
-	"tools",
-	"context",
-	"tokens",
-	"cost",
-	"time",
-];
+const LEGACY_STATUS_ICON_KEYS = {
+	pisync: "sync",
+	"unknown-error-retry": "retry",
+} as const;
+
+const DEFAULT_SEGMENTS: SegmentName[] = [...INFORMATION_PROFILES.balanced];
 
 export const DEFAULT_STATUSLINE_CONFIG: StatuslineConfig = {
-	palette: "tokyo-night",
+	palettePreset: "tokyo-night",
+	palette: segmentPaletteForPreset("tokyo-night"),
 	density: "compact",
 	separator: "none",
 	segments: DEFAULT_SEGMENTS,
@@ -74,7 +82,20 @@ export const DEFAULT_STATUSLINE_CONFIG: StatuslineConfig = {
 	extensionStatusIcons: DEFAULT_EXTENSION_STATUS_ICONS,
 };
 
-export const DEFAULT_STATUSLINE_DOCUMENT = `${JSON.stringify(DEFAULT_STATUSLINE_CONFIG, null, "\t")}\n`;
+const DEFAULT_STATUSLINE_DOCUMENT_CONFIG = {
+	palettePreset: DEFAULT_STATUSLINE_CONFIG.palettePreset,
+	density: DEFAULT_STATUSLINE_CONFIG.density,
+	separator: DEFAULT_STATUSLINE_CONFIG.separator,
+	segments: DEFAULT_SEGMENTS,
+	segmentText: DEFAULT_STATUSLINE_CONFIG.segmentText,
+	extensionStatusIcons: DEFAULT_DOCUMENT_EXTENSION_STATUS_ICONS,
+} satisfies Omit<StatuslineConfig, "palette">;
+
+export const DEFAULT_STATUSLINE_DOCUMENT = `${JSON.stringify(
+	DEFAULT_STATUSLINE_DOCUMENT_CONFIG,
+	null,
+	"\t",
+)}\n`;
 
 export interface StatuslineConfigDiagnostic {
 	severity: "warning" | "error";
@@ -127,8 +148,8 @@ export function normalizeStatuslineConfig(value: unknown): {
 			diagnostics: [invalidDiagnostic("", "Settings must contain a JSON object", "error")],
 		};
 	}
-
 	const knownRoot = new Set([
+		"palettePreset",
 		"palette",
 		"density",
 		"separator",
@@ -140,7 +161,11 @@ export function normalizeStatuslineConfig(value: unknown): {
 		if (!knownRoot.has(key)) diagnostics.push(unknownDiagnostic(key));
 	}
 
-	normalizeEnum(value, "palette", PALETTE_NAMES, config, diagnostics);
+	normalizePalette(value.palette, config, diagnostics);
+	normalizeEnum(value, "palettePreset", PALETTE_PRESET_NAMES, config, diagnostics);
+	if (!isRecord(value.palette) && isPaletteName(config.palettePreset)) {
+		config.palette = segmentPaletteForPreset(config.palettePreset);
+	}
 	normalizeEnum(value, "density", DENSITIES, config, diagnostics);
 	normalizeEnum(value, "separator", SEPARATOR_NAMES, config, diagnostics);
 
@@ -237,6 +262,28 @@ export function normalizeStatuslineConfig(value: unknown): {
 					writable: true,
 				});
 			}
+			for (const [legacyKey, canonicalKey] of Object.entries(LEGACY_STATUS_ICON_KEYS)) {
+				const legacyIcon = Object.hasOwn(value.extensionStatusIcons, legacyKey)
+					? value.extensionStatusIcons[legacyKey]
+					: undefined;
+				const canonicalIcon = Object.hasOwn(value.extensionStatusIcons, canonicalKey)
+					? value.extensionStatusIcons[canonicalKey]
+					: undefined;
+				const targetKey = typeof canonicalIcon === "string" ? legacyKey : canonicalKey;
+				const inheritedIcon =
+					typeof canonicalIcon === "string"
+						? canonicalIcon
+						: typeof legacyIcon === "string"
+							? legacyIcon
+							: undefined;
+				if (inheritedIcon === undefined) continue;
+				Object.defineProperty(config.extensionStatusIcons, targetKey, {
+					value: inheritedIcon,
+					enumerable: true,
+					configurable: true,
+					writable: true,
+				});
+			}
 		}
 	}
 
@@ -412,8 +459,63 @@ export function normalizeStatuslineSettings(value: unknown): StatuslineConfig {
 	return normalizeStatuslineConfig(value).config;
 }
 
+function normalizePalette(
+	value: unknown,
+	config: StatuslineConfig,
+	diagnostics: StatuslineConfigDiagnostic[],
+) {
+	if (value === undefined) return;
+	if (typeof value === "string") {
+		if (!(PALETTE_NAMES as readonly string[]).includes(value)) {
+			diagnostics.push(
+				invalidDiagnostic(
+					"palette",
+					`Expected a palette object or one of: ${PALETTE_NAMES.join(", ")}`,
+				),
+			);
+			return;
+		}
+		config.palettePreset = value as (typeof PALETTE_NAMES)[number];
+		return;
+	}
+	if (!isRecord(value)) {
+		diagnostics.push(invalidDiagnostic("palette", "Expected a palette object"));
+		return;
+	}
+
+	const palette: SegmentPalette = {};
+	config.palette = palette;
+	for (const [name, colors] of Object.entries(value)) {
+		const path = `palette.${name}`;
+		if (!isSegmentName(name)) {
+			diagnostics.push(unknownDiagnostic(path));
+			continue;
+		}
+		if (!isRecord(colors)) {
+			diagnostics.push(invalidDiagnostic(path, "Expected an object"));
+			continue;
+		}
+		const normalizedColors: NonNullable<SegmentPalette[SegmentName]> = {};
+		palette[name] = normalizedColors;
+		for (const [field, color] of Object.entries(colors)) {
+			const colorPath = `${path}.${field}`;
+			if (field !== "fg" && field !== "bg") {
+				diagnostics.push(unknownDiagnostic(colorPath));
+				continue;
+			}
+			if (typeof color !== "string" || !/^#[0-9a-f]{6}$/iu.test(color)) {
+				diagnostics.push(invalidDiagnostic(colorPath, "Expected a full #RRGGBB hexadecimal color"));
+				continue;
+			}
+			normalizedColors[field] = color.toLowerCase();
+		}
+	}
+	config.palette = palette;
+	config.palettePreset = "custom";
+}
+
 function normalizeEnum<
-	K extends "palette" | "density" | "separator",
+	K extends "palettePreset" | "density" | "separator",
 	T extends StatuslineConfig[K],
 >(
 	value: Record<string, unknown>,
@@ -433,9 +535,16 @@ function normalizeEnum<
 	config[field] = candidate as StatuslineConfig[K];
 }
 
+function cloneSegmentPalette(palette: SegmentPalette): SegmentPalette {
+	return Object.fromEntries(
+		Object.entries(palette).map(([name, colors]) => [name, { ...colors }]),
+	) as SegmentPalette;
+}
+
 function cloneConfig(config: StatuslineConfig): StatuslineConfig {
 	return {
 		...config,
+		palette: cloneSegmentPalette(config.palette),
 		segments: [...config.segments],
 		segmentText: Object.fromEntries(
 			SEGMENT_NAMES.map((name) => [name, { ...config.segmentText[name] }]),
@@ -472,6 +581,10 @@ function isConfigSegmentName(value: string): value is ConfigSegmentName {
 	return value === LINE_BREAK_SEGMENT_NAME || isSegmentName(value);
 }
 
+function isPaletteName(value: StatuslineConfig["palettePreset"]): value is PaletteName {
+	return (PALETTE_NAMES as readonly StatuslineConfig["palettePreset"][]).includes(value);
+}
+
 function isSegmentName(value: string): value is SegmentName {
 	return (SEGMENT_NAMES as readonly string[]).includes(value);
 }

package/src/statusline.ts

@@ -19,6 +19,7 @@ import {
 	loadStatuslineSettings,
 	settingsFilePath,
 } from "./settings.js";
+import type { PalettePreset } from "./types.js";
 
 const STATUSLINE_KEY = "statusline";
 const GIT_STATUS_REFRESH_INTERVAL_MS = 30_000;
@@ -27,6 +28,8 @@ const EMPTY_EXTENSION_STATUS_ICON_ALIASES: ExtensionStatusIconAliasMap = new Map
 
 export default function statusline(pi: ExtensionAPI) {
 	let loaded: LoadedStatuslineSettings | undefined;
+	let previewPalettePreset: PalettePreset | undefined;
+	let activeSessionManager: ExtensionContext["sessionManager"] | undefined;
 	const runtime: RuntimeState = {
 		turnCount: 0,
 		activeTools: new Map(),
@@ -44,6 +47,7 @@ export default function statusline(pi: ExtensionAPI) {
 	let pendingGitStatusRefresh: { cwd: string; generation: number; requestId: number } | undefined;
 
 	const refresh = () => runtime.requestRender?.();
+	const ownsRuntime = (ctx: ExtensionContext) => ctx.sessionManager === activeSessionManager;
 
 	const setGitStatus = (summary: GitStatusSummary | undefined) => {
 		if (gitStatusSummaryEqual(runtime.gitStatus, summary)) return;
@@ -111,6 +115,8 @@ export default function statusline(pi: ExtensionAPI) {
 	const installFooter = (ctx: ExtensionContext) => {
 		const generation = ++sessionGeneration;
 		const cwd = ctx.cwd;
+		activeSessionManager = ctx.sessionManager;
+		previewPalettePreset = undefined;
 		clearGitStatusDebounce();
 		activeGitStatusTarget = ctx.mode === "tui" ? { cwd, generation } : undefined;
 		runtime.gitStatus = undefined;
@@ -154,7 +160,9 @@ export default function statusline(pi: ExtensionAPI) {
 				invalidate() {},
 				render(width: number): string[] {
 					if (!loaded) return [];
-					const config = loaded.config;
+					const config = previewPalettePreset
+						? { ...loaded.config, palettePreset: previewPalettePreset }
+						: loaded.config;
 					const mainLine = renderStatusline(width, ctx, footerData, theme, config, runtime);
 					const lines = mainLine ? mainLine.split("\n") : [];
 					lines.push(
@@ -172,13 +180,23 @@ export default function statusline(pi: ExtensionAPI) {
 	registerStatuslineCommand(pi, {
 		settingsPath: configPath,
 		getLoaded: () => loaded ?? loadStatuslineSettings(configPath),
-		apply(next) {
+		apply(next, ctx) {
+			if (ctx.sessionManager !== activeSessionManager) return;
+			previewPalettePreset = undefined;
 			loaded = next;
 			refresh();
 		},
+		preview(palettePreset, ctx) {
+			if (ctx.sessionManager !== activeSessionManager) return;
+			previewPalettePreset = palettePreset;
+			refresh();
+		},
 	});
 
 	pi.on("session_start", (_event, ctx) => {
+		runtime.turnCount = 0;
+		runtime.activeTools.clear();
+		runtime.isStreaming = false;
 		loaded = loadOrCreateStatuslineSettings(agentDir);
 		const settingsNotice = consumeStatuslineSettingsNotice();
 		if (settingsNotice) ctx.ui.notify(settingsNotice, "warning");
@@ -195,11 +213,16 @@ export default function statusline(pi: ExtensionAPI) {
 	});
 
 	pi.on("session_shutdown", (_event, ctx) => {
+		if (!ownsRuntime(ctx)) return;
 		sessionGeneration += 1;
+		activeSessionManager = undefined;
+		previewPalettePreset = undefined;
 		activeGitStatusTarget = undefined;
 		clearGitStatusDebounce();
 		pendingGitStatusRefresh = undefined;
 		runtime.gitStatus = undefined;
+		runtime.activeTools.clear();
+		runtime.isStreaming = false;
 		runtime.duplicateExtensions = [];
 		runtime.extensionStatusIconAliases = EMPTY_EXTENSION_STATUS_ICON_ALIASES;
 		ctx.ui.setFooter(undefined);
@@ -214,41 +237,52 @@ export default function statusline(pi: ExtensionAPI) {
 		refresh();
 	});
 
-	pi.on("agent_start", () => {
+	pi.on("agent_start", (_event, ctx) => {
+		if (!ownsRuntime(ctx)) return;
 		runtime.isStreaming = true;
 		refresh();
 	});
 
 	pi.on("agent_end", (_event, ctx) => {
-		runtime.isStreaming = false;
+		if (!ownsRuntime(ctx)) return;
+		runtime.activeTools.clear();
 		scheduleGitStatusRefreshForContext(ctx);
 		refresh();
 	});
 
-	pi.on("turn_start", () => {
+	pi.on("agent_settled", (_event, ctx) => {
+		if (!ownsRuntime(ctx)) return;
+		runtime.isStreaming = false;
+		runtime.activeTools.clear();
+		refresh();
+	});
+
+	pi.on("turn_start", (_event, ctx) => {
+		if (!ownsRuntime(ctx)) return;
 		runtime.turnCount += 1;
 		runtime.isStreaming = true;
 		refresh();
 	});
 
 	pi.on("turn_end", (_event, ctx) => {
+		if (!ownsRuntime(ctx)) return;
 		scheduleGitStatusRefreshForContext(ctx);
 		refresh();
 	});
 
-	pi.on("tool_execution_start", (event) => {
+	pi.on("tool_execution_start", (event, ctx) => {
+		if (!ownsRuntime(ctx)) return;
 		const currentCount = runtime.activeTools.get(event.toolName) ?? 0;
 		runtime.activeTools.set(event.toolName, currentCount + 1);
-		runtime.lastTool = event.toolName;
 		refresh();
 	});
 
 	pi.on("tool_execution_end", (event, ctx) => {
+		if (!ownsRuntime(ctx)) return;
 		const currentCount = runtime.activeTools.get(event.toolName) ?? 0;
 		if (currentCount <= 1) runtime.activeTools.delete(event.toolName);
 		else runtime.activeTools.set(event.toolName, currentCount - 1);
 
-		runtime.lastCompletedTool = event.toolName;
 		scheduleGitStatusRefreshForContext(ctx);
 		refresh();
 	});

package/src/types.ts

@@ -30,21 +30,32 @@ export const PALETTE_NAMES = [
 ] as const;
 export type PaletteName = (typeof PALETTE_NAMES)[number];
 
+export const PALETTE_PRESET_NAMES = [...PALETTE_NAMES, "custom"] as const;
+export type PalettePreset = (typeof PALETTE_PRESET_NAMES)[number];
+
 export const DENSITIES = ["compact", "cozy"] as const;
 export type Density = (typeof DENSITIES)[number];
 
 export const SEPARATOR_NAMES = ["none", "dot", "bar", "powerline", "round"] as const;
 export type SeparatorName = (typeof SEPARATOR_NAMES)[number];
 
-export type TokyoNightBlockName = "header" | "directory" | "git" | "runtime" | "meter";
+export type PowerlineBlockName = "header" | "directory" | "git" | "runtime" | "meter";
 
 export interface SegmentTextConfig {
 	prefix: string;
 	suffix: string;
 }
 
+export interface SegmentPaletteColor {
+	fg?: string;
+	bg?: string;
+}
+
+export type SegmentPalette = Partial<Record<SegmentName, SegmentPaletteColor>>;
+
 export interface StatuslineConfig {
-	palette: PaletteName;
+	palettePreset: PalettePreset;
+	palette: SegmentPalette;
 	density: Density;
 	separator: SeparatorName;
 	segments: ConfigSegmentName[];
@@ -56,7 +67,7 @@ export interface RenderSegment {
 	name: SegmentName;
 	text: string;
 	color: ThemeColor;
-	block: TokyoNightBlockName;
+	block: PowerlineBlockName;
 	emphasis?: boolean;
 }
 

package/src/tokyo-night.ts

@@ -1,180 +0,0 @@
-import type { Theme } from "@earendil-works/pi-coding-agent";
-import { truncateToWidth } from "@earendil-works/pi-tui";
-import { ansiFg, ansiStyle } from "./ansi.js";
-import {
-	LINE_BREAK_SEGMENT_NAME,
-	type PaletteName,
-	type RenderItem,
-	type RenderSegment,
-	type SeparatorName,
-	type StatuslineConfig,
-	type TokyoNightBlockName,
-} from "./types.js";
-
-interface TokyoNightBlock {
-	name: TokyoNightBlockName;
-	segments: RenderSegment[];
-}
-
-interface BlockColors {
-	fg: string;
-	bg: string;
-}
-
-interface PowerlinePalette {
-	lead: string;
-	blocks: Record<TokyoNightBlockName, BlockColors>;
-	extensionSeparator: string;
-}
-
-const BLOCK_NAMES: TokyoNightBlockName[] = ["header", "directory", "git", "runtime", "meter"];
-
-const TOKYO_NIGHT_PALETTE: PowerlinePalette = {
-	lead: "#a3aed2",
-	blocks: {
-		header: { fg: "#090c0c", bg: "#a3aed2" },
-		directory: { fg: "#e3e5e5", bg: "#769ff0" },
-		git: { fg: "#769ff0", bg: "#394260" },
-		runtime: { fg: "#769ff0", bg: "#212736" },
-		meter: { fg: "#a0a9cb", bg: "#1d2230" },
-	},
-	extensionSeparator: "#394260",
-};
-
-const SEMANTIC_COLORS = {
-	accent: "#7aa2f7",
-	muted: "#565f89",
-	success: "#9ece6a",
-	warning: "#e0af68",
-	error: "#f7768e",
-	dim: "#414868",
-} as const;
-
-type SemanticColor = keyof typeof SEMANTIC_COLORS;
-
-const PALETTE_SEQUENCES: Record<Exclude<PaletteName, "tokyo-night">, SemanticColor[]> = {
-	ocean: ["accent", "muted", "success", "warning"],
-	sunset: ["warning", "accent", "success", "muted"],
-	forest: ["success", "accent", "muted", "warning"],
-	candy: ["accent", "warning", "success", "muted"],
-	neon: ["accent", "success", "warning", "error"],
-	mono: ["muted", "dim"],
-};
-
-export function renderTokyoNightStatusline(
-	width: number,
-	items: RenderItem[],
-	config: Pick<StatuslineConfig, "palette" | "density" | "separator">,
-): string {
-	if (items.length === 0 || width <= 0) return "";
-	return splitLines(items)
-		.map((segments) =>
-			segments.length === 0
-				? ""
-				: truncateToWidth(joinTokyoNightSegments(segments, config), width, ""),
-		)
-		.join("\n");
-}
-
-function splitLines(items: RenderItem[]): RenderSegment[][] {
-	const lines: RenderSegment[][] = [[]];
-	for (const item of items) {
-		if (item.name === LINE_BREAK_SEGMENT_NAME) lines.push([]);
-		else lines.at(-1)?.push(item);
-	}
-	return lines;
-}
-
-export function tokyoNightExtensionSeparator(
-	_theme: Theme,
-	paletteName: PaletteName = "tokyo-night",
-): string {
-	return ansiFg(resolvePalette(paletteName).extensionSeparator, " • ");
-}
-
-function joinTokyoNightSegments(
-	segments: RenderSegment[],
-	config: Pick<StatuslineConfig, "palette" | "density" | "separator">,
-): string {
-	const palette = resolvePalette(config.palette);
-	const blocks = contiguousBlocks(segments);
-	let line = ansiFg(palette.lead, "░▒▓");
-
-	for (const [index, block] of blocks.entries()) {
-		const colors = palette.blocks[block.name];
-		const previous = index === 0 ? undefined : palette.blocks[blocks[index - 1]?.name ?? "header"];
-		if (previous) line += ansiStyle("", { fg: previous.bg, bg: colors.bg });
-		line += ansiStyle(formatBlockText(block, config), colors);
-	}
-
-	const lastBlock = blocks.at(-1);
-	if (lastBlock) line += ansiFg(palette.blocks[lastBlock.name].bg, "");
-	return line;
-}
-
-function contiguousBlocks(segments: RenderSegment[]): TokyoNightBlock[] {
-	const blocks: TokyoNightBlock[] = [];
-	for (const segment of segments) {
-		const previous = blocks.at(-1);
-		if (previous?.name === segment.block) previous.segments.push(segment);
-		else blocks.push({ name: segment.block, segments: [segment] });
-	}
-	return blocks;
-}
-
-function formatBlockText(
-	block: TokyoNightBlock,
-	config: Pick<StatuslineConfig, "density" | "separator">,
-): string {
-	const texts = block.segments.map(formatSegmentText);
-	const separator = separatorText(config.separator, config.density === "cozy");
-	const leading = config.density === "cozy" ? "  " : " ";
-	const trailing = config.density === "cozy" ? " " : "";
-	return `${leading}${texts.join(separator)}${trailing}`;
-}
-
-function formatSegmentText(segment: RenderSegment): string {
-	return segment.emphasis ? `\u001b[1m${segment.text}\u001b[22m` : segment.text;
-}
-
-function separatorText(separator: SeparatorName, cozy: boolean): string {
-	const padding = cozy ? "  " : " ";
-	switch (separator) {
-		case "dot":
-			return `${padding}•${padding}`;
-		case "bar":
-			return `${padding}│${padding}`;
-		case "powerline":
-			return `${padding}${padding}`;
-		case "round":
-			return `${padding}❯${padding}`;
-		case "none":
-			return padding;
-	}
-}
-
-function resolvePalette(name: PaletteName): PowerlinePalette {
-	if (name === "tokyo-night") return TOKYO_NIGHT_PALETTE;
-	const sequence = PALETTE_SEQUENCES[name];
-	const backgrounds = BLOCK_NAMES.map(
-		(_block, index) => SEMANTIC_COLORS[sequence[index % sequence.length] ?? "muted"],
-	);
-	return {
-		lead: backgrounds[0] ?? SEMANTIC_COLORS.accent,
-		blocks: Object.fromEntries(
-			BLOCK_NAMES.map((block, index) => {
-				const background = backgrounds[index] ?? SEMANTIC_COLORS.muted;
-				return [block, { fg: contrastColor(background), bg: background }];
-			}),
-		) as Record<TokyoNightBlockName, BlockColors>,
-		extensionSeparator: backgrounds[2] ?? SEMANTIC_COLORS.muted,
-	};
-}
-
-function contrastColor(hex: string): string {
-	const normalized = hex.slice(1);
-	const red = Number.parseInt(normalized.slice(0, 2), 16);
-	const green = Number.parseInt(normalized.slice(2, 4), 16);
-	const blue = Number.parseInt(normalized.slice(4, 6), 16);
-	return red * 0.299 + green * 0.587 + blue * 0.114 > 150 ? "#090c0c" : "#f0f0f0";
-}