@narumitw/pi-statusline 0.34.0 → 0.36.0

package/README.md

@@ -8,12 +8,12 @@ without setup and keeps useful context visible as the terminal narrows.
 A representative uncolored layout:
 
 ```text
-░▒▓ 🤖 sonnet-4 🧠 high 📁 pi-extensions 🌿 main ~2 🪟 ctx 42% 💸 $0.184
+░▒▓ 🤖 sonnet-4 🧠 high 📁 pi-extensions 🌿 main ~2 🪟 ctx 42% 🕒 16:42
 ```
 
 ## ✨ Features
 
-- **Zero-config default:** model, thinking, workspace, Git/PR state, context use, and cost.
+- **Zero-config default:** model, thinking, workspace, Git/PR state, context use, and local time.
 - **Responsive:** removes lower-priority segments before important information gets clipped.
 - **Quiet when idle:** activity appears only while Pi is streaming or running tools.
 - **Easy choices:** three information levels and seven previewable color presets.
@@ -73,7 +73,7 @@ preserved.
 | Level | Included segments |
 | --- | --- |
 | **Minimal** | `model cwd branch context` |
-| **Balanced** (default) | `model thinking cwd branch tools context cost` |
+| **Balanced** (default) | `model thinking cwd branch tools context time` |
 | **Detailed** | `provider model thinking cwd branch tools context tokens cost time` |
 | **Custom** | Any other segment order, including explicit line breaks |
 
@@ -125,12 +125,13 @@ The extension uses one user-level file:
 <getAgentDir()>/pi-statusline.json
 ```
 
-There are no project or environment overrides. On first session start, pi-statusline atomically
-creates a complete editable default. It never overwrites malformed or unreadable settings. Settings
-reload on startup, `/reload`, and session replacement.
+There are no project or environment overrides. When the file is absent, pi-statusline uses its
+built-in defaults without creating the file or parent directory. The first successful settings save
+creates a complete editable document atomically. Malformed or unreadable settings are never
+overwritten. Settings reload on startup, `/reload`, and session replacement.
 
-A valid legacy `pi-statusline-settings.json` is migrated without rewriting its contents. If both files
-exist, `pi-statusline.json` wins.
+A valid legacy `pi-statusline-settings.json` remains readable with a warning and is never modified
+automatically; rename it to `pi-statusline.json`. If both files exist, `pi-statusline.json` wins.
 
 ### Settings reference
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@narumitw/pi-statusline",
-	"version": "0.34.0",
+	"version": "0.36.0",
 	"description": "Pi extension that replaces the footer with an information-rich statusline.",
 	"type": "module",
 	"license": "MIT",

package/src/commands.ts

@@ -24,6 +24,7 @@ import { segmentPaletteForPreset } from "./presets/index.js";
 import {
 	DEFAULT_STATUSLINE_DOCUMENT,
 	type LoadedStatuslineSettings,
+	removeStatuslineSettingsDocumentIfMatches,
 	saveStatuslineSettingsDocument,
 } from "./settings.js";
 import {
@@ -193,21 +194,31 @@ async function choosePalettePreset(
 	}
 	if (selection === undefined) return;
 
+	let loaded: LoadedStatuslineSettings;
 	try {
 		const rawDocument = palettePresetDocument(current, selection);
-		const loaded = (options.save ?? saveStatuslineSettingsDocument)(
-			options.settingsPath,
-			rawDocument,
-		);
-		options.apply(loaded, ctx);
-		const message =
-			loaded.config.palettePreset === "custom"
-				? "Custom palette applied. Edit colors via /statusline → Advanced → Edit settings JSON."
-				: `Palette preset applied: ${loaded.config.palettePreset}.`;
-		ctx.ui.notify(message, "info");
+		loaded = (options.save ?? saveStatuslineSettingsDocument)(options.settingsPath, rawDocument);
 	} catch (error) {
 		ctx.ui.notify(`Palette preset was not saved: ${formatError(error)}`, "error");
+		return;
 	}
+	try {
+		options.apply(loaded, ctx);
+	} catch (error) {
+		const rollbackError = restoreStatuslineSettings(ctx, options, current, loaded);
+		ctx.ui.notify(
+			rollbackError
+				? `Palette preset could not be applied: ${formatError(error)}; rollback failed: ${formatError(rollbackError)}`
+				: `Palette preset could not be applied: ${formatError(error)}; previous settings restored.`,
+			"error",
+		);
+		return;
+	}
+	const message =
+		loaded.config.palettePreset === "custom"
+			? "Custom palette applied. Edit colors via /statusline → Advanced → Edit settings JSON."
+			: `Palette preset applied: ${loaded.config.palettePreset}.`;
+	ctx.ui.notify(message, "info");
 }
 
 async function showPalettePresetPicker(
@@ -587,17 +598,30 @@ async function editSettings(ctx: ExtensionCommandContext, options: StatuslineCom
 		current.rawDocument ?? DEFAULT_STATUSLINE_DOCUMENT,
 	);
 	if (edited === undefined) return;
+	let loaded: LoadedStatuslineSettings;
 	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");
+		loaded = (options.save ?? saveStatuslineSettingsDocument)(options.settingsPath, edited);
 	} catch (error) {
 		ctx.ui.notify(`pi-statusline settings were not saved: ${formatError(error)}`, "error");
+		return;
+	}
+	try {
+		options.apply(loaded, ctx);
+	} catch (error) {
+		const rollbackError = restoreStatuslineSettings(ctx, options, current, loaded);
+		ctx.ui.notify(
+			rollbackError
+				? `pi-statusline settings could not be applied: ${formatError(error)}; rollback failed: ${formatError(rollbackError)}`
+				: `pi-statusline settings could not be applied: ${formatError(error)}; previous settings restored.`,
+			"error",
+		);
+		return;
 	}
+	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");
 }
 
 function palettePresetDocument(
@@ -771,15 +795,14 @@ function applySegmentsDocumentChange(
 	ctx: ExtensionCommandContext,
 	options: StatuslineCommandOptions,
 ): LoadedStatuslineSettings {
+	const previous = options.getLoaded();
 	const save = options.save ?? saveStatuslineSettingsDocument;
 	const next = save(options.settingsPath, change.nextDocument);
 	try {
 		options.apply(next, ctx);
 	} catch (applyError) {
-		try {
-			const restored = save(options.settingsPath, change.previousDocument);
-			options.apply(restored, ctx);
-		} catch (rollbackError) {
+		const rollbackError = restoreStatuslineSettings(ctx, options, previous, next);
+		if (rollbackError) {
 			throw new Error(
 				`runtime update failed: ${formatError(applyError)}; rollback failed: ${formatError(rollbackError)}`,
 			);
@@ -789,6 +812,36 @@ function applySegmentsDocumentChange(
 	return next;
 }
 
+function restoreStatuslineSettings(
+	ctx: ExtensionCommandContext,
+	options: StatuslineCommandOptions,
+	previous: LoadedStatuslineSettings,
+	saved: LoadedStatuslineSettings,
+): unknown {
+	try {
+		if (saved.rawDocument === undefined || saved.fileIdentity === undefined) {
+			throw new Error("The saved settings document identity is unavailable");
+		}
+		removeStatuslineSettingsDocumentIfMatches(
+			options.settingsPath,
+			saved.rawDocument,
+			saved.fileIdentity,
+		);
+		if (previous.rawDocument === undefined || previous.settingsPath !== options.settingsPath) {
+			options.apply(previous, ctx);
+			return undefined;
+		}
+		const restored = (options.save ?? saveStatuslineSettingsDocument)(
+			options.settingsPath,
+			previous.rawDocument,
+		);
+		options.apply(restored, ctx);
+		return undefined;
+	} catch (error) {
+		return error;
+	}
+}
+
 function normalizeLineBreaks(segments: readonly ConfigSegmentName[]): ConfigSegmentName[] {
 	const normalized: ConfigSegmentName[] = [];
 	for (const segment of segments) {
@@ -808,14 +861,17 @@ function editableSettings(
 	current: LoadedStatuslineSettings,
 	action: string,
 ): { parsed: Record<string, unknown>; rawDocument: string } {
-	if (
-		current.source !== "user" ||
-		current.rawDocument === undefined ||
-		current.diagnostics.some((item) => item.code !== "unknown")
-	) {
+	const rawDocument =
+		current.source === "user" && current.rawDocument !== undefined
+			? current.rawDocument
+			: current.source === "built-in" &&
+					current.rawDocument === undefined &&
+					current.diagnostics.length === 0
+				? DEFAULT_STATUSLINE_DOCUMENT
+				: undefined;
+	if (rawDocument === undefined || current.diagnostics.some((item) => item.code !== "unknown")) {
 		throw new Error(`Fix pi-statusline.json before ${action}`);
 	}
-	const rawDocument = current.rawDocument;
 	const parsed = JSON.parse(rawDocument) as unknown;
 	if (!isRecord(parsed)) throw new Error("Settings must contain a JSON object");
 	return { parsed, rawDocument };
@@ -831,7 +887,8 @@ function showStatus(ctx: ExtensionCommandContext, options: StatuslineCommandOpti
 	ctx.ui.notify(
 		[
 			`pi-statusline source: ${loaded.source}`,
-			`path: ${options.settingsPath}`,
+			`active path: ${loaded.settingsPath}`,
+			`save target: ${options.settingsPath}`,
 			`palette preset: ${loaded.config.palettePreset}`,
 			`density: ${loaded.config.density}`,
 			`separator: ${loaded.config.separator}`,

package/src/information-profiles.ts

@@ -8,7 +8,7 @@ export const INFORMATION_PROFILES: Readonly<
 	Record<InformationProfileName, readonly SegmentName[]>
 > = {
 	minimal: ["model", "cwd", "branch", "context"],
-	balanced: ["model", "thinking", "cwd", "branch", "tools", "context", "cost"],
+	balanced: ["model", "thinking", "cwd", "branch", "tools", "context", "time"],
 	detailed: [
 		"provider",
 		"model",

package/src/settings.ts

@@ -1,13 +1,5 @@
 import { randomUUID } from "node:crypto";
-import {
-	linkSync,
-	lstatSync,
-	mkdirSync,
-	readFileSync,
-	renameSync,
-	rmSync,
-	writeFileSync,
-} from "node:fs";
+import { lstatSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { getAgentDir } from "@earendil-works/pi-coding-agent";
 import { INFORMATION_PROFILES } from "./information-profiles.js";
@@ -109,16 +101,10 @@ export interface LoadedStatuslineSettings {
 	source: "built-in" | "user";
 	settingsPath: string;
 	rawDocument?: string;
+	fileIdentity?: { dev: number; ino: number };
 	diagnostics: StatuslineConfigDiagnostic[];
 }
 
-interface InitialFileSystem {
-	mkdirSync: typeof mkdirSync;
-	writeFileSync: typeof writeFileSync;
-	linkSync: typeof linkSync;
-	rmSync: typeof rmSync;
-}
-
 interface AtomicFileSystem {
 	mkdirSync: typeof mkdirSync;
 	writeFileSync: typeof writeFileSync;
@@ -295,7 +281,7 @@ export function loadStatuslineSettings(settingsPath: string): LoadedStatuslineSe
 	try {
 		rawDocument = readFileSync(settingsPath, "utf8");
 	} catch (error) {
-		if (!pathExists(settingsPath)) {
+		if ((error as NodeJS.ErrnoException).code === "ENOENT" && !pathExists(settingsPath)) {
 			return builtInSettings(settingsPath);
 		}
 		return builtInSettings(settingsPath, [
@@ -324,56 +310,32 @@ export function loadStatuslineSettings(settingsPath: string): LoadedStatuslineSe
 	};
 }
 
-export function loadOrCreateStatuslineSettings(
-	agentDir = getAgentDir(),
-	overrides: Partial<InitialFileSystem> = {},
-): LoadedStatuslineSettings {
+export function loadStatuslineSettingsForAgent(agentDir = getAgentDir()): LoadedStatuslineSettings {
 	pendingSettingsNotice = undefined;
 	const canonicalPath = settingsFilePath(agentDir);
 	const legacyPath = join(agentDir, LEGACY_SETTINGS_FILE_NAME);
-	if (pathExists(canonicalPath)) {
-		if (pathExists(legacyPath)) {
+	const canonical = loadStatuslineSettings(canonicalPath);
+	if (!isMissingStatuslineSettings(canonical)) {
+		if (!isMissingStatuslineSettings(loadStatuslineSettings(legacyPath))) {
 			pendingSettingsNotice = `${LEGACY_SETTINGS_FILE_NAME} ignored because ${SETTINGS_FILE_NAME} takes precedence.`;
 		}
-		return loadStatuslineSettings(canonicalPath);
-	}
-	if (pathExists(legacyPath)) return migrateLegacySettings(canonicalPath, legacyPath);
-	return createInitialSettings(canonicalPath, overrides);
-}
-
-function createInitialSettings(
-	canonicalPath: string,
-	overrides: Partial<InitialFileSystem>,
-): LoadedStatuslineSettings {
-	const fs = { mkdirSync, writeFileSync, linkSync, rmSync, ...overrides };
-	const temporaryPath = temporarySettingsPath(canonicalPath);
-	try {
-		fs.mkdirSync(dirname(canonicalPath), { recursive: true });
-		fs.writeFileSync(temporaryPath, DEFAULT_STATUSLINE_DOCUMENT, {
-			encoding: "utf8",
-			flag: "wx",
-		});
-		try {
-			fs.linkSync(temporaryPath, canonicalPath);
-		} catch (error) {
-			if (isAlreadyExistsError(error)) return loadStatuslineSettings(canonicalPath);
-			throw error;
-		}
-		return loadStatuslineSettings(canonicalPath);
-	} catch (error) {
-		return builtInSettings(canonicalPath, [
-			diagnostic("warning", "io", "", `Unable to create default settings: ${formatError(error)}`),
-		]);
-	} finally {
-		removeTemporaryFile(fs.rmSync, temporaryPath);
+		return canonical;
 	}
+	const legacy = loadStatuslineSettings(legacyPath);
+	return isMissingStatuslineSettings(legacy)
+		? canonical
+		: migrateLegacySettings(canonicalPath, legacy);
 }
 
 function migrateLegacySettings(
 	canonicalPath: string,
-	legacyPath: string,
+	legacy: LoadedStatuslineSettings,
 ): LoadedStatuslineSettings {
-	const legacy = loadStatuslineSettings(legacyPath);
+	const racedCanonical = loadStatuslineSettings(canonicalPath);
+	if (!isMissingStatuslineSettings(racedCanonical)) {
+		pendingSettingsNotice = `${LEGACY_SETTINGS_FILE_NAME} ignored because ${SETTINGS_FILE_NAME} was created concurrently.`;
+		return racedCanonical;
+	}
 	if (
 		legacy.source !== "user" ||
 		legacy.rawDocument === undefined ||
@@ -382,30 +344,16 @@ function migrateLegacySettings(
 		pendingSettingsNotice = `${LEGACY_SETTINGS_FILE_NAME} is invalid and was ignored.`;
 		return legacy;
 	}
-	let identity: FileIdentity;
-	try {
-		identity = installFileExclusively(canonicalPath, legacy.rawDocument);
-	} catch (error) {
-		if (pathExists(canonicalPath)) {
-			pendingSettingsNotice = `${LEGACY_SETTINGS_FILE_NAME} ignored because ${SETTINGS_FILE_NAME} was created concurrently.`;
-			return loadStatuslineSettings(canonicalPath);
-		}
-		pendingSettingsNotice = `Statusline settings migration failed: ${formatError(error)}. The legacy file was used for this session.`;
-		return legacy;
-	}
-	if (!fileContentsEqual(legacyPath, legacy.rawDocument)) {
-		pendingSettingsNotice = removeFileIfIdentityMatches(canonicalPath, identity, legacy.rawDocument)
-			? `${LEGACY_SETTINGS_FILE_NAME} changed during migration; the stale ${SETTINGS_FILE_NAME} snapshot was removed.`
-			: `${LEGACY_SETTINGS_FILE_NAME} changed during migration, but ${SETTINGS_FILE_NAME} was replaced concurrently and takes precedence on the next load.`;
-		return legacy;
-	}
-	try {
-		rmSync(legacyPath);
-		pendingSettingsNotice = `Statusline settings migrated from ${LEGACY_SETTINGS_FILE_NAME} to ${SETTINGS_FILE_NAME}.`;
-	} catch (error) {
-		pendingSettingsNotice = `Statusline settings migrated to ${SETTINGS_FILE_NAME}, but ${LEGACY_SETTINGS_FILE_NAME} could not be removed: ${formatError(error)}.`;
-	}
-	return loadStatuslineSettings(canonicalPath);
+	pendingSettingsNotice = `Using legacy ${LEGACY_SETTINGS_FILE_NAME}; rename it to ${SETTINGS_FILE_NAME}. Future saves write ${SETTINGS_FILE_NAME} without modifying the legacy file.`;
+	return legacy;
+}
+
+function isMissingStatuslineSettings(settings: LoadedStatuslineSettings): boolean {
+	return (
+		settings.source === "built-in" &&
+		settings.rawDocument === undefined &&
+		settings.diagnostics.length === 0
+	);
 }
 
 export function saveStatuslineSettingsDocument(
@@ -426,10 +374,17 @@ export function saveStatuslineSettingsDocument(
 	}
 
 	const fs = { mkdirSync, writeFileSync, renameSync, rmSync, ...overrides };
+	const replaceExisting = pathEntryExists(settingsPath);
 	const temporaryPath = temporarySettingsPath(settingsPath);
+	let fileIdentity: { dev: number; ino: number } | undefined;
 	try {
 		fs.mkdirSync(dirname(settingsPath), { recursive: true });
 		fs.writeFileSync(temporaryPath, rawDocument, { encoding: "utf8", flag: "wx" });
+		const info = lstatSync(temporaryPath);
+		fileIdentity = { dev: info.dev, ino: info.ino };
+		if (!replaceExisting && pathEntryExists(settingsPath)) {
+			throw new Error(`${SETTINGS_FILE_NAME} was created concurrently; reopen settings and retry.`);
+		}
 		fs.renameSync(temporaryPath, settingsPath);
 	} finally {
 		removeTemporaryFile(fs.rmSync, temporaryPath);
@@ -439,10 +394,45 @@ export function saveStatuslineSettingsDocument(
 		source: "user",
 		settingsPath,
 		rawDocument,
+		...(fileIdentity ? { fileIdentity } : {}),
 		diagnostics: normalized.diagnostics,
 	};
 }
 
+export function removeStatuslineSettingsDocumentIfMatches(
+	settingsPath: string,
+	expectedRawDocument: string,
+	expectedIdentity: { dev: number; ino: number },
+): void {
+	const quarantinePath = join(
+		dirname(settingsPath),
+		`.${SETTINGS_FILE_NAME}.${randomUUID()}.rollback`,
+	);
+	const before = lstatSync(settingsPath);
+	if (before.dev !== expectedIdentity.dev || before.ino !== expectedIdentity.ino) {
+		throw new Error("Statusline settings changed concurrently; the newer file was preserved");
+	}
+	renameSync(settingsPath, quarantinePath);
+	const quarantined = lstatSync(quarantinePath);
+	const quarantinedSavedFile =
+		quarantined.isFile() &&
+		!quarantined.isSymbolicLink() &&
+		quarantined.dev === expectedIdentity.dev &&
+		quarantined.ino === expectedIdentity.ino;
+	if (quarantinedSavedFile && readFileSync(quarantinePath, "utf8") === expectedRawDocument) {
+		rmSync(quarantinePath);
+		return;
+	}
+	if (quarantinedSavedFile && !pathEntryExists(settingsPath)) {
+		try {
+			renameSync(quarantinePath, settingsPath);
+		} catch {
+			// Keep the quarantine for recovery when its atomic restoration fails.
+		}
+	}
+	throw new Error("Statusline settings changed concurrently; the newer file was preserved");
+}
+
 export function consumeStatuslineSettingsNotice(): string | undefined {
 	const notice = pendingSettingsNotice;
 	pendingSettingsNotice = undefined;
@@ -452,7 +442,7 @@ export function consumeStatuslineSettingsNotice(): string | undefined {
 export function readStatuslineSettings(settingsPath?: string): StatuslineConfig {
 	return settingsPath
 		? loadStatuslineSettings(settingsPath).config
-		: loadOrCreateStatuslineSettings().config;
+		: loadStatuslineSettingsForAgent().config;
 }
 
 export function normalizeStatuslineSettings(value: unknown): StatuslineConfig {
@@ -628,58 +618,25 @@ function removeTemporaryFile(remove: typeof rmSync, temporaryPath: string) {
 	}
 }
 
-type FileIdentity = { dev: number; ino: number };
-
-function installFileExclusively(filePath: string, contents: string): FileIdentity {
-	mkdirSync(dirname(filePath), { recursive: true });
-	const temporaryPath = temporarySettingsPath(filePath);
-	try {
-		writeFileSync(temporaryPath, contents, { encoding: "utf8", flag: "wx" });
-		const identity = lstatSync(temporaryPath);
-		linkSync(temporaryPath, filePath);
-		return { dev: identity.dev, ino: identity.ino };
-	} finally {
-		removeTemporaryFile(rmSync, temporaryPath);
-	}
-}
-
-function removeFileIfIdentityMatches(
-	filePath: string,
-	expected: FileIdentity,
-	expectedContents: string,
-): boolean {
+function pathExists(path: string): boolean {
 	try {
-		const current = lstatSync(filePath);
-		if (current.dev !== expected.dev || current.ino !== expected.ino) return false;
-		if (readFileSync(filePath, "utf8") !== expectedContents) return false;
-		rmSync(filePath);
+		lstatSync(path);
 		return true;
 	} catch {
 		return false;
 	}
 }
 
-function fileContentsEqual(path: string, expected: string): boolean {
-	try {
-		return readFileSync(path, "utf8") === expected;
-	} catch {
-		return false;
-	}
-}
-
-function pathExists(path: string): boolean {
+function pathEntryExists(path: string): boolean {
 	try {
 		lstatSync(path);
 		return true;
-	} catch {
-		return false;
+	} catch (error) {
+		if ((error as NodeJS.ErrnoException).code === "ENOENT") return false;
+		throw error;
 	}
 }
 
-function isAlreadyExistsError(error: unknown): boolean {
-	return error instanceof Error && "code" in error && error.code === "EEXIST";
-}
-
 function formatError(error: unknown): string {
 	return error instanceof Error ? error.message : String(error);
 }

package/src/statusline.ts

@@ -15,8 +15,8 @@ import { type RuntimeState, renderExtensionStatusline, renderStatusline } from "
 import {
 	consumeStatuslineSettingsNotice,
 	type LoadedStatuslineSettings,
-	loadOrCreateStatuslineSettings,
 	loadStatuslineSettings,
+	loadStatuslineSettingsForAgent,
 	settingsFilePath,
 } from "./settings.js";
 import type { PalettePreset } from "./types.js";
@@ -197,7 +197,7 @@ export default function statusline(pi: ExtensionAPI) {
 		runtime.turnCount = 0;
 		runtime.activeTools.clear();
 		runtime.isStreaming = false;
-		loaded = loadOrCreateStatuslineSettings(agentDir);
+		loaded = loadStatuslineSettingsForAgent(agentDir);
 		const settingsNotice = consumeStatuslineSettingsNotice();
 		if (settingsNotice) ctx.ui.notify(settingsNotice, "warning");
 		if (loaded.diagnostics.length > 0) {