Luigit
repositories / pi-ext

pi-ext

bugabingas pi extensions

owned by admin

extensions/voice/src/voice-history.ts

Raw
import { createHash } from "node:crypto";
import { isAbsolute, join, resolve } from "node:path";
import { setImmediate } from "node:timers/promises";
import { SessionManager } from "@earendil-works/pi-coding-agent";

export type NativeHistoryEntry = {
	id: string;
	role: "user" | "assistant";
	text: string;
	playedText: string;
	interrupted: boolean;
	playback: "not-played" | "partial" | "played";
	kind?: "status";
};

const HISTORY_TYPE = "voice.native-history";
const MAX_ENTRIES = 160;
const MAX_TEXT = 12_000;

/** SDK conversation and playback metadata share one session, isolated by main identity. */
export class VoiceHistory {
	readonly sessionManager: SessionManager;
	readonly mainSessionId: string;
	readonly cwd: string;
	readonly directory: string;
	private entries: NativeHistoryEntry[] = [];

	constructor(cwd: string, root: string, mainSessionId: string) {
		if (!isAbsolute(root) || !mainSessionId)
			throw new Error(
				"Native history requires an absolute directory and stable session identity.",
			);
		this.mainSessionId = mainSessionId;
		this.cwd = resolve(cwd);
		this.directory = resolve(root);
		const key = createHash("sha256").update(mainSessionId).digest("hex");
		this.sessionManager = SessionManager.continueRecent(cwd, join(root, key));
		const latest = new Map<string, NativeHistoryEntry>();
		for (const saved of this.sessionManager.getEntries().slice(-1_024)) {
			if (
				saved.type !== "custom" ||
				saved.customType !== HISTORY_TYPE ||
				!isHistoryEntry(saved.data)
			)
				continue;
			const entry = saved.data;
			latest.set(entry.id, {
				...entry,
				text: entry.text.slice(0, MAX_TEXT),
				playedText: entry.playedText.slice(0, MAX_TEXT),
			});
		}
		this.entries = [...latest.values()].slice(-MAX_ENTRIES);
	}

	snapshot(): NativeHistoryEntry[] {
		return this.entries
			.filter((entry) => entry.text.length > 0)
			.map((entry) => ({ ...entry }));
	}

	/** Build the on-demand archive in bounded batches; keep streaming updates memory-only. */
	loadAll(): Promise<NativeHistoryEntry[]> {
		return archiveEntries(this.sessionManager, this.entries);
	}

	update(
		id: string,
		role: "user" | "assistant",
		text: string,
		interrupted = false,
		writeToSession = true,
		kind?: "status",
	): void {
		let entry = this.entries.find((candidate) => candidate.id === id);
		if (!entry) {
			entry = {
				id,
				role,
				text: "",
				playedText: "",
				interrupted: false,
				playback: "not-played",
			};
			this.entries.push(entry);
			this.entries = this.entries.slice(-MAX_ENTRIES);
		}
		if (kind) entry.kind = kind;
		entry.text = text.slice(0, MAX_TEXT);
		entry.playback = !entry.playedText
			? "not-played"
			: entry.playedText === entry.text
				? "played"
				: "partial";
		entry.interrupted ||= interrupted && entry.playback !== "played";
		if (writeToSession) this.persist(entry);
	}

	markPlayback(id: string, playedText: string): void {
		const entry = this.entries.find(
			(candidate) => candidate.id === id && candidate.role === "assistant",
		);
		if (
			!entry ||
			playedText.length <= entry.playedText.length ||
			playedText.length > MAX_TEXT
		)
			return;
		// Audio can contain normalized speech or modality cues, not exact generated wording.
		entry.playedText = playedText;
		entry.playback = playedText === entry.text ? "played" : "partial";
		this.persist(entry);
	}

	private persist(entry: NativeHistoryEntry): void {
		this.sessionManager.appendCustomEntry(HISTORY_TYPE, { ...entry });
	}
}

/** Opening history must not create a new SDK session or require microphone startup. */
export async function readVoiceHistory(
	cwd: string,
	root: string,
	mainSessionId: string,
): Promise<NativeHistoryEntry[]> {
	if (!isAbsolute(root) || !mainSessionId)
		throw new Error("Invalid voice history scope.");
	const key = createHash("sha256").update(mainSessionId).digest("hex");
	const sessions = await SessionManager.list(cwd, join(root, key));
	const latest = sessions.sort(
		(a, b) => b.modified.getTime() - a.modified.getTime(),
	)[0];
	return latest ? archiveEntries(SessionManager.open(latest.path)) : [];
}

async function archiveEntries(
	manager: SessionManager,
	live: readonly NativeHistoryEntry[] = [],
): Promise<NativeHistoryEntry[]> {
	const latest = new Map<string, NativeHistoryEntry>();
	const saved = manager.getEntries();
	for (let index = 0; index < saved.length; index++) {
		const entry = saved[index];
		if (
			entry?.type === "custom" &&
			entry.customType === HISTORY_TYPE &&
			isHistoryEntry(entry.data)
		) {
			latest.set(entry.data.id, {
				...entry.data,
				text: entry.data.text.slice(0, MAX_TEXT),
				playedText: entry.data.playedText.slice(0, MAX_TEXT),
			});
		}
		if (index % 256 === 255) await setImmediate();
	}
	for (const entry of live) latest.set(entry.id, { ...entry });
	return [...latest.values()].filter((entry) => entry.text.length > 0);
}

export function isHistoryEntry(value: unknown): value is NativeHistoryEntry {
	if (typeof value !== "object" || value === null) return false;
	const entry = value as NativeHistoryEntry;
	return (
		typeof entry.id === "string" &&
		(entry.role === "user" || entry.role === "assistant") &&
		typeof entry.text === "string" &&
		typeof entry.playedText === "string" &&
		typeof entry.interrupted === "boolean" &&
		(entry.kind === undefined || entry.kind === "status") &&
		["not-played", "partial", "played"].includes(entry.playback)
	);
}