@prjct.app/pi-activity 0.1.3 → 0.2.1

package/index.ts

@@ -6,80 +6,179 @@ import {
 	createLsTool,
 	createReadTool,
 	createWriteTool,
+	getSettingsListTheme,
+	keyHint,
 	type ExtensionAPI,
 	type ExtensionContext,
 } from "@earendil-works/pi-coding-agent";
-import { Container, Text, TruncatedText, truncateToWidth } from "@earendil-works/pi-tui";
-import { stripVTControlCharacters } from "node:util";
-import { homedir } from "node:os";
 import type { AgentTool } from "@earendil-works/pi-agent-core";
+import { Container, SettingsList, Text, type SettingItem } from "@earendil-works/pi-tui";
 import type { TSchema } from "typebox";
+import {
+	ActiveToolsWidget,
+	ActivityInspectorComponent,
+	ActivityRowComponent,
+	ActivitySummaryComponent,
+	renderExpandedToolResult,
+} from "./src/components.ts";
+import {
+	actionTarget,
+	activityCategory,
+	aggregateFileChanges,
+	applyToolResult,
+	finishRecord,
+	formatDuration,
+	resultText,
+	snapshotRecord,
+	TOOL_VERBS,
+} from "./src/format.ts";
+import type {
+	ActivityCategory,
+	ActivityDensity,
+	ActivityRecord,
+	ActivityRecordSnapshot,
+	ActivitySummaryData,
+} from "./src/types.ts";
 
-const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+const DENSITIES: ActivityDensity[] = ["minimal", "balanced", "forensic"];
+const HISTORY_LIMIT = 200;
 
-function actionTarget(name: string, args: Record<string, unknown>): string {
-	const value = name === "bash" ? args.command
-		: name === "grep" || name === "find" ? `${args.pattern ?? ""}${args.path ? ` · ${args.path}` : ""}`
-		: args.path;
-	if (typeof value !== "string" || !value) return ".";
-	const home = homedir();
-	const target = value.startsWith(`${home}/`) ? `~/${value.slice(home.length + 1)}` : value;
-	return stripVTControlCharacters(target).replace(/\r?\n/g, " ↵ ").replace(/\t/g, " ").replace(/[\x00-\x1f\x7f]/g, "");
+function isDensity(value: unknown): value is ActivityDensity {
+	return typeof value === "string" && DENSITIES.includes(value as ActivityDensity);
 }
 
-function detailText(result: { content: Array<{ type: string; text?: string }> }): string {
-	const text = result.content
-		.filter((item) => item.type === "text" && item.text)
-		.map((item) => item.text)
-		.join("\n")
-		.trim();
-	return text || "No additional details.";
+function unique(values: string[]): string[] {
+	return [...new Set(values)];
 }
 
 export default function activityMode(pi: ExtensionAPI) {
-	const modifiedFiles = new Set<string>();
-	const completedActions = new Set<string>();
-	const failedActions = new Set<string>();
-	let actionCount = 0;
-	let errorCount = 0;
-	const activeTools = new Map<string, string>();
+	let density: ActivityDensity = "balanced";
+	let runStartedAt: number | undefined;
+	let agentRunning = false;
+	let waitingForUser = false;
 	let lastWorkingMessage: string | undefined;
+	let history: Array<ActivityRecord | ActivityRecordSnapshot> = [];
+	let runRecords: ActivityRecord[] = [];
+	const recordsById = new Map<string, ActivityRecord>();
+	const activeRecords = new Map<string, ActivityRecord>();
 
-	function refreshWorkingMessage(ctx: ExtensionContext, settled = false) {
-		if (ctx.mode !== "tui") return;
-		const first = activeTools.values().next().value;
-		const message = settled ? undefined : activeTools.size > 1
-			? `${activeTools.size} tools running · ${first}`
-			: first ?? "Thinking…";
+	const completedCount = () => runRecords.filter((record) => record.status !== "running").length;
+
+	function ensureRecord(
+		id: string,
+		name: string,
+		args: Record<string, unknown> = {},
+		startedAt = Date.now(),
+	): ActivityRecord {
+		const existing = recordsById.get(id);
+		if (existing) {
+			if (Object.keys(args).length) {
+				existing.args = args;
+				existing.target = actionTarget(name, args);
+				existing.category = activityCategory(name, args);
+			}
+			return existing;
+		}
+		const record: ActivityRecord = {
+			id,
+			name,
+			args,
+			target: actionTarget(name, args),
+			category: activityCategory(name, args),
+			status: "running",
+			startedAt,
+		};
+		recordsById.set(id, record);
+		runRecords.push(record);
+		runStartedAt ??= startedAt;
+		return record;
+	}
+
+	function reconstructSessionState(ctx: ExtensionContext): void {
+		density = "balanced";
+		history = [];
+		const byId = new Map<string, ActivityRecordSnapshot>();
+		for (const entry of ctx.sessionManager.getBranch()) {
+			if (entry.type !== "custom") continue;
+			if (entry.customType === "activity-settings") {
+				const savedDensity = (entry.data as { density?: unknown } | undefined)?.density;
+				if (isDensity(savedDensity)) density = savedDensity;
+			}
+			if (entry.customType !== "activity-summary") continue;
+			const data = entry.data as Partial<ActivitySummaryData> | undefined;
+			if (data?.version !== 2 || !Array.isArray(data.records)) continue;
+			for (const record of data.records) byId.set(record.id, record);
+		}
+		history = [...byId.values()].slice(-HISTORY_LIMIT);
+	}
+
+	function activeList(): ActivityRecord[] {
+		return [...activeRecords.values()];
+	}
+
+	function setWorkingMessage(ctx: ExtensionContext, message: string | undefined): void {
 		if (message === lastWorkingMessage) return;
 		lastWorkingMessage = message;
 		ctx.ui.setWorkingMessage(message);
 	}
 
+	function refreshPresence(ctx: ExtensionContext, settled = false): void {
+		if (ctx.mode !== "tui") return;
+		const records = activeList();
+		if (settled) {
+			ctx.ui.setWidget("pi-activity", undefined);
+			setWorkingMessage(ctx, undefined);
+			return;
+		}
+
+		if (waitingForUser || records.length) {
+			ctx.ui.setWidget(
+				"pi-activity",
+				(_tui, theme) => new ActiveToolsWidget(activeList, completedCount, () => waitingForUser, theme),
+				{ placement: "aboveEditor" },
+			);
+		} else {
+			ctx.ui.setWidget("pi-activity", undefined);
+		}
+
+		if (waitingForUser) {
+			setWorkingMessage(ctx, "Waiting for input…");
+			ctx.ui.setStatus("pi-activity", ctx.ui.theme.fg("warning", "! waiting for input"));
+			return;
+		}
+		if (records.length) {
+			const first = records[0]!;
+			const verb = TOOL_VERBS[first.name] ?? first.name.toUpperCase();
+			const message = records.length > 1
+				? `${records.length} active · ${verb} ${first.target}`
+				: `${verb} ${first.target}`;
+			setWorkingMessage(ctx, message);
+			ctx.ui.setStatus("pi-activity", ctx.ui.theme.fg("accent", `◆ ${records.length} active · ${completedCount()} done`));
+			return;
+		}
+		if (agentRunning) {
+			setWorkingMessage(ctx, "Thinking…");
+			ctx.ui.setStatus("pi-activity", ctx.ui.theme.fg("dim", "◆ thinking"));
+		} else {
+			setWorkingMessage(ctx, undefined);
+			ctx.ui.setStatus("pi-activity", ctx.ui.theme.fg("dim", `◇ ready · ${density}`));
+		}
+	}
+
 	pi.registerEntryRenderer("activity-summary", (entry, options, theme) => {
-		const data = entry.data as {
-			modifiedFiles?: string[];
-			failedActions?: string[];
-			actionCount?: number;
-			errorCount?: number;
-		} | undefined;
-		const files = data?.modifiedFiles ?? [];
-		const failures = data?.failedActions ?? [];
-		const count = (n: number, label: string) => `${n} ${label}${n === 1 ? "" : "s"}`;
-		// Legacy summaries stored categories, not counts; do not invent action totals.
-		const total = data?.actionCount === undefined ? "previous run" : count(data.actionCount, "action");
-		const errors = data?.errorCount === undefined ? count(failures.length, "error category") : count(data.errorCount, "error");
-		const title = `Activity · ${total} · ${count(files.length, "file")} · ${errors}`;
-		if (!options.expanded) return new TruncatedText(theme.fg(failures.length ? "error" : "muted", title), 0, 0);
-		const lines = [title, ...files.map((path) => `  • ${actionTarget("read", { path })}`)];
-		if (failures.length) lines.push(`Errors: ${failures.join(" · ")}`);
-		return new Text(lines.join("\n"), 0, 0);
+		return new ActivitySummaryComponent(
+			(entry.data ?? {}) as ActivitySummaryData,
+			options.expanded,
+			theme,
+		);
 	});
 
+	// Settings are persisted as invisible session entries and restored on resume/tree navigation.
+	pi.registerEntryRenderer("activity-settings", () => new Container());
+
 	function registerCompactTool<T extends TSchema, D>(createTool: (cwd: string) => AgentTool<T, D>) {
 		const initialTool = createTool(process.cwd());
 		const name = initialTool.name;
-
 		pi.registerTool({
 			...initialTool,
 			name,
@@ -88,22 +187,33 @@ export default function activityMode(pi: ExtensionAPI) {
 				return createTool(ctx.cwd).execute(toolCallId, params, signal, onUpdate);
 			},
 			renderCall(args, theme, context) {
-				const target = actionTarget(name, args as Record<string, unknown>);
-				const symbol = context.isPartial ? "·" : context.isError ? "✗" : "✓";
-				const color = context.isPartial ? "muted" : context.isError ? "error" : "success";
-				const title = `${theme.fg(color, symbol)} ${theme.fg("toolTitle", name)} · ${theme.fg("toolOutput", target)}`;
-				if (context.expanded) {
-					const text = context.lastComponent instanceof Text ? context.lastComponent : new Text("", 0, 0);
-					text.setText(title);
-					return text;
-				}
-				return new TruncatedText(title, 0, 0);
+				const id = context.toolCallId || `${name}:render`;
+				const record = ensureRecord(id, name, args as Record<string, unknown>);
+				if (context.isError && record.status === "running") record.status = "error";
+				const component = context.lastComponent instanceof ActivityRowComponent
+					? context.lastComponent
+					: new ActivityRowComponent(record, theme, () => density);
+				component.update(record, theme);
+				return component;
 			},
-			renderResult(result, { expanded }, _theme, context) {
-				if (!expanded) return new Container();
-				const text = context.lastComponent instanceof Text ? context.lastComponent : new Text("", 0, 0);
-				text.setText(detailText(result));
-				return text;
+			renderResult(result, options, theme, context) {
+				const id = context.toolCallId || `${name}:render`;
+				const record = ensureRecord(id, name, context.args as Record<string, unknown>);
+				if (!options.isPartial || context.isError) applyToolResult(record, result, context.isError);
+				else {
+					const preview = resultText(result);
+					if (preview) record.outputPreview = preview.slice(0, 2_000);
+				}
+				return renderExpandedToolResult(
+					name,
+					context.args as Record<string, unknown>,
+					result,
+					options.expanded,
+					context.isError,
+					context.showImages,
+					theme,
+					record,
+				);
 			},
 		});
 	}
@@ -116,68 +226,225 @@ export default function activityMode(pi: ExtensionAPI) {
 	registerCompactTool(createGrepTool);
 	registerCompactTool(createLsTool);
 
+	pi.registerCommand("activity", {
+		description: "Inspect recent tool activity with filters for changes, commands, and issues.",
+		handler: async (_args, ctx) => {
+			if (ctx.mode !== "tui") {
+				ctx.ui.notify("/activity requires interactive TUI mode.", "error");
+				return;
+			}
+			const currentRecords = runRecords.filter((record) => !history.some((saved) => saved.id === record.id));
+			const records = [...history, ...currentRecords].slice(-HISTORY_LIMIT);
+			if (!records.length) {
+				ctx.ui.notify("No activity has been recorded in this session yet.", "info");
+				return;
+			}
+			await ctx.ui.custom<void>((tui, theme, keybindings, done) => {
+				return new ActivityInspectorComponent(records, theme, keybindings, () => done(), () => tui.requestRender());
+			});
+		},
+	});
+
+	pi.registerCommand("activity-settings", {
+		description: "Choose minimal, balanced, or forensic activity-row density.",
+		handler: async (args, ctx) => {
+			const requested = args.trim().toLowerCase();
+			if (requested) {
+				if (!isDensity(requested)) {
+					if (ctx.hasUI) ctx.ui.notify("Usage: /activity-settings [minimal|balanced|forensic]", "error");
+					return;
+				}
+				density = requested;
+				pi.appendEntry("activity-settings", { density });
+				if (ctx.mode === "tui") {
+					ctx.ui.setStatus("pi-activity", ctx.ui.theme.fg("dim", `Activity · ${density}`));
+					ctx.ui.notify(`Activity density set to ${density}.`, "info");
+				}
+				return;
+			}
+			if (ctx.mode !== "tui") {
+				if (ctx.hasUI) ctx.ui.notify("Pass a density: /activity-settings [minimal|balanced|forensic]", "error");
+				return;
+			}
+			const items: SettingItem[] = [{
+				id: "density",
+				label: "Activity density",
+				description: "Minimal hides metadata; balanced shows outcomes; forensic adds category and truncation evidence.",
+				currentValue: density,
+				values: DENSITIES,
+			}];
+			await ctx.ui.custom<void>((tui, theme, _keybindings, done) => {
+				const container = new Container();
+				container.addChild(new Text(theme.fg("accent", theme.bold("Activity settings")), 1, 1));
+				const settings = new SettingsList(
+					items,
+					3,
+					getSettingsListTheme(),
+					(id, value) => {
+						if (id !== "density" || !isDensity(value)) return;
+						density = value;
+						settings.updateValue(id, value);
+						pi.appendEntry("activity-settings", { density });
+						ctx.ui.setStatus("pi-activity", theme.fg("dim", `Activity · ${density}`));
+						tui.requestRender();
+					},
+					() => done(),
+				);
+				container.addChild(settings);
+				container.addChild(new Text(theme.fg("dim", `${keyHint("tui.select.confirm", "change")} · ${keyHint("tui.select.cancel", "close")}`), 1, 1));
+				return {
+					render: (width) => container.render(width),
+					invalidate: () => container.invalidate(),
+					handleInput: (data) => {
+						settings.handleInput(data);
+						tui.requestRender();
+					},
+				};
+			});
+		},
+	});
+
 	pi.on("session_start", (_event, ctx) => {
-		activeTools.clear();
+		runStartedAt = undefined;
+		agentRunning = false;
+		waitingForUser = false;
 		lastWorkingMessage = undefined;
+		runRecords = [];
+		recordsById.clear();
+		activeRecords.clear();
+		reconstructSessionState(ctx);
 		if (ctx.mode !== "tui") return;
 		ctx.ui.setToolsExpanded(false);
-		ctx.ui.setWorkingIndicator({ frames: SPINNER_FRAMES, intervalMs: 160 });
+		ctx.ui.setStatus("pi-activity", ctx.ui.theme.fg("dim", `◇ ready · ${density}`));
+	});
+
+	pi.on("session_tree", (_event, ctx) => {
+		activeRecords.clear();
+		recordsById.clear();
+		runRecords = [];
+		runStartedAt = undefined;
+		agentRunning = false;
+		reconstructSessionState(ctx);
+		if (ctx.mode === "tui") {
+			ctx.ui.setWidget("pi-activity", undefined);
+			setWorkingMessage(ctx, undefined);
+			ctx.ui.setStatus("pi-activity", ctx.ui.theme.fg("dim", `◇ ready · ${density}`));
+		}
 	});
 
 	pi.on("session_shutdown", (_event, ctx) => {
-		activeTools.clear();
-		refreshWorkingMessage(ctx, true);
+		activeRecords.clear();
+		agentRunning = false;
+		waitingForUser = false;
 		if (ctx.mode !== "tui") return;
-		ctx.ui.setWorkingIndicator();
+		ctx.ui.setWidget("pi-activity", undefined);
+		ctx.ui.setStatus("pi-activity", undefined);
+		setWorkingMessage(ctx, undefined);
 	});
 
 	pi.on("agent_start", (_event, ctx) => {
-		// A retry can emit another agent_start before the overall run settles.
-		activeTools.clear();
-		refreshWorkingMessage(ctx);
+		activeRecords.clear();
+		agentRunning = true;
+		waitingForUser = false;
+		runStartedAt ??= Date.now();
+		refreshPresence(ctx);
 	});
 
-	pi.on("tool_execution_start", (event, ctx) => {
-		const target = actionTarget(event.toolName, event.args ?? {});
-		activeTools.set(event.toolCallId, truncateToWidth(`${event.toolName} · ${target}`, 72));
-		refreshWorkingMessage(ctx);
+	pi.on("ui_prompt_start", (_event, ctx) => {
+		waitingForUser = true;
+		refreshPresence(ctx);
 	});
 
-	pi.on("tool_execution_end", (event, ctx) => {
-		activeTools.delete(event.toolCallId);
-		refreshWorkingMessage(ctx);
-		actionCount++;
-		if (event.isError) {
-			errorCount++;
-			failedActions.add(event.toolName);
-			return;
-		}
-		completedActions.add(event.toolName);
+	pi.on("ui_prompt_end", (_event, ctx) => {
+		waitingForUser = false;
+		refreshPresence(ctx);
+	});
 
+	pi.on("tool_execution_start", (event, ctx) => {
+		agentRunning = true;
+		const record = ensureRecord(event.toolCallId, event.toolName, event.args ?? {}, Date.now());
+		record.status = "running";
+		record.startedAt = Date.now();
+		record.endedAt = undefined;
+		record.durationMs = undefined;
+		activeRecords.set(event.toolCallId, record);
+		refreshPresence(ctx);
+	});
+
+	pi.on("tool_execution_update", (event) => {
+		const record = ensureRecord(event.toolCallId, event.toolName, event.args ?? {});
+		const preview = resultText(event.partialResult);
+		if (preview) record.outputPreview = preview.slice(0, 2_000);
 	});
 
 	pi.on("tool_result", (event) => {
-		if (!event.isError && (event.toolName === "edit" || event.toolName === "write") && typeof event.input.path === "string") {
-			modifiedFiles.add(event.input.path);
+		const record = ensureRecord(event.toolCallId, event.toolName, event.input ?? {});
+		applyToolResult(record, { content: event.content, details: event.details }, event.isError);
+	});
+
+	pi.on("tool_execution_end", (event, ctx) => {
+		const record = ensureRecord(event.toolCallId, event.toolName);
+		if (event.result) {
+			finishRecord(record, Date.now(), event.result, event.isError);
+		} else {
+			record.endedAt = Date.now();
+			record.durationMs = Math.max(0, record.endedAt - record.startedAt);
+			if (record.status === "running") applyToolResult(record, { content: [] }, event.isError);
 		}
+		activeRecords.delete(event.toolCallId);
+		refreshPresence(ctx);
 	});
 
-	pi.on("turn_start", (_event, ctx) => refreshWorkingMessage(ctx));
+	pi.on("turn_start", (_event, ctx) => {
+		agentRunning = true;
+		refreshPresence(ctx);
+	});
 
 	pi.on("agent_settled", (_event, ctx) => {
-		activeTools.clear();
-		refreshWorkingMessage(ctx, true);
-		if (ctx.mode === "tui" && actionCount > 0) pi.appendEntry("activity-summary", {
-			actionCount,
-			errorCount,
-			modifiedFiles: [...modifiedFiles],
-			completedActions: [...completedActions],
-			failedActions: [...failedActions],
-		});
-		actionCount = 0;
-		errorCount = 0;
-		modifiedFiles.clear();
-		completedActions.clear();
-		failedActions.clear();
+		const settledAt = Date.now();
+		agentRunning = false;
+		for (const record of runRecords) {
+			if (record.status !== "running") continue;
+			record.status = "cancelled";
+			record.outcome = "interrupted";
+			record.endedAt = settledAt;
+			record.durationMs = Math.max(0, settledAt - record.startedAt);
+		}
+		activeRecords.clear();
+		waitingForUser = false;
+		refreshPresence(ctx, true);
+
+		const records = runRecords.map(snapshotRecord);
+		if (records.length && ctx.mode === "tui") {
+			const categoryCounts: Partial<Record<ActivityCategory, number>> = {};
+			for (const record of records) categoryCounts[record.category] = (categoryCounts[record.category] ?? 0) + 1;
+			const errors = records.filter((record) => record.status === "error");
+			const cancelled = records.filter((record) => record.status === "cancelled");
+			const data: ActivitySummaryData = {
+				version: 2,
+				startedAt: runStartedAt ?? records[0]!.startedAt,
+				durationMs: Math.max(0, settledAt - (runStartedAt ?? records[0]!.startedAt)),
+				actionCount: records.length,
+				errorCount: errors.length,
+				cancelledCount: cancelled.length,
+				truncatedCount: records.filter((record) => record.truncated).length,
+				modifiedFiles: aggregateFileChanges(records),
+				completedActions: unique(records.filter((record) => record.status === "success").map((record) => record.name)),
+				failedActions: unique([...errors, ...cancelled].map((record) => record.name)),
+				categoryCounts,
+				records,
+			};
+			pi.appendEntry("activity-summary", data);
+			history = [...history, ...runRecords].slice(-HISTORY_LIMIT);
+			const issueCount = data.errorCount + data.cancelledCount;
+			const status = issueCount
+				? ctx.ui.theme.fg("warning", `! ${data.actionCount} actions · ${issueCount} issues · ${formatDuration(data.durationMs)}`)
+				: ctx.ui.theme.fg("success", `✓ ${data.actionCount} actions · ${data.modifiedFiles.length} files · ${formatDuration(data.durationMs)}`);
+			ctx.ui.setStatus("pi-activity", status);
+		}
+
+		runRecords = [];
+		recordsById.clear();
+		runStartedAt = undefined;
 	});
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prjct.app/pi-activity",
-  "version": "0.1.3",
+  "version": "0.2.1",
   "description": "Keep PI Agent tool output readable with compact, expandable activity rows and summaries of actions, errors, and changed files.",
   "type": "module",
   "keywords": [
@@ -59,10 +59,12 @@
   },
   "files": [
     "index.ts",
+    "src",
     "README.md",
     "LICENSE",
     "CONTRIBUTING.md",
     "CHANGELOG.md",
-    "docs/package.md"
+    "docs/package.md",
+    "docs/releases.md"
   ]
 }