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(); 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 { 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 { 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 { const latest = new Map(); 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) ); }