@narumitw/pi-statusline 0.13.0 → 0.14.0

package/README.md

@@ -125,7 +125,8 @@ Examples:
 ```txt
 extensions/pi-statusline/
 ├── src/
-│   └── statusline.ts
+│   ├── statusline.ts  # Pi entrypoint and watcher lifecycle
+│   └── *.ts           # Package-local git, extension status, settings, and render modules
 ├── presets/
 │   ├── ansi.ts
 │   ├── classic.ts
@@ -137,7 +138,7 @@ extensions/pi-statusline/
 └── package.json
 ```
 
-The package exposes its Pi extension through `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
 {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@narumitw/pi-statusline",
-	"version": "0.13.0",
+	"version": "0.14.0",
 	"description": "Pi extension that replaces the footer with an information-rich statusline.",
 	"type": "module",
 	"license": "MIT",
@@ -29,10 +29,10 @@
 		"typecheck": "tsc --noEmit"
 	},
 	"devDependencies": {
-		"@biomejs/biome": "2.5.2",
+		"@biomejs/biome": "2.5.3",
 		"@earendil-works/pi-coding-agent": "0.80.3",
 		"@earendil-works/pi-tui": "0.80.3",
-		"@types/node": "26.1.0",
+		"@types/node": "26.1.1",
 		"typescript": "6.0.3"
 	},
 	"repository": {

package/src/extension-status.ts

@@ -0,0 +1,300 @@
+import { existsSync, readFileSync } from "node:fs";
+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";
+
+export type ExtensionStatusIconAliasMap = ReadonlyMap<string, readonly string[]>;
+export interface ExtensionStatusRuntime {
+	duplicateExtensions: string[];
+	extensionStatusIconAliases: ExtensionStatusIconAliasMap;
+}
+
+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);
+}
+
+export function formatExtensionStatuses(
+	statuses: ReadonlyMap<string, string>,
+	theme: Theme,
+	config: StatuslineConfig,
+	runtime: ExtensionStatusRuntime,
+): string {
+	const separator = extensionStatusSeparator(config.preset, 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,
+			)
+			.map(([key, value]) =>
+				formatExtensionStatus(key, value, theme, config, runtime.extensionStatusIconAliases),
+			),
+	].slice(0, 5);
+
+	return visibleStatuses.join(separator);
+}
+
+export function formatExtensionStatus(
+	key: string,
+	value: string,
+	theme: Theme,
+	config: Pick<StatuslineConfig, "extensionStatusIcons">,
+	extensionStatusIconAliases: ExtensionStatusIconAliasMap = EMPTY_EXTENSION_STATUS_ICON_ALIASES,
+): string {
+	const status = splitExtensionStatusIcon(stripExtensionStatusPrefix(key, value));
+	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 renderedText = theme.fg(textColor, text);
+	return icon ? `${theme.fg(color, icon)} ${renderedText}` : renderedText;
+}
+
+function extensionStatusIcon(
+	key: string,
+	leadingIcon: string | undefined,
+	configuredIcons: Record<string, string>,
+	extensionStatusIconAliases: ExtensionStatusIconAliasMap,
+) {
+	if (Object.hasOwn(configuredIcons, key)) return configuredIcons[key];
+	for (const alias of extensionStatusAliasesForKey(key, extensionStatusIconAliases)) {
+		if (Object.hasOwn(configuredIcons, alias)) return configuredIcons[alias];
+	}
+	return leadingIcon ?? DEFAULT_EXTENSION_STATUS_ICONS[key] ?? "🔌";
+}
+
+function extensionStatusAliasesForKey(
+	key: string,
+	extensionStatusIconAliases: ExtensionStatusIconAliasMap,
+): readonly string[] {
+	for (const [statusBase, aliases] of extensionStatusIconAliases) {
+		if (statusKeyMatchesStatusBase(key, statusBase)) return aliases;
+	}
+	return [];
+}
+
+function statusKeyMatchesStatusBase(key: string, statusBase: string): boolean {
+	return key === statusBase || key.startsWith(`${statusBase}:`) || key.startsWith(`${statusBase}/`);
+}
+
+export function wrapExtensionStatusline(status: string, width: number): string[] {
+	if (!status || width <= 0) return [];
+	return wrapTextWithAnsi(status, width);
+}
+
+function formatDuplicateExtensionStatus(runtime: ExtensionStatusRuntime, theme: Theme): string[] {
+	if (runtime.duplicateExtensions.length === 0) return [];
+	const names = runtime.duplicateExtensions.slice(0, 2).join(", ");
+	const suffix =
+		runtime.duplicateExtensions.length > 2 ? ` +${runtime.duplicateExtensions.length - 2}` : "";
+	return [`${theme.fg("warning", "⚠️")} ${theme.fg("warning", `dup ${names}${suffix}`)}`];
+}
+
+export function splitExtensionStatusIcon(value: string): { icon?: string; text: string } {
+	const trimmed = value.trim();
+	const [firstToken, ...restTokens] = trimmed.split(/\s+/);
+	if (firstToken && isEmojiOnlyToken(firstToken)) {
+		return { icon: firstToken, text: restTokens.join(" ") };
+	}
+	return { text: trimmed };
+}
+
+function isEmojiOnlyToken(value: string): boolean {
+	return /^(?=.*(?:\p{Extended_Pictographic}|\p{Regional_Indicator}|[0-9#*]\ufe0f?\u20e3))(?:\p{Extended_Pictographic}|\p{Emoji_Modifier}|\p{Regional_Indicator}|\u200d|\ufe0f|[0-9#*]\ufe0f?\u20e3)+$/u.test(
+		value,
+	);
+}
+
+export function extensionColor(key: string, value: string): ThemeColor {
+	const normalized = `${key} ${value}`.toLowerCase();
+	if (/missing|error|fail|conflict|duplicate|unavailable/.test(normalized)) return "warning";
+	if (normalized.includes("codex")) return "accent";
+	if (/ready|active|running|enabled|awake|ok/.test(normalized)) return "success";
+	return "muted";
+}
+
+export function stripExtensionStatusPrefix(key: string, value: string): string {
+	return value.trim().replace(new RegExp(`^${escapeRegExp(key)}\\s*:\\s*`, "iu"), "");
+}
+
+export function simplifyExtensionStatusText(value: string): string {
+	return value
+		.trim()
+		.replace(/\bready\b/giu, "✓")
+		.replace(/\bmissing\b/giu, "✗")
+		.replace(/,\s*/g, " ")
+		.replace(/\s+\([^)]*\)\s*$/, "")
+		.replace(/\s+/g, " ");
+}
+
+function escapeRegExp(value: string): string {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+interface InstalledExtensionPackage {
+	packageName: string;
+	source: string;
+	identity: string;
+}
+
+export function readInstalledExtensionPackages(cwd: string): InstalledExtensionPackage[] {
+	const packages: InstalledExtensionPackage[] = [];
+	const settingsFiles = extensionSettingsFiles(cwd);
+
+	for (const settingsFile of settingsFiles) {
+		const baseDirectory = dirname(settingsFile);
+		for (const rawSource of readPackageSources(settingsFile)) {
+			const source = rawSource.trim();
+			if (!source) continue;
+			const packageName = packageNameForSource(source, baseDirectory);
+			if (!packageName) continue;
+			packages.push({ packageName, source, identity: sourceIdentity(source, baseDirectory) });
+		}
+	}
+
+	return packages;
+}
+
+function extensionSettingsFiles(cwd: string): string[] {
+	return [
+		join(process.env.HOME ?? "", ".pi", "agent", "settings.json"),
+		join(cwd, ".pi", "settings.json"),
+	].filter((file) => existsSync(file));
+}
+
+export function findDuplicateExtensions(installedPackages: readonly InstalledExtensionPackage[]): string[] {
+	const sourcesByPackage = new Map<string, Set<string>>();
+
+	for (const extensionPackage of installedPackages) {
+		const sources = sourcesByPackage.get(extensionPackage.packageName) ?? new Set<string>();
+		sources.add(extensionPackage.identity);
+		sourcesByPackage.set(extensionPackage.packageName, sources);
+	}
+
+	return [...sourcesByPackage.entries()]
+		.filter(([, sources]) => sources.size > 1)
+		.map(([packageName]) => packageName.replace(/^@[^/]+\//, "").replace(/^pi-/, ""));
+}
+
+export function buildExtensionStatusIconAliases(
+	installedPackages: readonly { packageName: string; source?: string }[],
+): Map<string, string[]> {
+	const packageAliasesByStatusBase = new Map<string, Map<string, string[]>>();
+
+	for (const extensionPackage of installedPackages) {
+		const candidate = extensionStatusIconAliasCandidate(extensionPackage.packageName, extensionPackage.source);
+		if (!candidate) continue;
+		const aliasesByPackage = packageAliasesByStatusBase.get(candidate.statusBase) ?? new Map<string, string[]>();
+		const existingAliases = aliasesByPackage.get(extensionPackage.packageName) ?? [];
+		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] ?? []);
+	}
+	return aliases;
+}
+
+function extensionStatusIconAliasCandidate(
+	packageName: string,
+	source?: string,
+): { statusBase: string; aliases: string[] } | undefined {
+	const packageBase = packageBaseName(packageName);
+	const statusBase = statusBaseFromPackageBase(packageBase);
+	if (!statusBase) return undefined;
+
+	const sourceAliases = source?.startsWith("npm:") ? [source, `npm:${npmPackageName(source)}`] : [];
+	return {
+		statusBase,
+		aliases: uniqueStrings([...sourceAliases, packageName, packageBase, statusBase]),
+	};
+}
+
+function packageBaseName(packageName: string): string {
+	const slashIndex = packageName.lastIndexOf("/");
+	return slashIndex === -1 ? packageName : packageName.slice(slashIndex + 1);
+}
+
+function statusBaseFromPackageBase(packageBase: string): string {
+	return packageBase.startsWith("pi-") && packageBase.length > "pi-".length
+		? packageBase.slice("pi-".length)
+		: packageBase;
+}
+
+function uniqueStrings(values: readonly string[]): string[] {
+	return [...new Set(values.filter((value) => value.length > 0))];
+}
+
+function readPackageSources(settingsFile: string): string[] {
+	try {
+		const settings = JSON.parse(readFileSync(settingsFile, "utf8")) as { packages?: unknown[] };
+		return (settings.packages ?? [])
+			.map((entry) => {
+				if (typeof entry === "string") return entry;
+				if (
+					entry &&
+					typeof entry === "object" &&
+					typeof (entry as { source?: unknown }).source === "string"
+				) {
+					return (entry as { source: string }).source;
+				}
+				return undefined;
+			})
+			.filter((source): source is string => source !== undefined);
+	} catch {
+		return [];
+	}
+}
+
+function packageNameForSource(source: string, baseDirectory: string): string | undefined {
+	if (source.startsWith("npm:")) return npmPackageName(source);
+	const packageJson = join(resolveSourcePath(source, baseDirectory), "package.json");
+	try {
+		const packageData = JSON.parse(readFileSync(packageJson, "utf8")) as { name?: unknown };
+		return typeof packageData.name === "string" ? packageData.name : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+export function npmPackageName(source: string): string {
+	const spec = source.slice("npm:".length);
+	if (spec.startsWith("@")) return spec.split("@").slice(0, 2).join("@").replace(/^@/, "@");
+	return spec.split("@")[0] ?? spec;
+}
+
+function sourceIdentity(source: string, baseDirectory: string): string {
+	if (source.startsWith("npm:")) return `npm:${npmPackageName(source)}`;
+	return resolveSourcePath(source, baseDirectory);
+}
+
+function resolveSourcePath(source: string, baseDirectory: string): string {
+	return isAbsolute(source) ? source : resolve(baseDirectory, source);
+}

package/src/git-status.ts

@@ -0,0 +1,117 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+const GIT_STATUS_TIMEOUT_MS = 3_000;
+
+export interface GitStatusSummary {
+	ahead: number;
+	behind: number;
+	staged: number;
+	modified: number;
+	untracked: number;
+	conflicts: number;
+}
+
+export async function readGitStatus(
+	pi: ExtensionAPI,
+	cwd: string,
+): Promise<GitStatusSummary | undefined> {
+	const result = await pi.exec(
+		"git",
+		["--no-optional-locks", "status", "--porcelain=v1", "--branch", "--untracked-files=normal"],
+		{ cwd, timeout: GIT_STATUS_TIMEOUT_MS },
+	);
+	if (result.code !== 0 || result.killed) return undefined;
+	return parseGitStatusPorcelain(result.stdout);
+}
+
+export function parseGitStatusPorcelain(output: string): GitStatusSummary {
+	const summary: GitStatusSummary = {
+		ahead: 0,
+		behind: 0,
+		staged: 0,
+		modified: 0,
+		untracked: 0,
+		conflicts: 0,
+	};
+	for (const line of output.split(/\r?\n/)) {
+		if (!line) continue;
+		if (line.startsWith("## ")) {
+			const ahead = line.match(/\bahead (\d+)/u);
+			const behind = line.match(/\bbehind (\d+)/u);
+			summary.ahead = ahead ? Number(ahead[1]) : 0;
+			summary.behind = behind ? Number(behind[1]) : 0;
+			continue;
+		}
+		const indexStatus = line[0] ?? " ";
+		const worktreeStatus = line[1] ?? " ";
+		if (indexStatus === "?" && worktreeStatus === "?") {
+			summary.untracked += 1;
+			continue;
+		}
+		if (isConflictStatus(indexStatus, worktreeStatus)) {
+			summary.conflicts += 1;
+			continue;
+		}
+		if (isChangedStatus(indexStatus)) summary.staged += 1;
+		if (isChangedStatus(worktreeStatus)) summary.modified += 1;
+	}
+	return summary;
+}
+
+function isConflictStatus(indexStatus: string, worktreeStatus: string): boolean {
+	return (
+		(indexStatus === "D" && worktreeStatus === "D") ||
+		(indexStatus === "A" && worktreeStatus === "A") ||
+		indexStatus === "U" ||
+		worktreeStatus === "U"
+	);
+}
+
+function isChangedStatus(status: string): boolean {
+	return status !== " " && status !== "?" && status !== "!";
+}
+
+export function formatGitStatusSummary(summary: GitStatusSummary | undefined): string {
+	if (!summary) return "";
+	const tokens = [
+		["⇡", summary.ahead],
+		["⇣", summary.behind],
+		["+", summary.staged],
+		["~", summary.modified],
+		["?", summary.untracked],
+		["!", summary.conflicts],
+	] as const;
+	return tokens
+		.filter(([, count]) => count > 0)
+		.map(([prefix, count]) => `${prefix}${formatCount(count)}`)
+		.join(" ");
+}
+
+export function formatGitBranchText(
+	branch: string | null,
+	status: GitStatusSummary | undefined,
+	pr?: string,
+): string {
+	if (!branch) return "🌿 no-git";
+	const suffixes = [formatGitStatusSummary(status), pr ? `(${pr})` : ""].filter(Boolean);
+	return suffixes.length > 0 ? `🌿 ${branch} ${suffixes.join(" ")}` : `🌿 ${branch}`;
+}
+
+export function gitStatusSummaryEqual(
+	left: GitStatusSummary | undefined,
+	right: GitStatusSummary | undefined,
+): boolean {
+	if (!left || !right) return left === right;
+	return (
+		left.ahead === right.ahead &&
+		left.behind === right.behind &&
+		left.staged === right.staged &&
+		left.modified === right.modified &&
+		left.untracked === right.untracked &&
+		left.conflicts === right.conflicts
+	);
+}
+
+function formatCount(value: number): string {
+	return Intl.NumberFormat("en", { notation: "compact", maximumFractionDigits: 1 }).format(value);
+}