@vibefield/rosetta-room 0.0.0-stage → 0.1.0

package/dist/components/file-viewer/diff/parse.js

@@ -0,0 +1,164 @@
+// Parsing one file's unified diff, as `git diff` writes it.
+//
+// One file per call. git will happily emit many in one run; the column asks
+// per file, because the viewer shows one file and a parser that returns a
+// list would only be unpacked at every call site.
+/** `@@ -12,7 +12,9 @@ fn walk()` — counts are optional and default to 1. */
+const HUNK = /^@@+ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@+(.*)$/;
+/** Codex `apply_patch` also persists location-free `@@` hunks. */
+const UNPOSITIONED_HUNK = /^@@(?:\s+(.*))?$/;
+const EMPTY = {
+    oldPath: null,
+    newPath: null,
+    hunks: [],
+    absence: "unchanged",
+    renamedFrom: null,
+    added: 0,
+    deleted: 0,
+};
+/** `a/src/main.rs` → `src/main.rs`; `/dev/null` → null. */
+function pathOf(raw) {
+    const trimmed = raw.trim();
+    if (trimmed === "/dev/null" || trimmed === "")
+        return null;
+    // git quotes a path containing anything unusual, and escapes it C-style.
+    const unquoted = trimmed.startsWith('"') && trimmed.endsWith('"')
+        ? trimmed.slice(1, -1).replace(/\\(.)/g, "$1")
+        : trimmed;
+    return unquoted.replace(/^[ab]\//, "");
+}
+/** The header's path, with the timestamp `--- a/x.ts\t2026-08-30` can carry. */
+function headerPath(line, marker) {
+    return pathOf(line.slice(marker.length).split("\t")[0]);
+}
+export function parseDiff(text) {
+    if (text.trim() === "")
+        return EMPTY;
+    const lines = text.split("\n");
+    const hunks = [];
+    let oldPath = null;
+    let newPath = null;
+    let renamedFrom = null;
+    let absence = null;
+    let added = 0;
+    let deleted = 0;
+    // `---` and `+++` are authoritative — `/dev/null` on one of them is how an
+    // add or a delete is spelled. `diff --git a/x b/y` is only a FALLBACK, for
+    // a pure rename or mode change where those two lines do not appear; it must
+    // never overwrite a `/dev/null` with a path, which is what an
+    // already-assigned `??=` quietly did.
+    let sawOldMarker = false;
+    let sawNewMarker = false;
+    let statedOld = null;
+    let statedNew = null;
+    let current = null;
+    let oldNumber = 0;
+    let newNumber = 0;
+    const close = (header, oldStart, newStart) => {
+        if (current !== null && current.length > 0) {
+            hunks.push({ header, oldStart, newStart, lines: current });
+        }
+        current = null;
+    };
+    let header = "";
+    let oldStart = 0;
+    let newStart = 0;
+    for (const line of lines) {
+        const hunk = HUNK.exec(line);
+        if (hunk !== null) {
+            close(header, oldStart, newStart);
+            header = hunk[5].trim();
+            oldStart = Number.parseInt(hunk[1], 10);
+            newStart = Number.parseInt(hunk[3], 10);
+            oldNumber = oldStart;
+            newNumber = newStart;
+            current = [];
+            continue;
+        }
+        const unpositioned = UNPOSITIONED_HUNK.exec(line);
+        if (unpositioned !== null) {
+            close(header, oldStart, newStart);
+            header = (unpositioned[1] ?? "").trim();
+            oldStart = null;
+            newStart = null;
+            oldNumber = null;
+            newNumber = null;
+            current = [];
+            continue;
+        }
+        if (current === null) {
+            // Still in the file header: the preamble git writes before the hunks.
+            if (line.startsWith("--- ") && !sawOldMarker) {
+                sawOldMarker = true;
+                oldPath = headerPath(line, "--- ");
+            }
+            else if (line.startsWith("+++ ") && !sawNewMarker) {
+                sawNewMarker = true;
+                newPath = headerPath(line, "+++ ");
+            }
+            else if (line.startsWith("rename from "))
+                renamedFrom = pathOf(line.slice(12));
+            else if (line.startsWith("Binary files") || line.startsWith("GIT binary patch")) {
+                absence = "binary";
+            }
+            else if (line.startsWith("diff --git ")) {
+                // `diff --git a/x b/y`, which is the only place a path appears when
+                // the change is a pure rename or a mode change — there are no `---`
+                // and `+++` lines in that case.
+                const both = line.slice(11);
+                const half = Math.floor(both.length / 2);
+                const split = both.lastIndexOf(" b/", half + 2);
+                if (split !== -1) {
+                    statedOld = pathOf(both.slice(0, split));
+                    statedNew = pathOf(both.slice(split + 1));
+                }
+            }
+            else if (line.startsWith("old mode ") || line.startsWith("new mode ")) {
+                absence ??= "mode-only";
+            }
+            continue;
+        }
+        // Inside a hunk. An empty line is a context line whose leading space git
+        // dropped — real diffs in the wild carry them, and treating one as the
+        // end of the hunk truncates the file at its first blank line.
+        const marker = line === "" ? " " : line[0];
+        const body = line === "" ? "" : line.slice(1);
+        if (marker === "+") {
+            current.push({ kind: "add", text: body, oldNumber: null, newNumber });
+            if (newNumber !== null)
+                newNumber += 1;
+            added += 1;
+        }
+        else if (marker === "-") {
+            current.push({ kind: "del", text: body, oldNumber, newNumber: null });
+            if (oldNumber !== null)
+                oldNumber += 1;
+            deleted += 1;
+        }
+        else if (marker === " ") {
+            current.push({ kind: "context", text: body, oldNumber, newNumber });
+            if (oldNumber !== null)
+                oldNumber += 1;
+            if (newNumber !== null)
+                newNumber += 1;
+        }
+        else if (marker === "\\") {
+            current.push({ kind: "note", text: body.trim(), oldNumber: null, newNumber: null });
+        }
+        else {
+            // Anything else ends the hunk: the next file's header, or trailing
+            // output the caller did not strip.
+            close(header, oldStart, newStart);
+        }
+    }
+    close(header, oldStart, newStart);
+    return {
+        oldPath: sawOldMarker ? oldPath : statedOld,
+        newPath: sawNewMarker ? newPath : statedNew,
+        hunks,
+        absence: hunks.length > 0 ? null : (absence ?? "unchanged"),
+        renamedFrom,
+        added,
+        deleted,
+    };
+}

package/dist/components/file-viewer/diff/types.d.ts

@@ -0,0 +1,44 @@
+export type DiffLineKind = 
+/** Unchanged, shown on both sides. */
+"context" | "add" | "del"
+/** `` — git's own note about the line above. */
+ | "note";
+export interface DiffLine {
+    readonly kind: DiffLineKind;
+    readonly text: string;
+    /** Line number on the left, or null for an added line. */
+    readonly oldNumber: number | null;
+    /** Line number on the right, or null for a removed line. */
+    readonly newNumber: number | null;
+}
+export interface DiffHunk {
+    /** The `@@ … @@` line, whose trailing text git fills with the enclosing
+     * function or section — worth showing, and not ours to invent. */
+    readonly header: string;
+    /** Null when the source persisted a hunk but omitted its coordinates, as
+     * Codex's `apply_patch` dialect may do with a bare `@@`. */
+    readonly oldStart: number | null;
+    readonly newStart: number | null;
+    readonly lines: readonly DiffLine[];
+}
+/** Why a diff has no hunks, when it has none. */
+export type DiffAbsence = 
+/** The two sides are identical. */
+"unchanged"
+/** git declined to diff it: `Binary files … differ`. */
+ | "binary"
+/** The file's mode changed and its content did not. */
+ | "mode-only";
+export interface ParsedDiff {
+    /** Path on the left, or null when the file is being added. */
+    readonly oldPath: string | null;
+    /** Path on the right, or null when the file is being deleted. */
+    readonly newPath: string | null;
+    readonly hunks: readonly DiffHunk[];
+    /** Set when `hunks` is empty and that is a fact rather than an error. */
+    readonly absence: DiffAbsence | null;
+    /** `old → new` when git detected a rename. */
+    readonly renamedFrom: string | null;
+    readonly added: number;
+    readonly deleted: number;
+}

package/dist/components/file-viewer/diff/types.js

@@ -0,0 +1,7 @@
+// A unified diff, parsed.
+//
+// The viewer displays diffs; it does not compute them. git already knows
+// which lines changed — including the rename and binary cases that a naive
+// line differ gets wrong — so the room reads git's answer rather than
+// deriving a second one that can disagree with it.
+export {};

package/dist/components/file-viewer/gallery-source.d.ts

@@ -0,0 +1,11 @@
+import type { FileHandle, FileSource } from "./types.js";
+/** Share thumbnail/main-image reads for one open gallery. Released on close;
+ * the byte cache is bounded even when a row contains many large images. */
+export declare function createGallerySource(source: FileSource, limit?: number): {
+    source: {
+        read: (handle: FileHandle, signal: AbortSignal) => Promise<Uint8Array>;
+        image: ((handle: FileHandle) => import("./types.js").ImageResource | null) | undefined;
+    };
+    invalidate: (key: string) => void;
+    dispose: () => void;
+};

package/dist/components/file-viewer/gallery-source.js

@@ -0,0 +1,75 @@
+/** Share thumbnail/main-image reads for one open gallery. Released on close;
+ * the byte cache is bounded even when a row contains many large images. */
+export function createGallerySource(source, limit = 64 * 1024 * 1024) {
+    const cache = new Map();
+    let size = 0;
+    const pending = new Map();
+    const forget = (key) => {
+        size -= cache.get(key)?.byteLength ?? 0;
+        cache.delete(key);
+    };
+    const read = (handle, signal) => {
+        const cancelled = () => new DOMException("Image read cancelled", "AbortError");
+        if (signal.aborted)
+            return Promise.reject(cancelled());
+        const cached = cache.get(handle.key);
+        if (cached) {
+            cache.delete(handle.key);
+            cache.set(handle.key, cached);
+            return Promise.resolve(cached);
+        }
+        let request = pending.get(handle.key);
+        if (!request) {
+            const controller = new AbortController();
+            const created = { controller, readers: 0, done: false, promise: Promise.resolve(new Uint8Array()) };
+            created.promise = Promise.resolve().then(() => source.read(handle, controller.signal)).then(bytes => {
+                if (!controller.signal.aborted && bytes.byteLength <= limit) {
+                    forget(handle.key);
+                    while (size + bytes.byteLength > limit && cache.size)
+                        forget(cache.keys().next().value);
+                    cache.set(handle.key, bytes);
+                    size += bytes.byteLength;
+                }
+                return bytes;
+            }).finally(() => {
+                created.done = true;
+                if (pending.get(handle.key) === created)
+                    pending.delete(handle.key);
+            });
+            request = created;
+            pending.set(handle.key, created);
+        }
+        const active = request;
+        active.readers += 1;
+        return new Promise((resolve, reject) => {
+            let finished = false;
+            const finish = (result) => {
+                if (finished)
+                    return;
+                finished = true;
+                signal.removeEventListener("abort", abort);
+                active.readers -= 1;
+                if (active.readers === 0 && !active.done) {
+                    active.controller.abort();
+                    if (pending.get(handle.key) === active)
+                        pending.delete(handle.key);
+                }
+                result();
+            };
+            const abort = () => finish(() => reject(cancelled()));
+            signal.addEventListener("abort", abort, { once: true });
+            active.promise.then(bytes => finish(() => resolve(bytes)), error => finish(() => reject(error)));
+        });
+    };
+    return {
+        source: { read, image: source.image?.bind(source) },
+        invalidate: (key) => forget(key),
+        dispose: () => {
+            for (const request of pending.values())
+                request.controller.abort();
+            pending.clear();
+            cache.clear();
+            size = 0;
+        },
+    };
+}

package/dist/components/file-viewer/image-resource.d.ts

@@ -0,0 +1,19 @@
+import type { RefObject } from "react";
+import type { ImageRendition, ImageResource } from "./types.js";
+/** A retry's address. A daemon URL gets a cache-busting parameter; an object
+ * or data URL cannot carry one, so it is used as it is (its source was asked
+ * again for the retry). */
+export declare function imageRequestUrl(url: string, attempt?: number): string;
+export interface ResolvedImageUrl {
+    /** The address to load, or null while pending or when there is none. */
+    readonly url: string | null;
+    /** The source is still fetching this rendition. */
+    readonly pending: boolean;
+}
+/** One rendition's address, asked of its source once per image, rendition and
+ * attempt. A source that answers at once answers in this render, exactly as a
+ * plain string did; one that must fetch first answers when it has the bytes. */
+export declare function useImageUrl(resource: ImageResource | null | undefined, rendition: ImageRendition, attempt?: number): ResolvedImageUrl;
+/** Stop retaining image elements outside the reading window, including after
+ * a horizontal rail was scrolled through. Browser caching owns reusable bytes. */
+export declare function useImageVisibility(ref: RefObject<HTMLElement | null>, rail?: boolean): boolean;

package/dist/components/file-viewer/image-resource.js

@@ -0,0 +1,60 @@
+import { useEffect, useMemo, useState } from "react";
+/** A retry's address. A daemon URL gets a cache-busting parameter; an object
+ * or data URL cannot carry one, so it is used as it is (its source was asked
+ * again for the retry). */
+export function imageRequestUrl(url, attempt = 0) {
+    if (attempt === 0)
+        return url;
+    const value = new URL(url, window.location.href);
+    if (value.protocol !== "http:" && value.protocol !== "https:")
+        return url;
+    value.searchParams.set("retry", String(attempt));
+    return value.toString();
+}
+const NONE = { url: null, pending: false };
+/** One rendition's address, asked of its source once per image, rendition and
+ * attempt. A source that answers at once answers in this render, exactly as a
+ * plain string did; one that must fetch first answers when it has the bytes. */
+export function useImageUrl(resource, rendition, attempt = 0) {
+    const key = resource ? `${resource.key}\u0000${rendition}\u0000${attempt}` : null;
+    // Keyed by identity, not by the resource object: a parent may rebuild the
+    // resource every render, and a fetching source must not be asked each time.
+    const answer = useMemo(() => (resource ? resource.url(rendition) : null), [key]);
+    const [settled, setSettled] = useState(null);
+    useEffect(() => {
+        if (key === null || answer === null || typeof answer === "string")
+            return;
+        let live = true;
+        Promise.resolve(answer).then((url) => {
+            if (live)
+                setSettled({ key, url });
+        }, () => {
+            if (live)
+                setSettled({ key, url: null });
+        });
+        return () => {
+            live = false;
+        };
+    }, [key, answer]);
+    if (key === null || answer === null)
+        return NONE;
+    if (typeof answer === "string")
+        return { url: imageRequestUrl(answer, attempt), pending: false };
+    return settled?.key === key ? { url: settled.url, pending: false } : { url: null, pending: true };
+}
+/** Stop retaining image elements outside the reading window, including after
+ * a horizontal rail was scrolled through. Browser caching owns reusable bytes. */
+export function useImageVisibility(ref, rail = false) {
+    const [visible, setVisible] = useState(false);
+    useEffect(() => {
+        const node = ref.current;
+        if (!node)
+            return;
+        const observer = new IntersectionObserver(entries => {
+            setVisible(entries.some(entry => entry.isIntersecting));
+        }, { root: rail ? node.closest(".ah-image-gallery__rail") : null, rootMargin: rail ? "80px" : "240px" });
+        observer.observe(node);
+        return () => observer.disconnect();
+    }, [ref, rail]);
+    return visible;
+}

package/dist/components/file-viewer/index.d.ts

@@ -0,0 +1,5 @@
+export { FileViewerDialog } from "./FileViewerDialog.js";
+export type { FileViewerDialogProps } from "./FileViewerDialog.js";
+export { diffKind, resolveKind } from "./registry.js";
+export { DiffBody } from "./views/DiffBody.js";
+export type { FileHandle, FileKind, FileSource, OpenFile, ViewBodyProps, ViewerActionId, ViewerDefinition, ViewMode, } from "./types.js";

package/dist/components/file-viewer/index.js

@@ -0,0 +1,8 @@
+// The file viewer: a popup that shows one file, with a view per kind of file.
+//
+// It depends on nothing above it. Give it a name, a size and a `FileSource`,
+// and it reads and draws the file — which is why the worktree column owns the
+// engine and this owns none of it.
+export { FileViewerDialog } from "./FileViewerDialog.js";
+export { diffKind, resolveKind } from "./registry.js";
+export { DiffBody } from "./views/DiffBody.js";

package/dist/components/file-viewer/markdown/blocks.d.ts

@@ -0,0 +1,2 @@
+import type { Block } from "./types.js";
+export declare function parseBlocks(lines: readonly string[], sources?: readonly (readonly number[])[]): readonly Block[];