@pasko70/pibo 1.1.0 → 1.2.0

package/dist/debug/messages.js

@@ -0,0 +1,185 @@
+import { byteLength, formatTruncationFooter, sliceTextByBytes } from "./detail-format.js";
+import { formatNextCommands } from "./next-commands.js";
+import { compactOneLine, messageRole, rawEventObject, resolveMessageContent, sourceRef } from "./payloads.js";
+import { normalizeLimit, openReadOnlyDebugDatabase, withStorePath } from "./sql.js";
+export function inspectDebugMessagesList(piboSessionId, store, options = {}) {
+    const messages = readMessages(piboSessionId, store, normalizeLimit(options.limit));
+    const limited = messages.limited;
+    const rows = messages.rows.map(({ content: _content, ...row }) => row);
+    return {
+        piboSessionId,
+        messages: rows,
+        limited,
+        nextCommands: [
+            `pibo debug messages ${piboSessionId} show assistant:last --full`,
+            `pibo debug final ${piboSessionId}`,
+            rows[0] ? `pibo debug events ${piboSessionId} show ${rows[rows.length - 1]?.streamId} --json` : undefined,
+        ].filter((command) => Boolean(command)),
+    };
+}
+export function inspectDebugMessageShow(piboSessionId, store, selector, options = {}) {
+    const messages = readMessages(piboSessionId, store, 1000).rows;
+    const message = selectMessage(messages, selector);
+    if (!message) {
+        return {
+            piboSessionId,
+            resultType: options.final ? "debug.final" : "debug.messages.show",
+            selector,
+            nextCommands: [`pibo debug messages ${piboSessionId} list`],
+        };
+    }
+    const content = options.raw ? JSON.stringify(message.rawEvent ?? {}, null, 2) : message.content;
+    const source = options.raw ? sourceRef({ stream_id: message.streamId, event_id: message.eventId ?? null, type: "message", created_at: message.createdAt, preview_text: message.preview, attributes_json: null }, undefined, "raw") : message.source;
+    const slice = sliceTextByBytes(content, { ...options, noTruncate: options.noTruncate || options.full }, 8 * 1024);
+    const nextCommands = buildShowNextCommands(piboSessionId, selector, message, slice, options.final ? "final" : "messages");
+    const { rawEvent: _rawEvent, ...messageForResult } = message;
+    return {
+        piboSessionId,
+        resultType: options.final ? "debug.final" : "debug.messages.show",
+        selector,
+        message: { ...messageForResult, content: slice.text },
+        source,
+        truncation: slice,
+        nextCommands,
+    };
+}
+export function formatDebugMessagesList(result) {
+    if (result.messages.length === 0)
+        return [`messages: 0`, ...formatNextCommands(result.nextCommands)].join("\n");
+    const lines = ["idx\trole\tstream_id\tevent_id\tbytes\ttruncated\tpreview"];
+    for (const message of result.messages) {
+        lines.push([
+            message.idx,
+            message.role,
+            message.streamId,
+            message.eventId ?? "",
+            message.contentBytes,
+            message.previewOnly ? "preview-only" : "no",
+            compactOneLine(message.preview),
+        ].join("\t"));
+    }
+    lines.push(`messages: ${result.messages.length}${result.limited ? " (limited)" : ""}`);
+    lines.push(...formatNextCommands(result.nextCommands));
+    return lines.join("\n");
+}
+export function formatDebugMessageShow(result, options = {}) {
+    if (!result.message || !result.truncation) {
+        return [`message: not found`, ...formatNextCommands(result.nextCommands)].join("\n");
+    }
+    if (options.plain)
+        return result.message.content;
+    const lines = [];
+    lines.push(`piboSessionId: ${result.piboSessionId}`);
+    lines.push(`selector: ${result.selector}`);
+    lines.push(`role: ${result.message.role}`);
+    lines.push(`stream_id: ${result.message.streamId}`);
+    if (result.message.eventId)
+        lines.push(`event_id: ${result.message.eventId}`);
+    lines.push(`created_at: ${result.message.createdAt}`);
+    lines.push(`contentBytes: ${result.message.contentBytes}`);
+    if (result.message.previewOnly)
+        lines.push("warning: only preview_text is available from the inspected store");
+    lines.push("");
+    lines.push("Content:");
+    lines.push(result.message.content);
+    lines.push(...formatTruncationFooter(result.truncation, {
+        nextChunk: result.truncation.truncatedAfter ? nextChunkCommand(result.piboSessionId, result.selector, result.truncation, options.final) : undefined,
+        full: fullCommand(result.piboSessionId, result.selector, options.final),
+    }));
+    lines.push("");
+    lines.push("Source:");
+    lines.push(`  store: ${result.source?.store}`);
+    lines.push(`  table: ${result.source?.table}`);
+    lines.push(`  stream_id: ${result.message.streamId}`);
+    if (result.source?.path)
+        lines.push(`  path: ${result.source.path}`);
+    lines.push(...formatNextCommands(result.nextCommands));
+    return lines.join("\n");
+}
+function readMessages(piboSessionId, store, limit) {
+    if (!store.exists)
+        throw new Error(`Debug store "chat" not found at ${store.path}`);
+    const db = openReadOnlyDebugDatabase(store);
+    try {
+        if (!tableExists(db, "event_log"))
+            return { rows: [], limited: false };
+        const rows = db.prepare(`
+			SELECT stream_id, session_id, session_sequence, event_id, type, created_at, preview_text, attributes_json
+			FROM event_log
+			WHERE session_id = ?
+			ORDER BY stream_id ASC
+			LIMIT ?
+		`).all(piboSessionId, limit + 1);
+        const messages = [];
+        for (const row of rows) {
+            const role = messageRole(row);
+            if (!role)
+                continue;
+            const resolved = resolveMessageContent(row);
+            if (!resolved)
+                continue;
+            const previewSlice = sliceTextByBytes(resolved.content, { maxBytes: 200 }, 200);
+            messages.push({
+                idx: messages.length + 1,
+                role,
+                streamId: row.stream_id,
+                eventId: row.event_id ?? undefined,
+                createdAt: row.created_at,
+                contentBytes: byteLength(resolved.content),
+                preview: previewSlice.text,
+                previewOnly: resolved.previewOnly,
+                source: { ...resolved.source, byteLength: byteLength(resolved.content) },
+                content: resolved.content,
+                rawEvent: rawEventObject(row),
+            });
+        }
+        return { rows: messages.slice(0, limit), limited: rows.length > limit };
+    }
+    catch (error) {
+        throw withStorePath(error, store);
+    }
+    finally {
+        db.close();
+    }
+}
+function selectMessage(messages, selector) {
+    if (selector === "last")
+        return messages[messages.length - 1];
+    if (selector === "assistant:last")
+        return [...messages].reverse().find((message) => message.role === "assistant");
+    if (selector === "user:last")
+        return [...messages].reverse().find((message) => message.role === "user");
+    if (selector.startsWith("stream:")) {
+        const streamId = Number(selector.slice("stream:".length));
+        return messages.find((message) => message.streamId === streamId);
+    }
+    if (selector.startsWith("msg:")) {
+        const eventId = selector.slice("msg:".length);
+        return messages.find((message) => message.eventId === eventId);
+    }
+    const index = Number(selector);
+    if (Number.isInteger(index) && index > 0)
+        return messages[index - 1];
+    return undefined;
+}
+function buildShowNextCommands(piboSessionId, selector, message, slice, commandKind) {
+    return [
+        slice.truncatedAfter ? nextChunkCommand(piboSessionId, selector, slice, commandKind === "final") : undefined,
+        fullCommand(piboSessionId, selector, commandKind === "final"),
+        `pibo debug events ${piboSessionId} show ${message.streamId} --field ${message.source.path ?? "preview_text"}`,
+        `pibo debug messages ${piboSessionId} list`,
+    ].filter((command) => Boolean(command));
+}
+function nextChunkCommand(piboSessionId, selector, slice, final = false) {
+    const from = slice.from + slice.bytesShown;
+    return final
+        ? `pibo debug final ${piboSessionId} --from ${from} --bytes ${Math.max(slice.bytesShown, 1)}`
+        : `pibo debug messages ${piboSessionId} show ${selector} --from ${from} --bytes ${Math.max(slice.bytesShown, 1)}`;
+}
+function fullCommand(piboSessionId, selector, final = false) {
+    return final ? `pibo debug final ${piboSessionId} --no-truncate` : `pibo debug messages ${piboSessionId} show ${selector} --full`;
+}
+function tableExists(db, table) {
+    const row = db.prepare("SELECT name FROM sqlite_schema WHERE type = 'table' AND name = ?").get(table);
+    return row !== undefined;
+}

package/dist/debug/next-commands.js

@@ -0,0 +1,6 @@
+export function formatNextCommands(commands) {
+    const unique = [...new Set(commands.filter((command) => Boolean(command)))].slice(0, 5);
+    if (unique.length === 0)
+        return [];
+    return ["", "Next:", ...unique.map((command) => `  ${command}`)];
+}

package/dist/debug/payloads.js

@@ -0,0 +1,123 @@
+export function parseObject(value) {
+    if (!value)
+        return {};
+    try {
+        const parsed = JSON.parse(value);
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+            return {};
+        return parsed;
+    }
+    catch {
+        return {};
+    }
+}
+export function eventAttributes(row) {
+    return parseObject(row.attributes_json);
+}
+export function eventPayload(row) {
+    const attributes = eventAttributes(row);
+    const inlinePayload = attributes.inlinePayload;
+    if (inlinePayload && typeof inlinePayload === "object" && !Array.isArray(inlinePayload))
+        return inlinePayload;
+    return { ...attributes, previewText: row.preview_text };
+}
+export function getPath(value, path) {
+    let current = value;
+    for (const part of path.split(".").filter(Boolean)) {
+        if (!current || typeof current !== "object" || Array.isArray(current))
+            return undefined;
+        current = current[part];
+    }
+    return current;
+}
+export function resolveEventField(row, path) {
+    const raw = rawEventObject(row);
+    if (path.startsWith("attributes_json."))
+        return { value: getPath(raw, path), source: "raw" };
+    if (path in raw)
+        return { value: getPath(raw, path), source: "raw" };
+    const attributes = eventAttributes(row);
+    if (path in attributes)
+        return { value: getPath(attributes, path), source: "raw" };
+    const payload = eventPayload(row);
+    return { value: getPath(payload, path), source: "payload" };
+}
+export function rawEventObject(row) {
+    return {
+        ...row,
+        attributes_json: eventAttributes(row),
+    };
+}
+export function messageRole(row) {
+    if (row.type === "assistant_message" || row.type === "assistant_delta")
+        return "assistant";
+    if (row.type === "user_message")
+        return "user";
+    const payload = eventPayload(row);
+    const source = payload.source;
+    if (typeof source === "string" && ["user", "assistant", "system"].includes(source))
+        return source;
+    const role = payload.role;
+    if (typeof role === "string")
+        return role;
+    if (row.type === "message_started" && typeof source === "string")
+        return source;
+    return undefined;
+}
+export function resolveMessageContent(row) {
+    const attributes = eventAttributes(row);
+    const inlinePayload = attributes.inlinePayload;
+    if (typeof inlinePayload === "string") {
+        return {
+            content: inlinePayload,
+            previewOnly: false,
+            source: sourceRef(row, "attributes_json.inlinePayload", "message"),
+        };
+    }
+    if (inlinePayload && typeof inlinePayload === "object" && !Array.isArray(inlinePayload)) {
+        const object = inlinePayload;
+        if (typeof object.content === "string")
+            return { content: object.content, previewOnly: false, source: sourceRef(row, "attributes_json.inlinePayload.content", "message") };
+        if (typeof object.text === "string")
+            return { content: object.text, previewOnly: false, source: sourceRef(row, "attributes_json.inlinePayload.text", "message") };
+        if (typeof object.message === "string")
+            return { content: object.message, previewOnly: false, source: sourceRef(row, "attributes_json.inlinePayload.message", "message") };
+    }
+    if (typeof attributes.inlineText === "string") {
+        return {
+            content: attributes.inlineText,
+            previewOnly: false,
+            source: sourceRef(row, "attributes_json.inlineText", "message"),
+        };
+    }
+    if (row.preview_text) {
+        return {
+            content: row.preview_text,
+            previewOnly: true,
+            source: sourceRef(row, "preview_text", "message"),
+        };
+    }
+    return undefined;
+}
+export function sourceRef(row, path, kind) {
+    return {
+        store: "chat",
+        table: "event_log",
+        rowSelector: { stream_id: row.stream_id },
+        path,
+        kind,
+    };
+}
+export function stringifyPayloadValue(value) {
+    if (value === undefined)
+        return "";
+    if (typeof value === "string")
+        return value;
+    return JSON.stringify(value, null, 2);
+}
+export function compactOneLine(value) {
+    if (value === null || value === undefined)
+        return "";
+    const text = typeof value === "string" ? value : JSON.stringify(value);
+    return text.replaceAll("\n", "\\n");
+}