@gajae-code/coding-agent 0.12.0 → 0.12.2

package/src/modes/components/session-observer-overlay.ts

@@ -1,6 +1,6 @@
 import * as crypto from "node:crypto";
 import * as fs from "node:fs";
-import type { ToolResultMessage } from "@gajae-code/ai";
+import type { ToolCall, ToolResultMessage } from "@gajae-code/ai";
 import { matchesKey } from "@gajae-code/tui";
 import { formatDuration, formatNumber } from "@gajae-code/utils";
 import type { KeyId } from "../../config/keybindings";
@@ -19,7 +19,19 @@ import { type TranscriptViewerEntry, TranscriptViewerOverlay } from "./transcrip
 const FATAL_UTF8_DECODER = new TextDecoder("utf-8", { fatal: true });
 
 type FileIdentity = { dev: bigint; ino: bigint };
-type StableSnapshot = { identity: FileIdentity; size: number; prefix: Buffer; tail: Buffer };
+type StableSnapshot = {
+	identity: FileIdentity;
+	size: number;
+	prefix: Buffer;
+	tail: Buffer;
+	offsetReset: boolean;
+};
+type SnapshotReadResult =
+	| { status: "stable"; snapshot: StableSnapshot }
+	| { status: "unstable" }
+	| { status: "unavailable" };
+
+class UnstableSnapshotError extends Error {}
 type ObserverCache = {
 	path: string;
 	identity: FileIdentity;
@@ -27,8 +39,56 @@ type ObserverCache = {
 	prefixDigest: string;
 	entries: SessionMessageEntry[];
 	model?: string;
+	projectedCount: number;
+	projectedOutput: TranscriptViewerEntry[];
+	toolCallOutputIndex: Map<string, number>;
+	projectionSafe: boolean;
 };
 
+type ProjectionState = Pick<
+	ObserverCache,
+	"projectedCount" | "projectedOutput" | "toolCallOutputIndex" | "projectionSafe"
+>;
+type ProjectionUpdate = { state: ProjectionState; preserveLayoutCache: boolean };
+
+export const __sessionObserverProjectionCounters = {
+	enabled: false,
+	projectionFullRuns: 0,
+	projectionIncrementalRuns: 0,
+	sourceMessagesProjected: 0,
+	projectedEntriesAppended: 0,
+	resultPatchCount: 0,
+	snapshot() {
+		return {
+			projectionFullRuns: this.projectionFullRuns,
+			projectionIncrementalRuns: this.projectionIncrementalRuns,
+			sourceMessagesProjected: this.sourceMessagesProjected,
+			projectedEntriesAppended: this.projectedEntriesAppended,
+			resultPatchCount: this.resultPatchCount,
+		};
+	},
+	enable(): void {
+		this.enabled = true;
+	},
+	disable(): void {
+		this.enabled = false;
+	},
+	reset(): void {
+		this.projectionFullRuns = 0;
+		this.projectionIncrementalRuns = 0;
+		this.sourceMessagesProjected = 0;
+		this.projectedEntriesAppended = 0;
+		this.resultPatchCount = 0;
+	},
+};
+
+function recordProjectionCounter(
+	counter: keyof ReturnType<typeof __sessionObserverProjectionCounters.snapshot>,
+	amount = 1,
+): void {
+	if (__sessionObserverProjectionCounters.enabled) __sessionObserverProjectionCounters[counter] += amount;
+}
+
 /** Session-observer adapter. The shared viewer owns navigation and fold state. */
 export class SessionObserverOverlayComponent extends TranscriptViewerOverlay {
 	#registry: SessionObserverRegistry;
@@ -62,11 +122,21 @@ export class SessionObserverOverlayComponent extends TranscriptViewerOverlay {
 		this.#observeKeys = observeKeys;
 		this.#selectedSessionId = this.#mostRecent()?.id;
 		if (!this.#selectedSessionId) queueMicrotask(onDone);
-		this.refresh();
+		this.#refreshCurrentSource();
 	}
 
 	refreshFromRegistry(): void {
-		this.refresh();
+		this.#refreshCurrentSource();
+	}
+	#refreshCurrentSource(): void {
+		const session = this.#registry.getSessions().find(candidate => candidate.id === this.#selectedSessionId);
+		if (!session?.sessionFile) {
+			this.#clearSource();
+			this.refresh(undefined, false);
+			return;
+		}
+		const preserveLayoutCache = this.#load(session.sessionFile);
+		this.refresh(undefined, preserveLayoutCache);
 	}
 	override handleInput(keyData: string): void {
 		if (this.#observeKeys.some(key => matchesKey(keyData, key))) {
@@ -100,12 +170,10 @@ export class SessionObserverOverlayComponent extends TranscriptViewerOverlay {
 		this.#selectedSessionId = ids[(current + direction + ids.length) % ids.length];
 		this.#cache = undefined;
 		this.resetSourceState();
-		this.refresh();
+		this.#refreshCurrentSource();
 	}
 	#entries(): readonly TranscriptViewerEntry[] {
-		const session = this.#registry.getSessions().find(candidate => candidate.id === this.#selectedSessionId);
-		if (!session?.sessionFile) return [];
-		return entriesFromMessages(this.#load(session.sessionFile));
+		return this.#cache?.projectedOutput ?? [];
 	}
 	#headerLines(): string[] {
 		const session = this.#registry.getSessions().find(candidate => candidate.id === this.#selectedSessionId);
@@ -139,71 +207,146 @@ export class SessionObserverOverlayComponent extends TranscriptViewerOverlay {
 		if (progress.cost > 0) stats.push(`$${progress.cost.toFixed(2)}`);
 		return stats.length ? [theme.fg("dim", stats.join(theme.sep.dot))] : [];
 	}
-	#load(filePath: string): SessionMessageEntry[] {
+	#load(filePath: string): boolean {
 		if (this.#cache && this.#cache.path !== filePath) {
 			this.#cache = undefined;
 			this.resetSourceState();
 		}
 
 		const cache = this.#cache;
-		const snapshot = readStableSnapshot(filePath, cache?.completeOffset ?? 0);
-		if (!snapshot) {
-			// An unreadable source is never allowed to keep presenting a prior file as current.
+		const read = readStableSnapshot(filePath, cache?.completeOffset ?? 0);
+		if (read.status === "unstable") return cache !== undefined;
+		if (read.status === "unavailable") {
 			if (cache) this.#clearSource();
-			return [];
+			return false;
 		}
-
+		const snapshot = read.snapshot;
 		const canAppend =
 			cache &&
+			!snapshot.offsetReset &&
 			sameIdentity(cache.identity, snapshot.identity) &&
 			snapshot.size >= cache.completeOffset &&
 			digest(snapshot.prefix) === cache.prefixDigest;
 		if (canAppend) return this.#appendStable(cache, snapshot);
 
-		// A changed fd identity, changed committed bytes, or a shrink is a replacement.
-		// Validate the entire candidate before it replaces the visible transcript.
-		const replacement = readStableSnapshot(filePath, 0);
-		if (!replacement) {
-			this.#clearSource();
-			return [];
-		}
-		const candidate = cacheEntries(filePath, replacement);
+		const candidate = cacheEntries(filePath, asFullSnapshot(snapshot));
 		if (!candidate) {
 			this.#clearSource();
-			return [];
+			return false;
 		}
 		this.#cache = candidate;
 		if (cache) this.resetSourceState();
-		return candidate.entries;
+		return false;
 	}
-	#appendStable(cache: ObserverCache, snapshot: StableSnapshot): SessionMessageEntry[] {
+	#appendStable(cache: ObserverCache, snapshot: StableSnapshot): boolean {
 		const complete = completePrefix(snapshot.tail);
 		if (!complete) {
 			if (!isValidUtf8Prefix(snapshot.tail)) {
 				this.#clearSource();
-				return [];
+				return false;
 			}
-			return cache.entries;
+			return true;
 		}
 		const remainder = snapshot.tail.subarray(complete.bytes.length);
 		if (!isValidUtf8Prefix(remainder)) {
 			this.#clearSource();
-			return [];
+			return false;
 		}
 		const parsed = parseCompleteEntries(complete.bytes);
 		if (!parsed) {
 			this.#clearSource();
-			return [];
+			return false;
 		}
+		if (parsed.hasPatchRecords) {
+			const candidate = cacheEntries(cache.path, asFullSnapshot(snapshot));
+			if (!candidate) {
+				this.#clearSource();
+				return false;
+			}
+			this.#cache = candidate;
+			return false;
+		}
+
 		const entries = [...cache.entries, ...parsed.entries];
+		const projection = this.#appendProjection(cache, parsed.entries);
 		this.#cache = {
 			...cache,
 			completeOffset: cache.completeOffset + complete.bytes.length,
 			prefixDigest: digest(Buffer.concat([snapshot.prefix, complete.bytes])),
 			entries,
 			model: parsed.model ?? cache.model,
+			...projection.state,
+		};
+		return projection.preserveLayoutCache;
+	}
+	#appendProjection(cache: ObserverCache, suffix: readonly SessionMessageEntry[]): ProjectionUpdate {
+		if (suffix.length === 0) {
+			return {
+				state: projectionState(cache),
+				preserveLayoutCache: true,
+			};
+		}
+		if (!cache.projectionSafe || cache.projectedCount !== cache.entries.length) {
+			return {
+				state: fullProjection([...cache.entries, ...suffix]),
+				preserveLayoutCache: false,
+			};
+		}
+
+		const projectedOutput = [...cache.projectedOutput];
+		const toolCallOutputIndex = new Map(cache.toolCallOutputIndex);
+		const patchedIds: string[] = [];
+		let appendedCount = 0;
+		let patchCount = 0;
+		for (const entry of suffix) {
+			const message = entry.message;
+			if (message.role === "toolResult") {
+				const index = toolCallOutputIndex.get(message.toolCallId);
+				const existing = index === undefined ? undefined : projectedOutput[index];
+				const source = existing?.payload.source;
+				const call = isToolProjectionSource(source) ? source.call : undefined;
+				if (index === undefined || !call) {
+					return {
+						state: fullProjection([...cache.entries, ...suffix]),
+						preserveLayoutCache: false,
+					};
+				}
+				projectedOutput[index] = toolEntry(call, message);
+				patchedIds.push(projectedOutput[index].id);
+				patchCount++;
+				continue;
+			}
+
+			const appended = entriesFromMessages([entry]);
+			for (const outputEntry of appended) {
+				if (outputEntry.id.startsWith("tool:")) {
+					const callId = outputEntry.id.slice("tool:".length);
+					if (toolCallOutputIndex.has(callId)) {
+						return {
+							state: fullProjection([...cache.entries, ...suffix]),
+							preserveLayoutCache: false,
+						};
+					}
+					toolCallOutputIndex.set(callId, projectedOutput.length);
+				}
+				projectedOutput.push(outputEntry);
+			}
+			appendedCount += appended.length;
+		}
+		if (patchedIds.length > 0) this.invalidateLayoutEntries(patchedIds);
+		recordProjectionCounter("projectionIncrementalRuns");
+		recordProjectionCounter("sourceMessagesProjected", suffix.length);
+		recordProjectionCounter("projectedEntriesAppended", appendedCount);
+		recordProjectionCounter("resultPatchCount", patchCount);
+		return {
+			state: {
+				projectedCount: cache.projectedCount + suffix.length,
+				projectedOutput,
+				toolCallOutputIndex,
+				projectionSafe: true,
+			},
+			preserveLayoutCache: true,
 		};
-		return entries;
 	}
 	#clearSource(): void {
 		if (this.#cache) this.resetSourceState();
@@ -211,6 +354,95 @@ export class SessionObserverOverlayComponent extends TranscriptViewerOverlay {
 	}
 }
 
+type ToolProjectionSource = { call: ToolCall; result?: ToolResultMessage };
+
+function isToolProjectionSource(source: unknown): source is ToolProjectionSource {
+	if (!source || typeof source !== "object" || !("call" in source)) return false;
+	const call = source.call;
+	return Boolean(call && typeof call === "object" && "type" in call && call.type === "toolCall");
+}
+
+function projectionState(cache: ObserverCache): ProjectionState {
+	return {
+		projectedCount: cache.projectedCount,
+		projectedOutput: cache.projectedOutput,
+		toolCallOutputIndex: cache.toolCallOutputIndex,
+		projectionSafe: cache.projectionSafe,
+	};
+}
+
+function fullProjection(
+	entries: readonly SessionMessageEntry[],
+): Pick<ObserverCache, "projectedCount" | "projectedOutput" | "toolCallOutputIndex" | "projectionSafe"> {
+	const projectedOutput = entriesFromMessages(entries);
+	const toolCallOutputIndex = new Map<string, number>();
+	let projectionSafe = true;
+	const knownToolCallIds = new Set<string>();
+	const unresolvedToolResultIds = new Set<string>();
+	for (const entry of entries) {
+		const message = entry.message;
+		if (message.role === "assistant") {
+			for (const content of message.content) if (content.type === "toolCall") knownToolCallIds.add(content.id);
+		} else if (message.role === "toolResult") unresolvedToolResultIds.add(message.toolCallId);
+	}
+	for (const callId of knownToolCallIds) unresolvedToolResultIds.delete(callId);
+	if (unresolvedToolResultIds.size > 0) projectionSafe = false;
+	for (let index = 0; index < projectedOutput.length; index++) {
+		const id = projectedOutput[index].id;
+		if (!id.startsWith("tool:")) continue;
+		const callId = id.slice("tool:".length);
+		if (toolCallOutputIndex.has(callId)) projectionSafe = false;
+		else toolCallOutputIndex.set(callId, index);
+	}
+	recordProjectionCounter("projectionFullRuns");
+	recordProjectionCounter("sourceMessagesProjected", entries.length);
+	return { projectedCount: entries.length, projectedOutput, toolCallOutputIndex, projectionSafe };
+}
+
+function toolEntry(call: ToolCall, result?: ToolResultMessage): TranscriptViewerEntry {
+	const resultText =
+		result?.content
+			.filter(part => part.type === "text")
+			.map(part => part.text)
+			.join("\n")
+			.trim() ?? "";
+	const hasResult = result !== undefined;
+	const canonicalPayload = {
+		text: composeToolText({
+			name: call.name,
+			args: call.arguments,
+			intent: call.intent,
+			resultText,
+			isError: result?.isError ?? false,
+			hasResult,
+		}),
+		metadata: {
+			name: call.name,
+			arguments: call.arguments,
+			intent: call.intent,
+			resultText,
+			isError: result?.isError ?? false,
+			hasResult,
+			detailsData: result?.details,
+		},
+		source: { call, result },
+	};
+	return buildToolTranscriptEntry({
+		canonicalPayload,
+		renderDescriptor: createToolTranscriptRenderDescriptor({
+			name: call.name,
+			args: call.arguments,
+			intent: call.intent,
+			resultContent: resultText,
+			isError: result?.isError,
+			hasResult,
+			detailsData: result?.details,
+		}),
+		capabilities: { copyable: true, foldable: true, rawViewable: true },
+		identity: { id: `tool:${call.id}`, label: call.name, display: "full" },
+	});
+}
+
 /**
  * This deliberately remains the eager full-history projection. PR2 owns projection
  * virtualization/incrementalization; source acquisition above only controls snapshot safety.
@@ -249,51 +481,7 @@ export function entriesFromMessages(entries: readonly SessionMessageEntry[]): Tr
 						payload: { text: content.text, metadata: {}, source: content },
 						foldable: true,
 					});
-				if (content.type === "toolCall") {
-					const result = results.get(content.id);
-					const resultText =
-						result?.content
-							.filter(part => part.type === "text")
-							.map(part => part.text)
-							.join("\n")
-							.trim() ?? "";
-					const canonicalPayload = {
-						text: composeToolText({
-							name: content.name,
-							args: content.arguments,
-							intent: content.intent,
-							resultText,
-							isError: result?.isError ?? false,
-							hasResult: results.has(content.id),
-						}),
-						metadata: {
-							name: content.name,
-							arguments: content.arguments,
-							intent: content.intent,
-							resultText,
-							isError: result?.isError ?? false,
-							hasResult: results.has(content.id),
-							detailsData: result?.details,
-						},
-						source: { call: content, result },
-					};
-					output.push(
-						buildToolTranscriptEntry({
-							canonicalPayload,
-							renderDescriptor: createToolTranscriptRenderDescriptor({
-								name: content.name,
-								args: content.arguments,
-								intent: content.intent,
-								resultContent: resultText,
-								isError: result?.isError,
-								hasResult: results.has(content.id),
-								detailsData: result?.details,
-							}),
-							capabilities: { copyable: true, foldable: true, rawViewable: true },
-							identity: { id: `tool:${content.id}`, label: content.name, display: "full" },
-						}),
-					);
-				}
+				if (content.type === "toolCall") output.push(toolEntry(content, results.get(content.id)));
 			});
 		}
 		if (message.role === "user" || message.role === "developer") {
@@ -322,15 +510,17 @@ function truncateThinking(text: string, expanded: boolean): string {
 	return text.length > limit ? `${text.slice(0, limit)}...` : text;
 }
 
-function readStableSnapshot(filePath: string, completeOffset: number): StableSnapshot | null {
+function readStableSnapshot(filePath: string, completeOffset: number): SnapshotReadResult {
 	let fd: number | undefined;
 	try {
 		fd = fs.openSync(filePath, "r");
 		const before = fs.fstatSync(fd, { bigint: true });
-		if (before.size > BigInt(Number.MAX_SAFE_INTEGER) || completeOffset > Number(before.size)) return null;
+		if (before.size > BigInt(Number.MAX_SAFE_INTEGER)) return { status: "unavailable" };
 		const size = Number(before.size);
-		const prefix = readExactly(fd, 0, completeOffset);
-		const tail = readExactly(fd, completeOffset, size - completeOffset);
+		const offsetReset = completeOffset > size;
+		const offset = offsetReset ? 0 : completeOffset;
+		const prefix = readExactly(fd, 0, offset);
+		const tail = readExactly(fd, offset, size - offset);
 		const after = fs.fstatSync(fd, { bigint: true });
 		if (
 			before.dev !== after.dev ||
@@ -339,21 +529,34 @@ function readStableSnapshot(filePath: string, completeOffset: number): StableSna
 			before.mtimeNs !== after.mtimeNs ||
 			before.ctimeNs !== after.ctimeNs
 		)
-			return null;
-		return { identity: { dev: before.dev, ino: before.ino }, size, prefix, tail };
-	} catch {
-		return null;
+			return { status: "unstable" };
+		return {
+			status: "stable",
+			snapshot: { identity: { dev: before.dev, ino: before.ino }, size, prefix, tail, offsetReset },
+		};
+	} catch (err) {
+		return err instanceof UnstableSnapshotError ? { status: "unstable" } : { status: "unavailable" };
 	} finally {
 		if (fd !== undefined) fs.closeSync(fd);
 	}
 }
 
+function asFullSnapshot(snapshot: StableSnapshot): StableSnapshot {
+	if (snapshot.prefix.length === 0) return snapshot;
+	return {
+		...snapshot,
+		prefix: Buffer.alloc(0),
+		tail: Buffer.concat([snapshot.prefix, snapshot.tail]),
+		offsetReset: true,
+	};
+}
+
 function readExactly(fd: number, position: number, length: number): Buffer {
 	const buffer = Buffer.alloc(length);
 	let offset = 0;
 	while (offset < length) {
 		const bytesRead = fs.readSync(fd, buffer, offset, length - offset, position + offset);
-		if (bytesRead === 0) throw new Error("Short session file read");
+		if (bytesRead === 0) throw new UnstableSnapshotError("Short session file read");
 		offset += bytesRead;
 	}
 	return buffer;
@@ -372,14 +575,28 @@ function completePrefix(bytes: Buffer): { bytes: Buffer } | undefined {
 	return newline < 0 ? undefined : { bytes: bytes.subarray(0, newline + 1) };
 }
 
-function parseCompleteEntries(bytes: Buffer): { entries: SessionMessageEntry[]; model?: string } | null {
+function parseCompleteEntries(
+	bytes: Buffer,
+): { entries: SessionMessageEntry[]; model?: string; hasPatchRecords: boolean } | null {
 	try {
 		const text = FATAL_UTF8_DECODER.decode(bytes);
-		for (const line of text.split("\n")) if (line.trim()) JSON.parse(line);
+		let hasPatchRecords = false;
+		for (const line of text.split("\n")) {
+			if (!line.trim()) continue;
+			const record: unknown = JSON.parse(line);
+			if (
+				record !== null &&
+				typeof record === "object" &&
+				"type" in record &&
+				(record.type === "entry_patch" || record.type === "header_patch")
+			)
+				hasPatchRecords = true;
+		}
 		const parsed = parseSessionEntries(text);
 		return {
 			entries: parsed.filter((entry): entry is SessionMessageEntry => entry.type === "message"),
 			model: modelFromEntries(parsed),
+			hasPatchRecords,
 		};
 	} catch {
 		return null;
@@ -415,6 +632,7 @@ function cacheEntries(filePath: string, snapshot: StableSnapshot): ObserverCache
 			completeOffset: 0,
 			prefixDigest: digest(Buffer.alloc(0)),
 			entries: [],
+			...fullProjection([]),
 		};
 	}
 	const remainder = snapshot.tail.subarray(complete.bytes.length);
@@ -428,5 +646,6 @@ function cacheEntries(filePath: string, snapshot: StableSnapshot): ObserverCache
 		prefixDigest: digest(complete.bytes),
 		entries: parsed.entries,
 		model: parsed.model,
+		...fullProjection(parsed.entries),
 	};
 }