@narumitw/pi-statusline 0.20.0 → 0.23.0

package/README.md

@@ -1,159 +1,207 @@
-# ✨ pi-statusline — Rich Statusline for the Pi Coding Agent
+# ✨ pi-statusline — Configurable Tokyo Night Footer for Pi
 
 [![npm](https://img.shields.io/npm/v/@narumitw/pi-statusline)](https://www.npmjs.com/package/@narumitw/pi-statusline) [![Pi extension](https://img.shields.io/badge/Pi-extension-blue)](https://pi.dev) [![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](./LICENSE)
 
-`@narumitw/pi-statusline` is a native [Pi coding agent](https://pi.dev) extension that replaces Pi's footer with a beautiful, information-rich terminal statusline.
+`@narumitw/pi-statusline` is a native [Pi coding agent](https://pi.dev) extension that replaces Pi's footer with a configurable Tokyo Night powerline statusline.
 
-Use it to monitor model selection, thinking level, git branch, working directory, active tools, context usage, token totals, estimated cost, time, and statuses from other Pi extensions.
+## Features
 
-## ✨ Features
+- Shows provider, model, thinking, directory, Git/PR state, tools, context, tokens, cost, time, and extension statuses.
+- Uses one Starship-inspired `░▒▓` / `` Tokyo Night layout.
+- Configures segment order, visibility, multiline breaks, surrounding text, palette, density, separators, and extension icons through JSON.
+- Creates a complete editable default configuration on first session start.
+- Applies validated `/statusline settings` edits immediately after an atomic save.
+- Caches Git state outside footer rendering and guards stale session results.
+- Wraps extension statuses safely at narrow terminal widths.
 
-- Replaces the default Pi footer with a compact preset-based statusline.
-- Shows model, thinking level, git branch/status, project directory, active tool, context usage, tokens, cost, and clock.
-- Displays compact statuses published through Pi's generic extension status API.
-- Owns extension status icons through optional JSON config, including per-extension icon suppression with `""`.
-- Warns when the same extension package is installed from multiple sources.
-- Uses emoji-labeled segments for readability in both classic and Tokyo Night presets.
-- Adapts to terminal width and wraps long extension status lines safely.
-- Requires no configuration, with optional preset selection through `PI_STATUSLINE_PRESET`.
-
-## 📦 Install
+## Install
 
 ```bash
 pi install npm:@narumitw/pi-statusline
 ```
 
-Try without installing permanently:
+Try it once or from a checkout:
 
 ```bash
 pi -e npm:@narumitw/pi-statusline
-```
-
-Try this package locally from the repository root:
-
-```bash
 pi -e ./extensions/pi-statusline
 ```
 
-## 🎨 Presets
+Do not enable this together with `@narumitw/pi-starship`: both extensions own Pi's footer. Use `pi-starship` instead when you need full Starship-style format/style grammar.
 
-`pi-statusline` supports presets through the `PI_STATUSLINE_PRESET` environment variable:
+## Configuration
 
-```bash
-PI_STATUSLINE_PRESET=tokyo-night pi
-PI_STATUSLINE_PRESET=classic pi
-```
-
-Supported presets:
+The only configuration source is:
 
-- `tokyo-night` — the default, inspired by the [Starship Tokyo Night preset](https://starship.rs/presets/tokyo-night), using `░▒▓` / `` powerline blocks and the Tokyo Night color ramp.
-- `classic` — a compact Pi-themed statusline with left-aligned `•` separators.
+```text
+<getAgentDir()>/pi-statusline.json
+```
 
-Unset or invalid values fall back to `tokyo-night`. Both presets keep the same emoji-labeled information.
+On first session start, the extension atomically creates the complete default document. It never overwrites an existing malformed or unreadable file. A valid legacy `pi-statusline-settings.json` is migrated by preserving its original bytes; the canonical filename wins when both exist.
 
-## ⚙️ Extension status icons
+There are no project overrides or environment-variable overrides.
 
-Extension statuses use built-in icons by status key. Override or suppress them in `${PI_CODING_AGENT_DIR:-~/.pi/agent}/pi-statusline.json`:
+### Default JSON
 
 ```json
 {
+  "palette": "tokyo-night",
+  "density": "compact",
+  "separator": "none",
+  "segments": [
+    "brand",
+    "provider",
+    "model",
+    "thinking",
+    "cwd",
+    "branch",
+    "tools",
+    "context",
+    "tokens",
+    "cost",
+    "time"
+  ],
+  "segmentText": {
+    "brand": { "prefix": "", "suffix": "" },
+    "provider": { "prefix": "🔌 ", "suffix": "" },
+    "model": { "prefix": "🤖 ", "suffix": "" },
+    "thinking": { "prefix": "🧠 ", "suffix": "" },
+    "cwd": { "prefix": "📁 ", "suffix": "" },
+    "branch": { "prefix": "🌿 ", "suffix": "" },
+    "tools": { "prefix": "", "suffix": "" },
+    "context": { "prefix": "🪟 ctx ", "suffix": "" },
+    "tokens": { "prefix": "🔢 ", "suffix": "" },
+    "cost": { "prefix": "💸 $", "suffix": "" },
+    "time": { "prefix": "🕒 ", "suffix": "" },
+    "turn": { "prefix": "🔁 #", "suffix": "" }
+  },
   "extensionStatusIcons": {
-    "caffeinate": "☕",
+    "chrome-devtools": "🌐",
+    "codex-usage": "📊",
+    "caffeinate": "💊",
+    "firecrawl": "🔥",
     "github-pr": "🔎",
     "goal": "🎯",
-    "pisync": "☁️",
-    "unknown-error-retry": "",
+    "lsp": "🧰",
     "plan-mode": "📝",
-    "subagents": "🤖",
-    "@vendor/pi-foo": "🧪"
+    "pisync": "🔄",
+    "subagents": "🧑‍🤝‍🧑",
+    "unknown-error-retry": "🔁"
   }
 }
 ```
 
-Compatibility: a valid legacy `pi-statusline-settings.json` is migrated automatically to `pi-statusline.json`. If both files exist, the new filename takes precedence.
+All fields are optional in an existing document. Missing fields use defaults.
+
+### Appearance
+
+- `palette`: `tokyo-night`, `ocean`, `sunset`, `forest`, `candy`, `neon`, or `mono`.
+- `density`: `compact` or `cozy`.
+- `separator`: `none`, `dot`, `bar`, `powerline`, or `round`.
+
+The separator applies only between adjacent segments in the same color block. Color-block transitions always use ``. Extension statuses remain on separate wrapped lines with their own palette-colored separator.
+
+### Segments
+
+`segments` is an ordered list containing:
+
+```text
+brand provider model thinking cwd branch tools context tokens cost time turn line_break
+```
+
+The array controls visibility and actual rendering order. Data segments must remain unique. The special `line_break` segment starts another footer row and may repeat when another segment separates each occurrence; consecutive `line_break` entries are invalid. Each row receives its own powerline start and end. `line_break` has no `segmentText` entry.
+
+An empty array hides the main powerline while still allowing extension statuses to render. `turn` is available but omitted by default.
+
+Example multiline layout:
+
+```json
+{
+  "segments": ["model", "line_break", "cwd", "line_break", "branch"]
+}
+```
+
+This is valid because the `line_break` entries are separated. `["model", "line_break", "line_break", "cwd"]` is invalid.
+
+### Segment text
 
-- Exact status key: always wins, e.g. `"goal"` or `"foo:server"`.
-- Installed extension id: for installed packages, use the package name/source such as `"@vendor/pi-foo"`, `"npm:@vendor/pi-foo@1.2.3"`, `"pi-foo"`, or the derived key `"foo"`.
-- Namespaced status keys: package `@vendor/pi-foo` can match `foo`, `foo:server`, and `foo/server`, but not fuzzy matches like `foobar`.
-- Missing key: use the built-in icon, or `🔌` for an unknown status key.
-- String value: use that string as the icon.
-- Empty string: show the status text without an icon.
-- If multiple installed packages derive the same key, use the exact status key to disambiguate.
-- `PI_STATUSLINE_PRESET` remains the only preset setting; this JSON file only controls extension status icons.
+Each visible segment renders as:
 
-During the `PI_CAFFEINATE_ICON` deprecation window, a leading emoji from `pi-caffeinate` is still used when JSON does not configure `caffeinate`. JSON wins when both are set.
+```text
+prefix + Pi-owned dynamic value + suffix
+```
 
-## 👀 What it shows
+Override either string independently:
 
-The default `tokyo-night` statusline uses a Starship-inspired `░▒▓` / `` powerline layout and includes:
+```json
+{
+  "segmentText": {
+    "provider": { "prefix": "Provider: " },
+    "context": { "prefix": "[", "suffix": "]" },
+    "cost": { "prefix": "Cost $", "suffix": " USD" }
+  }
+}
+```
 
-- `π` brand marker.
-- 🤖 current model.
-- 🧠 thinking level.
-- 📁 current project directory.
-- 🌿 git branch, with compact git status tokens when dirty or ahead/behind.
-- ⚙ active or last tool.
-- 🪟 context usage percentage.
-- 🔢 token totals.
-- 💸 estimated cost.
-- 🕒 clock.
+Prefix and suffix values must be single-line text without terminal control characters; use the `line_break` segment for additional rows.
 
-Git status tokens are hidden for clean repositories. When present, they mean `⇡` ahead, `⇣` behind, `+` staged, `~` modified/deleted in the worktree, `?` untracked, and `!` conflicts. Example: `🌿 main ⇡1 +2 ~1 ?3`.
+This structured model intentionally does not provide variables or a format language. Dynamic Git, PR, activity, usage, token, and cost formatting remains owned by the extension.
 
-Statuses from other extensions appear below the main statusline, use each preset's separator, and wrap onto additional footer lines when they exceed the terminal width.
+### Extension status icons
 
-`pi-statusline` is extension-agnostic: it consumes Pi's generic extension status API and does not import or depend on status-producing extensions.
+`extensionStatusIcons` preserves these rules:
 
-Examples:
+- An exact status key wins, such as `goal` or `foo:server`.
+- Installed package aliases such as `@vendor/pi-foo`, `npm:@vendor/pi-foo@1.2.3`, `pi-foo`, or `foo` can configure namespaced statuses.
+- An empty string hides the icon but keeps the status text.
+- A missing key uses the built-in icon or `🔌` for an unknown key.
+- Ambiguous package aliases require an exact status key.
 
-- `🎯 active` for `goal: active` using the built-in `goal` icon.
-- `🔎 PR #123 checks passing` for `github-pr: PR #123 checks passing` using the built-in `github-pr` icon.
-- `☕ display` when JSON config sets `"caffeinate": "☕"`.
-- `🧪 running` for third-party status `foo:server` when an installed package is named `@vendor/pi-foo` and JSON config sets `"@vendor/pi-foo": "🧪"`.
-- `receiving` when JSON config sets `"unknown-error-retry": ""`.
-- `🔌 running` for an unknown extension status key with no configured icon.
-- `⚠️ dup biome-lsp` when local and npm installs register the same extension.
+Statuses from other extensions appear below the main powerline. The linked GitHub PR status is hidden from that line when the branch segment already renders it.
 
-## 🧠 Use cases
+## Commands
 
-- Track agent context usage during long coding sessions.
-- See which model and thinking level are active.
-- Monitor token totals and estimated cost.
-- Keep git branch and project directory visible.
-- Make Pi terminal sessions easier to scan at a glance.
+| Command | Purpose |
+| --- | --- |
+| `/statusline settings` | Edit raw JSON in TUI, validate, atomically save, and apply immediately |
+| `/statusline status` | Show settings path/source, effective appearance, segments, and diagnostics |
+| `/statusline help` | Show command and schema guidance |
 
-## 🗂️ Package layout
+Invalid or cancelled edits leave both the previous file and effective runtime configuration unchanged. The editor is TUI-only; status and help are safe in TUI, print, JSON, and RPC modes.
 
-```txt
+## Git and activity details
+
+Git status tokens are hidden for clean repositories. When present, they mean `⇡` ahead, `⇣` behind, `+` staged, `~` modified/deleted, `?` untracked, and `!` conflicts.
+
+The tools segment distinguishes active tools, streaming/thinking, the last completed tool, and idle state. Parallel calls are summarized without running subprocesses during footer rendering.
+
+## Package layout
+
+```text
 extensions/pi-statusline/
 ├── src/
-│   ├── statusline.ts  # Pi entrypoint and watcher lifecycle
-│   └── *.ts           # Package-local git, extension status, settings, and render modules
-├── presets/
 │   ├── ansi.ts
-│   ├── classic.ts
+│   ├── commands.ts
+│   ├── extension-status.ts
+│   ├── git-status.ts
+│   ├── render.ts
+│   ├── settings.ts
+│   ├── statusline.ts
 │   ├── tokyo-night.ts
 │   └── types.ts
+├── test/
 ├── README.md
 ├── LICENSE
 ├── tsconfig.json
 └── package.json
 ```
 
-Only `statusline.ts` is a Pi entrypoint; the other source modules are internal. The package exposes its Pi extension through `package.json`:
-
-```json
-{
-  "pi": {
-    "extensions": ["./src/statusline.ts"]
-  }
-}
-```
+Only `src/statusline.ts` is a Pi entrypoint. Other modules are package-internal.
 
-## 🔎 Keywords
+## Keywords
 
-Pi extension, Pi coding agent, statusline, terminal UI, AI coding agent status, token usage, context window, model status, TypeScript Pi package.
+Pi extension, Pi coding agent, configurable statusline, Tokyo Night, terminal footer, token usage, context window, model status, TypeScript Pi package.
 
-## 📄 License
+## License
 
 MIT. See [`LICENSE`](./LICENSE).

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@narumitw/pi-statusline",
-	"version": "0.20.0",
+	"version": "0.23.0",
 	"description": "Pi extension that replaces the footer with an information-rich statusline.",
 	"type": "module",
 	"license": "MIT",
@@ -14,7 +14,6 @@
 	],
 	"files": [
 		"src",
-		"presets",
 		"README.md",
 		"LICENSE"
 	],
@@ -24,8 +23,8 @@
 		]
 	},
 	"scripts": {
-		"check": "biome check . && npm run typecheck",
-		"format": "biome check --write .",
+		"check": "biome check --vcs-use-ignore-file=false src test package.json tsconfig.json README.md && npm run typecheck",
+		"format": "biome check --write --vcs-use-ignore-file=false src test package.json tsconfig.json README.md",
 		"typecheck": "tsc --noEmit"
 	},
 	"devDependencies": {

package/src/commands.ts

@@ -0,0 +1,118 @@
+import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import type { AutocompleteItem } from "@earendil-works/pi-tui";
+import {
+	DEFAULT_STATUSLINE_DOCUMENT,
+	type LoadedStatuslineSettings,
+	saveStatuslineSettingsDocument,
+} from "./settings.js";
+
+const SUBCOMMANDS: AutocompleteItem[] = [
+	{ value: "settings", label: "settings", description: "Edit pi-statusline.json" },
+	{ value: "status", label: "status", description: "Show effective statusline settings" },
+	{ value: "help", label: "help", description: "Show configuration help" },
+];
+
+export interface StatuslineCommandOptions {
+	settingsPath: string;
+	getLoaded(): LoadedStatuslineSettings;
+	apply(loaded: LoadedStatuslineSettings, ctx: ExtensionCommandContext): void;
+	save?: (settingsPath: string, rawDocument: string) => LoadedStatuslineSettings;
+}
+
+export function registerStatuslineCommand(pi: ExtensionAPI, options: StatuslineCommandOptions) {
+	pi.registerCommand("statusline", {
+		description: "Edit or inspect the Tokyo Night footer settings",
+		getArgumentCompletions(prefix: string): AutocompleteItem[] | null {
+			const normalized = prefix.trim().toLowerCase();
+			const matches = SUBCOMMANDS.filter((item) => item.value.startsWith(normalized));
+			return matches.length > 0 ? matches : null;
+		},
+		handler: async (args, ctx) => {
+			const subcommand = args.trim().split(/\s+/u)[0]?.toLowerCase() || "help";
+			switch (subcommand) {
+				case "settings":
+					await editSettings(ctx, options);
+					return;
+				case "status":
+					showStatus(ctx, options);
+					return;
+				case "help":
+					showHelp(ctx, options.settingsPath);
+					return;
+				default:
+					if (canNotify(ctx)) {
+						ctx.ui.notify(`Unknown /statusline subcommand: ${subcommand}`, "warning");
+					}
+			}
+		},
+	});
+}
+
+async function editSettings(ctx: ExtensionCommandContext, options: StatuslineCommandOptions) {
+	if (ctx.mode !== "tui") {
+		if (ctx.hasUI) ctx.ui.notify(`Edit settings manually: ${options.settingsPath}`, "info");
+		return;
+	}
+	const current = options.getLoaded();
+	const edited = await ctx.ui.editor(
+		"pi-statusline.json — save and close to apply",
+		current.rawDocument ?? DEFAULT_STATUSLINE_DOCUMENT,
+	);
+	if (edited === undefined) return;
+	try {
+		const loaded = (options.save ?? saveStatuslineSettingsDocument)(options.settingsPath, edited);
+		options.apply(loaded, ctx);
+		const suffix =
+			loaded.diagnostics.length > 0
+				? ` (${loaded.diagnostics.length} warning${loaded.diagnostics.length === 1 ? "" : "s"})`
+				: "";
+		ctx.ui.notify(`pi-statusline settings saved and applied${suffix}.`, "info");
+	} catch (error) {
+		ctx.ui.notify(`pi-statusline settings were not saved: ${formatError(error)}`, "error");
+	}
+}
+
+function showStatus(ctx: ExtensionCommandContext, options: StatuslineCommandOptions) {
+	if (!canNotify(ctx)) return;
+	const loaded = options.getLoaded();
+	const diagnostics = loaded.diagnostics
+		.slice(0, 5)
+		.map((item) => `${item.path || "root"}: ${item.message}`)
+		.join("; ");
+	ctx.ui.notify(
+		[
+			`pi-statusline source: ${loaded.source}`,
+			`path: ${options.settingsPath}`,
+			`palette: ${loaded.config.palette}`,
+			`density: ${loaded.config.density}`,
+			`separator: ${loaded.config.separator}`,
+			`segments: ${loaded.config.segments.join(", ") || "none"}`,
+			diagnostics ? `warnings: ${diagnostics}` : "warnings: none",
+		].join("\n"),
+		loaded.diagnostics.length > 0 ? "warning" : "info",
+	);
+}
+
+function showHelp(ctx: ExtensionCommandContext, settingsPath: string) {
+	if (!canNotify(ctx)) return;
+	ctx.ui.notify(
+		[
+			"/statusline settings — edit and apply JSON",
+			"/statusline status — show source, path, and warnings",
+			"/statusline help — show this help",
+			`Settings: ${settingsPath}`,
+			"Fields: palette, density, separator, segments, segmentText, extensionStatusIcons",
+			"Use line_break between segments for another footer row; repeats must not be consecutive.",
+			"The segmentText entries support prefix and suffix strings around Pi-owned dynamic values.",
+		].join("\n"),
+		"info",
+	);
+}
+
+function canNotify(ctx: ExtensionCommandContext): boolean {
+	return ctx.mode === "tui" || ctx.hasUI;
+}
+
+function formatError(error: unknown): string {
+	return error instanceof Error ? error.message : String(error);
+}

package/src/extension-status.ts

@@ -3,9 +3,9 @@ import { dirname, isAbsolute, join, resolve } from "node:path";
 import process from "node:process";
 import type { Theme, ThemeColor } from "@earendil-works/pi-coding-agent";
 import { wrapTextWithAnsi } from "@earendil-works/pi-tui";
-import { classicExtensionSeparator } from "../presets/classic.js";
-import { tokyoNightExtensionSeparator } from "../presets/tokyo-night.js";
-import type { StatuslineConfig, StatuslinePresetName } from "../presets/types.js";
+import { DEFAULT_EXTENSION_STATUS_ICONS } from "./settings.js";
+import { tokyoNightExtensionSeparator } from "./tokyo-night.js";
+import type { StatuslineConfig } from "./types.js";
 
 export type ExtensionStatusIconAliasMap = ReadonlyMap<string, readonly string[]>;
 export interface ExtensionStatusRuntime {
@@ -14,26 +14,9 @@ export interface ExtensionStatusRuntime {
 }
 
 const STATUSLINE_KEY = "statusline";
-const GITHUB_PR_KEY = "github-pr";
 const EMPTY_EXTENSION_STATUS_ICON_ALIASES: ExtensionStatusIconAliasMap = new Map();
-const DEFAULT_EXTENSION_STATUS_ICONS: Record<string, string> = {
-	"chrome-devtools": "🌐",
-	"codex-usage": "📊",
-	caffeinate: "💊",
-	firecrawl: "🔥",
-	"github-pr": "🔎",
-	goal: "🎯",
-	lsp: "🧰",
-	"plan-mode": "📝",
-	pisync: "🔄",
-	subagents: "🧑‍🤝‍🧑",
-	"unknown-error-retry": "🔁",
-};
-
-function extensionStatusSeparator(presetName: StatuslinePresetName, theme: Theme): string {
-	return presetName === "classic"
-		? classicExtensionSeparator(theme)
-		: tokyoNightExtensionSeparator(theme);
+function extensionStatusSeparator(config: StatuslineConfig, theme: Theme): string {
+	return tokyoNightExtensionSeparator(theme, config.palette);
 }
 
 export function formatExtensionStatuses(
@@ -41,15 +24,14 @@ export function formatExtensionStatuses(
 	theme: Theme,
 	config: StatuslineConfig,
 	runtime: ExtensionStatusRuntime,
+	hiddenKeys: ReadonlySet<string> = new Set(),
 ): string {
-	const separator = extensionStatusSeparator(config.preset, theme);
+	const separator = extensionStatusSeparator(config, theme);
 	const visibleStatuses = [
 		...formatDuplicateExtensionStatus(runtime, theme),
 		...[...statuses.entries()]
-			// github-pr is rendered inline in the branch segment, so skip it here to avoid duplication.
 			.filter(
-				([key, value]) =>
-					key !== STATUSLINE_KEY && key !== GITHUB_PR_KEY && value.trim().length > 0,
+				([key, value]) => key !== STATUSLINE_KEY && !hiddenKeys.has(key) && value.trim().length > 0,
 			)
 			.map(([key, value]) =>
 				formatExtensionStatus(key, value, theme, config, runtime.extensionStatusIconAliases),
@@ -70,7 +52,12 @@ export function formatExtensionStatus(
 	const text = simplifyExtensionStatusText(status.text);
 	const color = extensionColor(key, value);
 	const textColor = color === "warning" ? "warning" : "muted";
-	const icon = extensionStatusIcon(key, status.icon, config.extensionStatusIcons, extensionStatusIconAliases);
+	const icon = extensionStatusIcon(
+		key,
+		status.icon,
+		config.extensionStatusIcons,
+		extensionStatusIconAliases,
+	);
 	const renderedText = theme.fg(textColor, text);
 	return icon ? `${theme.fg(color, icon)} ${renderedText}` : renderedText;
 }
@@ -187,7 +174,9 @@ function extensionSettingsFiles(cwd: string): string[] {
 	].filter((file) => existsSync(file));
 }
 
-export function findDuplicateExtensions(installedPackages: readonly InstalledExtensionPackage[]): string[] {
+export function findDuplicateExtensions(
+	installedPackages: readonly InstalledExtensionPackage[],
+): string[] {
 	const sourcesByPackage = new Map<string, Set<string>>();
 
 	for (const extensionPackage of installedPackages) {
@@ -207,17 +196,25 @@ export function buildExtensionStatusIconAliases(
 	const packageAliasesByStatusBase = new Map<string, Map<string, string[]>>();
 
 	for (const extensionPackage of installedPackages) {
-		const candidate = extensionStatusIconAliasCandidate(extensionPackage.packageName, extensionPackage.source);
+		const candidate = extensionStatusIconAliasCandidate(
+			extensionPackage.packageName,
+			extensionPackage.source,
+		);
 		if (!candidate) continue;
-		const aliasesByPackage = packageAliasesByStatusBase.get(candidate.statusBase) ?? new Map<string, string[]>();
+		const aliasesByPackage =
+			packageAliasesByStatusBase.get(candidate.statusBase) ?? new Map<string, string[]>();
 		const existingAliases = aliasesByPackage.get(extensionPackage.packageName) ?? [];
-		aliasesByPackage.set(extensionPackage.packageName, uniqueStrings([...existingAliases, ...candidate.aliases]));
+		aliasesByPackage.set(
+			extensionPackage.packageName,
+			uniqueStrings([...existingAliases, ...candidate.aliases]),
+		);
 		packageAliasesByStatusBase.set(candidate.statusBase, aliasesByPackage);
 	}
 
 	const aliases = new Map<string, string[]>();
 	for (const [statusBase, aliasesByPackage] of packageAliasesByStatusBase) {
-		if (aliasesByPackage.size === 1) aliases.set(statusBase, [...aliasesByPackage.values()][0] ?? []);
+		if (aliasesByPackage.size === 1)
+			aliases.set(statusBase, [...aliasesByPackage.values()][0] ?? []);
 	}
 	return aliases;
 }

package/src/git-status.ts

@@ -87,14 +87,22 @@ export function formatGitStatusSummary(summary: GitStatusSummary | undefined): s
 		.join(" ");
 }
 
-export function formatGitBranchText(
+export function formatGitBranchValue(
 	branch: string | null,
 	status: GitStatusSummary | undefined,
 	pr?: string,
 ): string {
-	if (!branch) return "🌿 no-git";
+	if (!branch) return "no-git";
 	const suffixes = [formatGitStatusSummary(status), pr ? `(${pr})` : ""].filter(Boolean);
-	return suffixes.length > 0 ? `🌿 ${branch} ${suffixes.join(" ")}` : `🌿 ${branch}`;
+	return suffixes.length > 0 ? `${branch} ${suffixes.join(" ")}` : branch;
+}
+
+export function formatGitBranchText(
+	branch: string | null,
+	status: GitStatusSummary | undefined,
+	pr?: string,
+): string {
+	return `🌿 ${formatGitBranchValue(branch, status, pr)}`;
 }
 
 export function gitStatusSummaryEqual(