gentle-pi 2.4.0 → 2.5.0

package/lib/review-session-standing-permission.ts

@@ -0,0 +1,219 @@
+import { execFile, execFileSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { realpath } from "node:fs/promises";
+import { realpathSync } from "node:fs";
+import { isAbsolute, resolve } from "node:path";
+import { promisify } from "node:util";
+
+export const REVIEW_SESSION_PERMISSION_REGISTRY_SCHEMA = "gentle-pi.review-session-standing-permission/v1";
+export const REVIEW_SESSION_PERMISSION_REGISTRY_SYMBOL = Symbol.for(REVIEW_SESSION_PERMISSION_REGISTRY_SCHEMA);
+
+const execFileAsync = promisify(execFile);
+
+export interface ReviewSessionManager {
+	getSessionId(): unknown;
+}
+
+export interface ReviewSessionContext {
+	cwd: string;
+	mode?: string;
+	hasUI: boolean;
+	ui?: { getAllThemes?: () => readonly unknown[] };
+	sessionManager: ReviewSessionManager;
+}
+
+export interface ReviewSessionIdentity {
+	readonly sessionManager: ReviewSessionManager;
+	readonly sessionId: string;
+	readonly worktreeRoot: string;
+	// A SHA-256 digest of the canonical Git common directory. It is stable for
+	// sibling worktrees of one clone without serializing a filesystem path.
+	readonly repositoryIdentity: string;
+}
+
+interface ReviewSessionPermissionRegistry {
+	readonly schema: typeof REVIEW_SESSION_PERMISSION_REGISTRY_SCHEMA;
+	readonly permissions: WeakMap<object, Map<string, Set<string>>>;
+	readonly revocationEpochs: WeakMap<object, Map<string, number>>;
+}
+
+type GlobalRegistry = Record<symbol, unknown>;
+
+function registry(): ReviewSessionPermissionRegistry | undefined {
+	const globalRegistry = globalThis as GlobalRegistry;
+	const current = globalRegistry[REVIEW_SESSION_PERMISSION_REGISTRY_SYMBOL];
+	if (current === undefined) {
+		const created: ReviewSessionPermissionRegistry = {
+			schema: REVIEW_SESSION_PERMISSION_REGISTRY_SCHEMA,
+			permissions: new WeakMap(),
+			revocationEpochs: new WeakMap(),
+		};
+		globalRegistry[REVIEW_SESSION_PERMISSION_REGISTRY_SYMBOL] = created;
+		return created;
+	}
+	if (
+		typeof current !== "object" ||
+		current === null ||
+		(current as { schema?: unknown }).schema !== REVIEW_SESSION_PERMISSION_REGISTRY_SCHEMA ||
+		!((current as { permissions?: unknown }).permissions instanceof WeakMap) ||
+		!((current as { revocationEpochs?: unknown }).revocationEpochs instanceof WeakMap)
+	) return undefined;
+	return current as ReviewSessionPermissionRegistry;
+}
+
+function exactSessionId(sessionManager: ReviewSessionManager): string | undefined {
+	try {
+		const value = sessionManager.getSessionId();
+		return typeof value === "string" && value.length > 0 ? value : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+function canonicalRepositoryIdentity(commonDir: string): string {
+	return `sha256:${createHash("sha256").update(commonDir).digest("hex")}`;
+}
+
+function validAbsoluteGitPath(value: string): boolean {
+	return isAbsolute(value) && value.length > 0 && !value.includes("\n") && !value.includes("\r");
+}
+
+export async function resolveCanonicalGitWorktreeRoot(cwd: string): Promise<string | undefined> {
+	try {
+		const result = await execFileAsync("git", ["-C", cwd, "rev-parse", "--show-toplevel"], {
+			encoding: "utf8",
+			timeout: 5_000,
+			maxBuffer: 64 * 1024,
+		});
+		const output = result.stdout.trim();
+		if (!validAbsoluteGitPath(output)) return undefined;
+		return await realpath(output);
+	} catch {
+		return undefined;
+	}
+}
+
+/** Resolves a non-secret, clone-stable identity from Git's canonical common dir. */
+export async function resolveCanonicalGitRepositoryIdentity(cwd: string): Promise<string | undefined> {
+	try {
+		const result = await execFileAsync("git", ["-C", cwd, "rev-parse", "--git-common-dir"], {
+			encoding: "utf8",
+			timeout: 5_000,
+			maxBuffer: 64 * 1024,
+		});
+		const output = result.stdout.trim();
+		if (output.length === 0 || output.includes("\n") || output.includes("\r")) return undefined;
+		return canonicalRepositoryIdentity(await realpath(resolve(cwd, output)));
+	} catch {
+		return undefined;
+	}
+}
+
+/** The parent AgentRunner binds a child task to this same digest at spawn time. */
+export function resolveCanonicalGitRepositoryIdentitySync(cwd: string): string | undefined {
+	try {
+		const output = execFileSync("git", ["-C", cwd, "rev-parse", "--git-common-dir"], { encoding: "utf8", timeout: 5_000, maxBuffer: 64 * 1024 }).trim();
+		if (output.length === 0 || output.includes("\n") || output.includes("\r")) return undefined;
+		return canonicalRepositoryIdentity(realpathSync(resolve(cwd, output)));
+	} catch {
+		return undefined;
+	}
+}
+
+function hasInteractiveTui(context: ReviewSessionContext): boolean {
+	if (context.mode !== undefined) return context.mode === "tui";
+	try {
+		// Pi 0.85 exposes ctx.mode in the documented SDK surface, while its
+		// compatibility runner omits that property. In the latter, the real TUI
+		// has themes and RPC's deliberately unsupported TUI surface returns none.
+		return (context.ui?.getAllThemes?.().length ?? 0) > 0;
+	} catch {
+		return false;
+	}
+}
+
+export async function captureReviewSessionIdentity(
+	context: ReviewSessionContext,
+	processEnv: NodeJS.ProcessEnv = process.env,
+	resolveRoot: (cwd: string) => Promise<string | undefined> = resolveCanonicalGitWorktreeRoot,
+	resolveRepositoryIdentity: (cwd: string) => Promise<string | undefined> = resolveCanonicalGitRepositoryIdentity,
+): Promise<ReviewSessionIdentity | undefined> {
+	if (processEnv.GENTLE_PI_AGENTS_CHILD === "1" || context.hasUI !== true || !hasInteractiveTui(context)) return undefined;
+	const sessionManager = context.sessionManager;
+	if (typeof sessionManager !== "object" || sessionManager === null) return undefined;
+	const sessionId = exactSessionId(sessionManager);
+	if (sessionId === undefined) return undefined;
+	const [worktreeRoot, repositoryIdentity] = await Promise.all([resolveRoot(context.cwd), resolveRepositoryIdentity(context.cwd)]);
+	if (worktreeRoot === undefined || repositoryIdentity === undefined) return undefined;
+	return { sessionManager, sessionId, worktreeRoot, repositoryIdentity };
+}
+
+export function sameReviewSessionIdentity(left: ReviewSessionIdentity, right: ReviewSessionIdentity): boolean {
+	return left.sessionManager === right.sessionManager && left.sessionId === right.sessionId && left.repositoryIdentity === right.repositoryIdentity;
+}
+
+function epochFor(state: ReviewSessionPermissionRegistry, sessionManager: object, sessionId: string): number {
+	return state.revocationEpochs.get(sessionManager)?.get(sessionId) ?? 0;
+}
+
+function advanceEpoch(state: ReviewSessionPermissionRegistry, sessionManager: object, sessionId: string): void {
+	let sessions = state.revocationEpochs.get(sessionManager);
+	if (sessions === undefined) {
+		sessions = new Map();
+		state.revocationEpochs.set(sessionManager, sessions);
+	}
+	sessions.set(sessionId, epochFor(state, sessionManager, sessionId) + 1);
+}
+
+export function reviewSessionPermissionEpoch(identity: ReviewSessionIdentity): number | undefined {
+	const state = registry();
+	return state === undefined ? undefined : epochFor(state, identity.sessionManager, identity.sessionId);
+}
+
+export function grantReviewSessionPermission(identity: ReviewSessionIdentity, expectedEpoch?: number): boolean {
+	const state = registry();
+	if (state === undefined || (expectedEpoch !== undefined && epochFor(state, identity.sessionManager, identity.sessionId) !== expectedEpoch)) return false;
+	let sessions = state.permissions.get(identity.sessionManager);
+	if (sessions === undefined) {
+		sessions = new Map();
+		state.permissions.set(identity.sessionManager, sessions);
+	}
+	let roots = sessions.get(identity.sessionId);
+	if (roots === undefined) {
+		roots = new Set();
+		sessions.set(identity.sessionId, roots);
+	}
+	roots.add(identity.repositoryIdentity);
+	return true;
+}
+
+// A grant belongs to one live session and one Git clone. It follows sibling
+// worktrees through their common directory, never an unrelated repository.
+export function hasReviewSessionPermission(identity: ReviewSessionIdentity): boolean {
+	return registry()?.permissions.get(identity.sessionManager)?.get(identity.sessionId)?.has(identity.repositoryIdentity) === true;
+}
+
+export function revokeReviewSessionPermission(identity: ReviewSessionIdentity): boolean {
+	const state = registry();
+	if (state === undefined) return false;
+	advanceEpoch(state, identity.sessionManager, identity.sessionId);
+	const sessions = state.permissions.get(identity.sessionManager);
+	const roots = sessions?.get(identity.sessionId);
+	if (sessions === undefined || roots === undefined) return false;
+	const removed = roots.delete(identity.repositoryIdentity);
+	if (roots.size === 0) sessions.delete(identity.sessionId);
+	if (sessions.size === 0) state.permissions.delete(identity.sessionManager);
+	return removed;
+}
+
+export function revokeReviewSessionPermissionsForSession(sessionManager: object, sessionId: string): boolean {
+	if (sessionId.length === 0) return false;
+	const state = registry();
+	if (state === undefined) return false;
+	advanceEpoch(state, sessionManager, sessionId);
+	const sessions = state.permissions.get(sessionManager);
+	if (sessions === undefined) return false;
+	const removed = sessions.delete(sessionId);
+	if (sessions.size === 0) state.permissions.delete(sessionManager);
+	return removed;
+}

package/lib/shell-bar.ts

@@ -0,0 +1,138 @@
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import { GAUGE_CELLS, gaugeTone, paintGauge, renderGauge, type GaugeTone } from "./shell-gauge.ts";
+import { renderUsageBar, type ProviderUsage } from "./shell-usage.ts";
+import { sanitizeTerminalText } from "./terminal-theme.ts";
+
+export { gaugeTone, renderGauge, type GaugeTone };
+
+// Gentle Shell status bar: one line of segments that replaces pi's built-in
+// three-line footer. Everything here is pure so the bar can be rendered and
+// verified without a live TUI.
+
+export interface ShellBarModel {
+	cwd: string;
+	branch: string | null;
+	dirty: number | undefined;
+	sessionName: string | undefined;
+	modelId: string;
+	effort: string | undefined;
+	contextPercent: number | null;
+	contextWindow: number;
+	costTotal: number;
+	subscription: boolean;
+	usage: ProviderUsage | undefined;
+	statuses: string[];
+}
+
+export interface ShellBarTheme {
+	fg(color: string, text: string): string;
+	bold(text: string): string;
+}
+
+// Theme roles the bar paints with. Keys are pi theme colors; the Gentle themes
+// map them to the rose palette (accent = rose, syntaxFunction = powder blue).
+const ROLE = {
+	BRAND: "accent",
+	SEPARATOR: "dim",
+	PATH: "muted",
+	BRANCH: "text",
+	DIRTY: "warning",
+	MODEL: "text",
+	EFFORT: "syntaxFunction",
+	LABEL: "muted",
+	VALUE: "text",
+	STATUS: "muted",
+	SESSION: "dim",
+} as const;
+
+export const SHELL_BAR_BRAND = "✿ gentle-pi";
+export const SHELL_BAR_SEPARATOR = "⟡";
+export const SHELL_BAR_GAUGE_CELLS = GAUGE_CELLS;
+const RIGHT_PADDING = 2;
+const COMPACT_BRANCH_WIDTH = 15;
+
+export function shellEnabled(env: NodeJS.ProcessEnv = process.env): boolean {
+	if (env.GENTLE_PI_AGENTS_CHILD === "1") return false;
+	const value = env.GENTLE_PI_SHELL?.trim().toLowerCase();
+	return !(value === "0" || value === "false" || value === "off");
+}
+
+export function formatTokens(count: number): string {
+	if (count < 1000) return count.toString();
+	if (count < 10_000) return `${(count / 1000).toFixed(1)}k`;
+	if (count < 1_000_000) return `${Math.round(count / 1000)}k`;
+	if (count < 10_000_000) return `${(count / 1_000_000).toFixed(1)}M`;
+	return `${Math.round(count / 1_000_000)}M`;
+}
+
+export function formatCost(total: number, subscription: boolean): string {
+	const amount = total >= 1 ? total.toFixed(2) : total.toFixed(3);
+	return subscription ? `$${amount} sub` : `$${amount}`;
+}
+
+// Extensions may paint their status themselves (pi-mcp-adapter does); the bar
+// owns the palette, so their escapes go and the text takes the status role.
+function sanitizeStatus(text: string): string {
+	return sanitizeTerminalText(text.replace(/[\r\n\t]/g, " ")).replace(/ +/g, " ").trim();
+}
+
+function buildSegments(model: ShellBarModel, theme: ShellBarTheme): string[] {
+	const dirty = model.dirty ? ` ${theme.fg(ROLE.DIRTY, `±${model.dirty}`)}` : "";
+	const location = model.branch
+		? `${theme.fg(ROLE.PATH, model.cwd)} ${theme.fg(ROLE.BRANCH, model.branch)}${dirty}`
+		: theme.fg(ROLE.PATH, model.cwd) + dirty;
+	const modelSegment = model.effort
+		? `${theme.fg(ROLE.MODEL, model.modelId)} ${theme.fg(ROLE.LABEL, "·")} ${theme.fg(ROLE.EFFORT, model.effort)}`
+		: theme.fg(ROLE.MODEL, model.modelId);
+	const percentText = model.contextPercent === null ? "?%" : `${Math.round(model.contextPercent)}%`;
+	const context = `${theme.fg(ROLE.LABEL, "ctx")} ${paintGauge(model.contextPercent, theme)} ${theme.fg(ROLE.VALUE, percentText)}`;
+	const cost = theme.fg(ROLE.VALUE, formatCost(model.costTotal, model.subscription));
+	const usage = model.usage ? renderUsageBar(model.usage, theme) : undefined;
+	const statuses = model.statuses.map((status) => theme.fg(ROLE.STATUS, sanitizeStatus(status)));
+	return [theme.fg(ROLE.BRAND, SHELL_BAR_BRAND), location, modelSegment, context, cost, ...(usage ? [usage] : []), ...statuses];
+}
+
+// When the line overflows, the location gives way first: the path shrinks to
+// its last segment and a long branch is clipped, so the trailing statuses
+// (MCP servers, extension notices) survive on ordinary terminal widths.
+function compactModel(model: ShellBarModel): ShellBarModel {
+	const cwd = model.cwd.split("/").filter((part) => part.length > 0).pop() ?? model.cwd;
+	const branch = model.branch && visibleWidth(model.branch) > COMPACT_BRANCH_WIDTH ? clipText(model.branch, COMPACT_BRANCH_WIDTH) : model.branch;
+	return { ...model, cwd, branch };
+}
+
+// Plain clip: pi's truncateToWidth wraps the result in resets, which would end
+// up inside a painted segment.
+function clipText(text: string, max: number): string {
+	let clipped = "";
+	for (const char of text) {
+		if (visibleWidth(clipped + char) > max - 1) break;
+		clipped += char;
+	}
+	return `${clipped}…`;
+}
+
+function joinSegments(segments: string[], theme: ShellBarTheme): string {
+	return segments.join(` ${theme.fg(ROLE.SEPARATOR, SHELL_BAR_SEPARATOR)} `);
+}
+
+export function renderShellBar(model: ShellBarModel, theme: ShellBarTheme, width: number): string[] {
+	let segments = buildSegments(model, theme);
+	const right = model.sessionName ? theme.fg(ROLE.SESSION, model.sessionName) : undefined;
+
+	let left = joinSegments(segments, theme);
+	if (right && visibleWidth(left) + RIGHT_PADDING + visibleWidth(right) <= width) {
+		const padding = " ".repeat(width - visibleWidth(left) - visibleWidth(right));
+		return [left + padding + right];
+	}
+
+	if (visibleWidth(left) > width) {
+		segments = buildSegments(compactModel(model), theme);
+		left = joinSegments(segments, theme);
+	}
+	while (segments.length > 1 && visibleWidth(left) > width) {
+		segments.pop();
+		left = joinSegments(segments, theme);
+	}
+	return [truncateToWidth(left, width, "…")];
+}

package/lib/shell-card.ts

@@ -0,0 +1,136 @@
+import { truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
+
+// Gentle Shell cards: the shape every Gentle notice takes in the transcript
+// and above the editor. The same rounded frame as the prompt and the
+// overlays, with the title in the card's tone. Pure: strings in, lines out.
+
+export const CARD_TONE = {
+	INFO: "info",
+	SUCCESS: "success",
+	WARNING: "warning",
+	ERROR: "error",
+} as const;
+
+export type CardTone = (typeof CARD_TONE)[keyof typeof CARD_TONE];
+
+export interface Card {
+	title: string;
+	subtitle?: string;
+	body: string[];
+	tone: CardTone;
+	glyph?: string;
+}
+
+export interface CardTheme {
+	fg(color: string, text: string): string;
+}
+
+export interface CardRenderOptions {
+	expanded: boolean;
+	/** Right-aligned hint in the top rule, e.g. the expand key. May carry ANSI. */
+	hint?: string;
+	/** Paints a finished line, e.g. with the panel background. */
+	paint?: (line: string) => string;
+}
+
+export const CARD_GLYPH = "✿";
+const TONE_ROLE: Record<CardTone, string> = {
+	[CARD_TONE.INFO]: "customMessageLabel",
+	[CARD_TONE.SUCCESS]: "success",
+	[CARD_TONE.WARNING]: "warning",
+	[CARD_TONE.ERROR]: "error",
+};
+const HINT_ROLE = "dim";
+const SUBTITLE_ROLE = "muted";
+const BODY_ROLE = "text";
+const SEPARATOR = "·";
+const FRAME_COLUMNS = 4;
+
+function rule(length: number): string {
+	return "─".repeat(Math.max(0, length));
+}
+
+function titleText(card: Card, theme: CardTheme): { styled: string; width: number } {
+	const head = `${card.glyph ?? CARD_GLYPH} ${card.title}`;
+	const styled = card.subtitle
+		? `${theme.fg(TONE_ROLE[card.tone], head)} ${theme.fg(SUBTITLE_ROLE, SEPARATOR)} ${theme.fg(SUBTITLE_ROLE, card.subtitle)}`
+		: theme.fg(TONE_ROLE[card.tone], head);
+	return { styled, width: visibleWidth(head) + (card.subtitle ? visibleWidth(card.subtitle) + 3 : 0) };
+}
+
+function bodyLines(card: Card, innerWidth: number): string[] {
+	return card.body.flatMap((paragraph) => (paragraph === "" ? [""] : wrapTextWithAnsi(paragraph, innerWidth)));
+}
+
+// The left rail, corners included, carries the tone at full strength; the
+// rest of the frame stays in the theme's border color, so the state reads from the rail.
+const FRAME_ROLE = "border";
+
+function soft(theme: CardTheme, _tone: CardTone, text: string): string {
+	return theme.fg(FRAME_ROLE, text);
+}
+
+export function cardTop(card: Card, theme: CardTheme, width: number, hint?: string): string {
+	const targetWidth = Math.max(0, Math.floor(width));
+	if (targetWidth === 0) return "";
+	if (targetWidth < 5) {
+		const left = theme.fg(TONE_ROLE[card.tone], "╭");
+		if (targetWidth === 1) return left;
+		return left + soft(theme, card.tone, `${rule(targetWidth - 2)}╮`);
+	}
+
+	const title = titleText(card, theme);
+	const fullHintWidth = hint ? visibleWidth(hint) + 2 : 0;
+	const shownHint = hint && title.width + 5 + fullHintWidth <= targetWidth ? hint : undefined;
+	const hintWidth = shownHint ? fullHintWidth : 0;
+	const titleWidth = Math.max(0, targetWidth - 5 - hintWidth);
+	const styledTitle = title.width <= titleWidth ? title.styled : truncateToWidth(title.styled, titleWidth, "");
+	const styledTitleWidth = title.width <= titleWidth ? title.width : visibleWidth(styledTitle);
+	const fill = rule(targetWidth - styledTitleWidth - 5 - hintWidth);
+	const tail = shownHint ? ` ${theme.fg(HINT_ROLE, shownHint)} ` : "";
+	return theme.fg(TONE_ROLE[card.tone], "╭") + soft(theme, card.tone, "─ ") + styledTitle + soft(theme, card.tone, ` ${fill}`) + tail + soft(theme, card.tone, "╮");
+}
+
+export function cardLine(text: string, tone: CardTone, theme: CardTheme, width: number): string {
+	const targetWidth = Math.max(0, Math.floor(width));
+	if (targetWidth === 0) return "";
+	const left = theme.fg(TONE_ROLE[tone], "│");
+	if (targetWidth === 1) return left;
+	if (targetWidth === 2) return left + soft(theme, tone, "│");
+	if (targetWidth === 3) return `${left} ${soft(theme, tone, "│")}`;
+
+	const innerWidth = targetWidth - FRAME_COLUMNS;
+	const clipped = innerWidth === 0 ? "" : truncateToWidth(text, innerWidth, "…");
+	const padding = " ".repeat(Math.max(0, innerWidth - visibleWidth(clipped)));
+	return `${left} ${clipped}${padding} ${soft(theme, tone, "│")}`;
+}
+
+export function cardBottom(tone: CardTone, theme: CardTheme, width: number): string {
+	const targetWidth = Math.max(0, Math.floor(width));
+	if (targetWidth === 0) return "";
+	const left = theme.fg(TONE_ROLE[tone], "╰");
+	if (targetWidth === 1) return left;
+	return left + soft(theme, tone, `${rule(targetWidth - 2)}╯`);
+}
+
+export function cardInnerWidth(width: number): number {
+	return Math.max(1, width - FRAME_COLUMNS);
+}
+
+export function renderCard(card: Card, theme: CardTheme, width: number, options: CardRenderOptions): string[] {
+	const innerWidth = Math.max(1, width - FRAME_COLUMNS);
+	const paint = options.paint ?? ((line: string) => line);
+	const top = cardTop(card, theme, width, options.hint);
+	const bottom = cardBottom(card.tone, theme, width);
+	const lines = bodyLines(card, innerWidth);
+	const body = (() => {
+		if (lines.length === 0) return [];
+		if (!options.expanded) {
+			const first = lines.find((line) => line !== "") ?? "";
+			const clipped = lines.length > 1 ? truncateToWidth(first, Math.max(1, innerWidth - 1), "") + "…" : first;
+			return [cardLine(theme.fg(BODY_ROLE, clipped), card.tone, theme, width)];
+		}
+		return lines.map((line) => cardLine(line === "" ? "" : theme.fg(BODY_ROLE, line), card.tone, theme, width));
+	})();
+	return [top, ...body, bottom].map(paint);
+}