@vibefield/rosetta-room 0.0.0-stage → 0.1.0

package/dist/components/worktree/worktree-file-commands.js

@@ -0,0 +1,112 @@
+import { fileActionTargetForId } from "@vibecook/mille-ui";
+import { createCommandRegistry } from "@vibecook/mille-ui/commands";
+/** One registry per engine generation. Menu commands receive Mille's live
+ * context; keyboard commands get the same selection through its observers. */
+export function createWorktreeFileCommands(engine, environment) {
+    let selectedIds = new Set();
+    let focusedId = null;
+    const emptyIds = new Set();
+    const available = () => {
+        const { actions, stale } = environment();
+        return !stale && typeof actions?.fileAction === "function";
+    };
+    const hasSelection = (ctx) => available() && ctx.selectedIds.size > 0;
+    async function perform(ctx, action) {
+        const { actions, platform, onReceipt } = environment();
+        if (!available() || actions === null || ctx.selectedIds.size === 0)
+            return;
+        const ids = action === "copyPath"
+            ? [...ctx.selectedIds]
+            : ctx.focusedId !== null && ctx.selectedIds.has(ctx.focusedId)
+                ? [ctx.focusedId]
+                : [];
+        if (ids.length === 0)
+            return;
+        try {
+            const paths = ids.map((id) => {
+                const target = fileActionTargetForId(ctx.snapshot, id);
+                if (target === null)
+                    throw new Error("That file is no longer in the tree. Select it again.");
+                return target.rootRelativePath;
+            }).sort();
+            const result = await actions.fileAction({
+                root: engine.root,
+                generation: engine.generation,
+                action,
+                paths,
+            });
+            if (!result.ok)
+                throw new Error(result.error);
+            if (action === "copyPath") {
+                onReceipt(paths.length === 1 ? "Path copied" : `${paths.length} paths copied`);
+            }
+            else {
+                onReceipt(platform === "darwin" ? "Revealed in Finder" : "Revealed in file manager");
+            }
+        }
+        catch (error) {
+            onReceipt(error instanceof Error ? error.message : "Could not complete the file action.");
+        }
+    }
+    const commands = createCommandRegistry([
+        {
+            id: "file.copyAbsolutePath",
+            label: "Copy Path",
+            keybinding: ["Mod+C", "Ctrl+C", "Cmd+C"],
+            group: "path",
+            order: 0,
+            enablement: hasSelection,
+            run: (ctx) => perform(ctx, "copyPath"),
+        },
+        {
+            id: "file.revealInFileManager",
+            label: () => environment().platform === "darwin"
+                ? "Open in Finder"
+                : "Open in File Manager",
+            group: "path",
+            order: 1,
+            enablement: (ctx) => hasSelection(ctx) && ctx.focusedId !== null && ctx.selectedIds.has(ctx.focusedId),
+            run: (ctx) => perform(ctx, "revealInFileManager"),
+        },
+        // Mille installs its mutating Paste command if this id is absent. Reserve
+        // it explicitly so it stays unavailable in menus and keyboard dispatch.
+        {
+            id: "file.paste",
+            label: "Paste",
+            visibleInContextMenu: false,
+            enablement: () => false,
+            run: () => { },
+        },
+    ]);
+    commands.setContextProvider(() => {
+        // Mille types its registry against the in-process engine; our port exposes
+        // the same snapshot methods used by these commands, as it does for the tree.
+        const fx = engine.fx;
+        const snapshot = fx.getSnapshot();
+        return {
+            fx,
+            snapshot,
+            focusedId,
+            focusedEntry: focusedId === null ? null : snapshot.getById(focusedId),
+            selectedIds,
+            selectedEntries: [...selectedIds].flatMap((id) => {
+                const entry = snapshot.getById(id);
+                return entry === null ? [] : [entry];
+            }),
+            isMultiSelect: selectedIds.size > 1,
+            isRenaming: false,
+            host: {},
+            cutIds: emptyIds,
+            copyIds: emptyIds,
+        };
+    });
+    return {
+        commands,
+        onSelectionChange: (ids) => {
+            selectedIds = ids;
+        },
+        onFocusedIdChange: (id) => {
+            focusedId = id;
+        },
+    };
+}

package/dist/components/worktree/worktree-file-source.d.ts

@@ -0,0 +1,15 @@
+import type { Entry } from "@vibecook/mille";
+import type { FileHandle, FileSource } from "../file-viewer/index.js";
+import type { WorktreeEngine } from "./types.js";
+/** Can this entry be opened as a file at all? */
+export declare function isOpenable(entry: Entry): boolean;
+/** What the viewer needs to know about an entry the reader just opened. */
+export declare function handleFor(engine: WorktreeEngine, entry: Entry): FileHandle;
+/**
+ * A `FileSource` backed by one engine.
+ *
+ * Memoize this per engine: `useFileContent` treats a new source as a new
+ * request, so a fresh object every render would re-read the open file every
+ * render.
+ */
+export declare function createWorktreeFileSource(engine: WorktreeEngine): FileSource;

package/dist/components/worktree/worktree-file-source.js

@@ -0,0 +1,75 @@
+// The adapter between the tree and the viewer: it is the ONLY file that knows
+// both what a mille engine is and what a `FileSource` is.
+//
+// Bytes come back over the port the tree is already using, which means the
+// renderer never opens a file itself. There is no `node:fs` here, no new IPC
+// channel, and no path handed to a privileged process to read — the request
+// is an entry id, and the engine will only answer for entries inside the root
+// it was forked against. The read is bounded by the same walk the tree is.
+/** `EntryKind.Directory`. A folder toggles; it does not open. */
+const DIRECTORY = 1;
+/** Deep enough for any real repository, shallow enough that a mirror that
+ * somehow cycles cannot hang the renderer. */
+const MAX_DEPTH = 64;
+/**
+ * The absolute path of an entry, walked up the mirror.
+ *
+ * `null` is a real answer: the mirror is viewport-bounded, so an ancestor can
+ * have been evicted, and the column would rather show no path than a wrong
+ * one. Nothing load-bearing depends on it — reading uses the id — so a null
+ * costs the reader the path line and the two acts that need a path.
+ */
+function pathOf(engine, id) {
+    const snapshot = engine.fx.getSnapshot();
+    const segments = [];
+    let current = snapshot.getById(id);
+    for (let depth = 0; depth < MAX_DEPTH; depth += 1) {
+        if (current === null)
+            return null;
+        // The root entry's own name is the folder the engine was pointed at, and
+        // `engine.root` already spells that out in full.
+        if (current.parentId === null) {
+            const root = engine.root.endsWith("/") ? engine.root.slice(0, -1) : engine.root;
+            return [root, ...segments.reverse()].join("/");
+        }
+        segments.push(current.name);
+        current = snapshot.getById(current.parentId);
+    }
+    return null;
+}
+/** Can this entry be opened as a file at all? */
+export function isOpenable(entry) {
+    return entry.kind !== DIRECTORY;
+}
+/** What the viewer needs to know about an entry the reader just opened. */
+export function handleFor(engine, entry) {
+    return {
+        // Scoped to the root, so the same id in a re-forked engine on a different
+        // project can never be mistaken for this one.
+        key: `${engine.root}#${entry.id}`,
+        name: entry.name,
+        path: pathOf(engine, entry.id),
+        size: entry.size,
+        ref: entry.id,
+    };
+}
+/**
+ * A `FileSource` backed by one engine.
+ *
+ * Memoize this per engine: `useFileContent` treats a new source as a new
+ * request, so a fresh object every render would re-read the open file every
+ * render.
+ */
+export function createWorktreeFileSource(engine) {
+    return {
+        async read(handle) {
+            const id = handle.ref;
+            if (typeof id !== "number")
+                throw new Error("that file is no longer in the tree");
+            // The port has no cancel for a read in flight; the caller drops the
+            // answer instead, which for a local file is the same thing a few
+            // milliseconds later.
+            return engine.fx.readFile(id);
+        },
+    };
+}

package/dist/components/worktree/worktree-host.d.ts

@@ -0,0 +1,31 @@
+import type { GitConnection } from "../git/git-host.js";
+import type { GitFacts } from "../../ports.js";
+import type { WorktreeEngine } from "./types.js";
+export interface WorktreeConnection {
+    readonly root: string;
+    readonly generation: number;
+    readonly engine: WorktreeEngine;
+    readonly git: GitConnection;
+    dispose(): void;
+}
+export type WorktreeConnectionState = {
+    readonly status: "idle";
+} | {
+    readonly status: "connecting";
+    readonly root: string;
+    readonly generation: number;
+} | {
+    readonly status: "ready";
+    readonly connection: WorktreeConnection;
+} | {
+    readonly status: "error";
+    readonly root: string;
+    readonly generation: number;
+    readonly message: string;
+};
+/** The current generation-safe, atomically paired tree + git connection, or
+ * idle for a host with no worktree engine. */
+export declare function useWorktreeConnection(): WorktreeConnectionState;
+/** Branch, dirty count and sibling worktrees for one exact connection
+ * generation. `null` until the first answer, and for a folder without git. */
+export declare function useGitFacts(root: string | null, generation: number | null): GitFacts | null;

package/dist/components/worktree/worktree-host.js

@@ -0,0 +1,242 @@
+// One transactional renderer connection for column ③. The host's worktree
+// port transfers the mille and git ports together with the root and engine
+// generation; this store publishes them together only after mille's async
+// handshake has completed. A late handshake can therefore never pair an old
+// tree with a new git client (or win after a newer project switch).
+import { useEffect, useState, useSyncExternalStore } from "react";
+import { connectFileExplorer } from "@vibecook/mille/port";
+import { connectGitClient } from "../git/git-host.js";
+import { useRoom } from "../../room-context.js";
+/**
+ * Fallback wire window before Mille's virtualizer publishes the rail's
+ * measured viewport. This is deliberately independent from the native
+ * directory page size: the host can keep walking while the renderer receives
+ * only the rows it can use.
+ */
+const PORT_PREFETCH_ROWS = 200;
+/**
+ * How much of the tree a port client caches before evicting cold entries.
+ * This is not a project or directory-size limit; wide folders rehydrate from
+ * the host as the viewport moves.
+ */
+const MIRROR_CAP = 20_000;
+/** How often the column re-reads branch and dirty count. Slow on purpose:
+ * these are ambient facts about a repository someone else is editing, and
+ * the room is a reader. */
+const GIT_FACTS_POLL_MS = 15_000;
+const IDLE = { status: "idle" };
+/** One store per worktree port, created on first read and listening from
+ * then on: the ports it is handed are one-owner capabilities, so it must not
+ * come and go with a component. */
+const stores = new WeakMap();
+function storeFor(port) {
+    let store = stores.get(port);
+    if (store === undefined) {
+        store = createWorktreeConnectionStore(port);
+        stores.set(port, store);
+    }
+    return store;
+}
+function createWorktreeConnectionStore(port) {
+    const storeListeners = new Set();
+    let storeState = IDLE;
+    let current = null;
+    let latestGeneration = 0;
+    let latestRoot = null;
+    let handshakeAttempt = 0;
+    let pendingHandshake = null;
+    function publish(next) {
+        storeState = next;
+        for (const listener of storeListeners)
+            listener();
+    }
+    function closePorts(message) {
+        message.treePort.close();
+        message.gitPort.close();
+    }
+    function disposeCurrent() {
+        const connection = current;
+        current = null;
+        connection?.dispose();
+    }
+    function cancelPendingHandshake() {
+        const pending = pendingHandshake;
+        pendingHandshake = null;
+        if (pending === null)
+            return;
+        pending.treePort.close();
+        pending.git.dispose();
+    }
+    function acceptStatus(message) {
+        if (message.generation < latestGeneration)
+            return;
+        if (message.generation === latestGeneration &&
+            latestRoot !== null &&
+            message.root !== latestRoot) {
+            return;
+        }
+        if (message.state === "starting" &&
+            ((storeState.status === "ready" &&
+                storeState.connection.generation === message.generation) ||
+                (storeState.status === "connecting" && storeState.generation === message.generation))) {
+            return;
+        }
+        latestGeneration = message.generation;
+        latestRoot = message.root;
+        handshakeAttempt += 1;
+        cancelPendingHandshake();
+        disposeCurrent();
+        if (message.state === "starting") {
+            publish({
+                status: "connecting",
+                root: message.root,
+                generation: message.generation,
+            });
+            return;
+        }
+        publish({
+            status: "error",
+            root: message.root,
+            generation: message.generation,
+            message: message.message ?? "The worktree process stopped unexpectedly.",
+        });
+    }
+    function acceptPorts(message) {
+        if (message.generation < latestGeneration) {
+            closePorts(message);
+            return;
+        }
+        if (message.generation === latestGeneration &&
+            latestRoot !== null &&
+            message.root !== latestRoot) {
+            closePorts(message);
+            return;
+        }
+        if (storeState.status === "ready" &&
+            storeState.connection.generation === message.generation) {
+            closePorts(message);
+            return;
+        }
+        if (storeState.status === "error" && storeState.generation === message.generation) {
+            closePorts(message);
+            return;
+        }
+        if (message.generation > latestGeneration) {
+            latestGeneration = message.generation;
+            latestRoot = message.root;
+            disposeCurrent();
+        }
+        publish({
+            status: "connecting",
+            root: message.root,
+            generation: message.generation,
+        });
+        cancelPendingHandshake();
+        const attempt = (handshakeAttempt += 1);
+        const git = connectGitClient(message.gitPort, message.root, message.generation);
+        pendingHandshake = { attempt, treePort: message.treePort, git };
+        void connectFileExplorer(message.treePort, {
+            prefetchRows: PORT_PREFETCH_ROWS,
+            mirrorCap: MIRROR_CAP,
+        })
+            .then((fx) => {
+            if (pendingHandshake?.attempt === attempt)
+                pendingHandshake = null;
+            if (attempt !== handshakeAttempt || message.generation !== latestGeneration) {
+                void fx.dispose();
+                git.dispose();
+                return;
+            }
+            let disposed = false;
+            const engine = {
+                fx,
+                root: message.root,
+                generation: message.generation,
+                dispose: () => void fx.dispose(),
+            };
+            const connection = {
+                root: message.root,
+                generation: message.generation,
+                engine,
+                git,
+                dispose: () => {
+                    if (disposed)
+                        return;
+                    disposed = true;
+                    engine.dispose();
+                    git.dispose();
+                },
+            };
+            disposeCurrent();
+            current = connection;
+            publish({ status: "ready", connection });
+        })
+            .catch((error) => {
+            if (pendingHandshake?.attempt === attempt)
+                pendingHandshake = null;
+            git.dispose();
+            message.treePort.close();
+            if (attempt !== handshakeAttempt || message.generation !== latestGeneration)
+                return;
+            publish({
+                status: "error",
+                root: message.root,
+                generation: message.generation,
+                message: error instanceof Error ? error.message : "Could not connect to the worktree.",
+            });
+        });
+    }
+    port.ports((event) => {
+        if (event.type === "ports")
+            acceptPorts(event);
+        else
+            acceptStatus(event);
+    });
+    return {
+        subscribe(listener) {
+            storeListeners.add(listener);
+            return () => storeListeners.delete(listener);
+        },
+        getSnapshot: () => storeState,
+    };
+}
+const IDLE_STORE = { subscribe: () => () => { }, getSnapshot: () => IDLE };
+/** The current generation-safe, atomically paired tree + git connection, or
+ * idle for a host with no worktree engine. */
+export function useWorktreeConnection() {
+    const worktree = useRoom().host?.worktree;
+    const store = worktree === undefined ? IDLE_STORE : storeFor(worktree);
+    return useSyncExternalStore(store.subscribe, store.getSnapshot, store.getSnapshot);
+}
+/** Branch, dirty count and sibling worktrees for one exact connection
+ * generation. `null` until the first answer, and for a folder without git. */
+export function useGitFacts(root, generation) {
+    const [facts, setFacts] = useState(null);
+    const worktree = useRoom().host?.worktree ?? null;
+    useEffect(() => {
+        setFacts(null);
+        const host = worktree;
+        if (root === null || generation === null || host === null)
+            return;
+        let cancelled = false;
+        const read = () => {
+            void host
+                .gitFacts(root, generation)
+                .then((next) => {
+                if (!cancelled)
+                    setFacts(next);
+            })
+                .catch(() => {
+                if (!cancelled)
+                    setFacts(null);
+            });
+        };
+        read();
+        const timer = window.setInterval(read, GIT_FACTS_POLL_MS);
+        return () => {
+            cancelled = true;
+            window.clearInterval(timer);
+        };
+    }, [root, generation, worktree]);
+    return facts;
+}

package/dist/fixtures/index.d.ts

@@ -0,0 +1,24 @@
+import type { MetaState, TimelineEntry, UsageResponse } from "@vibefield/rosetta-protocol";
+import type { AssetSource, CatalogStatus, RoomPorts } from "../ports.js";
+import type { ActivityOrder } from "../lib/activity-order.js";
+import type { ProjectStats, ProjectViewModel } from "../lib/model.js";
+/** Everything the demo room shows. */
+export interface RoomDemo {
+    readonly now: number;
+    readonly meta: MetaState;
+    readonly status: CatalogStatus;
+    readonly stats: ReadonlyMap<string, ProjectStats>;
+    readonly usage: ReadonlyMap<string, UsageResponse>;
+    readonly timelines: ReadonlyMap<string, readonly TimelineEntry[]>;
+}
+export declare function createRoomDemo(now?: number): RoomDemo;
+/** The demo's addresses: every stored image is a drawn tile, inline. */
+export declare function demoAssets(): AssetSource;
+/** Ports over the demo: a catalog, sessions and asset addresses. No host —
+ * a host that is a desktop adds its own `HostPort`. */
+export declare function createDemoPorts(demo?: RoomDemo): RoomPorts;
+/** The demo's projects as the room's columns draw them, for a harness that
+ * mounts a column on its own. */
+export declare function demoProjectViewModels(demo?: RoomDemo): ProjectViewModel[];
+/** The order the projects and sessions column would settle on for the demo. */
+export declare function demoActivityOrder(demo?: RoomDemo): ActivityOrder;