@pasko70/pibo 1.1.0 → 1.2.0

package/dist/debug/session.js

@@ -1,4 +1,5 @@
 import { normalizeLimit, openReadOnlyDebugDatabase, withStorePath } from "./sql.js";
+import { formatNextCommands } from "./next-commands.js";
 export function parseDebugSessionInput(input) {
     const raw = input.trim();
     if (!raw)
@@ -18,15 +19,15 @@ export function inspectDebugSession(input, stores, options = {}) {
     const parsed = parseDebugSessionInput(input);
     const limit = normalizeLimit(options.limit);
     if (!stores.sessions.exists) {
-        throw new Error(`Debug store "sessions" not found at ${stores.sessions.defaultPath}`);
+        throw new Error(`Debug store "sessions" not found at ${stores.sessions.path}`);
     }
     const sessionsDb = openReadOnlyDebugDatabase(stores.sessions);
     try {
-        const session = sessionsDb.prepare("SELECT * FROM pibo_sessions WHERE id = ?").get(parsed.piboSessionId);
+        const session = sessionsDb.prepare("SELECT * FROM sessions WHERE id = ?").get(parsed.piboSessionId);
         if (!session)
             throw new Error(`Pibo session "${parsed.piboSessionId}" not found`);
         const metadata = parseObject(session.metadata_json);
-        const sessionRoomId = stringValue(metadata.chatRoomId);
+        const sessionRoomId = session.room_id ?? stringValue(metadata.chatRoomId);
         const warnings = parsed.roomId && sessionRoomId && parsed.roomId !== sessionRoomId
             ? [`URL roomId "${parsed.roomId}" does not match session metadata chatRoomId "${sessionRoomId}".`]
             : [];
@@ -42,8 +43,15 @@ export function inspectDebugSession(input, stores, options = {}) {
             },
             children: listChildSessions(sessionsDb, parsed.piboSessionId, limit),
         };
+        summary.nextCommands = [
+            `pibo debug messages ${parsed.piboSessionId} list`,
+            `pibo debug final ${parsed.piboSessionId}`,
+            `pibo debug trace ${parsed.piboSessionId} --check`,
+            `pibo debug failures ${parsed.piboSessionId}`,
+            `pibo debug events ${parsed.piboSessionId} --limit 20`,
+        ];
         if (stores.chat.exists) {
-            const chatDb = openReadOnlyDebugDatabase(stores.chat);
+            const chatDb = stores.chat.path === stores.sessions.path ? sessionsDb : openReadOnlyDebugDatabase(stores.chat);
             try {
                 summary.chat = readChatSession(chatDb, parsed.piboSessionId);
                 if (options.events)
@@ -53,7 +61,8 @@ export function inspectDebugSession(input, stores, options = {}) {
                 throw withStorePath(error, stores.chat);
             }
             finally {
-                chatDb.close();
+                if (chatDb !== sessionsDb)
+                    chatDb.close();
             }
         }
         return summary;
@@ -107,13 +116,14 @@ export function formatDebugSessionSummary(summary) {
             lines.push(`  ${formatValue(event.created_at)}\t${formatValue(event.type)}\t${formatValue(event.event_id)}`);
         }
     }
+    lines.push(...formatNextCommands(summary.nextCommands ?? []));
     return lines.join("\n");
 }
 function listChildSessions(db, piboSessionId, limit) {
     const rows = db
         .prepare(`
-				SELECT id, pi_session_id, channel, kind, profile, parent_id, metadata_json, created_at, updated_at
-				FROM pibo_sessions
+				SELECT id, pi_session_id, channel, kind, profile, room_id, root_session_id, parent_id, origin_id, workspace, title, status, metadata_json, created_at, updated_at, last_activity_at
+				FROM sessions
 				WHERE parent_id = ?
 				ORDER BY created_at
 				LIMIT ?
@@ -138,19 +148,36 @@ function listChildSessions(db, piboSessionId, limit) {
     });
 }
 function readChatSession(db, piboSessionId) {
-    if (!tableExists(db, "web_chat_sessions"))
+    if (!tableExists(db, "sessions"))
         return undefined;
-    return db.prepare("SELECT * FROM web_chat_sessions WHERE pibo_session_id = ?").get(piboSessionId);
+    return db.prepare(`
+		SELECT
+			s.id AS pibo_session_id,
+			s.room_id,
+			s.root_session_id,
+			s.status,
+			s.last_activity_at,
+			stats.message_count,
+			stats.tool_call_count,
+			stats.error_count,
+			stats.last_event_stream_id,
+			nav.child_count,
+			nav.sort_key
+		FROM sessions s
+		LEFT JOIN session_stats stats ON stats.session_id = s.id
+		LEFT JOIN session_navigation nav ON nav.session_id = s.id
+		WHERE s.id = ?
+	`).get(piboSessionId);
 }
 function readEventSummaries(db, piboSessionId, limit) {
-    if (!tableExists(db, "web_chat_events"))
+    if (!tableExists(db, "event_log"))
         return [];
     return db
         .prepare(`
-				SELECT type, event_id, created_at
-				FROM web_chat_events
-				WHERE pibo_session_id = ?
-				ORDER BY rowid DESC
+				SELECT type, event_id, created_at, stream_id
+				FROM event_log
+				WHERE session_id = ?
+				ORDER BY stream_id DESC
 				LIMIT ?
 			`)
         .all(piboSessionId, limit);
@@ -166,13 +193,16 @@ function compactSessionRow(row) {
         channel: row.channel,
         kind: row.kind,
         profile: row.profile,
-        owner_scope: row.owner_scope,
         parent_id: row.parent_id,
         origin_id: row.origin_id,
         workspace: row.workspace,
         title: row.title,
+        status: row.status,
+        room_id: row.room_id,
+        root_session_id: row.root_session_id,
         created_at: row.created_at,
         updated_at: row.updated_at,
+        last_activity_at: row.last_activity_at,
     };
 }
 function parseObject(value) {

package/dist/debug/sql.js

@@ -80,7 +80,7 @@ export function formatJson(value) {
 }
 export function openReadOnlyDebugDatabase(store) {
     if (!store.exists) {
-        throw new Error(`Debug store "${store.name}" not found at ${store.defaultPath}`);
+        throw new Error(`Debug store "${store.name}" not found at ${store.path}`);
     }
     const db = new DatabaseSync(store.path, { readOnly: true });
     db.exec("PRAGMA busy_timeout = 5000");

package/dist/debug/stores.js

@@ -1,46 +1,51 @@
 import { existsSync } from "node:fs";
-import { resolve } from "node:path";
+import { piboHomePath } from "../core/pibo-home.js";
 export const PIBO_DEBUG_STORES = [
+    {
+        name: "pibo-data",
+        description: "current unified Chat Web and Pibo Session data",
+        defaultPath: "pibo.sqlite",
+    },
     {
         name: "sessions",
-        description: "canonical Pibo Session metadata",
-        defaultPath: ".pibo/pibo-sessions.sqlite",
+        description: "V2 alias for Pibo Session metadata in pibo.sqlite",
+        defaultPath: "pibo.sqlite",
     },
     {
         name: "chat",
-        description: "Chat Web read model, rooms, and durable chat events",
-        defaultPath: ".pibo/web-chat.sqlite",
+        description: "V2 alias for Chat Web rooms, messages, events, observations, and stats in pibo.sqlite",
+        defaultPath: "pibo.sqlite",
     },
     {
         name: "agents",
         description: "custom Agent Designer profiles",
-        defaultPath: ".pibo/chat-agents.sqlite",
+        defaultPath: "chat-agents.sqlite",
     },
     {
         name: "auth",
         description: "Better Auth local auth data",
-        defaultPath: ".pibo/auth.sqlite",
+        defaultPath: "auth.sqlite",
     },
     {
         name: "bindings",
         description: "local session binding data",
-        defaultPath: ".pibo/session-bindings.sqlite",
+        defaultPath: "session-bindings.sqlite",
     },
     {
         name: "reliability",
         description: "Pibo event stream, durable jobs, and yielded runs",
-        defaultPath: ".pibo/pibo-events.sqlite",
+        defaultPath: "pibo-events.sqlite",
     },
 ];
-export function resolveDebugStores(cwd = process.cwd()) {
-    return PIBO_DEBUG_STORES.map((store) => resolveDebugStore(store.name, cwd));
+export function resolveDebugStores() {
+    return PIBO_DEBUG_STORES.map((store) => resolveDebugStore(store.name));
 }
-export function resolveDebugStore(name, cwd = process.cwd()) {
+export function resolveDebugStore(name) {
     const store = PIBO_DEBUG_STORES.find((item) => item.name === name);
     if (!store) {
         throw new Error(`Unknown debug store "${name}". Use one of: ${PIBO_DEBUG_STORES.map((item) => item.name).join(", ")}`);
     }
-    const path = resolve(cwd, store.defaultPath);
+    const path = piboHomePath(store.defaultPath);
     return {
         ...store,
         path,

package/dist/debug/summary.js

@@ -0,0 +1,72 @@
+import { inspectDebugEvents } from "./events.js";
+import { inspectDebugMessageShow, inspectDebugMessagesList } from "./messages.js";
+import { formatNextCommands } from "./next-commands.js";
+import { inspectDebugSession, parseDebugSessionInput } from "./session.js";
+import { inspectDebugTrace } from "./trace.js";
+export async function inspectDebugSummary(input, stores) {
+    const parsed = parseDebugSessionInput(input);
+    const session = inspectDebugSession(input, stores, {});
+    const messages = inspectDebugMessagesList(parsed.piboSessionId, stores.chat, { limit: 1000 }).messages;
+    const final = inspectDebugMessageShow(parsed.piboSessionId, stores.chat, "assistant:last", { maxBytes: 240 });
+    let traceStatus;
+    try {
+        traceStatus = (await inspectDebugTrace(parsed.piboSessionId, stores, { check: true })).status;
+    }
+    catch {
+        traceStatus = undefined;
+    }
+    const failedToolCallCount = inspectDebugEvents(parsed.piboSessionId, stores.chat, { type: "tool_execution_finished", fields: ["isError", "result.status", "result.details.status"], limit: 1000 }).events.filter((event) => event.isError === true || event["result.status"] === "error" || event["result.details.status"] === "error" || event["result.details.status"] === "failed").length;
+    const messageCounts = messages.reduce((counts, message) => {
+        counts[message.role] = (counts[message.role] ?? 0) + 1;
+        return counts;
+    }, {});
+    return {
+        piboSessionId: parsed.piboSessionId,
+        status: session.session.status,
+        traceStatus,
+        roomId: session.room.sessionRoomId,
+        title: session.session.title,
+        createdAt: session.session.created_at,
+        updatedAt: session.session.updated_at,
+        lastActivityAt: session.session.last_activity_at,
+        messages: messageCounts,
+        finalAssistant: final.message ? { available: true, bytes: final.message.contentBytes, streamId: final.message.streamId, preview: final.message.preview } : { available: false },
+        toolCallCount: session.chat?.tool_call_count,
+        failedToolCallCount,
+        nextCommands: [
+            `pibo debug final ${parsed.piboSessionId}`,
+            `pibo debug failures ${parsed.piboSessionId}`,
+            `pibo debug messages ${parsed.piboSessionId} list`,
+            `pibo debug trace ${parsed.piboSessionId} --check`,
+            `pibo debug events ${parsed.piboSessionId} --limit 20`,
+        ],
+    };
+}
+export function formatDebugSummary(result) {
+    const lines = [];
+    lines.push(`piboSessionId: ${result.piboSessionId}`);
+    if (result.status !== undefined)
+        lines.push(`status: ${result.status}`);
+    if (result.traceStatus)
+        lines.push(`traceStatus: ${result.traceStatus}`);
+    if (result.roomId)
+        lines.push(`roomId: ${result.roomId}`);
+    if (result.title)
+        lines.push(`title: ${result.title}`);
+    if (result.createdAt)
+        lines.push(`createdAt: ${result.createdAt}`);
+    if (result.updatedAt)
+        lines.push(`updatedAt: ${result.updatedAt}`);
+    if (result.lastActivityAt)
+        lines.push(`lastActivityAt: ${result.lastActivityAt}`);
+    lines.push(`messages: ${Object.entries(result.messages).map(([role, count]) => `${count} ${role}`).join(", ") || "0"}`);
+    if (result.finalAssistant?.available)
+        lines.push(`finalAssistant: available, ${result.finalAssistant.bytes} bytes, stream_id=${result.finalAssistant.streamId}`);
+    else
+        lines.push("finalAssistant: unavailable");
+    if (result.toolCallCount !== undefined)
+        lines.push(`toolCalls: ${result.toolCallCount}`);
+    lines.push(`failures: ${result.failedToolCallCount} tool executions`);
+    lines.push(...formatNextCommands(result.nextCommands));
+    return lines.join("\n");
+}