@xzzpig/pi-starline 0.5.1 → 0.7.1

package/extensions/starline/pill-config.ts

@@ -26,6 +26,8 @@ export type PillConfig = {
 	separator: PillSeparator;
 	bold: boolean;
 	caps: PillCaps;
+	/** Unfold a pill's bubble upward from the pill instead of showing it at once. */
+	bubbleAnimation: boolean;
 };
 
 export const EXTENSION_STATUS_SEGMENT = "extensionStatus";
@@ -35,18 +37,17 @@ export const EXTENSION_STATUS_PREFIX = `${EXTENSION_STATUS_SEGMENT}:`;
 export const PILL_SEGMENT_VARIABLES: Record<string, string> = {
 	model: "model",
 	thinking: "thinking",
+	queue: "queue",
+	subagents: "subagents",
 	cwd: "cwd",
 	sessionName: "session_name",
-	gitBranch: "git_branch",
-	gitStatus: "git_status",
-	gitState: "git_state",
+	git: "git",
 	gitCommit: "git_commit",
 	gitTag: "git_tag",
 	gitMetrics: "git_metrics",
 	runtime: "runtime",
 	context: "context",
-	tokens: "tokens",
-	cacheHit: "cache_hit",
+	tps: "tps",
 	cost: "cost",
 	sessionDuration: "session_duration",
 	username: "username",
@@ -59,16 +60,19 @@ export const DEFAULT_PILL_CONFIG: PillConfig = {
 	segments: [
 		"model",
 		"thinking",
+		"queue",
+		"subagents",
 		"cwd",
-		"gitBranch",
-		"gitStatus",
+		"git",
 		"context",
+		"tps",
 		"cost",
 		EXTENSION_STATUS_SEGMENT,
 	],
 	separator: "powerline",
 	bold: true,
 	caps: "round",
+	bubbleAnimation: true,
 };
 
 function isRecord(value: unknown): value is Record<string, unknown> {
@@ -98,15 +102,65 @@ export function isKnownPillSegment(name: string): boolean {
 	return name in PILL_SEGMENT_VARIABLES;
 }
 
+/**
+ * Every segment name `/starline` can put on the bar, in a fixed order so the
+ * rows do not move under the cursor when a position changes. Per-status
+ * `extensionStatus:<key>` entries are not listed here: they depend on what other
+ * extensions published this session, and the *Pills* tab appends a row for each
+ * one after these.
+ */
+export const PILL_SEGMENT_NAMES: readonly string[] = [
+	...Object.keys(PILL_SEGMENT_VARIABLES),
+	EXTENSION_STATUS_SEGMENT,
+];
+
+/** 1-based position of a segment in the bar, or 0 when it is not drawn. */
+export function pillSegmentPosition(segments: readonly string[], name: string): number {
+	return segments.indexOf(name) + 1;
+}
+
+/**
+ * Apply a position edit to `pill.segments`.
+ *
+ * `value` is `off` or a 1-based position. A position is where the segment ends
+ * up: everything already there shifts along, and a position past the end
+ * appends. Moving the segment that is already in the bar works the same way,
+ * because it is removed before the index is applied.
+ */
+export function movePillSegment(
+	segments: readonly string[],
+	name: string,
+	value: string,
+): string[] {
+	const rest = segments.filter((segment) => segment !== name);
+	if (value === "off") return rest;
+	const position = Number(value);
+	if (!Number.isInteger(position) || position < 1) return [...segments];
+	const index = Math.min(position - 1, rest.length);
+	return [...rest.slice(0, index), name, ...rest.slice(index)];
+}
+
+/** Segment names that became part of another one. */
+const LEGACY_SEGMENT_NAMES: Record<string, string> = {
+	gitBranch: "git",
+	gitStatus: "git",
+	gitState: "git",
+	tokens: "context",
+	cacheHit: "context",
+};
+
 function parseSegments(value: unknown): string[] {
 	if (!Array.isArray(value)) return DEFAULT_PILL_CONFIG.segments;
 	const segments: string[] = [];
 	for (const entry of value) {
 		if (typeof entry !== "string") continue;
-		const name = entry.trim();
+		// A bar that listed the branch and the dirty block separately now draws
+		// both in one pill, so the old names collapse into it instead of vanishing.
+		const renamed = LEGACY_SEGMENT_NAMES[entry.trim()] ?? entry.trim();
 		// Unknown names are dropped rather than rendered as empty pills, so a
 		// typo shortens the bar instead of punching a hole in it.
-		if (name && isKnownPillSegment(name) && !segments.includes(name)) segments.push(name);
+		if (renamed && isKnownPillSegment(renamed) && !segments.includes(renamed))
+			segments.push(renamed);
 	}
 	return segments;
 }
@@ -118,5 +172,9 @@ export function normalizePillConfig(value: unknown): PillConfig {
 		separator: parseSeparator(value.separator),
 		bold: typeof value.bold === "boolean" ? value.bold : DEFAULT_PILL_CONFIG.bold,
 		caps: parseCaps(value.caps),
+		bubbleAnimation:
+			typeof value.bubbleAnimation === "boolean"
+				? value.bubbleAnimation
+				: DEFAULT_PILL_CONFIG.bubbleAnimation,
 	};
 }

package/extensions/starline/pill.ts

@@ -43,6 +43,42 @@ const CAP_GLYPHS = { left: "", right: "" };
 /** Divider used where a solid arrow would be invisible. */
 const THIN_SEPARATOR = SEPARATOR_GLYPHS["powerline-thin"];
 
+/**
+ * Where one pill ended up in a rendered bar, in visible columns.
+ *
+ * `startColumn` is inclusive, `endColumn` exclusive. Columns count what the
+ * terminal draws, so a CJK pill spans two cells per character and a pill that
+ * `width` cut in half still reports the cells it kept.
+ *
+ * A span covers everything the pill visually owns: its own padding, the
+ * separator that points out of it, and — on the two ends of the bar — the cap.
+ * That leaves no dead cells between two pills for a click to fall into.
+ */
+export type PillSpan = {
+	/** `PillInput.key` of the segment this span belongs to. */
+	key: string;
+	startColumn: number;
+	endColumn: number;
+	/**
+	 * First column painted solid in the pill's colour. The hit area starts earlier
+	 * on the first pill, whose round cap is the colour drawn on the terminal's own
+	 * background; anything that has to line up with the pill's edge uses this.
+	 */
+	bodyStartColumn: number;
+	/** First column after the pill's own colour: where its arrow or cap starts. */
+	bodyEndColumn: number;
+	/** Background SGR the pill was painted with, for anything that has to match it. */
+	bg: string;
+	/** Foreground SGR, or "" when the text carried its own styling. */
+	fg: string;
+};
+
+export type PillRenderOptions = {
+	ascii?: boolean;
+	/** Called once per pill that survived truncation, in left-to-right order. */
+	onSpan?: (span: PillSpan) => void;
+};
+
 export type PillInput = {
 	/** Segment name, for diagnostics. */
 	key: string;
@@ -123,6 +159,7 @@ export function collectPillInputs(
 }
 
 type PreparedPill = {
+	key: string;
 	text: string;
 	bg: string;
 	fg: string;
@@ -213,7 +250,7 @@ function prepare(
 		if (!text || visibleWidth(text) === 0) continue;
 
 		if (input.keepStyling) {
-			pills.push({ text, bg: neutral, fg: "", bold: false });
+			pills.push({ key: input.key, text, bg: neutral, fg: "", bold: false });
 			continue;
 		}
 
@@ -221,6 +258,7 @@ function prepare(
 		const bg = resolved.bg ?? resolveBackgroundSgr(theme, source, input.spec) ?? neutral;
 		// An explicit fg: in the spec wins; otherwise pick for legibility.
 		pills.push({
+			key: input.key,
 			text,
 			bg,
 			fg: resolved.bg && resolved.fg ? resolved.fg : contrastTextSgr(bg),
@@ -234,6 +272,11 @@ function prepare(
 /**
  * Render the pill bar. Returns "" when nothing has content, so the caller can
  * fall back rather than emit a lone pair of caps.
+ *
+ * `options.onSpan` receives the hit area of every pill the terminal will
+ * actually show, measured in the bar's own visible columns. Recording the spans
+ * here rather than recomputing them later keeps them in step with the render:
+ * colour, caps, separators and truncation are all already accounted for.
  */
 export function renderPillBar(
 	inputs: PillInput[],
@@ -241,7 +284,7 @@ export function renderPillBar(
 	source: ColorSource,
 	config: PillConfig,
 	width: number,
-	options: { ascii?: boolean } = {},
+	options: PillRenderOptions = {},
 ): string {
 	const pills = prepare(inputs, theme, source, config);
 	if (pills.length === 0) return "";
@@ -255,41 +298,80 @@ export function renderPillBar(
 	const rightCap = wantsCaps ? CAP_GLYPHS.right : "";
 
 	let out = "";
+	// Columns the terminal will draw so far. Getting this from `visibleWidth`
+	// rather than string length is what makes CJK segment text hit the right cells.
+	let column = 0;
+	const emit = (piece: string) => {
+		out += piece;
+		column += visibleWidth(piece);
+	};
 
+	const capStart = column;
 	const firstBg = pills[0]?.bg;
 	if (leftCap && firstBg) {
 		const capFg = toForegroundSgr(firstBg);
-		if (capFg) out += `${DEFAULT_BG}${capFg}${leftCap}${RESET}`;
+		if (capFg) emit(`${DEFAULT_BG}${capFg}${leftCap}${RESET}`);
 	}
 
+	const spans: PillSpan[] = [];
+
 	pills.forEach((pill, index) => {
-		out += `${pill.bg}${pill.fg}${pill.bold ? BOLD : ""} ${pill.text} ${RESET}`;
+		// The left cap opens the bar in the first pill's colour, so it belongs to it.
+		const startColumn = index === 0 ? capStart : column;
+		const bodyStartColumn = column;
+		emit(`${pill.bg}${pill.fg}${pill.bold ? BOLD : ""} ${pill.text} ${RESET}`);
+		const bodyEndColumn = column;
 
 		const next = pills[index + 1];
 		if (next) {
-			if (!separator) return;
-
 			// A solid arrow works by being the left colour on the right colour, so
 			// it vanishes when the two pills share a background — several segments
 			// default to the same theme colour, which merged them into one blob.
 			// Fall back to the thin divider in the text colour, which stays visible.
-			if (pill.bg === next.bg) {
-				out += `${pill.bg}${pill.fg || contrastTextSgr(pill.bg)}${THIN_SEPARATOR}${RESET}`;
-				return;
+			if (separator && pill.bg === next.bg) {
+				emit(`${pill.bg}${pill.fg || contrastTextSgr(pill.bg)}${THIN_SEPARATOR}${RESET}`);
+			} else if (separator) {
+				const arrowFg = toForegroundSgr(pill.bg);
+				// Without a usable foreground the arrow would be invisible; letting the
+				// backgrounds abut is better than drawing a glyph in the wrong colour.
+				if (arrowFg) emit(`${next.bg}${arrowFg}${separator}${RESET}`);
 			}
-
-			const arrowFg = toForegroundSgr(pill.bg);
-			// Without a usable foreground the arrow would be invisible; letting the
-			// backgrounds abut is better than drawing a glyph in the wrong colour.
-			out += arrowFg ? `${next.bg}${arrowFg}${separator}${RESET}` : "";
-			return;
-		}
-
-		if (rightCap) {
+		} else if (rightCap) {
 			const capFg = toForegroundSgr(pill.bg);
-			if (capFg) out += `${DEFAULT_BG}${capFg}${rightCap}${RESET}`;
+			if (capFg) emit(`${DEFAULT_BG}${capFg}${rightCap}${RESET}`);
 		}
+
+		// The arrow (or cap) is emitted before the span closes, so it belongs to
+		// the pill that points out of itself.
+		spans.push({
+			key: pill.key,
+			startColumn,
+			endColumn: column,
+			bodyStartColumn,
+			bodyEndColumn,
+			bg: pill.bg,
+			fg: pill.fg,
+		});
 	});
 
-	return width > 0 ? truncateToWidth(out, width, "") : out;
+	const rendered = width > 0 ? truncateToWidth(out, width, "") : out;
+	if (options.onSpan) {
+		// Truncation keeps a prefix, so surviving cells keep their columns; only
+		// the far end needs clamping, and a pill clipped away entirely vanishes.
+		const visible = visibleWidth(rendered);
+		for (const span of spans) {
+			const startColumn = Math.min(span.startColumn, visible);
+			const endColumn = Math.min(span.endColumn, visible);
+			if (endColumn > startColumn) {
+				const bodyStartColumn = Math.min(span.bodyStartColumn, endColumn - 1);
+				const bodyEndColumn = Math.max(
+					bodyStartColumn + 1,
+					Math.min(span.bodyEndColumn, endColumn),
+				);
+				options.onSpan({ ...span, startColumn, endColumn, bodyStartColumn, bodyEndColumn });
+			}
+		}
+	}
+
+	return rendered;
 }

package/extensions/starline/project-probe.ts

@@ -0,0 +1,79 @@
+/**
+ * One project refresh's reads: git, the runtime in this directory, and the
+ * project's own version.
+ *
+ * Kept out of the extension entry so a test can hand it fake readers and see
+ * which of them a given bar actually asks for — the question "does a bar with
+ * no git pill still run `git status`?" is not answerable from a closure.
+ *
+ * The readers are injected rather than imported at the call site for exactly
+ * that reason; production passes the real ones.
+ */
+
+import type { PolishedTuiConfig } from "./config";
+import {
+	emptyGitStatus,
+	type GitHost,
+	type GitReadResult,
+	readGitHost,
+	readGitStatus,
+} from "./git";
+import { gitProbeOptions } from "./git-probe";
+import { type PackageVersionReadResult, readPackageVersionResult } from "./package-version";
+import { type RuntimeReadResult, readRuntimeInfo } from "./runtime";
+
+export type ProjectProbe = {
+	git: GitReadResult;
+	/** Undefined when the bar does not ask for a forge icon: keep the last one. */
+	gitHost: GitHost | undefined;
+	runtime: RuntimeReadResult;
+	/** Undefined when the bar does not show the project version. */
+	packageVersion: PackageVersionReadResult | undefined;
+};
+
+export type ProjectProbeReaders = {
+	readGitStatus: typeof readGitStatus;
+	readGitHost: typeof readGitHost;
+	readRuntimeInfo: typeof readRuntimeInfo;
+	readPackageVersion: typeof readPackageVersionResult;
+};
+
+const REAL_READERS: ProjectProbeReaders = {
+	readGitStatus,
+	readGitHost,
+	readRuntimeInfo,
+	readPackageVersion: readPackageVersionResult,
+};
+
+/**
+ * Read what the bar is about to draw, in parallel.
+ *
+ * A bar with no git pill gets an empty status instead of a read, which also
+ * clears the branch and dirty markers the previous bar left in state — the
+ * object is reused across refreshes, so skipping the read must not mean keeping
+ * yesterday's branch.
+ */
+export async function probeProject(
+	cwd: string,
+	config: PolishedTuiConfig,
+	readers: ProjectProbeReaders = REAL_READERS,
+): Promise<ProjectProbe> {
+	const probe = gitProbeOptions(config.pill.segments, {
+		showTag: config.git.commit.showTag,
+		hostIcon: config.git.hostIcon,
+	});
+	const wantPackage = config.pill.segments.includes("packageVersion");
+	const [git, runtime, packageVersion, gitHost] = await Promise.all([
+		probe.enabled
+			? readers.readGitStatus(cwd, {
+					readExactTag: probe.readExactTag,
+					readMetrics: probe.readMetrics,
+					ignoreSubmodules: config.git.metrics.ignoreSubmodules,
+				})
+			: Promise.resolve<GitReadResult>({ kind: "ok", status: emptyGitStatus() }),
+		readers.readRuntimeInfo(cwd),
+		wantPackage ? readers.readPackageVersion(cwd) : Promise.resolve(undefined),
+		probe.readHost ? readers.readGitHost(cwd) : Promise.resolve(undefined),
+	]);
+	return { git, gitHost, runtime, packageVersion };
+}

package/extensions/starline/prototype-patch-registry.ts

@@ -21,7 +21,12 @@ const LEGACY_PROTOTYPE_PATCH_REGISTRY = Symbol.for("pi-zentui.prototype-patch-re
 type PrototypePatchAdapter =
 	| "user-message-render"
 	| "user-message-invalidate"
-	| "selector-border-render";
+	| "selector-border-render"
+	| "selection-marker-dedupe"
+	| "agent-session-capture-prompt"
+	| "agent-session-capture-usage"
+	| "pending-messages-hide"
+	| "mouse-pointer-shape";
 
 type PrototypeMethodName = string;
 

package/extensions/starline/queue-rows.ts

@@ -0,0 +1,43 @@
+/**
+ * Hides Pi's own queued-message rows above the editor while the queue pill is
+ * showing the same thing.
+ *
+ * Pi draws `Steering: …` / `Follow-up: …` plus a dequeue hint in
+ * `pendingMessagesContainer`, rebuilt by `InteractiveMode.updatePendingMessagesDisplay`.
+ * There is no switch for it, so the method is wrapped: when the queue pill is on,
+ * the container is cleared instead of refilled, which leaves the layout row empty
+ * rather than collapsing the layout from outside.
+ *
+ * Deliberately tied to the pill rather than a config key: the rows only disappear
+ * when something else is already carrying that information. Remove `queue` from
+ * `pill.segments` (or turn the status line off) and the rows come back on the next
+ * queue update, with no restart.
+ */
+
+import { InteractiveMode } from "@earendil-works/pi-coding-agent";
+import { installPrototypePatch } from "./prototype-patch-registry";
+
+type PendingMessagesHost = {
+	pendingMessagesContainer?: { clear?: () => void };
+};
+
+/**
+ * Wrap the rebuild so it can be skipped. `isEnabled` is read on every queue
+ * update, so a `/starline` change applies immediately.
+ */
+export function installNativeQueueRowHiding(isEnabled: () => boolean): () => void {
+	try {
+		return installPrototypePatch(
+			InteractiveMode.prototype,
+			"updatePendingMessagesDisplay",
+			"pending-messages-hide",
+			({ predecessor, receiver, args }) => {
+				if (!isEnabled()) return Function.prototype.apply.call(predecessor, receiver, args);
+				(receiver as PendingMessagesHost).pendingMessagesContainer?.clear?.();
+				return undefined;
+			},
+		);
+	} catch {
+		return () => {};
+	}
+}