@gajae-code/coding-agent 0.11.11 → 0.12.1

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

@@ -1,10 +1,11 @@
+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";
 import { isSilentAbort } from "../../session/messages";
-import type { SessionMessageEntry } from "../../session/session-manager";
+import type { FileEntry, SessionMessageEntry } from "../../session/session-manager";
 import { parseSessionEntries } from "../../session/session-manager";
 import type { ObservableSession, SessionObserverRegistry } from "../session-observer-registry";
 import { theme } from "../theme/theme";
@@ -15,13 +16,86 @@ import {
 } from "./tool-transcript-format";
 import { type TranscriptViewerEntry, TranscriptViewerOverlay } from "./transcript-viewer-overlay";
 
+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;
+	offsetReset: boolean;
+};
+type SnapshotReadResult =
+	| { status: "stable"; snapshot: StableSnapshot }
+	| { status: "unstable" }
+	| { status: "unavailable" };
+
+class UnstableSnapshotError extends Error {}
+type ObserverCache = {
+	path: string;
+	identity: FileIdentity;
+	completeOffset: number;
+	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;
 	#onDone: () => void;
 	#observeKeys: readonly KeyId[];
 	#selectedSessionId?: string;
-	#cache?: { path: string; bytesRead: number; entries: SessionMessageEntry[]; model?: string };
+	#cache?: ObserverCache;
 
 	constructor(registry: SessionObserverRegistry, onDone: () => void, observeKeys: KeyId[]) {
 		// The option closures run during the base constructor's initial refresh,
@@ -48,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))) {
@@ -86,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);
@@ -125,33 +207,246 @@ 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[] {
-		if (this.#cache?.path !== filePath) this.#cache = undefined;
-		const fromByte = this.#cache?.bytesRead ?? 0;
-		const result = readFileIncremental(filePath, fromByte);
-		if (!result) return this.#cache?.entries ?? [];
-		if (result.newSize < fromByte) {
+	#load(filePath: string): boolean {
+		if (this.#cache && this.#cache.path !== filePath) {
 			this.#cache = undefined;
-			return this.#load(filePath);
+			this.resetSourceState();
+		}
+
+		const cache = this.#cache;
+		const read = readStableSnapshot(filePath, cache?.completeOffset ?? 0);
+		if (read.status === "unstable") return cache !== undefined;
+		if (read.status === "unavailable") {
+			if (cache) this.#clearSource();
+			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);
+
+		const candidate = cacheEntries(filePath, asFullSnapshot(snapshot));
+		if (!candidate) {
+			this.#clearSource();
+			return false;
+		}
+		this.#cache = candidate;
+		if (cache) this.resetSourceState();
+		return false;
+	}
+	#appendStable(cache: ObserverCache, snapshot: StableSnapshot): boolean {
+		const complete = completePrefix(snapshot.tail);
+		if (!complete) {
+			if (!isValidUtf8Prefix(snapshot.tail)) {
+				this.#clearSource();
+				return false;
+			}
+			return true;
+		}
+		const remainder = snapshot.tail.subarray(complete.bytes.length);
+		if (!isValidUtf8Prefix(remainder)) {
+			this.#clearSource();
+			return false;
 		}
-		if (!this.#cache) this.#cache = { path: filePath, bytesRead: 0, entries: [] };
-		if (result.text) {
-			const lastNewline = result.text.lastIndexOf("\n");
-			if (lastNewline >= 0) {
-				const complete = result.text.slice(0, lastNewline + 1);
-				for (const entry of parseSessionEntries(complete)) {
-					if (entry.type === "message") {
-						this.#cache.entries.push(entry);
-						if (!this.#cache.model && entry.message.role === "assistant") this.#cache.model = entry.message.model;
-					} else if (entry.type === "model_change") this.#cache.model = entry.model;
+		const parsed = parseCompleteEntries(complete.bytes);
+		if (!parsed) {
+			this.#clearSource();
+			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);
 				}
-				this.#cache.bytesRead = fromByte + Buffer.byteLength(complete, "utf-8");
+				projectedOutput.push(outputEntry);
 			}
+			appendedCount += appended.length;
 		}
-		return this.#cache.entries;
+		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,
+		};
 	}
+	#clearSource(): void {
+		if (this.#cache) this.resetSourceState();
+		this.#cache = undefined;
+	}
+}
+
+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.
+ */
 export function entriesFromMessages(entries: readonly SessionMessageEntry[]): TranscriptViewerEntry[] {
 	const results = new Map<string, ToolResultMessage>();
 	for (const entry of entries)
@@ -186,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") {
@@ -259,19 +510,142 @@ function truncateThinking(text: string, expanded: boolean): string {
 	return text.length > limit ? `${text.slice(0, limit)}...` : text;
 }
 
-function readFileIncremental(filePath: string, fromByte: number): { text: string; newSize: number } | null {
+function readStableSnapshot(filePath: string, completeOffset: number): SnapshotReadResult {
+	let fd: number | undefined;
 	try {
-		const stat = fs.statSync(filePath);
-		if (stat.size <= fromByte) return { text: "", newSize: stat.size };
-		const buffer = Buffer.alloc(stat.size - fromByte);
-		const fd = fs.openSync(filePath, "r");
-		try {
-			fs.readSync(fd, buffer, 0, buffer.length, fromByte);
-		} finally {
-			fs.closeSync(fd);
+		fd = fs.openSync(filePath, "r");
+		const before = fs.fstatSync(fd, { bigint: true });
+		if (before.size > BigInt(Number.MAX_SAFE_INTEGER)) return { status: "unavailable" };
+		const size = Number(before.size);
+		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 ||
+			before.ino !== after.ino ||
+			before.size !== after.size ||
+			before.mtimeNs !== after.mtimeNs ||
+			before.ctimeNs !== after.ctimeNs
+		)
+			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 UnstableSnapshotError("Short session file read");
+		offset += bytesRead;
+	}
+	return buffer;
+}
+
+function sameIdentity(left: FileIdentity, right: FileIdentity): boolean {
+	return left.dev === right.dev && left.ino === right.ino;
+}
+
+function digest(bytes: Buffer): string {
+	return crypto.createHash("sha256").update(bytes).digest("hex");
+}
+
+function completePrefix(bytes: Buffer): { bytes: Buffer } | undefined {
+	const newline = bytes.lastIndexOf(0x0a);
+	return newline < 0 ? undefined : { bytes: bytes.subarray(0, newline + 1) };
+}
+
+function parseCompleteEntries(
+	bytes: Buffer,
+): { entries: SessionMessageEntry[]; model?: string; hasPatchRecords: boolean } | null {
+	try {
+		const text = FATAL_UTF8_DECODER.decode(bytes);
+		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;
 		}
-		return { text: buffer.toString("utf-8"), newSize: stat.size };
+		const parsed = parseSessionEntries(text);
+		return {
+			entries: parsed.filter((entry): entry is SessionMessageEntry => entry.type === "message"),
+			model: modelFromEntries(parsed),
+			hasPatchRecords,
+		};
 	} catch {
 		return null;
 	}
 }
+
+function modelFromEntries(entries: readonly FileEntry[]): string | undefined {
+	let model: string | undefined;
+	for (const entry of entries) {
+		if (entry.type === "model_change") model = entry.model;
+		else if (entry.type === "message" && entry.message.role === "assistant" && entry.message.model)
+			model = entry.message.model;
+	}
+	return model;
+}
+
+function isValidUtf8Prefix(bytes: Buffer): boolean {
+	try {
+		new TextDecoder("utf-8", { fatal: true }).decode(bytes, { stream: true });
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+function cacheEntries(filePath: string, snapshot: StableSnapshot): ObserverCache | null {
+	const complete = completePrefix(snapshot.tail);
+	if (!complete) {
+		if (!isValidUtf8Prefix(snapshot.tail)) return null;
+		return {
+			path: filePath,
+			identity: snapshot.identity,
+			completeOffset: 0,
+			prefixDigest: digest(Buffer.alloc(0)),
+			entries: [],
+			...fullProjection([]),
+		};
+	}
+	const remainder = snapshot.tail.subarray(complete.bytes.length);
+	if (!isValidUtf8Prefix(remainder)) return null;
+	const parsed = parseCompleteEntries(complete.bytes);
+	if (!parsed) return null;
+	return {
+		path: filePath,
+		identity: snapshot.identity,
+		completeOffset: complete.bytes.length,
+		prefixDigest: digest(complete.bytes),
+		entries: parsed.entries,
+		model: parsed.model,
+		...fullProjection(parsed.entries),
+	};
+}