@vibefield/rosetta-room 0.0.0-stage → 0.1.1

package/dist/lib/format.js

@@ -0,0 +1,116 @@
+// Numbers and time, per the design record §4: three significant figures with
+// digits and unit in separate slots; every number that can change is tabular.
+const COMPACT_UNITS = ["", "K", "M", "B", "T"];
+/** Shared count/token/currency scale. Round before choosing precision and
+ * promote a rounded 1,000 into the next unit (999,500 → 1.00M). */
+export function fmtCompactNumber(value) {
+    if (!Number.isFinite(value))
+        return { n: "—", u: "" };
+    const magnitude = Math.abs(value);
+    if (magnitude < 999.5)
+        return { n: String(value), u: "" };
+    // Round in the original unit so decimal ties such as 9,995 do not become
+    // 9.99K through the binary representation of a scaled 9.995.
+    const precision = 10 ** (Math.floor(Math.log10(magnitude)) - 2);
+    let scaled = Math.round(magnitude / precision) * precision;
+    let unit = 0;
+    while (scaled >= 1e3 && unit < COMPACT_UNITS.length - 1) {
+        scaled /= 1e3;
+        unit += 1;
+    }
+    const decimals = Math.max(0, 2 - Math.floor(Math.log10(scaled)));
+    return { n: (Math.sign(value) * scaled).toFixed(decimals), u: COMPACT_UNITS[unit] };
+}
+export function fmtTokens(n) {
+    return fmtCompactNumber(n);
+}
+export function tokenText(n) {
+    const t = fmtTokens(n);
+    return t.n + t.u;
+}
+/** `now` under 90s, then minutes, hours, `yesterday`, days. */
+export function lastActive(ms, nowMs) {
+    if (ms === null || !Number.isFinite(ms))
+        return "unknown";
+    const delta = nowMs - ms;
+    if (delta < 0)
+        return "future";
+    if (delta < 90_000)
+        return "now";
+    const minutes = Math.floor(delta / 60_000);
+    if (minutes < 60)
+        return `${minutes}m`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24)
+        return `${hours}h`;
+    const days = Math.floor(hours / 24);
+    if (days === 1)
+        return "yesterday";
+    return `${days}d`;
+}
+export function duration(fromMs, toMs) {
+    const mins = Math.max(0, Math.round((toMs - fromMs) / 60_000));
+    if (mins < 60)
+        return `${mins}m`;
+    const h = Math.floor(mins / 60);
+    if (h < 48)
+        return `${h}h ${String(mins % 60).padStart(2, "0")}m`;
+    return `${Math.floor(h / 24)}d ${h % 24}h`;
+}
+export function clock(ms) {
+    const d = new Date(ms);
+    const p = (v) => String(v).padStart(2, "0");
+    return `${p(d.getHours())}:${p(d.getMinutes())}:${p(d.getSeconds())}`;
+}
+export function clockShort(ms) {
+    const d = new Date(ms);
+    const p = (v) => String(v).padStart(2, "0");
+    return `${p(d.getHours())}:${p(d.getMinutes())}`;
+}
+function startOfDay(ms) {
+    const d = new Date(ms);
+    d.setHours(0, 0, 0, 0);
+    return d.getTime();
+}
+/** `Today`, `Yesterday`, then `Mon 24 Aug` — the session list's day breaks. */
+export function dayLabel(ms, nowMs) {
+    if (ms === null || !Number.isFinite(ms))
+        return "Activity unknown";
+    const today = startOfDay(nowMs);
+    const day = startOfDay(ms);
+    if (day === today)
+        return "Today";
+    const yesterday = new Date(today);
+    yesterday.setDate(yesterday.getDate() - 1);
+    if (day === yesterday.getTime())
+        return "Yesterday";
+    const d = new Date(ms);
+    return d.toLocaleDateString("en-GB", { weekday: "short", day: "numeric", month: "short" });
+}
+/** Home-relative form of a path, the way the ledger row prints one. The
+ * home is a folder, so only the home itself and what is under it shorten:
+ * `/Users/ab` is not under `/Users/a`. A root home shortens nothing. */
+export function tildePath(path, home) {
+    const root = home?.replace(/\/+$/, "") ?? "";
+    if (root === "")
+        return path;
+    if (path === root)
+        return "~";
+    if (path.startsWith(`${root}/`))
+        return `~${path.slice(root.length)}`;
+    return path;
+}
+/** A file size, at three significant figures — the ledger's rule for a
+ * figure, applied to bytes. `812 B` · `4.20 KB` · `1.3 MB` · `212 MB`. */
+export function fmtBytes(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    const units = ["KB", "MB", "GB", "TB"];
+    let value = bytes / 1024;
+    let unit = 0;
+    while (value >= 1024 && unit < units.length - 1) {
+        value /= 1024;
+        unit += 1;
+    }
+    return `${value.toFixed(value >= 100 ? 0 : value >= 10 ? 1 : 2)} ${units[unit]}`;
+}

package/dist/lib/hooks.d.ts

@@ -0,0 +1,118 @@
+import type { ApiError, IngestProgress, MetaState, SearchReadiness, SearchBuildProgress, SearchResponse, ResponseRuntime, SubscriptionStatus, TimelineEntry, TimelineMeta, UsageResponse } from "@vibefield/rosetta-protocol";
+import type { ProjectStats } from "./model.js";
+import type { CatalogPort } from "../ports.js";
+import type { SessionLeases } from "./session-leases.js";
+import type { EarlierLanding, EarlierNotice, EarlierState } from "./transcript/head-state.js";
+export interface MetaFeed {
+    meta: MetaState | null;
+    /** Advances even if React batches a replacement and its first live mutation. */
+    snapshotVersion: number;
+    status: SubscriptionStatus;
+    error: ApiError | null;
+}
+export declare function useMeta(catalog: CatalogPort): MetaFeed;
+export interface DaemonStatusFeed {
+    /** A connection or startup failure suitable for the disconnected state. */
+    readonly connectionError: string | null;
+    /** The exact durable-publication gate for global derived reads. */
+    readonly canonicalReady: boolean | null;
+    /** Last observed readiness; null until the first successful answer. */
+    readonly searchReadiness: SearchReadiness | null;
+    /** The cold-start block; null on a daemon too old to carry it. */
+    readonly ingest: IngestProgress | null;
+    readonly searchProgress: SearchBuildProgress | null;
+    readonly startedAt: number | null;
+    readonly uptimeMs: number;
+    readonly receivedAt: number | null;
+}
+/** The daemon's status surface. It answers from the daemon's first breath —
+ * before the projection is even readable — so it is the room's connectivity
+ * truth during a cold start. Polls fast through canonical publication and
+ * search preparation, then quietly once both are ready. */
+export declare function useDaemonStatus(catalog: CatalogPort): DaemonStatusFeed;
+/** Per-project heatmaps and contributions. These are global derived reads,
+ * so they begin only after the daemon's canonical publication gate. Four
+ * workers hydrate the list progressively; unbounded Promise.all here once
+ * launched two full-corpus queries per project and starved cold ingestion. */
+export declare function useProjectStats(catalog: CatalogPort, projectIds: string[], ready?: boolean): Map<string, ProjectStats>;
+/** The selected project's usage decomposition — per-model days and the
+ * hour-of-day profile, over the same 53-week window the heatmap draws. */
+export declare function useProjectUsage(catalog: CatalogPort, projectId: string | null, ready?: boolean): UsageResponse | null;
+export interface TimelineFeed {
+    /** Ordinal-ordered rows: paged history + the live tail, deduplicated. */
+    rows: TimelineEntry[];
+    /** The subscription has delivered its first authoritative snapshot. A live
+     * status can arrive one frame earlier, so consumers must not infer an empty
+     * transcript until this is true. */
+    snapshotReady: boolean;
+    /** Initial read failures stay distinct from an authoritative empty snapshot. */
+    error: string | null;
+    retry: () => void;
+    /** Complete task/workflow/plan/artifact index delivered beside the tail snapshot. */
+    timelineMeta: TimelineMeta | null;
+    status: SubscriptionStatus;
+    /** Rows with ordinal > watermark arrived after you did (D33's line). */
+    watermark: number | null;
+    /** §08 — what the head of the document offers the reader right now. */
+    earlier: EarlierState;
+    /** The 410 sentence, surfaced once after the paged history is dropped. */
+    earlierNotice: EarlierNotice | null;
+    /** Rows still above the loaded document, or null when no total is known. */
+    earlierAbove: number | null;
+    /** The last landing — the receipt's figure and the scroll fix-up's key. */
+    landed: EarlierLanding | null;
+    /** Fetch the page above and keep it aside. No-op unless idle or failed. */
+    holdEarlier: () => void;
+    /** Spend the bar: prepend a held page now, or land the fetch on arrival. */
+    revealEarlier: () => void;
+    /** Try again after `earlier.kind === "failed"`. */
+    retryEarlier: () => void;
+    /** Drop the 410 sentence once it has been read. */
+    dismissEarlierNotice: () => void;
+    /** @deprecated §08 replaced the load-earlier button with the head line.
+     *  Read `earlier.kind !== "none"` instead. */
+    canLoadEarlier: boolean;
+    /** @deprecated §08 fetches on approach and inserts on the pull. This fetches
+     *  AND inserts in one act, for the anchor search that still pages blindly.
+     *  Use `holdEarlier()` then `revealEarlier()`. */
+    loadEarlier: () => void;
+    /** Load one exact canonical row without walking intervening history pages. */
+    loadAnchor: (timelineId: string) => Promise<boolean>;
+}
+export declare function useTimeline(sessions: SessionLeases, sessionId: string | null): TimelineFeed;
+export interface TeamTimelineFeed {
+    /** Complete boundary histories for the known team members. Private work is
+     * fetched separately when its report disclosure opens. */
+    readonly rowsBySession: ReadonlyMap<string, readonly TimelineEntry[]>;
+    /** Content-free response model/effort observations across full history. */
+    readonly responseRuntimesBySession: ReadonlyMap<string, readonly ResponseRuntime[]>;
+    /** True only after every current member's complete boundary query succeeds. */
+    readonly historyReady: boolean;
+    readonly historyError: string | null;
+    readonly retry: () => void;
+}
+/** Team conversation is distributed across member transcripts, so one parent
+ * document owns a small subscription set. Unlike ordinary Agent subthreads it
+ * is eager: delivered boundary messages belong in shared chronology even when
+ * no disclosure is open. */
+export declare function useTeamTimelines(sessions: SessionLeases, sessionIds: readonly string[]): TeamTimelineFeed;
+export interface SearchFeed {
+    query: string;
+    response: SearchResponse | null;
+    error: string | null;
+    searching: boolean;
+}
+/** The structured side of a search: each maps onto one API selector. */
+export interface SearchFacets {
+    readonly project?: string | null;
+    readonly kind?: string | null;
+    readonly agent?: string | null;
+}
+export declare const SEARCH_LIMIT = 200;
+/**
+ * One ranked search per settled query. The previous response stays on screen
+ * while its successor is in flight — a list that blanks on every keystroke
+ * reads as a search that keeps failing — and only the newest request may
+ * land: a superseded one is aborted and its late result ignored.
+ */
+export declare function useSearch(catalog: CatalogPort, query: string, facets?: SearchFacets): SearchFeed;