@hank-warren/pi-statusline 0.2.4 → 0.4.0

package/themes.ts

@@ -0,0 +1,129 @@
+/**
+ * Statusline colour palettes. Every role is a full SGR prefix so a theme can use
+ * a true-colour value, a plain attribute (`\x1b[2m`), or both.
+ */
+export interface StatuslinePalette {
+	/** Active model id. */
+	model: string;
+	/** Repository and directory names. */
+	path: string;
+	/** Git branch names. */
+	branch: string;
+	/** Neutral figures: the context window total and the usage provider icons. */
+	text: string;
+	/** Separators, the session id, and unknown values. */
+	dim: string;
+	/** Healthy: low context use, high remaining usage, an open PR. */
+	ok: string;
+	/** First warning step, and the dirty-checkout marker. */
+	warn: string;
+	/** Second warning step, and the commits-behind marker. */
+	caution: string;
+	/** Exhausted: high context use, low remaining usage, a closed PR. */
+	danger: string;
+	/** Merged pull requests. */
+	accent: string;
+	/** The two colours the cache-hit badge alternates between. */
+	celebration: readonly [string, string];
+}
+
+const rgb = (hex: string): string => {
+	const value = Number.parseInt(hex.slice(1), 16);
+	return `\x1b[38;2;${(value >> 16) & 0xff};${(value >> 8) & 0xff};${value & 0xff}m`;
+};
+
+/** The palette this package shipped before themes existed. */
+const DEFAULT: StatuslinePalette = {
+	model: rgb("#0099ff"),
+	path: rgb("#dcdcdc"),
+	branch: rgb("#56b6c2"),
+	text: rgb("#dcdcdc"),
+	dim: "\x1b[2m",
+	ok: rgb("#00af50"),
+	warn: rgb("#e6c800"),
+	caution: rgb("#ffb055"),
+	danger: rgb("#ff5555"),
+	accent: rgb("#be78ff"),
+	celebration: [rgb("#ff00ff"), rgb("#00ffff")],
+};
+
+/** Dracula, with the pink branch colour from Hank's Herdr sidebar config. */
+const DRACULA: StatuslinePalette = {
+	model: rgb("#bd93f9"),
+	path: rgb("#f8f8f2"),
+	branch: rgb("#ff79c6"),
+	text: rgb("#f8f8f2"),
+	dim: rgb("#6272a4"),
+	ok: rgb("#50fa7b"),
+	warn: rgb("#f1fa8c"),
+	caution: rgb("#ffb86c"),
+	danger: rgb("#ff5555"),
+	accent: rgb("#8be9fd"),
+	celebration: [rgb("#ff79c6"), rgb("#8be9fd")],
+};
+
+const GITHUB_DARK: StatuslinePalette = {
+	model: rgb("#58a6ff"),
+	path: rgb("#c9d1d9"),
+	branch: rgb("#39c5cf"),
+	text: rgb("#c9d1d9"),
+	dim: rgb("#8b949e"),
+	ok: rgb("#3fb950"),
+	warn: rgb("#d29922"),
+	caution: rgb("#db6d28"),
+	danger: rgb("#f85149"),
+	accent: rgb("#bc8cff"),
+	celebration: [rgb("#bc8cff"), rgb("#39c5cf")],
+};
+
+const CATPPUCCIN_MOCHA: StatuslinePalette = {
+	model: rgb("#cba6f7"),
+	path: rgb("#cdd6f4"),
+	branch: rgb("#89dceb"),
+	text: rgb("#cdd6f4"),
+	dim: rgb("#6c7086"),
+	ok: rgb("#a6e3a1"),
+	warn: rgb("#f9e2af"),
+	caution: rgb("#fab387"),
+	danger: rgb("#f38ba8"),
+	accent: rgb("#f5c2e7"),
+	celebration: [rgb("#cba6f7"), rgb("#89dceb")],
+};
+
+/** No colour at all: white text, dimmed punctuation, a grey badge flash. */
+const WHITE: StatuslinePalette = {
+	model: rgb("#ffffff"),
+	path: rgb("#ffffff"),
+	branch: rgb("#ffffff"),
+	text: rgb("#ffffff"),
+	dim: "\x1b[2m",
+	ok: rgb("#ffffff"),
+	warn: rgb("#ffffff"),
+	caution: rgb("#ffffff"),
+	danger: rgb("#ffffff"),
+	accent: rgb("#ffffff"),
+	celebration: [rgb("#ffffff"), rgb("#888888")],
+};
+
+export const STATUSLINE_THEMES = {
+	default: DEFAULT,
+	dracula: DRACULA,
+	"github-dark": GITHUB_DARK,
+	"catppuccin-mocha": CATPPUCCIN_MOCHA,
+	white: WHITE,
+} as const satisfies Record<string, StatuslinePalette>;
+
+export type StatuslineThemeName = keyof typeof STATUSLINE_THEMES;
+
+export const DEFAULT_THEME: StatuslineThemeName = "default";
+export const THEME_NAMES = Object.keys(STATUSLINE_THEMES) as StatuslineThemeName[];
+
+export function isThemeName(value: unknown): value is StatuslineThemeName {
+	// hasOwn, not `in`: "__proto__" and "toString" are on the prototype chain.
+	return typeof value === "string" && Object.hasOwn(STATUSLINE_THEMES, value);
+}
+
+/** Resolve a theme name to its palette; anything unknown falls back to the default. */
+export function resolvePalette(name: string): StatuslinePalette {
+	return isThemeName(name) ? STATUSLINE_THEMES[name] : STATUSLINE_THEMES[DEFAULT_THEME];
+}

package/worktrees.ts

@@ -1,4 +1,5 @@
 import { readFile } from "node:fs/promises";
+import { homedir } from "node:os";
 import { basename, join, resolve } from "node:path";
 import type { ExecResult } from "@earendil-works/pi-coding-agent";
 
@@ -34,7 +35,10 @@ export interface WorktreeTrackerHost {
 		args: string[],
 		options: { cwd?: string; timeout?: number; signal?: AbortSignal },
 	): Promise<ExecResult>;
-	home: string;
+	/** Directory whose immediate children are tracked as session worktrees. */
+	worktreeRoot: string;
+	/** Home directory used to recognise `~`/`$HOME` spellings of the root. */
+	home?: string;
 	now?: () => number;
 	onChange?: () => void;
 }
@@ -94,24 +98,48 @@ function visitStrings(value: unknown, visit: (value: string) => void): void {
 	for (const item of Object.values(value)) visitStrings(item, visit);
 }
 
-export function extractWorktreePaths(value: unknown, home: string): string[] {
+function trimTrailingSlashes(path: string): string {
+	return path.replace(/\/+$/, "") || path.slice(0, 1);
+}
+
+/**
+ * Spellings of the configured root that may appear in tool arguments: the
+ * absolute path, plus the `~/` and `$HOME/` forms when it lives under home.
+ */
+export function worktreeRootNeedles(worktreeRoot: string, home: string = homedir()): string[] {
+	const root = trimTrailingSlashes(worktreeRoot);
+	if (root.length === 0) return [];
+	const needles = [`${root}/`];
+	const base = trimTrailingSlashes(home ?? "");
+	if (base.length > 0 && root.startsWith(`${base}/`)) {
+		const relative = root.slice(base.length + 1);
+		if (relative.length > 0) needles.push(`~/${relative}/`, `$HOME/${relative}/`);
+	}
+	return needles;
+}
+
+export function extractWorktreePaths(value: unknown, worktreeRoot: string, home: string = homedir()): string[] {
 	const names = new Set<string>();
-	const needle = "repos/worktrees/";
+	const needles = worktreeRootNeedles(worktreeRoot, home);
+	if (needles.length === 0) return [];
 
 	visitStrings(value, (text) => {
-		let rest = text;
-		while (true) {
-			const index = rest.indexOf(needle);
-			if (index < 0) break;
-			rest = rest.slice(index + needle.length);
-			const name = rest.match(/^[a-zA-Z0-9._-]+/)?.[0];
-			if (name) names.add(name);
-			if (rest.length === 0) break;
-			rest = rest.slice(Math.max(1, name?.length ?? 0));
+		for (const needle of needles) {
+			let rest = text;
+			while (true) {
+				const index = rest.indexOf(needle);
+				if (index < 0) break;
+				rest = rest.slice(index + needle.length);
+				const name = rest.match(/^[a-zA-Z0-9._-]+/)?.[0];
+				if (name) names.add(name);
+				if (rest.length === 0) break;
+				rest = rest.slice(Math.max(1, name?.length ?? 0));
+			}
 		}
 	});
 
-	return [...names].sort().map((name) => join(home, "repos", "worktrees", name));
+	const root = trimTrailingSlashes(worktreeRoot);
+	return [...names].sort().map((name) => join(root, name));
 }
 
 function stripHeredocBodies(command: string): string {
@@ -137,17 +165,28 @@ function stripHeredocBodies(command: string): string {
 	return visible.join("\n");
 }
 
-export function extractWorktreePathsFromToolCall(toolName: string, input: unknown, home: string): string[] {
+export function extractWorktreePathsFromToolCall(
+	toolName: string,
+	input: unknown,
+	worktreeRoot: string,
+	home: string = homedir(),
+): string[] {
 	const baseName = toolName.slice(toolName.lastIndexOf(".") + 1);
 	if (baseName !== "bash" || !input || typeof input !== "object" || Array.isArray(input)) {
-		return extractWorktreePaths(input, home);
+		return extractWorktreePaths(input, worktreeRoot, home);
 	}
 
 	const command = (input as { command?: unknown }).command;
-	return typeof command === "string" ? extractWorktreePaths(stripHeredocBodies(command), home) : [];
+	return typeof command === "string"
+		? extractWorktreePaths(stripHeredocBodies(command), worktreeRoot, home)
+		: [];
 }
 
-export function extractWorktreePathsFromEntries(entries: readonly unknown[], home: string): string[] {
+export function extractWorktreePathsFromEntries(
+	entries: readonly unknown[],
+	worktreeRoot: string,
+	home: string = homedir(),
+): string[] {
 	const paths = new Set<string>();
 
 	for (const entry of entries) {
@@ -161,30 +200,15 @@ export function extractWorktreePathsFromEntries(entries: readonly unknown[], hom
 			if (!block || typeof block !== "object") continue;
 			const toolCall = block as { type?: unknown; name?: unknown; arguments?: unknown };
 			if (toolCall.type !== "toolCall" || typeof toolCall.name !== "string") continue;
-			for (const path of extractWorktreePathsFromToolCall(toolCall.name, toolCall.arguments, home)) paths.add(path);
+			for (const path of extractWorktreePathsFromToolCall(toolCall.name, toolCall.arguments, worktreeRoot, home)) {
+				paths.add(path);
+			}
 		}
 	}
 
 	return [...paths].sort();
 }
 
-export function repoAlias(repo: string): string {
-	switch (repo) {
-		case "model-runtime-engine":
-			return "mre";
-		case "frontend":
-			return "fe";
-		case "infrastructure":
-			return "infra";
-		case "platform-releases":
-			return "rel";
-		case "np-integration-testing":
-			return "tests";
-		default:
-			return repo.startsWith("platform-") ? repo.slice("platform-".length) : repo;
-	}
-}
-
 export async function readWorktreeMetadata(path: string): Promise<WorktreeMetadata | undefined> {
 	try {
 		const gitFile = await readFile(join(path, ".git"), "utf8");
@@ -242,13 +266,15 @@ export class SessionWorktreeTracker {
 	}
 
 	async seedFromEntries(entries: readonly unknown[]): Promise<void> {
-		for (const path of extractWorktreePathsFromEntries(entries, this.host.home)) this.trackedPaths.add(path);
+		for (const path of extractWorktreePathsFromEntries(entries, this.host.worktreeRoot, this.host.home)) {
+			this.trackedPaths.add(path);
+		}
 		await this.refresh();
 	}
 
 	async observeToolInput(toolName: string, input: unknown): Promise<void> {
 		const added: string[] = [];
-		for (const path of extractWorktreePathsFromToolCall(toolName, input, this.host.home)) {
+		for (const path of extractWorktreePathsFromToolCall(toolName, input, this.host.worktreeRoot, this.host.home)) {
 			if (this.trackedPaths.has(path)) continue;
 			this.trackedPaths.add(path);
 			added.push(path);