Luigit
repositories / pi-ext

pi-ext

bugabingas pi extensions

owned by admin

extensions/autopsy/index.ts

Raw
import type {
	ExtensionAPI,
	ExtensionContext,
} from "@earendil-works/pi-coding-agent";
import { Key } from "@earendil-works/pi-tui";
import { closeDebug, dbg, span } from "./src/debug.ts";

import type { PromptSnapshot } from "./src/types.ts";

const MAX_SNAPSHOTS = 32;
const MAX_PROMPT_CHARS = 4 * 1024 * 1024;
const LABEL = {
	preamble: "[PREAMBLE]",
	core: "[CORE]",
	tools: "[TOOLS]",
	rules: "[RULES]",
	generalGuidelines: "[GENERAL GUIDELINES]",
	toolGuidelines: "[TOOL GUIDELINES]",
	docs: "[DOCS]",
	append: "[APPEND]",
	context: "[CTX]",
	skills: "[SKILLS]",
	cwd: "[CWD]",
} as const;

const SECTION_LABEL: Readonly<Record<string, string>> = {
	tools: LABEL.tools,
	rules: LABEL.rules,
	general_guidelines: LABEL.generalGuidelines,
	tool_guidelines: LABEL.toolGuidelines,
	docs: LABEL.docs,
	addendum: LABEL.append,
	project_context: LABEL.context,
	skills: LABEL.skills,
	cwd: LABEL.cwd,
};
const SECTION_START = /(?:^|\n)<([a-z][a-z0-9_-]*)>\n/g;

type Range = { start: number; end: number; label: string };
type CapturedPrompt = { cwd: string; prompt: string };

export function groupSystemPrompt(prompt: string): string {
	const ranges = findSectionRanges(prompt);
	let pos = 0;
	const out: string[] = [];
	for (const [index, range] of ranges.entries()) {
		appendSection(
			out,
			index === 0 ? LABEL.preamble : LABEL.core,
			prompt.slice(pos, range.start),
		);
		appendSection(out, range.label, prompt.slice(range.start, range.end));
		pos = range.end;
	}
	appendSection(out, LABEL.core, prompt.slice(pos));
	return out.join("\n\n");
}

function findSectionRanges(prompt: string): Range[] {
	const ranges: Range[] = [];
	const pattern = new RegExp(SECTION_START.source, "g");
	let consumed = 0;
	for (let match = pattern.exec(prompt); match; match = pattern.exec(prompt)) {
		const start = match.index + (match[0].startsWith("\n") ? 1 : 0);
		if (start < consumed) continue;
		const name = match[1];
		if (name === undefined) continue;
		const end = findSectionEnd(prompt, name, pattern.lastIndex);
		if (end === undefined) continue;
		ranges.push({
			start,
			end,
			label: SECTION_LABEL[name] ?? `[SECTION ${name}]`,
		});
		consumed = end;
		pattern.lastIndex = end;
	}
	return ranges;
}

function findSectionEnd(
	prompt: string,
	name: string,
	contentStart: number,
): number | undefined {
	const opening = `<${name}>\n`;
	const closing = `\n</${name}>`;
	let depth = 1;
	let cursor = contentStart;

	while (depth > 0) {
		const nextOpening = findLineOpening(prompt, opening, cursor);
		const closeStart = prompt.indexOf(closing, cursor);
		if (closeStart < 0) return undefined;

		if (nextOpening >= 0 && nextOpening < closeStart) {
			depth++;
			cursor = nextOpening + opening.length;
			continue;
		}

		depth--;
		cursor = closeStart + closing.length;
		if (depth === 0) return cursor;
	}

	return undefined;
}

function findLineOpening(
	prompt: string,
	opening: string,
	from: number,
): number {
	for (
		let index = prompt.indexOf(opening, from);
		index >= 0;
		index = prompt.indexOf(opening, index + opening.length)
	) {
		if (index === 0 || prompt[index - 1] === "\n") return index;
	}
	return -1;
}

function appendSection(out: string[], label: string, text: string): void {
	const body = text.trim();
	if (body) out.push(`${label}\n${body}`);
}

export default function (pi: ExtensionAPI): void {
	let last: CapturedPrompt | undefined;
	let prompts: PromptSnapshot[] = [];
	let nextId = 0;
	let dropped = 0;
	let generation = 0;
	let stopped = false;
	let inspector:
		| Promise<
				Awaited<ReturnType<typeof import("./inspector.ts").startInspector>>
		  >
		| undefined;

	pi.on("session_start", () => {
		dbg?.("session.start");
		stopped = false;
		last = undefined;
		prompts = [];
		nextId = 0;
		dropped = 0;
	});
	pi.on("session_shutdown", async () => {
		dbg?.("session.shutdown");
		stopped = true;
		generation++;
		const pending = inspector;
		inspector = undefined;
		last = undefined;
		prompts = [];
		try {
			await (await pending?.catch(() => undefined))?.close();
		} finally {
			closeDebug();
		}
	});
	pi.on("before_agent_start", (event, ctx) => {
		last = { cwd: ctx.cwd, prompt: event.systemPrompt };
	});
	pi.on("agent_start", (_event, ctx) => {
		if (stopped || last?.cwd !== ctx.cwd) return;
		// Same capture boundary as the editor: after all before_agent_start handlers.
		last.prompt = ctx.getSystemPrompt();
		prompts.push({
			id: ++nextId,
			timestamp: new Date().toISOString(),
			entryId: ctx.sessionManager.getLeafId(),
			prompt: last.prompt,
			grouped: groupSystemPrompt(last.prompt),
		});
		let chars = prompts.reduce(
			(sum, p) => sum + p.prompt.length + p.grouped.length,
			0,
		);
		while (
			prompts.length > 1 &&
			(prompts.length > MAX_SNAPSHOTS || chars > MAX_PROMPT_CHARS)
		) {
			const oldest = prompts.shift();
			if (oldest) chars -= oldest.prompt.length + oldest.grouped.length;
			dropped++;
		}
	});

	const run = async (ctx: ExtensionContext) => {
		if (stopped) return;
		const currentGeneration = generation;
		let owned: typeof inspector;
		if (!prompts.length) dbg?.("prompt.skip", { reason: "not_captured" });
		const finish = span?.("prompt.open");
		try {
			const { buildInspectorData, startInspector, streamInspectorMetrics } =
				await import("./inspector.ts");
			if (generation !== currentGeneration) return;
			inspector ??= startInspector(
				(query, signal) =>
					buildInspectorData(
						ctx,
						prompts,
						[
							...(dropped
								? [
										`${dropped} older prompt captures expired; the latest capture is retained unchanged.`,
									]
								: []),
						],
						(provider, model) => ctx.modelRegistry.find(provider, model)?.cost,
						query,
						signal,
					),
				(id) => ctx.sessionManager.getEntry(id),
				(query, signal) =>
					streamInspectorMetrics(
						ctx,
						(provider, model) => ctx.modelRegistry.find(provider, model)?.cost,
						query,
						signal,
					),
				() => prompts.map((prompt) => ({ ...prompt })),
			);
			owned = inspector;
			const server = await owned;
			if (generation !== currentGeneration) return;
			const { openUrl } = await import("./src/pi-ext-browser-open.ts");
			if (generation !== currentGeneration) return;
			const opened = await openUrl(server.url, {});
			if (generation !== currentGeneration) return;
			ctx.ui.notify(
				`${opened ? "Inspector" : "Browser launch failed; open"}: ${server.url}`,
				opened ? "info" : "warning",
			);
			finish?.("finish", { outcome: opened ? "opened" : "browser_failed" });
		} catch {
			if (generation === currentGeneration && inspector === owned)
				inspector = undefined;
			await (await owned?.catch(() => undefined))?.close();
			finish?.("error", { outcome: "failed" });
			if (generation === currentGeneration)
				ctx.ui.notify("Could not open autopsy. Retry /autopsy.", "error");
		}
	};

	pi.registerCommand("autopsy", {
		description:
			"Inspect session history, usage, and captured prompts in your browser",
		handler: async (_args, ctx) => run(ctx),
	});
	pi.registerShortcut(Key.ctrlAlt("a"), {
		description:
			"Inspect session history, usage, and captured prompts in your browser",
		handler: run,
	});
}