import { fileURLToPath } from "node:url";

import {

migrateSessionEntries,

parseSessionEntries,

type FileEntry as PiSessionFileEntry,

type SessionEntry as PiSessionEntry,

type SessionHeader,

} from "@earendil-works/pi-coding-agent";

tools?: Array<{ name: string; description?: string; parameters?: unknown }>;

}

type SessionExportJsonlWarning = {

code: "invalid-session-json" | "invalid-session-row";

row: number;

};

type SessionExportWarningSummary = {

code: SessionExportJsonlWarning["code"];

count: number;

rows: number[];

};

async function loadTemplate(fileName: string): Promise<string> {

return await fsp.readFile(path.join(EXPORT_HTML_DIR, fileName), "utf-8");

}

}

throw new Error(`Could not find an unused export filename near ${filePath}`);

}

function isRecord(value: unknown): value is Record<string, unknown> {

return Boolean(value) && typeof value === "object" && !Array.isArray(value);

}

function isSessionFileEntry(value: unknown): value is PiSessionFileEntry {

if (!isRecord(value) || typeof value.type !== "string") {

return false;

}

if (value.type !== "message") {

return true;

}

const message = value.message;

return isRecord(message) && typeof message.role === "string";

}

function parseSessionEntriesWithWarnings(content: string): {

entries: PiSessionFileEntry[];

warnings: SessionExportJsonlWarning[];

} {

const entries: PiSessionFileEntry[] = [];

const warnings: SessionExportJsonlWarning[] = [];

const rows = content.split(/\r?\n/u);

for (const [index, rawLine] of rows.entries()) {

const line = rawLine.trim();

if (!line) {

continue;

}

try {

const parsed = JSON.parse(line) as unknown;

if (!isSessionFileEntry(parsed)) {

warnings.push({ code: "invalid-session-row", row: index + 1 });

continue;

}

entries.push(parsed);

} catch {

warnings.push({ code: "invalid-session-json", row: index + 1 });

}

}

return { entries, warnings };

}

function summarizeSessionExportWarnings(

warnings: SessionExportJsonlWarning[],

): SessionExportWarningSummary[] {

const summaries = new Map<SessionExportJsonlWarning["code"], SessionExportWarningSummary>();

for (const warning of warnings) {

const summary = summaries.get(warning.code);

if (summary) {

summary.count += 1;

if (summary.rows.length < 20) {

summary.rows.push(warning.row);

}

continue;

}

summaries.set(warning.code, {

code: warning.code,

count: 1,

rows: [warning.row],

});

}

return [...summaries.values()];

}

function formatSkippedRows(count: number): string {

return `${count.toLocaleString()} malformed transcript ${count === 1 ? "row" : "rows"}`;

}

function formatSessionExportWarning(summary: SessionExportWarningSummary): string {

const rows = summary.rows.length > 0 ? ` rows ${summary.rows.join(", ")}` : "";

const verb = summary.count === 1 ? "was" : "were";

switch (summary.code) {

case "invalid-session-json":

return `⚠️ Skipped ${formatSkippedRows(summary.count)} that ${verb} not valid JSON.${rows}`;

case "invalid-session-row":

return summary.count === 1

? `⚠️ Skipped ${formatSkippedRows(summary.count)} that was not a session entry.${rows}`

: `⚠️ Skipped ${formatSkippedRows(summary.count)} that were not session entries.${rows}`;

}

const unreachable: never = summary.code;

return unreachable;

}

async function readSessionDataFromTranscript(sessionFile: string): Promise<{

header: SessionHeader | null;

entries: PiSessionEntry[];

leafId: string | null;

warnings: SessionExportWarningSummary[];

}> {

const raw = await fsp.readFile(sessionFile, "utf-8");

const fileEntries = parseSessionEntries(raw);

const { entries: fileEntries, warnings } = parseSessionEntriesWithWarnings(raw);

migrateSessionEntries(fileEntries);

const header =

fileEntries.find((entry): entry is SessionHeader => entry.type === "session") ?? null;

const entries = fileEntries.filter((entry): entry is PiSessionEntry => entry.type !== "session");

const lastEntry = entries.at(-1);

const leafId = typeof lastEntry?.id === "string" ? lastEntry.id : null;

return { header, entries, leafId };

return { header, entries, leafId, warnings: summarizeSessionExportWarnings(warnings) };

}

export async function buildExportSessionReply(params: HandleCommandsParams): Promise<ReplyPayload> {

}

// 2. Load session entries

const { entries, header, leafId } = await readSessionDataFromTranscript(sessionFile);

const { entries, header, leafId, warnings } = await readSessionDataFromTranscript(sessionFile);

// 3. Build full system prompt

const { systemPrompt, tools } = await resolveCommandsSystemPromptBundle({

"",

`📄 File: ${displayPath}`,

`📊 Entries: ${entries.length}`,

...warnings.map(formatSessionExportWarning),

`🧠 System prompt: ${systemPrompt.length.toLocaleString()} chars`,

`🔧 Tools: ${tools.length}`,

].join("\n"),