@sealant/mend 0.14.0 → 0.15.2

package/dist/dashboard-model.js

@@ -0,0 +1,297 @@
+import { HARNESS_COMMANDS, LIVE_STATUSES } from "./shared.js";
+/**
+ * The worktree IS the session's identity (one worktree per session): its
+ * branch, with the noisy default prefix receded. What you are working on
+ * leads every row; the harness is a fact about it, not its name.
+ */
+export const worktreeName = (branch) => branch.startsWith("mend/") ? branch.slice("mend/".length) : branch;
+/**
+ * What to call an UNNAMED worktree: its branch is `mend/session/<uuid>` —
+ * noise nobody recognizes — so the auto-name label stands in, and before one
+ * lands, the short session id. A named worktree is always its own name.
+ */
+export const worktreeDisplayName = (session) => {
+    const name = worktreeName(session.branch);
+    if (!name.startsWith("session/"))
+        return name;
+    return session.label ?? `session ${session.id.slice(0, 8)}`;
+};
+/** True when the label already IS the row's identity — don't repeat it. */
+export const labelIsIdentity = (session) => worktreeName(session.branch).startsWith("session/") && session.label !== null;
+export const WORKBENCH_KEY = ["workbench"];
+export const fetchWorkbench = async (ctx) => {
+    const projects = await ctx.api("GET", "/projects");
+    const [fetched, services] = await Promise.all([
+        Promise.all(projects.map((project) => ctx.api("GET", `/projects/${project.id}`))),
+        ctx.api("GET", "/services"),
+    ]);
+    const servicesBySession = new Map();
+    for (const service of services) {
+        const bucket = servicesBySession.get(service.sessionId) ?? [];
+        bucket.push(service);
+        servicesBySession.set(service.sessionId, bucket);
+    }
+    // What lives in each LIVE worktree: the agent and shells come from the
+    // session detail (settled sessions have nothing live — no fetch for them).
+    const liveSessions = fetched.flatMap((detail) => detail.sessions.filter((session) => LIVE_STATUSES.has(session.status)));
+    const detailed = await Promise.all(liveSessions.map(async (session) => {
+        try {
+            return await ctx.api("GET", `/sessions/${session.id}`);
+        }
+        catch {
+            return null;
+        }
+    }));
+    const processesBySession = new Map();
+    for (const detail of detailed) {
+        if (detail === null)
+            continue;
+        processesBySession.set(detail.session.id, detail.processes.filter((process) => process.exitedAt === null && process.kind !== "service"));
+    }
+    return {
+        projects,
+        details: new Map(fetched.map((detail) => [detail.project.id, detail])),
+        servicesBySession,
+        processesBySession,
+    };
+};
+// ─── optimistic cache surgery: pure Workbench → Workbench ───────────────────
+/** Apply `f` to every session row in every project detail. */
+export const mapWorkbenchSessions = (data, f) => ({
+    ...data,
+    details: new Map([...data.details].map(([id, detail]) => [id, { ...detail, sessions: detail.sessions.map(f) }])),
+});
+export const mapProjectSessions = (data, projectId, f) => {
+    const detail = data.details.get(projectId);
+    if (detail === undefined)
+        return data;
+    const details = new Map(data.details);
+    details.set(projectId, { ...detail, sessions: f(detail.sessions) });
+    return { ...data, details };
+};
+export const prependSession = (data, projectId, session) => mapProjectSessions(data, projectId, (sessions) => [session, ...sessions]);
+export const replaceSession = (data, projectId, oldId, session) => mapProjectSessions(data, projectId, (sessions) => sessions.map((candidate) => (candidate.id === oldId ? session : candidate)));
+export const removeSession = (data, projectId, sessionId) => mapProjectSessions(data, projectId, (sessions) => sessions.filter((candidate) => candidate.id !== sessionId));
+export const deriveProjects = (data) => (data?.projects ?? []).map((project) => {
+    const detail = data?.details.get(project.id);
+    const sessions = detail?.sessions ?? [];
+    const live = sessions.filter((s) => LIVE_STATUSES.has(s.status)).length;
+    const open = (detail?.annotations ?? []).reduce((sum, a) => sum + a.openComments, 0);
+    return { project, total: sessions.length, live, open };
+});
+export const bySessionRecency = (a, b) => {
+    const aLive = LIVE_STATUSES.has(a.status) ? 1 : 0;
+    const bLive = LIVE_STATUSES.has(b.status) ? 1 : 0;
+    if (aLive !== bLive)
+        return bLive - aLive;
+    return b.createdAt.localeCompare(a.createdAt);
+};
+export const toSessionItem = (data, detail) => (session) => ({
+    session,
+    annotation: detail.annotations.find((a) => a.sessionId === session.id),
+    services: data.servicesBySession.get(session.id) ?? [],
+    processes: data.processesBySession.get(session.id) ?? [],
+});
+export const deriveWorktrees = (data, projectId) => {
+    if (data === undefined || projectId === null)
+        return [];
+    const detail = data.details.get(projectId);
+    if (detail === undefined)
+        return [];
+    const item = toSessionItem(data, detail);
+    const sorted = detail.sessions.toSorted(bySessionRecency);
+    const groups = [];
+    if (detail.worktrees !== undefined) {
+        const claimed = new Set();
+        for (const worktree of detail.worktrees) {
+            const members = sorted.filter((session) => session.worktreeId === worktree.id);
+            for (const member of members)
+                claimed.add(member.id);
+            groups.push({
+                key: worktree.id,
+                id: worktree.id,
+                name: worktree.name.startsWith("wt-")
+                    ? (members.find((m) => m.label !== null)?.label ??
+                        (members[0] === undefined ? worktree.name : `session ${members[0].id.slice(0, 8)}`))
+                    : worktree.name,
+                branch: worktree.branch,
+                baseRef: worktree.baseRef,
+                createdAt: worktree.createdAt,
+                sessions: members.map(item),
+                live: members.filter((session) => LIVE_STATUSES.has(session.status)).length,
+                annotation: detail.annotations.find((a) => members.some((m) => m.id === a.sessionId)),
+            });
+        }
+        // Optimistic pending rows have no worktree yet — each is its own group.
+        for (const session of sorted) {
+            if (claimed.has(session.id))
+                continue;
+            groups.push(pseudoGroup(session, item));
+        }
+    }
+    else {
+        for (const session of sorted)
+            groups.push(pseudoGroup(session, item));
+    }
+    return groups.toSorted((a, b) => {
+        if (a.live > 0 !== b.live > 0)
+            return a.live > 0 ? -1 : 1;
+        const aNewest = a.sessions[0]?.session.createdAt ?? a.createdAt;
+        const bNewest = b.sessions[0]?.session.createdAt ?? b.createdAt;
+        return bNewest.localeCompare(aNewest);
+    });
+};
+export const pseudoGroup = (session, item) => ({
+    key: session.id,
+    id: null,
+    name: worktreeDisplayName(session),
+    branch: session.branch,
+    baseRef: session.baseRef,
+    createdAt: session.createdAt,
+    sessions: [item(session)],
+    live: LIVE_STATUSES.has(session.status) ? 1 : 0,
+    annotation: item(session).annotation,
+});
+export const deriveRows = (groups) => groups.flatMap((group) => {
+    const only = group.sessions.length === 1 ? group.sessions[0] : undefined;
+    if (only !== undefined)
+        return [{ kind: "session", group, item: only }];
+    return [
+        { kind: "worktree", group },
+        ...group.sessions.map((item) => ({ kind: "session", group, item })),
+    ];
+});
+export const rowKeyOf = (row) => row.kind === "worktree" ? `wt:${row.group.key}` : `s:${row.item.session.id}`;
+/** The picker's rows: resume offers the same harness first, then the crossings. */
+export const deriveHarnesses = (resuming) => {
+    if (resuming !== null) {
+        const others = Object.keys(HARNESS_COMMANDS).filter((h) => h !== resuming.harness);
+        return [
+            {
+                harness: null,
+                label: resuming.harness,
+                hint: "same harness — native resume, conversation intact",
+            },
+            ...others.map((harness) => ({
+                harness,
+                label: harness,
+                hint: harness === "shell"
+                    ? "a bash in the worktree — resume either agent from inside"
+                    : "the conversation crosses as a distilled prompt",
+            })),
+        ];
+    }
+    return Object.keys(HARNESS_COMMANDS).map((harness) => ({
+        harness,
+        label: harness,
+        hint: harness === "shell"
+            ? "a plain bash session — new worktree, recorded"
+            : `mend ${harness} — new worktree, recorded session`,
+    }));
+};
+/** The worktree's folded status word: waiting wins, then running, then idle. */
+export const foldGroupStatus = (group) => {
+    const statuses = group.sessions.map((item) => item.session.status);
+    if (statuses.includes("waiting"))
+        return "waiting";
+    if (statuses.includes("running") || statuses.includes("starting"))
+        return "running";
+    if (statuses.includes("idle"))
+        return "idle";
+    return statuses[0] ?? "idle";
+};
+// ─── attach + verb helpers ──────────────────────────────────────────────────
+/**
+ * Where "get me in" should land when the session has no live agent terminal:
+ * the newest LIVE shell, so repeated attaches rejoin the same one instead of
+ * stacking a fresh bash per attempt (the five-orphan-shells failure mode).
+ * Null = nothing attachable; opening a new shell is then honest.
+ */
+export const liveShellOf = (processes) => processes.findLast((process) => process.kind === "shell" && process.exitedAt === null) ?? null;
+/**
+ * The optimistic stop: the row settles AND its live process/service fact
+ * lines drop in the same paint — the server's refetch only confirms.
+ */
+export const markSessionStopped = (data, sessionId) => {
+    const processesBySession = new Map(data.processesBySession);
+    processesBySession.delete(sessionId);
+    const servicesBySession = new Map(data.servicesBySession);
+    servicesBySession.delete(sessionId);
+    return {
+        ...mapWorkbenchSessions(data, (session) => session.id === sessionId ? { ...session, status: "stopped" } : session),
+        processesBySession,
+        servicesBySession,
+    };
+};
+/** The optimistic removal: the whole group leaves the list before the server answers. */
+export const removeWorktreeGroup = (data, projectId, group) => {
+    const memberIds = new Set(group.sessions.map((item) => item.session.id));
+    const detail = data.details.get(projectId);
+    if (detail === undefined)
+        return data;
+    const details = new Map(data.details);
+    details.set(projectId, {
+        ...detail,
+        sessions: detail.sessions.filter((session) => !memberIds.has(session.id)),
+        ...(detail.worktrees === undefined
+            ? {}
+            : { worktrees: detail.worktrees.filter((worktree) => worktree.id !== group.id) }),
+    });
+    return { ...data, details };
+};
+/**
+ * Subsequence fuzzy score, fzf-flavored: every query character must appear in
+ * order; consecutive hits and segment starts (after `/`, `-`, `_`, `.`) score
+ * higher; earlier matches beat later ones. Null = no match. Case-insensitive.
+ */
+export const fuzzyScore = (query, candidate) => {
+    if (query === "")
+        return 0;
+    const q = query.toLowerCase();
+    const c = candidate.toLowerCase();
+    let score = 0;
+    let last = -1;
+    for (const char of q) {
+        const at = c.indexOf(char, last + 1);
+        if (at === -1)
+            return null;
+        if (at === last + 1)
+            score += 3;
+        else if (at === 0 || "/-_.".includes(c[at - 1] ?? ""))
+            score += 2;
+        else
+            score += 1;
+        score -= (at - last - 1) * 0.01;
+        last = at;
+    }
+    return score;
+};
+/**
+ * The picker's rows for one query: fuzzy-filtered, best score first, ties by
+ * most recent commit; an empty query lists everything, default branch on top.
+ */
+export const filterBranches = (branches, query) => {
+    const scored = branches.flatMap((branch) => {
+        const score = fuzzyScore(query, branch.name);
+        return score === null ? [] : [{ branch, score }];
+    });
+    return scored
+        .toSorted((a, b) => {
+        if (query === "" && a.branch.isDefault !== b.branch.isDefault) {
+            return a.branch.isDefault ? -1 : 1;
+        }
+        if (a.score !== b.score)
+            return b.score - a.score;
+        return b.branch.committedAt.localeCompare(a.branch.committedAt);
+    })
+        .map((entry) => entry.branch);
+};
+/** Commit the base step: the highlighted branch (default branch = null base). */
+export const advanceFromBase = (current) => {
+    const chosen = filterBranches(current.branches ?? [], current.query)[current.baseIndex];
+    return {
+        ...current,
+        base: chosen === undefined || chosen.isDefault ? null : chosen.name,
+        step: "harness",
+    };
+};