pi-zentui 0.2.1 → 0.2.5

package/extensions/zentui/git.ts

@@ -2,6 +2,7 @@ import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 
 const execFileAsync = promisify(execFile);
+const GIT_COMMAND_TIMEOUT_MS = 2_000;
 
 export type GitStatusSummary = {
 	branch?: string;
@@ -88,10 +89,14 @@ export function parseGitStatusPorcelain(stdoutText: string, hasStash: boolean):
 export async function readGitStatus(cwd: string): Promise<GitStatusSummary> {
 	try {
 		const [{ stdout: statusStdout }, stashResult] = await Promise.all([
-			execFileAsync("git", ["status", "--porcelain=2", "--branch"], { cwd }),
-			execFileAsync("git", ["rev-parse", "--verify", "--quiet", "refs/stash"], { cwd }).catch(
-				() => ({ stdout: "" }),
-			),
+			execFileAsync("git", ["status", "--porcelain=2", "--branch"], {
+				cwd,
+				timeout: GIT_COMMAND_TIMEOUT_MS,
+			}),
+			execFileAsync("git", ["rev-parse", "--verify", "--quiet", "refs/stash"], {
+				cwd,
+				timeout: GIT_COMMAND_TIMEOUT_MS,
+			}).catch(() => ({ stdout: "" })),
 		]);
 		const stdoutText = typeof statusStdout === "string" ? statusStdout : String(statusStdout);
 		const stashStdout =

package/extensions/zentui/index.ts

@@ -18,7 +18,12 @@ import {
 } from "./config";
 import { installFooter } from "./footer";
 import { emptyGitStatus, readGitStatus } from "./git";
-import { type StopProjectRefreshInterval, startProjectRefreshInterval } from "./project-refresh";
+import {
+	type ScheduleProjectRefreshOptions,
+	type StopProjectRefreshInterval,
+	createProjectRefreshScheduler,
+	startProjectRefreshInterval,
+} from "./project-refresh";
 import { readRuntimeInfo } from "./runtime";
 import { installSelectorBorderStyle } from "./selector-border";
 import { registerZentuiSettingsCommand } from "./settings-command";
@@ -27,11 +32,13 @@ import { PolishedEditor, WrappedPolishedEditor } from "./ui";
 import { installUserMessageStyle } from "./user-message";
 
 const ZENTUI_EDITOR_FACTORY = Symbol.for("pi-zentui.editor-factory");
+const ZENTUI_EDITOR_BASE_FACTORY = Symbol.for("pi-zentui.editor-base-factory");
 
 type EditorFactory = NonNullable<Parameters<ExtensionContext["ui"]["setEditorComponent"]>[0]>;
 
 type ZentuiEditorFactory = EditorFactory & {
 	[ZENTUI_EDITOR_FACTORY]?: true;
+	[ZENTUI_EDITOR_BASE_FACTORY]?: EditorFactory;
 };
 
 type ApplyUiResult = {
@@ -44,6 +51,15 @@ function isZentuiEditorFactory(factory: EditorFactory | undefined): boolean {
 	return Boolean((factory as ZentuiEditorFactory | undefined)?.[ZENTUI_EDITOR_FACTORY]);
 }
 
+function getZentuiEditorBaseFactory(factory: EditorFactory | undefined): EditorFactory | undefined {
+	return (factory as ZentuiEditorFactory | undefined)?.[ZENTUI_EDITOR_BASE_FACTORY];
+}
+
+function isTuiContext(ctx: ExtensionContext): boolean {
+	const mode = (ctx as ExtensionContext & { mode?: string }).mode;
+	return ctx.hasUI && (mode === undefined || mode === "tui");
+}
+
 export default function (pi: ExtensionAPI) {
 	const state: FooterState = createInitialState(emptyGitStatus());
 
@@ -56,10 +72,9 @@ export default function (pi: ExtensionAPI) {
 	let footerInstalled = false;
 	let editorInstalled = false;
 	let editorInstallMode: EditorInstallMode = "none";
+	let installedEditorFactory: EditorFactory | undefined;
 	let wrappedEditorFactory: EditorFactory | undefined;
 	let prototypePatchesInstalled = false;
-	let projectRefreshInFlight = false;
-	let projectRefreshPending = false;
 
 	const refresh = () => requestFooterRender?.();
 	const getActiveTheme = () => activeTheme;
@@ -77,22 +92,9 @@ export default function (pi: ExtensionAPI) {
 		state.runtime = runtime;
 	};
 
-	const scheduleProjectRefresh = (ctx: ExtensionContext) => {
-		if (projectRefreshInFlight) {
-			projectRefreshPending = true;
-			return;
-		}
-
-		projectRefreshInFlight = true;
-		void refreshProjectState(ctx).finally(() => {
-			projectRefreshInFlight = false;
-			refresh();
-			if (projectRefreshPending) {
-				projectRefreshPending = false;
-				scheduleProjectRefresh(ctx);
-			}
-		});
-	};
+	const projectRefreshScheduler = createProjectRefreshScheduler(refreshProjectState, refresh);
+	const scheduleProjectRefresh = (ctx: ExtensionContext, options?: ScheduleProjectRefreshOptions) =>
+		projectRefreshScheduler.schedule(ctx, options);
 
 	const refreshInteractiveState = (ctx: ExtensionContext, project = false) => {
 		if (!ctx.hasUI) return;
@@ -104,8 +106,7 @@ export default function (pi: ExtensionAPI) {
 	const stopProjectRefresh = () => {
 		stopRefreshInterval();
 		stopRefreshInterval = () => {};
-		projectRefreshInFlight = false;
-		projectRefreshPending = false;
+		projectRefreshScheduler.stop();
 	};
 
 	const installPrototypePatches = () => {
@@ -159,24 +160,38 @@ export default function (pi: ExtensionAPI) {
 				getThinkingLevel,
 			)) as ZentuiEditorFactory;
 		factory[ZENTUI_EDITOR_FACTORY] = true;
+		factory[ZENTUI_EDITOR_BASE_FACTORY] = baseFactory;
 		return factory;
 	};
 
 	const installEditor = (ctx: ExtensionContext): boolean => {
 		const currentFactory = ctx.ui.getEditorComponent();
-		if (currentFactory && isZentuiEditorFactory(currentFactory)) {
+		if (currentFactory && currentFactory === installedEditorFactory) {
 			editorInstalled = true;
 			return true;
 		}
 
 		installPrototypePatches();
-		if (currentFactory) {
+		const currentZentuiBaseFactory = getZentuiEditorBaseFactory(currentFactory);
+		if (currentFactory && isZentuiEditorFactory(currentFactory)) {
+			wrappedEditorFactory = currentZentuiBaseFactory;
+			const nextFactory = currentZentuiBaseFactory
+				? makeWrappedEditorFactory(ctx, currentZentuiBaseFactory)
+				: makeEditorFactory(ctx);
+			ctx.ui.setEditorComponent(nextFactory);
+			installedEditorFactory = nextFactory;
+			editorInstallMode = currentZentuiBaseFactory ? "wrapper" : "standalone";
+		} else if (currentFactory) {
 			wrappedEditorFactory = currentFactory;
-			ctx.ui.setEditorComponent(makeWrappedEditorFactory(ctx, currentFactory));
+			const nextFactory = makeWrappedEditorFactory(ctx, currentFactory);
+			ctx.ui.setEditorComponent(nextFactory);
+			installedEditorFactory = nextFactory;
 			editorInstallMode = "wrapper";
 		} else {
 			wrappedEditorFactory = undefined;
-			ctx.ui.setEditorComponent(makeEditorFactory(ctx));
+			const nextFactory = makeEditorFactory(ctx);
+			ctx.ui.setEditorComponent(nextFactory);
+			installedEditorFactory = nextFactory;
 			editorInstallMode = "standalone";
 		}
 		editorInstalled = true;
@@ -192,6 +207,7 @@ export default function (pi: ExtensionAPI) {
 			editorInstallMode === "wrapper" && wrappedEditorFactory ? wrappedEditorFactory : undefined,
 		);
 		wrappedEditorFactory = undefined;
+		installedEditorFactory = undefined;
 		editorInstallMode = "none";
 		editorInstalled = false;
 		return true;
@@ -213,7 +229,7 @@ export default function (pi: ExtensionAPI) {
 		stopRefreshInterval = startProjectRefreshInterval(currentConfig.projectRefreshIntervalMs, () =>
 			scheduleProjectRefresh(ctx),
 		);
-		scheduleProjectRefresh(ctx);
+		scheduleProjectRefresh(ctx, { force: true });
 		refresh();
 	};
 
@@ -227,7 +243,7 @@ export default function (pi: ExtensionAPI) {
 
 	const applyConfiguredUi = (ctx: ExtensionContext): ApplyUiResult => {
 		const result: ApplyUiResult = { editorBlocked: false };
-		if (!ctx.hasUI) return result;
+		if (!isTuiContext(ctx)) return result;
 		activeTheme = ctx.ui.theme;
 		if (currentConfig.features.editor) {
 			const currentFactory = ctx.ui.getEditorComponent();
@@ -246,11 +262,12 @@ export default function (pi: ExtensionAPI) {
 	};
 
 	const installUi = (ctx: ExtensionContext) => {
-		if (!ctx.hasUI) return;
+		if (!isTuiContext(ctx)) return;
 		activeTheme = ctx.ui.theme;
 		uninstallPrototypePatches();
 		footerInstalled = false;
 		editorInstalled = false;
+		installedEditorFactory = undefined;
 		ensureConfigExists();
 		currentConfig = loadConfig();
 		syncFooterState(ctx);
@@ -261,9 +278,9 @@ export default function (pi: ExtensionAPI) {
 
 	const scheduleEditorReconciliation = (ctx: ExtensionContext) => {
 		setTimeout(() => {
-			if (!ctx.hasUI || !currentConfig.features.editor) return;
+			if (!isTuiContext(ctx) || !currentConfig.features.editor) return;
 			const currentFactory = ctx.ui.getEditorComponent();
-			if (currentFactory && !isZentuiEditorFactory(currentFactory)) {
+			if (currentFactory && currentFactory !== installedEditorFactory) {
 				applyConfiguredUi(ctx);
 				refresh();
 			}
@@ -275,18 +292,20 @@ export default function (pi: ExtensionAPI) {
 		stopProjectRefresh();
 		requestFooterRender = undefined;
 		getActiveExtensionStatuses = () => new Map();
-		if (ctx?.hasUI) {
+		if (ctx && isTuiContext(ctx)) {
 			ctx.ui.setFooter(undefined);
 			const currentFactory = ctx.ui.getEditorComponent();
 			if (!currentFactory || isZentuiEditorFactory(currentFactory)) {
 				ctx.ui.setEditorComponent(
-					editorInstallMode === "wrapper" && wrappedEditorFactory
-						? wrappedEditorFactory
-						: undefined,
+					getZentuiEditorBaseFactory(currentFactory) ??
+						(editorInstallMode === "wrapper" && wrappedEditorFactory
+							? wrappedEditorFactory
+							: undefined),
 				);
 			}
 		}
 		wrappedEditorFactory = undefined;
+		installedEditorFactory = undefined;
 		editorInstallMode = "none";
 		footerInstalled = false;
 		editorInstalled = false;

package/extensions/zentui/project-refresh.ts

@@ -1,5 +1,16 @@
 export type StopProjectRefreshInterval = () => void;
 
+export type ScheduleProjectRefreshOptions = {
+	force?: boolean;
+};
+
+export type ProjectRefreshScheduler<T> = {
+	schedule: (target: T, options?: ScheduleProjectRefreshOptions) => void;
+	stop: () => void;
+};
+
+export const PROJECT_REFRESH_THROTTLE_MS = 5_000;
+
 export function startProjectRefreshInterval(
 	intervalMs: number,
 	refresh: () => void,
@@ -11,3 +22,83 @@ export function startProjectRefreshInterval(
 
 	return () => clearInterval(timer);
 }
+
+export function createProjectRefreshScheduler<T>(
+	refresh: (target: T) => Promise<void>,
+	afterRefresh: () => void,
+	throttleMs = PROJECT_REFRESH_THROTTLE_MS,
+): ProjectRefreshScheduler<T> {
+	let refreshInFlight = false;
+	let refreshPending = false;
+	let pendingTarget: T | undefined;
+	let delayedRefresh: ReturnType<typeof setTimeout> | undefined;
+	let lastRefreshStartedAt: number | undefined;
+	let generation = 0;
+
+	const clearDelayedRefresh = () => {
+		if (!delayedRefresh) return;
+		clearTimeout(delayedRefresh);
+		delayedRefresh = undefined;
+	};
+
+	const runRefresh = (target: T) => {
+		clearDelayedRefresh();
+		if (refreshInFlight) {
+			refreshPending = true;
+			pendingTarget = target;
+			return;
+		}
+
+		const currentGeneration = generation;
+		refreshInFlight = true;
+		lastRefreshStartedAt = Date.now();
+		void refresh(target)
+			.catch(() => undefined)
+			.finally(() => {
+				if (currentGeneration !== generation) return;
+				refreshInFlight = false;
+				afterRefresh();
+				if (refreshPending) {
+					refreshPending = false;
+					const nextTarget = pendingTarget ?? target;
+					pendingTarget = undefined;
+					schedule(nextTarget);
+				}
+			});
+	};
+
+	const schedule = (target: T, options: ScheduleProjectRefreshOptions = {}) => {
+		if (options.force || throttleMs <= 0 || lastRefreshStartedAt === undefined) {
+			runRefresh(target);
+			return;
+		}
+
+		const delayMs = Math.max(0, throttleMs - (Date.now() - lastRefreshStartedAt));
+		if (delayMs === 0) {
+			runRefresh(target);
+			return;
+		}
+
+		pendingTarget = target;
+		if (delayedRefresh) return;
+		delayedRefresh = setTimeout(() => {
+			delayedRefresh = undefined;
+			const nextTarget = pendingTarget ?? target;
+			pendingTarget = undefined;
+			runRefresh(nextTarget);
+		}, delayMs);
+		delayedRefresh.unref?.();
+	};
+
+	return {
+		schedule,
+		stop() {
+			generation += 1;
+			clearDelayedRefresh();
+			refreshInFlight = false;
+			refreshPending = false;
+			pendingTarget = undefined;
+			lastRefreshStartedAt = undefined;
+		},
+	};
+}

package/extensions/zentui/settings-command.ts

@@ -305,7 +305,8 @@ export function registerZentuiSettingsCommand(pi: ExtensionAPI, deps: SettingsCo
 				return;
 			}
 
-			if (!ctx.hasUI) return;
+			const mode = (ctx as typeof ctx & { mode?: string }).mode;
+			if (!ctx.hasUI || (mode !== undefined && mode !== "tui")) return;
 
 			await ctx.ui.custom<void>((tui, theme, _keybindings, done) => {
 				const settingsListTheme = deps.settingsListTheme ?? getSettingsListTheme();

package/extensions/zentui/ui.ts

@@ -132,6 +132,40 @@ function composeMetadataLine(left: string, right: string | undefined, width: num
 	return `${leftText}${gap}${right}`;
 }
 
+function plainRenderedText(line: string): string {
+	return line
+		.replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "")
+		.replace(/\x1b\][^\x07]*(?:\x07|\x1b\\)/g, "")
+		.replace(/\[[/?][^\]]+\]/g, "");
+}
+
+function isHorizontalBorder(line: string): boolean {
+	const plain = plainRenderedText(line).trim();
+	return plain.length > 0 && /^─+$/.test(plain);
+}
+
+function isRenderedModelMetaLine(line: string, modelMeta: EditorMeta): boolean {
+	const plain = plainRenderedText(line);
+	return plain.includes(modelMeta.modelLabel) && plain.includes(modelMeta.providerLabel);
+}
+
+function removeRenderedModelMetaLines(lines: string[], modelMeta: EditorMeta): string[] {
+	const result: string[] = [];
+	for (let index = 0; index < lines.length; index++) {
+		const line = lines[index] ?? "";
+		if (isRenderedModelMetaLine(line, modelMeta)) continue;
+
+		const plain = plainRenderedText(line).trim();
+		const previousWasMeta = index > 0 && isRenderedModelMetaLine(lines[index - 1] ?? "", modelMeta);
+		const nextIsMeta =
+			index < lines.length - 1 && isRenderedModelMetaLine(lines[index + 1] ?? "", modelMeta);
+		if (!plain && (previousWasMeta || nextIsMeta)) continue;
+
+		result.push(line);
+	}
+	return result;
+}
+
 function vimModeColor(mode: string): string {
 	switch (mode.toLowerCase()) {
 		case "insert":
@@ -195,10 +229,9 @@ function renderPolishedFrame({
 		autocompleteCount > 0 && autocompleteCount < baseRendered.length
 			? baseRendered.slice(-autocompleteCount)
 			: [];
-
 	if (editorFrame.length < 2) return clampRenderedLines(baseRendered, width);
 
-	const editorLines = editorFrame.slice(1, -1);
+	const editorLines = removeRenderedModelMetaLines(editorFrame.slice(1, -1), modelMeta);
 	const model = renderStyleForSourceOrFallback(
 		uiTheme,
 		colorSource,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-zentui",
-	"version": "0.2.1",
+	"version": "0.2.5",
 	"description": "A Starship-inspired statusline and Opencode-style TUI for Pi.",
 	"type": "module",
 	"license": "MIT",