@vibefield/rosetta-room 0.0.0-stage → 0.1.1

package/dist/components/transcript/activity-plan.js

@@ -0,0 +1,209 @@
+import { runSummary } from "../../lib/transcript/ledger.js";
+import { collaborationStamp } from "../../lib/transcript/collaboration.js";
+import { noticeText } from "../../lib/transcript/vocabulary.js";
+export function activityRows(item) {
+    if (item.kind === "tool")
+        return item.line.rows;
+    if (item.kind === "prompt")
+        return item.prompt.rows;
+    return item.kind === "compaction" ? item.rows : [item.row];
+}
+export function activityRowKey(row) {
+    return `${row.session_id}:${row.timeline_id}`;
+}
+function eventAt(row) {
+    return row.body.type === "collaboration" ? collaborationStamp(row).at : row.at;
+}
+/** Tool lines must already have been cut at these boundaries before coalescing. */
+export function activityCuts(rows, watermark, displayedRows = rows) {
+    const gaps = new Map();
+    const previous = new Map();
+    let watermarkId = null;
+    for (const row of rows) {
+        const ordinal = previous.get(row.session_id);
+        if (ordinal !== undefined && row.ordinal > ordinal + 1)
+            gaps.set(row.timeline_id, row.ordinal - ordinal - 1);
+        previous.set(row.session_id, row.ordinal);
+        if (watermarkId === null && watermark !== null && row.ordinal > watermark)
+            watermarkId = row.timeline_id;
+    }
+    // A delivery copy may be removed by ownership reconciliation. Keep its
+    // paging boundary before the next surviving source event, never discard it.
+    if (displayedRows !== rows) {
+        const displayed = new Set(displayedRows.map(row => row.timeline_id));
+        let next = null;
+        // i walks rows from its last index down to 0.
+        const rowAt = (index) => rows[index];
+        for (let i = rows.length - 1; i >= 0; i -= 1) {
+            const id = rowAt(i).timeline_id;
+            if (displayed.has(id)) {
+                next = id;
+                continue;
+            }
+            const gap = gaps.get(id);
+            if (gap !== undefined) {
+                gaps.delete(id);
+                if (next !== null)
+                    gaps.set(next, (gaps.get(next) ?? 0) + gap);
+            }
+            if (watermarkId === id)
+                watermarkId = next;
+        }
+    }
+    return { gaps, watermarkId, cutBefore: new Set([...gaps.keys(), ...(watermarkId === null ? [] : [watermarkId])]) };
+}
+export function activityPlan(plan, options) {
+    const headed = new Set();
+    let firstContent = true;
+    const bounded = new Set();
+    return plan.map(({ sitting, parts }) => {
+        const blocks = [];
+        let items = [];
+        let partial = false;
+        const flush = () => {
+            if (items.length === 0)
+                return;
+            const rows = items.flatMap(activityRows);
+            blocks.push({ kind: "activity", key: `activity:${activityRowKey(rows[0])}`, items, rows, partial, at: eventAt(rows[0]) });
+            items = [];
+            partial = false;
+        };
+        const boundary = (rows) => {
+            for (const row of rows) {
+                if (bounded.has(row.timeline_id))
+                    continue;
+                bounded.add(row.timeline_id);
+                const gap = options.gaps.get(row.timeline_id);
+                if (gap !== undefined) {
+                    flush();
+                    blocks.push({ kind: "gap", key: `gap:${activityRowKey(row)}`, count: gap, at: eventAt(row) });
+                }
+                if (row.timeline_id === options.watermarkId) {
+                    flush();
+                    blocks.push({ kind: "watermark", key: `watermark:${activityRowKey(row)}`, at: eventAt(row) });
+                }
+            }
+        };
+        const secondary = (item) => {
+            const rows = activityRows(item);
+            boundary(rows);
+            const request = (item.kind === "tool" && item.line.family === "question") ||
+                (item.kind === "marker" && item.notice.type === "permission_requested");
+            if (request) {
+                flush();
+                blocks.push({ kind: "request", key: item.key, item, at: eventAt(rows[0]) });
+            }
+            else {
+                if ((firstContent || rows.some(row => options.gaps.has(row.timeline_id))) && options.partial)
+                    partial = true;
+                items.push(item);
+            }
+            firstContent = false;
+        };
+        for (const part of parts) {
+            const human = [];
+            const flushPrompts = () => {
+                if (human.length === 0)
+                    return;
+                flush();
+                blocks.push({ kind: "prompt", key: human[0].key, prompts: human.splice(0), at: part.at });
+                firstContent = false;
+            };
+            for (const prompt of part.prompts) {
+                if (prompt.machine !== null || prompt.fromParent || prompt.row.body.type !== "user") {
+                    flushPrompts();
+                    secondary({ kind: "prompt", key: prompt.key, prompt });
+                }
+                else {
+                    // A settings cluster can straddle a loaded gap or live watermark.
+                    // Finish its earlier prompts before drawing the boundary marker.
+                    if (prompt.rows.some(row => options.gaps.has(row.timeline_id) || row.timeline_id === options.watermarkId))
+                        flushPrompts();
+                    boundary([prompt.row]);
+                    human.push(prompt);
+                    // A setting's normalized value belongs to the user's command pill.
+                    // Other machine output receives its own context disclosure.
+                    if (prompt.commandOutputRow !== null && prompt.setting === null) {
+                        human[human.length - 1] = { ...prompt, commandOutput: null };
+                        flushPrompts();
+                        const row = prompt.commandOutputRow;
+                        if (row.body.type === "notice")
+                            secondary({ kind: "marker", key: row.timeline_id,
+                                row, at: row.at, notice: row.body.notice, text: noticeText(row.body.notice), tone: "plain" });
+                    }
+                }
+            }
+            flushPrompts();
+            for (const segment of [...part.before, ...part.after]) {
+                if (segment.kind === "prose") {
+                    boundary([segment.row]);
+                    flush();
+                    blocks.push({ kind: "reply", key: segment.key, segment,
+                        head: headed.has(part.turn.key) ? null : part.turn.head, at: segment.at });
+                    headed.add(part.turn.key);
+                    firstContent = false;
+                }
+                else if (segment.kind === "ledger") {
+                    for (const member of segment.members)
+                        secondary(member.kind === "line"
+                            ? { kind: "tool", key: member.key, line: member.line } : member);
+                }
+                else
+                    secondary(segment);
+            }
+        }
+        flush();
+        return { sitting, blocks };
+    });
+}
+export function summarizeActivity(items) {
+    const lines = items.flatMap(item => item.kind === "tool" ? [item.line] : []);
+    const toolSummary = runSummary(lines);
+    const counts = new Map();
+    let failed = toolSummary.failed;
+    let interrupted = 0;
+    let cancelled = 0;
+    const runningRows = [];
+    const count = (name) => counts.set(name, (counts.get(name) ?? 0) + 1);
+    for (const item of items) {
+        const row = activityRows(item)[0];
+        if (item.kind === "tool") {
+            if (item.line.state === "running")
+                runningRows.push(...item.line.rows);
+            interrupted += item.line.rows.filter(row => row.body.type === "tool_use" && row.body.tool.status.value === "interrupted").length;
+            cancelled += item.line.rows.filter(row => row.body.type === "tool_use" && row.body.tool.status.value === "cancelled").length;
+            continue;
+        }
+        if (row.body.type === "collaboration") {
+            const event = row.body.event;
+            count(event.kind === "report" ? "report" : event.kind === "assignment" ? "assignment" :
+                event.kind !== "message" ? "team update" : event.channel === "peer" ? "peer message" :
+                    event.channel === "coordinator" ? "coordinator follow-up" : "team message");
+            if (event.status === "failed")
+                failed += 1;
+        }
+        else if (item.kind === "thinking")
+            count("thought");
+        else if (item.kind === "prompt" && item.prompt.fromParent)
+            count("assignment");
+        else
+            count("context event");
+        if (item.kind === "marker") {
+            if (item.tone === "failed")
+                failed += 1;
+            if (item.notice.type === "async_task") {
+                if (["running", "pending"].includes(item.notice.status))
+                    runningRows.push(item.row);
+                if (item.notice.status === "interrupted")
+                    interrupted += 1;
+                if (item.notice.status === "cancelled")
+                    cancelled += 1;
+            }
+        }
+    }
+    const nouns = toolSummary.nouns.map(noun => ({ ...noun, key: noun.family }));
+    for (const [name, total] of counts)
+        nouns.push({ key: name, text: `${total} ${name}${total === 1 ? "" : "s"}`, names: [], more: 0 });
+    const stamps = items.flatMap(activityRows).map(eventAt).filter((at) => at !== null);
+    return { nouns, failed, interrupted, cancelled, runningRows, firstAt: stamps[0] ?? null, lastAt: stamps.at(-1) ?? null };
+}

package/dist/components/transcript/attachment-file-source.d.ts

@@ -0,0 +1,23 @@
+import type { AssetRef } from "@vibefield/rosetta-protocol";
+import type { AttachmentFact } from "../../lib/transcript/index.js";
+import type { AssetSource } from "../../ports.js";
+import type { FileHandle, FileSource } from "../file-viewer/index.js";
+import type { ImageResource } from "../file-viewer/types.js";
+/** Reads one stored member's bytes. */
+export type AssetReader = (asset: AssetRef, signal: AbortSignal) => Promise<Uint8Array>;
+export interface AttachmentReader {
+    /** The address of bytes the daemon kept, never a provider-authored path. */
+    assetUrl(fact: AttachmentFact): string | null;
+    imageResource(fact: AttachmentFact): ImageResource | null;
+    /** A stored transcript asset as the generic file viewer understands it. */
+    handleFor(fact: AttachmentFact): FileHandle | null;
+    canOpen(fact: AttachmentFact): boolean;
+    /** Stable by construction: `useFileContent` treats source identity as a read. */
+    readonly fileSource: FileSource;
+    readonly readAsset: AssetReader;
+}
+export declare function attachmentViewerName(fact: AttachmentFact): string;
+export declare function createAttachmentReader(assets: AssetSource, readAsset: AssetReader): AttachmentReader;
+/** The attachment reader for the document being read here: the host's
+ * addresses, and bytes through the reading session's client. */
+export declare function useAttachmentReader(): AttachmentReader;

package/dist/components/transcript/attachment-file-source.js

@@ -0,0 +1,103 @@
+// Transcript attachments through the room's existing file-viewer seam.
+//
+// The viewer deliberately knows neither the daemon nor the transcript. This
+// adapter turns a canonical content-addressed asset into the same `FileHandle`
+// + `FileSource` pair the worktree supplies, so thumbnails and inline image
+// markers open the established image view instead of navigating the page.
+// Addresses come from the host's asset source; bytes ride the reading
+// session's client.
+import { useMemo } from "react";
+import { useReadingSession, useRoom } from "../../room-context.js";
+import { resolveKind } from "../file-viewer/index.js";
+import { isOptimizedImageAsset } from "../../lib/image-media.js";
+const EXTENSION_BY_MEDIA_TYPE = new Map([
+    ["image/png", "png"],
+    ["image/jpeg", "jpg"],
+    ["image/jpg", "jpg"],
+    ["image/gif", "gif"],
+    ["image/webp", "webp"],
+    ["image/avif", "avif"],
+    ["image/bmp", "bmp"],
+    ["image/x-icon", "ico"],
+    ["image/apng", "apng"],
+    ["image/svg+xml", "svg"],
+]);
+export function attachmentViewerName(fact) {
+    const source = fact.ref?.source;
+    const base = fact.name?.trim() ||
+        fact.ref?.label?.trim() ||
+        "Image";
+    const kind = resolveKind(base).viewer.id;
+    if (kind === "image" || kind === "svg")
+        return base;
+    const mediaType = fact.mediaType ?? (source?.type === "asset" ? source.asset.media_type : null);
+    const extension = mediaType === null ? undefined : EXTENSION_BY_MEDIA_TYPE.get(mediaType.toLowerCase());
+    return extension === undefined ? base : `${base}.${extension}`;
+}
+/** One stored image as the viewer asks for it: by rendition, through the host. */
+function imageOf(assets, asset, width, height) {
+    return { key: asset.digest, url: (rendition) => assets.imageAssetUrl(asset, rendition), width, height };
+}
+export function createAttachmentReader(assets, readAsset) {
+    function assetUrl(fact) {
+        const source = fact.ref?.source;
+        if (source === undefined || source === null || source.type !== "asset")
+            return null;
+        if (fact.kind === "image" && !isOptimizedImageAsset(source.asset))
+            return null;
+        return assets.attachmentAssetUrl(source.asset);
+    }
+    function imageResource(fact) {
+        const source = fact.ref?.source;
+        const asset = source?.type === "asset" && assetUrl(fact) !== null ? source.asset : null;
+        if (!asset || !isOptimizedImageAsset(asset))
+            return null;
+        return imageOf(assets, asset, fact.ref?.dimensions?.width, fact.ref?.dimensions?.height);
+    }
+    function handleFor(fact) {
+        const source = fact.ref?.source;
+        const url = assetUrl(fact);
+        if (source === undefined || source === null || source.type !== "asset" || url === null)
+            return null;
+        return {
+            key: `attachment:${source.asset.digest}`,
+            name: attachmentViewerName(fact),
+            path: null,
+            size: fact.byteLen ?? source.asset.byte_len,
+            ref: source.asset,
+        };
+    }
+    const fileSource = {
+        image(handle) {
+            const asset = handle.ref;
+            if (!asset || !isOptimizedImageAsset(asset))
+                return null;
+            return imageOf(assets, asset);
+        },
+        async read(handle, signal) {
+            const asset = handle.ref;
+            if (!asset || !isOptimizedImageAsset(asset))
+                throw new Error("that attachment is no longer available");
+            return readAsset(asset, signal);
+        },
+    };
+    return {
+        assetUrl,
+        imageResource,
+        handleFor,
+        canOpen: (fact) => fact.kind === "image" && handleFor(fact) !== null,
+        fileSource,
+        readAsset,
+    };
+}
+/** The attachment reader for the document being read here: the host's
+ * addresses, and bytes through the reading session's client. */
+export function useAttachmentReader() {
+    const { assets, sessions } = useRoom();
+    const sessionId = useReadingSession();
+    return useMemo(() => createAttachmentReader(assets, (asset, signal) => {
+        if (sessionId === null)
+            return Promise.reject(new Error("No session is open to read that attachment"));
+        return sessions.run(sessionId, (client) => client.readAsset(asset, signal));
+    }), [assets, sessions, sessionId]);
+}

package/dist/components/transcript/attachment-gallery.d.ts

@@ -0,0 +1,12 @@
+import type { AttachmentFact } from "../../lib/transcript/index.js";
+import type { FileSource } from "../file-viewer/index.js";
+import type { GalleryImage } from "../file-viewer/ImageGalleryDialog.js";
+import type { AttachmentReader } from "./attachment-file-source.js";
+export type AttachmentOpener = (fact: AttachmentFact, row?: readonly AttachmentFact[]) => void;
+/** Snapshot just the row that was opened, including distinct uses of one asset. */
+export declare function attachmentGallery(reader: AttachmentReader, fact: AttachmentFact, row?: readonly AttachmentFact[]): {
+    images: GalleryImage[];
+    initialKey: string;
+};
+/** Transcript galleries read only optimized members committed during ingestion. */
+export declare function createAttachmentGallerySource(reader: AttachmentReader): FileSource;

package/dist/components/transcript/attachment-gallery.js

@@ -0,0 +1,33 @@
+import { attachmentViewerName } from "./attachment-file-source.js";
+/** Snapshot just the row that was opened, including distinct uses of one asset. */
+export function attachmentGallery(reader, fact, row = [fact]) {
+    const images = row.filter(item => item.kind === "image").map((item, index) => {
+        const image = item.key === fact.key ? fact : item;
+        const asset = image.ref?.source.type === "asset" ? image.ref.source.asset : null;
+        return {
+            key: image.key,
+            label: image.ref?.label ?? `Image ${index + 1}`,
+            handle: reader.canOpen(image) ? {
+                key: image.key, name: attachmentViewerName(image),
+                path: null,
+                size: image.byteLen ?? asset?.byte_len ?? -1,
+                ref: image,
+            } : null,
+        };
+    });
+    return { images, initialKey: fact.key };
+}
+/** Transcript galleries read only optimized members committed during ingestion. */
+export function createAttachmentGallerySource(reader) {
+    return {
+        image(handle) { return reader.imageResource(handle.ref); },
+        async read(handle, signal) {
+            const fact = handle.ref;
+            if (signal.aborted)
+                throw new DOMException("Image read cancelled", "AbortError");
+            if (reader.canOpen(fact) && fact.ref?.source.type === "asset")
+                return reader.readAsset(fact.ref.source.asset, signal);
+            throw new Error("Image data was not recorded");
+        },
+    };
+}

package/dist/components/transcript/detail-parts.d.ts

@@ -0,0 +1,50 @@
+import type { TaskSnapshotItem } from "@vibefield/rosetta-protocol";
+import type { CommandFact, Diffstat, PathFact, TaskChange } from "../../lib/transcript/index.js";
+import type { CanonicalDocument, CollaboratorRef, DisplayField, FileDelta, FindingItem, UserAnswer, UserQuestion } from "../../lib/transcript/protocol.js";
+/** A bounded list is a list; an unbounded one is a scroll trap in the measure. */
+export declare const LIST_CAP = 24;
+export declare function PathList({ paths, total, onOpenPath, }: {
+    readonly paths: readonly PathFact[];
+    readonly total: number;
+    readonly onOpenPath?: ((path: PathFact) => void) | undefined;
+}): import("react").JSX.Element;
+/** A task action opens to a three-row glimpse immediately after that action.
+ * The changed row stays last; the reader can disclose the complete board. */
+export declare function Tasks({ tasks, total, changedTaskId, change, }: {
+    readonly tasks: readonly TaskSnapshotItem[];
+    readonly total: number;
+    readonly changedTaskId: string | null;
+    readonly change: TaskChange | null;
+}): import("react").JSX.Element;
+export declare function DiffLines({ delta }: {
+    readonly delta: FileDelta;
+}): import("react").JSX.Element;
+export declare function DiffDetail({ deltas, diffstat, }: {
+    readonly deltas: readonly FileDelta[];
+    readonly diffstat: Diffstat;
+}): import("react").JSX.Element;
+export declare function CommandList({ commands, code, }: {
+    readonly commands: readonly CommandFact[];
+    readonly code: boolean;
+}): import("react").JSX.Element;
+/** Conversation, so it opens by default: the questions with their options and
+ * the answer marked in primary ink. */
+export declare function Questions({ questions, answers, }: {
+    readonly questions: readonly UserQuestion[];
+    readonly answers: readonly UserAnswer[];
+}): import("react").JSX.Element;
+export declare function Findings({ findings, total }: {
+    readonly findings: readonly FindingItem[];
+    readonly total: number;
+}): import("react").JSX.Element;
+export declare function Fields({ fields }: {
+    readonly fields: readonly DisplayField[];
+}): import("react").JSX.Element | null;
+export declare function Document({ document }: {
+    readonly document: CanonicalDocument;
+}): import("react").JSX.Element;
+export declare function Participants({ participants, total, body, }: {
+    readonly participants: readonly CollaboratorRef[];
+    readonly total: number;
+    readonly body: string | null;
+}): import("react").JSX.Element;