@bacnh85/pi-plan 0.2.0 → 0.3.0

package/index.ts

@@ -1,5 +1,7 @@
+import type { AssistantMessage } from "@earendil-works/pi-ai";
 import type { ExtensionAPI, ExtensionCommandContext, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { isToolCallEventType, withFileMutationQueue } from "@earendil-works/pi-coding-agent";
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
 import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
 import os from "node:os";
@@ -181,22 +183,168 @@ export default function piPlanExtension(pi: ExtensionAPI): void {
 	let lastPlanStatus: PlanStatus | undefined;
 	let applyingStoredThinking = false;
 
-	function setStatus(ctx: ExtensionContext): void {
-		if (planModeEnabled) {
-			ctx.ui.setStatus(STATUS_KEY, ctx.ui.theme.fg("warning", `plan:${planThinking}`));
-			return;
-		}
-		if (executionMode) {
-			ctx.ui.setStatus(STATUS_KEY, ctx.ui.theme.fg("accent", `exec:${normalThinking}`));
-			return;
-		}
-		ctx.ui.setStatus(STATUS_KEY, undefined);
-	}
-
 	function clearPlanWidget(ctx: ExtensionContext): void {
 		ctx.ui.setWidget(STATUS_KEY, undefined);
 	}
-
+function updateFooter(ctx: ExtensionContext): void {
+		if (planModeEnabled) {
+			ctx.ui.setFooter((tui, theme, footerData) => {
+				const unsub = footerData.onBranchChange(() => tui.requestRender());
+				const sanitizeStatusText = (text: string) =>
+					text.replace(/[\r\n\t]/g, " ").replace(/ +/g, " ").trim();
+				return {
+					dispose: unsub,
+					invalidate() {},
+					render(width: number): string[] {
+						const lines: string[] = [];
+
+						// Line 1: cwd (branch) • session name
+						const home = process.env.HOME || process.env.USERPROFILE;
+						const resolvedCwd = path.resolve(ctx.sessionManager.getCwd());
+						let pwd = resolvedCwd;
+						if (home) {
+							const resolvedHome = path.resolve(home);
+							const rel = path.relative(resolvedHome, resolvedCwd);
+							if (rel === "" || (!rel.startsWith(`..`) && !path.isAbsolute(rel))) {
+								pwd = rel === "" ? "~" : `~${path.sep}${rel}`;
+							}
+						}
+						const branch = footerData.getGitBranch();
+						if (branch) pwd = `${pwd} (${branch})`;
+						const sessionName = ctx.sessionManager.getSessionName();
+						if (sessionName) pwd = `${pwd} • ${sessionName}`;
+						lines.push(truncateToWidth(theme.fg("dim", pwd), width, theme.fg("dim", "...")));
+
+						// Calculate cumulative usage from ALL session entries
+						const fmtTokens = (n: number) =>
+							n < 1000 ? `${n}` :
+							n < 10000 ? `${(n / 1000).toFixed(1)}k` :
+							n < 1000000 ? `${Math.round(n / 1000)}k` :
+							n < 10000000 ? `${(n / 1000000).toFixed(1)}M` :
+							`${Math.round(n / 1000000)}M`;
+
+						let totalInput = 0, totalOutput = 0, totalCacheRead = 0, totalCacheWrite = 0, totalCost = 0;
+						let latestCacheHitRate: number | undefined;
+						for (const e of ctx.sessionManager.getEntries()) {
+							if (e.type === "message" && e.message.role === "assistant") {
+								const m = e.message as AssistantMessage;
+								totalInput += m.usage.input;
+								totalOutput += m.usage.output;
+								totalCacheRead += m.usage.cacheRead;
+								totalCacheWrite += m.usage.cacheWrite;
+								totalCost += m.usage.cost.total;
+								const latestPromptTokens = m.usage.input + m.usage.cacheRead + m.usage.cacheWrite;
+								latestCacheHitRate = latestPromptTokens > 0
+									? (m.usage.cacheRead / latestPromptTokens) * 100
+									: undefined;
+							}
+						}
+
+						const contextUsage = ctx.getContextUsage();
+						const contextWindow = contextUsage?.contextWindow ?? ctx.model?.contextWindow ?? 0;
+						const contextPercentValue = contextUsage?.percent ?? 0;
+						const contextPercent = contextUsage?.percent !== null
+							? contextPercentValue.toFixed(1)
+							: "?";
+
+						// Build left stats
+						const parts: string[] = [];
+						if (totalInput) parts.push(`↑${fmtTokens(totalInput)}`);
+						if (totalOutput) parts.push(`↓${fmtTokens(totalOutput)}`);
+						if (totalCacheRead) parts.push(`R${fmtTokens(totalCacheRead)}`);
+						if (totalCacheWrite) parts.push(`W${fmtTokens(totalCacheWrite)}`);
+						if ((totalCacheRead > 0 || totalCacheWrite > 0) && latestCacheHitRate !== undefined) {
+							parts.push(`CH${latestCacheHitRate.toFixed(1)}%`);
+						}
+						const usingSubscription = ctx.model ? ctx.modelRegistry.isUsingOAuth(ctx.model) : false;
+						if (totalCost || usingSubscription) {
+							parts.push(`$${totalCost.toFixed(3)}${usingSubscription ? " (sub)" : ""}`);
+						}
+						const autoIndicator = " (auto)";
+						const contextPercentDisplay = contextPercent === "?"
+							? `?/${fmtTokens(contextWindow)}${autoIndicator}`
+							: `${contextPercent}%/${fmtTokens(contextWindow)}${autoIndicator}`;
+						let contextPercentStr: string;
+						if (contextPercentValue > 90) {
+							contextPercentStr = theme.fg("error", contextPercentDisplay);
+						} else if (contextPercentValue > 70) {
+							contextPercentStr = theme.fg("warning", contextPercentDisplay);
+						} else {
+							contextPercentStr = contextPercentDisplay;
+						}
+						parts.push(contextPercentStr);
+
+						const statsLeft = parts.join(" ");
+						const statsLeftWidth = visibleWidth(statsLeft);
+
+						// Right side: model info (dimmed) + highlighted plan mode indicator
+						const modelName = ctx.model?.id || "no-model";
+						let rightModelInfo = modelName;
+						if (ctx.model?.reasoning) {
+							const thinkingLevel = pi.getThinkingLevel() || "off";
+							rightModelInfo = thinkingLevel === "off"
+								? `${modelName} • thinking off`
+								: `${modelName} • ${thinkingLevel}`;
+						}
+						if (footerData.getAvailableProviderCount() > 1 && ctx.model) {
+							const withProvider = `(${ctx.model.provider}) ${rightModelInfo}`;
+							const minPad = 2;
+							if (statsLeftWidth + minPad + visibleWidth(withProvider) + visibleWidth(" | Plan mode") <= width) {
+								rightModelInfo = withProvider;
+							}
+						}
+
+						const planText = " | Plan mode";
+						const rightModelWidth = visibleWidth(rightModelInfo);
+						const planWidth = visibleWidth(planText);
+						const minPadding = 2;
+						const totalNeeded = statsLeftWidth + minPadding + rightModelWidth + planWidth;
+
+						let statsLine: string;
+						if (totalNeeded <= width) {
+							const padding = " ".repeat(width - statsLeftWidth - rightModelWidth - planWidth);
+							// Dim statsLeft and model info separately (statsLeft may have color codes from context %)
+							statsLine = theme.fg("dim", statsLeft) + theme.fg("dim", padding + rightModelInfo) + theme.fg("warning", planText);
+						} else {
+							const availableForRight = width - statsLeftWidth - minPadding;
+							if (availableForRight > 0) {
+								if (availableForRight <= planWidth) {
+									// Very tight: show only (part of) plan indicator
+									const trimmed = truncateToWidth(theme.fg("warning", planText), availableForRight, "");
+									const pad = " ".repeat(Math.max(0, width - statsLeftWidth - visibleWidth(trimmed)));
+									statsLine = theme.fg("dim", statsLeft) + pad + trimmed;
+								} else {
+									// Show model info (truncated if needed) + plan indicator
+									const availModel = availableForRight - planWidth;
+									const modelDisplay = truncateToWidth(rightModelInfo, availModel, "");
+									const pad = " ".repeat(Math.max(0, width - statsLeftWidth - visibleWidth(modelDisplay) - planWidth));
+									statsLine = theme.fg("dim", statsLeft) + theme.fg("dim", pad + modelDisplay) + theme.fg("warning", planText);
+								}
+							} else {
+								statsLine = theme.fg("dim", statsLeft);
+							}
+						}
+
+						lines.push(statsLine);
+
+						// Line 3: extension statuses (from setStatus calls by other extensions)
+						const extensionStatuses = footerData.getExtensionStatuses();
+						if (extensionStatuses.size > 0) {
+							const sortedStatuses = Array.from(extensionStatuses.entries())
+								.sort(([a], [b]) => a.localeCompare(b))
+								.map(([, text]) => sanitizeStatusText(text));
+							const statusLine = sortedStatuses.join(" ");
+							lines.push(truncateToWidth(statusLine, width, theme.fg("dim", "...")));
+						}
+
+						return lines;
+					},
+				};
+			});
+		} else {
+			ctx.ui.setFooter(undefined);
+		}
+	}
 	function persistState(): void {
 		pi.appendEntry("pi-plan", {
 			enabled: planModeEnabled,
@@ -248,7 +396,7 @@ export default function piPlanExtension(pi: ExtensionAPI): void {
 		if (key && preferences) {
 			preferences.perModel[key] = { planThinking, normalThinking };
 		}
-		setStatus(ctx);
+		updateFooter(ctx);
 		persistState();
 		persistPreferences();
 	}
@@ -258,10 +406,10 @@ export default function piPlanExtension(pi: ExtensionAPI): void {
 		executionMode = false;
 		enablePlanTools();
 		applyThinking(planThinking);
-		setStatus(ctx);
+		updateFooter(ctx);
 		clearPlanWidget(ctx);
 		persistState();
-		ctx.ui.notify(`Plan mode enabled. Thinking=${planThinking}. Plans will be written to ${PLAN_DIR}/`, "info");
+		ctx.ui.notify(`Plan mode enabled. Plans will be written to ${PLAN_DIR}/`, "info");
 	}
 
 	function leavePlanMode(ctx: ExtensionContext, restoreThinking = true): void {
@@ -269,10 +417,10 @@ export default function piPlanExtension(pi: ExtensionAPI): void {
 		executionMode = false;
 		restoreTools();
 		if (restoreThinking) applyThinking(normalThinking);
-		setStatus(ctx);
+		updateFooter(ctx);
 		clearPlanWidget(ctx);
 		persistState();
-		ctx.ui.notify(`Plan mode disabled. Thinking=${pi.getThinkingLevel()}.`, "info");
+		ctx.ui.notify("Plan mode disabled.", "info");
 	}
 
 	async function handlePlanCommand(args: string, ctx: ExtensionContext): Promise<void> {
@@ -290,7 +438,7 @@ export default function piPlanExtension(pi: ExtensionAPI): void {
 		lastPlanStatus = "approved";
 		restoreTools();
 		applyThinking(normalThinking);
-		setStatus(ctx);
+		updateFooter(ctx);
 		clearPlanWidget(ctx);
 		persistState();
 		persistPreferences();
@@ -500,7 +648,7 @@ export default function piPlanExtension(pi: ExtensionAPI): void {
 		} else if (executionMode) {
 			applyThinking(normalThinking);
 		}
-		setStatus(ctx);
+		updateFooter(ctx);
 		clearPlanWidget(ctx);
 	});
 
@@ -519,7 +667,7 @@ export default function piPlanExtension(pi: ExtensionAPI): void {
 				applyThinking(normalThinking);
 			}
 		}
-		setStatus(ctx);
+		updateFooter(ctx);
 		persistState();
 	});
 
@@ -540,6 +688,28 @@ export default function piPlanExtension(pi: ExtensionAPI): void {
 		}
 	});
 
+	pi.on("context", async (event) => {
+		// When not in plan mode or execution mode, filter out stale context messages
+		if (!planModeEnabled && !executionMode) {
+			return {
+				messages: event.messages.filter((m) => {
+					const msg = m as { customType?: string };
+					return msg.customType !== "pi-plan-context" && msg.customType !== "pi-plan-execution-context";
+				}),
+			};
+		}
+		// In execution mode, filter out stale plan mode context messages
+		if (executionMode && !planModeEnabled) {
+			return {
+				messages: event.messages.filter((m) => {
+					const msg = m as { customType?: string };
+					return msg.customType !== "pi-plan-context";
+				}),
+			};
+		}
+		// In plan mode, let all messages through
+	});
+
 	pi.on("before_agent_start", async (_event, ctx) => {
 		if (planModeEnabled) {
 			const relativePlan = lastPlanPath ? relativeToCwd(ctx.cwd, lastPlanPath) : `${PLAN_DIR}/<timestamp>-<title>.md`;
@@ -589,7 +759,7 @@ export default function piPlanExtension(pi: ExtensionAPI): void {
 			lastPlanStatus = "approved";
 			restoreTools();
 			applyThinking(normalThinking);
-			setStatus(ctx);
+			updateFooter(ctx);
 			clearPlanWidget(ctx);
 			persistState();
 			persistPreferences();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bacnh85/pi-plan",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Pi extension that adds a plan mode with workspace markdown plans and thinking-level presets.",
   "license": "MIT",
   "publishConfig": {