@pasko70/pibo 1.0.5 → 1.2.0

package/dist/session-ui/commandResults.js

@@ -0,0 +1,95 @@
+import { redactTerminalSecret } from "./statusViewModel.js";
+export function normalizeCommandResultDescriptor(command, value) {
+    const unwrapped = unwrapActionPayload(value);
+    if (unwrapped instanceof Error)
+        return { kind: "error", title: command, message: redactTerminalSecret(unwrapped.message) };
+    if (typeof unwrapped === "string")
+        return { kind: "text", title: command, text: redactTerminalSecret(unwrapped) };
+    if (!unwrapped || typeof unwrapped !== "object" || Array.isArray(unwrapped))
+        return { kind: "json", title: command, value: unwrapped };
+    const record = unwrapped;
+    if (typeof record.error === "string")
+        return { kind: "error", title: command, message: redactTerminalSecret(record.error) };
+    if (record.supported === false || typeof record.unsupportedReason === "string") {
+        return { kind: "unsupported", command, reason: redactTerminalSecret(typeof record.unsupportedReason === "string" ? record.unsupportedReason : "This command is not supported in the terminal.") };
+    }
+    if (command === "status" || record.contextUsage || record.providerUsage || record.queuedMessages !== undefined) {
+        return { kind: "status", title: "Status", status: record };
+    }
+    if (typeof record.piboSessionId === "string" || typeof record.sessionId === "string") {
+        return {
+            kind: "session-link",
+            title: command,
+            sessionId: String(record.piboSessionId ?? record.sessionId),
+            roomId: typeof record.roomId === "string" ? record.roomId : undefined,
+            roomLabel: typeof record.roomTitle === "string" ? redactTerminalSecret(record.roomTitle) : typeof record.roomLabel === "string" ? redactTerminalSecret(record.roomLabel) : undefined,
+            label: typeof record.title === "string" ? redactTerminalSecret(record.title) : typeof record.sessionTitle === "string" ? redactTerminalSecret(record.sessionTitle) : undefined,
+        };
+    }
+    if (record.action === "show_login_menu" || record.action === "show_model_menu" || record.action === "show_fork_candidates" || Array.isArray(record.items) || Array.isArray(record.providers) || Array.isArray(record.messages)) {
+        return { kind: "menu", title: menuTitle(command, record), items: menuItems(record) };
+    }
+    if (typeof record.message === "string")
+        return { kind: "text", title: command, text: redactTerminalSecret(record.message), tone: record.ok === false ? "red" : "green" };
+    return { kind: "json", title: command, value: record };
+}
+export function normalizeCommandErrorDescriptor(command, error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { kind: "error", title: command, message: redactTerminalSecret(message) };
+}
+function unwrapActionPayload(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return value;
+    const record = value;
+    if (record.ok === true && "result" in record)
+        return record.result;
+    if (record.success === true && "data" in record)
+        return record.data;
+    return value;
+}
+function menuTitle(command, record) {
+    if (record.action === "show_login_menu")
+        return "Login";
+    if (record.action === "show_model_menu")
+        return "Model";
+    if (record.action === "show_fork_candidates")
+        return "Fork candidates";
+    return command;
+}
+function menuItems(record) {
+    const explicitItems = arrayRecordField(record, "items");
+    if (explicitItems.length)
+        return explicitItems.map((item, index) => itemFromRecord(item, index));
+    const providers = arrayRecordField(record, "providers");
+    if (providers.length)
+        return providers.map((provider, index) => itemFromRecord(provider, index));
+    const messages = arrayRecordField(record, "messages");
+    return messages.map((message, index) => itemFromRecord(message, index));
+}
+function itemFromRecord(record, index) {
+    const id = stringField(record, "id") ?? stringField(record, "entryId") ?? stringField(record, "provider") ?? `item-${index}`;
+    const text = stringField(record, "text");
+    return {
+        id,
+        label: redactTerminalSecret(stringField(record, "label") ?? stringField(record, "name") ?? trimLabel(text) ?? id),
+        description: redactTerminalSecret(stringField(record, "description") ?? (text && text.length > 80 ? text : undefined) ?? stringField(record, "reason") ?? arrayStringField(record, "authMethods").join(", ")) || undefined,
+        action: stringField(record, "action"),
+        value: record.value ?? record,
+        disabled: record.disabled === true,
+    };
+}
+function arrayRecordField(record, key) {
+    const value = record[key];
+    return Array.isArray(value) ? value.filter((item) => Boolean(item) && typeof item === "object" && !Array.isArray(item)) : [];
+}
+function arrayStringField(record, key) {
+    const value = record[key];
+    return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+}
+function stringField(record, key) {
+    const value = record[key];
+    return typeof value === "string" ? value : undefined;
+}
+function trimLabel(value) {
+    return value;
+}

package/dist/session-ui/index.js

@@ -0,0 +1,7 @@
+export * from "./commandCatalog.js";
+export * from "./commandResults.js";
+export * from "./roomSessionViewModel.js";
+export * from "./statusViewModel.js";
+export * from "./terminalCards.js";
+export * from "./terminalRows.js";
+export * from "./terminalValue.js";

package/dist/session-ui/ownerViewModel.js

@@ -0,0 +1,27 @@
+import { redactTerminalSecret } from "./statusViewModel.js";
+export function buildOwnerPickerDescriptor(input) {
+    const items = input.owners.map((owner) => ownerPickerItem(owner, owner.ownerScope === input.activeOwnerScope));
+    const selectedIndex = Math.max(0, items.findIndex((item) => item.current));
+    return {
+        kind: "owner",
+        title: input.title ?? "Select effective owner",
+        items,
+        selectedIndex,
+        emptyMessage: "No owners are available.",
+    };
+}
+function ownerPickerItem(owner, current) {
+    const label = redactTerminalSecret(owner.label ?? owner.ownerScope);
+    const markers = [current ? "current" : undefined, owner.isFallback ? "fallback" : undefined, owner.kind === "root-recovery" ? "root recovery" : undefined, owner.kind === "legacy" ? "legacy" : undefined]
+        .filter((marker) => Boolean(marker));
+    return {
+        id: owner.ownerScope,
+        ownerScope: owner.ownerScope,
+        label,
+        description: redactTerminalSecret([owner.ownerScope, owner.description].filter(Boolean).join(" | ")) || undefined,
+        current,
+        fallback: owner.isFallback,
+        disabled: false,
+        markers,
+    };
+}

package/dist/session-ui/roomSessionViewModel.js

@@ -0,0 +1,69 @@
+import { redactTerminalSecret } from "./statusViewModel.js";
+export function buildRoomPickerDescriptor(input) {
+    const items = input.rooms.map((room) => roomPickerItem(room, room.id === input.activeRoomId, room.id === input.defaultRoomId || room.isDefault === true));
+    const activeIndex = items.findIndex((item) => item.active);
+    const defaultIndex = items.findIndex((item) => item.default);
+    const selectedIndex = Math.max(0, activeIndex >= 0 ? activeIndex : defaultIndex);
+    return {
+        kind: "room",
+        title: input.title ?? "Select room",
+        items,
+        selectedIndex,
+        emptyMessage: "No rooms are available.",
+    };
+}
+export function buildSessionPickerDescriptor(input) {
+    const roomTitle = redactTerminalSecret(input.room.title ?? input.room.id);
+    const backItem = input.includeBackAction ? [{ id: "back", kind: "back", label: "← Back to rooms", markers: [] }] : [];
+    const sessionItems = input.sessions.map((session) => sessionPickerItem(session, session.id === input.activeSessionId));
+    const createItem = input.includeCreateAction === false ? [] : [{
+            id: `create:${input.room.id}`,
+            kind: "create-session",
+            label: `+ New session in ${roomTitle}`,
+            description: "Create and open a new CLI session in this room",
+            roomId: input.room.id,
+            markers: ["new"],
+        }];
+    const items = [...backItem, ...sessionItems, ...createItem];
+    const selectedIndex = Math.max(0, items.findIndex((item) => item.current || item.kind === "create-session"));
+    return {
+        kind: "session",
+        title: input.title ?? `Select session in ${roomTitle}`,
+        items,
+        selectedIndex,
+        emptyMessage: `No sessions in ${roomTitle}. Create a new session to start chatting.`,
+        roomId: input.room.id,
+    };
+}
+function roomPickerItem(room, active, isDefault) {
+    const markers = [active ? "active" : undefined, isDefault ? "default" : undefined, room.archived ? "archived" : undefined]
+        .filter((marker) => Boolean(marker));
+    return {
+        id: room.id,
+        kind: "room",
+        label: redactTerminalSecret(room.title ?? room.id),
+        description: redactTerminalSecret([room.description, markers.join(", ")].filter(Boolean).join(" | ")) || undefined,
+        roomId: room.id,
+        active,
+        default: isDefault,
+        archived: room.archived,
+        disabled: room.disabled,
+        markers,
+    };
+}
+function sessionPickerItem(session, current) {
+    const markers = [current ? "current" : undefined, session.status, session.archived ? "archived" : undefined]
+        .filter((marker) => Boolean(marker));
+    return {
+        id: session.id,
+        kind: "session",
+        label: redactTerminalSecret(session.title ?? session.id),
+        description: redactTerminalSecret([session.profile, session.description, session.updatedAt, markers.join(", ")].filter(Boolean).join(" | ")) || undefined,
+        roomId: session.roomId,
+        sessionId: session.id,
+        current,
+        archived: session.archived,
+        disabled: session.disabled,
+        markers,
+    };
+}

package/dist/session-ui/statusViewModel.js

@@ -0,0 +1,127 @@
+export function buildTerminalStatusViewModel(input = {}) {
+    const fields = [];
+    const progress = [];
+    const warnings = sanitizeTextList(input.warnings);
+    const errors = sanitizeTextList(input.errors);
+    if (input.session?.id || input.session?.title) {
+        fields.push({ id: "session", label: "Session", value: redactTerminalSecret([input.session?.title, input.session?.id].filter(Boolean).join(" | ")) });
+    }
+    if (input.session?.profile)
+        fields.push({ id: "profile", label: "Profile", value: redactTerminalSecret(input.session.profile) });
+    if (input.session?.status)
+        fields.push({ id: "session-status", label: "Session status", value: redactTerminalSecret(input.session.status), tone: input.session.status === "error" || input.session.status === "disposed" ? "red" : "neutral" });
+    if (input.model?.provider || input.model?.id || input.model?.label) {
+        fields.push({ id: "model", label: "Model", value: redactTerminalSecret(input.model.label ?? [input.model.provider, input.model.id].filter(Boolean).join("/")) });
+    }
+    if (input.runtime?.state)
+        fields.push({ id: "runtime", label: "Runtime", value: redactTerminalSecret(input.runtime.state), tone: input.runtime.connected === false || input.runtime.disposed ? "red" : "green" });
+    if (input.runtime?.disposed !== undefined)
+        fields.push({ id: "disposed", label: "Disposed", value: input.runtime.disposed ? "yes" : "no", tone: input.runtime.disposed ? "red" : "neutral" });
+    if (typeof input.runtime?.queuedMessages === "number")
+        fields.push({ id: "queue", label: "Queue", value: String(input.runtime.queuedMessages) });
+    if (input.runtime?.processing !== undefined)
+        fields.push({ id: "processing", label: "Processing", value: input.runtime.processing ? "yes" : "no", tone: input.runtime.processing ? "cyan" : "neutral" });
+    if (input.runtime?.streaming !== undefined)
+        fields.push({ id: "streaming", label: "Streaming", value: input.runtime.streaming ? "yes" : "no", tone: input.runtime.streaming ? "cyan" : "neutral" });
+    if (input.cwd)
+        fields.push({ id: "cwd", label: "CWD", value: redactTerminalSecret(input.cwd) });
+    const thinking = typeof input.thinking === "string" ? { level: input.thinking } : input.thinking;
+    if (thinking?.level || thinking?.supported !== undefined) {
+        fields.push({ id: "thinking", label: "Thinking", value: redactTerminalSecret(thinking.level ?? (thinking.supported === false ? "unsupported" : "available")), tone: thinking.supported === false ? "red" : "yellow" });
+    }
+    if (input.fastMode !== undefined)
+        fields.push({ id: "fast-mode", label: "Fast mode", value: typeof input.fastMode === "string" ? redactTerminalSecret(input.fastMode) : input.fastMode ? "on" : "off", tone: input.fastMode ? "green" : "neutral" });
+    const enabledTools = sanitizeTextList(input.tools?.enabled);
+    const activeTools = sanitizeTextList(input.tools?.active);
+    if (enabledTools.length)
+        fields.push({ id: "enabled-tools", label: "Enabled tools", value: `${enabledTools.length}${enabledTools.length <= 4 ? ` (${enabledTools.join(", ")})` : ""}` });
+    if (activeTools.length)
+        fields.push({ id: "active-tools", label: "Active tools", value: `${activeTools.length}${activeTools.length <= 4 ? ` (${activeTools.join(", ")})` : ""}`, tone: "cyan" });
+    if (input.providerUsage?.planType)
+        fields.push({ id: "provider-plan", label: "Provider plan", value: redactTerminalSecret(input.providerUsage.planType) });
+    if (input.providerUsage?.credits)
+        fields.push({ id: "provider-credits", label: "Credits", value: input.providerUsage.credits.unlimited ? "unlimited" : redactTerminalSecret(input.providerUsage.credits.balance ?? "available") });
+    if (input.message)
+        fields.push({ id: "message", label: "Message", value: redactTerminalSecret(input.message) });
+    progress.push(contextProgress(input.contextUsage));
+    for (const descriptor of providerProgress(input.providerUsage))
+        progress.push(descriptor);
+    return { kind: "status", title: "Status", fields, progress, warnings, errors };
+}
+export function progressBarText(descriptor, width = 20) {
+    if (descriptor.state === "unavailable" || descriptor.percent === undefined)
+        return "unavailable";
+    const boundedWidth = Math.max(4, Math.min(80, Math.floor(width)));
+    const filled = Math.round((Math.max(0, Math.min(100, descriptor.percent)) / 100) * boundedWidth);
+    return `${"█".repeat(filled)}${"░".repeat(boundedWidth - filled)} ${descriptor.percent.toFixed(1)}%`;
+}
+export function redactTerminalSecret(text) {
+    return text
+        .replace(/\b([A-Z0-9_]*(?:API[_-]?KEY|TOKEN|SECRET|PASSWORD)[A-Z0-9_]*)\s*=\s*([^\s]+)/gi, "$1=[redacted]")
+        .replace(/\b(api[_-]?key|token|secret|password)\s*[:=]\s*([^\s]+)/gi, "$1=[redacted]")
+        .replace(/\b(?:sk|pk|pibo|ghp|github_pat)_[A-Za-z0-9_\-]{8,}\b/g, "[redacted]");
+}
+function contextProgress(usage) {
+    if (!usage || (usage.tokens === undefined && usage.contextWindow === undefined && usage.percent === undefined)) {
+        return { id: "context", label: "Context", state: "unavailable", text: "Context usage unavailable", tone: "neutral" };
+    }
+    const percent = normalizePercent(usage.percent ?? (usage.tokens !== undefined && usage.contextWindow ? (usage.tokens / usage.contextWindow) * 100 : undefined));
+    return {
+        id: "context",
+        label: "Context",
+        state: percent === undefined ? "unavailable" : "available",
+        value: usage.tokens,
+        max: usage.contextWindow,
+        percent,
+        text: percent === undefined ? "Context usage unavailable" : `${usage.tokens ?? "?"}/${usage.contextWindow ?? "?"} tokens (${percent.toFixed(1)}%)`,
+        tone: toneForPercent(percent),
+    };
+}
+function providerProgress(usage) {
+    if (!usage?.limits?.length) {
+        return [{ id: "provider", label: "Provider quota", state: "unavailable", text: "Provider usage unavailable", tone: "neutral" }];
+    }
+    return usage.limits.map((limit, index) => {
+        const usedPercent = normalizePercent(limit.usedPercent);
+        const remainingPercent = normalizePercent(limit.remainingPercent ?? (usedPercent === undefined ? undefined : 100 - usedPercent));
+        const provider = usage.provider ? `${usage.provider} ` : "";
+        const details = [
+            remainingPercent === undefined ? undefined : `${remainingPercent.toFixed(1)}% remaining`,
+            limit.resetsAt ? `resets ${redactTerminalSecret(limit.resetsAt)}` : undefined,
+        ].filter(Boolean).join(", ");
+        return {
+            id: `provider-${index}`,
+            label: `${provider}${limit.label ?? "quota"}`.trim(),
+            state: remainingPercent === undefined ? "unavailable" : "available",
+            percent: remainingPercent,
+            text: remainingPercent === undefined ? "Provider usage unavailable" : details,
+            tone: toneForRemainingPercent(remainingPercent),
+        };
+    });
+}
+function normalizePercent(value) {
+    if (typeof value !== "number" || !Number.isFinite(value))
+        return undefined;
+    return Math.max(0, Math.min(100, value));
+}
+function toneForPercent(percent) {
+    if (percent === undefined)
+        return "neutral";
+    if (percent >= 80)
+        return "red";
+    if (percent >= 50)
+        return "yellow";
+    return "green";
+}
+function toneForRemainingPercent(percent) {
+    if (percent === undefined)
+        return "neutral";
+    if (percent <= 20)
+        return "red";
+    if (percent <= 50)
+        return "yellow";
+    return "green";
+}
+function sanitizeTextList(values) {
+    return (values ?? []).map((value) => redactTerminalSecret(value)).filter((value) => value.length > 0);
+}

package/dist/session-ui/terminalCards.js

@@ -0,0 +1,210 @@
+import { buildTerminalStatusViewModel, redactTerminalSecret } from "./statusViewModel.js";
+export function buildTerminalCardDescriptor(row) {
+    switch (row.kind) {
+        case "tool.status":
+            return buildStatusCard(row);
+        case "tool.thinking":
+            return buildThinkingCard(row);
+        case "tool.model":
+            return buildModelCard(row);
+        case "tool.login":
+            return buildLoginCard(row);
+        case "tool.call":
+        case "tool.image":
+        case "tool.group.exploring":
+        case "tool.group.images":
+            return buildToolCard(row);
+        case "yielded.run":
+            return baseCard(row, "yielded-run", "Yielded run", row.status === "error" ? "red" : row.status === "running" ? "cyan" : "green");
+        case "execution.compaction":
+            return baseCard(row, "compaction", row.status === "error" ? "Compaction failed" : row.status === "running" ? "Compacting" : "Compaction", row.status === "error" ? "red" : "magenta");
+        case "execution.command":
+            return baseCard(row, "command", "Command", row.status === "error" ? "red" : "yellow");
+        case "error":
+            return baseCard(row, "error", "Error", "red");
+        default:
+            return undefined;
+    }
+}
+export function buildTerminalCardDescriptors(rows) {
+    return rows.map(buildTerminalCardDescriptor).filter((descriptor) => Boolean(descriptor));
+}
+function buildStatusCard(row) {
+    const data = parseRecord(row.output);
+    const model = recordField(data, "activeModel") ?? recordField(data, "model");
+    const statusView = buildTerminalStatusViewModel({
+        session: {
+            id: stringField(data, "piboSessionId") ?? stringField(data, "sessionId"),
+            title: stringField(data, "sessionTitle") ?? stringField(data, "title"),
+            profile: stringField(data, "profile") ?? stringField(data, "activeAgentId") ?? stringField(data, "agentId"),
+            status: boolField(data, "disposed") ? "disposed" : stringField(data, "sessionStatus"),
+        },
+        model: model ? { provider: stringField(model, "provider"), id: stringField(model, "id"), label: stringField(model, "label") } : undefined,
+        runtime: {
+            state: boolField(data, "disposed") ? "disposed" : boolField(data, "processing") ? "processing" : boolField(data, "streaming") ? "streaming" : stringField(data, "mode") ?? "idle",
+            connected: boolField(data, "connected"),
+            queuedMessages: numberField(data, "queuedMessages"),
+            processing: boolField(data, "processing"),
+            streaming: boolField(data, "streaming"),
+            disposed: boolField(data, "disposed"),
+        },
+        cwd: stringField(data, "cwd"),
+        contextUsage: recordField(data, "contextUsage"),
+        providerUsage: recordField(data, "providerUsage"),
+        tools: { enabled: arrayStringField(data, "enabledTools"), active: arrayStringField(data, "activeTools") },
+        thinking: stringField(data, "thinkingLevel") ? { level: stringField(data, "thinkingLevel") } : undefined,
+        fastMode: boolField(data, "fastMode"),
+        warnings: arrayStringField(data, "warnings"),
+        errors: arrayStringField(data, "errors"),
+        message: stringField(data, "message"),
+    });
+    return {
+        id: row.id,
+        kind: "status",
+        title: "Status",
+        status: row.status,
+        tone: row.status === "error" ? "red" : "green",
+        rows: statusView.fields.map((field) => ({ label: field.label, value: field.value, tone: field.tone })),
+        statusView,
+        sourceRowKind: row.kind,
+    };
+}
+function buildThinkingCard(row) {
+    const data = parseRecord(row.output);
+    const level = stringField(data, "level") ?? "unknown";
+    const supported = data?.supported === false ? false : true;
+    const levels = arrayStringField(data, "availableLevels");
+    return {
+        id: row.id,
+        kind: "thinking",
+        title: "Thinking",
+        status: row.status,
+        tone: supported ? "yellow" : "red",
+        rows: [{ label: "Current", value: redactTerminalSecret(level) }, { label: "Supported", value: supported ? "yes" : "no", tone: supported ? "green" : "red" }],
+        actions: levels.map((availableLevel) => ({ id: `thinking:${availableLevel}`, label: availableLevel, action: "thinking.set", value: availableLevel, disabled: !supported })),
+        sourceRowKind: row.kind,
+    };
+}
+function buildModelCard(row) {
+    const data = parseRecord(row.output);
+    const providers = arrayRecordField(data, "providers");
+    const actions = providers.flatMap((provider) => {
+        const providerId = stringField(provider, "id") ?? stringField(provider, "provider") ?? "provider";
+        const providerLabel = stringField(provider, "label") ?? stringField(provider, "name") ?? providerId;
+        return arrayRecordField(provider, "models").map((model) => {
+            const modelId = stringField(model, "id") ?? "model";
+            const label = stringField(model, "label") ?? modelId;
+            return { id: `model:${providerId}:${modelId}`, label: `${providerLabel} / ${label}`, action: "model.select", value: `${providerId}/${modelId}` };
+        });
+    });
+    return {
+        id: row.id,
+        kind: "model",
+        title: "Model",
+        status: row.status,
+        tone: actions.length ? "cyan" : "neutral",
+        rows: [{ label: "Providers", value: String(providers.length) }, { label: "Models", value: String(actions.length) }],
+        actions,
+        sourceRowKind: row.kind,
+    };
+}
+function buildLoginCard(row) {
+    const data = parseRecord(row.output);
+    const providers = arrayRecordField(data, "providers");
+    const actions = providers.map((provider) => {
+        const providerId = stringField(provider, "id") ?? "provider";
+        return {
+            id: `login:${providerId}`,
+            label: stringField(provider, "name") ?? stringField(provider, "label") ?? providerId,
+            action: "login.selectProvider",
+            value: providerId,
+            description: arrayStringField(provider, "authMethods").join(", "),
+        };
+    });
+    return {
+        id: row.id,
+        kind: "login",
+        title: "Login",
+        status: row.status,
+        tone: actions.length ? "cyan" : "neutral",
+        rows: [{ label: "Providers", value: String(providers.length) }],
+        actions,
+        sourceRowKind: row.kind,
+    };
+}
+function buildToolCard(row) {
+    const title = row.kind === "tool.group.exploring"
+        ? "Exploring"
+        : row.kind === "tool.image" || row.kind === "tool.group.images"
+            ? "Image"
+            : "Tool";
+    return baseCard(row, "tool", title, row.status === "error" ? "red" : row.status === "running" ? "cyan" : "green");
+}
+function baseCard(row, kind, title, tone) {
+    const rows = row.lines.flatMap((line) => {
+        const tokenText = line.tokens.map((token) => token.text).join("");
+        const functionText = line.functionCall ? `${line.functionCall.name}${line.functionCall.input !== undefined ? ` ${safeInlineJson(line.functionCall.input)}` : ""}` : "";
+        const text = `${tokenText}${functionText}`.trim();
+        return text ? [{ value: redactTerminalSecret(text) }] : [];
+    });
+    const output = row.lines.length === 0 && typeof row.output === "string" && row.output.trim()
+        ? [{ value: redactTerminalSecret(row.output.trim()) }]
+        : [];
+    const extraRows = [row.error ? { label: "Error", value: redactTerminalSecret(row.error), tone: "red" } : undefined]
+        .filter((item) => Boolean(item));
+    return {
+        id: row.id,
+        kind,
+        title,
+        status: row.status,
+        tone,
+        rows: [...rows, ...output, ...extraRows],
+        sourceRowKind: row.kind,
+    };
+}
+function safeInlineJson(value) {
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+function parseRecord(value) {
+    if (!value)
+        return undefined;
+    if (typeof value === "string") {
+        try {
+            const parsed = JSON.parse(value);
+            return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    return typeof value === "object" && !Array.isArray(value) ? value : undefined;
+}
+function recordField(record, key) {
+    const value = record?.[key];
+    return value && typeof value === "object" && !Array.isArray(value) ? value : undefined;
+}
+function arrayRecordField(record, key) {
+    const value = record?.[key];
+    return Array.isArray(value) ? value.filter((item) => Boolean(item) && typeof item === "object" && !Array.isArray(item)) : [];
+}
+function arrayStringField(record, key) {
+    const value = record?.[key];
+    return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+}
+function stringField(record, key) {
+    const value = record?.[key];
+    return typeof value === "string" ? value : undefined;
+}
+function numberField(record, key) {
+    const value = record?.[key];
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function boolField(record, key) {
+    const value = record?.[key];
+    return typeof value === "boolean" ? value : undefined;
+}