@quandev104/pi-style 0.1.1

package/extension-src/pi-style/domain/config-types.ts

@@ -0,0 +1,115 @@
+export const PI_STYLE_SCHEMA_VERSION = 1 as const;
+
+export type Placement = "above" | "below";
+export type NerdFontsMode = "auto" | "on" | "off";
+export type ToggleMode = "auto" | "on" | "off";
+export type PresetName = "default" | "minimal" | "compact" | "full" | "ascii" | "native";
+export type EditorStyle = "compact" | "boxed" | "dock" | "native";
+export type EditorFrame = "auto" | "halfblock" | "line" | "solid" | "outline" | "native";
+
+export interface StatusCustomItemConfig {
+	id: string;
+	statusKey: string;
+	label?: string;
+	priority?: number;
+	placement?: "left" | "right" | "secondary";
+}
+
+export interface PiStyleConfig {
+	enabled?: boolean;
+	preset?: string;
+	placement?: string;
+	startup?: { mode?: string; showResources?: boolean; alwaysExpanded?: boolean };
+	statusLine?: {
+		enabled?: boolean;
+		separator?: string;
+		layout?: { left?: string[]; right?: string[]; secondary?: string[] };
+		disabledSegments?: string[];
+		customItems?: StatusCustomItemConfig[];
+		/** Blank rows reserved below the primary status row (0 disables). */
+		bottomMargin?: number;
+		/** Context progress-bar cell count (default 10). */
+		contextBarWidth?: number;
+	};
+	editor?: { enabled?: boolean; style?: string; frame?: string; showMetadata?: boolean };
+	messages?: { enabled?: boolean; userPrefix?: boolean; assistantPrefix?: boolean; specialBlocks?: boolean };
+	tools?: {
+		enabled?: boolean;
+		style?: string;
+		maxCollapsedLines?: number;
+		maxExpandedLines?: number;
+		dimOutput?: boolean;
+		showElapsed?: boolean;
+	};
+	theme?: {
+		nerdFonts?: string;
+		terminalBackgroundSync?: string;
+		colors?: Record<string, unknown>;
+		glyphs?: Record<string, unknown>;
+	};
+	compatibility?: {
+		allowSafePatches?: boolean;
+		allowCorePatches?: boolean;
+		preferExistingEditor?: boolean;
+		preferExistingFooter?: boolean;
+	};
+	debug?: boolean;
+	schemaVersion?: number;
+}
+
+export interface NormalizedPiStyleConfig {
+	readonly schemaVersion: typeof PI_STYLE_SCHEMA_VERSION;
+	readonly enabled: boolean;
+	readonly preset: PresetName;
+	readonly placement: Placement;
+	readonly startup: {
+		mode: "off" | "compact" | "overlay";
+		showResources: boolean;
+		alwaysExpanded: boolean;
+	};
+	readonly statusLine: {
+		enabled: boolean;
+		separator: string;
+		layout: { left: readonly string[]; right: readonly string[]; secondary: readonly string[] };
+		disabledSegments: readonly string[];
+		customItems: readonly StatusCustomItemConfig[];
+		/** Blank rows reserved below the primary status row (0 disables). */
+		bottomMargin: number;
+		/** Context progress-bar cell count. */
+		contextBarWidth: number;
+	};
+	readonly editor: { enabled: boolean; style: EditorStyle; frame: EditorFrame; showMetadata: boolean };
+	readonly messages: { enabled: boolean; userPrefix: boolean; assistantPrefix: boolean; specialBlocks: boolean };
+	readonly tools: {
+		enabled: boolean;
+		style: string;
+		maxCollapsedLines: number;
+		maxExpandedLines: number;
+		dimOutput: boolean;
+		showElapsed: boolean;
+	};
+	readonly theme: {
+		nerdFonts: NerdFontsMode;
+		terminalBackgroundSync: ToggleMode;
+		colors: Readonly<Record<string, string>>;
+		glyphs: Readonly<Record<string, string>>;
+	};
+	readonly compatibility: {
+		allowSafePatches: boolean;
+		allowCorePatches: boolean;
+		preferExistingEditor: boolean;
+		preferExistingFooter: boolean;
+	};
+	/** Internal provenance marker; never serialized or accepted as a command field. */
+	readonly productCorePatchesExplicit?: boolean;
+	readonly debug: boolean;
+}
+
+export interface ConfigSources {
+	defaults?: unknown;
+	global?: unknown;
+	project?: unknown;
+	environment?: Record<string, string | undefined>;
+	session?: unknown;
+	projectTrusted?: boolean;
+}

package/extension-src/pi-style/domain/providers.ts

@@ -0,0 +1,37 @@
+import type { ContextSnapshot, GitSnapshot, StatusSnapshot, UsageSnapshot } from "./status.js";
+
+export interface GitCommandResult {
+	readonly stdout: string;
+	readonly stderr: string;
+	readonly code: number;
+}
+
+export interface GitCommandRunner {
+	run(args: readonly string[], cwd: string, timeoutMs: number, signal?: AbortSignal): Promise<GitCommandResult>;
+}
+
+export interface GitProvider {
+	get(cwd: string): Promise<GitSnapshot>;
+	invalidate(cwd?: string): void;
+	dispose(): void;
+}
+
+export interface UsageProvider {
+	get(sessionId: string): UsageSnapshot;
+	record(sessionId: string, usage: Partial<UsageSnapshot>, options?: { eventId?: string; finalized?: boolean }): void;
+	reset(sessionId?: string): void;
+}
+
+export interface ContextProvider {
+	get(sessionId: string): ContextSnapshot | undefined;
+	set(sessionId: string, context: ContextSnapshot): void;
+	clear(sessionId?: string): void;
+}
+
+export interface StatusProviderBundle {
+	readonly git: GitProvider;
+	readonly usage: UsageProvider;
+	readonly context: ContextProvider;
+}
+
+export type SnapshotStatusValues = Pick<StatusSnapshot, "model" | "thinkingLevel" | "git" | "context" | "usage">;

package/extension-src/pi-style/domain/status-presets.ts

@@ -0,0 +1,60 @@
+import type { PresetName } from "./config-types.js";
+import type { StatusLayout, StatusSegmentId } from "./status.js";
+
+export const STATUS_PRESETS: Readonly<Record<PresetName, StatusLayout>> = Object.freeze({
+	default: Object.freeze({
+		left: ["path", "git", "context_bar", "cost"],
+		right: ["model_effort"],
+		secondary: ["extension_statuses"],
+	}),
+	minimal: Object.freeze({ left: ["path", "git"], right: ["context_pct"], secondary: [] }),
+	compact: Object.freeze({
+		left: ["model", "thinking", "git"],
+		right: ["context_pct"],
+		secondary: ["extension_statuses"],
+	}),
+	full: Object.freeze({
+		left: ["hostname", "model", "thinking", "path", "git", "session"],
+		right: ["token_in", "token_out", "cache_read", "cost", "context_pct", "time_spent", "time"],
+		secondary: ["extension_statuses"],
+	}),
+	ascii: Object.freeze({
+		left: ["path", "git", "context_bar", "cost"],
+		right: ["model_effort"],
+		secondary: ["extension_statuses"],
+	}),
+	native: Object.freeze({ left: ["model", "path"], right: ["context_pct"], secondary: [] }),
+});
+
+function unique(values: readonly unknown[]): StatusSegmentId[] {
+	const result: StatusSegmentId[] = [];
+	for (const value of values) {
+		if (typeof value !== "string" || result.includes(value)) continue;
+		result.push(value);
+	}
+	return result;
+}
+
+export function normalizeStatusLayout(
+	preset: PresetName,
+	input:
+		| {
+				left?: readonly unknown[] | undefined;
+				right?: readonly unknown[] | undefined;
+				secondary?: readonly unknown[] | undefined;
+		  }
+		| undefined,
+): StatusLayout {
+	const base = STATUS_PRESETS[preset] ?? STATUS_PRESETS.default;
+	const left = input?.left === undefined ? base.left : unique(input.left);
+	const right = input?.right === undefined ? base.right : unique(input.right);
+	const secondary = input?.secondary === undefined ? base.secondary : unique(input.secondary);
+	const seen = new Set<StatusSegmentId>();
+	const dedupe = (values: readonly StatusSegmentId[]) =>
+		values.filter((value) => {
+			if (seen.has(value)) return false;
+			seen.add(value);
+			return true;
+		});
+	return Object.freeze({ left: dedupe(left), right: dedupe(right), secondary: dedupe(secondary) });
+}

package/extension-src/pi-style/domain/status-renderer.ts

@@ -0,0 +1,142 @@
+import type {
+	SegmentContext,
+	SegmentRenderResult,
+	StatusLayout,
+	StatusRenderResult,
+	StatusSegment,
+	StatusSegmentId,
+	StatusSnapshot,
+} from "../domain/status.js";
+import type { ResolvedTheme } from "../domain/theme.js";
+import { truncateAnsi, visibleWidth } from "../shared/ansi.js";
+
+export interface StatusRendererOptions {
+	readonly separator?: string;
+	readonly padding?: string;
+	readonly segments: ReadonlyMap<StatusSegmentId, StatusSegment>;
+	readonly theme: ResolvedTheme;
+	readonly options?: Readonly<
+		Record<string, { readonly disabled?: boolean; readonly [key: string]: unknown } | undefined>
+	>;
+}
+
+interface Candidate {
+	readonly id: StatusSegmentId;
+	readonly segment: StatusSegment;
+	readonly result: SegmentRenderResult;
+	content: string;
+	compact: boolean;
+	moved: boolean;
+}
+
+function uniqueLayout(layout: StatusLayout): StatusLayout {
+	const seen = new Set<StatusSegmentId>();
+	const dedupe = (items: readonly StatusSegmentId[]) =>
+		items.filter((id) => {
+			if (seen.has(id)) return false;
+			seen.add(id);
+			return true;
+		});
+	return { left: dedupe(layout.left), right: dedupe(layout.right), secondary: dedupe(layout.secondary) };
+}
+
+function renderGroup(items: readonly Candidate[], separator: string, padding: string): string {
+	return items
+		.map((item) => item.content)
+		.filter(Boolean)
+		.join(`${padding}${separator}${padding}`);
+}
+
+function widthOf(items: readonly Candidate[], separator: string, padding: string): number {
+	return visibleWidth(renderGroup(items, separator, padding));
+}
+
+export function renderStatus(
+	layout: StatusLayout,
+	snapshot: StatusSnapshot,
+	width: number,
+	options: StatusRendererOptions,
+): StatusRenderResult {
+	if (width <= 0) return { primary: "", lines: [], visibleSegments: [] };
+	const separator = options.separator ?? "│";
+	const padding = options.padding ?? " ";
+	const normalized = uniqueLayout(layout);
+	const context: SegmentContext = { snapshot, theme: options.theme, options: options.options ?? {}, width };
+	const candidates = new Map<StatusSegmentId, Candidate>();
+	for (const id of [...normalized.left, ...normalized.right, ...normalized.secondary]) {
+		if (candidates.has(id)) continue;
+		const segment = options.segments.get(id);
+		if (!segment || options.options?.[id]?.disabled) continue;
+		try {
+			const result = segment.render(context);
+			if (!result.visible || !result.content) continue;
+			candidates.set(id, { id, segment, result, content: result.content, compact: false, moved: false });
+		} catch {
+			// A broken optional segment must not break the status row.
+		}
+	}
+	const primary = [...normalized.left, ...normalized.right]
+		.map((id) => candidates.get(id))
+		.filter((candidate): candidate is Candidate => candidate !== undefined)
+		.sort(
+			(a, b) =>
+				(b.segment.essential ? 1 : 0) - (a.segment.essential ? 1 : 0) ||
+				b.segment.defaultPriority - a.segment.defaultPriority,
+		);
+	const secondary = normalized.secondary
+		.map((id) => candidates.get(id))
+		.filter((candidate): candidate is Candidate => candidate !== undefined);
+	const visible: Candidate[] = [];
+	const overflow: Candidate[] = [];
+	for (const candidate of primary) {
+		visible.push(candidate);
+		if (widthOf(visible, separator, padding) <= width) continue;
+		if (candidate.result.compactContent && !candidate.compact) {
+			candidate.content = candidate.result.compactContent;
+			candidate.compact = true;
+			if (widthOf(visible, separator, padding) <= width) continue;
+		}
+		visible.pop();
+		if (candidate.segment.overflow !== "drop" && candidate.segment.overflow !== "primary") {
+			candidate.moved = true;
+			overflow.push(candidate);
+		}
+	}
+	for (const candidate of [...overflow].sort((a, b) => b.segment.defaultPriority - a.segment.defaultPriority))
+		secondary.push(candidate);
+	// Right-aligned trailing group: layout.right candidates render flush to the
+	// right edge, mirroring Pi's native footer (model • effort on the far right).
+	// Group order follows the layout declaration; the priority sort above only
+	// decides what drops on overflow.
+	const visibleIds = new Set(visible.map((candidate) => candidate.id));
+	const groupOf = (group: readonly StatusSegmentId[]) =>
+		group
+			.map((id) => candidates.get(id))
+			.filter((candidate): candidate is Candidate => candidate !== undefined && visibleIds.has(candidate.id));
+	const leftVisible = groupOf(normalized.left);
+	const rightVisible = groupOf(normalized.right);
+	const leftText = renderGroup(leftVisible, separator, padding);
+	const rightText = renderGroup(rightVisible, separator, padding);
+	let primaryText: string;
+	if (!rightText) {
+		primaryText = leftText;
+	} else {
+		const core = leftText ? `${leftText}${padding}${separator}${padding}` : "";
+		const gap = Math.max(2, width - visibleWidth(core) - visibleWidth(rightText));
+		primaryText = `${core}${" ".repeat(gap)}${rightText}`;
+	}
+	if (visibleWidth(primaryText) > width) primaryText = truncateAnsi(primaryText, width);
+	const secondaryVisible: Candidate[] = [];
+	for (const candidate of [...secondary].sort((a, b) => b.segment.defaultPriority - a.segment.defaultPriority)) {
+		secondaryVisible.push(candidate);
+		if (widthOf(secondaryVisible, separator, padding) > width) secondaryVisible.pop();
+	}
+	const secondaryText = renderGroup(secondaryVisible, separator, padding);
+	const lines = secondaryText ? [primaryText, secondaryText] : primaryText ? [primaryText] : [];
+	return {
+		primary: primaryText,
+		...(secondaryText ? { secondary: secondaryText } : {}),
+		lines,
+		visibleSegments: [...visible, ...secondaryVisible].map((candidate) => candidate.id),
+	};
+}