Luigit
repositories / pi-ext

pi-ext

bugabingas pi extensions

owned by admin

extensions/autopsy/history.ts

Raw
import { setImmediate } from "node:timers/promises";
import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
import { entryDetailEvents } from "./details.ts";
import { usageOf } from "./metrics.ts";
import type {
	CatalogPrices,
	InspectorData,
	InspectorEntry,
	InspectorQuery,
	InspectorSummary,
} from "./src/types.ts";

export type HistoryContext = Pick<ExtensionContext, "cwd" | "sessionManager">;
export type PriceLookup = (
	provider: string,
	model: string,
) => CatalogPrices | undefined;
type SourceEntry = ReturnType<
	HistoryContext["sessionManager"]["getEntries"]
>[number];

export class InspectorQueryError extends Error {
	constructor(
		message: string,
		public readonly status = 400,
	) {
		super(message);
	}
}

export function validateQuery(query: InspectorQuery): void {
	if (
		query.limit !== undefined &&
		(!Number.isInteger(query.limit) || query.limit < 1 || query.limit > 100)
	)
		throw new InspectorQueryError("limit must be an integer from 1 to 100");
	if (
		query.q !== undefined &&
		(typeof query.q !== "string" || query.q.length > 256)
	)
		throw new InspectorQueryError("q must contain at most 256 characters");
	if (
		query.branch !== undefined &&
		query.branch !== "current" &&
		query.branch !== "all"
	)
		throw new InspectorQueryError("Invalid branch");
	if (
		query.order !== undefined &&
		query.order !== "newest" &&
		query.order !== "oldest"
	)
		throw new InspectorQueryError("Invalid order");
	for (const key of ["provider", "model"] as const) identity(query[key]);
	const from = time(query.from),
		to = time(query.to);
	if (from !== undefined && to !== undefined && from > to)
		throw new InspectorQueryError("from must not exceed to");
	if (
		[query.after, query.before, query.around].filter(
			(value) => value !== undefined,
		).length > 1
	)
		throw new InspectorQueryError("Use only one cursor");
	for (const cursor of [query.after, query.before, query.around])
		if (cursor !== undefined && (!cursor || cursor.length > 128))
			throw new InspectorQueryError("Invalid cursor");
}

function identity(value: string | undefined): string | null | undefined {
	if (value === undefined) return undefined;
	try {
		const parsed: unknown = JSON.parse(value);
		if (parsed === null || typeof parsed === "string") return parsed;
	} catch {
		/* Report the same safe error for malformed identities. */
	}
	throw new InspectorQueryError("provider/model must be a JSON string or null");
}
function time(value: string | undefined): number | undefined {
	if (value === undefined) return undefined;
	// Accept ISO dates and datetime-local values, not Date.parse's numeric shorthand.
	if (
		!/^\d{4}-\d{2}-\d{2}(?:T\d{2}:\d{2}(?::\d{2}(?:\.\d{1,3})?)?(?:Z|[+-]\d{2}:\d{2})?)?$/u.test(
			value,
		) ||
		!Number.isFinite(Date.parse(value))
	)
		throw new InspectorQueryError("Invalid from/to timestamp");
	const day = value.slice(0, 10);
	if (new Date(`${day}T00:00:00Z`).toISOString().slice(0, 10) !== day)
		throw new InspectorQueryError("Invalid from/to date");
	return Date.parse(value);
}
function record(value: unknown): Record<string, unknown> | undefined {
	return value !== null && typeof value === "object"
		? (value as Record<string, unknown>)
		: undefined;
}
function nonnegative(value: unknown): number | null {
	return typeof value === "number" && Number.isFinite(value) && value >= 0
		? value
		: null;
}

/** Metadata and request accounting only: never walks content or decodes images. */
export function entryMetadata(
	entry: SourceEntry,
	branch: Set<string>,
	getPrices?: PriceLookup,
): InspectorEntry {
	const source = entry as unknown as Record<string, unknown>;
	const message = record(source["message"]) ?? source;
	const provider =
		typeof message["provider"] === "string" ? message["provider"] : null;
	const requested =
		typeof message["model"] === "string" ? message["model"] : null;
	const responder =
		typeof message["responseModel"] === "string" && message["responseModel"]
			? message["responseModel"]
			: requested;
	// Keep both identities visible through existing rows, facets and filters.
	const model =
		requested && responder && requested !== responder
			? `${responder} ← ${requested}`
			: responder;
	const prices =
		provider !== null && responder !== null
			? (getPrices?.(provider, responder) ??
				(requested !== null && requested !== responder
					? getPrices?.(provider, requested)
					: undefined))
			: undefined;
	const start =
		message["role"] === "assistant" ? nonnegative(message["timestamp"]) : null;
	return {
		id: entry.id,
		parentId: entry.parentId,
		timestamp: entry.timestamp,
		type: entry.type,
		role: typeof message["role"] === "string" ? message["role"] : entry.type,
		toolNames: [],
		images: [],
		provider,
		model,
		metrics: {
			durationMs:
				(message["role"] === "assistant" || message["role"] === "toolResult"
					? nonnegative(message["durationMs"])
					: null) ?? nonnegative(source["durationMs"]),
			startedAt:
				start !== null && start <= 8_640_000_000_000_000
					? new Date(start).toISOString()
					: null,
			textBytes: null,
			imageBytes: null,
			imageCount: null,
			totalBytes: null,
		},
		onBranch: branch.has(entry.id),
		text: "",
		raw: "",
		previewTruncated: false,
		usage: usageOf(message["usage"] ?? source["usage"], prices),
	};
}

async function matchesText(
	entry: SourceEntry,
	metadata: InspectorEntry,
	q: string,
	signal?: AbortSignal,
): Promise<boolean> {
	for (const label of [
		metadata.id,
		metadata.type,
		metadata.role,
		metadata.provider,
		metadata.model,
	])
		if (label?.toLowerCase().includes(q)) return true;
	const message = record(
		(entry as unknown as Record<string, unknown>)["message"],
	);
	if (
		typeof message?.["toolName"] === "string" &&
		message["toolName"].toLowerCase().includes(q)
	)
		return true;
	for (const view of ["text", "json"] as const) {
		let tail = "";
		for await (const event of entryDetailEvents(entry, view)) {
			signal?.throwIfAborted();
			if (event.type === "error")
				throw new InspectorQueryError(
					"Complete search unavailable for unsupported entry content",
					422,
				);
			if (event.type === "text") {
				const text = tail + event.text.toLowerCase();
				if (text.includes(q)) return true;
				tail = q.length > 1 ? text.slice(-(q.length - 1)) : "";
			}
		}
	}
	return false;
}

type HistoryScope = {
	selected: { source: SourceEntry; metadata: InspectorEntry }[];
	start: number;
	end: number;
	page: InspectorData["page"];
	summary: InspectorSummary;
	facets: InspectorData["facets"];
	sessionId: string;
	leafId: string | null;
	name: string;
	revision: string;
};

export async function scanHistory(
	ctx: HistoryContext,
	query: InspectorQuery,
	getPrices?: PriceLookup,
	signal?: AbortSignal,
): Promise<HistoryScope> {
	validateQuery(query);
	signal?.throwIfAborted();
	const manager = ctx.sessionManager;
	const all = manager.getEntries().slice();
	const branch = new Set(manager.getBranch().map((entry) => entry.id));
	const sessionId = manager.getSessionId(),
		leafId = manager.getLeafId(),
		name = manager.getSessionName() ?? "";
	const revision = JSON.stringify([sessionId, all.length, leafId]);
	const roles = new Set<string>(),
		types = new Set<string>(),
		providers = new Set<string | null>(),
		models = new Set<string | null>();
	const selected: { source: SourceEntry; metadata: InspectorEntry }[] = [];
	const summary: InspectorSummary = {
		entries: 0,
		usageEntries: 0,
		tokens: null,
		tokensKnown: 0,
		storedCost: null,
		storedCostKnown: 0,
		catalogCost: null,
		catalogCostKnown: 0,
		durationMs: null,
		durationKnown: 0,
		firstTimestamp: null,
		lastTimestamp: null,
	};
	const prices = new Map<string, ReturnType<PriceLookup>>();
	const cachedPrices: PriceLookup | undefined = getPrices
		? (provider, model) => {
				const key = JSON.stringify([provider, model]);
				if (!prices.has(key)) prices.set(key, getPrices(provider, model));
				return prices.get(key);
			}
		: undefined;
	const provider = identity(query.provider),
		model = identity(query.model),
		from = time(query.from),
		to = time(query.to),
		q = query.q?.toLowerCase();
	for (let index = 0; index < all.length; index++) {
		if (index % 64 === 0) {
			await setImmediate();
			signal?.throwIfAborted();
		}
		const source = all[index];
		if (!source) continue;
		const metadata = entryMetadata(source, branch, cachedPrices);
		roles.add(metadata.role);
		types.add(metadata.type);
		providers.add(metadata.provider);
		models.add(metadata.model);
		if ((query.branch ?? "current") === "current" && !metadata.onBranch)
			continue;
		if (
			(query.role !== undefined && metadata.role !== query.role) ||
			(query.type !== undefined && metadata.type !== query.type) ||
			(provider !== undefined && metadata.provider !== provider) ||
			(model !== undefined && metadata.model !== model)
		)
			continue;
		const stamp = Date.parse(metadata.timestamp);
		if (
			(from !== undefined && !(stamp >= from)) ||
			(to !== undefined && !(stamp <= to))
		)
			continue;
		if (q && !(await matchesText(source, metadata, q, signal))) continue;
		selected.push({ source, metadata });
		summary.entries++;
		if (metadata.usage) summary.usageEntries++;
		for (const [key, known, value] of [
			["tokens", "tokensKnown", metadata.usage?.totalTokens],
			["storedCost", "storedCostKnown", metadata.usage?.cost],
			["catalogCost", "catalogCostKnown", metadata.usage?.catalogCost?.total],
			["durationMs", "durationKnown", metadata.metrics.durationMs],
		] as const)
			if (value != null) {
				summary[key] = (summary[key] ?? 0) + value;
				summary[known]++;
			}
		if (Number.isFinite(stamp)) {
			if (
				summary.firstTimestamp === null ||
				stamp < Date.parse(summary.firstTimestamp)
			)
				summary.firstTimestamp = metadata.timestamp;
			if (
				summary.lastTimestamp === null ||
				stamp > Date.parse(summary.lastTimestamp)
			)
				summary.lastTimestamp = metadata.timestamp;
		}
	}
	if ((query.order ?? "newest") === "newest") selected.reverse();
	const limit = query.limit ?? 50;
	let start = 0,
		end = Math.min(limit, selected.length);
	const cursor = query.after ?? query.before ?? query.around;
	if (cursor !== undefined) {
		const index = selected.findIndex((entry) => entry.metadata.id === cursor);
		if (index < 0)
			throw new InspectorQueryError(
				"Cursor no longer belongs to the matching scope",
				409,
			);
		if (query.after !== undefined) {
			start = index + 1;
			end = Math.min(start + limit, selected.length);
		} else if (query.before !== undefined) {
			end = index;
			start = Math.max(0, end - limit);
		} else {
			start = Math.max(0, index - Math.floor(limit / 2));
			end = Math.min(start + limit, selected.length);
		}
	}
	const page: InspectorData["page"] = {
		total: selected.length,
		start,
		nextCursor:
			end < selected.length ? (selected[end - 1]?.metadata.id ?? null) : null,
		previousCursor: start > 0 ? (selected[start]?.metadata.id ?? null) : null,
	};
	return {
		selected,
		start,
		end,
		page,
		summary,
		facets: {
			roles: [...roles],
			types: [...types],
			providers: [...providers],
			models: [...models],
		},
		sessionId,
		leafId,
		name,
		revision,
	};
}