Luigit
repositories / pi-ext

pi-ext

bugabingas pi extensions

owned by admin

extensions/autopsy/__tests__/history.test.ts

Raw
import { request } from "node:http";
import { setImmediate } from "node:timers/promises";
import { SessionManager } from "@earendil-works/pi-coding-agent";
import { describe, expect, it } from "vitest";
import {
	buildInspectorData,
	startInspector,
	streamInspectorMetrics,
} from "../inspector.ts";
import type { InspectorQuery } from "../src/types.ts";

function fixture() {
	const manager = SessionManager.inMemory();
	const ctx = { cwd: "/", sessionManager: manager };
	const data = (query: InspectorQuery = {}, signal?: AbortSignal) =>
		buildInspectorData(ctx, [], [], undefined, query, signal);
	return { manager, ctx, data };
}

describe("lazy session history", () => {
	it("retains earliest/latest entries beyond both former corpus limits and anchors pages across appends", async () => {
		const { manager, data } = fixture();
		const ids: string[] = [];
		const large = "old body ".repeat(1024);
		for (let index = 0; index < 10_050; index++)
			ids.push(
				manager.appendMessage({
					role: "user",
					content: large,
					timestamp: index,
				}),
			);
		const latest = await data({ limit: 3 });
		expect(latest.entries.map((entry) => entry.id)).toEqual(
			ids.slice(-3).reverse(),
		);
		expect(latest.page).toEqual({
			total: 10_050,
			start: 0,
			nextCursor: ids.at(-3),
			previousCursor: null,
		});
		expect(latest.summary.entries).toBe(10_050);
		expect(
			latest.entries.every(
				(entry) =>
					Buffer.byteLength(entry.text) <= 2048 &&
					Buffer.byteLength(entry.raw) <= 2048 &&
					entry.previewTruncated,
			),
		).toBe(true);
		expect(latest.warnings).toEqual([]);
		const oldest = await data({ order: "oldest", limit: 2 });
		expect(oldest.entries.map((entry) => entry.id)).toEqual(ids.slice(0, 2));
		expect(oldest.summary).toEqual(latest.summary);
		manager.appendMessage({
			role: "user",
			content: "appended",
			timestamp: 11_000,
		});
		const next = await data({ limit: 3, after: latest.page.nextCursor! });
		expect(next.entries.map((entry) => entry.id)).toEqual(
			ids.slice(-6, -3).reverse(),
		);
		expect(next.page.start).toBe(4);
		expect(next.revision).not.toBe(latest.revision);
		const previous = await data({ limit: 3, before: next.entries[0]!.id });
		expect(previous.entries.map((entry) => entry.id)).toEqual(
			latest.entries.map((entry) => entry.id),
		);
		const around = await data({ around: ids[0]!, limit: 3 });
		expect(around.entries.some((entry) => entry.id === ids[0])).toBe(true);
		expect(around.page.nextCursor).toBeNull();
	});

	it("searches full readable content beyond previews, with exact filters and all-session nullable facets", async () => {
		const { manager, data } = fixture();
		const first = manager.appendMessage({
			role: "user",
			content: "x".repeat(40_000) + "Late Needle",
			timestamp: 0,
		});
		const offBranch = manager.appendCustomEntry("side", {
			value: "not selected",
		});
		manager.branch(first);
		const last = manager.appendUsage("usage", "p", "m", {
			input: 0,
			output: 0,
			cacheRead: 0,
			cacheWrite: 0,
			totalTokens: 0,
			cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
		});
		const result = await data({
			q: "lATE nEEDLE",
			role: "user",
			provider: "null",
			model: "null",
		});
		expect(result.entries.map((entry) => entry.id)).toEqual([first]);
		expect(result.entries[0]?.text).not.toContain("Needle");
		expect(result.page.total).toBe(1);
		expect(result.facets.types).toContain("custom");
		expect(result.facets.providers).toEqual(
			expect.arrayContaining([null, "p"]),
		);
		expect((await data()).entries.some((entry) => entry.id === offBranch)).toBe(
			false,
		);
		expect(
			(await data({ branch: "all" })).entries.some(
				(entry) => entry.id === offBranch,
			),
		).toBe(true);
		const usage = await data({
			provider: JSON.stringify("p"),
			model: JSON.stringify("m"),
		});
		expect(usage.entries.map((entry) => entry.id)).toEqual([last.id]);
		expect(usage.summary).toMatchObject({
			tokens: 0,
			tokensKnown: 1,
			storedCost: 0,
			storedCostKnown: 1,
		});
		expect(
			(await data({ provider: "null", role: "usage" })).summary.tokens,
		).toBeNull();
		const stamp = manager.getEntry(first)!.timestamp;
		expect(
			(await data({ from: stamp, to: stamp })).entries.some(
				(entry) => entry.id === first,
			),
		).toBe(true);
	});

	it("searches complete provider metadata independently of readable previews", async () => {
		const { manager, data } = fixture();
		const id = manager.appendMessage({
			role: "assistant",
			api: "openai",
			provider: "p",
			model: "m",
			timestamp: 1,
			content: [
				{
					type: "text",
					text: "ordinary reply",
					textSignature: "x".repeat(40_000) + "opaque-needle",
				},
			],
			usage: {
				input: 0,
				output: 0,
				cacheRead: 0,
				cacheWrite: 0,
				totalTokens: 0,
				cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
			},
			stopReason: "stop",
		});
		const found = await data({ q: "OPAQUE-NEEDLE" });
		expect(found.entries.map((entry) => entry.id)).toEqual([id]);
		expect(found.entries[0]?.text).toBe("ordinary reply");
		expect(found.entries[0]?.raw).not.toContain("opaque-needle");
	});

	it("shows requested and concrete identities consistently while pricing responders and preserving stored zero", async () => {
		const { manager, ctx } = fixture();
		const usage = {
			input: 1_000_000,
			output: 0,
			cacheRead: 0,
			cacheWrite: 0,
			totalTokens: 1_000_000,
			cost: {
				input: 0,
				output: 0,
				cacheRead: 0,
				cacheWrite: 0,
				total: 0,
				totalFromProvider: true,
			},
		};
		for (const responseModel of ["concrete", "unknown", undefined]) {
			manager.appendMessage({
				role: "assistant",
				api: "openai",
				provider: "router",
				model: "requested",
				...(responseModel ? { responseModel } : {}),
				content: [],
				timestamp: 1,
				stopReason: "stop",
				usage,
			});
		}
		const prices = (_provider: string, model: string) =>
			model === "unknown"
				? undefined
				: {
						input: model === "concrete" ? 2 : 7,
						output: 0,
						cacheRead: 0,
						cacheWrite: 0,
					};
		const data = await buildInspectorData(ctx, [], [], prices);
		expect(data.facets.models).toEqual([
			"concrete ← requested",
			"unknown ← requested",
			"requested",
		]);
		expect(
			data.entries.map((entry) => entry.usage?.catalogCost?.total),
		).toEqual([7, 7, 2]);
		expect(
			data.entries.every(
				(entry) =>
					entry.usage?.cost === 0 && entry.usage.costSource === "provider",
			),
		).toBe(true);
		const filtered = await buildInspectorData(ctx, [], [], prices, {
			model: JSON.stringify("concrete ← requested"),
		});
		expect(filtered.entries).toHaveLength(1);
		expect(filtered.summary).toMatchObject({ storedCost: 0, catalogCost: 2 });
		expect(filtered.entries[0]?.raw).toContain('"responseModel"');
		const unknown = await buildInspectorData(ctx, [], [], () => undefined);
		expect(
			unknown.entries.every((entry) => entry.usage?.catalogCost === null),
		).toBe(true);
	});

	it("sums cheap accounting over the entire scope independently of page measurement", async () => {
		const { manager, ctx } = fixture();
		for (const count of [0, 3]) {
			const source = manager.appendUsage("accounting", "p", "m", {
				input: count,
				output: 0,
				cacheRead: 0,
				cacheWrite: 0,
				totalTokens: count,
				cost: {
					input: count,
					output: 0,
					cacheRead: 0,
					cacheWrite: 0,
					total: count,
				},
			});
			Object.assign(source, { durationMs: count });
		}
		manager.appendCustomEntry("unknown", {});
		let lookups = 0;
		const prices = () => {
			lookups++;
			return { input: 1_000_000, output: 0, cacheRead: 0, cacheWrite: 0 };
		};
		const first = await buildInspectorData(ctx, [], [], prices, { limit: 1 });
		expect(lookups).toBe(1);
		const next = await buildInspectorData(ctx, [], [], prices, {
			limit: 1,
			after: first.page.nextCursor!,
		});
		expect(first.summary).toMatchObject({
			entries: 3,
			usageEntries: 2,
			tokens: 3,
			tokensKnown: 2,
			storedCost: 3,
			storedCostKnown: 2,
			catalogCost: 3,
			catalogCostKnown: 2,
			durationMs: 3,
			durationKnown: 2,
		});
		expect(next.summary).toEqual(first.summary);
		expect(lookups).toBe(2);
	});

	it("rejects invalid queries, stale/nonmatching anchors and unsupported search, and cancels yielding scans", async () => {
		const { manager, data } = fixture();
		manager.appendMessage({ role: "user", content: "content", timestamp: 1 });
		for (const query of [
			{ limit: 0 },
			{ limit: 101 },
			{ limit: 1.5 },
			{ q: "x".repeat(257) },
			{ provider: "p" },
			{ model: "42" },
			{ from: "garbage" },
			{ from: "2026-02-30" },
			{ from: "2026-01-02", to: "2026-01-01" },
			{ after: "x", before: "y" },
		])
			await expect(data(query)).rejects.toMatchObject({ status: 400 });
		await expect(data({ after: "missing" })).rejects.toMatchObject({
			status: 409,
		});
		const entry = manager.getEntries()[0]!;
		await expect(
			data({ after: entry.id, role: "assistant" }),
		).rejects.toMatchObject({ status: 409 });
		manager.appendCustomEntry("ephemeral", { unsupported: new Date() });
		await expect(data({ q: "unfindable" })).rejects.toMatchObject({
			status: 422,
		});
		const controller = new AbortController();
		const pending = data({}, controller.signal);
		controller.abort();
		await expect(pending).rejects.toMatchObject({ name: "AbortError" });
	});

	it("matches across detail chunks and cancels an active one-character full-content search", async () => {
		const { manager, data } = fixture();
		const id = manager.appendMessage({
			role: "user",
			content: "x".repeat(8191) + "boundary",
			timestamp: 1,
		});
		expect(
			(await data({ q: "boundary" })).entries.map((entry) => entry.id),
		).toEqual([id]);
		const entry = manager.getEntry(id) as { message: { content: string } };
		entry.message.content = "x".repeat(32 * 1024 * 1024);
		const controller = new AbortController();
		const pending = data({ q: "z" }, controller.signal);
		await setImmediate();
		controller.abort();
		await expect(pending).rejects.toMatchObject({ name: "AbortError" });
	});

	it("propagates slow-reader disconnect cancellation through the metrics pipeline", async () => {
		const { manager, data } = fixture();
		manager.appendMessage({ role: "user", content: "sample", timestamp: 1 });
		const sample = (await data()).entries[0]!;
		let produced = 0;
		let cleaned = false;
		let signal: AbortSignal | undefined;
		const inspector = await startInspector(
			(query, signal) => data(query, signal),
			undefined,
			async function* (_query, cancellation) {
				signal = cancellation;
				try {
					for (; produced < 10_000; produced++) {
						cancellation.throwIfAborted();
						yield {
							type: "entry" as const,
							entry: { ...sample, toolNames: ["x".repeat(8192)] },
						};
					}
					yield { type: "end" as const };
				} finally {
					cleaned = true;
				}
			},
		);
		try {
			await new Promise<void>((resolve, reject) => {
				const req = request(`${inspector.url}metrics`, (res) => {
					res.once("data", () => {
						res.pause();
						setTimeout(() => {
							req.destroy();
							resolve();
						}, 50);
					});
				});
				req.on("error", (error) => {
					if ((error as NodeJS.ErrnoException).code !== "ECONNRESET")
						reject(error);
				});
				req.end();
			});
			for (let index = 0; index < 100 && !cleaned; index++)
				await new Promise((resolve) => setTimeout(resolve, 5));
			expect(signal?.aborted).toBe(true);
			expect(cleaned).toBe(true);
			expect(produced).toBeLessThan(10_000);
		} finally {
			await inspector.close();
		}
	});

	it("streams scope metrics independently of pages and never eagerly captures prompts", async () => {
		const { manager, ctx, data } = fixture();
		for (let index = 0; index < 65; index++)
			manager.appendMessage({
				role: "user",
				content: [
					{ type: "text", text: "hello" },
					{ type: "image", mimeType: "image/png", data: "invalid" },
				],
				timestamp: index,
			});
		const events = [];
		for await (const event of streamInspectorMetrics(ctx, undefined, {
			limit: 1,
		}))
			events.push(event);
		expect(events).toHaveLength(66);
		expect(events.at(-1)).toEqual({ type: "end" });
		expect(events[0]).toMatchObject({
			type: "entry",
			entry: { text: "", raw: "", images: [], metrics: { imageCount: 1 } },
		});
		let captures = 0;
		let cancelled: AbortSignal | undefined;
		const inspector = await startInspector(
			async (query, signal) => {
				if (query.q === "wait") {
					cancelled = signal;
					while (!signal.aborted) await setImmediate();
					signal.throwIfAborted();
				}
				return data(query, signal);
			},
			(id) => manager.getEntry(id),
			(query, signal) => streamInspectorMetrics(ctx, undefined, query, signal),
			() => {
				captures++;
				return [
					{
						id: 1,
						prompt: "captured",
						grouped: "grouped",
						timestamp: "now",
						entryId: null,
					},
				];
			},
		);
		try {
			expect(
				(await (await fetch(`${inspector.url}data?limit=1`)).json()).entries,
			).toHaveLength(1);
			expect(captures).toBe(0);
			expect(
				(await (await fetch(`${inspector.url}prompts`)).json())[0].prompt,
			).toBe("captured");
			expect(captures).toBe(1);
			const metrics = await fetch(`${inspector.url}metrics?limit=1`);
			expect(metrics.headers.get("content-type")).toContain(
				"application/x-ndjson",
			);
			expect((await metrics.text()).trim().split("\n")).toHaveLength(66);
			expect((await fetch(`${inspector.url}data?limit=101`)).status).toBe(400);
			expect((await fetch(`${inspector.url}data?after=missing`)).status).toBe(
				409,
			);
			expect(
				(await fetch(`${inspector.url}metrics?after=missing`)).status,
			).toBe(409);
			const req = request(`${inspector.url}data?q=wait`);
			req.on("error", () => {});
			req.end();
			for (let index = 0; index < 100 && !cancelled; index++)
				await new Promise((resolve) => setTimeout(resolve, 5));
			expect(cancelled).toBeDefined();
			req.destroy();
			for (let index = 0; index < 100 && !cancelled?.aborted; index++)
				await new Promise((resolve) => setTimeout(resolve, 5));
			expect(cancelled?.aborted).toBe(true);
		} finally {
			await inspector.close();
		}
	});
});