pi-execution-time 0.1.4 → 0.3.0

package/README.md

@@ -1,8 +1,8 @@
 # pi-execution-time
 
-[pi](https://github.com/badlogic/pi-mono) package that adds a live task execution timer to the footer.
+[pi](https://github.com/badlogic/pi-mono) package that adds live task and session timers.
 
-The timer starts when a prompt begins running and counts up until the agent finishes. It renders as a compact status item in the bottom bar next to pi's built-in cost and context usage indicators.
+The task timer starts when a prompt begins running and counts up until the agent finishes. A separate session timer keeps counting from session start. Both render as compact status items in the bottom bar next to pi's built-in cost and context usage indicators.
 
 ## Install
 
@@ -26,13 +26,25 @@ Reload or restart pi after installation. When the agent is working, the footer s
 ⏱ 4.2s
 ```
 
-When the agent finishes, it keeps the final duration visible:
+When the agent finishes, it keeps the final duration and completion time visible:
 
 ```text
-✓ task 18s
+✓ task 18s · 17:42
 ```
 
-Longer durations are formatted as `1m 05s` or `1h 02m 03s`.
+The bottom bar also shows the total elapsed session time and keeps updating it every second:
+
+```text
+Σ session 12m 04s
+```
+
+Completed standard user prompts are rendered above the next standard user prompt:
+
+```text
+✓ step 1 18s · 17:42
+```
+
+Steering messages are ignored for step history. Longer durations are formatted as `1m 05s` or `1h 02m 03s`. Completion time is shown as local `HH:mm`.
 
 ## Local development
 

package/extensions/execution-time.ts

@@ -1,62 +1,183 @@
-import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { Text } from "@earendil-works/pi-tui";
 
-const STATUS_KEY = "execution-time";
-const UPDATE_INTERVAL_MS = 250;
+const TASK_STATUS_KEY = "execution-time";
+const TOTAL_STATUS_KEY = "zz-execution-time-total";
+const STEP_MESSAGE_TYPE = "execution-time-step";
+const TASK_UPDATE_INTERVAL_MS = 250;
+const TOTAL_UPDATE_INTERVAL_MS = 1000;
 
 type TimerState = {
 	startedAt: number;
 	interval: ReturnType<typeof setInterval>;
 };
 
+type CompletedStep = {
+	step: number;
+	elapsedMs: number;
+	completedAt: Date;
+};
+
 export default function (pi: ExtensionAPI) {
-	let timer: TimerState | undefined;
+	let sessionStartedAt = Date.now();
+	let totalInterval: ReturnType<typeof setInterval> | undefined;
+	let taskTimer: TimerState | undefined;
+	let activeStep: { step: number; startedAt: number } | undefined;
+	let nextStep = 1;
+	let standardInputsQueued = 0;
+	let completedSteps: CompletedStep[] = [];
+
+	function stopTaskTimer() {
+		if (!taskTimer) return;
+		clearInterval(taskTimer.interval);
+		taskTimer = undefined;
+	}
 
-	function stopTimer() {
-		if (!timer) return;
-		clearInterval(timer.interval);
-		timer = undefined;
+	function stopTotalTimer() {
+		if (!totalInterval) return;
+		clearInterval(totalInterval);
+		totalInterval = undefined;
 	}
 
-	function renderRunning(ctx: ExtensionContext) {
-		if (!timer) return;
-		const elapsedMs = Date.now() - timer.startedAt;
+	function renderTaskRunning(ctx: ExtensionContext) {
+		if (!taskTimer) return;
+		const elapsedMs = Date.now() - taskTimer.startedAt;
 		const icon = ctx.ui.theme.fg("accent", "⏱");
 		const text = ctx.ui.theme.fg("dim", ` ${formatElapsed(elapsedMs)}`);
-		ctx.ui.setStatus(STATUS_KEY, icon + text);
+		ctx.ui.setStatus(TASK_STATUS_KEY, icon + text);
 	}
 
-	function renderDone(ctx: ExtensionContext, elapsedMs: number) {
+	function renderTaskDone(ctx: ExtensionContext, elapsedMs: number, completedAt: Date) {
 		const icon = ctx.ui.theme.fg("success", "✓");
 		const label = ctx.ui.theme.fg("dim", " task ");
-		const value = ctx.ui.theme.fg("muted", formatElapsed(elapsedMs));
-		ctx.ui.setStatus(STATUS_KEY, icon + label + value);
+		const duration = ctx.ui.theme.fg("muted", formatElapsed(elapsedMs));
+		const separator = ctx.ui.theme.fg("dim", " · ");
+		const completedTime = ctx.ui.theme.fg("muted", formatCompletedAt(completedAt));
+		ctx.ui.setStatus(TASK_STATUS_KEY, icon + label + duration + separator + completedTime);
+	}
+
+	function renderTotal(ctx: ExtensionContext) {
+		const icon = ctx.ui.theme.fg("accent", "Σ");
+		const label = ctx.ui.theme.fg("dim", " session ");
+		const elapsed = ctx.ui.theme.fg("muted", formatElapsed(Date.now() - sessionStartedAt));
+		ctx.ui.setStatus(TOTAL_STATUS_KEY, icon + label + elapsed);
+	}
+
+	function renderCompletedSteps() {
+		for (const { step, elapsedMs, completedAt } of completedSteps) {
+			pi.sendMessage({
+				customType: STEP_MESSAGE_TYPE,
+				content: "",
+				display: true,
+				details: { step, elapsedMs, completedAt: completedAt.toISOString() },
+			});
+		}
+		completedSteps = [];
 	}
 
+	pi.registerMessageRenderer<{ step: number; elapsedMs: number; completedAt: string }>(
+		STEP_MESSAGE_TYPE,
+		(message, _options, theme) => {
+			const details = message.details;
+			const step = details?.step ?? "?";
+			const elapsed = typeof details?.elapsedMs === "number" ? formatElapsed(details.elapsedMs) : "?";
+			const completedAt = details?.completedAt ? formatCompletedAt(new Date(details.completedAt)) : "?";
+			const text = `${theme.fg("success", "✓")} ${theme.fg("dim", `step ${step}`)} ${theme.fg("muted", elapsed)} ${theme.fg("dim", "·")} ${theme.fg("muted", completedAt)}`;
+			return new Text(text, 0, 0);
+		},
+	);
+
+	pi.on("session_start", async (_event, ctx) => {
+		sessionStartedAt = Date.now();
+		activeStep = undefined;
+		standardInputsQueued = 0;
+		completedSteps = [];
+		nextStep = getNextStep(ctx);
+		stopTotalTimer();
+		totalInterval = setInterval(() => renderTotal(ctx), TOTAL_UPDATE_INTERVAL_MS);
+		renderTotal(ctx);
+	});
+
+	pi.on("context", async (event) => ({
+		messages: event.messages.filter(
+			(message) => message.role !== "custom" || message.customType !== STEP_MESSAGE_TYPE,
+		),
+	}));
+
+	pi.on("before_agent_start", async () => {
+		renderCompletedSteps();
+		standardInputsQueued++;
+	});
+
+	pi.on("input", async (event) => {
+		if (event.source === "extension" || event.streamingBehavior !== "followUp") return;
+
+		standardInputsQueued++;
+	});
+
 	pi.on("agent_start", async (_event, ctx) => {
-		stopTimer();
+		stopTaskTimer();
 
-		timer = {
+		taskTimer = {
 			startedAt: Date.now(),
-			interval: setInterval(() => renderRunning(ctx), UPDATE_INTERVAL_MS),
+			interval: setInterval(() => renderTaskRunning(ctx), TASK_UPDATE_INTERVAL_MS),
 		};
 
-		renderRunning(ctx);
+		renderTaskRunning(ctx);
 	});
 
-	pi.on("agent_end", async (_event, ctx) => {
-		if (!timer) return;
+	pi.on("message_start", async (event) => {
+		if (event.message.role !== "user" || standardInputsQueued === 0) return;
 
-		const elapsedMs = Date.now() - timer.startedAt;
-		stopTimer();
-		renderDone(ctx, elapsedMs);
+		if (activeStep) {
+			completedSteps.push(completeStep(activeStep, new Date()));
+		}
+
+		standardInputsQueued--;
+		activeStep = { step: nextStep++, startedAt: Date.now() };
+	});
+
+	pi.on("agent_end", async (_event, ctx) => {
+		if (!taskTimer) return;
+
+		const completedAt = new Date();
+		const elapsedMs = completedAt.getTime() - taskTimer.startedAt;
+		const completedStep = activeStep;
+		stopTaskTimer();
+		activeStep = undefined;
+		renderTaskDone(ctx, elapsedMs, completedAt);
+
+		if (completedStep) {
+			completedSteps.push(completeStep(completedStep, completedAt));
+		}
 	});
 
 	pi.on("session_shutdown", async (_event, ctx) => {
-		stopTimer();
-		ctx.ui.setStatus(STATUS_KEY, undefined);
+		stopTaskTimer();
+		stopTotalTimer();
+		ctx.ui.setStatus(TASK_STATUS_KEY, undefined);
+		ctx.ui.setStatus(TOTAL_STATUS_KEY, undefined);
 	});
 }
 
+function getNextStep(ctx: ExtensionContext) {
+	let maxStep = 0;
+	for (const entry of ctx.sessionManager.getEntries()) {
+		if (entry.type !== "custom_message" || entry.customType !== STEP_MESSAGE_TYPE) continue;
+		const step = (entry.details as { step?: unknown } | undefined)?.step;
+		if (typeof step === "number") maxStep = Math.max(maxStep, step);
+	}
+	return maxStep + 1;
+}
+
+function completeStep(step: { step: number; startedAt: number }, completedAt: Date): CompletedStep {
+	return {
+		step: step.step,
+		elapsedMs: completedAt.getTime() - step.startedAt,
+		completedAt,
+	};
+}
+
 function formatElapsed(ms: number) {
 	const totalSeconds = Math.max(0, ms / 1000);
 
@@ -81,6 +202,10 @@ function formatElapsed(ms: number) {
 	return `${roundedSeconds}s`;
 }
 
+function formatCompletedAt(date: Date) {
+	return `${pad2(date.getHours())}:${pad2(date.getMinutes())}`;
+}
+
 function pad2(value: number) {
 	return value.toString().padStart(2, "0");
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-execution-time",
-  "version": "0.1.4",
+  "version": "0.3.0",
   "description": "Pi extension that shows prompt execution time in the footer while the agent works.",
   "type": "module",
   "license": "MIT",
@@ -32,16 +32,18 @@
   "exports": {
     "./package.json": "./package.json"
   },
-  "peerDependencies": {
-    "@mariozechner/pi-coding-agent": "*"
-  },
   "devDependencies": {
-    "@mariozechner/pi-coding-agent": "^0.73.1",
-    "typescript": "^5.9.3"
+    "@earendil-works/pi-coding-agent": "^1.4.0",
+    "@earendil-works/pi-tui": "^1.4.0",
+    "typescript": "^7.0.2"
   },
   "pi": {
     "extensions": [
       "./extensions/execution-time.ts"
     ]
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-tui": "*"
   }
 }