@pasko70/pibo 1.0.0

package/dist/debug/trace.js

@@ -0,0 +1,245 @@
+import { buildTraceView } from "../apps/chat/trace.js";
+import { compareTraceOrder } from "../shared/trace-order.js";
+import { openReadOnlyDebugDatabase, withStorePath } from "./sql.js";
+export async function inspectDebugTrace(piboSessionId, stores, options = {}) {
+    if (!stores.sessions.exists)
+        throw new Error(`Debug store "sessions" not found at ${stores.sessions.defaultPath}`);
+    if (!stores.chat.exists)
+        throw new Error(`Debug store "chat" not found at ${stores.chat.defaultPath}`);
+    const sessionsDb = openReadOnlyDebugDatabase(stores.sessions);
+    const chatDb = openReadOnlyDebugDatabase(stores.chat);
+    try {
+        const sessionRow = sessionsDb.prepare("SELECT * FROM pibo_sessions WHERE id = ?").get(piboSessionId);
+        if (!sessionRow)
+            throw new Error(`Pibo session "${piboSessionId}" not found`);
+        const session = sessionFromRow(sessionRow);
+        const sessions = sessionsDb.prepare("SELECT * FROM pibo_sessions").all().map(sessionFromRow);
+        const chatRow = tableExists(chatDb, "web_chat_sessions")
+            ? chatDb.prepare("SELECT status FROM web_chat_sessions WHERE pibo_session_id = ?").get(piboSessionId)
+            : undefined;
+        const events = tableExists(chatDb, "web_chat_events")
+            ? chatDb
+                .prepare("SELECT * FROM web_chat_events WHERE pibo_session_id = ? ORDER BY rowid ASC")
+                .all(piboSessionId).map(eventFromRow)
+            : [];
+        const view = await buildTraceView({
+            session,
+            sessions,
+            events,
+            status: chatRow?.status === "running" || chatRow?.status === "error" ? chatRow.status : "idle",
+        });
+        const rows = flattenTraceNodes(view.nodes);
+        const filtered = options.runningOnly ? rows.filter((node) => node.status === "running") : rows;
+        return {
+            piboSessionId: view.piboSessionId,
+            piSessionId: view.piSessionId,
+            title: view.title,
+            status: traceStatus(view),
+            nodes: filtered,
+            rawNodeCount: rows.length,
+            ...(options.check ? { checks: checkTraceView(view) } : {}),
+        };
+    }
+    catch (error) {
+        throw withStorePath(withStorePath(error, stores.chat), stores.sessions);
+    }
+    finally {
+        sessionsDb.close();
+        chatDb.close();
+    }
+}
+export function formatDebugTrace(result) {
+    const lines = [
+        `piboSessionId: ${result.piboSessionId}`,
+        `piSessionId: ${result.piSessionId}`,
+        `title: ${result.title}`,
+        `status: ${result.status}`,
+        "",
+    ];
+    if (result.nodes.length === 0) {
+        lines.push("nodes: 0");
+        return lines.join("\n");
+    }
+    lines.push("status\ttype\ttitle\tid\trunId\tlinkedPiboSessionId");
+    for (const node of result.nodes) {
+        const title = `${"  ".repeat(node.depth)}${node.title}`;
+        lines.push([
+            node.status,
+            node.type,
+            title,
+            node.id,
+            node.runId ?? "",
+            node.linkedPiboSessionId ?? "",
+        ].join("\t"));
+    }
+    lines.push(`nodes: ${result.nodes.length}${result.nodes.length !== result.rawNodeCount ? ` of ${result.rawNodeCount}` : ""}`);
+    if (result.checks) {
+        lines.push("");
+        lines.push(`checks: ${result.checks.status}`);
+        for (const issue of result.checks.issues) {
+            lines.push(`${issue.severity}\t${issue.code}\t${issue.nodeId ?? ""}\t${issue.message}`);
+        }
+        if (result.checks.issues.length === 0)
+            lines.push("issues: 0");
+    }
+    return lines.join("\n");
+}
+function flattenTraceNodes(nodes, depth = 0) {
+    return nodes.flatMap((node) => [
+        {
+            status: node.status,
+            type: node.type,
+            title: node.title,
+            id: node.id,
+            runId: node.runId,
+            toolCallId: node.toolCallId,
+            linkedPiboSessionId: node.linkedPiboSessionId,
+            source: node.source,
+            stableKey: node.stableKey,
+            order: formatOrderKey(node),
+            startedAt: node.startedAt,
+            completedAt: node.completedAt,
+            depth,
+        },
+        ...flattenTraceNodes(node.children, depth + 1),
+    ]);
+}
+function traceStatus(view) {
+    const rows = flattenTraceNodes(view.nodes);
+    if (rows.some((node) => node.status === "error"))
+        return "error";
+    if (rows.some((node) => node.status === "running"))
+        return "running";
+    return "done";
+}
+function checkTraceView(view) {
+    const issues = [];
+    const all = flattenPiboTraceNodes(view.nodes);
+    const ids = new Set();
+    for (const node of all) {
+        if (ids.has(node.id)) {
+            issues.push({
+                severity: "warning",
+                code: "duplicate_id",
+                nodeId: node.id,
+                message: "Trace node id appears more than once.",
+            });
+        }
+        ids.add(node.id);
+        if (!node.orderKey) {
+            issues.push({
+                severity: "warning",
+                code: "missing_order",
+                nodeId: node.id,
+                message: "Trace node has no stable order key and may fall back to timestamp ordering.",
+            });
+        }
+        if (!node.source) {
+            issues.push({
+                severity: "warning",
+                code: "missing_source",
+                nodeId: node.id,
+                message: "Trace node has no projection source.",
+            });
+        }
+        if (!node.stableKey) {
+            issues.push({
+                severity: "warning",
+                code: "missing_stable_key",
+                nodeId: node.id,
+                message: "Trace node has no conceptual stable key.",
+            });
+        }
+    }
+    for (const node of all) {
+        if (node.parentId && !ids.has(node.parentId)) {
+            issues.push({
+                severity: "warning",
+                code: "missing_parent",
+                nodeId: node.id,
+                message: `Parent "${node.parentId}" is not present in the trace tree.`,
+            });
+        }
+    }
+    checkSiblingOrder(view.nodes, issues);
+    return { status: issues.length ? "warning" : "ok", issues };
+}
+function checkSiblingOrder(nodes, issues) {
+    for (let index = 1; index < nodes.length; index += 1) {
+        if (compareOrder(nodes[index - 1], nodes[index]) > 0) {
+            issues.push({
+                severity: "warning",
+                code: "order_regression",
+                nodeId: nodes[index].id,
+                message: `Node appears before previous sibling by stable order: ${nodes[index - 1].id}`,
+            });
+        }
+    }
+    for (const node of nodes)
+        checkSiblingOrder(node.children, issues);
+}
+function compareOrder(left, right) {
+    return compareTraceOrder(left.orderKey, right.orderKey) || left.id.localeCompare(right.id);
+}
+function flattenPiboTraceNodes(nodes) {
+    return nodes.flatMap((node) => [node, ...flattenPiboTraceNodes(node.children)]);
+}
+function formatOrderKey(node) {
+    const order = node.orderKey;
+    if (!order)
+        return undefined;
+    return [
+        `turn=${order.turnSeq}`,
+        order.transcriptIndex === undefined ? undefined : `tx=${order.transcriptIndex}`,
+        order.contentPartIndex === undefined ? undefined : `part=${order.contentPartIndex}`,
+        order.eventSequence === undefined ? undefined : `event=${order.eventSequence}`,
+        order.streamFrameIndex === undefined ? undefined : `frame=${order.streamFrameIndex}`,
+        `phase=${order.phaseRank}`,
+        `source=${order.sourceRank}`,
+    ].filter(Boolean).join(",");
+}
+function sessionFromRow(row) {
+    return {
+        id: row.id,
+        piSessionId: row.pi_session_id,
+        channel: row.channel,
+        kind: row.kind,
+        profile: row.profile,
+        ownerScope: row.owner_scope ?? undefined,
+        parentId: row.parent_id ?? undefined,
+        originId: row.origin_id ?? undefined,
+        workspace: row.workspace ?? undefined,
+        title: row.title ?? undefined,
+        metadata: parseObject(row.metadata_json),
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}
+function eventFromRow(row) {
+    return {
+        id: row.id,
+        piboSessionId: row.pibo_session_id,
+        eventSequence: row.event_sequence ?? undefined,
+        eventId: row.event_id ?? undefined,
+        type: row.type,
+        createdAt: row.created_at,
+        payload: JSON.parse(row.payload_json),
+    };
+}
+function tableExists(db, table) {
+    const row = db.prepare("SELECT name FROM sqlite_schema WHERE type = 'table' AND name = ?").get(table);
+    return row !== undefined;
+}
+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 {};
+    }
+}

package/dist/env.js

@@ -0,0 +1,32 @@
+import { existsSync, readFileSync } from "node:fs";
+import { resolve } from "node:path";
+function parseEnvLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#"))
+        return undefined;
+    const equalsIndex = trimmed.indexOf("=");
+    if (equalsIndex === -1)
+        return undefined;
+    const key = trimmed.slice(0, equalsIndex).trim();
+    let value = trimmed.slice(equalsIndex + 1).trim();
+    if (!key)
+        return undefined;
+    if ((value.startsWith('"') && value.endsWith('"')) ||
+        (value.startsWith("'") && value.endsWith("'"))) {
+        value = value.slice(1, -1);
+    }
+    return [key, value];
+}
+export function loadDotEnv(path = ".env") {
+    const resolvedPath = resolve(path);
+    if (!existsSync(resolvedPath))
+        return;
+    const content = readFileSync(resolvedPath, "utf-8");
+    for (const line of content.split(/\r?\n/)) {
+        const entry = parseEnvLine(line);
+        if (!entry)
+            continue;
+        const [key, value] = entry;
+        process.env[key] ??= value;
+    }
+}

package/dist/gateway/client.js

@@ -0,0 +1,200 @@
+import { randomUUID } from "node:crypto";
+import { connect } from "node:net";
+import readline from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+import { DEFAULT_GATEWAY_HOST, DEFAULT_GATEWAY_PORT, encodeFrame, } from "./protocol.js";
+import { parsePiboThinkingLevel } from "../core/thinking.js";
+function parseJsonLine(line) {
+    try {
+        return JSON.parse(line);
+    }
+    catch {
+        return undefined;
+    }
+}
+function writeFrame(socket, frame) {
+    socket.write(encodeFrame(frame));
+}
+function printResponse(frame) {
+    if (frame.ok)
+        return;
+    console.error(`\nerror: ${frame.error?.message ?? "request failed"}`);
+}
+function isSessionStatus(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const candidate = value;
+    return (typeof candidate.piboSessionId === "string" &&
+        typeof candidate.queuedMessages === "number" &&
+        typeof candidate.processing === "boolean");
+}
+function printExecutionResult(event) {
+    if (event.action === "status" && isSessionStatus(event.result)) {
+        console.error(`status: session=${event.result.piboSessionId} queued=${event.result.queuedMessages} processing=${event.result.processing} streaming=${event.result.streaming}`);
+        return;
+    }
+    if (event.action === "clear_queue" && event.result && typeof event.result === "object") {
+        const cleared = event.result.cleared;
+        console.error(`clear: removed ${typeof cleared === "number" ? cleared : 0} queued message(s)`);
+        return;
+    }
+    console.error(`${event.action}: ${JSON.stringify(event.result)}`);
+}
+function printIncomingMessage(event, state) {
+    if (event.source === "user")
+        return;
+    if (event.eventId && state.visibleIncomingEventIds.has(event.eventId))
+        return;
+    if (event.eventId)
+        state.visibleIncomingEventIds.add(event.eventId);
+    const source = event.source ?? "external";
+    console.error(`\nincoming ${source}> ${event.text}`);
+}
+function printEvent(frame, piboSessionId, state) {
+    if (frame.type !== "event" || frame.event !== "router")
+        return;
+    const event = frame.payload;
+    if (event.piboSessionId !== piboSessionId)
+        return;
+    if (event.type === "message_queued") {
+        printIncomingMessage(event, state);
+        return;
+    }
+    if (event.type === "assistant_delta") {
+        state.sawAssistantDelta = true;
+        output.write(event.text);
+        return;
+    }
+    if (event.type === "thinking_started") {
+        state.sawThinkingDelta = false;
+        if (state.showThinking)
+            output.write("\nthinking> ");
+        return;
+    }
+    if (event.type === "thinking_delta") {
+        if (!state.showThinking)
+            return;
+        state.sawThinkingDelta = true;
+        output.write(event.text);
+        return;
+    }
+    if (event.type === "thinking_finished") {
+        if (!state.showThinking)
+            return;
+        if (!state.sawThinkingDelta && event.text)
+            output.write(event.text);
+        state.sawThinkingDelta = false;
+        output.write("\n");
+        return;
+    }
+    if (event.type === "assistant_message") {
+        if (!state.sawAssistantDelta) {
+            output.write(event.text);
+        }
+        state.sawAssistantDelta = false;
+        output.write("\n");
+        return;
+    }
+    if (event.type === "session_error") {
+        console.error(`\nsession error: ${event.error}`);
+        return;
+    }
+    if (event.type === "execution_result") {
+        printExecutionResult(event);
+        return;
+    }
+    if (event.type === "message_started") {
+        state.sawAssistantDelta = false;
+        printIncomingMessage(event, state);
+        output.write("assistant> ");
+    }
+}
+export async function runGatewayClient(options = {}) {
+    const host = options.host ?? DEFAULT_GATEWAY_HOST;
+    const port = options.port ?? DEFAULT_GATEWAY_PORT;
+    const piboSessionId = options.piboSessionId ?? "default";
+    const socket = connect({ host, port });
+    socket.setEncoding("utf-8");
+    await new Promise((resolve, reject) => {
+        socket.once("connect", resolve);
+        socket.once("error", reject);
+    });
+    console.error(`connected to pibo gateway at ${host}:${port}`);
+    console.error(`session: ${piboSessionId}`);
+    console.error("type a message, /status, /clear, /abort, /thinking [level], /thinking-show, or /quit");
+    let buffer = "";
+    const renderState = {
+        visibleIncomingEventIds: new Set(),
+        sawAssistantDelta: false,
+        showThinking: false,
+        sawThinkingDelta: false,
+    };
+    socket.on("data", (chunk) => {
+        buffer += chunk;
+        let newlineIndex = buffer.indexOf("\n");
+        while (newlineIndex !== -1) {
+            const line = buffer.slice(0, newlineIndex).trim();
+            buffer = buffer.slice(newlineIndex + 1);
+            const frame = line ? parseJsonLine(line) : undefined;
+            if (frame?.type === "res") {
+                printResponse(frame);
+            }
+            else if (frame?.type === "event") {
+                printEvent(frame, piboSessionId, renderState);
+            }
+            newlineIndex = buffer.indexOf("\n");
+        }
+    });
+    const rl = readline.createInterface({ input, output });
+    try {
+        while (!socket.destroyed) {
+            const text = (await rl.question("you> ")).trim();
+            if (!text)
+                continue;
+            if (text === "/quit" || text === "/exit")
+                break;
+            if (text === "/thinking-show") {
+                renderState.showThinking = !renderState.showThinking;
+                console.error(`thinking display: ${renderState.showThinking ? "on" : "off"}`);
+                continue;
+            }
+            if (text === "/thinking" || text.startsWith("/thinking ")) {
+                const level = text.slice("/thinking".length).trim();
+                let params;
+                try {
+                    params = level ? { level: parsePiboThinkingLevel(level) } : undefined;
+                }
+                catch (error) {
+                    console.error(error instanceof Error ? error.message : String(error));
+                    continue;
+                }
+                writeFrame(socket, {
+                    type: "req",
+                    id: randomUUID(),
+                    event: params === undefined
+                        ? { type: "execution", piboSessionId, action: "thinking" }
+                        : { type: "execution", piboSessionId, action: "thinking", params },
+                });
+                continue;
+            }
+            if (text === "/status" || text === "/clear" || text === "/abort") {
+                const action = text === "/status" ? "status" : text === "/clear" ? "clear_queue" : "abort";
+                writeFrame(socket, {
+                    type: "req",
+                    id: randomUUID(),
+                    event: { type: "execution", piboSessionId, action },
+                });
+                continue;
+            }
+            writeFrame(socket, {
+                type: "req",
+                id: randomUUID(),
+                event: { type: "message", piboSessionId, text, source: "user" },
+            });
+        }
+    }
+    finally {
+        rl.close();
+        socket.end();
+    }
+}

package/dist/gateway/protocol.js

@@ -0,0 +1,46 @@
+export const DEFAULT_GATEWAY_HOST = "127.0.0.1";
+export const DEFAULT_GATEWAY_PORT = 4789;
+function isJsonValue(value) {
+    if (value === null ||
+        typeof value === "string" ||
+        typeof value === "boolean" ||
+        (typeof value === "number" && Number.isFinite(value))) {
+        return true;
+    }
+    if (Array.isArray(value)) {
+        return value.every(isJsonValue);
+    }
+    if (typeof value === "object") {
+        return Object.values(value).every(isJsonValue);
+    }
+    return false;
+}
+export function isGatewayRequestFrame(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const frame = value;
+    if (frame.type !== "req" || typeof frame.id !== "string")
+        return false;
+    if (!frame.event || typeof frame.event !== "object")
+        return false;
+    const event = frame.event;
+    if (typeof event.piboSessionId !== "string" || event.piboSessionId.length === 0)
+        return false;
+    if (event.type === "message")
+        return typeof event.text === "string";
+    if (event.type === "execution") {
+        return typeof event.action === "string" && (event.params === undefined || isJsonValue(event.params));
+    }
+    return false;
+}
+export function encodeFrame(frame) {
+    return `${JSON.stringify(frame)}\n`;
+}
+export function errorResponse(id, error) {
+    return {
+        type: "res",
+        id,
+        ok: false,
+        error: { message: error instanceof Error ? error.message : String(error) },
+    };
+}

package/dist/gateway/request.js

@@ -0,0 +1,146 @@
+import { randomUUID } from "node:crypto";
+import { connect } from "node:net";
+import { DEFAULT_GATEWAY_HOST, DEFAULT_GATEWAY_PORT, encodeFrame, } from "./protocol.js";
+function parseJsonLine(line) {
+    try {
+        return JSON.parse(line);
+    }
+    catch {
+        return undefined;
+    }
+}
+function writeFrame(socket, frame) {
+    socket.write(encodeFrame(frame));
+}
+export async function sendGatewayEvent(event, options = {}) {
+    const host = options.host ?? DEFAULT_GATEWAY_HOST;
+    const port = options.port ?? DEFAULT_GATEWAY_PORT;
+    const timeoutMs = options.timeoutMs ?? 5000;
+    const id = randomUUID();
+    const eventWithId = { ...event, id: event.id ?? id };
+    return await new Promise((resolve, reject) => {
+        const socket = connect({ host, port });
+        socket.setEncoding("utf-8");
+        let buffer = "";
+        let settled = false;
+        const timeout = setTimeout(() => {
+            finish(new Error(`Timed out waiting for gateway response at ${host}:${port}`));
+        }, timeoutMs);
+        const finish = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timeout);
+            socket.end();
+            if (result instanceof Error) {
+                reject(result);
+            }
+            else {
+                resolve(result);
+            }
+        };
+        socket.once("connect", () => {
+            writeFrame(socket, { type: "req", id, event: eventWithId });
+        });
+        socket.once("error", finish);
+        socket.once("close", () => {
+            finish(new Error("Gateway connection closed before response"));
+        });
+        socket.on("data", (chunk) => {
+            buffer += chunk;
+            let newlineIndex = buffer.indexOf("\n");
+            while (newlineIndex !== -1) {
+                const line = buffer.slice(0, newlineIndex).trim();
+                buffer = buffer.slice(newlineIndex + 1);
+                const frame = line ? parseJsonLine(line) : undefined;
+                if (frame?.type === "res" && frame.id === id) {
+                    finish(frame);
+                    return;
+                }
+                newlineIndex = buffer.indexOf("\n");
+            }
+        });
+    });
+}
+export async function sendGatewayMessageAndWaitForReply(event, options = {}) {
+    const host = options.host ?? DEFAULT_GATEWAY_HOST;
+    const port = options.port ?? DEFAULT_GATEWAY_PORT;
+    const timeoutMs = options.timeoutMs ?? 120000;
+    const id = randomUUID();
+    const eventWithId = { ...event, id: event.id ?? id };
+    return await new Promise((resolve, reject) => {
+        const socket = connect({ host, port });
+        socket.setEncoding("utf-8");
+        let buffer = "";
+        let settled = false;
+        let response;
+        let reply;
+        const timeout = setTimeout(() => {
+            finish(new Error(`Timed out waiting for assistant reply from session "${event.piboSessionId}"`));
+        }, timeoutMs);
+        const finish = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timeout);
+            socket.end();
+            if (result instanceof Error) {
+                reject(result);
+            }
+            else {
+                resolve(result);
+            }
+        };
+        const handleFrame = (frame) => {
+            if (frame.type === "res" && frame.id === id) {
+                response = frame;
+                if (!frame.ok) {
+                    finish(new Error(frame.error?.message ?? "Gateway rejected the message"));
+                }
+                else if (reply) {
+                    finish({ response, reply });
+                }
+                return;
+            }
+            if (frame.type !== "event" || frame.event !== "router")
+                return;
+            const output = frame.payload;
+            if (output.type === "session_error" &&
+                output.piboSessionId === eventWithId.piboSessionId &&
+                output.eventId === eventWithId.id) {
+                finish(new Error(output.error));
+                return;
+            }
+            if (output.type === "assistant_message" &&
+                output.piboSessionId === eventWithId.piboSessionId &&
+                output.eventId === eventWithId.id) {
+                reply = output;
+                if (response?.ok) {
+                    finish({ response, reply });
+                }
+            }
+        };
+        socket.once("connect", () => {
+            writeFrame(socket, { type: "req", id, event: eventWithId });
+        });
+        socket.once("error", finish);
+        socket.once("close", () => {
+            finish(new Error("Gateway connection closed before assistant reply"));
+        });
+        socket.on("data", (chunk) => {
+            buffer += chunk;
+            let newlineIndex = buffer.indexOf("\n");
+            while (newlineIndex !== -1) {
+                const line = buffer.slice(0, newlineIndex).trim();
+                buffer = buffer.slice(newlineIndex + 1);
+                const frame = line ? parseJsonLine(line) : undefined;
+                if (frame) {
+                    handleFrame(frame);
+                    if (settled)
+                        return;
+                }
+                newlineIndex = buffer.indexOf("\n");
+            }
+        });
+    });
+}