repositories / pi-ext
pi-ext
bugabingas pi extensions
owned by admin
extensions/voice/src/voice-history.ts
Rawimport { 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)
);
}